[thirdparty/util-linux.git] / misc-utils / lsblk-properties.c


#include <blkid.h>

#ifdef HAVE_LIBUDEV
# include <libudev.h>
#endif

#include "c.h"
#include "xalloc.h"
#include "mangle.h"
#include "path.h"
#include "nls.h"

#include "lsblk.h"

#ifdef HAVE_LIBUDEV
static struct udev *udev;
#endif

void lsblk_device_free_properties(struct lsblk_devprop *p)
{
	if (!p)
		return;

	free(p->fstype);
	free(p->fsversion);
	free(p->uuid);
	free(p->ptuuid);
	free(p->pttype);
	free(p->label);
	free(p->parttype);
	free(p->partuuid);
	free(p->partlabel);
	free(p->wwn);
	free(p->serial);
	free(p->model);
	free(p->partflags);

	free(p->mode);
	free(p->owner);
	free(p->group);

	free(p);
}

#ifndef HAVE_LIBUDEV
static struct lsblk_devprop *get_properties_by_udev(struct lsblk_device *dev
				__attribute__((__unused__)))
{
	return NULL;
}
#else
static struct lsblk_devprop *get_properties_by_udev(struct lsblk_device *ld)
{
	struct udev_device *dev;

	if (ld->udev_requested)
		return ld->properties;

	if (!udev)
		udev = udev_new();	/* global handler */
	if (!udev)
		goto done;

	dev = udev_device_new_from_subsystem_sysname(udev, "block", ld->name);
	if (dev) {
		const char *data;
		struct lsblk_devprop *prop;

		if (ld->properties)
			lsblk_device_free_properties(ld->properties);
		prop = ld->properties = xcalloc(1, sizeof(*ld->properties));

		if ((data = udev_device_get_property_value(dev, "ID_FS_LABEL_ENC"))) {
			prop->label = xstrdup(data);
			unhexmangle_string(prop->label);
		}
		if ((data = udev_device_get_property_value(dev, "ID_FS_UUID_ENC"))) {
			prop->uuid = xstrdup(data);
			unhexmangle_string(prop->uuid);
		}
		if ((data = udev_device_get_property_value(dev, "ID_PART_TABLE_UUID")))
			prop->ptuuid = xstrdup(data);
		if ((data = udev_device_get_property_value(dev, "ID_PART_TABLE_TYPE")))
			prop->pttype = xstrdup(data);
		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME"))) {
			prop->partlabel = xstrdup(data);
			unhexmangle_string(prop->partlabel);
		}
		if ((data = udev_device_get_property_value(dev, "ID_FS_TYPE")))
			prop->fstype = xstrdup(data);
		if ((data = udev_device_get_property_value(dev, "ID_FS_VERSION")))
			prop->fsversion = xstrdup(data);
		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_TYPE")))
			prop->parttype = xstrdup(data);
		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_UUID")))
			prop->partuuid = xstrdup(data);
		if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_FLAGS")))
			prop->partflags = xstrdup(data);

		data = udev_device_get_property_value(dev, "ID_WWN_WITH_EXTENSION");
		if (!data)
			data = udev_device_get_property_value(dev, "ID_WWN");
		if (data)
			prop->wwn = xstrdup(data);

		data = udev_device_get_property_value(dev, "ID_SCSI_SERIAL");
		if(!data)
			data = udev_device_get_property_value(dev, "ID_SERIAL_SHORT");
		if(!data)
			data = udev_device_get_property_value(dev, "ID_SERIAL");
		if (data)
			prop->serial = xstrdup(data);

		if ((data = udev_device_get_property_value(dev, "ID_MODEL")))
			prop->model = xstrdup(data);

		udev_device_unref(dev);
		DBG(DEV, ul_debugobj(ld, "%s: found udev properties", ld->name));
	}

done:
	ld->udev_requested = 1;

	DBG(DEV, ul_debugobj(ld, " from udev"));
	return ld->properties;
}
#endif /* HAVE_LIBUDEV */


