![[BACK]](/icons/back.gif){kind=icon}
Return to toke.l CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sudo|
Return to toke.l CVS log | Up to [local] / src / usr.bin / sudo |
1.1 millert 1: %{
2: /*
3: * Copyright (c) 1996, 1998-2005, 2007-2008
4: * Todd C. Miller <Todd.Miller@courtesan.com>
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 THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
18: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
19: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
20: *
21: * Sponsored in part by the Defense Advanced Research Projects
22: * Agency (DARPA) and Air Force Research Laboratory, Air Force
23: * Materiel Command, USAF, under agreement number F39502-99-1-0512.
24: */
25:
26: #include <config.h>
27:
28: #include <sys/types.h>
29: #include <sys/param.h>
30: #include <stdio.h>
31: #ifdef STDC_HEADERS
32: # include <stdlib.h>
33: # include <stddef.h>
34: #else
35: # ifdef HAVE_STDLIB_H
36: # include <stdlib.h>
37: # endif
38: #endif /* STDC_HEADERS */
39: #ifdef HAVE_STRING_H
40: # include <string.h>
41: #else
42: # ifdef HAVE_STRINGS_H
43: # include <strings.h>
44: # endif
45: #endif /* HAVE_STRING_H */
46: #ifdef HAVE_UNISTD_H
47: # include <unistd.h>
48: #endif /* HAVE_UNISTD_H */
49: #if defined(HAVE_MALLOC_H) && !defined(STDC_HEADERS)
50: # include <malloc.h>
51: #endif /* HAVE_MALLOC_H && !STDC_HEADERS */
52: #include <ctype.h>
53: #include "sudo.h"
54: #include "parse.h"
55: #include <gram.h>
56:
57: #ifndef lint
1.2 ! millert 58: __unused static const char rcsid[] = "$Sudo: toke.l,v 1.27 2008/11/24 00:41:36 millert Exp $";
1.1 millert 59: #endif /* lint */
60:
61: extern YYSTYPE yylval;
62: int sudolineno = 1;
63: char *sudoers;
64: static int sawspace = 0;
65: static int arg_len = 0;
66: static int arg_size = 0;
67:
68: static int append __P((char *, int));
69: static int _fill __P((char *, int, int));
70: static int fill_cmnd __P((char *, int));
71: static int fill_args __P((char *, int, int));
72: static int switch_buffer __P((char *));
73: static int ipv6_valid __P((const char *s));
74: static char *parse_include __P((char *));
75: extern void yyerror __P((const char *));
76:
77: #define fill(a, b) _fill(a, b, 0)
78:
79: #define push_include(_p) (switch_buffer((_p)))
80: #define pop_include() (switch_buffer(NULL))
81:
82: /* realloc() to size + COMMANDARGINC to make room for command args */
83: #define COMMANDARGINC 64
84:
85: #ifdef TRACELEXER
86: #define LEXTRACE(msg) fputs(msg, stderr)
87: #else
88: #define LEXTRACE(msg)
89: #endif
90: %}
91:
92: HEX16 [0-9A-Fa-f]{1,4}
93: OCTET (1?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5])
94: IPV4ADDR {OCTET}(\.{OCTET}){3}
95: IPV6ADDR ({HEX16}?:){2,7}{HEX16}?|({HEX16}?:){2,6}:{IPV4ADDR}
96:
97: HOSTNAME [[:alnum:]_-]+
98: WORD ([^#>!=:,\(\) \t\n\\]|\\[^\n])+
99: ID #-?[0-9]+
100: PATH \/(\\[\,:= \t#]|[^\,:=\\ \t\n#])+
101: ENVAR ([^#!=, \t\n\\\"]|\\[^\n])([^#=, \t\n\\\"]|\\[^\n])*
102: DEFVAR [a-z_]+
103:
104: %option nounput
105: %option noyywrap
106:
107: %s GOTDEFS
108: %x GOTCMND
109: %x STARTDEFS
110: %x INDEFS
111: %x INSTR
112:
113: %%
114: <GOTDEFS>[[:blank:]]+ BEGIN STARTDEFS;
115:
116: <STARTDEFS>{DEFVAR} {
117: BEGIN INDEFS;
118: LEXTRACE("DEFVAR ");
119: if (!fill(yytext, yyleng))
120: yyterminate();
121: return(DEFVAR);
122: }
123:
124: <INDEFS>{
125: , {
126: BEGIN STARTDEFS;
127: LEXTRACE(", ");
128: return(',');
129: } /* return ',' */
130:
131: = {
132: LEXTRACE("= ");
133: return('=');
134: } /* return '=' */
135:
136: \+= {
137: LEXTRACE("+= ");
138: return('+');
139: } /* return '+' */
140:
141: -= {
142: LEXTRACE("-= ");
143: return('-');
144: } /* return '-' */
145:
146: \" {
147: LEXTRACE("BEGINSTR ");
148: yylval.string = NULL;
149: BEGIN INSTR;
150: }
151:
152: {ENVAR} {
153: LEXTRACE("WORD(2) ");
154: if (!fill(yytext, yyleng))
155: yyterminate();
156: return(WORD);
157: }
158: }
159:
160: <INSTR>{
161: \\[[:blank:]]*\n[[:blank:]]* {
162: /* Line continuation char followed by newline. */
163: ++sudolineno;
164: LEXTRACE("\n");
165: }
166:
167: \" {
168: LEXTRACE("ENDSTR ");
169: BEGIN INDEFS;
170: return(WORD);
171: }
172:
173: \\ {
174: LEXTRACE("BACKSLASH ");
175: if (!append(yytext, yyleng))
176: yyterminate();
177: }
178:
179: ([^\"\n\\]|\\\")+ {
180: LEXTRACE("STRBODY ");
181: if (!append(yytext, yyleng))
182: yyterminate();
183: }
184: }
185:
186: <GOTCMND>{
187: \\[\*\?\[\]\!] {
188: /* quoted fnmatch glob char, pass verbatim */
189: LEXTRACE("QUOTEDCHAR ");
190: if (!fill_args(yytext, 2, sawspace))
191: yyterminate();
192: sawspace = FALSE;
193: }
194:
195: \\[:\\,= \t#] {
196: /* quoted sudoers special char, strip backslash */
197: LEXTRACE("QUOTEDCHAR ");
198: if (!fill_args(yytext + 1, 1, sawspace))
199: yyterminate();
200: sawspace = FALSE;
201: }
202:
203: [#:\,=\n] {
204: BEGIN INITIAL;
205: yyless(0);
206: return(COMMAND);
207: } /* end of command line args */
208:
209: [^\\:, \t\n]+ {
210: LEXTRACE("ARG ");
211: if (!fill_args(yytext, yyleng, sawspace))
212: yyterminate();
213: sawspace = FALSE;
214: } /* a command line arg */
215: }
216:
217: <INITIAL>^#include[[:blank:]]+\/.*\n {
218: char *path;
219:
220: if ((path = parse_include(yytext)) == NULL)
221: yyterminate();
222:
223: LEXTRACE("INCLUDE\n");
224:
225: /* Push current buffer and switch to include file */
226: if (!push_include(path))
227: yyterminate();
228: }
229:
230: <INITIAL>^[[:blank:]]*Defaults([:@>\!]{WORD})? {
231: int n;
232: for (n = 0; isblank((unsigned char)yytext[n]); n++)
233: continue;
234: n += 8;
235: BEGIN GOTDEFS;
236: switch (yytext[n++]) {
237: case ':':
238: yyless(n);
239: LEXTRACE("DEFAULTS_USER ");
240: return(DEFAULTS_USER);
241: case '>':
242: yyless(n);
243: LEXTRACE("DEFAULTS_RUNAS ");
244: return(DEFAULTS_RUNAS);
245: case '@':
246: yyless(n);
247: LEXTRACE("DEFAULTS_HOST ");
248: return(DEFAULTS_HOST);
249: case '!':
250: yyless(n);
251: LEXTRACE("DEFAULTS_CMND ");
252: return(DEFAULTS_CMND);
253: default:
254: LEXTRACE("DEFAULTS ");
255: return(DEFAULTS);
256: }
257: }
258:
259: <INITIAL>^[[:blank:]]*(Host|Cmnd|User|Runas)_Alias {
260: int n;
261: for (n = 0; isblank((unsigned char)yytext[n]); n++)
262: continue;
263: switch (yytext[n]) {
264: case 'H':
265: LEXTRACE("HOSTALIAS ");
266: return(HOSTALIAS);
267: case 'C':
268: LEXTRACE("CMNDALIAS ");
269: return(CMNDALIAS);
270: case 'U':
271: LEXTRACE("USERALIAS ");
272: return(USERALIAS);
273: case 'R':
274: LEXTRACE("RUNASALIAS ");
275: return(RUNASALIAS);
276: }
277: }
278:
279: NOPASSWD[[:blank:]]*: {
280: /* cmnd does not require passwd for this user */
281: LEXTRACE("NOPASSWD ");
282: return(NOPASSWD);
283: }
284:
285: PASSWD[[:blank:]]*: {
286: /* cmnd requires passwd for this user */
287: LEXTRACE("PASSWD ");
288: return(PASSWD);
289: }
290:
291: NOEXEC[[:blank:]]*: {
292: LEXTRACE("NOEXEC ");
293: return(NOEXEC);
294: }
295:
296: EXEC[[:blank:]]*: {
297: LEXTRACE("EXEC ");
298: return(EXEC);
299: }
300:
301: SETENV[[:blank:]]*: {
302: LEXTRACE("SETENV ");
303: return(SETENV);
304: }
305:
306: NOSETENV[[:blank:]]*: {
307: LEXTRACE("NOSETENV ");
308: return(NOSETENV);
309: }
310:
311: \+{WORD} {
312: /* netgroup */
313: if (!fill(yytext, yyleng))
314: yyterminate();
315: LEXTRACE("NETGROUP ");
316: return(NETGROUP);
317: }
318:
319: \%{WORD} {
320: /* UN*X group */
321: if (!fill(yytext, yyleng))
322: yyterminate();
323: LEXTRACE("USERGROUP ");
324: return(USERGROUP);
325: }
326:
327: {IPV4ADDR}(\/{IPV4ADDR})? {
328: if (!fill(yytext, yyleng))
329: yyterminate();
330: LEXTRACE("NTWKADDR ");
331: return(NTWKADDR);
332: }
333:
334: {IPV4ADDR}\/([12][0-9]*|3[0-2]*) {
335: if (!fill(yytext, yyleng))
336: yyterminate();
337: LEXTRACE("NTWKADDR ");
338: return(NTWKADDR);
339: }
340:
341: {IPV6ADDR}(\/{IPV6ADDR})? {
342: if (!ipv6_valid(yytext)) {
343: LEXTRACE("ERROR ");
344: return(ERROR);
345: }
346: if (!fill(yytext, yyleng))
347: yyterminate();
348: LEXTRACE("NTWKADDR ");
349: return(NTWKADDR);
350: }
351:
352: {IPV6ADDR}\/([0-9]|[1-9][0-9]|1[01][0-9]|12[0-8]) {
353: if (!ipv6_valid(yytext)) {
354: LEXTRACE("ERROR ");
355: return(ERROR);
356: }
357: if (!fill(yytext, yyleng))
358: yyterminate();
359: LEXTRACE("NTWKADDR ");
360: return(NTWKADDR);
361: }
362:
363: [[:upper:]][[:upper:][:digit:]_]* {
364: if (strcmp(yytext, "ALL") == 0) {
365: LEXTRACE("ALL ");
366: return(ALL);
367: }
368: #ifdef HAVE_SELINUX
369: /* XXX - restrict type/role to initial state */
370: if (strcmp(yytext, "TYPE") == 0) {
371: LEXTRACE("TYPE ");
372: return(TYPE);
373: }
374: if (strcmp(yytext, "ROLE") == 0) {
375: LEXTRACE("ROLE ");
376: return(ROLE);
377: }
378: #endif /* HAVE_SELINUX */
379: if (!fill(yytext, yyleng))
380: yyterminate();
381: LEXTRACE("ALIAS ");
382: return(ALIAS);
383: }
384:
385: <GOTDEFS>({PATH}|sudoedit) {
386: /* no command args allowed for Defaults!/path */
387: if (!fill_cmnd(yytext, yyleng))
388: yyterminate();
389: LEXTRACE("COMMAND ");
390: return(COMMAND);
391: }
392:
393: sudoedit {
394: BEGIN GOTCMND;
395: LEXTRACE("COMMAND ");
396: if (!fill_cmnd(yytext, yyleng))
397: yyterminate();
398: } /* sudo -e */
399:
400: {PATH} {
401: /* directories can't have args... */
402: if (yytext[yyleng - 1] == '/') {
403: LEXTRACE("COMMAND ");
404: if (!fill_cmnd(yytext, yyleng))
405: yyterminate();
406: return(COMMAND);
407: } else {
408: BEGIN GOTCMND;
409: LEXTRACE("COMMAND ");
410: if (!fill_cmnd(yytext, yyleng))
411: yyterminate();
412: }
413: } /* a pathname */
414:
415: <INITIAL,GOTDEFS>({ID}|{WORD}) {
416: /* a word */
417: if (!fill(yytext, yyleng))
418: yyterminate();
419: LEXTRACE("WORD(4) ");
420: return(WORD);
421: }
422:
423: \( {
424: LEXTRACE("( ");
425: return ('(');
426: }
427:
428: \) {
429: LEXTRACE(") ");
430: return(')');
431: }
432:
433: , {
434: LEXTRACE(", ");
435: return(',');
436: } /* return ',' */
437:
438: = {
439: LEXTRACE("= ");
440: return('=');
441: } /* return '=' */
442:
443: : {
444: LEXTRACE(": ");
445: return(':');
446: } /* return ':' */
447:
448: <*>!+ {
449: if (yyleng % 2 == 1)
450: return('!'); /* return '!' */
451: }
452:
453: <*>\n {
454: BEGIN INITIAL;
455: ++sudolineno;
456: LEXTRACE("\n");
457: return(COMMENT);
458: } /* return newline */
459:
460: <*>[[:blank:]]+ { /* throw away space/tabs */
461: sawspace = TRUE; /* but remember for fill_args */
462: }
463:
464: <*>\\[[:blank:]]*\n {
465: sawspace = TRUE; /* remember for fill_args */
466: ++sudolineno;
467: LEXTRACE("\n\t");
468: } /* throw away EOL after \ */
469:
1.2 ! millert 470: <INITIAL,STARTDEFS,INDEFS>#([^\n0-9-].*)?\n {
1.1 millert 471: BEGIN INITIAL;
472: ++sudolineno;
473: LEXTRACE("\n");
474: return(COMMENT);
475: } /* return comments */
476:
477: <*>. {
478: LEXTRACE("ERROR ");
479: return(ERROR);
480: } /* parse error */
481:
482: <*><<EOF>> {
483: if (YY_START != INITIAL) {
484: BEGIN INITIAL;
485: LEXTRACE("ERROR ");
486: return(ERROR);
487: }
488: if (!pop_include())
489: yyterminate();
490: }
491:
492: %%
493: static int
494: _fill(src, len, olen)
495: char *src;
496: int len, olen;
497: {
498: int i, j;
499: char *dst;
500:
501: dst = olen ? realloc(yylval.string, olen + len + 1) : malloc(len + 1);
502: if (dst == NULL) {
503: yyerror("unable to allocate memory");
504: return(FALSE);
505: }
506: yylval.string = dst;
507:
508: /* Copy the string and collapse any escaped characters. */
509: dst += olen;
510: for (i = 0, j = 0; i < len; i++, j++) {
511: if (src[i] == '\\' && i != len - 1)
512: dst[j] = src[++i];
513: else
514: dst[j] = src[i];
515: }
516: dst[j] = '\0';
517: return(TRUE);
518: }
519:
520: static int
521: append(src, len)
522: char *src;
523: int len;
524: {
525: int olen = 0;
526:
527: if (yylval.string != NULL)
528: olen = strlen(yylval.string);
529:
530: return(_fill(src, len, olen));
531: }
532:
533: #define SPECIAL(c) \
534: ((c) == ',' || (c) == ':' || (c) == '=' || (c) == ' ' || (c) == '\t' || (c) == '#')
535:
536: static int
537: fill_cmnd(src, len)
538: char *src;
539: int len;
540: {
541: char *dst;
542: int i;
543:
544: arg_len = arg_size = 0;
545:
546: dst = yylval.command.cmnd = (char *) malloc(len + 1);
547: if (yylval.command.cmnd == NULL) {
548: yyerror("unable to allocate memory");
549: return(FALSE);
550: }
551:
552: /* Copy the string and collapse any escaped sudo-specific characters. */
553: for (i = 0; i < len; i++) {
554: if (src[i] == '\\' && i != len - 1 && SPECIAL(src[i + 1]))
555: *dst++ = src[++i];
556: else
557: *dst++ = src[i];
558: }
559: *dst = '\0';
560:
561: yylval.command.args = NULL;
562: return(TRUE);
563: }
564:
565: static int
566: fill_args(s, len, addspace)
567: char *s;
568: int len;
569: int addspace;
570: {
571: int new_len;
572: char *p;
573:
574: if (yylval.command.args == NULL) {
575: addspace = 0;
576: new_len = len;
577: } else
578: new_len = arg_len + len + addspace;
579:
580: if (new_len >= arg_size) {
581: /* Allocate more space than we need for subsequent args */
582: while (new_len >= (arg_size += COMMANDARGINC))
583: ;
584:
585: p = yylval.command.args ?
586: (char *) realloc(yylval.command.args, arg_size) :
587: (char *) malloc(arg_size);
588: if (p == NULL) {
589: efree(yylval.command.args);
590: yyerror("unable to allocate memory");
591: return(FALSE);
592: } else
593: yylval.command.args = p;
594: }
595:
596: /* Efficiently append the arg (with a leading space if needed). */
597: p = yylval.command.args + arg_len;
598: if (addspace)
599: *p++ = ' ';
600: if (strlcpy(p, s, arg_size - (p - yylval.command.args)) != len) {
601: yyerror("fill_args: buffer overflow"); /* paranoia */
602: return(FALSE);
603: }
604: arg_len = new_len;
605: return(TRUE);
606: }
607:
608: struct sudoers_state {
609: YY_BUFFER_STATE bs;
610: char *path;
611: int lineno;
612: };
613:
614: #define MAX_SUDOERS_DEPTH 128
615: #define SUDOERS_STACK_INCREMENT 16
616:
617: static int
618: switch_buffer(path)
619: char *path;
620: {
621: static size_t stacksize, depth;
622: static struct sudoers_state *state;
623: static int keepopen;
624: FILE *fp;
625:
626: if (path != NULL) {
627: /* push current state */
628: if (depth >= stacksize) {
629: if (depth > MAX_SUDOERS_DEPTH) {
630: yyerror("too many levels of includes");
631: return(FALSE);
632: }
633: stacksize += SUDOERS_STACK_INCREMENT;
634: state = (struct sudoers_state *) realloc(state,
635: sizeof(state) * stacksize);
636: if (state == NULL) {
637: yyerror("unable to allocate memory");
638: return(FALSE);
639: }
640: }
641: if ((fp = open_sudoers(path, &keepopen)) == NULL) {
642: yyerror(path);
643: return(FALSE);
644: }
645: state[depth].bs = YY_CURRENT_BUFFER;
646: state[depth].path = sudoers;
647: state[depth].lineno = sudolineno;
648: depth++;
649: sudolineno = 1;
650: sudoers = path;
651: yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
652: } else {
653: /* pop */
654: if (depth == 0)
655: return(FALSE);
656: depth--;
657: if (!keepopen)
658: fclose(YY_CURRENT_BUFFER->yy_input_file);
659: yy_delete_buffer(YY_CURRENT_BUFFER);
660: yy_switch_to_buffer(state[depth].bs);
661: efree(sudoers);
662: sudoers = state[depth].path;
663: sudolineno = state[depth].lineno;
664: keepopen = FALSE;
665: }
666: return(TRUE);
667: }
668:
669: static char *
670: parse_include(base)
671: char *base;
672: {
673: char *cp, *ep, *path;
674: int len;
675:
676: /* Pull out path from #include line. */
677: cp = base + sizeof("#include");
678: while (isblank((unsigned char) *cp))
679: cp++;
680: ep = cp;
681: while (*ep != '\0' && !isspace((unsigned char) *ep))
682: ep++;
683:
684: /* Make a copy of path and return it. */
685: len = (int)(ep - cp);
686: if ((path = malloc(len + 1)) == NULL)
687: yyerror("unable to allocate memory");
688: memcpy(path, cp, len);
689: path[len] = '\0';
690:
691: /* Push any excess characters (e.g. comment, newline) back to the lexer */
692: if (*ep != '\0')
693: yyless((int)(ep - base));
694:
695: return(path);
696: }
697:
698: /*
699: * Check to make sure an IPv6 address does not contain multiple instances
700: * of the string "::". Assumes strlen(s) >= 1.
701: * Returns TRUE if address is valid else FALSE.
702: */
703: static int
704: ipv6_valid(s)
705: const char *s;
706: {
707: int nmatch = 0;
708:
709: for (; *s != '\0'; s++) {
710: if (s[0] == ':' && s[1] == ':') {
711: if (++nmatch > 1)
712: break;
713: }
714: if (s[0] == '/')
715: nmatch = 0; /* reset if we hit netmask */
716: }
717:
718: return (nmatch <= 1);
719: }