util/src/TclTk/tcl8.6.12/unix/tclUnixSock.c

   1 /*
   2  * tclUnixSock.c --
   3  *
   4  *      This file contains Unix-specific socket related code.
   5  *
   6  * Copyright (c) 1995 Sun Microsystems, Inc.
   7  *
   8  * See the file "license.terms" for information on usage and redistribution of
   9  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10  */
  11
  12 #include "tclInt.h"
  13
  14 /*
  15  * Helper macros to make parts of this file clearer. The macros do exactly
  16  * what they say on the tin. :-) They also only ever refer to their arguments
  17  * once, and so can be used without regard to side effects.
  18  */
  19
  20 #define SET_BITS(var, bits)     ((var) |= (bits))
  21 #define CLEAR_BITS(var, bits)   ((var) &= ~(bits))
  22 #define GOT_BITS(var, bits)     (((var) & (bits)) != 0)
  23
  24 /* "sock" + a pointer in hex + \0 */
  25 #define SOCK_CHAN_LENGTH        (4 + sizeof(void *) * 2 + 1)
  26 #define SOCK_TEMPLATE           "sock%lx"
  27
  28 #undef SOCKET   /* Possible conflict with win32 SOCKET */
  29
  30 /*
  31  * This is needed to comply with the strict aliasing rules of GCC, but it also
  32  * simplifies casting between the different sockaddr types.
  33  */
  34
  35 typedef union {
  36     struct sockaddr sa;
  37     struct sockaddr_in sa4;
  38     struct sockaddr_in6 sa6;
  39     struct sockaddr_storage sas;
  40 } address;
  41
  42 /*
  43  * This structure describes per-instance state of a tcp based channel.
  44  */
  45
  46 typedef struct TcpState TcpState;
  47
  48 typedef struct TcpFdList {
  49     TcpState *statePtr;
  50     int fd;
  51     struct TcpFdList *next;
  52 } TcpFdList;
  53
  54 struct TcpState {
  55     Tcl_Channel channel;        /* Channel associated with this file. */
  56     TcpFdList fds;              /* The file descriptors of the sockets. */
  57     int flags;                  /* ORed combination of the bitfields defined
  58                                  * below. */
  59     int interest;               /* Event types of interest */
  60
  61     /*
  62      * Only needed for server sockets
  63      */
  64
  65     Tcl_TcpAcceptProc *acceptProc;
  66                                 /* Proc to call on accept. */
  67     ClientData acceptProcData;  /* The data for the accept proc. */
  68
  69     /*
  70      * Only needed for client sockets
  71      */
  72
  73     struct addrinfo *addrlist;  /* Addresses to connect to. */
  74     struct addrinfo *addr;      /* Iterator over addrlist. */
  75     struct addrinfo *myaddrlist;/* Local address. */
  76     struct addrinfo *myaddr;    /* Iterator over myaddrlist. */
  77     int filehandlers;           /* Caches FileHandlers that get set up while
  78                                  * an async socket is not yet connected. */
  79     int connectError;           /* Cache SO_ERROR of async socket. */
  80     int cachedBlocking;         /* Cache blocking mode of async socket. */
  81 };
  82
  83 /*
  84  * These bits may be ORed together into the "flags" field of a TcpState
  85  * structure.
  86  */
  87
  88 #define TCP_NONBLOCKING         (1<<0)  /* Socket with non-blocking I/O */
  89 #define TCP_ASYNC_CONNECT       (1<<1)  /* Async connect in progress. */
  90 #define TCP_ASYNC_PENDING       (1<<4)  /* TcpConnect was called to
  91                                          * process an async connect. This
  92                                          * flag indicates that reentry is
  93                                          * still pending */
  94 #define TCP_ASYNC_FAILED        (1<<5)  /* An async connect finally failed */
  95
  96 /*
  97  * The following defines the maximum length of the listen queue. This is the
  98  * number of outstanding yet-to-be-serviced requests for a connection on a
  99  * server socket, more than this number of outstanding requests and the
 100  * connection request will fail.
 101  */
 102
 103 #ifndef SOMAXCONN
 104 #   define SOMAXCONN    100
 105 #elif (SOMAXCONN < 100)
 106 #   undef  SOMAXCONN
 107 #   define SOMAXCONN    100
 108 #endif /* SOMAXCONN < 100 */
 109
 110 /*
 111  * The following defines how much buffer space the kernel should maintain for
 112  * a socket.
 113  */
 114
 115 #define SOCKET_BUFSIZE  4096
 116
 117 /*
 118  * Static routines for this file:
 119  */
 120
 121 static void             TcpAsyncCallback(ClientData clientData, int mask);
 122 static int              TcpConnect(Tcl_Interp *interp, TcpState *state);
 123 static void             TcpAccept(ClientData data, int mask);
 124 static int              TcpBlockModeProc(ClientData data, int mode);
 125 static int              TcpCloseProc(ClientData instanceData,
 126                             Tcl_Interp *interp);
 127 static int              TcpClose2Proc(ClientData instanceData,
 128                             Tcl_Interp *interp, int flags);
 129 static int              TcpGetHandleProc(ClientData instanceData,
 130                             int direction, ClientData *handlePtr);
 131 static int              TcpGetOptionProc(ClientData instanceData,
 132                             Tcl_Interp *interp, const char *optionName,
 133                             Tcl_DString *dsPtr);
 134 static int              TcpInputProc(ClientData instanceData, char *buf,
 135                             int toRead, int *errorCode);
 136 static int              TcpOutputProc(ClientData instanceData,
 137                             const char *buf, int toWrite, int *errorCode);
 138 static void             TcpThreadActionProc(ClientData instanceData, int action);
 139 static void             TcpWatchProc(ClientData instanceData, int mask);
 140 static int              WaitForConnect(TcpState *statePtr, int *errorCodePtr);
 141 static void             WrapNotify(ClientData clientData, int mask);
 142
 143 /*
 144  * This structure describes the channel type structure for TCP socket
 145  * based IO:
 146  */
 147
 148 static const Tcl_ChannelType tcpChannelType = {
 149     "tcp",                      /* Type name. */
 150     TCL_CHANNEL_VERSION_5,      /* v5 channel */
 151     TcpCloseProc,               /* Close proc. */
 152     TcpInputProc,               /* Input proc. */
 153     TcpOutputProc,              /* Output proc. */
 154     NULL,                       /* Seek proc. */
 155     NULL,                       /* Set option proc. */
 156     TcpGetOptionProc,           /* Get option proc. */
 157     TcpWatchProc,               /* Initialize notifier. */
 158     TcpGetHandleProc,           /* Get OS handles out of channel. */
 159     TcpClose2Proc,              /* Close2 proc. */
 160     TcpBlockModeProc,           /* Set blocking or non-blocking mode.*/
 161     NULL,                       /* flush proc. */
 162     NULL,                       /* handler proc. */
 163     NULL,                       /* wide seek proc. */
 164     TcpThreadActionProc,        /* thread action proc. */
 165     NULL                        /* truncate proc. */
 166 };
 167
 168 /*
 169  * The following variable holds the network name of this host.
 170  */
 171
 172 static TclInitProcessGlobalValueProc InitializeHostName;
 173 static ProcessGlobalValue hostName =
 174         {0, 0, NULL, NULL, InitializeHostName, NULL, NULL};
 175 \f
 176 #if 0
 177 /* printf debugging */
 178 void
 179 printaddrinfo(
 180     struct addrinfo *addrlist,
 181     char *prefix)
 182 {
 183     char host[NI_MAXHOST], port[NI_MAXSERV];
 184     struct addrinfo *ai;
 185
 186     for (ai = addrlist; ai != NULL; ai = ai->ai_next) {
 187         getnameinfo(ai->ai_addr, ai->ai_addrlen,
 188                 host, sizeof(host), port, sizeof(port),
 189                 NI_NUMERICHOST|NI_NUMERICSERV);
 190         fprintf(stderr,"%s: %s:%s\n", prefix, host, port);
 191     }
 192 }
 193 #endif
 194 /*
 195  * ----------------------------------------------------------------------
 196  *
 197  * InitializeHostName --
 198  *
 199  *      This routine sets the process global value of the name of the local
 200  *      host on which the process is running.
 201  *
 202  * Results:
 203  *      None.
 204  *
 205  * ----------------------------------------------------------------------
 206  */
 207
 208 static void
 209 InitializeHostName(
 210     char **valuePtr,
 211     int *lengthPtr,
 212     Tcl_Encoding *encodingPtr)
 213 {
 214     const char *native = NULL;
 215
 216 #ifndef NO_UNAME
 217     struct utsname u;
 218     struct hostent *hp;
 219
 220     memset(&u, (int) 0, sizeof(struct utsname));
 221     if (uname(&u) > -1) {                               /* INTL: Native. */
 222         hp = TclpGetHostByName(u.nodename);             /* INTL: Native. */
 223         if (hp == NULL) {
 224             /*
 225              * Sometimes the nodename is fully qualified, but gets truncated
 226              * as it exceeds SYS_NMLN. See if we can just get the immediate
 227              * nodename and get a proper answer that way.
 228              */
 229
 230             char *dot = strchr(u.nodename, '.');
 231
 232             if (dot != NULL) {
 233                 char *node = (char *)ckalloc(dot - u.nodename + 1);
 234
 235                 memcpy(node, u.nodename, dot - u.nodename);
 236                 node[dot - u.nodename] = '\0';
 237                 hp = TclpGetHostByName(node);
 238                 ckfree(node);
 239             }
 240         }
 241         if (hp != NULL) {
 242             native = hp->h_name;
 243         } else {
 244             native = u.nodename;
 245         }
 246     }
 247     if (native == NULL) {
 248         native = tclEmptyStringRep;
 249     }
 250 #else /* !NO_UNAME */
 251     /*
 252      * Uname doesn't exist; try gethostname instead.
 253      *
 254      * There is no portable macro for the maximum length of host names
 255      * returned by gethostbyname(). We should only trust SYS_NMLN if it is at
 256      * least 255 + 1 bytes to comply with DNS host name limits.
 257      *
 258      * Note: SYS_NMLN is a restriction on "uname" not on gethostbyname!
 259      *
 260      * For example HP-UX 10.20 has SYS_NMLN == 9, while gethostbyname() can
 261      * return a fully qualified name from DNS of up to 255 bytes.
 262      *
 263      * Fix suggested by Viktor Dukhovni (viktor@esm.com)
 264      */
 265
 266 #    if defined(SYS_NMLN) && (SYS_NMLEN >= 256)
 267     char buffer[SYS_NMLEN];
 268 #    else
 269     char buffer[256];
 270 #    endif
 271
 272     if (gethostname(buffer, sizeof(buffer)) > -1) {     /* INTL: Native. */
 273         native = buffer;
 274     }
 275 #endif /* NO_UNAME */
 276
 277     *encodingPtr = Tcl_GetEncoding(NULL, NULL);
 278     *lengthPtr = strlen(native);
 279     *valuePtr = ckalloc(*lengthPtr + 1);
 280     memcpy(*valuePtr, native, *lengthPtr + 1);
 281 }
 282 \f
 283 /*
 284  * ----------------------------------------------------------------------
 285  *
 286  * Tcl_GetHostName --
 287  *
 288  *      Returns the name of the local host.
 289  *
 290  * Results:
 291  *      A string containing the network name for this machine, or an empty
 292  *      string if we can't figure out the name. The caller must not modify or
 293  *      free this string.
 294  *
 295  * Side effects:
 296  *      Caches the name to return for future calls.
 297  *
 298  * ----------------------------------------------------------------------
 299  */
 300
 301 const char *
 302 Tcl_GetHostName(void)
 303 {
 304     return Tcl_GetString(TclGetProcessGlobalValue(&hostName));
 305 }
 306 \f
 307 /*
 308  * ----------------------------------------------------------------------
 309  *
 310  * TclpHasSockets --
 311  *
 312  *      Detect if sockets are available on this platform.
 313  *
 314  * Results:
 315  *      Returns TCL_OK.
 316  *
 317  * Side effects:
 318  *      None.
 319  *
 320  * ----------------------------------------------------------------------
 321  */
 322
 323 int
 324 TclpHasSockets(
 325     Tcl_Interp *dummy)          /* Not used. */
 326 {
 327     (void)dummy;
 328
 329     return TCL_OK;
 330 }
 331 \f
 332 /*
 333  * ----------------------------------------------------------------------
 334  *
 335  * TclpFinalizeSockets --
 336  *
 337  *      Performs per-thread socket subsystem finalization.
 338  *
 339  * Results:
 340  *      None.
 341  *
 342  * Side effects:
 343  *      None.
 344  *
 345  * ----------------------------------------------------------------------
 346  */
 347
 348 void
 349 TclpFinalizeSockets(void)
 350 {
 351     return;
 352 }
 353 \f
 354 /*
 355  * ----------------------------------------------------------------------
 356  *
 357  * TcpBlockModeProc --
 358  *
 359  *      This function is invoked by the generic IO level to set blocking and
 360  *      nonblocking mode on a TCP socket based channel.
 361  *
 362  * Results:
 363  *      0 if successful, errno when failed.
 364  *
 365  * Side effects:
 366  *      Sets the device into blocking or nonblocking mode.
 367  *
 368  * ----------------------------------------------------------------------
 369  */
 370
 371 static int
 372 TcpBlockModeProc(
 373     ClientData instanceData,    /* Socket state. */
 374     int mode)                   /* The mode to set. Can be one of
 375                                  * TCL_MODE_BLOCKING or
 376                                  * TCL_MODE_NONBLOCKING. */
 377 {
 378     TcpState *statePtr = (TcpState *)instanceData;
 379
 380     if (mode == TCL_MODE_BLOCKING) {
 381         CLEAR_BITS(statePtr->flags, TCP_NONBLOCKING);
 382     } else {
 383         SET_BITS(statePtr->flags, TCP_NONBLOCKING);
 384     }
 385     if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 386         statePtr->cachedBlocking = mode;
 387         return 0;
 388     }
 389     if (TclUnixSetBlockingMode(statePtr->fds.fd, mode) < 0) {
 390         return errno;
 391     }
 392     return 0;
 393 }
 394 \f
 395 /*
 396  * ----------------------------------------------------------------------
 397  *
 398  * WaitForConnect --
 399  *
 400  *      Check the state of an async connect process. If a connection attempt
 401  *      terminated, process it, which may finalize it or may start the next
 402  *      attempt. If a connect error occures, it is saved in
 403  *      statePtr->connectError to be reported by 'fconfigure -error'.
 404  *
 405  *      There are two modes of operation, defined by errorCodePtr:
 406  *       *  non-NULL: Called by explicite read/write command. Blocks if the
 407  *          socket is blocking.
 408  *          May return two error codes:
 409  *           *  EWOULDBLOCK: if connect is still in progress
 410  *           *  ENOTCONN: if connect failed. This would be the error message
 411  *              of a rect or sendto syscall so this is emulated here.
 412  *       *  NULL: Called by a backround operation. Do not block and do not
 413  *          return any error code.
 414  *
 415  * Results:
 416  *      0 if the connection has completed, -1 if still in progress or there is
 417  *      an error.
 418  *
 419  * Side effects:
 420  *      Processes socket events off the system queue. May process
 421  *      asynchroneous connects.
 422  *
 423  *----------------------------------------------------------------------
 424  */
 425
 426 static int
 427 WaitForConnect(
 428     TcpState *statePtr,         /* State of the socket. */
 429     int *errorCodePtr)
 430 {
 431     int timeout;
 432
 433     /*
 434      * Check if an async connect failed already and error reporting is
 435      * demanded, return the error ENOTCONN
 436      */
 437
 438     if (errorCodePtr != NULL && GOT_BITS(statePtr->flags, TCP_ASYNC_FAILED)) {
 439         *errorCodePtr = ENOTCONN;
 440         return -1;
 441     }
 442
 443     /*
 444      * Check if an async connect is running. If not return ok
 445      */
 446
 447     if (!GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
 448         return 0;
 449     }
 450
 451     if (errorCodePtr == NULL || GOT_BITS(statePtr->flags, TCP_NONBLOCKING)) {
 452         timeout = 0;
 453     } else {
 454         timeout = -1;
 455     }
 456     do {
 457         if (TclUnixWaitForFile(statePtr->fds.fd,
 458                 TCL_WRITABLE | TCL_EXCEPTION, timeout) != 0) {
 459             TcpConnect(NULL, statePtr);
 460         }
 461
 462         /*
 463          * Do this only once in the nonblocking case and repeat it until the
 464          * socket is final when blocking.
 465          */
 466     } while (timeout == -1 && GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT));
 467
 468     if (errorCodePtr != NULL) {
 469         if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
 470             *errorCodePtr = EAGAIN;
 471             return -1;
 472         } else if (statePtr->connectError != 0) {
 473             *errorCodePtr = ENOTCONN;
 474             return -1;
 475         }
 476     }
 477     return 0;
 478 }
 479 \f
 480 /*
 481  *----------------------------------------------------------------------
 482  *
 483  * TcpInputProc --
 484  *
 485  *      This function is invoked by the generic IO level to read input from a
 486  *      TCP socket based channel.
 487  *
 488  *      NOTE: We cannot share code with FilePipeInputProc because here we must
 489  *      use recv to obtain the input from the channel, not read.
 490  *
 491  * Results:
 492  *      The number of bytes read is returned or -1 on error. An output
 493  *      argument contains the POSIX error code on error, or zero if no error
 494  *      occurred.
 495  *
 496  * Side effects:
 497  *      Reads input from the input device of the channel.
 498  *
 499  *----------------------------------------------------------------------
 500  */
 501
 502 static int
 503 TcpInputProc(
 504     ClientData instanceData,    /* Socket state. */
 505     char *buf,                  /* Where to store data read. */
 506     int bufSize,                /* How much space is available in the
 507                                  * buffer? */
 508     int *errorCodePtr)          /* Where to store error code. */
 509 {
 510     TcpState *statePtr = (TcpState *)instanceData;
 511     int bytesRead;
 512
 513     *errorCodePtr = 0;
 514     if (WaitForConnect(statePtr, errorCodePtr) != 0) {
 515         return -1;
 516     }
 517     bytesRead = recv(statePtr->fds.fd, buf, (size_t) bufSize, 0);
 518     if (bytesRead > -1) {
 519         return bytesRead;
 520     }
 521     if (errno == ECONNRESET) {
 522         /*
 523          * Turn ECONNRESET into a soft EOF condition.
 524          */
 525
 526         return 0;
 527     }
 528     *errorCodePtr = errno;
 529     return -1;
 530 }
 531 \f
 532 /*
 533  *----------------------------------------------------------------------
 534  *
 535  * TcpOutputProc --
 536  *
 537  *      This function is invoked by the generic IO level to write output to a
 538  *      TCP socket based channel.
 539  *
 540  *      NOTE: We cannot share code with FilePipeOutputProc because here we
 541  *      must use send, not write, to get reliable error reporting.
 542  *
 543  * Results:
 544  *      The number of bytes written is returned. An output argument is set to
 545  *      a POSIX error code if an error occurred, or zero.
 546  *
 547  * Side effects:
 548  *      Writes output on the output device of the channel.
 549  *
 550  *----------------------------------------------------------------------
 551  */
 552
 553 static int
 554 TcpOutputProc(
 555     ClientData instanceData,    /* Socket state. */
 556     const char *buf,            /* The data buffer. */
 557     int toWrite,                /* How many bytes to write? */
 558     int *errorCodePtr)          /* Where to store error code. */
 559 {
 560     TcpState *statePtr = (TcpState *)instanceData;
 561     int written;
 562
 563     *errorCodePtr = 0;
 564     if (WaitForConnect(statePtr, errorCodePtr) != 0) {
 565         return -1;
 566     }
 567     written = send(statePtr->fds.fd, buf, (size_t) toWrite, 0);
 568
 569     if (written > -1) {
 570         return written;
 571     }
 572     *errorCodePtr = errno;
 573     return -1;
 574 }
 575 \f
 576 /*
 577  *----------------------------------------------------------------------
 578  *
 579  * TcpCloseProc --
 580  *
 581  *      This function is invoked by the generic IO level to perform
 582  *      channel-type-specific cleanup when a TCP socket based channel is
 583  *      closed.
 584  *
 585  * Results:
 586  *      0 if successful, the value of errno if failed.
 587  *
 588  * Side effects:
 589  *      Closes the socket of the channel.
 590  *
 591  *----------------------------------------------------------------------
 592  */
 593
 594 static int
 595 TcpCloseProc(
 596     ClientData instanceData,    /* The socket to close. */
 597     Tcl_Interp *dummy)          /* For error reporting - unused. */
 598 {
 599     TcpState *statePtr = (TcpState *)instanceData;
 600     int errorCode = 0;
 601     TcpFdList *fds;
 602     (void)dummy;
 603
 604     /*
 605      * Delete a file handler that may be active for this socket if this is a
 606      * server socket - the file handler was created automatically by Tcl as
 607      * part of the mechanism to accept new client connections. Channel
 608      * handlers are already deleted in the generic IO channel closing code
 609      * that called this function, so we do not have to delete them here.
 610      */
 611
 612     for (fds = &statePtr->fds; fds != NULL; fds = fds->next) {
 613         if (fds->fd < 0) {
 614             continue;
 615         }
 616         Tcl_DeleteFileHandler(fds->fd);
 617         if (close(fds->fd) < 0) {
 618             errorCode = errno;
 619         }
 620
 621     }
 622     fds = statePtr->fds.next;
 623     while (fds != NULL) {
 624         TcpFdList *next = fds->next;
 625
 626         ckfree(fds);
 627         fds = next;
 628     }
 629     if (statePtr->addrlist != NULL) {
 630         freeaddrinfo(statePtr->addrlist);
 631     }
 632     if (statePtr->myaddrlist != NULL) {
 633         freeaddrinfo(statePtr->myaddrlist);
 634     }
 635     ckfree(statePtr);
 636     return errorCode;
 637 }
 638 \f
 639 /*
 640  *----------------------------------------------------------------------
 641  *
 642  * TcpClose2Proc --
 643  *
 644  *      This function is called by the generic IO level to perform the channel
 645  *      type specific part of a half-close: namely, a shutdown() on a socket.
 646  *
 647  * Results:
 648  *      0 if successful, the value of errno if failed.
 649  *
 650  * Side effects:
 651  *      Shuts down one side of the socket.
 652  *
 653  *----------------------------------------------------------------------
 654  */
 655
 656 static int
 657 TcpClose2Proc(
 658     ClientData instanceData,    /* The socket to close. */
 659     Tcl_Interp *dummy,          /* For error reporting. */
 660     int flags)                  /* Flags that indicate which side to close. */
 661 {
 662     TcpState *statePtr = (TcpState *)instanceData;
 663     int readError = 0;
 664     int writeError = 0;
 665     (void)dummy;
 666
 667     /*
 668      * Shutdown the OS socket handle.
 669      */
 670     if ((flags & (TCL_CLOSE_READ|TCL_CLOSE_WRITE)) == 0) {
 671         return TcpCloseProc(instanceData, NULL);
 672     }
 673     if ((flags & TCL_CLOSE_READ) && (shutdown(statePtr->fds.fd, SHUT_RD) < 0)) {
 674         readError = errno;
 675     }
 676     if ((flags & TCL_CLOSE_WRITE) && (shutdown(statePtr->fds.fd, SHUT_WR) < 0)) {
 677         writeError = errno;
 678     }
 679     return (readError != 0) ? readError : writeError;
 680 }
 681 \f
 682 /*
 683  *----------------------------------------------------------------------
 684  *
 685  * TcpHostPortList --
 686  *
 687  *      This function is called by the -gethostname and -getpeername switches
 688  *      of TcpGetOptionProc() to add three list elements with the textual
 689  *      representation of the given address to the given DString.
 690  *
 691  * Results:
 692  *      None.
 693  *
 694  * Side effects:
 695  *      Adds three elements do dsPtr
 696  *
 697  *----------------------------------------------------------------------
 698  */
 699
 700 #ifndef NEED_FAKE_RFC2553
 701 #if defined (__clang__) || ((__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
 702 #pragma GCC diagnostic push
 703 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 704 #endif
 705 static inline int
 706 IPv6AddressNeedsNumericRendering(
 707     struct in6_addr addr)
 708 {
 709     if (IN6_ARE_ADDR_EQUAL(&addr, &in6addr_any)) {
 710         return 1;
 711     }
 712
 713     /*
 714      * The IN6_IS_ADDR_V4MAPPED macro has a problem with aliasing warnings on
 715      * at least some versions of OSX.
 716      */
 717
 718     if (!IN6_IS_ADDR_V4MAPPED(&addr)) {
 719         return 0;
 720     }
 721
 722     return (addr.s6_addr[12] == 0 && addr.s6_addr[13] == 0
 723             && addr.s6_addr[14] == 0 && addr.s6_addr[15] == 0);
 724 }
 725 #if defined (__clang__) || ((__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
 726 #pragma GCC diagnostic pop
 727 #endif
 728 #endif /* NEED_FAKE_RFC2553 */
 729
 730 static void
 731 TcpHostPortList(
 732     Tcl_Interp *interp,
 733     Tcl_DString *dsPtr,
 734     address addr,
 735     socklen_t salen)
 736 {
 737 #define SUPPRESS_RDNS_VAR "::tcl::unsupported::noReverseDNS"
 738     char host[NI_MAXHOST], nhost[NI_MAXHOST], nport[NI_MAXSERV];
 739     int flags = 0;
 740
 741     getnameinfo(&addr.sa, salen, nhost, sizeof(nhost), nport, sizeof(nport),
 742             NI_NUMERICHOST | NI_NUMERICSERV);
 743     Tcl_DStringAppendElement(dsPtr, nhost);
 744
 745     /*
 746      * We don't want to resolve INADDR_ANY and sin6addr_any; they can
 747      * sometimes cause problems (and never have a name).
 748      */
 749
 750     if (addr.sa.sa_family == AF_INET) {
 751         if (addr.sa4.sin_addr.s_addr == INADDR_ANY) {
 752             flags |= NI_NUMERICHOST;
 753         }
 754 #ifndef NEED_FAKE_RFC2553
 755     } else if (addr.sa.sa_family == AF_INET6) {
 756         if (IPv6AddressNeedsNumericRendering(addr.sa6.sin6_addr)) {
 757             flags |= NI_NUMERICHOST;
 758         }
 759 #endif /* NEED_FAKE_RFC2553 */
 760     }
 761
 762     /*
 763      * Check if reverse DNS has been switched off globally.
 764      */
 765
 766     if (interp != NULL &&
 767             Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
 768         flags |= NI_NUMERICHOST;
 769     }
 770     if (getnameinfo(&addr.sa, salen, host, sizeof(host), NULL, 0,
 771             flags) == 0) {
 772         /*
 773          * Reverse mapping worked.
 774          */
 775
 776         Tcl_DStringAppendElement(dsPtr, host);
 777     } else {
 778         /*
 779          * Reverse mapping failed - use the numeric rep once more.
 780          */
 781
 782         Tcl_DStringAppendElement(dsPtr, nhost);
 783     }
 784     Tcl_DStringAppendElement(dsPtr, nport);
 785 }
 786 \f
 787 /*
 788  *----------------------------------------------------------------------
 789  *
 790  * TcpGetOptionProc --
 791  *
 792  *      Computes an option value for a TCP socket based channel, or a list of
 793  *      all options and their values.
 794  *
 795  *      Note: This code is based on code contributed by John Haxby.
 796  *
 797  * Results:
 798  *      A standard Tcl result. The value of the specified option or a list of
 799  *      all options and their values is returned in the supplied DString. Sets
 800  *      Error message if needed.
 801  *
 802  * Side effects:
 803  *      None.
 804  *
 805  *----------------------------------------------------------------------
 806  */
 807
 808 static int
 809 TcpGetOptionProc(
 810     ClientData instanceData,    /* Socket state. */
 811     Tcl_Interp *interp,         /* For error reporting - can be NULL. */
 812     const char *optionName,     /* Name of the option to retrieve the value
 813                                  * for, or NULL to get all options and their
 814                                  * values. */
 815     Tcl_DString *dsPtr)         /* Where to store the computed value;
 816                                  * initialized by caller. */
 817 {
 818     TcpState *statePtr = (TcpState *)instanceData;
 819     size_t len = 0;
 820
 821     WaitForConnect(statePtr, NULL);
 822
 823     if (optionName != NULL) {
 824         len = strlen(optionName);
 825     }
 826
 827     if ((len > 1) && (optionName[1] == 'e') &&
 828             (strncmp(optionName, "-error", len) == 0)) {
 829         socklen_t optlen = sizeof(int);
 830
 831         if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 832             /*
 833              * Suppress errors as long as we are not done.
 834              */
 835
 836             errno = 0;
 837         } else if (statePtr->connectError != 0) {
 838             errno = statePtr->connectError;
 839             statePtr->connectError = 0;
 840         } else {
 841             int err;
 842
 843             getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR, (char *) &err,
 844                     &optlen);
 845             errno = err;
 846         }
 847         if (errno != 0) {
 848             Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(errno), -1);
 849         }
 850         return TCL_OK;
 851     }
 852
 853     if ((len > 1) && (optionName[1] == 'c') &&
 854             (strncmp(optionName, "-connecting", len) == 0)) {
 855         Tcl_DStringAppend(dsPtr,
 856                 GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT) ? "1" : "0", -1);
 857         return TCL_OK;
 858     }
 859
 860     if ((len == 0) || ((len > 1) && (optionName[1] == 'p') &&
 861             (strncmp(optionName, "-peername", len) == 0))) {
 862         address peername;
 863         socklen_t size = sizeof(peername);
 864
 865         if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 866             /*
 867              * In async connect output an empty string
 868              */
 869
 870             if (len == 0) {
 871                 Tcl_DStringAppendElement(dsPtr, "-peername");
 872                 Tcl_DStringAppendElement(dsPtr, "");
 873             } else {
 874                 return TCL_OK;
 875             }
 876         } else if (getpeername(statePtr->fds.fd, &peername.sa, &size) >= 0) {
 877             /*
 878              * Peername fetch succeeded - output list
 879              */
 880
 881             if (len == 0) {
 882                 Tcl_DStringAppendElement(dsPtr, "-peername");
 883                 Tcl_DStringStartSublist(dsPtr);
 884             }
 885             TcpHostPortList(interp, dsPtr, peername, size);
 886             if (len) {
 887                 return TCL_OK;
 888             }
 889             Tcl_DStringEndSublist(dsPtr);
 890         } else {
 891             /*
 892              * getpeername failed - but if we were asked for all the options
 893              * (len==0), don't flag an error at that point because it could be
 894              * an fconfigure request on a server socket (which have no peer).
 895              * Same must be done on win&mac.
 896              */
 897
 898             if (len) {
 899                 if (interp) {
 900                     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 901                             "can't get peername: %s",
 902                             Tcl_PosixError(interp)));
 903                 }
 904                 return TCL_ERROR;
 905             }
 906         }
 907     }
 908
 909     if ((len == 0) || ((len > 1) && (optionName[1] == 's') &&
 910             (strncmp(optionName, "-sockname", len) == 0))) {
 911         TcpFdList *fds;
 912         address sockname;
 913         socklen_t size;
 914         int found = 0;
 915
 916         if (len == 0) {
 917             Tcl_DStringAppendElement(dsPtr, "-sockname");
 918             Tcl_DStringStartSublist(dsPtr);
 919         }
 920         if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 921             /*
 922              * In async connect output an empty string
 923              */
 924
 925             found = 1;
 926         } else {
 927             for (fds = &statePtr->fds; fds != NULL; fds = fds->next) {
 928                 size = sizeof(sockname);
 929                 if (getsockname(fds->fd, &(sockname.sa), &size) >= 0) {
 930                     found = 1;
 931                     TcpHostPortList(interp, dsPtr, sockname, size);
 932                 }
 933             }
 934         }
 935         if (found) {
 936             if (len) {
 937                 return TCL_OK;
 938             }
 939             Tcl_DStringEndSublist(dsPtr);
 940         } else {
 941             if (interp) {
 942                 Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 943                         "can't get sockname: %s", Tcl_PosixError(interp)));
 944             }
 945             return TCL_ERROR;
 946         }
 947     }
 948
 949     if (len > 0) {
 950         return Tcl_BadChannelOption(interp, optionName,
 951                 "connecting peername sockname");
 952     }
 953
 954     return TCL_OK;
 955 }
 956 \f
 957 /*
 958  * ----------------------------------------------------------------------
 959  *
 960  * TcpThreadActionProc --
 961  *
 962  *      Handles detach/attach for asynchronously connecting socket.
 963  *
 964  *      Reassigning the file handler associated with thread-related channel
 965  *      notification, responsible for callbacks (signaling that asynchronous
 966  *      connection attempt has succeeded or failed).
 967  *
 968  * Results:
 969  *      None.
 970  *
 971  * ----------------------------------------------------------------------
 972  */
 973
 974 static void
 975 TcpThreadActionProc(
 976     ClientData instanceData,
 977     int action)
 978 {
 979     TcpState *statePtr = (TcpState *)instanceData;
 980
 981     if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 982         /*
 983          * Async-connecting socket must get reassigned handler if it have been
 984          * transferred to another thread. Remove the handler if the socket is
 985          * not managed by this thread anymore and create new handler (TSD related)
 986          * so the callback will run in the correct thread, bug [f583715154].
 987          */
 988         switch (action) {
 989           case TCL_CHANNEL_THREAD_REMOVE:
 990             CLEAR_BITS(statePtr->flags, TCP_ASYNC_PENDING);
 991             Tcl_DeleteFileHandler(statePtr->fds.fd);
 992           break;
 993           case TCL_CHANNEL_THREAD_INSERT:
 994             Tcl_CreateFileHandler(statePtr->fds.fd,
 995                 TCL_WRITABLE | TCL_EXCEPTION, TcpAsyncCallback, statePtr);
 996             SET_BITS(statePtr->flags, TCP_ASYNC_PENDING);
 997           break;
 998         }
 999     }
