builtins.c revision ca7648ddfb46347c60014a849b0150a74df4e1d2 
1/*
2 * Copyright (C) 2008 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 <sys/types.h>
18#include <sys/stat.h>
19#include <fcntl.h>
20#include <unistd.h>
21#include <string.h>
22#include <stdio.h>
23#include <linux/kd.h>
24#include <errno.h>
25#include <sys/socket.h>
26#include <netinet/in.h>
27#include <linux/if.h>
28#include <arpa/inet.h>
29#include <stdlib.h>
30#include <sys/mount.h>
31#include <sys/resource.h>
32#include <linux/loop.h>
33
34#include "init.h"
35#include "keywords.h"
36#include "property_service.h"
37#include "devices.h"
38#include "parser.h"
39
40#include <private/android_filesystem_config.h>
41
42void add_environment(const char *name, const char *value);
43
44extern int init_module(void *, unsigned long, const char *);
45
46static int write_file(const char *path, const char *value)
47{
48    int fd, ret, len;
49
50    fd = open(path, O_WRONLY|O_CREAT, 0622);
51
52    if (fd < 0)
53        return -errno;
54
55    len = strlen(value);
56
57    do {
58        ret = write(fd, value, len);
59    } while (ret < 0 && errno == EINTR);
60
61    close(fd);
62    if (ret < 0) {
63        return -errno;
64    } else {
65        return 0;
66    }
67}
68
69static int insmod(const char *filename, char *options)
70{
71    void *module;
72    unsigned size;
73    int ret;
74
75    module = read_file(filename, &size);
76    if (!module)
77        return -1;
78
79    ret = init_module(module, size, options);
80
81    free(module);
82
83    return ret;
84}
85
86static int setkey(struct kbentry *kbe)
87{
88    int fd, ret;
89
90    fd = open("/dev/tty0", O_RDWR | O_SYNC);
91    if (fd < 0)
92        return -1;
93
94    ret = ioctl(fd, KDSKBENT, kbe);
95
96    close(fd);
97    return ret;
98}
99
100static int __ifupdown(const char *interface, int up)
101{
102    struct ifreq ifr;
103    int s, ret;
104
105    strlcpy(ifr.ifr_name, interface, IFNAMSIZ);
106
107    s = socket(AF_INET, SOCK_DGRAM, 0);
108    if (s < 0)
109        return -1;
110
111    ret = ioctl(s, SIOCGIFFLAGS, &ifr);
112    if (ret < 0) {
113        goto done;
114    }
115
116    if (up)
117        ifr.ifr_flags |= IFF_UP;
118    else
119        ifr.ifr_flags &= ~IFF_UP;
120
121    ret = ioctl(s, SIOCSIFFLAGS, &ifr);
122
123done:
124    close(s);
125    return ret;
126}
127
128static void service_start_if_not_disabled(struct service *svc)
129{
130    if (!(svc->flags & SVC_DISABLED)) {
131        service_start(svc, NULL);
132    }
133}
134
135int do_chdir(int nargs, char **args)
136{
137    chdir(args[1]);
138    return 0;
139}
140
141int do_chroot(int nargs, char **args)
142{
143    chroot(args[1]);
144    return 0;
145}
146
147int do_class_start(int nargs, char **args)
148{
149        /* Starting a class does not start services
150         * which are explicitly disabled.  They must
151         * be started individually.
152         */
153    service_for_each_class(args[1], service_start_if_not_disabled);
154    return 0;
155}
156
157int do_class_stop(int nargs, char **args)
158{
159    service_for_each_class(args[1], service_stop);
160    return 0;
161}
162
163int do_domainname(int nargs, char **args)
164{
165    return write_file("/proc/sys/kernel/domainname", args[1]);
166}
167
168int do_exec(int nargs, char **args)
169{
170    return -1;
171}
172
173int do_export(int nargs, char **args)
174{
175    add_environment(args[1], args[2]);
176    return 0;
177}
178
179int do_hostname(int nargs, char **args)
180{
181    return write_file("/proc/sys/kernel/hostname", args[1]);
182}
183
184int do_ifup(int nargs, char **args)
185{
186    return __ifupdown(args[1], 1);
187}
188
189
190static int do_insmod_inner(int nargs, char **args, int opt_len)
191{
192    char options[opt_len + 1];
193    int i;
194
195    options[0] = '\0';
196    if (nargs > 2) {
197        strcpy(options, args[2]);
198        for (i = 3; i < nargs; ++i) {
199            strcat(options, " ");
200            strcat(options, args[i]);
201        }
202    }
203
204    return insmod(args[1], options);
205}
206
207int do_insmod(int nargs, char **args)
208{
209    int i;
210    int size = 0;
211
212    if (nargs > 2) {
213        for (i = 2; i < nargs; ++i)
214            size += strlen(args[i]) + 1;
215    }
216
217    return do_insmod_inner(nargs, args, size);
218}
219
220int do_import(int nargs, char **args)
221{
222    return parse_config_file(args[1]);
223}
224
225int do_mkdir(int nargs, char **args)
226{
227    mode_t mode = 0755;
228
229    /* mkdir <path> [mode] [owner] [group] */
230
231    if (nargs >= 3) {
232        mode = strtoul(args[2], 0, 8);
233    }
234
235    if (mkdir(args[1], mode)) {
236        return -errno;
237    }
238
239    if (nargs >= 4) {
240        uid_t uid = decode_uid(args[3]);
241        gid_t gid = -1;
242
243        if (nargs == 5) {
244            gid = decode_uid(args[4]);
245        }
246
247        if (chown(args[1], uid, gid)) {
248            return -errno;
249        }
250    }
251
252    return 0;
253}
254
255static struct {
256    const char *name;
257    unsigned flag;
258} mount_flags[] = {
259    { "noatime",    MS_NOATIME },
260    { "nosuid",     MS_NOSUID },
261    { "nodev",      MS_NODEV },
262    { "nodiratime", MS_NODIRATIME },
263    { "ro",         MS_RDONLY },
264    { "rw",         0 },
265    { "remount",    MS_REMOUNT },
266    { "defaults",   0 },
267    { 0,            0 },
268};
269
270/* mount <type> <device> <path> <flags ...> <options> */
271int do_mount(int nargs, char **args)
272{
273    char tmp[64];
274    char *source, *target, *system;
275    char *options = NULL;
276    unsigned flags = 0;
277    int n, i;
278
279    for (n = 4; n < nargs; n++) {
280        for (i = 0; mount_flags[i].name; i++) {
281            if (!strcmp(args[n], mount_flags[i].name)) {
282                flags |= mount_flags[i].flag;
283                break;
284            }
285        }
286
287        /* if our last argument isn't a flag, wolf it up as an option string */
288        if (n + 1 == nargs && !mount_flags[i].name)
289            options = args[n];
290    }
291
292    system = args[1];
293    source = args[2];
294    target = args[3];
295
296    if (!strncmp(source, "mtd@", 4)) {
297        n = mtd_name_to_number(source + 4);
298        if (n < 0) {
299            return -1;
300        }
301
302        sprintf(tmp, "/dev/block/mtdblock%d", n);
303
304        if (mount(tmp, target, system, flags, options) < 0) {
305            return -1;
306        }
307
308        return 0;
309    } else if (!strncmp(source, "loop@", 5)) {
310        int mode, loop, fd;
311        struct loop_info info;
312
313        mode = (flags & MS_RDONLY) ? O_RDONLY : O_RDWR;
314        fd = open(source + 5, mode);
315        if (fd < 0) {
316            return -1;
317        }
318
319        for (n = 0; ; n++) {
320            sprintf(tmp, "/dev/block/loop%d", n);
321            loop = open(tmp, mode);
322            if (loop < 0) {
323                return -1;
324            }
325
326            /* if it is a blank loop device */
327            if (ioctl(loop, LOOP_GET_STATUS, &info) < 0 && errno == ENXIO) {
328                /* if it becomes our loop device */
329                if (ioctl(loop, LOOP_SET_FD, fd) >= 0) {
330                    close(fd);
331
332                    if (mount(tmp, target, system, flags, options) < 0) {
333                        ioctl(loop, LOOP_CLR_FD, 0);
334                        close(loop);
335                        return -1;
336                    }
337
338                    close(loop);
339                    return 0;
340                }
341            }
342
343            close(loop);
344        }
345
346        close(fd);
347        ERROR("out of loopback devices");
348        return -1;
349    } else {
350        if (mount(source, target, system, flags, options) < 0) {
351            return -1;
352        }
353
354        return 0;
355    }
356}
357
358int do_setkey(int nargs, char **args)
359{
360    struct kbentry kbe;
361    kbe.kb_table = strtoul(args[1], 0, 0);
362    kbe.kb_index = strtoul(args[2], 0, 0);
363    kbe.kb_value = strtoul(args[3], 0, 0);
364    return setkey(&kbe);
365}
366
367int do_setprop(int nargs, char **args)
368{
369    property_set(args[1], args[2]);
370    return 0;
371}
372
373int do_setrlimit(int nargs, char **args)
374{
375    struct rlimit limit;
376    int resource;
377    resource = atoi(args[1]);
378    limit.rlim_cur = atoi(args[2]);
379    limit.rlim_max = atoi(args[3]);
380    return setrlimit(resource, &limit);
381}
382
383int do_start(int nargs, char **args)
384{
385    struct service *svc;
386    svc = service_find_by_name(args[1]);
387    if (svc) {
388        service_start(svc, NULL);
389    }
390    return 0;
391}
392
393int do_stop(int nargs, char **args)
394{
395    struct service *svc;
396    svc = service_find_by_name(args[1]);
397    if (svc) {
398        service_stop(svc);
399    }
400    return 0;
401}
402
403int do_restart(int nargs, char **args)
404{
405    struct service *svc;
406    svc = service_find_by_name(args[1]);
407    if (svc) {
408        service_stop(svc);
409        service_start(svc, NULL);
410    }
411    return 0;
412}
413
414int do_trigger(int nargs, char **args)
415{
416    action_for_each_trigger(args[1], action_add_queue_tail);
417    drain_action_queue();
418    return 0;
419}
420
421int do_symlink(int nargs, char **args)
422{
423    return symlink(args[1], args[2]);
424}
425
426int do_sysclktz(int nargs, char **args)
427{
428    struct timezone tz;
429
430    if (nargs != 2)
431        return -1;
432
433    memset(&tz, 0, sizeof(tz));
434    tz.tz_minuteswest = atoi(args[1]);
435    if (settimeofday(NULL, &tz))
436        return -1;
437    return 0;
438}
439
440int do_write(int nargs, char **args)
441{
442    return write_file(args[1], args[2]);
443}
444
445int do_copy(int nargs, char **args)
446{
447    char *buffer = NULL;
448    int rc = 0;
449    int fd1 = -1, fd2 = -1;
450    struct stat info;
451    int brtw, brtr;
452    char *p;
453
454    if (nargs != 3)
455        return -1;
456
457    if (stat(args[1], &info) < 0)
458        return -1;
459
460    if ((fd1 = open(args[1], O_RDONLY)) < 0)
461        goto out_err;
462
463    if ((fd2 = open(args[2], O_WRONLY|O_CREAT|O_TRUNC, 0660)) < 0)
464        goto out_err;
465
466    if (!(buffer = malloc(info.st_size)))
467        goto out_err;
468
469    p = buffer;
470    brtr = info.st_size;
471    while(brtr) {
472        rc = read(fd1, p, brtr);
473        if (rc < 0)
474            goto out_err;
475        if (rc == 0)
476            break;
477        p += rc;
478        brtr -= rc;
479    }
480
481    p = buffer;
482    brtw = info.st_size;
483    while(brtw) {
484        rc = write(fd2, p, brtw);
485        if (rc < 0)
486            goto out_err;
487        if (rc == 0)
488            break;
489        p += rc;
490        brtw -= rc;
491    }
492
493    rc = 0;
494    goto out;
495out_err:
496    rc = -1;
497out:
498    if (buffer)
499        free(buffer);
500    if (fd1 >= 0)
501        close(fd1);
502    if (fd2 >= 0)
503        close(fd2);
504    return rc;
505}
506
507int do_chown(int nargs, char **args) {
508    /* GID is optional. */
509    if (nargs == 3) {
510        if (chown(args[2], decode_uid(args[1]), -1) < 0)
511            return -errno;
512    } else if (nargs == 4) {
513        if (chown(args[3], decode_uid(args[1]), decode_uid(args[2])))
514            return -errno;
515    } else {
516        return -1;
517    }
518    return 0;
519}
520
521static mode_t get_mode(const char *s) {
522    mode_t mode = 0;
523    while (*s) {
524        if (*s >= '0' && *s <= '7') {
525            mode = (mode<<3) | (*s-'0');
526        } else {
527            return -1;
528        }
529        s++;
530    }
531    return mode;
532}
533
534int do_chmod(int nargs, char **args) {
535    mode_t mode = get_mode(args[1]);
536    if (chmod(args[2], mode) < 0) {
537        return -errno;
538    }
539    return 0;
540}
541
542int do_loglevel(int nargs, char **args) {
543    if (nargs == 2) {
544        log_set_level(atoi(args[1]));
545        return 0;
546    }
547    return -1;
548}
549
550int do_device(int nargs, char **args) {
551    int len;
552    char tmp[64];
553    char *source = args[1];
554    int prefix = 0;
555
556    if (nargs != 5)
557        return -1;
558    /* Check for wildcard '*' at the end which indicates a prefix. */
559    len = strlen(args[1]) - 1;
560    if (args[1][len] == '*') {
561        args[1][len] = '\0';
562        prefix = 1;
563    }
564    /* If path starts with mtd@ lookup the mount number. */
565    if (!strncmp(source, "mtd@", 4)) {
566        int n = mtd_name_to_number(source + 4);
567        if (n >= 0) {
568            snprintf(tmp, sizeof(tmp), "/dev/mtd/mtd%d", n);
569            source = tmp;
570        }
571    }
572    add_devperms_partners(source, get_mode(args[2]), decode_uid(args[3]),
573                          decode_uid(args[4]), prefix);
574    return 0;
575}
576