return m;
}
-int sd_bus_message_new_signal(
+_public_ int sd_bus_message_new_signal(
sd_bus *bus,
const char *path,
const char *interface,
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,
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) {
return message_new_reply(bus, call, SD_BUS_MESSAGE_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,
return r;
}
-int sd_bus_message_new_method_errorf(
+_public_ int sd_bus_message_new_method_errorf(
sd_bus *bus,
sd_bus_message *call,
sd_bus_message **m,
return sd_bus_message_new_method_error(bus, call, &error, m);
}
-int sd_bus_message_new_method_errno(
+_public_ int sd_bus_message_new_method_errno(
sd_bus *bus,
sd_bus_message *call,
int error,
return sd_bus_message_new_method_error(bus, call, &berror, m);
}
-int sd_bus_message_new_method_errnof(
+_public_ int sd_bus_message_new_method_errnof(
sd_bus *bus,
sd_bus_message *call,
sd_bus_message **m,
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) {
assert_return(m, NULL);
assert(m->n_ref > 0);
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) {
assert_return(m, NULL);
assert(m->n_ref > 0);
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) {
assert_return(m, -EINVAL);
assert_return(type, -EINVAL);
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) {
assert_return(m, -EINVAL);
assert_return(serial, -EINVAL);
assert_return(m->header->serial != 0, -ENOENT);
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) {
assert_return(m, -EINVAL);
assert_return(serial, -EINVAL);
assert_return(m->reply_serial != 0, -ENOENT);
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) {
assert_return(m, -EINVAL);
return m->header->type == SD_BUS_MESSAGE_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) {
assert_return(m, 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) {
assert_return(m, 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) {
assert_return(m, 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) {
assert_return(m, 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) {
assert_return(m, 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) {
assert_return(m, NULL);
assert_return(sd_bus_error_is_set(&m->error), NULL);
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) {
assert_return(m, -EINVAL);
assert_return(uid, -EINVAL);
assert_return(m->uid_valid, -ESRCH);
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) {
assert_return(m, -EINVAL);
assert_return(gid, -EINVAL);
assert_return(m->gid_valid, -ESRCH);
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) {
assert_return(m, -EINVAL);
assert_return(pid, -EINVAL);
assert_return(m->pid > 0, -ESRCH);
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) {
assert_return(m, -EINVAL);
assert_return(tid, -EINVAL);
assert_return(m->tid > 0, -ESRCH);
return 0;
}
-int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
assert_return(m, -EINVAL);
assert_return(usec, -EINVAL);
assert_return(m->pid_starttime > 0, -ESRCH);
return 0;
}
-int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
assert_return(m, -EINVAL);
assert_return(m->label, -ESRCH);
return 0;
}
-int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
assert_return(m, -EINVAL);
assert_return(usec, -EINVAL);
assert_return(m->monotonic > 0, -ESRCH);
return 0;
}
-int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
assert_return(m, -EINVAL);
assert_return(usec, -EINVAL);
assert_return(m->realtime > 0, -ESRCH);
return 0;
}
-int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
assert_return(m, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(m->comm, -ESRCH);
return 0;
}
-int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
assert_return(m, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(m->tid_comm, -ESRCH);
return 0;
}
-int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
assert_return(m, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(m->exe, -ESRCH);
return 0;
}
-int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
assert_return(m, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(m->cgroup, -ESRCH);
return 0;
}
-int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
+_public_ int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
int r;
assert_return(m, -EINVAL);
return 0;
}
-int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
+_public_ int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
assert_return(m, -EINVAL);
assert_return(uid, -EINVAL);
assert_return(m->cgroup, -ESRCH);
return cg_path_get_owner_uid(m->cgroup, uid);
}
-int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
+_public_ int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
size_t n, i;
const char *p;
bool first;
return 0;
}
-int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
+_public_ int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
assert_return(m, -EINVAL);
assert_return(sessionid, -EINVAL);
assert_return(m->audit, -ESRCH);
return 0;
}
-int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
+_public_ int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
assert_return(m, -EINVAL);
assert_return(uid, -EINVAL);
assert_return(m->audit, -ESRCH);
return 0;
}
-int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
+_public_ int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
unsigned sz;
assert_return(m, -EINVAL);
return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8)));
}
-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) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
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) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
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) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
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) {
assert_return(m, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EPERM);
int r;
assert_return(m, -EINVAL);
- assert_return(p, -EINVAL);
assert_return(!m->sealed, -EPERM);
assert_return(bus_type_is_basic(type), -EINVAL);
assert_return(!m->poisoned, -ESTALE);
break;
case SD_BUS_TYPE_BOOLEAN:
+
+ if (!p) {
+ r = -EINVAL;
+ goto fail;
+ }
+
align = sz = 4;
assert_cc(sizeof(int) == sizeof(uint32_t));
case SD_BUS_TYPE_UNIX_FD: {
int z, *f;
+ if (!p) {
+ r = -EINVAL;
+ goto fail;
+ }
+
if (!m->allow_fds) {
r = -ENOTSUP;
goto fail;
}
default:
+ if (!p) {
+ r = -EINVAL;
+ goto fail;
+ }
+
align = bus_type_get_alignment(type);
sz = bus_type_get_size(type);
break;
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);
}
-int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) {
+_public_ int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) {
struct bus_container *c;
void *a;
return 0;
}
-int sd_bus_message_open_container(
+_public_ int sd_bus_message_open_container(
sd_bus_message *m,
char type,
const char *contents) {
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;
assert_return(m, -EINVAL);
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;
return r;
}
-int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, void **ptr) {
+_public_ int sd_bus_message_append_array_space(sd_bus_message *m,
+ char type,
+ size_t size,
+ void **ptr) {
ssize_t align, sz;
void *a;
int r;
return 0;
}
-int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size) {
+_public_ int sd_bus_message_append_array(sd_bus_message *m,
+ char type,
+ const void *ptr,
+ size_t size) {
int r;
void *p;
return 0;
}
-int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *memfd) {
+_public_ int sd_bus_message_append_array_memfd(sd_bus_message *m,
+ char type,
+ sd_memfd *memfd) {
_cleanup_close_ int copy_fd = -1;
struct bus_body_part *part;
ssize_t align, sz;
return sd_bus_message_close_container(m);
}
-int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) {
+_public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) {
_cleanup_close_ int copy_fd = -1;
struct bus_body_part *part;
struct bus_container *c;
return 0;
}
-int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
+_public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
char **i;
int r;
return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
}
-int sd_bus_message_at_end(sd_bus_message *m, int complete) {
+_public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) {
assert_return(m, -EINVAL);
assert_return(m->sealed, -EPERM);
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;
void *q;
int r;
case SD_BUS_TYPE_BOOLEAN:
if (p)
- *(unsigned*) p = !!*(uint32_t*) q;
+ *(int*) p = !!*(uint32_t*) q;
break;
case SD_BUS_TYPE_INT16:
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;
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;
assert_return(m, -EINVAL);
assert_return(m->sealed, -EPERM);
- assert_return(m->n_containers > 0, -EINVAL);
+ assert_return(m->n_containers > 0, -ENXIO);
c = message_get_container(m);
if (c->enclosing == SD_BUS_TYPE_ARRAY) {
} else {
if (c->signature && c->signature[c->index] != 0)
- return -EINVAL;
+ return -EBUSY;
}
free(c->signature);
c->index = c->saved_index;
}
-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;
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;
assert_return(m, -EINVAL);
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;
return r;
}
-int sd_bus_message_skip(sd_bus_message *m, const char *types) {
+_public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
int r;
assert_return(m, -EINVAL);
}
}
-int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size) {
+_public_ int sd_bus_message_read_array(sd_bus_message *m,
+ char type,
+ const void **ptr,
+ size_t *size) {
struct bus_container *c;
void *p;
size_t sz;
c = message_get_container(m);
sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
- r = message_peek_body(m, &m->rindex, align, sz, &p);
- if (r < 0)
- goto fail;
- if (r == 0) {
- r = -EBADMSG;
- goto fail;
+ if (sz == 0)
+ /* Zero length array, let's return some aligned
+ * pointer that is not NULL */
+ p = (uint8_t*) NULL + align;
+ else {
+ r = message_peek_body(m, &m->rindex, align, sz, &p);
+ if (r < 0)
+ goto fail;
+ if (r == 0) {
+ r = -EBADMSG;
+ goto fail;
+ }
}
r = sd_bus_message_exit_container(m);
if (!streq(signature, "s"))
return -EBADMSG;
- r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination);
+ r = message_peek_field_string(m, sender_name_is_valid, &ri, &m->destination);
break;
case SD_BUS_MESSAGE_HEADER_SENDER:
if (!streq(signature, "s"))
return -EBADMSG;
- r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);
+ r = message_peek_field_string(m, sender_name_is_valid, &ri, &m->sender);
break;
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) {
assert_return(m, -EINVAL);
assert_return(destination, -EINVAL);
assert_return(!m->sealed, -EPERM);
return r;
}
- fprintf(f, "BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
+ fprintf(f, "MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
for(;;) {
_cleanup_free_ char *prefix = NULL;
log_error("Failed to peek type: %s", strerror(-r));
return r;
}
+
if (r == 0) {
if (level <= 1)
break;
if (!prefix)
return log_oom();
- if (type == SD_BUS_TYPE_ARRAY)
- fprintf(f, "%s} END_ARRAY \n", prefix);
- else if (type == SD_BUS_TYPE_VARIANT)
- fprintf(f, "%s} END_VARIANT\n", prefix);
- else if (type == SD_BUS_TYPE_STRUCT)
- fprintf(f, "%s} END_STRUCT\n", prefix);
- else if (type == SD_BUS_TYPE_DICT_ENTRY)
- fprintf(f, "%s} END_DICT_ENTRY\n", prefix);
-
+ fprintf(f, "%s};\n", prefix);
continue;
}
}
if (type == SD_BUS_TYPE_ARRAY)
- fprintf(f, "%sBEGIN_ARRAY \"%s\" {\n", prefix, contents);
+ fprintf(f, "%sARRAY \"%s\" {\n", prefix, contents);
else if (type == SD_BUS_TYPE_VARIANT)
- fprintf(f, "%sBEGIN_VARIANT \"%s\" {\n", prefix, contents);
+ fprintf(f, "%sVARIANT \"%s\" {\n", prefix, contents);
else if (type == SD_BUS_TYPE_STRUCT)
- fprintf(f, "%sBEGIN_STRUCT \"%s\" {\n", prefix, contents);
+ fprintf(f, "%sSTRUCT \"%s\" {\n", prefix, contents);
else if (type == SD_BUS_TYPE_DICT_ENTRY)
- fprintf(f, "%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents);
+ fprintf(f, "%sDICT_ENTRY \"%s\" {\n", prefix, contents);
level ++;
switch (type) {
case SD_BUS_TYPE_BYTE:
- fprintf(f, "%sBYTE: %u\n", prefix, basic.u8);
+ fprintf(f, "%sBYTE %u;\n", prefix, basic.u8);
break;
case SD_BUS_TYPE_BOOLEAN:
- fprintf(f, "%sBOOLEAN: %s\n", prefix, yes_no(basic.i));
+ fprintf(f, "%sBOOLEAN %s;\n", prefix, yes_no(basic.i));
break;
case SD_BUS_TYPE_INT16:
- fprintf(f, "%sINT16: %i\n", prefix, basic.s16);
+ fprintf(f, "%sINT16 %i;\n", prefix, basic.s16);
break;
case SD_BUS_TYPE_UINT16:
- fprintf(f, "%sUINT16: %u\n", prefix, basic.u16);
+ fprintf(f, "%sUINT16 %u;\n", prefix, basic.u16);
break;
case SD_BUS_TYPE_INT32:
- fprintf(f, "%sINT32: %i\n", prefix, basic.s32);
+ fprintf(f, "%sINT32 %i;\n", prefix, basic.s32);
break;
case SD_BUS_TYPE_UINT32:
- fprintf(f, "%sUINT32: %u\n", prefix, basic.u32);
+ fprintf(f, "%sUINT32 %u;\n", prefix, basic.u32);
break;
case SD_BUS_TYPE_INT64:
- fprintf(f, "%sINT64: %lli\n", prefix, (long long) basic.s64);
+ fprintf(f, "%sINT64 %lli;\n", prefix, (long long) basic.s64);
break;
case SD_BUS_TYPE_UINT64:
- fprintf(f, "%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64);
+ fprintf(f, "%sUINT64 %llu;\n", prefix, (unsigned long long) basic.u64);
break;
case SD_BUS_TYPE_DOUBLE:
- fprintf(f, "%sDOUBLE: %g\n", prefix, basic.d64);
+ fprintf(f, "%sDOUBLE %g;\n", prefix, basic.d64);
break;
case SD_BUS_TYPE_STRING:
- fprintf(f, "%sSTRING: \"%s\"\n", prefix, basic.string);
+ fprintf(f, "%sSTRING \"%s\";\n", prefix, basic.string);
break;
case SD_BUS_TYPE_OBJECT_PATH:
- fprintf(f, "%sOBJECT_PATH: \"%s\"\n", prefix, basic.string);
+ fprintf(f, "%sOBJECT_PATH \"%s\";\n", prefix, basic.string);
break;
case SD_BUS_TYPE_SIGNATURE:
- fprintf(f, "%sSIGNATURE: \"%s\"\n", prefix, basic.string);
+ fprintf(f, "%sSIGNATURE \"%s\";\n", prefix, basic.string);
break;
case SD_BUS_TYPE_UNIX_FD:
- fprintf(f, "%sUNIX_FD: %i\n", prefix, basic.i);
+ fprintf(f, "%sUNIX_FD %i;\n", prefix, basic.i);
break;
default:
}
}
- fprintf(f, "} END_MESSAGE\n");
+ fprintf(f, "};\n");
return 0;
}
if (r < 0)
return r;
- return 0;
+ return 1;
}
-int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
+_public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
char **strv = NULL;
int r;
return 0;
}
-int sd_bus_message_get_errno(sd_bus_message *m) {
+_public_ int sd_bus_message_get_errno(sd_bus_message *m) {
assert_return(m, -EINVAL);
if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
return sd_bus_error_get_errno(&m->error);
}
-const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
+_public_ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
struct bus_container *c;
assert_return(m, NULL);
return c->signature ?: "";
}
-int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
+_public_ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
bool done_something = false;
int r;
return done_something;
}
-int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
+_public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
const char *c;
char t;
int r;