[thirdparty/util-linux.git] / misc-utils / uuidgen.c

/*
 * 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>
#include <stdlib.h>
#include <getopt.h>

#include "uuid.h"
#include "nls.h"
#include "c.h"
#include "closestream.h"

static void __attribute__((__noreturn__)) usage(void)
{
	FILE *out = stdout;
	fputs(USAGE_HEADER, out);
	fprintf(out,
	      _(" %s [options]\n"), program_invocation_short_name);

	fputs(USAGE_SEPARATOR, out);
	fputs(_("Create a new UUID value.\n"), out);

	fputs(USAGE_OPTIONS, out);
	fputs(_(" -r, --random        generate random-based uuid\n"), out);
	fputs(_(" -t, --time          generate time-based uuid\n"), out);
	fputs(_(" -n, --namespace ns  generate hash-based uuid in this namespace\n"), out);
	fputs(_(" -N, --name name     generate hash-based uuid from this name\n"), out);
	fputs(_(" -m, --md5           generate md5 hash\n"), out);
	fputs(_(" -s, --sha1          generate sha1 hash\n"), out);
	fputs(_(" -x, --hex           interpret name as hex string\n"), out);
	fputs(USAGE_SEPARATOR, out);
	printf(USAGE_HELP_OPTIONS(18));
	printf(USAGE_MAN_TAIL("uuidgen(1)"));
	exit(EXIT_SUCCESS);
}

static char *unhex(const char *value, size_t *valuelen)
{
	char c, *value2;
	unsigned n, x;

	if (*valuelen % 2 != 0) {
badstring:
		fprintf(stderr, "%s: not a valid hex string\n", program_invocation_short_name);
		errtryhelp(EXIT_FAILURE);
	}

	value2 = malloc(*valuelen / 2 + 1);

	for (x = n = 0; n < *valuelen; n++) {
		c = value[n];
		if ('0' <= c && c <= '9')
			x += c - '0';
		else if (('a' <= c && c <= 'f') || ('A' <= c && c <= 'F'))
			x += (c - 'A' + 10) & 0xf;
		else
			goto badstring;

		if (n % 2 == 0)
			x *= 16;
		else {
			value2[n / 2] = x;
			x = 0;
		}
	}
	value2[n / 2] = '\0';

	*valuelen = (n / 2);

	return value2;
}

int
main (int argc, char *argv[])
{
	int    c;
	int    do_type = 0, is_hex = 0;
	char   str[UUID_STR_LEN];
	char   *namespace = NULL, *name = NULL;
	size_t namelen = 0;
	uuid_t ns, uu;

	static const struct option longopts[] = {
		{"random", no_argument, NULL, 'r'},
		{"time", no_argument, NULL, 't'},
		{"version", no_argument, NULL, 'V'},
		{"help", no_argument, NULL, 'h'},
		{"namespace", required_argument, NULL, 'n'},
		{"name", required_argument, NULL, 'N'},
		{"md5", no_argument, NULL, 'm'},
		{"sha1", no_argument, NULL, 's'},
		{"hex", no_argument, NULL, 'x'},
		{NULL, 0, NULL, 0}
	};

	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	close_stdout_atexit();

	while ((c = getopt_long(argc, argv, "rtVhn:N:msx", longopts, NULL)) != -1)
		switch (c) {
		case 't':
			do_type = UUID_TYPE_DCE_TIME;
			break;
		case 'r':
			do_type = UUID_TYPE_DCE_RANDOM;
			break;
		case 'n':
			namespace = optarg;
			break;
		case 'N':
			name = optarg;
			break;
		case 'm':
			do_type = UUID_TYPE_DCE_MD5;
			break;
		case 's':
			do_type = UUID_TYPE_DCE_SHA1;
			break;
		case 'x':
			is_hex = 1;
			break;

		case 'h':
			usage();
		case 'V':
			print_version(EXIT_SUCCESS);
		default:
			errtryhelp(EXIT_FAILURE);
		}

	if (namespace) {
		if (!name) {
			fprintf(stderr, "%s: --namespace requires --name argument\n", program_invocation_short_name);
			errtryhelp(EXIT_FAILURE);
		}
		if (do_type != UUID_TYPE_DCE_MD5 && do_type != UUID_TYPE_DCE_SHA1) {
			fprintf(stderr, "%s: --namespace requires --md5 or --sha1\n", program_invocation_short_name);
			errtryhelp(EXIT_FAILURE);
		}
	} else {
		if (name) {
			fprintf(stderr, "%s: --name requires --namespace argument\n", program_invocation_short_name);
			errtryhelp(EXIT_FAILURE);
		}
		if (do_type == UUID_TYPE_DCE_MD5 || do_type == UUID_TYPE_DCE_SHA1) {
			fprintf(stderr, "%s: --md5 or --sha1 require --namespace\n", program_invocation_short_name);
			errtryhelp(EXIT_FAILURE);
		}
	}

	if (name) {
		namelen = strlen(name);
		if (is_hex)
			name = unhex(name, &namelen);
	}

	switch (do_type) {
	case UUID_TYPE_DCE_TIME:
		uuid_generate_time(uu);
		break;
	case UUID_TYPE_DCE_RANDOM:
		uuid_generate_random(uu);
		break;
	case UUID_TYPE_DCE_MD5:
	case UUID_TYPE_DCE_SHA1:
		if (namespace[0] == '@' && namespace[1] != '\0') {
			const uuid_t *uuidptr;

			uuidptr = uuid_get_template(&namespace[1]);
			if (uuidptr == NULL) {
				fprintf(stderr, "%s: unknown namespace alias '%s'\n", program_invocation_short_name, namespace);
				errtryhelp(EXIT_FAILURE);
			}
			memcpy(ns, *uuidptr, sizeof(ns));
		} else {
			if (uuid_parse(namespace, ns) != 0) {
				fprintf(stderr, "%s: invalid uuid for namespace '%s'\n", program_invocation_short_name, namespace);
				errtryhelp(EXIT_FAILURE);
			}
		}
		if (do_type == UUID_TYPE_DCE_MD5)
			uuid_generate_md5(uu, ns, name, namelen);
		else
			uuid_generate_sha1(uu, ns, name, namelen);
		break;
	default:
		uuid_generate(uu);
		break;
	}

	uuid_unparse(uu, str);

	printf("%s\n", str);

	if (is_hex)
		free(name);

	return EXIT_SUCCESS;
}
Commit	Line	Data
0140c397 KZ	1	/*
	2	* gen_uuid.c --- generate a DCE-compatible uuid
	3	*
	4	* Copyright (C) 1999, Andreas Dilger and Theodore Ts'o
	5	*
	6	* %Begin-Header%
	7	* This file may be redistributed under the terms of the GNU Public
	8	* License.
	9	* %End-Header%
	10	*/
	11
	12	#include <stdio.h>
