Getting more systematic about style

1 files changed, 688 insertions, 703 deletions

diff --git a/win/tclWinSock.c b/win/tclWinSock.c
index 8af394b..10c24bd 100644
--- a/win/tclWinSock.c
+++ b/win/tclWinSock.c
@@ -1,22 +1,23 @@
-/* 
+/*
  * tclWinSock.c --
  *
  *	This file contains Windows-specific socket related code.
  *
  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclWinSock.c,v 1.47 2005/07/13 20:01:02 dgp Exp $
+ * RCS: @(#) $Id: tclWinSock.c,v 1.48 2005/07/24 22:56:50 dkf Exp $
  */
 
 #include "tclWinInt.h"
 
 /*
- * Make sure to remove the redirection defines set in tclWinPort.h
- * that is in use in other sections of the core, except for us.
+ * Make sure to remove the redirection defines set in tclWinPort.h that is in
+ * use in other sections of the core, except for us.
  */
+
 #undef getservbyname
 #undef getsockopt
 #undef ntohs
@@ -34,7 +35,7 @@ TCL_DECLARE_MUTEX(socketMutex)
  * The following variable holds the network name of this host.
  */
 
-static TclInitProcessGlobalValueProc    InitializeHostName;
+static TclInitProcessGlobalValueProc	InitializeHostName;
 static ProcessGlobalValue hostName =
 	{0, 0, NULL, NULL, InitializeHostName, NULL, NULL};
 
@@ -44,62 +45,62 @@ static ProcessGlobalValue hostName =
 
 #ifdef HAVE_NO_LPFN_DECLS
     typedef SOCKET (PASCAL FAR *LPFN_ACCEPT)(SOCKET s,
-            struct sockaddr FAR * addr, int FAR * addrlen);
+	    struct sockaddr FAR * addr, int FAR * addrlen);
     typedef int (PASCAL FAR *LPFN_BIND)(SOCKET s,
-            const struct sockaddr FAR *addr, int namelen);
+	    const struct sockaddr FAR *addr, int namelen);
     typedef int (PASCAL FAR *LPFN_CLOSESOCKET)(SOCKET s);
     typedef int (PASCAL FAR *LPFN_CONNECT)(SOCKET s,
-            const struct sockaddr FAR *name, int namelen);
+	    const struct sockaddr FAR *name, int namelen);
     typedef struct hostent FAR * (PASCAL FAR *LPFN_GETHOSTBYADDR)
-            (const char FAR *addr, int addrlen, int addrtype);
+	    (const char FAR *addr, int addrlen, int addrtype);
     typedef struct hostent FAR * (PASCAL FAR *LPFN_GETHOSTBYNAME)
-            (const char FAR * name);
+	    (const char FAR * name);
     typedef int (PASCAL FAR *LPFN_GETHOSTNAME)(char FAR * name,
-            int namelen);
+	    int namelen);
     typedef int (PASCAL FAR *LPFN_GETPEERNAME)(SOCKET sock,
-            struct sockaddr FAR *name, int FAR *namelen);
+	    struct sockaddr FAR *name, int FAR *namelen);
     typedef struct servent FAR * (PASCAL FAR *LPFN_GETSERVBYNAME)
-            (const char FAR * name, const char FAR * proto);
+	    (const char FAR * name, const char FAR * proto);
     typedef int (PASCAL FAR *LPFN_GETSOCKNAME)(SOCKET sock,
-            struct sockaddr FAR *name, int FAR *namelen);
+	    struct sockaddr FAR *name, int FAR *namelen);
     typedef int (PASCAL FAR *LPFN_GETSOCKOPT)(SOCKET s, int level,
-            int optname, char FAR * optval, int FAR *optlen);
+	    int optname, char FAR * optval, int FAR *optlen);
     typedef u_short (PASCAL FAR *LPFN_HTONS)(u_short hostshort);
     typedef unsigned long (PASCAL FAR *LPFN_INET_ADDR)
-            (const char FAR * cp);
+	    (const char FAR * cp);
     typedef char FAR * (PASCAL FAR *LPFN_INET_NTOA)
-            (struct in_addr in);
+	    (struct in_addr in);
     typedef int (PASCAL FAR *LPFN_IOCTLSOCKET)(SOCKET s,
-            long cmd, u_long FAR *argp);
+	    long cmd, u_long FAR *argp);
     typedef int (PASCAL FAR *LPFN_LISTEN)(SOCKET s, int backlog);
     typedef u_short (PASCAL FAR *LPFN_NTOHS)(u_short netshort);
     typedef int (PASCAL FAR *LPFN_RECV)(SOCKET s, char FAR * buf,
-            int len, int flags);
+	    int len, int flags);
     typedef int (PASCAL FAR *LPFN_SELECT)(int nfds,
-            fd_set FAR * readfds, fd_set FAR * writefds,
-            fd_set FAR * exceptfds,
-            const struct timeval FAR * timeout);
+	    fd_set FAR * readfds, fd_set FAR * writefds,
+	    fd_set FAR * exceptfds,
+	    const struct timeval FAR * timeout);
     typedef int (PASCAL FAR *LPFN_SEND)(SOCKET s,
-            const char FAR * buf, int len, int flags);
+	    const char FAR * buf, int len, int flags);
     typedef int (PASCAL FAR *LPFN_SETSOCKOPT)(SOCKET s,
-            int level, int optname, const char FAR * optval,
-            int optlen);
+	    int level, int optname, const char FAR * optval,
+	    int optlen);
     typedef SOCKET (PASCAL FAR *LPFN_SOCKET)(int af,
-            int type, int protocol);
+	    int type, int protocol);
     typedef int (PASCAL FAR *LPFN_WSAASYNCSELECT)(SOCKET s,
-            HWND hWnd, u_int wMsg, long lEvent);
+	    HWND hWnd, u_int wMsg, long lEvent);
     typedef int (PASCAL FAR *LPFN_WSACLEANUP)(void);
     typedef int (PASCAL FAR *LPFN_WSAGETLASTERROR)(void);
     typedef int (PASCAL FAR *LPFN_WSASTARTUP)(WORD wVersionRequired,
-            LPWSADATA lpWSAData);
+	    LPWSADATA lpWSAData);
 #endif
 
 
 /*
- * The following structure contains pointers to all of the WinSock API
- * entry points used by Tcl.  It is initialized by InitSockets.  Since
- * we dynamically load the Winsock DLL on demand, we must use this
- * function table to refer to functions in the winsock API.
+ * The following structure contains pointers to all of the WinSock API entry
+ * points used by Tcl. It is initialized by InitSockets. Since we dynamically
+ * load the Winsock DLL on demand, we must use this function table to refer to
+ * functions in the winsock API.
  */
 
 static struct {
@@ -132,7 +133,6 @@ static struct {
     LPFN_WSACLEANUP	    WSACleanup;
     LPFN_WSAGETLASTERROR    WSAGetLastError;
     LPFN_WSASTARTUP	    WSAStartup;
-
 } winSock;
 
 /*
@@ -146,52 +146,48 @@ static struct {
 #define UNSELECT	    FALSE
 
 /*
- * The following structure is used to store the data associated with
- * each socket.
+ * The following structure is used to store the data associated with each
+ * socket.
  */
 
 typedef struct SocketInfo {
-    Tcl_Channel channel;	   /* Channel associated with this
-				    * socket. */
-    SOCKET socket;		   /* Windows SOCKET handle. */
-    int flags;			   /* Bit field comprised of the flags
-				    * described below.  */
-    int watchEvents;		   /* OR'ed combination of FD_READ,
-				    * FD_WRITE, FD_CLOSE, FD_ACCEPT and
-				    * FD_CONNECT that indicate which
-				    * events are interesting. */
-    int readyEvents;		   /* OR'ed combination of FD_READ,
-				    * FD_WRITE, FD_CLOSE, FD_ACCEPT and
-				    * FD_CONNECT that indicate which
-				    * events have occurred. */
-    int selectEvents;		   /* OR'ed combination of FD_READ,
-				    * FD_WRITE, FD_CLOSE, FD_ACCEPT and
-				    * FD_CONNECT that indicate which
-				    * events are currently being
-				    * selected. */
-    int acceptEventCount;          /* Count of the current number of
-				    * FD_ACCEPTs that have arrived and
-				    * not yet processed. */
-    Tcl_TcpAcceptProc *acceptProc; /* Proc to call on accept. */
-    ClientData acceptProcData;	   /* The data for the accept proc. */
-    int lastError;		   /* Error code from last message. */
-    struct SocketInfo *nextPtr;	   /* The next socket on the per-thread
-				    * socket list. */
+    Tcl_Channel channel;	/* Channel associated with this socket. */
+    SOCKET socket;		/* Windows SOCKET handle. */
+    int flags;			/* Bit field comprised of the flags described
+				 * below. */
+    int watchEvents;		/* OR'ed combination of FD_READ, FD_WRITE,
+				 * FD_CLOSE, FD_ACCEPT and FD_CONNECT that
+				 * indicate which events are interesting. */
+    int readyEvents;		/* OR'ed combination of FD_READ, FD_WRITE,
+				 * FD_CLOSE, FD_ACCEPT and FD_CONNECT that
+				 * indicate which events have occurred. */
+    int selectEvents;		/* OR'ed combination of FD_READ, FD_WRITE,
+				 * FD_CLOSE, FD_ACCEPT and FD_CONNECT that
+				 * indicate which events are currently being
+				 * selected. */
+    int acceptEventCount;	/* Count of the current number of FD_ACCEPTs
+				 * that have arrived and not yet processed. */
+    Tcl_TcpAcceptProc *acceptProc;
+				/* Proc to call on accept. */
+    ClientData acceptProcData;	/* The data for the accept proc. */
+    int lastError;		/* Error code from last message. */
+    struct SocketInfo *nextPtr;	/* The next socket on the per-thread socket
+				 * list. */
 } SocketInfo;
 
 /*
- * The following structure is what is added to the Tcl event queue when
- * a socket event occurs.
+ * The following structure is what is added to the Tcl event queue when a
+ * socket event occurs.
  */
 
 typedef struct SocketEvent {
-    Tcl_Event header;		/* Information that is standard for
-				 * all events. */
-    SOCKET socket;		/* Socket descriptor that is ready.  Used
-				 * to find the SocketInfo structure for
-				 * the file (can't point directly to the
-				 * SocketInfo structure because it could
-				 * go away while the event is queued). */
+    Tcl_Event header;		/* Information that is standard for all
+				 * events. */
+    SOCKET socket;		/* Socket descriptor that is ready. Used to
+				 * find the SocketInfo structure for the file
+				 * (can't point directly to the SocketInfo
+				 * structure because it could go away while
+				 * the event is queued). */
 } SocketEvent;
 
 /*
@@ -201,30 +197,28 @@ typedef struct SocketEvent {
 #define TCP_BUFFER_SIZE 4096
 
 /*
- * The following macros may be used to set the flags field of
- * a SocketInfo structure.
+ * The following macros may be used to set the flags field of a SocketInfo
+ * structure.
  */
 
-#define SOCKET_ASYNC		(1<<0)	/* The socket is in blocking
-					 * mode. */
-#define SOCKET_EOF		(1<<1)	/* A zero read happened on
-					 * the socket. */
-#define SOCKET_ASYNC_CONNECT	(1<<2)	/* This socket uses async
-					 * connect. */
-#define SOCKET_PENDING		(1<<3)	/* A message has been sent
-					 * for this socket */
+#define SOCKET_ASYNC		(1<<0)	/* The socket is in blocking mode. */
+#define SOCKET_EOF		(1<<1)	/* A zero read happened on the
+					 * socket. */
+#define SOCKET_ASYNC_CONNECT	(1<<2)	/* This socket uses async connect. */
+#define SOCKET_PENDING		(1<<3)	/* A message has been sent for this
+					 * socket */
 
 typedef struct ThreadSpecificData {
-    HWND hwnd;		    /* Handle to window for socket messages. */
-    HANDLE socketThread;    /* Thread handling the window */
-    Tcl_ThreadId threadId;  /* Parent thread. */
-    HANDLE readyEvent;      /* Event indicating that a socket event is
-			     * ready.  Also used to indicate that the
-			     * socketThread has been initialized and has
-			     * started. */
-    HANDLE socketListLock;  /* Win32 Event to lock the socketList */
-    SocketInfo *socketList; /* Every open socket in this thread has an
-			     * entry on this list. */
+    HWND hwnd;			/* Handle to window for socket messages. */
+    HANDLE socketThread;	/* Thread handling the window */
+    Tcl_ThreadId threadId;	/* Parent thread. */
+    HANDLE readyEvent;		/* Event indicating that a socket event is
+				 * ready. Also used to indicate that the
+				 * socketThread has been initialized and has
+				 * started. */
+    HANDLE socketListLock;	/* Win32 Event to lock the socketList */
+    SocketInfo *socketList;	/* Every open socket in this thread has an
+				 * entry on this list. */
 } ThreadSpecificData;
 
 static Tcl_ThreadDataKey dataKey;
@@ -234,26 +228,28 @@ static WNDCLASS windowClass;
  * Static functions defined in this file.
  */
 
-static SocketInfo *	    CreateSocket _ANSI_ARGS_((Tcl_Interp *interp,
-				    int port, CONST char *host,
-				    int server, CONST char *myaddr,
-				    int myport, int async));
-static int		    CreateSocketAddress _ANSI_ARGS_(
-				    (LPSOCKADDR_IN sockaddrPtr,
-				    CONST char *host, int port));
-static void		    InitSockets _ANSI_ARGS_((void));
-static SocketInfo *	    NewSocketInfo _ANSI_ARGS_((SOCKET socket));
-static Tcl_EventCheckProc   SocketCheckProc;
-static Tcl_EventProc	    SocketEventProc;
-static void		    SocketExitHandler _ANSI_ARGS_((
-				    ClientData clientData));
-static LRESULT CALLBACK	    SocketProc _ANSI_ARGS_((HWND hwnd,
-				    UINT message, WPARAM wParam,
-				    LPARAM lParam));
-static Tcl_EventSetupProc   SocketSetupProc;
-static Tcl_ExitProc	    SocketThreadExitHandler;
-static int		    SocketsEnabled _ANSI_ARGS_((void));
-static void		    TcpAccept _ANSI_ARGS_((SocketInfo *infoPtr));
+static SocketInfo *	CreateSocket(Tcl_Interp *interp, int port,
+			    CONST char *host, int server, CONST char *myaddr,
+			    int myport, int async);
+static int		CreateSocketAddress(LPSOCKADDR_IN sockaddrPtr,
+			    CONST char *host, int port);
+static void		InitSockets(void);
+static SocketInfo *	NewSocketInfo(SOCKET socket);
+static void		SocketExitHandler(ClientData clientData);
+static LRESULT CALLBACK	SocketProc(HWND hwnd, UINT message, WPARAM wParam,
+			    LPARAM lParam);
+static int		SocketsEnabled(void);
+static void		TcpAccept(SocketInfo *infoPtr);
+static int		WaitForSocketEvent(SocketInfo *infoPtr, int events,
+			    int *errorCodePtr);
+static DWORD WINAPI	SocketThread(LPVOID arg);
+static void		TcpThreadActionProc(ClientData instanceData,
+			    int action);
+
+static Tcl_EventCheckProc	SocketCheckProc;
+static Tcl_EventProc		SocketEventProc;
+static Tcl_EventSetupProc	SocketSetupProc;
+static Tcl_ExitProc		SocketThreadExitHandler;
 static Tcl_DriverBlockModeProc	TcpBlockProc;
 static Tcl_DriverCloseProc	TcpCloseProc;
 static Tcl_DriverSetOptionProc	TcpSetOptionProc;
@@ -262,14 +258,6 @@ static Tcl_DriverInputProc	TcpInputProc;
 static Tcl_DriverOutputProc	TcpOutputProc;
 static Tcl_DriverWatchProc	TcpWatchProc;
 static Tcl_DriverGetHandleProc	TcpGetHandleProc;
-static int		    WaitForSocketEvent _ANSI_ARGS_((
-				SocketInfo *infoPtr, int events,
-				int *errorCodePtr));
-static DWORD WINAPI	    SocketThread _ANSI_ARGS_((LPVOID arg));
-
-static void             TcpThreadActionProc _ANSI_ARGS_ ((
-			   ClientData instanceData, int action));
-
 
 /*
  * This structure describes the channel type structure for TCP socket
@@ -291,7 +279,7 @@ static Tcl_ChannelType tcpChannelType = {
     TcpBlockProc,	    /* Set socket into (non-)blocking mode. */
     NULL,		    /* flush proc. */
     NULL,		    /* handler proc. */
-    NULL,                   /* wide seek proc */
+    NULL,		    /* wide seek proc */
     TcpThreadActionProc,    /* thread action proc */
 };
 
