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

Bug Summary

File:	build-scan/../src/libsystemd/sd-bus/bus-message.c
Warning:	line 1384, column 58 Use of memory after it is freed
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);
      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);
      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);
      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);
      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);

      if (header_accessible < sizeof(struct bus_header))
              return -EBADMSG74;

      if (header_accessible > message_size)
              return -EBADMSG74;
      if (footer_accessible > message_size)
              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
; }))
              return -EBADMSG74;

      if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
              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; }))
              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) {
              label_sz = strlen(label);
              a += label_sz + 1;
      }

      m = malloc0(a)(calloc(1, (a)));
      if (!m)
              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)) {
              size_t ws;

              if (h->dbus2.cookie == 0)
                      return -EBADMSG74;

              /* 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(
                      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);
51
←
Taking false branch→
52
←
Loop condition is false.  Exiting loop→
92
←
Taking false branch→
93
←
Loop condition is false.  Exiting loop→
      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);
53
←
Taking false branch→
54
←
Loop condition is false.  Exiting loop→
94
←
Taking false branch→
95
←
Loop condition is false.  Exiting loop→
      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);
55
←
Assuming field 'sealed' is false→
56
←
Taking false branch→
57
←
Loop condition is false.  Exiting loop→
96
←
Taking false branch→
97
←
Loop condition is false.  Exiting loop→

      if (m->poisoned57.1
Field 'poisoned' is false
1
Field 'poisoned' is false
)
58
←
Taking false branch→
98
←
Taking false branch→
              return -ENOMEM12;

      if (part->allocated98.1
Field 'allocated' is not equal to 0
 == 0 || sz59.1
'sz' is <= field 'allocated'
 > part->allocated) {
59
←
Assuming field 'allocated' is not equal to 0→
60
←
Taking false branch→
99
←
Assuming 'sz' is > field 'allocated'→
100
←
Taking true branch→
              size_t new_allocated;

              new_allocated = sz100.1
'sz' is > 0
 > 0 ? 2 * sz : 64;
101
←
'?' condition is true→
              n = realloc(part->data, new_allocated);
102
←
Memory is released→
              if (!n) {
103
←
Assuming 'n' is non-null→
104
←
Taking false branch→
                      m->poisoned = true1;
                      return -ENOMEM12;
              }

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

      if (q60.1
'q' is non-null
1
'q' is non-null
)
61
←
Taking true branch→
105
←
Taking true branch→
              *q = part->data105.1
Field 'data' is non-null
 ? (uint8_t*) part->data + part->size : NULL((void*)0);
62
←
Assuming field 'data' is non-null→
63
←
'?' condition is true→
106
←
'?' condition is true→

      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);
38
←
Taking false branch→
39
←
Loop condition is false.  Exiting loop→
78
←
Taking false branch→
79
←
Loop condition is false.  Exiting loop→
      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);
40
←
Taking false branch→
41
←
Loop condition is false.  Exiting loop→
80
←
Taking false branch→
81
←
Loop condition is false.  Exiting loop→
      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);
42
←
Taking false branch→
43
←
Loop condition is false.  Exiting loop→
82
←
Taking false branch→
83
←
Loop condition is false.  Exiting loop→

      if (m->poisoned43.1
Field 'poisoned' is false
1
Field 'poisoned' is false
)
44
←
Taking false branch→
84
←
Taking false branch→
              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) ||
45
←
Taking false branch→
85
←
Assuming the condition is false→
87
←
Taking false branch→
          end_body44.1
'end_body' is >= 'start_body'
 < start_body) {
86
←
Assuming 'end_body' is >= 'start_body'→
              m->poisoned = true1;
              return NULL((void*)0);
      }

      if (added45.1
'added' is > 0
 > 0) {
46
←
Taking true branch→
88
←
Assuming 'added' is > 0→
89
←
Taking true branch→
              struct bus_body_part *part = NULL((void*)0);
              bool_Bool add_new_part;

              add_new_part =
                      m->n_body_parts46.1
Field 'n_body_parts' is <= 0
1
Field 'n_body_parts' is > 0
 <= 0 ||
                      m->body_end->sealed89.2
Field 'sealed' is false
 ||
                      (padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size) ||
                      (force_inline89.3
'force_inline' is true
 && 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_part46.2
'add_new_part' is true
4
'add_new_part' is false
) {
47
←
Taking true branch→
90
←
Taking false branch→
                      if (padding47.1
'padding' is <= 0
 > 0) {
48
←
Taking false branch→
                              part = message_append_part(m);
                              if (!part)
                                      return NULL((void*)0);

                              part_zero(part, padding);
                      }

                      part = message_append_part(m);
                      if (!part48.1
'part' is non-null
)
49
←
Taking false branch→
                              return NULL((void*)0);

                      r = part_make_space(m, part, sz, &p);
50
←
Calling 'part_make_space'→
64
←
Returning from 'part_make_space'→
                      if (r64.1
'r' is >= 0
 < 0)
65
←
Taking false branch→
                              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);
91
←
Calling 'part_make_space'→
107
←
Returning; memory was released→
                      if (r107.1
'r' is >= 0
 < 0)
108
←
Taking false branch→
                              return NULL((void*)0);

                      if (padding108.1
'padding' is <= 0
 > 0) {
109
←
Taking false branch→
                              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++)
110
←
Loop condition is false. Execution continues on line 1384→
                              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);
111
←
Use of memory after it is freed
              }
      } 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_offset65.1
'add_offset' is false
) {
66
←
Taking false branch→
              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);
26
←
Taking false branch→
27
←
Loop condition is false.  Exiting loop→
      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);
28
←
Taking false branch→
29
←
Loop condition is false.  Exiting loop→

      if (!BUS_MESSAGE_IS_GVARIANT(m))
30
←
Taking false branch→
              return 0;

      p = strempty(c->signature);
      while (*p != 0) {
31
←
Loop condition is false. Execution continues on line 2170→
              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);
32
←
Taking false branch→
33
←
Loop condition is false.  Exiting loop→
      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);
34
←
Taking false branch→
35
←
Loop condition is false.  Exiting loop→

      if (isempty(c->signature)) {
36
←
Taking true branch→
              /* The unary type is encoded as fixed 1 byte padding */
              a = message_extend_body(m, 1, 1, add_offset, false0);
37
←
Calling 'message_extend_body'→
67
←
Returning from 'message_extend_body'→
              if (!a67.1
'a' is non-null
)
68
←
Taking false branch→
                      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_12 { 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);
73
←
Taking false branch→
74
←
Loop condition is false.  Exiting loop→

      /* 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)) {
75
←
Taking true branch→
              const char *signature;
              size_t sz, l;
              void *d;

              /* Add offset table to end of fields array */
              if (m->n_header_offsets75.1
Field 'n_header_offsets' is < 1
 >= 1) {
76
←
Taking false branch→
                      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);
77
←
Calling 'message_extend_body'→
              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);
