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.
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.
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
25 /* ----------------------------------------------------------------------
26 * Generic definitions.
30 * Maximum amount of backlog we will allow to build up on an input
31 * handle before we stop reading from it.
33 #define MAX_BACKLOG 32768
35 struct handle_generic {
37 * Initial fields common to both handle_input and handle_output
40 * The three HANDLEs are set up at initialisation time and are
41 * thereafter read-only to both main thread and subthread.
42 * `moribund' is only used by the main thread; `done' is
43 * written by the main thread before signalling to the
44 * subthread. `defunct' and `busy' are used only by the main
47 HANDLE h; /* the handle itself */
48 HANDLE ev_to_main; /* event used to signal main thread */
49 HANDLE ev_from_main; /* event used to signal back to us */
50 int moribund; /* are we going to kill this soon? */
51 int done; /* request subthread to terminate */
52 int defunct; /* has the subthread already gone? */
53 int busy; /* operation currently in progress? */
54 void *privdata; /* for client to remember who they are */
57 /* ----------------------------------------------------------------------
62 * Data required by an input thread.
66 * Copy of the handle_generic structure.
68 HANDLE h; /* the handle itself */
69 HANDLE ev_to_main; /* event used to signal main thread */
70 HANDLE ev_from_main; /* event used to signal back to us */
71 int moribund; /* are we going to kill this soon? */
72 int done; /* request subthread to terminate */
73 int defunct; /* has the subthread already gone? */
74 int busy; /* operation currently in progress? */
75 void *privdata; /* for client to remember who they are */
78 * Data set at initialisation and then read-only.
83 * Data set by the input thread before signalling ev_to_main,
84 * and read by the main thread after receiving that signal.
86 char buffer[4096]; /* the data read from the handle */
87 DWORD len; /* how much data that was */
88 int readret; /* lets us know about read errors */
91 * Callback function called by this module when data arrives on
94 handle_inputfn_t gotdata;
98 * The actual thread procedure for an input thread.
100 static DWORD WINAPI handle_input_threadfunc(void *param)
102 struct handle_input *ctx = (struct handle_input *) param;
103 OVERLAPPED ovl, *povl;
105 if (ctx->flags & HANDLE_FLAG_OVERLAPPED)
112 memset(povl, 0, sizeof(OVERLAPPED));
113 ctx->readret = ReadFile(ctx->h, ctx->buffer, sizeof(ctx->buffer),
115 if (povl && !ctx->readret && GetLastError() == ERROR_IO_PENDING)
116 ctx->readret = GetOverlappedResult(ctx->h, povl, &ctx->len, TRUE);
121 if (ctx->readret && ctx->len == 0 &&
122 (ctx->flags & HANDLE_FLAG_IGNOREEOF))
125 SetEvent(ctx->ev_to_main);
130 WaitForSingleObject(ctx->ev_from_main, INFINITE);
132 break; /* main thread told us to shut down */
139 * This is called after a succcessful read, or from the
140 * `unthrottle' function. It decides whether or not to begin a new
143 static void handle_throttle(struct handle_input *ctx, int backlog)
149 * If there's a read operation already in progress, do nothing:
150 * when that completes, we'll come back here and be in a
151 * position to make a better decision.
157 * Otherwise, we must decide whether to start a new read based
158 * on the size of the backlog.
160 if (backlog < MAX_BACKLOG) {
161 SetEvent(ctx->ev_from_main);
166 /* ----------------------------------------------------------------------
171 * Data required by an output thread.
173 struct handle_output {
175 * Copy of the handle_generic structure.
177 HANDLE h; /* the handle itself */
178 HANDLE ev_to_main; /* event used to signal main thread */
179 HANDLE ev_from_main; /* event used to signal back to us */
180 int moribund; /* are we going to kill this soon? */
181 int done; /* request subthread to terminate */
182 int defunct; /* has the subthread already gone? */
183 int busy; /* operation currently in progress? */
184 void *privdata; /* for client to remember who they are */
187 * Data set at initialisation and then read-only.
192 * Data set by the main thread before signalling ev_from_main,
193 * and read by the input thread after receiving that signal.
195 char *buffer; /* the data to write */
196 DWORD len; /* how much data there is */
199 * Data set by the input thread before signalling ev_to_main,
200 * and read by the main thread after receiving that signal.
202 DWORD lenwritten; /* how much data we actually wrote */
203 int writeret; /* return value from WriteFile */
206 * Data only ever read or written by the main thread.
208 bufchain queued_data; /* data still waiting to be written */
211 * Callback function called when the backlog in the bufchain
214 handle_outputfn_t sentdata;
217 static DWORD WINAPI handle_output_threadfunc(void *param)
219 struct handle_output *ctx = (struct handle_output *) param;
220 OVERLAPPED ovl, *povl;
222 if (ctx->flags & HANDLE_FLAG_OVERLAPPED)
228 WaitForSingleObject(ctx->ev_from_main, INFINITE);
230 SetEvent(ctx->ev_to_main);
234 memset(povl, 0, sizeof(OVERLAPPED));
235 ctx->writeret = WriteFile(ctx->h, ctx->buffer, ctx->len,
236 &ctx->lenwritten, povl);
237 if (povl && !ctx->writeret && GetLastError() == ERROR_IO_PENDING)
238 ctx->writeret = GetOverlappedResult(ctx->h, povl,
239 &ctx->lenwritten, TRUE);
241 SetEvent(ctx->ev_to_main);
249 static void handle_try_output(struct handle_output *ctx)
254 if (!ctx->busy && bufchain_size(&ctx->queued_data)) {
255 bufchain_prefix(&ctx->queued_data, &senddata, &sendlen);
256 ctx->buffer = senddata;
258 SetEvent(ctx->ev_from_main);
263 /* ----------------------------------------------------------------------
264 * Unified code handling both input and output threads.
270 struct handle_generic g;
271 struct handle_input i;
272 struct handle_output o;
276 static tree234 *handles_by_evtomain;
278 static int handle_cmp_evtomain(void *av, void *bv)
280 struct handle *a = (struct handle *)av;
281 struct handle *b = (struct handle *)bv;
283 if ((unsigned)a->u.g.ev_to_main < (unsigned)b->u.g.ev_to_main)
285 else if ((unsigned)a->u.g.ev_to_main > (unsigned)b->u.g.ev_to_main)
291 static int handle_find_evtomain(void *av, void *bv)
293 HANDLE *a = (HANDLE *)av;
294 struct handle *b = (struct handle *)bv;
296 if ((unsigned)*a < (unsigned)b->u.g.ev_to_main)
298 else if ((unsigned)*a > (unsigned)b->u.g.ev_to_main)
304 struct handle *handle_input_new(HANDLE handle, handle_inputfn_t gotdata,
305 void *privdata, int flags)
307 struct handle *h = snew(struct handle);
311 h->u.i.ev_to_main = CreateEvent(NULL, FALSE, FALSE, NULL);
312 h->u.i.ev_from_main = CreateEvent(NULL, FALSE, FALSE, NULL);
313 h->u.i.gotdata = gotdata;
314 h->u.i.defunct = FALSE;
315 h->u.i.moribund = FALSE;
317 h->u.i.privdata = privdata;
318 h->u.i.flags = flags;
320 if (!handles_by_evtomain)
321 handles_by_evtomain = newtree234(handle_cmp_evtomain);
322 add234(handles_by_evtomain, h);
324 CreateThread(NULL, 0, handle_input_threadfunc,
331 struct handle *handle_output_new(HANDLE handle, handle_outputfn_t sentdata,
332 void *privdata, int flags)
334 struct handle *h = snew(struct handle);
338 h->u.o.ev_to_main = CreateEvent(NULL, FALSE, FALSE, NULL);
339 h->u.o.ev_from_main = CreateEvent(NULL, FALSE, FALSE, NULL);
341 h->u.o.defunct = FALSE;
342 h->u.o.moribund = FALSE;
344 h->u.o.privdata = privdata;
345 bufchain_init(&h->u.o.queued_data);
346 h->u.o.sentdata = sentdata;
347 h->u.o.flags = flags;
349 if (!handles_by_evtomain)
350 handles_by_evtomain = newtree234(handle_cmp_evtomain);
351 add234(handles_by_evtomain, h);
353 CreateThread(NULL, 0, handle_output_threadfunc,
359 int handle_write(struct handle *h, const void *data, int len)
362 bufchain_add(&h->u.o.queued_data, data, len);
363 handle_try_output(&h->u.o);
364 return bufchain_size(&h->u.o.queued_data);
367 HANDLE *handle_get_events(int *nevents)
374 * Go through our tree counting the handle objects currently
375 * engaged in useful activity.
379 if (handles_by_evtomain) {
380 for (i = 0; (h = index234(handles_by_evtomain, i)) != NULL; i++) {
384 ret = sresize(ret, size, HANDLE);
386 ret[n++] = h->u.g.ev_to_main;
395 static void handle_destroy(struct handle *h)
398 bufchain_clear(&h->u.o.queued_data);
399 CloseHandle(h->u.g.ev_from_main);
400 CloseHandle(h->u.g.ev_to_main);
401 del234(handles_by_evtomain, h);
405 void handle_free(struct handle *h)
408 * If the handle is currently busy, we cannot immediately free
409 * it. Instead we must wait until it's finished its current
410 * operation, because otherwise the subthread will write to
411 * invalid memory after we free its context from under it.
413 assert(h && !h->u.g.moribund);
416 * Just set the moribund flag, which will be noticed next
417 * time an operation completes.
419 h->u.g.moribund = TRUE;
420 } else if (h->u.g.defunct) {
422 * There isn't even a subthread; we can go straight to
428 * The subthread is alive but not busy, so we now signal it
429 * to die. Set the moribund flag to indicate that it will
430 * want destroying after that.
432 h->u.g.moribund = TRUE;
435 SetEvent(h->u.g.ev_from_main);
439 void handle_got_event(HANDLE event)
443 assert(handles_by_evtomain);
444 h = find234(handles_by_evtomain, &event, handle_find_evtomain);
447 * This isn't an error condition. If two or more event
448 * objects were signalled during the same select operation,
449 * and processing of the first caused the second handle to
450 * be closed, then it will sometimes happen that we receive
451 * an event notification here for a handle which is already
452 * deceased. In that situation we simply do nothing.
457 if (h->u.g.moribund) {
459 * A moribund handle is already treated as dead from the
460 * external user's point of view, so do nothing with the
461 * actual event. Just signal the thread to die if
462 * necessary, or destroy the handle if not.
469 SetEvent(h->u.g.ev_from_main);
480 * A signal on an input handle means data has arrived.
482 if (h->u.i.len == 0) {
484 * EOF, or (nearly equivalently) read error.
486 h->u.i.gotdata(h, NULL, (h->u.i.readret ? 0 : -1));
487 h->u.i.defunct = TRUE;
489 backlog = h->u.i.gotdata(h, h->u.i.buffer, h->u.i.len);
490 handle_throttle(&h->u.i, backlog);
496 * A signal on an output handle means we have completed a
497 * write. Call the callback to indicate that the output
498 * buffer size has decreased, or to indicate an error.
500 if (!h->u.o.writeret) {
502 * Write error. Send a negative value to the callback,
503 * and mark the thread as defunct (because the output
504 * thread is terminating by now).
506 h->u.o.sentdata(h, -1);
507 h->u.o.defunct = TRUE;
509 bufchain_consume(&h->u.o.queued_data, h->u.o.lenwritten);
510 h->u.o.sentdata(h, bufchain_size(&h->u.o.queued_data));
511 handle_try_output(&h->u.o);
516 void handle_unthrottle(struct handle *h, int backlog)
519 handle_throttle(&h->u.i, backlog);
522 int handle_backlog(struct handle *h)
525 return bufchain_size(&h->u.o.queued_data);
528 void *handle_get_privdata(struct handle *h)
530 return h->u.g.privdata;