libudev/libudev-util-private.c

   1 /*
   2  * libudev - interface to udev device information
   3  *
   4  * Copyright (C) 2003-2009 Kay Sievers <kay.sievers@vrfy.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <stddef.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <fcntl.h>
  18 #include <errno.h>
  19 #include <ctype.h>
  20 #include <pwd.h>
  21 #include <grp.h>
  22 #include <sys/prctl.h>
  23 #include <sys/epoll.h>
  24 #include <sys/wait.h>
  25 #include <sys/param.h>
  26
  27 #include "libudev.h"
  28 #include "libudev-private.h"
  29
  30 static int create_path(struct udev *udev, const char *path, bool selinux)
  31 {
  32         char p[UTIL_PATH_SIZE];
  33         char *pos;
  34         struct stat stats;
  35         int err;
  36
  37         util_strscpy(p, sizeof(p), path);
  38         pos = strrchr(p, '/');
  39         if (pos == NULL)
  40                 return 0;
  41         while (pos != p && pos[-1] == '/')
  42                 pos--;
  43         if (pos == p)
  44                 return 0;
  45         pos[0] = '\0';
  46
  47         dbg(udev, "stat '%s'\n", p);
  48         if (stat(p, &stats) == 0) {
  49                 if ((stats.st_mode & S_IFMT) == S_IFDIR)
  50                         return 0;
  51                 else
  52                         return -ENOTDIR;
  53         }
  54
  55         err = util_create_path(udev, p);
  56         if (err != 0)
  57                 return err;
  58
  59         dbg(udev, "mkdir '%s'\n", p);
  60         if (selinux)
  61                 udev_selinux_setfscreatecon(udev, p, S_IFDIR|0755);
  62         err = mkdir(p, 0755);
  63         if (err != 0) {
  64                 err = -errno;
  65                 if (err == -EEXIST && stat(p, &stats) == 0) {
  66                         if ((stats.st_mode & S_IFMT) == S_IFDIR)
  67                                 err = 0;
  68                         else
  69                                 err = -ENOTDIR;
  70                 }
  71         }
  72         if (selinux)
  73                 udev_selinux_resetfscreatecon(udev);
  74         return err;
  75 }
  76
  77 int util_create_path(struct udev *udev, const char *path)
  78 {
  79         return create_path(udev, path, false);
  80 }
  81
  82 int util_create_path_selinux(struct udev *udev, const char *path)
  83 {
  84         return create_path(udev, path, true);
  85 }
  86
  87 int util_delete_path(struct udev *udev, const char *path)
  88 {
  89         char p[UTIL_PATH_SIZE];
  90         char *pos;
  91         int err = 0;
  92
  93         if (path[0] == '/')
  94                 while(path[1] == '/')
  95                         path++;
  96         util_strscpy(p, sizeof(p), path);
  97         pos = strrchr(p, '/');
  98         if (pos == p || pos == NULL)
  99                 return 0;
 100
 101         for (;;) {
 102                 *pos = '\0';
 103                 pos = strrchr(p, '/');
 104
 105                 /* don't remove the last one */
 106                 if ((pos == p) || (pos == NULL))
 107                         break;
 108
 109                 err = rmdir(p);
 110                 if (err < 0) {
 111                         if (errno == ENOENT)
 112                                 err = 0;
 113                         break;
 114                 }
 115         }
 116         return err;
 117 }
 118
 119 /* Reset permissions on the device node, before unlinking it to make sure,
 120  * that permissions of possible hard links will be removed too.
 121  */
 122 int util_unlink_secure(struct udev *udev, const char *filename)
 123 {
 124         int err;
 125
 126         chown(filename, 0, 0);
 127         chmod(filename, 0000);
 128         err = unlink(filename);
 129         if (errno == ENOENT)
 130                 err = 0;
 131         if (err)
 132                 err(udev, "unlink(%s) failed: %m\n", filename);
 133         return err;
 134 }
 135
 136 uid_t util_lookup_user(struct udev *udev, const char *user)
 137 {
 138         char *endptr;
 139         size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 140         char buf[buflen];
 141         struct passwd pwbuf;
 142         struct passwd *pw;
 143         uid_t uid;
 144
 145         if (strcmp(user, "root") == 0)
 146                 return 0;
 147         uid = strtoul(user, &endptr, 10);
 148         if (endptr[0] == '\0')
 149                 return uid;
 150
 151         errno = getpwnam_r(user, &pwbuf, buf, buflen, &pw);
 152         if (pw != NULL)
 153                 return pw->pw_uid;
 154         if (errno == 0 || errno == ENOENT || errno == ESRCH)
 155                 err(udev, "specified user '%s' unknown\n", user);
 156         else
 157                 err(udev, "error resolving user '%s': %m\n", user);
 158         return 0;
 159 }
 160
 161 gid_t util_lookup_group(struct udev *udev, const char *group)
 162 {
 163         char *endptr;
 164         size_t buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
 165         char *buf;
 166         struct group grbuf;
 167         struct group *gr;
 168         gid_t gid = 0;
 169
 170         if (strcmp(group, "root") == 0)
 171                 return 0;
 172         gid = strtoul(group, &endptr, 10);
 173         if (endptr[0] == '\0')
 174                 return gid;
 175         buf = NULL;
 176         gid = 0;
 177         for (;;) {
 178                 char *newbuf;
 179
 180                 newbuf = realloc(buf, buflen);
 181                 if (!newbuf)
 182                         break;
 183                 buf = newbuf;
 184                 errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
 185                 if (gr != NULL) {
 186                         gid = gr->gr_gid;
 187                 } else if (errno == ERANGE) {
 188                         buflen *= 2;
 189                         continue;
 190                 } else if (errno == 0 || errno == ENOENT || errno == ESRCH) {
 191                         err(udev, "specified group '%s' unknown\n", group);
 192                 } else {
 193                         err(udev, "error resolving group '%s': %m\n", group);
 194                 }
 195                 break;
 196         }
 197         free(buf);
 198         return gid;
 199 }
 200
 201 /* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
 202 int util_resolve_subsys_kernel(struct udev *udev, const char *string,
 203                                char *result, size_t maxsize, int read_value)
 204 {
 205         char temp[UTIL_PATH_SIZE];
 206         char *subsys;
 207         char *sysname;
 208         struct udev_device *dev;
 209         char *attr;
 210
 211         if (string[0] != '[')
 212                 return -1;
 213
 214         util_strscpy(temp, sizeof(temp), string);
 215
 216         subsys = &temp[1];
 217
 218         sysname = strchr(subsys, '/');
 219         if (sysname == NULL)
 220                 return -1;
 221         sysname[0] = '\0';
 222         sysname = &sysname[1];
 223
 224         attr = strchr(sysname, ']');
 225         if (attr == NULL)
 226                 return -1;
 227         attr[0] = '\0';
 228         attr = &attr[1];
 229         if (attr[0] == '/')
 230                 attr = &attr[1];
 231         if (attr[0] == '\0')
 232                 attr = NULL;
 233
 234         if (read_value && attr == NULL)
 235                 return -1;
 236
 237         dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
 238         if (dev == NULL)
 239                 return -1;
 240
 241         if (read_value) {
 242                 const char *val;
 243
 244                 val = udev_device_get_sysattr_value(dev, attr);
 245                 if (val != NULL)
 246                         util_strscpy(result, maxsize, val);
 247                 else
 248                         result[0] = '\0';
 249                 info(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
 250         } else {
 251                 size_t l;
 252                 char *s;
 253
 254                 s = result;
 255                 l = util_strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
 256                 if (attr != NULL)
 257                         util_strpcpyl(&s, l, "/", attr, NULL);
 258                 info(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
 259         }
 260         udev_device_unref(dev);
 261         return 0;
 262 }
 263
 264 static int run_program_exec(struct udev *udev, int fd_stdout, int fd_stderr,
 265                             char *const argv[], char **envp, const sigset_t *sigmask)
 266 {
 267         int err;
 268         int fd;
 269
 270         /* discard child output or connect to pipe */
 271         fd = open("/dev/null", O_RDWR);
 272         if (fd >= 0) {
 273                 dup2(fd, STDIN_FILENO);
 274                 if (fd_stdout < 0)
 275                         dup2(fd, STDOUT_FILENO);
 276                 if (fd_stderr < 0)
 277                         dup2(fd, STDERR_FILENO);
 278                 close(fd);
 279         } else {
 280                 err(udev, "open /dev/null failed: %m\n");
 281         }
 282
 283         /* connect pipes to std{out,err} */
 284         if (fd_stdout >= 0) {
 285                 dup2(fd_stdout, STDOUT_FILENO);
 286                         close(fd_stdout);
 287         }
 288         if (fd_stderr >= 0) {
 289                 dup2(fd_stderr, STDERR_FILENO);
 290                 close(fd_stderr);
 291         }
 292
 293         /* terminate child in case parent goes away */
 294         prctl(PR_SET_PDEATHSIG, SIGTERM);
 295
 296         /* restore original udev sigmask before exec */
 297         if (sigmask)
 298                 sigprocmask(SIG_SETMASK, sigmask, NULL);
 299
 300         execve(argv[0], argv, envp);
 301
 302         /* exec failed */
 303         err = -errno;
 304         if (err == -ENOENT || err == -ENOTDIR) {
 305                 /* may be on a filesystem which is not mounted right now */
 306                 info(udev, "program '%s' not found\n", argv[0]);
 307         } else {
 308                 /* other problems */
 309                 err(udev, "exec of program '%s' failed\n", argv[0]);
 310         }
 311         return err;
 312 }
 313
 314 static int run_program_read(struct udev *udev, int fd_stdout, int fd_stderr,
 315                             char *const argv[], char *result, size_t ressize, size_t *reslen)
 316 {
 317         size_t respos = 0;
 318         int fd_ep = -1;
 319         struct epoll_event ep_outpipe;
 320         struct epoll_event ep_errpipe;
 321         int err = 0;
 322
 323         /* read from child if requested */
 324         if (fd_stdout < 0 && fd_stderr < 0)
 325                 return 0;
 326
 327         fd_ep = epoll_create1(EPOLL_CLOEXEC);
 328         if (fd_ep < 0) {
 329                 err = -errno;
 330                 err(udev, "error creating epoll fd: %m\n");
 331                 goto out;
 332         }
 333
 334         if (fd_stdout >= 0) {
 335                 memset(&ep_outpipe, 0, sizeof(struct epoll_event));
 336                 ep_outpipe.events = EPOLLIN;
 337                 ep_outpipe.data.ptr = &fd_stdout;
 338                 if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe) < 0) {
 339                         err(udev, "fail to add fd to epoll: %m\n");
 340                         goto out;
 341                 }
 342         }
 343
 344         if (fd_stderr >= 0) {
 345                 memset(&ep_errpipe, 0, sizeof(struct epoll_event));
 346                 ep_errpipe.events = EPOLLIN;
 347                 ep_errpipe.data.ptr = &fd_stderr;
 348                 if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe) < 0) {
 349                         err(udev, "fail to add fd to epoll: %m\n");
 350                         goto out;
 351                 }
 352         }
 353
 354         /* read child output */
 355         while (fd_stdout >= 0 || fd_stderr >= 0) {
 356                 int fdcount;
 357                 struct epoll_event ev[4];
 358                 int i;
 359
 360                 fdcount = epoll_wait(fd_ep, ev, ARRAY_SIZE(ev), -1);
 361                 if (fdcount < 0) {
 362                         if (errno == EINTR)
 363                                 continue;
 364                         err(udev, "failed to poll: %m\n");
 365                         err = -errno;
 366                         goto out;
 367                 }
 368
 369                 for (i = 0; i < fdcount; i++) {
 370                         int *fd = (int *)ev[i].data.ptr;
 371
 372                         if (ev[i].events & EPOLLIN) {
 373                                 ssize_t count;
 374                                 char buf[4096];
 375
 376                                 count = read(*fd, buf, sizeof(buf)-1);
 377                                 if (count <= 0)
 378                                         continue;
 379                                 buf[count] = '\0';
 380
 381                                 /* store stdout result */
 382                                 if (result != NULL && *fd == fd_stdout) {
 383                                         if (respos + count < ressize) {
 384                                                 memcpy(&result[respos], buf, count);
 385                                                 respos += count;
 386                                         } else {
 387                                                 err(udev, "ressize %zd too short\n", ressize);
 388                                                 err = -ENOBUFS;
 389                                         }
 390                                 }
 391
 392                                 /* log debug output only if we watch stderr */
 393                                 if (fd_stderr >= 0) {
 394                                         char *pos;
 395                                         char *line;
 396
 397                                         pos = buf;
 398                                         while ((line = strsep(&pos, "\n"))) {
 399                                                 if (pos != NULL || line[0] != '\0')
 400                                                         info(udev, "'%s'(%s) '%s'\n", argv[0], *fd == fd_stdout ? "out" : "err" , line);
 401                                         }
 402                                 }
 403                         } else if (ev[i].events & EPOLLHUP) {
 404                                 if (epoll_ctl(fd_ep, EPOLL_CTL_DEL, *fd, NULL) < 0) {
 405                                         err = -errno;
 406                                         err(udev, "failed to remove fd from epoll: %m\n");
 407                                         goto out;
 408                                 }
 409                                 *fd = -1;
 410                         }
 411                 }
 412         }
 413
 414         /* return the child's stdout string */
 415         if (result != NULL) {
 416                 result[respos] = '\0';
 417                 dbg(udev, "result='%s'\n", result);
 418                 if (reslen != NULL)
 419                         *reslen = respos;
 420         }
 421 out:
 422         if (fd_ep >= 0)
 423                 close(fd_ep);
 424         return err;
 425 }
 426
 427 int util_run_program(struct udev *udev, const char *command, char **envp,
 428                      char *result, size_t ressize, size_t *reslen,
 429                      const sigset_t *sigmask)
 430 {
 431         int status;
 432         int outpipe[2] = {-1, -1};
 433         int errpipe[2] = {-1, -1};
 434         pid_t pid;
 435         char arg[UTIL_PATH_SIZE];
 436         char program[UTIL_PATH_SIZE];
 437         char *argv[((sizeof(arg) + 1) / 2) + 1];
 438         int i;
 439         int err = 0;
 440
 441         info(udev, "'%s' started\n", command);
 442
 443         /* build argv from command */
 444         util_strscpy(arg, sizeof(arg), command);
 445         i = 0;
 446         if (strchr(arg, ' ') != NULL) {
 447                 char *pos = arg;
 448
 449                 while (pos != NULL && pos[0] != '\0') {
 450                         if (pos[0] == '\'') {
 451                                 /* do not separate quotes */
 452                                 pos++;
 453                                 argv[i] = strsep(&pos, "\'");
 454                                 if (pos != NULL)
 455                                         while (pos[0] == ' ')
 456                                                 pos++;
 457                         } else {
 458                                 argv[i] = strsep(&pos, " ");
 459                                 if (pos != NULL)
 460                                         while (pos[0] == ' ')
 461                                                 pos++;
 462                         }
 463                         dbg(udev, "arg[%i] '%s'\n", i, argv[i]);
 464                         i++;
 465                 }
 466                 argv[i] = NULL;
 467         } else {
 468                 argv[0] = arg;
 469                 argv[1] = NULL;
 470         }
 471
 472         /* pipes from child to parent */
 473         if (result != NULL || udev_get_log_priority(udev) >= LOG_INFO) {
 474                 if (pipe2(outpipe, O_NONBLOCK) != 0) {
 475                         err = -errno;
 476                         err(udev, "pipe failed: %m\n");
 477                         goto out;
 478                 }
 479         }
 480         if (udev_get_log_priority(udev) >= LOG_INFO) {
 481                 if (pipe2(errpipe, O_NONBLOCK) != 0) {
 482                         err = -errno;
 483                         err(udev, "pipe failed: %m\n");
 484                         goto out;
 485                 }
 486         }
 487
 488         /* allow programs in /lib/udev/ to be called without the path */
 489         if (argv[0][0] != '/') {
 490                 util_strscpyl(program, sizeof(program), LIBEXECDIR "/", argv[0], NULL);
 491                 argv[0] = program;
 492         }
 493
 494         pid = fork();
 495         switch(pid) {
 496         case 0:
 497                 /* child closes parent's ends of pipes */
 498                 if (outpipe[READ_END] >= 0) {
 499                         close(outpipe[READ_END]);
 500                         outpipe[READ_END] = -1;
 501                 }
 502                 if (errpipe[READ_END] >= 0) {
 503                         close(errpipe[READ_END]);
 504                         errpipe[READ_END] = -1;
 505                 }
 506
 507                 err = run_program_exec(udev, outpipe[WRITE_END], errpipe[WRITE_END], argv, envp, sigmask);
 508
 509                 _exit(1);
 510         case -1:
 511                 err(udev, "fork of '%s' failed: %m\n", argv[0]);
 512                 err = -1;
 513                 goto out;
 514         default:
 515                 /* parent closed child's ends of pipes */
 516                 if (outpipe[WRITE_END] >= 0) {
 517                         close(outpipe[WRITE_END]);
 518                         outpipe[WRITE_END] = -1;
 519                 }
 520                 if (errpipe[WRITE_END] >= 0) {
 521                         close(errpipe[WRITE_END]);
 522                         errpipe[WRITE_END] = -1;
 523                 }
 524
 525                 err = run_program_read(udev, outpipe[READ_END], errpipe[READ_END], argv, result, ressize, reslen);
 526
 527                 waitpid(pid, &status, 0);
 528                 if (WIFEXITED(status)) {
 529                         info(udev, "'%s' returned with exitcode %i\n", command, WEXITSTATUS(status));
 530                         if (WEXITSTATUS(status) != 0)
 531                                 err = -1;
 532                 } else {
 533                         err(udev, "'%s' unexpected exit with status 0x%04x\n", command, status);
 534                         err = -1;
 535                 }
 536         }
 537
 538 out:
 539         if (outpipe[READ_END] >= 0)
 540                 close(outpipe[READ_END]);
 541         if (outpipe[WRITE_END] >= 0)
 542                 close(outpipe[WRITE_END]);
 543         if (errpipe[READ_END] >= 0)
 544                 close(errpipe[READ_END]);
 545         if (errpipe[WRITE_END] >= 0)
 546                 close(errpipe[WRITE_END]);
 547         return err;
 548 }