X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/a073bee10b5d35dae36c8417c705222b990807ec..68a49acbf3f96fbbbc385620655dcb577e62c328:/winnet.c diff --git a/winnet.c b/winnet.c index b6710472..430a47bb 100644 --- a/winnet.c +++ b/winnet.c @@ -68,9 +68,11 @@ struct Socket_tag { 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 */ }; /* @@ -122,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) { @@ -354,6 +368,26 @@ void sk_getaddr(SockAddr addr, char *buf, int buflen) #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); @@ -379,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); @@ -391,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 }; @@ -410,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; @@ -435,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, @@ -443,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 }; @@ -469,6 +514,8 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, 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. @@ -488,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. */ @@ -610,6 +662,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 }; @@ -636,6 +691,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. @@ -764,32 +821,22 @@ 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 " - ".", - 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) { @@ -925,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); } @@ -963,13 +1014,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(); @@ -977,7 +1028,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 */ } } @@ -987,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; @@ -1017,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) @@ -1046,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; +}