[thirdparty/systemd.git] / src / udev / udevadm-info.c

/*
 * Copyright (C) 2004-2009 Kay Sievers <kay@vrfy.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stddef.h>
#include <ctype.h>
#include <stdarg.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

#include "udev.h"
#include "udev-util.h"
#include "udevadm-util.h"

static bool skip_attribute(const char *name) {
        static const char* const skip[] = {
                "uevent",
                "dev",
                "modalias",
                "resource",
                "driver",
                "subsystem",
                "module",
        };
        unsigned int i;

        for (i = 0; i < ELEMENTSOF(skip); i++)
                if (streq(name, skip[i]))
                        return true;
        return false;
}

static void print_all_attributes(struct udev_device *device, const char *key) {
        struct udev_list_entry *sysattr;

        udev_list_entry_foreach(sysattr, udev_device_get_sysattr_list_entry(device)) {
                const char *name;
                const char *value;
                size_t len;

                name = udev_list_entry_get_name(sysattr);
                if (skip_attribute(name))
                        continue;

                value = udev_device_get_sysattr_value(device, name);
                if (value == NULL)
                        continue;

                /* skip any values that look like a path */
                if (value[0] == '/')
                        continue;

                /* skip nonprintable attributes */
                len = strlen(value);
                while (len > 0 && isprint(value[len-1]))
                        len--;
                if (len > 0)
                        continue;

                printf("    %s{%s}==\"%s\"\n", key, name, value);
        }
        printf("\n");
}

static int print_device_chain(struct udev_device *device) {
        struct udev_device *device_parent;
        const char *str;

        printf("\n"
               "Udevadm info starts with the device specified by the devpath and then\n"
               "walks up the chain of parent devices. It prints for every device\n"
               "found, all possible attributes in the udev rules key format.\n"
               "A rule to match, can be composed by the attributes of the device\n"
               "and the attributes from one single parent device.\n"
               "\n");

        printf("  looking at device '%s':\n", udev_device_get_devpath(device));
        printf("    KERNEL==\"%s\"\n", udev_device_get_sysname(device));
        str = udev_device_get_subsystem(device);
        if (str == NULL)
                str = "";
        printf("    SUBSYSTEM==\"%s\"\n", str);
        str = udev_device_get_driver(device);
        if (str == NULL)
                str = "";
        printf("    DRIVER==\"%s\"\n", str);
        print_all_attributes(device, "ATTR");

        device_parent = device;
        do {
                device_parent = udev_device_get_parent(device_parent);
                if (device_parent == NULL)
                        break;
                printf("  looking at parent device '%s':\n", udev_device_get_devpath(device_parent));
                printf("    KERNELS==\"%s\"\n", udev_device_get_sysname(device_parent));
                str = udev_device_get_subsystem(device_parent);
                if (str == NULL)
                        str = "";
                printf("    SUBSYSTEMS==\"%s\"\n", str);
                str = udev_device_get_driver(device_parent);
                if (str == NULL)
                        str = "";
                printf("    DRIVERS==\"%s\"\n", str);
                print_all_attributes(device_parent, "ATTRS");
        } while (device_parent != NULL);

        return 0;
}

static void print_record(struct udev_device *device) {
        const char *str;
        int i;
        struct udev_list_entry *list_entry;

        printf("P: %s\n", udev_device_get_devpath(device));

        str = udev_device_get_devnode(device);
        if (str != NULL)
                printf("N: %s\n", str + strlen("/dev/"));

        i = udev_device_get_devlink_priority(device);
        if (i != 0)
                printf("L: %i\n", i);

        udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device))
                printf("S: %s\n", udev_list_entry_get_name(list_entry) + strlen("/dev/"));

        udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
                printf("E: %s=%s\n",
                       udev_list_entry_get_name(list_entry),
                       udev_list_entry_get_value(list_entry));
        printf("\n");
}

static int stat_device(const char *name, bool export, const char *prefix) {
        struct stat statbuf;

        if (stat(name, &statbuf) != 0)
                return -1;

        if (export) {
                if (prefix == NULL)
                        prefix = "INFO_";
                printf("%sMAJOR=%d\n"
                       "%sMINOR=%d\n",
                       prefix, major(statbuf.st_dev),
                       prefix, minor(statbuf.st_dev));
        } else
                printf("%d:%d\n", major(statbuf.st_dev), minor(statbuf.st_dev));
        return 0;
}

static int export_devices(struct udev *udev) {
        struct udev_enumerate *udev_enumerate;
        struct udev_list_entry *list_entry;

        udev_enumerate = udev_enumerate_new(udev);
        if (udev_enumerate == NULL)
                return -1;
        udev_enumerate_scan_devices(udev_enumerate);
        udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) {
                struct udev_device *device;

                device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry));
                if (device != NULL) {
                        print_record(device);
                        udev_device_unref(device);
                }
        }
        udev_enumerate_unref(udev_enumerate);
        return 0;
}

static void cleanup_dir(DIR *dir, mode_t mask, int depth) {
        struct dirent *dent;

        if (depth <= 0)
                return;

        for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
                struct stat stats;

                if (dent->d_name[0] == '.')
                        continue;
                if (fstatat(dirfd(dir), dent->d_name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
                        continue;
                if ((stats.st_mode & mask) != 0)
                        continue;
                if (S_ISDIR(stats.st_mode)) {
                        DIR *dir2;

                        dir2 = fdopendir(openat(dirfd(dir), dent->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC));
                        if (dir2 != NULL) {
                                cleanup_dir(dir2, mask, depth-1);
                                closedir(dir2);
                        }
                        unlinkat(dirfd(dir), dent->d_name, AT_REMOVEDIR);
                } else {
                        unlinkat(dirfd(dir), dent->d_name, 0);
                }
        }
}

static void cleanup_db(struct udev *udev) {
        DIR *dir;

        unlink("/run/udev/queue.bin");

        dir = opendir("/run/udev/data");
        if (dir != NULL) {
                cleanup_dir(dir, S_ISVTX, 1);
                closedir(dir);
        }

        dir = opendir("/run/udev/links");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 2);
                closedir(dir);
        }

        dir = opendir("/run/udev/tags");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 2);
                closedir(dir);
        }

        dir = opendir("/run/udev/static_node-tags");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 2);
                closedir(dir);
        }

        dir = opendir("/run/udev/watch");
        if (dir != NULL) {
                cleanup_dir(dir, 0, 1);
                closedir(dir);
        }
}

