Merge commit 'origin/master'

Conflicts:
	AUTHORS
	NEWS
	config/include-Makefile.am
	configure.ac
	mount/lomount.c
	po/POTFILES.in
	po/ca.po
	po/cs.po
	po/da.po
	po/de.po
	po/es.po
	po/et.po
	po/eu.po
	po/fi.po
	po/fr.po
	po/hu.po
	po/id.po
	po/it.po
	po/ja.po
	po/nl.po
	po/pl.po
	po/pt_BR.po
	po/ru.po
	po/sl.po
	po/sv.po
	po/tr.po
	po/uk.po
	po/util-linux-ng.pot
	po/vi.po
	po/zh_CN.po

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;
+}