X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/bc4802a17ba16140386b06bbebbf053815d4ef9e..247308b5cf8a51eba882abf13c5572ba8f83d0ea:/winnet.c

diff --git a/winnet.c b/winnet.c
index b68846fa..73369f74 100644
--- a/winnet.c
+++ b/winnet.c
@@ -72,6 +72,7 @@ struct Socket_tag {
     char oobdata[1];
     int sending_oob;
     int oobinline;
+    int pending_error;		       /* in case send() returns error */
 };
 
 /*
@@ -123,6 +124,18 @@ void sk_init(void)
     sktree = newtree234(cmpfortree);
 }
 
+void sk_cleanup(void)
+{
+    Actual_Socket s;
+    int i;
+
+    if (sktree) {
+	for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
+	    closesocket(s->s);
+	}
+    }
+}
+
 char *winsock_error_string(int error)
 {
     switch (error) {
@@ -380,6 +393,9 @@ static void sk_tcp_flush(Socket s)
 static void sk_tcp_close(Socket s);
 static int sk_tcp_write(Socket s, char *data, int len);
 static int sk_tcp_write_oob(Socket s, char *data, int len);
+static void sk_tcp_set_private_ptr(Socket s, void *ptr);
+static void *sk_tcp_get_private_ptr(Socket s);
+static void sk_tcp_set_frozen(Socket s, int is_frozen);
 static char *sk_tcp_socket_error(Socket s);
 
 extern char *do_select(SOCKET skt, int startup);
@@ -392,6 +408,9 @@ Socket sk_register(void *sock, Plug plug)
 	sk_tcp_write,
 	sk_tcp_write_oob,
 	sk_tcp_flush,
+	sk_tcp_set_private_ptr,
+	sk_tcp_get_private_ptr,
+	sk_tcp_set_frozen,
 	sk_tcp_socket_error
     };
 
@@ -412,6 +431,7 @@ Socket sk_register(void *sock, Plug plug)
     ret->frozen = 1;
     ret->frozen_readable = 0;
     ret->localhost_only = 0;	       /* unused, but best init anyway */
+    ret->pending_error = 0;
 
     ret->s = (SOCKET)sock;
 
@@ -437,7 +457,7 @@ Socket sk_register(void *sock, Plug plug)
 }
 
 Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
-	      Plug plug)
+	      int nodelay, Plug plug)
 {
     static struct socket_function_table fn_table = {
 	sk_tcp_plug,
@@ -445,6 +465,9 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
 	sk_tcp_write,
 	sk_tcp_write_oob,
 	sk_tcp_flush,
+	sk_tcp_set_private_ptr,
+	sk_tcp_get_private_ptr,
+	sk_tcp_set_frozen,
 	sk_tcp_socket_error
     };
 
@@ -472,6 +495,7 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
     ret->frozen = 0;
     ret->frozen_readable = 0;
     ret->localhost_only = 0;	       /* unused, but best init anyway */
+    ret->pending_error = 0;
 
     /*
      * Open socket.
@@ -491,6 +515,11 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
 	setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b));
     }
 
+    if (nodelay) {
+	BOOL b = TRUE;
+	setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b));
+    }
+
     /*
      * Bind to local address.
      */
@@ -613,6 +642,9 @@ Socket sk_newlistener(int port, Plug plug, int local_host_only)
 	sk_tcp_write,
 	sk_tcp_write_oob,
 	sk_tcp_flush,
+	sk_tcp_set_private_ptr,
+	sk_tcp_get_private_ptr,
+	sk_tcp_set_frozen,
 	sk_tcp_socket_error
     };
 
@@ -640,6 +672,7 @@ Socket sk_newlistener(int port, Plug plug, int local_host_only)
     ret->frozen = 0;
     ret->frozen_readable = 0;
     ret->localhost_only = local_host_only;
