X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/5471d09ad63fc6216fb9c2a3b52ca9c93821a054..68a49acbf3f96fbbbc385620655dcb577e62c328:/winnet.c

diff --git a/winnet.c b/winnet.c
index ee2fc3a6..430a47bb 100644
--- a/winnet.c
+++ b/winnet.c
@@ -63,13 +63,16 @@ struct Socket_tag {
     Plug plug;
     void *private_ptr;
     bufchain output_data;
+    int connected;
     int writable;
     int frozen; /* this causes readability notifications to be ignored */
     int frozen_readable; /* this means we missed at least one readability
 			  * notification while we were frozen */
+    int localhost_only;		       /* for listening sockets */
     char oobdata[1];
     int sending_oob;
     int oobinline;
+    int pending_error;		       /* in case send() returns error */
 };
 
 /*
@@ -121,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) {
@@ -338,6 +353,41 @@ SockAddr sk_namelookup(char *host, char **canonicalname)
     return ret;
 }
 
+void sk_getaddr(SockAddr addr, char *buf, int buflen)
+{
+#ifdef IPV6
+    if (addr->family == AF_INET) {
+#endif
+	struct in_addr a;
+	a.s_addr = htonl(addr->address);
+	strncpy(buf, inet_ntoa(a), buflen);
+#ifdef IPV6
+    } else {
+	FIXME; /* I don't know how to get a text form of an IPv6 address. */
+    }
+#endif
+}
+
+int sk_addrtype(SockAddr addr)
+{
+    return (addr->family == AF_INET ? ADDRTYPE_IPV4 : ADDRTYPE_IPV6);
+}
+
+void sk_addrcopy(SockAddr addr, char *buf)
+{
+#ifdef IPV6
+    if (addr->family == AF_INET) {
+#endif
+	struct in_addr a;
+	a.s_addr = htonl(addr->address);
+	memcpy(buf, (char*) &a.s_addr, 4);
+#ifdef IPV6
+    } else {
+	memcpy(buf, (char*) addr->ai, 16);
+    }
+#endif
+}
+
 void sk_addr_free(SockAddr addr)
 {
     sfree(addr);
@@ -363,6 +413,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);
@@ -375,6 +428,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
     };
 
@@ -394,6 +450,8 @@ Socket sk_register(void *sock, Plug plug)
     ret->sending_oob = 0;
     ret->frozen = 1;
     ret->frozen_readable = 0;
+    ret->localhost_only = 0;	       /* unused, but best init anyway */
+    ret->pending_error = 0;
 
     ret->s = (SOCKET)sock;
 
@@ -419,7 +477,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,
@@ -427,6 +485,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
     };
 
@@ -448,10 +509,13 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
     ret->error = NULL;
     ret->plug = plug;
     bufchain_init(&ret->output_data);
-    ret->writable = 1;		       /* to start with */
+    ret->connected = 0;		       /* to start with */
+    ret->writable = 0;		       /* to start with */
     ret->sending_oob = 0;
     ret->frozen = 0;
     ret->frozen_readable = 0;
+    ret->localhost_only = 0;	       /* unused, but best init anyway */
+    ret->pending_error = 0;
 
     /*
      * Open socket.
@@ -471,6 +535,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.
      */
@@ -543,6 +612,15 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
 	a.sin_addr.s_addr = htonl(addr->address);
 	a.sin_port = htons((short) port);
     }
