X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/putty/blobdiff_plain/39934deb5202149f98198c111a35c21cb4d0d0f8..42466758a12a92c5efb190ee0e2884d8657c1a27:/windows/winnet.c diff --git a/windows/winnet.c b/windows/winnet.c index f2b2aaa4..4fddd72c 100644 --- a/windows/winnet.c +++ b/windows/winnet.c @@ -1,43 +1,10 @@ /* * Windows networking abstraction. * - * Due to this clean abstraction it was possible - * to easily implement IPv6 support :) - * - * IPv6 patch 1 (27 October 2000) Jeroen Massar - * - Preliminary hacked IPv6 support. - * - Connecting to IPv6 address (eg fec0:4242:4242:100:2d0:b7ff:fe8f:5d42) works. - * - Connecting to IPv6 hostname (eg heaven.ipv6.unfix.org) works. - * - Compiles as either IPv4 or IPv6. - * - * IPv6 patch 2 (29 October 2000) Jeroen Massar - * - When compiled as IPv6 it also allows connecting to IPv4 hosts. - * - Added some more documentation. - * - * IPv6 patch 3 (18 November 2000) Jeroen Massar - * - It now supports dynamically loading the IPv6 resolver dll's. - * This way we should be able to distribute one (1) binary - * which supports both IPv4 and IPv6. - * - getaddrinfo() and getnameinfo() are loaded dynamicaly if possible. - * - in6addr_any is defined in this file so we don't need to link to wship6.lib - * - The patch is now more unified so that we can still - * remove all IPv6 support by undef'ing IPV6. - * But where it fallsback to IPv4 it uses the IPv4 code which is already in place... - * - Canonical name resolving works. - * - * IPv6 patch 4 (07 January 2001) Jeroen Massar - * - patch against CVS of today, will be submitted to the bugs list - * as a 'cvs diff -u' on Simon's request... - * + * For the IPv6 code in here I am indebted to Jeroen Massar and + * unfix.org. */ -/* - * Define IPV6 to have IPv6 on-the-fly-loading support. - * This means that one doesn't have to have an IPv6 stack to use it. - * But if an IPv6 stack is found it is used with a fallback to IPv4. - */ -/* #define IPV6 1 */ - #include #include #include @@ -48,13 +15,38 @@ #include "tree234.h" #include -#ifdef IPV6 -#include + +#ifndef NO_IPV6 +const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; +const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT; #endif #define ipv4_is_loopback(addr) \ ((p_ntohl(addr.s_addr) & 0xFF000000L) == 0x7F000000L) +/* + * We used to typedef struct Socket_tag *Socket. + * + * Since we have made the networking abstraction slightly more + * abstract, Socket no longer means a tcp socket (it could mean + * an ssl socket). So now we must use Actual_Socket when we know + * we are talking about a tcp socket. + */ +typedef struct Socket_tag *Actual_Socket; + +/* + * Mutable state that goes with a SockAddr: stores information + * about where in the list of candidate IP(v*) addresses we've + * currently got to. + */ +typedef struct SockAddrStep_tag SockAddrStep; +struct SockAddrStep_tag { +#ifndef NO_IPV6 + struct addrinfo *ai; /* steps along addr->ais */ +#endif + int curraddr; +}; + struct Socket_tag { const struct socket_function_table *fn; /* the above variable absolutely *must* be the first in this structure */ @@ -71,36 +63,60 @@ struct Socket_tag { int localhost_only; /* for listening sockets */ char oobdata[1]; int sending_oob; - int oobinline; + int oobinline, nodelay, keepalive, privport; + enum { EOF_NO, EOF_PENDING, EOF_SENT } outgoingeof; + SockAddr addr; + SockAddrStep step; + int port; int pending_error; /* in case send() returns error */ + /* + * We sometimes need pairs of Socket structures to be linked: + * if we are listening on the same IPv6 and v4 port, for + * example. So here we define `parent' and `child' pointers to + * track this link. + */ + Actual_Socket parent, child; }; -/* - * We used to typedef struct Socket_tag *Socket. - * - * Since we have made the networking abstraction slightly more - * abstract, Socket no longer means a tcp socket (it could mean - * an ssl socket). So now we must use Actual_Socket when we know - * we are talking about a tcp socket. - */ -typedef struct Socket_tag *Actual_Socket; - struct SockAddr_tag { + int refcount; char *error; - /* - * Which address family this address belongs to. AF_INET for - * IPv4; AF_INET6 for IPv6; AF_UNSPEC indicates that name - * resolution has not been done and a simple host name is held - * in this SockAddr structure. - */ - int family; - unsigned long address; /* Address IPv4 style. */ -#ifdef IPV6 - struct addrinfo *ai; /* Address IPv6 style. */ + int resolved; +#ifndef NO_IPV6 + struct addrinfo *ais; /* Addresses IPv6 style. */ #endif + unsigned long *addresses; /* Addresses IPv4 style. */ + int naddresses; char hostname[512]; /* Store an unresolved host name. */ }; +/* + * Which address family this address belongs to. AF_INET for IPv4; + * AF_INET6 for IPv6; AF_UNSPEC indicates that name resolution has + * not been done and a simple host name is held in this SockAddr + * structure. + */ +#ifndef NO_IPV6 +#define SOCKADDR_FAMILY(addr, step) \ + (!(addr)->resolved ? AF_UNSPEC : \ + (step).ai ? (step).ai->ai_family : AF_INET) +#else +#define SOCKADDR_FAMILY(addr, step) \ + (!(addr)->resolved ? AF_UNSPEC : AF_INET) +#endif + +/* + * Start a SockAddrStep structure to step through multiple + * addresses. + */ +#ifndef NO_IPV6 +#define START_STEP(addr, step) \ + ((step).ai = (addr)->ais, (step).curraddr = 0) +#else +#define START_STEP(addr, step) \ + ((step).curraddr = 0) +#endif + static tree234 *sktree; static int cmpfortree(void *av, void *bv) @@ -111,6 +127,10 @@ static int cmpfortree(void *av, void *bv) return -1; if (as > bs) return +1; + if (a < b) + return -1; + if (a > b) + return +1; return 0; } @@ -125,105 +145,166 @@ static int cmpforsearch(void *av, void *bv) return 0; } -#define NOTHING -#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) - -DECL_WINSOCK_FUNCTION(NOTHING, int, WSAAsyncSelect, - (SOCKET, HWND, u_int, long)); -DECL_WINSOCK_FUNCTION(NOTHING, int, WSAEventSelect, (SOCKET, WSAEVENT, long)); -DECL_WINSOCK_FUNCTION(NOTHING, int, select, - (int, fd_set FAR *, fd_set FAR *, - fd_set FAR *, const struct timeval FAR *)); -DECL_WINSOCK_FUNCTION(NOTHING, int, WSAGetLastError, (void)); -DECL_WINSOCK_FUNCTION(NOTHING, int, WSAEnumNetworkEvents, - (SOCKET, WSAEVENT, LPWSANETWORKEVENTS)); -DECL_WINSOCK_FUNCTION(static, int, WSAStartup, (WORD, LPWSADATA)); -DECL_WINSOCK_FUNCTION(static, int, WSACleanup, (void)); -DECL_WINSOCK_FUNCTION(static, int, closesocket, (SOCKET)); -DECL_WINSOCK_FUNCTION(static, u_long, ntohl, (u_long)); -DECL_WINSOCK_FUNCTION(static, u_long, htonl, (u_long)); -DECL_WINSOCK_FUNCTION(static, u_short, htons, (u_short)); -DECL_WINSOCK_FUNCTION(static, u_short, ntohs, (u_short)); -DECL_WINSOCK_FUNCTION(static, struct hostent FAR *, gethostbyname, +DECL_WINDOWS_FUNCTION(static, int, WSAStartup, (WORD, LPWSADATA)); +DECL_WINDOWS_FUNCTION(static, int, WSACleanup, (void)); +DECL_WINDOWS_FUNCTION(static, int, closesocket, (SOCKET)); +DECL_WINDOWS_FUNCTION(static, u_long, ntohl, (u_long)); +DECL_WINDOWS_FUNCTION(static, u_long, htonl, (u_long)); +DECL_WINDOWS_FUNCTION(static, u_short, htons, (u_short)); +DECL_WINDOWS_FUNCTION(static, u_short, ntohs, (u_short)); +DECL_WINDOWS_FUNCTION(static, int, gethostname, (char *, int)); +DECL_WINDOWS_FUNCTION(static, struct hostent FAR *, gethostbyname, (const char FAR *)); -DECL_WINSOCK_FUNCTION(static, struct servent FAR *, getservbyname, +DECL_WINDOWS_FUNCTION(static, struct servent FAR *, getservbyname, (const char FAR *, const char FAR *)); -DECL_WINSOCK_FUNCTION(static, unsigned long, inet_addr, (const char FAR *)); -DECL_WINSOCK_FUNCTION(static, char FAR *, inet_ntoa, (struct in_addr)); -DECL_WINSOCK_FUNCTION(static, int, connect, +DECL_WINDOWS_FUNCTION(static, unsigned long, inet_addr, (const char FAR *)); +DECL_WINDOWS_FUNCTION(static, char FAR *, inet_ntoa, (struct in_addr)); +DECL_WINDOWS_FUNCTION(static, int, connect, (SOCKET, const struct sockaddr FAR *, int)); -DECL_WINSOCK_FUNCTION(static, int, bind, +DECL_WINDOWS_FUNCTION(static, int, bind, (SOCKET, const struct sockaddr FAR *, int)); -DECL_WINSOCK_FUNCTION(static, int, setsockopt, +DECL_WINDOWS_FUNCTION(static, int, setsockopt, (SOCKET, int, int, const char FAR *, int)); -DECL_WINSOCK_FUNCTION(static, SOCKET, socket, (int, int, int)); -DECL_WINSOCK_FUNCTION(static, int, listen, (SOCKET, int)); -DECL_WINSOCK_FUNCTION(static, int, send, (SOCKET, const char FAR *, int, int)); -DECL_WINSOCK_FUNCTION(static, int, ioctlsocket, +DECL_WINDOWS_FUNCTION(static, SOCKET, socket, (int, int, int)); +DECL_WINDOWS_FUNCTION(static, int, listen, (SOCKET, int)); +DECL_WINDOWS_FUNCTION(static, int, send, (SOCKET, const char FAR *, int, int)); +DECL_WINDOWS_FUNCTION(static, int, shutdown, (SOCKET, int)); +DECL_WINDOWS_FUNCTION(static, int, ioctlsocket, (SOCKET, long, u_long FAR *)); -DECL_WINSOCK_FUNCTION(static, SOCKET, accept, +DECL_WINDOWS_FUNCTION(static, SOCKET, accept, (SOCKET, struct sockaddr FAR *, int FAR *)); -DECL_WINSOCK_FUNCTION(static, int, recv, (SOCKET, char FAR *, int, int)); -DECL_WINSOCK_FUNCTION(static, int, WSAIoctl, +DECL_WINDOWS_FUNCTION(static, int, recv, (SOCKET, char FAR *, int, int)); +DECL_WINDOWS_FUNCTION(static, int, WSAIoctl, (SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE)); +#ifndef NO_IPV6 +DECL_WINDOWS_FUNCTION(static, int, getaddrinfo, + (const char *nodename, const char *servname, + const struct addrinfo *hints, struct addrinfo **res)); +DECL_WINDOWS_FUNCTION(static, void, freeaddrinfo, (struct addrinfo *res)); +DECL_WINDOWS_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)); +DECL_WINDOWS_FUNCTION(static, char *, gai_strerror, (int ecode)); +DECL_WINDOWS_FUNCTION(static, int, WSAAddressToStringA, + (LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFO, + LPSTR, LPDWORD)); +#endif -static HMODULE winsock_module; +static HMODULE winsock_module = NULL; +static WSADATA wsadata; +#ifndef NO_IPV6 +static HMODULE winsock2_module = NULL; +static HMODULE wship6_module = NULL; +#endif -void sk_init(void) +int sk_startup(int hi, int lo) { WORD winsock_ver; - WSADATA wsadata; - winsock_ver = MAKEWORD(2, 0); - winsock_module = LoadLibrary("WS2_32.DLL"); + winsock_ver = MAKEWORD(hi, lo); + + if (p_WSAStartup(winsock_ver, &wsadata)) { + return FALSE; + } + + if (LOBYTE(wsadata.wVersion) != LOBYTE(winsock_ver)) { + return FALSE; + } + +#ifdef NET_SETUP_DIAGNOSTICS + { + char buf[80]; + sprintf(buf, "Using WinSock %d.%d", hi, lo); + logevent(NULL, buf); + } +#endif + return TRUE; +} + +void sk_init(void) +{ +#ifndef NO_IPV6 + winsock2_module = +#endif + winsock_module = load_system32_dll("ws2_32.dll"); if (!winsock_module) { - winsock_module = LoadLibrary("WSOCK32.DLL"); - winsock_ver = MAKEWORD(1, 1); + winsock_module = load_system32_dll("wsock32.dll"); } 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 + /* Check if we have getaddrinfo in Winsock */ + if (GetProcAddress(winsock_module, "getaddrinfo") != NULL) { +#ifdef NET_SETUP_DIAGNOSTICS + logevent(NULL, "Native WinSock IPv6 support detected"); +#endif + GET_WINDOWS_FUNCTION(winsock_module, getaddrinfo); + GET_WINDOWS_FUNCTION(winsock_module, freeaddrinfo); + GET_WINDOWS_FUNCTION(winsock_module, getnameinfo); + GET_WINDOWS_FUNCTION(winsock_module, gai_strerror); + } else { + /* Fall back to wship6.dll for Windows 2000 */ + wship6_module = load_system32_dll("wship6.dll"); + if (wship6_module) { +#ifdef NET_SETUP_DIAGNOSTICS + logevent(NULL, "WSH IPv6 support detected"); +#endif + GET_WINDOWS_FUNCTION(wship6_module, getaddrinfo); + GET_WINDOWS_FUNCTION(wship6_module, freeaddrinfo); + GET_WINDOWS_FUNCTION(wship6_module, getnameinfo); + GET_WINDOWS_FUNCTION(wship6_module, gai_strerror); + } else { +#ifdef NET_SETUP_DIAGNOSTICS + logevent(NULL, "No IPv6 support detected"); +#endif + } + } + GET_WINDOWS_FUNCTION(winsock2_module, WSAAddressToStringA); +#else +#ifdef NET_SETUP_DIAGNOSTICS + logevent(NULL, "PuTTY was built without IPv6 support"); +#endif +#endif - if (p_WSAStartup(winsock_ver, &wsadata)) { + GET_WINDOWS_FUNCTION(winsock_module, WSAAsyncSelect); + GET_WINDOWS_FUNCTION(winsock_module, WSAEventSelect); + GET_WINDOWS_FUNCTION(winsock_module, select); + GET_WINDOWS_FUNCTION(winsock_module, WSAGetLastError); + GET_WINDOWS_FUNCTION(winsock_module, WSAEnumNetworkEvents); + GET_WINDOWS_FUNCTION(winsock_module, WSAStartup); + GET_WINDOWS_FUNCTION(winsock_module, WSACleanup); + GET_WINDOWS_FUNCTION(winsock_module, closesocket); + GET_WINDOWS_FUNCTION(winsock_module, ntohl); + GET_WINDOWS_FUNCTION(winsock_module, htonl); + GET_WINDOWS_FUNCTION(winsock_module, htons); + GET_WINDOWS_FUNCTION(winsock_module, ntohs); + GET_WINDOWS_FUNCTION(winsock_module, gethostname); + GET_WINDOWS_FUNCTION(winsock_module, gethostbyname); + GET_WINDOWS_FUNCTION(winsock_module, getservbyname); + GET_WINDOWS_FUNCTION(winsock_module, inet_addr); + GET_WINDOWS_FUNCTION(winsock_module, inet_ntoa); + GET_WINDOWS_FUNCTION(winsock_module, connect); + GET_WINDOWS_FUNCTION(winsock_module, bind); + GET_WINDOWS_FUNCTION(winsock_module, setsockopt); + GET_WINDOWS_FUNCTION(winsock_module, socket); + GET_WINDOWS_FUNCTION(winsock_module, listen); + GET_WINDOWS_FUNCTION(winsock_module, send); + GET_WINDOWS_FUNCTION(winsock_module, shutdown); + GET_WINDOWS_FUNCTION(winsock_module, ioctlsocket); + GET_WINDOWS_FUNCTION(winsock_module, accept); + GET_WINDOWS_FUNCTION(winsock_module, recv); + GET_WINDOWS_FUNCTION(winsock_module, WSAIoctl); + + /* Try to get the best WinSock version we can get */ + if (!sk_startup(2,2) && + !sk_startup(2,0) && + !sk_startup(1,1)) { fatalbox("Unable to initialise WinSock"); } - if (LOBYTE(wsadata.wVersion) != LOBYTE(winsock_ver)) { - p_WSACleanup(); - fatalbox("WinSock version is incompatible with %d.%d", - LOBYTE(winsock_ver), HIBYTE(winsock_ver)); - } sktree = newtree234(cmpfortree); } @@ -241,13 +322,48 @@ void sk_cleanup(void) sktree = NULL; } - p_WSACleanup(); + if (p_WSACleanup) + p_WSACleanup(); if (winsock_module) FreeLibrary(winsock_module); +#ifndef NO_IPV6 + if (wship6_module) + FreeLibrary(wship6_module); +#endif +} + +struct errstring { + int error; + char *text; +}; + +static int errstring_find(void *av, void *bv) +{ + int *a = (int *)av; + struct errstring *b = (struct errstring *)bv; + if (*a < b->error) + return -1; + if (*a > b->error) + return +1; + return 0; +} +static int errstring_compare(void *av, void *bv) +{ + struct errstring *a = (struct errstring *)av; + return errstring_find(&a->error, bv); } +static tree234 *errstrings = NULL; + char *winsock_error_string(int error) { + const char prefix[] = "Network error: "; + struct errstring *es; + + /* + * Error codes we know about and have historically had reasonably + * sensible error messages for. + */ switch (error) { case WSAEACCES: return "Network error: Permission denied"; @@ -320,143 +436,167 @@ char *winsock_error_string(int error) return "Network error: Resource temporarily unavailable"; case WSAEDISCON: return "Network error: Graceful shutdown in progress"; - default: - return "Unknown network error"; } + + /* + * Generic code to handle any other error. + * + * Slightly nasty hack here: we want to return a static string + * which the caller will never have to worry about freeing, but on + * the other hand if we call FormatMessage to get it then it will + * want to either allocate a buffer or write into one we own. + * + * So what we do is to maintain a tree234 of error strings we've + * already used. New ones are allocated from the heap, but then + * put in this tree and kept forever. + */ + + if (!errstrings) + errstrings = newtree234(errstring_compare); + + es = find234(errstrings, &error, errstring_find); + + if (!es) { + int bufsize, bufused; + + es = snew(struct errstring); + es->error = error; + /* maximum size for FormatMessage is 64K */ + bufsize = 65535 + sizeof(prefix); + es->text = snewn(bufsize, char); + strcpy(es->text, prefix); + bufused = strlen(es->text); + if (!FormatMessage((FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS), NULL, error, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + es->text + bufused, bufsize - bufused, NULL)) { + sprintf(es->text + bufused, + "Windows error code %d (and FormatMessage returned %d)", + error, GetLastError()); + } else { + int len = strlen(es->text); + if (len > 0 && es->text[len-1] == '\n') + es->text[len-1] = '\0'; + } + es->text = sresize(es->text, strlen(es->text) + 1, char); + add234(errstrings, es); + } + + return es->text; } -SockAddr sk_namelookup(const char *host, char **canonicalname) +SockAddr sk_namelookup(const char *host, char **canonicalname, + int address_family) { SockAddr ret = snew(struct SockAddr_tag); unsigned long a; - struct hostent *h = NULL; char realhost[8192]; + int hint_family; + + /* Default to IPv4. */ + hint_family = (address_family == ADDRTYPE_IPV4 ? AF_INET : +#ifndef NO_IPV6 + address_family == ADDRTYPE_IPV6 ? AF_INET6 : +#endif + AF_UNSPEC); /* Clear the structure and default to IPv4. */ memset(ret, 0, sizeof(struct SockAddr_tag)); - ret->family = 0; /* We set this one when we have resolved the host. */ +#ifndef NO_IPV6 + ret->ais = NULL; +#endif + ret->addresses = NULL; + ret->resolved = FALSE; + ret->refcount = 1; *realhost = '\0'; if ((a = p_inet_addr(host)) == (unsigned long) INADDR_NONE) { -#ifdef 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"); - + struct hostent *h = NULL; + int err; +#ifndef NO_IPV6 /* - * Use fGetAddrInfo when it's available (which usually also - * means IPv6 is installed...) + * Use getaddrinfo when it's available */ - if (fGetAddrInfo) { - /*debug(("Resolving \"%s\" with getaddrinfo() (IPv4+IPv6 capable)...\n", host)); */ - if (fGetAddrInfo(host, NULL, NULL, &ret->ai) == 0) - ret->family = ret->ai->ai_family; + if (p_getaddrinfo) { + struct addrinfo hints; +#ifdef NET_SETUP_DIAGNOSTICS + logevent(NULL, "Using getaddrinfo() for resolving"); +#endif + memset(&hints, 0, sizeof(hints)); + hints.ai_family = hint_family; + hints.ai_flags = AI_CANONNAME; + if ((err = p_getaddrinfo(host, NULL, &hints, &ret->ais)) == 0) + ret->resolved = TRUE; } else #endif { +#ifdef NET_SETUP_DIAGNOSTICS + logevent(NULL, "Using gethostbyname() for resolving"); +#endif /* * Otherwise use the IPv4-only gethostbyname... - * (NOTE: we don't use gethostbyname as a - * fallback!) + * (NOTE: we don't use gethostbyname as a fallback!) */ - if (ret->family == 0) { - /*debug(("Resolving \"%s\" with gethostbyname() (IPv4 only)...\n", host)); */ - if ( (h = p_gethostbyname(host)) ) - ret->family = AF_INET; - } + if ( (h = p_gethostbyname(host)) ) + ret->resolved = TRUE; + else + err = p_WSAGetLastError(); } - /*debug(("Done resolving...(family is %d) AF_INET = %d, AF_INET6 = %d\n", ret->family, AF_INET, AF_INET6)); */ - if (ret->family == 0) { - DWORD err = p_WSAGetLastError(); + if (!ret->resolved) { ret->error = (err == WSAENETDOWN ? "Network is down" : - err == - WSAHOST_NOT_FOUND ? "Host does not exist" : err - == WSATRY_AGAIN ? "Host not found" : -#ifdef IPV6 - fGetAddrInfo ? "getaddrinfo: unknown error" : + err == WSAHOST_NOT_FOUND ? "Host does not exist" : + err == WSATRY_AGAIN ? "Host not found" : +#ifndef NO_IPV6 + p_getaddrinfo&&p_gai_strerror ? p_gai_strerror(err) : #endif "gethostbyname: unknown error"); -#ifdef DEBUG - { - LPVOID lpMsgBuf; - FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) & lpMsgBuf, 0, NULL); - /*debug(("Error %ld: %s (h=%lx)\n", err, lpMsgBuf, h)); */ - /* Free the buffer. */ - LocalFree(lpMsgBuf); - } -#endif } else { ret->error = NULL; -#ifdef IPV6 +#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; - + if (ret->ais) { /* 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) + if (ret->ais->ai_family == AF_INET) memcpy(&a, - (char *) &((SOCKADDR_IN *) ret->ai-> + (char *) &((SOCKADDR_IN *) ret->ais-> ai_addr)->sin_addr, sizeof(a)); - /* Now let's find that canonicalname... */ - if ((dllWSHIP6) - && (fGetNameInfo = - (FGETNAMEINFO) GetProcAddress(dllWSHIP6, - "getnameinfo"))) { - if (fGetNameInfo - ((struct sockaddr *) ret->ai->ai_addr, - ret->family == - AF_INET ? sizeof(SOCKADDR_IN) : - sizeof(SOCKADDR_IN6), realhost, - sizeof(realhost), NULL, 0, 0) != 0) { - strncpy(realhost, host, sizeof(realhost)); - } - } + if (ret->ais->ai_canonname) + strncpy(realhost, ret->ais->ai_canonname, lenof(realhost)); + else + strncpy(realhost, host, lenof(realhost)); } /* We used the IPv4-only gethostbyname()... */ 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); + } 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)); } } -#ifdef IPV6 - FreeLibrary(dllWSHIP6); -#endif } else { /* * This must be a numeric IPv4 address because it caused a * success return from inet_addr. */ - ret->family = AF_INET; + ret->addresses = snewn(1, unsigned long); + ret->naddresses = 1; + ret->addresses[0] = p_ntohl(a); + ret->resolved = TRUE; strncpy(realhost, host, sizeof(realhost)); } - ret->address = p_ntohl(a); realhost[lenof(realhost)-1] = '\0'; *canonicalname = snewn(1+strlen(realhost), char); strcpy(*canonicalname, realhost); @@ -467,34 +607,76 @@ SockAddr sk_nonamelookup(const char *host) { SockAddr ret = snew(struct SockAddr_tag); ret->error = NULL; - ret->family = AF_UNSPEC; + ret->resolved = FALSE; +#ifndef NO_IPV6 + ret->ais = NULL; +#endif + ret->addresses = NULL; + ret->naddresses = 0; + ret->refcount = 1; strncpy(ret->hostname, host, lenof(ret->hostname)); ret->hostname[lenof(ret->hostname)-1] = '\0'; return ret; } +int sk_nextaddr(SockAddr addr, SockAddrStep *step) +{ +#ifndef NO_IPV6 + if (step->ai) { + if (step->ai->ai_next) { + step->ai = step->ai->ai_next; + return TRUE; + } else + return FALSE; + } +#endif + if (step->curraddr+1 < addr->naddresses) { + step->curraddr++; + return TRUE; + } else { + return FALSE; + } +} + void sk_getaddr(SockAddr addr, char *buf, int buflen) { -#ifdef IPV6 - if (addr->family == AF_INET6) { - FIXME; /* I don't know how to get a text form of an IPv6 address. */ + SockAddrStep step; + START_STEP(addr, step); + +#ifndef NO_IPV6 + if (step.ai) { + int err = 0; + if (p_WSAAddressToStringA) { + DWORD dwbuflen = buflen; + err = p_WSAAddressToStringA(step.ai->ai_addr, step.ai->ai_addrlen, + NULL, buf, &dwbuflen); + } else + err = -1; + if (err) { + strncpy(buf, addr->hostname, buflen); + if (!buf[0]) + strncpy(buf, "", buflen); + buf[buflen-1] = '\0'; + } } else #endif - if (addr->family == AF_INET) { + if (SOCKADDR_FAMILY(addr, step) == AF_INET) { struct in_addr a; - a.s_addr = p_htonl(addr->address); + assert(addr->addresses && step.curraddr < addr->naddresses); + a.s_addr = p_htonl(addr->addresses[step.curraddr]); strncpy(buf, p_inet_ntoa(a), buflen); buf[buflen-1] = '\0'; } else { - assert(addr->family == AF_UNSPEC); strncpy(buf, addr->hostname, buflen); buf[buflen-1] = '\0'; } } -int sk_hostname_is_local(char *name) +int sk_hostname_is_local(const char *name) { - return !strcmp(name, "localhost"); + return !strcmp(name, "localhost") || + !strcmp(name, "::1") || + !strncmp(name, "127.", 4); } static INTERFACE_INFO local_interfaces[16]; @@ -530,50 +712,101 @@ static int ipv4_is_local_addr(struct in_addr addr) int sk_address_is_local(SockAddr addr) { -#ifdef IPV6 - if (addr->family == AF_INET6) { - FIXME; /* someone who can compile for IPV6 had better do this bit */ + SockAddrStep step; + int family; + START_STEP(addr, step); + family = SOCKADDR_FAMILY(addr, step); + +#ifndef NO_IPV6 + if (family == AF_INET6) { + return IN6_IS_ADDR_LOOPBACK(&((const struct sockaddr_in6 *)step.ai->ai_addr)->sin6_addr); } else #endif - if (addr->family == AF_INET) { - struct in_addr a; - a.s_addr = p_htonl(addr->address); - return ipv4_is_local_addr(a); + if (family == AF_INET) { +#ifndef NO_IPV6 + if (step.ai) { + return ipv4_is_local_addr(((struct sockaddr_in *)step.ai->ai_addr) + ->sin_addr); + } else +#endif + { + struct in_addr a; + assert(addr->addresses && step.curraddr < addr->naddresses); + a.s_addr = p_htonl(addr->addresses[step.curraddr]); + return ipv4_is_local_addr(a); + } } else { - assert(addr->family == AF_UNSPEC); + assert(family == AF_UNSPEC); return 0; /* we don't know; assume not */ } } +int sk_address_is_special_local(SockAddr addr) +{ + return 0; /* no Unix-domain socket analogue here */ +} + int sk_addrtype(SockAddr addr) { - return (addr->family == AF_INET ? ADDRTYPE_IPV4 : -#ifdef IPV6 - addr->family == AF_INET6 ? ADDRTYPE_IPV6 : + SockAddrStep step; + int family; + START_STEP(addr, step); + family = SOCKADDR_FAMILY(addr, step); + + return (family == AF_INET ? ADDRTYPE_IPV4 : +#ifndef NO_IPV6 + family == AF_INET6 ? ADDRTYPE_IPV6 : #endif ADDRTYPE_NAME); } void sk_addrcopy(SockAddr addr, char *buf) { - assert(addr->family != AF_UNSPEC); -#ifdef IPV6 - if (addr->family == AF_INET6) { - memcpy(buf, (char*) addr->ai, 16); + SockAddrStep step; + int family; + START_STEP(addr, step); + family = SOCKADDR_FAMILY(addr, step); + + assert(family != AF_UNSPEC); +#ifndef NO_IPV6 + if (step.ai) { + if (family == AF_INET) + memcpy(buf, &((struct sockaddr_in *)step.ai->ai_addr)->sin_addr, + sizeof(struct in_addr)); + else if (family == AF_INET6) + memcpy(buf, &((struct sockaddr_in6 *)step.ai->ai_addr)->sin6_addr, + sizeof(struct in6_addr)); + else + assert(FALSE); } else #endif - if (addr->family == AF_INET) { + if (family == AF_INET) { struct in_addr a; - a.s_addr = p_htonl(addr->address); + assert(addr->addresses && step.curraddr < addr->naddresses); + a.s_addr = p_htonl(addr->addresses[step.curraddr]); memcpy(buf, (char*) &a.s_addr, 4); } } void sk_addr_free(SockAddr addr) { + if (--addr->refcount > 0) + return; +#ifndef NO_IPV6 + if (addr->ais && p_freeaddrinfo) + p_freeaddrinfo(addr->ais); +#endif + if (addr->addresses) + sfree(addr->addresses); sfree(addr); } +SockAddr sk_addr_dup(SockAddr addr) +{ + addr->refcount++; + return addr; +} + static Plug sk_tcp_plug(Socket sock, Plug p) { Actual_Socket s = (Actual_Socket) sock; @@ -594,6 +827,7 @@ static void sk_tcp_flush(Socket s) static void sk_tcp_close(Socket s); static int sk_tcp_write(Socket s, const char *data, int len); static int sk_tcp_write_oob(Socket s, const char *data, int len); +static void sk_tcp_write_eof(Socket s); 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); @@ -608,6 +842,7 @@ Socket sk_register(void *sock, Plug plug) sk_tcp_close, sk_tcp_write, sk_tcp_write_oob, + sk_tcp_write_eof, sk_tcp_flush, sk_tcp_set_private_ptr, sk_tcp_get_private_ptr, @@ -629,10 +864,13 @@ Socket sk_register(void *sock, Plug plug) bufchain_init(&ret->output_data); ret->writable = 1; /* to start with */ ret->sending_oob = 0; + ret->outgoingeof = EOF_NO; ret->frozen = 1; ret->frozen_readable = 0; 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; @@ -657,72 +895,58 @@ 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; -#ifdef IPV6 +#ifndef NO_IPV6 SOCKADDR_IN6 a6; #endif SOCKADDR_IN a; DWORD err; char *errstr; - Actual_Socket ret; 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); /* - * Create Socket structure. + * Open socket. */ - 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; + family = SOCKADDR_FAMILY(sock->addr, sock->step); /* - * Open socket. + * Remove the socket from the tree before we overwrite its + * internal socket id, because that forms part of the tree's + * sorting criterion. We'll add it back before exiting this + * function, whether we changed anything or not. */ - assert(addr->family != AF_UNSPEC); - s = p_socket(addr->family, SOCK_STREAM, 0); - ret->s = s; + del234(sktree, sock); + + 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)); } @@ -730,20 +954,20 @@ 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; -#ifdef IPV6 - if (addr->family == AF_INET6) { +#ifndef NO_IPV6 + if (family == AF_INET6) { memset(&a6, 0, sizeof(a6)); a6.sin6_family = AF_INET6; -/*a6.sin6_addr = in6addr_any; *//* == 0 */ + /*a6.sin6_addr = in6addr_any; */ /* == 0 done by memset() */ a6.sin6_port = p_htons(localport); } else #endif @@ -752,16 +976,15 @@ Socket sk_new(SockAddr addr, int port, int privport, int oobinline, a.sin_addr.s_addr = p_htonl(INADDR_ANY); a.sin_port = p_htons(localport); } -#ifdef IPV6 - retcode = p_bind(s, (addr->family == AF_INET6 ? - (struct sockaddr *) &a6 : - (struct sockaddr *) &a), - (addr->family == - AF_INET6 ? sizeof(a6) : sizeof(a))); +#ifndef NO_IPV6 + sockcode = p_bind(s, (family == AF_INET6 ? + (struct sockaddr *) &a6 : + (struct sockaddr *) &a), + (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 { @@ -778,41 +1001,52 @@ 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. */ -#ifdef 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; +#ifndef NO_IPV6 + if (sock->step.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->step.ai->ai_addr)->sin6_addr; + a6.sin6_flowinfo = ((struct sockaddr_in6 *) sock->step.ai->ai_addr)->sin6_flowinfo; + a6.sin6_scope_id = ((struct sockaddr_in6 *) sock->step.ai->ai_addr)->sin6_scope_id; + } else { + a.sin_family = AF_INET; + a.sin_addr = + ((struct sockaddr_in *) sock->step.ai->ai_addr)->sin_addr; + a.sin_port = p_htons((short) sock->port); + } } else #endif { + assert(sock->addr->addresses && sock->step.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->step.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 (( -#ifdef IPV6 - p_connect(s, ((addr->family == AF_INET6) ? - (struct sockaddr *) &a6 : (struct sockaddr *) &a), - (addr->family == AF_INET6) ? sizeof(a6) : sizeof(a)) +#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 @@ -825,32 +1059,93 @@ 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); + err = 0; + + ret: + + /* + * No matter what happened, put the socket back in the tree. + */ + add234(sktree, sock); + + 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_write_eof, + sk_tcp_flush, + sk_tcp_set_private_ptr, + sk_tcp_get_private_ptr, + sk_tcp_set_frozen, + sk_tcp_socket_error + }; - /* We're done with 'addr' now. */ - sk_addr_free(addr); + 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->outgoingeof = EOF_NO; + 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; + START_STEP(ret->addr, ret->step); + ret->s = INVALID_SOCKET; + + err = 0; + do { + err = try_connect(ret); + } while (err && sk_nextaddr(ret->addr, &ret->step)); return (Socket) ret; } -Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) +Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, + int orig_address_family) { static const struct socket_function_table fn_table = { sk_tcp_plug, sk_tcp_close, sk_tcp_write, sk_tcp_write_oob, + sk_tcp_write_eof, sk_tcp_flush, sk_tcp_set_private_ptr, sk_tcp_get_private_ptr, @@ -859,16 +1154,19 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) }; SOCKET s; -#ifdef IPV6 +#ifndef NO_IPV6 SOCKADDR_IN6 a6; #endif SOCKADDR_IN a; + DWORD err; char *errstr; Actual_Socket ret; int retcode; int on = 1; + int address_family; + /* * Create Socket structure. */ @@ -879,15 +1177,37 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) bufchain_init(&ret->output_data); ret->writable = 0; /* to start with */ ret->sending_oob = 0; + ret->outgoingeof = EOF_NO; ret->frozen = 0; ret->frozen_readable = 0; 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 + * into local reality. + */ + address_family = (orig_address_family == ADDRTYPE_IPV4 ? AF_INET : +#ifndef NO_IPV6 + orig_address_family == ADDRTYPE_IPV6 ? AF_INET6 : +#endif + AF_UNSPEC); + + /* + * Our default, if passed the `don't care' value + * ADDRTYPE_UNSPEC, is to listen on IPv4. If IPv6 is supported, + * we will also set up a second socket listening on IPv6, but + * the v4 one is primary since that ought to work even on + * non-v6-supporting systems. + */ + if (address_family == AF_UNSPEC) address_family = AF_INET; /* * Open socket. */ - s = p_socket(AF_INET, SOCK_STREAM, 0); + s = p_socket(address_family, SOCK_STREAM, 0); ret->s = s; if (s == INVALID_SOCKET) { @@ -900,12 +1220,15 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) p_setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); -#ifdef IPV6 - if (addr->family == AF_INET6) { +#ifndef NO_IPV6 + if (address_family == AF_INET6) { memset(&a6, 0, sizeof(a6)); a6.sin6_family = AF_INET6; /* FIXME: srcaddr is ignored for IPv6, because I (SGT) don't - * know how to do it. :-) */ + * know how to do it. :-) + * (jeroen:) saddr is specified as an address.. eg 2001:db8::1 + * Thus we need either a parser that understands [2001:db8::1]:80 + * style addresses and/or enhance this to understand hostnames too. */ if (local_host_only) a6.sin6_addr = in6addr_loopback; else @@ -942,11 +1265,11 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) a.sin_port = p_htons((short)port); } -#ifdef IPV6 - retcode = p_bind(s, (addr->family == AF_INET6 ? +#ifndef NO_IPV6 + retcode = p_bind(s, (address_family == AF_INET6 ? (struct sockaddr *) &a6 : (struct sockaddr *) &a), - (addr->family == + (address_family == AF_INET6 ? sizeof(a6) : sizeof(a))); #else retcode = p_bind(s, (struct sockaddr *) &a, sizeof(a)); @@ -958,6 +1281,7 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) } if (err) { + p_closesocket(s); ret->error = winsock_error_string(err); return (Socket) ret; } @@ -965,7 +1289,7 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) if (p_listen(s, SOMAXCONN) == SOCKET_ERROR) { p_closesocket(s); - ret->error = winsock_error_string(err); + ret->error = winsock_error_string(p_WSAGetLastError()); return (Socket) ret; } @@ -973,12 +1297,35 @@ Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only) * window, or an EventSelect on an event object. */ errstr = do_select(s, 1); if (errstr) { + p_closesocket(s); ret->error = errstr; return (Socket) ret; } add234(sktree, ret); +#ifndef NO_IPV6 + /* + * If we were given ADDRTYPE_UNSPEC, we must also create an + * IPv6 listening socket and link it to this one. + */ + if (address_family == AF_INET && orig_address_family == ADDRTYPE_UNSPEC) { + Actual_Socket other; + + other = (Actual_Socket) sk_newlistener(srcaddr, port, plug, + local_host_only, ADDRTYPE_IPV6); + + if (other) { + if (!other->error) { + other->parent = ret; + ret->child = other; + } else { + sfree(other); + } + } + } +#endif + return (Socket) ret; } @@ -987,9 +1334,14 @@ static void sk_tcp_close(Socket sock) extern char *do_select(SOCKET skt, int startup); Actual_Socket s = (Actual_Socket) sock; + if (s->child) + sk_tcp_close((Socket)s->child); + del234(sktree, s); do_select(s->s, 0); p_closesocket(s->s); + if (s->addr) + sk_addr_free(s->addr); sfree(s); } @@ -1062,12 +1414,23 @@ void try_send(Actual_Socket s) } } } + + /* + * If we reach here, we've finished sending everything we might + * have needed to send. Send EOF, if we need to. + */ + if (s->outgoingeof == EOF_PENDING) { + p_shutdown(s->s, SD_SEND); + s->outgoingeof = EOF_SENT; + } } static int sk_tcp_write(Socket sock, const char *buf, int len) { Actual_Socket s = (Actual_Socket) sock; + assert(s->outgoingeof == EOF_NO); + /* * Add the data to the buffer list on the socket. */ @@ -1086,6 +1449,8 @@ static int sk_tcp_write_oob(Socket sock, const char *buf, int len) { Actual_Socket s = (Actual_Socket) sock; + assert(s->outgoingeof == EOF_NO); + /* * Replace the buffer list on the socket with the data. */ @@ -1103,6 +1468,24 @@ static int sk_tcp_write_oob(Socket sock, const char *buf, int len) return s->sending_oob; } +static void sk_tcp_write_eof(Socket sock) +{ + Actual_Socket s = (Actual_Socket) sock; + + assert(s->outgoingeof == EOF_NO); + + /* + * Mark the socket as pending outgoing EOF. + */ + s->outgoingeof = EOF_PENDING; + + /* + * Now try sending from the start of the buffer list. + */ + if (s->writable) + try_send(s); +} + int select_result(WPARAM wParam, LPARAM lParam) { int ret, open; @@ -1125,7 +1508,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, &s->step)) { + err = try_connect(s); + } + } + if (err != 0) + return plug_closing(s->plug, winsock_error_string(err), err, 0); + else + return 1; } noise_ultralight(lParam); @@ -1133,6 +1526,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 */ @@ -1229,11 +1631,15 @@ int select_result(WPARAM wParam, LPARAM lParam) return open; case FD_ACCEPT: { +#ifdef NO_IPV6 struct sockaddr_in isa; - int addrlen = sizeof(struct sockaddr_in); +#else + struct sockaddr_storage isa; +#endif + int addrlen = sizeof(isa); SOCKET t; /* socket of connection */ - memset(&isa, 0, sizeof(struct sockaddr_in)); + memset(&isa, 0, sizeof(isa)); err = 0; t = p_accept(s->s,(struct sockaddr *)&isa,&addrlen); if (t == INVALID_SOCKET) @@ -1242,8 +1648,14 @@ int select_result(WPARAM wParam, LPARAM lParam) if (err == WSATRY_AGAIN) break; } - - if (s->localhost_only && !ipv4_is_local_addr(isa.sin_addr)) { +#ifndef NO_IPV6 + if (isa.ss_family == AF_INET && + s->localhost_only && + !ipv4_is_local_addr(((struct sockaddr_in *)&isa)->sin_addr)) +#else + if (s->localhost_only && !ipv4_is_local_addr(isa.sin_addr)) +#endif + { p_closesocket(t); /* dodgy WinSock let nonlocal through */ } else if (plug_accepting(s->plug, (void*)t)) { p_closesocket(t); /* denied or error */ @@ -1329,13 +1741,27 @@ static void sk_tcp_set_frozen(Socket sock, int is_frozen) if (s->frozen == is_frozen) return; s->frozen = is_frozen; - if (!is_frozen && s->frozen_readable) { - char c; - p_recv(s->s, &c, 1, MSG_PEEK); + if (!is_frozen) { + do_select(s->s, 1); + if (s->frozen_readable) { + char c; + p_recv(s->s, &c, 1, MSG_PEEK); + } } s->frozen_readable = 0; } +void socket_reselect_all(void) +{ + Actual_Socket s; + int i; + + for (i = 0; (s = index234(sktree, i)) != NULL; i++) { + if (!s->frozen) + do_select(s->s, 1); + } +} + /* * For Plink: enumerate all sockets currently active. */ @@ -1373,10 +1799,28 @@ int net_service_lookup(char *service) return 0; } -SockAddr platform_get_x11_unix_address(int displaynum, char **canonicalname) +char *get_hostname(void) +{ + int len = 128; + char *hostname = NULL; + do { + len *= 2; + hostname = sresize(hostname, len, char); + if (p_gethostname(hostname, len) < 0) { + sfree(hostname); + hostname = NULL; + break; + } + } while (strlen(hostname) >= (size_t)(len-1)); + return hostname; +} + +SockAddr platform_get_x11_unix_address(const char *display, int displaynum, + char **canonicalname) { SockAddr ret = snew(struct SockAddr_tag); memset(ret, 0, sizeof(struct SockAddr_tag)); ret->error = "unix sockets not supported on this platform"; + ret->refcount = 1; return ret; }