static int lookup(char *buf, char *pattern, char **value)
{
	char *p, *v;
	int len;

	/* do not re-fill value */
	if (!buf || *value)
		return 0;

	len = strlen(pattern);
	if (strncmp(buf, pattern, len) != 0)
		return 0;

	p = buf + len;
	if (*p != '=')
		return 0;
	p++;
	if (!*p || *p == '\n')
		return 0;
	v = p;
	for (; *p && *p != '\n'; p++) ;
	if (*p == '\n')
		*p = '\0';

	*value = xstrdup(v);
	return 1;
}

/* read device properties from fake text file (used on --sysroot) */
static struct lsblk_devprop *get_properties_by_file(struct lsblk_device *ld)
{
	struct lsblk_devprop *prop;
	struct path_cxt *pc;
	FILE *fp = NULL;
	struct stat sb;
	char buf[BUFSIZ];

	assert(lsblk->sysroot);

	if (ld->file_requested)
		return ld->properties;

	if (ld->properties || ld->filename) {
		lsblk_device_free_properties(ld->properties);
		ld->properties = NULL;
	}

	pc = ul_new_path("/");
	if (!pc)
		return NULL;
	if (ul_path_set_prefix(pc, lsblk->sysroot) != 0)
		goto done;
	if (ul_path_stat(pc, &sb, ld->filename) != 0 || !S_ISREG(sb.st_mode))
		goto done;

	fp = ul_path_fopen(pc, "r", ld->filename);
	if (!fp)
		goto done;

	prop = ld->properties;
	if (!prop)
		prop = ld->properties = xcalloc(1, sizeof(*ld->properties));

	while (fgets(buf, sizeof(buf), fp) != NULL) {
		/* udev based */
		if (lookup(buf, "ID_FS_LABEL_ENC", &prop->label))
			unhexmangle_string(prop->label);
		else if (lookup(buf, "ID_FS_UUID_ENC", &prop->uuid))
			unhexmangle_string(prop->uuid);
		else if (lookup(buf, "ID_PART_ENTRY_NAME", &prop->partlabel))
			unhexmangle_string(prop->partlabel);
		else if (lookup(buf, "ID_PART_TABLE_UUID", &prop->ptuuid)) ;
		else if (lookup(buf, "ID_PART_TABLE_TYPE", &prop->pttype)) ;
		else if (lookup(buf, "ID_FS_TYPE", &prop->fstype)) ;
		else if (lookup(buf, "ID_FS_VERSION", &prop->fsversion)) ;
		else if (lookup(buf, "ID_PART_ENTRY_TYPE", &prop->parttype)) ;
		else if (lookup(buf, "ID_PART_ENTRY_UUID", &prop->partuuid)) ;
		else if (lookup(buf, "ID_PART_ENTRY_FLAGS", &prop->partflags)) ;
		else if (lookup(buf, "ID_MODEL", &prop->model)) ;
		else if (lookup(buf, "ID_WWN_WITH_EXTENSION", &prop->wwn)) ;
		else if (lookup(buf, "ID_WWN", &prop->wwn)) ;
		else if (lookup(buf, "ID_SCSI_SERIAL", &prop->serial)) ;
		else if (lookup(buf, "ID_SERIAL_SHORT", &prop->serial)) ;
		else if (lookup(buf, "ID_SERIAL", &prop->serial)) ;

		/* lsblk specific */
		else if (lookup(buf, "MODE", &prop->mode)) ;
		else if (lookup(buf, "OWNER", &prop->owner)) ;
		else if (lookup(buf, "GROUP", &prop->group)) ;

		else
			continue;
	}
done:
	if (fp)
		fclose(fp);
	ul_unref_path(pc);
	ld->file_requested = 1;

	DBG(DEV, ul_debugobj(ld, " from fake-file"));
	return ld->properties;
}


static struct lsblk_devprop *get_properties_by_blkid(struct lsblk_device *dev)
{
	blkid_probe pr = NULL;

	if (dev->blkid_requested)
		return dev->properties;

	if (!dev->size)
		goto done;
	if (getuid() != 0)
		goto done;;				/* no permissions to read from the device */

