../src/libsystemd/sd-bus/bus-message.c

Bug Summary

File:	build-scan/../src/libsystemd/sd-bus/bus-message.c
Warning:	line 473, column 33 Potential leak of memory pointed to by 'm'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name bus-message.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fdenormal-fp-math=preserve-sign,preserve-sign -ffp-contract=fast -fno-rounding-math -ffast-math -ffinite-math-only -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/12.0.0 -include config.h -I src/libsystemd/libsystemd_static.a.p -I src/libsystemd -I ../src/libsystemd -I src/basic -I ../src/basic -I src/shared -I ../src/shared -I src/systemd -I ../src/systemd -I src/journal -I ../src/journal -I src/journal-remote -I ../src/journal-remote -I src/nspawn -I ../src/nspawn -I src/resolve -I ../src/resolve -I src/timesync -I ../src/timesync -I ../src/time-wait-sync -I src/login -I ../src/login -I src/udev -I ../src/udev -I src/libudev -I ../src/libudev -I src/core -I ../src/core -I ../src/libsystemd/sd-bus -I ../src/libsystemd/sd-device -I ../src/libsystemd/sd-hwdb -I ../src/libsystemd/sd-id128 -I ../src/libsystemd/sd-netlink -I ../src/libsystemd/sd-network -I src/libsystemd-network -I ../src/libsystemd-network -I . -I .. -D _FILE_OFFSET_BITS=64 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wwrite-strings -Wno-unused-parameter -Wno-missing-field-initializers -Wno-unused-result -Wno-format-signedness -Wno-error=nonnull -std=gnu99 -fconst-strings -fdebug-compilation-dir /home/mrc0mmand/repos/@redhat-plumbers/systemd-rhel8/build-scan -ferror-limit 19 -fvisibility default -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-07-16-221226-1465241-1 -x c ../src/libsystemd/sd-bus/bus-message.c
1/* SPDX-License-Identifier: LGPL-2.1+ */
2/***
3***/

5#include <errno(*__errno_location ()).h>
6#include <fcntl.h>
7#include <sys/mman.h>

9#include "sd-bus.h"

11#include "alloc-util.h"
12#include "bus-gvariant.h"
13#include "bus-internal.h"
14#include "bus-message.h"
15#include "bus-signature.h"
16#include "bus-type.h"
17#include "bus-util.h"
18#include "fd-util.h"
19#include "io-util.h"
20#include "memfd-util.h"
21#include "string-util.h"
22#include "strv.h"
23#include "time-util.h"
24#include "utf8.h"
25#include "util.h"

27static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);

29static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {

      if (p == NULL((void*)0))
              return NULL((void*)0);

      if (old_base == new_base)
              return (void*) p;

      if ((uint8_t*) p < (uint8_t*) old_base)
              return (void*) p;

      if ((uint8_t*) p >= (uint8_t*) old_base + sz)
              return (void*) p;

      return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base);
44}

46static void message_free_part(sd_bus_message *m, struct bus_body_part *part) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 47, __PRETTY_FUNCTION__); } while (0);
      assert(part)do { if ((__builtin_expect(!!(!(part)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("part"), "../src/libsystemd/sd-bus/bus-message.c"
, 48, __PRETTY_FUNCTION__); } while (0);

      if (part->memfd >= 0)
              close_and_munmap(part->memfd, part->mmap_begin, part->mapped);
      else if (part->munmap_this)
              munmap(part->mmap_begin, part->mapped);
      else if (part->free_this)
              free(part->data);

      if (part != &m->body)
              free(part);
59}

61static void message_reset_parts(sd_bus_message *m) {
      struct bus_body_part *part;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 64, __PRETTY_FUNCTION__); } while (0);

      part = &m->body;
      while (m->n_body_parts > 0) {
              struct bus_body_part *next = part->next;
              message_free_part(m, part);
              part = next;
              m->n_body_parts--;
      }

      m->body_end = NULL((void*)0);

      m->cached_rindex_part = NULL((void*)0);
      m->cached_rindex_part_begin = 0;
78}

80static struct bus_container *message_get_last_container(sd_bus_message *m) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 81, __PRETTY_FUNCTION__); } while (0);

      if (m->n_containers == 0)
              return &m->root_container;

      assert(m->containers)do { if ((__builtin_expect(!!(!(m->containers)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m->containers"), "../src/libsystemd/sd-bus/bus-message.c"
, 86, __PRETTY_FUNCTION__); } while (0);
      return m->containers + m->n_containers - 1;
88}

90static void message_free_last_container(sd_bus_message *m) {
      struct bus_container *c;

      c = message_get_last_container(m);

      free(c->signature);
      free(c->peeked_signature);
      free(c->offsets);

      /* Move to previous container, but not if we are on root container */
      if (m->n_containers > 0)
              m->n_containers--;
102}

104static void message_reset_containers(sd_bus_message *m) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 105, __PRETTY_FUNCTION__); } while (0);

      while (m->n_containers > 0)
              message_free_last_container(m);

      m->containers = mfree(m->containers);
      m->containers_allocated = 0;
      m->root_container.index = 0;
113}

115static sd_bus_message* message_free(sd_bus_message *m) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 116, __PRETTY_FUNCTION__); } while (0);

      if (m->free_header)
              free(m->header);

      message_reset_parts(m);

      /* Note that we don't unref m->bus here. That's already done by sd_bus_message_unref() as each user
       * reference to the bus message also is considered a reference to the bus connection itself. */

      if (m->free_fds) {
              close_many(m->fds, m->n_fds);
              free(m->fds);
      }

      if (m->iovec != m->iovec_fixed)
              free(m->iovec);

      message_reset_containers(m);
      assert(m->n_containers == 0)do { if ((__builtin_expect(!!(!(m->n_containers == 0)),0))
) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("m->n_containers == 0"
), "../src/libsystemd/sd-bus/bus-message.c", 135, __PRETTY_FUNCTION__
); } while (0);
      message_free_last_container(m);

      bus_creds_done(&m->creds);
      return mfree(m);
140}

142static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz, bool_Bool add_offset) {
      void *op, *np;
      size_t old_size, new_size, start;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 146, __PRETTY_FUNCTION__); } while (0);

      if (m->poisoned)
              return NULL((void*)0);

      old_size = sizeof(struct bus_header) + m->fields_size;
      start = ALIGN_TO(old_size, align);
      new_size = start + sz;

      if (new_size < start ||
          new_size > (size_t) ((uint32_t) -1))
              goto poison;

      if (old_size == new_size)
              return (uint8_t*) m->header + old_size;

      if (m->free_header) {
              np = realloc(m->header, ALIGN8(new_size)(((new_size) + 7) & ~7));
              if (!np)
                      goto poison;
      } else {
              /* Initially, the header is allocated as part of
               * the sd_bus_message itself, let's replace it by
               * dynamic data */

              np = malloc(ALIGN8(new_size)(((new_size) + 7) & ~7));
              if (!np)
                      goto poison;

              memcpy(np, m->header, sizeof(struct bus_header));
      }

      /* Zero out padding */
      if (start > old_size)
              memzero((uint8_t*) np + old_size, start - old_size)({ size_t _l_ = (start - old_size); void *_x_ = ((uint8_t*) np
 + old_size); _l_ == 0 ? _x_ : memset(_x_, 0, _l_); });

      op = m->header;
      m->header = np;
      m->fields_size = new_size - sizeof(struct bus_header);

      /* Adjust quick access pointers */
      m->path = adjust_pointer(m->path, op, old_size, m->header);
      m->interface = adjust_pointer(m->interface, op, old_size, m->header);
      m->member = adjust_pointer(m->member, op, old_size, m->header);
      m->destination = adjust_pointer(m->destination, op, old_size, m->header);
      m->sender = adjust_pointer(m->sender, op, old_size, m->header);
      m->error.name = adjust_pointer(m->error.name, op, old_size, m->header);

      m->free_header = true1;

      if (add_offset) {
              if (m->n_header_offsets >= ELEMENTSOF(m->header_offsets)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(m->header_offsets), typeof(&*(m->header_offsets
))), sizeof(m->header_offsets)/sizeof((m->header_offsets
)[0]), ((void)0))))
                      goto poison;

              m->header_offsets[m->n_header_offsets++] = new_size - sizeof(struct bus_header);
      }

      return (uint8_t*) np + start;

205poison:
      m->poisoned = true1;
      return NULL((void*)0);
208}

210static int message_append_field_string(
              sd_bus_message *m,
              uint64_t h,
              char type,
              const char *s,
              const char **ret) {

      size_t l;
      uint8_t *p;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 220, __PRETTY_FUNCTION__); } while (0);

      /* dbus1 only allows 8bit header field ids */
      if (h > 0xFF)
              return -EINVAL22;

      /* dbus1 doesn't allow strings over 32bit, let's enforce this
       * globally, to not risk convertability */
      l = strlen(s);
      if (l > UINT32_MAX(4294967295U))
              return -EINVAL22;

      /* Signature "(yv)" where the variant contains "s" */

      if (BUS_MESSAGE_IS_GVARIANT(m)) {

              /* (field id 64bit, ((string + NUL) + NUL + signature string 's') */
              p = message_extend_fields(m, 8, 8 + l + 1 + 1 + 1, true1);
              if (!p)
                      return -ENOMEM12;

              *((uint64_t*) p) = h;
              memcpy(p+8, s, l);
              p[8+l] = 0;
              p[8+l+1] = 0;
              p[8+l+2] = type;

              if (ret)
                      *ret = (char*) p + 8;

      } else {
              /* (field id byte + (signature length + signature 's' + NUL) + (string length + string + NUL)) */
              p = message_extend_fields(m, 8, 4 + 4 + l + 1, false0);
              if (!p)
                      return -ENOMEM12;

              p[0] = (uint8_t) h;
              p[1] = 1;
              p[2] = type;
              p[3] = 0;

              ((uint32_t*) p)[1] = l;
              memcpy(p + 8, s, l + 1);

              if (ret)
                      *ret = (char*) p + 8;
      }

      return 0;
269}

271static int message_append_field_signature(
              sd_bus_message *m,
              uint64_t h,
              const char *s,
              const char **ret) {

      size_t l;
      uint8_t *p;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 280, __PRETTY_FUNCTION__); } while (0);

      /* dbus1 only allows 8bit header field ids */
      if (h > 0xFF)
              return -EINVAL22;

      /* dbus1 doesn't allow signatures over 8bit, let's enforce
       * this globally, to not risk convertability */
      l = strlen(s);
      if (l > 255)
              return -EINVAL22;

      /* Signature "(yv)" where the variant contains "g" */

      if (BUS_MESSAGE_IS_GVARIANT(m))
              /* For gvariant the serialization is the same as for normal strings */
              return message_append_field_string(m, h, 'g', s, ret);
      else {
              /* (field id byte + (signature length + signature 'g' + NUL) + (string length + string + NUL)) */
              p = message_extend_fields(m, 8, 4 + 1 + l + 1, false0);
              if (!p)
                      return -ENOMEM12;

              p[0] = (uint8_t) h;
              p[1] = 1;
              p[2] = SD_BUS_TYPE_SIGNATURE;
              p[3] = 0;
              p[4] = l;
              memcpy(p + 5, s, l + 1);

              if (ret)
                      *ret = (const char*) p + 5;
      }

      return 0;
315}

317static int message_append_field_uint32(sd_bus_message *m, uint64_t h, uint32_t x) {
      uint8_t *p;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 320, __PRETTY_FUNCTION__); } while (0);

      /* dbus1 only allows 8bit header field ids */
      if (h > 0xFF)
              return -EINVAL22;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              /* (field id 64bit + ((value + NUL + signature string 'u') */

              p = message_extend_fields(m, 8, 8 + 4 + 1 + 1, true1);
              if (!p)
                      return -ENOMEM12;

              *((uint64_t*) p) = h;
              *((uint32_t*) (p + 8)) = x;
              p[12] = 0;
              p[13] = 'u';
      } else {
              /* (field id byte + (signature length + signature 'u' + NUL) + value) */
              p = message_extend_fields(m, 8, 4 + 4, false0);
              if (!p)
                      return -ENOMEM12;

              p[0] = (uint8_t) h;
              p[1] = 1;
              p[2] = 'u';
              p[3] = 0;

              ((uint32_t*) p)[1] = x;
      }

      return 0;
352}

354static int message_append_field_uint64(sd_bus_message *m, uint64_t h, uint64_t x) {
      uint8_t *p;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 357, __PRETTY_FUNCTION__); } while (0);

      /* dbus1 only allows 8bit header field ids */
      if (h > 0xFF)
              return -EINVAL22;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              /* (field id 64bit + ((value + NUL + signature string 't') */

              p = message_extend_fields(m, 8, 8 + 8 + 1 + 1, true1);
              if (!p)
                      return -ENOMEM12;

              *((uint64_t*) p) = h;
              *((uint64_t*) (p + 8)) = x;
              p[16] = 0;
              p[17] = 't';
      } else {
              /* (field id byte + (signature length + signature 't' + NUL) + 4 byte padding + value) */
              p = message_extend_fields(m, 8, 4 + 4 + 8, false0);
              if (!p)
                      return -ENOMEM12;

              p[0] = (uint8_t) h;
              p[1] = 1;
              p[2] = 't';
              p[3] = 0;
              p[4] = 0;
              p[5] = 0;
              p[6] = 0;
              p[7] = 0;

              ((uint64_t*) p)[1] = x;
      }

      return 0;
393}

395static int message_append_reply_cookie(sd_bus_message *m, uint64_t cookie) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 396, __PRETTY_FUNCTION__); } while (0);

      if (BUS_MESSAGE_IS_GVARIANT(m))
              return message_append_field_uint64(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, cookie);
      else {
              /* 64bit cookies are not supported on dbus1 */
              if (cookie > 0xffffffffUL)
                      return -EOPNOTSUPP95;

              return message_append_field_uint32(m, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) cookie);
      }
407}

409int bus_message_from_header(
              sd_bus *bus,
              void *header,
              size_t header_accessible,
              void *footer,
              size_t footer_accessible,
              size_t message_size,
              int *fds,
              size_t n_fds,
              const char *label,
              size_t extra,
              sd_bus_message **ret) {

      _cleanup_free___attribute__((cleanup(freep))) sd_bus_message *m = NULL((void*)0);
      struct bus_header *h;
      size_t a, label_sz;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 426, __PRETTY_FUNCTION__); } while (0);
2
←
Assuming 'bus' is non-null→
3
←
Taking false branch→
4
←
Loop condition is false.  Exiting loop→
      assert(header || header_accessible <= 0)do { if ((__builtin_expect(!!(!(header || header_accessible <=
 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("header || header_accessible <= 0"
), "../src/libsystemd/sd-bus/bus-message.c", 427, __PRETTY_FUNCTION__
); } while (0);
5
←
Assuming 'header' is non-null→
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→
      assert(footer || footer_accessible <= 0)do { if ((__builtin_expect(!!(!(footer || footer_accessible <=
 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("footer || footer_accessible <= 0"
), "../src/libsystemd/sd-bus/bus-message.c", 428, __PRETTY_FUNCTION__
); } while (0);
8
←
Taking false branch→
9
←
Loop condition is false.  Exiting loop→
      assert(fds || n_fds <= 0)do { if ((__builtin_expect(!!(!(fds || n_fds <= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fds || n_fds <= 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 429, __PRETTY_FUNCTION__); } while (0);
10
←
Assuming 'fds' is non-null→
11
←
Taking false branch→
12
←
Loop condition is false.  Exiting loop→
      assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/libsystemd/sd-bus/bus-message.c"
, 430, __PRETTY_FUNCTION__); } while (0);
13
←
Taking false branch→
14
←
Loop condition is false.  Exiting loop→

      if (header_accessible < sizeof(struct bus_header))
15
←
Assuming the condition is false→
16
←
Taking false branch→
              return -EBADMSG74;

      if (header_accessible16.1
'header_accessible' is <= 'message_size'
 > message_size)
17
←
Taking false branch→
              return -EBADMSG74;
      if (footer_accessible17.1
'footer_accessible' is <= 'message_size'
 > message_size)
18
←
Taking false branch→
              return -EBADMSG74;

      h = header;
      if (!IN_SET(h->version, 1, 2)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){1, 2})/sizeof(int)]; switch(h->version
) { case 1: case 2: _found = 1; break; default: break; } _found
; }))
19
←
Control jumps to 'case 2:'  at line 441→
20
←
 Execution continues on line 441→
21
←
Taking false branch→
              return -EBADMSG74;

      if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
22
←
Assuming field 'type' is not equal to _SD_BUS_MESSAGE_TYPE_INVALID→
23
←
Taking false branch→
              return -EBADMSG74;

      if (!IN_SET(h->endian, BUS_LITTLE_ENDIAN, BUS_BIG_ENDIAN)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){BUS_LITTLE_ENDIAN, BUS_BIG_ENDIAN})/sizeof
(int)]; switch(h->endian) { case BUS_LITTLE_ENDIAN: case BUS_BIG_ENDIAN
: _found = 1; break; default: break; } _found; }))
24
←
Control jumps to 'case BUS_BIG_ENDIAN:'  at line 447→
25
←
 Execution continues on line 447→
26
←
Taking false branch→
              return -EBADMSG74;

      /* Note that we are happy with unknown flags in the flags header! */

      a = ALIGN(sizeof(sd_bus_message))(((sizeof(sd_bus_message)) + 7) & ~7) + ALIGN(extra)(((extra) + 7) & ~7);

      if (label) {
27
←
Assuming 'label' is null→
28
←
Taking false branch→
              label_sz = strlen(label);
              a += label_sz + 1;
      }

      m = malloc0(a)(calloc(1, (a)));
29
←
Memory is allocated→
      if (!m)
30
←
Assuming 'm' is non-null→
31
←
Taking false branch→
              return -ENOMEM12;

      m->sealed = true1;
      m->header = header;
      m->header_accessible = header_accessible;
      m->footer = footer;
      m->footer_accessible = footer_accessible;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
32
←
Taking true branch→
              size_t ws;

              if (h->dbus2.cookie == 0)
33
←
Assuming field 'cookie' is equal to 0→
34
←
Taking true branch→
                      return -EBADMSG74;
35
←
Potential leak of memory pointed to by 'm'

              /* dbus2 derives the sizes from the message size and
              the offset table at the end, since it is formatted as
              gvariant "yyyyuta{tv}v". Since the message itself is a
              structure with precisely to variable sized entries,
              there's only one offset in the table, which marks the
              end of the fields array. */

              ws = bus_gvariant_determine_word_size(message_size, 0);
              if (footer_accessible < ws)
                      return -EBADMSG74;

              m->fields_size = bus_gvariant_read_word_le((uint8_t*) footer + footer_accessible - ws, ws);
              if (ALIGN8(m->fields_size)(((m->fields_size) + 7) & ~7) > message_size - ws)
                      return -EBADMSG74;
              if (m->fields_size < sizeof(struct bus_header))
                      return -EBADMSG74;

              m->fields_size -= sizeof(struct bus_header);
              m->body_size = message_size - (sizeof(struct bus_header) + ALIGN8(m->fields_size)(((m->fields_size) + 7) & ~7));
      } else {
              if (h->dbus1.serial == 0)
                      return -EBADMSG74;

              /* dbus1 has the sizes in the header */
              m->fields_size = BUS_MESSAGE_BSWAP32(m, h->dbus1.fields_size);
              m->body_size = BUS_MESSAGE_BSWAP32(m, h->dbus1.body_size);

              if (sizeof(struct bus_header) + ALIGN8(m->fields_size)(((m->fields_size) + 7) & ~7) + m->body_size != message_size)
                      return -EBADMSG74;
      }

      m->fds = fds;
      m->n_fds = n_fds;

      if (label) {
              m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message))(((sizeof(sd_bus_message)) + 7) & ~7) + ALIGN(extra)(((extra) + 7) & ~7);
              memcpy(m->creds.label, label, label_sz + 1);

              m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
      }

      m->n_ref = 1;
      m->bus = sd_bus_ref(bus);

      *ret = TAKE_PTR(m)({ typeof(m) _ptr_ = (m); (m) = ((void*)0); _ptr_; });

      return 0;
522}

524int bus_message_from_malloc(
              sd_bus *bus,
              void *buffer,
              size_t length,
              int *fds,
              size_t n_fds,
              const char *label,
              sd_bus_message **ret) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *m = NULL((void*)0);
      size_t sz;
      int r;

      r = bus_message_from_header(
1
Calling 'bus_message_from_header'→
                      bus,
                      buffer, length, /* in this case the initial bytes and the final bytes are the same */
                      buffer, length,
                      length,
                      fds, n_fds,
                      label,
                      0, &m);
      if (r < 0)
              return r;

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

      m->n_iovec = 1;
      m->iovec = m->iovec_fixed;
      m->iovec[0].iov_base = buffer;
      m->iovec[0].iov_len = length;

      r = bus_message_parse_fields(m);
      if (r < 0)
              return r;

      /* We take possession of the memory and fds now */
      m->free_header = true1;
      m->free_fds = true1;

      *ret = TAKE_PTR(m)({ typeof(m) _ptr_ = (m); (m) = ((void*)0); _ptr_; });
      return 0;
572}

