util-linux/volume_id/get_devname.c

/* vi: set sw=4 ts=4: */
/*
 * Support functions for mounting devices by label/uuid
 *
 * Copyright (C) 2006 by Jason Schoon <floydpink@gmail.com>
 * Some portions cribbed from e2fsprogs, util-linux, dosfstools
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 */
#include <sys/mount.h> /* BLKGETSIZE64 */
#if !defined(BLKGETSIZE64)
# define BLKGETSIZE64 _IOR(0x12,114,size_t)
#endif
#include "volume_id_internal.h"

static struct uuidCache_s {
	struct uuidCache_s *next;
//	int major, minor;
	char *device;
	char *label;
	char *uc_uuid; /* prefix makes it easier to grep for */
} *uuidCache;

/* Returns !0 on error.
 * Otherwise, returns malloc'ed strings for label and uuid
 * (and they can't be NULL, although they can be "").
 * NB: closes fd. */
static int
get_label_uuid(int fd, char **label, char **uuid)
{
	int rv = 1;
	uint64_t size;
	struct volume_id *vid;

	/* fd is owned by vid now */
	vid = volume_id_open_node(fd);

	if (ioctl(/*vid->*/fd, BLKGETSIZE64, &size) != 0)
		size = 0;

	if (volume_id_probe_all(vid, /*0,*/ size) != 0)
		goto ret;

	if (vid->label[0] != '\0' || vid->uuid[0] != '\0') {
		*label = xstrndup(vid->label, sizeof(vid->label));
		*uuid  = xstrndup(vid->uuid, sizeof(vid->uuid));
		dbg("found label '%s', uuid '%s'", *label, *uuid);
		rv = 0;
	}
 ret:
	free_volume_id(vid); /* also closes fd */
	return rv;
}

/* NB: we take ownership of (malloc'ed) label and uuid */
static void
uuidcache_addentry(char *device, /*int major, int minor,*/ char *label, char *uuid)
{
	struct uuidCache_s *last;

	if (!uuidCache) {
		last = uuidCache = xzalloc(sizeof(*uuidCache));
	} else {
		for (last = uuidCache; last->next; last = last->next)
			continue;
		last->next = xzalloc(sizeof(*uuidCache));
		last = last->next;
	}
	/*last->next = NULL; - xzalloc did it*/
//	last->major = major;
//	last->minor = minor;
	last->device = device;
	last->label = label;
	last->uc_uuid = uuid;
}

/* If get_label_uuid() on device_name returns success,
 * add a cache entry for this device.
 * If device node does not exist, it will be temporarily created. */
static int FAST_FUNC
uuidcache_check_device(const char *device,
		struct stat *statbuf,
		void *userData UNUSED_PARAM,
		int depth UNUSED_PARAM)
{
	char *uuid = uuid; /* for compiler */
	char *label = label;
	int fd;

	/* note: this check rejects links to devices, among other nodes */
	if (!S_ISBLK(statbuf->st_mode))
		return TRUE;

	/* Users report that mucking with floppies (especially non-present
	 * ones) is significant PITA. This is a horribly dirty hack,
	 * but it is very useful in real world.
	 * If this will ever need to be enabled, consider using O_NONBLOCK.
	 */
	if (major(statbuf->st_rdev) == 2)
		return TRUE;

	fd = open(device, O_RDONLY);
	if (fd < 0)
		return TRUE;

	/* get_label_uuid() closes fd in all cases (success & failure) */
	if (get_label_uuid(fd, &label, &uuid) == 0) {
		/* uuidcache_addentry() takes ownership of all three params */
		uuidcache_addentry(xstrdup(device), /*ma, mi,*/ label, uuid);
	}
	return TRUE;
}

static void
uuidcache_init(void)
{
	if (uuidCache)
		return;

	/* We were scanning /proc/partitions
	 * and /proc/sys/dev/cdrom/info here.
	 * Missed volume managers. I see that "standard" blkid uses these:
	 * /dev/mapper/control
	 * /proc/devices
	 * /proc/evms/volumes
	 * /proc/lvm/VGs
	 * This is unacceptably complex. Let's just scan /dev.
	 * (Maybe add scanning of /sys/block/XXX/dev for devices
	 * somehow not having their /dev/XXX entries created?) */

	recursive_action("/dev", ACTION_RECURSE,
		uuidcache_check_device, /* file_action */
		NULL, /* dir_action */
		NULL, /* userData */
		0 /* depth */);
}

