![[BACK]](/icons/back.gif){kind=icon}
Return to parse.lex CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sudo|
Return to parse.lex CVS log | Up to [local] / src / usr.bin / sudo |
1.1 millert 1: %{
2: /*
3: * Copyright (c) 1996, 1998, 1999 Todd C. Miller <Todd.Miller@courtesan.com>
4: * All rights reserved.
5: *
6: * This code is derived from software contributed by Chris Jepeway
7: * <jepeway@cs.utk.edu>
8: *
9: * This code is derived from software contributed by Chris Jepeway
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: *
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: *
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: *
21: * 3. The name of the author may not be used to endorse or promote products
22: * derived from this software without specific prior written permission.
23: *
24: * 4. Products derived from this software may not be called "Sudo" nor
25: * may "Sudo" appear in their names without specific prior written
26: * permission from the author.
27: *
28: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
29: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
30: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
31: * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
34: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
35: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
36: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
37: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include "config.h"
41:
42: #ifdef STDC_HEADERS
43: #include <stdlib.h>
44: #endif /* STDC_HEADERS */
45: #ifdef HAVE_UNISTD_H
46: #include <unistd.h>
47: #endif /* HAVE_UNISTD_H */
48: #ifdef HAVE_STRING_H
49: #include <string.h>
50: #endif /* HAVE_STRING_H */
51: #ifdef HAVE_STRINGS_H
52: #include <strings.h>
53: #endif /* HAVE_STRINGS_H */
54: #if defined(HAVE_MALLOC_H) && !defined(STDC_HEADERS)
55: #include <malloc.h>
56: #endif /* HAVE_MALLOC_H && !STDC_HEADERS */
57: #include <ctype.h>
58: #include <sys/types.h>
59: #include <sys/param.h>
60: #include "sudo.h"
61: #include "parse.h"
62: #include "sudo.tab.h"
63:
64: #ifndef lint
65: static const char rcsid[] = "$Sudo: parse.lex,v 1.109 1999/11/09 20:06:52 millert Exp $";
66: #endif /* lint */
67:
68: #undef yywrap /* guard against a yywrap macro */
69:
70: extern YYSTYPE yylval;
71: extern int clearaliases;
72: int sudolineno = 1;
73: static int sawspace = 0;
74: static int arg_len = 0;
75: static int arg_size = 0;
76:
77: static void fill __P((char *, int));
78: static void fill_cmnd __P((char *, int));
79: static void fill_args __P((char *, int, int));
80: extern void reset_aliases __P((void));
81: extern void yyerror __P((char *));
82:
83: /* realloc() to size + COMMANDARGINC to make room for command args */
84: #define COMMANDARGINC 64
85:
86: #ifdef TRACELEXER
87: #define LEXTRACE(msg) fputs(msg, stderr)
88: #else
89: #define LEXTRACE(msg)
90: #endif
91: %}
92:
93: OCTET (1?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5])
94: DOTTEDQUAD {OCTET}(\.{OCTET}){3}
95: HOSTNAME [[:alnum:]_-]+
96: WORD ([^@!=:,\(\) \t\n\\]|\\[^\n])+
97:
98: %s GOTCMND
99: %s GOTRUNAS
100: %s GOTDEFS
101:
102: %%
103: [ \t]+ { /* throw away space/tabs */
104: sawspace = TRUE; /* but remember for fill_args */
105: }
106:
107: \\[ \t]*\n {
108: sawspace = TRUE; /* remember for fill_args */
109: ++sudolineno;
110: LEXTRACE("\n\t");
111: } /* throw away EOL after \ */
112:
113: <GOTCMND>\\[:\,=\\ \t] {
114: LEXTRACE("QUOTEDCHAR ");
115: fill_args(yytext + 1, 1, sawspace);
116: sawspace = FALSE;
117: }
118:
119: <GOTDEFS>\"([^\"]|\\\")+\" {
120: LEXTRACE("WORD(1) ");
121: fill(yytext + 1, yyleng - 2);
122: return(WORD);
123: }
124:
125: <GOTDEFS>(#.*)?\n {
126: BEGIN INITIAL;
127: ++sudolineno;
128: LEXTRACE("\n");
129: return(COMMENT);
130: }
131:
132: <GOTCMND>[:\,=\n] {
133: BEGIN INITIAL;
134: unput(*yytext);
135: return(COMMAND);
136: } /* end of command line args */
137:
138: \n {
139: ++sudolineno;
140: LEXTRACE("\n");
141: return(COMMENT);
142: } /* return newline */
143:
144: <INITIAL>#.*\n {
145: ++sudolineno;
146: LEXTRACE("\n");
147: return(COMMENT);
148: } /* return comments */
149:
150: <GOTCMND>[^\\:, \t\n]+ {
151: LEXTRACE("ARG ");
152: fill_args(yytext, yyleng, sawspace);
153: sawspace = FALSE;
154: } /* a command line arg */
155:
156: , {
157: LEXTRACE(", ");
158: return(',');
159: } /* return ',' */
160:
161: !+ {
162: if (yyleng % 2 == 1)
163: return('!'); /* return '!' */
164: }
165:
166: = {
167: LEXTRACE("= ");
168: return('=');
169: } /* return '=' */
170:
171: : {
172: LEXTRACE(": ");
173: return(':');
174: } /* return ':' */
175:
176: NOPASSWD[[:blank:]]*: {
177: /* cmnd does not require passwd for this user */
178: LEXTRACE("NOPASSWD ");
179: return(NOPASSWD);
180: }
181:
182: PASSWD[[:blank:]]*: {
183: /* cmnd requires passwd for this user */
184: LEXTRACE("PASSWD ");
185: return(PASSWD);
186: }
187:
188: \+{WORD} {
189: /* netgroup */
190: fill(yytext, yyleng);
191: LEXTRACE("NETGROUP ");
192: return(NETGROUP);
193: }
194:
195: \%{WORD} {
196: /* UN*X group */
197: fill(yytext, yyleng);
198: LEXTRACE("GROUP ");
199: return(USERGROUP);
200: }
201:
202: {DOTTEDQUAD}(\/{DOTTEDQUAD})? {
203: fill(yytext, yyleng);
204: LEXTRACE("NTWKADDR ");
205: return(NTWKADDR);
206: }
207:
208: {DOTTEDQUAD}\/([12][0-9]*|3[0-2]*) {
209: fill(yytext, yyleng);
210: LEXTRACE("NTWKADDR ");
211: return(NTWKADDR);
212: }
213:
214: [[:alpha:]][[:alnum:]_-]*(\.{HOSTNAME})+ {
215: fill(yytext, yyleng);
216: LEXTRACE("FQHOST ");
217: return(FQHOST);
218: }
219:
220: <INITIAL>\( {
221: BEGIN GOTRUNAS;
222: LEXTRACE("RUNAS ");
223: return (RUNAS);
224: }
225:
226: <GOTRUNAS>[[:upper:]][[:upper:][:digit:]_]* {
227: /* Runas_Alias user can run command as or ALL */
228: if (strcmp(yytext, "ALL") == 0) {
229: LEXTRACE("ALL ");
230: return(ALL);
231: } else {
232: fill(yytext, yyleng);
233: LEXTRACE("ALIAS ");
234: return(ALIAS);
235: }
236: }
237:
238: <GOTRUNAS>#?{WORD} {
239: /* username/uid that user can run command as */
240: fill(yytext, yyleng);
241: LEXTRACE("WORD(2) ");
242: return(WORD);
243: }
244:
245: <GOTRUNAS>\) {
246: BEGIN INITIAL;
247: }
248:
249: [[:upper:]][[:upper:][:digit:]_]* {
250: if (strcmp(yytext, "ALL") == 0) {
251: LEXTRACE("ALL ");
252: return(ALL);
253: } else {
254: fill(yytext, yyleng);
255: LEXTRACE("ALIAS ");
256: return(ALIAS);
257: }
258: }
259:
260: <GOTDEFS>{WORD} {
261: LEXTRACE("WORD(3) ");
262: fill(yytext, yyleng);
263: return(WORD);
264: }
265:
266: <INITIAL>^Defaults[:@]? {
267: BEGIN GOTDEFS;
268: if (yyleng == 9) {
269: switch (yytext[8]) {
270: case ':' :
271: LEXTRACE("DEFAULTS_USER ");
272: return(DEFAULTS_USER);
273: case '@' :
274: LEXTRACE("DEFAULTS_HOST ");
275: return(DEFAULTS_HOST);
276: }
277: } else {
278: LEXTRACE("DEFAULTS ");
279: return(DEFAULTS);
280: }
281: }
282:
283: <INITIAL>^(Host|Cmnd|User|Runas)_Alias {
284: fill(yytext, yyleng);
285: if (*yytext == 'H') {
286: LEXTRACE("HOSTALIAS ");
287: return(HOSTALIAS);
288: }
289: if (*yytext == 'C') {
290: LEXTRACE("CMNDALIAS ");
291: return(CMNDALIAS);
292: }
293: if (*yytext == 'U') {
294: LEXTRACE("USERALIAS ");
295: return(USERALIAS);
296: }
297: if (*yytext == 'R') {
298: LEXTRACE("RUNASALIAS ");
299: return(RUNASALIAS);
300: }
301: }
302:
303: \/[^\,:=\\ \t\n#]+ {
304: /* directories can't have args... */
305: if (yytext[yyleng - 1] == '/') {
306: LEXTRACE("COMMAND ");
307: fill_cmnd(yytext, yyleng);
308: return(COMMAND);
309: } else {
310: BEGIN GOTCMND;
311: LEXTRACE("COMMAND ");
312: fill_cmnd(yytext, yyleng);
313: }
314: } /* a pathname */
315:
316: <INITIAL>{WORD} {
317: /* a word */
318: fill(yytext, yyleng);
319: LEXTRACE("WORD(4) ");
320: return(WORD);
321: }
322:
323: . {
324: LEXTRACE("ERROR ");
325: return(ERROR);
326: } /* parse error */
327:
328: %%
329: static void
330: fill(s, len)
331: char *s;
332: int len;
333: {
334: int i, j;
335:
336: yylval.string = (char *) malloc(len + 1);
337: if (yylval.string == NULL)
338: yyerror("unable to allocate memory");
339:
340: /* Copy the string and collapse any escaped characters. */
341: for (i = 0, j = 0; i < len; i++, j++) {
342: if (s[i] == '\\' && i != len - 1)
343: yylval.string[j] = s[++i];
344: else
345: yylval.string[j] = s[i];
346: }
347: yylval.string[j] = '\0';
348: }
349:
350: static void
351: fill_cmnd(s, len)
352: char *s;
353: int len;
354: {
355: arg_len = arg_size = 0;
356:
357: yylval.command.cmnd = (char *) malloc(len + 1);
358: if (yylval.command.cmnd == NULL)
359: yyerror("unable to allocate memory");
360:
361: /* copy the string and NULL-terminate it */
362: (void) strncpy(yylval.command.cmnd, s, len);
363: yylval.command.cmnd[len] = '\0';
364:
365: yylval.command.args = NULL;
366: }
367:
368: static void
369: fill_args(s, len, addspace)
370: char *s;
371: int len;
372: int addspace;
373: {
374: int new_len;
375: char *p;
376:
377: /*
378: * If first arg, malloc() some room, else if we don't
379: * have enough space realloc() some more.
380: */
381: if (yylval.command.args == NULL) {
382: addspace = 0;
383: new_len = len;
384:
385: while (new_len >= (arg_size += COMMANDARGINC))
386: ;
387:
388: yylval.command.args = (char *) malloc(arg_size);
389: if (yylval.command.args == NULL)
390: yyerror("unable to allocate memory");
391: } else {
392: new_len = arg_len + len + addspace;
393:
394: if (new_len >= arg_size) {
395: /* Allocate more space than we need for subsequent args */
396: while (new_len >= (arg_size += COMMANDARGINC))
397: ;
398:
399: if ((p = (char *) realloc(yylval.command.args, arg_size)) == NULL) {
400: free(yylval.command.args);
401: yyerror("unable to allocate memory");
402: } else
403: yylval.command.args = p;
404: }
405: }
406:
407: /* Efficiently append the arg (with a leading space if needed). */
408: p = yylval.command.args + arg_len;
409: if (addspace)
410: *p++ = ' ';
411: (void) strcpy(p, s);
412: arg_len = new_len;
413: }
414:
415: int
416: yywrap()
417: {
418:
419: /* Free space used by the aliases unless called by testsudoers. */
420: if (clearaliases)
421: reset_aliases();
422:
423: return(TRUE);
424: }