void uuid_generate_random(uuid_t out) { int num = 1; /* No real reason to use the daemon for random uuid's -- yet */ __uuid_generate_random(out, &num); }
static void server_loop(const char *socket_path, const char *pidfile_path, const struct uuidd_cxt_t *uuidd_cxt) { struct sockaddr_un from_addr; socklen_t fromlen; int32_t reply_len = 0; uuid_t uu; char reply_buf[1024], *cp; char op, str[UUID_STR_LEN]; int i, ns, len, num; int s = 0; int fd_pidfile = -1; int ret; #ifdef USE_SOCKET_ACTIVATION if (!uuidd_cxt->no_sock) /* no_sock implies no_fork and no_pid */ #endif { signal(SIGALRM, terminate_intr); alarm(30); if (pidfile_path) fd_pidfile = create_pidfile(pidfile_path, uuidd_cxt->quiet); ret = call_daemon(socket_path, UUIDD_OP_GETPID, reply_buf, sizeof(reply_buf), 0, NULL); if (ret > 0) { if (!uuidd_cxt->quiet) warnx(_("uuidd daemon is already running at pid %s"), reply_buf); exit(EXIT_FAILURE); } alarm(0); s = create_socket(socket_path, (!uuidd_cxt->debug || !uuidd_cxt->no_fork), uuidd_cxt->quiet); if (listen(s, SOMAXCONN) < 0) { if (!uuidd_cxt->quiet) warn(_("couldn't listen on unix socket %s"), socket_path); exit(EXIT_FAILURE); } if (!uuidd_cxt->debug && !uuidd_cxt->no_fork) create_daemon(); if (pidfile_path) { sprintf(reply_buf, "%8d\n", getpid()); ignore_result( ftruncate(fd_pidfile, 0) ); write_all(fd_pidfile, reply_buf, strlen(reply_buf)); if (fd_pidfile > 1) close(fd_pidfile); /* Unlock the pid file */ } } signal(SIGHUP, terminate_intr); signal(SIGINT, terminate_intr); signal(SIGTERM, terminate_intr); signal(SIGALRM, terminate_intr); signal(SIGPIPE, SIG_IGN); #ifdef USE_SOCKET_ACTIVATION if (uuidd_cxt->no_sock) { if (sd_listen_fds(0) != 1) errx(EXIT_FAILURE, _("no or too many file descriptors received")); s = SD_LISTEN_FDS_START + 0; } #endif while (1) { fromlen = sizeof(from_addr); if (uuidd_cxt->timeout > 0) alarm(uuidd_cxt->timeout); ns = accept(s, (struct sockaddr *) &from_addr, &fromlen); alarm(0); if (ns < 0) { if ((errno == EAGAIN) || (errno == EINTR)) continue; else err(EXIT_FAILURE, "accept"); } len = read(ns, &op, 1); if (len != 1) { if (len < 0) warn(_("read failed")); else warnx(_("error reading from client, len = %d"), len); goto shutdown_socket; } if ((op == UUIDD_OP_BULK_TIME_UUID) || (op == UUIDD_OP_BULK_RANDOM_UUID)) { if (read_all(ns, (char *) &num, sizeof(num)) != 4) goto shutdown_socket; if (uuidd_cxt->debug) fprintf(stderr, _("operation %d, incoming num = %d\n"), op, num); } else if (uuidd_cxt->debug) fprintf(stderr, _("operation %d\n"), op); switch (op) { case UUIDD_OP_GETPID: sprintf(reply_buf, "%d", getpid()); reply_len = strlen(reply_buf) + 1; break; case UUIDD_OP_GET_MAXOP: sprintf(reply_buf, "%d", UUIDD_MAX_OP); reply_len = strlen(reply_buf) + 1; break; case UUIDD_OP_TIME_UUID: num = 1; __uuid_generate_time(uu, &num); if (uuidd_cxt->debug) { uuid_unparse(uu, str); fprintf(stderr, _("Generated time UUID: %s\n"), str); } memcpy(reply_buf, uu, sizeof(uu)); reply_len = sizeof(uu); break; case UUIDD_OP_RANDOM_UUID: num = 1; __uuid_generate_random(uu, &num); if (uuidd_cxt->debug) { uuid_unparse(uu, str); fprintf(stderr, _("Generated random UUID: %s\n"), str); } memcpy(reply_buf, uu, sizeof(uu)); reply_len = sizeof(uu); break; case UUIDD_OP_BULK_TIME_UUID: __uuid_generate_time(uu, &num); if (uuidd_cxt->debug) { uuid_unparse(uu, str); fprintf(stderr, P_("Generated time UUID %s " "and %d following\n", "Generated time UUID %s " "and %d following\n", num - 1), str, num - 1); } memcpy(reply_buf, uu, sizeof(uu)); reply_len = sizeof(uu); memcpy(reply_buf + reply_len, &num, sizeof(num)); reply_len += sizeof(num); break; case UUIDD_OP_BULK_RANDOM_UUID: if (num < 0) num = 1; if (num > 1000) num = 1000; if (num * UUID_LEN > (int) (sizeof(reply_buf) - sizeof(num))) num = (sizeof(reply_buf) - sizeof(num)) / UUID_LEN; __uuid_generate_random((unsigned char *) reply_buf + sizeof(num), &num); if (uuidd_cxt->debug) { fprintf(stderr, P_("Generated %d UUID:\n", "Generated %d UUIDs:\n", num), num); for (i = 0, cp = reply_buf + sizeof(num); i < num; i++, cp += UUID_LEN) { uuid_unparse((unsigned char *)cp, str); fprintf(stderr, "\t%s\n", str); } } reply_len = (num * UUID_LEN) + sizeof(num); memcpy(reply_buf, &num, sizeof(num)); break; default: if (uuidd_cxt->debug) fprintf(stderr, _("Invalid operation %d\n"), op); goto shutdown_socket; } write_all(ns, (char *) &reply_len, sizeof(reply_len)); write_all(ns, reply_buf, reply_len); shutdown_socket: close(ns); } }
static void server_loop(const char *socket_path, const char *pidfile_path, int debug, int timeout, int quiet) { struct sockaddr_un my_addr, from_addr; struct flock fl; socklen_t fromlen; int32_t reply_len = 0; uuid_t uu; mode_t save_umask; char reply_buf[1024], *cp; char op, str[UUID_STR_LEN]; int i, s, ns, len, num; int fd_pidfile, ret; fd_pidfile = open(pidfile_path, O_CREAT | O_RDWR, 0664); if (fd_pidfile < 0) { if (!quiet) fprintf(stderr, _("Failed to open/create %s: %m\n"), pidfile_path); exit(EXIT_FAILURE); } cleanup_pidfile = pidfile_path; cleanup_socket = 0; signal(SIGALRM, terminate_intr); alarm(30); fl.l_type = F_WRLCK; fl.l_whence = SEEK_SET; fl.l_start = 0; fl.l_len = 0; fl.l_pid = 0; while (fcntl(fd_pidfile, F_SETLKW, &fl) < 0) { if ((errno == EAGAIN) || (errno == EINTR)) continue; if (!quiet) fprintf(stderr, _("Failed to lock %s: %m\n"), pidfile_path); exit(EXIT_FAILURE); } ret = call_daemon(socket_path, 0, reply_buf, sizeof(reply_buf), 0, 0); if (ret > 0) { if (!quiet) printf(_("uuidd daemon already running at pid %s\n"), reply_buf); exit(EXIT_FAILURE); } alarm(0); if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { if (!quiet) fprintf(stderr, _("Couldn't create unix stream socket: %m")); exit(EXIT_FAILURE); } /* * Make sure the socket isn't using fd numbers 0-2 to avoid it * getting closed by create_daemon() */ while (!debug && s <= 2) { s = dup(s); if (s < 0) err(EXIT_FAILURE, "dup"); } /* * Create the address we will be binding to. */ my_addr.sun_family = AF_UNIX; strncpy(my_addr.sun_path, socket_path, sizeof(my_addr.sun_path)); my_addr.sun_path[sizeof(my_addr.sun_path) - 1] = '\0'; unlink(socket_path); save_umask = umask(0); if (bind(s, (const struct sockaddr *) &my_addr, sizeof(struct sockaddr_un)) < 0) { if (!quiet) fprintf(stderr, _("Couldn't bind unix socket %s: %m\n"), socket_path); exit(EXIT_FAILURE); } umask(save_umask); if (listen(s, SOMAXCONN) < 0) { if (!quiet) fprintf(stderr, _("Couldn't listen on unix " "socket %s: %m\n"), socket_path); exit(EXIT_FAILURE); } cleanup_socket = socket_path; if (!debug) create_daemon(); signal(SIGHUP, terminate_intr); signal(SIGINT, terminate_intr); signal(SIGTERM, terminate_intr); signal(SIGALRM, terminate_intr); signal(SIGPIPE, SIG_IGN); sprintf(reply_buf, "%8d\n", getpid()); if (ftruncate(fd_pidfile, 0)) { /* Silence warn_unused_result */ } write_all(fd_pidfile, reply_buf, strlen(reply_buf)); if (fd_pidfile > 1) close(fd_pidfile); /* Unlock the pid file */ while (1) { fromlen = sizeof(from_addr); if (timeout > 0) alarm(timeout); ns = accept(s, (struct sockaddr *) &from_addr, &fromlen); alarm(0); if (ns < 0) { if ((errno == EAGAIN) || (errno == EINTR)) continue; else err(EXIT_FAILURE, "accept"); } len = read(ns, &op, 1); if (len != 1) { if (len < 0) perror("read"); else printf(_("Error reading from client, " "len = %d\n"), len); goto shutdown_socket; } if ((op == UUIDD_OP_BULK_TIME_UUID) || (op == UUIDD_OP_BULK_RANDOM_UUID)) { if (read_all(ns, (char *) &num, sizeof(num)) != 4) goto shutdown_socket; if (debug) printf(_("operation %d, incoming num = %d\n"), op, num); } else if (debug) printf(_("operation %d\n"), op); switch (op) { case UUIDD_OP_GETPID: sprintf(reply_buf, "%d", getpid()); reply_len = strlen(reply_buf) + 1; break; case UUIDD_OP_GET_MAXOP: sprintf(reply_buf, "%d", UUIDD_MAX_OP); reply_len = strlen(reply_buf) + 1; break; case UUIDD_OP_TIME_UUID: num = 1; __uuid_generate_time(uu, &num); if (debug) { uuid_unparse(uu, str); printf(_("Generated time UUID: %s\n"), str); } memcpy(reply_buf, uu, sizeof(uu)); reply_len = sizeof(uu); break; case UUIDD_OP_RANDOM_UUID: num = 1; __uuid_generate_random(uu, &num); if (debug) { uuid_unparse(uu, str); printf(_("Generated random UUID: %s\n"), str); } memcpy(reply_buf, uu, sizeof(uu)); reply_len = sizeof(uu); break; case UUIDD_OP_BULK_TIME_UUID: __uuid_generate_time(uu, &num); if (debug) { uuid_unparse(uu, str); printf(P_("Generated time UUID %s " "and %d following\n", "Generated time UUID %s " "and %d following\n", num - 1), str, num - 1); } memcpy(reply_buf, uu, sizeof(uu)); reply_len = sizeof(uu); memcpy(reply_buf + reply_len, &num, sizeof(num)); reply_len += sizeof(num); break; case UUIDD_OP_BULK_RANDOM_UUID: if (num < 0) num = 1; if (num > 1000) num = 1000; if (num * UUID_LEN > (int) (sizeof(reply_buf) - sizeof(num))) num = (sizeof(reply_buf) - sizeof(num)) / UUID_LEN; __uuid_generate_random((unsigned char *) reply_buf + sizeof(num), &num); if (debug) { printf(P_("Generated %d UUID:\n", "Generated %d UUIDs:\n", num), num); for (i = 0, cp = reply_buf + sizeof(num); i < num; i++, cp += UUID_LEN) { uuid_unparse((unsigned char *)cp, str); printf("\t%s\n", str); } } reply_len = (num * UUID_LEN) + sizeof(num); memcpy(reply_buf, &num, sizeof(num)); break; default: if (debug) printf(_("Invalid operation %d\n"), op); goto shutdown_socket; } write_all(ns, (char *) &reply_len, sizeof(reply_len)); write_all(ns, reply_buf, reply_len); shutdown_socket: close(ns); } }