init_parser.c revision a76baaabe56b98e23861e89722bd1425f92dbc2c 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdio.h>
18#include <stdlib.h>
19#include <unistd.h>
20#include <fcntl.h>
21#include <stdarg.h>
22#include <string.h>
23#include <stddef.h>
24#include <ctype.h>
25
26#include "init.h"
27#include "parser.h"
28#include "init_parser.h"
29#include "log.h"
30#include "property_service.h"
31#include "util.h"
32
33#include <cutils/iosched_policy.h>
34#include <cutils/list.h>
35
36#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
37#include <sys/_system_properties.h>
38
39static list_declare(service_list);
40static list_declare(action_list);
41static list_declare(action_queue);
42
43struct import {
44    struct listnode list;
45    const char *filename;
46};
47
48static void *parse_service(struct parse_state *state, int nargs, char **args);
49static void parse_line_service(struct parse_state *state, int nargs, char **args);
50
51static void *parse_action(struct parse_state *state, int nargs, char **args);
52static void parse_line_action(struct parse_state *state, int nargs, char **args);
53
54#define SECTION 0x01
55#define COMMAND 0x02
56#define OPTION  0x04
57
58#include "keywords.h"
59
60#define KEYWORD(symbol, flags, nargs, func) \
61    [ K_##symbol ] = { #symbol, func, nargs + 1, flags, },
62
63struct {
64    const char *name;
65    int (*func)(int nargs, char **args);
66    unsigned char nargs;
67    unsigned char flags;
68} keyword_info[KEYWORD_COUNT] = {
69    [ K_UNKNOWN ] = { "unknown", 0, 0, 0 },
70#include "keywords.h"
71};
72#undef KEYWORD
73
74#define kw_is(kw, type) (keyword_info[kw].flags & (type))
75#define kw_name(kw) (keyword_info[kw].name)
76#define kw_func(kw) (keyword_info[kw].func)
77#define kw_nargs(kw) (keyword_info[kw].nargs)
78
79int lookup_keyword(const char *s)
80{
81    switch (*s++) {
82    case 'c':
83    if (!strcmp(s, "opy")) return K_copy;
84        if (!strcmp(s, "apability")) return K_capability;
85        if (!strcmp(s, "hdir")) return K_chdir;
86        if (!strcmp(s, "hroot")) return K_chroot;
87        if (!strcmp(s, "lass")) return K_class;
88        if (!strcmp(s, "lass_start")) return K_class_start;
89        if (!strcmp(s, "lass_stop")) return K_class_stop;
90        if (!strcmp(s, "lass_reset")) return K_class_reset;
91        if (!strcmp(s, "onsole")) return K_console;
92        if (!strcmp(s, "hown")) return K_chown;
93        if (!strcmp(s, "hmod")) return K_chmod;
94        if (!strcmp(s, "ritical")) return K_critical;
95        break;
96    case 'd':
97        if (!strcmp(s, "isabled")) return K_disabled;
98        if (!strcmp(s, "omainname")) return K_domainname;
99        break;
100    case 'e':
101        if (!strcmp(s, "xec")) return K_exec;
102        if (!strcmp(s, "xport")) return K_export;
103        break;
104    case 'g':
105        if (!strcmp(s, "roup")) return K_group;
106        break;
107    case 'h':
108        if (!strcmp(s, "ostname")) return K_hostname;
109        break;
110    case 'i':
111        if (!strcmp(s, "oprio")) return K_ioprio;
112        if (!strcmp(s, "fup")) return K_ifup;
113        if (!strcmp(s, "nsmod")) return K_insmod;
114        if (!strcmp(s, "mport")) return K_import;
115        break;
116    case 'k':
117        if (!strcmp(s, "eycodes")) return K_keycodes;
118        break;
119    case 'l':
120        if (!strcmp(s, "oglevel")) return K_loglevel;
121        if (!strcmp(s, "oad_persist_props")) return K_load_persist_props;
122        break;
123    case 'm':
124        if (!strcmp(s, "kdir")) return K_mkdir;
125        if (!strcmp(s, "ount_all")) return K_mount_all;
126        if (!strcmp(s, "ount")) return K_mount;
127        break;
128    case 'o':
129        if (!strcmp(s, "n")) return K_on;
130        if (!strcmp(s, "neshot")) return K_oneshot;
131        if (!strcmp(s, "nrestart")) return K_onrestart;
132        break;
133    case 'p':
134        if (!strcmp(s, "owerctl")) return K_powerctl;
135    case 'r':
136        if (!strcmp(s, "estart")) return K_restart;
137        if (!strcmp(s, "estorecon")) return K_restorecon;
138        if (!strcmp(s, "mdir")) return K_rmdir;
139        if (!strcmp(s, "m")) return K_rm;
140        break;
141    case 's':
142        if (!strcmp(s, "eclabel")) return K_seclabel;
143        if (!strcmp(s, "ervice")) return K_service;
144        if (!strcmp(s, "etcon")) return K_setcon;
145        if (!strcmp(s, "etenforce")) return K_setenforce;
146        if (!strcmp(s, "etenv")) return K_setenv;
147        if (!strcmp(s, "etkey")) return K_setkey;
148        if (!strcmp(s, "etprop")) return K_setprop;
149        if (!strcmp(s, "etrlimit")) return K_setrlimit;
150        if (!strcmp(s, "etsebool")) return K_setsebool;
151        if (!strcmp(s, "ocket")) return K_socket;
152        if (!strcmp(s, "tart")) return K_start;
153        if (!strcmp(s, "top")) return K_stop;
154        if (!strcmp(s, "wapon_all")) return K_swapon_all;
155        if (!strcmp(s, "ymlink")) return K_symlink;
156        if (!strcmp(s, "ysclktz")) return K_sysclktz;
157        break;
158    case 't':
159        if (!strcmp(s, "rigger")) return K_trigger;
160        break;
161    case 'u':
162        if (!strcmp(s, "ser")) return K_user;
163        break;
164    case 'w':
165        if (!strcmp(s, "rite")) return K_write;
166        if (!strcmp(s, "ait")) return K_wait;
167        break;
168    }
169    return K_UNKNOWN;
170}
171
172void parse_line_no_op(struct parse_state *state, int nargs, char **args)
173{
174}
175
176static int push_chars(char **dst, int *len, const char *chars, int cnt)
177{
178    if (cnt > *len)
179        return -1;
180
181    memcpy(*dst, chars, cnt);
182    *dst += cnt;
183    *len -= cnt;
184
185    return 0;
186}
187
188int expand_props(char *dst, const char *src, int dst_size)
189{
190    int cnt = 0;
191    char *dst_ptr = dst;
192    const char *src_ptr = src;
193    int src_len;
194    int idx = 0;
195    int ret = 0;
196    int left = dst_size - 1;
197
198    if (!src || !dst || dst_size == 0)
199        return -1;
200
201    src_len = strlen(src);
202
203    /* - variables can either be $x.y or ${x.y}, in case they are only part
204     *   of the string.
205     * - will accept $$ as a literal $.
206     * - no nested property expansion, i.e. ${foo.${bar}} is not supported,
207     *   bad things will happen
208     */
209    while (*src_ptr && left > 0) {
210        char *c;
211        char prop[PROP_NAME_MAX + 1];
212        char prop_val[PROP_VALUE_MAX];
213        int prop_len = 0;
214        int prop_val_len;
215
216        c = strchr(src_ptr, '$');
217        if (!c) {
218            while (left-- > 0 && *src_ptr)
219                *(dst_ptr++) = *(src_ptr++);
220            break;
221        }
222
223        memset(prop, 0, sizeof(prop));
224
225        ret = push_chars(&dst_ptr, &left, src_ptr, c - src_ptr);
226        if (ret < 0)
227            goto err_nospace;
228        c++;
229
230        if (*c == '$') {
231            *(dst_ptr++) = *(c++);
232            src_ptr = c;
233            left--;
234            continue;
235        } else if (*c == '\0') {
236            break;
237        }
238
239        if (*c == '{') {
240            c++;
241            while (*c && *c != '}' && prop_len < PROP_NAME_MAX)
242                prop[prop_len++] = *(c++);
243            if (*c != '}') {
244                /* failed to find closing brace, abort. */
245                if (prop_len == PROP_NAME_MAX)
246                    ERROR("prop name too long during expansion of '%s'\n",
247                          src);
248                else if (*c == '\0')
249                    ERROR("unexpected end of string in '%s', looking for }\n",
250                          src);
251                goto err;
252            }
253            prop[prop_len] = '\0';
254            c++;
255        } else if (*c) {
256            while (*c && prop_len < PROP_NAME_MAX)
257                prop[prop_len++] = *(c++);
258            if (prop_len == PROP_NAME_MAX && *c != '\0') {
259                ERROR("prop name too long in '%s'\n", src);
260                goto err;
261            }
262            prop[prop_len] = '\0';
263            ERROR("using deprecated syntax for specifying property '%s', use ${name} instead\n",
264                  prop);
265        }
266
267        if (prop_len == 0) {
268            ERROR("invalid zero-length prop name in '%s'\n", src);
269            goto err;
270        }
271
272        prop_val_len = property_get(prop, prop_val);
273        if (!prop_val_len) {
274            ERROR("property '%s' doesn't exist while expanding '%s'\n",
275                  prop, src);
276            goto err;
277        }
278
279        ret = push_chars(&dst_ptr, &left, prop_val, prop_val_len);
280        if (ret < 0)
281            goto err_nospace;
282        src_ptr = c;
283        continue;
284    }
285
286    *dst_ptr = '\0';
287    return 0;
288
289err_nospace:
290    ERROR("destination buffer overflow while expanding '%s'\n", src);
291err:
292    return -1;
293}
294
295void parse_import(struct parse_state *state, int nargs, char **args)
296{
297    struct listnode *import_list = state->priv;
298    struct import *import;
299    char conf_file[PATH_MAX];
300    int ret;
301
302    if (nargs != 2) {
303        ERROR("single argument needed for import\n");
304        return;
305    }
306
307    ret = expand_props(conf_file, args[1], sizeof(conf_file));
308    if (ret) {
309        ERROR("error while handling import on line '%d' in '%s'\n",
310              state->line, state->filename);
311        return;
312    }
313
314    import = calloc(1, sizeof(struct import));
315    import->filename = strdup(conf_file);
316    list_add_tail(import_list, &import->list);
317    INFO("found import '%s', adding to import list", import->filename);
318}
319
320void parse_new_section(struct parse_state *state, int kw,
321                       int nargs, char **args)
322{
323    printf("[ %s %s ]\n", args[0],
324           nargs > 1 ? args[1] : "");
325    switch(kw) {
326    case K_service:
327        state->context = parse_service(state, nargs, args);
328        if (state->context) {
329            state->parse_line = parse_line_service;
330            return;
331        }
332        break;
333    case K_on:
334        state->context = parse_action(state, nargs, args);
335        if (state->context) {
336            state->parse_line = parse_line_action;
337            return;
338        }
339        break;
340    case K_import:
341        parse_import(state, nargs, args);
342        break;
343    }
344    state->parse_line = parse_line_no_op;
345}
346
347static void parse_config(const char *fn, char *s)
348{
349    struct parse_state state;
350    struct listnode import_list;
351    struct listnode *node;
352    char *args[INIT_PARSER_MAXARGS];
353    int nargs;
354
355    nargs = 0;
356    state.filename = fn;
357    state.line = 0;
358    state.ptr = s;
359    state.nexttoken = 0;
360    state.parse_line = parse_line_no_op;
361
362    list_init(&import_list);
363    state.priv = &import_list;
364
365    for (;;) {
366        switch (next_token(&state)) {
367        case T_EOF:
368            state.parse_line(&state, 0, 0);
369            goto parser_done;
370        case T_NEWLINE:
371            state.line++;
372            if (nargs) {
373                int kw = lookup_keyword(args[0]);
374                if (kw_is(kw, SECTION)) {
375                    state.parse_line(&state, 0, 0);
376                    parse_new_section(&state, kw, nargs, args);
377                } else {
378                    state.parse_line(&state, nargs, args);
379                }
380                nargs = 0;
381            }
382            break;
383        case T_TEXT:
384            if (nargs < INIT_PARSER_MAXARGS) {
385                args[nargs++] = state.text;
386            }
387            break;
388        }
389    }
390
391parser_done:
392    list_for_each(node, &import_list) {
393         struct import *import = node_to_item(node, struct import, list);
394         int ret;
395
396         INFO("importing '%s'", import->filename);
397         ret = init_parse_config_file(import->filename);
398         if (ret)
399             ERROR("could not import file '%s' from '%s'\n",
400                   import->filename, fn);
401    }
402}
403
404int init_parse_config_file(const char *fn)
405{
406    char *data;
407    data = read_file(fn, 0);
408    if (!data) return -1;
409
410    parse_config(fn, data);
411    DUMP();
412    return 0;
413}
414
415static int valid_name(const char *name)
416{
417    if (strlen(name) > 16) {
418        return 0;
419    }
420    while (*name) {
421        if (!isalnum(*name) && (*name != '_') && (*name != '-')) {
422            return 0;
423        }
424        name++;
425    }
426    return 1;
427}
428
429struct service *service_find_by_name(const char *name)
430{
431    struct listnode *node;
432    struct service *svc;
433    list_for_each(node, &service_list) {
434        svc = node_to_item(node, struct service, slist);
435        if (!strcmp(svc->name, name)) {
436            return svc;
437        }
438    }
439    return 0;
440}
441
442struct service *service_find_by_pid(pid_t pid)
443{
444    struct listnode *node;
445    struct service *svc;
446    list_for_each(node, &service_list) {
447        svc = node_to_item(node, struct service, slist);
448        if (svc->pid == pid) {
449            return svc;
450        }
451    }
452    return 0;
453}
454
455struct service *service_find_by_keychord(int keychord_id)
456{
457    struct listnode *node;
458    struct service *svc;
459    list_for_each(node, &service_list) {
460        svc = node_to_item(node, struct service, slist);
461        if (svc->keychord_id == keychord_id) {
462            return svc;
463        }
464    }
465    return 0;
466}
467
468void service_for_each(void (*func)(struct service *svc))
469{
470    struct listnode *node;
471    struct service *svc;
472    list_for_each(node, &service_list) {
473        svc = node_to_item(node, struct service, slist);
474        func(svc);
475    }
476}
477
478void service_for_each_class(const char *classname,
479                            void (*func)(struct service *svc))
480{
481    struct listnode *node;
482    struct service *svc;
483    list_for_each(node, &service_list) {
484        svc = node_to_item(node, struct service, slist);
485        if (!strcmp(svc->classname, classname)) {
486            func(svc);
487        }
488    }
489}
490
491void service_for_each_flags(unsigned matchflags,
492                            void (*func)(struct service *svc))
493{
494    struct listnode *node;
495    struct service *svc;
496    list_for_each(node, &service_list) {
497        svc = node_to_item(node, struct service, slist);
498        if (svc->flags & matchflags) {
499            func(svc);
500        }
501    }
502}
503
504void action_for_each_trigger(const char *trigger,
505                             void (*func)(struct action *act))
506{
507    struct listnode *node;
508    struct action *act;
509    list_for_each(node, &action_list) {
510        act = node_to_item(node, struct action, alist);
511        if (!strcmp(act->name, trigger)) {
512            func(act);
513        }
514    }
515}
516
517void queue_property_triggers(const char *name, const char *value)
518{
519    struct listnode *node;
520    struct action *act;
521    list_for_each(node, &action_list) {
522        act = node_to_item(node, struct action, alist);
523        if (!strncmp(act->name, "property:", strlen("property:"))) {
524            const char *test = act->name + strlen("property:");
525            int name_length = strlen(name);
526
527            if (!strncmp(name, test, name_length) &&
528                    test[name_length] == '=' &&
529                    (!strcmp(test + name_length + 1, value) ||
530                     !strcmp(test + name_length + 1, "*"))) {
531                action_add_queue_tail(act);
532            }
533        }
534    }
535}
536
537void queue_all_property_triggers()
538{
539    struct listnode *node;
540    struct action *act;
541    list_for_each(node, &action_list) {
542        act = node_to_item(node, struct action, alist);
543        if (!strncmp(act->name, "property:", strlen("property:"))) {
544            /* parse property name and value
545               syntax is property:<name>=<value> */
546            const char* name = act->name + strlen("property:");
547            const char* equals = strchr(name, '=');
548            if (equals) {
549                char prop_name[PROP_NAME_MAX + 1];
550                char value[PROP_VALUE_MAX];
551                int length = equals - name;
552                if (length > PROP_NAME_MAX) {
553                    ERROR("property name too long in trigger %s", act->name);
554                } else {
555                    memcpy(prop_name, name, length);
556                    prop_name[length] = 0;
557
558                    /* does the property exist, and match the trigger value? */
559                    property_get(prop_name, value);
560                    if (!strcmp(equals + 1, value) ||!strcmp(equals + 1, "*")) {
561                        action_add_queue_tail(act);
562                    }
563                }
564            }
565        }
566    }
567}
568
569void queue_builtin_action(int (*func)(int nargs, char **args), char *name)
570{
571    struct action *act;
572    struct command *cmd;
573
574    act = calloc(1, sizeof(*act));
575    act->name = name;
576    list_init(&act->commands);
577    list_init(&act->qlist);
578
579    cmd = calloc(1, sizeof(*cmd));
580    cmd->func = func;
581    cmd->args[0] = name;
582    list_add_tail(&act->commands, &cmd->clist);
583
584    list_add_tail(&action_list, &act->alist);
585    action_add_queue_tail(act);
586}
587
588void action_add_queue_tail(struct action *act)
589{
590    if (list_empty(&act->qlist)) {
591        list_add_tail(&action_queue, &act->qlist);
592    }
593}
594
595struct action *action_remove_queue_head(void)
596{
597    if (list_empty(&action_queue)) {
598        return 0;
599    } else {
600        struct listnode *node = list_head(&action_queue);
601        struct action *act = node_to_item(node, struct action, qlist);
602        list_remove(node);
603        list_init(node);
604        return act;
605    }
606}
607
608int action_queue_empty()
609{
610    return list_empty(&action_queue);
611}
612
613static void *parse_service(struct parse_state *state, int nargs, char **args)
614{
615    struct service *svc;
616    if (nargs < 3) {
617        parse_error(state, "services must have a name and a program\n");
618        return 0;
619    }
620    if (!valid_name(args[1])) {
621        parse_error(state, "invalid service name '%s'\n", args[1]);
622        return 0;
623    }
624
625    svc = service_find_by_name(args[1]);
626    if (svc) {
627        parse_error(state, "ignored duplicate definition of service '%s'\n", args[1]);
628        return 0;
629    }
630
631    nargs -= 2;
632    svc = calloc(1, sizeof(*svc) + sizeof(char*) * nargs);
633    if (!svc) {
634        parse_error(state, "out of memory\n");
635        return 0;
636    }
637    svc->name = args[1];
638    svc->classname = "default";
639    memcpy(svc->args, args + 2, sizeof(char*) * nargs);
640    svc->args[nargs] = 0;
641    svc->nargs = nargs;
642    svc->onrestart.name = "onrestart";
643    list_init(&svc->onrestart.commands);
644    list_add_tail(&service_list, &svc->slist);
645    return svc;
646}
647
648static void parse_line_service(struct parse_state *state, int nargs, char **args)
649{
650    struct service *svc = state->context;
651    struct command *cmd;
652    int i, kw, kw_nargs;
653
654    if (nargs == 0) {
655        return;
656    }
657
658    svc->ioprio_class = IoSchedClass_NONE;
659
660    kw = lookup_keyword(args[0]);
661    switch (kw) {
662    case K_capability:
663        break;
664    case K_class:
665        if (nargs != 2) {
666            parse_error(state, "class option requires a classname\n");
667        } else {
668            svc->classname = args[1];
669        }
670        break;
671    case K_console:
672        svc->flags |= SVC_CONSOLE;
673        break;
674    case K_disabled:
675        svc->flags |= SVC_DISABLED;
676        svc->flags |= SVC_RC_DISABLED;
677        break;
678    case K_ioprio:
679        if (nargs != 3) {
680            parse_error(state, "ioprio optin usage: ioprio <rt|be|idle> <ioprio 0-7>\n");
681        } else {
682            svc->ioprio_pri = strtoul(args[2], 0, 8);
683
684            if (svc->ioprio_pri < 0 || svc->ioprio_pri > 7) {
685                parse_error(state, "priority value must be range 0 - 7\n");
686                break;
687            }
688
689            if (!strcmp(args[1], "rt")) {
690                svc->ioprio_class = IoSchedClass_RT;
691            } else if (!strcmp(args[1], "be")) {
692                svc->ioprio_class = IoSchedClass_BE;
693            } else if (!strcmp(args[1], "idle")) {
694                svc->ioprio_class = IoSchedClass_IDLE;
695            } else {
696                parse_error(state, "ioprio option usage: ioprio <rt|be|idle> <0-7>\n");
697            }
698        }
699        break;
700    case K_group:
701        if (nargs < 2) {
702            parse_error(state, "group option requires a group id\n");
703        } else if (nargs > NR_SVC_SUPP_GIDS + 2) {
704            parse_error(state, "group option accepts at most %d supp. groups\n",
705                        NR_SVC_SUPP_GIDS);
706        } else {
707            int n;
708            svc->gid = decode_uid(args[1]);
709            for (n = 2; n < nargs; n++) {
710                svc->supp_gids[n-2] = decode_uid(args[n]);
711            }
712            svc->nr_supp_gids = n - 2;
713        }
714        break;
715    case K_keycodes:
716        if (nargs < 2) {
717            parse_error(state, "keycodes option requires atleast one keycode\n");
718        } else {
719            svc->keycodes = malloc((nargs - 1) * sizeof(svc->keycodes[0]));
720            if (!svc->keycodes) {
721                parse_error(state, "could not allocate keycodes\n");
722            } else {
723                svc->nkeycodes = nargs - 1;
724                for (i = 1; i < nargs; i++) {
725                    svc->keycodes[i - 1] = atoi(args[i]);
726                }
727            }
728        }
729        break;
730    case K_oneshot:
731        svc->flags |= SVC_ONESHOT;
732        break;
733    case K_onrestart:
734        nargs--;
735        args++;
736        kw = lookup_keyword(args[0]);
737        if (!kw_is(kw, COMMAND)) {
738            parse_error(state, "invalid command '%s'\n", args[0]);
739            break;
740        }
741        kw_nargs = kw_nargs(kw);
742        if (nargs < kw_nargs) {
743            parse_error(state, "%s requires %d %s\n", args[0], kw_nargs - 1,
744                kw_nargs > 2 ? "arguments" : "argument");
745            break;
746        }
747
748        cmd = malloc(sizeof(*cmd) + sizeof(char*) * nargs);
749        cmd->func = kw_func(kw);
750        cmd->nargs = nargs;
751        memcpy(cmd->args, args, sizeof(char*) * nargs);
752        list_add_tail(&svc->onrestart.commands, &cmd->clist);
753        break;
754    case K_critical:
755        svc->flags |= SVC_CRITICAL;
756        break;
757    case K_setenv: { /* name value */
758        struct svcenvinfo *ei;
759        if (nargs < 2) {
760            parse_error(state, "setenv option requires name and value arguments\n");
761            break;
762        }
763        ei = calloc(1, sizeof(*ei));
764        if (!ei) {
765            parse_error(state, "out of memory\n");
766            break;
767        }
768        ei->name = args[1];
769        ei->value = args[2];
770        ei->next = svc->envvars;
771        svc->envvars = ei;
772        break;
773    }
774    case K_socket: {/* name type perm [ uid gid ] */
775        struct socketinfo *si;
776        if (nargs < 4) {
777            parse_error(state, "socket option requires name, type, perm arguments\n");
778            break;
779        }
780        if (strcmp(args[2],"dgram") && strcmp(args[2],"stream")
781                && strcmp(args[2],"seqpacket")) {
782            parse_error(state, "socket type must be 'dgram', 'stream' or 'seqpacket'\n");
783            break;
784        }
785        si = calloc(1, sizeof(*si));
786        if (!si) {
787            parse_error(state, "out of memory\n");
788            break;
789        }
790        si->name = args[1];
791        si->type = args[2];
792        si->perm = strtoul(args[3], 0, 8);
793        if (nargs > 4)
794            si->uid = decode_uid(args[4]);
795        if (nargs > 5)
796            si->gid = decode_uid(args[5]);
797        si->next = svc->sockets;
798        svc->sockets = si;
799        break;
800    }
801    case K_user:
802        if (nargs != 2) {
803            parse_error(state, "user option requires a user id\n");
804        } else {
805            svc->uid = decode_uid(args[1]);
806        }
807        break;
808    case K_seclabel:
809        if (nargs != 2) {
810            parse_error(state, "seclabel option requires a label string\n");
811        } else {
812            svc->seclabel = args[1];
813        }
814        break;
815
816    default:
817        parse_error(state, "invalid option '%s'\n", args[0]);
818    }
819}
820
821static void *parse_action(struct parse_state *state, int nargs, char **args)
822{
823    struct action *act;
824    if (nargs < 2) {
825        parse_error(state, "actions must have a trigger\n");
826        return 0;
827    }
828    if (nargs > 2) {
829        parse_error(state, "actions may not have extra parameters\n");
830        return 0;
831    }
832    act = calloc(1, sizeof(*act));
833    act->name = args[1];
834    list_init(&act->commands);
835    list_init(&act->qlist);
836    list_add_tail(&action_list, &act->alist);
837        /* XXX add to hash */
838    return act;
839}
840
841static void parse_line_action(struct parse_state* state, int nargs, char **args)
842{
843    struct command *cmd;
844    struct action *act = state->context;
845    int (*func)(int nargs, char **args);
846    int kw, n;
847
848    if (nargs == 0) {
849        return;
850    }
851
852    kw = lookup_keyword(args[0]);
853    if (!kw_is(kw, COMMAND)) {
854        parse_error(state, "invalid command '%s'\n", args[0]);
855        return;
856    }
857
858    n = kw_nargs(kw);
859    if (nargs < n) {
860        parse_error(state, "%s requires %d %s\n", args[0], n - 1,
861            n > 2 ? "arguments" : "argument");
862        return;
863    }
864    cmd = malloc(sizeof(*cmd) + sizeof(char*) * nargs);
865    cmd->func = kw_func(kw);
866    cmd->nargs = nargs;
867    memcpy(cmd->args, args, sizeof(char*) * nargs);
868    list_add_tail(&act->commands, &cmd->clist);
869}
870