diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 46d1d83d78..aaa3d86267 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -9,8 +9,8 @@ SPDX-License-Identifier: LGPL-2.1-or-later ## Code Map -This section will attempt to provide a high-level overview of the various -components of the systemd repository. +This document provides a high-level overview of the various components of the +systemd repository. ## Source Code @@ -21,30 +21,60 @@ names are self-explanatory. ### Shared Code -You might wonder what kind of common code belongs in `src/shared/` and what -belongs in `src/basic/`. The split is like this: anything that is used to -implement the public shared objects we provide (`sd-bus`, `sd-login`, -`sd-id128`, `nss-systemd`, `nss-mymachines`, `nss-resolve`, `nss-myhostname`, -`pam_systemd`), must be located in `src/basic` (those objects are not allowed -to link to `libsystemd-shared.so`). Conversely, anything which is shared -between multiple components and does not need to be in `src/basic/`, should be -in `src/shared/`. +The code that is shared between components is split into a few directories, +each with a different purpose: + +- `src/basic/` and `src/fundamental/` — those directories contain code + primitives that are used by all other code. `src/fundamental/` is stricter, + because it used for EFI and user-space code, while `src/basic/` is only used + for user-space code. The code in `src/fundamental/` cannot depend on any + other code in the tree, and `src/basic/` can depend only on itself and + `src/fundamental/`. For user-space, a static library is built from this code + and linked statically in various places. + +- `src/libsystemd/` implements the `libsystemd.so` shared library (also + available as static `libsystemd.a`). This code may use anything in + `src/basic/` or `src/fundamental/`. + +- `src/shared/` provides various utilities and code shared between other + components that is exposed as the `libsystemd-shared-.so` shared library. + +The other subdirectories implement individual components. They may depend only +on `src/fundamental/` + `src/basic/`, or also on `src/libsystemd/`, or also on +`src/shared/`. + +You might wonder what kind of code belongs where. In general, the rule is that +code should linked as few times as possible, ideally only once. Thus code that +is used by "higher-level" components (e.g. our binaries which are linked to +`libsystemd-shared-.so`), would go to a subdirectory specific to that +component if it is only used there. If the code is to be shared between +components, it'd go to `src/shared/`. Shared code that that is used by multiple +components that do not link to `libsystemd-shared-.so` may live either in +`src/libsystemd/`, `src/basic/`, or `src/fundamental/`. Any code that is used +only for EFI goes under `src/boot/efi/`, and `src/fundamental/` if is shared +with non-EFI compoenents. To summarize: +`src/fundamental/` +- may be used by all code in the tree +- may not use any code outside of `src/fundamental/` + `src/basic/` - may be used by all code in the tree -- may not use any code outside of `src/basic/` +- may not use any code outside of `src/fundamental/` and `src/basic/` `src/libsystemd/` -- may be used by all code in the tree, except for code in `src/basic/` -- may not use any code outside of `src/basic/`, `src/libsystemd/` +- may be used by all code in the tree that links to `libsystem.so` +- may not use any code outside of `src/fundamental/`, `src/basic/`, and + `src/libsystemd/` `src/shared/` - may be used by all code in the tree, except for code in `src/basic/`, -`src/libsystemd/`, `src/nss-*`, `src/login/pam_systemd.*`, and files under -`src/journal/` that end up in `libjournal-client.a` convenience library. -- may not use any code outside of `src/basic/`, `src/libsystemd/`, `src/shared/` + `src/libsystemd/`, `src/nss-*`, `src/login/pam_systemd.*`, and files under + `src/journal/` that end up in `libjournal-client.a` convenience library. +- may not use any code outside of `src/fundamental/`, `src/basic/`, + `src/libsystemd/`, `src/shared/` ### PID 1 diff --git a/man/rules/meson.build b/man/rules/meson.build index 55376c0ecc..277ab5e593 100644 --- a/man/rules/meson.build +++ b/man/rules/meson.build @@ -137,6 +137,7 @@ manpages = [ 'sd_id128_in_setv', 'sd_id128_is_allf', 'sd_id128_is_null', + 'sd_id128_string_equal', 'sd_id128_t'], ''], ['sd-journal', '3', [], ''], @@ -267,7 +268,8 @@ manpages = [ 'sd_bus_error_set_errno', 'sd_bus_error_set_errnof', 'sd_bus_error_set_errnofv', - 'sd_bus_error_setf'], + 'sd_bus_error_setf', + 'sd_bus_error_setfv'], ''], ['sd_bus_error_add_map', '3', @@ -359,7 +361,7 @@ manpages = [ ''], ['sd_bus_message_read_array', '3', [], ''], ['sd_bus_message_read_basic', '3', [], ''], - ['sd_bus_message_read_strv', '3', [], ''], + ['sd_bus_message_read_strv', '3', ['sd_bus_message_read_strv_extend'], ''], ['sd_bus_message_rewind', '3', [], ''], ['sd_bus_message_seal', '3', [], ''], ['sd_bus_message_sensitive', '3', [], ''], @@ -646,7 +648,10 @@ manpages = [ '3', ['SD_HWDB_FOREACH_PROPERTY', 'sd_hwdb_enumerate', 'sd_hwdb_seek'], ''], - ['sd_hwdb_new', '3', ['sd_hwdb_ref', 'sd_hwdb_unref'], ''], + ['sd_hwdb_new', + '3', + ['sd_hwdb_new_from_path', 'sd_hwdb_ref', 'sd_hwdb_unref'], + ''], ['sd_id128_get_machine', '3', ['sd_id128_get_boot', diff --git a/man/sd-id128.xml b/man/sd-id128.xml index b6e50a559e..c869943ad7 100644 --- a/man/sd-id128.xml +++ b/man/sd-id128.xml @@ -28,6 +28,7 @@ SD_ID128_NULL SD_ID128_UUID_FORMAT_STR sd_id128_equal + sd_id128_string_equal sd_id128_in_set sd_id128_in_set_sentinel sd_id128_in_setv @@ -40,6 +41,75 @@ #include <systemd/sd-id128.h> + + + SD_ID128_ALLF + + + SD_ID128_NULL + + + SD_ID128_CONST_STR(id) + + + SD_ID128_FORMAT_STR + + + SD_ID128_FORMAT_VAL(id) + + + SD_ID128_MAKE(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, vA, vB, vC, vD, vE, vF) + + + SD_ID128_MAKE_STR(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, vA, vB, vC, vD, vE, vF) + + + SD_ID128_MAKE_UUID_STR(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, vA, vB, vC, vD, vE, vF) + + + SD_ID128_UUID_FORMAT_STR + + + + int sd_id128_equal + sd_id128_t a + sd_id128_t b + + + + int sd_id128_string_equal + const char *a + sd_id128_t b + + + + int sd_id128_is_null + sd_id128_t id + + + + int sd_id128_is_allf + sd_id128_t id + + + + int sd_id128_in_setv + sd_id128_t id + va_list ap + + + + int sd_id128_in_set_sentinel + sd_id128_t id + … + SD_ID128_NULL + + + + int sd_id128_in_set + sd_id128_t id + … + @@ -51,20 +121,13 @@ Description - sd-id128.h provides APIs to process and generate 128-bit ID values. The - 128-bit ID values processed and generated by these APIs are a generalization of OSF UUIDs as defined by - RFC 4122 but use a simpler string format. These - functions impose no structure on the used IDs, much unlike OSF UUIDs or Microsoft GUIDs, but are mostly - compatible with those types of IDs. + sd-id128.h provides APIs to generate, convert, and compare 128-bit ID values. + The 128-bit ID values processed and generated by these APIs are a generalization of OSF UUIDs as defined + by RFC 4122 but use a simpler string format. + These functions impose no structure on the used IDs, much unlike OSF UUIDs or Microsoft GUIDs, but are + mostly compatible with those types of IDs. - See - sd_id128_to_string3, - sd_id128_randomize3 - and - sd_id128_get_machine3 - for more information about the implemented functions. - A 128-bit ID is implemented as the following union type: @@ -73,30 +136,28 @@ uint64_t qwords[2]; } sd_id128_t; - This union type allows accessing the 128-bit ID as 16 - separate bytes or two 64-bit words. It is generally safer to - access the ID components by their 8-bit array to avoid endianness - issues. This union is intended to be passed call-by-value (as - opposed to call-by-reference) and may be directly manipulated by + This union type allows accessing the 128-bit ID as 16 separate bytes or two 64-bit words. It is + generally safer to access the ID components by their 8-bit array to avoid endianness issues. This union + is intended to be passed by value (as opposed to pass-by-reference) and may be directly manipulated by clients. A couple of macros are defined to denote and decode 128-bit IDs: - SD_ID128_MAKE() may be used to denote a - constant 128-bit ID in source code. A commonly used idiom is to - assign a name to a 128-bit ID using this macro: + SD_ID128_MAKE() is used to write a constant ID in source code. A commonly used + idiom is to assign a name to an ID using this macro: #define SD_MESSAGE_COREDUMP SD_ID128_MAKE(fc,2e,22,bc,6e,e6,47,b6,b9,07,29,ab,34,a2,50,b1) - SD_ID128_NULL may be used to refer to the 128-bit ID consisting of only - NUL bytes (i.e. all bits off). + SD_ID128_NULL defines an ID consisting of only NUL bytes + (i.e. all bits off). - SD_ID128_ALLF may be used to refer to the 128-bit ID consisting of only - 0xFF bytes (i.e. all bits on). + SD_ID128_ALLF defines an ID consisting of only 0xFF bytes + (i.e. all bits on). - SD_ID128_MAKE_STR() is similar to SD_ID128_MAKE(), but creates a - const char* expression that can be conveniently used in message formats and such: + SD_ID128_MAKE_STR() is similar to SD_ID128_MAKE(), but + creates a const char* expression that can be conveniently used in message formats and + such: #include <stdio.h> #define SD_MESSAGE_COREDUMP_STR SD_ID128_MAKE_STR(fc,2e,22,bc,6e,e6,47,b6,b9,07,29,ab,34,a2,50,b1) @@ -105,18 +166,16 @@ int main(int argc, char **argv) { puts("Match for coredumps: MESSAGE_ID=" SD_MESSAGE_COREDUMP_STR); } - SD_ID128_CONST_STR() may be used to - convert constant 128-bit IDs into constant strings for output. The - following example code will output the string - "fc2e22bc6ee647b6b90729ab34a250b1": + SD_ID128_CONST_STR() converts constant IDs into constant strings for + output. The following example code will output the string "fc2e22bc6ee647b6b90729ab34a250b1": int main(int argc, char *argv[]) { puts("Match for coredumps: %s", SD_ID128_CONST_STR(SD_MESSAGE_COREDUMP)); } - SD_ID128_FORMAT_STR and SD_ID128_FORMAT_VAL() may - be used to format a 128-bit ID in a - printf3 - format string, as shown in the following example: + SD_ID128_FORMAT_STR and SD_ID128_FORMAT_VAL() is used to + format an ID in a printf3 format + string, as shown in the following example: int main(int argc, char *argv[]) { sd_id128_t id; @@ -136,7 +195,7 @@ int main(int argc, char **argv) { best to avoid UUIDs of other variants, in order to avoid unnecessary ambiguities. All 128-bit IDs generated by the sd-id128 APIs strictly conform to Variant 1 Version 4 UUIDs, as per RFC 4122. - Use sd_id128_equal() to compare two 128-bit IDs: + sd_id128_equal() compares two 128-bit IDs: int main(int argc, char *argv[]) { sd_id128_t a, b, c; @@ -148,18 +207,26 @@ int main(int argc, char **argv) { return 0; } - Use sd_id128_is_null() to check if an 128-bit ID consists of only - NUL bytes: + sd_id128_string_equal() is similar to sd_id128_equal(), + but the first ID is formatted as const char*. The same restrictions apply as to the first + argument of sd_id128_from_string(). + + sd_id128_is_null() checks if an ID consists of only NUL + bytes: assert(sd_id128_is_null(SD_ID128_NULL)); - Similarly, use sd_id128_is_allf() to check if an 128-bit ID consists of only + Similarly, sd_id128_is_allf() checks if an ID consists of only 0xFF bytes (all bits on): assert(sd_id128_is_allf(SD_ID128_ALLF)); - For convenience, sd_id128_in_set() takes a list of IDs and - returns true if any are equal to the first argument: + sd_id128_in_set_sentinel() takes a list of IDs and returns true if the first + argument is equal to any of the subsequent arguments. The argument list is terminated by an + SD_ID128_NULL sentinel, which must be present. + + sd_id128_in_set() is a convenience function that takes a list of IDs and + returns true if the first argument is equal to any of the subsequent arguments: int main(int argc, char *argv[]) { sd_id12_t a = SD_ID128_MAKE(ee,89,be,71,bd,6e,43,d6,91,e6,c5,5d,eb,03,02,07); @@ -175,18 +242,25 @@ int main(int argc, char **argv) { sd_id128_in_set() is defined as a macro over - sd_id128_in_set_sentinel(), adding the SD_ID128_NULL - sentinel. Since sd_id128_in_set_sentinel() uses SD_ID128_NULL - as the sentinel, SD_ID128_NULL cannot be otherwise placed in the argument list. - + sd_id128_in_set_sentinel(), adding the SD_ID128_NULL sentinel + automatically. Since sd_id128_in_set_sentinel() uses + SD_ID128_NULL as the sentinel, SD_ID128_NULL cannot be + otherwise placed in the argument list. sd_id128_in_setv() is similar to sd_id128_in_set_sentinel(), but takes a struct varargs argument. - Note that new, randomized IDs may be generated with + New randomized IDs may be generated with systemd-id1281's new command. + + See + sd_id128_to_string3, + sd_id128_randomize3 + and + sd_id128_get_machine3 + for information about other implemented functions. diff --git a/man/sd_bus_error.xml b/man/sd_bus_error.xml index d8f3317e29..6f5e9e4b97 100644 --- a/man/sd_bus_error.xml +++ b/man/sd_bus_error.xml @@ -22,6 +22,7 @@ sd_bus_error_free sd_bus_error_set sd_bus_error_setf + sd_bus_error_setfv sd_bus_error_set_const sd_bus_error_set_errno sd_bus_error_set_errnof @@ -74,6 +75,14 @@ … + + int sd_bus_error_setfv + sd_bus_error *e + const char *name + const char *format + va_list ap + + int sd_bus_error_set_const sd_bus_error *e @@ -196,11 +205,15 @@ which case an SD_BUS_ERROR_NO_MEMORY error will be set instead and -ENOMEM returned. - sd_bus_error_setf() is similar to - sd_bus_error_set(), but takes a printf3 - format string and corresponding arguments to generate the - message field. + sd_bus_error_setf() and sd_bus_error_setfv() are similar + to sd_bus_error_set(), but take a printf3 format + string and corresponding arguments to generate the message field. + sd_bus_error_setf() uses variadic arguments, and + sd_bus_error_setfv() accepts the arguments as a + va_arg3 + parameter list. sd_bus_error_set_const() is similar to sd_bus_error_set(), but the string parameters are not copied internally, and must @@ -223,17 +236,15 @@ due to lack of memory, in which case an SD_BUS_ERROR_NO_MEMORY error is set instead, and -ENOMEM is returned. - sd_bus_error_set_errnof() is similar to - sd_bus_error_set_errno(), but in addition to - error, takes a printf3 - format string and corresponding arguments. The - message field will be generated from - format and the arguments. - - sd_bus_error_set_errnofv() is similar to - sd_bus_error_set_errnof(), but takes the - format string parameters as sd_bus_error_set_errnof() and sd_bus_error_set_errnof() + are similar to sd_bus_error_set_errno(), but in addition to + error, take a printf3 format + string and corresponding arguments. The message field will be generated from + format and the arguments. + sd_bus_error_set_errnof() uses variadic arguments, and + sd_bus_error_set_errnofv() accepts the arguments as a + va_arg3 parameter list. diff --git a/man/sd_bus_message_dump.xml b/man/sd_bus_message_dump.xml index eac0541ca4..83a4a4e31a 100644 --- a/man/sd_bus_message_dump.xml +++ b/man/sd_bus_message_dump.xml @@ -44,9 +44,10 @@ Description The sd_bus_message_dump() function writes a textual representation of the - message m to the stream f. This function is intended to be - used for debugging purposes, and the output is neither stable nor designed to be machine readable. - + message m to the stream f. If f is + NULL, standard output (stdio) will be used. This function is + intended to be used for debugging purposes, and the output is neither stable nor designed to be machine + readable. The flags parameter may be used to modify the output. With SD_BUS_MESSAGE_DUMP_WITH_HEADER, a header that specifies the message type and flags diff --git a/man/sd_bus_message_read_strv.xml b/man/sd_bus_message_read_strv.xml index 50580d86bc..6f46c18e09 100644 --- a/man/sd_bus_message_read_strv.xml +++ b/man/sd_bus_message_read_strv.xml @@ -17,6 +17,7 @@ sd_bus_message_read_strv + sd_bus_message_read_strv_extend Access an array of strings in a message @@ -30,26 +31,39 @@ sd_bus_message *m char ***l + + + int sd_bus_message_read_strv_extend + sd_bus_message *m + char ***l + Description - sd_bus_message_read_strv() gives access to an array of string-like items in + sd_bus_message_read_strv() reads an array of string-like items from the message m. The "read pointer" in the message must be right before an array of strings (D-Bus type as), object paths (D-Bus type ao), or signatures (D-Bus type ag). On success, a pointer to a - NULL-terminated array of strings is returned in the output parameter + NULL-terminated array of strings (strv) is returned in the output parameter l. Note that ownership of this array is transferred to the caller. Hence, the caller is responsible for freeing this array and its contents. + + sd_bus_message_read_strv_extend() is similar, but the second parameter is an + input-output parameter. If *l is NULL, if behaves identically + to sd_bus_message_read_strv(). Otherwise, *l must point to a + strv, which will be reallocated and extended with additional strings. This function is particularly + useful when combining multiple lists of strings in a message or messages into a single array of strings. + Return Value - On success, sd_bus_message_read_strv() returns a non-negative integer. On - failure, it returns a negative errno-style error code. + On success, these functions return a non-negative integer. On failure, they return a negative + errno-style error code. Errors diff --git a/man/sd_event_source_set_enabled.xml b/man/sd_event_source_set_enabled.xml index c8ae169c17..5f13fc101d 100644 --- a/man/sd_event_source_set_enabled.xml +++ b/man/sd_event_source_set_enabled.xml @@ -53,28 +53,29 @@ Description - sd_event_source_set_enabled() may be - used to enable or disable the event source object specified as - source. The enabled - parameter takes one of SD_EVENT_ON (to - enable), SD_EVENT_OFF (to disable) or - SD_EVENT_ONESHOT. If invoked with - SD_EVENT_ONESHOT the event source will be - enabled but automatically reset to - SD_EVENT_OFF after the event source was - dispatched once. + sd_event_source_set_enabled() may be used to enable or disable the event + source object specified as source. The enabled parameter + takes one of SD_EVENT_ON (to enable), SD_EVENT_OFF (to disable) + or SD_EVENT_ONESHOT. If invoked with SD_EVENT_ONESHOT the event + source will be enabled but automatically reset to SD_EVENT_OFF after one dispatch. + For SD_EVENT_OFF, the event source source may be + NULL, in which case the function does nothing. Otherwise, + source must be a valid pointer to an sd_event_source + object. Event sources that are disabled will not result in event loop wakeups and will not be dispatched, until they are enabled again. - sd_event_source_get_enabled() may be - used to query whether the event source object - source is currently enabled or not. It - returns the enablement state (one of SD_EVENT_ON, - SD_EVENT_OFF, SD_EVENT_ONESHOT) - in enabled, if it is not NULL. - It also returns true if the event source is not disabled. + sd_event_source_get_enabled() may be used to query whether the event source + object source is currently enabled or not. If both the + source and the output parameter enabled are + NULL, this function returns false. Otherwise, source must be + a valid pointer to an sd_event_source object. If the output parameter + enabled is not NULL, it is set to the enablement state (one + of SD_EVENT_ON, SD_EVENT_OFF, + SD_EVENT_ONESHOT). The function also returns true if the event source is not + disabled. Event source objects are enabled when they are first created with calls such as diff --git a/meson.build b/meson.build index 2e8b69c96a..25bcfdba1b 100644 --- a/meson.build +++ b/meson.build @@ -1928,7 +1928,6 @@ alias_target('devel', libsystemd_pc, libudev_pc) libsystemd = shared_library( 'systemd', - disable_mempool_c, version : libsystemd_version, include_directories : libsystemd_includes, link_args : ['-shared', @@ -1953,7 +1952,6 @@ install_libsystemd_static = static_library( basic_gcrypt_sources, basic_compress_sources, fundamental_sources, - disable_mempool_c, include_directories : libsystemd_includes, build_by_default : static_libsystemd != 'false', install : static_libsystemd != 'false', @@ -1975,7 +1973,6 @@ install_libsystemd_static = static_library( libudev = shared_library( 'udev', - disable_mempool_c, version : libudev_version, include_directories : includes, link_args : ['-shared', @@ -1997,7 +1994,6 @@ install_libudev_static = static_library( shared_sources, libsystemd_sources, libudev_sources, - disable_mempool_c, include_directories : includes, build_by_default : static_libudev != 'false', install : static_libudev != 'false', @@ -2118,7 +2114,6 @@ subdir('test') test_dlopen = executable( 'test-dlopen', test_dlopen_c, - disable_mempool_c, include_directories : includes, link_with : [libbasic], dependencies : [libdl], @@ -2148,7 +2143,6 @@ foreach tuple : [['myhostname', 'ENABLE_NSS_MYHOSTNAME'], nss = shared_library( 'nss_' + module, sources, - disable_mempool_c, version : '2', include_directories : incs, # Note that we link NSS modules with '-z nodelete' so that mempools never get orphaned diff --git a/src/basic/hashmap.c b/src/basic/hashmap.c index 62380b0e4a..1fadaad996 100644 --- a/src/basic/hashmap.c +++ b/src/basic/hashmap.c @@ -771,16 +771,15 @@ static void shared_hash_key_initialize(void) { static struct HashmapBase* hashmap_base_new(const struct hash_ops *hash_ops, enum HashmapType type HASHMAP_DEBUG_PARAMS) { HashmapBase *h; const struct hashmap_type_info *hi = &hashmap_type_info[type]; - bool up; - up = mempool_enabled(); + bool use_pool = mempool_enabled && mempool_enabled(); - h = up ? mempool_alloc0_tile(hi->mempool) : malloc0(hi->head_size); + h = use_pool ? mempool_alloc0_tile(hi->mempool) : malloc0(hi->head_size); if (!h) return NULL; h->type = type; - h->from_pool = up; + h->from_pool = use_pool; h->hash_ops = hash_ops ?: &trivial_hash_ops; if (type == HASHMAP_TYPE_ORDERED) { diff --git a/src/basic/mempool.c b/src/basic/mempool.c index 9eedc20c4f..fff23fdbac 100644 --- a/src/basic/mempool.c +++ b/src/basic/mempool.c @@ -3,12 +3,9 @@ #include #include -#include "env-util.h" #include "macro.h" #include "memory-util.h" #include "mempool.h" -#include "process-util.h" -#include "util.h" struct pool { struct pool *next; @@ -73,20 +70,6 @@ void mempool_free_tile(struct mempool *mp, void *p) { mp->freelist = p; } -bool mempool_enabled(void) { - static int b = -1; - - if (!is_main_thread()) - return false; - - if (!mempool_use_allowed) - b = false; - if (b < 0) - b = getenv_bool("SYSTEMD_MEMPOOL") != 0; - - return b; -} - #if VALGRIND void mempool_drop(struct mempool *mp) { struct pool *p = mp->first_pool; diff --git a/src/basic/mempool.h b/src/basic/mempool.h index 0fe2f2789c..539ccbdf06 100644 --- a/src/basic/mempool.h +++ b/src/basic/mempool.h @@ -23,8 +23,7 @@ static struct mempool pool_name = { \ .at_least = alloc_at_least, \ } -extern const bool mempool_use_allowed; -bool mempool_enabled(void); +__attribute__((weak)) bool mempool_enabled(void); #if VALGRIND void mempool_drop(struct mempool *mp); diff --git a/src/basic/socket-util.h b/src/basic/socket-util.h index fdadc9c686..2e36e1a56b 100644 --- a/src/basic/socket-util.h +++ b/src/basic/socket-util.h @@ -129,7 +129,7 @@ static inline int fd_inc_sndbuf(int fd, size_t n) { return fd_set_sndbuf(fd, n, true); } int fd_set_rcvbuf(int fd, size_t n, bool increase); -static inline int fd_inc_rcvbuf(int fd, size_t n) { +static inline int fd_increase_rxbuf(int fd, size_t n) { return fd_set_rcvbuf(fd, n, true); } diff --git a/src/core/manager.c b/src/core/manager.c index bf9d18e96e..5453e5fa9b 100644 --- a/src/core/manager.c +++ b/src/core/manager.c @@ -1005,7 +1005,7 @@ static int manager_setup_notify(Manager *m) { if (fd < 0) return log_error_errno(errno, "Failed to allocate notification socket: %m"); - fd_inc_rcvbuf(fd, NOTIFY_RCVBUF_SIZE); + fd_increase_rxbuf(fd, NOTIFY_RCVBUF_SIZE); m->notify_socket = path_join(m->prefix[EXEC_DIRECTORY_RUNTIME], "systemd/notify"); if (!m->notify_socket) @@ -1093,7 +1093,7 @@ static int manager_setup_cgroups_agent(Manager *m) { if (fd < 0) return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m"); - fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE); + fd_increase_rxbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE); (void) sockaddr_un_unlink(&sa.un); @@ -1157,7 +1157,7 @@ static int manager_setup_user_lookup_fd(Manager *m) { if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, m->user_lookup_fds) < 0) return log_error_errno(errno, "Failed to allocate user lookup socket: %m"); - (void) fd_inc_rcvbuf(m->user_lookup_fds[0], NOTIFY_RCVBUF_SIZE); + (void) fd_increase_rxbuf(m->user_lookup_fds[0], NOTIFY_RCVBUF_SIZE); } if (!m->user_lookup_event_source) { diff --git a/src/home/homed-manager.c b/src/home/homed-manager.c index 12e0ff516c..d114236cf7 100644 --- a/src/home/homed-manager.c +++ b/src/home/homed-manager.c @@ -10,6 +10,8 @@ #include #include +#include "sd-id128.h" + #include "btrfs-util.h" #include "bus-common-errors.h" #include "bus-error.h" @@ -1239,7 +1241,7 @@ static int manager_add_device(Manager *m, sd_device *d) { return 0; if (r < 0) return log_error_errno(r, "Failed to acquire ID_PART_ENTRY_TYPE device property, ignoring: %m"); - if (id128_equal_string(parttype, GPT_USER_HOME) <= 0) { + if (sd_id128_string_equal(parttype, GPT_USER_HOME) <= 0) { log_debug("Found partition (%s) we don't care about, ignoring.", sysfs); return 0; } diff --git a/src/home/homework-luks.c b/src/home/homework-luks.c index bffd75bdd0..97269db80d 100644 --- a/src/home/homework-luks.c +++ b/src/home/homework-luks.c @@ -14,6 +14,7 @@ #include "sd-daemon.h" #include "sd-device.h" #include "sd-event.h" +#include "sd-id128.h" #include "blkid-util.h" #include "blockdev-util.h" @@ -34,7 +35,6 @@ #include "home-util.h" #include "homework-luks.h" #include "homework-mount.h" -#include "id128-util.h" #include "io-util.h" #include "keyring-util.h" #include "memory-util.h" @@ -704,7 +704,7 @@ static int luks_validate( if (!pp) return errno > 0 ? -errno : -EIO; - if (id128_equal_string(blkid_partition_get_type_string(pp), GPT_USER_HOME) <= 0) + if (sd_id128_string_equal(blkid_partition_get_type_string(pp), GPT_USER_HOME) <= 0) continue; if (!streq_ptr(blkid_partition_get_name(pp), label)) diff --git a/src/journal/managed-journal-file.c b/src/journal/managed-journal-file.c index 5c34d14ddc..2672679458 100644 --- a/src/journal/managed-journal-file.c +++ b/src/journal/managed-journal-file.c @@ -375,12 +375,9 @@ ManagedJournalFile* managed_journal_file_close(ManagedJournalFile *f) { } #endif - if (f->file->post_change_timer) { - if (sd_event_source_get_enabled(f->file->post_change_timer, NULL) > 0) - journal_file_post_change(f->file); - - sd_event_source_disable_unref(f->file->post_change_timer); - } + if (sd_event_source_get_enabled(f->file->post_change_timer, NULL) > 0) + journal_file_post_change(f->file); + sd_event_source_disable_unref(f->file->post_change_timer); managed_journal_file_set_offline(f, true); diff --git a/src/libsystemd/disable-mempool.c b/src/libsystemd/disable-mempool.c deleted file mode 100644 index 1baf91f05b..0000000000 --- a/src/libsystemd/disable-mempool.c +++ /dev/null @@ -1,5 +0,0 @@ -/* SPDX-License-Identifier: LGPL-2.1-or-later */ - -#include "mempool.h" - -const bool mempool_use_allowed = false; diff --git a/src/libsystemd/libsystemd.sym b/src/libsystemd/libsystemd.sym index 528e86b663..24dfee7095 100644 --- a/src/libsystemd/libsystemd.sym +++ b/src/libsystemd/libsystemd.sym @@ -781,5 +781,165 @@ global: LIBSYSTEMD_252 { global: + sd_bus_message_read_strv_extend; + sd_bus_error_setfv; + + sd_id128_string_equal; + sd_hwdb_new_from_path; + + sd_netlink_new_from_fd; + sd_netlink_open; + sd_netlink_open_fd; + sd_netlink_increase_rxbuf; + sd_netlink_ref; + sd_netlink_unref; + sd_netlink_send; + sd_netlink_call_async; + sd_netlink_call; + sd_netlink_read; + sd_netlink_get_events; + sd_netlink_get_timeout; + sd_netlink_process; + sd_netlink_wait; + sd_netlink_add_match; + sd_netlink_attach_event; + sd_netlink_detach_event; + sd_netlink_attach_filter; + sd_netlink_message_append_string; + sd_netlink_message_append_strv; + sd_netlink_message_append_flag; + sd_netlink_message_append_u8; + sd_netlink_message_append_u16; + sd_netlink_message_append_u32; + sd_netlink_message_append_u64; + sd_netlink_message_append_s8; + sd_netlink_message_append_s16; + sd_netlink_message_append_s32; + sd_netlink_message_append_s64; + sd_netlink_message_append_data; + sd_netlink_message_append_in_addr; + sd_netlink_message_append_in6_addr; + sd_netlink_message_append_sockaddr_in; + sd_netlink_message_append_sockaddr_in6; + sd_netlink_message_append_ether_addr; + sd_netlink_message_append_cache_info; + sd_netlink_message_open_container; + sd_netlink_message_open_container_union; + sd_netlink_message_close_container; + sd_netlink_message_read; + sd_netlink_message_read_data; + sd_netlink_message_read_data_suffix0; + sd_netlink_message_read_string_strdup; + sd_netlink_message_read_string; + sd_netlink_message_read_strv; + sd_netlink_message_read_u8; + sd_netlink_message_read_u16; + sd_netlink_message_read_u32; + sd_netlink_message_read_ether_addr; + sd_netlink_message_read_cache_info; + sd_netlink_message_read_in_addr; + sd_netlink_message_read_in6_addr; + sd_netlink_message_has_flag; + sd_netlink_message_enter_container; + sd_netlink_message_enter_array; + sd_netlink_message_exit_container; + sd_netlink_message_open_array; + sd_netlink_message_cancel_array; + sd_netlink_message_rewind; + sd_netlink_message_next; + sd_netlink_message_ref; + sd_netlink_message_unref; + sd_netlink_message_request_dump; + sd_netlink_message_is_error; + sd_netlink_message_get_errno; + sd_netlink_message_get_type; + sd_netlink_message_set_flags; + sd_netlink_message_is_broadcast; + sd_netlink_message_get_max_attribute; + sd_netlink_slot_ref; + sd_netlink_slot_unref; + sd_netlink_slot_get_netlink; + sd_netlink_slot_get_userdata; + sd_netlink_slot_set_userdata; + sd_netlink_slot_get_destroy_callback; + sd_netlink_slot_set_destroy_callback; + sd_netlink_slot_get_floating; + sd_netlink_slot_set_floating; + sd_netlink_slot_get_description; + sd_netlink_slot_set_description; + + sd_rtnl_message_get_family; + sd_rtnl_message_new_addr; + sd_rtnl_message_new_addr_update; + sd_rtnl_message_addr_set_prefixlen; + sd_rtnl_message_addr_set_scope; + sd_rtnl_message_addr_set_flags; + sd_rtnl_message_addr_get_family; + sd_rtnl_message_addr_get_prefixlen; + sd_rtnl_message_addr_get_scope; + sd_rtnl_message_addr_get_flags; + sd_rtnl_message_addr_get_ifindex; + sd_rtnl_message_new_link; + sd_rtnl_message_link_set_flags; + sd_rtnl_message_link_set_type; + sd_rtnl_message_link_set_family; + sd_rtnl_message_link_get_ifindex; + sd_rtnl_message_link_get_flags; + sd_rtnl_message_link_get_type; + sd_rtnl_message_new_route; + sd_rtnl_message_route_set_dst_prefixlen; + sd_rtnl_message_route_set_src_prefixlen; + sd_rtnl_message_route_set_scope; + sd_rtnl_message_route_set_flags; + sd_rtnl_message_route_set_table; + sd_rtnl_message_route_set_type; + sd_rtnl_message_route_get_flags; + sd_rtnl_message_route_get_family; + sd_rtnl_message_route_get_protocol; + sd_rtnl_message_route_get_scope; + sd_rtnl_message_route_get_tos; + sd_rtnl_message_route_get_table; + sd_rtnl_message_route_get_dst_prefixlen; + sd_rtnl_message_route_get_src_prefixlen; + sd_rtnl_message_route_get_type; + sd_rtnl_message_new_nexthop; + sd_rtnl_message_nexthop_set_flags; + sd_rtnl_message_nexthop_get_flags; + sd_rtnl_message_nexthop_get_family; + sd_rtnl_message_nexthop_get_protocol; + sd_rtnl_message_new_neigh; + sd_rtnl_message_neigh_set_flags; + sd_rtnl_message_neigh_set_state; + sd_rtnl_message_neigh_get_family; + sd_rtnl_message_neigh_get_ifindex; + sd_rtnl_message_neigh_get_state; + sd_rtnl_message_neigh_get_flags; + sd_rtnl_message_new_addrlabel; + sd_rtnl_message_addrlabel_set_prefixlen; + sd_rtnl_message_addrlabel_get_prefixlen; + sd_rtnl_message_new_routing_policy_rule; + sd_rtnl_message_routing_policy_rule_set_tos; + sd_rtnl_message_routing_policy_rule_get_tos; + sd_rtnl_message_routing_policy_rule_set_table; + sd_rtnl_message_routing_policy_rule_get_table; + sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen; + sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen; + sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen; + sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen; + sd_rtnl_message_routing_policy_rule_set_fib_type; + sd_rtnl_message_routing_policy_rule_get_fib_type; + sd_rtnl_message_routing_policy_rule_set_flags; + sd_rtnl_message_routing_policy_rule_get_flags; + sd_rtnl_message_new_traffic_control; + sd_rtnl_message_traffic_control_get_ifindex; + sd_rtnl_message_traffic_control_get_handle; + sd_rtnl_message_traffic_control_get_parent; + sd_rtnl_message_new_mdb; + + sd_genl_socket_open; + sd_genl_message_new; + sd_genl_message_get_family_name; + sd_genl_message_get_command; + sd_genl_add_match; } LIBSYSTEMD_251; diff --git a/src/libsystemd/meson.build b/src/libsystemd/meson.build index 2701efc8f9..2b288ccb28 100644 --- a/src/libsystemd/meson.build +++ b/src/libsystemd/meson.build @@ -155,10 +155,8 @@ libsystemd_sources = files( 'sd-path/sd-path.c', 'sd-resolve/resolve-private.h', 'sd-resolve/sd-resolve.c', - 'sd-utf8/sd-utf8.c', ) + sd_journal_sources + id128_sources + sd_daemon_sources + sd_event_sources + sd_login_sources -disable_mempool_c = files('disable-mempool.c') libsystemd_c_args = ['-fvisibility=default'] diff --git a/src/libsystemd/sd-bus/bus-convenience.c b/src/libsystemd/sd-bus/bus-convenience.c index a36aeb238e..6a3f2ea0ec 100644 --- a/src/libsystemd/sd-bus/bus-convenience.c +++ b/src/libsystemd/sd-bus/bus-convenience.c @@ -270,7 +270,7 @@ _public_ int sd_bus_reply_method_errorfv( if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) return 0; - bus_error_setfv(&error, name, format, ap); + sd_bus_error_setfv(&error, name, format, ap); return sd_bus_reply_method_error(call, &error); } diff --git a/src/libsystemd/sd-bus/bus-dump.c b/src/libsystemd/sd-bus/bus-dump.c index d67a170a2d..73939d8f7a 100644 --- a/src/libsystemd/sd-bus/bus-dump.c +++ b/src/libsystemd/sd-bus/bus-dump.c @@ -50,7 +50,8 @@ _public_ int sd_bus_message_dump(sd_bus_message *m, FILE *f, uint64_t flags) { unsigned level = 1; int r; - assert(m); + assert_return(m, -EINVAL); + assert_return((flags & ~_SD_BUS_MESSAGE_DUMP_KNOWN_FLAGS) == 0, -EINVAL); if (!f) f = stdout; diff --git a/src/libsystemd/sd-bus/bus-error.c b/src/libsystemd/sd-bus/bus-error.c index 2454a95b9d..218677eac4 100644 --- a/src/libsystemd/sd-bus/bus-error.c +++ b/src/libsystemd/sd-bus/bus-error.c @@ -237,7 +237,7 @@ _public_ int sd_bus_error_set(sd_bus_error *e, const char *name, const char *mes return -r; } -int bus_error_setfv(sd_bus_error *e, const char *name, const char *format, va_list ap) { +_public_ int sd_bus_error_setfv(sd_bus_error *e, const char *name, const char *format, va_list ap) { int r; if (!name) @@ -277,7 +277,7 @@ _public_ int sd_bus_error_setf(sd_bus_error *e, const char *name, const char *fo va_list ap; va_start(ap, format); - r = bus_error_setfv(e, name, format, ap); + r = sd_bus_error_setfv(e, name, format, ap); assert(!name || r < 0); va_end(ap); diff --git a/src/libsystemd/sd-bus/bus-error.h b/src/libsystemd/sd-bus/bus-error.h index 05dabdb737..518493762c 100644 --- a/src/libsystemd/sd-bus/bus-error.h +++ b/src/libsystemd/sd-bus/bus-error.h @@ -11,9 +11,6 @@ bool bus_error_is_dirty(sd_bus_error *e); const char *bus_error_message(const sd_bus_error *e, int error); -int bus_error_setfv(sd_bus_error *e, const char *name, const char *format, va_list ap) _printf_(3,0); -int bus_error_set_errnofv(sd_bus_error *e, int error, const char *format, va_list ap) _printf_(3,0); - #define BUS_ERROR_OOM SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_MEMORY, "Out of memory") #define BUS_ERROR_FAILED SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FAILED, "Operation failed") diff --git a/src/libsystemd/sd-bus/bus-message.c b/src/libsystemd/sd-bus/bus-message.c index 7ab1de80d9..d9c52d64c0 100644 --- a/src/libsystemd/sd-bus/bus-message.c +++ b/src/libsystemd/sd-bus/bus-message.c @@ -674,7 +674,7 @@ _public_ int sd_bus_message_new_method_errorf( assert_return(m, -EINVAL); va_start(ap, format); - bus_error_setfv(&error, name, format, ap); + sd_bus_error_setfv(&error, name, format, ap); va_end(ap); return sd_bus_message_new_method_error(call, m, &error); @@ -4256,7 +4256,7 @@ int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { return 0; } -int bus_message_read_strv_extend(sd_bus_message *m, char ***l) { +_public_ int sd_bus_message_read_strv_extend(sd_bus_message *m, char ***l) { char type; const char *contents, *s; int r; @@ -4299,7 +4299,7 @@ _public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) { assert_return(m->sealed, -EPERM); assert_return(l, -EINVAL); - r = bus_message_read_strv_extend(m, &strv); + r = sd_bus_message_read_strv_extend(m, &strv); if (r <= 0) return r; diff --git a/src/libsystemd/sd-bus/bus-message.h b/src/libsystemd/sd-bus/bus-message.h index b51fb896ed..0439fbd45a 100644 --- a/src/libsystemd/sd-bus/bus-message.h +++ b/src/libsystemd/sd-bus/bus-message.h @@ -159,7 +159,6 @@ static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) { } int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz); -int bus_message_read_strv_extend(sd_bus_message *m, char ***l); int bus_message_from_malloc( sd_bus *bus, diff --git a/src/libsystemd/sd-bus/bus-socket.c b/src/libsystemd/sd-bus/bus-socket.c index bf70e19826..2148351952 100644 --- a/src/libsystemd/sd-bus/bus-socket.c +++ b/src/libsystemd/sd-bus/bus-socket.c @@ -608,7 +608,7 @@ void bus_socket_setup(sd_bus *b) { assert(b); /* Increase the buffers to 8 MB */ - (void) fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE); + (void) fd_increase_rxbuf(b->input_fd, SNDBUF_SIZE); (void) fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE); b->message_version = 1; diff --git a/src/libsystemd/sd-bus/sd-bus.c b/src/libsystemd/sd-bus/sd-bus.c index 13ff6bcb1f..a4d3f479c9 100644 --- a/src/libsystemd/sd-bus/sd-bus.c +++ b/src/libsystemd/sd-bus/sd-bus.c @@ -505,15 +505,15 @@ static int synthesize_connected_signal(sd_bus *bus) { } void bus_set_state(sd_bus *bus, enum bus_state state) { - static const char * const table[_BUS_STATE_MAX] = { - [BUS_UNSET] = "UNSET", - [BUS_WATCH_BIND] = "WATCH_BIND", - [BUS_OPENING] = "OPENING", + static const char* const table[_BUS_STATE_MAX] = { + [BUS_UNSET] = "UNSET", + [BUS_WATCH_BIND] = "WATCH_BIND", + [BUS_OPENING] = "OPENING", [BUS_AUTHENTICATING] = "AUTHENTICATING", - [BUS_HELLO] = "HELLO", - [BUS_RUNNING] = "RUNNING", - [BUS_CLOSING] = "CLOSING", - [BUS_CLOSED] = "CLOSED", + [BUS_HELLO] = "HELLO", + [BUS_RUNNING] = "RUNNING", + [BUS_CLOSING] = "CLOSING", + [BUS_CLOSED] = "CLOSED", }; assert(bus); diff --git a/src/libsystemd/sd-daemon/sd-daemon.c b/src/libsystemd/sd-daemon/sd-daemon.c index c6380768bb..199d10a00e 100644 --- a/src/libsystemd/sd-daemon/sd-daemon.c +++ b/src/libsystemd/sd-daemon/sd-daemon.c @@ -190,7 +190,7 @@ _public_ int sd_is_special(int fd, const char *path) { return 1; } -static int sd_is_socket_internal(int fd, int type, int listening) { +static int is_socket_internal(int fd, int type, int listening) { struct stat st_fd; assert_return(fd >= 0, -EBADF); @@ -239,7 +239,7 @@ _public_ int sd_is_socket(int fd, int family, int type, int listening) { assert_return(fd >= 0, -EBADF); assert_return(family >= 0, -EINVAL); - r = sd_is_socket_internal(fd, type, listening); + r = is_socket_internal(fd, type, listening); if (r <= 0) return r; @@ -267,7 +267,7 @@ _public_ int sd_is_socket_inet(int fd, int family, int type, int listening, uint assert_return(fd >= 0, -EBADF); assert_return(IN_SET(family, 0, AF_INET, AF_INET6), -EINVAL); - r = sd_is_socket_internal(fd, type, listening); + r = is_socket_internal(fd, type, listening); if (r <= 0) return r; @@ -307,7 +307,7 @@ _public_ int sd_is_socket_sockaddr(int fd, int type, const struct sockaddr* addr assert_return(addr_len >= sizeof(sa_family_t), -ENOBUFS); assert_return(IN_SET(addr->sa_family, AF_INET, AF_INET6), -EPFNOSUPPORT); - r = sd_is_socket_internal(fd, type, listening); + r = is_socket_internal(fd, type, listening); if (r <= 0) return r; @@ -362,7 +362,7 @@ _public_ int sd_is_socket_unix(int fd, int type, int listening, const char *path assert_return(fd >= 0, -EBADF); - r = sd_is_socket_internal(fd, type, listening); + r = is_socket_internal(fd, type, listening); if (r <= 0) return r; diff --git a/src/libsystemd/sd-event/event-util.c b/src/libsystemd/sd-event/event-util.c index 8c24e7db63..a36eba9029 100644 --- a/src/libsystemd/sd-event/event-util.c +++ b/src/libsystemd/sd-event/event-util.c @@ -109,20 +109,6 @@ int event_reset_time_relative( return event_reset_time(e, s, clock, usec_add(usec_now, usec), accuracy, callback, userdata, priority, description, force_reset); } -int event_source_disable(sd_event_source *s) { - if (!s) - return 0; - - return sd_event_source_set_enabled(s, SD_EVENT_OFF); -} - -int event_source_is_enabled(sd_event_source *s) { - if (!s) - return false; - - return sd_event_source_get_enabled(s, NULL); -} - int event_add_time_change(sd_event *e, sd_event_source **ret, sd_event_io_handler_t callback, void *userdata) { _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL; _cleanup_close_ int fd = -1; diff --git a/src/libsystemd/sd-event/event-util.h b/src/libsystemd/sd-event/event-util.h index abd043bdcc..c185584412 100644 --- a/src/libsystemd/sd-event/event-util.h +++ b/src/libsystemd/sd-event/event-util.h @@ -27,7 +27,8 @@ int event_reset_time_relative( int64_t priority, const char *description, bool force_reset); -int event_source_disable(sd_event_source *s); -int event_source_is_enabled(sd_event_source *s); +static inline int event_source_disable(sd_event_source *s) { + return sd_event_source_set_enabled(s, SD_EVENT_OFF); +} int event_add_time_change(sd_event *e, sd_event_source **ret, sd_event_io_handler_t callback, void *userdata); diff --git a/src/libsystemd/sd-event/sd-event.c b/src/libsystemd/sd-event/sd-event.c index 50f2bb2804..cea1c009d6 100644 --- a/src/libsystemd/sd-event/sd-event.c +++ b/src/libsystemd/sd-event/sd-event.c @@ -2413,6 +2413,10 @@ fail: } _public_ int sd_event_source_get_enabled(sd_event_source *s, int *ret) { + /* Quick mode: the event source doesn't exist and we only want to query boolean enablement state. */ + if (!s && !ret) + return false; + assert_return(s, -EINVAL); assert_return(!event_pid_changed(s->event), -ECHILD); @@ -2590,8 +2594,13 @@ static int event_source_online( _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) { int r; - assert_return(s, -EINVAL); assert_return(IN_SET(m, SD_EVENT_OFF, SD_EVENT_ON, SD_EVENT_ONESHOT), -EINVAL); + + /* Quick mode: if the source doesn't exist, SD_EVENT_OFF is a noop. */ + if (m == SD_EVENT_OFF && !s) + return 0; + + assert_return(s, -EINVAL); assert_return(!event_pid_changed(s->event), -ECHILD); /* If we are dead anyway, we are fine with turning off sources, but everything else needs to fail. */ diff --git a/src/libsystemd/sd-id128/id128-util.c b/src/libsystemd/sd-id128/id128-util.c index e4a3bbd3eb..1068721dd4 100644 --- a/src/libsystemd/sd-id128/id128-util.c +++ b/src/libsystemd/sd-id128/id128-util.c @@ -206,19 +206,3 @@ int id128_get_product(sd_id128_t *ret) { *ret = uuid; return 0; } - -int id128_equal_string(const char *s, sd_id128_t id) { - sd_id128_t parsed; - int r; - - if (!s) - return false; - - /* Checks if the specified string matches a valid string representation of the specified 128 bit ID/uuid */ - - r = sd_id128_from_string(s, &parsed); - if (r < 0) - return r; - - return sd_id128_equal(parsed, id); -} diff --git a/src/libsystemd/sd-id128/id128-util.h b/src/libsystemd/sd-id128/id128-util.h index 65a278c8ee..17b180c10c 100644 --- a/src/libsystemd/sd-id128/id128-util.h +++ b/src/libsystemd/sd-id128/id128-util.h @@ -34,5 +34,3 @@ extern const struct hash_ops id128_hash_ops; sd_id128_t id128_make_v4_uuid(sd_id128_t id); int id128_get_product(sd_id128_t *ret); - -int id128_equal_string(const char *s, sd_id128_t id); diff --git a/src/libsystemd/sd-id128/sd-id128.c b/src/libsystemd/sd-id128/sd-id128.c index 183d34054d..709c8ffb57 100644 --- a/src/libsystemd/sd-id128/sd-id128.c +++ b/src/libsystemd/sd-id128/sd-id128.c @@ -101,6 +101,22 @@ _public_ int sd_id128_from_string(const char s[], sd_id128_t *ret) { return 0; } +_public_ int sd_id128_string_equal(const char *s, sd_id128_t id) { + sd_id128_t parsed; + int r; + + if (!s) + return false; + + /* Checks if the specified string matches a valid string representation of the specified 128 bit ID/uuid */ + + r = sd_id128_from_string(s, &parsed); + if (r < 0) + return r; + + return sd_id128_equal(parsed, id); +} + _public_ int sd_id128_get_machine(sd_id128_t *ret) { static thread_local sd_id128_t saved_machine_id = {}; int r; diff --git a/src/libsystemd/sd-netlink/netlink-genl.c b/src/libsystemd/sd-netlink/netlink-genl.c index 8c907f2836..74be75d406 100644 --- a/src/libsystemd/sd-netlink/netlink-genl.c +++ b/src/libsystemd/sd-netlink/netlink-genl.c @@ -365,7 +365,7 @@ int genl_get_type_system_and_header_size( return 0; } -int sd_genl_message_new(sd_netlink *nl, const char *family_name, uint8_t cmd, sd_netlink_message **ret) { +_public_ int sd_genl_message_new(sd_netlink *nl, const char *family_name, uint8_t cmd, sd_netlink_message **ret) { const GenericNetlinkFamily *family; int r; @@ -381,7 +381,7 @@ int sd_genl_message_new(sd_netlink *nl, const char *family_name, uint8_t cmd, sd return genl_message_new(nl, family, cmd, ret); } -int sd_genl_message_get_family_name(sd_netlink *nl, sd_netlink_message *m, const char **ret) { +_public_ int sd_genl_message_get_family_name(sd_netlink *nl, sd_netlink_message *m, const char **ret) { const GenericNetlinkFamily *family; uint16_t nlmsg_type; int r; @@ -403,7 +403,7 @@ int sd_genl_message_get_family_name(sd_netlink *nl, sd_netlink_message *m, const return 0; } -int sd_genl_message_get_command(sd_netlink *nl, sd_netlink_message *m, uint8_t *ret) { +_public_ int sd_genl_message_get_command(sd_netlink *nl, sd_netlink_message *m, uint8_t *ret) { struct genlmsghdr *h; uint16_t nlmsg_type; size_t size; @@ -448,7 +448,7 @@ static int genl_family_get_multicast_group_id_by_name(const GenericNetlinkFamily return 0; } -int sd_genl_add_match( +_public_ int sd_genl_add_match( sd_netlink *nl, sd_netlink_slot **ret_slot, const char *family_name, @@ -483,6 +483,6 @@ int sd_genl_add_match( callback, destroy_callback, userdata, description); } -int sd_genl_socket_open(sd_netlink **ret) { +_public_ int sd_genl_socket_open(sd_netlink **ret) { return netlink_open_family(ret, NETLINK_GENERIC); } diff --git a/src/libsystemd/sd-netlink/netlink-internal.h b/src/libsystemd/sd-netlink/netlink-internal.h index 80d28258e2..497ffe9112 100644 --- a/src/libsystemd/sd-netlink/netlink-internal.h +++ b/src/libsystemd/sd-netlink/netlink-internal.h @@ -138,7 +138,12 @@ int message_new_full( sd_netlink_message **ret); int message_new(sd_netlink *nl, sd_netlink_message **ret, uint16_t type); int message_new_synthetic_error(sd_netlink *nl, int error, uint32_t serial, sd_netlink_message **ret); -uint32_t message_get_serial(sd_netlink_message *m); + +static inline uint32_t message_get_serial(sd_netlink_message *m) { + assert(m); + return ASSERT_PTR(m->hdr)->nlmsg_seq; +} + void message_seal(sd_netlink_message *m); int netlink_open_family(sd_netlink **ret, int family); @@ -146,12 +151,10 @@ bool netlink_pid_changed(sd_netlink *nl); int netlink_rqueue_make_room(sd_netlink *nl); int netlink_rqueue_partial_make_room(sd_netlink *nl); -int socket_open(int family); int socket_bind(sd_netlink *nl); int socket_broadcast_group_ref(sd_netlink *nl, unsigned group); int socket_broadcast_group_unref(sd_netlink *nl, unsigned group); int socket_write_message(sd_netlink *nl, sd_netlink_message *m); -int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount); int socket_read_message(sd_netlink *nl); int netlink_add_match_internal( @@ -169,3 +172,30 @@ int netlink_add_match_internal( /* Make sure callbacks don't destroy the netlink connection */ #define NETLINK_DONT_DESTROY(nl) \ _cleanup_(sd_netlink_unrefp) _unused_ sd_netlink *_dont_destroy_##nl = sd_netlink_ref(nl) + +/* nfnl */ +/* TODO: to be exported later */ +int sd_nfnl_socket_open(sd_netlink **ret); +int sd_nfnl_message_batch_begin(sd_netlink *nfnl, sd_netlink_message **ret); +int sd_nfnl_message_batch_end(sd_netlink *nfnl, sd_netlink_message **ret); +int sd_nfnl_nft_message_del_table(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table); +int sd_nfnl_nft_message_new_table(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table); +int sd_nfnl_nft_message_new_basechain(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table, const char *chain, + const char *type, uint8_t hook, int prio); +int sd_nfnl_nft_message_new_rule(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table, const char *chain); +int sd_nfnl_nft_message_new_set(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table, const char *set_name, + uint32_t setid, uint32_t klen); +int sd_nfnl_nft_message_new_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table, const char *set_name); +int sd_nfnl_nft_message_del_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret, + int family, const char *table, const char *set_name); +int sd_nfnl_nft_message_add_setelem(sd_netlink_message *m, + uint32_t num, + const void *key, uint32_t klen, + const void *data, uint32_t dlen); +int sd_nfnl_nft_message_add_setelem_end(sd_netlink_message *m); diff --git a/src/libsystemd/sd-netlink/netlink-message-nfnl.c b/src/libsystemd/sd-netlink/netlink-message-nfnl.c index 9b24f74042..6f32167772 100644 --- a/src/libsystemd/sd-netlink/netlink-message-nfnl.c +++ b/src/libsystemd/sd-netlink/netlink-message-nfnl.c @@ -277,7 +277,7 @@ int sd_nfnl_nft_message_del_setelems_begin( return r; } -static int sd_nfnl_add_data(sd_netlink_message *m, uint16_t attr, const void *data, uint32_t dlen) { +static int add_data(sd_netlink_message *m, uint16_t attr, const void *data, uint32_t dlen) { int r; r = sd_netlink_message_open_container(m, attr); @@ -305,12 +305,12 @@ int sd_nfnl_nft_message_add_setelem( if (r < 0) return r; - r = sd_nfnl_add_data(m, NFTA_SET_ELEM_KEY, key, klen); + r = add_data(m, NFTA_SET_ELEM_KEY, key, klen); if (r < 0) goto cancel; if (data) { - r = sd_nfnl_add_data(m, NFTA_SET_ELEM_DATA, data, dlen); + r = add_data(m, NFTA_SET_ELEM_DATA, data, dlen); if (r < 0) goto cancel; } diff --git a/src/libsystemd/sd-netlink/netlink-message-rtnl.c b/src/libsystemd/sd-netlink/netlink-message-rtnl.c index 87b1c3c3c8..289eb41ca9 100644 --- a/src/libsystemd/sd-netlink/netlink-message-rtnl.c +++ b/src/libsystemd/sd-netlink/netlink-message-rtnl.c @@ -17,7 +17,7 @@ #include "socket-util.h" #include "util.h" -int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { +_public_ int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -35,7 +35,7 @@ int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char return 0; } -int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { +_public_ int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -53,7 +53,7 @@ int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char return 0; } -int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) { +_public_ int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -67,7 +67,7 @@ int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) return 0; } -int sd_rtnl_message_route_set_flags(sd_netlink_message *m, unsigned flags) { +_public_ int sd_rtnl_message_route_set_flags(sd_netlink_message *m, unsigned flags) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -81,7 +81,7 @@ int sd_rtnl_message_route_set_flags(sd_netlink_message *m, unsigned flags) { return 0; } -int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags) { +_public_ int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -96,7 +96,7 @@ int sd_rtnl_message_route_get_flags(sd_netlink_message *m, unsigned *flags) { return 0; } -int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table) { +_public_ int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -110,7 +110,7 @@ int sd_rtnl_message_route_set_table(sd_netlink_message *m, unsigned char table) return 0; } -int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) { +_public_ int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -125,7 +125,7 @@ int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) { return 0; } -int sd_rtnl_message_route_get_type(sd_netlink_message *m, unsigned char *type) { +_public_ int sd_rtnl_message_route_get_type(sd_netlink_message *m, unsigned char *type) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -140,7 +140,7 @@ int sd_rtnl_message_route_get_type(sd_netlink_message *m, unsigned char *type) { return 0; } -int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type) { +_public_ int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -154,7 +154,7 @@ int sd_rtnl_message_route_set_type(sd_netlink_message *m, unsigned char type) { return 0; } -int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *protocol) { +_public_ int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *protocol) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -169,7 +169,7 @@ int sd_rtnl_message_route_get_protocol(sd_netlink_message *m, unsigned char *pro return 0; } -int sd_rtnl_message_route_get_scope(sd_netlink_message *m, unsigned char *scope) { +_public_ int sd_rtnl_message_route_get_scope(sd_netlink_message *m, unsigned char *scope) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -184,7 +184,7 @@ int sd_rtnl_message_route_get_scope(sd_netlink_message *m, unsigned char *scope) return 0; } -int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *tos) { +_public_ int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *tos) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -199,7 +199,7 @@ int sd_rtnl_message_route_get_tos(sd_netlink_message *m, uint8_t *tos) { return 0; } -int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table) { +_public_ int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -214,7 +214,7 @@ int sd_rtnl_message_route_get_table(sd_netlink_message *m, unsigned char *table) return 0; } -int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) { +_public_ int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -229,7 +229,7 @@ int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char return 0; } -int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) { +_public_ int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) { struct rtmsg *rtm; assert_return(m, -EINVAL); @@ -244,7 +244,7 @@ int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char return 0; } -int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret, +_public_ int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int rtm_family, unsigned char rtm_protocol) { struct rtmsg *rtm; @@ -270,7 +270,7 @@ int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret, return 0; } -int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, +_public_ int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int nh_family, unsigned char nh_protocol) { struct nhmsg *nhm; @@ -308,7 +308,7 @@ int sd_rtnl_message_new_nexthop(sd_netlink *rtnl, sd_netlink_message **ret, return 0; } -int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags) { +_public_ int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags) { struct nhmsg *nhm; assert_return(m, -EINVAL); @@ -321,7 +321,7 @@ int sd_rtnl_message_nexthop_set_flags(sd_netlink_message *m, uint8_t flags) { return 0; } -int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret) { +_public_ int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret) { struct nhmsg *nhm; assert_return(m, -EINVAL); @@ -335,7 +335,7 @@ int sd_rtnl_message_nexthop_get_flags(sd_netlink_message *m, uint8_t *ret) { return 0; } -int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family) { +_public_ int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family) { struct nhmsg *nhm; assert_return(m, -EINVAL); @@ -349,7 +349,7 @@ int sd_rtnl_message_nexthop_get_family(sd_netlink_message *m, uint8_t *family) { return 0; } -int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protocol) { +_public_ int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protocol) { struct nhmsg *nhm; assert_return(m, -EINVAL); @@ -363,7 +363,7 @@ int sd_rtnl_message_nexthop_get_protocol(sd_netlink_message *m, uint8_t *protoco return 0; } -int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) { +_public_ int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) { struct ndmsg *ndm; assert_return(m, -EINVAL); @@ -376,7 +376,7 @@ int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) { return 0; } -int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) { +_public_ int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) { struct ndmsg *ndm; assert_return(m, -EINVAL); @@ -389,7 +389,7 @@ int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) { return 0; } -int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) { +_public_ int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) { struct ndmsg *ndm; assert_return(m, -EINVAL); @@ -402,7 +402,7 @@ int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) { return 0; } -int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) { +_public_ int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) { struct ndmsg *ndm; assert_return(m, -EINVAL); @@ -415,7 +415,7 @@ int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) { return 0; } -int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) { +_public_ int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) { struct ndmsg *ndm; assert_return(m, -EINVAL); @@ -430,7 +430,7 @@ int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) { return 0; } -int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) { +_public_ int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) { struct ndmsg *ndm; assert_return(m, -EINVAL); @@ -445,7 +445,13 @@ int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) { return 0; } -int sd_rtnl_message_new_neigh(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int index, int ndm_family) { +_public_ int sd_rtnl_message_new_neigh( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int index, + int ndm_family) { + struct ndmsg *ndm; int r; @@ -472,7 +478,7 @@ int sd_rtnl_message_new_neigh(sd_netlink *rtnl, sd_netlink_message **ret, uint16 return 0; } -int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) { +_public_ int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -488,7 +494,7 @@ int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsign return 0; } -int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) { +_public_ int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -502,7 +508,7 @@ int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) { return 0; } -int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) { +_public_ int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -516,7 +522,7 @@ int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) { return 0; } -int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret, +_public_ int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int index) { struct ifinfomsg *ifi; int r; @@ -541,7 +547,7 @@ int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret, return 0; } -int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { +_public_ int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -559,7 +565,7 @@ int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char pref return 0; } -int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) { +_public_ int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -573,7 +579,7 @@ int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) { return 0; } -int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) { +_public_ int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -587,7 +593,7 @@ int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) { return 0; } -int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) { +_public_ int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -602,7 +608,7 @@ int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) { return 0; } -int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) { +_public_ int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -617,7 +623,7 @@ int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *pre return 0; } -int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) { +_public_ int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -632,7 +638,7 @@ int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) return 0; } -int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) { +_public_ int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -647,7 +653,7 @@ int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) return 0; } -int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) { +_public_ int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) { struct ifaddrmsg *ifa; assert_return(m, -EINVAL); @@ -662,9 +668,13 @@ int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) { return 0; } -int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret, - uint16_t nlmsg_type, int index, - int family) { +_public_ int sd_rtnl_message_new_addr( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int index, + int family) { + struct ifaddrmsg *ifa; int r; @@ -687,8 +697,11 @@ int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret, return 0; } -int sd_rtnl_message_new_addr_update(sd_netlink *rtnl, sd_netlink_message **ret, - int index, int family) { +_public_ int sd_rtnl_message_new_addr_update( + sd_netlink *rtnl, + sd_netlink_message **ret, + int index, + int family) { int r; r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family); @@ -700,7 +713,7 @@ int sd_rtnl_message_new_addr_update(sd_netlink *rtnl, sd_netlink_message **ret, return 0; } -int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) { +_public_ int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -715,7 +728,7 @@ int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) { return 0; } -int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) { +_public_ int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -730,7 +743,7 @@ int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) { return 0; } -int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned short *type) { +_public_ int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned short *type) { struct ifinfomsg *ifi; assert_return(m, -EINVAL); @@ -745,7 +758,7 @@ int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned short *type) { return 0; } -int sd_rtnl_message_get_family(sd_netlink_message *m, int *family) { +_public_ int sd_rtnl_message_get_family(sd_netlink_message *m, int *family) { assert_return(m, -EINVAL); assert_return(family, -EINVAL); @@ -804,7 +817,13 @@ int sd_rtnl_message_get_family(sd_netlink_message *m, int *family) { return -EOPNOTSUPP; } -int sd_rtnl_message_new_addrlabel(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifindex, int ifal_family) { +_public_ int sd_rtnl_message_new_addrlabel( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int ifindex, + int ifal_family) { + struct ifaddrlblmsg *addrlabel; int r; @@ -826,7 +845,7 @@ int sd_rtnl_message_new_addrlabel(sd_netlink *rtnl, sd_netlink_message **ret, ui return 0; } -int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { +_public_ int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) { struct ifaddrlblmsg *addrlabel; assert_return(m, -EINVAL); @@ -843,7 +862,7 @@ int sd_rtnl_message_addrlabel_set_prefixlen(sd_netlink_message *m, unsigned char return 0; } -int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) { +_public_ int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) { struct ifaddrlblmsg *addrlabel; assert_return(m, -EINVAL); @@ -857,7 +876,12 @@ int sd_rtnl_message_addrlabel_get_prefixlen(sd_netlink_message *m, unsigned char return 0; } -int sd_rtnl_message_new_routing_policy_rule(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int ifal_family) { +_public_ int sd_rtnl_message_new_routing_policy_rule( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int ifal_family) { + struct fib_rule_hdr *frh; int r; @@ -877,7 +901,7 @@ int sd_rtnl_message_new_routing_policy_rule(sd_netlink *rtnl, sd_netlink_message return 0; } -int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t tos) { +_public_ int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t tos) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -891,7 +915,7 @@ int sd_rtnl_message_routing_policy_rule_set_tos(sd_netlink_message *m, uint8_t t return 0; } -int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t *tos) { +_public_ int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t *tos) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -905,7 +929,7 @@ int sd_rtnl_message_routing_policy_rule_get_tos(sd_netlink_message *m, uint8_t * return 0; } -int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t table) { +_public_ int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t table) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -919,7 +943,7 @@ int sd_rtnl_message_routing_policy_rule_set_table(sd_netlink_message *m, uint8_t return 0; } -int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t *table) { +_public_ int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t *table) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -933,7 +957,7 @@ int sd_rtnl_message_routing_policy_rule_get_table(sd_netlink_message *m, uint8_t return 0; } -int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_t flags) { +_public_ int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_t flags) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -946,7 +970,7 @@ int sd_rtnl_message_routing_policy_rule_set_flags(sd_netlink_message *m, uint32_ return 0; } -int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_t *flags) { +_public_ int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_t *flags) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -959,7 +983,7 @@ int sd_rtnl_message_routing_policy_rule_get_flags(sd_netlink_message *m, uint32_ return 0; } -int sd_rtnl_message_routing_policy_rule_set_fib_type(sd_netlink_message *m, uint8_t type) { +_public_ int sd_rtnl_message_routing_policy_rule_set_fib_type(sd_netlink_message *m, uint8_t type) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -973,7 +997,7 @@ int sd_rtnl_message_routing_policy_rule_set_fib_type(sd_netlink_message *m, uint return 0; } -int sd_rtnl_message_routing_policy_rule_get_fib_type(sd_netlink_message *m, uint8_t *type) { +_public_ int sd_rtnl_message_routing_policy_rule_get_fib_type(sd_netlink_message *m, uint8_t *type) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -987,7 +1011,7 @@ int sd_rtnl_message_routing_policy_rule_get_fib_type(sd_netlink_message *m, uint return 0; } -int sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(sd_netlink_message *m, uint8_t len) { +_public_ int sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(sd_netlink_message *m, uint8_t len) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -1001,7 +1025,7 @@ int sd_rtnl_message_routing_policy_rule_set_fib_dst_prefixlen(sd_netlink_message return 0; } -int sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(sd_netlink_message *m, uint8_t *len) { +_public_ int sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(sd_netlink_message *m, uint8_t *len) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -1015,7 +1039,7 @@ int sd_rtnl_message_routing_policy_rule_get_fib_dst_prefixlen(sd_netlink_message return 0; } -int sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(sd_netlink_message *m, uint8_t len) { +_public_ int sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(sd_netlink_message *m, uint8_t len) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -1029,7 +1053,7 @@ int sd_rtnl_message_routing_policy_rule_set_fib_src_prefixlen(sd_netlink_message return 0; } -int sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(sd_netlink_message *m, uint8_t *len) { +_public_ int sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(sd_netlink_message *m, uint8_t *len) { struct fib_rule_hdr *frh; assert_return(m, -EINVAL); @@ -1043,7 +1067,7 @@ int sd_rtnl_message_routing_policy_rule_get_fib_src_prefixlen(sd_netlink_message return 0; } -int sd_rtnl_message_new_traffic_control( +_public_ int sd_rtnl_message_new_traffic_control( sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, @@ -1072,7 +1096,7 @@ int sd_rtnl_message_new_traffic_control( return 0; } -int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret) { +_public_ int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret) { struct tcmsg *tcm; assert_return(m, -EINVAL); @@ -1086,7 +1110,7 @@ int sd_rtnl_message_traffic_control_get_ifindex(sd_netlink_message *m, int *ret) return 0; } -int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret) { +_public_ int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t *ret) { struct tcmsg *tcm; assert_return(m, -EINVAL); @@ -1100,7 +1124,7 @@ int sd_rtnl_message_traffic_control_get_handle(sd_netlink_message *m, uint32_t * return 0; } -int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret) { +_public_ int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t *ret) { struct tcmsg *tcm; assert_return(m, -EINVAL); @@ -1114,7 +1138,12 @@ int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t * return 0; } -int sd_rtnl_message_new_mdb(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int mdb_ifindex) { +_public_ int sd_rtnl_message_new_mdb( + sd_netlink *rtnl, + sd_netlink_message **ret, + uint16_t nlmsg_type, + int mdb_ifindex) { + struct br_port_msg *bpm; int r; diff --git a/src/libsystemd/sd-netlink/netlink-message.c b/src/libsystemd/sd-netlink/netlink-message.c index e846399a53..34b4c23bd5 100644 --- a/src/libsystemd/sd-netlink/netlink-message.c +++ b/src/libsystemd/sd-netlink/netlink-message.c @@ -113,7 +113,7 @@ int message_new_synthetic_error(sd_netlink *nl, int error, uint32_t serial, sd_n return 0; } -int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) { +_public_ int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) { assert_return(m, -EINVAL); assert_return(m->hdr, -EINVAL); assert_return(m->protocol != NETLINK_ROUTE || @@ -129,7 +129,7 @@ int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) { DEFINE_TRIVIAL_REF_FUNC(sd_netlink_message, sd_netlink_message); -sd_netlink_message *sd_netlink_message_unref(sd_netlink_message *m) { +_public_ sd_netlink_message* sd_netlink_message_unref(sd_netlink_message *m) { while (m && --m->n_ref == 0) { unsigned i; @@ -146,7 +146,7 @@ sd_netlink_message *sd_netlink_message_unref(sd_netlink_message *m) { return NULL; } -int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) { +_public_ int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) { assert_return(m, -EINVAL); assert_return(type != 0, -EINVAL); @@ -155,7 +155,7 @@ int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) { return 0; } -int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags) { +_public_ int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags) { assert_return(m, -EINVAL); assert_return(flags != 0, -EINVAL); @@ -164,7 +164,7 @@ int sd_netlink_message_set_flags(sd_netlink_message *m, uint16_t flags) { return 0; } -int sd_netlink_message_is_broadcast(sd_netlink_message *m) { +_public_ int sd_netlink_message_is_broadcast(sd_netlink_message *m) { assert_return(m, -EINVAL); return m->multicast_group != 0; @@ -231,7 +231,7 @@ static int message_attribute_has_type(sd_netlink_message *m, size_t *out_size, u return 0; } -int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data) { +_public_ int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data) { size_t length, size; int r; @@ -257,7 +257,7 @@ int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, return 0; } -int sd_netlink_message_append_strv(sd_netlink_message *m, unsigned short type, char * const *data) { +_public_ int sd_netlink_message_append_strv(sd_netlink_message *m, unsigned short type, char * const *data) { size_t length, size; int r; @@ -285,7 +285,7 @@ int sd_netlink_message_append_strv(sd_netlink_message *m, unsigned short type, c return 0; } -int sd_netlink_message_append_flag(sd_netlink_message *m, unsigned short type) { +_public_ int sd_netlink_message_append_flag(sd_netlink_message *m, unsigned short type) { size_t size; int r; @@ -303,7 +303,7 @@ int sd_netlink_message_append_flag(sd_netlink_message *m, unsigned short type) { return 0; } -int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data) { +_public_ int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data) { int r; assert_return(m, -EINVAL); @@ -320,7 +320,7 @@ int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uin return 0; } -int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data) { +_public_ int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data) { int r; assert_return(m, -EINVAL); @@ -337,7 +337,7 @@ int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, ui return 0; } -int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data) { +_public_ int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data) { int r; assert_return(m, -EINVAL); @@ -354,7 +354,7 @@ int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, ui return 0; } -int sd_netlink_message_append_u64(sd_netlink_message *m, unsigned short type, uint64_t data) { +_public_ int sd_netlink_message_append_u64(sd_netlink_message *m, unsigned short type, uint64_t data) { int r; assert_return(m, -EINVAL); @@ -371,7 +371,7 @@ int sd_netlink_message_append_u64(sd_netlink_message *m, unsigned short type, ui return 0; } -int sd_netlink_message_append_s8(sd_netlink_message *m, unsigned short type, int8_t data) { +_public_ int sd_netlink_message_append_s8(sd_netlink_message *m, unsigned short type, int8_t data) { int r; assert_return(m, -EINVAL); @@ -388,7 +388,7 @@ int sd_netlink_message_append_s8(sd_netlink_message *m, unsigned short type, int return 0; } -int sd_netlink_message_append_s16(sd_netlink_message *m, unsigned short type, int16_t data) { +_public_ int sd_netlink_message_append_s16(sd_netlink_message *m, unsigned short type, int16_t data) { int r; assert_return(m, -EINVAL); @@ -405,7 +405,7 @@ int sd_netlink_message_append_s16(sd_netlink_message *m, unsigned short type, in return 0; } -int sd_netlink_message_append_s32(sd_netlink_message *m, unsigned short type, int32_t data) { +_public_ int sd_netlink_message_append_s32(sd_netlink_message *m, unsigned short type, int32_t data) { int r; assert_return(m, -EINVAL); @@ -422,7 +422,7 @@ int sd_netlink_message_append_s32(sd_netlink_message *m, unsigned short type, in return 0; } -int sd_netlink_message_append_s64(sd_netlink_message *m, unsigned short type, int64_t data) { +_public_ int sd_netlink_message_append_s64(sd_netlink_message *m, unsigned short type, int64_t data) { int r; assert_return(m, -EINVAL); @@ -439,7 +439,7 @@ int sd_netlink_message_append_s64(sd_netlink_message *m, unsigned short type, in return 0; } -int sd_netlink_message_append_data(sd_netlink_message *m, unsigned short type, const void *data, size_t len) { +_public_ int sd_netlink_message_append_data(sd_netlink_message *m, unsigned short type, const void *data, size_t len) { int r; assert_return(m, -EINVAL); @@ -471,11 +471,11 @@ int netlink_message_append_in_addr_union(sd_netlink_message *m, unsigned short t return 0; } -int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data) { +_public_ int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data) { return netlink_message_append_in_addr_union(m, type, AF_INET, (const union in_addr_union *) data); } -int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data) { +_public_ int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data) { return netlink_message_append_in_addr_union(m, type, AF_INET6, (const union in_addr_union *) data); } @@ -498,15 +498,15 @@ int netlink_message_append_sockaddr_union(sd_netlink_message *m, unsigned short return 0; } -int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, unsigned short type, const struct sockaddr_in *data) { +_public_ int sd_netlink_message_append_sockaddr_in(sd_netlink_message *m, unsigned short type, const struct sockaddr_in *data) { return netlink_message_append_sockaddr_union(m, type, (const union sockaddr_union *) data); } -int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, unsigned short type, const struct sockaddr_in6 *data) { +_public_ int sd_netlink_message_append_sockaddr_in6(sd_netlink_message *m, unsigned short type, const struct sockaddr_in6 *data) { return netlink_message_append_sockaddr_union(m, type, (const union sockaddr_union *) data); } -int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data) { +_public_ int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data) { int r; assert_return(m, -EINVAL); @@ -543,7 +543,7 @@ int netlink_message_append_hw_addr(sd_netlink_message *m, unsigned short type, c return 0; } -int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info) { +_public_ int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info) { int r; assert_return(m, -EINVAL); @@ -561,7 +561,7 @@ int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short t return 0; } -int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type) { +_public_ int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type) { size_t size; int r; @@ -610,7 +610,7 @@ int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type return 0; } -int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key) { +_public_ int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key) { const NLTypeSystemUnion *type_system_union; int r; @@ -645,7 +645,7 @@ int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned shor return 0; } -int sd_netlink_message_close_container(sd_netlink_message *m) { +_public_ int sd_netlink_message_close_container(sd_netlink_message *m) { assert_return(m, -EINVAL); assert_return(!m->sealed, -EPERM); assert_return(m->n_containers > 0, -EINVAL); @@ -657,7 +657,7 @@ int sd_netlink_message_close_container(sd_netlink_message *m) { return 0; } -int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type) { +_public_ int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type) { int r; assert_return(m, -EINVAL); @@ -675,7 +675,7 @@ int sd_netlink_message_open_array(sd_netlink_message *m, uint16_t type) { return 0; } -int sd_netlink_message_cancel_array(sd_netlink_message *m) { +_public_ int sd_netlink_message_cancel_array(sd_netlink_message *m) { uint32_t rta_len; assert_return(m, -EINVAL); @@ -731,7 +731,7 @@ static int netlink_message_read_internal( return RTA_PAYLOAD(rta); } -int sd_netlink_message_read(sd_netlink_message *m, unsigned short type, size_t size, void *data) { +_public_ int sd_netlink_message_read(sd_netlink_message *m, unsigned short type, size_t size, void *data) { void *attr_data; int r; @@ -741,16 +741,16 @@ int sd_netlink_message_read(sd_netlink_message *m, unsigned short type, size_t s if (r < 0) return r; - if ((size_t) r < size) - return -EIO; + if ((size_t) r > size) + return -ENOBUFS; if (data) - memcpy(data, attr_data, size); + memcpy(data, attr_data, r); return r; } -int sd_netlink_message_read_data(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) { +_public_ int sd_netlink_message_read_data(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) { void *attr_data; int r; @@ -776,7 +776,7 @@ int sd_netlink_message_read_data(sd_netlink_message *m, unsigned short type, siz return r; } -int sd_netlink_message_read_data_suffix0(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) { +_public_ int sd_netlink_message_read_data_suffix0(sd_netlink_message *m, unsigned short type, size_t *ret_size, void **ret_data) { void *attr_data; int r; @@ -802,7 +802,7 @@ int sd_netlink_message_read_data_suffix0(sd_netlink_message *m, unsigned short t return r; } -int sd_netlink_message_read_string_strdup(sd_netlink_message *m, unsigned short type, char **data) { +_public_ int sd_netlink_message_read_string_strdup(sd_netlink_message *m, unsigned short type, char **data) { void *attr_data; int r; @@ -829,7 +829,7 @@ int sd_netlink_message_read_string_strdup(sd_netlink_message *m, unsigned short return 0; } -int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data) { +_public_ int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data) { void *attr_data; int r; @@ -852,7 +852,7 @@ int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, c return 0; } -int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data) { +_public_ int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data) { void *attr_data; int r; @@ -875,7 +875,7 @@ int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8 return 0; } -int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data) { +_public_ int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data) { void *attr_data; bool net_byteorder; int r; @@ -903,7 +903,7 @@ int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint return 0; } -int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data) { +_public_ int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data) { void *attr_data; bool net_byteorder; int r; @@ -931,7 +931,7 @@ int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint return 0; } -int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data) { +_public_ int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data) { void *attr_data; int r; @@ -979,7 +979,7 @@ int netlink_message_read_hw_addr(sd_netlink_message *m, unsigned short type, str return 0; } -int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info) { +_public_ int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info) { void *attr_data; int r; @@ -1026,7 +1026,7 @@ int netlink_message_read_in_addr_union(sd_netlink_message *m, unsigned short typ return 0; } -int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data) { +_public_ int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data) { union in_addr_union u; int r; @@ -1037,7 +1037,7 @@ int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, return r; } -int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data) { +_public_ int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data) { union in_addr_union u; int r; @@ -1048,7 +1048,7 @@ int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, return r; } -int sd_netlink_message_has_flag(sd_netlink_message *m, unsigned short type) { +_public_ int sd_netlink_message_has_flag(sd_netlink_message *m, unsigned short type) { void *attr_data; int r; @@ -1069,7 +1069,7 @@ int sd_netlink_message_has_flag(sd_netlink_message *m, unsigned short type) { return 1; } -int sd_netlink_message_read_strv(sd_netlink_message *m, unsigned short container_type, unsigned short type_id, char ***ret) { +_public_ int sd_netlink_message_read_strv(sd_netlink_message *m, unsigned short container_type, unsigned short type_id, char ***ret) { _cleanup_strv_free_ char **s = NULL; const NLTypeSystem *type_system; const NLType *nl_type; @@ -1166,7 +1166,7 @@ static int netlink_container_parse( return 0; } -int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type_id) { +_public_ int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type_id) { const NLType *nl_type; const NLTypeSystem *type_system; void *container; @@ -1261,7 +1261,7 @@ int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short typ return 0; } -int sd_netlink_message_enter_array(sd_netlink_message *m, unsigned short type_id) { +_public_ int sd_netlink_message_enter_array(sd_netlink_message *m, unsigned short type_id) { void *container; size_t size; int r; @@ -1290,7 +1290,7 @@ int sd_netlink_message_enter_array(sd_netlink_message *m, unsigned short type_id return 0; } -int sd_netlink_message_exit_container(sd_netlink_message *m) { +_public_ int sd_netlink_message_exit_container(sd_netlink_message *m) { assert_return(m, -EINVAL); assert_return(m->sealed, -EINVAL); assert_return(m->n_containers > 0, -EINVAL); @@ -1304,7 +1304,7 @@ int sd_netlink_message_exit_container(sd_netlink_message *m) { return 0; } -int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret) { +_public_ int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret) { assert_return(m, -EINVAL); assert_return(m->sealed, -EINVAL); assert_return(ret, -EINVAL); @@ -1313,21 +1313,14 @@ int sd_netlink_message_get_max_attribute(sd_netlink_message *m, uint16_t *ret) { return 0; } -uint32_t message_get_serial(sd_netlink_message *m) { - assert(m); - assert(m->hdr); - - return m->hdr->nlmsg_seq; -} - -int sd_netlink_message_is_error(sd_netlink_message *m) { +_public_ int sd_netlink_message_is_error(sd_netlink_message *m) { assert_return(m, 0); assert_return(m->hdr, 0); return m->hdr->nlmsg_type == NLMSG_ERROR; } -int sd_netlink_message_get_errno(sd_netlink_message *m) { +_public_ int sd_netlink_message_get_errno(sd_netlink_message *m) { struct nlmsgerr *err; assert_return(m, -EINVAL); @@ -1362,7 +1355,7 @@ static int netlink_message_parse_error(sd_netlink_message *m) { NLMSG_PAYLOAD(m->hdr, hlen)); } -int sd_netlink_message_rewind(sd_netlink_message *m, sd_netlink *nl) { +_public_ int sd_netlink_message_rewind(sd_netlink_message *m, sd_netlink *nl) { size_t size; int r; diff --git a/src/libsystemd/sd-netlink/netlink-socket.c b/src/libsystemd/sd-netlink/netlink-socket.c index 7197cb4daa..70f5b85a54 100644 --- a/src/libsystemd/sd-netlink/netlink-socket.c +++ b/src/libsystemd/sd-netlink/netlink-socket.c @@ -17,16 +17,6 @@ #include "socket-util.h" #include "util.h" -int socket_open(int family) { - int fd; - - fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, family); - if (fd < 0) - return -errno; - - return fd_move_above_stdio(fd); -} - static int broadcast_groups_get(sd_netlink *nl) { _cleanup_free_ uint32_t *groups = NULL; socklen_t len = 0, old_len; @@ -192,32 +182,6 @@ int socket_write_message(sd_netlink *nl, sd_netlink_message *m) { return k; } -int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount) { - _cleanup_free_ struct iovec *iovs = NULL; - ssize_t k; - - assert(nl); - assert(m); - assert(msgcount > 0); - - iovs = new(struct iovec, msgcount); - if (!iovs) - return -ENOMEM; - - for (size_t i = 0; i < msgcount; i++) { - assert(m[i]->hdr); - assert(m[i]->hdr->nlmsg_len > 0); - - iovs[i] = IOVEC_MAKE(m[i]->hdr, m[i]->hdr->nlmsg_len); - } - - k = writev(nl->fd, iovs, msgcount); - if (k < 0) - return -errno; - - return k; -} - static int socket_recv_message(int fd, struct iovec *iov, uint32_t *ret_mcast_group, bool peek) { union sockaddr_union sender; CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct nl_pktinfo))) control; diff --git a/src/libsystemd/sd-netlink/netlink-util.c b/src/libsystemd/sd-netlink/netlink-util.c index ce2c4f3b54..8e05161558 100644 --- a/src/libsystemd/sd-netlink/netlink-util.c +++ b/src/libsystemd/sd-netlink/netlink-util.c @@ -2,11 +2,14 @@ #include "sd-netlink.h" +#include "fd-util.h" #include "format-util.h" +#include "io-util.h" #include "memory-util.h" #include "netlink-internal.h" #include "netlink-util.h" #include "parse-util.h" +#include "process-util.h" #include "strv.h" int rtnl_set_link_name(sd_netlink **rtnl, int ifindex, const char *name) { @@ -628,3 +631,121 @@ int rtattr_read_nexthop(const struct rtnexthop *rtnh, size_t size, int family, O *ret = TAKE_PTR(set); return 0; } + +bool netlink_pid_changed(sd_netlink *nl) { + /* We don't support people creating an nl connection and + * keeping it around over a fork(). Let's complain. */ + return ASSERT_PTR(nl)->original_pid != getpid_cached(); +} + +static int socket_open(int family) { + int fd; + + fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, family); + if (fd < 0) + return -errno; + + return fd_move_above_stdio(fd); +} + +int netlink_open_family(sd_netlink **ret, int family) { + _cleanup_close_ int fd = -1; + int r; + + fd = socket_open(family); + if (fd < 0) + return fd; + + r = sd_netlink_open_fd(ret, fd); + if (r < 0) + return r; + TAKE_FD(fd); + + return 0; +} + +void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m) { + uint32_t picked; + + assert(nl); + assert(!netlink_pid_changed(nl)); + assert(m); + assert(m->hdr); + + /* Avoid collisions with outstanding requests */ + do { + picked = nl->serial; + + /* Don't use seq == 0, as that is used for broadcasts, so we would get confused by replies to + such messages */ + nl->serial = nl->serial == UINT32_MAX ? 1 : nl->serial + 1; + + } while (hashmap_contains(nl->reply_callbacks, UINT32_TO_PTR(picked))); + + m->hdr->nlmsg_seq = picked; + message_seal(m); +} + +static int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount) { + _cleanup_free_ struct iovec *iovs = NULL; + ssize_t k; + + assert(nl); + assert(m); + assert(msgcount > 0); + + iovs = new(struct iovec, msgcount); + if (!iovs) + return -ENOMEM; + + for (size_t i = 0; i < msgcount; i++) { + assert(m[i]->hdr); + assert(m[i]->hdr->nlmsg_len > 0); + + iovs[i] = IOVEC_MAKE(m[i]->hdr, m[i]->hdr->nlmsg_len); + } + + k = writev(nl->fd, iovs, msgcount); + if (k < 0) + return -errno; + + return k; +} + +int sd_netlink_sendv( + sd_netlink *nl, + sd_netlink_message **messages, + size_t msgcount, + uint32_t **ret_serial) { + + _cleanup_free_ uint32_t *serials = NULL; + int r; + + assert_return(nl, -EINVAL); + assert_return(!netlink_pid_changed(nl), -ECHILD); + assert_return(messages, -EINVAL); + assert_return(msgcount > 0, -EINVAL); + + if (ret_serial) { + serials = new(uint32_t, msgcount); + if (!serials) + return -ENOMEM; + } + + for (size_t i = 0; i < msgcount; i++) { + assert_return(!messages[i]->sealed, -EPERM); + + netlink_seal_message(nl, messages[i]); + if (serials) + serials[i] = message_get_serial(messages[i]); + } + + r = socket_writev_message(nl, messages, msgcount); + if (r < 0) + return r; + + if (ret_serial) + *ret_serial = TAKE_PTR(serials); + + return r; +} diff --git a/src/libsystemd/sd-netlink/netlink-util.h b/src/libsystemd/sd-netlink/netlink-util.h index fee450cdc2..606d14eeaf 100644 --- a/src/libsystemd/sd-netlink/netlink-util.h +++ b/src/libsystemd/sd-netlink/netlink-util.h @@ -142,3 +142,8 @@ void rtattr_append_attribute_internal(struct rtattr *rta, unsigned short type, c int rtattr_append_attribute(struct rtattr **rta, unsigned short type, const void *data, size_t data_length); int rtattr_read_nexthop(const struct rtnexthop *rtnh, size_t size, int family, OrderedSet **ret); + +void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m); + +/* TODO: to be exported later */ +int sd_netlink_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcnt, uint32_t **ret_serial); diff --git a/src/libsystemd/sd-netlink/sd-netlink.c b/src/libsystemd/sd-netlink/sd-netlink.c index e23e2cc163..5cb831cb4a 100644 --- a/src/libsystemd/sd-netlink/sd-netlink.c +++ b/src/libsystemd/sd-netlink/sd-netlink.c @@ -12,6 +12,7 @@ #include "netlink-genl.h" #include "netlink-internal.h" #include "netlink-slot.h" +#include "netlink-util.h" #include "process-util.h" #include "socket-util.h" #include "string-util.h" @@ -68,7 +69,7 @@ static int netlink_new(sd_netlink **ret) { return 0; } -int sd_netlink_new_from_fd(sd_netlink **ret, int fd) { +_public_ int sd_netlink_new_from_fd(sd_netlink **ret, int fd) { _cleanup_(sd_netlink_unrefp) sd_netlink *nl = NULL; socklen_t addrlen; int r; @@ -93,7 +94,7 @@ int sd_netlink_new_from_fd(sd_netlink **ret, int fd) { return 0; } -int sd_netlink_open_fd(sd_netlink **ret, int fd) { +_public_ int sd_netlink_open_fd(sd_netlink **ret, int fd) { _cleanup_(sd_netlink_unrefp) sd_netlink *nl = NULL; int r, protocol; @@ -131,40 +132,15 @@ int sd_netlink_open_fd(sd_netlink **ret, int fd) { return 0; } -int netlink_open_family(sd_netlink **ret, int family) { - _cleanup_close_ int fd = -1; - int r; - - fd = socket_open(family); - if (fd < 0) - return fd; - - r = sd_netlink_open_fd(ret, fd); - if (r < 0) - return r; - TAKE_FD(fd); - - return 0; -} - -int sd_netlink_open(sd_netlink **ret) { +_public_ int sd_netlink_open(sd_netlink **ret) { return netlink_open_family(ret, NETLINK_ROUTE); } -bool netlink_pid_changed(sd_netlink *nl) { - assert(nl); - - /* We don't support people creating an nl connection and - * keeping it around over a fork(). Let's complain. */ - - return nl->original_pid != getpid_cached(); -} - -int sd_netlink_inc_rcvbuf(sd_netlink *nl, size_t size) { +_public_ int sd_netlink_increase_rxbuf(sd_netlink *nl, size_t size) { assert_return(nl, -EINVAL); assert_return(!netlink_pid_changed(nl), -ECHILD); - return fd_inc_rcvbuf(nl->fd, size); + return fd_increase_rxbuf(nl->fd, size); } static sd_netlink *netlink_free(sd_netlink *nl) { @@ -204,29 +180,7 @@ static sd_netlink *netlink_free(sd_netlink *nl) { DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_netlink, sd_netlink, netlink_free); -static void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m) { - uint32_t picked; - - assert(nl); - assert(!netlink_pid_changed(nl)); - assert(m); - assert(m->hdr); - - /* Avoid collisions with outstanding requests */ - do { - picked = nl->serial; - - /* Don't use seq == 0, as that is used for broadcasts, so we would get confused by replies to - such messages */ - nl->serial = nl->serial == UINT32_MAX ? 1 : nl->serial + 1; - - } while (hashmap_contains(nl->reply_callbacks, UINT32_TO_PTR(picked))); - - m->hdr->nlmsg_seq = picked; - message_seal(m); -} - -int sd_netlink_send( +_public_ int sd_netlink_send( sd_netlink *nl, sd_netlink_message *message, uint32_t *serial) { @@ -250,44 +204,6 @@ int sd_netlink_send( return 1; } -int sd_netlink_sendv( - sd_netlink *nl, - sd_netlink_message **messages, - size_t msgcount, - uint32_t **ret_serial) { - - _cleanup_free_ uint32_t *serials = NULL; - int r; - - assert_return(nl, -EINVAL); - assert_return(!netlink_pid_changed(nl), -ECHILD); - assert_return(messages, -EINVAL); - assert_return(msgcount > 0, -EINVAL); - - if (ret_serial) { - serials = new(uint32_t, msgcount); - if (!serials) - return -ENOMEM; - } - - for (size_t i = 0; i < msgcount; i++) { - assert_return(!messages[i]->sealed, -EPERM); - - netlink_seal_message(nl, messages[i]); - if (serials) - serials[i] = message_get_serial(messages[i]); - } - - r = socket_writev_message(nl, messages, msgcount); - if (r < 0) - return r; - - if (ret_serial) - *ret_serial = TAKE_PTR(serials); - - return r; -} - int netlink_rqueue_make_room(sd_netlink *nl) { assert(nl); @@ -594,7 +510,7 @@ static int timeout_compare(const void *a, const void *b) { return CMP(x->timeout, y->timeout); } -int sd_netlink_call_async( +_public_ int sd_netlink_call_async( sd_netlink *nl, sd_netlink_slot **ret_slot, sd_netlink_message *m, @@ -659,7 +575,7 @@ int sd_netlink_call_async( return k; } -int sd_netlink_read( +_public_ int sd_netlink_read( sd_netlink *nl, uint32_t serial, uint64_t usec, @@ -736,7 +652,7 @@ int sd_netlink_read( } } -int sd_netlink_call( +_public_ int sd_netlink_call( sd_netlink *nl, sd_netlink_message *message, uint64_t usec, @@ -756,14 +672,14 @@ int sd_netlink_call( return sd_netlink_read(nl, serial, usec, ret); } -int sd_netlink_get_events(sd_netlink *nl) { +_public_ int sd_netlink_get_events(sd_netlink *nl) { assert_return(nl, -EINVAL); assert_return(!netlink_pid_changed(nl), -ECHILD); return nl->rqueue_size == 0 ? POLLIN : 0; } -int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout_usec) { +_public_ int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout_usec) { struct reply_callback *c; assert_return(nl, -EINVAL); @@ -846,7 +762,7 @@ static int prepare_callback(sd_event_source *s, void *userdata) { return 1; } -int sd_netlink_attach_event(sd_netlink *nl, sd_event *event, int64_t priority) { +_public_ int sd_netlink_attach_event(sd_netlink *nl, sd_event *event, int64_t priority) { int r; assert_return(nl, -EINVAL); @@ -898,7 +814,7 @@ fail: return r; } -int sd_netlink_detach_event(sd_netlink *nl) { +_public_ int sd_netlink_detach_event(sd_netlink *nl) { assert_return(nl, -EINVAL); assert_return(nl->event, -ENXIO); @@ -961,7 +877,7 @@ int netlink_add_match_internal( return 0; } -int sd_netlink_add_match( +_public_ int sd_netlink_add_match( sd_netlink *rtnl, sd_netlink_slot **ret_slot, uint16_t type, @@ -1031,7 +947,7 @@ int sd_netlink_add_match( destroy_callback, userdata, description); } -int sd_netlink_attach_filter(sd_netlink *nl, size_t len, struct sock_filter *filter) { +_public_ int sd_netlink_attach_filter(sd_netlink *nl, size_t len, struct sock_filter *filter) { assert_return(nl, -EINVAL); assert_return(len == 0 || filter, -EINVAL); diff --git a/src/libsystemd/sd-resolve/sd-resolve.c b/src/libsystemd/sd-resolve/sd-resolve.c index fdc09ff20f..e4d43e7558 100644 --- a/src/libsystemd/sd-resolve/sd-resolve.c +++ b/src/libsystemd/sd-resolve/sd-resolve.c @@ -506,9 +506,9 @@ _public_ int sd_resolve_new(sd_resolve **ret) { resolve->fds[i] = fd_move_above_stdio(resolve->fds[i]); (void) fd_inc_sndbuf(resolve->fds[REQUEST_SEND_FD], QUERIES_MAX * BUFSIZE); - (void) fd_inc_rcvbuf(resolve->fds[REQUEST_RECV_FD], QUERIES_MAX * BUFSIZE); + (void) fd_increase_rxbuf(resolve->fds[REQUEST_RECV_FD], QUERIES_MAX * BUFSIZE); (void) fd_inc_sndbuf(resolve->fds[RESPONSE_SEND_FD], QUERIES_MAX * BUFSIZE); - (void) fd_inc_rcvbuf(resolve->fds[RESPONSE_RECV_FD], QUERIES_MAX * BUFSIZE); + (void) fd_increase_rxbuf(resolve->fds[RESPONSE_RECV_FD], QUERIES_MAX * BUFSIZE); (void) fd_nonblock(resolve->fds[RESPONSE_RECV_FD], true); diff --git a/src/libsystemd/sd-utf8/sd-utf8.c b/src/libsystemd/sd-utf8/sd-utf8.c deleted file mode 100644 index 82fa125ade..0000000000 --- a/src/libsystemd/sd-utf8/sd-utf8.c +++ /dev/null @@ -1,18 +0,0 @@ -/* SPDX-License-Identifier: LGPL-2.1-or-later */ - -#include "sd-utf8.h" - -#include "utf8.h" -#include "util.h" - -_public_ const char *sd_utf8_is_valid(const char *s) { - assert_return(s, NULL); - - return utf8_is_valid(s); -} - -_public_ const char *sd_ascii_is_valid(const char *s) { - assert_return(s, NULL); - - return ascii_is_valid(s); -} diff --git a/src/network/netdev/wireguard.c b/src/network/netdev/wireguard.c index 2667a9fb2a..99ec09c641 100644 --- a/src/network/netdev/wireguard.c +++ b/src/network/netdev/wireguard.c @@ -405,7 +405,7 @@ static int peer_resolve_endpoint(WireguardPeer *peer) { /* Not necessary to resolve the endpoint. */ return 0; - if (event_source_is_enabled(peer->resolve_retry_event_source) > 0) + if (sd_event_source_get_enabled(peer->resolve_retry_event_source, NULL) > 0) /* Timer event source is enabled. The endpoint will be resolved later. */ return 0; diff --git a/src/network/networkctl.c b/src/network/networkctl.c index 95ef31aab6..2f789e773a 100644 --- a/src/network/networkctl.c +++ b/src/network/networkctl.c @@ -692,7 +692,7 @@ static void acquire_wlan_link_info(LinkInfo *link) { return; } - (void) sd_netlink_inc_rcvbuf(genl, RCVBUF_SIZE); + (void) sd_netlink_increase_rxbuf(genl, RCVBUF_SIZE); r = wifi_get_interface(genl, link->ifindex, &link->wlan_iftype, &link->ssid); if (r < 0) diff --git a/src/network/networkd-manager.c b/src/network/networkd-manager.c index 3cda1110b9..d8a18006d3 100644 --- a/src/network/networkd-manager.c +++ b/src/network/networkd-manager.c @@ -226,7 +226,7 @@ static int manager_connect_genl(Manager *m) { if (r < 0) return r; - r = sd_netlink_inc_rcvbuf(m->genl, RCVBUF_SIZE); + r = sd_netlink_increase_rxbuf(m->genl, RCVBUF_SIZE); if (r < 0) log_warning_errno(r, "Failed to increase receive buffer size for general netlink socket, ignoring: %m"); @@ -298,7 +298,7 @@ static int manager_connect_rtnl(Manager *m) { * case systemd sets the receive buffer size for us, and the value in the .socket unit * should take full effect. */ if (fd < 0) { - r = sd_netlink_inc_rcvbuf(m->rtnl, RCVBUF_SIZE); + r = sd_netlink_increase_rxbuf(m->rtnl, RCVBUF_SIZE); if (r < 0) log_warning_errno(r, "Failed to increase receive buffer size for rtnl socket, ignoring: %m"); } diff --git a/src/shared/bus-map-properties.c b/src/shared/bus-map-properties.c index 84608567aa..e5e8933963 100644 --- a/src/shared/bus-map-properties.c +++ b/src/shared/bus-map-properties.c @@ -30,7 +30,7 @@ int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus char ***p = userdata; int r; - r = bus_message_read_strv_extend(m, &l); + r = sd_bus_message_read_strv_extend(m, &l); if (r < 0) return r; @@ -75,7 +75,7 @@ static int map_basic(sd_bus *bus, const char *member, sd_bus_message *m, unsigne _cleanup_strv_free_ char **l = NULL; char ***p = userdata; - r = bus_message_read_strv_extend(m, &l); + r = sd_bus_message_read_strv_extend(m, &l); if (r < 0) return r; diff --git a/src/shared/enable-mempool.c b/src/shared/enable-mempool.c index 1abfccbd81..fd582c0e78 100644 --- a/src/shared/enable-mempool.c +++ b/src/shared/enable-mempool.c @@ -1,5 +1,19 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ -#include "mempool.h" +#include -const bool mempool_use_allowed = true; +#include "env-util.h" +#include "mempool.h" +#include "process-util.h" + +bool mempool_enabled(void) { + static int cache = -1; + + if (!is_main_thread()) + return false; + + if (cache < 0) + cache = getenv_bool("SYSTEMD_MEMPOOL") != 0; + + return cache; +} diff --git a/src/shared/find-esp.c b/src/shared/find-esp.c index 41eb644aa5..ea27d7911a 100644 --- a/src/shared/find-esp.c +++ b/src/shared/find-esp.c @@ -4,6 +4,7 @@ #include #include "sd-device.h" +#include "sd-id128.h" #include "alloc-util.h" #include "blkid-util.h" @@ -13,7 +14,6 @@ #include "errno-util.h" #include "find-esp.h" #include "gpt.h" -#include "id128-util.h" #include "parse-util.h" #include "path-util.h" #include "stat-util.h" @@ -85,7 +85,7 @@ static int verify_esp_blkid( r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL); if (r != 0) return log_error_errno(errno ?: EIO, "Failed to probe partition type UUID of \"%s\": %m", node); - if (id128_equal_string(v, GPT_ESP) <= 0) + if (sd_id128_string_equal(v, GPT_ESP) <= 0) return log_full_errno(searching ? LOG_DEBUG : LOG_ERR, SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV), "File system \"%s\" has wrong type for an EFI System Partition (ESP).", node); @@ -178,7 +178,7 @@ static int verify_esp_udev( r = sd_device_get_property_value(d, "ID_PART_ENTRY_TYPE", &v); if (r < 0) return log_error_errno(r, "Failed to get device property: %m"); - if (id128_equal_string(v, GPT_ESP) <= 0) + if (sd_id128_string_equal(v, GPT_ESP) <= 0) return log_full_errno(searching ? LOG_DEBUG : LOG_ERR, SYNTHETIC_ERRNO(searching ? EADDRNOTAVAIL : ENODEV), "File system \"%s\" has wrong type for an EFI System Partition (ESP).", node); @@ -510,7 +510,7 @@ static int verify_xbootldr_blkid( r = blkid_probe_lookup_value(b, "PART_ENTRY_TYPE", &v, NULL); if (r != 0) return log_error_errno(errno ?: SYNTHETIC_ERRNO(EIO), "%s: Failed to probe PART_ENTRY_TYPE: %m", node); - if (id128_equal_string(v, GPT_XBOOTLDR) <= 0) + if (sd_id128_string_equal(v, GPT_XBOOTLDR) <= 0) return log_full_errno(searching ? LOG_DEBUG : LOG_ERR, searching ? SYNTHETIC_ERRNO(EADDRNOTAVAIL) : SYNTHETIC_ERRNO(ENODEV), "%s: Partitition has wrong PART_ENTRY_TYPE=%s for XBOOTLDR partition.", node, v); @@ -576,7 +576,7 @@ static int verify_xbootldr_udev( if (r < 0) return log_device_error_errno(d, r, "Failed to query ID_PART_ENTRY_TYPE: %m"); - r = id128_equal_string(v, GPT_XBOOTLDR); + r = sd_id128_string_equal(v, GPT_XBOOTLDR); if (r < 0) return log_device_error_errno(d, r, "Failed to parse ID_PART_ENTRY_TYPE=%s: %m", v); if (r == 0) diff --git a/src/shared/firewall-util-nft.c b/src/shared/firewall-util-nft.c index 2f98e791c2..87a326cafd 100644 --- a/src/shared/firewall-util-nft.c +++ b/src/shared/firewall-util-nft.c @@ -18,6 +18,8 @@ #include "firewall-util-private.h" #include "in-addr-util.h" #include "macro.h" +#include "netlink-internal.h" +#include "netlink-util.h" #include "socket-util.h" #include "time-util.h" diff --git a/src/systemd/meson.build b/src/systemd/meson.build index c13e88b594..6048c13859 100644 --- a/src/systemd/meson.build +++ b/src/systemd/meson.build @@ -12,6 +12,7 @@ _systemd_headers = [ 'sd-journal.h', 'sd-login.h', 'sd-messages.h', + 'sd-netlink.h', 'sd-path.h', ] @@ -32,11 +33,9 @@ _not_installed_headers = [ 'sd-lldp-tx.h', 'sd-lldp.h', 'sd-ndisc.h', - 'sd-netlink.h', 'sd-network.h', 'sd-radv.h', 'sd-resolve.h', - 'sd-utf8.h', ] install_headers( diff --git a/src/systemd/sd-bus.h b/src/systemd/sd-bus.h index cad37d64ba..74bc56b427 100644 --- a/src/systemd/sd-bus.h +++ b/src/systemd/sd-bus.h @@ -102,7 +102,8 @@ __extension__ enum { __extension__ enum { SD_BUS_MESSAGE_DUMP_WITH_HEADER = 1ULL << 0, - SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY = 1ULL << 1 + SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY = 1ULL << 1, + _SD_BUS_MESSAGE_DUMP_KNOWN_FLAGS = SD_BUS_MESSAGE_DUMP_WITH_HEADER | SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY }; /* Callbacks */ @@ -330,6 +331,7 @@ int sd_bus_message_readv(sd_bus_message *m, const char *types, va_list ap); int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p); int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size); int sd_bus_message_read_strv(sd_bus_message *m, char ***l); /* free the result! */ +int sd_bus_message_read_strv_extend(sd_bus_message *m, char ***l); int sd_bus_message_skip(sd_bus_message *m, const char *types); int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents); int sd_bus_message_exit_container(sd_bus_message *m); @@ -445,6 +447,8 @@ int sd_bus_creds_get_description(sd_bus_creds *c, const char **name); void sd_bus_error_free(sd_bus_error *e); int sd_bus_error_set(sd_bus_error *e, const char *name, const char *message); int sd_bus_error_setf(sd_bus_error *e, const char *name, const char *format, ...) _sd_printf_(3, 4); +int sd_bus_error_setfv(sd_bus_error *e, const char *name, const char *format, va_list ap) _sd_printf_(3,0); + int sd_bus_error_set_const(sd_bus_error *e, const char *name, const char *message); int sd_bus_error_set_errno(sd_bus_error *e, int error); int sd_bus_error_set_errnof(sd_bus_error *e, int error, const char *format, ...) _sd_printf_(3, 4); diff --git a/src/systemd/sd-id128.h b/src/systemd/sd-id128.h index cf87e8820f..92682166d7 100644 --- a/src/systemd/sd-id128.h +++ b/src/systemd/sd-id128.h @@ -119,6 +119,8 @@ _sd_pure_ static __inline__ int sd_id128_equal(sd_id128_t a, sd_id128_t b) { return memcmp(&a, &b, 16) == 0; } +int sd_id128_string_equal(const char *s, sd_id128_t id); + _sd_pure_ static __inline__ int sd_id128_is_null(sd_id128_t a) { return a.qwords[0] == 0 && a.qwords[1] == 0; } diff --git a/src/systemd/sd-netlink.h b/src/systemd/sd-netlink.h index 2f748df2b5..dcdf77c4fe 100644 --- a/src/systemd/sd-netlink.h +++ b/src/systemd/sd-netlink.h @@ -43,13 +43,12 @@ typedef _sd_destroy_t sd_netlink_destroy_t; int sd_netlink_new_from_fd(sd_netlink **nl, int fd); int sd_netlink_open(sd_netlink **nl); int sd_netlink_open_fd(sd_netlink **nl, int fd); -int sd_netlink_inc_rcvbuf(sd_netlink *nl, const size_t size); +int sd_netlink_increase_rxbuf(sd_netlink *nl, const size_t size); sd_netlink *sd_netlink_ref(sd_netlink *nl); sd_netlink *sd_netlink_unref(sd_netlink *nl); int sd_netlink_send(sd_netlink *nl, sd_netlink_message *message, uint32_t *serial); -int sd_netlink_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcnt, uint32_t **ret_serial); int sd_netlink_call_async(sd_netlink *nl, sd_netlink_slot **ret_slot, sd_netlink_message *message, sd_netlink_message_handler_t callback, sd_netlink_destroy_t destoy_callback, void *userdata, uint64_t usec, const char *description); @@ -210,32 +209,6 @@ int sd_rtnl_message_traffic_control_get_parent(sd_netlink_message *m, uint32_t * int sd_rtnl_message_new_mdb(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int mdb_ifindex); -/* nfnl */ -int sd_nfnl_socket_open(sd_netlink **ret); -int sd_nfnl_message_batch_begin(sd_netlink *nfnl, sd_netlink_message **ret); -int sd_nfnl_message_batch_end(sd_netlink *nfnl, sd_netlink_message **ret); -int sd_nfnl_nft_message_del_table(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table); -int sd_nfnl_nft_message_new_table(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table); -int sd_nfnl_nft_message_new_basechain(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table, const char *chain, - const char *type, uint8_t hook, int prio); -int sd_nfnl_nft_message_new_rule(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table, const char *chain); -int sd_nfnl_nft_message_new_set(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table, const char *set_name, - uint32_t setid, uint32_t klen); -int sd_nfnl_nft_message_new_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table, const char *set_name); -int sd_nfnl_nft_message_del_setelems_begin(sd_netlink *nfnl, sd_netlink_message **ret, - int family, const char *table, const char *set_name); -int sd_nfnl_nft_message_add_setelem(sd_netlink_message *m, - uint32_t num, - const void *key, uint32_t klen, - const void *data, uint32_t dlen); -int sd_nfnl_nft_message_add_setelem_end(sd_netlink_message *m); - /* genl */ int sd_genl_socket_open(sd_netlink **ret); int sd_genl_message_new(sd_netlink *genl, const char *family_name, uint8_t cmd, sd_netlink_message **ret); diff --git a/src/test/generate-sym-test.py b/src/test/generate-sym-test.py index 955d5e9699..8ed4d26fd3 100755 --- a/src/test/generate-sym-test.py +++ b/src/test/generate-sym-test.py @@ -11,21 +11,26 @@ print(''' /* We want to check deprecated symbols too, without complaining */ #pragma GCC diagnostic ignored "-Wdeprecated-declarations" -const void* symbols[] = {''') +const struct { + const char *name; + const void *symbol; +} symbols[] = {''') +count = 0 for line in open(sys.argv[1]): match = re.search('^ +([a-zA-Z0-9_]+);', line) if match: s = match.group(1) if s == 'sd_bus_object_vtable_format': - print(' &{},'.format(s)) + print(f' {{"{s}", &{s}}},') else: - print(' {},'.format(s)) + print(f' {{"{s}", {s}}},') + count += 1 -print('''}; +print(f'''}}; -int main(void) { - for (size_t i = 0; i < sizeof(symbols)/sizeof(void*); i++) - printf("%p\\n", symbols[i]); +int main(void) {{ + for (size_t i = 0; i < {count}; i++) + printf("%p: %s\\n", symbols[i].symbol, symbols[i].name); return 0; -}''') +}}''') diff --git a/src/test/test-set-disable-mempool.c b/src/test/test-set-disable-mempool.c index f02e433d7b..91244b25ac 100644 --- a/src/test/test-set-disable-mempool.c +++ b/src/test/test-set-disable-mempool.c @@ -2,6 +2,7 @@ #include +#include "mempool.h" #include "process-util.h" #include "set.h" #include "tests.h" @@ -15,6 +16,9 @@ static void* thread(void *p) { assert_se(*s); assert_se(!is_main_thread()); + assert_se(mempool_enabled); + assert_se(!mempool_enabled()); + assert_se(set_size(*s) == NUM); *s = set_free(*s); @@ -29,7 +33,10 @@ static void test_one(const char *val) { log_info("Testing with SYSTEMD_MEMPOOL=%s", val); assert_se(setenv("SYSTEMD_MEMPOOL", val, true) == 0); + assert_se(is_main_thread()); + assert_se(mempool_enabled); /* It is a weak symbol, but we expect it to be available */ + assert_se(!mempool_enabled()); assert_se(s = set_new(NULL)); for (i = 0; i < NUM; i++)