Backport some code cleanup from 8.7/9.0. Fix indenting

1 files changed, 298 insertions, 301 deletions

diff --git a/unix/tclUnixSock.c b/unix/tclUnixSock.c
index 441f75b..3c14984 100644
--- a/unix/tclUnixSock.c
+++ b/unix/tclUnixSock.c
@@ -62,8 +62,7 @@ struct TcpState {
      * Only needed for server sockets
      */
 
-    Tcl_TcpAcceptProc *acceptProc;
-                                /* Proc to call on accept. */
+    Tcl_TcpAcceptProc *acceptProc; /* Proc to call on accept. */
     void *acceptProcData;  /* The data for the accept proc. */
 
     /*
@@ -146,23 +145,23 @@ static Tcl_FileProc	WrapNotify;
  */
 
 static const Tcl_ChannelType tcpChannelType = {
-    "tcp",			/* Type name. */
-    TCL_CHANNEL_VERSION_5,	/* v5 channel */
-    TcpCloseProc,		/* Close proc. */
-    TcpInputProc,		/* Input proc. */
-    TcpOutputProc,		/* Output proc. */
+    "tcp",
+    TCL_CHANNEL_VERSION_5,
+    TcpCloseProc,
+    TcpInputProc,
+    TcpOutputProc,
     NULL,			/* Seek proc. */
     NULL,			/* Set option proc. */
-    TcpGetOptionProc,		/* Get option proc. */
-    TcpWatchProc,		/* Initialize notifier. */
-    TcpGetHandleProc,		/* Get OS handles out of channel. */
-    TcpClose2Proc,		/* Close2 proc. */
-    TcpBlockModeProc,		/* Set blocking or non-blocking mode.*/
-    NULL,			/* flush proc. */
-    NULL,			/* handler proc. */
-    NULL,			/* wide seek proc. */
-    TcpThreadActionProc,	/* thread action proc. */
-    NULL			/* truncate proc. */
+    TcpGetOptionProc,
+    TcpWatchProc,
+    TcpGetHandleProc,
+    TcpClose2Proc,
+    TcpBlockModeProc,
+    NULL,			/* Flush proc. */
+    NULL,			/* Bubbled event handler proc. */
+    NULL,			/* Seek proc. */
+    TcpThreadActionProc,
+    NULL			/* Truncate proc. */
 };
 
 /*
@@ -196,8 +195,8 @@ printaddrinfo(
  *
  * InitializeHostName --
  *
- * 	This routine sets the process global value of the name of the local
- * 	host on which the process is running.
+ *	This routine sets the process global value of the name of the local
+ *	host on which the process is running.
  *
  * Results:
  *	None.
@@ -219,7 +218,7 @@ InitializeHostName(
 
     memset(&u, (int) 0, sizeof(struct utsname));
     if (uname(&u) >= 0) {				/* INTL: Native. */
-        hp = TclpGetHostByName(u.nodename);		/* INTL: Native. */
+	hp = TclpGetHostByName(u.nodename);		/* INTL: Native. */
 	if (hp == NULL) {
 	    /*
 	     * Sometimes the nodename is fully qualified, but gets truncated
@@ -238,11 +237,11 @@ InitializeHostName(
 		ckfree(node);
 	    }
 	}
-        if (hp != NULL) {
+	if (hp != NULL) {
 	    native = hp->h_name;
-        } else {
+	} else {
 	    native = u.nodename;
-        }
+	}
     }
     if (native == NULL) {
 	native = tclEmptyStringRep;
@@ -383,8 +382,8 @@ TcpBlockModeProc(
 	SET_BITS(statePtr->flags, TCP_NONBLOCKING);
     }
     if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
-        statePtr->cachedBlocking = mode;
-        return 0;
+	statePtr->cachedBlocking = mode;
+	return 0;
     }
     if (TclUnixSetBlockingMode(statePtr->fds.fd, mode) < 0) {
 	return errno;
@@ -413,8 +412,8 @@ TcpBlockModeProc(
  *	    return any error code.
  *
  * Results:
- * 	0 if the connection has completed, -1 if still in progress or there is
- * 	an error.
+ *	0 if the connection has completed, -1 if still in progress or there is
+ *	an error.
  *
  * Side effects:
  *	Processes socket events off the system queue. May process
@@ -449,30 +448,30 @@ WaitForConnect(
     }
 
     if (errorCodePtr == NULL || GOT_BITS(statePtr->flags, TCP_NONBLOCKING)) {
-        timeout = 0;
+	timeout = 0;
     } else {
-        timeout = -1;
+	timeout = -1;
     }
     do {
-        if (TclUnixWaitForFile(statePtr->fds.fd,
-                TCL_WRITABLE | TCL_EXCEPTION, timeout) != 0) {
-            TcpConnect(NULL, statePtr);
-        }
-
-        /*
-         * Do this only once in the nonblocking case and repeat it until the
-         * socket is final when blocking.
-         */
+	if (TclUnixWaitForFile(statePtr->fds.fd,
+		TCL_WRITABLE | TCL_EXCEPTION, timeout) != 0) {
+	    TcpConnect(NULL, statePtr);
+	}
+
+	/*
+	 * Do this only once in the nonblocking case and repeat it until the
+	 * socket is final when blocking.
+	 */
     } while (timeout == -1 && GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT));
 
     if (errorCodePtr != NULL) {
-        if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
-            *errorCodePtr = EAGAIN;
-            return -1;
-        } else if (statePtr->connectError != 0) {
-            *errorCodePtr = ENOTCONN;
-            return -1;
-        }
+	if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
+	    *errorCodePtr = EAGAIN;
+	    return -1;
+	} else if (statePtr->connectError != 0) {
+	    *errorCodePtr = ENOTCONN;
+	    return -1;
+	}
     }
     return 0;
 }