18
←
'?' condition is true→
19
←
Taking false branch→
20
←
Loop condition is false.  Exiting loop→

      if (m->sealed20.1
Field 'sealed' is false
)
21
←
Taking false branch→
              return -EPERM1;

      if (m->n_containers21.1
Field 'n_containers' is <= 0
 > 0)
22
←
Taking false branch→
              return -EBADMSG74;

      if (m->poisoned22.1
Field 'poisoned' is false
)
23
←
Taking false branch→
              return -ESTALE116;

      if (cookie23.1
'cookie' is <= 4294967295
 > 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 &&
24
←
Assuming field 'type' is not equal to 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);
25
←
Calling 'bus_message_close_struct'→
69
←
Returning from 'bus_message_close_struct'→
      if (r69.1
'r' is >= 0
 < 0)
70
←
Taking false branch→
              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_fds70.1
Field 'n_fds' is <= 0
 > 0) {
71
←
Taking false branch→
              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);
72
←
Calling 'bus_message_close_header'→
      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);
1
Assuming 'bus' is non-null→
2
←
Taking false branch→
3
←
Loop condition is false.  Exiting loop→
      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);
4
←
Assuming 'm' is non-null→
5
←
Taking false branch→
6
←
Loop condition is false.  Exiting loop→
      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);
7
←
Assuming the condition is false→
8
←
Taking false branch→
9
←
Loop condition is false.  Exiting loop→

      switch ((*m)->header->type) {
10
←
Control jumps to 'case SD_BUS_MESSAGE_SIGNAL:'  at line 5823→

      case SD_BUS_MESSAGE_SIGNAL:
              r = sd_bus_message_new_signal(bus, &n, (*m)->path, (*m)->interface, (*m)->member);
              if (r10.1
'r' is >= 0
 < 0)
11
←
Taking false branch→
                      return r;

              break;
12
←
 Execution continues on line 5866→

      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) {
13
←
Assuming field 'destination' is null→
              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) {
14
←
Assuming field 'sender' is null→
              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 (r14.1
'r' is >= 0
 < 0)
15
←
Taking false branch→
              return r;

      timeout = (*m)->timeout;
      if (timeout == 0 && !((*m)->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED))
16
←
Assuming 'timeout' is not equal to 0→
              timeout = BUS_DEFAULT_TIMEOUT((usec_t) (25 * ((usec_t) 1000000ULL)));

      r = sd_bus_message_seal(n, BUS_MESSAGE_COOKIE(*m), timeout);
17
←
Calling 'sd_bus_message_seal'→
      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}