[thirdparty/systemd.git] / src / udev / libudev-util-private.c

/*
 * libudev - interface to udev device information
 *
 * Copyright (C) 2003-2009 Kay Sievers <kay.sievers@vrfy.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 */

#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <pwd.h>
#include <grp.h>
#include <sys/param.h>

#include "libudev.h"
#include "libudev-private.h"

static int create_path(struct udev *udev, const char *path, bool selinux)
{
        char p[UTIL_PATH_SIZE];
        char *pos;
        struct stat stats;
        int err;

        util_strscpy(p, sizeof(p), path);
        pos = strrchr(p, '/');
        if (pos == NULL)
                return 0;
        while (pos != p && pos[-1] == '/')
                pos--;
        if (pos == p)
                return 0;
        pos[0] = '\0';

        dbg(udev, "stat '%s'\n", p);
        if (stat(p, &stats) == 0) {
                if ((stats.st_mode & S_IFMT) == S_IFDIR)
                        return 0;
                else
                        return -ENOTDIR;
        }

        err = util_create_path(udev, p);
        if (err != 0)
                return err;

        dbg(udev, "mkdir '%s'\n", p);
        if (selinux)
                udev_selinux_setfscreatecon(udev, p, S_IFDIR|0755);
        err = mkdir(p, 0755);
        if (err != 0) {
                err = -errno;
                if (err == -EEXIST && stat(p, &stats) == 0) {
                        if ((stats.st_mode & S_IFMT) == S_IFDIR)
                                err = 0;
                        else
                                err = -ENOTDIR;
                }
        }
        if (selinux)
                udev_selinux_resetfscreatecon(udev);
        return err;
}

int util_create_path(struct udev *udev, const char *path)
{
        return create_path(udev, path, false);
}

int util_create_path_selinux(struct udev *udev, const char *path)
{
        return create_path(udev, path, true);
}

int util_delete_path(struct udev *udev, const char *path)
{
        char p[UTIL_PATH_SIZE];
        char *pos;
        int err = 0;

        if (path[0] == '/')
                while(path[1] == '/')
                        path++;
        util_strscpy(p, sizeof(p), path);
        pos = strrchr(p, '/');
        if (pos == p || pos == NULL)
                return 0;

        for (;;) {
                *pos = '\0';
                pos = strrchr(p, '/');

                /* don't remove the last one */
                if ((pos == p) || (pos == NULL))
                        break;

                err = rmdir(p);
                if (err < 0) {
                        if (errno == ENOENT)
                                err = 0;
                        break;
                }
        }
        return err;
}

uid_t util_lookup_user(struct udev *udev, const char *user)
{
        char *endptr;
        size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
        char buf[buflen];
        struct passwd pwbuf;
        struct passwd *pw;
        uid_t uid;

        if (strcmp(user, "root") == 0)
                return 0;
        uid = strtoul(user, &endptr, 10);
        if (endptr[0] == '\0')
                return uid;

        errno = getpwnam_r(user, &pwbuf, buf, buflen, &pw);
        if (pw != NULL)
                return pw->pw_uid;
        if (errno == 0 || errno == ENOENT || errno == ESRCH)
                err(udev, "specified user '%s' unknown\n", user);
        else
                err(udev, "error resolving user '%s': %m\n", user);
        return 0;
}

gid_t util_lookup_group(struct udev *udev, const char *group)
{
        char *endptr;
        size_t buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
        char *buf;
        struct group grbuf;
        struct group *gr;
        gid_t gid = 0;

        if (strcmp(group, "root") == 0)
                return 0;
        gid = strtoul(group, &endptr, 10);
        if (endptr[0] == '\0')
                return gid;
        buf = NULL;
        gid = 0;
        for (;;) {
                char *newbuf;

                newbuf = realloc(buf, buflen);
                if (!newbuf)
                        break;
                buf = newbuf;
                errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
                if (gr != NULL) {
                        gid = gr->gr_gid;
                } else if (errno == ERANGE) {
                        buflen *= 2;
                        continue;
                } else if (errno == 0 || errno == ENOENT || errno == ESRCH) {
                        err(udev, "specified group '%s' unknown\n", group);
                } else {
                        err(udev, "error resolving group '%s': %m\n", group);
                }
                break;
        }
        free(buf);
        return gid;
}

/* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
int util_resolve_subsys_kernel(struct udev *udev, const char *string,
                               char *result, size_t maxsize, int read_value)
{
        char temp[UTIL_PATH_SIZE];
        char *subsys;
        char *sysname;
        struct udev_device *dev;
        char *attr;

        if (string[0] != '[')
                return -1;

        util_strscpy(temp, sizeof(temp), string);

        subsys = &temp[1];

        sysname = strchr(subsys, '/');
        if (sysname == NULL)
                return -1;
        sysname[0] = '\0';
        sysname = &sysname[1];

        attr = strchr(sysname, ']');
        if (attr == NULL)
                return -1;
        attr[0] = '\0';
        attr = &attr[1];
        if (attr[0] == '/')
                attr = &attr[1];
        if (attr[0] == '\0')
                attr = NULL;

        if (read_value && attr == NULL)
                return -1;

        dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
        if (dev == NULL)
                return -1;

        if (read_value) {
                const char *val;

                val = udev_device_get_sysattr_value(dev, attr);
                if (val != NULL)
                        util_strscpy(result, maxsize, val);
                else
                        result[0] = '\0';
                info(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
        } else {
                size_t l;
                char *s;

                s = result;
                l = util_strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
                if (attr != NULL)
                        util_strpcpyl(&s, l, "/", attr, NULL);
                info(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
        }
        udev_device_unref(dev);
        return 0;
}
Commit	Line	Data
c81b35c0	1	/*
44b49d37	2	* libudev - interface to udev device information
c81b35c0	3	*
fc206fbe	4	* Copyright (C) 2003-2009 Kay Sievers <kay.sievers@vrfy.org>
c81b35c0	5	*
44b49d37 KS	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
c81b35c0 KS	10	*/
c81b35c0 KS	11
c81b35c0 KS	12	#include <stdlib.h>
c81b35c0 KS	13	#include <stdio.h>
4a539daf	14	#include <stddef.h>
c81b35c0	15	#include <unistd.h>
01618658	16	#include <string.h>
c81b35c0	17	#include <fcntl.h>
4a539daf	18	#include <errno.h>
9f8dfa19	19	#include <ctype.h>
3a020a85 KS	20	#include <pwd.h>
3a020a85 KS	21	#include <grp.h>
257bb4cd	22	#include <sys/param.h>
c81b35c0	23
44b49d37 KS	24	#include "libudev.h"
44b49d37 KS	25	#include "libudev-private.h"
c81b35c0	26
51f43b53	27	static int create_path(struct udev udev, const char path, bool selinux)
4a539daf	28	{
912541b0 KS	29	char p[UTIL_PATH_SIZE];
	30	char *pos;
	31	struct stat stats;
	32	int err;
	33
	34	util_strscpy(p, sizeof(p), path);
	35	pos = strrchr(p, '/');
	36	if (pos == NULL)
	37	return 0;
	38	while (pos != p && pos[-1] == '/')
	39	pos--;
	40	if (pos == p)
	41	return 0;
	42	pos[0] = '\0';
	43
	44	dbg(udev, "stat '%s'\n", p);
	45	if (stat(p, &stats) == 0) {
	46	if ((stats.st_mode & S_IFMT) == S_IFDIR)
	47	return 0;
	48	else
	49	return -ENOTDIR;
	50	}
	51
	52	err = util_create_path(udev, p);
	53	if (err != 0)
	54	return err;
	55
	56	dbg(udev, "mkdir '%s'\n", p);
	57	if (selinux)
	58	udev_selinux_setfscreatecon(udev, p, S_IFDIR\|0755);
	59	err = mkdir(p, 0755);
	60	if (err != 0) {
	61	err = -errno;
	62	if (err == -EEXIST && stat(p, &stats) == 0) {
	63	if ((stats.st_mode & S_IFMT) == S_IFDIR)
	64	err = 0;
	65	else
	66	err = -ENOTDIR;
	67	}
	68	}
	69	if (selinux)
	70	udev_selinux_resetfscreatecon(udev);
	71	return err;
a390e6f7	72	}
4a539daf	73
51f43b53 KS	74	int util_create_path(struct udev udev, const char path)
51f43b53 KS	75	{
912541b0	76	return create_path(udev, path, false);
51f43b53 KS	77	}
	78
	79	int util_create_path_selinux(struct udev udev, const char path)
	80	{
912541b0	81	return create_path(udev, path, true);
51f43b53 KS	82	}
51f43b53 KS	83
54808d77	84	int util_delete_path(struct udev udev, const char path)
a390e6f7	85	{
912541b0 KS	86	char p[UTIL_PATH_SIZE];
	87	char *pos;
	88	int err = 0;
	89
	90	if (path[0] == '/')
	91	while(path[1] == '/')
	92	path++;
	93	util_strscpy(p, sizeof(p), path);
	94	pos = strrchr(p, '/');
	95	if (pos == p \|\| pos == NULL)
	96	return 0;
	97
	98	for (;;) {
	99	*pos = '\0';
	100	pos = strrchr(p, '/');
	101
	102	/* don't remove the last one */
	103	if ((pos == p) \|\| (pos == NULL))
	104	break;
	105
	106	err = rmdir(p);
	107	if (err < 0) {
	108	if (errno == ENOENT)
	109	err = 0;
	110	break;
	111	}
	112	}
	113	return err;
b8476286 KS	114	}
b8476286 KS	115
54808d77	116	uid_t util_lookup_user(struct udev udev, const char user)
3a020a85	117	{
912541b0 KS	118	char *endptr;
	119	size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
	120	char buf[buflen];
	121	struct passwd pwbuf;
	122	struct passwd *pw;
	123	uid_t uid;
	124
	125	if (strcmp(user, "root") == 0)
	126	return 0;
	127	uid = strtoul(user, &endptr, 10);
	128	if (endptr[0] == '\0')
	129	return uid;
	130
	131	errno = getpwnam_r(user, &pwbuf, buf, buflen, &pw);
	132	if (pw != NULL)
	133	return pw->pw_uid;
	134	if (errno == 0 \|\| errno == ENOENT \|\| errno == ESRCH)
	135	err(udev, "specified user '%s' unknown\n", user);
	136	else
	137	err(udev, "error resolving user '%s': %m\n", user);
	138	return 0;
90024521	139	}
3a020a85	140
37ed4f56	141	gid_t util_lookup_group(struct udev udev, const char group)
90024521	142	{
912541b0 KS	143	char *endptr;
	144	size_t buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
	145	char *buf;
	146	struct group grbuf;
	147	struct group *gr;
	148	gid_t gid = 0;
	149
	150	if (strcmp(group, "root") == 0)
	151	return 0;
	152	gid = strtoul(group, &endptr, 10);
	153	if (endptr[0] == '\0')
	154	return gid;
	155	buf = NULL;
	156	gid = 0;
	157	for (;;) {
	158	char *newbuf;
	159
	160	newbuf = realloc(buf, buflen);
	161	if (!newbuf)
	162	break;
	163	buf = newbuf;
	164	errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
	165	if (gr != NULL) {
	166	gid = gr->gr_gid;
	167	} else if (errno == ERANGE) {
	168	buflen *= 2;
	169	continue;
	170	} else if (errno == 0 \|\| errno == ENOENT \|\| errno == ESRCH) {
	171	err(udev, "specified group '%s' unknown\n", group);
	172	} else {
	173	err(udev, "error resolving group '%s': %m\n", group);
	174	}
	175	break;
	176	}
	177	free(buf);
	178	return gid;
90024521	179	}
d0db192f	180
14f40256 KS	181	/* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
14f40256 KS	182	int util_resolve_subsys_kernel(struct udev udev, const char string,
912541b0	183	char *result, size_t maxsize, int read_value)
14f40256	184	{
912541b0 KS	185	char temp[UTIL_PATH_SIZE];
	186	char *subsys;
	187	char *sysname;
	188	struct udev_device *dev;
	189	char *attr;
	190
	191	if (string[0] != '[')
	192	return -1;
	193
	194	util_strscpy(temp, sizeof(temp), string);
	195
	196	subsys = &temp[1];
	197
	198	sysname = strchr(subsys, '/');
	199	if (sysname == NULL)
	200	return -1;
	201	sysname[0] = '\0';
	202	sysname = &sysname[1];
	203
	204	attr = strchr(sysname, ']');
	205	if (attr == NULL)
	206	return -1;
	207	attr[0] = '\0';
	208	attr = &attr[1];
	209	if (attr[0] == '/')
	210	attr = &attr[1];
	211	if (attr[0] == '\0')
	212	attr = NULL;
	213
	214	if (read_value && attr == NULL)
	215	return -1;
	216
	217	dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
	218	if (dev == NULL)
	219	return -1;
	220
	221	if (read_value) {
	222	const char *val;
	223
	224	val = udev_device_get_sysattr_value(dev, attr);
	225	if (val != NULL)
	226	util_strscpy(result, maxsize, val);
	227	else
	228	result[0] = '\0';
	229	info(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
	230	} else {
	231	size_t l;
	232	char *s;
	233
	234	s = result;
	235	l = util_strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
	236	if (attr != NULL)
	237	util_strpcpyl(&s, l, "/", attr, NULL);
	238	info(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
	239	}
	240	udev_device_unref(dev);
	241	return 0;
14f40256	242	}