char oobdata[1];
int sending_oob;
int oobinline, nodelay, keepalive, privport;
+ enum { EOF_NO, EOF_PENDING, EOF_SENT } outgoingeof;
SockAddr addr;
SockAddrStep step;
int port;
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(module, name) \
- p_##name = module ? (t_##name) GetProcAddress(module, #name) : NULL
-
-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, int, gethostname, (char *, int));
-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_WINSOCK_FUNCTION(static, int, getaddrinfo,
+DECL_WINDOWS_FUNCTION(static, int, getaddrinfo,
(const char *nodename, const char *servname,
const struct addrinfo *hints, struct addrinfo **res));
-DECL_WINSOCK_FUNCTION(static, void, freeaddrinfo, (struct addrinfo *res));
-DECL_WINSOCK_FUNCTION(static, int, getnameinfo,
+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_WINSOCK_FUNCTION(static, char *, gai_strerror, (int ecode));
-DECL_WINSOCK_FUNCTION(static, int, WSAAddressToStringA,
+DECL_WINDOWS_FUNCTION(static, char *, gai_strerror, (int ecode));
+DECL_WINDOWS_FUNCTION(static, int, WSAAddressToStringA,
(LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFO,
LPSTR, LPDWORD));
#endif
#ifndef NO_IPV6
winsock2_module =
#endif
- winsock_module = LoadLibrary("WS2_32.DLL");
+ winsock_module = load_system32_dll("ws2_32.dll");
if (!winsock_module) {
- winsock_module = LoadLibrary("WSOCK32.DLL");
+ winsock_module = load_system32_dll("wsock32.dll");
}
if (!winsock_module)
fatalbox("Unable to load any WinSock library");
#ifdef NET_SETUP_DIAGNOSTICS
logevent(NULL, "Native WinSock IPv6 support detected");
#endif
- GET_WINSOCK_FUNCTION(winsock_module, getaddrinfo);
- GET_WINSOCK_FUNCTION(winsock_module, freeaddrinfo);
- GET_WINSOCK_FUNCTION(winsock_module, getnameinfo);
- GET_WINSOCK_FUNCTION(winsock_module, gai_strerror);
+ 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 = LoadLibrary("wship6.dll");
+ wship6_module = load_system32_dll("wship6.dll");
if (wship6_module) {
#ifdef NET_SETUP_DIAGNOSTICS
logevent(NULL, "WSH IPv6 support detected");
#endif
- GET_WINSOCK_FUNCTION(wship6_module, getaddrinfo);
- GET_WINSOCK_FUNCTION(wship6_module, freeaddrinfo);
- GET_WINSOCK_FUNCTION(wship6_module, getnameinfo);
- GET_WINSOCK_FUNCTION(wship6_module, gai_strerror);
+ 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_WINSOCK_FUNCTION(winsock2_module, WSAAddressToStringA);
+ GET_WINDOWS_FUNCTION(winsock2_module, WSAAddressToStringA);
#else
#ifdef NET_SETUP_DIAGNOSTICS
logevent(NULL, "PuTTY was built without IPv6 support");
#endif
#endif
- GET_WINSOCK_FUNCTION(winsock_module, WSAAsyncSelect);
- GET_WINSOCK_FUNCTION(winsock_module, WSAEventSelect);
- GET_WINSOCK_FUNCTION(winsock_module, select);
- GET_WINSOCK_FUNCTION(winsock_module, WSAGetLastError);
- GET_WINSOCK_FUNCTION(winsock_module, WSAEnumNetworkEvents);
- GET_WINSOCK_FUNCTION(winsock_module, WSAStartup);
- GET_WINSOCK_FUNCTION(winsock_module, WSACleanup);
- GET_WINSOCK_FUNCTION(winsock_module, closesocket);
- GET_WINSOCK_FUNCTION(winsock_module, ntohl);
- GET_WINSOCK_FUNCTION(winsock_module, htonl);
- GET_WINSOCK_FUNCTION(winsock_module, htons);
- GET_WINSOCK_FUNCTION(winsock_module, ntohs);
- GET_WINSOCK_FUNCTION(winsock_module, gethostname);
- GET_WINSOCK_FUNCTION(winsock_module, gethostbyname);
- GET_WINSOCK_FUNCTION(winsock_module, getservbyname);
- GET_WINSOCK_FUNCTION(winsock_module, inet_addr);
- GET_WINSOCK_FUNCTION(winsock_module, inet_ntoa);
- GET_WINSOCK_FUNCTION(winsock_module, connect);
- GET_WINSOCK_FUNCTION(winsock_module, bind);
- GET_WINSOCK_FUNCTION(winsock_module, setsockopt);
- GET_WINSOCK_FUNCTION(winsock_module, socket);
- GET_WINSOCK_FUNCTION(winsock_module, listen);
- GET_WINSOCK_FUNCTION(winsock_module, send);
- GET_WINSOCK_FUNCTION(winsock_module, ioctlsocket);
- GET_WINSOCK_FUNCTION(winsock_module, accept);
- GET_WINSOCK_FUNCTION(winsock_module, recv);
- GET_WINSOCK_FUNCTION(winsock_module, WSAIoctl);
+ 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) &&
#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";
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,
}
}
-int sk_hostname_is_local(char *name)
+int sk_hostname_is_local(const char *name)
{
return !strcmp(name, "localhost") ||
!strcmp(name, "::1") ||
#ifndef NO_IPV6
if (family == AF_INET6) {
- return IN6_IS_ADDR_LOOPBACK((const struct in6_addr *)step.ai->ai_addr);
+ return IN6_IS_ADDR_LOOPBACK(&((const struct sockaddr_in6 *)step.ai->ai_addr)->sin6_addr);
} else
#endif
if (family == AF_INET) {
}
}
+int sk_address_is_special_local(SockAddr addr)
+{
+ return 0; /* no Unix-domain socket analogue here */
+}
+
int sk_addrtype(SockAddr addr)
{
SockAddrStep step;
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);
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,
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 */
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,
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 */
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,
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;
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;
}
}
}
}
+
+ /*
+ * 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.
*/
{
Actual_Socket s = (Actual_Socket) sock;
+ assert(s->outgoingeof == EOF_NO);
+
/*
* Replace the buffer list on the socket with the data.
*/
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;
hostname = NULL;
break;
}
- } while (strlen(hostname) >= len-1);
+ } while (strlen(hostname) >= (size_t)(len-1));
return hostname;
}
projects / u / mdw / putty / blobdiff