nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-09 09:27:59 +00:00
Code Issues Projects Releases Wiki Activity

Support for falling back through the list of addresses returned from

Browse Source 
a DNS lookup, whether they're IPv4, v6 or a mixture of both.

[originally from svn r5119]
[this svn revision also touched putty-wishlist]
This commit is contained in:
Simon Tatham 2005-01-16 14:29:34 +00:00
parent 0f754aac82
commit f70efc5cc6
10 changed files with 648 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
network.h
View File

@ -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))

9
portfwd.c
View File

@ -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 */

10
proxy.c
View File

@ -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,

24
raw.c
View File

@ -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)

24
rlogin.c
View File

@ -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)

22
ssh.c
View File

@ -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);

28
telnet.c
View File

@ -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)

289
unix/uxnet.c
View File

@ -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);
sk_addr_free(addr);
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));
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;
}

572
windows/winnet.c
View File

@ -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,6 +701,192 @@ Socket sk_register(void *sock, Plug plug)
return (Socket) ret;
}
static DWORD try_connect(Actual_Socket sock)
{
SOCKET s;
#ifndef NO_IPV6
SOCKADDR_IN6 a6;
#endif
SOCKADDR_IN a;
DWORD err;
char *errstr;
short localport;
int family;
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.
*/
#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 (sock->addr->ai) {
family = sock->addr->ai->ai_family;
} else
#endif
{
/* Default to IPv4 */
family = AF_INET;
}
s = p_socket(family, SOCK_STREAM, 0);
sock->s = s;
if (s == INVALID_SOCKET) {
err = p_WSAGetLastError();
sock->error = winsock_error_string(err);
goto ret;
}
if (sock->oobinline) {
BOOL b = TRUE;
p_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b));
}
if (sock->nodelay) {
BOOL b = TRUE;
p_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b));
}
if (sock->keepalive) {
BOOL b = TRUE;
p_setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *) &b, sizeof(b));
}
/*
* Bind to local address.
*/
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 sockcode;
#ifndef NO_IPV6
if (family == AF_INET6) {
memset(&a6, 0, sizeof(a6));
a6.sin6_family = AF_INET6;
/*a6.sin6_addr = in6addr_any; */ /* == 0 done by memset() */
a6.sin6_port = p_htons(localport);
} else
#endif
{
a.sin_family = AF_INET;
a.sin_addr.s_addr = p_htonl(INADDR_ANY);
a.sin_port = p_htons(localport);
}
#ifndef NO_IPV6
sockcode = p_bind(s, (sock->addr->family == AF_INET6 ?
(struct sockaddr *) &a6 :
(struct sockaddr *) &a),
(sock->addr->family ==
AF_INET6 ? sizeof(a6) : sizeof(a)));
#else
sockcode = p_bind(s, (struct sockaddr *) &a, sizeof(a));
#endif
if (sockcode != SOCKET_ERROR) {
err = 0;
break; /* done */
} else {
err = p_WSAGetLastError();
if (err != WSAEADDRINUSE) /* failed, for a bad reason */
break;
}
if (localport == 0)
break; /* we're only looping once */
localport--;
if (localport == 0)
break; /* we might have got to the end */
}
if (err) {
sock->error = winsock_error_string(err);
goto ret;
}
/*
* Connect to remote address.
*/
#ifndef NO_IPV6
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(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) {
sock->error = errstr;
err = 1;
goto ret;
}
if ((
#ifndef NO_IPV6
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
) == SOCKET_ERROR) {
err = p_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 ) {
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.
*/
sock->writable = 1;
}
add234(sktree, sock);
err = 0;
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)
{
@ -665,15 +902,8 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
sk_tcp_socket_error
};
SOCKET s;
#ifndef NO_IPV6
SOCKADDR_IN6 a6;
#endif
SOCKADDR_IN a;
DWORD err;
char *errstr;
Actual_Socket ret;
short localport;
DWORD err;
/*
* Create Socket structure.
@ -691,156 +921,18 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
ret->localhost_only = 0; /* unused, but best init anyway */
ret->pending_error = 0;
ret->parent = ret->child = NULL;
/*
* Open socket.
*/
#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;
#endif
s = p_socket(addr->family, SOCK_STREAM, 0);
ret->s = s;
if (s == INVALID_SOCKET) {
err = p_WSAGetLastError();
ret->error = winsock_error_string(err);
return (Socket) ret;
}
ret->oobinline = oobinline;
if (oobinline) {
BOOL b = TRUE;
p_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b));
}
ret->nodelay = nodelay;
ret->keepalive = keepalive;
ret->privport = privport;
ret->port = port;
ret->addr = addr;
ret->s = INVALID_SOCKET;
if (nodelay) {
BOOL b = TRUE;
p_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b));
}
if (keepalive) {
BOOL b = TRUE;
p_setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *) &b, sizeof(b));
}
/*
* Bind to local address.
*/
if (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;
#ifndef NO_IPV6
if (addr->family == AF_INET6) {
memset(&a6, 0, sizeof(a6));
a6.sin6_family = AF_INET6;
/*a6.sin6_addr = in6addr_any; */ /* == 0 done by memset() */
a6.sin6_port = p_htons(localport);
} else
#endif
{
a.sin_family = AF_INET;
a.sin_addr.s_addr = p_htonl(INADDR_ANY);
a.sin_port = p_htons(localport);
}
#ifndef NO_IPV6
retcode = p_bind(s, (addr->family == AF_INET6 ?
(struct sockaddr *) &a6 :
(struct sockaddr *) &a),
(addr->family ==
AF_INET6 ? sizeof(a6) : sizeof(a)));
#else
retcode = p_bind(s, (struct sockaddr *) &a, sizeof(a));
#endif
if (retcode != SOCKET_ERROR) {
err = 0;
break; /* done */
} else {
err = p_WSAGetLastError();
if (err != WSAEADDRINUSE) /* failed, for a bad reason */
break;
}
if (localport == 0)
break; /* we're only looping once */
localport--;
if (localport == 0)
break; /* we might have got to the end */
}
if (err) {
ret->error = winsock_error_string(err);
return (Socket) 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;
} else
#endif
{
a.sin_family = AF_INET;
a.sin_addr.s_addr = p_htonl(addr->address);
a.sin_port = p_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 ((
#ifndef NO_IPV6
p_connect(s, ((addr->family == AF_INET6) ?
(struct sockaddr *) &a6 : (struct sockaddr *) &a),
(addr->family == AF_INET6) ? sizeof(a6) : sizeof(a))
#else
p_connect(s, (struct sockaddr *) &a, sizeof(a))
#endif
) == SOCKET_ERROR) {
err = p_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);
/* We're done with 'addr' now. */
sk_addr_free(addr);
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 */

7
x11fwd.c
View File

@ -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,