Home | History | Annotate | Line # | Download | only in gpt
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