0140c397	13	#include <stdlib.h>
0140c397	14	#include <getopt.h>
0140c397 KZ	15
	16	#include "uuid.h"
	17	#include "nls.h"
0379a55d	18	#include "c.h"
c05a80ca	19	#include "closestream.h"
0140c397	20
86be6a32	21	static void __attribute__((__noreturn__)) usage(void)
0140c397	22	{
86be6a32	23	FILE *out = stdout;
db433bf7	24	fputs(USAGE_HEADER, out);
44697763 KZ	25	fprintf(out,
44697763 KZ	26	_(" %s [options]\n"), program_invocation_short_name);
0379a55d	27
451dbcfa BS	28	fputs(USAGE_SEPARATOR, out);
	29	fputs(_("Create a new UUID value.\n"), out);
	30
db433bf7	31	fputs(USAGE_OPTIONS, out);
c6f1ec68 PP	32	fputs(_(" -r, --random generate random-based uuid\n"), out);
	33	fputs(_(" -t, --time generate time-based uuid\n"), out);
	34	fputs(_(" -n, --namespace ns generate hash-based uuid in this namespace\n"), out);
	35	fputs(_(" -N, --name name generate hash-based uuid from this name\n"), out);
	36	fputs(_(" -m, --md5 generate md5 hash\n"), out);
	37	fputs(_(" -s, --sha1 generate sha1 hash\n"), out);
	38	fputs(_(" -x, --hex interpret name as hex string\n"), out);
504c03ec	39	fputs(USAGE_SEPARATOR, out);
f45f3ec3 RM	40	printf(USAGE_HELP_OPTIONS(18));
f45f3ec3 RM	41	printf(USAGE_MAN_TAIL("uuidgen(1)"));
86be6a32	42	exit(EXIT_SUCCESS);
0140c397 KZ	43	}
0140c397 KZ	44
c6f1ec68 PP	45	static char unhex(const char value, size_t *valuelen)
	46	{
	47	char c, *value2;
	48	unsigned n, x;
	49
	50	if (*valuelen % 2 != 0) {
	51	badstring:
	52	fprintf(stderr, "%s: not a valid hex string\n", program_invocation_short_name);
	53	errtryhelp(EXIT_FAILURE);
	54	}
	55
	56	value2 = malloc(*valuelen / 2 + 1);
	57
	58	for (x = n = 0; n < *valuelen; n++) {
	59	c = value[n];
	60	if ('0' <= c && c <= '9')
	61	x += c - '0';
	62	else if (('a' <= c && c <= 'f') \|\| ('A' <= c && c <= 'F'))
	63	x += (c - 'A' + 10) & 0xf;
	64	else
	65	goto badstring;
	66
	67	if (n % 2 == 0)
	68	x *= 16;
	69	else {
	70	value2[n / 2] = x;
	71	x = 0;
	72	}
	73	}
	74	value2[n / 2] = '\0';
	75
	76	*valuelen = (n / 2);
	77
	78	return value2;
	79	}
	80