	pr = blkid_new_probe_from_filename(dev->filename);
	if (!pr)
		goto done;

	blkid_probe_enable_superblocks(pr, 1);
	blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL |
					      BLKID_SUBLKS_UUID |
					      BLKID_SUBLKS_TYPE);
	blkid_probe_enable_partitions(pr, 1);
	blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);

	if (!blkid_do_safeprobe(pr)) {
		const char *data = NULL;
		struct lsblk_devprop *prop;

		if (dev->properties)
			lsblk_device_free_properties(dev->properties);
		prop = dev->properties = xcalloc(1, sizeof(*dev->properties));

		if (!blkid_probe_lookup_value(pr, "TYPE", &data, NULL))
			prop->fstype = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "UUID", &data, NULL))
			prop->uuid = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "PTUUID", &data, NULL))
			prop->ptuuid = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "PTTYPE", &data, NULL))
			prop->pttype = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "LABEL", &data, NULL))
			prop->label = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "VERSION", &data, NULL))
			prop->fsversion = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_TYPE", &data, NULL))
			prop->parttype = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_UUID", &data, NULL))
			prop->partuuid = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_NAME", &data, NULL))
			prop->partlabel = xstrdup(data);
		if (!blkid_probe_lookup_value(pr, "PART_ENTRY_FLAGS", &data, NULL))
			prop->partflags = xstrdup(data);

		DBG(DEV, ul_debugobj(dev, "%s: found blkid properties", dev->name));
	}

done:
	blkid_free_probe(pr);

	DBG(DEV, ul_debugobj(dev, " from blkid"));
	dev->blkid_requested = 1;
	return dev->properties;
}

struct lsblk_devprop *lsblk_device_get_properties(struct lsblk_device *dev)
{
	struct lsblk_devprop *p = NULL;

	DBG(DEV, ul_debugobj(dev, "%s: properties requested", dev->filename));
	if (lsblk->sysroot)
		return get_properties_by_file(dev);

	p = get_properties_by_udev(dev);
	if (!p)
		p = get_properties_by_blkid(dev);
	return p;
}

void lsblk_properties_deinit(void)
{
#ifdef HAVE_LIBUDEV
	udev_unref(udev);
#endif
}


/*
 * Partition types
 */
struct lsblk_parttype {
	unsigned int	code;		/* type as number or zero */
	char		*name;		/* description */
	char		*typestr;	/* type as string or NULL */
};

static const struct lsblk_parttype mbr_types[] =
{
	#include "pt-mbr-partnames.h"
};

#define DEF_GUID(_u, _n) \
	{ \
		.typestr = (_u), \
		.name = (_n),    \
	}
static const struct lsblk_parttype gpt_types[] =
{
	#include "pt-gpt-partnames.h"
};

const char *lsblk_parttype_code_to_string(const char *code, const char *pttype)
{
	size_t i;

	if (!code || !pttype)
		return NULL;

	if (strcmp(pttype, "dos") == 0 || strcmp(pttype, "mbr") == 0) {
		char *end = NULL;
		unsigned int xcode;

		errno = 0;
		xcode = strtol(code, &end, 16);

		if (errno || *end != '\0')
			return NULL;

		for (i = 0; i < ARRAY_SIZE(mbr_types); i++) {
			const struct lsblk_parttype *t = &mbr_types[i];

			if (t->name && t->code == xcode)
				return t->name;
		}

	} else if (strcmp(pttype, "gpt") == 0) {
		for (i = 0; i < ARRAY_SIZE(gpt_types); i++) {
			const struct lsblk_parttype *t = &gpt_types[i];

			if (t->name && t->typestr &&
			    strcasecmp(code, t->typestr) == 0)
				return t->name;
		}
	}

	return NULL;
}
Commit	Line	Data
ccafadb7 KZ	1
	2	#include <blkid.h>
	3
	4	#ifdef HAVE_LIBUDEV
	5	# include <libudev.h>
	6	#endif
	7
	8	#include "c.h"
	9	#include "xalloc.h"
	10	#include "mangle.h"