@@ -627,10 +626,10 @@ TcpCloseProc(
 	fds = next;
     }
     if (statePtr->addrlist != NULL) {
-        freeaddrinfo(statePtr->addrlist);
+	freeaddrinfo(statePtr->addrlist);
     }
     if (statePtr->myaddrlist != NULL) {
-        freeaddrinfo(statePtr->myaddrlist);
+	freeaddrinfo(statePtr->myaddrlist);
     }
     ckfree(statePtr);
     return errorCode;
@@ -707,7 +706,7 @@ IPv6AddressNeedsNumericRendering(
     struct in6_addr addr)
 {
     if (IN6_ARE_ADDR_EQUAL(&addr, &in6addr_any)) {
-        return 1;
+	return 1;
     }
 
     /*
@@ -716,11 +715,11 @@ IPv6AddressNeedsNumericRendering(
      */
 
     if (!IN6_IS_ADDR_V4MAPPED(&addr)) {
-        return 0;
+	return 0;
     }
 
     return (addr.s6_addr[12] == 0 && addr.s6_addr[13] == 0
-            && addr.s6_addr[14] == 0 && addr.s6_addr[15] == 0);
+	    && addr.s6_addr[14] == 0 && addr.s6_addr[15] == 0);
 }
 #if defined (__clang__) || ((__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
 #pragma GCC diagnostic pop
@@ -739,7 +738,7 @@ TcpHostPortList(
     int flags = 0;
 
     getnameinfo(&addr.sa, salen, nhost, sizeof(nhost), nport, sizeof(nport),
-            NI_NUMERICHOST | NI_NUMERICSERV);
+	    NI_NUMERICHOST | NI_NUMERICSERV);
     Tcl_DStringAppendElement(dsPtr, nhost);
 
     /*
@@ -748,14 +747,14 @@ TcpHostPortList(
      */
 
     if (addr.sa.sa_family == AF_INET) {
-        if (addr.sa4.sin_addr.s_addr == INADDR_ANY) {
-            flags |= NI_NUMERICHOST;
-        }
+	if (addr.sa4.sin_addr.s_addr == INADDR_ANY) {
+	    flags |= NI_NUMERICHOST;
+	}
 #ifndef NEED_FAKE_RFC2553
     } else if (addr.sa.sa_family == AF_INET6) {
-        if (IPv6AddressNeedsNumericRendering(addr.sa6.sin6_addr)) {
-            flags |= NI_NUMERICHOST;
-        }
+	if (IPv6AddressNeedsNumericRendering(addr.sa6.sin6_addr)) {
+	    flags |= NI_NUMERICHOST;
+	}
 #endif /* NEED_FAKE_RFC2553 */
     }
 
