winnet.c

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