From: Krisztian Litkey Date: Thu, 29 Aug 2013 23:08:43 +0000 (+0300) Subject: common/dbus: added patch for Fedora 18/systemd-201 src.rpm. X-Git-Tag: v0.0.42~12^2~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=108d686c25ed69dd9f73d6d7219b453abdc945e9;p=profile%2Fivi%2Fmurphy.git common/dbus: added patch for Fedora 18/systemd-201 src.rpm. If you download the official Fedora 18 systemd source RPM, patch it with this patch and rebuild, you should get two additional subpackages: systemd-libs-dbus and systemd-libs-dbus-devel. These include a shared version of systemd's dbus library, systemd-bus. Installing these should allow you to test/use the systemd-bus based version of murphy-dbus. --- diff --git a/systemd-201-src-rpm-shared-bus-lib-fedora-18.patch b/systemd-201-src-rpm-shared-bus-lib-fedora-18.patch new file mode 100644 index 0000000..05815b3 --- /dev/null +++ b/systemd-201-src-rpm-shared-bus-lib-fedora-18.patch @@ -0,0 +1,1350 @@ +*** SPECS/systemd.spec.orig 2013-08-30 02:02:28.523413573 +0300 +--- SPECS/systemd.spec 2013-08-30 02:04:26.248492809 +0300 +*************** +*** 103,108 **** +--- 103,111 ---- + # kernel-install patch for grubby, drop if grubby is obsolete + Patch1000: kernel-install-grubby.patch + ++ Patch10000: 0001-systemd-bus-create-a-shared-library-for-public-consu.patch ++ Patch10001: 0001-systemd-bus-export-additional-forgotten-symbols.patch ++ + %global num_patches %{lua: c=0; for i,p in ipairs(patches) do c=c+1; end; print(c);} + + BuildRequires: libcap-devel +*************** +*** 209,214 **** +--- 212,233 ---- + %description devel + Development headers and auxiliary files for developing applications for systemd. + ++ %package libs-dbus ++ Summary: systemd D-Bus client library ++ License: LGPLV2+ ++ Requires: systemd-libs = %{version} ++ ++ %description libs-dbus ++ D-Bus library from the systemd sources. ++ ++ %package libs-dbus-devel ++ Summary: Development headers for systemd-libs-dbus ++ License: LGPLv2+ ++ Requires: systemd-devel = %{version} ++ ++ %description libs-dbus-devel ++ Development files for the D-Bus library from the systemd sources. ++ + %package sysv + Summary: SysV tools for systemd + License: LGPLv2+ +*************** +*** 809,814 **** +--- 828,844 ---- + %dir %{_datadir}/gtk-doc/html/libudev + %{_datadir}/gtk-doc/html/libudev/* + ++ %files libs-dbus ++ %{_libdir}/libsystemd-bus.so.0.0.0 ++ %{_libdir}/libsystemd-bus.so.0 ++ ++ %files libs-dbus-devel ++ %{_includedir}/systemd/sd-bus.h ++ %{_includedir}/systemd/sd-bus-protocol.h ++ %{_includedir}/systemd/bus ++ %{_libdir}/libsystemd-bus.so ++ %{_libdir}/pkgconfig/libsystemd-bus.pc ++ + %files sysv + %{_bindir}/systemd-sysv-convert + +*** /dev/null 2013-07-09 15:36:51.773521412 +0300 +--- SOURCES/0001-systemd-bus-create-a-shared-library-for-public-consu.patch 2013-08-06 23:10:20.960714606 +0300 +*************** +*** 0 **** +--- 1,1257 ---- ++ From 7a53ccec1eee76801a3104cd8f0ac98289716ffa Mon Sep 17 00:00:00 2001 ++ From: Fedora systemd team ++ Date: Tue, 6 Aug 2013 21:38:33 +0300 ++ Subject: [PATCH 1/1] systemd-bus: create a shared library for public ++ consumption. ++ ++ For testing systemd-bus as a libdbus replacement, create a shared ++ library out of it. Note that there might be still some sd_bus_* ++ symbols that do not get properly exported because of missing linker ++ version script entries. ++ ++ Note also, that as a quick fix the symbols referenced by the various ++ test-* test cases have been marked public and exported from the library. ++ This should be just a temporary workaround and we need something more ++ civilized instead. ++ --- ++ Makefile.am | 26 ++++- ++ src/libsystemd-bus/bus-control.c | 14 +-- ++ src/libsystemd-bus/bus-error.c | 15 +-- ++ src/libsystemd-bus/bus-internal.c | 15 ++- ++ src/libsystemd-bus/bus-match.c | 21 ++-- ++ src/libsystemd-bus/bus-message.c | 84 ++++++++-------- ++ src/libsystemd-bus/bus-signature.c | 9 +- ++ src/libsystemd-bus/libsystemd-bus.pc.in | 19 ++++ ++ src/libsystemd-bus/libsystemd-bus.sym | 163 ++++++++++++++++++++++++++++++++ ++ src/libsystemd-bus/sd-bus.c | 78 +++++++-------- ++ 10 files changed, 335 insertions(+), 109 deletions(-) ++ create mode 100644 src/libsystemd-bus/libsystemd-bus.pc.in ++ create mode 100644 src/libsystemd-bus/libsystemd-bus.sym ++ ++ diff --git a/Makefile.am b/Makefile.am ++ index c7b5a4a..faad661 100644 ++ --- a/Makefile.am ++ +++ b/Makefile.am ++ @@ -55,6 +55,10 @@ LIBSYSTEMD_JOURNAL_CURRENT=9 ++ LIBSYSTEMD_JOURNAL_REVISION=0 ++ LIBSYSTEMD_JOURNAL_AGE=9 ++ ++ +LIBSYSTEMD_BUS_CURRENT=0 ++ +LIBSYSTEMD_BUS_REVISION=0 ++ +LIBSYSTEMD_BUS_AGE=0 ++ + ++ # Dirs of external packages ++ dbuspolicydir=@dbuspolicydir@ ++ dbussessionservicedir=@dbussessionservicedir@ ++ @@ -1717,7 +1721,27 @@ libsystemd_bus_la_LIBADD = \ ++ libsystemd-shared.la \ ++ libsystemd-daemon.la ++ ++ -noinst_LTLIBRARIES += \ ++ +libsystemd_bus_la_LDFLAGS = \ ++ + $(AM_LDFLAGS) \ ++ + -version-info $(LIBSYSTEMD_BUS_CURRENT):$(LIBSYSTEMD_BUS_REVISION):$(LIBSYSTEMD_BUS_AGE) \ ++ + -Wl,--version-script=$(top_srcdir)/src/libsystemd-bus/libsystemd-bus.sym ++ + ++ +pkginclude_HEADERS += \ ++ + src/systemd/sd-bus.h \ ++ + src/systemd/sd-bus-protocol.h ++ + ++ +libsystemd_bus_la_HEADERS = \ ++ + src/libsystemd-bus/bus-message.h \ ++ + src/shared/macro.h \ ++ + src/shared/log.h ++ + ++ +libsystemd_bus_ladir = \ ++ + $(includedir)/systemd/bus ++ + ++ +pkgconfiglib_DATA += \ ++ + src/libsystemd-bus/libsystemd-bus.pc ++ + ++ +lib_LTLIBRARIES += \ ++ libsystemd-bus.la ++ ++ noinst_tests += \ ++ diff --git a/src/libsystemd-bus/bus-control.c b/src/libsystemd-bus/bus-control.c ++ index a0abccf..2795cb4 100644 ++ --- a/src/libsystemd-bus/bus-control.c ++ +++ b/src/libsystemd-bus/bus-control.c ++ @@ -29,7 +29,7 @@ ++ #include "bus-message.h" ++ #include "bus-control.h" ++ ++ -int sd_bus_get_unique_name(sd_bus *bus, const char **unique) { ++ +_public_ int sd_bus_get_unique_name(sd_bus *bus, const char **unique) { ++ int r; ++ ++ if (!bus) ++ @@ -45,7 +45,7 @@ int sd_bus_get_unique_name(sd_bus *bus, const char **unique) { ++ return 0; ++ } ++ ++ -int sd_bus_request_name(sd_bus *bus, const char *name, int flags) { ++ +_public_ int sd_bus_request_name(sd_bus *bus, const char *name, int flags) { ++ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; ++ uint32_t ret; ++ int r; ++ @@ -76,7 +76,7 @@ int sd_bus_request_name(sd_bus *bus, const char *name, int flags) { ++ return ret; ++ } ++ ++ -int sd_bus_release_name(sd_bus *bus, const char *name) { ++ +_public_ int sd_bus_release_name(sd_bus *bus, const char *name) { ++ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; ++ uint32_t ret; ++ int r; ++ @@ -106,7 +106,7 @@ int sd_bus_release_name(sd_bus *bus, const char *name) { ++ return ret; ++ } ++ ++ -int sd_bus_list_names(sd_bus *bus, char ***l) { ++ +_public_ int sd_bus_list_names(sd_bus *bus, char ***l) { ++ _cleanup_bus_message_unref_ sd_bus_message *reply1 = NULL, *reply2 = NULL; ++ char **x = NULL; ++ int r; ++ @@ -156,7 +156,7 @@ int sd_bus_list_names(sd_bus *bus, char ***l) { ++ return 0; ++ } ++ ++ -int sd_bus_get_owner(sd_bus *bus, const char *name, char **owner) { ++ +_public_ int sd_bus_get_owner(sd_bus *bus, const char *name, char **owner) { ++ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; ++ const char *found; ++ int r; ++ @@ -196,7 +196,7 @@ int sd_bus_get_owner(sd_bus *bus, const char *name, char **owner) { ++ return 0; ++ } ++ ++ -int sd_bus_get_owner_uid(sd_bus *bus, const char *name, uid_t *uid) { ++ +_public_ int sd_bus_get_owner_uid(sd_bus *bus, const char *name, uid_t *uid) { ++ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; ++ uint32_t u; ++ int r; ++ @@ -229,7 +229,7 @@ int sd_bus_get_owner_uid(sd_bus *bus, const char *name, uid_t *uid) { ++ return 0; ++ } ++ ++ -int sd_bus_get_owner_pid(sd_bus *bus, const char *name, pid_t *pid) { ++ +_public_ int sd_bus_get_owner_pid(sd_bus *bus, const char *name, pid_t *pid) { ++ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; ++ uint32_t u; ++ int r; ++ diff --git a/src/libsystemd-bus/bus-error.c b/src/libsystemd-bus/bus-error.c ++ index 5faa173..145a378 100644 ++ --- a/src/libsystemd-bus/bus-error.c ++ +++ b/src/libsystemd-bus/bus-error.c ++ @@ -38,7 +38,7 @@ bool bus_error_is_dirty(sd_bus_error *e) { ++ return e->name || e->message || e->need_free; ++ } ++ ++ -void sd_bus_error_free(sd_bus_error *e) { ++ +_public_ void sd_bus_error_free(sd_bus_error *e) { ++ if (!e) ++ return; ++ ++ @@ -51,7 +51,7 @@ void sd_bus_error_free(sd_bus_error *e) { ++ e->need_free = false; ++ } ++ ++ -int sd_bus_error_set(sd_bus_error *e, const char *name, const char *format, ...) { ++ +_public_ int sd_bus_error_set(sd_bus_error *e, const char *name, const char *format, ...) { ++ char *n, *m = NULL; ++ va_list ap; ++ int r; ++ @@ -85,7 +85,7 @@ int sd_bus_error_set(sd_bus_error *e, const char *name, const char *format, ...) ++ return 0; ++ } ++ ++ -int sd_bus_error_copy(sd_bus_error *dest, const sd_bus_error *e) { ++ +_public_ int sd_bus_error_copy(sd_bus_error *dest, const sd_bus_error *e) { ++ char *x, *y = NULL; ++ ++ if (!dest) ++ @@ -113,7 +113,7 @@ int sd_bus_error_copy(sd_bus_error *dest, const sd_bus_error *e) { ++ return 0; ++ } ++ ++ -void sd_bus_error_set_const(sd_bus_error *e, const char *name, const char *message) { ++ +_public_ void sd_bus_error_set_const(sd_bus_error *e, const char *name, const char *message) { ++ if (!e) ++ return; ++ if (bus_error_is_dirty(e)) ++ @@ -124,14 +124,14 @@ void sd_bus_error_set_const(sd_bus_error *e, const char *name, const char *messa ++ e->need_free = false; ++ } ++ ++ -int sd_bus_error_is_set(const sd_bus_error *e) { ++ +_public_ int sd_bus_error_is_set(const sd_bus_error *e) { ++ if (!e) ++ return 0; ++ ++ return !!e->name; ++ } ++ ++ -int sd_bus_error_has_name(const sd_bus_error *e, const char *name) { ++ +_public_ int sd_bus_error_has_name(const sd_bus_error *e, const char *name) { ++ if (!e) ++ return 0; ++ ++ @@ -169,7 +169,8 @@ int bus_error_from_errno(sd_bus_error *e, int error) { ++ return error; ++ } ++ ++ -const char *bus_error_message(const sd_bus_error *e, int error) { ++ +/* XXX TODO: for test-* */ ++ +_public_ const char *bus_error_message(const sd_bus_error *e, int error) { ++ if (e && e->message) ++ return e->message; ++ ++ diff --git a/src/libsystemd-bus/bus-internal.c b/src/libsystemd-bus/bus-internal.c ++ index 317f6a8..ec66a11 100644 ++ --- a/src/libsystemd-bus/bus-internal.c ++ +++ b/src/libsystemd-bus/bus-internal.c ++ @@ -101,7 +101,8 @@ bool interface_name_is_valid(const char *p) { ++ return true; ++ } ++ ++ -bool service_name_is_valid(const char *p) { ++ +/* XXX TODO: for busctl */ ++ +_public_ bool service_name_is_valid(const char *p) { ++ const char *q; ++ bool dot, found_dot, unique; ++ ++ @@ -187,11 +188,13 @@ static bool complex_pattern_check(char c, const char *a, const char *b) { ++ } ++ } ++ ++ -bool namespace_complex_pattern(const char *pattern, const char *value) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool namespace_complex_pattern(const char *pattern, const char *value) { ++ return complex_pattern_check('.', pattern, value); ++ } ++ ++ -bool path_complex_pattern(const char *pattern, const char *value) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool path_complex_pattern(const char *pattern, const char *value) { ++ return complex_pattern_check('/', pattern, value); ++ } ++ ++ @@ -207,11 +210,13 @@ static bool simple_pattern_check(char c, const char *a, const char *b) { ++ } ++ } ++ ++ -bool namespace_simple_pattern(const char *pattern, const char *value) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool namespace_simple_pattern(const char *pattern, const char *value) { ++ return simple_pattern_check('.', pattern, value); ++ } ++ ++ -bool path_simple_pattern(const char *pattern, const char *value) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool path_simple_pattern(const char *pattern, const char *value) { ++ return simple_pattern_check('/', pattern, value); ++ } ++ ++ diff --git a/src/libsystemd-bus/bus-match.c b/src/libsystemd-bus/bus-match.c ++ index fed25c1..6907a5f 100644 ++ --- a/src/libsystemd-bus/bus-match.c ++ +++ b/src/libsystemd-bus/bus-match.c ++ @@ -196,7 +196,8 @@ static bool value_node_same( ++ } ++ } ++ ++ -int bus_match_run( ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_match_run( ++ sd_bus *bus, ++ struct bus_match_node *node, ++ int ret, ++ @@ -546,7 +547,8 @@ static int bus_match_find_leaf( ++ return 0; ++ } ++ ++ -enum bus_match_node_type bus_match_node_type_from_string(const char *k, size_t n) { ++ +/* XXX TODO: for test-* */ ++ +_public_ enum bus_match_node_type bus_match_node_type_from_string(const char *k, size_t n) { ++ assert(k); ++ ++ if (n == 4 && memcmp(k, "type", 4) == 0) ++ @@ -788,7 +790,8 @@ fail: ++ return r; ++ } ++ ++ -int bus_match_add( ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_match_add( ++ struct bus_match_node *root, ++ const char *match, ++ sd_bus_message_handler_t callback, ++ @@ -829,7 +832,8 @@ finish: ++ return r; ++ } ++ ++ -int bus_match_remove( ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_match_remove( ++ struct bus_match_node *root, ++ const char *match, ++ sd_bus_message_handler_t callback, ++ @@ -884,7 +888,8 @@ finish: ++ return r; ++ } ++ ++ -void bus_match_free(struct bus_match_node *node) { ++ +/* XXX TODO: for test-* */ ++ +_public_ void bus_match_free(struct bus_match_node *node) { ++ struct bus_match_node *c; ++ ++ if (!node) ++ @@ -906,7 +911,8 @@ void bus_match_free(struct bus_match_node *node) { ++ bus_match_node_free(node); ++ } ++ ++ -const char* bus_match_node_type_to_string(enum bus_match_node_type t, char buf[], size_t l) { ++ +/* XXX TODO: for test-* */ ++ +_public_ const char* bus_match_node_type_to_string(enum bus_match_node_type t, char buf[], size_t l) { ++ switch (t) { ++ ++ case BUS_MATCH_ROOT: ++ @@ -956,7 +962,8 @@ const char* bus_match_node_type_to_string(enum bus_match_node_type t, char buf[] ++ } ++ } ++ ++ -void bus_match_dump(struct bus_match_node *node, unsigned level) { ++ +/* XXX TODO: for test-* */ ++ +_public_ void bus_match_dump(struct bus_match_node *node, unsigned level) { ++ struct bus_match_node *c; ++ _cleanup_free_ char *pfx = NULL; ++ char buf[32]; ++ diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c ++ index 2d051e8..0e33faf 100644 ++ --- a/src/libsystemd-bus/bus-message.c ++ +++ b/src/libsystemd-bus/bus-message.c ++ @@ -225,7 +225,8 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) ++ return 0; ++ } ++ ++ -int bus_message_from_malloc( ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_message_from_malloc( ++ void *buffer, ++ size_t length, ++ int *fds, ++ @@ -337,7 +338,7 @@ static sd_bus_message *message_new(sd_bus *bus, uint8_t type) { ++ return m; ++ } ++ ++ -int sd_bus_message_new_signal( ++ +_public_ int sd_bus_message_new_signal( ++ sd_bus *bus, ++ const char *path, ++ const char *interface, ++ @@ -382,7 +383,7 @@ fail: ++ return r; ++ } ++ ++ -int sd_bus_message_new_method_call( ++ +_public_ int sd_bus_message_new_method_call( ++ sd_bus *bus, ++ const char *destination, ++ const char *path, ++ @@ -480,7 +481,7 @@ fail: ++ return r; ++ } ++ ++ -int sd_bus_message_new_method_return( ++ +_public_ int sd_bus_message_new_method_return( ++ sd_bus *bus, ++ sd_bus_message *call, ++ sd_bus_message **m) { ++ @@ -488,7 +489,7 @@ int sd_bus_message_new_method_return( ++ return message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_RETURN, m); ++ } ++ ++ -int sd_bus_message_new_method_error( ++ +_public_ int sd_bus_message_new_method_error( ++ sd_bus *bus, ++ sd_bus_message *call, ++ const sd_bus_error *e, ++ @@ -524,7 +525,7 @@ fail: ++ return r; ++ } ++ ++ -sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { ++ +_public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ @@ -534,7 +535,7 @@ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) { ++ return m; ++ } ++ ++ -sd_bus_message* sd_bus_message_unref(sd_bus_message *m) { ++ +_public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ @@ -547,7 +548,7 @@ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) { ++ return NULL; ++ } ++ ++ -int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) { ++ +_public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) { ++ if (!m) ++ return -EINVAL; ++ if (!type) ++ @@ -557,7 +558,7 @@ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) { ++ return 0; ++ } ++ ++ -int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) { ++ +_public_ int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) { ++ if (!m) ++ return -EINVAL; ++ if (!serial) ++ @@ -569,7 +570,7 @@ int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) { ++ return 0; ++ } ++ ++ -int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) { ++ +_public_ int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) { ++ if (!m) ++ return -EINVAL; ++ if (!serial) ++ @@ -581,48 +582,48 @@ int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) { ++ return 0; ++ } ++ ++ -int sd_bus_message_get_no_reply(sd_bus_message *m) { ++ +_public_ int sd_bus_message_get_no_reply(sd_bus_message *m) { ++ if (!m) ++ return -EINVAL; ++ ++ return m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0; ++ } ++ ++ -const char *sd_bus_message_get_path(sd_bus_message *m) { ++ +_public_ const char *sd_bus_message_get_path(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ return m->path; ++ } ++ ++ -const char *sd_bus_message_get_interface(sd_bus_message *m) { ++ +_public_ const char *sd_bus_message_get_interface(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ return m->interface; ++ } ++ ++ -const char *sd_bus_message_get_member(sd_bus_message *m) { ++ +_public_ const char *sd_bus_message_get_member(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ return m->member; ++ } ++ -const char *sd_bus_message_get_destination(sd_bus_message *m) { ++ +_public_ const char *sd_bus_message_get_destination(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ return m->destination; ++ } ++ ++ -const char *sd_bus_message_get_sender(sd_bus_message *m) { ++ +_public_ const char *sd_bus_message_get_sender(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ return m->sender; ++ } ++ ++ -const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) { ++ +_public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ @@ -632,7 +633,7 @@ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) { ++ return &m->error; ++ } ++ ++ -int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) { ++ +_public_ int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) { ++ if (!m) ++ return -EINVAL; ++ if (!m->uid_valid) ++ @@ -642,7 +643,7 @@ int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) { ++ return 0; ++ } ++ ++ -int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) { ++ +_public_ int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) { ++ if (!m) ++ return -EINVAL; ++ if (!m->gid_valid) ++ @@ -652,7 +653,7 @@ int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) { ++ return 0; ++ } ++ ++ -int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) { ++ +_public_ int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) { ++ if (!m) ++ return -EINVAL; ++ if (m->pid <= 0) ++ @@ -662,7 +663,7 @@ int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) { ++ return 0; ++ } ++ ++ -int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) { ++ +_public_ int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) { ++ if (!m) ++ return -EINVAL; ++ if (m->tid <= 0) ++ @@ -672,14 +673,14 @@ int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) { ++ return 0; ++ } ++ ++ -const char *sd_bus_message_get_label(sd_bus_message *m) { ++ +_public_ const char *sd_bus_message_get_label(sd_bus_message *m) { ++ if (!m) ++ return NULL; ++ ++ return m->label; ++ } ++ ++ -int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) { ++ +_public_ int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) { ++ if (!m) ++ return -EINVAL; ++ ++ @@ -695,7 +696,7 @@ int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const cha ++ return 1; ++ } ++ ++ -int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) { ++ +_public_ int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) { ++ if (!m) ++ return -EINVAL; ++ ++ @@ -711,7 +712,7 @@ int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, cons ++ return 1; ++ } ++ ++ -int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { ++ +_public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { ++ if (!m) ++ return -EINVAL; ++ ++ @@ -724,7 +725,7 @@ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) { ++ return 1; ++ } ++ ++ -int sd_bus_message_set_no_reply(sd_bus_message *m, int b) { ++ +_public_ int sd_bus_message_set_no_reply(sd_bus_message *m, int b) { ++ if (!m) ++ return -EINVAL; ++ if (m->sealed) ++ @@ -937,7 +938,7 @@ fail: ++ return r; ++ } ++ ++ -int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { ++ +_public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) { ++ return message_append_basic(m, type, p, NULL); ++ } ++ ++ @@ -1164,7 +1165,7 @@ static int bus_message_open_dict_entry( ++ return 0; ++ } ++ ++ -int sd_bus_message_open_container( ++ +_public_ int sd_bus_message_open_container( ++ sd_bus_message *m, ++ char type, ++ const char *contents) { ++ @@ -1220,7 +1221,7 @@ int sd_bus_message_open_container( ++ return 0; ++ } ++ ++ -int sd_bus_message_close_container(sd_bus_message *m) { ++ +_public_ int sd_bus_message_close_container(sd_bus_message *m) { ++ struct bus_container *c; ++ ++ if (!m) ++ @@ -1400,7 +1401,7 @@ int bus_message_append_ap( ++ return 0; ++ } ++ ++ -int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { ++ +_public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) { ++ va_list ap; ++ int r; ++ ++ @@ -1514,7 +1515,7 @@ static bool validate_object_path(const char *s, size_t l) { ++ return true; ++ } ++ ++ -int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { ++ +_public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) { ++ struct bus_container *c; ++ int r; ++ void *q; ++ @@ -1843,7 +1844,7 @@ static int bus_message_enter_dict_entry( ++ return 1; ++ } ++ ++ -int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents) { ++ +_public_ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents) { ++ struct bus_container *c, *w; ++ uint32_t *array_size = NULL; ++ char *signature; ++ @@ -1916,7 +1917,7 @@ int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *con ++ return 1; ++ } ++ ++ -int sd_bus_message_exit_container(sd_bus_message *m) { ++ +_public_ int sd_bus_message_exit_container(sd_bus_message *m) { ++ struct bus_container *c; ++ ++ if (!m) ++ @@ -1945,7 +1946,7 @@ int sd_bus_message_exit_container(sd_bus_message *m) { ++ return 1; ++ } ++ ++ -int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { ++ +_public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) { ++ struct bus_container *c; ++ int r; ++ ++ @@ -2067,7 +2068,7 @@ eof: ++ return 0; ++ } ++ ++ -int sd_bus_message_rewind(sd_bus_message *m, int complete) { ++ +_public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) { ++ struct bus_container *c; ++ ++ if (!m) ++ @@ -2224,7 +2225,7 @@ static int message_read_ap(sd_bus_message *m, const char *types, va_list ap) { ++ return 1; ++ } ++ ++ -int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { ++ +_public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) { ++ va_list ap; ++ int r; ++ ++ @@ -2711,7 +2712,8 @@ static void setup_iovec(sd_bus_message *m) { ++ } ++ } ++ ++ -int bus_message_seal(sd_bus_message *m, uint64_t serial) { ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_message_seal(sd_bus_message *m, uint64_t serial) { ++ int r; ++ ++ assert(m); ++ @@ -2743,7 +2745,7 @@ int bus_message_seal(sd_bus_message *m, uint64_t serial) { ++ return 0; ++ } ++ ++ -int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { ++ +_public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { ++ if (!m) ++ return -EINVAL; ++ if (!destination) ++ @@ -2756,7 +2758,8 @@ int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) { ++ return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination); ++ } ++ ++ -int bus_message_dump(sd_bus_message *m) { ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_message_dump(sd_bus_message *m) { ++ unsigned level = 1; ++ int r; ++ ++ @@ -2953,7 +2956,8 @@ int bus_message_dump(sd_bus_message *m) { ++ return 0; ++ } ++ ++ -int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { ++ +/* XXX TODO: for test-* */ ++ +_public_ int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) { ++ size_t total; ++ unsigned i; ++ void *p, *e; ++ diff --git a/src/libsystemd-bus/bus-signature.c b/src/libsystemd-bus/bus-signature.c ++ index a92b712..3755d08 100644 ++ --- a/src/libsystemd-bus/bus-signature.c ++ +++ b/src/libsystemd-bus/bus-signature.c ++ @@ -110,7 +110,8 @@ int signature_element_length(const char *s, size_t *l) { ++ return signature_element_length_internal(s, true, 0, 0, l); ++ } ++ ++ -bool signature_is_single(const char *s) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool signature_is_single(const char *s) { ++ int r; ++ size_t t; ++ ++ @@ -123,7 +124,8 @@ bool signature_is_single(const char *s) { ++ return s[t] == 0; ++ } ++ ++ -bool signature_is_pair(const char *s) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool signature_is_pair(const char *s) { ++ assert(s); ++ ++ if (!bus_type_is_basic(*s)) ++ @@ -132,7 +134,8 @@ bool signature_is_pair(const char *s) { ++ return signature_is_single(s + 1); ++ } ++ ++ -bool signature_is_valid(const char *s, bool allow_dict_entry) { ++ +/* XXX TODO: for test-* */ ++ +_public_ bool signature_is_valid(const char *s, bool allow_dict_entry) { ++ const char *p; ++ int r; ++ ++ diff --git a/src/libsystemd-bus/libsystemd-bus.pc.in b/src/libsystemd-bus/libsystemd-bus.pc.in ++ new file mode 100644 ++ index 0000000..6907a1d ++ --- /dev/null ++ +++ b/src/libsystemd-bus/libsystemd-bus.pc.in ++ @@ -0,0 +1,19 @@ ++ +# This file is part of systemd. ++ +# ++ +# systemd is free software; you can redistribute it and/or modify it ++ +# under the terms of the GNU Lesser General Public License as published by ++ +# the Free Software Foundation; either version 2.1 of the License, or ++ +# (at your option) any later version. ++ + ++ +prefix=@prefix@ ++ +exec_prefix=@exec_prefix@ ++ +libdir=@libdir@ ++ +includedir=@includedir@ ++ + ++ +Name: systemd ++ +Description: systemd D-Bus client library ++ +URL: @PACKAGE_URL@ ++ +Version: @PACKAGE_VERSION@ ++ +Requires: libsystemd-daemon = @PACKAGE_VERSION@ ++ +Libs: -L${libdir} -lsystemd-bus ++ +Cflags: -I${includedir} -I${includedir}/systemd -I${includedir}/systemd/bus ++ diff --git a/src/libsystemd-bus/libsystemd-bus.sym b/src/libsystemd-bus/libsystemd-bus.sym ++ new file mode 100644 ++ index 0000000..02f63c0 ++ --- /dev/null ++ +++ b/src/libsystemd-bus/libsystemd-bus.sym ++ @@ -0,0 +1,163 @@ ++ +{ ++ +global: ++ + sd_bus_open_system; ++ + sd_bus_open_user; ++ + sd_bus_new; ++ + sd_bus_set_address; ++ + sd_bus_set_fd; ++ + sd_bus_set_exec; ++ + sd_bus_set_bus_client; ++ + sd_bus_set_server; ++ + sd_bus_set_anonymous; ++ + sd_bus_set_negotiate_fds; ++ + sd_bus_negotiate_attach_comm; ++ + sd_bus_negotiate_attach_exe; ++ + sd_bus_negotiate_attach_cmdline; ++ + sd_bus_negotiate_attach_cgroup; ++ + sd_bus_negotiate_attach_caps; ++ + sd_bus_negotiate_attach_selinux_context; ++ + sd_bus_negotiate_attach_audit; ++ + sd_bus_start; ++ + sd_bus_close; ++ + sd_bus_ref; ++ + sd_bus_unref; ++ + sd_bus_is_open; ++ + sd_bus_can_send; ++ + sd_bus_get_server_id; ++ + sd_bus_send; ++ + sd_bus_send_with_reply; ++ + sd_bus_send_with_reply_cancel; ++ + sd_bus_send_with_reply_and_block; ++ + sd_bus_get_fd; ++ + sd_bus_get_events; ++ + sd_bus_get_timeout; ++ + sd_bus_process; ++ + sd_bus_wait; ++ + sd_bus_flush; ++ + sd_bus_add_filter; ++ + sd_bus_remove_filter; ++ + sd_bus_add_object; ++ + sd_bus_remove_object; ++ + sd_bus_add_fallback; ++ + sd_bus_remove_fallback; ++ + sd_bus_add_match; ++ + sd_bus_remove_match; ++ + sd_bus_message_new_signal; ++ + sd_bus_message_new_method_call; ++ + sd_bus_message_new_method_return; ++ + sd_bus_message_new_method_error; ++ + sd_bus_message_ref; ++ + sd_bus_message_unref; ++ + sd_bus_message_get_type; ++ + sd_bus_message_get_serial; ++ + sd_bus_message_get_reply_serial; ++ + sd_bus_message_get_no_reply; ++ + sd_bus_message_get_error; ++ + sd_bus_message_get_uid; ++ + sd_bus_message_get_gid; ++ + sd_bus_message_get_pid; ++ + sd_bus_message_get_tid; ++ + sd_bus_message_get_pid_starttime; ++ + sd_bus_message_get_selinux_context; ++ + sd_bus_message_get_monotonic_timestamp; ++ + sd_bus_message_get_realtime_timestamp; ++ + sd_bus_message_get_comm; ++ + sd_bus_message_get_tid_comm; ++ + sd_bus_message_get_exe; ++ + sd_bus_message_get_cgroup; ++ + sd_bus_message_get_unit; ++ + sd_bus_message_get_user_unit; ++ + sd_bus_message_get_session; ++ + sd_bus_message_get_owner_uid; ++ + sd_bus_message_get_cmdline; ++ + sd_bus_message_get_audit_sessionid; ++ + sd_bus_message_get_audit_loginuid; ++ + sd_bus_message_get_label; ++ + sd_bus_message_has_effective_cap; ++ + sd_bus_message_is_signal; ++ + sd_bus_message_is_method_call; ++ + sd_bus_message_is_method_error; ++ + sd_bus_message_set_no_reply; ++ + sd_bus_message_set_destination; ++ + sd_bus_message_append; ++ + sd_bus_message_append_basic; ++ + sd_bus_message_append_array; ++ + sd_bus_message_append_array_space; ++ + sd_bus_message_append_array_memfd; ++ + sd_bus_message_append_string_space; ++ + sd_bus_message_append_string_memfd; ++ + sd_bus_message_open_container; ++ + sd_bus_message_close_container; ++ + sd_bus_message_read; ++ + sd_bus_message_read_basic; ++ + sd_bus_message_read_array; ++ + sd_bus_message_enter_container; ++ + sd_bus_message_exit_container; ++ + sd_bus_message_peek_type; ++ + sd_bus_message_rewind; ++ + sd_bus_emit_signal; ++ + sd_bus_call_method; ++ + sd_bus_reply_method_return; ++ + sd_bus_reply_method_error; ++ + sd_bus_get_unique_name; ++ + sd_bus_request_name; ++ + sd_bus_release_name; ++ + sd_bus_list_names; ++ + sd_bus_get_owner; ++ + sd_bus_get_owner_uid; ++ + sd_bus_get_owner_pid; ++ + sd_bus_get_owner_machine_id; ++ + sd_bus_error_free; ++ + sd_bus_error_set; ++ + sd_bus_error_set_const; ++ + sd_bus_error_copy; ++ + sd_bus_error_is_set; ++ + sd_bus_error_has_name; ++ + sd_bus_message_get_type; ++ + sd_bus_message_get_serial; ++ + sd_bus_message_get_reply_serial; ++ + sd_bus_message_get_no_reply; ++ + sd_bus_message_get_path; ++ + sd_bus_message_get_interface; ++ + sd_bus_message_get_member; ++ + sd_bus_message_get_sender; ++ + sd_bus_message_get_error; ++ + sd_bus_message_get_uid; ++ + sd_memfd_new; ++ + sd_memfd_make; ++ + sd_memfd_free; ++ + sd_memfd_get_fd; ++ + sd_memfd_get_file; ++ + sd_memfd_dup_fd; ++ + sd_memfd_map; ++ + sd_memfd_set_sealed; ++ + sd_memfd_get_sealed; ++ + sd_memfd_get_size; ++ + sd_memfd_set_size; ++ + sd_memfd_new_and_map; ++ + bus_message_seal; ++ + bus_message_dump; ++ + bus_message_from_malloc; ++ + bus_message_get_blob; ++ + bus_message_to_errno; ++ + bus_error_message; ++ + bus_match_add; ++ + bus_match_run; ++ + bus_match_free; ++ + bus_match_dump; ++ + bus_match_remove; ++ + bus_match_parse; ++ + bus_match_parse_free; ++ + bus_match_node_type_to_string; ++ + bus_match_node_type_from_string; ++ + bus_kernel_create; ++ + service_name_is_valid; ++ + signature_is_valid; ++ + signature_is_pair; ++ + signature_is_single; ++ + namespace_complex_pattern; ++ + namespace_simple_pattern; ++ + path_complex_pattern; ++ +local: ++ + *; ++ +}; ++ diff --git a/src/libsystemd-bus/sd-bus.c b/src/libsystemd-bus/sd-bus.c ++ index 2f084c2..b53d8fb 100644 ++ --- a/src/libsystemd-bus/sd-bus.c ++ +++ b/src/libsystemd-bus/sd-bus.c ++ @@ -89,7 +89,7 @@ static void bus_free(sd_bus *b) { ++ free(b); ++ } ++ ++ -int sd_bus_new(sd_bus **ret) { ++ +_public_ int sd_bus_new(sd_bus **ret) { ++ sd_bus *r; ++ ++ if (!ret) ++ @@ -116,7 +116,7 @@ int sd_bus_new(sd_bus **ret) { ++ return 0; ++ } ++ ++ -int sd_bus_set_address(sd_bus *bus, const char *address) { ++ +_public_ int sd_bus_set_address(sd_bus *bus, const char *address) { ++ char *a; ++ ++ if (!bus) ++ @@ -136,7 +136,7 @@ int sd_bus_set_address(sd_bus *bus, const char *address) { ++ return 0; ++ } ++ ++ -int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) { ++ +_public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) { ++ if (!bus) ++ return -EINVAL; ++ if (bus->state != BUS_UNSET) ++ @@ -151,7 +151,7 @@ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) { ++ return 0; ++ } ++ ++ -int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) { ++ +_public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) { ++ char *p, **a; ++ ++ if (!bus) ++ @@ -182,7 +182,7 @@ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) { ++ return 0; ++ } ++ ++ -int sd_bus_set_bus_client(sd_bus *bus, int b) { ++ +_public_ int sd_bus_set_bus_client(sd_bus *bus, int b) { ++ if (!bus) ++ return -EINVAL; ++ if (bus->state != BUS_UNSET) ++ @@ -192,7 +192,7 @@ int sd_bus_set_bus_client(sd_bus *bus, int b) { ++ return 0; ++ } ++ ++ -int sd_bus_set_negotiate_fds(sd_bus *bus, int b) { ++ +_public_ int sd_bus_set_negotiate_fds(sd_bus *bus, int b) { ++ if (!bus) ++ return -EINVAL; ++ if (bus->state != BUS_UNSET) ++ @@ -202,7 +202,7 @@ int sd_bus_set_negotiate_fds(sd_bus *bus, int b) { ++ return 0; ++ } ++ ++ -int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) { ++ +_public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) { ++ if (!bus) ++ return -EINVAL; ++ if (!b && !sd_id128_equal(server_id, SD_ID128_NULL)) ++ @@ -215,7 +215,7 @@ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) { ++ return 0; ++ } ++ ++ -int sd_bus_set_anonymous(sd_bus *bus, int b) { ++ +_public_ int sd_bus_set_anonymous(sd_bus *bus, int b) { ++ if (!bus) ++ return -EINVAL; ++ if (bus->state != BUS_UNSET) ++ @@ -742,7 +742,7 @@ static int bus_start_fd(sd_bus *b) { ++ return bus_socket_take_fd(b); ++ } ++ ++ -int sd_bus_start(sd_bus *bus) { ++ +_public_ int sd_bus_start(sd_bus *bus) { ++ int r; ++ ++ if (!bus) ++ @@ -768,7 +768,7 @@ int sd_bus_start(sd_bus *bus) { ++ return bus_send_hello(bus); ++ } ++ ++ -int sd_bus_open_system(sd_bus **ret) { ++ +_public_ int sd_bus_open_system(sd_bus **ret) { ++ const char *e; ++ sd_bus *b; ++ int r; ++ @@ -805,7 +805,7 @@ fail: ++ return r; ++ } ++ ++ -int sd_bus_open_user(sd_bus **ret) { ++ +_public_ int sd_bus_open_user(sd_bus **ret) { ++ const char *e; ++ sd_bus *b; ++ size_t l; ++ @@ -855,7 +855,7 @@ fail: ++ return r; ++ } ++ ++ -void sd_bus_close(sd_bus *bus) { ++ +_public_ void sd_bus_close(sd_bus *bus) { ++ if (!bus) ++ return; ++ ++ @@ -867,7 +867,7 @@ void sd_bus_close(sd_bus *bus) { ++ bus->input_fd = bus->output_fd = -1; ++ } ++ ++ -sd_bus *sd_bus_ref(sd_bus *bus) { ++ +_public_ sd_bus *sd_bus_ref(sd_bus *bus) { ++ if (!bus) ++ return NULL; ++ ++ @@ -877,7 +877,7 @@ sd_bus *sd_bus_ref(sd_bus *bus) { ++ return bus; ++ } ++ ++ -sd_bus *sd_bus_unref(sd_bus *bus) { ++ +_public_ sd_bus *sd_bus_unref(sd_bus *bus) { ++ if (!bus) ++ return NULL; ++ ++ @@ -890,14 +890,14 @@ sd_bus *sd_bus_unref(sd_bus *bus) { ++ return NULL; ++ } ++ ++ -int sd_bus_is_open(sd_bus *bus) { ++ +_public_ int sd_bus_is_open(sd_bus *bus) { ++ if (!bus) ++ return -EINVAL; ++ ++ return bus->state != BUS_UNSET && bus->input_fd >= 0; ++ } ++ ++ -int sd_bus_can_send(sd_bus *bus, char type) { ++ +_public_ int sd_bus_can_send(sd_bus *bus, char type) { ++ int r; ++ ++ if (!bus) ++ @@ -919,7 +919,7 @@ int sd_bus_can_send(sd_bus *bus, char type) { ++ return bus_type_is_valid(type); ++ } ++ ++ -int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) { ++ +_public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) { ++ int r; ++ ++ if (!bus) ++ @@ -1025,7 +1025,7 @@ static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) { ++ return 1; ++ } ++ ++ -int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) { ++ +_public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) { ++ int r; ++ ++ if (!bus) ++ @@ -1126,7 +1126,7 @@ static int timeout_compare(const void *a, const void *b) { ++ return 0; ++ } ++ ++ -int sd_bus_send_with_reply( ++ +_public_ int sd_bus_send_with_reply( ++ sd_bus *bus, ++ sd_bus_message *m, ++ sd_bus_message_handler_t callback, ++ @@ -1199,7 +1199,7 @@ int sd_bus_send_with_reply( ++ return r; ++ } ++ ++ -int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) { ++ +_public_ int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) { ++ struct reply_callback *c; ++ ++ if (!bus) ++ @@ -1246,7 +1246,7 @@ int bus_ensure_running(sd_bus *bus) { ++ } ++ } ++ ++ -int sd_bus_send_with_reply_and_block( ++ +_public_ int sd_bus_send_with_reply_and_block( ++ sd_bus *bus, ++ sd_bus_message *m, ++ uint64_t usec, ++ @@ -1372,7 +1372,7 @@ int sd_bus_send_with_reply_and_block( ++ } ++ } ++ ++ -int sd_bus_get_fd(sd_bus *bus) { ++ +_public_ int sd_bus_get_fd(sd_bus *bus) { ++ if (!bus) ++ return -EINVAL; ++ if (bus->input_fd < 0) ++ @@ -1383,7 +1383,7 @@ int sd_bus_get_fd(sd_bus *bus) { ++ return bus->input_fd; ++ } ++ ++ -int sd_bus_get_events(sd_bus *bus) { ++ +_public_ int sd_bus_get_events(sd_bus *bus) { ++ int flags = 0; ++ ++ if (!bus) ++ @@ -1412,7 +1412,7 @@ int sd_bus_get_events(sd_bus *bus) { ++ return flags; ++ } ++ ++ -int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) { ++ +_public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) { ++ struct reply_callback *c; ++ ++ if (!bus) ++ @@ -1883,7 +1883,7 @@ null_message: ++ return r; ++ } ++ ++ -int sd_bus_process(sd_bus *bus, sd_bus_message **ret) { ++ +_public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) { ++ int r; ++ ++ /* Returns 0 when we didn't do anything. This should cause the ++ @@ -1985,7 +1985,7 @@ static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) { ++ return r > 0 ? 1 : 0; ++ } ++ ++ -int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) { ++ +_public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) { ++ ++ if (!bus) ++ return -EINVAL; ++ @@ -1999,7 +1999,7 @@ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) { ++ return bus_poll(bus, false, timeout_usec); ++ } ++ ++ -int sd_bus_flush(sd_bus *bus) { ++ +_public_ int sd_bus_flush(sd_bus *bus) { ++ int r; ++ ++ if (!bus) ++ @@ -2030,7 +2030,7 @@ int sd_bus_flush(sd_bus *bus) { ++ } ++ } ++ ++ -int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) { ++ struct filter_callback *f; ++ ++ if (!bus) ++ @@ -2049,7 +2049,7 @@ int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *user ++ return 0; ++ } ++ ++ -int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) { ++ struct filter_callback *f; ++ ++ if (!bus) ++ @@ -2147,23 +2147,23 @@ static int bus_remove_object( ++ return 1; ++ } ++ ++ -int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) { ++ return bus_add_object(bus, false, path, callback, userdata); ++ } ++ ++ -int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) { ++ return bus_remove_object(bus, false, path, callback, userdata); ++ } ++ ++ -int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) { ++ return bus_add_object(bus, true, prefix, callback, userdata); ++ } ++ ++ -int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) { ++ return bus_remove_object(bus, true, prefix, callback, userdata); ++ } ++ ++ -int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) { ++ int r = 0; ++ ++ if (!bus) ++ @@ -2190,7 +2190,7 @@ int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t ca ++ return r; ++ } ++ ++ -int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) { ++ +_public_ int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) { ++ int r = 0, q = 0; ++ ++ if (!bus) ++ @@ -2211,7 +2211,7 @@ int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t ++ return q; ++ } ++ ++ -int sd_bus_emit_signal( ++ +_public_ int sd_bus_emit_signal( ++ sd_bus *bus, ++ const char *path, ++ const char *interface, ++ @@ -2238,7 +2238,7 @@ int sd_bus_emit_signal( ++ return sd_bus_send(bus, m, NULL); ++ } ++ ++ -int sd_bus_call_method( ++ +_public_ int sd_bus_call_method( ++ sd_bus *bus, ++ const char *destination, ++ const char *path, ++ @@ -2268,7 +2268,7 @@ int sd_bus_call_method( ++ return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply); ++ } ++ ++ -int sd_bus_reply_method_return( ++ +_public_ int sd_bus_reply_method_return( ++ sd_bus *bus, ++ sd_bus_message *call, ++ const char *types, ...) { ++ @@ -2302,7 +2302,7 @@ int sd_bus_reply_method_return( ++ return sd_bus_send(bus, m, NULL); ++ } ++ ++ -int sd_bus_reply_method_error( ++ +_public_ int sd_bus_reply_method_error( ++ sd_bus *bus, ++ sd_bus_message *call, ++ const sd_bus_error *e) { ++ -- ++ 1.8.1.4 ++ +*** /dev/null 2013-07-09 15:36:51.773521412 +0300 +--- SOURCES/0001-systemd-bus-export-additional-forgotten-symbols.patch 2013-08-16 14:17:03.251343617 +0300 +*************** +*** 0 **** +--- 1,24 ---- ++ From a102e7847a3f9358717a8d864a7285b123fdb171 Mon Sep 17 00:00:00 2001 ++ From: Krisztian Litkey ++ Date: Fri, 16 Aug 2013 14:16:27 +0300 ++ Subject: [PATCH 1/1] systemd-bus: export additional forgotten symbols. ++ ++ --- ++ src/libsystemd-bus/libsystemd-bus.sym | 1 + ++ 1 file changed, 1 insertion(+) ++ ++ diff --git a/src/libsystemd-bus/libsystemd-bus.sym b/src/libsystemd-bus/libsystemd-bus.sym ++ index 15a8747..ee6bb53 100644 ++ --- a/src/libsystemd-bus/libsystemd-bus.sym ++ +++ b/src/libsystemd-bus/libsystemd-bus.sym ++ @@ -116,6 +116,7 @@ global: ++ sd_bus_message_get_serial; ++ sd_bus_message_get_reply_serial; ++ sd_bus_message_get_no_reply; ++ + sd_bus_message_get_destination; ++ sd_bus_message_get_path; ++ sd_bus_message_get_interface; ++ sd_bus_message_get_member; ++ -- ++ 1.8.1.4 ++