remove unused variable from makefile

[uuid] / internal.c

diff --git a/internal.c b/internal.c
index 59e1bbf402d05b3416b1c1323e625f1f095b9e16..597dc7417ad2e1203073d2a756515391e1789ca2 100644 (file)
--- a/internal.c
+++ b/internal.c
@@ -6,6 +6,9 @@
 #include <stdint.h>
 #include <sys/time.h>
 #include <stdio.h>
+#include <errno.h>
+
+#include <inttypes.h>
 
 #include "hash.h"
 
@@ -37,6 +40,24 @@
 #include <iphlpapi.h>
 #endif
 
+#if 0
+static void pnode(uint64_t node) {
+       unsigned int bytes[6];
+       int i;
+       for (i=0;i<6;i++) {
+               bytes[5-i] = node & 0xff;
+               node >>= 8;
+       }
+
+       fprintf(stderr, "%02x", bytes[0]);
+
+       for (i=1;i<6;i++) {
+               fprintf(stderr, ":%02x", bytes[i]);
+       }
+       fprintf(stderr, "\n");
+}
+#endif
+
 static void set_time_low(pd_uuid_t *u, uint32_t low) {
        u->data[0] = (low >> 24) & 0xff;
        u->data[1] = (low >> 16) & 0xff;
@@ -127,11 +148,12 @@ static int release_global_lock(void *data) {
 static uint64_t current_time(void) {
        uint64_t now;
        struct timeval tv;
+       static int seq = 0;
        
        /* TODO is this BSD specific? */
        gettimeofday(&tv, 0);
 
-       now = (tv.tv_sec * 10000000ULL + tv.tv_usec * 10ULL) + GREGORIAN;
+       now = (tv.tv_sec * 10000000ULL + tv.tv_usec * 10ULL + seq++ % 10) + GREGORIAN;
        return now;
 }
 
@@ -156,6 +178,7 @@ static uint64_t random_mc_mac(struct pd_uuid_state  *s) {
        return node;
 }
 
+
 /*
  * TODO would probably make more sense to use a destination array
  * rather than returning an integer
@@ -186,6 +209,8 @@ static uint64_t current_node(struct pd_uuid_state *st) {
                                if (req->ifr_flags & IFF_NOARP) {
                                        continue;
                                }
+
+
                                if (ioctl(s, SIOCGIFHWADDR, req) == 0) {
                                        data = (unsigned char *)req->ifr_hwaddr.sa_data;
                                        node = data[0];
@@ -195,7 +220,10 @@ static uint64_t current_node(struct pd_uuid_state *st) {
                                        node = node << 8; node += data[4];
                                        node = node << 8; node += data[5];
                                        close(s);
+
                                        return node;
+                               } else {
+                                       fprintf(stderr, "ioctl to read address failed: %d\n", errno);
                                }
                        }
                }
@@ -274,10 +302,16 @@ static uint16_t random_clock_sequence(struct pd_uuid_state *s) {
 }
 
 static int read_state(struct pd_uuid_state *s) {
+       uint64_t        node;
+
        s->available = 0;
-       s->node = 0LL;
-       s->clock_sequence = 0;
-       s->timestamp = 0LL;
+
+       node = current_node(s);
+
+       if (!s->available || s->node != node) {
+               s->clock_sequence = random_clock_sequence(s);
+       }
+       s->node = node;
 
        return 0;
 }
@@ -297,15 +331,21 @@ static unsigned long get_bytes(void *buf, unsigned long n, void *state) {
        return i;
 }
 
-int pd_uuid_init_state(struct pd_uuid_state *s) {
+int pd_uuid_init(struct pd_uuid_state *s, int flags) {
        if (!s) return 0;
 
        s->get_lock = obtain_global_lock;
        s->release_lock = release_global_lock;
        s->lock_data = 0;
 
-       s->read_state = read_state;
-       s->save_state = save_state;
+       if (flags & 0x1) {
+               s->read_state = 0;
+               s->save_state = 0;
+               s->node = current_node(s);
+       } else {
+               s->read_state = read_state;
+               s->save_state = 0;
+       }
 
        s->random_bytes = get_bytes;
        s->rng_state = 0;
@@ -315,66 +355,35 @@ int pd_uuid_init_state(struct pd_uuid_state *s) {
        return 1;
 }
 
-int pd_uuid_make_v1(struct pd_uuid_state *s, pd_uuid_t *uuid) {
-       struct pd_uuid_state    ls;
-       uint64_t        now;
-       uint64_t        node;
-       int err;
-
-       if (!s) {
-               s = &ls;
-               pd_uuid_init_state(s);
-       }
-
-       if (s->get_lock) {
-               if ((err = s->get_lock(s->lock_data)) != 0) {
-                       /* TODO set uuid to nil ? */
-                       /* be cute and have an "error" uuid? */
-                       return 0;
-               }
-       }
-
-       if (s->read_state) {
-               if ((err = s->read_state(s)) != 0) {
-                       return 0;
-               }
-       }
-
-       now = current_time();
-       node = current_node(s);
-
-       if (!s->available || s->node != node) {
-               s->clock_sequence = random_clock_sequence(s);
-       }
-
-       s->node = node;
+int pd_uuid_init_state(struct pd_uuid_state *s) {
+       if (!s) return 0;
 
-       if (s->available && s->timestamp > now) {
-               s->clock_sequence++;
-       } else {
-               s->timestamp = now;
-       }
+       s->get_lock = obtain_global_lock;
+       s->release_lock = release_global_lock;
+       s->lock_data = 0;
 
-       if (s->save_state) {
-               if ((err = s->save_state(s)) != 0) {
-                       return 0;
-               }
-       }
+       s->read_state = read_state;
+       s->save_state = save_state;
 
-       if (s->release_lock) {
-               if ((err = s->release_lock(s->lock_data)) != 0) {
-                       /* TODO set uuid to nil ? */
-                       /* be cute and have an "error" uuid? */
-                       return 0;
-               }
-       }
+       s->random_bytes = get_bytes;
+       s->rng_state = 0;
+       s->node = 0;
 
-       format_uuid(uuid, s, 1);
+       s->available = 0;
 
        return 1;
 }
