bus: support temporarily const errors that don't need to be freed but require deep...

[elogind.git] / src / libsystemd-bus / bus-message.c

diff --git a/src/libsystemd-bus/bus-message.c b/src/libsystemd-bus/bus-message.c
index 4b53a6c5095bd793661f0f896d37b5eebb09cbc7..a1e6c9f97368123fd9143c71a4e31853566d092c 100644 (file)
--- a/src/libsystemd-bus/bus-message.c
+++ b/src/libsystemd-bus/bus-message.c
@@ -129,7 +129,7 @@ static void message_free(sd_bus_message *m) {
                 uint64_t off;
 
                 off = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer;
                 uint64_t off;
 
                 off = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer;

-                ioctl(m->bus->input_fd, KDBUS_CMD_MSG_RELEASE, &off);
+                ioctl(m->bus->input_fd, KDBUS_CMD_FREE, &off);

         }
 
         if (m->bus)
         }
 
         if (m->bus)


@@ -143,16 +143,12 @@ static void message_free(sd_bus_message *m) {
         if (m->iovec != m->iovec_fixed)
                 free(m->iovec);
 
         if (m->iovec != m->iovec_fixed)
                 free(m->iovec);
 

-        free(m->cmdline_array);
-

         message_reset_containers(m);
         free(m->root_container.signature);
 
         free(m->peeked_signature);
 
         message_reset_containers(m);
         free(m->root_container.signature);
 
         free(m->peeked_signature);
 

-        free(m->unit);
-        free(m->user_unit);
-        free(m->session);
+        bus_creds_done(&m->creds);

         free(m);
 }
 
         free(m);
 }
 


