3 * ===================================
4 * HARP | Host ATM Research Platform
5 * ===================================
8 * This Host ATM Research Platform ("HARP") file (the "Software") is
9 * made available by Network Computing Services, Inc. ("NetworkCS")
10 * "AS IS". NetworkCS does not provide maintenance, improvements or
11 * support of any kind.
13 * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15 * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16 * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17 * In no event shall NetworkCS be responsible for any damages, including
18 * but not limited to consequential damages, arising from or relating to
19 * any use of the Software or related support.
21 * Copyright 1994-1998 Network Computing Services, Inc.
23 * Copies of this Software may be made, however, the above copyright
24 * notice must be reproduced on all copies.
26 * @(#) $FreeBSD: src/usr.sbin/atm/scspd/scsp_config_lex.c,v 1.3 1999/08/28 01:15:32 peter Exp $
27 * @(#) $DragonFly: src/usr.sbin/atm/scspd/scsp_config_lex.c,v 1.2 2003/06/17 04:29:52 dillon Exp $
31 * Server Cache Synchronization Protocol (SCSP) Support
32 * ----------------------------------------------------
34 * Parse a configuration file into tokens
38 #include <sys/types.h>
39 #include <sys/param.h>
40 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <netatm/port.h>
44 #include <netatm/queue.h>
45 #include <netatm/atm.h>
46 #include <netatm/atm_if.h>
47 #include <netatm/atm_sap.h>
48 #include <netatm/atm_sys.h>
49 #include <netatm/atm_ioctl.h>
62 #include "scsp_config_parse.h"
72 #define TOK_MAX_LEN 128
77 #define CHAR_INVALID 0 /* Not allowed */
78 #define CHAR_ALPHA 1 /* G-W, Y, Z */
79 #define CHAR_HEX_DIGIT 2 /* A-F */
80 #define CHAR_X 3 /* X */
81 #define CHAR_0 4 /* '0' */
82 #define CHAR_DIGIT 5 /* 1-9 */
83 #define CHAR_SPACE 6 /* space, tab */
84 #define CHAR_DECIMAL 7 /* period */
85 #define CHAR_SLASH 8 /* slash */
86 #define CHAR_ASTERISK 9 /* asterisk */
87 #define CHAR_HASH 10 /* pound sign */
88 #define CHAR_SPECIAL 11 /* semicolon, braces */
89 #define CHAR_MISC 12 /* chars allowd in file names */
90 #define CHAR_EOL 13 /* new line */
91 #define CHAR_EOF 14 /* EOF */
92 #define CHAR_CNT CHAR_EOF + 1
95 * Character class table (initialized by init_class_tbl())
97 static char class_tbl[128];
100 * State table element structure
117 #define TS_COMMENT_1 7
120 #define TS_CNT TS_HEX_1 + 1
123 * Token scanner state table
125 static struct state_entry token_state_tbl[CHAR_CNT][TS_CNT] = {
126 /* 0 1 2 3 4 5 6 7 8 9 */
127 /* bad */{{2,0},{2,0},{2,0},{2,0},{2,0},{2,0},{0,6},{0,6},{0,8},{2,0}},
128 /* g-z */{{1,1},{1,1},{1,1},{1,1},{2,0},{1,1},{0,6},{0,6},{0,8},{2,0}},
129 /* a-f */{{1,1},{1,1},{1,1},{1,1},{1,9},{1,1},{0,6},{0,6},{0,8},{1,4}},
130 /* x */{{1,1},{1,1},{1,4},{1,4},{2,0},{1,1},{0,6},{0,6},{0,8},{2,0}},
131 /* 0 */{{1,2},{1,1},{1,3},{1,3},{1,9},{1,1},{0,6},{0,6},{0,8},{1,4}},
132 /* 1-9 */{{1,3},{1,1},{1,3},{1,3},{1,9},{1,1},{0,6},{0,6},{0,8},{1,4}},
133 /* sp */{{0,0},{6,0},{8,0},{8,0},{7,0},{6,0},{0,6},{0,6},{0,8},{2,0}},
134 /* . */{{2,0},{1,1},{1,1},{1,1},{1,4},{1,1},{0,6},{0,6},{0,8},{2,0}},
135 /* / */{{1,5},{1,1},{1,1},{1,1},{7,0},{4,8},{0,6},{0,0},{0,8},{2,0}},
136 /* * */{{2,0},{6,0},{8,0},{8,0},{7,0},{4,6},{0,7},{0,7},{0,8},{2,0}},
137 /* # */{{0,8},{6,0},{8,0},{8,0},{7,0},{6,0},{0,6},{0,6},{0,8},{2,0}},
138 /* ;{} */{{3,0},{6,0},{8,0},{8,0},{7,0},{6,0},{0,6},{0,6},{0,8},{2,0}},
139 /* Msc */{{2,0},{1,1},{1,1},{1,1},{2,0},{1,1},{0,6},{0,6},{0,8},{2,0}},
140 /* EOL */{{0,0},{6,0},{8,0},{8,0},{7,0},{6,0},{0,6},{0,6},{0,0},{2,0}},
141 /* EOF */{{9,0},{6,0},{8,0},{8,0},{7,0},{6,0},{2,0},{2,0},{9,0},{2,0}},
151 } rsvd_word_tbl[] = {
152 { "ATMaddr", TOK_DCS_ADDR },
153 { "ATMARP", TOK_ATMARP },
154 { "CAReXmitInt", TOK_DCS_CA_REXMIT_INT },
155 { "CSUSReXmitInt", TOK_DCS_CSUS_REXMIT_INT },
156 { "CSUReXmitInt", TOK_DCS_CSU_REXMIT_INT },
157 { "CSUReXmitMax", TOK_DCS_CSU_REXMIT_MAX },
159 { "DHCP", TOK_DHCP },
160 { "familyID", TOK_FAMILY },
162 { "hops", TOK_DCS_HOP_CNT },
163 { "HelloDead", TOK_DCS_HELLO_DF },
164 { "HelloInt", TOK_DCS_HELLO_INT },
165 { "ID", TOK_DCS_ID },
166 { "LNNI", TOK_LNNI },
168 { "MARS", TOK_MARS },
169 { "netif", TOK_NETIF },
170 { "NHRP", TOK_NHRP },
171 { "protocol", TOK_PROTOCOL },
172 { "server", TOK_SERVER },
173 { "ServerGroupID", TOK_SRVGRP },
174 { "syslog", TOK_SYSLOG },
180 * Copy a character string
182 * Make a copy of a character string, using strdup. If strdup fails,
183 * meaning we're out of memory, then print an error message and exit.
186 * s string to be copied
189 * char * pointer to area provided by strdup
201 fprintf(stderr, "%s: strdup failed\n", prog);
210 * Push a character back onto the input stream.
213 * c character to be pushed
231 * Initialize the character class table.
233 * Set each entry in the character class table to the class
234 * corresponding to the character.
237 * tbl pointer to table to be initialized
250 * Set up the table for all ASCII characters
252 for (i=0; isascii((char)i); i++) {
256 tbl[i] = CHAR_INVALID;
259 * Set entries depending on character type
262 if (c == 'a' || c == 'b' || c == 'c' ||
263 c == 'd' || c == 'e' || c == 'f' ||
264 c == 'A' || c == 'B' || c == 'C' ||
265 c == 'D' || c == 'E' || c == 'F')
266 tbl[i] = CHAR_HEX_DIGIT;
267 else if (c == 'x' || c == 'X')
277 else if (c == ' ' || c == '\t')
282 tbl[i] = CHAR_ASTERISK;
284 tbl[i] = CHAR_DECIMAL;
287 else if (c == ';' || c == '{' || c == '}')
288 tbl[i] = CHAR_SPECIAL;
289 else if (c == '-' || c == '_' || c == '&' || c == '@' ||
297 * Get the class of a character.
300 * c character being scanned
303 * int character class
309 int class = CHAR_INVALID;
313 } else if (c < 0 || !isascii(c)) {
314 class = CHAR_INVALID;
316 class = class_tbl[(int)c];
324 * Print an error message when the scanner finds an error
327 * c character on which the error was recognized
328 * state scanner state at error
339 * Check for invalid character
341 if (char_class(c) == CHAR_INVALID) {
342 parse_error("Invalid character 0x%x encountered",
348 * Check for unexpected EOF
350 if (char_class(c) == CHAR_EOF) {
351 parse_error("Unexpected end of file");
356 * Error depends on state
360 parse_error("Syntax error at '%c'", c);
369 parse_error("Syntax error");
373 parse_error("Syntax error in hex string");
382 * Read a character at a time from the input file, assembling the
383 * characters into tokens as specified by the token scanner state
384 * table. Return the completed token.
390 * token the type of the token found
396 char c, token_buffer[TOK_MAX_LEN];
401 if (class_tbl['A'] != CHAR_HEX_DIGIT)
402 init_class_tbl(class_tbl);
404 UM_ZERO(token_buffer, sizeof(token_buffer));
405 UM_ZERO(&yylval, sizeof(yylval));
408 * Handle a character at a time until a token is built
412 * Read a character from the input file.
414 c = (char)getc(cfg_file);
420 printf("token_state: state=%d, char=%c, class=%d, action=%d, next=%d\n",
424 token_state_tbl[char_class][state].action,
425 token_state_tbl[char_class][state].next);
429 * Perform an action based on the state table
431 switch(token_state_tbl[char_class(c)][state].action) {
434 * Ignore the character
439 * Add character to buffer
441 if (strlen(token_buffer) < TOK_MAX_LEN) {
442 token_buffer[strlen(token_buffer)] = c;
447 * Error--print a message and start over
449 scan_error(c, state);
453 * Return special character
459 * Clear the token buffer
461 UM_ZERO(token_buffer, sizeof(token_buffer));
470 * Return character token
475 * Check for reserved words
477 for (i=0; rsvd_word_tbl[i].word; i++) {
478 if (strcasecmp(token_buffer,
479 rsvd_word_tbl[i].word) == 0)
482 if (rsvd_word_tbl[i].word) {
483 return(rsvd_word_tbl[i].token);
487 * Word isn't reserved, return alpha string
489 yylval.tv_alpha = copy_buffer(token_buffer);
494 * Return hex string (ATM address)
497 yylval.tv_hex = copy_buffer(token_buffer);
505 yylval.tv_int = atoi(token_buffer);
515 fprintf(stderr, "Invalid action indicator, state=%d, char=0x%02x\n",
521 * Set the next state and bump to the next character
523 state = token_state_tbl[char_class(c)][state].next;