?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Cause cli_close to return an NTSTATUS.
[Samba/ekacnet.git] / lib / tsocket / tsocket_bsd.c
blob29097bd987898a681112493e91df89881d5c0160
1 /*
2 Unix SMB/CIFS implementation.
3
4 Copyright (C) Stefan Metzmacher 2009
5
6 ** NOTE! The following LGPL license applies to the tevent
7 ** library. This does NOT imply that all of Samba is released
8 ** under the LGPL
9
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
14
15 This library 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 GNU
18 Lesser General Public License for more details.
19
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "replace.h"
25 #include "system/filesys.h"
26 #include "system/network.h"
27 #include "system/filesys.h"
28 #include "tsocket.h"
29 #include "tsocket_internal.h"
30
31 static int tsocket_bsd_error_from_errno(int ret,
32 int sys_errno,
33 bool *retry)
34 {
35 *retry = false;
36
37 if (ret >= 0) {
38 return 0;
39 }
40
41 if (ret != -1) {
42 return EIO;
43 }
44
45 if (sys_errno == 0) {
46 return EIO;
47 }
48
49 if (sys_errno == EINTR) {
50 *retry = true;
51 return sys_errno;
52 }
53
54 if (sys_errno == EINPROGRESS) {
55 *retry = true;
56 return sys_errno;
57 }
58
59 if (sys_errno == EAGAIN) {
60 *retry = true;
61 return sys_errno;
62 }
63
64 #ifdef EWOULDBLOCK
65 if (sys_errno == EWOULDBLOCK) {
66 *retry = true;
67 return sys_errno;
68 }
69 #endif
70
71 return sys_errno;
72 }
73
74 static int tsocket_bsd_common_prepare_fd(int fd, bool high_fd)
75 {
76 int i;
77 int sys_errno = 0;
78 int fds[3];
79 int num_fds = 0;
80
81 int result, flags;
82
83 if (fd == -1) {
84 return -1;
85 }
86
87 /* first make a fd >= 3 */
88 if (high_fd) {
89 while (fd < 3) {
90 fds[num_fds++] = fd;
91 fd = dup(fd);
92 if (fd == -1) {
93 sys_errno = errno;
94 break;
95 }
96 }
97 for (i=0; i<num_fds; i++) {
98 close(fds[i]);
99 }
100 if (fd == -1) {
101 errno = sys_errno;
102 return fd;
103 }
104 }
105
106 /* fd should be nonblocking. */
107
108 #ifdef O_NONBLOCK
109 #define FLAG_TO_SET O_NONBLOCK
110 #else
111 #ifdef SYSV
112 #define FLAG_TO_SET O_NDELAY
113 #else /* BSD */
114 #define FLAG_TO_SET FNDELAY
115 #endif
116 #endif
117
118 if ((flags = fcntl(fd, F_GETFL)) == -1) {
119 goto fail;
120 }
121
122 flags |= FLAG_TO_SET;
123 if (fcntl(fd, F_SETFL, flags) == -1) {
124 goto fail;
125 }
126
127 #undef FLAG_TO_SET
128
129 /* fd should be closed on exec() */
130 #ifdef FD_CLOEXEC
131 result = flags = fcntl(fd, F_GETFD, 0);
132 if (flags >= 0) {
133 flags |= FD_CLOEXEC;
134 result = fcntl(fd, F_SETFD, flags);
135 }
136 if (result < 0) {
137 goto fail;
138 }
139 #endif
140 return fd;
141
142 fail:
143 if (fd != -1) {
144 sys_errno = errno;
145 close(fd);
146 errno = sys_errno;
147 }
148 return -1;
149 }
150
151 static ssize_t tsocket_bsd_pending(int fd)
152 {
153 int ret;
154 int value = 0;
155
156 ret = ioctl(fd, FIONREAD, &value);
157 if (ret == -1) {
158 return ret;
159 }
160
161 if (ret == 0) {
162 if (value == 0) {
163 int error=0;
164 socklen_t len = sizeof(error);
165 /*
166 * if no data is available check if the socket
167 * is in error state. For dgram sockets
168 * it's the way to return ICMP error messages
169 * of connected sockets to the caller.
170 */
171 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR,
172 &error, &len);
173 if (ret == -1) {
174 return ret;
175 }
176 if (error != 0) {
177 errno = error;
178 return -1;
179 }
180 }
181 return value;
182 }
183
184 /* this should not be reached */
185 errno = EIO;
186 return -1;
187 }
188
189 static const struct tsocket_context_ops tsocket_context_bsd_ops;
190 static const struct tsocket_address_ops tsocket_address_bsd_ops;
191
192 static int tsocket_context_bsd_set_option(const struct tsocket_context *sock,
193 const char *option,
194 bool force,
195 const char *value);
196
197 struct tsocket_context_bsd {
198 bool close_on_disconnect;
199 int fd;
200 struct tevent_fd *fde;
201 };
202
203 struct tsocket_address_bsd {
204 bool broadcast;
205 union {
206 struct sockaddr sa;
207 struct sockaddr_in in;
208 #ifdef HAVE_IPV6
209 struct sockaddr_in6 in6;
210 #endif
211 struct sockaddr_un un;
212 struct sockaddr_storage ss;
213 } u;
214 };
215
216 static int _tsocket_address_bsd_from_sockaddr(TALLOC_CTX *mem_ctx,
217 struct sockaddr *sa,
218 socklen_t sa_len,
219 struct tsocket_address **_addr,
220 const char *location)
221 {
222 struct tsocket_address *addr;
223 struct tsocket_address_bsd *bsda;
224
225 switch (sa->sa_family) {
226 case AF_UNIX:
227 if (sa_len < sizeof(struct sockaddr_un)) {
228 errno = EINVAL;
229 return -1;
230 }
231 break;
232 case AF_INET:
233 if (sa_len < sizeof(struct sockaddr_in)) {
234 errno = EINVAL;
235 return -1;
236 }
237 break;
238 #ifdef HAVE_IPV6
239 case AF_INET6:
240 if (sa_len < sizeof(struct sockaddr_in6)) {
241 errno = EINVAL;
242 return -1;
243 }
244 break;
245 #endif
246 default:
247 errno = EAFNOSUPPORT;
248 return -1;
249 }
250
251 if (sa_len > sizeof(struct sockaddr_storage)) {
252 errno = EINVAL;
253 return -1;
254 }
255
256 addr = tsocket_address_create(mem_ctx,
257 &tsocket_address_bsd_ops,
258 &bsda,
259 struct tsocket_address_bsd,
260 location);
261 if (!addr) {
262 errno = ENOMEM;
263 return -1;
264 }
265
266 ZERO_STRUCTP(bsda);
267
268 memcpy(&bsda->u.ss, sa, sa_len);
269
270 *_addr = addr;
271 return 0;
272 }
273
274 int _tsocket_address_inet_from_strings(TALLOC_CTX *mem_ctx,
275 const char *fam,
276 const char *addr,
277 uint16_t port,
278 struct tsocket_address **_addr,
279 const char *location)
280 {
281 struct addrinfo hints;
282 struct addrinfo *result = NULL;
283 char port_str[6];
284 int ret;
285
286 ZERO_STRUCT(hints);
287 /*
288 * we use SOCKET_STREAM here to get just one result
289 * back from getaddrinfo().
290 */
291 hints.ai_socktype = SOCK_STREAM;
292 hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
293
294 if (strcasecmp(fam, "ip") == 0) {
295 hints.ai_family = AF_UNSPEC;
296 if (!addr) {
297 #ifdef HAVE_IPV6
298 addr = "::";
299 #else
300 addr = "0.0.0.0";
301 #endif
302 }
303 } else if (strcasecmp(fam, "ipv4") == 0) {
304 hints.ai_family = AF_INET;
305 if (!addr) {
306 addr = "0.0.0.0";
307 }
308 #ifdef HAVE_IPV6
309 } else if (strcasecmp(fam, "ipv6") == 0) {
310 hints.ai_family = AF_INET6;
311 if (!addr) {
312 addr = "::";
313 }
314 #endif
315 } else {
316 errno = EAFNOSUPPORT;
317 return -1;
318 }
319
320 snprintf(port_str, sizeof(port_str) - 1, "%u", port);
321
322 ret = getaddrinfo(addr, port_str, &hints, &result);
323 if (ret != 0) {
324 switch (ret) {
325 case EAI_FAIL:
326 errno = EINVAL;
327 break;
328 }
329 ret = -1;
330 goto done;
331 }
332
333 if (result->ai_socktype != SOCK_STREAM) {
334 errno = EINVAL;
335 ret = -1;
336 goto done;
337 }
338
339 ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
340 result->ai_addr,
341 result->ai_addrlen,
342 _addr,
343 location);
344
345 done:
346 if (result) {
347 freeaddrinfo(result);
348 }
349 return ret;
350 }
351
352 char *tsocket_address_inet_addr_string(const struct tsocket_address *addr,
353 TALLOC_CTX *mem_ctx)
354 {
355 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
356 struct tsocket_address_bsd);
357 char addr_str[INET6_ADDRSTRLEN+1];
358 const char *str;
359
360 if (!bsda) {
361 errno = EINVAL;
362 return NULL;
363 }
364
365 switch (bsda->u.sa.sa_family) {
366 case AF_INET:
367 str = inet_ntop(bsda->u.in.sin_family,
368 &bsda->u.in.sin_addr,
369 addr_str, sizeof(addr_str));
370 break;
371 #ifdef HAVE_IPV6
372 case AF_INET6:
373 str = inet_ntop(bsda->u.in6.sin6_family,
374 &bsda->u.in6.sin6_addr,
375 addr_str, sizeof(addr_str));
376 break;
377 #endif
378 default:
379 errno = EINVAL;
380 return NULL;
381 }
382
383 if (!str) {
384 return NULL;
385 }
386
387 return talloc_strdup(mem_ctx, str);
388 }
389
390 uint16_t tsocket_address_inet_port(const struct tsocket_address *addr)
391 {
392 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
393 struct tsocket_address_bsd);
394 uint16_t port = 0;
395
396 if (!bsda) {
397 errno = EINVAL;
398 return 0;
399 }
400
401 switch (bsda->u.sa.sa_family) {
402 case AF_INET:
403 port = ntohs(bsda->u.in.sin_port);
404 break;
405 #ifdef HAVE_IPV6
406 case AF_INET6:
407 port = ntohs(bsda->u.in6.sin6_port);
408 break;
409 #endif
410 default:
411 errno = EINVAL;
412 return 0;
413 }
414
415 return port;
416 }
417
418 int tsocket_address_inet_set_port(struct tsocket_address *addr,
419 uint16_t port)
420 {
421 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
422 struct tsocket_address_bsd);
423
424 if (!bsda) {
425 errno = EINVAL;
426 return -1;
427 }
428
429 switch (bsda->u.sa.sa_family) {
430 case AF_INET:
431 bsda->u.in.sin_port = htons(port);
432 break;
433 #ifdef HAVE_IPV6
434 case AF_INET6:
435 bsda->u.in6.sin6_port = htons(port);
436 break;
437 #endif
438 default:
439 errno = EINVAL;
440 return -1;
441 }
442
443 return 0;
444 }
445
446 void tsocket_address_inet_set_broadcast(struct tsocket_address *addr,
447 bool broadcast)
448 {
449 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
450 struct tsocket_address_bsd);
451
452 if (!bsda) {
453 return;
454 }
455
456 bsda->broadcast = broadcast;
457 }
458
459 int _tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
460 const char *path,
461 struct tsocket_address **_addr,
462 const char *location)
463 {
464 struct sockaddr_un un;
465 void *p = &un;
466 int ret;
467
468 if (!path) {
469 path = "";
470 }
471
472 ZERO_STRUCT(un);
473 un.sun_family = AF_UNIX;
474 strncpy(un.sun_path, path, sizeof(un.sun_path));
475
476 ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
477 (struct sockaddr *)p,
478 sizeof(un),
479 _addr,
480 location);
481
482 return ret;
483 }
484
485 char *tsocket_address_unix_path(const struct tsocket_address *addr,
486 TALLOC_CTX *mem_ctx)
487 {
488 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
489 struct tsocket_address_bsd);
490 const char *str;
491
492 if (!bsda) {
493 errno = EINVAL;
494 return NULL;
495 }
496
497 switch (bsda->u.sa.sa_family) {
498 case AF_UNIX:
499 str = bsda->u.un.sun_path;
500 break;
501 default:
502 errno = EINVAL;
503 return NULL;
504 }
505
506 return talloc_strdup(mem_ctx, str);
507 }
508
509 static char *tsocket_address_bsd_string(const struct tsocket_address *addr,
510 TALLOC_CTX *mem_ctx)
511 {
512 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
513 struct tsocket_address_bsd);
514 char *str;
515 char *addr_str;
516 const char *prefix = NULL;
517 uint16_t port;
518
519 switch (bsda->u.sa.sa_family) {
520 case AF_UNIX:
521 return talloc_asprintf(mem_ctx, "unix:%s",
522 bsda->u.un.sun_path);
523 case AF_INET:
524 prefix = "ipv4";
525 break;
526 #ifdef HAVE_IPV6
527 case AF_INET6:
528 prefix = "ipv6";
529 break;
530 #endif
531 default:
532 errno = EINVAL;
533 return NULL;
534 }
535
536 addr_str = tsocket_address_inet_addr_string(addr, mem_ctx);
537 if (!addr_str) {
538 return NULL;
539 }
540
541 port = tsocket_address_inet_port(addr);
542
543 str = talloc_asprintf(mem_ctx, "%s:%s:%u",
544 prefix, addr_str, port);
545 talloc_free(addr_str);
546
547 return str;
548 }
549
550 static struct tsocket_address *tsocket_address_bsd_copy(const struct tsocket_address *addr,
551 TALLOC_CTX *mem_ctx,
552 const char *location)
553 {
554 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
555 struct tsocket_address_bsd);
556 struct tsocket_address *copy;
557 int ret;
558
559 ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
560 &bsda->u.sa,
561 sizeof(bsda->u.ss),
562 &copy,
563 location);
564 if (ret != 0) {
565 return NULL;
566 }
567
568 tsocket_address_inet_set_broadcast(copy, bsda->broadcast);
569 return copy;
570 }
571
572 int _tsocket_context_bsd_wrap_existing(TALLOC_CTX *mem_ctx,
573 int fd, bool close_on_disconnect,
574 struct tsocket_context **_sock,
575 const char *location)
576 {
577 struct tsocket_context *sock;
578 struct tsocket_context_bsd *bsds;
579
580 sock = tsocket_context_create(mem_ctx,
581 &tsocket_context_bsd_ops,
582 &bsds,
583 struct tsocket_context_bsd,
584 location);
585 if (!sock) {
586 return -1;
587 }
588
589 bsds->close_on_disconnect = close_on_disconnect;
590 bsds->fd = fd;
591 bsds->fde = NULL;
592
593 *_sock = sock;
594 return 0;
595 }
596
597 static int tsocket_address_bsd_create_socket(const struct tsocket_address *addr,
598 enum tsocket_type type,
599 TALLOC_CTX *mem_ctx,
600 struct tsocket_context **_sock,
601 const char *location)
602 {
603 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
604 struct tsocket_address_bsd);
605 struct tsocket_context *sock;
606 int bsd_type;
607 int fd;
608 int ret;
609 bool do_bind = false;
610 bool do_reuseaddr = false;
611
612 switch (type) {
613 case TSOCKET_TYPE_STREAM:
614 if (bsda->broadcast) {
615 errno = EINVAL;
616 return -1;
617 }
618 bsd_type = SOCK_STREAM;
619 break;
620 default:
621 errno = EPROTONOSUPPORT;
622 return -1;
623 }
624
625 switch (bsda->u.sa.sa_family) {
626 case AF_UNIX:
627 if (bsda->broadcast) {
628 errno = EINVAL;
629 return -1;
630 }
631 if (bsda->u.un.sun_path[0] != 0) {
632 do_bind = true;
633 }
634 break;
635 case AF_INET:
636 if (bsda->u.in.sin_port != 0) {
637 do_reuseaddr = true;
638 do_bind = true;
639 }
640 if (bsda->u.in.sin_addr.s_addr == INADDR_ANY) {
641 do_bind = true;
642 }
643 break;
644 #ifdef HAVE_IPV6
645 case AF_INET6:
646 if (bsda->u.in6.sin6_port != 0) {
647 do_reuseaddr = true;
648 do_bind = true;
649 }
650 if (memcmp(&in6addr_any,
651 &bsda->u.in6.sin6_addr,
652 sizeof(in6addr_any)) != 0) {
653 do_bind = true;
654 }
655 break;
656 #endif
657 default:
658 errno = EINVAL;
659 return -1;
660 }
661
662 fd = socket(bsda->u.sa.sa_family, bsd_type, 0);
663 if (fd < 0) {
664 return fd;
665 }
666
667 fd = tsocket_common_prepare_fd(fd, true);
668 if (fd < 0) {
669 return fd;
670 }
671
672 ret = _tsocket_context_bsd_wrap_existing(mem_ctx, fd, true,
673 &sock, location);
674 if (ret != 0) {
675 int saved_errno = errno;
676 close(fd);
677 errno = saved_errno;
678 return ret;
679 }
680
681 if (bsda->broadcast) {
682 ret = tsocket_context_bsd_set_option(sock, "SO_BROADCAST", true, "1");
683 if (ret != 0) {
684 int saved_errno = errno;
685 talloc_free(sock);
686 errno = saved_errno;
687 return ret;
688 }
689 }
690
691 if (do_reuseaddr) {
692 ret = tsocket_context_bsd_set_option(sock, "SO_REUSEADDR", true, "1");
693 if (ret != 0) {
694 int saved_errno = errno;
695 talloc_free(sock);
696 errno = saved_errno;
697 return ret;
698 }
699 }
700
701 if (do_bind) {
702 ret = bind(fd, &bsda->u.sa, sizeof(bsda->u.ss));
703 if (ret != 0) {
704 int saved_errno = errno;
705 talloc_free(sock);
706 errno = saved_errno;
707 return ret;
708 }
709 }
710
711 *_sock = sock;
712 return 0;
713 }
714
715 static const struct tsocket_address_ops tsocket_address_bsd_ops = {
716 .name = "bsd",
717 .string = tsocket_address_bsd_string,
718 .copy = tsocket_address_bsd_copy,
719 .create_socket = tsocket_address_bsd_create_socket
720 };
721
722 static void tsocket_context_bsd_fde_handler(struct tevent_context *ev,
723 struct tevent_fd *fde,
724 uint16_t flags,
725 void *private_data)
726 {
727 struct tsocket_context *sock = talloc_get_type(private_data,
728 struct tsocket_context);
729
730 if (flags & TEVENT_FD_WRITE) {
731 sock->event.write_handler(sock, sock->event.write_private);
732 return;
733 }
734 if (flags & TEVENT_FD_READ) {
735 sock->event.read_handler(sock, sock->event.read_private);
736 return;
737 }
738 }
739
740 static int tsocket_context_bsd_set_event_context(struct tsocket_context *sock,
741 struct tevent_context *ev)
742 {
743 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
744 struct tsocket_context_bsd);
745
746 talloc_free(bsds->fde);
747 bsds->fde = NULL;
748 ZERO_STRUCT(sock->event);
749
750 if (!ev) {
751 return 0;
752 }
753
754 bsds->fde = tevent_add_fd(ev, bsds,
755 bsds->fd,
756 0,
757 tsocket_context_bsd_fde_handler,
758 sock);
759 if (!bsds->fde) {
760 if (errno == 0) {
761 errno = ENOMEM;
762 }
763 return -1;
764 }
765
766 sock->event.ctx = ev;
767
768 return 0;
769 }
770
771 static int tsocket_context_bsd_set_read_handler(struct tsocket_context *sock,
772 tsocket_event_handler_t handler,
773 void *private_data)
774 {
775 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
776 struct tsocket_context_bsd);
777
778 if (sock->event.read_handler && !handler) {
779 TEVENT_FD_NOT_READABLE(bsds->fde);
780 } else if (!sock->event.read_handler && handler) {
781 TEVENT_FD_READABLE(bsds->fde);
782 }
783
784 sock->event.read_handler = handler;
785 sock->event.read_private = private_data;
786
787 return 0;
788 }
789
790 static int tsocket_context_bsd_set_write_handler(struct tsocket_context *sock,
791 tsocket_event_handler_t handler,
792 void *private_data)
793 {
794 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
795 struct tsocket_context_bsd);
796
797 if (sock->event.write_handler && !handler) {
798 TEVENT_FD_NOT_WRITEABLE(bsds->fde);
799 } else if (!sock->event.write_handler && handler) {
800 TEVENT_FD_WRITEABLE(bsds->fde);
801 }
802
803 sock->event.write_handler = handler;
804 sock->event.write_private = private_data;
805
806 return 0;
807 }
808
809 static int tsocket_context_bsd_connect_to(struct tsocket_context *sock,
810 const struct tsocket_address *remote)
811 {
812 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
813 struct tsocket_context_bsd);
814 struct tsocket_address_bsd *bsda = talloc_get_type(remote->private_data,
815 struct tsocket_address_bsd);
816 int ret;
817
818 ret = connect(bsds->fd, &bsda->u.sa,
819 sizeof(bsda->u.ss));
820
821 return ret;
822 }
823
824 static int tsocket_context_bsd_listen_on(struct tsocket_context *sock,
825 int queue_size)
826 {
827 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
828 struct tsocket_context_bsd);
829 int ret;
830
831 ret = listen(bsds->fd, queue_size);
832
833 return ret;
834 }
835
836 static int tsocket_context_bsd_accept_new(struct tsocket_context *sock,
837 TALLOC_CTX *mem_ctx,
838 struct tsocket_context **_new_sock,
839 const char *location)
840 {
841 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
842 struct tsocket_context_bsd);
843 int new_fd;
844 struct tsocket_context *new_sock;
845 struct tsocket_context_bsd *new_bsds;
846 struct sockaddr_storage ss;
847 void *p = &ss;
848 socklen_t ss_len = sizeof(ss);
849
850 new_fd = accept(bsds->fd, (struct sockaddr *)p, &ss_len);
851 if (new_fd < 0) {
852 return new_fd;
853 }
854
855 new_fd = tsocket_common_prepare_fd(new_fd, true);
856 if (new_fd < 0) {
857 return new_fd;
858 }
859
860 new_sock = tsocket_context_create(mem_ctx,
861 &tsocket_context_bsd_ops,
862 &new_bsds,
863 struct tsocket_context_bsd,
864 location);
865 if (!new_sock) {
866 int saved_errno = errno;
867 close(new_fd);
868 errno = saved_errno;
869 return -1;
870 }
871
872 new_bsds->close_on_disconnect = true;
873 new_bsds->fd = new_fd;
874 new_bsds->fde = NULL;
875
876 *_new_sock = new_sock;
877 return 0;
878 }
879
880 static ssize_t tsocket_context_bsd_pending_data(struct tsocket_context *sock)
881 {
882 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
883 struct tsocket_context_bsd);
884 int ret;
885 int value = 0;
886
887 ret = ioctl(bsds->fd, FIONREAD, &value);
888 if (ret == -1) {
889 return ret;
890 }
891
892 if (ret == 0) {
893 if (value == 0) {
894 int error=0;
895 socklen_t len = sizeof(error);
896 /*
897 * if no data is available check if the socket
898 * is in error state. For dgram sockets
899 * it's the way to return ICMP error messages
900 * of connected sockets to the caller.
901 */
902 ret = getsockopt(bsds->fd, SOL_SOCKET, SO_ERROR,
903 &error, &len);
904 if (ret == -1) {
905 return ret;
906 }
907 if (error != 0) {
908 errno = error;
909 return -1;
910 }
911 }
912 return value;
913 }
914
915 /* this should not be reached */
916 errno = EIO;
917 return -1;
918 }
919
920 static int tsocket_context_bsd_readv_data(struct tsocket_context *sock,
921 const struct iovec *vector,
922 size_t count)
923 {
924 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
925 struct tsocket_context_bsd);
926 int ret;
927
928 ret = readv(bsds->fd, vector, count);
929
930 return ret;
931 }
932
933 static int tsocket_context_bsd_writev_data(struct tsocket_context *sock,
934 const struct iovec *vector,
935 size_t count)
936 {
937 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
938 struct tsocket_context_bsd);
939 int ret;
940
941 ret = writev(bsds->fd, vector, count);
942
943 return ret;
944 }
945
946 static int tsocket_context_bsd_get_status(const struct tsocket_context *sock)
947 {
948 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
949 struct tsocket_context_bsd);
950 int ret;
951 int error=0;
952 socklen_t len = sizeof(error);
953
954 if (bsds->fd == -1) {
955 errno = EPIPE;
956 return -1;
957 }
958
959 ret = getsockopt(bsds->fd, SOL_SOCKET, SO_ERROR, &error, &len);
960 if (ret == -1) {
961 return ret;
962 }
963 if (error != 0) {
964 errno = error;
965 return -1;
966 }
967
968 return 0;
969 }
970
971 static int tsocket_context_bsd_get_local_address(const struct tsocket_context *sock,
972 TALLOC_CTX *mem_ctx,
973 struct tsocket_address **_addr,
974 const char *location)
975 {
976 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
977 struct tsocket_context_bsd);
978 struct tsocket_address *addr;
979 struct tsocket_address_bsd *bsda;
980 ssize_t ret;
981 socklen_t sa_len;
982
983 addr = tsocket_address_create(mem_ctx,
984 &tsocket_address_bsd_ops,
985 &bsda,
986 struct tsocket_address_bsd,
987 location);
988 if (!addr) {
989 return -1;
990 }
991
992 ZERO_STRUCTP(bsda);
993
994 sa_len = sizeof(bsda->u.ss);
995 ret = getsockname(bsds->fd, &bsda->u.sa, &sa_len);
996 if (ret < 0) {
997 int saved_errno = errno;
998 talloc_free(addr);
999 errno = saved_errno;
1000 return ret;
1001 }
1002
1003 *_addr = addr;
1004 return 0;
1005 }
1006
1007 static int tsocket_context_bsd_get_remote_address(const struct tsocket_context *sock,
1008 TALLOC_CTX *mem_ctx,
1009 struct tsocket_address **_addr,
1010 const char *location)
1011 {
1012 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
1013 struct tsocket_context_bsd);
1014 struct tsocket_address *addr;
1015 struct tsocket_address_bsd *bsda;
1016 ssize_t ret;
1017 socklen_t sa_len;
1018
1019 addr = tsocket_address_create(mem_ctx,
1020 &tsocket_address_bsd_ops,
1021 &bsda,
1022 struct tsocket_address_bsd,
1023 location);
1024 if (!addr) {
1025 return -1;
1026 }
1027
1028 ZERO_STRUCTP(bsda);
1029
1030 sa_len = sizeof(bsda->u.ss);
1031 ret = getpeername(bsds->fd, &bsda->u.sa, &sa_len);
1032 if (ret < 0) {
1033 int saved_errno = errno;
1034 talloc_free(addr);
1035 errno = saved_errno;
1036 return ret;
1037 }
1038
1039 *_addr = addr;
1040 return 0;
1041 }
1042
1043 static const struct tsocket_context_bsd_option {
1044 const char *name;
1045 int level;
1046 int optnum;
1047 int optval;
1048 } tsocket_context_bsd_options[] = {
1049 #define TSOCKET_OPTION(_level, _optnum, _optval) { \
1050 .name = #_optnum, \
1051 .level = _level, \
1052 .optnum = _optnum, \
1053 .optval = _optval \
1054 }
1055 TSOCKET_OPTION(SOL_SOCKET, SO_REUSEADDR, 0),
1056 TSOCKET_OPTION(SOL_SOCKET, SO_BROADCAST, 0)
1057 };
1058
1059 static int tsocket_context_bsd_get_option(const struct tsocket_context *sock,
1060 const char *option,
1061 TALLOC_CTX *mem_ctx,
1062 char **_value)
1063 {
1064 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
1065 struct tsocket_context_bsd);
1066 const struct tsocket_context_bsd_option *opt = NULL;
1067 uint32_t i;
1068 int optval;
1069 socklen_t optval_len = sizeof(optval);
1070 char *value;
1071 int ret;
1072
1073 for (i=0; i < ARRAY_SIZE(tsocket_context_bsd_options); i++) {
1074 if (strcmp(option, tsocket_context_bsd_options[i].name) != 0) {
1075 continue;
1076 }
1077
1078 opt = &tsocket_context_bsd_options[i];
1079 break;
1080 }
1081
1082 if (!opt) {
1083 goto nosys;
1084 }
1085
1086 ret = getsockopt(bsds->fd, opt->level, opt->optnum,
1087 (void *)&optval, &optval_len);
1088 if (ret != 0) {
1089 return ret;
1090 }
1091
1092 if (optval_len != sizeof(optval)) {
1093 value = NULL;
1094 } if (opt->optval != 0) {
1095 if (optval == opt->optval) {
1096 value = talloc_strdup(mem_ctx, "1");
1097 } else {
1098 value = talloc_strdup(mem_ctx, "0");
1099 }
1100 if (!value) {
1101 goto nomem;
1102 }
1103 } else {
1104 value = talloc_asprintf(mem_ctx, "%d", optval);
1105 if (!value) {
1106 goto nomem;
1107 }
1108 }
1109
1110 *_value = value;
1111 return 0;
1112
1113 nomem:
1114 errno = ENOMEM;
1115 return -1;
1116 nosys:
1117 errno = ENOSYS;
1118 return -1;
1119 }
1120
1121 static int tsocket_context_bsd_set_option(const struct tsocket_context *sock,
1122 const char *option,
1123 bool force,
1124 const char *value)
1125 {
1126 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
1127 struct tsocket_context_bsd);
1128 const struct tsocket_context_bsd_option *opt = NULL;
1129 uint32_t i;
1130 int optval;
1131 int ret;
1132
1133 for (i=0; i < ARRAY_SIZE(tsocket_context_bsd_options); i++) {
1134 if (strcmp(option, tsocket_context_bsd_options[i].name) != 0) {
1135 continue;
1136 }
1137
1138 opt = &tsocket_context_bsd_options[i];
1139 break;
1140 }
1141
1142 if (!opt) {
1143 goto nosys;
1144 }
1145
1146 if (value) {
1147 if (opt->optval != 0) {
1148 errno = EINVAL;
1149 return -1;
1150 }
1151
1152 optval = atoi(value);
1153 } else {
1154 optval = opt->optval;
1155 }
1156
1157 ret = setsockopt(bsds->fd, opt->level, opt->optnum,
1158 (const void *)&optval, sizeof(optval));
1159 if (ret != 0) {
1160 if (!force) {
1161 errno = 0;
1162 return 0;
1163 }
1164 return ret;
1165 }
1166
1167 return 0;
1168
1169 nosys:
1170 if (!force) {
1171 return 0;
1172 }
1173
1174 errno = ENOSYS;
1175 return -1;
1176 }
1177
1178 static void tsocket_context_bsd_disconnect(struct tsocket_context *sock)
1179 {
1180 struct tsocket_context_bsd *bsds = talloc_get_type(sock->private_data,
1181 struct tsocket_context_bsd);
1182
1183 tsocket_context_bsd_set_event_context(sock, NULL);
1184
1185 if (bsds->fd != -1) {
1186 if (bsds->close_on_disconnect) {
1187 close(bsds->fd);
1188 }
1189 bsds->fd = -1;
1190 }
1191 }
1192
1193 static const struct tsocket_context_ops tsocket_context_bsd_ops = {
1194 .name = "bsd",
1195
1196 .set_event_context = tsocket_context_bsd_set_event_context,
1197 .set_read_handler = tsocket_context_bsd_set_read_handler,
1198 .set_write_handler = tsocket_context_bsd_set_write_handler,
1199
1200 .connect_to = tsocket_context_bsd_connect_to,
1201 .listen_on = tsocket_context_bsd_listen_on,
1202 .accept_new = tsocket_context_bsd_accept_new,
1203
1204 .pending_data = tsocket_context_bsd_pending_data,
1205 .readv_data = tsocket_context_bsd_readv_data,
1206 .writev_data = tsocket_context_bsd_writev_data,
1207
1208 .get_status = tsocket_context_bsd_get_status,
1209 .get_local_address = tsocket_context_bsd_get_local_address,
1210 .get_remote_address = tsocket_context_bsd_get_remote_address,
1211
1212 .get_option = tsocket_context_bsd_get_option,
1213 .set_option = tsocket_context_bsd_set_option,
1214
1215 .disconnect = tsocket_context_bsd_disconnect
1216 };
1217
1218 struct tdgram_bsd {
1219 int fd;
1220
1221 void *event_ptr;
1222 struct tevent_fd *fde;
1223
1224 void *readable_private;
1225 void (*readable_handler)(void *private_data);
1226 void *writeable_private;
1227 void (*writeable_handler)(void *private_data);
1228
1229 struct tevent_req *read_req;
1230 struct tevent_req *write_req;
1231 };
1232
1233 static void tdgram_bsd_fde_handler(struct tevent_context *ev,
1234 struct tevent_fd *fde,
1235 uint16_t flags,
1236 void *private_data)
1237 {
1238 struct tdgram_bsd *bsds = talloc_get_type_abort(private_data,
1239 struct tdgram_bsd);
1240
1241 if (flags & TEVENT_FD_WRITE) {
1242 bsds->writeable_handler(bsds->writeable_private);
1243 return;
1244 }
1245 if (flags & TEVENT_FD_READ) {
1246 if (!bsds->readable_handler) {
1247 TEVENT_FD_NOT_READABLE(bsds->fde);
1248 return;
1249 }
1250 bsds->readable_handler(bsds->readable_private);
1251 return;
1252 }
1253 }
1254
1255 static int tdgram_bsd_set_readable_handler(struct tdgram_bsd *bsds,
1256 struct tevent_context *ev,
1257 void (*handler)(void *private_data),
1258 void *private_data)
1259 {
1260 if (ev == NULL) {
1261 if (handler) {
1262 errno = EINVAL;
1263 return -1;
1264 }
1265 if (!bsds->readable_handler) {
1266 return 0;
1267 }
1268 bsds->readable_handler = NULL;
1269 bsds->readable_private = NULL;
1270
1271 return 0;
1272 }
1273
1274 /* read and write must use the same tevent_context */
1275 if (bsds->event_ptr != ev) {
1276 if (bsds->readable_handler || bsds->writeable_handler) {
1277 errno = EINVAL;
1278 return -1;
1279 }
1280 bsds->event_ptr = NULL;
1281 TALLOC_FREE(bsds->fde);
1282 }
1283
1284 if (bsds->fde == NULL) {
1285 bsds->fde = tevent_add_fd(ev, bsds,
1286 bsds->fd, TEVENT_FD_READ,
1287 tdgram_bsd_fde_handler,
1288 bsds);
1289 if (!bsds->fde) {
1290 return -1;
1291 }
1292
1293 /* cache the event context we're running on */
1294 bsds->event_ptr = ev;
1295 } else if (!bsds->readable_handler) {
1296 TEVENT_FD_READABLE(bsds->fde);
1297 }
1298
1299 bsds->readable_handler = handler;
1300 bsds->readable_private = private_data;
1301
1302 return 0;
1303 }
1304
1305 static int tdgram_bsd_set_writeable_handler(struct tdgram_bsd *bsds,
1306 struct tevent_context *ev,
1307 void (*handler)(void *private_data),
1308 void *private_data)
1309 {
1310 if (ev == NULL) {
1311 if (handler) {
1312 errno = EINVAL;
1313 return -1;
1314 }
1315 if (!bsds->writeable_handler) {
1316 return 0;
1317 }
1318 bsds->writeable_handler = NULL;
1319 bsds->writeable_private = NULL;
1320 TEVENT_FD_NOT_WRITEABLE(bsds->fde);
1321
1322 return 0;
1323 }
1324
1325 /* read and write must use the same tevent_context */
1326 if (bsds->event_ptr != ev) {
1327 if (bsds->readable_handler || bsds->writeable_handler) {
1328 errno = EINVAL;
1329 return -1;
1330 }
1331 bsds->event_ptr = NULL;
1332 TALLOC_FREE(bsds->fde);
1333 }
1334
1335 if (bsds->fde == NULL) {
1336 bsds->fde = tevent_add_fd(ev, bsds,
1337 bsds->fd, TEVENT_FD_WRITE,
1338 tdgram_bsd_fde_handler,
1339 bsds);
1340 if (!bsds->fde) {
1341 return -1;
1342 }
1343
1344 /* cache the event context we're running on */
1345 bsds->event_ptr = ev;
1346 } else if (!bsds->writeable_handler) {
1347 TEVENT_FD_WRITEABLE(bsds->fde);
1348 }
1349
1350 bsds->writeable_handler = handler;
1351 bsds->writeable_private = private_data;
1352
1353 return 0;
1354 }
1355
1356 struct tdgram_bsd_recvfrom_state {
1357 struct tdgram_context *dgram;
1358
1359 uint8_t *buf;
1360 size_t len;
1361 struct tsocket_address *src;
1362 };
1363
1364 static int tdgram_bsd_recvfrom_destructor(struct tdgram_bsd_recvfrom_state *state)
1365 {
1366 struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
1367 struct tdgram_bsd);
1368
1369 bsds->read_req = NULL;
1370 tdgram_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
1371
1372 return 0;
1373 }
1374
1375 static void tdgram_bsd_recvfrom_handler(void *private_data);
1376
1377 static struct tevent_req *tdgram_bsd_recvfrom_send(TALLOC_CTX *mem_ctx,
1378 struct tevent_context *ev,
1379 struct tdgram_context *dgram)
1380 {
1381 struct tevent_req *req;
1382 struct tdgram_bsd_recvfrom_state *state;
1383 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1384 int ret;
1385
1386 req = tevent_req_create(mem_ctx, &state,
1387 struct tdgram_bsd_recvfrom_state);
1388 if (!req) {
1389 return NULL;
1390 }
1391
1392 state->dgram = dgram;
1393 state->buf = NULL;
1394 state->len = 0;
1395 state->src = NULL;
1396
1397 if (bsds->read_req) {
1398 tevent_req_error(req, EBUSY);
1399 goto post;
1400 }
1401 bsds->read_req = req;
1402
1403 talloc_set_destructor(state, tdgram_bsd_recvfrom_destructor);
1404
1405 if (bsds->fd == -1) {
1406 tevent_req_error(req, ENOTCONN);
1407 goto post;
1408 }
1409
1410 /*
1411 * this is a fast path, not waiting for the
1412 * socket to become explicit readable gains
1413 * about 10%-20% performance in benchmark tests.
1414 */
1415 tdgram_bsd_recvfrom_handler(req);
1416 if (!tevent_req_is_in_progress(req)) {
1417 goto post;
1418 }
1419
1420 ret = tdgram_bsd_set_readable_handler(bsds, ev,
1421 tdgram_bsd_recvfrom_handler,
1422 req);
1423 if (ret == -1) {
1424 tevent_req_error(req, errno);
1425 goto post;
1426 }
1427
1428 return req;
1429
1430 post:
1431 tevent_req_post(req, ev);
1432 return req;
1433 }
1434
1435 static void tdgram_bsd_recvfrom_handler(void *private_data)
1436 {
1437 struct tevent_req *req = talloc_get_type_abort(private_data,
1438 struct tevent_req);
1439 struct tdgram_bsd_recvfrom_state *state = tevent_req_data(req,
1440 struct tdgram_bsd_recvfrom_state);
1441 struct tdgram_context *dgram = state->dgram;
1442 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1443 struct tsocket_address_bsd *bsda;
1444 ssize_t ret;
1445 struct sockaddr *sa = NULL;
1446 socklen_t sa_len = 0;
1447 int err;
1448 bool retry;
1449
1450 ret = tsocket_bsd_pending(bsds->fd);
1451 if (ret == 0) {
1452 /* retry later */
1453 return;
1454 }
1455 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
1456 if (retry) {
1457 /* retry later */
1458 return;
1459 }
1460 if (tevent_req_error(req, err)) {
1461 return;
1462 }
1463
1464 state->buf = talloc_array(state, uint8_t, ret);
1465 if (tevent_req_nomem(state->buf, req)) {
1466 return;
1467 }
1468 state->len = ret;
1469
1470 state->src = tsocket_address_create(state,
1471 &tsocket_address_bsd_ops,
1472 &bsda,
1473 struct tsocket_address_bsd,
1474 __location__ "bsd_recvfrom");
1475 if (tevent_req_nomem(state->src, req)) {
1476 return;
1477 }
1478
1479 ZERO_STRUCTP(bsda);
1480
1481 sa = &bsda->u.sa;
1482 sa_len = sizeof(bsda->u.ss);
1483
1484 ret = recvfrom(bsds->fd, state->buf, state->len, 0, sa, &sa_len);
1485 err = tsocket_error_from_errno(ret, errno, &retry);
1486 if (retry) {
1487 /* retry later */
1488 return;
1489 }
1490 if (tevent_req_error(req, err)) {
1491 return;
1492 }
1493
1494 if (ret != state->len) {
1495 tevent_req_error(req, EIO);
1496 return;
1497 }
1498
1499 tevent_req_done(req);
1500 }
1501
1502 static ssize_t tdgram_bsd_recvfrom_recv(struct tevent_req *req,
1503 int *perrno,
1504 TALLOC_CTX *mem_ctx,
1505 uint8_t **buf,
1506 struct tsocket_address **src)
1507 {
1508 struct tdgram_bsd_recvfrom_state *state = tevent_req_data(req,
1509 struct tdgram_bsd_recvfrom_state);
1510 ssize_t ret;
1511
1512 ret = tsocket_simple_int_recv(req, perrno);
1513 if (ret == 0) {
1514 *buf = talloc_move(mem_ctx, &state->buf);
1515 ret = state->len;
1516 if (src) {
1517 *src = talloc_move(mem_ctx, &state->src);
1518 }
1519 }
1520
1521 tevent_req_received(req);
1522 return ret;
1523 }
1524
1525 struct tdgram_bsd_sendto_state {
1526 struct tdgram_context *dgram;
1527
1528 const uint8_t *buf;
1529 size_t len;
1530 const struct tsocket_address *dst;
1531
1532 ssize_t ret;
1533 };
1534
1535 static int tdgram_bsd_sendto_destructor(struct tdgram_bsd_sendto_state *state)
1536 {
1537 struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
1538 struct tdgram_bsd);
1539
1540 bsds->write_req = NULL;
1541 tdgram_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
1542 return 0;
1543 }
1544
1545 static void tdgram_bsd_sendto_handler(void *private_data);
1546
1547 static struct tevent_req *tdgram_bsd_sendto_send(TALLOC_CTX *mem_ctx,
1548 struct tevent_context *ev,
1549 struct tdgram_context *dgram,
1550 const uint8_t *buf,
1551 size_t len,
1552 const struct tsocket_address *dst)
1553 {
1554 struct tevent_req *req;
1555 struct tdgram_bsd_sendto_state *state;
1556 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1557 int ret;
1558
1559 req = tevent_req_create(mem_ctx, &state,
1560 struct tdgram_bsd_sendto_state);
1561 if (!req) {
1562 return NULL;
1563 }
1564
1565 state->dgram = dgram;
1566 state->buf = buf;
1567 state->len = len;
1568 state->dst = dst;
1569 state->ret = -1;
1570
1571 if (bsds->write_req) {
1572 tevent_req_error(req, EBUSY);
1573 goto post;
1574 }
1575 bsds->write_req = req;
1576
1577 talloc_set_destructor(state, tdgram_bsd_sendto_destructor);
1578
1579 if (bsds->fd == -1) {
1580 tevent_req_error(req, ENOTCONN);
1581 goto post;
1582 }
1583
1584 /*
1585 * this is a fast path, not waiting for the
1586 * socket to become explicit writeable gains
1587 * about 10%-20% performance in benchmark tests.
1588 */
1589 tdgram_bsd_sendto_handler(req);
1590 if (!tevent_req_is_in_progress(req)) {
1591 goto post;
1592 }
1593
1594 ret = tdgram_bsd_set_writeable_handler(bsds, ev,
1595 tdgram_bsd_sendto_handler,
1596 req);
1597 if (ret == -1) {
1598 tevent_req_error(req, errno);
1599 goto post;
1600 }
1601
1602 return req;
1603
1604 post:
1605 tevent_req_post(req, ev);
1606 return req;
1607 }
1608
1609 static void tdgram_bsd_sendto_handler(void *private_data)
1610 {
1611 struct tevent_req *req = talloc_get_type_abort(private_data,
1612 struct tevent_req);
1613 struct tdgram_bsd_sendto_state *state = tevent_req_data(req,
1614 struct tdgram_bsd_sendto_state);
1615 struct tdgram_context *dgram = state->dgram;
1616 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1617 struct sockaddr *sa = NULL;
1618 socklen_t sa_len = 0;
1619 ssize_t ret;
1620 int err;
1621 bool retry;
1622
1623 if (state->dst) {
1624 struct tsocket_address_bsd *bsda =
1625 talloc_get_type(state->dst->private_data,
1626 struct tsocket_address_bsd);
1627
1628 sa = &bsda->u.sa;
1629 sa_len = sizeof(bsda->u.ss);
1630 }
1631
1632 ret = sendto(bsds->fd, state->buf, state->len, 0, sa, sa_len);
1633 err = tsocket_error_from_errno(ret, errno, &retry);
1634 if (retry) {
1635 /* retry later */
1636 return;
1637 }
1638 if (tevent_req_error(req, err)) {
1639 return;
1640 }
1641
1642 state->ret = ret;
1643
1644 tevent_req_done(req);
1645 }
1646
1647 static ssize_t tdgram_bsd_sendto_recv(struct tevent_req *req, int *perrno)
1648 {
1649 struct tdgram_bsd_sendto_state *state = tevent_req_data(req,
1650 struct tdgram_bsd_sendto_state);
1651 ssize_t ret;
1652
1653 ret = tsocket_simple_int_recv(req, perrno);
1654 if (ret == 0) {
1655 ret = state->ret;
1656 }
1657
1658 tevent_req_received(req);
1659 return ret;
1660 }
1661
1662 struct tdgram_bsd_disconnect_state {
1663 uint8_t __dummy;
1664 };
1665
1666 static struct tevent_req *tdgram_bsd_disconnect_send(TALLOC_CTX *mem_ctx,
1667 struct tevent_context *ev,
1668 struct tdgram_context *dgram)
1669 {
1670 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1671 struct tevent_req *req;
1672 struct tdgram_bsd_disconnect_state *state;
1673 int ret;
1674 int err;
1675 bool dummy;
1676
1677 req = tevent_req_create(mem_ctx, &state,
1678 struct tdgram_bsd_disconnect_state);
1679 if (req == NULL) {
1680 return NULL;
1681 }
1682
1683 if (bsds->read_req || bsds->write_req) {
1684 tevent_req_error(req, EBUSY);
1685 goto post;
1686 }
1687
1688 if (bsds->fd == -1) {
1689 tevent_req_error(req, ENOTCONN);
1690 goto post;
1691 }
1692
1693 ret = close(bsds->fd);
1694 bsds->fd = -1;
1695 err = tsocket_error_from_errno(ret, errno, &dummy);
1696 if (tevent_req_error(req, err)) {
1697 goto post;
1698 }
1699
1700 tevent_req_done(req);
1701 post:
1702 tevent_req_post(req, ev);
1703 return req;
1704 }
1705
1706 static int tdgram_bsd_disconnect_recv(struct tevent_req *req,
1707 int *perrno)
1708 {
1709 int ret;
1710
1711 ret = tsocket_simple_int_recv(req, perrno);
1712
1713 tevent_req_received(req);
1714 return ret;
1715 }
1716
1717 static const struct tdgram_context_ops tdgram_bsd_ops = {
1718 .name = "bsd",
1719
1720 .recvfrom_send = tdgram_bsd_recvfrom_send,
1721 .recvfrom_recv = tdgram_bsd_recvfrom_recv,
1722
1723 .sendto_send = tdgram_bsd_sendto_send,
1724 .sendto_recv = tdgram_bsd_sendto_recv,
1725
1726 .disconnect_send = tdgram_bsd_disconnect_send,
1727 .disconnect_recv = tdgram_bsd_disconnect_recv,
1728 };
1729
1730 static int tdgram_bsd_destructor(struct tdgram_bsd *bsds)
1731 {
1732 TALLOC_FREE(bsds->fde);
1733 if (bsds->fd != -1) {
1734 close(bsds->fd);
1735 bsds->fd = -1;
1736 }
1737 return 0;
1738 }
1739
1740 static int tdgram_bsd_dgram_socket(const struct tsocket_address *local,
1741 const struct tsocket_address *remote,
1742 TALLOC_CTX *mem_ctx,
1743 struct tdgram_context **_dgram,
1744 const char *location)
1745 {
1746 struct tsocket_address_bsd *lbsda =
1747 talloc_get_type_abort(local->private_data,
1748 struct tsocket_address_bsd);
1749 struct tsocket_address_bsd *rbsda = NULL;
1750 struct tdgram_context *dgram;
1751 struct tdgram_bsd *bsds;
1752 int fd;
1753 int ret;
1754 bool do_bind = false;
1755 bool do_reuseaddr = false;
1756
1757 if (remote) {
1758 rbsda = talloc_get_type_abort(remote->private_data,
1759 struct tsocket_address_bsd);
1760 }
1761
1762 switch (lbsda->u.sa.sa_family) {
1763 case AF_UNIX:
1764 if (lbsda->u.un.sun_path[0] != 0) {
1765 do_reuseaddr = true;
1766 do_bind = true;
1767 }
1768 break;
1769 case AF_INET:
1770 if (lbsda->u.in.sin_port != 0) {
1771 do_reuseaddr = true;
1772 do_bind = true;
1773 }
1774 if (lbsda->u.in.sin_addr.s_addr == INADDR_ANY) {
1775 do_bind = true;
1776 }
1777 break;
1778 #ifdef HAVE_IPV6
1779 case AF_INET6:
1780 if (lbsda->u.in6.sin6_port != 0) {
1781 do_reuseaddr = true;
1782 do_bind = true;
1783 }
1784 if (memcmp(&in6addr_any,
1785 &lbsda->u.in6.sin6_addr,
1786 sizeof(in6addr_any)) != 0) {
1787 do_bind = true;
1788 }
1789 break;
1790 #endif
1791 default:
1792 errno = EINVAL;
1793 return -1;
1794 }
1795
1796 fd = socket(lbsda->u.sa.sa_family, SOCK_DGRAM, 0);
1797 if (fd < 0) {
1798 return fd;
1799 }
1800
1801 fd = tsocket_bsd_common_prepare_fd(fd, true);
1802 if (fd < 0) {
1803 return fd;
1804 }
1805
1806 dgram = tdgram_context_create(mem_ctx,
1807 &tdgram_bsd_ops,
1808 &bsds,
1809 struct tdgram_bsd,
1810 location);
1811 if (!dgram) {
1812 int saved_errno = errno;
1813 close(fd);
1814 errno = saved_errno;
1815 return -1;
1816 }
1817 ZERO_STRUCTP(bsds);
1818 bsds->fd = fd;
1819 talloc_set_destructor(bsds, tdgram_bsd_destructor);
1820
1821 if (lbsda->broadcast) {
1822 int val = 1;
1823
1824 ret = setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
1825 (const void *)&val, sizeof(val));
1826 if (ret == -1) {
1827 int saved_errno = errno;
1828 talloc_free(dgram);
1829 errno = saved_errno;
1830 return ret;
1831 }
1832 }
1833
1834 if (do_reuseaddr) {
1835 int val = 1;
1836
1837 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1838 (const void *)&val, sizeof(val));
1839 if (ret == -1) {
1840 int saved_errno = errno;
1841 talloc_free(dgram);
1842 errno = saved_errno;
1843 return ret;
1844 }
1845 }
1846
1847 if (do_bind) {
1848 ret = bind(fd, &lbsda->u.sa, sizeof(lbsda->u.ss));
1849 if (ret == -1) {
1850 int saved_errno = errno;
1851 talloc_free(dgram);
1852 errno = saved_errno;
1853 return ret;
1854 }
1855 }
1856
1857 if (rbsda) {
1858 ret = connect(fd, &rbsda->u.sa, sizeof(rbsda->u.ss));
1859 if (ret == -1) {
1860 int saved_errno = errno;
1861 talloc_free(dgram);
1862 errno = saved_errno;
1863 return ret;
1864 }
1865 }
1866
1867 *_dgram = dgram;
1868 return 0;
1869 }
1870
1871 int _tdgram_inet_udp_socket(const struct tsocket_address *local,
1872 const struct tsocket_address *remote,
1873 TALLOC_CTX *mem_ctx,
1874 struct tdgram_context **dgram,
1875 const char *location)
1876 {
1877 struct tsocket_address_bsd *lbsda =
1878 talloc_get_type_abort(local->private_data,
1879 struct tsocket_address_bsd);
1880 int ret;
1881
1882 switch (lbsda->u.sa.sa_family) {
1883 case AF_INET:
1884 break;
1885 #ifdef HAVE_IPV6
1886 case AF_INET6:
1887 break;
1888 #endif
1889 default:
1890 errno = EINVAL;
1891 return -1;
1892 }
1893
1894 ret = tdgram_bsd_dgram_socket(local, remote, mem_ctx, dgram, location);
1895
1896 return ret;
1897 }
1898
1899 int _tdgram_unix_dgram_socket(const struct tsocket_address *local,
1900 const struct tsocket_address *remote,
1901 TALLOC_CTX *mem_ctx,
1902 struct tdgram_context **dgram,
1903 const char *location)
1904 {
1905 struct tsocket_address_bsd *lbsda =
1906 talloc_get_type_abort(local->private_data,
1907 struct tsocket_address_bsd);
1908 int ret;
1909
1910 switch (lbsda->u.sa.sa_family) {
1911 case AF_UNIX:
1912 break;
1913 default:
1914 errno = EINVAL;
1915 return -1;
1916 }
1917
1918 ret = tdgram_bsd_dgram_socket(local, remote, mem_ctx, dgram, location);
1919
1920 return ret;
1921 }
1922