Home | History | Annotate | Download | only in init
      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 <stdarg.h>
     18 #include <stdlib.h>
     19 #include <stdio.h>
     20 #include <string.h>
     21 #include <fcntl.h>
     22 #include <ctype.h>
     23 #include <errno.h>
     24 #include <time.h>
     25 
     26 #ifdef HAVE_SELINUX
     27 #include <selinux/label.h>
     28 #endif
     29 
     30 #include <sys/stat.h>
     31 #include <sys/types.h>
     32 #include <sys/socket.h>
     33 #include <sys/un.h>
     34 
     35 /* for ANDROID_SOCKET_* */
     36 #include <cutils/sockets.h>
     37 
     38 #include <private/android_filesystem_config.h>
     39 
     40 #include "init.h"
     41 #include "log.h"
     42 #include "util.h"
     43 
     44 /*
     45  * android_name_to_id - returns the integer uid/gid associated with the given
     46  * name, or -1U on error.
     47  */
     48 static unsigned int android_name_to_id(const char *name)
     49 {
     50     const struct android_id_info *info = android_ids;
     51     unsigned int n;
     52 
     53     for (n = 0; n < android_id_count; n++) {
     54         if (!strcmp(info[n].name, name))
     55             return info[n].aid;
     56     }
     57 
     58     return -1U;
     59 }
     60 
     61 /*
     62  * decode_uid - decodes and returns the given string, which can be either the
     63  * numeric or name representation, into the integer uid or gid. Returns -1U on
     64  * error.
     65  */
     66 unsigned int decode_uid(const char *s)
     67 {
     68     unsigned int v;
     69 
     70     if (!s || *s == '\0')
     71         return -1U;
     72     if (isalpha(s[0]))
     73         return android_name_to_id(s);
     74 
     75     errno = 0;
     76     v = (unsigned int) strtoul(s, 0, 0);
     77     if (errno)
     78         return -1U;
     79     return v;
     80 }
     81 
     82 /*
     83  * create_socket - creates a Unix domain socket in ANDROID_SOCKET_DIR
     84  * ("/dev/socket") as dictated in init.rc. This socket is inherited by the
     85  * daemon. We communicate the file descriptor's value via the environment
     86  * variable ANDROID_SOCKET_ENV_PREFIX<name> ("ANDROID_SOCKET_foo").
     87  */
     88 int create_socket(const char *name, int type, mode_t perm, uid_t uid, gid_t gid)
     89 {
     90     struct sockaddr_un addr;
     91     int fd, ret;
     92 #ifdef HAVE_SELINUX
     93     char *secon;
     94 #endif
     95 
     96     fd = socket(PF_UNIX, type, 0);
     97     if (fd < 0) {
     98         ERROR("Failed to open socket '%s': %s\n", name, strerror(errno));
     99         return -1;
    100     }
    101 
    102     memset(&addr, 0 , sizeof(addr));
    103     addr.sun_family = AF_UNIX;
    104     snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR"/%s",
    105              name);
    106 
    107     ret = unlink(addr.sun_path);
    108     if (ret != 0 && errno != ENOENT) {
    109         ERROR("Failed to unlink old socket '%s': %s\n", name, strerror(errno));
    110         goto out_close;
    111     }
    112 
    113 #ifdef HAVE_SELINUX
    114     secon = NULL;
    115     if (sehandle) {
    116         ret = selabel_lookup(sehandle, &secon, addr.sun_path, S_IFSOCK);
    117         if (ret == 0)
    118             setfscreatecon(secon);
    119     }
    120 #endif
    121 
    122     ret = bind(fd, (struct sockaddr *) &addr, sizeof (addr));
    123     if (ret) {
    124         ERROR("Failed to bind socket '%s': %s\n", name, strerror(errno));
    125         goto out_unlink;
    126     }
    127 
    128 #ifdef HAVE_SELINUX
    129     setfscreatecon(NULL);
    130     freecon(secon);
    131 #endif
    132 
    133     chown(addr.sun_path, uid, gid);
    134     chmod(addr.sun_path, perm);
    135 
    136     INFO("Created socket '%s' with mode '%o', user '%d', group '%d'\n",
    137          addr.sun_path, perm, uid, gid);
    138 
    139     return fd;
    140 
    141 out_unlink:
    142     unlink(addr.sun_path);
    143 out_close:
    144     close(fd);
    145     return -1;
    146 }
    147 
    148 /* reads a file, making sure it is terminated with \n \0 */
    149 void *read_file(const char *fn, unsigned *_sz)
    150 {
    151     char *data;
    152     int sz;
    153     int fd;
    154     struct stat sb;
    155 
    156     data = 0;
    157     fd = open(fn, O_RDONLY);
    158     if(fd < 0) return 0;
    159 
    160     // for security reasons, disallow world-writable
    161     // or group-writable files
    162     if (fstat(fd, &sb) < 0) {
    163         ERROR("fstat failed for '%s'\n", fn);
    164         goto oops;
    165     }
    166     if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
    167         ERROR("skipping insecure file '%s'\n", fn);
    168         goto oops;
    169     }
    170 
    171     sz = lseek(fd, 0, SEEK_END);
    172     if(sz < 0) goto oops;
    173 
    174     if(lseek(fd, 0, SEEK_SET) != 0) goto oops;
    175 
    176     data = (char*) malloc(sz + 2);
    177     if(data == 0) goto oops;
    178 
    179     if(read(fd, data, sz) != sz) goto oops;
    180     close(fd);
    181     data[sz] = '\n';
    182     data[sz+1] = 0;
    183     if(_sz) *_sz = sz;
    184     return data;
    185 
    186 oops:
    187     close(fd);
    188     if(data != 0) free(data);
    189     return 0;
    190 }
    191 
    192 #define MAX_MTD_PARTITIONS 16
    193 
    194 static struct {
    195     char name[16];
    196     int number;
    197 } mtd_part_map[MAX_MTD_PARTITIONS];
    198 
    199 static int mtd_part_count = -1;
    200 
    201 static void find_mtd_partitions(void)
    202 {
    203     int fd;
    204     char buf[1024];
    205     char *pmtdbufp;
    206     ssize_t pmtdsize;
    207     int r;
    208 
    209     fd = open("/proc/mtd", O_RDONLY);
    210     if (fd < 0)
    211         return;
    212 
    213     buf[sizeof(buf) - 1] = '\0';
    214     pmtdsize = read(fd, buf, sizeof(buf) - 1);
    215     pmtdbufp = buf;
    216     while (pmtdsize > 0) {
    217         int mtdnum, mtdsize, mtderasesize;
    218         char mtdname[16];
    219         mtdname[0] = '\0';
    220         mtdnum = -1;
    221         r = sscanf(pmtdbufp, "mtd%d: %x %x %15s",
    222                    &mtdnum, &mtdsize, &mtderasesize, mtdname);
    223         if ((r == 4) && (mtdname[0] == '"')) {
    224             char *x = strchr(mtdname + 1, '"');
    225             if (x) {
    226                 *x = 0;
    227             }
    228             INFO("mtd partition %d, %s\n", mtdnum, mtdname + 1);
    229             if (mtd_part_count < MAX_MTD_PARTITIONS) {
    230                 strcpy(mtd_part_map[mtd_part_count].name, mtdname + 1);
    231                 mtd_part_map[mtd_part_count].number = mtdnum;
    232                 mtd_part_count++;
    233             } else {
    234                 ERROR("too many mtd partitions\n");
    235             }
    236         }
    237         while (pmtdsize > 0 && *pmtdbufp != '\n') {
    238             pmtdbufp++;
    239             pmtdsize--;
    240         }
    241         if (pmtdsize > 0) {
    242             pmtdbufp++;
    243             pmtdsize--;
    244         }
    245     }
    246     close(fd);
    247 }
    248 
    249 int mtd_name_to_number(const char *name)
    250 {
    251     int n;
    252     if (mtd_part_count < 0) {
    253         mtd_part_count = 0;
    254         find_mtd_partitions();
    255     }
    256     for (n = 0; n < mtd_part_count; n++) {
    257         if (!strcmp(name, mtd_part_map[n].name)) {
    258             return mtd_part_map[n].number;
    259         }
    260     }
    261     return -1;
    262 }
    263 
    264 /*
    265  * gettime() - returns the time in seconds of the system's monotonic clock or
    266  * zero on error.
    267  */
    268 time_t gettime(void)
    269 {
    270     struct timespec ts;
    271     int ret;
    272 
    273     ret = clock_gettime(CLOCK_MONOTONIC, &ts);
    274     if (ret < 0) {
    275         ERROR("clock_gettime(CLOCK_MONOTONIC) failed: %s\n", strerror(errno));
    276         return 0;
    277     }
    278 
    279     return ts.tv_sec;
    280 }
    281 
    282 int mkdir_recursive(const char *pathname, mode_t mode)
    283 {
    284     char buf[128];
    285     const char *slash;
    286     const char *p = pathname;
    287     int width;
    288     int ret;
    289     struct stat info;
    290 
    291     while ((slash = strchr(p, '/')) != NULL) {
    292         width = slash - pathname;
    293         p = slash + 1;
    294         if (width < 0)
    295             break;
    296         if (width == 0)
    297             continue;
    298         if ((unsigned int)width > sizeof(buf) - 1) {
    299             ERROR("path too long for mkdir_recursive\n");
    300             return -1;
    301         }
    302         memcpy(buf, pathname, width);
    303         buf[width] = 0;
    304         if (stat(buf, &info) != 0) {
    305             ret = make_dir(buf, mode);
    306             if (ret && errno != EEXIST)
    307                 return ret;
    308         }
    309     }
    310     ret = make_dir(pathname, mode);
    311     if (ret && errno != EEXIST)
    312         return ret;
    313     return 0;
    314 }
    315 
    316 void sanitize(char *s)
    317 {
    318     if (!s)
    319         return;
    320     while (isalnum(*s))
    321         s++;
    322     *s = 0;
    323 }
    324 void make_link(const char *oldpath, const char *newpath)
    325 {
    326     int ret;
    327     char buf[256];
    328     char *slash;
    329     int width;
    330 
    331     slash = strrchr(newpath, '/');
    332     if (!slash)
    333         return;
    334     width = slash - newpath;
    335     if (width <= 0 || width > (int)sizeof(buf) - 1)
    336         return;
    337     memcpy(buf, newpath, width);
    338     buf[width] = 0;
    339     ret = mkdir_recursive(buf, 0755);
    340     if (ret)
    341         ERROR("Failed to create directory %s: %s (%d)\n", buf, strerror(errno), errno);
    342 
    343     ret = symlink(oldpath, newpath);
    344     if (ret && errno != EEXIST)
    345         ERROR("Failed to symlink %s to %s: %s (%d)\n", oldpath, newpath, strerror(errno), errno);
    346 }
    347 
    348 void remove_link(const char *oldpath, const char *newpath)
    349 {
    350     char path[256];
    351     ssize_t ret;
    352     ret = readlink(newpath, path, sizeof(path) - 1);
    353     if (ret <= 0)
    354         return;
    355     path[ret] = 0;
    356     if (!strcmp(path, oldpath))
    357         unlink(newpath);
    358 }
    359 
    360 int wait_for_file(const char *filename, int timeout)
    361 {
    362     struct stat info;
    363     time_t timeout_time = gettime() + timeout;
    364     int ret = -1;
    365 
    366     while (gettime() < timeout_time && ((ret = stat(filename, &info)) < 0))
    367         usleep(10000);
    368 
    369     return ret;
    370 }
    371 
    372 void open_devnull_stdio(void)
    373 {
    374     int fd;
    375     static const char *name = "/dev/__null__";
    376     if (mknod(name, S_IFCHR | 0600, (1 << 8) | 3) == 0) {
    377         fd = open(name, O_RDWR);
    378         unlink(name);
    379         if (fd >= 0) {
    380             dup2(fd, 0);
    381             dup2(fd, 1);
    382             dup2(fd, 2);
    383             if (fd > 2) {
    384                 close(fd);
    385             }
    386             return;
    387         }
    388     }
    389 
    390     exit(1);
    391 }
    392 
    393 void get_hardware_name(char *hardware, unsigned int *revision)
    394 {
    395     char data[1024];
    396     int fd, n;
    397     char *x, *hw, *rev;
    398 
    399     /* Hardware string was provided on kernel command line */
    400     if (hardware[0])
    401         return;
    402 
    403     fd = open("/proc/cpuinfo", O_RDONLY);
    404     if (fd < 0) return;
    405 
    406     n = read(fd, data, 1023);
    407     close(fd);
    408     if (n < 0) return;
    409 
    410     data[n] = 0;
    411     hw = strstr(data, "\nHardware");
    412     rev = strstr(data, "\nRevision");
    413 
    414     if (hw) {
    415         x = strstr(hw, ": ");
    416         if (x) {
    417             x += 2;
    418             n = 0;
    419             while (*x && *x != '\n') {
    420                 if (!isspace(*x))
    421                     hardware[n++] = tolower(*x);
    422                 x++;
    423                 if (n == 31) break;
    424             }
    425             hardware[n] = 0;
    426         }
    427     }
    428 
    429     if (rev) {
    430         x = strstr(rev, ": ");
    431         if (x) {
    432             *revision = strtoul(x + 2, 0, 16);
    433         }
    434     }
    435 }
    436 
    437 void import_kernel_cmdline(int in_qemu,
    438                            void (*import_kernel_nv)(char *name, int in_qemu))
    439 {
    440     char cmdline[1024];
    441     char *ptr;
    442     int fd;
    443 
    444     fd = open("/proc/cmdline", O_RDONLY);
    445     if (fd >= 0) {
    446         int n = read(fd, cmdline, 1023);
    447         if (n < 0) n = 0;
    448 
    449         /* get rid of trailing newline, it happens */
    450         if (n > 0 && cmdline[n-1] == '\n') n--;
    451 
    452         cmdline[n] = 0;
    453         close(fd);
    454     } else {
    455         cmdline[0] = 0;
    456     }
    457 
    458     ptr = cmdline;
    459     while (ptr && *ptr) {
    460         char *x = strchr(ptr, ' ');
    461         if (x != 0) *x++ = 0;
    462         import_kernel_nv(ptr, in_qemu);
    463         ptr = x;
    464     }
    465 }
    466 
    467 int make_dir(const char *path, mode_t mode)
    468 {
    469     int rc;
    470 
    471 #ifdef HAVE_SELINUX
    472     char *secontext = NULL;
    473 
    474     if (sehandle) {
    475         selabel_lookup(sehandle, &secontext, path, mode);
    476         setfscreatecon(secontext);
    477     }
    478 #endif
    479 
    480     rc = mkdir(path, mode);
    481 
    482 #ifdef HAVE_SELINUX
    483     if (secontext) {
    484         int save_errno = errno;
    485         freecon(secontext);
    486         setfscreatecon(NULL);
    487         errno = save_errno;
    488     }
    489 #endif
    490     return rc;
    491 }
    492 
    493 int restorecon(const char *pathname)
    494 {
    495 #ifdef HAVE_SELINUX
    496     char *secontext = NULL;
    497     struct stat sb;
    498     int i;
    499 
    500     if (is_selinux_enabled() <= 0 || !sehandle)
    501         return 0;
    502 
    503     if (lstat(pathname, &sb) < 0)
    504         return -errno;
    505     if (selabel_lookup(sehandle, &secontext, pathname, sb.st_mode) < 0)
    506         return -errno;
    507     if (lsetfilecon(pathname, secontext) < 0) {
    508         freecon(secontext);
    509         return -errno;
    510     }
    511     freecon(secontext);
    512 #endif
    513     return 0;
    514 }
    515