netdev-dpdk: fix mbuf leaks

[cascardo/ovs.git] / lib / uuid.c

diff --git a/lib/uuid.c b/lib/uuid.c
index 620c039..0f2a58e 100644 (file)
--- a/lib/uuid.c
+++ b/lib/uuid.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008, 2009, 2010 Nicira Networks
+/* Copyright (c) 2008, 2009, 2010, 2011, 2013 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,8 +25,10 @@
 #include <unistd.h>
 
 #include "aes128.h"
+#include "entropy.h"
+#include "ovs-thread.h"
 #include "sha1.h"
-#include "socket-util.h"
+#include "timeval.h"
 #include "util.h"
 
 static struct aes128 key;
@@ -34,7 +36,6 @@ static uint64_t counter[2];
 BUILD_ASSERT_DECL(sizeof counter == 16);
 
 static void do_init(void);
-static void read_urandom(void *buffer, size_t n);
 
 /*
  * Initialize the UUID module.  Aborts the program with an error message if
@@ -49,11 +50,8 @@ static void read_urandom(void *buffer, size_t n);
 void
 uuid_init(void)
 {
-    static bool inited;
-    if (!inited) {
-        do_init();
-        inited = true;
-    }
+    static pthread_once_t once = PTHREAD_ONCE_INIT;
+    pthread_once(&once, do_init);
 }
 
 /* Generates a new random UUID in 'uuid'.
@@ -83,16 +81,29 @@ uuid_init(void)
 void
 uuid_generate(struct uuid *uuid)
 {
+    static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
+    uint64_t copy[2];
+
     uuid_init();
 
-    /* Increment the counter. */
+    /* Copy out the counter's current value, then increment it. */
+    ovs_mutex_lock(&mutex);
+    copy[0] = counter[0];
+    copy[1] = counter[1];
     if (++counter[1] == 0) {
         counter[0]++;
     }
+    ovs_mutex_unlock(&mutex);
 
     /* AES output is exactly 16 bytes, so we encrypt directly into 'uuid'. */
-    aes128_encrypt(&key, counter, uuid);
+    aes128_encrypt(&key, copy, uuid);
+
+    uuid_set_bits_v4(uuid);
+}
 
+void
+uuid_set_bits_v4(struct uuid *uuid)
+{
     /* Set bits to indicate a random UUID.  See RFC 4122 section 4.4. */
     uuid->parts[2] &= ~0xc0000000;
     uuid->parts[2] |=  0x80000000;
@@ -141,48 +152,69 @@ uuid_compare_3way(const struct uuid *a, const struct uuid *b)
 bool
 uuid_from_string(struct uuid *uuid, const char *s)
 {
-    static const char template[] = "00000000-1111-1111-2222-222233333333";
-    const char *t;
+    if (!uuid_from_string_prefix(uuid, s)) {
+        return false;
+    } else if (s[UUID_LEN] != '\0') {
+        uuid_zero(uuid);
+        return false;
+    } else {
+        return true;
+    }
+}
+
+/* Same as uuid_from_string() but s[UUID_LEN] is not required to be a null byte
+ * to succeed; that is, 's' need only begin with UUID syntax, not consist
+ * entirely of it. */
+bool
+uuid_from_string_prefix(struct uuid *uuid, const char *s)
+{
+    /* 0         1         2         3      */
+    /* 012345678901234567890123456789012345 */
+    /* ------------------------------------ */
+    /* 00000000-1111-1111-2222-222233333333 */
 
-    uuid_zero(uuid);
-    for (t = template; ; t++, s++) {
-        if (*t >= '0' && *t <= '3') {
-            uint32_t *part = &uuid->parts[*t - '0'];
-            if (!isxdigit(*s)) {
-                goto error;
-            }
-            *part = (*part << 4) + hexit_value(*s);
-        } else if (*t != *s) {
-            goto error;
-        } else if (*t == 0) {
-            return true;
-        }
+    bool ok;
+
+    uuid->parts[0] = hexits_value(s, 8, &ok);
+    if (!ok || s[8] != '-') {
+        goto error;
     }
 
+    uuid->parts[1] = hexits_value(s + 9, 4, &ok) << 16;
+    if (!ok || s[13] != '-') {
+        goto error;
+    }
+
+    uuid->parts[1] += hexits_value(s + 14, 4, &ok);
+    if (!ok || s[18] != '-') {
+        goto error;
+    }
+
+    uuid->parts[2] = hexits_value(s + 19, 4, &ok) << 16;
+    if (!ok || s[23] != '-') {
+        goto error;
+    }
+
+    uuid->parts[2] += hexits_value(s + 24, 4, &ok);
+    if (!ok) {
+        goto error;
+    }
+
+    uuid->parts[3] = hexits_value(s + 28, 8, &ok);
+    if (!ok) {
+        goto error;
+    }
+    return true;
+
 error:
     uuid_zero(uuid);
     return false;
 }
 \f
 static void
-read_urandom(void *buffer, size_t n)
+sha1_update_int(struct sha1_ctx *sha1_ctx, uintmax_t x)
 {
-    static const char urandom[] = "/dev/urandom";
-    size_t bytes_read;
-    int error;
-    int fd;
-
-    fd = open(urandom, O_RDONLY);
-    if (fd < 0) {
-        ovs_fatal(errno, "%s: open failed", urandom);
-    }
-    error = read_fully(fd, buffer, n, &bytes_read);
-    if (error == EOF) {
-        ovs_fatal(0, "%s: unexpected end of file", urandom);
-    } else if (error) {
-        ovs_fatal(error, "%s: read error", urandom);
-    }
-    close(fd);
+   sha1_update(sha1_ctx, &x, sizeof x);
 }
 
 static void
@@ -192,27 +224,21 @@ do_init(void)
     struct sha1_ctx sha1_ctx;
     uint8_t random_seed[16];
     struct timeval now;
-    pid_t pid, ppid;
-    uid_t uid;
-    gid_t gid;
 
     /* Get seed data. */
-    read_urandom(random_seed, sizeof random_seed);
-    if (gettimeofday(&now, NULL)) {
-        ovs_fatal(errno, "gettimeofday failed");
-    }
-    pid = getpid();
-    ppid = getppid();
-    uid = getuid();
-    gid = getgid();
+    get_entropy_or_die(random_seed, sizeof random_seed);
+    xgettimeofday(&now);
 
     /* Convert seed into key. */
     sha1_init(&sha1_ctx);
     sha1_update(&sha1_ctx, random_seed, sizeof random_seed);
-    sha1_update(&sha1_ctx, &pid, sizeof pid);
-    sha1_update(&sha1_ctx, &ppid, sizeof ppid);
-    sha1_update(&sha1_ctx, &uid, sizeof uid);
-    sha1_update(&sha1_ctx, &gid, sizeof gid);
+    sha1_update(&sha1_ctx, &now, sizeof now);
+    sha1_update_int(&sha1_ctx, getpid());
+#ifndef _WIN32
+    sha1_update_int(&sha1_ctx, getppid());
+    sha1_update_int(&sha1_ctx, getuid());
+    sha1_update_int(&sha1_ctx, getgid());
+#endif
     sha1_final(&sha1_ctx, sha1);
 
     /* Generate key. */
@@ -220,5 +246,5 @@ do_init(void)
     aes128_schedule(&key, sha1);
 
     /* Generate initial counter. */
-    read_urandom(counter, sizeof counter);
+    get_entropy_or_die(counter, sizeof counter);
 }