#include <ctype.h>

#include <net/if.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include "sd-device.h"

#include "alloc-util.h"

#include "chase-symlinks.h"

#include "device-internal.h"

#include "device-private.h"

#include "device-util.h"

#include "dirent-util.h"

#include "fd-util.h"

#include "fileio.h"

#include "format-util.h"

#include "fs-util.h"

#include "hashmap.h"

#include "id128-util.h"

#include "macro.h"

#include "netlink-util.h"

#include "parse-util.h"

#include "path-util.h"

#include "set.h"

#include "socket-util.h"

#include "stat-util.h"

#include "stdio-util.h"

#include "string-util.h"

#include "strv.h"

#include "strxcpyx.h"

#include "user-util.h"

#include "util.h"

int device_new_aux(sd_device **ret) {

sd_device *device;

assert(ret);

device = new(sd_device, 1);

if (!device)

return -ENOMEM;

*device = (sd_device) {

.n_ref = 1,

.watch_handle = -1,

.devmode = MODE_INVALID,

.devuid = UID_INVALID,

.devgid = GID_INVALID,

.action = _SD_DEVICE_ACTION_INVALID,

};

*ret = device;

return 0;

}

static sd_device *device_free(sd_device *device) {

assert(device);

sd_device_unref(device->parent);

free(device->syspath);

free(device->sysname);

free(device->devtype);

free(device->devname);

free(device->subsystem);

free(device->driver_subsystem);

free(device->driver);

free(device->device_id);

free(device->properties_strv);

free(device->properties_nulstr);

ordered_hashmap_free(device->properties);

ordered_hashmap_free(device->properties_db);

hashmap_free(device->sysattr_values);

set_free(device->sysattrs);

set_free(device->all_tags);

set_free(device->current_tags);

set_free(device->devlinks);

return mfree(device);

}

DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_device, sd_device, device_free);

int device_add_property_aux(sd_device *device, const char *key, const char *value, bool db) {

OrderedHashmap **properties;

assert(device);

assert(key);

if (db)

properties = &device->properties_db;

else

properties = &device->properties;

if (value) {

_unused_ _cleanup_free_ char *old_value = NULL;

_cleanup_free_ char *new_key = NULL, *new_value = NULL, *old_key = NULL;

int r;

r = ordered_hashmap_ensure_allocated(properties, &string_hash_ops_free_free);

if (r < 0)

return r;

new_key = strdup(key);

if (!new_key)

return -ENOMEM;

new_value = strdup(value);

if (!new_value)

return -ENOMEM;

old_value = ordered_hashmap_get2(*properties, key, (void**) &old_key);

/* ordered_hashmap_replace() does not fail when the hashmap already has the entry. */

r = ordered_hashmap_replace(*properties, new_key, new_value);

if (r < 0)

return r;

TAKE_PTR(new_key);

TAKE_PTR(new_value);

} else {

_unused_ _cleanup_free_ char *old_value = NULL;

_cleanup_free_ char *old_key = NULL;

old_value = ordered_hashmap_remove2(*properties, key, (void**) &old_key);

}

if (!db) {

device->properties_generation++;

device->properties_buf_outdated = true;

}

return 0;

}

int device_set_syspath(sd_device *device, const char *_syspath, bool verify) {

_cleanup_free_ char *syspath = NULL;

const char *devpath;

int r;

assert(device);

assert(_syspath);

/* must be a subdirectory of /sys */

if (!path_startswith(_syspath, "/sys/"))

return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),

"sd-device: Syspath '%s' is not a subdirectory of /sys",

_syspath);