@@ -305,6 +301,7 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x)
 }
 
 int bus_message_from_header(
 }
 
 int bus_message_from_header(

+                sd_bus *bus,

                 void *buffer,
                 size_t length,
                 int *fds,
                 void *buffer,
                 size_t length,
                 int *fds,


@@ -357,22 +354,28 @@ int bus_message_from_header(
         m->n_fds = n_fds;
 
         if (ucred) {
         m->n_fds = n_fds;
 
         if (ucred) {

-                m->uid = ucred->uid;
-                m->pid = ucred->pid;
-                m->gid = ucred->gid;
-                m->uid_valid = m->gid_valid = true;
+                m->creds.uid = ucred->uid;
+                m->creds.pid = ucred->pid;
+                m->creds.gid = ucred->gid;
+                m->creds.mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID;

         }
 
         if (label) {
         }
 
         if (label) {

-                m->label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
-                memcpy(m->label, label, label_sz + 1);
+                m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
+                memcpy(m->creds.label, label, label_sz + 1);
+
+                m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT;

         }
 
         }
 

+        if (bus)
+                m->bus = sd_bus_ref(bus);
+

         *ret = m;
         return 0;
 }
 
 int bus_message_from_malloc(
         *ret = m;
         return 0;
 }
 
 int bus_message_from_malloc(

+                sd_bus *bus,

                 void *buffer,
                 size_t length,
                 int *fds,
                 void *buffer,
                 size_t length,
                 int *fds,


@@ -382,9 +385,10 @@ int bus_message_from_malloc(
                 sd_bus_message **ret) {
 
         sd_bus_message *m;
                 sd_bus_message **ret) {
 
         sd_bus_message *m;

+        size_t sz;

         int r;
 
         int r;
 

-        r = bus_message_from_header(buffer, length, fds, n_fds, ucred, label, 0, &m);
+        r = bus_message_from_header(bus, buffer, length, fds, n_fds, ucred, label, 0, &m);

         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 


@@ -393,11 +397,14 @@ int bus_message_from_malloc(
                 goto fail;
         }
 
                 goto fail;
         }
 

-        m->n_body_parts = 1;
-        m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
-        m->body.size = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
-        m->body.sealed = true;
-        m->body.memfd = -1;
+        sz = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
+        if (sz > 0) {
+                m->n_body_parts = 1;
+                m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
+                m->body.size = sz;
+                m->body.sealed = true;
+                m->body.memfd = -1;
+        }

 
         m->n_iovec = 1;
         m->iovec = m->iovec_fixed;
 
         m->n_iovec = 1;
         m->iovec = m->iovec_fixed;


@@ -530,7 +537,6 @@ fail:
 }
 
 static int message_new_reply(
 }
 
 static int message_new_reply(

-                sd_bus *bus,

                 sd_bus_message *call,
                 uint8_t type,
                 sd_bus_message **m) {
                 sd_bus_message *call,
                 uint8_t type,
                 sd_bus_message **m) {


@@ -538,13 +544,13 @@ static int message_new_reply(
         sd_bus_message *t;
         int r;
 
         sd_bus_message *t;
         int r;
 

-        assert_return(!bus || bus->state != BUS_UNSET, -ENOTCONN);

         assert_return(call, -EINVAL);
         assert_return(call->sealed, -EPERM);
         assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
         assert_return(call, -EINVAL);
         assert_return(call->sealed, -EPERM);
         assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);

+        assert_return(!call->bus || call->bus->state != BUS_UNSET, -ENOTCONN);

         assert_return(m, -EINVAL);
 
         assert_return(m, -EINVAL);
 

-        t = message_new(bus, type);
+        t = message_new(call->bus, type);

         if (!t)
                 return -ENOMEM;
 
         if (!t)
                 return -ENOMEM;
 


@@ -572,15 +578,13 @@ fail:
 }
 
 _public_ 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) {
 
                 sd_bus_message *call,
                 sd_bus_message **m) {
 

-        return message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_RETURN, m);
+        return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m);

 }
 
 _public_ 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,
                 sd_bus_message **m) {
                 sd_bus_message *call,
                 const sd_bus_error *e,
                 sd_bus_message **m) {


@@ -591,7 +595,7 @@ _public_ int sd_bus_message_new_method_error(
         assert_return(sd_bus_error_is_set(e), -EINVAL);
         assert_return(m, -EINVAL);
 
         assert_return(sd_bus_error_is_set(e), -EINVAL);
         assert_return(m, -EINVAL);
 

-        r = message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
+        r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);

         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 


@@ -605,6 +609,8 @@ _public_ int sd_bus_message_new_method_error(
                         goto fail;
         }
 
                         goto fail;
         }
 

+        t->error._need_free = -1;
+

         *m = t;
         return 0;
 
         *m = t;
         return 0;
 


@@ -614,7 +620,6 @@ fail:
 }
 
 _public_ 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,
                 const char *name,
                 sd_bus_message *call,
                 sd_bus_message **m,
                 const char *name,


