util_strscpyl(path, sizeof(path), syspath, "/", slink, NULL);
len = readlink(path, path, sizeof(path));
- if (len < 0 || len >= (ssize_t) sizeof(path))
+ if (len <= 0 || len == (ssize_t)sizeof(path))
return -1;
path[len] = '\0';
pos = strrchr(path, '/');
{
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);
{
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;
}