7408a5d9	11	#include "path.h"
107e9559	12	#include "nls.h"
ccafadb7 KZ	13
	14	#include "lsblk.h"
	15
	16	#ifdef HAVE_LIBUDEV
	17	static struct udev *udev;
	18	#endif
	19
	20	void lsblk_device_free_properties(struct lsblk_devprop *p)
	21	{
	22	if (!p)
	23	return;
	24
	25	free(p->fstype);
9cca1ef2	26	free(p->fsversion);
ccafadb7 KZ	27	free(p->uuid);
	28	free(p->ptuuid);
	29	free(p->pttype);
	30	free(p->label);
	31	free(p->parttype);
	32	free(p->partuuid);
	33	free(p->partlabel);
	34	free(p->wwn);
	35	free(p->serial);
	36	free(p->model);
7408a5d9	37	free(p->partflags);
ccafadb7	38
6f74ede5 KZ	39	free(p->mode);
	40	free(p->owner);
	41	free(p->group);
	42
ccafadb7 KZ	43	free(p);
	44	}
	45
	46	#ifndef HAVE_LIBUDEV
fed34a1e	47	static struct lsblk_devprop get_properties_by_udev(struct lsblk_device dev
ccafadb7 KZ	48	__attribute__((__unused__)))
	49	{
	50	return NULL;
	51	}
	52	#else
fed34a1e	53	static struct lsblk_devprop get_properties_by_udev(struct lsblk_device ld)
ccafadb7 KZ	54	{
	55	struct udev_device *dev;
	56
fed34a1e KZ	57	if (ld->udev_requested)
fed34a1e KZ	58	return ld->properties;
ccafadb7	59
ccafadb7 KZ	60	if (!udev)
	61	udev = udev_new(); /* global handler */
	62	if (!udev)
	63	goto done;
	64
fed34a1e	65	dev = udev_device_new_from_subsystem_sysname(udev, "block", ld->name);
ccafadb7 KZ	66	if (dev) {
	67	const char *data;
	68	struct lsblk_devprop *prop;
	69
fed34a1e KZ	70	if (ld->properties)
	71	lsblk_device_free_properties(ld->properties);
	72	prop = ld->properties = xcalloc(1, sizeof(*ld->properties));
ccafadb7 KZ	73
	74	if ((data = udev_device_get_property_value(dev, "ID_FS_LABEL_ENC"))) {
	75	prop->label = xstrdup(data);
	76	unhexmangle_string(prop->label);
	77	}
	78	if ((data = udev_device_get_property_value(dev, "ID_FS_UUID_ENC"))) {
	79	prop->uuid = xstrdup(data);
	80	unhexmangle_string(prop->uuid);
	81	}
	82	if ((data = udev_device_get_property_value(dev, "ID_PART_TABLE_UUID")))
	83	prop->ptuuid = xstrdup(data);
	84	if ((data = udev_device_get_property_value(dev, "ID_PART_TABLE_TYPE")))
	85	prop->pttype = xstrdup(data);
	86	if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_NAME"))) {
	87	prop->partlabel = xstrdup(data);
	88	unhexmangle_string(prop->partlabel);
	89	}
	90	if ((data = udev_device_get_property_value(dev, "ID_FS_TYPE")))
	91	prop->fstype = xstrdup(data);
9cca1ef2 KZ	92	if ((data = udev_device_get_property_value(dev, "ID_FS_VERSION")))
9cca1ef2 KZ	93	prop->fsversion = xstrdup(data);
ccafadb7 KZ	94	if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_TYPE")))
	95	prop->parttype = xstrdup(data);
	96	if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_UUID")))
	97	prop->partuuid = xstrdup(data);
	98	if ((data = udev_device_get_property_value(dev, "ID_PART_ENTRY_FLAGS")))
	99	prop->partflags = xstrdup(data);
	100
	101	data = udev_device_get_property_value(dev, "ID_WWN_WITH_EXTENSION");
	102	if (!data)
	103	data = udev_device_get_property_value(dev, "ID_WWN");
	104	if (data)
	105	prop->wwn = xstrdup(data);
	106
c2f6513c SW	107	data = udev_device_get_property_value(dev, "ID_SCSI_SERIAL");
	108	if(!data)
	109	data = udev_device_get_property_value(dev, "ID_SERIAL_SHORT");
e81d0f80 SW	110	if(!data)
e81d0f80 SW	111	data = udev_device_get_property_value(dev, "ID_SERIAL");
c2f6513c	112	if (data)
ccafadb7	113	prop->serial = xstrdup(data);
c2f6513c	114
ccafadb7 KZ	115	if ((data = udev_device_get_property_value(dev, "ID_MODEL")))
	116	prop->model = xstrdup(data);
	117
	118	udev_device_unref(dev);
fed34a1e	119	DBG(DEV, ul_debugobj(ld, "%s: found udev properties", ld->name));
ccafadb7 KZ	120	}
	121
	122	done:
