Home | History | Annotate | Download | only in misc 
      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