#define UUID   1
#define VOL    2

#ifdef UNUSED
static char *
get_spec_by_x(int n, const char *t, int *majorPtr, int *minorPtr)
{
	struct uuidCache_s *uc;

	uuidcache_init();
	uc = uuidCache;

	while (uc) {
		switch (n) {
		case UUID:
			if (strcmp(t, uc->uc_uuid) == 0) {
				*majorPtr = uc->major;
				*minorPtr = uc->minor;
				return uc->device;
			}
			break;
		case VOL:
			if (strcmp(t, uc->label) == 0) {
				*majorPtr = uc->major;
				*minorPtr = uc->minor;
				return uc->device;
			}
			break;
		}
		uc = uc->next;
	}
	return NULL;
}

static unsigned char
fromhex(char c)
{
	if (isdigit(c))
		return (c - '0');
	return ((c|0x20) - 'a' + 10);
}

static char *
get_spec_by_uuid(const char *s, int *major, int *minor)
{
	unsigned char uuid[16];
	int i;

	if (strlen(s) != 36 || s[8] != '-' || s[13] != '-'
	 || s[18] != '-' || s[23] != '-'
	) {
		goto bad_uuid;
	}
	for (i = 0; i < 16; i++) {
		if (*s == '-')
			s++;
		if (!isxdigit(s[0]) || !isxdigit(s[1]))
			goto bad_uuid;
		uuid[i] = ((fromhex(s[0]) << 4) | fromhex(s[1]));
		s += 2;
	}
	return get_spec_by_x(UUID, (char *)uuid, major, minor);

 bad_uuid:
	fprintf(stderr, _("mount: bad UUID"));
	return 0;
}

static char *
get_spec_by_volume_label(const char *s, int *major, int *minor)
{
	return get_spec_by_x(VOL, s, major, minor);
}
#endif // UNUSED

/* Used by blkid */
void display_uuid_cache(void)
{
	struct uuidCache_s *u;

	uuidcache_init();
	u = uuidCache;
	while (u) {
		printf("%s:", u->device);
		if (u->label[0])
			printf(" LABEL=\"%s\"", u->label);
		if (u->uc_uuid[0])
			printf(" UUID=\"%s\"", u->uc_uuid);
		bb_putchar('\n');
		u = u->next;
	}
}

/* Used by mount and findfs */

char *get_devname_from_label(const char *spec)
{
	struct uuidCache_s *uc;

	uuidcache_init();
	uc = uuidCache;
	while (uc) {
		if (uc->label[0] && strcmp(spec, uc->label) == 0) {
			return xstrdup(uc->device);
		}
		uc = uc->next;
	}
	return NULL;
}

char *get_devname_from_uuid(const char *spec)
{
	struct uuidCache_s *uc;

	uuidcache_init();
	uc = uuidCache;
	while (uc) {
		/* case of hex numbers doesn't matter */
		if (strcasecmp(spec, uc->uc_uuid) == 0) {
			return xstrdup(uc->device);
		}
		uc = uc->next;
	}
	return NULL;
}

