Justin Bradford's proxy support patch. Currently supports only HTTP
[u/mdw/putty] / winnet.c
CommitLineData
2f75bae1 1/*
2 * Windows networking abstraction.
c4d8e107 3 *
4 * Due to this clean abstraction it was possible
5 * to easily implement IPv6 support :)
6 *
7 * IPv6 patch 1 (27 October 2000) Jeroen Massar <jeroen@unfix.org>
8 * - Preliminary hacked IPv6 support.
9 * - Connecting to IPv6 address (eg fec0:4242:4242:100:2d0:b7ff:fe8f:5d42) works.
10 * - Connecting to IPv6 hostname (eg heaven.ipv6.unfix.org) works.
11 * - Compiles as either IPv4 or IPv6.
12 *
13 * IPv6 patch 2 (29 October 2000) Jeroen Massar <jeroen@unfix.org>
14 * - When compiled as IPv6 it also allows connecting to IPv4 hosts.
15 * - Added some more documentation.
16 *
17 * IPv6 patch 3 (18 November 2000) Jeroen Massar <jeroen@unfix.org>
18 * - It now supports dynamically loading the IPv6 resolver dll's.
19 * This way we should be able to distribute one (1) binary
20 * which supports both IPv4 and IPv6.
21 * - getaddrinfo() and getnameinfo() are loaded dynamicaly if possible.
22 * - in6addr_any is defined in this file so we don't need to link to wship6.lib
23 * - The patch is now more unified so that we can still
24 * remove all IPv6 support by undef'ing IPV6.
25 * But where it fallsback to IPv4 it uses the IPv4 code which is already in place...
26 * - Canonical name resolving works.
27 *
28 * IPv6 patch 4 (07 January 2001) Jeroen Massar <jeroen@unfix.org>
29 * - patch against CVS of today, will be submitted to the bugs list
30 * as a 'cvs diff -u' on Simon's request...
31 *
2f75bae1 32 */
33
c4d8e107 34/*
35 * Define IPV6 to have IPv6 on-the-fly-loading support.
36 * This means that one doesn't have to have an IPv6 stack to use it.
37 * But if an IPv6 stack is found it is used with a fallback to IPv4.
38 */
39/* #define IPV6 1 */
40
41#ifdef IPV6
42#include <winsock2.h>
43#include <ws2tcpip.h>
44#include <tpipv6.h>
45#else
2f75bae1 46#include <winsock.h>
c4d8e107 47#endif
48#include <windows.h>
2f75bae1 49#include <stdio.h>
49bad831 50#include <stdlib.h>
5471d09a 51#include <assert.h>
2f75bae1 52
7e78000d 53#define DEFINE_PLUG_METHOD_MACROS
2f75bae1 54#include "putty.h"
55#include "network.h"
56#include "tree234.h"
57
2f75bae1 58struct Socket_tag {
7e78000d 59 struct socket_function_table *fn;
60 /* the above variable absolutely *must* be the first in this structure */
2f75bae1 61 char *error;
62 SOCKET s;
7e78000d 63 Plug plug;
2f75bae1 64 void *private_ptr;
5471d09a 65 bufchain output_data;
3ad9d396 66 int connected;
2f75bae1 67 int writable;
5471d09a 68 int frozen; /* this causes readability notifications to be ignored */
69 int frozen_readable; /* this means we missed at least one readability
70 * notification while we were frozen */
bc4802a1 71 int localhost_only; /* for listening sockets */
5471d09a 72 char oobdata[1];
1ad4eb6f 73 int sending_oob;
4b1e8acc 74 int oobinline;
7732d38a 75 int pending_error; /* in case send() returns error */
2f75bae1 76};
77
7e78000d 78/*
79 * We used to typedef struct Socket_tag *Socket.
80 *
81 * Since we have made the networking abstraction slightly more
82 * abstract, Socket no longer means a tcp socket (it could mean
83 * an ssl socket). So now we must use Actual_Socket when we know
84 * we are talking about a tcp socket.
85 */
86typedef struct Socket_tag *Actual_Socket;
87
2f75bae1 88struct SockAddr_tag {
89 char *error;
c4d8e107 90 /* address family this belongs to, AF_INET for IPv4, AF_INET6 for IPv6. */
32874aea 91 int family;
c4d8e107 92 unsigned long address; /* Address IPv4 style. */
93#ifdef IPV6
94 struct addrinfo *ai; /* Address IPv6 style. */
95#endif
2f75bae1 96};
97
2f75bae1 98static tree234 *sktree;
99
32874aea 100static int cmpfortree(void *av, void *bv)
101{
102 Actual_Socket a = (Actual_Socket) av, b = (Actual_Socket) bv;
103 unsigned long as = (unsigned long) a->s, bs = (unsigned long) b->s;
104 if (as < bs)
105 return -1;
106 if (as > bs)
107 return +1;
2f75bae1 108 return 0;
109}
110
32874aea 111static int cmpforsearch(void *av, void *bv)
112{
113 Actual_Socket b = (Actual_Socket) bv;
114 unsigned long as = (unsigned long) av, bs = (unsigned long) b->s;
115 if (as < bs)
116 return -1;
117 if (as > bs)
118 return +1;
2f75bae1 119 return 0;
120}
121
32874aea 122void sk_init(void)
123{
2f75bae1 124 sktree = newtree234(cmpfortree);
125}
126
93b581bd 127void sk_cleanup(void)
128{
129 Actual_Socket s;
130 int i;
131
132 if (sktree) {
133 for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
134 closesocket(s->s);
135 }
136 }
137}
138
32874aea 139char *winsock_error_string(int error)
140{
e74fbad9 141 switch (error) {
32874aea 142 case WSAEACCES:
143 return "Network error: Permission denied";
144 case WSAEADDRINUSE:
145 return "Network error: Address already in use";
146 case WSAEADDRNOTAVAIL:
147 return "Network error: Cannot assign requested address";
148 case WSAEAFNOSUPPORT:
149 return
150 "Network error: Address family not supported by protocol family";
151 case WSAEALREADY:
152 return "Network error: Operation already in progress";
153 case WSAECONNABORTED:
154 return "Network error: Software caused connection abort";
155 case WSAECONNREFUSED:
156 return "Network error: Connection refused";
157 case WSAECONNRESET:
158 return "Network error: Connection reset by peer";
159 case WSAEDESTADDRREQ:
160 return "Network error: Destination address required";
161 case WSAEFAULT:
162 return "Network error: Bad address";
163 case WSAEHOSTDOWN:
164 return "Network error: Host is down";
165 case WSAEHOSTUNREACH:
166 return "Network error: No route to host";
167 case WSAEINPROGRESS:
168 return "Network error: Operation now in progress";
169 case WSAEINTR:
170 return "Network error: Interrupted function call";
171 case WSAEINVAL:
172 return "Network error: Invalid argument";
173 case WSAEISCONN:
174 return "Network error: Socket is already connected";
175 case WSAEMFILE:
176 return "Network error: Too many open files";
177 case WSAEMSGSIZE:
178 return "Network error: Message too long";
179 case WSAENETDOWN:
180 return "Network error: Network is down";
181 case WSAENETRESET:
182 return "Network error: Network dropped connection on reset";
183 case WSAENETUNREACH:
184 return "Network error: Network is unreachable";
185 case WSAENOBUFS:
186 return "Network error: No buffer space available";
187 case WSAENOPROTOOPT:
188 return "Network error: Bad protocol option";
189 case WSAENOTCONN:
190 return "Network error: Socket is not connected";
191 case WSAENOTSOCK:
192 return "Network error: Socket operation on non-socket";
193 case WSAEOPNOTSUPP:
194 return "Network error: Operation not supported";
195 case WSAEPFNOSUPPORT:
196 return "Network error: Protocol family not supported";
197 case WSAEPROCLIM:
198 return "Network error: Too many processes";
199 case WSAEPROTONOSUPPORT:
200 return "Network error: Protocol not supported";
201 case WSAEPROTOTYPE:
202 return "Network error: Protocol wrong type for socket";
203 case WSAESHUTDOWN:
204 return "Network error: Cannot send after socket shutdown";
205 case WSAESOCKTNOSUPPORT:
206 return "Network error: Socket type not supported";
207 case WSAETIMEDOUT:
208 return "Network error: Connection timed out";
209 case WSAEWOULDBLOCK:
210 return "Network error: Resource temporarily unavailable";
211 case WSAEDISCON:
212 return "Network error: Graceful shutdown in progress";
213 default:
214 return "Unknown network error";
e74fbad9 215 }
216}
217
c4d8e107 218SockAddr sk_namelookup(char *host, char **canonicalname)
219{
2f75bae1 220 SockAddr ret = smalloc(sizeof(struct SockAddr_tag));
221 unsigned long a;
c4d8e107 222 struct hostent *h = NULL;
6e1ebb76 223 char realhost[8192];
2f75bae1 224
c4d8e107 225 /* Clear the structure and default to IPv4. */
226 memset(ret, 0, sizeof(struct SockAddr_tag));
227 ret->family = 0; /* We set this one when we have resolved the host. */
6e1ebb76 228 *realhost = '\0';
c4d8e107 229
32874aea 230 if ((a = inet_addr(host)) == (unsigned long) INADDR_NONE) {
c4d8e107 231#ifdef IPV6
232
233 /* Try to get the getaddrinfo() function from wship6.dll */
234 /* This way one doesn't need to have IPv6 dll's to use PuTTY and
235 * it will fallback to IPv4. */
32874aea 236 typedef int (CALLBACK * FGETADDRINFO) (const char *nodename,
237 const char *servname,
238 const struct addrinfo *
239 hints,
240 struct addrinfo ** res);
c4d8e107 241 FGETADDRINFO fGetAddrInfo = NULL;
242
243 HINSTANCE dllWSHIP6 = LoadLibrary("wship6.dll");
244 if (dllWSHIP6)
32874aea 245 fGetAddrInfo = (FGETADDRINFO) GetProcAddress(dllWSHIP6,
246 "getaddrinfo");
c4d8e107 247
248 /*
249 * Use fGetAddrInfo when it's available (which usually also
250 * means IPv6 is installed...)
251 */
32874aea 252 if (fGetAddrInfo) {
c4d8e107 253 /*debug(("Resolving \"%s\" with getaddrinfo() (IPv4+IPv6 capable)...\n", host)); */
254 if (fGetAddrInfo(host, NULL, NULL, &ret->ai) == 0)
255 ret->family = ret->ai->ai_family;
32874aea 256 } else
c4d8e107 257#endif
32874aea 258 {
c4d8e107 259 /*
260 * Otherwise use the IPv4-only gethostbyname...
261 * (NOTE: we don't use gethostbyname as a
262 * fallback!)
263 */
32874aea 264 if (ret->family == 0) {
265 /*debug(("Resolving \"%s\" with gethostbyname() (IPv4 only)...\n", host)); */
2d466ffd 266 if ( (h = gethostbyname(host)) )
32874aea 267 ret->family = AF_INET;
268 }
c4d8e107 269 }
270 /*debug(("Done resolving...(family is %d) AF_INET = %d, AF_INET6 = %d\n", ret->family, AF_INET, AF_INET6)); */
271
32874aea 272 if (ret->family == 0) {
2f75bae1 273 DWORD err = WSAGetLastError();
c4d8e107 274 ret->error = (err == WSAENETDOWN ? "Network is down" :
32874aea 275 err ==
276 WSAHOST_NOT_FOUND ? "Host does not exist" : err
277 == WSATRY_AGAIN ? "Host not found" :
c4d8e107 278#ifdef IPV6
279 fGetAddrInfo ? "getaddrinfo: unknown error" :
280#endif
281 "gethostbyname: unknown error");
282#ifdef DEBUG
283 {
284 LPVOID lpMsgBuf;
32874aea 285 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
286 FORMAT_MESSAGE_FROM_SYSTEM |
287 FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err,
288 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
289 (LPTSTR) & lpMsgBuf, 0, NULL);
290 /*debug(("Error %ld: %s (h=%lx)\n", err, lpMsgBuf, h)); */
c4d8e107 291 /* Free the buffer. */
292 LocalFree(lpMsgBuf);
293 }
294#endif
32874aea 295 } else {
c4d8e107 296 ret->error = NULL;
297
298#ifdef IPV6
299 /* If we got an address info use that... */
32874aea 300 if (ret->ai) {
301 typedef int (CALLBACK * FGETNAMEINFO)
302 (const struct sockaddr FAR * sa, socklen_t salen,
303 char FAR * host, size_t hostlen, char FAR * serv,
304 size_t servlen, int flags);
c4d8e107 305 FGETNAMEINFO fGetNameInfo = NULL;
306
307 /* Are we in IPv4 fallback mode? */
308 /* We put the IPv4 address into the a variable so we can further-on use the IPv4 code... */
309 if (ret->family == AF_INET)
32874aea 310 memcpy(&a,
311 (char *) &((SOCKADDR_IN *) ret->ai->
312 ai_addr)->sin_addr, sizeof(a));
c4d8e107 313
314 /* Now let's find that canonicalname... */
32874aea 315 if ((dllWSHIP6)
316 && (fGetNameInfo =
317 (FGETNAMEINFO) GetProcAddress(dllWSHIP6,
318 "getnameinfo"))) {
319 if (fGetNameInfo
320 ((struct sockaddr *) ret->ai->ai_addr,
321 ret->family ==
322 AF_INET ? sizeof(SOCKADDR_IN) :
6e1ebb76 323 sizeof(SOCKADDR_IN6), realhost,
324 sizeof(realhost), NULL, 0, 0) != 0) {
325 strncpy(realhost, host, sizeof(realhost));
c4d8e107 326 }
327 }
328 }
329 /* We used the IPv4-only gethostbyname()... */
330 else
c4d8e107 331#endif
32874aea 332 {
c4d8e107 333 memcpy(&a, h->h_addr, sizeof(a));
334 /* This way we are always sure the h->h_name is valid :) */
6e1ebb76 335 strncpy(realhost, h->h_name, sizeof(realhost));
c4d8e107 336 }
c4d8e107 337 }
338#ifdef IPV6
339 FreeLibrary(dllWSHIP6);
340#endif
32874aea 341 } else {
87ed061f 342 /*
343 * This must be a numeric IPv4 address because it caused a
344 * success return from inet_addr.
345 */
32874aea 346 ret->family = AF_INET;
6e1ebb76 347 strncpy(realhost, host, sizeof(realhost));
2f75bae1 348 }
349 ret->address = ntohl(a);
6e1ebb76 350 realhost[lenof(realhost)-1] = '\0';
351 *canonicalname = smalloc(1+strlen(realhost));
352 strcpy(*canonicalname, realhost);
2f75bae1 353 return ret;
354}
355
3ad9d396 356void sk_getaddr(SockAddr addr, char *buf, int buflen)
357{
358#ifdef IPV6
359 if (addr->family == AF_INET) {
360#endif
361 struct in_addr a;
362 a.s_addr = htonl(addr->address);
363 strncpy(buf, inet_ntoa(a), buflen);
364#ifdef IPV6
365 } else {
366 FIXME; /* I don't know how to get a text form of an IPv6 address. */
367 }
368#endif
369}
370
32874aea 371void sk_addr_free(SockAddr addr)
372{
2f75bae1 373 sfree(addr);
374}
375
32874aea 376static Plug sk_tcp_plug(Socket sock, Plug p)
377{
7e78000d 378 Actual_Socket s = (Actual_Socket) sock;
379 Plug ret = s->plug;
32874aea 380 if (p)
381 s->plug = p;
7e78000d 382 return ret;
383}
384
32874aea 385static void sk_tcp_flush(Socket s)
386{
7e78000d 387 /*
388 * We send data to the socket as soon as we can anyway,
389 * so we don't need to do anything here. :-)
390 */
391}
392
2d466ffd 393static void sk_tcp_close(Socket s);
5471d09a 394static int sk_tcp_write(Socket s, char *data, int len);
395static int sk_tcp_write_oob(Socket s, char *data, int len);
8eebd221 396static void sk_tcp_set_private_ptr(Socket s, void *ptr);
397static void *sk_tcp_get_private_ptr(Socket s);
398static void sk_tcp_set_frozen(Socket s, int is_frozen);
2d466ffd 399static char *sk_tcp_socket_error(Socket s);
7e78000d 400
d74d141c 401extern char *do_select(SOCKET skt, int startup);
402
403Socket sk_register(void *sock, Plug plug)
404{
405 static struct socket_function_table fn_table = {
406 sk_tcp_plug,
407 sk_tcp_close,
408 sk_tcp_write,
409 sk_tcp_write_oob,
410 sk_tcp_flush,
8eebd221 411 sk_tcp_set_private_ptr,
412 sk_tcp_get_private_ptr,
413 sk_tcp_set_frozen,
d74d141c 414 sk_tcp_socket_error
415 };
416
417 DWORD err;
418 char *errstr;
419 Actual_Socket ret;
420
421 /*
422 * Create Socket structure.
423 */
424 ret = smalloc(sizeof(struct Socket_tag));
425 ret->fn = &fn_table;
426 ret->error = NULL;
427 ret->plug = plug;
5471d09a 428 bufchain_init(&ret->output_data);
d74d141c 429 ret->writable = 1; /* to start with */
430 ret->sending_oob = 0;
431 ret->frozen = 1;
5471d09a 432 ret->frozen_readable = 0;
bc4802a1 433 ret->localhost_only = 0; /* unused, but best init anyway */
7732d38a 434 ret->pending_error = 0;
d74d141c 435
436 ret->s = (SOCKET)sock;
437
438 if (ret->s == INVALID_SOCKET) {
439 err = WSAGetLastError();
440 ret->error = winsock_error_string(err);
441 return (Socket) ret;
442 }
443
444 ret->oobinline = 0;
445
446 /* Set up a select mechanism. This could be an AsyncSelect on a
447 * window, or an EventSelect on an event object. */
448 errstr = do_select(ret->s, 1);
449 if (errstr) {
450 ret->error = errstr;
451 return (Socket) ret;
452 }
453
454 add234(sktree, ret);
455
456 return (Socket) ret;
457}
458
4b1e8acc 459Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
2184a5d9 460 int nodelay, Plug plug)
7e78000d 461{
462 static struct socket_function_table fn_table = {
463 sk_tcp_plug,
464 sk_tcp_close,
465 sk_tcp_write,
466 sk_tcp_write_oob,
467 sk_tcp_flush,
8eebd221 468 sk_tcp_set_private_ptr,
469 sk_tcp_get_private_ptr,
470 sk_tcp_set_frozen,
7e78000d 471 sk_tcp_socket_error
472 };
473
2f75bae1 474 SOCKET s;
c4d8e107 475#ifdef IPV6
476 SOCKADDR_IN6 a6;
477#endif
2f75bae1 478 SOCKADDR_IN a;
479 DWORD err;
480 char *errstr;
7e78000d 481 Actual_Socket ret;
c91409da 482 short localport;
2f75bae1 483
484 /*
485 * Create Socket structure.
486 */
487 ret = smalloc(sizeof(struct Socket_tag));
7e78000d 488 ret->fn = &fn_table;
2f75bae1 489 ret->error = NULL;
7e78000d 490 ret->plug = plug;
5471d09a 491 bufchain_init(&ret->output_data);
3ad9d396 492 ret->connected = 0; /* to start with */
493 ret->writable = 0; /* to start with */
33232c8f 494 ret->sending_oob = 0;
d74d141c 495 ret->frozen = 0;
5471d09a 496 ret->frozen_readable = 0;
bc4802a1 497 ret->localhost_only = 0; /* unused, but best init anyway */
7732d38a 498 ret->pending_error = 0;
2f75bae1 499
500 /*
501 * Open socket.
502 */
c4d8e107 503 s = socket(addr->family, SOCK_STREAM, 0);
2f75bae1 504 ret->s = s;
505
506 if (s == INVALID_SOCKET) {
507 err = WSAGetLastError();
32874aea 508 ret->error = winsock_error_string(err);
7e78000d 509 return (Socket) ret;
2f75bae1 510 }
4b1e8acc 511
512 ret->oobinline = oobinline;
513 if (oobinline) {
1ad4eb6f 514 BOOL b = TRUE;
32874aea 515 setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b));
1ad4eb6f 516 }
2f75bae1 517
2184a5d9 518 if (nodelay) {
519 BOOL b = TRUE;
520 setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b));
521 }
522
2f75bae1 523 /*
524 * Bind to local address.
525 */
c91409da 526 if (privport)
32874aea 527 localport = 1023; /* count from 1023 downwards */
c4d8e107 528 else
32874aea 529 localport = 0; /* just use port 0 (ie winsock picks) */
c91409da 530
531 /* Loop round trying to bind */
532 while (1) {
32874aea 533 int retcode;
c91409da 534
535#ifdef IPV6
32874aea 536 if (addr->family == AF_INET6) {
537 memset(&a6, 0, sizeof(a6));
538 a6.sin6_family = AF_INET6;
539/*a6.sin6_addr = in6addr_any; *//* == 0 */
540 a6.sin6_port = htons(localport);
541 } else
c4d8e107 542#endif
32874aea 543 {
544 a.sin_family = AF_INET;
545 a.sin_addr.s_addr = htonl(INADDR_ANY);
546 a.sin_port = htons(localport);
547 }
c4d8e107 548#ifdef IPV6
32874aea 549 retcode = bind(s, (addr->family == AF_INET6 ?
550 (struct sockaddr *) &a6 :
551 (struct sockaddr *) &a),
552 (addr->family ==
553 AF_INET6 ? sizeof(a6) : sizeof(a)));
c4d8e107 554#else
32874aea 555 retcode = bind(s, (struct sockaddr *) &a, sizeof(a));
c4d8e107 556#endif
32874aea 557 if (retcode != SOCKET_ERROR) {
558 err = 0;
559 break; /* done */
560 } else {
561 err = WSAGetLastError();
562 if (err != WSAEADDRINUSE) /* failed, for a bad reason */
563 break;
564 }
565
566 if (localport == 0)
567 break; /* we're only looping once */
568 localport--;
569 if (localport == 0)
570 break; /* we might have got to the end */
c91409da 571 }
572
32874aea 573 if (err) {
c4d8e107 574 ret->error = winsock_error_string(err);
7e78000d 575 return (Socket) ret;
2f75bae1 576 }
577
578 /*
579 * Connect to remote address.
580 */
c4d8e107 581#ifdef IPV6
32874aea 582 if (addr->family == AF_INET6) {
583 memset(&a, 0, sizeof(a));
c4d8e107 584 a6.sin6_family = AF_INET6;
32874aea 585 a6.sin6_port = htons((short) port);
586 a6.sin6_addr =
587 ((struct sockaddr_in6 *) addr->ai->ai_addr)->sin6_addr;
588 } else
c4d8e107 589#endif
32874aea 590 {
c4d8e107 591 a.sin_family = AF_INET;
592 a.sin_addr.s_addr = htonl(addr->address);
32874aea 593 a.sin_port = htons((short) port);
c4d8e107 594 }
3ad9d396 595
596 /* Set up a select mechanism. This could be an AsyncSelect on a
597 * window, or an EventSelect on an event object. */
598 errstr = do_select(s, 1);
599 if (errstr) {
600 ret->error = errstr;
601 return (Socket) ret;
602 }
603
32874aea 604 if ((
605#ifdef IPV6
606 connect(s, ((addr->family == AF_INET6) ?
607 (struct sockaddr *) &a6 : (struct sockaddr *) &a),
608 (addr->family == AF_INET6) ? sizeof(a6) : sizeof(a))
c4d8e107 609#else
32874aea 610 connect(s, (struct sockaddr *) &a, sizeof(a))
c4d8e107 611#endif
32874aea 612 ) == SOCKET_ERROR) {
2f75bae1 613 err = WSAGetLastError();
3ad9d396 614 /*
615 * We expect a potential EWOULDBLOCK here, because the
616 * chances are the front end has done a select for
617 * FD_CONNECT, so that connect() will complete
618 * asynchronously.
619 */
620 if ( err != WSAEWOULDBLOCK ) {
621 ret->error = winsock_error_string(err);
622 return (Socket) ret;
623 }
624 } else {
625 /*
626 * If we _don't_ get EWOULDBLOCK, the connect has completed
627 * and we should set the socket as writable.
628 */
629 ret->writable = 1;
2f75bae1 630 }
631
632 add234(sktree, ret);
633
7e78000d 634 return (Socket) ret;
2f75bae1 635}
636
bcce45ed 637Socket sk_newlistener(int port, Plug plug, int local_host_only)
d74d141c 638{
639 static struct socket_function_table fn_table = {
640 sk_tcp_plug,
641 sk_tcp_close,
642 sk_tcp_write,
643 sk_tcp_write_oob,
644 sk_tcp_flush,
8eebd221 645 sk_tcp_set_private_ptr,
646 sk_tcp_get_private_ptr,
647 sk_tcp_set_frozen,
d74d141c 648 sk_tcp_socket_error
649 };
650
651 SOCKET s;
652#ifdef IPV6
653 SOCKADDR_IN6 a6;
654#endif
655 SOCKADDR_IN a;
656 DWORD err;
657 char *errstr;
658 Actual_Socket ret;
659 int retcode;
660 int on = 1;
661
662 /*
663 * Create Socket structure.
664 */
665 ret = smalloc(sizeof(struct Socket_tag));
666 ret->fn = &fn_table;
667 ret->error = NULL;
668 ret->plug = plug;
5471d09a 669 bufchain_init(&ret->output_data);
d74d141c 670 ret->writable = 0; /* to start with */
671 ret->sending_oob = 0;
672 ret->frozen = 0;
5471d09a 673 ret->frozen_readable = 0;
bc4802a1 674 ret->localhost_only = local_host_only;
7732d38a 675 ret->pending_error = 0;
d74d141c 676
677 /*
678 * Open socket.
679 */
680 s = socket(AF_INET, SOCK_STREAM, 0);
681 ret->s = s;
682
683 if (s == INVALID_SOCKET) {
684 err = WSAGetLastError();
685 ret->error = winsock_error_string(err);
686 return (Socket) ret;
687 }
688
689 ret->oobinline = 0;
690
691
692 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on));
693
694
695#ifdef IPV6
696 if (addr->family == AF_INET6) {
697 memset(&a6, 0, sizeof(a6));
698 a6.sin6_family = AF_INET6;
bcce45ed 699 if (local_host_only)
700 a6.sin6_addr = in6addr_loopback;
701 else
702 a6.sin6_addr = in6addr_any;
d74d141c 703 a6.sin6_port = htons(port);
704 } else
705#endif
706 {
707 a.sin_family = AF_INET;
bcce45ed 708 if (local_host_only)
709 a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
710 else
711 a.sin_addr.s_addr = htonl(INADDR_ANY);
d74d141c 712 a.sin_port = htons((short)port);
713 }
714#ifdef IPV6
715 retcode = bind(s, (addr->family == AF_INET6 ?
716 (struct sockaddr *) &a6 :
717 (struct sockaddr *) &a),
718 (addr->family ==
719 AF_INET6 ? sizeof(a6) : sizeof(a)));
720#else
721 retcode = bind(s, (struct sockaddr *) &a, sizeof(a));
722#endif
723 if (retcode != SOCKET_ERROR) {
724 err = 0;
725 } else {
726 err = WSAGetLastError();
727 }
728
729 if (err) {
730 ret->error = winsock_error_string(err);
731 return (Socket) ret;
732 }
733
734
735 if (listen(s, SOMAXCONN) == SOCKET_ERROR) {
736 closesocket(s);
737 ret->error = winsock_error_string(err);
738 return (Socket) ret;
739 }
740
741 /* Set up a select mechanism. This could be an AsyncSelect on a
742 * window, or an EventSelect on an event object. */
743 errstr = do_select(s, 1);
744 if (errstr) {
745 ret->error = errstr;
746 return (Socket) ret;
747 }
748
749 add234(sktree, ret);
750
751 return (Socket) ret;
752}
753
32874aea 754static void sk_tcp_close(Socket sock)
755{
9c964e85 756 extern char *do_select(SOCKET skt, int startup);
7e78000d 757 Actual_Socket s = (Actual_Socket) sock;
9c964e85 758
2f75bae1 759 del234(sktree, s);
760 do_select(s->s, 0);
761 closesocket(s->s);
dcbde236 762 sfree(s);
2f75bae1 763}
764
2f75bae1 765/*
766 * The function which tries to send on a socket once it's deemed
767 * writable.
768 */
32874aea 769void try_send(Actual_Socket s)
770{
5471d09a 771 while (s->sending_oob || bufchain_size(&s->output_data) > 0) {
2f75bae1 772 int nsent;
773 DWORD err;
5471d09a 774 void *data;
32874aea 775 int len, urgentflag;
776
777 if (s->sending_oob) {
778 urgentflag = MSG_OOB;
779 len = s->sending_oob;
5471d09a 780 data = &s->oobdata;
32874aea 781 } else {
782 urgentflag = 0;
5471d09a 783 bufchain_prefix(&s->output_data, &data, &len);
32874aea 784 }
5471d09a 785 nsent = send(s->s, data, len, urgentflag);
32874aea 786 noise_ultralight(nsent);
2f75bae1 787 if (nsent <= 0) {
788 err = (nsent < 0 ? WSAGetLastError() : 0);
e5eb3a1c 789 if ((err < WSABASEERR && nsent < 0) || err == WSAEWOULDBLOCK) {
d40a94b9 790 /*
791 * Perfectly normal: we've sent all we can for the moment.
792 *
e5eb3a1c 793 * (Some WinSock send() implementations can return
794 * <0 but leave no sensible error indication -
795 * WSAGetLastError() is called but returns zero or
796 * a small number - so we check that case and treat
797 * it just like WSAEWOULDBLOCK.)
d40a94b9 798 */
2f75bae1 799 s->writable = FALSE;
32874aea 800 return;
2f75bae1 801 } else if (nsent == 0 ||
32874aea 802 err == WSAECONNABORTED || err == WSAECONNRESET) {
803 /*
7732d38a 804 * If send() returns CONNABORTED or CONNRESET, we
805 * unfortunately can't just call plug_closing(),
806 * because it's quite likely that we're currently
807 * _in_ a call from the code we'd be calling back
808 * to, so we'd have to make half the SSH code
809 * reentrant. Instead we flag a pending error on
810 * the socket, to be dealt with (by calling
811 * plug_closing()) at some suitable future moment.
32874aea 812 */
7732d38a 813 s->pending_error = err;
814 return;
2f75bae1 815 } else {
816 fatalbox(winsock_error_string(err));
817 }
818 } else {
5471d09a 819 if (s->sending_oob) {
820 if (nsent < len) {
821 memmove(s->oobdata, s->oobdata+nsent, len-nsent);
822 s->sending_oob = len - nsent;
823 } else {
824 s->sending_oob = 0;
825 }
826 } else {
827 bufchain_consume(&s->output_data, nsent);
2f75bae1 828 }
829 }
830 }
831}
832
5471d09a 833static int sk_tcp_write(Socket sock, char *buf, int len)
32874aea 834{
7e78000d 835 Actual_Socket s = (Actual_Socket) sock;
836
2f75bae1 837 /*
838 * Add the data to the buffer list on the socket.
839 */
5471d09a 840 bufchain_add(&s->output_data, buf, len);
2f75bae1 841
842 /*
843 * Now try sending from the start of the buffer list.
844 */
845 if (s->writable)
846 try_send(s);
5471d09a 847
848 return bufchain_size(&s->output_data);
2f75bae1 849}
850
5471d09a 851static int sk_tcp_write_oob(Socket sock, char *buf, int len)
32874aea 852{
7e78000d 853 Actual_Socket s = (Actual_Socket) sock;
854
2f75bae1 855 /*
856 * Replace the buffer list on the socket with the data.
857 */
5471d09a 858 bufchain_clear(&s->output_data);
859 assert(len <= sizeof(s->oobdata));
860 memcpy(s->oobdata, buf, len);
2f75bae1 861 s->sending_oob = len;
862
863 /*
864 * Now try sending from the start of the buffer list.
865 */
866 if (s->writable)
867 try_send(s);
5471d09a 868
869 return s->sending_oob;
2f75bae1 870}
871
32874aea 872int select_result(WPARAM wParam, LPARAM lParam)
873{
f9d3f227 874 int ret, open;
2f75bae1 875 DWORD err;
b675c612 876 char buf[20480]; /* nice big buffer for plenty of speed */
7e78000d 877 Actual_Socket s;
49bad831 878 u_long atmark;
2f75bae1 879
880 /* wParam is the socket itself */
32874aea 881 s = find234(sktree, (void *) wParam, cmpforsearch);
2f75bae1 882 if (!s)
883 return 1; /* boggle */
884
885 if ((err = WSAGETSELECTERROR(lParam)) != 0) {
32874aea 886 /*
887 * An error has occurred on this socket. Pass it to the
888 * plug.
889 */
890 return plug_closing(s->plug, winsock_error_string(err), err, 0);
2f75bae1 891 }
892
7d6ee6ff 893 noise_ultralight(lParam);
894
2f75bae1 895 switch (WSAGETSELECTEVENT(lParam)) {
3ad9d396 896 case FD_CONNECT:
897 s->connected = s->writable = 1;
898 break;
2f75bae1 899 case FD_READ:
d74d141c 900 /* In the case the socket is still frozen, we don't even bother */
5471d09a 901 if (s->frozen) {
902 s->frozen_readable = 1;
d74d141c 903 break;
5471d09a 904 }
d74d141c 905
32874aea 906 /*
907 * We have received data on the socket. For an oobinline
908 * socket, this might be data _before_ an urgent pointer,
909 * in which case we send it to the back end with type==1
910 * (data prior to urgent).
911 */
912 if (s->oobinline) {
913 atmark = 1;
914 ioctlsocket(s->s, SIOCATMARK, &atmark);
915 /*
916 * Avoid checking the return value from ioctlsocket(),
917 * on the grounds that some WinSock wrappers don't
918 * support it. If it does nothing, we get atmark==1,
919 * which is equivalent to `no OOB pending', so the
920 * effect will be to non-OOB-ify any OOB data.
921 */
922 } else
923 atmark = 1;
4b1e8acc 924
2f75bae1 925 ret = recv(s->s, buf, sizeof(buf), 0);
32874aea 926 noise_ultralight(ret);
2f75bae1 927 if (ret < 0) {
928 err = WSAGetLastError();
929 if (err == WSAEWOULDBLOCK) {
930 break;
931 }
932 }
933 if (ret < 0) {
32874aea 934 return plug_closing(s->plug, winsock_error_string(err), err,
935 0);
7e78000d 936 } else if (0 == ret) {
32874aea 937 return plug_closing(s->plug, NULL, 0, 0);
2f75bae1 938 } else {
32874aea 939 return plug_receive(s->plug, atmark ? 0 : 1, buf, ret);
2f75bae1 940 }
941 break;
942 case FD_OOB:
32874aea 943 /*
944 * This will only happen on a non-oobinline socket. It
945 * indicates that we can immediately perform an OOB read
946 * and get back OOB data, which we will send to the back
947 * end with type==2 (urgent data).
948 */
949 ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
950 noise_ultralight(ret);
951 if (ret <= 0) {
952 fatalbox(ret == 0 ? "Internal networking trouble" :
953 winsock_error_string(WSAGetLastError()));
954 } else {
955 return plug_receive(s->plug, 2, buf, ret);
956 }
957 break;
2f75bae1 958 case FD_WRITE:
5471d09a 959 {
960 int bufsize_before, bufsize_after;
961 s->writable = 1;
962 bufsize_before = s->sending_oob + bufchain_size(&s->output_data);
963 try_send(s);
964 bufsize_after = s->sending_oob + bufchain_size(&s->output_data);
965 if (bufsize_after < bufsize_before)
966 plug_sent(s->plug, bufsize_after);
967 }
2f75bae1 968 break;
969 case FD_CLOSE:
f9d3f227 970 /* Signal a close on the socket. First read any outstanding data. */
32874aea 971 open = 1;
972 do {
973 ret = recv(s->s, buf, sizeof(buf), 0);
974 if (ret < 0) {
975 err = WSAGetLastError();
976 if (err == WSAEWOULDBLOCK)
977 break;
978 return plug_closing(s->plug, winsock_error_string(err),
979 err, 0);
980 } else {
981 if (ret)
982 open &= plug_receive(s->plug, 0, buf, ret);
983 else
984 open &= plug_closing(s->plug, NULL, 0, 0);
7e78000d 985 }
f9d3f227 986 } while (ret > 0);
32874aea 987 return open;
d74d141c 988 case FD_ACCEPT:
989 {
bc4802a1 990 struct sockaddr_in isa;
991 int addrlen = sizeof(struct sockaddr_in);
bcce45ed 992 SOCKET t; /* socket of connection */
993
bc4802a1 994 memset(&isa, 0, sizeof(struct sockaddr_in));
bcce45ed 995 err = 0;
0e5e7f46 996 t = accept(s->s,(struct sockaddr *)&isa,&addrlen);
bcce45ed 997 if (t == INVALID_SOCKET)
998 {
999 err = WSAGetLastError();
1000 if (err == WSATRY_AGAIN)
1001 break;
1002 }
1003
bc4802a1 1004 if (s->localhost_only &&
1005 ntohl(isa.sin_addr.s_addr) != INADDR_LOOPBACK) {
1006 closesocket(t); /* dodgy WinSock let nonlocal through */
1007 } else if (plug_accepting(s->plug, (void*)t)) {
bcce45ed 1008 closesocket(t); /* denied or error */
1009 }
d74d141c 1010 }
2f75bae1 1011 }
1012
1013 return 1;
1014}
1015
1016/*
7732d38a 1017 * Deal with socket errors detected in try_send().
1018 */
1019void net_pending_errors(void)
1020{
1021 int i;
1022 Actual_Socket s;
1023
1024 /*
1025 * This might be a fiddly business, because it's just possible
1026 * that handling a pending error on one socket might cause
1027 * others to be closed. (I can't think of any reason this might
1028 * happen in current SSH implementation, but to maintain
1029 * generality of this network layer I'll assume the worst.)
1030 *
1031 * So what we'll do is search the socket list for _one_ socket
1032 * with a pending error, and then handle it, and then search
1033 * the list again _from the beginning_. Repeat until we make a
1034 * pass with no socket errors present. That way we are
1035 * protected against the socket list changing under our feet.
1036 */
1037
1038 do {
1039 for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
1040 if (s->pending_error) {
1041 /*
1042 * An error has occurred on this socket. Pass it to the
1043 * plug.
1044 */
1045 plug_closing(s->plug,
1046 winsock_error_string(s->pending_error),
1047 s->pending_error, 0);
1048 break;
1049 }
1050 }
1051 } while (s);
1052}
1053
1054/*
2f75bae1 1055 * Each socket abstraction contains a `void *' private field in
1056 * which the client can keep state.
1057 */
8eebd221 1058static void sk_tcp_set_private_ptr(Socket sock, void *ptr)
32874aea 1059{
7e78000d 1060 Actual_Socket s = (Actual_Socket) sock;
2f75bae1 1061 s->private_ptr = ptr;
1062}
32874aea 1063
8eebd221 1064static void *sk_tcp_get_private_ptr(Socket sock)
32874aea 1065{
7e78000d 1066 Actual_Socket s = (Actual_Socket) sock;
2f75bae1 1067 return s->private_ptr;
1068}
1069
1070/*
1071 * Special error values are returned from sk_namelookup and sk_new
1072 * if there's a problem. These functions extract an error message,
1073 * or return NULL if there's no problem.
1074 */
32874aea 1075char *sk_addr_error(SockAddr addr)
1076{
2f75bae1 1077 return addr->error;
1078}
32874aea 1079static char *sk_tcp_socket_error(Socket sock)
1080{
7e78000d 1081 Actual_Socket s = (Actual_Socket) sock;
2f75bae1 1082 return s->error;
1083}
1084
8eebd221 1085static void sk_tcp_set_frozen(Socket sock, int is_frozen)
d74d141c 1086{
1087 Actual_Socket s = (Actual_Socket) sock;
5471d09a 1088 if (s->frozen == is_frozen)
1089 return;
d74d141c 1090 s->frozen = is_frozen;
5471d09a 1091 if (!is_frozen && s->frozen_readable) {
d74d141c 1092 char c;
1093 recv(s->s, &c, 1, MSG_PEEK);
1094 }
5471d09a 1095 s->frozen_readable = 0;
d74d141c 1096}
1097
2f75bae1 1098/*
1099 * For Plink: enumerate all sockets currently active.
1100 */
32874aea 1101SOCKET first_socket(int *state)
1102{
d2371c81 1103 Actual_Socket s;
1104 *state = 0;
1105 s = index234(sktree, (*state)++);
2f75bae1 1106 return s ? s->s : INVALID_SOCKET;
1107}
32874aea 1108
1109SOCKET next_socket(int *state)
1110{
d2371c81 1111 Actual_Socket s = index234(sktree, (*state)++);
2f75bae1 1112 return s ? s->s : INVALID_SOCKET;
1113}