+
+    /* Set up a select mechanism. This could be an AsyncSelect on a
+     * window, or an EventSelect on an event object. */
+    errstr = do_select(s, 1);
+    if (errstr) {
+	ret->error = errstr;
+	return (Socket) ret;
+    }
+
     if ((
 #ifdef IPV6
 	    connect(s, ((addr->family == AF_INET6) ?
@@ -553,16 +631,22 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
 #endif
 	) == SOCKET_ERROR) {
 	err = WSAGetLastError();
-	ret->error = winsock_error_string(err);
-	return (Socket) ret;
-    }
-
-    /* Set up a select mechanism. This could be an AsyncSelect on a
-     * window, or an EventSelect on an event object. */
-    errstr = do_select(s, 1);
-    if (errstr) {
-	ret->error = errstr;
-	return (Socket) ret;
+	/*
+	 * We expect a potential EWOULDBLOCK here, because the
+	 * chances are the front end has done a select for
+	 * FD_CONNECT, so that connect() will complete
+	 * asynchronously.
+	 */
+	if ( err != WSAEWOULDBLOCK ) {
+	    ret->error = winsock_error_string(err);
+	    return (Socket) ret;
+	}
+    } else {
+	/*
+	 * If we _don't_ get EWOULDBLOCK, the connect has completed
+	 * and we should set the socket as writable.
+	 */
+	ret->writable = 1;
     }
 
     add234(sktree, ret);
@@ -570,7 +654,7 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
     return (Socket) ret;
 }
 
-Socket sk_newlistenner(int port, Plug plug)
+Socket sk_newlistener(int port, Plug plug, int local_host_only)
 {
     static struct socket_function_table fn_table = {
 	sk_tcp_plug,
@@ -578,6 +662,9 @@ Socket sk_newlistenner(int port, 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
     };
 
@@ -604,6 +691,8 @@ Socket sk_newlistenner(int port, Plug plug)
     ret->sending_oob = 0;
     ret->frozen = 0;
     ret->frozen_readable = 0;
+    ret->localhost_only = local_host_only;
+    ret->pending_error = 0;
 
     /*
      * Open socket.
@@ -627,13 +716,19 @@ Socket sk_newlistenner(int port, Plug plug)
 	if (addr->family == AF_INET6) {
 	    memset(&a6, 0, sizeof(a6));
 	    a6.sin6_family = AF_INET6;
-/*a6.sin6_addr      = in6addr_any; *//* == 0 */
+	    if (local_host_only)
+		a6.sin6_addr = in6addr_loopback;
+	    else
+		a6.sin6_addr = in6addr_any;
 	    a6.sin6_port = htons(port);
 	} else
 #endif
 	{
 	    a.sin_family = AF_INET;
-	    a.sin_addr.s_addr = htonl(INADDR_ANY);
+	    if (local_host_only)
+		a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	    else
+		a.sin_addr.s_addr = htonl(INADDR_ANY);
 	    a.sin_port = htons((short)port);
 	}
 #ifdef IPV6
@@ -707,38 +802,41 @@ void try_send(Actual_Socket s)
 	    urgentflag = 0;
 	    bufchain_prefix(&s->output_data, &data, &len);
 	}
-
 	nsent = send(s->s, data, len, urgentflag);
 	noise_ultralight(nsent);
 	if (nsent <= 0) {
 	    err = (nsent < 0 ? WSAGetLastError() : 0);
-	    if ((err == 0 && nsent < 0) || err == WSAEWOULDBLOCK) {
+	    if ((err < WSABASEERR && nsent < 0) || err == WSAEWOULDBLOCK) {
 		/*
 		 * Perfectly normal: we've sent all we can for the moment.
 		 * 
-		 * (Apparently some WinSocks can return <0 but
-		 * leave no error indication - WSAGetLastError() is
-		 * called but returns zero - so we check that case
-		 * and treat it just like WSAEWOULDBLOCK.)
+		 * (Some WinSock send() implementations can return
+		 * <0 but leave no sensible error indication -
+		 * WSAGetLastError() is called but returns zero or
+		 * a small number - so we check that case and treat
+		 * it just like WSAEWOULDBLOCK.)
 		 */
 		s->writable = FALSE;
 		return;
 	    } else if (nsent == 0 ||
 		       err == WSAECONNABORTED || err == WSAECONNRESET) {
 		/*
-		 * FIXME. This will have to be done better when we
-		 * start managing multiple sockets (e.g. SSH port
-		 * forwarding), because if we get CONNRESET while
-		 * trying to write a particular forwarded socket
-		 * then it isn't necessarily the end of the world.
-		 * Ideally I'd like to pass the error code back to
-		 * somewhere the next select_result() will see it,
-		 * but that might be hard. Perhaps I should pass it
-		 * back to be queued in the Windows front end bit.
+		 * 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(winsock_error_string(err));
+		s->pending_error = err;
+		return;
 	    } else {
-		fatalbox(winsock_error_string(err));
+		/* We're inside the Windows frontend here, so we know
+		 * that the frontend handle is unnecessary. */
+		logevent(NULL, winsock_error_string(err));
+		fatalbox("%s", winsock_error_string(err));
 	    }
 	} else {
 	    if (s->sending_oob) {
@@ -818,6 +916,9 @@ int select_result(WPARAM wParam, LPARAM lParam)
     noise_ultralight(lParam);
 
     switch (WSAGETSELECTEVENT(lParam)) {
+      case FD_CONNECT:
+	s->connected = s->writable = 1;
+	break;
       case FD_READ:
 	/* In the case the socket is still frozen, we don't even bother */
 	if (s->frozen) {
@@ -871,8 +972,12 @@ 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()));
+	    /* We're inside the Windows frontend here, so we know
+	     * that the frontend handle is unnecessary. */
+	    logevent(NULL, str);
+	    fatalbox("%s", str);
 	} else {
 	    return plug_receive(s->plug, 2, buf, ret);
 	}
@@ -909,23 +1014,26 @@ int select_result(WPARAM wParam, LPARAM lParam)
 	return open;
        case FD_ACCEPT:
 	{
-		struct sockaddr isa;
-		int addrlen = sizeof(struct sockaddr);
-		SOCKET t;  /* socket of connection */
-
-		memset(&isa, 0, sizeof(struct sockaddr));
-		err = 0;
-		t = accept(s->s,&isa,&addrlen);
-		if (t == INVALID_SOCKET)
-				{
-					err = WSAGetLastError();
-					if (err == WSATRY_AGAIN)
-						break;
-				}
-
-		if (plug_accepting(s->plug, &isa, (void*)t)) {
-			closesocket(t); // denied or error
-		}
+	    struct sockaddr_in isa;
+	    int addrlen = sizeof(struct sockaddr_in);
+	    SOCKET t;  /* socket of connection */
+
+	    memset(&isa, 0, sizeof(struct sockaddr_in));
+	    err = 0;
+	    t = accept(s->s,(struct sockaddr *)&isa,&addrlen);
+	    if (t == INVALID_SOCKET)
+	    {
+		err = WSAGetLastError();
+		if (err == WSATRY_AGAIN)
+		    break;
+	    }
+
+	    if (s->localhost_only &&
+		ntohl(isa.sin_addr.s_addr) != INADDR_LOOPBACK) {
+		closesocket(t);	       /* dodgy WinSock let nonlocal through */
+	    } else if (plug_accepting(s->plug, (void*)t)) {
+		closesocket(t);	       /* denied or error */
+	    }
 	}
     }
 
@@ -933,16 +1041,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;
@@ -963,7 +1109,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)
@@ -992,3 +1138,13 @@ SOCKET next_socket(int *state)
     Actual_Socket s = index234(sktree, (*state)++);
     return s ? s->s : INVALID_SOCKET;
 }
+
+int net_service_lookup(char *service)
+{
+    struct servent *se;
+    se = getservbyname(service, NULL);
+    if (se != NULL)
+	return ntohs(se->s_port);
+    else
+	return 0;
+}