X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=udev%2Flib%2Flibudev-util.c;h=dcc4a0fd16e78e9270a352f13da947c4d60d0e90;hb=15a45c89e5c79e374247bad5c6ae28ad41496161;hp=0e5bc37d4395cc2cd66e79e9aec67739c89bc494;hpb=bf7ad0ea662e747701cc66cdd1b33d22b6836cdf;p=elogind.git diff --git a/udev/lib/libudev-util.c b/udev/lib/libudev-util.c index 0e5bc37d4..dcc4a0fd1 100644 --- a/udev/lib/libudev-util.c +++ b/udev/lib/libudev-util.c @@ -1,20 +1,12 @@ /* * libudev - interface to udev device information * - * Copyright (C) 2008 Kay Sievers + * Copyright (C) 2008-2009 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 @@ -31,15 +23,13 @@ #include "libudev.h" #include "libudev-private.h" -static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *syspath, 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, syspath, sizeof(path)); - util_strlcat(path, "/", sizeof(path)); - util_strlcat(path, slink, sizeof(path)); + util_strscpyl(path, sizeof(path), syspath, "/", slink, NULL); len = readlink(path, path, sizeof(path)); if (len < 0 || len >= (ssize_t) sizeof(path)) return -1; @@ -48,8 +38,8 @@ static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *sy if (pos == NULL) return -1; pos = &pos[1]; - info(udev, "resolved link to: '%s'\n", pos); - return util_strlcpy(subsystem, pos, size); + dbg(udev, "resolved link to: '%s'\n", pos); + return util_strscpy(value, size, pos); } ssize_t util_get_sys_subsystem(struct udev *udev, const char *syspath, char *subsystem, size_t size) @@ -64,17 +54,13 @@ ssize_t util_get_sys_driver(struct udev *udev, const char *syspath, char *driver int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size) { - struct stat statbuf; char link_target[UTIL_PATH_SIZE]; int len; int i; int back; + char *base; - if (lstat(syspath, &statbuf) < 0) - return -1; - if (!S_ISLNK(statbuf.st_mode)) - return -1; len = readlink(syspath, link_target, sizeof(link_target)); if (len <= 0) return -1; @@ -85,15 +71,13 @@ int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size) ; dbg(udev, "base '%s', tail '%s', back %i\n", syspath, &link_target[back * 3], back); for (i = 0; i <= back; i++) { - char *pos = strrchr(syspath, '/'); - - if (pos == NULL) + base = strrchr(syspath, '/'); + if (base == NULL) return -1; - pos[0] = '\0'; + base[0] = '\0'; } dbg(udev, "after moving back '%s'\n", syspath); - util_strlcat(syspath, "/", size); - util_strlcat(syspath, &link_target[back * 3], size); + util_strscpyl(base, size - (base - syspath), "/", &link_target[back * 3], NULL); return 0; } @@ -105,35 +89,44 @@ int util_log_priority(const char *priority) prio = strtol(priority, &endptr, 10); if (endptr[0] == '\0') return prio; - if (strncasecmp(priority, "err", 3) == 0) + if (strncmp(priority, "err", 3) == 0) return LOG_ERR; - if (strcasecmp(priority, "info") == 0) + if (strcmp(priority, "info") == 0) return LOG_INFO; - if (strcasecmp(priority, "debug") == 0) + if (strcmp(priority, "debug") == 0) return LOG_DEBUG; return 0; } -size_t util_path_encode(char *s, size_t len) +size_t util_path_encode(const char *src, char *dest, size_t size) { - char t[(len * 3)+1]; size_t i, j; - t[0] = '\0'; - for (i = 0, j = 0; s[i] != '\0'; i++) { - if (s[i] == '/') { - memcpy(&t[j], "\\x2f", 4); + for (i = 0, j = 0; src[i] != '\0'; i++) { + if (src[i] == '/') { + if (j+4 >= size) { + j = 0; + break; + } + memcpy(&dest[j], "\\x2f", 4); j += 4; - } else if (s[i] == '\\') { - memcpy(&t[j], "\\x5c", 4); + } else if (src[i] == '\\') { + if (j+4 >= size) { + j = 0; + break; + } + memcpy(&dest[j], "\\x5c", 4); j += 4; } else { - t[j] = s[i]; + if (j+1 >= size) { + j = 0; + break; + } + dest[j] = src[i]; j++; } } - t[j] = '\0'; - strncpy(s, t, len); + dest[j] = '\0'; return j; } @@ -145,7 +138,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 { @@ -168,47 +161,70 @@ void util_remove_trailing_chars(char *path, char c) path[--len] = '\0'; } -size_t util_strlcpy(char *dst, const char *src, size_t size) +/* + * Concatenates strings. In any case, terminates in _all_ cases with '\0' + * and moves the @dest pointer forward to the added '\0'. Returns the + * remaining size, and 0 if the string was truncated. + */ +size_t util_strpcpy(char **dest, size_t size, const char *src) { - size_t bytes = 0; - char *q = dst; - const char *p = src; - char ch; - - while ((ch = *p++)) { - if (bytes+1 < size) - *q++ = ch; - bytes++; + size_t len; + + len = strlen(src); + if (len >= size) { + if (size > 1) + *dest = mempcpy(*dest, src, size-1); + size = 0; + *dest[0] = '\0'; + } else { + if (len > 0) { + *dest = mempcpy(*dest, src, len); + size -= len; + } + *dest[0] = '\0'; } + return size; +} + +/* concatenates list of strings, moves dest forward */ +size_t util_strpcpyl(char **dest, size_t size, const char *src, ...) +{ + va_list va; + + va_start(va, src); + do { + size = util_strpcpy(dest, size, src); + src = va_arg(va, char *); + } while (src != NULL); + va_end(va); - /* If size == 0 there is no space for a final null... */ - if (size) - *q = '\0'; - return bytes; + return size; } -size_t util_strlcat(char *dst, const char *src, size_t size) +/* copies string */ +size_t util_strscpy(char *dest, size_t size, const char *src) { - size_t bytes = 0; - char *q = dst; - const char *p = src; - char ch; - - while (bytes < size && *q) { - q++; - bytes++; - } - if (bytes == size) - return (bytes + strlen(src)); + char *s; - while ((ch = *p++)) { - if (bytes+1 < size) - *q++ = ch; - bytes++; - } + s = dest; + return util_strpcpy(&s, size, src); +} - *q = '\0'; - return bytes; +/* concatenates list of strings */ +size_t util_strscpyl(char *dest, size_t size, const char *src, ...) +{ + va_list va; + char *s; + + va_start(va, src); + s = dest; + do { + size = util_strpcpy(&s, size, src); + src = va_arg(va, char *); + } while (src != NULL); + va_end(va); + + return size; } /* count of characters used to encode one unicode char */ @@ -334,8 +350,47 @@ static int utf8_encoded_valid_unichar(const char *str) 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 util_replace_chars(char *str, const char *white) +int udev_util_replace_chars(char *str, const char *white) { size_t i = 0; int replaced = 0; @@ -343,16 +398,7 @@ int util_replace_chars(char *str, const char *white) while (str[i] != '\0') { int len; - /* accept whitelist */ - if (white != NULL && strchr(white, str[i]) != NULL) { - i++; - continue; - } - - /* accept plain ascii char */ - if ((str[i] >= '0' && str[i] <= '9') || - (str[i] >= 'A' && str[i] <= 'Z') || - (str[i] >= 'a' && str[i] <= 'z')) { + if (is_whitelisted(str[i], white)) { i++; continue; } @@ -371,7 +417,7 @@ int util_replace_chars(char *str, const char *white) } /* if space is allowed, replace whitespace with ordinary space */ - if (isspace(str[i]) && strchr(white, ' ') != NULL) { + if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) { str[i] = ' '; i++; replaced++; @@ -383,6 +429,74 @@ int util_replace_chars(char *str, const char *white) 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; +}