--- /dev/null
+/*\r
+ * Windows networking abstraction.\r
+ *\r
+ * For the IPv6 code in here I am indebted to Jeroen Massar and\r
+ * unfix.org.\r
+ */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <assert.h>\r
+\r
+#define DEFINE_PLUG_METHOD_MACROS\r
+#include "putty.h"\r
+#include "network.h"\r
+#include "tree234.h"\r
+\r
+#include <ws2tcpip.h>\r
+\r
+#ifndef NO_IPV6\r
+const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;\r
+const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;\r
+#endif\r
+\r
+#define ipv4_is_loopback(addr) \\r
+ ((p_ntohl(addr.s_addr) & 0xFF000000L) == 0x7F000000L)\r
+\r
+/*\r
+ * We used to typedef struct Socket_tag *Socket.\r
+ *\r
+ * Since we have made the networking abstraction slightly more\r
+ * abstract, Socket no longer means a tcp socket (it could mean\r
+ * an ssl socket). So now we must use Actual_Socket when we know\r
+ * we are talking about a tcp socket.\r
+ */\r
+typedef struct Socket_tag *Actual_Socket;\r
+\r
+/*\r
+ * Mutable state that goes with a SockAddr: stores information\r
+ * about where in the list of candidate IP(v*) addresses we've\r
+ * currently got to.\r
+ */\r
+typedef struct SockAddrStep_tag SockAddrStep;\r
+struct SockAddrStep_tag {\r
+#ifndef NO_IPV6\r
+ struct addrinfo *ai; /* steps along addr->ais */\r
+#endif\r
+ int curraddr;\r
+};\r
+\r
+struct Socket_tag {\r
+ const struct socket_function_table *fn;\r
+ /* the above variable absolutely *must* be the first in this structure */\r
+ char *error;\r
+ SOCKET s;\r
+ Plug plug;\r
+ void *private_ptr;\r
+ bufchain output_data;\r
+ int connected;\r
+ int writable;\r
+ int frozen; /* this causes readability notifications to be ignored */\r
+ int frozen_readable; /* this means we missed at least one readability\r
+ * notification while we were frozen */\r
+ int localhost_only; /* for listening sockets */\r
+ char oobdata[1];\r
+ int sending_oob;\r
+ int oobinline, nodelay, keepalive, privport;\r
+ SockAddr addr;\r
+ SockAddrStep step;\r
+ int port;\r
+ int pending_error; /* in case send() returns error */\r
+ /*\r
+ * We sometimes need pairs of Socket structures to be linked:\r
+ * if we are listening on the same IPv6 and v4 port, for\r
+ * example. So here we define `parent' and `child' pointers to\r
+ * track this link.\r
+ */\r
+ Actual_Socket parent, child;\r
+};\r
+\r
+struct SockAddr_tag {\r
+ int refcount;\r
+ char *error;\r
+ int resolved;\r
+#ifndef NO_IPV6\r
+ struct addrinfo *ais; /* Addresses IPv6 style. */\r
+#endif\r
+ unsigned long *addresses; /* Addresses IPv4 style. */\r
+ int naddresses;\r
+ char hostname[512]; /* Store an unresolved host name. */\r
+};\r
+\r
+/*\r
+ * Which address family this address belongs to. AF_INET for IPv4;\r
+ * AF_INET6 for IPv6; AF_UNSPEC indicates that name resolution has\r
+ * not been done and a simple host name is held in this SockAddr\r
+ * structure.\r
+ */\r
+#ifndef NO_IPV6\r
+#define SOCKADDR_FAMILY(addr, step) \\r
+ (!(addr)->resolved ? AF_UNSPEC : \\r
+ (step).ai ? (step).ai->ai_family : AF_INET)\r
+#else\r
+#define SOCKADDR_FAMILY(addr, step) \\r
+ (!(addr)->resolved ? AF_UNSPEC : AF_INET)\r
+#endif\r
+\r
+/*\r
+ * Start a SockAddrStep structure to step through multiple\r
+ * addresses.\r
+ */\r
+#ifndef NO_IPV6\r
+#define START_STEP(addr, step) \\r
+ ((step).ai = (addr)->ais, (step).curraddr = 0)\r
+#else\r
+#define START_STEP(addr, step) \\r
+ ((step).curraddr = 0)\r
+#endif\r
+\r
+static tree234 *sktree;\r
+\r
+static int cmpfortree(void *av, void *bv)\r
+{\r
+ Actual_Socket a = (Actual_Socket) av, b = (Actual_Socket) bv;\r
+ unsigned long as = (unsigned long) a->s, bs = (unsigned long) b->s;\r
+ if (as < bs)\r
+ return -1;\r
+ if (as > bs)\r
+ return +1;\r
+ if (a < b)\r
+ return -1;\r
+ if (a > b)\r
+ return +1;\r
+ return 0;\r
+}\r
+\r
+static int cmpforsearch(void *av, void *bv)\r
+{\r
+ Actual_Socket b = (Actual_Socket) bv;\r
+ unsigned long as = (unsigned long) av, bs = (unsigned long) b->s;\r
+ if (as < bs)\r
+ return -1;\r
+ if (as > bs)\r
+ return +1;\r
+ return 0;\r
+}\r
+\r
+DECL_WINDOWS_FUNCTION(static, int, WSAStartup, (WORD, LPWSADATA));\r
+DECL_WINDOWS_FUNCTION(static, int, WSACleanup, (void));\r
+DECL_WINDOWS_FUNCTION(static, int, closesocket, (SOCKET));\r
+DECL_WINDOWS_FUNCTION(static, u_long, ntohl, (u_long));\r
+DECL_WINDOWS_FUNCTION(static, u_long, htonl, (u_long));\r
+DECL_WINDOWS_FUNCTION(static, u_short, htons, (u_short));\r
+DECL_WINDOWS_FUNCTION(static, u_short, ntohs, (u_short));\r
+DECL_WINDOWS_FUNCTION(static, int, gethostname, (char *, int));\r
+DECL_WINDOWS_FUNCTION(static, struct hostent FAR *, gethostbyname,\r
+ (const char FAR *));\r
+DECL_WINDOWS_FUNCTION(static, struct servent FAR *, getservbyname,\r
+ (const char FAR *, const char FAR *));\r
+DECL_WINDOWS_FUNCTION(static, unsigned long, inet_addr, (const char FAR *));\r
+DECL_WINDOWS_FUNCTION(static, char FAR *, inet_ntoa, (struct in_addr));\r
+DECL_WINDOWS_FUNCTION(static, int, connect,\r
+ (SOCKET, const struct sockaddr FAR *, int));\r
+DECL_WINDOWS_FUNCTION(static, int, bind,\r
+ (SOCKET, const struct sockaddr FAR *, int));\r
+DECL_WINDOWS_FUNCTION(static, int, setsockopt,\r
+ (SOCKET, int, int, const char FAR *, int));\r
+DECL_WINDOWS_FUNCTION(static, SOCKET, socket, (int, int, int));\r
+DECL_WINDOWS_FUNCTION(static, int, listen, (SOCKET, int));\r
+DECL_WINDOWS_FUNCTION(static, int, send, (SOCKET, const char FAR *, int, int));\r
+DECL_WINDOWS_FUNCTION(static, int, ioctlsocket,\r
+ (SOCKET, long, u_long FAR *));\r
+DECL_WINDOWS_FUNCTION(static, SOCKET, accept,\r
+ (SOCKET, struct sockaddr FAR *, int FAR *));\r
+DECL_WINDOWS_FUNCTION(static, int, recv, (SOCKET, char FAR *, int, int));\r
+DECL_WINDOWS_FUNCTION(static, int, WSAIoctl,\r
+ (SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD,\r
+ LPDWORD, LPWSAOVERLAPPED,\r
+ LPWSAOVERLAPPED_COMPLETION_ROUTINE));\r
+#ifndef NO_IPV6\r
+DECL_WINDOWS_FUNCTION(static, int, getaddrinfo,\r
+ (const char *nodename, const char *servname,\r
+ const struct addrinfo *hints, struct addrinfo **res));\r
+DECL_WINDOWS_FUNCTION(static, void, freeaddrinfo, (struct addrinfo *res));\r
+DECL_WINDOWS_FUNCTION(static, int, getnameinfo,\r
+ (const struct sockaddr FAR * sa, socklen_t salen,\r
+ char FAR * host, size_t hostlen, char FAR * serv,\r
+ size_t servlen, int flags));\r
+DECL_WINDOWS_FUNCTION(static, char *, gai_strerror, (int ecode));\r
+DECL_WINDOWS_FUNCTION(static, int, WSAAddressToStringA,\r
+ (LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFO,\r
+ LPSTR, LPDWORD));\r
+#endif\r
+\r
+static HMODULE winsock_module = NULL;\r
+static WSADATA wsadata;\r
+#ifndef NO_IPV6\r
+static HMODULE winsock2_module = NULL;\r
+static HMODULE wship6_module = NULL;\r
+#endif\r
+\r
+int sk_startup(int hi, int lo)\r
+{\r
+ WORD winsock_ver;\r
+\r
+ winsock_ver = MAKEWORD(hi, lo);\r
+\r
+ if (p_WSAStartup(winsock_ver, &wsadata)) {\r
+ return FALSE;\r
+ }\r
+\r
+ if (LOBYTE(wsadata.wVersion) != LOBYTE(winsock_ver)) {\r
+ return FALSE;\r
+ }\r
+\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ {\r
+ char buf[80];\r
+ sprintf(buf, "Using WinSock %d.%d", hi, lo);\r
+ logevent(NULL, buf);\r
+ }\r
+#endif\r
+ return TRUE;\r
+}\r
+\r
+void sk_init(void)\r
+{\r
+#ifndef NO_IPV6\r
+ winsock2_module =\r
+#endif\r
+ winsock_module = load_system32_dll("ws2_32.dll");\r
+ if (!winsock_module) {\r
+ winsock_module = load_system32_dll("wsock32.dll");\r
+ }\r
+ if (!winsock_module)\r
+ fatalbox("Unable to load any WinSock library");\r
+\r
+#ifndef NO_IPV6\r
+ /* Check if we have getaddrinfo in Winsock */\r
+ if (GetProcAddress(winsock_module, "getaddrinfo") != NULL) {\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ logevent(NULL, "Native WinSock IPv6 support detected");\r
+#endif\r
+ GET_WINDOWS_FUNCTION(winsock_module, getaddrinfo);\r
+ GET_WINDOWS_FUNCTION(winsock_module, freeaddrinfo);\r
+ GET_WINDOWS_FUNCTION(winsock_module, getnameinfo);\r
+ GET_WINDOWS_FUNCTION(winsock_module, gai_strerror);\r
+ } else {\r
+ /* Fall back to wship6.dll for Windows 2000 */\r
+ wship6_module = load_system32_dll("wship6.dll");\r
+ if (wship6_module) {\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ logevent(NULL, "WSH IPv6 support detected");\r
+#endif\r
+ GET_WINDOWS_FUNCTION(wship6_module, getaddrinfo);\r
+ GET_WINDOWS_FUNCTION(wship6_module, freeaddrinfo);\r
+ GET_WINDOWS_FUNCTION(wship6_module, getnameinfo);\r
+ GET_WINDOWS_FUNCTION(wship6_module, gai_strerror);\r
+ } else {\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ logevent(NULL, "No IPv6 support detected");\r
+#endif\r
+ }\r
+ }\r
+ GET_WINDOWS_FUNCTION(winsock2_module, WSAAddressToStringA);\r
+#else\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ logevent(NULL, "PuTTY was built without IPv6 support");\r
+#endif\r
+#endif\r
+\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSAAsyncSelect);\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSAEventSelect);\r
+ GET_WINDOWS_FUNCTION(winsock_module, select);\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSAGetLastError);\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSAEnumNetworkEvents);\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSAStartup);\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSACleanup);\r
+ GET_WINDOWS_FUNCTION(winsock_module, closesocket);\r
+ GET_WINDOWS_FUNCTION(winsock_module, ntohl);\r
+ GET_WINDOWS_FUNCTION(winsock_module, htonl);\r
+ GET_WINDOWS_FUNCTION(winsock_module, htons);\r
+ GET_WINDOWS_FUNCTION(winsock_module, ntohs);\r
+ GET_WINDOWS_FUNCTION(winsock_module, gethostname);\r
+ GET_WINDOWS_FUNCTION(winsock_module, gethostbyname);\r
+ GET_WINDOWS_FUNCTION(winsock_module, getservbyname);\r
+ GET_WINDOWS_FUNCTION(winsock_module, inet_addr);\r
+ GET_WINDOWS_FUNCTION(winsock_module, inet_ntoa);\r
+ GET_WINDOWS_FUNCTION(winsock_module, connect);\r
+ GET_WINDOWS_FUNCTION(winsock_module, bind);\r
+ GET_WINDOWS_FUNCTION(winsock_module, setsockopt);\r
+ GET_WINDOWS_FUNCTION(winsock_module, socket);\r
+ GET_WINDOWS_FUNCTION(winsock_module, listen);\r
+ GET_WINDOWS_FUNCTION(winsock_module, send);\r
+ GET_WINDOWS_FUNCTION(winsock_module, ioctlsocket);\r
+ GET_WINDOWS_FUNCTION(winsock_module, accept);\r
+ GET_WINDOWS_FUNCTION(winsock_module, recv);\r
+ GET_WINDOWS_FUNCTION(winsock_module, WSAIoctl);\r
+\r
+ /* Try to get the best WinSock version we can get */\r
+ if (!sk_startup(2,2) &&\r
+ !sk_startup(2,0) &&\r
+ !sk_startup(1,1)) {\r
+ fatalbox("Unable to initialise WinSock");\r
+ }\r
+\r
+ sktree = newtree234(cmpfortree);\r
+}\r
+\r
+void sk_cleanup(void)\r
+{\r
+ Actual_Socket s;\r
+ int i;\r
+\r
+ if (sktree) {\r
+ for (i = 0; (s = index234(sktree, i)) != NULL; i++) {\r
+ p_closesocket(s->s);\r
+ }\r
+ freetree234(sktree);\r
+ sktree = NULL;\r
+ }\r
+\r
+ if (p_WSACleanup)\r
+ p_WSACleanup();\r
+ if (winsock_module)\r
+ FreeLibrary(winsock_module);\r
+#ifndef NO_IPV6\r
+ if (wship6_module)\r
+ FreeLibrary(wship6_module);\r
+#endif\r
+}\r
+\r
+char *winsock_error_string(int error)\r
+{\r
+ switch (error) {\r
+ case WSAEACCES:\r
+ return "Network error: Permission denied";\r
+ case WSAEADDRINUSE:\r
+ return "Network error: Address already in use";\r
+ case WSAEADDRNOTAVAIL:\r
+ return "Network error: Cannot assign requested address";\r
+ case WSAEAFNOSUPPORT:\r
+ return\r
+ "Network error: Address family not supported by protocol family";\r
+ case WSAEALREADY:\r
+ return "Network error: Operation already in progress";\r
+ case WSAECONNABORTED:\r
+ return "Network error: Software caused connection abort";\r
+ case WSAECONNREFUSED:\r
+ return "Network error: Connection refused";\r
+ case WSAECONNRESET:\r
+ return "Network error: Connection reset by peer";\r
+ case WSAEDESTADDRREQ:\r
+ return "Network error: Destination address required";\r
+ case WSAEFAULT:\r
+ return "Network error: Bad address";\r
+ case WSAEHOSTDOWN:\r
+ return "Network error: Host is down";\r
+ case WSAEHOSTUNREACH:\r
+ return "Network error: No route to host";\r
+ case WSAEINPROGRESS:\r
+ return "Network error: Operation now in progress";\r
+ case WSAEINTR:\r
+ return "Network error: Interrupted function call";\r
+ case WSAEINVAL:\r
+ return "Network error: Invalid argument";\r
+ case WSAEISCONN:\r
+ return "Network error: Socket is already connected";\r
+ case WSAEMFILE:\r
+ return "Network error: Too many open files";\r
+ case WSAEMSGSIZE:\r
+ return "Network error: Message too long";\r
+ case WSAENETDOWN:\r
+ return "Network error: Network is down";\r
+ case WSAENETRESET:\r
+ return "Network error: Network dropped connection on reset";\r
+ case WSAENETUNREACH:\r
+ return "Network error: Network is unreachable";\r
+ case WSAENOBUFS:\r
+ return "Network error: No buffer space available";\r
+ case WSAENOPROTOOPT:\r
+ return "Network error: Bad protocol option";\r
+ case WSAENOTCONN:\r
+ return "Network error: Socket is not connected";\r
+ case WSAENOTSOCK:\r
+ return "Network error: Socket operation on non-socket";\r
+ case WSAEOPNOTSUPP:\r
+ return "Network error: Operation not supported";\r
+ case WSAEPFNOSUPPORT:\r
+ return "Network error: Protocol family not supported";\r
+ case WSAEPROCLIM:\r
+ return "Network error: Too many processes";\r
+ case WSAEPROTONOSUPPORT:\r
+ return "Network error: Protocol not supported";\r
+ case WSAEPROTOTYPE:\r
+ return "Network error: Protocol wrong type for socket";\r
+ case WSAESHUTDOWN:\r
+ return "Network error: Cannot send after socket shutdown";\r
+ case WSAESOCKTNOSUPPORT:\r
+ return "Network error: Socket type not supported";\r
+ case WSAETIMEDOUT:\r
+ return "Network error: Connection timed out";\r
+ case WSAEWOULDBLOCK:\r
+ return "Network error: Resource temporarily unavailable";\r
+ case WSAEDISCON:\r
+ return "Network error: Graceful shutdown in progress";\r
+ default:\r
+ return "Unknown network error";\r
+ }\r
+}\r
+\r
+SockAddr sk_namelookup(const char *host, char **canonicalname,\r
+ int address_family)\r
+{\r
+ SockAddr ret = snew(struct SockAddr_tag);\r
+ unsigned long a;\r
+ char realhost[8192];\r
+ int hint_family;\r
+\r
+ /* Default to IPv4. */\r
+ hint_family = (address_family == ADDRTYPE_IPV4 ? AF_INET :\r
+#ifndef NO_IPV6\r
+ address_family == ADDRTYPE_IPV6 ? AF_INET6 :\r
+#endif\r
+ AF_UNSPEC);\r
+\r
+ /* Clear the structure and default to IPv4. */\r
+ memset(ret, 0, sizeof(struct SockAddr_tag));\r
+#ifndef NO_IPV6\r
+ ret->ais = NULL;\r
+#endif\r
+ ret->addresses = NULL;\r
+ ret->resolved = FALSE;\r
+ ret->refcount = 1;\r
+ *realhost = '\0';\r
+\r
+ if ((a = p_inet_addr(host)) == (unsigned long) INADDR_NONE) {\r
+ struct hostent *h = NULL;\r
+ int err;\r
+#ifndef NO_IPV6\r
+ /*\r
+ * Use getaddrinfo when it's available\r
+ */\r
+ if (p_getaddrinfo) {\r
+ struct addrinfo hints;\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ logevent(NULL, "Using getaddrinfo() for resolving");\r
+#endif\r
+ memset(&hints, 0, sizeof(hints));\r
+ hints.ai_family = hint_family;\r
+ hints.ai_flags = AI_CANONNAME;\r
+ if ((err = p_getaddrinfo(host, NULL, &hints, &ret->ais)) == 0)\r
+ ret->resolved = TRUE;\r
+ } else\r
+#endif\r
+ {\r
+#ifdef NET_SETUP_DIAGNOSTICS\r
+ logevent(NULL, "Using gethostbyname() for resolving");\r
+#endif\r
+ /*\r
+ * Otherwise use the IPv4-only gethostbyname...\r
+ * (NOTE: we don't use gethostbyname as a fallback!)\r
+ */\r
+ if ( (h = p_gethostbyname(host)) )\r
+ ret->resolved = TRUE;\r
+ else\r
+ err = p_WSAGetLastError();\r
+ }\r
+\r
+ if (!ret->resolved) {\r
+ ret->error = (err == WSAENETDOWN ? "Network is down" :\r
+ err == WSAHOST_NOT_FOUND ? "Host does not exist" :\r
+ err == WSATRY_AGAIN ? "Host not found" :\r
+#ifndef NO_IPV6\r
+ p_getaddrinfo&&p_gai_strerror ? p_gai_strerror(err) :\r
+#endif\r
+ "gethostbyname: unknown error");\r
+ } else {\r
+ ret->error = NULL;\r
+\r
+#ifndef NO_IPV6\r
+ /* If we got an address info use that... */\r
+ if (ret->ais) {\r
+ /* Are we in IPv4 fallback mode? */\r
+ /* We put the IPv4 address into the a variable so we can further-on use the IPv4 code... */\r
+ if (ret->ais->ai_family == AF_INET)\r
+ memcpy(&a,\r
+ (char *) &((SOCKADDR_IN *) ret->ais->\r
+ ai_addr)->sin_addr, sizeof(a));\r
+\r
+ if (ret->ais->ai_canonname)\r
+ strncpy(realhost, ret->ais->ai_canonname, lenof(realhost));\r
+ else\r
+ strncpy(realhost, host, lenof(realhost));\r
+ }\r
+ /* We used the IPv4-only gethostbyname()... */\r
+ else\r
+#endif\r
+ {\r
+ int n;\r
+ for (n = 0; h->h_addr_list[n]; n++);\r
+ ret->addresses = snewn(n, unsigned long);\r
+ ret->naddresses = n;\r
+ for (n = 0; n < ret->naddresses; n++) {\r
+ memcpy(&a, h->h_addr_list[n], sizeof(a));\r
+ ret->addresses[n] = p_ntohl(a);\r
+ }\r
+ memcpy(&a, h->h_addr, sizeof(a));\r
+ /* This way we are always sure the h->h_name is valid :) */\r
+ strncpy(realhost, h->h_name, sizeof(realhost));\r
+ }\r
+ }\r
+ } else {\r
+ /*\r
+ * This must be a numeric IPv4 address because it caused a\r
+ * success return from inet_addr.\r
+ */\r
+ ret->addresses = snewn(1, unsigned long);\r
+ ret->naddresses = 1;\r
+ ret->addresses[0] = p_ntohl(a);\r
+ ret->resolved = TRUE;\r
+ strncpy(realhost, host, sizeof(realhost));\r
+ }\r
+ realhost[lenof(realhost)-1] = '\0';\r
+ *canonicalname = snewn(1+strlen(realhost), char);\r
+ strcpy(*canonicalname, realhost);\r
+ return ret;\r
+}\r
+\r
+SockAddr sk_nonamelookup(const char *host)\r
+{\r
+ SockAddr ret = snew(struct SockAddr_tag);\r
+ ret->error = NULL;\r
+ ret->resolved = FALSE;\r
+#ifndef NO_IPV6\r
+ ret->ais = NULL;\r
+#endif\r
+ ret->addresses = NULL;\r
+ ret->naddresses = 0;\r
+ ret->refcount = 1;\r
+ strncpy(ret->hostname, host, lenof(ret->hostname));\r
+ ret->hostname[lenof(ret->hostname)-1] = '\0';\r
+ return ret;\r
+}\r
+\r
+int sk_nextaddr(SockAddr addr, SockAddrStep *step)\r
+{\r
+#ifndef NO_IPV6\r
+ if (step->ai) {\r
+ if (step->ai->ai_next) {\r
+ step->ai = step->ai->ai_next;\r
+ return TRUE;\r
+ } else\r
+ return FALSE;\r
+ }\r
+#endif\r
+ if (step->curraddr+1 < addr->naddresses) {\r
+ step->curraddr++;\r
+ return TRUE;\r
+ } else {\r
+ return FALSE;\r
+ }\r
+}\r
+\r
+void sk_getaddr(SockAddr addr, char *buf, int buflen)\r
+{\r
+ SockAddrStep step;\r
+ START_STEP(addr, step);\r
+\r
+#ifndef NO_IPV6\r
+ if (step.ai) {\r
+ int err = 0;\r
+ if (p_WSAAddressToStringA) {\r
+ DWORD dwbuflen = buflen;\r
+ err = p_WSAAddressToStringA(step.ai->ai_addr, step.ai->ai_addrlen,\r
+ NULL, buf, &dwbuflen);\r
+ } else\r
+ err = -1;\r
+ if (err) {\r
+ strncpy(buf, addr->hostname, buflen);\r
+ if (!buf[0])\r
+ strncpy(buf, "<unknown>", buflen);\r
+ buf[buflen-1] = '\0';\r
+ }\r
+ } else\r
+#endif\r
+ if (SOCKADDR_FAMILY(addr, step) == AF_INET) {\r
+ struct in_addr a;\r
+ assert(addr->addresses && step.curraddr < addr->naddresses);\r
+ a.s_addr = p_htonl(addr->addresses[step.curraddr]);\r
+ strncpy(buf, p_inet_ntoa(a), buflen);\r
+ buf[buflen-1] = '\0';\r
+ } else {\r
+ strncpy(buf, addr->hostname, buflen);\r
+ buf[buflen-1] = '\0';\r
+ }\r
+}\r
+\r
+int sk_hostname_is_local(char *name)\r
+{\r
+ return !strcmp(name, "localhost") ||\r
+ !strcmp(name, "::1") ||\r
+ !strncmp(name, "127.", 4);\r
+}\r
+\r
+static INTERFACE_INFO local_interfaces[16];\r
+static int n_local_interfaces; /* 0=not yet, -1=failed, >0=number */\r
+\r
+static int ipv4_is_local_addr(struct in_addr addr)\r
+{\r
+ if (ipv4_is_loopback(addr))\r
+ return 1; /* loopback addresses are local */\r
+ if (!n_local_interfaces) {\r
+ SOCKET s = p_socket(AF_INET, SOCK_DGRAM, 0);\r
+ DWORD retbytes;\r
+\r
+ if (p_WSAIoctl &&\r
+ p_WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0,\r
+ local_interfaces, sizeof(local_interfaces),\r
+ &retbytes, NULL, NULL) == 0)\r
+ n_local_interfaces = retbytes / sizeof(INTERFACE_INFO);\r
+ else\r
+ logevent(NULL, "Unable to get list of local IP addresses");\r
+ }\r
+ if (n_local_interfaces > 0) {\r
+ int i;\r
+ for (i = 0; i < n_local_interfaces; i++) {\r
+ SOCKADDR_IN *address =\r
+ (SOCKADDR_IN *)&local_interfaces[i].iiAddress;\r
+ if (address->sin_addr.s_addr == addr.s_addr)\r
+ return 1; /* this address is local */\r
+ }\r
+ }\r
+ return 0; /* this address is not local */\r
+}\r
+\r
+int sk_address_is_local(SockAddr addr)\r
+{\r
+ SockAddrStep step;\r
+ int family;\r
+ START_STEP(addr, step);\r
+ family = SOCKADDR_FAMILY(addr, step);\r
+\r
+#ifndef NO_IPV6\r
+ if (family == AF_INET6) {\r
+ return IN6_IS_ADDR_LOOPBACK((const struct in6_addr *)step.ai->ai_addr);\r
+ } else\r
+#endif\r
+ if (family == AF_INET) {\r
+#ifndef NO_IPV6\r
+ if (step.ai) {\r
+ return ipv4_is_local_addr(((struct sockaddr_in *)step.ai->ai_addr)\r
+ ->sin_addr);\r
+ } else\r
+#endif\r
+ {\r
+ struct in_addr a;\r
+ assert(addr->addresses && step.curraddr < addr->naddresses);\r
+ a.s_addr = p_htonl(addr->addresses[step.curraddr]);\r
+ return ipv4_is_local_addr(a);\r
+ }\r
+ } else {\r
+ assert(family == AF_UNSPEC);\r
+ return 0; /* we don't know; assume not */\r
+ }\r
+}\r
+\r
+int sk_addrtype(SockAddr addr)\r
+{\r
+ SockAddrStep step;\r
+ int family;\r
+ START_STEP(addr, step);\r
+ family = SOCKADDR_FAMILY(addr, step);\r
+\r
+ return (family == AF_INET ? ADDRTYPE_IPV4 :\r
+#ifndef NO_IPV6\r
+ family == AF_INET6 ? ADDRTYPE_IPV6 :\r
+#endif\r
+ ADDRTYPE_NAME);\r
+}\r
+\r
+void sk_addrcopy(SockAddr addr, char *buf)\r
+{\r
+ SockAddrStep step;\r
+ int family;\r
+ START_STEP(addr, step);\r
+ family = SOCKADDR_FAMILY(addr, step);\r
+\r
+ assert(family != AF_UNSPEC);\r
+#ifndef NO_IPV6\r
+ if (step.ai) {\r
+ if (family == AF_INET)\r
+ memcpy(buf, &((struct sockaddr_in *)step.ai->ai_addr)->sin_addr,\r
+ sizeof(struct in_addr));\r
+ else if (family == AF_INET6)\r
+ memcpy(buf, &((struct sockaddr_in6 *)step.ai->ai_addr)->sin6_addr,\r
+ sizeof(struct in6_addr));\r
+ else\r
+ assert(FALSE);\r
+ } else\r
+#endif\r
+ if (family == AF_INET) {\r
+ struct in_addr a;\r
+ assert(addr->addresses && step.curraddr < addr->naddresses);\r
+ a.s_addr = p_htonl(addr->addresses[step.curraddr]);\r
+ memcpy(buf, (char*) &a.s_addr, 4);\r
+ }\r
+}\r
+\r
+void sk_addr_free(SockAddr addr)\r
+{\r
+ if (--addr->refcount > 0)\r
+ return;\r
+#ifndef NO_IPV6\r
+ if (addr->ais && p_freeaddrinfo)\r
+ p_freeaddrinfo(addr->ais);\r
+#endif\r
+ if (addr->addresses)\r
+ sfree(addr->addresses);\r
+ sfree(addr);\r
+}\r
+\r
+SockAddr sk_addr_dup(SockAddr addr)\r
+{\r
+ addr->refcount++;\r
+ return addr;\r
+}\r
+\r
+static Plug sk_tcp_plug(Socket sock, Plug p)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+ Plug ret = s->plug;\r
+ if (p)\r
+ s->plug = p;\r
+ return ret;\r
+}\r
+\r
+static void sk_tcp_flush(Socket s)\r
+{\r
+ /*\r
+ * We send data to the socket as soon as we can anyway,\r
+ * so we don't need to do anything here. :-)\r
+ */\r
+}\r
+\r
+static void sk_tcp_close(Socket s);\r
+static int sk_tcp_write(Socket s, const char *data, int len);\r
+static int sk_tcp_write_oob(Socket s, const char *data, int len);\r
+static void sk_tcp_set_private_ptr(Socket s, void *ptr);\r
+static void *sk_tcp_get_private_ptr(Socket s);\r
+static void sk_tcp_set_frozen(Socket s, int is_frozen);\r
+static const char *sk_tcp_socket_error(Socket s);\r
+\r
+extern char *do_select(SOCKET skt, int startup);\r
+\r
+Socket sk_register(void *sock, Plug plug)\r
+{\r
+ static const struct socket_function_table fn_table = {\r
+ sk_tcp_plug,\r
+ sk_tcp_close,\r
+ sk_tcp_write,\r
+ sk_tcp_write_oob,\r
+ sk_tcp_flush,\r
+ sk_tcp_set_private_ptr,\r
+ sk_tcp_get_private_ptr,\r
+ sk_tcp_set_frozen,\r
+ sk_tcp_socket_error\r
+ };\r
+\r
+ DWORD err;\r
+ char *errstr;\r
+ Actual_Socket ret;\r
+\r
+ /*\r
+ * Create Socket structure.\r
+ */\r
+ ret = snew(struct Socket_tag);\r
+ ret->fn = &fn_table;\r
+ ret->error = NULL;\r
+ ret->plug = plug;\r
+ bufchain_init(&ret->output_data);\r
+ ret->writable = 1; /* to start with */\r
+ ret->sending_oob = 0;\r
+ ret->frozen = 1;\r
+ ret->frozen_readable = 0;\r
+ ret->localhost_only = 0; /* unused, but best init anyway */\r
+ ret->pending_error = 0;\r
+ ret->parent = ret->child = NULL;\r
+ ret->addr = NULL;\r
+\r
+ ret->s = (SOCKET)sock;\r
+\r
+ if (ret->s == INVALID_SOCKET) {\r
+ err = p_WSAGetLastError();\r
+ ret->error = winsock_error_string(err);\r
+ return (Socket) ret;\r
+ }\r
+\r
+ ret->oobinline = 0;\r
+\r
+ /* Set up a select mechanism. This could be an AsyncSelect on a\r
+ * window, or an EventSelect on an event object. */\r
+ errstr = do_select(ret->s, 1);\r
+ if (errstr) {\r
+ ret->error = errstr;\r
+ return (Socket) ret;\r
+ }\r
+\r
+ add234(sktree, ret);\r
+\r
+ return (Socket) ret;\r
+}\r
+\r
+static DWORD try_connect(Actual_Socket sock)\r
+{\r
+ SOCKET s;\r
+#ifndef NO_IPV6\r
+ SOCKADDR_IN6 a6;\r
+#endif\r
+ SOCKADDR_IN a;\r
+ DWORD err;\r
+ char *errstr;\r
+ short localport;\r
+ int family;\r
+\r
+ if (sock->s != INVALID_SOCKET) {\r
+ do_select(sock->s, 0);\r
+ p_closesocket(sock->s);\r
+ }\r
+\r
+ plug_log(sock->plug, 0, sock->addr, sock->port, NULL, 0);\r
+\r
+ /*\r
+ * Open socket.\r
+ */\r
+ family = SOCKADDR_FAMILY(sock->addr, sock->step);\r
+\r
+ /*\r
+ * Remove the socket from the tree before we overwrite its\r
+ * internal socket id, because that forms part of the tree's\r
+ * sorting criterion. We'll add it back before exiting this\r
+ * function, whether we changed anything or not.\r
+ */\r
+ del234(sktree, sock);\r
+\r
+ s = p_socket(family, SOCK_STREAM, 0);\r
+ sock->s = s;\r
+\r
+ if (s == INVALID_SOCKET) {\r
+ err = p_WSAGetLastError();\r
+ sock->error = winsock_error_string(err);\r
+ goto ret;\r
+ }\r
+\r
+ if (sock->oobinline) {\r
+ BOOL b = TRUE;\r
+ p_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b));\r
+ }\r
+\r
+ if (sock->nodelay) {\r
+ BOOL b = TRUE;\r
+ p_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b));\r
+ }\r
+\r
+ if (sock->keepalive) {\r
+ BOOL b = TRUE;\r
+ p_setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (void *) &b, sizeof(b));\r
+ }\r
+\r
+ /*\r
+ * Bind to local address.\r
+ */\r
+ if (sock->privport)\r
+ localport = 1023; /* count from 1023 downwards */\r
+ else\r
+ localport = 0; /* just use port 0 (ie winsock picks) */\r
+\r
+ /* Loop round trying to bind */\r
+ while (1) {\r
+ int sockcode;\r
+\r
+#ifndef NO_IPV6\r
+ if (family == AF_INET6) {\r
+ memset(&a6, 0, sizeof(a6));\r
+ a6.sin6_family = AF_INET6;\r
+ /*a6.sin6_addr = in6addr_any; */ /* == 0 done by memset() */\r
+ a6.sin6_port = p_htons(localport);\r
+ } else\r
+#endif\r
+ {\r
+ a.sin_family = AF_INET;\r
+ a.sin_addr.s_addr = p_htonl(INADDR_ANY);\r
+ a.sin_port = p_htons(localport);\r
+ }\r
+#ifndef NO_IPV6\r
+ sockcode = p_bind(s, (family == AF_INET6 ?\r
+ (struct sockaddr *) &a6 :\r
+ (struct sockaddr *) &a),\r
+ (family == AF_INET6 ? sizeof(a6) : sizeof(a)));\r
+#else\r
+ sockcode = p_bind(s, (struct sockaddr *) &a, sizeof(a));\r
+#endif\r
+ if (sockcode != SOCKET_ERROR) {\r
+ err = 0;\r
+ break; /* done */\r
+ } else {\r
+ err = p_WSAGetLastError();\r
+ if (err != WSAEADDRINUSE) /* failed, for a bad reason */\r
+ break;\r
+ }\r
+\r
+ if (localport == 0)\r
+ break; /* we're only looping once */\r
+ localport--;\r
+ if (localport == 0)\r
+ break; /* we might have got to the end */\r
+ }\r
+\r
+ if (err) {\r
+ sock->error = winsock_error_string(err);\r
+ goto ret;\r
+ }\r
+\r
+ /*\r
+ * Connect to remote address.\r
+ */\r
+#ifndef NO_IPV6\r
+ if (sock->step.ai) {\r
+ if (family == AF_INET6) {\r
+ a6.sin6_family = AF_INET6;\r
+ a6.sin6_port = p_htons((short) sock->port);\r
+ a6.sin6_addr =\r
+ ((struct sockaddr_in6 *) sock->step.ai->ai_addr)->sin6_addr;\r
+ a6.sin6_flowinfo = ((struct sockaddr_in6 *) sock->step.ai->ai_addr)->sin6_flowinfo;\r
+ a6.sin6_scope_id = ((struct sockaddr_in6 *) sock->step.ai->ai_addr)->sin6_scope_id;\r
+ } else {\r
+ a.sin_family = AF_INET;\r
+ a.sin_addr =\r
+ ((struct sockaddr_in *) sock->step.ai->ai_addr)->sin_addr;\r
+ a.sin_port = p_htons((short) sock->port);\r
+ }\r
+ } else\r
+#endif\r
+ {\r
+ assert(sock->addr->addresses && sock->step.curraddr < sock->addr->naddresses);\r
+ a.sin_family = AF_INET;\r
+ a.sin_addr.s_addr = p_htonl(sock->addr->addresses[sock->step.curraddr]);\r
+ a.sin_port = p_htons((short) sock->port);\r
+ }\r
+\r
+ /* Set up a select mechanism. This could be an AsyncSelect on a\r
+ * window, or an EventSelect on an event object. */\r
+ errstr = do_select(s, 1);\r
+ if (errstr) {\r
+ sock->error = errstr;\r
+ err = 1;\r
+ goto ret;\r
+ }\r
+\r
+ if ((\r
+#ifndef NO_IPV6\r
+ p_connect(s,\r
+ ((family == AF_INET6) ? (struct sockaddr *) &a6 :\r
+ (struct sockaddr *) &a),\r
+ (family == AF_INET6) ? sizeof(a6) : sizeof(a))\r
+#else\r
+ p_connect(s, (struct sockaddr *) &a, sizeof(a))\r
+#endif\r
+ ) == SOCKET_ERROR) {\r
+ err = p_WSAGetLastError();\r
+ /*\r
+ * We expect a potential EWOULDBLOCK here, because the\r
+ * chances are the front end has done a select for\r
+ * FD_CONNECT, so that connect() will complete\r
+ * asynchronously.\r
+ */\r
+ if ( err != WSAEWOULDBLOCK ) {\r
+ sock->error = winsock_error_string(err);\r
+ goto ret;\r
+ }\r
+ } else {\r
+ /*\r
+ * If we _don't_ get EWOULDBLOCK, the connect has completed\r
+ * and we should set the socket as writable.\r
+ */\r
+ sock->writable = 1;\r
+ }\r
+\r
+ err = 0;\r
+\r
+ ret:\r
+\r
+ /*\r
+ * No matter what happened, put the socket back in the tree.\r
+ */\r
+ add234(sktree, sock);\r
+\r
+ if (err)\r
+ plug_log(sock->plug, 1, sock->addr, sock->port, sock->error, err);\r
+ return err;\r
+}\r
+\r
+Socket sk_new(SockAddr addr, int port, int privport, int oobinline,\r
+ int nodelay, int keepalive, Plug plug)\r
+{\r
+ static const struct socket_function_table fn_table = {\r
+ sk_tcp_plug,\r
+ sk_tcp_close,\r
+ sk_tcp_write,\r
+ sk_tcp_write_oob,\r
+ sk_tcp_flush,\r
+ sk_tcp_set_private_ptr,\r
+ sk_tcp_get_private_ptr,\r
+ sk_tcp_set_frozen,\r
+ sk_tcp_socket_error\r
+ };\r
+\r
+ Actual_Socket ret;\r
+ DWORD err;\r
+\r
+ /*\r
+ * Create Socket structure.\r
+ */\r
+ ret = snew(struct Socket_tag);\r
+ ret->fn = &fn_table;\r
+ ret->error = NULL;\r
+ ret->plug = plug;\r
+ bufchain_init(&ret->output_data);\r
+ ret->connected = 0; /* to start with */\r
+ ret->writable = 0; /* to start with */\r
+ ret->sending_oob = 0;\r
+ ret->frozen = 0;\r
+ ret->frozen_readable = 0;\r
+ ret->localhost_only = 0; /* unused, but best init anyway */\r
+ ret->pending_error = 0;\r
+ ret->parent = ret->child = NULL;\r
+ ret->oobinline = oobinline;\r
+ ret->nodelay = nodelay;\r
+ ret->keepalive = keepalive;\r
+ ret->privport = privport;\r
+ ret->port = port;\r
+ ret->addr = addr;\r
+ START_STEP(ret->addr, ret->step);\r
+ ret->s = INVALID_SOCKET;\r
+\r
+ err = 0;\r
+ do {\r
+ err = try_connect(ret);\r
+ } while (err && sk_nextaddr(ret->addr, &ret->step));\r
+\r
+ return (Socket) ret;\r
+}\r
+\r
+Socket sk_newlistener(char *srcaddr, int port, Plug plug, int local_host_only,\r
+ int orig_address_family)\r
+{\r
+ static const struct socket_function_table fn_table = {\r
+ sk_tcp_plug,\r
+ sk_tcp_close,\r
+ sk_tcp_write,\r
+ sk_tcp_write_oob,\r
+ sk_tcp_flush,\r
+ sk_tcp_set_private_ptr,\r
+ sk_tcp_get_private_ptr,\r
+ sk_tcp_set_frozen,\r
+ sk_tcp_socket_error\r
+ };\r
+\r
+ SOCKET s;\r
+#ifndef NO_IPV6\r
+ SOCKADDR_IN6 a6;\r
+#endif\r
+ SOCKADDR_IN a;\r
+\r
+ DWORD err;\r
+ char *errstr;\r
+ Actual_Socket ret;\r
+ int retcode;\r
+ int on = 1;\r
+\r
+ int address_family;\r
+\r
+ /*\r
+ * Create Socket structure.\r
+ */\r
+ ret = snew(struct Socket_tag);\r
+ ret->fn = &fn_table;\r
+ ret->error = NULL;\r
+ ret->plug = plug;\r
+ bufchain_init(&ret->output_data);\r
+ ret->writable = 0; /* to start with */\r
+ ret->sending_oob = 0;\r
+ ret->frozen = 0;\r
+ ret->frozen_readable = 0;\r
+ ret->localhost_only = local_host_only;\r
+ ret->pending_error = 0;\r
+ ret->parent = ret->child = NULL;\r
+ ret->addr = NULL;\r
+\r
+ /*\r
+ * Translate address_family from platform-independent constants\r
+ * into local reality.\r
+ */\r
+ address_family = (orig_address_family == ADDRTYPE_IPV4 ? AF_INET :\r
+#ifndef NO_IPV6\r
+ orig_address_family == ADDRTYPE_IPV6 ? AF_INET6 :\r
+#endif\r
+ AF_UNSPEC);\r
+\r
+ /*\r
+ * Our default, if passed the `don't care' value\r
+ * ADDRTYPE_UNSPEC, is to listen on IPv4. If IPv6 is supported,\r
+ * we will also set up a second socket listening on IPv6, but\r
+ * the v4 one is primary since that ought to work even on\r
+ * non-v6-supporting systems.\r
+ */\r
+ if (address_family == AF_UNSPEC) address_family = AF_INET;\r
+\r
+ /*\r
+ * Open socket.\r
+ */\r
+ s = p_socket(address_family, SOCK_STREAM, 0);\r
+ ret->s = s;\r
+\r
+ if (s == INVALID_SOCKET) {\r
+ err = p_WSAGetLastError();\r
+ ret->error = winsock_error_string(err);\r
+ return (Socket) ret;\r
+ }\r
+\r
+ ret->oobinline = 0;\r
+\r
+ p_setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on));\r
+\r
+#ifndef NO_IPV6\r
+ if (address_family == AF_INET6) {\r
+ memset(&a6, 0, sizeof(a6));\r
+ a6.sin6_family = AF_INET6;\r
+ /* FIXME: srcaddr is ignored for IPv6, because I (SGT) don't\r
+ * know how to do it. :-)\r
+ * (jeroen:) saddr is specified as an address.. eg 2001:db8::1\r
+ * Thus we need either a parser that understands [2001:db8::1]:80\r
+ * style addresses and/or enhance this to understand hostnames too. */\r
+ if (local_host_only)\r
+ a6.sin6_addr = in6addr_loopback;\r
+ else\r
+ a6.sin6_addr = in6addr_any;\r
+ a6.sin6_port = p_htons(port);\r
+ } else\r
+#endif\r
+ {\r
+ int got_addr = 0;\r
+ a.sin_family = AF_INET;\r
+\r
+ /*\r
+ * Bind to source address. First try an explicitly\r
+ * specified one...\r
+ */\r
+ if (srcaddr) {\r
+ a.sin_addr.s_addr = p_inet_addr(srcaddr);\r
+ if (a.sin_addr.s_addr != INADDR_NONE) {\r
+ /* Override localhost_only with specified listen addr. */\r
+ ret->localhost_only = ipv4_is_loopback(a.sin_addr);\r
+ got_addr = 1;\r
+ }\r
+ }\r
+\r
+ /*\r
+ * ... and failing that, go with one of the standard ones.\r
+ */\r
+ if (!got_addr) {\r
+ if (local_host_only)\r
+ a.sin_addr.s_addr = p_htonl(INADDR_LOOPBACK);\r
+ else\r
+ a.sin_addr.s_addr = p_htonl(INADDR_ANY);\r
+ }\r
+\r
+ a.sin_port = p_htons((short)port);\r
+ }\r
+#ifndef NO_IPV6\r
+ retcode = p_bind(s, (address_family == AF_INET6 ?\r
+ (struct sockaddr *) &a6 :\r
+ (struct sockaddr *) &a),\r
+ (address_family ==\r
+ AF_INET6 ? sizeof(a6) : sizeof(a)));\r
+#else\r
+ retcode = p_bind(s, (struct sockaddr *) &a, sizeof(a));\r
+#endif\r
+ if (retcode != SOCKET_ERROR) {\r
+ err = 0;\r
+ } else {\r
+ err = p_WSAGetLastError();\r
+ }\r
+\r
+ if (err) {\r
+ p_closesocket(s);\r
+ ret->error = winsock_error_string(err);\r
+ return (Socket) ret;\r
+ }\r
+\r
+\r
+ if (p_listen(s, SOMAXCONN) == SOCKET_ERROR) {\r
+ p_closesocket(s);\r
+ ret->error = winsock_error_string(err);\r
+ return (Socket) ret;\r
+ }\r
+\r
+ /* Set up a select mechanism. This could be an AsyncSelect on a\r
+ * window, or an EventSelect on an event object. */\r
+ errstr = do_select(s, 1);\r
+ if (errstr) {\r
+ p_closesocket(s);\r
+ ret->error = errstr;\r
+ return (Socket) ret;\r
+ }\r
+\r
+ add234(sktree, ret);\r
+\r
+#ifndef NO_IPV6\r
+ /*\r
+ * If we were given ADDRTYPE_UNSPEC, we must also create an\r
+ * IPv6 listening socket and link it to this one.\r
+ */\r
+ if (address_family == AF_INET && orig_address_family == ADDRTYPE_UNSPEC) {\r
+ Actual_Socket other;\r
+\r
+ other = (Actual_Socket) sk_newlistener(srcaddr, port, plug,\r
+ local_host_only, ADDRTYPE_IPV6);\r
+\r
+ if (other) {\r
+ if (!other->error) {\r
+ other->parent = ret;\r
+ ret->child = other;\r
+ } else {\r
+ sfree(other);\r
+ }\r
+ }\r
+ }\r
+#endif\r
+\r
+ return (Socket) ret;\r
+}\r
+\r
+static void sk_tcp_close(Socket sock)\r
+{\r
+ extern char *do_select(SOCKET skt, int startup);\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+\r
+ if (s->child)\r
+ sk_tcp_close((Socket)s->child);\r
+\r
+ del234(sktree, s);\r
+ do_select(s->s, 0);\r
+ p_closesocket(s->s);\r
+ if (s->addr)\r
+ sk_addr_free(s->addr);\r
+ sfree(s);\r
+}\r
+\r
+/*\r
+ * The function which tries to send on a socket once it's deemed\r
+ * writable.\r
+ */\r
+void try_send(Actual_Socket s)\r
+{\r
+ while (s->sending_oob || bufchain_size(&s->output_data) > 0) {\r
+ int nsent;\r
+ DWORD err;\r
+ void *data;\r
+ int len, urgentflag;\r
+\r
+ if (s->sending_oob) {\r
+ urgentflag = MSG_OOB;\r
+ len = s->sending_oob;\r
+ data = &s->oobdata;\r
+ } else {\r
+ urgentflag = 0;\r
+ bufchain_prefix(&s->output_data, &data, &len);\r
+ }\r
+ nsent = p_send(s->s, data, len, urgentflag);\r
+ noise_ultralight(nsent);\r
+ if (nsent <= 0) {\r
+ err = (nsent < 0 ? p_WSAGetLastError() : 0);\r
+ if ((err < WSABASEERR && nsent < 0) || err == WSAEWOULDBLOCK) {\r
+ /*\r
+ * Perfectly normal: we've sent all we can for the moment.\r
+ * \r
+ * (Some WinSock send() implementations can return\r
+ * <0 but leave no sensible error indication -\r
+ * WSAGetLastError() is called but returns zero or\r
+ * a small number - so we check that case and treat\r
+ * it just like WSAEWOULDBLOCK.)\r
+ */\r
+ s->writable = FALSE;\r
+ return;\r
+ } else if (nsent == 0 ||\r
+ err == WSAECONNABORTED || err == WSAECONNRESET) {\r
+ /*\r
+ * If send() returns CONNABORTED or CONNRESET, we\r
+ * unfortunately can't just call plug_closing(),\r
+ * because it's quite likely that we're currently\r
+ * _in_ a call from the code we'd be calling back\r
+ * to, so we'd have to make half the SSH code\r
+ * reentrant. Instead we flag a pending error on\r
+ * the socket, to be dealt with (by calling\r
+ * plug_closing()) at some suitable future moment.\r
+ */\r
+ s->pending_error = err;\r
+ return;\r
+ } else {\r
+ /* We're inside the Windows frontend here, so we know\r
+ * that the frontend handle is unnecessary. */\r
+ logevent(NULL, winsock_error_string(err));\r
+ fatalbox("%s", winsock_error_string(err));\r
+ }\r
+ } else {\r
+ if (s->sending_oob) {\r
+ if (nsent < len) {\r
+ memmove(s->oobdata, s->oobdata+nsent, len-nsent);\r
+ s->sending_oob = len - nsent;\r
+ } else {\r
+ s->sending_oob = 0;\r
+ }\r
+ } else {\r
+ bufchain_consume(&s->output_data, nsent);\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+static int sk_tcp_write(Socket sock, const char *buf, int len)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+\r
+ /*\r
+ * Add the data to the buffer list on the socket.\r
+ */\r
+ bufchain_add(&s->output_data, buf, len);\r
+\r
+ /*\r
+ * Now try sending from the start of the buffer list.\r
+ */\r
+ if (s->writable)\r
+ try_send(s);\r
+\r
+ return bufchain_size(&s->output_data);\r
+}\r
+\r
+static int sk_tcp_write_oob(Socket sock, const char *buf, int len)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+\r
+ /*\r
+ * Replace the buffer list on the socket with the data.\r
+ */\r
+ bufchain_clear(&s->output_data);\r
+ assert(len <= sizeof(s->oobdata));\r
+ memcpy(s->oobdata, buf, len);\r
+ s->sending_oob = len;\r
+\r
+ /*\r
+ * Now try sending from the start of the buffer list.\r
+ */\r
+ if (s->writable)\r
+ try_send(s);\r
+\r
+ return s->sending_oob;\r
+}\r
+\r
+int select_result(WPARAM wParam, LPARAM lParam)\r
+{\r
+ int ret, open;\r
+ DWORD err;\r
+ char buf[20480]; /* nice big buffer for plenty of speed */\r
+ Actual_Socket s;\r
+ u_long atmark;\r
+\r
+ /* wParam is the socket itself */\r
+\r
+ if (wParam == 0)\r
+ return 1; /* boggle */\r
+\r
+ s = find234(sktree, (void *) wParam, cmpforsearch);\r
+ if (!s)\r
+ return 1; /* boggle */\r
+\r
+ if ((err = WSAGETSELECTERROR(lParam)) != 0) {\r
+ /*\r
+ * An error has occurred on this socket. Pass it to the\r
+ * plug.\r
+ */\r
+ if (s->addr) {\r
+ plug_log(s->plug, 1, s->addr, s->port,\r
+ winsock_error_string(err), err);\r
+ while (s->addr && sk_nextaddr(s->addr, &s->step)) {\r
+ err = try_connect(s);\r
+ }\r
+ }\r
+ if (err != 0)\r
+ return plug_closing(s->plug, winsock_error_string(err), err, 0);\r
+ else\r
+ return 1;\r
+ }\r
+\r
+ noise_ultralight(lParam);\r
+\r
+ switch (WSAGETSELECTEVENT(lParam)) {\r
+ case FD_CONNECT:\r
+ s->connected = s->writable = 1;\r
+ /*\r
+ * Once a socket is connected, we can stop falling\r
+ * back through the candidate addresses to connect\r
+ * to.\r
+ */\r
+ if (s->addr) {\r
+ sk_addr_free(s->addr);\r
+ s->addr = NULL;\r
+ }\r
+ break;\r
+ case FD_READ:\r
+ /* In the case the socket is still frozen, we don't even bother */\r
+ if (s->frozen) {\r
+ s->frozen_readable = 1;\r
+ break;\r
+ }\r
+\r
+ /*\r
+ * We have received data on the socket. For an oobinline\r
+ * socket, this might be data _before_ an urgent pointer,\r
+ * in which case we send it to the back end with type==1\r
+ * (data prior to urgent).\r
+ */\r
+ if (s->oobinline) {\r
+ atmark = 1;\r
+ p_ioctlsocket(s->s, SIOCATMARK, &atmark);\r
+ /*\r
+ * Avoid checking the return value from ioctlsocket(),\r
+ * on the grounds that some WinSock wrappers don't\r
+ * support it. If it does nothing, we get atmark==1,\r
+ * which is equivalent to `no OOB pending', so the\r
+ * effect will be to non-OOB-ify any OOB data.\r
+ */\r
+ } else\r
+ atmark = 1;\r
+\r
+ ret = p_recv(s->s, buf, sizeof(buf), 0);\r
+ noise_ultralight(ret);\r
+ if (ret < 0) {\r
+ err = p_WSAGetLastError();\r
+ if (err == WSAEWOULDBLOCK) {\r
+ break;\r
+ }\r
+ }\r
+ if (ret < 0) {\r
+ return plug_closing(s->plug, winsock_error_string(err), err,\r
+ 0);\r
+ } else if (0 == ret) {\r
+ return plug_closing(s->plug, NULL, 0, 0);\r
+ } else {\r
+ return plug_receive(s->plug, atmark ? 0 : 1, buf, ret);\r
+ }\r
+ break;\r
+ case FD_OOB:\r
+ /*\r
+ * This will only happen on a non-oobinline socket. It\r
+ * indicates that we can immediately perform an OOB read\r
+ * and get back OOB data, which we will send to the back\r
+ * end with type==2 (urgent data).\r
+ */\r
+ ret = p_recv(s->s, buf, sizeof(buf), MSG_OOB);\r
+ noise_ultralight(ret);\r
+ if (ret <= 0) {\r
+ char *str = (ret == 0 ? "Internal networking trouble" :\r
+ winsock_error_string(p_WSAGetLastError()));\r
+ /* We're inside the Windows frontend here, so we know\r
+ * that the frontend handle is unnecessary. */\r
+ logevent(NULL, str);\r
+ fatalbox("%s", str);\r
+ } else {\r
+ return plug_receive(s->plug, 2, buf, ret);\r
+ }\r
+ break;\r
+ case FD_WRITE:\r
+ {\r
+ int bufsize_before, bufsize_after;\r
+ s->writable = 1;\r
+ bufsize_before = s->sending_oob + bufchain_size(&s->output_data);\r
+ try_send(s);\r
+ bufsize_after = s->sending_oob + bufchain_size(&s->output_data);\r
+ if (bufsize_after < bufsize_before)\r
+ plug_sent(s->plug, bufsize_after);\r
+ }\r
+ break;\r
+ case FD_CLOSE:\r
+ /* Signal a close on the socket. First read any outstanding data. */\r
+ open = 1;\r
+ do {\r
+ ret = p_recv(s->s, buf, sizeof(buf), 0);\r
+ if (ret < 0) {\r
+ err = p_WSAGetLastError();\r
+ if (err == WSAEWOULDBLOCK)\r
+ break;\r
+ return plug_closing(s->plug, winsock_error_string(err),\r
+ err, 0);\r
+ } else {\r
+ if (ret)\r
+ open &= plug_receive(s->plug, 0, buf, ret);\r
+ else\r
+ open &= plug_closing(s->plug, NULL, 0, 0);\r
+ }\r
+ } while (ret > 0);\r
+ return open;\r
+ case FD_ACCEPT:\r
+ {\r
+#ifdef NO_IPV6\r
+ struct sockaddr_in isa;\r
+#else\r
+ struct sockaddr_storage isa;\r
+#endif\r
+ int addrlen = sizeof(isa);\r
+ SOCKET t; /* socket of connection */\r
+\r
+ memset(&isa, 0, sizeof(isa));\r
+ err = 0;\r
+ t = p_accept(s->s,(struct sockaddr *)&isa,&addrlen);\r
+ if (t == INVALID_SOCKET)\r
+ {\r
+ err = p_WSAGetLastError();\r
+ if (err == WSATRY_AGAIN)\r
+ break;\r
+ }\r
+#ifndef NO_IPV6\r
+ if (isa.ss_family == AF_INET &&\r
+ s->localhost_only &&\r
+ !ipv4_is_local_addr(((struct sockaddr_in *)&isa)->sin_addr))\r
+#else\r
+ if (s->localhost_only && !ipv4_is_local_addr(isa.sin_addr))\r
+#endif\r
+ {\r
+ p_closesocket(t); /* dodgy WinSock let nonlocal through */\r
+ } else if (plug_accepting(s->plug, (void*)t)) {\r
+ p_closesocket(t); /* denied or error */\r
+ }\r
+ }\r
+ }\r
+\r
+ return 1;\r
+}\r
+\r
+/*\r
+ * Deal with socket errors detected in try_send().\r
+ */\r
+void net_pending_errors(void)\r
+{\r
+ int i;\r
+ Actual_Socket s;\r
+\r
+ /*\r
+ * This might be a fiddly business, because it's just possible\r
+ * that handling a pending error on one socket might cause\r
+ * others to be closed. (I can't think of any reason this might\r
+ * happen in current SSH implementation, but to maintain\r
+ * generality of this network layer I'll assume the worst.)\r
+ * \r
+ * So what we'll do is search the socket list for _one_ socket\r
+ * with a pending error, and then handle it, and then search\r
+ * the list again _from the beginning_. Repeat until we make a\r
+ * pass with no socket errors present. That way we are\r
+ * protected against the socket list changing under our feet.\r
+ */\r
+\r
+ do {\r
+ for (i = 0; (s = index234(sktree, i)) != NULL; i++) {\r
+ if (s->pending_error) {\r
+ /*\r
+ * An error has occurred on this socket. Pass it to the\r
+ * plug.\r
+ */\r
+ plug_closing(s->plug,\r
+ winsock_error_string(s->pending_error),\r
+ s->pending_error, 0);\r
+ break;\r
+ }\r
+ }\r
+ } while (s);\r
+}\r
+\r
+/*\r
+ * Each socket abstraction contains a `void *' private field in\r
+ * which the client can keep state.\r
+ */\r
+static void sk_tcp_set_private_ptr(Socket sock, void *ptr)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+ s->private_ptr = ptr;\r
+}\r
+\r
+static void *sk_tcp_get_private_ptr(Socket sock)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+ return s->private_ptr;\r
+}\r
+\r
+/*\r
+ * Special error values are returned from sk_namelookup and sk_new\r
+ * if there's a problem. These functions extract an error message,\r
+ * or return NULL if there's no problem.\r
+ */\r
+const char *sk_addr_error(SockAddr addr)\r
+{\r
+ return addr->error;\r
+}\r
+static const char *sk_tcp_socket_error(Socket sock)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+ return s->error;\r
+}\r
+\r
+static void sk_tcp_set_frozen(Socket sock, int is_frozen)\r
+{\r
+ Actual_Socket s = (Actual_Socket) sock;\r
+ if (s->frozen == is_frozen)\r
+ return;\r
+ s->frozen = is_frozen;\r
+ if (!is_frozen) {\r
+ do_select(s->s, 1);\r
+ if (s->frozen_readable) {\r
+ char c;\r
+ p_recv(s->s, &c, 1, MSG_PEEK);\r
+ }\r
+ }\r
+ s->frozen_readable = 0;\r
+}\r
+\r
+void socket_reselect_all(void)\r
+{\r
+ Actual_Socket s;\r
+ int i;\r
+\r
+ for (i = 0; (s = index234(sktree, i)) != NULL; i++) {\r
+ if (!s->frozen)\r
+ do_select(s->s, 1);\r
+ }\r
+}\r
+\r
+/*\r
+ * For Plink: enumerate all sockets currently active.\r
+ */\r
+SOCKET first_socket(int *state)\r
+{\r
+ Actual_Socket s;\r
+ *state = 0;\r
+ s = index234(sktree, (*state)++);\r
+ return s ? s->s : INVALID_SOCKET;\r
+}\r
+\r
+SOCKET next_socket(int *state)\r
+{\r
+ Actual_Socket s = index234(sktree, (*state)++);\r
+ return s ? s->s : INVALID_SOCKET;\r
+}\r
+\r
+extern int socket_writable(SOCKET skt)\r
+{\r
+ Actual_Socket s = find234(sktree, (void *)skt, cmpforsearch);\r
+\r
+ if (s)\r
+ return bufchain_size(&s->output_data) > 0;\r
+ else\r
+ return 0;\r
+}\r
+\r
+int net_service_lookup(char *service)\r
+{\r
+ struct servent *se;\r
+ se = p_getservbyname(service, NULL);\r
+ if (se != NULL)\r
+ return p_ntohs(se->s_port);\r
+ else\r
+ return 0;\r
+}\r
+\r
+char *get_hostname(void)\r
+{\r
+ int len = 128;\r
+ char *hostname = NULL;\r
+ do {\r
+ len *= 2;\r
+ hostname = sresize(hostname, len, char);\r
+ if (p_gethostname(hostname, len) < 0) {\r
+ sfree(hostname);\r
+ hostname = NULL;\r
+ break;\r
+ }\r
+ } while (strlen(hostname) >= (size_t)(len-1));\r
+ return hostname;\r
+}\r
+\r
+SockAddr platform_get_x11_unix_address(const char *display, int displaynum,\r
+ char **canonicalname)\r
+{\r
+ SockAddr ret = snew(struct SockAddr_tag);\r
+ memset(ret, 0, sizeof(struct SockAddr_tag));\r
+ ret->error = "unix sockets not supported on this platform";\r
+ ret->refcount = 1;\r
+ return ret;\r
+}\r
OSDN Git Service