@@ -623,23 +628,18 @@ _public_ int sd_bus_message_new_method_errorf(
 
         _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         va_list ap;
 
         _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
         va_list ap;

-        int r;

 
         assert_return(name, -EINVAL);
         assert_return(m, -EINVAL);
 
         va_start(ap, format);
 
         assert_return(name, -EINVAL);
         assert_return(m, -EINVAL);
 
         va_start(ap, format);

-        r = bus_error_setfv(&error, name, format, ap);
+        bus_error_setfv(&error, name, format, ap);

         va_end(ap);
 
         va_end(ap);
 

-        if (r < 0)
-                return r;
-
-        return sd_bus_message_new_method_error(bus, call, &error, m);
+        return sd_bus_message_new_method_error(call, &error, m);

 }
 
 _public_ int sd_bus_message_new_method_errno(
 }
 
 _public_ int sd_bus_message_new_method_errno(

-                sd_bus *bus,

                 sd_bus_message *call,
                 int error,
                 const sd_bus_error *p,
                 sd_bus_message *call,
                 int error,
                 const sd_bus_error *p,


@@ -648,15 +648,14 @@ _public_ int sd_bus_message_new_method_errno(
         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 
         if (sd_bus_error_is_set(p))
         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 
         if (sd_bus_error_is_set(p))

-                return sd_bus_message_new_method_error(bus, call, p, m);
+                return sd_bus_message_new_method_error(call, p, m);

 
         sd_bus_error_set_errno(&berror, error);
 
 
         sd_bus_error_set_errno(&berror, error);
 

-        return sd_bus_message_new_method_error(bus, call, &berror, m);
+        return sd_bus_message_new_method_error(call, &berror, m);

 }
 
 _public_ 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,
                 int error,
                 sd_bus_message *call,
                 sd_bus_message **m,
                 int error,


@@ -665,16 +664,12 @@ _public_ int sd_bus_message_new_method_errnof(
 
         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
         va_list ap;
 
         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
         va_list ap;

-        int r;

 
         va_start(ap, format);
 
         va_start(ap, format);

-        r = bus_error_set_errnofv(&berror, error, format, ap);
+        bus_error_set_errnofv(&berror, error, format, ap);

         va_end(ap);
 
         va_end(ap);
 

-        if (r < 0)
-                return r;
-
-        return sd_bus_message_new_method_error(bus, call, &berror, m);
+        return sd_bus_message_new_method_error(call, &berror, m);

 }
 
 int bus_message_new_synthetic_error(
 }
 
 int bus_message_new_synthetic_error(


@@ -716,6 +711,8 @@ int bus_message_new_synthetic_error(
                         goto fail;
         }
 
                         goto fail;
         }
 

+        t->error._need_free = -1;
+

         *m = t;
         return 0;
 
         *m = t;
         return 0;
 


@@ -777,6 +774,12 @@ _public_ int sd_bus_message_get_no_reply(sd_bus_message *m) {
         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
 }
 
         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
 }
 

+_public_ int sd_bus_message_get_no_auto_start(sd_bus_message *m) {
+        assert_return(m, -EINVAL);
+
+        return !!(m->header->flags & SD_BUS_MESSAGE_NO_AUTO_START);
+}
+

 _public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
         assert_return(m, NULL);
 
 _public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
         assert_return(m, NULL);
 


@@ -814,63 +817,10 @@ _public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
         return &m->error;
 }
 
         return &m->error;
 }
 

-_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);
-
-        *uid = m->uid;
-        return 0;
-}
-
-_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);
-
-        *gid = m->gid;
-        return 0;
-}
-
-_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);
-
-        *pid = m->pid;
-        return 0;
-}
-
-_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);
-
-        *tid = m->tid;
-        return 0;
-}
-
-_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);
-
-        *usec = m->pid_starttime;
-        return 0;
-}
-
-_public_ int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
-        assert_return(m, -EINVAL);
-        assert_return(m->label, -ESRCH);
-
-        *ret = m->label;
-        return 0;
-}
-

 _public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
         assert_return(m, -EINVAL);
         assert_return(usec, -EINVAL);
 _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);
+        assert_return(m->monotonic > 0, -ENODATA);

 
         *usec = m->monotonic;
         return 0;
 
         *usec = m->monotonic;
         return 0;


@@ -879,166 +829,19 @@ _public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t
 _public_ int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
         assert_return(m, -EINVAL);
         assert_return(usec, -EINVAL);
 _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);
+        assert_return(m->realtime > 0, -ENODATA);

 
         *usec = m->realtime;
         return 0;
 }
 
 
         *usec = m->realtime;
         return 0;
 }
 