if (verify) {

r = chase_symlinks(_syspath, NULL, 0, &syspath, NULL);

if (r == -ENOENT)

/* the device does not exist (any more?) */

return log_debug_errno(SYNTHETIC_ERRNO(ENODEV),

"sd-device: Failed to chase symlinks in \"%s\".", _syspath);

if (r < 0)

return log_debug_errno(r, "sd-device: Failed to get target of '%s': %m", _syspath);

if (!path_startswith(syspath, "/sys")) {

_cleanup_free_ char *real_sys = NULL, *new_syspath = NULL;

char *p;

/* /sys is a symlink to somewhere sysfs is mounted on? In that case, we convert the path to real sysfs to "/sys". */

r = chase_symlinks("/sys", NULL, 0, &real_sys, NULL);

if (r < 0)

return log_debug_errno(r, "sd-device: Failed to chase symlink /sys: %m");

p = path_startswith(syspath, real_sys);

if (!p)

return log_debug_errno(SYNTHETIC_ERRNO(ENODEV),

"sd-device: Canonicalized path '%s' does not starts with sysfs mount point '%s'",

syspath, real_sys);

new_syspath = path_join("/sys", p);

if (!new_syspath)

return log_oom_debug();

free_and_replace(syspath, new_syspath);

path_simplify(syspath);

}

if (path_startswith(syspath, "/sys/devices/")) {

char *path;

/* all 'devices' require an 'uevent' file */

path = strjoina(syspath, "/uevent");

if (access(path, F_OK) < 0) {

if (errno == ENOENT)

/* This is not a valid device.

return log_trace_errno(SYNTHETIC_ERRNO(ENODEV),

"sd-device: the uevent file \"%s\" does not exist.", path);

return log_debug_errno(errno, "sd-device: cannot access uevent file for %s: %m", syspath);

}

} else {

/* everything else just needs to be a directory */

if (!is_dir(syspath, false))

return log_debug_errno(SYNTHETIC_ERRNO(ENODEV),

"sd-device: the syspath \"%s\" is not a directory.", syspath);

}

} else {

syspath = strdup(_syspath);

if (!syspath)

return log_oom_debug();

}

devpath = syspath + STRLEN("/sys");

if (devpath[0] != '/')

return log_debug_errno(SYNTHETIC_ERRNO(ENODEV), "sd-device: \"/sys\" alone is not a valid device path.");

r = device_add_property_internal(device, "DEVPATH", devpath);

if (r < 0)

return log_debug_errno(r, "sd-device: Failed to add \"DEVPATH\" property for device \"%s\": %m", syspath);

free_and_replace(device->syspath, syspath);

device->devpath = devpath;

return 0;

}

_public_ int sd_device_new_from_syspath(sd_device **ret, const char *syspath) {

_cleanup_(sd_device_unrefp) sd_device *device = NULL;

int r;

assert_return(ret, -EINVAL);

assert_return(syspath, -EINVAL);

r = device_new_aux(&device);

if (r < 0)

return r;

r = device_set_syspath(device, syspath, true);

if (r < 0)

return r;

*ret = TAKE_PTR(device);

return 0;

}

_public_ int sd_device_new_from_devnum(sd_device **ret, char type, dev_t devnum) {

char id[DECIMAL_STR_MAX(unsigned) * 2 + 1], *syspath;

assert_return(ret, -EINVAL);

assert_return(IN_SET(type, 'b', 'c'), -EINVAL);

if (devnum == 0)

return log_debug_errno(SYNTHETIC_ERRNO(ENODEV),

"sd-device: Attempted to allocate device by zero major/minor, refusing.");

/* use /sys/dev/{block,char}/<maj>:<min> link */

xsprintf(id, "%u:%u", major(devnum), minor(devnum));

syspath = strjoina("/sys/dev/", (type == 'b' ? "block" : "char"), "/", id);

return sd_device_new_from_syspath(ret, syspath);

}

static int device_new_from_main_ifname(sd_device **ret, const char *ifname) {

const char *syspath;

assert(ret);

assert(ifname);

syspath = strjoina("/sys/class/net/", ifname);

return sd_device_new_from_syspath(ret, syspath);

}

_public_ int sd_device_new_from_ifname(sd_device **ret, const char *ifname) {

_cleanup_free_ char *main_name = NULL;

int r;

assert_return(ret, -EINVAL);

assert_return(ifname, -EINVAL);

r = parse_ifindex(ifname);

if (r > 0)

return sd_device_new_from_ifindex(ret, r);

if (ifname_valid(ifname)) {

r = device_new_from_main_ifname(ret, ifname);

if (r >= 0)

return r;

}

r = rtnl_resolve_link_alternative_name(NULL, ifname, &main_name);

if (r < 0)

return r;

return device_new_from_main_ifname(ret, main_name);

}

