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