src/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/param.h>
  23
  24 #include "libudev.h"
  25 #include "libudev-private.h"
  26
  27 static int create_path(struct udev *udev, const char *path, bool selinux)
  28 {
  29         char p[UTIL_PATH_SIZE];
  30         char *pos;
  31         struct stat stats;
  32         int err;
  33
  34         util_strscpy(p, sizeof(p), path);
  35         pos = strrchr(p, '/');
  36         if (pos == NULL)
  37                 return 0;
  38         while (pos != p && pos[-1] == '/')
  39                 pos--;
  40         if (pos == p)
  41                 return 0;
  42         pos[0] = '\0';
  43
  44         dbg(udev, "stat '%s'\n", p);
  45         if (stat(p, &stats) == 0) {
  46                 if ((stats.st_mode & S_IFMT) == S_IFDIR)
  47                         return 0;
  48                 else
  49                         return -ENOTDIR;
  50         }
  51
  52         err = util_create_path(udev, p);
  53         if (err != 0)
  54                 return err;
  55
  56         dbg(udev, "mkdir '%s'\n", p);
  57         if (selinux)
  58                 udev_selinux_setfscreatecon(udev, p, S_IFDIR|0755);
  59         err = mkdir(p, 0755);
  60         if (err != 0) {
  61                 err = -errno;
  62                 if (err == -EEXIST && stat(p, &stats) == 0) {
  63                         if ((stats.st_mode & S_IFMT) == S_IFDIR)
  64                                 err = 0;
  65                         else
  66                                 err = -ENOTDIR;
  67                 }
  68         }
  69         if (selinux)
  70                 udev_selinux_resetfscreatecon(udev);
  71         return err;
  72 }
  73
  74 int util_create_path(struct udev *udev, const char *path)
  75 {
  76         return create_path(udev, path, false);
  77 }
  78
  79 int util_create_path_selinux(struct udev *udev, const char *path)
  80 {
  81         return create_path(udev, path, true);
  82 }
  83
  84 int util_delete_path(struct udev *udev, const char *path)
  85 {
  86         char p[UTIL_PATH_SIZE];
  87         char *pos;
  88         int err = 0;
  89
  90         if (path[0] == '/')
  91                 while(path[1] == '/')
  92                         path++;
  93         util_strscpy(p, sizeof(p), path);
  94         pos = strrchr(p, '/');
  95         if (pos == p || pos == NULL)
  96                 return 0;
  97
  98         for (;;) {
  99                 *pos = '\0';
 100                 pos = strrchr(p, '/');
 101
 102                 /* don't remove the last one */
 103                 if ((pos == p) || (pos == NULL))
 104                         break;
 105
 106                 err = rmdir(p);
 107                 if (err < 0) {
 108                         if (errno == ENOENT)
 109                                 err = 0;
 110                         break;
 111                 }
 112         }
 113         return err;
 114 }
 115
 116 uid_t util_lookup_user(struct udev *udev, const char *user)
 117 {
 118         char *endptr;
 119         size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 120         char buf[buflen];
 121         struct passwd pwbuf;
 122         struct passwd *pw;
 123         uid_t uid;
 124
 125         if (strcmp(user, "root") == 0)
 126                 return 0;
 127         uid = strtoul(user, &endptr, 10);
 128         if (endptr[0] == '\0')
 129                 return uid;
 130
 131         errno = getpwnam_r(user, &pwbuf, buf, buflen, &pw);
 132         if (pw != NULL)
 133                 return pw->pw_uid;
 134         if (errno == 0 || errno == ENOENT || errno == ESRCH)
 135                 err(udev, "specified user '%s' unknown\n", user);
 136         else
 137                 err(udev, "error resolving user '%s': %m\n", user);
 138         return 0;
 139 }
 140
 141 gid_t util_lookup_group(struct udev *udev, const char *group)
 142 {
 143         char *endptr;
 144         size_t buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
 145         char *buf;
 146         struct group grbuf;
 147         struct group *gr;
 148         gid_t gid = 0;
 149
 150         if (strcmp(group, "root") == 0)
 151                 return 0;
 152         gid = strtoul(group, &endptr, 10);
 153         if (endptr[0] == '\0')
 154                 return gid;
 155         buf = NULL;
 156         gid = 0;
 157         for (;;) {
 158                 char *newbuf;
 159
 160                 newbuf = realloc(buf, buflen);
 161                 if (!newbuf)
 162                         break;
 163                 buf = newbuf;
 164                 errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
 165                 if (gr != NULL) {
 166                         gid = gr->gr_gid;
 167                 } else if (errno == ERANGE) {
 168                         buflen *= 2;
 169                         continue;
 170                 } else if (errno == 0 || errno == ENOENT || errno == ESRCH) {
 171                         err(udev, "specified group '%s' unknown\n", group);
 172                 } else {
 173                         err(udev, "error resolving group '%s': %m\n", group);
 174                 }
 175                 break;
 176         }
 177         free(buf);
 178         return gid;
 179 }
 180
 181 /* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
 182 int util_resolve_subsys_kernel(struct udev *udev, const char *string,
 183                                char *result, size_t maxsize, int read_value)
 184 {
 185         char temp[UTIL_PATH_SIZE];
 186         char *subsys;
 187         char *sysname;
 188         struct udev_device *dev;
 189         char *attr;
 190
 191         if (string[0] != '[')
 192                 return -1;
 193
 194         util_strscpy(temp, sizeof(temp), string);
 195
 196         subsys = &temp[1];
 197
 198         sysname = strchr(subsys, '/');
 199         if (sysname == NULL)
 200                 return -1;
 201         sysname[0] = '\0';
 202         sysname = &sysname[1];
 203
 204         attr = strchr(sysname, ']');
 205         if (attr == NULL)
 206                 return -1;
 207         attr[0] = '\0';
 208         attr = &attr[1];
 209         if (attr[0] == '/')
 210                 attr = &attr[1];
 211         if (attr[0] == '\0')
 212                 attr = NULL;
 213
 214         if (read_value && attr == NULL)
 215                 return -1;
 216
 217         dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
 218         if (dev == NULL)
 219                 return -1;
 220
 221         if (read_value) {
 222                 const char *val;
 223
 224                 val = udev_device_get_sysattr_value(dev, attr);
 225                 if (val != NULL)
 226                         util_strscpy(result, maxsize, val);
 227                 else
 228                         result[0] = '\0';
 229                 info(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
 230         } else {
 231                 size_t l;
 232                 char *s;
 233
 234                 s = result;
 235                 l = util_strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
 236                 if (attr != NULL)
 237                         util_strpcpyl(&s, l, "/", attr, NULL);
 238                 info(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
 239         }
 240         udev_device_unref(dev);
 241         return 0;
 242 }