gpt_uuid.c revision 1.22 1 /* $NetBSD: gpt_uuid.c,v 1.22 2024/08/19 17:15:38 christos 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.22 2024/08/19 17:15:38 christos 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
52 const gpt_uuid_t gpt_uuid_nil;
53
54 struct 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
63 static const struct {
64 struct dce_uuid u;
65 const char *n;
66 const char *d;
67 } gpt_nv[] = {
68 /* Must match the gpt_type_t enum in gpt_uuid.h */
69 { GPT_ENT_TYPE_APPLE_HFS, "apple", "Apple HFS" },
70 { GPT_ENT_TYPE_APPLE_UFS, "apple-ufs", "Apple UFS" },
71 { GPT_ENT_TYPE_BIOS, "bios", "BIOS Boot" },
72 { GPT_ENT_TYPE_EFI, "efi", "EFI System" },
73 { GPT_ENT_TYPE_FREEBSD, "fbsd-legacy", "FreeBSD legacy" },
74 { GPT_ENT_TYPE_FREEBSD_SWAP, "fbsd-swap", "FreeBSD swap" },
75 { GPT_ENT_TYPE_FREEBSD_UFS, "fbsd-ufs", "FreeBSD UFS/UFS2" },
76 { GPT_ENT_TYPE_FREEBSD_VINUM, "fbsd-vinum", "FreeBSD vinum" },
77 { GPT_ENT_TYPE_FREEBSD_ZFS, "zfs", "ZFS" },
78 { GPT_ENT_TYPE_LINUX_DATA, "linux-data", "Linux data" },
79 { GPT_ENT_TYPE_LINUX_RAID, "linux-raid", "Linux RAID" },
80 { GPT_ENT_TYPE_LINUX_SWAP, "linux-swap", "Linux swap" },
81 { GPT_ENT_TYPE_LINUX_LVM, "linux-lvm", "Linux LVM" },
82 { GPT_ENT_TYPE_MS_BASIC_DATA, "windows", "Windows basic data" },
83 { GPT_ENT_TYPE_MS_RESERVED, "windows-reserved", "Windows reserved" },
84 { GPT_ENT_TYPE_MS_RECOVERY, "windows-recovery", "Windows recovery" },
85 { GPT_ENT_TYPE_NETBSD_CCD, "ccd", "NetBSD ccd component" },
86 { GPT_ENT_TYPE_NETBSD_CGD, "cgd", "NetBSD Cryptographic Disk" },
87 { GPT_ENT_TYPE_NETBSD_FFS, "ffs", "NetBSD FFSv1/FFSv2" },
88 { GPT_ENT_TYPE_NETBSD_LFS, "lfs", "NetBSD LFS" },
89 { GPT_ENT_TYPE_NETBSD_RAIDFRAME, "raid",
90 "NetBSD RAIDFrame component" },
91 { GPT_ENT_TYPE_NETBSD_SWAP, "swap", "NetBSD swap" },
92 { GPT_ENT_TYPE_OPENBSD_DATA, "obsd", "OpenBSD data" },
93 { GPT_ENT_TYPE_VMWARE_VMKCORE, "vmcore", "VMware VMkernel core dump" },
94 { GPT_ENT_TYPE_VMWARE_VMFS, "vmfs", "VMware VMFS" },
95 { GPT_ENT_TYPE_VMWARE_RESERVED, "vmresered", "VMware reserved" },
96 };
97
98 static void
99 gpt_uuid_to_dce(const gpt_uuid_t buf, struct dce_uuid *uuid)
100 {
101 const uint8_t *p = buf;
102 size_t i;
103
104 uuid->time_low = le32dec(p);
105 uuid->time_mid = le16dec(p + 4);
106 uuid->time_hi_and_version = le16dec(p + 6);
107 uuid->clock_seq_hi_and_reserved = p[8];
108 uuid->clock_seq_low = p[9];
109 for (i = 0; i < sizeof(uuid->node); i++)
110 uuid->node[i] = p[10 + i];
111 }
112
113 static void
114 gpt_dce_to_uuid(const struct dce_uuid *uuid, uint8_t *buf)
115 {
116 uint8_t *p = buf;
117 size_t i;
118
119 le32enc(p, uuid->time_low);
120 le16enc(p + 4, uuid->time_mid);
121 le16enc(p + 6, uuid->time_hi_and_version);
122 p[8] = uuid->clock_seq_hi_and_reserved;
123 p[9] = uuid->clock_seq_low;
124 for (i = 0; i < sizeof(uuid->node); i++)
125 p[10 + i] = uuid->node[i];
126 }
127
128 static int
129 gpt_uuid_numeric(char *buf, size_t bufsiz, const struct dce_uuid *u)
130 {
131 return snprintf(buf, bufsiz,
132 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
133 u->time_low, u->time_mid, u->time_hi_and_version,
134 u->clock_seq_hi_and_reserved, u->clock_seq_low, u->node[0],
135 u->node[1], u->node[2], u->node[3], u->node[4], u->node[5]);
136 }
137
138
139 static int
140 gpt_uuid_symbolic(char *buf, size_t bufsiz, const struct dce_uuid *u)
141 {
142 size_t i;
143
144 for (i = 0; i < __arraycount(gpt_nv); i++)
145 if (memcmp(&gpt_nv[i].u, u, sizeof(*u)) == 0)
146 return (int)strlcpy(buf, gpt_nv[i].n, bufsiz);
147 return -1;
148 }
149
150 static int
151 gpt_uuid_descriptive(char *buf, size_t bufsiz, const struct dce_uuid *u)
152 {
153 size_t i;
154
155 for (i = 0; i < __arraycount(gpt_nv); i++)
156 if (memcmp(&gpt_nv[i].u, u, sizeof(*u)) == 0)
157 return (int)strlcpy(buf, gpt_nv[i].d, bufsiz);
158 return -1;
159 }
160
161 int
162 gpt_uuid_snprintf(char *buf, size_t bufsiz, const char *fmt,
163 const gpt_uuid_t uu)
164 {
165 struct dce_uuid u;
166 gpt_uuid_to_dce(uu, &u);
167
168 if (fmt[1] == 's') {
169 int r;
170 if ((r = gpt_uuid_symbolic(buf, bufsiz, &u)) != -1)
171 return r;
172 }
173 if (fmt[1] == 'l') {
174 int r;
175 if ((r = gpt_uuid_descriptive(buf, bufsiz, &u)) != -1)
176 return r;
177 }
178 return gpt_uuid_numeric(buf, bufsiz, &u);
179 }
180
181 static int
182 gpt_uuid_parse_numeric(const char *s, struct dce_uuid *u)
183 {
184 int n;
185
186 if (s == NULL || *s == '\0') {
187 memset(u, 0, sizeof(*u));
188 return 0;
189 }
190
191 n = sscanf(s,
192 "%8x-%4hx-%4hx-%2hhx%2hhx-%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx",
193 &u->time_low, &u->time_mid, &u->time_hi_and_version,
194 &u->clock_seq_hi_and_reserved, &u->clock_seq_low, &u->node[0],
195 &u->node[1], &u->node[2], &u->node[3], &u->node[4], &u->node[5]);
196
197 /* Make sure we have all conversions. */
198 if (n != 11)
199 return -1;
200
201 /* We have a successful scan. Check semantics... */
202 n = u->clock_seq_hi_and_reserved;
203 if ((n & 0x80) != 0x00 && /* variant 0? */
204 (n & 0xc0) != 0x80 && /* variant 1? */
205 (n & 0xe0) != 0xc0) /* variant 2? */
206 return -1;
207 return 0;
208 }
209
210 static int
211 gpt_uuid_parse_symbolic(const char *s, struct dce_uuid *u)
212 {
213 size_t i;
214
215 for (i = 0; i < __arraycount(gpt_nv); i++)
216 if (strcmp(gpt_nv[i].n, s) == 0) {
217 *u = gpt_nv[i].u;
218 return 0;
219 }
220 return -1;
221 }
222
223 int
224 gpt_uuid_parse(const char *s, gpt_uuid_t uuid)
225 {
226 struct dce_uuid u;
227
228 if (gpt_uuid_parse_numeric(s, &u) != -1) {
229 gpt_dce_to_uuid(&u, uuid);
230 return 0;
231 }
232
233 if (gpt_uuid_parse_symbolic(s, &u) == -1)
234 return -1;
235
236 gpt_dce_to_uuid(&u, uuid);
237 return 0;
238 }
239
240 size_t
241 gpt_uuid_query(
242 void (*func)(const char *uuid, const char *short_name, const char *desc))
243 {
244 size_t i;
245 char buf[64];
246
247 if (func != NULL) {
248 for (i = 0; i < __arraycount(gpt_nv); i++) {
249 gpt_uuid_numeric(buf, sizeof(buf), &gpt_nv[i].u);
250 (*func)(buf, gpt_nv[i].n, gpt_nv[i].d);
251 }
252 }
253 return __arraycount(gpt_nv);
254 }
255
256 #ifndef GPT_UUID_QUERY_ONLY
257 void
258 gpt_uuid_help(const char *prefix)
259 {
260 size_t i;
261
262 for (i = 0; i < __arraycount(gpt_nv); i++)
263 printf("%s%18.18s\t%s\n", prefix, gpt_nv[i].n, gpt_nv[i].d);
264 }
265
266 void
267 gpt_uuid_create(gpt_type_t t, gpt_uuid_t u, uint16_t *b, size_t s)
268 {
269 gpt_dce_to_uuid(&gpt_nv[t].u, u);
270 if (b)
271 utf8_to_utf16((const uint8_t *)gpt_nv[t].d, b, s / sizeof(*b));
272 }
273
274 static int
275 gpt_uuid_random(gpt_t gpt, void *v, size_t n)
276 {
277 int fd;
278 uint8_t *p;
279 ssize_t nread;
280
281 /* Randomly generate the content. */
282 fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC);
283 if (fd == -1) {
284 gpt_warn(gpt, "Can't open `/dev/urandom'");
285 return -1;
286 }
287 for (p = v; n > 0; p += nread, n -= (size_t)nread) {
288 nread = read(fd, p, n);
289 if (nread < 0) {
290 gpt_warn(gpt, "Can't read `/dev/urandom'");
291 goto out;
292 }
293 if (nread == 0) {
294 gpt_warn(gpt, "EOF from /dev/urandom");
295 goto out;
296 }
297 if ((size_t)nread > n) {
298 gpt_warnx(gpt, "read too much: %zd > %zu", nread, n);
299 goto out;
300 }
301 }
302 (void)close(fd);
303 return 0;
304 out:
305 (void)close(fd);
306 return -1;
307 }
308
309 static int
310 gpt_uuid_tstamp(gpt_t gpt, void *v, size_t l)
311 {
312 uint8_t *p;
313 // Perhaps use SHA?
314 uint32_t x = (uint32_t)gpt->timestamp;
315
316 for (p = v; l > 0; p += sizeof(x), l -= sizeof(x))
317 memcpy(p, &x, sizeof(x));
318
319 return 0;
320 }
321
322 int
323 gpt_uuid_generate(gpt_t gpt, gpt_uuid_t t)
324 {
325 int rv;
326 struct dce_uuid u;
327 if (gpt && (gpt->flags & GPT_TIMESTAMP))
328 rv = gpt_uuid_tstamp(gpt, &u, sizeof(u));
329 else
330 rv = gpt_uuid_random(gpt, &u, sizeof(u));
331
332 if (rv == -1)
333 return -1;
334
335 /* Set the version number to 4. */
336 u.time_hi_and_version &= (uint16_t)~0xf000;
337 u.time_hi_and_version |= 0x4000;
338
339 /* Fix the reserved bits. */
340 u.clock_seq_hi_and_reserved &= (uint8_t)~0x40;
341 u.clock_seq_hi_and_reserved |= 0x80;
342
343 gpt_dce_to_uuid(&u, t);
344 return 0;
345 }
346 #endif
347