_public_ int sd_device_new_from_ifindex(sd_device **ret, int ifindex) {

char ifname[IF_NAMESIZE];

assert_return(ret, -EINVAL);

assert_return(ifindex > 0, -EINVAL);

if (format_ifname(ifindex, ifname) < 0)

return -ENODEV;

return device_new_from_main_ifname(ret, ifname);

}

static int device_strjoin_new(

sd_device **ret) {

const char *p;

int r;

p = strjoina(a, b, c, d);

if (access(p, F_OK) < 0)

return IN_SET(errno, ENOENT, ENAMETOOLONG) ? 0 : -errno; /* If this sysfs is too long then it doesn't exist either */

r = sd_device_new_from_syspath(ret, p);

if (r < 0)

return r;

return 1;

}

_public_ int sd_device_new_from_subsystem_sysname(

sd_device **ret,

const char *subsystem,

const char *sysname) {

char *name;

int r;

assert_return(ret, -EINVAL);

assert_return(path_is_normalized(subsystem), -EINVAL);

assert_return(path_is_normalized(sysname), -EINVAL);

if (streq(subsystem, "subsystem")) {

FOREACH_STRING(s, "/sys/bus/", "/sys/class/") {

r = device_strjoin_new(s, sysname, NULL, NULL, ret);

if (r < 0)

return r;

if (r > 0)

return 0;

}

} else if (streq(subsystem, "module")) {

r = device_strjoin_new("/sys/module/", sysname, NULL, NULL, ret);

if (r < 0)

return r;

if (r > 0)

return 0;

} else if (streq(subsystem, "drivers")) {

const char *sep;

sep = strchr(sysname, ':');

if (sep && sep[1] != '\0') { /* Require ":" and something non-empty after that. */

const char *subsys = memdupa_suffix0(sysname, sep - sysname);

sep++;

r = device_strjoin_new("/sys/bus/", subsys, "/drivers/", sep, ret);

if (r < 0)

return r;

if (r > 0)

return 0;

}

}

/* translate sysname back to sysfs filename */

name = strdupa_safe(sysname);

for (size_t i = 0; name[i]; i++)

if (name[i] == '/')

name[i] = '!';

r = device_strjoin_new("/sys/bus/", subsystem, "/devices/", name, ret);

if (r < 0)

return r;

if (r > 0)

return 0;

r = device_strjoin_new("/sys/class/", subsystem, "/", name, ret);

if (r < 0)

return r;

if (r > 0)

return 0;

r = device_strjoin_new("/sys/firmware/", subsystem, "/", sysname, ret);

if (r < 0)

return r;

if (r > 0)

return 0;

return -ENODEV;

}

_public_ int sd_device_new_from_stat_rdev(sd_device **ret, const struct stat *st) {

char type;

assert_return(ret, -EINVAL);

assert_return(st, -EINVAL);

if (S_ISBLK(st->st_mode))

type = 'b';

else if (S_ISCHR(st->st_mode))

type = 'c';

else

return -ENOTTY;

return sd_device_new_from_devnum(ret, type, st->st_rdev);

}

