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 /*
 154  * Copy from 'str' to 'to', while removing all leading and trailing whitespace,
 155  * and replacing each run of consecutive whitespace with a single underscore.
 156  * The chars from 'str' are copied up to the \0 at the end of the string, or
 157  * at most 'len' chars.  This appends \0 to 'to', at the end of the copied
 158  * characters.
 159  *
 160  * If 'len' chars are copied into 'to', the final \0 is placed at len+1
 161  * (i.e. 'to[len] = \0'), so the 'to' buffer must have at least len+1
 162  * chars available.
 163  *
 164  * Note this may be called with 'str' == 'to', i.e. to replace whitespace
 165  * in-place in a buffer.  This function can handle that situation.
 166  */
 167 int util_replace_whitespace(const char *str, char *to, size_t len)
 168 {
 169         size_t i, j;
 170
 171         /* strip trailing whitespace */
 172         len = strnlen(str, len);
 173         while (len && isspace(str[len-1]))
 174                 len--;
 175
 176         /* strip leading whitespace */
 177         i = 0;
 178         while ((i < len) && isspace(str[i]))
 179                 i++;
 180
 181         j = 0;
 182         while (i < len) {
 183                 /* substitute multiple whitespace with a single '_' */
 184                 if (isspace(str[i])) {
 185                         while (isspace(str[i]))
 186                                 i++;
 187                         to[j++] = '_';
 188                 }
 189                 to[j++] = str[i++];
 190         }
 191         to[j] = '\0';
 192         return j;
 193 }
 194
 195 /* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */
 196 int util_replace_chars(char *str, const char *white)
 197 {
 198         size_t i = 0;
 199         int replaced = 0;
 200
 201         while (str[i] != '\0') {
 202                 int len;
 203
 204                 if (whitelisted_char_for_devnode(str[i], white)) {
 205                         i++;
 206                         continue;
 207                 }
 208
 209                 /* accept hex encoding */
 210                 if (str[i] == '\\' && str[i+1] == 'x') {
 211                         i += 2;
 212                         continue;
 213                 }
 214
 215                 /* accept valid utf8 */
 216                 len = utf8_encoded_valid_unichar(&str[i]);
 217                 if (len > 1) {
 218                         i += len;
 219                         continue;
 220                 }
 221
 222                 /* if space is allowed, replace whitespace with ordinary space */
 223                 if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) {
 224                         str[i] = ' ';
 225                         i++;
 226                         replaced++;
 227                         continue;
 228                 }
 229
 230                 /* everything else is replaced with '_' */
 231                 str[i] = '_';
 232                 i++;
 233                 replaced++;
 234         }
 235         return replaced;
 236 }
 237
 238 /**
 239  * udev_util_encode_string:
 240  * @str: input string to be encoded
 241  * @str_enc: output string to store the encoded input string
 242  * @len: maximum size of the output string, which may be
 243  *       four times as long as the input string
 244  *
 245  * Encode all potentially unsafe characters of a string to the
 246  * corresponding 2 char hex value prefixed by '\x'.
 247  *
 248  * Returns: 0 if the entire string was copied, non-zero otherwise.
 249  **/
 250 _public_ int udev_util_encode_string(const char *str, char *str_enc, size_t len)
 251 {
 252         return encode_devnode_name(str, str_enc, len);
 253 }
 254
 255 unsigned int util_string_hash32(const char *str)
 256 {
 257         return MurmurHash2(str, strlen(str), 0);
 258 }
 259
 260 /* get a bunch of bit numbers out of the hash, and set the bits in our bit field */
 261 uint64_t util_string_bloom64(const char *str)
 262 {
 263         uint64_t bits = 0;
 264         unsigned int hash = util_string_hash32(str);
 265
 266         bits |= 1LLU << (hash & 63);
 267         bits |= 1LLU << ((hash >> 6) & 63);
 268         bits |= 1LLU << ((hash >> 12) & 63);
 269         bits |= 1LLU << ((hash >> 18) & 63);
 270         return bits;
 271 }