lib/tsocket/tsocket_bsd.c

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