4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright 2012 Milan Jurik. All rights reserved.
25 * Copyright 2014 Joyent, Inc. All rights reserved.
26 * Copyright 2014 Andrew Stormont.
30 * The copyright in this file is taken from the original Leach & Salz
31 * UUID specification, from which this implementation is derived.
35 * Copyright (c) 1990- 1993, 1996 Open Software Foundation, Inc.
36 * Copyright (c) 1989 by Hewlett-Packard Company, Palo Alto, Ca. &
37 * Digital Equipment Corporation, Maynard, Mass. Copyright (c) 1998
38 * Microsoft. To anyone who acknowledges that this file is provided
39 * "AS IS" without any express or implied warranty: permission to use,
40 * copy, modify, and distribute this file for any purpose is hereby
41 * granted without fee, provided that the above copyright notices and
42 * this notice appears in all source code copies, and that none of the
43 * names of Open Software Foundation, Inc., Hewlett-Packard Company,
44 * or Digital Equipment Corporation be used in advertising or
45 * publicity pertaining to distribution of the software without
46 * specific, written prior permission. Neither Open Software
47 * Foundation, Inc., Hewlett-Packard Company, Microsoft, nor Digital
48 * Equipment Corporation makes any representations about the
49 * suitability of this software for any purpose.
53 * This module is the workhorse for generating abstract
54 * UUIDs. It delegates system-specific tasks (such
55 * as obtaining the node identifier or system time)
56 * to the sysdep module.
60 #include <sys/param.h>
70 #include "uuid_misc.h"
72 shared_buffer_t
*data
;
74 static uuid_node_t node_id_cache
;
80 * The urandmtx mutex prevents multiple opens of /dev/urandom and protects the
83 #define RCACHE_SIZE 65535
84 static mutex_t urandmtx
;
85 static int fd_urand
= -1;
86 static char rcache
[RCACHE_SIZE
];
87 static char *rcachep
= rcache
;
92 uint16_t get_random(void);
93 void get_current_time(uuid_time_t
*);
95 void struct_to_string(uuid_t
, struct uuid
*);
96 void string_to_struct(struct uuid
*, uuid_t
);
97 int get_ethernet_address(uuid_node_t
*);
102 static int map_state();
103 static void format_uuid(struct uuid
*, uint16_t, uuid_time_t
,
105 static void fill_random_bytes(uchar_t
*, int);
106 static int uuid_create(struct uuid
*);
107 static void gen_ethernet_address(uuid_node_t
*);
108 static void revalidate_data(uuid_node_t
*);
111 * Generates a uuid based on version 1 format.
112 * Returns 0 on success and -1 on failure.
115 uuid_create(struct uuid
*uuid
)
117 uuid_time_t timestamp
;
118 uuid_node_t system_node
;
119 int ret
, non_unique
= 0;
122 * Get the system MAC address and/or cache it
125 bcopy(&node_id_cache
, &system_node
, sizeof (uuid_node_t
));
127 gen_ethernet_address(&system_node
);
128 bcopy(&system_node
, &node_id_cache
, sizeof (uuid_node_t
));
133 * Access the state file, mmap it and initialize the shared lock.
134 * file_type tells us whether we had access to the state file or
135 * created a temporary one.
137 if (map_state() == -1)
144 if ((ret
= mutex_lock(&data
->lock
)) == 0)
149 revalidate_data(&system_node
);
150 (void) mutex_consistent(&data
->lock
);
151 (void) mutex_unlock(&data
->lock
);
153 case ENOTRECOVERABLE
:
158 /* State file is either new or is temporary, get a random clock seq */
159 if (data
->state
.clock
== 0) {
160 data
->state
.clock
= get_random();
164 if (memcmp(&system_node
, &data
->state
.node
, sizeof (uuid_node_t
)) != 0)
167 get_current_time(×tamp
);
170 * If timestamp is not set or is not in the past, bump
173 if ((data
->state
.ts
== 0) || (data
->state
.ts
>= timestamp
)) {
175 data
->state
.ts
= timestamp
;
179 system_node
.nodeID
[0] |= 0x80;
181 /* Stuff fields into the UUID struct */
182 format_uuid(uuid
, data
->state
.clock
, timestamp
, system_node
);
184 (void) mutex_unlock(&data
->lock
);
190 * Fills system_node with Ethernet address if available,
191 * else fills random numbers
194 gen_ethernet_address(uuid_node_t
*system_node
)
198 if (get_ethernet_address(system_node
) != 0) {
199 fill_random_bytes(node
, 6);
200 (void) memcpy(system_node
->nodeID
, node
, 6);
202 * use 8:0:20 with the multicast bit set
203 * to avoid namespace collisions.
205 system_node
->nodeID
[0] = 0x88;
206 system_node
->nodeID
[1] = 0x00;
207 system_node
->nodeID
[2] = 0x20;
212 * Formats a UUID, given the clock_seq timestamp, and node address.
213 * Fills in passed-in pointer with the resulting uuid.
216 format_uuid(struct uuid
*uuid
, uint16_t clock_seq
,
217 uuid_time_t timestamp
, uuid_node_t node
)
221 * First set up the first 60 bits from the timestamp
223 uuid
->time_low
= (uint32_t)(timestamp
& 0xFFFFFFFF);
224 uuid
->time_mid
= (uint16_t)((timestamp
>> 32) & 0xFFFF);
225 uuid
->time_hi_and_version
= (uint16_t)((timestamp
>> 48) & 0x0FFF);
228 * This is version 1, so say so in the UUID version field (4 bits)
230 uuid
->time_hi_and_version
|= (1 << 12);
233 * Now do the clock sequence
235 uuid
->clock_seq_low
= clock_seq
& 0xFF;
238 * We must save the most-significant 2 bits for the reserved field
240 uuid
->clock_seq_hi_and_reserved
= (clock_seq
& 0x3F00) >> 8;
243 * The variant for this format is the 2 high bits set to 10,
246 uuid
->clock_seq_hi_and_reserved
|= 0x80;
249 * write result to passed-in pointer
251 (void) memcpy(&uuid
->node_addr
, &node
, sizeof (uuid
->node_addr
));
255 * Opens/creates the state file, falling back to a tmp
262 /* If file's mapped, return */
266 if ((fd
= open(STATE_LOCATION
, O_RDWR
)) < 0) {
267 file_type
= TEMP_FILE
;
269 if ((tmp
= tmpfile()) == NULL
)
274 file_type
= STATE_FILE
;
277 (void) ftruncate(fd
, (off_t
)sizeof (shared_buffer_t
));
279 /* LINTED - alignment */
280 data
= (shared_buffer_t
*)mmap(NULL
, sizeof (shared_buffer_t
),
281 PROT_READ
|PROT_WRITE
, MAP_SHARED
, fd
, 0);
283 if (data
== MAP_FAILED
)
286 (void) mutex_init(&data
->lock
, USYNC_PROCESS
|LOCK_ROBUST
, 0);
294 revalidate_data(uuid_node_t
*node
)
300 for (i
= 0; i
< sizeof (data
->state
.node
.nodeID
); i
++)
301 data
->state
.node
.nodeID
[i
] = 0;
303 data
->state
.clock
= 0;
305 gen_ethernet_address(node
);
306 bcopy(node
, &node_id_cache
, sizeof (uuid_node_t
));
311 * Prints a nicely-formatted uuid to stdout.
314 uuid_print(struct uuid u
)
318 (void) printf("%8.8x-%4.4x-%4.4x-%2.2x%2.2x-", u
.time_low
, u
.time_mid
,
319 u
.time_hi_and_version
, u
.clock_seq_hi_and_reserved
,
321 for (i
= 0; i
< 6; i
++)
322 (void) printf("%2.2x", u
.node_addr
[i
]);
327 * Only called with urandmtx held.
328 * Fills/refills the cache of randomness. We know that our allocations of
329 * randomness are always much less than the total size of the cache.
330 * Tries to use /dev/urandom random number generator - if that fails for some
331 * reason, it retries MAX_RETRY times then sets rcachep to NULL so we no
332 * longer use the cache.
338 int nbytes
= RCACHE_SIZE
;
342 i
= read(fd_urand
, buf
, nbytes
);
343 if ((i
< 0) && (errno
== EINTR
)) {
347 if (retries
++ == MAX_RETRY
)
364 (void) mutex_lock(&urandmtx
);
370 (void) mutex_unlock(&urandmtx
);
376 if (fd_urand
!= -1) {
377 (void) close(fd_urand
);
380 (void) mutex_unlock(&urandmtx
);
383 #pragma init(cache_init)
387 (void) pthread_atfork(close_pre
, close_parent
, close_child
);
391 * Fills buf with random numbers - nbytes is the number of bytes
392 * to fill-in. Tries to use cached data from the /dev/urandom random number
393 * generator - if that fails for some reason, it uses srand48(3C)
396 fill_random_bytes(uchar_t
*buf
, int nbytes
)
400 if (fd_urand
== -1) {
401 (void) mutex_lock(&urandmtx
);
402 /* check again now that we have the mutex */
403 if (fd_urand
== -1) {
404 if ((fd_urand
= open(URANDOM_PATH
,
405 O_RDONLY
| O_CLOEXEC
)) >= 0)
408 (void) mutex_unlock(&urandmtx
);
410 if (fd_urand
>= 0 && rcachep
!= NULL
) {
413 (void) mutex_lock(&urandmtx
);
414 if (rcachep
!= NULL
&&
415 (rcachep
+ nbytes
) >= (rcache
+ RCACHE_SIZE
))
418 if (rcachep
!= NULL
) {
419 for (cnt
= 0; cnt
< nbytes
; cnt
++)
421 (void) mutex_unlock(&urandmtx
);
424 (void) mutex_unlock(&urandmtx
);
426 for (i
= 0; i
< nbytes
; i
++) {
427 *buf
++ = get_random() & 0xFF;
432 * Unpacks the structure members in "struct uuid" to a char string "uuid_t".
435 struct_to_string(uuid_t ptr
, struct uuid
*uu
)
441 out
[3] = (uchar_t
)tmp
;
443 out
[2] = (uchar_t
)tmp
;
445 out
[1] = (uchar_t
)tmp
;
447 out
[0] = (uchar_t
)tmp
;
450 out
[5] = (uchar_t
)tmp
;
452 out
[4] = (uchar_t
)tmp
;
454 tmp
= uu
->time_hi_and_version
;
455 out
[7] = (uchar_t
)tmp
;
457 out
[6] = (uchar_t
)tmp
;
459 tmp
= uu
->clock_seq_hi_and_reserved
;
460 out
[8] = (uchar_t
)tmp
;
461 tmp
= uu
->clock_seq_low
;
462 out
[9] = (uchar_t
)tmp
;
464 (void) memcpy(out
+10, uu
->node_addr
, 6);
469 * Packs the values in the "uuid_t" string into "struct uuid".
472 string_to_struct(struct uuid
*uuid
, uuid_t in
)
480 tmp
= (tmp
<< 8) | *ptr
++;
481 tmp
= (tmp
<< 8) | *ptr
++;
482 tmp
= (tmp
<< 8) | *ptr
++;
483 uuid
->time_low
= tmp
;
486 tmp
= (tmp
<< 8) | *ptr
++;
487 uuid
->time_mid
= tmp
;
490 tmp
= (tmp
<< 8) | *ptr
++;
491 uuid
->time_hi_and_version
= tmp
;
494 uuid
->clock_seq_hi_and_reserved
= tmp
;
497 uuid
->clock_seq_low
= tmp
;
499 (void) memcpy(uuid
->node_addr
, ptr
, 6);
504 * Generates UUID based on DCE Version 4
507 uuid_generate_random(uuid_t uu
)
514 (void) memset(uu
, 0, sizeof (uuid_t
));
515 (void) memset(&uuid
, 0, sizeof (struct uuid
));
517 fill_random_bytes(uu
, sizeof (uuid_t
));
518 string_to_struct(&uuid
, uu
);
520 * This is version 4, so say so in the UUID version field (4 bits)
522 uuid
.time_hi_and_version
|= (1 << 14);
524 * we don't want the bit 1 to be set also which is for version 1
526 uuid
.time_hi_and_version
&= VER1_MASK
;
529 * The variant for this format is the 2 high bits set to 10,
532 uuid
.clock_seq_hi_and_reserved
|= 0x80;
535 * Set MSB of Ethernet address to 1 to indicate that it was generated
538 uuid
.node_addr
[0] |= 0x80;
539 struct_to_string(uu
, &uuid
);
543 * Generates UUID based on DCE Version 1.
546 uuid_generate_time(uuid_t uu
)
553 if (uuid_create(&uuid
) < 0) {
554 uuid_generate_random(uu
);
558 struct_to_string(uu
, &uuid
);
562 * Creates a new UUID. The uuid will be generated based on high-quality
563 * randomness from /dev/urandom, if available by calling uuid_generate_random.
564 * If it failed to generate UUID then uuid_generate will call
565 * uuid_generate_time.
568 uuid_generate(uuid_t uu
)
573 if (fd_urand
== -1) {
574 (void) mutex_lock(&urandmtx
);
575 /* check again now that we have the mutex */
576 if (fd_urand
== -1) {
577 if ((fd_urand
= open(URANDOM_PATH
, O_RDONLY
)) >= 0)
580 (void) mutex_unlock(&urandmtx
);
583 uuid_generate_random(uu
);
585 (void) uuid_generate_time(uu
);
590 * Copies the UUID variable src to dst.
593 uuid_copy(uuid_t dst
, uuid_t src
)
595 (void) memcpy(dst
, src
, UUID_LEN
);
599 * Sets the value of the supplied uuid variable uu, to the NULL value.
602 uuid_clear(uuid_t uu
)
604 (void) memset(uu
, 0, UUID_LEN
);
608 * This function converts the supplied UUID uu from the internal
609 * binary format into a 36-byte string (plus trailing null char)
610 * and stores this value in the character string pointed to by out.
613 uuid_unparse_common(uuid_t uu
, char *out
, boolean_t upper
)
620 /* basic sanity checking */
625 string_to_struct(&uuid
, uu
);
626 clock_seq
= uuid
.clock_seq_hi_and_reserved
;
627 clock_seq
= (clock_seq
<< 8) | uuid
.clock_seq_low
;
628 for (i
= 0; i
< 6; i
++) {
629 (void) sprintf(ðeraddr
[index
++], upper
? "%.2X" : "%.2x",
633 etheraddr
[index
] = '\0';
635 (void) snprintf(out
, 25,
636 upper
? "%08X-%04X-%04X-%04X-" : "%08x-%04x-%04x-%04x-",
637 uuid
.time_low
, uuid
.time_mid
, uuid
.time_hi_and_version
, clock_seq
);
638 (void) strlcat(out
, etheraddr
, UUID_PRINTABLE_STRING_LENGTH
);
642 uuid_unparse_upper(uuid_t uu
, char *out
)
644 uuid_unparse_common(uu
, out
, B_TRUE
);
648 uuid_unparse_lower(uuid_t uu
, char *out
)
650 uuid_unparse_common(uu
, out
, B_FALSE
);
654 uuid_unparse(uuid_t uu
, char *out
)
657 * Historically uuid_unparse on Solaris returns lower case,
658 * for compatibility we preserve this behaviour.
660 uuid_unparse_common(uu
, out
, B_FALSE
);
664 * The uuid_is_null function compares the value of the supplied
665 * UUID variable uu to the NULL value. If the value is equal
666 * to the NULL UUID, 1 is returned, otherwise 0 is returned.
669 uuid_is_null(uuid_t uu
)
674 (void) memset(null_uu
, 0, sizeof (uuid_t
));
675 i
= memcmp(uu
, null_uu
, sizeof (uuid_t
));
677 /* uu is NULL uuid */
685 * uuid_parse converts the UUID string given by 'in' into the
686 * internal uuid_t format. The input UUID is a string of the form
687 * cefa7a9c-1dd2-11b2-8350-880020adbeef in printf(3C) format.
688 * Upon successfully parsing the input string, UUID is stored
689 * in the location pointed to by uu
692 uuid_parse(char *in
, uuid_t uu
)
700 /* do some sanity checking */
701 if ((strlen(in
) != 36) || (uu
== NULL
) || (in
[36] != '\0')) {
706 for (i
= 0; i
< 36; i
++, ptr
++) {
707 if ((i
== 8) || (i
== 13) || (i
== 18) || (i
== 23)) {
712 if (!isxdigit(*ptr
)) {
718 uuid
.time_low
= strtoul(in
, NULL
, 16);
719 uuid
.time_mid
= strtoul(in
+9, NULL
, 16);
720 uuid
.time_hi_and_version
= strtoul(in
+14, NULL
, 16);
721 clock_seq
= strtoul(in
+19, NULL
, 16);
722 uuid
.clock_seq_hi_and_reserved
= (clock_seq
& 0xFF00) >> 8;
723 uuid
.clock_seq_low
= (clock_seq
& 0xFF);
727 for (i
= 0; i
< 6; i
++) {
730 uuid
.node_addr
[i
] = strtoul(buf
, NULL
, 16);
732 struct_to_string(uu
, &uuid
);
737 * uuid_time extracts the time at which the supplied UUID uu
738 * was created. This function can only extract the creation
739 * time for UUIDs created with the uuid_generate_time function.
740 * The time at which the UUID was created, in seconds and
741 * microseconds since the epoch is stored in the location
742 * pointed to by ret_tv.
745 uuid_time(uuid_t uu
, struct timeval
*ret_tv
)
750 u_longlong_t clock_reg
;
754 string_to_struct(&uuid
, uu
);
755 tmp
= (uuid
.time_hi_and_version
& 0xF000) >> 12;
756 clk
= uuid
.clock_seq_hi_and_reserved
;
758 /* check if uu is NULL, Version = 1 of DCE and Variant = 0b10x */
759 if ((uu
== NULL
) || ((tmp
& 0x01) != 0x01) || ((clk
& 0x80) != 0x80)) {
762 high
= uuid
.time_mid
| ((uuid
.time_hi_and_version
& 0xFFF) << 16);
763 clock_reg
= uuid
.time_low
| ((u_longlong_t
)high
<< 32);
765 clock_reg
-= (((u_longlong_t
)0x01B21DD2) << 32) + 0x13814000;
766 tv
.tv_sec
= clock_reg
/ 10000000;
767 tv
.tv_usec
= (clock_reg
% 10000000) / 10;