| |
| |
| #include <ctype.h> |
| #include <errno.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include "libudev.h" |
| |
| #include "MurmurHash2.h" |
| #include "device-nodes.h" |
| #include "libudev-private.h" |
| #include "syslog-util.h" |
| #include "utf8.h" |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| int util_resolve_subsys_kernel(struct udev *udev, const char *string, |
| char *result, size_t maxsize, int read_value) |
| { |
| char temp[UTIL_PATH_SIZE]; |
| char *subsys; |
| char *sysname; |
| struct udev_device *dev; |
| char *attr; |
| |
| if (string[0] != '[') |
| return -1; |
| |
| strscpy(temp, sizeof(temp), string); |
| |
| subsys = &temp[1]; |
| |
| sysname = strchr(subsys, '/'); |
| if (sysname == NULL) |
| return -1; |
| sysname[0] = '\0'; |
| sysname = &sysname[1]; |
| |
| attr = strchr(sysname, ']'); |
| if (attr == NULL) |
| return -1; |
| attr[0] = '\0'; |
| attr = &attr[1]; |
| if (attr[0] == '/') |
| attr = &attr[1]; |
| if (attr[0] == '\0') |
| attr = NULL; |
| |
| if (read_value && attr == NULL) |
| return -1; |
| |
| dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname); |
| if (dev == NULL) |
| return -1; |
| |
| if (read_value) { |
| const char *val; |
| |
| val = udev_device_get_sysattr_value(dev, attr); |
| if (val != NULL) |
| strscpy(result, maxsize, val); |
| else |
| result[0] = '\0'; |
| log_debug("value '[%s/%s]%s' is '%s'", subsys, sysname, attr, result); |
| } else { |
| size_t l; |
| char *s; |
| |
| s = result; |
| l = strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL); |
| if (attr != NULL) |
| strpcpyl(&s, l, "/", attr, NULL); |
| log_debug("path '[%s/%s]%s' is '%s'", subsys, sysname, attr, result); |
| } |
| udev_device_unref(dev); |
| return 0; |
| } |
| |
| int util_log_priority(const char *priority) |
| { |
| char *endptr; |
| int prio; |
| |
| prio = strtoul(priority, &endptr, 10); |
| if (endptr[0] == '\0' || isspace(endptr[0])) { |
| if (prio >= 0 && prio <= 7) |
| return prio; |
| else |
| return -ERANGE; |
| } |
| |
| return log_level_from_string(priority); |
| } |
| |
| size_t util_path_encode(const char *src, char *dest, size_t size) |
| { |
| size_t i, j; |
| |
| 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 (src[i] == '\\') { |
| if (j+4 >= size) { |
| j = 0; |
| break; |
| } |
| memcpy(&dest[j], "\\x5c", 4); |
| j += 4; |
| } else { |
| if (j+1 >= size) { |
| j = 0; |
| break; |
| } |
| dest[j] = src[i]; |
| j++; |
| } |
| } |
| dest[j] = '\0'; |
| return j; |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| int util_replace_whitespace(const char *str, char *to, size_t len) |
| { |
| size_t i, j; |
| |
| |
| len = strnlen(str, len); |
| while (len && isspace(str[len-1])) |
| len--; |
| |
| |
| i = 0; |
| while ((i < len) && isspace(str[i])) |
| i++; |
| |
| j = 0; |
| while (i < len) { |
| |
| if (isspace(str[i])) { |
| while (isspace(str[i])) |
| i++; |
| to[j++] = '_'; |
| } |
| to[j++] = str[i++]; |
| } |
| to[j] = '\0'; |
| return j; |
| } |
| |
| |
| int util_replace_chars(char *str, const char *white) |
| { |
| size_t i = 0; |
| int replaced = 0; |
| |
| while (str[i] != '\0') { |
| int len; |
| |
| if (whitelisted_char_for_devnode(str[i], white)) { |
| i++; |
| continue; |
| } |
| |
| |
| if (str[i] == '\\' && str[i+1] == 'x') { |
| i += 2; |
| continue; |
| } |
| |
| |
| len = utf8_encoded_valid_unichar(&str[i]); |
| if (len > 1) { |
| i += len; |
| continue; |
| } |
| |
| |
| if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) { |
| str[i] = ' '; |
| i++; |
| replaced++; |
| continue; |
| } |
| |
| |
| str[i] = '_'; |
| i++; |
| replaced++; |
| } |
| return replaced; |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| _public_ int udev_util_encode_string(const char *str, char *str_enc, size_t len) |
| { |
| return encode_devnode_name(str, str_enc, len); |
| } |
| |
| unsigned int util_string_hash32(const char *str) |
| { |
| return MurmurHash2(str, strlen(str), 0); |
| } |
| |
| |
| uint64_t util_string_bloom64(const char *str) |
| { |
| uint64_t bits = 0; |
| unsigned int hash = util_string_hash32(str); |
| |
| bits |= 1LLU << (hash & 63); |
| bits |= 1LLU << ((hash >> 6) & 63); |
| bits |= 1LLU << ((hash >> 12) & 63); |
| bits |= 1LLU << ((hash >> 18) & 63); |
| return bits; |
| } |