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_newlistenner(int port, Plug plug)
 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 /*a6.sin6_addr      = in6addr_any; *//* == 0 */
 631             a6.sin6_port = htons(port);
 632         } else
 633 #endif
 634         {
 635             a.sin_family = AF_INET;
 636             a.sin_addr.s_addr = htonl(INADDR_ANY);
 637             a.sin_port = htons((short)port);
 638         }
 639 #ifdef IPV6
 640         retcode = bind(s, (addr->family == AF_INET6 ?
 641                            (struct sockaddr *) &a6 :
 642                            (struct sockaddr *) &a),
 643                        (addr->family ==
 644                         AF_INET6 ? sizeof(a6) : sizeof(a)));
 645 #else
 646         retcode = bind(s, (struct sockaddr *) &a, sizeof(a));
 647 #endif
 648         if (retcode != SOCKET_ERROR) {
 649             err = 0;
 650         } else {
 651             err = WSAGetLastError();
 652         }
 653
 654     if (err) {
 655         ret->error = winsock_error_string(err);
 656         return (Socket) ret;
 657     }
 658
 659
 660     if (listen(s, SOMAXCONN) == SOCKET_ERROR) {
 661         closesocket(s);
 662         ret->error = winsock_error_string(err);
 663         return (Socket) ret;
 664     }
 665
 666     /* Set up a select mechanism. This could be an AsyncSelect on a
 667      * window, or an EventSelect on an event object. */
 668     errstr = do_select(s, 1);
 669     if (errstr) {
 670         ret->error = errstr;
 671         return (Socket) ret;
 672     }
 673
 674     add234(sktree, ret);
 675
 676     return (Socket) ret;
 677 }
 678
 679 static void sk_tcp_close(Socket sock)
 680 {
 681     extern char *do_select(SOCKET skt, int startup);
 682     Actual_Socket s = (Actual_Socket) sock;
 683
 684     del234(sktree, s);
 685     do_select(s->s, 0);
 686     closesocket(s->s);
 687     sfree(s);
 688 }
 689
 690 /*
 691  * The function which tries to send on a socket once it's deemed
 692  * writable.
 693  */
 694 void try_send(Actual_Socket s)
 695 {
 696     while (s->sending_oob || bufchain_size(&s->output_data) > 0) {
 697         int nsent;
 698         DWORD err;
 699         void *data;
 700         int len, urgentflag;
 701
 702         if (s->sending_oob) {
 703             urgentflag = MSG_OOB;
 704             len = s->sending_oob;
 705             data = &s->oobdata;
 706         } else {
 707             urgentflag = 0;
 708             bufchain_prefix(&s->output_data, &data, &len);
 709         }
 710
 711         nsent = send(s->s, data, len, urgentflag);
 712         noise_ultralight(nsent);
 713         if (nsent <= 0) {
 714             err = (nsent < 0 ? WSAGetLastError() : 0);
 715             if ((err == 0 && nsent < 0) || err == WSAEWOULDBLOCK) {
 716                 /*
 717                  * Perfectly normal: we've sent all we can for the moment.
 718                  *
 719                  * (Apparently some WinSocks can return <0 but
 720                  * leave no error indication - WSAGetLastError() is
 721                  * called but returns zero - so we check that case
 722                  * and treat it just like WSAEWOULDBLOCK.)
 723                  */
 724                 s->writable = FALSE;
 725                 return;
 726             } else if (nsent == 0 ||
 727                        err == WSAECONNABORTED || err == WSAECONNRESET) {
 728                 /*
 729                  * FIXME. This will have to be done better when we
 730                  * start managing multiple sockets (e.g. SSH port
 731                  * forwarding), because if we get CONNRESET while
 732                  * trying to write a particular forwarded socket
 733                  * then it isn't necessarily the end of the world.
 734                  * Ideally I'd like to pass the error code back to
 735                  * somewhere the next select_result() will see it,
 736                  * but that might be hard. Perhaps I should pass it
 737                  * back to be queued in the Windows front end bit.
 738                  */
 739                 fatalbox(winsock_error_string(err));
 740             } else {
 741                 fatalbox(winsock_error_string(err));
 742             }
 743         } else {
 744             if (s->sending_oob) {
 745                 if (nsent < len) {
 746                     memmove(s->oobdata, s->oobdata+nsent, len-nsent);
 747                     s->sending_oob = len - nsent;
 748                 } else {
 749                     s->sending_oob = 0;
 750                 }
 751             } else {
 752                 bufchain_consume(&s->output_data, nsent);
 753             }
 754         }
 755     }
 756 }
 757
 758 static int sk_tcp_write(Socket sock, char *buf, int len)
 759 {
 760     Actual_Socket s = (Actual_Socket) sock;
 761
 762     /*
 763      * Add the data to the buffer list on the socket.
 764      */
 765     bufchain_add(&s->output_data, buf, len);
 766
 767     /*
 768      * Now try sending from the start of the buffer list.
 769      */
 770     if (s->writable)
 771         try_send(s);
 772
 773     return bufchain_size(&s->output_data);
 774 }
 775
 776 static int sk_tcp_write_oob(Socket sock, char *buf, int len)
 777 {
 778     Actual_Socket s = (Actual_Socket) sock;
 779
 780     /*
 781      * Replace the buffer list on the socket with the data.
 782      */
 783     bufchain_clear(&s->output_data);
 784     assert(len <= sizeof(s->oobdata));
 785     memcpy(s->oobdata, buf, len);
 786     s->sending_oob = len;
 787
 788     /*
 789      * Now try sending from the start of the buffer list.
 790      */
 791     if (s->writable)
 792         try_send(s);
 793
 794     return s->sending_oob;
 795 }
 796
 797 int select_result(WPARAM wParam, LPARAM lParam)
 798 {
 799     int ret, open;
 800     DWORD err;
 801     char buf[20480];                   /* nice big buffer for plenty of speed */
 802     Actual_Socket s;
 803     u_long atmark;
 804
 805     /* wParam is the socket itself */
 806     s = find234(sktree, (void *) wParam, cmpforsearch);
 807     if (!s)
 808         return 1;                      /* boggle */
 809
 810     if ((err = WSAGETSELECTERROR(lParam)) != 0) {
 811         /*
 812          * An error has occurred on this socket. Pass it to the
 813          * plug.
 814          */
 815         return plug_closing(s->plug, winsock_error_string(err), err, 0);
 816     }
 817
 818     noise_ultralight(lParam);
 819
 820     switch (WSAGETSELECTEVENT(lParam)) {
 821       case FD_READ:
 822         /* In the case the socket is still frozen, we don't even bother */
 823         if (s->frozen) {
 824             s->frozen_readable = 1;
 825             break;
 826         }
 827
 828         /*
 829          * We have received data on the socket. For an oobinline
 830          * socket, this might be data _before_ an urgent pointer,
 831          * in which case we send it to the back end with type==1
 832          * (data prior to urgent).
 833          */
 834         if (s->oobinline) {
 835             atmark = 1;
 836             ioctlsocket(s->s, SIOCATMARK, &atmark);
 837             /*
 838              * Avoid checking the return value from ioctlsocket(),
 839              * on the grounds that some WinSock wrappers don't
 840              * support it. If it does nothing, we get atmark==1,
 841              * which is equivalent to `no OOB pending', so the
 842              * effect will be to non-OOB-ify any OOB data.
 843              */
 844         } else
 845             atmark = 1;
 846
 847         ret = recv(s->s, buf, sizeof(buf), 0);
 848         noise_ultralight(ret);
 849         if (ret < 0) {
 850             err = WSAGetLastError();
 851             if (err == WSAEWOULDBLOCK) {
 852                 break;
 853             }
 854         }
 855         if (ret < 0) {
 856             return plug_closing(s->plug, winsock_error_string(err), err,
 857                                 0);
 858         } else if (0 == ret) {
 859             return plug_closing(s->plug, NULL, 0, 0);
 860         } else {
 861             return plug_receive(s->plug, atmark ? 0 : 1, buf, ret);
 862         }
 863         break;
 864       case FD_OOB:
 865         /*
 866          * This will only happen on a non-oobinline socket. It
 867          * indicates that we can immediately perform an OOB read
 868          * and get back OOB data, which we will send to the back
 869          * end with type==2 (urgent data).
 870          */
 871         ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
 872         noise_ultralight(ret);
 873         if (ret <= 0) {
 874             fatalbox(ret == 0 ? "Internal networking trouble" :
 875                      winsock_error_string(WSAGetLastError()));
 876         } else {
 877             return plug_receive(s->plug, 2, buf, ret);
 878         }
 879         break;
 880       case FD_WRITE:
 881         {
 882             int bufsize_before, bufsize_after;
 883             s->writable = 1;
 884             bufsize_before = s->sending_oob + bufchain_size(&s->output_data);
 885             try_send(s);
 886             bufsize_after = s->sending_oob + bufchain_size(&s->output_data);
 887             if (bufsize_after < bufsize_before)
 888                 plug_sent(s->plug, bufsize_after);
 889         }
 890         break;
 891       case FD_CLOSE:
 892         /* Signal a close on the socket. First read any outstanding data. */
 893         open = 1;
 894         do {
 895             ret = recv(s->s, buf, sizeof(buf), 0);
 896             if (ret < 0) {
 897                 err = WSAGetLastError();
 898                 if (err == WSAEWOULDBLOCK)
 899                     break;
 900                 return plug_closing(s->plug, winsock_error_string(err),
 901                                     err, 0);
 902             } else {
 903                 if (ret)
 904                     open &= plug_receive(s->plug, 0, buf, ret);
 905                 else
 906                     open &= plug_closing(s->plug, NULL, 0, 0);
 907             }
 908         } while (ret > 0);
 909         return open;
 910        case FD_ACCEPT:
 911         {
 912                 struct sockaddr isa;
 913                 int addrlen = sizeof(struct sockaddr);
 914                 SOCKET t;  /* socket of connection */
 915
 916                 memset(&isa, 0, sizeof(struct sockaddr));
 917                 err = 0;
 918                 t = accept(s->s,&isa,&addrlen);
 919                 if (t == INVALID_SOCKET)
 920                                 {
 921                                         err = WSAGetLastError();
 922                                         if (err == WSATRY_AGAIN)
 923                                                 break;
 924                                 }
 925
 926                 if (plug_accepting(s->plug, &isa, (void*)t)) {
 927                         closesocket(t); // denied or error
 928                 }
 929         }
 930     }
 931
 932     return 1;
 933 }
 934
 935 /*
 936  * Each socket abstraction contains a `void *' private field in
 937  * which the client can keep state.
 938  */
 939 void sk_set_private_ptr(Socket sock, void *ptr)
 940 {
 941     Actual_Socket s = (Actual_Socket) sock;
 942     s->private_ptr = ptr;
 943 }
 944
 945 void *sk_get_private_ptr(Socket sock)
 946 {
 947     Actual_Socket s = (Actual_Socket) sock;
 948     return s->private_ptr;
 949 }
 950
 951 /*
 952  * Special error values are returned from sk_namelookup and sk_new
 953  * if there's a problem. These functions extract an error message,
 954  * or return NULL if there's no problem.
 955  */
 956 char *sk_addr_error(SockAddr addr)
 957 {
 958     return addr->error;
 959 }
 960 static char *sk_tcp_socket_error(Socket sock)
 961 {
 962     Actual_Socket s = (Actual_Socket) sock;
 963     return s->error;
 964 }
 965
 966 void sk_set_frozen(Socket sock, int is_frozen)
 967 {
 968     Actual_Socket s = (Actual_Socket) sock;
 969     if (s->frozen == is_frozen)
 970         return;
 971     s->frozen = is_frozen;
 972     if (!is_frozen && s->frozen_readable) {
 973         char c;
 974         recv(s->s, &c, 1, MSG_PEEK);
 975     }
 976     s->frozen_readable = 0;
 977 }
 978
 979 /*
 980  * For Plink: enumerate all sockets currently active.
 981  */
 982 SOCKET first_socket(int *state)
 983 {
 984     Actual_Socket s;
 985     *state = 0;
 986     s = index234(sktree, (*state)++);
 987     return s ? s->s : INVALID_SOCKET;
 988 }
 989
 990 SOCKET next_socket(int *state)
 991 {
 992     Actual_Socket s = index234(sktree, (*state)++);
 993     return s ? s->s : INVALID_SOCKET;
 994 }