574_public___attribute__ ((visibility("default"))) int sd_bus_message_new(
              sd_bus *bus,
              sd_bus_message **m,
              uint8_t type) {

      sd_bus_message *t;

      assert_return(bus, -ENOTCONN)do { if (!(((__builtin_expect(!!(bus),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 581, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(bus->state != BUS_UNSET, -ENOTCONN)do { if (!(((__builtin_expect(!!(bus->state != BUS_UNSET),
1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus->state != BUS_UNSET"), "../src/libsystemd/sd-bus/bus-message.c"
, 582, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 583, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(type < _SD_BUS_MESSAGE_TYPE_MAX, -EINVAL)do { if (!(((__builtin_expect(!!(type < _SD_BUS_MESSAGE_TYPE_MAX
),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("type < _SD_BUS_MESSAGE_TYPE_MAX"), "../src/libsystemd/sd-bus/bus-message.c"
, 584, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      t = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header))(calloc(1, ((((sizeof(sd_bus_message)) + 7) & ~7) + sizeof
(struct bus_header))));
      if (!t)
              return -ENOMEM12;

      t->n_ref = 1;
      t->bus = sd_bus_ref(bus);
      t->header = (struct bus_header*) ((uint8_t*) t + ALIGN(sizeof(struct sd_bus_message))(((sizeof(struct sd_bus_message)) + 7) & ~7));
      t->header->endian = BUS_NATIVE_ENDIAN;
      t->header->type = type;
      t->header->version = bus->message_version;
      t->allow_fds = bus->can_fds || !IN_SET(bus->state, BUS_HELLO, BUS_RUNNING)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){BUS_HELLO, BUS_RUNNING})/sizeof(int)]; switch
(bus->state) { case BUS_HELLO: case BUS_RUNNING: _found = 1
; break; default: break; } _found; });
      t->root_container.need_offsets = BUS_MESSAGE_IS_GVARIANT(t);

      if (bus->allow_interactive_authorization)
              t->header->flags |= BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;

      *m = t;
      return 0;
604}

606_public___attribute__ ((visibility("default"))) int sd_bus_message_new_signal(
              sd_bus *bus,
              sd_bus_message **m,
              const char *path,
              const char *interface,
              const char *member) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *t = NULL((void*)0);
      int r;

      assert_return(bus, -ENOTCONN)do { if (!(((__builtin_expect(!!(bus),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 616, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(bus->state != BUS_UNSET, -ENOTCONN)do { if (!(((__builtin_expect(!!(bus->state != BUS_UNSET),
1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus->state != BUS_UNSET"), "../src/libsystemd/sd-bus/bus-message.c"
, 617, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(object_path_is_valid(path), -EINVAL)do { if (!(((__builtin_expect(!!(object_path_is_valid(path)),
1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("object_path_is_valid(path)"), "../src/libsystemd/sd-bus/bus-message.c"
, 618, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(interface_name_is_valid(interface), -EINVAL)do { if (!(((__builtin_expect(!!(interface_name_is_valid(interface
)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("interface_name_is_valid(interface)"), "../src/libsystemd/sd-bus/bus-message.c"
, 619, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(member_name_is_valid(member), -EINVAL)do { if (!(((__builtin_expect(!!(member_name_is_valid(member)
),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("member_name_is_valid(member)"), "../src/libsystemd/sd-bus/bus-message.c"
, 620, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 621, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_SIGNAL);
      if (r < 0)
              return -ENOMEM12;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/libsystemd/sd-bus/bus-message.c"
, 627, __PRETTY_FUNCTION__); } while (0);

      t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;

      r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
      if (r < 0)
              return r;
      r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
      if (r < 0)
              return r;
      r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
      if (r < 0)
              return r;

      *m = TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
      return 0;
643}

645_public___attribute__ ((visibility("default"))) 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) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *t = NULL((void*)0);
      int r;

      assert_return(bus, -ENOTCONN)do { if (!(((__builtin_expect(!!(bus),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 656, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(bus->state != BUS_UNSET, -ENOTCONN)do { if (!(((__builtin_expect(!!(bus->state != BUS_UNSET),
1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus->state != BUS_UNSET"), "../src/libsystemd/sd-bus/bus-message.c"
, 657, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(!destination || service_name_is_valid(destination), -EINVAL)do { if (!(((__builtin_expect(!!(!destination || service_name_is_valid
(destination)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("!destination || service_name_is_valid(destination)"), "../src/libsystemd/sd-bus/bus-message.c"
, 658, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(object_path_is_valid(path), -EINVAL)do { if (!(((__builtin_expect(!!(object_path_is_valid(path)),
1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("object_path_is_valid(path)"), "../src/libsystemd/sd-bus/bus-message.c"
, 659, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!interface || interface_name_is_valid(interface), -EINVAL)do { if (!(((__builtin_expect(!!(!interface || interface_name_is_valid
(interface)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("!interface || interface_name_is_valid(interface)"), "../src/libsystemd/sd-bus/bus-message.c"
, 660, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(member_name_is_valid(member), -EINVAL)do { if (!(((__builtin_expect(!!(member_name_is_valid(member)
),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("member_name_is_valid(member)"), "../src/libsystemd/sd-bus/bus-message.c"
, 661, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 662, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_METHOD_CALL);
      if (r < 0)
              return -ENOMEM12;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/libsystemd/sd-bus/bus-message.c"
, 668, __PRETTY_FUNCTION__); } while (0);

      r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
      if (r < 0)
              return r;
      r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
      if (r < 0)
              return r;

      if (interface) {
              r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
              if (r < 0)
                      return r;
      }

      if (destination) {
              r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
              if (r < 0)
                      return r;
      }

      *m = TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
      return 0;
691}

693static int message_new_reply(
              sd_bus_message *call,
              uint8_t type,
              sd_bus_message **m) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *t = NULL((void*)0);
      uint64_t cookie;
      int r;

      assert_return(call, -EINVAL)do { if (!(((__builtin_expect(!!(call),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("call"), "../src/libsystemd/sd-bus/bus-message.c"
, 702, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(call->sealed, -EPERM)do { if (!(((__builtin_expect(!!(call->sealed),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("call->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 703, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL)do { if (!(((__builtin_expect(!!(call->header->type == SD_BUS_MESSAGE_METHOD_CALL
),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("call->header->type == SD_BUS_MESSAGE_METHOD_CALL"),
 "../src/libsystemd/sd-bus/bus-message.c", 704, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(call->bus->state != BUS_UNSET, -ENOTCONN)do { if (!(((__builtin_expect(!!(call->bus->state != BUS_UNSET
),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("call->bus->state != BUS_UNSET"), "../src/libsystemd/sd-bus/bus-message.c"
, 705, __PRETTY_FUNCTION__), 0))) return (-107); } while (0);
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 706, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      cookie = BUS_MESSAGE_COOKIE(call);
      if (cookie == 0)
              return -EOPNOTSUPP95;

      r = sd_bus_message_new(call->bus, &t, type);
      if (r < 0)
              return -ENOMEM12;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/libsystemd/sd-bus/bus-message.c"
, 716, __PRETTY_FUNCTION__); } while (0);

      t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
      t->reply_cookie = cookie;
      r = message_append_reply_cookie(t, t->reply_cookie);
      if (r < 0)
              return r;

      if (call->sender) {
              r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->destination);
              if (r < 0)
                      return r;
      }

      t->dont_send = !!(call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
      t->enforced_reply_signature = call->enforced_reply_signature;

      *m = TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
      return 0;
735}

737_public___attribute__ ((visibility("default"))) int sd_bus_message_new_method_return(
              sd_bus_message *call,
              sd_bus_message **m) {

      return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m);
742}

744_public___attribute__ ((visibility("default"))) int sd_bus_message_new_method_error(
              sd_bus_message *call,
              sd_bus_message **m,
              const sd_bus_error *e) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *t = NULL((void*)0);
      int r;

      assert_return(sd_bus_error_is_set(e), -EINVAL)do { if (!(((__builtin_expect(!!(sd_bus_error_is_set(e)),1)))
 ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, (
"sd_bus_error_is_set(e)"), "../src/libsystemd/sd-bus/bus-message.c"
, 752, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 753, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
      if (r < 0)
              return r;

      r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
      if (r < 0)
              return r;

      if (e->message) {
              r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
              if (r < 0)
                      return r;
      }

      t->error._need_free = -1;

      *m = TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
      return 0;
773}

775_public___attribute__ ((visibility("default"))) int sd_bus_message_new_method_errorf(
              sd_bus_message *call,
              sd_bus_message **m,
              const char *name,
              const char *format,
              ...) {

      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});
      va_list ap;

      assert_return(name, -EINVAL)do { if (!(((__builtin_expect(!!(name),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/libsystemd/sd-bus/bus-message.c"
, 785, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 786, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      va_start(ap, format)__builtin_va_start(ap, format);
      bus_error_setfv(&error, name, format, ap);
      va_end(ap)__builtin_va_end(ap);

      return sd_bus_message_new_method_error(call, m, &error);
793}

795_public___attribute__ ((visibility("default"))) int sd_bus_message_new_method_errno(
              sd_bus_message *call,
              sd_bus_message **m,
              int error,
              const sd_bus_error *p) {

      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error berror = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

      if (sd_bus_error_is_set(p))
              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, m, &berror);
809}

811_public___attribute__ ((visibility("default"))) int sd_bus_message_new_method_errnof(
              sd_bus_message *call,
              sd_bus_message **m,
              int error,
              const char *format,
              ...) {

      _cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error berror = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});
      va_list ap;

      va_start(ap, format)__builtin_va_start(ap, format);
      sd_bus_error_set_errnofv(&berror, error, format, ap);
      va_end(ap)__builtin_va_end(ap);

      return sd_bus_message_new_method_error(call, m, &berror);
826}

828void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m) {
      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 829, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 830, __PRETTY_FUNCTION__); } while (0);

      m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus.Local";
      m->creds.well_known_names_local = true1;
      m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
835}

837void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m) {
      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 838, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 839, __PRETTY_FUNCTION__); } while (0);

      m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
      m->creds.well_known_names_driver = true1;
      m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
844}

846int bus_message_new_synthetic_error(
              sd_bus *bus,
              uint64_t cookie,
              const sd_bus_error *e,
              sd_bus_message **m) {

      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *t = NULL((void*)0);
      int r;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 855, __PRETTY_FUNCTION__); } while (0);
      assert(sd_bus_error_is_set(e))do { if ((__builtin_expect(!!(!(sd_bus_error_is_set(e))),0)))
 log_assert_failed_realm(LOG_REALM_SYSTEMD, ("sd_bus_error_is_set(e)"
), "../src/libsystemd/sd-bus/bus-message.c", 856, __PRETTY_FUNCTION__
); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 857, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_new(bus, &t, SD_BUS_MESSAGE_METHOD_ERROR);
      if (r < 0)
              return -ENOMEM12;

      assert(t)do { if ((__builtin_expect(!!(!(t)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("t"), "../src/libsystemd/sd-bus/bus-message.c"
, 863, __PRETTY_FUNCTION__); } while (0);

      t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
      t->reply_cookie = cookie;

      r = message_append_reply_cookie(t, t->reply_cookie);
      if (r < 0)
              return r;

      if (bus && bus->unique_name) {
              r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination);
              if (r < 0)
                      return r;
      }

      r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
      if (r < 0)
              return r;

      if (e->message) {
              r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
              if (r < 0)
                      return r;
      }

      t->error._need_free = -1;

      bus_message_set_sender_driver(bus, t);

      *m = TAKE_PTR(t)({ typeof(t) _ptr_ = (t); (t) = ((void*)0); _ptr_; });
      return 0;
894}

896_public___attribute__ ((visibility("default"))) sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
      if (!m)
              return NULL((void*)0);

      /* We are fine if this message so far was either explicitly reffed or not reffed but queued into at
       * least one bus connection object. */
      assert(m->n_ref > 0 || m->n_queued > 0)do { if ((__builtin_expect(!!(!(m->n_ref > 0 || m->n_queued
 > 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("m->n_ref > 0 || m->n_queued > 0"
), "../src/libsystemd/sd-bus/bus-message.c", 902, __PRETTY_FUNCTION__
); } while (0);

      m->n_ref++;

      /* Each user reference to a bus message shall also be considered a ref on the bus */
      sd_bus_ref(m->bus);
      return m;
909}

911_public___attribute__ ((visibility("default"))) sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
      if (!m)
              return NULL((void*)0);

      assert(m->n_ref > 0)do { if ((__builtin_expect(!!(!(m->n_ref > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m->n_ref > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 915, __PRETTY_FUNCTION__); } while (0);

      sd_bus_unref(m->bus); /* Each regular ref is also a ref on the bus connection. Let's hence drop it
                             * here. Note we have to do this before decrementing our own n_ref here, since
                             * otherwise, if this message is currently queued sd_bus_unref() might call
                             * bus_message_unref_queued() for this which might then destroy the message
                             * while we are still processing it. */
      m->n_ref--;

      if (m->n_ref > 0 || m->n_queued > 0)
              return NULL((void*)0);

      /* Unset the bus field if neither the user has a reference nor this message is queued. We are careful
       * to reset the field only after the last reference to the bus is dropped, after all we might keep
       * multiple references to the bus, once for each reference kept on outselves. */
      m->bus = NULL((void*)0);

      return message_free(m);
933}

935sd_bus_message* bus_message_ref_queued(sd_bus_message *m, sd_bus *bus) {
      if (!m)
              return NULL((void*)0);

      /* If this is a different bus than the message is associated with, then implicitly turn this into a
       * regular reference. This means that you can create a memory leak by enqueuing a message generated
       * on one bus onto another at the same time as enqueueing a message from the second one on the first,
       * as we'll not detect the cyclic references there. */
      if (bus != m->bus)
              return sd_bus_message_ref(m);

      assert(m->n_ref > 0 || m->n_queued > 0)do { if ((__builtin_expect(!!(!(m->n_ref > 0 || m->n_queued
 > 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("m->n_ref > 0 || m->n_queued > 0"
), "../src/libsystemd/sd-bus/bus-message.c", 946, __PRETTY_FUNCTION__
); } while (0);
      m->n_queued++;

      return m;
950}

952sd_bus_message* bus_message_unref_queued(sd_bus_message *m, sd_bus *bus) {
      if (!m)
              return NULL((void*)0);

      if (bus != m->bus)
              return sd_bus_message_unref(m);

      assert(m->n_queued > 0)do { if ((__builtin_expect(!!(!(m->n_queued > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m->n_queued > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 959, __PRETTY_FUNCTION__); } while (0);
      m->n_queued--;

      if (m->n_ref > 0 || m->n_queued > 0)
              return NULL((void*)0);

      m->bus = NULL((void*)0);

      return message_free(m);
968}

970_public___attribute__ ((visibility("default"))) int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 971, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(type, -EINVAL)do { if (!(((__builtin_expect(!!(type),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("type"), "../src/libsystemd/sd-bus/bus-message.c"
, 972, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      *type = m->header->type;
      return 0;
976}

978_public___attribute__ ((visibility("default"))) int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie) {
      uint64_t c;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 981, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(cookie, -EINVAL)do { if (!(((__builtin_expect(!!(cookie),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("cookie"), "../src/libsystemd/sd-bus/bus-message.c"
, 982, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      c = BUS_MESSAGE_COOKIE(m);
      if (c == 0)
              return -ENODATA61;

      *cookie = BUS_MESSAGE_COOKIE(m);
      return 0;
990}

992_public___attribute__ ((visibility("default"))) int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 993, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(cookie, -EINVAL)do { if (!(((__builtin_expect(!!(cookie),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("cookie"), "../src/libsystemd/sd-bus/bus-message.c"
, 994, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->reply_cookie == 0)
              return -ENODATA61;

      *cookie = m->reply_cookie;
      return 0;
1001}

1003_public___attribute__ ((visibility("default"))) int sd_bus_message_get_expect_reply(sd_bus_message *m) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1004, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
              !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
1008}

1010_public___attribute__ ((visibility("default"))) int sd_bus_message_get_auto_start(sd_bus_message *m) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1011, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      return !(m->header->flags & BUS_MESSAGE_NO_AUTO_START);
1014}

1016_public___attribute__ ((visibility("default"))) int sd_bus_message_get_allow_interactive_authorization(sd_bus_message *m) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1017, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
              (m->header->flags & BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION);
1021}

1023_public___attribute__ ((visibility("default"))) const char *sd_bus_message_get_path(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1024, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      return m->path;
1027}

1029_public___attribute__ ((visibility("default"))) const char *sd_bus_message_get_interface(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1030, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      return m->interface;
1033}

1035_public___attribute__ ((visibility("default"))) const char *sd_bus_message_get_member(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1036, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      return m->member;
1039}

1041_public___attribute__ ((visibility("default"))) const char *sd_bus_message_get_destination(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1042, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      return m->destination;
1045}

1047_public___attribute__ ((visibility("default"))) const char *sd_bus_message_get_sender(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1048, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      return m->sender;
1051}

1053_public___attribute__ ((visibility("default"))) const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1054, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      if (!sd_bus_error_is_set(&m->error))
              return NULL((void*)0);

      return &m->error;
1060}

1062_public___attribute__ ((visibility("default"))) int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1063, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(usec, -EINVAL)do { if (!(((__builtin_expect(!!(usec),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("usec"), "../src/libsystemd/sd-bus/bus-message.c"
, 1064, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->monotonic <= 0)
              return -ENODATA61;

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

1073_public___attribute__ ((visibility("default"))) int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1074, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(usec, -EINVAL)do { if (!(((__builtin_expect(!!(usec),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("usec"), "../src/libsystemd/sd-bus/bus-message.c"
, 1075, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->realtime <= 0)
              return -ENODATA61;

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

1084_public___attribute__ ((visibility("default"))) int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1085, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(seqnum, -EINVAL)do { if (!(((__builtin_expect(!!(seqnum),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("seqnum"), "../src/libsystemd/sd-bus/bus-message.c"
, 1086, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->seqnum <= 0)
              return -ENODATA61;

      *seqnum = m->seqnum;
      return 0;
1093}

1095_public___attribute__ ((visibility("default"))) sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1096, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      if (m->creds.mask == 0)
              return NULL((void*)0);

      return &m->creds;
1102}

1104_public___attribute__ ((visibility("default"))) int sd_bus_message_is_signal(
              sd_bus_message *m,
              const char *interface,
              const char *member) {

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1109, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
              return 0;

      if (interface && !streq_ptr(m->interface, interface))
              return 0;

      if (member && !streq_ptr(m->member, member))
              return 0;

      return 1;
1121}

1123_public___attribute__ ((visibility("default"))) int sd_bus_message_is_method_call(
              sd_bus_message *m,
              const char *interface,
              const char *member) {

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1128, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
              return 0;

      if (interface && !streq_ptr(m->interface, interface))
              return 0;

      if (member && !streq_ptr(m->member, member))
              return 0;

      return 1;
1140}

1142_public___attribute__ ((visibility("default"))) int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1143, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
              return 0;

      if (name && !streq_ptr(m->error.name, name))
              return 0;

      return 1;
1152}

1154_public___attribute__ ((visibility("default"))) int sd_bus_message_set_expect_reply(sd_bus_message *m, int b) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1155, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 1156, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EPERM)do { if (!(((__builtin_expect(!!(m->header->type == SD_BUS_MESSAGE_METHOD_CALL
),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("m->header->type == SD_BUS_MESSAGE_METHOD_CALL"), "../src/libsystemd/sd-bus/bus-message.c"
, 1157, __PRETTY_FUNCTION__), 0))) return (-1); } while (0);

      SET_FLAG(m->header->flags, BUS_MESSAGE_NO_REPLY_EXPECTED, !b)(m->header->flags) = (!b) ? ((m->header->flags) |
 (BUS_MESSAGE_NO_REPLY_EXPECTED)) : ((m->header->flags)
 & ~(BUS_MESSAGE_NO_REPLY_EXPECTED));

      return 0;
1162}

1164_public___attribute__ ((visibility("default"))) int sd_bus_message_set_auto_start(sd_bus_message *m, int b) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1165, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 1166, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      SET_FLAG(m->header->flags, BUS_MESSAGE_NO_AUTO_START, !b)(m->header->flags) = (!b) ? ((m->header->flags) |
 (BUS_MESSAGE_NO_AUTO_START)) : ((m->header->flags) &
 ~(BUS_MESSAGE_NO_AUTO_START));

      return 0;
1171}

1173_public___attribute__ ((visibility("default"))) int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *m, int b) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1174, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 1175, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      SET_FLAG(m->header->flags, BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION, b)(m->header->flags) = (b) ? ((m->header->flags) | (
BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION)) : ((m->header
->flags) & ~(BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION
));

      return 0;
1180}

1182struct bus_body_part *message_append_part(sd_bus_message *m) {
      struct bus_body_part *part;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1185, __PRETTY_FUNCTION__); } while (0);

      if (m->poisoned)
              return NULL((void*)0);

      if (m->n_body_parts <= 0) {
              part = &m->body;
              zero(*part)(({ size_t _l_ = (sizeof(*part)); void *_x_ = (&(*part));
 _l_ == 0 ? _x_ : memset(_x_, 0, _l_); }));
      } else {
              assert(m->body_end)do { if ((__builtin_expect(!!(!(m->body_end)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m->body_end"), "../src/libsystemd/sd-bus/bus-message.c"
, 1194, __PRETTY_FUNCTION__); } while (0);

              part = new0(struct bus_body_part, 1)((struct bus_body_part*) calloc((1), sizeof(struct bus_body_part
)));
              if (!part) {
                      m->poisoned = true1;
                      return NULL((void*)0);
              }

              m->body_end->next = part;
      }

      part->memfd = -1;
      m->body_end = part;
      m->n_body_parts++;

      return part;
1210}

1212static void part_zero(struct bus_body_part *part, size_t sz) {
      assert(part)do { if ((__builtin_expect(!!(!(part)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("part"), "../src/libsystemd/sd-bus/bus-message.c"
, 1213, __PRETTY_FUNCTION__); } while (0);
      assert(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1214, __PRETTY_FUNCTION__); } while (0);
      assert(sz < 8)do { if ((__builtin_expect(!!(!(sz < 8)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz < 8"), "../src/libsystemd/sd-bus/bus-message.c"
, 1215, __PRETTY_FUNCTION__); } while (0);

      /* All other fields can be left in their defaults */
      assert(!part->data)do { if ((__builtin_expect(!!(!(!part->data)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!part->data"), "../src/libsystemd/sd-bus/bus-message.c"
, 1218, __PRETTY_FUNCTION__); } while (0);
      assert(part->memfd < 0)do { if ((__builtin_expect(!!(!(part->memfd < 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("part->memfd < 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1219, __PRETTY_FUNCTION__); } while (0);

      part->size = sz;
      part->is_zero = true1;
      part->sealed = true1;
1224}

1226static int part_make_space(
              struct sd_bus_message *m,
              struct bus_body_part *part,
              size_t sz,
              void **q) {

      void *n;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1234, __PRETTY_FUNCTION__); } while (0);
      assert(part)do { if ((__builtin_expect(!!(!(part)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("part"), "../src/libsystemd/sd-bus/bus-message.c"
, 1235, __PRETTY_FUNCTION__); } while (0);
      assert(!part->sealed)do { if ((__builtin_expect(!!(!(!part->sealed)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!part->sealed"), "../src/libsystemd/sd-bus/bus-message.c"
, 1236, __PRETTY_FUNCTION__); } while (0);

      if (m->poisoned)
              return -ENOMEM12;

      if (part->allocated == 0 || sz > part->allocated) {
              size_t new_allocated;

              new_allocated = sz > 0 ? 2 * sz : 64;
              n = realloc(part->data, new_allocated);
              if (!n) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }

              part->data = n;
              part->allocated = new_allocated;
              part->free_this = true1;
      }

      if (q)
              *q = part->data ? (uint8_t*) part->data + part->size : NULL((void*)0);

      part->size = sz;
      return 0;
1261}

1263static int message_add_offset(sd_bus_message *m, size_t offset) {
      struct bus_container *c;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1266, __PRETTY_FUNCTION__); } while (0);
      assert(BUS_MESSAGE_IS_GVARIANT(m))do { if ((__builtin_expect(!!(!(BUS_MESSAGE_IS_GVARIANT(m))),
0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("BUS_MESSAGE_IS_GVARIANT(m)"
), "../src/libsystemd/sd-bus/bus-message.c", 1267, __PRETTY_FUNCTION__
); } while (0);

      /* Add offset to current container, unless this is the first
       * item in it, which will have the 0 offset, which we can
       * ignore. */
      c = message_get_last_container(m);

      if (!c->need_offsets)
              return 0;

      if (!GREEDY_REALLOC(c->offsets, c->offsets_allocated, c->n_offsets + 1)greedy_realloc((void**) &(c->offsets), &(c->offsets_allocated
), (c->n_offsets + 1), sizeof((c->offsets)[0])))
              return -ENOMEM12;

      c->offsets[c->n_offsets++] = offset;
      return 0;
1282}

1284static void message_extend_containers(sd_bus_message *m, size_t expand) {
      struct bus_container *c;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1287, __PRETTY_FUNCTION__); } while (0);

      if (expand <= 0)
              return;

      /* Update counters */
      for (c = m->containers; c < m->containers + m->n_containers; c++) {

              if (c->array_size)
                      *c->array_size += expand;
      }
1298}

1300static void *message_extend_body(
              sd_bus_message *m,
              size_t align,
              size_t sz,
              bool_Bool add_offset,
              bool_Bool force_inline) {

      size_t start_body, end_body, padding, added;
      void *p;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1311, __PRETTY_FUNCTION__); } while (0);
      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1312, __PRETTY_FUNCTION__); } while (0);
      assert(!m->sealed)do { if ((__builtin_expect(!!(!(!m->sealed)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!m->sealed"), "../src/libsystemd/sd-bus/bus-message.c"
, 1313, __PRETTY_FUNCTION__); } while (0);

      if (m->poisoned)
              return NULL((void*)0);

      start_body = ALIGN_TO((size_t) m->body_size, align);
      end_body = start_body + sz;

      padding = start_body - m->body_size;
      added = padding + sz;

      /* Check for 32bit overflows */
      if (end_body > (size_t) ((uint32_t) -1) ||
          end_body < start_body) {
              m->poisoned = true1;
              return NULL((void*)0);
      }

      if (added > 0) {
              struct bus_body_part *part = NULL((void*)0);
              bool_Bool add_new_part;

              add_new_part =
                      m->n_body_parts <= 0 ||
                      m->body_end->sealed ||
                      (padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size) ||
                      (force_inline && m->body_end->size > MEMFD_MIN_SIZE(512*1024));
                      /* If this must be an inlined extension, let's create a new part if
                       * the previous part is large enough to be inlined. */

              if (add_new_part) {
                      if (padding > 0) {
                              part = message_append_part(m);
                              if (!part)
                                      return NULL((void*)0);

                              part_zero(part, padding);
                      }

                      part = message_append_part(m);
                      if (!part)
                              return NULL((void*)0);

                      r = part_make_space(m, part, sz, &p);
                      if (r < 0)
                              return NULL((void*)0);
              } else {
                      struct bus_container *c;
                      void *op;
                      size_t os, start_part, end_part;

                      part = m->body_end;
                      op = part->data;
                      os = part->size;

                      start_part = ALIGN_TO(part->size, align);
                      end_part = start_part + sz;

                      r = part_make_space(m, part, end_part, &p);
                      if (r < 0)
                              return NULL((void*)0);

                      if (padding > 0) {
                              memzero(p, padding)({ size_t _l_ = (padding); void *_x_ = (p); _l_ == 0 ? _x_ : memset
(_x_, 0, _l_); });
                              p = (uint8_t*) p + padding;
                      }

                      /* Readjust pointers */
                      for (c = m->containers; c < m->containers + m->n_containers; c++)
                              c->array_size = adjust_pointer(c->array_size, op, os, part->data);

                      m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data);
              }
      } else
              /* Return something that is not NULL and is aligned */
              p = (uint8_t*) align;

      m->body_size = end_body;
      message_extend_containers(m, added);

      if (add_offset) {
              r = message_add_offset(m, end_body);
              if (r < 0) {
                      m->poisoned = true1;
                      return NULL((void*)0);
              }
      }

      return p;
1402}

1404static int message_push_fd(sd_bus_message *m, int fd) {
      int *f, copy;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1407, __PRETTY_FUNCTION__); } while (0);

      if (fd < 0)
              return -EINVAL22;

      if (!m->allow_fds)
              return -EOPNOTSUPP95;

      copy = fcntl(fd, F_DUPFD_CLOEXEC1030, 3);
      if (copy < 0)
              return -errno(*__errno_location ());

      f = reallocarray(m->fds, sizeof(int), m->n_fds + 1);
      if (!f) {
              m->poisoned = true1;
              safe_close(copy);
              return -ENOMEM12;
      }

      m->fds = f;
      m->fds[m->n_fds] = copy;
      m->free_fds = true1;

      return copy;
1431}

1433int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
      _cleanup_close___attribute__((cleanup(closep))) int fd = -1;
      struct bus_container *c;
      ssize_t align, sz;
      void *a;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1439, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 1440, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(bus_type_is_basic(type), -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_basic(type)),1))
) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, (
"bus_type_is_basic(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 1441, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 1442, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      c = message_get_last_container(m);

      if (c->signature && c->signature[c->index]) {
              /* Container signature is already set */

              if (c->signature[c->index] != type)
                      return -ENXIO6;
      } else {
              char *e;

              /* Maybe we can append to the signature? But only if this is the top-level container */
              if (c->enclosing != 0)
                      return -ENXIO6;

              e = strextend(&c->signature, CHAR_TO_STR(type), NULL)strextend_with_separator(&c->signature, ((void*)0), ((
char[2]) { type, 0 }), ((void*)0));
              if (!e) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }
      }

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              uint8_t u8;
              uint32_t u32;

              switch (type) {

              case SD_BUS_TYPE_SIGNATURE:
              case SD_BUS_TYPE_STRING:
                      p = strempty(p);

                      _fallthrough_;
              case SD_BUS_TYPE_OBJECT_PATH:
                      if (!p)
                              return -EINVAL22;

                      align = 1;
                      sz = strlen(p) + 1;
                      break;

              case SD_BUS_TYPE_BOOLEAN:

                      u8 = p && *(int*) p;
                      p = &u8;

                      align = sz = 1;
                      break;

              case SD_BUS_TYPE_UNIX_FD:

                      if (!p)
                              return -EINVAL22;

                      fd = message_push_fd(m, *(int*) p);
                      if (fd < 0)
                              return fd;

                      u32 = m->n_fds;
                      p = &u32;

                      align = sz = 4;
                      break;

              default:
                      align = bus_gvariant_get_alignment(CHAR_TO_STR(type)((char[2]) { type, 0 }));
                      sz = bus_gvariant_get_size(CHAR_TO_STR(type)((char[2]) { type, 0 }));
                      break;
              }

              assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1513, __PRETTY_FUNCTION__); } while (0);
              assert(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1514, __PRETTY_FUNCTION__); } while (0);

              a = message_extend_body(m, align, sz, true1, false0);
              if (!a)
                      return -ENOMEM12;

              memcpy(a, p, sz);

              if (stored)
                      *stored = (const uint8_t*) a;

      } else {
              uint32_t u32;

              switch (type) {

              case SD_BUS_TYPE_STRING:
                      /* To make things easy we'll serialize a NULL string
                       * into the empty string */
                      p = strempty(p);

                      _fallthrough_;
              case SD_BUS_TYPE_OBJECT_PATH:

                      if (!p)
                              return -EINVAL22;

                      align = 4;
                      sz = 4 + strlen(p) + 1;
                      break;

              case SD_BUS_TYPE_SIGNATURE:

                      p = strempty(p);

                      align = 1;
                      sz = 1 + strlen(p) + 1;
                      break;

              case SD_BUS_TYPE_BOOLEAN:

                      u32 = p && *(int*) p;
                      p = &u32;

                      align = sz = 4;
                      break;

              case SD_BUS_TYPE_UNIX_FD:

                      if (!p)
                              return -EINVAL22;

                      fd = message_push_fd(m, *(int*) p);
                      if (fd < 0)
                              return fd;

                      u32 = m->n_fds;
                      p = &u32;

                      align = sz = 4;
                      break;

              default:
                      align = bus_type_get_alignment(type);
                      sz = bus_type_get_size(type);
                      break;
              }

              assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1582, __PRETTY_FUNCTION__); } while (0);
              assert(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 1583, __PRETTY_FUNCTION__); } while (0);

              a = message_extend_body(m, align, sz, false0, false0);
              if (!a)
                      return -ENOMEM12;

              if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH
})/sizeof(int)]; switch(type) { case SD_BUS_TYPE_STRING: case
 SD_BUS_TYPE_OBJECT_PATH: _found = 1; break; default: break; }
 _found; })) {
                      *(uint32_t*) a = sz - 5;
                      memcpy((uint8_t*) a + 4, p, sz - 4);

                      if (stored)
                              *stored = (const uint8_t*) a + 4;

              } else if (type == SD_BUS_TYPE_SIGNATURE) {
                      *(uint8_t*) a = sz - 2;
                      memcpy((uint8_t*) a + 1, p, sz - 1);

                      if (stored)
                              *stored = (const uint8_t*) a + 1;
              } else {
                      memcpy(a, p, sz);

                      if (stored)
                              *stored = a;
              }
      }

      if (type == SD_BUS_TYPE_UNIX_FD)
              m->n_fds++;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index++;

      fd = -1;
      return 0;
1618}

1620_public___attribute__ ((visibility("default"))) int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
      return message_append_basic(m, type, p, NULL((void*)0));
1622}

1624_public___attribute__ ((visibility("default"))) int sd_bus_message_append_string_space(
              sd_bus_message *m,
              size_t size,
              char **s) {

      struct bus_container *c;
      void *a;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1632, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(s, -EINVAL)do { if (!(((__builtin_expect(!!(s),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/libsystemd/sd-bus/bus-message.c"
, 1633, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 1634, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 1635, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      c = message_get_last_container(m);

      if (c->signature && c->signature[c->index]) {
              /* Container signature is already set */

              if (c->signature[c->index] != SD_BUS_TYPE_STRING)
                      return -ENXIO6;
      } else {
              char *e;

              /* Maybe we can append to the signature? But only if this is the top-level container */
              if (c->enclosing != 0)
                      return -ENXIO6;

              e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL)strextend_with_separator(&c->signature, ((void*)0), ((
char[2]) { SD_BUS_TYPE_STRING, 0 }), ((void*)0));
              if (!e) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }
      }

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              a = message_extend_body(m, 1, size + 1, true1, false0);
              if (!a)
                      return -ENOMEM12;

              *s = a;
      } else {
              a = message_extend_body(m, 4, 4 + size + 1, false0, false0);
              if (!a)
                      return -ENOMEM12;

              *(uint32_t*) a = size;
              *s = (char*) a + 4;
      }

      (*s)[size] = 0;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index++;

      return 0;
1679}

1681_public___attribute__ ((visibility("default"))) int sd_bus_message_append_string_iovec(
              sd_bus_message *m,
              const struct iovec *iov,
              unsigned n /* should be size_t, but is API now… 😞 */) {

      size_t size;
      unsigned i;
      char *p;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1691, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 1692, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(iov || n == 0, -EINVAL)do { if (!(((__builtin_expect(!!(iov || n == 0),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("iov || n == 0"
), "../src/libsystemd/sd-bus/bus-message.c", 1693, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 1694, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      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;
1713}

1715static int bus_message_open_array(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              uint32_t **array_size,
              size_t *begin,
              bool_Bool *need_offsets) {

      unsigned nindex;
      int alignment, r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1726, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 1727, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 1728, __PRETTY_FUNCTION__); } while (0);
      assert(array_size)do { if ((__builtin_expect(!!(!(array_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("array_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 1729, __PRETTY_FUNCTION__); } while (0);
      assert(begin)do { if ((__builtin_expect(!!(!(begin)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("begin"), "../src/libsystemd/sd-bus/bus-message.c"
, 1730, __PRETTY_FUNCTION__); } while (0);
      assert(need_offsets)do { if ((__builtin_expect(!!(!(need_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("need_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 1731, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_single(contents, true1))
              return -EINVAL22;

      if (c->signature && c->signature[c->index]) {

              /* Verify the existing signature */

              if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
                      return -ENXIO6;

              if (!startswith(c->signature + c->index + 1, contents))
                      return -ENXIO6;

              nindex = c->index + 1 + strlen(contents);
      } else {
              char *e;

              if (c->enclosing != 0)
                      return -ENXIO6;

              /* Extend the existing signature */

              e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL)strextend_with_separator(&c->signature, ((void*)0), ((
char[2]) { SD_BUS_TYPE_ARRAY, 0 }), contents, ((void*)0));
              if (!e) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }

              nindex = e - c->signature;
      }

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              alignment = bus_gvariant_get_alignment(contents);
              if (alignment < 0)
                      return alignment;

              /* Add alignment padding and add to offset list */
              if (!message_extend_body(m, alignment, 0, false0, false0))
                      return -ENOMEM12;

              r = bus_gvariant_is_fixed_size(contents);
              if (r < 0)
                      return r;

              *begin = m->body_size;
              *need_offsets = r == 0;
      } else {
              void *a, *op;
              size_t os;
              struct bus_body_part *o;

              alignment = bus_type_get_alignment(contents[0]);
              if (alignment < 0)
                      return alignment;

              a = message_extend_body(m, 4, 4, false0, false0);
              if (!a)
                      return -ENOMEM12;

              o = m->body_end;
              op = m->body_end->data;
              os = m->body_end->size;

              /* Add alignment between size and first element */
              if (!message_extend_body(m, alignment, 0, false0, false0))
                      return -ENOMEM12;

              /* location of array size might have changed so let's readjust a */
              if (o == m->body_end)
                      a = adjust_pointer(a, op, os, m->body_end->data);

              *(uint32_t*) a = 0;
              *array_size = a;
      }

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index = nindex;

      return 0;
1812}

1814static int bus_message_open_variant(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents) {

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1819, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 1820, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 1821, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_single(contents, false0))
              return -EINVAL22;

      if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
              return -EINVAL22;

      if (c->signature && c->signature[c->index]) {

              if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
                      return -ENXIO6;

      } else {
              char *e;

              if (c->enclosing != 0)
                      return -ENXIO6;

              e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL)strextend_with_separator(&c->signature, ((void*)0), ((
char[2]) { SD_BUS_TYPE_VARIANT, 0 }), ((void*)0));
              if (!e) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }
      }

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              /* Variants are always aligned to 8 */

              if (!message_extend_body(m, 8, 0, false0, false0))
                      return -ENOMEM12;

      } else {
              size_t l;
              void *a;

              l = strlen(contents);
              a = message_extend_body(m, 1, 1 + l + 1, false0, false0);
              if (!a)
                      return -ENOMEM12;

              *(uint8_t*) a = l;
              memcpy((uint8_t*) a + 1, contents, l + 1);
      }

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index++;

      return 0;
1870}

1872static int bus_message_open_struct(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              size_t *begin,
              bool_Bool *need_offsets) {

      size_t nindex;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1882, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 1883, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 1884, __PRETTY_FUNCTION__); } while (0);
      assert(begin)do { if ((__builtin_expect(!!(!(begin)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("begin"), "../src/libsystemd/sd-bus/bus-message.c"
, 1885, __PRETTY_FUNCTION__); } while (0);
      assert(need_offsets)do { if ((__builtin_expect(!!(!(need_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("need_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 1886, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_valid(contents, false0))
              return -EINVAL22;

      if (c->signature && c->signature[c->index]) {
              size_t l;

              l = strlen(contents);

              if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
                  !startswith(c->signature + c->index + 1, contents) ||
                  c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
                      return -ENXIO6;

              nindex = c->index + 1 + l + 1;
      } else {
              char *e;

              if (c->enclosing != 0)
                      return -ENXIO6;

              e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL)strextend_with_separator(&c->signature, ((void*)0), ((
char[2]) { SD_BUS_TYPE_STRUCT_BEGIN, 0 }), contents, ((char[2
]) { SD_BUS_TYPE_STRUCT_END, 0 }), ((void*)0));
              if (!e) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }

              nindex = e - c->signature;
      }

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              int alignment;

              alignment = bus_gvariant_get_alignment(contents);
              if (alignment < 0)
                      return alignment;

              if (!message_extend_body(m, alignment, 0, false0, false0))
                      return -ENOMEM12;

              r = bus_gvariant_is_fixed_size(contents);
              if (r < 0)
                      return r;

              *begin = m->body_size;
              *need_offsets = r == 0;
      } else {
              /* Align contents to 8 byte boundary */
              if (!message_extend_body(m, 8, 0, false0, false0))
                      return -ENOMEM12;
      }

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index = nindex;

      return 0;
1943}

1945static int bus_message_open_dict_entry(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              size_t *begin,
              bool_Bool *need_offsets) {

      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 1954, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 1955, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 1956, __PRETTY_FUNCTION__); } while (0);
      assert(begin)do { if ((__builtin_expect(!!(!(begin)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("begin"), "../src/libsystemd/sd-bus/bus-message.c"
, 1957, __PRETTY_FUNCTION__); } while (0);
      assert(need_offsets)do { if ((__builtin_expect(!!(!(need_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("need_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 1958, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_pair(contents))
              return -EINVAL22;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              return -ENXIO6;

      if (c->signature && c->signature[c->index]) {
              size_t l;

              l = strlen(contents);

              if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
                  !startswith(c->signature + c->index + 1, contents) ||
                  c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
                      return -ENXIO6;
      } else
              return -ENXIO6;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              int alignment;

              alignment = bus_gvariant_get_alignment(contents);
              if (alignment < 0)
                      return alignment;

              if (!message_extend_body(m, alignment, 0, false0, false0))
                      return -ENOMEM12;

              r = bus_gvariant_is_fixed_size(contents);
              if (r < 0)
                      return r;

              *begin = m->body_size;
              *need_offsets = r == 0;
      } else {
              /* Align contents to 8 byte boundary */
              if (!message_extend_body(m, 8, 0, false0, false0))
                      return -ENOMEM12;
      }

      return 0;
2001}

2003_public___attribute__ ((visibility("default"))) int sd_bus_message_open_container(
              sd_bus_message *m,
              char type,
              const char *contents) {

      struct bus_container *c;
      uint32_t *array_size = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *signature = NULL((void*)0);
      size_t before, begin = 0;
      bool_Bool need_offsets = false0;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2015, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2016, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(contents, -EINVAL)do { if (!(((__builtin_expect(!!(contents),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 2017, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2018, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      /* Make sure we have space for one more container */
      if (!GREEDY_REALLOC(m->containers, m->containers_allocated, m->n_containers + 1)greedy_realloc((void**) &(m->containers), &(m->
containers_allocated), (m->n_containers + 1), sizeof((m->
containers)[0]))) {
              m->poisoned = true1;
              return -ENOMEM12;
      }

      c = message_get_last_container(m);

      signature = strdup(contents);
      if (!signature) {
              m->poisoned = true1;
              return -ENOMEM12;
      }

      /* Save old index in the parent container, in case we have to
       * abort this container */
      c->saved_index = c->index;
      before = m->body_size;

      if (type == SD_BUS_TYPE_ARRAY)
              r = bus_message_open_array(m, c, contents, &array_size, &begin, &need_offsets);
      else if (type == SD_BUS_TYPE_VARIANT)
              r = bus_message_open_variant(m, c, contents);
      else if (type == SD_BUS_TYPE_STRUCT)
              r = bus_message_open_struct(m, c, contents, &begin, &need_offsets);
      else if (type == SD_BUS_TYPE_DICT_ENTRY)
              r = bus_message_open_dict_entry(m, c, contents, &begin, &need_offsets);
      else
              r = -EINVAL22;
      if (r < 0)
              return r;

      /* OK, let's fill it in */
      m->containers[m->n_containers++] = (struct bus_container) {
              .enclosing = type,
              .signature = TAKE_PTR(signature)({ typeof(signature) _ptr_ = (signature); (signature) = ((void
*)0); _ptr_; }),
              .array_size = array_size,
              .before = before,
              .begin = begin,
              .need_offsets = need_offsets,
      };

      return 0;
2063}

2065static int bus_message_close_array(sd_bus_message *m, struct bus_container *c) {

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2067, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 2068, __PRETTY_FUNCTION__); } while (0);

      if (!BUS_MESSAGE_IS_GVARIANT(m))
              return 0;

      if (c->need_offsets) {
              size_t payload, sz, i;
              uint8_t *a;

              /* Variable-width arrays */

              payload = c->n_offsets > 0 ? c->offsets[c->n_offsets-1] - c->begin : 0;
              sz = bus_gvariant_determine_word_size(payload, c->n_offsets);

              a = message_extend_body(m, 1, sz * c->n_offsets, true1, false0);
              if (!a)
                      return -ENOMEM12;

              for (i = 0; i < c->n_offsets; i++)
                      bus_gvariant_write_word_le(a + sz*i, sz, c->offsets[i] - c->begin);
      } else {
              void *a;

              /* Fixed-width or empty arrays */

              a = message_extend_body(m, 1, 0, true1, false0); /* let's add offset to parent */
              if (!a)
                      return -ENOMEM12;
      }

      return 0;
2099}

2101static int bus_message_close_variant(sd_bus_message *m, struct bus_container *c) {
      uint8_t *a;
      size_t l;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2105, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 2106, __PRETTY_FUNCTION__); } while (0);
      assert(c->signature)do { if ((__builtin_expect(!!(!(c->signature)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c->signature"), "../src/libsystemd/sd-bus/bus-message.c"
, 2107, __PRETTY_FUNCTION__); } while (0);

      if (!BUS_MESSAGE_IS_GVARIANT(m))
              return 0;

      l = strlen(c->signature);

      a = message_extend_body(m, 1, 1 + l, true1, false0);
      if (!a)
              return -ENOMEM12;

      a[0] = 0;
      memcpy(a+1, c->signature, l);

      return 0;
2122}

2124static int bus_message_close_struct(sd_bus_message *m, struct bus_container *c, bool_Bool add_offset) {
      bool_Bool fixed_size = true1;
      size_t n_variable = 0;
      unsigned i = 0;
      const char *p;
      uint8_t *a;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2132, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 2133, __PRETTY_FUNCTION__); } while (0);

      if (!BUS_MESSAGE_IS_GVARIANT(m))
              return 0;

      p = strempty(c->signature);
      while (*p != 0) {
              size_t n;

              r = signature_element_length(p, &n);
              if (r < 0)
                      return r;
              else {
                      char t[n+1];

                      memcpy(t, p, n);
                      t[n] = 0;

                      r = bus_gvariant_is_fixed_size(t);
                      if (r < 0)
                              return r;
              }

              assert(!c->need_offsets || i <= c->n_offsets)do { if ((__builtin_expect(!!(!(!c->need_offsets || i <=
 c->n_offsets)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!c->need_offsets || i <= c->n_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 2156, __PRETTY_FUNCTION__); } while (0);

              /* We need to add an offset for each item that has a
               * variable size and that is not the last one in the
               * list */
              if (r == 0)
                      fixed_size = false0;
              if (r == 0 && p[n] != 0)
                      n_variable++;

              i++;
              p += n;
      }

      assert(!c->need_offsets || i == c->n_offsets)do { if ((__builtin_expect(!!(!(!c->need_offsets || i == c
->n_offsets)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("!c->need_offsets || i == c->n_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 2170, __PRETTY_FUNCTION__); } while (0);
      assert(c->need_offsets || n_variable == 0)do { if ((__builtin_expect(!!(!(c->need_offsets || n_variable
 == 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("c->need_offsets || n_variable == 0"
), "../src/libsystemd/sd-bus/bus-message.c", 2171, __PRETTY_FUNCTION__
); } while (0);

      if (isempty(c->signature)) {
              /* The unary type is encoded as fixed 1 byte padding */
              a = message_extend_body(m, 1, 1, add_offset, false0);
              if (!a)
                      return -ENOMEM12;

              *a = 0;
      } else if (n_variable <= 0) {
              int alignment = 1;

              /* Structures with fixed-size members only have to be
               * fixed-size themselves. But gvariant requires all fixed-size
               * elements to be sized a multiple of their alignment. Hence,
               * we must *always* add final padding after the last member so
               * the overall size of the structure is properly aligned. */
              if (fixed_size)
                      alignment = bus_gvariant_get_alignment(strempty(c->signature));

              assert(alignment > 0)do { if ((__builtin_expect(!!(!(alignment > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("alignment > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2191, __PRETTY_FUNCTION__); } while (0);

              a = message_extend_body(m, alignment, 0, add_offset, false0);
              if (!a)
                      return -ENOMEM12;
      } else {
              size_t sz;
              unsigned j;

              assert(c->offsets[c->n_offsets-1] == m->body_size)do { if ((__builtin_expect(!!(!(c->offsets[c->n_offsets
-1] == m->body_size)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("c->offsets[c->n_offsets-1] == m->body_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 2200, __PRETTY_FUNCTION__); } while (0);

              sz = bus_gvariant_determine_word_size(m->body_size - c->begin, n_variable);

              a = message_extend_body(m, 1, sz * n_variable, add_offset, false0);
              if (!a)
                      return -ENOMEM12;

              p = strempty(c->signature);
              for (i = 0, j = 0; i < c->n_offsets; i++) {
                      unsigned k;
                      size_t n;

                      r = signature_element_length(p, &n);
                      if (r < 0)
                              return r;
                      else {
                              char t[n+1];

                              memcpy(t, p, n);
                              t[n] = 0;

                              p += n;

                              r = bus_gvariant_is_fixed_size(t);
                              if (r < 0)
                                      return r;
                              if (r > 0 || p[0] == 0)
                                      continue;
                      }

                      k = n_variable - 1 - j;

                      bus_gvariant_write_word_le(a + k * sz, sz, c->offsets[i] - c->begin);

                      j++;
              }
      }

      return 0;
2240}

2242_public___attribute__ ((visibility("default"))) int sd_bus_message_close_container(sd_bus_message *m) {
      struct bus_container *c;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2246, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2247, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(m->n_containers > 0, -EINVAL)do { if (!(((__builtin_expect(!!(m->n_containers > 0),1
))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("m->n_containers > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2248, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2249, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      c = message_get_last_container(m);

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              if (c->signature && c->signature[c->index] != 0)
                      return -EINVAL22;

      m->n_containers--;

      if (c->enclosing == SD_BUS_TYPE_ARRAY)
              r = bus_message_close_array(m, c);
      else if (c->enclosing == SD_BUS_TYPE_VARIANT)
              r = bus_message_close_variant(m, c);
      else if (IN_SET(c->enclosing, SD_BUS_TYPE_STRUCT, SD_BUS_TYPE_DICT_ENTRY)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRUCT, SD_BUS_TYPE_DICT_ENTRY
})/sizeof(int)]; switch(c->enclosing) { case SD_BUS_TYPE_STRUCT
: case SD_BUS_TYPE_DICT_ENTRY: _found = 1; break; default: break
; } _found; }))
              r = bus_message_close_struct(m, c, true1);
      else
              assert_not_reached("Unknown container type")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unknown container type"), "../src/libsystemd/sd-bus/bus-message.c"
, 2266, __PRETTY_FUNCTION__); } while (0);

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

      return r;
2272}

2274typedef struct {
      const char *types;
      unsigned n_struct;
      unsigned n_array;
2278} TypeStack;

2280static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) {
      assert(stack)do { if ((__builtin_expect(!!(!(stack)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("stack"), "../src/libsystemd/sd-bus/bus-message.c"
, 2281, __PRETTY_FUNCTION__); } while (0);
      assert(max > 0)do { if ((__builtin_expect(!!(!(max > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("max > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2282, __PRETTY_FUNCTION__); } while (0);

      if (*i >= max)
              return -EINVAL22;

      stack[*i].types = types;
      stack[*i].n_struct = n_struct;
      stack[*i].n_array = n_array;
      (*i)++;

      return 0;
2293}

2295static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) {
      assert(stack)do { if ((__builtin_expect(!!(!(stack)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("stack"), "../src/libsystemd/sd-bus/bus-message.c"
, 2296, __PRETTY_FUNCTION__); } while (0);
      assert(max > 0)do { if ((__builtin_expect(!!(!(max > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("max > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2297, __PRETTY_FUNCTION__); } while (0);
      assert(types)do { if ((__builtin_expect(!!(!(types)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("types"), "../src/libsystemd/sd-bus/bus-message.c"
, 2298, __PRETTY_FUNCTION__); } while (0);
      assert(n_struct)do { if ((__builtin_expect(!!(!(n_struct)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_struct"), "../src/libsystemd/sd-bus/bus-message.c"
, 2299, __PRETTY_FUNCTION__); } while (0);
      assert(n_array)do { if ((__builtin_expect(!!(!(n_array)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_array"), "../src/libsystemd/sd-bus/bus-message.c"
, 2300, __PRETTY_FUNCTION__); } while (0);

      if (*i <= 0)
              return 0;

      (*i)--;
      *types = stack[*i].types;
      *n_struct = stack[*i].n_struct;
      *n_array = stack[*i].n_array;

      return 1;
2311}

2313_public___attribute__ ((visibility("default"))) int sd_bus_message_appendv(
              sd_bus_message *m,
              const char *types,
              va_list ap) {

      unsigned n_array, n_struct;
      TypeStack stack[BUS_CONTAINER_DEPTH128];
      unsigned stack_ptr = 0;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2323, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(types, -EINVAL)do { if (!(((__builtin_expect(!!(types),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("types"), "../src/libsystemd/sd-bus/bus-message.c"
, 2324, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2325, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2326, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      n_array = (unsigned) -1;
      n_struct = strlen(types);

      for (;;) {
              const char *t;

              if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
                      r = type_stack_pop(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, &types, &n_struct, &n_array);
                      if (r < 0)
                              return r;
                      if (r == 0)
                              break;

                      r = sd_bus_message_close_container(m);
                      if (r < 0)
                              return r;

                      continue;
              }

              t = types;
              if (n_array != (unsigned) -1)
                      n_array--;
              else {
                      types++;
                      n_struct--;
              }

              switch (*t) {

              case SD_BUS_TYPE_BYTE: {
                      uint8_t x;

                      x = (uint8_t) va_arg(ap, int)__builtin_va_arg(ap, int);
                      r = sd_bus_message_append_basic(m, *t, &x);
                      break;
              }

              case SD_BUS_TYPE_BOOLEAN:
              case SD_BUS_TYPE_INT32:
              case SD_BUS_TYPE_UINT32:
              case SD_BUS_TYPE_UNIX_FD: {
                      uint32_t x;

                      /* We assume a boolean is the same as int32_t */
                      assert_cc(sizeof(int32_t) == sizeof(int))GCC diagnostic push
; GCC diagnostic ignored "-Wdeclaration-after-statement"

; struct _assert_struct_11 { char x[(sizeof(int32_t) == sizeof
(int)) ? 0 : -1]; }; GCC diagnostic pop
;

                      x = va_arg(ap, uint32_t)__builtin_va_arg(ap, uint32_t);
                      r = sd_bus_message_append_basic(m, *t, &x);
                      break;
              }

              case SD_BUS_TYPE_INT16:
              case SD_BUS_TYPE_UINT16: {
                      uint16_t x;

                      x = (uint16_t) va_arg(ap, int)__builtin_va_arg(ap, int);
                      r = sd_bus_message_append_basic(m, *t, &x);
                      break;
              }

              case SD_BUS_TYPE_INT64:
              case SD_BUS_TYPE_UINT64: {
                      uint64_t x;

                      x = va_arg(ap, uint64_t)__builtin_va_arg(ap, uint64_t);
                      r = sd_bus_message_append_basic(m, *t, &x);
                      break;
              }

              case SD_BUS_TYPE_DOUBLE: {
                      double x;

                      x = va_arg(ap, double)__builtin_va_arg(ap, double);
                      r = sd_bus_message_append_basic(m, *t, &x);
                      break;
              }

              case SD_BUS_TYPE_STRING:
              case SD_BUS_TYPE_OBJECT_PATH:
              case SD_BUS_TYPE_SIGNATURE: {
                      const char *x;

                      x = va_arg(ap, const char*)__builtin_va_arg(ap, const char*);
                      r = sd_bus_message_append_basic(m, *t, x);
                      break;
              }

              case SD_BUS_TYPE_ARRAY: {
                      size_t k;

                      r = signature_element_length(t + 1, &k);
                      if (r < 0)
                              return r;

                      {
                              char s[k + 1];
                              memcpy(s, t + 1, k);
                              s[k] = 0;

                              r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
                              if (r < 0)
                                      return r;
                      }

                      if (n_array == (unsigned) -1) {
                              types += k;
                              n_struct -= k;
                      }

                      r = type_stack_push(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, types, n_struct, n_array);
                      if (r < 0)
                              return r;

                      types = t + 1;
                      n_struct = k;
                      n_array = va_arg(ap, unsigned)__builtin_va_arg(ap, unsigned);

                      break;
              }

              case SD_BUS_TYPE_VARIANT: {
                      const char *s;

                      s = va_arg(ap, const char*)__builtin_va_arg(ap, const char*);
                      if (!s)
                              return -EINVAL22;

                      r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s);
                      if (r < 0)
                              return r;

                      r = type_stack_push(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, types, n_struct, n_array);
                      if (r < 0)
                              return r;

                      types = s;
                      n_struct = strlen(s);
                      n_array = (unsigned) -1;

                      break;
              }

              case SD_BUS_TYPE_STRUCT_BEGIN:
              case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                      size_t k;

                      r = signature_element_length(t, &k);
                      if (r < 0)
                              return r;

                      {
                              char s[k - 1];

                              memcpy(s, t + 1, k - 2);
                              s[k - 2] = 0;

                              r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
                              if (r < 0)
                                      return r;
                      }

                      if (n_array == (unsigned) -1) {
                              types += k - 1;
                              n_struct -= k - 1;
                      }

                      r = type_stack_push(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, types, n_struct, n_array);
                      if (r < 0)
                              return r;

                      types = t + 1;
                      n_struct = k - 2;
                      n_array = (unsigned) -1;

                      break;
              }

              default:
                      r = -EINVAL22;
              }

              if (r < 0)
                      return r;
      }

      return 1;
2515}

2517_public___attribute__ ((visibility("default"))) int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
      va_list ap;
      int r;

      va_start(ap, types)__builtin_va_start(ap, types);
      r = sd_bus_message_appendv(m, types, ap);
      va_end(ap)__builtin_va_end(ap);

      return r;
2526}

2528_public___attribute__ ((visibility("default"))) 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;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2538, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2539, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN, -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_trivial(type) &&
 type != SD_BUS_TYPE_BOOLEAN),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN"
), "../src/libsystemd/sd-bus/bus-message.c", 2540, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(ptr || size == 0, -EINVAL)do { if (!(((__builtin_expect(!!(ptr || size == 0),1))) ? (1)
 : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("ptr || size == 0"
), "../src/libsystemd/sd-bus/bus-message.c", 2541, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2542, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      /* alignment and size of the trivial types (except bool) is
       * identical for gvariant and dbus1 marshalling */
      align = bus_type_get_alignment(type);
      sz = bus_type_get_size(type);

      assert_se(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2549, __PRETTY_FUNCTION__); } while (0);
      assert_se(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2550, __PRETTY_FUNCTION__); } while (0);

      if (size % sz != 0)
              return -EINVAL22;

      r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)((char[2]) { type, 0 }));
      if (r < 0)
              return r;

      a = message_extend_body(m, align, size, false0, false0);
      if (!a)
              return -ENOMEM12;

      r = sd_bus_message_close_container(m);
      if (r < 0)
              return r;

      *ptr = a;
      return 0;
2569}

2571_public___attribute__ ((visibility("default"))) int sd_bus_message_append_array(
              sd_bus_message *m,
              char type,
              const void *ptr,
              size_t size) {
      int r;
      void *p;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2579, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2580, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(bus_type_is_trivial(type), -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_trivial(type)),1
))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus_type_is_trivial(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 2581, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(ptr || size == 0, -EINVAL)do { if (!(((__builtin_expect(!!(ptr || size == 0),1))) ? (1)
 : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("ptr || size == 0"
), "../src/libsystemd/sd-bus/bus-message.c", 2582, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2583, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      r = sd_bus_message_append_array_space(m, type, size, &p);
      if (r < 0)
              return r;

      memcpy_safe(p, ptr, size);

      return 0;
2592}

2594_public___attribute__ ((visibility("default"))) int sd_bus_message_append_array_iovec(
              sd_bus_message *m,
              char type,
              const struct iovec *iov,
              unsigned n /* should be size_t, but is API now… 😞 */) {

      size_t size;
      unsigned i;
      void *p;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2605, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2606, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(bus_type_is_trivial(type), -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_trivial(type)),1
))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus_type_is_trivial(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 2607, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(iov || n == 0, -EINVAL)do { if (!(((__builtin_expect(!!(iov || n == 0),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("iov || n == 0"
), "../src/libsystemd/sd-bus/bus-message.c", 2608, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2609, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      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
                      memzero(p, iov[i].iov_len)({ size_t _l_ = (iov[i].iov_len); void *_x_ = (p); _l_ == 0 ?
 _x_ : memset(_x_, 0, _l_); });

              p = (uint8_t*) p + iov[i].iov_len;
      }

      return 0;
2628}

2630_public___attribute__ ((visibility("default"))) int sd_bus_message_append_array_memfd(
              sd_bus_message *m,
              char type,
              int memfd,
              uint64_t offset,
              uint64_t size) {

      _cleanup_close___attribute__((cleanup(closep))) int copy_fd = -1;
      struct bus_body_part *part;
      ssize_t align, sz;
      uint64_t real_size;
      void *a;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2644, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(memfd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(memfd >= 0),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("memfd >= 0"
), "../src/libsystemd/sd-bus/bus-message.c", 2645, __PRETTY_FUNCTION__
), 0))) return (-9); } while (0);
      assert_return(bus_type_is_trivial(type), -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_trivial(type)),1
))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus_type_is_trivial(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 2646, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(size > 0, -EINVAL)do { if (!(((__builtin_expect(!!(size > 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("size > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2647, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2648, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2649, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      r = memfd_set_sealed(memfd);
      if (r < 0)
              return r;

      copy_fd = fcntl(memfd, F_DUPFD_CLOEXEC1030, 3);
      if (copy_fd < 0)
              return copy_fd;

      r = memfd_get_size(memfd, &real_size);
      if (r < 0)
              return r;

      if (offset == 0 && size == (uint64_t) -1)
              size = real_size;
      else if (offset + size > real_size)
              return -EMSGSIZE90;

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

      assert_se(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2671, __PRETTY_FUNCTION__); } while (0);
      assert_se(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2672, __PRETTY_FUNCTION__); } while (0);

      if (offset % align != 0)
              return -EINVAL22;

      if (size % sz != 0)
              return -EINVAL22;

      if (size > (uint64_t) (uint32_t) -1)
              return -EINVAL22;

      r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)((char[2]) { type, 0 }));
      if (r < 0)
              return r;

      a = message_extend_body(m, align, 0, false0, false0);
      if (!a)
              return -ENOMEM12;

      part = message_append_part(m);
      if (!part)
              return -ENOMEM12;

      part->memfd = copy_fd;
      part->memfd_offset = offset;
      part->sealed = true1;
      part->size = size;
      copy_fd = -1;

      m->body_size += size;
      message_extend_containers(m, size);

      return sd_bus_message_close_container(m);
2705}

2707_public___attribute__ ((visibility("default"))) int sd_bus_message_append_string_memfd(
              sd_bus_message *m,
              int memfd,
              uint64_t offset,
              uint64_t size) {

      _cleanup_close___attribute__((cleanup(closep))) int copy_fd = -1;
      struct bus_body_part *part;
      struct bus_container *c;
      uint64_t real_size;
      void *a;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2720, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(memfd >= 0, -EBADF)do { if (!(((__builtin_expect(!!(memfd >= 0),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("memfd >= 0"
), "../src/libsystemd/sd-bus/bus-message.c", 2721, __PRETTY_FUNCTION__
), 0))) return (-9); } while (0);
      assert_return(size > 0, -EINVAL)do { if (!(((__builtin_expect(!!(size > 0),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("size > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 2722, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2723, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2724, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      r = memfd_set_sealed(memfd);
      if (r < 0)
              return r;

      copy_fd = fcntl(memfd, FD_CLOEXEC1, 3);
      if (copy_fd < 0)
              return copy_fd;

      r = memfd_get_size(memfd, &real_size);
      if (r < 0)
              return r;

      if (offset == 0 && size == (uint64_t) -1)
              size = real_size;
      else if (offset + size > real_size)
              return -EMSGSIZE90;

      /* We require this to be NUL terminated */
      if (size == 0)
              return -EINVAL22;

      if (size > (uint64_t) (uint32_t) -1)
              return -EINVAL22;

      c = message_get_last_container(m);
      if (c->signature && c->signature[c->index]) {
              /* Container signature is already set */

              if (c->signature[c->index] != SD_BUS_TYPE_STRING)
                      return -ENXIO6;
      } else {
              char *e;

              /* Maybe we can append to the signature? But only if this is the top-level container */
              if (c->enclosing != 0)
                      return -ENXIO6;

              e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL)strextend_with_separator(&c->signature, ((void*)0), ((
char[2]) { SD_BUS_TYPE_STRING, 0 }), ((void*)0));
              if (!e) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }
      }

      if (!BUS_MESSAGE_IS_GVARIANT(m)) {
              a = message_extend_body(m, 4, 4, false0, false0);
              if (!a)
                      return -ENOMEM12;

              *(uint32_t*) a = size - 1;
      }

      part = message_append_part(m);
      if (!part)
              return -ENOMEM12;

      part->memfd = copy_fd;
      part->memfd_offset = offset;
      part->sealed = true1;
      part->size = size;
      copy_fd = -1;

      m->body_size += size;
      message_extend_containers(m, size);

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              r = message_add_offset(m, m->body_size);
              if (r < 0) {
                      m->poisoned = true1;
                      return -ENOMEM12;
              }
      }

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index++;

      return 0;
2803}

2805_public___attribute__ ((visibility("default"))) int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
      char **i;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2809, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 2810, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->poisoned, -ESTALE)do { if (!(((__builtin_expect(!!(!m->poisoned),1))) ? (1) :
 (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->poisoned"
), "../src/libsystemd/sd-bus/bus-message.c", 2811, __PRETTY_FUNCTION__
), 0))) return (-116); } while (0);

      r = sd_bus_message_open_container(m, 'a', "s");
      if (r < 0)
              return r;

      STRV_FOREACH(i, l)for ((i) = (l); (i) && *(i); (i)++) {
              r = sd_bus_message_append_basic(m, 's', *i);
              if (r < 0)
                      return r;
      }

      return sd_bus_message_close_container(m);
2824}

2826static int bus_message_close_header(sd_bus_message *m) {

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2828, __PRETTY_FUNCTION__); } while (0);

      /* The actual user data is finished now, we just complete the
         variant and struct now (at least on gvariant). Remember
         this position, so that during parsing we know where to
         put the outer container end. */
      m->user_body_size = m->body_size;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              const char *signature;
              size_t sz, l;
              void *d;

              /* Add offset table to end of fields array */
              if (m->n_header_offsets >= 1) {
                      uint8_t *a;
                      unsigned i;

                      assert(m->fields_size == m->header_offsets[m->n_header_offsets-1])do { if ((__builtin_expect(!!(!(m->fields_size == m->header_offsets
[m->n_header_offsets-1])),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("m->fields_size == m->header_offsets[m->n_header_offsets-1]"
), "../src/libsystemd/sd-bus/bus-message.c", 2846, __PRETTY_FUNCTION__
); } while (0);

                      sz = bus_gvariant_determine_word_size(m->fields_size, m->n_header_offsets);
                      a = message_extend_fields(m, 1, sz * m->n_header_offsets, false0);
                      if (!a)
                              return -ENOMEM12;

                      for (i = 0; i < m->n_header_offsets; i++)
                              bus_gvariant_write_word_le(a + sz*i, sz, m->header_offsets[i]);
              }

              /* Add gvariant NUL byte plus signature to the end of
               * the body, followed by the final offset pointing to
               * the end of the fields array */

              signature = strempty(m->root_container.signature);
              l = strlen(signature);

              sz = bus_gvariant_determine_word_size(sizeof(struct bus_header) + ALIGN8(m->fields_size)(((m->fields_size) + 7) & ~7) + m->body_size + 1 + l + 2, 1);
              d = message_extend_body(m, 1, 1 + l + 2 + sz, false0, true1);
              if (!d)
                      return -ENOMEM12;

              *(uint8_t*) d = 0;
              *((uint8_t*) d + 1) = SD_BUS_TYPE_STRUCT_BEGIN;
              memcpy((uint8_t*) d + 2, signature, l);
              *((uint8_t*) d + 1 + l + 1) = SD_BUS_TYPE_STRUCT_END;

              bus_gvariant_write_word_le((uint8_t*) d + 1 + l + 2, sz, sizeof(struct bus_header) + m->fields_size);

              m->footer = d;
              m->footer_accessible = 1 + l + 2 + sz;
      } else {
              m->header->dbus1.fields_size = m->fields_size;
              m->header->dbus1.body_size = m->body_size;
      }

      return 0;
2884}

2886_public___attribute__ ((visibility("default"))) int sd_bus_message_seal(sd_bus_message *m, uint64_t cookie, uint64_t timeout_usec) {
      struct bus_body_part *part;
      size_t a;
      unsigned i;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 2892, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (m->sealed)
              return -EPERM1;

      if (m->n_containers > 0)
              return -EBADMSG74;

      if (m->poisoned)
              return -ESTALE116;

      if (cookie > 0xffffffffULL &&
          !BUS_MESSAGE_IS_GVARIANT(m))
              return -EOPNOTSUPP95;

      /* In vtables the return signature of method calls is listed,
       * let's check if they match if this is a response */
      if (m->header->type == SD_BUS_MESSAGE_METHOD_RETURN &&
          m->enforced_reply_signature &&
          !streq(strempty(m->root_container.signature), m->enforced_reply_signature)(strcmp((strempty(m->root_container.signature)),(m->enforced_reply_signature
)) == 0))
              return -ENOMSG42;

      /* If gvariant marshalling is used we need to close the body structure */
      r = bus_message_close_struct(m, &m->root_container, false0);
      if (r < 0)
              return r;

      /* If there's a non-trivial signature set, then add it in
       * here, but only on dbus1 */
      if (!isempty(m->root_container.signature) && !BUS_MESSAGE_IS_GVARIANT(m)) {
              r = message_append_field_signature(m, BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL((void*)0));
              if (r < 0)
                      return r;
      }

      if (m->n_fds > 0) {
              r = message_append_field_uint32(m, BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds);
              if (r < 0)
                      return r;
      }

      r = bus_message_close_header(m);
      if (r < 0)
              return r;

      if (BUS_MESSAGE_IS_GVARIANT(m))
              m->header->dbus2.cookie = cookie;
      else
              m->header->dbus1.serial = (uint32_t) cookie;

      m->timeout = m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED ? 0 : timeout_usec;

      /* Add padding at the end of the fields part, since we know
       * the body needs to start at an 8 byte alignment. We made
       * sure we allocated enough space for this, so all we need to
       * do here is to zero it out. */
      a = ALIGN8(m->fields_size)(((m->fields_size) + 7) & ~7) - m->fields_size;
      if (a > 0)
              memzero((uint8_t*) BUS_MESSAGE_FIELDS(m) + m->fields_size, a)({ size_t _l_ = (a); void *_x_ = ((uint8_t*) BUS_MESSAGE_FIELDS
(m) + m->fields_size); _l_ == 0 ? _x_ : memset(_x_, 0, _l_
); });

      /* 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
      for directed messages, and not for broadcasts. */
      if (m->destination && m->bus->use_memfd) {
              MESSAGE_FOREACH_PART(part, i, m)for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts
; (i)++, (part) = (part)->next)
                      if (part->memfd >= 0 &&
                          !part->sealed &&
                          (part->size > MEMFD_MIN_SIZE(512*1024) || m->bus->use_memfd < 0) &&
                          part != m->body_end) { /* The last part may never be sent as memfd */
                              uint64_t sz;

                              /* Try to seal it if that makes
                               * sense. First, unmap our own map to
                               * make sure we don't keep it busy. */
                              bus_body_part_unmap(part);

                              /* Then, sync up real memfd size */
                              sz = part->size;
                              r = memfd_set_size(part->memfd, sz);
                              if (r < 0)
                                      return r;

                              /* Finally, try to seal */
                              if (memfd_set_sealed(part->memfd) >= 0)
                                      part->sealed = true1;
                      }
      }

      m->root_container.end = m->user_body_size;
      m->root_container.index = 0;
      m->root_container.offset_index = 0;
      m->root_container.item_size = m->root_container.n_offsets > 0 ? m->root_container.offsets[0] : 0;

      m->sealed = true1;

      return 0;
2988}

2990int bus_body_part_map(struct bus_body_part *part) {
      void *p;
      size_t psz, shift;

      assert_se(part)do { if ((__builtin_expect(!!(!(part)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("part"), "../src/libsystemd/sd-bus/bus-message.c"
, 2994, __PRETTY_FUNCTION__); } while (0);

      if (part->data)
              return 0;

      if (part->size <= 0)
              return 0;

      /* For smaller zero parts (as used for padding) we don't need to map anything... */
      if (part->memfd < 0 && part->is_zero && part->size < 8) {
              static const uint8_t zeroes[7] = { };
              part->data = (void*) zeroes;
              return 0;
      }

      shift = part->memfd_offset - ((part->memfd_offset / page_size()) * page_size());
      psz = PAGE_ALIGN(part->size + shift)ALIGN_TO((part->size + shift), page_size());

      if (part->memfd >= 0)
              p = mmap(NULL((void*)0), psz, PROT_READ0x1, MAP_PRIVATE0x02, part->memfd, part->memfd_offset - shift);
      else if (part->is_zero)
              p = mmap(NULL((void*)0), psz, PROT_READ0x1, MAP_PRIVATE0x02|MAP_ANONYMOUS0x20, -1, 0);
      else
              return -EINVAL22;

      if (p == MAP_FAILED((void *) -1))
              return -errno(*__errno_location ());

      part->mapped = psz;
      part->mmap_begin = p;
      part->data = (uint8_t*) p + shift;
      part->munmap_this = true1;

      return 0;
3028}

3030void bus_body_part_unmap(struct bus_body_part *part) {

      assert_se(part)do { if ((__builtin_expect(!!(!(part)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("part"), "../src/libsystemd/sd-bus/bus-message.c"
, 3032, __PRETTY_FUNCTION__); } while (0);

      if (part->memfd < 0)
              return;

      if (!part->mmap_begin)
              return;

      if (!part->munmap_this)
              return;

      assert_se(munmap(part->mmap_begin, part->mapped) == 0)do { if ((__builtin_expect(!!(!(munmap(part->mmap_begin, part
->mapped) == 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("munmap(part->mmap_begin, part->mapped) == 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3043, __PRETTY_FUNCTION__); } while (0);

      part->mmap_begin = NULL((void*)0);
      part->data = NULL((void*)0);
      part->mapped = 0;
      part->munmap_this = false0;

      return;
3051}

3053static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) {
      size_t k, start, end;

      assert(rindex)do { if ((__builtin_expect(!!(!(rindex)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("rindex"), "../src/libsystemd/sd-bus/bus-message.c"
, 3056, __PRETTY_FUNCTION__); } while (0);
      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3057, __PRETTY_FUNCTION__); } while (0);

      start = ALIGN_TO((size_t) *rindex, align);
      end = start + nbytes;

      if (end > sz)
              return -EBADMSG74;

      /* Verify that padding is 0 */
      for (k = *rindex; k < start; k++)
              if (((const uint8_t*) p)[k] != 0)
                      return -EBADMSG74;

      if (r)
              *r = (uint8_t*) p + start;

      *rindex = end;

      return 1;
3076}

3078static bool_Bool message_end_of_signature(sd_bus_message *m) {
      struct bus_container *c;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3081, __PRETTY_FUNCTION__); } while (0);

      c = message_get_last_container(m);
      return !c->signature || c->signature[c->index] == 0;
3085}

3087static bool_Bool message_end_of_array(sd_bus_message *m, size_t index) {
      struct bus_container *c;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3090, __PRETTY_FUNCTION__); } while (0);

      c = message_get_last_container(m);
      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              return false0;

      if (BUS_MESSAGE_IS_GVARIANT(m))
              return index >= c->end;
      else {
              assert(c->array_size)do { if ((__builtin_expect(!!(!(c->array_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c->array_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3099, __PRETTY_FUNCTION__); } while (0);
              return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
      }
3102}

3104_public___attribute__ ((visibility("default"))) int sd_bus_message_at_end(sd_bus_message *m, int complete) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3105, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 3106, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      if (complete && m->n_containers > 0)
              return false0;

      if (message_end_of_signature(m))
              return true1;

      if (message_end_of_array(m, m->rindex))
              return true1;

      return false0;
3118}

3120static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) {
      struct bus_body_part *part;
      size_t begin;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3125, __PRETTY_FUNCTION__); } while (0);

      if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) {
              part = m->cached_rindex_part;
              begin = m->cached_rindex_part_begin;
      } else {
              part = &m->body;
              begin = 0;
      }

      while (part) {
              if (index < begin)
                      return NULL((void*)0);

              if (index + sz <= begin + part->size) {

                      r = bus_body_part_map(part);
                      if (r < 0)
                              return NULL((void*)0);

                      if (p)
                              *p = (uint8_t*) part->data + index - begin;

                      m->cached_rindex_part = part;
                      m->cached_rindex_part_begin = begin;

                      return part;
              }

              begin += part->size;
              part = part->next;
      }

      return NULL((void*)0);
3159}

3161static int container_next_item(sd_bus_message *m, struct bus_container *c, size_t *rindex) {
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3164, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 3165, __PRETTY_FUNCTION__); } while (0);
      assert(rindex)do { if ((__builtin_expect(!!(!(rindex)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("rindex"), "../src/libsystemd/sd-bus/bus-message.c"
, 3166, __PRETTY_FUNCTION__); } while (0);

      if (!BUS_MESSAGE_IS_GVARIANT(m))
              return 0;

      if (c->enclosing == SD_BUS_TYPE_ARRAY) {
              int sz;

              sz = bus_gvariant_get_size(c->signature);
              if (sz < 0) {
                      int alignment;

                      if (c->offset_index+1 >= c->n_offsets)
                              goto end;

                      /* Variable-size array */

                      alignment = bus_gvariant_get_alignment(c->signature);
                      assert(alignment > 0)do { if ((__builtin_expect(!!(!(alignment > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("alignment > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3184, __PRETTY_FUNCTION__); } while (0);

                      *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment);
                      assert(c->offsets[c->offset_index+1] >= *rindex)do { if ((__builtin_expect(!!(!(c->offsets[c->offset_index
+1] >= *rindex)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("c->offsets[c->offset_index+1] >= *rindex"), "../src/libsystemd/sd-bus/bus-message.c"
, 3187, __PRETTY_FUNCTION__); } while (0);
                      c->item_size = c->offsets[c->offset_index+1] - *rindex;
              } else {

                      if (c->offset_index+1 >= (c->end-c->begin)/sz)
                              goto end;

                      /* Fixed-size array */
                      *rindex = c->begin + (c->offset_index+1) * sz;
                      c->item_size = sz;
              }

              c->offset_index++;

      } else if (IN_SET(c->enclosing, 0, SD_BUS_TYPE_STRUCT, SD_BUS_TYPE_DICT_ENTRY)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){0, SD_BUS_TYPE_STRUCT, SD_BUS_TYPE_DICT_ENTRY
})/sizeof(int)]; switch(c->enclosing) { case 0: case SD_BUS_TYPE_STRUCT
: case SD_BUS_TYPE_DICT_ENTRY: _found = 1; break; default: break
; } _found; })) {

              int alignment;
              size_t n, j;

              if (c->offset_index+1 >= c->n_offsets)
                      goto end;

              r = signature_element_length(c->signature + c->index, &n);
              if (r < 0)
                      return r;

              r = signature_element_length(c->signature + c->index + n, &j);
              if (r < 0)
                      return r;
              else {
                      char t[j+1];
                      memcpy(t, c->signature + c->index + n, j);
                      t[j] = 0;

                      alignment = bus_gvariant_get_alignment(t);
              }

              assert(alignment > 0)do { if ((__builtin_expect(!!(!(alignment > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("alignment > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3224, __PRETTY_FUNCTION__); } while (0);

              *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment);
              assert(c->offsets[c->offset_index+1] >= *rindex)do { if ((__builtin_expect(!!(!(c->offsets[c->offset_index
+1] >= *rindex)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("c->offsets[c->offset_index+1] >= *rindex"), "../src/libsystemd/sd-bus/bus-message.c"
, 3227, __PRETTY_FUNCTION__); } while (0);
              c->item_size = c->offsets[c->offset_index+1] - *rindex;

              c->offset_index++;

      } else if (c->enclosing == SD_BUS_TYPE_VARIANT)
              goto end;
      else
              assert_not_reached("Unknown container type")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unknown container type"), "../src/libsystemd/sd-bus/bus-message.c"
, 3235, __PRETTY_FUNCTION__); } while (0);

      return 0;

3239end:
      /* Reached the end */
      *rindex = c->end;
      c->item_size = 0;
      return 0;
3244}

3246static int message_peek_body(
              sd_bus_message *m,
              size_t *rindex,
              size_t align,
              size_t nbytes,
              void **ret) {

      size_t k, start, end, padding;
      struct bus_body_part *part;
      uint8_t *q;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3257, __PRETTY_FUNCTION__); } while (0);
      assert(rindex)do { if ((__builtin_expect(!!(!(rindex)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("rindex"), "../src/libsystemd/sd-bus/bus-message.c"
, 3258, __PRETTY_FUNCTION__); } while (0);
      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3259, __PRETTY_FUNCTION__); } while (0);

      start = ALIGN_TO((size_t) *rindex, align);
      padding = start - *rindex;
      end = start + nbytes;

      if (end > m->user_body_size)
              return -EBADMSG74;

      part = find_part(m, *rindex, padding, (void**) &q);
      if (!part)
              return -EBADMSG74;

      if (q) {
              /* Verify padding */
              for (k = 0; k < padding; k++)
                      if (q[k] != 0)
                              return -EBADMSG74;
      }

      part = find_part(m, start, nbytes, (void**) &q);
      if (!part || (nbytes > 0 && !q))
              return -EBADMSG74;

      *rindex = end;

      if (ret)
              *ret = q;

      return 0;
3289}

3291static bool_Bool validate_nul(const char *s, size_t l) {

      /* Check for NUL chars in the string */
      if (memchr(s, 0, l))
              return false0;

      /* Check for NUL termination */
      if (s[l] != 0)
              return false0;

      return true1;
3302}

3304static bool_Bool validate_string(const char *s, size_t l) {

      if (!validate_nul(s, l))
              return false0;

      /* Check if valid UTF8 */
      if (!utf8_is_valid(s))
              return false0;

      return true1;
3314}

3316static bool_Bool validate_signature(const char *s, size_t l) {

      if (!validate_nul(s, l))
              return false0;

      /* Check if valid signature */
      if (!signature_is_valid(s, true1))
              return false0;

      return true1;
3326}

3328static bool_Bool validate_object_path(const char *s, size_t l) {

      if (!validate_nul(s, l))
              return false0;

      if (!object_path_is_valid(s))
              return false0;

      return true1;
3337}

3339_public___attribute__ ((visibility("default"))) int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
      struct bus_container *c;
      size_t rindex;
      void *q;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3345, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 3346, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(bus_type_is_basic(type), -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_basic(type)),1))
) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, (
"bus_type_is_basic(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 3347, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (message_end_of_signature(m))
              return -ENXIO6;

      if (message_end_of_array(m, m->rindex))
              return 0;

      c = message_get_last_container(m);
      if (c->signature[c->index] != type)
              return -ENXIO6;

      rindex = m->rindex;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {

              if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH
, SD_BUS_TYPE_SIGNATURE})/sizeof(int)]; switch(type) { case SD_BUS_TYPE_STRING
: case SD_BUS_TYPE_OBJECT_PATH: case SD_BUS_TYPE_SIGNATURE: _found
 = 1; break; default: break; } _found; })) {
                      bool_Bool ok;

                      /* D-Bus spec: The marshalling formats for the string-like types all end
                       * with a single zero (NUL) byte, but that byte is not considered to be part
                       * of the text. */
                      if (c->item_size == 0)
                              return -EBADMSG74;

                      r = message_peek_body(m, &rindex, 1, c->item_size, &q);
                      if (r < 0)
                              return r;

                      if (type == SD_BUS_TYPE_STRING)
                              ok = validate_string(q, c->item_size-1);
                      else if (type == SD_BUS_TYPE_OBJECT_PATH)
                              ok = validate_object_path(q, c->item_size-1);
                      else
                              ok = validate_signature(q, c->item_size-1);

                      if (!ok)
                              return -EBADMSG74;

                      if (p)
                              *(const char**) p = q;
              } else {
                      int sz, align;

                      sz = bus_gvariant_get_size(CHAR_TO_STR(type)((char[2]) { type, 0 }));
                      assert(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3392, __PRETTY_FUNCTION__); } while (0);
                      if ((size_t) sz != c->item_size)
                              return -EBADMSG74;

                      align = bus_gvariant_get_alignment(CHAR_TO_STR(type)((char[2]) { type, 0 }));
                      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3397, __PRETTY_FUNCTION__); } while (0);

                      r = message_peek_body(m, &rindex, align, c->item_size, &q);
                      if (r < 0)
                              return r;

                      switch (type) {

                      case SD_BUS_TYPE_BYTE:
                              if (p)
                                      *(uint8_t*) p = *(uint8_t*) q;
                              break;

                      case SD_BUS_TYPE_BOOLEAN:
                              if (p)
                                      *(int*) p = !!*(uint8_t*) q;
                              break;

                      case SD_BUS_TYPE_INT16:
                      case SD_BUS_TYPE_UINT16:
                              if (p)
                                      *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
                              break;

                      case SD_BUS_TYPE_INT32:
                      case SD_BUS_TYPE_UINT32:
                              if (p)
                                      *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                              break;

                      case SD_BUS_TYPE_INT64:
                      case SD_BUS_TYPE_UINT64:
                      case SD_BUS_TYPE_DOUBLE:
                              if (p)
                                      *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
                              break;

                      case SD_BUS_TYPE_UNIX_FD: {
                              uint32_t j;

                              j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                              if (j >= m->n_fds)
                                      return -EBADMSG74;

                              if (p)
                                      *(int*) p = m->fds[j];

                              break;
                      }

                      default:
                              assert_not_reached("unexpected type")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"unexpected type"), "../src/libsystemd/sd-bus/bus-message.c",
 3448, __PRETTY_FUNCTION__); } while (0);
                      }
              }

              r = container_next_item(m, c, &rindex);
              if (r < 0)
                      return r;
      } else {

              if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH
})/sizeof(int)]; switch(type) { case SD_BUS_TYPE_STRING: case
 SD_BUS_TYPE_OBJECT_PATH: _found = 1; break; default: break; }
 _found; })) {
                      uint32_t l;
                      bool_Bool ok;

                      r = message_peek_body(m, &rindex, 4, 4, &q);
                      if (r < 0)
                              return r;

                      l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                      if (l == UINT32_MAX(4294967295U))
                              /* avoid overflow right below */
                              return -EBADMSG74;

                      r = message_peek_body(m, &rindex, 1, l+1, &q);
                      if (r < 0)
                              return r;

                      if (type == SD_BUS_TYPE_OBJECT_PATH)
                              ok = validate_object_path(q, l);
                      else
                              ok = validate_string(q, l);
                      if (!ok)
                              return -EBADMSG74;

                      if (p)
                              *(const char**) p = q;

              } else if (type == SD_BUS_TYPE_SIGNATURE) {
                      uint8_t l;

                      r = message_peek_body(m, &rindex, 1, 1, &q);
                      if (r < 0)
                              return r;

                      l = *(uint8_t*) q;
                      if (l == UINT8_MAX(255))
                              /* avoid overflow right below */
                              return -EBADMSG74;

                      r = message_peek_body(m, &rindex, 1, l+1, &q);
                      if (r < 0)
                              return r;

                      if (!validate_signature(q, l))
                              return -EBADMSG74;

                      if (p)
                              *(const char**) p = q;

              } else {
                      ssize_t sz, align;

                      align = bus_type_get_alignment(type);
                      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3510, __PRETTY_FUNCTION__); } while (0);

                      sz = bus_type_get_size(type);
                      assert(sz > 0)do { if ((__builtin_expect(!!(!(sz > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3513, __PRETTY_FUNCTION__); } while (0);

                      r = message_peek_body(m, &rindex, align, sz, &q);
                      if (r < 0)
                              return r;

                      switch (type) {

                      case SD_BUS_TYPE_BYTE:
                              if (p)
                                      *(uint8_t*) p = *(uint8_t*) q;
                              break;

                      case SD_BUS_TYPE_BOOLEAN:
                              if (p)
                                      *(int*) p = !!*(uint32_t*) q;
                              break;

                      case SD_BUS_TYPE_INT16:
                      case SD_BUS_TYPE_UINT16:
                              if (p)
                                      *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
                              break;

                      case SD_BUS_TYPE_INT32:
                      case SD_BUS_TYPE_UINT32:
                              if (p)
                                      *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                              break;

                      case SD_BUS_TYPE_INT64:
                      case SD_BUS_TYPE_UINT64:
                      case SD_BUS_TYPE_DOUBLE:
                              if (p)
                                      *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
                              break;

                      case SD_BUS_TYPE_UNIX_FD: {
                              uint32_t j;

                              j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
                              if (j >= m->n_fds)
                                      return -EBADMSG74;

                              if (p)
                                      *(int*) p = m->fds[j];
                              break;
                      }

                      default:
                              assert_not_reached("Unknown basic type...")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unknown basic type..."), "../src/libsystemd/sd-bus/bus-message.c"
, 3563, __PRETTY_FUNCTION__); } while (0);
                      }
              }
      }

      m->rindex = rindex;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index++;

      return 1;
3574}

3576static int bus_message_enter_array(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              uint32_t **array_size,
              size_t *item_size,
              size_t **offsets,
              size_t *n_offsets) {

      size_t rindex;
      void *q;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3589, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 3590, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 3591, __PRETTY_FUNCTION__); } while (0);
      assert(array_size)do { if ((__builtin_expect(!!(!(array_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("array_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3592, __PRETTY_FUNCTION__); } while (0);
      assert(item_size)do { if ((__builtin_expect(!!(!(item_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("item_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3593, __PRETTY_FUNCTION__); } while (0);
      assert(offsets)do { if ((__builtin_expect(!!(!(offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3594, __PRETTY_FUNCTION__); } while (0);
      assert(n_offsets)do { if ((__builtin_expect(!!(!(n_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3595, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_single(contents, true1))
              return -EINVAL22;

      if (!c->signature || c->signature[c->index] == 0)
              return -ENXIO6;

      if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
              return -ENXIO6;

      if (!startswith(c->signature + c->index + 1, contents))
              return -ENXIO6;

      rindex = m->rindex;

      if (!BUS_MESSAGE_IS_GVARIANT(m)) {
              /* dbus1 */
              int alignment;

              r = message_peek_body(m, &rindex, 4, 4, &q);
              if (r < 0)
                      return r;

              if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE67108864)
                      return -EBADMSG74;

              alignment = bus_type_get_alignment(contents[0]);
              if (alignment < 0)
                      return alignment;

              r = message_peek_body(m, &rindex, alignment, 0, NULL((void*)0));
              if (r < 0)
                      return r;

              *array_size = (uint32_t*) q;

      } else if (c->item_size <= 0) {

              /* gvariant: empty array */
              *item_size = 0;
              *offsets = NULL((void*)0);
              *n_offsets = 0;

      } else if (bus_gvariant_is_fixed_size(contents)) {

              /* gvariant: fixed length array */
              *item_size = bus_gvariant_get_size(contents);
              *offsets = NULL((void*)0);
              *n_offsets = 0;

      } else {
              size_t where, previous = 0, framing, sz;
              int alignment;
              unsigned i;

              /* gvariant: variable length array */
              sz = bus_gvariant_determine_word_size(c->item_size, 0);

              where = rindex + c->item_size - sz;
              r = message_peek_body(m, &where, 1, sz, &q);
              if (r < 0)
                      return r;

              framing = bus_gvariant_read_word_le(q, sz);
              if (framing > c->item_size - sz)
                      return -EBADMSG74;
              if ((c->item_size - framing) % sz != 0)
                      return -EBADMSG74;

              *n_offsets = (c->item_size - framing) / sz;

              where = rindex + framing;
              r = message_peek_body(m, &where, 1, *n_offsets * sz, &q);
              if (r < 0)
                      return r;

              *offsets = new(size_t, *n_offsets)((size_t*) malloc_multiply(sizeof(size_t), (*n_offsets)));
              if (!*offsets)
                      return -ENOMEM12;

              alignment = bus_gvariant_get_alignment(c->signature);
              assert(alignment > 0)do { if ((__builtin_expect(!!(!(alignment > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("alignment > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3677, __PRETTY_FUNCTION__); } while (0);

              for (i = 0; i < *n_offsets; i++) {
                      size_t x, start;

                      start = ALIGN_TO(previous, alignment);

                      x = bus_gvariant_read_word_le((uint8_t*) q + i * sz, sz);
                      if (x > c->item_size - sz)
                              return -EBADMSG74;
                      if (x < start)
                              return -EBADMSG74;

                      (*offsets)[i] = rindex + x;
                      previous = x;
              }

              *item_size = (*offsets)[0] - rindex;
      }

      m->rindex = rindex;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index += 1 + strlen(contents);

      return 1;
3703}

3705static int bus_message_enter_variant(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              size_t *item_size) {

      size_t rindex;
      uint8_t l;
      void *q;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3716, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 3717, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 3718, __PRETTY_FUNCTION__); } while (0);
      assert(item_size)do { if ((__builtin_expect(!!(!(item_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("item_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3719, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_single(contents, false0))
              return -EINVAL22;

      if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
              return -EINVAL22;

      if (!c->signature || c->signature[c->index] == 0)
              return -ENXIO6;

      if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
              return -ENXIO6;

      rindex = m->rindex;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              size_t k, where;

              k = strlen(contents);
              if (1+k > c->item_size)
                      return -EBADMSG74;

              where = rindex + c->item_size - (1+k);
              r = message_peek_body(m, &where, 1, 1+k, &q);
              if (r < 0)
                      return r;

              if (*(char*) q != 0)
                      return -EBADMSG74;

              if (memcmp((uint8_t*) q+1, contents, k))
                      return -ENXIO6;

              *item_size = c->item_size - (1+k);

      } else {
              r = message_peek_body(m, &rindex, 1, 1, &q);
              if (r < 0)
                      return r;

              l = *(uint8_t*) q;
              if (l == UINT8_MAX(255))
                      /* avoid overflow right below */
                      return -EBADMSG74;

              r = message_peek_body(m, &rindex, 1, l+1, &q);
              if (r < 0)
                      return r;

              if (!validate_signature(q, l))
                      return -EBADMSG74;

              if (!streq(q, contents)(strcmp((q),(contents)) == 0))
                      return -ENXIO6;
      }

      m->rindex = rindex;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index++;

      return 1;
3782}

3784static int build_struct_offsets(
              sd_bus_message *m,
              const char *signature,
              size_t size,
              size_t *item_size,
              size_t **offsets,
              size_t *n_offsets) {

      unsigned n_variable = 0, n_total = 0, v;
      size_t previous, where;
      const char *p;
      size_t sz;
      void *q;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3799, __PRETTY_FUNCTION__); } while (0);
      assert(item_size)do { if ((__builtin_expect(!!(!(item_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("item_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3800, __PRETTY_FUNCTION__); } while (0);
      assert(offsets)do { if ((__builtin_expect(!!(!(offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3801, __PRETTY_FUNCTION__); } while (0);
      assert(n_offsets)do { if ((__builtin_expect(!!(!(n_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3802, __PRETTY_FUNCTION__); } while (0);

      if (isempty(signature)) {
              /* Unary type is encoded as *fixed* 1 byte padding */
              r = message_peek_body(m, &m->rindex, 1, 1, &q);
              if (r < 0)
                      return r;

              if (*(uint8_t *) q != 0)
                      return -EBADMSG74;

              *item_size = 0;
              *offsets = NULL((void*)0);
              *n_offsets = 0;
              return 0;
      }

      sz = bus_gvariant_determine_word_size(size, 0);
      if (sz <= 0)
              return -EBADMSG74;

      /* First, loop over signature and count variable elements and
       * elements in general. We use this to know how large the
       * offset array is at the end of the structure. Note that
       * GVariant only stores offsets for all variable size elements
       * that are not the last item. */

      p = signature;
      while (*p != 0) {
              size_t n;

              r = signature_element_length(p, &n);
              if (r < 0)
                      return r;
              else {
                      char t[n+1];

                      memcpy(t, p, n);
                      t[n] = 0;

                      r = bus_gvariant_is_fixed_size(t);
              }

              if (r < 0)
                      return r;
              if (r == 0 && p[n] != 0) /* except the last item */
                      n_variable++;
              n_total++;

              p += n;
      }

      if (size < n_variable * sz)
              return -EBADMSG74;

      where = m->rindex + size - (n_variable * sz);
      r = message_peek_body(m, &where, 1, n_variable * sz, &q);
      if (r < 0)
              return r;

      v = n_variable;

      *offsets = new(size_t, n_total)((size_t*) malloc_multiply(sizeof(size_t), (n_total)));
      if (!*offsets)
              return -ENOMEM12;

      *n_offsets = 0;

      /* Second, loop again and build an offset table */
      p = signature;
      previous = m->rindex;
      while (*p != 0) {
              size_t n, offset;
              int k;

              r = signature_element_length(p, &n);
              if (r < 0)
                      return r;
              else {
                      char t[n+1];

                      memcpy(t, p, n);
                      t[n] = 0;

                      size_t align = bus_gvariant_get_alignment(t);
                      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3887, __PRETTY_FUNCTION__); } while (0);

                      /* The possible start of this member after including alignment */
                      size_t start = ALIGN_TO(previous, align);

                      k = bus_gvariant_get_size(t);
                      if (k < 0) {
                              size_t x;

                              /* Variable size */
                              if (v > 0) {
                                      v--;

                                      x = bus_gvariant_read_word_le((uint8_t*) q + v*sz, sz);
                                      if (x >= size)
                                              return -EBADMSG74;
                              } else
                                      /* The last item's end is determined
                                       * from the start of the offset array */
                                      x = size - (n_variable * sz);

                              offset = m->rindex + x;
                              if (offset < start) {
                                      log_debug("For type %s with alignment %zu, message specifies offset %zu which is smaller than previous end %zu + alignment = %zu",({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/libsystemd/sd-bus/bus-message.c", 3911, __func__, "For type %s with alignment %zu, message specifies offset %zu which is smaller than previous end %zu + alignment = %zu"
, t, align, offset, previous, start) : -abs(_e); })
                                                t, align, offset, previous, start)({ int _level = (((7))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/libsystemd/sd-bus/bus-message.c", 3911, __func__, "For type %s with alignment %zu, message specifies offset %zu which is smaller than previous end %zu + alignment = %zu"
, t, align, offset, previous, start) : -abs(_e); });
                                      return -EBADMSG74;
                              }
                      } else
                              /* Fixed size */
                              offset = start + k;
              }

              previous = (*offsets)[(*n_offsets)++] = offset;
              p += n;
      }

      assert(v == 0)do { if ((__builtin_expect(!!(!(v == 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("v == 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 3923, __PRETTY_FUNCTION__); } while (0);
      assert(*n_offsets == n_total)do { if ((__builtin_expect(!!(!(*n_offsets == n_total)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("*n_offsets == n_total"), "../src/libsystemd/sd-bus/bus-message.c"
, 3924, __PRETTY_FUNCTION__); } while (0);

      *item_size = (*offsets)[0] - m->rindex;
      return 0;
3928}

3930static int enter_struct_or_dict_entry(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              size_t *item_size,
              size_t **offsets,
              size_t *n_offsets) {

      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3940, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 3941, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 3942, __PRETTY_FUNCTION__); } while (0);
      assert(item_size)do { if ((__builtin_expect(!!(!(item_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("item_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3943, __PRETTY_FUNCTION__); } while (0);
      assert(offsets)do { if ((__builtin_expect(!!(!(offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3944, __PRETTY_FUNCTION__); } while (0);
      assert(n_offsets)do { if ((__builtin_expect(!!(!(n_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3945, __PRETTY_FUNCTION__); } while (0);

      if (!BUS_MESSAGE_IS_GVARIANT(m)) {

              /* dbus1 */
              r = message_peek_body(m, &m->rindex, 8, 0, NULL((void*)0));
              if (r < 0)
                      return r;

      } else
              /* gvariant with contents */
              return build_struct_offsets(m, contents, c->item_size, item_size, offsets, n_offsets);

      return 0;
3959}

3961static int bus_message_enter_struct(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              size_t *item_size,
              size_t **offsets,
              size_t *n_offsets) {

      size_t l;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 3972, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 3973, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 3974, __PRETTY_FUNCTION__); } while (0);
      assert(item_size)do { if ((__builtin_expect(!!(!(item_size)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("item_size"), "../src/libsystemd/sd-bus/bus-message.c"
, 3975, __PRETTY_FUNCTION__); } while (0);
      assert(offsets)do { if ((__builtin_expect(!!(!(offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3976, __PRETTY_FUNCTION__); } while (0);
      assert(n_offsets)do { if ((__builtin_expect(!!(!(n_offsets)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n_offsets"), "../src/libsystemd/sd-bus/bus-message.c"
, 3977, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_valid(contents, false0))
              return -EINVAL22;

      if (!c->signature || c->signature[c->index] == 0)
              return -ENXIO6;

      l = strlen(contents);

      if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
          !startswith(c->signature + c->index + 1, contents) ||
          c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
              return -ENXIO6;

      r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets);
      if (r < 0)
              return r;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index += 1 + l + 1;

      return 1;
4000}

4002static int bus_message_enter_dict_entry(
              sd_bus_message *m,
              struct bus_container *c,
              const char *contents,
              size_t *item_size,
              size_t **offsets,
              size_t *n_offsets) {

      size_t l;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4013, __PRETTY_FUNCTION__); } while (0);
      assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/libsystemd/sd-bus/bus-message.c"
, 4014, __PRETTY_FUNCTION__); } while (0);
      assert(contents)do { if ((__builtin_expect(!!(!(contents)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 4015, __PRETTY_FUNCTION__); } while (0);

      if (!signature_is_pair(contents))
              return -EINVAL22;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              return -ENXIO6;

      if (!c->signature || c->signature[c->index] == 0)
              return 0;

      l = strlen(contents);

      if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
          !startswith(c->signature + c->index + 1, contents) ||
          c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
              return -ENXIO6;

      r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets);
      if (r < 0)
              return r;

      if (c->enclosing != SD_BUS_TYPE_ARRAY)
              c->index += 1 + l + 1;

      return 1;
4041}

4043_public___attribute__ ((visibility("default"))) int sd_bus_message_enter_container(sd_bus_message *m,
                                          char type,
                                          const char *contents) {
      struct bus_container *c;
      uint32_t *array_size = NULL((void*)0);
      _cleanup_free___attribute__((cleanup(freep))) char *signature = NULL((void*)0);
      size_t before, end;
      _cleanup_free___attribute__((cleanup(freep))) size_t *offsets = NULL((void*)0);
      size_t n_offsets = 0, item_size = 0;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4054, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 4055, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(type != 0 || !contents, -EINVAL)do { if (!(((__builtin_expect(!!(type != 0 || !contents),1)))
 ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, (
"type != 0 || !contents"), "../src/libsystemd/sd-bus/bus-message.c"
, 4056, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      if (type == 0 || !contents) {
              const char *cc;
              char tt;

              /* Allow entering into anonymous containers */
              r = sd_bus_message_peek_type(m, &tt, &cc);
              if (r < 0)
                      return r;

              if (type != 0 && type != tt)
                      return -ENXIO6;

              if (contents && !streq(contents, cc)(strcmp((contents),(cc)) == 0))
                      return -ENXIO6;

              type = tt;
              contents = cc;
      }

      /*
       * We enforce a global limit on container depth, that is much
       * higher than the 32 structs and 32 arrays the specification
       * mandates. This is simpler to implement for us, and we need
       * this only to ensure our container array doesn't grow
       * without bounds. We are happy to return any data from a
       * message as long as the data itself is valid, even if the
       * overall message might be not.
       *
       * Note that the message signature is validated when
       * parsing the headers, and that validation does check the
       * 32/32 limit.
       *
       * Note that the specification defines no limits on the depth
       * of stacked variants, but we do.
       */
      if (m->n_containers >= BUS_CONTAINER_DEPTH128)
              return -EBADMSG74;

      if (!GREEDY_REALLOC(m->containers, m->containers_allocated, m->n_containers + 1)greedy_realloc((void**) &(m->containers), &(m->
containers_allocated), (m->n_containers + 1), sizeof((m->
containers)[0])))
              return -ENOMEM12;

      if (message_end_of_signature(m))
              return -ENXIO6;

      if (message_end_of_array(m, m->rindex))
              return 0;

      c = message_get_last_container(m);

      signature = strdup(contents);
      if (!signature)
              return -ENOMEM12;

      c->saved_index = c->index;
      before = m->rindex;

      if (type == SD_BUS_TYPE_ARRAY)
              r = bus_message_enter_array(m, c, contents, &array_size, &item_size, &offsets, &n_offsets);
      else if (type == SD_BUS_TYPE_VARIANT)
              r = bus_message_enter_variant(m, c, contents, &item_size);
      else if (type == SD_BUS_TYPE_STRUCT)
              r = bus_message_enter_struct(m, c, contents, &item_size, &offsets, &n_offsets);
      else if (type == SD_BUS_TYPE_DICT_ENTRY)
              r = bus_message_enter_dict_entry(m, c, contents, &item_size, &offsets, &n_offsets);
      else
              r = -EINVAL22;
      if (r <= 0)
              return r;

      /* OK, let's fill it in */
      if (BUS_MESSAGE_IS_GVARIANT(m) &&
          type == SD_BUS_TYPE_STRUCT &&
          isempty(signature))
              end = m->rindex + 0;
      else
              end = m->rindex + c->item_size;

      m->containers[m->n_containers++] = (struct bus_container) {
               .enclosing = type,
               .signature = TAKE_PTR(signature)({ typeof(signature) _ptr_ = (signature); (signature) = ((void
*)0); _ptr_; }),

               .before = before,
               .begin = m->rindex,
               /* Unary type has fixed size of 1, but virtual size of 0 */
               .end = end,
               .array_size = array_size,
               .item_size = item_size,
               .offsets = TAKE_PTR(offsets)({ typeof(offsets) _ptr_ = (offsets); (offsets) = ((void*)0);
 _ptr_; }),
               .n_offsets = n_offsets,
      };

      return 1;
4150}

4152_public___attribute__ ((visibility("default"))) int sd_bus_message_exit_container(sd_bus_message *m) {
      struct bus_container *c;
      unsigned saved;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4157, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 4158, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(m->n_containers > 0, -ENXIO)do { if (!(((__builtin_expect(!!(m->n_containers > 0),1
))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("m->n_containers > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 4159, __PRETTY_FUNCTION__), 0))) return (-6); } while (0);

      c = message_get_last_container(m);

      if (c->enclosing != SD_BUS_TYPE_ARRAY) {
              if (c->signature && c->signature[c->index] != 0)
                      return -EBUSY16;
      }

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              if (m->rindex < c->end)
                      return -EBUSY16;

      } else if (c->enclosing == SD_BUS_TYPE_ARRAY) {
              uint32_t l;

              l = BUS_MESSAGE_BSWAP32(m, *c->array_size);
              if (c->begin + l != m->rindex)
                      return -EBUSY16;
      }

      message_free_last_container(m);

      c = message_get_last_container(m);
      saved = c->index;
      c->index = c->saved_index;
      r = container_next_item(m, c, &m->rindex);
      c->index = saved;
      if (r < 0)
              return r;

      return 1;
4191}

4193static void message_quit_container(sd_bus_message *m) {
      struct bus_container *c;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4196, __PRETTY_FUNCTION__); } while (0);
      assert(m->sealed)do { if ((__builtin_expect(!!(!(m->sealed)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m->sealed"), "../src/libsystemd/sd-bus/bus-message.c"
, 4197, __PRETTY_FUNCTION__); } while (0);
      assert(m->n_containers > 0)do { if ((__builtin_expect(!!(!(m->n_containers > 0)),0
))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("m->n_containers > 0"
), "../src/libsystemd/sd-bus/bus-message.c", 4198, __PRETTY_FUNCTION__
); } while (0);

      /* Undo seeks */
      c = message_get_last_container(m);
      assert(m->rindex >= c->before)do { if ((__builtin_expect(!!(!(m->rindex >= c->before
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("m->rindex >= c->before"
), "../src/libsystemd/sd-bus/bus-message.c", 4202, __PRETTY_FUNCTION__
); } while (0);
      m->rindex = c->before;

      /* Free container */
      message_free_last_container(m);

      /* Correct index of new top-level container */
      c = message_get_last_container(m);
      c->index = c->saved_index;
4211}

4213_public___attribute__ ((visibility("default"))) int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
      struct bus_container *c;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4217, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 4218, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      if (message_end_of_signature(m))
              goto eof;

      if (message_end_of_array(m, m->rindex))
              goto eof;

      c = message_get_last_container(m);

      if (bus_type_is_basic(c->signature[c->index])) {
              if (contents)
                      *contents = NULL((void*)0);
              if (type)
                      *type = c->signature[c->index];
              return 1;
      }

      if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) {

              if (contents) {
                      size_t l;

                      r = signature_element_length(c->signature+c->index+1, &l);
                      if (r < 0)
                              return r;

                      /* signature_element_length does verification internally */

                      /* The array element must not be empty */
                      assert(l >= 1)do { if ((__builtin_expect(!!(!(l >= 1)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("l >= 1"), "../src/libsystemd/sd-bus/bus-message.c"
, 4248, __PRETTY_FUNCTION__); } while (0);
                      if (free_and_strndup(&c->peeked_signature,
                                           c->signature + c->index + 1, l) < 0)
                              return -ENOMEM12;

                      *contents = c->peeked_signature;
              }

              if (type)
                      *type = SD_BUS_TYPE_ARRAY;

              return 1;
      }

      if (IN_SET(c->signature[c->index], SD_BUS_TYPE_STRUCT_BEGIN, SD_BUS_TYPE_DICT_ENTRY_BEGIN)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRUCT_BEGIN, SD_BUS_TYPE_DICT_ENTRY_BEGIN
})/sizeof(int)]; switch(c->signature[c->index]) { case SD_BUS_TYPE_STRUCT_BEGIN
: case SD_BUS_TYPE_DICT_ENTRY_BEGIN: _found = 1; break; default
: break; } _found; })) {

              if (contents) {
                      size_t l;

                      r = signature_element_length(c->signature+c->index, &l);
                      if (r < 0)
                              return r;

                      assert(l >= 3)do { if ((__builtin_expect(!!(!(l >= 3)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("l >= 3"), "../src/libsystemd/sd-bus/bus-message.c"
, 4271, __PRETTY_FUNCTION__); } while (0);
                      if (free_and_strndup(&c->peeked_signature,
                                           c->signature + c->index + 1, l - 2) < 0)
                              return -ENOMEM12;

                      *contents = c->peeked_signature;
              }

              if (type)
                      *type = c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;

              return 1;
      }

      if (c->signature[c->index] == SD_BUS_TYPE_VARIANT) {
              if (contents) {
                      void *q;

                      if (BUS_MESSAGE_IS_GVARIANT(m)) {
                              size_t k;

                              if (c->item_size < 2)
                                      return -EBADMSG74;

                              /* Look for the NUL delimiter that
                                 separates the payload from the
                                 signature. Since the body might be
                                 in a different part that then the
                                 signature we map byte by byte. */

                              for (k = 2; k <= c->item_size; k++) {
                                      size_t where;

                                      where = m->rindex + c->item_size - k;
                                      r = message_peek_body(m, &where, 1, k, &q);
                                      if (r < 0)
                                              return r;

                                      if (*(char*) q == 0)
                                              break;
                              }

                              if (k > c->item_size)
                                      return -EBADMSG74;

                              if (free_and_strndup(&c->peeked_signature,
                                                   (char*) q + 1, k - 1) < 0)
                                      return -ENOMEM12;

                              if (!signature_is_valid(c->peeked_signature, true1))
                                      return -EBADMSG74;

                              *contents = c->peeked_signature;
                      } else {
                              size_t rindex, l;

                              rindex = m->rindex;
                              r = message_peek_body(m, &rindex, 1, 1, &q);
                              if (r < 0)
                                      return r;

                              l = *(uint8_t*) q;
                              if (l == UINT8_MAX(255))
                                      /* avoid overflow right below */
                                      return -EBADMSG74;

                              r = message_peek_body(m, &rindex, 1, l+1, &q);
                              if (r < 0)
                                      return r;

                              if (!validate_signature(q, l))
                                      return -EBADMSG74;

                              *contents = q;
                      }
              }

              if (type)
                      *type = SD_BUS_TYPE_VARIANT;

              return 1;
      }

      return -EINVAL22;

4356eof:
      if (type)
              *type = 0;
      if (contents)
              *contents = NULL((void*)0);
      return 0;
4362}

4364_public___attribute__ ((visibility("default"))) int sd_bus_message_rewind(sd_bus_message *m, int complete) {
      struct bus_container *c;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4367, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 4368, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      if (complete) {
              message_reset_containers(m);
              m->rindex = 0;

              c = message_get_last_container(m);
      } else {
              c = message_get_last_container(m);

              c->index = 0;
              m->rindex = c->begin;
      }

      c->offset_index = 0;
      c->item_size = (c->n_offsets > 0 ? c->offsets[0] : c->end) - c->begin;

      return !isempty(c->signature);
4386}

4388static int message_read_ap(
              sd_bus_message *m,
              const char *types,
              va_list ap) {

      unsigned n_array, n_struct;
      TypeStack stack[BUS_CONTAINER_DEPTH128];
      unsigned stack_ptr = 0;
      unsigned n_loop = 0;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4399, __PRETTY_FUNCTION__); } while (0);

      if (isempty(types))
              return 0;

      /* Ideally, we'd just call ourselves recursively on every
       * complex type. However, the state of a va_list that is
       * passed to a function is undefined after that function
       * returns. This means we need to decode the va_list linearly
       * in a single stackframe. We hence implement our own
       * home-grown stack in an array. */

      n_array = (unsigned) -1; /* length of current array entries */
      n_struct = strlen(types); /* length of current struct contents signature */

      for (;;) {
              const char *t;

              n_loop++;

              if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
                      r = type_stack_pop(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, &types, &n_struct, &n_array);
                      if (r < 0)
                              return r;
                      if (r == 0)
                              break;

                      r = sd_bus_message_exit_container(m);
                      if (r < 0)
                              return r;

                      continue;
              }

              t = types;
              if (n_array != (unsigned) -1)
                      n_array--;
              else {
                      types++;
                      n_struct--;
              }

              switch (*t) {

              case SD_BUS_TYPE_BYTE:
              case SD_BUS_TYPE_BOOLEAN:
              case SD_BUS_TYPE_INT16:
              case SD_BUS_TYPE_UINT16:
              case SD_BUS_TYPE_INT32:
              case SD_BUS_TYPE_UINT32:
              case SD_BUS_TYPE_INT64:
              case SD_BUS_TYPE_UINT64:
              case SD_BUS_TYPE_DOUBLE:
              case SD_BUS_TYPE_STRING:
              case SD_BUS_TYPE_OBJECT_PATH:
              case SD_BUS_TYPE_SIGNATURE:
              case SD_BUS_TYPE_UNIX_FD: {
                      void *p;

                      p = va_arg(ap, void*)__builtin_va_arg(ap, void*);
                      r = sd_bus_message_read_basic(m, *t, p);
                      if (r < 0)
                              return r;
                      if (r == 0) {
                              if (n_loop <= 1)
                                      return 0;

                              return -ENXIO6;
                      }

                      break;
              }

              case SD_BUS_TYPE_ARRAY: {
                      size_t k;

                      r = signature_element_length(t + 1, &k);
                      if (r < 0)
                              return r;

                      {
                              char s[k + 1];
                              memcpy(s, t + 1, k);
                              s[k] = 0;

                              r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
                              if (r < 0)
                                      return r;
                              if (r == 0) {
                                      if (n_loop <= 1)
                                              return 0;

                                      return -ENXIO6;
                              }
                      }

                      if (n_array == (unsigned) -1) {
                              types += k;
                              n_struct -= k;
                      }

                      r = type_stack_push(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, types, n_struct, n_array);
                      if (r < 0)
                              return r;

                      types = t + 1;
                      n_struct = k;
                      n_array = va_arg(ap, unsigned)__builtin_va_arg(ap, unsigned);

                      break;
              }

              case SD_BUS_TYPE_VARIANT: {
                      const char *s;

                      s = va_arg(ap, const char *)__builtin_va_arg(ap, const char *);
                      if (!s)
                              return -EINVAL22;

                      r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s);
                      if (r < 0)
                              return r;
                      if (r == 0) {
                              if (n_loop <= 1)
                                      return 0;

                              return -ENXIO6;
                      }

                      r = type_stack_push(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, types, n_struct, n_array);
                      if (r < 0)
                              return r;

                      types = s;
                      n_struct = strlen(s);
                      n_array = (unsigned) -1;

                      break;
              }

              case SD_BUS_TYPE_STRUCT_BEGIN:
              case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                      size_t k;

                      r = signature_element_length(t, &k);
                      if (r < 0)
                              return r;

                      {
                              char s[k - 1];
                              memcpy(s, t + 1, k - 2);
                              s[k - 2] = 0;

                              r = sd_bus_message_enter_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
                              if (r < 0)
                                      return r;
                              if (r == 0) {
                                      if (n_loop <= 1)
                                              return 0;
                                      return -ENXIO6;
                              }
                      }

                      if (n_array == (unsigned) -1) {
                              types += k - 1;
                              n_struct -= k - 1;
                      }

                      r = type_stack_push(stack, ELEMENTSOF(stack)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(stack), typeof(&*(stack))), sizeof(stack)/sizeof(
(stack)[0]), ((void)0))), &stack_ptr, types, n_struct, n_array);
                      if (r < 0)
                              return r;

                      types = t + 1;
                      n_struct = k - 2;
                      n_array = (unsigned) -1;

                      break;
              }

              default:
                      return -EINVAL22;
              }
      }

      return 1;
4584}

4586_public___attribute__ ((visibility("default"))) int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
      va_list ap;
      int r;

      va_start(ap, types)__builtin_va_start(ap, types);
      r = message_read_ap(m, types, ap);
      va_end(ap)__builtin_va_end(ap);

      return r;
4595}

4597_public___attribute__ ((visibility("default"))) int sd_bus_message_skip(sd_bus_message *m, const char *types) {
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4600, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 4601, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      /* If types is NULL, read exactly one element */
      if (!types) {
              struct bus_container *c;
              size_t l;

              if (message_end_of_signature(m))
                      return -ENXIO6;

              if (message_end_of_array(m, m->rindex))
                      return 0;

              c = message_get_last_container(m);

              r = signature_element_length(c->signature + c->index, &l);
              if (r < 0)
                      return r;

              types = strndupa(c->signature + c->index, l)(__extension__ ({ const char *__old = (c->signature + c->
index); size_t __len = strnlen (__old, (l)); char *__new = (char
 *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *
) memcpy (__new, __old, __len); }));
      }

      switch (*types) {

      case 0: /* Nothing to drop */
              return 0;

      case SD_BUS_TYPE_BYTE:
      case SD_BUS_TYPE_BOOLEAN:
      case SD_BUS_TYPE_INT16:
      case SD_BUS_TYPE_UINT16:
      case SD_BUS_TYPE_INT32:
      case SD_BUS_TYPE_UINT32:
      case SD_BUS_TYPE_INT64:
      case SD_BUS_TYPE_UINT64:
      case SD_BUS_TYPE_DOUBLE:
      case SD_BUS_TYPE_STRING:
      case SD_BUS_TYPE_OBJECT_PATH:
      case SD_BUS_TYPE_SIGNATURE:
      case SD_BUS_TYPE_UNIX_FD:

              r = sd_bus_message_read_basic(m, *types, NULL((void*)0));
              if (r <= 0)
                      return r;

              r = sd_bus_message_skip(m, types + 1);
              if (r < 0)
                      return r;

              return 1;

      case SD_BUS_TYPE_ARRAY: {
              size_t k;

              r = signature_element_length(types + 1, &k);
              if (r < 0)
                      return r;

              {
                      char s[k+1];
                      memcpy(s, types+1, k);
                      s[k] = 0;

                      r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
                      if (r <= 0)
                              return r;

                      for (;;) {
                              r = sd_bus_message_skip(m, s);
                              if (r < 0)
                                      return r;
                              if (r == 0)
                                      break;
                      }

                      r = sd_bus_message_exit_container(m);
                      if (r < 0)
                              return r;
              }

              r = sd_bus_message_skip(m, types + 1 + k);
              if (r < 0)
                      return r;

              return 1;
      }

      case SD_BUS_TYPE_VARIANT: {
              const char *contents;
              char x;

              r = sd_bus_message_peek_type(m, &x, &contents);
              if (r <= 0)
                      return r;

              if (x != SD_BUS_TYPE_VARIANT)
                      return -ENXIO6;

              r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
              if (r <= 0)
                      return r;

              r = sd_bus_message_skip(m, contents);
              if (r < 0)
                      return r;
              assert(r != 0)do { if ((__builtin_expect(!!(!(r != 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("r != 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 4706, __PRETTY_FUNCTION__); } while (0);

              r = sd_bus_message_exit_container(m);
              if (r < 0)
                      return r;

              r = sd_bus_message_skip(m, types + 1);
              if (r < 0)
                      return r;

              return 1;
      }

      case SD_BUS_TYPE_STRUCT_BEGIN:
      case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
              size_t k;

              r = signature_element_length(types, &k);
              if (r < 0)
                      return r;

              {
                      char s[k-1];
                      memcpy(s, types+1, k-2);
                      s[k-2] = 0;

                      r = sd_bus_message_enter_container(m, *types == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
                      if (r <= 0)
                              return r;

                      r = sd_bus_message_skip(m, s);
                      if (r < 0)
                              return r;

                      r = sd_bus_message_exit_container(m);
                      if (r < 0)
                              return r;
              }

              r = sd_bus_message_skip(m, types + k);
              if (r < 0)
                      return r;

              return 1;
      }

      default:
              return -EINVAL22;
      }
4755}

4757_public___attribute__ ((visibility("default"))) 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;
      ssize_t align;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4769, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 4770, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(bus_type_is_trivial(type), -EINVAL)do { if (!(((__builtin_expect(!!(bus_type_is_trivial(type)),1
))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("bus_type_is_trivial(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 4771, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(ptr, -EINVAL)do { if (!(((__builtin_expect(!!(ptr),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("ptr"), "../src/libsystemd/sd-bus/bus-message.c"
, 4772, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(size, -EINVAL)do { if (!(((__builtin_expect(!!(size),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("size"), "../src/libsystemd/sd-bus/bus-message.c"
, 4773, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -EOPNOTSUPP)do { if (!(((__builtin_expect(!!(!BUS_MESSAGE_NEED_BSWAP(m)),
1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("!BUS_MESSAGE_NEED_BSWAP(m)"), "../src/libsystemd/sd-bus/bus-message.c"
, 4774, __PRETTY_FUNCTION__), 0))) return (-95); } while (0);

      r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type)((char[2]) { type, 0 }));
      if (r <= 0)
              return r;

      c = message_get_last_container(m);

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              align = bus_gvariant_get_alignment(CHAR_TO_STR(type)((char[2]) { type, 0 }));
              if (align < 0)
                      return align;

              sz = c->end - c->begin;
      } else {
              align = bus_type_get_alignment(type);
              if (align < 0)
                      return align;

              sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
      }

      if (sz == 0)
              /* Zero length array, let's return some aligned
               * pointer that is not NULL */
              p = (uint8_t*) align;
      else {
              r = message_peek_body(m, &m->rindex, align, sz, &p);
              if (r < 0)
                      goto fail;
      }

      r = sd_bus_message_exit_container(m);
      if (r < 0)
              goto fail;

      *ptr = (const void*) p;
      *size = sz;

      return 1;

4815fail:
      message_quit_container(m);
      return r;
4818}

4820static int message_peek_fields(
              sd_bus_message *m,
              size_t *rindex,
              size_t align,
              size_t nbytes,
              void **ret) {

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4827, __PRETTY_FUNCTION__); } while (0);
      assert(rindex)do { if ((__builtin_expect(!!(!(rindex)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("rindex"), "../src/libsystemd/sd-bus/bus-message.c"
, 4828, __PRETTY_FUNCTION__); } while (0);
      assert(align > 0)do { if ((__builtin_expect(!!(!(align > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("align > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 4829, __PRETTY_FUNCTION__); } while (0);

      return buffer_peek(BUS_MESSAGE_FIELDS(m), m->fields_size, rindex, align, nbytes, ret);
4832}

4834static int message_peek_field_uint32(
              sd_bus_message *m,
              size_t *ri,
              size_t item_size,
              uint32_t *ret) {

      int r;
      void *q;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4843, __PRETTY_FUNCTION__); } while (0);
      assert(ri)do { if ((__builtin_expect(!!(!(ri)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ri"), "../src/libsystemd/sd-bus/bus-message.c"
, 4844, __PRETTY_FUNCTION__); } while (0);

      if (BUS_MESSAGE_IS_GVARIANT(m) && item_size != 4)
              return -EBADMSG74;

      /* identical for gvariant and dbus1 */

      r = message_peek_fields(m, ri, 4, 4, &q);
      if (r < 0)
              return r;

      if (ret)
              *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);

      return 0;
4859}

4861static int message_peek_field_uint64(
              sd_bus_message *m,
              size_t *ri,
              size_t item_size,
              uint64_t *ret) {

      int r;
      void *q;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4870, __PRETTY_FUNCTION__); } while (0);
      assert(ri)do { if ((__builtin_expect(!!(!(ri)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ri"), "../src/libsystemd/sd-bus/bus-message.c"
, 4871, __PRETTY_FUNCTION__); } while (0);

      if (BUS_MESSAGE_IS_GVARIANT(m) && item_size != 8)
              return -EBADMSG74;

      /* identical for gvariant and dbus1 */

      r = message_peek_fields(m, ri, 8, 8, &q);
      if (r < 0)
              return r;

      if (ret)
              *ret = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);

      return 0;
4886}

4888static int message_peek_field_string(
              sd_bus_message *m,
              bool_Bool (*validate)(const char *p),
              size_t *ri,
              size_t item_size,
              const char **ret) {

      uint32_t l;
      int r;
      void *q;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4899, __PRETTY_FUNCTION__); } while (0);
      assert(ri)do { if ((__builtin_expect(!!(!(ri)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ri"), "../src/libsystemd/sd-bus/bus-message.c"
, 4900, __PRETTY_FUNCTION__); } while (0);

      if (BUS_MESSAGE_IS_GVARIANT(m)) {

              if (item_size <= 0)
                      return -EBADMSG74;

              r = message_peek_fields(m, ri, 1, item_size, &q);
              if (r < 0)
                      return r;

              l = item_size - 1;
      } else {
              r = message_peek_field_uint32(m, ri, 4, &l);
              if (r < 0)
                      return r;

              if (l == UINT32_MAX(4294967295U))
                      /* avoid overflow right below */
                      return -EBADMSG74;

              r = message_peek_fields(m, ri, 1, l+1, &q);
              if (r < 0)
                      return r;
      }

      if (validate) {
              if (!validate_nul(q, l))
                      return -EBADMSG74;

              if (!validate(q))
                      return -EBADMSG74;
      } else {
              if (!validate_string(q, l))
                      return -EBADMSG74;
      }

      if (ret)
              *ret = q;

      return 0;
4941}

4943static int message_peek_field_signature(
              sd_bus_message *m,
              size_t *ri,
              size_t item_size,
              const char **ret) {

      size_t l;
      int r;
      void *q;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4953, __PRETTY_FUNCTION__); } while (0);
      assert(ri)do { if ((__builtin_expect(!!(!(ri)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ri"), "../src/libsystemd/sd-bus/bus-message.c"
, 4954, __PRETTY_FUNCTION__); } while (0);

      if (BUS_MESSAGE_IS_GVARIANT(m)) {

              if (item_size <= 0)
                      return -EBADMSG74;

              r = message_peek_fields(m, ri, 1, item_size, &q);
              if (r < 0)
                      return r;

              l = item_size - 1;
      } else {
              r = message_peek_fields(m, ri, 1, 1, &q);
              if (r < 0)
                      return r;

              l = *(uint8_t*) q;
              if (l == UINT8_MAX(255))
                      /* avoid overflow right below */
                      return -EBADMSG74;

              r = message_peek_fields(m, ri, 1, l+1, &q);
              if (r < 0)
                      return r;
      }

      if (!validate_signature(q, l))
              return -EBADMSG74;

      if (ret)
              *ret = q;

      return 0;
4988}

4990static int message_skip_fields(
              sd_bus_message *m,
              size_t *ri,
              uint32_t array_size,
              const char **signature) {

      size_t original_index;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 4999, __PRETTY_FUNCTION__); } while (0);
      assert(ri)do { if ((__builtin_expect(!!(!(ri)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ri"), "../src/libsystemd/sd-bus/bus-message.c"
, 5000, __PRETTY_FUNCTION__); } while (0);
      assert(signature)do { if ((__builtin_expect(!!(!(signature)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("signature"), "../src/libsystemd/sd-bus/bus-message.c"
, 5001, __PRETTY_FUNCTION__); } while (0);
      assert(!BUS_MESSAGE_IS_GVARIANT(m))do { if ((__builtin_expect(!!(!(!BUS_MESSAGE_IS_GVARIANT(m)))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("!BUS_MESSAGE_IS_GVARIANT(m)"
), "../src/libsystemd/sd-bus/bus-message.c", 5002, __PRETTY_FUNCTION__
); } while (0);

      original_index = *ri;

      for (;;) {
              char t;
              size_t l;

              if (array_size != (uint32_t) -1 &&
                  array_size <= *ri - original_index)
                      return 0;

              t = **signature;
              if (!t)
                      return 0;

              if (t == SD_BUS_TYPE_STRING) {

                      r = message_peek_field_string(m, NULL((void*)0), ri, 0, NULL((void*)0));
                      if (r < 0)
                              return r;

                      (*signature)++;

              } else if (t == SD_BUS_TYPE_OBJECT_PATH) {

                      r = message_peek_field_string(m, object_path_is_valid, ri, 0, NULL((void*)0));
                      if (r < 0)
                              return r;

                      (*signature)++;

              } else if (t == SD_BUS_TYPE_SIGNATURE) {

                      r = message_peek_field_signature(m, ri, 0, NULL((void*)0));
                      if (r < 0)
                              return r;

                      (*signature)++;

              } else if (bus_type_is_basic(t)) {
                      ssize_t align, k;

                      align = bus_type_get_alignment(t);
                      k = bus_type_get_size(t);
                      assert(align > 0 && k > 0)do { if ((__builtin_expect(!!(!(align > 0 && k >
 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("align > 0 && k > 0"
), "../src/libsystemd/sd-bus/bus-message.c", 5047, __PRETTY_FUNCTION__
); } while (0);

                      r = message_peek_fields(m, ri, align, k, NULL((void*)0));
                      if (r < 0)
                              return r;

                      (*signature)++;

              } else if (t == SD_BUS_TYPE_ARRAY) {

                      r = signature_element_length(*signature + 1, &l);
                      if (r < 0)
                              return r;

                      assert(l >= 1)do { if ((__builtin_expect(!!(!(l >= 1)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("l >= 1"), "../src/libsystemd/sd-bus/bus-message.c"
, 5061, __PRETTY_FUNCTION__); } while (0);
                      {
                              char sig[l + 1], *s = sig;
                              uint32_t nas;
                              int alignment;

                              strncpy(sig, *signature + 1, l);
                              sig[l] = '\0';

                              alignment = bus_type_get_alignment(sig[0]);
                              if (alignment < 0)
                                      return alignment;

                              r = message_peek_field_uint32(m, ri, 0, &nas);
                              if (r < 0)
                                      return r;
                              if (nas > BUS_ARRAY_MAX_SIZE67108864)
                                      return -EBADMSG74;

                              r = message_peek_fields(m, ri, alignment, 0, NULL((void*)0));
                              if (r < 0)
                                      return r;

                              r = message_skip_fields(m, ri, nas, (const char**) &s);
                              if (r < 0)
                                      return r;
                      }

                      (*signature) += 1 + l;

              } else if (t == SD_BUS_TYPE_VARIANT) {
                      const char *s;

                      r = message_peek_field_signature(m, ri, 0, &s);
                      if (r < 0)
                              return r;

                      r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
                      if (r < 0)
                              return r;

                      (*signature)++;

              } else if (IN_SET(t, SD_BUS_TYPE_STRUCT, SD_BUS_TYPE_DICT_ENTRY)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRUCT, SD_BUS_TYPE_DICT_ENTRY
})/sizeof(int)]; switch(t) { case SD_BUS_TYPE_STRUCT: case SD_BUS_TYPE_DICT_ENTRY
: _found = 1; break; default: break; } _found; })) {

                      r = signature_element_length(*signature, &l);
                      if (r < 0)
                              return r;

                      assert(l >= 2)do { if ((__builtin_expect(!!(!(l >= 2)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("l >= 2"), "../src/libsystemd/sd-bus/bus-message.c"
, 5110, __PRETTY_FUNCTION__); } while (0);
                      {
                              char sig[l + 1], *s = sig;
                              strncpy(sig, *signature + 1, l);
                              sig[l] = '\0';

                              r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
                              if (r < 0)
                                      return r;
                      }

                      *signature += l;
              } else
                      return -EBADMSG74;
      }
5125}

5127int bus_message_parse_fields(sd_bus_message *m) {
      size_t ri;
      int r;
      uint32_t unix_fds = 0;
      bool_Bool unix_fds_set = false0;
      void *offsets = NULL((void*)0);
      unsigned n_offsets = 0;
      size_t sz = 0;
      unsigned i = 0;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5137, __PRETTY_FUNCTION__); } while (0);

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              char *p;

              /* Read the signature from the end of the body variant first */
              sz = bus_gvariant_determine_word_size(BUS_MESSAGE_SIZE(m), 0);
              if (m->footer_accessible < 1 + sz)
                      return -EBADMSG74;

              p = (char*) m->footer + m->footer_accessible - (1 + sz);
              for (;;) {
                      if (p < (char*) m->footer)
                              return -EBADMSG74;

                      if (*p == 0) {
                              char *k;
                              size_t l;

                              /* We found the beginning of the signature
                               * string, yay! We require the body to be a
                               * structure, so verify it and then strip the
                               * opening/closing brackets. */

                              l = (char*) m->footer + m->footer_accessible - p - (1 + sz);
                              if (l < 2 ||
                                  p[1] != SD_BUS_TYPE_STRUCT_BEGIN ||
                                  p[1 + l - 1] != SD_BUS_TYPE_STRUCT_END)
                                      return -EBADMSG74;

                              k = memdup_suffix0(p + 1 + 1, l - 2);
                              if (!k)
                                      return -ENOMEM12;

                              free_and_replace(m->root_container.signature, k)({ free(m->root_container.signature); (m->root_container
.signature) = (k); (k) = ((void*)0); 0; });
                              break;
                      }

                      p--;
              }

              /* Calculate the actual user body size, by removing
               * the trailing variant signature and struct offset
               * table */
              m->user_body_size = m->body_size - ((char*) m->footer + m->footer_accessible - p);

              /* Pull out the offset table for the fields array */
              sz = bus_gvariant_determine_word_size(m->fields_size, 0);
              if (sz > 0) {
                      size_t framing;
                      void *q;

                      ri = m->fields_size - sz;
                      r = message_peek_fields(m, &ri, 1, sz, &q);
                      if (r < 0)
                              return r;

                      framing = bus_gvariant_read_word_le(q, sz);
                      if (framing >= m->fields_size - sz)
                              return -EBADMSG74;
                      if ((m->fields_size - framing) % sz != 0)
                              return -EBADMSG74;

                      ri = framing;
                      r = message_peek_fields(m, &ri, 1, m->fields_size - framing, &offsets);
                      if (r < 0)
                              return r;

                      n_offsets = (m->fields_size - framing) / sz;
              }
      } else
              m->user_body_size = m->body_size;

      ri = 0;
      while (ri < m->fields_size) {
              _cleanup_free___attribute__((cleanup(freep))) char *sig = NULL((void*)0);
              const char *signature;
              uint64_t field_type;
              size_t item_size = (size_t) -1;

              if (BUS_MESSAGE_IS_GVARIANT(m)) {
                      uint64_t *u64;

                      if (i >= n_offsets)
                              break;

                      if (i == 0)
                              ri = 0;
                      else
                              ri = ALIGN_TO(bus_gvariant_read_word_le((uint8_t*) offsets + (i-1)*sz, sz), 8);

                      r = message_peek_fields(m, &ri, 8, 8, (void**) &u64);
                      if (r < 0)
                              return r;

                      field_type = BUS_MESSAGE_BSWAP64(m, *u64);
              } else {
                      uint8_t *u8;

                      r = message_peek_fields(m, &ri, 8, 1, (void**) &u8);
                      if (r < 0)
                              return r;

                      field_type = *u8;
              }

              if (BUS_MESSAGE_IS_GVARIANT(m)) {
                      size_t where, end;
                      char *b;
                      void *q;

                      end = bus_gvariant_read_word_le((uint8_t*) offsets + i*sz, sz);

                      if (end < ri)
                              return -EBADMSG74;

                      where = ri = ALIGN_TO(ri, 8);
                      item_size = end - ri;
                      r = message_peek_fields(m, &where, 1, item_size, &q);
                      if (r < 0)
                              return r;

                      b = memrchr(q, 0, item_size);
                      if (!b)
                              return -EBADMSG74;

                      sig = strndup(b+1, item_size - (b+1-(char*) q));
                      if (!sig)
                              return -ENOMEM12;

                      signature = sig;
                      item_size = b - (char*) q;
              } else {
                      r = message_peek_field_signature(m, &ri, 0, &signature);
                      if (r < 0)
                              return r;
              }

              switch (field_type) {

              case _BUS_MESSAGE_HEADER_INVALID:
                      return -EBADMSG74;

              case BUS_MESSAGE_HEADER_PATH:

                      if (m->path)
                              return -EBADMSG74;

                      if (!streq(signature, "o")(strcmp((signature),("o")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_string(m, object_path_is_valid, &ri, item_size, &m->path);
                      break;

              case BUS_MESSAGE_HEADER_INTERFACE:

                      if (m->interface)
                              return -EBADMSG74;

                      if (!streq(signature, "s")(strcmp((signature),("s")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_string(m, interface_name_is_valid, &ri, item_size, &m->interface);
                      break;

              case BUS_MESSAGE_HEADER_MEMBER:

                      if (m->member)
                              return -EBADMSG74;

                      if (!streq(signature, "s")(strcmp((signature),("s")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_string(m, member_name_is_valid, &ri, item_size, &m->member);
                      break;

              case BUS_MESSAGE_HEADER_ERROR_NAME:

                      if (m->error.name)
                              return -EBADMSG74;

                      if (!streq(signature, "s")(strcmp((signature),("s")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_string(m, error_name_is_validinterface_name_is_valid, &ri, item_size, &m->error.name);
                      if (r >= 0)
                              m->error._need_free = -1;

                      break;

              case BUS_MESSAGE_HEADER_DESTINATION:

                      if (m->destination)
                              return -EBADMSG74;

                      if (!streq(signature, "s")(strcmp((signature),("s")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->destination);
                      break;

              case BUS_MESSAGE_HEADER_SENDER:

                      if (m->sender)
                              return -EBADMSG74;

                      if (!streq(signature, "s")(strcmp((signature),("s")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->sender);

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

                      break;

              case BUS_MESSAGE_HEADER_SIGNATURE: {
                      const char *s;
                      char *c;

                      if (BUS_MESSAGE_IS_GVARIANT(m)) /* only applies to dbus1 */
                              return -EBADMSG74;

                      if (m->root_container.signature)
                              return -EBADMSG74;

                      if (!streq(signature, "g")(strcmp((signature),("g")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_signature(m, &ri, item_size, &s);
                      if (r < 0)
                              return r;

                      c = strdup(s);
                      if (!c)
                              return -ENOMEM12;

                      free_and_replace(m->root_container.signature, c)({ free(m->root_container.signature); (m->root_container
.signature) = (c); (c) = ((void*)0); 0; });
                      break;
              }

              case BUS_MESSAGE_HEADER_REPLY_SERIAL:

                      if (m->reply_cookie != 0)
                              return -EBADMSG74;

                      if (BUS_MESSAGE_IS_GVARIANT(m)) {
                              /* 64bit on dbus2 */

                              if (!streq(signature, "t")(strcmp((signature),("t")) == 0))
                                      return -EBADMSG74;

                              r = message_peek_field_uint64(m, &ri, item_size, &m->reply_cookie);
                              if (r < 0)
                                      return r;
                      } else {
                              /* 32bit on dbus1 */
                              uint32_t serial;

                              if (!streq(signature, "u")(strcmp((signature),("u")) == 0))
                                      return -EBADMSG74;

                              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 -EBADMSG74;

                      break;

              case BUS_MESSAGE_HEADER_UNIX_FDS:
                      if (unix_fds_set)
                              return -EBADMSG74;

                      if (!streq(signature, "u")(strcmp((signature),("u")) == 0))
                              return -EBADMSG74;

                      r = message_peek_field_uint32(m, &ri, item_size, &unix_fds);
                      if (r < 0)
                              return -EBADMSG74;

                      unix_fds_set = true1;
                      break;

              default:
                      if (!BUS_MESSAGE_IS_GVARIANT(m))
                              r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
              }

              if (r < 0)
                      return r;

              i++;
      }

      if (m->n_fds != unix_fds)
              return -EBADMSG74;

      switch (m->header->type) {

      case SD_BUS_MESSAGE_SIGNAL:
              if (!m->path || !m->interface || !m->member)
                      return -EBADMSG74;

              if (m->reply_cookie != 0)
                      return -EBADMSG74;

              break;

      case SD_BUS_MESSAGE_METHOD_CALL:

              if (!m->path || !m->member)
                      return -EBADMSG74;

              if (m->reply_cookie != 0)
                      return -EBADMSG74;

              break;

      case SD_BUS_MESSAGE_METHOD_RETURN:

              if (m->reply_cookie == 0)
                      return -EBADMSG74;
              break;

      case SD_BUS_MESSAGE_METHOD_ERROR:

              if (m->reply_cookie == 0 || !m->error.name)
                      return -EBADMSG74;
              break;
      }

      /* Refuse non-local messages that claim they are local */
      if (streq_ptr(m->path, "/org/freedesktop/DBus/Local"))
              return -EBADMSG74;
      if (streq_ptr(m->interface, "org.freedesktop.DBus.Local"))
              return -EBADMSG74;
      if (streq_ptr(m->sender, "org.freedesktop.DBus.Local"))
              return -EBADMSG74;

      m->root_container.end = m->user_body_size;

      if (BUS_MESSAGE_IS_GVARIANT(m)) {
              r = build_struct_offsets(
                              m,
                              m->root_container.signature,
                              m->user_body_size,
                              &m->root_container.item_size,
                              &m->root_container.offsets,
                              &m->root_container.n_offsets);
              if (r == -EINVAL22)
                      return -EBADMSG74;
              if (r < 0)
                      return r;
      }

      /* Try to read the error message, but if we can't it's a non-issue */
      if (m->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
              (void) sd_bus_message_read(m, "s", &m->error.message);

      return 0;
5504}

5506_public___attribute__ ((visibility("default"))) int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5507, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(destination, -EINVAL)do { if (!(((__builtin_expect(!!(destination),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("destination"), "../src/libsystemd/sd-bus/bus-message.c"
, 5508, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5509, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->destination, -EEXIST)do { if (!(((__builtin_expect(!!(!m->destination),1))) ? (
1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->destination"
), "../src/libsystemd/sd-bus/bus-message.c", 5510, __PRETTY_FUNCTION__
), 0))) return (-17); } while (0);

      return message_append_field_string(m, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
5513}

5515_public___attribute__ ((visibility("default"))) int sd_bus_message_set_sender(sd_bus_message *m, const char *sender) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5516, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(sender, -EINVAL)do { if (!(((__builtin_expect(!!(sender),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("sender"), "../src/libsystemd/sd-bus/bus-message.c"
, 5517, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5518, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->sender, -EEXIST)do { if (!(((__builtin_expect(!!(!m->sender),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sender"
), "../src/libsystemd/sd-bus/bus-message.c", 5519, __PRETTY_FUNCTION__
), 0))) return (-17); } while (0);

      return message_append_field_string(m, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, sender, &m->sender);
5522}

5524int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
      size_t total;
      void *p, *e;
      size_t i;
      struct bus_body_part *part;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5530, __PRETTY_FUNCTION__); } while (0);
      assert(buffer)do { if ((__builtin_expect(!!(!(buffer)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("buffer"), "../src/libsystemd/sd-bus/bus-message.c"
, 5531, __PRETTY_FUNCTION__); } while (0);
      assert(sz)do { if ((__builtin_expect(!!(!(sz)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sz"), "../src/libsystemd/sd-bus/bus-message.c"
, 5532, __PRETTY_FUNCTION__); } while (0);

      total = BUS_MESSAGE_SIZE(m);

      p = malloc(total);
      if (!p)
              return -ENOMEM12;

      e = mempcpy(p, m->header, BUS_MESSAGE_BODY_BEGIN(m));
      MESSAGE_FOREACH_PART(part, i, m)for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts
; (i)++, (part) = (part)->next)
              e = mempcpy(e, part->data, part->size);

      assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p))do { if ((__builtin_expect(!!(!(total == (size_t) ((uint8_t*)
 e - (uint8_t*) p))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("total == (size_t) ((uint8_t*) e - (uint8_t*) p)"), "../src/libsystemd/sd-bus/bus-message.c"
, 5544, __PRETTY_FUNCTION__); } while (0);

      *buffer = p;
      *sz = total;

      return 0;
5550}

5552int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
      const char *s;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5556, __PRETTY_FUNCTION__); } while (0);
      assert(l)do { if ((__builtin_expect(!!(!(l)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("l"), "../src/libsystemd/sd-bus/bus-message.c"
, 5557, __PRETTY_FUNCTION__); } while (0);

      r = sd_bus_message_enter_container(m, 'a', "s");
      if (r <= 0)
              return r;

      while ((r = sd_bus_message_read_basic(m, 's', &s)) > 0) {
              r = strv_extend(l, s);
              if (r < 0)
                      return r;
      }
      if (r < 0)
              return r;

      r = sd_bus_message_exit_container(m);
      if (r < 0)
              return r;

      return 1;
5576}

5578_public___attribute__ ((visibility("default"))) int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
      _cleanup_strv_free___attribute__((cleanup(strv_freep))) char **strv = NULL((void*)0);
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5582, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5583, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(l, -EINVAL)do { if (!(((__builtin_expect(!!(l),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("l"), "../src/libsystemd/sd-bus/bus-message.c"
, 5584, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = bus_message_read_strv_extend(m, &strv);
      if (r <= 0)
              return r;

      *l = TAKE_PTR(strv)({ typeof(strv) _ptr_ = (strv); (strv) = ((void*)0); _ptr_; }
);
      return 1;
5592}

5594static int bus_message_get_arg_skip(
              sd_bus_message *m,
              unsigned i,
              char *_type,
              const char **_contents) {

      unsigned j;
      int r;

      r = sd_bus_message_rewind(m, true1);
      if (r < 0)
              return r;

      for (j = 0;; j++) {
              const char *contents;
              char type;

              r = sd_bus_message_peek_type(m, &type, &contents);
              if (r < 0)
                      return r;
              if (r == 0)
                      return -ENXIO6;

              /* Don't match against arguments after the first one we don't understand */
              if (!IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH
, SD_BUS_TYPE_SIGNATURE})/sizeof(int)]; switch(type) { case SD_BUS_TYPE_STRING
: case SD_BUS_TYPE_OBJECT_PATH: case SD_BUS_TYPE_SIGNATURE: _found
 = 1; break; default: break; } _found; }) &&
                  !(type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")(!!strv_find((((char**) ((const char*[]) { "s", "o", "g", ((void
*)0) }))), (contents)))))
                      return -ENXIO6;

              if (j >= i) {
                      if (_contents)
                              *_contents = contents;
                      if (_type)
                              *_type = type;
                      return 0;
              }

              r = sd_bus_message_skip(m, NULL((void*)0));
              if (r < 0)
                      return r;
      }

5635}

5637int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str) {
      char type;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5641, __PRETTY_FUNCTION__); } while (0);
      assert(str)do { if ((__builtin_expect(!!(!(str)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("str"), "../src/libsystemd/sd-bus/bus-message.c"
, 5642, __PRETTY_FUNCTION__); } while (0);

      r = bus_message_get_arg_skip(m, i, &type, NULL((void*)0));
      if (r < 0)
              return r;

      if (!IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH
, SD_BUS_TYPE_SIGNATURE})/sizeof(int)]; switch(type) { case SD_BUS_TYPE_STRING
: case SD_BUS_TYPE_OBJECT_PATH: case SD_BUS_TYPE_SIGNATURE: _found
 = 1; break; default: break; } _found; }))
              return -ENXIO6;

      return sd_bus_message_read_basic(m, type, str);
5652}

5654int bus_message_get_arg_strv(sd_bus_message *m, unsigned i, char ***strv) {
      const char *contents;
      char type;
      int r;

      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5659, __PRETTY_FUNCTION__); } while (0);
      assert(strv)do { if ((__builtin_expect(!!(!(strv)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("strv"), "../src/libsystemd/sd-bus/bus-message.c"
, 5660, __PRETTY_FUNCTION__); } while (0);

      r = bus_message_get_arg_skip(m, i, &type, &contents);
      if (r < 0)
              return r;

      if (type != SD_BUS_TYPE_ARRAY)
              return -ENXIO6;
      if (!STR_IN_SET(contents, "s", "o", "g")(!!strv_find((((char**) ((const char*[]) { "s", "o", "g", ((void
*)0) }))), (contents))))
              return -ENXIO6;

      return sd_bus_message_read_strv(m, strv);
5672}

5674_public___attribute__ ((visibility("default"))) int sd_bus_message_get_errno(sd_bus_message *m) {
      assert_return(m, EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5675, __PRETTY_FUNCTION__), 0))) return (22); } while (0);

      if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
              return 0;

      return sd_bus_error_get_errno(&m->error);
5681}

5683_public___attribute__ ((visibility("default"))) const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
      struct bus_container *c;

      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5686, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      c = complete ? &m->root_container : message_get_last_container(m);
      return strempty(c->signature);
5690}

5692_public___attribute__ ((visibility("default"))) int sd_bus_message_is_empty(sd_bus_message *m) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5693, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      return isempty(m->root_container.signature);
5696}

5698_public___attribute__ ((visibility("default"))) int sd_bus_message_has_signature(sd_bus_message *m, const char *signature) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5699, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      return streq(strempty(m->root_container.signature), strempty(signature))(strcmp((strempty(m->root_container.signature)),(strempty(
signature))) == 0);
5702}

5704_public___attribute__ ((visibility("default"))) int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
      bool_Bool done_something = false0;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5708, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(source, -EINVAL)do { if (!(((__builtin_expect(!!(source),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("source"), "../src/libsystemd/sd-bus/bus-message.c"
, 5709, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5710, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(source->sealed, -EPERM)do { if (!(((__builtin_expect(!!(source->sealed),1))) ? (1
) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("source->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5711, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      do {
              const char *contents;
              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(source, &type, &contents);
              if (r < 0)
                      return r;
              if (r == 0)
                      break;

              done_something = true1;

              if (bus_type_is_container(type) > 0) {

                      r = sd_bus_message_enter_container(source, type, contents);
                      if (r < 0)
                              return r;

                      r = sd_bus_message_open_container(m, type, contents);
                      if (r < 0)
                              return r;

                      r = sd_bus_message_copy(m, source, true1);
                      if (r < 0)
                              return r;

                      r = sd_bus_message_close_container(m);
                      if (r < 0)
                              return r;

                      r = sd_bus_message_exit_container(source);
                      if (r < 0)
                              return r;

                      continue;
              }

              r = sd_bus_message_read_basic(source, type, &basic);
              if (r < 0)
                      return r;

              assert(r > 0)do { if ((__builtin_expect(!!(!(r > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("r > 0"), "../src/libsystemd/sd-bus/bus-message.c"
, 5766, __PRETTY_FUNCTION__); } while (0);

              if (IN_SET(type, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE, SD_BUS_TYPE_STRING)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE
, SD_BUS_TYPE_STRING})/sizeof(int)]; switch(type) { case SD_BUS_TYPE_OBJECT_PATH
: case SD_BUS_TYPE_SIGNATURE: case SD_BUS_TYPE_STRING: _found
 = 1; break; default: break; } _found; }))
                      r = sd_bus_message_append_basic(m, type, basic.string);
              else
                      r = sd_bus_message_append_basic(m, type, &basic);

              if (r < 0)
                      return r;

      } while (all);

      return done_something;
5779}

5781_public___attribute__ ((visibility("default"))) int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
      const char *c;
      char t;
      int r;

      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5786, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5787, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!type || bus_type_is_valid(type), -EINVAL)do { if (!(((__builtin_expect(!!(!type || bus_type_is_valid(type
)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("!type || bus_type_is_valid(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 5788, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!contents || signature_is_valid(contents, true), -EINVAL)do { if (!(((__builtin_expect(!!(!contents || signature_is_valid
(contents, 1)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("!contents || signature_is_valid(contents, true)"), "../src/libsystemd/sd-bus/bus-message.c"
, 5789, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(type || contents, -EINVAL)do { if (!(((__builtin_expect(!!(type || contents),1))) ? (1)
 : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("type || contents"
), "../src/libsystemd/sd-bus/bus-message.c", 5790, __PRETTY_FUNCTION__
), 0))) return (-22); } while (0);
      assert_return(!contents || !type || bus_type_is_container(type), -EINVAL)do { if (!(((__builtin_expect(!!(!contents || !type || bus_type_is_container
(type)),1))) ? (1) : (log_assert_failed_return_realm(LOG_REALM_SYSTEMD
, ("!contents || !type || bus_type_is_container(type)"), "../src/libsystemd/sd-bus/bus-message.c"
, 5791, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      r = sd_bus_message_peek_type(m, &t, &c);
      if (r <= 0)
              return r;

      if (type != 0 && type != t)
              return 0;

      if (contents && !streq_ptr(contents, c))
              return 0;

      return 1;
5804}

5806_public___attribute__ ((visibility("default"))) sd_bus *sd_bus_message_get_bus(sd_bus_message *m) {
      assert_return(m, NULL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5807, __PRETTY_FUNCTION__), 0))) return (((void*)0)); } while
 (0);

      return m->bus;
5810}

5812int bus_message_remarshal(sd_bus *bus, sd_bus_message **m) {
      _cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *n = NULL((void*)0);
      usec_t timeout;
      int r;

      assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/libsystemd/sd-bus/bus-message.c"
, 5817, __PRETTY_FUNCTION__); } while (0);
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5818, __PRETTY_FUNCTION__); } while (0);
      assert(*m)do { if ((__builtin_expect(!!(!(*m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("*m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5819, __PRETTY_FUNCTION__); } while (0);

      switch ((*m)->header->type) {

      case SD_BUS_MESSAGE_SIGNAL:
              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, &n, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member);
              if (r < 0)
                      return r;

              break;

      case SD_BUS_MESSAGE_METHOD_RETURN:
      case SD_BUS_MESSAGE_METHOD_ERROR:

              r = sd_bus_message_new(bus, &n, (*m)->header->type);
              if (r < 0)
                      return -ENOMEM12;

              assert(n)do { if ((__builtin_expect(!!(!(n)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("n"), "../src/libsystemd/sd-bus/bus-message.c"
, 5844, __PRETTY_FUNCTION__); } while (0);

              n->reply_cookie = (*m)->reply_cookie;

              r = message_append_reply_cookie(n, n->reply_cookie);
              if (r < 0)
                      return r;

              if ((*m)->header->type == SD_BUS_MESSAGE_METHOD_ERROR && (*m)->error.name) {
                      r = message_append_field_string(n, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, (*m)->error.name, &n->error.message);
                      if (r < 0)
                              return r;

                      n->error._need_free = -1;
              }

              break;

      default:
              return -EINVAL22;
      }

      if ((*m)->destination && !n->destination) {
              r = message_append_field_string(n, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, (*m)->destination, &n->destination);
              if (r < 0)
                      return r;
      }

      if ((*m)->sender && !n->sender) {
              r = message_append_field_string(n, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, (*m)->sender, &n->sender);
              if (r < 0)
                      return r;
      }

      n->header->flags |= (*m)->header->flags & (BUS_MESSAGE_NO_REPLY_EXPECTED|BUS_MESSAGE_NO_AUTO_START);

      r = sd_bus_message_copy(n, *m, true1);
      if (r < 0)
              return r;

      timeout = (*m)->timeout;
      if (timeout == 0 && !((*m)->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED))
              timeout = BUS_DEFAULT_TIMEOUT((usec_t) (25 * ((usec_t) 1000000ULL)));

      r = sd_bus_message_seal(n, BUS_MESSAGE_COOKIE(*m), timeout);
      if (r < 0)
              return r;

      sd_bus_message_unref(*m);
      *m = TAKE_PTR(n)({ typeof(n) _ptr_ = (n); (n) = ((void*)0); _ptr_; });

      return 0;
5896}

5898int bus_message_append_sender(sd_bus_message *m, const char *sender) {
      assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5899, __PRETTY_FUNCTION__); } while (0);
      assert(sender)do { if ((__builtin_expect(!!(!(sender)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("sender"), "../src/libsystemd/sd-bus/bus-message.c"
, 5900, __PRETTY_FUNCTION__); } while (0);

      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5902, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);
      assert_return(!m->sender, -EPERM)do { if (!(((__builtin_expect(!!(!m->sender),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sender"
), "../src/libsystemd/sd-bus/bus-message.c", 5903, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      return message_append_field_string(m, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, sender, &m->sender);
5906}

5908_public___attribute__ ((visibility("default"))) int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5909, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(priority, -EINVAL)do { if (!(((__builtin_expect(!!(priority),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("priority"), "../src/libsystemd/sd-bus/bus-message.c"
, 5910, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);

      *priority = m->priority;
      return 0;
5914}

5916_public___attribute__ ((visibility("default"))) int sd_bus_message_set_priority(sd_bus_message *m, int64_t priority) {
      assert_return(m, -EINVAL)do { if (!(((__builtin_expect(!!(m),1))) ? (1) : (log_assert_failed_return_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/libsystemd/sd-bus/bus-message.c"
, 5917, __PRETTY_FUNCTION__), 0))) return (-22); } while (0);
      assert_return(!m->sealed, -EPERM)do { if (!(((__builtin_expect(!!(!m->sealed),1))) ? (1) : (
log_assert_failed_return_realm(LOG_REALM_SYSTEMD, ("!m->sealed"
), "../src/libsystemd/sd-bus/bus-message.c", 5918, __PRETTY_FUNCTION__
), 0))) return (-1); } while (0);

      m->priority = priority;
      return 0;
5922}