]> pd.if.org Git - uuid/blob - internal.c
Added test framework
[uuid] / internal.c
1 /*
2  * internal functions for uuid library
3  *
4  * written by nathan wagner and placed in the public domain
5  */
6 #include <stdint.h>
7 #include <sys/time.h>
8 #include <stdio.h>
9
10 #include "hash.h"
11
12 #include "pduuid.h"
13
14 #ifdef __linux__
15 #include <sys/ioctl.h>
16 #include <sys/types.h>
17 #include <sys/socket.h>
18 #include <netinet/in.h>
19 #include <linux/if.h>
20 #endif
21
22 #ifdef __APPLE__
23 #include <sys/types.h>
24 #include <sys/socket.h>
25 #include <net/if_dl.h>
26 #include <ifaddrs.h>
27 #endif
28
29 #ifdef WIN32
30 #include <windows.h>
31 #include <iphlpapi.h>
32 #endif
33
34 #ifdef __CYGWIN__
35 #include <windows.h>
36 #include <iphlpapi.h>
37 #endif
38
39 static void set_time_low(pd_uuid_t *u, uint32_t low) {
40         u->data[0] = (low >> 24) & 0xff;
41         u->data[1] = (low >> 16) & 0xff;
42         u->data[2] = (low >> 8) & 0xff;
43         u->data[3] = low & 0xff;
44 }
45
46 static void set_time_mid(pd_uuid_t *u, uint16_t mid) {
47         u->data[4] = (mid >> 8) & 0xff;
48         u->data[5] = mid & 0xff;
49 }
50
51 static void set_time_hi(pd_uuid_t *u, uint16_t hi) {
52         u->data[7] = hi & 0xff;
53         u->data[6] &= 0xf0;
54         u->data[6] |= (hi >> 8) & 0xf;
55 }
56
57 static void set_version(pd_uuid_t *u, uint8_t version) {
58         u->data[6] &= 0xf;
59         u->data[6] |= (version & 0xf) << 4;
60 }
61
62 static void set_clock_seq_low(pd_uuid_t *u, uint8_t low) {
63         u->data[9] = low & 0xff;
64 }
65
66 static void set_clock_seq_hi(pd_uuid_t *u, uint8_t hi) {
67         u->data[8] &= 0xc0;
68         u->data[8] |= hi & 0x3f;
69 }
70
71 static void set_reserved(pd_uuid_t *u, uint8_t reserved) {
72         u->data[8] &= 0x3f;
73         u->data[8] |= (reserved & 0x3) << 6;
74 }
75
76 #if 0
77 static void set_node(pd_uuid_t *u, uint8_t data[6]) {
78         u->data[10] = data[0];
79         u->data[11] = data[1];
80         u->data[12] = data[2];
81         u->data[13] = data[3];
82         u->data[14] = data[4];
83         u->data[15] = data[5];
84 }
85 #endif
86
87 static void set_node64(pd_uuid_t *u, uint64_t node) {
88         u->data[10] = (node >> 40) & 0xff;
89         u->data[11] = (node >> 32) & 0xff;
90         u->data[12] = (node >> 24) & 0xff;
91         u->data[13] = (node >> 16) & 0xff;
92         u->data[14] = (node >> 8) & 0xff;
93         u->data[15] = (node >> 0) & 0xff;
94 }
95
96 static void set_timestamp(pd_uuid_t *u, uint64_t ts) {
97         set_time_low(u, ts & 0xffffffff);
98         set_time_mid(u, (ts >> 32) & 0xffff);
99         set_time_hi(u, (ts >> 48) & 0xfff);
100 }
101
102 static void set_clockseq(pd_uuid_t *u, uint16_t seq) {
103         set_clock_seq_low(u, seq & 0xff);
104         set_clock_seq_hi(u, (seq >> 8) & 0xff);
105 }
106
107 static void format_uuid(pd_uuid_t *u, struct pd_uuid_state *s, int version) {
108         set_timestamp(u, s->timestamp);
109         set_version(u, version);
110         set_clockseq(u, s->clock_sequence);
111         set_reserved(u, 0x2);
112         set_node64(u, s->node);
113 }
114
115 static int obtain_global_lock(void *data) {
116         /* no-op */
117         return 0;
118 }
119
120 static int release_global_lock(void *data) {
121         /* no-op */
122         return 0;
123 }
124
125 #define GREGORIAN 122192928000000000ULL
126 static uint64_t current_time(void) {
127         uint64_t now;
128         struct timeval tv;
129         
130         /* TODO is this BSD specific? */
131         gettimeofday(&tv, 0);
132
133         now = (tv.tv_sec * 10000000ULL + tv.tv_usec * 10ULL) + GREGORIAN;
134         return now;
135 }
136
137 static void random_bytes(void *buf, size_t n) {
138         unsigned char *s = buf;
139         int i = 0;
140
141         while (i < n) {
142                 i += pd_uuid_rng_get_bytes(s+i, n-i);
143         }
144 }
145
146 static uint64_t random_mc_mac(struct pd_uuid_state  *s) {
147         uint64_t node = 0;
148
149         if (s && s->random_bytes) {
150                 s->random_bytes(&node, sizeof node, s->rng_state);
151         } else {
152                 random_bytes(&node, sizeof node);
153         }
154         node |= 0x800000000000ULL; /* rfc 4.5 */
155         return node;
156 }
157
158 /*
159  * TODO would probably make more sense to use a destination array
160  * rather than returning an integer
161  */
162 static uint64_t current_node(struct pd_uuid_state *st) {
163         uint64_t node = 0;
164
165 #ifdef __linux__
166         struct ifconf   conf;
167         struct ifreq    *req;
168         struct ifreq    interfaces[4];
169         int s, i;
170         unsigned char *data;
171
172         s = socket(AF_INET, SOCK_DGRAM, 0);
173         if (s != -1) {
174                 conf.ifc_len = sizeof interfaces;
175                 conf.ifc_req = interfaces;
176                 if (ioctl(s, SIOCGIFCONF, &conf) == 0)  {
177                         for (i=0; i < 4; i++) {
178                                 req = &conf.ifc_req[i];
179                                 if (ioctl(s, SIOCGIFFLAGS, req) != 0) {
180                                         continue;
181                                 }
182                                 if (req->ifr_flags & IFF_LOOPBACK) {
183                                         continue;
184                                 }
185                                 if (req->ifr_flags & IFF_NOARP) {
186                                         continue;
187                                 }
188                                 if (ioctl(s, SIOCGIFHWADDR, req) == 0) {
189                                         int j;
190                                         data = (unsigned char *)req->ifr_hwaddr.sa_data;
191                                         node = data[0];
192                                         node = node << 8; node += data[1];
193                                         node = node << 8; node += data[2];
194                                         node = node << 8; node += data[3];
195                                         node = node << 8; node += data[4];
196                                         node = node << 8; node += data[5];
197                                         return node;
198                                 }
199                         }
200                 }
201         }
202 #endif
203
204         /* this is any BSD based system i think */
205 #ifdef __APPLE__
206         struct ifaddrs *addrs;
207         struct ifaddrs *a;
208         struct sockaddr_dl *dl;
209         unsigned char *data;
210         if (getifaddrs(&addrs) == 0) {
211                 for (a = addrs; a; a = a->ifa_next) {
212
213                         if (a->ifa_addr && a->ifa_addr->sa_family == AF_LINK) {
214                                 dl = (struct sockaddr_dl *)a->ifa_addr;
215                                 data = (unsigned char *)(dl->sdl_data + dl->sdl_nlen);
216                                 if (dl->sdl_alen != 6) continue;
217
218                                 node = data[0];
219                                 node = node << 8; node += data[1];
220                                 node = node << 8; node += data[2];
221                                 node = node << 8; node += data[3];
222                                 node = node << 8; node += data[4];
223                                 node = node << 8; node += data[5];
224                                 freeifaddrs(addrs);
225                                 return node;
226                         }
227                 }
228                 freeifaddrs(addrs);
229         }
230 #endif
231
232 #if defined(WIN32) || defined(__CYGWIN__)
233         IP_ADAPTER_INFO addrs[4];
234         DWORD size;
235         int rc;
236         unsigned char *data;
237
238         size = sizeof addrs;
239         rc = GetAdaptersInfo(addrs, &size);
240         if (rc == ERROR_SUCCESS) {
241                 PIP_ADAPTER_INFO info;
242                 for (info = addrs; info; info = info->Next) {
243                         if (info->Type != MIB_IF_TYPE_ETHERNET) {
244                                 continue;
245                         }
246                         data = info->Address;
247                         node = data[0];
248                         node = node << 8; node += data[1];
249                         node = node << 8; node += data[2];
250                         node = node << 8; node += data[3];
251                         node = node << 8; node += data[4];
252                         node = node << 8; node += data[5];
253                 }
254                 return node;
255         }
256 #endif
257
258         /* if we get here, use a random multicast address */
259         node = random_mc_mac(st);
260         return node;
261 }
262
263 static uint16_t random_clock_sequence(struct pd_uuid_state *s) {
264         uint16_t seq;
265
266         if (s && s->random_bytes) {
267                 s->random_bytes(&seq, sizeof seq, s->rng_state);
268         } else {
269                 random_bytes(&seq, sizeof seq);
270         }
271         return seq;
272 }
273
274 static int read_state(struct pd_uuid_state *s) {
275         s->available = 0;
276         s->node = 0LL;
277         s->clock_sequence = 0;
278         s->timestamp = 0LL;
279
280         return 0;
281 }
282
283 static int save_state(struct pd_uuid_state *s) {
284         /* no op */
285         return 0;
286 }
287
288 static unsigned long get_bytes(void *buf, unsigned long n, void *state) {
289         unsigned char *s = buf;
290         int i = 0;
291
292         while (i < n) {
293                 i += pd_uuid_rng_get_bytes(s+i, n-i);
294         }
295         return i;
296 }
297
298 int pd_uuid_init_state(struct pd_uuid_state *s) {
299         if (!s) return 0;
300
301         s->get_lock = obtain_global_lock;
302         s->release_lock = release_global_lock;
303         s->lock_data = 0;
304
305         s->read_state = read_state;
306         s->save_state = save_state;
307
308         s->random_bytes = get_bytes;
309         s->rng_state = 0;
310
311         s->available = 0;
312
313         return 1;
314 }
315
316 int pd_uuid_make_v1(struct pd_uuid_state *s, pd_uuid_t *uuid) {
317         struct pd_uuid_state    ls;
318         uint64_t        now;
319         uint64_t        node;
320         int err;
321
322         if (!s) {
323                 s = &ls;
324                 pd_uuid_init_state(s);
325         }
326
327         if (s->get_lock) {
328                 if ((err = s->get_lock(s->lock_data)) != 0) {
329                         /* TODO set uuid to nil ? */
330                         /* be cute and have an "error" uuid? */
331                         return 0;
332                 }
333         }
334
335         if (s->read_state) {
336                 if ((err = s->read_state(s)) != 0) {
337                         return 0;
338                 }
339         }
340
341         now = current_time();
342         node = current_node(s);
343
344         if (!s->available || s->node != node) {
345                 s->clock_sequence = random_clock_sequence(s);
346         }
347         s->node = node;
348
349         if (s->available && s->timestamp > now) {
350                 s->clock_sequence++;
351         } else {
352                 s->timestamp = now;
353         }
354
355         if (s->save_state) {
356                 if ((err = s->save_state(s)) != 0) {
357                         return 0;
358                 }
359         }
360
361         if (s->release_lock) {
362                 if ((err = s->release_lock(s->lock_data)) != 0) {
363                         /* TODO set uuid to nil ? */
364                         /* be cute and have an "error" uuid? */
365                         return 0;
366                 }
367         }
368
369         format_uuid(uuid, s, 1);
370
371         return 1;
372 }
373
374 int pd_uuid_make_v1mc(struct pd_uuid_state *ps, pd_uuid_t *uuid) {
375         struct pd_uuid_state    s;
376         uint64_t        now;
377         uint64_t        node;
378
379         obtain_global_lock(0);
380         read_state(&s);
381         now = current_time();
382         node = random_mc_mac(&s);
383         if (!s.available) {
384                 s.clock_sequence = random_clock_sequence(&s);
385         }
386
387         if (s.available && s.timestamp > now) {
388                 s.clock_sequence++;
389         } else {
390                 s.timestamp = now;
391         }
392
393         save_state(&s);
394         release_global_lock(0);
395         s.node = node;
396
397         format_uuid(uuid, &s, 1);
398
399         return 1;
400 }
401
402 int pd_uuid_make_v4(struct pd_uuid_state *s, pd_uuid_t *uuid) {
403         random_bytes(uuid, sizeof *uuid);
404         set_version(uuid, 4);
405         set_reserved(uuid, 0x2);
406         return 1;
407 }
408
409 int pd_set_uuid_hash(struct pd_uuid *s, void *hash, int version) {
410         int i;
411         unsigned char *h = hash;
412
413         for (i=0;i<16;i++) {
414                 s->data[i] = h[i];
415         }
416         set_version(s, version);
417         set_reserved(s, 0x2);
418         return 1;
419 }
420
421 int pd_uuid_make_v3(struct pd_uuid_state *s, pd_uuid_t *uuid, pd_uuid_t *ns, void *data, int len) {
422         hash_state hs;
423         unsigned char hash[16];
424
425         md5_init(&hs);
426         md5_process(&hs, ns->data, 16);
427         md5_process(&hs, data, len);
428         md5_done(&hs, hash);
429         pd_set_uuid_hash(uuid, hash, 3);
430         return 1;
431 }
432
433 int pd_uuid_make_v5(struct pd_uuid_state *s, pd_uuid_t *uuid, pd_uuid_t *ns, void *data, int len) {
434         hash_state hs;
435         unsigned char hash[20];
436
437         sha1_init(&hs);
438         sha1_process(&hs, ns->data, sizeof *ns);
439         sha1_process(&hs, data, len);
440         sha1_done(&hs, hash);
441         pd_set_uuid_hash(uuid, hash, 5);
442         return 1;
443 }
444
445 int pd_uuid_set_string(pd_uuid_t *uuid, char *s) {
446         unsigned int byte;
447         int i;
448
449         for (i=0;i<16;i++) {
450                 if (*s == 0) return 0;
451                 if (*s == '-') s++;
452
453                 if (sscanf(s, "%02x", &byte) != 1) {
454                         return 0;
455                 }
456                 s += 2;
457                 uuid->data[i] = byte & 0xff;
458         }
459         return 1;
460 }
461
462 /* pre-defined namespace uuids */
463
464 pd_uuid_t pd_uuid_ns_dns = {
465         {
466                 0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1,
467                 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
468         }
469 };
470
471 pd_uuid_t pd_uuid_ns_url = {
472         {
473                 0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1,
474                 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
475         }
476 };
477
478 pd_uuid_t pd_uuid_ns_oid = {
479         {
480                 0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1,
481                 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
482         }
483 };
484
485 pd_uuid_t pd_uuid_ns_x500 = {
486         {
487                 0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1,
488                 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8
489         }
490 };
491
492 int pd_uuid_copy(pd_uuid_t *src, pd_uuid_t *dst) {
493         if (src && dst) {
494                 memcpy(dst->data, src->data, 16);
495                 return 1;
496         }
497         return 0;
498 }
499
500 int pd_uuid_cmp(pd_uuid_t *a, pd_uuid_t *b) {
501         if (a && b) {
502                 return memcmp(a, b, 16);
503         }
504         return 1;
505 }