@@ -764,22 +763,22 @@ TcpHostPortList(
      */
 
     if (interp != NULL &&
-            Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
-        flags |= NI_NUMERICHOST;
+	    Tcl_GetVar2(interp, SUPPRESS_RDNS_VAR, NULL, 0) != NULL) {
+	flags |= NI_NUMERICHOST;
     }
     if (getnameinfo(&addr.sa, salen, host, sizeof(host), NULL, 0,
-            flags) == 0) {
-        /*
-         * Reverse mapping worked.
-         */
+	    flags) == 0) {
+	/*
+	 * Reverse mapping worked.
+	 */
 
-        Tcl_DStringAppendElement(dsPtr, host);
+	Tcl_DStringAppendElement(dsPtr, host);
     } else {
-        /*
-         * Reverse mapping failed - use the numeric rep once more.
-         */
+	/*
+	 * Reverse mapping failed - use the numeric rep once more.
+	 */
 
-        Tcl_DStringAppendElement(dsPtr, nhost);
+	Tcl_DStringAppendElement(dsPtr, nhost);
     }
     Tcl_DStringAppendElement(dsPtr, nport);
 }
@@ -828,25 +827,25 @@ TcpGetOptionProc(
 	    (strncmp(optionName, "-error", len) == 0)) {
 	socklen_t optlen = sizeof(int);
 
-        if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
-            /*
-             * Suppress errors as long as we are not done.
-             */
-
-            errno = 0;
-        } else if (statePtr->connectError != 0) {
-            errno = statePtr->connectError;
-            statePtr->connectError = 0;
-        } else {
-            int err;
-
-            getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR, (char *) &err,
-                    &optlen);
-            errno = err;
-        }
-        if (errno != 0) {
+	if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
+	    /*
+	     * Suppress errors as long as we are not done.
+	     */
+
+	    errno = 0;
+	} else if (statePtr->connectError != 0) {
+	    errno = statePtr->connectError;
+	    statePtr->connectError = 0;
+	} else {
+	    int err;
+
+	    getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR, (char *) &err,
+		    &optlen);
+	    errno = err;
+	}
+	if (errno != 0) {
 	    Tcl_DStringAppend(dsPtr, Tcl_ErrnoMsg(errno), -1);
-        }
+	}
 	return TCL_OK;
     }
 
@@ -854,13 +853,13 @@ TcpGetOptionProc(
 	    (strncmp(optionName, "-connecting", len) == 0)) {
 	Tcl_DStringAppend(dsPtr,
 		GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT) ? "1" : "0", -1);
-        return TCL_OK;
+	return TCL_OK;
     }
 
     if ((len == 0) || ((len > 1) && (optionName[1] == 'p') &&
 	    (strncmp(optionName, "-peername", len) == 0))) {
-        address peername;
-        socklen_t size = sizeof(peername);
+	address peername;
+	socklen_t size = sizeof(peername);
 
 	if (GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT)) {
 	    /*
@@ -882,11 +881,11 @@ TcpGetOptionProc(
 		Tcl_DStringAppendElement(dsPtr, "-peername");
 		Tcl_DStringStartSublist(dsPtr);
 	    }
-            TcpHostPortList(interp, dsPtr, peername, size);
+	    TcpHostPortList(interp, dsPtr, peername, size);
 	    if (len) {
-                return TCL_OK;
-            }
-            Tcl_DStringEndSublist(dsPtr);
+		return TCL_OK;
+	    }
+	    Tcl_DStringEndSublist(dsPtr);
 	} else {
 	    /*
 	     * getpeername failed - but if we were asked for all the options
@@ -898,7 +897,7 @@ TcpGetOptionProc(
 	    if (len) {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                            "can't get peername: %s",
+			    "can't get peername: %s",
 			    Tcl_PosixError(interp)));
 		}
 		return TCL_ERROR;
@@ -922,7 +921,7 @@ TcpGetOptionProc(
 	     * In async connect output an empty string
 	     */
 
-            found = 1;
+	    found = 1;
 	} else {
 	    for (fds = &statePtr->fds; fds != NULL; fds = fds->next) {
 		size = sizeof(sockname);
@@ -932,23 +931,23 @@ TcpGetOptionProc(
 		}
 	    }
 	}
