1 /* 2 * uuidd.c --- UUID-generation daemon 3 * 4 * Copyright (C) 2007 Theodore Ts'o 5 * 6 * %Begin-Header% 7 * This file may be redistributed under the terms of the GNU Public 8 * License. 9 * %End-Header% 10 */ 11 12 #define _GNU_SOURCE /* for setres[ug]id() */ 13 14 #include <stdio.h> 15 #ifdef HAVE_STDLIB_H 16 #include <stdlib.h> 17 #endif 18 #include <unistd.h> 19 #include <inttypes.h> 20 #include <errno.h> 21 #include <sys/types.h> 22 #include <sys/stat.h> 23 #include <sys/socket.h> 24 #include <sys/un.h> 25 #include <fcntl.h> 26 #include <signal.h> 27 #include <string.h> 28 #ifdef HAVE_GETOPT_H 29 #include <getopt.h> 30 #else 31 extern int getopt(int argc, char * const argv[], const char *optstring); 32 extern char *optarg; 33 extern int optind; 34 #endif 35 #include "uuid/uuid.h" 36 #include "uuid/uuidd.h" 37 #include "nls-enable.h" 38 39 #ifdef __GNUC__ 40 #define CODE_ATTR(x) __attribute__(x) 41 #else 42 #define CODE_ATTR(x) 43 #endif 44 45 static void usage(const char *progname) 46 { 47 fprintf(stderr, _("Usage: %s [-d] [-p pidfile] [-s socketpath] " 48 "[-T timeout]\n"), progname); 49 fprintf(stderr, _(" %s [-r|t] [-n num] [-s socketpath]\n"), 50 progname); 51 fprintf(stderr, _(" %s -k\n"), progname); 52 exit(1); 53 } 54 55 static void die(const char *msg) 56 { 57 perror(msg); 58 exit(1); 59 } 60 61 static void create_daemon(void) 62 { 63 pid_t pid; 64 uid_t euid; 65 66 pid = fork(); 67 if (pid == -1) { 68 perror("fork"); 69 exit(1); 70 } else if (pid != 0) { 71 exit(0); 72 } 73 74 close(0); 75 close(1); 76 close(2); 77 open("/dev/null", O_RDWR); 78 open("/dev/null", O_RDWR); 79 open("/dev/null", O_RDWR); 80 81 if (chdir("/")) {} /* Silence warn_unused_result warning */ 82 (void) setsid(); 83 euid = geteuid(); 84 if (setreuid(euid, euid) < 0) 85 die("setreuid"); 86 } 87 88 static ssize_t read_all(int fd, char *buf, size_t count) 89 { 90 ssize_t ret; 91 ssize_t c = 0; 92 int tries = 0; 93 94 memset(buf, 0, count); 95 while (count > 0) { 96 ret = read(fd, buf, count); 97 if (ret <= 0) { 98 if ((errno == EAGAIN || errno == EINTR || ret == 0) && 99 (tries++ < 5)) 100 continue; 101 return c ? c : -1; 102 } 103 if (ret > 0) 104 tries = 0; 105 count -= ret; 106 buf += ret; 107 c += ret; 108 } 109 return c; 110 } 111 112 static int write_all(int fd, char *buf, size_t count) 113 { 114 ssize_t ret; 115 int c = 0; 116 117 while (count > 0) { 118 ret = write(fd, buf, count); 119 if (ret < 0) { 120 if ((errno == EAGAIN) || (errno == EINTR)) 121 continue; 122 return -1; 123 } 124 count -= ret; 125 buf += ret; 126 c += ret; 127 } 128 return c; 129 } 130 131 static const char *cleanup_pidfile, *cleanup_socket; 132 133 static void terminate_intr(int signo CODE_ATTR((unused))) 134 { 135 (void) unlink(cleanup_pidfile); 136 if (cleanup_socket) 137 (void) unlink(cleanup_socket); 138 exit(0); 139 } 140 141 static int call_daemon(const char *socket_path, int op, char *buf, 142 int buflen, int *num, const char **err_context) 143 { 144 char op_buf[8]; 145 int op_len; 146 int s; 147 ssize_t ret; 148 int32_t reply_len = 0; 149 struct sockaddr_un srv_addr; 150 151 if (((op == 4) || (op == 5)) && !num) { 152 if (err_context) 153 *err_context = _("bad arguments"); 154 errno = EINVAL; 155 return -1; 156 } 157 158 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { 159 if (err_context) 160 *err_context = _("socket"); 161 return -1; 162 } 163 164 srv_addr.sun_family = AF_UNIX; 165 strncpy(srv_addr.sun_path, socket_path, sizeof(srv_addr.sun_path)); 166 srv_addr.sun_path[sizeof(srv_addr.sun_path)-1] = '\0'; 167 168 if (connect(s, (const struct sockaddr *) &srv_addr, 169 sizeof(struct sockaddr_un)) < 0) { 170 if (err_context) 171 *err_context = _("connect"); 172 close(s); 173 return -1; 174 } 175 176 if (op == 5) { 177 if ((*num)*16 > buflen-4) 178 *num = (buflen-4) / 16; 179 } 180 op_buf[0] = op; 181 op_len = 1; 182 if ((op == 4) || (op == 5)) { 183 memcpy(op_buf+1, num, sizeof(int)); 184 op_len += sizeof(int); 185 } 186 187 ret = write_all(s, op_buf, op_len); 188 if (ret < op_len) { 189 if (err_context) 190 *err_context = _("write"); 191 close(s); 192 return -1; 193 } 194 195 ret = read_all(s, (char *) &reply_len, sizeof(reply_len)); 196 if (ret < 0) { 197 if (err_context) 198 *err_context = _("read count"); 199 close(s); 200 return -1; 201 } 202 if (reply_len < 0 || reply_len > buflen) { 203 if (err_context) 204 *err_context = _("bad response length"); 205 close(s); 206 return -1; 207 } 208 ret = read_all(s, (char *) buf, reply_len); 209 210 if ((ret > 0) && (op == 4)) { 211 if (reply_len >= (int) (16+sizeof(int))) 212 memcpy(buf+16, num, sizeof(int)); 213 else 214 *num = -1; 215 } 216 if ((ret > 0) && (op == 5)) { 217 if (*num >= (int) sizeof(int)) 218 memcpy(buf, num, sizeof(int)); 219 else 220 *num = -1; 221 } 222 223 close(s); 224 225 return ret; 226 } 227 228 static void server_loop(const char *socket_path, const char *pidfile_path, 229 int debug, int timeout, int quiet) 230 { 231 struct sockaddr_un my_addr, from_addr; 232 struct flock fl; 233 socklen_t fromlen; 234 int32_t reply_len = 0; 235 uuid_t uu; 236 mode_t save_umask; 237 char reply_buf[1024], *cp; 238 char op, str[37]; 239 int i, s, ns, len, num; 240 int fd_pidfile, ret; 241 242 fd_pidfile = open(pidfile_path, O_CREAT | O_RDWR, 0664); 243 if (fd_pidfile < 0) { 244 if (!quiet) 245 fprintf(stderr, "Failed to open/create %s: %s\n", 246 pidfile_path, strerror(errno)); 247 exit(1); 248 } 249 cleanup_pidfile = pidfile_path; 250 cleanup_socket = 0; 251 signal(SIGALRM, terminate_intr); 252 alarm(30); 253 fl.l_type = F_WRLCK; 254 fl.l_whence = SEEK_SET; 255 fl.l_start = 0; 256 fl.l_len = 0; 257 fl.l_pid = 0; 258 while (fcntl(fd_pidfile, F_SETLKW, &fl) < 0) { 259 if ((errno == EAGAIN) || (errno == EINTR)) 260 continue; 261 if (!quiet) 262 fprintf(stderr, "Failed to lock %s: %s\n", 263 pidfile_path, strerror(errno)); 264 exit(1); 265 } 266 ret = call_daemon(socket_path, 0, reply_buf, sizeof(reply_buf), 0, 0); 267 if (ret > 0) { 268 if (!quiet) 269 printf(_("uuidd daemon already running at pid %s\n"), 270 reply_buf); 271 exit(1); 272 } 273 alarm(0); 274 275 if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { 276 if (!quiet) 277 fprintf(stderr, _("Couldn't create unix stream " 278 "socket: %s"), strerror(errno)); 279 exit(1); 280 } 281 282 /* 283 * Make sure the socket isn't using fd numbers 0-2 to avoid it 284 * getting closed by create_daemon() 285 */ 286 while (!debug && s <= 2) { 287 s = dup(s); 288 if (s < 0) { 289 perror("dup"); 290 exit(1); 291 } 292 } 293 294 /* 295 * Create the address we will be binding to. 296 */ 297 my_addr.sun_family = AF_UNIX; 298 strncpy(my_addr.sun_path, socket_path, sizeof(my_addr.sun_path)); 299 my_addr.sun_path[sizeof(my_addr.sun_path)-1] = '\0'; 300 (void) unlink(socket_path); 301 save_umask = umask(0); 302 if (bind(s, (const struct sockaddr *) &my_addr, 303 sizeof(struct sockaddr_un)) < 0) { 304 if (!quiet) 305 fprintf(stderr, 306 _("Couldn't bind unix socket %s: %s\n"), 307 socket_path, strerror(errno)); 308 exit(1); 309 } 310 (void) umask(save_umask); 311 312 if (listen(s, 5) < 0) { 313 if (!quiet) 314 fprintf(stderr, _("Couldn't listen on unix " 315 "socket %s: %s\n"), socket_path, 316 strerror(errno)); 317 exit(1); 318 } 319 320 cleanup_socket = socket_path; 321 if (!debug) 322 create_daemon(); 323 signal(SIGHUP, terminate_intr); 324 signal(SIGINT, terminate_intr); 325 signal(SIGTERM, terminate_intr); 326 signal(SIGALRM, terminate_intr); 327 signal(SIGPIPE, SIG_IGN); 328 329 sprintf(reply_buf, "%8d\n", getpid()); 330 if (ftruncate(fd_pidfile, 0)) {} /* Silence warn_unused_result */ 331 write_all(fd_pidfile, reply_buf, strlen(reply_buf)); 332 if (fd_pidfile > 1) 333 close(fd_pidfile); /* Unlock the pid file */ 334 335 while (1) { 336 fromlen = sizeof(from_addr); 337 if (timeout > 0) 338 alarm(timeout); 339 ns = accept(s, (struct sockaddr *) &from_addr, &fromlen); 340 alarm(0); 341 if (ns < 0) { 342 if ((errno == EAGAIN) || (errno == EINTR)) 343 continue; 344 perror("accept"); 345 exit(1); 346 } 347 len = read(ns, &op, 1); 348 if (len != 1) { 349 if (len < 0) 350 perror("read"); 351 else 352 printf(_("Error reading from client, " 353 "len = %d\n"), len); 354 goto shutdown_socket; 355 } 356 if ((op == 4) || (op == 5)) { 357 if (read_all(ns, (char *) &num, sizeof(num)) != 4) 358 goto shutdown_socket; 359 if (debug) 360 printf(_("operation %d, incoming num = %d\n"), 361 op, num); 362 } else if (debug) 363 printf("operation %d\n", op); 364 365 switch(op) { 366 case UUIDD_OP_GETPID: 367 sprintf(reply_buf, "%d", getpid()); 368 reply_len = strlen(reply_buf)+1; 369 break; 370 case UUIDD_OP_GET_MAXOP: 371 sprintf(reply_buf, "%d", UUIDD_MAX_OP); 372 reply_len = strlen(reply_buf)+1; 373 break; 374 case UUIDD_OP_TIME_UUID: 375 num = 1; 376 uuid__generate_time(uu, &num); 377 if (debug) { 378 uuid_unparse(uu, str); 379 printf(_("Generated time UUID: %s\n"), str); 380 } 381 memcpy(reply_buf, uu, sizeof(uu)); 382 reply_len = sizeof(uu); 383 break; 384 case UUIDD_OP_RANDOM_UUID: 385 num = 1; 386 uuid__generate_random(uu, &num); 387 if (debug) { 388 uuid_unparse(uu, str); 389 printf(_("Generated random UUID: %s\n"), str); 390 } 391 memcpy(reply_buf, uu, sizeof(uu)); 392 reply_len = sizeof(uu); 393 break; 394 case UUIDD_OP_BULK_TIME_UUID: 395 uuid__generate_time(uu, &num); 396 if (debug) { 397 uuid_unparse(uu, str); 398 printf(P_("Generated time UUID %s and " 399 "subsequent UUID\n", 400 "Generated time UUID %s and %d " 401 "subsequent UUIDs\n", num), 402 str, num); 403 } 404 memcpy(reply_buf, uu, sizeof(uu)); 405 reply_len = sizeof(uu); 406 memcpy(reply_buf+reply_len, &num, sizeof(num)); 407 reply_len += sizeof(num); 408 break; 409 case UUIDD_OP_BULK_RANDOM_UUID: 410 if (num < 0) 411 num = 1; 412 if (num > 1000) 413 num = 1000; 414 if (num*16 > (int) (sizeof(reply_buf)-sizeof(num))) 415 num = (sizeof(reply_buf)-sizeof(num)) / 16; 416 uuid__generate_random((unsigned char *) reply_buf + 417 sizeof(num), &num); 418 if (debug) { 419 printf(_("Generated %d UUID's:\n"), num); 420 for (i=0, cp=reply_buf+sizeof(num); 421 i < num; i++, cp+=16) { 422 uuid_unparse((unsigned char *)cp, str); 423 printf("\t%s\n", str); 424 } 425 } 426 reply_len = (num*16) + sizeof(num); 427 memcpy(reply_buf, &num, sizeof(num)); 428 break; 429 default: 430 if (debug) 431 printf(_("Invalid operation %d\n"), op); 432 goto shutdown_socket; 433 } 434 write_all(ns, (char *) &reply_len, sizeof(reply_len)); 435 write_all(ns, reply_buf, reply_len); 436 shutdown_socket: 437 close(ns); 438 } 439 } 440 441 int main(int argc, char **argv) 442 { 443 const char *socket_path = UUIDD_SOCKET_PATH; 444 const char *pidfile_path = UUIDD_PIDFILE_PATH; 445 const char *err_context; 446 char buf[1024], *cp; 447 char str[37], *tmp; 448 uuid_t uu; 449 uid_t uid; 450 gid_t gid; 451 int i, c, ret; 452 int debug = 0, do_type = 0, do_kill = 0, num = 0; 453 int timeout = 0, quiet = 0, drop_privs = 0; 454 455 #ifdef ENABLE_NLS 456 setlocale(LC_MESSAGES, ""); 457 setlocale(LC_CTYPE, ""); 458 bindtextdomain(NLS_CAT_NAME, LOCALEDIR); 459 textdomain(NLS_CAT_NAME); 460 #endif 461 462 while ((c = getopt (argc, argv, "dkn:qp:s:tT:r")) != EOF) { 463 switch (c) { 464 case 'd': 465 debug++; 466 drop_privs = 1; 467 break; 468 case 'k': 469 do_kill++; 470 drop_privs = 1; 471 break; 472 case 'n': 473 num = strtol(optarg, &tmp, 0); 474 if ((num < 0) || *tmp) { 475 fprintf(stderr, _("Bad number: %s\n"), optarg); 476 exit(1); 477 } 478 break; 479 case 'p': 480 pidfile_path = optarg; 481 drop_privs = 1; 482 break; 483 case 'q': 484 quiet++; 485 break; 486 case 's': 487 socket_path = optarg; 488 drop_privs = 1; 489 break; 490 case 't': 491 do_type = UUIDD_OP_TIME_UUID; 492 drop_privs = 1; 493 break; 494 case 'T': 495 timeout = strtol(optarg, &tmp, 0); 496 if ((timeout < 0) || *tmp) { 497 fprintf(stderr, _("Bad number: %s\n"), optarg); 498 exit(1); 499 } 500 break; 501 case 'r': 502 do_type = UUIDD_OP_RANDOM_UUID; 503 drop_privs = 1; 504 break; 505 default: 506 usage(argv[0]); 507 } 508 } 509 uid = getuid(); 510 if (uid && drop_privs) { 511 gid = getgid(); 512 #ifdef HAVE_SETRESGID 513 if (setresgid(gid, gid, gid) < 0) 514 die("setresgid"); 515 #else 516 if (setregid(gid, gid) < 0) 517 die("setregid"); 518 #endif 519 520 #ifdef HAVE_SETRESUID 521 if (setresuid(uid, uid, uid) < 0) 522 die("setresuid"); 523 #else 524 if (setreuid(uid, uid) < 0) 525 die("setreuid"); 526 #endif 527 } 528 if (num && do_type) { 529 ret = call_daemon(socket_path, do_type+2, buf, 530 sizeof(buf), &num, &err_context); 531 if (ret < 0) { 532 printf(_("Error calling uuidd daemon (%s): %s\n"), 533 err_context, strerror(errno)); 534 exit(1); 535 } 536 if (do_type == UUIDD_OP_TIME_UUID) { 537 if (ret != sizeof(uu) + sizeof(num)) 538 goto unexpected_size; 539 540 uuid_unparse((unsigned char *) buf, str); 541 542 printf(P_("%s and subsequent UUID\n", 543 "%s and subsequent %d UUIDs\n", num), 544 str, num); 545 } else { 546 printf("%s", _("List of UUID's:\n")); 547 cp = buf + 4; 548 if (ret != (int) (sizeof(num) + num*sizeof(uu))) 549 goto unexpected_size; 550 for (i=0; i < num; i++, cp+=16) { 551 uuid_unparse((unsigned char *) cp, str); 552 printf("\t%s\n", str); 553 } 554 } 555 exit(0); 556 } 557 if (do_type) { 558 ret = call_daemon(socket_path, do_type, (char *) &uu, 559 sizeof(uu), 0, &err_context); 560 if (ret < 0) { 561 printf(_("Error calling uuidd daemon (%s): %s\n"), 562 err_context, strerror(errno)); 563 exit(1); 564 } 565 if (ret != sizeof(uu)) { 566 unexpected_size: 567 printf(_("Unexpected reply length from server %d\n"), 568 ret); 569 exit(1); 570 } 571 uuid_unparse(uu, str); 572 573 printf("%s\n", str); 574 exit(0); 575 } 576 577 if (do_kill) { 578 ret = call_daemon(socket_path, 0, buf, sizeof(buf), 0, 0); 579 if ((ret > 0) && ((do_kill = atoi((char *) buf)) > 0)) { 580 ret = kill(do_kill, SIGTERM); 581 if (ret < 0) { 582 if (!quiet) 583 fprintf(stderr, 584 _("Couldn't kill uuidd running " 585 "at pid %d: %s\n"), do_kill, 586 strerror(errno)); 587 exit(1); 588 } 589 if (!quiet) 590 printf(_("Killed uuidd running at pid %d\n"), 591 do_kill); 592 } 593 exit(0); 594 } 595 596 server_loop(socket_path, pidfile_path, debug, timeout, quiet); 597 return 0; 598 } 599
