src/libsystemd-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
  32 #include "sd-bus.h"
  33 #include "bus-message.h"
  34 #include "bus-internal.h"
  35 #include "bus-type.h"
  36 #include "bus-signature.h"
  37
  38 static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);
  39
  40 static void *adjust_pointer(const void *p, void *old_base, size_t sz, void *new_base) {
  41
  42         if (p == NULL)
  43                 return NULL;
  44
  45         if (old_base == new_base)
  46                 return (void*) p;
  47
  48         if ((uint8_t*) p < (uint8_t*) old_base)
  49                 return (void*) p;
  50
  51         if ((uint8_t*) p >= (uint8_t*) old_base + sz)
  52                 return (void*) p;
  53
  54         return (uint8_t*) new_base + ((uint8_t*) p - (uint8_t*) old_base);
  55 }
  56
  57 static void message_free_part(sd_bus_message *m, struct bus_body_part *part) {
  58         assert(m);
  59         assert(part);
  60
  61         if (part->memfd >= 0) {
  62                 /* If we can reuse the memfd, try that. For that it
  63                  * can't be sealed yet. */
  64
  65                 if (!part->sealed)
  66                         bus_kernel_push_memfd(m->bus, part->memfd, part->data, part->mapped);
  67                 else {
  68                         if (part->mapped > 0)
  69                                 assert_se(munmap(part->data, part->mapped) == 0);
  70
  71                         close_nointr_nofail(part->memfd);
  72                 }
  73
  74         } else if (part->munmap_this)
  75                 munmap(part->data, part->mapped);
  76         else if (part->free_this)
  77                 free(part->data);
  78
  79         if (part != &m->body)
  80                 free(part);
  81 }
  82
  83 static void message_reset_parts(sd_bus_message *m) {
  84         struct bus_body_part *part;
  85
  86         assert(m);
  87
  88         part = &m->body;
  89         while (m->n_body_parts > 0) {
  90                 struct bus_body_part *next = part->next;
  91                 message_free_part(m, part);
  92                 part = next;
  93                 m->n_body_parts--;
  94         }
  95
  96         m->body_end = NULL;
  97
  98         m->cached_rindex_part = NULL;
  99         m->cached_rindex_part_begin = 0;
 100 }
 101
 102 static void message_reset_containers(sd_bus_message *m) {
 103         unsigned i;
 104
 105         assert(m);
 106
 107         for (i = 0; i < m->n_containers; i++)
 108                 free(m->containers[i].signature);
 109
 110         free(m->containers);
 111         m->containers = NULL;
 112
 113         m->n_containers = 0;
 114         m->root_container.index = 0;
 115 }
 116
 117 static void message_free(sd_bus_message *m) {
 118         assert(m);
 119
 120         if (m->free_header)
 121                 free(m->header);
 122
 123         message_reset_parts(m);
 124
 125         if (m->free_kdbus)
 126                 free(m->kdbus);
 127
 128         if (m->release_kdbus) {
 129                 uint64_t off;
 130
 131                 off = (uint8_t *)m->kdbus - (uint8_t *)m->bus->kdbus_buffer;
 132                 ioctl(m->bus->input_fd, KDBUS_CMD_MSG_RELEASE, &off);
 133         }
 134
 135         if (m->bus)
 136                 sd_bus_unref(m->bus);
 137
 138         if (m->free_fds) {
 139                 close_many(m->fds, m->n_fds);
 140                 free(m->fds);
 141         }
 142
 143         if (m->iovec != m->iovec_fixed)
 144                 free(m->iovec);
 145
 146         free(m->cmdline_array);
 147
 148         message_reset_containers(m);
 149         free(m->root_container.signature);
 150
 151         free(m->peeked_signature);
 152
 153         free(m->unit);
 154         free(m->user_unit);
 155         free(m->session);
 156         free(m);
 157 }
 158
 159 static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) {
 160         void *op, *np;
 161         size_t old_size, new_size, start;
 162
 163         assert(m);
 164
 165         if (m->poisoned)
 166                 return NULL;
 167
 168         old_size = sizeof(struct bus_header) + m->header->fields_size;
 169         start = ALIGN_TO(old_size, align);
 170         new_size = start + sz;
 171
 172         if (old_size == new_size)
 173                 return (uint8_t*) m->header + old_size;
 174
 175         if (new_size > (size_t) ((uint32_t) -1))
 176                 goto poison;
 177
 178         if (m->free_header) {
 179                 np = realloc(m->header, ALIGN8(new_size));
 180                 if (!np)
 181                         goto poison;
 182         } else {
 183                 /* Initially, the header is allocated as part of of
 184                  * the sd_bus_message itself, let's replace it by
 185                  * dynamic data */
 186
 187                 np = malloc(ALIGN8(new_size));
 188                 if (!np)
 189                         goto poison;
 190
 191                 memcpy(np, m->header, sizeof(struct bus_header));
 192         }
 193
 194         /* Zero out padding */
 195         if (start > old_size)
 196                 memset((uint8_t*) np + old_size, 0, start - old_size);
 197
 198         op = m->header;
 199         m->header = np;
 200         m->header->fields_size = new_size - sizeof(struct bus_header);
 201
 202         /* Adjust quick access pointers */
 203         m->path = adjust_pointer(m->path, op, old_size, m->header);
 204         m->interface = adjust_pointer(m->interface, op, old_size, m->header);
 205         m->member = adjust_pointer(m->member, op, old_size, m->header);
 206         m->destination = adjust_pointer(m->destination, op, old_size, m->header);
 207         m->sender = adjust_pointer(m->sender, op, old_size, m->header);
 208         m->error.name = adjust_pointer(m->error.name, op, old_size, m->header);
 209
 210         m->free_header = true;
 211
 212         return (uint8_t*) np + start;
 213
 214 poison:
 215         m->poisoned = true;
 216         return NULL;
 217 }
 218
 219 static int message_append_field_string(
 220                 sd_bus_message *m,
 221                 uint8_t h,
 222                 char type,
 223                 const char *s,
 224                 const char **ret) {
 225
 226         size_t l;
 227         uint8_t *p;
 228
 229         assert(m);
 230
 231         l = strlen(s);
 232         if (l > (size_t) (uint32_t) -1)
 233                 return -EINVAL;
 234
 235         /* field id byte + signature length + signature 's' + NUL + string length + string + NUL */
 236         p = message_extend_fields(m, 8, 4 + 4 + l + 1);
 237         if (!p)
 238                 return -ENOMEM;
 239
 240         p[0] = h;
 241         p[1] = 1;
 242         p[2] = type;
 243         p[3] = 0;
 244
 245         ((uint32_t*) p)[1] = l;
 246         memcpy(p + 8, s, l + 1);
 247
 248         if (ret)
 249                 *ret = (char*) p + 8;
 250
 251         return 0;
 252 }
 253
 254 static int message_append_field_signature(
 255                 sd_bus_message *m,
 256                 uint8_t h,
 257                 const char *s,
 258                 const char **ret) {
 259
 260         size_t l;
 261         uint8_t *p;
 262
 263         assert(m);
 264
 265         l = strlen(s);
 266         if (l > 255)
 267                 return -EINVAL;
 268
 269         /* field id byte + signature length + signature 'g' + NUL + string length + string + NUL */
 270         p = message_extend_fields(m, 8, 4 + 1 + l + 1);
 271         if (!p)
 272                 return -ENOMEM;
 273
 274         p[0] = h;
 275         p[1] = 1;
 276         p[2] = SD_BUS_TYPE_SIGNATURE;
 277         p[3] = 0;
 278         p[4] = l;
 279         memcpy(p + 5, s, l + 1);
 280
 281         if (ret)
 282                 *ret = (const char*) p + 5;
 283
 284         return 0;
 285 }
 286
 287 static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) {
 288         uint8_t *p;
 289
 290         assert(m);
 291
 292         /* field id byte + signature length + signature 'u' + NUL + value */
 293         p = message_extend_fields(m, 8, 4 + 4);
 294         if (!p)
 295                 return -ENOMEM;
 296
 297         p[0] = h;
 298         p[1] = 1;
 299         p[2] = SD_BUS_TYPE_UINT32;
 300         p[3] = 0;
 301
 302         ((uint32_t*) p)[1] = x;
 303
 304         return 0;
 305 }
 306
 307 int bus_message_from_header(
 308                 void *buffer,
 309                 size_t length,
 310                 int *fds,
 311                 unsigned n_fds,
 312                 const struct ucred *ucred,
 313                 const char *label,
 314                 size_t extra,
 315                 sd_bus_message **ret) {
 316
 317         sd_bus_message *m;
 318         struct bus_header *h;
 319         size_t a, label_sz;
 320
 321         assert(buffer || length <= 0);
 322         assert(fds || n_fds <= 0);
 323         assert(ret);
 324
 325         if (length < sizeof(struct bus_header))
 326                 return -EBADMSG;
 327
 328         h = buffer;
 329         if (h->version != 1)
 330                 return -EBADMSG;
 331
 332         if (h->serial == 0)
 333                 return -EBADMSG;
 334
 335         if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
 336                 return -EBADMSG;
 337
 338         if (h->endian != SD_BUS_LITTLE_ENDIAN &&
 339             h->endian != SD_BUS_BIG_ENDIAN)
 340                 return -EBADMSG;
 341
 342         a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
 343
 344         if (label) {
 345                 label_sz = strlen(label);
 346                 a += label_sz + 1;
 347         }
 348
 349         m = malloc0(a);
 350         if (!m)
 351                 return -ENOMEM;
 352
 353         m->n_ref = 1;
 354         m->sealed = true;
 355         m->header = h;
 356         m->fds = fds;
 357         m->n_fds = n_fds;
 358
 359         if (ucred) {
 360                 m->uid = ucred->uid;
 361                 m->pid = ucred->pid;
 362                 m->gid = ucred->gid;
 363                 m->uid_valid = m->gid_valid = true;
 364         }
 365
 366         if (label) {
 367                 m->label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
 368                 memcpy(m->label, label, label_sz + 1);
 369         }
 370
 371         *ret = m;
 372         return 0;
 373 }
 374
 375 int bus_message_from_malloc(
 376                 void *buffer,
 377                 size_t length,
 378                 int *fds,
 379                 unsigned n_fds,
 380                 const struct ucred *ucred,
 381                 const char *label,
 382                 sd_bus_message **ret) {
 383
 384         sd_bus_message *m;
 385         int r;
 386
 387         r = bus_message_from_header(buffer, length, fds, n_fds, ucred, label, 0, &m);
 388         if (r < 0)
 389                 return r;
 390
 391         if (length != BUS_MESSAGE_SIZE(m)) {
 392                 r = -EBADMSG;
 393                 goto fail;
 394         }
 395
 396         m->n_body_parts = 1;
 397         m->body.data = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 398         m->body.size = length - sizeof(struct bus_header) - ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 399         m->body.sealed = true;
 400         m->body.memfd = -1;
 401
 402         m->n_iovec = 1;
 403         m->iovec = m->iovec_fixed;
 404         m->iovec[0].iov_base = buffer;
 405         m->iovec[0].iov_len = length;
 406
 407         r = bus_message_parse_fields(m);
 408         if (r < 0)
 409                 goto fail;
 410
 411         /* We take possession of the memory and fds now */
 412         m->free_header = true;
 413         m->free_fds = true;
 414
 415         *ret = m;
 416         return 0;
 417
 418 fail:
 419         message_free(m);
 420         return r;
 421 }
 422
 423 static sd_bus_message *message_new(sd_bus *bus, uint8_t type) {
 424         sd_bus_message *m;
 425
 426         m = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header));
 427         if (!m)
 428                 return NULL;
 429
 430         m->n_ref = 1;
 431         m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message)));
 432         m->header->endian = SD_BUS_NATIVE_ENDIAN;
 433         m->header->type = type;
 434         m->header->version = bus ? bus->message_version : 1;
 435         m->allow_fds = !bus || bus->can_fds || (bus->state != BUS_HELLO && bus->state != BUS_RUNNING);
 436
 437         if (bus)
 438                 m->bus = sd_bus_ref(bus);
 439
 440         return m;
 441 }
 442
 443 int sd_bus_message_new_signal(
 444                 sd_bus *bus,
 445                 const char *path,
 446                 const char *interface,
 447                 const char *member,
 448                 sd_bus_message **m) {
 449
 450         sd_bus_message *t;
 451         int r;
 452
 453         if (!path)
 454                 return -EINVAL;
 455         if (!interface)
 456                 return -EINVAL;
 457         if (!member)
 458                 return -EINVAL;
 459         if (!m)
 460                 return -EINVAL;
 461         if (bus && bus->state == BUS_UNSET)
 462                 return -ENOTCONN;
 463
 464         t = message_new(bus, SD_BUS_MESSAGE_SIGNAL);
 465         if (!t)
 466                 return -ENOMEM;
 467
 468         t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 469
 470         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
 471         if (r < 0)
 472                 goto fail;
 473         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
 474         if (r < 0)
 475                 goto fail;
 476         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
 477         if (r < 0)
 478                 goto fail;
 479
 480         *m = t;
 481         return 0;
 482
 483 fail:
 484         sd_bus_message_unref(t);
 485         return r;
 486 }
 487
 488 int sd_bus_message_new_method_call(
 489                 sd_bus *bus,
 490                 const char *destination,
 491                 const char *path,
 492                 const char *interface,
 493                 const char *member,
 494                 sd_bus_message **m) {
 495
 496         sd_bus_message *t;
 497         int r;
 498
 499         if (destination && !service_name_is_valid(destination))
 500                 return -EINVAL;
 501         if (!object_path_is_valid(path))
 502                 return -EINVAL;
 503         if (interface && !interface_name_is_valid(interface))
 504                 return -EINVAL;
 505         if (!member_name_is_valid(member))
 506                 return -EINVAL;
 507         if (!m)
 508                 return -EINVAL;
 509         if (bus && bus->state == BUS_UNSET)
 510                 return -ENOTCONN;
 511
 512         t = message_new(bus, SD_BUS_MESSAGE_METHOD_CALL);
 513         if (!t)
 514                 return -ENOMEM;
 515
 516         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
 517         if (r < 0)
 518                 goto fail;
 519         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
 520         if (r < 0)
 521                 goto fail;
 522
 523         if (interface) {
 524                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
 525                 if (r < 0)
 526                         goto fail;
 527         }
 528
 529         if (destination) {
 530                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
 531                 if (r < 0)
 532                         goto fail;
 533         }
 534
 535         *m = t;
 536         return 0;
 537
 538 fail:
 539         message_free(t);
 540         return r;
 541 }
 542
 543 static int message_new_reply(
 544                 sd_bus *bus,
 545                 sd_bus_message *call,
 546                 uint8_t type,
 547                 sd_bus_message **m) {
 548
 549         sd_bus_message *t;
 550         int r;
 551
 552         if (!call)
 553                 return -EINVAL;
 554         if (!call->sealed)
 555                 return -EPERM;
 556         if (call->header->type != SD_BUS_MESSAGE_METHOD_CALL)
 557                 return -EINVAL;
 558         if (!m)
 559                 return -EINVAL;
 560         if (bus && bus->state == BUS_UNSET)
 561                 return -ENOTCONN;
 562
 563         t = message_new(bus, type);
 564         if (!t)
 565                 return -ENOMEM;
 566
 567         t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 568         t->reply_serial = BUS_MESSAGE_SERIAL(call);
 569
 570         r = message_append_field_uint32(t, SD_BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial);
 571         if (r < 0)
 572                 goto fail;
 573
 574         if (call->sender) {
 575                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->destination);
 576                 if (r < 0)
 577                         goto fail;
 578         }
 579
 580         t->dont_send = !!(call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED);
 581
 582         *m = t;
 583         return 0;
 584
 585 fail:
 586         message_free(t);
 587         return r;
 588 }
 589
 590 int sd_bus_message_new_method_return(
 591                 sd_bus *bus,
 592                 sd_bus_message *call,
 593                 sd_bus_message **m) {
 594
 595         return message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_RETURN, m);
 596 }
 597
 598 int sd_bus_message_new_method_error(
 599                 sd_bus *bus,
 600                 sd_bus_message *call,
 601                 const sd_bus_error *e,
 602                 sd_bus_message **m) {
 603
 604         sd_bus_message *t;
 605         int r;
 606
 607         if (!sd_bus_error_is_set(e))
 608                 return -EINVAL;
 609         if (!m)
 610                 return -EINVAL;
 611
 612         r = message_new_reply(bus, call, SD_BUS_MESSAGE_METHOD_ERROR, &t);
 613         if (r < 0)
 614                 return r;
 615
 616         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
 617         if (r < 0)
 618                 goto fail;
 619
 620         if (e->message) {
 621                 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
 622                 if (r < 0)
 623                         goto fail;
 624         }
 625
 626         *m = t;
 627         return 0;
 628
 629 fail:
 630         message_free(t);
 631         return r;
 632 }
 633
 634 int sd_bus_message_new_method_errorf(
 635                 sd_bus *bus,
 636                 sd_bus_message *call,
 637                 sd_bus_message **m,
 638                 const char *name,
 639                 const char *format,
 640                 ...) {
 641
 642         _cleanup_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 643         va_list ap;
 644         int r;
 645
 646         assert_return(name, -EINVAL);
 647         assert_return(m, -EINVAL);
 648
 649         va_start(ap, format);
 650         r = bus_error_setfv(&error, name, format, ap);
 651         va_end(ap);
 652
 653         if (r < 0)
 654                 return r;
 655
 656         return sd_bus_message_new_method_error(bus, call, &error, m);
 657 }
 658
 659 int sd_bus_message_new_method_errno(
 660                 sd_bus *bus,
 661                 sd_bus_message *call,
 662                 int error,
 663                 const sd_bus_error *p,
 664                 sd_bus_message **m) {
 665
 666         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 667
 668         if (sd_bus_error_is_set(p))
 669                 return sd_bus_message_new_method_error(bus, call, p, m);
 670
 671         sd_bus_error_set_errno(&berror, error);
 672
 673         return sd_bus_message_new_method_error(bus, call, &berror, m);
 674 }
 675
 676 int sd_bus_message_new_method_errnof(
 677                 sd_bus *bus,
 678                 sd_bus_message *call,
 679                 sd_bus_message **m,
 680                 int error,
 681                 const char *format,
 682                 ...) {
 683
 684         _cleanup_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
 685         va_list ap;
 686         int r;
 687
 688         va_start(ap, format);
 689         r = bus_error_set_errnofv(&berror, error, format, ap);
 690         va_end(ap);
 691
 692         if (r < 0)
 693                 return r;
 694
 695         return sd_bus_message_new_method_error(bus, call, &berror, m);
 696 }
 697
 698 int bus_message_new_synthetic_error(
 699                 sd_bus *bus,
 700                 uint64_t serial,
 701                 const sd_bus_error *e,
 702                 sd_bus_message **m) {
 703
 704         sd_bus_message *t;
 705         int r;
 706
 707         assert(sd_bus_error_is_set(e));
 708         assert(m);
 709
 710         t = message_new(bus, SD_BUS_MESSAGE_METHOD_ERROR);
 711         if (!t)
 712                 return -ENOMEM;
 713
 714         t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 715         t->reply_serial = serial;
 716
 717         r = message_append_field_uint32(t, SD_BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial);
 718         if (r < 0)
 719                 goto fail;
 720
 721         if (bus && bus->unique_name) {
 722                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, bus->unique_name, &t->destination);
 723                 if (r < 0)
 724                         goto fail;
 725         }
 726
 727         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
 728         if (r < 0)
 729                 goto fail;
 730
 731         if (e->message) {
 732                 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
 733                 if (r < 0)
 734                         goto fail;
 735         }
 736
 737         *m = t;
 738         return 0;
 739
 740 fail:
 741         message_free(t);
 742         return r;
 743 }
 744
 745 sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
 746         if (!m)
 747                 return NULL;
 748
 749         assert(m->n_ref > 0);
 750         m->n_ref++;
 751
 752         return m;
 753 }
 754
 755 sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
 756         if (!m)
 757                 return NULL;
 758
 759         assert(m->n_ref > 0);
 760         m->n_ref--;
 761
 762         if (m->n_ref <= 0)
 763                 message_free(m);
 764
 765         return NULL;
 766 }
 767
 768 int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
 769         if (!m)
 770                 return -EINVAL;
 771         if (!type)
 772                 return -EINVAL;
 773
 774         *type = m->header->type;
 775         return 0;
 776 }
 777
 778 int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) {
 779         if (!m)
 780                 return -EINVAL;
 781         if (!serial)
 782                 return -EINVAL;
 783         if (m->header->serial == 0)
 784                 return -ENOENT;
 785
 786         *serial = BUS_MESSAGE_SERIAL(m);
 787         return 0;
 788 }
 789
 790 int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) {
 791         if (!m)
 792                 return -EINVAL;
 793         if (!serial)
 794                 return -EINVAL;
 795         if (m->reply_serial == 0)
 796                 return -ENOENT;
 797
 798         *serial = m->reply_serial;
 799         return 0;
 800 }
 801
 802 int sd_bus_message_get_no_reply(sd_bus_message *m) {
 803         if (!m)
 804                 return -EINVAL;
 805
 806         return m->header->type == SD_BUS_MESSAGE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
 807 }
 808
 809 const char *sd_bus_message_get_path(sd_bus_message *m) {
 810         if (!m)
 811                 return NULL;
 812
 813         return m->path;
 814 }
 815
 816 const char *sd_bus_message_get_interface(sd_bus_message *m) {
 817         if (!m)
 818                 return NULL;
 819
 820         return m->interface;
 821 }
 822
 823 const char *sd_bus_message_get_member(sd_bus_message *m) {
 824         if (!m)
 825                 return NULL;
 826
 827         return m->member;
 828 }
 829 const char *sd_bus_message_get_destination(sd_bus_message *m) {
 830         if (!m)
 831                 return NULL;
 832
 833         return m->destination;
 834 }
 835
 836 const char *sd_bus_message_get_sender(sd_bus_message *m) {
 837         if (!m)
 838                 return NULL;
 839
 840         return m->sender;
 841 }
 842
 843 const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
 844         if (!m)
 845                 return NULL;
 846
 847         if (!sd_bus_error_is_set(&m->error))
 848                 return NULL;
 849
 850         return &m->error;
 851 }
 852
 853 int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) {
 854         if (!m)
 855                 return -EINVAL;
 856         if (!uid)
 857                 return -EINVAL;
 858         if (!m->uid_valid)
 859                 return -ESRCH;
 860
 861         *uid = m->uid;
 862         return 0;
 863 }
 864
 865 int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
 866         if (!m)
 867                 return -EINVAL;
 868         if (!gid)
 869                 return -EINVAL;
 870         if (!m->gid_valid)
 871                 return -ESRCH;
 872
 873         *gid = m->gid;
 874         return 0;
 875 }
 876
 877 int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
 878         if (!m)
 879                 return -EINVAL;
 880         if (!pid)
 881                 return -EINVAL;
 882         if (m->pid <= 0)
 883                 return -ESRCH;
 884
 885         *pid = m->pid;
 886         return 0;
 887 }
 888
 889 int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
 890         if (!m)
 891                 return -EINVAL;
 892         if (!tid)
 893                 return -EINVAL;
 894         if (m->tid <= 0)
 895                 return -ESRCH;
 896
 897         *tid = m->tid;
 898         return 0;
 899 }
 900
 901 int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
 902         if (!m)
 903                 return -EINVAL;
 904         if (!usec)
 905                 return -EINVAL;
 906         if (m->pid_starttime <= 0)
 907                 return -ESRCH;
 908
 909         *usec = m->pid_starttime;
 910         return 0;
 911 }
 912
 913 int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
 914         if (!m)
 915                 return -EINVAL;
 916         if (!m->label)
 917                 return -ESRCH;
 918
 919         *ret = m->label;
 920         return 0;
 921 }
 922
 923 int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
 924         if (!m)
 925                 return -EINVAL;
 926         if (!usec)
 927                 return -EINVAL;
 928         if (m->monotonic <= 0)
 929                 return -ESRCH;
 930
 931         *usec = m->monotonic;
 932         return 0;
 933 }
 934
 935 int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
 936         if (!m)
 937                 return -EINVAL;
 938         if (!usec)
 939                 return -EINVAL;
 940         if (m->realtime <= 0)
 941                 return -ESRCH;
 942
 943         *usec = m->realtime;
 944         return 0;
 945 }
 946
 947 int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
 948         if (!m)
 949                 return -EINVAL;
 950         if (!ret)
 951                 return -EINVAL;
 952         if (!m->comm)
 953                 return -ESRCH;
 954
 955         *ret = m->comm;
 956         return 0;
 957 }
 958
 959 int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
 960         if (!m)
 961                 return -EINVAL;
 962         if (!ret)
 963                 return -EINVAL;
 964         if (!m->tid_comm)
 965                 return -ESRCH;
 966
 967         *ret = m->tid_comm;
 968         return 0;
 969 }
 970
 971 int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
 972         if (!m)
 973                 return -EINVAL;
 974         if (!ret)
 975                 return -EINVAL;
 976         if (!m->exe)
 977                 return -ESRCH;
 978
 979         *ret = m->exe;
 980         return 0;
 981 }
 982
 983 int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
 984         if (!m)
 985                 return -EINVAL;
 986         if (!ret)
 987                 return -EINVAL;
 988         if (!m->cgroup)
 989                 return -ESRCH;
 990
 991         *ret = m->cgroup;
 992         return 0;
 993 }
 994
 995 int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
 996         int r;
 997
 998         if (!m)
 999                 return -EINVAL;
