![[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 / common|
Return to dispatch.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / common |
1.1 misho 1: /* dispatch.c
2:
3: Network input dispatcher... */
4:
5: /*
6: * Copyright (c) 2004-2009,2011 by Internet Systems Consortium, Inc. ("ISC")
7: * Copyright (c) 1995-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: struct timeout *timeouts;
38: static struct timeout *free_timeouts;
39:
40: void set_time(TIME t)
41: {
42: /* Do any outstanding timeouts. */
43: if (cur_tv . tv_sec != t) {
44: cur_tv . tv_sec = t;
45: cur_tv . tv_usec = 0;
46: process_outstanding_timeouts ((struct timeval *)0);
47: }
48: }
49:
50: struct timeval *process_outstanding_timeouts (struct timeval *tvp)
51: {
52: /* Call any expired timeouts, and then if there's
53: still a timeout registered, time out the select
54: call then. */
55: another:
56: if (timeouts) {
57: struct timeout *t;
58: if ((timeouts -> when . tv_sec < cur_tv . tv_sec) ||
59: ((timeouts -> when . tv_sec == cur_tv . tv_sec) &&
60: (timeouts -> when . tv_usec <= cur_tv . tv_usec))) {
61: t = timeouts;
62: timeouts = timeouts -> next;
63: (*(t -> func)) (t -> what);
64: if (t -> unref)
65: (*t -> unref) (&t -> what, MDL);
66: t -> next = free_timeouts;
67: free_timeouts = t;
68: goto another;
69: }
70: if (tvp) {
71: tvp -> tv_sec = timeouts -> when . tv_sec;
72: tvp -> tv_usec = timeouts -> when . tv_usec;
73: }
74: return tvp;
75: } else
76: return (struct timeval *)0;
77: }
78:
79: /* Wait for packets to come in using select(). When one does, call
80: receive_packet to receive the packet and possibly strip hardware
81: addressing information from it, and then call through the
82: bootp_packet_handler hook to try to do something with it. */
83:
84: void dispatch ()
85: {
86: struct timeval tv, *tvp;
87: isc_result_t status;
88:
89: /* Wait for a packet or a timeout... XXX */
90: do {
91: tvp = process_outstanding_timeouts (&tv);
92: status = omapi_one_dispatch (0, tvp);
93: } while (status == ISC_R_TIMEDOUT || status == ISC_R_SUCCESS);
94: log_fatal ("omapi_one_dispatch failed: %s -- exiting.",
95: isc_result_totext (status));
96: }
97:
98: void add_timeout (when, where, what, ref, unref)
99: struct timeval *when;
100: void (*where) (void *);
101: void *what;
102: tvref_t ref;
103: tvunref_t unref;
104: {
105: struct timeout *t, *q;
106:
107: /* See if this timeout supersedes an existing timeout. */
108: t = (struct timeout *)0;
109: for (q = timeouts; q; q = q -> next) {
110: if ((where == NULL || q -> func == where) &&
111: q -> what == what) {
112: if (t)
113: t -> next = q -> next;
114: else
115: timeouts = q -> next;
116: break;
117: }
118: t = q;
119: }
120:
121: /* If we didn't supersede a timeout, allocate a timeout
122: structure now. */
123: if (!q) {
124: if (free_timeouts) {
125: q = free_timeouts;
126: free_timeouts = q -> next;
127: } else {
128: q = ((struct timeout *)
129: dmalloc (sizeof (struct timeout), MDL));
130: if (!q)
131: log_fatal ("add_timeout: no memory!");
132: }
133: memset (q, 0, sizeof *q);
134: q -> func = where;
135: q -> ref = ref;
136: q -> unref = unref;
137: if (q -> ref)
138: (*q -> ref)(&q -> what, what, MDL);
139: else
140: q -> what = what;
141: }
142:
143: q -> when . tv_sec = when -> tv_sec;
144: q -> when . tv_usec = when -> tv_usec;
145:
146: /* Now sort this timeout into the timeout list. */
147:
148: /* Beginning of list? */
149: if (!timeouts || (timeouts -> when . tv_sec > q -> when . tv_sec) ||
150: ((timeouts -> when . tv_sec == q -> when . tv_sec) &&
151: (timeouts -> when . tv_usec > q -> when . tv_usec))) {
152: q -> next = timeouts;
153: timeouts = q;
154: return;
155: }
156:
157: /* Middle of list? */
158: for (t = timeouts; t -> next; t = t -> next) {
159: if ((t -> next -> when . tv_sec > q -> when . tv_sec) ||
160: ((t -> next -> when . tv_sec == q -> when . tv_sec) &&
161: (t -> next -> when . tv_usec > q -> when . tv_usec))) {
162: q -> next = t -> next;
163: t -> next = q;
164: return;
165: }
166: }
167:
168: /* End of list. */
169: t -> next = q;
170: q -> next = (struct timeout *)0;
171: }
172:
173: void cancel_timeout (where, what)
174: void (*where) (void *);
175: void *what;
176: {
177: struct timeout *t, *q;
178:
179: /* Look for this timeout on the list, and unlink it if we find it. */
180: t = (struct timeout *)0;
181: for (q = timeouts; q; q = q -> next) {
182: if (q -> func == where && q -> what == what) {
183: if (t)
184: t -> next = q -> next;
185: else
186: timeouts = q -> next;
187: break;
188: }
189: t = q;
190: }
191:
192: /* If we found the timeout, put it on the free list. */
193: if (q) {
194: if (q -> unref)
195: (*q -> unref) (&q -> what, MDL);
196: q -> next = free_timeouts;
197: free_timeouts = q;
198: }
199: }
200:
201: #if defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
202: void cancel_all_timeouts ()
203: {
204: struct timeout *t, *n;
205: for (t = timeouts; t; t = n) {
206: n = t -> next;
207: if (t -> unref && t -> what)
208: (*t -> unref) (&t -> what, MDL);
209: t -> next = free_timeouts;
210: free_timeouts = t;
211: }
212: }
213:
214: void relinquish_timeouts ()
215: {
216: struct timeout *t, *n;
217: for (t = free_timeouts; t; t = n) {
218: n = t -> next;
219: dfree (t, MDL);
220: }
221: }
222: #endif