1: /* dispatch.c
2:
3: I/O dispatcher. */
4:
5: /*
6: * Copyright (c) 2004,2007-2009 by Internet Systems Consortium, Inc. ("ISC")
7: * Copyright (c) 1999-2003 by Internet Software Consortium
8: *
9: * Permission to use, copy, modify, and distribute this software for any
10: * purpose with or without fee is hereby granted, provided that the above
11: * copyright notice and this permission notice appear in all copies.
12: *
13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20: *
21: * Internet Systems Consortium, Inc.
22: * 950 Charter Street
23: * Redwood City, CA 94063
24: * <info@isc.org>
25: * https://www.isc.org/
26: *
27: * This software has been written for Internet Systems Consortium
28: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
29: * To learn more about Internet Systems Consortium, see
30: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
31: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
32: * ``http://www.nominum.com''.
33: */
34:
35: #include "dhcpd.h"
36:
37: #include <omapip/omapip_p.h>
38: #include <sys/time.h>
39:
40: static omapi_io_object_t omapi_io_states;
41: struct timeval cur_tv;
42:
43: struct eventqueue *rw_queue_empty;
44:
45: OMAPI_OBJECT_ALLOC (omapi_io,
46: omapi_io_object_t, omapi_type_io_object)
47: OMAPI_OBJECT_ALLOC (omapi_waiter,
48: omapi_waiter_object_t, omapi_type_waiter)
49:
50: void
51: register_eventhandler(struct eventqueue **queue, void (*handler)(void *))
52: {
53: struct eventqueue *t, *q;
54:
55: /* traverse to end of list */
56: t = NULL;
57: for (q = *queue ; q ; q = q->next) {
58: if (q->handler == handler)
59: return; /* handler already registered */
60: t = q;
61: }
62:
63: q = ((struct eventqueue *)dmalloc(sizeof(struct eventqueue), MDL));
64: if (!q)
65: log_fatal("register_eventhandler: no memory!");
66: memset(q, 0, sizeof *q);
67: if (t)
68: t->next = q;
69: else
70: *queue = q;
71: q->handler = handler;
72: return;
73: }
74:
75: void
76: unregister_eventhandler(struct eventqueue **queue, void (*handler)(void *))
77: {
78: struct eventqueue *t, *q;
79:
80: /* traverse to end of list */
81: t= NULL;
82: for (q = *queue ; q ; q = q->next) {
83: if (q->handler == handler) {
84: if (t)
85: t->next = q->next;
86: else
87: *queue = q->next;
88: dfree(q, MDL); /* Don't access q after this!*/
89: break;
90: }
91: t = q;
92: }
93: return;
94: }
95:
96: void
97: trigger_event(struct eventqueue **queue)
98: {
99: struct eventqueue *q;
100:
101: for (q=*queue ; q ; q=q->next) {
102: if (q->handler)
103: (*q->handler)(NULL);
104: }
105: }
106:
107:
108: /* Register an I/O handle so that we can do asynchronous I/O on it. */
109:
110: isc_result_t omapi_register_io_object (omapi_object_t *h,
111: int (*readfd) (omapi_object_t *),
112: int (*writefd) (omapi_object_t *),
113: isc_result_t (*reader)
114: (omapi_object_t *),
115: isc_result_t (*writer)
116: (omapi_object_t *),
117: isc_result_t (*reaper)
118: (omapi_object_t *))
119: {
120: isc_result_t status;
121: omapi_io_object_t *obj, *p;
122:
123: /* omapi_io_states is a static object. If its reference count
124: is zero, this is the first I/O handle to be registered, so
125: we need to initialize it. Because there is no inner or outer
126: pointer on this object, and we're setting its refcnt to 1, it
127: will never be freed. */
128: if (!omapi_io_states.refcnt) {
129: omapi_io_states.refcnt = 1;
130: omapi_io_states.type = omapi_type_io_object;
131: }
132:
133: obj = (omapi_io_object_t *)0;
134: status = omapi_io_allocate (&obj, MDL);
135: if (status != ISC_R_SUCCESS)
136: return status;
137:
138: status = omapi_object_reference (&obj -> inner, h, MDL);
139: if (status != ISC_R_SUCCESS) {
140: omapi_io_dereference (&obj, MDL);
141: return status;
142: }
143:
144: status = omapi_object_reference (&h -> outer,
145: (omapi_object_t *)obj, MDL);
146: if (status != ISC_R_SUCCESS) {
147: omapi_io_dereference (&obj, MDL);
148: return status;
149: }
150:
151: /* Find the last I/O state, if there are any. */
152: for (p = omapi_io_states.next;
153: p && p -> next; p = p -> next)
154: ;
155: if (p)
156: omapi_io_reference (&p -> next, obj, MDL);
157: else
158: omapi_io_reference (&omapi_io_states.next, obj, MDL);
159:
160: obj -> readfd = readfd;
161: obj -> writefd = writefd;
162: obj -> reader = reader;
163: obj -> writer = writer;
164: obj -> reaper = reaper;
165:
166: omapi_io_dereference(&obj, MDL);
167: return ISC_R_SUCCESS;
168: }
169:
170: /* ReRegister an I/O handle so that we can do asynchronous I/O on it.
171: * If the handle doesn't exist we call the register routine to build it.
172: * if it does exist we change the functions associated with it, and
173: * repoke the fd code to make it happy. Neither the objects nor the
174: * fd are allowed to have changed. */
175:
176: isc_result_t omapi_reregister_io_object (omapi_object_t *h,
177: int (*readfd) (omapi_object_t *),
178: int (*writefd) (omapi_object_t *),
179: isc_result_t (*reader)
180: (omapi_object_t *),
181: isc_result_t (*writer)
182: (omapi_object_t *),
183: isc_result_t (*reaper)
184: (omapi_object_t *))
185: {
186: omapi_io_object_t *obj;
187:
188: if ((!h -> outer) || (h -> outer -> type != omapi_type_io_object)) {
189: /* If we don't have an object or if the type isn't what
190: * we expect do the normal registration (which will overwrite
191: * an incorrect type, that's what we did historically, may
192: * want to change that)
193: */
194: return (omapi_register_io_object (h, readfd, writefd,
195: reader, writer, reaper));
196: }
197:
198: /* We have an io object of the correct type, try to update it */
199: /*sar*/
200: /* Should we validate that the fd matches the previous one?
201: * It's suppossed to, that's a requirement, don't bother yet */
202:
203: obj = (omapi_io_object_t *)h->outer;
204:
205: obj -> readfd = readfd;
206: obj -> writefd = writefd;
207: obj -> reader = reader;
208: obj -> writer = writer;
209: obj -> reaper = reaper;
210:
211: return (ISC_R_SUCCESS);
212: }
213:
214: isc_result_t omapi_unregister_io_object (omapi_object_t *h)
215: {
216: omapi_io_object_t *p, *obj, *last, *ph;
217:
218: if (!h -> outer || h -> outer -> type != omapi_type_io_object)
219: return ISC_R_INVALIDARG;
220: obj = (omapi_io_object_t *)h -> outer;
221: ph = (omapi_io_object_t *)0;
222: omapi_io_reference (&ph, obj, MDL);
223:
224: /* remove from the list of I/O states */
225: last = &omapi_io_states;
226: for (p = omapi_io_states.next; p; p = p -> next) {
227: if (p == obj) {
228: omapi_io_dereference (&last -> next, MDL);
229: omapi_io_reference (&last -> next, p -> next, MDL);
230: break;
231: }
232: last = p;
233: }
234: if (obj -> next)
235: omapi_io_dereference (&obj -> next, MDL);
236:
237: if (obj -> outer) {
238: if (obj -> outer -> inner == (omapi_object_t *)obj)
239: omapi_object_dereference (&obj -> outer -> inner,
240: MDL);
241: omapi_object_dereference (&obj -> outer, MDL);
242: }
243: omapi_object_dereference (&obj -> inner, MDL);
244: omapi_object_dereference (&h -> outer, MDL);
245: omapi_io_dereference (&ph, MDL);
246: return ISC_R_SUCCESS;
247: }
248:
249: isc_result_t omapi_dispatch (struct timeval *t)
250: {
251: return omapi_wait_for_completion ((omapi_object_t *)&omapi_io_states,
252: t);
253: }
254:
255: isc_result_t omapi_wait_for_completion (omapi_object_t *object,
256: struct timeval *t)
257: {
258: isc_result_t status;
259: omapi_waiter_object_t *waiter;
260: omapi_object_t *inner;
261:
262: if (object) {
263: waiter = (omapi_waiter_object_t *)0;
264: status = omapi_waiter_allocate (&waiter, MDL);
265: if (status != ISC_R_SUCCESS)
266: return status;
267:
268: /* Paste the waiter object onto the inner object we're
269: waiting on. */
270: for (inner = object; inner -> inner; inner = inner -> inner)
271: ;
272:
273: status = omapi_object_reference (&waiter -> outer, inner, MDL);
274: if (status != ISC_R_SUCCESS) {
275: omapi_waiter_dereference (&waiter, MDL);
276: return status;
277: }
278:
279: status = omapi_object_reference (&inner -> inner,
280: (omapi_object_t *)waiter,
281: MDL);
282: if (status != ISC_R_SUCCESS) {
283: omapi_waiter_dereference (&waiter, MDL);
284: return status;
285: }
286: } else
287: waiter = (omapi_waiter_object_t *)0;
288:
289: do {
290: status = omapi_one_dispatch ((omapi_object_t *)waiter, t);
291: if (status != ISC_R_SUCCESS)
292: return status;
293: } while (!waiter || !waiter -> ready);
294:
295: if (waiter -> outer) {
296: if (waiter -> outer -> inner) {
297: omapi_object_dereference (&waiter -> outer -> inner,
298: MDL);
299: if (waiter -> inner)
300: omapi_object_reference
301: (&waiter -> outer -> inner,
302: waiter -> inner, MDL);
303: }
304: omapi_object_dereference (&waiter -> outer, MDL);
305: }
306: if (waiter -> inner)
307: omapi_object_dereference (&waiter -> inner, MDL);
308:
309: status = waiter -> waitstatus;
310: omapi_waiter_dereference (&waiter, MDL);
311: return status;
312: }
313:
314: isc_result_t omapi_one_dispatch (omapi_object_t *wo,
315: struct timeval *t)
316: {
317: fd_set r, w, x, rr, ww, xx;
318: int max = 0;
319: int count;
320: int desc;
321: struct timeval now, to;
322: omapi_io_object_t *io, *prev, *next;
323: omapi_waiter_object_t *waiter;
324: omapi_object_t *tmp = (omapi_object_t *)0;
325:
326: if (!wo || wo -> type != omapi_type_waiter)
327: waiter = (omapi_waiter_object_t *)0;
328: else
329: waiter = (omapi_waiter_object_t *)wo;
330:
331: FD_ZERO (&x);
332:
333: /* First, see if the timeout has expired, and if so return. */
334: if (t) {
335: gettimeofday (&now, (struct timezone *)0);
336: cur_tv.tv_sec = now.tv_sec;
337: cur_tv.tv_usec = now.tv_usec;
338: if (now.tv_sec > t -> tv_sec ||
339: (now.tv_sec == t -> tv_sec && now.tv_usec >= t -> tv_usec))
340: return ISC_R_TIMEDOUT;
341:
342: /* We didn't time out, so figure out how long until
343: we do. */
344: to.tv_sec = t -> tv_sec - now.tv_sec;
345: to.tv_usec = t -> tv_usec - now.tv_usec;
346: if (to.tv_usec < 0) {
347: to.tv_usec += 1000000;
348: to.tv_sec--;
349: }
350:
351: /* It is possible for the timeout to get set larger than
352: the largest time select() is willing to accept.
353: Restricting the timeout to a maximum of one day should
354: work around this. -DPN. (Ref: Bug #416) */
355: if (to.tv_sec > (60 * 60 * 24))
356: to.tv_sec = 60 * 60 * 24;
357: }
358:
359: /* If the object we're waiting on has reached completion,
360: return now. */
361: if (waiter && waiter -> ready)
362: return ISC_R_SUCCESS;
363:
364: again:
365: /* If we have no I/O state, we can't proceed. */
366: if (!(io = omapi_io_states.next))
367: return ISC_R_NOMORE;
368:
369: /* Set up the read and write masks. */
370: FD_ZERO (&r);
371: FD_ZERO (&w);
372:
373: for (; io; io = io -> next) {
374: /* Check for a read socket. If we shouldn't be
375: trying to read for this I/O object, either there
376: won't be a readfd function, or it'll return -1. */
377: if (io -> readfd && io -> inner &&
378: (desc = (*(io -> readfd)) (io -> inner)) >= 0) {
379: FD_SET (desc, &r);
380: if (desc > max)
381: max = desc;
382: }
383:
384: /* Same deal for write fdets. */
385: if (io -> writefd && io -> inner &&
386: (desc = (*(io -> writefd)) (io -> inner)) >= 0) {
387: FD_SET (desc, &w);
388: if (desc > max)
389: max = desc;
390: }
391: }
392:
393: /* poll if all reader are dry */
394: now.tv_sec = 0;
395: now.tv_usec = 0;
396: rr=r;
397: ww=w;
398: xx=x;
399:
400: /* poll once */
401: count = select(max + 1, &r, &w, &x, &now);
402: if (!count) {
403: /* We are dry now */
404: trigger_event(&rw_queue_empty);
405: /* Wait for a packet or a timeout... XXX */
406: r = rr;
407: w = ww;
408: x = xx;
409: count = select(max + 1, &r, &w, &x, t ? &to : NULL);
410: }
411:
412: /* Get the current time... */
413: gettimeofday (&cur_tv, (struct timezone *)0);
414:
415: /* We probably have a bad file descriptor. Figure out which one.
416: When we find it, call the reaper function on it, which will
417: maybe make it go away, and then try again. */
418: if (count < 0) {
419: struct timeval t0;
420: omapi_io_object_t *prev = (omapi_io_object_t *)0;
421: io = (omapi_io_object_t *)0;
422: if (omapi_io_states.next)
423: omapi_io_reference (&io, omapi_io_states.next, MDL);
424:
425: while (io) {
426: omapi_object_t *obj;
427: FD_ZERO (&r);
428: FD_ZERO (&w);
429: t0.tv_sec = t0.tv_usec = 0;
430:
431: if (io -> readfd && io -> inner &&
432: (desc = (*(io -> readfd)) (io -> inner)) >= 0) {
433: FD_SET (desc, &r);
434: count = select (desc + 1, &r, &w, &x, &t0);
435: bogon:
436: if (count < 0) {
437: log_error ("Bad descriptor %d.", desc);
438: for (obj = (omapi_object_t *)io;
439: obj -> outer;
440: obj = obj -> outer)
441: ;
442: for (; obj; obj = obj -> inner) {
443: omapi_value_t *ov;
444: int len;
445: const char *s;
446: ov = (omapi_value_t *)0;
447: omapi_get_value_str (obj,
448: (omapi_object_t *)0,
449: "name", &ov);
450: if (ov && ov -> value &&
451: (ov -> value -> type ==
452: omapi_datatype_string)) {
453: s = (char *)
454: ov -> value -> u.buffer.value;
455: len = ov -> value -> u.buffer.len;
456: } else {
457: s = "";
458: len = 0;
459: }
460: log_error ("Object %lx %s%s%.*s",
461: (unsigned long)obj,
462: obj -> type -> name,
463: len ? " " : "",
464: len, s);
465: if (len)
466: omapi_value_dereference (&ov, MDL);
467: }
468: (*(io -> reaper)) (io -> inner);
469: if (prev) {
470: omapi_io_dereference (&prev -> next, MDL);
471: if (io -> next)
472: omapi_io_reference (&prev -> next,
473: io -> next, MDL);
474: } else {
475: omapi_io_dereference
476: (&omapi_io_states.next, MDL);
477: if (io -> next)
478: omapi_io_reference
479: (&omapi_io_states.next,
480: io -> next, MDL);
481: }
482: omapi_io_dereference (&io, MDL);
483: goto again;
484: }
485: }
486:
487: FD_ZERO (&r);
488: FD_ZERO (&w);
489: t0.tv_sec = t0.tv_usec = 0;
490:
491: /* Same deal for write fdets. */
492: if (io -> writefd && io -> inner &&
493: (desc = (*(io -> writefd)) (io -> inner)) >= 0) {
494: FD_SET (desc, &w);
495: count = select (desc + 1, &r, &w, &x, &t0);
496: if (count < 0)
497: goto bogon;
498: }
499: if (prev)
500: omapi_io_dereference (&prev, MDL);
501: omapi_io_reference (&prev, io, MDL);
502: omapi_io_dereference (&io, MDL);
503: if (prev -> next)
504: omapi_io_reference (&io, prev -> next, MDL);
505: }
506: if (prev)
507: omapi_io_dereference (&prev, MDL);
508:
509: }
510:
511: for (io = omapi_io_states.next; io; io = io -> next) {
512: if (!io -> inner)
513: continue;
514: omapi_object_reference (&tmp, io -> inner, MDL);
515: /* Check for a read descriptor, and if there is one,
516: see if we got input on that socket. */
517: if (io -> readfd &&
518: (desc = (*(io -> readfd)) (tmp)) >= 0) {
519: if (FD_ISSET (desc, &r))
520: ((*(io -> reader)) (tmp));
521: }
522:
523: /* Same deal for write descriptors. */
524: if (io -> writefd &&
525: (desc = (*(io -> writefd)) (tmp)) >= 0)
526: {
527: if (FD_ISSET (desc, &w))
528: ((*(io -> writer)) (tmp));
529: }
530: omapi_object_dereference (&tmp, MDL);
531: }
532:
533: /* Now check for I/O handles that are no longer valid,
534: and remove them from the list. */
535: prev = NULL;
536: io = NULL;
537: if (omapi_io_states.next != NULL) {
538: omapi_io_reference(&io, omapi_io_states.next, MDL);
539: }
540: while (io != NULL) {
541: if ((io->inner == NULL) ||
542: ((io->reaper != NULL) &&
543: ((io->reaper)(io->inner) != ISC_R_SUCCESS)))
544: {
545:
546: omapi_io_object_t *tmp = NULL;
547: /* Save a reference to the next
548: pointer, if there is one. */
549: if (io->next != NULL) {
550: omapi_io_reference(&tmp, io->next, MDL);
551: omapi_io_dereference(&io->next, MDL);
552: }
553: if (prev != NULL) {
554: omapi_io_dereference(&prev->next, MDL);
555: if (tmp != NULL)
556: omapi_io_reference(&prev->next,
557: tmp, MDL);
558: } else {
559: omapi_io_dereference(&omapi_io_states.next,
560: MDL);
561: if (tmp != NULL)
562: omapi_io_reference
563: (&omapi_io_states.next,
564: tmp, MDL);
565: else
566: omapi_signal_in(
567: (omapi_object_t *)
568: &omapi_io_states,
569: "ready");
570: }
571: if (tmp != NULL)
572: omapi_io_dereference(&tmp, MDL);
573:
574: } else {
575:
576: if (prev != NULL) {
577: omapi_io_dereference(&prev, MDL);
578: }
579: omapi_io_reference(&prev, io, MDL);
580:
581: }
582:
583: /*
584: * Equivalent to:
585: * io = io->next
586: * But using our reference counting voodoo.
587: */
588: next = NULL;
589: if (io->next != NULL) {
590: omapi_io_reference(&next, io->next, MDL);
591: }
592: omapi_io_dereference(&io, MDL);
593: if (next != NULL) {
594: omapi_io_reference(&io, next, MDL);
595: omapi_io_dereference(&next, MDL);
596: }
597: }
598: if (prev != NULL) {
599: omapi_io_dereference(&prev, MDL);
600: }
601:
602: return ISC_R_SUCCESS;
603: }
604:
605: isc_result_t omapi_io_set_value (omapi_object_t *h,
606: omapi_object_t *id,
607: omapi_data_string_t *name,
608: omapi_typed_data_t *value)
609: {
610: if (h -> type != omapi_type_io_object)
611: return ISC_R_INVALIDARG;
612:
613: if (h -> inner && h -> inner -> type -> set_value)
614: return (*(h -> inner -> type -> set_value))
615: (h -> inner, id, name, value);
616: return ISC_R_NOTFOUND;
617: }
618:
619: isc_result_t omapi_io_get_value (omapi_object_t *h,
620: omapi_object_t *id,
621: omapi_data_string_t *name,
622: omapi_value_t **value)
623: {
624: if (h -> type != omapi_type_io_object)
625: return ISC_R_INVALIDARG;
626:
627: if (h -> inner && h -> inner -> type -> get_value)
628: return (*(h -> inner -> type -> get_value))
629: (h -> inner, id, name, value);
630: return ISC_R_NOTFOUND;
631: }
632:
633: /* omapi_io_destroy (object, MDL);
634: *
635: * Find the requested IO [object] and remove it from the list of io
636: * states, causing the cleanup functions to destroy it. Note that we must
637: * hold a reference on the object while moving its ->next reference and
638: * removing the reference in the chain to the target object...otherwise it
639: * may be cleaned up from under us.
640: */
641: isc_result_t omapi_io_destroy (omapi_object_t *h, const char *file, int line)
642: {
643: omapi_io_object_t *obj = NULL, *p, *last = NULL, **holder;
644:
645: if (h -> type != omapi_type_io_object)
646: return ISC_R_INVALIDARG;
647:
648: /* remove from the list of I/O states */
649: for (p = omapi_io_states.next; p; p = p -> next) {
650: if (p == (omapi_io_object_t *)h) {
651: omapi_io_reference (&obj, p, MDL);
652:
653: if (last)
654: holder = &last -> next;
655: else
656: holder = &omapi_io_states.next;
657:
658: omapi_io_dereference (holder, MDL);
659:
660: if (obj -> next) {
661: omapi_io_reference (holder, obj -> next, MDL);
662: omapi_io_dereference (&obj -> next, MDL);
663: }
664:
665: return omapi_io_dereference (&obj, MDL);
666: }
667: last = p;
668: }
669:
670: return ISC_R_NOTFOUND;
671: }
672:
673: isc_result_t omapi_io_signal_handler (omapi_object_t *h,
674: const char *name, va_list ap)
675: {
676: if (h -> type != omapi_type_io_object)
677: return ISC_R_INVALIDARG;
678:
679: if (h -> inner && h -> inner -> type -> signal_handler)
680: return (*(h -> inner -> type -> signal_handler)) (h -> inner,
681: name, ap);
682: return ISC_R_NOTFOUND;
683: }
684:
685: isc_result_t omapi_io_stuff_values (omapi_object_t *c,
686: omapi_object_t *id,
687: omapi_object_t *i)
688: {
689: if (i -> type != omapi_type_io_object)
690: return ISC_R_INVALIDARG;
691:
692: if (i -> inner && i -> inner -> type -> stuff_values)
693: return (*(i -> inner -> type -> stuff_values)) (c, id,
694: i -> inner);
695: return ISC_R_SUCCESS;
696: }
697:
698: isc_result_t omapi_waiter_signal_handler (omapi_object_t *h,
699: const char *name, va_list ap)
700: {
701: omapi_waiter_object_t *waiter;
702:
703: if (h -> type != omapi_type_waiter)
704: return ISC_R_INVALIDARG;
705:
706: if (!strcmp (name, "ready")) {
707: waiter = (omapi_waiter_object_t *)h;
708: waiter -> ready = 1;
709: waiter -> waitstatus = ISC_R_SUCCESS;
710: return ISC_R_SUCCESS;
711: }
712:
713: if (!strcmp (name, "status")) {
714: waiter = (omapi_waiter_object_t *)h;
715: waiter -> ready = 1;
716: waiter -> waitstatus = va_arg (ap, isc_result_t);
717: return ISC_R_SUCCESS;
718: }
719:
720: if (!strcmp (name, "disconnect")) {
721: waiter = (omapi_waiter_object_t *)h;
722: waiter -> ready = 1;
723: waiter -> waitstatus = ISC_R_CONNRESET;
724: return ISC_R_SUCCESS;
725: }
726:
727: if (h -> inner && h -> inner -> type -> signal_handler)
728: return (*(h -> inner -> type -> signal_handler)) (h -> inner,
729: name, ap);
730: return ISC_R_NOTFOUND;
731: }
732:
733: isc_result_t omapi_io_state_foreach (isc_result_t (*func) (omapi_object_t *,
734: void *),
735: void *p)
736: {
737: omapi_io_object_t *io;
738: isc_result_t status;
739:
740: for (io = omapi_io_states.next; io; io = io -> next) {
741: if (io -> inner) {
742: status = (*func) (io -> inner, p);
743: if (status != ISC_R_SUCCESS)
744: return status;
745: }
746: }
747: return ISC_R_SUCCESS;
748: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dispatch.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / omapip