static int uinfo(struct udev *udev, int argc, char *argv[]) {
        _cleanup_udev_device_unref_ struct udev_device *device = NULL;
        bool root = 0;
        bool export = 0;
        const char *export_prefix = NULL;
        char name[UTIL_PATH_SIZE];
        struct udev_list_entry *list_entry;
        int c;

        static const struct option options[] = {
                { "name",              required_argument, NULL, 'n' },
                { "path",              required_argument, NULL, 'p' },
                { "query",             required_argument, NULL, 'q' },
                { "attribute-walk",    no_argument,       NULL, 'a' },
                { "cleanup-db",        no_argument,       NULL, 'c' },
                { "export-db",         no_argument,       NULL, 'e' },
                { "root",              no_argument,       NULL, 'r' },
                { "device-id-of-file", required_argument, NULL, 'd' },
                { "export",            no_argument,       NULL, 'x' },
                { "export-prefix",     required_argument, NULL, 'P' },
                { "version",           no_argument,       NULL, 'V' },
                { "help",              no_argument,       NULL, 'h' },
                {}
        };

        static const char *usage =
                "Usage: udevadm info [OPTIONS] [DEVPATH|FILE]\n"
                " -q,--query=TYPE             query device information:\n"
                "      name                     name of device node\n"
                "      symlink                  pointing to node\n"
                "      path                     sys device path\n"
                "      property                 the device properties\n"
                "      all                      all values\n"
                " -p,--path=SYSPATH           sys device path used for query or attribute walk\n"
                " -n,--name=NAME              node or symlink name used for query or attribute walk\n"
                " -r,--root                   prepend dev directory to path names\n"
                " -a,--attribute-walk         print all key matches walking along the chain\n"
                "                             of parent devices\n"
                " -d,--device-id-of-file=FILE print major:minor of device containing this file\n"
                " -x,--export                 export key/value pairs\n"
                " -P,--export-prefix          export the key name with a prefix\n"
                " -e,--export-db              export the content of the udev database\n"
                " -c,--cleanup-db             cleanup the udev database\n"
                "    --version                print version of the program\n"
                " -h,--help                   print this message\n";

        enum action_type {
                ACTION_QUERY,
                ACTION_ATTRIBUTE_WALK,
                ACTION_DEVICE_ID_FILE,
        } action = ACTION_QUERY;

        enum query_type {
                QUERY_NAME,
                QUERY_PATH,
                QUERY_SYMLINK,
                QUERY_PROPERTY,
                QUERY_ALL,
        } query = QUERY_ALL;

        while ((c = getopt_long(argc, argv, "aced:n:p:q:rxP:RVh", options, NULL)) >= 0)
                switch (c) {
                case 'n': {
                        if (device != NULL) {
                                fprintf(stderr, "device already specified\n");
                                return 2;
                        }

                        device = find_device(udev, optarg, "/dev/");
                        if (device == NULL) {
                                fprintf(stderr, "device node not found\n");
                                return 2;
                        }
                        break;
                }
                case 'p':
                        if (device != NULL) {
                                fprintf(stderr, "device already specified\n");
                                return 2;
                        }

                        device = find_device(udev, optarg, "/sys");
                        if (device == NULL) {
                                fprintf(stderr, "syspath not found\n");
                                return 2;
                        }
                        break;
                case 'q':
                        action = ACTION_QUERY;
                        if (streq(optarg, "property") || streq(optarg, "env"))
                                query = QUERY_PROPERTY;
                        else if (streq(optarg, "name"))
                                query = QUERY_NAME;
                        else if (streq(optarg, "symlink"))
                                query = QUERY_SYMLINK;
                        else if (streq(optarg, "path"))
                                query = QUERY_PATH;
                        else if (streq(optarg, "all"))
                                query = QUERY_ALL;
                        else {
                                fprintf(stderr, "unknown query type\n");
                                return 3;
                        }
                        break;
                case 'r':
                        root = true;
                        break;
                case 'd':
                        action = ACTION_DEVICE_ID_FILE;
                        strscpy(name, sizeof(name), optarg);
                        break;
                case 'a':
                        action = ACTION_ATTRIBUTE_WALK;
                        break;
                case 'e':
                        export_devices(udev);
                        return 0;
                case 'c':
                        cleanup_db(udev);
                        return 0;
                case 'x':
                        export = true;
                        break;
                case 'P':
                        export_prefix = optarg;
                        break;
                case 'V':
                        printf("%s\n", VERSION);
                        return 0;
                case 'h':
                        printf("%s\n", usage);
                        return 0;
                default:
                        return 1;
                }

        switch (action) {
        case ACTION_QUERY:
                if (!device) {
                        if (!argv[optind]) {
                                fprintf(stderr, "%s\n", usage);
                                return 2;
                        }
                        device = find_device(udev, argv[optind], NULL);
                        if (!device) {
                                fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
                                return 4;
                        }
                }

                switch(query) {
                case QUERY_NAME: {
                        const char *node = udev_device_get_devnode(device);

                        if (node == NULL) {
                                fprintf(stderr, "no device node found\n");
                                return 5;
                        }

                        if (root)
                                printf("%s\n", udev_device_get_devnode(device));
                        else
                                printf("%s\n", udev_device_get_devnode(device) + strlen("/dev/"));
                        break;
                }
                case QUERY_SYMLINK:
                        list_entry = udev_device_get_devlinks_list_entry(device);
                        while (list_entry != NULL) {
                                if (root)
                                        printf("%s", udev_list_entry_get_name(list_entry));
                                else
                                        printf("%s", udev_list_entry_get_name(list_entry) + strlen("/dev/"));
                                list_entry = udev_list_entry_get_next(list_entry);
                                if (list_entry != NULL)
                                        printf(" ");
                        }
                        printf("\n");
                        break;
                case QUERY_PATH:
                        printf("%s\n", udev_device_get_devpath(device));
                        return 0;
                case QUERY_PROPERTY:
                        list_entry = udev_device_get_properties_list_entry(device);
                        while (list_entry != NULL) {
                                if (export) {
                                        const char *prefix = export_prefix;

                                        if (prefix == NULL)
                                                prefix = "";
                                        printf("%s%s='%s'\n", prefix,
                                               udev_list_entry_get_name(list_entry),
                                               udev_list_entry_get_value(list_entry));
                                } else {
                                        printf("%s=%s\n", udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry));
                                }
                                list_entry = udev_list_entry_get_next(list_entry);
                        }
                        break;
                case QUERY_ALL:
                        print_record(device);
                        break;
                default:
                        assert_not_reached("unknown query type");
                }
                break;
        case ACTION_ATTRIBUTE_WALK:
                if (!device && argv[optind]) {
                        device = find_device(udev, argv[optind], NULL);
                        if (!device) {
                                fprintf(stderr, "Unknown device, absolute path in /dev/ or /sys expected.\n");
                                return 4;
                        }
                }
                if (!device) {
                        fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
                        return 4;
                }
                print_device_chain(device);
                break;
        case ACTION_DEVICE_ID_FILE:
                if (stat_device(name, export, export_prefix) != 0)
                        return 1;
                break;
        }

        return 0;
}

