From 7555d6a50b05d96de39b5e95cf11a8f05f0c4fd9 Mon Sep 17 00:00:00 2001 From: simon Date: Sun, 16 Jan 2005 14:29:34 +0000 Subject: [PATCH] Support for falling back through the list of addresses returned from a DNS lookup, whether they're IPv4, v6 or a mixture of both. git-svn-id: svn://svn.tartarus.org/sgt/putty@5119 cda61777-01e9-0310-a592-d414129be87e --- network.h | 15 +++ portfwd.c | 9 ++ proxy.c | 10 ++ raw.c | 24 +++- rlogin.c | 24 +++- ssh.c | 22 ++- telnet.c | 28 ++-- unix/uxnet.c | 289 ++++++++++++++++++++++++++------------- windows/winnet.c | 402 +++++++++++++++++++++++++++++++++++-------------------- x11fwd.c | 7 + 10 files changed, 563 insertions(+), 267 deletions(-) diff --git a/network.h b/network.h index a97a6c47..41d0d442 100644 --- a/network.h +++ b/network.h @@ -46,6 +46,20 @@ struct socket_function_table { }; struct plug_function_table { + void (*log)(Plug p, int type, SockAddr addr, int port, + const char *error_msg, int error_code); + /* + * Passes the client progress reports on the process of setting + * up the connection. + * + * - type==0 means we are about to try to connect to address + * `addr' (error_msg and error_code are ignored) + * - type==1 means we have failed to connect to address `addr' + * (error_msg and error_code are supplied). This is not a + * fatal error - we may well have other candidate addresses + * to fall back to. When it _is_ fatal, the closing() + * function will be called. + */ int (*closing) (Plug p, const char *error_msg, int error_code, int calling_back); /* error_msg is NULL iff it is not an error (ie it closed normally) */ @@ -123,6 +137,7 @@ Socket sk_register(OSSocket sock, Plug plug); #define sk_flush(s) (((*s)->flush) (s)) #ifdef DEFINE_PLUG_METHOD_MACROS +#define plug_log(p,type,addr,port,msg,code) (((*p)->log) (p, type, addr, port, msg, code)) #define plug_closing(p,msg,code,callback) (((*p)->closing) (p, msg, code, callback)) #define plug_receive(p,urgent,buf,len) (((*p)->receive) (p, urgent, buf, len)) #define plug_sent(p,bufsize) (((*p)->sent) (p, bufsize)) diff --git a/portfwd.c b/portfwd.c index 1239f671..3b772599 100644 --- a/portfwd.c +++ b/portfwd.c @@ -86,6 +86,12 @@ struct PFwdPrivate { int buflen; }; +static void pfd_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + /* we have to dump these since we have no interface to logging.c */ +} + static int pfd_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { @@ -357,6 +363,7 @@ const char *pfd_newconnect(Socket *s, char *hostname, int port, void *c, const Config *cfg, int addressfamily) { static const struct plug_function_table fn_table = { + pfd_log, pfd_closing, pfd_receive, pfd_sent, @@ -407,6 +414,7 @@ const char *pfd_newconnect(Socket *s, char *hostname, int port, static int pfd_accepting(Plug p, OSSocket sock) { static const struct plug_function_table fn_table = { + pfd_log, pfd_closing, pfd_receive, pfd_sent, @@ -466,6 +474,7 @@ const char *pfd_addforward(char *desthost, int destport, char *srcaddr, void **sockdata, int address_family) { static const struct plug_function_table fn_table = { + pfd_log, pfd_closing, pfd_receive, /* should not happen... */ pfd_sent, /* also should not happen */ diff --git a/proxy.c b/proxy.c index 5baab7a8..a27c38ee 100644 --- a/proxy.c +++ b/proxy.c @@ -191,6 +191,15 @@ static const char * sk_proxy_socket_error (Socket s) /* basic proxy plug functions */ +static void plug_proxy_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + Proxy_Plug pp = (Proxy_Plug) plug; + Proxy_Socket ps = pp->proxy_socket; + + plug_log(ps->plug, type, addr, port, error_msg, error_code); +} + static int plug_proxy_closing (Plug p, const char *error_msg, int error_code, int calling_back) { @@ -372,6 +381,7 @@ Socket new_connection(SockAddr addr, char *hostname, }; static const struct plug_function_table plug_fn_table = { + plug_proxy_log, plug_proxy_closing, plug_proxy_receive, plug_proxy_sent, diff --git a/raw.c b/raw.c index 86194464..31d7490c 100644 --- a/raw.c +++ b/raw.c @@ -29,6 +29,22 @@ static void c_write(Raw raw, char *buf, int len) sk_set_frozen(raw->s, backlog > RAW_MAX_BACKLOG); } +static void raw_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + Raw raw = (Raw) plug; + char addrbuf[256], *msg; + + sk_getaddr(addr, addrbuf, lenof(addrbuf)); + + if (type == 0) + msg = dupprintf("Connecting to %s port %d", addrbuf, port); + else + msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg); + + logevent(raw->frontend, msg); +} + static int raw_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { @@ -74,6 +90,7 @@ static const char *raw_init(void *frontend_handle, void **backend_handle, int keepalive) { static const struct plug_function_table fn_table = { + raw_log, raw_closing, raw_receive, raw_sent @@ -113,13 +130,6 @@ static const char *raw_init(void *frontend_handle, void **backend_handle, /* * Open socket. */ - { - char *buf, addrbuf[100]; - sk_getaddr(addr, addrbuf, 100); - buf = dupprintf("Connecting to %s port %d", addrbuf, port); - logevent(raw->frontend, buf); - sfree(buf); - } raw->s = new_connection(addr, *realhost, port, 0, 1, nodelay, keepalive, (Plug) raw, cfg); if ((err = sk_socket_error(raw->s)) != NULL) diff --git a/rlogin.c b/rlogin.c index 29d7be56..a6dad0e4 100644 --- a/rlogin.c +++ b/rlogin.c @@ -32,6 +32,22 @@ static void c_write(Rlogin rlogin, char *buf, int len) sk_set_frozen(rlogin->s, backlog > RLOGIN_MAX_BACKLOG); } +static void rlogin_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + Rlogin rlogin = (Rlogin) plug; + char addrbuf[256], *msg; + + sk_getaddr(addr, addrbuf, lenof(addrbuf)); + + if (type == 0) + msg = dupprintf("Connecting to %s port %d", addrbuf, port); + else + msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg); + + logevent(rlogin->frontend, msg); +} + static int rlogin_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { @@ -104,6 +120,7 @@ static const char *rlogin_init(void *frontend_handle, void **backend_handle, int nodelay, int keepalive) { static const struct plug_function_table fn_table = { + rlogin_log, rlogin_closing, rlogin_receive, rlogin_sent @@ -145,13 +162,6 @@ static const char *rlogin_init(void *frontend_handle, void **backend_handle, /* * Open socket. */ - { - char *buf, addrbuf[100]; - sk_getaddr(addr, addrbuf, 100); - buf = dupprintf("Connecting to %s port %d", addrbuf, port); - logevent(rlogin->frontend, buf); - sfree(buf); - } rlogin->s = new_connection(addr, *realhost, port, 1, 0, nodelay, keepalive, (Plug) rlogin, cfg); if ((err = sk_socket_error(rlogin->s)) != NULL) diff --git a/ssh.c b/ssh.c index cf957b44..e693fb6a 100644 --- a/ssh.c +++ b/ssh.c @@ -2408,6 +2408,22 @@ static int ssh_do_close(Ssh ssh, int notify_exit) return ret; } +static void ssh_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + Ssh ssh = (Ssh) plug; + char addrbuf[256], *msg; + + sk_getaddr(addr, addrbuf, lenof(addrbuf)); + + if (type == 0) + msg = dupprintf("Connecting to %s port %d", addrbuf, port); + else + msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg); + + logevent(msg); +} + static int ssh_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { @@ -2462,6 +2478,7 @@ static const char *connect_to_host(Ssh ssh, char *host, int port, char **realhost, int nodelay, int keepalive) { static const struct plug_function_table fn_table = { + ssh_log, ssh_closing, ssh_receive, ssh_sent, @@ -2496,11 +2513,6 @@ static const char *connect_to_host(Ssh ssh, char *host, int port, /* * Open socket. */ - { - char addrbuf[100]; - sk_getaddr(addr, addrbuf, 100); - logeventf(ssh, "Connecting to %s port %d", addrbuf, port); - } ssh->fn = &fn_table; ssh->s = new_connection(addr, *realhost, port, 0, 1, nodelay, keepalive, (Plug) ssh, &ssh->cfg); diff --git a/telnet.c b/telnet.c index 6789e5de..36c0f723 100644 --- a/telnet.c +++ b/telnet.c @@ -638,6 +638,22 @@ static void do_telnet_read(Telnet telnet, char *buf, int len) } } +static void telnet_log(Plug plug, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + Telnet telnet = (Telnet) plug; + char addrbuf[256], *msg; + + sk_getaddr(addr, addrbuf, lenof(addrbuf)); + + if (type == 0) + msg = dupprintf("Connecting to %s port %d", addrbuf, port); + else + msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg); + + logevent(telnet->frontend, msg); +} + static int telnet_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { @@ -649,10 +665,10 @@ static int telnet_closing(Plug plug, const char *error_msg, int error_code, notify_remote_exit(telnet->frontend); } if (error_msg) { - /* A socket error has occurred. */ logevent(telnet->frontend, error_msg); connection_fatal(telnet->frontend, "%s", error_msg); - } /* Otherwise, the remote side closed the connection normally. */ + } + /* Otherwise, the remote side closed the connection normally. */ return 0; } @@ -685,6 +701,7 @@ static const char *telnet_init(void *frontend_handle, void **backend_handle, int nodelay, int keepalive) { static const struct plug_function_table fn_table = { + telnet_log, telnet_closing, telnet_receive, telnet_sent @@ -734,13 +751,6 @@ static const char *telnet_init(void *frontend_handle, void **backend_handle, /* * Open socket. */ - { - char *buf, addrbuf[100]; - sk_getaddr(addr, addrbuf, 100); - buf = dupprintf("Connecting to %s port %d", addrbuf, port); - logevent(telnet->frontend, buf); - sfree(buf); - } telnet->s = new_connection(addr, *realhost, port, 0, 1, nodelay, keepalive, (Plug) telnet, &telnet->cfg); if ((err = sk_socket_error(telnet->s)) != NULL) diff --git a/unix/uxnet.c b/unix/uxnet.c index fd86af0c..03120948 100644 --- a/unix/uxnet.c +++ b/unix/uxnet.c @@ -48,6 +48,9 @@ struct Socket_tag { int oobinline; int pending_error; /* in case send() returns error */ int listener; + int nodelay, keepalive; /* for connect()-type sockets */ + int privport, port; /* and again */ + SockAddr addr; }; /* @@ -70,9 +73,11 @@ struct SockAddr_tag { */ int family; #ifndef NO_IPV6 - struct addrinfo *ai; /* Address IPv6 style. */ + struct addrinfo *ais; /* Addresses IPv6 style. */ + struct addrinfo *ai; /* steps along the linked list */ #else - unsigned long address; /* Address IPv4 style. */ + unsigned long *addresses; /* Addresses IPv4 style. */ + int naddresses, curraddr; #endif char hostname[512]; /* Store an unresolved host name. */ }; @@ -120,11 +125,6 @@ void sk_cleanup(void) } } -const char *error_string(int error) -{ - return strerror(error); -} - SockAddr sk_namelookup(const char *host, char **canonicalname, int address_family) { SockAddr ret = snew(struct SockAddr_tag); @@ -134,6 +134,7 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, int address_famil #else unsigned long a; struct hostent *h = NULL; + int n; #endif char realhost[8192]; @@ -154,7 +155,8 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, int address_famil hints.ai_addr = NULL; hints.ai_canonname = NULL; hints.ai_next = NULL; - err = getaddrinfo(host, NULL, &hints, &ret->ai); + err = getaddrinfo(host, NULL, &hints, &ret->ais); + ret->ai = ret->ais; if (err != 0) { ret->error = gai_strerror(err); return ret; @@ -172,22 +174,28 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, int address_famil * we don't use gethostbyname as a fallback!) */ if (ret->family == 0) { - /*debug(("Resolving \"%s\" with gethostbyname() (IPv4 only)...\n", host)); */ - if ( (h = gethostbyname(host)) ) - ret->family = AF_INET; + /*debug(("Resolving \"%s\" with gethostbyname() (IPv4 only)...\n", host)); */ + if ( (h = gethostbyname(host)) ) + ret->family = AF_INET; } if (ret->family == 0) { - ret->error = (h_errno == HOST_NOT_FOUND || - h_errno == NO_DATA || - h_errno == NO_ADDRESS ? "Host does not exist" : - h_errno == TRY_AGAIN ? - "Temporary name service failure" : - "gethostbyname: unknown error"); - return ret; + ret->error = (h_errno == HOST_NOT_FOUND || + h_errno == NO_DATA || + h_errno == NO_ADDRESS ? "Host does not exist" : + h_errno == TRY_AGAIN ? + "Temporary name service failure" : + "gethostbyname: unknown error"); + return ret; } - memcpy(&a, h->h_addr, sizeof(a)); /* This way we are always sure the h->h_name is valid :) */ strncpy(realhost, h->h_name, sizeof(realhost)); + for (n = 0; h->h_addr_list[n]; n++); + ret->addresses = snewn(n, unsigned long); + ret->naddresses = n; + for (n = 0; n < ret->naddresses; n++) { + memcpy(&a, h->h_addr_list[n], sizeof(a)); + ret->addresses[n] = ntohl(a); + } } else { /* * This must be a numeric IPv4 address because it caused a @@ -195,8 +203,11 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, int address_famil */ ret->family = AF_INET; strncpy(realhost, host, sizeof(realhost)); + ret->addresses = snew(unsigned long); + ret->naddresses = 1; + ret->addresses[0] = ntohl(a); + ret->curraddr = 0; } - ret->address = ntohl(a); #endif realhost[lenof(realhost)-1] = '\0'; *canonicalname = snewn(1+strlen(realhost), char); @@ -212,11 +223,32 @@ SockAddr sk_nonamelookup(const char *host) strncpy(ret->hostname, host, lenof(ret->hostname)); ret->hostname[lenof(ret->hostname)-1] = '\0'; #ifndef NO_IPV6 - ret->ai = NULL; + ret->ais = NULL; +#else + ret->addresses = NULL; #endif return ret; } +static int sk_nextaddr(SockAddr addr) +{ +#ifndef NO_IPV6 + if (addr->ai->ai_next) { + addr->ai = addr->ai->ai_next; + addr->family = addr->ai->ai_family; + return TRUE; + } else + return FALSE; +#else + if (addr->curraddr+1 < addr->naddresses) { + addr->curraddr++; + return TRUE; + } else { + return FALSE; + } +#endif +} + void sk_getaddr(SockAddr addr, char *buf, int buflen) { @@ -233,7 +265,7 @@ void sk_getaddr(SockAddr addr, char *buf, int buflen) #else struct in_addr a; assert(addr->family == AF_INET); - a.s_addr = htonl(addr->address); + a.s_addr = htonl(addr->addresses[addr->curraddr]); strncpy(buf, inet_ntoa(a), buflen); buf[buflen-1] = '\0'; #endif @@ -263,7 +295,7 @@ int sk_address_is_local(SockAddr addr) #else struct in_addr a; assert(addr->family == AF_INET); - a.s_addr = htonl(addr->address); + a.s_addr = htonl(addr->addresses[addr->curraddr]); return ipv4_is_loopback(a); #endif } @@ -294,7 +326,7 @@ void sk_addrcopy(SockAddr addr, char *buf) struct in_addr a; assert(addr->family == AF_INET); - a.s_addr = htonl(addr->address); + a.s_addr = htonl(addr->addresses[addr->curraddr]); memcpy(buf, (char*) &a.s_addr, 4); #endif } @@ -303,8 +335,10 @@ void sk_addr_free(SockAddr addr) { #ifndef NO_IPV6 - if (addr->ai != NULL) - freeaddrinfo(addr->ai); + if (addr->ais != NULL) + freeaddrinfo(addr->ais); +#else + sfree(addr->addresses); #endif sfree(addr); } @@ -366,11 +400,12 @@ Socket sk_register(OSSocket sockfd, Plug plug) ret->pending_error = 0; ret->oobpending = FALSE; ret->listener = 0; + ret->addr = NULL; ret->s = sockfd; if (ret->s < 0) { - ret->error = error_string(errno); + ret->error = strerror(errno); return (Socket) ret; } @@ -382,8 +417,7 @@ Socket sk_register(OSSocket sockfd, Plug plug) return (Socket) ret; } -Socket sk_new(SockAddr addr, int port, int privport, int oobinline, - int nodelay, int keepalive, Plug plug) +static int try_connect(Actual_Socket sock) { int s; #ifndef NO_IPV6 @@ -392,53 +426,38 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, struct sockaddr_in a; struct sockaddr_un au; const struct sockaddr *sa; - int err; - Actual_Socket ret; + int err = 0; short localport; int fl, salen; - /* - * Create Socket structure. - */ - ret = snew(struct Socket_tag); - ret->fn = &tcp_fn_table; - ret->error = NULL; - ret->plug = plug; - 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; - ret->oobpending = FALSE; - ret->listener = 0; + if (sock->s >= 0) + close(sock->s); + + plug_log(sock->plug, 0, sock->addr, sock->port, NULL, 0); /* * Open socket. */ - assert(addr->family != AF_UNSPEC); - s = socket(addr->family, SOCK_STREAM, 0); - ret->s = s; + assert(sock->addr->family != AF_UNSPEC); + s = socket(sock->addr->family, SOCK_STREAM, 0); + sock->s = s; if (s < 0) { - ret->error = error_string(errno); - return (Socket) ret; + err = errno; + goto ret; } - ret->oobinline = oobinline; - if (oobinline) { + if (sock->oobinline) { int b = TRUE; setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b)); } - if (nodelay) { + if (sock->nodelay) { int b = TRUE; setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b)); } - if (keepalive) { + if (sock->keepalive) { int b = TRUE; setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *) &b, sizeof(b)); } @@ -446,7 +465,7 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, /* * Bind to local address. */ - if (privport) + if (sock->privport) localport = 1023; /* count from 1023 downwards */ else localport = 0; /* just use port 0 (ie kernel picks) */ @@ -459,13 +478,13 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, /* We don't try to bind to a local address for UNIX domain sockets. (Why * do we bother doing the bind when localport == 0 anyway?) */ - if(addr->family != AF_UNIX) { + if(sock->addr->family != AF_UNIX) { /* Loop round trying to bind */ while (1) { int retcode; #ifndef NO_IPV6 - if (addr->family == AF_INET6) { + if (sock->addr->family == AF_INET6) { /* XXX use getaddrinfo to get a local address? */ a6.sin6_family = AF_INET6; a6.sin6_addr = in6addr_any; @@ -474,7 +493,7 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, } else #endif { - assert(addr->family == AF_INET); + assert(sock->addr->family == AF_INET); a.sin_family = AF_INET; a.sin_addr.s_addr = htonl(INADDR_ANY); a.sin_port = htons(localport); @@ -496,45 +515,43 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, break; /* we might have got to the end */ } - if (err) { - ret->error = error_string(err); - return (Socket) ret; - } + if (err) + goto ret; } /* * Connect to remote address. */ - switch(addr->family) { + switch(sock->addr->family) { #ifndef NO_IPV6 case AF_INET: /* XXX would be better to have got getaddrinfo() to fill in the port. */ - ((struct sockaddr_in *)addr->ai->ai_addr)->sin_port = - htons(port); - sa = (const struct sockaddr *)addr->ai->ai_addr; - salen = addr->ai->ai_addrlen; + ((struct sockaddr_in *)sock->addr->ai->ai_addr)->sin_port = + htons(sock->port); + sa = (const struct sockaddr *)sock->addr->ai->ai_addr; + salen = sock->addr->ai->ai_addrlen; break; case AF_INET6: - ((struct sockaddr_in *)addr->ai->ai_addr)->sin_port = - htons(port); - sa = (const struct sockaddr *)addr->ai->ai_addr; - salen = addr->ai->ai_addrlen; + ((struct sockaddr_in *)sock->addr->ai->ai_addr)->sin_port = + htons(sock->port); + sa = (const struct sockaddr *)sock->addr->ai->ai_addr; + salen = sock->addr->ai->ai_addrlen; break; #else case AF_INET: a.sin_family = AF_INET; - a.sin_addr.s_addr = htonl(addr->address); - a.sin_port = htons((short) port); + a.sin_addr.s_addr = htonl(sock->addr->addresses[sock->addr->curraddr]); + a.sin_port = htons((short) sock->port); sa = (const struct sockaddr *)&a; salen = sizeof a; break; #endif case AF_UNIX: - assert(port == 0); /* to catch confused people */ - assert(strlen(addr->hostname) < sizeof au.sun_path); + assert(sock->port == 0); /* to catch confused people */ + assert(strlen(sock->addr->hostname) < sizeof au.sun_path); memset(&au, 0, sizeof au); au.sun_family = AF_UNIX; - strcpy(au.sun_path, addr->hostname); + strcpy(au.sun_path, sock->addr->hostname); sa = (const struct sockaddr *)&au; salen = sizeof au; break; @@ -549,22 +566,65 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, if ((connect(s, sa, salen)) < 0) { if ( errno != EINPROGRESS ) { - ret->error = error_string(errno); - return (Socket) ret; + err = errno; + goto ret; } } else { /* * If we _don't_ get EWOULDBLOCK, the connect has completed * and we should set the socket as connected and writable. */ - ret->connected = 1; - ret->writable = 1; + sock->connected = 1; + sock->writable = 1; } - uxsel_tell(ret); - add234(sktree, ret); + uxsel_tell(sock); + add234(sktree, sock); + + ret: + if (err) + plug_log(sock->plug, 1, sock->addr, sock->port, strerror(err), err); + return err; +} + +Socket sk_new(SockAddr addr, int port, int privport, int oobinline, + int nodelay, int keepalive, Plug plug) +{ + Actual_Socket ret; + int err; + + /* + * Create Socket structure. + */ + ret = snew(struct Socket_tag); + ret->fn = &tcp_fn_table; + ret->error = NULL; + ret->plug = plug; + 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; + ret->oobpending = FALSE; + ret->listener = 0; + ret->addr = addr; + ret->s = -1; + ret->oobinline = oobinline; + ret->nodelay = nodelay; + ret->keepalive = keepalive; + ret->privport = privport; + ret->port = port; + + err = 0; + do { + err = try_connect(ret); + } while (err && sk_nextaddr(ret->addr)); - sk_addr_free(addr); + if (err) + ret->error = strerror(err); return (Socket) ret; } @@ -600,6 +660,7 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, i ret->pending_error = 0; ret->oobpending = FALSE; ret->listener = 1; + ret->addr = NULL; /* * Translate address_family from platform-independent constants @@ -629,7 +690,7 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, i } if (s < 0) { - ret->error = error_string(errno); + ret->error = strerror(errno); return (Socket) ret; } @@ -700,14 +761,13 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, i retcode = bind(s, addr, addrlen); if (retcode < 0) { close(s); - ret->error = error_string(errno); + ret->error = strerror(errno); return (Socket) ret; } - if (listen(s, SOMAXCONN) < 0) { close(s); - ret->error = error_string(errno); + ret->error = strerror(errno); return (Socket) ret; } @@ -726,6 +786,8 @@ static void sk_tcp_close(Socket sock) uxsel_del(s->s); del234(sktree, s); close(s->s); + if (s->addr) + sk_addr_free(s->addr); sfree(s); } @@ -814,8 +876,8 @@ void try_send(Actual_Socket s) } else { /* We're inside the Unix frontend here, so we know * that the frontend handle is unnecessary. */ - logevent(NULL, error_string(err)); - fatalbox("%s", error_string(err)); + logevent(NULL, strerror(err)); + fatalbox("%s", strerror(err)); } } else { if (s->sending_oob) { @@ -912,12 +974,21 @@ static int net_select_result(int fd, int event) noise_ultralight(ret); if (ret <= 0) { const char *str = (ret == 0 ? "Internal networking trouble" : - error_string(errno)); + strerror(errno)); /* We're inside the Unix frontend here, so we know * that the frontend handle is unnecessary. */ logevent(NULL, str); fatalbox("%s", str); } else { + /* + * Receiving actual data on a socket means we can + * stop falling back through the candidate + * addresses to connect to. + */ + if (s->addr) { + sk_addr_free(s->addr); + s->addr = NULL; + } return plug_receive(s->plug, 2, buf, ret); } break; @@ -988,10 +1059,33 @@ static int net_select_result(int fd, int event) } } if (ret < 0) { - return plug_closing(s->plug, error_string(errno), errno, 0); + /* + * An error at this point _might_ be an error reported + * by a non-blocking connect(). So before we return a + * panic status to the user, let's just see whether + * that's the case. + */ + int err = errno; + if (s->addr) { + plug_log(s->plug, 1, s->addr, s->port, strerror(err), err); + while (s->addr && sk_nextaddr(s->addr)) { + err = try_connect(s); + } + } + if (err != 0) + return plug_closing(s->plug, strerror(err), err, 0); } else if (0 == ret) { return plug_closing(s->plug, NULL, 0, 0); } else { + /* + * Receiving actual data on a socket means we can + * stop falling back through the candidate + * addresses to connect to. + */ + if (s->addr) { + sk_addr_free(s->addr); + s->addr = NULL; + } return plug_receive(s->plug, atmark ? 0 : 1, buf, ret); } break; @@ -1048,7 +1142,7 @@ void net_pending_errors(void) * An error has occurred on this socket. Pass it to the * plug. */ - plug_closing(s->plug, error_string(s->pending_error), + plug_closing(s->plug, strerror(s->pending_error), s->pending_error, 0); break; } @@ -1140,5 +1234,10 @@ SockAddr platform_get_x11_unix_address(int displaynum, char **canonicalname) ret->error = "X11 UNIX name too long"; else *canonicalname = dupstr(ret->hostname); +#ifndef NO_IPV6 + ret->ais = NULL; +#else + ret->addresses = NULL; +#endif return ret; } diff --git a/windows/winnet.c b/windows/winnet.c index eccdb6f6..f6f7bab0 100644 --- a/windows/winnet.c +++ b/windows/winnet.c @@ -50,7 +50,9 @@ struct Socket_tag { int localhost_only; /* for listening sockets */ char oobdata[1]; int sending_oob; - int oobinline; + int oobinline, nodelay, keepalive, privport; + SockAddr addr; + int port; int pending_error; /* in case send() returns error */ /* * We sometimes need pairs of Socket structures to be linked: @@ -75,10 +77,12 @@ struct SockAddr_tag { * on the commandline for selecting a default protocol. */ int family; - unsigned long address; /* Address IPv4 style. */ #ifndef NO_IPV6 - struct addrinfo *ai; /* Address AF-independent (IPv4+IPv6) style. */ + struct addrinfo *ais; /* Addresses IPv6 style. */ + struct addrinfo *ai; /* steps along the linked list */ #endif + unsigned long *addresses; /* Addresses IPv4 style. */ + int naddresses, curraddr; char hostname[512]; /* Store an unresolved host name. */ }; @@ -110,8 +114,8 @@ static int cmpforsearch(void *av, void *bv) #define DECL_WINSOCK_FUNCTION(linkage, rettype, name, params) \ typedef rettype (WINAPI *t_##name) params; \ linkage t_##name p_##name -#define GET_WINSOCK_FUNCTION(name) \ - p_##name = (t_##name) GetProcAddress(winsock_module, #name) +#define GET_WINSOCK_FUNCTION(module, name) \ + p_##name = (t_##name) GetProcAddress(module, #name) DECL_WINSOCK_FUNCTION(NOTHING, int, WSAAsyncSelect, (SOCKET, HWND, u_int, long)); @@ -153,8 +157,21 @@ DECL_WINSOCK_FUNCTION(static, int, WSAIoctl, (SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE)); +#ifndef NO_IPV6 +DECL_WINSOCK_FUNCTION(static, int, getaddrinfo, + (const char *nodename, const char *servname, + const struct addrinfo *hints, struct addrinfo **res)); +DECL_WINSOCK_FUNCTION(static, void, freeaddrinfo, (struct addrinfo *res)); +DECL_WINSOCK_FUNCTION(static, int, getnameinfo, + (const struct sockaddr FAR * sa, socklen_t salen, + char FAR * host, size_t hostlen, char FAR * serv, + size_t servlen, int flags)); +#endif static HMODULE winsock_module; +#ifndef NO_IPV6 +static HMODULE wship6_module; +#endif void sk_init(void) { @@ -170,32 +187,41 @@ void sk_init(void) if (!winsock_module) fatalbox("Unable to load any WinSock library"); - GET_WINSOCK_FUNCTION(WSAAsyncSelect); - GET_WINSOCK_FUNCTION(WSAEventSelect); - GET_WINSOCK_FUNCTION(select); - GET_WINSOCK_FUNCTION(WSAGetLastError); - GET_WINSOCK_FUNCTION(WSAEnumNetworkEvents); - GET_WINSOCK_FUNCTION(WSAStartup); - GET_WINSOCK_FUNCTION(WSACleanup); - GET_WINSOCK_FUNCTION(closesocket); - GET_WINSOCK_FUNCTION(ntohl); - GET_WINSOCK_FUNCTION(htonl); - GET_WINSOCK_FUNCTION(htons); - GET_WINSOCK_FUNCTION(ntohs); - GET_WINSOCK_FUNCTION(gethostbyname); - GET_WINSOCK_FUNCTION(getservbyname); - GET_WINSOCK_FUNCTION(inet_addr); - GET_WINSOCK_FUNCTION(inet_ntoa); - GET_WINSOCK_FUNCTION(connect); - GET_WINSOCK_FUNCTION(bind); - GET_WINSOCK_FUNCTION(setsockopt); - GET_WINSOCK_FUNCTION(socket); - GET_WINSOCK_FUNCTION(listen); - GET_WINSOCK_FUNCTION(send); - GET_WINSOCK_FUNCTION(ioctlsocket); - GET_WINSOCK_FUNCTION(accept); - GET_WINSOCK_FUNCTION(recv); - GET_WINSOCK_FUNCTION(WSAIoctl); +#ifndef NO_IPV6 + wship6_module = LoadLibrary("wship6.dll"); + if (wship6_module) { + GET_WINSOCK_FUNCTION(wship6_module, getaddrinfo); + GET_WINSOCK_FUNCTION(wship6_module, freeaddrinfo); + GET_WINSOCK_FUNCTION(wship6_module, getnameinfo); + } +#endif + + GET_WINSOCK_FUNCTION(winsock_module, WSAAsyncSelect); + GET_WINSOCK_FUNCTION(winsock_module, WSAEventSelect); + GET_WINSOCK_FUNCTION(winsock_module, select); + GET_WINSOCK_FUNCTION(winsock_module, WSAGetLastError); + GET_WINSOCK_FUNCTION(winsock_module, WSAEnumNetworkEvents); + GET_WINSOCK_FUNCTION(winsock_module, WSAStartup); + GET_WINSOCK_FUNCTION(winsock_module, WSACleanup); + GET_WINSOCK_FUNCTION(winsock_module, closesocket); + GET_WINSOCK_FUNCTION(winsock_module, ntohl); + GET_WINSOCK_FUNCTION(winsock_module, htonl); + GET_WINSOCK_FUNCTION(winsock_module, htons); + GET_WINSOCK_FUNCTION(winsock_module, ntohs); + GET_WINSOCK_FUNCTION(winsock_module, gethostbyname); + GET_WINSOCK_FUNCTION(winsock_module, getservbyname); + GET_WINSOCK_FUNCTION(winsock_module, inet_addr); + GET_WINSOCK_FUNCTION(winsock_module, inet_ntoa); + GET_WINSOCK_FUNCTION(winsock_module, connect); + GET_WINSOCK_FUNCTION(winsock_module, bind); + GET_WINSOCK_FUNCTION(winsock_module, setsockopt); + GET_WINSOCK_FUNCTION(winsock_module, socket); + GET_WINSOCK_FUNCTION(winsock_module, listen); + GET_WINSOCK_FUNCTION(winsock_module, send); + GET_WINSOCK_FUNCTION(winsock_module, ioctlsocket); + GET_WINSOCK_FUNCTION(winsock_module, accept); + GET_WINSOCK_FUNCTION(winsock_module, recv); + GET_WINSOCK_FUNCTION(winsock_module, WSAIoctl); if (p_WSAStartup(winsock_ver, &wsadata)) { fatalbox("Unable to initialise WinSock"); @@ -225,6 +251,8 @@ void sk_cleanup(void) p_WSACleanup(); if (winsock_module) FreeLibrary(winsock_module); + if (wship6_module) + FreeLibrary(wship6_module); } char *winsock_error_string(int error) @@ -328,30 +356,16 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, if ((a = p_inet_addr(host)) == (unsigned long) INADDR_NONE) { #ifndef NO_IPV6 - - /* Try to get the getaddrinfo() function from wship6.dll */ - /* This way one doesn't need to have IPv6 dll's to use PuTTY and - * it will fallback to IPv4. */ - typedef int (CALLBACK * FGETADDRINFO) (const char *nodename, - const char *servname, - const struct addrinfo *hints, - struct addrinfo **res); - FGETADDRINFO fGetAddrInfo = NULL; - - HINSTANCE dllWSHIP6 = LoadLibrary("wship6.dll"); - if (dllWSHIP6) - fGetAddrInfo = (FGETADDRINFO) GetProcAddress(dllWSHIP6, - "getaddrinfo"); - /* - * Use fGetAddrInfo when it's available + * Use getaddrinfo when it's available */ - if (fGetAddrInfo) { + if (p_getaddrinfo) { struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = ret->family; - if ((err = fGetAddrInfo(host, NULL, &hints, &ret->ai)) == 0) - ret_family = ret->ai->ai_family; + if ((err = p_getaddrinfo(host, NULL, &hints, &ret->ais)) == 0) + ret_family = ret->ais->ai_family; + ret->ai = ret->ais; } else #endif { @@ -370,7 +384,7 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, err == WSAHOST_NOT_FOUND ? "Host does not exist" : err == WSATRY_AGAIN ? "Host not found" : #ifndef NO_IPV6 - fGetAddrInfo ? "getaddrinfo: unknown error" : + p_getaddrinfo ? "getaddrinfo: unknown error" : #endif "gethostbyname: unknown error"); } else { @@ -380,12 +394,6 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, #ifndef NO_IPV6 /* If we got an address info use that... */ if (ret->ai) { - typedef int (CALLBACK * FGETNAMEINFO) - (const struct sockaddr FAR * sa, socklen_t salen, - char FAR * host, size_t hostlen, char FAR * serv, - size_t servlen, int flags); - FGETNAMEINFO fGetNameInfo = NULL; - /* Are we in IPv4 fallback mode? */ /* We put the IPv4 address into the a variable so we can further-on use the IPv4 code... */ if (ret->family == AF_INET) @@ -394,11 +402,8 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, ai_addr)->sin_addr, sizeof(a)); /* Now let's find that canonicalname... */ - if ((dllWSHIP6) - && (fGetNameInfo = - (FGETNAMEINFO) GetProcAddress(dllWSHIP6, - "getnameinfo"))) { - if (fGetNameInfo + if (p_getnameinfo) { + if (p_getnameinfo ((struct sockaddr *) ret->ai->ai_addr, ret->family == AF_INET ? sizeof(SOCKADDR_IN) : @@ -412,23 +417,32 @@ SockAddr sk_namelookup(const char *host, char **canonicalname, else #endif { + int n; + for (n = 0; h->h_addr_list[n]; n++); + ret->addresses = snewn(n, unsigned long); + ret->naddresses = n; + for (n = 0; n < ret->naddresses; n++) { + memcpy(&a, h->h_addr_list[n], sizeof(a)); + ret->addresses[n] = p_ntohl(a); + } + ret->curraddr = 0; memcpy(&a, h->h_addr, sizeof(a)); /* This way we are always sure the h->h_name is valid :) */ strncpy(realhost, h->h_name, sizeof(realhost)); } } -#ifndef NO_IPV6 - FreeLibrary(dllWSHIP6); -#endif } else { /* * This must be a numeric IPv4 address because it caused a * success return from inet_addr. */ + ret->addresses = snewn(1, unsigned long); + ret->naddresses = 1; + ret->curraddr = 0; + ret->addresses[0] = p_ntohl(a); ret->family = AF_INET; strncpy(realhost, host, sizeof(realhost)); } - ret->address = p_ntohl(a); realhost[lenof(realhost)-1] = '\0'; *canonicalname = snewn(1+strlen(realhost), char); strcpy(*canonicalname, realhost); @@ -445,10 +459,30 @@ SockAddr sk_nonamelookup(const char *host) return ret; } +int sk_nextaddr(SockAddr addr) +{ +#ifndef NO_IPV6 + if (addr->ai) { + if (addr->ai->ai_next) { + addr->ai = addr->ai->ai_next; + addr->family = addr->ai->ai_family; + return TRUE; + } else + return FALSE; + } +#endif + if (addr->curraddr+1 < addr->naddresses) { + addr->curraddr++; + return TRUE; + } else { + return FALSE; + } +} + void sk_getaddr(SockAddr addr, char *buf, int buflen) { #ifndef NO_IPV6 - if (addr->family == AF_INET6) { + if (addr->ai) { /* Try to get the WSAAddressToStringA() function from wship6.dll */ /* This way one doesn't need to have IPv6 dll's to use PuTTY and * it will fallback to IPv4. */ @@ -475,7 +509,8 @@ void sk_getaddr(SockAddr addr, char *buf, int buflen) #endif if (addr->family == AF_INET) { struct in_addr a; - a.s_addr = p_htonl(addr->address); + assert(addr->addresses && addr->curraddr < addr->naddresses); + a.s_addr = p_htonl(addr->addresses[addr->curraddr]); strncpy(buf, p_inet_ntoa(a), buflen); buf[buflen-1] = '\0'; } else { @@ -529,7 +564,8 @@ int sk_address_is_local(SockAddr addr) #endif if (addr->family == AF_INET) { struct in_addr a; - a.s_addr = p_htonl(addr->address); + assert(addr->addresses && addr->curraddr < addr->naddresses); + a.s_addr = p_htonl(addr->addresses[addr->curraddr]); return ipv4_is_local_addr(a); } else { assert(addr->family == AF_UNSPEC); @@ -550,19 +586,33 @@ void sk_addrcopy(SockAddr addr, char *buf) { assert(addr->family != AF_UNSPEC); #ifndef NO_IPV6 - if (addr->family == AF_INET6) { - memcpy(buf, (char*) addr->ai, 16); + if (addr->ai) { + if (addr->family == AF_INET) + memcpy(buf, &((struct sockaddr_in *)addr->ai->ai_addr)->sin_addr, + sizeof(struct in_addr)); + else if (addr->family == AF_INET6) + memcpy(buf, &((struct sockaddr_in6 *)addr->ai->ai_addr)->sin6_addr, + sizeof(struct in6_addr)); + else + assert(FALSE); } else #endif if (addr->family == AF_INET) { struct in_addr a; - a.s_addr = p_htonl(addr->address); + assert(addr->addresses && addr->curraddr < addr->naddresses); + a.s_addr = p_htonl(addr->addresses[addr->curraddr]); memcpy(buf, (char*) &a.s_addr, 4); } } void sk_addr_free(SockAddr addr) { +#ifndef NO_IPV6 + if (addr->ais && p_freeaddrinfo) + p_freeaddrinfo(addr->ais); +#endif + if (addr->addresses) + sfree(addr->addresses); sfree(addr); } @@ -626,6 +676,7 @@ Socket sk_register(void *sock, Plug plug) ret->localhost_only = 0; /* unused, but best init anyway */ ret->pending_error = 0; ret->parent = ret->child = NULL; + ret->addr = NULL; ret->s = (SOCKET)sock; @@ -650,21 +701,8 @@ Socket sk_register(void *sock, Plug plug) return (Socket) ret; } -Socket sk_new(SockAddr addr, int port, int privport, int oobinline, - int nodelay, int keepalive, Plug plug) +static DWORD try_connect(Actual_Socket sock) { - static const 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; #ifndef NO_IPV6 SOCKADDR_IN6 a6; @@ -672,25 +710,15 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, SOCKADDR_IN a; DWORD err; char *errstr; - Actual_Socket ret; short localport; + int family; - /* - * Create Socket structure. - */ - ret = snew(struct Socket_tag); - ret->fn = &fn_table; - ret->error = NULL; - ret->plug = plug; - 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; - ret->parent = ret->child = NULL; + if (sock->s != INVALID_SOCKET) { + do_select(sock->s, 0); + p_closesocket(sock->s); + } + + plug_log(sock->plug, 0, sock->addr, sock->port, NULL, 0); /* * Open socket. @@ -698,32 +726,35 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, #ifndef NO_IPV6 /* Let's default to IPv6, this shouldn't hurt anybody * If the stack supports IPv6 it will also allow IPv4 connections. */ - if (addr->family == AF_UNSPEC) addr->family = AF_INET6; -#else - /* No other choice, default to IPv4 */ - if (addr->family == AF_UNSPEC) addr->family = AF_INET; + if (sock->addr->ai) { + family = sock->addr->ai->ai_family; + } else #endif - s = p_socket(addr->family, SOCK_STREAM, 0); - ret->s = s; + { + /* Default to IPv4 */ + family = AF_INET; + } + + s = p_socket(family, SOCK_STREAM, 0); + sock->s = s; if (s == INVALID_SOCKET) { err = p_WSAGetLastError(); - ret->error = winsock_error_string(err); - return (Socket) ret; + sock->error = winsock_error_string(err); + goto ret; } - ret->oobinline = oobinline; - if (oobinline) { + if (sock->oobinline) { BOOL b = TRUE; p_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b)); } - if (nodelay) { + if (sock->nodelay) { BOOL b = TRUE; p_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b)); } - if (keepalive) { + if (sock->keepalive) { BOOL b = TRUE; p_setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *) &b, sizeof(b)); } @@ -731,17 +762,17 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, /* * Bind to local address. */ - if (privport) + if (sock->privport) localport = 1023; /* count from 1023 downwards */ else localport = 0; /* just use port 0 (ie winsock picks) */ /* Loop round trying to bind */ while (1) { - int retcode; + int sockcode; #ifndef NO_IPV6 - if (addr->family == AF_INET6) { + if (family == AF_INET6) { memset(&a6, 0, sizeof(a6)); a6.sin6_family = AF_INET6; /*a6.sin6_addr = in6addr_any; */ /* == 0 done by memset() */ @@ -754,15 +785,15 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, a.sin_port = p_htons(localport); } #ifndef NO_IPV6 - retcode = p_bind(s, (addr->family == AF_INET6 ? + sockcode = p_bind(s, (sock->addr->family == AF_INET6 ? (struct sockaddr *) &a6 : (struct sockaddr *) &a), - (addr->family == + (sock->addr->family == AF_INET6 ? sizeof(a6) : sizeof(a))); #else - retcode = p_bind(s, (struct sockaddr *) &a, sizeof(a)); + sockcode = p_bind(s, (struct sockaddr *) &a, sizeof(a)); #endif - if (retcode != SOCKET_ERROR) { + if (sockcode != SOCKET_ERROR) { err = 0; break; /* done */ } else { @@ -779,41 +810,50 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, } if (err) { - ret->error = winsock_error_string(err); - return (Socket) ret; + sock->error = winsock_error_string(err); + goto ret; } /* * Connect to remote address. */ #ifndef NO_IPV6 - if (addr->family == AF_INET6) { - memset(&a, 0, sizeof(a)); - a6.sin6_family = AF_INET6; - a6.sin6_port = p_htons((short) port); - a6.sin6_addr = - ((struct sockaddr_in6 *) addr->ai->ai_addr)->sin6_addr; + if (sock->addr->ai) { + if (family == AF_INET6) { + a6.sin6_family = AF_INET6; + a6.sin6_port = p_htons((short) sock->port); + a6.sin6_addr = + ((struct sockaddr_in6 *) sock->addr->ai->ai_addr)->sin6_addr; + } else { + a.sin_family = AF_INET; + a.sin_addr = + ((struct sockaddr_in *) sock->addr->ai->ai_addr)->sin_addr; + a.sin_port = p_htons((short) sock->port); + } } else #endif { + assert(sock->addr->addresses && sock->addr->curraddr < sock->addr->naddresses); a.sin_family = AF_INET; - a.sin_addr.s_addr = p_htonl(addr->address); - a.sin_port = p_htons((short) port); + a.sin_addr.s_addr = p_htonl(sock->addr->addresses[sock->addr->curraddr]); + a.sin_port = p_htons((short) sock->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; + sock->error = errstr; + err = 1; + goto ret; } if (( #ifndef NO_IPV6 - p_connect(s, ((addr->family == AF_INET6) ? - (struct sockaddr *) &a6 : (struct sockaddr *) &a), - (addr->family == AF_INET6) ? sizeof(a6) : sizeof(a)) + p_connect(s, + ((family == AF_INET6) ? (struct sockaddr *) &a6 : + (struct sockaddr *) &a), + (family == AF_INET6) ? sizeof(a6) : sizeof(a)) #else p_connect(s, (struct sockaddr *) &a, sizeof(a)) #endif @@ -826,21 +866,73 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, * asynchronously. */ if ( err != WSAEWOULDBLOCK ) { - ret->error = winsock_error_string(err); - return (Socket) ret; + sock->error = winsock_error_string(err); + goto ret; } } else { /* * If we _don't_ get EWOULDBLOCK, the connect has completed * and we should set the socket as writable. */ - ret->writable = 1; + sock->writable = 1; } - add234(sktree, ret); + add234(sktree, sock); + + err = 0; - /* We're done with 'addr' now. */ - sk_addr_free(addr); + ret: + if (err) + plug_log(sock->plug, 1, sock->addr, sock->port, sock->error, err); + return err; +} + +Socket sk_new(SockAddr addr, int port, int privport, int oobinline, + int nodelay, int keepalive, Plug plug) +{ + static const 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 + }; + + Actual_Socket ret; + DWORD err; + + /* + * Create Socket structure. + */ + ret = snew(struct Socket_tag); + ret->fn = &fn_table; + ret->error = NULL; + ret->plug = plug; + 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; + ret->parent = ret->child = NULL; + ret->oobinline = oobinline; + ret->nodelay = nodelay; + ret->keepalive = keepalive; + ret->privport = privport; + ret->port = port; + ret->addr = addr; + ret->s = INVALID_SOCKET; + + err = 0; + do { + err = try_connect(ret); + } while (err && sk_nextaddr(ret->addr)); return (Socket) ret; } @@ -889,6 +981,7 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, ret->localhost_only = local_host_only; ret->pending_error = 0; ret->parent = ret->child = NULL; + ret->addr = NULL; /* * Translate address_family from platform-independent constants @@ -1045,6 +1138,8 @@ static void sk_tcp_close(Socket sock) del234(sktree, s); do_select(s->s, 0); p_closesocket(s->s); + if (s->addr) + sk_addr_free(s->addr); sfree(s); } @@ -1180,7 +1275,17 @@ int select_result(WPARAM wParam, LPARAM lParam) * An error has occurred on this socket. Pass it to the * plug. */ - return plug_closing(s->plug, winsock_error_string(err), err, 0); + if (s->addr) { + plug_log(s->plug, 1, s->addr, s->port, + winsock_error_string(err), err); + while (s->addr && sk_nextaddr(s->addr)) { + err = try_connect(s); + } + } + if (err != 0) + return plug_closing(s->plug, winsock_error_string(err), err, 0); + else + return 1; } noise_ultralight(lParam); @@ -1188,6 +1293,15 @@ int select_result(WPARAM wParam, LPARAM lParam) switch (WSAGETSELECTEVENT(lParam)) { case FD_CONNECT: s->connected = s->writable = 1; + /* + * Once a socket is connected, we can stop falling + * back through the candidate addresses to connect + * to. + */ + if (s->addr) { + sk_addr_free(s->addr); + s->addr = NULL; + } break; case FD_READ: /* In the case the socket is still frozen, we don't even bother */ diff --git a/x11fwd.c b/x11fwd.c index 52b320d1..0eec1211 100644 --- a/x11fwd.c +++ b/x11fwd.c @@ -178,6 +178,12 @@ static char *x11_verify(unsigned long peer_ip, int peer_port, return NULL; } +static void x11_log(Plug p, int type, SockAddr addr, int port, + const char *error_msg, int error_code) +{ + /* We have no interface to the logging module here, so we drop these. */ +} + static int x11_closing(Plug plug, const char *error_msg, int error_code, int calling_back) { @@ -259,6 +265,7 @@ const char *x11_init(Socket * s, char *display, void *c, void *auth, const char *peeraddr, int peerport, const Config *cfg) { static const struct plug_function_table fn_table = { + x11_log, x11_closing, x11_receive, x11_sent, -- 2.11.0