fed34a1e	123	ld->udev_requested = 1;
7408a5d9 KZ	124
7408a5d9 KZ	125	DBG(DEV, ul_debugobj(ld, " from udev"));
fed34a1e	126	return ld->properties;
ccafadb7 KZ	127	}
	128	#endif /* HAVE_LIBUDEV */
	129
7408a5d9 KZ	130
	131	static int lookup(char buf, char pattern, char **value)
	132	{
	133	char p, v;
	134	int len;
	135
	136	/* do not re-fill value */
	137	if (!buf \|\| *value)
	138	return 0;
	139
	140	len = strlen(pattern);
ad296391	141	if (strncmp(buf, pattern, len) != 0)
7408a5d9 KZ	142	return 0;
	143
	144	p = buf + len;
	145	if (*p != '=')
	146	return 0;
	147	p++;
	148	if (!p \|\| p == '\n')
	149	return 0;
	150	v = p;
	151	for (; p && p != '\n'; p++) ;
	152	if (*p == '\n')
	153	*p = '\0';
	154
	155	*value = xstrdup(v);
	156	return 1;
	157	}
	158
	159	/* read device properties from fake text file (used on --sysroot) */
	160	static struct lsblk_devprop get_properties_by_file(struct lsblk_device ld)
	161	{
	162	struct lsblk_devprop *prop;
	163	struct path_cxt *pc;
	164	FILE *fp = NULL;
	165	struct stat sb;
	166	char buf[BUFSIZ];
	167
eea06b92 KZ	168	assert(lsblk->sysroot);
eea06b92 KZ	169
7408a5d9 KZ	170	if (ld->file_requested)
	171	return ld->properties;
	172
7408a5d9 KZ	173	if (ld->properties \|\| ld->filename) {
	174	lsblk_device_free_properties(ld->properties);
	175	ld->properties = NULL;
	176	}
	177
	178	pc = ul_new_path("/");
	179	if (!pc)
	180	return NULL;
	181	if (ul_path_set_prefix(pc, lsblk->sysroot) != 0)
	182	goto done;
	183	if (ul_path_stat(pc, &sb, ld->filename) != 0 \|\| !S_ISREG(sb.st_mode))
	184	goto done;
	185
	186	fp = ul_path_fopen(pc, "r", ld->filename);
	187	if (!fp)
	188	goto done;
	189
	190	prop = ld->properties;
	191	if (!prop)
	192	prop = ld->properties = xcalloc(1, sizeof(*ld->properties));
	193
	194	while (fgets(buf, sizeof(buf), fp) != NULL) {
6f74ede5	195	/* udev based */
7408a5d9 KZ	196	if (lookup(buf, "ID_FS_LABEL_ENC", &prop->label))
	197	unhexmangle_string(prop->label);
	198	else if (lookup(buf, "ID_FS_UUID_ENC", &prop->uuid))
	199	unhexmangle_string(prop->uuid);
	200	else if (lookup(buf, "ID_PART_ENTRY_NAME", &prop->partlabel))
	201	unhexmangle_string(prop->partlabel);
	202	else if (lookup(buf, "ID_PART_TABLE_UUID", &prop->ptuuid)) ;
	203	else if (lookup(buf, "ID_PART_TABLE_TYPE", &prop->pttype)) ;
	204	else if (lookup(buf, "ID_FS_TYPE", &prop->fstype)) ;
9cca1ef2	205	else if (lookup(buf, "ID_FS_VERSION", &prop->fsversion)) ;
7408a5d9 KZ	206	else if (lookup(buf, "ID_PART_ENTRY_TYPE", &prop->parttype)) ;
	207	else if (lookup(buf, "ID_PART_ENTRY_UUID", &prop->partuuid)) ;
	208	else if (lookup(buf, "ID_PART_ENTRY_FLAGS", &prop->partflags)) ;
	209	else if (lookup(buf, "ID_MODEL", &prop->model)) ;
	210	else if (lookup(buf, "ID_WWN_WITH_EXTENSION", &prop->wwn)) ;
	211	else if (lookup(buf, "ID_WWN", &prop->wwn)) ;
	212	else if (lookup(buf, "ID_SCSI_SERIAL", &prop->serial)) ;
	213	else if (lookup(buf, "ID_SERIAL_SHORT", &prop->serial)) ;
e81d0f80	214	else if (lookup(buf, "ID_SERIAL", &prop->serial)) ;
6f74ede5 KZ	215
	216	/* lsblk specific */
	217	else if (lookup(buf, "MODE", &prop->mode)) ;
	218	else if (lookup(buf, "OWNER", &prop->owner)) ;
	219	else if (lookup(buf, "GROUP", &prop->group)) ;
	220
7408a5d9 KZ	221	else
	222	continue;
	223	}
	224	done:
	225	if (fp)
	226	fclose(fp);
	227	ul_unref_path(pc);
	228	ld->file_requested = 1;
	229
	230	DBG(DEV, ul_debugobj(ld, " from fake-file"));
	231	return ld->properties;
	232	}
	233
	234
