src/binfmt/binfmt.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <getopt.h>
  24 #include <limits.h>
  25 #include <stdbool.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "alloc-util.h"
  31 #include "conf-files.h"
  32 #include "def.h"
  33 #include "fd-util.h"
  34 #include "fileio.h"
  35 #include "log.h"
  36 #include "string-util.h"
  37 #include "strv.h"
  38 #include "util.h"
  39
  40 static const char conf_file_dirs[] = CONF_PATHS_NULSTR("binfmt.d");
  41
  42 static int delete_rule(const char *rule) {
  43         _cleanup_free_ char *x = NULL, *fn = NULL;
  44         char *e;
  45
  46         assert(rule[0]);
  47
  48         x = strdup(rule);
  49         if (!x)
  50                 return log_oom();
  51
  52         e = strchrnul(x+1, x[0]);
  53         *e = 0;
  54
  55         fn = strappend("/proc/sys/fs/binfmt_misc/", x+1);
  56         if (!fn)
  57                 return log_oom();
  58
  59         return write_string_file(fn, "-1", 0);
  60 }
  61
  62 static int apply_rule(const char *rule) {
  63         int r;
  64
  65         delete_rule(rule);
  66
  67         r = write_string_file("/proc/sys/fs/binfmt_misc/register", rule, 0);
  68         if (r < 0)
  69                 return log_error_errno(r, "Failed to add binary format: %m");
  70
  71         return 0;
  72 }
  73
  74 static int apply_file(const char *path, bool ignore_enoent) {
  75         _cleanup_fclose_ FILE *f = NULL;
  76         int r;
  77
  78         assert(path);
  79
  80         r = search_and_fopen_nulstr(path, "re", NULL, conf_file_dirs, &f);
  81         if (r < 0) {
  82                 if (ignore_enoent && r == -ENOENT)
  83                         return 0;
  84
  85                 return log_error_errno(r, "Failed to open file '%s', ignoring: %m", path);
  86         }
  87
  88         log_debug("apply: %s", path);
  89         for (;;) {
  90                 char l[LINE_MAX], *p;
  91                 int k;
  92
  93                 if (!fgets(l, sizeof(l), f)) {
  94                         if (feof(f))
  95                                 break;
  96
  97                         return log_error_errno(errno, "Failed to read file '%s', ignoring: %m", path);
  98                 }
  99
 100                 p = strstrip(l);
 101                 if (!*p)
 102                         continue;
 103                 if (strchr(COMMENTS "\n", *p))
 104                         continue;
 105
 106                 k = apply_rule(p);
 107                 if (k < 0 && r == 0)
 108                         r = k;
 109         }
 110
 111         return r;
 112 }
 113
 114 static void help(void) {
 115         printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
 116                "Registers binary formats.\n\n"
 117                "  -h --help             Show this help\n"
 118                "     --version          Show package version\n"
 119                , program_invocation_short_name);
 120 }
 121
 122 static int parse_argv(int argc, char *argv[]) {
 123
 124         enum {
 125                 ARG_VERSION = 0x100,
 126         };
 127
 128         static const struct option options[] = {
 129                 { "help",      no_argument,       NULL, 'h'           },
 130                 { "version",   no_argument,       NULL, ARG_VERSION   },
 131                 {}
 132         };
 133
 134         int c;
 135
 136         assert(argc >= 0);
 137         assert(argv);
 138
 139         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 140
 141                 switch (c) {
 142
 143                 case 'h':
 144                         help();
 145                         return 0;
 146
 147                 case ARG_VERSION:
 148                         return version();
 149
 150                 case '?':
 151                         return -EINVAL;
 152
 153                 default:
 154                         assert_not_reached("Unhandled option");
 155                 }
 156
 157         return 1;
 158 }
 159
 160 int main(int argc, char *argv[]) {
 161         int r, k;
 162
 163         r = parse_argv(argc, argv);
 164         if (r <= 0)
 165                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 166
 167         log_set_target(LOG_TARGET_AUTO);
 168         log_parse_environment();
 169         log_open();
 170
 171         umask(0022);
 172
 173         r = 0;
 174
 175         if (argc > optind) {
 176                 int i;
 177
 178                 for (i = optind; i < argc; i++) {
 179                         k = apply_file(argv[i], false);
 180                         if (k < 0 && r == 0)
 181                                 r = k;
 182                 }
 183         } else {
 184                 _cleanup_strv_free_ char **files = NULL;
 185                 char **f;
 186
 187                 r = conf_files_list_nulstr(&files, ".conf", NULL, conf_file_dirs);
 188                 if (r < 0) {
 189                         log_error_errno(r, "Failed to enumerate binfmt.d files: %m");
 190                         goto finish;
 191                 }
 192
 193                 /* Flush out all rules */
 194                 write_string_file("/proc/sys/fs/binfmt_misc/status", "-1", 0);
 195
 196                 STRV_FOREACH(f, files) {
 197                         k = apply_file(*f, true);
 198                         if (k < 0 && r == 0)
 199                                 r = k;
 200                 }
 201         }
 202
 203 finish:
 204         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 205 }