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
 254     /*
 255      * Callback function called when the backlog in the bufchain
 256      * drops.
 257      */
 258     handle_outputfn_t sentdata;
 259 };
 260
 261 static DWORD WINAPI handle_output_threadfunc(void *param)
 262 {
 263     struct handle_output *ctx = (struct handle_output *) param;
 264     OVERLAPPED ovl, *povl;
 265     int writeret;
 266
 267     if (ctx->flags & HANDLE_FLAG_OVERLAPPED)
 268         povl = &ovl;
 269     else
 270         povl = NULL;
 271
 272     while (1) {
 273         WaitForSingleObject(ctx->ev_from_main, INFINITE);
 274         if (ctx->done) {
 275             SetEvent(ctx->ev_to_main);
 276             break;
 277         }
 278         if (povl)
 279             memset(povl, 0, sizeof(OVERLAPPED));
 280         writeret = WriteFile(ctx->h, ctx->buffer, ctx->len,
 281                              &ctx->lenwritten, povl);
 282         if (!writeret)
 283             ctx->writeerr = GetLastError();
 284         else
 285             ctx->writeerr = 0;
 286         if (povl && !writeret && GetLastError() == ERROR_IO_PENDING) {
 287             writeret = GetOverlappedResult(ctx->h, povl,
 288                                            &ctx->lenwritten, TRUE);
 289             if (!writeret)
 290                 ctx->writeerr = GetLastError();
 291             else
 292                 ctx->writeerr = 0;
 293         }
 294
 295         SetEvent(ctx->ev_to_main);
 296         if (!writeret)
 297             break;
 298     }
 299
 300     return 0;
 301 }
 302
 303 static void handle_try_output(struct handle_output *ctx)
 304 {
 305     void *senddata;
 306     int sendlen;
 307
 308     if (!ctx->busy && bufchain_size(&ctx->queued_data)) {
 309         bufchain_prefix(&ctx->queued_data, &senddata, &sendlen);
 310         ctx->buffer = senddata;
 311         ctx->len = sendlen;
 312         SetEvent(ctx->ev_from_main);
 313         ctx->busy = TRUE;
 314     }
 315 }
 316
 317 /* ----------------------------------------------------------------------
 318  * Unified code handling both input and output threads.
 319  */
 320
 321 struct handle {
 322     int output;
 323     union {
 324         struct handle_generic g;
 325         struct handle_input i;
 326         struct handle_output o;
 327     } u;
 328 };
 329
 330 static tree234 *handles_by_evtomain;
 331
 332 static int handle_cmp_evtomain(void *av, void *bv)
 333 {
 334     struct handle *a = (struct handle *)av;
 335     struct handle *b = (struct handle *)bv;
 336
 337     if ((unsigned)a->u.g.ev_to_main < (unsigned)b->u.g.ev_to_main)
 338         return -1;
 339     else if ((unsigned)a->u.g.ev_to_main > (unsigned)b->u.g.ev_to_main)
 340         return +1;
 341     else
 342         return 0;
 343 }
 344
 345 static int handle_find_evtomain(void *av, void *bv)
 346 {
 347     HANDLE *a = (HANDLE *)av;
 348     struct handle *b = (struct handle *)bv;
 349
 350     if ((unsigned)*a < (unsigned)b->u.g.ev_to_main)
 351         return -1;
 352     else if ((unsigned)*a > (unsigned)b->u.g.ev_to_main)
 353         return +1;
 354     else
 355         return 0;
 356 }
 357
 358 struct handle *handle_input_new(HANDLE handle, handle_inputfn_t gotdata,
 359                                 void *privdata, int flags)
 360 {
 361     struct handle *h = snew(struct handle);
 362     DWORD in_threadid; /* required for Win9x */
 363
 364     h->output = FALSE;
 365     h->u.i.h = handle;
 366     h->u.i.ev_to_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 367     h->u.i.ev_from_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 368     h->u.i.gotdata = gotdata;
 369     h->u.i.defunct = FALSE;
 370     h->u.i.moribund = FALSE;
 371     h->u.i.done = FALSE;
 372     h->u.i.privdata = privdata;
 373     h->u.i.flags = flags;
 374
 375     if (!handles_by_evtomain)
 376         handles_by_evtomain = newtree234(handle_cmp_evtomain);
 377     add234(handles_by_evtomain, h);
 378
 379     CreateThread(NULL, 0, handle_input_threadfunc,
 380                  &h->u.i, 0, &in_threadid);
 381     h->u.i.busy = TRUE;
 382
 383     return h;
 384 }
 385
 386 struct handle *handle_output_new(HANDLE handle, handle_outputfn_t sentdata,
 387                                  void *privdata, int flags)
 388 {
 389     struct handle *h = snew(struct handle);
 390     DWORD out_threadid; /* required for Win9x */
 391
 392     h->output = TRUE;
 393     h->u.o.h = handle;
 394     h->u.o.ev_to_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 395     h->u.o.ev_from_main = CreateEvent(NULL, FALSE, FALSE, NULL);
 396     h->u.o.busy = FALSE;
 397     h->u.o.defunct = FALSE;
 398     h->u.o.moribund = FALSE;
 399     h->u.o.done = FALSE;
 400     h->u.o.privdata = privdata;
 401     bufchain_init(&h->u.o.queued_data);
 402     h->u.o.sentdata = sentdata;
 403     h->u.o.flags = flags;
 404
 405     if (!handles_by_evtomain)
 406         handles_by_evtomain = newtree234(handle_cmp_evtomain);
 407     add234(handles_by_evtomain, h);
 408
 409     CreateThread(NULL, 0, handle_output_threadfunc,
 410                  &h->u.i, 0, &out_threadid);
 411
 412     return h;
 413 }
 414
 415 int handle_write(struct handle *h, const void *data, int len)
 416 {
 417     assert(h->output);
 418     bufchain_add(&h->u.o.queued_data, data, len);
 419     handle_try_output(&h->u.o);
 420     return bufchain_size(&h->u.o.queued_data);
 421 }
 422
 423 HANDLE *handle_get_events(int *nevents)
 424 {
 425     HANDLE *ret;
 426     struct handle *h;
 427     int i, n, size;
 428
 429     /*
 430      * Go through our tree counting the handle objects currently
 431      * engaged in useful activity.
 432      */
 433     ret = NULL;
 434     n = size = 0;
 435     if (handles_by_evtomain) {
 436         for (i = 0; (h = index234(handles_by_evtomain, i)) != NULL; i++) {
 437             if (h->u.g.busy) {
 438                 if (n >= size) {
 439                     size += 32;
 440                     ret = sresize(ret, size, HANDLE);
 441                 }
 442                 ret[n++] = h->u.g.ev_to_main;
 443             }
 444         }
 445     }
 446
 447     *nevents = n;
 448     return ret;
 449 }
 450
 451 static void handle_destroy(struct handle *h)
 452 {
 453     if (h->output)
 454         bufchain_clear(&h->u.o.queued_data);
 455     CloseHandle(h->u.g.ev_from_main);
 456     CloseHandle(h->u.g.ev_to_main);
 457     del234(handles_by_evtomain, h);
 458     sfree(h);
 459 }
 460
 461 void handle_free(struct handle *h)
 462 {
 463     /*
 464      * If the handle is currently busy, we cannot immediately free
 465      * it. Instead we must wait until it's finished its current
 466      * operation, because otherwise the subthread will write to
 467      * invalid memory after we free its context from under it.
 468      */
 469     assert(h && !h->u.g.moribund);
 470     if (h->u.g.busy) {
 471         /*
 472          * Just set the moribund flag, which will be noticed next
 473          * time an operation completes.
 474          */
 475         h->u.g.moribund = TRUE;
 476     } else if (h->u.g.defunct) {
 477         /*
 478          * There isn't even a subthread; we can go straight to
 479          * handle_destroy.
 480          */
 481         handle_destroy(h);
 482     } else {
 483         /*
 484          * The subthread is alive but not busy, so we now signal it
 485          * to die. Set the moribund flag to indicate that it will
 486          * want destroying after that.
 487          */
 488         h->u.g.moribund = TRUE;
 489         h->u.g.done = TRUE;
 490         h->u.g.busy = TRUE;
 491         SetEvent(h->u.g.ev_from_main);
 492     }
 493 }
 494
 495 void handle_got_event(HANDLE event)
 496 {
 497     struct handle *h;
 498
 499     assert(handles_by_evtomain);
 500     h = find234(handles_by_evtomain, &event, handle_find_evtomain);
 501     if (!h) {
 502         /*
 503          * This isn't an error condition. If two or more event
 504          * objects were signalled during the same select operation,
 505          * and processing of the first caused the second handle to
 506          * be closed, then it will sometimes happen that we receive
 507          * an event notification here for a handle which is already
 508          * deceased. In that situation we simply do nothing.
 509          */
 510         return;
 511     }
 512
 513     if (h->u.g.moribund) {
 514         /*
 515          * A moribund handle is already treated as dead from the
 516          * external user's point of view, so do nothing with the
 517          * actual event. Just signal the thread to die if
 518          * necessary, or destroy the handle if not.
 519          */
 520         if (h->u.g.done) {
 521             handle_destroy(h);
 522         } else {
 523             h->u.g.done = TRUE;
 524             h->u.g.busy = TRUE;
 525             SetEvent(h->u.g.ev_from_main);
 526         }
 527         return;
 528     }
 529
 530     if (!h->output) {
 531         int backlog;
 532
 533         h->u.i.busy = FALSE;
 534
 535         /*
 536          * A signal on an input handle means data has arrived.
 537          */
 538         if (h->u.i.len == 0) {
 539             /*
 540              * EOF, or (nearly equivalently) read error.
 541              */
 542             h->u.i.gotdata(h, NULL, -h->u.i.readerr);
 543             h->u.i.defunct = TRUE;
 544         } else {
 545             backlog = h->u.i.gotdata(h, h->u.i.buffer, h->u.i.len);
 546             handle_throttle(&h->u.i, backlog);
 547         }
 548     } else {
 549         h->u.o.busy = FALSE;
 550
 551         /*
 552          * A signal on an output handle means we have completed a
 553          * write. Call the callback to indicate that the output
 554          * buffer size has decreased, or to indicate an error.
 555          */
 556         if (h->u.o.writeerr) {
 557             /*
 558              * Write error. Send a negative value to the callback,
 559              * and mark the thread as defunct (because the output
 560              * thread is terminating by now).
 561              */
 562             h->u.o.sentdata(h, -h->u.o.writeerr);
 563             h->u.o.defunct = TRUE;
 564         } else {
 565             bufchain_consume(&h->u.o.queued_data, h->u.o.lenwritten);
 566             h->u.o.sentdata(h, bufchain_size(&h->u.o.queued_data));
 567             handle_try_output(&h->u.o);
 568         }
 569     }
 570 }
 571
 572 void handle_unthrottle(struct handle *h, int backlog)
 573 {
 574     assert(!h->output);
 575     handle_throttle(&h->u.i, backlog);
 576 }
 577
 578 int handle_backlog(struct handle *h)
 579 {
 580     assert(h->output);
 581     return bufchain_size(&h->u.o.queued_data);
 582 }
 583
 584 void *handle_get_privdata(struct handle *h)
 585 {
 586     return h->u.g.privdata;
 587 }