const struct udevadm_cmd udevadm_info = {
        .name = "info",
        .cmd = uinfo,
        .help = "query sysfs or the udev database",
};
Commit	Line	Data
be9b51f6	1	/*
1298001e	2	* Copyright (C) 2004-2009 Kay Sievers <kay@vrfy.org>
be9b51f6	3	*
55e9959b KS	4	* This program is free software: you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation, either version 2 of the License, or
	7	* (at your option) any later version.
be9b51f6	8	*
55e9959b KS	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program. If not, see <http://www.gnu.org/licenses/>.
be9b51f6 KS	16	*/
	17
	18	#include <stdlib.h>
	19	#include <string.h>
	20	#include <stdio.h>
1aa1e248	21	#include <stddef.h>
034f35d7	22	#include <ctype.h>
87171e46 KS	23	#include <stdarg.h>
87171e46 KS	24	#include <unistd.h>
1aa1e248	25	#include <dirent.h>
87171e46	26	#include <errno.h>
11f1bb5a	27	#include <getopt.h>
e6c1a2bd	28	#include <fcntl.h>
492e76c9 KS	29	#include <sys/stat.h>
492e76c9 KS	30	#include <sys/types.h>
be9b51f6	31
869fc2f1	32	#include "udev.h"
44433ebd	33	#include "udev-util.h"
d6170d27	34	#include "udevadm-util.h"
be9b51f6	35
9ec6e95b	36	static bool skip_attribute(const char *name) {
46512cd9	37	static const char* const skip[] = {
912541b0 KS	38	"uevent",
	39	"dev",
	40	"modalias",
	41	"resource",
	42	"driver",
	43	"subsystem",
	44	"module",
	45	};
	46	unsigned int i;
	47
8fef0ff2	48	for (i = 0; i < ELEMENTSOF(skip); i++)
090be865	49	if (streq(name, skip[i]))
912541b0 KS	50	return true;
912541b0 KS	51	return false;
20bee04c KS	52	}
20bee04c KS	53
9ec6e95b	54	static void print_all_attributes(struct udev_device device, const char key) {
912541b0 KS	55	struct udev_list_entry *sysattr;
	56
	57	udev_list_entry_foreach(sysattr, udev_device_get_sysattr_list_entry(device)) {
	58	const char *name;
	59	const char *value;
	60	size_t len;
	61
	62	name = udev_list_entry_get_name(sysattr);
	63	if (skip_attribute(name))
	64	continue;
	65
	66	value = udev_device_get_sysattr_value(device, name);
	67	if (value == NULL)
	68	continue;
912541b0 KS	69
	70	/* skip any values that look like a path */
	71	if (value[0] == '/')
	72	continue;
	73
	74	/* skip nonprintable attributes */
	75	len = strlen(value);
	76	while (len > 0 && isprint(value[len-1]))
	77	len--;
baa30fbc	78	if (len > 0)
912541b0	79	continue;
912541b0 KS	80
	81	printf(" %s{%s}==\"%s\"\n", key, name, value);
	82	}
	83	printf("\n");
be9b51f6 KS	84	}
be9b51f6 KS	85
9ec6e95b	86	static int print_device_chain(struct udev_device *device) {
912541b0 KS	87	struct udev_device *device_parent;
	88	const char *str;
	89
	90	printf("\n"
	91	"Udevadm info starts with the device specified by the devpath and then\n"
	92	"walks up the chain of parent devices. It prints for every device\n"
	93	"found, all possible attributes in the udev rules key format.\n"
	94	"A rule to match, can be composed by the attributes of the device\n"
	95	"and the attributes from one single parent device.\n"
	96	"\n");
	97
	98	printf(" looking at device '%s':\n", udev_device_get_devpath(device));
	99	printf(" KERNEL==\"%s\"\n", udev_device_get_sysname(device));
	100	str = udev_device_get_subsystem(device);
	101	if (str == NULL)
	102	str = "";
	103	printf(" SUBSYSTEM==\"%s\"\n", str);
	104	str = udev_device_get_driver(device);
	105	if (str == NULL)
	106	str = "";
	107	printf(" DRIVER==\"%s\"\n", str);
	108	print_all_attributes(device, "ATTR");
	109
	110	device_parent = device;
	111	do {
	112	device_parent = udev_device_get_parent(device_parent);
	113	if (device_parent == NULL)
	114	break;
	115	printf(" looking at parent device '%s':\n", udev_device_get_devpath(device_parent));
	116	printf(" KERNELS==\"%s\"\n", udev_device_get_sysname(device_parent));
	117	str = udev_device_get_subsystem(device_parent);
	118	if (str == NULL)
	119	str = "";
	120	printf(" SUBSYSTEMS==\"%s\"\n", str);
	121	str = udev_device_get_driver(device_parent);
	122	if (str == NULL)
	123	str = "";
	124	printf(" DRIVERS==\"%s\"\n", str);
	125	print_all_attributes(device_parent, "ATTRS");
	126	} while (device_parent != NULL);
	127
	128	return 0;
1aa1e248 KS	129	}
1aa1e248 KS	130
9ec6e95b	131	static void print_record(struct udev_device *device) {
912541b0 KS	132	const char *str;
	133	int i;
	134	struct udev_list_entry *list_entry;
	135
	136	printf("P: %s\n", udev_device_get_devpath(device));
	137
912541b0 KS	138	str = udev_device_get_devnode(device);
912541b0 KS	139	if (str != NULL)
6ada823a	140	printf("N: %s\n", str + strlen("/dev/"));
912541b0 KS	141
	142	i = udev_device_get_devlink_priority(device);
	143	if (i != 0)
	144	printf("L: %i\n", i);
	145
6ada823a KS	146	udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device))
6ada823a KS	147	printf("S: %s\n", udev_list_entry_get_name(list_entry) + strlen("/dev/"));
912541b0 KS	148
	149	udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
	150	printf("E: %s=%s\n",
	151	udev_list_entry_get_name(list_entry),
	152	udev_list_entry_get_value(list_entry));
	153	printf("\n");
