X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Flib%2Flibudev-util.c;h=2b8cda59f6e30cb41b2d6c6bfee3732f5051fe45;hp=ae0adf4b88cbb8b26df2dbbbcce9ed6a57826876;hb=c7dff03e057a7548bc2f2adbd5d2798d209b56e6;hpb=3eb46ec6ddeb31d9886ebb736d1d7b3534d2f354 diff --git a/udev/lib/libudev-util.c b/udev/lib/libudev-util.c index ae0adf4b8..2b8cda59f 100644 --- a/udev/lib/libudev-util.c +++ b/udev/lib/libudev-util.c @@ -3,22 +3,12 @@ * * Copyright (C) 2008 Kay Sievers * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. */ -#include "config.h" - #include #include #include @@ -26,19 +16,20 @@ #include #include #include +#include +#include #include #include "libudev.h" #include "libudev-private.h" -static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *devpath, char *subsystem, size_t size) +static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *syspath, char *value, size_t size) { char path[UTIL_PATH_SIZE]; ssize_t len; const char *pos; - util_strlcpy(path, udev_get_sys_path(udev), sizeof(path)); - util_strlcat(path, devpath, sizeof(path)); + util_strlcpy(path, syspath, sizeof(path)); util_strlcat(path, "/", sizeof(path)); util_strlcat(path, slink, sizeof(path)); len = readlink(path, path, sizeof(path)); @@ -49,99 +40,50 @@ static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *de if (pos == NULL) return -1; pos = &pos[1]; - return util_strlcpy(subsystem, pos, size); + dbg(udev, "resolved link to: '%s'\n", pos); + return util_strlcpy(value, pos, size); } -ssize_t util_get_sys_subsystem(struct udev *udev, const char *devpath, char *subsystem, size_t size) +ssize_t util_get_sys_subsystem(struct udev *udev, const char *syspath, char *subsystem, size_t size) { - return get_sys_link(udev, "subsystem", devpath, subsystem, size); + return get_sys_link(udev, "subsystem", syspath, subsystem, size); } -ssize_t util_get_sys_driver(struct udev *udev, const char *devpath, char *driver, size_t size) +ssize_t util_get_sys_driver(struct udev *udev, const char *syspath, char *driver, size_t size) { - return get_sys_link(udev, "driver", devpath, driver, size); + return get_sys_link(udev, "driver", syspath, driver, size); } -int util_resolve_sys_link(struct udev *udev, char *devpath, size_t size) +int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size) { - char link_path[UTIL_PATH_SIZE]; char link_target[UTIL_PATH_SIZE]; int len; int i; int back; - util_strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path)); - util_strlcat(link_path, devpath, sizeof(link_path)); - len = readlink(link_path, link_target, sizeof(link_target)); + len = readlink(syspath, link_target, sizeof(link_target)); if (len <= 0) return -1; link_target[len] = '\0'; - dbg(udev, "path link '%s' points to '%s'\n", devpath, link_target); + dbg(udev, "path link '%s' points to '%s'\n", syspath, link_target); for (back = 0; strncmp(&link_target[back * 3], "../", 3) == 0; back++) ; - dbg(udev, "base '%s', tail '%s', back %i\n", devpath, &link_target[back * 3], back); + dbg(udev, "base '%s', tail '%s', back %i\n", syspath, &link_target[back * 3], back); for (i = 0; i <= back; i++) { - char *pos = strrchr(devpath, '/'); + char *pos = strrchr(syspath, '/'); if (pos == NULL) return -1; pos[0] = '\0'; } - dbg(udev, "after moving back '%s'\n", devpath); - util_strlcat(devpath, "/", size); - util_strlcat(devpath, &link_target[back * 3], size); + dbg(udev, "after moving back '%s'\n", syspath); + util_strlcat(syspath, "/", size); + util_strlcat(syspath, &link_target[back * 3], size); return 0; } -struct util_name_entry *util_name_list_add(struct udev *udev, struct list_head *name_list, - const char *name, int sort) -{ - struct util_name_entry *name_loop; - struct util_name_entry *name_new; - - /* avoid duplicate entries */ - list_for_each_entry(name_loop, name_list, node) { - if (strcmp(name_loop->name, name) == 0) { - dbg(udev, "'%s' is already in the list\n", name); - return name_loop; - } - } - - if (sort) { - list_for_each_entry(name_loop, name_list, node) { - if (strcmp(name_loop->name, name) > 0) - break; - } - } - - name_new = malloc(sizeof(struct util_name_entry)); - if (name_new == NULL) - return NULL; - memset(name_new, 0x00, sizeof(struct util_name_entry)); - name_new->name = strdup(name); - if (name_new->name == NULL) { - free(name_new); - return NULL; - } - dbg(udev, "adding '%s'\n", name_new->name); - list_add_tail(&name_new->node, &name_loop->node); - return name_new; -} - -void util_name_list_cleanup(struct udev *udev, struct list_head *name_list) -{ - struct util_name_entry *name_loop; - struct util_name_entry *name_tmp; - - list_for_each_entry_safe(name_loop, name_tmp, name_list, node) { - list_del(&name_loop->node); - free(name_loop->name); - free(name_loop); - } -} - int util_log_priority(const char *priority) { char *endptr; @@ -159,13 +101,12 @@ int util_log_priority(const char *priority) return 0; } -size_t util_path_encode(char *s, size_t len) +size_t util_path_encode(char *s, size_t size) { - char t[(len * 3)+1]; + char t[(size * 4)+1]; size_t i, j; - t[0] = '\0'; - for (i = 0, j = 0; s[i] != '\0'; i++) { + for (i = 0, j = 0; s[i] != '\0' && i < size; i++) { if (s[i] == '/') { memcpy(&t[j], "\\x2f", 4); j += 4; @@ -177,8 +118,12 @@ size_t util_path_encode(char *s, size_t len) j++; } } - t[j] = '\0'; - strncpy(s, t, len); + if (i >= size) + return 0; + if (j >= size) + return 0; + memcpy(s, t, j); + s[j] = '\0'; return j; } @@ -190,7 +135,7 @@ size_t util_path_decode(char *s) if (memcmp(&s[i], "\\x2f", 4) == 0) { s[j] = '/'; i += 4; - }else if (memcmp(&s[i], "\\x5c", 4) == 0) { + } else if (memcmp(&s[i], "\\x5c", 4) == 0) { s[j] = '\\'; i += 4; } else { @@ -255,3 +200,277 @@ size_t util_strlcat(char *dst, const char *src, size_t size) *q = '\0'; return bytes; } + +/* count of characters used to encode one unicode char */ +static int utf8_encoded_expected_len(const char *str) +{ + unsigned char c = (unsigned char)str[0]; + + if (c < 0x80) + return 1; + if ((c & 0xe0) == 0xc0) + return 2; + if ((c & 0xf0) == 0xe0) + return 3; + if ((c & 0xf8) == 0xf0) + return 4; + if ((c & 0xfc) == 0xf8) + return 5; + if ((c & 0xfe) == 0xfc) + return 6; + return 0; +} + +/* decode one unicode char */ +static int utf8_encoded_to_unichar(const char *str) +{ + int unichar; + int len; + int i; + + len = utf8_encoded_expected_len(str); + switch (len) { + case 1: + return (int)str[0]; + case 2: + unichar = str[0] & 0x1f; + break; + case 3: + unichar = (int)str[0] & 0x0f; + break; + case 4: + unichar = (int)str[0] & 0x07; + break; + case 5: + unichar = (int)str[0] & 0x03; + break; + case 6: + unichar = (int)str[0] & 0x01; + break; + default: + return -1; + } + + for (i = 1; i < len; i++) { + if (((int)str[i] & 0xc0) != 0x80) + return -1; + unichar <<= 6; + unichar |= (int)str[i] & 0x3f; + } + + return unichar; +} + +/* expected size used to encode one unicode char */ +static int utf8_unichar_to_encoded_len(int unichar) +{ + if (unichar < 0x80) + return 1; + if (unichar < 0x800) + return 2; + if (unichar < 0x10000) + return 3; + if (unichar < 0x200000) + return 4; + if (unichar < 0x4000000) + return 5; + return 6; +} + +/* check if unicode char has a valid numeric range */ +static int utf8_unichar_valid_range(int unichar) +{ + if (unichar > 0x10ffff) + return 0; + if ((unichar & 0xfffff800) == 0xd800) + return 0; + if ((unichar > 0xfdcf) && (unichar < 0xfdf0)) + return 0; + if ((unichar & 0xffff) == 0xffff) + return 0; + return 1; +} + +/* validate one encoded unicode char and return its length */ +static int utf8_encoded_valid_unichar(const char *str) +{ + int len; + int unichar; + int i; + + len = utf8_encoded_expected_len(str); + if (len == 0) + return -1; + + /* ascii is valid */ + if (len == 1) + return 1; + + /* check if expected encoded chars are available */ + for (i = 0; i < len; i++) + if ((str[i] & 0x80) != 0x80) + return -1; + + unichar = utf8_encoded_to_unichar(str); + + /* check if encoded length matches encoded value */ + if (utf8_unichar_to_encoded_len(unichar) != len) + return -1; + + /* check if value has valid range */ + if (!utf8_unichar_valid_range(unichar)) + return -1; + + return len; +} + +int udev_util_replace_whitespace(const char *str, char *to, size_t len) +{ + size_t i, j; + + /* strip trailing whitespace */ + len = strnlen(str, len); + while (len && isspace(str[len-1])) + len--; + + /* strip leading whitespace */ + i = 0; + while (isspace(str[i]) && (i < len)) + i++; + + j = 0; + while (i < len) { + /* substitute multiple whitespace with a single '_' */ + if (isspace(str[i])) { + while (isspace(str[i])) + i++; + to[j++] = '_'; + } + to[j++] = str[i++]; + } + to[j] = '\0'; + return 0; +} + +static int is_whitelisted(char c, const char *white) +{ + if ((c >= '0' && c <= '9') || + (c >= 'A' && c <= 'Z') || + (c >= 'a' && c <= 'z') || + strchr("#+-.:=@_", c) != NULL || + (white != NULL && strchr(white, c) != NULL)) + return 1; + return 0; +} + +/* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */ +int udev_util_replace_chars(char *str, const char *white) +{ + size_t i = 0; + int replaced = 0; + + while (str[i] != '\0') { + int len; + + if (is_whitelisted(str[i], white)) { + i++; + continue; + } + + /* accept hex encoding */ + if (str[i] == '\\' && str[i+1] == 'x') { + i += 2; + continue; + } + + /* accept valid utf8 */ + len = utf8_encoded_valid_unichar(&str[i]); + if (len > 1) { + i += len; + continue; + } + + /* if space is allowed, replace whitespace with ordinary space */ + if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) { + str[i] = ' '; + i++; + replaced++; + continue; + } + + /* everything else is replaced with '_' */ + str[i] = '_'; + i++; + replaced++; + } + return replaced; +} + +/** + * util_encode_string: + * @str: input string to be encoded + * @str_enc: output string to store the encoded input string + * @len: maximum size of the output string, which may be + * four times as long as the input string + * + * Encode all potentially unsafe characters of a string to the + * corresponding hex value prefixed by '\x'. + * + * Returns: 0 if the entire string was copied, non-zero otherwise. + **/ +int udev_util_encode_string(const char *str, char *str_enc, size_t len) +{ + size_t i, j; + + if (str == NULL || str_enc == NULL || len == 0) + return -1; + + str_enc[0] = '\0'; + for (i = 0, j = 0; str[i] != '\0'; i++) { + int seqlen; + + seqlen = utf8_encoded_valid_unichar(&str[i]); + if (seqlen > 1) { + memcpy(&str_enc[j], &str[i], seqlen); + j += seqlen; + i += (seqlen-1); + } else if (str[i] == '\\' || !is_whitelisted(str[i], NULL)) { + sprintf(&str_enc[j], "\\x%02x", (unsigned char) str[i]); + j += 4; + } else { + str_enc[j] = str[i]; + j++; + } + if (j+3 >= len) + goto err; + } + str_enc[j] = '\0'; + return 0; +err: + return -1; +} + +void util_set_fd_cloexec(int fd) +{ + int flags; + + flags = fcntl(fd, F_GETFD); + if (flags < 0) + flags = FD_CLOEXEC; + else + flags |= FD_CLOEXEC; + fcntl(fd, F_SETFD, flags); +} + +unsigned int util_string_hash32(const char *str) +{ + unsigned int hash = 0; + + while (str[0] != '\0') { + hash += str[0] << 4; + hash += str[0] >> 4; + hash *= 11; + str++; + } + return hash; +}