1 /* $NetBSD: execute.c,v 1.1.1.3 2014/07/12 11:57:44 spz Exp $ */ 2 /* execute.c 3 4 Support for executable statements. */ 5 6 /* 7 * Copyright (c) 2009,2013,2014 by Internet Systems Consortium, Inc. ("ISC") 8 * Copyright (c) 2004-2007 by Internet Systems Consortium, Inc. ("ISC") 9 * Copyright (c) 1998-2003 by Internet Software Consortium 10 * 11 * Permission to use, copy, modify, and distribute this software for any 12 * purpose with or without fee is hereby granted, provided that the above 13 * copyright notice and this permission notice appear in all copies. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 16 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 17 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 18 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 19 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 20 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 21 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 22 * 23 * Internet Systems Consortium, Inc. 24 * 950 Charter Street 25 * Redwood City, CA 94063 26 * <info@isc.org> 27 * https://www.isc.org/ 28 * 29 */ 30 31 #include <sys/cdefs.h> 32 __RCSID("$NetBSD: execute.c,v 1.1.1.3 2014/07/12 11:57:44 spz Exp $"); 33 34 #include "dhcpd.h" 35 #include <omapip/omapip_p.h> 36 #include <sys/types.h> 37 #include <sys/wait.h> 38 39 int execute_statements (result, packet, lease, client_state, 40 in_options, out_options, scope, statements, 41 on_star) 42 struct binding_value **result; 43 struct packet *packet; 44 struct lease *lease; 45 struct client_state *client_state; 46 struct option_state *in_options; 47 struct option_state *out_options; 48 struct binding_scope **scope; 49 struct executable_statement *statements; 50 struct on_star *on_star; 51 { 52 struct executable_statement *r, *e, *next; 53 int rc; 54 int status; 55 struct binding *binding; 56 struct data_string ds; 57 struct binding_scope *ns; 58 59 if (!statements) 60 return 1; 61 62 r = NULL; 63 next = NULL; 64 e = NULL; 65 executable_statement_reference (&r, statements, MDL); 66 while (r && !(result && *result)) { 67 if (r->next) 68 executable_statement_reference (&next, r->next, MDL); 69 switch (r->op) { 70 case statements_statement: 71 #if defined (DEBUG_EXPRESSIONS) 72 log_debug ("exec: statements"); 73 #endif 74 status = execute_statements (result, packet, lease, 75 client_state, in_options, 76 out_options, scope, 77 r->data.statements, 78 on_star); 79 #if defined (DEBUG_EXPRESSIONS) 80 log_debug ("exec: statements returns %d", status); 81 #endif 82 if (!status) 83 return 0; 84 break; 85 86 case on_statement: 87 /* 88 * if we haven't been passed an on_star block but 89 * do have a lease, use the one from the lease 90 * This handles the previous v4 calls. 91 */ 92 if ((on_star == NULL) && (lease != NULL)) 93 on_star = &lease->on_star; 94 95 if (on_star != NULL) { 96 if (r->data.on.evtypes & ON_EXPIRY) { 97 #if defined (DEBUG_EXPRESSIONS) 98 log_debug ("exec: on expiry"); 99 #endif 100 if (on_star->on_expiry) 101 executable_statement_dereference 102 (&on_star->on_expiry, MDL); 103 if (r->data.on.statements) 104 executable_statement_reference 105 (&on_star->on_expiry, 106 r->data.on.statements, MDL); 107 } 108 if (r->data.on.evtypes & ON_RELEASE) { 109 #if defined (DEBUG_EXPRESSIONS) 110 log_debug ("exec: on release"); 111 #endif 112 if (on_star->on_release) 113 executable_statement_dereference 114 (&on_star->on_release, MDL); 115 if (r->data.on.statements) 116 executable_statement_reference 117 (&on_star->on_release, 118 r->data.on.statements, MDL); 119 } 120 if (r->data.on.evtypes & ON_COMMIT) { 121 #if defined (DEBUG_EXPRESSIONS) 122 log_debug ("exec: on commit"); 123 #endif 124 if (on_star->on_commit) 125 executable_statement_dereference 126 (&on_star->on_commit, MDL); 127 if (r->data.on.statements) 128 executable_statement_reference 129 (&on_star->on_commit, 130 r->data.on.statements, MDL); 131 } 132 } 133 break; 134 135 case switch_statement: 136 #if defined (DEBUG_EXPRESSIONS) 137 log_debug ("exec: switch"); 138 #endif 139 status = (find_matching_case 140 (&e, packet, lease, client_state, 141 in_options, out_options, scope, 142 r->data.s_switch.expr, 143 r->data.s_switch.statements)); 144 #if defined (DEBUG_EXPRESSIONS) 145 log_debug ("exec: switch: case %lx", (unsigned long)e); 146 #endif 147 if (status) { 148 if (!(execute_statements 149 (result, packet, lease, client_state, 150 in_options, out_options, scope, e, 151 on_star))) { 152 executable_statement_dereference 153 (&e, MDL); 154 return 0; 155 } 156 executable_statement_dereference (&e, MDL); 157 } 158 break; 159 160 /* These have no effect when executed. */ 161 case case_statement: 162 case default_statement: 163 break; 164 165 case if_statement: 166 status = (evaluate_boolean_expression 167 (&rc, packet, 168 lease, client_state, in_options, 169 out_options, scope, r->data.ie.expr)); 170 171 #if defined (DEBUG_EXPRESSIONS) 172 log_debug ("exec: if %s", (status 173 ? (rc ? "true" : "false") 174 : "NULL")); 175 #endif 176 /* XXX Treat NULL as false */ 177 if (!status) 178 rc = 0; 179 if (!execute_statements 180 (result, packet, lease, client_state, 181 in_options, out_options, scope, 182 rc ? r->data.ie.tc : r->data.ie.fc, 183 on_star)) 184 return 0; 185 break; 186 187 case eval_statement: 188 status = evaluate_expression 189 (NULL, packet, lease, client_state, in_options, 190 out_options, scope, r->data.eval, MDL); 191 #if defined (DEBUG_EXPRESSIONS) 192 log_debug ("exec: evaluate: %s", 193 (status ? "succeeded" : "failed")); 194 #else 195 POST(status); 196 #endif 197 break; 198 199 case execute_statement: { 200 #ifdef ENABLE_EXECUTE 201 struct expression *expr; 202 char **argv; 203 int i, argc = r->data.execute.argc; 204 pid_t p; 205 206 /* save room for the command and the NULL terminator */ 207 argv = dmalloc((argc + 2) * sizeof(*argv), MDL); 208 if (!argv) 209 break; 210 211 argv[0] = dmalloc(strlen(r->data.execute.command) + 1, 212 MDL); 213 if (argv[0]) { 214 strcpy(argv[0], r->data.execute.command); 215 } else { 216 goto execute_out; 217 } 218 219 log_debug("execute_statement argv[0] = %s", argv[0]); 220 221 for (i = 1, expr = r->data.execute.arglist; expr; 222 expr = expr->data.arg.next, i++) { 223 memset (&ds, 0, sizeof(ds)); 224 status = (evaluate_data_expression 225 (&ds, packet, 226 lease, client_state, in_options, 227 out_options, scope, 228 expr->data.arg.val, MDL)); 229 if (status) { 230 argv[i] = dmalloc(ds.len + 1, MDL); 231 if (argv[i]) { 232 memcpy(argv[i], ds.data, 233 ds.len); 234 argv[i][ds.len] = 0; 235 log_debug("execute_statement argv[%d] = %s", i, argv[i]); 236 } 237 data_string_forget (&ds, MDL); 238 if (!argv[i]) { 239 log_debug("execute_statement failed argv[%d]", i); 240 goto execute_out; 241 } 242 } else { 243 log_debug("execute: bad arg %d", i); 244 goto execute_out; 245 } 246 } 247 argv[i] = NULL; 248 249 if ((p = fork()) > 0) { 250 int status; 251 waitpid(p, &status, 0); 252 253 if (status) { 254 log_error("execute: %s exit status %d", 255 argv[0], status); 256 } 257 } else if (p == 0) { 258 execvp(argv[0], argv); 259 log_error("Unable to execute %s: %m", argv[0]); 260 _exit(127); 261 } else { 262 log_error("execute: fork() failed"); 263 } 264 265 execute_out: 266 for (i = 0; i <= argc; i++) { 267 if(argv[i]) 268 dfree(argv[i], MDL); 269 } 270 271 dfree(argv, MDL); 272 #else /* !ENABLE_EXECUTE */ 273 log_fatal("Impossible case at %s:%d (ENABLE_EXECUTE " 274 "is not defined).", MDL); 275 #endif /* ENABLE_EXECUTE */ 276 break; 277 } 278 279 case return_statement: 280 status = evaluate_expression 281 (result, packet, 282 lease, client_state, in_options, 283 out_options, scope, r -> data.retval, MDL); 284 #if defined (DEBUG_EXPRESSIONS) 285 log_debug ("exec: return: %s", 286 (status ? "succeeded" : "failed")); 287 #else 288 POST(status); 289 #endif 290 break; 291 292 case add_statement: 293 #if defined (DEBUG_EXPRESSIONS) 294 log_debug ("exec: add %s", (r->data.add->name 295 ? r->data.add->name 296 : "<unnamed class>")); 297 #endif 298 classify (packet, r->data.add); 299 break; 300 301 case break_statement: 302 #if defined (DEBUG_EXPRESSIONS) 303 log_debug ("exec: break"); 304 #endif 305 return 1; 306 307 case supersede_option_statement: 308 case send_option_statement: 309 #if defined (DEBUG_EXPRESSIONS) 310 log_debug ("exec: %s option %s.%s", 311 (r->op == supersede_option_statement 312 ? "supersede" : "send"), 313 r->data.option->option->universe->name, 314 r->data.option->option->name); 315 goto option_statement; 316 #endif 317 case default_option_statement: 318 #if defined (DEBUG_EXPRESSIONS) 319 log_debug ("exec: default option %s.%s", 320 r->data.option->option->universe->name, 321 r->data.option->option->name); 322 goto option_statement; 323 #endif 324 case append_option_statement: 325 #if defined (DEBUG_EXPRESSIONS) 326 log_debug ("exec: append option %s.%s", 327 r->data.option->option->universe->name, 328 r->data.option->option->name); 329 goto option_statement; 330 #endif 331 case prepend_option_statement: 332 #if defined (DEBUG_EXPRESSIONS) 333 log_debug ("exec: prepend option %s.%s", 334 r->data.option->option->universe->name, 335 r->data.option->option->name); 336 option_statement: 337 #endif 338 set_option (r->data.option->option->universe, 339 out_options, r->data.option, r->op); 340 break; 341 342 case set_statement: 343 case define_statement: 344 status = 1; 345 if (!scope) { 346 log_error("set %s: no scope", 347 r->data.set.name); 348 break; 349 } 350 if (!*scope) { 351 if (!binding_scope_allocate(scope, MDL)) { 352 log_error("set %s: can't allocate scope", 353 r->data.set.name); 354 break; 355 } 356 } 357 binding = find_binding(*scope, r->data.set.name); 358 #if defined (DEBUG_EXPRESSIONS) 359 log_debug("exec: set %s", r->data.set.name); 360 #else 361 POST(status); 362 #endif 363 if (binding == NULL) { 364 binding = dmalloc(sizeof(*binding), MDL); 365 if (binding != NULL) { 366 memset(binding, 0, sizeof(*binding)); 367 binding->name = 368 dmalloc(strlen 369 (r->data.set.name) + 1, 370 MDL); 371 if (binding->name != NULL) { 372 strcpy(binding->name, r->data.set.name); 373 binding->next = (*scope)->bindings; 374 (*scope)->bindings = binding; 375 } else { 376 dfree(binding, MDL); 377 binding = NULL; 378 } 379 } 380 } 381 if (binding != NULL) { 382 if (binding->value != NULL) 383 binding_value_dereference 384 (&binding->value, MDL); 385 if (r->op == set_statement) { 386 status = (evaluate_expression 387 (&binding->value, packet, 388 lease, client_state, 389 in_options, out_options, 390 scope, r->data.set.expr, 391 MDL)); 392 } else { 393 if (!(binding_value_allocate 394 (&binding->value, MDL))) { 395 dfree(binding, MDL); 396 binding = NULL; 397 } 398 if ((binding != NULL) && 399 (binding->value != NULL)) { 400 binding->value->type = 401 binding_function; 402 (fundef_reference 403 (&binding->value->value.fundef, 404 r->data.set.expr->data.func, 405 MDL)); 406 } 407 } 408 } 409 #if defined (DEBUG_EXPRESSIONS) 410 log_debug ("exec: set %s%s", r -> data.set.name, 411 (binding && status ? "" : " (failed)")); 412 #else 413 POST(status); 414 #endif 415 break; 416 417 case unset_statement: 418 if (!scope || !*scope) 419 break; 420 binding = find_binding (*scope, r->data.unset); 421 if (binding) { 422 if (binding->value) 423 binding_value_dereference 424 (&binding->value, MDL); 425 status = 1; 426 } else 427 status = 0; 428 #if defined (DEBUG_EXPRESSIONS) 429 log_debug ("exec: unset %s: %s", r->data.unset, 430 (status ? "found" : "not found")); 431 #else 432 POST(status); 433 #endif 434 break; 435 436 case let_statement: 437 #if defined (DEBUG_EXPRESSIONS) 438 log_debug("exec: let %s", r->data.let.name); 439 #endif 440 status = 0; 441 ns = NULL; 442 binding_scope_allocate (&ns, MDL); 443 e = r; 444 445 next_let: 446 if (ns) { 447 binding = dmalloc(sizeof(*binding), MDL); 448 memset(binding, 0, sizeof(*binding)); 449 if (!binding) { 450 blb: 451 binding_scope_dereference(&ns, MDL); 452 } else { 453 binding->name = 454 dmalloc(strlen 455 (e->data.let.name + 1), 456 MDL); 457 if (binding->name) 458 strcpy(binding->name, 459 e->data.let.name); 460 else { 461 dfree(binding, MDL); 462 binding = NULL; 463 goto blb; 464 } 465 } 466 } else 467 binding = NULL; 468 469 if (ns && binding) { 470 status = (evaluate_expression 471 (&binding->value, packet, lease, 472 client_state, 473 in_options, out_options, 474 scope, e->data.set.expr, MDL)); 475 binding->next = ns->bindings; 476 ns->bindings = binding; 477 } 478 479 #if defined (DEBUG_EXPRESSIONS) 480 log_debug("exec: let %s%s", e->data.let.name, 481 (binding && status ? "" : "failed")); 482 #else 483 POST(status); 484 #endif 485 if (!e->data.let.statements) { 486 } else if (e->data.let.statements->op == 487 let_statement) { 488 e = e->data.let.statements; 489 goto next_let; 490 } else if (ns) { 491 if (scope && *scope) 492 binding_scope_reference(&ns->outer, 493 *scope, MDL); 494 execute_statements 495 (result, packet, lease, client_state, 496 in_options, out_options, 497 &ns, e->data.let.statements, on_star); 498 } 499 if (ns) 500 binding_scope_dereference(&ns, MDL); 501 break; 502 503 case log_statement: 504 memset (&ds, 0, sizeof ds); 505 status = (evaluate_data_expression 506 (&ds, packet, 507 lease, client_state, in_options, 508 out_options, scope, r->data.log.expr, MDL)); 509 510 #if defined (DEBUG_EXPRESSIONS) 511 log_debug ("exec: log"); 512 #endif 513 514 if (status) { 515 switch (r->data.log.priority) { 516 case log_priority_fatal: 517 log_fatal ("%.*s", (int)ds.len, 518 ds.data); 519 break; 520 case log_priority_error: 521 log_error ("%.*s", (int)ds.len, 522 ds.data); 523 break; 524 case log_priority_debug: 525 log_debug ("%.*s", (int)ds.len, 526 ds.data); 527 break; 528 case log_priority_info: 529 log_info ("%.*s", (int)ds.len, 530 ds.data); 531 break; 532 } 533 data_string_forget (&ds, MDL); 534 } 535 536 break; 537 538 default: 539 log_error ("bogus statement type %d", r -> op); 540 break; 541 } 542 executable_statement_dereference (&r, MDL); 543 if (next) { 544 executable_statement_reference (&r, next, MDL); 545 executable_statement_dereference (&next, MDL); 546 } 547 } 548 549 return 1; 550 } 551 552 /* Execute all the statements in a particular scope, and all statements in 553 scopes outer from that scope, but if a particular limiting scope is 554 reached, do not execute statements in that scope or in scopes outer 555 from it. More specific scopes need to take precedence over less 556 specific scopes, so we recursively traverse the scope list, executing 557 the most outer scope first. */ 558 559 void execute_statements_in_scope (result, packet, 560 lease, client_state, in_options, out_options, 561 scope, group, limiting_group, on_star) 562 struct binding_value **result; 563 struct packet *packet; 564 struct lease *lease; 565 struct client_state *client_state; 566 struct option_state *in_options; 567 struct option_state *out_options; 568 struct binding_scope **scope; 569 struct group *group; 570 struct group *limiting_group; 571 struct on_star *on_star; 572 { 573 struct group *limit; 574 575 /* If we've recursed as far as we can, return. */ 576 if (!group) 577 return; 578 579 /* As soon as we get to a scope that is outer than the limiting 580 scope, we are done. This is so that if somebody does something 581 like this, it does the expected thing: 582 583 domain-name "fugue.com"; 584 shared-network FOO { 585 host bar { 586 domain-name "othello.fugue.com"; 587 fixed-address 10.20.30.40; 588 } 589 subnet 10.20.30.0 netmask 255.255.255.0 { 590 domain-name "manhattan.fugue.com"; 591 } 592 } 593 594 The problem with the above arrangement is that the host's 595 group nesting will be host -> shared-network -> top-level, 596 and the limiting scope when we evaluate the host's scope 597 will be the subnet -> shared-network -> top-level, so we need 598 to know when we evaluate the host's scope to stop before we 599 evaluate the shared-networks scope, because it's outer than 600 the limiting scope, which means we've already evaluated it. */ 601 602 for (limit = limiting_group; limit; limit = limit -> next) { 603 if (group == limit) 604 return; 605 } 606 607 if (group -> next) 608 execute_statements_in_scope (result, packet, 609 lease, client_state, 610 in_options, out_options, scope, 611 group->next, limiting_group, 612 on_star); 613 execute_statements (result, packet, lease, client_state, in_options, 614 out_options, scope, group->statements, on_star); 615 } 616 617 /* Dereference or free any subexpressions of a statement being freed. */ 618 619 int executable_statement_dereference (ptr, file, line) 620 struct executable_statement **ptr; 621 const char *file; 622 int line; 623 { 624 if (!ptr || !*ptr) { 625 log_error ("%s(%d): null pointer", file, line); 626 #if defined (POINTER_DEBUG) 627 abort (); 628 #else 629 return 0; 630 #endif 631 } 632 633 (*ptr) -> refcnt--; 634 rc_register (file, line, ptr, *ptr, (*ptr) -> refcnt, 1, RC_MISC); 635 if ((*ptr) -> refcnt > 0) { 636 *ptr = (struct executable_statement *)0; 637 return 1; 638 } 639 640 if ((*ptr) -> refcnt < 0) { 641 log_error ("%s(%d): negative refcnt!", file, line); 642 #if defined (DEBUG_RC_HISTORY) 643 dump_rc_history (*ptr); 644 #endif 645 #if defined (POINTER_DEBUG) 646 abort (); 647 #else 648 return 0; 649 #endif 650 } 651 652 if ((*ptr) -> next) 653 executable_statement_dereference (&(*ptr) -> next, file, line); 654 655 switch ((*ptr) -> op) { 656 case statements_statement: 657 if ((*ptr) -> data.statements) 658 executable_statement_dereference 659 (&(*ptr) -> data.statements, file, line); 660 break; 661 662 case on_statement: 663 if ((*ptr) -> data.on.statements) 664 executable_statement_dereference 665 (&(*ptr) -> data.on.statements, file, line); 666 break; 667 668 case switch_statement: 669 if ((*ptr) -> data.s_switch.statements) 670 executable_statement_dereference 671 (&(*ptr) -> data.on.statements, file, line); 672 if ((*ptr) -> data.s_switch.expr) 673 expression_dereference (&(*ptr) -> data.s_switch.expr, 674 file, line); 675 break; 676 677 case case_statement: 678 if ((*ptr) -> data.s_switch.expr) 679 expression_dereference (&(*ptr) -> data.c_case, 680 file, line); 681 break; 682 683 case if_statement: 684 if ((*ptr) -> data.ie.expr) 685 expression_dereference (&(*ptr) -> data.ie.expr, 686 file, line); 687 if ((*ptr) -> data.ie.tc) 688 executable_statement_dereference 689 (&(*ptr) -> data.ie.tc, file, line); 690 if ((*ptr) -> data.ie.fc) 691 executable_statement_dereference 692 (&(*ptr) -> data.ie.fc, file, line); 693 break; 694 695 case eval_statement: 696 if ((*ptr) -> data.eval) 697 expression_dereference (&(*ptr) -> data.eval, 698 file, line); 699 break; 700 701 case return_statement: 702 if ((*ptr) -> data.eval) 703 expression_dereference (&(*ptr) -> data.eval, 704 file, line); 705 break; 706 707 case set_statement: 708 if ((*ptr)->data.set.name) 709 dfree ((*ptr)->data.set.name, file, line); 710 if ((*ptr)->data.set.expr) 711 expression_dereference (&(*ptr) -> data.set.expr, 712 file, line); 713 break; 714 715 case unset_statement: 716 if ((*ptr)->data.unset) 717 dfree ((*ptr)->data.unset, file, line); 718 break; 719 720 case execute_statement: 721 if ((*ptr)->data.execute.command) 722 dfree ((*ptr)->data.execute.command, file, line); 723 if ((*ptr)->data.execute.arglist) 724 expression_dereference (&(*ptr) -> data.execute.arglist, 725 file, line); 726 break; 727 728 case supersede_option_statement: 729 case send_option_statement: 730 case default_option_statement: 731 case append_option_statement: 732 case prepend_option_statement: 733 if ((*ptr) -> data.option) 734 option_cache_dereference (&(*ptr) -> data.option, 735 file, line); 736 break; 737 738 default: 739 /* Nothing to do. */ 740 break; 741 } 742 743 dfree ((*ptr), file, line); 744 *ptr = (struct executable_statement *)0; 745 return 1; 746 } 747 748 void write_statements (file, statements, indent) 749 FILE *file; 750 struct executable_statement *statements; 751 int indent; 752 { 753 #if defined ENABLE_EXECUTE 754 struct expression *expr; 755 #endif 756 struct executable_statement *r, *x; 757 const char *s, *t, *dot; 758 int col; 759 760 if (!statements) 761 return; 762 763 for (r = statements; r; r = r -> next) { 764 switch (r -> op) { 765 case statements_statement: 766 write_statements (file, r -> data.statements, indent); 767 break; 768 769 case on_statement: 770 indent_spaces (file, indent); 771 fprintf (file, "on "); 772 s = ""; 773 if (r -> data.on.evtypes & ON_EXPIRY) { 774 fprintf (file, "%sexpiry", s); 775 s = " or "; 776 } 777 if (r -> data.on.evtypes & ON_COMMIT) { 778 fprintf (file, "%scommit", s); 779 s = " or "; 780 } 781 if (r -> data.on.evtypes & ON_RELEASE) { 782 fprintf (file, "%srelease", s); 783 /* s = " or "; */ 784 } 785 if (r -> data.on.statements) { 786 fprintf (file, " {"); 787 write_statements (file, 788 r -> data.on.statements, 789 indent + 2); 790 indent_spaces (file, indent); 791 fprintf (file, "}"); 792 } else { 793 fprintf (file, ";"); 794 } 795 break; 796 797 case switch_statement: 798 indent_spaces (file, indent); 799 fprintf (file, "switch ("); 800 col = write_expression (file, 801 r -> data.s_switch.expr, 802 indent + 7, indent + 7, 1); 803 col = token_print_indent (file, col, indent + 7, 804 "", "", ")"); 805 token_print_indent (file, 806 col, indent, " ", "", "{"); 807 write_statements (file, r -> data.s_switch.statements, 808 indent + 2); 809 indent_spaces (file, indent); 810 fprintf (file, "}"); 811 break; 812 813 case case_statement: 814 indent_spaces (file, indent - 1); 815 fprintf (file, "case "); 816 col = write_expression (file, 817 r -> data.s_switch.expr, 818 indent + 5, indent + 5, 1); 819 token_print_indent (file, col, indent + 5, 820 "", "", ":"); 821 break; 822 823 case default_statement: 824 indent_spaces (file, indent - 1); 825 fprintf (file, "default: "); 826 break; 827 828 case if_statement: 829 indent_spaces (file, indent); 830 fprintf (file, "if "); 831 x = r; 832 col = write_expression (file, 833 x -> data.ie.expr, 834 indent + 3, indent + 3, 1); 835 else_if: 836 token_print_indent (file, col, indent, " ", "", "{"); 837 write_statements (file, x -> data.ie.tc, indent + 2); 838 if (x -> data.ie.fc && 839 x -> data.ie.fc -> op == if_statement && 840 !x -> data.ie.fc -> next) { 841 indent_spaces (file, indent); 842 fprintf (file, "} elsif "); 843 x = x -> data.ie.fc; 844 col = write_expression (file, 845 x -> data.ie.expr, 846 indent + 6, 847 indent + 6, 1); 848 goto else_if; 849 } 850 if (x -> data.ie.fc) { 851 indent_spaces (file, indent); 852 fprintf (file, "} else {"); 853 write_statements (file, x -> data.ie.fc, 854 indent + 2); 855 } 856 indent_spaces (file, indent); 857 fprintf (file, "}"); 858 break; 859 860 case eval_statement: 861 indent_spaces (file, indent); 862 fprintf (file, "eval "); 863 (void) write_expression (file, r -> data.eval, 864 indent + 5, indent + 5, 1); 865 fprintf (file, ";"); 866 break; 867 868 case return_statement: 869 indent_spaces (file, indent); 870 fprintf (file, "return;"); 871 break; 872 873 case add_statement: 874 indent_spaces (file, indent); 875 fprintf (file, "add \"%s\"", r -> data.add -> name); 876 break; 877 878 case break_statement: 879 indent_spaces (file, indent); 880 fprintf (file, "break;"); 881 break; 882 883 case supersede_option_statement: 884 case send_option_statement: 885 s = "supersede"; 886 goto option_statement; 887 888 case default_option_statement: 889 s = "default"; 890 goto option_statement; 891 892 case append_option_statement: 893 s = "append"; 894 goto option_statement; 895 896 case prepend_option_statement: 897 s = "prepend"; 898 option_statement: 899 /* Note: the reason we don't try to pretty print 900 the option here is that the format of the option 901 may change in dhcpd.conf, and then when this 902 statement was read back, it would cause a syntax 903 error. */ 904 if (r -> data.option -> option -> universe == 905 &dhcp_universe) { 906 t = ""; 907 dot = ""; 908 } else { 909 t = (r -> data.option -> option -> 910 universe -> name); 911 dot = "."; 912 } 913 indent_spaces (file, indent); 914 fprintf (file, "%s %s%s%s = ", s, t, dot, 915 r -> data.option -> option -> name); 916 col = (indent + strlen (s) + strlen (t) + 917 strlen (dot) + strlen (r -> data.option -> 918 option -> name) + 4); 919 if (r -> data.option -> expression) 920 write_expression 921 (file, 922 r -> data.option -> expression, 923 col, indent + 8, 1); 924 else 925 token_indent_data_string 926 (file, col, indent + 8, "", "", 927 &r -> data.option -> data); 928 929 fprintf (file, ";"); /* XXX */ 930 break; 931 932 case set_statement: 933 indent_spaces (file, indent); 934 fprintf (file, "set "); 935 col = token_print_indent (file, indent + 4, indent + 4, 936 "", "", r -> data.set.name); 937 (void) token_print_indent (file, col, indent + 4, 938 " ", " ", "="); 939 col = write_expression (file, r -> data.set.expr, 940 indent + 3, indent + 3, 0); 941 (void) token_print_indent (file, col, indent + 4, 942 " ", "", ";"); 943 break; 944 945 case unset_statement: 946 indent_spaces (file, indent); 947 fprintf (file, "unset "); 948 col = token_print_indent (file, indent + 6, indent + 6, 949 "", "", r -> data.set.name); 950 (void) token_print_indent (file, col, indent + 6, 951 " ", "", ";"); 952 break; 953 954 case log_statement: 955 indent_spaces (file, indent); 956 fprintf (file, "log "); 957 col = token_print_indent (file, indent + 4, indent + 4, 958 "", "", "("); 959 switch (r -> data.log.priority) { 960 case log_priority_fatal: 961 (void) token_print_indent 962 (file, col, indent + 4, "", 963 " ", "fatal,"); 964 break; 965 case log_priority_error: 966 (void) token_print_indent 967 (file, col, indent + 4, "", 968 " ", "error,"); 969 break; 970 case log_priority_debug: 971 (void) token_print_indent 972 (file, col, indent + 4, "", 973 " ", "debug,"); 974 break; 975 case log_priority_info: 976 (void) token_print_indent 977 (file, col, indent + 4, "", 978 " ", "info,"); 979 break; 980 } 981 col = write_expression (file, r -> data.log.expr, 982 indent + 4, indent + 4, 0); 983 (void) token_print_indent (file, col, indent + 4, 984 "", "", ");"); 985 986 break; 987 988 case execute_statement: 989 #ifdef ENABLE_EXECUTE 990 indent_spaces (file, indent); 991 col = token_print_indent(file, indent + 4, indent + 4, 992 "", "", "execute"); 993 col = token_print_indent(file, col, indent + 4, " ", "", 994 "("); 995 col = token_print_indent(file, col, indent + 4, "\"", "\"", r->data.execute.command); 996 for (expr = r->data.execute.arglist; expr; expr = expr->data.arg.next) { 997 col = token_print_indent(file, col, indent + 4, "", " ", ","); 998 col = write_expression (file, expr->data.arg.val, col, indent + 4, 0); 999 } 1000 (void) token_print_indent(file, col, indent + 4, "", "", ");"); 1001 #else /* !ENABLE_EXECUTE */ 1002 log_fatal("Impossible case at %s:%d (ENABLE_EXECUTE " 1003 "is not defined).", MDL); 1004 #endif /* ENABLE_EXECUTE */ 1005 break; 1006 1007 default: 1008 log_fatal ("bogus statement type %d\n", r -> op); 1009 } 1010 } 1011 } 1012 1013 /* Find a case statement in the sequence of executable statements that 1014 matches the expression, and if found, return the following statement. 1015 If no case statement matches, try to find a default statement and 1016 return that (the default statement can precede all the case statements). 1017 Otherwise, return the null statement. */ 1018 1019 int find_matching_case (struct executable_statement **ep, 1020 struct packet *packet, struct lease *lease, 1021 struct client_state *client_state, 1022 struct option_state *in_options, 1023 struct option_state *out_options, 1024 struct binding_scope **scope, 1025 struct expression *expr, 1026 struct executable_statement *stmt) 1027 { 1028 int status, sub; 1029 struct executable_statement *s; 1030 1031 if (is_data_expression (expr)) { 1032 struct data_string cd, ds; 1033 memset (&ds, 0, sizeof ds); 1034 memset (&cd, 0, sizeof cd); 1035 1036 status = (evaluate_data_expression (&ds, packet, lease, 1037 client_state, in_options, 1038 out_options, scope, expr, 1039 MDL)); 1040 if (status) { 1041 for (s = stmt; s; s = s -> next) { 1042 if (s -> op == case_statement) { 1043 sub = (evaluate_data_expression 1044 (&cd, packet, lease, client_state, 1045 in_options, out_options, 1046 scope, s->data.c_case, MDL)); 1047 if (sub && cd.len == ds.len && 1048 !memcmp (cd.data, ds.data, cd.len)) 1049 { 1050 data_string_forget (&cd, MDL); 1051 data_string_forget (&ds, MDL); 1052 executable_statement_reference 1053 (ep, s->next, MDL); 1054 return 1; 1055 } 1056 data_string_forget (&cd, MDL); 1057 } 1058 } 1059 data_string_forget (&ds, MDL); 1060 } 1061 } else { 1062 unsigned long n, c; 1063 status = evaluate_numeric_expression (&n, packet, lease, 1064 client_state, 1065 in_options, out_options, 1066 scope, expr); 1067 1068 if (status) { 1069 for (s = stmt; s; s = s->next) { 1070 if (s -> op == case_statement) { 1071 sub = (evaluate_numeric_expression 1072 (&c, packet, lease, client_state, 1073 in_options, out_options, 1074 scope, s->data.c_case)); 1075 if (sub && n == c) { 1076 executable_statement_reference 1077 (ep, s->next, MDL); 1078 return 1; 1079 } 1080 } 1081 } 1082 } 1083 } 1084 1085 /* If we didn't find a matching case statement, look for a default 1086 statement and return the statement following it. */ 1087 for (s = stmt; s; s = s->next) 1088 if (s->op == default_statement) 1089 break; 1090 if (s) { 1091 executable_statement_reference (ep, s->next, MDL); 1092 return 1; 1093 } 1094 return 0; 1095 } 1096 1097 int executable_statement_foreach (struct executable_statement *stmt, 1098 int (*callback) (struct 1099 executable_statement *, 1100 void *, int), 1101 void *vp, int condp) 1102 { 1103 struct executable_statement *foo; 1104 int ok = 0; 1105 1106 for (foo = stmt; foo; foo = foo->next) { 1107 if ((*callback) (foo, vp, condp) != 0) 1108 ok = 1; 1109 switch (foo->op) { 1110 case null_statement: 1111 break; 1112 case if_statement: 1113 if (executable_statement_foreach (foo->data.ie.tc, 1114 callback, vp, 1)) 1115 ok = 1; 1116 if (executable_statement_foreach (foo->data.ie.fc, 1117 callback, vp, 1)) 1118 ok = 1; 1119 break; 1120 case add_statement: 1121 break; 1122 case eval_statement: 1123 break; 1124 case break_statement: 1125 break; 1126 case default_option_statement: 1127 break; 1128 case supersede_option_statement: 1129 break; 1130 case append_option_statement: 1131 break; 1132 case prepend_option_statement: 1133 break; 1134 case send_option_statement: 1135 break; 1136 case statements_statement: 1137 if ((executable_statement_foreach 1138 (foo->data.statements, callback, vp, condp))) 1139 ok = 1; 1140 break; 1141 case on_statement: 1142 if ((executable_statement_foreach 1143 (foo->data.on.statements, callback, vp, 1))) 1144 ok = 1; 1145 break; 1146 case switch_statement: 1147 if ((executable_statement_foreach 1148 (foo->data.s_switch.statements, callback, vp, 1))) 1149 ok = 1; 1150 break; 1151 case case_statement: 1152 break; 1153 case default_statement: 1154 break; 1155 case set_statement: 1156 break; 1157 case unset_statement: 1158 break; 1159 case let_statement: 1160 if ((executable_statement_foreach 1161 (foo->data.let.statements, callback, vp, 0))) 1162 ok = 1; 1163 break; 1164 case define_statement: 1165 break; 1166 case log_statement: 1167 case return_statement: 1168 case execute_statement: 1169 break; 1170 } 1171 } 1172 return ok; 1173 } 1174