diff options
Diffstat (limited to 'misc-utils')
| -rw-r--r-- | misc-utils/.gitignore | 4 | ||||
| -rw-r--r-- | misc-utils/Makefile.am | 50 | ||||
| -rw-r--r-- | misc-utils/blkid.8 | 211 | ||||
| -rw-r--r-- | misc-utils/blkid.c | 633 | ||||
| -rw-r--r-- | misc-utils/cal.c | 25 | ||||
| -rw-r--r-- | misc-utils/findfs.8 | 35 | ||||
| -rw-r--r-- | misc-utils/findfs.c | 60 | ||||
| -rw-r--r-- | misc-utils/script.c | 2 | ||||
| -rw-r--r-- | misc-utils/scriptreplay.c | 2 | ||||
| -rw-r--r-- | misc-utils/uuidd.8 | 96 | ||||
| -rw-r--r-- | misc-utils/uuidd.c | 588 | ||||
| -rw-r--r-- | misc-utils/uuidd.rc | 71 | ||||
| -rw-r--r-- | misc-utils/uuidgen.1 | 62 | ||||
| -rw-r--r-- | misc-utils/uuidgen.c | 77 |
14 files changed, 1894 insertions, 22 deletions
diff --git a/misc-utils/.gitignore b/misc-utils/.gitignore index 122b1920..2242b920 100644 --- a/misc-utils/.gitignore +++ b/misc-utils/.gitignore @@ -12,3 +12,7 @@ setterm whereis kill write +uuidgen +uuidd +findfs +blkid diff --git a/misc-utils/Makefile.am b/misc-utils/Makefile.am index 40610c14..a4f2f44e 100644 --- a/misc-utils/Makefile.am +++ b/misc-utils/Makefile.am @@ -1,22 +1,53 @@ include $(top_srcdir)/config/include-Makefile.am -EXTRA_DIST = README.flushb +EXTRA_DIST = README.flushb uuidd.rc bin_PROGRAMS = +sbin_PROGRAMS = +usrsbin_exec_PROGRAMS = -usrbinexec_PROGRAMS = cal ddate logger look mcookie \ +usrbin_exec_PROGRAMS = cal ddate logger look mcookie \ namei script whereis scriptreplay EXTRA_DIST += README.cal README.ddate README.namei README.namei2 mcookie_SOURCES = mcookie.c ../lib/md5.c -usrbinexec_SCRIPTS = chkdupexe +usrbin_exec_SCRIPTS = chkdupexe CLEANFILES = chkdupexe dist_man_MANS = cal.1 chkdupexe.1 ddate.1 logger.1 look.1 mcookie.1 \ namei.1 script.1 whereis.1 scriptreplay.1 +if BUILD_LIBUUID +usrbin_exec_PROGRAMS += uuidgen +dist_man_MANS += uuidgen.1 +uuidgen_LDADD = $(ul_libuuid_la) +uuidgen_CFLAGS = -I$(ul_libuuid_srcdir) +if BUILD_UUIDD +usrsbin_exec_PROGRAMS += uuidd +dist_man_MANS += uuidd.8 +uuidd_LDADD = $(ul_libuuid_la) +uuidd_CFLAGS = -I$(ul_libuuid_srcdir) +endif +endif + +if BUILD_LIBBLKID +sbin_PROGRAMS += blkid findfs +dist_man_MANS += blkid.8 findfs.8 +blkid_LDADD = $(ul_libblkid_la) +blkid_CFLAGS = -I$(ul_libblkid_srcdir) +findfs_LDADD = $(ul_libblkid_la) +findfs_CFLAGS = -I$(ul_libblkid_srcdir) +if HAVE_STATIC_BLKID +sbin_PROGRAMS += blkid.static +blkid_static_SOURCES = $(blkid_SOURCES) +blkid_static_LDFLAGS = "-all-static" # libtool option +blkid_static_LDADD = $(ul_libblkid_la) +blkid_static_CFLAGS = -I$(ul_libblkid_srcdir) +endif +endif + if HAVE_TINFO cal_LDADD = -ltinfo @NCURSES_LIBS@ else @@ -35,7 +66,7 @@ endif if HAVE_NCURSES if LINUX -usrbinexec_PROGRAMS += setterm +usrbin_exec_PROGRAMS += setterm dist_man_MANS += setterm.1 endif if HAVE_TINFO @@ -52,19 +83,18 @@ dist_man_MANS += kill.1 endif if BUILD_RENAME -usrbinexec_PROGRAMS += rename +usrbin_exec_PROGRAMS += rename dist_man_MANS += rename.1 endif if BUILD_RESET -dist_usrbinexec_SCRIPTS = reset +dist_usrbin_exec_SCRIPTS = reset dist_man_MANS += reset.1 endif EXTRA_DIST += README.reset reset.033c if BUILD_WRITE - -usrbinexec_PROGRAMS += write +usrbin_exec_PROGRAMS += write dist_man_MANS += write.1 write_CFLAGS = $(SUID_CFLAGS) $(AM_CFLAGS) write_LDFLAGS = $(SUID_LDFLAGS) $(AM_LDFLAGS) @@ -72,8 +102,8 @@ write_LDFLAGS = $(SUID_LDFLAGS) $(AM_LDFLAGS) if USE_TTY_GROUP if MAKEINSTALL_DO_CHOWN install-exec-hook:: - chgrp tty $(DESTDIR)$(usrbinexecdir)/write - chmod g+s $(DESTDIR)$(usrbinexecdir)/write + chgrp tty $(DESTDIR)$(usrbin_execdir)/write + chmod g+s $(DESTDIR)$(usrbin_execdir)/write endif endif endif diff --git a/misc-utils/blkid.8 b/misc-utils/blkid.8 new file mode 100644 index 00000000..ff8e8e57 --- /dev/null +++ b/misc-utils/blkid.8 @@ -0,0 +1,211 @@ +.\" Copyright 2000 Andreas Dilger (adilger@turbolinux.com) +.\" +.\" This man page was created for blkid from e2fsprogs-1.25. +.\" +.\" This file may be copied under the terms of the GNU Public License. +.\" +.\" Based on uuidgen, Mon Sep 17 10:42:12 2000, Andreas Dilger +.TH BLKID 8 "February 2009" "Linux" "MAINTENANCE COMMANDS" +.SH NAME +blkid \- command\-line utility to locate/print block device attributes +.SH SYNOPSIS +.B blkid +.RB \-L +.IR label " | " +.RB \-U +.IR uuid + +.B blkid +.RB [ \-ghlv ] +.RB [ \-c +.IR file ] +.RB [ \-w +.IR file ] +.RB [ \-o +.IR format ] +.in +6 +.RB [ \-s +.IR tag ] +.RB [ \-t +.IR NAME=value ] +.I device +[\fIdevice\fR ...] +.in -6 + +.B blkid +.RB -p +.RB [ \-O +.IR offset ] +.RB [ \-S +.IR size ] +.RB [ \-o +.IR format ] +.RB [ \-u +.IR list ] +.I device +[\fIdevice\fR ...] + +.SH DESCRIPTION +The +.B blkid +program is the command-line interface to working with +.BR libblkid (3) +library. It can determine the type of content (e.g. filesystem, swap) +a block device holds, and also attributes (tokens, NAME=value pairs) +from the content metadata (e.g. LABEL or UUID fields). +.PP +.B blkid +has two main forms of operation: either searching for a device with a +specific NAME=value pair, or displaying NAME=value pairs for one or +more devices. +.SH OPTIONS +.TP +.BI \-c " cachefile" +Read from +.I cachefile +instead of reading from the default cache file +.IR /etc/blkid.tab . +If you want to start with a clean cache (i.e. don't report devices previously +scanned but not necessarily available at this time), specify +.IR /dev/null . +.TP +.B \-g +Perform a garbage collection pass on the blkid cache to remove +devices which no longer exist. +.TP +.B \-h +Display a usage message and exit. +.TP +.B \-l +Look up one device that matches the search parameter specified using +the +.B \-t +option. If there are multiple devices that match the specified search +parameter, then the device with the highest priority is returned, and/or +the first device found at a given priority. Device types in order of +decreasing priority are Device Mapper, EVMS, LVM, MD, and finally regular +block devices. If this option is not specified, +.B blkid +will print all of the devices that match the search parameter. +.TP +.B \-L " label " +Look up one device that uses the label (same as: -l -o device -t +LABEL=<label>). This look up method is able to reliable use /dev/disk/by-label +udev symlinks (depends on setting in /etc/blkid.conf). Avoid to use the +symlinks directly. It is not reliable to use the symlinks without verification. +The \fB-L\fR option is portable and works on systems with and without udev. +.TP +.B \-u " list " +Restrict probing functions to defined (comma separated) list of "usage" types. +Supported usage types are: filesystem, raid, crypto and other. The list can be +prefixed with "no" to specify the usage types which should be ignored. For example: +.sp + blkid -p -u filesystem,other /dev/sda1 +.sp +probes for all filesystems and others (e.g. swap) formats, and +.sp + blkid -p -u noraid /dev/sda1 +.sp +probes for all supported formats exclude RAIDs. This option is useful with +\fB-p\fR only. +.TP +.B \-U " uuid " +Look up one device that uses the uuid. For more details see the \fB-L\fR option. +.TP +.BI \-o " format" +Display +.BR blkid 's +output using the specified format. The +.I format +parameter may be: +.RS +.TP +.B full +print all tags (the default) +.TP +.B value +print the value of the tags +.TP +.B list +print the devices in a user-friendly format +.TP +.B device +print the device name only +.TP +.B udev +vol_id compatible mode; usable in udev rules +.RE +.TP +.BI \-O " bytes" +Probe at the given offset (only useful with \fB-p\fR). +.TP +.BI \-p +Switch to low-level probing mode (bypass cache)" +.TP +.BI \-s " tag" +For each (specified) device, show only the tags that match +.IR tag . +It is possible to specify multiple +.B \-s +options. If no tag is specified, then all tokens are shown for all +(specified) devices. +In order to just refresh the cache without showing any tokens, use +.B "-s none" +with no other options. +.TP +.BI \-S " bytes" +Overwrite device/file size (only useful with \fB-p\fR). +.TP +.BI \-t " NAME" = "value" +Search for block devices with tokens named +.I NAME +that have the value +.IR value , +and display any devices which are found. +Common values for +.I NAME +include +.BR TYPE , +.BR LABEL , +and +.BR UUID . +If there are no devices specified on the command line, all block devices +will be searched; otherwise only the specified devices are searched. +.TP +.B \-v +Display version number and exit. +.TP +.BI \-w " writecachefile" +Write the device cache to +.I writecachefile +instead of writing it to the default cache file +.IR /etc/blkid.tab . +If you don't want to save the cache to the default file, specify +.IR /dev/null. +If not specified it will be the same file as that given by the +.B \-c +option. +.TP +.I device +Display tokens from only the specified device. It is possible to +give multiple +.I device +options on the command line. If none is given, all devices which +appear in +.I /proc/partitions +are shown, if they are recognized. +.SH "RETURN CODE" +If the specified token was found, or if any tags were shown from (specified) +devices, 0 is returned. If the specified token was not found, or no +(specified) devices could be identified, an exit code of 2 is returned. +For usage or other errors, an exit code of 4 is returned. +.SH AUTHOR +.B blkid +was written by Andreas Dilger for libblkid and improved by Theodore Ts'o +and Karel Zak. +.SH AVAILABILITY +The blkid command is part of the util-linux-ng package and is available from +ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/. +.SH "SEE ALSO" +.BR libblkid (3) +.BR findfs (8) diff --git a/misc-utils/blkid.c b/misc-utils/blkid.c new file mode 100644 index 00000000..528e4a22 --- /dev/null +++ b/misc-utils/blkid.c @@ -0,0 +1,633 @@ +/* + * blkid.c - User command-line interface for libblkid + * + * Copyright (C) 2001 Andreas Dilger + * + * %Begin-Header% + * This file may be redistributed under the terms of the + * GNU Lesser General Public License. + * %End-Header% + */ + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#ifdef HAVE_TERMIOS_H +#include <termios.h> +#endif +#ifdef HAVE_TERMIO_H +#include <termio.h> +#endif +#ifdef HAVE_SYS_IOCTL_H +#include <sys/ioctl.h> +#endif +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#else +extern int getopt(int argc, char * const argv[], const char *optstring); +extern char *optarg; +extern int optind; +#endif + +#define OUTPUT_VALUE_ONLY 0x0001 +#define OUTPUT_DEVICE_ONLY 0x0002 +#define OUTPUT_PRETTY_LIST 0x0004 +#define OUTPUT_UDEV_LIST 0x0008 + +#include <blkid.h> + +const char *progname = "blkid"; + +static void print_version(FILE *out) +{ + fprintf(out, "%s from %s (libblkid %s, %s)\n", + progname, PACKAGE_STRING, LIBBLKID_VERSION, LIBBLKID_DATE); +} + +static void usage(int error) +{ + FILE *out = error ? stderr : stdout; + + print_version(out); + fprintf(out, + "Usage:\n" + " %1$s -L <label> | -U <uuid>\n\n" + " %1$s [-c <file>] [-ghlLv] [-o format] [-s <tag>] \n" + " [-t <token>] [-w <file>] [dev ...]\n\n" + " %1$s -p [-O <offset>] [-S <size>] [-o format] <dev> [dev ...]\n\n" + "Options:\n" + " -c <file> cache file (default: /etc/blkid.tab, /dev/null = none)\n" + " -h print this usage message and exit\n" + " -g garbage collect the blkid cache\n" + " -o <format> output format; can be one of:\n" + " value, device, list, udev or full; (default: full)\n" + " -s <tag> show specified tag(s) (default show all tags)\n" + " -t <token> find device with a specific token (NAME=value pair)\n" + " -l lookup the the first device with arguments specified by -t\n" + " -L <label> convert LABEL to device name\n" + " -U <uuid> convert UUID to device name\n" + " -v print version and exit\n" + " -w <file> write cache to different file (/dev/null = no write)\n" + " <dev> specify device(s) to probe (default: all devices)\n\n" + "Low-level probing options:\n" + " -p switch to low-level mode (bypass cache)\n" + " -S <bytes> overwrite device size\n" + " -O <bytes> probe at the given offset\n" + " -u <list> filter by \"usage\" (e.g. -u filesystem,raid)\n" + "\n", + progname); + + exit(error); +} + +/* + * This function does "safe" printing. It will convert non-printable + * ASCII characters using '^' and M- notation. + */ +static void safe_print(const char *cp, int len) +{ + unsigned char ch; + + if (len < 0) + len = strlen(cp); + + while (len--) { + ch = *cp++; + if (ch > 128) { + fputs("M-", stdout); + ch -= 128; + } + if ((ch < 32) || (ch == 0x7f)) { + fputc('^', stdout); + ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */ + } + fputc(ch, stdout); + } +} + +static int get_terminal_width(void) +{ +#ifdef TIOCGSIZE + struct ttysize t_win; +#endif +#ifdef TIOCGWINSZ + struct winsize w_win; +#endif + const char *cp; + +#ifdef TIOCGSIZE + if (ioctl (0, TIOCGSIZE, &t_win) == 0) + return (t_win.ts_cols); +#endif +#ifdef TIOCGWINSZ + if (ioctl (0, TIOCGWINSZ, &w_win) == 0) + return (w_win.ws_col); +#endif + cp = getenv("COLUMNS"); + if (cp) + return strtol(cp, NULL, 10); + return 80; +} + +static int pretty_print_word(const char *str, int max_len, + int left_len, int overflow_nl) +{ + int len = strlen(str) + left_len; + int ret = 0; + + fputs(str, stdout); + if (overflow_nl && len > max_len) { + fputc('\n', stdout); + len = 0; + } else if (len > max_len) + ret = len - max_len; + do + fputc(' ', stdout); + while (len++ < max_len); + return ret; +} + +static void pretty_print_line(const char *device, const char *fs_type, + const char *label, const char *mtpt, + const char *uuid) +{ + static int device_len = 10, fs_type_len = 7; + static int label_len = 8, mtpt_len = 14; + static int term_width = -1; + int len, w; + + if (term_width < 0) + term_width = get_terminal_width(); + + if (term_width > 80) { + term_width -= 80; + w = term_width / 10; + if (w > 8) + w = 8; + term_width -= 2*w; + label_len += w; + fs_type_len += w; + w = term_width/2; + device_len += w; + mtpt_len +=w; + } + + len = pretty_print_word(device, device_len, 0, 1); + len = pretty_print_word(fs_type, fs_type_len, len, 0); + len = pretty_print_word(label, label_len, len, 0); + len = pretty_print_word(mtpt, mtpt_len, len, 0); + fputs(uuid, stdout); + fputc('\n', stdout); +} + +static void pretty_print_dev(blkid_dev dev) +{ + fprintf(stderr, "pretty print not implemented yet\n"); + +#ifdef NOT_IMPLEMENTED + blkid_tag_iterate iter; + const char *type, *value, *devname; + const char *uuid = "", *fs_type = "", *label = ""; + char *cp; + int len, mount_flags; + char mtpt[80]; + errcode_t retval; + + if (dev == NULL) { + pretty_print_line("device", "fs_type", "label", + "mount point", "UUID"); + for (len=get_terminal_width()-1; len > 0; len--) + fputc('-', stdout); + fputc('\n', stdout); + return; + } + + devname = blkid_dev_devname(dev); + if (access(devname, F_OK)) + return; + + /* Get the uuid, label, type */ + iter = blkid_tag_iterate_begin(dev); + while (blkid_tag_next(iter, &type, &value) == 0) { + if (!strcmp(type, "UUID")) + uuid = value; + if (!strcmp(type, "TYPE")) + fs_type = value; + if (!strcmp(type, "LABEL")) + label = value; + } + blkid_tag_iterate_end(iter); + + /* Get the mount point */ + mtpt[0] = 0; + retval = ext2fs_check_mount_point(devname, &mount_flags, + mtpt, sizeof(mtpt)); + if (retval == 0) { + if (mount_flags & EXT2_MF_MOUNTED) { + if (!mtpt[0]) + strcpy(mtpt, "(mounted, mtpt unknown)"); + } else if (mount_flags & EXT2_MF_BUSY) + strcpy(mtpt, "(in use)"); + else + strcpy(mtpt, "(not mounted)"); + } + + pretty_print_line(devname, fs_type, label, mtpt, uuid); +#endif +} + +static void print_udev_format(const char *name, const char *value, size_t sz) +{ + char enc[265], safe[256]; + + *safe = *enc = '\0'; + + if (!strcmp(name, "TYPE") || !strcmp(name, "VERSION")) { + blkid_encode_string(value, enc, sizeof(enc)); + printf("ID_FS_%s=%s\n", name, enc); + + } else if (!strcmp(name, "UUID") || + !strcmp(name, "LABEL") || + !strcmp(name, "UUID_SUB")) { + + blkid_safe_string(value, safe, sizeof(safe)); + printf("ID_FS_%s=%s\n", name, safe); + + blkid_encode_string(value, enc, sizeof(enc)); + printf("ID_FS_%s_ENC=%s\n", name, enc); + } + else + printf("ID_FS_%s=%s\n", name, value); +} + +static void print_value(int output, int num, const char *devname, + const char *value, const char *name, size_t valsz) +{ + if (output & OUTPUT_VALUE_ONLY) { + fputs(value, stdout); + fputc('\n', stdout); + + } else if (output & OUTPUT_UDEV_LIST) { + print_udev_format(name, value, valsz); + + } else { + if (num == 1 && devname) + printf("%s: ", devname); + fputs(name, stdout); + fputs("=\"", stdout); + safe_print(value, valsz); + fputs("\" ", stdout); + } +} + +static void print_tags(blkid_dev dev, char *show[], int numtag, int output) +{ + blkid_tag_iterate iter; + const char *type, *value, *devname; + int i, num = 1; + + if (!dev) + return; + + if (output & OUTPUT_PRETTY_LIST) { + pretty_print_dev(dev); + return; + } + + devname = blkid_dev_devname(dev); + + if (output & OUTPUT_DEVICE_ONLY) { + printf("%s\n", devname); + return; + } + + iter = blkid_tag_iterate_begin(dev); + while (blkid_tag_next(iter, &type, &value) == 0) { + if (numtag && show) { + for (i=0; i < numtag; i++) + if (!strcmp(type, show[i])) + break; + if (i >= numtag) + continue; + } + print_value(output, num++, devname, value, type, strlen(value)); + } + blkid_tag_iterate_end(iter); + + if (num > 1 && !(output & (OUTPUT_VALUE_ONLY | OUTPUT_UDEV_LIST))) + printf("\n"); +} + +static int lowprobe_device(blkid_probe pr, const char *devname, int output, + blkid_loff_t offset, blkid_loff_t size) +{ + const char *data; + const char *name; + int nvals = 0, n; + size_t len; + int fd; + int rc = 0; + + fd = open(devname, O_RDONLY); + if (fd < 0) + return 2; + + if (blkid_probe_set_device(pr, fd, offset, size)) + goto done; + rc = blkid_do_safeprobe(pr); + if (rc) + goto done; + + nvals = blkid_probe_numof_values(pr); + + if (output & OUTPUT_DEVICE_ONLY) { + printf("%s\n", devname); + goto done; + } + + for (n = 0; n < nvals; n++) { + if (blkid_probe_get_value(pr, n, &name, &data, &len)) + continue; + + len = strnlen((char *) data, len); + print_value(output, n + 1, devname, (char *) data, name, len); + } + + if (nvals > 1 && !(output & (OUTPUT_VALUE_ONLY | OUTPUT_UDEV_LIST))) + printf("\n"); +done: + if (rc == -2) + fprintf(stderr, "%s: ambivalent result " + "(probably more filesystems on the device)\n", + devname); + close(fd); + return !nvals ? 2 : 0; +} + +/* converts comma separated list to BLKID_USAGE_* mask */ +static int list_to_usage(const char *list, int *flag) +{ + int mask = 0; + const char *word, *p = list; + + if (p && strncmp(p, "no", 2) == 0) { + *flag = BLKID_FLTR_NOTIN; + p += 2; + } + + for (word = p; p && *p; p++) { + if (*p == ',' || *(p + 1) == '\0') { + if (!strncmp(word, "filesystem", 10)) + mask |= BLKID_USAGE_FILESYSTEM; + else if (!strncmp(word, "raid", 4)) + mask |= BLKID_USAGE_RAID; + else if (!strncmp(word, "crypto", 6)) + mask |= BLKID_USAGE_CRYPTO; + else if (!strncmp(word, "other", 5)) + mask |= BLKID_USAGE_OTHER; + else { + fprintf(stderr, "unknown usage keyword '%*s'\n", + (int) (p - word), word); + exit(4); + } + word = p + 1; + } + } + return mask; +} + +int main(int argc, char **argv) +{ + blkid_cache cache = NULL; + char *devices[128] = { NULL, }; + char *show[128] = { NULL, }; + char *search_type = NULL, *search_value = NULL; + char *read = NULL; + char *write = NULL; + int fltr_usage = 0; + int fltr_flag = BLKID_FLTR_ONLYIN; + unsigned int numdev = 0, numtag = 0; + int version = 0; + int err = 4; + unsigned int i; + int output_format = 0; + int lookup = 0, gc = 0, lowprobe = 0, eval = 0; + int c; + blkid_loff_t offset = 0, size = 0; + + while ((c = getopt (argc, argv, "c:f:ghlL:o:O:ps:S:t:u:U:w:v")) != EOF) + switch (c) { + case 'c': + if (optarg && !*optarg) + read = NULL; + else + read = optarg; + if (!write) + write = read; + break; + case 'L': + eval++; + search_value = strdup(optarg); + search_type = strdup("LABEL"); + break; + case 'u': + fltr_usage = list_to_usage(optarg, &fltr_flag); + break; + case 'U': + eval++; + search_value = strdup(optarg); + search_type = strdup("UUID"); + break; + case 'l': + lookup++; + break; + case 'g': + gc = 1; + break; + case 'o': + if (!strcmp(optarg, "value")) + output_format = OUTPUT_VALUE_ONLY; + else if (!strcmp(optarg, "device")) + output_format = OUTPUT_DEVICE_ONLY; + else if (!strcmp(optarg, "list")) + output_format = OUTPUT_PRETTY_LIST; + else if (!strcmp(optarg, "udev")) + output_format = OUTPUT_UDEV_LIST; + else if (!strcmp(optarg, "full")) + output_format = 0; + else { + fprintf(stderr, "Invalid output format %s. " + "Choose from value,\n\t" + "device, list, udev or full\n", optarg); + exit(4); + } + break; + case 'O': + offset = strtoll(optarg, NULL, 10); + break; + case 'p': + lowprobe++; + break; + case 's': + if (numtag >= sizeof(show) / sizeof(*show)) { + fprintf(stderr, "Too many tags specified\n"); + usage(err); + } + show[numtag++] = optarg; + break; + case 'S': + size = strtoll(optarg, NULL, 10); + break; + case 't': + if (search_type) { + fprintf(stderr, "Can only search for " + "one NAME=value pair\n"); + usage(err); + } + if (blkid_parse_tag_string(optarg, + &search_type, + &search_value)) { + fprintf(stderr, "-t needs NAME=value pair\n"); + usage(err); + } + break; + case 'v': + version = 1; + break; + case 'w': + if (optarg && !*optarg) + write = NULL; + else + write = optarg; + break; + case 'h': + err = 0; + default: + usage(err); + } + + while (optind < argc) + devices[numdev++] = argv[optind++]; + + if (version) { + print_version(stdout); + goto exit; + } + + /* convert LABEL/UUID lookup to evaluate request */ + if (lookup && output_format == OUTPUT_DEVICE_ONLY && search_type && + (!strcmp(search_type, "LABEL") || !strcmp(search_type, "UUID"))) { + eval++; + lookup = 0; + } + + if (!lowprobe && !eval && blkid_get_cache(&cache, read) < 0) + goto exit; + + if (gc) { + blkid_gc_cache(cache); + err = 0; + goto exit; + } + err = 2; + + if (output_format & OUTPUT_PRETTY_LIST) + pretty_print_dev(NULL); + + if (lowprobe) { + /* + * Low-level API + */ + blkid_probe pr; + + if (!numdev) { + fprintf(stderr, "The low-probe option requires a device\n"); + exit(4); + } + pr = blkid_new_probe(); + if (!pr) + goto exit; + blkid_probe_set_request(pr, + BLKID_PROBREQ_LABEL | BLKID_PROBREQ_UUID | + BLKID_PROBREQ_TYPE | BLKID_PROBREQ_SECTYPE | + BLKID_PROBREQ_USAGE | BLKID_PROBREQ_VERSION); + if (fltr_usage && + blkid_probe_filter_usage(pr, fltr_flag, fltr_usage)) + goto exit; + + for (i = 0; i < numdev; i++) + err = lowprobe_device(pr, devices[i], + output_format, offset, size); + blkid_free_probe(pr); + } else if (eval) { + /* + * Evaluate API + */ + char *res = blkid_evaluate_tag(search_type, search_value, NULL); + if (res) { + err = 0; + printf("%s\n", res); + } + } else if (lookup) { + /* + * Classic (cache based) API + */ + blkid_dev dev; + + if (!search_type) { + fprintf(stderr, "The lookup option requires a " + "search type specified using -t\n"); + exit(4); + } + /* Load any additional devices not in the cache */ + for (i = 0; i < numdev; i++) + blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL); + + if ((dev = blkid_find_dev_with_tag(cache, search_type, + search_value))) { + print_tags(dev, show, numtag, output_format); + err = 0; + } + /* If we didn't specify a single device, show all available devices */ + } else if (!numdev) { + blkid_dev_iterate iter; + blkid_dev dev; + + blkid_probe_all(cache); + + iter = blkid_dev_iterate_begin(cache); + blkid_dev_set_search(iter, search_type, search_value); + while (blkid_dev_next(iter, &dev) == 0) { + dev = blkid_verify(cache, dev); + if (!dev) + continue; + print_tags(dev, show, numtag, output_format); + err = 0; + } + blkid_dev_iterate_end(iter); + /* Add all specified devices to cache (optionally display tags) */ + } else for (i = 0; i < numdev; i++) { + blkid_dev dev = blkid_get_dev(cache, devices[i], + BLKID_DEV_NORMAL); + + if (dev) { + if (search_type && + !blkid_dev_has_tag(dev, search_type, + search_value)) + continue; + print_tags(dev, show, numtag, output_format); + err = 0; + } + } + +exit: + free(search_type); + free(search_value); + if (!lowprobe && !eval) + blkid_put_cache(cache); + return err; +} diff --git a/misc-utils/cal.c b/misc-utils/cal.c index a8534b8c..bda3a963 100644 --- a/misc-utils/cal.c +++ b/misc-utils/cal.c @@ -162,7 +162,7 @@ char *Hrow; /* pointer to highlighted row in month */ #define FIRST_MISSING_DAY 639799 /* 3 Sep 1752 */ #define NUMBER_MISSING_DAYS 11 /* 11 day correction */ -#define MAXDAYS 43 /* max slots in a month array */ +#define MAXDAYS 42 /* slots in a month array */ #define SPACE -1 /* used in day array */ static int days_in_month[2][13] = { @@ -170,30 +170,34 @@ static int days_in_month[2][13] = { {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, }; -int sep1752[MAXDAYS] = { +#define SEP1752_OFS 4 /* sep1752[4] is a Sunday */ + +/* 1 Sep 1752 is represented by sep1752[6] and j_sep1752[6] */ +int sep1752[MAXDAYS+6] = { + SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, 1, 2, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, - SPACE -}, j_sep1752[MAXDAYS] = { + SPACE, SPACE +}, j_sep1752[MAXDAYS+6] = { + SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, 245, 246, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, - SPACE + SPACE, SPACE }, empty[MAXDAYS] = { SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, - SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, - SPACE + SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE }; #define DAY_LEN 3 /* 3 spaces per day */ @@ -354,7 +358,7 @@ main(int argc, char **argv) { day = month = year = 0; switch(argc) { case 3: - if ((day = atoi(*argv++)) < 1 || month > 31) + if ((day = atoi(*argv++)) < 1 || day > 31) errx(1, _("illegal day value: use 1-%d"), 31); /* FALLTHROUGH */ case 2: @@ -629,10 +633,11 @@ day_array(int day, int month, int year, int *days) { int *d_sep1752; if (month == 9 && year == 1752) { + int sep1752_ofs = (weekstart + SEP1752_OFS) % 7; d_sep1752 = julian ? j_sep1752 : sep1752; - memcpy(days, d_sep1752 + weekstart, MAXDAYS * sizeof(int)); + memcpy(days, d_sep1752 + sep1752_ofs, MAXDAYS * sizeof(int)); for (dm=0; dm<MAXDAYS; dm++) - if (j_sep1752[dm] == day) + if (j_sep1752[dm + sep1752_ofs] == day) days[dm] |= TODAY_FLAG; return; } diff --git a/misc-utils/findfs.8 b/misc-utils/findfs.8 new file mode 100644 index 00000000..e93fe542 --- /dev/null +++ b/misc-utils/findfs.8 @@ -0,0 +1,35 @@ +.\" -*- nroff -*- +.\" Copyright 1993, 1994, 1995 by Theodore Ts'o. All Rights Reserved. +.\" This file may be copied under the terms of the GNU Public License. +.\" +.TH FINDFS 8 "February 2009" "Linux" "MAINTENANCE COMMANDS" +.SH NAME +findfs \- Find a filesystem by label or UUID +.SH SYNOPSIS +.B findfs +.BI LABEL= label +.sp +.B findfs +.BI UUID= uuid +.SH DESCRIPTION +.B findfs +will search the disks in the system looking for a filesystem which has +a label matching +.I label +or a UUID equal to +.IR uuid . +If the filesystem is found, the device name for the filesystem will +be printed on stdout. +.PP +.SH AUTHOR +.B findfs +was originally written by Theodore Ts'o (tytso@mit.edu) and re-written for +util-linux-ng package by Karel Zak (kzak@redhat.com). +.SH AVAILABILITY +.B findfs +The blkid command is part of the util-linux-ng package and is available from +ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/. +.SH SEE ALSO +.BR blkid (8) +.BR fsck (8) + diff --git a/misc-utils/findfs.c b/misc-utils/findfs.c new file mode 100644 index 00000000..18608b47 --- /dev/null +++ b/misc-utils/findfs.c @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 Karel Zak <kzak@redhat.com> + * + * This file may be redistributed under the terms of the GNU Public + * License. + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <err.h> + +#include <blkid.h> + +#include "nls.h" + +static void __attribute__((__noreturn__)) usage(int rc) +{ + const char *p = program_invocation_short_name; + + if (!p) + p = "findfs"; + + fprintf(stderr, _("Usage: %s LABEL=<label>|UUID=<uuid>\n"), p); + exit(rc); +} + +int main(int argc, char **argv) +{ + char *dev, *tk, *vl; + + setlocale(LC_ALL, ""); + bindtextdomain(PACKAGE, LOCALEDIR); + textdomain(PACKAGE); + + if (argc != 2) + /* we return '2' for backward compatibility + * with version from e2fsprogs */ + usage(2); + + if (!strncmp(argv[1], "LABEL=", 6)) { + tk = "LABEL"; + vl = argv[1] + 6; + } else if (!strncmp(argv[1], "UUID=", 5)) { + tk = "UUID"; + vl = argv[1] + 5; + } else if (!strcmp(argv[1], "-h") == 0 || + !strcmp(argv[1], "--help") == 0) { + usage(EXIT_SUCCESS); + } else + usage(2); + + dev = blkid_evaluate_tag(tk, vl, NULL); + if (!dev) + errx(EXIT_FAILURE, _("unable to resolve '%s'"), argv[1]); + + puts(dev); + exit(EXIT_SUCCESS); +} + diff --git a/misc-utils/script.c b/misc-utils/script.c index 12ea43a8..b877c312 100644 --- a/misc-utils/script.c +++ b/misc-utils/script.c @@ -371,7 +371,7 @@ doshell() { #if 0 int t; - t = open(_PATH_TTY, O_RDWR); + t = open(_PATH_DEV_TTY, O_RDWR); if (t >= 0) { (void) ioctl(t, TIOCNOTTY, (char *)0); (void) close(t); diff --git a/misc-utils/scriptreplay.c b/misc-utils/scriptreplay.c index 8a254de9..e13edf37 100644 --- a/misc-utils/scriptreplay.c +++ b/misc-utils/scriptreplay.c @@ -163,7 +163,7 @@ main(int argc, char *argv[]) err(EXIT_FAILURE, _("failed to read timing file %s"), tname); errx(EXIT_FAILURE, - _("timings file %s: %lu: expected format"), + _("timings file %s: %lu: unexpected format"), tname, line); } delay /= divi; diff --git a/misc-utils/uuidd.8 b/misc-utils/uuidd.8 new file mode 100644 index 00000000..67c6614a --- /dev/null +++ b/misc-utils/uuidd.8 @@ -0,0 +1,96 @@ +.\" -*- nroff -*- +.\" Copyright 2007 by Theodore Ts'o. All Rights Reserved. +.\" This file may be copied under the terms of the GNU Public License. +.\" +.TH UUIDD 8 "May 2009" "Linux" +.SH NAME +uuidd \- UUID generation daemon +.SH SYNOPSIS +.B uuidd +[ +.B \-d +] +[ +.B \-p +.I pidfile +] +[ +.B \-s +.I socketpath +] +[ +.B \-T +.I timeout +] + +.B uuidd +[ +.B \-r +| +.B \-t +] +[ +.B \-n +.I number +] +[ +.B \-s +.I socketpath +] + +.B uuidd \-k +.SH DESCRIPTION +The +.B uuidd +daemon is used by the UUID library to generate +universally unique identifiers (UUIDs), especially time-based UUID's +in a secure and guaranteed-unique fashion, even in the face of large +numbers of threads trying to grab UUID's running on different CPU's. +.SH OPTIONS +.TP +.B \-d +Run +.B uuidd +in debugging mode. This prevents uuidd from running as a daemon. +.TP +.B \-k +If a currently uuidd daemon is running, kill it. +.TP +.BI \-n " number" +When issuing a test request to a running uuidd, request a bulk response +of +.I number +UUID's. +.TP +.BI \-p " pidfile" +Specify the pathname where the pid file should be written. By default, +the pid file is written to /var/run/uuidd/uuidd.pid. +.TP +.BI \-s " socketpath" +Specify the pathname used for the unix-domain socket used by uuidd. By +default, the pathname used is /var/run/uuidd/request. This is primarily +for debugging purposes, since the pathname is hard-coded in the libuuid +library. +.TP +.B \-r +Test uuidd by trying to connect to a running uuidd daemon and +request it to return a random-based UUID. +.TP +.B \-t +Test uuidd by trying to connect to a running uuidd daemon and +request it to return a time-based UUID. +.TP +.BI \-T " timeout" +Specify a timeout for uuidd. If specified, then uuidd will exit after +.I timeout +seconds of inactivity. +.SH AUTHOR +The +.B uuidd +daemon was written by Theodore Ts'o <tytso@mit.edu>. +.SH AVAILABILITY +uuidd is part of the util-linux-ng package and is available from +ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/. +.SH "SEE ALSO" +.BR libuuid (3), +.BR uuidgen (1) diff --git a/misc-utils/uuidd.c b/misc-utils/uuidd.c new file mode 100644 index 00000000..74bab693 --- /dev/null +++ b/misc-utils/uuidd.c @@ -0,0 +1,588 @@ +/* + * uuidd.c --- UUID-generation daemon + * + * Copyright (C) 2007 Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ +#include <stdio.h> +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#include <unistd.h> +#include <inttypes.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <fcntl.h> +#include <signal.h> +#include <string.h> +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#else +extern int getopt(int argc, char * const argv[], const char *optstring); +extern char *optarg; +extern int optind; +#endif + +#include "uuid.h" +#include "uuidd.h" + +#include "nls.h" + +#ifdef __GNUC__ +#define CODE_ATTR(x) __attribute__(x) +#else +#define CODE_ATTR(x) +#endif + +static void usage(const char *progname) +{ + fprintf(stderr, _("Usage: %s [-d] [-p pidfile] [-s socketpath] " + "[-T timeout]\n"), progname); + fprintf(stderr, _(" %s [-r|t] [-n num] [-s socketpath]\n"), + progname); + fprintf(stderr, _(" %s -k\n"), progname); + exit(1); +} + +static void die(const char *msg) +{ + perror(msg); + exit(1); +} + +static void create_daemon(void) +{ + pid_t pid; + uid_t euid; + + pid = fork(); + if (pid == -1) { + perror("fork"); + exit(1); + } else if (pid != 0) { + exit(0); + } + + close(0); + close(1); + close(2); + open("/dev/null", O_RDWR); + open("/dev/null", O_RDWR); + open("/dev/null", O_RDWR); + + if (chdir("/")) {} /* Silence warn_unused_result warning */ + (void) setsid(); + euid = geteuid(); + if (setreuid(euid, euid) < 0) + die("setreuid"); +} + +static ssize_t read_all(int fd, char *buf, size_t count) +{ + ssize_t ret; + ssize_t c = 0; + int tries = 0; + + memset(buf, 0, count); + while (count > 0) { + ret = read(fd, buf, count); + if (ret <= 0) { + if ((errno == EAGAIN || errno == EINTR || ret == 0) && + (tries++ < 5)) + continue; + return c ? c : -1; + } + if (ret > 0) + tries = 0; + count -= ret; + buf += ret; + c += ret; + } + return c; +} + +static int write_all(int fd, char *buf, size_t count) +{ + ssize_t ret; + int c = 0; + + while (count > 0) { + ret = write(fd, buf, count); + if (ret < 0) { + if ((errno == EAGAIN) || (errno == EINTR)) + continue; + return -1; + } + count -= ret; + buf += ret; + c += ret; + } + return c; +} + +static const char *cleanup_pidfile, *cleanup_socket; + +static void terminate_intr(int signo CODE_ATTR((unused))) +{ + (void) unlink(cleanup_pidfile); + if (cleanup_socket) + (void) unlink(cleanup_socket); + exit(0); +} + +static int call_daemon(const char *socket_path, int op, char *buf, + int buflen, int *num, const char **err_context) +{ + char op_buf[8]; + int op_len; + int s; + ssize_t ret; + int32_t reply_len = 0; + struct sockaddr_un srv_addr; + + if (((op == 4) || (op == 5)) && !num) { + if (err_context) + *err_context = _("bad arguments"); + errno = EINVAL; + return -1; + } + + if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + if (err_context) + *err_context = _("socket"); + return -1; + } + + srv_addr.sun_family = AF_UNIX; + strncpy(srv_addr.sun_path, socket_path, sizeof(srv_addr.sun_path)); + srv_addr.sun_path[sizeof(srv_addr.sun_path)-1] = '\0'; + + if (connect(s, (const struct sockaddr *) &srv_addr, + sizeof(struct sockaddr_un)) < 0) { + if (err_context) + *err_context = _("connect"); + close(s); + return -1; + } + + if (op == 5) { + if ((*num)*16 > buflen-4) + *num = (buflen-4) / 16; + } + op_buf[0] = op; + op_len = 1; + if ((op == 4) || (op == 5)) { + memcpy(op_buf+1, num, sizeof(int)); + op_len += sizeof(int); + } + + ret = write_all(s, op_buf, op_len); + if (ret < op_len) { + if (err_context) + *err_context = _("write"); + close(s); + return -1; + } + + ret = read_all(s, (char *) &reply_len, sizeof(reply_len)); + if (ret < 0) { + if (err_context) + *err_context = _("read count"); + close(s); + return -1; + } + if (reply_len < 0 || reply_len > buflen) { + if (err_context) + *err_context = _("bad response length"); + close(s); + return -1; + } + ret = read_all(s, (char *) buf, reply_len); + + if ((ret > 0) && (op == 4)) { + if (reply_len >= (int) (16+sizeof(int))) + memcpy(buf+16, num, sizeof(int)); + else + *num = -1; + } + if ((ret > 0) && (op == 5)) { + if (*num >= (int) sizeof(int)) + memcpy(buf, num, sizeof(int)); + else + *num = -1; + } + + close(s); + + return ret; +} + +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[37]; + 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: %s\n", + pidfile_path, strerror(errno)); + exit(1); + } + 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: %s\n", + pidfile_path, strerror(errno)); + exit(1); + } + 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(1); + } + alarm(0); + + if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + if (!quiet) + fprintf(stderr, _("Couldn't create unix stream " + "socket: %s"), strerror(errno)); + exit(1); + } + + /* + * 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) { + perror("dup"); + exit(1); + } + } + + /* + * 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'; + (void) 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: %s\n"), + socket_path, strerror(errno)); + exit(1); + } + (void) umask(save_umask); + + if (listen(s, 5) < 0) { + if (!quiet) + fprintf(stderr, _("Couldn't listen on unix " + "socket %s: %s\n"), socket_path, + strerror(errno)); + exit(1); + } + + 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; + perror("accept"); + exit(1); + } + 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 == 4) || (op == 5)) { + 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(_("Generated time UUID %s and %d " + "following\n"), str, num); + } + 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*16 > (int) (sizeof(reply_buf)-sizeof(num))) + num = (sizeof(reply_buf)-sizeof(num)) / 16; + uuid__generate_random((unsigned char *) reply_buf + + sizeof(num), &num); + if (debug) { + printf(_("Generated %d UUID's:\n"), num); + for (i=0, cp=reply_buf+sizeof(num); + i < num; i++, cp+=16) { + uuid_unparse((unsigned char *)cp, str); + printf("\t%s\n", str); + } + } + reply_len = (num*16) + 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); + } +} + +int main(int argc, char **argv) +{ + const char *socket_path = UUIDD_SOCKET_PATH; + const char *pidfile_path = UUIDD_PIDFILE_PATH; + const char *err_context; + char buf[1024], *cp; + char str[37], *tmp; + uuid_t uu; + uid_t uid; + gid_t gid; + int i, c, ret; + int debug = 0, do_type = 0, do_kill = 0, num = 0; + int timeout = 0, quiet = 0, drop_privs = 0; + + setlocale(LC_ALL, ""); + bindtextdomain(PACKAGE, LOCALEDIR); + textdomain(PACKAGE); + + while ((c = getopt (argc, argv, "dkn:qp:s:tT:r")) != EOF) { + switch (c) { + case 'd': + debug++; + drop_privs = 1; + break; + case 'k': + do_kill++; + drop_privs = 1; + break; + case 'n': + num = strtol(optarg, &tmp, 0); + if ((num < 0) || *tmp) { + fprintf(stderr, _("Bad number: %s\n"), optarg); + exit(1); + } + case 'p': + pidfile_path = optarg; + drop_privs = 1; + break; + case 'q': + quiet++; + break; + case 's': + socket_path = optarg; + drop_privs = 1; + break; + case 't': + do_type = UUIDD_OP_TIME_UUID; + drop_privs = 1; + break; + case 'T': + timeout = strtol(optarg, &tmp, 0); + if ((timeout < 0) || *tmp) { + fprintf(stderr, _("Bad number: %s\n"), optarg); + exit(1); + } + break; + case 'r': + do_type = UUIDD_OP_RANDOM_UUID; + drop_privs = 1; + break; + default: + usage(argv[0]); + } + } + uid = getuid(); + if (uid && drop_privs) { + gid = getgid(); +#ifdef HAVE_SETRESGID + if (setresgid(gid, gid, gid) < 0) + die("setresgid"); +#else + if (setregid(gid, gid) < 0) + die("setregid"); +#endif + +#ifdef HAVE_SETRESUID + if (setresuid(uid, uid, uid) < 0) + die("setresuid"); +#else + if (setreuid(uid, uid) < 0) + die("setreuid"); +#endif + } + if (num && do_type) { + ret = call_daemon(socket_path, do_type+2, buf, + sizeof(buf), &num, &err_context); + if (ret < 0) { + printf(_("Error calling uuidd daemon (%s): %s\n"), + err_context, strerror(errno)); + exit(1); + } + if (do_type == UUIDD_OP_TIME_UUID) { + if (ret != sizeof(uu) + sizeof(num)) + goto unexpected_size; + + uuid_unparse((unsigned char *) buf, str); + + printf(_("%s and subsequent %d UUID's\n"), str, num); + } else { + printf(_("List of UUID's:\n")); + cp = buf + 4; + if (ret != (int) (sizeof(num) + num*sizeof(uu))) + goto unexpected_size; + for (i=0; i < num; i++, cp+=16) { + uuid_unparse((unsigned char *) cp, str); + printf("\t%s\n", str); + } + } + exit(0); + } + if (do_type) { + ret = call_daemon(socket_path, do_type, (char *) &uu, + sizeof(uu), 0, &err_context); + if (ret < 0) { + printf(_("Error calling uuidd daemon (%s): %s\n"), + err_context, strerror(errno)); + exit(1); + } + if (ret != sizeof(uu)) { + unexpected_size: + printf(_("Unexpected reply length from server %d\n"), + ret); + exit(1); + } + uuid_unparse(uu, str); + + printf("%s\n", str); + exit(0); + } + + if (do_kill) { + ret = call_daemon(socket_path, 0, buf, sizeof(buf), 0, 0); + if ((ret > 0) && ((do_kill = atoi((char *) buf)) > 0)) { + ret = kill(do_kill, SIGTERM); + if (ret < 0) { + if (!quiet) + fprintf(stderr, + _("Couldn't kill uuidd running " + "at pid %d: %s\n"), do_kill, + strerror(errno)); + exit(1); + } + if (!quiet) + printf(_("Killed uuidd running at pid %d\n"), + do_kill); + } + exit(0); + } + + server_loop(socket_path, pidfile_path, debug, timeout, quiet); + return 0; +} diff --git a/misc-utils/uuidd.rc b/misc-utils/uuidd.rc new file mode 100644 index 00000000..dbdd5f5c --- /dev/null +++ b/misc-utils/uuidd.rc @@ -0,0 +1,71 @@ +#! /bin/sh -e +### BEGIN INIT INFO +# Provides: uuidd +# Required-Start: $time $local_fs +# Required-Stop: $time $local_fs +# Default-Start: 2 3 4 5 +# Default-Stop: 0 1 6 +# Short-Description: uuidd daemon +# Description: Init script for the uuid generation daemon +### END INIT INFO +# +# Author: "Theodore Ts'o" <tytso@mit.edu> +# +set -e + +# libuuid is able to execute the uuid daemon on-demand -- in such a case +# the daemon binary must be setuid to an unprivileged user (e.g. uuidd:uuidd). +# [-- kzak Jun 2009] +UUIDD_ON_DEMAND_ONLY="no" + +PATH=/bin:/usr/bin:/sbin:/usr/sbin +DAEMON=/usr/sbin/uuidd +UUIDD_USER=uuidd +UUIDD_GROUP=uuidd +UUIDD_DIR=/var/run/uuidd +PIDFILE=$UUIDD_DIR/uuidd.pid + +test -x $DAEMON || exit 0 + +. /lib/lsb/init-functions + +case "$1" in + start) + log_daemon_msg "Starting uuid generator" "uuidd" + if ! test -d $UUIDD_DIR; then + mkdir -p $UUIDD_DIR + chown -R $UUIDD_USER:$UUIDD_GROUP $UUIDD_DIR + fi + if test "$UUIDD_ON_DEMAND_ONLY" = yes; then + echo -n "(on demand only)" + else + start_daemon -p $PIDFILE $DAEMON + fi + log_end_msg $? + ;; + stop) + log_daemon_msg "Stopping uuidd generator" "uuidd" + killproc -p $PIDFILE $DAEMON + log_end_msg $? + ;; + status) + if pidofproc -p $PIDFILE $DAEMON >& /dev/null ; then + echo "$DAEMON is running"; + exit 0; + else + echo "$DAEMON is NOT running"; + if test -f $PIDFILE; then exit 2; fi + exit 3; + fi + ;; + force-reload|restart) + $0 stop + $0 start + ;; + *) + echo "Usage: /etc/init.d/uuidd {start|stop|restart|force-reload}" + exit 1 + ;; +esac + +exit 0 diff --git a/misc-utils/uuidgen.1 b/misc-utils/uuidgen.1 new file mode 100644 index 00000000..13b13c42 --- /dev/null +++ b/misc-utils/uuidgen.1 @@ -0,0 +1,62 @@ +.\" Copyright 1999 Andreas Dilger (adilger@enel.ucalgary.ca) +.\" +.\" This man page was created for libuuid.so.1.1 from e2fsprogs-1.14. +.\" +.\" This file may be copied under the terms of the GNU Public License. +.\" +.\" Created Wed Mar 10 17:42:12 1999, Andreas Dilger +.TH UUIDGEN 1 "May 2009" "Linux" +.SH NAME +uuidgen \- command\-line utility to create a new UUID value +.SH SYNOPSIS +.B uuidgen +[ +.B \-r +| +.B \-t +] +.SH DESCRIPTION +The +.B uuidgen +program creates (and prints) +a new universally unique identifier (UUID) using the +.BR libuuid (3) +library. The new UUID can reasonably be considered unique among +all UUIDs created on the local system, +and among UUIDs created on other systems in the past +and in the future. +.PP +There are two types of UUID's which +.B uuidgen +can generate: time-based UUID's and random-based UUID's. By +default +.B uuidgen +will generate a random-based UUID if a high-quality random number +generator is present. Otherwise, it will chose a time-based UUID. It +is possible to force the generation of one of these two +UUID types by using the +.B \-r +or +.B \-t +options. +.SH OPTIONS +.TP +.B \-r +Generate a random-based UUID. This method creates a UUID consisting mostly +of random bits. It requires that the operating system have a high +quality random number generator, such as +.IR /dev/random . +.TP +.B \-t +Generate a time-based UUID. This method creates a UUID based on the system +clock plus the system's ethernet hardware address, if present. +.SH "CONFORMING TO" +OSF DCE 1.1 +.SH AUTHOR +.B uuidgen +was written by Andreas Dilger for libuuid. +.SH AVAILABILITY +The uuidgen command is part of the util-linux-ng package and is available from +ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/. +.SH "SEE ALSO" +.BR libuuid (3) diff --git a/misc-utils/uuidgen.c b/misc-utils/uuidgen.c new file mode 100644 index 00000000..3cf6ec91 --- /dev/null +++ b/misc-utils/uuidgen.c @@ -0,0 +1,77 @@ +/* + * gen_uuid.c --- generate a DCE-compatible uuid + * + * Copyright (C) 1999, Andreas Dilger and Theodore Ts'o + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% + */ + +#include <stdio.h> +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#else +extern int getopt(int argc, char * const argv[], const char *optstring); +extern char *optarg; +extern int optind; +#endif + +#include "uuid.h" +#include "nls.h" + +#define DO_TYPE_TIME 1 +#define DO_TYPE_RANDOM 2 + +static void usage(const char *progname) +{ + fprintf(stderr, _("Usage: %s [-r] [-t]\n"), progname); + exit(1); +} + +int +main (int argc, char *argv[]) +{ + int c; + int do_type = 0; + char str[37]; + uuid_t uu; + + setlocale(LC_ALL, ""); + bindtextdomain(PACKAGE, LOCALEDIR); + textdomain(PACKAGE); + + while ((c = getopt (argc, argv, "tr")) != EOF) + switch (c) { + case 't': + do_type = DO_TYPE_TIME; + break; + case 'r': + do_type = DO_TYPE_RANDOM; + break; + default: + usage(argv[0]); + } + + switch (do_type) { + case DO_TYPE_TIME: + uuid_generate_time(uu); + break; + case DO_TYPE_RANDOM: + uuid_generate_random(uu); + break; + default: + uuid_generate(uu); + break; + } + + uuid_unparse(uu, str); + + printf("%s\n", str); + + return 0; +} |