build: commit all the waf build files in the tree
[nivanova/samba-autobuild/.git] / source4 / lib / socket / socket_ip.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Socket IPv4/IPv6 functions
5
6    Copyright (C) Stefan Metzmacher 2004
7    Copyright (C) Andrew Tridgell 2004-2005
8    Copyright (C) Jelmer Vernooij 2004
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "system/filesys.h"
26 #include "lib/socket/socket.h"
27 #include "system/network.h"
28 #include "lib/util/util_net.h"
29
30 static NTSTATUS ipv4_init(struct socket_context *sock)
31 {
32         int type;
33
34         switch (sock->type) {
35         case SOCKET_TYPE_STREAM:
36                 type = SOCK_STREAM;
37                 break;
38         case SOCKET_TYPE_DGRAM:
39                 type = SOCK_DGRAM;
40                 break;
41         default:
42                 return NT_STATUS_INVALID_PARAMETER;
43         }
44
45         sock->fd = socket(PF_INET, type, 0);
46         if (sock->fd == -1) {
47                 return map_nt_error_from_unix(errno);
48         }
49
50         sock->backend_name = "ipv4";
51         sock->family = AF_INET;
52
53         return NT_STATUS_OK;
54 }
55
56 static void ip_close(struct socket_context *sock)
57 {
58         close(sock->fd);
59 }
60
61 static NTSTATUS ip_connect_complete(struct socket_context *sock, uint32_t flags)
62 {
63         int error=0, ret;
64         socklen_t len = sizeof(error);
65
66         /* check for any errors that may have occurred - this is needed
67            for non-blocking connect */
68         ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &error, &len);
69         if (ret == -1) {
70                 return map_nt_error_from_unix(errno);
71         }
72         if (error != 0) {
73                 return map_nt_error_from_unix(error);
74         }
75
76         if (!(flags & SOCKET_FLAG_BLOCK)) {
77                 ret = set_blocking(sock->fd, false);
78                 if (ret == -1) {
79                         return map_nt_error_from_unix(errno);
80                 }
81         }
82
83         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
84
85         return NT_STATUS_OK;
86 }
87
88
89 static NTSTATUS ipv4_connect(struct socket_context *sock,
90                              const struct socket_address *my_address, 
91                              const struct socket_address *srv_address,
92                              uint32_t flags)
93 {
94         struct sockaddr_in srv_addr;
95         struct in_addr my_ip;
96         struct in_addr srv_ip;
97         int ret;
98
99         if (my_address && my_address->sockaddr) {
100                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
101                 if (ret == -1) {
102                         return map_nt_error_from_unix(errno);
103                 }
104         } else if (my_address) {
105                 my_ip = interpret_addr2(my_address->addr);
106                 
107                 if (my_ip.s_addr != 0 || my_address->port != 0) {
108                         struct sockaddr_in my_addr;
109                         ZERO_STRUCT(my_addr);
110 #ifdef HAVE_SOCK_SIN_LEN
111                         my_addr.sin_len         = sizeof(my_addr);
112 #endif
113                         my_addr.sin_addr.s_addr = my_ip.s_addr;
114                         my_addr.sin_port        = htons(my_address->port);
115                         my_addr.sin_family      = PF_INET;
116                         
117                         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
118                         if (ret == -1) {
119                                 return map_nt_error_from_unix(errno);
120                         }
121                 }
122         }
123
124         if (srv_address->sockaddr) {
125                 ret = connect(sock->fd, srv_address->sockaddr, srv_address->sockaddrlen);
126                 if (ret == -1) {
127                         return map_nt_error_from_unix(errno);
128                 }
129         } else {
130                 srv_ip = interpret_addr2(srv_address->addr);
131                 if (!srv_ip.s_addr) {
132                         return NT_STATUS_BAD_NETWORK_NAME;
133                 }
134
135                 SMB_ASSERT(srv_address->port != 0);
136                 
137                 ZERO_STRUCT(srv_addr);
138 #ifdef HAVE_SOCK_SIN_LEN
139                 srv_addr.sin_len        = sizeof(srv_addr);
140 #endif
141                 srv_addr.sin_addr.s_addr= srv_ip.s_addr;
142                 srv_addr.sin_port       = htons(srv_address->port);
143                 srv_addr.sin_family     = PF_INET;
144
145                 ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
146                 if (ret == -1) {
147                         return map_nt_error_from_unix(errno);
148                 }
149         }
150
151         return ip_connect_complete(sock, flags);
152 }
153
154
155 /*
156   note that for simplicity of the API, socket_listen() is also
157   use for DGRAM sockets, but in reality only a bind() is done
158 */
159 static NTSTATUS ipv4_listen(struct socket_context *sock,
160                             const struct socket_address *my_address, 
161                             int queue_size, uint32_t flags)
162 {
163         struct sockaddr_in my_addr;
164         struct in_addr ip_addr;
165         int ret;
166
167         socket_set_option(sock, "SO_REUSEADDR=1", NULL);
168
169         if (my_address->sockaddr) {
170                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
171         } else {
172                 ip_addr = interpret_addr2(my_address->addr);
173                 
174                 ZERO_STRUCT(my_addr);
175 #ifdef HAVE_SOCK_SIN_LEN
176                 my_addr.sin_len         = sizeof(my_addr);
177 #endif
178                 my_addr.sin_addr.s_addr = ip_addr.s_addr;
179                 my_addr.sin_port        = htons(my_address->port);
180                 my_addr.sin_family      = PF_INET;
181                 
182                 ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
183         }
184
185         if (ret == -1) {
186                 return map_nt_error_from_unix(errno);
187         }
188
189         if (sock->type == SOCKET_TYPE_STREAM) {
190                 ret = listen(sock->fd, queue_size);
191                 if (ret == -1) {
192                         return map_nt_error_from_unix(errno);
193                 }
194         }
195
196         if (!(flags & SOCKET_FLAG_BLOCK)) {
197                 ret = set_blocking(sock->fd, false);
198                 if (ret == -1) {
199                         return map_nt_error_from_unix(errno);
200                 }
201         }
202
203         sock->state= SOCKET_STATE_SERVER_LISTEN;
204
205         return NT_STATUS_OK;
206 }
207
208 static NTSTATUS ipv4_accept(struct socket_context *sock, struct socket_context **new_sock)
209 {
210         struct sockaddr_in cli_addr;
211         socklen_t cli_addr_len = sizeof(cli_addr);
212         int new_fd;
213
214         if (sock->type != SOCKET_TYPE_STREAM) {
215                 return NT_STATUS_INVALID_PARAMETER;
216         }
217
218         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
219         if (new_fd == -1) {
220                 return map_nt_error_from_unix(errno);
221         }
222
223         if (!(sock->flags & SOCKET_FLAG_BLOCK)) {
224                 int ret = set_blocking(new_fd, false);
225                 if (ret == -1) {
226                         close(new_fd);
227                         return map_nt_error_from_unix(errno);
228                 }
229         }
230
231         /* TODO: we could add a 'accept_check' hook here
232          *       which get the black/white lists via socket_set_accept_filter()
233          *       or something like that
234          *       --metze
235          */
236
237         (*new_sock) = talloc(NULL, struct socket_context);
238         if (!(*new_sock)) {
239                 close(new_fd);
240                 return NT_STATUS_NO_MEMORY;
241         }
242
243         /* copy the socket_context */
244         (*new_sock)->type               = sock->type;
245         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
246         (*new_sock)->flags              = sock->flags;
247
248         (*new_sock)->fd                 = new_fd;
249
250         (*new_sock)->private_data       = NULL;
251         (*new_sock)->ops                = sock->ops;
252         (*new_sock)->backend_name       = sock->backend_name;
253
254         return NT_STATUS_OK;
255 }
256
257 static NTSTATUS ip_recv(struct socket_context *sock, void *buf, 
258                               size_t wantlen, size_t *nread)
259 {
260         ssize_t gotlen;
261
262         *nread = 0;
263
264         gotlen = recv(sock->fd, buf, wantlen, 0);
265         if (gotlen == 0) {
266                 return NT_STATUS_END_OF_FILE;
267         } else if (gotlen == -1) {
268                 return map_nt_error_from_unix(errno);
269         }
270
271         *nread = gotlen;
272
273         return NT_STATUS_OK;
274 }
275
276
277 static NTSTATUS ipv4_recvfrom(struct socket_context *sock, void *buf, 
278                               size_t wantlen, size_t *nread, 
279                               TALLOC_CTX *addr_ctx, struct socket_address **_src)
280 {
281         ssize_t gotlen;
282         struct sockaddr_in *from_addr;
283         socklen_t from_len = sizeof(*from_addr);
284         struct socket_address *src;
285         char addrstring[INET_ADDRSTRLEN];
286         
287         src = talloc(addr_ctx, struct socket_address);
288         if (!src) {
289                 return NT_STATUS_NO_MEMORY;
290         }
291         
292         src->family = sock->backend_name;
293
294         from_addr = talloc(src, struct sockaddr_in);
295         if (!from_addr) {
296                 talloc_free(src);
297                 return NT_STATUS_NO_MEMORY;
298         }
299
300         src->sockaddr = (struct sockaddr *)from_addr;
301
302         *nread = 0;
303
304         gotlen = recvfrom(sock->fd, buf, wantlen, 0, 
305                           src->sockaddr, &from_len);
306         if (gotlen == 0) {
307                 talloc_free(src);
308                 return NT_STATUS_END_OF_FILE;
309         } else if (gotlen == -1) {
310                 talloc_free(src);
311                 return map_nt_error_from_unix(errno);
312         }
313
314         src->sockaddrlen = from_len;
315
316         if (inet_ntop(AF_INET, &from_addr->sin_addr, addrstring, 
317                          sizeof(addrstring)) == NULL) {
318                 talloc_free(src);
319                 return NT_STATUS_INTERNAL_ERROR;
320         }
321         src->addr = talloc_strdup(src, addrstring);
322         if (src->addr == NULL) {
323                 talloc_free(src);
324                 return NT_STATUS_NO_MEMORY;
325         }
326         src->port = ntohs(from_addr->sin_port);
327
328         *nread  = gotlen;
329         *_src   = src;
330         return NT_STATUS_OK;
331 }
332
333 static NTSTATUS ip_send(struct socket_context *sock, 
334                               const DATA_BLOB *blob, size_t *sendlen)
335 {
336         ssize_t len;
337
338         *sendlen = 0;
339
340         len = send(sock->fd, blob->data, blob->length, 0);
341         if (len == -1) {
342                 return map_nt_error_from_unix(errno);
343         }       
344
345         *sendlen = len;
346
347         return NT_STATUS_OK;
348 }
349
350 static NTSTATUS ipv4_sendto(struct socket_context *sock, 
351                             const DATA_BLOB *blob, size_t *sendlen, 
352                             const struct socket_address *dest_addr)
353 {
354         ssize_t len;
355
356         if (dest_addr->sockaddr) {
357                 len = sendto(sock->fd, blob->data, blob->length, 0, 
358                              dest_addr->sockaddr, dest_addr->sockaddrlen);
359         } else {
360                 struct sockaddr_in srv_addr;
361                 struct in_addr addr;
362
363                 SMB_ASSERT(dest_addr->port != 0);
364                 
365                 ZERO_STRUCT(srv_addr);
366 #ifdef HAVE_SOCK_SIN_LEN
367                 srv_addr.sin_len         = sizeof(srv_addr);
368 #endif
369                 addr                     = interpret_addr2(dest_addr->addr);
370                 if (addr.s_addr == 0) {
371                         return NT_STATUS_HOST_UNREACHABLE;
372                 }
373                 srv_addr.sin_addr.s_addr = addr.s_addr;
374                 srv_addr.sin_port        = htons(dest_addr->port);
375                 srv_addr.sin_family      = PF_INET;
376                 
377                 *sendlen = 0;
378                 
379                 len = sendto(sock->fd, blob->data, blob->length, 0, 
380                              (struct sockaddr *)&srv_addr, sizeof(srv_addr));
381         }
382         if (len == -1) {
383                 return map_nt_error_from_unix(errno);
384         }       
385
386         *sendlen = len;
387
388         return NT_STATUS_OK;
389 }
390
391 static NTSTATUS ipv4_set_option(struct socket_context *sock, const char *option, const char *val)
392 {
393         set_socket_options(sock->fd, option);
394         return NT_STATUS_OK;
395 }
396
397 static char *ipv4_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
398 {
399         struct sockaddr_in peer_addr;
400         socklen_t len = sizeof(peer_addr);
401         struct hostent *he;
402         int ret;
403
404         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
405         if (ret == -1) {
406                 return NULL;
407         }
408
409         he = gethostbyaddr((char *)&peer_addr.sin_addr, sizeof(peer_addr.sin_addr), AF_INET);
410         if (he == NULL) {
411                 return NULL;
412         }
413
414         return talloc_strdup(mem_ctx, he->h_name);
415 }
416
417 static struct socket_address *ipv4_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
418 {
419         struct sockaddr_in *peer_addr;
420         socklen_t len = sizeof(*peer_addr);
421         struct socket_address *peer;
422         char addrstring[INET_ADDRSTRLEN];
423         int ret;
424         
425         peer = talloc(mem_ctx, struct socket_address);
426         if (!peer) {
427                 return NULL;
428         }
429         
430         peer->family = sock->backend_name;
431         peer_addr = talloc(peer, struct sockaddr_in);
432         if (!peer_addr) {
433                 talloc_free(peer);
434                 return NULL;
435         }
436
437         peer->sockaddr = (struct sockaddr *)peer_addr;
438
439         ret = getpeername(sock->fd, peer->sockaddr, &len);
440         if (ret == -1) {
441                 talloc_free(peer);
442                 return NULL;
443         }
444
445         peer->sockaddrlen = len;
446
447         if (inet_ntop(AF_INET, &peer_addr->sin_addr, addrstring,
448                          sizeof(addrstring)) == NULL) {
449                 talloc_free(peer);
450                 return NULL;
451         }
452         peer->addr = talloc_strdup(peer, addrstring);
453         if (!peer->addr) {
454                 talloc_free(peer);
455                 return NULL;
456         }
457         peer->port = ntohs(peer_addr->sin_port);
458
459         return peer;
460 }
461
462 static struct socket_address *ipv4_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
463 {
464         struct sockaddr_in *local_addr;
465         socklen_t len = sizeof(*local_addr);
466         struct socket_address *local;
467         char addrstring[INET_ADDRSTRLEN];
468         int ret;
469         
470         local = talloc(mem_ctx, struct socket_address);
471         if (!local) {
472                 return NULL;
473         }
474         
475         local->family = sock->backend_name;
476         local_addr = talloc(local, struct sockaddr_in);
477         if (!local_addr) {
478                 talloc_free(local);
479                 return NULL;
480         }
481
482         local->sockaddr = (struct sockaddr *)local_addr;
483
484         ret = getsockname(sock->fd, local->sockaddr, &len);
485         if (ret == -1) {
486                 talloc_free(local);
487                 return NULL;
488         }
489
490         local->sockaddrlen = len;
491
492         if (inet_ntop(AF_INET, &local_addr->sin_addr, addrstring, 
493                          sizeof(addrstring)) == NULL) {
494                 talloc_free(local);
495                 return NULL;
496         }
497         local->addr = talloc_strdup(local, addrstring);
498         if (!local->addr) {
499                 talloc_free(local);
500                 return NULL;
501         }
502         local->port = ntohs(local_addr->sin_port);
503
504         return local;
505 }
506 static int ip_get_fd(struct socket_context *sock)
507 {
508         return sock->fd;
509 }
510
511 static NTSTATUS ip_pending(struct socket_context *sock, size_t *npending)
512 {
513         int value = 0;
514         if (ioctl(sock->fd, FIONREAD, &value) == 0) {
515                 *npending = value;
516                 return NT_STATUS_OK;
517         }
518         return map_nt_error_from_unix(errno);
519 }
520
521 static const struct socket_ops ipv4_ops = {
522         .name                   = "ipv4",
523         .fn_init                = ipv4_init,
524         .fn_connect             = ipv4_connect,
525         .fn_connect_complete    = ip_connect_complete,
526         .fn_listen              = ipv4_listen,
527         .fn_accept              = ipv4_accept,
528         .fn_recv                = ip_recv,
529         .fn_recvfrom            = ipv4_recvfrom,
530         .fn_send                = ip_send,
531         .fn_sendto              = ipv4_sendto,
532         .fn_pending             = ip_pending,
533         .fn_close               = ip_close,
534
535         .fn_set_option          = ipv4_set_option,
536
537         .fn_get_peer_name       = ipv4_get_peer_name,
538         .fn_get_peer_addr       = ipv4_get_peer_addr,
539         .fn_get_my_addr         = ipv4_get_my_addr,
540
541         .fn_get_fd              = ip_get_fd
542 };
543
544 _PUBLIC_ const struct socket_ops *socket_ipv4_ops(enum socket_type type)
545 {
546         return &ipv4_ops;
547 }
548
549 #if HAVE_IPV6
550
551 static struct in6_addr interpret_addr6(const char *name)
552 {
553         char addr[INET6_ADDRSTRLEN];
554         struct in6_addr dest6;
555         const char *sp = name;
556         char *p;
557         int ret;
558
559         if (sp == NULL) return in6addr_any;
560
561         p = strchr_m(sp, '%');
562
563         if (strcasecmp(sp, "localhost") == 0) {
564                 sp = "::1";
565         }
566
567         /*
568          * Cope with link-local.
569          * This is IP:v6:addr%ifname.
570          */
571
572         if (p && (p > sp) && (if_nametoindex(p+1) != 0)) {
573                 strlcpy(addr, sp,
574                         MIN(PTR_DIFF(p,sp)+1,
575                                 sizeof(addr)));
576                 sp = addr;
577         }
578
579         ret = inet_pton(AF_INET6, sp, &dest6);
580         if (ret > 0) {
581                 return dest6;
582         }
583
584         return in6addr_any;
585 }
586
587 static NTSTATUS ipv6_init(struct socket_context *sock)
588 {
589         int type;
590
591         switch (sock->type) {
592         case SOCKET_TYPE_STREAM:
593                 type = SOCK_STREAM;
594                 break;
595         case SOCKET_TYPE_DGRAM:
596                 type = SOCK_DGRAM;
597                 break;
598         default:
599                 return NT_STATUS_INVALID_PARAMETER;
600         }
601
602         sock->fd = socket(PF_INET6, type, 0);
603         if (sock->fd == -1) {
604                 return map_nt_error_from_unix(errno);
605         }
606
607         sock->backend_name = "ipv6";
608         sock->family = AF_INET6;
609
610         return NT_STATUS_OK;
611 }
612
613 static NTSTATUS ipv6_tcp_connect(struct socket_context *sock,
614                                  const struct socket_address *my_address,
615                                  const struct socket_address *srv_address,
616                                  uint32_t flags)
617 {
618         int ret;
619
620         if (my_address && my_address->sockaddr) {
621                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
622                 if (ret == -1) {
623                         return map_nt_error_from_unix(errno);
624                 }
625         } else if (my_address) {
626                 struct in6_addr my_ip;
627                 my_ip = interpret_addr6(my_address->addr);
628
629                 if (memcmp(&my_ip, &in6addr_any, sizeof(my_ip)) || my_address->port != 0) {
630                         struct sockaddr_in6 my_addr;
631                         ZERO_STRUCT(my_addr);
632                         my_addr.sin6_addr       = my_ip;
633                         my_addr.sin6_port       = htons(my_address->port);
634                         my_addr.sin6_family     = PF_INET6;
635                         
636                         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
637                         if (ret == -1) {
638                                 return map_nt_error_from_unix(errno);
639                         }
640                 }
641         }
642
643         if (srv_address->sockaddr) {
644                 ret = connect(sock->fd, srv_address->sockaddr, srv_address->sockaddrlen);
645         } else {
646                 struct in6_addr srv_ip;
647                 struct sockaddr_in6 srv_addr;
648                 srv_ip = interpret_addr6(srv_address->addr);
649                 if (memcmp(&srv_ip, &in6addr_any, sizeof(srv_ip)) == 0) {
650                         return NT_STATUS_BAD_NETWORK_NAME;
651                 }
652                 
653                 ZERO_STRUCT(srv_addr);
654                 srv_addr.sin6_addr      = srv_ip;
655                 srv_addr.sin6_port      = htons(srv_address->port);
656                 srv_addr.sin6_family    = PF_INET6;
657                 
658                 ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
659         }
660         if (ret == -1) {
661                 return map_nt_error_from_unix(errno);
662         }
663
664         return ip_connect_complete(sock, flags);
665 }
666
667 static NTSTATUS ipv6_listen(struct socket_context *sock,
668                                 const struct socket_address *my_address,
669                                 int queue_size, uint32_t flags)
670 {
671         struct sockaddr_in6 my_addr;
672         struct in6_addr ip_addr;
673         int ret;
674
675         socket_set_option(sock, "SO_REUSEADDR=1", NULL);
676
677         if (my_address->sockaddr) {
678                 ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen);
679         } else {
680                 ip_addr = interpret_addr6(my_address->addr);
681                 
682                 ZERO_STRUCT(my_addr);
683                 my_addr.sin6_addr       = ip_addr;
684                 my_addr.sin6_port       = htons(my_address->port);
685                 my_addr.sin6_family     = PF_INET6;
686                 
687                 ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
688         }
689
690         if (ret == -1) {
691                 return map_nt_error_from_unix(errno);
692         }
693
694         if (sock->type == SOCKET_TYPE_STREAM) {
695                 ret = listen(sock->fd, queue_size);
696                 if (ret == -1) {
697                         return map_nt_error_from_unix(errno);
698                 }
699         }
700
701         if (!(flags & SOCKET_FLAG_BLOCK)) {
702                 ret = set_blocking(sock->fd, false);
703                 if (ret == -1) {
704                         return map_nt_error_from_unix(errno);
705                 }
706         }
707
708         sock->state= SOCKET_STATE_SERVER_LISTEN;
709
710         return NT_STATUS_OK;
711 }
712
713 static NTSTATUS ipv6_tcp_accept(struct socket_context *sock, struct socket_context **new_sock)
714 {
715         struct sockaddr_in cli_addr;
716         socklen_t cli_addr_len = sizeof(cli_addr);
717         int new_fd;
718         
719         if (sock->type != SOCKET_TYPE_STREAM) {
720                 return NT_STATUS_INVALID_PARAMETER;
721         }
722
723         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
724         if (new_fd == -1) {
725                 return map_nt_error_from_unix(errno);
726         }
727
728         if (!(sock->flags & SOCKET_FLAG_BLOCK)) {
729                 int ret = set_blocking(new_fd, false);
730                 if (ret == -1) {
731                         close(new_fd);
732                         return map_nt_error_from_unix(errno);
733                 }
734         }
735
736         /* TODO: we could add a 'accept_check' hook here
737          *       which get the black/white lists via socket_set_accept_filter()
738          *       or something like that
739          *       --metze
740          */
741
742         (*new_sock) = talloc(NULL, struct socket_context);
743         if (!(*new_sock)) {
744                 close(new_fd);
745                 return NT_STATUS_NO_MEMORY;
746         }
747
748         /* copy the socket_context */
749         (*new_sock)->type               = sock->type;
750         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
751         (*new_sock)->flags              = sock->flags;
752
753         (*new_sock)->fd                 = new_fd;
754
755         (*new_sock)->private_data       = NULL;
756         (*new_sock)->ops                = sock->ops;
757         (*new_sock)->backend_name       = sock->backend_name;
758
759         return NT_STATUS_OK;
760 }
761
762 static NTSTATUS ipv6_recvfrom(struct socket_context *sock, void *buf, 
763                               size_t wantlen, size_t *nread, 
764                               TALLOC_CTX *addr_ctx, struct socket_address **_src)
765 {
766         ssize_t gotlen;
767         struct sockaddr_in6 *from_addr;
768         socklen_t from_len = sizeof(*from_addr);
769         struct socket_address *src;
770         char addrstring[INET6_ADDRSTRLEN];
771         
772         src = talloc(addr_ctx, struct socket_address);
773         if (!src) {
774                 return NT_STATUS_NO_MEMORY;
775         }
776         
777         src->family = sock->backend_name;
778
779         from_addr = talloc(src, struct sockaddr_in6);
780         if (!from_addr) {
781                 talloc_free(src);
782                 return NT_STATUS_NO_MEMORY;
783         }
784
785         src->sockaddr = (struct sockaddr *)from_addr;
786
787         *nread = 0;
788
789         gotlen = recvfrom(sock->fd, buf, wantlen, 0, 
790                           src->sockaddr, &from_len);
791         if (gotlen == 0) {
792                 talloc_free(src);
793                 return NT_STATUS_END_OF_FILE;
794         } else if (gotlen == -1) {
795                 talloc_free(src);
796                 return map_nt_error_from_unix(errno);
797         }
798
799         src->sockaddrlen = from_len;
800
801         if (inet_ntop(AF_INET6, &from_addr->sin6_addr, addrstring, sizeof(addrstring)) == NULL) {
802                 DEBUG(0, ("Unable to convert address to string: %s\n", strerror(errno)));
803                 talloc_free(src);
804                 return NT_STATUS_INTERNAL_ERROR;
805         }
806
807         src->addr = talloc_strdup(src, addrstring);
808         if (src->addr == NULL) {
809                 talloc_free(src);
810                 return NT_STATUS_NO_MEMORY;
811         }
812         src->port = ntohs(from_addr->sin6_port);
813
814         *nread  = gotlen;
815         *_src   = src;
816         return NT_STATUS_OK;
817 }
818
819 static NTSTATUS ipv6_sendto(struct socket_context *sock, 
820                             const DATA_BLOB *blob, size_t *sendlen, 
821                             const struct socket_address *dest_addr)
822 {
823         ssize_t len;
824
825         if (dest_addr->sockaddr) {
826                 len = sendto(sock->fd, blob->data, blob->length, 0, 
827                              dest_addr->sockaddr, dest_addr->sockaddrlen);
828         } else {
829                 struct sockaddr_in6 srv_addr;
830                 struct in6_addr addr;
831                 
832                 ZERO_STRUCT(srv_addr);
833                 addr                     = interpret_addr6(dest_addr->addr);
834                 if (addr.s6_addr == 0) {
835                         return NT_STATUS_HOST_UNREACHABLE;
836                 }
837                 srv_addr.sin6_addr = addr;
838                 srv_addr.sin6_port        = htons(dest_addr->port);
839                 srv_addr.sin6_family      = PF_INET6;
840                 
841                 *sendlen = 0;
842                 
843                 len = sendto(sock->fd, blob->data, blob->length, 0, 
844                              (struct sockaddr *)&srv_addr, sizeof(srv_addr));
845         }
846         if (len == -1) {
847                 return map_nt_error_from_unix(errno);
848         }       
849
850         *sendlen = len;
851
852         return NT_STATUS_OK;
853 }
854
855 static NTSTATUS ipv6_set_option(struct socket_context *sock, const char *option, const char *val)
856 {
857         set_socket_options(sock->fd, option);
858         return NT_STATUS_OK;
859 }
860
861 static char *ipv6_tcp_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
862 {
863         struct sockaddr_in6 peer_addr;
864         socklen_t len = sizeof(peer_addr);
865         struct hostent *he;
866         int ret;
867
868         ret = getpeername(sock->fd, (struct sockaddr *)&peer_addr, &len);
869         if (ret == -1) {
870                 return NULL;
871         }
872
873         he = gethostbyaddr((char *)&peer_addr.sin6_addr, sizeof(peer_addr.sin6_addr), AF_INET6);
874         if (he == NULL) {
875                 return NULL;
876         }
877
878         return talloc_strdup(mem_ctx, he->h_name);
879 }
880
881 static struct socket_address *ipv6_tcp_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
882 {
883         struct sockaddr_in6 *peer_addr;
884         socklen_t len = sizeof(*peer_addr);
885         struct socket_address *peer;
886         int ret;
887         char addr[128];
888         const char *addr_ret;
889         
890         peer = talloc(mem_ctx, struct socket_address);
891         if (!peer) {
892                 return NULL;
893         }
894         
895         peer->family = sock->backend_name;
896         peer_addr = talloc(peer, struct sockaddr_in6);
897         if (!peer_addr) {
898                 talloc_free(peer);
899                 return NULL;
900         }
901
902         peer->sockaddr = (struct sockaddr *)peer_addr;
903
904         ret = getpeername(sock->fd, peer->sockaddr, &len);
905         if (ret == -1) {
906                 talloc_free(peer);
907                 return NULL;
908         }
909
910         peer->sockaddrlen = len;
911
912         addr_ret = inet_ntop(AF_INET6, &peer_addr->sin6_addr, addr, sizeof(addr));
913         if (addr_ret == NULL) {
914                 talloc_free(peer);
915                 return NULL;
916         }
917
918         peer->addr = talloc_strdup(peer, addr_ret);
919         if (peer->addr == NULL) {
920                 talloc_free(peer);
921                 return NULL;
922         }
923
924         peer->port = ntohs(peer_addr->sin6_port);
925
926         return peer;
927 }
928
929 static struct socket_address *ipv6_tcp_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
930 {
931         struct sockaddr_in6 *local_addr;
932         socklen_t len = sizeof(*local_addr);
933         struct socket_address *local;
934         int ret;
935         char addrstring[INET6_ADDRSTRLEN];
936         
937         local = talloc(mem_ctx, struct socket_address);
938         if (!local) {
939                 return NULL;
940         }
941         
942         local->family = sock->backend_name;
943         local_addr = talloc(local, struct sockaddr_in6);
944         if (!local_addr) {
945                 talloc_free(local);
946                 return NULL;
947         }
948
949         local->sockaddr = (struct sockaddr *)local_addr;
950
951         ret = getsockname(sock->fd, local->sockaddr, &len);
952         if (ret == -1) {
953                 talloc_free(local);
954                 return NULL;
955         }
956
957         local->sockaddrlen = len;
958
959         if (inet_ntop(AF_INET6, &local_addr->sin6_addr, addrstring, 
960                        sizeof(addrstring)) == NULL) {
961                 DEBUG(0, ("Unable to convert address to string: %s\n", 
962                           strerror(errno)));
963                 talloc_free(local);
964                 return NULL;
965         }
966         
967         local->addr = talloc_strdup(mem_ctx, addrstring);
968         if (!local->addr) {
969                 talloc_free(local);
970                 return NULL;
971         }
972         local->port = ntohs(local_addr->sin6_port);
973
974         return local;
975 }
976
977 static const struct socket_ops ipv6_tcp_ops = {
978         .name                   = "ipv6",
979         .fn_init                = ipv6_init,
980         .fn_connect             = ipv6_tcp_connect,
981         .fn_connect_complete    = ip_connect_complete,
982         .fn_listen              = ipv6_listen,
983         .fn_accept              = ipv6_tcp_accept,
984         .fn_recv                = ip_recv,
985         .fn_recvfrom            = ipv6_recvfrom,
986         .fn_send                = ip_send,
987         .fn_sendto              = ipv6_sendto,
988         .fn_pending             = ip_pending,
989         .fn_close               = ip_close,
990
991         .fn_set_option          = ipv6_set_option,
992
993         .fn_get_peer_name       = ipv6_tcp_get_peer_name,
994         .fn_get_peer_addr       = ipv6_tcp_get_peer_addr,
995         .fn_get_my_addr         = ipv6_tcp_get_my_addr,
996
997         .fn_get_fd              = ip_get_fd
998 };
999
1000 _PUBLIC_ const struct socket_ops *socket_ipv6_ops(enum socket_type type)
1001 {
1002         return &ipv6_tcp_ops;
1003 }
1004
1005 #endif