-        if (found) {
-            if (len) {
-                return TCL_OK;
-            }
-            Tcl_DStringEndSublist(dsPtr);
-        } else {
-            if (interp) {
-                Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                        "can't get sockname: %s", Tcl_PosixError(interp)));
-            }
+	if (found) {
+	    if (len) {
+		return TCL_OK;
+	    }
+	    Tcl_DStringEndSublist(dsPtr);
+	} else {
+	    if (interp) {
+		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+			"can't get sockname: %s", Tcl_PosixError(interp)));
+	    }
 	    return TCL_ERROR;
 	}
     }
 
     if (len > 0) {
 	return Tcl_BadChannelOption(interp, optionName,
-                "connecting peername sockname");
+		"connecting peername sockname");
     }
 
     return TCL_OK;
@@ -1055,22 +1054,22 @@ TcpWatchProc(
     TcpState *statePtr = (TcpState *)instanceData;
 
     if (statePtr->acceptProc != NULL) {
-        /*
-         * Make sure we don't mess with server sockets since they will never
-         * be readable or writable at the Tcl level. This keeps Tcl scripts
-         * from interfering with the -accept behavior (bug #3394732).
-         */
+	/*
+	 * Make sure we don't mess with server sockets since they will never
+	 * be readable or writable at the Tcl level. This keeps Tcl scripts
+	 * from interfering with the -accept behavior (bug #3394732).
+	 */
 
-    	return;
+	return;
     }
 
     if (GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING)) {
-        /*
-         * Async sockets use a FileHandler internally while connecting, so we
-         * need to cache this request until the connection has succeeded.
-         */
+	/*
+	 * Async sockets use a FileHandler internally while connecting, so we
+	 * need to cache this request until the connection has succeeded.
+	 */
 
-        statePtr->filehandlers = mask;
+	statePtr->filehandlers = mask;
     } else if (mask) {
 
 	/*
@@ -1194,18 +1193,17 @@ TcpConnect(
     int async_callback = GOT_BITS(statePtr->flags, TCP_ASYNC_PENDING);
     int ret = -1, error = EHOSTUNREACH;
     int async = GOT_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
+    static const int reuseaddr = 1;
 
     if (async_callback) {
-        goto reenter;
+	goto reenter;
     }
 
     for (statePtr->addr = statePtr->addrlist; statePtr->addr != NULL;
-            statePtr->addr = statePtr->addr->ai_next) {
-        for (statePtr->myaddr = statePtr->myaddrlist;
-                statePtr->myaddr != NULL;
-                statePtr->myaddr = statePtr->myaddr->ai_next) {
-            int reuseaddr = 1;
-
+	    statePtr->addr = statePtr->addr->ai_next) {
+	for (statePtr->myaddr = statePtr->myaddrlist;
+		statePtr->myaddr != NULL;
+		statePtr->myaddr = statePtr->myaddr->ai_next) {
 	    /*
 	     * No need to try combinations of local and remote addresses of
 	     * different families.
@@ -1215,19 +1213,19 @@ TcpConnect(
 		continue;
 	    }
 
-            /*
-             * Close the socket if it is still open from the last unsuccessful
-             * iteration.
-             */
+	    /*
+	     * Close the socket if it is still open from the last unsuccessful
+	     * iteration.
+	     */
 
-            if (statePtr->fds.fd >= 0) {
+	    if (statePtr->fds.fd >= 0) {
 		close(statePtr->fds.fd);
 		statePtr->fds.fd = -1;
-                errno = 0;
+		errno = 0;
 	    }
 
 	    statePtr->fds.fd = socket(statePtr->addr->ai_family, SOCK_STREAM,
-                    0);
+		    0);
 	    if (statePtr->fds.fd < 0) {
 		continue;
 	    }
@@ -1246,28 +1244,28 @@ TcpConnect(
 	    TclSockMinimumBuffers(INT2PTR(statePtr->fds.fd), SOCKET_BUFSIZE);
 
 	    if (async) {
-                ret = TclUnixSetBlockingMode(statePtr->fds.fd,
-                        TCL_MODE_NONBLOCKING);
-                if (ret < 0) {
-                    continue;
-                }
-            }
-
-            /*
-             * Must reset the error variable here, before we use it for the
-             * first time in this iteration.
-             */
-
-            error = 0;
-
-            (void) setsockopt(statePtr->fds.fd, SOL_SOCKET, SO_REUSEADDR,
-                    (char *) &reuseaddr, sizeof(reuseaddr));
-            ret = bind(statePtr->fds.fd, statePtr->myaddr->ai_addr,
-                    statePtr->myaddr->ai_addrlen);
-            if (ret < 0) {
-                error = errno;
-                continue;
-            }
+		ret = TclUnixSetBlockingMode(statePtr->fds.fd,
+			TCL_MODE_NONBLOCKING);
+		if (ret < 0) {
+		    continue;
+		}
+	    }
+
+	    /*
+	     * Must reset the error variable here, before we use it for the
+	     * first time in this iteration.
+	     */
+
+	    error = 0;
+
+	    (void) setsockopt(statePtr->fds.fd, SOL_SOCKET, SO_REUSEADDR,
+		    (char *) &reuseaddr, sizeof(reuseaddr));
+	    ret = bind(statePtr->fds.fd, statePtr->myaddr->ai_addr,
+		    statePtr->myaddr->ai_addrlen);
+	    if (ret < 0) {
+		error = errno;
+		continue;
+	    }
 
 	    /*
 	     * Attempt to connect. The connect may fail at present with an
@@ -1277,35 +1275,35 @@ TcpConnect(
 	     */
 
 	    ret = connect(statePtr->fds.fd, statePtr->addr->ai_addr,
-                        statePtr->addr->ai_addrlen);
-            if (ret < 0) {
-                error = errno;
-            }
+			statePtr->addr->ai_addrlen);
+	    if (ret < 0) {
+		error = errno;
+	    }
 	    if (ret < 0 && errno == EINPROGRESS) {
-                Tcl_CreateFileHandler(statePtr->fds.fd,
-                        TCL_WRITABLE | TCL_EXCEPTION, TcpAsyncCallback,
-                        statePtr);
-                errno = EWOULDBLOCK;
-                SET_BITS(statePtr->flags, TCP_ASYNC_PENDING);
-                return TCL_OK;
-
-            reenter:
-                CLEAR_BITS(statePtr->flags, TCP_ASYNC_PENDING);
-                Tcl_DeleteFileHandler(statePtr->fds.fd);
-
-                /*
-                 * Read the error state from the socket to see if the async
-                 * connection has succeeded or failed. As this clears the
-                 * error condition, we cache the status in the socket state
-                 * struct for later retrieval by [fconfigure -error].
-                 */
-
-                optlen = sizeof(int);
-
-                getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR,
-                        (char *) &error, &optlen);
-                errno = error;
-            }
+		Tcl_CreateFileHandler(statePtr->fds.fd,
+			TCL_WRITABLE | TCL_EXCEPTION, TcpAsyncCallback,
+			statePtr);
+		errno = EWOULDBLOCK;
+		SET_BITS(statePtr->flags, TCP_ASYNC_PENDING);
+		return TCL_OK;
+
+	    reenter:
+		CLEAR_BITS(statePtr->flags, TCP_ASYNC_PENDING);
+		Tcl_DeleteFileHandler(statePtr->fds.fd);
+
+		/*
+		 * Read the error state from the socket to see if the async
+		 * connection has succeeded or failed. As this clears the
+		 * error condition, we cache the status in the socket state
+		 * struct for later retrieval by [fconfigure -error].
+		 */
+
+		optlen = sizeof(int);
+
+		getsockopt(statePtr->fds.fd, SOL_SOCKET, SO_ERROR,
+			(char *) &error, &optlen);
+		errno = error;
+	    }
 	    if (error == 0) {
 		goto out;
 	    }
