?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MFC: following 2 commits:
[dragonfly.git] / contrib / dhcp-3.0 / common / options.c
blobd0d5caccca0d5386bd5dd632de2f86922b06e0be
1 /* options.c
2
3 DHCP options parsing and reassembly. */
4
5 /*
6 * Copyright (c) 2004 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 * http://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 * ``http://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 #ifndef lint
36 static char copyright[] =
37 "$Id: options.c,v 1.85.2.27 2004/12/04 00:03:18 dhankins Exp $ Copyright (c) 2004 Internet Systems Consortium. All rights reserved.\n";
38 #endif /* not lint */
39
40 #define DHCP_OPTION_DATA
41 #include "dhcpd.h"
42 #include <omapip/omapip_p.h>
43
44 struct option *vendor_cfg_option;
45
46 static void do_option_set PROTO ((pair *,
47 struct option_cache *,
48 enum statement_op));
49
50 /* Parse all available options out of the specified packet. */
51
52 int parse_options (packet)
53 struct packet *packet;
54 {
55 int i;
56 struct option_cache *op = (struct option_cache *)0;
57
58 /* Allocate a new option state. */
59 if (!option_state_allocate (&packet -> options, MDL)) {
60 packet -> options_valid = 0;
61 return 0;
62 }
63
64 /* If we don't see the magic cookie, there's nothing to parse. */
65 if (memcmp (packet -> raw -> options, DHCP_OPTIONS_COOKIE, 4)) {
66 packet -> options_valid = 0;
67 return 1;
68 }
69
70 /* Go through the options field, up to the end of the packet
71 or the End field. */
72 if (!parse_option_buffer (packet -> options,
73 &packet -> raw -> options [4],
74 (packet -> packet_length -
75 DHCP_FIXED_NON_UDP - 4),
76 &dhcp_universe))
77 return 0;
78
79 /* If we parsed a DHCP Option Overload option, parse more
80 options out of the buffer(s) containing them. */
81 if (packet -> options_valid &&
82 (op = lookup_option (&dhcp_universe, packet -> options,
83 DHO_DHCP_OPTION_OVERLOAD))) {
84 if (op -> data.data [0] & 1) {
85 if (!parse_option_buffer
86 (packet -> options,
87 (unsigned char *)packet -> raw -> file,
88 sizeof packet -> raw -> file,
89 &dhcp_universe))
90 return 0;
91 }
92 if (op -> data.data [0] & 2) {
93 if (!parse_option_buffer
94 (packet -> options,
95 (unsigned char *)packet -> raw -> sname,
96 sizeof packet -> raw -> sname,
97 &dhcp_universe))
98 return 0;
99 }
100 }
101 packet -> options_valid = 1;
102 return 1;
103 }
104
105 /* Parse options out of the specified buffer, storing addresses of option
106 values in packet -> options and setting packet -> options_valid if no
107 errors are encountered. */
108
109 int parse_option_buffer (options, buffer, length, universe)
110 struct option_state *options;
111 const unsigned char *buffer;
112 unsigned length;
113 struct universe *universe;
114 {
115 unsigned char *t;
116 const unsigned char *end = buffer + length;
117 unsigned len, offset;
118 int code;
119 struct option_cache *op = (struct option_cache *)0;
120 struct buffer *bp = (struct buffer *)0;
121
122 if (!buffer_allocate (&bp, length, MDL)) {
123 log_error ("no memory for option buffer.");
124 return 0;
125 }
126 memcpy (bp -> data, buffer, length);
127
128 for (offset = 0; buffer [offset] != DHO_END && offset < length; ) {
129 code = buffer [offset];
130 /* Pad options don't have a length - just skip them. */
131 if (code == DHO_PAD) {
132 ++offset;
133 continue;
134 }
135
136 /* Don't look for length if the buffer isn't that big. */
137 if (offset + 2 > length) {
138 len = 65536;
139 goto bogus;
140 }
141
142 /* All other fields (except end, see above) have a
143 one-byte length. */
144 len = buffer [offset + 1];
145
146 /* If the length is outrageous, the options are bad. */
147 if (offset + len + 2 > length) {
148 bogus:
149 log_error ("parse_option_buffer: option %s (%d) %s.",
150 dhcp_options [code].name, len,
151 "larger than buffer");
152 buffer_dereference (&bp, MDL);
153 return 0;
154 }
155
156 /* If the option contains an encapsulation, parse it. If
157 the parse fails, or the option isn't an encapsulation (by
158 far the most common case), or the option isn't entirely
159 an encapsulation, keep the raw data as well. */
160 if (universe -> options [code] &&
161 !((universe -> options [code] -> format [0] == 'e' ||
162 universe -> options [code] -> format [0] == 'E') &&
163 (parse_encapsulated_suboptions
164 (options, universe -> options [code],
165 buffer + offset + 2, len,
166 universe, (const char *)0)))) {
167 op = lookup_option (universe, options, code);
168 if (op) {
169 struct data_string new;
170 memset (&new, 0, sizeof new);
171 if (!buffer_allocate (&new.buffer, op -> data.len + len,
172 MDL)) {
173 log_error ("parse_option_buffer: No memory.");
174 return 0;
175 }
176 memcpy (new.buffer -> data, op -> data.data,
177 op -> data.len);
178 memcpy (&new.buffer -> data [op -> data.len],
179 &bp -> data [offset + 2], len);
180 new.len = op -> data.len + len;
181 new.data = new.buffer -> data;
182 data_string_forget (&op -> data, MDL);
183 data_string_copy (&op -> data, &new, MDL);
184 data_string_forget (&new, MDL);
185 } else {
186 save_option_buffer (universe, options, bp,
187 &bp -> data [offset + 2], len,
188 universe -> options [code], 1);
189 }
190 }
191 offset += len + 2;
192 }
193 buffer_dereference (&bp, MDL);
194 return 1;
195 }
196
197 /* If an option in an option buffer turns out to be an encapsulation,
198 figure out what to do. If we don't know how to de-encapsulate it,
199 or it's not well-formed, return zero; otherwise, return 1, indicating
200 that we succeeded in de-encapsulating it. */
201
202 struct universe *find_option_universe (struct option *eopt, const char *uname)
203 {
204 int i;
205 char *s, *t;
206 struct universe *universe = (struct universe *)0;
207
208 /* Look for the E option in the option format. */
209 s = strchr (eopt -> format, 'E');
210 if (!s) {
211 log_error ("internal encapsulation format error 1.");
212 return 0;
213 }
214 /* Look for the universe name in the option format. */
215 t = strchr (++s, '.');
216 /* If there was no trailing '.', or there's something after the
217 trailing '.', the option is bogus and we can't use it. */
218 if (!t || t [1]) {
219 log_error ("internal encapsulation format error 2.");
220 return 0;
221 }
222 if (t == s && uname) {
223 for (i = 0; i < universe_count; i++) {
224 if (!strcmp (universes [i] -> name, uname)) {
225 universe = universes [i];
226 break;
227 }
228 }
229 } else if (t != s) {
230 for (i = 0; i < universe_count; i++) {
231 if (strlen (universes [i] -> name) == t - s &&
232 !memcmp (universes [i] -> name,
233 s, (unsigned)(t - s))) {
234 universe = universes [i];
235 break;
236 }
237 }
238 }
239 return universe;
240 }
241
242 /* If an option in an option buffer turns out to be an encapsulation,
243 figure out what to do. If we don't know how to de-encapsulate it,
244 or it's not well-formed, return zero; otherwise, return 1, indicating
245 that we succeeded in de-encapsulating it. */
246
247 int parse_encapsulated_suboptions (struct option_state *options,
248 struct option *eopt,
249 const unsigned char *buffer,
250 unsigned len, struct universe *eu,
251 const char *uname)
252 {
253 int i;
254 struct universe *universe = find_option_universe (eopt, uname);
255
256 /* If we didn't find the universe, we can't do anything with it
257 right now (e.g., we can't decode vendor options until we've
258 decoded the packet and executed the scopes that it matches). */
259 if (!universe)
260 return 0;
261
262 /* If we don't have a decoding function for it, we can't decode
263 it. */
264 if (!universe -> decode)
265 return 0;
266
267 i = (*universe -> decode) (options, buffer, len, universe);
268
269 /* If there is stuff before the suboptions, we have to keep it. */
270 if (eopt -> format [0] != 'E')
271 return 0;
272 /* Otherwise, return the status of the decode function. */
273 return i;
274 }
275
276 int fqdn_universe_decode (struct option_state *options,
277 const unsigned char *buffer,
278 unsigned length, struct universe *u)
279 {
280 char *name;
281 struct buffer *bp = (struct buffer *)0;
282
283 /* FQDN options have to be at least four bytes long. */
284 if (length < 3)
285 return 0;
286
287 /* Save the contents of the option in a buffer. */
288 if (!buffer_allocate (&bp, length + 4, MDL)) {
289 log_error ("no memory for option buffer.");
290 return 0;
291 }
292 memcpy (&bp -> data [3], buffer + 1, length - 1);
293
294 if (buffer [0] & 4) /* encoded */
295 bp -> data [0] = 1;
296 else
297 bp -> data [0] = 0;
298 if (!save_option_buffer (&fqdn_universe, options, bp,
299 &bp -> data [0], 1,
300 &fqdn_options [FQDN_ENCODED], 0)) {
301 bad:
302 buffer_dereference (&bp, MDL);
303 return 0;
304 }
305
306 if (buffer [0] & 1) /* server-update */
307 bp -> data [2] = 1;
308 else
309 bp -> data [2] = 0;
310 if (buffer [0] & 2) /* no-client-update */
311 bp -> data [1] = 1;
312 else
313 bp -> data [1] = 0;
314
315 /* XXX Ideally we should store the name in DNS format, so if the
316 XXX label isn't in DNS format, we convert it to DNS format,
317 XXX rather than converting labels specified in DNS format to
318 XXX the plain ASCII representation. But that's hard, so
319 XXX not now. */
320
321 /* Not encoded using DNS format? */
322 if (!bp -> data [0]) {
323 unsigned i;
324
325 /* Some broken clients NUL-terminate this option. */
326 if (buffer [length - 1] == 0) {
327 --length;
328 bp -> data [1] = 1;
329 }
330
331 /* Determine the length of the hostname component of the
332 name. If the name contains no '.' character, it
333 represents a non-qualified label. */
334 for (i = 3; i < length && buffer [i] != '.'; i++);
335 i -= 3;
336
337 /* Note: If the client sends a FQDN, the first '.' will
338 be used as a NUL terminator for the hostname. */
339 if (i)
340 if (!save_option_buffer (&fqdn_universe, options, bp,
341 &bp -> data[5], i,
342 &fqdn_options [FQDN_HOSTNAME],
343 0))
344 goto bad;
345 /* Note: If the client sends a single label, the
346 FQDN_DOMAINNAME option won't be set. */
347 if (length > 4 + i &&
348 !save_option_buffer (&fqdn_universe, options, bp,
349 &bp -> data[6 + i], length - 4 - i,
350 &fqdn_options [FQDN_DOMAINNAME], 1))
351 goto bad;
352 /* Also save the whole name. */
353 if (length > 3)
354 if (!save_option_buffer (&fqdn_universe, options, bp,
355 &bp -> data [5], length - 3,
356 &fqdn_options [FQDN_FQDN], 1))
357 goto bad;
358 } else {
359 unsigned len;
360 unsigned total_len = 0;
361 unsigned first_len = 0;
362 int terminated = 0;
363 unsigned char *s;
364
365 s = &bp -> data[5];
366
367 while (s < &bp -> data[0] + length + 2) {
368 len = *s;
369 if (len > 63) {
370 log_info ("fancy bits in fqdn option");
371 return 0;
372 }
373 if (len == 0) {
374 terminated = 1;
375 break;
376 }
377 if (s + len > &bp -> data [0] + length + 3) {
378 log_info ("fqdn tag longer than buffer");
379 return 0;
380 }
381
382 if (first_len == 0) {
383 first_len = len;
384 }
385
386 *s = '.';
387 s += len + 1;
388 total_len += len + 1;
389 }
390
391 /* We wind up with a length that's one too many because
392 we shouldn't increment for the last label, but there's
393 no way to tell we're at the last label until we exit
394 the loop. :'*/
395 if (total_len > 0)
396 total_len--;
397
398 if (!terminated) {
399 first_len = total_len;
400 }
401
402 if (first_len > 0 &&
403 !save_option_buffer (&fqdn_universe, options, bp,
404 &bp -> data[6], first_len,
405 &fqdn_options [FQDN_HOSTNAME], 0))
406 goto bad;
407 if (total_len > 0 && first_len != total_len) {
408 if (!save_option_buffer
409 (&fqdn_universe, options, bp,
410 &bp -> data[6 + first_len], total_len - first_len,
411 &fqdn_options [FQDN_DOMAINNAME], 1))
412 goto bad;
413 }
414 if (total_len > 0)
415 if (!save_option_buffer (&fqdn_universe, options, bp,
416 &bp -> data [6], total_len,
417 &fqdn_options [FQDN_FQDN], 1))
418 goto bad;
419 }
420
421 if (!save_option_buffer (&fqdn_universe, options, bp,
422 &bp -> data [1], 1,
423 &fqdn_options [FQDN_NO_CLIENT_UPDATE], 0))
424 goto bad;
425 if (!save_option_buffer (&fqdn_universe, options, bp,
426 &bp -> data [2], 1,
427 &fqdn_options [FQDN_SERVER_UPDATE], 0))
428 goto bad;
429
430 if (!save_option_buffer (&fqdn_universe, options, bp,
431 &bp -> data [3], 1,
432 &fqdn_options [FQDN_RCODE1], 0))
433 goto bad;
434 if (!save_option_buffer (&fqdn_universe, options, bp,
435 &bp -> data [4], 1,
436 &fqdn_options [FQDN_RCODE2], 0))
437 goto bad;
438
439 buffer_dereference (&bp, MDL);
440 return 1;
441 }
442
443 /* cons options into a big buffer, and then split them out into the
444 three seperate buffers if needed. This allows us to cons up a set
445 of vendor options using the same routine. */
446
447 int cons_options (inpacket, outpacket, lease, client_state,
448 mms, in_options, cfg_options,
449 scope, overload, terminate, bootpp, prl, vuname)
450 struct packet *inpacket;
451 struct dhcp_packet *outpacket;
452 struct lease *lease;
453 struct client_state *client_state;
454 int mms;
455 struct option_state *in_options;
456 struct option_state *cfg_options;
457 struct binding_scope **scope;
458 int overload; /* Overload flags that may be set. */
459 int terminate;
460 int bootpp;
461 struct data_string *prl;
462 const char *vuname;
463 {
464 #define PRIORITY_COUNT 300
465 unsigned priority_list [PRIORITY_COUNT];
466 int priority_len;
467 unsigned char buffer [4096]; /* Really big buffer... */
468 unsigned main_buffer_size;
469 unsigned mainbufix, bufix, agentix;
470 int fileix;
471 int snameix;
472 unsigned option_size;
473 unsigned length;
474 int i;
475 struct option_cache *op;
476 struct data_string ds;
477 pair pp, *hash;
478 int need_endopt = 0;
479 int have_sso = 0;
480 int ocount = 0;
481 int ofbuf1=0, ofbuf2=0;
482
483 memset (&ds, 0, sizeof ds);
484
485 /* If there's a Maximum Message Size option in the incoming packet
486 and no alternate maximum message size has been specified, take the
487 one in the packet. */
488
489 if (inpacket &&
490 (op = lookup_option (&dhcp_universe, inpacket -> options,
491 DHO_DHCP_MAX_MESSAGE_SIZE))) {
492 evaluate_option_cache (&ds, inpacket,
493 lease, client_state, in_options,
494 cfg_options, scope, op, MDL);
495 if (ds.len >= sizeof (u_int16_t)) {
496 i = getUShort (ds.data);
497
498 if(!mms || (i < mms))
499 mms = i;
500 }
501 data_string_forget (&ds, MDL);
502 }
503
504 /* If the client has provided a maximum DHCP message size,
505 use that; otherwise, if it's BOOTP, only 64 bytes; otherwise
506 use up to the minimum IP MTU size (576 bytes). */
507 /* XXX if a BOOTP client specifies a max message size, we will
508 honor it. */
509
510 if (mms) {
511 main_buffer_size = mms - DHCP_FIXED_LEN;
512
513 /* Enforce a minimum packet size... */
514 if (main_buffer_size < (576 - DHCP_FIXED_LEN))
515 main_buffer_size = 576 - DHCP_FIXED_LEN;
516 } else if (bootpp) {
517 if (inpacket) {
518 main_buffer_size =
519 inpacket -> packet_length - DHCP_FIXED_LEN;
520 if (main_buffer_size < 64)
521 main_buffer_size = 64;
522 } else
523 main_buffer_size = 64;
524 } else
525 main_buffer_size = 576 - DHCP_FIXED_LEN;
526
527 /* Set a hard limit at the size of the output buffer. */
528 if (main_buffer_size > sizeof buffer)
529 main_buffer_size = sizeof buffer;
530
531 /* Preload the option priority list with mandatory options. */
532 priority_len = 0;
533 priority_list [priority_len++] = DHO_DHCP_MESSAGE_TYPE;
534 priority_list [priority_len++] = DHO_DHCP_SERVER_IDENTIFIER;
535 priority_list [priority_len++] = DHO_DHCP_LEASE_TIME;
536 priority_list [priority_len++] = DHO_DHCP_MESSAGE;
537 priority_list [priority_len++] = DHO_DHCP_REQUESTED_ADDRESS;
538 priority_list [priority_len++] = DHO_FQDN;
539
540 if (prl && prl -> len > 0) {
541 if ((op = lookup_option (&dhcp_universe, cfg_options,
542 DHO_SUBNET_SELECTION))) {
543 if (priority_len < PRIORITY_COUNT)
544 priority_list [priority_len++] =
545 DHO_SUBNET_SELECTION;
546 }
547
548 data_string_truncate (prl, (PRIORITY_COUNT - priority_len));
549
550 for (i = 0; i < prl -> len; i++) {
551 /* Prevent client from changing order of delivery
552 of relay agent information option. */
553 if (prl -> data [i] != DHO_DHCP_AGENT_OPTIONS)
554 priority_list [priority_len++] =
555 prl -> data [i];
556 }
557 } else {
558 /* First, hardcode some more options that ought to be
559 sent first... */
560 priority_list [priority_len++] = DHO_SUBNET_MASK;
561 priority_list [priority_len++] = DHO_ROUTERS;
562 priority_list [priority_len++] = DHO_DOMAIN_NAME_SERVERS;
563 priority_list [priority_len++] = DHO_HOST_NAME;
564
565 /* Append a list of the standard DHCP options from the
566 standard DHCP option space. Actually, if a site
567 option space hasn't been specified, we wind up
568 treating the dhcp option space as the site option
569 space, and the first for loop is skipped, because
570 it's slightly more general to do it this way,
571 taking the 1Q99 DHCP futures work into account. */
572 if (cfg_options -> site_code_min) {
573 for (i = 0; i < OPTION_HASH_SIZE; i++) {
574 hash = cfg_options -> universes [dhcp_universe.index];
575 if (hash) {
576 for (pp = hash [i]; pp; pp = pp -> cdr) {
577 op = (struct option_cache *)(pp -> car);
578 if (op -> option -> code <
579 cfg_options -> site_code_min &&
580 priority_len < PRIORITY_COUNT &&
581 (op -> option -> code !=
582 DHO_DHCP_AGENT_OPTIONS))
583 priority_list [priority_len++] =
584 op -> option -> code;
585 }
586 }
587 }
588 }
589
590 /* Now cycle through the site option space, or if there
591 is no site option space, we'll be cycling through the
592 dhcp option space. */
593 for (i = 0; i < OPTION_HASH_SIZE; i++) {
594 hash = (cfg_options -> universes
595 [cfg_options -> site_universe]);
596 if (hash)
597 for (pp = hash [i]; pp; pp = pp -> cdr) {
598 op = (struct option_cache *)(pp -> car);
599 if (op -> option -> code >=
600 cfg_options -> site_code_min &&
601 priority_len < PRIORITY_COUNT &&
602 (op -> option -> code !=
603 DHO_DHCP_AGENT_OPTIONS))
604 priority_list [priority_len++] =
605 op -> option -> code;
606 }
607 }
608
609 /* Now go through all the universes for which options
610 were set and see if there are encapsulations for
611 them; if there are, put the encapsulation options
612 on the priority list as well. */
613 for (i = 0; i < cfg_options -> universe_count; i++) {
614 if (cfg_options -> universes [i] &&
615 universes [i] -> enc_opt &&
616 priority_len < PRIORITY_COUNT &&
617 universes [i] -> enc_opt -> universe == &dhcp_universe)
618 {
619 if (universes [i] -> enc_opt -> code !=
620 DHO_DHCP_AGENT_OPTIONS)
621 priority_list [priority_len++] =
622 universes [i] -> enc_opt -> code;
623 }
624 }
625
626 /* The vendor option space can't stand on its own, so always
627 add it to the list. */
628 if (priority_len < PRIORITY_COUNT)
629 priority_list [priority_len++] =
630 DHO_VENDOR_ENCAPSULATED_OPTIONS;
631 }
632
633 /* Figure out the overload buffer offset(s). */
634 if (overload) {
635 ofbuf1 = main_buffer_size - 4;
636 if (overload == 3)
637 ofbuf2 = main_buffer_size - 4 + DHCP_FILE_LEN;
638 }
639
640 /* Copy the options into the big buffer... */
641 option_size = store_options (&ocount, buffer,
642 (main_buffer_size - 4 +
643 ((overload & 1) ? DHCP_FILE_LEN : 0) +
644 ((overload & 2) ? DHCP_SNAME_LEN : 0)),
645 inpacket, lease, client_state,
646 in_options, cfg_options, scope,
647 priority_list, priority_len,
648 ofbuf1, ofbuf2, terminate, vuname);
649 /* If store_options failed. */
650 if (option_size == 0)
651 return 0;
652 if (overload) {
653 if (ocount == 1 && (overload & 1))
654 overload = 1;
655 else if (ocount == 1 && (overload & 2))
656 overload = 2;
657 else if (ocount == 3)
658 overload = 3;
659 else
660 overload = 0;
661 }
662
663 /* Put the cookie up front... */
664 memcpy (outpacket -> options, DHCP_OPTIONS_COOKIE, 4);
665 mainbufix = 4;
666
667 /* If we're going to have to overload, store the overload
668 option at the beginning. If we can, though, just store the
669 whole thing in the packet's option buffer and leave it at
670 that. */
671 memcpy (&outpacket -> options [mainbufix],
672 buffer, option_size);
673 mainbufix += option_size;
674 if (overload) {
675 outpacket -> options [mainbufix++] = DHO_DHCP_OPTION_OVERLOAD;
676 outpacket -> options [mainbufix++] = 1;
677 outpacket -> options [mainbufix++] = overload;
678
679 if (overload & 1) {
680 memcpy (outpacket -> file,
681 &buffer [ofbuf1], DHCP_FILE_LEN);
682 }
683 if (overload & 2) {
684 if (ofbuf2) {
685 memcpy (outpacket -> sname, &buffer [ofbuf2],
686 DHCP_SNAME_LEN);
687 } else {
688 memcpy (outpacket -> sname, &buffer [ofbuf1],
689 DHCP_SNAME_LEN);
690 }
691 }
692 }
693 agentix = mainbufix;
694 if (mainbufix < main_buffer_size)
695 need_endopt = 1;
696 length = DHCP_FIXED_NON_UDP + mainbufix;
697
698 /* Now hack in the agent options if there are any. */
699 priority_list [0] = DHO_DHCP_AGENT_OPTIONS;
700 priority_len = 1;
701 agentix +=
702 store_options (0, &outpacket -> options [agentix],
703 1500 - DHCP_FIXED_LEN - agentix,
704 inpacket, lease, client_state,
705 in_options, cfg_options, scope,
706 priority_list, priority_len,
707 0, 0, 0, (char *)0);
708
709 /* Tack a DHO_END option onto the packet if we need to. */
710 if (agentix < 1500 - DHCP_FIXED_LEN && need_endopt)
711 outpacket -> options [agentix++] = DHO_END;
712
713 /* Figure out the length. */
714 length = DHCP_FIXED_NON_UDP + agentix;
715 return length;
716 }
717
718 /* Store all the requested options into the requested buffer. */
719
720 int store_options (ocount, buffer, buflen, packet, lease, client_state,
721 in_options, cfg_options, scope, priority_list, priority_len,
722 first_cutoff, second_cutoff, terminate, vuname)
723 int *ocount;
724 unsigned char *buffer;
725 unsigned buflen;
726 struct packet *packet;
727 struct lease *lease;
728 struct client_state *client_state;
729 struct option_state *in_options;
730 struct option_state *cfg_options;
731 struct binding_scope **scope;
732 unsigned *priority_list;
733 int priority_len;
734 unsigned first_cutoff, second_cutoff;
735 int terminate;
736 const char *vuname;
737 {
738 int bufix = 0, six = 0, tix = 0;
739 int i;
740 int ix;
741 int tto;
742 int bufend, sbufend;
743 struct data_string od;
744 struct option_cache *oc;
745 unsigned code;
746
747 if (first_cutoff) {
748 if (first_cutoff >= buflen)
749 log_fatal("%s:%d:store_options: Invalid first cutoff.", MDL);
750
751 bufend = first_cutoff;
752 } else
753 bufend = buflen;
754
755 if (second_cutoff) {
756 if (second_cutoff >= buflen)
757 log_fatal("%s:%d:store_options: Invalid second cutoff.", MDL);
758
759 sbufend = second_cutoff;
760 } else
761 sbufend = buflen;
762
763 memset (&od, 0, sizeof od);
764
765 /* Eliminate duplicate options in the parameter request list.
766 There's got to be some clever knuthian way to do this:
767 Eliminate all but the first occurance of a value in an array
768 of values without otherwise disturbing the order of the array. */
769 for (i = 0; i < priority_len - 1; i++) {
770 tto = 0;
771 for (ix = i + 1; ix < priority_len + tto; ix++) {
772 if (tto)
773 priority_list [ix - tto] =
774 priority_list [ix];
775 if (priority_list [i] == priority_list [ix]) {
776 tto++;
777 priority_len--;
778 }
779 }
780 }
781
782 /* Copy out the options in the order that they appear in the
783 priority list... */
784 for (i = 0; i < priority_len; i++) {
785 /* Number of bytes left to store (some may already
786 have been stored by a previous pass). */
787 unsigned length;
788 int optstart, soptstart, toptstart;
789 struct universe *u;
790 int have_encapsulation = 0;
791 struct data_string encapsulation;
792 int splitup;
793
794 memset (&encapsulation, 0, sizeof encapsulation);
795
796 /* Code for next option to try to store. */
797 code = priority_list [i];
798
799 /* Look up the option in the site option space if the code
800 is above the cutoff, otherwise in the DHCP option space. */
801 if (code >= cfg_options -> site_code_min)
802 u = universes [cfg_options -> site_universe];
803 else
804 u = &dhcp_universe;
805
806 oc = lookup_option (u, cfg_options, code);
807
808 /* It's an encapsulation, try to find the universe
809 to be encapsulated first, except that if it's a straight
810 encapsulation and the user has provided a value for the
811 encapsulation option, use the user-provided value. */
812 if (u -> options [code] &&
813 ((u -> options [code] -> format [0] == 'E' && !oc) ||
814 u -> options [code] -> format [0] == 'e')) {
815 int uix;
816 static char *s, *t;
817 struct option_cache *tmp;
818 struct data_string name;
819
820 s = strchr (u -> options [code] -> format, 'E');
821 if (s)
822 t = strchr (++s, '.');
823 if (s && t) {
824 memset (&name, 0, sizeof name);
825
826 /* A zero-length universe name means the vendor
827 option space, if one is defined. */
828 if (t == s) {
829 if (vendor_cfg_option) {
830 tmp = lookup_option (vendor_cfg_option -> universe,
831 cfg_options,
832 vendor_cfg_option -> code);
833 if (tmp)
834 evaluate_option_cache (&name, packet, lease,
835 client_state,
836 in_options,
837 cfg_options,
838 scope, tmp, MDL);
839 } else if (vuname) {
840 name.data = (unsigned char *)s;
841 name.len = strlen (s);
842 }
843 } else {
844 name.data = (unsigned char *)s;
845 name.len = t - s;
846 }
847
848 /* If we found a universe, and there are options configured
849 for that universe, try to encapsulate it. */
850 if (name.len) {
851 have_encapsulation =
852 (option_space_encapsulate
853 (&encapsulation, packet, lease, client_state,
854 in_options, cfg_options, scope, &name));
855 data_string_forget (&name, MDL);
856 }
857 }
858 }
859
860 /* In order to avoid memory leaks, we have to get to here
861 with any option cache that we allocated in tmp not being
862 referenced by tmp, and whatever option cache is referenced
863 by oc being an actual reference. lookup_option doesn't
864 generate a reference (this needs to be fixed), so the
865 preceding goop ensures that if we *didn't* generate a new
866 option cache, oc still winds up holding an actual reference. */
867
868 /* If no data is available for this option, skip it. */
869 if (!oc && !have_encapsulation) {
870 continue;
871 }
872
873 /* Find the value of the option... */
874 if (oc) {
875 evaluate_option_cache (&od, packet,
876 lease, client_state, in_options,
877 cfg_options, scope, oc, MDL);
878 if (!od.len) {
879 data_string_forget (&encapsulation, MDL);
880 data_string_forget (&od, MDL);
881 have_encapsulation = 0;
882 continue;
883 }
884 }
885
886 /* We should now have a constant length for the option. */
887 length = od.len;
888 if (have_encapsulation) {
889 length += encapsulation.len;
890 if (!od.len) {
891 data_string_copy (&od, &encapsulation, MDL);
892 data_string_forget (&encapsulation, MDL);
893 } else {
894 struct buffer *bp = (struct buffer *)0;
895 if (!buffer_allocate (&bp, length, MDL)) {
896 option_cache_dereference (&oc, MDL);
897 data_string_forget (&od, MDL);
898 data_string_forget (&encapsulation, MDL);
899 continue;
900 }
901 memcpy (&bp -> data [0], od.data, od.len);
902 memcpy (&bp -> data [od.len], encapsulation.data,
903 encapsulation.len);
904 data_string_forget (&od, MDL);
905 data_string_forget (&encapsulation, MDL);
906 od.data = &bp -> data [0];
907 buffer_reference (&od.buffer, bp, MDL);
908 buffer_dereference (&bp, MDL);
909 od.len = length;
910 od.terminated = 0;
911 }
912 }
913
914 /* Do we add a NUL? */
915 if (terminate && dhcp_options [code].format [0] == 't') {
916 length++;
917 tto = 1;
918 } else {
919 tto = 0;
920 }
921
922 /* Try to store the option. */
923
924 /* If the option's length is more than 255, we must store it
925 in multiple hunks. Store 255-byte hunks first. However,
926 in any case, if the option data will cross a buffer
927 boundary, split it across that boundary. */
928
929
930 if (length > 255)
931 splitup = 1;
932 else
933 splitup = 0;
934
935 ix = 0;
936 optstart = bufix;
937 soptstart = six;
938 toptstart = tix;
939 while (length) {
940 unsigned incr = length;
941 int consumed = 0;
942 int *pix;
943 char *base;
944
945 /* Try to fit it in the options buffer. */
946 if (!splitup &&
947 ((!six && !tix && (i == priority_len - 1) &&
948 (bufix + 2 + length < bufend)) ||
949 (bufix + 5 + length < bufend))) {
950 base = buffer;
951 pix = &bufix;
952 /* Try to fit it in the second buffer. */
953 } else if (!splitup && first_cutoff &&
954 (first_cutoff + six + 3 + length < sbufend)) {
955 base = &buffer[first_cutoff];
956 pix = &six;
957 /* Try to fit it in the third buffer. */
958 } else if (!splitup && second_cutoff &&
959 (second_cutoff + tix + 3 + length < buflen)) {
960 base = &buffer[second_cutoff];
961 pix = &tix;
962 /* Split the option up into the remaining space. */
963 } else {
964 splitup = 1;
965
966 /* Use any remaining options space. */
967 if (bufix + 6 < bufend) {
968 incr = bufend - bufix - 5;
969 base = buffer;
970 pix = &bufix;
971 /* Use any remaining first_cutoff space. */
972 } else if (first_cutoff &&
973 (first_cutoff + six + 4 < sbufend)) {
974 incr = sbufend - (first_cutoff + six) - 3;
975 base = &buffer[first_cutoff];
976 pix = &six;
977 /* Use any remaining second_cutoff space. */
978 } else if (second_cutoff &&
979 (second_cutoff + tix + 4 < buflen)) {
980 incr = buflen - (second_cutoff + tix) - 3;
981 base = &buffer[second_cutoff];
982 pix = &tix;
983 /* Give up, roll back this option. */
984 } else {
985 bufix = optstart;
986 six = soptstart;
987 tix = toptstart;
988 break;
989 }
990 }
991
992 if (incr > length)
993 incr = length;
994 if (incr > 255)
995 incr = 255;
996
997 /* Everything looks good - copy it in! */
998 base [*pix] = code;
999 base [*pix + 1] = (unsigned char)incr;
1000 if (tto && incr == length) {
1001 if (incr > 1)
1002 memcpy (base + *pix + 2,
1003 od.data + ix, (unsigned)(incr - 1));
1004 base [*pix + 2 + incr - 1] = 0;
1005 } else {
1006 memcpy (base + *pix + 2,
1007 od.data + ix, (unsigned)incr);
1008 }
1009 length -= incr;
1010 ix += incr;
1011 *pix += 2 + incr;
1012 }
1013 data_string_forget (&od, MDL);
1014 }
1015
1016 /* If we can overload, and we have, then PAD and END those spaces. */
1017 if (first_cutoff && six) {
1018 if ((first_cutoff + six + 1) < sbufend)
1019 memset (&buffer[first_cutoff + six + 1], DHO_PAD,
1020 sbufend - (first_cutoff + six + 1));
1021 else if (first_cutoff + six >= sbufend)
1022 log_fatal("Second buffer overflow in overloaded options.");
1023
1024 buffer[first_cutoff + six] = DHO_END;
1025 *ocount |= 1; /* So that caller knows there's data there. */
1026 }
1027
1028 if (second_cutoff && tix) {
1029 if (second_cutoff + tix + 1 < buflen) {
1030 memset (&buffer[second_cutoff + tix + 1], DHO_PAD,
1031 buflen - (second_cutoff + tix + 1));
1032 } else if (second_cutoff + tix >= buflen)
1033 log_fatal("Third buffer overflow in overloaded options.");
1034
1035 buffer[second_cutoff + tix] = DHO_END;
1036 *ocount |= 2; /* So that caller knows there's data there. */
1037 }
1038
1039 if ((six || tix) && (bufix + 3 > bufend))
1040 log_fatal("Not enough space for option overload option.");
1041
1042 return bufix;
1043 }
1044
1045 /* Format the specified option so that a human can easily read it. */
1046
1047 const char *pretty_print_option (option, data, len, emit_commas, emit_quotes)
1048 struct option *option;
1049 const unsigned char *data;
1050 unsigned len;
1051 int emit_commas;
1052 int emit_quotes;
1053 {
1054 static char optbuf [32768]; /* XXX */
1055 int hunksize = 0;
1056 int opthunk = 0;
1057 int hunkinc = 0;
1058 int numhunk = -1;
1059 int numelem = 0;
1060 char fmtbuf [32];
1061 struct enumeration *enumbuf [32];
1062 int i, j, k, l;
1063 char *op = optbuf;
1064 const unsigned char *dp = data;
1065 struct in_addr foo;
1066 char comma;
1067 unsigned long tval;
1068
1069 if (emit_commas)
1070 comma = ',';
1071 else
1072 comma = ' ';
1073
1074 memset (enumbuf, 0, sizeof enumbuf);
1075
1076 /* Figure out the size of the data. */
1077 for (l = i = 0; option -> format [i]; i++, l++) {
1078 if (!numhunk) {
1079 log_error ("%s: Extra codes in format string: %s",
1080 option -> name,
1081 &(option -> format [i]));
1082 break;
1083 }
1084 numelem++;
1085 fmtbuf [l] = option -> format [i];
1086 switch (option -> format [i]) {
1087 case 'a':
1088 --numelem;
1089 fmtbuf [l] = 0;
1090 numhunk = 0;
1091 break;
1092 case 'A':
1093 --numelem;
1094 fmtbuf [l] = 0;
1095 numhunk = 0;
1096 break;
1097 case 'E':
1098 /* Skip the universe name. */
1099 while (option -> format [i] &&
1100 option -> format [i] != '.')
1101 i++;
1102 case 'X':
1103 for (k = 0; k < len; k++) {
1104 if (!isascii (data [k]) ||
1105 !isprint (data [k]))
1106 break;
1107 }
1108 /* If we found no bogus characters, or the bogus
1109 character we found is a trailing NUL, it's
1110 okay to print this option as text. */
1111 if (k == len || (k + 1 == len && data [k] == 0)) {
1112 fmtbuf [l] = 't';
1113 numhunk = -2;
1114 } else {
1115 fmtbuf [l] = 'x';
1116 hunksize++;
1117 comma = ':';
1118 numhunk = 0;
1119 }
1120 fmtbuf [l + 1] = 0;
1121 break;
1122 case 'd':
1123 case 't':
1124 fmtbuf [l] = 't';
1125 fmtbuf [l + 1] = 0;
1126 numhunk = -2;
1127 break;
1128 case 'N':
1129 k = i;
1130 while (option -> format [i] &&
1131 option -> format [i] != '.')
1132 i++;
1133 enumbuf [l] =
1134 find_enumeration (&option -> format [k] + 1,
1135 i - k - 1);
1136 hunksize += 1;
1137 hunkinc = 1;
1138 break;
1139 case 'I':
1140 case 'l':
1141 case 'L':
1142 case 'T':
1143 hunksize += 4;
1144 hunkinc = 4;
1145 break;
1146 case 's':
1147 case 'S':
1148 hunksize += 2;
1149 hunkinc = 2;
1150 break;
1151 case 'b':
1152 case 'B':
1153 case 'f':
1154 hunksize++;
1155 hunkinc = 1;
1156 break;
1157 case 'e':
1158 break;
1159 case 'o':
1160 opthunk += hunkinc;
1161 break;
1162 default:
1163 log_error ("%s: garbage in format string: %s",
1164 option -> name,
1165 &(option -> format [i]));
1166 break;
1167 }
1168 }
1169
1170 /* Check for too few bytes... */
1171 if (hunksize - opthunk > len) {
1172 log_error ("%s: expecting at least %d bytes; got %d",
1173 option -> name,
1174 hunksize, len);
1175 return "<error>";
1176 }
1177 /* Check for too many bytes... */
1178 if (numhunk == -1 && hunksize < len)
1179 log_error ("%s: %d extra bytes",
1180 option -> name,
1181 len - hunksize);
1182
1183 /* If this is an array, compute its size. */
1184 if (!numhunk)
1185 numhunk = len / hunksize;
1186 /* See if we got an exact number of hunks. */
1187 if (numhunk > 0 && numhunk * hunksize < len)
1188 log_error ("%s: %d extra bytes at end of array\n",
1189 option -> name,
1190 len - numhunk * hunksize);
1191
1192 /* A one-hunk array prints the same as a single hunk. */
1193 if (numhunk < 0)
1194 numhunk = 1;
1195
1196 /* Cycle through the array (or hunk) printing the data. */
1197 for (i = 0; i < numhunk; i++) {
1198 for (j = 0; j < numelem; j++) {
1199 switch (fmtbuf [j]) {
1200 case 't':
1201 if (emit_quotes)
1202 *op++ = '"';
1203 for (; dp < data + len; dp++) {
1204 if (!isascii (*dp) ||
1205 !isprint (*dp)) {
1206 /* Skip trailing NUL. */
1207 if (dp + 1 != data + len ||
1208 *dp != 0) {
1209 sprintf (op, "\\%03o",
1210 *dp);
1211 op += 4;
1212 }
1213 } else if (*dp == '"' ||
1214 *dp == '\'' ||
1215 *dp == '$' ||
1216 *dp == '`' ||
1217 *dp == '\\') {
1218 *op++ = '\\';
1219 *op++ = *dp;
1220 } else
1221 *op++ = *dp;
1222 }
1223 if (emit_quotes)
1224 *op++ = '"';
1225 *op = 0;
1226 break;
1227 /* pretty-printing an array of enums is
1228 going to get ugly. */
1229 case 'N':
1230 if (!enumbuf [j])
1231 goto enum_as_num;
1232 for (i = 0; ;i++) {
1233 if (!enumbuf [j] -> values [i].name)
1234 goto enum_as_num;
1235 if (enumbuf [j] -> values [i].value ==
1236 *dp)
1237 break;
1238 }
1239 strcpy (op, enumbuf [j] -> values [i].name);
1240 op += strlen (op);
1241 break;
1242 case 'I':
1243 foo.s_addr = htonl (getULong (dp));
1244 strcpy (op, inet_ntoa (foo));
1245 dp += 4;
1246 break;
1247 case 'l':
1248 sprintf (op, "%ld", (long)getLong (dp));
1249 dp += 4;
1250 break;
1251 case 'T':
1252 tval = getULong (dp);
1253 if (tval == -1)
1254 sprintf (op, "%s", "infinite");
1255 else
1256 sprintf (op, "%ld", tval);
1257 break;
1258 case 'L':
1259 sprintf (op, "%ld",
1260 (unsigned long)getULong (dp));
1261 dp += 4;
1262 break;
1263 case 's':
1264 sprintf (op, "%d", (int)getShort (dp));
1265 dp += 2;
1266 break;
1267 case 'S':
1268 sprintf (op, "%d", (unsigned)getUShort (dp));
1269 dp += 2;
1270 break;
1271 case 'b':
1272 sprintf (op, "%d", *(const char *)dp++);
1273 break;
1274 case 'B':
1275 enum_as_num:
1276 sprintf (op, "%d", *dp++);
1277 break;
1278 case 'x':
1279 sprintf (op, "%x", *dp++);
1280 break;
1281 case 'f':
1282 strcpy (op, *dp++ ? "true" : "false");
1283 break;
1284 default:
1285 log_error ("Unexpected format code %c",
1286 fmtbuf [j]);
1287 }
1288 op += strlen (op);
1289 if (dp == data + len)
1290 break;
1291 if (j + 1 < numelem && comma != ':')
1292 *op++ = ' ';
1293 }
1294 if (i + 1 < numhunk) {
1295 *op++ = comma;
1296 }
1297 if (dp == data + len)
1298 break;
1299 }
1300 return optbuf;
1301 }
1302
1303 int get_option (result, universe, packet, lease, client_state,
1304 in_options, cfg_options, options, scope, code, file, line)
1305 struct data_string *result;
1306 struct universe *universe;
1307 struct packet *packet;
1308 struct lease *lease;
1309 struct client_state *client_state;
1310 struct option_state *in_options;
1311 struct option_state *cfg_options;
1312 struct option_state *options;
1313 struct binding_scope **scope;
1314 unsigned code;
1315 const char *file;
1316 int line;
1317 {
1318 struct option_cache *oc;
1319
1320 if (!universe -> lookup_func)
1321 return 0;
1322 oc = ((*universe -> lookup_func) (universe, options, code));
1323 if (!oc)
1324 return 0;
1325 if (!evaluate_option_cache (result, packet, lease, client_state,
1326 in_options, cfg_options, scope, oc,
1327 file, line))
1328 return 0;
1329 return 1;
1330 }
1331
1332 void set_option (universe, options, option, op)
1333 struct universe *universe;
1334 struct option_state *options;
1335 struct option_cache *option;
1336 enum statement_op op;
1337 {
1338 struct option_cache *oc, *noc;
1339
1340 switch (op) {
1341 case if_statement:
1342 case add_statement:
1343 case eval_statement:
1344 case break_statement:
1345 default:
1346 log_error ("bogus statement type in do_option_set.");
1347 break;
1348
1349 case default_option_statement:
1350 oc = lookup_option (universe, options,
1351 option -> option -> code);
1352 if (oc)
1353 break;
1354 save_option (universe, options, option);
1355 break;
1356
1357 case supersede_option_statement:
1358 case send_option_statement:
1359 /* Install the option, replacing any existing version. */
1360 save_option (universe, options, option);
1361 break;
1362
1363 case append_option_statement:
1364 case prepend_option_statement:
1365 oc = lookup_option (universe, options,
1366 option -> option -> code);
1367 if (!oc) {
1368 save_option (universe, options, option);
1369 break;
1370 }
1371 /* If it's not an expression, make it into one. */
1372 if (!oc -> expression && oc -> data.len) {
1373 if (!expression_allocate (&oc -> expression, MDL)) {
1374 log_error ("Can't allocate const expression.");
1375 break;
1376 }
1377 oc -> expression -> op = expr_const_data;
1378 data_string_copy
1379 (&oc -> expression -> data.const_data,
1380 &oc -> data, MDL);
1381 data_string_forget (&oc -> data, MDL);
1382 }
1383 noc = (struct option_cache *)0;
1384 if (!option_cache_allocate (&noc, MDL))
1385 break;
1386 if (op == append_option_statement) {
1387 if (!make_concat (&noc -> expression,
1388 oc -> expression,
1389 option -> expression)) {
1390 option_cache_dereference (&noc, MDL);
1391 break;
1392 }
1393 } else {
1394 if (!make_concat (&noc -> expression,
1395 option -> expression,
1396 oc -> expression)) {
1397 option_cache_dereference (&noc, MDL);
1398 break;
1399 }
1400 }
1401 noc -> option = oc -> option;
1402 save_option (universe, options, noc);
1403 option_cache_dereference (&noc, MDL);
1404 break;
1405 }
1406 }
1407
1408 struct option_cache *lookup_option (universe, options, code)
1409 struct universe *universe;
1410 struct option_state *options;
1411 unsigned code;
1412 {
1413 if (!options)
1414 return (struct option_cache *)0;
1415 if (universe -> lookup_func)
1416 return (*universe -> lookup_func) (universe, options, code);
1417 else
1418 log_error ("can't look up options in %s space.",
1419 universe -> name);
1420 return (struct option_cache *)0;
1421 }
1422
1423 struct option_cache *lookup_hashed_option (universe, options, code)
1424 struct universe *universe;
1425 struct option_state *options;
1426 unsigned code;
1427 {
1428 int hashix;
1429 pair bptr;
1430 pair *hash;
1431
1432 /* Make sure there's a hash table. */
1433 if (universe -> index >= options -> universe_count ||
1434 !(options -> universes [universe -> index]))
1435 return (struct option_cache *)0;
1436
1437 hash = options -> universes [universe -> index];
1438
1439 hashix = compute_option_hash (code);
1440 for (bptr = hash [hashix]; bptr; bptr = bptr -> cdr) {
1441 if (((struct option_cache *)(bptr -> car)) -> option -> code ==
1442 code)
1443 return (struct option_cache *)(bptr -> car);
1444 }
1445 return (struct option_cache *)0;
1446 }
1447
1448 int save_option_buffer (struct universe *universe,
1449 struct option_state *options,
1450 struct buffer *bp,
1451 unsigned char *buffer, unsigned length,
1452 struct option *option, int tp)
1453 {
1454 struct buffer *lbp = (struct buffer *)0;
1455 struct option_cache *op = (struct option_cache *)0;
1456
1457 if (!option_cache_allocate (&op, MDL)) {
1458 log_error ("No memory for option %s.%s.",
1459 universe -> name,
1460 option -> name);
1461 return 0;
1462 }
1463
1464 /* If we weren't passed a buffer in which the data are saved and
1465 refcounted, allocate one now. */
1466 if (!bp) {
1467 if (!buffer_allocate (&lbp, length, MDL)) {
1468 log_error ("no memory for option buffer.");
1469
1470 option_cache_dereference (&op, MDL);
1471 return 0;
1472 }
1473 memcpy (lbp -> data, buffer, length + tp);
1474 bp = lbp;
1475 buffer = &bp -> data [0]; /* Refer to saved buffer. */
1476 }
1477
1478 /* Reference buffer copy to option cache. */
1479 op -> data.buffer = (struct buffer *)0;
1480 buffer_reference (&op -> data.buffer, bp, MDL);
1481
1482 /* Point option cache into buffer. */
1483 op -> data.data = buffer;
1484 op -> data.len = length;
1485
1486 if (tp) {
1487 /* NUL terminate (we can get away with this because we (or
1488 the caller!) allocated one more than the buffer size, and
1489 because the byte following the end of an option is always
1490 the code of the next option, which the caller is getting
1491 out of the *original* buffer. */
1492 buffer [length] = 0;
1493 op -> data.terminated = 1;
1494 } else
1495 op -> data.terminated = 0;
1496
1497 op -> option = option;
1498
1499 /* Now store the option. */
1500 save_option (universe, options, op);
1501
1502 /* And let go of our reference. */
1503 option_cache_dereference (&op, MDL);
1504
1505 return 1;
1506 }
1507
1508 void save_option (struct universe *universe,
1509 struct option_state *options, struct option_cache *oc)
1510 {
1511 if (universe -> save_func)
1512 (*universe -> save_func) (universe, options, oc);
1513 else
1514 log_error ("can't store options in %s space.",
1515 universe -> name);
1516 }
1517
1518 void save_hashed_option (universe, options, oc)
1519 struct universe *universe;
1520 struct option_state *options;
1521 struct option_cache *oc;
1522 {
1523 int hashix;
1524 pair bptr;
1525 pair *hash = options -> universes [universe -> index];
1526
1527 if (oc -> refcnt == 0)
1528 abort ();
1529
1530 /* Compute the hash. */
1531 hashix = compute_option_hash (oc -> option -> code);
1532
1533 /* If there's no hash table, make one. */
1534 if (!hash) {
1535 hash = (pair *)dmalloc (OPTION_HASH_SIZE * sizeof *hash, MDL);
1536 if (!hash) {
1537 log_error ("no memory to store %s.%s",
1538 universe -> name, oc -> option -> name);
1539 return;
1540 }
1541 memset (hash, 0, OPTION_HASH_SIZE * sizeof *hash);
1542 options -> universes [universe -> index] = (VOIDPTR)hash;
1543 } else {
1544 /* Try to find an existing option matching the new one. */
1545 for (bptr = hash [hashix]; bptr; bptr = bptr -> cdr) {
1546 if (((struct option_cache *)
1547 (bptr -> car)) -> option -> code ==
1548 oc -> option -> code)
1549 break;
1550 }
1551
1552 /* If we find one, dereference it and put the new one
1553 in its place. */
1554 if (bptr) {
1555 option_cache_dereference
1556 ((struct option_cache **)&bptr -> car, MDL);
1557 option_cache_reference
1558 ((struct option_cache **)&bptr -> car,
1559 oc, MDL);
1560 return;
1561 }
1562 }
1563
1564 /* Otherwise, just put the new one at the head of the list. */
1565 bptr = new_pair (MDL);
1566 if (!bptr) {
1567 log_error ("No memory for option_cache reference.");
1568 return;
1569 }
1570 bptr -> cdr = hash [hashix];
1571 bptr -> car = 0;
1572 option_cache_reference ((struct option_cache **)&bptr -> car, oc, MDL);
1573 hash [hashix] = bptr;
1574 }
1575
1576 void delete_option (universe, options, code)
1577 struct universe *universe;
1578 struct option_state *options;
1579 int code;
1580 {
1581 if (universe -> delete_func)
1582 (*universe -> delete_func) (universe, options, code);
1583 else
1584 log_error ("can't delete options from %s space.",
1585 universe -> name);
1586 }
1587
1588 void delete_hashed_option (universe, options, code)
1589 struct universe *universe;
1590 struct option_state *options;
1591 int code;
1592 {
1593 int hashix;
1594 pair bptr, prev = (pair)0;
1595 pair *hash = options -> universes [universe -> index];
1596
1597 /* There may not be any options in this space. */
1598 if (!hash)
1599 return;
1600
1601 /* Try to find an existing option matching the new one. */
1602 hashix = compute_option_hash (code);
1603 for (bptr = hash [hashix]; bptr; bptr = bptr -> cdr) {
1604 if (((struct option_cache *)(bptr -> car)) -> option -> code
1605 == code)
1606 break;
1607 prev = bptr;
1608 }
1609 /* If we found one, wipe it out... */
1610 if (bptr) {
1611 if (prev)
1612 prev -> cdr = bptr -> cdr;
1613 else
1614 hash [hashix] = bptr -> cdr;
1615 option_cache_dereference
1616 ((struct option_cache **)(&bptr -> car), MDL);
1617 free_pair (bptr, MDL);
1618 }
1619 }
1620
1621 extern struct option_cache *free_option_caches; /* XXX */
1622
1623 int option_cache_dereference (ptr, file, line)
1624 struct option_cache **ptr;
1625 const char *file;
1626 int line;
1627 {
1628 if (!ptr || !*ptr) {
1629 log_error ("Null pointer in option_cache_dereference: %s(%d)",
1630 file, line);
1631 #if defined (POINTER_DEBUG)
1632 abort ();
1633 #else
1634 return 0;
1635 #endif
1636 }
1637
1638 (*ptr) -> refcnt--;
1639 rc_register (file, line, ptr, *ptr, (*ptr) -> refcnt, 1, RC_MISC);
1640 if (!(*ptr) -> refcnt) {
1641 if ((*ptr) -> data.buffer)
1642 data_string_forget (&(*ptr) -> data, file, line);
1643 if ((*ptr) -> expression)
1644 expression_dereference (&(*ptr) -> expression,
1645 file, line);
1646 if ((*ptr) -> next)
1647 option_cache_dereference (&((*ptr) -> next),
1648 file, line);
1649 /* Put it back on the free list... */
1650 (*ptr) -> expression = (struct expression *)free_option_caches;
1651 free_option_caches = *ptr;
1652 dmalloc_reuse (free_option_caches, (char *)0, 0, 0);
1653 }
1654 if ((*ptr) -> refcnt < 0) {
1655 log_error ("%s(%d): negative refcnt!", file, line);
1656 #if defined (DEBUG_RC_HISTORY)
1657 dump_rc_history (*ptr);
1658 #endif
1659 #if defined (POINTER_DEBUG)
1660 abort ();
1661 #else
1662 *ptr = (struct option_cache *)0;
1663 return 0;
1664 #endif
1665 }
1666 *ptr = (struct option_cache *)0;
1667 return 1;
1668
1669 }
1670
1671 int hashed_option_state_dereference (universe, state, file, line)
1672 struct universe *universe;
1673 struct option_state *state;
1674 const char *file;
1675 int line;
1676 {
1677 pair *heads;
1678 pair cp, next;
1679 int i;
1680
1681 /* Get the pointer to the array of hash table bucket heads. */
1682 heads = (pair *)(state -> universes [universe -> index]);
1683 if (!heads)
1684 return 0;
1685
1686 /* For each non-null head, loop through all the buckets dereferencing
1687 the attached option cache structures and freeing the buckets. */
1688 for (i = 0; i < OPTION_HASH_SIZE; i++) {
1689 for (cp = heads [i]; cp; cp = next) {
1690 next = cp -> cdr;
1691 option_cache_dereference
1692 ((struct option_cache **)&cp -> car,
1693 file, line);
1694 free_pair (cp, file, line);
1695 }
1696 }
1697
1698 dfree (heads, file, line);
1699 state -> universes [universe -> index] = (void *)0;
1700 return 1;
1701 }
1702
1703 int store_option (result, universe, packet, lease, client_state,
1704 in_options, cfg_options, scope, oc)
1705 struct data_string *result;
1706 struct universe *universe;
1707 struct packet *packet;
1708 struct lease *lease;
1709 struct client_state *client_state;
1710 struct option_state *in_options;
1711 struct option_state *cfg_options;
1712 struct binding_scope **scope;
1713 struct option_cache *oc;
1714 {
1715 struct data_string d1, d2;
1716
1717 memset (&d1, 0, sizeof d1);
1718 memset (&d2, 0, sizeof d2);
1719
1720 if (evaluate_option_cache (&d2, packet, lease, client_state,
1721 in_options, cfg_options, scope, oc, MDL)) {
1722 if (!buffer_allocate (&d1.buffer,
1723 (result -> len +
1724 universe -> length_size +
1725 universe -> tag_size + d2.len), MDL)) {
1726 data_string_forget (result, MDL);
1727 data_string_forget (&d2, MDL);
1728 return 0;
1729 }
1730 d1.data = &d1.buffer -> data [0];
1731 if (result -> len)
1732 memcpy (d1.buffer -> data,
1733 result -> data, result -> len);
1734 d1.len = result -> len;
1735 (*universe -> store_tag) (&d1.buffer -> data [d1.len],
1736 oc -> option -> code);
1737 d1.len += universe -> tag_size;
1738 (*universe -> store_length) (&d1.buffer -> data [d1.len],
1739 d2.len);
1740 d1.len += universe -> length_size;
1741 memcpy (&d1.buffer -> data [d1.len], d2.data, d2.len);
1742 d1.len += d2.len;
1743 data_string_forget (&d2, MDL);
1744 data_string_forget (result, MDL);
1745 data_string_copy (result, &d1, MDL);
1746 data_string_forget (&d1, MDL);
1747 return 1;
1748 }
1749 return 0;
1750 }
1751
1752 int option_space_encapsulate (result, packet, lease, client_state,
1753 in_options, cfg_options, scope, name)
1754 struct data_string *result;
1755 struct packet *packet;
1756 struct lease *lease;
1757 struct client_state *client_state;
1758 struct option_state *in_options;
1759 struct option_state *cfg_options;
1760 struct binding_scope **scope;
1761 struct data_string *name;
1762 {
1763 struct universe *u;
1764
1765 u = (struct universe *)0;
1766 universe_hash_lookup (&u, universe_hash,
1767 (const char *)name -> data, name -> len, MDL);
1768 if (!u)
1769 return 0;
1770
1771 if (u -> encapsulate)
1772 return (*u -> encapsulate) (result, packet, lease,
1773 client_state,
1774 in_options, cfg_options, scope, u);
1775 log_error ("encapsulation requested for %s with no support.",
1776 name -> data);
1777 return 0;
1778 }
1779
1780 int hashed_option_space_encapsulate (result, packet, lease, client_state,
1781 in_options, cfg_options, scope, universe)
1782 struct data_string *result;
1783 struct packet *packet;
1784 struct lease *lease;
1785 struct client_state *client_state;
1786 struct option_state *in_options;
1787 struct option_state *cfg_options;
1788 struct binding_scope **scope;
1789 struct universe *universe;
1790 {
1791 pair p, *hash;
1792 int status;
1793 int i;
1794
1795 if (universe -> index >= cfg_options -> universe_count)
1796 return 0;
1797
1798 hash = cfg_options -> universes [universe -> index];
1799 if (!hash)
1800 return 0;
1801
1802 status = 0;
1803 for (i = 0; i < OPTION_HASH_SIZE; i++) {
1804 for (p = hash [i]; p; p = p -> cdr) {
1805 if (store_option (result, universe, packet,
1806 lease, client_state, in_options,
1807 cfg_options, scope,
1808 (struct option_cache *)p -> car))
1809 status = 1;
1810 }
1811 }
1812
1813 return status;
1814 }
1815
1816 int nwip_option_space_encapsulate (result, packet, lease, client_state,
1817 in_options, cfg_options, scope, universe)
1818 struct data_string *result;
1819 struct packet *packet;
1820 struct lease *lease;
1821 struct client_state *client_state;
1822 struct option_state *in_options;
1823 struct option_state *cfg_options;
1824 struct binding_scope **scope;
1825 struct universe *universe;
1826 {
1827 pair ocp;
1828 int status;
1829 int i;
1830 static struct option_cache *no_nwip;
1831 struct data_string ds;
1832 struct option_chain_head *head;
1833
1834 if (universe -> index >= cfg_options -> universe_count)
1835 return 0;
1836 head = ((struct option_chain_head *)
1837 cfg_options -> universes [fqdn_universe.index]);
1838 if (!head)
1839 return 0;
1840
1841 status = 0;
1842 for (ocp = head -> first; ocp; ocp = ocp -> cdr) {
1843 struct option_cache *oc = (struct option_cache *)(ocp -> car);
1844 if (store_option (result, universe, packet,
1845 lease, client_state, in_options,
1846 cfg_options, scope,
1847 (struct option_cache *)ocp -> car))
1848 status = 1;
1849 }
1850
1851 /* If there's no data, the nwip suboption is supposed to contain
1852 a suboption saying there's no data. */
1853 if (!status) {
1854 if (!no_nwip) {
1855 static unsigned char nni [] = { 1, 0 };
1856 memset (&ds, 0, sizeof ds);
1857 ds.data = nni;
1858 ds.len = 2;
1859 if (option_cache_allocate (&no_nwip, MDL))
1860 data_string_copy (&no_nwip -> data, &ds, MDL);
1861 no_nwip -> option = nwip_universe.options [1];
1862 }
1863 if (no_nwip) {
1864 if (store_option (result, universe, packet, lease,
1865 client_state, in_options,
1866 cfg_options, scope, no_nwip))
1867 status = 1;
1868 }
1869 } else {
1870 memset (&ds, 0, sizeof ds);
1871
1872 /* If we have nwip options, the first one has to be the
1873 nwip-exists-in-option-area option. */
1874 if (!buffer_allocate (&ds.buffer, result -> len + 2, MDL)) {
1875 data_string_forget (result, MDL);
1876 return 0;
1877 }
1878 ds.data = &ds.buffer -> data [0];
1879 ds.buffer -> data [0] = 2;
1880 ds.buffer -> data [1] = 0;
1881 memcpy (&ds.buffer -> data [2], result -> data, result -> len);
1882 data_string_forget (result, MDL);
1883 data_string_copy (result, &ds, MDL);
1884 data_string_forget (&ds, MDL);
1885 }
1886
1887 return status;
1888 }
1889
1890 int fqdn_option_space_encapsulate (result, packet, lease, client_state,
1891 in_options, cfg_options, scope, universe)
1892 struct data_string *result;
1893 struct packet *packet;
1894 struct lease *lease;
1895 struct client_state *client_state;
1896 struct option_state *in_options;
1897 struct option_state *cfg_options;
1898 struct binding_scope **scope;
1899 struct universe *universe;
1900 {
1901 pair ocp;
1902 struct data_string results [FQDN_SUBOPTION_COUNT + 1];
1903 unsigned i;
1904 unsigned len;
1905 struct buffer *bp = (struct buffer *)0;
1906 struct option_chain_head *head;
1907
1908 /* If there's no FQDN universe, don't encapsulate. */
1909 if (fqdn_universe.index >= cfg_options -> universe_count)
1910 return 0;
1911 head = ((struct option_chain_head *)
1912 cfg_options -> universes [fqdn_universe.index]);
1913 if (!head)
1914 return 0;
1915
1916 /* Figure out the values of all the suboptions. */
1917 memset (results, 0, sizeof results);
1918 for (ocp = head -> first; ocp; ocp = ocp -> cdr) {
1919 struct option_cache *oc = (struct option_cache *)(ocp -> car);
1920 if (oc -> option -> code > FQDN_SUBOPTION_COUNT)
1921 continue;
1922 evaluate_option_cache (&results [oc -> option -> code],
1923 packet, lease, client_state, in_options,
1924 cfg_options, scope, oc, MDL);
1925 }
1926 len = 4 + results [FQDN_FQDN].len;
1927 /* Save the contents of the option in a buffer. */
1928 if (!buffer_allocate (&bp, len, MDL)) {
1929 log_error ("no memory for option buffer.");
1930 return 0;
1931 }
1932 buffer_reference (&result -> buffer, bp, MDL);
1933 result -> len = 3;
1934 result -> data = &bp -> data [0];
1935
1936 memset (&bp -> data [0], 0, len);
1937 if (results [FQDN_NO_CLIENT_UPDATE].len &&
1938 results [FQDN_NO_CLIENT_UPDATE].data [0])
1939 bp -> data [0] |= 2;
1940 if (results [FQDN_SERVER_UPDATE].len &&
1941 results [FQDN_SERVER_UPDATE].data [0])
1942 bp -> data [0] |= 1;
1943 if (results [FQDN_RCODE1].len)
1944 bp -> data [1] = results [FQDN_RCODE1].data [0];
1945 if (results [FQDN_RCODE2].len)
1946 bp -> data [2] = results [FQDN_RCODE2].data [0];
1947
1948 if (results [FQDN_ENCODED].len &&
1949 results [FQDN_ENCODED].data [0]) {
1950 unsigned char *out;
1951 int i;
1952 bp -> data [0] |= 4;
1953 out = &bp -> data [3];
1954 if (results [FQDN_FQDN].len) {
1955 i = 0;
1956 while (i < results [FQDN_FQDN].len) {
1957 int j;
1958 for (j = i; ('.' !=
1959 results [FQDN_FQDN].data [j]) &&
1960 j < results [FQDN_FQDN].len; j++)
1961 ;
1962 *out++ = j - i;
1963 memcpy (out, &results [FQDN_FQDN].data [i],
1964 (unsigned)(j - i));
1965 out += j - i;
1966 i = j;
1967 if (results [FQDN_FQDN].data [j] == '.')
1968 i++;
1969 }
1970 if ((results [FQDN_FQDN].data
1971 [results [FQDN_FQDN].len - 1] == '.'))
1972 *out++ = 0;
1973 result -> len = out - result -> data;
1974 result -> terminated = 0;
1975 }
1976 } else {
1977 if (results [FQDN_FQDN].len) {
1978 memcpy (&bp -> data [3], results [FQDN_FQDN].data,
1979 results [FQDN_FQDN].len);
1980 result -> len += results [FQDN_FQDN].len;
1981 result -> terminated = 0;
1982 }
1983 }
1984 for (i = 1; i <= FQDN_SUBOPTION_COUNT; i++) {
1985 if (results [i].len)
1986 data_string_forget (&results [i], MDL);
1987 }
1988 buffer_dereference (&bp, MDL);
1989 return 1;
1990 }
1991
1992 void option_space_foreach (struct packet *packet, struct lease *lease,
1993 struct client_state *client_state,
1994 struct option_state *in_options,
1995 struct option_state *cfg_options,
1996 struct binding_scope **scope,
1997 struct universe *u, void *stuff,
1998 void (*func) (struct option_cache *,
1999 struct packet *,
2000 struct lease *, struct client_state *,
2001 struct option_state *,
2002 struct option_state *,
2003 struct binding_scope **,
2004 struct universe *, void *))
2005 {
2006 if (u -> foreach)
2007 (*u -> foreach) (packet, lease, client_state, in_options,
2008 cfg_options, scope, u, stuff, func);
2009 }
2010
2011 void suboption_foreach (struct packet *packet, struct lease *lease,
2012 struct client_state *client_state,
2013 struct option_state *in_options,
2014 struct option_state *cfg_options,
2015 struct binding_scope **scope,
2016 struct universe *u, void *stuff,
2017 void (*func) (struct option_cache *,
2018 struct packet *,
2019 struct lease *, struct client_state *,
2020 struct option_state *,
2021 struct option_state *,
2022 struct binding_scope **,
2023 struct universe *, void *),
2024 struct option_cache *oc,
2025 const char *vsname)
2026 {
2027 struct universe *universe = find_option_universe (oc -> option,
2028 vsname);
2029 int i;
2030
2031 if (universe -> foreach)
2032 (*universe -> foreach) (packet, lease, client_state,
2033 in_options, cfg_options,
2034 scope, universe, stuff, func);
2035 }
2036
2037 void hashed_option_space_foreach (struct packet *packet, struct lease *lease,
2038 struct client_state *client_state,
2039 struct option_state *in_options,
2040 struct option_state *cfg_options,
2041 struct binding_scope **scope,
2042 struct universe *u, void *stuff,
2043 void (*func) (struct option_cache *,
2044 struct packet *,
2045 struct lease *,
2046 struct client_state *,
2047 struct option_state *,
2048 struct option_state *,
2049 struct binding_scope **,
2050 struct universe *, void *))
2051 {
2052 pair *hash;
2053 int i;
2054 struct option_cache *oc;
2055
2056 if (cfg_options -> universe_count <= u -> index)
2057 return;
2058
2059 hash = cfg_options -> universes [u -> index];
2060 if (!hash)
2061 return;
2062 for (i = 0; i < OPTION_HASH_SIZE; i++) {
2063 pair p;
2064 /* XXX save _all_ options! XXX */
2065 for (p = hash [i]; p; p = p -> cdr) {
2066 oc = (struct option_cache *)p -> car;
2067 (*func) (oc, packet, lease, client_state,
2068 in_options, cfg_options, scope, u, stuff);
2069 }
2070 }
2071 }
2072
2073 void save_linked_option (universe, options, oc)
2074 struct universe *universe;
2075 struct option_state *options;
2076 struct option_cache *oc;
2077 {
2078 pair *tail;
2079 pair np = (pair )0;
2080 struct option_chain_head *head;
2081
2082 if (universe -> index >= options -> universe_count)
2083 return;
2084 head = ((struct option_chain_head *)
2085 options -> universes [universe -> index]);
2086 if (!head) {
2087 if (!option_chain_head_allocate (((struct option_chain_head **)
2088 &options -> universes
2089 [universe -> index]), MDL))
2090 return;
2091 head = ((struct option_chain_head *)
2092 options -> universes [universe -> index]);
2093 }
2094
2095 /* Find the tail of the list. */
2096 for (tail = &head -> first; *tail; tail = &((*tail) -> cdr)) {
2097 if (oc -> option ==
2098 ((struct option_cache *)((*tail) -> car)) -> option) {
2099 option_cache_dereference ((struct option_cache **)
2100 (&(*tail) -> car), MDL);
2101 option_cache_reference ((struct option_cache **)
2102 (&(*tail) -> car), oc, MDL);
2103 return;
2104 }
2105 }
2106
2107 *tail = cons (0, 0);
2108 if (*tail) {
2109 option_cache_reference ((struct option_cache **)
2110 (&(*tail) -> car), oc, MDL);
2111 }
2112 }
2113
2114 int linked_option_space_encapsulate (result, packet, lease, client_state,
2115 in_options, cfg_options, scope, universe)
2116 struct data_string *result;
2117 struct packet *packet;
2118 struct lease *lease;
2119 struct client_state *client_state;
2120 struct option_state *in_options;
2121 struct option_state *cfg_options;
2122 struct binding_scope **scope;
2123 struct universe *universe;
2124 {
2125 int status;
2126 pair oc;
2127 struct option_chain_head *head;
2128
2129 if (universe -> index >= cfg_options -> universe_count)
2130 return 0;
2131 head = ((struct option_chain_head *)
2132 cfg_options -> universes [universe -> index]);
2133 if (!head)
2134 return 0;
2135
2136 status = 0;
2137 for (oc = head -> first; oc; oc = oc -> cdr) {
2138 if (store_option (result, universe, packet,
2139 lease, client_state, in_options, cfg_options,
2140 scope, (struct option_cache *)(oc -> car)))
2141 status = 1;
2142 }
2143
2144 return status;
2145 }
2146
2147 void delete_linked_option (universe, options, code)
2148 struct universe *universe;
2149 struct option_state *options;
2150 int code;
2151 {
2152 pair *tail, tmp = (pair)0;
2153 struct option_chain_head *head;
2154
2155 if (universe -> index >= options -> universe_count)
2156 return;
2157 head = ((struct option_chain_head *)
2158 options -> universes [universe -> index]);
2159 if (!head)
2160 return;
2161
2162 for (tail = &head -> first; *tail; tail = &((*tail) -> cdr)) {
2163 if (code ==
2164 ((struct option_cache *)(*tail) -> car) -> option -> code)
2165 {
2166 tmp = (*tail) -> cdr;
2167 option_cache_dereference ((struct option_cache **)
2168 (&(*tail) -> car), MDL);
2169 dfree (*tail, MDL);
2170 (*tail) = tmp;
2171 break;
2172 }
2173 }
2174 }
2175
2176 struct option_cache *lookup_linked_option (universe, options, code)
2177 struct universe *universe;
2178 struct option_state *options;
2179 unsigned code;
2180 {
2181 pair oc;
2182 struct option_chain_head *head;
2183
2184 if (universe -> index >= options -> universe_count)
2185 return 0;
2186 head = ((struct option_chain_head *)
2187 options -> universes [universe -> index]);
2188 if (!head)
2189 return 0;
2190
2191 for (oc = head -> first; oc; oc = oc -> cdr) {
2192 if (code ==
2193 ((struct option_cache *)(oc -> car)) -> option -> code) {
2194 return (struct option_cache *)(oc -> car);
2195 }
2196 }
2197
2198 return (struct option_cache *)0;
2199 }
2200
2201 int linked_option_state_dereference (universe, state, file, line)
2202 struct universe *universe;
2203 struct option_state *state;
2204 const char *file;
2205 int line;
2206 {
2207 return (option_chain_head_dereference
2208 ((struct option_chain_head **)
2209 (&state -> universes [universe -> index]), MDL));
2210 }
2211
2212 void linked_option_space_foreach (struct packet *packet, struct lease *lease,
2213 struct client_state *client_state,
2214 struct option_state *in_options,
2215 struct option_state *cfg_options,
2216 struct binding_scope **scope,
2217 struct universe *u, void *stuff,
2218 void (*func) (struct option_cache *,
2219 struct packet *,
2220 struct lease *,
2221 struct client_state *,
2222 struct option_state *,
2223 struct option_state *,
2224 struct binding_scope **,
2225 struct universe *, void *))
2226 {
2227 pair car;
2228 struct option_chain_head *head;
2229
2230 if (u -> index >= cfg_options -> universe_count)
2231 return;
2232 head = ((struct option_chain_head *)
2233 cfg_options -> universes [u -> index]);
2234 if (!head)
2235 return;
2236 for (car = head -> first; car; car = car -> cdr) {
2237 (*func) ((struct option_cache *)(car -> car),
2238 packet, lease, client_state,
2239 in_options, cfg_options, scope, u, stuff);
2240 }
2241 }
2242
2243 void do_packet (interface, packet, len, from_port, from, hfrom)
2244 struct interface_info *interface;
2245 struct dhcp_packet *packet;
2246 unsigned len;
2247 unsigned int from_port;
2248 struct iaddr from;
2249 struct hardware *hfrom;
2250 {
2251 int i;
2252 struct option_cache *op;
2253 struct packet *decoded_packet;
2254 #if defined (DEBUG_MEMORY_LEAKAGE)
2255 unsigned long previous_outstanding = dmalloc_outstanding;
2256 #endif
2257
2258 #if defined (TRACING)
2259 trace_inpacket_stash (interface, packet, len, from_port, from, hfrom);
2260 #endif
2261
2262 decoded_packet = (struct packet *)0;
2263 if (!packet_allocate (&decoded_packet, MDL)) {
2264 log_error ("do_packet: no memory for incoming packet!");
2265 return;
2266 }
2267 decoded_packet -> raw = packet;
2268 decoded_packet -> packet_length = len;
2269 decoded_packet -> client_port = from_port;
2270 decoded_packet -> client_addr = from;
2271 interface_reference (&decoded_packet -> interface, interface, MDL);
2272 decoded_packet -> haddr = hfrom;
2273
2274 if (packet -> hlen > sizeof packet -> chaddr) {
2275 packet_dereference (&decoded_packet, MDL);
2276 log_info ("Discarding packet with bogus hlen.");
2277 return;
2278 }
2279
2280 /* If there's an option buffer, try to parse it. */
2281 if (decoded_packet -> packet_length >= DHCP_FIXED_NON_UDP + 4) {
2282 if (!parse_options (decoded_packet)) {
2283 if (decoded_packet -> options)
2284 option_state_dereference
2285 (&decoded_packet -> options, MDL);
2286 packet_dereference (&decoded_packet, MDL);
2287 return;
2288 }
2289
2290 if (decoded_packet -> options_valid &&
2291 (op = lookup_option (&dhcp_universe,
2292 decoded_packet -> options,
2293 DHO_DHCP_MESSAGE_TYPE))) {
2294 struct data_string dp;
2295 memset (&dp, 0, sizeof dp);
2296 evaluate_option_cache (&dp, decoded_packet,
2297 (struct lease *)0,
2298 (struct client_state *)0,
2299 decoded_packet -> options,
2300 (struct option_state *)0,
2301 (struct binding_scope **)0,
2302 op, MDL);
2303 if (dp.len > 0)
2304 decoded_packet -> packet_type = dp.data [0];
2305 else
2306 decoded_packet -> packet_type = 0;
2307 data_string_forget (&dp, MDL);
2308 }
2309 }
2310
2311 if (decoded_packet -> packet_type)
2312 dhcp (decoded_packet);
2313 else
2314 bootp (decoded_packet);
2315
2316 /* If the caller kept the packet, they'll have upped the refcnt. */
2317 packet_dereference (&decoded_packet, MDL);
2318
2319 #if defined (DEBUG_MEMORY_LEAKAGE)
2320 log_info ("generation %ld: %ld new, %ld outstanding, %ld long-term",
2321 dmalloc_generation,
2322 dmalloc_outstanding - previous_outstanding,
2323 dmalloc_outstanding, dmalloc_longterm);
2324 #endif
2325 #if defined (DEBUG_MEMORY_LEAKAGE)
2326 dmalloc_dump_outstanding ();
2327 #endif
2328 #if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
2329 dump_rc_history (0);
2330 #endif
2331 }
2332
DragonFly BSD