1000 }
1001 \f
1002 /*
1003  * ----------------------------------------------------------------------
1004  *
1005  * TcpWatchProc --
1006  *
1007  *      Initialize the notifier to watch the fd from this channel.
1008  *
1009  * Results:
1010  *      None.
1011  *
1012  * Side effects:
1013  *      Sets up the notifier so that a future event on the channel will be
1014  *      seen by Tcl.
1015  *
1016  * ----------------------------------------------------------------------
1017  */
1018
1019 static void
1020 WrapNotify(
1021     ClientData clientData,
1022     int mask)
1023 {
1024     TcpState *statePtr = (TcpState *) clientData;
1025     int newmask = mask & statePtr->interest;
1026
1027     if (newmask == 0) {
1028         /*
1029          * There was no overlap between the states the channel is interested
1030          * in notifications for, and the states that are reported present on
1031          * the file descriptor by select().  The only way that can happen is
1032          * when the channel is interested in a writable condition, and only a
1033          * readable state is reported present (see TcpWatchProc() below).  In
1034          * that case, signal back to the caller the writable state, which is
1035          * really an error condition.  As an extra check on that assumption,
1036          * check for a non-zero value of errno before reporting an artificial
1037          * writable state.
1038          */
1039
1040         if (errno == 0) {
1041             return;
1042         }
1043         newmask = TCL_WRITABLE;
1044     }
1045     Tcl_NotifyChannel(statePtr->channel, newmask);
1046 }
1047
1048 static void
1049 TcpWatchProc(
1050     ClientData instanceData,    /* The socket state. */
1051     int mask)                   /* Events of interest; an OR-ed combination of
1052                                  * TCL_READABLE, TCL_WRITABLE and
1053                                  * TCL_EXCEPTION. */
1054 {
1055     TcpState *statePtr = (TcpState *)instanceData;
1056
1057     if (statePtr->acceptProc != NULL) {
1058         /*
1059          * Make sure we don't mess with server sockets since they will never
1060          * be readable or writable at the Tcl level. This keeps Tcl scripts
1061          * from interfering with the -accept behavior (bug #3394732).
1062          */
1063
1064         return;
1065     }
1066
1067     if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
1068         /*
1069          * Async sockets use a FileHandler internally while connecting, so we
1070          * need to cache this request until the connection has succeeded.
1071          */
1072
1073         statePtr->filehandlers = mask;
1074     } else if (mask) {
1075
1076         /*
1077          * Whether it is a bug or feature or otherwise, it is a fact of life
1078          * that on at least some Linux kernels select() fails to report that a
1079          * socket file descriptor is writable when the other end of the socket
1080          * is closed.  This is in contrast to the guarantees Tcl makes that
1081          * its channels become writable and fire writable events on an error
1082          * conditon.  This has caused a leak of file descriptors in a state of
1083          * background flushing.  See Tcl ticket 1758a0b603.
1084          *
1085          * As a workaround, when our caller indicates an interest in writable
1086          * notifications, we must tell the notifier built around select() that
1087          * we are interested in the readable state of the file descriptor as
1088          * well, as that is the only reliable means to get notified of error
1089          * conditions.  Then it is the task of WrapNotify() above to untangle
1090          * the meaning of these channel states and report the chan events as
1091          * best it can.  We save a copy of the mask passed in to assist with
1092          * that.
1093          */
1094
1095         statePtr->interest = mask;
1096         Tcl_CreateFileHandler(statePtr->fds.fd, mask|TCL_READABLE,
1097                 (Tcl_FileProc *) WrapNotify, statePtr);
1098     } else {
1099         Tcl_DeleteFileHandler(statePtr->fds.fd);
1100     }
1101 }
1102 \f
1103 /*
1104  * ----------------------------------------------------------------------
1105  *
1106  * TcpGetHandleProc --
1107  *
1108  *      Called from Tcl_GetChannelHandle to retrieve OS handles from inside a
1109  *      TCP socket based channel.
1110  *
1111  * Results:
1112  *      Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if there is no
1113  *      handle for the specified direction.
1114  *
1115  * Side effects:
1116  *      None.
1117  *
1118  * ----------------------------------------------------------------------
1119  */
1120
1121 static int
1122 TcpGetHandleProc(
1123     ClientData instanceData,    /* The socket state. */
1124     int direction,              /* Not used. */
1125     ClientData *handlePtr)      /* Where to store the handle. */
1126 {
1127     TcpState *statePtr = (TcpState *)instanceData;
1128     (void)direction;
1129
1130     *handlePtr = INT2PTR(statePtr->fds.fd);
1131     return TCL_OK;
1132 }
1133 \f
1134 /*
1135  * ----------------------------------------------------------------------
1136  *
1137  * TcpAsyncCallback --
1138  *
1139  *      Called by the event handler that TcpConnect sets up internally for
1140  *      [socket -async] to get notified when the asynchronous connection
1141  *      attempt has succeeded or failed.
1142  *
1143  * ----------------------------------------------------------------------
1144  */
1145
1146 static void
1147 TcpAsyncCallback(
1148     ClientData clientData,      /* The socket state. */
1149     int mask)                   /* Events of interest; an OR-ed combination of
1150                                  * TCL_READABLE, TCL_WRITABLE and
1151                                  * TCL_EXCEPTION. */
1152 {
1153     (void)mask;
1154
1155     TcpConnect(NULL, (TcpState *)clientData);
1156 }
1157 \f
1158 /*
1159  * ----------------------------------------------------------------------
1160  *
1161  * TcpConnect --
1162  *
1163  *      This function opens a new socket in client mode.
1164  *
1165  * Results:
1166  *      TCL_OK, if the socket was successfully connected or an asynchronous
1167  *      connection is in progress. If an error occurs, TCL_ERROR is returned
1168  *      and an error message is left in interp.
1169  *
1170  * Side effects:
1171  *      Opens a socket.
1172  *
1173  * Remarks:
1174  *      A single host name may resolve to more than one IP address, e.g. for
1175  *      an IPv4/IPv6 dual stack host. For handling asynchronously connecting
1176  *      sockets in the background for such hosts, this function can act as a
1177  *      coroutine. On the first call, it sets up the control variables for the
1178  *      two nested loops over the local and remote addresses. Once the first
1179  *      connection attempt is in progress, it sets up itself as a writable
1180  *      event handler for that socket, and returns. When the callback occurs,
1181  *      control is transferred to the "reenter" label, right after the initial
1182  *      return and the loops resume as if they had never been interrupted.
1183  *      For synchronously connecting sockets, the loops work the usual way.
1184  *
1185  * ----------------------------------------------------------------------
1186  */
1187
1188 static int
1189 TcpConnect(
1190     Tcl_Interp *interp,         /* For error reporting; can be NULL. */
1191     TcpState *statePtr)
1192 {
1193     socklen_t optlen;
1194     int async_callback = GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING);
1195     int ret = -1, error = EHOSTUNREACH;
1196     int async = GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
1197
1198     if (async_callback) {
1199         goto reenter;
1200     }
1201
1202     for (statePtr->addr = statePtr->addrlist; statePtr->addr != NULL;
1203             statePtr->addr = statePtr->addr->ai_next) {
1204         for (statePtr->myaddr = statePtr->myaddrlist;
1205                 statePtr->myaddr != NULL;
1206                 statePtr->myaddr = statePtr->myaddr->ai_next) {
1207             int reuseaddr = 1;
1208
1209             /*
1210              * No need to try combinations of local and remote addresses of
1211              * different families.
1212              */
1213
1214             if (statePtr->myaddr->ai_family != statePtr->addr->ai_family) {
1215                 continue;
1216             }
1217
1218             /*
1219              * Close the socket if it is still open from the last unsuccessful
1220              * iteration.
1221              */
1222
1223             if (statePtr->fds.fd >= 0) {
1224                 close(statePtr->fds.fd);
1225                 statePtr->fds.fd = -1;
1226                 errno = 0;
1227             }
1228
1229             statePtr->fds.fd = socket(statePtr->addr->ai_family, SOCK_STREAM,
1230                     0);
1231             if (statePtr->fds.fd < 0) {
1232                 continue;
1233             }
1234
1235             /*
1236              * Set the close-on-exec flag so that the socket will not get
1237              * inherited by child processes.
1238              */
1239
1240             fcntl(statePtr->fds.fd, F_SETFD, FD_CLOEXEC);
1241
1242             /*
1243              * Set kernel space buffering
1244              */
1245
1246             TclSockMinimumBuffers(INT2PTR(statePtr->fds.fd), SOCKET_BUFSIZE);
1247
1248             if (async) {
1249                 ret = TclUnixSetBlockingMode(statePtr->fds.fd,
1250                         TCL_MODE_NONBLOCKING);
1251                 if (ret < 0) {
1252                     continue;
1253                 }
1254             }
1255
1256             /*
1257              * Must reset the error variable here, before we use it for the
1258              * first time in this iteration.
1259              */
1260
1261             error = 0;
1262
1263             (void) setsockopt(statePtr->fds.fd, SOL_SOCKET, SO_REUSEADDR,
1264                     (char *) &reuseaddr, sizeof(reuseaddr));
1265             ret = bind(statePtr->fds.fd, statePtr->myaddr->ai_addr,
1266                     statePtr->myaddr->ai_addrlen);
1267             if (ret < 0) {
1268                 error = errno;
1269                 continue;
1270             }
1271
1272             /*
1273              * Attempt to connect. The connect may fail at present with an
1274              * EINPROGRESS but at a later time it will complete. The caller
1275              * will set up a file handler on the socket if she is interested
1276              * in being informed when the connect completes.
1277              */
1278
1279             ret = connect(statePtr->fds.fd, statePtr->addr->ai_addr,
1280                         statePtr->addr->ai_addrlen);
1281             if (ret < 0) {
1282                 error = errno;
1283             }
1284             if (ret < 0 && errno == EINPROGRESS) {
1285                 Tcl_CreateFileHandler(statePtr->fds.fd,
1286                         TCL_WRITABLE | TCL_EXCEPTION, TcpAsyncCallback,
1287                         statePtr);
1288                 errno = EWOULDBLOCK;
1289                 SET_BITS(statePtr->flags, TCP_ASYNC_PENDING);
1290                 return TCL_OK;
1291
1292             reenter:
1293                 CLEAR_BITS(statePtr->flags, TCP_ASYNC_PENDING);
1294                 Tcl_DeleteFileHandler(statePtr->fds.fd);
1295
1296                 /*
1297                  * Read the error state from the socket to see if the async
1298                  * connection has succeeded or failed. As this clears the
1299                  * error condition, we cache the status in the socket state
1300                  * struct for later retrieval by [fconfigure -error].
1301                  */
1302
1303                 optlen = sizeof(int);
1304
1305                 getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR,
1306                         (char *) &error, &optlen);
1307                 errno = error;
1308             }
1309             if (error == 0) {
1310                 goto out;
1311             }
1312         }
1313     }
1314
1315   out:
1316     statePtr->connectError = error;
1317     CLEAR_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
1318     if (async_callback) {
1319         /*
1320          * An asynchonous connection has finally succeeded or failed.
1321          */
1322
1323         TcpWatchProc(statePtr, statePtr->filehandlers);
1324         TclUnixSetBlockingMode(statePtr->fds.fd, statePtr->cachedBlocking);
1325
1326         if (error != 0) {
1327             SET_BITS(statePtr->flags, TCP_ASYNC_FAILED);
1328         }
1329
1330         /*
1331          * We need to forward the writable event that brought us here, bcasue
1332          * upon reading of getsockopt(SO_ERROR), at least some OSes clear the
1333          * writable state from the socket, and so a subsequent select() on
1334          * behalf of a script level [fileevent] would not fire. It doesn't
1335          * hurt that this is also called in the successful case and will save
1336          * the event mechanism one roundtrip through select().
1337          */
1338
1339         if (statePtr->cachedBlocking == TCL_MODE_NONBLOCKING) {
1340             Tcl_NotifyChannel(statePtr->channel, TCL_WRITABLE);
1341         }
1342     }
1343     if (error != 0) {
1344         /*
1345          * Failure for either a synchronous connection, or an async one that
1346          * failed before it could enter background mode, e.g. because an
1347          * invalid -myaddr was given.
1348          */
1349
1350         if (interp != NULL) {
1351             errno = error;
1352             Tcl_SetObjResult(interp, Tcl_ObjPrintf(
1353                     "couldn't open socket: %s", Tcl_PosixError(interp)));
1354         }
1355         return TCL_ERROR;
1356     }
1357     return TCL_OK;
1358 }
1359 \f
1360 /*
1361  *----------------------------------------------------------------------
1362  *
1363  * Tcl_OpenTcpClient --
1364  *
1365  *      Opens a TCP client socket and creates a channel around it.
1366  *
1367  * Results:
1368  *      The channel or NULL if failed. An error message is returned in the
1369  *      interpreter on failure.
1370  *
1371  * Side effects:
1372  *      Opens a client socket and creates a new channel.
1373  *
1374  *----------------------------------------------------------------------
1375  */
1376
1377 Tcl_Channel
1378 Tcl_OpenTcpClient(
1379     Tcl_Interp *interp,         /* For error reporting; can be NULL. */
1380     int port,                   /* Port number to open. */
1381     const char *host,           /* Host on which to open port. */
1382     const char *myaddr,         /* Client-side address */
1383     int myport,                 /* Client-side port */
1384     int async)                  /* If nonzero, attempt to do an asynchronous
1385                                  * connect. Otherwise we do a blocking
1386                                  * connect. */
1387 {
1388     TcpState *statePtr;
1389     const char *errorMsg = NULL;
1390     struct addrinfo *addrlist = NULL, *myaddrlist = NULL;
1391     char channelName[SOCK_CHAN_LENGTH];
1392
1393     /*
1394      * Do the name lookups for the local and remote addresses.
1395      */
1396
1397     if (!TclCreateSocketAddress(interp, &addrlist, host, port, 0, &errorMsg)
1398             || !TclCreateSocketAddress(interp, &myaddrlist, myaddr, myport, 1,
1399                     &errorMsg)) {
1400         if (addrlist != NULL) {
1401             freeaddrinfo(addrlist);
1402         }
1403         if (interp != NULL) {
1404             Tcl_SetObjResult(interp, Tcl_ObjPrintf(
1405                     "couldn't open socket: %s", errorMsg));
1406         }
1407         return NULL;
1408     }
1409
1410     /*
1411      * Allocate a new TcpState for this socket.
1412      */
1413
1414     statePtr = (TcpState *)ckalloc(sizeof(TcpState));
1415     memset(statePtr, 0, sizeof(TcpState));
1416     statePtr->flags = async ? TCP_ASYNC_CONNECT : 0;
1417     statePtr->cachedBlocking = TCL_MODE_BLOCKING;
1418     statePtr->addrlist = addrlist;
1419     statePtr->myaddrlist = myaddrlist;
1420     statePtr->fds.fd = -1;
1421
1422     /*
1423      * Create a new client socket and wrap it in a channel.
1424      */
1425
1426     if (TcpConnect(interp, statePtr) != TCL_OK) {
1427         TcpCloseProc(statePtr, NULL);
1428         return NULL;
1429     }
1430
1431     sprintf(channelName, SOCK_TEMPLATE, (long) statePtr);
1432
1433     statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
1434             statePtr, TCL_READABLE | TCL_WRITABLE);
1435     if (Tcl_SetChannelOption(interp, statePtr->channel, "-translation",
1436             "auto crlf") == TCL_ERROR) {
1437         Tcl_Close(NULL, statePtr->channel);
1438         return NULL;
1439     }
1440     return statePtr->channel;
1441 }
1442 \f
1443 /*
1444  *----------------------------------------------------------------------
1445  *
1446  * Tcl_MakeTcpClientChannel --
1447  *
1448  *      Creates a Tcl_Channel from an existing client TCP socket.
1449  *
1450  * Results:
1451  *      The Tcl_Channel wrapped around the preexisting TCP socket.
1452  *
1453  * Side effects:
1454  *      None.
1455  *
1456  *----------------------------------------------------------------------
1457  */
1458
1459 Tcl_Channel
1460 Tcl_MakeTcpClientChannel(
1461     ClientData sock)            /* The socket to wrap up into a channel. */
1462 {
1463     return (Tcl_Channel) TclpMakeTcpClientChannelMode(sock,
1464             TCL_READABLE | TCL_WRITABLE);
1465 }
1466 \f
1467 /*
1468  *----------------------------------------------------------------------
1469  *
1470  * TclpMakeTcpClientChannelMode --
1471  *
1472  *      Creates a Tcl_Channel from an existing client TCP socket
1473  *      with given mode.
1474  *
1475  * Results:
1476  *      The Tcl_Channel wrapped around the preexisting TCP socket.
1477  *
1478  * Side effects:
1479  *      None.
1480  *
1481  *----------------------------------------------------------------------
1482  */
1483
1484 void *
1485 TclpMakeTcpClientChannelMode(
1486     void *sock,         /* The socket to wrap up into a channel. */
1487     int mode)                   /* ORed combination of TCL_READABLE and
1488                                  * TCL_WRITABLE to indicate file mode. */
1489 {
1490     TcpState *statePtr;
1491     char channelName[SOCK_CHAN_LENGTH];
1492
1493     statePtr = (TcpState *)ckalloc(sizeof(TcpState));
1494     memset(statePtr, 0, sizeof(TcpState));
1495     statePtr->fds.fd = PTR2INT(sock);
1496     statePtr->flags = 0;
1497
1498     sprintf(channelName, SOCK_TEMPLATE, (long)statePtr);
1499
1500     statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
1501             statePtr, mode);
1502     if (Tcl_SetChannelOption(NULL, statePtr->channel, "-translation",
1503             "auto crlf") == TCL_ERROR) {
1504         Tcl_Close(NULL, statePtr->channel);
1505         return NULL;
1506     }
1507     return statePtr->channel;
1508 }
1509 \f
1510 /*
1511  *----------------------------------------------------------------------
1512  *
1513  * Tcl_OpenTcpServer --
1514  *
1515  *      Opens a TCP server socket and creates a channel around it.
1516  *
1517  * Results:
1518  *      The channel or NULL if failed. If an error occurred, an error message
1519  *      is left in the interp's result if interp is not NULL.
1520  *
1521  * Side effects:
1522  *      Opens a server socket and creates a new channel.
1523  *
1524  *----------------------------------------------------------------------
1525  */
1526
1527 Tcl_Channel
1528 Tcl_OpenTcpServer(
1529     Tcl_Interp *interp,         /* For error reporting - may be NULL. */
1530     int port,                   /* Port number to open. */
1531     const char *myHost,         /* Name of local host. */
1532     Tcl_TcpAcceptProc *acceptProc,
1533                                 /* Callback for accepting connections from new
1534                                  * clients. */
1535     ClientData acceptProcData)  /* Data for the callback. */
1536 {
1537     int status = 0, sock = -1, reuseaddr = 1, chosenport = 0;
1538     struct addrinfo *addrlist = NULL, *addrPtr; /* socket address */
1539     TcpState *statePtr = NULL;
1540     char channelName[SOCK_CHAN_LENGTH];
1541     const char *errorMsg = NULL;
1542     TcpFdList *fds = NULL, *newfds;
1543
1544     /*
1545      * Try to record and return the most meaningful error message, i.e. the
1546      * one from the first socket that went the farthest before it failed.
1547      */
1548
1549     enum { LOOKUP, SOCKET, BIND, LISTEN } howfar = LOOKUP;
1550     int my_errno = 0;
1551
1552     if (!TclCreateSocketAddress(interp, &addrlist, myHost, port, 1, &errorMsg)) {
1553         my_errno = errno;
1554         goto error;
1555     }
1556
1557     for (addrPtr = addrlist; addrPtr != NULL; addrPtr = addrPtr->ai_next) {
1558         sock = socket(addrPtr->ai_family, addrPtr->ai_socktype,
1559                 addrPtr->ai_protocol);
1560         if (sock == -1) {
1561             if (howfar < SOCKET) {
1562                 howfar = SOCKET;
1563                 my_errno = errno;
1564             }
1565             continue;
1566         }
1567
1568         /*
1569          * Set the close-on-exec flag so that the socket will not get
1570          * inherited by child processes.
1571          */
1572
1573         fcntl(sock, F_SETFD, FD_CLOEXEC);
1574
1575         /*
1576          * Set kernel space buffering
1577          */
1578
1579         TclSockMinimumBuffers(INT2PTR(sock), SOCKET_BUFSIZE);
1580
1581         /*
1582          * Set up to reuse server addresses automatically and bind to the
1583          * specified port.
1584          */
1585
1586         (void) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
1587                 (char *) &reuseaddr, sizeof(reuseaddr));
1588
1589         /*
1590          * Make sure we use the same port number when opening two server
1591          * sockets for IPv4 and IPv6 on a random port.
1592          *
1593          * As sockaddr_in6 uses the same offset and size for the port member
1594          * as sockaddr_in, we can handle both through the IPv4 API.
1595          */
1596
1597         if (port == 0 && chosenport != 0) {
1598             ((struct sockaddr_in *) addrPtr->ai_addr)->sin_port =
1599                     htons(chosenport);
1600         }
1601
1602 #ifdef IPV6_V6ONLY
1603         /*
1604          * Missing on: Solaris 2.8
1605          */
1606
1607         if (addrPtr->ai_family == AF_INET6) {
1608             int v6only = 1;
1609
1610             (void) setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
1611                     &v6only, sizeof(v6only));
1612         }
1613 #endif /* IPV6_V6ONLY */
1614
1615         status = bind(sock, addrPtr->ai_addr, addrPtr->ai_addrlen);
1616         if (status == -1) {
1617             if (howfar < BIND) {
1618                 howfar = BIND;
1619                 my_errno = errno;
1620             }
1621             close(sock);
1622             sock = -1;
1623             continue;
1624         }
1625         if (port == 0 && chosenport == 0) {
1626             address sockname;
1627             socklen_t namelen = sizeof(sockname);
1628
1629             /*
1630              * Synchronize port numbers when binding to port 0 of multiple
1631              * addresses.
1632              */
1633
1634             if (getsockname(sock, &sockname.sa, &namelen) >= 0) {
1635                 chosenport = ntohs(sockname.sa4.sin_port);
1636             }
1637         }
1638         status = listen(sock, SOMAXCONN);
1639         if (status < 0) {
1640             if (howfar < LISTEN) {
1641                 howfar = LISTEN;
1642                 my_errno = errno;
1643             }
1644             close(sock);
1645             sock = -1;
1646             continue;
1647         }
1648         if (statePtr == NULL) {
1649             /*
1650              * Allocate a new TcpState for this socket.
1651              */
1652
1653             statePtr = (TcpState *)ckalloc(sizeof(TcpState));
1654             memset(statePtr, 0, sizeof(TcpState));
1655             statePtr->acceptProc = acceptProc;
1656             statePtr->acceptProcData = acceptProcData;
1657             sprintf(channelName, SOCK_TEMPLATE, (long) statePtr);
1658             newfds = &statePtr->fds;
1659         } else {
1660             newfds = (TcpFdList *)ckalloc(sizeof(TcpFdList));
1661             memset(newfds, (int) 0, sizeof(TcpFdList));
1662             fds->next = newfds;
1663         }
1664         newfds->fd = sock;
1665         newfds->statePtr = statePtr;
1666         fds = newfds;
1667
1668         /*
1669          * Set up the callback mechanism for accepting connections from new
1670          * clients.
1671          */
1672
1673         Tcl_CreateFileHandler(sock, TCL_READABLE, TcpAccept, fds);
1674     }
1675
1676   error:
1677     if (addrlist != NULL) {
1678         freeaddrinfo(addrlist);
1679     }
1680     if (statePtr != NULL) {
1681         statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
1682                 statePtr, 0);
1683         return statePtr->channel;
1684     }
1685     if (interp != NULL) {
1686         Tcl_Obj *errorObj = Tcl_NewStringObj("couldn't open socket: ", -1);
1687
1688         if (errorMsg == NULL) {
1689             errno = my_errno;
1690             Tcl_AppendToObj(errorObj, Tcl_PosixError(interp), -1);
1691         } else {
1692             Tcl_AppendToObj(errorObj, errorMsg, -1);
1693         }
1694         Tcl_SetObjResult(interp, errorObj);
1695     }
1696     if (sock != -1) {
1697         close(sock);
1698     }
1699     return NULL;
1700 }
1701 \f
1702 /*
1703  *----------------------------------------------------------------------
1704  *
1705  * TcpAccept --
1706  *      Accept a TCP socket connection.  This is called by the event loop.
1707  *
1708  * Results:
1709  *      None.
1710  *
1711  * Side effects:
1712  *      Creates a new connection socket. Calls the registered callback for the
1713  *      connection acceptance mechanism.
1714  *
1715  *----------------------------------------------------------------------
1716  */
1717
1718 static void
1719 TcpAccept(
1720     ClientData data,            /* Callback token. */
1721     int mask)                   /* Not used. */
1722 {
1723     TcpFdList *fds = (TcpFdList *)data; /* Client data of server socket. */
1724     int newsock;                /* The new client socket */
1725     TcpState *newSockState;     /* State for new socket. */
1726     address addr;               /* The remote address */
1727     socklen_t len;              /* For accept interface */
1728     char channelName[SOCK_CHAN_LENGTH];
1729     char host[NI_MAXHOST], port[NI_MAXSERV];
1730     (void)mask;
1731
1732     len = sizeof(addr);
1733     newsock = accept(fds->fd, &addr.sa, &len);
1734     if (newsock < 0) {
1735         return;
1736     }
1737
1738     /*
1739      * Set close-on-exec flag to prevent the newly accepted socket from being
1740      * inherited by child processes.
1741      */
1742
1743     (void) fcntl(newsock, F_SETFD, FD_CLOEXEC);
1744
1745     newSockState = (TcpState *)ckalloc(sizeof(TcpState));
1746     memset(newSockState, 0, sizeof(TcpState));
1747     newSockState->flags = 0;
1748     newSockState->fds.fd = newsock;
1749
1750     sprintf(channelName, SOCK_TEMPLATE, (long) newSockState);
1751     newSockState->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
1752             newSockState, TCL_READABLE | TCL_WRITABLE);
1753
1754     Tcl_SetChannelOption(NULL, newSockState->channel, "-translation",
1755             "auto crlf");
1756
1757     if (fds->statePtr->acceptProc != NULL) {
1758         getnameinfo(&addr.sa, len, host, sizeof(host), port, sizeof(port),
1759                 NI_NUMERICHOST|NI_NUMERICSERV);
1760         fds->statePtr->acceptProc(fds->statePtr->acceptProcData,
1761                 newSockState->channel, host, atoi(port));
1762     }
1763 }
1764 \f
1765 /*
1766  * Local Variables:
1767  * mode: c
1768  * c-basic-offset: 4
1769  * fill-column: 78
1770  * tab-width: 8
1771  * indent-tabs-mode: nil
1772  * End:
1773  */