+    ret->pending_error = 0;
 
     /*
      * Open socket.
@@ -768,32 +801,20 @@ void try_send(Actual_Socket s)
 	    } else if (nsent == 0 ||
 		       err == WSAECONNABORTED || err == WSAECONNRESET) {
 		/*
-		 * ASSUMPTION:
-		 * 
-		 * I'm assuming here that if a TCP connection is
-		 * reset or aborted once established, we will be
-		 * notified by a select event rather than a
-		 * CONNABORTED or CONNRESET from send(). In other
-		 * words, I'm assuming CONNABORTED and CONNRESET
-		 * don't come back from a _nonblocking_ send(),
-		 * because the local side doesn't know they've
-		 * happened until it waits for a response to its
-		 * TCP segment - so the error will arrive
-		 * asynchronously.
-		 * 
-		 * If I'm wrong, this will be a really nasty case,
-		 * because we can't necessarily call plug_closing()
-		 * without having to make half the SSH code
-		 * reentrant; so instead we'll have to schedule a
-		 * call to plug_closing() for some suitable future
-		 * time.
+		 * If send() returns CONNABORTED or CONNRESET, we
+		 * unfortunately can't just call plug_closing(),
+		 * because it's quite likely that we're currently
+		 * _in_ a call from the code we'd be calling back
+		 * to, so we'd have to make half the SSH code
+		 * reentrant. Instead we flag a pending error on
+		 * the socket, to be dealt with (by calling
+		 * plug_closing()) at some suitable future moment.
 		 */
-		fatalbox("SERIOUS NETWORK INTERNAL ERROR: %s\n"
-			 "Please report this immediately to "
-			 "<putty@projects.tartarus.org>.",
-			 winsock_error_string(err));
+		s->pending_error = err;
+		return;
 	    } else {
-		fatalbox(winsock_error_string(err));
+		logevent(winsock_error_string(err));
+		fatalbox("%s", winsock_error_string(err));
 	    }
 	} else {
 	    if (s->sending_oob) {
@@ -929,8 +950,10 @@ int select_result(WPARAM wParam, LPARAM lParam)
 	ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
 	noise_ultralight(ret);
 	if (ret <= 0) {
-	    fatalbox(ret == 0 ? "Internal networking trouble" :
-		     winsock_error_string(WSAGetLastError()));
+	    char *str = (ret == 0 ? "Internal networking trouble" :
+			 winsock_error_string(WSAGetLastError()));
+	    logevent(str);
+	    fatalbox("%s", str);
 	} else {
 	    return plug_receive(s->plug, 2, buf, ret);
 	}
@@ -973,7 +996,7 @@ int select_result(WPARAM wParam, LPARAM lParam)
 
 	    memset(&isa, 0, sizeof(struct sockaddr_in));
 	    err = 0;
-	    t = accept(s->s,&isa,&addrlen);
+	    t = accept(s->s,(struct sockaddr *)&isa,&addrlen);
 	    if (t == INVALID_SOCKET)
 	    {
 		err = WSAGetLastError();
@@ -994,16 +1017,54 @@ int select_result(WPARAM wParam, LPARAM lParam)
 }
 
 /*
+ * Deal with socket errors detected in try_send().
+ */
+void net_pending_errors(void)
+{
+    int i;
+    Actual_Socket s;
+
+    /*
+     * This might be a fiddly business, because it's just possible
+     * that handling a pending error on one socket might cause
+     * others to be closed. (I can't think of any reason this might
+     * happen in current SSH implementation, but to maintain
+     * generality of this network layer I'll assume the worst.)
+     * 
+     * So what we'll do is search the socket list for _one_ socket
+     * with a pending error, and then handle it, and then search
+     * the list again _from the beginning_. Repeat until we make a
+     * pass with no socket errors present. That way we are
+     * protected against the socket list changing under our feet.
+     */
+
+    do {
+	for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
+	    if (s->pending_error) {
+		/*
+		 * An error has occurred on this socket. Pass it to the
+		 * plug.
+		 */
+		plug_closing(s->plug,
+			     winsock_error_string(s->pending_error),
+			     s->pending_error, 0);
+		break;
+	    }
+	}
+    } while (s);
+}
+
+/*
  * Each socket abstraction contains a `void *' private field in
  * which the client can keep state.
  */
-void sk_set_private_ptr(Socket sock, void *ptr)
+static void sk_tcp_set_private_ptr(Socket sock, void *ptr)
 {
     Actual_Socket s = (Actual_Socket) sock;
     s->private_ptr = ptr;
 }
 
-void *sk_get_private_ptr(Socket sock)
+static void *sk_tcp_get_private_ptr(Socket sock)
 {
     Actual_Socket s = (Actual_Socket) sock;
     return s->private_ptr;
@@ -1024,7 +1085,7 @@ static char *sk_tcp_socket_error(Socket sock)
     return s->error;
 }
 
-void sk_set_frozen(Socket sock, int is_frozen)
+static void sk_tcp_set_frozen(Socket sock, int is_frozen)
 {
     Actual_Socket s = (Actual_Socket) sock;
     if (s->frozen == is_frozen)