@@ -1316,43 +1314,43 @@ TcpConnect(
     statePtr->connectError = error;
     CLEAR_BITS(statePtr->flags, TCP_ASYNC_CONNECT);
     if (async_callback) {
-        /*
-         * An asynchonous connection has finally succeeded or failed.
-         */
-
-        TcpWatchProc(statePtr, statePtr->filehandlers);
-        TclUnixSetBlockingMode(statePtr->fds.fd, statePtr->cachedBlocking);
-
-        if (error != 0) {
-            SET_BITS(statePtr->flags, TCP_ASYNC_FAILED);
-        }
-
-        /*
-         * We need to forward the writable event that brought us here, because
-         * upon reading of getsockopt(SO_ERROR), at least some OSes clear the
-         * writable state from the socket, and so a subsequent select() on
-         * behalf of a script level [fileevent] would not fire. It doesn't
-         * hurt that this is also called in the successful case and will save
-         * the event mechanism one roundtrip through select().
-         */
+	/*
+	 * An asynchonous connection has finally succeeded or failed.
+	 */
+
+	TcpWatchProc(statePtr, statePtr->filehandlers);
+	TclUnixSetBlockingMode(statePtr->fds.fd, statePtr->cachedBlocking);
+
+	if (error != 0) {
+	    SET_BITS(statePtr->flags, TCP_ASYNC_FAILED);
+	}
+
+	/*
+	 * We need to forward the writable event that brought us here, because
+	 * upon reading of getsockopt(SO_ERROR), at least some OSes clear the
+	 * writable state from the socket, and so a subsequent select() on
+	 * behalf of a script level [fileevent] would not fire. It doesn't
+	 * hurt that this is also called in the successful case and will save
+	 * the event mechanism one roundtrip through select().
+	 */
 
 	if (statePtr->cachedBlocking == TCL_MODE_NONBLOCKING) {
 	    Tcl_NotifyChannel(statePtr->channel, TCL_WRITABLE);
 	}
     }
     if (error != 0) {
-        /*
-         * Failure for either a synchronous connection, or an async one that
-         * failed before it could enter background mode, e.g. because an
-         * invalid -myaddr was given.
-         */
-
-        if (interp != NULL) {
-            errno = error;
-            Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                    "couldn't open socket: %s", Tcl_PosixError(interp)));
-        }
-        return TCL_ERROR;
+	/*
+	 * Failure for either a synchronous connection, or an async one that
+	 * failed before it could enter background mode, e.g. because an
+	 * invalid -myaddr was given.
+	 */
+
+	if (interp != NULL) {
+	    errno = error;
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		    "couldn't open socket: %s", Tcl_PosixError(interp)));
+	}
+	return TCL_ERROR;
     }
     return TCL_OK;
 }
