X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd%2Fsd-bus%2Fbus-message.c;h=97ab0e3beac81798d1e0f13aabf683b9c3d5a415;hb=42c4ebcbd4cbd7b27667eb8081ee4dc46f9ece17;hp=1a2039b8cd77a10e52046f635087c6cd6f2d57a5;hpb=607553f9306286fdccf0b356bc3d1087adfe21c4;p=elogind.git

diff --git a/src/libsystemd/sd-bus/bus-message.c b/src/libsystemd/sd-bus/bus-message.c
index 1a2039b8c..97ab0e3be 100644
--- a/src/libsystemd/sd-bus/bus-message.c
+++ b/src/libsystemd/sd-bus/bus-message.c
@@ -194,7 +194,7 @@ static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz, b
 
         /* Zero out padding */
         if (start > old_size)
-                memset((uint8_t*) np + old_size, 0, start - old_size);
+                memzero((uint8_t*) np + old_size, start - old_size);
 
         op = m->header;
         m->header = np;
@@ -252,7 +252,7 @@ static int message_append_field_string(
                         return -ENOMEM;
 
                 p[0] = h;
-                memset(p+1, 0, 7);
+                memzero(p+1, 7);
                 memcpy(p+8, s, l);
                 p[8+l] = 0;
                 p[8+l+1] = 0;
@@ -337,7 +337,7 @@ static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x)
                         return -ENOMEM;
 
                 p[0] = h;
-                memset(p+1, 0, 7);
+                memzero(p+1, 7);
                 *((uint32_t*) (p + 8)) = x;
                 p[12] = 0;
                 p[13] = 'u';
@@ -509,10 +509,10 @@ static sd_bus_message *message_new(sd_bus *bus, uint8_t type) {
 
 _public_ int sd_bus_message_new_signal(
                 sd_bus *bus,
+                sd_bus_message **m,
                 const char *path,
                 const char *interface,
-                const char *member,
-                sd_bus_message **m) {
+                const char *member) {
 
         sd_bus_message *t;
         int r;
@@ -549,11 +549,11 @@ fail:
 
 _public_ int sd_bus_message_new_method_call(
                 sd_bus *bus,
+                sd_bus_message **m,
                 const char *destination,
                 const char *path,
                 const char *interface,
-                const char *member,
-                sd_bus_message **m) {
+                const char *member) {
 
         sd_bus_message *t;
         int r;
@@ -617,7 +617,7 @@ static int message_new_reply(
         t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
         t->reply_cookie = BUS_MESSAGE_COOKIE(call);
 
-        r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_cookie);
+        r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) t->reply_cookie);
         if (r < 0)
                 goto fail;
 
@@ -647,8 +647,8 @@ _public_ int sd_bus_message_new_method_return(
 
 _public_ int sd_bus_message_new_method_error(
                 sd_bus_message *call,
-                const sd_bus_error *e,
-                sd_bus_message **m) {
+                sd_bus_message **m,
+                const sd_bus_error *e) {
 
         sd_bus_message *t;
         int r;
@@ -697,23 +697,23 @@ _public_ int sd_bus_message_new_method_errorf(
         bus_error_setfv(&error, name, format, ap);
         va_end(ap);
 
-        return sd_bus_message_new_method_error(call, &error, m);
+        return sd_bus_message_new_method_error(call, m, &error);
 }
 
 _public_ int sd_bus_message_new_method_errno(
                 sd_bus_message *call,
+                sd_bus_message **m,
                 int error,
-                const sd_bus_error *p,
-                sd_bus_message **m) {
+                const sd_bus_error *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(call, p, m);
+                return sd_bus_message_new_method_error(call, m, p);
 
         sd_bus_error_set_errno(&berror, error);
 
-        return sd_bus_message_new_method_error(call, &berror, m);
+        return sd_bus_message_new_method_error(call, m, &berror);
 }
 
 _public_ int sd_bus_message_new_method_errnof(
@@ -730,7 +730,7 @@ _public_ int sd_bus_message_new_method_errnof(
         bus_error_set_errnofv(&berror, error, format, ap);
         va_end(ap);
 
-        return sd_bus_message_new_method_error(call, &berror, m);
+        return sd_bus_message_new_method_error(call, m, &berror);
 }
 
 int bus_message_new_synthetic_error(
@@ -752,7 +752,7 @@ int bus_message_new_synthetic_error(
         t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
         t->reply_cookie = cookie;
 
-        r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_cookie);
+        r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) t->reply_cookie);
         if (r < 0)
                 goto fail;
 
@@ -831,16 +831,17 @@ _public_ int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie
         return 0;
 }
 
-_public_ int sd_bus_message_get_no_reply(sd_bus_message *m) {
+_public_ int sd_bus_message_get_expect_reply(sd_bus_message *m) {
         assert_return(m, -EINVAL);
 
-        return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
+        return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
+                !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
 }
 
-_public_ int sd_bus_message_get_no_auto_start(sd_bus_message *m) {
+_public_ int sd_bus_message_get_auto_start(sd_bus_message *m) {
         assert_return(m, -EINVAL);
 
-        return !!(m->header->flags & BUS_MESSAGE_NO_AUTO_START);
+        return !(m->header->flags & BUS_MESSAGE_NO_AUTO_START);
 }
 
 _public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
@@ -880,24 +881,39 @@ _public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
         return &m->error;
 }
 
-_public_ int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec) {
         assert_return(m, -EINVAL);
         assert_return(usec, -EINVAL);
-        assert_return(m->monotonic > 0, -ENODATA);
+
+        if (m->monotonic <= 0)
+                return -ENODATA;
 
         *usec = m->monotonic;
         return 0;
 }
 
-_public_ int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
+_public_ int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec) {
         assert_return(m, -EINVAL);
         assert_return(usec, -EINVAL);
-        assert_return(m->realtime > 0, -ENODATA);
+
+        if (m->realtime <= 0)
+                return -ENODATA;
 
         *usec = m->realtime;
         return 0;
 }
 
+_public_ int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum) {
+        assert_return(m, -EINVAL);
+        assert_return(seqnum, -EINVAL);
+
+        if (m->seqnum <= 0)
+                return -ENODATA;
+
+        *seqnum = m->seqnum;
+        return 0;
+}
+
 _public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
         assert_return(m, NULL);
 