-_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);
-
-        *ret = m->comm;
-        return 0;
-}
-
-_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);
-
-        *ret = m->tid_comm;
-        return 0;
-}
-
-_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);
-
-        *ret = m->exe;
-        return 0;
-}
-
-_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);
-
-        *ret = m->cgroup;
-        return 0;
-}
-
-_public_ int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
-        int r;
-
-        assert_return(m, -EINVAL);
-        assert_return(ret, -EINVAL);
-        assert_return(m->cgroup, -ESRCH);
-
-        if (!m->unit) {
-                r = cg_path_get_unit(m->cgroup, &m->unit);
-                if (r < 0)
-                        return r;
-        }
-
-        *ret = m->unit;
-        return 0;
-}
-
-_public_ int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
-        int r;
-
-        assert_return(m, -EINVAL);
-        assert_return(ret, -EINVAL);
-        assert_return(m->cgroup, -ESRCH);
-
-        if (!m->user_unit) {
-                r = cg_path_get_user_unit(m->cgroup, &m->user_unit);
-                if (r < 0)
-                        return r;
-        }
-
-        *ret = m->user_unit;
-        return 0;
-}
-
-_public_ int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
-        int r;
-
-        assert_return(m, -EINVAL);
-        assert_return(ret, -EINVAL);
-        assert_return(m->cgroup, -ESRCH);
-
-        if (!m->session) {
-                r = cg_path_get_session(m->cgroup, &m->session);
-                if (r < 0)
-                        return r;
-        }
-
-        *ret = m->session;
-        return 0;
-}
-
-_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);
-}
-
-_public_ int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
-        size_t n, i;
-        const char *p;
-        bool first;
-
-        assert_return(m, -EINVAL);
-        assert_return(m->cmdline, -ESRCH);
-
-        for (p = m->cmdline, n = 0; p < m->cmdline + m->cmdline_length; p++)
-                if (*p == 0)
-                        n++;
-
-        m->cmdline_array = new(char*, n + 1);
-        if (!m->cmdline_array)
-                return -ENOMEM;
-
-        for (p = m->cmdline, i = 0, first = true; p < m->cmdline + m->cmdline_length; p++) {
-                if (first)
-                        m->cmdline_array[i++] = (char*) p;
-
-                first = *p == 0;
-        }
-
-        m->cmdline_array[i] = NULL;
-        *cmdline = m->cmdline_array;
-
-        return 0;
-}
-
-_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);
-
-        *sessionid = m->audit->sessionid;
-        return 0;
-}
-
-_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);
-
-        *uid = m->audit->loginuid;
-        return 0;
-}
-
-_public_ int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
-        unsigned sz;
-
-        assert_return(m, -EINVAL);
-        assert_return(capability < 0, -EINVAL);
-        assert_return(!m->capability, -ESRCH);
+_public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
+        assert_return(m, NULL);

 
 

-        sz = m->capability_size / 4;
-        if ((unsigned) capability >= sz*8)
-                return 0;
+        if (m->creds.mask == 0)
+                return NULL;

 
 

-        return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8)));
+        return &m->creds;

 }
 
 _public_ int sd_bus_message_is_signal(sd_bus_message *m,
 }
 
 _public_ int sd_bus_message_is_signal(sd_bus_message *m,


@@ -1100,6 +903,18 @@ _public_ int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
         return 0;
 }
 
         return 0;
 }
 

+_public_ int sd_bus_message_set_no_auto_start(sd_bus_message *m, int b) {
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+
+        if (b)
+                m->header->flags |= SD_BUS_MESSAGE_NO_AUTO_START;
+        else
+                m->header->flags &= ~SD_BUS_MESSAGE_NO_AUTO_START;
+
+        return 0;
+}
+

 static struct bus_container *message_get_container(sd_bus_message *m) {
         assert(m);
 
 static struct bus_container *message_get_container(sd_bus_message *m) {
         assert(m);
 


@@ -1379,6 +1194,7 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
                 break;
 
         case SD_BUS_TYPE_BOOLEAN:
                 break;
 
         case SD_BUS_TYPE_BOOLEAN:

+

                 if (!p) {
                         r = -EINVAL;
                         goto fail;
                 if (!p) {
                         r = -EINVAL;
                         goto fail;


@@ -1434,6 +1250,11 @@ int message_append_basic(sd_bus_message *m, char type, const void *p, const void
         }
 
         default:
         }
 
         default:

+                if (!p) {
+                        r = -EINVAL;
+                        goto fail;
+                }
+

                 align = bus_type_get_alignment(type);
                 sz = bus_type_get_size(type);
                 break;
                 align = bus_type_get_alignment(type);
                 sz = bus_type_get_size(type);
                 break;


@@ -1492,7 +1313,11 @@ _public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const voi
         return message_append_basic(m, type, p, NULL);
 }
 
         return message_append_basic(m, type, p, NULL);
 }
 

-_public_ 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;
 
         struct bus_container *c;
         void *a;
 


@@ -1537,6 +1362,40 @@ _public_ int sd_bus_message_append_string_space(sd_bus_message *m, size_t size,
         return 0;
 }
 
         return 0;
 }
 

