[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 <string.h>
#include <stdio.h>
#include <stddef.h>
#include <ctype.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/stat.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=%u\n"
                       "%sMINOR=%u\n",
                       prefix, major(statbuf.st_dev),
                       prefix, minor(statbuf.st_dev));
        } else
                printf("%u:%u\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 void help(void) {

        printf("%s info [OPTIONS] [DEVPATH|FILE]\n\n"
               "Query sysfs or the udev database.\n\n"
               "  -h --help                   Print this message\n"
               "     --version                Print version of the program\n"
               "  -q --query=TYPE             Query device information:\n"
               "       name                     Name of device node\n"
               "       symlink                  Pointing to node\n"
               "       path                     sysfs device path\n"
               "       property                 The device properties\n"
               "       all                      All values\n"
               "  -p --path=SYSPATH           sysfs 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             Clean up the udev database\n"
               , program_invocation_short_name);
}

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' },
                {}
        };

        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':
                        help();
                        return 0;
                default:
                        return 1;
                }

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