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

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <sys/mman.h>
  25
  26 #include "util.h"
  27 #include "utf8.h"
  28 #include "strv.h"
  29 #include "time-util.h"
  30 #include "cgroup-util.h"
  31 #include "memfd-util.h"
  32
  33 #include "sd-bus.h"
  34 #include "bus-message.h"
  35 #include "bus-internal.h"
  36 #include "bus-type.h"
  37 #include "bus-signature.h"
  38 #include "bus-gvariant.h"
  39 #include "bus-util.h"
  40
  41 static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);
  42
  43 static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {
  44
  45         if (p == NULL)
  46                 return NULL;
  47
  48         if (old_base == new_base)
  49                 return (void*) p;
  50
  51         if ((uint8_t*) p < (uint8_t*) old_base)
  52                 return (void*) p;
  53
  54         if ((uint8_t*) p >= (uint8_t*) old_base + sz)
  55                 return (void*) p;
  56
  57         return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base);
  58 }
  59
  60 static void message_free_part(sd_bus_message *m, struct bus_body_part *part) {
  61         assert(m);
  62         assert(part);
  63
  64         if (part->memfd >= 0) {
  65                 /* If we can reuse the memfd, try that. For that it
  66                  * can't be sealed yet. */
  67
  68                 if (!part->sealed)
  69                         bus_kernel_push_memfd(m->bus, part->memfd, part->data, part->mapped, part->allocated);
  70                 else {
  71                         if (part->mapped > 0)
  72                                 assert_se(munmap(part->data, part->mapped) == 0);
  73
  74                         safe_close(part->memfd);
  75                 }
  76
  77         } else if (part->munmap_this)
  78                 munmap(part->data, part->mapped);
  79         else if (part->free_this)
  80                 free(part->data);
  81
  82         if (part != &m->body)
  83                 free(part);
  84 }
  85
  86 static void message_reset_parts(sd_bus_message *m) {
  87         struct bus_body_part *part;
  88
  89         assert(m);
  90
  91         part = &m->body;
  92         while (m->n_body_parts > 0) {
  93                 struct bus_body_part *next = part->next;
  94                 message_free_part(m, part);
  95                 part = next;
  96                 m->n_body_parts--;
  97         }
  98
  99         m->body_end = NULL;
 100
 101         m->cached_rindex_part = NULL;
 102         m->cached_rindex_part_begin = 0;
 103 }
 104
 105 static void message_reset_containers(sd_bus_message *m) {
 106         unsigned i;
 107
 108         assert(m);
 109
 110         for (i = 0; i < m->n_containers; i++) {
 111                 free(m->containers[i].signature);
 112                 free(m->containers[i].offsets);
 113         }
 114
 115         free(m->containers);
 116         m->containers = NULL;
 117
 118         m->n_containers = m->containers_allocated = 0;
 119         m->root_container.index = 0;
 120 }
 121
 122 static void message_free(sd_bus_message *m) {
 123         assert(m);
 124
 125         if (m->free_header)
 126                 free(m->header);
 127
 128         message_reset_parts(m);
 129
 130         if (m->release_kdbus) {
 131                 struct kdbus_cmd_free cmd_free;
 132
 133                 cmd_free.flags = 0;
 134                 cmd_free.offset = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer;
 135                 (void) ioctl(m->bus->input_fd, KDBUS_CMD_FREE, &cmd_free);
 136         }
 137
 138         if (m->free_kdbus)
 139                 free(m->kdbus);
 140
 141         sd_bus_unref(m->bus);
 142
 143         if (m->free_fds) {
 144                 close_many(m->fds, m->n_fds);
 145                 free(m->fds);
 146         }
 147
 148         if (m->iovec != m->iovec_fixed)
 149                 free(m->iovec);
 150
 151         if (m->destination_ptr) {
 152                 free(m->destination_ptr);
 153                 m->destination_ptr = NULL;
 154         }
 155
 156         message_reset_containers(m);
 157         free(m->root_container.signature);
 158         free(m->root_container.offsets);
 159
 160         free(m->root_container.peeked_signature);
 161
 162         bus_creds_done(&m->creds);
 163         free(m);
 164 }
 165
 166 static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz, bool add_offset) {
 167         void *op, *np;
 168         size_t old_size, new_size, start;
 169
 170         assert(m);
 171
 172         if (m->poisoned)
 173                 return NULL;
 174
 175         old_size = sizeof(struct bus_header) + m->header->fields_size;
 176         start = ALIGN_TO(old_size, align);
 177         new_size = start + sz;
 178
 179         if (old_size == new_size)
 180                 return (uint8_t*) m->header + old_size;
 181
 182         if (new_size > (size_t) ((uint32_t) -1))
 183                 goto poison;
 184
 185         if (m->free_header) {
 186                 np = realloc(m->header, ALIGN8(new_size));
 187                 if (!np)
 188                         goto poison;
 189         } else {
 190                 /* Initially, the header is allocated as part of of
 191                  * the sd_bus_message itself, let's replace it by
 192                  * dynamic data */
 193
 194                 np = malloc(ALIGN8(new_size));
 195                 if (!np)
 196                         goto poison;
 197
 198                 memcpy(np, m->header, sizeof(struct bus_header));
 199         }
 200
 201         /* Zero out padding */
 202         if (start > old_size)
 203                 memzero((uint8_t*) np + old_size, start - old_size);
 204
 205         op = m->header;
 206         m->header = np;
 207         m->header->fields_size = new_size - sizeof(struct bus_header);
 208
 209         /* Adjust quick access pointers */
 210         m->path = adjust_pointer(m->path, op, old_size, m->header);
 211         m->interface = adjust_pointer(m->interface, op, old_size, m->header);
 212         m->member = adjust_pointer(m->member, op, old_size, m->header);
 213         m->destination = adjust_pointer(m->destination, op, old_size, m->header);
 214         m->sender = adjust_pointer(m->sender, op, old_size, m->header);
 215         m->error.name = adjust_pointer(m->error.name, op, old_size, m->header);
 216
 217         m->free_header = true;
 218
 219         if (add_offset) {
 220                 if (m->n_header_offsets >= ELEMENTSOF(m->header_offsets))
 221                         goto poison;
 222
 223                 m->header_offsets[m->n_header_offsets++] = new_size - sizeof(struct bus_header);
 224         }
 225
 226         return (uint8_t*) np + start;
 227
 228 poison:
 229         m->poisoned = true;
 230         return NULL;
 231 }
 232
 233 static int message_append_field_string(
 234                 sd_bus_message *m,
 235                 uint8_t h,
 236                 char type,
 237                 const char *s,
 238                 const char **ret) {
 239
 240         size_t l;
 241         uint8_t *p;
 242
 243         assert(m);
 244
 245         /* dbus1 doesn't allow strings over 32bit, let's enforce this
 246          * globally, to not risk convertability */
 247         l = strlen(s);
 248         if (l > (size_t) (uint32_t) -1)
 249                 return -EINVAL;
 250
 251         /* Signature "(yv)" where the variant contains "s" */
 252
 253         if (BUS_MESSAGE_IS_GVARIANT(m)) {
 254
 255                 /* (field id byte + 7x padding, ((string + NUL) + NUL + signature string 's') */
 256                 p = message_extend_fields(m, 8, 1 + 7 + l + 1 + 1 + 1, true);
 257                 if (!p)
 258                         return -ENOMEM;
 259
 260                 p[0] = h;
 261                 memzero(p+1, 7);
 262                 memcpy(p+8, s, l);
 263                 p[8+l] = 0;
 264                 p[8+l+1] = 0;
 265                 p[8+l+2] = type;
 266
 267                 if (ret)
 268                         *ret = (char*) p + 8;
 269
 270         } else {
 271                 /* (field id byte + (signature length + signature 's' + NUL) + (string length + string + NUL)) */
 272                 p = message_extend_fields(m, 8, 4 + 4 + l + 1, false);
 273                 if (!p)
 274                         return -ENOMEM;
 275
 276                 p[0] = h;
 277                 p[1] = 1;
 278                 p[2] = type;
 279                 p[3] = 0;
 280
 281                 ((uint32_t*) p)[1] = l;
 282                 memcpy(p + 8, s, l + 1);
 283
 284                 if (ret)
 285                         *ret = (char*) p + 8;
 286         }
 287
 288         return 0;
 289 }
 290
 291 static int message_append_field_signature(
 292                 sd_bus_message *m,
 293                 uint8_t h,
 294                 const char *s,
 295                 const char **ret) {
 296
 297         size_t l;
 298         uint8_t *p;
 299
 300         assert(m);
 301
 302         /* dbus1 doesn't allow signatures over 32bit, let's enforce
 303          * this globally, to not risk convertability */
 304         l = strlen(s);
 305         if (l > 255)
 306                 return -EINVAL;
 307
 308         /* Signature "(yv)" where the variant contains "g" */
 309
 310         if (BUS_MESSAGE_IS_GVARIANT(m))
 311                 /* For gvariant the serialization is the same as for normal strings */
 312                 return message_append_field_string(m, h, 'g', s, ret);
 313         else {
 314                 /* (field id byte + (signature length + signature 'g' + NUL) + (string length + string + NUL)) */
 315                 p = message_extend_fields(m, 8, 4 + 1 + l + 1, false);
 316                 if (!p)
 317                         return -ENOMEM;
 318
 319                 p[0] = h;
 320                 p[1] = 1;
 321                 p[2] = SD_BUS_TYPE_SIGNATURE;
 322                 p[3] = 0;
 323                 p[4] = l;
 324                 memcpy(p + 5, s, l + 1);
 325
 326                 if (ret)
 327                         *ret = (const char*) p + 5;
 328         }
 329
 330         return 0;
 331 }
 332
 333 static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) {
 334         uint8_t *p;
 335
 336         assert(m);
 337
 338         if (BUS_MESSAGE_IS_GVARIANT(m)) {
 339                 /* (field id byte + 7x padding + ((value + NUL + signature string 'u') */
 340
 341                 p = message_extend_fields(m, 8, 1 + 7 + 4 + 1 + 1, true);
 342                 if (!p)
 343                         return -ENOMEM;
 344
 345                 p[0] = h;
 346                 memzero(p+1, 7);
 347                 *((uint32_t*) (p + 8)) = x;
 348                 p[12] = 0;
 349                 p[13] = 'u';
 350         } else {
 351                 /* (field id byte + (signature length + signature 'u' + NUL) + value) */
 352                 p = message_extend_fields(m, 8, 4 + 4, false);
 353                 if (!p)
 354                         return -ENOMEM;
 355
 356                 p[0] = h;
 357                 p[1] = 1;
 358                 p[2] = SD_BUS_TYPE_UINT32;
 359                 p[3] = 0;
 360
 361                 ((uint32_t*) p)[1] = x;
 362         }
 363
 364         return 0;
 365 }
 366
 367 int bus_message_from_header(
 368                 sd_bus *bus,
 369                 void *buffer,
 370                 size_t length,
 371                 int *fds,
 372                 unsigned n_fds,
 373                 const struct ucred *ucred,
 374                 const char *label,
 375                 size_t extra,
 376                 sd_bus_message **ret) {
 377
 378         sd_bus_message *m;
 379         struct bus_header *h;
 380         size_t a, label_sz;
 381
 382         assert(bus);
 383         assert(buffer || length <= 0);
 384         assert(fds || n_fds <= 0);
 385         assert(ret);
 386
 387         if (length < sizeof(struct bus_header))
 388                 return -EBADMSG;
 389
 390         h = buffer;
 391         if (h->version != 1 &&
 392             h->version != 2)
 393                 return -EBADMSG;
 394
 395         if (h->serial == 0)
 396                 return -EBADMSG;
 397
 398         if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
 399                 return -EBADMSG;
 400
 401         if (h->endian != BUS_LITTLE_ENDIAN &&
 402             h->endian != BUS_BIG_ENDIAN)
 403                 return -EBADMSG;
 404
 405         a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
 406
 407         if (label) {
 408                 label_sz = strlen(label);
 409                 a += label_sz + 1;
 410         }
 411
 412         m = malloc0(a);
 413         if (!m)
 414                 return -ENOMEM;
 415
 416         m->n_ref = 1;
 417         m->sealed = true;
 418         m->header = h;
 419         m->fds = fds;
 420         m->n_fds = n_fds;
 421
 422         if (ucred) {
 423                 m->creds.pid = ucred->pid;
 424                 m->creds.uid = ucred->uid;
 425                 m->creds.gid = ucred->gid;
 426
 427                 /* Due to namespace translations some data might be
 428                  * missing from this ucred record. */
 429                 if (m->creds.pid > 0)
 430                         m->creds.mask |= SD_BUS_CREDS_PID;
 431
 432                 if (m->creds.uid != UID_INVALID)
 433                         m->creds.mask |= SD_BUS_CREDS_UID;
 434
 435                 if (m->creds.gid != GID_INVALID)
 436                         m->creds.mask |= SD_BUS_CREDS_GID;
 437         }
 438
 439         if (label) {
 440                 m->creds.label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
 441                 memcpy(m->creds.label, label, label_sz + 1);
 442
 443                 m->creds.mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
 444         }
 445
 446         m->bus = sd_bus_ref(bus);
 447         *ret = m;
 448
 449         return 0;
 450 }
 451
 452 int bus_message_from_malloc(
 453                 sd_bus *bus,
 454                 void *buffer,
 455                 size_t length,
 456                 int *fds,
 457                 unsigned n_fds,
 458                 const struct ucred *ucred,
 459                 const char *label,
 460                 sd_bus_message **ret) {
 461
 462         sd_bus_message *m;
 463         size_t sz;
 464         int r;
 465
 466         r = bus_message_from_header(bus, buffer, length, fds, n_fds, ucred, label, 0, &m);
 467         if (r < 0)
 468                 return r;
 469
 470         if (length != BUS_MESSAGE_SIZE(m)) {
 471                 r = -EBADMSG;
 472                 goto fail;
 473         }
 474
 475         sz = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 476         if (sz > 0) {
 477                 m->n_body_parts = 1;
 478                 m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 479                 m->body.size = sz;
 480                 m->body.sealed = true;
 481                 m->body.memfd = -1;
 482         }
 483
 484         m->n_iovec = 1;
 485         m->iovec = m->iovec_fixed;
 486         m->iovec[0].iov_base = buffer;
 487         m->iovec[0].iov_len = length;
 488
 489         r = bus_message_parse_fields(m);
 490         if (r < 0)
 491                 goto fail;
 492
 493         /* We take possession of the memory and fds now */
 494         m->free_header = true;
 495         m->free_fds = true;
 496
 497         *ret = m;
 498         return 0;
 499
 500 fail:
 501         message_free(m);
 502         return r;
 503 }
 504
 505 static sd_bus_message *message_new(sd_bus *bus, uint8_t type) {
 506         sd_bus_message *m;
 507
 508         assert(bus);
 509
 510         m = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header));
 511         if (!m)
 512                 return NULL;
 513
 514         m->n_ref = 1;
 515         m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message)));
 516         m->header->endian = BUS_NATIVE_ENDIAN;
 517         m->header->type = type;
 518         m->header->version = bus ? bus->message_version : 1;
 519         m->allow_fds = !bus || bus->can_fds || (bus->state != BUS_HELLO && bus->state != BUS_RUNNING);
 520         m->root_container.need_offsets = BUS_MESSAGE_IS_GVARIANT(m);
 521         m->bus = sd_bus_ref(bus);
 522
 523         return m;
 524 }
 525
 526 _public_ int sd_bus_message_new_signal(
 527                 sd_bus *bus,
 528                 sd_bus_message **m,
 529                 const char *path,
 530                 const char *interface,
 531                 const char *member) {
 532
 533         sd_bus_message *t;
 534         int r;
 535
 536         assert_return(bus, -ENOTCONN);
 537         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
 538         assert_return(object_path_is_valid(path), -EINVAL);
 539         assert_return(interface_name_is_valid(interface), -EINVAL);
 540         assert_return(member_name_is_valid(member), -EINVAL);
 541         assert_return(m, -EINVAL);
 542
 543         t = message_new(bus, SD_BUS_MESSAGE_SIGNAL);
 544         if (!t)
 545                 return -ENOMEM;
 546
 547         t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
 548
 549         r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
 550         if (r < 0)
 551                 goto fail;
 552         r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
 553         if (r < 0)
 554                 goto fail;
 555         r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
 556         if (r < 0)
 557                 goto fail;
 558
 559         *m = t;
 560         return 0;
 561
 562 fail:
 563         sd_bus_message_unref(t);
 564         return r;
 565 }
 566
 567 _public_ int sd_bus_message_new_method_call(
 568                 sd_bus *bus,
 569                 sd_bus_message **m,
 570                 const char *destination,
 571                 const char *path,
 572                 const char *interface,
 573                 const char *member) {
 574
 575         sd_bus_message *t;
 576         int r;
 577
 578         assert_return(bus, -ENOTCONN);
 579         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
 580         assert_return(!destination || service_name_is_valid(destination), -EINVAL);
 581         assert_return(object_path_is_valid(path), -EINVAL);
 582         assert_return(!interface || interface_name_is_valid(interface), -EINVAL);
 583         assert_return(member_name_is_valid(member), -EINVAL);
 584         assert_return(m, -EINVAL);
 585
 586         t = message_new(bus, SD_BUS_MESSAGE_METHOD_CALL);
 587         if (!t)
 588                 return -ENOMEM;
 589
 590         r = message_append_field_string(t, BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
 591         if (r < 0)
 592                 goto fail;
 593         r = message_append_field_string(t, BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
 594         if (r < 0)
 595                 goto fail;
 596
 597         if (interface) {
 598                 r = message_append_field_string(t, BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
 599                 if (r < 0)
 600                         goto fail;
 601         }
 602
 603         if (destination) {
 604                 r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
 605                 if (r < 0)
 606                         goto fail;
 607         }
 608
 609         *m = t;
 610         return 0;
 611
 612 fail:
 613         message_free(t);
 614         return r;
 615 }
 616
 617 static int message_new_reply(
 618                 sd_bus_message *call,
 619                 uint8_t type,
 620                 sd_bus_message **m) {
 621
 622         sd_bus_message *t;
 623         int r;
 624
 625         assert_return(call, -EINVAL);
 626         assert_return(call->sealed, -EPERM);
 627         assert_return(call->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
 628         assert_return(call->bus->state != BUS_UNSET, -ENOTCONN);
 629         assert_return(m, -EINVAL);
 630
 631         t = message_new(call->bus, type);
 632         if (!t)
 633                 return -ENOMEM;
 634
 635         t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
 636         t->reply_cookie = BUS_MESSAGE_COOKIE(call);
 637
 638         r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) t->reply_cookie);
 639         if (r < 0)
 640                 goto fail;
 641
 642         if (call->sender) {
 643                 r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->destination);
 644                 if (r < 0)
 645                         goto fail;
 646         }
 647
 648         t->dont_send = !!(call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
 649         t->enforced_reply_signature = call->enforced_reply_signature;
 650
 651         *m = t;
 652         return 0;
 653
 654 fail:
 655         message_free(t);
 656         return r;
 657 }
 658
 659 _public_ int sd_bus_message_new_method_return(
 660                 sd_bus_message *call,
 661                 sd_bus_message **m) {
 662
 663         return message_new_reply(call, SD_BUS_MESSAGE_METHOD_RETURN, m);
 664 }
 665
 666 _public_ int sd_bus_message_new_method_error(
 667                 sd_bus_message *call,
 668                 sd_bus_message **m,
 669                 const sd_bus_error *e) {
 670
 671         sd_bus_message *t;
 672         int r;
 673
 674         assert_return(sd_bus_error_is_set(e), -EINVAL);
 675         assert_return(m, -EINVAL);
 676
 677         r = message_new_reply(call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
 678         if (r < 0)
 679                 return r;
 680
 681         r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
 682         if (r < 0)
 683                 goto fail;
 684
 685         if (e->message) {
 686                 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
 687                 if (r < 0)
 688                         goto fail;
 689         }
 690
 691         t->error._need_free = -1;
 692
 693         *m = t;
 694         return 0;
 695
 696 fail:
 697         message_free(t);
 698         return r;
 699 }
 700
 701 _public_ int sd_bus_message_new_method_errorf(
 702                 sd_bus_message *call,
 703                 sd_bus_message **m,
 704                 const char *name,
 705                 const char *format,
 706                 ...) {
 707
 708         _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 709         va_list ap;
 710
 711         assert_return(name, -EINVAL);
 712         assert_return(m, -EINVAL);
 713
 714         va_start(ap, format);
 715         bus_error_setfv(&error, name, format, ap);
 716         va_end(ap);
 717
 718         return sd_bus_message_new_method_error(call, m, &error);
 719 }
 720
 721 _public_ int sd_bus_message_new_method_errno(
 722                 sd_bus_message *call,
 723                 sd_bus_message **m,
 724                 int error,
 725                 const sd_bus_error *p) {
 726
 727         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 728
 729         if (sd_bus_error_is_set(p))
 730                 return sd_bus_message_new_method_error(call, m, p);
 731
 732         sd_bus_error_set_errno(&berror, error);
 733
 734         return sd_bus_message_new_method_error(call, m, &berror);
 735 }
 736
 737 _public_ int sd_bus_message_new_method_errnof(
 738                 sd_bus_message *call,
 739                 sd_bus_message **m,
 740                 int error,
 741                 const char *format,
 742                 ...) {
 743
 744         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 745         va_list ap;
 746
 747         va_start(ap, format);
 748         bus_error_set_errnofv(&berror, error, format, ap);
 749         va_end(ap);
 750
 751         return sd_bus_message_new_method_error(call, m, &berror);
 752 }
 753
 754 int bus_message_new_synthetic_error(
 755                 sd_bus *bus,
 756                 uint64_t cookie,
 757                 const sd_bus_error *e,
 758                 sd_bus_message **m) {
 759
 760         sd_bus_message *t;
 761         int r;
 762
 763         assert(bus);
 764         assert(sd_bus_error_is_set(e));
 765         assert(m);
 766
 767         t = message_new(bus, SD_BUS_MESSAGE_METHOD_ERROR);
 768         if (!t)
 769                 return -ENOMEM;
 770
 771         t->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
 772         t->reply_cookie = cookie;
 773
 774         r = message_append_field_uint32(t, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) t->reply_cookie);
 775         if (r < 0)
 776                 goto fail;
 777
 778         if (bus && bus->unique_name) {
 779                 r = message_append_field_string(t, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination);
 780                 if (r < 0)
 781                         goto fail;
 782         }
 783
 784         r = message_append_field_string(t, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
 785         if (r < 0)
 786                 goto fail;
 787
 788         if (e->message) {
 789                 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
 790                 if (r < 0)
 791                         goto fail;
 792         }
 793
 794         t->error._need_free = -1;
 795
 796         *m = t;
 797         return 0;
 798
 799 fail:
 800         message_free(t);
 801         return r;
 802 }
 803
 804 _public_ sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
 805         assert_return(m, NULL);
 806
 807         assert(m->n_ref > 0);
 808         m->n_ref++;
 809
 810         return m;
 811 }
 812
 813 _public_ sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
 814
 815         if (!m)
 816                 return NULL;
 817
 818         assert(m->n_ref > 0);
 819         m->n_ref--;
 820
 821         if (m->n_ref > 0)
 822                 return NULL;
 823
 824         message_free(m);
 825         return NULL;
 826 }
 827
 828 _public_ int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
 829         assert_return(m, -EINVAL);
 830         assert_return(type, -EINVAL);
 831
 832         *type = m->header->type;
 833         return 0;
 834 }
 835
 836 _public_ int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie) {
 837         assert_return(m, -EINVAL);
 838         assert_return(cookie, -EINVAL);
 839         assert_return(m->header->serial != 0, -ENODATA);
 840
 841         *cookie = BUS_MESSAGE_COOKIE(m);
 842         return 0;
 843 }
 844
 845 _public_ int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie) {
 846         assert_return(m, -EINVAL);
 847         assert_return(cookie, -EINVAL);
 848         assert_return(m->reply_cookie != 0, -ENODATA);
 849
 850         *cookie = m->reply_cookie;
 851         return 0;
 852 }
 853
 854 _public_ int sd_bus_message_get_expect_reply(sd_bus_message *m) {
 855         assert_return(m, -EINVAL);
 856
 857         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
 858                 !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED);
 859 }
 860
 861 _public_ int sd_bus_message_get_auto_start(sd_bus_message *m) {
 862         assert_return(m, -EINVAL);
 863
 864         return !(m->header->flags & BUS_MESSAGE_NO_AUTO_START);
 865 }
 866
 867 _public_ int sd_bus_message_get_allow_interactive_authorization(sd_bus_message *m) {
 868         assert_return(m, -EINVAL);
 869
 870         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL &&
 871                 (m->header->flags & BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION);
 872 }
 873
 874 _public_ const char *sd_bus_message_get_path(sd_bus_message *m) {
 875         assert_return(m, NULL);
 876
 877         return m->path;
 878 }
 879
 880 _public_ const char *sd_bus_message_get_interface(sd_bus_message *m) {
 881         assert_return(m, NULL);
 882
 883         return m->interface;
 884 }
 885
 886 _public_ const char *sd_bus_message_get_member(sd_bus_message *m) {
 887         assert_return(m, NULL);
 888
 889         return m->member;
 890 }
 891
 892 _public_ const char *sd_bus_message_get_destination(sd_bus_message *m) {
 893         assert_return(m, NULL);
 894
 895         return m->destination;
 896 }
 897
 898 _public_ const char *sd_bus_message_get_sender(sd_bus_message *m) {
 899         assert_return(m, NULL);
 900
 901         return m->sender;
 902 }
 903
 904 _public_ const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
 905         assert_return(m, NULL);
 906         assert_return(sd_bus_error_is_set(&m->error), NULL);
 907
 908         return &m->error;
 909 }
 910
 911 _public_ int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec) {
 912         assert_return(m, -EINVAL);
 913         assert_return(usec, -EINVAL);
 914
 915         if (m->monotonic <= 0)
 916                 return -ENODATA;
 917
 918         *usec = m->monotonic;
 919         return 0;
 920 }
 921
 922 _public_ int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec) {
 923         assert_return(m, -EINVAL);
 924         assert_return(usec, -EINVAL);
 925
 926         if (m->realtime <= 0)
 927                 return -ENODATA;
 928
 929         *usec = m->realtime;
 930         return 0;
 931 }
 932
 933 _public_ int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum) {
 934         assert_return(m, -EINVAL);
 935         assert_return(seqnum, -EINVAL);
 936
 937         if (m->seqnum <= 0)
 938                 return -ENODATA;
 939
 940         *seqnum = m->seqnum;
 941         return 0;
 942 }
 943
 944 _public_ sd_bus_creds *sd_bus_message_get_creds(sd_bus_message *m) {
 945         assert_return(m, NULL);
 946
 947         if (m->creds.mask == 0)
 948                 return NULL;
 949
 950         return &m->creds;
 951 }
 952
 953 _public_ int sd_bus_message_is_signal(sd_bus_message *m,
 954                                       const char *interface,
 955                                       const char *member) {
 956         assert_return(m, -EINVAL);
 957
 958         if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
 959                 return 0;
 960
 961         if (interface && (!m->interface || !streq(m->interface, interface)))
 962                 return 0;
 963
 964         if (member &&  (!m->member || !streq(m->member, member)))
 965                 return 0;
 966
 967         return 1;
 968 }
 969
 970 _public_ int sd_bus_message_is_method_call(sd_bus_message *m,
 971                                            const char *interface,
 972                                            const char *member) {
 973         assert_return(m, -EINVAL);
 974
 975         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
 976                 return 0;
 977
 978         if (interface && (!m->interface || !streq(m->interface, interface)))
 979                 return 0;
 980
 981         if (member &&  (!m->member || !streq(m->member, member)))
 982                 return 0;
 983
 984         return 1;
 985 }
 986
 987 _public_ int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
 988         assert_return(m, -EINVAL);
 989
 990         if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
 991                 return 0;
 992
 993         if (name && (!m->error.name || !streq(m->error.name, name)))
 994                 return 0;
 995
 996         return 1;
 997 }
 998
 999 _public_ int sd_bus_message_set_expect_reply(sd_bus_message *m, int b) {
1000         assert_return(m, -EINVAL);
1001         assert_return(!m->sealed, -EPERM);
1002         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EPERM);
1003
1004         if (b)
1005                 m->header->flags &= ~BUS_MESSAGE_NO_REPLY_EXPECTED;
1006         else
1007                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1008
1009         return 0;
1010 }
1011
1012 _public_ int sd_bus_message_set_auto_start(sd_bus_message *m, int b) {
1013         assert_return(m, -EINVAL);
1014         assert_return(!m->sealed, -EPERM);
1015
1016         if (b)
1017                 m->header->flags &= ~BUS_MESSAGE_NO_AUTO_START;
1018         else
1019                 m->header->flags |= BUS_MESSAGE_NO_AUTO_START;
1020
1021         return 0;
1022 }
1023
1024 _public_ int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *m, int b) {
1025         assert_return(m, -EINVAL);
1026         assert_return(!m->sealed, -EPERM);
1027
1028         if (b)
1029                 m->header->flags |= BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
1030         else
1031                 m->header->flags &= ~BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION;
1032
1033         return 0;
1034 }
1035
1036 static struct bus_container *message_get_container(sd_bus_message *m) {
1037         assert(m);
1038
1039         if (m->n_containers == 0)
1040                 return &m->root_container;
1041
1042         assert(m->containers);
1043         return m->containers + m->n_containers - 1;
1044 }
1045
1046 struct bus_body_part *message_append_part(sd_bus_message *m) {
1047         struct bus_body_part *part;
1048
1049         assert(m);
1050
1051         if (m->poisoned)
1052                 return NULL;
1053
1054         if (m->n_body_parts <= 0) {
1055                 part = &m->body;
1056                 zero(*part);
1057         } else {
1058                 assert(m->body_end);
1059
1060                 part = new0(struct bus_body_part, 1);
1061                 if (!part) {
1062                         m->poisoned = true;
1063                         return NULL;
1064                 }
1065
1066                 m->body_end->next = part;
1067         }
1068
1069         part->memfd = -1;
1070         m->body_end = part;
1071         m->n_body_parts ++;
1072
1073         return part;
1074 }
1075
1076 static void part_zero(struct bus_body_part *part, size_t sz) {
1077         assert(part);
1078         assert(sz > 0);
1079         assert(sz < 8);
1080
1081         /* All other fields can be left in their defaults */
1082         assert(!part->data);
1083         assert(part->memfd < 0);
1084
1085         part->size = sz;
1086         part->is_zero = true;
1087         part->sealed = true;
1088 }
1089
1090 static int part_make_space(
1091                 struct sd_bus_message *m,
1092                 struct bus_body_part *part,
1093                 size_t sz,
1094                 void **q) {
1095
1096         void *n;
1097         int r;
1098
1099         assert(m);
1100         assert(part);
1101         assert(!part->sealed);
1102
1103         if (m->poisoned)
1104                 return -ENOMEM;
1105
1106         if (!part->data && part->memfd < 0)
1107                 part->memfd = bus_kernel_pop_memfd(m->bus, &part->data, &part->mapped, &part->allocated);
1108
1109         if (part->memfd >= 0) {
1110
1111                 if (part->allocated == 0 || sz > part->allocated) {
1112                         uint64_t new_allocated;
1113
1114                         new_allocated = PAGE_ALIGN(sz > 0 ? 2 * sz : 1);
1115                         r = memfd_set_size(part->memfd, new_allocated);
1116                         if (r < 0) {
1117                                 m->poisoned = true;
1118                                 return r;
1119                         }
1120
1121                         part->allocated = new_allocated;
1122                 }
1123
1124                 if (!part->data || sz > part->mapped) {
1125                         size_t psz;
1126
1127                         psz = PAGE_ALIGN(sz > 0 ? sz : 1);
1128                         if (part->mapped <= 0)
1129                                 n = mmap(NULL, psz, PROT_READ|PROT_WRITE, MAP_SHARED, part->memfd, 0);
1130                         else
1131                                 n = mremap(part->data, part->mapped, psz, MREMAP_MAYMOVE);
1132
1133                         if (n == MAP_FAILED) {
1134                                 m->poisoned = true;
1135                                 return -errno;
1136                         }
1137
1138                         part->mapped = psz;
1139                         part->data = n;
1140                 }
1141
1142                 part->munmap_this = true;
1143         } else {
1144                 if (part->allocated == 0 || sz > part->allocated) {
1145                         size_t new_allocated;
1146
1147                         new_allocated = sz > 0 ? 2 * sz : 64;
1148                         n = realloc(part->data, new_allocated);
1149                         if (!n) {
1150                                 m->poisoned = true;
1151                                 return -ENOMEM;
1152                         }
1153
1154                         part->data = n;
1155                         part->allocated = new_allocated;
1156                         part->free_this = true;
1157                 }
1158         }
1159
1160         if (q)
1161                 *q = part->data ? (uint8_t*) part->data + part->size : NULL;
1162
1163         part->size = sz;
1164         return 0;
1165 }
1166
1167 static int message_add_offset(sd_bus_message *m, size_t offset) {
1168         struct bus_container *c;
1169
1170         assert(m);
1171         assert(BUS_MESSAGE_IS_GVARIANT(m));
1172
1173         /* Add offset to current container, unless this is the first
1174          * item in it, which will have the 0 offset, which we can
1175          * ignore. */
1176         c = message_get_container(m);
1177
1178         if (!c->need_offsets)
1179                 return 0;
1180
1181         if (!GREEDY_REALLOC(c->offsets, c->offsets_allocated, c->n_offsets + 1))
1182                 return -ENOMEM;
1183
1184         c->offsets[c->n_offsets++] = offset;
1185         return 0;
1186 }
1187
1188 static void message_extend_containers(sd_bus_message *m, size_t expand) {
1189         struct bus_container *c;
1190
1191         assert(m);
1192
1193         if (expand <= 0)
1194                 return;
1195
1196         /* Update counters */
1197         for (c = m->containers; c < m->containers + m->n_containers; c++) {
1198
1199                 if (c->array_size)
1200                         *c->array_size += expand;
1201         }
1202 }
1203
1204 static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz, bool add_offset) {
1205         size_t start_body, end_body, padding, added;
1206         void *p;
1207         int r;
1208
1209         assert(m);
1210         assert(align > 0);
1211         assert(!m->sealed);
1212
1213         if (m->poisoned)
1214                 return NULL;
1215
1216         start_body = ALIGN_TO((size_t) m->header->body_size, align);
1217         end_body = start_body + sz;
1218
1219         padding = start_body - m->header->body_size;
1220         added = padding + sz;
1221
1222         /* Check for 32bit overflows */
1223         if (end_body > (size_t) ((uint32_t) -1)) {
1224                 m->poisoned = true;
1225                 return NULL;
1226         }
1227
1228         if (added > 0) {
1229                 struct bus_body_part *part = NULL;
1230                 bool add_new_part;
1231
1232                 add_new_part =
1233                         m->n_body_parts <= 0 ||
1234                         m->body_end->sealed ||
1235                         padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size;
1236
1237                 if (add_new_part) {
1238                         if (padding > 0) {
1239                                 part = message_append_part(m);
1240                                 if (!part)
1241                                         return NULL;
1242
1243                                 part_zero(part, padding);
1244                         }
1245
1246                         part = message_append_part(m);
1247                         if (!part)
1248                                 return NULL;
1249
1250                         r = part_make_space(m, part, sz, &p);
1251                         if (r < 0)
1252                                 return NULL;
1253                 } else {
1254                         struct bus_container *c;
1255                         void *op;
1256                         size_t os, start_part, end_part;
1257
1258                         part = m->body_end;
1259                         op = part->data;
1260                         os = part->size;
1261
1262                         start_part = ALIGN_TO(part->size, align);
1263                         end_part = start_part + sz;
1264
1265                         r = part_make_space(m, part, end_part, &p);
1266                         if (r < 0)
1267                                 return NULL;
1268
1269                         if (padding > 0) {
1270                                 memzero(p, padding);
1271                                 p = (uint8_t*) p + padding;
1272                         }
1273
1274                         /* Readjust pointers */
1275                         for (c = m->containers; c < m->containers + m->n_containers; c++)
1276                                 c->array_size = adjust_pointer(c->array_size, op, os, part->data);
1277
1278                         m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data);
1279                 }
1280         } else
1281                 /* Return something that is not NULL and is aligned */
1282                 p = (uint8_t *) NULL + align;
1283
1284         m->header->body_size = end_body;
1285         message_extend_containers(m, added);
1286
1287         if (add_offset) {
1288                 r = message_add_offset(m, end_body);
1289                 if (r < 0) {
1290                         m->poisoned = true;
1291                         return NULL;
1292                 }
1293         }
1294
1295         return p;
1296 }
1297
1298 static int message_push_fd(sd_bus_message *m, int fd) {
1299         int *f, copy;
1300
1301         assert(m);
1302
1303         if (fd < 0)
1304                 return -EINVAL;
1305
1306         if (!m->allow_fds)
1307                 return -ENOTSUP;
1308
1309         copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
1310         if (copy < 0)
1311                 return -errno;
1312
1313         f = realloc(m->fds, sizeof(int) * (m->n_fds + 1));
1314         if (!f) {
1315                 m->poisoned = true;
1316                 safe_close(copy);
1317                 return -ENOMEM;
1318         }
1319
1320         m->fds = f;
1321         m->fds[m->n_fds] = copy;
1322         m->free_fds = true;
1323
1324         return copy;
1325 }
1326
1327 int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
1328         _cleanup_close_ int fd = -1;
1329         struct bus_container *c;
1330         ssize_t align, sz;
1331         void *a;
1332
1333         assert_return(m, -EINVAL);
1334         assert_return(!m->sealed, -EPERM);
1335         assert_return(bus_type_is_basic(type), -EINVAL);
1336         assert_return(!m->poisoned, -ESTALE);
1337
1338         c = message_get_container(m);
1339
1340         if (c->signature && c->signature[c->index]) {
1341                 /* Container signature is already set */
1342
1343                 if (c->signature[c->index] != type)
1344                         return -ENXIO;
1345         } else {
1346                 char *e;
1347
1348                 /* Maybe we can append to the signature? But only if this is the top-level container*/
1349                 if (c->enclosing != 0)
1350                         return -ENXIO;
1351
1352                 e = strextend(&c->signature, CHAR_TO_STR(type), NULL);
1353                 if (!e) {
1354                         m->poisoned = true;
1355                         return -ENOMEM;
1356                 }
1357         }
1358
1359         if (BUS_MESSAGE_IS_GVARIANT(m)) {
1360                 uint8_t u8;
1361                 uint32_t u32;
1362
1363                 switch (type) {
1364
1365                 case SD_BUS_TYPE_SIGNATURE:
1366                 case SD_BUS_TYPE_STRING:
1367                         p = strempty(p);
1368
1369                         /* Fall through... */
1370                 case SD_BUS_TYPE_OBJECT_PATH:
1371                         if (!p)
1372                                 return -EINVAL;
1373
1374                         align = 1;
1375                         sz = strlen(p) + 1;
1376                         break;
1377
1378                 case SD_BUS_TYPE_BOOLEAN:
1379
1380                         u8 = p && *(int*) p;
1381                         p = &u8;
1382
1383                         align = sz = 1;
1384                         break;
1385
1386                 case SD_BUS_TYPE_UNIX_FD:
1387
1388                         if (!p)
1389                                 return -EINVAL;
1390
1391                         fd = message_push_fd(m, *(int*) p);
1392                         if (fd < 0)
1393                                 return fd;
1394
1395                         u32 = m->n_fds;
1396                         p = &u32;
1397
1398                         align = sz = 4;
1399                         break;
1400
1401                 default:
1402                         align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
1403                         sz = bus_gvariant_get_size(CHAR_TO_STR(type));
1404                         break;
1405                 }
1406
1407                 assert(align > 0);
1408                 assert(sz > 0);
1409
1410                 a = message_extend_body(m, align, sz, true);
1411                 if (!a)
1412                         return -ENOMEM;
1413
1414                 memcpy(a, p, sz);
1415
1416                 if (stored)
1417                         *stored = (const uint8_t*) a;
1418
1419         } else {
1420                 uint32_t u32;
1421
1422                 switch (type) {
1423
1424                 case SD_BUS_TYPE_STRING:
1425                         /* To make things easy we'll serialize a NULL string
1426                          * into the empty string */
1427                         p = strempty(p);
1428
1429                         /* Fall through... */
1430                 case SD_BUS_TYPE_OBJECT_PATH:
1431
1432                         if (!p)
1433                                 return -EINVAL;
1434
1435                         align = 4;
1436                         sz = 4 + strlen(p) + 1;
1437                         break;
1438
1439                 case SD_BUS_TYPE_SIGNATURE:
1440
1441                         p = strempty(p);
1442
1443                         align = 1;
1444                         sz = 1 + strlen(p) + 1;
1445                         break;
1446
1447                 case SD_BUS_TYPE_BOOLEAN:
1448
1449                         u32 = p && *(int*) p;
1450                         p = &u32;
1451
1452                         align = sz = 4;
1453                         break;
1454
1455                 case SD_BUS_TYPE_UNIX_FD:
1456
1457                         if (!p)
1458                                 return -EINVAL;
1459
1460                         fd = message_push_fd(m, *(int*) p);
1461                         if (fd < 0)
1462                                 return fd;
1463
1464                         u32 = m->n_fds;
1465                         p = &u32;
1466
1467                         align = sz = 4;
1468                         break;
1469
1470                 default:
1471                         align = bus_type_get_alignment(type);
1472                         sz = bus_type_get_size(type);
1473                         break;
1474                 }
1475
1476                 assert(align > 0);
1477                 assert(sz > 0);
1478
1479                 a = message_extend_body(m, align, sz, false);
1480                 if (!a)
1481                         return -ENOMEM;
1482
1483                 if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) {
1484                         *(uint32_t*) a = sz - 5;
1485                         memcpy((uint8_t*) a + 4, p, sz - 4);
1486
1487                         if (stored)
1488                                 *stored = (const uint8_t*) a + 4;
1489
1490                 } else if (type == SD_BUS_TYPE_SIGNATURE) {
1491                         *(uint8_t*) a = sz - 2;
1492                         memcpy((uint8_t*) a + 1, p, sz - 1);
1493
1494                         if (stored)
1495                                 *stored = (const uint8_t*) a + 1;
1496                 } else {
1497                         memcpy(a, p, sz);
1498
1499                         if (stored)
1500                                 *stored = a;
1501                 }
1502         }
1503
1504         if (type == SD_BUS_TYPE_UNIX_FD)
1505                 m->n_fds ++;
1506
1507         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1508                 c->index++;
1509
1510         fd = -1;
1511         return 0;
1512 }
1513
1514 _public_ int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
1515         return message_append_basic(m, type, p, NULL);
1516 }
1517
1518 _public_ int sd_bus_message_append_string_space(
1519                 sd_bus_message *m,
1520                 size_t size,
1521                 char **s) {
1522
1523         struct bus_container *c;
1524         void *a;
1525
1526         assert_return(m, -EINVAL);
1527         assert_return(s, -EINVAL);
1528         assert_return(!m->sealed, -EPERM);
1529         assert_return(!m->poisoned, -ESTALE);
1530
1531         c = message_get_container(m);
1532
1533         if (c->signature && c->signature[c->index]) {
1534                 /* Container signature is already set */
1535
1536                 if (c->signature[c->index] != SD_BUS_TYPE_STRING)
1537                         return -ENXIO;
1538         } else {
1539                 char *e;
1540
1541                 /* Maybe we can append to the signature? But only if this is the top-level container*/
1542                 if (c->enclosing != 0)
1543                         return -ENXIO;
1544
1545                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL);
1546                 if (!e) {
1547                         m->poisoned = true;
1548                         return -ENOMEM;
1549                 }
1550         }
1551
1552         if (BUS_MESSAGE_IS_GVARIANT(m)) {
1553                 a = message_extend_body(m, 1, size + 1, true);
1554                 if (!a)
1555                         return -ENOMEM;
1556
1557                 *s = a;
1558         } else {
1559                 a = message_extend_body(m, 4, 4 + size + 1, false);
1560                 if (!a)
1561                         return -ENOMEM;
1562
1563                 *(uint32_t*) a = size;
1564                 *s = (char*) a + 4;
1565         }
1566
1567         (*s)[size] = 0;
1568
1569         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1570                 c->index++;
1571
1572         return 0;
1573 }
1574
1575 _public_ int sd_bus_message_append_string_iovec(
1576                 sd_bus_message *m,
1577                 const struct iovec *iov,
1578                 unsigned n) {
1579
1580         size_t size;
1581         unsigned i;
1582         char *p;
1583         int r;
1584
1585         assert_return(m, -EINVAL);
1586         assert_return(!m->sealed, -EPERM);
1587         assert_return(iov || n == 0, -EINVAL);
1588         assert_return(!m->poisoned, -ESTALE);
1589
1590         size = IOVEC_TOTAL_SIZE(iov, n);
1591
1592         r = sd_bus_message_append_string_space(m, size, &p);
1593         if (r < 0)
1594                 return r;
1595
1596         for (i = 0; i < n; i++) {
1597
1598                 if (iov[i].iov_base)
1599                         memcpy(p, iov[i].iov_base, iov[i].iov_len);
1600                 else
1601                         memset(p, ' ', iov[i].iov_len);
1602
1603                 p += iov[i].iov_len;
1604         }
1605
1606         return 0;
1607 }
1608
1609 static int bus_message_open_array(
1610                 sd_bus_message *m,
1611                 struct bus_container *c,
1612                 const char *contents,
1613                 uint32_t **array_size,
1614                 size_t *begin,
1615                 bool *need_offsets) {
1616
1617         unsigned nindex;
1618         int alignment, r;
1619
1620         assert(m);
1621         assert(c);
1622         assert(contents);
1623         assert(array_size);
1624         assert(begin);
1625         assert(need_offsets);
1626
1627         if (!signature_is_single(contents, true))
1628                 return -EINVAL;
1629
1630         if (c->signature && c->signature[c->index]) {
1631
1632                 /* Verify the existing signature */
1633
1634                 if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
1635                         return -ENXIO;
1636
1637                 if (!startswith(c->signature + c->index + 1, contents))
1638                         return -ENXIO;
1639
1640                 nindex = c->index + 1 + strlen(contents);
1641         } else {
1642                 char *e;
1643
1644                 if (c->enclosing != 0)
1645                         return -ENXIO;
1646
1647                 /* Extend the existing signature */
1648
1649                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL);
1650                 if (!e) {
1651                         m->poisoned = true;
1652                         return -ENOMEM;
1653                 }
1654
1655                 nindex = e - c->signature;
1656         }
1657
1658         if (BUS_MESSAGE_IS_GVARIANT(m)) {
1659                 alignment = bus_gvariant_get_alignment(contents);
1660                 if (alignment < 0)
1661                         return alignment;
1662
1663                 /* Add alignment padding and add to offset list */
1664                 if (!message_extend_body(m, alignment, 0, false))
1665                         return -ENOMEM;
1666
1667                 r = bus_gvariant_is_fixed_size(contents);
1668                 if (r < 0)
1669                         return r;
1670
1671                 *begin = m->header->body_size;
1672                 *need_offsets = r == 0;
1673         } else {
1674                 void *a, *op;
1675                 size_t os;
1676                 struct bus_body_part *o;
1677
1678                 alignment = bus_type_get_alignment(contents[0]);
1679                 if (alignment < 0)
1680                         return alignment;
1681
1682                 a = message_extend_body(m, 4, 4, false);
1683                 if (!a)
1684                         return -ENOMEM;
1685
1686                 o = m->body_end;
1687                 op = m->body_end->data;
1688                 os = m->body_end->size;
1689
1690                 /* Add alignment between size and first element */
1691                 if (!message_extend_body(m, alignment, 0, false))
1692                         return -ENOMEM;
1693
1694                 /* location of array size might have changed so let's readjust a */
1695                 if (o == m->body_end)
1696                         a = adjust_pointer(a, op, os, m->body_end->data);
1697
1698                 *(uint32_t*) a = 0;
1699                 *array_size = a;
1700         }
1701
1702         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1703                 c->index = nindex;
1704
1705         return 0;
1706 }
1707
1708 static int bus_message_open_variant(
1709                 sd_bus_message *m,
1710                 struct bus_container *c,
1711                 const char *contents) {
1712
1713         assert(m);
1714         assert(c);
1715         assert(contents);
1716
1717         if (!signature_is_single(contents, false))
1718                 return -EINVAL;
1719
1720         if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
1721                 return -EINVAL;
1722
1723         if (c->signature && c->signature[c->index]) {
1724
1725                 if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
1726                         return -ENXIO;
1727
1728         } else {
1729                 char *e;
1730
1731                 if (c->enclosing != 0)
1732                         return -ENXIO;
1733
1734                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL);
1735                 if (!e) {
1736                         m->poisoned = true;
1737                         return -ENOMEM;
1738                 }
1739         }
1740
1741         if (BUS_MESSAGE_IS_GVARIANT(m)) {
1742                 /* Variants are always aligned to 8 */
1743
1744                 if (!message_extend_body(m, 8, 0, false))
1745                         return -ENOMEM;
1746
1747         } else {
1748                 size_t l;
1749                 void *a;
1750
1751                 l = strlen(contents);
1752                 a = message_extend_body(m, 1, 1 + l + 1, false);
1753                 if (!a)
1754                         return -ENOMEM;
1755
1756                 *(uint8_t*) a = l;
1757                 memcpy((uint8_t*) a + 1, contents, l + 1);
1758         }
1759
1760         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1761                 c->index++;
1762
1763         return 0;
1764 }
1765
1766 static int bus_message_open_struct(
1767                 sd_bus_message *m,
1768                 struct bus_container *c,
1769                 const char *contents,
1770                 size_t *begin,
1771                 bool *need_offsets) {
1772
1773         size_t nindex;
1774         int r;
1775
1776         assert(m);
1777         assert(c);
1778         assert(contents);
1779         assert(begin);
1780         assert(need_offsets);
1781
1782         if (!signature_is_valid(contents, false))
1783                 return -EINVAL;
1784
1785         if (c->signature && c->signature[c->index]) {
1786                 size_t l;
1787
1788                 l = strlen(contents);
1789
1790                 if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
1791                     !startswith(c->signature + c->index + 1, contents) ||
1792                     c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
1793                         return -ENXIO;
1794
1795                 nindex = c->index + 1 + l + 1;
1796         } else {
1797                 char *e;
1798
1799                 if (c->enclosing != 0)
1800                         return -ENXIO;
1801
1802                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL);
1803                 if (!e) {
1804                         m->poisoned = true;
1805                         return -ENOMEM;
1806                 }
1807
1808                 nindex = e - c->signature;
1809         }
1810
1811         if (BUS_MESSAGE_IS_GVARIANT(m)) {
1812                 int alignment;
1813
1814                 alignment = bus_gvariant_get_alignment(contents);
1815                 if (alignment < 0)
1816                         return alignment;
1817
1818                 if (!message_extend_body(m, alignment, 0, false))
1819                         return -ENOMEM;
1820
1821                 r = bus_gvariant_is_fixed_size(contents);
1822                 if (r < 0)
1823                         return r;
1824
1825                 *begin = m->header->body_size;
1826                 *need_offsets = r == 0;
1827         } else {
1828                 /* Align contents to 8 byte boundary */
1829                 if (!message_extend_body(m, 8, 0, false))
1830                         return -ENOMEM;
1831         }
1832
1833         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1834                 c->index = nindex;
1835
1836         return 0;
1837 }
1838
1839 static int bus_message_open_dict_entry(
1840                 sd_bus_message *m,
1841                 struct bus_container *c,
1842                 const char *contents,
1843                 size_t *begin,
1844                 bool *need_offsets) {
1845
1846         int r;
1847
1848         assert(m);
1849         assert(c);
1850         assert(contents);
1851         assert(begin);
1852         assert(need_offsets);
1853
1854         if (!signature_is_pair(contents))
1855                 return -EINVAL;
1856
1857         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1858                 return -ENXIO;
1859
1860         if (c->signature && c->signature[c->index]) {
1861                 size_t l;
1862
1863                 l = strlen(contents);
1864
1865                 if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
1866                     !startswith(c->signature + c->index + 1, contents) ||
1867                     c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
1868                         return -ENXIO;
1869         } else
1870                 return -ENXIO;
1871
1872         if (BUS_MESSAGE_IS_GVARIANT(m)) {
1873                 int alignment;
1874
1875                 alignment = bus_gvariant_get_alignment(contents);
1876                 if (alignment < 0)
1877                         return alignment;
1878
1879                 if (!message_extend_body(m, alignment, 0, false))
1880                         return -ENOMEM;
1881
1882                 r = bus_gvariant_is_fixed_size(contents);
1883                 if (r < 0)
1884                         return r;
1885
1886                 *begin = m->header->body_size;
1887                 *need_offsets = r == 0;
1888         } else {
1889                 /* Align contents to 8 byte boundary */
1890                 if (!message_extend_body(m, 8, 0, false))
1891                         return -ENOMEM;
1892         }
1893
1894         return 0;
1895 }
1896
1897 _public_ int sd_bus_message_open_container(
1898                 sd_bus_message *m,
1899                 char type,
1900                 const char *contents) {
1901
1902         struct bus_container *c, *w;
1903         uint32_t *array_size = NULL;
1904         char *signature;
1905         size_t before, begin = 0;
1906         bool need_offsets = false;
1907         int r;
1908
1909         assert_return(m, -EINVAL);
1910         assert_return(!m->sealed, -EPERM);
1911         assert_return(contents, -EINVAL);
1912         assert_return(!m->poisoned, -ESTALE);
1913
1914         /* Make sure we have space for one more container */
1915         if (!GREEDY_REALLOC(m->containers, m->containers_allocated, m->n_containers + 1)) {
1916                 m->poisoned = true;
1917                 return -ENOMEM;
1918         }
1919
1920         c = message_get_container(m);
1921
1922         signature = strdup(contents);
1923         if (!signature) {
1924                 m->poisoned = true;
1925                 return -ENOMEM;
1926         }
1927
1928         /* Save old index in the parent container, in case we have to
1929          * abort this container */
1930         c->saved_index = c->index;
1931         before = m->header->body_size;
1932
1933         if (type == SD_BUS_TYPE_ARRAY)
1934                 r = bus_message_open_array(m, c, contents, &array_size, &begin, &need_offsets);
1935         else if (type == SD_BUS_TYPE_VARIANT)
1936                 r = bus_message_open_variant(m, c, contents);
1937         else if (type == SD_BUS_TYPE_STRUCT)
1938                 r = bus_message_open_struct(m, c, contents, &begin, &need_offsets);
1939         else if (type == SD_BUS_TYPE_DICT_ENTRY)
1940                 r = bus_message_open_dict_entry(m, c, contents, &begin, &need_offsets);
1941         else
1942                 r = -EINVAL;
1943
1944         if (r < 0) {
1945                 free(signature);
1946                 return r;
1947         }
1948
1949         /* OK, let's fill it in */
1950         w = m->containers + m->n_containers++;
1951         w->enclosing = type;
1952         w->signature = signature;
1953         w->index = 0;
1954         w->array_size = array_size;
1955         w->before = before;
1956         w->begin = begin;
1957         w->n_offsets = w->offsets_allocated = 0;
1958         w->offsets = NULL;
1959         w->need_offsets = need_offsets;
1960
1961         return 0;
1962 }
1963
1964 static size_t determine_word_size(size_t sz, size_t extra) {
1965         if (sz + extra <= 0xFF)
1966                 return 1;
1967         else if (sz + extra*2 <= 0xFFFF)
1968                 return 2;
1969         else if (sz + extra*4 <= 0xFFFFFFFF)
1970                 return 4;
1971         else
1972                 return 8;
1973 }
1974
1975 static size_t read_word_le(void *p, size_t sz) {
1976         union {
1977                 uint16_t u16;
1978                 uint32_t u32;
1979                 uint64_t u64;
1980         } x;
1981
1982         assert(p);
1983
1984         if (sz == 1)
1985                 return *(uint8_t*) p;
1986
1987         memcpy(&x, p, sz);
1988
1989         if (sz == 2)
1990                 return le16toh(x.u16);
1991         else if (sz == 4)
1992                 return le32toh(x.u32);
1993         else if (sz == 8)
1994                 return le64toh(x.u64);
1995
1996         assert_not_reached("unknown word width");
1997 }
1998
1999 static void write_word_le(void *p, size_t sz, size_t value) {
2000         union {
2001                 uint16_t u16;
2002                 uint32_t u32;
2003                 uint64_t u64;
2004         } x;
2005
2006         assert(p);
2007         assert(sz == 8 || (value < (1ULL << (sz*8))));
2008
2009         if (sz == 1) {
2010                 *(uint8_t*) p = value;
2011                 return;
2012         } else if (sz == 2)
2013                 x.u16 = htole16((uint16_t) value);
2014         else if (sz == 4)
2015                 x.u32 = htole32((uint32_t) value);
2016         else if (sz == 8)
2017                 x.u64 = htole64((uint64_t) value);
2018         else
2019                 assert_not_reached("unknown word width");
2020
2021         memcpy(p, &x, sz);
2022 }
2023
2024 static int bus_message_close_array(sd_bus_message *m, struct bus_container *c) {
2025
2026         assert(m);
2027         assert(c);
2028
2029         if (!BUS_MESSAGE_IS_GVARIANT(m))
2030                 return 0;
2031
2032         if (c->need_offsets) {
2033                 size_t payload, sz, i;
2034                 uint8_t *a;
2035
2036                 /* Variable-width arrays */
2037
2038                 payload = c->n_offsets > 0 ? c->offsets[c->n_offsets-1] - c->begin : 0;
2039                 sz = determine_word_size(payload, c->n_offsets);
2040
2041                 a = message_extend_body(m, 1, sz * c->n_offsets, true);
2042                 if (!a)
2043                         return -ENOMEM;
2044
2045                 for (i = 0; i < c->n_offsets; i++)
2046                         write_word_le(a + sz*i, sz, c->offsets[i] - c->begin);
2047         } else {
2048                 void *a;
2049
2050                 /* Fixed-width or empty arrays */
2051
2052                 a = message_extend_body(m, 1, 0, true); /* let's add offset to parent */
2053                 if (!a)
2054                         return -ENOMEM;
2055         }
2056
2057         return 0;
2058 }
2059
2060 static int bus_message_close_variant(sd_bus_message *m, struct bus_container *c) {
2061         uint8_t *a;
2062         size_t l;
2063
2064         assert(m);
2065         assert(c);
2066
2067         if (!BUS_MESSAGE_IS_GVARIANT(m))
2068                 return 0;
2069
2070         l = strlen(c->signature);
2071
2072         a = message_extend_body(m, 1, 1 + l, true);
2073         if (!a)
2074                 return -ENOMEM;
2075
2076         a[0] = 0;
2077         memcpy(a+1, c->signature, l);
2078
2079         return 0;
2080 }
2081
2082 static int bus_message_close_struct(sd_bus_message *m, struct bus_container *c, bool add_offset) {
2083         size_t n_variable = 0;
2084         unsigned i = 0;
2085         const char *p;
2086         uint8_t *a;
2087         int r;
2088
2089         assert(m);
2090         assert(c);
2091
2092         if (!BUS_MESSAGE_IS_GVARIANT(m))
2093                 return 0;
2094
2095         p = strempty(c->signature);
2096         while (*p != 0) {
2097                 size_t n;
2098
2099                 r = signature_element_length(p, &n);
2100                 if (r < 0)
2101                         return r;
2102                 else {
2103                         char t[n+1];
2104
2105                         memcpy(t, p, n);
2106                         t[n] = 0;
2107
2108                         r = bus_gvariant_is_fixed_size(t);
2109                         if (r < 0)
2110                                 return r;
2111                 }
2112
2113                 assert(!c->need_offsets || i <= c->n_offsets);
2114
2115                 /* We need to add an offset for each item that has a
2116                  * variable size and that is not the last one in the
2117                  * list */
2118                 if (r == 0 && p[n] != 0)
2119                         n_variable++;
2120
2121                 i++;
2122                 p += n;
2123         }
2124
2125         assert(!c->need_offsets || i == c->n_offsets);
2126         assert(c->need_offsets || n_variable == 0);
2127
2128         if (n_variable <= 0) {
2129                 a = message_extend_body(m, 1, 0, add_offset);
2130                 if (!a)
2131                         return -ENOMEM;
2132         } else {
2133                 size_t sz;
2134                 unsigned j;
2135
2136                 assert(c->offsets[c->n_offsets-1] == m->header->body_size);
2137
2138                 sz = determine_word_size(m->header->body_size - c->begin, n_variable);
2139
2140                 a = message_extend_body(m, 1, sz * n_variable, add_offset);
2141                 if (!a)
2142                         return -ENOMEM;
2143
2144                 p = strempty(c->signature);
2145                 for (i = 0, j = 0; i < c->n_offsets; i++) {
2146                         unsigned k;
2147                         size_t n;
2148
2149                         r = signature_element_length(p, &n);
2150                         if (r < 0)
2151                                 return r;
2152                         else {
2153                                 char t[n+1];
2154
2155                                 memcpy(t, p, n);
2156                                 t[n] = 0;
2157
2158                                 p += n;
2159
2160                                 r = bus_gvariant_is_fixed_size(t);
2161                                 if (r < 0)
2162                                         return r;
2163                                 if (r > 0 || p[0] == 0)
2164                                         continue;
2165                         }
2166
2167                         k = n_variable - 1 - j;
2168
2169                         write_word_le(a + k * sz, sz, c->offsets[i] - c->begin);
2170
2171                         j++;
2172                 }
2173         }
2174
2175         return 0;
2176 }
2177
2178 _public_ int sd_bus_message_close_container(sd_bus_message *m) {
2179         struct bus_container *c;
2180         int r;
2181
2182         assert_return(m, -EINVAL);
2183         assert_return(!m->sealed, -EPERM);
2184         assert_return(m->n_containers > 0, -EINVAL);
2185         assert_return(!m->poisoned, -ESTALE);
2186
2187         c = message_get_container(m);
2188
2189         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2190                 if (c->signature && c->signature[c->index] != 0)
2191                         return -EINVAL;
2192
2193         m->n_containers--;
2194
2195         if (c->enclosing == SD_BUS_TYPE_ARRAY)
2196                 r = bus_message_close_array(m, c);
2197         else if (c->enclosing == SD_BUS_TYPE_VARIANT)
2198                 r = bus_message_close_variant(m, c);
2199         else if (c->enclosing == SD_BUS_TYPE_STRUCT || c->enclosing == SD_BUS_TYPE_DICT_ENTRY)
2200                 r = bus_message_close_struct(m, c, true);
2201         else
2202                 assert_not_reached("Unknown container type");
2203
2204         free(c->signature);
2205         free(c->offsets);
2206
2207         return r;
2208 }
2209
2210 typedef struct {
2211         const char *types;
2212         unsigned n_struct;
2213         unsigned n_array;
2214 } TypeStack;
2215
2216 static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) {
2217         assert(stack);
2218         assert(max > 0);
2219
2220         if (*i >= max)
2221                 return -EINVAL;
2222
2223         stack[*i].types = types;
2224         stack[*i].n_struct = n_struct;
2225         stack[*i].n_array = n_array;
2226         (*i)++;
2227
2228         return 0;
2229 }
2230
2231 static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) {
2232         assert(stack);
2233         assert(max > 0);
2234         assert(types);
2235         assert(n_struct);
2236         assert(n_array);
2237
2238         if (*i <= 0)
2239                 return 0;
2240
2241         (*i)--;
2242         *types = stack[*i].types;
2243         *n_struct = stack[*i].n_struct;
2244         *n_array = stack[*i].n_array;
2245
2246         return 1;
2247 }
2248
2249 int bus_message_append_ap(
2250                 sd_bus_message *m,
2251                 const char *types,
2252                 va_list ap) {
2253
2254         unsigned n_array, n_struct;
2255         TypeStack stack[BUS_CONTAINER_DEPTH];
2256         unsigned stack_ptr = 0;
2257         int r;
2258
2259         assert(m);
2260
2261         if (!types)
2262                 return 0;
2263
2264         n_array = (unsigned) -1;
2265         n_struct = strlen(types);
2266
2267         for (;;) {
2268                 const char *t;
2269
2270                 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
2271                         r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
2272                         if (r < 0)
2273                                 return r;
2274                         if (r == 0)
2275                                 break;
2276
2277                         r = sd_bus_message_close_container(m);
2278                         if (r < 0)
2279                                 return r;
2280
2281                         continue;
2282                 }
2283
2284                 t = types;
2285                 if (n_array != (unsigned) -1)
2286                         n_array --;
2287                 else {
2288                         types ++;
2289                         n_struct--;
2290                 }
2291
2292                 switch (*t) {
2293
2294                 case SD_BUS_TYPE_BYTE: {
2295                         uint8_t x;
2296
2297                         x = (uint8_t) va_arg(ap, int);
2298                         r = sd_bus_message_append_basic(m, *t, &x);
2299                         break;
2300                 }
2301
2302                 case SD_BUS_TYPE_BOOLEAN:
2303                 case SD_BUS_TYPE_INT32:
2304                 case SD_BUS_TYPE_UINT32:
2305                 case SD_BUS_TYPE_UNIX_FD: {
2306                         uint32_t x;
2307
2308                         /* We assume a boolean is the same as int32_t */
2309                         assert_cc(sizeof(int32_t) == sizeof(int));
2310
2311                         x = va_arg(ap, uint32_t);
2312                         r = sd_bus_message_append_basic(m, *t, &x);
2313                         break;
2314                 }
2315
2316                 case SD_BUS_TYPE_INT16:
2317                 case SD_BUS_TYPE_UINT16: {
2318                         uint16_t x;
2319
2320                         x = (uint16_t) va_arg(ap, int);
2321                         r = sd_bus_message_append_basic(m, *t, &x);
2322                         break;
2323                 }
2324
2325                 case SD_BUS_TYPE_INT64:
2326                 case SD_BUS_TYPE_UINT64:
2327                 case SD_BUS_TYPE_DOUBLE: {
2328                         uint64_t x;
2329
2330                         x = va_arg(ap, uint64_t);
2331                         r = sd_bus_message_append_basic(m, *t, &x);
2332                         break;
2333                 }
2334
2335                 case SD_BUS_TYPE_STRING:
2336                 case SD_BUS_TYPE_OBJECT_PATH:
2337                 case SD_BUS_TYPE_SIGNATURE: {
2338                         const char *x;
2339
2340                         x = va_arg(ap, const char*);
2341                         r = sd_bus_message_append_basic(m, *t, x);
2342                         break;
2343                 }
2344
2345                 case SD_BUS_TYPE_ARRAY: {
2346                         size_t k;
2347
2348                         r = signature_element_length(t + 1, &k);
2349                         if (r < 0)
2350                                 return r;
2351
2352                         {
2353                                 char s[k + 1];
2354                                 memcpy(s, t + 1, k);
2355                                 s[k] = 0;
2356
2357                                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
2358                                 if (r < 0)
2359                                         return r;
2360                         }
2361
2362                         if (n_array == (unsigned) -1) {
2363                                 types += k;
2364                                 n_struct -= k;
2365                         }
2366
2367                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2368                         if (r < 0)
2369                                 return r;
2370
2371                         types = t + 1;
2372                         n_struct = k;
2373                         n_array = va_arg(ap, unsigned);
2374
2375                         break;
2376                 }
2377
2378                 case SD_BUS_TYPE_VARIANT: {
2379                         const char *s;
2380
2381                         s = va_arg(ap, const char*);
2382                         if (!s)
2383                                 return -EINVAL;
2384
2385                         r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s);
2386                         if (r < 0)
2387                                 return r;
2388
2389                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2390                         if (r < 0)
2391                                 return r;
2392
2393                         types = s;
2394                         n_struct = strlen(s);
2395                         n_array = (unsigned) -1;
2396
2397                         break;
2398                 }
2399
2400                 case SD_BUS_TYPE_STRUCT_BEGIN:
2401                 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
2402                         size_t k;
2403
2404                         r = signature_element_length(t, &k);
2405                         if (r < 0)
2406                                 return r;
2407
2408                         {
2409                                 char s[k - 1];
2410
2411                                 memcpy(s, t + 1, k - 2);
2412                                 s[k - 2] = 0;
2413
2414                                 r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
2415                                 if (r < 0)
2416                                         return r;
2417                         }
2418
2419                         if (n_array == (unsigned) -1) {
2420                                 types += k - 1;
2421                                 n_struct -= k - 1;
2422                         }
2423
2424                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2425                         if (r < 0)
2426                                 return r;
2427
2428                         types = t + 1;
2429                         n_struct = k - 2;
2430                         n_array = (unsigned) -1;
2431
2432                         break;
2433                 }
2434
2435                 default:
2436                         r = -EINVAL;
2437                 }
2438
2439                 if (r < 0)
2440                         return r;
2441         }
2442
2443         return 1;
2444 }
2445
2446 _public_ int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
2447         va_list ap;
2448         int r;
2449
2450         assert_return(m, -EINVAL);
2451         assert_return(types, -EINVAL);
2452         assert_return(!m->sealed, -EPERM);
2453         assert_return(!m->poisoned, -ESTALE);
2454
2455         va_start(ap, types);
2456         r = bus_message_append_ap(m, types, ap);
2457         va_end(ap);
2458
2459         return r;
2460 }
2461
2462 _public_ int sd_bus_message_append_array_space(
2463                 sd_bus_message *m,
2464                 char type,
2465                 size_t size,
2466                 void **ptr) {
2467
2468         ssize_t align, sz;
2469         void *a;
2470         int r;
2471
2472         assert_return(m, -EINVAL);
2473         assert_return(!m->sealed, -EPERM);
2474         assert_return(bus_type_is_trivial(type) && type != SD_BUS_TYPE_BOOLEAN, -EINVAL);
2475         assert_return(ptr || size == 0, -EINVAL);
2476         assert_return(!m->poisoned, -ESTALE);
2477
2478         /* alignment and size of the trivial types (except bool) is
2479          * identical for gvariant and dbus1 marshalling */
2480         align = bus_type_get_alignment(type);
2481         sz = bus_type_get_size(type);
2482
2483         assert_se(align > 0);
2484         assert_se(sz > 0);
2485
2486         if (size % sz != 0)
2487                 return -EINVAL;
2488
2489         r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
2490         if (r < 0)
2491                 return r;
2492
2493         a = message_extend_body(m, align, size, false);
2494         if (!a)
2495                 return -ENOMEM;
2496
2497         r = sd_bus_message_close_container(m);
2498         if (r < 0)
2499                 return r;
2500
2501         *ptr = a;
2502         return 0;
2503 }
2504
2505 _public_ int sd_bus_message_append_array(sd_bus_message *m,
2506                                          char type,
2507                                          const void *ptr,
2508                                          size_t size) {
2509         int r;
2510         void *p;
2511
2512         assert_return(m, -EINVAL);
2513         assert_return(!m->sealed, -EPERM);
2514         assert_return(bus_type_is_trivial(type), -EINVAL);
2515         assert_return(ptr || size == 0, -EINVAL);
2516         assert_return(!m->poisoned, -ESTALE);
2517
2518         r = sd_bus_message_append_array_space(m, type, size, &p);
2519         if (r < 0)
2520                 return r;
2521
2522         if (size > 0)
2523                 memcpy(p, ptr, size);
2524
2525         return 0;
2526 }
2527
2528 _public_ int sd_bus_message_append_array_iovec(
2529                 sd_bus_message *m,
2530                 char type,
2531                 const struct iovec *iov,
2532                 unsigned n) {
2533
2534         size_t size;
2535         unsigned i;
2536         void *p;
2537         int r;
2538
2539         assert_return(m, -EINVAL);
2540         assert_return(!m->sealed, -EPERM);
2541         assert_return(bus_type_is_trivial(type), -EINVAL);
2542         assert_return(iov || n == 0, -EINVAL);
2543         assert_return(!m->poisoned, -ESTALE);
2544
2545         size = IOVEC_TOTAL_SIZE(iov, n);
2546
2547         r = sd_bus_message_append_array_space(m, type, size, &p);
2548         if (r < 0)
2549                 return r;
2550
2551         for (i = 0; i < n; i++) {
2552
2553                 if (iov[i].iov_base)
2554                         memcpy(p, iov[i].iov_base, iov[i].iov_len);
2555                 else
2556                         memzero(p, iov[i].iov_len);
2557
2558                 p = (uint8_t*) p + iov[i].iov_len;
2559         }
2560
2561         return 0;
2562 }
2563
2564 _public_ int sd_bus_message_append_array_memfd(sd_bus_message *m,
2565                                                char type,
2566                                                int memfd) {
2567         _cleanup_close_ int copy_fd = -1;
2568         struct bus_body_part *part;
2569         ssize_t align, sz;
2570         uint64_t size;
2571         void *a;
2572         int r;
2573
2574         if (!m)
2575                 return -EINVAL;
2576         if (memfd < 0)
2577                 return -EINVAL;
2578         if (m->sealed)
2579                 return -EPERM;
2580         if (!bus_type_is_trivial(type))
2581                 return -EINVAL;
2582         if (m->poisoned)
2583                 return -ESTALE;
2584
2585         r = memfd_set_sealed(memfd);
2586         if (r < 0)
2587                 return r;
2588
2589         copy_fd = dup(memfd);
2590         if (copy_fd < 0)
2591                 return copy_fd;
2592
2593         r = memfd_get_size(memfd, &size);
2594         if (r < 0)
2595                 return r;
2596
2597         align = bus_type_get_alignment(type);
2598         sz = bus_type_get_size(type);
2599
2600         assert_se(align > 0);
2601         assert_se(sz > 0);
2602
2603         if (size % sz != 0)
2604                 return -EINVAL;
2605
2606         if (size > (uint64_t) (uint32_t) -1)
2607                 return -EINVAL;
2608
2609         r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
2610         if (r < 0)
2611                 return r;
2612
2613         a = message_extend_body(m, align, 0, false);
2614         if (!a)
2615                 return -ENOMEM;
2616
2617         part = message_append_part(m);
2618         if (!part)
2619                 return -ENOMEM;
2620
2621         part->memfd = copy_fd;
2622         part->sealed = true;
2623         part->size = size;
2624         copy_fd = -1;
2625
2626         m->header->body_size += size;
2627         message_extend_containers(m, size);
2628
2629         return sd_bus_message_close_container(m);
2630 }
2631
2632 _public_ int sd_bus_message_append_string_memfd(sd_bus_message *m, int memfd) {
2633         _cleanup_close_ int copy_fd = -1;
2634         struct bus_body_part *part;
2635         struct bus_container *c;
2636         uint64_t size;
2637         void *a;
2638         int r;
2639
2640         assert_return(m, -EINVAL);
2641         assert_return(memfd >= 0, -EINVAL);
2642         assert_return(!m->sealed, -EPERM);
2643         assert_return(!m->poisoned, -ESTALE);
2644
2645         r = memfd_set_sealed(memfd);
2646         if (r < 0)
2647                 return r;
2648
2649         copy_fd = dup(memfd);
2650         if (copy_fd < 0)
2651                 return copy_fd;
2652
2653         r = memfd_get_size(memfd, &size);
2654         if (r < 0)
2655                 return r;
2656
2657         /* We require this to be NUL terminated */
2658         if (size == 0)
2659                 return -EINVAL;
2660
2661         if (size > (uint64_t) (uint32_t) -1)
2662                 return -EINVAL;
2663
2664         c = message_get_container(m);
2665         if (c->signature && c->signature[c->index]) {
2666                 /* Container signature is already set */
2667
2668                 if (c->signature[c->index] != SD_BUS_TYPE_STRING)
2669                         return -ENXIO;
2670         } else {
2671                 char *e;
2672
2673                 /* Maybe we can append to the signature? But only if this is the top-level container*/
2674                 if (c->enclosing != 0)
2675                         return -ENXIO;
2676
2677                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL);
2678                 if (!e) {
2679                         m->poisoned = true;
2680                         return -ENOMEM;
2681                 }
2682         }
2683
2684         if (!BUS_MESSAGE_IS_GVARIANT(m)) {
2685                 a = message_extend_body(m, 4, 4, false);
2686                 if (!a)
2687                         return -ENOMEM;
2688
2689                 *(uint32_t*) a = size - 1;
2690         }
2691
2692         part = message_append_part(m);
2693         if (!part)
2694                 return -ENOMEM;
2695
2696         part->memfd = copy_fd;
2697         part->sealed = true;
2698         part->size = size;
2699         copy_fd = -1;
2700
2701         m->header->body_size += size;
2702         message_extend_containers(m, size);
2703
2704         if (BUS_MESSAGE_IS_GVARIANT(m)) {
2705                 r = message_add_offset(m, m->header->body_size);
2706                 if (r < 0) {
2707                         m->poisoned = true;
2708                         return -ENOMEM;
2709                 }
2710         }
2711
2712         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2713                 c->index++;
2714
2715         return 0;
2716 }
2717
2718 _public_ int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
2719         char **i;
2720         int r;
2721
2722         assert_return(m, -EINVAL);
2723         assert_return(!m->sealed, -EPERM);
2724         assert_return(!m->poisoned, -ESTALE);
2725
2726         r = sd_bus_message_open_container(m, 'a', "s");
2727         if (r < 0)
2728                 return r;
2729
2730         STRV_FOREACH(i, l) {
2731                 r = sd_bus_message_append_basic(m, 's', *i);
2732                 if (r < 0)
2733                         return r;
2734         }
2735
2736         return sd_bus_message_close_container(m);
2737 }
2738
2739 static int bus_message_close_header(sd_bus_message *m) {
2740         uint8_t *a;
2741         size_t sz, i;
2742
2743         assert(m);
2744
2745         if (!BUS_MESSAGE_IS_GVARIANT(m))
2746                 return 0;
2747
2748         if (m->n_header_offsets < 1)
2749                 return 0;
2750
2751         assert(m->header->fields_size == m->header_offsets[m->n_header_offsets-1]);
2752
2753         sz = determine_word_size(m->header->fields_size, m->n_header_offsets);
2754
2755         a = message_extend_fields(m, 1, sz * m->n_header_offsets, false);
2756         if (!a)
2757                 return -ENOMEM;
2758
2759         for (i = 0; i < m->n_header_offsets; i++)
2760                 write_word_le(a + sz*i, sz, m->header_offsets[i]);
2761
2762         return 0;
2763 }
2764
2765 int bus_message_seal(sd_bus_message *m, uint64_t cookie, usec_t timeout) {
2766         struct bus_body_part *part;
2767         size_t l, a;
2768         unsigned i;
2769         int r;
2770
2771         assert(m);
2772
2773         if (m->sealed)
2774                 return -EPERM;
2775
2776         if (m->n_containers > 0)
2777                 return -EBADMSG;
2778
2779         if (m->poisoned)
2780                 return -ESTALE;
2781
2782         /* In vtables the return signature of method calls is listed,
2783          * let's check if they match if this is a response */
2784         if (m->header->type == SD_BUS_MESSAGE_METHOD_RETURN &&
2785             m->enforced_reply_signature &&
2786             !streq(strempty(m->root_container.signature), m->enforced_reply_signature))
2787                 return -ENOMSG;
2788
2789         /* If gvariant marshalling is used we need to close the body structure */
2790         r = bus_message_close_struct(m, &m->root_container, false);
2791         if (r < 0)
2792                 return r;
2793
2794         /* If there's a non-trivial signature set, then add it in here */
2795         if (!isempty(m->root_container.signature)) {
2796                 r = message_append_field_signature(m, BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL);
2797                 if (r < 0)
2798                         return r;
2799         }
2800
2801         if (m->n_fds > 0) {
2802                 r = message_append_field_uint32(m, BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds);
2803                 if (r < 0)
2804                         return r;
2805         }
2806
2807         r = bus_message_close_header(m);
2808         if (r < 0)
2809                 return r;
2810
2811         m->header->serial = (uint32_t) cookie;
2812         m->timeout = m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED ? 0 : timeout;
2813
2814         /* Add padding at the end of the fields part, since we know
2815          * the body needs to start at an 8 byte alignment. We made
2816          * sure we allocated enough space for this, so all we need to
2817          * do here is to zero it out. */
2818         l = BUS_MESSAGE_FIELDS_SIZE(m);
2819         a = ALIGN8(l) - l;
2820         if (a > 0)
2821                 memzero((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, a);
2822
2823         /* If this is something we can send as memfd, then let's seal
2824         the memfd now. Note that we can send memfds as payload only
2825         for directed messages, and not for broadcasts. */
2826         if (m->destination && m->bus->use_memfd) {
2827                 MESSAGE_FOREACH_PART(part, i, m)
2828                         if (part->memfd >= 0 && !part->sealed && (part->size > MEMFD_MIN_SIZE || m->bus->use_memfd < 0)) {
2829                                 uint64_t sz;
2830
2831                                 /* Try to seal it if that makes
2832                                  * sense. First, unmap our own map to
2833                                  * make sure we don't keep it busy. */
2834                                 bus_body_part_unmap(part);
2835
2836                                 /* Then, sync up real memfd size */
2837                                 sz = part->size;
2838                                 r = memfd_set_size(part->memfd, sz);
2839                                 if (r < 0)
2840                                         return r;
2841
2842                                 /* Finally, try to seal */
2843                                 if (memfd_set_sealed(part->memfd) >= 0)
2844                                         part->sealed = true;
2845                         }
2846         }
2847
2848         m->root_container.end = BUS_MESSAGE_BODY_SIZE(m);
2849         m->root_container.index = 0;
2850         m->root_container.offset_index = 0;
2851         m->root_container.item_size = m->root_container.n_offsets > 0 ? m->root_container.offsets[0] : 0;
2852
2853         m->sealed = true;
2854
2855         return 0;
2856 }
2857
2858 int bus_body_part_map(struct bus_body_part *part) {
2859         void *p;
2860         size_t psz;
2861
2862         assert_se(part);
2863
2864         if (part->data)
2865                 return 0;
2866
2867         if (part->size <= 0)
2868                 return 0;
2869
2870         /* For smaller zero parts (as used for padding) we don't need to map anything... */
2871         if (part->memfd < 0 && part->is_zero && part->size < 8) {
2872                 static const uint8_t zeroes[7] = { };
2873                 part->data = (void*) zeroes;
2874                 return 0;
2875         }
2876
2877         psz = PAGE_ALIGN(part->size);
2878
2879         if (part->memfd >= 0)
2880                 p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE, part->memfd, 0);
2881         else if (part->is_zero)
2882                 p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
2883         else
2884                 return -EINVAL;
2885
2886         if (p == MAP_FAILED)
2887                 return -errno;
2888
2889         part->mapped = psz;
2890         part->data = p;
2891         part->munmap_this = true;
2892
2893         return 0;
2894 }
2895
2896 void bus_body_part_unmap(struct bus_body_part *part) {
2897
2898         assert_se(part);
2899
2900         if (part->memfd < 0)
2901                 return;
2902
2903         if (!part->data)
2904                 return;
2905
2906         if (!part->munmap_this)
2907                 return;
2908
2909         assert_se(munmap(part->data, part->mapped) == 0);
2910
2911         part->data = NULL;
2912         part->mapped = 0;
2913         part->munmap_this = false;
2914
2915         return;
2916 }
2917
2918 static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) {
2919         size_t k, start, end;
2920
2921         assert(rindex);
2922         assert(align > 0);
2923
2924         start = ALIGN_TO((size_t) *rindex, align);
2925         end = start + nbytes;
2926
2927         if (end > sz)
2928                 return -EBADMSG;
2929
2930         /* Verify that padding is 0 */
2931         for (k = *rindex; k < start; k++)
2932                 if (((const uint8_t*) p)[k] != 0)
2933                         return -EBADMSG;
2934
2935         if (r)
2936                 *r = (uint8_t*) p + start;
2937
2938         *rindex = end;
2939
2940         return 1;
2941 }
2942
2943 static bool message_end_of_signature(sd_bus_message *m) {
2944         struct bus_container *c;
2945
2946         assert(m);
2947
2948         c = message_get_container(m);
2949         return !c->signature || c->signature[c->index] == 0;
2950 }
2951
2952 static bool message_end_of_array(sd_bus_message *m, size_t index) {
2953         struct bus_container *c;
2954
2955         assert(m);
2956
2957         c = message_get_container(m);
2958         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2959                 return false;
2960
2961         if (BUS_MESSAGE_IS_GVARIANT(m))
2962                 return index >= c->end;
2963         else {
2964                 assert(c->array_size);
2965                 return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
2966         }
2967 }
2968
2969 _public_ int sd_bus_message_at_end(sd_bus_message *m, int complete) {
2970         assert_return(m, -EINVAL);
2971         assert_return(m->sealed, -EPERM);
2972
2973         if (complete && m->n_containers > 0)
2974                 return false;
2975
2976         if (message_end_of_signature(m))
2977                 return true;
2978
2979         if (message_end_of_array(m, m->rindex))
2980                 return true;
2981
2982         return false;
2983 }
2984
2985 static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) {
2986         struct bus_body_part *part;
2987         size_t begin;
2988         int r;
2989
2990         assert(m);
2991
2992         if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) {
2993                 part = m->cached_rindex_part;
2994                 begin = m->cached_rindex_part_begin;
2995         } else {
2996                 part = &m->body;
2997                 begin = 0;
2998         }
2999
3000         while (part) {
3001                 if (index < begin)
3002                         return NULL;
3003
3004                 if (index + sz <= begin + part->size) {
3005
3006                         r = bus_body_part_map(part);
3007                         if (r < 0)
3008                                 return NULL;
3009
3010                         if (p)
3011                                 *p = (uint8_t*) part->data + index - begin;
3012
3013                         m->cached_rindex_part = part;
3014                         m->cached_rindex_part_begin = begin;
3015
3016                         return part;
3017                 }
3018
3019                 begin += part->size;
3020                 part = part->next;
3021         }
3022
3023         return NULL;
3024 }
3025
3026 static int container_next_item(sd_bus_message *m, struct bus_container *c, size_t *rindex) {
3027         int r;
3028
3029         assert(m);
3030         assert(c);
3031         assert(rindex);
3032
3033         if (!BUS_MESSAGE_IS_GVARIANT(m))
3034                 return 0;
3035
3036         if (c->enclosing == SD_BUS_TYPE_ARRAY) {
3037                 int sz;
3038
3039                 sz = bus_gvariant_get_size(c->signature);
3040                 if (sz < 0) {
3041                         int alignment;
3042
3043                         if (c->offset_index+1 >= c->n_offsets)
3044                                 goto end;
3045
3046                         /* Variable-size array */
3047
3048                         alignment = bus_gvariant_get_alignment(c->signature);
3049                         assert(alignment > 0);
3050
3051                         *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment);
3052                         c->item_size = c->offsets[c->offset_index+1] - *rindex;
3053                 } else {
3054
3055                         if (c->offset_index+1 >= (c->end-c->begin)/sz)
3056                                 goto end;
3057
3058                         /* Fixed-size array */
3059                         *rindex = c->begin + (c->offset_index+1) * sz;
3060                         c->item_size = sz;
3061                 }
3062
3063                 c->offset_index++;
3064
3065         } else if (c->enclosing == 0 ||
3066                    c->enclosing == SD_BUS_TYPE_STRUCT ||
3067                    c->enclosing == SD_BUS_TYPE_DICT_ENTRY) {
3068
3069                 int alignment;
3070                 size_t n, j;
3071
3072                 if (c->offset_index+1 >= c->n_offsets)
3073                         goto end;
3074
3075                 r = signature_element_length(c->signature + c->index, &n);
3076                 if (r < 0)
3077                         return r;
3078
3079                 r = signature_element_length(c->signature + c->index + n, &j);
3080                 if (r < 0)
3081                         return r;
3082                 else {
3083                         char t[j+1];
3084                         memcpy(t, c->signature + c->index + n, j);
3085                         t[j] = 0;
3086
3087                         alignment = bus_gvariant_get_alignment(t);
3088                 }
3089
3090                 assert(alignment > 0);
3091
3092                 *rindex = ALIGN_TO(c->offsets[c->offset_index], alignment);
3093                 c->item_size = c->offsets[c->offset_index+1] - *rindex;
3094
3095                 c->offset_index++;
3096
3097         } else if (c->enclosing == SD_BUS_TYPE_VARIANT)
3098                 goto end;
3099         else
3100                 assert_not_reached("Unknown container type");
3101
3102         return 0;
3103
3104 end:
3105         /* Reached the end */
3106         *rindex = c->end;
3107         c->item_size = 0;
3108         return 0;
3109 }
3110
3111
3112 static int message_peek_body(
3113                 sd_bus_message *m,
3114                 size_t *rindex,
3115                 size_t align,
3116                 size_t nbytes,
3117                 void **ret) {
3118
3119         size_t k, start, end, padding;
3120         struct bus_body_part *part;
3121         uint8_t *q;
3122
3123         assert(m);
3124         assert(rindex);
3125         assert(align > 0);
3126
3127         start = ALIGN_TO((size_t) *rindex, align);
3128         padding = start - *rindex;
3129         end = start + nbytes;
3130
3131         if (end > BUS_MESSAGE_BODY_SIZE(m))
3132                 return -EBADMSG;
3133
3134         part = find_part(m, *rindex, padding, (void**) &q);
3135         if (!part)
3136                 return -EBADMSG;
3137
3138         if (q) {
3139                 /* Verify padding */
3140                 for (k = 0; k < padding; k++)
3141                         if (q[k] != 0)
3142                                 return -EBADMSG;
3143         }
3144
3145         part = find_part(m, start, nbytes, (void**) &q);
3146         if (!part || (nbytes > 0 && !q))
3147                 return -EBADMSG;
3148
3149         *rindex = end;
3150
3151         if (ret)
3152                 *ret = q;
3153
3154         return 0;
3155 }
3156
3157 static bool validate_nul(const char *s, size_t l) {
3158
3159         /* Check for NUL chars in the string */
3160         if (memchr(s, 0, l))
3161                 return false;
3162
3163         /* Check for NUL termination */
3164         if (s[l] != 0)
3165                 return false;
3166
3167         return true;
3168 }
3169
3170 static bool validate_string(const char *s, size_t l) {
3171
3172         if (!validate_nul(s, l))
3173                 return false;
3174
3175         /* Check if valid UTF8 */
3176         if (!utf8_is_valid(s))
3177                 return false;
3178
3179         return true;
3180 }
3181
3182 static bool validate_signature(const char *s, size_t l) {
3183
3184         if (!validate_nul(s, l))
3185                 return false;
3186
3187         /* Check if valid signature */
3188         if (!signature_is_valid(s, true))
3189                 return false;
3190
3191         return true;
3192 }
3193
3194 static bool validate_object_path(const char *s, size_t l) {
3195
3196         if (!validate_nul(s, l))
3197                 return false;
3198
3199         if (!object_path_is_valid(s))
3200                 return false;
3201
3202         return true;
3203 }
3204
3205 _public_ int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
3206         struct bus_container *c;
3207         size_t rindex;
3208         void *q;
3209         int r;
3210
3211         assert_return(m, -EINVAL);
3212         assert_return(m->sealed, -EPERM);
3213         assert_return(bus_type_is_basic(type), -EINVAL);
3214
3215         if (message_end_of_signature(m))
3216                 return -ENXIO;
3217
3218         if (message_end_of_array(m, m->rindex))
3219                 return 0;
3220
3221         c = message_get_container(m);
3222         if (c->signature[c->index] != type)
3223                 return -ENXIO;
3224
3225         rindex = m->rindex;
3226
3227         if (BUS_MESSAGE_IS_GVARIANT(m)) {
3228
3229                 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE)) {
3230                         bool ok;
3231
3232                         r = message_peek_body(m, &rindex, 1, c->item_size, &q);
3233                         if (r < 0)
3234                                 return r;
3235
3236                         if (type == SD_BUS_TYPE_STRING)
3237                                 ok = validate_string(q, c->item_size-1);
3238                         else if (type == SD_BUS_TYPE_OBJECT_PATH)
3239                                 ok = validate_object_path(q, c->item_size-1);
3240                         else
3241                                 ok = validate_signature(q, c->item_size-1);
3242
3243                         if (!ok)
3244                                 return -EBADMSG;
3245
3246                         if (p)
3247                                 *(const char**) p = q;
3248                 } else {
3249                         int sz, align;
3250
3251                         sz = bus_gvariant_get_size(CHAR_TO_STR(type));
3252                         assert(sz > 0);
3253                         if ((size_t) sz != c->item_size)
3254                                 return -EBADMSG;
3255
3256                         align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
3257                         assert(align > 0);
3258
3259                         r = message_peek_body(m, &rindex, align, c->item_size, &q);
3260                         if (r < 0)
3261                                 return r;
3262
3263                         switch (type) {
3264
3265                         case SD_BUS_TYPE_BYTE:
3266                                 if (p)
3267                                         *(uint8_t*) p = *(uint8_t*) q;
3268                                 break;
3269
3270                         case SD_BUS_TYPE_BOOLEAN:
3271                                 if (p)
3272                                         *(int*) p = !!*(uint8_t*) q;
3273                                 break;
3274
3275                         case SD_BUS_TYPE_INT16:
3276                         case SD_BUS_TYPE_UINT16:
3277                                 if (p)
3278                                         *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
3279                                 break;
3280
3281                         case SD_BUS_TYPE_INT32:
3282                         case SD_BUS_TYPE_UINT32:
3283                                 if (p)
3284                                         *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3285                                 break;
3286
3287                         case SD_BUS_TYPE_INT64:
3288                         case SD_BUS_TYPE_UINT64:
3289                         case SD_BUS_TYPE_DOUBLE:
3290                                 if (p)
3291                                         *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
3292                                 break;
3293
3294                         case SD_BUS_TYPE_UNIX_FD: {
3295                                 uint32_t j;
3296
3297                                 j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3298                                 if (j >= m->n_fds)
3299                                         return -EBADMSG;
3300
3301                                 if (p)
3302                                         *(int*) p = m->fds[j];
3303
3304                                 break;
3305                         }
3306
3307                         default:
3308                                 assert_not_reached("unexpected type");
3309                         }
3310                 }
3311
3312                 r = container_next_item(m, c, &rindex);
3313                 if (r < 0)
3314                         return r;
3315         } else {
3316
3317                 rindex = m->rindex;
3318
3319                 if (IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH)) {
3320                         uint32_t l;
3321                         bool ok;
3322
3323                         r = message_peek_body(m, &rindex, 4, 4, &q);
3324                         if (r < 0)
3325                                 return r;
3326
3327                         l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3328                         r = message_peek_body(m, &rindex, 1, l+1, &q);
3329                         if (r < 0)
3330                                 return r;
3331
3332                         if (type == SD_BUS_TYPE_OBJECT_PATH)
3333                                 ok = validate_object_path(q, l);
3334                         else
3335                                 ok = validate_string(q, l);
3336                         if (!ok)
3337                                 return -EBADMSG;
3338
3339                         if (p)
3340                                 *(const char**) p = q;
3341
3342                 } else if (type == SD_BUS_TYPE_SIGNATURE) {
3343                         uint8_t l;
3344
3345                         r = message_peek_body(m, &rindex, 1, 1, &q);
3346                         if (r < 0)
3347                                 return r;
3348
3349                         l = *(uint8_t*) q;
3350                         r = message_peek_body(m, &rindex, 1, l+1, &q);
3351                         if (r < 0)
3352                                 return r;
3353
3354                         if (!validate_signature(q, l))
3355                                 return -EBADMSG;
3356
3357                         if (p)
3358                                 *(const char**) p = q;
3359
3360                 } else {
3361                         ssize_t sz, align;
3362
3363                         align = bus_type_get_alignment(type);
3364                         assert(align > 0);
3365
3366                         sz = bus_type_get_size(type);
3367                         assert(sz > 0);
3368
3369                         r = message_peek_body(m, &rindex, align, sz, &q);
3370                         if (r < 0)
3371                                 return r;
3372
3373                         switch (type) {
3374
3375                         case SD_BUS_TYPE_BYTE:
3376                                 if (p)
3377                                         *(uint8_t*) p = *(uint8_t*) q;
3378                                 break;
3379
3380                         case SD_BUS_TYPE_BOOLEAN:
3381                                 if (p)
3382                                         *(int*) p = !!*(uint32_t*) q;
3383                                 break;
3384
3385                         case SD_BUS_TYPE_INT16:
3386                         case SD_BUS_TYPE_UINT16:
3387                                 if (p)
3388                                         *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
3389                                 break;
3390
3391                         case SD_BUS_TYPE_INT32:
3392                         case SD_BUS_TYPE_UINT32:
3393                                 if (p)
3394                                         *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3395                                 break;
3396
3397                         case SD_BUS_TYPE_INT64:
3398                         case SD_BUS_TYPE_UINT64:
3399                         case SD_BUS_TYPE_DOUBLE:
3400                                 if (p)
3401                                         *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
3402                                 break;
3403
3404                         case SD_BUS_TYPE_UNIX_FD: {
3405                                 uint32_t j;
3406
3407                                 j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3408                                 if (j >= m->n_fds)
3409                                         return -EBADMSG;
3410
3411                                 if (p)
3412                                         *(int*) p = m->fds[j];
3413                                 break;
3414                         }
3415
3416                         default:
3417                                 assert_not_reached("Unknown basic type...");
3418                         }
3419                 }
3420         }
3421
3422         m->rindex = rindex;
3423
3424         if (c->enclosing != SD_BUS_TYPE_ARRAY)
3425                 c->index++;
3426
3427         return 1;
3428 }
3429
3430 static int bus_message_enter_array(
3431                 sd_bus_message *m,
3432                 struct bus_container *c,
3433                 const char *contents,
3434                 uint32_t **array_size,
3435                 size_t *item_size,
3436                 size_t **offsets,
3437                 size_t *n_offsets) {
3438
3439         size_t rindex;
3440         void *q;
3441         int r, alignment;
3442
3443         assert(m);
3444         assert(c);
3445         assert(contents);
3446         assert(array_size);
3447         assert(item_size);
3448         assert(offsets);
3449         assert(n_offsets);
3450
3451         if (!signature_is_single(contents, true))
3452                 return -EINVAL;
3453
3454         if (!c->signature || c->signature[c->index] == 0)
3455                 return -ENXIO;
3456
3457         if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
3458                 return -ENXIO;
3459
3460         if (!startswith(c->signature + c->index + 1, contents))
3461                 return -ENXIO;
3462
3463         rindex = m->rindex;
3464
3465         if (!BUS_MESSAGE_IS_GVARIANT(m)) {
3466                 /* dbus1 */
3467
3468                 r = message_peek_body(m, &rindex, 4, 4, &q);
3469                 if (r < 0)
3470                         return r;
3471
3472                 if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
3473                         return -EBADMSG;
3474
3475                 alignment = bus_type_get_alignment(contents[0]);
3476                 if (alignment < 0)
3477                         return alignment;
3478
3479                 r = message_peek_body(m, &rindex, alignment, 0, NULL);
3480                 if (r < 0)
3481                         return r;
3482
3483                 *array_size = (uint32_t*) q;
3484
3485         } else if (c->item_size <= 0) {
3486
3487                 /* gvariant: empty array */
3488                 *item_size = 0;
3489                 *offsets = NULL;
3490                 *n_offsets = 0;
3491
3492         } else if (bus_gvariant_is_fixed_size(contents)) {
3493
3494                 /* gvariant: fixed length array */
3495                 *item_size = bus_gvariant_get_size(contents);
3496                 *offsets = NULL;
3497                 *n_offsets = 0;
3498
3499         } else {
3500                 size_t where, p = 0, framing, sz;
3501                 unsigned i;
3502
3503                 /* gvariant: variable length array */
3504                 sz = determine_word_size(c->item_size, 0);
3505
3506                 where = rindex + c->item_size - sz;
3507                 r = message_peek_body(m, &where, 1, sz, &q);
3508                 if (r < 0)
3509                         return r;
3510
3511                 framing = read_word_le(q, sz);
3512                 if (framing > c->item_size - sz)
3513                         return -EBADMSG;
3514                 if ((c->item_size - framing) % sz != 0)
3515                         return -EBADMSG;
3516
3517                 *n_offsets = (c->item_size - framing) / sz;
3518
3519                 where = rindex + framing;
3520                 r = message_peek_body(m, &where, 1, *n_offsets * sz, &q);
3521                 if (r < 0)
3522                         return r;
3523
3524                 *offsets = new(size_t, *n_offsets);
3525                 if (!*offsets)
3526                         return -ENOMEM;
3527
3528                 for (i = 0; i < *n_offsets; i++) {
3529                         size_t x;
3530
3531                         x = read_word_le((uint8_t*) q + i * sz, sz);
3532                         if (x > c->item_size - sz)
3533                                 return -EBADMSG;
3534                         if (x < p)
3535                                 return -EBADMSG;
3536
3537                         (*offsets)[i] = rindex + x;
3538                         p = x;
3539                 }
3540
3541                 *item_size = (*offsets)[0] - rindex;
3542         }
3543
3544         m->rindex = rindex;
3545
3546         if (c->enclosing != SD_BUS_TYPE_ARRAY)
3547                 c->index += 1 + strlen(contents);
3548
3549         return 1;
3550 }
3551
3552 static int bus_message_enter_variant(
3553                 sd_bus_message *m,
3554                 struct bus_container *c,
3555                 const char *contents,
3556                 size_t *item_size) {
3557
3558         size_t rindex;
3559         uint8_t l;
3560         void *q;
3561         int r;
3562
3563         assert(m);
3564         assert(c);
3565         assert(contents);
3566         assert(item_size);
3567
3568         if (!signature_is_single(contents, false))
3569                 return -EINVAL;
3570
3571         if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
3572                 return -EINVAL;
3573
3574         if (!c->signature || c->signature[c->index] == 0)
3575                 return -ENXIO;
3576
3577         if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
3578                 return -ENXIO;
3579
3580         rindex = m->rindex;
3581
3582         if (BUS_MESSAGE_IS_GVARIANT(m)) {
3583                 size_t k, where;
3584
3585                 k = strlen(contents);
3586                 if (1+k > c->item_size)
3587                         return -EBADMSG;
3588
3589                 where = rindex + c->item_size - (1+k);
3590                 r = message_peek_body(m, &where, 1, 1+k, &q);
3591                 if (r < 0)
3592                         return r;
3593
3594                 if (*(char*) q != 0)
3595                         return -EBADMSG;
3596
3597                 if (memcmp((uint8_t*) q+1, contents, k))
3598                         return -ENXIO;
3599
3600                 *item_size = c->item_size - (1+k);
3601
3602         } else {
3603                 r = message_peek_body(m, &rindex, 1, 1, &q);
3604                 if (r < 0)
3605                         return r;
3606
3607                 l = *(uint8_t*) q;
3608                 r = message_peek_body(m, &rindex, 1, l+1, &q);
3609                 if (r < 0)
3610                         return r;
3611
3612                 if (!validate_signature(q, l))
3613                         return -EBADMSG;
3614
3615                 if (!streq(q, contents))
3616                         return -ENXIO;
3617         }
3618
3619         m->rindex = rindex;
3620
3621         if (c->enclosing != SD_BUS_TYPE_ARRAY)
3622                 c->index++;
3623
3624         return 1;
3625 }
3626
3627 static int build_struct_offsets(
3628                 sd_bus_message *m,
3629                 const char *signature,
3630                 size_t size,
3631                 size_t *item_size,
3632                 size_t **offsets,
3633                 size_t *n_offsets) {
3634
3635         unsigned n_variable = 0, n_total = 0, v;
3636         size_t previous = 0, where;
3637         const char *p;
3638         size_t sz;
3639         void *q;
3640         int r;
3641
3642         assert(m);
3643         assert(item_size);
3644         assert(offsets);
3645         assert(n_offsets);
3646
3647         if (isempty(signature)) {
3648                 *item_size = 0;
3649                 *offsets = NULL;
3650                 *n_offsets = 0;
3651                 return 0;
3652         }
3653
3654         sz = determine_word_size(size, 0);
3655         if (sz <= 0)
3656                 return -EBADMSG;
3657
3658         /* First, loop over signature and count variable elements and
3659          * elements in general. We use this to know how large the
3660          * offset array is at the end of the structure. Note that
3661          * GVariant only stores offsets for all variable size elements
3662          * that are not the last item. */
3663
3664         p = signature;
3665         while (*p != 0) {
3666                 size_t n;
3667
3668                 r = signature_element_length(p, &n);
3669                 if (r < 0)
3670                         return r;
3671                 else {
3672                         char t[n+1];
3673
3674                         memcpy(t, p, n);
3675                         t[n] = 0;
3676
3677                         r = bus_gvariant_is_fixed_size(t);
3678                 }
3679
3680                 if (r < 0)
3681                         return r;
3682                 if (r == 0 && p[n] != 0) /* except the last item */
3683                         n_variable ++;
3684                 n_total++;
3685
3686                 p += n;
3687         }
3688
3689         if (size < n_variable * sz)
3690                 return -EBADMSG;
3691
3692         where = m->rindex + size - (n_variable * sz);
3693         r = message_peek_body(m, &where, 1, n_variable * sz, &q);
3694         if (r < 0)
3695                 return r;
3696
3697         v = n_variable;
3698
3699         *offsets = new(size_t, n_total);
3700         if (!*offsets)
3701                 return -ENOMEM;
3702
3703         *n_offsets = 0;
3704
3705         /* Second, loop again and build an offset table */
3706         p = signature;
3707         while (*p != 0) {
3708                 size_t n, offset;
3709                 int k;
3710
3711                 r = signature_element_length(p, &n);
3712                 if (r < 0)
3713                         return r;
3714                 else {
3715                         char t[n+1];
3716
3717                         memcpy(t, p, n);
3718                         t[n] = 0;
3719
3720                         k = bus_gvariant_get_size(t);
3721                         if (k < 0) {
3722                                 size_t x;
3723
3724                                 /* variable size */
3725                                 if (v > 0) {
3726                                         v--;
3727
3728                                         x = read_word_le((uint8_t*) q + v*sz, sz);
3729                                         if (x >= size)
3730                                                 return -EBADMSG;
3731                                         if (m->rindex + x < previous)
3732                                                 return -EBADMSG;
3733                                 } else
3734                                         /* The last item's end
3735                                          * is determined from
3736                                          * the start of the
3737                                          * offset array */
3738                                         x = size - (n_variable * sz);
3739
3740                                 offset = m->rindex + x;
3741
3742                         } else {
3743                                 size_t align;
3744
3745                                 /* fixed size */
3746                                 align = bus_gvariant_get_alignment(t);
3747                                 assert(align > 0);
3748
3749                                 offset = (*n_offsets == 0 ? m->rindex  : ALIGN_TO((*offsets)[*n_offsets-1], align)) + k;
3750                         }
3751                 }
3752
3753                 previous = (*offsets)[(*n_offsets)++] = offset;
3754                 p += n;
3755         }
3756
3757         assert(v == 0);
3758         assert(*n_offsets == n_total);
3759
3760         *item_size = (*offsets)[0] - m->rindex;
3761         return 0;
3762 }
3763
3764 static int enter_struct_or_dict_entry(
3765                 sd_bus_message *m,
3766                 struct bus_container *c,
3767                 const char *contents,
3768                 size_t *item_size,
3769                 size_t **offsets,
3770                 size_t *n_offsets) {
3771
3772         int r;
3773
3774         assert(m);
3775         assert(c);
3776         assert(contents);
3777         assert(item_size);
3778         assert(offsets);
3779         assert(n_offsets);
3780
3781         if (!BUS_MESSAGE_IS_GVARIANT(m)) {
3782
3783                 /* dbus1 */
3784                 r = message_peek_body(m, &m->rindex, 8, 0, NULL);
3785                 if (r < 0)
3786                         return r;
3787
3788         } else if (c->item_size <= 0) {
3789
3790                 /* gvariant empty struct */
3791                 *item_size = 0;
3792                 *offsets = NULL;
3793                 *n_offsets = 0;
3794         } else
3795                 /* gvariant with contents */
3796                 return build_struct_offsets(m, contents, c->item_size, item_size, offsets, n_offsets);
3797
3798         return 0;
3799 }
3800
3801 static int bus_message_enter_struct(
3802                 sd_bus_message *m,
3803                 struct bus_container *c,
3804                 const char *contents,
3805                 size_t *item_size,
3806                 size_t **offsets,
3807                 size_t *n_offsets) {
3808
3809         size_t l;
3810         int r;
3811
3812         assert(m);
3813         assert(c);
3814         assert(contents);
3815         assert(item_size);
3816         assert(offsets);
3817         assert(n_offsets);
3818
3819         if (!signature_is_valid(contents, false))
3820                 return -EINVAL;
3821
3822         if (!c->signature || c->signature[c->index] == 0)
3823                 return -ENXIO;
3824
3825         l = strlen(contents);
3826
3827         if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
3828             !startswith(c->signature + c->index + 1, contents) ||
3829             c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
3830                 return -ENXIO;
3831
3832         r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets);
3833         if (r < 0)
3834                 return r;
3835
3836         if (c->enclosing != SD_BUS_TYPE_ARRAY)
3837                 c->index += 1 + l + 1;
3838
3839         return 1;
3840 }
3841
3842 static int bus_message_enter_dict_entry(
3843                 sd_bus_message *m,
3844                 struct bus_container *c,
3845                 const char *contents,
3846                 size_t *item_size,
3847                 size_t **offsets,
3848                 size_t *n_offsets) {
3849
3850         size_t l;
3851         int r;
3852
3853         assert(m);
3854         assert(c);
3855         assert(contents);
3856
3857         if (!signature_is_pair(contents))
3858                 return -EINVAL;
3859
3860         if (c->enclosing != SD_BUS_TYPE_ARRAY)
3861                 return -ENXIO;
3862
3863         if (!c->signature || c->signature[c->index] == 0)
3864                 return 0;
3865
3866         l = strlen(contents);
3867
3868         if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
3869             !startswith(c->signature + c->index + 1, contents) ||
3870             c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
3871                 return -ENXIO;
3872
3873         r = enter_struct_or_dict_entry(m, c, contents, item_size, offsets, n_offsets);
3874         if (r < 0)
3875                 return r;
3876
3877         if (c->enclosing != SD_BUS_TYPE_ARRAY)
3878                 c->index += 1 + l + 1;
3879
3880         return 1;
3881 }
3882
3883 _public_ int sd_bus_message_enter_container(sd_bus_message *m,
3884                                             char type,
3885                                             const char *contents) {
3886         struct bus_container *c, *w;
3887         uint32_t *array_size = NULL;
3888         char *signature;
3889         size_t before;
3890         size_t *offsets = NULL;
3891         size_t n_offsets = 0, item_size = 0;
3892         int r;
3893
3894         assert_return(m, -EINVAL);
3895         assert_return(m->sealed, -EPERM);
3896         assert_return(type != 0 || !contents, -EINVAL);
3897
3898         if (type == 0 || !contents) {
3899                 const char *cc;
3900                 char tt;
3901
3902                 /* Allow entering into anonymous containers */
3903                 r = sd_bus_message_peek_type(m, &tt, &cc);
3904                 if (r < 0)
3905                         return r;
3906
3907                 if (type != 0 && type != tt)
3908                         return -ENXIO;
3909
3910                 if (contents && !streq(contents, cc))
3911                         return -ENXIO;
3912
3913                 type = tt;
3914                 contents = cc;
3915         }
3916
3917         /*
3918          * We enforce a global limit on container depth, that is much
3919          * higher than the 32 structs and 32 arrays the specification
3920          * mandates. This is simpler to implement for us, and we need
3921          * this only to ensure our container array doesn't grow
3922          * without bounds. We are happy to return any data from a
3923          * message as long as the data itself is valid, even if the
3924          * overall message might be not.
3925          *
3926          * Note that the message signature is validated when
3927          * parsing the headers, and that validation does check the
3928          * 32/32 limit.
3929          *
3930          * Note that the specification defines no limits on the depth
3931          * of stacked variants, but we do.
3932          */
3933         if (m->n_containers >= BUS_CONTAINER_DEPTH)
3934                 return -EBADMSG;
3935
3936         if (!GREEDY_REALLOC(m->containers, m->containers_allocated, m->n_containers + 1))
3937                 return -ENOMEM;
3938
3939         if (message_end_of_signature(m))
3940                 return -ENXIO;
3941
3942         if (message_end_of_array(m, m->rindex))
3943                 return 0;
3944
3945         c = message_get_container(m);
3946
3947         signature = strdup(contents);
3948         if (!signature)
3949                 return -ENOMEM;
3950
3951         c->saved_index = c->index;
3952         before = m->rindex;
3953
3954         if (type == SD_BUS_TYPE_ARRAY)
3955                 r = bus_message_enter_array(m, c, contents, &array_size, &item_size, &offsets, &n_offsets);
3956         else if (type == SD_BUS_TYPE_VARIANT)
3957                 r = bus_message_enter_variant(m, c, contents, &item_size);
3958         else if (type == SD_BUS_TYPE_STRUCT)
3959                 r = bus_message_enter_struct(m, c, contents, &item_size, &offsets, &n_offsets);
3960         else if (type == SD_BUS_TYPE_DICT_ENTRY)
3961                 r = bus_message_enter_dict_entry(m, c, contents, &item_size, &offsets, &n_offsets);
3962         else
3963                 r = -EINVAL;
3964
3965         if (r <= 0) {
3966                 free(signature);
3967                 free(offsets);
3968                 return r;
3969         }
3970
3971         /* OK, let's fill it in */
3972         w = m->containers + m->n_containers++;
3973         w->enclosing = type;
3974         w->signature = signature;
3975         w->peeked_signature = NULL;
3976         w->index = 0;
3977
3978         w->before = before;
3979         w->begin = m->rindex;
3980         w->end = m->rindex + c->item_size;
3981
3982         w->array_size = array_size;
3983         w->item_size = item_size;
3984         w->offsets = offsets;
3985         w->n_offsets = n_offsets;
3986         w->offset_index = 0;
3987
3988         return 1;
3989 }
3990
3991 _public_ int sd_bus_message_exit_container(sd_bus_message *m) {
3992         struct bus_container *c;
3993         unsigned saved;
3994         int r;
3995
3996         assert_return(m, -EINVAL);
3997         assert_return(m->sealed, -EPERM);
3998         assert_return(m->n_containers > 0, -ENXIO);
3999
4000         c = message_get_container(m);
4001
4002         if (c->enclosing != SD_BUS_TYPE_ARRAY) {
4003                 if (c->signature && c->signature[c->index] != 0)
4004                         return -EBUSY;
4005         }
4006
4007         if (BUS_MESSAGE_IS_GVARIANT(m)) {
4008                 if (m->rindex < c->end)
4009                         return -EBUSY;
4010
4011         } else if (c->enclosing == SD_BUS_TYPE_ARRAY) {
4012                 uint32_t l;
4013
4014                 l = BUS_MESSAGE_BSWAP32(m, *c->array_size);
4015                 if (c->begin + l != m->rindex)
4016                         return -EBUSY;
4017         }
4018
4019         free(c->signature);
4020         free(c->peeked_signature);
4021         free(c->offsets);
4022         m->n_containers--;
4023
4024         c = message_get_container(m);
4025
4026         saved = c->index;
4027         c->index = c->saved_index;
4028         r = container_next_item(m, c, &m->rindex);
4029         c->index = saved;
4030         if (r < 0)
4031                 return r;
4032
4033         return 1;
4034 }
4035
4036 static void message_quit_container(sd_bus_message *m) {
4037         struct bus_container *c;
4038
4039         assert(m);
4040         assert(m->sealed);
4041         assert(m->n_containers > 0);
4042
4043         c = message_get_container(m);
4044
4045         /* Undo seeks */
4046         assert(m->rindex >= c->before);
4047         m->rindex = c->before;
4048
4049         /* Free container */
4050         free(c->signature);
4051         free(c->offsets);
4052         m->n_containers--;
4053
4054         /* Correct index of new top-level container */
4055         c = message_get_container(m);
4056         c->index = c->saved_index;
4057 }
4058
4059 _public_ int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
4060         struct bus_container *c;
4061         int r;
4062
4063         assert_return(m, -EINVAL);
4064         assert_return(m->sealed, -EPERM);
4065
4066         if (message_end_of_signature(m))
4067                 goto eof;
4068
4069         if (message_end_of_array(m, m->rindex))
4070                 goto eof;
4071
4072         c = message_get_container(m);
4073
4074         if (bus_type_is_basic(c->signature[c->index])) {
4075                 if (contents)
4076                         *contents = NULL;
4077                 if (type)
4078                         *type = c->signature[c->index];
4079                 return 1;
4080         }
4081
4082         if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) {
4083
4084                 if (contents) {
4085                         size_t l;
4086                         char *sig;
4087
4088                         r = signature_element_length(c->signature+c->index+1, &l);
4089                         if (r < 0)
4090                                 return r;
4091
4092                         assert(l >= 1);
4093
4094                         sig = strndup(c->signature + c->index + 1, l);
4095                         if (!sig)
4096                                 return -ENOMEM;
4097
4098                         free(c->peeked_signature);
4099                         *contents = c->peeked_signature = sig;
4100                 }
4101
4102                 if (type)
4103                         *type = SD_BUS_TYPE_ARRAY;
4104
4105                 return 1;
4106         }
4107
4108         if (c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ||
4109             c->signature[c->index] == SD_BUS_TYPE_DICT_ENTRY_BEGIN) {
4110
4111                 if (contents) {
4112                         size_t l;
4113                         char *sig;
4114
4115                         r = signature_element_length(c->signature+c->index, &l);
4116                         if (r < 0)
4117                                 return r;
4118
4119                         assert(l >= 2);
4120                         sig = strndup(c->signature + c->index + 1, l - 2);
4121                         if (!sig)
4122                                 return -ENOMEM;
4123
4124                         free(c->peeked_signature);
4125                         *contents = c->peeked_signature = sig;
4126                 }
4127
4128                 if (type)
4129                         *type = c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
4130
4131                 return 1;
4132         }
4133
4134         if (c->signature[c->index] == SD_BUS_TYPE_VARIANT) {
4135                 if (contents) {
4136                         void *q;
4137
4138                         if (BUS_MESSAGE_IS_GVARIANT(m)) {
4139                                 size_t k;
4140
4141                                 if (c->item_size < 2)
4142                                         return -EBADMSG;
4143
4144                                 /* Look for the NUL delimiter that
4145                                    separates the payload from the
4146                                    signature. Since the body might be
4147                                    in a different part that then the
4148                                    signature we map byte by byte. */
4149
4150                                 for (k = 2; k <= c->item_size; k++) {
4151                                         size_t where;
4152
4153                                         where = m->rindex + c->item_size - k;
4154                                         r = message_peek_body(m, &where, 1, k, &q);
4155                                         if (r < 0)
4156                                                 return r;
4157
4158                                         if (*(char*) q == 0)
4159                                                 break;
4160                                 }
4161
4162                                 if (k > c->item_size)
4163                                         return -EBADMSG;
4164
4165                                 free(c->peeked_signature);
4166                                 c->peeked_signature = strndup((char*) q + 1, k - 1);
4167                                 if (!c->peeked_signature)
4168                                         return -ENOMEM;
4169
4170                                 if (!signature_is_valid(c->peeked_signature, true))
4171                                         return -EBADMSG;
4172
4173                                 *contents = c->peeked_signature;
4174                         } else {
4175                                 size_t rindex, l;
4176
4177                                 rindex = m->rindex;
4178                                 r = message_peek_body(m, &rindex, 1, 1, &q);
4179                                 if (r < 0)
4180                                         return r;
4181
4182                                 l = *(uint8_t*) q;
4183                                 r = message_peek_body(m, &rindex, 1, l+1, &q);
4184                                 if (r < 0)
4185                                         return r;
4186
4187                                 if (!validate_signature(q, l))
4188                                         return -EBADMSG;
4189
4190                                 *contents = q;
4191                         }
4192                 }
4193
4194                 if (type)
4195                         *type = SD_BUS_TYPE_VARIANT;
4196
4197                 return 1;
4198         }
4199
4200         return -EINVAL;
4201
4202 eof:
4203         if (type)
4204                 *type = 0;
4205         if (contents)
4206                 *contents = NULL;
4207         return 0;
4208 }
4209
4210 _public_ int sd_bus_message_rewind(sd_bus_message *m, int complete) {
4211         struct bus_container *c;
4212
4213         assert_return(m, -EINVAL);
4214         assert_return(m->sealed, -EPERM);
4215
4216         if (complete) {
4217                 message_reset_containers(m);
4218                 m->rindex = 0;
4219
4220                 c = message_get_container(m);
4221         } else {
4222                 c = message_get_container(m);
4223
4224                 c->offset_index = 0;
4225                 c->index = 0;
4226                 m->rindex = c->begin;
4227         }
4228
4229         c->offset_index = 0;
4230         c->item_size = (c->n_offsets > 0 ? c->offsets[0] : c->end) - c->begin;
4231
4232         return !isempty(c->signature);
4233 }
4234
4235 static int message_read_ap(
4236                 sd_bus_message *m,
4237                 const char *types,
4238                 va_list ap) {
4239
4240         unsigned n_array, n_struct;
4241         TypeStack stack[BUS_CONTAINER_DEPTH];
4242         unsigned stack_ptr = 0;
4243         unsigned n_loop = 0;
4244         int r;
4245
4246         assert(m);
4247
4248         if (isempty(types))
4249                 return 0;
4250
4251         /* Ideally, we'd just call ourselves recursively on every
4252          * complex type. However, the state of a va_list that is
4253          * passed to a function is undefined after that function
4254          * returns. This means we need to docode the va_list linearly
4255          * in a single stackframe. We hence implement our own
4256          * home-grown stack in an array. */
4257
4258         n_array = (unsigned) -1; /* length of current array entries */
4259         n_struct = strlen(types); /* length of current struct contents signature */
4260
4261         for (;;) {
4262                 const char *t;
4263
4264                 n_loop++;
4265
4266                 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
4267                         r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
4268                         if (r < 0)
4269                                 return r;
4270                         if (r == 0)
4271                                 break;
4272
4273                         r = sd_bus_message_exit_container(m);
4274                         if (r < 0)
4275                                 return r;
4276
4277                         continue;
4278                 }
4279
4280                 t = types;
4281                 if (n_array != (unsigned) -1)
4282                         n_array --;
4283                 else {
4284                         types ++;
4285                         n_struct--;
4286                 }
4287
4288                 switch (*t) {
4289
4290                 case SD_BUS_TYPE_BYTE:
4291                 case SD_BUS_TYPE_BOOLEAN:
4292                 case SD_BUS_TYPE_INT16:
4293                 case SD_BUS_TYPE_UINT16:
4294                 case SD_BUS_TYPE_INT32:
4295                 case SD_BUS_TYPE_UINT32:
4296                 case SD_BUS_TYPE_INT64:
4297                 case SD_BUS_TYPE_UINT64:
4298                 case SD_BUS_TYPE_DOUBLE:
4299                 case SD_BUS_TYPE_STRING:
4300                 case SD_BUS_TYPE_OBJECT_PATH:
4301                 case SD_BUS_TYPE_SIGNATURE:
4302                 case SD_BUS_TYPE_UNIX_FD: {
4303                         void *p;
4304
4305                         p = va_arg(ap, void*);
4306                         r = sd_bus_message_read_basic(m, *t, p);
4307                         if (r < 0)
4308                                 return r;
4309                         if (r == 0) {
4310                                 if (n_loop <= 1)
4311                                         return 0;
4312
4313                                 return -ENXIO;
4314                         }
4315
4316                         break;
4317                 }
4318
4319                 case SD_BUS_TYPE_ARRAY: {
4320                         size_t k;
4321
4322                         r = signature_element_length(t + 1, &k);
4323                         if (r < 0)
4324                                 return r;
4325
4326                         {
4327                                 char s[k + 1];
4328                                 memcpy(s, t + 1, k);
4329                                 s[k] = 0;
4330
4331                                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
4332                                 if (r < 0)
4333                                         return r;
4334                                 if (r == 0) {
4335                                         if (n_loop <= 1)
4336                                                 return 0;
4337
4338                                         return -ENXIO;
4339                                 }
4340                         }
4341
4342                         if (n_array == (unsigned) -1) {
4343                                 types += k;
4344                                 n_struct -= k;
4345                         }
4346
4347                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
4348                         if (r < 0)
4349                                 return r;
4350
4351                         types = t + 1;
4352                         n_struct = k;
4353                         n_array = va_arg(ap, unsigned);
4354
4355                         break;
4356                 }
4357
4358                 case SD_BUS_TYPE_VARIANT: {
4359                         const char *s;
4360
4361                         s = va_arg(ap, const char *);
4362                         if (!s)
4363                                 return -EINVAL;
4364
4365                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s);
4366                         if (r < 0)
4367                                 return r;
4368                         if (r == 0) {
4369                                 if (n_loop <= 1)
4370                                         return 0;
4371
4372                                 return -ENXIO;
4373                         }
4374
4375                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
4376                         if (r < 0)
4377                                 return r;
4378
4379                         types = s;
4380                         n_struct = strlen(s);
4381                         n_array = (unsigned) -1;
4382
4383                         break;
4384                 }
4385
4386                 case SD_BUS_TYPE_STRUCT_BEGIN:
4387                 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
4388                         size_t k;
4389
4390                         r = signature_element_length(t, &k);
4391                         if (r < 0)
4392                                 return r;
4393
4394                         {
4395                                 char s[k - 1];
4396                                 memcpy(s, t + 1, k - 2);
4397                                 s[k - 2] = 0;
4398
4399                                 r = sd_bus_message_enter_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
4400                                 if (r < 0)
4401                                         return r;
4402                                 if (r == 0) {
4403                                         if (n_loop <= 1)
4404                                                 return 0;
4405                                         return -ENXIO;
4406                                 }
4407                         }
4408
4409                         if (n_array == (unsigned) -1) {
4410                                 types += k - 1;
4411                                 n_struct -= k - 1;
4412                         }
4413
4414                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
4415                         if (r < 0)
4416                                 return r;
4417
4418                         types = t + 1;
4419                         n_struct = k - 2;
4420                         n_array = (unsigned) -1;
4421
4422                         break;
4423                 }
4424
4425                 default:
4426                         return -EINVAL;
4427                 }
4428         }
4429
4430         return 1;
4431 }
4432
4433 _public_ int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
4434         va_list ap;
4435         int r;
4436
4437         assert_return(m, -EINVAL);
4438         assert_return(m->sealed, -EPERM);
4439         assert_return(types, -EINVAL);
4440
4441         va_start(ap, types);
4442         r = message_read_ap(m, types, ap);
4443         va_end(ap);
4444
4445         return r;
4446 }
4447
4448 _public_ int sd_bus_message_skip(sd_bus_message *m, const char *types) {
4449         int r;
4450
4451         assert_return(m, -EINVAL);
4452         assert_return(m->sealed, -EPERM);
4453
4454         /* If types is NULL, read exactly one element */
4455         if (!types) {
4456                 struct bus_container *c;
4457                 size_t l;
4458
4459                 if (message_end_of_signature(m))
4460                         return -ENXIO;
4461
4462                 if (message_end_of_array(m, m->rindex))
4463                         return 0;
4464
4465                 c = message_get_container(m);
4466
4467                 r = signature_element_length(c->signature + c->index, &l);
4468                 if (r < 0)
4469                         return r;
4470
4471                 types = strndupa(c->signature + c->index, l);
4472         }
4473
4474         switch (*types) {
4475
4476         case 0: /* Nothing to drop */
4477                 return 0;
4478
4479         case SD_BUS_TYPE_BYTE:
4480         case SD_BUS_TYPE_BOOLEAN:
4481         case SD_BUS_TYPE_INT16:
4482         case SD_BUS_TYPE_UINT16:
4483         case SD_BUS_TYPE_INT32:
4484         case SD_BUS_TYPE_UINT32:
4485         case SD_BUS_TYPE_INT64:
4486         case SD_BUS_TYPE_UINT64:
4487         case SD_BUS_TYPE_DOUBLE:
4488         case SD_BUS_TYPE_STRING:
4489         case SD_BUS_TYPE_OBJECT_PATH:
4490         case SD_BUS_TYPE_SIGNATURE:
4491         case SD_BUS_TYPE_UNIX_FD:
4492
4493                 r = sd_bus_message_read_basic(m, *types, NULL);
4494                 if (r <= 0)
4495                         return r;
4496
4497                 r = sd_bus_message_skip(m, types + 1);
4498                 if (r < 0)
4499                         return r;
4500
4501                 return 1;
4502
4503         case SD_BUS_TYPE_ARRAY: {
4504                 size_t k;
4505
4506                 r = signature_element_length(types + 1, &k);
4507                 if (r < 0)
4508                         return r;
4509
4510                 {
4511                         char s[k+1];
4512                         memcpy(s, types+1, k);
4513                         s[k] = 0;
4514
4515                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
4516                         if (r <= 0)
4517                                 return r;
4518
4519                         for (;;) {
4520                                 r = sd_bus_message_skip(m, s);
4521                                 if (r < 0)
4522                                         return r;
4523                                 if (r == 0)
4524                                         break;
4525                         }
4526
4527                         r = sd_bus_message_exit_container(m);
4528                         if (r < 0)
4529                                 return r;
4530                 }
4531
4532                 r = sd_bus_message_skip(m, types + 1 + k);
4533                 if (r < 0)
4534                         return r;
4535
4536                 return 1;
4537         }
4538
4539         case SD_BUS_TYPE_VARIANT: {
4540                 const char *contents;
4541                 char x;
4542
4543                 r = sd_bus_message_peek_type(m, &x, &contents);
4544                 if (r <= 0)
4545                         return r;
4546
4547                 if (x != SD_BUS_TYPE_VARIANT)
4548                         return -ENXIO;
4549
4550                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
4551                 if (r <= 0)
4552                         return r;
4553
4554                 r = sd_bus_message_skip(m, contents);
4555                 if (r < 0)
4556                         return r;
4557                 assert(r != 0);
4558
4559                 r = sd_bus_message_exit_container(m);
4560                 if (r < 0)
4561                         return r;
4562
4563                 r = sd_bus_message_skip(m, types + 1);
4564                 if (r < 0)
4565                         return r;
4566
4567                 return 1;
4568         }
4569
4570         case SD_BUS_TYPE_STRUCT_BEGIN:
4571         case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
4572                 size_t k;
4573
4574                 r = signature_element_length(types, &k);
4575                 if (r < 0)
4576                         return r;
4577
4578                 {
4579                         char s[k-1];
4580                         memcpy(s, types+1, k-2);
4581                         s[k-2] = 0;
4582
4583                         r = sd_bus_message_enter_container(m, *types == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
4584                         if (r <= 0)
4585                                 return r;
4586
4587                         r = sd_bus_message_skip(m, s);
4588                         if (r < 0)
4589                                 return r;
4590                         assert(r != 0);
4591
4592                         r = sd_bus_message_exit_container(m);
4593                         if (r < 0)
4594                                 return r;
4595                 }
4596
4597                 r = sd_bus_message_skip(m, types + k);
4598                 if (r < 0)
4599                         return r;
4600
4601                 return 1;
4602         }
4603
4604         default:
4605                 return -EINVAL;
4606         }
4607 }
4608
4609 _public_ int sd_bus_message_read_array(sd_bus_message *m,
4610                                        char type,
4611                                        const void **ptr,
4612                                        size_t *size) {
4613         struct bus_container *c;
4614         void *p;
4615         size_t sz;
4616         ssize_t align;
4617         int r;
4618
4619         assert_return(m, -EINVAL);
4620         assert_return(m->sealed, -EPERM);
4621         assert_return(bus_type_is_trivial(type), -EINVAL);
4622         assert_return(ptr, -EINVAL);
4623         assert_return(size, -EINVAL);
4624         assert_return(!BUS_MESSAGE_NEED_BSWAP(m), -ENOTSUP);
4625
4626         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
4627         if (r <= 0)
4628                 return r;
4629
4630         c = message_get_container(m);
4631
4632         if (BUS_MESSAGE_IS_GVARIANT(m)) {
4633                 align = bus_gvariant_get_alignment(CHAR_TO_STR(type));
4634                 if (align < 0)
4635                         return align;
4636
4637                 sz = c->end - c->begin;
4638         } else {
4639                 align = bus_type_get_alignment(type);
4640                 if (align < 0)
4641                         return align;
4642
4643                 sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
4644         }
4645
4646         if (sz == 0)
4647                 /* Zero length array, let's return some aligned
4648                  * pointer that is not NULL */
4649                 p = (uint8_t*) NULL + align;
4650         else {
4651                 r = message_peek_body(m, &m->rindex, align, sz, &p);
4652                 if (r < 0)
4653                         goto fail;
4654         }
4655
4656         r = sd_bus_message_exit_container(m);
4657         if (r < 0)
4658                 goto fail;
4659
4660         *ptr = (const void*) p;
4661         *size = sz;
4662
4663         return 1;
4664
4665 fail:
4666         message_quit_container(m);
4667         return r;
4668 }
4669
4670 static int message_peek_fields(
4671                 sd_bus_message *m,
4672                 size_t *rindex,
4673                 size_t align,
4674                 size_t nbytes,
4675                 void **ret) {
4676
4677         assert(m);
4678         assert(rindex);
4679         assert(align > 0);
4680
4681         return buffer_peek(BUS_MESSAGE_FIELDS(m), BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret);
4682 }
4683
4684 static int message_peek_field_uint32(
4685                 sd_bus_message *m,
4686                 size_t *ri,
4687                 size_t item_size,
4688                 uint32_t *ret) {
4689
4690         int r;
4691         void *q;
4692
4693         assert(m);
4694         assert(ri);
4695
4696         if (BUS_MESSAGE_IS_GVARIANT(m) && item_size != 4)
4697                 return -EBADMSG;
4698
4699         /* identical for gvariant and dbus1 */
4700
4701         r = message_peek_fields(m, ri, 4, 4, &q);
4702         if (r < 0)
4703                 return r;
4704
4705         if (ret)
4706                 *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
4707
4708         return 0;
4709 }
4710
4711 static int message_peek_field_string(
4712                 sd_bus_message *m,
4713                 bool (*validate)(const char *p),
4714                 size_t *ri,
4715                 size_t item_size,
4716                 const char **ret) {
4717
4718         uint32_t l;
4719         int r;
4720         void *q;
4721
4722         assert(m);
4723         assert(ri);
4724
4725         if (BUS_MESSAGE_IS_GVARIANT(m)) {
4726
4727                 if (item_size <= 0)
4728                         return -EBADMSG;
4729
4730                 r = message_peek_fields(m, ri, 1, item_size, &q);
4731                 if (r < 0)
4732                         return r;
4733
4734                 l = item_size - 1;
4735         } else {
4736                 r = message_peek_field_uint32(m, ri, 4, &l);
4737                 if (r < 0)
4738                         return r;
4739
4740                 r = message_peek_fields(m, ri, 1, l+1, &q);
4741                 if (r < 0)
4742                         return r;
4743         }
4744
4745         if (validate) {
4746                 if (!validate_nul(q, l))
4747                         return -EBADMSG;
4748
4749                 if (!validate(q))
4750                         return -EBADMSG;
4751         } else {
4752                 if (!validate_string(q, l))
4753                         return -EBADMSG;
4754         }
4755
4756         if (ret)
4757                 *ret = q;
4758
4759         return 0;
4760 }
4761
4762 static int message_peek_field_signature(
4763                 sd_bus_message *m,
4764                 size_t *ri,
4765                 size_t item_size,
4766                 const char **ret) {
4767
4768         size_t l;
4769         int r;
4770         void *q;
4771
4772         assert(m);
4773         assert(ri);
4774
4775         if (BUS_MESSAGE_IS_GVARIANT(m)) {
4776
4777                 if (item_size <= 0)
4778                         return -EBADMSG;
4779
4780                 r = message_peek_fields(m, ri, 1, item_size, &q);
4781                 if (r < 0)
4782                         return r;
4783
4784                 l = item_size - 1;
4785         } else {
4786                 r = message_peek_fields(m, ri, 1, 1, &q);
4787                 if (r < 0)
4788                         return r;
4789
4790                 l = *(uint8_t*) q;
4791                 r = message_peek_fields(m, ri, 1, l+1, &q);
4792                 if (r < 0)
4793                         return r;
4794         }
4795
4796         if (!validate_signature(q, l))
4797                 return -EBADMSG;
4798
4799         if (ret)
4800                 *ret = q;
4801
4802         return 0;
4803 }
4804
4805 static int message_skip_fields(
4806                 sd_bus_message *m,
4807                 size_t *ri,
4808                 uint32_t array_size,
4809                 const char **signature) {
4810
4811         size_t original_index;
4812         int r;
4813
4814         assert(m);
4815         assert(ri);
4816         assert(signature);
4817         assert(!BUS_MESSAGE_IS_GVARIANT(m));
4818
4819         original_index = *ri;
4820
4821         for (;;) {
4822                 char t;
4823                 size_t l;
4824
4825                 if (array_size != (uint32_t) -1 &&
4826                     array_size <= *ri - original_index)
4827                         return 0;
4828
4829                 t = **signature;
4830                 if (!t)
4831                         return 0;
4832
4833                 if (t == SD_BUS_TYPE_STRING) {
4834
4835                         r = message_peek_field_string(m, NULL, ri, 0, NULL);
4836                         if (r < 0)
4837                                 return r;
4838
4839                         (*signature)++;
4840
4841                 } else if (t == SD_BUS_TYPE_OBJECT_PATH) {
4842
4843                         r = message_peek_field_string(m, object_path_is_valid, ri, 0, NULL);
4844                         if (r < 0)
4845                                 return r;
4846
4847                         (*signature)++;
4848
4849                 } else if (t == SD_BUS_TYPE_SIGNATURE) {
4850
4851                         r = message_peek_field_signature(m, ri, 0, NULL);
4852                         if (r < 0)
4853                                 return r;
4854
4855                         (*signature)++;
4856
4857                 } else if (bus_type_is_basic(t)) {
4858                         ssize_t align, k;
4859
4860                         align = bus_type_get_alignment(t);
4861                         k = bus_type_get_size(t);
4862                         assert(align > 0 && k > 0);
4863
4864                         r = message_peek_fields(m, ri, align, k, NULL);
4865                         if (r < 0)
4866                                 return r;
4867
4868                         (*signature)++;
4869
4870                 } else if (t == SD_BUS_TYPE_ARRAY) {
4871
4872                         r = signature_element_length(*signature+1, &l);
4873                         if (r < 0)
4874                                 return r;
4875
4876                         assert(l >= 1);
4877                         {
4878                                 char sig[l-1], *s;
4879                                 uint32_t nas;
4880                                 int alignment;
4881
4882                                 strncpy(sig, *signature + 1, l-1);
4883                                 s = sig;
4884
4885                                 alignment = bus_type_get_alignment(sig[0]);
4886                                 if (alignment < 0)
4887                                         return alignment;
4888
4889                                 r = message_peek_field_uint32(m, ri, 0, &nas);
4890                                 if (r < 0)
4891                                         return r;
4892                                 if (nas > BUS_ARRAY_MAX_SIZE)
4893                                         return -EBADMSG;
4894
4895                                 r = message_peek_fields(m, ri, alignment, 0, NULL);
4896                                 if (r < 0)
4897                                         return r;
4898
4899                                 r = message_skip_fields(m, ri, nas, (const char**) &s);
4900                                 if (r < 0)
4901                                         return r;
4902                         }
4903
4904                         (*signature) += 1 + l;
4905
4906                 } else if (t == SD_BUS_TYPE_VARIANT) {
4907                         const char *s;
4908
4909                         r = message_peek_field_signature(m, ri, 0, &s);
4910                         if (r < 0)
4911                                 return r;
4912
4913                         r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
4914                         if (r < 0)
4915                                 return r;
4916
4917                         (*signature)++;
4918
4919                 } else if (t == SD_BUS_TYPE_STRUCT ||
4920                            t == SD_BUS_TYPE_DICT_ENTRY) {
4921
4922                         r = signature_element_length(*signature, &l);
4923                         if (r < 0)
4924                                 return r;
4925
4926                         assert(l >= 2);
4927                         {
4928                                 char sig[l-1], *s;
4929                                 strncpy(sig, *signature + 1, l-1);
4930                                 s = sig;
4931
4932                                 r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
4933                                 if (r < 0)
4934                                         return r;
4935                         }
4936
4937                         *signature += l;
4938                 } else
4939                         return -EINVAL;
4940         }
4941 }
4942
4943 int bus_message_parse_fields(sd_bus_message *m) {
4944         size_t ri;
4945         int r;
4946         uint32_t unix_fds = 0;
4947         bool unix_fds_set = false;
4948         void *offsets = NULL;
4949         unsigned n_offsets = 0;
4950         size_t sz = 0;
4951         unsigned i = 0;
4952
4953         assert(m);
4954
4955         if (BUS_MESSAGE_IS_GVARIANT(m)) {
4956                 void *q;
4957
4958                 sz = determine_word_size(BUS_MESSAGE_FIELDS_SIZE(m), 0);
4959                 if (sz > 0) {
4960                         size_t framing;
4961
4962                         ri = BUS_MESSAGE_FIELDS_SIZE(m) - sz;
4963                         r = message_peek_fields(m, &ri, 1, sz, &q);
4964                         if (r < 0)
4965                                 return r;
4966
4967                         framing = read_word_le(q, sz);
4968                         if (framing >= BUS_MESSAGE_FIELDS_SIZE(m) - sz)
4969                                 return -EBADMSG;
4970                         if ((BUS_MESSAGE_FIELDS_SIZE(m) - framing) % sz != 0)
4971                                 return -EBADMSG;
4972
4973                         ri = framing;
4974                         r = message_peek_fields(m, &ri, 1, BUS_MESSAGE_FIELDS_SIZE(m) - framing, &offsets);
4975                         if (r < 0)
4976                                 return r;
4977
4978                         n_offsets = (BUS_MESSAGE_FIELDS_SIZE(m) - framing) / sz;
4979                 }
4980         }
4981
4982         ri = 0;
4983         while (ri < BUS_MESSAGE_FIELDS_SIZE(m)) {
4984                 _cleanup_free_ char *sig = NULL;
4985                 const char *signature;
4986                 uint8_t *header;
4987                 size_t item_size = (size_t) -1;
4988
4989                 if (BUS_MESSAGE_IS_GVARIANT(m)) {
4990                         if (i >= n_offsets)
4991                                 break;
4992
4993                         if (i == 0)
4994                                 ri = 0;
4995                         else
4996                                 ri = ALIGN_TO(read_word_le((uint8_t*) offsets + (i-1)*sz, sz), 8);
4997                 }
4998
4999                 r = message_peek_fields(m, &ri, 8, 1, (void**) &header);
5000                 if (r < 0)
5001                         return r;
5002
5003                 if (BUS_MESSAGE_IS_GVARIANT(m)) {
5004                         size_t where, end;
5005                         char *b;
5006                         void *q;
5007
5008                         end = read_word_le((uint8_t*) offsets + i*sz, sz);
5009
5010                         if (end < ri)
5011                                 return -EBADMSG;
5012
5013                         where = ri = ALIGN_TO(ri, 8);
5014                         item_size = end - ri;
5015                         r = message_peek_fields(m, &where, 1, item_size, &q);
5016                         if (r < 0)
5017                                 return r;
5018
5019                         b = memrchr(q, 0, item_size);
5020                         if (!b)
5021                                 return -EBADMSG;
5022
5023                         sig = strndup(b+1, item_size - (b+1-(char*) q));
5024                         if (!sig)
5025                                 return -ENOMEM;
5026
5027                         signature = sig;
5028                         item_size = b - (char*) q;
5029                 } else {
5030                         r = message_peek_field_signature(m, &ri, 0, &signature);
5031                         if (r < 0)
5032                                 return r;
5033                 }
5034
5035                 switch (*header) {
5036                 case _BUS_MESSAGE_HEADER_INVALID:
5037                         return -EBADMSG;
5038
5039                 case BUS_MESSAGE_HEADER_PATH:
5040
5041                         if (m->path)
5042                                 return -EBADMSG;
5043
5044                         if (!streq(signature, "o"))
5045                                 return -EBADMSG;
5046
5047                         r = message_peek_field_string(m, object_path_is_valid, &ri, item_size, &m->path);
5048                         break;
5049
5050                 case BUS_MESSAGE_HEADER_INTERFACE:
5051
5052                         if (m->interface)
5053                                 return -EBADMSG;
5054
5055                         if (!streq(signature, "s"))
5056                                 return -EBADMSG;
5057
5058                         r = message_peek_field_string(m, interface_name_is_valid, &ri, item_size, &m->interface);
5059                         break;
5060
5061                 case BUS_MESSAGE_HEADER_MEMBER:
5062
5063                         if (m->member)
5064                                 return -EBADMSG;
5065
5066                         if (!streq(signature, "s"))
5067                                 return -EBADMSG;
5068
5069                         r = message_peek_field_string(m, member_name_is_valid, &ri, item_size, &m->member);
5070                         break;
5071
5072                 case BUS_MESSAGE_HEADER_ERROR_NAME:
5073
5074                         if (m->error.name)
5075                                 return -EBADMSG;
5076
5077                         if (!streq(signature, "s"))
5078                                 return -EBADMSG;
5079
5080                         r = message_peek_field_string(m, error_name_is_valid, &ri, item_size, &m->error.name);
5081                         if (r >= 0)
5082                                 m->error._need_free = -1;
5083
5084                         break;
5085
5086                 case BUS_MESSAGE_HEADER_DESTINATION:
5087
5088                         if (m->destination)
5089                                 return -EBADMSG;
5090
5091                         if (!streq(signature, "s"))
5092                                 return -EBADMSG;
5093
5094                         r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->destination);
5095                         break;
5096
5097                 case BUS_MESSAGE_HEADER_SENDER:
5098
5099                         if (m->sender)
5100                                 return -EBADMSG;
5101
5102                         if (!streq(signature, "s"))
5103                                 return -EBADMSG;
5104
5105                         r = message_peek_field_string(m, service_name_is_valid, &ri, item_size, &m->sender);
5106
5107                         if (r >= 0 && m->sender[0] == ':' && m->bus->bus_client && !m->bus->is_kernel) {
5108                                 m->creds.unique_name = (char*) m->sender;
5109                                 m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & m->bus->creds_mask;
5110                         }
5111
5112                         break;
5113
5114
5115                 case BUS_MESSAGE_HEADER_SIGNATURE: {
5116                         const char *s;
5117                         char *c;
5118
5119                         if (m->root_container.signature)
5120                                 return -EBADMSG;
5121
5122                         if (!streq(signature, "g"))
5123                                 return -EBADMSG;
5124
5125                         r = message_peek_field_signature(m, &ri, item_size, &s);
5126                         if (r < 0)
5127                                 return r;
5128
5129                         c = strdup(s);
5130                         if (!c)
5131                                 return -ENOMEM;
5132
5133                         free(m->root_container.signature);
5134                         m->root_container.signature = c;
5135                         break;
5136                 }
5137
5138                 case BUS_MESSAGE_HEADER_REPLY_SERIAL: {
5139                         uint32_t serial;
5140
5141                         if (m->reply_cookie != 0)
5142                                 return -EBADMSG;
5143
5144                         if (!streq(signature, "u"))
5145                                 return -EBADMSG;
5146
5147                         r = message_peek_field_uint32(m, &ri, item_size, &serial);
5148                         if (r < 0)
5149                                 return r;
5150
5151                         m->reply_cookie = serial;
5152
5153                         if (m->reply_cookie == 0)
5154                                 return -EBADMSG;
5155
5156                         break;
5157                 }
5158
5159                 case BUS_MESSAGE_HEADER_UNIX_FDS:
5160                         if (unix_fds_set)
5161                                 return -EBADMSG;
5162
5163                         if (!streq(signature, "u"))
5164                                 return -EBADMSG;
5165
5166                         r = message_peek_field_uint32(m, &ri, item_size, &unix_fds);
5167                         if (r < 0)
5168                                 return -EBADMSG;
5169
5170                         unix_fds_set = true;
5171                         break;
5172
5173                 default:
5174                         if (!BUS_MESSAGE_IS_GVARIANT(m))
5175                                 r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
5176                 }
5177
5178                 if (r < 0)
5179                         return r;
5180
5181                 i++;
5182         }
5183
5184         if (m->n_fds != unix_fds)
5185                 return -EBADMSG;
5186
5187         switch (m->header->type) {
5188
5189         case SD_BUS_MESSAGE_SIGNAL:
5190                 if (!m->path || !m->interface || !m->member)
5191                         return -EBADMSG;
5192
5193                 if (m->reply_cookie != 0)
5194                         return -EBADMSG;
5195
5196                 break;
5197
5198         case SD_BUS_MESSAGE_METHOD_CALL:
5199
5200                 if (!m->path || !m->member)
5201                         return -EBADMSG;
5202
5203                 if (m->reply_cookie != 0)
5204                         return -EBADMSG;
5205
5206                 break;
5207
5208         case SD_BUS_MESSAGE_METHOD_RETURN:
5209
5210                 if (m->reply_cookie == 0)
5211                         return -EBADMSG;
5212                 break;
5213
5214         case SD_BUS_MESSAGE_METHOD_ERROR:
5215
5216                 if (m->reply_cookie == 0 || !m->error.name)
5217                         return -EBADMSG;
5218                 break;
5219         }
5220
5221         /* Refuse non-local messages that claim they are local */
5222         if (streq_ptr(m->path, "/org/freedesktop/DBus/Local"))
5223                 return -EBADMSG;
5224         if (streq_ptr(m->interface, "org.freedesktop.DBus.Local"))
5225                 return -EBADMSG;
5226         if (streq_ptr(m->sender, "org.freedesktop.DBus.Local"))
5227                 return -EBADMSG;
5228
5229         m->root_container.end = BUS_MESSAGE_BODY_SIZE(m);
5230
5231         if (BUS_MESSAGE_IS_GVARIANT(m)) {
5232                 r = build_struct_offsets(
5233                                 m,
5234                                 m->root_container.signature,
5235                                 BUS_MESSAGE_BODY_SIZE(m),
5236                                 &m->root_container.item_size,
5237                                 &m->root_container.offsets,
5238                                 &m->root_container.n_offsets);
5239                 if (r < 0)
5240                         return r;
5241         }
5242
5243         /* Try to read the error message, but if we can't it's a non-issue */
5244         if (m->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
5245                 sd_bus_message_read(m, "s", &m->error.message);
5246
5247         return 0;
5248 }
5249
5250 _public_ int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
5251         assert_return(m, -EINVAL);
5252         assert_return(destination, -EINVAL);
5253         assert_return(!m->sealed, -EPERM);
5254         assert_return(!m->destination, -EEXIST);
5255
5256         return message_append_field_string(m, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
5257 }
5258
5259 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
5260         size_t total;
5261         void *p, *e;
5262         unsigned i;
5263         struct bus_body_part *part;
5264
5265         assert(m);
5266         assert(buffer);
5267         assert(sz);
5268
5269         total = BUS_MESSAGE_SIZE(m);
5270
5271         p = malloc(total);
5272         if (!p)
5273                 return -ENOMEM;
5274
5275         e = mempcpy(p, m->header, BUS_MESSAGE_BODY_BEGIN(m));
5276         MESSAGE_FOREACH_PART(part, i, m)
5277                 e = mempcpy(e, part->data, part->size);
5278
5279         assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p));
5280
5281         *buffer = p;
5282         *sz = total;
5283
5284         return 0;
5285 }
5286
5287 int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
5288         int r;
5289
5290         assert(m);
5291         assert(l);
5292
5293         r = sd_bus_message_enter_container(m, 'a', "s");
5294         if (r <= 0)
5295                 return r;
5296
5297         for (;;) {
5298                 const char *s;
5299
5300                 r = sd_bus_message_read_basic(m, 's', &s);
5301                 if (r < 0)
5302                         return r;
5303                 if (r == 0)
5304                         break;
5305
5306                 r = strv_extend(l, s);
5307                 if (r < 0)
5308                         return r;
5309         }
5310
5311         r = sd_bus_message_exit_container(m);
5312         if (r < 0)
5313                 return r;
5314
5315         return 1;
5316 }
5317
5318 _public_ int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
5319         char **strv = NULL;
5320         int r;
5321
5322         assert_return(m, -EINVAL);
5323         assert_return(m->sealed, -EPERM);
5324         assert_return(l, -EINVAL);
5325
5326         r = bus_message_read_strv_extend(m, &strv);
5327         if (r <= 0) {
5328                 strv_free(strv);
5329                 return r;
5330         }
5331
5332         *l = strv;
5333         return 1;
5334 }
5335
5336 int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str, char ***strv) {
5337         const char *contents;
5338         unsigned j;
5339         char type;
5340         int r;
5341
5342         assert(m);
5343         assert(str);
5344         assert(strv);
5345
5346         r = sd_bus_message_rewind(m, true);
5347         if (r < 0)
5348                 return r;
5349
5350         for (j = 0;; j++) {
5351                 r = sd_bus_message_peek_type(m, &type, &contents);
5352                 if (r < 0)
5353                         return r;
5354                 if (r == 0)
5355                         return -ENXIO;
5356
5357                 /* Don't match against arguments after the first one we don't understand */
5358                 if (!IN_SET(type, SD_BUS_TYPE_STRING, SD_BUS_TYPE_OBJECT_PATH, SD_BUS_TYPE_SIGNATURE) &&
5359                     !(type == SD_BUS_TYPE_ARRAY && STR_IN_SET(contents, "s", "o", "g")))
5360                         return -ENXIO;
5361
5362                 if (j >= i)
5363                         break;
5364
5365                 r = sd_bus_message_skip(m, NULL);
5366                 if (r < 0)
5367                         return r;
5368         }
5369
5370         if (type == SD_BUS_TYPE_ARRAY) {
5371
5372                 r = sd_bus_message_read_strv(m, strv);
5373                 if (r < 0)
5374                         return r;
5375
5376                 *str = NULL;
5377
5378         } else {
5379                 r = sd_bus_message_read_basic(m, type, str);
5380                 if (r < 0)
5381                         return r;
5382
5383                 *strv = NULL;
5384         }
5385
5386         return 0;
5387 }
5388
5389 bool bus_header_is_complete(struct bus_header *h, size_t size) {
5390         size_t full;
5391
5392         assert(h);
5393         assert(size);
5394
5395         if (size < sizeof(struct bus_header))
5396                 return false;
5397
5398         full = sizeof(struct bus_header) +
5399                 (h->endian == BUS_NATIVE_ENDIAN ? h->fields_size : bswap_32(h->fields_size));
5400
5401         return size >= full;
5402 }
5403
5404 int bus_header_message_size(struct bus_header *h, size_t *sum) {
5405         size_t fs, bs;
5406
5407         assert(h);
5408         assert(sum);
5409
5410         if (h->endian == BUS_NATIVE_ENDIAN) {
5411                 fs = h->fields_size;
5412                 bs = h->body_size;
5413         } else if (h->endian == BUS_REVERSE_ENDIAN) {
5414                 fs = bswap_32(h->fields_size);
5415                 bs = bswap_32(h->body_size);
5416         } else
5417                 return -EBADMSG;
5418
5419         *sum = sizeof(struct bus_header) + ALIGN8(fs) + bs;
5420         return 0;
5421 }
5422
5423 _public_ int sd_bus_message_get_errno(sd_bus_message *m) {
5424         assert_return(m, EINVAL);
5425
5426         if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
5427                 return 0;
5428
5429         return sd_bus_error_get_errno(&m->error);
5430 }
5431
5432 _public_ const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
5433         struct bus_container *c;
5434
5435         assert_return(m, NULL);
5436
5437         c = complete ? &m->root_container : message_get_container(m);
5438         return strempty(c->signature);
5439 }
5440
5441 _public_ int sd_bus_message_is_empty(sd_bus_message *m) {
5442         assert_return(m, -EINVAL);
5443
5444         return isempty(m->root_container.signature);
5445 }
5446
5447 _public_ int sd_bus_message_has_signature(sd_bus_message *m, const char *signature) {
5448         assert_return(m, -EINVAL);
5449
5450         return streq(strempty(m->root_container.signature), strempty(signature));
5451 }
5452
5453 _public_ int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
5454         bool done_something = false;
5455         int r;
5456
5457         assert_return(m, -EINVAL);
5458         assert_return(source, -EINVAL);
5459         assert_return(!m->sealed, -EPERM);
5460         assert_return(source->sealed, -EPERM);
5461
5462         do {
5463                 const char *contents;
5464                 char type;
5465                 union {
5466                         uint8_t u8;
5467                         uint16_t u16;
5468                         int16_t s16;
5469                         uint32_t u32;
5470                         int32_t s32;
5471                         uint64_t u64;
5472                         int64_t s64;
5473                         double d64;
5474                         const char *string;
5475                         int i;
5476                 } basic;
5477
5478                 r = sd_bus_message_peek_type(source, &type, &contents);
5479                 if (r < 0)
5480                         return r;
5481                 if (r == 0)
5482                         break;
5483
5484                 done_something = true;
5485
5486                 if (bus_type_is_container(type) > 0) {
5487
5488                         r = sd_bus_message_enter_container(source, type, contents);
5489                         if (r < 0)
5490                                 return r;
5491
5492                         r = sd_bus_message_open_container(m, type, contents);
5493                         if (r < 0)
5494                                 return r;
5495
5496                         r = sd_bus_message_copy(m, source, true);
5497                         if (r < 0)
5498                                 return r;
5499
5500                         r = sd_bus_message_close_container(m);
5501                         if (r < 0)
5502                                 return r;
5503
5504                         r = sd_bus_message_exit_container(source);
5505                         if (r < 0)
5506                                 return r;
5507
5508                         continue;
5509                 }
5510
5511                 r = sd_bus_message_read_basic(source, type, &basic);
5512                 if (r < 0)
5513                         return r;
5514
5515                 assert(r > 0);
5516
5517                 if (type == SD_BUS_TYPE_OBJECT_PATH ||
5518                     type == SD_BUS_TYPE_SIGNATURE ||
5519                     type == SD_BUS_TYPE_STRING)
5520                         r = sd_bus_message_append_basic(m, type, basic.string);
5521                 else
5522                         r = sd_bus_message_append_basic(m, type, &basic);
5523
5524                 if (r < 0)
5525                         return r;
5526
5527         } while (all);
5528
5529         return done_something;
5530 }
5531
5532 _public_ int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
5533         const char *c;
5534         char t;
5535         int r;
5536
5537         assert_return(m, -EINVAL);
5538         assert_return(m->sealed, -EPERM);
5539         assert_return(!type || bus_type_is_valid(type), -EINVAL);
5540         assert_return(!contents || signature_is_valid(contents, true), -EINVAL);
5541         assert_return(type || contents, -EINVAL);
5542         assert_return(!contents || !type || bus_type_is_container(type), -EINVAL);
5543
5544         r = sd_bus_message_peek_type(m, &t, &c);
5545         if (r <= 0)
5546                 return r;
5547
5548         if (type != 0 && type != t)
5549                 return 0;
5550
5551         if (contents && !streq_ptr(contents, c))
5552                 return 0;
5553
5554         return 1;
5555 }
5556
5557 _public_ sd_bus *sd_bus_message_get_bus(sd_bus_message *m) {
5558         assert_return(m, NULL);
5559
5560         return m->bus;
5561 }
5562
5563 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m) {
5564         _cleanup_bus_message_unref_ sd_bus_message *n = NULL;
5565         usec_t timeout;
5566         int r;
5567
5568         assert(bus);
5569         assert(m);
5570         assert(*m);
5571
5572         switch ((*m)->header->type) {
5573
5574         case SD_BUS_MESSAGE_SIGNAL:
5575                 r = sd_bus_message_new_signal(bus, &n, (*m)->path, (*m)->interface, (*m)->member);
5576                 if (r < 0)
5577                         return r;
5578
5579                 break;
5580
5581         case SD_BUS_MESSAGE_METHOD_CALL:
5582                 r = sd_bus_message_new_method_call(bus, &n, (*m)->destination, (*m)->path, (*m)->interface, (*m)->member);
5583                 if (r < 0)
5584                         return r;
5585
5586                 break;
5587
5588         case SD_BUS_MESSAGE_METHOD_RETURN:
5589         case SD_BUS_MESSAGE_METHOD_ERROR:
5590
5591                 n = message_new(bus, (*m)->header->type);
5592                 if (!n)
5593                         return -ENOMEM;
5594
5595                 n->reply_cookie = (*m)->reply_cookie;
5596                 r = message_append_field_uint32(n, BUS_MESSAGE_HEADER_REPLY_SERIAL, (uint32_t) n->reply_cookie);
5597                 if (r < 0)
5598                         return r;
5599
5600                 if ((*m)->header->type == SD_BUS_MESSAGE_METHOD_ERROR && (*m)->error.name) {
5601                         r = message_append_field_string(n, BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, (*m)->error.name, &n->error.message);
5602                         if (r < 0)
5603                                 return r;
5604
5605                         n->error._need_free = -1;
5606                 }
5607
5608                 break;
5609
5610         default:
5611                 return -EINVAL;
5612         }
5613
5614         if ((*m)->destination && !n->destination) {
5615                 r = message_append_field_string(n, BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, (*m)->destination, &n->destination);
5616                 if (r < 0)
5617                         return r;
5618         }
5619
5620         if ((*m)->sender && !n->sender) {
5621                 r = message_append_field_string(n, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, (*m)->sender, &n->sender);
5622                 if (r < 0)
5623                         return r;
5624         }
5625
5626         n->header->flags |= (*m)->header->flags & (BUS_MESSAGE_NO_REPLY_EXPECTED|BUS_MESSAGE_NO_AUTO_START);
5627
5628         r = sd_bus_message_copy(n, *m, true);
5629         if (r < 0)
5630                 return r;
5631
5632         timeout = (*m)->timeout;
5633         if (timeout == 0 && !((*m)->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED))
5634                 timeout = BUS_DEFAULT_TIMEOUT;
5635
5636         r = bus_message_seal(n, BUS_MESSAGE_COOKIE(*m), timeout);
5637         if (r < 0)
5638                 return r;
5639
5640         sd_bus_message_unref(*m);
5641         *m = n;
5642         n = NULL;
5643
5644         return 0;
5645 }
5646
5647 int bus_message_append_sender(sd_bus_message *m, const char *sender) {
5648         assert(m);
5649         assert(sender);
5650
5651         assert_return(!m->sealed, -EPERM);
5652         assert_return(!m->sender, -EPERM);
5653
5654         return message_append_field_string(m, BUS_MESSAGE_HEADER_SENDER, SD_BUS_TYPE_STRING, sender, &m->sender);
5655 }
5656
5657 _public_ int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) {
5658         assert_return(m, -EINVAL);
5659         assert_return(priority, -EINVAL);
5660
5661         *priority = m->priority;
5662         return 0;
5663 }
5664
5665 _public_ int sd_bus_message_set_priority(sd_bus_message *m, int64_t priority) {
5666         assert_return(m, -EINVAL);
5667         assert_return(!m->sealed, -EPERM);
5668
5669         m->priority = priority;
5670         return 0;
5671 }