+_public_ int sd_bus_message_append_string_iovec(
+                sd_bus_message *m,
+                const struct iovec *iov,
+                unsigned n) {
+
+        size_t size;
+        unsigned i;
+        char *p;
+        int r;
+
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(iov || n == 0, -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
+
+        size = IOVEC_TOTAL_SIZE(iov, n);
+
+        r = sd_bus_message_append_string_space(m, size, &p);
+        if (r < 0)
+                return r;
+
+        for (i = 0; i < n; i++) {
+
+                if (iov[i].iov_base)
+                        memcpy(p, iov[i].iov_base, iov[i].iov_len);
+                else
+                        memset(p, ' ', iov[i].iov_len);
+
+                p += iov[i].iov_len;
+        }
+
+        return 0;
+}
+

 static int bus_message_open_array(
                 sd_bus_message *m,
                 struct bus_container *c,
 static int bus_message_open_array(
                 sd_bus_message *m,
                 struct bus_container *c,


@@ -2072,7 +1931,7 @@ int bus_message_append_ap(
                         return r;
         }
 
                         return r;
         }
 

-        return 0;
+        return 1;

 }
 
 _public_ 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, ...) {


@@ -2153,6 +2012,42 @@ _public_ int sd_bus_message_append_array(sd_bus_message *m,
         return 0;
 }
 
         return 0;
 }
 

+_public_ int sd_bus_message_append_array_iovec(
+                sd_bus_message *m,
+                char type,
+                const struct iovec *iov,
+                unsigned n) {
+
+        size_t size;
+        unsigned i;
+        void *p;
+        int r;
+
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+        assert_return(bus_type_is_trivial(type), -EINVAL);
+        assert_return(iov || n == 0, -EINVAL);
+        assert_return(!m->poisoned, -ESTALE);
+
+        size = IOVEC_TOTAL_SIZE(iov, n);
+
+        r = sd_bus_message_append_array_space(m, type, size, &p);
+        if (r < 0)
+                return r;
+
+        for (i = 0; i < n; i++) {
+
+                if (iov[i].iov_base)
+                        memcpy(p, iov[i].iov_base, iov[i].iov_len);
+                else
+                        memset(p, 0, iov[i].iov_len);
+
+                p = (uint8_t*) p + iov[i].iov_len;
+        }
+
+        return 0;
+}
+

 _public_ 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) {


@@ -2424,7 +2319,7 @@ static bool message_end_of_array(sd_bus_message *m, size_t index) {
         return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
 }
 
         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);
 
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
 


@@ -3012,7 +2907,7 @@ _public_ int sd_bus_message_exit_container(sd_bus_message *m) {
 
         assert_return(m, -EINVAL);
         assert_return(m->sealed, -EPERM);
 
         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) {
 
         c = message_get_container(m);
         if (c->enclosing == SD_BUS_TYPE_ARRAY) {


@@ -3024,7 +2919,7 @@ _public_ int sd_bus_message_exit_container(sd_bus_message *m) {
 
         } else {
                 if (c->signature && c->signature[c->index] != 0)
 
         } else {
                 if (c->signature && c->signature[c->index] != 0)

-                        return -EINVAL;
+                        return -EBUSY;

         }
 
         free(c->signature);
         }
 
         free(c->signature);


@@ -3196,6 +3091,7 @@ _public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
 
         return !isempty(c->signature);
 }
 
         return !isempty(c->signature);
 }

