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 <stdio.h>
  21 #include <stdlib.h>
  22 #include <stddef.h>
  23 #include <unistd.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <dirent.h>
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <time.h>
  30 #include <pwd.h>
  31 #include <grp.h>
  32 #include <sys/stat.h>
  33 #include <sys/param.h>
  34
  35 #include "libudev.h"
  36 #include "libudev-private.h"
  37
  38 /**
  39  * SECTION:libudev-util
  40  * @short_description: utils
  41  *
  42  * Utilities useful when dealing with devices and device node names.
  43  */
  44
  45 int util_delete_path(struct udev *udev, const char *path)
  46 {
  47         char p[UTIL_PATH_SIZE];
  48         char *pos;
  49         int err = 0;
  50
  51         if (path[0] == '/')
  52                 while(path[1] == '/')
  53                         path++;
  54         util_strscpy(p, sizeof(p), path);
  55         pos = strrchr(p, '/');
  56         if (pos == p || pos == NULL)
  57                 return 0;
  58
  59         for (;;) {
  60                 *pos = '\0';
  61                 pos = strrchr(p, '/');
  62
  63                 /* don't remove the last one */
  64                 if ((pos == p) || (pos == NULL))
  65                         break;
  66
  67                 err = rmdir(p);
  68                 if (err < 0) {
  69                         if (errno == ENOENT)
  70                                 err = 0;
  71                         break;
  72                 }
  73         }
  74         return err;
  75 }
  76
  77 uid_t util_lookup_user(struct udev *udev, const char *user)
  78 {
  79         char *endptr;
  80         struct passwd pwbuf;
  81         struct passwd *pw;
  82         uid_t uid;
  83         size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
  84         char *buf = alloca(buflen);
  85
  86         if (strcmp(user, "root") == 0)
  87                 return 0;
  88         uid = strtoul(user, &endptr, 10);
  89         if (endptr[0] == '\0')
  90                 return uid;
  91
  92         errno = getpwnam_r(user, &pwbuf, buf, buflen, &pw);
  93         if (pw != NULL)
  94                 return pw->pw_uid;
  95         if (errno == 0 || errno == ENOENT || errno == ESRCH)
  96                 udev_err(udev, "specified user '%s' unknown\n", user);
  97         else
  98                 udev_err(udev, "error resolving user '%s': %m\n", user);
  99         return 0;
 100 }
 101
 102 gid_t util_lookup_group(struct udev *udev, const char *group)
 103 {
 104         char *endptr;
 105         struct group grbuf;
 106         struct group *gr;
 107         gid_t gid = 0;
 108         size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
 109         char *buf = NULL;
 110
 111         if (strcmp(group, "root") == 0)
 112                 return 0;
 113         gid = strtoul(group, &endptr, 10);
 114         if (endptr[0] == '\0')
 115                 return gid;
 116         gid = 0;
 117         for (;;) {
 118                 char *newbuf;
 119
 120                 newbuf = realloc(buf, buflen);
 121                 if (!newbuf)
 122                         break;
 123                 buf = newbuf;
 124                 errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
 125                 if (gr != NULL) {
 126                         gid = gr->gr_gid;
 127                 } else if (errno == ERANGE) {
 128                         buflen *= 2;
 129                         continue;
 130                 } else if (errno == 0 || errno == ENOENT || errno == ESRCH) {
 131                         udev_err(udev, "specified group '%s' unknown\n", group);
 132                 } else {
 133                         udev_err(udev, "error resolving group '%s': %m\n", group);
 134                 }
 135                 break;
 136         }
 137         free(buf);
 138         return gid;
 139 }
 140
 141 /* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
 142 int util_resolve_subsys_kernel(struct udev *udev, const char *string,
 143                                char *result, size_t maxsize, int read_value)
 144 {
 145         char temp[UTIL_PATH_SIZE];
 146         char *subsys;
 147         char *sysname;
 148         struct udev_device *dev;
 149         char *attr;
 150
 151         if (string[0] != '[')
 152                 return -1;
 153
 154         util_strscpy(temp, sizeof(temp), string);
 155
 156         subsys = &temp[1];
 157
 158         sysname = strchr(subsys, '/');
 159         if (sysname == NULL)
 160                 return -1;
 161         sysname[0] = '\0';
 162         sysname = &sysname[1];
 163
 164         attr = strchr(sysname, ']');
 165         if (attr == NULL)
 166                 return -1;
 167         attr[0] = '\0';
 168         attr = &attr[1];
 169         if (attr[0] == '/')
 170                 attr = &attr[1];
 171         if (attr[0] == '\0')
 172                 attr = NULL;
 173
 174         if (read_value && attr == NULL)
 175                 return -1;
 176
 177         dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
 178         if (dev == NULL)
 179                 return -1;
 180
 181         if (read_value) {
 182                 const char *val;
 183
 184                 val = udev_device_get_sysattr_value(dev, attr);
 185                 if (val != NULL)
 186                         util_strscpy(result, maxsize, val);
 187                 else
 188                         result[0] = '\0';
 189                 udev_dbg(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
 190         } else {
 191                 size_t l;
 192                 char *s;
 193
 194                 s = result;
 195                 l = util_strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
 196                 if (attr != NULL)
 197                         util_strpcpyl(&s, l, "/", attr, NULL);
 198                 udev_dbg(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
 199         }
 200         udev_device_unref(dev);
 201         return 0;
 202 }
 203 ssize_t util_get_sys_core_link_value(struct udev *udev, const char *slink, const char *syspath, char *value, size_t size)
 204 {
 205         char path[UTIL_PATH_SIZE];
 206         char target[UTIL_PATH_SIZE];
 207         ssize_t len;
 208         const char *pos;
 209
 210         util_strscpyl(path, sizeof(path), syspath, "/", slink, NULL);
 211         len = readlink(path, target, sizeof(target));
 212         if (len <= 0 || len == (ssize_t)sizeof(target))
 213                 return -1;
 214         target[len] = '\0';
 215         pos = strrchr(target, '/');
 216         if (pos == NULL)
 217                 return -1;
 218         pos = &pos[1];
 219         return util_strscpy(value, size, pos);
 220 }
 221
 222 int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size)
 223 {
 224         char link_target[UTIL_PATH_SIZE];
 225
 226         ssize_t len;
 227         int i;
 228         int back;
 229         char *base = NULL;
 230
 231         len = readlink(syspath, link_target, sizeof(link_target));
 232         if (len <= 0 || len == (ssize_t)sizeof(link_target))
 233                 return -1;
 234         link_target[len] = '\0';
 235
 236         for (back = 0; startswith(&link_target[back * 3], "../"); back++)
 237                 ;
 238         for (i = 0; i <= back; i++) {
 239                 base = strrchr(syspath, '/');
 240                 if (base == NULL)
 241                         return -EINVAL;
 242                 base[0] = '\0';
 243         }
 244         if (base == NULL)
 245                 return -EINVAL;
 246         util_strscpyl(base, size - (base - syspath), "/", &link_target[back * 3], NULL);
 247         return 0;
 248 }
 249
 250 int util_log_priority(const char *priority)
 251 {
 252         char *endptr;
 253         int prio;
 254
 255         prio = strtol(priority, &endptr, 10);
 256         if (endptr[0] == '\0' || isspace(endptr[0]))
 257                 return prio;
 258         if (startswith(priority, "err"))
 259                 return LOG_ERR;
 260         if (startswith(priority, "info"))
 261                 return LOG_INFO;
 262         if (startswith(priority, "debug"))
 263                 return LOG_DEBUG;
 264         return 0;
 265 }
 266
 267 size_t util_path_encode(const char *src, char *dest, size_t size)
 268 {
 269         size_t i, j;
 270
 271         for (i = 0, j = 0; src[i] != '\0'; i++) {
 272                 if (src[i] == '/') {
 273                         if (j+4 >= size) {
 274                                 j = 0;
 275                                 break;
 276                         }
 277                         memcpy(&dest[j], "\\x2f", 4);
 278                         j += 4;
 279                 } else if (src[i] == '\\') {
 280                         if (j+4 >= size) {
 281                                 j = 0;
 282                                 break;
 283                         }
 284                         memcpy(&dest[j], "\\x5c", 4);
 285                         j += 4;
 286                 } else {
 287                         if (j+1 >= size) {
 288                                 j = 0;
 289                                 break;
 290                         }
 291                         dest[j] = src[i];
 292                         j++;
 293                 }
 294         }
 295         dest[j] = '\0';
 296         return j;
 297 }
 298
 299 void util_remove_trailing_chars(char *path, char c)
 300 {
 301         size_t len;
 302
 303         if (path == NULL)
 304                 return;
 305         len = strlen(path);
 306         while (len > 0 && path[len-1] == c)
 307                 path[--len] = '\0';
 308 }
 309
 310 /*
 311  * Concatenates strings. In any case, terminates in _all_ cases with '\0'
 312  * and moves the @dest pointer forward to the added '\0'. Returns the
 313  * remaining size, and 0 if the string was truncated.
 314  */
 315 size_t util_strpcpy(char **dest, size_t size, const char *src)
 316 {
 317         size_t len;
 318
 319         len = strlen(src);
 320         if (len >= size) {
 321                 if (size > 1)
 322                         *dest = mempcpy(*dest, src, size-1);
 323                 size = 0;
 324         } else {
 325                 if (len > 0) {
 326                         *dest = mempcpy(*dest, src, len);
 327                         size -= len;
 328                 }
 329         }
 330         *dest[0] = '\0';
 331         return size;
 332 }
 333
 334 size_t util_strpcpyf(char **dest, size_t size, const char *src, ...)
 335 {
 336         va_list va;
 337         int i;
 338
 339         va_start(va, src);
 340         i = vsnprintf(*dest, size, src, va);
 341         if (i < (int)size) {
 342                 *dest += i;
 343                 size -= i;
 344         } else {
 345                 *dest += size;
 346                 size = 0;
 347         }
 348         va_end(va);
 349         *dest[0] = '\0';
 350         return size;
 351 }
 352
 353 /* concatenates list of strings, moves dest forward */
 354 size_t util_strpcpyl(char **dest, size_t size, const char *src, ...)
 355 {
 356         va_list va;
 357
 358         va_start(va, src);
 359         do {
 360                 size = util_strpcpy(dest, size, src);
 361                 src = va_arg(va, char *);
 362         } while (src != NULL);
 363         va_end(va);
 364         return size;
 365 }
 366
 367 /* copies string */
 368 size_t util_strscpy(char *dest, size_t size, const char *src)
 369 {
 370         char *s;
 371
 372         s = dest;
 373         return util_strpcpy(&s, size, src);
 374 }
 375
 376 /* concatenates list of strings */
 377 size_t util_strscpyl(char *dest, size_t size, const char *src, ...)
 378 {
 379         va_list va;
 380         char *s;
 381
 382         va_start(va, src);
 383         s = dest;
 384         do {
 385                 size = util_strpcpy(&s, size, src);
 386                 src = va_arg(va, char *);
 387         } while (src != NULL);
 388         va_end(va);
 389
 390         return size;
 391 }
 392
 393 /* count of characters used to encode one unicode char */
 394 static int utf8_encoded_expected_len(const char *str)
 395 {
 396         unsigned char c = (unsigned char)str[0];
 397
 398         if (c < 0x80)
 399                 return 1;
 400         if ((c & 0xe0) == 0xc0)
 401                 return 2;
 402         if ((c & 0xf0) == 0xe0)
 403                 return 3;
 404         if ((c & 0xf8) == 0xf0)
 405                 return 4;
 406         if ((c & 0xfc) == 0xf8)
 407                 return 5;
 408         if ((c & 0xfe) == 0xfc)
 409                 return 6;
 410         return 0;
 411 }
 412
 413 /* decode one unicode char */
 414 static int utf8_encoded_to_unichar(const char *str)
 415 {
 416         int unichar;
 417         int len;
 418         int i;
 419
 420         len = utf8_encoded_expected_len(str);
 421         switch (len) {
 422         case 1:
 423                 return (int)str[0];
 424         case 2:
 425                 unichar = str[0] & 0x1f;
 426                 break;
 427         case 3:
 428                 unichar = (int)str[0] & 0x0f;
 429                 break;
 430         case 4:
 431                 unichar = (int)str[0] & 0x07;
 432                 break;
 433         case 5:
 434                 unichar = (int)str[0] & 0x03;
 435                 break;
 436         case 6:
 437                 unichar = (int)str[0] & 0x01;
 438                 break;
 439         default:
 440                 return -1;
 441         }
 442
 443         for (i = 1; i < len; i++) {
 444                 if (((int)str[i] & 0xc0) != 0x80)
 445                         return -1;
 446                 unichar <<= 6;
 447                 unichar |= (int)str[i] & 0x3f;
 448         }
 449
 450         return unichar;
 451 }
 452
 453 /* expected size used to encode one unicode char */
 454 static int utf8_unichar_to_encoded_len(int unichar)
 455 {
 456         if (unichar < 0x80)
 457                 return 1;
 458         if (unichar < 0x800)
 459                 return 2;
 460         if (unichar < 0x10000)
 461                 return 3;
 462         if (unichar < 0x200000)
 463                 return 4;
 464         if (unichar < 0x4000000)
 465                 return 5;
 466         return 6;
 467 }
 468
 469 /* check if unicode char has a valid numeric range */
 470 static int utf8_unichar_valid_range(int unichar)
 471 {
 472         if (unichar > 0x10ffff)
 473                 return 0;
 474         if ((unichar & 0xfffff800) == 0xd800)
 475                 return 0;
 476         if ((unichar > 0xfdcf) && (unichar < 0xfdf0))
 477                 return 0;
 478         if ((unichar & 0xffff) == 0xffff)
 479                 return 0;
 480         return 1;
 481 }
 482
 483 /* validate one encoded unicode char and return its length */
 484 static int utf8_encoded_valid_unichar(const char *str)
 485 {
 486         int len;
 487         int unichar;
 488         int i;
 489
 490         len = utf8_encoded_expected_len(str);
 491         if (len == 0)
 492                 return -1;
 493
 494         /* ascii is valid */
 495         if (len == 1)
 496                 return 1;
 497
 498         /* check if expected encoded chars are available */
 499         for (i = 0; i < len; i++)
 500                 if ((str[i] & 0x80) != 0x80)
 501                         return -1;
 502
 503         unichar = utf8_encoded_to_unichar(str);
 504
 505         /* check if encoded length matches encoded value */
 506         if (utf8_unichar_to_encoded_len(unichar) != len)
 507                 return -1;
 508
 509         /* check if value has valid range */
 510         if (!utf8_unichar_valid_range(unichar))
 511                 return -1;
 512
 513         return len;
 514 }
 515
 516 int util_replace_whitespace(const char *str, char *to, size_t len)
 517 {
 518         size_t i, j;
 519
 520         /* strip trailing whitespace */
 521         len = strnlen(str, len);
 522         while (len && isspace(str[len-1]))
 523                 len--;
 524
 525         /* strip leading whitespace */
 526         i = 0;
 527         while (isspace(str[i]) && (i < len))
 528                 i++;
 529
 530         j = 0;
 531         while (i < len) {
 532                 /* substitute multiple whitespace with a single '_' */
 533                 if (isspace(str[i])) {
 534                         while (isspace(str[i]))
 535                                 i++;
 536                         to[j++] = '_';
 537                 }
 538                 to[j++] = str[i++];
 539         }
 540         to[j] = '\0';
 541         return 0;
 542 }
 543
 544 static int is_whitelisted(char c, const char *white)
 545 {
 546         if ((c >= '0' && c <= '9') ||
 547             (c >= 'A' && c <= 'Z') ||
 548             (c >= 'a' && c <= 'z') ||
 549             strchr("#+-.:=@_", c) != NULL ||
 550             (white != NULL && strchr(white, c) != NULL))
 551                 return 1;
 552         return 0;
 553 }
 554
 555 /* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */
 556 int util_replace_chars(char *str, const char *white)
 557 {
 558         size_t i = 0;
 559         int replaced = 0;
 560
 561         while (str[i] != '\0') {
 562                 int len;
 563
 564                 if (is_whitelisted(str[i], white)) {
 565                         i++;
 566                         continue;
 567                 }
 568
 569                 /* accept hex encoding */
 570                 if (str[i] == '\\' && str[i+1] == 'x') {
 571                         i += 2;
 572                         continue;
 573                 }
 574
 575                 /* accept valid utf8 */
 576                 len = utf8_encoded_valid_unichar(&str[i]);
 577                 if (len > 1) {
 578                         i += len;
 579                         continue;
 580                 }
 581
 582                 /* if space is allowed, replace whitespace with ordinary space */
 583                 if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) {
 584                         str[i] = ' ';
 585                         i++;
 586                         replaced++;
 587                         continue;
 588                 }
 589
 590                 /* everything else is replaced with '_' */
 591                 str[i] = '_';
 592                 i++;
 593                 replaced++;
 594         }
 595         return replaced;
 596 }
 597
 598 /**
 599  * udev_util_encode_string:
 600  * @str: input string to be encoded
 601  * @str_enc: output string to store the encoded input string
 602  * @len: maximum size of the output string, which may be
 603  *       four times as long as the input string
 604  *
 605  * Encode all potentially unsafe characters of a string to the
 606  * corresponding 2 char hex value prefixed by '\x'.
 607  *
 608  * Returns: 0 if the entire string was copied, non-zero otherwise.
 609  **/
 610 _public_ int udev_util_encode_string(const char *str, char *str_enc, size_t len)
 611 {
 612         size_t i, j;
 613
 614         if (str == NULL || str_enc == NULL)
 615                 return -1;
 616
 617         for (i = 0, j = 0; str[i] != '\0'; i++) {
 618                 int seqlen;
 619
 620                 seqlen = utf8_encoded_valid_unichar(&str[i]);
 621                 if (seqlen > 1) {
 622                         if (len-j < (size_t)seqlen)
 623                                 goto err;
 624                         memcpy(&str_enc[j], &str[i], seqlen);
 625                         j += seqlen;
 626                         i += (seqlen-1);
 627                 } else if (str[i] == '\\' || !is_whitelisted(str[i], NULL)) {
 628                         if (len-j < 4)
 629                                 goto err;
 630                         sprintf(&str_enc[j], "\\x%02x", (unsigned char) str[i]);
 631                         j += 4;
 632                 } else {
 633                         if (len-j < 1)
 634                                 goto err;
 635                         str_enc[j] = str[i];
 636                         j++;
 637                 }
 638         }
 639         if (len-j < 1)
 640                 goto err;
 641         str_enc[j] = '\0';
 642         return 0;
 643 err:
 644         return -1;
 645 }
 646
 647 /*
 648  * http://sites.google.com/site/murmurhash/
 649  *
 650  * All code is released to the public domain. For business purposes,
 651  * Murmurhash is under the MIT license.
 652  *
 653  */
 654 static unsigned int murmur_hash2(const char *key, int len, unsigned int seed)
 655 {
 656         /*
 657          *  'm' and 'r' are mixing constants generated offline.
 658          *  They're not really 'magic', they just happen to work well.
 659          */
 660         const unsigned int m = 0x5bd1e995;
 661         const int r = 24;
 662
 663         /* initialize the hash to a 'random' value */
 664         unsigned int h = seed ^ len;
 665
 666         /* mix 4 bytes at a time into the hash */
 667         const unsigned char * data = (const unsigned char *)key;
 668
 669         while(len >= 4) {
 670                 unsigned int k = *(unsigned int *)data;
 671
 672                 k *= m;
 673                 k ^= k >> r;
 674                 k *= m;
 675                 h *= m;
 676                 h ^= k;
 677
 678                 data += 4;
 679                 len -= 4;
 680         }
 681
 682         /* handle the last few bytes of the input array */
 683         switch(len) {
 684         case 3:
 685                 h ^= data[2] << 16;
 686         case 2:
 687                 h ^= data[1] << 8;
 688         case 1:
 689                 h ^= data[0];
 690                 h *= m;
 691         };
 692
 693         /* do a few final mixes of the hash to ensure the last few bytes are well-incorporated */
 694         h ^= h >> 13;
 695         h *= m;
 696         h ^= h >> 15;
 697
 698         return h;
 699 }
 700
 701 unsigned int util_string_hash32(const char *str)
 702 {
 703         return murmur_hash2(str, strlen(str), 0);
 704 }
 705
 706 /* get a bunch of bit numbers out of the hash, and set the bits in our bit field */
 707 uint64_t util_string_bloom64(const char *str)
 708 {
 709         uint64_t bits = 0;
 710         unsigned int hash = util_string_hash32(str);
 711
 712         bits |= 1LLU << (hash & 63);
 713         bits |= 1LLU << ((hash >> 6) & 63);
 714         bits |= 1LLU << ((hash >> 12) & 63);
 715         bits |= 1LLU << ((hash >> 18) & 63);
 716         return bits;
 717 }
 718
 719 ssize_t print_kmsg(const char *fmt, ...)
 720 {
 721         int fd;
 722         va_list ap;
 723         char text[1024];
 724         ssize_t len;
 725         ssize_t ret;
 726
 727         fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
 728         if (fd < 0)
 729                 return -errno;
 730
 731         len = snprintf(text, sizeof(text), "<30>systemd-udevd[%u]: ", getpid());
 732
 733         va_start(ap, fmt);
 734         len += vsnprintf(text + len, sizeof(text) - len, fmt, ap);
 735         va_end(ap);
 736
 737         ret = write(fd, text, len);
 738         if (ret < 0)
 739                 ret = -errno;
 740         close(fd);
 741         return ret;
 742 }