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
31extern int getopt(int argc, char * const argv[], const char *optstring);
32extern char *optarg;
33extern 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
45static 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
55static void die(const char *msg)
56{
57	perror(msg);
58	exit(1);
59}
60
61static 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
88static 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
112static 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
131static const char *cleanup_pidfile, *cleanup_socket;
132
133static 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
141static 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
228static 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
441int 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