windows/winhandl.c

   1 /*
   2  * winhandl.c: Module to give Windows front ends the general
   3  * ability to deal with consoles, pipes, serial ports, or any other
   4  * type of data stream accessed through a Windows API HANDLE rather
   5  * than a WinSock SOCKET.
   6  *
   7  * We do this by spawning a subthread to continuously try to read
   8  * from the handle. Every time a read successfully returns some
   9  * data, the subthread sets an event object which is picked up by
  10  * the main thread, and the main thread then sets an event in
  11  * return to instruct the subthread to resume reading.
  12  *
  13  * Output works precisely the other way round, in a second
  14  * subthread. The output subthread should not be attempting to
  15  * write all the time, because it hasn't always got data _to_
  16  * write; so the output thread waits for an event object notifying
  17  * it to _attempt_ a write, and then it sets an event in return
  18  * when one completes.
  19  *
  20  * (It's terribly annoying having to spawn a subthread for each
  21  * direction of each handle. Technically it isn't necessary for
  22  * serial ports, since we could use overlapped I/O within the main
  23  * thread and wait directly on the event objects in the OVERLAPPED
  24  * structures. However, we can't use this trick for some types of
  25  * file handle at all - for some reason Windows restricts use of
  26  * OVERLAPPED to files which were opened with the overlapped flag -
  27  * and so we must use threads for those. This being the case, it's
  28  * simplest just to use threads for everything rather than trying
  29  * to keep track of multiple completely separate mechanisms.)
  30  */
  31
  32 #include <assert.h>
  33
  34 #include "putty.h"
  35
  36 /* ----------------------------------------------------------------------
  37  * Generic definitions.
  38  */
  39
  40 /*
  41  * Maximum amount of backlog we will allow to build up on an input
  42  * handle before we stop reading from it.
  43  */
  44 #define MAX_BACKLOG 32768
  45
  46 struct handle_generic {
  47     /*
  48      * Initial fields common to both handle_input and handle_output
  49      * structures.
  50      *
  51      * The three HANDLEs are set up at initialisation time and are
  52      * thereafter read-only to both main thread and subthread.
  53      * `moribund' is only used by the main thread; `done' is
  54      * written by the main thread before signalling to the
  55      * subthread. `defunct' and `busy' are used only by the main
  56      * thread.
  57      */
  58     HANDLE h;                          /* the handle itself */
  59     HANDLE ev_to_main;                 /* event used to signal main thread */
  60     HANDLE ev_from_main;               /* event used to signal back to us */
  61     int moribund;                      /* are we going to kill this soon? */
  62     int done;                          /* request subthread to terminate */
  63     int defunct;                       /* has the subthread already gone? */
  64     int busy;                          /* operation currently in progress? */
  65     void *privdata;                    /* for client to remember who they are */
  66 };
  67
  68 /* ----------------------------------------------------------------------
  69  * Input threads.
  70  */
  71
  72 /*
  73  * Data required by an input thread.
  74  */
  75 struct handle_input {
  76     /*
  77      * Copy of the handle_generic structure.
  78      */
  79     HANDLE h;                          /* the handle itself */
  80     HANDLE ev_to_main;                 /* event used to signal main thread */
  81     HANDLE ev_from_main;               /* event used to signal back to us */
  82     int moribund;                      /* are we going to kill this soon? */
  83     int done;                          /* request subthread to terminate */
  84     int defunct;                       /* has the subthread already gone? */
  85     int busy;                          /* operation currently in progress? */
  86     void *privdata;                    /* for client to remember who they are */
  87
  88     /*
  89      * Data set at initialisation and then read-only.
  90      */
  91     int flags;
  92
  93     /*
  94      * Data set by the input thread before signalling ev_to_main,
  95      * and read by the main thread after receiving that signal.
  96      */
  97     char buffer[4096];                 /* the data read from the handle */
  98     DWORD len;                         /* how much data that was */
  99     int readerr;                       /* lets us know about read errors */
 100
 101     /*
 102      * Callback function called by this module when data arrives on
 103      * an input handle.
 104      */
 105     handle_inputfn_t gotdata;
 106 };
 107
 108 /*
 109  * The actual thread procedure for an input thread.
 110  */
 111 static DWORD WINAPI handle_input_threadfunc(void *param)
 112 {
 113     struct handle_input *ctx = (struct handle_input *) param;
 114     OVERLAPPED ovl, *povl;
 115     HANDLE oev;
 116     int readret, readlen;
 117
 118     if (ctx->flags & HANDLE_FLAG_OVERLAPPED) {
 119         povl = &ovl;
 120         oev = CreateEvent(NULL, TRUE, FALSE, NULL);
 121     } else {
 122         povl = NULL;
 123     }
 124
 125     if (ctx->flags & HANDLE_FLAG_UNITBUFFER)
 126         readlen = 1;
 127     else
 128         readlen = sizeof(ctx->buffer);
 129
 130     while (1) {
 131         if (povl) {
 132             memset(povl, 0, sizeof(OVERLAPPED));
 133             povl->hEvent = oev;
 134         }
 135         readret = ReadFile(ctx->h, ctx->buffer,readlen, &ctx->len, povl);
 136         if (!readret)
 137             ctx->readerr = GetLastError();
 138         else
 139             ctx->readerr = 0;
 140         if (povl && !readret && ctx->readerr == ERROR_IO_PENDING) {
 141             WaitForSingleObject(povl->hEvent, INFINITE);
 142             readret = GetOverlappedResult(ctx->h, povl, &ctx->len, FALSE);
 143             if (!readret)
 144                 ctx->readerr = GetLastError();
 145             else
 146                 ctx->readerr = 0;
 147         }
 148
 149         if (!readret) {
 150             /*
 151              * Windows apparently sends ERROR_BROKEN_PIPE when a
 152              * pipe we're reading from is closed normally from the
 153              * writing end. This is ludicrous; if that situation
 154              * isn't a natural EOF, _nothing_ is. So if we get that
 155              * particular error, we pretend it's EOF.
 156              */
 157             if (ctx->readerr == ERROR_BROKEN_PIPE)
 158                 ctx->readerr = 0;
 159             ctx->len = 0;
 160         }
 161
 162         if (readret && ctx->len == 0 &&
 163             (ctx->flags & HANDLE_FLAG_IGNOREEOF))
 164             continue;
 165
 166         SetEvent(ctx->ev_to_main);
 167
 168         if (!ctx->len)
 169             break;
 170
 171         WaitForSingleObject(ctx->ev_from_main, INFINITE);
 172         if (ctx->done)
 173             break;                     /* main thread told us to shut down */
 174     }
 175
 176     if (povl)
 177         CloseHandle(oev);
 178
 179     return 0;
 180 }
 181
 182 /*
 183  * This is called after a succcessful read, or from the
 184  * `unthrottle' function. It decides whether or not to begin a new
 185  * read operation.
 186  */
 187 static void handle_throttle(struct handle_input *ctx, int backlog)
 188 {
 189     if (ctx->defunct)
 190         return;
 191
 192     /*
 193      * If there's a read operation already in progress, do nothing:
 194      * when that completes, we'll come back here and be in a
 195      * position to make a better decision.
 196      */
 197     if (ctx->busy)
 198         return;
 199
 200     /*
 201      * Otherwise, we must decide whether to start a new read based
 202      * on the size of the backlog.
 203      */
 204     if (backlog < MAX_BACKLOG) {
 205         SetEvent(ctx->ev_from_main);
 206         ctx->busy = TRUE;
 207     }
 208 }
 209
 210 /* ----------------------------------------------------------------------
 211  * Output threads.
 212  */
 213
 214 /*
 215  * Data required by an output thread.
 216  */
 217 struct handle_output {
 218     /*
 219      * Copy of the handle_generic structure.
 220      */
 221     HANDLE h;                          /* the handle itself */
 222     HANDLE ev_to_main;                 /* event used to signal main thread */
 223     HANDLE ev_from_main;               /* event used to signal back to us */
 224     int moribund;                      /* are we going to kill this soon? */
 225     int done;                          /* request subthread to terminate */
 226     int defunct;                       /* has the subthread already gone? */
 227     int busy;                          /* operation currently in progress? */
 228     void *privdata;                    /* for client to remember who they are */
 229
 230     /*
 231      * Data set at initialisation and then read-only.
 232      */
 233     int flags;
 234
 235     /*
 236      * Data set by the main thread before signalling ev_from_main,
 237      * and read by the input thread after receiving that signal.
 238      */
 239     char *buffer;                      /* the data to write */
 240     DWORD len;                         /* how much data there is */
 241
 242     /*
 243      * Data set by the input thread before signalling ev_to_main,
 244      * and read by the main thread after receiving that signal.
 245      */
 246     DWORD lenwritten;                  /* how much data we actually wrote */
 247     int writeerr;                      /* return value from WriteFile */
 248
 249     /*
 250      * Data only ever read or written by the main thread.
 251      */
 252     bufchain queued_data;              /* data still waiting to be written */
 253     enum { EOF_NO, EOF_PENDING, EOF_SENT } outgoingeof;
 254
 255     /*
 256      * Callback function called when the backlog in the bufchain
 257      * drops.
 258      */
 259     handle_outputfn_t sentdata;
 260 };
 261
 262 static DWORD WINAPI handle_output_threadfunc(void *param)
 263 {
 264     struct handle_output *ctx = (struct handle_output *) param;
 265     OVERLAPPED ovl, *povl;
 266     HANDLE oev;
 267     int writeret;
 268
 269     if (ctx->flags & HANDLE_FLAG_OVERLAPPED) {
 270         povl = &ovl;
 271         oev = CreateEvent(NULL, TRUE, FALSE, NULL);
 272     } else {
 273         povl = NULL;
 274     }
 275
 276     while (1) {
 277         WaitForSingleObject(ctx->ev_from_main, INFINITE);
 278         if (ctx->done) {
 279             SetEvent(ctx->ev_to_main);
 280             break;
 281         }
 282         if (povl) {
 283             memset(povl, 0, sizeof(OVERLAPPED));
 284             povl->hEvent = oev;
 285         }
 286
 287         writeret = WriteFile(ctx->h, ctx->buffer, ctx->len,
 288                              &ctx->lenwritten, povl);
 289         if (!writeret)
 290             ctx->writeerr = GetLastError();
 291         else
 292             ctx->writeerr = 0;
 293         if (povl && !writeret && GetLastError() == ERROR_IO_PENDING) {
 294             writeret = GetOverlappedResult(ctx->h, povl,
 295                                            &ctx->lenwritten, TRUE);
 296             if (!writeret)
 297                 ctx->writeerr = GetLastError();
 298             else
 299                 ctx->writeerr = 0;
 300         }
 301
 302         SetEvent(ctx->ev_to_main);
 303         if (!writeret)
 304             break;
 305     }
 306
 307     if (povl)
 308         CloseHandle(oev);
 309
 310     return 0;
 311 }
 312
 313 static void handle_try_output(struct handle_output *ctx)
 314 {
 315     void *senddata;
 316     int sendlen;
 317
 318     if (!ctx->busy && bufchain_size(&ctx->queued_data)) {
 319         bufchain_prefix(&ctx->queued_data, &senddata, &sendlen);
 320         ctx->buffer = senddata;
 321         ctx->len = sendlen;
 322         SetEvent(ctx->ev_from_main);
 323         ctx->busy = TRUE;
 324     } else if (!ctx->busy && bufchain_size(&ctx->queued_data) == 0 &&
 325                ctx->outgoingeof == EOF_PENDING) {
 326         CloseHandle(ctx->h);
 327         ctx->h = INVALID_HANDLE_VALUE;
 328         ctx->outgoingeof = EOF_SENT;
 329     }
 330 }
 331
 332 /* ----------------------------------------------------------------------
 333  * Unified code handling both input and output threads.
 334  */
 335
 336 struct handle {
 337     int output;
 338     union {
 339         struct handle_generic g;
 340         struct handle_input i;
 341         struct handle_output o;
 342     } u;
 343 };
 344
 345 static tree234 *handles_by_evtomain;
 346
 347 static int handle_cmp_evtomain(void *av, void *bv)
 348 {
 349     struct handle *a = (struct handle *)av;
 350     struct handle *b = (struct handle *)bv;
 351
 352     if ((unsigned)a->u.g.ev_to_main < (unsigned)b->u.g.ev_to_main)
 353         return -1;
 354     else if ((unsigned)a->u.g.ev_to_main > (unsigned)b->u.g.ev_to_main)
 355         return +1;
 356     else
 357         return 0;
 358 }
 359
 360 static int handle_find_evtomain(void *av, void *bv)
 361 {
 362     HANDLE *a = (HANDLE *)av;
 363     struct handle *b = (struct handle *)bv;
 364
 365     if ((unsigned)*a < (unsigned)b->u.g.ev_to_main)
 366         return -1;
 367     else if ((unsigned)*a > (unsigned)b->u.g.ev_to_main)
 368         return +1;
 369     else
 370         return 0;
 371 }
 372
 373 struct handle *handle_input_new(HANDLE handle, handle_inputfn_t gotdata,
 374                                 void *privdata, int flags)
 375 {
 376     struct handle *h = snew(struct handle);
 377     DWORD in_threadid; /* required for Win9x */
 378
 379     h->output = FALSE;
 380     h->u.i.h = handle;
 381     h->u.i.ev_to_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 382     h->u.i.ev_from_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 383     h->u.i.gotdata = gotdata;
 384     h->u.i.defunct = FALSE;
 385     h->u.i.moribund = FALSE;
 386     h->u.i.done = FALSE;
 387     h->u.i.privdata = privdata;
 388     h->u.i.flags = flags;
 389
 390     if (!handles_by_evtomain)
 391         handles_by_evtomain = newtree234(handle_cmp_evtomain);
 392     add234(handles_by_evtomain, h);
 393
 394     CreateThread(NULL, 0, handle_input_threadfunc,
 395                  &h->u.i, 0, &in_threadid);
 396     h->u.i.busy = TRUE;
 397
 398     return h;
 399 }
 400
 401 struct handle *handle_output_new(HANDLE handle, handle_outputfn_t sentdata,
 402                                  void *privdata, int flags)
 403 {
 404     struct handle *h = snew(struct handle);
 405     DWORD out_threadid; /* required for Win9x */
 406
 407     h->output = TRUE;
 408     h->u.o.h = handle;
 409     h->u.o.ev_to_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 410     h->u.o.ev_from_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 411     h->u.o.busy = FALSE;
 412     h->u.o.defunct = FALSE;
 413     h->u.o.moribund = FALSE;
 414     h->u.o.done = FALSE;
 415     h->u.o.privdata = privdata;
 416     bufchain_init(&h->u.o.queued_data);
 417     h->u.o.outgoingeof = EOF_NO;
 418     h->u.o.sentdata = sentdata;
 419     h->u.o.flags = flags;
 420
 421     if (!handles_by_evtomain)
 422         handles_by_evtomain = newtree234(handle_cmp_evtomain);
 423     add234(handles_by_evtomain, h);
 424
 425     CreateThread(NULL, 0, handle_output_threadfunc,
 426                  &h->u.o, 0, &out_threadid);
 427
 428     return h;
 429 }
 430
 431 int handle_write(struct handle *h, const void *data, int len)
 432 {
 433     assert(h->output);
 434     assert(h->u.o.outgoingeof == EOF_NO);
 435     bufchain_add(&h->u.o.queued_data, data, len);
 436     handle_try_output(&h->u.o);
 437     return bufchain_size(&h->u.o.queued_data);
 438 }
 439
 440 void handle_write_eof(struct handle *h)
 441 {
 442     /*
 443      * This function is called when we want to proactively send an
 444      * end-of-file notification on the handle. We can only do this by
 445      * actually closing the handle - so never call this on a
 446      * bidirectional handle if we're still interested in its incoming
 447      * direction!
 448      */
 449     assert(h->output);
 450     if (!h->u.o.outgoingeof == EOF_NO) {
 451         h->u.o.outgoingeof = EOF_PENDING;
 452         handle_try_output(&h->u.o);
 453     }
 454 }
 455
 456 HANDLE *handle_get_events(int *nevents)
 457 {
 458     HANDLE *ret;
 459     struct handle *h;
 460     int i, n, size;
 461
 462     /*
 463      * Go through our tree counting the handle objects currently
 464      * engaged in useful activity.
 465      */
 466     ret = NULL;
 467     n = size = 0;
 468     if (handles_by_evtomain) {
 469         for (i = 0; (h = index234(handles_by_evtomain, i)) != NULL; i++) {
 470             if (h->u.g.busy) {
 471                 if (n >= size) {
 472                     size += 32;
 473                     ret = sresize(ret, size, HANDLE);
 474                 }
 475                 ret[n++] = h->u.g.ev_to_main;
 476             }
 477         }
 478     }
 479
 480     *nevents = n;
 481     return ret;
 482 }
 483
 484 static void handle_destroy(struct handle *h)
 485 {
 486     if (h->output)
 487         bufchain_clear(&h->u.o.queued_data);
 488     CloseHandle(h->u.g.ev_from_main);
 489     CloseHandle(h->u.g.ev_to_main);
 490     del234(handles_by_evtomain, h);
 491     sfree(h);
 492 }
 493
 494 void handle_free(struct handle *h)
 495 {
 496     /*
 497      * If the handle is currently busy, we cannot immediately free
 498      * it. Instead we must wait until it's finished its current
 499      * operation, because otherwise the subthread will write to
 500      * invalid memory after we free its context from under it.
 501      */
 502     assert(h && !h->u.g.moribund);
 503     if (h->u.g.busy) {
 504         /*
 505          * Just set the moribund flag, which will be noticed next
 506          * time an operation completes.
 507          */
 508         h->u.g.moribund = TRUE;
 509     } else if (h->u.g.defunct) {
 510         /*
 511          * There isn't even a subthread; we can go straight to
 512          * handle_destroy.
 513          */
 514         handle_destroy(h);
 515     } else {
 516         /*
 517          * The subthread is alive but not busy, so we now signal it
 518          * to die. Set the moribund flag to indicate that it will
 519          * want destroying after that.
 520          */
 521         h->u.g.moribund = TRUE;
 522         h->u.g.done = TRUE;
 523         h->u.g.busy = TRUE;
 524         SetEvent(h->u.g.ev_from_main);
 525     }
 526 }
 527
 528 void handle_got_event(HANDLE event)
 529 {
 530     struct handle *h;
 531
 532     assert(handles_by_evtomain);
 533     h = find234(handles_by_evtomain, &event, handle_find_evtomain);
 534     if (!h) {
 535         /*
 536          * This isn't an error condition. If two or more event
 537          * objects were signalled during the same select operation,
 538          * and processing of the first caused the second handle to
 539          * be closed, then it will sometimes happen that we receive
 540          * an event notification here for a handle which is already
 541          * deceased. In that situation we simply do nothing.
 542          */
 543         return;
 544     }
 545
 546     if (h->u.g.moribund) {
 547         /*
 548          * A moribund handle is already treated as dead from the
 549          * external user's point of view, so do nothing with the
 550          * actual event. Just signal the thread to die if
 551          * necessary, or destroy the handle if not.
 552          */
 553         if (h->u.g.done) {
 554             handle_destroy(h);
 555         } else {
 556             h->u.g.done = TRUE;
 557             h->u.g.busy = TRUE;
 558             SetEvent(h->u.g.ev_from_main);
 559         }
 560         return;
 561     }
 562
 563     if (!h->output) {
 564         int backlog;
 565
 566         h->u.i.busy = FALSE;
 567
 568         /*
 569          * A signal on an input handle means data has arrived.
 570          */
 571         if (h->u.i.len == 0) {
 572             /*
 573              * EOF, or (nearly equivalently) read error.
 574              */
 575             h->u.i.gotdata(h, NULL, -h->u.i.readerr);
 576             h->u.i.defunct = TRUE;
 577         } else {
 578             backlog = h->u.i.gotdata(h, h->u.i.buffer, h->u.i.len);
 579             handle_throttle(&h->u.i, backlog);
 580         }
 581     } else {
 582         h->u.o.busy = FALSE;
 583
 584         /*
 585          * A signal on an output handle means we have completed a
 586          * write. Call the callback to indicate that the output
 587          * buffer size has decreased, or to indicate an error.
 588          */
 589         if (h->u.o.writeerr) {
 590             /*
 591              * Write error. Send a negative value to the callback,
 592              * and mark the thread as defunct (because the output
 593              * thread is terminating by now).
 594              */
 595             h->u.o.sentdata(h, -h->u.o.writeerr);
 596             h->u.o.defunct = TRUE;
 597         } else {
 598             bufchain_consume(&h->u.o.queued_data, h->u.o.lenwritten);
 599             h->u.o.sentdata(h, bufchain_size(&h->u.o.queued_data));
 600             handle_try_output(&h->u.o);
 601         }
 602     }
 603 }
 604
 605 void handle_unthrottle(struct handle *h, int backlog)
 606 {
 607     assert(!h->output);
 608     handle_throttle(&h->u.i, backlog);
 609 }
 610
 611 int handle_backlog(struct handle *h)
 612 {
 613     assert(h->output);
 614     return bufchain_size(&h->u.o.queued_data);
 615 }
 616
 617 void *handle_get_privdata(struct handle *h)
 618 {
 619     return h->u.g.privdata;
 620 }