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>
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
21 static void __attribute__((__noreturn__)) usage(void)
22 {
23 FILE *out = stdout;
24 fputs(USAGE_HEADER, out);
25 fprintf(out,
26 _(" %s [options]\n"), program_invocation_short_name);
27
28 fputs(USAGE_SEPARATOR, out);
29 fputs(_("Create a new UUID value.\n"), out);
30
31 fputs(USAGE_OPTIONS, out);
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 printf(_(" available namespaces: %s\n"), "@dns @url @oid @x500");
36 fputs(_(" -N, --name name generate hash-based uuid from this name\n"), out);
37 fputs(_(" -m, --md5 generate md5 hash\n"), out);
38 fputs(_(" -s, --sha1 generate sha1 hash\n"), out);
39 fputs(_(" -x, --hex interpret name as hex string\n"), out);
40 fputs(USAGE_SEPARATOR, out);
41 printf(USAGE_HELP_OPTIONS(21));
42 printf(USAGE_MAN_TAIL("uuidgen(1)"));
43 exit(EXIT_SUCCESS);
44 }
45
46 static char *unhex(const char *value, size_t *valuelen)
47 {
48 char c, *value2;
49 unsigned n, x;
50
51 if (*valuelen % 2 != 0) {
52 badstring:
53 warnx(_("not a valid hex string"));
54 errtryhelp(EXIT_FAILURE);
55 }
56
57 value2 = malloc(*valuelen / 2 + 1);
58
59 for (x = n = 0; n < *valuelen; n++) {
60 c = value[n];
61 if ('0' <= c && c <= '9')
62 x += c - '0';
63 else if (('a' <= c && c <= 'f') || ('A' <= c && c <= 'F'))
64 x += (c - 'A' + 10) & 0xf;
65 else
66 goto badstring;
67
68 if (n % 2 == 0)
69 x *= 16;
70 else {
71 value2[n / 2] = x;
72 x = 0;
73 }
74 }
75 value2[n / 2] = '\0';
76
77 *valuelen = (n / 2);
78
79 return value2;
80 }
81
82 int
83 main (int argc, char *argv[])
84 {
85 int c;
86 int do_type = 0, is_hex = 0;
87 char str[UUID_STR_LEN];
88 char *namespace = NULL, *name = NULL;
89 size_t namelen = 0;
90 uuid_t ns, uu;
91
92 static const struct option longopts[] = {
93 {"random", no_argument, NULL, 'r'},
94 {"time", no_argument, NULL, 't'},
95 {"version", no_argument, NULL, 'V'},
96 {"help", no_argument, NULL, 'h'},
97 {"namespace", required_argument, NULL, 'n'},
98 {"name", required_argument, NULL, 'N'},
99 {"md5", no_argument, NULL, 'm'},
100 {"sha1", no_argument, NULL, 's'},
101 {"hex", no_argument, NULL, 'x'},
102 {NULL, 0, NULL, 0}
103 };
104
105 setlocale(LC_ALL, "");
106 bindtextdomain(PACKAGE, LOCALEDIR);
107 textdomain(PACKAGE);
108 close_stdout_atexit();
109
110 while ((c = getopt_long(argc, argv, "rtVhn:N:msx", longopts, NULL)) != -1)
111 switch (c) {
112 case 't':
113 do_type = UUID_TYPE_DCE_TIME;
114 break;
115 case 'r':
116 do_type = UUID_TYPE_DCE_RANDOM;
117 break;
118 case 'n':
119 namespace = optarg;
120 break;
121 case 'N':
122 name = optarg;
123 break;
124 case 'm':
125 do_type = UUID_TYPE_DCE_MD5;
126 break;
127 case 's':
128 do_type = UUID_TYPE_DCE_SHA1;
129 break;
130 case 'x':
131 is_hex = 1;
132 break;
133
134 case 'h':
135 usage();
136 case 'V':
137 print_version(EXIT_SUCCESS);
138 default:
139 errtryhelp(EXIT_FAILURE);
140 }
141
142 if (namespace) {
143 if (!name) {
144 warnx(_("--namespace requires --name argument"));
145 errtryhelp(EXIT_FAILURE);
146 }
147 if (do_type != UUID_TYPE_DCE_MD5 && do_type != UUID_TYPE_DCE_SHA1) {
148 warnx(_("--namespace requires --md5 or --sha1"));
149 errtryhelp(EXIT_FAILURE);
150 }
151 } else {
152 if (name) {
153 warnx(_("--name requires --namespace argument"));
154 errtryhelp(EXIT_FAILURE);
155 }
156 if (do_type == UUID_TYPE_DCE_MD5 || do_type == UUID_TYPE_DCE_SHA1) {
157 warnx(_("--md5 or --sha1 requires --namespace argument"));
158 errtryhelp(EXIT_FAILURE);
159 }
160 }
161
162 if (name) {
163 namelen = strlen(name);
164 if (is_hex)
165 name = unhex(name, &namelen);
166 }
167
168 switch (do_type) {
169 case UUID_TYPE_DCE_TIME:
170 uuid_generate_time(uu);
171 break;
172 case UUID_TYPE_DCE_RANDOM:
173 uuid_generate_random(uu);
174 break;
175 case UUID_TYPE_DCE_MD5:
176 case UUID_TYPE_DCE_SHA1:
177 if (namespace[0] == '@' && namespace[1] != '\0') {
178 const uuid_t *uuidptr;
179
180 uuidptr = uuid_get_template(&namespace[1]);
181 if (uuidptr == NULL) {
182 warnx(_("unknown namespace alias: '%s'"), namespace);
183 errtryhelp(EXIT_FAILURE);
184 }
185 memcpy(ns, *uuidptr, sizeof(ns));
186 } else {
187 if (uuid_parse(namespace, ns) != 0) {
188 warnx(_("invalid uuid for namespace: '%s'"), namespace);
189 errtryhelp(EXIT_FAILURE);
190 }
191 }
192 if (do_type == UUID_TYPE_DCE_MD5)
193 uuid_generate_md5(uu, ns, name, namelen);
194 else
195 uuid_generate_sha1(uu, ns, name, namelen);
196 break;
197 default:
198 uuid_generate(uu);
199 break;
200 }
201
202 uuid_unparse(uu, str);
203
204 printf("%s\n", str);
205
206 if (is_hex)
207 free(name);
208
209 return EXIT_SUCCESS;
210 }