unix/uxnet.c

   1 /*
   2  * Unix networking abstraction.
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <assert.h>
   8 #include <errno.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <sys/types.h>
  12 #include <sys/socket.h>
  13 #include <sys/ioctl.h>
  14 #include <arpa/inet.h>
  15 #include <netinet/in.h>
  16 #include <netinet/tcp.h>
  17 #include <netdb.h>
  18 #include <sys/un.h>
  19
  20 #define DEFINE_PLUG_METHOD_MACROS
  21 #include "putty.h"
  22 #include "network.h"
  23 #include "tree234.h"
  24
  25 /* Solaris needs <sys/sockio.h> for SIOCATMARK. */
  26 #ifndef SIOCATMARK
  27 #include <sys/sockio.h>
  28 #endif
  29
  30 #ifndef X11_UNIX_PATH
  31 # define X11_UNIX_PATH "/tmp/.X11-unix/X"
  32 #endif
  33
  34 /*
  35  * Access to sockaddr types without breaking C strict aliasing rules.
  36  */
  37 union sockaddr_union {
  38 #ifdef NO_IPV6
  39     struct sockaddr_in storage;
  40 #else
  41     struct sockaddr_storage storage;
  42     struct sockaddr_in6 sin6;
  43 #endif
  44     struct sockaddr sa;
  45     struct sockaddr_in sin;
  46     struct sockaddr_un su;
  47 };
  48
  49 /*
  50  * We used to typedef struct Socket_tag *Socket.
  51  *
  52  * Since we have made the networking abstraction slightly more
  53  * abstract, Socket no longer means a tcp socket (it could mean
  54  * an ssl socket).  So now we must use Actual_Socket when we know
  55  * we are talking about a tcp socket.
  56  */
  57 typedef struct Socket_tag *Actual_Socket;
  58
  59 /*
  60  * Mutable state that goes with a SockAddr: stores information
  61  * about where in the list of candidate IP(v*) addresses we've
  62  * currently got to.
  63  */
  64 typedef struct SockAddrStep_tag SockAddrStep;
  65 struct SockAddrStep_tag {
  66 #ifndef NO_IPV6
  67     struct addrinfo *ai;               /* steps along addr->ais */
  68 #endif
  69     int curraddr;
  70 };
  71
  72 struct Socket_tag {
  73     struct socket_function_table *fn;
  74     /* the above variable absolutely *must* be the first in this structure */
  75     const char *error;
  76     int s;
  77     Plug plug;
  78     bufchain output_data;
  79     int connected;                     /* irrelevant for listening sockets */
  80     int writable;
  81     int frozen; /* this causes readability notifications to be ignored */
  82     int localhost_only;                /* for listening sockets */
  83     char oobdata[1];
  84     int sending_oob;
  85     int oobpending;                    /* is there OOB data available to read? */
  86     int oobinline;
  87     enum { EOF_NO, EOF_PENDING, EOF_SENT } outgoingeof;
  88     int incomingeof;
  89     int pending_error;                 /* in case send() returns error */
  90     int listener;
  91     int nodelay, keepalive;            /* for connect()-type sockets */
  92     int privport, port;                /* and again */
  93     SockAddr addr;
  94     SockAddrStep step;
  95     /*
  96      * We sometimes need pairs of Socket structures to be linked:
  97      * if we are listening on the same IPv6 and v4 port, for
  98      * example. So here we define `parent' and `child' pointers to
  99      * track this link.
 100      */
 101     Actual_Socket parent, child;
 102 };
 103
 104 struct SockAddr_tag {
 105     int refcount;
 106     const char *error;
 107     enum { UNRESOLVED, UNIX, IP } superfamily;
 108 #ifndef NO_IPV6
 109     struct addrinfo *ais;              /* Addresses IPv6 style. */
 110 #else
 111     unsigned long *addresses;          /* Addresses IPv4 style. */
 112     int naddresses;
 113 #endif
 114     char hostname[512];                /* Store an unresolved host name. */
 115 };
 116
 117 /*
 118  * Which address family this address belongs to. AF_INET for IPv4;
 119  * AF_INET6 for IPv6; AF_UNSPEC indicates that name resolution has
 120  * not been done and a simple host name is held in this SockAddr
 121  * structure.
 122  */
 123 #ifndef NO_IPV6
 124 #define SOCKADDR_FAMILY(addr, step) \
 125     ((addr)->superfamily == UNRESOLVED ? AF_UNSPEC : \
 126      (addr)->superfamily == UNIX ? AF_UNIX : \
 127      (step).ai ? (step).ai->ai_family : AF_INET)
 128 #else
 129 /* Here we gratuitously reference 'step' to avoid gcc warnings about
 130  * 'set but not used' when compiling -DNO_IPV6 */
 131 #define SOCKADDR_FAMILY(addr, step) \
 132     ((addr)->superfamily == UNRESOLVED ? AF_UNSPEC : \
 133      (addr)->superfamily == UNIX ? AF_UNIX : \
 134      (step).curraddr ? AF_INET : AF_INET)
 135 #endif
 136
 137 /*
 138  * Start a SockAddrStep structure to step through multiple
 139  * addresses.
 140  */
 141 #ifndef NO_IPV6
 142 #define START_STEP(addr, step) \
 143     ((step).ai = (addr)->ais, (step).curraddr = 0)
 144 #else
 145 #define START_STEP(addr, step) \
 146     ((step).curraddr = 0)
 147 #endif
 148
 149 static tree234 *sktree;
 150
 151 static void uxsel_tell(Actual_Socket s);
 152
 153 static int cmpfortree(void *av, void *bv)
 154 {
 155     Actual_Socket a = (Actual_Socket) av, b = (Actual_Socket) bv;
 156     int as = a->s, bs = b->s;
 157     if (as < bs)
 158         return -1;
 159     if (as > bs)
 160         return +1;
 161     if (a < b)
 162        return -1;
 163     if (a > b)
 164        return +1;
 165     return 0;
 166 }
 167
 168 static int cmpforsearch(void *av, void *bv)
 169 {
 170     Actual_Socket b = (Actual_Socket) bv;
 171     int as = *(int *)av, bs = b->s;
 172     if (as < bs)
 173         return -1;
 174     if (as > bs)
 175         return +1;
 176     return 0;
 177 }
 178
 179 void sk_init(void)
 180 {
 181     sktree = newtree234(cmpfortree);
 182 }
 183
 184 void sk_cleanup(void)
 185 {
 186     Actual_Socket s;
 187     int i;
 188
 189     if (sktree) {
 190         for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
 191             close(s->s);
 192         }
 193     }
 194 }
 195
 196 SockAddr sk_namelookup(const char *host, char **canonicalname, int address_family)
 197 {
 198     SockAddr ret = snew(struct SockAddr_tag);
 199 #ifndef NO_IPV6
 200     struct addrinfo hints;
 201     int err;
 202 #else
 203     unsigned long a;
 204     struct hostent *h = NULL;
 205     int n;
 206 #endif
 207     char realhost[8192];
 208
 209     /* Clear the structure and default to IPv4. */
 210     memset(ret, 0, sizeof(struct SockAddr_tag));
 211     ret->superfamily = UNRESOLVED;
 212     *realhost = '\0';
 213     ret->error = NULL;
 214     ret->refcount = 1;
 215
 216 #ifndef NO_IPV6
 217     hints.ai_flags = AI_CANONNAME;
 218     hints.ai_family = (address_family == ADDRTYPE_IPV4 ? AF_INET :
 219                        address_family == ADDRTYPE_IPV6 ? AF_INET6 :
 220                        AF_UNSPEC);
 221     hints.ai_socktype = SOCK_STREAM;
 222     hints.ai_protocol = 0;
 223     hints.ai_addrlen = 0;
 224     hints.ai_addr = NULL;
 225     hints.ai_canonname = NULL;
 226     hints.ai_next = NULL;
 227     {
 228         char *trimmed_host = host_strduptrim(host); /* strip [] on literals */
 229         err = getaddrinfo(trimmed_host, NULL, &hints, &ret->ais);
 230         sfree(trimmed_host);
 231     }
 232     if (err != 0) {
 233         ret->error = gai_strerror(err);
 234         return ret;
 235     }
 236     ret->superfamily = IP;
 237     *realhost = '\0';
 238     if (ret->ais->ai_canonname != NULL)
 239         strncat(realhost, ret->ais->ai_canonname, sizeof(realhost) - 1);
 240     else
 241         strncat(realhost, host, sizeof(realhost) - 1);
 242 #else
 243     if ((a = inet_addr(host)) == (unsigned long)(in_addr_t)(-1)) {
 244         /*
 245          * Otherwise use the IPv4-only gethostbyname... (NOTE:
 246          * we don't use gethostbyname as a fallback!)
 247          */
 248         if (ret->superfamily == UNRESOLVED) {
 249             /*debug(("Resolving \"%s\" with gethostbyname() (IPv4 only)...\n", host)); */
 250             if ( (h = gethostbyname(host)) )
 251                 ret->superfamily = IP;
 252         }
 253         if (ret->superfamily == UNRESOLVED) {
 254             ret->error = (h_errno == HOST_NOT_FOUND ||
 255                           h_errno == NO_DATA ||
 256                           h_errno == NO_ADDRESS ? "Host does not exist" :
 257                           h_errno == TRY_AGAIN ?
 258                           "Temporary name service failure" :
 259                           "gethostbyname: unknown error");
 260             return ret;
 261         }
 262         /* This way we are always sure the h->h_name is valid :) */
 263         strncpy(realhost, h->h_name, sizeof(realhost));
 264         for (n = 0; h->h_addr_list[n]; n++);
 265         ret->addresses = snewn(n, unsigned long);
 266         ret->naddresses = n;
 267         for (n = 0; n < ret->naddresses; n++) {
 268             memcpy(&a, h->h_addr_list[n], sizeof(a));
 269             ret->addresses[n] = ntohl(a);
 270         }
 271     } else {
 272         /*
 273          * This must be a numeric IPv4 address because it caused a
 274          * success return from inet_addr.
 275          */
 276         ret->superfamily = IP;
 277         strncpy(realhost, host, sizeof(realhost));
 278         ret->addresses = snew(unsigned long);
 279         ret->naddresses = 1;
 280         ret->addresses[0] = ntohl(a);
 281     }
 282 #endif
 283     realhost[lenof(realhost)-1] = '\0';
 284     *canonicalname = snewn(1+strlen(realhost), char);
 285     strcpy(*canonicalname, realhost);
 286     return ret;
 287 }
 288
 289 SockAddr sk_nonamelookup(const char *host)
 290 {
 291     SockAddr ret = snew(struct SockAddr_tag);
 292     ret->error = NULL;
 293     ret->superfamily = UNRESOLVED;
 294     strncpy(ret->hostname, host, lenof(ret->hostname));
 295     ret->hostname[lenof(ret->hostname)-1] = '\0';
 296 #ifndef NO_IPV6
 297     ret->ais = NULL;
 298 #else
 299     ret->addresses = NULL;
 300 #endif
 301     ret->refcount = 1;
 302     return ret;
 303 }
 304
 305 static int sk_nextaddr(SockAddr addr, SockAddrStep *step)
 306 {
 307 #ifndef NO_IPV6
 308     if (step->ai && step->ai->ai_next) {
 309         step->ai = step->ai->ai_next;
 310         return TRUE;
 311     } else
 312         return FALSE;
 313 #else
 314     if (step->curraddr+1 < addr->naddresses) {
 315         step->curraddr++;
 316         return TRUE;
 317     } else {
 318         return FALSE;
 319     }
 320 #endif
 321 }
 322
 323 void sk_getaddr(SockAddr addr, char *buf, int buflen)
 324 {
 325     if (addr->superfamily == UNRESOLVED || addr->superfamily == UNIX) {
 326         strncpy(buf, addr->hostname, buflen);
 327         buf[buflen-1] = '\0';
 328     } else {
 329 #ifndef NO_IPV6
 330         if (getnameinfo(addr->ais->ai_addr, addr->ais->ai_addrlen, buf, buflen,
 331                         NULL, 0, NI_NUMERICHOST) != 0) {
 332             buf[0] = '\0';
 333             strncat(buf, "<unknown>", buflen - 1);
 334         }
 335 #else
 336         struct in_addr a;
 337         SockAddrStep step;
 338         START_STEP(addr, step);
 339         assert(SOCKADDR_FAMILY(addr, step) == AF_INET);
 340         a.s_addr = htonl(addr->addresses[0]);
 341         strncpy(buf, inet_ntoa(a), buflen);
 342         buf[buflen-1] = '\0';
 343 #endif
 344     }
 345 }
 346
 347 int sk_addr_needs_port(SockAddr addr)
 348 {
 349     if (addr->superfamily == UNRESOLVED || addr->superfamily == UNIX) {
 350         return FALSE;
 351     } else {
 352         return TRUE;
 353     }
 354 }
 355
 356 int sk_hostname_is_local(const char *name)
 357 {
 358     return !strcmp(name, "localhost") ||
 359            !strcmp(name, "::1") ||
 360            !strncmp(name, "127.", 4);
 361 }
 362
 363 #define ipv4_is_loopback(addr) \
 364     (((addr).s_addr & htonl(0xff000000)) == htonl(0x7f000000))
 365
 366 static int sockaddr_is_loopback(struct sockaddr *sa)
 367 {
 368     union sockaddr_union *u = (union sockaddr_union *)sa;
 369     switch (u->sa.sa_family) {
 370       case AF_INET:
 371         return ipv4_is_loopback(u->sin.sin_addr);
 372 #ifndef NO_IPV6
 373       case AF_INET6:
 374         return IN6_IS_ADDR_LOOPBACK(&u->sin6.sin6_addr);
 375 #endif
 376       case AF_UNIX:
 377         return TRUE;
 378       default:
 379         return FALSE;
 380     }
 381 }
 382
 383 int sk_address_is_local(SockAddr addr)
 384 {
 385     if (addr->superfamily == UNRESOLVED)
 386         return 0;                      /* we don't know; assume not */
 387     else if (addr->superfamily == UNIX)
 388         return 1;
 389     else {
 390 #ifndef NO_IPV6
 391         return sockaddr_is_loopback(addr->ais->ai_addr);
 392 #else
 393         struct in_addr a;
 394         SockAddrStep step;
 395         START_STEP(addr, step);
 396         assert(SOCKADDR_FAMILY(addr, step) == AF_INET);
 397         a.s_addr = htonl(addr->addresses[0]);
 398         return ipv4_is_loopback(a);
 399 #endif
 400     }
 401 }
 402
 403 int sk_address_is_special_local(SockAddr addr)
 404 {
 405     return addr->superfamily == UNIX;
 406 }
 407
 408 int sk_addrtype(SockAddr addr)
 409 {
 410     SockAddrStep step;
 411     int family;
 412     START_STEP(addr, step);
 413     family = SOCKADDR_FAMILY(addr, step);
 414
 415     return (family == AF_INET ? ADDRTYPE_IPV4 :
 416 #ifndef NO_IPV6
 417             family == AF_INET6 ? ADDRTYPE_IPV6 :
 418 #endif
 419             ADDRTYPE_NAME);
 420 }
 421
 422 void sk_addrcopy(SockAddr addr, char *buf)
 423 {
 424     SockAddrStep step;
 425     int family;
 426     START_STEP(addr, step);
 427     family = SOCKADDR_FAMILY(addr, step);
 428
 429 #ifndef NO_IPV6
 430     if (family == AF_INET)
 431         memcpy(buf, &((struct sockaddr_in *)step.ai->ai_addr)->sin_addr,
 432                sizeof(struct in_addr));
 433     else if (family == AF_INET6)
 434         memcpy(buf, &((struct sockaddr_in6 *)step.ai->ai_addr)->sin6_addr,
 435                sizeof(struct in6_addr));
 436     else
 437         assert(FALSE);
 438 #else
 439     struct in_addr a;
 440
 441     assert(family == AF_INET);
 442     a.s_addr = htonl(addr->addresses[step.curraddr]);
 443     memcpy(buf, (char*) &a.s_addr, 4);
 444 #endif
 445 }
 446
 447 void sk_addr_free(SockAddr addr)
 448 {
 449     if (--addr->refcount > 0)
 450         return;
 451 #ifndef NO_IPV6
 452     if (addr->ais != NULL)
 453         freeaddrinfo(addr->ais);
 454 #else
 455     sfree(addr->addresses);
 456 #endif
 457     sfree(addr);
 458 }
 459
 460 SockAddr sk_addr_dup(SockAddr addr)
 461 {
 462     addr->refcount++;
 463     return addr;
 464 }
 465
 466 static Plug sk_tcp_plug(Socket sock, Plug p)
 467 {
 468     Actual_Socket s = (Actual_Socket) sock;
 469     Plug ret = s->plug;
 470     if (p)
 471         s->plug = p;
 472     return ret;
 473 }
 474
 475 static void sk_tcp_flush(Socket s)
 476 {
 477     /*
 478      * We send data to the socket as soon as we can anyway,
 479      * so we don't need to do anything here.  :-)
 480      */
 481 }
 482
 483 static void sk_tcp_close(Socket s);
 484 static int sk_tcp_write(Socket s, const char *data, int len);
 485 static int sk_tcp_write_oob(Socket s, const char *data, int len);
 486 static void sk_tcp_write_eof(Socket s);
 487 static void sk_tcp_set_frozen(Socket s, int is_frozen);
 488 static const char *sk_tcp_socket_error(Socket s);
 489
 490 static struct socket_function_table tcp_fn_table = {
 491     sk_tcp_plug,
 492     sk_tcp_close,
 493     sk_tcp_write,
 494     sk_tcp_write_oob,
 495     sk_tcp_write_eof,
 496     sk_tcp_flush,
 497     sk_tcp_set_frozen,
 498     sk_tcp_socket_error
 499 };
 500
 501 static Socket sk_tcp_accept(accept_ctx_t ctx, Plug plug)
 502 {
 503     int sockfd = ctx.i;
 504     Actual_Socket ret;
 505
 506     /*
 507      * Create Socket structure.
 508      */
 509     ret = snew(struct Socket_tag);
 510     ret->fn = &tcp_fn_table;
 511     ret->error = NULL;
 512     ret->plug = plug;
 513     bufchain_init(&ret->output_data);
 514     ret->writable = 1;                 /* to start with */
 515     ret->sending_oob = 0;
 516     ret->frozen = 1;
 517     ret->localhost_only = 0;           /* unused, but best init anyway */
 518     ret->pending_error = 0;
 519     ret->oobpending = FALSE;
 520     ret->outgoingeof = EOF_NO;
 521     ret->incomingeof = FALSE;
 522     ret->listener = 0;
 523     ret->parent = ret->child = NULL;
 524     ret->addr = NULL;
 525     ret->connected = 1;
 526
 527     ret->s = sockfd;
 528
 529     if (ret->s < 0) {
 530         ret->error = strerror(errno);
 531         return (Socket) ret;
 532     }
 533
 534     ret->oobinline = 0;
 535
 536     uxsel_tell(ret);
 537     add234(sktree, ret);
 538
 539     return (Socket) ret;
 540 }
 541
 542 static int try_connect(Actual_Socket sock)
 543 {
 544     int s;
 545     union sockaddr_union u;
 546     const union sockaddr_union *sa;
 547     int err = 0;
 548     short localport;
 549     int salen, family;
 550
 551     /*
 552      * Remove the socket from the tree before we overwrite its
 553      * internal socket id, because that forms part of the tree's
 554      * sorting criterion. We'll add it back before exiting this
 555      * function, whether we changed anything or not.
 556      */
 557     del234(sktree, sock);
 558
 559     if (sock->s >= 0)
 560         close(sock->s);
 561
 562     plug_log(sock->plug, 0, sock->addr, sock->port, NULL, 0);
 563
 564     /*
 565      * Open socket.
 566      */
 567     family = SOCKADDR_FAMILY(sock->addr, sock->step);
 568     assert(family != AF_UNSPEC);
 569     s = socket(family, SOCK_STREAM, 0);
 570     sock->s = s;
 571
 572     if (s < 0) {
 573         err = errno;
 574         goto ret;
 575     }
 576
 577     cloexec(s);
 578
 579     if (sock->oobinline) {
 580         int b = TRUE;
 581         if (setsockopt(s, SOL_SOCKET, SO_OOBINLINE,
 582                        (void *) &b, sizeof(b)) < 0) {
 583             err = errno;
 584             close(s);
 585             goto ret;
 586         }
 587     }
 588
 589     if (sock->nodelay) {
 590         int b = TRUE;
 591         if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY,
 592                        (void *) &b, sizeof(b)) < 0) {
 593             err = errno;
 594             close(s);
 595             goto ret;
 596         }
 597     }
 598
 599     if (sock->keepalive) {
 600         int b = TRUE;
 601         if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
 602                        (void *) &b, sizeof(b)) < 0) {
 603             err = errno;
 604             close(s);
 605             goto ret;
 606         }
 607     }
 608
 609     /*
 610      * Bind to local address.
 611      */
 612     if (sock->privport)
 613         localport = 1023;              /* count from 1023 downwards */
 614     else
 615         localport = 0;                 /* just use port 0 (ie kernel picks) */
 616
 617     /* BSD IP stacks need sockaddr_in zeroed before filling in */
 618     memset(&u,'\0',sizeof(u));
 619
 620     /* We don't try to bind to a local address for UNIX domain sockets.  (Why
 621      * do we bother doing the bind when localport == 0 anyway?) */
 622     if (family != AF_UNIX) {
 623         /* Loop round trying to bind */
 624         while (1) {
 625             int retcode;
 626
 627 #ifndef NO_IPV6
 628             if (family == AF_INET6) {
 629                 /* XXX use getaddrinfo to get a local address? */
 630                 u.sin6.sin6_family = AF_INET6;
 631                 u.sin6.sin6_addr = in6addr_any;
 632                 u.sin6.sin6_port = htons(localport);
 633                 retcode = bind(s, &u.sa, sizeof(u.sin6));
 634             } else
 635 #endif
 636             {
 637                 assert(family == AF_INET);
 638                 u.sin.sin_family = AF_INET;
 639                 u.sin.sin_addr.s_addr = htonl(INADDR_ANY);
 640                 u.sin.sin_port = htons(localport);
 641                 retcode = bind(s, &u.sa, sizeof(u.sin));
 642             }
 643             if (retcode >= 0) {
 644                 err = 0;
 645                 break;                 /* done */
 646             } else {
 647                 err = errno;
 648                 if (err != EADDRINUSE) /* failed, for a bad reason */
 649                   break;
 650             }
 651
 652             if (localport == 0)
 653               break;                   /* we're only looping once */
 654             localport--;
 655             if (localport == 0)
 656               break;                   /* we might have got to the end */
 657         }
 658
 659         if (err)
 660             goto ret;
 661     }
 662
 663     /*
 664      * Connect to remote address.
 665      */
 666     switch(family) {
 667 #ifndef NO_IPV6
 668       case AF_INET:
 669         /* XXX would be better to have got getaddrinfo() to fill in the port. */
 670         ((struct sockaddr_in *)sock->step.ai->ai_addr)->sin_port =
 671             htons(sock->port);
 672         sa = (const union sockaddr_union *)sock->step.ai->ai_addr;
 673         salen = sock->step.ai->ai_addrlen;
 674         break;
 675       case AF_INET6:
 676         ((struct sockaddr_in *)sock->step.ai->ai_addr)->sin_port =
 677             htons(sock->port);
 678         sa = (const union sockaddr_union *)sock->step.ai->ai_addr;
 679         salen = sock->step.ai->ai_addrlen;
 680         break;
 681 #else
 682       case AF_INET:
 683         u.sin.sin_family = AF_INET;
 684         u.sin.sin_addr.s_addr = htonl(sock->addr->addresses[sock->step.curraddr]);
 685         u.sin.sin_port = htons((short) sock->port);
 686         sa = &u;
 687         salen = sizeof u.sin;
 688         break;
 689 #endif
 690       case AF_UNIX:
 691         assert(sock->port == 0);       /* to catch confused people */
 692         assert(strlen(sock->addr->hostname) < sizeof u.su.sun_path);
 693         u.su.sun_family = AF_UNIX;
 694         strcpy(u.su.sun_path, sock->addr->hostname);
 695         sa = &u;
 696         salen = sizeof u.su;
 697         break;
 698
 699       default:
 700         assert(0 && "unknown address family");
 701         exit(1); /* XXX: GCC doesn't understand assert() on some systems. */
 702     }
 703
 704     nonblock(s);
 705
 706     if ((connect(s, &(sa->sa), salen)) < 0) {
 707         if ( errno != EINPROGRESS ) {
 708             err = errno;
 709             goto ret;
 710         }
 711     } else {
 712         /*
 713          * If we _don't_ get EWOULDBLOCK, the connect has completed
 714          * and we should set the socket as connected and writable.
 715          */
 716         sock->connected = 1;
 717         sock->writable = 1;
 718     }
 719
 720     uxsel_tell(sock);
 721
 722     ret:
 723
 724     /*
 725      * No matter what happened, put the socket back in the tree.
 726      */
 727     add234(sktree, sock);
 728
 729     if (err)
 730         plug_log(sock->plug, 1, sock->addr, sock->port, strerror(err), err);
 731     return err;
 732 }
 733
 734 Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
 735               int nodelay, int keepalive, Plug plug)
 736 {
 737     Actual_Socket ret;
 738     int err;
 739
 740     /*
 741      * Create Socket structure.
 742      */
 743     ret = snew(struct Socket_tag);
 744     ret->fn = &tcp_fn_table;
 745     ret->error = NULL;
 746     ret->plug = plug;
 747     bufchain_init(&ret->output_data);
 748     ret->connected = 0;                /* to start with */
 749     ret->writable = 0;                 /* to start with */
 750     ret->sending_oob = 0;
 751     ret->frozen = 0;
 752     ret->localhost_only = 0;           /* unused, but best init anyway */
 753     ret->pending_error = 0;
 754     ret->parent = ret->child = NULL;
 755     ret->oobpending = FALSE;
 756     ret->outgoingeof = EOF_NO;
 757     ret->incomingeof = FALSE;
 758     ret->listener = 0;
 759     ret->addr = addr;
 760     START_STEP(ret->addr, ret->step);
 761     ret->s = -1;
 762     ret->oobinline = oobinline;
 763     ret->nodelay = nodelay;
 764     ret->keepalive = keepalive;
 765     ret->privport = privport;
 766     ret->port = port;
 767
 768     err = 0;
 769     do {
 770         err = try_connect(ret);
 771     } while (err && sk_nextaddr(ret->addr, &ret->step));
 772
 773     if (err)
 774         ret->error = strerror(err);
 775
 776     return (Socket) ret;
 777 }
 778
 779 Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, int orig_address_family)
 780 {
 781     int s;
 782 #ifndef NO_IPV6
 783     struct addrinfo hints, *ai = NULL;
 784     char portstr[6];
 785 #endif
 786     union sockaddr_union u;
 787     union sockaddr_union *addr;
 788     int addrlen;
 789     Actual_Socket ret;
 790     int retcode;
 791     int address_family;
 792     int on = 1;
 793
 794     /*
 795      * Create Socket structure.
 796      */
 797     ret = snew(struct Socket_tag);
 798     ret->fn = &tcp_fn_table;
 799     ret->error = NULL;
 800     ret->plug = plug;
 801     bufchain_init(&ret->output_data);
 802     ret->writable = 0;                 /* to start with */
 803     ret->sending_oob = 0;
 804     ret->frozen = 0;
 805     ret->localhost_only = local_host_only;
 806     ret->pending_error = 0;
 807     ret->parent = ret->child = NULL;
 808     ret->oobpending = FALSE;
 809     ret->outgoingeof = EOF_NO;
 810     ret->incomingeof = FALSE;
 811     ret->listener = 1;
 812     ret->addr = NULL;
 813     ret->s = -1;
 814
 815     /*
 816      * Translate address_family from platform-independent constants
 817      * into local reality.
 818      */
 819     address_family = (orig_address_family == ADDRTYPE_IPV4 ? AF_INET :
 820 #ifndef NO_IPV6
 821                       orig_address_family == ADDRTYPE_IPV6 ? AF_INET6 :
 822 #endif
 823                       AF_UNSPEC);
 824
 825 #ifndef NO_IPV6
 826     /* Let's default to IPv6.
 827      * If the stack doesn't support IPv6, we will fall back to IPv4. */
 828     if (address_family == AF_UNSPEC) address_family = AF_INET6;
 829 #else
 830     /* No other choice, default to IPv4 */
 831     if (address_family == AF_UNSPEC)  address_family = AF_INET;
 832 #endif
 833
 834     /*
 835      * Open socket.
 836      */
 837     s = socket(address_family, SOCK_STREAM, 0);
 838
 839 #ifndef NO_IPV6
 840     /* If the host doesn't support IPv6 try fallback to IPv4. */
 841     if (s < 0 && address_family == AF_INET6) {
 842         address_family = AF_INET;
 843         s = socket(address_family, SOCK_STREAM, 0);
 844     }
 845 #endif
 846
 847     if (s < 0) {
 848         ret->error = strerror(errno);
 849         return (Socket) ret;
 850     }
 851
 852     cloexec(s);
 853
 854     ret->oobinline = 0;
 855
 856     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
 857                    (const char *)&on, sizeof(on)) < 0) {
 858         ret->error = strerror(errno);
 859         close(s);
 860         return (Socket) ret;
 861     }
 862
 863     retcode = -1;
 864     addr = NULL; addrlen = -1;         /* placate optimiser */
 865
 866     if (srcaddr != NULL) {
 867 #ifndef NO_IPV6
 868         hints.ai_flags = AI_NUMERICHOST;
 869         hints.ai_family = address_family;
 870         hints.ai_socktype = SOCK_STREAM;
 871         hints.ai_protocol = 0;
 872         hints.ai_addrlen = 0;
 873         hints.ai_addr = NULL;
 874         hints.ai_canonname = NULL;
 875         hints.ai_next = NULL;
 876         assert(port >= 0 && port <= 99999);
 877         sprintf(portstr, "%d", port);
 878         {
 879             char *trimmed_addr = host_strduptrim(srcaddr);
 880             retcode = getaddrinfo(trimmed_addr, portstr, &hints, &ai);
 881             sfree(trimmed_addr);
 882         }
 883         if (retcode == 0) {
 884             addr = (union sockaddr_union *)ai->ai_addr;
 885             addrlen = ai->ai_addrlen;
 886         }
 887 #else
 888         memset(&u,'\0',sizeof u);
 889         u.sin.sin_family = AF_INET;
 890         u.sin.sin_port = htons(port);
 891         u.sin.sin_addr.s_addr = inet_addr(srcaddr);
 892         if (u.sin.sin_addr.s_addr != (in_addr_t)(-1)) {
 893             /* Override localhost_only with specified listen addr. */
 894             ret->localhost_only = ipv4_is_loopback(u.sin.sin_addr);
 895         }
 896         addr = &u;
 897         addrlen = sizeof(u.sin);
 898         retcode = 0;
 899 #endif
 900     }
 901
 902     if (retcode != 0) {
 903         memset(&u,'\0',sizeof u);
 904 #ifndef NO_IPV6
 905         if (address_family == AF_INET6) {
 906             u.sin6.sin6_family = AF_INET6;
 907             u.sin6.sin6_port = htons(port);
 908             if (local_host_only)
 909                 u.sin6.sin6_addr = in6addr_loopback;
 910             else
 911                 u.sin6.sin6_addr = in6addr_any;
 912             addr = &u;
 913             addrlen = sizeof(u.sin6);
 914         } else
 915 #endif
 916         {
 917             u.sin.sin_family = AF_INET;
 918             u.sin.sin_port = htons(port);
 919             if (local_host_only)
 920                 u.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 921             else
 922                 u.sin.sin_addr.s_addr = htonl(INADDR_ANY);
 923             addr = &u;
 924             addrlen = sizeof(u.sin);
 925         }
 926     }
 927
 928     retcode = bind(s, &addr->sa, addrlen);
 929
 930 #ifndef NO_IPV6
 931     if (ai)
 932         freeaddrinfo(ai);
 933 #endif
 934
 935     if (retcode < 0) {
 936         close(s);
 937         ret->error = strerror(errno);
 938         return (Socket) ret;
 939     }
 940
 941     if (listen(s, SOMAXCONN) < 0) {
 942         close(s);
 943         ret->error = strerror(errno);
 944         return (Socket) ret;
 945     }
 946
 947 #ifndef NO_IPV6
 948     /*
 949      * If we were given ADDRTYPE_UNSPEC, we must also create an
 950      * IPv4 listening socket and link it to this one.
 951      */
 952     if (address_family == AF_INET6 && orig_address_family == ADDRTYPE_UNSPEC) {
 953         Actual_Socket other;
 954
 955         other = (Actual_Socket) sk_newlistener(srcaddr, port, plug,
 956                                                local_host_only, ADDRTYPE_IPV4);
 957
 958         if (other) {
 959             if (!other->error) {
 960                 other->parent = ret;
 961                 ret->child = other;
 962             } else {
 963                 /* If we couldn't create a listening socket on IPv4 as well
 964                  * as IPv6, we must return an error overall. */
 965                 close(s);
 966                 sfree(ret);
 967                 return (Socket) other;
 968             }
 969         }
 970     }
 971 #endif
 972
 973     ret->s = s;
 974
 975     uxsel_tell(ret);
 976     add234(sktree, ret);
 977
 978     return (Socket) ret;
 979 }
 980
 981 static void sk_tcp_close(Socket sock)
 982 {
 983     Actual_Socket s = (Actual_Socket) sock;
 984
 985     if (s->child)
 986         sk_tcp_close((Socket)s->child);
 987
 988     uxsel_del(s->s);
 989     del234(sktree, s);
 990     close(s->s);
 991     if (s->addr)
 992         sk_addr_free(s->addr);
 993     sfree(s);
 994 }
 995
 996 void *sk_getxdmdata(void *sock, int *lenp)
 997 {
 998     Actual_Socket s = (Actual_Socket) sock;
 999     union sockaddr_union u;
1000     socklen_t addrlen;
1001     char *buf;
1002     static unsigned int unix_addr = 0xFFFFFFFF;
1003
1004     /*
1005      * We must check that this socket really _is_ an Actual_Socket.
1006      */
1007     if (s->fn != &tcp_fn_table)
1008         return NULL;                   /* failure */
1009
1010     addrlen = sizeof(u);
1011     if (getsockname(s->s, &u.sa, &addrlen) < 0)
1012         return NULL;
1013     switch(u.sa.sa_family) {
1014       case AF_INET:
1015         *lenp = 6;
1016         buf = snewn(*lenp, char);
1017         PUT_32BIT_MSB_FIRST(buf, ntohl(u.sin.sin_addr.s_addr));
1018         PUT_16BIT_MSB_FIRST(buf+4, ntohs(u.sin.sin_port));
1019         break;
1020 #ifndef NO_IPV6
1021     case AF_INET6:
1022         *lenp = 6;
1023         buf = snewn(*lenp, char);
1024         if (IN6_IS_ADDR_V4MAPPED(&u.sin6.sin6_addr)) {
1025             memcpy(buf, u.sin6.sin6_addr.s6_addr + 12, 4);
1026             PUT_16BIT_MSB_FIRST(buf+4, ntohs(u.sin6.sin6_port));
1027         } else
1028             /* This is stupid, but it's what XLib does. */
1029             memset(buf, 0, 6);
1030         break;
1031 #endif
1032       case AF_UNIX:
1033         *lenp = 6;
1034         buf = snewn(*lenp, char);
1035         PUT_32BIT_MSB_FIRST(buf, unix_addr--);
1036         PUT_16BIT_MSB_FIRST(buf+4, getpid());
1037         break;
1038
1039         /* XXX IPV6 */
1040
1041       default:
1042         return NULL;
1043     }
1044
1045     return buf;
1046 }
1047
1048 /*
1049  * Deal with socket errors detected in try_send().
1050  */
1051 static void socket_error_callback(void *vs)
1052 {
1053     Actual_Socket s = (Actual_Socket)vs;
1054
1055     /*
1056      * Just in case other socket work has caused this socket to vanish
1057      * or become somehow non-erroneous before this callback arrived...
1058      */
1059     if (!find234(sktree, s, NULL) || !s->pending_error)
1060         return;
1061
1062     /*
1063      * An error has occurred on this socket. Pass it to the plug.
1064      */
1065     plug_closing(s->plug, strerror(s->pending_error), s->pending_error, 0);
1066 }
1067
1068 /*
1069  * The function which tries to send on a socket once it's deemed
1070  * writable.
1071  */
1072 void try_send(Actual_Socket s)
1073 {
1074     while (s->sending_oob || bufchain_size(&s->output_data) > 0) {
1075         int nsent;
1076         int err;
1077         void *data;
1078         int len, urgentflag;
1079
1080         if (s->sending_oob) {
1081             urgentflag = MSG_OOB;
1082             len = s->sending_oob;
1083             data = &s->oobdata;
1084         } else {
1085             urgentflag = 0;
1086             bufchain_prefix(&s->output_data, &data, &len);
1087         }
1088         nsent = send(s->s, data, len, urgentflag);
1089         noise_ultralight(nsent);
1090         if (nsent <= 0) {
1091             err = (nsent < 0 ? errno : 0);
1092             if (err == EWOULDBLOCK) {
1093                 /*
1094                  * Perfectly normal: we've sent all we can for the moment.
1095                  */
1096                 s->writable = FALSE;
1097                 return;
1098             } else {
1099                 /*
1100                  * We unfortunately can't just call plug_closing(),
1101                  * because it's quite likely that we're currently
1102                  * _in_ a call from the code we'd be calling back
1103                  * to, so we'd have to make half the SSH code
1104                  * reentrant. Instead we flag a pending error on
1105                  * the socket, to be dealt with (by calling
1106                  * plug_closing()) at some suitable future moment.
1107                  */
1108                 s->pending_error = err;
1109                 /*
1110                  * Immediately cease selecting on this socket, so that
1111                  * we don't tight-loop repeatedly trying to do
1112                  * whatever it was that went wrong.
1113                  */
1114                 uxsel_tell(s);
1115                 /*
1116                  * Arrange to be called back from the top level to
1117                  * deal with the error condition on this socket.
1118                  */
1119                 queue_toplevel_callback(socket_error_callback, s);
1120                 return;
1121             }
1122         } else {
1123             if (s->sending_oob) {
1124                 if (nsent < len) {
1125                     memmove(s->oobdata, s->oobdata+nsent, len-nsent);
1126                     s->sending_oob = len - nsent;
1127                 } else {
1128                     s->sending_oob = 0;
1129                 }
1130             } else {
1131                 bufchain_consume(&s->output_data, nsent);
1132             }
1133         }
1134     }
1135
1136     /*
1137      * If we reach here, we've finished sending everything we might
1138      * have needed to send. Send EOF, if we need to.
1139      */
1140     if (s->outgoingeof == EOF_PENDING) {
1141         shutdown(s->s, SHUT_WR);
1142         s->outgoingeof = EOF_SENT;
1143     }
1144
1145     /*
1146      * Also update the select status, because we don't need to select
1147      * for writing any more.
1148      */
1149     uxsel_tell(s);
1150 }
1151
1152 static int sk_tcp_write(Socket sock, const char *buf, int len)
1153 {
1154     Actual_Socket s = (Actual_Socket) sock;
1155
1156     assert(s->outgoingeof == EOF_NO);
1157
1158     /*
1159      * Add the data to the buffer list on the socket.
1160      */
1161     bufchain_add(&s->output_data, buf, len);
1162
1163     /*
1164      * Now try sending from the start of the buffer list.
1165      */
1166     if (s->writable)
1167         try_send(s);
1168
1169     /*
1170      * Update the select() status to correctly reflect whether or
1171      * not we should be selecting for write.
1172      */
1173     uxsel_tell(s);
1174
1175     return bufchain_size(&s->output_data);
1176 }
1177
1178 static int sk_tcp_write_oob(Socket sock, const char *buf, int len)
1179 {
1180     Actual_Socket s = (Actual_Socket) sock;
1181
1182     assert(s->outgoingeof == EOF_NO);
1183
1184     /*
1185      * Replace the buffer list on the socket with the data.
1186      */
1187     bufchain_clear(&s->output_data);
1188     assert(len <= sizeof(s->oobdata));
1189     memcpy(s->oobdata, buf, len);
1190     s->sending_oob = len;
1191
1192     /*
1193      * Now try sending from the start of the buffer list.
1194      */
1195     if (s->writable)
1196         try_send(s);
1197
1198     /*
1199      * Update the select() status to correctly reflect whether or
1200      * not we should be selecting for write.
1201      */
1202     uxsel_tell(s);
1203
1204     return s->sending_oob;
1205 }
1206
1207 static void sk_tcp_write_eof(Socket sock)
1208 {
1209     Actual_Socket s = (Actual_Socket) sock;
1210
1211     assert(s->outgoingeof == EOF_NO);
1212
1213     /*
1214      * Mark the socket as pending outgoing EOF.
1215      */
1216     s->outgoingeof = EOF_PENDING;
1217
1218     /*
1219      * Now try sending from the start of the buffer list.
1220      */
1221     if (s->writable)
1222         try_send(s);
1223
1224     /*
1225      * Update the select() status to correctly reflect whether or
1226      * not we should be selecting for write.
1227      */
1228     uxsel_tell(s);
1229 }
1230
1231 static int net_select_result(int fd, int event)
1232 {
1233     int ret;
1234     char buf[20480];                   /* nice big buffer for plenty of speed */
1235     Actual_Socket s;
1236     u_long atmark;
1237
1238     /* Find the Socket structure */
1239     s = find234(sktree, &fd, cmpforsearch);
1240     if (!s)
1241         return 1;                      /* boggle */
1242
1243     noise_ultralight(event);
1244
1245     switch (event) {
1246       case 4:                          /* exceptional */
1247         if (!s->oobinline) {
1248             /*
1249              * On a non-oobinline socket, this indicates that we
1250              * can immediately perform an OOB read and get back OOB
1251              * data, which we will send to the back end with
1252              * type==2 (urgent data).
1253              */
1254             ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
1255             noise_ultralight(ret);
1256             if (ret <= 0) {
1257                 return plug_closing(s->plug,
1258                                     ret == 0 ? "Internal networking trouble" :
1259                                     strerror(errno), errno, 0);
1260             } else {
1261                 /*
1262                  * Receiving actual data on a socket means we can
1263                  * stop falling back through the candidate
1264                  * addresses to connect to.
1265                  */
1266                 if (s->addr) {
1267                     sk_addr_free(s->addr);
1268                     s->addr = NULL;
1269                 }
1270                 return plug_receive(s->plug, 2, buf, ret);
1271             }
1272             break;
1273         }
1274
1275         /*
1276          * If we reach here, this is an oobinline socket, which
1277          * means we should set s->oobpending and then deal with it
1278          * when we get called for the readability event (which
1279          * should also occur).
1280          */
1281         s->oobpending = TRUE;
1282         break;
1283       case 1:                          /* readable; also acceptance */
1284         if (s->listener) {
1285             /*
1286              * On a listening socket, the readability event means a
1287              * connection is ready to be accepted.
1288              */
1289             union sockaddr_union su;
1290             socklen_t addrlen = sizeof(su);
1291             accept_ctx_t actx;
1292             int t;  /* socket of connection */
1293
1294             memset(&su, 0, addrlen);
1295             t = accept(s->s, &su.sa, &addrlen);
1296             if (t < 0) {
1297                 break;
1298             }
1299
1300             nonblock(t);
1301             actx.i = t;
1302
1303             if ((!s->addr || s->addr->superfamily != UNIX) &&
1304                 s->localhost_only && !sockaddr_is_loopback(&su.sa)) {
1305                 close(t);              /* someone let nonlocal through?! */
1306             } else if (plug_accepting(s->plug, sk_tcp_accept, actx)) {
1307                 close(t);              /* denied or error */
1308             }
1309             break;
1310         }
1311
1312         /*
1313          * If we reach here, this is not a listening socket, so
1314          * readability really means readability.
1315          */
1316
1317         /* In the case the socket is still frozen, we don't even bother */
1318         if (s->frozen)
1319             break;
1320
1321         /*
1322          * We have received data on the socket. For an oobinline
1323          * socket, this might be data _before_ an urgent pointer,
1324          * in which case we send it to the back end with type==1
1325          * (data prior to urgent).
1326          */
1327         if (s->oobinline && s->oobpending) {
1328             atmark = 1;
1329             if (ioctl(s->s, SIOCATMARK, &atmark) == 0 && atmark)
1330                 s->oobpending = FALSE; /* clear this indicator */
1331         } else
1332             atmark = 1;
1333
1334         ret = recv(s->s, buf, s->oobpending ? 1 : sizeof(buf), 0);
1335         noise_ultralight(ret);
1336         if (ret < 0) {
1337             if (errno == EWOULDBLOCK) {
1338                 break;
1339             }
1340         }
1341         if (ret < 0) {
1342             /*
1343              * An error at this point _might_ be an error reported
1344              * by a non-blocking connect(). So before we return a
1345              * panic status to the user, let's just see whether
1346              * that's the case.
1347              */
1348             int err = errno;
1349             if (s->addr) {
1350                 plug_log(s->plug, 1, s->addr, s->port, strerror(err), err);
1351                 while (s->addr && sk_nextaddr(s->addr, &s->step)) {
1352                     err = try_connect(s);
1353                 }
1354             }
1355             if (err != 0)
1356                 return plug_closing(s->plug, strerror(err), err, 0);
1357         } else if (0 == ret) {
1358             s->incomingeof = TRUE;     /* stop trying to read now */
1359             uxsel_tell(s);
1360             return plug_closing(s->plug, NULL, 0, 0);
1361         } else {
1362             /*
1363              * Receiving actual data on a socket means we can
1364              * stop falling back through the candidate
1365              * addresses to connect to.
1366              */
1367             if (s->addr) {
1368                 sk_addr_free(s->addr);
1369                 s->addr = NULL;
1370             }
1371             return plug_receive(s->plug, atmark ? 0 : 1, buf, ret);
1372         }
1373         break;
1374       case 2:                          /* writable */
1375         if (!s->connected) {
1376             /*
1377              * select() reports a socket as _writable_ when an
1378              * asynchronous connection is completed.
1379              */
1380             s->connected = s->writable = 1;
1381             uxsel_tell(s);
1382             break;
1383         } else {
1384             int bufsize_before, bufsize_after;
1385             s->writable = 1;
1386             bufsize_before = s->sending_oob + bufchain_size(&s->output_data);
1387             try_send(s);
1388             bufsize_after = s->sending_oob + bufchain_size(&s->output_data);
1389             if (bufsize_after < bufsize_before)
1390                 plug_sent(s->plug, bufsize_after);
1391         }
1392         break;
1393     }
1394
1395     return 1;
1396 }
1397
1398 /*
1399  * Special error values are returned from sk_namelookup and sk_new
1400  * if there's a problem. These functions extract an error message,
1401  * or return NULL if there's no problem.
1402  */
1403 const char *sk_addr_error(SockAddr addr)
1404 {
1405     return addr->error;
1406 }
1407 static const char *sk_tcp_socket_error(Socket sock)
1408 {
1409     Actual_Socket s = (Actual_Socket) sock;
1410     return s->error;
1411 }
1412
1413 static void sk_tcp_set_frozen(Socket sock, int is_frozen)
1414 {
1415     Actual_Socket s = (Actual_Socket) sock;
1416     if (s->frozen == is_frozen)
1417         return;
1418     s->frozen = is_frozen;
1419     uxsel_tell(s);
1420 }
1421
1422 static void uxsel_tell(Actual_Socket s)
1423 {
1424     int rwx = 0;
1425     if (!s->pending_error) {
1426         if (s->listener) {
1427             rwx |= 1;                  /* read == accept */
1428         } else {
1429             if (!s->connected)
1430                 rwx |= 2;              /* write == connect */
1431             if (s->connected && !s->frozen && !s->incomingeof)
1432                 rwx |= 1 | 4;          /* read, except */
1433             if (bufchain_size(&s->output_data))
1434                 rwx |= 2;              /* write */
1435         }
1436     }
1437     uxsel_set(s->s, rwx, net_select_result);
1438 }
1439
1440 int net_service_lookup(char *service)
1441 {
1442     struct servent *se;
1443     se = getservbyname(service, NULL);
1444     if (se != NULL)
1445         return ntohs(se->s_port);
1446     else
1447         return 0;
1448 }
1449
1450 char *get_hostname(void)
1451 {
1452     int len = 128;
1453     char *hostname = NULL;
1454     do {
1455         len *= 2;
1456         hostname = sresize(hostname, len, char);
1457         if ((gethostname(hostname, len) < 0) &&
1458             (errno != ENAMETOOLONG)) {
1459             sfree(hostname);
1460             hostname = NULL;
1461             break;
1462         }
1463     } while (strlen(hostname) >= len-1);
1464     return hostname;
1465 }
1466
1467 SockAddr platform_get_x11_unix_address(const char *sockpath, int displaynum)
1468 {
1469     SockAddr ret = snew(struct SockAddr_tag);
1470     int n;
1471
1472     memset(ret, 0, sizeof *ret);
1473     ret->superfamily = UNIX;
1474     /*
1475      * In special circumstances (notably Mac OS X Leopard), we'll
1476      * have been passed an explicit Unix socket path.
1477      */
1478     if (sockpath) {
1479         n = snprintf(ret->hostname, sizeof ret->hostname,
1480                      "%s", sockpath);
1481     } else {
1482         n = snprintf(ret->hostname, sizeof ret->hostname,
1483                      "%s%d", X11_UNIX_PATH, displaynum);
1484     }
1485
1486     if (n < 0)
1487         ret->error = "snprintf failed";
1488     else if (n >= sizeof ret->hostname)
1489         ret->error = "X11 UNIX name too long";
1490
1491 #ifndef NO_IPV6
1492     ret->ais = NULL;
1493 #else
1494     ret->addresses = NULL;
1495     ret->naddresses = 0;
1496 #endif
1497     ret->refcount = 1;
1498     return ret;
1499 }
1500
1501 SockAddr unix_sock_addr(const char *path)
1502 {
1503     SockAddr ret = snew(struct SockAddr_tag);
1504     int n;
1505
1506     memset(ret, 0, sizeof *ret);
1507     ret->superfamily = UNIX;
1508     n = snprintf(ret->hostname, sizeof ret->hostname, "%s", path);
1509
1510     if (n < 0)
1511         ret->error = "snprintf failed";
1512     else if (n >= sizeof ret->hostname)
1513         ret->error = "socket pathname too long";
1514
1515 #ifndef NO_IPV6
1516     ret->ais = NULL;
1517 #else
1518     ret->addresses = NULL;
1519     ret->naddresses = 0;
1520 #endif
1521     ret->refcount = 1;
1522     return ret;
1523 }
1524
1525 Socket new_unix_listener(SockAddr listenaddr, Plug plug)
1526 {
1527     int s;
1528     union sockaddr_union u;
1529     union sockaddr_union *addr;
1530     int addrlen;
1531     Actual_Socket ret;
1532     int retcode;
1533
1534     /*
1535      * Create Socket structure.
1536      */
1537     ret = snew(struct Socket_tag);
1538     ret->fn = &tcp_fn_table;
1539     ret->error = NULL;
1540     ret->plug = plug;
1541     bufchain_init(&ret->output_data);
1542     ret->writable = 0;                 /* to start with */
1543     ret->sending_oob = 0;
1544     ret->frozen = 0;
1545     ret->localhost_only = TRUE;
1546     ret->pending_error = 0;
1547     ret->parent = ret->child = NULL;
1548     ret->oobpending = FALSE;
1549     ret->outgoingeof = EOF_NO;
1550     ret->incomingeof = FALSE;
1551     ret->listener = 1;
1552     ret->addr = listenaddr;
1553     ret->s = -1;
1554
1555     assert(listenaddr->superfamily == UNIX);
1556
1557     /*
1558      * Open socket.
1559      */
1560     s = socket(AF_UNIX, SOCK_STREAM, 0);
1561     if (s < 0) {
1562         ret->error = strerror(errno);
1563         return (Socket) ret;
1564     }
1565
1566     cloexec(s);
1567
1568     ret->oobinline = 0;
1569
1570     memset(&u, '\0', sizeof(u));
1571     u.su.sun_family = AF_UNIX;
1572     strncpy(u.su.sun_path, listenaddr->hostname, sizeof(u.su.sun_path)-1);
1573     addr = &u;
1574     addrlen = sizeof(u.su);
1575
1576     if (unlink(u.su.sun_path) < 0 && errno != ENOENT) {
1577         close(s);
1578         ret->error = strerror(errno);
1579         return (Socket) ret;
1580     }
1581
1582     retcode = bind(s, &addr->sa, addrlen);
1583     if (retcode < 0) {
1584         close(s);
1585         ret->error = strerror(errno);
1586         return (Socket) ret;
1587     }
1588
1589     if (listen(s, SOMAXCONN) < 0) {
1590         close(s);
1591         ret->error = strerror(errno);
1592         return (Socket) ret;
1593     }
1594
1595     ret->s = s;
1596
1597     uxsel_tell(ret);
1598     add234(sktree, ret);
1599
1600     return (Socket) ret;
1601 }