1 /* $NetBSD: print.c,v 1.3 2022/04/03 01:10:59 christos Exp $ */ 2 3 /* 4 * Copyright (C) 2017-2022 Internet Systems Consortium, Inc. ("ISC") 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 16 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 * 18 * Internet Systems Consortium, Inc. 19 * PO Box 360 20 * Newmarket, NH 03857 USA 21 * <info@isc.org> 22 * https://www.isc.org/ 23 * 24 */ 25 26 #include <sys/cdefs.h> 27 __RCSID("$NetBSD: print.c,v 1.3 2022/04/03 01:10:59 christos Exp $"); 28 29 #include "keama.h" 30 31 #include <sys/errno.h> 32 #include <sys/types.h> 33 #include <arpa/inet.h> 34 #include <ctype.h> 35 #include <netdb.h> 36 #include <stdarg.h> 37 #include <stdio.h> 38 #include <string.h> 39 #include <unistd.h> 40 41 static void debug(const char* fmt, ...); 42 43 const char * 44 print_expression(struct element *expr, isc_boolean_t *lose) 45 { 46 if (expr->type == ELEMENT_BOOLEAN) 47 return print_boolean_expression(expr, lose); 48 if (expr->type == ELEMENT_INTEGER) 49 return print_numeric_expression(expr, lose); 50 if (expr->type == ELEMENT_STRING) 51 return print_data_expression(expr, lose); 52 53 if (is_boolean_expression(expr)) 54 return print_boolean_expression(expr, lose); 55 if (is_numeric_expression(expr)) 56 return print_numeric_expression(expr, lose); 57 if (is_data_expression(expr)) 58 return print_data_expression(expr, lose); 59 *lose = ISC_TRUE; 60 return "???"; 61 } 62 63 const char * 64 print_boolean_expression(struct element *expr, isc_boolean_t *lose) 65 { 66 struct string *result; 67 68 if (expr->type == ELEMENT_BOOLEAN) { 69 if (boolValue(expr)) 70 return "true"; 71 else 72 return "false"; 73 } 74 75 /* 76 * From is_boolean_expression 77 */ 78 if (expr->type != ELEMENT_MAP) { 79 *lose = ISC_TRUE; 80 return "???"; 81 } 82 result = allocString(); 83 84 /* check */ 85 if (mapContains(expr, "check")) { 86 struct element *name; 87 88 appendString(result, "check "); 89 name = mapGet(expr, "check"); 90 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 91 *lose = ISC_TRUE; 92 appendString(result, "???"); 93 } else 94 concatString(result, stringValue(name)); 95 return result->content; 96 } 97 98 /* exists */ 99 if (mapContains(expr, "exists")) { 100 struct element *arg; 101 struct element *universe; 102 struct element *name; 103 104 appendString(result, "exists "); 105 arg = mapGet(expr, "exists"); 106 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 107 *lose = ISC_TRUE; 108 appendString(result, "???"); 109 return result->content; 110 } 111 universe = mapGet(arg, "universe"); 112 if ((universe == NULL) || (universe->type != ELEMENT_STRING)) { 113 *lose = ISC_TRUE; 114 appendString(result, "???"); 115 return result->content; 116 } 117 concatString(result, stringValue(universe)); 118 appendString(result, "."); 119 name = mapGet(arg, "name"); 120 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 121 *lose = ISC_TRUE; 122 appendString(result, "???"); 123 return result->content; 124 } 125 concatString(result, stringValue(name)); 126 return result->content; 127 } 128 129 /* variable-exists */ 130 if (mapContains(expr, "variable-exists")) { 131 struct element *name; 132 133 appendString(result, "variable-exists "); 134 name = mapGet(expr, "variable-exists"); 135 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 136 *lose = ISC_TRUE; 137 appendString(result, "???"); 138 } else 139 concatString(result, stringValue(name)); 140 return result->content; 141 } 142 143 /* equal */ 144 if (mapContains(expr, "equal")) { 145 struct element *arg; 146 struct element *left; 147 struct element *right; 148 isc_boolean_t add_parenthesis; 149 150 appendString(result, "equal "); 151 arg = mapGet(expr, "equal"); 152 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 153 *lose = ISC_TRUE; 154 appendString(result, "???"); 155 return result->content; 156 } 157 left = mapGet(arg, "left"); 158 if (left == NULL) { 159 *lose = ISC_TRUE; 160 appendString(result, "???"); 161 return result->content; 162 } 163 result = allocString(); 164 add_parenthesis = ISC_TF(expr_precedence(expr_equal, 165 left) < 0); 166 if (add_parenthesis) 167 appendString(result, "("); 168 appendString(result, print_expression(left, lose)); 169 if (add_parenthesis) 170 appendString(result, ")"); 171 appendString(result, " = "); 172 right = mapGet(arg, "right"); 173 if (right == NULL) { 174 *lose = ISC_TRUE; 175 appendString(result, "???"); 176 return result->content; 177 } 178 add_parenthesis = ISC_TF(expr_precedence(expr_equal, 179 right) < 0); 180 if (add_parenthesis) 181 appendString(result, "("); 182 appendString(result, print_expression(right, lose)); 183 if (add_parenthesis) 184 appendString(result, ")"); 185 return result->content; 186 } 187 188 /* not-equal */ 189 if (mapContains(expr, "not-equal")) { 190 struct element *arg; 191 struct element *left; 192 struct element *right; 193 isc_boolean_t add_parenthesis; 194 195 appendString(result, "not-equal "); 196 arg = mapGet(expr, "not-equal"); 197 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 198 *lose = ISC_TRUE; 199 appendString(result, "???"); 200 return result->content; 201 } 202 left = mapGet(arg, "left"); 203 if (left == NULL) { 204 *lose = ISC_TRUE; 205 appendString(result, "???"); 206 return result->content; 207 } 208 result = allocString(); 209 add_parenthesis = ISC_TF(expr_precedence(expr_not_equal, 210 left) < 0); 211 if (add_parenthesis) 212 appendString(result, "("); 213 appendString(result, print_expression(left, lose)); 214 if (add_parenthesis) 215 appendString(result, ")"); 216 appendString(result, " != "); 217 right = mapGet(arg, "right"); 218 if (right == NULL) { 219 *lose = ISC_TRUE; 220 appendString(result, "???"); 221 return result->content; 222 } 223 add_parenthesis = ISC_TF(expr_precedence(expr_not_equal, 224 right) < 0); 225 if (add_parenthesis) 226 appendString(result, "("); 227 appendString(result, print_expression(right, lose)); 228 if (add_parenthesis) 229 appendString(result, ")"); 230 return result->content; 231 } 232 233 /* regex-match */ 234 if (mapContains(expr, "regex-match")) { 235 struct element *arg; 236 struct element *left; 237 struct element *right; 238 isc_boolean_t add_parenthesis; 239 240 appendString(result, "regex-match "); 241 arg = mapGet(expr, "regex-match"); 242 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 243 *lose = ISC_TRUE; 244 appendString(result, "???"); 245 return result->content; 246 } 247 left = mapGet(arg, "left"); 248 if (left == NULL) { 249 *lose = ISC_TRUE; 250 appendString(result, "???"); 251 return result->content; 252 } 253 result = allocString(); 254 add_parenthesis = ISC_TF(expr_precedence(expr_regex_match, 255 left) < 0); 256 if (add_parenthesis) 257 appendString(result, "("); 258 appendString(result, print_expression(left, lose)); 259 if (add_parenthesis) 260 appendString(result, ")"); 261 appendString(result, " ~= "); 262 right = mapGet(arg, "right"); 263 if (right == NULL) { 264 *lose = ISC_TRUE; 265 appendString(result, "???"); 266 return result->content; 267 } 268 appendString(result, print_expression(right, lose)); 269 return result->content; 270 } 271 272 /* iregex-match */ 273 if (mapContains(expr, "iregex-match")) { 274 struct element *arg; 275 struct element *left; 276 struct element *right; 277 isc_boolean_t add_parenthesis; 278 279 appendString(result, "iregex-match "); 280 arg = mapGet(expr, "iregex-match"); 281 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 282 *lose = ISC_TRUE; 283 appendString(result, "???"); 284 return result->content; 285 } 286 left = mapGet(arg, "left"); 287 if (left == NULL) { 288 *lose = ISC_TRUE; 289 appendString(result, "???"); 290 return result->content; 291 } 292 result = allocString(); 293 add_parenthesis = ISC_TF(expr_precedence(expr_iregex_match, 294 left) < 0); 295 if (add_parenthesis) 296 appendString(result, "("); 297 appendString(result, print_expression(left, lose)); 298 if (add_parenthesis) 299 appendString(result, ")"); 300 appendString(result, " ~~ "); 301 right = mapGet(arg, "right"); 302 if (right == NULL) { 303 *lose = ISC_TRUE; 304 appendString(result, "???"); 305 return result->content; 306 } 307 appendString(result, print_expression(right, lose)); 308 return result->content; 309 } 310 311 /* and */ 312 if (mapContains(expr, "and")) { 313 struct element *arg; 314 struct element *left; 315 struct element *right; 316 isc_boolean_t add_parenthesis; 317 318 appendString(result, "and "); 319 arg = mapGet(expr, "and"); 320 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 321 *lose = ISC_TRUE; 322 appendString(result, "???"); 323 return result->content; 324 } 325 left = mapGet(arg, "left"); 326 if (left == NULL) { 327 *lose = ISC_TRUE; 328 appendString(result, "???"); 329 return result->content; 330 } 331 result = allocString(); 332 add_parenthesis = ISC_TF(expr_precedence(expr_and, 333 left) < 0); 334 if (add_parenthesis) 335 appendString(result, "("); 336 appendString(result, print_expression(left, lose)); 337 if (add_parenthesis) 338 appendString(result, ")"); 339 appendString(result, " and "); 340 right = mapGet(arg, "right"); 341 if (right == NULL) { 342 *lose = ISC_TRUE; 343 appendString(result, "???"); 344 return result->content; 345 } 346 add_parenthesis = ISC_TF(expr_precedence(expr_and, 347 right) < 0); 348 if (add_parenthesis) 349 appendString(result, "("); 350 appendString(result, print_expression(right, lose)); 351 if (add_parenthesis) 352 appendString(result, ")"); 353 return result->content; 354 } 355 356 /* or */ 357 if (mapContains(expr, "or")) { 358 struct element *arg; 359 struct element *left; 360 struct element *right; 361 isc_boolean_t add_parenthesis; 362 363 appendString(result, "or "); 364 arg = mapGet(expr, "or"); 365 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 366 *lose = ISC_TRUE; 367 appendString(result, "???"); 368 return result->content; 369 } 370 left = mapGet(arg, "left"); 371 if (left == NULL) { 372 *lose = ISC_TRUE; 373 appendString(result, "???"); 374 return result->content; 375 } 376 result = allocString(); 377 add_parenthesis = ISC_TF(expr_precedence(expr_or, 378 left) < 0); 379 if (add_parenthesis) 380 appendString(result, "("); 381 appendString(result, print_expression(left, lose)); 382 if (add_parenthesis) 383 appendString(result, ")"); 384 appendString(result, " or "); 385 right = mapGet(arg, "right"); 386 if (right == NULL) { 387 *lose = ISC_TRUE; 388 appendString(result, "???"); 389 return result->content; 390 } 391 add_parenthesis = ISC_TF(expr_precedence(expr_or, 392 right) < 0); 393 if (add_parenthesis) 394 appendString(result, "("); 395 appendString(result, print_expression(right, lose)); 396 if (add_parenthesis) 397 appendString(result, ")"); 398 return result->content; 399 } 400 401 /* not */ 402 if (mapContains(expr, "not")) { 403 struct element *arg; 404 isc_boolean_t add_parenthesis; 405 406 appendString(result, "not "); 407 arg = mapGet(expr, "not"); 408 if (arg == NULL) { 409 *lose = ISC_TRUE; 410 appendString(result, "???"); 411 return result->content; 412 } 413 add_parenthesis = ISC_TF(expr_precedence(expr_not, 414 arg) < 0); 415 if (add_parenthesis) 416 appendString(result, "("); 417 appendString(result, print_expression(arg, lose)); 418 if (add_parenthesis) 419 appendString(result, ")"); 420 return result->content; 421 } 422 423 /* known */ 424 if (mapContains(expr, "known")) { 425 return "known"; 426 } 427 428 /* static */ 429 if (mapContains(expr, "static")) { 430 return "static"; 431 } 432 433 /* variable-reference */ 434 if (mapContains(expr, "variable-reference")) { 435 struct element *name; 436 437 appendString(result, "variable-reference "); 438 name = mapGet(expr, "variable-reference"); 439 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 440 *lose = ISC_TRUE; 441 appendString(result, "???"); 442 return result->content; 443 } 444 return stringValue(name)->content; 445 } 446 447 /* funcall */ 448 if (mapContains(expr, "funcall")) { 449 struct element *arg; 450 struct element *name; 451 struct element *args; 452 size_t i; 453 454 appendString(result, "funcall "); 455 arg = mapGet(expr, "funcall"); 456 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 457 *lose = ISC_TRUE; 458 appendString(result, "???"); 459 return result->content; 460 } 461 name = mapGet(arg, "name"); 462 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 463 *lose = ISC_TRUE; 464 appendString(result, "???"); 465 return result->content; 466 } 467 result = allocString(); 468 concatString(result, stringValue(name)); 469 appendString(result, "("); 470 args = mapGet(arg, "arguments"); 471 if ((args == NULL) || (args->type != ELEMENT_LIST)) { 472 *lose = ISC_TRUE; 473 appendString(result, "???" ")"); 474 return result->content; 475 } 476 for (i = 0; i < listSize(args); i++) { 477 struct element *item; 478 479 if (i != 0) 480 appendString(result, ", "); 481 item = listGet(args, i); 482 if (item == NULL) { 483 debug("funcall null argument %u", 484 (unsigned)i); 485 *lose = ISC_TRUE; 486 appendString(result, "???"); 487 continue; 488 } 489 appendString(result, print_expression(item, lose)); 490 } 491 appendString(result, ")"); 492 return result->content; 493 } 494 495 *lose = ISC_TRUE; 496 appendString(result, "???"); 497 return result->content; 498 } 499 500 const char * 501 print_data_expression(struct element *expr, isc_boolean_t *lose) 502 { 503 struct string *result; 504 505 if (expr->type == ELEMENT_STRING) 506 return quote(stringValue(expr))->content; 507 508 /* 509 * From is_data_expression 510 */ 511 if (expr->type != ELEMENT_MAP) { 512 *lose = ISC_TRUE; 513 return "???"; 514 } 515 result = allocString(); 516 517 /* substring */ 518 if (mapContains(expr, "substring")) { 519 struct element *arg; 520 struct element *string; 521 struct element *offset; 522 struct element *length; 523 524 appendString(result, "substring("); 525 arg = mapGet(expr, "substring"); 526 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 527 *lose = ISC_TRUE; 528 appendString(result, "???" ")"); 529 return result->content; 530 } 531 string = mapGet(arg, "expression"); 532 if (string == NULL) { 533 *lose = ISC_TRUE; 534 appendString(result, "???" ")"); 535 return result->content; 536 } 537 appendString(result, print_data_expression(string, lose)); 538 appendString(result, ", "); 539 offset = mapGet(arg, "offset"); 540 if (offset == NULL) { 541 *lose = ISC_TRUE; 542 appendString(result, "???" ")"); 543 return result->content; 544 } 545 appendString(result, print_numeric_expression(offset, lose)); 546 appendString(result, ", "); 547 length = mapGet(arg, "length"); 548 if (length == NULL) { 549 *lose = ISC_TRUE; 550 appendString(result, "???" ")"); 551 return result->content; 552 } 553 appendString(result, print_numeric_expression(length, lose)); 554 appendString(result, ")"); 555 return result->content; 556 } 557 558 /* suffix */ 559 if (mapContains(expr, "suffix")) { 560 struct element *arg; 561 struct element *string; 562 struct element *length; 563 564 appendString(result, "suffix("); 565 arg = mapGet(expr, "suffix"); 566 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 567 *lose = ISC_TRUE; 568 appendString(result, "???" ")"); 569 return result->content; 570 } 571 string = mapGet(arg, "expression"); 572 if (string == NULL) { 573 *lose = ISC_TRUE; 574 appendString(result, "???" ")"); 575 return result->content; 576 } 577 appendString(result, print_data_expression(string, lose)); 578 appendString(result, ", "); 579 length = mapGet(arg, "length"); 580 if (length == NULL) { 581 *lose = ISC_TRUE; 582 appendString(result, "???" ")"); 583 return result->content; 584 } 585 appendString(result, print_numeric_expression(length, lose)); 586 appendString(result, ")"); 587 return result->content; 588 } 589 590 /* lowercase */ 591 if (mapContains(expr, "lowercase")) { 592 struct element *arg; 593 594 appendString(result, "lowercase("); 595 arg = mapGet(expr, "lowercase"); 596 if (arg == NULL) { 597 *lose = ISC_TRUE; 598 appendString(result, "???" ")"); 599 return result->content; 600 } 601 appendString(result, print_data_expression(arg, lose)); 602 appendString(result, ")"); 603 return result->content; 604 } 605 606 /* uppercase */ 607 if (mapContains(expr, "uppercase")) { 608 struct element *arg; 609 610 appendString(result, "uppercase("); 611 arg = mapGet(expr, "uppercase"); 612 if (arg == NULL) { 613 *lose = ISC_TRUE; 614 appendString(result, "???" ")"); 615 return result->content; 616 } 617 appendString(result, print_data_expression(arg, lose)); 618 appendString(result, ")"); 619 return result->content; 620 } 621 622 /* option */ 623 if (mapContains(expr, "option")) { 624 struct element *arg; 625 struct element *universe; 626 struct element *name; 627 628 appendString(result, "option "); 629 arg = mapGet(expr, "option"); 630 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 631 *lose = ISC_TRUE; 632 appendString(result, "???"); 633 return result->content; 634 } 635 universe = mapGet(arg, "universe"); 636 if ((universe == NULL) || (universe->type != ELEMENT_STRING)) { 637 *lose = ISC_TRUE; 638 appendString(result, "???"); 639 return result->content; 640 } 641 concatString(result, stringValue(universe)); 642 appendString(result, "."); 643 name = mapGet(arg, "name"); 644 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 645 *lose = ISC_TRUE; 646 appendString(result, "???"); 647 return result->content; 648 } 649 concatString(result, stringValue(name)); 650 return result->content; 651 } 652 653 /* hardware */ 654 if (mapContains(expr, "hardware")) 655 return "hardware"; 656 657 /* hw-type */ 658 if (mapContains(expr, "hw-type")) 659 return "hw-type"; 660 661 /* hw-address */ 662 if (mapContains(expr, "hw-address")) 663 return "hw-address"; 664 665 /* const-data */ 666 if (mapContains(expr, "const-data")) { 667 struct element *arg; 668 669 arg = mapGet(expr, "const-data"); 670 if ((arg == NULL) || (arg->type != ELEMENT_STRING)) { 671 *lose = ISC_TRUE; 672 appendString(result, "???"); 673 return result->content; 674 } 675 concatString(result, stringValue(arg)); 676 return result->content; 677 } 678 679 /* packet */ 680 if (mapContains(expr, "packet")) { 681 struct element *arg; 682 struct element *offset; 683 struct element *length; 684 685 appendString(result, "packet("); 686 arg = mapGet(expr, "packet"); 687 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 688 *lose = ISC_TRUE; 689 appendString(result, "???" ")"); 690 return result->content; 691 } 692 offset = mapGet(arg, "offset"); 693 if (offset == NULL) { 694 *lose = ISC_TRUE; 695 appendString(result, "???" ")"); 696 return result->content; 697 } 698 appendString(result, print_numeric_expression(offset, lose)); 699 appendString(result, ", "); 700 length = mapGet(arg, "length"); 701 if (length == NULL) { 702 *lose = ISC_TRUE; 703 appendString(result, "???" ")"); 704 return result->content; 705 } 706 appendString(result, print_numeric_expression(length, lose)); 707 appendString(result, ")"); 708 return result->content; 709 } 710 711 /* concat */ 712 if (mapContains(expr, "concat")) { 713 struct element *arg; 714 struct element *left; 715 struct element *right; 716 717 appendString(result, "concat("); 718 arg = mapGet(expr, "concat"); 719 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 720 *lose = ISC_TRUE; 721 appendString(result, "???" ")"); 722 return result->content; 723 } 724 left = mapGet(arg, "left"); 725 if (left == NULL) { 726 *lose = ISC_TRUE; 727 appendString(result, "???" ")"); 728 return result->content; 729 } 730 appendString(result, print_data_expression(left, lose)); 731 appendString(result, ", "); 732 right = mapGet(arg, "right"); 733 if (right == NULL) { 734 *lose = ISC_TRUE; 735 appendString(result, "???" ")"); 736 return result->content; 737 } 738 appendString(result, print_data_expression(right, lose)); 739 appendString(result, ")"); 740 return result->content; 741 } 742 743 /* encapsulate */ 744 if (mapContains(expr, "encapsulate")) { 745 struct element *arg; 746 747 appendString(result, "encapsulate "); 748 arg = mapGet(expr, "encapsulate"); 749 if (arg == NULL) { 750 *lose = ISC_TRUE; 751 appendString(result, "???"); 752 return result->content; 753 } 754 appendString(result, print_data_expression(arg, lose)); 755 return result->content; 756 } 757 758 /* encode-int8 */ 759 if (mapContains(expr, "encode-int8")) { 760 struct element *arg; 761 762 appendString(result, "encode-int("); 763 arg = mapGet(expr, "encode-int8"); 764 if (arg == NULL) { 765 *lose = ISC_TRUE; 766 appendString(result, "???, 8)"); 767 return result->content; 768 } 769 appendString(result, print_numeric_expression(arg, lose)); 770 appendString(result, ", 8)"); 771 return result->content; 772 } 773 774 /* encode-int16 */ 775 if (mapContains(expr, "encode-int16")) { 776 struct element *arg; 777 778 appendString(result, "encode-int("); 779 arg = mapGet(expr, "encode-int16"); 780 if (arg == NULL) { 781 *lose = ISC_TRUE; 782 appendString(result, "???, 16)"); 783 return result->content; 784 } 785 appendString(result, print_numeric_expression(arg, lose)); 786 appendString(result, ", 16)"); 787 return result->content; 788 } 789 790 /* encode-int32 */ 791 if (mapContains(expr, "encode-int32")) { 792 struct element *arg; 793 794 appendString(result, "encode-int("); 795 arg = mapGet(expr, "encode-int32"); 796 if (arg == NULL) { 797 *lose = ISC_TRUE; 798 appendString(result, "???, 32)"); 799 return result->content; 800 } 801 appendString(result, print_numeric_expression(arg, lose)); 802 appendString(result, ", 32)"); 803 return result->content; 804 } 805 806 /* gethostbyname */ 807 if (mapContains(expr, "gethostbyname")) { 808 struct element *arg; 809 810 appendString(result, "gethostbyname("); 811 arg = mapGet(expr, "gethostbyname"); 812 if (arg == NULL) { 813 *lose = ISC_TRUE; 814 appendString(result, "???"); 815 return result->content; 816 } 817 appendString(result, print_data_expression(arg, lose)); 818 appendString(result, ")"); 819 return result->content; 820 } 821 822 /* binary-to-ascii */ 823 if (mapContains(expr, "binary-to-ascii")) { 824 struct element *arg; 825 struct element *base; 826 struct element *width; 827 struct element *separator; 828 struct element *buffer; 829 830 appendString(result, "binary-to-ascii("); 831 arg = mapGet(expr, "binary-to-ascii"); 832 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 833 *lose = ISC_TRUE; 834 appendString(result, "???" ")"); 835 return result->content; 836 } 837 base = mapGet(arg, "base"); 838 if (base == NULL) { 839 *lose = ISC_TRUE; 840 appendString(result, "???" ")"); 841 return result->content; 842 } 843 appendString(result, print_numeric_expression(base, lose)); 844 appendString(result, ", "); 845 width = mapGet(arg, "width"); 846 if (width == NULL) { 847 *lose = ISC_TRUE; 848 appendString(result, "???" ")"); 849 return result->content; 850 } 851 appendString(result, print_numeric_expression(width, lose)); 852 appendString(result, ", "); 853 separator = mapGet(arg, "separator"); 854 if (separator == NULL) { 855 *lose = ISC_TRUE; 856 appendString(result, "???" ")"); 857 return result->content; 858 } 859 appendString(result, print_data_expression(separator, lose)); 860 appendString(result, ", "); 861 buffer = mapGet(arg, "buffer"); 862 if (buffer == NULL) { 863 *lose = ISC_TRUE; 864 appendString(result, "???" ")"); 865 return result->content; 866 } 867 appendString(result, print_data_expression(buffer, lose)); 868 appendString(result, ")"); 869 return result->content; 870 } 871 872 /* filename */ 873 if (mapContains(expr, "filename")) 874 return "filename"; 875 876 /* server-name */ 877 if (mapContains(expr, "server-name")) 878 return "server-name"; 879 880 /* reverse */ 881 if (mapContains(expr, "reverse")) { 882 struct element *arg; 883 struct element *width; 884 struct element *buffer; 885 886 appendString(result, "reverse("); 887 arg = mapGet(expr, "reverse"); 888 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 889 *lose = ISC_TRUE; 890 appendString(result, "???" ")"); 891 return result->content; 892 } 893 width = mapGet(arg, "width"); 894 if (width == NULL) { 895 *lose = ISC_TRUE; 896 appendString(result, "???" ")"); 897 return result->content; 898 } 899 appendString(result, print_numeric_expression(width, lose)); 900 appendString(result, ", "); 901 buffer = mapGet(arg, "buffer"); 902 if (buffer == NULL) { 903 *lose = ISC_TRUE; 904 appendString(result, "???" ")"); 905 return result->content; 906 } 907 appendString(result, print_data_expression(buffer, lose)); 908 appendString(result, ")"); 909 return result->content; 910 } 911 912 /* pick-first-value */ 913 if (mapContains(expr, "pick-first-value")) { 914 struct element *arg; 915 size_t i; 916 917 appendString(result, "pick-first-value("); 918 arg = mapGet(expr, "pick-first-value"); 919 if ((arg == NULL) || (arg->type != ELEMENT_LIST)) { 920 *lose = ISC_TRUE; 921 appendString(result, "???" ")"); 922 return result->content; 923 } 924 for (i = 0; i < listSize(arg); i++) { 925 struct element *item; 926 927 if (i != 0) 928 appendString(result, ", "); 929 item = listGet(arg, i); 930 if (item == NULL) { 931 *lose = ISC_TRUE; 932 appendString(result, "???"); 933 continue; 934 } 935 appendString(result, 936 print_data_expression(item, lose)); 937 } 938 appendString(result, ")"); 939 return result->content; 940 } 941 942 /* host-decl-name */ 943 if (mapContains(expr, "host-decl-name")) 944 return "host-decl-name"; 945 946 /* leased-address */ 947 if (mapContains(expr, "leased-address")) 948 return "leased-address"; 949 950 /* config-option */ 951 if (mapContains(expr, "config-option")) { 952 struct element *arg; 953 struct element *universe; 954 struct element *name; 955 956 appendString(result, "config-option "); 957 arg = mapGet(expr, "config-option"); 958 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 959 *lose = ISC_TRUE; 960 appendString(result, "???"); 961 return result->content; 962 } 963 universe = mapGet(arg, "universe"); 964 if ((universe == NULL) || (universe->type != ELEMENT_STRING)) { 965 *lose = ISC_TRUE; 966 appendString(result, "???"); 967 return result->content; 968 } 969 concatString(result, stringValue(universe)); 970 appendString(result, "."); 971 name = mapGet(arg, "name"); 972 if ((name == NULL) || (name->type != ELEMENT_STRING)) { 973 *lose = ISC_TRUE; 974 appendString(result, "???"); 975 return result->content; 976 } 977 concatString(result, stringValue(name)); 978 return result->content; 979 } 980 981 /* null */ 982 if (mapContains(expr, "null")) 983 return "null"; 984 985 /* gethostname */ 986 if (mapContains(expr, "gethostname")) 987 return "gethostname"; 988 989 /* v6relay */ 990 if (mapContains(expr, "v6relay")) { 991 struct element *arg; 992 struct element *relay; 993 struct element *option; 994 995 996 appendString(result, "v6relay("); 997 arg = mapGet(expr, "v6relay"); 998 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 999 *lose = ISC_TRUE; 1000 appendString(result, "???" ")"); 1001 return result->content; 1002 } 1003 relay = mapGet(arg, "relay"); 1004 if (relay == NULL) { 1005 *lose = ISC_TRUE; 1006 appendString(result, "???" ")"); 1007 return result->content; 1008 } 1009 appendString(result, print_numeric_expression(relay, lose)); 1010 appendString(result, ", "); 1011 option = mapGet(arg, "relay-option"); 1012 if (option == NULL) { 1013 *lose = ISC_TRUE; 1014 appendString(result, "???" ")"); 1015 return result->content; 1016 } 1017 appendString(result, print_data_expression(option, lose)); 1018 appendString(result, ")"); 1019 return result->content; 1020 } 1021 1022 *lose = ISC_TRUE; 1023 appendString(result, "???"); 1024 return result->content; 1025 } 1026 1027 const char * 1028 print_numeric_expression(struct element *expr, isc_boolean_t *lose) 1029 { 1030 struct string *result; 1031 1032 if (expr->type == ELEMENT_INTEGER) { 1033 char buf[20]; 1034 1035 snprintf(buf, sizeof(buf), "%lld", (long long)intValue(expr)); 1036 result = makeString(-1, buf); 1037 return result->content; 1038 } 1039 1040 /* 1041 * From is_numeric_expression 1042 */ 1043 if (expr->type != ELEMENT_MAP) { 1044 *lose = ISC_TRUE; 1045 return "???"; 1046 } 1047 result = allocString(); 1048 1049 /* extract-int8 */ 1050 if (mapContains(expr, "extract-int8")) { 1051 struct element *arg; 1052 1053 appendString(result, "extract-int("); 1054 arg = mapGet(expr, "extract-int8"); 1055 if (arg == NULL) { 1056 *lose = ISC_TRUE; 1057 appendString(result, "???, 8)"); 1058 return result->content; 1059 } 1060 appendString(result, print_data_expression(arg, lose)); 1061 appendString(result, ", 8)"); 1062 return result->content; 1063 } 1064 1065 /* extract-int16 */ 1066 if (mapContains(expr, "extract-int16")) { 1067 struct element *arg; 1068 1069 appendString(result, "extract-int("); 1070 arg = mapGet(expr, "extract-int16"); 1071 if (arg == NULL) { 1072 *lose = ISC_TRUE; 1073 appendString(result, "???, 16)"); 1074 return result->content; 1075 } 1076 appendString(result, print_data_expression(arg, lose)); 1077 appendString(result, ", 16)"); 1078 return result->content; 1079 } 1080 1081 /* extract-int32 */ 1082 if (mapContains(expr, "extract-int32")) { 1083 struct element *arg; 1084 1085 appendString(result, "extract-int("); 1086 arg = mapGet(expr, "extract-int32"); 1087 if (arg == NULL) { 1088 *lose = ISC_TRUE; 1089 appendString(result, "???, 32)"); 1090 return result->content; 1091 } 1092 appendString(result, print_data_expression(arg, lose)); 1093 appendString(result, ", 32)"); 1094 return result->content; 1095 } 1096 1097 /* const-int */ 1098 if (mapContains(expr, "const-int")) { 1099 struct element *arg; 1100 char buf[20]; 1101 1102 arg = mapGet(expr, "const-int"); 1103 if ((arg == NULL) || (arg->type != ELEMENT_INTEGER)) { 1104 *lose = ISC_TRUE; 1105 appendString(result, "???"); 1106 return result->content; 1107 } 1108 snprintf(buf, sizeof(buf), "%lld", (long long)intValue(arg)); 1109 result = makeString(-1, buf); 1110 return result->content; 1111 } 1112 1113 /* lease-time */ 1114 if (mapContains(expr, "lease-time")) 1115 return "lease-time"; 1116 1117 /* add */ 1118 if (mapContains(expr, "add")) { 1119 struct element *arg; 1120 struct element *left; 1121 struct element *right; 1122 isc_boolean_t add_parenthesis; 1123 1124 appendString(result, "add "); 1125 arg = mapGet(expr, "add"); 1126 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1127 *lose = ISC_TRUE; 1128 appendString(result, "???"); 1129 return result->content; 1130 } 1131 left = mapGet(arg, "left"); 1132 if (left == NULL) { 1133 *lose = ISC_TRUE; 1134 appendString(result, "???"); 1135 return result->content; 1136 } 1137 result = allocString(); 1138 add_parenthesis = ISC_TF(expr_precedence(expr_add, 1139 left) < 0); 1140 if (add_parenthesis) 1141 appendString(result, "("); 1142 appendString(result, print_expression(left, lose)); 1143 if (add_parenthesis) 1144 appendString(result, ")"); 1145 appendString(result, " + "); 1146 right = mapGet(arg, "right"); 1147 if (right == NULL) { 1148 *lose = ISC_TRUE; 1149 appendString(result, "???"); 1150 return result->content; 1151 } 1152 add_parenthesis = ISC_TF(expr_precedence(expr_add, 1153 right) < 0); 1154 if (add_parenthesis) 1155 appendString(result, "("); 1156 appendString(result, print_expression(right, lose)); 1157 if (add_parenthesis) 1158 appendString(result, ")"); 1159 return result->content; 1160 } 1161 1162 /* subtract */ 1163 if (mapContains(expr, "subtract")) { 1164 struct element *arg; 1165 struct element *left; 1166 struct element *right; 1167 isc_boolean_t add_parenthesis; 1168 1169 appendString(result, "subtract "); 1170 arg = mapGet(expr, "subtract"); 1171 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1172 *lose = ISC_TRUE; 1173 appendString(result, "???"); 1174 return result->content; 1175 } 1176 left = mapGet(arg, "left"); 1177 if (left == NULL) { 1178 *lose = ISC_TRUE; 1179 appendString(result, "???"); 1180 return result->content; 1181 } 1182 result = allocString(); 1183 add_parenthesis = ISC_TF(expr_precedence(expr_subtract, 1184 left) < 0); 1185 if (add_parenthesis) 1186 appendString(result, "("); 1187 appendString(result, print_expression(left, lose)); 1188 if (add_parenthesis) 1189 appendString(result, ")"); 1190 appendString(result, " - "); 1191 right = mapGet(arg, "right"); 1192 if (right == NULL) { 1193 *lose = ISC_TRUE; 1194 appendString(result, "???"); 1195 return result->content; 1196 } 1197 add_parenthesis = ISC_TF(expr_precedence(expr_subtract, 1198 right) < 0); 1199 if (add_parenthesis) 1200 appendString(result, "("); 1201 appendString(result, print_expression(right, lose)); 1202 if (add_parenthesis) 1203 appendString(result, ")"); 1204 return result->content; 1205 } 1206 1207 /* multiply */ 1208 if (mapContains(expr, "multiply")) { 1209 struct element *arg; 1210 struct element *left; 1211 struct element *right; 1212 isc_boolean_t add_parenthesis; 1213 1214 appendString(result, "multiply "); 1215 arg = mapGet(expr, "multiply"); 1216 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1217 *lose = ISC_TRUE; 1218 appendString(result, "???"); 1219 return result->content; 1220 } 1221 left = mapGet(arg, "left"); 1222 if (left == NULL) { 1223 *lose = ISC_TRUE; 1224 appendString(result, "???"); 1225 return result->content; 1226 } 1227 result = allocString(); 1228 add_parenthesis = ISC_TF(expr_precedence(expr_multiply, 1229 left) < 0); 1230 if (add_parenthesis) 1231 appendString(result, "("); 1232 appendString(result, print_expression(left, lose)); 1233 if (add_parenthesis) 1234 appendString(result, ")"); 1235 appendString(result, " * "); 1236 right = mapGet(arg, "right"); 1237 if (right == NULL) { 1238 *lose = ISC_TRUE; 1239 appendString(result, "???"); 1240 return result->content; 1241 } 1242 add_parenthesis = ISC_TF(expr_precedence(expr_multiply, 1243 right) < 0); 1244 if (add_parenthesis) 1245 appendString(result, "("); 1246 appendString(result, print_expression(right, lose)); 1247 if (add_parenthesis) 1248 appendString(result, ")"); 1249 return result->content; 1250 } 1251 1252 /* divide */ 1253 if (mapContains(expr, "divide")) { 1254 struct element *arg; 1255 struct element *left; 1256 struct element *right; 1257 isc_boolean_t add_parenthesis; 1258 1259 appendString(result, "divide "); 1260 arg = mapGet(expr, "divide"); 1261 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1262 *lose = ISC_TRUE; 1263 appendString(result, "???"); 1264 return result->content; 1265 } 1266 left = mapGet(arg, "left"); 1267 if (left == NULL) { 1268 *lose = ISC_TRUE; 1269 appendString(result, "???"); 1270 return result->content; 1271 } 1272 result = allocString(); 1273 add_parenthesis = ISC_TF(expr_precedence(expr_divide, 1274 left) < 0); 1275 if (add_parenthesis) 1276 appendString(result, "("); 1277 appendString(result, print_expression(left, lose)); 1278 if (add_parenthesis) 1279 appendString(result, ")"); 1280 appendString(result, " / "); 1281 right = mapGet(arg, "right"); 1282 if (right == NULL) { 1283 *lose = ISC_TRUE; 1284 appendString(result, "???"); 1285 return result->content; 1286 } 1287 add_parenthesis = ISC_TF(expr_precedence(expr_divide, 1288 right) < 0); 1289 if (add_parenthesis) 1290 appendString(result, "("); 1291 appendString(result, print_expression(right, lose)); 1292 if (add_parenthesis) 1293 appendString(result, ")"); 1294 return result->content; 1295 } 1296 1297 /* remainder */ 1298 if (mapContains(expr, "remainder")) { 1299 struct element *arg; 1300 struct element *left; 1301 struct element *right; 1302 isc_boolean_t add_parenthesis; 1303 1304 appendString(result, "remainder "); 1305 arg = mapGet(expr, "remainder"); 1306 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1307 *lose = ISC_TRUE; 1308 appendString(result, "???"); 1309 return result->content; 1310 } 1311 left = mapGet(arg, "left"); 1312 if (left == NULL) { 1313 *lose = ISC_TRUE; 1314 appendString(result, "???"); 1315 return result->content; 1316 } 1317 result = allocString(); 1318 add_parenthesis = ISC_TF(expr_precedence(expr_remainder, 1319 left) < 0); 1320 if (add_parenthesis) 1321 appendString(result, "("); 1322 appendString(result, print_expression(left, lose)); 1323 if (add_parenthesis) 1324 appendString(result, ")"); 1325 appendString(result, " % "); 1326 right = mapGet(arg, "right"); 1327 if (right == NULL) { 1328 *lose = ISC_TRUE; 1329 appendString(result, "???"); 1330 return result->content; 1331 } 1332 add_parenthesis = ISC_TF(expr_precedence(expr_remainder, 1333 right) < 0); 1334 if (add_parenthesis) 1335 appendString(result, "("); 1336 appendString(result, print_expression(right, lose)); 1337 if (add_parenthesis) 1338 appendString(result, ")"); 1339 return result->content; 1340 } 1341 1342 /* binary-and */ 1343 if (mapContains(expr, "binary-and")) { 1344 struct element *arg; 1345 struct element *left; 1346 struct element *right; 1347 isc_boolean_t add_parenthesis; 1348 1349 appendString(result, "binary-and "); 1350 arg = mapGet(expr, "binary-and"); 1351 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1352 *lose = ISC_TRUE; 1353 appendString(result, "???"); 1354 return result->content; 1355 } 1356 left = mapGet(arg, "left"); 1357 if (left == NULL) { 1358 *lose = ISC_TRUE; 1359 appendString(result, "???"); 1360 return result->content; 1361 } 1362 result = allocString(); 1363 add_parenthesis = ISC_TF(expr_precedence(expr_binary_and, 1364 left) < 0); 1365 if (add_parenthesis) 1366 appendString(result, "("); 1367 appendString(result, print_expression(left, lose)); 1368 if (add_parenthesis) 1369 appendString(result, ")"); 1370 appendString(result, " & "); 1371 right = mapGet(arg, "right"); 1372 if (right == NULL) { 1373 *lose = ISC_TRUE; 1374 appendString(result, "???"); 1375 return result->content; 1376 } 1377 add_parenthesis = ISC_TF(expr_precedence(expr_binary_and, 1378 right) < 0); 1379 if (add_parenthesis) 1380 appendString(result, "("); 1381 appendString(result, print_expression(right, lose)); 1382 if (add_parenthesis) 1383 appendString(result, ")"); 1384 return result->content; 1385 } 1386 1387 /* binary-or */ 1388 if (mapContains(expr, "binary-or")) { 1389 struct element *arg; 1390 struct element *left; 1391 struct element *right; 1392 isc_boolean_t add_parenthesis; 1393 1394 appendString(result, "binary-or "); 1395 arg = mapGet(expr, "binary-or"); 1396 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1397 *lose = ISC_TRUE; 1398 appendString(result, "???"); 1399 return result->content; 1400 } 1401 left = mapGet(arg, "left"); 1402 if (left == NULL) { 1403 *lose = ISC_TRUE; 1404 appendString(result, "???"); 1405 return result->content; 1406 } 1407 result = allocString(); 1408 add_parenthesis = ISC_TF(expr_precedence(expr_binary_or, 1409 left) < 0); 1410 if (add_parenthesis) 1411 appendString(result, "("); 1412 appendString(result, print_expression(left, lose)); 1413 if (add_parenthesis) 1414 appendString(result, ")"); 1415 appendString(result, " | "); 1416 right = mapGet(arg, "right"); 1417 if (right == NULL) { 1418 *lose = ISC_TRUE; 1419 appendString(result, "???"); 1420 return result->content; 1421 } 1422 add_parenthesis = ISC_TF(expr_precedence(expr_binary_or, 1423 right) < 0); 1424 if (add_parenthesis) 1425 appendString(result, "("); 1426 appendString(result, print_expression(right, lose)); 1427 if (add_parenthesis) 1428 appendString(result, ")"); 1429 return result->content; 1430 } 1431 1432 /* binary-xor */ 1433 if (mapContains(expr, "binary-xor")) { 1434 struct element *arg; 1435 struct element *left; 1436 struct element *right; 1437 isc_boolean_t add_parenthesis; 1438 1439 appendString(result, "binary-xor "); 1440 arg = mapGet(expr, "binary-xor"); 1441 if ((arg == NULL) || (arg->type != ELEMENT_MAP)) { 1442 *lose = ISC_TRUE; 1443 appendString(result, "???"); 1444 return result->content; 1445 } 1446 left = mapGet(arg, "left"); 1447 if (left == NULL) { 1448 *lose = ISC_TRUE; 1449 appendString(result, "???"); 1450 return result->content; 1451 } 1452 result = allocString(); 1453 add_parenthesis = ISC_TF(expr_precedence(expr_binary_xor, 1454 left) < 0); 1455 if (add_parenthesis) 1456 appendString(result, "("); 1457 appendString(result, print_expression(left, lose)); 1458 if (add_parenthesis) 1459 appendString(result, ")"); 1460 appendString(result, " ^ "); 1461 right = mapGet(arg, "right"); 1462 if (right == NULL) { 1463 *lose = ISC_TRUE; 1464 appendString(result, "???"); 1465 return result->content; 1466 } 1467 add_parenthesis = ISC_TF(expr_precedence(expr_binary_xor, 1468 right) < 0); 1469 if (add_parenthesis) 1470 appendString(result, "("); 1471 appendString(result, print_expression(right, lose)); 1472 if (add_parenthesis) 1473 appendString(result, ")"); 1474 return result->content; 1475 } 1476 1477 /* client-state */ 1478 if (mapContains(expr, "client-state")) 1479 return "client-state"; 1480 1481 *lose = ISC_TRUE; 1482 appendString(result, "???"); 1483 return result->content; 1484 } 1485 1486 static void 1487 debug(const char* fmt, ...) 1488 { 1489 va_list list; 1490 1491 va_start(list, fmt); 1492 vfprintf(stderr, fmt, list); 1493 fprintf(stderr, "\n"); 1494 va_end(list); 1495 } 1496