int resolve_mount_spec(char **fsname)
{
	char *tmp = *fsname;

	if (strncmp(*fsname, "UUID=", 5) == 0)
		tmp = get_devname_from_uuid(*fsname + 5);
	else if (strncmp(*fsname, "LABEL=", 6) == 0)
		tmp = get_devname_from_label(*fsname + 6);

	if (tmp == *fsname)
		return 0; /* no UUID= or LABEL= prefix found */

	if (tmp)
		*fsname = tmp;
	return 1;
}
1	niro	816	/* vi: set sw=4 ts=4: */
2			/*
3			* Support functions for mounting devices by label/uuid
4			*
5			* Copyright (C) 2006 by Jason Schoon <floydpink@gmail.com>
6			* Some portions cribbed from e2fsprogs, util-linux, dosfstools
7			*
8			* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
9			*/
10	niro	984	#include <sys/mount.h> /* BLKGETSIZE64 */
11			#if !defined(BLKGETSIZE64)
12			# define BLKGETSIZE64 _IOR(0x12,114,size_t)
13			#endif
14	niro	816	#include "volume_id_internal.h"
15
16			static struct uuidCache_s {
17			struct uuidCache_s *next;
18			// int major, minor;
19			char *device;
20			char *label;
21			char uc_uuid; / prefix makes it easier to grep for */
22			} *uuidCache;
23
24			/* Returns !0 on error.
25			* Otherwise, returns malloc'ed strings for label and uuid
26			* (and they can't be NULL, although they can be "").
27			* NB: closes fd. */
28			static int
29			get_label_uuid(int fd, char label, char uuid)
30			{
31			int rv = 1;
32			uint64_t size;
33			struct volume_id *vid;
34
35			/* fd is owned by vid now */
36			vid = volume_id_open_node(fd);
37
38			if (ioctl(/vid->/fd, BLKGETSIZE64, &size) != 0)
39			size = 0;
40
41	niro	984	if (volume_id_probe_all(vid, /0,/ size) != 0)
42	niro	816	goto ret;
43
44			if (vid->label[0] != '\0' \|\| vid->uuid[0] != '\0') {
45			*label = xstrndup(vid->label, sizeof(vid->label));
46			*uuid = xstrndup(vid->uuid, sizeof(vid->uuid));
47	niro	984	dbg("found label '%s', uuid '%s'", label, uuid);
48	niro	816	rv = 0;
49			}
50			ret:
51			free_volume_id(vid); /* also closes fd */
52			return rv;
53			}
54
55			/* NB: we take ownership of (malloc'ed) label and uuid */
56			static void
57			uuidcache_addentry(char device, /int major, int minor,/ char label, char *uuid)
58			{
59			struct uuidCache_s *last;
60
61			if (!uuidCache) {
62			last = uuidCache = xzalloc(sizeof(*uuidCache));
63			} else {
64			for (last = uuidCache; last->next; last = last->next)
65			continue;
66			last->next = xzalloc(sizeof(*uuidCache));
67			last = last->next;
68			}
69			/last->next = NULL; - xzalloc did it/
70			// last->major = major;
71			// last->minor = minor;
72			last->device = device;
73			last->label = label;
74			last->uc_uuid = uuid;
75			}
76
77			/* If get_label_uuid() on device_name returns success,
78			* add a cache entry for this device.
79			* If device node does not exist, it will be temporarily created. */
80			static int FAST_FUNC
81			uuidcache_check_device(const char *device,
82			struct stat *statbuf,
83			void *userData UNUSED_PARAM,
84			int depth UNUSED_PARAM)
85			{
86			char uuid = uuid; / for compiler */
87			char *label = label;
88			int fd;
89
90	niro	984	/* note: this check rejects links to devices, among other nodes */
91	niro	816	if (!S_ISBLK(statbuf->st_mode))
92			return TRUE;
93
94	niro	984	/* Users report that mucking with floppies (especially non-present
95			* ones) is significant PITA. This is a horribly dirty hack,
96			* but it is very useful in real world.
97			* If this will ever need to be enabled, consider using O_NONBLOCK.
98			*/
99			if (major(statbuf->st_rdev) == 2)
100			return TRUE;
101
102	niro	816	fd = open(device, O_RDONLY);
103			if (fd < 0)
104			return TRUE;
105
106			/* get_label_uuid() closes fd in all cases (success & failure) */
107			if (get_label_uuid(fd, &label, &uuid) == 0) {
108			/* uuidcache_addentry() takes ownership of all three params */
109			uuidcache_addentry(xstrdup(device), /ma, mi,/ label, uuid);
110			}
111			return TRUE;
112			}
113
114			static void
115			uuidcache_init(void)
116			{
117			if (uuidCache)
118			return;
119
120			/* We were scanning /proc/partitions
121			* and /proc/sys/dev/cdrom/info here.
122			* Missed volume managers. I see that "standard" blkid uses these:
123			* /dev/mapper/control
124			* /proc/devices
125			* /proc/evms/volumes
126			* /proc/lvm/VGs
127			* This is unacceptably complex. Let's just scan /dev.
128			* (Maybe add scanning of /sys/block/XXX/dev for devices
129			* somehow not having their /dev/XXX entries created?) */
130
131			recursive_action("/dev", ACTION_RECURSE,
132			uuidcache_check_device, /* file_action */
133			NULL, /* dir_action */
134			NULL, /* userData */
135			0 /* depth */);
136			}
137
138			#define UUID 1
139			#define VOL 2
140
141			#ifdef UNUSED
142			static char *
143			get_spec_by_x(int n, const char t, int majorPtr, int *minorPtr)
144			{
145			struct uuidCache_s *uc;
146
147			uuidcache_init();
148			uc = uuidCache;
149
150			while (uc) {
151			switch (n) {
152			case UUID:
153			if (strcmp(t, uc->uc_uuid) == 0) {
154			*majorPtr = uc->major;
155			*minorPtr = uc->minor;
156			return uc->device;
157			}
158			break;
159			case VOL:
160			if (strcmp(t, uc->label) == 0) {
161			*majorPtr = uc->major;
162			*minorPtr = uc->minor;
163			return uc->device;
164			}
165			break;
166			}
167			uc = uc->next;
168			}
169			return NULL;
170			}
171
172			static unsigned char
173			fromhex(char c)
174			{
175			if (isdigit(c))
176			return (c - '0');
177			return ((c\|0x20) - 'a' + 10);
178			}
179
180			static char *
181			get_spec_by_uuid(const char s, int major, int *minor)
182			{
183			unsigned char uuid[16];
184			int i;
185
186			if (strlen(s) != 36 \|\| s[8] != '-' \|\| s[13] != '-'
187			\|\| s[18] != '-' \|\| s[23] != '-'
188			) {
189			goto bad_uuid;
190			}
191			for (i = 0; i < 16; i++) {
192			if (*s == '-')
193			s++;
194			if (!isxdigit(s[0]) \|\| !isxdigit(s[1]))
195			goto bad_uuid;
196			uuid[i] = ((fromhex(s[0]) << 4) \| fromhex(s[1]));
197			s += 2;
198			}
199			return get_spec_by_x(UUID, (char *)uuid, major, minor);
200
201			bad_uuid:
202			fprintf(stderr, _("mount: bad UUID"));
203			return 0;
204			}
205
206			static char *
207			get_spec_by_volume_label(const char s, int major, int *minor)
208			{
209			return get_spec_by_x(VOL, s, major, minor);
210			}
211			#endif // UNUSED
212
213			/* Used by blkid */
214			void display_uuid_cache(void)
215			{
216			struct uuidCache_s *u;
217
218			uuidcache_init();
219			u = uuidCache;
220			while (u) {
221			printf("%s:", u->device);
222			if (u->label[0])
223			printf(" LABEL=\"%s\"", u->label);
224			if (u->uc_uuid[0])
225			printf(" UUID=\"%s\"", u->uc_uuid);
226			bb_putchar('\n');
227			u = u->next;
228			}
229			}
230
231			/* Used by mount and findfs */
232
233			char get_devname_from_label(const char spec)
234			{
235			struct uuidCache_s *uc;
236
237			uuidcache_init();
238			uc = uuidCache;
239			while (uc) {
240			if (uc->label[0] && strcmp(spec, uc->label) == 0) {
241			return xstrdup(uc->device);
242			}
243			uc = uc->next;
244			}
245			return NULL;
246			}
247
248			char get_devname_from_uuid(const char spec)
249			{
250			struct uuidCache_s *uc;
251
252			uuidcache_init();
253			uc = uuidCache;
254			while (uc) {
255			/* case of hex numbers doesn't matter */
256			if (strcasecmp(spec, uc->uc_uuid) == 0) {
257			return xstrdup(uc->device);
258			}
259			uc = uc->next;
260			}
261			return NULL;
262			}
263	niro	984
264			int resolve_mount_spec(char **fsname)
265			{
266			char tmp = fsname;
267
268			if (strncmp(*fsname, "UUID=", 5) == 0)
269			tmp = get_devname_from_uuid(*fsname + 5);
270			else if (strncmp(*fsname, "LABEL=", 6) == 0)
271			tmp = get_devname_from_label(*fsname + 6);
272
273			if (tmp == *fsname)
274			return 0; /* no UUID= or LABEL= prefix found */
275
276			if (tmp)
277			*fsname = tmp;
278			return 1;
279			}