2 Unix SMB/CIFS implementation.
4 Copyright (C) Stefan Metzmacher 2009
6 ** NOTE! The following LGPL license applies to the tsocket
7 ** library. This does NOT imply that all of Samba is released
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.
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.
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/>.
25 #include "system/filesys.h"
26 #include "system/network.h"
28 #include "tsocket_internal.h"
30 static int tsocket_bsd_error_from_errno(int ret
,
48 if (sys_errno
== EINTR
) {
53 if (sys_errno
== EINPROGRESS
) {
58 if (sys_errno
== EAGAIN
) {
64 if (sys_errno
== EWOULDBLOCK
) {
73 static int tsocket_bsd_common_prepare_fd(int fd
, bool high_fd
)
86 /* first make a fd >= 3 */
96 for (i
=0; i
<num_fds
; i
++) {
105 /* fd should be nonblocking. */
108 #define FLAG_TO_SET O_NONBLOCK
111 #define FLAG_TO_SET O_NDELAY
113 #define FLAG_TO_SET FNDELAY
117 if ((flags
= fcntl(fd
, F_GETFL
)) == -1) {
121 flags
|= FLAG_TO_SET
;
122 if (fcntl(fd
, F_SETFL
, flags
) == -1) {
128 /* fd should be closed on exec() */
130 result
= flags
= fcntl(fd
, F_GETFD
, 0);
133 result
= fcntl(fd
, F_SETFD
, flags
);
150 static ssize_t
tsocket_bsd_pending(int fd
)
156 ret
= ioctl(fd
, FIONREAD
, &value
);
162 /* this should not be reached */
175 * if no data is available check if the socket is in error state. For
176 * dgram sockets it's the way to return ICMP error messages of
177 * connected sockets to the caller.
179 ret
= getsockopt(fd
, SOL_SOCKET
, SO_ERROR
, &error
, &len
);
190 static const struct tsocket_address_ops tsocket_address_bsd_ops
;
192 struct tsocket_address_bsd
{
193 socklen_t sa_socklen
;
196 struct sockaddr_in in
;
198 struct sockaddr_in6 in6
;
200 struct sockaddr_un un
;
201 struct sockaddr_storage ss
;
205 int _tsocket_address_bsd_from_sockaddr(TALLOC_CTX
*mem_ctx
,
208 struct tsocket_address
**_addr
,
209 const char *location
)
211 struct tsocket_address
*addr
;
212 struct tsocket_address_bsd
*bsda
;
214 if (sa_socklen
< sizeof(sa
->sa_family
)) {
219 switch (sa
->sa_family
) {
221 if (sa_socklen
> sizeof(struct sockaddr_un
)) {
222 sa_socklen
= sizeof(struct sockaddr_un
);
226 if (sa_socklen
< sizeof(struct sockaddr_in
)) {
230 sa_socklen
= sizeof(struct sockaddr_in
);
234 if (sa_socklen
< sizeof(struct sockaddr_in6
)) {
238 sa_socklen
= sizeof(struct sockaddr_in6
);
242 errno
= EAFNOSUPPORT
;
246 if (sa_socklen
> sizeof(struct sockaddr_storage
)) {
251 addr
= tsocket_address_create(mem_ctx
,
252 &tsocket_address_bsd_ops
,
254 struct tsocket_address_bsd
,
263 memcpy(&bsda
->u
.ss
, sa
, sa_socklen
);
265 bsda
->sa_socklen
= sa_socklen
;
271 ssize_t
tsocket_address_bsd_sockaddr(const struct tsocket_address
*addr
,
275 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
276 struct tsocket_address_bsd
);
283 if (sa_socklen
< bsda
->sa_socklen
) {
288 if (sa_socklen
> bsda
->sa_socklen
) {
289 memset(sa
, 0, sa_socklen
);
290 sa_socklen
= bsda
->sa_socklen
;
293 memcpy(sa
, &bsda
->u
.ss
, sa_socklen
);
297 int _tsocket_address_inet_from_strings(TALLOC_CTX
*mem_ctx
,
301 struct tsocket_address
**_addr
,
302 const char *location
)
304 struct addrinfo hints
;
305 struct addrinfo
*result
= NULL
;
311 * we use SOCKET_STREAM here to get just one result
312 * back from getaddrinfo().
314 hints
.ai_socktype
= SOCK_STREAM
;
315 hints
.ai_flags
= AI_NUMERICHOST
| AI_NUMERICSERV
;
317 if (strcasecmp(fam
, "ip") == 0) {
318 hints
.ai_family
= AF_UNSPEC
;
326 } else if (strcasecmp(fam
, "ipv4") == 0) {
327 hints
.ai_family
= AF_INET
;
332 } else if (strcasecmp(fam
, "ipv6") == 0) {
333 hints
.ai_family
= AF_INET6
;
339 errno
= EAFNOSUPPORT
;
343 snprintf(port_str
, sizeof(port_str
) - 1, "%u", port
);
345 ret
= getaddrinfo(addr
, port_str
, &hints
, &result
);
356 if (result
->ai_socktype
!= SOCK_STREAM
) {
362 ret
= _tsocket_address_bsd_from_sockaddr(mem_ctx
,
370 freeaddrinfo(result
);
375 char *tsocket_address_inet_addr_string(const struct tsocket_address
*addr
,
378 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
379 struct tsocket_address_bsd
);
380 char addr_str
[INET6_ADDRSTRLEN
+1];
388 switch (bsda
->u
.sa
.sa_family
) {
390 str
= inet_ntop(bsda
->u
.in
.sin_family
,
391 &bsda
->u
.in
.sin_addr
,
392 addr_str
, sizeof(addr_str
));
396 str
= inet_ntop(bsda
->u
.in6
.sin6_family
,
397 &bsda
->u
.in6
.sin6_addr
,
398 addr_str
, sizeof(addr_str
));
410 return talloc_strdup(mem_ctx
, str
);
413 uint16_t tsocket_address_inet_port(const struct tsocket_address
*addr
)
415 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
416 struct tsocket_address_bsd
);
424 switch (bsda
->u
.sa
.sa_family
) {
426 port
= ntohs(bsda
->u
.in
.sin_port
);
430 port
= ntohs(bsda
->u
.in6
.sin6_port
);
441 int tsocket_address_inet_set_port(struct tsocket_address
*addr
,
444 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
445 struct tsocket_address_bsd
);
452 switch (bsda
->u
.sa
.sa_family
) {
454 bsda
->u
.in
.sin_port
= htons(port
);
458 bsda
->u
.in6
.sin6_port
= htons(port
);
469 int _tsocket_address_unix_from_path(TALLOC_CTX
*mem_ctx
,
471 struct tsocket_address
**_addr
,
472 const char *location
)
474 struct sockaddr_un un
;
482 if (strlen(path
) > sizeof(un
.sun_path
)-1) {
483 errno
= ENAMETOOLONG
;
488 un
.sun_family
= AF_UNIX
;
489 strncpy(un
.sun_path
, path
, sizeof(un
.sun_path
)-1);
491 ret
= _tsocket_address_bsd_from_sockaddr(mem_ctx
,
492 (struct sockaddr
*)p
,
500 char *tsocket_address_unix_path(const struct tsocket_address
*addr
,
503 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
504 struct tsocket_address_bsd
);
512 switch (bsda
->u
.sa
.sa_family
) {
514 str
= bsda
->u
.un
.sun_path
;
521 return talloc_strdup(mem_ctx
, str
);
524 static char *tsocket_address_bsd_string(const struct tsocket_address
*addr
,
527 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
528 struct tsocket_address_bsd
);
531 const char *prefix
= NULL
;
534 switch (bsda
->u
.sa
.sa_family
) {
536 return talloc_asprintf(mem_ctx
, "unix:%s",
537 bsda
->u
.un
.sun_path
);
551 addr_str
= tsocket_address_inet_addr_string(addr
, mem_ctx
);
556 port
= tsocket_address_inet_port(addr
);
558 str
= talloc_asprintf(mem_ctx
, "%s:%s:%u",
559 prefix
, addr_str
, port
);
560 talloc_free(addr_str
);
565 static struct tsocket_address
*tsocket_address_bsd_copy(const struct tsocket_address
*addr
,
567 const char *location
)
569 struct tsocket_address_bsd
*bsda
= talloc_get_type(addr
->private_data
,
570 struct tsocket_address_bsd
);
571 struct tsocket_address
*copy
;
574 ret
= _tsocket_address_bsd_from_sockaddr(mem_ctx
,
586 static const struct tsocket_address_ops tsocket_address_bsd_ops
= {
588 .string
= tsocket_address_bsd_string
,
589 .copy
= tsocket_address_bsd_copy
,
596 struct tevent_fd
*fde
;
598 void *readable_private
;
599 void (*readable_handler
)(void *private_data
);
600 void *writeable_private
;
601 void (*writeable_handler
)(void *private_data
);
604 static void tdgram_bsd_fde_handler(struct tevent_context
*ev
,
605 struct tevent_fd
*fde
,
609 struct tdgram_bsd
*bsds
= talloc_get_type_abort(private_data
,
612 if (flags
& TEVENT_FD_WRITE
) {
613 bsds
->writeable_handler(bsds
->writeable_private
);
616 if (flags
& TEVENT_FD_READ
) {
617 if (!bsds
->readable_handler
) {
618 TEVENT_FD_NOT_READABLE(bsds
->fde
);
621 bsds
->readable_handler(bsds
->readable_private
);
626 static int tdgram_bsd_set_readable_handler(struct tdgram_bsd
*bsds
,
627 struct tevent_context
*ev
,
628 void (*handler
)(void *private_data
),
636 if (!bsds
->readable_handler
) {
639 bsds
->readable_handler
= NULL
;
640 bsds
->readable_private
= NULL
;
645 /* read and write must use the same tevent_context */
646 if (bsds
->event_ptr
!= ev
) {
647 if (bsds
->readable_handler
|| bsds
->writeable_handler
) {
651 bsds
->event_ptr
= NULL
;
652 TALLOC_FREE(bsds
->fde
);
655 if (tevent_fd_get_flags(bsds
->fde
) == 0) {
656 TALLOC_FREE(bsds
->fde
);
658 bsds
->fde
= tevent_add_fd(ev
, bsds
,
659 bsds
->fd
, TEVENT_FD_READ
,
660 tdgram_bsd_fde_handler
,
667 /* cache the event context we're running on */
668 bsds
->event_ptr
= ev
;
669 } else if (!bsds
->readable_handler
) {
670 TEVENT_FD_READABLE(bsds
->fde
);
673 bsds
->readable_handler
= handler
;
674 bsds
->readable_private
= private_data
;
679 static int tdgram_bsd_set_writeable_handler(struct tdgram_bsd
*bsds
,
680 struct tevent_context
*ev
,
681 void (*handler
)(void *private_data
),
689 if (!bsds
->writeable_handler
) {
692 bsds
->writeable_handler
= NULL
;
693 bsds
->writeable_private
= NULL
;
694 TEVENT_FD_NOT_WRITEABLE(bsds
->fde
);
699 /* read and write must use the same tevent_context */
700 if (bsds
->event_ptr
!= ev
) {
701 if (bsds
->readable_handler
|| bsds
->writeable_handler
) {
705 bsds
->event_ptr
= NULL
;
706 TALLOC_FREE(bsds
->fde
);
709 if (tevent_fd_get_flags(bsds
->fde
) == 0) {
710 TALLOC_FREE(bsds
->fde
);
712 bsds
->fde
= tevent_add_fd(ev
, bsds
,
713 bsds
->fd
, TEVENT_FD_WRITE
,
714 tdgram_bsd_fde_handler
,
721 /* cache the event context we're running on */
722 bsds
->event_ptr
= ev
;
723 } else if (!bsds
->writeable_handler
) {
724 TEVENT_FD_WRITEABLE(bsds
->fde
);
727 bsds
->writeable_handler
= handler
;
728 bsds
->writeable_private
= private_data
;
733 struct tdgram_bsd_recvfrom_state
{
734 struct tdgram_context
*dgram
;
738 struct tsocket_address
*src
;
741 static int tdgram_bsd_recvfrom_destructor(struct tdgram_bsd_recvfrom_state
*state
)
743 struct tdgram_bsd
*bsds
= tdgram_context_data(state
->dgram
,
746 tdgram_bsd_set_readable_handler(bsds
, NULL
, NULL
, NULL
);
751 static void tdgram_bsd_recvfrom_handler(void *private_data
);
753 static struct tevent_req
*tdgram_bsd_recvfrom_send(TALLOC_CTX
*mem_ctx
,
754 struct tevent_context
*ev
,
755 struct tdgram_context
*dgram
)
757 struct tevent_req
*req
;
758 struct tdgram_bsd_recvfrom_state
*state
;
759 struct tdgram_bsd
*bsds
= tdgram_context_data(dgram
, struct tdgram_bsd
);
762 req
= tevent_req_create(mem_ctx
, &state
,
763 struct tdgram_bsd_recvfrom_state
);
768 state
->dgram
= dgram
;
773 talloc_set_destructor(state
, tdgram_bsd_recvfrom_destructor
);
775 if (bsds
->fd
== -1) {
776 tevent_req_error(req
, ENOTCONN
);
781 * this is a fast path, not waiting for the
782 * socket to become explicit readable gains
783 * about 10%-20% performance in benchmark tests.
785 tdgram_bsd_recvfrom_handler(req
);
786 if (!tevent_req_is_in_progress(req
)) {
790 ret
= tdgram_bsd_set_readable_handler(bsds
, ev
,
791 tdgram_bsd_recvfrom_handler
,
794 tevent_req_error(req
, errno
);
801 tevent_req_post(req
, ev
);
805 static void tdgram_bsd_recvfrom_handler(void *private_data
)
807 struct tevent_req
*req
= talloc_get_type_abort(private_data
,
809 struct tdgram_bsd_recvfrom_state
*state
= tevent_req_data(req
,
810 struct tdgram_bsd_recvfrom_state
);
811 struct tdgram_context
*dgram
= state
->dgram
;
812 struct tdgram_bsd
*bsds
= tdgram_context_data(dgram
, struct tdgram_bsd
);
813 struct tsocket_address_bsd
*bsda
;
818 ret
= tsocket_bsd_pending(bsds
->fd
);
823 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
828 if (tevent_req_error(req
, err
)) {
832 state
->buf
= talloc_array(state
, uint8_t, ret
);
833 if (tevent_req_nomem(state
->buf
, req
)) {
838 state
->src
= tsocket_address_create(state
,
839 &tsocket_address_bsd_ops
,
841 struct tsocket_address_bsd
,
842 __location__
"bsd_recvfrom");
843 if (tevent_req_nomem(state
->src
, req
)) {
848 bsda
->sa_socklen
= sizeof(bsda
->u
.ss
);
850 ret
= recvfrom(bsds
->fd
, state
->buf
, state
->len
, 0,
851 &bsda
->u
.sa
, &bsda
->sa_socklen
);
852 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
857 if (tevent_req_error(req
, err
)) {
862 * Some systems (FreeBSD, see bug #7115) return too much
863 * bytes in tsocket_bsd_pending()/ioctl(fd, FIONREAD, ...),
864 * the return value includes some IP/UDP header bytes,
865 * while recvfrom() just returns the payload.
867 state
->buf
= talloc_realloc(state
, state
->buf
, uint8_t, ret
);
868 if (tevent_req_nomem(state
->buf
, req
)) {
873 tevent_req_done(req
);
876 static ssize_t
tdgram_bsd_recvfrom_recv(struct tevent_req
*req
,
880 struct tsocket_address
**src
)
882 struct tdgram_bsd_recvfrom_state
*state
= tevent_req_data(req
,
883 struct tdgram_bsd_recvfrom_state
);
886 ret
= tsocket_simple_int_recv(req
, perrno
);
888 *buf
= talloc_move(mem_ctx
, &state
->buf
);
891 *src
= talloc_move(mem_ctx
, &state
->src
);
895 tevent_req_received(req
);
899 struct tdgram_bsd_sendto_state
{
900 struct tdgram_context
*dgram
;
904 const struct tsocket_address
*dst
;
909 static int tdgram_bsd_sendto_destructor(struct tdgram_bsd_sendto_state
*state
)
911 struct tdgram_bsd
*bsds
= tdgram_context_data(state
->dgram
,
914 tdgram_bsd_set_writeable_handler(bsds
, NULL
, NULL
, NULL
);
919 static void tdgram_bsd_sendto_handler(void *private_data
);
921 static struct tevent_req
*tdgram_bsd_sendto_send(TALLOC_CTX
*mem_ctx
,
922 struct tevent_context
*ev
,
923 struct tdgram_context
*dgram
,
926 const struct tsocket_address
*dst
)
928 struct tevent_req
*req
;
929 struct tdgram_bsd_sendto_state
*state
;
930 struct tdgram_bsd
*bsds
= tdgram_context_data(dgram
, struct tdgram_bsd
);
933 req
= tevent_req_create(mem_ctx
, &state
,
934 struct tdgram_bsd_sendto_state
);
939 state
->dgram
= dgram
;
945 talloc_set_destructor(state
, tdgram_bsd_sendto_destructor
);
947 if (bsds
->fd
== -1) {
948 tevent_req_error(req
, ENOTCONN
);
953 * this is a fast path, not waiting for the
954 * socket to become explicit writeable gains
955 * about 10%-20% performance in benchmark tests.
957 tdgram_bsd_sendto_handler(req
);
958 if (!tevent_req_is_in_progress(req
)) {
962 ret
= tdgram_bsd_set_writeable_handler(bsds
, ev
,
963 tdgram_bsd_sendto_handler
,
966 tevent_req_error(req
, errno
);
973 tevent_req_post(req
, ev
);
977 static void tdgram_bsd_sendto_handler(void *private_data
)
979 struct tevent_req
*req
= talloc_get_type_abort(private_data
,
981 struct tdgram_bsd_sendto_state
*state
= tevent_req_data(req
,
982 struct tdgram_bsd_sendto_state
);
983 struct tdgram_context
*dgram
= state
->dgram
;
984 struct tdgram_bsd
*bsds
= tdgram_context_data(dgram
, struct tdgram_bsd
);
985 struct sockaddr
*sa
= NULL
;
986 socklen_t sa_socklen
= 0;
992 struct tsocket_address_bsd
*bsda
=
993 talloc_get_type(state
->dst
->private_data
,
994 struct tsocket_address_bsd
);
997 sa_socklen
= bsda
->sa_socklen
;
1000 ret
= sendto(bsds
->fd
, state
->buf
, state
->len
, 0, sa
, sa_socklen
);
1001 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
1006 if (tevent_req_error(req
, err
)) {
1012 tevent_req_done(req
);
1015 static ssize_t
tdgram_bsd_sendto_recv(struct tevent_req
*req
, int *perrno
)
1017 struct tdgram_bsd_sendto_state
*state
= tevent_req_data(req
,
1018 struct tdgram_bsd_sendto_state
);
1021 ret
= tsocket_simple_int_recv(req
, perrno
);
1026 tevent_req_received(req
);
1030 struct tdgram_bsd_disconnect_state
{
1034 static struct tevent_req
*tdgram_bsd_disconnect_send(TALLOC_CTX
*mem_ctx
,
1035 struct tevent_context
*ev
,
1036 struct tdgram_context
*dgram
)
1038 struct tdgram_bsd
*bsds
= tdgram_context_data(dgram
, struct tdgram_bsd
);
1039 struct tevent_req
*req
;
1040 struct tdgram_bsd_disconnect_state
*state
;
1045 req
= tevent_req_create(mem_ctx
, &state
,
1046 struct tdgram_bsd_disconnect_state
);
1051 if (bsds
->fd
== -1) {
1052 tevent_req_error(req
, ENOTCONN
);
1056 ret
= close(bsds
->fd
);
1058 err
= tsocket_bsd_error_from_errno(ret
, errno
, &dummy
);
1059 if (tevent_req_error(req
, err
)) {
1063 tevent_req_done(req
);
1065 tevent_req_post(req
, ev
);
1069 static int tdgram_bsd_disconnect_recv(struct tevent_req
*req
,
1074 ret
= tsocket_simple_int_recv(req
, perrno
);
1076 tevent_req_received(req
);
1080 static const struct tdgram_context_ops tdgram_bsd_ops
= {
1083 .recvfrom_send
= tdgram_bsd_recvfrom_send
,
1084 .recvfrom_recv
= tdgram_bsd_recvfrom_recv
,
1086 .sendto_send
= tdgram_bsd_sendto_send
,
1087 .sendto_recv
= tdgram_bsd_sendto_recv
,
1089 .disconnect_send
= tdgram_bsd_disconnect_send
,
1090 .disconnect_recv
= tdgram_bsd_disconnect_recv
,
1093 static int tdgram_bsd_destructor(struct tdgram_bsd
*bsds
)
1095 TALLOC_FREE(bsds
->fde
);
1096 if (bsds
->fd
!= -1) {
1103 static int tdgram_bsd_dgram_socket(const struct tsocket_address
*local
,
1104 const struct tsocket_address
*remote
,
1106 TALLOC_CTX
*mem_ctx
,
1107 struct tdgram_context
**_dgram
,
1108 const char *location
)
1110 struct tsocket_address_bsd
*lbsda
=
1111 talloc_get_type_abort(local
->private_data
,
1112 struct tsocket_address_bsd
);
1113 struct tsocket_address_bsd
*rbsda
= NULL
;
1114 struct tdgram_context
*dgram
;
1115 struct tdgram_bsd
*bsds
;
1118 bool do_bind
= false;
1119 bool do_reuseaddr
= false;
1120 bool do_ipv6only
= false;
1121 bool is_inet
= false;
1122 int sa_fam
= lbsda
->u
.sa
.sa_family
;
1125 rbsda
= talloc_get_type_abort(remote
->private_data
,
1126 struct tsocket_address_bsd
);
1129 switch (lbsda
->u
.sa
.sa_family
) {
1135 if (lbsda
->u
.un
.sun_path
[0] != 0) {
1136 do_reuseaddr
= true;
1141 if (lbsda
->u
.in
.sin_port
!= 0) {
1142 do_reuseaddr
= true;
1145 if (lbsda
->u
.in
.sin_addr
.s_addr
!= INADDR_ANY
) {
1152 if (lbsda
->u
.in6
.sin6_port
!= 0) {
1153 do_reuseaddr
= true;
1156 if (memcmp(&in6addr_any
,
1157 &lbsda
->u
.in6
.sin6_addr
,
1158 sizeof(in6addr_any
)) != 0) {
1170 if (!do_bind
&& is_inet
&& rbsda
) {
1171 sa_fam
= rbsda
->u
.sa
.sa_family
;
1174 do_ipv6only
= false;
1184 fd
= socket(sa_fam
, SOCK_DGRAM
, 0);
1189 fd
= tsocket_bsd_common_prepare_fd(fd
, true);
1194 dgram
= tdgram_context_create(mem_ctx
,
1200 int saved_errno
= errno
;
1202 errno
= saved_errno
;
1207 talloc_set_destructor(bsds
, tdgram_bsd_destructor
);
1213 ret
= setsockopt(fd
, IPPROTO_IPV6
, IPV6_V6ONLY
,
1214 (const void *)&val
, sizeof(val
));
1216 int saved_errno
= errno
;
1218 errno
= saved_errno
;
1227 ret
= setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
,
1228 (const void *)&val
, sizeof(val
));
1230 int saved_errno
= errno
;
1232 errno
= saved_errno
;
1240 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
1241 (const void *)&val
, sizeof(val
));
1243 int saved_errno
= errno
;
1245 errno
= saved_errno
;
1251 ret
= bind(fd
, &lbsda
->u
.sa
, lbsda
->sa_socklen
);
1253 int saved_errno
= errno
;
1255 errno
= saved_errno
;
1261 if (rbsda
->u
.sa
.sa_family
!= sa_fam
) {
1267 ret
= connect(fd
, &rbsda
->u
.sa
, rbsda
->sa_socklen
);
1269 int saved_errno
= errno
;
1271 errno
= saved_errno
;
1280 int _tdgram_inet_udp_socket(const struct tsocket_address
*local
,
1281 const struct tsocket_address
*remote
,
1282 TALLOC_CTX
*mem_ctx
,
1283 struct tdgram_context
**dgram
,
1284 const char *location
)
1286 struct tsocket_address_bsd
*lbsda
=
1287 talloc_get_type_abort(local
->private_data
,
1288 struct tsocket_address_bsd
);
1291 switch (lbsda
->u
.sa
.sa_family
) {
1303 ret
= tdgram_bsd_dgram_socket(local
, remote
, false,
1304 mem_ctx
, dgram
, location
);
1309 int _tdgram_unix_socket(const struct tsocket_address
*local
,
1310 const struct tsocket_address
*remote
,
1311 TALLOC_CTX
*mem_ctx
,
1312 struct tdgram_context
**dgram
,
1313 const char *location
)
1315 struct tsocket_address_bsd
*lbsda
=
1316 talloc_get_type_abort(local
->private_data
,
1317 struct tsocket_address_bsd
);
1320 switch (lbsda
->u
.sa
.sa_family
) {
1328 ret
= tdgram_bsd_dgram_socket(local
, remote
, false,
1329 mem_ctx
, dgram
, location
);
1334 struct tstream_bsd
{
1338 struct tevent_fd
*fde
;
1340 void *readable_private
;
1341 void (*readable_handler
)(void *private_data
);
1342 void *writeable_private
;
1343 void (*writeable_handler
)(void *private_data
);
1346 static void tstream_bsd_fde_handler(struct tevent_context
*ev
,
1347 struct tevent_fd
*fde
,
1351 struct tstream_bsd
*bsds
= talloc_get_type_abort(private_data
,
1352 struct tstream_bsd
);
1354 if (flags
& TEVENT_FD_WRITE
) {
1355 bsds
->writeable_handler(bsds
->writeable_private
);
1358 if (flags
& TEVENT_FD_READ
) {
1359 if (!bsds
->readable_handler
) {
1360 if (bsds
->writeable_handler
) {
1361 bsds
->writeable_handler(bsds
->writeable_private
);
1364 TEVENT_FD_NOT_READABLE(bsds
->fde
);
1367 bsds
->readable_handler(bsds
->readable_private
);
1372 static int tstream_bsd_set_readable_handler(struct tstream_bsd
*bsds
,
1373 struct tevent_context
*ev
,
1374 void (*handler
)(void *private_data
),
1382 if (!bsds
->readable_handler
) {
1385 bsds
->readable_handler
= NULL
;
1386 bsds
->readable_private
= NULL
;
1391 /* read and write must use the same tevent_context */
1392 if (bsds
->event_ptr
!= ev
) {
1393 if (bsds
->readable_handler
|| bsds
->writeable_handler
) {
1397 bsds
->event_ptr
= NULL
;
1398 TALLOC_FREE(bsds
->fde
);
1401 if (tevent_fd_get_flags(bsds
->fde
) == 0) {
1402 TALLOC_FREE(bsds
->fde
);
1404 bsds
->fde
= tevent_add_fd(ev
, bsds
,
1405 bsds
->fd
, TEVENT_FD_READ
,
1406 tstream_bsd_fde_handler
,
1413 /* cache the event context we're running on */
1414 bsds
->event_ptr
= ev
;
1415 } else if (!bsds
->readable_handler
) {
1416 TEVENT_FD_READABLE(bsds
->fde
);
1419 bsds
->readable_handler
= handler
;
1420 bsds
->readable_private
= private_data
;
1425 static int tstream_bsd_set_writeable_handler(struct tstream_bsd
*bsds
,
1426 struct tevent_context
*ev
,
1427 void (*handler
)(void *private_data
),
1435 if (!bsds
->writeable_handler
) {
1438 bsds
->writeable_handler
= NULL
;
1439 bsds
->writeable_private
= NULL
;
1440 TEVENT_FD_NOT_WRITEABLE(bsds
->fde
);
1445 /* read and write must use the same tevent_context */
1446 if (bsds
->event_ptr
!= ev
) {
1447 if (bsds
->readable_handler
|| bsds
->writeable_handler
) {
1451 bsds
->event_ptr
= NULL
;
1452 TALLOC_FREE(bsds
->fde
);
1455 if (tevent_fd_get_flags(bsds
->fde
) == 0) {
1456 TALLOC_FREE(bsds
->fde
);
1458 bsds
->fde
= tevent_add_fd(ev
, bsds
,
1460 TEVENT_FD_READ
| TEVENT_FD_WRITE
,
1461 tstream_bsd_fde_handler
,
1468 /* cache the event context we're running on */
1469 bsds
->event_ptr
= ev
;
1470 } else if (!bsds
->writeable_handler
) {
1471 uint16_t flags
= tevent_fd_get_flags(bsds
->fde
);
1472 flags
|= TEVENT_FD_READ
| TEVENT_FD_WRITE
;
1473 tevent_fd_set_flags(bsds
->fde
, flags
);
1476 bsds
->writeable_handler
= handler
;
1477 bsds
->writeable_private
= private_data
;
1482 static ssize_t
tstream_bsd_pending_bytes(struct tstream_context
*stream
)
1484 struct tstream_bsd
*bsds
= tstream_context_data(stream
,
1485 struct tstream_bsd
);
1488 if (bsds
->fd
== -1) {
1493 ret
= tsocket_bsd_pending(bsds
->fd
);
1498 struct tstream_bsd_readv_state
{
1499 struct tstream_context
*stream
;
1501 struct iovec
*vector
;
1507 static int tstream_bsd_readv_destructor(struct tstream_bsd_readv_state
*state
)
1509 struct tstream_bsd
*bsds
= tstream_context_data(state
->stream
,
1510 struct tstream_bsd
);
1512 tstream_bsd_set_readable_handler(bsds
, NULL
, NULL
, NULL
);
1517 static void tstream_bsd_readv_handler(void *private_data
);
1519 static struct tevent_req
*tstream_bsd_readv_send(TALLOC_CTX
*mem_ctx
,
1520 struct tevent_context
*ev
,
1521 struct tstream_context
*stream
,
1522 struct iovec
*vector
,
1525 struct tevent_req
*req
;
1526 struct tstream_bsd_readv_state
*state
;
1527 struct tstream_bsd
*bsds
= tstream_context_data(stream
, struct tstream_bsd
);
1530 req
= tevent_req_create(mem_ctx
, &state
,
1531 struct tstream_bsd_readv_state
);
1536 state
->stream
= stream
;
1537 /* we make a copy of the vector so that we can modify it */
1538 state
->vector
= talloc_array(state
, struct iovec
, count
);
1539 if (tevent_req_nomem(state
->vector
, req
)) {
1542 memcpy(state
->vector
, vector
, sizeof(struct iovec
)*count
);
1543 state
->count
= count
;
1546 talloc_set_destructor(state
, tstream_bsd_readv_destructor
);
1548 if (bsds
->fd
== -1) {
1549 tevent_req_error(req
, ENOTCONN
);
1554 * this is a fast path, not waiting for the
1555 * socket to become explicit readable gains
1556 * about 10%-20% performance in benchmark tests.
1558 tstream_bsd_readv_handler(req
);
1559 if (!tevent_req_is_in_progress(req
)) {
1563 ret
= tstream_bsd_set_readable_handler(bsds
, ev
,
1564 tstream_bsd_readv_handler
,
1567 tevent_req_error(req
, errno
);
1574 tevent_req_post(req
, ev
);
1578 static void tstream_bsd_readv_handler(void *private_data
)
1580 struct tevent_req
*req
= talloc_get_type_abort(private_data
,
1582 struct tstream_bsd_readv_state
*state
= tevent_req_data(req
,
1583 struct tstream_bsd_readv_state
);
1584 struct tstream_context
*stream
= state
->stream
;
1585 struct tstream_bsd
*bsds
= tstream_context_data(stream
, struct tstream_bsd
);
1590 ret
= readv(bsds
->fd
, state
->vector
, state
->count
);
1592 /* propagate end of file */
1593 tevent_req_error(req
, EPIPE
);
1596 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
1601 if (tevent_req_error(req
, err
)) {
1608 if (ret
< state
->vector
[0].iov_len
) {
1610 base
= (uint8_t *)state
->vector
[0].iov_base
;
1612 state
->vector
[0].iov_base
= base
;
1613 state
->vector
[0].iov_len
-= ret
;
1616 ret
-= state
->vector
[0].iov_len
;
1622 * there're maybe some empty vectors at the end
1623 * which we need to skip, otherwise we would get
1624 * ret == 0 from the readv() call and return EPIPE
1626 while (state
->count
> 0) {
1627 if (state
->vector
[0].iov_len
> 0) {
1634 if (state
->count
> 0) {
1635 /* we have more to read */
1639 tevent_req_done(req
);
1642 static int tstream_bsd_readv_recv(struct tevent_req
*req
,
1645 struct tstream_bsd_readv_state
*state
= tevent_req_data(req
,
1646 struct tstream_bsd_readv_state
);
1649 ret
= tsocket_simple_int_recv(req
, perrno
);
1654 tevent_req_received(req
);
1658 struct tstream_bsd_writev_state
{
1659 struct tstream_context
*stream
;
1661 struct iovec
*vector
;
1667 static int tstream_bsd_writev_destructor(struct tstream_bsd_writev_state
*state
)
1669 struct tstream_bsd
*bsds
= tstream_context_data(state
->stream
,
1670 struct tstream_bsd
);
1672 tstream_bsd_set_writeable_handler(bsds
, NULL
, NULL
, NULL
);
1677 static void tstream_bsd_writev_handler(void *private_data
);
1679 static struct tevent_req
*tstream_bsd_writev_send(TALLOC_CTX
*mem_ctx
,
1680 struct tevent_context
*ev
,
1681 struct tstream_context
*stream
,
1682 const struct iovec
*vector
,
1685 struct tevent_req
*req
;
1686 struct tstream_bsd_writev_state
*state
;
1687 struct tstream_bsd
*bsds
= tstream_context_data(stream
, struct tstream_bsd
);
1690 req
= tevent_req_create(mem_ctx
, &state
,
1691 struct tstream_bsd_writev_state
);
1696 state
->stream
= stream
;
1697 /* we make a copy of the vector so that we can modify it */
1698 state
->vector
= talloc_array(state
, struct iovec
, count
);
1699 if (tevent_req_nomem(state
->vector
, req
)) {
1702 memcpy(state
->vector
, vector
, sizeof(struct iovec
)*count
);
1703 state
->count
= count
;
1706 talloc_set_destructor(state
, tstream_bsd_writev_destructor
);
1708 if (bsds
->fd
== -1) {
1709 tevent_req_error(req
, ENOTCONN
);
1714 * this is a fast path, not waiting for the
1715 * socket to become explicit writeable gains
1716 * about 10%-20% performance in benchmark tests.
1718 tstream_bsd_writev_handler(req
);
1719 if (!tevent_req_is_in_progress(req
)) {
1723 ret
= tstream_bsd_set_writeable_handler(bsds
, ev
,
1724 tstream_bsd_writev_handler
,
1727 tevent_req_error(req
, errno
);
1734 tevent_req_post(req
, ev
);
1738 static void tstream_bsd_writev_handler(void *private_data
)
1740 struct tevent_req
*req
= talloc_get_type_abort(private_data
,
1742 struct tstream_bsd_writev_state
*state
= tevent_req_data(req
,
1743 struct tstream_bsd_writev_state
);
1744 struct tstream_context
*stream
= state
->stream
;
1745 struct tstream_bsd
*bsds
= tstream_context_data(stream
, struct tstream_bsd
);
1750 ret
= writev(bsds
->fd
, state
->vector
, state
->count
);
1752 /* propagate end of file */
1753 tevent_req_error(req
, EPIPE
);
1756 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
1761 if (tevent_req_error(req
, err
)) {
1768 if (ret
< state
->vector
[0].iov_len
) {
1770 base
= (uint8_t *)state
->vector
[0].iov_base
;
1772 state
->vector
[0].iov_base
= base
;
1773 state
->vector
[0].iov_len
-= ret
;
1776 ret
-= state
->vector
[0].iov_len
;
1782 * there're maybe some empty vectors at the end
1783 * which we need to skip, otherwise we would get
1784 * ret == 0 from the writev() call and return EPIPE
1786 while (state
->count
> 0) {
1787 if (state
->vector
[0].iov_len
> 0) {
1794 if (state
->count
> 0) {
1795 /* we have more to read */
1799 tevent_req_done(req
);
1802 static int tstream_bsd_writev_recv(struct tevent_req
*req
, int *perrno
)
1804 struct tstream_bsd_writev_state
*state
= tevent_req_data(req
,
1805 struct tstream_bsd_writev_state
);
1808 ret
= tsocket_simple_int_recv(req
, perrno
);
1813 tevent_req_received(req
);
1817 struct tstream_bsd_disconnect_state
{
1821 static struct tevent_req
*tstream_bsd_disconnect_send(TALLOC_CTX
*mem_ctx
,
1822 struct tevent_context
*ev
,
1823 struct tstream_context
*stream
)
1825 struct tstream_bsd
*bsds
= tstream_context_data(stream
, struct tstream_bsd
);
1826 struct tevent_req
*req
;
1827 struct tstream_bsd_disconnect_state
*state
;
1832 req
= tevent_req_create(mem_ctx
, &state
,
1833 struct tstream_bsd_disconnect_state
);
1838 if (bsds
->fd
== -1) {
1839 tevent_req_error(req
, ENOTCONN
);
1843 ret
= close(bsds
->fd
);
1845 err
= tsocket_bsd_error_from_errno(ret
, errno
, &dummy
);
1846 if (tevent_req_error(req
, err
)) {
1850 tevent_req_done(req
);
1852 tevent_req_post(req
, ev
);
1856 static int tstream_bsd_disconnect_recv(struct tevent_req
*req
,
1861 ret
= tsocket_simple_int_recv(req
, perrno
);
1863 tevent_req_received(req
);
1867 static const struct tstream_context_ops tstream_bsd_ops
= {
1870 .pending_bytes
= tstream_bsd_pending_bytes
,
1872 .readv_send
= tstream_bsd_readv_send
,
1873 .readv_recv
= tstream_bsd_readv_recv
,
1875 .writev_send
= tstream_bsd_writev_send
,
1876 .writev_recv
= tstream_bsd_writev_recv
,
1878 .disconnect_send
= tstream_bsd_disconnect_send
,
1879 .disconnect_recv
= tstream_bsd_disconnect_recv
,
1882 static int tstream_bsd_destructor(struct tstream_bsd
*bsds
)
1884 TALLOC_FREE(bsds
->fde
);
1885 if (bsds
->fd
!= -1) {
1892 int _tstream_bsd_existing_socket(TALLOC_CTX
*mem_ctx
,
1894 struct tstream_context
**_stream
,
1895 const char *location
)
1897 struct tstream_context
*stream
;
1898 struct tstream_bsd
*bsds
;
1900 stream
= tstream_context_create(mem_ctx
,
1910 talloc_set_destructor(bsds
, tstream_bsd_destructor
);
1916 struct tstream_bsd_connect_state
{
1918 struct tevent_fd
*fde
;
1919 struct tstream_conext
*stream
;
1922 static int tstream_bsd_connect_destructor(struct tstream_bsd_connect_state
*state
)
1924 TALLOC_FREE(state
->fde
);
1925 if (state
->fd
!= -1) {
1933 static void tstream_bsd_connect_fde_handler(struct tevent_context
*ev
,
1934 struct tevent_fd
*fde
,
1936 void *private_data
);
1938 static struct tevent_req
* tstream_bsd_connect_send(TALLOC_CTX
*mem_ctx
,
1939 struct tevent_context
*ev
,
1941 const struct tsocket_address
*local
,
1942 const struct tsocket_address
*remote
)
1944 struct tevent_req
*req
;
1945 struct tstream_bsd_connect_state
*state
;
1946 struct tsocket_address_bsd
*lbsda
=
1947 talloc_get_type_abort(local
->private_data
,
1948 struct tsocket_address_bsd
);
1949 struct tsocket_address_bsd
*rbsda
=
1950 talloc_get_type_abort(remote
->private_data
,
1951 struct tsocket_address_bsd
);
1955 bool do_bind
= false;
1956 bool do_reuseaddr
= false;
1957 bool do_ipv6only
= false;
1958 bool is_inet
= false;
1959 int sa_fam
= lbsda
->u
.sa
.sa_family
;
1961 req
= tevent_req_create(mem_ctx
, &state
,
1962 struct tstream_bsd_connect_state
);
1969 talloc_set_destructor(state
, tstream_bsd_connect_destructor
);
1971 /* give the wrappers a chance to report an error */
1972 if (sys_errno
!= 0) {
1973 tevent_req_error(req
, sys_errno
);
1977 switch (lbsda
->u
.sa
.sa_family
) {
1979 if (lbsda
->u
.un
.sun_path
[0] != 0) {
1980 do_reuseaddr
= true;
1985 if (lbsda
->u
.in
.sin_port
!= 0) {
1986 do_reuseaddr
= true;
1989 if (lbsda
->u
.in
.sin_addr
.s_addr
!= INADDR_ANY
) {
1996 if (lbsda
->u
.in6
.sin6_port
!= 0) {
1997 do_reuseaddr
= true;
2000 if (memcmp(&in6addr_any
,
2001 &lbsda
->u
.in6
.sin6_addr
,
2002 sizeof(in6addr_any
)) != 0) {
2010 tevent_req_error(req
, EINVAL
);
2014 if (!do_bind
&& is_inet
) {
2015 sa_fam
= rbsda
->u
.sa
.sa_family
;
2018 do_ipv6only
= false;
2028 state
->fd
= socket(sa_fam
, SOCK_STREAM
, 0);
2029 if (state
->fd
== -1) {
2030 tevent_req_error(req
, errno
);
2034 state
->fd
= tsocket_bsd_common_prepare_fd(state
->fd
, true);
2035 if (state
->fd
== -1) {
2036 tevent_req_error(req
, errno
);
2044 ret
= setsockopt(state
->fd
, IPPROTO_IPV6
, IPV6_V6ONLY
,
2045 (const void *)&val
, sizeof(val
));
2047 tevent_req_error(req
, errno
);
2056 ret
= setsockopt(state
->fd
, SOL_SOCKET
, SO_REUSEADDR
,
2057 (const void *)&val
, sizeof(val
));
2059 tevent_req_error(req
, errno
);
2065 ret
= bind(state
->fd
, &lbsda
->u
.sa
, lbsda
->sa_socklen
);
2067 tevent_req_error(req
, errno
);
2072 if (rbsda
->u
.sa
.sa_family
!= sa_fam
) {
2073 tevent_req_error(req
, EINVAL
);
2077 ret
= connect(state
->fd
, &rbsda
->u
.sa
, rbsda
->sa_socklen
);
2078 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
2083 if (tevent_req_error(req
, err
)) {
2087 tevent_req_done(req
);
2091 state
->fde
= tevent_add_fd(ev
, state
,
2093 TEVENT_FD_READ
| TEVENT_FD_WRITE
,
2094 tstream_bsd_connect_fde_handler
,
2096 if (tevent_req_nomem(state
->fde
, req
)) {
2103 tevent_req_post(req
, ev
);
2107 static void tstream_bsd_connect_fde_handler(struct tevent_context
*ev
,
2108 struct tevent_fd
*fde
,
2112 struct tevent_req
*req
= talloc_get_type_abort(private_data
,
2114 struct tstream_bsd_connect_state
*state
= tevent_req_data(req
,
2115 struct tstream_bsd_connect_state
);
2118 socklen_t len
= sizeof(error
);
2122 ret
= getsockopt(state
->fd
, SOL_SOCKET
, SO_ERROR
, &error
, &len
);
2129 err
= tsocket_bsd_error_from_errno(ret
, errno
, &retry
);
2134 if (tevent_req_error(req
, err
)) {
2138 tevent_req_done(req
);
2141 static int tstream_bsd_connect_recv(struct tevent_req
*req
,
2143 TALLOC_CTX
*mem_ctx
,
2144 struct tstream_context
**stream
,
2145 const char *location
)
2147 struct tstream_bsd_connect_state
*state
= tevent_req_data(req
,
2148 struct tstream_bsd_connect_state
);
2151 ret
= tsocket_simple_int_recv(req
, perrno
);
2153 ret
= _tstream_bsd_existing_socket(mem_ctx
,
2161 TALLOC_FREE(state
->fde
);
2166 tevent_req_received(req
);
2170 struct tevent_req
* tstream_inet_tcp_connect_send(TALLOC_CTX
*mem_ctx
,
2171 struct tevent_context
*ev
,
2172 const struct tsocket_address
*local
,
2173 const struct tsocket_address
*remote
)
2175 struct tsocket_address_bsd
*lbsda
=
2176 talloc_get_type_abort(local
->private_data
,
2177 struct tsocket_address_bsd
);
2178 struct tevent_req
*req
;
2181 switch (lbsda
->u
.sa
.sa_family
) {
2193 req
= tstream_bsd_connect_send(mem_ctx
, ev
, sys_errno
, local
, remote
);
2198 int _tstream_inet_tcp_connect_recv(struct tevent_req
*req
,
2200 TALLOC_CTX
*mem_ctx
,
2201 struct tstream_context
**stream
,
2202 const char *location
)
2204 return tstream_bsd_connect_recv(req
, perrno
, mem_ctx
, stream
, location
);
2207 struct tevent_req
* tstream_unix_connect_send(TALLOC_CTX
*mem_ctx
,
2208 struct tevent_context
*ev
,
2209 const struct tsocket_address
*local
,
2210 const struct tsocket_address
*remote
)
2212 struct tsocket_address_bsd
*lbsda
=
2213 talloc_get_type_abort(local
->private_data
,
2214 struct tsocket_address_bsd
);
2215 struct tevent_req
*req
;
2218 switch (lbsda
->u
.sa
.sa_family
) {
2226 req
= tstream_bsd_connect_send(mem_ctx
, ev
, sys_errno
, local
, remote
);
2231 int _tstream_unix_connect_recv(struct tevent_req
*req
,
2233 TALLOC_CTX
*mem_ctx
,
2234 struct tstream_context
**stream
,
2235 const char *location
)
2237 return tstream_bsd_connect_recv(req
, perrno
, mem_ctx
, stream
, location
);
2240 int _tstream_unix_socketpair(TALLOC_CTX
*mem_ctx1
,
2241 struct tstream_context
**_stream1
,
2242 TALLOC_CTX
*mem_ctx2
,
2243 struct tstream_context
**_stream2
,
2244 const char *location
)
2250 struct tstream_context
*stream1
= NULL
;
2251 struct tstream_context
*stream2
= NULL
;
2253 ret
= socketpair(AF_UNIX
, SOCK_STREAM
, 0, fds
);
2260 fd1
= tsocket_bsd_common_prepare_fd(fd1
, true);
2262 int sys_errno
= errno
;
2268 fd2
= tsocket_bsd_common_prepare_fd(fd2
, true);
2270 int sys_errno
= errno
;
2276 ret
= _tstream_bsd_existing_socket(mem_ctx1
,
2281 int sys_errno
= errno
;
2288 ret
= _tstream_bsd_existing_socket(mem_ctx2
,
2293 int sys_errno
= errno
;
2294 talloc_free(stream1
);
2300 *_stream1
= stream1
;
2301 *_stream2
= stream2
;