@@ -1395,16 +1393,16 @@ Tcl_OpenTcpClient(
      */
 
     if (!TclCreateSocketAddress(interp, &addrlist, host, port, 0, &errorMsg)
-            || !TclCreateSocketAddress(interp, &myaddrlist, myaddr, myport, 1,
-                    &errorMsg)) {
-        if (addrlist != NULL) {
-            freeaddrinfo(addrlist);
-        }
-        if (interp != NULL) {
-            Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-                    "couldn't open socket: %s", errorMsg));
-        }
-        return NULL;
+	    || !TclCreateSocketAddress(interp, &myaddrlist, myaddr, myport, 1,
+		    &errorMsg)) {
+	if (addrlist != NULL) {
+	    freeaddrinfo(addrlist);
+	}
+	if (interp != NULL) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		    "couldn't open socket: %s", errorMsg));
+	}
+	return NULL;
     }
 
     /*
@@ -1424,14 +1422,14 @@ Tcl_OpenTcpClient(
      */
 
     if (TcpConnect(interp, statePtr) != TCL_OK) {
-        TcpCloseProc(statePtr, NULL);
-        return NULL;
+	TcpCloseProc(statePtr, NULL);
+	return NULL;
     }
 
     snprintf(channelName, sizeof(channelName), SOCK_TEMPLATE, (long)statePtr);
 
     statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName,