fed34a1e	235	static struct lsblk_devprop get_properties_by_blkid(struct lsblk_device dev)
ccafadb7 KZ	236	{
	237	blkid_probe pr = NULL;
	238
fed34a1e KZ	239	if (dev->blkid_requested)
fed34a1e KZ	240	return dev->properties;
ccafadb7	241
fed34a1e	242	if (!dev->size)
ccafadb7 KZ	243	goto done;
	244	if (getuid() != 0)
	245	goto done;; /* no permissions to read from the device */
	246
fed34a1e	247	pr = blkid_new_probe_from_filename(dev->filename);
ccafadb7 KZ	248	if (!pr)
	249	goto done;
	250
	251	blkid_probe_enable_superblocks(pr, 1);
	252	blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL \|
	253	BLKID_SUBLKS_UUID \|
	254	BLKID_SUBLKS_TYPE);
	255	blkid_probe_enable_partitions(pr, 1);
	256	blkid_probe_set_partitions_flags(pr, BLKID_PARTS_ENTRY_DETAILS);
	257
	258	if (!blkid_do_safeprobe(pr)) {
	259	const char *data = NULL;
	260	struct lsblk_devprop *prop;
	261
fed34a1e KZ	262	if (dev->properties)
	263	lsblk_device_free_properties(dev->properties);
	264	prop = dev->properties = xcalloc(1, sizeof(*dev->properties));
ccafadb7 KZ	265
	266	if (!blkid_probe_lookup_value(pr, "TYPE", &data, NULL))
	267	prop->fstype = xstrdup(data);
	268	if (!blkid_probe_lookup_value(pr, "UUID", &data, NULL))
	269	prop->uuid = xstrdup(data);
	270	if (!blkid_probe_lookup_value(pr, "PTUUID", &data, NULL))
	271	prop->ptuuid = xstrdup(data);
	272	if (!blkid_probe_lookup_value(pr, "PTTYPE", &data, NULL))
	273	prop->pttype = xstrdup(data);
	274	if (!blkid_probe_lookup_value(pr, "LABEL", &data, NULL))
	275	prop->label = xstrdup(data);
9cca1ef2 KZ	276	if (!blkid_probe_lookup_value(pr, "VERSION", &data, NULL))
9cca1ef2 KZ	277	prop->fsversion = xstrdup(data);
ccafadb7 KZ	278	if (!blkid_probe_lookup_value(pr, "PART_ENTRY_TYPE", &data, NULL))
	279	prop->parttype = xstrdup(data);
	280	if (!blkid_probe_lookup_value(pr, "PART_ENTRY_UUID", &data, NULL))
	281	prop->partuuid = xstrdup(data);
	282	if (!blkid_probe_lookup_value(pr, "PART_ENTRY_NAME", &data, NULL))
	283	prop->partlabel = xstrdup(data);
	284	if (!blkid_probe_lookup_value(pr, "PART_ENTRY_FLAGS", &data, NULL))
	285	prop->partflags = xstrdup(data);
	286
fed34a1e	287	DBG(DEV, ul_debugobj(dev, "%s: found blkid properties", dev->name));
ccafadb7 KZ	288	}
	289
	290	done:
	291	blkid_free_probe(pr);
	292
