#include <stdio.h>

#include <stdlib.h>

#include <stddef.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <dirent.h>

#include <ctype.h>

#include <fcntl.h>

#include <time.h>

#include <pwd.h>

#include <grp.h>

#include <sys/stat.h>

#include <sys/param.h>

#include "device-nodes.h"

#include "libudev.h"

#include "libudev-private.h"

#include "utf8.h"

#include "MurmurHash2.h"

int util_delete_path(struct udev *udev, const char *path)

{

char p[UTIL_PATH_SIZE];

char *pos;

int err = 0;

if (path[0] == '/')

while(path[1] == '/')

path++;

strscpy(p, sizeof(p), path);

pos = strrchr(p, '/');

if (pos == p || pos == NULL)

return 0;

for (;;) {

*pos = '\0';

pos = strrchr(p, '/');

/* don't remove the last one */

if ((pos == p) || (pos == NULL))

break;

err = rmdir(p);

if (err < 0) {

if (errno == ENOENT)

err = 0;

break;

}

}

return err;

}

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';

udev_dbg(udev, "value '[%s/%s]%s' is '%s'\n", 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);

udev_dbg(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);

}

udev_device_unref(dev);

return 0;

}

ssize_t util_get_sys_core_link_value(struct udev *udev, const char *slink, const char *syspath, char *value, size_t size)

{

char path[UTIL_PATH_SIZE];

char target[UTIL_PATH_SIZE];

ssize_t len;

const char *pos;

strscpyl(path, sizeof(path), syspath, "/", slink, NULL);

len = readlink(path, target, sizeof(target));

if (len <= 0 || len == (ssize_t)sizeof(target))

return -1;

target[len] = '\0';

pos = strrchr(target, '/');

if (pos == NULL)

return -1;

pos = &pos[1];

return strscpy(value, size, pos);

}

int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size)

{

char link_target[UTIL_PATH_SIZE];

ssize_t len;

int i;

int back;

char *base = NULL;

len = readlink(syspath, link_target, sizeof(link_target));

if (len <= 0 || len == (ssize_t)sizeof(link_target))

return -1;

link_target[len] = '\0';

for (back = 0; startswith(&link_target[back * 3], "../"); back++)

;

for (i = 0; i <= back; i++) {

base = strrchr(syspath, '/');

if (base == NULL)

return -EINVAL;

base[0] = '\0';

}

strscpyl(base, size - (base - syspath), "/", &link_target[back * 3], NULL);

return 0;

}

int util_log_priority(const char *priority)

{

char *endptr;

int prio;

prio = strtol(priority, &endptr, 10);

if (endptr[0] == '\0' || isspace(endptr[0]))

return prio;

if (startswith(priority, "err"))

return LOG_ERR;

if (startswith(priority, "info"))

return LOG_INFO;

if (startswith(priority, "debug"))

return LOG_DEBUG;

return 0;

}

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;

}

void util_remove_trailing_chars(char *path, char c)

{

size_t len;

if (path == NULL)

return;

len = strlen(path);

while (len > 0 && path[len-1] == c)

path[--len] = '\0';

}

int 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;

}

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;

}

/* 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;

}

_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;

}