u-tools/apps/busybox/procps/sysctl.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Sysctl 1.01 - A utility to read and manipulate the sysctl parameters
   4  *
   5  * Copyright 1999 George Staikos
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
   8  *
   9  * Changelog:
  10  *      v1.01:
  11  *              - added -p <preload> to preload values from a file
  12  *      v1.01.1
  13  *              - busybox applet aware by <solar@gentoo.org>
  14  *
  15  */
  16
  17 #include "libbb.h"
  18
  19 static int sysctl_read_setting(const char *setting);
  20 static int sysctl_write_setting(const char *setting);
  21 static int sysctl_display_all(const char *path);
  22 static int sysctl_preload_file_and_exit(const char *filename);
  23 static void sysctl_dots_to_slashes(char *name);
  24
  25 static const char ETC_SYSCTL_CONF[] ALIGN1 = "/etc/sysctl.conf";
  26 static const char PROC_SYS[] ALIGN1 = "/proc/sys/";
  27 enum { strlen_PROC_SYS = sizeof(PROC_SYS) - 1 };
  28
  29 static const char msg_unknown_key[] ALIGN1 =
  30         "error: '%s' is an unknown key";
  31
  32 static void dwrite_str(int fd, const char *buf)
  33 {
  34         write(fd, buf, strlen(buf));
  35 }
  36
  37 enum {
  38         FLAG_SHOW_KEYS       = 1 << 0,
  39         FLAG_SHOW_KEY_ERRORS = 1 << 1,
  40         FLAG_TABLE_FORMAT    = 1 << 2, /* not implemented */
  41         FLAG_SHOW_ALL        = 1 << 3,
  42         FLAG_PRELOAD_FILE    = 1 << 4,
  43         FLAG_WRITE           = 1 << 5,
  44 };
  45
  46 int sysctl_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  47 int sysctl_main(int argc UNUSED_PARAM, char **argv)
  48 {
  49         int retval;
  50         int opt;
  51
  52         opt = getopt32(argv, "+neAapw"); /* '+' - stop on first non-option */
  53         argv += optind;
  54         opt ^= (FLAG_SHOW_KEYS | FLAG_SHOW_KEY_ERRORS);
  55         option_mask32 ^= (FLAG_SHOW_KEYS | FLAG_SHOW_KEY_ERRORS);
  56
  57         if (opt & (FLAG_TABLE_FORMAT | FLAG_SHOW_ALL))
  58                 return sysctl_display_all(PROC_SYS);
  59         if (opt & FLAG_PRELOAD_FILE)
  60                 return sysctl_preload_file_and_exit(*argv ? *argv : ETC_SYSCTL_CONF);
  61
  62         retval = 0;
  63         while (*argv) {
  64                 if (opt & FLAG_WRITE)
  65                         retval |= sysctl_write_setting(*argv);
  66                 else
  67                         retval |= sysctl_read_setting(*argv);
  68                 argv++;
  69         }
  70
  71         return retval;
  72 } /* end sysctl_main() */
  73
  74 /* Set sysctl's from a conf file. Format example:
  75  * # Controls IP packet forwarding
  76  * net.ipv4.ip_forward = 0
  77  */
  78 static int sysctl_preload_file_and_exit(const char *filename)
  79 {
  80         char *token[2];
  81         parser_t *parser;
  82
  83         parser = config_open(filename);
  84 // TODO: ';' is comment char too
  85         while (config_read(parser, token, 2, 2, "# \t=", PARSE_NORMAL)) {
  86 #if 0
  87                 char *s = xasprintf("%s=%s", token[0], token[1]);
  88                 sysctl_write_setting(s);
  89                 free(s);
  90 #else /* Save ~4 bytes by using parser internals */
  91                 sprintf(parser->line, "%s=%s", token[0], token[1]); // must have room by definition
  92                 sysctl_write_setting(parser->line);
  93 #endif
  94         }
  95         if (ENABLE_FEATURE_CLEAN_UP)
  96                 config_close(parser);
  97         return 0;
  98 } /* end sysctl_preload_file_and_exit() */
  99
 100 static int sysctl_write_setting(const char *setting)
 101 {
 102         int retval;
 103         const char *name;
 104         const char *value;
 105         const char *equals;
 106         char *tmpname, *outname, *cptr;
 107         int fd;
 108
 109         name = setting;
 110         equals = strchr(setting, '=');
 111         if (!equals) {
 112                 bb_error_msg("error: '%s' must be of the form name=value", setting);
 113                 return EXIT_FAILURE;
 114         }
 115
 116         value = equals + 1;     /* point to the value in name=value */
 117         if (name == equals || !*value) {
 118                 bb_error_msg("error: malformed setting '%s'", setting);
 119                 return EXIT_FAILURE;
 120         }
 121
 122         tmpname = xasprintf("%s%.*s", PROC_SYS, (int)(equals - name), name);
 123         outname = xstrdup(tmpname + strlen_PROC_SYS);
 124
 125         sysctl_dots_to_slashes(tmpname);
 126
 127         while ((cptr = strchr(outname, '/')) != NULL)
 128                 *cptr = '.';
 129
 130         fd = open(tmpname, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 131         if (fd < 0) {
 132                 switch (errno) {
 133                 case ENOENT:
 134                         if (option_mask32 & FLAG_SHOW_KEY_ERRORS)
 135                                 bb_error_msg(msg_unknown_key, outname);
 136                         break;
 137                 default:
 138                         bb_perror_msg("error setting key '%s'", outname);
 139                         break;
 140                 }
 141                 retval = EXIT_FAILURE;
 142         } else {
 143                 dwrite_str(fd, value);
 144                 close(fd);
 145                 if (option_mask32 & FLAG_SHOW_KEYS) {
 146                         printf("%s = ", outname);
 147                 }
 148                 puts(value);
 149                 retval = EXIT_SUCCESS;
 150         }
 151
 152         free(tmpname);
 153         free(outname);
 154         return retval;
 155 } /* end sysctl_write_setting() */
 156
 157 static int sysctl_read_setting(const char *name)
 158 {
 159         int retval;
 160         char *tmpname, *outname, *cptr;
 161         char inbuf[1025];
 162         FILE *fp;
 163
 164         if (!*name) {
 165                 if (option_mask32 & FLAG_SHOW_KEY_ERRORS)
 166                         bb_error_msg(msg_unknown_key, name);
 167                 return -1;
 168         }
 169
 170         tmpname = concat_path_file(PROC_SYS, name);
 171         outname = xstrdup(tmpname + strlen_PROC_SYS);
 172
 173         sysctl_dots_to_slashes(tmpname);
 174
 175         while ((cptr = strchr(outname, '/')) != NULL)
 176                 *cptr = '.';
 177
 178         fp = fopen_for_read(tmpname);
 179         if (fp == NULL) {
 180                 switch (errno) {
 181                 case ENOENT:
 182                         if (option_mask32 & FLAG_SHOW_KEY_ERRORS)
 183                                 bb_error_msg(msg_unknown_key, outname);
 184                         break;
 185                 default:
 186                         bb_perror_msg("error reading key '%s'", outname);
 187                         break;
 188                 }
 189                 retval = EXIT_FAILURE;
 190         } else {
 191                 while (fgets(inbuf, sizeof(inbuf) - 1, fp)) {
 192                         if (option_mask32 & FLAG_SHOW_KEYS) {
 193                                 printf("%s = ", outname);
 194                         }
 195                         fputs(inbuf, stdout);
 196                 }
 197                 fclose(fp);
 198                 retval = EXIT_SUCCESS;
 199         }
 200
 201         free(tmpname);
 202         free(outname);
 203         return retval;
 204 } /* end sysctl_read_setting() */
 205
 206 static int sysctl_display_all(const char *path)
 207 {
 208         int retval = EXIT_SUCCESS;
 209         DIR *dp;
 210         struct dirent *de;
 211         char *tmpdir;
 212         struct stat ts;
 213
 214         dp = opendir(path);
 215         if (!dp) {
 216                 return EXIT_FAILURE;
 217         }
 218         while ((de = readdir(dp)) != NULL) {
 219                 tmpdir = concat_subpath_file(path, de->d_name);
 220                 if (tmpdir == NULL)
 221                         continue; /* . or .. */
 222                 if (stat(tmpdir, &ts) != 0) {
 223                         bb_perror_msg(tmpdir);
 224                 } else if (S_ISDIR(ts.st_mode)) {
 225                         retval |= sysctl_display_all(tmpdir);
 226                 } else {
 227                         retval |= sysctl_read_setting(tmpdir + strlen_PROC_SYS);
 228                 }
 229                 free(tmpdir);
 230         } /* end while */
 231         closedir(dp);
 232
 233         return retval;
 234 } /* end sysctl_display_all() */
 235
 236 static void sysctl_dots_to_slashes(char *name)
 237 {
 238         char *cptr, *last_good, *end;
 239
 240         /* It can be good as-is! */
 241         if (access(name, F_OK) == 0)
 242                 return;
 243
 244         /* Example from bug 3894:
 245          * net.ipv4.conf.eth0.100.mc_forwarding ->
 246          * net/ipv4/conf/eth0.100/mc_forwarding. NB:
 247          * net/ipv4/conf/eth0/mc_forwarding *also exists*,
 248          * therefore we must start from the end, and if
 249          * we replaced even one . -> /, start over again,
 250          * but never replace dots before the position
 251          * where replacement occurred. */
 252         end = name + strlen(name) - 1;
 253         last_good = name - 1;
 254  again:
 255         cptr = end;
 256         while (cptr > last_good) {
 257                 if (*cptr == '.') {
 258                         *cptr = '\0';
 259                         if (access(name, F_OK) == 0) {
 260                                 *cptr = '/';
 261                                 last_good = cptr;
 262                                 goto again;
 263                         }
 264                         *cptr = '.';
 265                 }
 266                 cptr--;
 267         }
 268 } /* end sysctl_dots_to_slashes() */