source: vendor/current/lib/tsocket/tsocket_bsd.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 52.2 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 Copyright (C) Stefan Metzmacher 2009
5
6 ** NOTE! The following LGPL license applies to the tsocket
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 "tsocket.h"
28#include "tsocket_internal.h"
29#include "lib/util/iov_buf.h"
30#include "lib/util/blocking.h"
31
32static int tsocket_bsd_error_from_errno(int ret,
33 int sys_errno,
34 bool *retry)
35{
36 *retry = false;
37
38 if (ret >= 0) {
39 return 0;
40 }
41
42 if (ret != -1) {
43 return EIO;
44 }
45
46 if (sys_errno == 0) {
47 return EIO;
48 }
49
50 if (sys_errno == EINTR) {
51 *retry = true;
52 return sys_errno;
53 }
54
55 if (sys_errno == EINPROGRESS) {
56 *retry = true;
57 return sys_errno;
58 }
59
60 if (sys_errno == EAGAIN) {
61 *retry = true;
62 return sys_errno;
63 }
64
65 /* ENOMEM is retryable on Solaris/illumos, and possibly other systems. */
66 if (sys_errno == ENOMEM) {
67 *retry = true;
68 return sys_errno;
69 }
70
71#ifdef EWOULDBLOCK
72 if (sys_errno == EWOULDBLOCK) {
73 *retry = true;
74 return sys_errno;
75 }
76#endif
77
78 return sys_errno;
79}
80
81static int tsocket_bsd_common_prepare_fd(int fd, bool high_fd)
82{
83 int i;
84 int sys_errno = 0;
85 int fds[3];
86 int num_fds = 0;
87
88 int result;
89 bool ok;
90
91 if (fd == -1) {
92 return -1;
93 }
94
95 /* first make a fd >= 3 */
96 if (high_fd) {
97 while (fd < 3) {
98 fds[num_fds++] = fd;
99 fd = dup(fd);
100 if (fd == -1) {
101 sys_errno = errno;
102 break;
103 }
104 }
105 for (i=0; i<num_fds; i++) {
106 close(fds[i]);
107 }
108 if (fd == -1) {
109 errno = sys_errno;
110 return fd;
111 }
112 }
113
114 result = set_blocking(fd, false);
115 if (result == -1) {
116 goto fail;
117 }
118
119 ok = smb_set_close_on_exec(fd);
120 if (!ok) {
121 goto fail;
122 }
123
124 return fd;
125
126 fail:
127 if (fd != -1) {
128 sys_errno = errno;
129 close(fd);
130 errno = sys_errno;
131 }
132 return -1;
133}
134
135#ifdef HAVE_LINUX_RTNETLINK_H
136/**
137 * Get the amount of pending bytes from a netlink socket
138 *
139 * For some reason netlink sockets don't support querying the amount of pending
140 * data via ioctl with FIONREAD, which is what we use in tsocket_bsd_pending()
141 * below.
142 *
143 * We know we are on Linux as we're using netlink, which means we have a working
144 * MSG_TRUNC flag to recvmsg() as well, so we use that together with MSG_PEEK.
145 **/
146static ssize_t tsocket_bsd_netlink_pending(int fd)
147{
148 struct iovec iov;
149 struct msghdr msg;
150 char buf[1];
151
152 iov = (struct iovec) {
153 .iov_base = buf,
154 .iov_len = sizeof(buf)
155 };
156
157 msg = (struct msghdr) {
158 .msg_iov = &iov,
159 .msg_iovlen = 1
160 };
161
162 return recvmsg(fd, &msg, MSG_PEEK | MSG_TRUNC);
163}
164#else
165static ssize_t tsocket_bsd_netlink_pending(int fd)
166{
167 errno = ENOSYS;
168 return -1;
169}
170#endif
171
172static ssize_t tsocket_bsd_pending(int fd)
173{
174 int ret, error;
175 int value = 0;
176 socklen_t len;
177
178 ret = ioctl(fd, FIONREAD, &value);
179 if (ret == -1) {
180 return ret;
181 }
182
183 if (ret != 0) {
184 /* this should not be reached */
185 errno = EIO;
186 return -1;
187 }
188
189 if (value != 0) {
190 return value;
191 }
192
193 error = 0;
194 len = sizeof(error);
195
196 /*
197 * if no data is available check if the socket is in error state. For
198 * dgram sockets it's the way to return ICMP error messages of
199 * connected sockets to the caller.
200 */
201 ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
202 if (ret == -1) {
203 return ret;
204 }
205 if (error != 0) {
206 errno = error;
207 return -1;
208 }
209 return 0;
210}
211
212static const struct tsocket_address_ops tsocket_address_bsd_ops;
213
214struct tsocket_address_bsd {
215 socklen_t sa_socklen;
216 union {
217 struct sockaddr sa;
218 struct sockaddr_in in;
219#ifdef HAVE_IPV6
220 struct sockaddr_in6 in6;
221#endif
222 struct sockaddr_un un;
223 struct sockaddr_storage ss;
224 } u;
225};
226
227int _tsocket_address_bsd_from_sockaddr(TALLOC_CTX *mem_ctx,
228 const struct sockaddr *sa,
229 size_t sa_socklen,
230 struct tsocket_address **_addr,
231 const char *location)
232{
233 struct tsocket_address *addr;
234 struct tsocket_address_bsd *bsda;
235
236 if (sa_socklen < sizeof(sa->sa_family)) {
237 errno = EINVAL;
238 return -1;
239 }
240
241 switch (sa->sa_family) {
242 case AF_UNIX:
243 if (sa_socklen > sizeof(struct sockaddr_un)) {
244 sa_socklen = sizeof(struct sockaddr_un);
245 }
246 break;
247 case AF_INET:
248 if (sa_socklen < sizeof(struct sockaddr_in)) {
249 errno = EINVAL;
250 return -1;
251 }
252 sa_socklen = sizeof(struct sockaddr_in);
253 break;
254#ifdef HAVE_IPV6
255 case AF_INET6:
256 if (sa_socklen < sizeof(struct sockaddr_in6)) {
257 errno = EINVAL;
258 return -1;
259 }
260 sa_socklen = sizeof(struct sockaddr_in6);
261 break;
262#endif
263 default:
264 errno = EAFNOSUPPORT;
265 return -1;
266 }
267
268 if (sa_socklen > sizeof(struct sockaddr_storage)) {
269 errno = EINVAL;
270 return -1;
271 }
272
273 addr = tsocket_address_create(mem_ctx,
274 &tsocket_address_bsd_ops,
275 &bsda,
276 struct tsocket_address_bsd,
277 location);
278 if (!addr) {
279 errno = ENOMEM;
280 return -1;
281 }
282
283 ZERO_STRUCTP(bsda);
284
285 memcpy(&bsda->u.ss, sa, sa_socklen);
286
287 bsda->sa_socklen = sa_socklen;
288#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
289 bsda->u.sa.sa_len = bsda->sa_socklen;
290#endif
291
292 *_addr = addr;
293 return 0;
294}
295
296ssize_t tsocket_address_bsd_sockaddr(const struct tsocket_address *addr,
297 struct sockaddr *sa,
298 size_t sa_socklen)
299{
300 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
301 struct tsocket_address_bsd);
302
303 if (!bsda) {
304 errno = EINVAL;
305 return -1;
306 }
307
308 if (sa_socklen < bsda->sa_socklen) {
309 errno = EINVAL;
310 return -1;
311 }
312
313 if (sa_socklen > bsda->sa_socklen) {
314 memset(sa, 0, sa_socklen);
315 sa_socklen = bsda->sa_socklen;
316 }
317
318 memcpy(sa, &bsda->u.ss, sa_socklen);
319#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
320 sa->sa_len = sa_socklen;
321#endif
322 return sa_socklen;
323}
324
325bool tsocket_address_is_inet(const struct tsocket_address *addr, const char *fam)
326{
327 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
328 struct tsocket_address_bsd);
329
330 if (!bsda) {
331 return false;
332 }
333
334 switch (bsda->u.sa.sa_family) {
335 case AF_INET:
336 if (strcasecmp(fam, "ip") == 0) {
337 return true;
338 }
339
340 if (strcasecmp(fam, "ipv4") == 0) {
341 return true;
342 }
343
344 return false;
345#ifdef HAVE_IPV6
346 case AF_INET6:
347 if (strcasecmp(fam, "ip") == 0) {
348 return true;
349 }
350
351 if (strcasecmp(fam, "ipv6") == 0) {
352 return true;
353 }
354
355 return false;
356#endif
357 }
358
359 return false;
360}
361
362int _tsocket_address_inet_from_strings(TALLOC_CTX *mem_ctx,
363 const char *fam,
364 const char *addr,
365 uint16_t port,
366 struct tsocket_address **_addr,
367 const char *location)
368{
369 struct addrinfo hints;
370 struct addrinfo *result = NULL;
371 char port_str[6];
372 int ret;
373
374 ZERO_STRUCT(hints);
375 /*
376 * we use SOCKET_STREAM here to get just one result
377 * back from getaddrinfo().
378 */
379 hints.ai_socktype = SOCK_STREAM;
380 hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
381
382 if (strcasecmp(fam, "ip") == 0) {
383 hints.ai_family = AF_UNSPEC;
384 if (!addr) {
385#ifdef HAVE_IPV6
386 addr = "::";
387#else
388 addr = "0.0.0.0";
389#endif
390 }
391 } else if (strcasecmp(fam, "ipv4") == 0) {
392 hints.ai_family = AF_INET;
393 if (!addr) {
394 addr = "0.0.0.0";
395 }
396#ifdef HAVE_IPV6
397 } else if (strcasecmp(fam, "ipv6") == 0) {
398 hints.ai_family = AF_INET6;
399 if (!addr) {
400 addr = "::";
401 }
402#endif
403 } else {
404 errno = EAFNOSUPPORT;
405 return -1;
406 }
407
408 snprintf(port_str, sizeof(port_str), "%u", port);
409
410 ret = getaddrinfo(addr, port_str, &hints, &result);
411 if (ret != 0) {
412 switch (ret) {
413 case EAI_FAIL:
414 errno = EINVAL;
415 break;
416 }
417 ret = -1;
418 goto done;
419 }
420
421 if (result->ai_socktype != SOCK_STREAM) {
422 errno = EINVAL;
423 ret = -1;
424 goto done;
425 }
426
427 ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
428 result->ai_addr,
429 result->ai_addrlen,
430 _addr,
431 location);
432
433done:
434 if (result) {
435 freeaddrinfo(result);
436 }
437 return ret;
438}
439
440char *tsocket_address_inet_addr_string(const struct tsocket_address *addr,
441 TALLOC_CTX *mem_ctx)
442{
443 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
444 struct tsocket_address_bsd);
445 char addr_str[INET6_ADDRSTRLEN+1];
446 const char *str;
447
448 if (!bsda) {
449 errno = EINVAL;
450 return NULL;
451 }
452
453 switch (bsda->u.sa.sa_family) {
454 case AF_INET:
455 str = inet_ntop(bsda->u.in.sin_family,
456 &bsda->u.in.sin_addr,
457 addr_str, sizeof(addr_str));
458 break;
459#ifdef HAVE_IPV6
460 case AF_INET6:
461 str = inet_ntop(bsda->u.in6.sin6_family,
462 &bsda->u.in6.sin6_addr,
463 addr_str, sizeof(addr_str));
464 break;
465#endif
466 default:
467 errno = EINVAL;
468 return NULL;
469 }
470
471 if (!str) {
472 return NULL;
473 }
474
475 return talloc_strdup(mem_ctx, str);
476}
477
478uint16_t tsocket_address_inet_port(const struct tsocket_address *addr)
479{
480 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
481 struct tsocket_address_bsd);
482 uint16_t port = 0;
483
484 if (!bsda) {
485 errno = EINVAL;
486 return 0;
487 }
488
489 switch (bsda->u.sa.sa_family) {
490 case AF_INET:
491 port = ntohs(bsda->u.in.sin_port);
492 break;
493#ifdef HAVE_IPV6
494 case AF_INET6:
495 port = ntohs(bsda->u.in6.sin6_port);
496 break;
497#endif
498 default:
499 errno = EINVAL;
500 return 0;
501 }
502
503 return port;
504}
505
506int tsocket_address_inet_set_port(struct tsocket_address *addr,
507 uint16_t port)
508{
509 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
510 struct tsocket_address_bsd);
511
512 if (!bsda) {
513 errno = EINVAL;
514 return -1;
515 }
516
517 switch (bsda->u.sa.sa_family) {
518 case AF_INET:
519 bsda->u.in.sin_port = htons(port);
520 break;
521#ifdef HAVE_IPV6
522 case AF_INET6:
523 bsda->u.in6.sin6_port = htons(port);
524 break;
525#endif
526 default:
527 errno = EINVAL;
528 return -1;
529 }
530
531 return 0;
532}
533
534bool tsocket_address_is_unix(const struct tsocket_address *addr)
535{
536 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
537 struct tsocket_address_bsd);
538
539 if (!bsda) {
540 return false;
541 }
542
543 switch (bsda->u.sa.sa_family) {
544 case AF_UNIX:
545 return true;
546 }
547
548 return false;
549}
550
551int _tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
552 const char *path,
553 struct tsocket_address **_addr,
554 const char *location)
555{
556 struct sockaddr_un un;
557 void *p = &un;
558 int ret;
559
560 if (!path) {
561 path = "";
562 }
563
564 if (strlen(path) > sizeof(un.sun_path)-1) {
565 errno = ENAMETOOLONG;
566 return -1;
567 }
568
569 ZERO_STRUCT(un);
570 un.sun_family = AF_UNIX;
571 strncpy(un.sun_path, path, sizeof(un.sun_path)-1);
572
573 ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
574 (struct sockaddr *)p,
575 sizeof(un),
576 _addr,
577 location);
578
579 return ret;
580}
581
582char *tsocket_address_unix_path(const struct tsocket_address *addr,
583 TALLOC_CTX *mem_ctx)
584{
585 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
586 struct tsocket_address_bsd);
587 const char *str;
588
589 if (!bsda) {
590 errno = EINVAL;
591 return NULL;
592 }
593
594 switch (bsda->u.sa.sa_family) {
595 case AF_UNIX:
596 str = bsda->u.un.sun_path;
597 break;
598 default:
599 errno = EINVAL;
600 return NULL;
601 }
602
603 return talloc_strdup(mem_ctx, str);
604}
605
606static char *tsocket_address_bsd_string(const struct tsocket_address *addr,
607 TALLOC_CTX *mem_ctx)
608{
609 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
610 struct tsocket_address_bsd);
611 char *str;
612 char *addr_str;
613 const char *prefix = NULL;
614 uint16_t port;
615
616 switch (bsda->u.sa.sa_family) {
617 case AF_UNIX:
618 return talloc_asprintf(mem_ctx, "unix:%s",
619 bsda->u.un.sun_path);
620 case AF_INET:
621 prefix = "ipv4";
622 break;
623#ifdef HAVE_IPV6
624 case AF_INET6:
625 prefix = "ipv6";
626 break;
627#endif
628 default:
629 errno = EINVAL;
630 return NULL;
631 }
632
633 addr_str = tsocket_address_inet_addr_string(addr, mem_ctx);
634 if (!addr_str) {
635 return NULL;
636 }
637
638 port = tsocket_address_inet_port(addr);
639
640 str = talloc_asprintf(mem_ctx, "%s:%s:%u",
641 prefix, addr_str, port);
642 talloc_free(addr_str);
643
644 return str;
645}
646
647static struct tsocket_address *tsocket_address_bsd_copy(const struct tsocket_address *addr,
648 TALLOC_CTX *mem_ctx,
649 const char *location)
650{
651 struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
652 struct tsocket_address_bsd);
653 struct tsocket_address *copy;
654 int ret;
655
656 ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
657 &bsda->u.sa,
658 bsda->sa_socklen,
659 &copy,
660 location);
661 if (ret != 0) {
662 return NULL;
663 }
664
665 return copy;
666}
667
668static const struct tsocket_address_ops tsocket_address_bsd_ops = {
669 .name = "bsd",
670 .string = tsocket_address_bsd_string,
671 .copy = tsocket_address_bsd_copy,
672};
673
674struct tdgram_bsd {
675 int fd;
676
677 void *event_ptr;
678 struct tevent_fd *fde;
679 bool optimize_recvfrom;
680 bool netlink;
681
682 void *readable_private;
683 void (*readable_handler)(void *private_data);
684 void *writeable_private;
685 void (*writeable_handler)(void *private_data);
686};
687
688bool tdgram_bsd_optimize_recvfrom(struct tdgram_context *dgram,
689 bool on)
690{
691 struct tdgram_bsd *bsds =
692 talloc_get_type(_tdgram_context_data(dgram),
693 struct tdgram_bsd);
694 bool old;
695
696 if (bsds == NULL) {
697 /* not a bsd socket */
698 return false;
699 }
700
701 old = bsds->optimize_recvfrom;
702 bsds->optimize_recvfrom = on;
703
704 return old;
705}
706
707static void tdgram_bsd_fde_handler(struct tevent_context *ev,
708 struct tevent_fd *fde,
709 uint16_t flags,
710 void *private_data)
711{
712 struct tdgram_bsd *bsds = talloc_get_type_abort(private_data,
713 struct tdgram_bsd);
714
715 if (flags & TEVENT_FD_WRITE) {
716 bsds->writeable_handler(bsds->writeable_private);
717 return;
718 }
719 if (flags & TEVENT_FD_READ) {
720 if (!bsds->readable_handler) {
721 TEVENT_FD_NOT_READABLE(bsds->fde);
722 return;
723 }
724 bsds->readable_handler(bsds->readable_private);
725 return;
726 }
727}
728
729static int tdgram_bsd_set_readable_handler(struct tdgram_bsd *bsds,
730 struct tevent_context *ev,
731 void (*handler)(void *private_data),
732 void *private_data)
733{
734 if (ev == NULL) {
735 if (handler) {
736 errno = EINVAL;
737 return -1;
738 }
739 if (!bsds->readable_handler) {
740 return 0;
741 }
742 bsds->readable_handler = NULL;
743 bsds->readable_private = NULL;
744
745 return 0;
746 }
747
748 /* read and write must use the same tevent_context */
749 if (bsds->event_ptr != ev) {
750 if (bsds->readable_handler || bsds->writeable_handler) {
751 errno = EINVAL;
752 return -1;
753 }
754 bsds->event_ptr = NULL;
755 TALLOC_FREE(bsds->fde);
756 }
757
758 if (tevent_fd_get_flags(bsds->fde) == 0) {
759 TALLOC_FREE(bsds->fde);
760
761 bsds->fde = tevent_add_fd(ev, bsds,
762 bsds->fd, TEVENT_FD_READ,
763 tdgram_bsd_fde_handler,
764 bsds);
765 if (!bsds->fde) {
766 errno = ENOMEM;
767 return -1;
768 }
769
770 /* cache the event context we're running on */
771 bsds->event_ptr = ev;
772 } else if (!bsds->readable_handler) {
773 TEVENT_FD_READABLE(bsds->fde);
774 }
775
776 bsds->readable_handler = handler;
777 bsds->readable_private = private_data;
778
779 return 0;
780}
781
782static int tdgram_bsd_set_writeable_handler(struct tdgram_bsd *bsds,
783 struct tevent_context *ev,
784 void (*handler)(void *private_data),
785 void *private_data)
786{
787 if (ev == NULL) {
788 if (handler) {
789 errno = EINVAL;
790 return -1;
791 }
792 if (!bsds->writeable_handler) {
793 return 0;
794 }
795 bsds->writeable_handler = NULL;
796 bsds->writeable_private = NULL;
797 TEVENT_FD_NOT_WRITEABLE(bsds->fde);
798
799 return 0;
800 }
801
802 /* read and write must use the same tevent_context */
803 if (bsds->event_ptr != ev) {
804 if (bsds->readable_handler || bsds->writeable_handler) {
805 errno = EINVAL;
806 return -1;
807 }
808 bsds->event_ptr = NULL;
809 TALLOC_FREE(bsds->fde);
810 }
811
812 if (tevent_fd_get_flags(bsds->fde) == 0) {
813 TALLOC_FREE(bsds->fde);
814
815 bsds->fde = tevent_add_fd(ev, bsds,
816 bsds->fd, TEVENT_FD_WRITE,
817 tdgram_bsd_fde_handler,
818 bsds);
819 if (!bsds->fde) {
820 errno = ENOMEM;
821 return -1;
822 }
823
824 /* cache the event context we're running on */
825 bsds->event_ptr = ev;
826 } else if (!bsds->writeable_handler) {
827 TEVENT_FD_WRITEABLE(bsds->fde);
828 }
829
830 bsds->writeable_handler = handler;
831 bsds->writeable_private = private_data;
832
833 return 0;
834}
835
836struct tdgram_bsd_recvfrom_state {
837 struct tdgram_context *dgram;
838 bool first_try;
839 uint8_t *buf;
840 size_t len;
841 struct tsocket_address *src;
842};
843
844static int tdgram_bsd_recvfrom_destructor(struct tdgram_bsd_recvfrom_state *state)
845{
846 struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
847 struct tdgram_bsd);
848
849 tdgram_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
850
851 return 0;
852}
853
854static void tdgram_bsd_recvfrom_handler(void *private_data);
855
856static struct tevent_req *tdgram_bsd_recvfrom_send(TALLOC_CTX *mem_ctx,
857 struct tevent_context *ev,
858 struct tdgram_context *dgram)
859{
860 struct tevent_req *req;
861 struct tdgram_bsd_recvfrom_state *state;
862 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
863 int ret;
864
865 req = tevent_req_create(mem_ctx, &state,
866 struct tdgram_bsd_recvfrom_state);
867 if (!req) {
868 return NULL;
869 }
870
871 state->dgram = dgram;
872 state->first_try= true;
873 state->buf = NULL;
874 state->len = 0;
875 state->src = NULL;
876
877 talloc_set_destructor(state, tdgram_bsd_recvfrom_destructor);
878
879 if (bsds->fd == -1) {
880 tevent_req_error(req, ENOTCONN);
881 goto post;
882 }
883
884
885 /*
886 * this is a fast path, not waiting for the
887 * socket to become explicit readable gains
888 * about 10%-20% performance in benchmark tests.
889 */
890 if (bsds->optimize_recvfrom) {
891 /*
892 * We only do the optimization on
893 * recvfrom if the caller asked for it.
894 *
895 * This is needed because in most cases
896 * we prefer to flush send buffers before
897 * receiving incoming requests.
898 */
899 tdgram_bsd_recvfrom_handler(req);
900 if (!tevent_req_is_in_progress(req)) {
901 goto post;
902 }
903 }
904
905 ret = tdgram_bsd_set_readable_handler(bsds, ev,
906 tdgram_bsd_recvfrom_handler,
907 req);
908 if (ret == -1) {
909 tevent_req_error(req, errno);
910 goto post;
911 }
912
913 return req;
914
915 post:
916 tevent_req_post(req, ev);
917 return req;
918}
919
920static void tdgram_bsd_recvfrom_handler(void *private_data)
921{
922 struct tevent_req *req = talloc_get_type_abort(private_data,
923 struct tevent_req);
924 struct tdgram_bsd_recvfrom_state *state = tevent_req_data(req,
925 struct tdgram_bsd_recvfrom_state);
926 struct tdgram_context *dgram = state->dgram;
927 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
928 struct tsocket_address_bsd *bsda;
929 ssize_t ret;
930 int err;
931 bool retry;
932
933 if (bsds->netlink) {
934 ret = tsocket_bsd_netlink_pending(bsds->fd);
935 } else {
936 ret = tsocket_bsd_pending(bsds->fd);
937 }
938
939 if (state->first_try && ret == 0) {
940 state->first_try = false;
941 /* retry later */
942 return;
943 }
944 state->first_try = false;
945
946 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
947 if (retry) {
948 /* retry later */
949 return;
950 }
951 if (tevent_req_error(req, err)) {
952 return;
953 }
954
955 /* note that 'ret' can be 0 here */
956 state->buf = talloc_array(state, uint8_t, ret);
957 if (tevent_req_nomem(state->buf, req)) {
958 return;
959 }
960 state->len = ret;
961
962 state->src = tsocket_address_create(state,
963 &tsocket_address_bsd_ops,
964 &bsda,
965 struct tsocket_address_bsd,
966 __location__ "bsd_recvfrom");
967 if (tevent_req_nomem(state->src, req)) {
968 return;
969 }
970
971 ZERO_STRUCTP(bsda);
972 bsda->sa_socklen = sizeof(bsda->u.ss);
973#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
974 bsda->u.sa.sa_len = bsda->sa_socklen;
975#endif
976
977 ret = recvfrom(bsds->fd, state->buf, state->len, 0,
978 &bsda->u.sa, &bsda->sa_socklen);
979 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
980 if (retry) {
981 /* retry later */
982 return;
983 }
984 if (tevent_req_error(req, err)) {
985 return;
986 }
987
988 /*
989 * Some systems (FreeBSD, see bug #7115) return too much
990 * bytes in tsocket_bsd_pending()/ioctl(fd, FIONREAD, ...),
991 * the return value includes some IP/UDP header bytes,
992 * while recvfrom() just returns the payload.
993 */
994 state->buf = talloc_realloc(state, state->buf, uint8_t, ret);
995 if (tevent_req_nomem(state->buf, req)) {
996 return;
997 }
998 state->len = ret;
999
1000 tevent_req_done(req);
1001}
1002
1003static ssize_t tdgram_bsd_recvfrom_recv(struct tevent_req *req,
1004 int *perrno,
1005 TALLOC_CTX *mem_ctx,
1006 uint8_t **buf,
1007 struct tsocket_address **src)
1008{
1009 struct tdgram_bsd_recvfrom_state *state = tevent_req_data(req,
1010 struct tdgram_bsd_recvfrom_state);
1011 ssize_t ret;
1012
1013 ret = tsocket_simple_int_recv(req, perrno);
1014 if (ret == 0) {
1015 *buf = talloc_move(mem_ctx, &state->buf);
1016 ret = state->len;
1017 if (src) {
1018 *src = talloc_move(mem_ctx, &state->src);
1019 }
1020 }
1021
1022 tevent_req_received(req);
1023 return ret;
1024}
1025
1026struct tdgram_bsd_sendto_state {
1027 struct tdgram_context *dgram;
1028
1029 const uint8_t *buf;
1030 size_t len;
1031 const struct tsocket_address *dst;
1032
1033 ssize_t ret;
1034};
1035
1036static int tdgram_bsd_sendto_destructor(struct tdgram_bsd_sendto_state *state)
1037{
1038 struct tdgram_bsd *bsds = tdgram_context_data(state->dgram,
1039 struct tdgram_bsd);
1040
1041 tdgram_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
1042
1043 return 0;
1044}
1045
1046static void tdgram_bsd_sendto_handler(void *private_data);
1047
1048static struct tevent_req *tdgram_bsd_sendto_send(TALLOC_CTX *mem_ctx,
1049 struct tevent_context *ev,
1050 struct tdgram_context *dgram,
1051 const uint8_t *buf,
1052 size_t len,
1053 const struct tsocket_address *dst)
1054{
1055 struct tevent_req *req;
1056 struct tdgram_bsd_sendto_state *state;
1057 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1058 int ret;
1059
1060 req = tevent_req_create(mem_ctx, &state,
1061 struct tdgram_bsd_sendto_state);
1062 if (!req) {
1063 return NULL;
1064 }
1065
1066 state->dgram = dgram;
1067 state->buf = buf;
1068 state->len = len;
1069 state->dst = dst;
1070 state->ret = -1;
1071
1072 talloc_set_destructor(state, tdgram_bsd_sendto_destructor);
1073
1074 if (bsds->fd == -1) {
1075 tevent_req_error(req, ENOTCONN);
1076 goto post;
1077 }
1078
1079 /*
1080 * this is a fast path, not waiting for the
1081 * socket to become explicit writeable gains
1082 * about 10%-20% performance in benchmark tests.
1083 */
1084 tdgram_bsd_sendto_handler(req);
1085 if (!tevent_req_is_in_progress(req)) {
1086 goto post;
1087 }
1088
1089 ret = tdgram_bsd_set_writeable_handler(bsds, ev,
1090 tdgram_bsd_sendto_handler,
1091 req);
1092 if (ret == -1) {
1093 tevent_req_error(req, errno);
1094 goto post;
1095 }
1096
1097 return req;
1098
1099 post:
1100 tevent_req_post(req, ev);
1101 return req;
1102}
1103
1104static void tdgram_bsd_sendto_handler(void *private_data)
1105{
1106 struct tevent_req *req = talloc_get_type_abort(private_data,
1107 struct tevent_req);
1108 struct tdgram_bsd_sendto_state *state = tevent_req_data(req,
1109 struct tdgram_bsd_sendto_state);
1110 struct tdgram_context *dgram = state->dgram;
1111 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1112 struct sockaddr *sa = NULL;
1113 socklen_t sa_socklen = 0;
1114 ssize_t ret;
1115 int err;
1116 bool retry;
1117
1118 if (state->dst) {
1119 struct tsocket_address_bsd *bsda =
1120 talloc_get_type(state->dst->private_data,
1121 struct tsocket_address_bsd);
1122
1123 sa = &bsda->u.sa;
1124 sa_socklen = bsda->sa_socklen;
1125 }
1126
1127 ret = sendto(bsds->fd, state->buf, state->len, 0, sa, sa_socklen);
1128 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
1129 if (retry) {
1130 /* retry later */
1131 return;
1132 }
1133
1134 if (err == EMSGSIZE) {
1135 /* round up in 1K increments */
1136 int bufsize = ((state->len + 1023) & (~1023));
1137
1138 ret = setsockopt(bsds->fd, SOL_SOCKET, SO_SNDBUF, &bufsize,
1139 sizeof(bufsize));
1140 if (ret == 0) {
1141 /*
1142 * We do the retry here, rather then via the
1143 * handler, as we only want to retry once for
1144 * this condition, so if there is a mismatch
1145 * between what setsockopt() accepts and what can
1146 * actually be sent, we do not end up in a
1147 * loop.
1148 */
1149
1150 ret = sendto(bsds->fd, state->buf, state->len,
1151 0, sa, sa_socklen);
1152 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
1153 if (retry) { /* retry later */
1154 return;
1155 }
1156 }
1157 }
1158
1159 if (tevent_req_error(req, err)) {
1160 return;
1161 }
1162
1163 state->ret = ret;
1164
1165 tevent_req_done(req);
1166}
1167
1168static ssize_t tdgram_bsd_sendto_recv(struct tevent_req *req, int *perrno)
1169{
1170 struct tdgram_bsd_sendto_state *state = tevent_req_data(req,
1171 struct tdgram_bsd_sendto_state);
1172 ssize_t ret;
1173
1174 ret = tsocket_simple_int_recv(req, perrno);
1175 if (ret == 0) {
1176 ret = state->ret;
1177 }
1178
1179 tevent_req_received(req);
1180 return ret;
1181}
1182
1183struct tdgram_bsd_disconnect_state {
1184 uint8_t __dummy;
1185};
1186
1187static struct tevent_req *tdgram_bsd_disconnect_send(TALLOC_CTX *mem_ctx,
1188 struct tevent_context *ev,
1189 struct tdgram_context *dgram)
1190{
1191 struct tdgram_bsd *bsds = tdgram_context_data(dgram, struct tdgram_bsd);
1192 struct tevent_req *req;
1193 struct tdgram_bsd_disconnect_state *state;
1194 int ret;
1195 int err;
1196 bool dummy;
1197
1198 req = tevent_req_create(mem_ctx, &state,
1199 struct tdgram_bsd_disconnect_state);
1200 if (req == NULL) {
1201 return NULL;
1202 }
1203
1204 if (bsds->fd == -1) {
1205 tevent_req_error(req, ENOTCONN);
1206 goto post;
1207 }
1208
1209 TALLOC_FREE(bsds->fde);
1210 ret = close(bsds->fd);
1211 bsds->fd = -1;
1212 err = tsocket_bsd_error_from_errno(ret, errno, &dummy);
1213 if (tevent_req_error(req, err)) {
1214 goto post;
1215 }
1216
1217 tevent_req_done(req);
1218post:
1219 tevent_req_post(req, ev);
1220 return req;
1221}
1222
1223static int tdgram_bsd_disconnect_recv(struct tevent_req *req,
1224 int *perrno)
1225{
1226 int ret;
1227
1228 ret = tsocket_simple_int_recv(req, perrno);
1229
1230 tevent_req_received(req);
1231 return ret;
1232}
1233
1234static const struct tdgram_context_ops tdgram_bsd_ops = {
1235 .name = "bsd",
1236
1237 .recvfrom_send = tdgram_bsd_recvfrom_send,
1238 .recvfrom_recv = tdgram_bsd_recvfrom_recv,
1239
1240 .sendto_send = tdgram_bsd_sendto_send,
1241 .sendto_recv = tdgram_bsd_sendto_recv,
1242
1243 .disconnect_send = tdgram_bsd_disconnect_send,
1244 .disconnect_recv = tdgram_bsd_disconnect_recv,
1245};
1246
1247static int tdgram_bsd_destructor(struct tdgram_bsd *bsds)
1248{
1249 TALLOC_FREE(bsds->fde);
1250 if (bsds->fd != -1) {
1251 close(bsds->fd);
1252 bsds->fd = -1;
1253 }
1254 return 0;
1255}
1256
1257static int tdgram_bsd_dgram_socket(const struct tsocket_address *local,
1258 const struct tsocket_address *remote,
1259 bool broadcast,
1260 TALLOC_CTX *mem_ctx,
1261 struct tdgram_context **_dgram,
1262 const char *location)
1263{
1264 struct tsocket_address_bsd *lbsda =
1265 talloc_get_type_abort(local->private_data,
1266 struct tsocket_address_bsd);
1267 struct tsocket_address_bsd *rbsda = NULL;
1268 struct tdgram_context *dgram;
1269 struct tdgram_bsd *bsds;
1270 int fd;
1271 int ret;
1272 bool do_bind = false;
1273 bool do_reuseaddr = false;
1274 bool do_ipv6only = false;
1275 bool is_inet = false;
1276 int sa_fam = lbsda->u.sa.sa_family;
1277
1278 if (remote) {
1279 rbsda = talloc_get_type_abort(remote->private_data,
1280 struct tsocket_address_bsd);
1281 }
1282
1283 switch (lbsda->u.sa.sa_family) {
1284 case AF_UNIX:
1285 if (broadcast) {
1286 errno = EINVAL;
1287 return -1;
1288 }
1289 if (lbsda->u.un.sun_path[0] != 0) {
1290 do_reuseaddr = true;
1291 do_bind = true;
1292 }
1293 break;
1294 case AF_INET:
1295 if (lbsda->u.in.sin_port != 0) {
1296 do_reuseaddr = true;
1297 do_bind = true;
1298 }
1299 if (lbsda->u.in.sin_addr.s_addr != INADDR_ANY) {
1300 do_bind = true;
1301 }
1302 is_inet = true;
1303 break;
1304#ifdef HAVE_IPV6
1305 case AF_INET6:
1306 if (lbsda->u.in6.sin6_port != 0) {
1307 do_reuseaddr = true;
1308 do_bind = true;
1309 }
1310 if (memcmp(&in6addr_any,
1311 &lbsda->u.in6.sin6_addr,
1312 sizeof(in6addr_any)) != 0) {
1313 do_bind = true;
1314 }
1315 is_inet = true;
1316 do_ipv6only = true;
1317 break;
1318#endif
1319 default:
1320 errno = EINVAL;
1321 return -1;
1322 }
1323
1324 if (!do_bind && is_inet && rbsda) {
1325 sa_fam = rbsda->u.sa.sa_family;
1326 switch (sa_fam) {
1327 case AF_INET:
1328 do_ipv6only = false;
1329 break;
1330#ifdef HAVE_IPV6
1331 case AF_INET6:
1332 do_ipv6only = true;
1333 break;
1334#endif
1335 }
1336 }
1337
1338 fd = socket(sa_fam, SOCK_DGRAM, 0);
1339 if (fd < 0) {
1340 return -1;
1341 }
1342
1343 fd = tsocket_bsd_common_prepare_fd(fd, true);
1344 if (fd < 0) {
1345 return -1;
1346 }
1347
1348 dgram = tdgram_context_create(mem_ctx,
1349 &tdgram_bsd_ops,
1350 &bsds,
1351 struct tdgram_bsd,
1352 location);
1353 if (!dgram) {
1354 int saved_errno = errno;
1355 close(fd);
1356 errno = saved_errno;
1357 return -1;
1358 }
1359 ZERO_STRUCTP(bsds);
1360 bsds->fd = fd;
1361 talloc_set_destructor(bsds, tdgram_bsd_destructor);
1362
1363#ifdef HAVE_IPV6
1364 if (do_ipv6only) {
1365 int val = 1;
1366
1367 ret = setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY,
1368 (const void *)&val, sizeof(val));
1369 if (ret == -1) {
1370 int saved_errno = errno;
1371 talloc_free(dgram);
1372 errno = saved_errno;
1373 return -1;
1374 }
1375 }
1376#endif
1377
1378 if (broadcast) {
1379 int val = 1;
1380
1381 ret = setsockopt(fd, SOL_SOCKET, SO_BROADCAST,
1382 (const void *)&val, sizeof(val));
1383 if (ret == -1) {
1384 int saved_errno = errno;
1385 talloc_free(dgram);
1386 errno = saved_errno;
1387 return -1;
1388 }
1389 }
1390
1391 if (do_reuseaddr) {
1392 int val = 1;
1393
1394 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1395 (const void *)&val, sizeof(val));
1396 if (ret == -1) {
1397 int saved_errno = errno;
1398 talloc_free(dgram);
1399 errno = saved_errno;
1400 return -1;
1401 }
1402 }
1403
1404 if (do_bind) {
1405 ret = bind(fd, &lbsda->u.sa, lbsda->sa_socklen);
1406 if (ret == -1) {
1407 int saved_errno = errno;
1408 talloc_free(dgram);
1409 errno = saved_errno;
1410 return -1;
1411 }
1412 }
1413
1414 if (rbsda) {
1415 if (rbsda->u.sa.sa_family != sa_fam) {
1416 talloc_free(dgram);
1417 errno = EINVAL;
1418 return -1;
1419 }
1420
1421 ret = connect(fd, &rbsda->u.sa, rbsda->sa_socklen);
1422 if (ret == -1) {
1423 int saved_errno = errno;
1424 talloc_free(dgram);
1425 errno = saved_errno;
1426 return -1;
1427 }
1428 }
1429
1430 *_dgram = dgram;
1431 return 0;
1432}
1433
1434int _tdgram_bsd_existing_socket(TALLOC_CTX *mem_ctx,
1435 int fd,
1436 struct tdgram_context **_dgram,
1437 const char *location)
1438{
1439 struct tdgram_context *dgram;
1440 struct tdgram_bsd *bsds;
1441#ifdef HAVE_LINUX_RTNETLINK_H
1442 int result;
1443 struct sockaddr sa;
1444 socklen_t sa_len = sizeof(struct sockaddr);
1445#endif
1446
1447 dgram = tdgram_context_create(mem_ctx,
1448 &tdgram_bsd_ops,
1449 &bsds,
1450 struct tdgram_bsd,
1451 location);
1452 if (!dgram) {
1453 return -1;
1454 }
1455 ZERO_STRUCTP(bsds);
1456 bsds->fd = fd;
1457 talloc_set_destructor(bsds, tdgram_bsd_destructor);
1458
1459 *_dgram = dgram;
1460
1461#ifdef HAVE_LINUX_RTNETLINK_H
1462 /*
1463 * Try to determine the protocol family and remember if it's
1464 * AF_NETLINK. We don't care if this fails.
1465 */
1466 result = getsockname(fd, &sa, &sa_len);
1467 if (result == 0 && sa.sa_family == AF_NETLINK) {
1468 bsds->netlink = true;
1469 }
1470#endif
1471
1472 return 0;
1473}
1474
1475int _tdgram_inet_udp_socket(const struct tsocket_address *local,
1476 const struct tsocket_address *remote,
1477 TALLOC_CTX *mem_ctx,
1478 struct tdgram_context **dgram,
1479 const char *location)
1480{
1481 struct tsocket_address_bsd *lbsda =
1482 talloc_get_type_abort(local->private_data,
1483 struct tsocket_address_bsd);
1484 int ret;
1485
1486 switch (lbsda->u.sa.sa_family) {
1487 case AF_INET:
1488 break;
1489#ifdef HAVE_IPV6
1490 case AF_INET6:
1491 break;
1492#endif
1493 default:
1494 errno = EINVAL;
1495 return -1;
1496 }
1497
1498 ret = tdgram_bsd_dgram_socket(local, remote, false,
1499 mem_ctx, dgram, location);
1500
1501 return ret;
1502}
1503
1504int _tdgram_inet_udp_broadcast_socket(const struct tsocket_address *local,
1505 TALLOC_CTX *mem_ctx,
1506 struct tdgram_context **dgram,
1507 const char *location)
1508{
1509 struct tsocket_address_bsd *lbsda =
1510 talloc_get_type_abort(local->private_data,
1511 struct tsocket_address_bsd);
1512 int ret;
1513
1514 switch (lbsda->u.sa.sa_family) {
1515 case AF_INET:
1516 break;
1517#ifdef HAVE_IPV6
1518 case AF_INET6:
1519 /* only ipv4 */
1520 errno = EINVAL;
1521 return -1;
1522#endif
1523 default:
1524 errno = EINVAL;
1525 return -1;
1526 }
1527
1528 ret = tdgram_bsd_dgram_socket(local, NULL, true,
1529 mem_ctx, dgram, location);
1530
1531 return ret;
1532}
1533
1534int _tdgram_unix_socket(const struct tsocket_address *local,
1535 const struct tsocket_address *remote,
1536 TALLOC_CTX *mem_ctx,
1537 struct tdgram_context **dgram,
1538 const char *location)
1539{
1540 struct tsocket_address_bsd *lbsda =
1541 talloc_get_type_abort(local->private_data,
1542 struct tsocket_address_bsd);
1543 int ret;
1544
1545 switch (lbsda->u.sa.sa_family) {
1546 case AF_UNIX:
1547 break;
1548 default:
1549 errno = EINVAL;
1550 return -1;
1551 }
1552
1553 ret = tdgram_bsd_dgram_socket(local, remote, false,
1554 mem_ctx, dgram, location);
1555
1556 return ret;
1557}
1558
1559struct tstream_bsd {
1560 int fd;
1561
1562 void *event_ptr;
1563 struct tevent_fd *fde;
1564 bool optimize_readv;
1565
1566 void *readable_private;
1567 void (*readable_handler)(void *private_data);
1568 void *writeable_private;
1569 void (*writeable_handler)(void *private_data);
1570};
1571
1572bool tstream_bsd_optimize_readv(struct tstream_context *stream,
1573 bool on)
1574{
1575 struct tstream_bsd *bsds =
1576 talloc_get_type(_tstream_context_data(stream),
1577 struct tstream_bsd);
1578 bool old;
1579
1580 if (bsds == NULL) {
1581 /* not a bsd socket */
1582 return false;
1583 }
1584
1585 old = bsds->optimize_readv;
1586 bsds->optimize_readv = on;
1587
1588 return old;
1589}
1590
1591static void tstream_bsd_fde_handler(struct tevent_context *ev,
1592 struct tevent_fd *fde,
1593 uint16_t flags,
1594 void *private_data)
1595{
1596 struct tstream_bsd *bsds = talloc_get_type_abort(private_data,
1597 struct tstream_bsd);
1598
1599 if (flags & TEVENT_FD_WRITE) {
1600 bsds->writeable_handler(bsds->writeable_private);
1601 return;
1602 }
1603 if (flags & TEVENT_FD_READ) {
1604 if (!bsds->readable_handler) {
1605 if (bsds->writeable_handler) {
1606 bsds->writeable_handler(bsds->writeable_private);
1607 return;
1608 }
1609 TEVENT_FD_NOT_READABLE(bsds->fde);
1610 return;
1611 }
1612 bsds->readable_handler(bsds->readable_private);
1613 return;
1614 }
1615}
1616
1617static int tstream_bsd_set_readable_handler(struct tstream_bsd *bsds,
1618 struct tevent_context *ev,
1619 void (*handler)(void *private_data),
1620 void *private_data)
1621{
1622 if (ev == NULL) {
1623 if (handler) {
1624 errno = EINVAL;
1625 return -1;
1626 }
1627 if (!bsds->readable_handler) {
1628 return 0;
1629 }
1630 bsds->readable_handler = NULL;
1631 bsds->readable_private = NULL;
1632
1633 return 0;
1634 }
1635
1636 /* read and write must use the same tevent_context */
1637 if (bsds->event_ptr != ev) {
1638 if (bsds->readable_handler || bsds->writeable_handler) {
1639 errno = EINVAL;
1640 return -1;
1641 }
1642 bsds->event_ptr = NULL;
1643 TALLOC_FREE(bsds->fde);
1644 }
1645
1646 if (tevent_fd_get_flags(bsds->fde) == 0) {
1647 TALLOC_FREE(bsds->fde);
1648
1649 bsds->fde = tevent_add_fd(ev, bsds,
1650 bsds->fd, TEVENT_FD_READ,
1651 tstream_bsd_fde_handler,
1652 bsds);
1653 if (!bsds->fde) {
1654 errno = ENOMEM;
1655 return -1;
1656 }
1657
1658 /* cache the event context we're running on */
1659 bsds->event_ptr = ev;
1660 } else if (!bsds->readable_handler) {
1661 TEVENT_FD_READABLE(bsds->fde);
1662 }
1663
1664 bsds->readable_handler = handler;
1665 bsds->readable_private = private_data;
1666
1667 return 0;
1668}
1669
1670static int tstream_bsd_set_writeable_handler(struct tstream_bsd *bsds,
1671 struct tevent_context *ev,
1672 void (*handler)(void *private_data),
1673 void *private_data)
1674{
1675 if (ev == NULL) {
1676 if (handler) {
1677 errno = EINVAL;
1678 return -1;
1679 }
1680 if (!bsds->writeable_handler) {
1681 return 0;
1682 }
1683 bsds->writeable_handler = NULL;
1684 bsds->writeable_private = NULL;
1685 TEVENT_FD_NOT_WRITEABLE(bsds->fde);
1686
1687 return 0;
1688 }
1689
1690 /* read and write must use the same tevent_context */
1691 if (bsds->event_ptr != ev) {
1692 if (bsds->readable_handler || bsds->writeable_handler) {
1693 errno = EINVAL;
1694 return -1;
1695 }
1696 bsds->event_ptr = NULL;
1697 TALLOC_FREE(bsds->fde);
1698 }
1699
1700 if (tevent_fd_get_flags(bsds->fde) == 0) {
1701 TALLOC_FREE(bsds->fde);
1702
1703 bsds->fde = tevent_add_fd(ev, bsds,
1704 bsds->fd,
1705 TEVENT_FD_READ | TEVENT_FD_WRITE,
1706 tstream_bsd_fde_handler,
1707 bsds);
1708 if (!bsds->fde) {
1709 errno = ENOMEM;
1710 return -1;
1711 }
1712
1713 /* cache the event context we're running on */
1714 bsds->event_ptr = ev;
1715 } else if (!bsds->writeable_handler) {
1716 uint16_t flags = tevent_fd_get_flags(bsds->fde);
1717 flags |= TEVENT_FD_READ | TEVENT_FD_WRITE;
1718 tevent_fd_set_flags(bsds->fde, flags);
1719 }
1720
1721 bsds->writeable_handler = handler;
1722 bsds->writeable_private = private_data;
1723
1724 return 0;
1725}
1726
1727static ssize_t tstream_bsd_pending_bytes(struct tstream_context *stream)
1728{
1729 struct tstream_bsd *bsds = tstream_context_data(stream,
1730 struct tstream_bsd);
1731 ssize_t ret;
1732
1733 if (bsds->fd == -1) {
1734 errno = ENOTCONN;
1735 return -1;
1736 }
1737
1738 ret = tsocket_bsd_pending(bsds->fd);
1739
1740 return ret;
1741}
1742
1743struct tstream_bsd_readv_state {
1744 struct tstream_context *stream;
1745
1746 struct iovec *vector;
1747 size_t count;
1748
1749 int ret;
1750};
1751
1752static int tstream_bsd_readv_destructor(struct tstream_bsd_readv_state *state)
1753{
1754 struct tstream_bsd *bsds = tstream_context_data(state->stream,
1755 struct tstream_bsd);
1756
1757 tstream_bsd_set_readable_handler(bsds, NULL, NULL, NULL);
1758
1759 return 0;
1760}
1761
1762static void tstream_bsd_readv_handler(void *private_data);
1763
1764static struct tevent_req *tstream_bsd_readv_send(TALLOC_CTX *mem_ctx,
1765 struct tevent_context *ev,
1766 struct tstream_context *stream,
1767 struct iovec *vector,
1768 size_t count)
1769{
1770 struct tevent_req *req;
1771 struct tstream_bsd_readv_state *state;
1772 struct tstream_bsd *bsds = tstream_context_data(stream, struct tstream_bsd);
1773 int ret;
1774
1775 req = tevent_req_create(mem_ctx, &state,
1776 struct tstream_bsd_readv_state);
1777 if (!req) {
1778 return NULL;
1779 }
1780
1781 state->stream = stream;
1782 /* we make a copy of the vector so that we can modify it */
1783 state->vector = talloc_array(state, struct iovec, count);
1784 if (tevent_req_nomem(state->vector, req)) {
1785 goto post;
1786 }
1787 memcpy(state->vector, vector, sizeof(struct iovec)*count);
1788 state->count = count;
1789 state->ret = 0;
1790
1791 talloc_set_destructor(state, tstream_bsd_readv_destructor);
1792
1793 if (bsds->fd == -1) {
1794 tevent_req_error(req, ENOTCONN);
1795 goto post;
1796 }
1797
1798 /*
1799 * this is a fast path, not waiting for the
1800 * socket to become explicit readable gains
1801 * about 10%-20% performance in benchmark tests.
1802 */
1803 if (bsds->optimize_readv) {
1804 /*
1805 * We only do the optimization on
1806 * readv if the caller asked for it.
1807 *
1808 * This is needed because in most cases
1809 * we prefer to flush send buffers before
1810 * receiving incoming requests.
1811 */
1812 tstream_bsd_readv_handler(req);
1813 if (!tevent_req_is_in_progress(req)) {
1814 goto post;
1815 }
1816 }
1817
1818 ret = tstream_bsd_set_readable_handler(bsds, ev,
1819 tstream_bsd_readv_handler,
1820 req);
1821 if (ret == -1) {
1822 tevent_req_error(req, errno);
1823 goto post;
1824 }
1825
1826 return req;
1827
1828 post:
1829 tevent_req_post(req, ev);
1830 return req;
1831}
1832
1833static void tstream_bsd_readv_handler(void *private_data)
1834{
1835 struct tevent_req *req = talloc_get_type_abort(private_data,
1836 struct tevent_req);
1837 struct tstream_bsd_readv_state *state = tevent_req_data(req,
1838 struct tstream_bsd_readv_state);
1839 struct tstream_context *stream = state->stream;
1840 struct tstream_bsd *bsds = tstream_context_data(stream, struct tstream_bsd);
1841 int ret;
1842 int err;
1843 int _count;
1844 bool ok, retry;
1845
1846 ret = readv(bsds->fd, state->vector, state->count);
1847 if (ret == 0) {
1848 /* propagate end of file */
1849 tevent_req_error(req, EPIPE);
1850 return;
1851 }
1852 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
1853 if (retry) {
1854 /* retry later */
1855 return;
1856 }
1857 if (tevent_req_error(req, err)) {
1858 return;
1859 }
1860
1861 state->ret += ret;
1862
1863 _count = state->count; /* tstream has size_t count, readv has int */
1864 ok = iov_advance(&state->vector, &_count, ret);
1865 state->count = _count;
1866
1867 if (!ok) {
1868 tevent_req_error(req, EINVAL);
1869 return;
1870 }
1871
1872 if (state->count > 0) {
1873 /* we have more to read */
1874 return;
1875 }
1876
1877 tevent_req_done(req);
1878}
1879
1880static int tstream_bsd_readv_recv(struct tevent_req *req,
1881 int *perrno)
1882{
1883 struct tstream_bsd_readv_state *state = tevent_req_data(req,
1884 struct tstream_bsd_readv_state);
1885 int ret;
1886
1887 ret = tsocket_simple_int_recv(req, perrno);
1888 if (ret == 0) {
1889 ret = state->ret;
1890 }
1891
1892 tevent_req_received(req);
1893 return ret;
1894}
1895
1896struct tstream_bsd_writev_state {
1897 struct tstream_context *stream;
1898
1899 struct iovec *vector;
1900 size_t count;
1901
1902 int ret;
1903};
1904
1905static int tstream_bsd_writev_destructor(struct tstream_bsd_writev_state *state)
1906{
1907 struct tstream_bsd *bsds = tstream_context_data(state->stream,
1908 struct tstream_bsd);
1909
1910 tstream_bsd_set_writeable_handler(bsds, NULL, NULL, NULL);
1911
1912 return 0;
1913}
1914
1915static void tstream_bsd_writev_handler(void *private_data);
1916
1917static struct tevent_req *tstream_bsd_writev_send(TALLOC_CTX *mem_ctx,
1918 struct tevent_context *ev,
1919 struct tstream_context *stream,
1920 const struct iovec *vector,
1921 size_t count)
1922{
1923 struct tevent_req *req;
1924 struct tstream_bsd_writev_state *state;
1925 struct tstream_bsd *bsds = tstream_context_data(stream, struct tstream_bsd);
1926 int ret;
1927
1928 req = tevent_req_create(mem_ctx, &state,
1929 struct tstream_bsd_writev_state);
1930 if (!req) {
1931 return NULL;
1932 }
1933
1934 state->stream = stream;
1935 /* we make a copy of the vector so that we can modify it */
1936 state->vector = talloc_array(state, struct iovec, count);
1937 if (tevent_req_nomem(state->vector, req)) {
1938 goto post;
1939 }
1940 memcpy(state->vector, vector, sizeof(struct iovec)*count);
1941 state->count = count;
1942 state->ret = 0;
1943
1944 talloc_set_destructor(state, tstream_bsd_writev_destructor);
1945
1946 if (bsds->fd == -1) {
1947 tevent_req_error(req, ENOTCONN);
1948 goto post;
1949 }
1950
1951 /*
1952 * this is a fast path, not waiting for the
1953 * socket to become explicit writeable gains
1954 * about 10%-20% performance in benchmark tests.
1955 */
1956 tstream_bsd_writev_handler(req);
1957 if (!tevent_req_is_in_progress(req)) {
1958 goto post;
1959 }
1960
1961 ret = tstream_bsd_set_writeable_handler(bsds, ev,
1962 tstream_bsd_writev_handler,
1963 req);
1964 if (ret == -1) {
1965 tevent_req_error(req, errno);
1966 goto post;
1967 }
1968
1969 return req;
1970
1971 post:
1972 tevent_req_post(req, ev);
1973 return req;
1974}
1975
1976static void tstream_bsd_writev_handler(void *private_data)
1977{
1978 struct tevent_req *req = talloc_get_type_abort(private_data,
1979 struct tevent_req);
1980 struct tstream_bsd_writev_state *state = tevent_req_data(req,
1981 struct tstream_bsd_writev_state);
1982 struct tstream_context *stream = state->stream;
1983 struct tstream_bsd *bsds = tstream_context_data(stream, struct tstream_bsd);
1984 ssize_t ret;
1985 int err;
1986 int _count;
1987 bool ok, retry;
1988
1989 ret = writev(bsds->fd, state->vector, state->count);
1990 if (ret == 0) {
1991 /* propagate end of file */
1992 tevent_req_error(req, EPIPE);
1993 return;
1994 }
1995 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
1996 if (retry) {
1997 /* retry later */
1998 return;
1999 }
2000 if (tevent_req_error(req, err)) {
2001 return;
2002 }
2003
2004 state->ret += ret;
2005
2006 _count = state->count; /* tstream has size_t count, writev has int */
2007 ok = iov_advance(&state->vector, &_count, ret);
2008 state->count = _count;
2009
2010 if (!ok) {
2011 tevent_req_error(req, EINVAL);
2012 return;
2013 }
2014
2015 if (state->count > 0) {
2016 /* we have more to read */
2017 return;
2018 }
2019
2020 tevent_req_done(req);
2021}
2022
2023static int tstream_bsd_writev_recv(struct tevent_req *req, int *perrno)
2024{
2025 struct tstream_bsd_writev_state *state = tevent_req_data(req,
2026 struct tstream_bsd_writev_state);
2027 int ret;
2028
2029 ret = tsocket_simple_int_recv(req, perrno);
2030 if (ret == 0) {
2031 ret = state->ret;
2032 }
2033
2034 tevent_req_received(req);
2035 return ret;
2036}
2037
2038struct tstream_bsd_disconnect_state {
2039 void *__dummy;
2040};
2041
2042static struct tevent_req *tstream_bsd_disconnect_send(TALLOC_CTX *mem_ctx,
2043 struct tevent_context *ev,
2044 struct tstream_context *stream)
2045{
2046 struct tstream_bsd *bsds = tstream_context_data(stream, struct tstream_bsd);
2047 struct tevent_req *req;
2048 struct tstream_bsd_disconnect_state *state;
2049 int ret;
2050 int err;
2051 bool dummy;
2052
2053 req = tevent_req_create(mem_ctx, &state,
2054 struct tstream_bsd_disconnect_state);
2055 if (req == NULL) {
2056 return NULL;
2057 }
2058
2059 if (bsds->fd == -1) {
2060 tevent_req_error(req, ENOTCONN);
2061 goto post;
2062 }
2063
2064 TALLOC_FREE(bsds->fde);
2065 ret = close(bsds->fd);
2066 bsds->fd = -1;
2067 err = tsocket_bsd_error_from_errno(ret, errno, &dummy);
2068 if (tevent_req_error(req, err)) {
2069 goto post;
2070 }
2071
2072 tevent_req_done(req);
2073post:
2074 tevent_req_post(req, ev);
2075 return req;
2076}
2077
2078static int tstream_bsd_disconnect_recv(struct tevent_req *req,
2079 int *perrno)
2080{
2081 int ret;
2082
2083 ret = tsocket_simple_int_recv(req, perrno);
2084
2085 tevent_req_received(req);
2086 return ret;
2087}
2088
2089static const struct tstream_context_ops tstream_bsd_ops = {
2090 .name = "bsd",
2091
2092 .pending_bytes = tstream_bsd_pending_bytes,
2093
2094 .readv_send = tstream_bsd_readv_send,
2095 .readv_recv = tstream_bsd_readv_recv,
2096
2097 .writev_send = tstream_bsd_writev_send,
2098 .writev_recv = tstream_bsd_writev_recv,
2099
2100 .disconnect_send = tstream_bsd_disconnect_send,
2101 .disconnect_recv = tstream_bsd_disconnect_recv,
2102};
2103
2104static int tstream_bsd_destructor(struct tstream_bsd *bsds)
2105{
2106 TALLOC_FREE(bsds->fde);
2107 if (bsds->fd != -1) {
2108 close(bsds->fd);
2109 bsds->fd = -1;
2110 }
2111 return 0;
2112}
2113
2114int _tstream_bsd_existing_socket(TALLOC_CTX *mem_ctx,
2115 int fd,
2116 struct tstream_context **_stream,
2117 const char *location)
2118{
2119 struct tstream_context *stream;
2120 struct tstream_bsd *bsds;
2121
2122 stream = tstream_context_create(mem_ctx,
2123 &tstream_bsd_ops,
2124 &bsds,
2125 struct tstream_bsd,
2126 location);
2127 if (!stream) {
2128 return -1;
2129 }
2130 ZERO_STRUCTP(bsds);
2131 bsds->fd = fd;
2132 talloc_set_destructor(bsds, tstream_bsd_destructor);
2133
2134 *_stream = stream;
2135 return 0;
2136}
2137
2138struct tstream_bsd_connect_state {
2139 int fd;
2140 struct tevent_fd *fde;
2141 struct tstream_conext *stream;
2142 struct tsocket_address *local;
2143};
2144
2145static int tstream_bsd_connect_destructor(struct tstream_bsd_connect_state *state)
2146{
2147 TALLOC_FREE(state->fde);
2148 if (state->fd != -1) {
2149 close(state->fd);
2150 state->fd = -1;
2151 }
2152
2153 return 0;
2154}
2155
2156static void tstream_bsd_connect_fde_handler(struct tevent_context *ev,
2157 struct tevent_fd *fde,
2158 uint16_t flags,
2159 void *private_data);
2160
2161static struct tevent_req *tstream_bsd_connect_send(TALLOC_CTX *mem_ctx,
2162 struct tevent_context *ev,
2163 int sys_errno,
2164 const struct tsocket_address *local,
2165 const struct tsocket_address *remote)
2166{
2167 struct tevent_req *req;
2168 struct tstream_bsd_connect_state *state;
2169 struct tsocket_address_bsd *lbsda =
2170 talloc_get_type_abort(local->private_data,
2171 struct tsocket_address_bsd);
2172 struct tsocket_address_bsd *lrbsda = NULL;
2173 struct tsocket_address_bsd *rbsda =
2174 talloc_get_type_abort(remote->private_data,
2175 struct tsocket_address_bsd);
2176 int ret;
2177 bool do_bind = false;
2178 bool do_reuseaddr = false;
2179 bool do_ipv6only = false;
2180 bool is_inet = false;
2181 int sa_fam = lbsda->u.sa.sa_family;
2182
2183 req = tevent_req_create(mem_ctx, &state,
2184 struct tstream_bsd_connect_state);
2185 if (!req) {
2186 return NULL;
2187 }
2188 state->fd = -1;
2189 state->fde = NULL;
2190
2191 talloc_set_destructor(state, tstream_bsd_connect_destructor);
2192
2193 /* give the wrappers a chance to report an error */
2194 if (sys_errno != 0) {
2195 tevent_req_error(req, sys_errno);
2196 goto post;
2197 }
2198
2199 switch (lbsda->u.sa.sa_family) {
2200 case AF_UNIX:
2201 if (lbsda->u.un.sun_path[0] != 0) {
2202 do_reuseaddr = true;
2203 do_bind = true;
2204 }
2205 break;
2206 case AF_INET:
2207 if (lbsda->u.in.sin_port != 0) {
2208 do_reuseaddr = true;
2209 do_bind = true;
2210 }
2211 if (lbsda->u.in.sin_addr.s_addr != INADDR_ANY) {
2212 do_bind = true;
2213 }
2214 is_inet = true;
2215 break;
2216#ifdef HAVE_IPV6
2217 case AF_INET6:
2218 if (lbsda->u.in6.sin6_port != 0) {
2219 do_reuseaddr = true;
2220 do_bind = true;
2221 }
2222 if (memcmp(&in6addr_any,
2223 &lbsda->u.in6.sin6_addr,
2224 sizeof(in6addr_any)) != 0) {
2225 do_bind = true;
2226 }
2227 is_inet = true;
2228 do_ipv6only = true;
2229 break;
2230#endif
2231 default:
2232 tevent_req_error(req, EINVAL);
2233 goto post;
2234 }
2235
2236 if (!do_bind && is_inet) {
2237 sa_fam = rbsda->u.sa.sa_family;
2238 switch (sa_fam) {
2239 case AF_INET:
2240 do_ipv6only = false;
2241 break;
2242#ifdef HAVE_IPV6
2243 case AF_INET6:
2244 do_ipv6only = true;
2245 break;
2246#endif
2247 }
2248 }
2249
2250 if (is_inet) {
2251 state->local = tsocket_address_create(state,
2252 &tsocket_address_bsd_ops,
2253 &lrbsda,
2254 struct tsocket_address_bsd,
2255 __location__ "bsd_connect");
2256 if (tevent_req_nomem(state->local, req)) {
2257 goto post;
2258 }
2259
2260 ZERO_STRUCTP(lrbsda);
2261 lrbsda->sa_socklen = sizeof(lrbsda->u.ss);
2262#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
2263 lrbsda->u.sa.sa_len = lrbsda->sa_socklen;
2264#endif
2265 }
2266
2267 state->fd = socket(sa_fam, SOCK_STREAM, 0);
2268 if (state->fd == -1) {
2269 tevent_req_error(req, errno);
2270 goto post;
2271 }
2272
2273 state->fd = tsocket_bsd_common_prepare_fd(state->fd, true);
2274 if (state->fd == -1) {
2275 tevent_req_error(req, errno);
2276 goto post;
2277 }
2278
2279#ifdef HAVE_IPV6
2280 if (do_ipv6only) {
2281 int val = 1;
2282
2283 ret = setsockopt(state->fd, IPPROTO_IPV6, IPV6_V6ONLY,
2284 (const void *)&val, sizeof(val));
2285 if (ret == -1) {
2286 tevent_req_error(req, errno);
2287 goto post;
2288 }
2289 }
2290#endif
2291
2292 if (do_reuseaddr) {
2293 int val = 1;
2294
2295 ret = setsockopt(state->fd, SOL_SOCKET, SO_REUSEADDR,
2296 (const void *)&val, sizeof(val));
2297 if (ret == -1) {
2298 tevent_req_error(req, errno);
2299 goto post;
2300 }
2301 }
2302
2303 if (do_bind) {
2304 ret = bind(state->fd, &lbsda->u.sa, lbsda->sa_socklen);
2305 if (ret == -1) {
2306 tevent_req_error(req, errno);
2307 goto post;
2308 }
2309 }
2310
2311 if (rbsda->u.sa.sa_family != sa_fam) {
2312 tevent_req_error(req, EINVAL);
2313 goto post;
2314 }
2315
2316 ret = connect(state->fd, &rbsda->u.sa, rbsda->sa_socklen);
2317 if (ret == -1) {
2318 if (errno == EINPROGRESS) {
2319 goto async;
2320 }
2321 tevent_req_error(req, errno);
2322 goto post;
2323 }
2324
2325 if (!state->local) {
2326 tevent_req_done(req);
2327 goto post;
2328 }
2329
2330 ret = getsockname(state->fd, &lrbsda->u.sa, &lrbsda->sa_socklen);
2331 if (ret == -1) {
2332 tevent_req_error(req, errno);
2333 goto post;
2334 }
2335
2336 tevent_req_done(req);
2337 goto post;
2338
2339 async:
2340 state->fde = tevent_add_fd(ev, state,
2341 state->fd,
2342 TEVENT_FD_READ | TEVENT_FD_WRITE,
2343 tstream_bsd_connect_fde_handler,
2344 req);
2345 if (tevent_req_nomem(state->fde, req)) {
2346 goto post;
2347 }
2348
2349 return req;
2350
2351 post:
2352 tevent_req_post(req, ev);
2353 return req;
2354}
2355
2356static void tstream_bsd_connect_fde_handler(struct tevent_context *ev,
2357 struct tevent_fd *fde,
2358 uint16_t flags,
2359 void *private_data)
2360{
2361 struct tevent_req *req = talloc_get_type_abort(private_data,
2362 struct tevent_req);
2363 struct tstream_bsd_connect_state *state = tevent_req_data(req,
2364 struct tstream_bsd_connect_state);
2365 struct tsocket_address_bsd *lrbsda = NULL;
2366 int ret;
2367 int error=0;
2368 socklen_t len = sizeof(error);
2369 int err;
2370 bool retry;
2371
2372 ret = getsockopt(state->fd, SOL_SOCKET, SO_ERROR, &error, &len);
2373 if (ret == 0) {
2374 if (error != 0) {
2375 errno = error;
2376 ret = -1;
2377 }
2378 }
2379 err = tsocket_bsd_error_from_errno(ret, errno, &retry);
2380 if (retry) {
2381 /* retry later */
2382 return;
2383 }
2384 if (tevent_req_error(req, err)) {
2385 return;
2386 }
2387
2388 if (!state->local) {
2389 tevent_req_done(req);
2390 return;
2391 }
2392
2393 lrbsda = talloc_get_type_abort(state->local->private_data,
2394 struct tsocket_address_bsd);
2395
2396 ret = getsockname(state->fd, &lrbsda->u.sa, &lrbsda->sa_socklen);
2397 if (ret == -1) {
2398 tevent_req_error(req, errno);
2399 return;
2400 }
2401
2402 tevent_req_done(req);
2403}
2404
2405static int tstream_bsd_connect_recv(struct tevent_req *req,
2406 int *perrno,
2407 TALLOC_CTX *mem_ctx,
2408 struct tstream_context **stream,
2409 struct tsocket_address **local,
2410 const char *location)
2411{
2412 struct tstream_bsd_connect_state *state = tevent_req_data(req,
2413 struct tstream_bsd_connect_state);
2414 int ret;
2415
2416 ret = tsocket_simple_int_recv(req, perrno);
2417 if (ret == 0) {
2418 ret = _tstream_bsd_existing_socket(mem_ctx,
2419 state->fd,
2420 stream,
2421 location);
2422 if (ret == -1) {
2423 *perrno = errno;
2424 goto done;
2425 }
2426 TALLOC_FREE(state->fde);
2427 state->fd = -1;
2428
2429 if (local) {
2430 *local = talloc_move(mem_ctx, &state->local);
2431 }
2432 }
2433
2434done:
2435 tevent_req_received(req);
2436 return ret;
2437}
2438
2439struct tevent_req * tstream_inet_tcp_connect_send(TALLOC_CTX *mem_ctx,
2440 struct tevent_context *ev,
2441 const struct tsocket_address *local,
2442 const struct tsocket_address *remote)
2443{
2444 struct tsocket_address_bsd *lbsda =
2445 talloc_get_type_abort(local->private_data,
2446 struct tsocket_address_bsd);
2447 struct tevent_req *req;
2448 int sys_errno = 0;
2449
2450 switch (lbsda->u.sa.sa_family) {
2451 case AF_INET:
2452 break;
2453#ifdef HAVE_IPV6
2454 case AF_INET6:
2455 break;
2456#endif
2457 default:
2458 sys_errno = EINVAL;
2459 break;
2460 }
2461
2462 req = tstream_bsd_connect_send(mem_ctx, ev, sys_errno, local, remote);
2463
2464 return req;
2465}
2466
2467int _tstream_inet_tcp_connect_recv(struct tevent_req *req,
2468 int *perrno,
2469 TALLOC_CTX *mem_ctx,
2470 struct tstream_context **stream,
2471 struct tsocket_address **local,
2472 const char *location)
2473{
2474 return tstream_bsd_connect_recv(req, perrno,
2475 mem_ctx, stream, local,
2476 location);
2477}
2478
2479struct tevent_req * tstream_unix_connect_send(TALLOC_CTX *mem_ctx,
2480 struct tevent_context *ev,
2481 const struct tsocket_address *local,
2482 const struct tsocket_address *remote)
2483{
2484 struct tsocket_address_bsd *lbsda =
2485 talloc_get_type_abort(local->private_data,
2486 struct tsocket_address_bsd);
2487 struct tevent_req *req;
2488 int sys_errno = 0;
2489
2490 switch (lbsda->u.sa.sa_family) {
2491 case AF_UNIX:
2492 break;
2493 default:
2494 sys_errno = EINVAL;
2495 break;
2496 }
2497
2498 req = tstream_bsd_connect_send(mem_ctx, ev, sys_errno, local, remote);
2499
2500 return req;
2501}
2502
2503int _tstream_unix_connect_recv(struct tevent_req *req,
2504 int *perrno,
2505 TALLOC_CTX *mem_ctx,
2506 struct tstream_context **stream,
2507 const char *location)
2508{
2509 return tstream_bsd_connect_recv(req, perrno,
2510 mem_ctx, stream, NULL,
2511 location);
2512}
2513
2514int _tstream_unix_socketpair(TALLOC_CTX *mem_ctx1,
2515 struct tstream_context **_stream1,
2516 TALLOC_CTX *mem_ctx2,
2517 struct tstream_context **_stream2,
2518 const char *location)
2519{
2520 int ret;
2521 int fds[2];
2522 int fd1;
2523 int fd2;
2524 struct tstream_context *stream1 = NULL;
2525 struct tstream_context *stream2 = NULL;
2526
2527 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
2528 if (ret == -1) {
2529 return -1;
2530 }
2531 fd1 = fds[0];
2532 fd2 = fds[1];
2533
2534 fd1 = tsocket_bsd_common_prepare_fd(fd1, true);
2535 if (fd1 == -1) {
2536 int sys_errno = errno;
2537 close(fd2);
2538 errno = sys_errno;
2539 return -1;
2540 }
2541
2542 fd2 = tsocket_bsd_common_prepare_fd(fd2, true);
2543 if (fd2 == -1) {
2544 int sys_errno = errno;
2545 close(fd1);
2546 errno = sys_errno;
2547 return -1;
2548 }
2549
2550 ret = _tstream_bsd_existing_socket(mem_ctx1,
2551 fd1,
2552 &stream1,
2553 location);
2554 if (ret == -1) {
2555 int sys_errno = errno;
2556 close(fd1);
2557 close(fd2);
2558 errno = sys_errno;
2559 return -1;
2560 }
2561
2562 ret = _tstream_bsd_existing_socket(mem_ctx2,
2563 fd2,
2564 &stream2,
2565 location);
2566 if (ret == -1) {
2567 int sys_errno = errno;
2568 talloc_free(stream1);
2569 close(fd2);
2570 errno = sys_errno;
2571 return -1;
2572 }
2573
2574 *_stream1 = stream1;
2575 *_stream2 = stream2;
2576 return 0;
2577}
2578
Note: See TracBrowser for help on using the repository browser.