31de3a2b KS	154	}
31de3a2b KS	155
9ec6e95b	156	static int stat_device(const char name, bool export, const char prefix) {
912541b0 KS	157	struct stat statbuf;
	158
	159	if (stat(name, &statbuf) != 0)
	160	return -1;
	161
	162	if (export) {
	163	if (prefix == NULL)
	164	prefix = "INFO_";
	165	printf("%sMAJOR=%d\n"
	166	"%sMINOR=%d\n",
	167	prefix, major(statbuf.st_dev),
	168	prefix, minor(statbuf.st_dev));
	169	} else
	170	printf("%d:%d\n", major(statbuf.st_dev), minor(statbuf.st_dev));
	171	return 0;
f338bac8 KS	172	}
f338bac8 KS	173
9ec6e95b	174	static int export_devices(struct udev *udev) {
912541b0 KS	175	struct udev_enumerate *udev_enumerate;
	176	struct udev_list_entry *list_entry;
	177
	178	udev_enumerate = udev_enumerate_new(udev);
	179	if (udev_enumerate == NULL)
	180	return -1;
	181	udev_enumerate_scan_devices(udev_enumerate);
	182	udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) {
	183	struct udev_device *device;
	184
	185	device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry));
	186	if (device != NULL) {
	187	print_record(device);
	188	udev_device_unref(device);
	189	}
	190	}
	191	udev_enumerate_unref(udev_enumerate);
	192	return 0;