+

 static int message_read_ap(
                 sd_bus_message *m,
                 const char *types,
 static int message_read_ap(
                 sd_bus_message *m,
                 const char *types,


@@ -3579,12 +3475,18 @@ _public_ int sd_bus_message_read_array(sd_bus_message *m,
         c = message_get_container(m);
         sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
 
         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);
         }
 
         r = sd_bus_message_exit_container(m);


@@ -3906,6 +3808,9 @@ int bus_message_parse_fields(sd_bus_message *m) {
                                 return -EBADMSG;
 
                         r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name);
                                 return -EBADMSG;
 
                         r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name);

+                        if (r >= 0)
+                                m->error._need_free = -1;
+

                         break;
 
                 case SD_BUS_MESSAGE_HEADER_DESTINATION:
                         break;
 
                 case SD_BUS_MESSAGE_HEADER_DESTINATION:


@@ -3928,6 +3833,12 @@ int bus_message_parse_fields(sd_bus_message *m) {
                                 return -EBADMSG;
 
                         r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);
                                 return -EBADMSG;
 
                         r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);

+
+                        if (r >= 0 && m->sender[0] == ':' && m->bus && m->bus->bus_client && !m->bus->is_kernel) {
+                                m->creds.unique_name = (char*) m->sender;
+                                m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & m->bus->creds_mask;
+                        }
+

                         break;
 
 
                         break;
 
 


@@ -4101,279 +4012,6 @@ _public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *desti
         return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->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, FILE *f, bool with_header) {
-        const char *u = NULL, *uu = NULL, *s = NULL;
-        char **cmdline = NULL;
-        unsigned level = 1;
-        int r;
-        uid_t owner, audit_loginuid;
-        uint32_t audit_sessionid;
-
-        assert(m);
-
-        if (!f)
-                f = stdout;
-
-        if (with_header) {
-                fprintf(f,
-                        "Message %p\n"
-                        "\tn_ref=%u\n"
-                        "\tendian=%c\n"
-                        "\ttype=%i\n"
-                        "\tflags=%u\n"
-                        "\tversion=%u\n"
-                        "\tserial=%u\n"
-                        "\tfields_size=%u\n"
-                        "\tbody_size=%u\n"
-                        "\tpath=%s\n"
-                        "\tinterface=%s\n"
-                        "\tmember=%s\n"
-                        "\tdestination=%s\n"
-                        "\tsender=%s\n"
-                        "\tsignature=%s\n"
-                        "\treply_serial=%u\n"
-                        "\tsealed=%s\n"
-                        "\tn_body_parts=%u\n",
-                        m,
-                        m->n_ref,
-                        m->header->endian,
-                        m->header->type,
-                        m->header->flags,
-                        m->header->version,
-                        BUS_MESSAGE_SERIAL(m),
-                        BUS_MESSAGE_FIELDS_SIZE(m),
-                        BUS_MESSAGE_BODY_SIZE(m),
-                        strna(m->path),
-                        strna(m->interface),
-                        strna(m->member),
-                        strna(m->destination),
-                        strna(m->sender),
-                        strna(m->root_container.signature),
-                        m->reply_serial,
-                        yes_no(m->sealed),
-                        m->n_body_parts);
-
-                if (sd_bus_error_is_set(&m->error))
-                        fprintf(f,
-                                "\terror.name=%s\n"
-                                "\terror.message=%s\n",
-                                strna(m->error.name),
-                                strna(m->error.message));
-
-                if (m->pid != 0)
-                        fprintf(f, "\tpid=%lu\n", (unsigned long) m->pid);
-                if (m->tid != 0)
-                        fprintf(f, "\ttid=%lu\n", (unsigned long) m->tid);
-                if (m->uid_valid)
-                        fprintf(f, "\tuid=%lu\n", (unsigned long) m->uid);
-                if (m->gid_valid)
-                        fprintf(f, "\tgid=%lu\n", (unsigned long) m->gid);
-                if (m->pid_starttime != 0)
-                        fprintf(f, "\tpid_starttime=%llu\n", (unsigned long long) m->pid_starttime);
-                if (m->monotonic != 0)
-                        fprintf(f, "\tmonotonic=%llu\n", (unsigned long long) m->monotonic);
-                if (m->realtime != 0)
-                        fprintf(f, "\trealtime=%llu\n", (unsigned long long) m->realtime);
-                if (m->exe)
-                        fprintf(f, "\texe=[%s]\n", m->exe);
-                if (m->comm)
-                        fprintf(f, "\tcomm=[%s]\n", m->comm);
-                if (m->tid_comm)
-                        fprintf(f, "\ttid_comm=[%s]\n", m->tid_comm);
-                if (m->label)
-                        fprintf(f, "\tlabel=[%s]\n", m->label);
-                if (m->cgroup)
-                        fprintf(f, "\tcgroup=[%s]\n", m->cgroup);
-
-                sd_bus_message_get_unit(m, &u);
-                if (u)
-                        fprintf(f, "\tunit=[%s]\n", u);
-                sd_bus_message_get_user_unit(m, &uu);
-                if (uu)
-                        fprintf(f, "\tuser_unit=[%s]\n", uu);
-                sd_bus_message_get_session(m, &s);
-                if (s)
-                        fprintf(f, "\tsession=[%s]\n", s);
-                if (sd_bus_message_get_owner_uid(m, &owner) >= 0)
-                        fprintf(f, "\towner_uid=%lu\n", (unsigned long) owner);
-                if (sd_bus_message_get_audit_loginuid(m, &audit_loginuid) >= 0)
-                        fprintf(f, "\taudit_loginuid=%lu\n", (unsigned long) audit_loginuid);
-                if (sd_bus_message_get_audit_sessionid(m, &audit_sessionid) >= 0)
-                        fprintf(f, "\taudit_sessionid=%lu\n", (unsigned long) audit_sessionid);
-
-                r = sd_bus_message_has_effective_cap(m, 5);
-                if (r >= 0)
-                        fprintf(f, "\tCAP_KILL=%s\n", yes_no(r));
-
-                if (sd_bus_message_get_cmdline(m, &cmdline) >= 0) {
-                        char **c;
-
-                        fputs("\tcmdline=[", f);
-                        STRV_FOREACH(c, cmdline) {
-                                if (c != cmdline)
-                                        fputc(' ', f);
-
-                                fputs(*c, f);
-                        }
-
-                        fputs("]\n", f);
-                }
-        }
-
-        r = sd_bus_message_rewind(m, true);
-        if (r < 0) {
-                log_error("Failed to rewind: %s", strerror(-r));
-                return r;
-        }
-
-        fprintf(f, "BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
-
-        for(;;) {
-                _cleanup_free_ char *prefix = NULL;
-                const char *contents = NULL;
-                char type;
-                union {
-                        uint8_t u8;
-                        uint16_t u16;
-                        int16_t s16;
-                        uint32_t u32;
-                        int32_t s32;
-                        uint64_t u64;
-                        int64_t s64;
-                        double d64;
-                        const char *string;
-                        int i;
-                } basic;
-
-                r = sd_bus_message_peek_type(m, &type, &contents);
-                if (r < 0) {
-                        log_error("Failed to peek type: %s", strerror(-r));
-                        return r;
-                }
-                if (r == 0) {
-                        if (level <= 1)
-                                break;
-
-                        r = sd_bus_message_exit_container(m);
-                        if (r < 0) {
-                                log_error("Failed to exit container: %s", strerror(-r));
-                                return r;
-                        }
-
-                        level--;
-
-                        prefix = strrep("\t", level);
-                        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);
-
-                        continue;
-                }
-
-                prefix = strrep("\t", level);
-                if (!prefix)
-                        return log_oom();
-
-                if (bus_type_is_container(type) > 0) {
-                        r = sd_bus_message_enter_container(m, type, contents);
-                        if (r < 0) {
-                                log_error("Failed to enter container: %s", strerror(-r));
-                                return r;
-                        }
-
-                        if (type == SD_BUS_TYPE_ARRAY)
-                                fprintf(f, "%sBEGIN_ARRAY \"%s\" {\n", prefix, contents);
-                        else if (type == SD_BUS_TYPE_VARIANT)
-                                fprintf(f, "%sBEGIN_VARIANT \"%s\" {\n", prefix, contents);
-                        else if (type == SD_BUS_TYPE_STRUCT)
-                                fprintf(f, "%sBEGIN_STRUCT \"%s\" {\n", prefix, contents);
-                        else if (type == SD_BUS_TYPE_DICT_ENTRY)
-                                fprintf(f, "%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents);
-
-                        level ++;
-
-                        continue;
-                }
-
-                r = sd_bus_message_read_basic(m, type, &basic);
-                if (r < 0) {
-                        log_error("Failed to get basic: %s", strerror(-r));
-                        return r;
-                }
-
-                assert(r > 0);
-
-                switch (type) {
-
-                case SD_BUS_TYPE_BYTE:
-                        fprintf(f, "%sBYTE: %u\n", prefix, basic.u8);
-                        break;
-
-                case SD_BUS_TYPE_BOOLEAN:
-                        fprintf(f, "%sBOOLEAN: %s\n", prefix, yes_no(basic.i));
-                        break;
-
-                case SD_BUS_TYPE_INT16:
-                        fprintf(f, "%sINT16: %i\n", prefix, basic.s16);
-                        break;
-
-                case SD_BUS_TYPE_UINT16:
-                        fprintf(f, "%sUINT16: %u\n", prefix, basic.u16);
-                        break;
-
-                case SD_BUS_TYPE_INT32:
-                        fprintf(f, "%sINT32: %i\n", prefix, basic.s32);
-                        break;
-
-                case SD_BUS_TYPE_UINT32:
-                        fprintf(f, "%sUINT32: %u\n", prefix, basic.u32);
-                        break;
-
-                case SD_BUS_TYPE_INT64:
-                        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);
-                        break;
-
-                case SD_BUS_TYPE_DOUBLE:
-                        fprintf(f, "%sDOUBLE: %g\n", prefix, basic.d64);
-                        break;
-
-                case SD_BUS_TYPE_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);
-                        break;
-
-                case SD_BUS_TYPE_SIGNATURE:
-                        fprintf(f, "%sSIGNATURE: \"%s\"\n", prefix, basic.string);
-                        break;
-
-                case SD_BUS_TYPE_UNIX_FD:
-                        fprintf(f, "%sUNIX_FD: %i\n", prefix, basic.i);
-                        break;
-
-                default:
-                        assert_not_reached("Unknown basic type.");
-                }
-        }
-
-        fprintf(f, "} END_MESSAGE\n");
-        return 0;
-}
-

 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
         size_t total;
         void *p, *e;
 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
         size_t total;
         void *p, *e;


@@ -4430,7 +4068,7 @@ int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 

-        return 0;
+        return 1;

 }
 
 _public_ 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) {


@@ -4637,3 +4275,9 @@ _public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char
 
         return 1;
 }
 
         return 1;
 }

+
+_public_ sd_bus *sd_bus_message_get_bus(sd_bus_message *m) {
+        assert_return(m, NULL);
+
+        return m->bus;
+}