src/libudev/libudev-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <ctype.h>
  21 #include <errno.h>
  22 #include <stddef.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include "libudev.h"
  28
  29 #include "MurmurHash2.h"
  30 #include "device-nodes.h"
  31 #include "libudev-private.h"
  32 #include "syslog-util.h"
  33 #include "utf8.h"
  34
  35 /**
  36  * SECTION:libudev-util
  37  * @short_description: utils
  38  *
  39  * Utilities useful when dealing with devices and device node names.
  40  */
  41
  42 /* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
  43 int util_resolve_subsys_kernel(struct udev *udev, const char *string,
  44                                char *result, size_t maxsize, int read_value)
  45 {
  46         char temp[UTIL_PATH_SIZE];
  47         char *subsys;
  48         char *sysname;
  49         struct udev_device *dev;
  50         char *attr;
  51
  52         if (string[0] != '[')
  53                 return -1;
  54
  55         strscpy(temp, sizeof(temp), string);
  56
  57         subsys = &temp[1];
  58
  59         sysname = strchr(subsys, '/');
  60         if (sysname == NULL)
  61                 return -1;
  62         sysname[0] = '\0';
  63         sysname = &sysname[1];
  64
  65         attr = strchr(sysname, ']');
  66         if (attr == NULL)
  67                 return -1;
  68         attr[0] = '\0';
  69         attr = &attr[1];
  70         if (attr[0] == '/')
  71                 attr = &attr[1];
  72         if (attr[0] == '\0')
  73                 attr = NULL;
  74
  75         if (read_value && attr == NULL)
  76                 return -1;
  77
  78         dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
  79         if (dev == NULL)
  80                 return -1;
  81
  82         if (read_value) {
  83                 const char *val;
  84
  85                 val = udev_device_get_sysattr_value(dev, attr);
  86                 if (val != NULL)
  87                         strscpy(result, maxsize, val);
  88                 else
  89                         result[0] = '\0';
  90                 log_debug("value '[%s/%s]%s' is '%s'", subsys, sysname, attr, result);
  91         } else {
  92                 size_t l;
  93                 char *s;
  94
  95                 s = result;
  96                 l = strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
  97                 if (attr != NULL)
  98                         strpcpyl(&s, l, "/", attr, NULL);
  99                 log_debug("path '[%s/%s]%s' is '%s'", subsys, sysname, attr, result);
 100         }
 101         udev_device_unref(dev);
 102         return 0;
 103 }
 104
 105 int util_log_priority(const char *priority)
 106 {
 107         char *endptr;
 108         int prio;
 109
 110         prio = strtoul(priority, &endptr, 10);
 111         if (endptr[0] == '\0' || isspace(endptr[0])) {
 112                 if (prio >= 0 && prio <= 7)
 113                         return prio;
 114                 else
 115                         return -ERANGE;
 116         }
 117
 118         return log_level_from_string(priority);
 119 }
 120
 121 size_t util_path_encode(const char *src, char *dest, size_t size)
 122 {
 123         size_t i, j;
 124
 125         for (i = 0, j = 0; src[i] != '\0'; i++) {
 126                 if (src[i] == '/') {
 127                         if (j+4 >= size) {
 128                                 j = 0;
 129                                 break;
 130                         }
 131                         memcpy(&dest[j], "\\x2f", 4);
 132                         j += 4;
 133                 } else if (src[i] == '\\') {
 134                         if (j+4 >= size) {
 135                                 j = 0;
 136                                 break;
 137                         }
 138                         memcpy(&dest[j], "\\x5c", 4);
 139                         j += 4;
 140                 } else {
 141                         if (j+1 >= size) {
 142                                 j = 0;
 143                                 break;
 144                         }
 145                         dest[j] = src[i];
 146                         j++;
 147                 }
 148         }
 149         dest[j] = '\0';
 150         return j;
 151 }
 152
 153 void util_remove_trailing_chars(char *path, char c)
 154 {
 155         size_t len;
 156
 157         if (path == NULL)
 158                 return;
 159         len = strlen(path);
 160         while (len > 0 && path[len-1] == c)
 161                 path[--len] = '\0';
 162 }
 163
 164 int util_replace_whitespace(const char *str, char *to, size_t len)
 165 {
 166         size_t i, j;
 167
 168         /* strip trailing whitespace */
 169         len = strnlen(str, len);
 170         while (len && isspace(str[len-1]))
 171                 len--;
 172
 173         /* strip leading whitespace */
 174         i = 0;
 175         while ((i < len) && isspace(str[i]))
 176                 i++;
 177
 178         j = 0;
 179         while (i < len) {
 180                 /* substitute multiple whitespace with a single '_' */
 181                 if (isspace(str[i])) {
 182                         while (isspace(str[i]))
 183                                 i++;
 184                         to[j++] = '_';
 185                 }
 186                 to[j++] = str[i++];
 187         }
 188         to[j] = '\0';
 189         return j;
 190 }
 191
 192 /* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */
 193 int util_replace_chars(char *str, const char *white)
 194 {
 195         size_t i = 0;
 196         int replaced = 0;
 197
 198         while (str[i] != '\0') {
 199                 int len;
 200
 201                 if (whitelisted_char_for_devnode(str[i], white)) {
 202                         i++;
 203                         continue;
 204                 }
 205
 206                 /* accept hex encoding */
 207                 if (str[i] == '\\' && str[i+1] == 'x') {
 208                         i += 2;
 209                         continue;
 210                 }
 211
 212                 /* accept valid utf8 */
 213                 len = utf8_encoded_valid_unichar(&str[i]);
 214                 if (len > 1) {
 215                         i += len;
 216                         continue;
 217                 }
 218
 219                 /* if space is allowed, replace whitespace with ordinary space */
 220                 if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) {
 221                         str[i] = ' ';
 222                         i++;
 223                         replaced++;
 224                         continue;
 225                 }
 226
 227                 /* everything else is replaced with '_' */
 228                 str[i] = '_';
 229                 i++;
 230                 replaced++;
 231         }
 232         return replaced;
 233 }
 234
 235 /**
 236  * udev_util_encode_string:
 237  * @str: input string to be encoded
 238  * @str_enc: output string to store the encoded input string
 239  * @len: maximum size of the output string, which may be
 240  *       four times as long as the input string
 241  *
 242  * Encode all potentially unsafe characters of a string to the
 243  * corresponding 2 char hex value prefixed by '\x'.
 244  *
 245  * Returns: 0 if the entire string was copied, non-zero otherwise.
 246  **/
 247 _public_ int udev_util_encode_string(const char *str, char *str_enc, size_t len)
 248 {
 249         return encode_devnode_name(str, str_enc, len);
 250 }
 251
 252 unsigned int util_string_hash32(const char *str)
 253 {
 254         return MurmurHash2(str, strlen(str), 0);
 255 }
 256
 257 /* get a bunch of bit numbers out of the hash, and set the bits in our bit field */
 258 uint64_t util_string_bloom64(const char *str)
 259 {
 260         uint64_t bits = 0;
 261         unsigned int hash = util_string_hash32(str);
 262
 263         bits |= 1LLU << (hash & 63);
 264         bits |= 1LLU << ((hash >> 6) & 63);
 265         bits |= 1LLU << ((hash >> 12) & 63);
 266         bits |= 1LLU << ((hash >> 18) & 63);
 267         return bits;
 268 }