libudev: docs - add udev_get_run_path()

[elogind.git] / libudev / libudev-util.c

diff --git a/libudev/libudev-util.c b/libudev/libudev-util.c
index dcc4a0fd16e78e9270a352f13da947c4d60d0e90..51dd017467c6ea577825ceee35ceb1663d31cf0c 100644 (file)
--- a/libudev/libudev-util.c
+++ b/libudev/libudev-util.c
@@ -18,6 +18,7 @@
 #include <dirent.h>
 #include <ctype.h>
 #include <fcntl.h>
+#include <time.h>
 #include <sys/stat.h>
 
 #include "libudev.h"
@@ -26,15 +27,16 @@
 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];
+       char target[UTIL_PATH_SIZE];
        ssize_t len;
        const char *pos;
 
        util_strscpyl(path, sizeof(path), syspath, "/", slink, NULL);
-       len = readlink(path, path, sizeof(path));
-       if (len < 0 || len >= (ssize_t) sizeof(path))
+       len = readlink(path, target, sizeof(target));
+       if (len <= 0 || len == (ssize_t)sizeof(target))
                return -1;
-       path[len] = '\0';
-       pos = strrchr(path, '/');
+       target[len] = '\0';
+       pos = strrchr(target, '/');
        if (pos == NULL)
                return -1;
        pos = &pos[1];
@@ -56,13 +58,13 @@ int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size)
 {
        char link_target[UTIL_PATH_SIZE];
 
-       int len;
+       ssize_t len;
        int i;
        int back;
        char *base;
 
        len = readlink(syspath, link_target, sizeof(link_target));
-       if (len <= 0)
+       if (len <= 0 || len == (ssize_t)sizeof(link_target))
                return -1;
        link_target[len] = '\0';
        dbg(udev, "path link '%s' points to '%s'\n", syspath, link_target);
@@ -87,13 +89,13 @@ int util_log_priority(const char *priority)
        int prio;
 
        prio = strtol(priority, &endptr, 10);
-       if (endptr[0] == '\0')
+       if (endptr[0] == '\0' || isspace(endptr[0]))
                return prio;
        if (strncmp(priority, "err", 3) == 0)
                return LOG_ERR;
-       if (strcmp(priority, "info") == 0)
+       if (strncmp(priority, "info", 4) == 0)
                return LOG_INFO;
-       if (strcmp(priority, "debug") == 0)
+       if (strncmp(priority, "debug", 5) == 0)
                return LOG_DEBUG;
        return 0;
 }
@@ -448,55 +450,119 @@ 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)
+       if (str == NULL || str_enc == NULL)
                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) {
+                       if (len-j < (size_t)seqlen)
+                               goto err;
                        memcpy(&str_enc[j], &str[i], seqlen);
                        j += seqlen;
                        i += (seqlen-1);
                } else if (str[i] == '\\' || !is_whitelisted(str[i], NULL)) {
+                       if (len-j < 4)
+                               goto err;
                        sprintf(&str_enc[j], "\\x%02x", (unsigned char) str[i]);
                        j += 4;
                } else {
+                       if (len-j < 1)
+                               goto err;
                        str_enc[j] = str[i];
                        j++;
                }
-               if (j+3 >= len)
-                       goto err;
        }
+       if (len-j < 1)
+               goto err;
        str_enc[j] = '\0';
        return 0;
 err:
        return -1;
 }
 
-void util_set_fd_cloexec(int fd)
+/*
+ * http://sites.google.com/site/murmurhash/
+ *
+ * All code is released to the public domain. For business purposes,
+ * Murmurhash is under the MIT license.
+ *
+ */
+static unsigned int murmur_hash2(const char *key, int len, unsigned int seed)
 {
-       int flags;
-
-       flags = fcntl(fd, F_GETFD);
-       if (flags < 0)
-               flags = FD_CLOEXEC;
-       else
-               flags |= FD_CLOEXEC;
-       fcntl(fd, F_SETFD, flags);
+       /*
+        *  'm' and 'r' are mixing constants generated offline.
+        *  They're not really 'magic', they just happen to work well.
+        */
+       const unsigned int m = 0x5bd1e995;
+       const int r = 24;
+
+       /* initialize the hash to a 'random' value */
+       unsigned int h = seed ^ len;
+
+       /* mix 4 bytes at a time into the hash */
+       const unsigned char * data = (const unsigned char *)key;
+
+       while(len >= 4) {
+               unsigned int k = *(unsigned int *)data;
+
+               k *= m; 
+               k ^= k >> r; 
+               k *= m; 
+               h *= m; 
+               h ^= k;
+
+               data += 4;
+               len -= 4;
+       }
+
+       /* handle the last few bytes of the input array */
+       switch(len) {
+       case 3:
+               h ^= data[2] << 16;
+       case 2:
+               h ^= data[1] << 8;
+       case 1:
+               h ^= data[0];
+               h *= m;
+       };
+
+       /* do a few final mixes of the hash to ensure the last few bytes are well-incorporated */
+       h ^= h >> 13;
+       h *= m;
+       h ^= h >> 15;
+
+       return h;
 }
 
 unsigned int util_string_hash32(const char *str)
 {
-       unsigned int hash = 0;
+       return murmur_hash2(str, strlen(str), 0);
+}
 
-       while (str[0] != '\0') {
-               hash += str[0] << 4;
-               hash += str[0] >> 4;
-               hash *= 11;
-               str++;
-       }
-       return hash;
+/* get a bunch of bit numbers out of the hash, and set the bits in our bit field */
+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;
+}
+
+#define USEC_PER_SEC  1000000ULL
+#define NSEC_PER_USEC 1000ULL
+unsigned long long usec_monotonic(void)
+{
+       struct timespec ts;
+
+       if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0)
+               return 0;
+       return (unsigned long long) ts.tv_sec * USEC_PER_SEC +
+              (unsigned long long) ts.tv_nsec / NSEC_PER_USEC;
 }