7408a5d9	293	DBG(DEV, ul_debugobj(dev, " from blkid"));
fed34a1e KZ	294	dev->blkid_requested = 1;
fed34a1e KZ	295	return dev->properties;
ccafadb7 KZ	296	}
ccafadb7 KZ	297
fed34a1e	298	struct lsblk_devprop lsblk_device_get_properties(struct lsblk_device dev)
ccafadb7	299	{
7408a5d9	300	struct lsblk_devprop *p = NULL;
ccafadb7	301
7408a5d9 KZ	302	DBG(DEV, ul_debugobj(dev, "%s: properties requested", dev->filename));
7408a5d9 KZ	303	if (lsblk->sysroot)
eea06b92 KZ	304	return get_properties_by_file(dev);
	305
	306	p = get_properties_by_udev(dev);
ccafadb7	307	if (!p)
fed34a1e	308	p = get_properties_by_blkid(dev);
ccafadb7 KZ	309	return p;
	310	}
	311
	312	void lsblk_properties_deinit(void)
	313	{
	314	#ifdef HAVE_LIBUDEV
	315	udev_unref(udev);
	316	#endif
	317	}
107e9559 KZ	318
	319
	320
	321	/*
	322	* Partition types
	323	*/
	324	struct lsblk_parttype {
	325	unsigned int code; /* type as number or zero */
	326	char name; / description */
	327	char typestr; / type as string or NULL */
	328	};
	329
	330	static const struct lsblk_parttype mbr_types[] =
	331	{
	332	#include "pt-mbr-partnames.h"
	333	};
	334
	335	#define DEF_GUID(_u, _n) \
	336	{ \
	337	.typestr = (_u), \
	338	.name = (_n), \
	339	}
	340	static const struct lsblk_parttype gpt_types[] =
	341	{
	342	#include "pt-gpt-partnames.h"
	343	};
	344
	345	const char lsblk_parttype_code_to_string(const char code, const char *pttype)
	346	{
	347	size_t i;
	348
	349	if (!code \|\| !pttype)
	350	return NULL;
	351
	352	if (strcmp(pttype, "dos") == 0 \|\| strcmp(pttype, "mbr") == 0) {
	353	char *end = NULL;
	354	unsigned int xcode;
	355
	356	errno = 0;
	357	xcode = strtol(code, &end, 16);
	358
	359	if (errno \|\| *end != '\0')
	360	return NULL;
	361
	362	for (i = 0; i < ARRAY_SIZE(mbr_types); i++) {
	363	const struct lsblk_parttype *t = &mbr_types[i];
	364
	365	if (t->name && t->code == xcode)
	366	return t->name;
	367	}
	368
	369	} else if (strcmp(pttype, "gpt") == 0) {
	370	for (i = 0; i < ARRAY_SIZE(gpt_types); i++) {
	371	const struct lsblk_parttype *t = &gpt_types[i];
	372
	373	if (t->name && t->typestr &&
	374	strcasecmp(code, t->typestr) == 0)
	375	return t->name;
	376	}
	377	}
	378
	379	return NULL;
	380	}