-            statePtr, TCL_READABLE | TCL_WRITABLE);
+	    statePtr, TCL_READABLE | TCL_WRITABLE);
     if (Tcl_SetChannelOption(interp, statePtr->channel, "-translation",
 	    "auto crlf") == TCL_ERROR) {
 	Tcl_Close(NULL, statePtr->channel);
@@ -1461,7 +1459,7 @@ Tcl_MakeTcpClientChannel(
     void *sock)		/* The socket to wrap up into a channel. */
 {
     return (Tcl_Channel) TclpMakeTcpClientChannelMode(sock,
-            TCL_READABLE | TCL_WRITABLE);
+	    TCL_READABLE | TCL_WRITABLE);
 }
 
 /*
@@ -1556,7 +1554,7 @@ Tcl_OpenTcpServer(
 
     for (addrPtr = addrlist; addrPtr != NULL; addrPtr = addrPtr->ai_next) {
 	sock = socket(addrPtr->ai_family, addrPtr->ai_socktype,
-                addrPtr->ai_protocol);
+		addrPtr->ai_protocol);
 	if (sock == -1) {
 	    if (howfar < SOCKET) {
 		howfar = SOCKET;
@@ -1579,98 +1577,97 @@ Tcl_OpenTcpServer(
 	TclSockMinimumBuffers(INT2PTR(sock), SOCKET_BUFSIZE);
 
 	/*
-	 * Set up to reuse server addresses automatically and bind to the
-	 * specified port.
+	 * Set up to reuse server addresses and/or ports if requested.
 	 */
 
 	(void) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 		(char *) &reuseaddr, sizeof(reuseaddr));
 
-        /*
-         * Make sure we use the same port number when opening two server
-         * sockets for IPv4 and IPv6 on a random port.
-         *
-         * As sockaddr_in6 uses the same offset and size for the port member
-         * as sockaddr_in, we can handle both through the IPv4 API.
-         */
+	/*
+	 * Make sure we use the same port number when opening two server
+	 * sockets for IPv4 and IPv6 on a random port.
+	 *
+	 * As sockaddr_in6 uses the same offset and size for the port member
+	 * as sockaddr_in, we can handle both through the IPv4 API.
+	 */
 
 	if (port == 0 && chosenport != 0) {
 	    ((struct sockaddr_in *) addrPtr->ai_addr)->sin_port =
-                    htons(chosenport);
+		    htons(chosenport);
 	}
 
 #ifdef IPV6_V6ONLY
 	/*
-         * Missing on: Solaris 2.8
-         */
+	 * Missing on: Solaris 2.8
+	 */
 
-        if (addrPtr->ai_family == AF_INET6) {
-            int v6only = 1;
+	if (addrPtr->ai_family == AF_INET6) {
+	    int v6only = 1;
 
-            (void) setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
-                    &v6only, sizeof(v6only));
-        }
+	    (void) setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
+		    &v6only, sizeof(v6only));
+	}
 #endif /* IPV6_V6ONLY */
 
 	status = bind(sock, addrPtr->ai_addr, addrPtr->ai_addrlen);