1000         if (!ret)
1001                 return -EINVAL;
1002         if (!m->cgroup)
1003                 return -ESRCH;
1004
1005         if (!m->unit) {
1006                 r = cg_path_get_unit(m->cgroup, &m->unit);
1007                 if (r < 0)
1008                         return r;
1009         }
1010
1011         *ret = m->unit;
1012         return 0;
1013 }
1014
1015 int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
1016         int r;
1017
1018         if (!m)
1019                 return -EINVAL;
1020         if (!ret)
1021                 return -EINVAL;
1022         if (!m->cgroup)
1023                 return -ESRCH;
1024
1025         if (!m->user_unit) {
1026                 r = cg_path_get_user_unit(m->cgroup, &m->user_unit);
1027                 if (r < 0)
1028                         return r;
1029         }
1030
1031         *ret = m->user_unit;
1032         return 0;
1033 }
1034
1035 int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
1036         int r;
1037
1038         if (!m)
1039                 return -EINVAL;
1040         if (!ret)
1041                 return -EINVAL;
1042         if (!m->cgroup)
1043                 return -ESRCH;
1044
1045         if (!m->session) {
1046                 r = cg_path_get_session(m->cgroup, &m->session);
1047                 if (r < 0)
1048                         return r;
1049         }
1050
1051         *ret = m->session;
1052         return 0;
1053 }
1054
1055 int sd_bus_message_get_owner_uid(sd_bus_message *m, uid_t *uid) {
1056         if (!m)
1057                 return -EINVAL;
1058         if (!uid)
1059                 return -EINVAL;
1060         if (!m->cgroup)
1061                 return -ESRCH;
1062
1063         return cg_path_get_owner_uid(m->cgroup, uid);
1064 }
1065
1066 int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
1067         size_t n, i;
1068         const char *p;
1069         bool first;
1070
1071         if (!m)
1072                 return -EINVAL;
1073
1074         if (!m->cmdline)
1075                 return -ENOENT;
1076
1077         for (p = m->cmdline, n = 0; p < m->cmdline + m->cmdline_length; p++)
1078                 if (*p == 0)
1079                         n++;
1080
1081         m->cmdline_array = new(char*, n + 1);
1082         if (!m->cmdline_array)
1083                 return -ENOMEM;
1084
1085         for (p = m->cmdline, i = 0, first = true; p < m->cmdline + m->cmdline_length; p++) {
1086                 if (first)
1087                         m->cmdline_array[i++] = (char*) p;
1088
1089                 first = *p == 0;
1090         }
1091
1092         m->cmdline_array[i] = NULL;
1093         *cmdline = m->cmdline_array;
1094
1095         return 0;
1096 }
1097
1098 int sd_bus_message_get_audit_sessionid(sd_bus_message *m, uint32_t *sessionid) {
1099         if (!m)
1100                 return -EINVAL;
1101         if (!sessionid)
1102                 return -EINVAL;
1103         if (!m->audit)
1104                 return -ESRCH;
1105
1106         *sessionid = m->audit->sessionid;
1107         return 0;
1108 }
1109
1110 int sd_bus_message_get_audit_loginuid(sd_bus_message *m, uid_t *uid) {
1111         if (!m)
1112                 return -EINVAL;
1113         if (!uid)
1114                 return -EINVAL;
1115         if (!m->audit)
1116                 return -ESRCH;
1117
1118         *uid = m->audit->loginuid;
1119         return 0;
1120 }
1121
1122 int sd_bus_message_has_effective_cap(sd_bus_message *m, int capability) {
1123         unsigned sz;
1124
1125         if (!m)
1126                 return -EINVAL;
1127         if (capability < 0)
1128                 return -EINVAL;
1129         if (!m->capability)
1130                 return -ESRCH;
1131
1132         sz = m->capability_size / 4;
1133         if ((unsigned) capability >= sz*8)
1134                 return 0;
1135
1136         return !!(m->capability[2 * sz + (capability / 8)] & (1 << (capability % 8)));
1137 }
1138
1139 int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) {
1140         if (!m)
1141                 return -EINVAL;
1142
1143         if (m->header->type != SD_BUS_MESSAGE_SIGNAL)
1144                 return 0;
1145
1146         if (interface && (!m->interface || !streq(m->interface, interface)))
1147                 return 0;
1148
1149         if (member &&  (!m->member || !streq(m->member, member)))
1150                 return 0;
1151
1152         return 1;
1153 }
1154
1155 int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) {
1156         if (!m)
1157                 return -EINVAL;
1158
1159         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1160                 return 0;
1161
1162         if (interface && (!m->interface || !streq(m->interface, interface)))
1163                 return 0;
1164
1165         if (member &&  (!m->member || !streq(m->member, member)))
1166                 return 0;
1167
1168         return 1;
1169 }
1170
1171 int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
1172         if (!m)
1173                 return -EINVAL;
1174
1175         if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1176                 return 0;
1177
1178         if (name && (!m->error.name || !streq(m->error.name, name)))
1179                 return 0;
1180
1181         return 1;
1182 }
1183
1184 int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
1185         if (!m)
1186                 return -EINVAL;
1187         if (m->sealed)
1188                 return -EPERM;
1189         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1190                 return -EPERM;
1191
1192         if (b)
1193                 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1194         else
1195                 m->header->flags &= ~SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1196
1197         return 0;
1198 }
1199
1200 static struct bus_container *message_get_container(sd_bus_message *m) {
1201         assert(m);
1202
1203         if (m->n_containers == 0)
1204                 return &m->root_container;
1205
1206         assert(m->containers);
1207         return m->containers + m->n_containers - 1;
1208 }
1209
1210 struct bus_body_part *message_append_part(sd_bus_message *m) {
1211         struct bus_body_part *part;
1212
1213         assert(m);
1214
1215         if (m->poisoned)
1216                 return NULL;
1217
1218         if (m->n_body_parts <= 0) {
1219                 part = &m->body;
1220                 zero(*part);
1221         } else {
1222                 assert(m->body_end);
1223
1224                 part = new0(struct bus_body_part, 1);
1225                 if (!part) {
1226                         m->poisoned = true;
1227                         return NULL;
1228                 }
1229
1230                 m->body_end->next = part;
1231         }
1232
1233         part->memfd = -1;
1234         m->body_end = part;
1235         m->n_body_parts ++;
1236
1237         return part;
1238 }
1239
1240 static void part_zero(struct bus_body_part *part, size_t sz) {
1241         assert(part);
1242         assert(sz > 0);
1243         assert(sz < 8);
1244
1245         /* All other fields can be left in their defaults */
1246         assert(!part->data);
1247         assert(part->memfd < 0);
1248
1249         part->size = sz;
1250         part->is_zero = true;
1251         part->sealed = true;
1252 }
1253
1254 static int part_make_space(
1255                 struct sd_bus_message *m,
1256                 struct bus_body_part *part,
1257                 size_t sz,
1258                 void **q) {
1259
1260         void *n;
1261         int r;
1262
1263         assert(m);
1264         assert(part);
1265         assert(!part->sealed);
1266
1267         if (m->poisoned)
1268                 return -ENOMEM;
1269
1270         if (!part->data && part->memfd < 0)
1271                 part->memfd = bus_kernel_pop_memfd(m->bus, &part->data, &part->mapped);
1272
1273         if (part->memfd >= 0) {
1274                 uint64_t u = sz;
1275
1276                 r = ioctl(part->memfd, KDBUS_CMD_MEMFD_SIZE_SET, &u);
1277                 if (r < 0) {
1278                         m->poisoned = true;
1279                         return -errno;
1280                 }
1281
1282                 if (!part->data || sz > part->mapped) {
1283                         size_t psz = PAGE_ALIGN(sz > 0 ? sz : 1);
1284
1285                         if (part->mapped <= 0)
1286                                 n = mmap(NULL, psz, PROT_READ|PROT_WRITE, MAP_SHARED, part->memfd, 0);
1287                         else
1288                                 n = mremap(part->data, part->mapped, psz, MREMAP_MAYMOVE);
1289
1290                         if (n == MAP_FAILED) {
1291                                 m->poisoned = true;
1292                                 return -errno;
1293                         }
1294
1295                         part->mapped = psz;
1296                         part->data = n;
1297                 }
1298
1299                 part->munmap_this = true;
1300         } else {
1301                 n = realloc(part->data, MAX(sz, 1u));
1302                 if (!n) {
1303                         m->poisoned = true;
1304                         return -ENOMEM;
1305                 }
1306
1307                 part->data = n;
1308                 part->free_this = true;
1309         }
1310
1311         if (q)
1312                 *q = part->data ? (uint8_t*) part->data + part->size : NULL;
1313
1314         part->size = sz;
1315         return 0;
1316 }
1317
1318 static void message_extend_containers(sd_bus_message *m, size_t expand) {
1319         struct bus_container *c;
1320
1321         assert(m);
1322
1323         if (expand <= 0)
1324                 return;
1325
1326         /* Update counters */
1327         for (c = m->containers; c < m->containers + m->n_containers; c++)
1328                 if (c->array_size)
1329                         *c->array_size += expand;
1330 }
1331
1332 static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) {
1333         struct bus_body_part *part = NULL;
1334         size_t start_body, end_body, padding, start_part, end_part, added;
1335         bool add_new_part;
1336         void *p;
1337         int r;
1338
1339         assert(m);
1340         assert(align > 0);
1341         assert(!m->sealed);
1342
1343         if (m->poisoned)
1344                 return NULL;
1345
1346         start_body = ALIGN_TO((size_t) m->header->body_size, align);
1347         end_body = start_body + sz;
1348
1349         padding = start_body - m->header->body_size;
1350         added = padding + sz;
1351
1352         /* Check for 32bit overflows */
1353         if (end_body > (size_t) ((uint32_t) -1)) {
1354                 m->poisoned = true;
1355                 return NULL;
1356         }
1357
1358         add_new_part =
1359                 m->n_body_parts <= 0 ||
1360                 m->body_end->sealed ||
1361                 padding != ALIGN_TO(m->body_end->size, align) - m->body_end->size;
1362
1363         if (add_new_part) {
1364                 if (padding > 0) {
1365                         part = message_append_part(m);
1366                         if (!part)
1367                                 return NULL;
1368
1369                         part_zero(part, padding);
1370                 }
1371
1372                 part = message_append_part(m);
1373                 if (!part)
1374                         return NULL;
1375
1376                 r = part_make_space(m, part, sz, &p);
1377                 if (r < 0)
1378                         return NULL;
1379         } else {
1380                 struct bus_container *c;
1381                 void *op;
1382                 size_t os;
1383
1384                 part = m->body_end;
1385                 op = part->data;
1386                 os = part->size;
1387
1388                 start_part = ALIGN_TO(part->size, align);
1389                 end_part = start_part + sz;
1390
1391                 r = part_make_space(m, part, end_part, &p);
1392                 if (r < 0)
1393                         return NULL;
1394
1395                 if (padding > 0) {
1396                         memset(p, 0, padding);
1397                         p = (uint8_t*) p + padding;
1398                 }
1399
1400                 /* Readjust pointers */
1401                 for (c = m->containers; c < m->containers + m->n_containers; c++)
1402                         c->array_size = adjust_pointer(c->array_size, op, os, part->data);
1403
1404                 m->error.message = (const char*) adjust_pointer(m->error.message, op, os, part->data);
1405         }
1406
1407         m->header->body_size = end_body;
1408         message_extend_containers(m, added);
1409
1410         return p;
1411 }
1412
1413 int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
1414         struct bus_container *c;
1415         ssize_t align, sz;
1416         uint32_t k;
1417         void *a;
1418         int fd = -1;
1419         uint32_t fdi = 0;
1420         int r;
1421
1422         if (!m)
1423                 return -EINVAL;
1424         if (!p)
1425                 return -EINVAL;
1426         if (m->sealed)
1427                 return -EPERM;
1428         if (!bus_type_is_basic(type))
1429                 return -EINVAL;
1430         if (m->poisoned)
1431                 return -ESTALE;
1432
1433         c = message_get_container(m);
1434
1435         if (c->signature && c->signature[c->index]) {
1436                 /* Container signature is already set */
1437
1438                 if (c->signature[c->index] != type)
1439                         return -ENXIO;
1440         } else {
1441                 char *e;
1442
1443                 /* Maybe we can append to the signature? But only if this is the top-level container*/
1444                 if (c->enclosing != 0)
1445                         return -ENXIO;
1446
1447                 e = strextend(&c->signature, CHAR_TO_STR(type), NULL);
1448                 if (!e) {
1449                         m->poisoned = true;
1450                         return -ENOMEM;
1451                 }
1452         }
1453
1454         switch (type) {
1455
1456         case SD_BUS_TYPE_STRING:
1457         case SD_BUS_TYPE_OBJECT_PATH:
1458
1459                 align = 4;
1460                 sz = 4 + strlen(p) + 1;
1461                 break;
1462
1463         case SD_BUS_TYPE_SIGNATURE:
1464
1465                 align = 1;
1466                 sz = 1 + strlen(p) + 1;
1467                 break;
1468
1469         case SD_BUS_TYPE_BOOLEAN:
1470                 align = sz = 4;
1471
1472                 assert_cc(sizeof(int) == sizeof(uint32_t));
1473                 memcpy(&k, p, 4);
1474                 k = !!k;
1475                 p = &k;
1476                 break;
1477
1478         case SD_BUS_TYPE_UNIX_FD: {
1479                 int z, *f;
1480
1481                 if (!m->allow_fds) {
1482                         r = -ENOTSUP;
1483                         goto fail;
1484                 }
1485
1486                 align = sz = 4;
1487
1488                 z = *(int*) p;
1489                 if (z < 0) {
1490                         r = -EINVAL;
1491                         goto fail;
1492                 }
1493
1494                 fd = fcntl(z, F_DUPFD_CLOEXEC, 3);
1495                 if (fd < 0) {
1496                         r = -errno;
1497                         goto fail;
1498                 }
1499
1500                 f = realloc(m->fds, sizeof(int) * (m->n_fds + 1));
1501                 if (!f) {
1502                         m->poisoned = true;
1503                         r = -ENOMEM;
1504                         goto fail;
1505                 }
1506
1507                 fdi = m->n_fds;
1508                 f[fdi] = fd;
1509                 m->fds = f;
1510                 m->free_fds = true;
1511                 break;
1512         }
1513
1514         default:
1515                 align = bus_type_get_alignment(type);
1516                 sz = bus_type_get_size(type);
1517                 break;
1518         }
1519
1520         assert(align > 0);
1521         assert(sz > 0);
1522
1523         a = message_extend_body(m, align, sz);
1524         if (!a) {
1525                 r = -ENOMEM;
1526                 goto fail;
1527         }
1528
1529         if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) {
1530                 *(uint32_t*) a = sz - 5;
1531                 memcpy((uint8_t*) a + 4, p, sz - 4);
1532
1533                 if (stored)
1534                         *stored = (const uint8_t*) a + 4;
1535
1536         } else if (type == SD_BUS_TYPE_SIGNATURE) {
1537                 *(uint8_t*) a = sz - 1;
1538                 memcpy((uint8_t*) a + 1, p, sz - 1);
1539
1540                 if (stored)
1541                         *stored = (const uint8_t*) a + 1;
1542         } else if (type == SD_BUS_TYPE_UNIX_FD) {
1543                 *(uint32_t*) a = fdi;
1544
1545                 if (stored)
1546                         *stored = a;
1547
1548                 m->n_fds ++;
1549
1550         } else {
1551                 memcpy(a, p, sz);
1552
1553                 if (stored)
1554                         *stored = a;
1555         }
1556
1557         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1558                 c->index++;
1559
1560         return 0;
1561
1562 fail:
1563         if (fd >= 0)
1564                 close_nointr_nofail(fd);
1565
1566         return r;
1567 }
1568
1569 int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
1570         return message_append_basic(m, type, p, NULL);
1571 }
1572
1573 int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s) {
1574         struct bus_container *c;
1575         void *a;
1576
1577         if (!m)
1578                 return -EINVAL;
1579         if (!s)
1580                 return -EINVAL;
1581         if (m->sealed)
1582                 return -EPERM;
1583         if (m->poisoned)
1584                 return -ESTALE;
1585
1586         c = message_get_container(m);
1587
1588         if (c->signature && c->signature[c->index]) {
1589                 /* Container signature is already set */
1590
1591                 if (c->signature[c->index] != SD_BUS_TYPE_STRING)
1592                         return -ENXIO;
1593         } else {
1594                 char *e;
1595
1596                 /* Maybe we can append to the signature? But only if this is the top-level container*/
1597                 if (c->enclosing != 0)
1598                         return -ENXIO;
1599
1600                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL);
1601                 if (!e) {
1602                         m->poisoned = true;
1603                         return -ENOMEM;
1604                 }
1605         }
1606
1607         a = message_extend_body(m, 4, 4 + size + 1);
1608         if (!a)
1609                 return -ENOMEM;
1610
1611         *(uint32_t*) a = size;
1612         *s = (char*) a + 4;
1613
1614         (*s)[size] = 0;
1615
1616         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1617                 c->index++;
1618
1619         return 0;
1620 }
1621
1622 static int bus_message_open_array(
1623                 sd_bus_message *m,
1624                 struct bus_container *c,
1625                 const char *contents,
1626                 uint32_t **array_size) {
1627
1628         unsigned nindex;
1629         void *a, *op;
1630         int alignment;
1631         size_t os;
1632         struct bus_body_part *o;
1633
1634         assert(m);
1635         assert(c);
1636         assert(contents);
1637         assert(array_size);
1638
1639         if (!signature_is_single(contents, true))
1640                 return -EINVAL;
1641
1642         alignment = bus_type_get_alignment(contents[0]);
1643         if (alignment < 0)
1644                 return alignment;
1645
1646         if (c->signature && c->signature[c->index]) {
1647
1648                 /* Verify the existing signature */
1649
1650                 if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
1651                         return -ENXIO;
1652
1653                 if (!startswith(c->signature + c->index + 1, contents))
1654                         return -ENXIO;
1655
1656                 nindex = c->index + 1 + strlen(contents);
1657         } else {
1658                 char *e;
1659
1660                 if (c->enclosing != 0)
1661                         return -ENXIO;
1662
1663                 /* Extend the existing signature */
1664
1665                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL);
1666                 if (!e) {
1667                         m->poisoned = true;
1668                         return -ENOMEM;
1669                 }
1670
1671                 nindex = e - c->signature;
1672         }
1673
1674         a = message_extend_body(m, 4, 4);
1675         if (!a)
1676                 return -ENOMEM;
1677
1678         o = m->body_end;
1679         op = m->body_end->data;
1680         os = m->body_end->size;
1681
1682         /* Add alignment between size and first element */
1683         if (!message_extend_body(m, alignment, 0))
1684                 return -ENOMEM;
1685
1686         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1687                 c->index = nindex;
1688
1689         /* location of array size might have changed so let's readjust a */
1690         if (o == m->body_end)
1691                 a = adjust_pointer(a, op, os, m->body_end->data);
1692
1693         *(uint32_t*) a = 0;
1694         *array_size = a;
1695         return 0;
1696 }
1697
1698 static int bus_message_open_variant(
1699                 sd_bus_message *m,
1700                 struct bus_container *c,
1701                 const char *contents) {
1702
1703         size_t l;
1704         void *a;
1705
1706         assert(m);
1707         assert(c);
1708         assert(contents);
1709
1710         if (!signature_is_single(contents, false))
1711                 return -EINVAL;
1712
1713         if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
1714                 return -EINVAL;
1715
1716         if (c->signature && c->signature[c->index]) {
1717
1718                 if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
1719                         return -ENXIO;
1720
1721         } else {
1722                 char *e;
1723
1724                 if (c->enclosing != 0)
1725                         return -ENXIO;
1726
1727                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL);
1728                 if (!e) {
1729                         m->poisoned = true;
1730                         return -ENOMEM;
1731                 }
1732         }
1733
1734         l = strlen(contents);
1735         a = message_extend_body(m, 1, 1 + l + 1);
1736         if (!a)
1737                 return -ENOMEM;
1738
1739         *(uint8_t*) a = l;
1740         memcpy((uint8_t*) a + 1, contents, l + 1);
1741
1742         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1743                 c->index++;
1744
1745         return 0;
1746 }
1747
1748 static int bus_message_open_struct(
1749                 sd_bus_message *m,
1750                 struct bus_container *c,
1751                 const char *contents) {
1752
1753         size_t nindex;
1754
1755         assert(m);
1756         assert(c);
1757         assert(contents);
1758
1759         if (!signature_is_valid(contents, false))
1760                 return -EINVAL;
1761
1762         if (c->signature && c->signature[c->index]) {
1763                 size_t l;
1764
1765                 l = strlen(contents);
1766
1767                 if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
1768                     !startswith(c->signature + c->index + 1, contents) ||
1769                     c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
1770                         return -ENXIO;
1771
1772                 nindex = c->index + 1 + l + 1;
1773         } else {
1774                 char *e;
1775
1776                 if (c->enclosing != 0)
1777                         return -ENXIO;
1778
1779                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL);
1780                 if (!e) {
1781                         m->poisoned = true;
1782                         return -ENOMEM;
1783                 }
1784
1785                 nindex = e - c->signature;
1786         }
1787
1788         /* Align contents to 8 byte boundary */
1789         if (!message_extend_body(m, 8, 0))
1790                 return -ENOMEM;
1791
1792         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1793                 c->index = nindex;
1794
1795         return 0;
1796 }
1797
1798 static int bus_message_open_dict_entry(
1799                 sd_bus_message *m,
1800                 struct bus_container *c,
1801                 const char *contents) {
1802
1803         size_t nindex;
1804
1805         assert(m);
1806         assert(c);
1807         assert(contents);
1808
1809         if (!signature_is_pair(contents))
1810                 return -EINVAL;
1811
1812         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1813                 return -ENXIO;
1814
1815         if (c->signature && c->signature[c->index]) {
1816                 size_t l;
1817
1818                 l = strlen(contents);
1819
1820                 if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
1821                     !startswith(c->signature + c->index + 1, contents) ||
1822                     c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
1823                         return -ENXIO;
1824
1825                 nindex = c->index + 1 + l + 1;
1826         } else
1827                 return -ENXIO;
1828
1829         /* Align contents to 8 byte boundary */
1830         if (!message_extend_body(m, 8, 0))
1831                 return -ENOMEM;
1832
1833         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1834                 c->index = nindex;
1835
1836         return 0;
1837 }
1838
1839 int sd_bus_message_open_container(
1840                 sd_bus_message *m,
1841                 char type,
1842                 const char *contents) {
1843
1844         struct bus_container *c, *w;
1845         uint32_t *array_size = NULL;
1846         char *signature;
1847         size_t before;
1848         int r;
1849
1850         if (!m)
1851                 return -EINVAL;
1852         if (m->sealed)
1853                 return -EPERM;
1854         if (!contents)
1855                 return -EINVAL;
1856         if (m->poisoned)
1857                 return -ESTALE;
1858
1859         /* Make sure we have space for one more container */
1860         w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1));
1861         if (!w) {
1862                 m->poisoned = true;
1863                 return -ENOMEM;
1864         }
1865
1866         m->containers = w;
1867
1868         c = message_get_container(m);
1869
1870         signature = strdup(contents);
1871         if (!signature) {
1872                 m->poisoned = true;
1873                 return -ENOMEM;
1874         }
1875
1876         /* Save old index in the parent container, in case we have to
1877          * abort this container */
1878         c->saved_index = c->index;
1879         before = m->header->body_size;
1880
1881         if (type == SD_BUS_TYPE_ARRAY)
1882                 r = bus_message_open_array(m, c, contents, &array_size);
1883         else if (type == SD_BUS_TYPE_VARIANT)
1884                 r = bus_message_open_variant(m, c, contents);
1885         else if (type == SD_BUS_TYPE_STRUCT)
1886                 r = bus_message_open_struct(m, c, contents);
1887         else if (type == SD_BUS_TYPE_DICT_ENTRY)
1888                 r = bus_message_open_dict_entry(m, c, contents);
1889         else
1890                 r = -EINVAL;
1891
1892         if (r < 0) {
1893                 free(signature);
1894                 return r;
1895         }
1896
1897         /* OK, let's fill it in */
1898         w += m->n_containers++;
1899         w->enclosing = type;
1900         w->signature = signature;
1901         w->index = 0;
1902         w->array_size = array_size;
1903         w->before = before;
1904         w->begin = m->rindex;
1905
1906         return 0;
1907 }
1908
1909 int sd_bus_message_close_container(sd_bus_message *m) {
1910         struct bus_container *c;
1911
1912         if (!m)
1913                 return -EINVAL;
1914         if (m->sealed)
1915                 return -EPERM;
1916         if (m->n_containers <= 0)
1917                 return -EINVAL;
1918         if (m->poisoned)
1919                 return -ESTALE;
1920
1921         c = message_get_container(m);
1922         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1923                 if (c->signature && c->signature[c->index] != 0)
1924                         return -EINVAL;
1925
1926         free(c->signature);
1927         m->n_containers--;
1928
1929         return 0;
1930 }
1931
1932 typedef struct {
1933         const char *types;
1934         unsigned n_struct;
1935         unsigned n_array;
1936 } TypeStack;
1937
1938 static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) {
1939         assert(stack);
1940         assert(max > 0);
1941
1942         if (*i >= max)
1943                 return -EINVAL;
1944
1945         stack[*i].types = types;
1946         stack[*i].n_struct = n_struct;
1947         stack[*i].n_array = n_array;
1948         (*i)++;
1949
1950         return 0;
1951 }
1952
1953 static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) {
1954         assert(stack);
1955         assert(max > 0);
1956         assert(types);
1957         assert(n_struct);
1958         assert(n_array);
1959
1960         if (*i <= 0)
1961                 return 0;
1962
1963         (*i)--;
1964         *types = stack[*i].types;
1965         *n_struct = stack[*i].n_struct;
1966         *n_array = stack[*i].n_array;
1967
1968         return 1;
1969 }
1970
1971 int bus_message_append_ap(
1972                 sd_bus_message *m,
1973                 const char *types,
1974                 va_list ap) {
1975
1976         unsigned n_array, n_struct;
1977         TypeStack stack[BUS_CONTAINER_DEPTH];
1978         unsigned stack_ptr = 0;
1979         int r;
1980
1981         assert(m);
1982
1983         if (!types)
1984                 return 0;
1985
1986         n_array = (unsigned) -1;
1987         n_struct = strlen(types);
1988
1989         for (;;) {
1990                 const char *t;
1991
1992                 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
1993                         r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
1994                         if (r < 0)
1995                                 return r;
1996                         if (r == 0)
1997                                 break;
1998
1999                         r = sd_bus_message_close_container(m);
2000                         if (r < 0)
2001                                 return r;
2002
2003                         continue;
2004                 }
2005
2006                 t = types;
2007                 if (n_array != (unsigned) -1)
2008                         n_array --;
2009                 else {
2010                         types ++;
2011                         n_struct--;
2012                 }
2013
2014                 switch (*t) {
2015
2016                 case SD_BUS_TYPE_BYTE: {
2017                         uint8_t x;
2018
2019                         x = (uint8_t) va_arg(ap, int);
2020                         r = sd_bus_message_append_basic(m, *t, &x);
2021                         break;
2022                 }
2023
2024                 case SD_BUS_TYPE_BOOLEAN:
2025                 case SD_BUS_TYPE_INT32:
2026                 case SD_BUS_TYPE_UINT32:
2027                 case SD_BUS_TYPE_UNIX_FD: {
2028                         uint32_t x;
2029
2030                         /* We assume a boolean is the same as int32_t */
2031                         assert_cc(sizeof(int32_t) == sizeof(int));
2032
2033                         x = va_arg(ap, uint32_t);
2034                         r = sd_bus_message_append_basic(m, *t, &x);
2035                         break;
2036                 }
2037
2038                 case SD_BUS_TYPE_INT16:
2039                 case SD_BUS_TYPE_UINT16: {
2040                         uint16_t x;
2041
2042                         x = (uint16_t) va_arg(ap, int);
2043                         r = sd_bus_message_append_basic(m, *t, &x);
2044                         break;
2045                 }
2046
2047                 case SD_BUS_TYPE_INT64:
2048                 case SD_BUS_TYPE_UINT64:
2049                 case SD_BUS_TYPE_DOUBLE: {
2050                         uint64_t x;
2051
2052                         x = va_arg(ap, uint64_t);
2053                         r = sd_bus_message_append_basic(m, *t, &x);
2054                         break;
2055                 }
2056
2057                 case SD_BUS_TYPE_STRING:
2058                 case SD_BUS_TYPE_OBJECT_PATH:
2059                 case SD_BUS_TYPE_SIGNATURE: {
2060                         const char *x;
2061
2062                         x = va_arg(ap, const char*);
2063                         r = sd_bus_message_append_basic(m, *t, x);
2064                         break;
2065                 }
2066
2067                 case SD_BUS_TYPE_ARRAY: {
2068                         size_t k;
2069
2070                         r = signature_element_length(t + 1, &k);
2071                         if (r < 0)
2072                                 return r;
2073
2074                         {
2075                                 char s[k + 1];
2076                                 memcpy(s, t + 1, k);
2077                                 s[k] = 0;
2078
2079                                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
2080                                 if (r < 0)
2081                                         return r;
2082                         }
2083
2084                         if (n_array == (unsigned) -1) {
2085                                 types += k;
2086                                 n_struct -= k;
2087                         }
2088
2089                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2090                         if (r < 0)
2091                                 return r;
2092
2093                         types = t + 1;
2094                         n_struct = k;
2095                         n_array = va_arg(ap, unsigned);
2096
2097                         break;
2098                 }
2099
2100                 case SD_BUS_TYPE_VARIANT: {
2101                         const char *s;
2102
2103                         s = va_arg(ap, const char*);
2104                         if (!s)
2105                                 return -EINVAL;
2106
2107                         r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s);
2108                         if (r < 0)
2109                                 return r;
2110
2111                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2112                         if (r < 0)
2113                                 return r;
2114
2115                         types = s;
2116                         n_struct = strlen(s);
2117                         n_array = (unsigned) -1;
2118
2119                         break;
2120                 }
2121
2122                 case SD_BUS_TYPE_STRUCT_BEGIN:
2123                 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
2124                         size_t k;
2125
2126                         r = signature_element_length(t, &k);
2127                         if (r < 0)
2128                                 return r;
2129
2130                         {
2131                                 char s[k - 1];
2132
2133                                 memcpy(s, t + 1, k - 2);
2134                                 s[k - 2] = 0;
2135
2136                                 r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
2137                                 if (r < 0)
2138                                         return r;
2139                         }
2140
2141                         if (n_array == (unsigned) -1) {
2142                                 types += k - 1;
2143                                 n_struct -= k - 1;
2144                         }
2145
2146                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2147                         if (r < 0)
2148                                 return r;
2149
2150                         types = t + 1;
2151                         n_struct = k - 2;
2152                         n_array = (unsigned) -1;
2153
2154                         break;
2155                 }
2156
2157                 default:
2158                         r = -EINVAL;
2159                 }
2160
2161                 if (r < 0)
2162                         return r;
2163         }
2164
2165         return 0;
2166 }
2167
2168 int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
2169         va_list ap;
2170         int r;
2171
2172         if (!m)
2173                 return -EINVAL;
2174         if (m->sealed)
2175                 return -EPERM;
2176         if (m->poisoned)
2177                 return -ESTALE;
2178         if (!types)
2179                 return 0;
2180
2181         va_start(ap, types);
2182         r = bus_message_append_ap(m, types, ap);
2183         va_end(ap);
2184
2185         return r;
2186 }
2187
2188 int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, void **ptr) {
2189         ssize_t align, sz;
2190         void *a;
2191         int r;
2192
2193         if (!m)
2194                 return -EINVAL;
2195         if (m->sealed)
2196                 return -EPERM;
2197         if (!bus_type_is_trivial(type))
2198                 return -EINVAL;
2199         if (!ptr && size > 0)
2200                 return -EINVAL;
2201         if (m->poisoned)
2202                 return -ESTALE;
2203
2204         align = bus_type_get_alignment(type);
2205         sz = bus_type_get_size(type);
2206
2207         assert_se(align > 0);
2208         assert_se(sz > 0);
2209
2210         if (size % sz != 0)
2211                 return -EINVAL;
2212
2213         r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
2214         if (r < 0)
2215                 return r;
2216
2217         a = message_extend_body(m, align, size);
2218         if (!a)
2219                 return -ENOMEM;
2220
2221         r = sd_bus_message_close_container(m);
2222         if (r < 0)
2223                 return r;
2224
2225         *ptr = a;
2226         return 0;
2227 }
2228
2229 int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size) {
2230         int r;
2231         void *p;
2232
2233         if (!ptr && size > 0)
2234                 return -EINVAL;
2235
2236         r = sd_bus_message_append_array_space(m, type, size, &p);
2237         if (r < 0)
2238                 return r;
2239
2240         if (size > 0)
2241                 memcpy(p, ptr, size);
2242
2243         return 0;
2244 }
2245
2246 int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memfd *memfd) {
2247         _cleanup_close_ int copy_fd = -1;
2248         struct bus_body_part *part;
2249         ssize_t align, sz;
2250         uint64_t size;
2251         void *a;
2252         int r;
2253
2254         if (!m)
2255                 return -EINVAL;
2256         if (!memfd)
2257                 return -EINVAL;
2258         if (m->sealed)
2259                 return -EPERM;
2260         if (!bus_type_is_trivial(type))
2261                 return -EINVAL;
2262         if (m->poisoned)
2263                 return -ESTALE;
2264
2265         r = sd_memfd_set_sealed(memfd, true);
2266         if (r < 0)
2267                 return r;
2268
2269         copy_fd = sd_memfd_dup_fd(memfd);
2270         if (copy_fd < 0)
2271                 return copy_fd;
2272
2273         r = sd_memfd_get_size(memfd, &size);
2274         if (r < 0)
2275                 return r;
2276
2277         align = bus_type_get_alignment(type);
2278         sz = bus_type_get_size(type);
2279
2280         assert_se(align > 0);
2281         assert_se(sz > 0);
2282
2283         if (size % sz != 0)
2284                 return -EINVAL;
2285
2286         if (size > (uint64_t) (uint32_t) -1)
2287                 return -EINVAL;
2288
2289         r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
2290         if (r < 0)
2291                 return r;
2292
2293         a = message_extend_body(m, align, 0);
2294         if (!a)
2295                 return -ENOMEM;
2296
2297         part = message_append_part(m);
2298         if (!part)
2299                 return -ENOMEM;
2300
2301         part->memfd = copy_fd;
2302         part->sealed = true;
2303         part->size = size;
2304         copy_fd = -1;
2305
2306         message_extend_containers(m, size);
2307         m->header->body_size += size;
2308
2309         return sd_bus_message_close_container(m);
2310 }
2311
2312 int sd_bus_message_append_string_memfd(sd_bus_message *m, sd_memfd *memfd) {
2313         _cleanup_close_ int copy_fd = -1;
2314         struct bus_body_part *part;
2315         struct bus_container *c;
2316         uint64_t size;
2317         void *a;
2318         int r;
2319
2320         assert_return(m, -EINVAL);
2321         assert_return(memfd, -EINVAL);
2322         assert_return(!m->sealed, -EPERM);
2323         assert_return(!m->poisoned, -ESTALE);
2324
2325         r = sd_memfd_set_sealed(memfd, true);
2326         if (r < 0)
2327                 return r;
2328
2329         copy_fd = sd_memfd_dup_fd(memfd);
2330         if (copy_fd < 0)
2331                 return copy_fd;
2332
2333         r = sd_memfd_get_size(memfd, &size);
2334         if (r < 0)
2335                 return r;
2336
2337         /* We require this to be NUL terminated */
2338         if (size == 0)
2339                 return -EINVAL;
2340
2341         if (size > (uint64_t) (uint32_t) -1)
2342                 return -EINVAL;
2343
2344         c = message_get_container(m);
2345         if (c->signature && c->signature[c->index]) {
2346                 /* Container signature is already set */
2347
2348                 if (c->signature[c->index] != SD_BUS_TYPE_STRING)
2349                         return -ENXIO;
2350         } else {
2351                 char *e;
2352
2353                 /* Maybe we can append to the signature? But only if this is the top-level container*/
2354                 if (c->enclosing != 0)
2355                         return -ENXIO;
2356
2357                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRING), NULL);
2358                 if (!e) {
2359                         m->poisoned = true;
2360                         return -ENOMEM;
2361                 }
2362         }
2363
2364         a = message_extend_body(m, 4, 4);
2365         if (!a)
2366                 return -ENOMEM;
2367
2368         *(uint32_t*) a = size - 1;
2369
2370         part = message_append_part(m);
2371         if (!part)
2372                 return -ENOMEM;
2373
2374         part->memfd = copy_fd;
2375         part->sealed = true;
2376         part->size = size;
2377         copy_fd = -1;
2378
2379         message_extend_containers(m, size);
2380         m->header->body_size += size;
2381
2382         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2383                 c->index++;
2384
2385         return 0;
2386 }
2387
2388 int sd_bus_message_append_strv(sd_bus_message *m, char **l) {
2389         char **i;
2390         int r;
2391
2392         assert_return(m, -EINVAL);
2393         assert_return(!m->sealed, -EPERM);
2394         assert_return(!m->poisoned, -ESTALE);
2395
2396         r = sd_bus_message_open_container(m, 'a', "s");
2397         if (r < 0)
2398                 return r;
2399
2400         STRV_FOREACH(i, l) {
2401                 r = sd_bus_message_append_basic(m, 's', *i);
2402                 if (r < 0)
2403                         return r;
2404         }
2405
2406         return sd_bus_message_close_container(m);
2407 }
2408
2409 int bus_body_part_map(struct bus_body_part *part) {
2410         void *p;
2411         size_t psz;
2412
2413         assert_se(part);
2414
2415         if (part->data)
2416                 return 0;
2417
2418         if (part->size <= 0)
2419                 return 0;
2420
2421         /* For smaller zero parts (as used for padding) we don't need to map anything... */
2422         if (part->memfd < 0 && part->is_zero && part->size < 8) {
2423                 static const uint8_t zeroes[7] = { };
2424                 part->data = (void*) zeroes;
2425                 return 0;
2426         }
2427
2428         psz = PAGE_ALIGN(part->size);
2429
2430         if (part->memfd >= 0)
2431                 p = mmap(NULL, psz, PROT_READ, MAP_SHARED, part->memfd, 0);
2432         else if (part->is_zero)
2433                 p = mmap(NULL, psz, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
2434         else
2435                 return -EINVAL;
2436
2437         if (p == MAP_FAILED)
2438                 return -errno;
2439
2440         part->mapped = psz;
2441         part->data = p;
2442         part->munmap_this = true;
2443
2444         return 0;
2445 }
2446
2447 void bus_body_part_unmap(struct bus_body_part *part) {
2448
2449         assert_se(part);
2450
2451         if (part->memfd < 0)
2452                 return;
2453
2454         if (!part->data)
2455                 return;
2456
2457         if (!part->munmap_this)
2458                 return;
2459
2460         assert_se(munmap(part->data, part->mapped) == 0);
2461
2462         part->data = NULL;
2463         part->mapped = 0;
2464         part->munmap_this = false;
2465
2466         return;
2467 }
2468
2469 static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) {
2470         size_t k, start, end;
2471
2472         assert(rindex);
2473         assert(align > 0);
2474
2475         start = ALIGN_TO((size_t) *rindex, align);
2476         end = start + nbytes;
2477
2478         if (end > sz)
2479                 return -EBADMSG;
2480
2481         /* Verify that padding is 0 */
2482         for (k = *rindex; k < start; k++)
2483                 if (((const uint8_t*) p)[k] != 0)
2484                         return -EBADMSG;
2485
2486         if (r)
2487                 *r = (uint8_t*) p + start;
2488
2489         *rindex = end;
2490
2491         return 1;
2492 }
2493
2494 static bool message_end_of_array(sd_bus_message *m, size_t index) {
2495         struct bus_container *c;
2496
2497         assert(m);
2498
2499         c = message_get_container(m);
2500         if (!c->array_size)
2501                 return false;
2502
2503         return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
2504 }
2505
2506 static struct bus_body_part* find_part(sd_bus_message *m, size_t index, size_t sz, void **p) {
2507         struct bus_body_part *part;
2508         size_t begin;
2509         int r;
2510
2511         assert(m);
2512
2513         if (m->cached_rindex_part && index >= m->cached_rindex_part_begin) {
2514                 part = m->cached_rindex_part;
2515                 begin = m->cached_rindex_part_begin;
2516         } else {
2517                 part = &m->body;
2518                 begin = 0;
2519         }
2520
2521         while (part) {
2522                 if (index < begin)
2523                         return NULL;
2524
2525                 if (index + sz <= begin + part->size) {
2526
2527                         r = bus_body_part_map(part);
2528                         if (r < 0)
2529                                 return NULL;
2530
2531                         if (p)
2532                                 *p = (uint8_t*) part->data + index - begin;
2533
2534                         m->cached_rindex_part = part;
2535                         m->cached_rindex_part_begin = begin;
2536
2537                         return part;
2538                 }
2539
2540                 begin += part->size;
2541                 part = part->next;
2542         }
2543
2544         return NULL;
2545 }
2546
2547 static int message_peek_body(
2548                 sd_bus_message *m,
2549                 size_t *rindex,
2550                 size_t align,
2551                 size_t nbytes,
2552                 void **ret) {
2553
2554         size_t k, start, end, padding;
2555         struct bus_body_part *part;
2556         uint8_t *q;
2557
2558         assert(m);
2559         assert(rindex);
2560         assert(align > 0);
2561
2562         if (message_end_of_array(m, *rindex))
2563                 return 0;
2564
2565         start = ALIGN_TO((size_t) *rindex, align);
2566         padding = start - *rindex;
2567         end = start + nbytes;
2568
2569         if (end > BUS_MESSAGE_BODY_SIZE(m))
2570                 return -EBADMSG;
2571
2572         part = find_part(m, *rindex, padding, (void**) &q);
2573         if (!part)
2574                 return -EBADMSG;
2575
2576         if (q) {
2577                 /* Verify padding */
2578                 for (k = 0; k < padding; k++)
2579                         if (q[k] != 0)
2580                                 return -EBADMSG;
2581         }
2582
2583         part = find_part(m, start, nbytes, (void**) &q);
2584         if (!part || !q)
2585                 return -EBADMSG;
2586
2587         *rindex = end;
2588
2589         if (ret)
2590                 *ret = q;
2591
2592         return 1;
2593 }
2594
2595 static bool validate_nul(const char *s, size_t l) {
2596
2597         /* Check for NUL chars in the string */
2598         if (memchr(s, 0, l))
2599                 return false;
2600
2601         /* Check for NUL termination */
2602         if (s[l] != 0)
2603                 return false;
2604
2605         return true;
2606 }
2607
2608 static bool validate_string(const char *s, size_t l) {
2609
2610         if (!validate_nul(s, l))
2611                 return false;
2612
2613         /* Check if valid UTF8 */
2614         if (!utf8_is_valid(s))
2615                 return false;
2616
2617         return true;
2618 }
2619
2620 static bool validate_signature(const char *s, size_t l) {
2621
2622         if (!validate_nul(s, l))
2623                 return false;
2624
2625         /* Check if valid signature */
2626         if (!signature_is_valid(s, true))
2627                 return false;
2628
2629         return true;
2630 }
2631
2632 static bool validate_object_path(const char *s, size_t l) {
2633
2634         if (!validate_nul(s, l))
2635                 return false;
2636
2637         if (!object_path_is_valid(s))
2638                 return false;
2639
2640         return true;
2641 }
2642
2643 int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
2644         struct bus_container *c;
2645         void *q;
2646         int r;
2647
2648         if (!m)
2649                 return -EINVAL;
2650         if (!m->sealed)
2651                 return -EPERM;
2652         if (!bus_type_is_basic(type))
2653                 return -EINVAL;
2654
2655         c = message_get_container(m);
2656
2657         if (!c->signature || c->signature[c->index] == 0)
2658                 return -ENXIO;
2659
2660         if (message_end_of_array(m, m->rindex))
2661                 return 0;
2662
2663         if (c->signature[c->index] != type)
2664                 return -ENXIO;
2665
2666         switch (type) {
2667
2668         case SD_BUS_TYPE_STRING:
2669         case SD_BUS_TYPE_OBJECT_PATH: {
2670                 uint32_t l;
2671                 size_t rindex;
2672
2673                 rindex = m->rindex;
2674                 r = message_peek_body(m, &rindex, 4, 4, &q);
2675                 if (r <= 0)
2676                         return r;
2677
2678                 l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
2679                 r = message_peek_body(m, &rindex, 1, l+1, &q);
2680                 if (r < 0)
2681                         return r;
2682                 if (r == 0)
2683                         return -EBADMSG;
2684
2685                 if (type == SD_BUS_TYPE_OBJECT_PATH) {
2686                         if (!validate_object_path(q, l))
2687                                 return -EBADMSG;
2688                 } else {
2689                         if (!validate_string(q, l))
2690                                 return -EBADMSG;
2691                 }
2692
2693                 m->rindex = rindex;
2694                 if (p)
2695                         *(const char**) p = q;
2696
2697                 break;
2698         }
2699
2700         case SD_BUS_TYPE_SIGNATURE: {
2701                 uint8_t l;
2702                 size_t rindex;
2703
2704                 rindex = m->rindex;
2705                 r = message_peek_body(m, &rindex, 1, 1, &q);
2706                 if (r <= 0)
2707                         return r;
2708
2709                 l = *(uint8_t*) q;
2710                 r = message_peek_body(m, &rindex, 1, l+1, &q);
2711                 if (r < 0)
2712                         return r;
2713                 if (r == 0)
2714                         return -EBADMSG;
2715
2716                 if (!validate_signature(q, l))
2717                         return -EBADMSG;
2718
2719                 m->rindex = rindex;
2720
2721                 if (p)
2722                         *(const char**) p = q;
2723                 break;
2724         }
2725
2726         default: {
2727                 ssize_t sz, align;
2728                 size_t rindex;
2729
2730                 align = bus_type_get_alignment(type);
2731                 sz = bus_type_get_size(type);
2732                 assert(align > 0 && sz > 0);
2733
2734                 rindex = m->rindex;
2735                 r = message_peek_body(m, &rindex, align, sz, &q);
2736                 if (r <= 0)
2737                         return r;
2738
2739                 switch (type) {
2740
2741                 case SD_BUS_TYPE_BYTE:
2742                         if (p)
2743                                 *(uint8_t*) p = *(uint8_t*) q;
2744                         break;
2745
2746                 case SD_BUS_TYPE_BOOLEAN:
2747                         if (p)
2748                                 *(unsigned*) p = !!*(uint32_t*) q;
2749                         break;
2750
2751                 case SD_BUS_TYPE_INT16:
2752                 case SD_BUS_TYPE_UINT16:
2753                         if (p)
2754                                 *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
2755                         break;
2756
2757                 case SD_BUS_TYPE_INT32:
2758                 case SD_BUS_TYPE_UINT32:
2759                         if (p)
2760                                 *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
2761                         break;
2762
2763                 case SD_BUS_TYPE_INT64:
2764                 case SD_BUS_TYPE_UINT64:
2765                 case SD_BUS_TYPE_DOUBLE:
2766                         if (p)
2767                                 *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
2768                         break;
2769
2770                 case SD_BUS_TYPE_UNIX_FD: {
2771                         uint32_t j;
2772
2773                         j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
2774                         if (j >= m->n_fds)
2775                                 return -EBADMSG;
2776
2777                         if (p)
2778                                 *(int*) p = m->fds[j];
2779                         break;
2780                 }
2781
2782                 default:
2783                         assert_not_reached("Unknown basic type...");
2784                 }
2785
2786                 m->rindex = rindex;
2787
2788                 break;
2789         }
2790         }
2791
2792         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2793                 c->index++;
2794
2795         return 1;
2796 }
2797
2798 static int bus_message_enter_array(
2799                 sd_bus_message *m,
2800                 struct bus_container *c,
2801                 const char *contents,
2802                 uint32_t **array_size) {
2803
2804         size_t rindex;
2805         void *q;
2806         int r, alignment;
2807
2808         assert(m);
2809         assert(c);
2810         assert(contents);
2811         assert(array_size);
2812
2813         if (!signature_is_single(contents, true))
2814                 return -EINVAL;
2815
2816         alignment = bus_type_get_alignment(contents[0]);
2817         if (alignment < 0)
2818                 return alignment;
2819
2820         if (!c->signature || c->signature[c->index] == 0)
2821                 return 0;
2822
2823         if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
2824                 return -ENXIO;
2825
2826         if (!startswith(c->signature + c->index + 1, contents))
2827                 return -ENXIO;
2828
2829         rindex = m->rindex;
2830         r = message_peek_body(m, &rindex, 4, 4, &q);
2831         if (r <= 0)
2832                 return r;
2833
2834         if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
2835                 return -EBADMSG;
2836
2837         r = message_peek_body(m, &rindex, alignment, 0, NULL);
2838         if (r < 0)
2839                 return r;
2840         if (r == 0)
2841                 return -EBADMSG;
2842
2843         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2844                 c->index += 1 + strlen(contents);
2845
2846         m->rindex = rindex;
2847
2848         *array_size = (uint32_t*) q;
2849
2850         return 1;
2851 }
2852
2853 static int bus_message_enter_variant(
2854                 sd_bus_message *m,
2855                 struct bus_container *c,
2856                 const char *contents) {
2857
2858         size_t rindex;
2859         uint8_t l;
2860         void *q;
2861         int r;
2862
2863         assert(m);
2864         assert(c);
2865         assert(contents);
2866
2867         if (!signature_is_single(contents, false))
2868                 return -EINVAL;
2869
2870         if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
2871                 return -EINVAL;
2872
2873         if (!c->signature || c->signature[c->index] == 0)
2874                 return 0;
2875
2876         if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
2877                 return -ENXIO;
2878
2879         rindex = m->rindex;
2880         r = message_peek_body(m, &rindex, 1, 1, &q);
2881         if (r <= 0)
2882                 return r;
2883
2884         l = *(uint8_t*) q;
2885         r = message_peek_body(m, &rindex, 1, l+1, &q);
2886         if (r < 0)
2887                 return r;
2888         if (r == 0)
2889                 return -EBADMSG;
2890
2891         if (!validate_signature(q, l))
2892                 return -EBADMSG;
2893
2894         if (!streq(q, contents))
2895                 return -ENXIO;
2896
2897         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2898                 c->index++;
2899
2900         m->rindex = rindex;
2901
2902         return 1;
2903 }
2904
2905 static int bus_message_enter_struct(
2906                 sd_bus_message *m,
2907                 struct bus_container *c,
2908                 const char *contents) {
2909
2910         size_t l;
2911         int r;
2912
2913         assert(m);
2914         assert(c);
2915         assert(contents);
2916
2917         if (!signature_is_valid(contents, false))
2918                 return -EINVAL;
2919
2920         if (!c->signature || c->signature[c->index] == 0)
2921                 return 0;
2922
2923         l = strlen(contents);
2924
2925         if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
2926             !startswith(c->signature + c->index + 1, contents) ||
2927             c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
2928                 return -ENXIO;
2929
2930         r = message_peek_body(m, &m->rindex, 8, 0, NULL);
2931         if (r <= 0)
2932                 return r;
2933
2934         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2935                 c->index += 1 + l + 1;
2936
2937         return 1;
2938 }
2939
2940 static int bus_message_enter_dict_entry(
2941                 sd_bus_message *m,
2942                 struct bus_container *c,
2943                 const char *contents) {
2944
2945         size_t l;
2946         int r;
2947
2948         assert(m);
2949         assert(c);
2950         assert(contents);
2951
2952         if (!signature_is_pair(contents))
2953                 return -EINVAL;
2954
2955         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2956                 return -ENXIO;
2957
2958         if (!c->signature || c->signature[c->index] == 0)
2959                 return 0;
2960
2961         l = strlen(contents);
2962
2963         if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
2964             !startswith(c->signature + c->index + 1, contents) ||
2965             c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
2966                 return -ENXIO;
2967
2968         r = message_peek_body(m, &m->rindex, 8, 0, NULL);
2969         if (r <= 0)
2970                 return r;
2971
2972         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2973                 c->index += 1 + l + 1;
2974
2975         return 1;
2976 }
2977
2978 int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents) {
2979         struct bus_container *c, *w;
2980         uint32_t *array_size = NULL;
2981         char *signature;
2982         size_t before;
2983         int r;
2984
2985         assert_return(m, -EINVAL);
2986         assert_return(m->sealed, -EPERM);
2987         assert_return(type != 0 || !contents, -EINVAL);
2988
2989         if (type == 0 || !contents) {
2990                 const char *cc;
2991                 char tt;
2992
2993                 /* Allow entering into anonymous containers */
2994                 r = sd_bus_message_peek_type(m, &tt, &cc);
2995                 if (r <= 0)
2996                         return r;
2997
2998                 if (type != 0 && type != tt)
2999                         return -ENXIO;
3000
3001                 if (contents && !streq(contents, cc))
3002                         return -ENXIO;
3003
3004                 type = tt;
3005                 contents = cc;
3006         }
3007
3008         /*
3009          * We enforce a global limit on container depth, that is much
3010          * higher than the 32 structs and 32 arrays the specification
3011          * mandates. This is simpler to implement for us, and we need
3012          * this only to ensure our container array doesn't grow
3013          * without bounds. We are happy to return any data from a
3014          * message as long as the data itself is valid, even if the
3015          * overall message might be not.
3016          *
3017          * Note that the message signature is validated when
3018          * parsing the headers, and that validation does check the
3019          * 32/32 limit.
3020          *
3021          * Note that the specification defines no limits on the depth
3022          * of stacked variants, but we do.
3023          */
3024         if (m->n_containers >= BUS_CONTAINER_DEPTH)
3025                 return -EBADMSG;
3026
3027         w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1));
3028         if (!w)
3029                 return -ENOMEM;
3030         m->containers = w;
3031
3032         c = message_get_container(m);
3033
3034         if (!c->signature || c->signature[c->index] == 0)
3035                 return -ENXIO;
3036
3037         if (message_end_of_array(m, m->rindex))
3038                 return 0;
3039
3040         signature = strdup(contents);
3041         if (!signature)
3042                 return -ENOMEM;
3043
3044         c->saved_index = c->index;
3045         before = m->rindex;
3046
3047         if (type == SD_BUS_TYPE_ARRAY)
3048                 r = bus_message_enter_array(m, c, contents, &array_size);
3049         else if (type == SD_BUS_TYPE_VARIANT)
3050                 r = bus_message_enter_variant(m, c, contents);
3051         else if (type == SD_BUS_TYPE_STRUCT)
3052                 r = bus_message_enter_struct(m, c, contents);
3053         else if (type == SD_BUS_TYPE_DICT_ENTRY)
3054                 r = bus_message_enter_dict_entry(m, c, contents);
3055         else
3056                 r = -EINVAL;
3057
3058         if (r <= 0) {
3059                 free(signature);
3060                 return r;
3061         }
3062
3063         /* OK, let's fill it in */
3064         w += m->n_containers++;
3065         w->enclosing = type;
3066         w->signature = signature;
3067         w->index = 0;
3068         w->array_size = array_size;
3069         w->before = before;
3070         w->begin = m->rindex;
3071
3072         return 1;
3073 }
3074
3075 int sd_bus_message_exit_container(sd_bus_message *m) {
3076         struct bus_container *c;
3077
3078         if (!m)
3079                 return -EINVAL;
3080         if (!m->sealed)
3081                 return -EPERM;
3082         if (m->n_containers <= 0)
3083                 return -EINVAL;
3084
3085         c = message_get_container(m);
3086         if (c->enclosing == SD_BUS_TYPE_ARRAY) {
3087                 uint32_t l;
3088
3089                 l = BUS_MESSAGE_BSWAP32(m, *c->array_size);
3090                 if (c->begin + l != m->rindex)
3091                         return -EBUSY;
3092
3093         } else {
3094                 if (c->signature && c->signature[c->index] != 0)
3095                         return -EINVAL;
3096         }
3097
3098         free(c->signature);
3099         m->n_containers--;
3100
3101         return 1;
3102 }
3103
3104 static void message_quit_container(sd_bus_message *m) {
3105         struct bus_container *c;
3106
3107         assert(m);
3108         assert(m->sealed);
3109         assert(m->n_containers > 0);
3110
3111         c = message_get_container(m);
3112
3113         /* Undo seeks */
3114         assert(m->rindex >= c->before);
3115         m->rindex = c->before;
3116
3117         /* Free container */
3118         free(c->signature);
3119         m->n_containers--;
3120
3121         /* Correct index of new top-level container */
3122         c = message_get_container(m);
3123         c->index = c->saved_index;
3124 }
3125
3126 int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
3127         struct bus_container *c;
3128         int r;
3129
3130         assert_return(m, -EINVAL);
3131         assert_return(m->sealed, -EPERM);
3132
3133         c = message_get_container(m);
3134
3135         if (!c->signature || c->signature[c->index] == 0)
3136                 goto eof;
3137
3138         if (message_end_of_array(m, m->rindex))
3139                 goto eof;
3140
3141         if (bus_type_is_basic(c->signature[c->index])) {
3142                 if (contents)
3143                         *contents = NULL;
3144                 if (type)
3145                         *type = c->signature[c->index];
3146                 return 1;
3147         }
3148
3149         if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) {
3150
3151                 if (contents) {
3152                         size_t l;
3153                         char *sig;
3154
3155                         r = signature_element_length(c->signature+c->index+1, &l);
3156                         if (r < 0)
3157                                 return r;
3158
3159                         assert(l >= 1);
3160
3161                         sig = strndup(c->signature + c->index + 1, l);
3162                         if (!sig)
3163                                 return -ENOMEM;
3164
3165                         free(m->peeked_signature);
3166                         m->peeked_signature = sig;
3167
3168                         *contents = sig;
3169                 }
3170
3171                 if (type)
3172                         *type = SD_BUS_TYPE_ARRAY;
3173
3174                 return 1;
3175         }
3176
3177         if (c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ||
3178             c->signature[c->index] == SD_BUS_TYPE_DICT_ENTRY_BEGIN) {
3179
3180                 if (contents) {
3181                         size_t l;
3182                         char *sig;
3183
3184                         r = signature_element_length(c->signature+c->index, &l);
3185                         if (r < 0)
3186                                 return r;
3187
3188                         assert(l >= 2);
3189                         sig = strndup(c->signature + c->index + 1, l - 2);
3190                         if (!sig)
3191                                 return -ENOMEM;
3192
3193                         free(m->peeked_signature);
3194                         m->peeked_signature = sig;
3195
3196                         *contents = sig;
3197                 }
3198
3199                 if (type)
3200                         *type = c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
3201
3202                 return 1;
3203         }
3204
3205         if (c->signature[c->index] == SD_BUS_TYPE_VARIANT) {
3206                 if (contents) {
3207                         size_t rindex, l;
3208                         void *q;
3209
3210                         rindex = m->rindex;
3211                         r = message_peek_body(m, &rindex, 1, 1, &q);
3212                         if (r < 0)
3213                                 return r;
3214                         if (r == 0)
3215                                 goto eof;
3216
3217                         l = *(uint8_t*) q;
3218                         r = message_peek_body(m, &rindex, 1, l+1, &q);
3219                         if (r < 0)
3220                                 return r;
3221                         if (r == 0)
3222                                 return -EBADMSG;
3223
3224                         if (!validate_signature(q, l))
3225                                 return -EBADMSG;
3226
3227                         *contents = q;
3228                 }
3229
3230                 if (type)
3231                         *type = SD_BUS_TYPE_VARIANT;
3232
3233                 return 1;
3234         }
3235
3236         return -EINVAL;
3237
3238 eof:
3239         if (type)
3240                 *type = c->enclosing;
3241         if (contents)
3242                 *contents = NULL;
3243         return 0;
3244 }
3245
3246 int sd_bus_message_rewind(sd_bus_message *m, int complete) {
3247         struct bus_container *c;
3248
3249         if (!m)
3250                 return -EINVAL;
3251         if (!m->sealed)
3252                 return -EPERM;
3253
3254         if (complete) {
3255                 message_reset_containers(m);
3256                 m->rindex = 0;
3257                 m->root_container.index = 0;
3258
3259                 c = message_get_container(m);
3260         } else {
3261                 c = message_get_container(m);
3262
3263                 c->index = 0;
3264                 m->rindex = c->begin;
3265         }
3266
3267         return !isempty(c->signature);
3268 }
3269 static int message_read_ap(
3270                 sd_bus_message *m,
3271                 const char *types,
3272                 va_list ap) {
3273
3274         unsigned n_array, n_struct;
3275         TypeStack stack[BUS_CONTAINER_DEPTH];
3276         unsigned stack_ptr = 0;
3277         unsigned n_loop = 0;
3278         int r;
3279
3280         assert(m);
3281
3282         if (isempty(types))
3283                 return 0;
3284
3285         /* Ideally, we'd just call ourselves recursively on every
3286          * complex type. However, the state of a va_list that is
3287          * passed to a function is undefined after that function
3288          * returns. This means we need to docode the va_list linearly
3289          * in a single stackframe. We hence implement our own
3290          * home-grown stack in an array. */
3291
3292         n_array = (unsigned) -1; /* lenght of current array entries */
3293         n_struct = strlen(types); /* length of current struct contents signature */
3294
3295         for (;;) {
3296                 const char *t;
3297
3298                 n_loop++;
3299
3300                 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
3301                         r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
3302                         if (r < 0)
3303                                 return r;
3304                         if (r == 0)
3305                                 break;
3306
3307                         r = sd_bus_message_exit_container(m);
3308                         if (r < 0)
3309                                 return r;
3310
3311                         continue;
3312                 }
3313
3314                 t = types;
3315                 if (n_array != (unsigned) -1)
3316                         n_array --;
3317                 else {
3318                         types ++;
3319                         n_struct--;
3320                 }
3321
3322                 switch (*t) {
3323
3324                 case SD_BUS_TYPE_BYTE:
3325                 case SD_BUS_TYPE_BOOLEAN:
3326                 case SD_BUS_TYPE_INT16:
3327                 case SD_BUS_TYPE_UINT16:
3328                 case SD_BUS_TYPE_INT32:
3329                 case SD_BUS_TYPE_UINT32:
3330                 case SD_BUS_TYPE_INT64:
3331                 case SD_BUS_TYPE_UINT64:
3332                 case SD_BUS_TYPE_DOUBLE:
3333                 case SD_BUS_TYPE_STRING:
3334                 case SD_BUS_TYPE_OBJECT_PATH:
3335                 case SD_BUS_TYPE_SIGNATURE:
3336                 case SD_BUS_TYPE_UNIX_FD: {
3337                         void *p;
3338
3339                         p = va_arg(ap, void*);
3340                         r = sd_bus_message_read_basic(m, *t, p);
3341                         if (r < 0)
3342                                 return r;
3343                         if (r == 0) {
3344                                 if (n_loop <= 1)
3345                                         return 0;
3346
3347                                 return -ENXIO;
3348                         }
3349
3350                         break;
3351                 }
3352
3353                 case SD_BUS_TYPE_ARRAY: {
3354                         size_t k;
3355
3356                         r = signature_element_length(t + 1, &k);
3357                         if (r < 0)
3358                                 return r;
3359
3360                         {
3361                                 char s[k + 1];
3362                                 memcpy(s, t + 1, k);
3363                                 s[k] = 0;
3364
3365                                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
3366                                 if (r < 0)
3367                                         return r;
3368                                 if (r == 0) {
3369                                         if (n_loop <= 1)
3370                                                 return 0;
3371
3372                                         return -ENXIO;
3373                                 }
3374                         }
3375
3376                         if (n_array == (unsigned) -1) {
3377                                 types += k;
3378                                 n_struct -= k;
3379                         }
3380
3381                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
3382                         if (r < 0)
3383                                 return r;
3384
3385                         types = t + 1;
3386                         n_struct = k;
3387                         n_array = va_arg(ap, unsigned);
3388
3389                         break;
3390                 }
3391
3392                 case SD_BUS_TYPE_VARIANT: {
3393                         const char *s;
3394
3395                         s = va_arg(ap, const char *);
3396                         if (!s)
3397                                 return -EINVAL;
3398
3399                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s);
3400                         if (r < 0)
3401                                 return r;
3402                         if (r == 0) {
3403                                 if (n_loop <= 1)
3404                                         return 0;
3405
3406                                 return -ENXIO;
3407                         }
3408
3409                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
3410                         if (r < 0)
3411                                 return r;
3412
3413                         types = s;
3414                         n_struct = strlen(s);
3415                         n_array = (unsigned) -1;
3416
3417                         break;
3418                 }
3419
3420                 case SD_BUS_TYPE_STRUCT_BEGIN:
3421                 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
3422                         size_t k;
3423
3424                         r = signature_element_length(t, &k);
3425                         if (r < 0)
3426                                 return r;
3427
3428                         {
3429                                 char s[k - 1];
3430                                 memcpy(s, t + 1, k - 2);
3431                                 s[k - 2] = 0;
3432
3433                                 r = sd_bus_message_enter_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
3434                                 if (r < 0)
3435                                         return r;
3436                                 if (r == 0) {
3437                                         if (n_loop <= 1)
3438                                                 return 0;
3439                                         return -ENXIO;
3440                                 }
3441                         }
3442
3443                         if (n_array == (unsigned) -1) {
3444                                 types += k - 1;
3445                                 n_struct -= k - 1;
3446                         }
3447
3448                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
3449                         if (r < 0)
3450                                 return r;
3451
3452                         types = t + 1;
3453                         n_struct = k - 2;
3454                         n_array = (unsigned) -1;
3455
3456                         break;
3457                 }
3458
3459                 default:
3460                         return -EINVAL;
3461                 }
3462         }
3463
3464         return 1;
3465 }
3466
3467 int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
3468         va_list ap;
3469         int r;
3470
3471         assert_return(m, -EINVAL);
3472         assert_return(m->sealed, -EPERM);
3473         assert_return(types, -EINVAL);
3474
3475         va_start(ap, types);
3476         r = message_read_ap(m, types, ap);
3477         va_end(ap);
3478
3479         return r;
3480 }
3481
3482 int sd_bus_message_skip(sd_bus_message *m, const char *types) {
3483         int r;
3484
3485         assert_return(m, -EINVAL);
3486         assert_return(m->sealed, -EPERM);
3487         assert_return(types, -EINVAL);
3488
3489         if (isempty(types))
3490                 return 0;
3491
3492         switch (*types) {
3493
3494         case SD_BUS_TYPE_BYTE:
3495         case SD_BUS_TYPE_BOOLEAN:
3496         case SD_BUS_TYPE_INT16:
3497         case SD_BUS_TYPE_UINT16:
3498         case SD_BUS_TYPE_INT32:
3499         case SD_BUS_TYPE_UINT32:
3500         case SD_BUS_TYPE_INT64:
3501         case SD_BUS_TYPE_UINT64:
3502         case SD_BUS_TYPE_DOUBLE:
3503         case SD_BUS_TYPE_STRING:
3504         case SD_BUS_TYPE_OBJECT_PATH:
3505         case SD_BUS_TYPE_SIGNATURE:
3506         case SD_BUS_TYPE_UNIX_FD:
3507
3508                 r = sd_bus_message_read_basic(m, *types, NULL);
3509                 if (r <= 0)
3510                         return r;
3511
3512                 r = sd_bus_message_skip(m, types + 1);
3513                 if (r < 0)
3514                         return r;
3515
3516                 return 1;
3517
3518         case SD_BUS_TYPE_ARRAY: {
3519                 size_t k;
3520
3521                 r = signature_element_length(types + 1, &k);
3522                 if (r < 0)
3523                         return r;
3524
3525                 {
3526                         char s[k+1];
3527                         memcpy(s, types+1, k);
3528                         s[k] = 0;
3529
3530                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
3531                         if (r <= 0)
3532                                 return r;
3533
3534                         for (;;) {
3535                                 r = sd_bus_message_skip(m, s);
3536                                 if (r < 0)
3537                                         return r;
3538                                 if (r == 0)
3539                                         break;
3540                         }
3541
3542                         r = sd_bus_message_exit_container(m);
3543                         if (r < 0)
3544                                 return r;
3545                 }
3546
3547                 r = sd_bus_message_skip(m, types + 1 + k);
3548                 if (r < 0)
3549                         return r;
3550
3551                 return 1;
3552         }
3553
3554         case SD_BUS_TYPE_VARIANT: {
3555                 const char *contents;
3556                 char x;
3557
3558                 r = sd_bus_message_peek_type(m, &x, &contents);
3559                 if (r <= 0)
3560                         return r;
3561
3562                 if (x != SD_BUS_TYPE_VARIANT)
3563                         return -ENXIO;
3564
3565                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
3566                 if (r <= 0)
3567                         return r;
3568
3569                 r = sd_bus_message_skip(m, contents);
3570                 if (r < 0)
3571                         return r;
3572                 assert(r != 0);
3573
3574                 r = sd_bus_message_exit_container(m);
3575                 if (r < 0)
3576                         return r;
3577
3578                 r = sd_bus_message_skip(m, types + 1);
3579                 if (r < 0)
3580                         return r;
3581
3582                 return 1;
3583         }
3584
3585         case SD_BUS_TYPE_STRUCT_BEGIN:
3586         case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
3587                 size_t k;
3588
3589                 r = signature_element_length(types, &k);
3590                 if (r < 0)
3591                         return r;
3592
3593                 {
3594                         char s[k-1];
3595                         memcpy(s, types+1, k-2);
3596                         s[k-2] = 0;
3597
3598                         r = sd_bus_message_enter_container(m, *types == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
3599                         if (r <= 0)
3600                                 return r;
3601
3602                         r = sd_bus_message_skip(m, s);
3603                         if (r < 0)
3604                                 return r;
3605                         assert(r != 0);
3606
3607                         r = sd_bus_message_exit_container(m);
3608                         if (r < 0)
3609                                 return r;
3610                 }
3611
3612                 r = sd_bus_message_skip(m, types + k);
3613                 if (r < 0)
3614                         return r;
3615
3616                 return 1;
3617         }
3618
3619         default:
3620                 return -EINVAL;
3621         }
3622 }
3623
3624 int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size) {
3625         struct bus_container *c;
3626         void *p;
3627         size_t sz;
3628         ssize_t align;
3629         int r;
3630
3631         if (!m)
3632                 return -EINVAL;
3633         if (!m->sealed)
3634                 return -EPERM;
3635         if (!bus_type_is_trivial(type))
3636                 return -EINVAL;
3637         if (!ptr)
3638                 return -EINVAL;
3639         if (!size)
3640                 return -EINVAL;
3641         if (BUS_MESSAGE_NEED_BSWAP(m))
3642                 return -ENOTSUP;
3643
3644         align = bus_type_get_alignment(type);
3645         if (align < 0)
3646                 return align;
3647
3648         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, CHAR_TO_STR(type));
3649         if (r <= 0)
3650                 return r;
3651
3652         c = message_get_container(m);
3653         sz = BUS_MESSAGE_BSWAP32(m, *c->array_size);
3654
3655         r = message_peek_body(m, &m->rindex, align, sz, &p);
3656         if (r < 0)
3657                 goto fail;
3658         if (r == 0) {
3659                 r = -EBADMSG;
3660                 goto fail;
3661         }
3662
3663         r = sd_bus_message_exit_container(m);
3664         if (r < 0)
3665                 goto fail;
3666
3667         *ptr = (const void*) p;
3668         *size = sz;
3669
3670         return 1;
3671
3672 fail:
3673         message_quit_container(m);
3674         return r;
3675 }
3676
3677 static int message_peek_fields(
3678                 sd_bus_message *m,
3679                 size_t *rindex,
3680                 size_t align,
3681                 size_t nbytes,
3682                 void **ret) {
3683
3684         assert(m);
3685         assert(rindex);
3686         assert(align > 0);
3687
3688         return buffer_peek(BUS_MESSAGE_FIELDS(m), BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret);
3689 }
3690
3691 static int message_peek_field_uint32(
3692                 sd_bus_message *m,
3693                 size_t *ri,
3694                 uint32_t *ret) {
3695
3696         int r;
3697         void *q;
3698
3699         assert(m);
3700         assert(ri);
3701
3702         r = message_peek_fields(m, ri, 4, 4, &q);
3703         if (r < 0)
3704                 return r;
3705
3706         if (ret)
3707                 *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
3708
3709         return 0;
3710 }
3711
3712 static int message_peek_field_string(
3713                 sd_bus_message *m,
3714                 bool (*validate)(const char *p),
3715                 size_t *ri,
3716                 const char **ret) {
3717
3718         uint32_t l;
3719         int r;
3720         void *q;
3721
3722         assert(m);
3723         assert(ri);
3724
3725         r = message_peek_field_uint32(m, ri, &l);
3726         if (r < 0)
3727                 return r;
3728
3729         r = message_peek_fields(m, ri, 1, l+1, &q);
3730         if (r < 0)
3731                 return r;
3732
3733         if (validate) {
3734                 if (!validate_nul(q, l))
3735                         return -EBADMSG;
3736
3737                 if (!validate(q))
3738                         return -EBADMSG;
3739         } else {
3740                 if (!validate_string(q, l))
3741                         return -EBADMSG;
3742         }
3743
3744         if (ret)
3745                 *ret = q;
3746
3747         return 0;
3748 }
3749
3750 static int message_peek_field_signature(
3751                 sd_bus_message *m,
3752                 size_t *ri,
3753                 const char **ret) {
3754
3755         size_t l;
3756         int r;
3757         void *q;
3758
3759         assert(m);
3760         assert(ri);
3761
3762         r = message_peek_fields(m, ri, 1, 1, &q);
3763         if (r < 0)
3764                 return r;
3765
3766         l = *(uint8_t*) q;
3767         r = message_peek_fields(m, ri, 1, l+1, &q);
3768         if (r < 0)
3769                 return r;
3770
3771         if (!validate_signature(q, l))
3772                 return -EBADMSG;
3773
3774         if (ret)
3775                 *ret = q;
3776
3777         return 0;
3778 }
3779
3780 static int message_skip_fields(
3781                 sd_bus_message *m,
3782                 size_t *ri,
3783                 uint32_t array_size,
3784                 const char **signature) {
3785
3786         size_t original_index;
3787         int r;
3788
3789         assert(m);
3790         assert(ri);
3791         assert(signature);
3792
3793         original_index = *ri;
3794
3795         for (;;) {
3796                 char t;
3797                 size_t l;
3798
3799                 if (array_size != (uint32_t) -1 &&
3800                     array_size <= *ri - original_index)
3801                         return 0;
3802
3803                 t = **signature;
3804                 if (!t)
3805                         return 0;
3806
3807                 if (t == SD_BUS_TYPE_STRING) {
3808
3809                         r = message_peek_field_string(m, NULL, ri, NULL);
3810                         if (r < 0)
3811                                 return r;
3812
3813                         (*signature)++;
3814
3815                 } else if (t == SD_BUS_TYPE_OBJECT_PATH) {
3816
3817                         r = message_peek_field_string(m, object_path_is_valid, ri, NULL);
3818                         if (r < 0)
3819                                 return r;
3820
3821                         (*signature)++;
3822
3823                 } else if (t == SD_BUS_TYPE_SIGNATURE) {
3824
3825                         r = message_peek_field_signature(m, ri, NULL);
3826                         if (r < 0)
3827                                 return r;
3828
3829                         (*signature)++;
3830
3831                 } else if (bus_type_is_basic(t)) {
3832                         ssize_t align, k;
3833
3834                         align = bus_type_get_alignment(t);
3835                         k = bus_type_get_size(t);
3836                         assert(align > 0 && k > 0);
3837
3838                         r = message_peek_fields(m, ri, align, k, NULL);
3839                         if (r < 0)
3840                                 return r;
3841
3842                         (*signature)++;
3843
3844                 } else if (t == SD_BUS_TYPE_ARRAY) {
3845
3846                         r = signature_element_length(*signature+1, &l);
3847                         if (r < 0)
3848                                 return r;
3849
3850                         assert(l >= 1);
3851                         {
3852                                 char sig[l-1], *s;
3853                                 uint32_t nas;
3854                                 int alignment;
3855
3856                                 strncpy(sig, *signature + 1, l-1);
3857                                 s = sig;
3858
3859                                 alignment = bus_type_get_alignment(sig[0]);
3860                                 if (alignment < 0)
3861                                         return alignment;
3862
3863                                 r = message_peek_field_uint32(m, ri, &nas);
3864                                 if (r < 0)
3865                                         return r;
3866                                 if (nas > BUS_ARRAY_MAX_SIZE)
3867                                         return -EBADMSG;
3868
3869                                 r = message_peek_fields(m, ri, alignment, 0, NULL);
3870                                 if (r < 0)
3871                                         return r;
3872
3873                                 r = message_skip_fields(m, ri, nas, (const char**) &s);
3874                                 if (r < 0)
3875                                         return r;
3876                         }
3877
3878                         (*signature) += 1 + l;
3879
3880                 } else if (t == SD_BUS_TYPE_VARIANT) {
3881                         const char *s;
3882
3883                         r = message_peek_field_signature(m, ri, &s);
3884                         if (r < 0)
3885                                 return r;
3886
3887                         r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
3888                         if (r < 0)
3889                                 return r;
3890
3891                         (*signature)++;
3892
3893                 } else if (t == SD_BUS_TYPE_STRUCT ||
3894                            t == SD_BUS_TYPE_DICT_ENTRY) {
3895
3896                         r = signature_element_length(*signature, &l);
3897                         if (r < 0)
3898                                 return r;
3899
3900                         assert(l >= 2);
3901                         {
3902                                 char sig[l-1], *s;
3903                                 strncpy(sig, *signature + 1, l-1);
3904                                 s = sig;
3905
3906                                 r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
3907                                 if (r < 0)
3908                                         return r;
3909                         }
3910
3911                         *signature += l;
3912                 } else
3913                         return -EINVAL;
3914         }
3915 }
3916
3917 int bus_message_parse_fields(sd_bus_message *m) {
3918         size_t ri;
3919         int r;
3920         uint32_t unix_fds = 0;
3921
3922         assert(m);
3923
3924         for (ri = 0; ri < BUS_MESSAGE_FIELDS_SIZE(m); ) {
3925                 const char *signature;
3926                 uint8_t *header;
3927
3928                 r = message_peek_fields(m, &ri, 8, 1, (void**) &header);
3929                 if (r < 0)
3930                         return r;
3931
3932                 r = message_peek_field_signature(m, &ri, &signature);
3933                 if (r < 0)
3934                         return r;
3935
3936                 switch (*header) {
3937                 case _SD_BUS_MESSAGE_HEADER_INVALID:
3938                         return -EBADMSG;
3939
3940                 case SD_BUS_MESSAGE_HEADER_PATH:
3941
3942                         if (m->path)
3943                                 return -EBADMSG;
3944
3945                         if (!streq(signature, "o"))
3946                                 return -EBADMSG;
3947
3948                         r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path);
3949                         break;
3950
3951                 case SD_BUS_MESSAGE_HEADER_INTERFACE:
3952
3953                         if (m->interface)
3954                                 return -EBADMSG;
3955
3956                         if (!streq(signature, "s"))
3957                                 return -EBADMSG;
3958
3959                         r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface);
3960                         break;
3961
3962                 case SD_BUS_MESSAGE_HEADER_MEMBER:
3963
3964                         if (m->member)
3965                                 return -EBADMSG;
3966
3967                         if (!streq(signature, "s"))
3968                                 return -EBADMSG;
3969
3970                         r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member);
3971                         break;
3972
3973                 case SD_BUS_MESSAGE_HEADER_ERROR_NAME:
3974
3975                         if (m->error.name)
3976                                 return -EBADMSG;
3977
3978                         if (!streq(signature, "s"))
3979                                 return -EBADMSG;
3980
3981                         r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name);
3982                         break;
3983
3984                 case SD_BUS_MESSAGE_HEADER_DESTINATION:
3985
3986                         if (m->destination)
3987                                 return -EBADMSG;
3988
3989                         if (!streq(signature, "s"))
3990                                 return -EBADMSG;
3991
3992                         r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination);
3993                         break;
3994
3995                 case SD_BUS_MESSAGE_HEADER_SENDER:
3996
3997                         if (m->sender)
3998                                 return -EBADMSG;
3999
4000                         if (!streq(signature, "s"))
4001                                 return -EBADMSG;
4002
4003                         r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);
4004                         break;
4005
4006
4007                 case SD_BUS_MESSAGE_HEADER_SIGNATURE: {
4008                         const char *s;
4009                         char *c;
4010
4011                         if (m->root_container.signature)
4012                                 return -EBADMSG;
4013
4014                         if (!streq(signature, "g"))
4015                                 return -EBADMSG;
4016
4017                         r = message_peek_field_signature(m, &ri, &s);
4018                         if (r < 0)
4019                                 return r;
4020
4021                         c = strdup(s);
4022                         if (!c)
4023                                 return -ENOMEM;
4024
4025                         free(m->root_container.signature);
4026                         m->root_container.signature = c;
4027                         break;
4028                 }
4029
4030                 case SD_BUS_MESSAGE_HEADER_REPLY_SERIAL:
4031                         if (m->reply_serial != 0)
4032                                 return -EBADMSG;
4033
4034                         if (!streq(signature, "u"))
4035                                 return -EBADMSG;
4036
4037                         r = message_peek_field_uint32(m, &ri, &m->reply_serial);
4038                         if (r < 0)
4039                                 return r;
4040
4041                         if (m->reply_serial == 0)
4042                                 return -EBADMSG;
4043
4044                         break;
4045
4046                 case SD_BUS_MESSAGE_HEADER_UNIX_FDS:
4047                         if (unix_fds != 0)
4048                                 return -EBADMSG;
4049
4050                         if (!streq(signature, "u"))
4051                                 return -EBADMSG;
4052
4053                         r = message_peek_field_uint32(m, &ri, &unix_fds);
4054                         if (r < 0)
4055                                 return -EBADMSG;
4056
4057                         if (unix_fds == 0)
4058                                 return -EBADMSG;
4059
4060                         break;
4061
4062                 default:
4063                         r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
4064                 }
4065
4066                 if (r < 0)
4067                         return r;
4068         }
4069
4070         if (m->n_fds != unix_fds)
4071                 return -EBADMSG;
4072
4073         if (isempty(m->root_container.signature) != (BUS_MESSAGE_BODY_SIZE(m) == 0))
4074                 return -EBADMSG;
4075
4076         switch (m->header->type) {
4077
4078         case SD_BUS_MESSAGE_SIGNAL:
4079                 if (!m->path || !m->interface || !m->member)
4080                         return -EBADMSG;
4081                 break;
4082
4083         case SD_BUS_MESSAGE_METHOD_CALL:
4084
4085                 if (!m->path || !m->member)
4086                         return -EBADMSG;
4087
4088                 break;
4089
4090         case SD_BUS_MESSAGE_METHOD_RETURN:
4091
4092                 if (m->reply_serial == 0)
4093                         return -EBADMSG;
4094                 break;
4095
4096         case SD_BUS_MESSAGE_METHOD_ERROR:
4097
4098                 if (m->reply_serial == 0 || !m->error.name)
4099                         return -EBADMSG;
4100                 break;
4101         }
4102
4103         /* Try to read the error message, but if we can't it's a non-issue */
4104         if (m->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
4105                 sd_bus_message_read(m, "s", &m->error.message);
4106
4107         return 0;
4108 }
4109
4110 int bus_message_seal(sd_bus_message *m, uint64_t serial) {
4111         struct bus_body_part *part;
4112         size_t l, a;
4113         unsigned i;
4114         int r;
4115
4116         assert(m);
4117
4118         if (m->sealed)
4119                 return -EPERM;
4120
4121         if (m->n_containers > 0)
4122                 return -EBADMSG;
4123
4124         if (m->poisoned)
4125                 return -ESTALE;
4126
4127         /* If there's a non-trivial signature set, then add it in here */
4128         if (!isempty(m->root_container.signature)) {
4129                 r = message_append_field_signature(m, SD_BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL);
4130                 if (r < 0)
4131                         return r;
4132         }
4133
4134         if (m->n_fds > 0) {
4135                 r = message_append_field_uint32(m, SD_BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds);
4136                 if (r < 0)
4137                         return r;
4138         }
4139
4140         /* Add padding at the end of the fields part, since we know
4141          * the body needs to start at an 8 byte alignment. We made
4142          * sure we allocated enough space for this, so all we need to
4143          * do here is to zero it out. */
4144         l = BUS_MESSAGE_FIELDS_SIZE(m);
4145         a = ALIGN8(l) - l;
4146         if (a > 0)
4147                 memset((uint8_t*) BUS_MESSAGE_FIELDS(m) + l, 0, a);
4148
4149         /* If this is something we can send as memfd, then let's seal
4150         the memfd now. Note that we can send memfds as payload only
4151         for directed messages, and not for broadcasts. */
4152         if (m->destination && m->bus && m->bus->use_memfd) {
4153                 MESSAGE_FOREACH_PART(part, i, m)
4154                         if (part->memfd >= 0 && !part->sealed && (part->size > MEMFD_MIN_SIZE || m->bus->use_memfd < 0)) {
4155                                 bus_body_part_unmap(part);
4156
4157                                 if (ioctl(part->memfd, KDBUS_CMD_MEMFD_SEAL_SET, 1) >= 0)
4158                                         part->sealed = true;
4159                         }
4160         }
4161
4162         m->header->serial = serial;
4163         m->sealed = true;
4164
4165         return 0;
4166 }
4167
4168 int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
4169         if (!m)
4170                 return -EINVAL;
4171         if (!destination)
4172                 return -EINVAL;
4173         if (m->sealed)
4174                 return -EPERM;
4175         if (m->destination)
4176                 return -EEXIST;
4177
4178         return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
4179 }
4180
4181 int bus_message_dump(sd_bus_message *m, FILE *f, bool with_header) {
4182         const char *u = NULL, *uu = NULL, *s = NULL;
4183         char **cmdline = NULL;
4184         unsigned level = 1;
4185         int r;
4186         uid_t owner, audit_loginuid;
4187         uint32_t audit_sessionid;
4188
4189         assert(m);
4190
4191         if (!f)
4192                 f = stdout;
4193
4194         if (with_header) {
4195                 fprintf(f,
4196                         "Message %p\n"
4197                         "\tn_ref=%u\n"
4198                         "\tendian=%c\n"
4199                         "\ttype=%i\n"
4200                         "\tflags=%u\n"
4201                         "\tversion=%u\n"
4202                         "\tserial=%u\n"
4203                         "\tfields_size=%u\n"
4204                         "\tbody_size=%u\n"
4205                         "\tpath=%s\n"
4206                         "\tinterface=%s\n"
4207                         "\tmember=%s\n"
4208                         "\tdestination=%s\n"
4209                         "\tsender=%s\n"
4210                         "\tsignature=%s\n"
4211                         "\treply_serial=%u\n"
4212                         "\tsealed=%s\n"
4213                         "\tn_body_parts=%u\n",
4214                         m,
4215                         m->n_ref,
4216                         m->header->endian,
4217                         m->header->type,
4218                         m->header->flags,
4219                         m->header->version,
4220                         BUS_MESSAGE_SERIAL(m),
4221                         BUS_MESSAGE_FIELDS_SIZE(m),
4222                         BUS_MESSAGE_BODY_SIZE(m),
4223                         strna(m->path),
4224                         strna(m->interface),
4225                         strna(m->member),
4226                         strna(m->destination),
4227                         strna(m->sender),
4228                         strna(m->root_container.signature),
4229                         m->reply_serial,
4230                         yes_no(m->sealed),
4231                         m->n_body_parts);
4232
4233                 if (sd_bus_error_is_set(&m->error))
4234                         fprintf(f,
4235                                 "\terror.name=%s\n"
4236                                 "\terror.message=%s\n",
4237                                 strna(m->error.name),
4238                                 strna(m->error.message));
4239
4240                 if (m->pid != 0)
4241                         fprintf(f, "\tpid=%lu\n", (unsigned long) m->pid);
4242                 if (m->tid != 0)
4243                         fprintf(f, "\ttid=%lu\n", (unsigned long) m->tid);
4244                 if (m->uid_valid)
4245                         fprintf(f, "\tuid=%lu\n", (unsigned long) m->uid);
4246                 if (m->gid_valid)
4247                         fprintf(f, "\tgid=%lu\n", (unsigned long) m->gid);
4248                 if (m->pid_starttime != 0)
4249                         fprintf(f, "\tpid_starttime=%llu\n", (unsigned long long) m->pid_starttime);
4250                 if (m->monotonic != 0)
4251                         fprintf(f, "\tmonotonic=%llu\n", (unsigned long long) m->monotonic);
4252                 if (m->realtime != 0)
4253                         fprintf(f, "\trealtime=%llu\n", (unsigned long long) m->realtime);
4254                 if (m->exe)
4255                         fprintf(f, "\texe=[%s]\n", m->exe);
4256                 if (m->comm)
4257                         fprintf(f, "\tcomm=[%s]\n", m->comm);
4258                 if (m->tid_comm)
4259                         fprintf(f, "\ttid_comm=[%s]\n", m->tid_comm);
4260                 if (m->label)
4261                         fprintf(f, "\tlabel=[%s]\n", m->label);
4262                 if (m->cgroup)
4263                         fprintf(f, "\tcgroup=[%s]\n", m->cgroup);
4264
4265                 sd_bus_message_get_unit(m, &u);
4266                 if (u)
4267                         fprintf(f, "\tunit=[%s]\n", u);
4268                 sd_bus_message_get_user_unit(m, &uu);
4269                 if (uu)
4270                         fprintf(f, "\tuser_unit=[%s]\n", uu);
4271                 sd_bus_message_get_session(m, &s);
4272                 if (s)
4273                         fprintf(f, "\tsession=[%s]\n", s);
4274                 if (sd_bus_message_get_owner_uid(m, &owner) >= 0)
4275                         fprintf(f, "\towner_uid=%lu\n", (unsigned long) owner);
4276                 if (sd_bus_message_get_audit_loginuid(m, &audit_loginuid) >= 0)
4277                         fprintf(f, "\taudit_loginuid=%lu\n", (unsigned long) audit_loginuid);
4278                 if (sd_bus_message_get_audit_sessionid(m, &audit_sessionid) >= 0)
4279                         fprintf(f, "\taudit_sessionid=%lu\n", (unsigned long) audit_sessionid);
4280
4281                 r = sd_bus_message_has_effective_cap(m, 5);
4282                 if (r >= 0)
4283                         fprintf(f, "\tCAP_KILL=%s\n", yes_no(r));
4284
4285                 if (sd_bus_message_get_cmdline(m, &cmdline) >= 0) {
4286                         char **c;
4287
4288                         fputs("\tcmdline=[", f);
4289                         STRV_FOREACH(c, cmdline) {
4290                                 if (c != cmdline)
4291                                         fputc(' ', f);
4292
4293                                 fputs(*c, f);
4294                         }
4295
4296                         fputs("]\n", f);
4297                 }
4298         }
4299
4300         r = sd_bus_message_rewind(m, true);
4301         if (r < 0) {
4302                 log_error("Failed to rewind: %s", strerror(-r));
4303                 return r;
4304         }
4305
4306         fprintf(f, "BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
4307
4308         for(;;) {
4309                 _cleanup_free_ char *prefix = NULL;
4310                 const char *contents = NULL;
4311                 char type;
4312                 union {
4313                         uint8_t u8;
4314                         uint16_t u16;
4315                         int16_t s16;
4316                         uint32_t u32;
4317                         int32_t s32;
4318                         uint64_t u64;
4319                         int64_t s64;
4320                         double d64;
4321                         const char *string;
4322                         int i;
4323                 } basic;
4324
4325                 r = sd_bus_message_peek_type(m, &type, &contents);
4326                 if (r < 0) {
4327                         log_error("Failed to peek type: %s", strerror(-r));
4328                         return r;
4329                 }
4330                 if (r == 0) {
4331                         if (level <= 1)
4332                                 break;
4333
4334                         r = sd_bus_message_exit_container(m);
4335                         if (r < 0) {
4336                                 log_error("Failed to exit container: %s", strerror(-r));
4337                                 return r;
4338                         }
4339
4340                         level--;
4341
4342                         prefix = strrep("\t", level);
4343                         if (!prefix)
4344                                 return log_oom();
4345
4346                         if (type == SD_BUS_TYPE_ARRAY)
4347                                 fprintf(f, "%s} END_ARRAY \n", prefix);
4348                         else if (type == SD_BUS_TYPE_VARIANT)
4349                                 fprintf(f, "%s} END_VARIANT\n", prefix);
4350                         else if (type == SD_BUS_TYPE_STRUCT)
4351                                 fprintf(f, "%s} END_STRUCT\n", prefix);
4352                         else if (type == SD_BUS_TYPE_DICT_ENTRY)
4353                                 fprintf(f, "%s} END_DICT_ENTRY\n", prefix);
4354
4355                         continue;
4356                 }
4357
4358                 prefix = strrep("\t", level);
4359                 if (!prefix)
4360                         return log_oom();
4361
4362                 if (bus_type_is_container(type) > 0) {
4363                         r = sd_bus_message_enter_container(m, type, contents);
4364                         if (r < 0) {
4365                                 log_error("Failed to enter container: %s", strerror(-r));
4366                                 return r;
4367                         }
4368
4369                         if (type == SD_BUS_TYPE_ARRAY)
4370                                 fprintf(f, "%sBEGIN_ARRAY \"%s\" {\n", prefix, contents);
4371                         else if (type == SD_BUS_TYPE_VARIANT)
4372                                 fprintf(f, "%sBEGIN_VARIANT \"%s\" {\n", prefix, contents);
4373                         else if (type == SD_BUS_TYPE_STRUCT)
4374                                 fprintf(f, "%sBEGIN_STRUCT \"%s\" {\n", prefix, contents);
4375                         else if (type == SD_BUS_TYPE_DICT_ENTRY)
4376                                 fprintf(f, "%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents);
4377
4378                         level ++;
4379
4380                         continue;
4381                 }
4382
4383                 r = sd_bus_message_read_basic(m, type, &basic);
4384                 if (r < 0) {
4385                         log_error("Failed to get basic: %s", strerror(-r));
4386                         return r;
4387                 }
4388
4389                 assert(r > 0);
4390
4391                 switch (type) {
4392
4393                 case SD_BUS_TYPE_BYTE:
4394                         fprintf(f, "%sBYTE: %u\n", prefix, basic.u8);
4395                         break;
4396
4397                 case SD_BUS_TYPE_BOOLEAN:
4398                         fprintf(f, "%sBOOLEAN: %s\n", prefix, yes_no(basic.i));
4399                         break;
4400
4401                 case SD_BUS_TYPE_INT16:
4402                         fprintf(f, "%sINT16: %i\n", prefix, basic.s16);
4403                         break;
4404
4405                 case SD_BUS_TYPE_UINT16:
4406                         fprintf(f, "%sUINT16: %u\n", prefix, basic.u16);
4407                         break;
4408
4409                 case SD_BUS_TYPE_INT32:
4410                         fprintf(f, "%sINT32: %i\n", prefix, basic.s32);
4411                         break;
4412
4413                 case SD_BUS_TYPE_UINT32:
4414                         fprintf(f, "%sUINT32: %u\n", prefix, basic.u32);
4415                         break;
4416
4417                 case SD_BUS_TYPE_INT64:
4418                         fprintf(f, "%sINT64: %lli\n", prefix, (long long) basic.s64);
4419                         break;
4420
4421                 case SD_BUS_TYPE_UINT64:
4422                         fprintf(f, "%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64);
4423                         break;
4424
4425                 case SD_BUS_TYPE_DOUBLE:
4426                         fprintf(f, "%sDOUBLE: %g\n", prefix, basic.d64);
4427                         break;
4428
4429                 case SD_BUS_TYPE_STRING:
4430                         fprintf(f, "%sSTRING: \"%s\"\n", prefix, basic.string);
4431                         break;
4432
4433                 case SD_BUS_TYPE_OBJECT_PATH:
4434                         fprintf(f, "%sOBJECT_PATH: \"%s\"\n", prefix, basic.string);
4435                         break;
4436
4437                 case SD_BUS_TYPE_SIGNATURE:
4438                         fprintf(f, "%sSIGNATURE: \"%s\"\n", prefix, basic.string);
4439                         break;
4440
4441                 case SD_BUS_TYPE_UNIX_FD:
4442                         fprintf(f, "%sUNIX_FD: %i\n", prefix, basic.i);
4443                         break;
4444
4445                 default:
4446                         assert_not_reached("Unknown basic type.");
4447                 }
4448         }
4449
4450         fprintf(f, "} END_MESSAGE\n");
4451         return 0;
4452 }
4453
4454 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
4455         size_t total;
4456         void *p, *e;
4457         unsigned i;
4458         struct bus_body_part *part;
4459
4460         assert(m);
4461         assert(buffer);
4462         assert(sz);
4463
4464         total = BUS_MESSAGE_SIZE(m);
4465
4466         p = malloc(total);
4467         if (!p)
4468                 return -ENOMEM;
4469
4470         e = mempcpy(p, m->header, BUS_MESSAGE_BODY_BEGIN(m));
4471         MESSAGE_FOREACH_PART(part, i, m)
4472                 e = mempcpy(e, part->data, part->size);
4473
4474         assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p));
4475
4476         *buffer = p;
4477         *sz = total;
4478
4479         return 0;
4480 }
4481
4482 int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
4483         int r;
4484
4485         assert(m);
4486         assert(l);
4487
4488         r = sd_bus_message_enter_container(m, 'a', "s");
4489         if (r <= 0)
4490                 return r;
4491
4492         for (;;) {
4493                 const char *s;
4494
4495                 r = sd_bus_message_read_basic(m, 's', &s);
4496                 if (r < 0)
4497                         return r;
4498                 if (r == 0)
4499                         break;
4500
4501                 r = strv_extend(l, s);
4502                 if (r < 0)
4503                         return r;
4504         }
4505
4506         r = sd_bus_message_exit_container(m);
4507         if (r < 0)
4508                 return r;
4509
4510         return 0;
4511 }
4512
4513 int sd_bus_message_read_strv(sd_bus_message *m, char ***l) {
4514         char **strv = NULL;
4515         int r;
4516
4517         assert_return(m, -EINVAL);
4518         assert_return(m->sealed, -EPERM);
4519         assert_return(l, -EINVAL);
4520
4521         r = bus_message_read_strv_extend(m, &strv);
4522         if (r <= 0) {
4523                 strv_free(strv);
4524                 return r;
4525         }
4526
4527         *l = strv;
4528         return 1;
4529 }
4530
4531 const char* bus_message_get_arg(sd_bus_message *m, unsigned i) {
4532         int r;
4533         const char *t = NULL;
4534         unsigned j;
4535
4536         assert(m);
4537
4538         r = sd_bus_message_rewind(m, true);
4539         if (r < 0)
4540                 return NULL;
4541
4542         for (j = 0; j <= i; j++) {
4543                 char type;
4544
4545                 r = sd_bus_message_peek_type(m, &type, NULL);
4546                 if (r < 0)
4547                         return NULL;
4548
4549                 if (type != SD_BUS_TYPE_STRING &&
4550                     type != SD_BUS_TYPE_OBJECT_PATH &&
4551                     type != SD_BUS_TYPE_SIGNATURE)
4552                         return NULL;
4553
4554                 r = sd_bus_message_read_basic(m, type, &t);
4555                 if (r < 0)
4556                         return NULL;
4557         }
4558
4559         return t;
4560 }
4561
4562 bool bus_header_is_complete(struct bus_header *h, size_t size) {
4563         size_t full;
4564
4565         assert(h);
4566         assert(size);
4567
4568         if (size < sizeof(struct bus_header))
4569                 return false;
4570
4571         full = sizeof(struct bus_header) +
4572                 (h->endian == SD_BUS_NATIVE_ENDIAN ? h->fields_size : bswap_32(h->fields_size));
4573
4574         return size >= full;
4575 }
4576
4577 int bus_header_message_size(struct bus_header *h, size_t *sum) {
4578         size_t fs, bs;
4579
4580         assert(h);
4581         assert(sum);
4582
4583         if (h->endian == SD_BUS_NATIVE_ENDIAN) {
4584                 fs = h->fields_size;
4585                 bs = h->body_size;
4586         } else if (h->endian == SD_BUS_REVERSE_ENDIAN) {
4587                 fs = bswap_32(h->fields_size);
4588                 bs = bswap_32(h->body_size);
4589         } else
4590                 return -EBADMSG;
4591
4592         *sum = sizeof(struct bus_header) + ALIGN8(fs) + bs;
4593         return 0;
4594 }
4595
4596 int sd_bus_message_get_errno(sd_bus_message *m) {
4597         assert_return(m, -EINVAL);
4598
4599         if (m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
4600                 return 0;
4601
4602         return sd_bus_error_get_errno(&m->error);
4603 }
4604
4605 const char* sd_bus_message_get_signature(sd_bus_message *m, int complete) {
4606         struct bus_container *c;
4607
4608         if (!m)
4609                 return NULL;
4610
4611         c = complete ? &m->root_container : message_get_container(m);
4612         return c->signature ?: "";
4613 }
4614
4615 int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all) {
4616         bool done_something = false;
4617         int r;
4618
4619         assert_return(m, -EINVAL);
4620         assert_return(source, -EINVAL);
4621         assert_return(!m->sealed, -EPERM);
4622         assert_return(source->sealed, -EPERM);
4623
4624         do {
4625                 const char *contents;
4626                 char type;
4627                 union {
4628                         uint8_t u8;
4629                         uint16_t u16;
4630                         int16_t s16;
4631                         uint32_t u32;
4632                         int32_t s32;
4633                         uint64_t u64;
4634                         int64_t s64;
4635                         double d64;
4636                         const char *string;
4637                         int i;
4638                 } basic;
4639
4640                 r = sd_bus_message_peek_type(source, &type, &contents);
4641                 if (r < 0)
4642                         return r;
4643                 if (r == 0)
4644                         break;
4645
4646                 done_something = true;
4647
4648                 if (bus_type_is_container(type) > 0) {
4649
4650                         r = sd_bus_message_enter_container(source, type, contents);
4651                         if (r < 0)
4652                                 return r;
4653
4654                         r = sd_bus_message_open_container(m, type, contents);
4655                         if (r < 0)
4656                                 return r;
4657
4658                         r = sd_bus_message_copy(m, source, true);
4659                         if (r < 0)
4660                                 return r;
4661
4662                         r = sd_bus_message_close_container(m);
4663                         if (r < 0)
4664                                 return r;
4665
4666                         r = sd_bus_message_exit_container(source);
4667                         if (r < 0)
4668                                 return r;
4669
4670                         continue;
4671                 }
4672
4673                 r = sd_bus_message_read_basic(source, type, &basic);
4674                 if (r < 0)
4675                         return r;
4676
4677                 assert(r > 0);
4678
4679                 if (type == SD_BUS_TYPE_OBJECT_PATH ||
4680                     type == SD_BUS_TYPE_SIGNATURE ||
4681                     type == SD_BUS_TYPE_STRING)
4682                         r = sd_bus_message_append_basic(m, type, basic.string);
4683                 else
4684                         r = sd_bus_message_append_basic(m, type, &basic);
4685
4686                 if (r < 0)
4687                         return r;
4688
4689         } while (all);
4690
4691         return done_something;
4692 }
4693
4694 int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents) {
4695         const char *c;
4696         char t;
4697         int r;
4698
4699         assert_return(m, -EINVAL);
4700         assert_return(m->sealed, -EPERM);
4701         assert_return(!type || bus_type_is_valid(type), -EINVAL);
4702         assert_return(!contents || signature_is_valid(contents, true), -EINVAL);
4703         assert_return(type || contents, -EINVAL);
4704         assert_return(!contents || !type || bus_type_is_container(type), -EINVAL);
4705
4706         r = sd_bus_message_peek_type(m, &t, &c);
4707         if (r <= 0)
4708                 return r;
4709
4710         if (type != 0 && type != t)
4711                 return 0;
4712
4713         if (contents && !streq_ptr(contents, c))
4714                 return 0;
4715
4716         return 1;
4717 }