r2671: we're getting too many errors caused by the talloc_realloc() API not
[bbaumbach/samba-autobuild/.git] / source4 / lib / socket / socket_ipv4.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Socket IPv4 functions
4    Copyright (C) Stefan Metzmacher 2004
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 static NTSTATUS ipv4_tcp_init(struct socket_context *sock)
24 {
25         sock->fd = socket(PF_INET, SOCK_STREAM, 0);
26         if (sock->fd == -1) {
27                 /* TODO: we need to map from errno to NTSTATUS here! */ 
28                 return NT_STATUS_FOOBAR;
29         }
30
31         return NT_STATUS_OK;
32 }
33
34 static void ipv4_tcp_close(struct socket_context *sock)
35 {
36         close(sock->fd);
37 }
38
39 static NTSTATUS ipv4_tcp_connect(struct socket_context *sock,
40                                         const char *my_address, int my_port,
41                                         const char *srv_address, int srv_port,
42                                         uint32_t flags)
43 {
44         struct sockaddr_in my_addr;
45         struct sockaddr_in srv_addr;
46         struct in_addr my_ip;
47         struct in_addr srv_ip;
48         int ret;
49
50         ret = inet_aton(my_address, &my_ip);
51         if (ret == 0) {
52                 /* not a valid ipv4 address */
53                 return NT_STATUS_FOOBAR;
54         }
55
56         ZERO_STRUCT(my_addr);
57 #ifdef HAVE_SOCK_SIN_LEN
58         my_addr.sin_len         = sizeof(my_addr);
59 #endif
60         my_addr.sin_addr        = my_ip;
61         my_addr.sin_port        = htons(my_port);
62         my_addr.sin_family      = PF_INET;
63
64         ret = inet_aton(srv_address, &srv_ip);
65         if (ret == 0) {
66                 /* not a valid ipv4 address */
67                 return NT_STATUS_FOOBAR;
68         }
69
70         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
71         if (ret == -1) {
72                 /* TODO: we need to map from errno to NTSTATUS here! */
73                 return NT_STATUS_FOOBAR;
74         }
75
76         ZERO_STRUCT(srv_addr);
77 #ifdef HAVE_SOCK_SIN_LEN
78         srv_addr.sin_len        = sizeof(srv_addr);
79 #endif
80         srv_addr.sin_addr       = srv_ip;
81         srv_addr.sin_port       = htons(srv_port);
82         srv_addr.sin_family     = PF_INET;
83
84         if (!(flags & SOCKET_FLAG_BLOCK)) {
85                 ret = set_blocking(sock->fd, False);
86                 if (ret == -1) {
87                         /* TODO: we need to map from errno to NTSTATUS here! */
88                         return NT_STATUS_FOOBAR;
89                 }
90         }
91
92         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
93         if (ret == -1) {
94                 /* TODO: we need to map from errno to NTSTATUS here! */
95                 return NT_STATUS_FOOBAR;
96         }
97
98         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
99
100         return NT_STATUS_OK;
101 }
102
103 static NTSTATUS ipv4_tcp_listen(struct socket_context *sock,
104                                         const char *my_address, int port,
105                                         int queue_size, uint32_t flags)
106 {
107         struct sockaddr_in my_addr;
108         struct in_addr ip_addr;
109         int ret;
110
111         ret = inet_aton(my_address, &ip_addr);
112         if (ret == 0) {
113                 /* not a valid ipv4 address */
114                 return NT_STATUS_FOOBAR;
115         }
116
117         ZERO_STRUCT(my_addr);
118 #ifdef HAVE_SOCK_SIN_LEN
119         my_addr.sin_len         = sizeof(my_addr);
120 #endif
121         my_addr.sin_addr        = ip_addr;
122         my_addr.sin_port        = htons(port);
123         my_addr.sin_family      = PF_INET;
124
125         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
126         if (ret == -1) {
127                 /* TODO: we need to map from errno to NTSTATUS here! */
128                 return NT_STATUS_FOOBAR;
129         }
130
131         ret = listen(sock->fd, queue_size);
132         if (ret == -1) {
133                 /* TODO: we need to map from errno to NTSTATUS here! */
134                 return NT_STATUS_FOOBAR;
135         }
136
137         if (!(flags & SOCKET_FLAG_BLOCK)) {
138                 ret = set_blocking(sock->fd, False);
139                 if (ret == -1) {
140                         /* TODO: we need to map from errno to NTSTATUS here! */
141                         return NT_STATUS_FOOBAR;
142                 }
143         }
144
145         sock->state= SOCKET_STATE_SERVER_LISTEN;
146
147         return NT_STATUS_OK;
148 }
149
150 static NTSTATUS ipv4_tcp_accept(struct socket_context *sock, struct socket_context **new_sock, uint32_t flags)
151 {
152         struct sockaddr_in cli_addr;
153         socklen_t cli_addr_len = 0;
154         int new_fd;
155
156         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
157         if (new_fd == -1) {
158                 /* TODO: we need to map from errno to NTSTATUS here! */
159                 return NT_STATUS_FOOBAR;
160         }
161
162         /* TODO: we could add a 'accept_check' hook here
163          *       which get the black/white lists via socket_set_accept_filter()
164          *       or something like that
165          *       --metze
166          */
167
168         (*new_sock) = talloc_p(NULL, struct socket_context);
169         if (!(*new_sock)) {
170                 return NT_STATUS_NO_MEMORY;
171         }
172
173         /* copy the socket_context */
174         (*new_sock)->type               = sock->type;
175         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
176         (*new_sock)->flags              = flags;
177
178         (*new_sock)->fd                 = new_fd;
179
180         (*new_sock)->private_data       = NULL;
181         (*new_sock)->ops                = sock->ops;
182
183         return NT_STATUS_OK;
184 }
185
186 static NTSTATUS ipv4_tcp_recv(struct socket_context *sock, TALLOC_CTX *mem_ctx,
187                               DATA_BLOB *blob, size_t wantlen, uint32_t flags)
188 {
189         ssize_t gotlen;
190         void *buf;
191         int flgs = 0;
192
193         buf = talloc(mem_ctx, wantlen);
194         if (!buf) {
195                 return NT_STATUS_NO_MEMORY;
196         }
197
198         /* TODO: we need to map all flags here */
199         if (flags & SOCKET_FLAG_PEEK) {
200                 flgs |= MSG_PEEK;
201         }
202
203         if (!(flags & SOCKET_FLAG_BLOCK)) {
204                 flgs |= MSG_DONTWAIT;
205         }
206
207         if (flags & SOCKET_FLAG_BLOCK) {
208                 flgs |= MSG_WAITALL;
209         }
210
211         gotlen = recv(sock->fd, buf, wantlen, flgs);
212         if (gotlen == 0) {
213                 talloc_free(buf);
214                 return NT_STATUS_END_OF_FILE;
215         } else if (gotlen == -1) {
216                 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
217                 switch (errno) {
218                         case EBADF:
219                         case ENOTCONN:
220                         case ENOTSOCK:
221                         case EFAULT:
222                         case EINVAL:
223                                 status = NT_STATUS_INVALID_PARAMETER;
224                                 break;
225                         case EAGAIN:
226                         case EINTR:
227                                 status = STATUS_MORE_ENTRIES;
228                                 break;
229                         case ECONNREFUSED:
230                                 status = NT_STATUS_CONNECTION_REFUSED;
231                                 break;
232                 }
233                 talloc_free(buf);
234                 return status;
235         }
236
237         blob->length = gotlen;
238         blob->data = talloc_realloc(mem_ctx, buf, gotlen);
239         if (!blob->data) {
240                 return NT_STATUS_NO_MEMORY;
241         }
242
243         return NT_STATUS_OK;
244 }
245
246 static NTSTATUS ipv4_tcp_send(struct socket_context *sock, TALLOC_CTX *mem_ctx,
247                                         const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
248 {
249         ssize_t len;
250         int flgs = 0;
251
252         /* TODO: we need to map all flags here */
253         if (!(flags & SOCKET_FLAG_BLOCK)) {
254                 flgs |= MSG_DONTWAIT;
255         }
256
257         len = send(sock->fd, blob->data, blob->length, flgs);
258         if (len == -1) {
259                 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
260                 switch (errno) {
261                         case EBADF:
262                         case ENOTSOCK:
263                         case EFAULT:
264                         case EINVAL:
265                                 status = NT_STATUS_INVALID_PARAMETER;
266                                 break;
267                         case EMSGSIZE:
268                                 status = NT_STATUS_INVALID_BUFFER_SIZE;
269                                 break;
270                         case EAGAIN:
271                         /*case EWOULDBLOCK: this is an alis of EAGAIN --metze */
272                         case EINTR:
273                                 *sendlen = 0;
274                                 status = STATUS_MORE_ENTRIES;
275                                 break;
276                         case ENOBUFS:
277                                 status = NT_STATUS_FOOBAR;
278                                 break;
279                         case ENOMEM:
280                                 status = NT_STATUS_NO_MEMORY;
281                                 break;
282                         case EPIPE:
283                                 status = NT_STATUS_CONNECTION_DISCONNECTED;
284                                 break;
285                 }
286                 return status;
287         }       
288
289         *sendlen = len;
290
291         return NT_STATUS_OK;
292 }
293
294 static NTSTATUS ipv4_tcp_set_option(struct socket_context *sock, const char *option, const char *val)
295 {
296         set_socket_options(sock->fd, option);
297         return NT_STATUS_OK;
298 }
299
300 static char *ipv4_tcp_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
301 {
302         struct sockaddr_in peer_addr;
303         socklen_t len = sizeof(peer_addr);
304         struct hostent *he;
305         int ret;
306
307         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
308         if (ret == -1) {
309                 return NULL;
310         }
311
312         he = gethostbyaddr((char *)&peer_addr.sin_addr, sizeof(peer_addr.sin_addr), AF_INET);
313         if (he == NULL) {
314                 return NULL;
315         }
316
317         return talloc_strdup(mem_ctx, he->h_name);
318 }
319
320 static char *ipv4_tcp_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
321 {
322         struct sockaddr_in peer_addr;
323         socklen_t len = sizeof(peer_addr);
324         int ret;
325
326         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
327         if (ret == -1) {
328                 return NULL;
329         }
330
331         return talloc_strdup(mem_ctx, inet_ntoa(peer_addr.sin_addr));
332 }
333
334 static int ipv4_tcp_get_peer_port(struct socket_context *sock)
335 {
336         struct sockaddr_in peer_addr;
337         socklen_t len = sizeof(peer_addr);
338         int ret;
339
340         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
341         if (ret == -1) {
342                 return -1;
343         }
344
345         return ntohs(peer_addr.sin_port);
346 }
347
348 static char *ipv4_tcp_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
349 {
350         struct sockaddr_in my_addr;
351         socklen_t len = sizeof(my_addr);
352         int ret;
353
354         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
355         if (ret == -1) {
356                 return NULL;
357         }
358
359         return talloc_strdup(mem_ctx, inet_ntoa(my_addr.sin_addr));
360 }
361
362 static int ipv4_tcp_get_my_port(struct socket_context *sock)
363 {
364         struct sockaddr_in my_addr;
365         socklen_t len = sizeof(my_addr);
366         int ret;
367
368         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
369         if (ret == -1) {
370                 return -1;
371         }
372
373         return ntohs(my_addr.sin_port);
374 }
375
376 static int ipv4_tcp_get_fd(struct socket_context *sock)
377 {
378         return sock->fd;
379 }
380
381 static const struct socket_ops ipv4_tcp_ops = {
382         .name           = "ipv4",
383         .type           = SOCKET_TYPE_STREAM,
384
385         .init           = ipv4_tcp_init,
386         .connect        = ipv4_tcp_connect,
387         .listen         = ipv4_tcp_listen,
388         .accept         = ipv4_tcp_accept,
389         .recv           = ipv4_tcp_recv,
390         .send           = ipv4_tcp_send,
391         .close          = ipv4_tcp_close,
392
393         .set_option     = ipv4_tcp_set_option,
394
395         .get_peer_name  = ipv4_tcp_get_peer_name,
396         .get_peer_addr  = ipv4_tcp_get_peer_addr,
397         .get_peer_port  = ipv4_tcp_get_peer_port,
398         .get_my_addr    = ipv4_tcp_get_my_addr,
399         .get_my_port    = ipv4_tcp_get_my_port,
400
401         .get_fd         = ipv4_tcp_get_fd
402 };
403
404 const struct socket_ops *socket_ipv4_ops(void)
405 {
406         return &ipv4_tcp_ops;
407 }
408
409 NTSTATUS socket_ipv4_init(void)
410 {
411         return NT_STATUS_OK;
412 }