version 1.1.1.4, 2013/07/22 10:46:12
|
version 1.1.1.5, 2014/06/15 16:12:54
|
Line 109
|
Line 109
|
/* |
/* |
* Globals |
* Globals |
*/ |
*/ |
extern int sudolineno; |
|
extern int last_token; |
|
extern char *sudoers; |
|
bool sudoers_warnings = true; |
bool sudoers_warnings = true; |
bool parse_error = false; |
bool parse_error = false; |
int errorlineno = -1; |
int errorlineno = -1; |
char *errorfile = NULL; | const char *errorfile = NULL; |
|
|
struct defaults_list defaults; | struct defaults_list defaults = TAILQ_HEAD_INITIALIZER(defaults); |
struct userspec_list userspecs; | struct userspec_list userspecs = TAILQ_HEAD_INITIALIZER(userspecs); |
|
|
/* |
/* |
* Local protoypes |
* Local protoypes |
Line 128 static void add_userspec(struct member *, struct priv
|
Line 125 static void add_userspec(struct member *, struct priv
|
static struct defaults *new_default(char *, char *, int); |
static struct defaults *new_default(char *, char *, int); |
static struct member *new_member(char *, int); |
static struct member *new_member(char *, int); |
static struct sudo_digest *new_digest(int, const char *); |
static struct sudo_digest *new_digest(int, const char *); |
#line 95 "gram.y" | #line 92 "gram.y" |
#ifndef YYSTYPE_DEFINED |
#ifndef YYSTYPE_DEFINED |
#define YYSTYPE_DEFINED |
#define YYSTYPE_DEFINED |
typedef union { |
typedef union { |
Line 146 typedef union {
|
Line 143 typedef union {
|
int tok; |
int tok; |
} YYSTYPE; |
} YYSTYPE; |
#endif /* YYSTYPE_DEFINED */ |
#endif /* YYSTYPE_DEFINED */ |
#line 149 "gram.c" | #line 146 "gram.c" |
#define COMMAND 257 |
#define COMMAND 257 |
#define ALIAS 258 |
#define ALIAS 258 |
#define DEFVAR 259 |
#define DEFVAR 259 |
Line 698 YYSTYPE yylval;
|
Line 695 YYSTYPE yylval;
|
short *yyss; |
short *yyss; |
short *yysslim; |
short *yysslim; |
YYSTYPE *yyvs; |
YYSTYPE *yyvs; |
int yystacksize; | unsigned int yystacksize; |
#line 681 "gram.y" | #line 685 "gram.y" |
void |
void |
sudoerserror(const char *s) |
sudoerserror(const char *s) |
{ |
{ |
Line 741 new_default(char *var, char *val, int op)
|
Line 738 new_default(char *var, char *val, int op)
|
d = ecalloc(1, sizeof(struct defaults)); |
d = ecalloc(1, sizeof(struct defaults)); |
d->var = var; |
d->var = var; |
d->val = val; |
d->val = val; |
tq_init(&d->binding); |
|
/* d->type = 0; */ |
/* d->type = 0; */ |
d->op = op; |
d->op = op; |
d->prev = d; | /* d->binding = NULL */ |
/* d->next = NULL; */ | HLTQ_INIT(d, entries); |
|
|
debug_return_ptr(d); |
debug_return_ptr(d); |
} |
} |
Line 759 new_member(char *name, int type)
|
Line 755 new_member(char *name, int type)
|
m = ecalloc(1, sizeof(struct member)); |
m = ecalloc(1, sizeof(struct member)); |
m->name = name; |
m->name = name; |
m->type = type; |
m->type = type; |
m->prev = m; | HLTQ_INIT(m, entries); |
/* m->next = NULL; */ | |
|
|
debug_return_ptr(m); |
debug_return_ptr(m); |
} |
} |
Line 787 static void
|
Line 782 static void
|
add_defaults(int type, struct member *bmem, struct defaults *defs) |
add_defaults(int type, struct member *bmem, struct defaults *defs) |
{ |
{ |
struct defaults *d; |
struct defaults *d; |
struct member_list binding; | struct member_list *binding; |
debug_decl(add_defaults, SUDO_DEBUG_PARSER) |
debug_decl(add_defaults, SUDO_DEBUG_PARSER) |
|
|
/* | if (defs != NULL) { |
* We can only call list2tq once on bmem as it will zero | /* |
* out the prev pointer when it consumes bmem. | * We use a single binding for each entry in defs. |
*/ | */ |
list2tq(&binding, bmem); | binding = emalloc(sizeof(*binding)); |
| if (bmem != NULL) |
| HLTQ_TO_TAILQ(binding, bmem, entries); |
| else |
| TAILQ_INIT(binding); |
|
|
/* | /* |
* Set type and binding (who it applies to) for new entries. | * Set type and binding (who it applies to) for new entries. |
*/ | * Then add to the global defaults list. |
for (d = defs; d != NULL; d = d->next) { | */ |
d->type = type; | HLTQ_FOREACH(d, defs, entries) { |
d->binding = binding; | d->type = type; |
| d->binding = binding; |
| } |
| TAILQ_CONCAT_HLTQ(&defaults, defs, entries); |
} |
} |
tq_append(&defaults, defs); |
|
|
|
debug_return; |
debug_return; |
} |
} |
|
|
/* |
/* |
* Allocate a new struct userspec, populate it, and insert it at the |
* Allocate a new struct userspec, populate it, and insert it at the |
* and of the userspecs list. | * end of the userspecs list. |
*/ |
*/ |
static void |
static void |
add_userspec(struct member *members, struct privilege *privs) |
add_userspec(struct member *members, struct privilege *privs) |
Line 819 add_userspec(struct member *members, struct privilege
|
Line 820 add_userspec(struct member *members, struct privilege
|
debug_decl(add_userspec, SUDO_DEBUG_PARSER) |
debug_decl(add_userspec, SUDO_DEBUG_PARSER) |
|
|
u = ecalloc(1, sizeof(*u)); |
u = ecalloc(1, sizeof(*u)); |
list2tq(&u->users, members); | HLTQ_TO_TAILQ(&u->users, members, entries); |
list2tq(&u->privileges, privs); | HLTQ_TO_TAILQ(&u->privileges, privs, entries); |
u->prev = u; | TAILQ_INSERT_TAIL(&userspecs, u, entries); |
/* u->next = NULL; */ | |
tq_append(&userspecs, u); | |
|
|
debug_return; |
debug_return; |
} |
} |
Line 835 add_userspec(struct member *members, struct privilege
|
Line 834 add_userspec(struct member *members, struct privilege
|
void |
void |
init_parser(const char *path, bool quiet) |
init_parser(const char *path, bool quiet) |
{ |
{ |
struct defaults *d; | struct member_list *binding; |
struct member *m, *binding; | struct defaults *d, *d_next; |
struct userspec *us; | struct userspec *us, *us_next; |
struct privilege *priv; | |
struct cmndspec *cs; | |
struct sudo_command *c; | |
debug_decl(init_parser, SUDO_DEBUG_PARSER) |
debug_decl(init_parser, SUDO_DEBUG_PARSER) |
|
|
while ((us = tq_pop(&userspecs)) != NULL) { | TAILQ_FOREACH_SAFE(us, &userspecs, entries, us_next) { |
while ((m = tq_pop(&us->users)) != NULL) { | struct member *m, *m_next; |
| struct privilege *priv, *priv_next; |
| |
| TAILQ_FOREACH_SAFE(m, &us->users, entries, m_next) { |
efree(m->name); |
efree(m->name); |
efree(m); |
efree(m); |
} |
} |
while ((priv = tq_pop(&us->privileges)) != NULL) { | TAILQ_FOREACH_SAFE(priv, &us->privileges, entries, priv_next) { |
struct member *runasuser = NULL, *runasgroup = NULL; | struct member_list *runasuserlist = NULL, *runasgrouplist = NULL; |
| struct cmndspec *cs, *cs_next; |
#ifdef HAVE_SELINUX |
#ifdef HAVE_SELINUX |
char *role = NULL, *type = NULL; |
char *role = NULL, *type = NULL; |
#endif /* HAVE_SELINUX */ |
#endif /* HAVE_SELINUX */ |
Line 857 init_parser(const char *path, bool quiet)
|
Line 857 init_parser(const char *path, bool quiet)
|
char *privs = NULL, *limitprivs = NULL; |
char *privs = NULL, *limitprivs = NULL; |
#endif /* HAVE_PRIV_SET */ |
#endif /* HAVE_PRIV_SET */ |
|
|
while ((m = tq_pop(&priv->hostlist)) != NULL) { | TAILQ_FOREACH_SAFE(m, &priv->hostlist, entries, m_next) { |
efree(m->name); |
efree(m->name); |
efree(m); |
efree(m); |
} |
} |
while ((cs = tq_pop(&priv->cmndlist)) != NULL) { | TAILQ_FOREACH_SAFE(cs, &priv->cmndlist, entries, cs_next) { |
#ifdef HAVE_SELINUX |
#ifdef HAVE_SELINUX |
/* Only free the first instance of a role/type. */ |
/* Only free the first instance of a role/type. */ |
if (cs->role != role) { |
if (cs->role != role) { |
Line 884 init_parser(const char *path, bool quiet)
|
Line 884 init_parser(const char *path, bool quiet)
|
efree(cs->limitprivs); |
efree(cs->limitprivs); |
} |
} |
#endif /* HAVE_PRIV_SET */ |
#endif /* HAVE_PRIV_SET */ |
if (tq_last(&cs->runasuserlist) != runasuser) { | /* Only free the first instance of runas user/group lists. */ |
runasuser = tq_last(&cs->runasuserlist); | if (cs->runasuserlist && cs->runasuserlist != runasuserlist) { |
while ((m = tq_pop(&cs->runasuserlist)) != NULL) { | runasuserlist = cs->runasuserlist; |
| TAILQ_FOREACH_SAFE(m, runasuserlist, entries, m_next) { |
efree(m->name); |
efree(m->name); |
efree(m); |
efree(m); |
} |
} |
|
efree(runasuserlist); |
} |
} |
if (tq_last(&cs->runasgrouplist) != runasgroup) { | if (cs->runasgrouplist && cs->runasgrouplist != runasgrouplist) { |
runasgroup = tq_last(&cs->runasgrouplist); | runasgrouplist = cs->runasgrouplist; |
while ((m = tq_pop(&cs->runasgrouplist)) != NULL) { | TAILQ_FOREACH_SAFE(m, runasgrouplist, entries, m_next) { |
efree(m->name); |
efree(m->name); |
efree(m); |
efree(m); |
} |
} |
|
efree(runasgrouplist); |
} |
} |
if (cs->cmnd->type == COMMAND) { |
if (cs->cmnd->type == COMMAND) { |
c = (struct sudo_command *) cs->cmnd->name; | struct sudo_command *c = |
| (struct sudo_command *) cs->cmnd->name; |
efree(c->cmnd); |
efree(c->cmnd); |
efree(c->args); |
efree(c->args); |
} |
} |
Line 911 init_parser(const char *path, bool quiet)
|
Line 915 init_parser(const char *path, bool quiet)
|
} |
} |
efree(us); |
efree(us); |
} |
} |
tq_init(&userspecs); | TAILQ_INIT(&userspecs); |
|
|
binding = NULL; |
binding = NULL; |
while ((d = tq_pop(&defaults)) != NULL) { | TAILQ_FOREACH_SAFE(d, &defaults, entries, d_next) { |
if (tq_last(&d->binding) != binding) { | if (d->binding != binding) { |
binding = tq_last(&d->binding); | struct member *m, *m_next; |
while ((m = tq_pop(&d->binding)) != NULL) { | |
| binding = d->binding; |
| TAILQ_FOREACH_SAFE(m, d->binding, entries, m_next) { |
if (m->type == COMMAND) { |
if (m->type == COMMAND) { |
c = (struct sudo_command *) m->name; | struct sudo_command *c = |
| (struct sudo_command *) m->name; |
efree(c->cmnd); |
efree(c->cmnd); |
efree(c->args); |
efree(c->args); |
} |
} |
efree(m->name); |
efree(m->name); |
efree(m); |
efree(m); |
} |
} |
|
efree(d->binding); |
} |
} |
efree(d->var); |
efree(d->var); |
efree(d->val); |
efree(d->val); |
efree(d); |
efree(d); |
} |
} |
tq_init(&defaults); | TAILQ_INIT(&defaults); |
|
|
init_aliases(); |
init_aliases(); |
|
|
Line 947 init_parser(const char *path, bool quiet)
|
Line 955 init_parser(const char *path, bool quiet)
|
|
|
debug_return; |
debug_return; |
} |
} |
#line 898 "gram.c" | #line 906 "gram.c" |
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ |
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ |
#if defined(__cplusplus) || defined(__STDC__) |
#if defined(__cplusplus) || defined(__STDC__) |
static int yygrowstack(void) |
static int yygrowstack(void) |
Line 955 static int yygrowstack(void)
|
Line 963 static int yygrowstack(void)
|
static int yygrowstack() |
static int yygrowstack() |
#endif |
#endif |
{ |
{ |
int newsize, i; | unsigned int newsize; |
| long sslen; |
short *newss; |
short *newss; |
YYSTYPE *newvs; |
YYSTYPE *newvs; |
|
|
newsize = yystacksize ? yystacksize : YYINITSTACKSIZE; | if ((newsize = yystacksize) == 0) |
if (newsize >= YYMAXDEPTH) | newsize = YYINITSTACKSIZE; |
| else if (newsize >= YYMAXDEPTH) |
return -1; |
return -1; |
else if ((newsize *= 2) > YYMAXDEPTH) |
else if ((newsize *= 2) > YYMAXDEPTH) |
newsize = YYMAXDEPTH; |
newsize = YYMAXDEPTH; |
#ifdef SIZE_MAX |
#ifdef SIZE_MAX |
#define YY_SIZE_MAX SIZE_MAX |
#define YY_SIZE_MAX SIZE_MAX |
#else |
#else |
#define YY_SIZE_MAX 0x7fffffff | #ifdef __STDC__ |
| #define YY_SIZE_MAX 0xffffffffU |
| #else |
| #define YY_SIZE_MAX (unsigned int)0xffffffff |
#endif |
#endif |
|
#endif |
if (YY_SIZE_MAX / newsize < sizeof *newss) |
if (YY_SIZE_MAX / newsize < sizeof *newss) |
goto bail; |
goto bail; |
i = yyssp - yyss; | sslen = yyssp - yyss; |
newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) : |
newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) : |
(short *)malloc(newsize * sizeof *newss); /* overflow check above */ |
(short *)malloc(newsize * sizeof *newss); /* overflow check above */ |
if (newss == NULL) |
if (newss == NULL) |
goto bail; |
goto bail; |
yyss = newss; |
yyss = newss; |
yyssp = newss + i; | yyssp = newss + sslen; |
newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) : |
newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) : |
(YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */ |
(YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */ |
if (newvs == NULL) |
if (newvs == NULL) |
goto bail; |
goto bail; |
yyvs = newvs; |
yyvs = newvs; |
yyvsp = newvs + i; | yyvsp = newvs + sslen; |
yystacksize = newsize; |
yystacksize = newsize; |
yysslim = yyss + newsize - 1; |
yysslim = yyss + newsize - 1; |
return 0; |
return 0; |
Line 1150 yyreduce:
|
Line 1164 yyreduce:
|
switch (yyn) |
switch (yyn) |
{ |
{ |
case 1: |
case 1: |
#line 185 "gram.y" | #line 182 "gram.y" |
{ ; } |
{ ; } |
break; |
break; |
case 5: |
case 5: |
#line 193 "gram.y" | #line 190 "gram.y" |
{ |
{ |
; |
; |
} |
} |
break; |
break; |
case 6: |
case 6: |
#line 196 "gram.y" | #line 193 "gram.y" |
{ |
{ |
yyerrok; |
yyerrok; |
} |
} |
break; |
break; |
case 7: |
case 7: |
#line 199 "gram.y" | #line 196 "gram.y" |
{ |
{ |
add_userspec(yyvsp[-1].member, yyvsp[0].privilege); |
add_userspec(yyvsp[-1].member, yyvsp[0].privilege); |
} |
} |
break; |
break; |
case 8: |
case 8: |
#line 202 "gram.y" | #line 199 "gram.y" |
{ |
{ |
; |
; |
} |
} |
break; |
break; |
case 9: |
case 9: |
#line 205 "gram.y" | #line 202 "gram.y" |
{ |
{ |
; |
; |
} |
} |
break; |
break; |
case 10: |
case 10: |
#line 208 "gram.y" | #line 205 "gram.y" |
{ |
{ |
; |
; |
} |
} |
break; |
break; |
case 11: |
case 11: |
#line 211 "gram.y" | #line 208 "gram.y" |
{ |
{ |
; |
; |
} |
} |
break; |
break; |
case 12: |
case 12: |
#line 214 "gram.y" | #line 211 "gram.y" |
{ |
{ |
add_defaults(DEFAULTS, NULL, yyvsp[0].defaults); |
add_defaults(DEFAULTS, NULL, yyvsp[0].defaults); |
} |
} |
break; |
break; |
case 13: |
case 13: |
#line 217 "gram.y" | #line 214 "gram.y" |
{ |
{ |
add_defaults(DEFAULTS_USER, yyvsp[-1].member, yyvsp[0].defaults); |
add_defaults(DEFAULTS_USER, yyvsp[-1].member, yyvsp[0].defaults); |
} |
} |
break; |
break; |
case 14: |
case 14: |
#line 220 "gram.y" | #line 217 "gram.y" |
{ |
{ |
add_defaults(DEFAULTS_RUNAS, yyvsp[-1].member, yyvsp[0].defaults); |
add_defaults(DEFAULTS_RUNAS, yyvsp[-1].member, yyvsp[0].defaults); |
} |
} |
break; |
break; |
case 15: |
case 15: |
#line 223 "gram.y" | #line 220 "gram.y" |
{ |
{ |
add_defaults(DEFAULTS_HOST, yyvsp[-1].member, yyvsp[0].defaults); |
add_defaults(DEFAULTS_HOST, yyvsp[-1].member, yyvsp[0].defaults); |
} |
} |
break; |
break; |
case 16: |
case 16: |
#line 226 "gram.y" | #line 223 "gram.y" |
{ |
{ |
add_defaults(DEFAULTS_CMND, yyvsp[-1].member, yyvsp[0].defaults); |
add_defaults(DEFAULTS_CMND, yyvsp[-1].member, yyvsp[0].defaults); |
} |
} |
break; |
break; |
case 18: |
case 18: |
#line 232 "gram.y" | #line 229 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].defaults, yyvsp[0].defaults); | HLTQ_CONCAT(yyvsp[-2].defaults, yyvsp[0].defaults, entries); |
yyval.defaults = yyvsp[-2].defaults; |
yyval.defaults = yyvsp[-2].defaults; |
} |
} |
break; |
break; |
case 19: |
case 19: |
#line 238 "gram.y" | #line 235 "gram.y" |
{ |
{ |
yyval.defaults = new_default(yyvsp[0].string, NULL, true); |
yyval.defaults = new_default(yyvsp[0].string, NULL, true); |
} |
} |
break; |
break; |
case 20: |
case 20: |
#line 241 "gram.y" | #line 238 "gram.y" |
{ |
{ |
yyval.defaults = new_default(yyvsp[0].string, NULL, false); |
yyval.defaults = new_default(yyvsp[0].string, NULL, false); |
} |
} |
break; |
break; |
case 21: |
case 21: |
#line 244 "gram.y" | #line 241 "gram.y" |
{ |
{ |
yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, true); |
yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, true); |
} |
} |
break; |
break; |
case 22: |
case 22: |
#line 247 "gram.y" | #line 244 "gram.y" |
{ |
{ |
yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '+'); |
yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '+'); |
} |
} |
break; |
break; |
case 23: |
case 23: |
#line 250 "gram.y" | #line 247 "gram.y" |
{ |
{ |
yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '-'); |
yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '-'); |
} |
} |
break; |
break; |
case 25: |
case 25: |
#line 256 "gram.y" | #line 253 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].privilege, yyvsp[0].privilege); | HLTQ_CONCAT(yyvsp[-2].privilege, yyvsp[0].privilege, entries); |
yyval.privilege = yyvsp[-2].privilege; |
yyval.privilege = yyvsp[-2].privilege; |
} |
} |
break; |
break; |
case 26: |
case 26: |
#line 262 "gram.y" | #line 259 "gram.y" |
{ |
{ |
struct privilege *p = ecalloc(1, sizeof(*p)); |
struct privilege *p = ecalloc(1, sizeof(*p)); |
list2tq(&p->hostlist, yyvsp[-2].member); | HLTQ_TO_TAILQ(&p->hostlist, yyvsp[-2].member, entries); |
list2tq(&p->cmndlist, yyvsp[0].cmndspec); | HLTQ_TO_TAILQ(&p->cmndlist, yyvsp[0].cmndspec, entries); |
p->prev = p; | HLTQ_INIT(p, entries); |
/* p->next = NULL; */ | |
yyval.privilege = p; |
yyval.privilege = p; |
} |
} |
break; |
break; |
case 27: |
case 27: |
#line 272 "gram.y" | #line 268 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = false; |
yyval.member->negated = false; |
} |
} |
break; |
break; |
case 28: |
case 28: |
#line 276 "gram.y" | #line 272 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = true; |
yyval.member->negated = true; |
} |
} |
break; |
break; |
case 29: |
case 29: |
#line 282 "gram.y" | #line 278 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
} |
} |
break; |
break; |
case 30: |
case 30: |
#line 285 "gram.y" | #line 281 "gram.y" |
{ |
{ |
yyval.member = new_member(NULL, ALL); |
yyval.member = new_member(NULL, ALL); |
} |
} |
break; |
break; |
case 31: |
case 31: |
#line 288 "gram.y" | #line 284 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, NETGROUP); |
yyval.member = new_member(yyvsp[0].string, NETGROUP); |
} |
} |
break; |
break; |
case 32: |
case 32: |
#line 291 "gram.y" | #line 287 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, NTWKADDR); |
yyval.member = new_member(yyvsp[0].string, NTWKADDR); |
} |
} |
break; |
break; |
case 33: |
case 33: |
#line 294 "gram.y" | #line 290 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, WORD); |
yyval.member = new_member(yyvsp[0].string, WORD); |
} |
} |
break; |
break; |
case 35: |
case 35: |
#line 300 "gram.y" | #line 296 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].cmndspec, yyvsp[0].cmndspec); | struct cmndspec *prev; |
| prev = HLTQ_LAST(yyvsp[-2].cmndspec, cmndspec, entries); |
| HLTQ_CONCAT(yyvsp[-2].cmndspec, yyvsp[0].cmndspec, entries); |
#ifdef HAVE_SELINUX |
#ifdef HAVE_SELINUX |
/* propagate role and type */ |
/* propagate role and type */ |
if (yyvsp[0].cmndspec->role == NULL) |
if (yyvsp[0].cmndspec->role == NULL) |
yyvsp[0].cmndspec->role = yyvsp[0].cmndspec->prev->role; | yyvsp[0].cmndspec->role = prev->role; |
if (yyvsp[0].cmndspec->type == NULL) |
if (yyvsp[0].cmndspec->type == NULL) |
yyvsp[0].cmndspec->type = yyvsp[0].cmndspec->prev->type; | yyvsp[0].cmndspec->type = prev->type; |
#endif /* HAVE_SELINUX */ |
#endif /* HAVE_SELINUX */ |
#ifdef HAVE_PRIV_SET |
#ifdef HAVE_PRIV_SET |
/* propagate privs & limitprivs */ |
/* propagate privs & limitprivs */ |
if (yyvsp[0].cmndspec->privs == NULL) |
if (yyvsp[0].cmndspec->privs == NULL) |
yyvsp[0].cmndspec->privs = yyvsp[0].cmndspec->prev->privs; | yyvsp[0].cmndspec->privs = prev->privs; |
if (yyvsp[0].cmndspec->limitprivs == NULL) |
if (yyvsp[0].cmndspec->limitprivs == NULL) |
yyvsp[0].cmndspec->limitprivs = yyvsp[0].cmndspec->prev->limitprivs; | yyvsp[0].cmndspec->limitprivs = prev->limitprivs; |
#endif /* HAVE_PRIV_SET */ |
#endif /* HAVE_PRIV_SET */ |
/* propagate tags and runas list */ |
/* propagate tags and runas list */ |
if (yyvsp[0].cmndspec->tags.nopasswd == UNSPEC) |
if (yyvsp[0].cmndspec->tags.nopasswd == UNSPEC) |
yyvsp[0].cmndspec->tags.nopasswd = yyvsp[0].cmndspec->prev->tags.nopasswd; | yyvsp[0].cmndspec->tags.nopasswd = prev->tags.nopasswd; |
if (yyvsp[0].cmndspec->tags.noexec == UNSPEC) |
if (yyvsp[0].cmndspec->tags.noexec == UNSPEC) |
yyvsp[0].cmndspec->tags.noexec = yyvsp[0].cmndspec->prev->tags.noexec; | yyvsp[0].cmndspec->tags.noexec = prev->tags.noexec; |
if (yyvsp[0].cmndspec->tags.setenv == UNSPEC && |
if (yyvsp[0].cmndspec->tags.setenv == UNSPEC && |
yyvsp[0].cmndspec->prev->tags.setenv != IMPLIED) | prev->tags.setenv != IMPLIED) |
yyvsp[0].cmndspec->tags.setenv = yyvsp[0].cmndspec->prev->tags.setenv; | yyvsp[0].cmndspec->tags.setenv = prev->tags.setenv; |
if (yyvsp[0].cmndspec->tags.log_input == UNSPEC) |
if (yyvsp[0].cmndspec->tags.log_input == UNSPEC) |
yyvsp[0].cmndspec->tags.log_input = yyvsp[0].cmndspec->prev->tags.log_input; | yyvsp[0].cmndspec->tags.log_input = prev->tags.log_input; |
if (yyvsp[0].cmndspec->tags.log_output == UNSPEC) |
if (yyvsp[0].cmndspec->tags.log_output == UNSPEC) |
yyvsp[0].cmndspec->tags.log_output = yyvsp[0].cmndspec->prev->tags.log_output; | yyvsp[0].cmndspec->tags.log_output = prev->tags.log_output; |
if ((tq_empty(&yyvsp[0].cmndspec->runasuserlist) && | if ((yyvsp[0].cmndspec->runasuserlist == NULL && |
tq_empty(&yyvsp[0].cmndspec->runasgrouplist)) && | yyvsp[0].cmndspec->runasgrouplist == NULL) && |
(!tq_empty(&yyvsp[0].cmndspec->prev->runasuserlist) || | (prev->runasuserlist != NULL || |
!tq_empty(&yyvsp[0].cmndspec->prev->runasgrouplist))) { | prev->runasgrouplist != NULL)) { |
yyvsp[0].cmndspec->runasuserlist = yyvsp[0].cmndspec->prev->runasuserlist; | yyvsp[0].cmndspec->runasuserlist = prev->runasuserlist; |
yyvsp[0].cmndspec->runasgrouplist = yyvsp[0].cmndspec->prev->runasgrouplist; | yyvsp[0].cmndspec->runasgrouplist = prev->runasgrouplist; |
} |
} |
yyval.cmndspec = yyvsp[-2].cmndspec; |
yyval.cmndspec = yyvsp[-2].cmndspec; |
} |
} |
break; |
break; |
case 36: |
case 36: |
#line 339 "gram.y" | #line 337 "gram.y" |
{ |
{ |
struct cmndspec *cs = ecalloc(1, sizeof(*cs)); |
struct cmndspec *cs = ecalloc(1, sizeof(*cs)); |
if (yyvsp[-4].runas != NULL) { |
if (yyvsp[-4].runas != NULL) { |
list2tq(&cs->runasuserlist, yyvsp[-4].runas->runasusers); | if (yyvsp[-4].runas->runasusers != NULL) { |
list2tq(&cs->runasgrouplist, yyvsp[-4].runas->runasgroups); | cs->runasuserlist = |
| emalloc(sizeof(*cs->runasuserlist)); |
| HLTQ_TO_TAILQ(cs->runasuserlist, |
| yyvsp[-4].runas->runasusers, entries); |
| } |
| if (yyvsp[-4].runas->runasgroups != NULL) { |
| cs->runasgrouplist = |
| emalloc(sizeof(*cs->runasgrouplist)); |
| HLTQ_TO_TAILQ(cs->runasgrouplist, |
| yyvsp[-4].runas->runasgroups, entries); |
| } |
efree(yyvsp[-4].runas); |
efree(yyvsp[-4].runas); |
} else { |
|
tq_init(&cs->runasuserlist); |
|
tq_init(&cs->runasgrouplist); |
|
} |
} |
#ifdef HAVE_SELINUX |
#ifdef HAVE_SELINUX |
cs->role = yyvsp[-3].seinfo.role; |
cs->role = yyvsp[-3].seinfo.role; |
Line 1386 case 36:
|
Line 1408 case 36:
|
#endif |
#endif |
cs->tags = yyvsp[-1].tag; |
cs->tags = yyvsp[-1].tag; |
cs->cmnd = yyvsp[0].member; |
cs->cmnd = yyvsp[0].member; |
cs->prev = cs; | HLTQ_INIT(cs, entries); |
cs->next = NULL; | |
/* sudo "ALL" implies the SETENV tag */ |
/* sudo "ALL" implies the SETENV tag */ |
if (cs->cmnd->type == ALL && !cs->cmnd->negated && |
if (cs->cmnd->type == ALL && !cs->cmnd->negated && |
cs->tags.setenv == UNSPEC) |
cs->tags.setenv == UNSPEC) |
Line 1396 case 36:
|
Line 1417 case 36:
|
} |
} |
break; |
break; |
case 37: |
case 37: |
#line 369 "gram.y" | #line 373 "gram.y" |
{ |
{ |
yyval.digest = new_digest(SUDO_DIGEST_SHA224, yyvsp[0].string); |
yyval.digest = new_digest(SUDO_DIGEST_SHA224, yyvsp[0].string); |
} |
} |
break; |
break; |
case 38: |
case 38: |
#line 372 "gram.y" | #line 376 "gram.y" |
{ |
{ |
yyval.digest = new_digest(SUDO_DIGEST_SHA256, yyvsp[0].string); |
yyval.digest = new_digest(SUDO_DIGEST_SHA256, yyvsp[0].string); |
} |
} |
break; |
break; |
case 39: |
case 39: |
#line 375 "gram.y" | #line 379 "gram.y" |
{ |
{ |
yyval.digest = new_digest(SUDO_DIGEST_SHA384, yyvsp[0].string); |
yyval.digest = new_digest(SUDO_DIGEST_SHA384, yyvsp[0].string); |
} |
} |
break; |
break; |
case 40: |
case 40: |
#line 378 "gram.y" | #line 382 "gram.y" |
{ |
{ |
yyval.digest = new_digest(SUDO_DIGEST_SHA512, yyvsp[0].string); |
yyval.digest = new_digest(SUDO_DIGEST_SHA512, yyvsp[0].string); |
} |
} |
break; |
break; |
case 41: |
case 41: |
#line 383 "gram.y" | #line 387 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
} |
} |
break; |
break; |
case 42: |
case 42: |
#line 386 "gram.y" | #line 390 "gram.y" |
{ |
{ |
/* XXX - yuck */ |
/* XXX - yuck */ |
struct sudo_command *c = (struct sudo_command *)(yyvsp[0].member->name); |
struct sudo_command *c = (struct sudo_command *)(yyvsp[0].member->name); |
Line 1435 case 42:
|
Line 1456 case 42:
|
} |
} |
break; |
break; |
case 43: |
case 43: |
#line 394 "gram.y" | #line 398 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = false; |
yyval.member->negated = false; |
} |
} |
break; |
break; |
case 44: |
case 44: |
#line 398 "gram.y" | #line 402 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = true; |
yyval.member->negated = true; |
} |
} |
break; |
break; |
case 45: |
case 45: |
#line 404 "gram.y" | #line 408 "gram.y" |
{ |
{ |
yyval.string = yyvsp[0].string; |
yyval.string = yyvsp[0].string; |
} |
} |
break; |
break; |
case 46: |
case 46: |
#line 409 "gram.y" | #line 413 "gram.y" |
{ |
{ |
yyval.string = yyvsp[0].string; |
yyval.string = yyvsp[0].string; |
} |
} |
break; |
break; |
case 47: |
case 47: |
#line 414 "gram.y" | #line 418 "gram.y" |
{ |
{ |
yyval.seinfo.role = NULL; |
yyval.seinfo.role = NULL; |
yyval.seinfo.type = NULL; |
yyval.seinfo.type = NULL; |
} |
} |
break; |
break; |
case 48: |
case 48: |
#line 418 "gram.y" | #line 422 "gram.y" |
{ |
{ |
yyval.seinfo.role = yyvsp[0].string; |
yyval.seinfo.role = yyvsp[0].string; |
yyval.seinfo.type = NULL; |
yyval.seinfo.type = NULL; |
} |
} |
break; |
break; |
case 49: |
case 49: |
#line 422 "gram.y" | #line 426 "gram.y" |
{ |
{ |
yyval.seinfo.type = yyvsp[0].string; |
yyval.seinfo.type = yyvsp[0].string; |
yyval.seinfo.role = NULL; |
yyval.seinfo.role = NULL; |
} |
} |
break; |
break; |
case 50: |
case 50: |
#line 426 "gram.y" | #line 430 "gram.y" |
{ |
{ |
yyval.seinfo.role = yyvsp[-1].string; |
yyval.seinfo.role = yyvsp[-1].string; |
yyval.seinfo.type = yyvsp[0].string; |
yyval.seinfo.type = yyvsp[0].string; |
} |
} |
break; |
break; |
case 51: |
case 51: |
#line 430 "gram.y" | #line 434 "gram.y" |
{ |
{ |
yyval.seinfo.type = yyvsp[-1].string; |
yyval.seinfo.type = yyvsp[-1].string; |
yyval.seinfo.role = yyvsp[0].string; |
yyval.seinfo.role = yyvsp[0].string; |
} |
} |
break; |
break; |
case 52: |
case 52: |
#line 436 "gram.y" | #line 440 "gram.y" |
{ |
{ |
yyval.string = yyvsp[0].string; |
yyval.string = yyvsp[0].string; |
} |
} |
break; |
break; |
case 53: |
case 53: |
#line 440 "gram.y" | #line 444 "gram.y" |
{ |
{ |
yyval.string = yyvsp[0].string; |
yyval.string = yyvsp[0].string; |
} |
} |
break; |
break; |
case 54: |
case 54: |
#line 445 "gram.y" | #line 449 "gram.y" |
{ |
{ |
yyval.privinfo.privs = NULL; |
yyval.privinfo.privs = NULL; |
yyval.privinfo.limitprivs = NULL; |
yyval.privinfo.limitprivs = NULL; |
} |
} |
break; |
break; |
case 55: |
case 55: |
#line 449 "gram.y" | #line 453 "gram.y" |
{ |
{ |
yyval.privinfo.privs = yyvsp[0].string; |
yyval.privinfo.privs = yyvsp[0].string; |
yyval.privinfo.limitprivs = NULL; |
yyval.privinfo.limitprivs = NULL; |
} |
} |
break; |
break; |
case 56: |
case 56: |
#line 453 "gram.y" | #line 457 "gram.y" |
{ |
{ |
yyval.privinfo.privs = NULL; |
yyval.privinfo.privs = NULL; |
yyval.privinfo.limitprivs = yyvsp[0].string; |
yyval.privinfo.limitprivs = yyvsp[0].string; |
} |
} |
break; |
break; |
case 57: |
case 57: |
#line 457 "gram.y" | #line 461 "gram.y" |
{ |
{ |
yyval.privinfo.privs = yyvsp[-1].string; |
yyval.privinfo.privs = yyvsp[-1].string; |
yyval.privinfo.limitprivs = yyvsp[0].string; |
yyval.privinfo.limitprivs = yyvsp[0].string; |
} |
} |
break; |
break; |
case 58: |
case 58: |
#line 461 "gram.y" | #line 465 "gram.y" |
{ |
{ |
yyval.privinfo.limitprivs = yyvsp[-1].string; |
yyval.privinfo.limitprivs = yyvsp[-1].string; |
yyval.privinfo.privs = yyvsp[0].string; |
yyval.privinfo.privs = yyvsp[0].string; |
} |
} |
break; |
break; |
case 59: |
case 59: |
#line 467 "gram.y" | #line 471 "gram.y" |
{ |
{ |
yyval.runas = NULL; |
yyval.runas = NULL; |
} |
} |
break; |
break; |
case 60: |
case 60: |
#line 470 "gram.y" | #line 474 "gram.y" |
{ |
{ |
yyval.runas = yyvsp[-1].runas; |
yyval.runas = yyvsp[-1].runas; |
} |
} |
break; |
break; |
case 61: |
case 61: |
#line 475 "gram.y" | #line 479 "gram.y" |
{ |
{ |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas->runasusers = new_member(NULL, MYSELF); |
yyval.runas->runasusers = new_member(NULL, MYSELF); |
Line 1563 case 61:
|
Line 1584 case 61:
|
} |
} |
break; |
break; |
case 62: |
case 62: |
#line 480 "gram.y" | #line 484 "gram.y" |
{ |
{ |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas->runasusers = yyvsp[0].member; |
yyval.runas->runasusers = yyvsp[0].member; |
Line 1571 case 62:
|
Line 1592 case 62:
|
} |
} |
break; |
break; |
case 63: |
case 63: |
#line 485 "gram.y" | #line 489 "gram.y" |
{ |
{ |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas->runasusers = yyvsp[-2].member; |
yyval.runas->runasusers = yyvsp[-2].member; |
Line 1579 case 63:
|
Line 1600 case 63:
|
} |
} |
break; |
break; |
case 64: |
case 64: |
#line 490 "gram.y" | #line 494 "gram.y" |
{ |
{ |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
/* $$->runasusers = NULL; */ |
/* $$->runasusers = NULL; */ |
Line 1587 case 64:
|
Line 1608 case 64:
|
} |
} |
break; |
break; |
case 65: |
case 65: |
#line 495 "gram.y" | #line 499 "gram.y" |
{ |
{ |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas = ecalloc(1, sizeof(struct runascontainer)); |
yyval.runas->runasusers = new_member(NULL, MYSELF); |
yyval.runas->runasusers = new_member(NULL, MYSELF); |
Line 1595 case 65:
|
Line 1616 case 65:
|
} |
} |
break; |
break; |
case 66: |
case 66: |
#line 502 "gram.y" | #line 506 "gram.y" |
{ |
{ |
yyval.tag.nopasswd = yyval.tag.noexec = yyval.tag.setenv = |
yyval.tag.nopasswd = yyval.tag.noexec = yyval.tag.setenv = |
yyval.tag.log_input = yyval.tag.log_output = UNSPEC; |
yyval.tag.log_input = yyval.tag.log_output = UNSPEC; |
} |
} |
break; |
break; |
case 67: |
case 67: |
#line 506 "gram.y" | #line 510 "gram.y" |
{ |
{ |
yyval.tag.nopasswd = true; |
yyval.tag.nopasswd = true; |
} |
} |
break; |
break; |
case 68: |
case 68: |
#line 509 "gram.y" | #line 513 "gram.y" |
{ |
{ |
yyval.tag.nopasswd = false; |
yyval.tag.nopasswd = false; |
} |
} |
break; |
break; |
case 69: |
case 69: |
#line 512 "gram.y" | #line 516 "gram.y" |
{ |
{ |
yyval.tag.noexec = true; |
yyval.tag.noexec = true; |
} |
} |
break; |
break; |
case 70: |
case 70: |
#line 515 "gram.y" | #line 519 "gram.y" |
{ |
{ |
yyval.tag.noexec = false; |
yyval.tag.noexec = false; |
} |
} |
break; |
break; |
case 71: |
case 71: |
#line 518 "gram.y" | #line 522 "gram.y" |
{ |
{ |
yyval.tag.setenv = true; |
yyval.tag.setenv = true; |
} |
} |
break; |
break; |
case 72: |
case 72: |
#line 521 "gram.y" | #line 525 "gram.y" |
{ |
{ |
yyval.tag.setenv = false; |
yyval.tag.setenv = false; |
} |
} |
break; |
break; |
case 73: |
case 73: |
#line 524 "gram.y" | #line 528 "gram.y" |
{ |
{ |
yyval.tag.log_input = true; |
yyval.tag.log_input = true; |
} |
} |
break; |
break; |
case 74: |
case 74: |
#line 527 "gram.y" | #line 531 "gram.y" |
{ |
{ |
yyval.tag.log_input = false; |
yyval.tag.log_input = false; |
} |
} |
break; |
break; |
case 75: |
case 75: |
#line 530 "gram.y" | #line 534 "gram.y" |
{ |
{ |
yyval.tag.log_output = true; |
yyval.tag.log_output = true; |
} |
} |
break; |
break; |
case 76: |
case 76: |
#line 533 "gram.y" | #line 537 "gram.y" |
{ |
{ |
yyval.tag.log_output = false; |
yyval.tag.log_output = false; |
} |
} |
break; |
break; |
case 77: |
case 77: |
#line 538 "gram.y" | #line 542 "gram.y" |
{ |
{ |
yyval.member = new_member(NULL, ALL); |
yyval.member = new_member(NULL, ALL); |
} |
} |
break; |
break; |
case 78: |
case 78: |
#line 541 "gram.y" | #line 545 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
} |
} |
break; |
break; |
case 79: |
case 79: |
#line 544 "gram.y" | #line 548 "gram.y" |
{ |
{ |
struct sudo_command *c = ecalloc(1, sizeof(*c)); |
struct sudo_command *c = ecalloc(1, sizeof(*c)); |
c->cmnd = yyvsp[0].command.cmnd; |
c->cmnd = yyvsp[0].command.cmnd; |
Line 1683 case 79:
|
Line 1704 case 79:
|
} |
} |
break; |
break; |
case 82: |
case 82: |
#line 556 "gram.y" | #line 560 "gram.y" |
{ |
{ |
char *s; |
char *s; |
if ((s = alias_add(yyvsp[-2].string, HOSTALIAS, yyvsp[0].member)) != NULL) { |
if ((s = alias_add(yyvsp[-2].string, HOSTALIAS, yyvsp[0].member)) != NULL) { |
Line 1693 case 82:
|
Line 1714 case 82:
|
} |
} |
break; |
break; |
case 84: |
case 84: |
#line 566 "gram.y" | #line 570 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].member, yyvsp[0].member); | HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries); |
yyval.member = yyvsp[-2].member; |
yyval.member = yyvsp[-2].member; |
} |
} |
break; |
break; |
case 87: |
case 87: |
#line 576 "gram.y" | #line 580 "gram.y" |
{ |
{ |
char *s; |
char *s; |
if ((s = alias_add(yyvsp[-2].string, CMNDALIAS, yyvsp[0].member)) != NULL) { |
if ((s = alias_add(yyvsp[-2].string, CMNDALIAS, yyvsp[0].member)) != NULL) { |
Line 1710 case 87:
|
Line 1731 case 87:
|
} |
} |
break; |
break; |
case 89: |
case 89: |
#line 586 "gram.y" | #line 590 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].member, yyvsp[0].member); | HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries); |
yyval.member = yyvsp[-2].member; |
yyval.member = yyvsp[-2].member; |
} |
} |
break; |
break; |
case 92: |
case 92: |
#line 596 "gram.y" | #line 600 "gram.y" |
{ |
{ |
char *s; |
char *s; |
if ((s = alias_add(yyvsp[-2].string, RUNASALIAS, yyvsp[0].member)) != NULL) { |
if ((s = alias_add(yyvsp[-2].string, RUNASALIAS, yyvsp[0].member)) != NULL) { |
Line 1727 case 92:
|
Line 1748 case 92:
|
} |
} |
break; |
break; |
case 95: |
case 95: |
#line 609 "gram.y" | #line 613 "gram.y" |
{ |
{ |
char *s; |
char *s; |
if ((s = alias_add(yyvsp[-2].string, USERALIAS, yyvsp[0].member)) != NULL) { |
if ((s = alias_add(yyvsp[-2].string, USERALIAS, yyvsp[0].member)) != NULL) { |
Line 1737 case 95:
|
Line 1758 case 95:
|
} |
} |
break; |
break; |
case 97: |
case 97: |
#line 619 "gram.y" | #line 623 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].member, yyvsp[0].member); | HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries); |
yyval.member = yyvsp[-2].member; |
yyval.member = yyvsp[-2].member; |
} |
} |
break; |
break; |
case 98: |
case 98: |
#line 625 "gram.y" | #line 629 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = false; |
yyval.member->negated = false; |
} |
} |
break; |
break; |
case 99: |
case 99: |
#line 629 "gram.y" | #line 633 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = true; |
yyval.member->negated = true; |
} |
} |
break; |
break; |
case 100: |
case 100: |
#line 635 "gram.y" | #line 639 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
} |
} |
break; |
break; |
case 101: |
case 101: |
#line 638 "gram.y" | #line 642 "gram.y" |
{ |
{ |
yyval.member = new_member(NULL, ALL); |
yyval.member = new_member(NULL, ALL); |
} |
} |
break; |
break; |
case 102: |
case 102: |
#line 641 "gram.y" | #line 645 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, NETGROUP); |
yyval.member = new_member(yyvsp[0].string, NETGROUP); |
} |
} |
break; |
break; |
case 103: |
case 103: |
#line 644 "gram.y" | #line 648 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, USERGROUP); |
yyval.member = new_member(yyvsp[0].string, USERGROUP); |
} |
} |
break; |
break; |
case 104: |
case 104: |
#line 647 "gram.y" | #line 651 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, WORD); |
yyval.member = new_member(yyvsp[0].string, WORD); |
} |
} |
break; |
break; |
case 106: |
case 106: |
#line 653 "gram.y" | #line 657 "gram.y" |
{ |
{ |
list_append(yyvsp[-2].member, yyvsp[0].member); | HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries); |
yyval.member = yyvsp[-2].member; |
yyval.member = yyvsp[-2].member; |
} |
} |
break; |
break; |
case 107: |
case 107: |
#line 659 "gram.y" | #line 663 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = false; |
yyval.member->negated = false; |
} |
} |
break; |
break; |
case 108: |
case 108: |
#line 663 "gram.y" | #line 667 "gram.y" |
{ |
{ |
yyval.member = yyvsp[0].member; |
yyval.member = yyvsp[0].member; |
yyval.member->negated = true; |
yyval.member->negated = true; |
} |
} |
break; |
break; |
case 109: |
case 109: |
#line 669 "gram.y" | #line 673 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
yyval.member = new_member(yyvsp[0].string, ALIAS); |
} |
} |
break; |
break; |
case 110: |
case 110: |
#line 672 "gram.y" | #line 676 "gram.y" |
{ |
{ |
yyval.member = new_member(NULL, ALL); |
yyval.member = new_member(NULL, ALL); |
} |
} |
break; |
break; |
case 111: |
case 111: |
#line 675 "gram.y" | #line 679 "gram.y" |
{ |
{ |
yyval.member = new_member(yyvsp[0].string, WORD); |
yyval.member = new_member(yyvsp[0].string, WORD); |
} |
} |
break; |
break; |
#line 1777 "gram.c" | #line 1798 "gram.c" |
} |
} |
yyssp -= yym; |
yyssp -= yym; |
yystate = *yyssp; |
yystate = *yyssp; |