+static int pd_uuid_make_v1_any(struct pd_uuid_state *s, pd_uuid_t *uuid, int rmac);
+
+int pd_uuid_make_v1(struct pd_uuid_state *s, pd_uuid_t *uuid) {
+       return pd_uuid_make_v1_any(s, uuid, 0);
+}
 
 int pd_uuid_make_v1mc(struct pd_uuid_state *s, pd_uuid_t *uuid) {
+       return pd_uuid_make_v1_any(s, uuid, 1);
+}
+
+static int pd_uuid_make_v1_any(struct pd_uuid_state *s, pd_uuid_t *uuid, int rmac) {
        struct pd_uuid_state    ls;
        uint64_t        now;
        uint64_t        node;
@@ -400,7 +409,11 @@ int pd_uuid_make_v1mc(struct pd_uuid_state *s, pd_uuid_t *uuid) {
        }
 
        now = current_time();
-       node = random_mc_mac(s);
+       if (rmac) {
+               node = random_mc_mac(s);
+       } else {
+               node = current_node(s);
+       }
 
        if (!s->available || s->node != node) {
                s->clock_sequence = random_clock_sequence(s);
@@ -475,6 +488,33 @@ int pd_uuid_make_v5(struct pd_uuid_state *s, pd_uuid_t *uuid, pd_uuid_t *ns, voi
        return 1;
 }
 
+/*
+ * s must point to enough space, i.e. at least 37 bytes.
+ * this is constrained enough that sprintf could
+ * probably be avoided
+ */
+char *pd_uuid_get_string(pd_uuid_t *uuid, char *s) {
+       char *r;
+       int i;
+
+       r = s;
+
+       for (i=0;i<16;i++) {
+               r += sprintf(r, "%.2x", (int)uuid->data[i]);
+               if (i == 3 || i == 5 || i == 7 || i == 9) {
+                       *r++ = '-';
+                       *r = 0;
+               }
+       }
+
+       return s;
+}
+
+/*
+ * might be faster to sscanf in four bytes at a time
+ * and using htonl()
+ * A nybble loop might be faster yet.
+ */
 int pd_uuid_set_string(pd_uuid_t *uuid, char *s) {
        unsigned int byte;
        int i;