?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated PCI IDs to latest snapshot.
[tangerine.git] / workbench / network / stacks / AROSTCP / dhcp / server / confpars.c
blob3dc6055f6d4656b745f242e4b752279bcda64d48
1 /* confpars.c
2
3 Parser for dhcpd config file... */
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$ Copyright (c) 2004 Internet Systems Consortium. All rights reserved.\n";
38 #endif /* not lint */
39
40 #include "dhcpd.h"
41
42 static TIME parsed_time;
43
44 #if defined (TRACING)
45 trace_type_t *trace_readconf_type;
46 trace_type_t *trace_readleases_type;
47
48 void parse_trace_setup ()
49 {
50 trace_readconf_type = trace_type_register ("readconf", (void *)0,
51 trace_conf_input,
52 trace_conf_stop, MDL);
53 trace_readleases_type = trace_type_register ("readleases", (void *)0,
54 trace_conf_input,
55 trace_conf_stop, MDL);
56 }
57 #endif
58
59 /* conf-file :== parameters declarations END_OF_FILE
60 parameters :== <nil> | parameter | parameters parameter
61 declarations :== <nil> | declaration | declarations declaration */
62
63 isc_result_t readconf ()
64 {
65 return read_conf_file (path_dhcpd_conf, root_group, ROOT_GROUP, 0);
66 }
67
68 isc_result_t read_conf_file (const char *filename, struct group *group,
69 int group_type, int leasep)
70 {
71 int file;
72 struct parse *cfile;
73 isc_result_t status;
74 #if defined (TRACING)
75 char *fbuf, *dbuf;
76 off_t flen;
77 int result;
78 unsigned tflen, ulen;
79 trace_type_t *ttype;
80
81 if (leasep)
82 ttype = trace_readleases_type;
83 else
84 ttype = trace_readconf_type;
85
86 /* If we're in playback, we need to snarf the contents of the
87 named file out of the playback file rather than trying to
88 open and read it. */
89 if (trace_playback ()) {
90 dbuf = (char *)0;
91 tflen = 0;
92 status = trace_get_file (ttype, filename, &tflen, &dbuf);
93 if (status != ISC_R_SUCCESS)
94 return status;
95 ulen = tflen;
96
97 /* What we get back is filename\0contents, where contents is
98 terminated just by the length. So we figure out the length
99 of the filename, and subtract that and the NUL from the
100 total length to get the length of the contents of the file.
101 We make fbuf a pointer to the contents of the file, and
102 leave dbuf as it is so we can free it later. */
103 tflen = strlen (dbuf);
104 ulen = ulen - tflen - 1;
105 fbuf = dbuf + tflen + 1;
106 goto memfile;
107 }
108 #endif
109
110 if ((file = open (filename, O_RDONLY)) < 0) {
111 if (leasep) {
112 log_error ("Can't open lease database %s: %m --",
113 path_dhcpd_db);
114 log_error (" check for failed database %s!",
115 "rewrite attempt");
116 log_error ("Please read the dhcpd.leases manual%s",
117 " page if you");
118 log_fatal ("don't know what to do about this.");
119 } else {
120 log_fatal ("Can't open %s: %m", filename);
121 }
122 }
123
124 cfile = (struct parse *)0;
125 #if defined (TRACING)
126 flen = lseek (file, (off_t)0, SEEK_END);
127 if (flen < 0) {
128 boom:
129 log_fatal ("Can't lseek on %s: %m", filename);
130 }
131 if (lseek (file, (off_t)0, SEEK_SET) < 0)
132 goto boom;
133 /* Can't handle files greater than 2^31-1. */
134 if (flen > 0x7FFFFFFFUL)
135 log_fatal ("%s: file is too long to buffer.", filename);
136 ulen = flen;
137
138 /* Allocate a buffer that will be what's written to the tracefile,
139 and also will be what we parse from. */
140 tflen = strlen (filename);
141 dbuf = dmalloc (ulen + tflen + 1, MDL);
142 if (!dbuf)
143 log_fatal ("No memory for %s (%d bytes)",
144 filename, ulen);
145
146 /* Copy the name into the beginning, nul-terminated. */
147 strcpy (dbuf, filename);
148
149 /* Load the file in after the NUL. */
150 fbuf = dbuf + tflen + 1;
151 result = read (file, fbuf, ulen);
152 if (result < 0)
153 log_fatal ("Can't read in %s: %m", filename);
154 if (result != ulen)
155 log_fatal ("%s: short read of %d bytes instead of %d.",
156 filename, ulen, result);
157 close (file);
158 memfile:
159 /* If we're recording, write out the filename and file contents. */
160 if (trace_record ())
161 trace_write_packet (ttype, ulen + tflen + 1, dbuf, MDL);
162 new_parse (&cfile, -1, fbuf, ulen, filename, 0); /* XXX */
163 #else
164 new_parse (&cfile, file, (char *)0, 0, filename, 0);
165 close (file);
166 #endif
167 if (leasep)
168 status = lease_file_subparse (cfile);
169 else
170 status = conf_file_subparse (cfile, group, group_type);
171 end_parse (&cfile);
172 #if defined (TRACING)
173 dfree (dbuf, MDL);
174 #endif
175 return status;
176 }
177
178 #if defined (TRACING)
179 void trace_conf_input (trace_type_t *ttype, unsigned len, char *data)
180 {
181 char *fbuf;
182 unsigned flen;
183 unsigned tflen;
184 struct parse *cfile = (struct parse *)0;
185 static int postconf_initialized;
186 static int leaseconf_initialized;
187
188 /* Do what's done above, except that we don't have to read in the
189 data, because it's already been read for us. */
190 tflen = strlen (data);
191 flen = len - tflen - 1;
192 fbuf = data + tflen + 1;
193
194 /* If we're recording, write out the filename and file contents. */
195 if (trace_record ())
196 trace_write_packet (ttype, len, data, MDL);
197 new_parse (&cfile, -1, fbuf, flen, data, 0);
198 if (ttype == trace_readleases_type)
199 lease_file_subparse (cfile);
200 else
201 conf_file_subparse (cfile, root_group, ROOT_GROUP);
202 end_parse (&cfile);
203
204 /* Postconfiguration needs to be done after the config file
205 has been loaded. */
206 if (!postconf_initialized && ttype == trace_readconf_type) {
207 postconf_initialization (0);
208 postconf_initialized = 1;
209 }
210
211 if (!leaseconf_initialized && ttype == trace_readleases_type) {
212 db_startup (0);
213 leaseconf_initialized = 1;
214 postdb_startup ();
215 }
216 }
217
218 void trace_conf_stop (trace_type_t *ttype) { }
219 #endif
220
221 /* conf-file :== parameters declarations END_OF_FILE
222 parameters :== <nil> | parameter | parameters parameter
223 declarations :== <nil> | declaration | declarations declaration */
224
225 isc_result_t conf_file_subparse (struct parse *cfile, struct group *group,
226 int group_type)
227 {
228 const char *val;
229 enum dhcp_token token;
230 int declaration = 0;
231 int status;
232
233 do {
234 token = peek_token (&val, (unsigned *)0, cfile);
235 if (token == END_OF_FILE)
236 break;
237 declaration = parse_statement (cfile, group, group_type,
238 (struct host_decl *)0,
239 declaration);
240 } while (1);
241 token = next_token (&val, (unsigned *)0, cfile);
242
243 status = cfile -> warnings_occurred ? ISC_R_BADPARSE : ISC_R_SUCCESS;
244 return status;
245 }
246
247 /* lease-file :== lease-declarations END_OF_FILE
248 lease-statments :== <nil>
249 | lease-declaration
250 | lease-declarations lease-declaration */
251
252 isc_result_t lease_file_subparse (struct parse *cfile)
253 {
254 const char *val;
255 enum dhcp_token token;
256 isc_result_t status;
257
258 do {
259 token = next_token (&val, (unsigned *)0, cfile);
260 if (token == END_OF_FILE)
261 break;
262 if (token == LEASE) {
263 struct lease *lease = (struct lease *)0;
264 if (parse_lease_declaration (&lease, cfile)) {
265 enter_lease (lease);
266 lease_dereference (&lease, MDL);
267 } else
268 parse_warn (cfile,
269 "possibly corrupt lease file");
270 } else if (token == HOST) {
271 parse_host_declaration (cfile, root_group);
272 } else if (token == GROUP) {
273 parse_group_declaration (cfile, root_group);
274 #if defined (FAILOVER_PROTOCOL)
275 } else if (token == FAILOVER) {
276 parse_failover_state_declaration
277 (cfile, (dhcp_failover_state_t *)0);
278 #endif
279 } else {
280 log_error ("Corrupt lease file - possible data loss!");
281 skip_to_semi (cfile);
282 }
283
284 } while (1);
285
286 status = cfile -> warnings_occurred ? ISC_R_BADPARSE : ISC_R_SUCCESS;
287 return status;
288 }
289
290 /* statement :== parameter | declaration
291
292 parameter :== timestamp
293 | DEFAULT_LEASE_TIME lease_time
294 | MAX_LEASE_TIME lease_time
295 | DYNAMIC_BOOTP_LEASE_CUTOFF date
296 | DYNAMIC_BOOTP_LEASE_LENGTH lease_time
297 | BOOT_UNKNOWN_CLIENTS boolean
298 | ONE_LEASE_PER_CLIENT boolean
299 | GET_LEASE_HOSTNAMES boolean
300 | USE_HOST_DECL_NAME boolean
301 | NEXT_SERVER ip-addr-or-hostname SEMI
302 | option_parameter
303 | SERVER-IDENTIFIER ip-addr-or-hostname SEMI
304 | FILENAME string-parameter
305 | SERVER_NAME string-parameter
306 | hardware-parameter
307 | fixed-address-parameter
308 | ALLOW allow-deny-keyword
309 | DENY allow-deny-keyword
310 | USE_LEASE_ADDR_FOR_DEFAULT_ROUTE boolean
311 | AUTHORITATIVE
312 | NOT AUTHORITATIVE
313
314 declaration :== host-declaration
315 | group-declaration
316 | shared-network-declaration
317 | subnet-declaration
318 | VENDOR_CLASS class-declaration
319 | USER_CLASS class-declaration
320 | RANGE address-range-declaration */
321
322 int parse_statement (cfile, group, type, host_decl, declaration)
323 struct parse *cfile;
324 struct group *group;
325 int type;
326 struct host_decl *host_decl;
327 int declaration;
328 {
329 enum dhcp_token token;
330 const char *val;
331 struct shared_network *share;
332 char *t, *n;
333 struct expression *expr;
334 struct data_string data;
335 struct hardware hardware;
336 struct executable_statement *et, *ep;
337 struct option *option;
338 struct option_cache *cache;
339 int lose;
340 struct data_string key_id;
341 int known;
342 isc_result_t status;
343
344 token = peek_token (&val, (unsigned *)0, cfile);
345
346 switch (token) {
347 case INCLUDE:
348 next_token (&val, (unsigned *)0, cfile);
349 token = next_token (&val, (unsigned *)0, cfile);
350 if (token != STRING) {
351 parse_warn (cfile, "filename string expected.");
352 skip_to_semi (cfile);
353 } else {
354 status = read_conf_file (val, group, type, 0);
355 if (status != ISC_R_SUCCESS)
356 parse_warn (cfile, "%s: bad parse.", val);
357 parse_semi (cfile);
358 }
359 return 1;
360
361 case HOST:
362 next_token (&val, (unsigned *)0, cfile);
363 if (type != HOST_DECL && type != CLASS_DECL)
364 parse_host_declaration (cfile, group);
365 else {
366 parse_warn (cfile,
367 "host declarations not allowed here.");
368 skip_to_semi (cfile);
369 }
370 return 1;
371
372 case GROUP:
373 next_token (&val, (unsigned *)0, cfile);
374 if (type != HOST_DECL && type != CLASS_DECL)
375 parse_group_declaration (cfile, group);
376 else {
377 parse_warn (cfile,
378 "group declarations not allowed here.");
379 skip_to_semi (cfile);
380 }
381 return 1;
382
383 case TIMESTAMP:
384 next_token (&val, (unsigned *)0, cfile);
385 parsed_time = parse_timestamp (cfile);
386 break;
387
388 case SHARED_NETWORK:
389 next_token (&val, (unsigned *)0, cfile);
390 if (type == SHARED_NET_DECL ||
391 type == HOST_DECL ||
392 type == SUBNET_DECL ||
393 type == CLASS_DECL) {
394 parse_warn (cfile, "shared-network parameters not %s.",
395 "allowed here");
396 skip_to_semi (cfile);
397 break;
398 }
399
400 parse_shared_net_declaration (cfile, group);
401 return 1;
402
403 case SUBNET:
404 next_token (&val, (unsigned *)0, cfile);
405 if (type == HOST_DECL || type == SUBNET_DECL ||
406 type == CLASS_DECL) {
407 parse_warn (cfile,
408 "subnet declarations not allowed here.");
409 skip_to_semi (cfile);
410 return 1;
411 }
412
413 /* If we're in a subnet declaration, just do the parse. */
414 if (group -> shared_network) {
415 parse_subnet_declaration (cfile,
416 group -> shared_network);
417 break;
418 }
419
420 /* Otherwise, cons up a fake shared network structure
421 and populate it with the lone subnet... */
422
423 share = (struct shared_network *)0;
424 status = shared_network_allocate (&share, MDL);
425 if (status != ISC_R_SUCCESS)
426 log_fatal ("Can't allocate shared subnet: %s",
427 isc_result_totext (status));
428 if (!clone_group (&share -> group, group, MDL))
429 log_fatal ("Can't allocate group for shared net");
430 shared_network_reference (&share -> group -> shared_network,
431 share, MDL);
432
433 parse_subnet_declaration (cfile, share);
434
435 /* share -> subnets is the subnet we just parsed. */
436 if (share -> subnets) {
437 interface_reference (&share -> interface,
438 share -> subnets -> interface,
439 MDL);
440
441 /* Make the shared network name from network number. */
442 n = piaddrmask (share -> subnets -> net,
443 share -> subnets -> netmask, MDL);
444 share -> name = n;
445
446 /* Copy the authoritative parameter from the subnet,
447 since there is no opportunity to declare it here. */
448 share -> group -> authoritative =
449 share -> subnets -> group -> authoritative;
450 enter_shared_network (share);
451 }
452 shared_network_dereference (&share, MDL);
453 return 1;
454
455 case VENDOR_CLASS:
456 next_token (&val, (unsigned *)0, cfile);
457 if (type == CLASS_DECL) {
458 parse_warn (cfile,
459 "class declarations not allowed here.");
460 skip_to_semi (cfile);
461 break;
462 }
463 parse_class_declaration ((struct class **)0, cfile, group, 0);
464 return 1;
465
466 case USER_CLASS:
467 next_token (&val, (unsigned *)0, cfile);
468 if (type == CLASS_DECL) {
469 parse_warn (cfile,
470 "class declarations not allowed here.");
471 skip_to_semi (cfile);
472 break;
473 }
474 parse_class_declaration ((struct class **)0, cfile, group, 1);
475 return 1;
476
477 case CLASS:
478 next_token (&val, (unsigned *)0, cfile);
479 if (type == CLASS_DECL) {
480 parse_warn (cfile,
481 "class declarations not allowed here.");
482 skip_to_semi (cfile);
483 break;
484 }
485 parse_class_declaration ((struct class **)0, cfile, group, 2);
486 return 1;
487
488 case SUBCLASS:
489 next_token (&val, (unsigned *)0, cfile);
490 if (type == CLASS_DECL) {
491 parse_warn (cfile,
492 "class declarations not allowed here.");
493 skip_to_semi (cfile);
494 break;
495 }
496 parse_class_declaration ((struct class **)0, cfile, group, 3);
497 return 1;
498
499 case HARDWARE:
500 next_token (&val, (unsigned *)0, cfile);
501 memset (&hardware, 0, sizeof hardware);
502 parse_hardware_param (cfile, &hardware);
503 if (host_decl)
504 host_decl -> interface = hardware;
505 else
506 parse_warn (cfile, "hardware address parameter %s",
507 "not allowed here.");
508 break;
509
510 case FIXED_ADDR:
511 next_token (&val, (unsigned *)0, cfile);
512 cache = (struct option_cache *)0;
513 if (parse_fixed_addr_param (&cache, cfile)) {
514 if (host_decl) {
515 if (host_decl -> fixed_addr) {
516 option_cache_dereference (&cache, MDL);
517 parse_warn (cfile,
518 "Only one fixed address%s",
519 " declaration per host.");
520 } else {
521 host_decl -> fixed_addr = cache;
522 }
523 } else {
524 parse_warn (cfile,
525 "fixed-address parameter not %s",
526 "allowed here.");
527 option_cache_dereference (&cache, MDL);
528 }
529 }
530 break;
531
532 case POOL:
533 next_token (&val, (unsigned *)0, cfile);
534 if (type != SUBNET_DECL && type != SHARED_NET_DECL) {
535 parse_warn (cfile, "pool declared outside of network");
536 }
537 if (type == POOL_DECL) {
538 parse_warn (cfile, "pool declared within pool.");
539 }
540 parse_pool_statement (cfile, group, type);
541 return declaration;
542
543 case RANGE:
544 next_token (&val, (unsigned *)0, cfile);
545 if (type != SUBNET_DECL || !group -> subnet) {
546 parse_warn (cfile,
547 "range declaration not allowed here.");
548 skip_to_semi (cfile);
549 return declaration;
550 }
551 parse_address_range (cfile, group, type, (struct pool *)0,
552 (struct lease **)0);
553 return declaration;
554
555 case TOKEN_NOT:
556 token = next_token (&val, (unsigned *)0, cfile);
557 token = next_token (&val, (unsigned *)0, cfile);
558 switch (token) {
559 case AUTHORITATIVE:
560 group -> authoritative = 0;
561 goto authoritative;
562 default:
563 parse_warn (cfile, "expecting assertion");
564 skip_to_semi (cfile);
565 break;
566 }
567 break;
568 case AUTHORITATIVE:
569 token = next_token (&val, (unsigned *)0, cfile);
570 group -> authoritative = 1;
571 authoritative:
572 if (type == HOST_DECL)
573 parse_warn (cfile, "authority makes no sense here.");
574 parse_semi (cfile);
575 break;
576
577 /* "server-identifier" is a special hack, equivalent to
578 "option dhcp-server-identifier". */
579 case SERVER_IDENTIFIER:
580 option = dhcp_universe.options [DHO_DHCP_SERVER_IDENTIFIER];
581 token = next_token (&val, (unsigned *)0, cfile);
582 goto finish_option;
583
584 case OPTION:
585 token = next_token (&val, (unsigned *)0, cfile);
586 token = peek_token (&val, (unsigned *)0, cfile);
587 if (token == SPACE) {
588 if (type != ROOT_GROUP) {
589 parse_warn (cfile,
590 "option space definitions %s",
591 "may not be scoped.");
592 skip_to_semi (cfile);
593 break;
594 }
595 parse_option_space_decl (cfile);
596 return declaration;
597 }
598
599 known = 0;
600 option = parse_option_name (cfile, 1, &known);
601 if (option) {
602 token = peek_token (&val, (unsigned *)0, cfile);
603 if (token == CODE) {
604 if (type != ROOT_GROUP) {
605 parse_warn (cfile,
606 "option definitions%s",
607 " may not be scoped.");
608 skip_to_semi (cfile);
609 free_option (option, MDL);
610 break;
611 }
612 next_token (&val, (unsigned *)0, cfile);
613 if (!parse_option_code_definition (cfile,
614 option))
615 free_option (option, MDL);
616 return declaration;
617 }
618
619 /* If this wasn't an option code definition, don't
620 allow an unknown option. */
621 if (!known) {
622 parse_warn (cfile, "unknown option %s.%s",
623 option -> universe -> name,
624 option -> name);
625 skip_to_semi (cfile);
626 free_option (option, MDL);
627 return declaration;
628 }
629
630 finish_option:
631 et = (struct executable_statement *)0;
632 if (!parse_option_statement
633 (&et, cfile, 1, option,
634 supersede_option_statement))
635 return declaration;
636 goto insert_statement;
637 } else
638 return declaration;
639
640 break;
641
642 case FAILOVER:
643 if (type != ROOT_GROUP && type != SHARED_NET_DECL) {
644 parse_warn (cfile, "failover peers may only be %s",
645 "defined in shared-network");
646 log_error ("declarations and the outer scope.");
647 skip_to_semi (cfile);
648 break;
649 }
650 token = next_token (&val, (unsigned *)0, cfile);
651 #if defined (FAILOVER_PROTOCOL)
652 parse_failover_peer (cfile, group, type);
653 #else
654 parse_warn (cfile, "No failover support.");
655 skip_to_semi (cfile);
656 #endif
657 break;
658
659 default:
660 et = (struct executable_statement *)0;
661 lose = 0;
662 if (!parse_executable_statement (&et, cfile, &lose,
663 context_any)) {
664 if (!lose) {
665 if (declaration)
666 parse_warn (cfile,
667 "expecting a declaration");
668 else
669 parse_warn (cfile,
670 "expecting a parameter %s",
671 "or declaration");
672 skip_to_semi (cfile);
673 }
674 return declaration;
675 }
676 if (!et)
677 return declaration;
678 insert_statement:
679 if (group -> statements) {
680 int multi = 0;
681
682 /* If this set of statements is only referenced
683 by this group, just add the current statement
684 to the end of the chain. */
685 for (ep = group -> statements; ep -> next;
686 ep = ep -> next)
687 if (ep -> refcnt > 1) /* XXX */
688 multi = 1;
689 if (!multi) {
690 executable_statement_reference (&ep -> next,
691 et, MDL);
692 executable_statement_dereference (&et, MDL);
693 return declaration;
694 }
695
696 /* Otherwise, make a parent chain, and put the
697 current group statements first and the new
698 statement in the next pointer. */
699 ep = (struct executable_statement *)0;
700 if (!executable_statement_allocate (&ep, MDL))
701 log_fatal ("No memory for statements.");
702 ep -> op = statements_statement;
703 executable_statement_reference (&ep -> data.statements,
704 group -> statements,
705 MDL);
706 executable_statement_reference (&ep -> next, et, MDL);
707 executable_statement_dereference (&group -> statements,
708 MDL);
709 executable_statement_reference (&group -> statements,
710 ep, MDL);
711 executable_statement_dereference (&ep, MDL);
712 } else {
713 executable_statement_reference (&group -> statements,
714 et, MDL);
715 }
716 executable_statement_dereference (&et, MDL);
717 return declaration;
718 }
719
720 return 0;
721 }
722
723 #if defined (FAILOVER_PROTOCOL)
724 void parse_failover_peer (cfile, group, type)
725 struct parse *cfile;
726 struct group *group;
727 int type;
728 {
729 enum dhcp_token token;
730 const char *val;
731 dhcp_failover_state_t *peer;
732 u_int32_t *tp;
733 char *name;
734 u_int32_t split;
735 u_int8_t hba [32];
736 unsigned hba_len = sizeof hba;
737 int i;
738 struct expression *expr;
739 isc_result_t status;
740 dhcp_failover_config_t *cp;
741
742 token = next_token (&val, (unsigned *)0, cfile);
743 if (token != PEER) {
744 parse_warn (cfile, "expecting \"peer\"");
745 skip_to_semi (cfile);
746 return;
747 }
748
749 token = next_token (&val, (unsigned *)0, cfile);
750 if (is_identifier (token) || token == STRING) {
751 name = dmalloc (strlen (val) + 1, MDL);
752 if (!name)
753 log_fatal ("no memory for peer name %s", name);
754 strcpy (name, val);
755 } else {
756 parse_warn (cfile, "expecting failover peer name.");
757 skip_to_semi (cfile);
758 return;
759 }
760
761 /* See if there's a peer declaration by this name. */
762 peer = (dhcp_failover_state_t *)0;
763 find_failover_peer (&peer, name, MDL);
764
765 token = next_token (&val, (unsigned *)0, cfile);
766 if (token == SEMI) {
767 dfree (name, MDL);
768 if (type != SHARED_NET_DECL)
769 parse_warn (cfile, "failover peer reference not %s",
770 "in shared-network declaration");
771 else {
772 if (!peer) {
773 parse_warn (cfile, "reference to unknown%s%s",
774 " failover peer ", name);
775 return;
776 }
777 dhcp_failover_state_reference
778 (&group -> shared_network -> failover_peer,
779 peer, MDL);
780 }
781 dhcp_failover_state_dereference (&peer, MDL);
782 return;
783 } else if (token == STATE) {
784 if (!peer) {
785 parse_warn (cfile, "state declaration for unknown%s%s",
786 " failover peer ", name);
787 return;
788 }
789 parse_failover_state_declaration (cfile, peer);
790 dhcp_failover_state_dereference (&peer, MDL);
791 return;
792 } else if (token != LBRACE) {
793 parse_warn (cfile, "expecting left brace");
794 skip_to_semi (cfile);
795 }
796
797 /* Make sure this isn't a redeclaration. */
798 if (peer) {
799 parse_warn (cfile, "redeclaration of failover peer %s", name);
800 skip_to_rbrace (cfile, 1);
801 dhcp_failover_state_dereference (&peer, MDL);
802 return;
803 }
804
805 status = dhcp_failover_state_allocate (&peer, MDL);
806 if (status != ISC_R_SUCCESS)
807 log_fatal ("Can't allocate failover peer %s: %s",
808 name, isc_result_totext (status));
809
810 /* Save the name. */
811 peer -> name = name;
812
813 do {
814 cp = &peer -> me;
815 peer:
816 token = next_token (&val, (unsigned *)0, cfile);
817 switch (token) {
818 case RBRACE:
819 break;
820
821 case PRIMARY:
822 peer -> i_am = primary;
823 break;
824
825 case SECONDARY:
826 peer -> i_am = secondary;
827 if (peer -> hba)
828 parse_warn (cfile,
829 "secondary may not define %s",
830 "load balance settings.");
831 break;
832
833 case PEER:
834 cp = &peer -> partner;
835 goto peer;
836
837 case ADDRESS:
838 expr = (struct expression *)0;
839 if (!parse_ip_addr_or_hostname (&expr, cfile, 0)) {
840 skip_to_rbrace (cfile, 1);
841 dhcp_failover_state_dereference (&peer, MDL);
842 return;
843 }
844 option_cache (&cp -> address,
845 (struct data_string *)0, expr,
846 (struct option *)0, MDL);
847 expression_dereference (&expr, MDL);
848 break;
849
850 case PORT:
851 token = next_token (&val, (unsigned *)0, cfile);
852 if (token != NUMBER) {
853 parse_warn (cfile, "expecting number");
854 skip_to_rbrace (cfile, 1);
855 }
856 cp -> port = atoi (val);
857 break;
858
859 case MAX_RESPONSE_DELAY:
860 tp = &cp -> max_response_delay;
861 parse_idle:
862 token = next_token (&val, (unsigned *)0, cfile);
863 if (token != NUMBER) {
864 parse_warn (cfile, "expecting number.");
865 skip_to_rbrace (cfile, 1);
866 dhcp_failover_state_dereference (&peer, MDL);
867 return;
868 }
869 *tp = atoi (val);
870 break;
871
872 case MAX_UNACKED_UPDATES:
873 tp = &cp -> max_flying_updates;
874 goto parse_idle;
875
876 case MCLT:
877 tp = &peer -> mclt;
878 goto parse_idle;
879
880 case HBA:
881 hba_len = 32;
882 if (peer -> i_am == secondary)
883 parse_warn (cfile,
884 "secondary may not define %s",
885 "load balance settings.");
886 if (!parse_numeric_aggregate (cfile, hba, &hba_len,
887 COLON, 16, 8)) {
888 skip_to_rbrace (cfile, 1);
889 dhcp_failover_state_dereference (&peer, MDL);
890 return;
891 }
892 if (hba_len != 32) {
893 parse_warn (cfile,
894 "HBA must be exactly 32 bytes.");
895 dfree (hba, MDL);
896 break;
897 }
898 make_hba:
899 peer -> hba = dmalloc (32, MDL);
900 if (!peer -> hba) {
901 dfree (peer -> name, MDL);
902 dfree (peer, MDL);
903 }
904 memcpy (peer -> hba, hba, 32);
905 break;
906
907 case SPLIT:
908 token = next_token (&val, (unsigned *)0, cfile);
909 if (peer -> i_am == secondary)
910 parse_warn (cfile,
911 "secondary may not define %s",
912 "load balance settings.");
913 if (token != NUMBER) {
914 parse_warn (cfile, "expecting number");
915 badsplit:
916 skip_to_rbrace (cfile, 1);
917 dhcp_failover_state_dereference (&peer, MDL);
918 return;
919 }
920 split = atoi (val);
921 if (split > 255) {
922 parse_warn (cfile, "split must be < 256");
923 } else {
924 memset (hba, 0, sizeof hba);
925 for (i = 0; i < split; i++) {
926 if (i < split)
927 hba [i / 8] |= (1 << (i & 7));
928 }
929 goto make_hba;
930 }
931 break;
932
933 case LOAD:
934 token = next_token (&val, (unsigned *)0, cfile);
935 if (token != BALANCE) {
936 parse_warn (cfile, "expecting 'balance'");
937 badload:
938 skip_to_rbrace (cfile, 1);
939 break;
940 }
941 token = next_token (&val, (unsigned *)0, cfile);
942 if (token != TOKEN_MAX) {
943 parse_warn (cfile, "expecting 'max'");
944 goto badload;
945 }
946 token = next_token (&val, (unsigned *)0, cfile);
947 if (token != SECONDS) {
948 parse_warn (cfile, "expecting 'secs'");
949 goto badload;
950 }
951 token = next_token (&val, (unsigned *)0, cfile);
952 if (token != NUMBER) {
953 parse_warn (cfile, "expecting number");
954 goto badload;
955 }
956 peer -> load_balance_max_secs = atoi (val);
957 break;
958
959 default:
960 parse_warn (cfile,
961 "invalid statement in peer declaration");
962 skip_to_rbrace (cfile, 1);
963 dhcp_failover_state_dereference (&peer, MDL);
964 return;
965 }
966 if (token != RBRACE && !parse_semi (cfile)) {
967 skip_to_rbrace (cfile, 1);
968 dhcp_failover_state_dereference (&peer, MDL);
969 return;
970 }
971 } while (token != RBRACE);
972
973 /* me.address can be null; the failover link initiate code tries to
974 * derive a reasonable address to use.
975 */
976 if (!peer -> partner.address)
977 parse_warn (cfile, "peer address may not be omitted");
978
979 /* XXX - when/if we get a port number assigned, just set as default */
980 if (!peer -> me.port)
981 parse_warn (cfile, "local port may not be omitted");
982 if (!peer -> partner.port)
983 parse_warn (cfile, "peer port may not be omitted");
984
985 if (peer -> i_am == primary) {
986 if (!peer -> hba) {
987 parse_warn (cfile,
988 "primary failover server must have hba or split.");
989 } else if (!peer -> mclt) {
990 parse_warn (cfile,
991 "primary failover server must have mclt.");
992 }
993 }
994 if (!peer -> me.max_flying_updates) {
995 peer -> me.max_flying_updates = 100;
996 }
997 if (!peer -> me.max_response_delay) {
998 peer -> me.max_response_delay = 60;
999 }
1000
1001 if (type == SHARED_NET_DECL) {
1002 group -> shared_network -> failover_peer = peer;
1003 }
1004
1005 /* Set the initial state. */
1006 if (peer -> i_am == primary) {
1007 peer -> me.state = recover;
1008 peer -> me.stos = cur_time;
1009 peer -> partner.state = unknown_state;
1010 peer -> partner.stos = cur_time;
1011 } else {
1012 peer -> me.state = recover;
1013 peer -> me.stos = cur_time;
1014 peer -> partner.state = unknown_state;
1015 peer -> partner.stos = cur_time;
1016 }
1017
1018 status = enter_failover_peer (peer);
1019 if (status != ISC_R_SUCCESS)
1020 parse_warn (cfile, "failover peer %s: %s",
1021 peer -> name, isc_result_totext (status));
1022 dhcp_failover_state_dereference (&peer, MDL);
1023 }
1024
1025 void parse_failover_state_declaration (struct parse *cfile,
1026 dhcp_failover_state_t *peer)
1027 {
1028 enum dhcp_token token;
1029 const char *val;
1030 char *name;
1031 dhcp_failover_state_t *state;
1032 dhcp_failover_config_t *cp;
1033
1034 if (!peer) {
1035 token = next_token (&val, (unsigned *)0, cfile);
1036 if (token != PEER) {
1037 parse_warn (cfile, "expecting \"peer\"");
1038 skip_to_semi (cfile);
1039 return;
1040 }
1041
1042 token = next_token (&val, (unsigned *)0, cfile);
1043 if (is_identifier (token) || token == STRING) {
1044 name = dmalloc (strlen (val) + 1, MDL);
1045 if (!name)
1046 log_fatal ("failover peer name %s: no memory",
1047 name);
1048 strcpy (name, val);
1049 } else {
1050 parse_warn (cfile, "expecting failover peer name.");
1051 skip_to_semi (cfile);
1052 return;
1053 }
1054
1055 /* See if there's a peer declaration by this name. */
1056 state = (dhcp_failover_state_t *)0;
1057 find_failover_peer (&state, name, MDL);
1058 if (!state) {
1059 parse_warn (cfile, "unknown failover peer: %s", name);
1060 skip_to_semi (cfile);
1061 return;
1062 }
1063
1064 token = next_token (&val, (unsigned *)0, cfile);
1065 if (token != STATE) {
1066 parse_warn (cfile, "expecting 'state'");
1067 if (token != SEMI)
1068 skip_to_semi (cfile);
1069 return;
1070 }
1071 } else {
1072 state = (dhcp_failover_state_t *)0;
1073 dhcp_failover_state_reference (&state, peer, MDL);
1074 }
1075 token = next_token (&val, (unsigned *)0, cfile);
1076 if (token != LBRACE) {
1077 parse_warn (cfile, "expecting left brace");
1078 if (token != SEMI)
1079 skip_to_semi (cfile);
1080 dhcp_failover_state_dereference (&state, MDL);
1081 return;
1082 }
1083 do {
1084 token = next_token (&val, (unsigned *)0, cfile);
1085 switch (token) {
1086 case RBRACE:
1087 break;
1088 case MY:
1089 cp = &state -> me;
1090 do_state:
1091 token = next_token (&val, (unsigned *)0, cfile);
1092 if (token != STATE) {
1093 parse_warn (cfile, "expecting 'state'");
1094 goto bogus;
1095 }
1096 parse_failover_state (cfile,
1097 &cp -> state, &cp -> stos);
1098 break;
1099
1100 case PARTNER:
1101 cp = &state -> partner;
1102 goto do_state;
1103
1104 case MCLT:
1105 if (state -> i_am == primary) {
1106 parse_warn (cfile,
1107 "mclt not valid for primary");
1108 goto bogus;
1109 }
1110 token = next_token (&val, (unsigned *)0, cfile);
1111 if (token != NUMBER) {
1112 parse_warn (cfile, "expecting a number.");
1113 goto bogus;
1114 }
1115 state -> mclt = atoi (val);
1116 parse_semi (cfile);
1117 break;
1118
1119 default:
1120 parse_warn (cfile, "expecting state setting.");
1121 bogus:
1122 skip_to_rbrace (cfile, 1);
1123 dhcp_failover_state_dereference (&state, MDL);
1124 return;
1125 }
1126 } while (token != RBRACE);
1127 dhcp_failover_state_dereference (&state, MDL);
1128 }
1129
1130 void parse_failover_state (cfile, state, stos)
1131 struct parse *cfile;
1132 enum failover_state *state;
1133 TIME *stos;
1134 {
1135 enum dhcp_token token;
1136 const char *val;
1137 enum failover_state state_in;
1138 TIME stos_in;
1139
1140 token = next_token (&val, (unsigned *)0, cfile);
1141 switch (token) {
1142 case UNKNOWN_STATE:
1143 state_in = unknown_state;
1144 break;
1145
1146 case PARTNER_DOWN:
1147 state_in = partner_down;
1148 break;
1149
1150 case NORMAL:
1151 state_in = normal;
1152 break;
1153
1154 case COMMUNICATIONS_INTERRUPTED:
1155 state_in = communications_interrupted;
1156 break;
1157
1158 case RESOLUTION_INTERRUPTED:
1159 state_in = resolution_interrupted;
1160 break;
1161
1162 case POTENTIAL_CONFLICT:
1163 state_in = potential_conflict;
1164 break;
1165
1166 case RECOVER:
1167 state_in = recover;
1168 break;
1169
1170 case RECOVER_WAIT:
1171 state_in = recover_wait;
1172 break;
1173
1174 case RECOVER_DONE:
1175 state_in = recover_done;
1176 break;
1177
1178 case SHUTDOWN:
1179 state_in = shut_down;
1180 break;
1181
1182 case PAUSED:
1183 state_in = paused;
1184 break;
1185
1186 case STARTUP:
1187 state_in = startup;
1188 break;
1189
1190 default:
1191 parse_warn (cfile, "unknown failover state");
1192 skip_to_semi (cfile);
1193 return;
1194 }
1195
1196 token = next_token (&val, (unsigned *)0, cfile);
1197 if (token == SEMI) {
1198 stos_in = cur_time;
1199 } else {
1200 if (token != AT) {
1201 parse_warn (cfile, "expecting \"at\"");
1202 skip_to_semi (cfile);
1203 return;
1204 }
1205
1206 stos_in = parse_date (cfile);
1207 if (!stos_in)
1208 return;
1209 }
1210
1211 /* Now that we've apparently gotten a clean parse, we
1212 can trust that this is a state that was fully committed to
1213 disk, so we can install it. */
1214 *stos = stos_in;
1215 *state = state_in;
1216 }
1217 #endif /* defined (FAILOVER_PROTOCOL) */
1218
1219 /* Permit_list_match returns 1 if every element of the permit list in lhs
1220 also appears in rhs. Note that this doesn't by itself mean that the
1221 two lists are equal - to check for equality, permit_list_match has to
1222 return 1 with (list1, list2) and with (list2, list1). */
1223
1224 int permit_list_match (struct permit *lhs, struct permit *rhs)
1225 {
1226 struct permit *plp, *prp;
1227 int matched;
1228
1229 if (!lhs)
1230 return 1;
1231 if (!rhs)
1232 return 0;
1233 for (plp = lhs; plp; plp = plp -> next) {
1234 matched = 0;
1235 for (prp = rhs; prp; prp = prp -> next) {
1236 if (prp -> type == plp -> type &&
1237 (prp -> type != permit_class ||
1238 prp -> class == plp -> class)) {
1239 matched = 1;
1240 break;
1241 }
1242 }
1243 if (!matched)
1244 return 0;
1245 }
1246 return 1;
1247 }
1248
1249 void parse_pool_statement (cfile, group, type)
1250 struct parse *cfile;
1251 struct group *group;
1252 int type;
1253 {
1254 enum dhcp_token token;
1255 const char *val;
1256 int done = 0;
1257 struct pool *pool, **p, *pp;
1258 struct permit *permit;
1259 struct permit **permit_head;
1260 int declaration = 0;
1261 isc_result_t status;
1262 struct lease *lpchain = (struct lease *)0, *lp;
1263
1264 pool = (struct pool *)0;
1265 status = pool_allocate (&pool, MDL);
1266 if (status != ISC_R_SUCCESS)
1267 log_fatal ("no memory for pool: %s",
1268 isc_result_totext (status));
1269
1270 if (type == SUBNET_DECL)
1271 shared_network_reference (&pool -> shared_network,
1272 group -> subnet -> shared_network,
1273 MDL);
1274 else
1275 shared_network_reference (&pool -> shared_network,
1276 group -> shared_network, MDL);
1277
1278 if (!clone_group (&pool -> group, pool -> shared_network -> group, MDL))
1279 log_fatal ("can't clone pool group.");
1280
1281 #if defined (FAILOVER_PROTOCOL)
1282 /* Inherit the failover peer from the shared network. */
1283 if (pool -> shared_network -> failover_peer)
1284 dhcp_failover_state_reference
1285 (&pool -> failover_peer,
1286 pool -> shared_network -> failover_peer, MDL);
1287 #endif
1288
1289 if (!parse_lbrace (cfile)) {
1290 pool_dereference (&pool, MDL);
1291 return;
1292 }
1293
1294 do {
1295 token = peek_token (&val, (unsigned *)0, cfile);
1296 switch (token) {
1297 case NO:
1298 next_token (&val, (unsigned *)0, cfile);
1299 token = next_token (&val, (unsigned *)0, cfile);
1300 if (token != FAILOVER ||
1301 (token = next_token (&val, (unsigned *)0,
1302 cfile)) != PEER) {
1303 parse_warn (cfile,
1304 "expecting \"failover peer\".");
1305 skip_to_semi (cfile);
1306 continue;
1307 }
1308 #if defined (FAILOVER_PROTOCOL)
1309 if (pool -> failover_peer)
1310 dhcp_failover_state_dereference
1311 (&pool -> failover_peer, MDL);
1312 #endif
1313 break;
1314
1315 #if defined (FAILOVER_PROTOCOL)
1316 case FAILOVER:
1317 next_token (&val, (unsigned *)0, cfile);
1318 token = next_token (&val, (unsigned *)0, cfile);
1319 if (token != PEER) {
1320 parse_warn (cfile, "expecting 'peer'.");
1321 skip_to_semi (cfile);
1322 break;
1323 }
1324 token = next_token (&val, (unsigned *)0, cfile);
1325 if (token != STRING) {
1326 parse_warn (cfile, "expecting string.");
1327 skip_to_semi (cfile);
1328 break;
1329 }
1330 if (pool -> failover_peer)
1331 dhcp_failover_state_dereference
1332 (&pool -> failover_peer, MDL);
1333 status = find_failover_peer (&pool -> failover_peer,
1334 val, MDL);
1335 if (status != ISC_R_SUCCESS)
1336 parse_warn (cfile,
1337 "failover peer %s: %s", val,
1338 isc_result_totext (status));
1339 else
1340 pool -> failover_peer -> pool_count++;
1341 parse_semi (cfile);
1342 break;
1343 #endif
1344
1345 case RANGE:
1346 next_token (&val, (unsigned *)0, cfile);
1347 parse_address_range (cfile, group, type,
1348 pool, &lpchain);
1349 break;
1350 case ALLOW:
1351 permit_head = &pool -> permit_list;
1352 get_permit:
1353 permit = new_permit (MDL);
1354 if (!permit)
1355 log_fatal ("no memory for permit");
1356 next_token (&val, (unsigned *)0, cfile);
1357 token = next_token (&val, (unsigned *)0, cfile);
1358 switch (token) {
1359 case UNKNOWN:
1360 permit -> type = permit_unknown_clients;
1361 get_clients:
1362 if (next_token (&val, (unsigned *)0,
1363 cfile) != CLIENTS) {
1364 parse_warn (cfile,
1365 "expecting \"clients\"");
1366 skip_to_semi (cfile);
1367 free_permit (permit, MDL);
1368 continue;
1369 }
1370 break;
1371
1372 case KNOWN_CLIENTS:
1373 permit -> type = permit_known_clients;
1374 break;
1375
1376 case UNKNOWN_CLIENTS:
1377 permit -> type = permit_unknown_clients;
1378 break;
1379
1380 case KNOWN:
1381 permit -> type = permit_known_clients;
1382 goto get_clients;
1383
1384 case AUTHENTICATED:
1385 permit -> type = permit_authenticated_clients;
1386 goto get_clients;
1387
1388 case UNAUTHENTICATED:
1389 permit -> type =
1390 permit_unauthenticated_clients;
1391 goto get_clients;
1392
1393 case ALL:
1394 permit -> type = permit_all_clients;
1395 goto get_clients;
1396 break;
1397
1398 case DYNAMIC:
1399 permit -> type = permit_dynamic_bootp_clients;
1400 if (next_token (&val, (unsigned *)0,
1401 cfile) != TOKEN_BOOTP) {
1402 parse_warn (cfile,
1403 "expecting \"bootp\"");
1404 skip_to_semi (cfile);
1405 free_permit (permit, MDL);
1406 continue;
1407 }
1408 goto get_clients;
1409
1410 case MEMBERS:
1411 if (next_token (&val, (unsigned *)0,
1412 cfile) != OF) {
1413 parse_warn (cfile, "expecting \"of\"");
1414 skip_to_semi (cfile);
1415 free_permit (permit, MDL);
1416 continue;
1417 }
1418 if (next_token (&val, (unsigned *)0,
1419 cfile) != STRING) {
1420 parse_warn (cfile,
1421 "expecting class name.");
1422 skip_to_semi (cfile);
1423 free_permit (permit, MDL);
1424 continue;
1425 }
1426 permit -> type = permit_class;
1427 permit -> class = (struct class *)0;
1428 find_class (&permit -> class, val, MDL);
1429 if (!permit -> class)
1430 parse_warn (cfile,
1431 "no such class: %s", val);
1432 break;
1433
1434 default:
1435 parse_warn (cfile, "expecting permit type.");
1436 skip_to_semi (cfile);
1437 break;
1438 }
1439 while (*permit_head)
1440 permit_head = &((*permit_head) -> next);
1441 *permit_head = permit;
1442 parse_semi (cfile);
1443 break;
1444
1445 case DENY:
1446 permit_head = &pool -> prohibit_list;
1447 goto get_permit;
1448
1449 case RBRACE:
1450 next_token (&val, (unsigned *)0, cfile);
1451 done = 1;
1452 break;
1453
1454 default:
1455 declaration = parse_statement (cfile, pool -> group,
1456 POOL_DECL,
1457 (struct host_decl *)0,
1458 declaration);
1459 break;
1460 }
1461 } while (!done);
1462
1463 #if defined (FAILOVER_PROTOCOL)
1464 /* We can't do failover on a pool that supports dynamic bootp,
1465 because BOOTP doesn't support leases, and failover absolutely
1466 depends on lease timing. */
1467 if (pool -> failover_peer) {
1468 /* This search order matches the search orders later in
1469 * execution - deny first, if not denied, check permit
1470 * list. A dynamic bootp client may be known or unknown,
1471 * it may belong to a member of a class, but it definitely
1472 * will not be authenticated since that requires DHCP
1473 * to work. So a dynamic bootp client is definitely not
1474 * an authenticated client, and we can't say for sure about
1475 * anything else.
1476 *
1477 * So we nag the user.
1478 */
1479 for (permit = pool -> prohibit_list; permit;
1480 permit = permit -> next) {
1481 if (permit -> type == permit_dynamic_bootp_clients ||
1482 permit -> type == permit_unauthenticated_clients ||
1483 permit -> type == permit_all_clients)
1484 break;
1485 }
1486 if (!permit) {
1487 permit = pool -> permit_list;
1488 do {
1489 if (!permit ||
1490 permit -> type !=
1491 permit_authenticated_clients) {
1492 parse_warn (cfile,
1493 "pools with failover peers %s",
1494 "may not permit dynamic bootp.");
1495 log_error ("Either write a \"%s\" %s",
1496 "no failover",
1497 "statement and use disjoint");
1498 log_error ("pools, or%s (%s) %s",
1499 " don't permit dynamic bootp",
1500 "\"deny dynamic bootp clients;\"",
1501 "in this pool.");
1502 log_error ("This is a protocol,%s %s",
1503 " limitation, not an ISC DHCP",
1504 "limitation, so");
1505 log_error ("please don't request an %s",
1506 "enhancement or ask why this is.");
1507
1508 break;
1509 }
1510
1511 permit = permit -> next;
1512 } while (permit);
1513 }
1514 }
1515 #endif /* FAILOVER_PROTOCOL */
1516
1517 /* See if there's already a pool into which we can merge this one. */
1518 for (pp = pool -> shared_network -> pools; pp; pp = pp -> next) {
1519 struct lease *l;
1520
1521 if (pp -> group -> statements != pool -> group -> statements)
1522 continue;
1523 #if defined (FAILOVER_PROTOCOL)
1524 if (pool -> failover_peer != pp -> failover_peer)
1525 continue;
1526 #endif
1527 if (!permit_list_match (pp -> permit_list,
1528 pool -> permit_list) ||
1529 !permit_list_match (pool -> permit_list,
1530 pp -> permit_list) ||
1531 !permit_list_match (pp -> prohibit_list,
1532 pool -> prohibit_list) ||
1533 !permit_list_match (pool -> prohibit_list,
1534 pp -> prohibit_list))
1535 continue;
1536
1537 /* Okay, we can merge these two pools. All we have to
1538 do is fix up the leases, which all point to their pool. */
1539 for (lp = lpchain; lp; lp = lp -> next) {
1540 pool_dereference (&lp -> pool, MDL);
1541 pool_reference (&lp -> pool, pp, MDL);
1542 }
1543 break;
1544 }
1545
1546 /* If we didn't succeed in merging this pool into another, put
1547 it on the list. */
1548 if (!pp) {
1549 p = &pool -> shared_network -> pools;
1550 for (; *p; p = &((*p) -> next))
1551 ;
1552 pool_reference (p, pool, MDL);
1553 }
1554
1555 /* Don't allow a pool declaration with no addresses, since it is
1556 probably a configuration error. */
1557 if (!lpchain) {
1558 parse_warn (cfile, "Pool declaration with no address range.");
1559 log_error ("Pool declarations must always contain at least");
1560 log_error ("one range statement.");
1561 }
1562
1563 /* Dereference the lease chain. */
1564 lp = (struct lease *)0;
1565 while (lpchain) {
1566 lease_reference (&lp, lpchain, MDL);
1567 lease_dereference (&lpchain, MDL);
1568 if (lp -> next) {
1569 lease_reference (&lpchain, lp -> next, MDL);
1570 lease_dereference (&lp -> next, MDL);
1571 lease_dereference (&lp, MDL);
1572 }
1573 }
1574 pool_dereference (&pool, MDL);
1575 }
1576
1577 /* boolean :== ON SEMI | OFF SEMI | TRUE SEMI | FALSE SEMI */
1578
1579 int parse_boolean (cfile)
1580 struct parse *cfile;
1581 {
1582 enum dhcp_token token;
1583 const char *val;
1584 int rv;
1585
1586 token = next_token (&val, (unsigned *)0, cfile);
1587 if (!strcasecmp (val, "true")
1588 || !strcasecmp (val, "on"))
1589 rv = 1;
1590 else if (!strcasecmp (val, "false")
1591 || !strcasecmp (val, "off"))
1592 rv = 0;
1593 else {
1594 parse_warn (cfile,
1595 "boolean value (true/false/on/off) expected");
1596 skip_to_semi (cfile);
1597 return 0;
1598 }
1599 parse_semi (cfile);
1600 return rv;
1601 }
1602
1603 /* Expect a left brace; if there isn't one, skip over the rest of the
1604 statement and return zero; otherwise, return 1. */
1605
1606 int parse_lbrace (cfile)
1607 struct parse *cfile;
1608 {
1609 enum dhcp_token token;
1610 const char *val;
1611
1612 token = next_token (&val, (unsigned *)0, cfile);
1613 if (token != LBRACE) {
1614 parse_warn (cfile, "expecting left brace.");
1615 skip_to_semi (cfile);
1616 return 0;
1617 }
1618 return 1;
1619 }
1620
1621
1622 /* host-declaration :== hostname RBRACE parameters declarations LBRACE */
1623
1624 void parse_host_declaration (cfile, group)
1625 struct parse *cfile;
1626 struct group *group;
1627 {
1628 const char *val;
1629 enum dhcp_token token;
1630 struct host_decl *host;
1631 char *name;
1632 int declaration = 0;
1633 int dynamicp = 0;
1634 int deleted = 0;
1635 isc_result_t status;
1636
1637 name = parse_host_name (cfile);
1638 if (!name) {
1639 parse_warn (cfile, "expecting a name for host declaration.");
1640 skip_to_semi (cfile);
1641 return;
1642 }
1643
1644 host = (struct host_decl *)0;
1645 status = host_allocate (&host, MDL);
1646 if (status != ISC_R_SUCCESS)
1647 log_fatal ("can't allocate host decl struct %s: %s",
1648 name, isc_result_totext (status));
1649 host -> name = name;
1650 if (!clone_group (&host -> group, group, MDL)) {
1651 log_fatal ("can't clone group for host %s", name);
1652 boom:
1653 host_dereference (&host, MDL);
1654 return;
1655 }
1656
1657 if (!parse_lbrace (cfile))
1658 goto boom;
1659
1660 do {
1661 token = peek_token (&val, (unsigned *)0, cfile);
1662 if (token == RBRACE) {
1663 token = next_token (&val, (unsigned *)0, cfile);
1664 break;
1665 }
1666 if (token == END_OF_FILE) {
1667 token = next_token (&val, (unsigned *)0, cfile);
1668 parse_warn (cfile, "unexpected end of file");
1669 break;
1670 }
1671 /* If the host declaration was created by the server,
1672 remember to save it. */
1673 if (token == DYNAMIC) {
1674 dynamicp = 1;
1675 token = next_token (&val, (unsigned *)0, cfile);
1676 if (!parse_semi (cfile))
1677 break;
1678 continue;
1679 }
1680 /* If the host declaration was created by the server,
1681 remember to save it. */
1682 if (token == TOKEN_DELETED) {
1683 deleted = 1;
1684 token = next_token (&val, (unsigned *)0, cfile);
1685 if (!parse_semi (cfile))
1686 break;
1687 continue;
1688 }
1689
1690 if (token == GROUP) {
1691 struct group_object *go;
1692 token = next_token (&val, (unsigned *)0, cfile);
1693 token = next_token (&val, (unsigned *)0, cfile);
1694 if (token != STRING && !is_identifier (token)) {
1695 parse_warn (cfile,
1696 "expecting string or identifier.");
1697 skip_to_rbrace (cfile, 1);
1698 break;
1699 }
1700 go = (struct group_object *)0;
1701 if (!group_hash_lookup (&go, group_name_hash,
1702 val, strlen (val), MDL)) {
1703 parse_warn (cfile, "unknown group %s in host %s",
1704 val, host -> name);
1705 } else {
1706 if (host -> named_group)
1707 group_object_dereference
1708 (&host -> named_group, MDL);
1709 group_object_reference (&host -> named_group,
1710 go, MDL);
1711 group_object_dereference (&go, MDL);
1712 }
1713 if (!parse_semi (cfile))
1714 break;
1715 continue;
1716 }
1717
1718 if (token == UID) {
1719 const char *s;
1720 unsigned char *t = 0;
1721 unsigned len;
1722
1723 token = next_token (&val, (unsigned *)0, cfile);
1724 data_string_forget (&host -> client_identifier, MDL);
1725
1726 /* See if it's a string or a cshl. */
1727 token = peek_token (&val, (unsigned *)0, cfile);
1728 if (token == STRING) {
1729 token = next_token (&val, &len, cfile);
1730 s = val;
1731 host -> client_identifier.terminated = 1;
1732 } else {
1733 len = 0;
1734 t = parse_numeric_aggregate
1735 (cfile,
1736 (unsigned char *)0, &len, ':', 16, 8);
1737 if (!t) {
1738 parse_warn (cfile,
1739 "expecting hex list.");
1740 skip_to_semi (cfile);
1741 }
1742 s = (const char *)t;
1743 }
1744 if (!buffer_allocate
1745 (&host -> client_identifier.buffer,
1746 len + host -> client_identifier.terminated, MDL))
1747 log_fatal ("no memory for uid for host %s.",
1748 host -> name);
1749 host -> client_identifier.data =
1750 host -> client_identifier.buffer -> data;
1751 host -> client_identifier.len = len;
1752 memcpy (host -> client_identifier.buffer -> data, s,
1753 len + host -> client_identifier.terminated);
1754 if (t)
1755 dfree (t, MDL);
1756
1757 if (!parse_semi (cfile))
1758 break;
1759 continue;
1760 }
1761 declaration = parse_statement (cfile, host -> group,
1762 HOST_DECL, host,
1763 declaration);
1764 } while (1);
1765
1766 if (deleted) {
1767 struct host_decl *hp = (struct host_decl *)0;
1768 if (host_hash_lookup (&hp, host_name_hash,
1769 (unsigned char *)host -> name,
1770 strlen (host -> name), MDL)) {
1771 delete_host (hp, 0);
1772 host_dereference (&hp, MDL);
1773 }
1774 } else {
1775 if (host -> named_group && host -> named_group -> group) {
1776 if (host -> group -> statements ||
1777 (host -> group -> authoritative !=
1778 host -> named_group -> group -> authoritative)) {
1779 if (host -> group -> next)
1780 group_dereference (&host -> group -> next,
1781 MDL);
1782 group_reference (&host -> group -> next,
1783 host -> named_group -> group,
1784 MDL);
1785 } else {
1786 group_dereference (&host -> group, MDL);
1787 group_reference (&host -> group,
1788 host -> named_group -> group,
1789 MDL);
1790 }
1791 }
1792
1793 if (dynamicp)
1794 host -> flags |= HOST_DECL_DYNAMIC;
1795 else
1796 host -> flags |= HOST_DECL_STATIC;
1797
1798 status = enter_host (host, dynamicp, 0);
1799 if (status != ISC_R_SUCCESS)
1800 parse_warn (cfile, "host %s: %s", host -> name,
1801 isc_result_totext (status));
1802 }
1803 host_dereference (&host, MDL);
1804 }
1805
1806 /* class-declaration :== STRING LBRACE parameters declarations RBRACE
1807 */
1808
1809 int parse_class_declaration (cp, cfile, group, type)
1810 struct class **cp;
1811 struct parse *cfile;
1812 struct group *group;
1813 int type;
1814 {
1815 const char *val;
1816 enum dhcp_token token;
1817 struct class *class = (struct class *)0, *pc = (struct class *)0;
1818 int declaration = 0;
1819 int lose = 0;
1820 struct data_string data;
1821 char *name;
1822 const char *tname;
1823 struct executable_statement *stmt = (struct executable_statement *)0;
1824 struct expression *expr;
1825 int new = 1;
1826 isc_result_t status = ISC_R_FAILURE;
1827
1828 token = next_token (&val, (unsigned *)0, cfile);
1829 if (token != STRING) {
1830 parse_warn (cfile, "Expecting class name");
1831 skip_to_semi (cfile);
1832 return 0;
1833 }
1834
1835 /* See if there's already a class with the specified name. */
1836 find_class (&pc, val, MDL);
1837
1838 /* If this isn't a subclass, we're updating an existing class. */
1839 if (pc && type != 0 && type != 1 && type != 3) {
1840 class_reference (&class, pc, MDL);
1841 new = 0;
1842 class_dereference (&pc, MDL);
1843 }
1844
1845 /* If this _is_ a subclass, there _must_ be a class with the
1846 same name. */
1847 if (!pc && (type == 0 || type == 1 || type == 3)) {
1848 parse_warn (cfile, "no class named %s", val);
1849 skip_to_semi (cfile);
1850 return 0;
1851 }
1852
1853 /* The old vendor-class and user-class declarations had an implicit
1854 match. We don't do the implicit match anymore. Instead, for
1855 backward compatibility, we have an implicit-vendor-class and an
1856 implicit-user-class. vendor-class and user-class declarations
1857 are turned into subclasses of the implicit classes, and the
1858 submatch expression of the implicit classes extracts the contents of
1859 the vendor class or user class. */
1860 if (type == 0 || type == 1) {
1861 data.len = strlen (val);
1862 data.buffer = (struct buffer *)0;
1863 if (!buffer_allocate (&data.buffer, data.len + 1, MDL))
1864 log_fatal ("no memory for class name.");
1865 data.data = &data.buffer -> data [0];
1866 data.terminated = 1;
1867
1868 tname = type ? "implicit-vendor-class" : "implicit-user-class";
1869 } else if (type == 2) {
1870 tname = val;
1871 } else {
1872 tname = (const char *)0;
1873 }
1874
1875 if (tname) {
1876 name = dmalloc (strlen (tname) + 1, MDL);
1877 if (!name)
1878 log_fatal ("No memory for class name %s.", tname);
1879 strcpy (name, val);
1880 } else
1881 name = (char *)0;
1882
1883 /* If this is a straight subclass, parse the hash string. */
1884 if (type == 3) {
1885 token = peek_token (&val, (unsigned *)0, cfile);
1886 if (token == STRING) {
1887 token = next_token (&val, &data.len, cfile);
1888 data.buffer = (struct buffer *)0;
1889 if (!buffer_allocate (&data.buffer,
1890 data.len + 1, MDL)) {
1891 if (pc)
1892 class_dereference (&pc, MDL);
1893
1894 return 0;
1895 }
1896 data.terminated = 1;
1897 data.data = &data.buffer -> data [0];
1898 memcpy ((char *)data.buffer -> data, val,
1899 data.len + 1);
1900 } else if (token == NUMBER_OR_NAME || token == NUMBER) {
1901 memset (&data, 0, sizeof data);
1902 if (!parse_cshl (&data, cfile)) {
1903 class_dereference (&pc, MDL);
1904 return 0;
1905 }
1906 } else {
1907 parse_warn (cfile, "Expecting string or hex list.");
1908 if (pc)
1909 class_dereference (&pc, MDL);
1910 return 0;
1911 }
1912 }
1913
1914 /* See if there's already a class in the hash table matching the
1915 hash data. */
1916 if (type == 0 || type == 1 || type == 3)
1917 class_hash_lookup (&class, pc -> hash,
1918 (const char *)data.data, data.len, MDL);
1919
1920 /* If we didn't find an existing class, allocate a new one. */
1921 if (!class) {
1922 /* Allocate the class structure... */
1923 status = class_allocate (&class, MDL);
1924 if (pc) {
1925 group_reference (&class -> group, pc -> group, MDL);
1926 class_reference (&class -> superclass, pc, MDL);
1927 class -> lease_limit = pc -> lease_limit;
1928 if (class -> lease_limit) {
1929 class -> billed_leases =
1930 dmalloc (class -> lease_limit *
1931 sizeof (struct lease *), MDL);
1932 if (!class -> billed_leases)
1933 log_fatal ("no memory for billing");
1934 memset (class -> billed_leases, 0,
1935 (class -> lease_limit *
1936 sizeof class -> billed_leases));
1937 }
1938 data_string_copy (&class -> hash_string, &data, MDL);
1939 if (!pc -> hash &&
1940 !class_new_hash (&pc -> hash, 0, MDL))
1941 log_fatal ("No memory for subclass hash.");
1942 class_hash_add (pc -> hash,
1943 (const char *)class -> hash_string.data,
1944 class -> hash_string.len,
1945 (void *)class, MDL);
1946 } else {
1947 if (!clone_group (&class -> group, group, MDL))
1948 log_fatal ("no memory to clone class group.");
1949 }
1950
1951 /* If this is an implicit vendor or user class, add a
1952 statement that causes the vendor or user class ID to
1953 be sent back in the reply. */
1954 if (type == 0 || type == 1) {
1955 stmt = (struct executable_statement *)0;
1956 if (!executable_statement_allocate (&stmt, MDL))
1957 log_fatal ("no memory for class statement.");
1958 stmt -> op = supersede_option_statement;
1959 if (option_cache_allocate (&stmt -> data.option,
1960 MDL)) {
1961 stmt -> data.option -> data = data;
1962 stmt -> data.option -> option =
1963 dhcp_universe.options
1964 [type
1965 ? DHO_VENDOR_CLASS_IDENTIFIER
1966 : DHO_USER_CLASS];
1967 }
1968 class -> statements = stmt;
1969 }
1970
1971 /* Save the name, if there is one. */
1972 class -> name = name;
1973 }
1974
1975 if (type == 0 || type == 1 || type == 3)
1976 data_string_forget (&data, MDL);
1977
1978 /* Spawned classes don't have to have their own settings. */
1979 if (class -> superclass) {
1980 token = peek_token (&val, (unsigned *)0, cfile);
1981 if (token == SEMI) {
1982 next_token (&val, (unsigned *)0, cfile);
1983 if (cp)
1984 status = class_reference (cp, class, MDL);
1985 class_dereference (&class, MDL);
1986 if (pc)
1987 class_dereference (&pc, MDL);
1988 return cp ? (status == ISC_R_SUCCESS) : 1;
1989 }
1990 /* Give the subclass its own group. */
1991 if (!clone_group (&class -> group, class -> group, MDL))
1992 log_fatal ("can't clone class group.");
1993
1994 }
1995
1996 if (!parse_lbrace (cfile)) {
1997 class_dereference (&class, MDL);
1998 if (pc)
1999 class_dereference (&pc, MDL);
2000 return 0;
2001 }
2002
2003 do {
2004 token = peek_token (&val, (unsigned *)0, cfile);
2005 if (token == RBRACE) {
2006 token = next_token (&val, (unsigned *)0, cfile);
2007 break;
2008 } else if (token == END_OF_FILE) {
2009 token = next_token (&val, (unsigned *)0, cfile);
2010 parse_warn (cfile, "unexpected end of file");
2011 break;
2012 } else if (token == MATCH) {
2013 if (pc) {
2014 parse_warn (cfile,
2015 "invalid match in subclass.");
2016 skip_to_semi (cfile);
2017 break;
2018 }
2019 token = next_token (&val, (unsigned *)0, cfile);
2020 token = peek_token (&val, (unsigned *)0, cfile);
2021 if (token != IF)
2022 goto submatch;
2023 if (class -> expr) {
2024 parse_warn (cfile, "can't override match.");
2025 skip_to_semi (cfile);
2026 break;
2027 }
2028 token = next_token (&val, (unsigned *)0, cfile);
2029 if (!parse_boolean_expression (&class -> expr, cfile,
2030 &lose)) {
2031 if (!lose) {
2032 parse_warn (cfile,
2033 "expecting boolean expr.");
2034 skip_to_semi (cfile);
2035 }
2036 } else {
2037 #if defined (DEBUG_EXPRESSION_PARSE)
2038 print_expression ("class match",
2039 class -> expr);
2040 #endif
2041 parse_semi (cfile);
2042 }
2043 } else if (token == SPAWN) {
2044 if (pc) {
2045 parse_warn (cfile,
2046 "invalid spawn in subclass.");
2047 skip_to_semi (cfile);
2048 break;
2049 }
2050 token = next_token (&val, (unsigned *)0, cfile);
2051 class -> spawning = 1;
2052 token = next_token (&val, (unsigned *)0, cfile);
2053 if (token != WITH) {
2054 parse_warn (cfile,
2055 "expecting with after spawn");
2056 skip_to_semi (cfile);
2057 break;
2058 }
2059 submatch:
2060 if (class -> submatch) {
2061 parse_warn (cfile,
2062 "can't override existing %s.",
2063 "submatch/spawn");
2064 skip_to_semi (cfile);
2065 break;
2066 }
2067 if (!parse_data_expression (&class -> submatch,
2068 cfile, &lose)) {
2069 if (!lose) {
2070 parse_warn (cfile,
2071 "expecting data expr.");
2072 skip_to_semi (cfile);
2073 }
2074 } else {
2075 #if defined (DEBUG_EXPRESSION_PARSE)
2076 print_expression ("class submatch",
2077 class -> submatch);
2078 #endif
2079 parse_semi (cfile);
2080 }
2081 } else if (token == LEASE) {
2082 next_token (&val, (unsigned *)0, cfile);
2083 token = next_token (&val, (unsigned *)0, cfile);
2084 if (token != LIMIT) {
2085 parse_warn (cfile, "expecting \"limit\"");
2086 if (token != SEMI)
2087 skip_to_semi (cfile);
2088 break;
2089 }
2090 token = next_token (&val, (unsigned *)0, cfile);
2091 if (token != NUMBER) {
2092 parse_warn (cfile, "expecting a number");
2093 if (token != SEMI)
2094 skip_to_semi (cfile);
2095 break;
2096 }
2097 class -> lease_limit = atoi (val);
2098 class -> billed_leases =
2099 dmalloc (class -> lease_limit *
2100 sizeof (struct lease *), MDL);
2101 if (!class -> billed_leases)
2102 log_fatal ("no memory for billed leases.");
2103 memset (class -> billed_leases, 0,
2104 (class -> lease_limit *
2105 sizeof class -> billed_leases));
2106 have_billing_classes = 1;
2107 parse_semi (cfile);
2108 } else {
2109 declaration = parse_statement (cfile, class -> group,
2110 CLASS_DECL,
2111 (struct host_decl *)0,
2112 declaration);
2113 }
2114 } while (1);
2115 if (type == 2 && new) {
2116 if (!collections -> classes)
2117 class_reference (&collections -> classes, class, MDL);
2118 else {
2119 struct class *c;
2120 for (c = collections -> classes;
2121 c -> nic; c = c -> nic)
2122 ;
2123 class_reference (&c -> nic, class, MDL);
2124 }
2125 }
2126 if (cp)
2127 status = class_reference (cp, class, MDL);
2128 class_dereference (&class, MDL);
2129 if (pc)
2130 class_dereference (&pc, MDL);
2131 return cp ? (status == ISC_R_SUCCESS) : 1;
2132 }
2133
2134 /* shared-network-declaration :==
2135 hostname LBRACE declarations parameters RBRACE */
2136
2137 void parse_shared_net_declaration (cfile, group)
2138 struct parse *cfile;
2139 struct group *group;
2140 {
2141 const char *val;
2142 enum dhcp_token token;
2143 struct shared_network *share;
2144 char *name;
2145 int declaration = 0;
2146 isc_result_t status;
2147
2148 share = (struct shared_network *)0;
2149 status = shared_network_allocate (&share, MDL);
2150 if (status != ISC_R_SUCCESS)
2151 log_fatal ("Can't allocate shared subnet: %s",
2152 isc_result_totext (status));
2153 clone_group (&share -> group, group, MDL);
2154 shared_network_reference (&share -> group -> shared_network,
2155 share, MDL);
2156
2157 /* Get the name of the shared network... */
2158 token = peek_token (&val, (unsigned *)0, cfile);
2159 if (token == STRING) {
2160 token = next_token (&val, (unsigned *)0, cfile);
2161
2162 if (val [0] == 0) {
2163 parse_warn (cfile, "zero-length shared network name");
2164 val = "<no-name-given>";
2165 }
2166 name = dmalloc (strlen (val) + 1, MDL);
2167 if (!name)
2168 log_fatal ("no memory for shared network name");
2169 strcpy (name, val);
2170 } else {
2171 name = parse_host_name (cfile);
2172 if (!name) {
2173 parse_warn (cfile,
2174 "expecting a name for shared-network");
2175 skip_to_semi (cfile);
2176 shared_network_dereference (&share, MDL);
2177 return;
2178 }
2179 }
2180 share -> name = name;
2181
2182 if (!parse_lbrace (cfile)) {
2183 shared_network_dereference (&share, MDL);
2184 return;
2185 }
2186
2187 do {
2188 token = peek_token (&val, (unsigned *)0, cfile);
2189 if (token == RBRACE) {
2190 token = next_token (&val, (unsigned *)0, cfile);
2191 if (!share -> subnets)
2192 parse_warn (cfile,
2193 "empty shared-network decl");
2194 else
2195 enter_shared_network (share);
2196 shared_network_dereference (&share, MDL);
2197 return;
2198 } else if (token == END_OF_FILE) {
2199 token = next_token (&val, (unsigned *)0, cfile);
2200 parse_warn (cfile, "unexpected end of file");
2201 break;
2202 } else if (token == INTERFACE) {
2203 token = next_token (&val, (unsigned *)0, cfile);
2204 token = next_token (&val, (unsigned *)0, cfile);
2205 new_shared_network_interface (cfile, share, val);
2206 if (!parse_semi (cfile))
2207 break;
2208 continue;
2209 }
2210
2211 declaration = parse_statement (cfile, share -> group,
2212 SHARED_NET_DECL,
2213 (struct host_decl *)0,
2214 declaration);
2215 } while (1);
2216 shared_network_dereference (&share, MDL);
2217 }
2218
2219 /* subnet-declaration :==
2220 net NETMASK netmask RBRACE parameters declarations LBRACE */
2221
2222 void parse_subnet_declaration (cfile, share)
2223 struct parse *cfile;
2224 struct shared_network *share;
2225 {
2226 const char *val;
2227 enum dhcp_token token;
2228 struct subnet *subnet, *t, *u;
2229 struct iaddr iaddr;
2230 unsigned char addr [4];
2231 unsigned len = sizeof addr;
2232 int declaration = 0;
2233 struct interface_info *ip;
2234 isc_result_t status;
2235
2236 subnet = (struct subnet *)0;
2237 status = subnet_allocate (&subnet, MDL);
2238 if (status != ISC_R_SUCCESS)
2239 log_fatal ("Allocation of new subnet failed: %s",
2240 isc_result_totext (status));
2241 shared_network_reference (&subnet -> shared_network, share, MDL);
2242 if (!clone_group (&subnet -> group, share -> group, MDL))
2243 log_fatal ("allocation of group for new subnet failed.");
2244 subnet_reference (&subnet -> group -> subnet, subnet, MDL);
2245
2246 /* Get the network number... */
2247 if (!parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8)) {
2248 subnet_dereference (&subnet, MDL);
2249 return;
2250 }
2251 memcpy (iaddr.iabuf, addr, len);
2252 iaddr.len = len;
2253 subnet -> net = iaddr;
2254
2255 token = next_token (&val, (unsigned *)0, cfile);
2256 if (token != NETMASK) {
2257 parse_warn (cfile, "Expecting netmask");
2258 skip_to_semi (cfile);
2259 return;
2260 }
2261
2262 /* Get the netmask... */
2263 if (!parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8)) {
2264 subnet_dereference (&subnet, MDL);
2265 return;
2266 }
2267 memcpy (iaddr.iabuf, addr, len);
2268 iaddr.len = len;
2269 subnet -> netmask = iaddr;
2270
2271 /* Validate the network number/netmask pair. */
2272 if (host_addr (subnet -> net, subnet -> netmask)) {
2273 char *maskstr;
2274
2275 maskstr = strdup (piaddr (subnet -> netmask));
2276 parse_warn (cfile,
2277 "subnet %s netmask %s: bad subnet number/mask combination.",
2278 piaddr (subnet -> net), maskstr);
2279 free(maskstr);
2280 subnet_dereference (&subnet, MDL);
2281 skip_to_semi (cfile);
2282 return;
2283 }
2284
2285 enter_subnet (subnet);
2286
2287 if (!parse_lbrace (cfile)) {
2288 subnet_dereference (&subnet, MDL);
2289 return;
2290 }
2291
2292 do {
2293 token = peek_token (&val, (unsigned *)0, cfile);
2294 if (token == RBRACE) {
2295 token = next_token (&val, (unsigned *)0, cfile);
2296 break;
2297 } else if (token == END_OF_FILE) {
2298 token = next_token (&val, (unsigned *)0, cfile);
2299 parse_warn (cfile, "unexpected end of file");
2300 break;
2301 } else if (token == INTERFACE) {
2302 token = next_token (&val, (unsigned *)0, cfile);
2303 token = next_token (&val, (unsigned *)0, cfile);
2304 new_shared_network_interface (cfile, share, val);
2305 if (!parse_semi (cfile))
2306 break;
2307 continue;
2308 }
2309 declaration = parse_statement (cfile, subnet -> group,
2310 SUBNET_DECL,
2311 (struct host_decl *)0,
2312 declaration);
2313 } while (1);
2314
2315 /* Add the subnet to the list of subnets in this shared net. */
2316 if (!share -> subnets)
2317 subnet_reference (&share -> subnets, subnet, MDL);
2318 else {
2319 u = (struct subnet *)0;
2320 for (t = share -> subnets;
2321 t -> next_sibling; t = t -> next_sibling) {
2322 if (subnet_inner_than (subnet, t, 0)) {
2323 subnet_reference (&subnet -> next_sibling,
2324 t, MDL);
2325 if (u) {
2326 subnet_dereference (&u -> next_sibling,
2327 MDL);
2328 subnet_reference (&u -> next_sibling,
2329 subnet, MDL);
2330 } else {
2331 subnet_dereference (&share -> subnets,
2332 MDL);
2333 subnet_reference (&share -> subnets,
2334 subnet, MDL);
2335 }
2336 subnet_dereference (&subnet, MDL);
2337 return;
2338 }
2339 u = t;
2340 }
2341 subnet_reference (&t -> next_sibling, subnet, MDL);
2342 }
2343 subnet_dereference (&subnet, MDL);
2344 }
2345
2346 /* group-declaration :== RBRACE parameters declarations LBRACE */
2347
2348 void parse_group_declaration (cfile, group)
2349 struct parse *cfile;
2350 struct group *group;
2351 {
2352 const char *val;
2353 enum dhcp_token token;
2354 struct group *g;
2355 int declaration = 0;
2356 struct group_object *t;
2357 isc_result_t status;
2358 char *name = NULL;
2359 int deletedp = 0;
2360 int dynamicp = 0;
2361 int staticp = 0;
2362
2363 g = (struct group *)0;
2364 if (!clone_group (&g, group, MDL))
2365 log_fatal ("no memory for explicit group.");
2366
2367 token = peek_token (&val, (unsigned *)0, cfile);
2368 if (is_identifier (token) || token == STRING) {
2369 next_token (&val, (unsigned *)0, cfile);
2370
2371 name = dmalloc (strlen (val) + 1, MDL);
2372 if (!name)
2373 log_fatal ("no memory for group decl name %s", val);
2374 strcpy (name, val);
2375 }
2376
2377 if (!parse_lbrace (cfile)) {
2378 group_dereference (&g, MDL);
2379 return;
2380 }
2381
2382 do {
2383 token = peek_token (&val, (unsigned *)0, cfile);
2384 if (token == RBRACE) {
2385 token = next_token (&val, (unsigned *)0, cfile);
2386 break;
2387 } else if (token == END_OF_FILE) {
2388 token = next_token (&val, (unsigned *)0, cfile);
2389 parse_warn (cfile, "unexpected end of file");
2390 break;
2391 } else if (token == TOKEN_DELETED) {
2392 token = next_token (&val, (unsigned *)0, cfile);
2393 parse_semi (cfile);
2394 deletedp = 1;
2395 } else if (token == DYNAMIC) {
2396 token = next_token (&val, (unsigned *)0, cfile);
2397 parse_semi (cfile);
2398 dynamicp = 1;
2399 } else if (token == _STATIC) {
2400 token = next_token (&val, (unsigned *)0, cfile);
2401 parse_semi (cfile);
2402 staticp = 1;
2403 }
2404 declaration = parse_statement (cfile, g, GROUP_DECL,
2405 (struct host_decl *)0,
2406 declaration);
2407 } while (1);
2408
2409 if (name) {
2410 if (deletedp) {
2411 if (group_name_hash) {
2412 t = (struct group_object *)0;
2413 if (group_hash_lookup (&t, group_name_hash,
2414 name,
2415 strlen (name), MDL)) {
2416 delete_group (t, 0);
2417 }
2418 }
2419 } else {
2420 t = (struct group_object *)0;
2421 status = group_object_allocate (&t, MDL);
2422 if (status != ISC_R_SUCCESS)
2423 log_fatal ("no memory for group decl %s: %s",
2424 val, isc_result_totext (status));
2425 group_reference (&t -> group, g, MDL);
2426 t -> name = name;
2427 t -> flags = ((staticp ? GROUP_OBJECT_STATIC : 0) |
2428 (dynamicp ? GROUP_OBJECT_DYNAMIC : 0) |
2429 (deletedp ? GROUP_OBJECT_DELETED : 0));
2430 supersede_group (t, 0);
2431 }
2432 if (t)
2433 group_object_dereference (&t, MDL);
2434 }
2435 }
2436
2437 /* fixed-addr-parameter :== ip-addrs-or-hostnames SEMI
2438 ip-addrs-or-hostnames :== ip-addr-or-hostname
2439 | ip-addrs-or-hostnames ip-addr-or-hostname */
2440
2441 int parse_fixed_addr_param (oc, cfile)
2442 struct option_cache **oc;
2443 struct parse *cfile;
2444 {
2445 const char *val;
2446 enum dhcp_token token;
2447 struct expression *expr = (struct expression *)0;
2448 struct expression *tmp, *new;
2449 int status;
2450
2451 do {
2452 tmp = (struct expression *)0;
2453 if (parse_ip_addr_or_hostname (&tmp, cfile, 1)) {
2454 if (expr) {
2455 new = (struct expression *)0;
2456 status = make_concat (&new, expr, tmp);
2457 expression_dereference (&expr, MDL);
2458 expression_dereference (&tmp, MDL);
2459 if (!status)
2460 return 0;
2461 expr = new;
2462 } else
2463 expr = tmp;
2464 } else {
2465 if (expr)
2466 expression_dereference (&expr, MDL);
2467 return 0;
2468 }
2469 token = peek_token (&val, (unsigned *)0, cfile);
2470 if (token == COMMA)
2471 token = next_token (&val, (unsigned *)0, cfile);
2472 } while (token == COMMA);
2473
2474 if (!parse_semi (cfile)) {
2475 if (expr)
2476 expression_dereference (&expr, MDL);
2477 return 0;
2478 }
2479 status = option_cache (oc, (struct data_string *)0, expr,
2480 (struct option *)0, MDL);
2481 expression_dereference (&expr, MDL);
2482 return status;
2483 }
2484
2485 /* timestamp :== date
2486
2487 Timestamps are actually not used in dhcpd.conf, which is a static file,
2488 but rather in the database file and the journal file. (Okay, actually
2489 they're not even used there yet). */
2490
2491 TIME parse_timestamp (cfile)
2492 struct parse *cfile;
2493 {
2494 TIME rv;
2495
2496 rv = parse_date (cfile);
2497 return rv;
2498 }
2499
2500 /* lease_declaration :== LEASE ip_address LBRACE lease_parameters RBRACE
2501
2502 lease_parameters :== <nil>
2503 | lease_parameter
2504 | lease_parameters lease_parameter
2505
2506 lease_parameter :== STARTS date
2507 | ENDS date
2508 | TIMESTAMP date
2509 | HARDWARE hardware-parameter
2510 | UID hex_numbers SEMI
2511 | HOSTNAME hostname SEMI
2512 | CLIENT_HOSTNAME hostname SEMI
2513 | CLASS identifier SEMI
2514 | DYNAMIC_BOOTP SEMI */
2515
2516 int parse_lease_declaration (struct lease **lp, struct parse *cfile)
2517 {
2518 const char *val;
2519 enum dhcp_token token;
2520 unsigned char addr [4];
2521 unsigned len = sizeof addr;
2522 int seenmask = 0;
2523 int seenbit;
2524 char tbuf [32];
2525 struct lease *lease;
2526 struct executable_statement *on;
2527 struct expression *exp;
2528 struct data_string ds;
2529 int lose;
2530 TIME t;
2531 char *s;
2532 int noequal, newbinding;
2533 struct binding *binding;
2534 isc_result_t status;
2535 struct option_cache *oc;
2536 pair *p;
2537 binding_state_t new_state;
2538 unsigned buflen = 0;
2539 struct class *class;
2540
2541 lease = (struct lease *)0;
2542 status = lease_allocate (&lease, MDL);
2543 if (status != ISC_R_SUCCESS)
2544 return 0;
2545
2546 /* Get the address for which the lease has been issued. */
2547 if (!parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8)) {
2548 lease_dereference (&lease, MDL);
2549 return 0;
2550 }
2551 memcpy (lease -> ip_addr.iabuf, addr, len);
2552 lease -> ip_addr.len = len;
2553
2554 if (!parse_lbrace (cfile)) {
2555 lease_dereference (&lease, MDL);
2556 return 0;
2557 }
2558
2559 do {
2560 token = next_token (&val, (unsigned *)0, cfile);
2561 if (token == RBRACE)
2562 break;
2563 else if (token == END_OF_FILE) {
2564 parse_warn (cfile, "unexpected end of file");
2565 break;
2566 }
2567 strncpy (tbuf, val, sizeof tbuf);
2568 tbuf [(sizeof tbuf) - 1] = 0;
2569
2570 /* Parse any of the times associated with the lease. */
2571 switch (token) {
2572 case STARTS:
2573 case ENDS:
2574 case TIMESTAMP:
2575 case TSTP:
2576 case TSFP:
2577 case CLTT:
2578 t = parse_date (cfile);
2579 switch (token) {
2580 case STARTS:
2581 seenbit = 1;
2582 lease -> starts = t;
2583 break;
2584
2585 case ENDS:
2586 seenbit = 2;
2587 lease -> ends = t;
2588 break;
2589
2590 case TIMESTAMP:
2591 seenbit = 4;
2592 lease -> timestamp = t;
2593 break;
2594
2595 case TSTP:
2596 seenbit = 65536;
2597 lease -> tstp = t;
2598 break;
2599
2600 case TSFP:
2601 seenbit = 131072;
2602 lease -> tsfp = t;
2603 break;
2604
2605 case CLTT:
2606 seenbit = 524288;
2607 lease -> cltt = t;
2608 break;
2609
2610 default: /* for gcc, we'll never get here. */
2611 log_fatal ("Impossible error at %s:%d.", MDL);
2612 return 0;
2613 }
2614 break;
2615
2616 /* Colon-seperated hexadecimal octets... */
2617 case UID:
2618 seenbit = 8;
2619 token = peek_token (&val, (unsigned *)0, cfile);
2620 if (token == STRING) {
2621 unsigned char *tuid;
2622 token = next_token (&val, &buflen, cfile);
2623 if (buflen < sizeof lease -> uid_buf) {
2624 tuid = lease -> uid_buf;
2625 lease -> uid_max =
2626 sizeof lease -> uid_buf;
2627 } else {
2628 tuid = ((unsigned char *)
2629 dmalloc (buflen, MDL));
2630 if (!tuid) {
2631 log_error ("no space for uid");
2632 lease_dereference (&lease,
2633 MDL);
2634 return 0;
2635 }
2636 lease -> uid_max = buflen;
2637 }
2638 lease -> uid_len = buflen;
2639 memcpy (tuid, val, lease -> uid_len);
2640 lease -> uid = tuid;
2641 } else {
2642 buflen = 0;
2643 lease -> uid = (parse_numeric_aggregate
2644 (cfile, (unsigned char *)0,
2645 &buflen, ':', 16, 8));
2646 if (!lease -> uid) {
2647 lease_dereference (&lease, MDL);
2648 return 0;
2649 }
2650 lease -> uid_len = buflen;
2651 lease -> uid_max = buflen;
2652 if (lease -> uid_len == 0) {
2653 lease -> uid = (unsigned char *)0;
2654 parse_warn (cfile, "zero-length uid");
2655 seenbit = 0;
2656 parse_semi (cfile);
2657 break;
2658 }
2659 }
2660 parse_semi (cfile);
2661 if (!lease -> uid) {
2662 log_fatal ("No memory for lease uid");
2663 }
2664 break;
2665
2666 case CLASS:
2667 seenbit = 32;
2668 token = next_token (&val, (unsigned *)0, cfile);
2669 if (!is_identifier (token)) {
2670 if (token != SEMI)
2671 skip_to_rbrace (cfile, 1);
2672 lease_dereference (&lease, MDL);
2673 return 0;
2674 }
2675 parse_semi (cfile);
2676 /* for now, we aren't using this. */
2677 break;
2678
2679 case HARDWARE:
2680 seenbit = 64;
2681 parse_hardware_param (cfile,
2682 &lease -> hardware_addr);
2683 break;
2684
2685 case DYNAMIC_BOOTP:
2686 seenbit = 256;
2687 lease -> flags |= BOOTP_LEASE;
2688 parse_semi (cfile);
2689 break;
2690
2691 case TOKEN_ABANDONED:
2692 seenbit = 256;
2693 lease -> binding_state = FTS_ABANDONED;
2694 lease -> next_binding_state = FTS_ABANDONED;
2695 parse_semi (cfile);
2696 break;
2697
2698 case TOKEN_NEXT:
2699 seenbit = 128;
2700 token = next_token (&val, (unsigned *)0, cfile);
2701 if (token != BINDING) {
2702 parse_warn (cfile, "expecting 'binding'");
2703 skip_to_semi (cfile);
2704 break;
2705 }
2706 goto do_binding_state;
2707
2708 case BINDING:
2709 seenbit = 256;
2710
2711 do_binding_state:
2712 token = next_token (&val, (unsigned *)0, cfile);
2713 if (token != STATE) {
2714 parse_warn (cfile, "expecting 'state'");
2715 skip_to_semi (cfile);
2716 break;
2717 }
2718 token = next_token (&val, (unsigned *)0, cfile);
2719 switch (token) {
2720 case TOKEN_ABANDONED:
2721 new_state = FTS_ABANDONED;
2722 break;
2723 case TOKEN_FREE:
2724 new_state = FTS_FREE;
2725 break;
2726 case TOKEN_ACTIVE:
2727 new_state = FTS_ACTIVE;
2728 break;
2729 case TOKEN_EXPIRED:
2730 new_state = FTS_EXPIRED;
2731 break;
2732 case TOKEN_RELEASED:
2733 new_state = FTS_RELEASED;
2734 break;
2735 case TOKEN_RESET:
2736 new_state = FTS_RESET;
2737 break;
2738 case TOKEN_BACKUP:
2739 new_state = FTS_BACKUP;
2740 break;
2741 case TOKEN_RESERVED:
2742 new_state = FTS_ACTIVE;
2743 break;
2744 case TOKEN_BOOTP:
2745 new_state = FTS_ACTIVE;
2746 lease -> flags |= BOOTP_LEASE;
2747 break;
2748 default:
2749 parse_warn (cfile,
2750 "%s: expecting a binding state.",
2751 val);
2752 skip_to_semi (cfile);
2753 return 0;
2754 }
2755
2756 if (seenbit == 256) {
2757 lease -> binding_state = new_state;
2758
2759 /* If no next binding state is specified, it's
2760 the same as the current state. */
2761 if (!(seenmask & 128))
2762 lease -> next_binding_state = new_state;
2763 } else
2764 lease -> next_binding_state = new_state;
2765
2766 parse_semi (cfile);
2767 break;
2768
2769 case CLIENT_HOSTNAME:
2770 seenbit = 1024;
2771 token = peek_token (&val, (unsigned *)0, cfile);
2772 if (token == STRING) {
2773 if (!parse_string (cfile,
2774 &lease -> client_hostname,
2775 (unsigned *)0)) {
2776 lease_dereference (&lease, MDL);
2777 return 0;
2778 }
2779 } else {
2780 lease -> client_hostname =
2781 parse_host_name (cfile);
2782 if (lease -> client_hostname)
2783 parse_semi (cfile);
2784 else {
2785 parse_warn (cfile,
2786 "expecting a hostname.");
2787 skip_to_semi (cfile);
2788 lease_dereference (&lease, MDL);
2789 return 0;
2790 }
2791 }
2792 break;
2793
2794 case BILLING:
2795 seenbit = 2048;
2796 class = (struct class *)0;
2797 token = next_token (&val, (unsigned *)0, cfile);
2798 if (token == CLASS) {
2799 token = next_token (&val,
2800 (unsigned *)0, cfile);
2801 if (token != STRING) {
2802 parse_warn (cfile, "expecting string");
2803 if (token != SEMI)
2804 skip_to_semi (cfile);
2805 token = BILLING;
2806 break;
2807 }
2808 if (lease -> billing_class)
2809 class_dereference (&lease -> billing_class,
2810 MDL);
2811 find_class (&class, val, MDL);
2812 if (!class)
2813 parse_warn (cfile,
2814 "unknown class %s", val);
2815 parse_semi (cfile);
2816 } else if (token == SUBCLASS) {
2817 if (lease -> billing_class)
2818 class_dereference (&lease -> billing_class,
2819 MDL);
2820 parse_class_declaration
2821 (&class,
2822 cfile, (struct group *)0, 3);
2823 } else {
2824 parse_warn (cfile, "expecting \"class\"");
2825 if (token != SEMI)
2826 skip_to_semi (cfile);
2827 }
2828 if (class) {
2829 class_reference (&lease -> billing_class,
2830 class, MDL);
2831 class_dereference (&class, MDL);
2832 }
2833 break;
2834
2835 case ON:
2836 on = (struct executable_statement *)0;
2837 lose = 0;
2838 if (!parse_on_statement (&on, cfile, &lose)) {
2839 skip_to_rbrace (cfile, 1);
2840 lease_dereference (&lease, MDL);
2841 return 0;
2842 }
2843 seenbit = 0;
2844 if ((on -> data.on.evtypes & ON_EXPIRY) &&
2845 on -> data.on.statements) {
2846 seenbit |= 16384;
2847 executable_statement_reference
2848 (&lease -> on_expiry,
2849 on -> data.on.statements, MDL);
2850 }
2851 if ((on -> data.on.evtypes & ON_RELEASE) &&
2852 on -> data.on.statements) {
2853 seenbit |= 32768;
2854 executable_statement_reference
2855 (&lease -> on_release,
2856 on -> data.on.statements, MDL);
2857 }
2858 executable_statement_dereference (&on, MDL);
2859 break;
2860
2861 case OPTION:
2862 case SUPERSEDE:
2863 noequal = 0;
2864 seenbit = 0;
2865 oc = (struct option_cache *)0;
2866 if (parse_option_decl (&oc, cfile)) {
2867 if (oc -> option -> universe !=
2868 &agent_universe) {
2869 parse_warn (cfile,
2870 "agent option expected.");
2871 option_cache_dereference (&oc, MDL);
2872 break;
2873 }
2874 if (!lease -> agent_options &&
2875 !(option_chain_head_allocate
2876 (&lease -> agent_options, MDL))) {
2877 log_error ("no memory to stash agent option");
2878 break;
2879 }
2880 for (p = &lease -> agent_options -> first;
2881 *p; p = &((*p) -> cdr))
2882 ;
2883 *p = cons (0, 0);
2884 option_cache_reference (((struct option_cache **)
2885 &((*p) -> car)), oc, MDL);
2886 option_cache_dereference (&oc, MDL);
2887 }
2888 break;
2889
2890 case TOKEN_SET:
2891 noequal = 0;
2892
2893 token = next_token (&val, (unsigned *)0, cfile);
2894 if (token != NAME && token != NUMBER_OR_NAME) {
2895 parse_warn (cfile,
2896 "%s can't be a variable name",
2897 val);
2898 badset:
2899 skip_to_semi (cfile);
2900 lease_dereference (&lease, MDL);
2901 return 0;
2902 }
2903
2904 seenbit = 0;
2905 special_set:
2906 if (lease -> scope)
2907 binding = find_binding (lease -> scope, val);
2908 else
2909 binding = (struct binding *)0;
2910 if (!binding) {
2911 if (!lease -> scope)
2912 if (!(binding_scope_allocate
2913 (&lease -> scope, MDL)))
2914 log_fatal ("no memory for scope");
2915 binding = dmalloc (sizeof *binding, MDL);
2916 if (!binding)
2917 log_fatal ("No memory for lease %s.",
2918 "binding");
2919 memset (binding, 0, sizeof *binding);
2920 binding -> name =
2921 dmalloc (strlen (val) + 1, MDL);
2922 if (!binding -> name)
2923 log_fatal ("No memory for binding %s.",
2924 "name");
2925 strcpy (binding -> name, val);
2926 newbinding = 1;
2927 } else {
2928 if (binding -> value)
2929 binding_value_dereference (&binding -> value,
2930 MDL);
2931 newbinding = 0;
2932 }
2933
2934 if (!binding_value_allocate (&binding -> value, MDL))
2935 log_fatal ("no memory for binding value.");
2936
2937 if (!noequal) {
2938 token = next_token (&val, (unsigned *)0, cfile);
2939 if (token != EQUAL) {
2940 parse_warn (cfile,
2941 "expecting '=' in set statement.");
2942 goto badset;
2943 }
2944 }
2945
2946 token = peek_token (&val, (unsigned *)0, cfile);
2947 if (token == STRING) {
2948 unsigned char *tuid;
2949 token = next_token (&val, &buflen, cfile);
2950 binding -> value -> type = binding_data;
2951 binding -> value -> value.data.len = buflen;
2952 if (!(buffer_allocate
2953 (&binding -> value -> value.data.buffer,
2954 buflen + 1, MDL)))
2955 log_fatal ("No memory for binding.");
2956 memcpy ((char *)
2957 (binding -> value ->
2958 value.data.buffer -> data),
2959 val, buflen + 1);
2960 binding -> value -> value.data.data =
2961 binding -> value -> value.data.buffer -> data;
2962 binding -> value -> value.data.terminated = 1;
2963 } else if (token == NUMBER_OR_NAME) {
2964 binding -> value -> type = binding_data;
2965 s = ((char *)
2966 (parse_numeric_aggregate
2967 (cfile, (unsigned char *)0,
2968 &binding -> value -> value.data.len,
2969 ':', 16, 8)));
2970 if (!s) {
2971 binding_value_dereference
2972 (&binding -> value, MDL);
2973 lease_dereference (&lease, MDL);
2974 return 0;
2975 }
2976 if (binding -> value -> value.data.len) {
2977 if (!(buffer_allocate
2978 (&binding -> value -> value.data.buffer,
2979 binding -> value -> value.data.len + 1,
2980 MDL)))
2981 log_fatal ("No memory for binding.");
2982 memcpy ((binding -> value ->
2983 value.data.buffer -> data), s,
2984 binding -> value -> value.data.len);
2985 dfree (s, MDL);
2986 binding -> value -> value.data.data =
2987 binding -> value -> value.data.buffer -> data;
2988 }
2989 } else if (token == PERCENT) {
2990 token = next_token (&val, (unsigned *)0, cfile);
2991 token = next_token (&val, (unsigned *)0, cfile);
2992 if (token != NUMBER) {
2993 parse_warn (cfile,
2994 "expecting decimal number.");
2995 if (token != SEMI)
2996 skip_to_semi (cfile);
2997 binding_value_dereference
2998 (&binding -> value, MDL);
2999 lease_dereference (&lease, MDL);
3000 return 0;
3001 }
3002 binding -> value -> type = binding_numeric;
3003 binding -> value -> value.intval = atol (val);
3004 } else if (token == NAME) {
3005 token = next_token (&val,
3006 (unsigned *)0, cfile);
3007 binding -> value -> type = binding_boolean;
3008 if (!strcasecmp (val, "true"))
3009 binding -> value -> value.boolean = 1;
3010 else if (!strcasecmp (val, "false"))
3011 binding -> value -> value.boolean = 0;
3012 else
3013 goto badbool;
3014 } else {
3015 badbool:
3016 parse_warn (cfile,
3017 "expecting a constant value.");
3018 skip_to_semi (cfile);
3019 binding_value_dereference (&binding -> value,
3020 MDL);
3021 lease_dereference (&lease, MDL);
3022 return 0;
3023 }
3024
3025 if (newbinding) {
3026 binding -> next = lease -> scope -> bindings;
3027 lease -> scope -> bindings = binding;
3028 }
3029 parse_semi (cfile);
3030 break;
3031
3032 default:
3033 if (!strcasecmp (val, "ddns-fwd-name")) {
3034 seenbit = 4096;
3035 noequal = 1;
3036 goto special_set;
3037 } else if (!strcasecmp (val, "ddns-rev-name")) {
3038 seenbit = 8192;
3039 noequal = 1;
3040 goto special_set;
3041 }
3042 skip_to_semi (cfile);
3043 seenbit = 0;
3044 lease_dereference (&lease, MDL);
3045 return 0;
3046 }
3047
3048 if (seenmask & seenbit) {
3049 parse_warn (cfile,
3050 "Too many %s parameters in lease %s\n",
3051 tbuf, piaddr (lease -> ip_addr));
3052 } else
3053 seenmask |= seenbit;
3054
3055 } while (1);
3056
3057 /* If no binding state is specified, make one up. */
3058 if (!(seenmask & 256)) {
3059 if (lease -> ends > cur_time ||
3060 lease -> on_expiry || lease -> on_release)
3061 lease -> binding_state = FTS_ACTIVE;
3062 #if defined (FAILOVER_PROTOCOL)
3063 else if (lease -> pool && lease -> pool -> failover_peer)
3064 lease -> binding_state = FTS_EXPIRED;
3065 #endif
3066 else
3067 lease -> binding_state = FTS_FREE;
3068 if (lease -> binding_state == FTS_ACTIVE) {
3069 #if defined (FAILOVER_PROTOCOL)
3070 if (lease -> pool && lease -> pool -> failover_peer)
3071 lease -> next_binding_state = FTS_EXPIRED;
3072 else
3073 #endif
3074 lease -> next_binding_state = FTS_FREE;
3075 } else
3076 lease -> next_binding_state = lease -> binding_state;
3077 }
3078
3079 if (!(seenmask & 65536))
3080 lease -> tstp = lease -> ends;
3081
3082 lease_reference (lp, lease, MDL);
3083 lease_dereference (&lease, MDL);
3084 return 1;
3085 }
3086
3087 /* address-range-declaration :== ip-address ip-address SEMI
3088 | DYNAMIC_BOOTP ip-address ip-address SEMI */
3089
3090 void parse_address_range (cfile, group, type, inpool, lpchain)
3091 struct parse *cfile;
3092 struct group *group;
3093 int type;
3094 struct pool *inpool;
3095 struct lease **lpchain;
3096 {
3097 struct iaddr low, high, net;
3098 unsigned char addr [4];
3099 unsigned len = sizeof addr;
3100 enum dhcp_token token;
3101 const char *val;
3102 int dynamic = 0;
3103 struct subnet *subnet;
3104 struct shared_network *share;
3105 struct pool *p;
3106 struct pool *pool;
3107 isc_result_t status;
3108
3109 if ((token = peek_token (&val,
3110 (unsigned *)0, cfile)) == DYNAMIC_BOOTP) {
3111 token = next_token (&val, (unsigned *)0, cfile);
3112 dynamic = 1;
3113 }
3114
3115 /* Get the bottom address in the range... */
3116 if (!parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8))
3117 return;
3118 memcpy (low.iabuf, addr, len);
3119 low.len = len;
3120
3121 /* Only one address? */
3122 token = peek_token (&val, (unsigned *)0, cfile);
3123 if (token == SEMI)
3124 high = low;
3125 else {
3126 /* Get the top address in the range... */
3127 if (!parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8))
3128 return;
3129 memcpy (high.iabuf, addr, len);
3130 high.len = len;
3131 }
3132
3133 token = next_token (&val, (unsigned *)0, cfile);
3134 if (token != SEMI) {
3135 parse_warn (cfile, "semicolon expected.");
3136 skip_to_semi (cfile);
3137 return;
3138 }
3139
3140 if (type == SUBNET_DECL) {
3141 subnet = group -> subnet;
3142 share = subnet -> shared_network;
3143 } else {
3144 share = group -> shared_network;
3145 for (subnet = share -> subnets;
3146 subnet; subnet = subnet -> next_sibling) {
3147 net = subnet_number (low, subnet -> netmask);
3148 if (addr_eq (net, subnet -> net))
3149 break;
3150 }
3151 if (!subnet) {
3152 parse_warn (cfile, "address range not on network %s",
3153 group -> shared_network -> name);
3154 log_error ("Be sure to place pool statement after %s",
3155 "related subnet declarations.");
3156 return;
3157 }
3158 }
3159
3160 if (!inpool) {
3161 struct pool *last = (struct pool *)0;
3162
3163 /* If we're permitting dynamic bootp for this range,
3164 then look for a pool with an empty prohibit list and
3165 a permit list with one entry that permits all clients. */
3166 for (pool = share -> pools; pool; pool = pool -> next) {
3167 if ((!dynamic && !pool -> permit_list &&
3168 pool -> prohibit_list &&
3169 !pool -> prohibit_list -> next &&
3170 (pool -> prohibit_list -> type ==
3171 permit_dynamic_bootp_clients)) ||
3172 (dynamic && !pool -> prohibit_list &&
3173 pool -> permit_list &&
3174 !pool -> permit_list -> next &&
3175 (pool -> permit_list -> type ==
3176 permit_all_clients))) {
3177 break;
3178 }
3179 last = pool;
3180 }
3181
3182 /* If we didn't get a pool, make one. */
3183 if (!pool) {
3184 struct permit *p;
3185 status = pool_allocate (&pool, MDL);
3186 if (status != ISC_R_SUCCESS)
3187 log_fatal ("no memory for ad-hoc pool: %s",
3188 isc_result_totext (status));
3189 p = new_permit (MDL);
3190 if (!p)
3191 log_fatal ("no memory for ad-hoc permit.");
3192
3193 /* Dynamic pools permit all clients. Otherwise
3194 we prohibit BOOTP clients. */
3195 if (dynamic) {
3196 p -> type = permit_all_clients;
3197 pool -> permit_list = p;
3198 } else {
3199 p -> type = permit_dynamic_bootp_clients;
3200 pool -> prohibit_list = p;
3201 }
3202
3203 if (share -> pools)
3204 pool_reference (&last -> next, pool, MDL);
3205 else
3206 pool_reference (&share -> pools, pool, MDL);
3207 shared_network_reference (&pool -> shared_network,
3208 share, MDL);
3209 if (!clone_group (&pool -> group, share -> group, MDL))
3210 log_fatal ("no memory for anon pool group.");
3211 } else {
3212 pool = (struct pool *)0;
3213 if (last)
3214 pool_reference (&pool, last, MDL);
3215 else
3216 pool_reference (&pool, share -> pools, MDL);
3217 }
3218 } else {
3219 pool = (struct pool *)0;
3220 pool_reference (&pool, inpool, MDL);
3221 }
3222
3223 #if defined (FAILOVER_PROTOCOL)
3224 if (pool -> failover_peer && dynamic) {
3225 /* Doctor, do you think I'm overly sensitive
3226 about getting bug reports I can't fix? */
3227 parse_warn (cfile, "dynamic-bootp flag is %s",
3228 "not permitted for address");
3229 log_error ("range declarations where there is a failover");
3230 log_error ("peer in scope. If you wish to declare an");
3231 log_error ("address range from which dynamic bootp leases");
3232 log_error ("can be allocated, please declare it within a");
3233 log_error ("pool declaration that also contains the \"no");
3234 log_error ("failover\" statement. The failover protocol");
3235 log_error ("itself does not permit dynamic bootp - this");
3236 log_error ("is not a limitation specific to the ISC DHCP");
3237 log_error ("server. Please don't ask me to defend this");
3238 log_error ("until you have read and really tried %s",
3239 "to understand");
3240 log_error ("the failover protocol specification.");
3241
3242 /* We don't actually bomb at this point - instead,
3243 we let parse_lease_file notice the error and
3244 bomb at that point - it's easier. */
3245 }
3246 #endif /* FAILOVER_PROTOCOL */
3247
3248 /* Create the new address range... */
3249 new_address_range (cfile, low, high, subnet, pool, lpchain);
3250 pool_dereference (&pool, MDL);
3251 }
3252
3253 /* allow-deny-keyword :== BOOTP
3254 | BOOTING
3255 | DYNAMIC_BOOTP
3256 | UNKNOWN_CLIENTS */
3257
3258 int parse_allow_deny (oc, cfile, flag)
3259 struct option_cache **oc;
3260 struct parse *cfile;
3261 int flag;
3262 {
3263 enum dhcp_token token;
3264 const char *val;
3265 unsigned char rf = flag;
3266 struct expression *data = (struct expression *)0;
3267 int status;
3268
3269 if (!make_const_data (&data, &rf, 1, 0, 1, MDL))
3270 return 0;
3271
3272 token = next_token (&val, (unsigned *)0, cfile);
3273 switch (token) {
3274 case TOKEN_BOOTP:
3275 status = option_cache (oc, (struct data_string *)0, data,
3276 &server_options [SV_ALLOW_BOOTP], MDL);
3277 break;
3278
3279 case BOOTING:
3280 status = option_cache (oc, (struct data_string *)0, data,
3281 &server_options [SV_ALLOW_BOOTING],
3282 MDL);
3283 break;
3284
3285 case DYNAMIC_BOOTP:
3286 status = option_cache (oc, (struct data_string *)0, data,
3287 &server_options [SV_DYNAMIC_BOOTP],
3288 MDL);
3289 break;
3290
3291 case UNKNOWN_CLIENTS:
3292 status = (option_cache
3293 (oc, (struct data_string *)0, data,
3294 &server_options [SV_BOOT_UNKNOWN_CLIENTS], MDL));
3295 break;
3296
3297 case DUPLICATES:
3298 status = option_cache (oc, (struct data_string *)0, data,
3299 &server_options [SV_DUPLICATES], MDL);
3300 break;
3301
3302 case DECLINES:
3303 status = option_cache (oc, (struct data_string *)0, data,
3304 &server_options [SV_DECLINES], MDL);
3305 break;
3306
3307 case CLIENT_UPDATES:
3308 status = option_cache (oc, (struct data_string *)0, data,
3309 &server_options [SV_CLIENT_UPDATES],
3310 MDL);
3311 break;
3312
3313 default:
3314 parse_warn (cfile, "expecting allow/deny key");
3315 skip_to_semi (cfile);
3316 return 0;
3317 }
3318 expression_dereference (&data, MDL);
3319 parse_semi (cfile);
3320 return status;
3321 }
3322
A totally sweet operating system