![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kparse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / krb|
Return to kparse.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / krb |
1.1 root 1: /*
2: * $Source: /mit/kerberos/src/lib/krb/RCS/kparse.c,v $
3: * $Author: jtkohl $
4: *
5: * Copyright 1988 by the Massachusetts Institute of Technology.
6: *
7: * For copying and distribution information, please see the file
8: * <mit-copyright.h>.
9: *
10: * Purpose:
11: * This module was developed to parse the "~/.klogin" files for
12: * Kerberos-authenticated rlogin/rcp/rsh services. However, it is
13: * general purpose and can be used to parse any such parameter file.
14: *
15: * The parameter file should consist of one or more entries, with each
16: * entry on a separate line and consisting of zero or more
17: * "keyword=value" combinations. The keyword is case insensitive, but
18: * the value is not. Any string may be enclosed in quotes, and
19: * c-style "\" literals are supported. A comma may be used to
20: * separate the k/v combinations, and multiple commas are ignored.
21: * Whitespace (blank or tab) may be used freely and is ignored.
22: *
23: * Full error processing is available. When PS_BAD_KEYWORD or
24: * PS_SYNTAX is returned from fGetParameterSet(), the string ErrorMsg
25: * contains a meaningful error message.
26: *
27: * Keywords and their default values are programmed by an external
28: * table.
29: *
30: * Routines:
31: * fGetParameterSet() parse one line of the parameter file
32: * fGetKeywordValue() parse one "keyword=value" combo
33: * fGetToken() parse one token
34: */
35:
36: #ifndef lint
37: static char rcsid_kparse_c[] =
38: "$Header: kparse.c,v 4.5 89/01/21 17:20:39 jtkohl Exp $";
39: #endif lint
40:
41: #include <mit-copyright.h>
42: #include <stdio.h>
43: #include <ctype.h>
44: #include <kparse.h>
45:
46: #ifndef FALSE
47: #define FALSE 0
48: #define TRUE 1
49: #endif
50:
51: #define void int
52:
53: #define MAXKEY 80
54: #define MAXVALUE 80
55:
56: char *malloc();
57: char *strcpy();
58:
59: int LineNbr=1; /* current line nbr in parameter file */
60: char ErrorMsg[80]; /* meaningful only when KV_SYNTAX, PS_SYNTAX,
61: * or PS_BAD_KEYWORD is returned by
62: * fGetKeywordValue or fGetParameterSet */
63:
64: int fGetParameterSet( fp,parm,parmcount )
65: FILE *fp;
66: parmtable parm[];
67: int parmcount;
68: {
69: int rc,i;
70: char keyword[MAXKEY];
71: char value[MAXVALUE];
72:
73: while (TRUE) {
74: rc=fGetKeywordValue(fp,keyword,MAXKEY,value,MAXVALUE);
75:
76: switch (rc) {
77:
78: case KV_EOF:
79: return(PS_EOF);
80:
81: case KV_EOL:
82: return(PS_OKAY);
83:
84: case KV_SYNTAX:
85: return(PS_SYNTAX);
86:
87: case KV_OKAY:
88: /*
89: * got a reasonable keyword/value pair. Search the
90: * parameter table to see if we recognize the keyword; if
91: * not, return an error. If we DO recognize it, make sure
92: * it has not already been given. If not already given,
93: * save the value.
94: */
95: for (i=0; i<parmcount; i++) {
96: if (strcmp(strutol(keyword),parm[i].keyword)==0) {
97: if (parm[i].value) {
98: sprintf(ErrorMsg,"duplicate keyword \"%s\" found",
99: keyword);
100: return(PS_BAD_KEYWORD);
101: }
102: parm[i].value = strsave( value );
103: break;
104: }
105: }
106: if (i >= parmcount) {
107: sprintf(ErrorMsg, "unrecognized keyword \"%s\" found",
108: keyword);
109: return(PS_BAD_KEYWORD);
110: }
111: break;
112:
113: default:
114: sprintf(ErrorMsg,
115: "panic: bad return (%d) from fGetToken()",rc);
116: break;
117: }
118: }
119: }
120:
121: /*
122: * Routine: ParmCompare
123: *
124: * Purpose:
125: * ParmCompare checks a specified value for a particular keyword.
126: * fails if keyword not found or keyword found but the value was
127: * different. Like strcmp, ParmCompare returns 0 for a match found, -1
128: * otherwise
129: */
130: int ParmCompare( parm, parmcount, keyword, value )
131: parmtable parm[];
132: int parmcount;
133: char *keyword;
134: char *value;
135: {
136: int i;
137:
138: for (i=0; i<parmcount; i++) {
139: if (strcmp(parm[i].keyword,keyword)==0) {
140: if (parm[i].value) {
141: return(strcmp(parm[i].value,value));
142: } else {
143: return(strcmp(parm[i].defvalue,value));
144: }
145: }
146: }
147: return(-1);
148: }
149:
150: void FreeParameterSet(parm,parmcount)
151: parmtable parm[];
152: int parmcount;
153: {
154: int i;
155:
156: for (i=0; i<parmcount; i++) {
157: if (parm[i].value) {
158: free(parm[i].value);
159: parm[i].value = (char *)NULL;
160: }
161: }
162: }
163:
164: int fGetKeywordValue( fp, keyword, klen, value, vlen )
165: FILE *fp;
166: char *keyword;
167: int klen;
168: char *value;
169: int vlen;
170: {
171: int rc;
172: int gotit;
173:
174: *keyword = *value = '\0'; /* preset strings to NULL */
175:
176: /*
177: * Looking for a keyword.
178: * return an exception for EOF or BAD_QSTRING
179: * ignore leading WHITEspace
180: * ignore any number of leading commas
181: * newline means we have all the parms for this
182: * statement; give an indication that there is
183: * nothing more on this line.
184: * stop looking if we find QSTRING, STRING, or NUMBER
185: * return syntax error for any other PUNKtuation
186: */
187: gotit = FALSE;
188: do {
189: rc = fGetToken(fp,keyword,klen);
190:
191: switch (rc) {
192:
193: case GTOK_WHITE:
194: break;
195:
196: case GTOK_EOF:
197: return(KV_EOF);
198:
199: case GTOK_BAD_QSTRING:
200: sprintf(ErrorMsg,"unterminated string \"%s found",keyword);
201: return(KV_SYNTAX);
202:
203: case GTOK_PUNK:
204: if (strcmp("\n",keyword)==0) {
205: return(KV_EOL);
206: } else if (strcmp(",",keyword)!=0) {
207: sprintf(ErrorMsg,"expecting rvalue, found \'%s\'",keyword);
208: }
209: break;
210:
211: case GTOK_STRING:
212: case GTOK_QSTRING:
213: case GTOK_NUMBER:
214: gotit = TRUE;
215: break;
216:
217: default:
218: sprintf(ErrorMsg,"panic: bad return (%d) from fGetToken()",rc);
219: return(KV_SYNTAX);
220: }
221:
222: } while (!gotit);
223:
224: /*
225: * now we expect an equal sign.
226: * skip any whitespace
227: * stop looking if we find an equal sign
228: * anything else causes a syntax error
229: */
230: gotit = FALSE;
231: do {
232: rc = fGetToken(fp,value,vlen);
233:
234: switch (rc) {
235:
236: case GTOK_WHITE:
237: break;
238:
239: case GTOK_BAD_QSTRING:
240: sprintf(ErrorMsg,
241: "expecting \'=\', found unterminated string \"%s",
242: value);
243: return(KV_SYNTAX);
244:
245: case GTOK_PUNK:
246: if (strcmp("=",value)==0) {
247: gotit = TRUE;
248: } else {
249: if (strcmp("\n",value)==0) {
250: sprintf(ErrorMsg,"expecting \"=\", found newline");
251: fUngetChar('\n',fp);
252: } else {
253: sprintf(ErrorMsg,
254: "expecting rvalue, found \'%s\'",keyword);
255: }
256: return(KV_SYNTAX);
257: }
258: break;
259:
260: case GTOK_STRING:
261: case GTOK_QSTRING:
262: case GTOK_NUMBER:
263: sprintf(ErrorMsg,"expecting \'=\', found \"%s\"",value);
264: return(KV_SYNTAX);
265:
266: case GTOK_EOF:
267: sprintf(ErrorMsg,"expecting \'=\', found EOF");
268: return(KV_SYNTAX);
269:
270: default:
271: sprintf(ErrorMsg,
272: "panic: bad return (%d) from fGetToken()",rc);
273: return(KV_SYNTAX);
274: }
275:
276: } while ( !gotit );
277:
278: /*
279: * got the keyword and equal sign, now get a value.
280: * ignore any whitespace
281: * any punctuation is a syntax error
282: */
283: gotit = FALSE;
284: do {
285: rc = fGetToken(fp,value,vlen);
286:
287: switch (rc) {
288:
289: case GTOK_WHITE:
290: break;
291:
292: case GTOK_EOF:
293: sprintf(ErrorMsg,"expecting rvalue, found EOF");
294: return(KV_SYNTAX);
295:
296: case GTOK_BAD_QSTRING:
297: sprintf(ErrorMsg,"unterminated quoted string \"%s",value);
298: return(KV_SYNTAX);
299:
300: case GTOK_PUNK:
301: if (strcmp("\n",value)==0) {
302: sprintf(ErrorMsg,"expecting rvalue, found newline");
303: fUngetChar('\n',fp);
304: } else {
305: sprintf(ErrorMsg,
306: "expecting rvalue, found \'%s\'",value);
307: }
308: return(KV_SYNTAX);
309: break;
310:
311: case GTOK_STRING:
312: case GTOK_QSTRING:
313: case GTOK_NUMBER:
314: gotit = TRUE;
315: return(KV_OKAY);
316:
317: default:
318: sprintf(ErrorMsg,
319: "panic: bad return (%d) from fGetToken()",rc);
320: return(KV_SYNTAX);
321: }
322:
323: } while ( !gotit );
324: /*NOTREACHED*/
325: }
326:
327: /*
328: * Routine Name: fGetToken
329: *
330: * Function: read the next token from the specified file.
331: * A token is defined as a group of characters
332: * terminated by a white space char (SPACE, CR,
333: * LF, FF, TAB). The token returned is stripped of
334: * both leading and trailing white space, and is
335: * terminated by a NULL terminator. An alternate
336: * definition of a token is a string enclosed in
337: * single or double quotes.
338: *
339: * Explicit Parameters:
340: * fp pointer to the input FILE
341: * dest pointer to destination buffer
342: * maxlen length of the destination buffer. The buffer
343: * length INCLUDES the NULL terminator.
344: *
345: * Implicit Parameters: stderr where the "token too long" message goes
346: *
347: * External Procedures: fgetc
348: *
349: * Side Effects: None
350: *
351: * Return Value: A token classification value, as
352: * defined in kparse.h. Note that the
353: * classification for end of file is
354: * always zero.
355: */
356: int fGetToken(fp, dest, maxlen)
357: FILE *fp;
358: char *dest;
359: int maxlen;
360: {
361: int ch='\0';
362: int len=0;
363: char *p = dest;
364: int digits;
365:
366: ch=fGetChar(fp);
367:
368: /*
369: * check for a quoted string. If found, take all characters
370: * that fit until a closing quote is found. Note that this
371: * algorithm will not behave well for a string which is too long.
372: */
373: if (ISQUOTE(ch)) {
374: int done = FALSE;
375: do {
376: ch = fGetChar(fp);
377: done = ((maxlen<++len)||ISLINEFEED(ch)||(ch==EOF)
378: ||ISQUOTE(ch));
379: if (ch=='\\')
380: ch = fGetLiteral(fp);
381: if (!done)
382: *p++ = ch;
383: else if ((ch!=EOF) && !ISQUOTE(ch))
384: fUngetChar(ch,fp);
385: } while (!done);
386: *p = '\0';
387: if (ISLINEFEED(ch)) return(GTOK_BAD_QSTRING);
388: return(GTOK_QSTRING);
389: }
390:
391: /*
392: * Not a quoted string. If its a token character (rules are
393: * defined via the ISTOKENCHAR macro, in kparse.h) take it and all
394: * token chars following it until we run out of space.
395: */
396: digits=TRUE;
397: if (ISTOKENCHAR(ch)) {
398: while ( (ISTOKENCHAR(ch)) && len<maxlen-1 ) {
399: if (!isdigit(ch)) digits=FALSE;
400: *p++ = ch;
401: len++;
402: ch = fGetChar(fp);
403: };
404: *p = '\0';
405:
406: if (ch!=EOF) {
407: fUngetChar(ch,fp);
408: }
409: if (digits) {
410: return(GTOK_NUMBER);
411: } else {
412: return(GTOK_STRING);
413: }
414: }
415:
416: /*
417: * Neither a quoted string nor a token character. Return a string
418: * with just that one character in it.
419: */
420: if (ch==EOF) {
421: return(GTOK_EOF);
422: }
423: if (!ISWHITESPACE(ch)) {
424: *p++ = ch;
425: *p='\0';
426: } else {
427: *p++ = ' '; /* white space is always the
428: * blank character */
429: *p='\0';
430: /*
431: * The character is a white space. Flush all additional white
432: * space.
433: */
434: while (ISWHITESPACE(ch) && ((ch=fGetChar(fp)) != EOF))
435: ;
436: if (ch!=EOF) {
437: fUngetChar(ch,fp);
438: }
439: return(GTOK_WHITE);
440: }
441: return(GTOK_PUNK);
442: }
443:
444: /*
445: * fGetLiteral is called after we find a '\' in the input stream. A
446: * string of numbers following the backslash are converted to the
447: * appropriate value; hex (0xn), octal (0n), and decimal (otherwise)
448: * are all supported. If the char after the \ is not a number, we
449: * special case certain values (\n, \f, \r, \b) or return a literal
450: * otherwise (useful for \", for example).
451: */
452: fGetLiteral(fp)
453: FILE *fp;
454: {
455: int ch;
456: int n=0;
457: int base;
458:
459: ch = fGetChar(fp);
460:
461: if (!isdigit(ch)) {
462: switch (ch) {
463: case 'n': return('\n');
464: case 'f': return('\f');
465: case 'r': return('\r');
466: case 'b': return('\b');
467: default: return(ch);
468: }
469: }
470:
471: /*
472: * got a number. might be decimal (no prefix), octal (prefix 0),
473: * or hexadecimal (prefix 0x). Set the base appropriately.
474: */
475: if (ch!='0') {
476: base=10; /* its a decimal number */
477: } else {
478: /*
479: * found a zero, its either hex or octal
480: */
481: ch = fGetChar(fp);
482: if ((ch!='x') && (ch!='X')) {
483: base=010;
484: } else {
485: ch = fGetChar(fp);
486: base=0x10;
487: }
488: }
489:
490: switch (base) {
491:
492: case 010: /* octal */
493: while (ISOCTAL(ch)) {
494: n = (n*base) + ch - '0';
495: ch = fGetChar(fp);
496: }
497: break;
498:
499: case 10: /* decimal */
500: while (isdigit(ch)) {
501: n = (n*base) + ch - '0';
502: ch = fGetChar(fp);
503: }
504: break;
505: case 0x10: /* hexadecimal */
506: while (isxdigit(ch)) {
507: if (isdigit(ch)) {
508: n = (n*base) + ch - '0';
509: } else {
510: n = (n*base) + toupper(ch) - 'A' + 0xA ;
511: }
512: ch = fGetChar(fp);
513: }
514: break;
515: default:
516: fprintf(stderr,"fGetLiteral() died real bad. Fix gettoken.c.");
517: exit(1);
518: break;
519: }
520: fUngetChar(ch,fp);
521: return(n);
522: }
523:
524: /*
525: * exactly the same as ungetc(3) except that the line number of the
526: * input file is maintained.
527: */
528: fUngetChar(ch,fp)
529: int ch;
530: FILE *fp;
531: {
532: if (ch=='\n') LineNbr--;
533: return(ungetc(ch,fp));
534: }
535:
536:
537: /*
538: * exactly the same as fgetc(3) except that the line number of the
539: * input file is maintained.
540: */
541: fGetChar(fp)
542: FILE *fp;
543: {
544: int ch = fgetc(fp);
545: if (ch=='\n') LineNbr++;
546: return(ch);
547: }
548:
549:
550: /*
551: * Routine Name: strsave
552: *
553: * Function: return a pointer to a saved copy of the
554: * input string. the copy will be allocated
555: * as large as necessary.
556: *
557: * Explicit Parameters: pointer to string to save
558: *
559: * Implicit Parameters: None
560: *
561: * External Procedures: malloc,strcpy,strlen
562: *
563: * Side Effects: None
564: *
565: * Return Value: pointer to copied string
566: *
567: */
568: char * strsave(p)
569: char *p;
570: {
571: return(strcpy(malloc(strlen(p)+1),p));
572: }
573:
574:
575: /*
576: * strutol changes all characters in a string to lower case, in place.
577: * the pointer to the beginning of the string is returned.
578: */
579:
580: char * strutol( start )
581: char *start;
582: {
583: char *q;
584: for (q=start; *q; q++)
585: if (isupper(*q))
586: *q=tolower(*q);
587: return(start);
588: }
589:
590: #ifdef GTOK_TEST /* mainline test routine for fGetToken() */
591:
592: #define MAXTOKEN 100
593:
594: char *pgm = "gettoken";
595:
596: main(argc,argv)
597: int argc;
598: char **argv;
599: {
600: char *p;
601: int type;
602: FILE *fp;
603:
604: if (--argc) {
605: fp = fopen(*++argv,"ra");
606: if (fp == (FILE *)NULL) {
607: fprintf(stderr,"can\'t open \"%s\"\n",*argv);
608: }
609: } else
610: fp = stdin;
611:
612: p = malloc(MAXTOKEN);
613: while (type = fGetToken(fp,p,MAXTOKEN)) {
614: switch(type) {
615: case GTOK_BAD_QSTRING:
616: printf("BAD QSTRING!\t");
617: break;
618: case GTOK_EOF:
619: printf("EOF!\t");
620: break;
621: case GTOK_QSTRING:
622: printf("QSTRING\t");
623: break;
624: case GTOK_STRING:
625: printf("STRING\t");
626: break;
627: case GTOK_NUMBER:
628: printf("NUMBER\t");
629: break;
630: case GTOK_PUNK:
631: printf("PUNK\t");
632: break;
633: case GTOK_WHITE:
634: printf("WHITE\t");
635: break;
636: default:
637: printf("HUH?\t");
638: break;
639: }
640: if (*p=='\n')
641: printf("\\n\n");
642: else
643: printf("%s\n",p);
644: }
645: exit(0);
646: }
647: #endif
648:
649: #ifdef KVTEST
650:
651: main(argc,argv)
652: int argc;
653: char **argv;
654: {
655: int rc,ch;
656: FILE *fp;
657: char key[MAXKEY],valu[MAXVALUE];
658: char *filename;
659:
660: if (argc != 2) {
661: fprintf(stderr,"usage: test <filename>\n");
662: exit(1);
663: }
664:
665: if (!(fp=fopen(*++argv,"r"))) {
666: fprintf(stderr,"can\'t open input file \"%s\"\n",filename);
667: exit(1);
668: }
669: filename = *argv;
670:
671: while ((rc=fGetKeywordValue(fp,key,MAXKEY,valu,MAXVALUE))!=KV_EOF){
672:
673: switch (rc) {
674:
675: case KV_EOL:
676: printf("%s, line %d: nada mas.\n",filename,LineNbr-1);
677: break;
678:
679: case KV_SYNTAX:
680: printf("%s, line %d: syntax error: %s\n",
681: filename,LineNbr,ErrorMsg);
682: while ( ((ch=fGetChar(fp))!=EOF) && (ch!='\n') );
683: break;
684:
685: case KV_OKAY:
686: printf("%s, line %d: okay, %s=\"%s\"\n",
687: filename,LineNbr,key,valu);
688: break;
689:
690: default:
691: printf("panic: bad return (%d) from fGetKeywordValue\n",rc);
692: break;
693: }
694: }
695: printf("EOF");
696: fclose(fp);
697: exit(0);
698: }
699: #endif
700:
701: #ifdef PSTEST
702:
703: parmtable kparm[] = {
704: /* keyword, default, found value */
705: { "user", "", (char *)NULL },
706: { "realm", "Athena", (char *)NULL },
707: { "instance", "", (char *)NULL }
708: };
709:
710: main(argc,argv)
711: int argc;
712: char **argv;
713: {
714: int rc,i,ch;
715: FILE *fp;
716: char *filename;
717:
718: if (argc != 2) {
719: fprintf(stderr,"usage: test <filename>\n");
720: exit(1);
721: }
722:
723: if (!(fp=fopen(*++argv,"r"))) {
724: fprintf(stderr,"can\'t open input file \"%s\"\n",filename);
725: exit(1);
726: }
727: filename = *argv;
728:
729: while ((rc=fGetParameterSet(fp,kparm,PARMCOUNT(kparm))) != PS_EOF) {
730:
731: switch (rc) {
732:
733: case PS_BAD_KEYWORD:
734: printf("%s, line %d: %s\n",filename,LineNbr,ErrorMsg);
735: while ( ((ch=fGetChar(fp))!=EOF) && (ch!='\n') );
736: break;
737:
738: case PS_SYNTAX:
739: printf("%s, line %d: syntax error: %s\n",
740: filename,LineNbr,ErrorMsg);
741: while ( ((ch=fGetChar(fp))!=EOF) && (ch!='\n') );
742: break;
743:
744: case PS_OKAY:
745: printf("%s, line %d: valid parameter set found:\n",
746: filename,LineNbr-1);
747: for (i=0; i<PARMCOUNT(kparm); i++) {
748: printf("\t%s = \"%s\"\n",kparm[i].keyword,
749: (kparm[i].value ? kparm[i].value
750: : kparm[i].defvalue));
751: }
752: break;
753:
754: default:
755: printf("panic: bad return (%d) from fGetParameterSet\n",rc);
756: break;
757: }
758: FreeParameterSet(kparm,PARMCOUNT(kparm));
759: }
760: printf("EOF");
761: fclose(fp);
762: exit(0);
763: }
764: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.