gen_uuid.c revision e70f32b79d29e287f8347c5d41c6716f094cc654
1/* 2 * gen_uuid.c --- generate a DCE-compatible uuid 3 * 4 * Copyright (C) 1996, 1997, 1998, 1999 Theodore Ts'o. 5 * 6 * %Begin-Header% 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, and the entire permission notice in its entirety, 12 * including the disclaimer of warranties. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the author may not be used to endorse or promote 17 * products derived from this software without specific prior 18 * written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 21 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF 23 * WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 26 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 27 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 28 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 30 * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH 31 * DAMAGE. 32 * %End-Header% 33 */ 34 35/* 36 * Force inclusion of SVID stuff since we need it if we're compiling in 37 * gcc-wall wall mode 38 */ 39#define _SVID_SOURCE 40 41#include <stdio.h> 42#ifdef HAVE_UNISTD_H 43#include <unistd.h> 44#endif 45#ifdef HAVE_STDLIB_H 46#include <stdlib.h> 47#endif 48#include <string.h> 49#include <fcntl.h> 50#include <errno.h> 51#include <sys/types.h> 52#include <sys/time.h> 53#include <sys/wait.h> 54#include <sys/stat.h> 55#include <sys/file.h> 56#ifdef HAVE_SYS_IOCTL_H 57#include <sys/ioctl.h> 58#endif 59#ifdef HAVE_SYS_SOCKET_H 60#include <sys/socket.h> 61#endif 62#include <sys/un.h> 63#ifdef HAVE_SYS_SOCKIO_H 64#include <sys/sockio.h> 65#endif 66#ifdef HAVE_NET_IF_H 67#include <net/if.h> 68#endif 69#ifdef HAVE_NETINET_IN_H 70#include <netinet/in.h> 71#endif 72#ifdef HAVE_NET_IF_DL_H 73#include <net/if_dl.h> 74#endif 75#if defined(__linux__) && defined(HAVE_SYS_SYSCALL_H) 76#include <sys/syscall.h> 77#endif 78 79#include "uuidP.h" 80#include "uuidd.h" 81 82#ifdef HAVE_SRANDOM 83#define srand(x) srandom(x) 84#define rand() random() 85#endif 86 87#ifdef TLS 88#define THREAD_LOCAL static TLS 89#else 90#define THREAD_LOCAL static 91#endif 92 93#if defined(__linux__) && defined(__NR_gettid) && defined(HAVE_JRAND48) 94#define DO_JRAND_MIX 95THREAD_LOCAL unsigned short jrand_seed[3]; 96#endif 97 98static int get_random_fd(void) 99{ 100 struct timeval tv; 101 static int fd = -2; 102 int i; 103 104 if (fd == -2) { 105 gettimeofday(&tv, 0); 106 fd = open("/dev/urandom", O_RDONLY); 107 if (fd == -1) 108 fd = open("/dev/random", O_RDONLY | O_NONBLOCK); 109 if (fd >= 0) { 110 i = fcntl(fd, F_GETFD); 111 if (i >= 0) 112 fcntl(fd, F_SETFD, i | FD_CLOEXEC); 113 } 114 srand((getpid() << 16) ^ getuid() ^ tv.tv_sec ^ tv.tv_usec); 115#ifdef DO_JRAND_MIX 116 jrand_seed[0] = getpid() ^ (tv.tv_sec & 0xFFFF); 117 jrand_seed[1] = getppid() ^ (tv.tv_usec & 0xFFFF); 118 jrand_seed[2] = (tv.tv_sec ^ tv.tv_usec) >> 16; 119#endif 120 } 121 /* Crank the random number generator a few times */ 122 gettimeofday(&tv, 0); 123 for (i = (tv.tv_sec ^ tv.tv_usec) & 0x1F; i > 0; i--) 124 rand(); 125 return fd; 126} 127 128 129/* 130 * Generate a series of random bytes. Use /dev/urandom if possible, 131 * and if not, use srandom/random. 132 */ 133static void get_random_bytes(void *buf, int nbytes) 134{ 135 int i, n = nbytes, fd = get_random_fd(); 136 int lose_counter = 0; 137 unsigned char *cp = (unsigned char *) buf; 138 unsigned short tmp_seed[3]; 139 140 if (fd >= 0) { 141 while (n > 0) { 142 i = read(fd, cp, n); 143 if (i <= 0) { 144 if (lose_counter++ > 16) 145 break; 146 continue; 147 } 148 n -= i; 149 cp += i; 150 lose_counter = 0; 151 } 152 } 153 154 /* 155 * We do this all the time, but this is the only source of 156 * randomness if /dev/random/urandom is out to lunch. 157 */ 158 for (cp = buf, i = 0; i < nbytes; i++) 159 *cp++ ^= (rand() >> 7) & 0xFF; 160#ifdef DO_JRAND_MIX 161 memcpy(tmp_seed, jrand_seed, sizeof(tmp_seed)); 162 jrand_seed[2] = jrand_seed[2] ^ syscall(__NR_gettid); 163 for (cp = buf, i = 0; i < nbytes; i++) 164 *cp++ ^= (jrand48(tmp_seed) >> 7) & 0xFF; 165 memcpy(jrand_seed, tmp_seed, 166 sizeof(jrand_seed)-sizeof(unsigned short)); 167#endif 168 169 return; 170} 171 172/* 173 * Get the ethernet hardware address, if we can find it... 174 */ 175static int get_node_id(unsigned char *node_id) 176{ 177#ifdef HAVE_NET_IF_H 178 int sd; 179 struct ifreq ifr, *ifrp; 180 struct ifconf ifc; 181 char buf[1024]; 182 int n, i; 183 unsigned char *a; 184#ifdef HAVE_NET_IF_DL_H 185 struct sockaddr_dl *sdlp; 186#endif 187 188/* 189 * BSD 4.4 defines the size of an ifreq to be 190 * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len 191 * However, under earlier systems, sa_len isn't present, so the size is 192 * just sizeof(struct ifreq) 193 */ 194#ifdef HAVE_SA_LEN 195#ifndef max 196#define max(a,b) ((a) > (b) ? (a) : (b)) 197#endif 198#define ifreq_size(i) max(sizeof(struct ifreq),\ 199 sizeof((i).ifr_name)+(i).ifr_addr.sa_len) 200#else 201#define ifreq_size(i) sizeof(struct ifreq) 202#endif /* HAVE_SA_LEN*/ 203 204 sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); 205 if (sd < 0) { 206 return -1; 207 } 208 memset(buf, 0, sizeof(buf)); 209 ifc.ifc_len = sizeof(buf); 210 ifc.ifc_buf = buf; 211 if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) { 212 close(sd); 213 return -1; 214 } 215 n = ifc.ifc_len; 216 for (i = 0; i < n; i+= ifreq_size(*ifrp) ) { 217 ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i); 218 strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ); 219#ifdef SIOCGIFHWADDR 220 if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0) 221 continue; 222 a = (unsigned char *) &ifr.ifr_hwaddr.sa_data; 223#else 224#ifdef SIOCGENADDR 225 if (ioctl(sd, SIOCGENADDR, &ifr) < 0) 226 continue; 227 a = (unsigned char *) ifr.ifr_enaddr; 228#else 229#ifdef HAVE_NET_IF_DL_H 230 sdlp = (struct sockaddr_dl *) &ifrp->ifr_addr; 231 if ((sdlp->sdl_family != AF_LINK) || (sdlp->sdl_alen != 6)) 232 continue; 233 a = (unsigned char *) &sdlp->sdl_data[sdlp->sdl_nlen]; 234#else 235 /* 236 * XXX we don't have a way of getting the hardware 237 * address 238 */ 239 close(sd); 240 return 0; 241#endif /* HAVE_NET_IF_DL_H */ 242#endif /* SIOCGENADDR */ 243#endif /* SIOCGIFHWADDR */ 244 if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5]) 245 continue; 246 if (node_id) { 247 memcpy(node_id, a, 6); 248 close(sd); 249 return 1; 250 } 251 } 252 close(sd); 253#endif 254 return 0; 255} 256 257/* Assume that the gettimeofday() has microsecond granularity */ 258#define MAX_ADJUSTMENT 10 259 260static int get_clock(uint32_t *clock_high, uint32_t *clock_low, 261 uint16_t *ret_clock_seq, int *num) 262{ 263 THREAD_LOCAL int adjustment = 0; 264 THREAD_LOCAL struct timeval last = {0, 0}; 265 THREAD_LOCAL int state_fd = -2; 266 THREAD_LOCAL FILE *state_f; 267 THREAD_LOCAL uint16_t clock_seq; 268 struct timeval tv; 269 struct flock fl; 270 unsigned long long clock_reg; 271 mode_t save_umask; 272 273 if (state_fd == -2) { 274 save_umask = umask(0); 275 state_fd = open("/var/lib/libuuid/clock.txt", 276 O_RDWR|O_CREAT, 0660); 277 (void) umask(save_umask); 278 state_f = fdopen(state_fd, "r+"); 279 if (!state_f) { 280 close(state_fd); 281 state_fd = -1; 282 } 283 } 284 fl.l_type = F_WRLCK; 285 fl.l_whence = SEEK_SET; 286 fl.l_start = 0; 287 fl.l_len = 0; 288 fl.l_pid = 0; 289 if (state_fd >= 0) { 290 rewind(state_f); 291 while (fcntl(state_fd, F_SETLKW, &fl) < 0) { 292 if ((errno == EAGAIN) || (errno == EINTR)) 293 continue; 294 fclose(state_f); 295 close(state_fd); 296 state_fd = -1; 297 break; 298 } 299 } 300 if (state_fd >= 0) { 301 unsigned int cl; 302 unsigned long tv1, tv2; 303 int a; 304 305 if (fscanf(state_f, "clock: %04x tv: %lu %lu adj: %d\n", 306 &cl, &tv1, &tv2, &a) == 4) { 307 clock_seq = cl & 0x3FFF; 308 last.tv_sec = tv1; 309 last.tv_usec = tv2; 310 adjustment = a; 311 } 312 } 313 314 if ((last.tv_sec == 0) && (last.tv_usec == 0)) { 315 get_random_bytes(&clock_seq, sizeof(clock_seq)); 316 clock_seq &= 0x3FFF; 317 last = tv; 318 last.tv_sec--; 319 } 320 321try_again: 322 gettimeofday(&tv, 0); 323 if ((tv.tv_sec < last.tv_sec) || 324 ((tv.tv_sec == last.tv_sec) && 325 (tv.tv_usec < last.tv_usec))) { 326 clock_seq = (clock_seq+1) & 0x3FFF; 327 adjustment = 0; 328 last = tv; 329 } else if ((tv.tv_sec == last.tv_sec) && 330 (tv.tv_usec == last.tv_usec)) { 331 if (adjustment >= MAX_ADJUSTMENT) 332 goto try_again; 333 adjustment++; 334 } else { 335 adjustment = 0; 336 last = tv; 337 } 338 339 clock_reg = tv.tv_usec*10 + adjustment; 340 clock_reg += ((unsigned long long) tv.tv_sec)*10000000; 341 clock_reg += (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000; 342 343 if (num && (*num > 1)) { 344 adjustment += *num - 1; 345 last.tv_usec += adjustment / 10; 346 adjustment = adjustment % 10; 347 last.tv_sec += last.tv_usec / 1000000; 348 last.tv_usec = last.tv_usec % 1000000; 349 } 350 351 if (state_fd > 0) { 352 rewind(state_f); 353 ftruncate(state_fd, 0); 354 fprintf(state_f, "clock: %04x tv: %lu %lu adj: %d\n", 355 clock_seq, last.tv_sec, last.tv_usec, adjustment); 356 fflush(state_f); 357 rewind(state_f); 358 fl.l_type = F_UNLCK; 359 fcntl(state_fd, F_SETLK, &fl); 360 } 361 362 *clock_high = clock_reg >> 32; 363 *clock_low = clock_reg; 364 *ret_clock_seq = clock_seq; 365 return 0; 366} 367 368static ssize_t read_all(int fd, char *buf, size_t count) 369{ 370 ssize_t ret; 371 ssize_t c = 0; 372 373 memset(buf, 0, count); 374 while (count > 0) { 375 ret = read(fd, buf, count); 376 if (ret < 0) { 377 if ((errno == EAGAIN) || (errno == EINTR)) 378 continue; 379 return -1; 380 } 381 count -= ret; 382 buf += ret; 383 c += ret; 384 } 385 return c; 386} 387 388 389/* 390 * Try using the uuidd daemon to generate the UUID 391 * 392 * Returns 0 on success, non-zero on failure. 393 */ 394static int get_uuid_via_daemon(int op, uuid_t out, int *num) 395{ 396#ifdef USE_UUIDD 397 char op_buf[64]; 398 int op_len; 399 int s; 400 ssize_t ret; 401 int32_t reply_len = 0, expected = 16; 402 struct sockaddr_un srv_addr; 403 pid_t pid; 404 static const char *uuidd_path = UUIDD_PATH; 405 static int access_ret = -2; 406 static int start_attempts = 0; 407 408 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) 409 return -1; 410 411 srv_addr.sun_family = AF_UNIX; 412 strcpy(srv_addr.sun_path, UUIDD_SOCKET_PATH); 413 414 if (connect(s, (const struct sockaddr *) &srv_addr, 415 sizeof(struct sockaddr_un)) < 0) { 416 if (access_ret == -2) 417 access_ret = access(uuidd_path, X_OK); 418 if (access_ret == 0 && start_attempts++ < 5) { 419 if ((pid = fork()) == 0) { 420 execl(uuidd_path, "uuidd", "-qT", "300", 421 (char *) NULL); 422 exit(1); 423 } 424 (void) waitpid(pid, 0, 0); 425 if (connect(s, (const struct sockaddr *) &srv_addr, 426 sizeof(struct sockaddr_un)) < 0) 427 goto fail; 428 } else 429 goto fail; 430 } 431 op_buf[0] = op; 432 op_len = 1; 433 if (op == UUIDD_OP_BULK_TIME_UUID) { 434 memcpy(op_buf+1, num, sizeof(*num)); 435 op_len += sizeof(*num); 436 expected += sizeof(*num); 437 } 438 439 ret = write(s, op_buf, op_len); 440 if (ret < 1) 441 goto fail; 442 443 ret = read_all(s, (char *) &reply_len, sizeof(reply_len)); 444 if (ret < 0) 445 goto fail; 446 447 if (reply_len != expected) 448 goto fail; 449 450 ret = read_all(s, op_buf, reply_len); 451 452 if (op == UUIDD_OP_BULK_TIME_UUID) 453 memcpy(op_buf+16, num, sizeof(int)); 454 455 memcpy(out, op_buf, 16); 456 457 close(s); 458 return ((ret == expected) ? 0 : -1); 459 460fail: 461 close(s); 462#endif 463 return -1; 464} 465 466void uuid__generate_time(uuid_t out, int *num) 467{ 468 static unsigned char node_id[6]; 469 static int has_init = 0; 470 struct uuid uu; 471 uint32_t clock_mid; 472 473 if (!has_init) { 474 if (get_node_id(node_id) <= 0) { 475 get_random_bytes(node_id, 6); 476 /* 477 * Set multicast bit, to prevent conflicts 478 * with IEEE 802 addresses obtained from 479 * network cards 480 */ 481 node_id[0] |= 0x01; 482 } 483 has_init = 1; 484 } 485 get_clock(&clock_mid, &uu.time_low, &uu.clock_seq, num); 486 uu.clock_seq |= 0x8000; 487 uu.time_mid = (uint16_t) clock_mid; 488 uu.time_hi_and_version = ((clock_mid >> 16) & 0x0FFF) | 0x1000; 489 memcpy(uu.node, node_id, 6); 490 uuid_pack(&uu, out); 491} 492 493void uuid_generate_time(uuid_t out) 494{ 495#ifdef TLS 496 THREAD_LOCAL int num = 0; 497 THREAD_LOCAL struct uuid uu; 498 THREAD_LOCAL time_t last_time = 0; 499 time_t now; 500 501 if (num > 0) { 502 now = time(0); 503 if (now > last_time+1) 504 num = 0; 505 } 506 if (num <= 0) { 507 num = 1000; 508 if (get_uuid_via_daemon(UUIDD_OP_BULK_TIME_UUID, 509 out, &num) == 0) { 510 last_time = time(0); 511 uuid_unpack(out, &uu); 512 num--; 513 return; 514 } 515 num = 0; 516 } 517 if (num > 0) { 518 uu.time_low++; 519 if (uu.time_low == 0) { 520 uu.time_mid++; 521 if (uu.time_mid == 0) 522 uu.time_hi_and_version++; 523 } 524 num--; 525 uuid_pack(&uu, out); 526 return; 527 } 528#else 529 if (get_uuid_via_daemon(UUIDD_OP_TIME_UUID, out, 0) == 0) 530 return; 531#endif 532 533 uuid__generate_time(out, 0); 534} 535 536 537void uuid__generate_random(uuid_t out, int *num) 538{ 539 uuid_t buf; 540 struct uuid uu; 541 int i, n; 542 543 if (!num || !*num) 544 n = 1; 545 else 546 n = *num; 547 548 for (i = 0; i < n; i++) { 549 get_random_bytes(buf, sizeof(buf)); 550 uuid_unpack(buf, &uu); 551 552 uu.clock_seq = (uu.clock_seq & 0x3FFF) | 0x8000; 553 uu.time_hi_and_version = (uu.time_hi_and_version & 0x0FFF) 554 | 0x4000; 555 uuid_pack(&uu, out); 556 out += sizeof(uuid_t); 557 } 558} 559 560void uuid_generate_random(uuid_t out) 561{ 562 int num = 1; 563 /* No real reason to use the daemon for random uuid's -- yet */ 564 565 uuid__generate_random(out, &num); 566} 567 568 569/* 570 * This is the generic front-end to uuid_generate_random and 571 * uuid_generate_time. It uses uuid_generate_random only if 572 * /dev/urandom is available, since otherwise we won't have 573 * high-quality randomness. 574 */ 575void uuid_generate(uuid_t out) 576{ 577 if (get_random_fd() >= 0) 578 uuid_generate_random(out); 579 else 580 uuid_generate_time(out); 581} 582