1 2 /* ntp_scanner.c 3 * 4 * The source code for a simple lexical analyzer. 5 * 6 * Written By: Sachin Kamboj 7 * University of Delaware 8 * Newark, DE 19711 9 * Copyright (c) 2006 10 */ 11 12 #ifdef HAVE_CONFIG_H 13 # include <config.h> 14 #endif 15 16 #include <stdio.h> 17 #include <ctype.h> 18 #include <stdlib.h> 19 #include <errno.h> 20 #include <string.h> 21 22 #include "ntpd.h" 23 #include "ntp_config.h" 24 #include "ntpsim.h" 25 #include "ntp_scanner.h" 26 #include "ntp_parser.h" 27 28 /* ntp_keyword.h declares finite state machine and token text */ 29 #include "ntp_keyword.h" 30 31 32 33 /* SCANNER GLOBAL VARIABLES 34 * ------------------------ 35 */ 36 37 #define MAX_LEXEME (1024 + 1) /* The maximum size of a lexeme */ 38 char yytext[MAX_LEXEME]; /* Buffer for storing the input text/lexeme */ 39 u_int32 conf_file_sum; /* Simple sum of characters read */ 40 41 static struct FILE_INFO * lex_stack = NULL; 42 43 44 45 /* CONSTANTS 46 * --------- 47 */ 48 49 50 /* SCANNER GLOBAL VARIABLES 51 * ------------------------ 52 */ 53 const char special_chars[] = "{}(),;|="; 54 55 56 /* FUNCTIONS 57 * --------- 58 */ 59 60 static int is_keyword(char *lexeme, follby *pfollowedby); 61 62 63 /* 64 * keyword() - Return the keyword associated with token T_ identifier. 65 * See also token_name() for the string-ized T_ identifier. 66 * Example: keyword(T_Server) returns "server" 67 * token_name(T_Server) returns "T_Server" 68 */ 69 const char * 70 keyword( 71 int token 72 ) 73 { 74 size_t i; 75 const char *text; 76 static char sbuf[64]; 77 78 i = token - LOWEST_KEYWORD_ID; 79 80 switch (token) { 81 case T_ServerresponseFuzz: 82 text = "serverresponse fuzz"; 83 break; 84 85 default: 86 if (i < COUNTOF(keyword_text)) { 87 text = keyword_text[i]; 88 } else { 89 snprintf(sbuf, sizeof sbuf, 90 "(keyword #%u not found)", token); 91 text = sbuf; 92 } 93 } 94 95 return text; 96 } 97 98 99 /* FILE & STRING BUFFER INTERFACE 100 * ------------------------------ 101 * 102 * This set out as a couple of wrapper functions around the standard C 103 * fgetc and ungetc functions in order to include positional 104 * bookkeeping. Alas, this is no longer a good solution with nested 105 * input files and the possibility to send configuration commands via 106 * 'ntpdc' and 'ntpq'. 107 * 108 * Now there are a few functions to maintain a stack of nested input 109 * sources (though nesting is only allowd for disk files) and from the 110 * scanner / parser point of view there's no difference between both 111 * types of sources. 112 * 113 * The 'fgetc()' / 'ungetc()' replacements now operate on a FILE_INFO 114 * structure. Instead of trying different 'ungetc()' strategies for file 115 * and buffer based parsing, we keep the backup char in our own 116 * FILE_INFO structure. This is sufficient, as the parser does *not* 117 * jump around via 'seek' or the like, and there's no need to 118 * check/clear the backup store in other places than 'lex_getch()'. 119 */ 120 121 /* 122 * Allocate an info structure and attach it to a file. 123 * 124 * Note: When 'mode' is NULL, then the INFO block will be set up to 125 * contain a NULL file pointer, as suited for remote config command 126 * parsing. Otherwise having a NULL file pointer is considered an error, 127 * and a NULL info block pointer is returned to indicate failure! 128 * 129 * Note: We use a variable-sized structure to hold a copy of the file 130 * name (or, more proper, the input source description). This is more 131 * secure than keeping a reference to some other storage that might go 132 * out of scope. 133 */ 134 static struct FILE_INFO * 135 lex_open( 136 const char *path, 137 const char *mode 138 ) 139 { 140 struct FILE_INFO *stream; 141 size_t nnambuf; 142 143 nnambuf = strlen(path); 144 stream = emalloc_zero(sizeof(*stream) + nnambuf); 145 stream->curpos.nline = 1; 146 stream->backch = EOF; 147 /* copy name with memcpy -- trailing NUL already there! */ 148 memcpy(stream->fname, path, nnambuf); 149 150 if (NULL != mode) { 151 stream->fpi = fopen(path, mode); 152 if (NULL == stream->fpi) { 153 free(stream); 154 stream = NULL; 155 } 156 } 157 return stream; 158 } 159 160 /* get next character from buffer or file. This will return any putback 161 * character first; it will also make sure the last line is at least 162 * virtually terminated with a '\n'. 163 */ 164 static int 165 lex_getch( 166 struct FILE_INFO *stream 167 ) 168 { 169 int ch; 170 171 if (NULL == stream || stream->force_eof) 172 return EOF; 173 174 if (EOF != stream->backch) { 175 ch = stream->backch; 176 stream->backch = EOF; 177 if (stream->fpi) 178 conf_file_sum += ch; 179 stream->curpos.ncol++; 180 } else if (stream->fpi) { 181 /* fetch next 7-bit ASCII char (or EOF) from file */ 182 while ((ch = fgetc(stream->fpi)) != EOF && ch > SCHAR_MAX) 183 stream->curpos.ncol++; 184 if (EOF != ch) { 185 conf_file_sum += ch; 186 stream->curpos.ncol++; 187 } 188 } else { 189 /* fetch next 7-bit ASCII char from buffer */ 190 const char * scan; 191 scan = &remote_config.buffer[remote_config.pos]; 192 while ((ch = (u_char)*scan) > SCHAR_MAX) { 193 scan++; 194 stream->curpos.ncol++; 195 } 196 if ('\0' != ch) { 197 scan++; 198 stream->curpos.ncol++; 199 } else { 200 ch = EOF; 201 } 202 remote_config.pos = (int)(scan - remote_config.buffer); 203 } 204 205 /* If the last line ends without '\n', generate one. This 206 * happens most likely on Windows, where editors often have a 207 * sloppy concept of a line. 208 */ 209 if (EOF == ch && stream->curpos.ncol != 0) 210 ch = '\n'; 211 212 /* update scan position tallies */ 213 if (ch == '\n') { 214 stream->bakpos = stream->curpos; 215 stream->curpos.nline++; 216 stream->curpos.ncol = 0; 217 } 218 219 return ch; 220 } 221 222 /* Note: lex_ungetch will fail to track more than one line of push 223 * back. But since it guarantees only one char of back storage anyway, 224 * this should not be a problem. 225 */ 226 static int 227 lex_ungetch( 228 int ch, 229 struct FILE_INFO *stream 230 ) 231 { 232 /* check preconditions */ 233 if (NULL == stream || stream->force_eof) 234 return EOF; 235 if (EOF != stream->backch || EOF == ch) 236 return EOF; 237 238 /* keep for later reference and update checksum */ 239 stream->backch = (u_char)ch; 240 if (stream->fpi) 241 conf_file_sum -= stream->backch; 242 243 /* update position */ 244 if (stream->backch == '\n') { 245 stream->curpos = stream->bakpos; 246 stream->bakpos.ncol = -1; 247 } 248 stream->curpos.ncol--; 249 return stream->backch; 250 } 251 252 /* dispose of an input structure. If the file pointer is not NULL, close 253 * the file. This function does not check the result of 'fclose()'. 254 */ 255 static void 256 lex_close( 257 struct FILE_INFO *stream 258 ) 259 { 260 if (NULL != stream) { 261 if (NULL != stream->fpi) 262 fclose(stream->fpi); 263 free(stream); 264 } 265 } 266 267 /* INPUT STACK 268 * ----------- 269 * 270 * Nested input sources are a bit tricky at first glance. We deal with 271 * this problem using a stack of input sources, that is, a forward 272 * linked list of FILE_INFO structs. 273 * 274 * This stack is never empty during parsing; while an encounter with EOF 275 * can and will remove nested input sources, removing the last element 276 * in the stack will not work during parsing, and the EOF condition of 277 * the outermost input file remains until the parser folds up. 278 */ 279 280 static struct FILE_INFO * 281 _drop_stack_do( 282 struct FILE_INFO * head 283 ) 284 { 285 struct FILE_INFO * tail; 286 while (NULL != head) { 287 tail = head->st_next; 288 lex_close(head); 289 head = tail; 290 } 291 return head; 292 } 293 294 295 296 /* Create a singleton input source on an empty lexer stack. This will 297 * fail if there is already an input source, or if the underlying disk 298 * file cannot be opened. 299 * 300 * Returns TRUE if a new input object was successfully created. 301 */ 302 int/*BOOL*/ 303 lex_init_stack( 304 const char * path, 305 const char * mode 306 ) 307 { 308 if (NULL != lex_stack || NULL == path) 309 return FALSE; 310 311 lex_stack = lex_open(path, mode); 312 return (NULL != lex_stack); 313 } 314 315 /* This removes *all* input sources from the stack, leaving the head 316 * pointer as NULL. Any attempt to parse in that state is likely to bomb 317 * with segmentation faults or the like. 318 * 319 * In other words: Use this to clean up after parsing, and do not parse 320 * anything until the next 'lex_init_stack()' succeeded. 321 */ 322 void 323 lex_drop_stack() 324 { 325 lex_stack = _drop_stack_do(lex_stack); 326 } 327 328 /* Flush the lexer input stack: This will nip all input objects on the 329 * stack (but keeps the current top-of-stack) and marks the top-of-stack 330 * as inactive. Any further calls to lex_getch yield only EOF, and it's 331 * no longer possible to push something back. 332 * 333 * Returns TRUE if there is a head element (top-of-stack) that was not 334 * in the force-eof mode before this call. 335 */ 336 int/*BOOL*/ 337 lex_flush_stack() 338 { 339 int retv = FALSE; 340 341 if (NULL != lex_stack) { 342 retv = !lex_stack->force_eof; 343 lex_stack->force_eof = TRUE; 344 lex_stack->st_next = _drop_stack_do( 345 lex_stack->st_next); 346 } 347 return retv; 348 } 349 350 /* Push another file on the parsing stack. If the mode is NULL, create a 351 * FILE_INFO suitable for in-memory parsing; otherwise, create a 352 * FILE_INFO that is bound to a local/disc file. Note that 'path' must 353 * not be NULL, or the function will fail. 354 * 355 * Returns TRUE if a new info record was pushed onto the stack. 356 */ 357 int/*BOOL*/ lex_push_file( 358 const char * path, 359 const char * mode 360 ) 361 { 362 struct FILE_INFO * next = NULL; 363 364 if (NULL != path) { 365 next = lex_open(path, mode); 366 if (NULL != next) { 367 next->st_next = lex_stack; 368 lex_stack = next; 369 } 370 } 371 return (NULL != next); 372 } 373 374 /* Pop, close & free the top of the include stack, unless the stack 375 * contains only a singleton input object. In that case the function 376 * fails, because the parser does not expect the input stack to be 377 * empty. 378 * 379 * Returns TRUE if an object was successfuly popped from the stack. 380 */ 381 int/*BOOL*/ 382 lex_pop_file(void) 383 { 384 struct FILE_INFO * head = lex_stack; 385 struct FILE_INFO * tail = NULL; 386 387 if (NULL != head) { 388 tail = head->st_next; 389 if (NULL != tail) { 390 lex_stack = tail; 391 lex_close(head); 392 } 393 } 394 return (NULL != tail); 395 } 396 397 /* Get include nesting level. This currently loops over the stack and 398 * counts elements; but since this is of concern only with an include 399 * statement and the nesting depth has a small limit, there's no 400 * bottleneck expected here. 401 * 402 * Returns the nesting level of includes, that is, the current depth of 403 * the lexer input stack. 404 * 405 * Note: 406 */ 407 size_t 408 lex_level(void) 409 { 410 size_t cnt = 0; 411 struct FILE_INFO *ipf = lex_stack; 412 413 while (NULL != ipf) { 414 cnt++; 415 ipf = ipf->st_next; 416 } 417 return cnt; 418 } 419 420 /* check if the current input is from a file */ 421 int/*BOOL*/ 422 lex_from_file(void) 423 { 424 return (NULL != lex_stack) && (NULL != lex_stack->fpi); 425 } 426 427 struct FILE_INFO * 428 lex_current() 429 { 430 /* this became so simple, it could be a macro. But then, 431 * lex_stack needed to be global... 432 */ 433 return lex_stack; 434 } 435 436 437 /* STATE MACHINES 438 * -------------- 439 */ 440 441 /* Keywords */ 442 static int 443 is_keyword( 444 char *lexeme, 445 follby *pfollowedby 446 ) 447 { 448 follby fb; 449 int curr_s; /* current state index */ 450 int token; 451 int i; 452 453 curr_s = SCANNER_INIT_S; 454 token = 0; 455 456 for (i = 0; lexeme[i]; i++) { 457 while (curr_s && (lexeme[i] != SS_CH(sst[curr_s]))) 458 curr_s = SS_OTHER_N(sst[curr_s]); 459 460 if (curr_s && (lexeme[i] == SS_CH(sst[curr_s]))) { 461 if ('\0' == lexeme[i + 1] 462 && FOLLBY_NON_ACCEPTING 463 != SS_FB(sst[curr_s])) { 464 fb = SS_FB(sst[curr_s]); 465 *pfollowedby = fb; 466 token = curr_s; 467 break; 468 } 469 curr_s = SS_MATCH_N(sst[curr_s]); 470 } else 471 break; 472 } 473 474 return token; 475 } 476 477 478 /* Integer */ 479 static int 480 is_integer( 481 char *lexeme 482 ) 483 { 484 int i; 485 int is_neg; 486 u_int u_val; 487 488 i = 0; 489 490 /* Allow a leading minus sign */ 491 if (lexeme[i] == '-') { 492 i++; 493 is_neg = TRUE; 494 } else { 495 is_neg = FALSE; 496 } 497 498 /* Check that all the remaining characters are digits */ 499 for (; lexeme[i] != '\0'; i++) { 500 if (!isdigit((u_char)lexeme[i])) 501 return FALSE; 502 } 503 504 if (is_neg) 505 return TRUE; 506 507 /* Reject numbers that fit in unsigned but not in signed int */ 508 if (1 == sscanf(lexeme, "%u", &u_val)) 509 return (u_val <= INT_MAX); 510 else 511 return FALSE; 512 } 513 514 515 /* U_int -- assumes is_integer() has returned FALSE */ 516 static int 517 is_u_int( 518 char *lexeme 519 ) 520 { 521 int i; 522 int is_hex; 523 524 i = 0; 525 if ('0' == lexeme[i] && 'x' == tolower((u_char)lexeme[i + 1])) { 526 i += 2; 527 is_hex = TRUE; 528 } else { 529 is_hex = FALSE; 530 } 531 532 /* Check that all the remaining characters are digits */ 533 for (; lexeme[i] != '\0'; i++) { 534 if (is_hex && !isxdigit((u_char)lexeme[i])) 535 return FALSE; 536 if (!is_hex && !isdigit((u_char)lexeme[i])) 537 return FALSE; 538 } 539 540 return TRUE; 541 } 542 543 544 /* Double */ 545 static int 546 is_double( 547 char *lexeme 548 ) 549 { 550 u_int num_digits = 0; /* Number of digits read */ 551 u_int i; 552 553 i = 0; 554 555 /* Check for an optional '+' or '-' */ 556 if ('+' == lexeme[i] || '-' == lexeme[i]) 557 i++; 558 559 /* Read the integer part */ 560 for (; lexeme[i] && isdigit((u_char)lexeme[i]); i++) 561 num_digits++; 562 563 /* Check for the optional decimal point */ 564 if ('.' == lexeme[i]) { 565 i++; 566 /* Check for any digits after the decimal point */ 567 for (; lexeme[i] && isdigit((u_char)lexeme[i]); i++) 568 num_digits++; 569 } 570 571 /* 572 * The number of digits in both the decimal part and the 573 * fraction part must not be zero at this point 574 */ 575 if (!num_digits) 576 return 0; 577 578 /* Check if we are done */ 579 if (!lexeme[i]) 580 return 1; 581 582 /* There is still more input, read the exponent */ 583 if ('e' == tolower((u_char)lexeme[i])) 584 i++; 585 else 586 return 0; 587 588 /* Read an optional Sign */ 589 if ('+' == lexeme[i] || '-' == lexeme[i]) 590 i++; 591 592 /* Now read the exponent part */ 593 while (lexeme[i] && isdigit((u_char)lexeme[i])) 594 i++; 595 596 /* Check if we are done */ 597 if (!lexeme[i]) 598 return 1; 599 else 600 return 0; 601 } 602 603 604 /* is_special() - Test whether a character is a token */ 605 static inline int 606 is_special( 607 int ch 608 ) 609 { 610 return strchr(special_chars, ch) != NULL; 611 } 612 613 614 static int 615 is_EOC( 616 int ch 617 ) 618 { 619 if ((old_config_style && (ch == '\n')) || 620 (!old_config_style && (ch == ';'))) 621 return 1; 622 return 0; 623 } 624 625 626 char * 627 quote_if_needed(char *str) 628 { 629 char *ret; 630 size_t len; 631 size_t octets; 632 633 len = strlen(str); 634 octets = len + 2 + 1; 635 ret = emalloc(octets); 636 if ('"' != str[0] 637 && (strcspn(str, special_chars) < len 638 || strchr(str, ' ') != NULL)) { 639 snprintf(ret, octets, "\"%s\"", str); 640 } else 641 strlcpy(ret, str, octets); 642 643 return ret; 644 } 645 646 647 static int 648 create_string_token( 649 char *lexeme 650 ) 651 { 652 char *pch; 653 654 /* 655 * ignore end of line whitespace 656 */ 657 pch = lexeme; 658 while (*pch && isspace((u_char)*pch)) 659 pch++; 660 661 if (!*pch) { 662 yylval.Integer = T_EOC; 663 return yylval.Integer; 664 } 665 666 yylval.String = estrdup(lexeme); 667 return T_String; 668 } 669 670 671 /* 672 * yylex() - function that does the actual scanning. 673 * Bison expects this function to be called yylex and for it to take no 674 * input and return an int. 675 * Conceptually yylex "returns" yylval as well as the actual return 676 * value representing the token or type. 677 */ 678 int 679 yylex(void) 680 { 681 static follby followedby = FOLLBY_TOKEN; 682 size_t i; 683 int instring; 684 int yylval_was_set; 685 int converted; 686 int token; /* The return value */ 687 int ch; 688 689 instring = FALSE; 690 yylval_was_set = FALSE; 691 692 do { 693 /* Ignore whitespace at the beginning */ 694 while (EOF != (ch = lex_getch(lex_stack)) && 695 isspace(ch) && 696 !is_EOC(ch)) 697 698 ; /* Null Statement */ 699 700 if (EOF == ch) { 701 702 if ( ! lex_pop_file()) 703 return 0; 704 token = T_EOC; 705 goto normal_return; 706 707 } else if (is_EOC(ch)) { 708 709 /* end FOLLBY_STRINGS_TO_EOC effect */ 710 followedby = FOLLBY_TOKEN; 711 token = T_EOC; 712 goto normal_return; 713 714 } else if (is_special(ch) && FOLLBY_TOKEN == followedby) { 715 /* special chars are their own token values */ 716 token = ch; 717 /* 718 * '=' outside simulator configuration implies 719 * a single string following as in: 720 * setvar Owner = "The Boss" default 721 */ 722 if ('=' == ch && old_config_style) 723 followedby = FOLLBY_STRING; 724 yytext[0] = (char)ch; 725 yytext[1] = '\0'; 726 goto normal_return; 727 } else 728 lex_ungetch(ch, lex_stack); 729 730 /* save the position of start of the token */ 731 lex_stack->tokpos = lex_stack->curpos; 732 733 /* Read in the lexeme */ 734 i = 0; 735 while (EOF != (ch = lex_getch(lex_stack))) { 736 737 yytext[i] = (char)ch; 738 739 /* Break on whitespace or a special character */ 740 if (isspace(ch) || is_EOC(ch) 741 || '"' == ch 742 || (FOLLBY_TOKEN == followedby 743 && is_special(ch))) 744 break; 745 746 /* Read the rest of the line on reading a start 747 of comment character */ 748 if ('#' == ch) { 749 while (EOF != (ch = lex_getch(lex_stack)) 750 && '\n' != ch) 751 ; /* Null Statement */ 752 break; 753 } 754 755 i++; 756 if (i >= COUNTOF(yytext)) 757 goto lex_too_long; 758 } 759 /* Pick up all of the string inside between " marks, to 760 * end of line. If we make it to EOL without a 761 * terminating " assume it for them. 762 * 763 * XXX - HMS: I'm not sure we want to assume the closing " 764 */ 765 if ('"' == ch) { 766 instring = TRUE; 767 while (EOF != (ch = lex_getch(lex_stack)) && 768 ch != '"' && ch != '\n') { 769 yytext[i++] = (char)ch; 770 if (i >= COUNTOF(yytext)) 771 goto lex_too_long; 772 } 773 /* 774 * yytext[i] will be pushed back as not part of 775 * this lexeme, but any closing quote should 776 * not be pushed back, so we read another char. 777 */ 778 if ('"' == ch) 779 ch = lex_getch(lex_stack); 780 } 781 /* Pushback the last character read that is not a part 782 * of this lexeme. This fails silently if ch is EOF, 783 * but then the EOF condition persists and is handled on 784 * the next turn by the include stack mechanism. 785 */ 786 lex_ungetch(ch, lex_stack); 787 788 yytext[i] = '\0'; 789 } while (i == 0); 790 791 /* Now return the desired token */ 792 793 /* First make sure that the parser is *not* expecting a string 794 * as the next token (based on the previous token that was 795 * returned) and that we haven't read a string. 796 */ 797 798 if (followedby == FOLLBY_TOKEN && !instring) { 799 token = is_keyword(yytext, &followedby); 800 if (token) { 801 /* 802 * T_Server is exceptional as it forces the 803 * following token to be a string in the 804 * non-simulator parts of the configuration, 805 * but in the simulator configuration section, 806 * "server" is followed by "=" which must be 807 * recognized as a token not a string. 808 */ 809 if (T_Server == token && !old_config_style) 810 followedby = FOLLBY_TOKEN; 811 goto normal_return; 812 } else if (is_integer(yytext)) { 813 yylval_was_set = TRUE; 814 errno = 0; 815 if ((yylval.Integer = strtol(yytext, NULL, 10)) == 0 816 && ((errno == EINVAL) || (errno == ERANGE))) { 817 msyslog(LOG_ERR, 818 "Integer cannot be represented: %s", 819 yytext); 820 if (lex_from_file()) { 821 exit(1); 822 } else { 823 /* force end of parsing */ 824 yylval.Integer = 0; 825 return 0; 826 } 827 } 828 token = T_Integer; 829 goto normal_return; 830 } else if (is_u_int(yytext)) { 831 yylval_was_set = TRUE; 832 if ('0' == yytext[0] && 833 'x' == tolower((unsigned long)yytext[1])) 834 converted = sscanf(&yytext[2], "%x", 835 &yylval.U_int); 836 else 837 converted = sscanf(yytext, "%u", 838 &yylval.U_int); 839 if (1 != converted) { 840 msyslog(LOG_ERR, 841 "U_int cannot be represented: %s", 842 yytext); 843 if (lex_from_file()) { 844 exit(1); 845 } else { 846 /* force end of parsing */ 847 yylval.Integer = 0; 848 return 0; 849 } 850 } 851 token = T_U_int; 852 goto normal_return; 853 } else if (is_double(yytext)) { 854 yylval_was_set = TRUE; 855 errno = 0; 856 if ((yylval.Double = atof(yytext)) == 0 && errno == ERANGE) { 857 msyslog(LOG_ERR, 858 "Double too large to represent: %s", 859 yytext); 860 exit(1); 861 } else { 862 token = T_Double; 863 goto normal_return; 864 } 865 } else { 866 /* Default: Everything is a string */ 867 yylval_was_set = TRUE; 868 token = create_string_token(yytext); 869 goto normal_return; 870 } 871 } 872 873 /* 874 * Either followedby is not FOLLBY_TOKEN or this lexeme is part 875 * of a string. Hence, we need to return T_String. 876 * 877 * _Except_ we might have a -4 or -6 flag on a an association 878 * configuration line (server, peer, pool, etc.). 879 * 880 * This is a terrible hack, but the grammar is ambiguous so we 881 * don't have a choice. [SK] 882 * 883 * The ambiguity is in the keyword scanner, not ntp_parser.y. 884 * We do not require server addresses be quoted in ntp.conf, 885 * complicating the scanner's job. To avoid trying (and 886 * failing) to match an IP address or DNS name to a keyword, 887 * the association keywords use FOLLBY_STRING in the keyword 888 * table, which tells the scanner to force the next token to be 889 * a T_String, so it does not try to match a keyword but rather 890 * expects a string when -4/-6 modifiers to server, peer, etc. 891 * are encountered. 892 * restrict -4 and restrict -6 parsing works correctly without 893 * this hack, as restrict uses FOLLBY_TOKEN. [DH] 894 */ 895 if ('-' == yytext[0]) { 896 if ('4' == yytext[1]) { 897 token = T_Ipv4_flag; 898 goto normal_return; 899 } else if ('6' == yytext[1]) { 900 token = T_Ipv6_flag; 901 goto normal_return; 902 } 903 } 904 905 if (FOLLBY_STRING == followedby) 906 followedby = FOLLBY_TOKEN; 907 908 yylval_was_set = TRUE; 909 token = create_string_token(yytext); 910 911 normal_return: 912 if (T_EOC == token) 913 DPRINTF(4,("\t<end of command>\n")); 914 else 915 DPRINTF(4, ("yylex: lexeme '%s' -> %s\n", yytext, 916 token_name(token))); 917 918 if (!yylval_was_set) 919 yylval.Integer = token; 920 921 return token; 922 923 lex_too_long: 924 yytext[min(sizeof(yytext) - 1, 50)] = 0; 925 msyslog(LOG_ERR, 926 "configuration item on line %d longer than limit of %lu, began with '%s'", 927 lex_stack->curpos.nline, (u_long)min(sizeof(yytext) - 1, 50), 928 yytext); 929 930 /* 931 * If we hit the length limit reading the startup configuration 932 * file, abort. 933 */ 934 if (lex_from_file()) 935 exit(sizeof(yytext) - 1); 936 937 /* 938 * If it's runtime configuration via ntpq :config treat it as 939 * if the configuration text ended before the too-long lexeme, 940 * hostname, or string. 941 */ 942 yylval.Integer = 0; 943 return 0; 944 } 945