chiark / gitweb /
Qualify name given to @bres_byname@.
[mLib] / sel.c
1 /* -*-c-*-
2  *
3  * $Id: sel.c,v 1.12 2003/05/18 15:10:29 mdw Exp $
4  *
5  * I/O multiplexing support
6  *
7  * (c) 1999 Straylight/Edgeware
8  */
9
10 /*----- Licensing notice --------------------------------------------------* 
11  *
12  * This file is part of the mLib utilities library.
13  *
14  * mLib is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU Library General Public License as
16  * published by the Free Software Foundation; either version 2 of the
17  * License, or (at your option) any later version.
18  * 
19  * mLib is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU Library General Public License for more details.
23  * 
24  * You should have received a copy of the GNU Library General Public
25  * License along with mLib; if not, write to the Free
26  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
27  * MA 02111-1307, USA.
28  */
29
30 /*----- Revision history --------------------------------------------------* 
31  *
32  * $Log: sel.c,v $
33  * Revision 1.12  2003/05/18 15:10:29  mdw
34  * Remove memory leak.
35  *
36  * Revision 1.11  2003/05/17 10:34:04  mdw
37  *  Tidying and bugfixing.
38  *
39  * Revision 1.10  2001/06/22 19:35:58  mdw
40  * Fix a large number of bugs.
41  *
42  * Revision 1.9  2001/02/03 19:07:08  mdw
43  * Ensure that timers set to go off in the past don't case a problem.
44  *
45  * Revision 1.8  2000/03/23 20:42:08  mdw
46  * Rearrange timeout handling to avoid list corruptions.
47  *
48  * Revision 1.7  1999/12/11 11:12:17  mdw
49  * Fix comment formatting error.
50  *
51  * Revision 1.6  1999/09/26 14:28:11  mdw
52  * (sel_select): Almost pointless efficiency tweak.
53  *
54  * Revision 1.5  1999/08/31 17:42:22  mdw
55  * New function `sel_force' to force a descriptor to be `selected'.
56  *
57  * Revision 1.4  1999/08/19 18:30:26  mdw
58  * Implement hooks for foreign select-using systems (currently not well
59  * tested).
60  *
61  * Revision 1.3  1999/05/21 22:13:59  mdw
62  * Use new `tv' macros.  Fix ordering bug for timeout selectors.
63  *
64  * Revision 1.2  1999/05/15 10:33:32  mdw
65  * Fix copyright notices.
66  *
67  * Revision 1.1  1999/05/14 21:01:14  mdw
68  * Integrated `select' handling bits from the background resolver project.
69  *
70  */
71
72 /*----- Header files ------------------------------------------------------*/
73
74 #include <assert.h>
75 #include <stdio.h>
76 #include <stdlib.h>
77 #include <string.h>
78
79 #include <sys/types.h>
80 #include <sys/time.h>
81 #include <unistd.h>
82
83 #include "sel.h"
84 #include "sub.h"
85 #include "tv.h"
86
87 /*----- Data structures ---------------------------------------------------*/
88
89 typedef struct sel_pendfile {
90   struct sel_pendfile *next;
91   sel_file *f;
92 } pfile;
93
94 typedef struct sel_pendtimer {
95   struct sel_pendtimer *next;
96   sel_timer *t;
97 } ptimer;
98
99 /*----- Main code ---------------------------------------------------------*/
100
101 /* --- @sel_init@ --- *
102  *
103  * Arguments:   @sel_state *s@ = pointer to a state block to initialize
104  *
105  * Returns:     ---
106  *
107  * Use:         Initializes a select state block.
108  */
109
110 void sel_init(sel_state *s)
111 {
112   int i;
113
114   for (i = 0; i < SEL_MODES; i++) {
115     s->files[i] = 0;
116     FD_ZERO(&s->fd[i]);
117   }
118   s->timers = 0;
119   s->hooks = 0;
120   s->args = 0;
121 }
122
123 /* --- @sel_initfile@ --- *
124  *
125  * Arguments:   @sel_state *s@ = select state to attach to
126  *              @sel_file *f@ = pointer to a file block to initialize
127  *              @int fd@ = the file descriptor to listen to
128  *              @unsigned mode@ = what to listen for
129  *              @void (*func)(int fd, unsigned mode, void *p)@ = handler
130  *              @void *p@ = argument to pass to handler
131  *
132  * Returns:     ---
133  *
134  * Use:         Initializes a file block ready for use.  The file block
135  *              isn't added to the list of things to do until a call to
136  *              @sel_addfile@.
137  */
138
139 void sel_initfile(sel_state *s, sel_file *f,
140                   int fd, unsigned mode,
141                   void (*func)(int /*fd*/, unsigned /*mode*/, void */*p*/),
142                   void *p)
143 {
144   f->s = s;
145   f->fd = fd;
146   f->mode = mode;
147   f->func = func;
148   f->p = p;
149   f->pend = 0;
150 }
151
152 /* --- @sel_addfile@ --- *
153  *
154  * Arguments:   @sel_file *f@ = pointer to a file block
155  *
156  * Returns:     ---
157  *
158  * Use:         Adds a file block into the list of things to listen to.
159  */
160
161 void sel_addfile(sel_file *f)
162 {
163   sel_file **ff = &f->s->files[f->mode];
164
165   /* --- This little dance looks like line-noise, but it does the job --- */
166
167   while (*ff && (*ff)->fd > f->fd)
168     ff = &(*ff)->next;
169   f->next = *ff;
170   f->prev = ff;
171   if (*ff)
172     (*ff)->prev = &f->next;
173   *ff = f;
174   FD_SET(f->fd, f->s->fd + f->mode);
175 }
176
177 /* --- @sel_force@ --- *
178  *
179  * Arguments:   @sel_file *f@ = pointer to file selector
180  *
181  * Returns:     ---
182  *
183  * Use:         Forces a file selector to be considered ready.  This is only
184  *              useful during a call to @sel_select@.  Of particular use is
185  *              forcing a write selector when there's something interesting
186  *              ready for it.
187  */
188
189 void sel_force(sel_file *f)
190 {
191   if (f->s->args)
192     FD_SET(f->fd, &f->s->args->fd[f->mode]);
193 }
194
195 /* --- @sel_rmfile@ --- *
196  *
197  * Arguments:   @sel_file *f@ = pointer to a file block
198  *
199  * Returns:     ---
200  *
201  * Use:         Removes a file block from the list of things to listen to.
202  */
203
204 void sel_rmfile(sel_file *f)
205 {
206   *f->prev = f->next;
207   if (f->next)
208     f->next->prev = f->prev;
209   FD_CLR(f->fd, f->s->fd + f->mode);
210   if (f->pend) {
211     f->pend->f = 0;
212     f->pend = 0;
213   }
214 }
215
216 /* --- @sel_addtimer@ --- *
217  *
218  * Arguments:   @sel_state *s@ = pointer to a state block
219  *              @sel_timer *t@ = pointer to a timer block
220  *              @struct timeval *tv@ = pointer to time to activate
221  *              @void (*func)(struct timeval *tv, void *p)@ = handler
222  *              @void *p@ = argument for handler function
223  *
224  * Returns:     ---
225  *
226  * Use:         Registers and sets up a timer.
227  */
228
229 void sel_addtimer(sel_state *s, sel_timer *t,
230                   struct timeval *tv,
231                   void (*func)(struct timeval */*tv*/, void */*p*/),
232                   void *p)
233 {
234   sel_timer **tt = &s->timers;
235   { sel_timer *q; for (q = s->timers; q; q = q->next) assert(q != t); }
236
237   /* --- Set up the timer block --- */
238
239   t->tv = *tv;
240   t->func = func;
241   t->p = p;
242   t->pend = 0;
243
244   /* --- More line noise --- */
245   
246   while (*tt && TV_CMP(&(*tt)->tv, <, tv))
247     tt = &(*tt)->next;
248   t->next = *tt;
249   t->prev = tt;
250   if (*tt)
251     (*tt)->prev = &t->next;
252   *tt = t;
253 }
254
255 /* --- @sel_rmtimer@ --- *
256  *
257  * Arguments:   @sel_timer *t@ = pointer to timer block
258  *
259  * Returns:     ---
260  *
261  * Use:         Removes a timer from the list of timers.
262  */
263
264 void sel_rmtimer(sel_timer *t)
265 {
266   if (t->pend) {
267     t->pend->t = 0;
268     t->pend = 0;
269   } else {
270     *t->prev = t->next;
271     if (t->next)
272       t->next->prev = t->prev;
273   }
274 }
275
276 /* --- @sel_addhook@ --- *
277  *
278  * Arguments:   @sel_state *s@ = pointer to state block
279  *              @sel_hook *h@ = pointer to hook block
280  *              @sel_hookfn before, after@ = hook functions
281  *              @void *p@ = pointer argument to pass to hook functions
282  *
283  * Returns:     ---
284  *
285  * Use:         Registers hook functions to be called on each select call.
286  */
287
288 void sel_addhook(sel_state *s, sel_hook *h,
289                  sel_hookfn before, sel_hookfn after,
290                  void *p)
291 {
292   h->before = before;
293   h->after = after;
294   h->p = p;
295   h->next = s->hooks;
296   h->prev = &s->hooks;
297   if (s->hooks)
298     s->hooks->prev = &h->next;
299   s->hooks = h;
300 }
301
302 /* --- @sel_rmhook@ --- *
303  *
304  * Arguments:   @sel_hook *h@ = pointer to hook block
305  *
306  * Returns:     ---
307  *
308  * Use:         Removes hook functions.
309  */
310
311 void sel_rmhook(sel_hook *h)
312 {
313   if (h->next)
314     h->next->prev = h->prev;
315   *h->prev = h->next;
316 }
317
318 /* --- @sel_fdmerge@ --- *
319  *
320  * Arguments:   @fd_set *dest@ = destination FD set
321  *              @fd_set *fd@ = pointer to set to merge
322  *              @int maxfd@ = highest numbered descriptor in @fd@ + 1
323  *
324  * Returns:     Actual highest numbered descriptor.
325  *
326  * Use:         Merges file descriptor sets, and returns an accurate @maxfd@
327  *              value.
328  */
329
330 int sel_fdmerge(fd_set *dest, fd_set *fd, int maxfd)
331 {
332   int i, m = -1;
333
334   for (i = 0; i < maxfd; i++) {
335     if (FD_ISSET(i, fd)) {
336       FD_SET(i, dest);
337       m = i;
338     }
339   }
340
341   return (m + 1);
342 }
343
344 /* --- @sel_select@ --- *
345  *
346  * Arguments:   @sel_state *s@ = pointer to state block
347  *
348  * Returns:     Zero if all OK, -1 on error.
349  *
350  * Use:         Does a @select@ call (or equivalent @poll@).
351  */
352
353 int sel_select(sel_state *s)
354 {
355   sel_args a;
356   int err;
357
358   /* --- Initialize the argument block --- */
359
360   {
361     int i;
362     a.maxfd = 0;
363     for (i = 0; i < SEL_MODES; i++) {
364       if (s->files[i] && s->files[i]->fd >= a.maxfd)
365         a.maxfd = s->files[i]->fd + 1;
366     }
367   }
368
369   memcpy(a.fd, s->fd, sizeof(a.fd));
370   if (s->timers || s->hooks)
371     gettimeofday(&a.now, 0);
372   if (!s->timers)
373     a.tvp = 0;
374   else {
375     if (TV_CMP(&s->timers->tv, >, &a.now))
376       TV_SUB(&a.tv, &s->timers->tv, &a.now);
377     else {
378       a.tv.tv_sec = 0;
379       a.tv.tv_usec = 0;
380     }
381     a.tvp = &a.tv;
382   }
383   s->args = &a;
384
385   /* --- Grind through the pre hooks --- */
386
387   {
388     sel_hook *h = s->hooks;
389     while (h) {
390       sel_hook *hh = h;
391       h = h->next;
392       if (hh->before)
393         hh->before(s, &a, hh->p);
394     }
395   }
396
397   /* --- Run the @select@ call --- */
398   
399   if ((err = select(a.maxfd,
400                     &a.fd[SEL_READ], &a.fd[SEL_WRITE], &a.fd[SEL_EXC],
401                     a.tvp)) < 0) {
402     s->args = 0;
403     return (err);
404   }
405
406   if (a.tvp)
407     gettimeofday(&a.now, 0);
408
409   /* --- Run through the hooks again --- */
410
411   {
412     sel_hook *h = s->hooks;
413     while (h) {
414       sel_hook *hh = h;
415       h = h->next;
416       if (hh->after)
417         hh->after(s, &a, hh->p);
418     }
419   }
420
421   /* --- Run through the timers --- */
422
423   if (s->timers) {
424     ptimer *pthead, *pt, **ptt = &pthead;
425     sel_timer *t;
426
427     for (t = s->timers; t && TV_CMP(&t->tv, <=, &a.now); t = t->next) {
428       pt = CREATE(ptimer);
429       pt->t = t;
430       t->pend = pt;
431       *ptt = pt;
432       ptt = &pt->next;
433     }
434     *ptt = 0;
435     if (t) {
436       *t->prev = 0;
437       t->prev = &s->timers;
438     }
439     s->timers = t;
440     while (pthead) {
441       pt = pthead;
442       pthead = pt->next;
443       t = pt->t;
444       if (t) {
445         t->pend = 0;
446         t->next = 0;
447         t->prev = &t->next;
448         t->func(&a.now, t->p);
449       }
450       DESTROY(pt);
451     }
452   }
453
454   /* --- And finally run through the files --- *
455    *
456    * Do reads first.  It's quite possible that a read might prompt a write,
457    * but the other way around is less likely.  Fortunately, the modes are
458    * in the right order for this.
459    */
460
461   {
462     int i;
463
464     for (i = 0; i < SEL_MODES; i++) {
465       pfile *pfhead, *pf, **pff = &pfhead;
466       sel_file *f;
467
468       for (f = s->files[i]; f; f = f->next) {
469         if (!FD_ISSET(f->fd, &a.fd[i]))
470           continue;
471         pf = CREATE(pfile);
472         pf->f = f;
473         f->pend = pf;
474         *pff = pf;
475         pff = &pf->next;
476       }
477       *pff = 0;
478       while (pfhead) {
479         pf = pfhead;
480         pfhead = pf->next;
481         f = pf->f;
482         if (f) {
483           f->pend = 0;
484           f->func(f->fd, i, f->p);
485         }
486         DESTROY(pf);
487       }
488     }
489   }
490
491   s->args = 0;
492   return (0);
493 }
494
495 /*----- That's all, folks -------------------------------------------------*/