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;
 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     if (retcode < 0) {
 930         close(s);
 931         ret->error = strerror(errno);
 932         return (Socket) ret;
 933     }
 934
 935     if (listen(s, SOMAXCONN) < 0) {
 936         close(s);
 937         ret->error = strerror(errno);
 938         return (Socket) ret;
 939     }
 940
 941 #ifndef NO_IPV6
 942     /*
 943      * If we were given ADDRTYPE_UNSPEC, we must also create an
 944      * IPv4 listening socket and link it to this one.
 945      */
 946     if (address_family == AF_INET6 && orig_address_family == ADDRTYPE_UNSPEC) {
 947         Actual_Socket other;
 948
 949         other = (Actual_Socket) sk_newlistener(srcaddr, port, plug,
 950                                                local_host_only, ADDRTYPE_IPV4);
 951
 952         if (other) {
 953             if (!other->error) {
 954                 other->parent = ret;
 955                 ret->child = other;
 956             } else {
 957                 /* If we couldn't create a listening socket on IPv4 as well
 958                  * as IPv6, we must return an error overall. */
 959                 close(s);
 960                 sfree(ret);
 961                 return (Socket) other;
 962             }
 963         }
 964     }
 965 #endif
 966
 967     ret->s = s;
 968
 969     uxsel_tell(ret);
 970     add234(sktree, ret);
 971
 972     return (Socket) ret;
 973 }
 974
 975 static void sk_tcp_close(Socket sock)
 976 {
 977     Actual_Socket s = (Actual_Socket) sock;
 978
 979     if (s->child)
 980         sk_tcp_close((Socket)s->child);
 981
 982     uxsel_del(s->s);
 983     del234(sktree, s);
 984     close(s->s);
 985     if (s->addr)
 986         sk_addr_free(s->addr);
 987     sfree(s);
 988 }
 989
 990 void *sk_getxdmdata(void *sock, int *lenp)
 991 {
 992     Actual_Socket s = (Actual_Socket) sock;
 993     union sockaddr_union u;
 994     socklen_t addrlen;
 995     char *buf;
 996     static unsigned int unix_addr = 0xFFFFFFFF;
 997
 998     /*
 999      * We must check that this socket really _is_ an Actual_Socket.
1000      */
1001     if (s->fn != &tcp_fn_table)
1002         return NULL;                   /* failure */
1003
1004     addrlen = sizeof(u);
1005     if (getsockname(s->s, &u.sa, &addrlen) < 0)
1006         return NULL;
1007     switch(u.sa.sa_family) {
1008       case AF_INET:
1009         *lenp = 6;
1010         buf = snewn(*lenp, char);
1011         PUT_32BIT_MSB_FIRST(buf, ntohl(u.sin.sin_addr.s_addr));
1012         PUT_16BIT_MSB_FIRST(buf+4, ntohs(u.sin.sin_port));
1013         break;
1014 #ifndef NO_IPV6
1015     case AF_INET6:
1016         *lenp = 6;
1017         buf = snewn(*lenp, char);
1018         if (IN6_IS_ADDR_V4MAPPED(&u.sin6.sin6_addr)) {
1019             memcpy(buf, u.sin6.sin6_addr.s6_addr + 12, 4);
1020             PUT_16BIT_MSB_FIRST(buf+4, ntohs(u.sin6.sin6_port));
1021         } else
1022             /* This is stupid, but it's what XLib does. */
1023             memset(buf, 0, 6);
1024         break;
1025 #endif
1026       case AF_UNIX:
1027         *lenp = 6;
1028         buf = snewn(*lenp, char);
1029         PUT_32BIT_MSB_FIRST(buf, unix_addr--);
1030         PUT_16BIT_MSB_FIRST(buf+4, getpid());
1031         break;
1032
1033         /* XXX IPV6 */
1034
1035       default:
1036         return NULL;
1037     }
1038
1039     return buf;
1040 }
1041
1042 /*
1043  * Deal with socket errors detected in try_send().
1044  */
1045 static void socket_error_callback(void *vs)
1046 {
1047     Actual_Socket s = (Actual_Socket)vs;
1048
1049     /*
1050      * Just in case other socket work has caused this socket to vanish
1051      * or become somehow non-erroneous before this callback arrived...
1052      */
1053     if (!find234(sktree, s, NULL) || !s->pending_error)
1054         return;
1055
1056     /*
1057      * An error has occurred on this socket. Pass it to the plug.
1058      */
1059     plug_closing(s->plug, strerror(s->pending_error), s->pending_error, 0);
1060 }
1061
1062 /*
1063  * The function which tries to send on a socket once it's deemed
1064  * writable.
1065  */
1066 void try_send(Actual_Socket s)
1067 {
1068     while (s->sending_oob || bufchain_size(&s->output_data) > 0) {
1069         int nsent;
1070         int err;
1071         void *data;
1072         int len, urgentflag;
1073
1074         if (s->sending_oob) {
1075             urgentflag = MSG_OOB;
1076             len = s->sending_oob;
1077             data = &s->oobdata;
1078         } else {
1079             urgentflag = 0;
1080             bufchain_prefix(&s->output_data, &data, &len);
1081         }
1082         nsent = send(s->s, data, len, urgentflag);
1083         noise_ultralight(nsent);
1084         if (nsent <= 0) {
1085             err = (nsent < 0 ? errno : 0);
1086             if (err == EWOULDBLOCK) {
1087                 /*
1088                  * Perfectly normal: we've sent all we can for the moment.
1089                  */
1090                 s->writable = FALSE;
1091                 return;
1092             } else {
1093                 /*
1094                  * We unfortunately can't just call plug_closing(),
1095                  * because it's quite likely that we're currently
1096                  * _in_ a call from the code we'd be calling back
1097                  * to, so we'd have to make half the SSH code
1098                  * reentrant. Instead we flag a pending error on
1099                  * the socket, to be dealt with (by calling
1100                  * plug_closing()) at some suitable future moment.
1101                  */
1102                 s->pending_error = err;
1103                 /*
1104                  * Immediately cease selecting on this socket, so that
1105                  * we don't tight-loop repeatedly trying to do
1106                  * whatever it was that went wrong.
1107                  */
1108                 uxsel_tell(s);
1109                 /*
1110                  * Arrange to be called back from the top level to
1111                  * deal with the error condition on this socket.
1112                  */
1113                 queue_toplevel_callback(socket_error_callback, s);
1114                 return;
1115             }
1116         } else {
1117             if (s->sending_oob) {
1118                 if (nsent < len) {
1119                     memmove(s->oobdata, s->oobdata+nsent, len-nsent);
1120                     s->sending_oob = len - nsent;
1121                 } else {
1122                     s->sending_oob = 0;
1123                 }
1124             } else {
1125                 bufchain_consume(&s->output_data, nsent);
1126             }
1127         }
1128     }
1129
1130     /*
1131      * If we reach here, we've finished sending everything we might
1132      * have needed to send. Send EOF, if we need to.
1133      */
1134     if (s->outgoingeof == EOF_PENDING) {
1135         shutdown(s->s, SHUT_WR);
1136         s->outgoingeof = EOF_SENT;
1137     }
1138
1139     /*
1140      * Also update the select status, because we don't need to select
1141      * for writing any more.
1142      */
1143     uxsel_tell(s);
1144 }
1145
1146 static int sk_tcp_write(Socket sock, const char *buf, int len)
1147 {
1148     Actual_Socket s = (Actual_Socket) sock;
1149
1150     assert(s->outgoingeof == EOF_NO);
1151
1152     /*
1153      * Add the data to the buffer list on the socket.
1154      */
1155     bufchain_add(&s->output_data, buf, len);
1156
1157     /*
1158      * Now try sending from the start of the buffer list.
1159      */
1160     if (s->writable)
1161         try_send(s);
1162
1163     /*
1164      * Update the select() status to correctly reflect whether or
1165      * not we should be selecting for write.
1166      */
1167     uxsel_tell(s);
1168
1169     return bufchain_size(&s->output_data);
1170 }
1171
1172 static int sk_tcp_write_oob(Socket sock, const char *buf, int len)
1173 {
1174     Actual_Socket s = (Actual_Socket) sock;
1175
1176     assert(s->outgoingeof == EOF_NO);
1177
1178     /*
1179      * Replace the buffer list on the socket with the data.
1180      */
1181     bufchain_clear(&s->output_data);
1182     assert(len <= sizeof(s->oobdata));
1183     memcpy(s->oobdata, buf, len);
1184     s->sending_oob = len;
1185
1186     /*
1187      * Now try sending from the start of the buffer list.
1188      */
1189     if (s->writable)
1190         try_send(s);
1191
1192     /*
1193      * Update the select() status to correctly reflect whether or
1194      * not we should be selecting for write.
1195      */
1196     uxsel_tell(s);
1197
1198     return s->sending_oob;
1199 }
1200
1201 static void sk_tcp_write_eof(Socket sock)
1202 {
1203     Actual_Socket s = (Actual_Socket) sock;
1204
1205     assert(s->outgoingeof == EOF_NO);
1206
1207     /*
1208      * Mark the socket as pending outgoing EOF.
1209      */
1210     s->outgoingeof = EOF_PENDING;
1211
1212     /*
1213      * Now try sending from the start of the buffer list.
1214      */
1215     if (s->writable)
1216         try_send(s);
1217
1218     /*
1219      * Update the select() status to correctly reflect whether or
1220      * not we should be selecting for write.
1221      */
1222     uxsel_tell(s);
1223 }
1224
1225 static int net_select_result(int fd, int event)
1226 {
1227     int ret;
1228     char buf[20480];                   /* nice big buffer for plenty of speed */
1229     Actual_Socket s;
1230     u_long atmark;
1231
1232     /* Find the Socket structure */
1233     s = find234(sktree, &fd, cmpforsearch);
1234     if (!s)
1235         return 1;                      /* boggle */
1236
1237     noise_ultralight(event);
1238
1239     switch (event) {
1240       case 4:                          /* exceptional */
1241         if (!s->oobinline) {
1242             /*
1243              * On a non-oobinline socket, this indicates that we
1244              * can immediately perform an OOB read and get back OOB
1245              * data, which we will send to the back end with
1246              * type==2 (urgent data).
1247              */
1248             ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
1249             noise_ultralight(ret);
1250             if (ret <= 0) {
1251                 return plug_closing(s->plug,
1252                                     ret == 0 ? "Internal networking trouble" :
1253                                     strerror(errno), errno, 0);
1254             } else {
1255                 /*
1256                  * Receiving actual data on a socket means we can
1257                  * stop falling back through the candidate
1258                  * addresses to connect to.
1259                  */
1260                 if (s->addr) {
1261                     sk_addr_free(s->addr);
1262                     s->addr = NULL;
1263                 }
1264                 return plug_receive(s->plug, 2, buf, ret);
1265             }
1266             break;
1267         }
1268
1269         /*
1270          * If we reach here, this is an oobinline socket, which
1271          * means we should set s->oobpending and then deal with it
1272          * when we get called for the readability event (which
1273          * should also occur).
1274          */
1275         s->oobpending = TRUE;
1276         break;
1277       case 1:                          /* readable; also acceptance */
1278         if (s->listener) {
1279             /*
1280              * On a listening socket, the readability event means a
1281              * connection is ready to be accepted.
1282              */
1283             union sockaddr_union su;
1284             socklen_t addrlen = sizeof(su);
1285             accept_ctx_t actx;
1286             int t;  /* socket of connection */
1287
1288             memset(&su, 0, addrlen);
1289             t = accept(s->s, &su.sa, &addrlen);
1290             if (t < 0) {
1291                 break;
1292             }
1293
1294             nonblock(t);
1295             actx.i = t;
1296
1297             if ((!s->addr || s->addr->superfamily != UNIX) &&
1298                 s->localhost_only && !sockaddr_is_loopback(&su.sa)) {
1299                 close(t);              /* someone let nonlocal through?! */
1300             } else if (plug_accepting(s->plug, sk_tcp_accept, actx)) {
1301                 close(t);              /* denied or error */
1302             }
1303             break;
1304         }
1305
1306         /*
1307          * If we reach here, this is not a listening socket, so
1308          * readability really means readability.
1309          */
1310
1311         /* In the case the socket is still frozen, we don't even bother */
1312         if (s->frozen)
1313             break;
1314
1315         /*
1316          * We have received data on the socket. For an oobinline
1317          * socket, this might be data _before_ an urgent pointer,
1318          * in which case we send it to the back end with type==1
1319          * (data prior to urgent).
1320          */
1321         if (s->oobinline && s->oobpending) {
1322             atmark = 1;
1323             if (ioctl(s->s, SIOCATMARK, &atmark) == 0 && atmark)
1324                 s->oobpending = FALSE; /* clear this indicator */
1325         } else
1326             atmark = 1;
1327
1328         ret = recv(s->s, buf, s->oobpending ? 1 : sizeof(buf), 0);
1329         noise_ultralight(ret);
1330         if (ret < 0) {
1331             if (errno == EWOULDBLOCK) {
1332                 break;
1333             }
1334         }
1335         if (ret < 0) {
1336             /*
1337              * An error at this point _might_ be an error reported
1338              * by a non-blocking connect(). So before we return a
1339              * panic status to the user, let's just see whether
1340              * that's the case.
1341              */
1342             int err = errno;
1343             if (s->addr) {
1344                 plug_log(s->plug, 1, s->addr, s->port, strerror(err), err);
1345                 while (s->addr && sk_nextaddr(s->addr, &s->step)) {
1346                     err = try_connect(s);
1347                 }
1348             }
1349             if (err != 0)
1350                 return plug_closing(s->plug, strerror(err), err, 0);
1351         } else if (0 == ret) {
1352             s->incomingeof = TRUE;     /* stop trying to read now */
1353             uxsel_tell(s);
1354             return plug_closing(s->plug, NULL, 0, 0);
1355         } else {
1356             /*
1357              * Receiving actual data on a socket means we can
1358              * stop falling back through the candidate
1359              * addresses to connect to.
1360              */
1361             if (s->addr) {
1362                 sk_addr_free(s->addr);
1363                 s->addr = NULL;
1364             }
1365             return plug_receive(s->plug, atmark ? 0 : 1, buf, ret);
1366         }
1367         break;
1368       case 2:                          /* writable */
1369         if (!s->connected) {
1370             /*
1371              * select() reports a socket as _writable_ when an
1372              * asynchronous connection is completed.
1373              */
1374             s->connected = s->writable = 1;
1375             uxsel_tell(s);
1376             break;
1377         } else {
1378             int bufsize_before, bufsize_after;
1379             s->writable = 1;
1380             bufsize_before = s->sending_oob + bufchain_size(&s->output_data);
1381             try_send(s);
1382             bufsize_after = s->sending_oob + bufchain_size(&s->output_data);
1383             if (bufsize_after < bufsize_before)
1384                 plug_sent(s->plug, bufsize_after);
1385         }
1386         break;
1387     }
1388
1389     return 1;
1390 }
1391
1392 /*
1393  * Special error values are returned from sk_namelookup and sk_new
1394  * if there's a problem. These functions extract an error message,
1395  * or return NULL if there's no problem.
1396  */
1397 const char *sk_addr_error(SockAddr addr)
1398 {
1399     return addr->error;
1400 }
1401 static const char *sk_tcp_socket_error(Socket sock)
1402 {
1403     Actual_Socket s = (Actual_Socket) sock;
1404     return s->error;
1405 }
1406
1407 static void sk_tcp_set_frozen(Socket sock, int is_frozen)
1408 {
1409     Actual_Socket s = (Actual_Socket) sock;
1410     if (s->frozen == is_frozen)
1411         return;
1412     s->frozen = is_frozen;
1413     uxsel_tell(s);
1414 }
1415
1416 static void uxsel_tell(Actual_Socket s)
1417 {
1418     int rwx = 0;
1419     if (!s->pending_error) {
1420         if (s->listener) {
1421             rwx |= 1;                  /* read == accept */
1422         } else {
1423             if (!s->connected)
1424                 rwx |= 2;              /* write == connect */
1425             if (s->connected && !s->frozen && !s->incomingeof)
1426                 rwx |= 1 | 4;          /* read, except */
1427             if (bufchain_size(&s->output_data))
1428                 rwx |= 2;              /* write */
1429         }
1430     }
1431     uxsel_set(s->s, rwx, net_select_result);
1432 }
1433
1434 int net_service_lookup(char *service)
1435 {
1436     struct servent *se;
1437     se = getservbyname(service, NULL);
1438     if (se != NULL)
1439         return ntohs(se->s_port);
1440     else
1441         return 0;
1442 }
1443
1444 char *get_hostname(void)
1445 {
1446     int len = 128;
1447     char *hostname = NULL;
1448     do {
1449         len *= 2;
1450         hostname = sresize(hostname, len, char);
1451         if ((gethostname(hostname, len) < 0) &&
1452             (errno != ENAMETOOLONG)) {
1453             sfree(hostname);
1454             hostname = NULL;
1455             break;
1456         }
1457     } while (strlen(hostname) >= len-1);
1458     return hostname;
1459 }
1460
1461 SockAddr platform_get_x11_unix_address(const char *sockpath, int displaynum)
1462 {
1463     SockAddr ret = snew(struct SockAddr_tag);
1464     int n;
1465
1466     memset(ret, 0, sizeof *ret);
1467     ret->superfamily = UNIX;
1468     /*
1469      * In special circumstances (notably Mac OS X Leopard), we'll
1470      * have been passed an explicit Unix socket path.
1471      */
1472     if (sockpath) {
1473         n = snprintf(ret->hostname, sizeof ret->hostname,
1474                      "%s", sockpath);
1475     } else {
1476         n = snprintf(ret->hostname, sizeof ret->hostname,
1477                      "%s%d", X11_UNIX_PATH, displaynum);
1478     }
1479
1480     if (n < 0)
1481         ret->error = "snprintf failed";
1482     else if (n >= sizeof ret->hostname)
1483         ret->error = "X11 UNIX name too long";
1484
1485 #ifndef NO_IPV6
1486     ret->ais = NULL;
1487 #else
1488     ret->addresses = NULL;
1489     ret->naddresses = 0;
1490 #endif
1491     ret->refcount = 1;
1492     return ret;
1493 }
1494
1495 SockAddr unix_sock_addr(const char *path)
1496 {
1497     SockAddr ret = snew(struct SockAddr_tag);
1498     int n;
1499
1500     memset(ret, 0, sizeof *ret);
1501     ret->superfamily = UNIX;
1502     n = snprintf(ret->hostname, sizeof ret->hostname, "%s", path);
1503
1504     if (n < 0)
1505         ret->error = "snprintf failed";
1506     else if (n >= sizeof ret->hostname)
1507         ret->error = "socket pathname too long";
1508
1509 #ifndef NO_IPV6
1510     ret->ais = NULL;
1511 #else
1512     ret->addresses = NULL;
1513     ret->naddresses = 0;
1514 #endif
1515     ret->refcount = 1;
1516     return ret;
1517 }
1518
1519 Socket new_unix_listener(SockAddr listenaddr, Plug plug)
1520 {
1521     int s;
1522     union sockaddr_union u;
1523     union sockaddr_union *addr;
1524     int addrlen;
1525     Actual_Socket ret;
1526     int retcode;
1527
1528     /*
1529      * Create Socket structure.
1530      */
1531     ret = snew(struct Socket_tag);
1532     ret->fn = &tcp_fn_table;
1533     ret->error = NULL;
1534     ret->plug = plug;
1535     bufchain_init(&ret->output_data);
1536     ret->writable = 0;                 /* to start with */
1537     ret->sending_oob = 0;
1538     ret->frozen = 0;
1539     ret->localhost_only = TRUE;
1540     ret->pending_error = 0;
1541     ret->parent = ret->child = NULL;
1542     ret->oobpending = FALSE;
1543     ret->outgoingeof = EOF_NO;
1544     ret->incomingeof = FALSE;
1545     ret->listener = 1;
1546     ret->addr = listenaddr;
1547     ret->s = -1;
1548
1549     assert(listenaddr->superfamily == UNIX);
1550
1551     /*
1552      * Open socket.
1553      */
1554     s = socket(AF_UNIX, SOCK_STREAM, 0);
1555     if (s < 0) {
1556         ret->error = strerror(errno);
1557         return (Socket) ret;
1558     }
1559
1560     cloexec(s);
1561
1562     ret->oobinline = 0;
1563
1564     memset(&u, '\0', sizeof(u));
1565     u.su.sun_family = AF_UNIX;
1566     strncpy(u.su.sun_path, listenaddr->hostname, sizeof(u.su.sun_path)-1);
1567     addr = &u;
1568     addrlen = sizeof(u.su);
1569
1570     if (unlink(u.su.sun_path) < 0 && errno != ENOENT) {
1571         close(s);
1572         ret->error = strerror(errno);
1573         return (Socket) ret;
1574     }
1575
1576     retcode = bind(s, &addr->sa, addrlen);
1577     if (retcode < 0) {
1578         close(s);
1579         ret->error = strerror(errno);
1580         return (Socket) ret;
1581     }
1582
1583     if (listen(s, SOMAXCONN) < 0) {
1584         close(s);
1585         ret->error = strerror(errno);
1586         return (Socket) ret;
1587     }
1588
1589     ret->s = s;
1590
1591     uxsel_tell(ret);
1592     add234(sktree, ret);
1593
1594     return (Socket) ret;
1595 }