X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/2d466ffd08675d26db45e524c2fe6a8cf4628e2b..a832773496d46caa5e328d36a15b4918f24a804e:/winnet.c diff --git a/winnet.c b/winnet.c index 621c3cab..4ea29038 100644 --- a/winnet.c +++ b/winnet.c @@ -48,14 +48,13 @@ #include #include #include +#include #define DEFINE_PLUG_METHOD_MACROS #include "putty.h" #include "network.h" #include "tree234.h" -#define BUFFER_GRANULE 512 - struct Socket_tag { struct socket_function_table *fn; /* the above variable absolutely *must* be the first in this structure */ @@ -63,10 +62,17 @@ struct Socket_tag { SOCKET s; Plug plug; void *private_ptr; - struct buffer *head, *tail; + 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 */ }; /* @@ -89,12 +95,6 @@ struct SockAddr_tag { #endif }; -struct buffer { - struct buffer *next; - int buflen, bufpos; - char buf[BUFFER_GRANULE]; -}; - static tree234 *sktree; static int cmpfortree(void *av, void *bv) @@ -124,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) { @@ -341,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; +} + +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); @@ -364,12 +411,73 @@ static void sk_tcp_flush(Socket s) } static void sk_tcp_close(Socket s); -static void sk_tcp_write(Socket s, char *data, int len); -static void sk_tcp_write_oob(Socket s, char *data, int len); +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); + +Socket sk_register(void *sock, Plug plug) +{ + static struct socket_function_table fn_table = { + sk_tcp_plug, + sk_tcp_close, + 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 + }; + + DWORD err; + char *errstr; + Actual_Socket ret; + + /* + * Create Socket structure. + */ + ret = smalloc(sizeof(struct Socket_tag)); + ret->fn = &fn_table; + ret->error = NULL; + ret->plug = plug; + bufchain_init(&ret->output_data); + ret->writable = 1; /* to start with */ + 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; + + if (ret->s == INVALID_SOCKET) { + err = WSAGetLastError(); + ret->error = winsock_error_string(err); + return (Socket) ret; + } + + ret->oobinline = 0; + + /* Set up a select mechanism. This could be an AsyncSelect on a + * window, or an EventSelect on an event object. */ + errstr = do_select(ret->s, 1); + if (errstr) { + ret->error = errstr; + return (Socket) ret; + } + + add234(sktree, ret); + + return (Socket) ret; +} + 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, @@ -377,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 }; @@ -388,7 +499,6 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, DWORD err; char *errstr; Actual_Socket ret; - extern char *do_select(SOCKET skt, int startup); short localport; /* @@ -398,9 +508,14 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, ret->fn = &fn_table; ret->error = NULL; ret->plug = plug; - ret->head = ret->tail = NULL; - ret->writable = 1; /* to start with */ + bufchain_init(&ret->output_data); + 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. @@ -420,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. */ @@ -492,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) ? @@ -502,6 +631,129 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, #endif ) == SOCKET_ERROR) { err = WSAGetLastError(); + /* + * 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); + + return (Socket) ret; +} + +Socket sk_newlistener(int port, Plug plug, int local_host_only) +{ + static struct socket_function_table fn_table = { + sk_tcp_plug, + sk_tcp_close, + 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 + }; + + SOCKET s; +#ifdef IPV6 + SOCKADDR_IN6 a6; +#endif + SOCKADDR_IN a; + DWORD err; + char *errstr; + Actual_Socket ret; + int retcode; + int on = 1; + + /* + * Create Socket structure. + */ + ret = smalloc(sizeof(struct Socket_tag)); + ret->fn = &fn_table; + ret->error = NULL; + ret->plug = plug; + bufchain_init(&ret->output_data); + ret->writable = 0; /* to start with */ + ret->sending_oob = 0; + ret->frozen = 0; + ret->frozen_readable = 0; + ret->localhost_only = local_host_only; + ret->pending_error = 0; + + /* + * Open socket. + */ + s = socket(AF_INET, SOCK_STREAM, 0); + ret->s = s; + + if (s == INVALID_SOCKET) { + err = WSAGetLastError(); + ret->error = winsock_error_string(err); + return (Socket) ret; + } + + ret->oobinline = 0; + + + setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); + + +#ifdef IPV6 + if (addr->family == AF_INET6) { + memset(&a6, 0, sizeof(a6)); + a6.sin6_family = AF_INET6; + 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; + 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 + retcode = bind(s, (addr->family == AF_INET6 ? + (struct sockaddr *) &a6 : + (struct sockaddr *) &a), + (addr->family == + AF_INET6 ? sizeof(a6) : sizeof(a))); +#else + retcode = bind(s, (struct sockaddr *) &a, sizeof(a)); +#endif + if (retcode != SOCKET_ERROR) { + err = 0; + } else { + err = WSAGetLastError(); + } + + if (err) { + ret->error = winsock_error_string(err); + return (Socket) ret; + } + + + if (listen(s, SOMAXCONN) == SOCKET_ERROR) { + closesocket(s); ret->error = winsock_error_string(err); return (Socket) ret; } @@ -536,130 +788,99 @@ static void sk_tcp_close(Socket sock) */ void try_send(Actual_Socket s) { - while (s->head) { + while (s->sending_oob || bufchain_size(&s->output_data) > 0) { int nsent; DWORD err; + void *data; int len, urgentflag; if (s->sending_oob) { urgentflag = MSG_OOB; len = s->sending_oob; + data = &s->oobdata; } else { urgentflag = 0; - len = s->head->buflen - s->head->bufpos; + bufchain_prefix(&s->output_data, &data, &len); } - - nsent = - send(s->s, s->head->buf + s->head->bufpos, len, urgentflag); + 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 { - s->head->bufpos += nsent; - if (s->sending_oob) - s->sending_oob -= nsent; - if (s->head->bufpos >= s->head->buflen) { - struct buffer *tmp = s->head; - s->head = tmp->next; - sfree(tmp); - if (!s->head) - s->tail = NULL; + if (s->sending_oob) { + if (nsent < len) { + memmove(s->oobdata, s->oobdata+nsent, len-nsent); + s->sending_oob = len - nsent; + } else { + s->sending_oob = 0; + } + } else { + bufchain_consume(&s->output_data, nsent); } } } } -static void sk_tcp_write(Socket sock, char *buf, int len) +static int sk_tcp_write(Socket sock, char *buf, int len) { Actual_Socket s = (Actual_Socket) sock; /* * Add the data to the buffer list on the socket. */ - if (s->tail && s->tail->buflen < BUFFER_GRANULE) { - int copylen = min(len, BUFFER_GRANULE - s->tail->buflen); - memcpy(s->tail->buf + s->tail->buflen, buf, copylen); - buf += copylen; - len -= copylen; - s->tail->buflen += copylen; - } - while (len > 0) { - int grainlen = min(len, BUFFER_GRANULE); - struct buffer *newbuf; - newbuf = smalloc(sizeof(struct buffer)); - newbuf->bufpos = 0; - newbuf->buflen = grainlen; - memcpy(newbuf->buf, buf, grainlen); - buf += grainlen; - len -= grainlen; - if (s->tail) - s->tail->next = newbuf; - else - s->head = s->tail = newbuf; - newbuf->next = NULL; - s->tail = newbuf; - } + bufchain_add(&s->output_data, buf, len); /* * Now try sending from the start of the buffer list. */ if (s->writable) try_send(s); + + return bufchain_size(&s->output_data); } -static void sk_tcp_write_oob(Socket sock, char *buf, int len) +static int sk_tcp_write_oob(Socket sock, char *buf, int len) { Actual_Socket s = (Actual_Socket) sock; /* * Replace the buffer list on the socket with the data. */ - if (!s->head) { - s->head = smalloc(sizeof(struct buffer)); - } else { - struct buffer *walk = s->head->next; - while (walk) { - struct buffer *tmp = walk; - walk = tmp->next; - sfree(tmp); - } - } - s->head->next = NULL; - s->tail = s->head; - s->head->buflen = len; - memcpy(s->head->buf, buf, len); - - /* - * Set the Urgent marker. - */ + bufchain_clear(&s->output_data); + assert(len <= sizeof(s->oobdata)); + memcpy(s->oobdata, buf, len); s->sending_oob = len; /* @@ -667,6 +888,8 @@ static void sk_tcp_write_oob(Socket sock, char *buf, int len) */ if (s->writable) try_send(s); + + return s->sending_oob; } int select_result(WPARAM wParam, LPARAM lParam) @@ -693,7 +916,16 @@ 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) { + s->frozen_readable = 1; + break; + } + /* * We have received data on the socket. For an oobinline * socket, this might be data _before_ an urgent pointer, @@ -740,15 +972,26 @@ 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); } break; case FD_WRITE: - s->writable = 1; - try_send(s); + { + int bufsize_before, bufsize_after; + s->writable = 1; + bufsize_before = s->sending_oob + bufchain_size(&s->output_data); + try_send(s); + bufsize_after = s->sending_oob + bufchain_size(&s->output_data); + if (bufsize_after < bufsize_before) + plug_sent(s->plug, bufsize_after); + } break; case FD_CLOSE: /* Signal a close on the socket. First read any outstanding data. */ @@ -769,22 +1012,83 @@ int select_result(WPARAM wParam, LPARAM lParam) } } while (ret > 0); return open; + case FD_ACCEPT: + { + 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 */ + } + } } return 1; } /* + * 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; @@ -805,6 +1109,19 @@ static char *sk_tcp_socket_error(Socket sock) return s->error; } +static void sk_tcp_set_frozen(Socket sock, int is_frozen) +{ + Actual_Socket s = (Actual_Socket) sock; + if (s->frozen == is_frozen) + return; + s->frozen = is_frozen; + if (!is_frozen && s->frozen_readable) { + char c; + recv(s->s, &c, 1, MSG_PEEK); + } + s->frozen_readable = 0; +} + /* * For Plink: enumerate all sockets currently active. */