_public_ int sd_device_new_from_devname(sd_device **ret, const char *devname) {

struct stat st;

assert_return(ret, -EINVAL);

assert_return(devname, -EINVAL);

/* This function actually accepts both devlinks and devnames, i.e. both symlinks and device

/* Also ignore when the specified path is "/dev". */

if (isempty(path_startswith(devname, "/dev")))

return -EINVAL;

if (device_path_parse_major_minor(devname, NULL, NULL) >= 0) {

_cleanup_free_ char *syspath = NULL;

/* Let's shortcut when "/dev/block/maj:min" or "/dev/char/maj:min" is specified.

syspath = path_join("/sys", devname);

return sd_device_new_from_syspath(ret, syspath);

}

if (stat(devname, &st) < 0)

return ERRNO_IS_DEVICE_ABSENT(errno) ? -ENODEV : -errno;

return sd_device_new_from_stat_rdev(ret, &st);

}

_public_ int sd_device_new_from_path(sd_device **ret, const char *path) {

assert_return(ret, -EINVAL);

assert_return(path, -EINVAL);

if (path_startswith(path, "/dev"))

return sd_device_new_from_devname(ret, path);

return sd_device_new_from_syspath(ret, path);

}

int device_set_devtype(sd_device *device, const char *devtype) {

_cleanup_free_ char *t = NULL;

int r;

assert(device);

assert(devtype);

t = strdup(devtype);

if (!t)

return -ENOMEM;

r = device_add_property_internal(device, "DEVTYPE", t);

if (r < 0)

return r;

return free_and_replace(device->devtype, t);

}

int device_set_ifindex(sd_device *device, const char *name) {

int r, ifindex;

assert(device);

assert(name);

ifindex = parse_ifindex(name);

if (ifindex < 0)

return ifindex;

r = device_add_property_internal(device, "IFINDEX", name);

if (r < 0)

return r;

device->ifindex = ifindex;

return 0;

}

int device_set_devname(sd_device *device, const char *devname) {

_cleanup_free_ char *t = NULL;

int r;

assert(device);

assert(devname);

if (devname[0] != '/')

t = strjoin("/dev/", devname);

else

t = strdup(devname);

if (!t)

return -ENOMEM;

r = device_add_property_internal(device, "DEVNAME", t);

if (r < 0)

return r;

return free_and_replace(device->devname, t);

}

int device_set_devmode(sd_device *device, const char *_devmode) {

unsigned devmode;

int r;

assert(device);

assert(_devmode);

r = safe_atou(_devmode, &devmode);

if (r < 0)

return r;

if (devmode > 07777)

return -EINVAL;

r = device_add_property_internal(device, "DEVMODE", _devmode);

if (r < 0)

return r;

device->devmode = devmode;

return 0;

}

int device_set_devnum(sd_device *device, const char *major, const char *minor) {

unsigned maj, min = 0;

int r;

assert(device);

assert(major);

r = safe_atou(major, &maj);

if (r < 0)

return r;

if (maj == 0)

return 0;

if (minor) {

r = safe_atou(minor, &min);

if (r < 0)

return r;

}

r = device_add_property_internal(device, "MAJOR", major);

if (r < 0)

return r;

if (minor) {

r = device_add_property_internal(device, "MINOR", minor);

if (r < 0)

return r;

}

device->devnum = makedev(maj, min);

return 0;

}

static int handle_uevent_line(sd_device *device, const char *key, const char *value, const char **major, const char **minor) {

int r;

assert(device);

assert(key);

assert(value);

assert(major);

assert(minor);

if (streq(key, "DEVTYPE")) {

r = device_set_devtype(device, value);

if (r < 0)

return r;

} else if (streq(key, "IFINDEX")) {

r = device_set_ifindex(device, value);

if (r < 0)

return r;

} else if (streq(key, "DEVNAME")) {

r = device_set_devname(device, value);

if (r < 0)

return r;

} else if (streq(key, "DEVMODE")) {

r = device_set_devmode(device, value);

if (r < 0)

return r;

} else if (streq(key, "MAJOR"))

*major = value;

else if (streq(key, "MINOR"))

*minor = value;

else {

r = device_add_property_internal(device, key, value);

if (r < 0)

return r;

}

return 0;

}

int device_read_uevent_file(sd_device *device) {

_cleanup_free_ char *uevent = NULL;

const char *syspath, *key = NULL, *value = NULL, *major = NULL, *minor = NULL;

char *path;

size_t uevent_len;

int r;

enum {

PRE_KEY,

KEY,

PRE_VALUE,

VALUE,

INVALID_LINE,

} state = PRE_KEY;

assert(device);

if (device->uevent_loaded || device->sealed)

return 0;

r = sd_device_get_syspath(device, &syspath);

if (r < 0)

return r;

device->uevent_loaded = true;

path = strjoina(syspath, "/uevent");

r = read_full_virtual_file(path, &uevent, &uevent_len);

if (IN_SET(r, -EACCES, -ENOENT))

/* The uevent files may be write-only, or the device may not have uevent file. */

return 0;

if (r < 0)

return log_device_debug_errno(device, r, "sd-device: Failed to read uevent file '%s': %m", path);

for (size_t i = 0; i < uevent_len; i++)

switch (state) {

case PRE_KEY:

if (!strchr(NEWLINE, uevent[i])) {

key = &uevent[i];

state = KEY;

}

break;

case KEY:

if (uevent[i] == '=') {

uevent[i] = '\0';

state = PRE_VALUE;

} else if (strchr(NEWLINE, uevent[i])) {

uevent[i] = '\0';

log_device_debug(device, "sd-device: Invalid uevent line '%s', ignoring", key);

state = PRE_KEY;

}

break;

case PRE_VALUE:

value = &uevent[i];

state = VALUE;

_fallthrough_; /* to handle empty property */

case VALUE:

if (strchr(NEWLINE, uevent[i])) {

uevent[i] = '\0';

r = handle_uevent_line(device, key, value, &major, &minor);

if (r < 0)

log_device_debug_errno(device, r, "sd-device: Failed to handle uevent entry '%s=%s', ignoring: %m", key, value);

state = PRE_KEY;

}

break;

default:

assert_not_reached();

}

if (major) {

r = device_set_devnum(device, major, minor);

if (r < 0)

log_device_debug_errno(device, r, "sd-device: Failed to set 'MAJOR=%s' or 'MINOR=%s' from '%s', ignoring: %m", major, minor, path);

}

return 0;

}

_public_ int sd_device_get_ifindex(sd_device *device, int *ifindex) {

int r;

assert_return(device, -EINVAL);

r = device_read_uevent_file(device);

if (r < 0)

return r;

if (device->ifindex <= 0)

return -ENOENT;

if (ifindex)

*ifindex = device->ifindex;

return 0;

}

_public_ int sd_device_new_from_device_id(sd_device **ret, const char *id) {

int r;

assert_return(ret, -EINVAL);

assert_return(id, -EINVAL);

switch (id[0]) {

case 'b':

case 'c': {

dev_t devt;

if (isempty(id))

return -EINVAL;

r = parse_dev(id + 1, &devt);

if (r < 0)

return r;

return sd_device_new_from_devnum(ret, id[0], devt);

}

case 'n': {

int ifindex;

ifindex = parse_ifindex(id + 1);

if (ifindex < 0)

return ifindex;

return sd_device_new_from_ifindex(ret, ifindex);

}

case '+': {

const char *subsys, *sep;

sep = strchr(id + 1, ':');

if (!sep || sep - id - 1 > NAME_MAX)

return -EINVAL;

subsys = memdupa_suffix0(id + 1, sep - id - 1);

return sd_device_new_from_subsystem_sysname(ret, subsys, sep + 1);

}

default:

return -EINVAL;

}

}

_public_ int sd_device_get_syspath(sd_device *device, const char **ret) {

assert_return(device, -EINVAL);

assert(path_startswith(device->syspath, "/sys/"));

if (ret)

*ret = device->syspath;

return 0;

}

static int device_new_from_child(sd_device **ret, sd_device *child) {

_cleanup_free_ char *path = NULL;

const char *syspath;

int r;

assert(ret);

assert(child);

r = sd_device_get_syspath(child, &syspath);

if (r < 0)

return r;

for (;;) {

_cleanup_free_ char *p = NULL;

r = path_extract_directory(path ?: syspath, &p);

if (r < 0)

return r;

if (path_equal(p, "/sys"))

return -ENODEV;

r = sd_device_new_from_syspath(ret, p);

if (r != -ENODEV)

return r;

free_and_replace(path, p);

}

}

_public_ int sd_device_get_parent(sd_device *child, sd_device **ret) {

int r;

assert_return(child, -EINVAL);

if (!child->parent_set) {

r = device_new_from_child(&child->parent, child);

if (r < 0 && r != -ENODEV)

return r;

child->parent_set = true;

}

if (!child->parent)

return -ENOENT;

if (ret)

*ret = child->parent;

return 0;

}

int device_set_subsystem(sd_device *device, const char *subsystem) {

_cleanup_free_ char *s = NULL;

int r;

assert(device);

if (subsystem) {

s = strdup(subsystem);

if (!s)

return -ENOMEM;

}

r = device_add_property_internal(device, "SUBSYSTEM", s);

if (r < 0)

return r;

device->subsystem_set = true;

return free_and_replace(device->subsystem, s);

}

int device_set_drivers_subsystem(sd_device *device) {

_cleanup_free_ char *subsystem = NULL;

const char *devpath, *drivers, *p;

int r;

assert(device);

r = sd_device_get_devpath(device, &devpath);

if (r < 0)

return r;

drivers = strstr(devpath, "/drivers/");

if (!drivers)

return -EINVAL;

r = path_find_last_component(devpath, false, &drivers, &p);

if (r < 0)

return r;

if (r == 0)

return -EINVAL;

subsystem = strndup(p, r);

if (!subsystem)

return -ENOMEM;

r = device_set_subsystem(device, "drivers");

if (r < 0)

return r;

return free_and_replace(device->driver_subsystem, subsystem);

}

_public_ int sd_device_get_subsystem(sd_device *device, const char **ret) {

int r;

assert_return(device, -EINVAL);

if (!device->subsystem_set) {

_cleanup_free_ char *subsystem = NULL;

const char *syspath;

char *path;

r = sd_device_get_syspath(device, &syspath);

if (r < 0)

return r;

/* read 'subsystem' link */

path = strjoina(syspath, "/subsystem");

r = readlink_value(path, &subsystem);

if (r < 0 && r != -ENOENT)

return log_device_debug_errno(device, r,

"sd-device: Failed to read subsystem for %s: %m",

device->devpath);

if (subsystem)

r = device_set_subsystem(device, subsystem);

/* use implicit names */

else if (path_startswith(device->devpath, "/module/"))

r = device_set_subsystem(device, "module");

else if (strstr(syspath, "/drivers/"))

r = device_set_drivers_subsystem(device);

else if (PATH_STARTSWITH_SET(device->devpath, "/class/", "/bus/"))

r = device_set_subsystem(device, "subsystem");

else {

device->subsystem_set = true;

r = 0;

}

if (r < 0)

return log_device_debug_errno(device, r,

"sd-device: Failed to set subsystem for %s: %m",

device->devpath);

}

if (!device->subsystem)

return -ENOENT;

if (ret)

*ret = device->subsystem;

return 0;

}

_public_ int sd_device_get_devtype(sd_device *device, const char **devtype) {

int r;

assert_return(device, -EINVAL);

r = device_read_uevent_file(device);

if (r < 0)

return r;

if (!device->devtype)

return -ENOENT;

if (devtype)

*devtype = device->devtype;

return !!device->devtype;

}

_public_ int sd_device_get_parent_with_subsystem_devtype(sd_device *child, const char *subsystem, const char *devtype, sd_device **ret) {

sd_device *parent = NULL;

int r;

assert_return(child, -EINVAL);

assert_return(subsystem, -EINVAL);

r = sd_device_get_parent(child, &parent);

while (r >= 0) {

const char *parent_subsystem = NULL;

(void) sd_device_get_subsystem(parent, &parent_subsystem);

if (streq_ptr(parent_subsystem, subsystem)) {

const char *parent_devtype = NULL;

if (!devtype)

break;

(void) sd_device_get_devtype(parent, &parent_devtype);

if (streq_ptr(parent_devtype, devtype))

break;

}

r = sd_device_get_parent(parent, &parent);

}

if (r < 0)

return r;

if (ret)

*ret = parent;

return 0;

}

_public_ int sd_device_get_devnum(sd_device *device, dev_t *devnum) {

int r;

assert_return(device, -EINVAL);

r = device_read_uevent_file(device);

if (r < 0)

return r;

if (major(device->devnum) <= 0)

return -ENOENT;

if (devnum)

*devnum = device->devnum;

return 0;

}

int device_set_driver(sd_device *device, const char *driver) {

_cleanup_free_ char *d = NULL;

int r;