bf7ad0ea KS	193	}
bf7ad0ea KS	194
9ec6e95b	195	static void cleanup_dir(DIR *dir, mode_t mask, int depth) {
912541b0 KS	196	struct dirent *dent;
	197
	198	if (depth <= 0)
	199	return;
	200
	201	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
	202	struct stat stats;
	203
	204	if (dent->d_name[0] == '.')
	205	continue;
	206	if (fstatat(dirfd(dir), dent->d_name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
	207	continue;
	208	if ((stats.st_mode & mask) != 0)
	209	continue;
	210	if (S_ISDIR(stats.st_mode)) {
	211	DIR *dir2;
	212
	213	dir2 = fdopendir(openat(dirfd(dir), dent->d_name, O_RDONLY\|O_NONBLOCK\|O_DIRECTORY\|O_CLOEXEC));
	214	if (dir2 != NULL) {
	215	cleanup_dir(dir2, mask, depth-1);
	216	closedir(dir2);
	217	}
	218	unlinkat(dirfd(dir), dent->d_name, AT_REMOVEDIR);
	219	} else {
	220	unlinkat(dirfd(dir), dent->d_name, 0);
	221	}
	222	}
9ead6627 KS	223	}
9ead6627 KS	224
9ec6e95b	225	static void cleanup_db(struct udev *udev) {
912541b0 KS	226	DIR *dir;
912541b0 KS	227
6ada823a	228	unlink("/run/udev/queue.bin");
912541b0	229
6ada823a	230	dir = opendir("/run/udev/data");
912541b0 KS	231	if (dir != NULL) {
	232	cleanup_dir(dir, S_ISVTX, 1);
	233	closedir(dir);
	234	}
	235
6ada823a	236	dir = opendir("/run/udev/links");
912541b0 KS	237	if (dir != NULL) {
	238	cleanup_dir(dir, 0, 2);
	239	closedir(dir);
	240	}
	241
6ada823a	242	dir = opendir("/run/udev/tags");
912541b0 KS	243	if (dir != NULL) {
	244	cleanup_dir(dir, 0, 2);
	245	closedir(dir);
	246	}
	247
84b6ad70 TG	248	dir = opendir("/run/udev/static_node-tags");
	249	if (dir != NULL) {
	250	cleanup_dir(dir, 0, 2);
	251	closedir(dir);
	252	}
	253
6ada823a	254	dir = opendir("/run/udev/watch");
912541b0 KS	255	if (dir != NULL) {
	256	cleanup_dir(dir, 0, 1);
	257	closedir(dir);
	258	}
9ead6627 KS	259	}
9ead6627 KS	260
9ec6e95b	261	static int uinfo(struct udev udev, int argc, char argv[]) {
44433ebd	262	_cleanup_udev_device_unref_ struct udev_device *device = NULL;
912541b0 KS	263	bool root = 0;
	264	bool export = 0;
	265	const char *export_prefix = NULL;
912541b0 KS	266	char name[UTIL_PATH_SIZE];
912541b0 KS	267	struct udev_list_entry *list_entry;
44433ebd	268	int c;
912541b0 KS	269
912541b0 KS	270	static const struct option options[] = {
7643ac9a ZJS	271	{ "name", required_argument, NULL, 'n' },
	272	{ "path", required_argument, NULL, 'p' },
	273	{ "query", required_argument, NULL, 'q' },
	274	{ "attribute-walk", no_argument, NULL, 'a' },
	275	{ "cleanup-db", no_argument, NULL, 'c' },
	276	{ "export-db", no_argument, NULL, 'e' },
	277	{ "root", no_argument, NULL, 'r' },
912541b0	278	{ "device-id-of-file", required_argument, NULL, 'd' },
7643ac9a ZJS	279	{ "export", no_argument, NULL, 'x' },
	280	{ "export-prefix", required_argument, NULL, 'P' },
	281	{ "version", no_argument, NULL, 'V' },
	282	{ "help", no_argument, NULL, 'h' },
912541b0 KS	283	{}
	284	};
	285
4f5d327a	286	static const char *usage =
7643ac9a ZJS	287	"Usage: udevadm info [OPTIONS] [DEVPATH\|FILE]\n"
7643ac9a ZJS	288	" -q,--query=TYPE query device information:\n"
4f5d327a KS	289	" name name of device node\n"
	290	" symlink pointing to node\n"
	291	" path sys device path\n"
	292	" property the device properties\n"
	293	" all all values\n"
7643ac9a ZJS	294	" -p,--path=SYSPATH sys device path used for query or attribute walk\n"
	295	" -n,--name=NAME node or symlink name used for query or attribute walk\n"
	296	" -r,--root prepend dev directory to path names\n"
	297	" -a,--attribute-walk print all key matches walking along the chain\n"
4f5d327a	298	" of parent devices\n"
7643ac9a ZJS	299	" -d,--device-id-of-file=FILE print major:minor of device containing this file\n"
	300	" -x,--export export key/value pairs\n"
	301	" -P,--export-prefix export the key name with a prefix\n"
	302	" -e,--export-db export the content of the udev database\n"
	303	" -c,--cleanup-db cleanup the udev database\n"
	304	" --version print version of the program\n"
	305	" -h,--help print this message\n";
4f5d327a	306
912541b0	307	enum action_type {
912541b0 KS	308	ACTION_QUERY,
912541b0 KS	309	ACTION_ATTRIBUTE_WALK,
912541b0	310	ACTION_DEVICE_ID_FILE,
4f5d327a	311	} action = ACTION_QUERY;
912541b0 KS	312
912541b0 KS	313	enum query_type {
912541b0 KS	314	QUERY_NAME,
	315	QUERY_PATH,
	316	QUERY_SYMLINK,
	317	QUERY_PROPERTY,
	318	QUERY_ALL,
4f5d327a	319	} query = QUERY_ALL;
912541b0	320
7643ac9a ZJS	321	while ((c = getopt_long(argc, argv, "aced:n:p:q:rxP:RVh", options, NULL)) >= 0)
7643ac9a ZJS	322	switch (c) {
4f5d327a	323	case 'n': {
912541b0 KS	324	if (device != NULL) {
912541b0 KS	325	fprintf(stderr, "device already specified\n");
44433ebd	326	return 2;
912541b0	327	}
4f5d327a KS	328
	329	device = find_device(udev, optarg, "/dev/");
	330	if (device == NULL) {
912541b0	331	fprintf(stderr, "device node not found\n");
44433ebd	332	return 2;
912541b0 KS	333	}
912541b0 KS	334	break;
4f5d327a	335	}
912541b0 KS	336	case 'p':
	337	if (device != NULL) {
	338	fprintf(stderr, "device already specified\n");
44433ebd	339	return 2;
912541b0	340	}
4f5d327a KS	341
4f5d327a KS	342	device = find_device(udev, optarg, "/sys");
912541b0	343	if (device == NULL) {
4f5d327a	344	fprintf(stderr, "syspath not found\n");
44433ebd	345	return 2;
912541b0 KS	346	}
	347	break;
	348	case 'q':
	349	action = ACTION_QUERY;
44433ebd	350	if (streq(optarg, "property") \|\| streq(optarg, "env"))
912541b0	351	query = QUERY_PROPERTY;
44433ebd	352	else if (streq(optarg, "name"))
912541b0	353	query = QUERY_NAME;
44433ebd	354	else if (streq(optarg, "symlink"))
912541b0	355	query = QUERY_SYMLINK;
44433ebd	356	else if (streq(optarg, "path"))
912541b0	357	query = QUERY_PATH;
44433ebd	358	else if (streq(optarg, "all"))
912541b0	359	query = QUERY_ALL;
44433ebd	360	else {
912541b0	361	fprintf(stderr, "unknown query type\n");
44433ebd	362	return 3;
912541b0 KS	363	}
	364	break;
	365	case 'r':
912541b0 KS	366	root = true;
912541b0 KS	367	break;
912541b0 KS	368	case 'd':
912541b0 KS	369	action = ACTION_DEVICE_ID_FILE;
d5a89d7d	370	strscpy(name, sizeof(name), optarg);
912541b0 KS	371	break;
	372	case 'a':
	373	action = ACTION_ATTRIBUTE_WALK;
	374	break;
	375	case 'e':
	376	export_devices(udev);
44433ebd	377	return 0;
912541b0 KS	378	case 'c':
912541b0 KS	379	cleanup_db(udev);
44433ebd	380	return 0;
912541b0 KS	381	case 'x':
	382	export = true;
	383	break;
	384	case 'P':
	385	export_prefix = optarg;
	386	break;
	387	case 'V':
	388	printf("%s\n", VERSION);
44433ebd	389	return 0;
912541b0	390	case 'h':
4f5d327a	391	printf("%s\n", usage);
44433ebd	392	return 0;
912541b0	393	default:
44433ebd	394	return 1;
912541b0	395	}
912541b0 KS	396
	397	switch (action) {
	398	case ACTION_QUERY:
4f5d327a KS	399	if (!device) {
	400	if (!argv[optind]) {
	401	fprintf(stderr, "%s\n", usage);
44433ebd	402	return 2;
4f5d327a KS	403	}
	404	device = find_device(udev, argv[optind], NULL);
	405	if (!device) {
	406	fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
44433ebd	407	return 4;
4f5d327a	408	}
912541b0 KS	409	}
	410
	411	switch(query) {
	412	case QUERY_NAME: {
	413	const char *node = udev_device_get_devnode(device);
	414
	415	if (node == NULL) {
	416	fprintf(stderr, "no device node found\n");
44433ebd	417	return 5;
912541b0 KS	418	}
912541b0 KS	419
6ada823a	420	if (root)
912541b0	421	printf("%s\n", udev_device_get_devnode(device));
6ada823a KS	422	else
6ada823a KS	423	printf("%s\n", udev_device_get_devnode(device) + strlen("/dev/"));
912541b0 KS	424	break;
	425	}
	426	case QUERY_SYMLINK:
	427	list_entry = udev_device_get_devlinks_list_entry(device);
	428	while (list_entry != NULL) {
6ada823a	429	if (root)
912541b0	430	printf("%s", udev_list_entry_get_name(list_entry));
6ada823a KS	431	else
6ada823a KS	432	printf("%s", udev_list_entry_get_name(list_entry) + strlen("/dev/"));
912541b0 KS	433	list_entry = udev_list_entry_get_next(list_entry);
	434	if (list_entry != NULL)
	435	printf(" ");
	436	}
	437	printf("\n");
	438	break;
	439	case QUERY_PATH:
	440	printf("%s\n", udev_device_get_devpath(device));
44433ebd	441	return 0;
912541b0 KS	442	case QUERY_PROPERTY:
	443	list_entry = udev_device_get_properties_list_entry(device);
	444	while (list_entry != NULL) {
	445	if (export) {
	446	const char *prefix = export_prefix;
	447
	448	if (prefix == NULL)
	449	prefix = "";
	450	printf("%s%s='%s'\n", prefix,
	451	udev_list_entry_get_name(list_entry),
	452	udev_list_entry_get_value(list_entry));
	453	} else {
	454	printf("%s=%s\n", udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry));
	455	}
	456	list_entry = udev_list_entry_get_next(list_entry);
	457	}
	458	break;
	459	case QUERY_ALL:
	460	print_record(device);
	461	break;
	462	default:
bdd13f6b	463	assert_not_reached("unknown query type");
912541b0 KS	464	}
	465	break;
	466	case ACTION_ATTRIBUTE_WALK:
4f5d327a KS	467	if (!device && argv[optind]) {
	468	device = find_device(udev, argv[optind], NULL);
	469	if (!device) {
	470	fprintf(stderr, "Unknown device, absolute path in /dev/ or /sys expected.\n");
44433ebd	471	return 4;
4f5d327a KS	472	}
	473	}
	474	if (!device) {
	475	fprintf(stderr, "Unknown device, --name=, --path=, or absolute path in /dev/ or /sys expected.\n");
44433ebd	476	return 4;
912541b0 KS	477	}
	478	print_device_chain(device);
	479	break;
	480	case ACTION_DEVICE_ID_FILE:
	481	if (stat_device(name, export, export_prefix) != 0)
44433ebd	482	return 1;
912541b0	483	break;
912541b0	484	}
87171e46	485
44433ebd	486	return 0;
87171e46	487	}
1985c76e KS	488
1985c76e KS	489	const struct udevadm_cmd udevadm_info = {
912541b0 KS	490	.name = "info",
	491	.cmd = uinfo,
	492	.help = "query sysfs or the udev database",
1985c76e	493	};