gpt_uuid.c revision 1.20 
1/*	$NetBSD: gpt_uuid.c,v 1.20 2023/09/26 15:48:30 kre Exp $	*/
2
3/*-
4 * Copyright (c) 2014 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#if HAVE_NBTOOL_CONFIG_H
30#include "nbtool_config.h"
31#endif
32
33#include <sys/cdefs.h>
34#ifdef __RCSID
35__RCSID("$NetBSD: gpt_uuid.c,v 1.20 2023/09/26 15:48:30 kre Exp $");
36#endif
37
38#include <err.h>
39#include <fcntl.h>
40#include <stdio.h>
41#include <unistd.h>
42
43#include "map.h"
44#include "gpt.h"
45#include "gpt_private.h"
46
47#if defined(HAVE_SYS_ENDIAN_H) || ! defined(HAVE_NBTOOL_CONFIG_H)
48#include <sys/endian.h>
49#endif
50
51
52const gpt_uuid_t gpt_uuid_nil;
53
54struct dce_uuid {
55	uint32_t	time_low;
56	uint16_t	time_mid;
57	uint16_t	time_hi_and_version;
58	uint8_t		clock_seq_hi_and_reserved;
59	uint8_t		clock_seq_low;
60	uint8_t		node[6];
61};
62
63static const struct {
64	struct dce_uuid u;
65	const char *n;
66	const char *d;
67} gpt_nv[] = {
68	{ GPT_ENT_TYPE_APPLE_HFS, "apple", "Apple HFS" },
69	{ GPT_ENT_TYPE_APPLE_UFS, "apple-ufs", "Apple UFS" },
70	{ GPT_ENT_TYPE_BIOS, "bios", "BIOS Boot" },
71	{ GPT_ENT_TYPE_EFI, "efi", "EFI System" },
72	{ GPT_ENT_TYPE_FREEBSD, "fbsd-legacy", "FreeBSD legacy" },
73	{ GPT_ENT_TYPE_FREEBSD_SWAP, "fbsd-swap", "FreeBSD swap" },
74	{ GPT_ENT_TYPE_FREEBSD_UFS, "fbsd-ufs", "FreeBSD UFS/UFS2" },
75	{ GPT_ENT_TYPE_FREEBSD_VINUM, "fbsd-vinum", "FreeBSD vinum" },
76	{ GPT_ENT_TYPE_FREEBSD_ZFS, "zfs", "ZFS" },
77	{ GPT_ENT_TYPE_LINUX_DATA, "linux-data", "Linux data" },
78	{ GPT_ENT_TYPE_LINUX_RAID, "linux-raid", "Linux RAID" },
79	{ GPT_ENT_TYPE_LINUX_SWAP, "linux-swap", "Linux swap" },
80	{ GPT_ENT_TYPE_LINUX_LVM, "linux-lvm", "Linux LVM" },
81	{ GPT_ENT_TYPE_MS_BASIC_DATA, "windows", "Windows basic data" },
82	{ GPT_ENT_TYPE_MS_RESERVED, "windows-reserved", "Windows reserved" },
83	{ GPT_ENT_TYPE_MS_RECOVERY, "windows-recovery", "Windows recovery" },
84	{ GPT_ENT_TYPE_NETBSD_CCD, "ccd", "NetBSD ccd component" },
85	{ GPT_ENT_TYPE_NETBSD_CGD, "cgd", "NetBSD Cryptographic Disk" },
86	{ GPT_ENT_TYPE_NETBSD_FFS, "ffs", "NetBSD FFSv1/FFSv2" },
87	{ GPT_ENT_TYPE_NETBSD_LFS, "lfs", "NetBSD LFS" },
88	{ GPT_ENT_TYPE_NETBSD_RAIDFRAME, "raid",
89	    "NetBSD RAIDFrame component" },
90	{ GPT_ENT_TYPE_NETBSD_SWAP, "swap", "NetBSD swap" },
91	{ GPT_ENT_TYPE_VMWARE_VMKCORE, "vmcore", "VMware VMkernel core dump" },
92	{ GPT_ENT_TYPE_VMWARE_VMFS, "vmfs", "VMware VMFS" },
93	{ GPT_ENT_TYPE_VMWARE_RESERVED, "vmresered", "VMware reserved" },
94};
95
96static void
97gpt_uuid_to_dce(const gpt_uuid_t buf, struct dce_uuid *uuid)
98{
99	const uint8_t *p = buf;
100	size_t i;
101
102	uuid->time_low = le32dec(p);
103	uuid->time_mid = le16dec(p + 4);
104	uuid->time_hi_and_version = le16dec(p + 6);
105	uuid->clock_seq_hi_and_reserved = p[8];
106	uuid->clock_seq_low = p[9];
107	for (i = 0; i < sizeof(uuid->node); i++)
108		uuid->node[i] = p[10 + i];
109}
110
111static void
112gpt_dce_to_uuid(const struct dce_uuid *uuid, uint8_t *buf)
113{
114	uint8_t *p = buf;
115	size_t i;
116
117	le32enc(p, uuid->time_low);
118	le16enc(p + 4, uuid->time_mid);
119	le16enc(p + 6, uuid->time_hi_and_version);
120	p[8] = uuid->clock_seq_hi_and_reserved;
121	p[9] = uuid->clock_seq_low;
122	for (i = 0; i < sizeof(uuid->node); i++)
123		p[10 + i] = uuid->node[i];
124}
125
126static int
127gpt_uuid_numeric(char *buf, size_t bufsiz, const struct dce_uuid *u)
128{
129	return snprintf(buf, bufsiz,
130	    "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
131	    u->time_low, u->time_mid, u->time_hi_and_version,
132	    u->clock_seq_hi_and_reserved, u->clock_seq_low, u->node[0],
133	    u->node[1], u->node[2], u->node[3], u->node[4], u->node[5]);
134}
135
136
137static int
138gpt_uuid_symbolic(char *buf, size_t bufsiz, const struct dce_uuid *u)
139{
140	size_t i;
141
142	for (i = 0; i < __arraycount(gpt_nv); i++)
143		if (memcmp(&gpt_nv[i].u, u, sizeof(*u)) == 0)
144			return (int)strlcpy(buf, gpt_nv[i].n, bufsiz);
145	return -1;
146}
147
148static int
149gpt_uuid_descriptive(char *buf, size_t bufsiz, const struct dce_uuid *u)
150{
151	size_t i;
152
153	for (i = 0; i < __arraycount(gpt_nv); i++)
154		if (memcmp(&gpt_nv[i].u, u, sizeof(*u)) == 0)
155			return (int)strlcpy(buf, gpt_nv[i].d, bufsiz);
156	return -1;
157}
158
159int
160gpt_uuid_snprintf(char *buf, size_t bufsiz, const char *fmt,
161    const gpt_uuid_t uu)
162{
163	struct dce_uuid u;
164	gpt_uuid_to_dce(uu, &u);
165
166	if (fmt[1] == 's') {
167		int r;
168		if ((r = gpt_uuid_symbolic(buf, bufsiz, &u)) != -1)
169			return r;
170	}
171	if (fmt[1] == 'l') {
172		int r;
173		if ((r = gpt_uuid_descriptive(buf, bufsiz, &u)) != -1)
174			return r;
175	}
176	return gpt_uuid_numeric(buf, bufsiz, &u);
177}
178
179static int
180gpt_uuid_parse_numeric(const char *s, struct dce_uuid *u)
181{
182	int n;
183
184	if (s == NULL || *s == '\0') {
185		memset(u, 0, sizeof(*u));
186		return 0;
187	}
188
189	n = sscanf(s,
190	    "%8x-%4hx-%4hx-%2hhx%2hhx-%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx",
191	    &u->time_low, &u->time_mid, &u->time_hi_and_version,
192	    &u->clock_seq_hi_and_reserved, &u->clock_seq_low, &u->node[0],
193	    &u->node[1], &u->node[2], &u->node[3], &u->node[4], &u->node[5]);
194
195	/* Make sure we have all conversions. */
196	if (n != 11)
197		return -1;
198
199	/* We have a successful scan. Check semantics... */
200	n = u->clock_seq_hi_and_reserved;
201	if ((n & 0x80) != 0x00 &&			/* variant 0? */
202	    (n & 0xc0) != 0x80 &&			/* variant 1? */
203	    (n & 0xe0) != 0xc0) 			/* variant 2? */
204		return -1;
205	return 0;
206}
207
208static int
209gpt_uuid_parse_symbolic(const char *s, struct dce_uuid *u)
210{
211	size_t i;
212
213	for (i = 0; i < __arraycount(gpt_nv); i++)
214		if (strcmp(gpt_nv[i].n, s) == 0) {
215			*u = gpt_nv[i].u;
216			return 0;
217		}
218	return -1;
219}
220
221int
222gpt_uuid_parse(const char *s, gpt_uuid_t uuid)
223{
224	struct dce_uuid u;
225
226	if (gpt_uuid_parse_numeric(s, &u) != -1) {
227		gpt_dce_to_uuid(&u, uuid);
228		return 0;
229	}
230
231	if (gpt_uuid_parse_symbolic(s, &u) == -1)
232		return -1;
233
234	gpt_dce_to_uuid(&u, uuid);
235	return 0;
236}
237
238size_t
239gpt_uuid_query(
240    void (*func)(const char *uuid, const char *short_name, const char *desc))
241{
242	size_t i;
243	char buf[64];
244
245	if (func != NULL) {
246		for (i = 0; i < __arraycount(gpt_nv); i++) {
247			gpt_uuid_numeric(buf, sizeof(buf), &gpt_nv[i].u);
248			(*func)(buf, gpt_nv[i].n, gpt_nv[i].d);
249		}
250	}
251	return __arraycount(gpt_nv);
252}
253
254#ifndef GPT_UUID_QUERY_ONLY
255void
256gpt_uuid_help(const char *prefix)
257{
258	size_t i;
259
260	for (i = 0; i < __arraycount(gpt_nv); i++)
261		printf("%s%18.18s\t%s\n", prefix, gpt_nv[i].n, gpt_nv[i].d);
262}
263
264void
265gpt_uuid_create(gpt_type_t t, gpt_uuid_t u, uint16_t *b, size_t s)
266{
267	gpt_dce_to_uuid(&gpt_nv[t].u, u);
268	if (b)
269		utf8_to_utf16((const uint8_t *)gpt_nv[t].d, b, s / sizeof(*b));
270}
271
272static int
273gpt_uuid_random(gpt_t gpt, void *v, size_t n)
274{
275	int fd;
276	uint8_t *p;
277	ssize_t nread;
278
279	/* Randomly generate the content.  */
280	fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC);
281	if (fd == -1) {
282		gpt_warn(gpt, "Can't open `/dev/urandom'");
283		return -1;
284	}
285	for (p = v;  n > 0; p += nread, n -= (size_t)nread) {
286		nread = read(fd, p, n);
287		if (nread < 0) {
288			gpt_warn(gpt, "Can't read `/dev/urandom'");
289			goto out;
290		}
291		if (nread == 0) {
292			gpt_warn(gpt, "EOF from /dev/urandom");
293			goto out;
294		}
295		if ((size_t)nread > n) {
296			gpt_warnx(gpt, "read too much: %zd > %zu", nread, n);
297			goto out;
298		}
299	}
300	(void)close(fd);
301	return 0;
302out:
303	(void)close(fd);
304	return -1;
305}
306
307static int
308gpt_uuid_tstamp(gpt_t gpt, void *v, size_t l)
309{
310	uint8_t *p;
311	// Perhaps use SHA?
312	uint32_t x = (uint32_t)gpt->timestamp;
313
314	for (p = v; l > 0; p += sizeof(x), l -= sizeof(x))
315		memcpy(p, &x, sizeof(x));
316
317	return 0;
318}
319
320int
321gpt_uuid_generate(gpt_t gpt, gpt_uuid_t t)
322{
323	int rv;
324	struct dce_uuid u;
325	if (gpt && (gpt->flags & GPT_TIMESTAMP))
326		rv = gpt_uuid_tstamp(gpt, &u, sizeof(u));
327	else
328		rv = gpt_uuid_random(gpt, &u, sizeof(u));
329
330	if (rv == -1)
331		return -1;
332
333	/* Set the version number to 4.  */
334	u.time_hi_and_version &= (uint16_t)~0xf000;
335	u.time_hi_and_version |= 0x4000;
336
337	/* Fix the reserved bits.  */
338	u.clock_seq_hi_and_reserved &= (uint8_t)~0x40;
339	u.clock_seq_hi_and_reserved |= 0x80;
340
341	gpt_dce_to_uuid(&u, t);
342	return 0;
343}
344#endif
345