r5298: - got rid of pstring.h from includes.h. This at least makes it a bit
[bbaumbach/samba-autobuild/.git] / source4 / lib / socket / socket_ipv4.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Socket IPv4 functions
5
6    Copyright (C) Stefan Metzmacher 2004
7    Copyright (C) Andrew Tridgell 2004-2005
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "system/network.h"
26 #include "system/filesys.h"
27
28 static NTSTATUS ipv4_init(struct socket_context *sock)
29 {
30         int type;
31
32         switch (sock->type) {
33         case SOCKET_TYPE_STREAM:
34                 type = SOCK_STREAM;
35                 break;
36         case SOCKET_TYPE_DGRAM:
37                 type = SOCK_DGRAM;
38                 break;
39         default:
40                 return NT_STATUS_INVALID_PARAMETER;
41         }
42
43         sock->fd = socket(PF_INET, type, 0);
44         if (sock->fd == -1) {
45                 return map_nt_error_from_unix(errno);
46         }
47
48         return NT_STATUS_OK;
49 }
50
51 static void ipv4_close(struct socket_context *sock)
52 {
53         close(sock->fd);
54 }
55
56 static NTSTATUS ipv4_connect_complete(struct socket_context *sock, uint32_t flags)
57 {
58         int error=0, ret;
59         socklen_t len = sizeof(error);
60
61         /* check for any errors that may have occurred - this is needed
62            for non-blocking connect */
63         ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &error, &len);
64         if (ret == -1) {
65                 return map_nt_error_from_unix(errno);
66         }
67         if (error != 0) {
68                 return map_nt_error_from_unix(error);
69         }
70
71         if (!(flags & SOCKET_FLAG_BLOCK)) {
72                 ret = set_blocking(sock->fd, False);
73                 if (ret == -1) {
74                         return map_nt_error_from_unix(errno);
75                 }
76         }
77
78         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
79
80         return NT_STATUS_OK;
81 }
82
83
84 static NTSTATUS ipv4_connect(struct socket_context *sock,
85                                  const char *my_address, int my_port,
86                                  const char *srv_address, int srv_port,
87                                  uint32_t flags)
88 {
89         struct sockaddr_in srv_addr;
90         struct ipv4_addr my_ip;
91         struct ipv4_addr srv_ip;
92         int ret;
93
94         my_ip = interpret_addr2(my_address);
95
96         if (my_ip.addr != 0 || my_port != 0) {
97                 struct sockaddr_in my_addr;
98                 ZERO_STRUCT(my_addr);
99 #ifdef HAVE_SOCK_SIN_LEN
100                 my_addr.sin_len         = sizeof(my_addr);
101 #endif
102                 my_addr.sin_addr.s_addr = my_ip.addr;
103                 my_addr.sin_port        = htons(my_port);
104                 my_addr.sin_family      = PF_INET;
105                 
106                 ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
107                 if (ret == -1) {
108                         return map_nt_error_from_unix(errno);
109                 }
110         }
111
112         srv_ip = interpret_addr2(srv_address);
113
114         ZERO_STRUCT(srv_addr);
115 #ifdef HAVE_SOCK_SIN_LEN
116         srv_addr.sin_len        = sizeof(srv_addr);
117 #endif
118         srv_addr.sin_addr.s_addr= srv_ip.addr;
119         srv_addr.sin_port       = htons(srv_port);
120         srv_addr.sin_family     = PF_INET;
121
122         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
123         if (ret == -1) {
124                 return map_nt_error_from_unix(errno);
125         }
126
127         return ipv4_connect_complete(sock, flags);
128 }
129
130
131 /*
132   note that for simplicity of the API, socket_listen() is also
133   use for DGRAM sockets, but in reality only a bind() is done
134 */
135 static NTSTATUS ipv4_listen(struct socket_context *sock,
136                             const char *my_address, int port,
137                             int queue_size, uint32_t flags)
138 {
139         struct sockaddr_in my_addr;
140         struct ipv4_addr ip_addr;
141         int ret;
142
143         socket_set_option(sock, "SO_REUSEADDR=1", NULL);
144
145         ip_addr = interpret_addr2(my_address);
146
147         ZERO_STRUCT(my_addr);
148 #ifdef HAVE_SOCK_SIN_LEN
149         my_addr.sin_len         = sizeof(my_addr);
150 #endif
151         my_addr.sin_addr.s_addr = ip_addr.addr;
152         my_addr.sin_port        = htons(port);
153         my_addr.sin_family      = PF_INET;
154
155         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
156         if (ret == -1) {
157                 return map_nt_error_from_unix(errno);
158         }
159
160         if (sock->type == SOCKET_TYPE_STREAM) {
161                 ret = listen(sock->fd, queue_size);
162                 if (ret == -1) {
163                         return map_nt_error_from_unix(errno);
164                 }
165         }
166
167         if (!(flags & SOCKET_FLAG_BLOCK)) {
168                 ret = set_blocking(sock->fd, False);
169                 if (ret == -1) {
170                         return map_nt_error_from_unix(errno);
171                 }
172         }
173
174         sock->state= SOCKET_STATE_SERVER_LISTEN;
175
176         return NT_STATUS_OK;
177 }
178
179 static NTSTATUS ipv4_accept(struct socket_context *sock, struct socket_context **new_sock)
180 {
181         struct sockaddr_in cli_addr;
182         socklen_t cli_addr_len = sizeof(cli_addr);
183         int new_fd;
184
185         if (sock->type != SOCKET_TYPE_STREAM) {
186                 return NT_STATUS_INVALID_PARAMETER;
187         }
188
189         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
190         if (new_fd == -1) {
191                 return map_nt_error_from_unix(errno);
192         }
193
194         if (!(sock->flags & SOCKET_FLAG_BLOCK)) {
195                 int ret = set_blocking(new_fd, False);
196                 if (ret == -1) {
197                         close(new_fd);
198                         return map_nt_error_from_unix(errno);
199                 }
200         }
201
202         /* TODO: we could add a 'accept_check' hook here
203          *       which get the black/white lists via socket_set_accept_filter()
204          *       or something like that
205          *       --metze
206          */
207
208         (*new_sock) = talloc(NULL, struct socket_context);
209         if (!(*new_sock)) {
210                 close(new_fd);
211                 return NT_STATUS_NO_MEMORY;
212         }
213
214         /* copy the socket_context */
215         (*new_sock)->type               = sock->type;
216         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
217         (*new_sock)->flags              = sock->flags;
218
219         (*new_sock)->fd                 = new_fd;
220
221         (*new_sock)->private_data       = NULL;
222         (*new_sock)->ops                = sock->ops;
223
224         return NT_STATUS_OK;
225 }
226
227 static NTSTATUS ipv4_recv(struct socket_context *sock, void *buf, 
228                               size_t wantlen, size_t *nread, uint32_t flags)
229 {
230         ssize_t gotlen;
231         int flgs = 0;
232
233         /* TODO: we need to map all flags here */
234         if (flags & SOCKET_FLAG_PEEK) {
235                 flgs |= MSG_PEEK;
236         }
237
238         if (flags & SOCKET_FLAG_BLOCK) {
239                 flgs |= MSG_WAITALL;
240         }
241
242         *nread = 0;
243
244         gotlen = recv(sock->fd, buf, wantlen, flgs);
245         if (gotlen == 0) {
246                 return NT_STATUS_END_OF_FILE;
247         } else if (gotlen == -1) {
248                 return map_nt_error_from_unix(errno);
249         }
250
251         *nread = gotlen;
252
253         return NT_STATUS_OK;
254 }
255
256
257 static NTSTATUS ipv4_recvfrom(struct socket_context *sock, void *buf, 
258                               size_t wantlen, size_t *nread, uint32_t flags,
259                               const char **src_addr, int *src_port)
260 {
261         ssize_t gotlen;
262         int flgs = 0;
263         struct sockaddr_in from_addr;
264         socklen_t from_len = sizeof(from_addr);
265         const char *addr;
266
267         if (flags & SOCKET_FLAG_PEEK) {
268                 flgs |= MSG_PEEK;
269         }
270
271         if (flags & SOCKET_FLAG_BLOCK) {
272                 flgs |= MSG_WAITALL;
273         }
274
275         *nread = 0;
276
277         gotlen = recvfrom(sock->fd, buf, wantlen, flgs, 
278                           (struct sockaddr *)&from_addr, &from_len);
279         if (gotlen == 0) {
280                 return NT_STATUS_END_OF_FILE;
281         } else if (gotlen == -1) {
282                 return map_nt_error_from_unix(errno);
283         }
284
285         addr = inet_ntoa(from_addr.sin_addr);
286         if (addr == NULL) {
287                 return NT_STATUS_INTERNAL_ERROR;
288         }
289         *src_addr = talloc_strdup(sock, addr);
290         NT_STATUS_HAVE_NO_MEMORY(*src_addr);
291         *src_port = ntohs(from_addr.sin_port);
292
293         *nread = gotlen;
294
295         return NT_STATUS_OK;
296 }
297
298 static NTSTATUS ipv4_send(struct socket_context *sock, 
299                               const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
300 {
301         ssize_t len;
302         int flgs = 0;
303
304         *sendlen = 0;
305
306         len = send(sock->fd, blob->data, blob->length, flgs);
307         if (len == -1) {
308                 return map_nt_error_from_unix(errno);
309         }       
310
311         *sendlen = len;
312
313         return NT_STATUS_OK;
314 }
315
316 static NTSTATUS ipv4_sendto(struct socket_context *sock, 
317                             const DATA_BLOB *blob, size_t *sendlen, uint32_t flags,
318                             const char *dest_addr, int dest_port)
319 {
320         ssize_t len;
321         int flgs = 0;
322         struct sockaddr_in srv_addr;
323         struct ipv4_addr addr;
324
325         ZERO_STRUCT(srv_addr);
326 #ifdef HAVE_SOCK_SIN_LEN
327         srv_addr.sin_len         = sizeof(srv_addr);
328 #endif
329         addr                     = interpret_addr2(dest_addr);
330         srv_addr.sin_addr.s_addr = addr.addr;
331         srv_addr.sin_port        = htons(dest_port);
332         srv_addr.sin_family      = PF_INET;
333
334         *sendlen = 0;
335
336         len = sendto(sock->fd, blob->data, blob->length, flgs, 
337                    (struct sockaddr *)&srv_addr, sizeof(srv_addr));
338         if (len == -1) {
339                 return map_nt_error_from_unix(errno);
340         }       
341
342         *sendlen = len;
343
344         return NT_STATUS_OK;
345 }
346
347 static NTSTATUS ipv4_set_option(struct socket_context *sock, const char *option, const char *val)
348 {
349         set_socket_options(sock->fd, option);
350         return NT_STATUS_OK;
351 }
352
353 static char *ipv4_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
354 {
355         struct sockaddr_in peer_addr;
356         socklen_t len = sizeof(peer_addr);
357         struct hostent *he;
358         int ret;
359
360         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
361         if (ret == -1) {
362                 return NULL;
363         }
364
365         he = gethostbyaddr((char *)&peer_addr.sin_addr, sizeof(peer_addr.sin_addr), AF_INET);
366         if (he == NULL) {
367                 return NULL;
368         }
369
370         return talloc_strdup(mem_ctx, he->h_name);
371 }
372
373 static char *ipv4_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
374 {
375         struct sockaddr_in peer_addr;
376         socklen_t len = sizeof(peer_addr);
377         int ret;
378
379         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
380         if (ret == -1) {
381                 return NULL;
382         }
383
384         return talloc_strdup(mem_ctx, inet_ntoa(peer_addr.sin_addr));
385 }
386
387 static int ipv4_get_peer_port(struct socket_context *sock)
388 {
389         struct sockaddr_in peer_addr;
390         socklen_t len = sizeof(peer_addr);
391         int ret;
392
393         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
394         if (ret == -1) {
395                 return -1;
396         }
397
398         return ntohs(peer_addr.sin_port);
399 }
400
401 static char *ipv4_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
402 {
403         struct sockaddr_in my_addr;
404         socklen_t len = sizeof(my_addr);
405         int ret;
406
407         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
408         if (ret == -1) {
409                 return NULL;
410         }
411
412         return talloc_strdup(mem_ctx, inet_ntoa(my_addr.sin_addr));
413 }
414
415 static int ipv4_get_my_port(struct socket_context *sock)
416 {
417         struct sockaddr_in my_addr;
418         socklen_t len = sizeof(my_addr);
419         int ret;
420
421         ret = getsockname(sock->fd, (struct sockaddr *)&my_addr, &len);
422         if (ret == -1) {
423                 return -1;
424         }
425
426         return ntohs(my_addr.sin_port);
427 }
428
429 static int ipv4_get_fd(struct socket_context *sock)
430 {
431         return sock->fd;
432 }
433
434 static const struct socket_ops ipv4_ops = {
435         .name                   = "ipv4",
436         .fn_init                = ipv4_init,
437         .fn_connect             = ipv4_connect,
438         .fn_connect_complete    = ipv4_connect_complete,
439         .fn_listen              = ipv4_listen,
440         .fn_accept              = ipv4_accept,
441         .fn_recv                = ipv4_recv,
442         .fn_recvfrom            = ipv4_recvfrom,
443         .fn_send                = ipv4_send,
444         .fn_sendto              = ipv4_sendto,
445         .fn_close               = ipv4_close,
446
447         .fn_set_option          = ipv4_set_option,
448
449         .fn_get_peer_name       = ipv4_get_peer_name,
450         .fn_get_peer_addr       = ipv4_get_peer_addr,
451         .fn_get_peer_port       = ipv4_get_peer_port,
452         .fn_get_my_addr         = ipv4_get_my_addr,
453         .fn_get_my_port         = ipv4_get_my_port,
454
455         .fn_get_fd              = ipv4_get_fd
456 };
457
458 const struct socket_ops *socket_ipv4_ops(enum socket_type type)
459 {
460         return &ipv4_ops;
461 }