@@ -953,27 +969,27 @@ _public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name)
         return 1;
 }
 
-_public_ int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
+_public_ int sd_bus_message_set_expect_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);
 
         if (b)
-                m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
-        else
                 m->header->flags &= ~BUS_MESSAGE_NO_REPLY_EXPECTED;
+        else
+                m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
 
         return 0;
 }
 
-_public_ int sd_bus_message_set_no_auto_start(sd_bus_message *m, int b) {
+_public_ int sd_bus_message_set_auto_start(sd_bus_message *m, int b) {
         assert_return(m, -EINVAL);
         assert_return(!m->sealed, -EPERM);
 
         if (b)
-                m->header->flags |= BUS_MESSAGE_NO_AUTO_START;
-        else
                 m->header->flags &= ~BUS_MESSAGE_NO_AUTO_START;
+        else
+                m->header->flags |= BUS_MESSAGE_NO_AUTO_START;
 
         return 0;
 }
@@ -1212,7 +1228,7 @@ static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz, boo
                                 return NULL;
 
                         if (padding > 0) {
-                                memset(p, 0, padding);
+                                memzero(p, padding);
                                 p = (uint8_t*) p + padding;
                         }
 
@@ -1847,7 +1863,7 @@ _public_ int sd_bus_message_open_container(
         struct bus_container *c, *w;
         uint32_t *array_size = NULL;
         char *signature;
-        size_t before, begin;
+        size_t before, begin = 0;
         bool need_offsets = false;
         int r;
 
@@ -2498,7 +2514,7 @@ _public_ int sd_bus_message_append_array_iovec(
                 if (iov[i].iov_base)
                         memcpy(p, iov[i].iov_base, iov[i].iov_len);
                 else
-                        memset(p, 0, iov[i].iov_len);
+                        memzero(p, iov[i].iov_len);
 
                 p = (uint8_t*) p + iov[i].iov_len;
         }
@@ -2763,7 +2779,7 @@ int bus_message_seal(sd_bus_message *m, uint64_t cookie, usec_t timeout) {
         l = BUS_MESSAGE_FIELDS_SIZE(m);
         a = ALIGN8(l) - l;
         if (a > 0)
-                memset((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, 0, a);
+                memzero((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, a);
 
         /* If this is something we can send as memfd, then let's seal
         the memfd now. Note that we can send memfds as payload only
@@ -5059,21 +5075,26 @@ int bus_message_parse_fields(sd_bus_message *m) {
                         break;
                 }
 
-                case BUS_MESSAGE_HEADER_REPLY_SERIAL:
+                case BUS_MESSAGE_HEADER_REPLY_SERIAL: {
+                        uint32_t serial;
+
                         if (m->reply_cookie != 0)
                                 return -EBADMSG;
 
                         if (!streq(signature, "u"))
                                 return -EBADMSG;
 
-                        r = message_peek_field_uint32(m, &ri, item_size, &m->reply_cookie);
+                        r = message_peek_field_uint32(m, &ri, item_size, &serial);
                         if (r < 0)
                                 return r;
 
+                        m->reply_cookie = serial;
+
                         if (m->reply_cookie == 0)
                                 return -EBADMSG;
 
                         break;
+                }
 
                 case BUS_MESSAGE_HEADER_UNIX_FDS:
                         if (unix_fds != 0)
@@ -5452,14 +5473,14 @@ int bus_message_remarshal(sd_bus *bus, sd_bus_message **m) {
         switch ((*m)->header->type) {
 
         case SD_BUS_MESSAGE_SIGNAL:
-                r = sd_bus_message_new_signal(bus, (*m)->path, (*m)->interface, (*m)->member, &n);
+                r = sd_bus_message_new_signal(bus, &n, (*m)->path, (*m)->interface, (*m)->member);
                 if (r < 0)
                         return r;
 
                 break;
 
         case SD_BUS_MESSAGE_METHOD_CALL:
-                r = sd_bus_message_new_method_call(bus, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member, &n);
+                r = sd_bus_message_new_method_call(bus, &n, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member);
                 if (r < 0)
                         return r;
 
@@ -5473,7 +5494,7 @@ int bus_message_remarshal(sd_bus *bus, sd_bus_message **m) {
                         return -ENOMEM;
 
                 n->reply_cookie = (*m)->reply_cookie;
-                r = message_append_field_uint32(n, BUS_MESSAGE_HEADER_REPLY_SERIAL, n->reply_cookie);
+                r = message_append_field_uint32(n, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) n->reply_cookie);
                 if (r < 0)
                         return r;
 
@@ -5533,3 +5554,19 @@ int bus_message_append_sender(sd_bus_message *m, const char *sender) {
 
         return message_append_field_string(m, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, sender, &m->sender);
 }
+
+_public_ int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) {
+        assert_return(m, -EINVAL);
+        assert_return(priority, -EINVAL);
+
+        *priority = m->priority;
+        return 0;
+}
+
+_public_ int sd_bus_message_set_priority(sd_bus_message *m, int64_t priority) {
+        assert_return(m, -EINVAL);
+        assert_return(!m->sealed, -EPERM);
+
+        m->priority = priority;
+        return 0;
+}