-        if (status == -1) {
+	if (status == -1) {
 	    if (howfar < BIND) {
 		howfar = BIND;
 		my_errno = errno;
 	    }
-            close(sock);
-            sock = -1;
-            continue;
-        }
-        if (port == 0 && chosenport == 0) {
-            address sockname;
-            socklen_t namelen = sizeof(sockname);
-
-            /*
-             * Synchronize port numbers when binding to port 0 of multiple
-             * addresses.
-             */
-
-            if (getsockname(sock, &sockname.sa, &namelen) >= 0) {
-                chosenport = ntohs(sockname.sa4.sin_port);
-            }
-        }
-        status = listen(sock, SOMAXCONN);
-        if (status < 0) {
+	    close(sock);
+	    sock = -1;
+	    continue;
+	}
+	if (port == 0 && chosenport == 0) {
+	    address sockname;
+	    socklen_t namelen = sizeof(sockname);
+
+	    /*
+	     * Synchronize port numbers when binding to port 0 of multiple
+	     * addresses.
+	     */
+
+	    if (getsockname(sock, &sockname.sa, &namelen) >= 0) {
+		chosenport = ntohs(sockname.sa4.sin_port);
+	    }
+	}
+	status = listen(sock, SOMAXCONN);
+	if (status < 0) {
 	    if (howfar < LISTEN) {
 		howfar = LISTEN;
 		my_errno = errno;
 	    }
-            close(sock);
-            sock = -1;
-            continue;
-        }
-        if (statePtr == NULL) {
-            /*
-             * Allocate a new TcpState for this socket.
-             */
-
-            statePtr = (TcpState *)ckalloc(sizeof(TcpState));
-            memset(statePtr, 0, sizeof(TcpState));
-            statePtr->acceptProc = acceptProc;
-            statePtr->acceptProcData = acceptProcData;
-            snprintf(channelName, sizeof(channelName), SOCK_TEMPLATE, (long) statePtr);
-            newfds = &statePtr->fds;
-        } else {
-            newfds = (TcpFdList *)ckalloc(sizeof(TcpFdList));
-            memset(newfds, (int) 0, sizeof(TcpFdList));
-            fds->next = newfds;
-        }
-        newfds->fd = sock;
-        newfds->statePtr = statePtr;
-        fds = newfds;
-
-        /*
-         * Set up the callback mechanism for accepting connections from new
-         * clients.
-         */
-
-        Tcl_CreateFileHandler(sock, TCL_READABLE, TcpAccept, fds);
+	    close(sock);
+	    sock = -1;
+	    continue;
+	}
+	if (statePtr == NULL) {
+	    /*
+	     * Allocate a new TcpState for this socket.
+	     */
+
+	    statePtr = (TcpState *)ckalloc(sizeof(TcpState));
+	    memset(statePtr, 0, sizeof(TcpState));
+	    statePtr->acceptProc = acceptProc;
+	    statePtr->acceptProcData = acceptProcData;
+	    snprintf(channelName, sizeof(channelName), SOCK_TEMPLATE, (long)statePtr);
+	    newfds = &statePtr->fds;
+	} else {
+	    newfds = (TcpFdList *)ckalloc(sizeof(TcpFdList));
+	    memset(newfds, (int) 0, sizeof(TcpFdList));
+	    fds->next = newfds;
+	}
+	newfds->fd = sock;
+	newfds->statePtr = statePtr;
+	fds = newfds;
+
+	/*
+	 * Set up the callback mechanism for accepting connections from new
+	 * clients.
+	 */
+
+	Tcl_CreateFileHandler(sock, TCL_READABLE, TcpAccept, fds);
     }
 
   error:
@@ -1683,15 +1680,15 @@ Tcl_OpenTcpServer(
 	return statePtr->channel;
     }
     if (interp != NULL) {
-        Tcl_Obj *errorObj = Tcl_NewStringObj("couldn't open socket: ", -1);
+	Tcl_Obj *errorObj = Tcl_NewStringObj("couldn't open socket: ", -1);
 
 	if (errorMsg == NULL) {
-            errno = my_errno;
-            Tcl_AppendToObj(errorObj, Tcl_PosixError(interp), -1);
-        } else {
+	    errno = my_errno;
+	    Tcl_AppendToObj(errorObj, Tcl_PosixError(interp), -1);
+	} else {
 	    Tcl_AppendToObj(errorObj, errorMsg, -1);
 	}
-        Tcl_SetObjResult(interp, errorObj);
+	Tcl_SetObjResult(interp, errorObj);
     }
     if (sock != -1) {
 	close(sock);
@@ -1756,9 +1753,9 @@ TcpAccept(
 
     if (fds->statePtr->acceptProc != NULL) {
 	getnameinfo(&addr.sa, len, host, sizeof(host), port, sizeof(port),
-                NI_NUMERICHOST|NI_NUMERICSERV);
+		NI_NUMERICHOST|NI_NUMERICSERV);
 	fds->statePtr->acceptProc(fds->statePtr->acceptProcData,
-                newSockState->channel, host, atoi(port));
+		newSockState->channel, host, atoi(port));
     }
 }