X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/e5eb3a1ca14cf38028d076b06701792af954c90b..d8d6c7e50e1fcf5171ec15f8a3e9bdcd141f0b64:/winnet.c diff --git a/winnet.c b/winnet.c index 1a80a80c..1663148f 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 */ }; /* @@ -338,6 +341,21 @@ 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 +} + void sk_addr_free(SockAddr addr) { sfree(addr); @@ -394,6 +412,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 +439,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, @@ -448,10 +468,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 +494,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 +571,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 +590,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); @@ -604,6 +647,8 @@ Socket sk_newlistener(int port, Plug plug, int local_host_only) ret->sending_oob = 0; ret->frozen = 0; ret->frozen_readable = 0; + ret->localhost_only = local_host_only; + ret->pending_error = 0; /* * Open socket. @@ -713,7 +758,6 @@ 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) { @@ -733,17 +777,17 @@ void try_send(Actual_Socket s) } 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)); } @@ -825,6 +869,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) { @@ -916,13 +963,13 @@ int select_result(WPARAM wParam, LPARAM lParam) return open; case FD_ACCEPT: { - struct sockaddr isa; - int addrlen = sizeof(struct sockaddr); + struct sockaddr_in isa; + int addrlen = sizeof(struct sockaddr_in); SOCKET t; /* socket of connection */ - memset(&isa, 0, sizeof(struct sockaddr)); + 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(); @@ -930,7 +977,10 @@ int select_result(WPARAM wParam, LPARAM lParam) break; } - if (plug_accepting(s->plug, (void*)t)) { + 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 */ } } @@ -940,6 +990,44 @@ 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. */