@@ -301,9 +289,9 @@ static Tcl_ChannelType tcpChannelType = {
  *
  * InitSockets --
  *
- *	Initialize the socket module.  Attempts to load the wsock32.dll
- *	library and set up the winSock function table.  If successful,
- *	registers the event window for the socket notifier code.
+ *	Initialize the socket module. Attempts to load the wsock32.dll library
+ *	and set up the winSock function table. If successful, registers the
+ *	event window for the socket notifier code.
  *
  *	Assumes Mutex is held.
  *
@@ -311,9 +299,8 @@ static Tcl_ChannelType tcpChannelType = {
  *	None.
  *
  * Side effects:
- *	Dynamically loads wsock32.dll, and registers a new window
- *	class and creates a window for use in asynchronous socket
- *	notification.
+ *	Dynamically loads wsock32.dll, and registers a new window class and
+ *	creates a window for use in asynchronous socket notification.
  *
  *----------------------------------------------------------------------
  */
@@ -324,8 +311,8 @@ InitSockets()
     DWORD id;
     WSADATA wsaData;
     DWORD err;
-    ThreadSpecificData *tsdPtr = 
-	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    TclThreadDataKeyGet(&dataKey);
 
     if (!initialized) {
 	initialized = 1;
@@ -336,7 +323,7 @@ InitSockets()
 	if (winSock.hModule == NULL) {
 	    return;
 	}
-    
+
 	/*
 	 * Initialize the function table.
 	 */
@@ -393,13 +380,12 @@ InitSockets()
 		GetProcAddress(winSock.hModule, "WSAGetLastError");
 	winSock.WSAStartup = (LPFN_WSASTARTUP)
 		GetProcAddress(winSock.hModule, "WSAStartup");
-    
+
 	/*
-	 * Now check that all fields are properly initialized. If not,
-	 * return zero to indicate that we failed to initialize
-	 * properly.
+	 * Now check that all fields are properly initialized. If not, return
+	 * zero to indicate that we failed to initialize properly.
 	 */
-    
+
 	if ((winSock.accept == NULL) ||
 		(winSock.bind == NULL) ||
 		(winSock.closesocket == NULL) ||
@@ -425,18 +411,17 @@ InitSockets()
 		(winSock.WSAAsyncSelect == NULL) ||
 		(winSock.WSACleanup == NULL) ||
 		(winSock.WSAGetLastError == NULL) ||
-		(winSock.WSAStartup == NULL))
-	{
+		(winSock.WSAStartup == NULL)) {
 	    goto unloadLibrary;
 	}
-	
+
 	/*
-	 * Create the async notification window with a new class.  We
-	 * must create a new class to avoid a Windows 95 bug that causes
-	 * us to get the wrong message number for socket events if the
-	 * message window is a subclass of a static control.
+	 * Create the async notification window with a new class. We must
+	 * create a new class to avoid a Windows 95 bug that causes us to get
+	 * the wrong message number for socket events if the message window is
+	 * a subclass of a static control.
 	 */
-    
+
 	windowClass.style = 0;
 	windowClass.cbClsExtra = 0;
 	windowClass.cbWndExtra = 0;
@@ -454,14 +439,14 @@ InitSockets()
 	}
 
 	/*
-	 * Initialize the winsock library and check the interface
-	 * version actually loaded. We only ask for the 1.1 interface
-	 * and do require that it not be less than 1.1.
+	 * Initialize the winsock library and check the interface version
+	 * actually loaded. We only ask for the 1.1 interface and do require
+	 * that it not be less than 1.1.
 	 */
 
-#define WSA_VERSION_MAJOR   1
-#define WSA_VERSION_MINOR   1
-#define WSA_VERSION_REQD    MAKEWORD(WSA_VERSION_MAJOR, WSA_VERSION_MINOR)
+#define WSA_VERSION_MAJOR 1
+#define WSA_VERSION_MINOR 1
+#define WSA_VERSION_REQD  MAKEWORD(WSA_VERSION_MAJOR, WSA_VERSION_MINOR)
 
 	if ((err = winSock.WSAStartup(WSA_VERSION_REQD, &wsaData)) != 0) {
 	    TclWinConvertWSAError(err);
@@ -469,9 +454,9 @@ InitSockets()
 	}
 
 	/*
-	 * Note the byte positions are swapped for the comparison, so
-	 * that 0x0002 (2.0, MAKEWORD(2,0)) doesn't look less than 0x0101
-	 * (1.1).  We want the comparison to be 0x0200 < 0x0101.
+	 * Note the byte positions are swapped for the comparison, so that
+	 * 0x0002 (2.0, MAKEWORD(2,0)) doesn't look less than 0x0101 (1.1).
+	 * We want the comparison to be 0x0200 < 0x0101.
 	 */
 
 	if (MAKEWORD(HIBYTE(wsaData.wVersion), LOBYTE(wsaData.wVersion))
@@ -496,7 +481,7 @@ InitSockets()
 	tsdPtr->hwnd = NULL;
 
 	tsdPtr->threadId = Tcl_GetCurrentThread();
-	
+
 	tsdPtr->readyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 	tsdPtr->socketListLock = CreateEvent(NULL, FALSE, TRUE, NULL);
 	tsdPtr->socketThread = CreateThread(NULL, 256, SocketThread,
@@ -506,29 +491,27 @@ InitSockets()
 	if (tsdPtr->socketThread == NULL) {
 	    goto unloadLibrary;
 	}
-	
+
 
 	/*
-	 * Wait for the thread to signal that the window has
-	 * been created and is ready to go.  Timeout after twenty
-	 * seconds.
+	 * Wait for the thread to signal that the window has been created and
+	 * is ready to go. Timeout after twenty seconds.
 	 */
-	
-	if (WaitForSingleObject(tsdPtr->readyEvent, 20000)
-		== WAIT_TIMEOUT) {
+
+	if (WaitForSingleObject(tsdPtr->readyEvent, 20000) == WAIT_TIMEOUT) {
 	    goto unloadLibrary;
 	}
 
 	if (tsdPtr->hwnd == NULL) {
 	    goto unloadLibrary;
 	}
-	
+
 	Tcl_CreateEventSource(SocketSetupProc, SocketCheckProc, NULL);
 	Tcl_CreateThreadExitHandler(SocketThreadExitHandler, NULL);
     }
     return;
 
-unloadLibrary:
+  unloadLibrary:
     if (tsdPtr != NULL && tsdPtr->hwnd != NULL) {
 	SocketThreadExitHandler(0);
     }
@@ -585,14 +568,15 @@ SocketsEnabled()
     /* ARGSUSED */
 static void
 SocketExitHandler(clientData)
-    ClientData clientData;              /* Not used. */
+    ClientData clientData;		/* Not used. */
 {
     Tcl_MutexLock(&socketMutex);
     if (winSock.hModule) {
 	/*
-	 * Make sure the socket event handling window is cleaned-up
-	 * for, at most, this thread.
+	 * Make sure the socket event handling window is cleaned-up for, at
+	 * most, this thread.
 	 */
+
 	SocketThreadExitHandler(clientData);
 	UnregisterClass("TclSocket", TclWinGetTclInstance());
 	winSock.WSACleanup();
@@ -608,8 +592,8 @@ SocketExitHandler(clientData)
  *
  * SocketThreadExitHandler --
  *
- *	Callback invoked during thread clean up to delete the socket
- *	event source.
+ *	Callback invoked during thread clean up to delete the socket event
+ *	source.
  *
  * Results:
  *	None.
@@ -623,9 +607,9 @@ SocketExitHandler(clientData)
     /* ARGSUSED */
 static void
 SocketThreadExitHandler(clientData)
-    ClientData clientData;              /* Not used. */
+    ClientData clientData;		/* Not used. */
 {
-    ThreadSpecificData *tsdPtr = 
+    ThreadSpecificData *tsdPtr =
 	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
 
     if (tsdPtr != NULL && tsdPtr->socketThread != NULL) {
@@ -634,11 +618,12 @@ SocketThreadExitHandler(clientData)
 	GetExitCodeThread(tsdPtr->socketThread, &exitCode);
 	if (exitCode == STILL_ACTIVE) {
 	    PostMessage(tsdPtr->hwnd, SOCKET_TERMINATE, 0, 0);
+
 	    /*
-	     * Wait for the thread to close.  This ensures that we are
-	     * completely cleaned up before we leave this function.
-	     * If Tcl_Finalize was called from DllMain, the thread
-	     * is in a paused state so we need to timeout and continue.
+	     * Wait for the thread to close. This ensures that we are
+	     * completely cleaned up before we leave this function. If
+	     * Tcl_Finalize was called from DllMain, the thread is in a paused
+	     * state so we need to timeout and continue.
 	     */
 
 	    WaitForSingleObject(tsdPtr->socketThread, 100);
@@ -658,18 +643,18 @@ SocketThreadExitHandler(clientData)
  *
  * TclpHasSockets --
  *
- *	This function determines whether sockets are available on the
- *	current system and returns an error in interp if they are not.
- *	Note that interp may be NULL.
+ *	This function determines whether sockets are available on the current
+ *	system and returns an error in interp if they are not. Note that
+ *	interp may be NULL.
  *
  * Results:
- *	Returns TCL_OK if the system supports sockets, or TCL_ERROR with
- *	an error in interp.
+ *	Returns TCL_OK if the system supports sockets, or TCL_ERROR with an
+ *	error in interp (if non-NULL).
  *
  * Side effects:
- *	If not already prepared, initializes the TSD structure and
- *	socket message handling thread associated to the calling thread
- *	for the subsystem of the driver.
+ *	If not already prepared, initializes the TSD structure and socket
+ *	message handling thread associated to the calling thread for the
+ *	subsystem of the driver.
  *
  *----------------------------------------------------------------------
  */
@@ -697,8 +682,8 @@ TclpHasSockets(interp)
  *
  * SocketSetupProc --
  *
- *	This procedure is invoked before Tcl_DoOneEvent blocks waiting
- *	for an event.
+ *	This function is invoked before Tcl_DoOneEvent blocks waiting for an
+ *	event.
  *
  * Results:
  *	None.
@@ -721,13 +706,13 @@ SocketSetupProc(data, flags)
     if (!(flags & TCL_FILE_EVENTS)) {
 	return;
     }
-    
+
     /*
-     * Check to see if there is a ready socket.  If so, poll.
+     * Check to see if there is a ready socket.	 If so, poll.
      */
 
     WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
-    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
+    for (infoPtr = tsdPtr->socketList; infoPtr != NULL;
 	    infoPtr = infoPtr->nextPtr) {
 	if (infoPtr->readyEvents & infoPtr->watchEvents) {
 	    Tcl_SetMaxBlockTime(&blockTime);
@@ -742,8 +727,8 @@ SocketSetupProc(data, flags)
  *
  * SocketCheckProc --
  *
- *	This procedure is called by Tcl_DoOneEvent to check the socket
- *	event source for events. 
+ *	This function is called by Tcl_DoOneEvent to check the socket event
+ *	source for events.
  *
  * Results:
  *	None.
@@ -766,7 +751,7 @@ SocketCheckProc(data, flags)
     if (!(flags & TCL_FILE_EVENTS)) {
 	return;
     }
-    
+
     /*
      * Queue events for any ready sockets that don't already have events
      * queued (caused by persistent states that won't generate WinSock
@@ -774,7 +759,7 @@ SocketCheckProc(data, flags)
      */
 
     WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
-    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
+    for (infoPtr = tsdPtr->socketList; infoPtr != NULL;
 	    infoPtr = infoPtr->nextPtr) {
 	if ((infoPtr->readyEvents & infoPtr->watchEvents)
 		&& !(infoPtr->flags & SOCKET_PENDING)) {
@@ -793,18 +778,18 @@ SocketCheckProc(data, flags)
  *
  * SocketEventProc --
  *
- *	This procedure is called by Tcl_ServiceEvent when a socket event
- *	reaches the front of the event queue.  This procedure is
- *	responsible for notifying the generic channel code.
+ *	This function is called by Tcl_ServiceEvent when a socket event
+ *	reaches the front of the event queue. This function is responsible for
+ *	notifying the generic channel code.
  *
  * Results:
- *	Returns 1 if the event was handled, meaning it should be removed
- *	from the queue.  Returns 0 if the event was not handled, meaning
- *	it should stay on the queue.  The only time the event isn't
- *	handled is if the TCL_FILE_EVENTS flag bit isn't set.
+ *	Returns 1 if the event was handled, meaning it should be removed from
+ *	the queue. Returns 0 if the event was not handled, meaning it should
+ *	stay on the queue. The only time the event isn't handled is if the
+ *	TCL_FILE_EVENTS flag bit isn't set.
  *
  * Side effects:
- *	Whatever the channel callback procedures do.
+ *	Whatever the channel callback functions do.
  *
  *----------------------------------------------------------------------
  */
@@ -812,8 +797,8 @@ SocketCheckProc(data, flags)
 static int
 SocketEventProc(evPtr, flags)
     Tcl_Event *evPtr;		/* Event to service. */
-    int flags;			/* Flags that indicate what events to
-				 * handle, such as TCL_FILE_EVENTS. */
+    int flags;			/* Flags that indicate what events to handle,
+				 * such as TCL_FILE_EVENTS. */
 {
     SocketInfo *infoPtr;
     SocketEvent *eventPtr = (SocketEvent *) evPtr;
@@ -830,7 +815,7 @@ SocketEventProc(evPtr, flags)
      */
 
     WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
-    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
+    for (infoPtr = tsdPtr->socketList; infoPtr != NULL;
 	    infoPtr = infoPtr->nextPtr) {
 	if (infoPtr->socket == eventPtr->socket) {
 	    break;
@@ -858,21 +843,21 @@ SocketEventProc(evPtr, flags)
     }
 
     /*
-     * Mask off unwanted events and compute the read/write mask so 
-     * we can notify the channel.
+     * Mask off unwanted events and compute the read/write mask so we can
+     * notify the channel.
      */
 
     events = infoPtr->readyEvents & infoPtr->watchEvents;
 
     if (events & FD_CLOSE) {
 	/*
-	 * If the socket was closed and the channel is still interested
-	 * in read events, then we need to ensure that we keep polling
-	 * for this event until someone does something with the channel.
-	 * Note that we do this before calling Tcl_NotifyChannel so we don't
-	 * have to watch out for the channel being deleted out from under
-	 * us.  This may cause a redundant trip through the event loop, but
-	 * it's simpler than trying to do unwind protection.
+	 * If the socket was closed and the channel is still interested in
+	 * read events, then we need to ensure that we keep polling for this
+	 * event until someone does something with the channel. Note that we
+	 * do this before calling Tcl_NotifyChannel so we don't have to watch
+	 * out for the channel being deleted out from under us. This may cause
+	 * a redundant trip through the event loop, but it's simpler than
+	 * trying to do unwind protection.
 	 */
 
 	Tcl_Time blockTime = { 0, 0 };
@@ -884,10 +869,10 @@ SocketEventProc(evPtr, flags)
 
 	/*
 	 * We must check to see if data is really available, since someone
-	 * could have consumed the data in the meantime.  Turn off async
-	 * notification so select will work correctly.	If the socket is
-	 * still readable, notify the channel driver, otherwise reset the
-	 * async select handler and keep waiting.
+	 * could have consumed the data in the meantime. Turn off async
+	 * notification so select will work correctly. If the socket is still
+	 * readable, notify the channel driver, otherwise reset the async
+	 * select handler and keep waiting.
 	 */
 
 	SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
@@ -897,7 +882,7 @@ SocketEventProc(evPtr, flags)
 	FD_SET(infoPtr->socket, &readFds);
 	timeout.tv_usec = 0;
 	timeout.tv_sec = 0;
- 
+
 	if (winSock.select(0, &readFds, NULL, NULL, &timeout) != 0) {
 	    mask |= TCL_READABLE;
 	} else {
@@ -909,7 +894,10 @@ SocketEventProc(evPtr, flags)
     if (events & (FD_WRITE | FD_CONNECT)) {
 	mask |= TCL_WRITABLE;
 	if (events & FD_CONNECT && infoPtr->lastError != NO_ERROR) {
-	    /* connect errors should also fire the readable handler. */
+	    /*
+	     * Connect errors should also fire the readable handler.
+	     */
+
 	    mask |= TCL_READABLE;
 	}
     }
@@ -940,7 +928,7 @@ static int
 TcpBlockProc(instanceData, mode)
     ClientData	instanceData;	/* The socket to block/un-block. */
     int mode;			/* TCL_MODE_BLOCKING or
-                                 * TCL_MODE_NONBLOCKING. */
+				 * TCL_MODE_NONBLOCKING. */
 {
     SocketInfo *infoPtr = (SocketInfo *) instanceData;
 
@@ -957,9 +945,9 @@ TcpBlockProc(instanceData, mode)
  *
  * TcpCloseProc --
  *
- *	This procedure is called by the generic IO level to perform
- *	channel type specific cleanup on a socket based channel
- *	when the channel is closed.
+ *	This function is called by the generic IO level to perform channel
+ *	type specific cleanup on a socket based channel when the channel is
+ *	closed.
  *
  * Results:
  *	0 if successful, the value of errno if failed.
@@ -982,32 +970,31 @@ TcpCloseProc(instanceData, interp)
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (SocketsEnabled()) {
-        
 	/*
-         * Clean up the OS socket handle.  The default Windows setting
-	 * for a socket is SO_DONTLINGER, which does a graceful shutdown
-	 * in the background.
-         */
-    
-        if (winSock.closesocket(infoPtr->socket) == SOCKET_ERROR) {
-            TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
-            errorCode = Tcl_GetErrno();
-        }
-    }
-
-    /* TIP #218. Removed the code removing the structure
-     * from the global socket list. This is now done by
-     * the thread action callbacks, and only there. This
-     * happens before this code is called. We can free
-     * without fear of damaging the list.
+	 * Clean up the OS socket handle. The default Windows setting for a
+	 * socket is SO_DONTLINGER, which does a graceful shutdown in the
+	 * background.
+	 */
+
+	if (winSock.closesocket(infoPtr->socket) == SOCKET_ERROR) {
+	    TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
+	    errorCode = Tcl_GetErrno();
+	}
+    }
+
+    /*
+     * TIP #218. Removed the code removing the structure from the global
+     * socket list. This is now done by the thread action callbacks, and only
+     * there. This happens before this code is called. We can free without
+     * fear of damaging the list.
      */
+
     ckfree((char *) infoPtr);
     return errorCode;
 }
@@ -1017,8 +1004,7 @@ TcpCloseProc(instanceData, interp)
  *
  * NewSocketInfo --
  *
- *	This function allocates and initializes a new SocketInfo
- *	structure.
+ *	This function allocates and initializes a new SocketInfo structure.
  *
  * Results:
  *	Returns a newly allocated SocketInfo.
@@ -1048,10 +1034,12 @@ NewSocketInfo(socket)
     infoPtr->acceptProcData = NULL;
     infoPtr->lastError = 0;
 
-    /* TIP #218. Removed the code inserting the new structure
-     * into the global list. This is now handled in the thread
-     * action callbacks, and only there.
+    /*
+     * TIP #218. Removed the code inserting the new structure into the global
+     * list. This is now handled in the thread action callbacks, and only
+     * there.
      */
+
     infoPtr->nextPtr = NULL;
 
     return infoPtr;
@@ -1062,8 +1050,8 @@ NewSocketInfo(socket)
  *
  * CreateSocket --
  *
- *	This function opens a new socket and initializes the
- *	SocketInfo structure.
+ *	This function opens a new socket and initializes the SocketInfo
+ *	structure.
  *
  * Results:
  *	Returns a new SocketInfo, or NULL with an error in interp.
@@ -1079,39 +1067,38 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
     Tcl_Interp *interp;		/* For error reporting; can be NULL. */
     int port;			/* Port number to open. */
     CONST char *host;		/* Name of host on which to open port. */
-    int server;			/* 1 if socket should be a server socket,
-				 * else 0 for a client socket. */
+    int server;			/* 1 if socket should be a server socket, else
+				 * 0 for a client socket. */
     CONST char *myaddr;		/* Optional client-side address */
     int myport;			/* Optional client-side port */
     int async;			/* If nonzero, connect client socket
 				 * asynchronously. */
 {
     u_long flag = 1;		/* Indicates nonblocking mode. */
-    int asyncConnect = 0;	/* Will be 1 if async connect is
-				 * in progress. */
+    int asyncConnect = 0;	/* Will be 1 if async connect is in
+				 * progress. */
     SOCKADDR_IN sockaddr;	/* Socket address */
     SOCKADDR_IN mysockaddr;	/* Socket address for client */
     SOCKET sock;
     SocketInfo *infoPtr;	/* The returned value. */
-    ThreadSpecificData *tsdPtr = 
-	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    TclThreadDataKeyGet(&dataKey);
 
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
-        return NULL;
+	return NULL;
     }
 
-    if (! CreateSocketAddress(&sockaddr, host, port)) {
+    if (!CreateSocketAddress(&sockaddr, host, port)) {
 	goto error;
     }
     if ((myaddr != NULL || myport != 0) &&
-	    ! CreateSocketAddress(&mysockaddr, myaddr, myport)) {
+	    !CreateSocketAddress(&mysockaddr, myaddr, myport)) {
 	goto error;
     }
 
@@ -1121,12 +1108,12 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
     }
 
     /*
-     * Win-NT has a misfeature that sockets are inherited in child
-     * processes by default.  Turn off the inherit bit.
+     * Win-NT has a misfeature that sockets are inherited in child processes
+     * by default. Turn off the inherit bit.
      */
 
-    SetHandleInformation( (HANDLE) sock, HANDLE_FLAG_INHERIT, 0 );
-	
+    SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0);
+
     /*
      * Set kernel space buffering
      */
@@ -1135,26 +1122,26 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
 
     if (server) {
 	/*
-	 * Bind to the specified port.  Note that we must not call setsockopt
+	 * Bind to the specified port. Note that we must not call setsockopt
 	 * with SO_REUSEADDR because Microsoft allows addresses to be reused
 	 * even if they are still in use.
-         *
-         * Bind should not be affected by the socket having already been
-         * set into nonblocking mode. If there is trouble, this is one place
-         * to look for bugs.
+	 *
+	 * Bind should not be affected by the socket having already been set
+	 * into nonblocking mode. If there is trouble, this is one place to
+	 * look for bugs.
 	 */
-    
+
 	if (winSock.bind(sock, (SOCKADDR *) &sockaddr,
 		sizeof(SOCKADDR_IN)) == SOCKET_ERROR) {
-            goto error;
-        }
-
-        /*
-         * Set the maximum number of pending connect requests to the
-         * max value allowed on each platform (Win32 and Win32s may be
-         * different, and there may be differences between TCP/IP stacks).
-         */
-        
+	    goto error;
+	}
+
+	/*
+	 * Set the maximum number of pending connect requests to the max value
+	 * allowed on each platform (Win32 and Win32s may be different, and
+	 * there may be differences between TCP/IP stacks).
+	 */
+
 	if (winSock.listen(sock, SOMAXCONN) == SOCKET_ERROR) {
 	    goto error;
 	}
@@ -1173,25 +1160,25 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
 	infoPtr->watchEvents |= FD_ACCEPT;
 
     } else {
+	/*
+	 * Try to bind to a local port, if specified.
+	 */
 
-        /*
-         * Try to bind to a local port, if specified.
-         */
-        
-	if (myaddr != NULL || myport != 0) { 
+	if (myaddr != NULL || myport != 0) {
 	    if (winSock.bind(sock, (SOCKADDR *) &mysockaddr,
 		    sizeof(SOCKADDR_IN)) == SOCKET_ERROR) {
 		goto error;
 	    }
-	}            
-    
+	}
+
 	/*
-	 * Set the socket into nonblocking mode if the connect should be
-	 * done in the background.
+	 * Set the socket into nonblocking mode if the connect should be done
+	 * in the background.
 	 */
-    
+
 	if (async) {
-	    if (winSock.ioctlsocket(sock, (long) FIONBIO, &flag) == SOCKET_ERROR) {
+	    if (winSock.ioctlsocket(sock, (long) FIONBIO,
+		    &flag) == SOCKET_ERROR) {
 		goto error;
 	    }
 	}
@@ -1202,7 +1189,7 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
 
 	if (winSock.connect(sock, (SOCKADDR *) &sockaddr,
 		sizeof(SOCKADDR_IN)) == SOCKET_ERROR) {
-            TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
+	    TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
 	    if (Tcl_GetErrno() != EWOULDBLOCK) {
 		goto error;
 	    }
@@ -1212,7 +1199,7 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
 	     */
 
 	    asyncConnect = 1;
-        }
+	}
 
 	/*
 	 * Add this socket to the global list of sockets.
@@ -1221,7 +1208,7 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
 	infoPtr = NewSocketInfo(sock);
 
 	/*
-	 * Set up the select mask for read/write events.  If the connect
+	 * Set up the select mask for read/write events. If the connect
 	 * attempt has not completed, include connect events.
 	 */
 
@@ -1233,7 +1220,7 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
     }
 
     /*
-     * Register for interest in events in the select mask.  Note that this
+     * Register for interest in events in the select mask. Note that this
      * automatically places the socket into non-blocking mode.
      */
 
@@ -1243,7 +1230,7 @@ CreateSocket(interp, port, host, server, myaddr, myport, async)
 
     return infoPtr;
 
-error:
+  error:
     TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
     if (interp != NULL) {
 	Tcl_AppendResult(interp, "couldn't open socket: ",
@@ -1263,8 +1250,8 @@ error:
  *	This function initializes a sockaddr structure for a host and port.
  *
  * Results:
- *	1 if the host was valid, 0 if the host could not be converted to
- *	an IP address.
+ *	1 if the host was valid, 0 if the host could not be converted to an IP
+ *	address.
  *
  * Side effects:
  *	Fills in the *sockaddrPtr structure.
@@ -1274,23 +1261,22 @@ error:
 
 static int
 CreateSocketAddress(sockaddrPtr, host, port)
-    LPSOCKADDR_IN sockaddrPtr;		/* Socket address */
-    CONST char *host;			/* Host.  NULL implies INADDR_ANY */
-    int port;				/* Port number */
+    LPSOCKADDR_IN sockaddrPtr;	/* Socket address */
+    CONST char *host;		/* Host. NULL implies INADDR_ANY */
+    int port;			/* Port number */
 {
-    struct hostent *hostent;		/* Host database entry */
-    struct in_addr addr;		/* For 64/32 bit madness */
+    struct hostent *hostent;	/* Host database entry */
+    struct in_addr addr;	/* For 64/32 bit madness */
 
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
-        Tcl_SetErrno(EFAULT);
-        return 0;
+	Tcl_SetErrno(EFAULT);
+	return 0;
     }
 
     ZeroMemory(sockaddrPtr, sizeof(SOCKADDR_IN));
@@ -1299,17 +1285,17 @@ CreateSocketAddress(sockaddrPtr, host, port)
     if (host == NULL) {
 	addr.s_addr = INADDR_ANY;
     } else {
-        addr.s_addr = winSock.inet_addr(host);
-        if (addr.s_addr == INADDR_NONE) {
-            hostent = winSock.gethostbyname(host);
-            if (hostent != NULL) {
-                memcpy(&addr, hostent->h_addr, (size_t) hostent->h_length);
-            } else {
+	addr.s_addr = winSock.inet_addr(host);
+	if (addr.s_addr == INADDR_NONE) {
+	    hostent = winSock.gethostbyname(host);
+	    if (hostent != NULL) {
+		memcpy(&addr, hostent->h_addr, (size_t) hostent->h_length);
+	    } else {
 #ifdef	EHOSTUNREACH
-                Tcl_SetErrno(EHOSTUNREACH);
+		Tcl_SetErrno(EHOSTUNREACH);
 #else
 #ifdef ENXIO
-                Tcl_SetErrno(ENXIO);
+		Tcl_SetErrno(ENXIO);
 #endif
 #endif
 		return 0;	/* Error. */
@@ -1318,14 +1304,14 @@ CreateSocketAddress(sockaddrPtr, host, port)
     }
 
     /*
-     * NOTE: On 64 bit machines the assignment below is rumored to not
-     * do the right thing. Please report errors related to this if you
-     * observe incorrect behavior on 64 bit machines such as DEC Alphas.
-     * Should we modify this code to do an explicit memcpy?
+     * NOTE: On 64 bit machines the assignment below is rumored to not do the
+     * right thing. Please report errors related to this if you observe
+     * incorrect behavior on 64 bit machines such as DEC Alphas. Should we
+     * modify this code to do an explicit memcpy?
      */
 
     sockaddrPtr->sin_addr.s_addr = addr.s_addr;
-    return 1;	/* Success. */
+    return 1;			/* Success. */
 }
 
 /*
@@ -1353,15 +1339,15 @@ WaitForSocketEvent(infoPtr, events, errorCodePtr)
 {
     int result = 1;
     int oldMode;
-    ThreadSpecificData *tsdPtr = 
-	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    TclThreadDataKeyGet(&dataKey);
 
     /*
      * Be sure to disable event servicing so we are truly modal.
      */
 
     oldMode = Tcl_SetServiceMode(TCL_SERVICE_NONE);
-    
+
     /*
      * Reset WSAAsyncSelect so we have a fresh set of events pending.
      */
@@ -1373,7 +1359,6 @@ WaitForSocketEvent(infoPtr, events, errorCodePtr)
 	    (WPARAM) SELECT, (LPARAM) infoPtr);
 
     while (1) {
-
 	if (infoPtr->lastError) {
 	    *errorCodePtr = infoPtr->lastError;
 	    result = 0;
@@ -1389,9 +1374,10 @@ WaitForSocketEvent(infoPtr, events, errorCodePtr)
 	/*
 	 * Wait until something happens.
 	 */
+
 	WaitForSingleObject(tsdPtr->readyEvent, INFINITE);
     }
-    
+
     (void) Tcl_SetServiceMode(oldMode);
     return result;
 }
@@ -1404,8 +1390,8 @@ WaitForSocketEvent(infoPtr, events, errorCodePtr)
  *	Opens a TCP client socket and creates a channel around it.
  *
  * Results:
- *	The channel or NULL if failed.  An error message is returned
- *	in the interpreter on failure.
+ *	The channel or NULL if failed. An error message is returned in the
+ *	interpreter on failure.
  *
  * Side effects:
  *	Opens a client socket and creates a new channel.
@@ -1415,13 +1401,13 @@ WaitForSocketEvent(infoPtr, events, errorCodePtr)
 
 Tcl_Channel
 Tcl_OpenTcpClient(interp, port, host, myaddr, myport, async)
-    Tcl_Interp *interp;			/* For error reporting; can be NULL. */
-    int port;				/* Port number to open. */
-    CONST char *host;			/* Host on which to open port. */
-    CONST char *myaddr;			/* Client-side address */
-    int myport;				/* Client-side port */
-    int async;				/* If nonzero, should connect
-                                         * client socket asynchronously. */
+    Tcl_Interp *interp;		/* For error reporting; can be NULL. */
+    int port;			/* Port number to open. */
+    CONST char *host;		/* Host on which to open port. */
+    CONST char *myaddr;		/* Client-side address */
+    int myport;			/* Client-side port */
+    int async;			/* If nonzero, should connect client socket
+				 * asynchronously. */
 {
     SocketInfo *infoPtr;
     char channelName[16 + TCL_INTEGER_SPACE];
@@ -1445,13 +1431,13 @@ Tcl_OpenTcpClient(interp, port, host, myaddr, myport, async)
 	    (ClientData) infoPtr, (TCL_READABLE | TCL_WRITABLE));
     if (Tcl_SetChannelOption(interp, infoPtr->channel, "-translation",
 	    "auto crlf") == TCL_ERROR) {
-        Tcl_Close((Tcl_Interp *) NULL, infoPtr->channel);
-        return (Tcl_Channel) NULL;
+	Tcl_Close((Tcl_Interp *) NULL, infoPtr->channel);
+	return (Tcl_Channel) NULL;
     }
     if (Tcl_SetChannelOption(NULL, infoPtr->channel, "-eofchar", "")
 	    == TCL_ERROR) {
-        Tcl_Close((Tcl_Interp *) NULL, infoPtr->channel);
-        return (Tcl_Channel) NULL;
+	Tcl_Close((Tcl_Interp *) NULL, infoPtr->channel);
+	return (Tcl_Channel) NULL;
     }
     return infoPtr->channel;
 }
@@ -1519,8 +1505,8 @@ Tcl_MakeTcpClientChannel(sock)
  *	Opens a TCP server socket and creates a channel around it.
  *
  * Results:
- *	The channel or NULL if failed.  An error message is returned
- *	in the interpreter on failure.
+ *	The channel or NULL if failed. An error message is returned in the
+ *	interpreter on failure.
  *
  * Side effects:
  *	Opens a server socket and creates a new channel.
@@ -1530,13 +1516,13 @@ Tcl_MakeTcpClientChannel(sock)
 
 Tcl_Channel
 Tcl_OpenTcpServer(interp, port, host, acceptProc, acceptProcData)
-    Tcl_Interp *interp;			/* For error reporting - may be
-                                         * NULL. */
-    int port;				/* Port number to open. */
-    CONST char *host;			/* Name of local host. */
-    Tcl_TcpAcceptProc *acceptProc;	/* Callback for accepting connections
-                                         * from new clients. */
-    ClientData acceptProcData;		/* Data for the callback. */
+    Tcl_Interp *interp;		/* For error reporting - may be NULL. */
+    int port;			/* Port number to open. */
+    CONST char *host;		/* Name of local host. */
+    Tcl_TcpAcceptProc *acceptProc;
+				/* Callback for accepting connections from new
+				 * clients. */
+    ClientData acceptProcData;	/* Data for the callback. */
 {
     SocketInfo *infoPtr;
     char channelName[16 + TCL_INTEGER_SPACE];
@@ -1563,8 +1549,8 @@ Tcl_OpenTcpServer(interp, port, host, acceptProc, acceptProcData)
 	    (ClientData) infoPtr, 0);
     if (Tcl_SetChannelOption(interp, infoPtr->channel, "-eofchar", "")
 	    == TCL_ERROR) {
-        Tcl_Close((Tcl_Interp *) NULL, infoPtr->channel);
-        return (Tcl_Channel) NULL;
+	Tcl_Close((Tcl_Interp *) NULL, infoPtr->channel);
+	return (Tcl_Channel) NULL;
     }
 
     return infoPtr->channel;
@@ -1574,9 +1560,9 @@ Tcl_OpenTcpServer(interp, port, host, acceptProc, acceptProcData)
  *----------------------------------------------------------------------
  *
  * TcpAccept --
- *	Accept a TCP socket connection.  This is called by
- *	SocketEventProc and it in turns calls the registered accept
- *	procedure.
+ *
+ *	Accept a TCP socket connection. This is called by SocketEventProc and
+ *	it in turns calls the registered accept function.
  *
  * Results:
  *	None.
@@ -1596,8 +1582,8 @@ TcpAccept(infoPtr)
     SOCKADDR_IN addr;
     int len;
     char channelName[16 + TCL_INTEGER_SPACE];
-    ThreadSpecificData *tsdPtr = 
-	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
+	    TclThreadDataKeyGet(&dataKey);
 
     /*
      * Accept the incoming connection request.
@@ -1610,8 +1596,8 @@ TcpAccept(infoPtr)
 
     /*
      * Clear the ready mask so we can detect the next connection request.
-     * Note that connection requests are level triggered, so if there is
-     * a request already pending, a new event will be generated.
+     * Note that connection requests are level triggered, so if there is a
+     * request already pending, a new event will be generated.
      */
 
     if (newSocket == INVALID_SOCKET) {
@@ -1622,7 +1608,7 @@ TcpAccept(infoPtr)
 
     /*
      * It is possible that more than one FD_ACCEPT has been sent, so an extra
-     * count must be kept.  Decrement the count, and reset the readyEvent bit
+     * count must be kept. Decrement the count, and reset the readyEvent bit
      * if the count is no longer > 0.
      */
 
@@ -1633,11 +1619,11 @@ TcpAccept(infoPtr)
     }
 
     /*
-     * Win-NT has a misfeature that sockets are inherited in child
-     * processes by default.  Turn off the inherit bit.
+     * Win-NT has a misfeature that sockets are inherited in child processes
+     * by default. Turn off the inherit bit.
      */
 
-    SetHandleInformation( (HANDLE) newSocket, HANDLE_FLAG_INHERIT, 0 );
+    SetHandleInformation((HANDLE) newSocket, HANDLE_FLAG_INHERIT, 0);
 
     /*
      * Add this socket to the global list of sockets.
@@ -1668,12 +1654,11 @@ TcpAccept(infoPtr)
     }
 
     /*
-     * Invoke the accept callback procedure.
+     * Invoke the accept callback function.
      */
 
     if (infoPtr->acceptProc != NULL) {
-	(infoPtr->acceptProc) (infoPtr->acceptProcData,
-		newInfoPtr->channel,
+	(infoPtr->acceptProc) (infoPtr->acceptProcData, newInfoPtr->channel,
 		winSock.inet_ntoa(addr.sin_addr),
 		winSock.ntohs(addr.sin_port));
     }
@@ -1684,8 +1669,8 @@ TcpAccept(infoPtr)
  *
  * TcpInputProc --
  *
- *	This procedure is called by the generic IO level to read data from
- *	a socket based channel.
+ *	This function is called by the generic IO level to read data from a
+ *	socket based channel.
  *
  * Results:
  *	The number of bytes read or -1 on error.
@@ -1698,34 +1683,33 @@ TcpAccept(infoPtr)
 
 static int
 TcpInputProc(instanceData, buf, toRead, errorCodePtr)
-    ClientData instanceData;		/* The socket state. */
-    char *buf;				/* Where to store data. */
-    int toRead;				/* Maximum number of bytes to read. */
-    int *errorCodePtr;			/* Where to store error codes. */
+    ClientData instanceData;	/* The socket state. */
+    char *buf;			/* Where to store data. */
+    int toRead;			/* Maximum number of bytes to read. */
+    int *errorCodePtr;		/* Where to store error codes. */
 {
     SocketInfo *infoPtr = (SocketInfo *) instanceData;
     int bytesRead;
     DWORD error;
-    ThreadSpecificData *tsdPtr = 
+    ThreadSpecificData *tsdPtr =
 	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
-    
+
     *errorCodePtr = 0;
 
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
-        *errorCodePtr = EFAULT;
-        return -1;
+	*errorCodePtr = EFAULT;
+	return -1;
     }
 
     /*
-     * First check to see if EOF was already detected, to prevent
-     * calling the socket stack after the first time EOF is detected.
+     * First check to see if EOF was already detected, to prevent calling the
+     * socket stack after the first time EOF is detected.
      */
 
     if (infoPtr->flags & SOCKET_EOF) {
@@ -1740,13 +1724,13 @@ TcpInputProc(instanceData, buf, toRead, errorCodePtr)
 	    && ! WaitForSocketEvent(infoPtr,  FD_CONNECT, errorCodePtr)) {
 	return -1;
     }
-    
+
     /*
-     * No EOF, and it is connected, so try to read more from the socket.
-     * Note that we clear the FD_READ bit because read events are level
-     * triggered so a new event will be generated if there is still data
-     * available to be read.  We have to simulate blocking behavior here
-     * since we are always using non-blocking sockets.
+     * No EOF, and it is connected, so try to read more from the socket. Note
+     * that we clear the FD_READ bit because read events are level triggered
+     * so a new event will be generated if there is still data available to be
+     * read. We have to simulate blocking behavior here since we are always
+     * using non-blocking sockets.
      */
 
     while (1) {
@@ -1754,33 +1738,33 @@ TcpInputProc(instanceData, buf, toRead, errorCodePtr)
 		(WPARAM) UNSELECT, (LPARAM) infoPtr);
 	bytesRead = winSock.recv(infoPtr->socket, buf, toRead, 0);
 	infoPtr->readyEvents &= ~(FD_READ);
-  
+
 	/*
 	 * Check for end-of-file condition or successful read.
 	 */
-  
+
 	if (bytesRead == 0) {
 	    infoPtr->flags |= SOCKET_EOF;
 	}
 	if (bytesRead != SOCKET_ERROR) {
 	    break;
 	}
-  
+
 	/*
-	 * If an error occurs after the FD_CLOSE has arrived,
-	 * then ignore the error and report an EOF.
+	 * If an error occurs after the FD_CLOSE has arrived, then ignore the
+	 * error and report an EOF.
 	 */
-  
+
 	if (infoPtr->readyEvents & FD_CLOSE) {
 	    infoPtr->flags |= SOCKET_EOF;
 	    bytesRead = 0;
 	    break;
 	}
-  
+
 	/*
 	 * Check for error condition or underflow in non-blocking case.
 	 */
-  
+
 	error = winSock.WSAGetLastError();
 	if ((infoPtr->flags & SOCKET_ASYNC) || (error != WSAEWOULDBLOCK)) {
 	    TclWinConvertWSAError(error);
@@ -1790,19 +1774,19 @@ TcpInputProc(instanceData, buf, toRead, errorCodePtr)
 	}
 
 	/*
-	 * In the blocking case, wait until the file becomes readable
-	 * or closed and try again.
+	 * In the blocking case, wait until the file becomes readable or
+	 * closed and try again.
 	 */
 
 	if (!WaitForSocketEvent(infoPtr, FD_READ|FD_CLOSE, errorCodePtr)) {
 	    bytesRead = -1;
 	    break;
-  	}
+	}
     }
-    
+
     SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
 	    (WPARAM) SELECT, (LPARAM) infoPtr);
-    
+
     return bytesRead;
 }
 
@@ -1811,8 +1795,8 @@ TcpInputProc(instanceData, buf, toRead, errorCodePtr)
  *
  * TcpOutputProc --
  *
- *	This procedure is called by the generic IO level to write data
- *	to a socket based channel.
+ *	This function is called by the generic IO level to write data to a
+ *	socket based channel.
  *
  * Results:
  *	The number of bytes written or -1 on failure.
@@ -1825,35 +1809,34 @@ TcpInputProc(instanceData, buf, toRead, errorCodePtr)
 
 static int
 TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)
-    ClientData instanceData;		/* The socket state. */
-    CONST char *buf;			/* Where to get data. */
-    int toWrite;			/* Maximum number of bytes to write. */
-    int *errorCodePtr;			/* Where to store error codes. */
+    ClientData instanceData;	/* The socket state. */
+    CONST char *buf;		/* Where to get data. */
+    int toWrite;		/* Maximum number of bytes to write. */
+    int *errorCodePtr;		/* Where to store error codes. */
 {
     SocketInfo *infoPtr = (SocketInfo *) instanceData;
     int bytesWritten;
     DWORD error;
-    ThreadSpecificData *tsdPtr = 
+    ThreadSpecificData *tsdPtr =
 	(ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
 
     *errorCodePtr = 0;
 
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
-        *errorCodePtr = EFAULT;
-        return -1;
+	*errorCodePtr = EFAULT;
+	return -1;
     }
 
     /*
      * Check to see if the socket is connected before trying to write.
      */
-    
+
     if ((infoPtr->flags & SOCKET_ASYNC_CONNECT)
 	    && ! WaitForSocketEvent(infoPtr,  FD_CONNECT, errorCodePtr)) {
 	return -1;
@@ -1866,22 +1849,22 @@ TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)
 	bytesWritten = winSock.send(infoPtr->socket, buf, toWrite, 0);
 	if (bytesWritten != SOCKET_ERROR) {
 	    /*
-	     * Since Windows won't generate a new write event until we hit
-	     * an overflow condition, we need to force the event loop to
-	     * poll until the condition changes.
+	     * Since Windows won't generate a new write event until we hit an
+	     * overflow condition, we need to force the event loop to poll
+	     * until the condition changes.
 	     */
 
 	    if (infoPtr->watchEvents & FD_WRITE) {
 		Tcl_Time blockTime = { 0, 0 };
 		Tcl_SetMaxBlockTime(&blockTime);
-	    }		
+	    }
 	    break;
 	}
-	
+
 	/*
-	 * Check for error condition or overflow.  In the event of overflow, we
+	 * Check for error condition or overflow. In the event of overflow, we
 	 * need to clear the FD_WRITE flag so we can detect the next writable
-	 * event.  Note that Windows only sends a new writable event after a
+	 * event. Note that Windows only sends a new writable event after a
 	 * send fails with WSAEWOULDBLOCK.
 	 */
 
@@ -1892,7 +1875,7 @@ TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)
 		*errorCodePtr = EWOULDBLOCK;
 		bytesWritten = -1;
 		break;
-	    } 
+	    }
 	} else {
 	    TclWinConvertWSAError(error);
 	    *errorCodePtr = Tcl_GetErrno();
@@ -1901,8 +1884,8 @@ TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)
 	}
 
 	/*
-	 * In the blocking case, wait until the file becomes writable
-	 * or closed and try again.
+	 * In the blocking case, wait until the file becomes writable or
+	 * closed and try again.
 	 */
 
 	if (!WaitForSocketEvent(infoPtr, FD_WRITE|FD_CLOSE, errorCodePtr)) {
@@ -1913,7 +1896,7 @@ TcpOutputProc(instanceData, buf, toWrite, errorCodePtr)
 
     SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
 	    (WPARAM) SELECT, (LPARAM) infoPtr);
-    
+
     return bytesWritten;
 }
 
@@ -1947,17 +1930,16 @@ TcpSetOptionProc (
     int boolVar, rtn;
 */
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
 	if (interp) {
 	    Tcl_AppendResult(interp, "winsock is not initialized", NULL);
 	}
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
 
     infoPtr = (SocketInfo *) instanceData;
@@ -2009,15 +1991,14 @@ TcpSetOptionProc (
  *
  * TcpGetOptionProc --
  *
- *	Computes an option value for a TCP socket based channel, or a
- *	list of all options and their values.
+ *	Computes an option value for a TCP socket based channel, or a list of
+ *	all options and their values.
  *
  *	Note: This code is based on code contributed by John Haxby.
  *
  * Results:
- *	A standard Tcl result. The value of the specified option or a
- *	list of all options and	their values is returned in the
- *	supplied DString.
+ *	A standard Tcl result. The value of the specified option or a list of
+ *	all options and their values is returned in the supplied DString.
  *
  * Side effects:
  *	None.
@@ -2027,14 +2008,13 @@ TcpSetOptionProc (
 
 static int
 TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
-    ClientData instanceData;		/* Socket state. */
-    Tcl_Interp *interp;                 /* For error reporting - can be NULL */
-    CONST char *optionName;		/* Name of the option to
-                                         * retrieve the value for, or
-                                         * NULL to get all options and
-                                         * their values. */
-    Tcl_DString *dsPtr;			/* Where to store the computed
-                                         * value; initialized by caller. */
+    ClientData instanceData;	/* Socket state. */
+    Tcl_Interp *interp;		/* For error reporting - can be NULL */
+    CONST char *optionName;	/* Name of the option to retrieve the value
+				 * for, or NULL to get all options and their
+				 * values. */
+    Tcl_DString *dsPtr;		/* Where to store the computed value;
+				 * initialized by caller. */
 {
     SocketInfo *infoPtr;
     SOCKADDR_IN sockname;
@@ -2046,23 +2026,22 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
     char buf[TCL_INTEGER_SPACE];
 
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
 	if (interp) {
 	    Tcl_AppendResult(interp, "winsock is not initialized", NULL);
 	}
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
-    
+
     infoPtr = (SocketInfo *) instanceData;
     sock = (int) infoPtr->socket;
     if (optionName != (char *) NULL) {
-        len = strlen(optionName);
+	len = strlen(optionName);
     }
 
     if ((len > 1) && (optionName[1] == 'e') &&
@@ -2070,7 +2049,7 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
 	int optlen;
 	DWORD err;
 	int ret;
-    
+
 	optlen = sizeof(int);
 	ret = TclWinGetSockOpt(sock, SOL_SOCKET, SO_ERROR,
 		(char *)&err, &optlen);
@@ -2084,94 +2063,89 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
 	return TCL_OK;
     }
 
-    if ((len == 0) ||
-            ((len > 1) && (optionName[1] == 'p') &&
-                    (strncmp(optionName, "-peername", len) == 0))) {
-        if (winSock.getpeername(sock, (LPSOCKADDR) &peername, &size)
-                == 0) {
-            if (len == 0) {
-                Tcl_DStringAppendElement(dsPtr, "-peername");
-                Tcl_DStringStartSublist(dsPtr);
-            }
-            Tcl_DStringAppendElement(dsPtr,
-                    winSock.inet_ntoa(peername.sin_addr));
+    if ((len == 0) || ((len > 1) && (optionName[1] == 'p') &&
+	    (strncmp(optionName, "-peername", len) == 0))) {
+	if (winSock.getpeername(sock, (LPSOCKADDR) &peername, &size) == 0) {
+	    if (len == 0) {
+		Tcl_DStringAppendElement(dsPtr, "-peername");
+		Tcl_DStringStartSublist(dsPtr);
+	    }
+	    Tcl_DStringAppendElement(dsPtr,
+		    winSock.inet_ntoa(peername.sin_addr));
 
 	    if (peername.sin_addr.s_addr == 0) {
-	        hostEntPtr = (struct hostent *) NULL;
+		hostEntPtr = (struct hostent *) NULL;
 	    } else {
-	        hostEntPtr = winSock.gethostbyaddr(
-                    (char *) &(peername.sin_addr), sizeof(peername.sin_addr),
-		    AF_INET);
+		hostEntPtr = winSock.gethostbyaddr(
+			(char *) &(peername.sin_addr),
+			sizeof(peername.sin_addr), AF_INET);
+	    }
+	    if (hostEntPtr != (struct hostent *) NULL) {
+		Tcl_DStringAppendElement(dsPtr, hostEntPtr->h_name);
+	    } else {
+		Tcl_DStringAppendElement(dsPtr,
+			winSock.inet_ntoa(peername.sin_addr));
 	    }
-            if (hostEntPtr != (struct hostent *) NULL) {
-                Tcl_DStringAppendElement(dsPtr, hostEntPtr->h_name);
-            } else {
-                Tcl_DStringAppendElement(dsPtr,
-                        winSock.inet_ntoa(peername.sin_addr));
-            }
 	    TclFormatInt(buf, winSock.ntohs(peername.sin_port));
-            Tcl_DStringAppendElement(dsPtr, buf);
-            if (len == 0) {
-                Tcl_DStringEndSublist(dsPtr);
-            } else {
-                return TCL_OK;
-            }
-        } else {
-            /*
-             * getpeername failed - but if we were asked for all the options
-             * (len==0), don't flag an error at that point because it could
-             * be an fconfigure request on a server socket. (which have
-             * no peer). {copied from unix/tclUnixChan.c}
-             */
-            if (len) {
+	    Tcl_DStringAppendElement(dsPtr, buf);
+	    if (len == 0) {
+		Tcl_DStringEndSublist(dsPtr);
+	    } else {
+		return TCL_OK;
+	    }
+	} else {
+	    /*
+	     * getpeername failed - but if we were asked for all the options
+	     * (len==0), don't flag an error at that point because it could be
+	     * an fconfigure request on a server socket (which have no peer).
+	     * {Copied from unix/tclUnixChan.c}
+	     */
+
+	    if (len) {
 		TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
-                if (interp) {
-                    Tcl_AppendResult(interp, "can't get peername: ",
-                                     Tcl_PosixError(interp),
-                                     (char *) NULL);
-                }
-                return TCL_ERROR;
-            }
-        }
-    }
-
-    if ((len == 0) ||
-            ((len > 1) && (optionName[1] == 's') &&
-                    (strncmp(optionName, "-sockname", len) == 0))) {
-        if (winSock.getsockname(sock, (LPSOCKADDR) &sockname, &size)
-                == 0) {
-            if (len == 0) {
-                Tcl_DStringAppendElement(dsPtr, "-sockname");
-                Tcl_DStringStartSublist(dsPtr);
-            }
-            Tcl_DStringAppendElement(dsPtr,
-                    winSock.inet_ntoa(sockname.sin_addr));
+		if (interp) {
+		    Tcl_AppendResult(interp, "can't get peername: ",
+			    Tcl_PosixError(interp), (char *) NULL);
+		}
+		return TCL_ERROR;
+	    }
+	}
+    }
+
+    if ((len == 0) || ((len > 1) && (optionName[1] == 's') &&
+	    (strncmp(optionName, "-sockname", len) == 0))) {
+	if (winSock.getsockname(sock, (LPSOCKADDR) &sockname, &size) == 0) {
+	    if (len == 0) {
+		Tcl_DStringAppendElement(dsPtr, "-sockname");
+		Tcl_DStringStartSublist(dsPtr);
+	    }
+	    Tcl_DStringAppendElement(dsPtr,
+		    winSock.inet_ntoa(sockname.sin_addr));
 	    if (sockname.sin_addr.s_addr == 0) {
-	        hostEntPtr = (struct hostent *) NULL;
+		hostEntPtr = (struct hostent *) NULL;
 	    } else {
-	        hostEntPtr = winSock.gethostbyaddr(
-                    (char *) &(sockname.sin_addr), sizeof(peername.sin_addr),
-		    AF_INET);
+		hostEntPtr = winSock.gethostbyaddr(
+			(char *) &(sockname.sin_addr),
+			sizeof(peername.sin_addr), AF_INET);
 	    }
-            if (hostEntPtr != (struct hostent *) NULL) {
-                Tcl_DStringAppendElement(dsPtr, hostEntPtr->h_name);
-            } else {
-                Tcl_DStringAppendElement(dsPtr,
-                        winSock.inet_ntoa(sockname.sin_addr));
-            }
-            TclFormatInt(buf, winSock.ntohs(sockname.sin_port));
-            Tcl_DStringAppendElement(dsPtr, buf);
-            if (len == 0) {
-                Tcl_DStringEndSublist(dsPtr);
-            } else {
-                return TCL_OK;
-            }
-        } else {
+	    if (hostEntPtr != (struct hostent *) NULL) {
+		Tcl_DStringAppendElement(dsPtr, hostEntPtr->h_name);
+	    } else {
+		Tcl_DStringAppendElement(dsPtr,
+			winSock.inet_ntoa(sockname.sin_addr));
+	    }
+	    TclFormatInt(buf, winSock.ntohs(sockname.sin_port));
+	    Tcl_DStringAppendElement(dsPtr, buf);
+	    if (len == 0) {
+		Tcl_DStringEndSublist(dsPtr);
+	    } else {
+		return TCL_OK;
+	    }
+	} else {
 	    if (interp) {
 		TclWinConvertWSAError((DWORD) winSock.WSAGetLastError());
 		Tcl_AppendResult(interp, "can't get sockname: ",
-				 Tcl_PosixError(interp),
-				 (char *) NULL);
+			Tcl_PosixError(interp), (char *) NULL);
 	    }
 	    return TCL_ERROR;
 	}
@@ -2181,10 +2155,10 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
     if (len == 0 || !strncmp(optionName, "-keepalive", len)) {
 	int optlen;
 	BOOL opt = FALSE;
-    
-        if (len == 0) {
-            Tcl_DStringAppendElement(dsPtr, "-keepalive");
-        }
+
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-keepalive");
+	}
 	optlen = sizeof(BOOL);
 	winSock.getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&opt,
 		&optlen);
@@ -2201,10 +2175,10 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
     if (len == 0 || !strncmp(optionName, "-nagle", len)) {
 	int optlen;
 	BOOL opt = FALSE;
-    
-        if (len == 0) {
-            Tcl_DStringAppendElement(dsPtr, "-nagle");
-        }
+
+	if (len == 0) {
+	    Tcl_DStringAppendElement(dsPtr, "-nagle");
+	}
 	optlen = sizeof(BOOL);
 	winSock.getsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&opt,
 		&optlen);
@@ -2220,8 +2194,8 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
 */
 
     if (len > 0) {
-        /*return Tcl_BadChannelOption(interp, optionName, "peername sockname keepalive nagle");*/
-        return Tcl_BadChannelOption(interp, optionName, "peername sockname");
+	/*return Tcl_BadChannelOption(interp, optionName, "peername sockname keepalive nagle");*/
+	return Tcl_BadChannelOption(interp, optionName, "peername sockname");
     }
 
     return TCL_OK;
@@ -2232,45 +2206,45 @@ TcpGetOptionProc(instanceData, interp, optionName, dsPtr)
  *
  * TcpWatchProc --
  *
- *	Informs the channel driver of the events that the generic
- *	channel code wishes to receive on this socket.
+ *	Informs the channel driver of the events that the generic channel code
+ *	wishes to receive on this socket.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	May cause the notifier to poll if any of the specified 
- *	conditions are already true.
+ *	May cause the notifier to poll if any of the specified conditions are
+ *	already true.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 TcpWatchProc(instanceData, mask)
-    ClientData instanceData;		/* The socket state. */
-    int mask;				/* Events of interest; an OR-ed
-                                         * combination of TCL_READABLE,
-                                         * TCL_WRITABLE and TCL_EXCEPTION. */
+    ClientData instanceData;	/* The socket state. */
+    int mask;			/* Events of interest; an OR-ed combination of
+				 * TCL_READABLE, TCL_WRITABLE and
+				 * TCL_EXCEPTION. */
 {
     SocketInfo *infoPtr = (SocketInfo *) instanceData;
-    
+
     /*
-     * Update the watch events mask. Only if the socket is not a
-     * server socket. Fix for SF Tcl Bug #557878.
+     * Update the watch events mask. Only if the socket is not a server
+     * socket. Fix for SF Tcl Bug #557878.
      */
 
-    if (!infoPtr->acceptProc) {    
-        infoPtr->watchEvents = 0;
+    if (!infoPtr->acceptProc) {
+	infoPtr->watchEvents = 0;
 	if (mask & TCL_READABLE) {
 	    infoPtr->watchEvents |= (FD_READ|FD_CLOSE|FD_ACCEPT);
 	}
 	if (mask & TCL_WRITABLE) {
 	    infoPtr->watchEvents |= (FD_WRITE|FD_CLOSE|FD_CONNECT);
 	}
-      
+
 	/*
-	 * If there are any conditions already set, then tell the notifier to poll
-	 * rather than block.
+	 * If there are any conditions already set, then tell the notifier to
+	 * poll rather than block.
 	 */
 
 	if (infoPtr->readyEvents & infoPtr->watchEvents) {
@@ -2331,16 +2305,16 @@ SocketThread(LPVOID arg)
     MSG msg;
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)(arg);
 
-    tsdPtr->hwnd = CreateWindow("TclSocket", "TclSocket", 
+    tsdPtr->hwnd = CreateWindow("TclSocket", "TclSocket",
 	    WS_TILED, 0, 0, 0, 0, NULL, NULL, windowClass.hInstance, arg);
 
     /*
-     * Signal the main thread that the window has been created
-     * and that the socket thread is ready to go.
+     * Signal the main thread that the window has been created and that the
+     * socket thread is ready to go.
      */
-    
+
     SetEvent(tsdPtr->readyEvent);
-    
+
     if (tsdPtr->hwnd == NULL) {
 	return 1;
     }
@@ -2362,16 +2336,15 @@ SocketThread(LPVOID arg)
  *
  * SocketProc --
  *
- *	This function is called when WSAAsyncSelect has been used
- *	to register interest in a socket event, and the event has
- *	occurred.
+ *	This function is called when WSAAsyncSelect has been used to register
+ *	interest in a socket event, and the event has occurred.
  *
  * Results:
  *	0 on success.
  *
  * Side effects:
- *	The flags for the given socket are updated to reflect the
- *	event that occured.
+ *	The flags for the given socket are updated to reflect the event that
+ *	occured.
  *
  *----------------------------------------------------------------------
  */
@@ -2394,120 +2367,117 @@ SocketProc(hwnd, message, wParam, lParam)
 #endif
 
     switch (message) {
+    default:
+	return DefWindowProc(hwnd, message, wParam, lParam);
+	break;
 
-	default:
-	    return DefWindowProc(hwnd, message, wParam, lParam);
-	    break;
-
-	case WM_CREATE:
-	    /*
-	     * store the initial tsdPtr, it's from a different thread, so it's
-	     * not directly accessible, but needed.
-	     */
+    case WM_CREATE:
+	/*
+	 * store the initial tsdPtr, it's from a different thread, so it's not
+	 * directly accessible, but needed.
+	 */
 
 #ifdef _WIN64
-	    SetWindowLongPtr(hwnd, GWLP_USERDATA,
-		    (LONG_PTR) ((LPCREATESTRUCT)lParam)->lpCreateParams);
+	SetWindowLongPtr(hwnd, GWLP_USERDATA,
+		(LONG_PTR) ((LPCREATESTRUCT)lParam)->lpCreateParams);
 #else
-	    SetWindowLong(hwnd, GWL_USERDATA,
-		    (LONG) ((LPCREATESTRUCT)lParam)->lpCreateParams);
+	SetWindowLong(hwnd, GWL_USERDATA,
+		(LONG) ((LPCREATESTRUCT)lParam)->lpCreateParams);
 #endif
-	    break;
+	break;
 
-	case WM_DESTROY:
-	    PostQuitMessage(0);
-	    break;
+    case WM_DESTROY:
+	PostQuitMessage(0);
+	break;
 
-	case SOCKET_MESSAGE:
-	    event = WSAGETSELECTEVENT(lParam);
-	    error = WSAGETSELECTERROR(lParam);
-	    socket = (SOCKET) wParam;
+    case SOCKET_MESSAGE:
+	event = WSAGETSELECTEVENT(lParam);
+	error = WSAGETSELECTERROR(lParam);
+	socket = (SOCKET) wParam;
 
-	    /*
-	     * Find the specified socket on the socket list and update its
-	     * eventState flag.
-	     */
+	/*
+	 * Find the specified socket on the socket list and update its
+	 * eventState flag.
+	 */
+
+	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
+	for (infoPtr = tsdPtr->socketList; infoPtr != NULL;
+		infoPtr = infoPtr->nextPtr) {
+	    if (infoPtr->socket == socket) {
+		/*
+		 * Update the socket state.
+		 */
+
+		/*
+		 * A count of FD_ACCEPTS is stored, so if an FD_CLOSE event
+		 * happens, then clear the FD_ACCEPT count. Otherwise,
+		 * increment the count if the current event is an FD_ACCEPT.
+		 */
 
-	    WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
-	    for (infoPtr = tsdPtr->socketList; infoPtr != NULL; 
-		 infoPtr = infoPtr->nextPtr) {
-		if (infoPtr->socket == socket) {
+		if (event & FD_CLOSE) {
+		    infoPtr->acceptEventCount = 0;
+		    infoPtr->readyEvents &= ~(FD_WRITE|FD_ACCEPT);
+		} else if (event & FD_ACCEPT) {
+		    infoPtr->acceptEventCount++;
+		}
+
+		if (event & FD_CONNECT) {
 		    /*
-		     * Update the socket state.
+		     * The socket is now connected, clear the async connect
+		     * flag.
 		     */
 
+		    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
+
 		    /*
-		     * A count of FD_ACCEPTS is stored, so if an FD_CLOSE
-		     * event happens, then clear the FD_ACCEPT count.
-		     * Otherwise, increment the count if the current
-		     * event is an FD_ACCEPT.
+		     * Remember any error that occurred so we can report
+		     * connection failures.
 		     */
 
-		    if (event & FD_CLOSE) {
-			infoPtr->acceptEventCount = 0;
-			infoPtr->readyEvents &= ~(FD_WRITE|FD_ACCEPT);
-		    } else if (event & FD_ACCEPT) {
-			infoPtr->acceptEventCount++;
+		    if (error != ERROR_SUCCESS) {
+			TclWinConvertWSAError((DWORD) error);
+			infoPtr->lastError = Tcl_GetErrno();
 		    }
+		}
 
-		    if (event & FD_CONNECT) {
-			/*
-			 * The socket is now connected,
-			 * clear the async connect flag.
-			 */
-
-			infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
-
-			/*
-			 * Remember any error that occurred so we can report
-			 * connection failures.
-			 */
-
-			if (error != ERROR_SUCCESS) {
-			    TclWinConvertWSAError((DWORD) error);
-			    infoPtr->lastError = Tcl_GetErrno();
-			}
-
-		    } 
-		    if (infoPtr->flags & SOCKET_ASYNC_CONNECT) {
-			infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
-			if (error != ERROR_SUCCESS) {
-			    TclWinConvertWSAError((DWORD) error);
-			    infoPtr->lastError = Tcl_GetErrno();
-			}
-			infoPtr->readyEvents |= FD_WRITE;
+		if (infoPtr->flags & SOCKET_ASYNC_CONNECT) {
+		    infoPtr->flags &= ~(SOCKET_ASYNC_CONNECT);
+		    if (error != ERROR_SUCCESS) {
+			TclWinConvertWSAError((DWORD) error);
+			infoPtr->lastError = Tcl_GetErrno();
 		    }
-		    infoPtr->readyEvents |= event;
-
-		    /*
-		     * Wake up the Main Thread.
-		     */
-		    SetEvent(tsdPtr->readyEvent);
-		    Tcl_ThreadAlert(tsdPtr->threadId);
-		    break;
+		    infoPtr->readyEvents |= FD_WRITE;
 		}
-	    }
-	    SetEvent(tsdPtr->socketListLock);
-	    break;
-
-	case SOCKET_SELECT:
-	    infoPtr = (SocketInfo *) lParam;
-	    if (wParam == SELECT) {
+		infoPtr->readyEvents |= event;
 
-		winSock.WSAAsyncSelect(infoPtr->socket, hwnd,
-			SOCKET_MESSAGE, infoPtr->selectEvents);
-	    } else {
 		/*
-		 * Clear the selection mask
+		 * Wake up the Main Thread.
 		 */
-
-		winSock.WSAAsyncSelect(infoPtr->socket, hwnd, 0, 0);
+		SetEvent(tsdPtr->readyEvent);
+		Tcl_ThreadAlert(tsdPtr->threadId);
+		break;
 	    }
-	    break;
+	}
+	SetEvent(tsdPtr->socketListLock);
+	break;
 
-	case SOCKET_TERMINATE:
-	    DestroyWindow(hwnd);
-	    break;
+    case SOCKET_SELECT:
+	infoPtr = (SocketInfo *) lParam;
+	if (wParam == SELECT) {
+	    winSock.WSAAsyncSelect(infoPtr->socket, hwnd,
+		    SOCKET_MESSAGE, infoPtr->selectEvents);
+	} else {
+	    /*
+	     * Clear the selection mask
+	     */
+
+	    winSock.WSAAsyncSelect(infoPtr->socket, hwnd, 0, 0);
+	}
+	break;
+
+    case SOCKET_TERMINATE:
+	DestroyWindow(hwnd);
+	break;
     }
 
     return 0;
@@ -2521,8 +2491,8 @@ SocketProc(hwnd, message, wParam, lParam)
  *	Returns the name of the local host.
  *
  * Results:
- *	A string containing the network name for this machine.
- *	The caller must not modify or free this string.
+ *	A string containing the network name for this machine. The caller must
+ *	not modify or free this string.
  *
  * Side effects:
  *	Caches the name to return for future calls.
@@ -2541,11 +2511,11 @@ Tcl_GetHostName()
  *
  * 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.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
@@ -2564,21 +2534,25 @@ InitializeHostName(valuePtr, lengthPtr, encodingPtr)
 	/*
 	 * Convert string from native to UTF then change to lowercase.
 	 */
+
 	Tcl_UtfToLower(Tcl_WinTCharToUtf((TCHAR *) wbuf, -1, &ds));
+
     } else if (TclpHasSockets(NULL) == TCL_OK) {
 	/*
-	 * Buffer length of 255 copied slavishly from previous version
-	 * of this routine.  Presumably there's a more "correct" macro
-	 * value for a properly sized buffer for a gethostname() call.
-	 * Maintainers are welcome to supply it.
+	 * Buffer length of 255 copied slavishly from previous version of this
+	 * routine. Presumably there's a more "correct" macro value for a
+	 * properly sized buffer for a gethostname() call. Maintainers are
+	 * welcome to supply it.
 	 */
+
 	Tcl_DStringInit(&ds);
 	Tcl_DStringSetLength(&ds, 255);
-	if (winSock.gethostname(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds))
-		== 0) {
+	if (winSock.gethostname(Tcl_DStringValue(&ds),
+		Tcl_DStringLength(&ds)) == 0) {
 	    Tcl_DStringSetLength(&ds, 0);
 	}
     }
+
     *encodingPtr = Tcl_GetEncoding(NULL, "utf-8");
     *lengthPtr = Tcl_DStringLength(&ds);
     *valuePtr = ckalloc((unsigned int) (*lengthPtr)+1);
@@ -2592,10 +2566,10 @@ InitializeHostName(valuePtr, lengthPtr, encodingPtr)
  *
  * TclWinGetSockOpt, et al. --
  *
- *	These functions are wrappers that let us bind the WinSock
- *	API dynamically so we can run on systems that don't have
- *	the wsock32.dll.  We need wrappers for these interfaces
- *	because they are called from the generic Tcl code.
+ *	These functions are wrappers that let us bind the WinSock API
+ *	dynamically so we can run on systems that don't have the wsock32.dll.
+ *	We need wrappers for these interfaces because they are called from the
+ *	generic Tcl code.
  *
  * Results:
  *	As defined for each function.
@@ -2611,16 +2585,15 @@ TclWinGetSockOpt(SOCKET s, int level, int optname, char * optval,
 	int FAR *optlen)
 {
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
-        return SOCKET_ERROR;
+	return SOCKET_ERROR;
     }
-    
+
     return winSock.getsockopt(s, level, optname, optval, optlen);
 }
 
@@ -2629,13 +2602,13 @@ TclWinSetSockOpt(SOCKET s, int level, int optname, const char * optval,
 	int optlen)
 {
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
+
     if (!SocketsEnabled()) {
-        return SOCKET_ERROR;
+	return SOCKET_ERROR;
     }
 
     return winSock.setsockopt(s, level, optname, optval, optlen);
@@ -2645,14 +2618,13 @@ u_short
 TclWinNToHS(u_short netshort)
 {
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
 
     if (!SocketsEnabled()) {
-        return (u_short) -1;
+	return (u_short) -1;
     }
 
     return winSock.ntohs(netshort);
@@ -2662,13 +2634,13 @@ struct servent *
 TclWinGetServByName(const char * name, const char * proto)
 {
     /*
-     * Check that WinSock is initialized; do not call it if not, to
-     * prevent system crashes. This can happen at exit time if the exit
-     * handler for WinSock ran before other exit handlers that want to
-     * use sockets.
+     * Check that WinSock is initialized; do not call it if not, to prevent
+     * system crashes. This can happen at exit time if the exit handler for
+     * WinSock ran before other exit handlers that want to use sockets.
      */
+
     if (!SocketsEnabled()) {
-        return (struct servent *) NULL;
+	return (struct servent *) NULL;
     }
 
     return winSock.getservbyname(name, proto);
@@ -2697,15 +2669,15 @@ TcpThreadActionProc (instanceData, action)
 {
     ThreadSpecificData *tsdPtr;
     SocketInfo *infoPtr = (SocketInfo *) instanceData;
-    int      notifyCmd;
+    int notifyCmd;
 
     if (action == TCL_CHANNEL_THREAD_INSERT) {
-        /*
-	 * Ensure that socket subsystem is initialized in this thread, or
-	 * else sockets will not work.
+	/*
+	 * Ensure that socket subsystem is initialized in this thread, or else
+	 * sockets will not work.
 	 */
 
-        Tcl_MutexLock(&socketMutex);
+	Tcl_MutexLock(&socketMutex);
 	InitSockets();
 	Tcl_MutexUnlock(&socketMutex);
 
@@ -2718,17 +2690,21 @@ TcpThreadActionProc (instanceData, action)
 
 	notifyCmd = SELECT;
     } else {
-        SocketInfo **nextPtrPtr;
+	SocketInfo **nextPtrPtr;
 	int removed = 0;
 
-	tsdPtr  = TCL_TSD_INIT(&dataKey);
+	tsdPtr	= TCL_TSD_INIT(&dataKey);
+
+	/*
+	 * TIP #218, Bugfix: All access to socketList has to be protected by
+	 * the lock.
+	 */
 
-	/* TIP #218, Bugfix: All access to socketList has to be protected by the lock */
 	WaitForSingleObject(tsdPtr->socketListLock, INFINITE);
 	for (nextPtrPtr = &(tsdPtr->socketList); (*nextPtrPtr) != NULL;
 	     nextPtrPtr = &((*nextPtrPtr)->nextPtr)) {
 	    if ((*nextPtrPtr) == infoPtr) {
-	        (*nextPtrPtr) = infoPtr->nextPtr;
+		(*nextPtrPtr) = infoPtr->nextPtr;
 		removed = 1;
 		break;
 	    }
@@ -2736,9 +2712,9 @@ TcpThreadActionProc (instanceData, action)
 	SetEvent(tsdPtr->socketListLock);
 
 	/*
-	 * This could happen if the channel was created in one thread
-	 * and then moved to another without updating the thread
-	 * local data in each thread.
+	 * This could happen if the channel was created in one thread and then
+	 * moved to another without updating the thread local data in each
+	 * thread.
 	 */
 
 	if (!removed) {
@@ -2749,9 +2725,18 @@ TcpThreadActionProc (instanceData, action)
     }
 
     /*
-     * Ensure that, or stop, notifications for the socket occur in this thread.
+     * Ensure that, or stop, notifications for the socket occur in this
+     * thread.
      */
 
     SendMessage(tsdPtr->hwnd, SOCKET_SELECT,
-		(WPARAM) notifyCmd, (LPARAM) infoPtr);
+	    (WPARAM) notifyCmd, (LPARAM) infoPtr);
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */