udev_utils.c

   1 /*
   2  * udev_lib - generic stuff used by udev
   3  *
   4  * Copyright (C) 2004 Kay Sievers <kay@vrfy.org>
   5  *
   6  *      This program is free software; you can redistribute it and/or modify it
   7  *      under the terms of the GNU General Public License as published by the
   8  *      Free Software Foundation version 2 of the License.
   9  *
  10  *      This program is distributed in the hope that it will be useful, but
  11  *      WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *      General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License along
  16  *      with this program; if not, write to the Free Software Foundation, Inc.,
  17  *      675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  */
  20
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <stddef.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28 #include <ctype.h>
  29 #include <dirent.h>
  30 #include <syslog.h>
  31 #include <sys/wait.h>
  32 #include <sys/stat.h>
  33 #include <sys/mman.h>
  34 #include <sys/utsname.h>
  35
  36 #include "udev_libc_wrapper.h"
  37 #include "udev.h"
  38 #include "logging.h"
  39 #include "udev_utils.h"
  40 #include "list.h"
  41
  42
  43 int udev_init_device(struct udevice *udev, const char* devpath, const char *subsystem, const char *action)
  44 {
  45         char *pos;
  46
  47         memset(udev, 0x00, sizeof(struct udevice));
  48         INIT_LIST_HEAD(&udev->symlink_list);
  49         INIT_LIST_HEAD(&udev->run_list);
  50
  51         if (subsystem)
  52                 strlcpy(udev->subsystem, subsystem, sizeof(udev->subsystem));
  53
  54         if (action)
  55                 strlcpy(udev->action, action, sizeof(udev->action));
  56
  57         if (devpath) {
  58                 strlcpy(udev->devpath, devpath, sizeof(udev->devpath));
  59                 remove_trailing_char(udev->devpath, '/');
  60
  61                 if (strncmp(udev->devpath, "/block/", 7) == 0)
  62                         udev->type = DEV_BLOCK;
  63                 else if (strncmp(udev->devpath, "/class/net/", 11) == 0)
  64                         udev->type = DEV_NET;
  65                 else if (strncmp(udev->devpath, "/class/", 7) == 0)
  66                         udev->type = DEV_CLASS;
  67                 else if (strncmp(udev->devpath, "/devices/", 9) == 0)
  68                         udev->type = DEV_DEVICE;
  69
  70                 /* get kernel name */
  71                 pos = strrchr(udev->devpath, '/');
  72                 if (pos) {
  73                         strlcpy(udev->kernel_name, &pos[1], sizeof(udev->kernel_name));
  74                         dbg("kernel_name='%s'", udev->kernel_name);
  75
  76                         /* Some block devices have '!' in their name, change that to '/' */
  77                         pos = udev->kernel_name;
  78                         while (pos[0] != '\0') {
  79                                 if (pos[0] == '!')
  80                                         pos[0] = '/';
  81                                 pos++;
  82                         }
  83
  84                         /* get kernel number */
  85                         pos = &udev->kernel_name[strlen(udev->kernel_name)];
  86                         while (isdigit(pos[-1]))
  87                                 pos--;
  88                         strlcpy(udev->kernel_number, pos, sizeof(udev->kernel_number));
  89                         dbg("kernel_number='%s'", udev->kernel_number);
  90                 }
  91         }
  92
  93         if (udev->type == DEV_BLOCK || udev->type == DEV_CLASS) {
  94                 udev->mode = 0660;
  95                 strcpy(udev->owner, "root");
  96                 strcpy(udev->group, "root");
  97         }
  98
  99         return 0;
 100 }
 101
 102 void udev_cleanup_device(struct udevice *udev)
 103 {
 104         struct name_entry *name_loop;
 105         struct name_entry *temp_loop;
 106
 107         list_for_each_entry_safe(name_loop, temp_loop, &udev->symlink_list, node) {
 108                 list_del(&name_loop->node);
 109                 free(name_loop);
 110         }
 111         list_for_each_entry_safe(name_loop, temp_loop, &udev->run_list, node) {
 112                 list_del(&name_loop->node);
 113                 free(name_loop);
 114         }
 115 }
 116
 117 int string_is_true(const char *str)
 118 {
 119         if (strcasecmp(str, "true") == 0)
 120                 return 1;
 121         if (strcasecmp(str, "yes") == 0)
 122                 return 1;
 123         if (strcasecmp(str, "1") == 0)
 124                 return 1;
 125         return 0;
 126 }
 127
 128 int log_priority(const char *priority)
 129 {
 130         char *endptr;
 131         int prio;
 132
 133         prio = strtol(priority, &endptr, 10);
 134         if (endptr[0] == '\0')
 135                 return prio;
 136         if (strncasecmp(priority, "err", 3) == 0)
 137                 return LOG_ERR;
 138         if (strcasecmp(priority, "info") == 0)
 139                 return LOG_INFO;
 140         if (strcasecmp(priority, "debug") == 0)
 141                 return LOG_DEBUG;
 142         if (string_is_true(priority))
 143                 return LOG_ERR;
 144
 145         return 0;
 146 }
 147
 148 int kernel_release_satisfactory(unsigned int version, unsigned int patchlevel, unsigned int sublevel)
 149 {
 150         static unsigned int kversion = 0;
 151         static unsigned int kpatchlevel;
 152         static unsigned int ksublevel;
 153
 154         if (kversion == 0) {
 155                 struct utsname uts;
 156                 if (uname(&uts) != 0)
 157                         return -1;
 158
 159                 if (sscanf (uts.release, "%u.%u.%u", &kversion, &kpatchlevel, &ksublevel) != 3) {
 160                         kversion = 0;
 161                         return -1;
 162                 }
 163         }
 164
 165         if (kversion >= version && kpatchlevel >= patchlevel && ksublevel >= sublevel)
 166                 return 1;
 167         else
 168                 return 0;
 169 }
 170
 171 int create_path(const char *path)
 172 {
 173         char p[PATH_SIZE];
 174         char *pos;
 175         struct stat stats;
 176
 177         strcpy (p, path);
 178         pos = strrchr(p, '/');
 179         if (pos == p || pos == NULL)
 180                 return 0;
 181
 182         while (pos[-1] == '/')
 183                 pos--;
 184
 185         pos[0] = '\0';
 186
 187         dbg("stat '%s'\n", p);
 188         if (stat (p, &stats) == 0 && (stats.st_mode & S_IFMT) == S_IFDIR)
 189                 return 0;
 190
 191         if (create_path (p) != 0)
 192                 return -1;
 193
 194         dbg("mkdir '%s'\n", p);
 195         return mkdir(p, 0755);
 196 }
 197
 198 /* Reset permissions on the device node, before unlinking it to make sure,
 199  * that permisions of possible hard links will be removed too.
 200  */
 201 int unlink_secure(const char *filename)
 202 {
 203         int retval;
 204
 205         retval = chown(filename, 0, 0);
 206         if (retval)
 207                 dbg("chown(%s, 0, 0) failed with error '%s'", filename, strerror(errno));
 208
 209         retval = chmod(filename, 0000);
 210         if (retval)
 211                 dbg("chmod(%s, 0000) failed with error '%s'", filename, strerror(errno));
 212
 213         retval = unlink(filename);
 214         if (errno == ENOENT)
 215                 retval = 0;
 216
 217         if (retval)
 218                 dbg("unlink(%s) failed with error '%s'", filename, strerror(errno));
 219
 220         return retval;
 221 }
 222
 223 int file_map(const char *filename, char **buf, size_t *bufsize)
 224 {
 225         struct stat stats;
 226         int fd;
 227
 228         fd = open(filename, O_RDONLY);
 229         if (fd < 0) {
 230                 return -1;
 231         }
 232
 233         if (fstat(fd, &stats) < 0) {
 234                 close(fd);
 235                 return -1;
 236         }
 237
 238         *buf = mmap(NULL, stats.st_size, PROT_READ, MAP_SHARED, fd, 0);
 239         if (*buf == MAP_FAILED) {
 240                 close(fd);
 241                 return -1;
 242         }
 243         *bufsize = stats.st_size;
 244
 245         close(fd);
 246
 247         return 0;
 248 }
 249
 250 void file_unmap(void *buf, size_t bufsize)
 251 {
 252         munmap(buf, bufsize);
 253 }
 254
 255 /* return number of chars until the next newline, skip escaped newline */
 256 size_t buf_get_line(const char *buf, size_t buflen, size_t cur)
 257 {
 258         int escape = 0;
 259         size_t count;
 260
 261         for (count = cur; count < buflen; count++) {
 262                 if (!escape && buf[count] == '\n')
 263                         break;
 264
 265                 if (buf[count] == '\\')
 266                         escape = 1;
 267                 else
 268                         escape = 0;
 269         }
 270
 271         return count - cur;
 272 }
 273
 274 void replace_untrusted_chars(char *string)
 275 {
 276         size_t len;
 277
 278         for (len = 0; string[len] != '\0'; len++) {
 279                 if (strchr(";,~\\()\'", string[len])) {
 280                         info("replace '%c' in '%s'", string[len], string);
 281                         string[len] = '_';
 282                 }
 283         }
 284 }
 285
 286 void remove_trailing_char(char *path, char c)
 287 {
 288         size_t len;
 289
 290         len = strlen(path);
 291         while (len > 0 && path[len-1] == c)
 292                 path[--len] = '\0';
 293 }
 294
 295 int name_list_add(struct list_head *name_list, const char *name, int sort)
 296 {
 297         struct name_entry *loop_name;
 298         struct name_entry *new_name;
 299
 300         list_for_each_entry(loop_name, name_list, node) {
 301                 /* avoid doubles */
 302                 if (strcmp(loop_name->name, name) == 0) {
 303                         dbg("'%s' is already in the list", name);
 304                         return 0;
 305                 }
 306                 if (sort && strcmp(loop_name->name, name) > 0)
 307                         break;
 308         }
 309
 310         new_name = malloc(sizeof(struct name_entry));
 311         if (new_name == NULL) {
 312                 dbg("error malloc");
 313                 return -ENOMEM;
 314         }
 315
 316         strlcpy(new_name->name, name, sizeof(new_name->name));
 317         list_add_tail(&new_name->node, &loop_name->node);
 318
 319         return 0;
 320 }
 321
 322 /* calls function for every file found in specified directory */
 323 int add_matching_files(struct list_head *name_list, const char *dirname, const char *suffix)
 324 {
 325         struct dirent *ent;
 326         DIR *dir;
 327         char *ext;
 328         char filename[PATH_SIZE];
 329
 330         dbg("open directory '%s'", dirname);
 331         dir = opendir(dirname);
 332         if (dir == NULL) {
 333                 dbg("unable to open '%s'", dirname);
 334                 return -1;
 335         }
 336
 337         while (1) {
 338                 ent = readdir(dir);
 339                 if (ent == NULL || ent->d_name[0] == '\0')
 340                         break;
 341
 342                 if ((ent->d_name[0] == '.') || (ent->d_name[0] == COMMENT_CHARACTER))
 343                         continue;
 344
 345                 /* look for file matching with specified suffix */
 346                 ext = strrchr(ent->d_name, '.');
 347                 if (ext == NULL)
 348                         continue;
 349
 350                 if (strcmp(ext, suffix) != 0)
 351                         continue;
 352
 353                 dbg("put file '%s/%s' in list", dirname, ent->d_name);
 354
 355                 snprintf(filename, sizeof(filename), "%s/%s", dirname, ent->d_name);
 356                 filename[sizeof(filename)-1] = '\0';
 357                 name_list_add(name_list, filename, 1);
 358         }
 359
 360         closedir(dir);
 361         return 0;
 362 }
 363
 364 int execute_command(const char *command, const char *subsystem)
 365 {
 366         int retval;
 367         pid_t pid;
 368         char arg[PATH_SIZE];
 369         char *argv[(PATH_SIZE / 2) + 1];
 370         char *pos;
 371         int devnull;
 372         int i;
 373
 374         strlcpy(arg, command, sizeof(arg));
 375         i = 0;
 376         if (strchr(arg, ' ')) {
 377                 pos = arg;
 378                 while (pos != NULL) {
 379                         if (pos[0] == '\'') {
 380                                 /* don't separate if in apostrophes */
 381                                 pos++;
 382                                 argv[i] = strsep(&pos, "\'");
 383                                 while (pos && pos[0] == ' ')
 384                                         pos++;
 385                         } else {
 386                                 argv[i] = strsep(&pos, " ");
 387                         }
 388                         dbg("arg[%i] '%s'", i, argv[i]);
 389                         i++;
 390                 }
 391                 argv[i] =  NULL;
 392                 dbg("execute '%s' with parsed arguments", arg);
 393         } else {
 394                 argv[0] = arg;
 395                 argv[1] = (char *) subsystem;
 396                 argv[2] = NULL;
 397                 dbg("execute '%s' with subsystem '%s' argument", arg, argv[1]);
 398         }
 399
 400         pid = fork();
 401         switch (pid) {
 402         case 0:
 403                 /* child */
 404                 devnull = open("/dev/null", O_RDWR);
 405                 if (devnull >= 0) {
 406                         dup2(devnull, STDIN_FILENO);
 407                         dup2(devnull, STDOUT_FILENO);
 408                         dup2(devnull, STDERR_FILENO);
 409                         close(devnull);
 410                 }
 411                 retval = execv(arg, argv);
 412                 err("exec of child '%s' failed", command);
 413                 _exit(1);
 414         case -1:
 415                 dbg("fork of child '%s' failed", command);
 416                 break;
 417                 return -1;
 418         default:
 419                 waitpid(pid, NULL, 0);
 420         }
 421
 422         return 0;
 423 }