0140c397 KZ	81	int
	82	main (int argc, char *argv[])
	83	{
	84	int c;
c6f1ec68	85	int do_type = 0, is_hex = 0;
b443c177	86	char str[UUID_STR_LEN];
c6f1ec68 PP	87	char namespace = NULL, name = NULL;
	88	size_t namelen = 0;
	89	uuid_t ns, uu;
0140c397	90
0379a55d	91	static const struct option longopts[] = {
71383195	92	{"random", no_argument, NULL, 'r'},
0379a55d SK	93	{"time", no_argument, NULL, 't'},
	94	{"version", no_argument, NULL, 'V'},
	95	{"help", no_argument, NULL, 'h'},
c6f1ec68 PP	96	{"namespace", required_argument, NULL, 'n'},
	97	{"name", required_argument, NULL, 'N'},
	98	{"md5", no_argument, NULL, 'm'},
	99	{"sha1", no_argument, NULL, 's'},
	100	{"hex", no_argument, NULL, 'x'},
0379a55d SK	101	{NULL, 0, NULL, 0}
	102	};
	103
0140c397 KZ	104	setlocale(LC_ALL, "");
	105	bindtextdomain(PACKAGE, LOCALEDIR);
	106	textdomain(PACKAGE);
2c308875	107	close_stdout_atexit();
0140c397	108
c6f1ec68	109	while ((c = getopt_long(argc, argv, "rtVhn:N:msx", longopts, NULL)) != -1)
0140c397 KZ	110	switch (c) {
0140c397 KZ	111	case 't':
6328799d	112	do_type = UUID_TYPE_DCE_TIME;
0140c397 KZ	113	break;
0140c397 KZ	114	case 'r':
6328799d	115	do_type = UUID_TYPE_DCE_RANDOM;
0140c397	116	break;
c6f1ec68 PP	117	case 'n':
	118	namespace = optarg;
	119	break;
	120	case 'N':
	121	name = optarg;
	122	break;
	123	case 'm':
	124	do_type = UUID_TYPE_DCE_MD5;
	125	break;
	126	case 's':
	127	do_type = UUID_TYPE_DCE_SHA1;
	128	break;
	129	case 'x':
	130	is_hex = 1;
	131	break;
2c308875	132
0379a55d	133	case 'h':
86be6a32	134	usage();
2c308875 KZ	135	case 'V':
2c308875 KZ	136	print_version(EXIT_SUCCESS);
0140c397	137	default:
677ec86c	138	errtryhelp(EXIT_FAILURE);
0140c397 KZ	139	}
0140c397 KZ	140
c6f1ec68 PP	141	if (namespace) {
	142	if (!name) {
	143	fprintf(stderr, "%s: --namespace requires --name argument\n", program_invocation_short_name);
	144	errtryhelp(EXIT_FAILURE);
	145	}
	146	if (do_type != UUID_TYPE_DCE_MD5 && do_type != UUID_TYPE_DCE_SHA1) {
	147	fprintf(stderr, "%s: --namespace requires --md5 or --sha1\n", program_invocation_short_name);
	148	errtryhelp(EXIT_FAILURE);
	149	}
	150	} else {
	151	if (name) {
	152	fprintf(stderr, "%s: --name requires --namespace argument\n", program_invocation_short_name);
	153	errtryhelp(EXIT_FAILURE);
	154	}
	155	if (do_type == UUID_TYPE_DCE_MD5 \|\| do_type == UUID_TYPE_DCE_SHA1) {
	156	fprintf(stderr, "%s: --md5 or --sha1 require --namespace\n", program_invocation_short_name);
	157	errtryhelp(EXIT_FAILURE);
	158	}
	159	}
	160
	161	if (name) {
	162	namelen = strlen(name);
	163	if (is_hex)
	164	name = unhex(name, &namelen);
	165	}
	166
0140c397	167	switch (do_type) {
6328799d	168	case UUID_TYPE_DCE_TIME:
0140c397 KZ	169	uuid_generate_time(uu);
0140c397 KZ	170	break;
6328799d	171	case UUID_TYPE_DCE_RANDOM:
0140c397 KZ	172	uuid_generate_random(uu);
0140c397 KZ	173	break;
c6f1ec68 PP	174	case UUID_TYPE_DCE_MD5:
	175	case UUID_TYPE_DCE_SHA1:
	176	if (namespace[0] == '@' && namespace[1] != '\0') {
	177	const uuid_t *uuidptr;
	178
	179	uuidptr = uuid_get_template(&namespace[1]);
	180	if (uuidptr == NULL) {
	181	fprintf(stderr, "%s: unknown namespace alias '%s'\n", program_invocation_short_name, namespace);
	182	errtryhelp(EXIT_FAILURE);
	183	}
	184	memcpy(ns, *uuidptr, sizeof(ns));
	185	} else {
	186	if (uuid_parse(namespace, ns) != 0) {
	187	fprintf(stderr, "%s: invalid uuid for namespace '%s'\n", program_invocation_short_name, namespace);
	188	errtryhelp(EXIT_FAILURE);
	189	}
	190	}
	191	if (do_type == UUID_TYPE_DCE_MD5)
	192	uuid_generate_md5(uu, ns, name, namelen);
	193	else
	194	uuid_generate_sha1(uu, ns, name, namelen);
	195	break;
0140c397 KZ	196	default:
	197	uuid_generate(uu);
	198	break;
	199	}
	200
	201	uuid_unparse(uu, str);
	202
	203	printf("%s\n", str);
	204
c6f1ec68 PP	205	if (is_hex)
	206	free(name);
	207
0379a55d	208	return EXIT_SUCCESS;
0140c397	209	}