picnoir
/
Systemd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #10787 from yuwata/libudev-cleanups 

libudev: drop unused private functions
This commit is contained in:
Zbigniew Jędrzejewski-Szmek 2018-11-20 10:42:19 +01:00 committed by GitHub
parent 278939be7a f921b457a7
commit 4874191d9d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 164 additions and 642 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libudev/libudev-device-internal.h
View File

@ -4,7 +4,7 @@
#include "libudev.h"
#include "sd-device.h"
#include "libudev-private.h"
#include "libudev-list-internal.h"
/**
* udev_device:

375
src/libudev/libudev-device-private.c
View File

@ -1,375 +0,0 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#include "libudev.h"
#include "device-private.h"
#include "libudev-device-internal.h"
#include "libudev-private.h"
int udev_device_tag_index(struct udev_device *udev_device, struct udev_device *udev_device_old, bool add) {
sd_device *device_old = NULL;
int r;
assert(udev_device);
if (udev_device_old)
device_old = udev_device_old->device;
r = device_tag_index(udev_device->device, device_old, add);
if (r < 0)
return r;
return 0;
}
int udev_device_update_db(struct udev_device *udev_device) {
int r;
assert(udev_device);
r = device_update_db(udev_device->device);
if (r < 0)
return r;
return 0;
}
int udev_device_delete_db(struct udev_device *udev_device) {
int r;
assert(udev_device);
r = device_delete_db(udev_device->device);
if (r < 0)
return r;
return 0;
}
int udev_device_get_ifindex(struct udev_device *udev_device) {
int r, ifindex;
assert(udev_device);
r = sd_device_get_ifindex(udev_device->device, &ifindex);
if (r == -ENOENT)
return 0;
if (r < 0)
return r;
return ifindex;
}
const char *udev_device_get_devpath_old(struct udev_device *udev_device) {
const char *devpath_old = NULL;
int r;
assert(udev_device);
r = sd_device_get_property_value(udev_device->device, "DEVPATH_OLD", &devpath_old);
if (r < 0 && r != -ENOENT) {
errno = -r;
return NULL;
}
return devpath_old;
}
mode_t udev_device_get_devnode_mode(struct udev_device *udev_device) {
mode_t mode;
int r;
assert(udev_device);
r = device_get_devnode_mode(udev_device->device, &mode);
if (r < 0) {
errno = -r;
return 0;
}
return mode;
}
uid_t udev_device_get_devnode_uid(struct udev_device *udev_device) {
uid_t uid;
int r;
assert(udev_device);
r = device_get_devnode_uid(udev_device->device, &uid);
if (r < 0) {
errno = -r;
return 0;
}
return uid;
}
gid_t udev_device_get_devnode_gid(struct udev_device *udev_device) {
gid_t gid;
int r;
assert(udev_device);
r = device_get_devnode_gid(udev_device->device, &gid);
if (r < 0) {
errno = -r;
return 0;
}
return gid;
}
void udev_device_ensure_usec_initialized(struct udev_device *udev_device, struct udev_device *udev_device_old) {
assert(udev_device);
device_ensure_usec_initialized(udev_device->device,
udev_device_old ? udev_device_old->device : NULL);
}
char **udev_device_get_properties_envp(struct udev_device *udev_device) {
char **envp;
int r;
assert(udev_device);
r = device_get_properties_strv(udev_device->device, &envp);
if (r < 0) {
errno = -r;
return NULL;
}
return envp;
}
ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf) {
const char *nulstr;
size_t len;
int r;
assert(udev_device);
assert(buf);
r = device_get_properties_nulstr(udev_device->device, (const uint8_t **)&nulstr, &len);
if (r < 0)
return r;
*buf = nulstr;
return len;
}
int udev_device_get_devlink_priority(struct udev_device *udev_device) {
int priority, r;
assert(udev_device);
r = device_get_devlink_priority(udev_device->device, &priority);
if (r < 0)
return r;
return priority;
}
int udev_device_get_watch_handle(struct udev_device *udev_device) {
int handle, r;
assert(udev_device);
r = device_get_watch_handle(udev_device->device, &handle);
if (r < 0)
return r;
return handle;
}
void udev_device_set_is_initialized(struct udev_device *udev_device) {
assert(udev_device);
device_set_is_initialized(udev_device->device);
}
int udev_device_rename(struct udev_device *udev_device, const char *name) {
int r;
assert(udev_device);
r = device_rename(udev_device->device, name);
if (r < 0)
return r;
return 0;
}
struct udev_device *udev_device_shallow_clone(struct udev_device *old_device) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
int r;
assert(old_device);
r = device_shallow_clone(old_device->device, &device);
if (r < 0) {
errno = -r;
return NULL;
}
return udev_device_new(old_device->udev, device);
}
struct udev_device *udev_device_clone_with_db(struct udev_device *udev_device_old) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
int r;
assert(udev_device_old);
r = device_clone_with_db(udev_device_old->device, &device);
if (r < 0) {
errno = -r;
return NULL;
}
return udev_device_new(udev_device_old->udev, device);
}
struct udev_device *udev_device_new_from_nulstr(struct udev *udev, char *nulstr, ssize_t buflen) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
int r;
r = device_new_from_nulstr(&device, (uint8_t*)nulstr, buflen);
if (r < 0) {
errno = -r;
return NULL;
}
return udev_device_new(udev, device);
}
struct udev_device *udev_device_new_from_synthetic_event(struct udev *udev, const char *syspath, const char *action) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
int r;
r = device_new_from_synthetic_event(&device, syspath, action);
if (r < 0) {
errno = -r;
return NULL;
}
return udev_device_new(udev, device);
}
int udev_device_copy_properties(struct udev_device *udev_device_dst, struct udev_device *udev_device_src) {
int r;
assert(udev_device_dst);
assert(udev_device_src);
r = device_copy_properties(udev_device_dst->device, udev_device_src->device);
if (r < 0)
return r;
return 0;
}
const char *udev_device_get_id_filename(struct udev_device *udev_device) {
const char *filename;
int r;
assert(udev_device);
r = device_get_id_filename(udev_device->device, &filename);
if (r < 0) {
errno = -r;
return NULL;
}
return filename;
}
int udev_device_set_watch_handle(struct udev_device *udev_device, int handle) {
assert(udev_device);
device_set_watch_handle(udev_device->device, handle);
return 0;
}
void udev_device_set_db_persist(struct udev_device *udev_device) {
assert(udev_device);
device_set_db_persist(udev_device->device);
}
int udev_device_set_devlink_priority(struct udev_device *udev_device, int priority) {
assert(udev_device);
device_set_devlink_priority(udev_device->device, priority);
return 0;
}
int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink) {
int r;
assert(udev_device);
r = device_add_devlink(udev_device->device, devlink);
if (r < 0)
return r;
return 0;
}
int udev_device_add_property(struct udev_device *udev_device, const char *property, const char *value) {
int r;
assert(udev_device);
r = device_add_property(udev_device->device, property, value);
if (r < 0)
return r;
return 0;
}
int udev_device_add_tag(struct udev_device *udev_device, const char *tag) {
int r;
assert(udev_device);
r = device_add_tag(udev_device->device, tag);
if (r < 0)
return r;
return 0;
}
void udev_device_remove_tag(struct udev_device *udev_device, const char *tag) {
assert(udev_device);
device_remove_tag(udev_device->device, tag);
}
void udev_device_cleanup_tags_list(struct udev_device *udev_device) {
assert(udev_device);
device_cleanup_tags(udev_device->device);
}
void udev_device_cleanup_devlinks_list(struct udev_device *udev_device) {
assert(udev_device);
device_cleanup_devlinks(udev_device->device);
}
void udev_device_set_info_loaded(struct udev_device *udev_device) {
assert(udev_device);
device_seal(udev_device->device);
}
void udev_device_read_db(struct udev_device *udev_device) {
assert(udev_device);
device_read_db_force(udev_device->device);
}

2
src/libudev/libudev-device.c
View File

@ -23,8 +23,8 @@
#include "device-private.h"
#include "device-util.h"
#include "libudev-device-internal.h"
#include "libudev-private.h"
#include "parse-util.h"
#include "time-util.h"
/**
* SECTION:libudev-device

6
src/libudev/libudev-hwdb.c
View File

@ -1,10 +1,12 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#include <errno.h>
#include "sd-hwdb.h"
#include "alloc-util.h"
#include "hwdb-util.h"
#include "libudev-private.h"
#include "libudev-list-internal.h"
/**
* SECTION:libudev-hwdb
@ -110,7 +112,7 @@ _public_ struct udev_list_entry *udev_hwdb_get_properties_list_entry(struct udev
udev_list_cleanup(&hwdb->properties_list);
SD_HWDB_FOREACH_PROPERTY(hwdb->hwdb, modalias, key, value) {
if (udev_list_entry_add(&hwdb->properties_list, key, value) == NULL) {
if (!udev_list_entry_add(&hwdb->properties_list, key, value)) {
errno = ENOMEM;
return NULL;
}

24
src/libudev/libudev-list-internal.h Normal file
View File

@ -0,0 +1,24 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once
#include "libudev.h"
struct udev_list_node {
struct udev_list_node *next, *prev;
};
struct udev_list {
struct udev *udev;
struct udev_list_node node;
struct udev_list_entry **entries;
unsigned entries_cur;
unsigned entries_max;
bool unique;
};
void udev_list_init(struct udev *udev, struct udev_list *list, bool unique);
void udev_list_cleanup(struct udev_list *list);
struct udev_list_entry *udev_list_get_entry(struct udev_list *list);
struct udev_list_entry *udev_list_entry_add(struct udev_list *list, const char *name, const char *value);
int udev_list_entry_get_num(struct udev_list_entry *list_entry);
void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num);

81
src/libudev/libudev-list.c
View File

@ -6,7 +6,8 @@
#include <string.h>
#include "alloc-util.h"
#include "libudev-private.h"
#include "libudev-list-internal.h"
#include "util.h"
/**
* SECTION:libudev-list
@ -30,34 +31,25 @@ struct udev_list_entry {
};
/* the list's head points to itself if empty */
void udev_list_node_init(struct udev_list_node *list)
{
static void udev_list_node_init(struct udev_list_node *list) {
list->next = list;
list->prev = list;
}
int udev_list_node_is_empty(struct udev_list_node *list)
{
static int udev_list_node_is_empty(struct udev_list_node *list) {
return list->next == list;
}
static void udev_list_node_insert_between(struct udev_list_node *new,
struct udev_list_node *prev,
struct udev_list_node *next)
{
struct udev_list_node *next) {
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
void udev_list_node_append(struct udev_list_node *new, struct udev_list_node *list)
{
udev_list_node_insert_between(new, list->prev, list);
}
void udev_list_node_remove(struct udev_list_node *entry)
{
static void udev_list_node_remove(struct udev_list_node *entry) {
struct udev_list_node *prev = entry->prev;
struct udev_list_node *next = entry->next;
@ -69,13 +61,11 @@ void udev_list_node_remove(struct udev_list_node *entry)
}
/* return list entry which embeds this node */
static inline struct udev_list_entry *list_node_to_entry(struct udev_list_node *node)
{
static inline struct udev_list_entry *list_node_to_entry(struct udev_list_node *node) {
return container_of(node, struct udev_list_entry, node);
}
void udev_list_init(struct udev *udev, struct udev_list *list, bool unique)
{
void udev_list_init(struct udev *udev, struct udev_list *list, bool unique) {
memzero(list, sizeof(struct udev_list));
list->udev = udev;
list->unique = unique;
@ -83,23 +73,20 @@ void udev_list_init(struct udev *udev, struct udev_list *list, bool unique)
}
/* insert entry into a list as the last element */
static void udev_list_entry_append(struct udev_list_entry *new, struct udev_list *list)
{
static void udev_list_entry_append(struct udev_list_entry *new, struct udev_list *list) {
/* inserting before the list head make the node the last node in the list */
udev_list_node_insert_between(&new->node, list->node.prev, &list->node);
new->list = list;
}
/* insert entry into a list, before a given existing entry */
static void udev_list_entry_insert_before(struct udev_list_entry *new, struct udev_list_entry *entry)
{
static void udev_list_entry_insert_before(struct udev_list_entry *new, struct udev_list_entry *entry) {
udev_list_node_insert_between(&new->node, entry->node.prev, &entry->node);
new->list = entry->list;
}
/* binary search in sorted array */
static int list_search(struct udev_list *list, const char *name)
{
static int list_search(struct udev_list *list, const char *name) {
unsigned first, last;
first = 0;
@ -200,9 +187,8 @@ struct udev_list_entry *udev_list_entry_add(struct udev_list *list, const char *
return entry;
}
void udev_list_entry_delete(struct udev_list_entry *entry)
{
if (entry->list->entries != NULL) {
static void udev_list_entry_delete(struct udev_list_entry *entry) {
if (entry->list->entries) {
int i;
struct udev_list *list = entry->list;
@ -221,8 +207,12 @@ void udev_list_entry_delete(struct udev_list_entry *entry)
free(entry);
}
void udev_list_cleanup(struct udev_list *list)
{
#define udev_list_entry_foreach_safe(entry, tmp, first) \
for (entry = first, tmp = udev_list_entry_get_next(entry); \
entry; \
entry = tmp, tmp = udev_list_entry_get_next(tmp))
void udev_list_cleanup(struct udev_list *list) {
struct udev_list_entry *entry_loop;
struct udev_list_entry *entry_tmp;
@ -233,8 +223,7 @@ void udev_list_cleanup(struct udev_list *list)
udev_list_entry_delete(entry_loop);
}
struct udev_list_entry *udev_list_get_entry(struct udev_list *list)
{
struct udev_list_entry *udev_list_get_entry(struct udev_list *list) {
if (udev_list_node_is_empty(&list->node))
return NULL;
return list_node_to_entry(list->node.next);
@ -248,11 +237,10 @@ struct udev_list_entry *udev_list_get_entry(struct udev_list *list)
*
* Returns: udev_list_entry, #NULL if no more entries are available.
*/
_public_ struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry)
{
_public_ struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry) {
struct udev_list_node *next;
if (list_entry == NULL)
if (!list_entry)
return NULL;
next = list_entry->node.next;
/* empty list or no more entries */
@ -270,11 +258,10 @@ _public_ struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry
*
* Returns: udev_list_entry, #NULL if no matching entry is found.
*/
_public_ struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_entry *list_entry, const char *name)
{
_public_ struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_entry *list_entry, const char *name) {
int i;
if (list_entry == NULL)
if (!list_entry)
return NULL;
if (!list_entry->list->unique)
@ -294,9 +281,8 @@ _public_ struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_en
*
* Returns: the name string of this entry.
*/
_public_ const char *udev_list_entry_get_name(struct udev_list_entry *list_entry)
{
if (list_entry == NULL)
_public_ const char *udev_list_entry_get_name(struct udev_list_entry *list_entry) {
if (!list_entry)
return NULL;
return list_entry->name;
}
@ -309,23 +295,20 @@ _public_ const char *udev_list_entry_get_name(struct udev_list_entry *list_entry
*
* Returns: the value string of this entry.
*/
_public_ const char *udev_list_entry_get_value(struct udev_list_entry *list_entry)
{
if (list_entry == NULL)
_public_ const char *udev_list_entry_get_value(struct udev_list_entry *list_entry) {
if (!list_entry)
return NULL;
return list_entry->value;
}
int udev_list_entry_get_num(struct udev_list_entry *list_entry)
{
if (list_entry == NULL)
int udev_list_entry_get_num(struct udev_list_entry *list_entry) {
if (!list_entry)
return -EINVAL;
return list_entry->num;
}
void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num)
{
if (list_entry == NULL)
void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num) {
if (!list_entry)
return;
list_entry->num = num;
}

92
src/libudev/libudev-monitor.c
View File

@ -10,7 +10,6 @@
#include "device-private.h"
#include "device-util.h"
#include "libudev-device-internal.h"
#include "libudev-private.h"
#include "string-util.h"
/**
@ -41,39 +40,6 @@ static MonitorNetlinkGroup monitor_netlink_group_from_string(const char *name) {
return _MONITOR_NETLINK_GROUP_INVALID;
}
struct udev_monitor *udev_monitor_new_from_netlink_fd(struct udev *udev, const char *name, int fd) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *m = NULL;
_cleanup_(udev_monitor_unrefp) struct udev_monitor *udev_monitor = NULL;
MonitorNetlinkGroup g;
int r;
g = monitor_netlink_group_from_string(name);
if (g < 0) {
errno = EINVAL;
return NULL;
}
r = device_monitor_new_full(&m, g, fd);
if (r < 0) {
errno = -r;
return NULL;
}
udev_monitor = new(struct udev_monitor, 1);
if (!udev_monitor) {
errno = ENOMEM;
return NULL;
}
*udev_monitor = (struct udev_monitor) {
.udev = udev,
.n_ref = 1,
.monitor = TAKE_PTR(m),
};
return TAKE_PTR(udev_monitor);
}
/**
* udev_monitor_new_from_netlink:
* @udev: udev library context
@ -97,7 +63,36 @@ struct udev_monitor *udev_monitor_new_from_netlink_fd(struct udev *udev, const c
* Returns: a new udev monitor, or #NULL, in case of an error
**/
_public_ struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char *name) {
return udev_monitor_new_from_netlink_fd(udev, name, -1);
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *m = NULL;
struct udev_monitor *udev_monitor;
MonitorNetlinkGroup g;
int r;
g = monitor_netlink_group_from_string(name);
if (g < 0) {
errno = EINVAL;
return NULL;
}
r = device_monitor_new_full(&m, g, -1);
if (r < 0) {
errno = -r;
return NULL;
}
udev_monitor = new(struct udev_monitor, 1);
if (!udev_monitor) {
errno = ENOMEM;
return NULL;
}
*udev_monitor = (struct udev_monitor) {
.udev = udev,
.n_ref = 1,
.monitor = TAKE_PTR(m),
};
return udev_monitor;
}
/**
@ -115,13 +110,6 @@ _public_ int udev_monitor_filter_update(struct udev_monitor *udev_monitor) {
return sd_device_monitor_filter_update(udev_monitor->monitor);
}
int udev_monitor_allow_unicast_sender(struct udev_monitor *udev_monitor, struct udev_monitor *sender) {
assert_return(udev_monitor, -EINVAL);
assert_return(sender, -EINVAL);
return device_monitor_allow_unicast_sender(udev_monitor->monitor, sender->monitor);
}
/**
* udev_monitor_enable_receiving:
* @udev_monitor: the monitor which should receive events
@ -152,12 +140,6 @@ _public_ int udev_monitor_set_receive_buffer_size(struct udev_monitor *udev_moni
return sd_device_monitor_set_receive_buffer_size(udev_monitor->monitor, (size_t) size);
}
int udev_monitor_disconnect(struct udev_monitor *udev_monitor) {
assert(udev_monitor);
return device_monitor_disconnect(udev_monitor->monitor);
}
static struct udev_monitor *udev_monitor_free(struct udev_monitor *udev_monitor) {
assert(udev_monitor);
@ -214,7 +196,7 @@ _public_ int udev_monitor_get_fd(struct udev_monitor *udev_monitor) {
return device_monitor_get_fd(udev_monitor->monitor);
}
int udev_monitor_receive_sd_device(struct udev_monitor *udev_monitor, sd_device **ret) {
static int udev_monitor_receive_sd_device(struct udev_monitor *udev_monitor, sd_device **ret) {
struct pollfd pfd;
int r;
@ -283,18 +265,6 @@ _public_ struct udev_device *udev_monitor_receive_device(struct udev_monitor *ud
return udev_device_new(udev_monitor->udev, device);
}
int udev_monitor_send_device(
struct udev_monitor *udev_monitor,
struct udev_monitor *destination,
struct udev_device *udev_device) {
assert(udev_monitor);
assert(udev_device);
return device_monitor_send_device(udev_monitor->monitor,
destination ? destination->monitor : NULL,
udev_device->device);
}
/**
* udev_monitor_filter_add_match_subsystem_devtype:
* @udev_monitor: the monitor

115
src/libudev/libudev-private.h
View File

@ -1,115 +0,0 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include "libudev.h"
#include "sd-device.h"
#include "macro.h"
#include "mkdir.h"
#include "strxcpyx.h"
#include "util.h"
#define READ_END 0
#define WRITE_END 1
/* libudev-device.c */
struct udev_device *udev_device_new_from_nulstr(struct udev *udev, char *nulstr, ssize_t buflen);
struct udev_device *udev_device_new_from_synthetic_event(struct udev *udev, const char *syspath, const char *action);
struct udev_device *udev_device_shallow_clone(struct udev_device *old_device);
struct udev_device *udev_device_clone_with_db(struct udev_device *old_device);
int udev_device_copy_properties(struct udev_device *dst, struct udev_device *src);
mode_t udev_device_get_devnode_mode(struct udev_device *udev_device);
uid_t udev_device_get_devnode_uid(struct udev_device *udev_device);
gid_t udev_device_get_devnode_gid(struct udev_device *udev_device);
int udev_device_rename(struct udev_device *udev_device, const char *new_name);
int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink);
void udev_device_cleanup_devlinks_list(struct udev_device *udev_device);
int udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value);
char **udev_device_get_properties_envp(struct udev_device *udev_device);
ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf);
const char *udev_device_get_devpath_old(struct udev_device *udev_device);
const char *udev_device_get_id_filename(struct udev_device *udev_device);
void udev_device_set_is_initialized(struct udev_device *udev_device);
int udev_device_add_tag(struct udev_device *udev_device, const char *tag);
void udev_device_remove_tag(struct udev_device *udev_device, const char *tag);
void udev_device_cleanup_tags_list(struct udev_device *udev_device);
void udev_device_ensure_usec_initialized(struct udev_device *udev_device, struct udev_device *old_device);
int udev_device_get_devlink_priority(struct udev_device *udev_device);
int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio);
int udev_device_get_watch_handle(struct udev_device *udev_device);
int udev_device_set_watch_handle(struct udev_device *udev_device, int handle);
int udev_device_get_ifindex(struct udev_device *udev_device);
void udev_device_set_info_loaded(struct udev_device *device);
void udev_device_set_db_persist(struct udev_device *udev_device);
void udev_device_read_db(struct udev_device *udev_device);
int udev_device_update_db(struct udev_device *udev_device);
int udev_device_delete_db(struct udev_device *udev_device);
int udev_device_tag_index(struct udev_device *dev, struct udev_device *dev_old, bool add);
/* libudev-monitor.c - netlink/unix socket communication */
int udev_monitor_disconnect(struct udev_monitor *udev_monitor);
int udev_monitor_allow_unicast_sender(struct udev_monitor *udev_monitor, struct udev_monitor *sender);
int udev_monitor_send_device(struct udev_monitor *udev_monitor,
struct udev_monitor *destination, struct udev_device *udev_device);
struct udev_monitor *udev_monitor_new_from_netlink_fd(struct udev *udev, const char *name, int fd);
int udev_monitor_receive_sd_device(struct udev_monitor *udev_monitor, sd_device **ret);
/* libudev-list.c */
struct udev_list_node {
struct udev_list_node *next, *prev;
};
struct udev_list {
struct udev *udev;
struct udev_list_node node;
struct udev_list_entry **entries;
unsigned entries_cur;
unsigned entries_max;
bool unique;
};
void udev_list_node_init(struct udev_list_node *list);
int udev_list_node_is_empty(struct udev_list_node *list);
void udev_list_node_append(struct udev_list_node *new, struct udev_list_node *list);
void udev_list_node_remove(struct udev_list_node *entry);
#define udev_list_node_foreach(node, list) \
for (node = (list)->next; \
node != list; \
node = (node)->next)
#define udev_list_node_foreach_safe(node, tmp, list) \
for (node = (list)->next, tmp = (node)->next; \
node != list; \
node = tmp, tmp = (tmp)->next)
void udev_list_init(struct udev *udev, struct udev_list *list, bool unique);
void udev_list_cleanup(struct udev_list *list);
struct udev_list_entry *udev_list_get_entry(struct udev_list *list);
struct udev_list_entry *udev_list_entry_add(struct udev_list *list, const char *name, const char *value);
void udev_list_entry_delete(struct udev_list_entry *entry);
int udev_list_entry_get_num(struct udev_list_entry *list_entry);
void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num);
#define udev_list_entry_foreach_safe(entry, tmp, first) \
for (entry = first, tmp = udev_list_entry_get_next(entry); \
entry != NULL; \
entry = tmp, tmp = udev_list_entry_get_next(tmp))
/* libudev-util.c */
#define UTIL_PATH_SIZE 1024
#define UTIL_NAME_SIZE 512
#define UTIL_LINE_SIZE 16384
#define UDEV_ALLOWED_CHARS_INPUT "/ $%?,"
size_t util_path_encode(const char *src, char *dest, size_t size);
int util_replace_whitespace(const char *str, char *to, size_t len);
int util_replace_chars(char *str, const char *white);
uint32_t util_string_hash32(const char *key);
uint64_t util_string_bloom64(const char *str);
int util_resolve_subsys_kernel(const char *string, char *result, size_t maxsize, int read_value);
/* Cleanup functions */
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev*, udev_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_device*, udev_device_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_enumerate*, udev_enumerate_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_monitor*, udev_monitor_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_hwdb*, udev_hwdb_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_queue*, udev_queue_unref);

5
src/libudev/libudev-queue.c
View File

@ -9,10 +9,11 @@
#include <sys/inotify.h>
#include <unistd.h>
#include "libudev.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "io-util.h"
#include "libudev-private.h"
/**
* SECTION:libudev-queue
@ -45,7 +46,7 @@ _public_ struct udev_queue *udev_queue_new(struct udev *udev) {
struct udev_queue *udev_queue;
udev_queue = new(struct udev_queue, 1);
if (udev_queue == NULL) {
if (!udev_queue) {
errno = ENOMEM;
return NULL;
}

20
src/libudev/libudev-util.c
View File

@ -7,11 +7,9 @@
#include <string.h>
#include <unistd.h>
#include "libudev.h"
#include "MurmurHash2.h"
#include "device-nodes.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "strxcpyx.h"
#include "utf8.h"
/**
@ -38,13 +36,13 @@ int util_resolve_subsys_kernel(const char *string,
subsys = &temp[1];
sysname = strchr(subsys, '/');
if (sysname == NULL)
if (!sysname)
return -1;
sysname[0] = '\0';
sysname = &sysname[1];
attr = strchr(sysname, ']');
if (attr == NULL)
if (!attr)
return -1;
attr[0] = '\0';
attr = &attr[1];
@ -53,18 +51,18 @@ int util_resolve_subsys_kernel(const char *string,
if (attr[0] == '\0')
attr = NULL;
if (read_value && attr == NULL)
if (read_value && !attr)
return -1;
dev = udev_device_new_from_subsystem_sysname(NULL, subsys, sysname);
if (dev == NULL)
if (!dev)
return -1;
if (read_value) {
const char *val;
val = udev_device_get_sysattr_value(dev, attr);
if (val != NULL)
if (val)
strscpy(result, maxsize, val);
else
result[0] = '\0';
@ -75,7 +73,7 @@ int util_resolve_subsys_kernel(const char *string,
s = result;
l = strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
if (attr != NULL)
if (attr)
strpcpyl(&s, l, "/", attr, NULL);
log_debug("path '[%s/%s]%s' is '%s'", subsys, sysname, attr, result);
}
@ -182,7 +180,7 @@ int util_replace_chars(char *str, const char *white) {
}
/* if space is allowed, replace whitespace with ordinary space */
if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) {
if (isspace(str[i]) && white && strchr(white, ' ')) {
str[i] = ' ';
i++;
replaced++;

24
src/libudev/libudev-util.h Normal file
View File

@ -0,0 +1,24 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once
#include "libudev.h"
#include "macro.h"
/* libudev-util.c */
#define UTIL_PATH_SIZE 1024
#define UTIL_NAME_SIZE 512
#define UTIL_LINE_SIZE 16384
#define UDEV_ALLOWED_CHARS_INPUT "/ $%?,"
size_t util_path_encode(const char *src, char *dest, size_t size);
int util_replace_whitespace(const char *str, char *to, size_t len);
int util_replace_chars(char *str, const char *white);
int util_resolve_subsys_kernel(const char *string, char *result, size_t maxsize, int read_value);
/* Cleanup functions */
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev*, udev_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_device*, udev_device_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_enumerate*, udev_enumerate_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_monitor*, udev_monitor_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_hwdb*, udev_hwdb_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_queue*, udev_queue_unref);

1
src/libudev/libudev.c
View File

@ -11,7 +11,6 @@
#include "alloc-util.h"
#include "fd-util.h"
#include "libudev-private.h"
#include "missing.h"
#include "string-util.h"

2
src/libudev/libudev.h
View File

@ -49,7 +49,7 @@ const char *udev_list_entry_get_value(struct udev_list_entry *list_entry);
*/
#define udev_list_entry_foreach(list_entry, first_entry) \
for (list_entry = first_entry; \
list_entry != NULL; \
list_entry; \
list_entry = udev_list_entry_get_next(list_entry))
/*

12
src/libudev/meson.build
View File

@ -1,17 +1,17 @@
# SPDX-License-Identifier: LGPL-2.1+
libudev_sources = files('''
libudev-private.h
libudev-device-internal.h
libudev.c
libudev-list.c
libudev-util.c
libudev-device.c
libudev-device-private.c
libudev-device-internal.h
libudev-enumerate.c
libudev-hwdb.c
libudev-list.c
libudev-list-internal.h
libudev-monitor.c
libudev-queue.c
libudev-hwdb.c
libudev-util.c
libudev-util.h
'''.split())
############################################################

3
src/test/test-libudev.c
View File

@ -1,12 +1,13 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <sys/epoll.h>
#include <unistd.h>
#include "fd-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "log.h"
#include "stdio-util.h"
#include "string-util.h"

1
src/test/test-udev.c
View File

@ -15,6 +15,7 @@
#include "fs-util.h"
#include "log.h"
#include "missing.h"
#include "mkdir.h"
#include "selinux-util.h"
#include "signal-util.h"
#include "string-util.h"

3
src/udev/ata_id/ata_id.c
View File

@ -24,9 +24,10 @@
#include <unistd.h>
#include "fd-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "log.h"
#include "udev-util.h"
#include "util.h"
#define COMMAND_TIMEOUT_MSEC (30 * 1000)

3
src/udev/scsi_id/scsi_id.c
View File

@ -19,9 +19,10 @@
#include "alloc-util.h"
#include "fd-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "scsi_id.h"
#include "string-util.h"
#include "strxcpyx.h"
#include "udev-util.h"
static const struct option options[] = {

2
src/udev/udev-builtin-path_id.c
View File

@ -18,7 +18,7 @@
#include "alloc-util.h"
#include "dirent-util.h"
#include "fd-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "string-util.h"
#include "strv.h"
#include "sysexits.h"

3
src/udev/udev-builtin-usb_id.c
View File

@ -18,8 +18,9 @@
#include "alloc-util.h"
#include "device-util.h"
#include "fd-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "string-util.h"
#include "strxcpyx.h"
#include "udev-builtin.h"
static void set_usb_iftype(char *to, int if_class_num, size_t len) {

4
src/udev/udev-event.c
View File

@ -16,13 +16,15 @@
#include "device-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "netlink-util.h"
#include "path-util.h"
#include "process-util.h"
#include "signal-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
#include "strxcpyx.h"
#include "udev-builtin.h"
#include "udev-node.h"
#include "udev-watch.h"

4
src/udev/udev-node.c
View File

@ -17,12 +17,14 @@
#include "fd-util.h"
#include "format-util.h"
#include "fs-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "mkdir.h"
#include "path-util.h"
#include "selinux-util.h"
#include "smack-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "strxcpyx.h"
#include "udev-node.h"
static int node_symlink(sd_device *dev, const char *node, const char *slink) {

4
src/udev/udev-rules.c
View File

@ -23,7 +23,8 @@
#include "fileio.h"
#include "fs-util.h"
#include "glob-util.h"
#include "libudev-private.h"
#include "libudev-util.h"
#include "mkdir.h"
#include "path-util.h"
#include "proc-cmdline.h"
#include "stat-util.h"
@ -31,6 +32,7 @@
#include "strbuf.h"
#include "string-util.h"
#include "strv.h"
#include "strxcpyx.h"
#include "sysctl-util.h"
#include "udev-builtin.h"
#include "udev.h"

12
src/udev/udev.h
View File

@ -5,20 +5,16 @@
* Copyright © 2003 Greg Kroah-Hartman <greg@kroah.com>
*/
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include "sd-device.h"
#include "sd-netlink.h"
#include "hashmap.h"
#include "label.h"
#include "libudev-private.h"
#include "macro.h"
#include "strv.h"
#include "util.h"
#include "udev-util.h"
#include "util.h"
#define READ_END 0
#define WRITE_END 1
struct udev_event {
sd_device *dev;

2
src/udev/udevadm-settle.c
View File

@ -13,7 +13,7 @@
#include <string.h>
#include <unistd.h>
#include "libudev-private.h"
#include "libudev-util.h"
#include "time-util.h"
#include "udevadm.h"
#include "udev-ctrl.h"

2
src/udev/udevadm-test.c
View File

@ -16,7 +16,9 @@
#include "device-private.h"
#include "device-util.h"
#include "libudev-util.h"
#include "string-util.h"
#include "strxcpyx.h"
#include "udev-builtin.h"
#include "udev.h"
#include "udevadm.h"

2
src/udev/udevd.c
View File

@ -46,6 +46,7 @@
#include "io-util.h"
#include "libudev-device-internal.h"
#include "list.h"
#include "mkdir.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "proc-cmdline.h"
@ -54,6 +55,7 @@
#include "signal-util.h"
#include "socket-util.h"
#include "string-util.h"
#include "strxcpyx.h"
#include "syslog-util.h"
#include "terminal-util.h"
#include "udev-builtin.h"