[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 General 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"
#include "strutils.h"
#include "optutils.h"
#include "xalloc.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);
	fprintf(out, _("                        available namespaces: %s\n"), "@dns @url @oid @x500");
	fputs(_(" -N, --name <name>     generate hash-based uuid from this name\n"), out);
	fputs(_(" -m, --md5             generate md5 hash\n"), out);
	fputs(_(" -C, --count <num>     generate more uuids in loop\n"), out);
	fputs(_(" -s, --sha1            generate sha1 hash\n"), out);
	fputs(_(" -6, --time-v6         generate time-based v6 uuid\n"), out);
	fputs(_(" -7, --time-v7         generate time-based v7 uuid\n"), out);
	fputs(_(" -x, --hex             interpret name as hex string\n"), out);
	fputs(USAGE_SEPARATOR, out);
	fprintf(out, USAGE_HELP_OPTIONS(21));
	fprintf(out, 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:
		warnx(_("not a valid hex string"));
		errtryhelp(EXIT_FAILURE);
	}

	value2 = xmalloc(*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;
	unsigned int count = 1, i;

	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'},
		{"count", required_argument, NULL, 'C'},
		{"sha1", no_argument, NULL, 's'},
		{"time-v6", no_argument, NULL, '6'},
		{"time-v7", no_argument, NULL, '7'},
		{"hex", no_argument, NULL, 'x'},
		{NULL, 0, NULL, 0}
	};

	static const ul_excl_t excl[] = {
		{ '6', '7', 'm', 'r', 's', 't' },
		{ 'C', 'm', 's' },
		{ 'N', 'r', 't' },
		{ 'n', 'r', 't' },
		{ 0 }
	};
	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;

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

	while ((c = getopt_long(argc, argv, "C:rtVhn:N:msx67", longopts, NULL)) != -1) {

		err_exclusive_options(c, longopts, excl, excl_st);

		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 'C':
			count = strtou32_or_err(optarg, _("invalid count argument"));
			break;
		case 's':
			do_type = UUID_TYPE_DCE_SHA1;
			break;
		case 'x':
			is_hex = 1;
			break;
		case '6':
			do_type = UUID_TYPE_DCE_TIME_V6;
			break;
		case '7':
			do_type = UUID_TYPE_DCE_TIME_V7;
			break;

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

	if (namespace) {
		if (!name) {
			warnx(_("--namespace requires --name argument"));
			errtryhelp(EXIT_FAILURE);
		}
		if (do_type != UUID_TYPE_DCE_MD5 && do_type != UUID_TYPE_DCE_SHA1) {
			warnx(_("--namespace requires --md5 or --sha1"));
			errtryhelp(EXIT_FAILURE);
		}
	} else {
		if (name) {
			warnx(_("--name requires --namespace argument"));
			errtryhelp(EXIT_FAILURE);
		}
		if (do_type == UUID_TYPE_DCE_MD5 || do_type == UUID_TYPE_DCE_SHA1) {
			warnx(_("--md5 or --sha1 requires --namespace argument"));
			errtryhelp(EXIT_FAILURE);
		}
	}

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

	for (i = 0; i < count; i++) {
		switch (do_type) {
		case UUID_TYPE_DCE_TIME:
			uuid_generate_time(uu);
			break;
		case UUID_TYPE_DCE_TIME_V6:
			uuid_generate_time_v6(uu);
			break;
		case UUID_TYPE_DCE_TIME_V7:
			uuid_generate_time_v7(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) {
					warnx(_("unknown namespace alias: '%s'"), namespace);
					errtryhelp(EXIT_FAILURE);
				}
				memcpy(ns, *uuidptr, sizeof(ns));
			} else {
				if (uuid_parse(namespace, ns) != 0) {
					warnx(_("invalid uuid for namespace: '%s'"), 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
	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
	8	* GNU General Public License.
	9	* %End-Header%
	10	*/
	11
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <getopt.h>
	15
	16	#include "uuid.h"
	17	#include "nls.h"
	18	#include "c.h"
	19	#include "closestream.h"
	20	#include "strutils.h"
	21	#include "optutils.h"
	22	#include "xalloc.h"
	23
	24	static void __attribute__((__noreturn__)) usage(void)
	25	{
	26	FILE *out = stdout;
	27	fputs(USAGE_HEADER, out);
	28	fprintf(out,
	29	_(" %s [options]\n"), program_invocation_short_name);
	30
	31	fputs(USAGE_SEPARATOR, out);
	32	fputs(_("Create a new UUID value.\n"), out);
	33
	34	fputs(USAGE_OPTIONS, out);
	35	fputs(_(" -r, --random generate random-based uuid\n"), out);
	36	fputs(_(" -t, --time generate time-based uuid\n"), out);
	37	fputs(_(" -n, --namespace <ns> generate hash-based uuid in this namespace\n"), out);
	38	fprintf(out, _(" available namespaces: %s\n"), "@dns @url @oid @x500");
	39	fputs(_(" -N, --name <name> generate hash-based uuid from this name\n"), out);
	40	fputs(_(" -m, --md5 generate md5 hash\n"), out);
	41	fputs(_(" -C, --count <num> generate more uuids in loop\n"), out);
	42	fputs(_(" -s, --sha1 generate sha1 hash\n"), out);
	43	fputs(_(" -6, --time-v6 generate time-based v6 uuid\n"), out);
	44	fputs(_(" -7, --time-v7 generate time-based v7 uuid\n"), out);
	45	fputs(_(" -x, --hex interpret name as hex string\n"), out);
	46	fputs(USAGE_SEPARATOR, out);
	47	fprintf(out, USAGE_HELP_OPTIONS(21));
	48	fprintf(out, USAGE_MAN_TAIL("uuidgen(1)"));
	49	exit(EXIT_SUCCESS);
	50	}
	51
	52	static char unhex(const char value, size_t *valuelen)
	53	{
	54	char c, *value2;
	55	unsigned n, x;
	56
	57	if (*valuelen % 2 != 0) {
	58	badstring:
	59	warnx(_("not a valid hex string"));
	60	errtryhelp(EXIT_FAILURE);
	61	}
	62
	63	value2 = xmalloc(*valuelen / 2 + 1);
	64
	65	for (x = n = 0; n < *valuelen; n++) {
	66	c = value[n];
	67	if ('0' <= c && c <= '9')
	68	x += c - '0';
	69	else if (('a' <= c && c <= 'f') \|\| ('A' <= c && c <= 'F'))
	70	x += (c - 'A' + 10) & 0xf;
	71	else
	72	goto badstring;
	73
	74	if (n % 2 == 0)
	75	x *= 16;
	76	else {
	77	value2[n / 2] = x;
	78	x = 0;
	79	}
	80	}
	81	value2[n / 2] = '\0';
	82
	83	*valuelen = (n / 2);
	84
	85	return value2;
	86	}
	87
	88	int
	89	main (int argc, char *argv[])
	90	{
	91	int c;
	92	int do_type = 0, is_hex = 0;
	93	char str[UUID_STR_LEN];
	94	char namespace = NULL, name = NULL;
	95	size_t namelen = 0;
	96	uuid_t ns, uu;
	97	unsigned int count = 1, i;
	98
	99	static const struct option longopts[] = {
	100	{"random", no_argument, NULL, 'r'},
	101	{"time", no_argument, NULL, 't'},
	102	{"version", no_argument, NULL, 'V'},
	103	{"help", no_argument, NULL, 'h'},
	104	{"namespace", required_argument, NULL, 'n'},
	105	{"name", required_argument, NULL, 'N'},
	106	{"md5", no_argument, NULL, 'm'},
	107	{"count", required_argument, NULL, 'C'},
	108	{"sha1", no_argument, NULL, 's'},
	109	{"time-v6", no_argument, NULL, '6'},
	110	{"time-v7", no_argument, NULL, '7'},
	111	{"hex", no_argument, NULL, 'x'},
	112	{NULL, 0, NULL, 0}
	113	};
	114
	115	static const ul_excl_t excl[] = {
	116	{ '6', '7', 'm', 'r', 's', 't' },
	117	{ 'C', 'm', 's' },
	118	{ 'N', 'r', 't' },
	119	{ 'n', 'r', 't' },
	120	{ 0 }
	121	};
	122	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
	123
	124	setlocale(LC_ALL, "");
	125	bindtextdomain(PACKAGE, LOCALEDIR);
	126	textdomain(PACKAGE);
	127	close_stdout_atexit();
	128
	129	while ((c = getopt_long(argc, argv, "C:rtVhn:N:msx67", longopts, NULL)) != -1) {
	130
	131	err_exclusive_options(c, longopts, excl, excl_st);
	132
	133	switch (c) {
	134	case 't':
	135	do_type = UUID_TYPE_DCE_TIME;
	136	break;
	137	case 'r':
	138	do_type = UUID_TYPE_DCE_RANDOM;
	139	break;
	140	case 'n':
	141	namespace = optarg;
	142	break;
	143	case 'N':
	144	name = optarg;
	145	break;
	146	case 'm':
	147	do_type = UUID_TYPE_DCE_MD5;
	148	break;
	149	case 'C':
	150	count = strtou32_or_err(optarg, _("invalid count argument"));
	151	break;
	152	case 's':
	153	do_type = UUID_TYPE_DCE_SHA1;
	154	break;
	155	case 'x':
	156	is_hex = 1;
	157	break;
	158	case '6':
	159	do_type = UUID_TYPE_DCE_TIME_V6;
	160	break;
	161	case '7':
	162	do_type = UUID_TYPE_DCE_TIME_V7;
	163	break;
	164
	165	case 'h':
	166	usage();
	167	case 'V':
	168	print_version(EXIT_SUCCESS);
	169	default:
	170	errtryhelp(EXIT_FAILURE);
	171	}
	172	}
	173
	174	if (namespace) {
	175	if (!name) {
	176	warnx(_("--namespace requires --name argument"));
	177	errtryhelp(EXIT_FAILURE);
	178	}
	179	if (do_type != UUID_TYPE_DCE_MD5 && do_type != UUID_TYPE_DCE_SHA1) {
	180	warnx(_("--namespace requires --md5 or --sha1"));
	181	errtryhelp(EXIT_FAILURE);
	182	}
	183	} else {
	184	if (name) {
	185	warnx(_("--name requires --namespace argument"));
	186	errtryhelp(EXIT_FAILURE);
	187	}
	188	if (do_type == UUID_TYPE_DCE_MD5 \|\| do_type == UUID_TYPE_DCE_SHA1) {
	189	warnx(_("--md5 or --sha1 requires --namespace argument"));
	190	errtryhelp(EXIT_FAILURE);
	191	}
	192	}
	193
	194	if (name) {
	195	namelen = strlen(name);
	196	if (is_hex)
	197	name = unhex(name, &namelen);
	198	}
	199
	200	for (i = 0; i < count; i++) {
	201	switch (do_type) {
	202	case UUID_TYPE_DCE_TIME:
	203	uuid_generate_time(uu);
	204	break;
	205	case UUID_TYPE_DCE_TIME_V6:
	206	uuid_generate_time_v6(uu);
	207	break;
	208	case UUID_TYPE_DCE_TIME_V7:
	209	uuid_generate_time_v7(uu);
	210	break;
	211	case UUID_TYPE_DCE_RANDOM:
	212	uuid_generate_random(uu);
	213	break;
	214	case UUID_TYPE_DCE_MD5:
	215	case UUID_TYPE_DCE_SHA1:
	216	if (namespace[0] == '@' && namespace[1] != '\0') {
	217	const uuid_t *uuidptr;
	218
	219	uuidptr = uuid_get_template(&namespace[1]);
	220	if (uuidptr == NULL) {
	221	warnx(_("unknown namespace alias: '%s'"), namespace);
	222	errtryhelp(EXIT_FAILURE);
	223	}
	224	memcpy(ns, *uuidptr, sizeof(ns));
	225	} else {
	226	if (uuid_parse(namespace, ns) != 0) {
	227	warnx(_("invalid uuid for namespace: '%s'"), namespace);
	228	errtryhelp(EXIT_FAILURE);
	229	}
	230	}
	231	if (do_type == UUID_TYPE_DCE_MD5)
	232	uuid_generate_md5(uu, ns, name, namelen);
	233	else
	234	uuid_generate_sha1(uu, ns, name, namelen);
	235	break;
	236	default:
	237	uuid_generate(uu);
	238	break;
	239	}
	240
	241	uuid_unparse(uu, str);
	242
	243	printf("%s\n", str);
	244	}
	245
	246	if (is_hex)
	247	free(name);
	248
	249	return EXIT_SUCCESS;
	250	}