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