*
* Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
*
- * 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 <http://www.gnu.org/licenses/>.
+ * 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 <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>
+#include <ctype.h>
+#include <fcntl.h>
#include <sys/stat.h>
#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));
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;
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;
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;
}
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 {
*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;
+}
~ianmdlvl / elogind.git / blobdiff