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
  25 #include "util.h"
  26 #include "utf8.h"
  27 #include "strv.h"
  28 #include "time-util.h"
  29 #include "cgroup-util.h"
  30
  31 #include "sd-bus.h"
  32 #include "bus-message.h"
  33 #include "bus-internal.h"
  34 #include "bus-type.h"
  35 #include "bus-signature.h"
  36
  37 static int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored);
  38
  39 static void reset_containers(sd_bus_message *m) {
  40         unsigned i;
  41
  42         assert(m);
  43
  44         for (i = 0; i < m->n_containers; i++)
  45                 free(m->containers[i].signature);
  46
  47         free(m->containers);
  48         m->containers = NULL;
  49
  50         m->n_containers = 0;
  51         m->root_container.index = 0;
  52 }
  53
  54 static void message_free(sd_bus_message *m) {
  55         assert(m);
  56
  57         if (m->free_header)
  58                 free(m->header);
  59
  60         if (m->free_fields)
  61                 free(m->fields);
  62
  63         if (m->free_body)
  64                 free(m->body);
  65
  66         if (m->free_kdbus)
  67                 free(m->kdbus);
  68
  69         if (m->free_fds) {
  70                 close_many(m->fds, m->n_fds);
  71                 free(m->fds);
  72         }
  73
  74         free(m->cmdline_array);
  75
  76         reset_containers(m);
  77         free(m->root_container.signature);
  78
  79         free(m->peeked_signature);
  80
  81         free(m->unit);
  82         free(m->user_unit);
  83         free(m->session);
  84         free(m);
  85 }
  86
  87 static void* buffer_extend(void **p, uint32_t *sz, size_t align, size_t extend) {
  88         size_t start, n;
  89         void *k;
  90
  91         assert(p);
  92         assert(sz);
  93         assert(align > 0);
  94
  95         start = ALIGN_TO((size_t) *sz, align);
  96         n = start + extend;
  97
  98         if (n == *sz)
  99                 return (uint8_t*) *p + start;
 100
 101         if (n > (size_t) ((uint32_t) -1))
 102                 return NULL;
 103
 104         k = realloc(*p, n);
 105         if (!k)
 106                 return NULL;
 107
 108         /* Zero out padding */
 109         if (start > *sz)
 110                 memset((uint8_t*) k + *sz, 0, start - *sz);
 111
 112         *p = k;
 113         *sz = n;
 114
 115         return (uint8_t*) k + start;
 116 }
 117
 118 static void *message_extend_fields(sd_bus_message *m, size_t align, size_t sz) {
 119         void *p, *o;
 120
 121         assert(m);
 122
 123         o = m->fields;
 124         p = buffer_extend(&m->fields, &m->header->fields_size, align, sz);
 125         if (!p)
 126                 return NULL;
 127
 128         if (o != m->fields) {
 129                 /* Adjust quick access pointers */
 130
 131                 if (m->path)
 132                         m->path = (const char*) m->fields + (m->path - (const char*) o);
 133                 if (m->interface)
 134                         m->interface = (const char*) m->fields + (m->interface - (const char*) o);
 135                 if (m->member)
 136                         m->member = (const char*) m->fields + (m->member - (const char*) o);
 137                 if (m->destination)
 138                         m->destination = (const char*) m->fields + (m->destination - (const char*) o);
 139                 if (m->sender)
 140                         m->sender = (const char*) m->fields + (m->sender - (const char*) o);
 141                 if (m->error.name)
 142                         m->error.name = (const char*) m->fields + (m->error.name - (const char*) o);
 143         }
 144
 145         m->free_fields = true;
 146
 147         return p;
 148 }
 149
 150 static int message_append_field_string(
 151                 sd_bus_message *m,
 152                 uint8_t h,
 153                 char type,
 154                 const char *s,
 155                 const char **ret) {
 156
 157         size_t l;
 158         uint8_t *p;
 159
 160         assert(m);
 161
 162         l = strlen(s);
 163         if (l > (size_t) (uint32_t) -1)
 164                 return -EINVAL;
 165
 166         /* field id byte + signature length + signature 's' + NUL + string length + string + NUL */
 167         p = message_extend_fields(m, 8, 4 + 4 + l + 1);
 168         if (!p)
 169                 return -ENOMEM;
 170
 171         p[0] = h;
 172         p[1] = 1;
 173         p[2] = type;
 174         p[3] = 0;
 175
 176         ((uint32_t*) p)[1] = l;
 177         memcpy(p + 8, s, l + 1);
 178
 179         if (ret)
 180                 *ret = (const char*) p + 8;
 181
 182         return 0;
 183 }
 184
 185 static int message_append_field_signature(
 186                 sd_bus_message *m,
 187                 uint8_t h,
 188                 const char *s,
 189                 const char **ret) {
 190
 191         size_t l;
 192         uint8_t *p;
 193
 194         assert(m);
 195
 196         l = strlen(s);
 197         if (l > 255)
 198                 return -EINVAL;
 199
 200         /* field id byte + signature length + signature 'g' + NUL + string length + string + NUL */
 201         p = message_extend_fields(m, 8, 4 + 1 + l + 1);
 202         if (!p)
 203                 return -ENOMEM;
 204
 205         p[0] = h;
 206         p[1] = 1;
 207         p[2] = SD_BUS_TYPE_SIGNATURE;
 208         p[3] = 0;
 209         p[4] = l;
 210         memcpy(p + 5, s, l + 1);
 211
 212         if (ret)
 213                 *ret = (const char*) p + 5;
 214
 215         return 0;
 216 }
 217
 218 static int message_append_field_uint32(sd_bus_message *m, uint8_t h, uint32_t x) {
 219         uint8_t *p;
 220
 221         assert(m);
 222
 223         /* field id byte + signature length + signature 'u' + NUL + value */
 224         p = message_extend_fields(m, 8, 4 + 4);
 225         if (!p)
 226                 return -ENOMEM;
 227
 228         p[0] = h;
 229         p[1] = 1;
 230         p[2] = SD_BUS_TYPE_UINT32;
 231         p[3] = 0;
 232
 233         ((uint32_t*) p)[1] = x;
 234
 235         return 0;
 236 }
 237
 238 int bus_message_from_header(
 239                 void *buffer,
 240                 size_t length,
 241                 int *fds,
 242                 unsigned n_fds,
 243                 const struct ucred *ucred,
 244                 const char *label,
 245                 size_t extra,
 246                 sd_bus_message **ret) {
 247
 248         sd_bus_message *m;
 249         struct bus_header *h;
 250         size_t a, label_sz;
 251
 252         assert(buffer || length <= 0);
 253         assert(fds || n_fds <= 0);
 254         assert(ret);
 255
 256         if (length < sizeof(struct bus_header))
 257                 return -EBADMSG;
 258
 259         h = buffer;
 260         if (h->version != 1)
 261                 return -EBADMSG;
 262
 263         if (h->serial == 0)
 264                 return -EBADMSG;
 265
 266         if (h->type == _SD_BUS_MESSAGE_TYPE_INVALID)
 267                 return -EBADMSG;
 268
 269         if (h->endian != SD_BUS_LITTLE_ENDIAN &&
 270             h->endian != SD_BUS_BIG_ENDIAN)
 271                 return -EBADMSG;
 272
 273         a = ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
 274
 275         if (label) {
 276                 label_sz = strlen(label);
 277                 a += label_sz + 1;
 278         }
 279
 280         m = malloc0(a);
 281         if (!m)
 282                 return -ENOMEM;
 283
 284         m->n_ref = 1;
 285         m->sealed = true;
 286         m->header = h;
 287         m->fds = fds;
 288         m->n_fds = n_fds;
 289
 290         if (ucred) {
 291                 m->uid = ucred->uid;
 292                 m->pid = ucred->pid;
 293                 m->gid = ucred->gid;
 294                 m->uid_valid = m->gid_valid = true;
 295         }
 296
 297         if (label) {
 298                 m->label = (char*) m + ALIGN(sizeof(sd_bus_message)) + ALIGN(extra);
 299                 memcpy(m->label, label, label_sz + 1);
 300         }
 301
 302         *ret = m;
 303         return 0;
 304 }
 305
 306 int bus_message_from_malloc(
 307                 void *buffer,
 308                 size_t length,
 309                 int *fds,
 310                 unsigned n_fds,
 311                 const struct ucred *ucred,
 312                 const char *label,
 313                 sd_bus_message **ret) {
 314
 315         sd_bus_message *m;
 316         int r;
 317
 318         r = bus_message_from_header(buffer, length, fds, n_fds, ucred, label, 0, &m);
 319         if (r < 0)
 320                 return r;
 321
 322         if (length != BUS_MESSAGE_SIZE(m)) {
 323                 r = -EBADMSG;
 324                 goto fail;
 325         }
 326
 327         m->fields = (uint8_t*) buffer + sizeof(struct bus_header);
 328         m->body = (uint8_t*) buffer + sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 329
 330         m->n_iovec = 1;
 331         m->iovec[0].iov_base = buffer;
 332         m->iovec[0].iov_len = length;
 333
 334         r = bus_message_parse_fields(m);
 335         if (r < 0)
 336                 goto fail;
 337
 338         /* We take possession of the memory and fds now */
 339         m->free_header = true;
 340         m->free_fds = true;
 341
 342         *ret = m;
 343         return 0;
 344
 345 fail:
 346         message_free(m);
 347         return r;
 348 }
 349
 350 static sd_bus_message *message_new(sd_bus *bus, uint8_t type) {
 351         sd_bus_message *m;
 352
 353         m = malloc0(ALIGN(sizeof(sd_bus_message)) + sizeof(struct bus_header));
 354         if (!m)
 355                 return NULL;
 356
 357         m->n_ref = 1;
 358         m->header = (struct bus_header*) ((uint8_t*) m + ALIGN(sizeof(struct sd_bus_message)));
 359         m->header->endian = SD_BUS_NATIVE_ENDIAN;
 360         m->header->type = type;
 361         m->header->version = bus ? bus->message_version : 1;
 362         m->allow_fds = !bus || bus->can_fds || (bus->state != BUS_HELLO && bus->state != BUS_RUNNING);
 363
 364         return m;
 365 }
 366
 367 int sd_bus_message_new_signal(
 368                 sd_bus *bus,
 369                 const char *path,
 370                 const char *interface,
 371                 const char *member,
 372                 sd_bus_message **m) {
 373
 374         sd_bus_message *t;
 375         int r;
 376
 377         if (!path)
 378                 return -EINVAL;
 379         if (!interface)
 380                 return -EINVAL;
 381         if (!member)
 382                 return -EINVAL;
 383         if (!m)
 384                 return -EINVAL;
 385         if (bus && bus->state == BUS_UNSET)
 386                 return -ENOTCONN;
 387
 388         t = message_new(bus, SD_BUS_MESSAGE_TYPE_SIGNAL);
 389         if (!t)
 390                 return -ENOMEM;
 391
 392         t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 393
 394         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
 395         if (r < 0)
 396                 goto fail;
 397         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
 398         if (r < 0)
 399                 goto fail;
 400         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
 401         if (r < 0)
 402                 goto fail;
 403
 404         *m = t;
 405         return 0;
 406
 407 fail:
 408         sd_bus_message_unref(t);
 409         return r;
 410 }
 411
 412 int sd_bus_message_new_method_call(
 413                 sd_bus *bus,
 414                 const char *destination,
 415                 const char *path,
 416                 const char *interface,
 417                 const char *member,
 418                 sd_bus_message **m) {
 419
 420         sd_bus_message *t;
 421         int r;
 422
 423         if (!path)
 424                 return -EINVAL;
 425         if (!member)
 426                 return -EINVAL;
 427         if (!m)
 428                 return -EINVAL;
 429         if (bus && bus->state == BUS_UNSET)
 430                 return -ENOTCONN;
 431
 432         t = message_new(bus, SD_BUS_MESSAGE_TYPE_METHOD_CALL);
 433         if (!t)
 434                 return -ENOMEM;
 435
 436         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_PATH, SD_BUS_TYPE_OBJECT_PATH, path, &t->path);
 437         if (r < 0)
 438                 goto fail;
 439         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_MEMBER, SD_BUS_TYPE_STRING, member, &t->member);
 440         if (r < 0)
 441                 goto fail;
 442
 443         if (interface) {
 444                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_INTERFACE, SD_BUS_TYPE_STRING, interface, &t->interface);
 445                 if (r < 0)
 446                         goto fail;
 447         }
 448
 449         if (destination) {
 450                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &t->destination);
 451                 if (r < 0)
 452                         goto fail;
 453         }
 454
 455         *m = t;
 456         return 0;
 457
 458 fail:
 459         message_free(t);
 460         return r;
 461 }
 462
 463 static int message_new_reply(
 464                 sd_bus *bus,
 465                 sd_bus_message *call,
 466                 uint8_t type,
 467                 sd_bus_message **m) {
 468
 469         sd_bus_message *t;
 470         int r;
 471
 472         if (!call)
 473                 return -EINVAL;
 474         if (!call->sealed)
 475                 return -EPERM;
 476         if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
 477                 return -EINVAL;
 478         if (!m)
 479                 return -EINVAL;
 480         if (bus && bus->state == BUS_UNSET)
 481                 return -ENOTCONN;
 482
 483         t = message_new(bus, type);
 484         if (!t)
 485                 return -ENOMEM;
 486
 487         t->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 488         t->reply_serial = BUS_MESSAGE_SERIAL(call);
 489
 490         r = message_append_field_uint32(t, SD_BUS_MESSAGE_HEADER_REPLY_SERIAL, t->reply_serial);
 491         if (r < 0)
 492                 goto fail;
 493
 494         if (call->sender) {
 495                 r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, call->sender, &t->sender);
 496                 if (r < 0)
 497                         goto fail;
 498         }
 499
 500         t->dont_send = !!(call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED);
 501
 502         *m = t;
 503         return 0;
 504
 505 fail:
 506         message_free(t);
 507         return r;
 508 }
 509
 510 int sd_bus_message_new_method_return(
 511                 sd_bus *bus,
 512                 sd_bus_message *call,
 513                 sd_bus_message **m) {
 514
 515         return message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_RETURN, m);
 516 }
 517
 518 int sd_bus_message_new_method_error(
 519                 sd_bus *bus,
 520                 sd_bus_message *call,
 521                 const sd_bus_error *e,
 522                 sd_bus_message **m) {
 523
 524         sd_bus_message *t;
 525         int r;
 526
 527         if (!sd_bus_error_is_set(e))
 528                 return -EINVAL;
 529         if (!m)
 530                 return -EINVAL;
 531
 532         r = message_new_reply(bus, call, SD_BUS_MESSAGE_TYPE_METHOD_ERROR, &t);
 533         if (r < 0)
 534                 return r;
 535
 536         r = message_append_field_string(t, SD_BUS_MESSAGE_HEADER_ERROR_NAME, SD_BUS_TYPE_STRING, e->name, &t->error.name);
 537         if (r < 0)
 538                 goto fail;
 539
 540         if (e->message) {
 541                 r = message_append_basic(t, SD_BUS_TYPE_STRING, e->message, (const void**) &t->error.message);
 542                 if (r < 0)
 543                         goto fail;
 544         }
 545
 546         *m = t;
 547         return 0;
 548
 549 fail:
 550         message_free(t);
 551         return r;
 552 }
 553
 554 sd_bus_message* sd_bus_message_ref(sd_bus_message *m) {
 555         if (!m)
 556                 return NULL;
 557
 558         assert(m->n_ref > 0);
 559         m->n_ref++;
 560
 561         return m;
 562 }
 563
 564 sd_bus_message* sd_bus_message_unref(sd_bus_message *m) {
 565         if (!m)
 566                 return NULL;
 567
 568         assert(m->n_ref > 0);
 569         m->n_ref--;
 570
 571         if (m->n_ref <= 0)
 572                 message_free(m);
 573
 574         return NULL;
 575 }
 576
 577 int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type) {
 578         if (!m)
 579                 return -EINVAL;
 580         if (!type)
 581                 return -EINVAL;
 582
 583         *type = m->header->type;
 584         return 0;
 585 }
 586
 587 int sd_bus_message_get_serial(sd_bus_message *m, uint64_t *serial) {
 588         if (!m)
 589                 return -EINVAL;
 590         if (!serial)
 591                 return -EINVAL;
 592         if (m->header->serial == 0)
 593                 return -ENOENT;
 594
 595         *serial = BUS_MESSAGE_SERIAL(m);
 596         return 0;
 597 }
 598
 599 int sd_bus_message_get_reply_serial(sd_bus_message *m, uint64_t *serial) {
 600         if (!m)
 601                 return -EINVAL;
 602         if (!serial)
 603                 return -EINVAL;
 604         if (m->reply_serial == 0)
 605                 return -ENOENT;
 606
 607         *serial = m->reply_serial;
 608         return 0;
 609 }
 610
 611 int sd_bus_message_get_no_reply(sd_bus_message *m) {
 612         if (!m)
 613                 return -EINVAL;
 614
 615         return m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL ? !!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED) : 0;
 616 }
 617
 618 const char *sd_bus_message_get_path(sd_bus_message *m) {
 619         if (!m)
 620                 return NULL;
 621
 622         return m->path;
 623 }
 624
 625 const char *sd_bus_message_get_interface(sd_bus_message *m) {
 626         if (!m)
 627                 return NULL;
 628
 629         return m->interface;
 630 }
 631
 632 const char *sd_bus_message_get_member(sd_bus_message *m) {
 633         if (!m)
 634                 return NULL;
 635
 636         return m->member;
 637 }
 638 const char *sd_bus_message_get_destination(sd_bus_message *m) {
 639         if (!m)
 640                 return NULL;
 641
 642         return m->destination;
 643 }
 644
 645 const char *sd_bus_message_get_sender(sd_bus_message *m) {
 646         if (!m)
 647                 return NULL;
 648
 649         return m->sender;
 650 }
 651
 652 const sd_bus_error *sd_bus_message_get_error(sd_bus_message *m) {
 653         if (!m)
 654                 return NULL;
 655
 656         if (!sd_bus_error_is_set(&m->error))
 657                 return NULL;
 658
 659         return &m->error;
 660 }
 661
 662 int sd_bus_message_get_uid(sd_bus_message *m, uid_t *uid) {
 663         if (!m)
 664                 return -EINVAL;
 665         if (!uid)
 666                 return -EINVAL;
 667         if (!m->uid_valid)
 668                 return -ESRCH;
 669
 670         *uid = m->uid;
 671         return 0;
 672 }
 673
 674 int sd_bus_message_get_gid(sd_bus_message *m, gid_t *gid) {
 675         if (!m)
 676                 return -EINVAL;
 677         if (!gid)
 678                 return -EINVAL;
 679         if (!m->gid_valid)
 680                 return -ESRCH;
 681
 682         *gid = m->gid;
 683         return 0;
 684 }
 685
 686 int sd_bus_message_get_pid(sd_bus_message *m, pid_t *pid) {
 687         if (!m)
 688                 return -EINVAL;
 689         if (!pid)
 690                 return -EINVAL;
 691         if (m->pid <= 0)
 692                 return -ESRCH;
 693
 694         *pid = m->pid;
 695         return 0;
 696 }
 697
 698 int sd_bus_message_get_tid(sd_bus_message *m, pid_t *tid) {
 699         if (!m)
 700                 return -EINVAL;
 701         if (!tid)
 702                 return -EINVAL;
 703         if (m->tid <= 0)
 704                 return -ESRCH;
 705
 706         *tid = m->tid;
 707         return 0;
 708 }
 709
 710 int sd_bus_message_get_pid_starttime(sd_bus_message *m, uint64_t *usec) {
 711         if (!m)
 712                 return -EINVAL;
 713         if (!usec)
 714                 return -EINVAL;
 715         if (m->pid_starttime <= 0)
 716                 return -ESRCH;
 717
 718         *usec = m->pid_starttime;
 719         return 0;
 720 }
 721
 722 int sd_bus_message_get_selinux_context(sd_bus_message *m, const char **ret) {
 723         if (!m)
 724                 return -EINVAL;
 725         if (!m->label)
 726                 return -ESRCH;
 727
 728         *ret = m->label;
 729         return 0;
 730 }
 731
 732 int sd_bus_message_get_monotonic_timestamp(sd_bus_message *m, uint64_t *usec) {
 733         if (!m)
 734                 return -EINVAL;
 735         if (!usec)
 736                 return -EINVAL;
 737         if (m->monotonic <= 0)
 738                 return -ESRCH;
 739
 740         *usec = m->monotonic;
 741         return 0;
 742 }
 743
 744 int sd_bus_message_get_realtime_timestamp(sd_bus_message *m, uint64_t *usec) {
 745         if (!m)
 746                 return -EINVAL;
 747         if (!usec)
 748                 return -EINVAL;
 749         if (m->realtime <= 0)
 750                 return -ESRCH;
 751
 752         *usec = m->realtime;
 753         return 0;
 754 }
 755
 756 int sd_bus_message_get_comm(sd_bus_message *m, const char **ret) {
 757         if (!m)
 758                 return -EINVAL;
 759         if (!ret)
 760                 return -EINVAL;
 761         if (!m->comm)
 762                 return -ESRCH;
 763
 764         *ret = m->comm;
 765         return 0;
 766 }
 767
 768 int sd_bus_message_get_tid_comm(sd_bus_message *m, const char **ret) {
 769         if (!m)
 770                 return -EINVAL;
 771         if (!ret)
 772                 return -EINVAL;
 773         if (!m->tid_comm)
 774                 return -ESRCH;
 775
 776         *ret = m->tid_comm;
 777         return 0;
 778 }
 779
 780 int sd_bus_message_get_exe(sd_bus_message *m, const char **ret) {
 781         if (!m)
 782                 return -EINVAL;
 783         if (!ret)
 784                 return -EINVAL;
 785         if (!m->exe)
 786                 return -ESRCH;
 787
 788         *ret = m->exe;
 789         return 0;
 790 }
 791
 792 int sd_bus_message_get_cgroup(sd_bus_message *m, const char **ret) {
 793         if (!m)
 794                 return -EINVAL;
 795         if (!ret)
 796                 return -EINVAL;
 797         if (!m->cgroup)
 798                 return -ESRCH;
 799
 800         *ret = m->cgroup;
 801         return 0;
 802 }
 803
 804 int sd_bus_message_get_unit(sd_bus_message *m, const char **ret) {
 805         int r;
 806
 807         if (!m)
 808                 return -EINVAL;
 809         if (!ret)
 810                 return -EINVAL;
 811         if (!m->cgroup)
 812                 return -ESRCH;
 813
 814         if (!m->unit) {
 815                 r = cg_path_get_unit(m->cgroup, &m->unit);
 816                 if (r < 0)
 817                         return r;
 818         }
 819
 820         *ret = m->unit;
 821         return 0;
 822 }
 823
 824 int sd_bus_message_get_user_unit(sd_bus_message *m, const char **ret) {
 825         int r;
 826
 827         if (!m)
 828                 return -EINVAL;
 829         if (!ret)
 830                 return -EINVAL;
 831         if (!m->cgroup)
 832                 return -ESRCH;
 833
 834         if (!m->user_unit) {
 835                 r = cg_path_get_user_unit(m->cgroup, &m->user_unit);
 836                 if (r < 0)
 837                         return r;
 838         }
 839
 840         *ret = m->user_unit;
 841         return 0;
 842 }
 843
 844 int sd_bus_message_get_session(sd_bus_message *m, const char **ret) {
 845         int r;
 846
 847         if (!m)
 848                 return -EINVAL;
 849         if (!ret)
 850                 return -EINVAL;
 851         if (!m->cgroup)
 852                 return -ESRCH;
 853
 854         if (!m->session) {
 855                 r = cg_path_get_session(m->cgroup, &m->session);
 856                 if (r < 0)
 857                         return r;
 858         }
 859
 860         *ret = m->session;
 861         return 0;
 862 }
 863
 864 int sd_bus_message_get_cmdline(sd_bus_message *m, char ***cmdline) {
 865         size_t n, i;
 866         const char *p;
 867         bool first;
 868
 869         if (!m)
 870                 return -EINVAL;
 871
 872         if (!m->cmdline)
 873                 return -ENOENT;
 874
 875         for (p = m->cmdline, n = 0; p < m->cmdline + m->cmdline_length; p++)
 876                 if (*p == 0)
 877                         n++;
 878
 879         m->cmdline_array = new(char*, n + 1);
 880         if (!m->cmdline_array)
 881                 return -ENOMEM;
 882
 883         for (p = m->cmdline, i = 0, first = true; p < m->cmdline + m->cmdline_length; p++) {
 884                 if (first)
 885                         m->cmdline_array[i++] = (char*) p;
 886
 887                 first = *p == 0;
 888         }
 889
 890         m->cmdline_array[i] = NULL;
 891         *cmdline = m->cmdline_array;
 892
 893         return 0;
 894 }
 895
 896 int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member) {
 897         if (!m)
 898                 return -EINVAL;
 899
 900         if (m->header->type != SD_BUS_MESSAGE_TYPE_SIGNAL)
 901                 return 0;
 902
 903         if (interface && (!m->interface || !streq(m->interface, interface)))
 904                 return 0;
 905
 906         if (member &&  (!m->member || !streq(m->member, member)))
 907                 return 0;
 908
 909         return 1;
 910 }
 911
 912 int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member) {
 913         if (!m)
 914                 return -EINVAL;
 915
 916         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
 917                 return 0;
 918
 919         if (interface && (!m->interface || !streq(m->interface, interface)))
 920                 return 0;
 921
 922         if (member &&  (!m->member || !streq(m->member, member)))
 923                 return 0;
 924
 925         return 1;
 926 }
 927
 928 int sd_bus_message_is_method_error(sd_bus_message *m, const char *name) {
 929         if (!m)
 930                 return -EINVAL;
 931
 932         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
 933                 return 0;
 934
 935         if (name && (!m->error.name || !streq(m->error.name, name)))
 936                 return 0;
 937
 938         return 1;
 939 }
 940
 941 int sd_bus_message_set_no_reply(sd_bus_message *m, int b) {
 942         if (!m)
 943                 return -EINVAL;
 944         if (m->sealed)
 945                 return -EPERM;
 946         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
 947                 return -EPERM;
 948
 949         if (b)
 950                 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 951         else
 952                 m->header->flags &= ~SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
 953
 954         return 0;
 955 }
 956
 957 static struct bus_container *message_get_container(sd_bus_message *m) {
 958         assert(m);
 959
 960         if (m->n_containers == 0)
 961                 return &m->root_container;
 962
 963         assert(m->containers);
 964         return m->containers + m->n_containers - 1;
 965 }
 966
 967 static void *message_extend_body(sd_bus_message *m, size_t align, size_t sz) {
 968         void *p, *o;
 969         size_t added;
 970         struct bus_container *c;
 971
 972         assert(m);
 973         assert(align > 0);
 974
 975         o = m->body;
 976         added = m->header->body_size;
 977
 978         p = buffer_extend(&m->body, &m->header->body_size, align, sz);
 979         if (!p)
 980                 return NULL;
 981
 982         added = m->header->body_size - added;
 983
 984         for (c = m->containers; c < m->containers + m->n_containers; c++)
 985                 if (c->array_size) {
 986                         c->array_size = (uint32_t*) ((uint8_t*) m->body + ((uint8_t*) c->array_size - (uint8_t*) o));
 987                         *c->array_size += added;
 988                 }
 989
 990         if (o != m->body) {
 991                 if (m->error.message)
 992                         m->error.message = (const char*) m->body + (m->error.message - (const char*) o);
 993         }
 994
 995         m->free_body = true;
 996
 997         return p;
 998 }
 999
1000 int message_append_basic(sd_bus_message *m, char type, const void *p, const void **stored) {
1001         struct bus_container *c;
1002         ssize_t align, sz;
1003         uint32_t k;
1004         void *a;
1005         char *e = NULL;
1006         int fd = -1;
1007         uint32_t fdi = 0;
1008         int r;
1009
1010         if (!m)
1011                 return -EINVAL;
1012         if (!p)
1013                 return -EINVAL;
1014         if (m->sealed)
1015                 return -EPERM;
1016         if (!bus_type_is_basic(type))
1017                 return -EINVAL;
1018
1019         c = message_get_container(m);
1020
1021         if (c->signature && c->signature[c->index]) {
1022                 /* Container signature is already set */
1023
1024                 if (c->signature[c->index] != type)
1025                         return -ENXIO;
1026         } else {
1027                 /* Maybe we can append to the signature? But only if this is the top-level container*/
1028                 if (c->enclosing != 0)
1029                         return -ENXIO;
1030
1031                 e = strextend(&c->signature, CHAR_TO_STR(type), NULL);
1032                 if (!e)
1033                         return -ENOMEM;
1034         }
1035
1036         switch (type) {
1037
1038         case SD_BUS_TYPE_STRING:
1039         case SD_BUS_TYPE_OBJECT_PATH:
1040
1041                 align = 4;
1042                 sz = 4 + strlen(p) + 1;
1043                 break;
1044
1045         case SD_BUS_TYPE_SIGNATURE:
1046
1047                 align = 1;
1048                 sz = 1 + strlen(p) + 1;
1049                 break;
1050
1051         case SD_BUS_TYPE_BOOLEAN:
1052                 align = sz = 4;
1053
1054                 assert_cc(sizeof(int) == sizeof(uint32_t));
1055                 memcpy(&k, p, 4);
1056                 k = !!k;
1057                 p = &k;
1058                 break;
1059
1060         case SD_BUS_TYPE_UNIX_FD: {
1061                 int z, *f;
1062
1063                 if (!m->allow_fds) {
1064                         r = -ENOTSUP;
1065                         goto fail;
1066                 }
1067
1068                 align = sz = 4;
1069
1070                 z = *(int*) p;
1071                 if (z < 0) {
1072                         r = -EINVAL;
1073                         goto fail;
1074                 }
1075
1076                 fd = fcntl(z, F_DUPFD_CLOEXEC, 3);
1077                 if (fd < 0) {
1078                         r = -errno;
1079                         goto fail;
1080                 }
1081
1082                 f = realloc(m->fds, sizeof(int) * (m->n_fds + 1));
1083                 if (!f) {
1084                         r = -ENOMEM;
1085                         goto fail;
1086                 }
1087
1088                 fdi = m->n_fds;
1089                 f[fdi] = fd;
1090                 m->fds = f;
1091                 m->free_fds = true;
1092                 break;
1093         }
1094
1095         default:
1096                 align = bus_type_get_alignment(type);
1097                 sz = bus_type_get_size(type);
1098                 break;
1099         }
1100
1101         assert(align > 0);
1102         assert(sz > 0);
1103
1104         a = message_extend_body(m, align, sz);
1105         if (!a) {
1106                 r = -ENOMEM;
1107                 goto fail;
1108         }
1109
1110         if (type == SD_BUS_TYPE_STRING || type == SD_BUS_TYPE_OBJECT_PATH) {
1111                 *(uint32_t*) a = sz - 5;
1112                 memcpy((uint8_t*) a + 4, p, sz - 4);
1113
1114                 if (stored)
1115                         *stored = (const uint8_t*) a + 4;
1116
1117         } else if (type == SD_BUS_TYPE_SIGNATURE) {
1118                 *(uint8_t*) a = sz - 1;
1119                 memcpy((uint8_t*) a + 1, p, sz - 1);
1120
1121                 if (stored)
1122                         *stored = (const uint8_t*) a + 1;
1123         } else if (type == SD_BUS_TYPE_UNIX_FD) {
1124                 *(uint32_t*) a = fdi;
1125
1126                 if (stored)
1127                         *stored = a;
1128
1129                 m->n_fds ++;
1130
1131         } else {
1132                 memcpy(a, p, sz);
1133
1134                 if (stored)
1135                         *stored = a;
1136         }
1137
1138         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1139                 c->index++;
1140
1141         return 0;
1142
1143 fail:
1144         /* Truncate extended signature again */
1145         if (e)
1146                 c->signature[c->index] = 0;
1147
1148         if (fd >= 0)
1149                 close_nointr_nofail(fd);
1150
1151         return r;
1152 }
1153
1154 int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p) {
1155         return message_append_basic(m, type, p, NULL);
1156 }
1157
1158 static int bus_message_open_array(
1159                 sd_bus_message *m,
1160                 struct bus_container *c,
1161                 const char *contents,
1162                 uint32_t **array_size) {
1163
1164         unsigned nindex;
1165         char *e = NULL;
1166         void *a, *b;
1167         int alignment;
1168         size_t saved;
1169
1170         assert(m);
1171         assert(c);
1172         assert(contents);
1173         assert(array_size);
1174
1175         if (!signature_is_single(contents))
1176                 return -EINVAL;
1177
1178         alignment = bus_type_get_alignment(contents[0]);
1179         if (alignment < 0)
1180                 return alignment;
1181
1182         if (c->signature && c->signature[c->index]) {
1183
1184                 /* Verify the existing signature */
1185
1186                 if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
1187                         return -ENXIO;
1188
1189                 if (!startswith(c->signature + c->index + 1, contents))
1190                         return -ENXIO;
1191
1192                 nindex = c->index + 1 + strlen(contents);
1193         } else {
1194                 if (c->enclosing != 0)
1195                         return -ENXIO;
1196
1197                 /* Extend the existing signature */
1198
1199                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_ARRAY), contents, NULL);
1200                 if (!e)
1201                         return -ENOMEM;
1202
1203                 nindex = e - c->signature;
1204         }
1205
1206         saved = m->header->body_size;
1207         a = message_extend_body(m, 4, 4);
1208         if (!a) {
1209                 /* Truncate extended signature again */
1210                 if (e)
1211                         c->signature[c->index] = 0;
1212
1213                 return -ENOMEM;
1214         }
1215         b = m->body;
1216
1217         if (!message_extend_body(m, alignment, 0)) {
1218                 /* Add alignment between size and first element */
1219                 if (e)
1220                         c->signature[c->index] = 0;
1221
1222                 m->header->body_size = saved;
1223                 return -ENOMEM;
1224         }
1225
1226         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1227                 c->index = nindex;
1228
1229         /* m->body might have changed so let's readjust a */
1230         a = (uint8_t*) m->body + ((uint8_t*) a - (uint8_t*) b);
1231         *(uint32_t*) a = 0;
1232
1233         *array_size = a;
1234         return 0;
1235 }
1236
1237 static int bus_message_open_variant(
1238                 sd_bus_message *m,
1239                 struct bus_container *c,
1240                 const char *contents) {
1241
1242         char *e = NULL;
1243         size_t l;
1244         void *a;
1245
1246         assert(m);
1247         assert(c);
1248         assert(contents);
1249
1250         if (!signature_is_single(contents))
1251                 return -EINVAL;
1252
1253         if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
1254                 return -EINVAL;
1255
1256         if (c->signature && c->signature[c->index]) {
1257
1258                 if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
1259                         return -ENXIO;
1260
1261         } else {
1262                 if (c->enclosing != 0)
1263                         return -ENXIO;
1264
1265                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_VARIANT), NULL);
1266                 if (!e)
1267                         return -ENOMEM;
1268         }
1269
1270         l = strlen(contents);
1271         a = message_extend_body(m, 1, 1 + l + 1);
1272         if (!a) {
1273                 /* Truncate extended signature again */
1274                 if (e)
1275                         c->signature[c->index] = 0;
1276
1277                 return -ENOMEM;
1278         }
1279
1280         *(uint8_t*) a = l;
1281         memcpy((uint8_t*) a + 1, contents, l + 1);
1282
1283         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1284                 c->index++;
1285
1286         return 0;
1287 }
1288
1289 static int bus_message_open_struct(
1290                 sd_bus_message *m,
1291                 struct bus_container *c,
1292                 const char *contents) {
1293
1294         size_t nindex;
1295         char *e = NULL;
1296
1297         assert(m);
1298         assert(c);
1299         assert(contents);
1300
1301         if (!signature_is_valid(contents, false))
1302                 return -EINVAL;
1303
1304         if (c->signature && c->signature[c->index]) {
1305                 size_t l;
1306
1307                 l = strlen(contents);
1308
1309                 if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
1310                     !startswith(c->signature + c->index + 1, contents) ||
1311                     c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
1312                         return -ENXIO;
1313
1314                 nindex = c->index + 1 + l + 1;
1315         } else {
1316                 if (c->enclosing != 0)
1317                         return -ENXIO;
1318
1319                 e = strextend(&c->signature, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_BEGIN), contents, CHAR_TO_STR(SD_BUS_TYPE_STRUCT_END), NULL);
1320                 if (!e)
1321                         return -ENOMEM;
1322
1323                 nindex = e - c->signature;
1324         }
1325
1326         /* Align contents to 8 byte boundary */
1327         if (!message_extend_body(m, 8, 0)) {
1328                 if (e)
1329                         c->signature[c->index] = 0;
1330
1331                 return -ENOMEM;
1332         }
1333
1334         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1335                 c->index = nindex;
1336
1337         return 0;
1338 }
1339
1340 static int bus_message_open_dict_entry(
1341                 sd_bus_message *m,
1342                 struct bus_container *c,
1343                 const char *contents) {
1344
1345         size_t nindex;
1346
1347         assert(m);
1348         assert(c);
1349         assert(contents);
1350
1351         if (!signature_is_pair(contents))
1352                 return -EINVAL;
1353
1354         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1355                 return -ENXIO;
1356
1357         if (c->signature && c->signature[c->index]) {
1358                 size_t l;
1359
1360                 l = strlen(contents);
1361
1362                 if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
1363                     !startswith(c->signature + c->index + 1, contents) ||
1364                     c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
1365                         return -ENXIO;
1366
1367                 nindex = c->index + 1 + l + 1;
1368         } else
1369                 return -ENXIO;
1370
1371         /* Align contents to 8 byte boundary */
1372         if (!message_extend_body(m, 8, 0))
1373                 return -ENOMEM;
1374
1375         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1376                 c->index = nindex;
1377
1378         return 0;
1379 }
1380
1381 int sd_bus_message_open_container(
1382                 sd_bus_message *m,
1383                 char type,
1384                 const char *contents) {
1385
1386         struct bus_container *c, *w;
1387         uint32_t *array_size = NULL;
1388         char *signature;
1389         int r;
1390
1391         if (!m)
1392                 return -EINVAL;
1393         if (m->sealed)
1394                 return -EPERM;
1395         if (!contents)
1396                 return -EINVAL;
1397
1398         /* Make sure we have space for one more container */
1399         w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1));
1400         if (!w)
1401                 return -ENOMEM;
1402         m->containers = w;
1403
1404         c = message_get_container(m);
1405
1406         signature = strdup(contents);
1407         if (!signature)
1408                 return -ENOMEM;
1409
1410         if (type == SD_BUS_TYPE_ARRAY)
1411                 r = bus_message_open_array(m, c, contents, &array_size);
1412         else if (type == SD_BUS_TYPE_VARIANT)
1413                 r = bus_message_open_variant(m, c, contents);
1414         else if (type == SD_BUS_TYPE_STRUCT)
1415                 r = bus_message_open_struct(m, c, contents);
1416         else if (type == SD_BUS_TYPE_DICT_ENTRY)
1417                 r = bus_message_open_dict_entry(m, c, contents);
1418         else
1419                 r = -EINVAL;
1420
1421         if (r < 0) {
1422                 free(signature);
1423                 return r;
1424         }
1425
1426         /* OK, let's fill it in */
1427         w += m->n_containers++;
1428         w->enclosing = type;
1429         w->signature = signature;
1430         w->index = 0;
1431         w->array_size = array_size;
1432         w->begin = 0;
1433
1434         return 0;
1435 }
1436
1437 int sd_bus_message_close_container(sd_bus_message *m) {
1438         struct bus_container *c;
1439
1440         if (!m)
1441                 return -EINVAL;
1442         if (m->sealed)
1443                 return -EPERM;
1444         if (m->n_containers <= 0)
1445                 return -EINVAL;
1446
1447         c = message_get_container(m);
1448         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1449                 if (c->signature && c->signature[c->index] != 0)
1450                         return -EINVAL;
1451
1452         free(c->signature);
1453         m->n_containers--;
1454
1455         return 0;
1456 }
1457
1458
1459 typedef struct {
1460         const char *types;
1461         unsigned n_struct;
1462         unsigned n_array;
1463 } TypeStack;
1464
1465 static int type_stack_push(TypeStack *stack, unsigned max, unsigned *i, const char *types, unsigned n_struct, unsigned n_array) {
1466         assert(stack);
1467         assert(max > 0);
1468
1469         if (*i >= max)
1470                 return -EINVAL;
1471
1472         stack[*i].types = types;
1473         stack[*i].n_struct = n_struct;
1474         stack[*i].n_array = n_array;
1475         (*i)++;
1476
1477         return 0;
1478 }
1479
1480 static int type_stack_pop(TypeStack *stack, unsigned max, unsigned *i, const char **types, unsigned *n_struct, unsigned *n_array) {
1481         assert(stack);
1482         assert(max > 0);
1483         assert(types);
1484         assert(n_struct);
1485         assert(n_array);
1486
1487         if (*i <= 0)
1488                 return 0;
1489
1490         (*i)--;
1491         *types = stack[*i].types;
1492         *n_struct = stack[*i].n_struct;
1493         *n_array = stack[*i].n_array;
1494
1495         return 1;
1496 }
1497
1498 int bus_message_append_ap(
1499                 sd_bus_message *m,
1500                 const char *types,
1501                 va_list ap) {
1502
1503         unsigned n_array, n_struct;
1504         TypeStack stack[BUS_CONTAINER_DEPTH];
1505         unsigned stack_ptr = 0;
1506         int r;
1507
1508         assert(m);
1509
1510         if (!types)
1511                 return 0;
1512
1513         n_array = (unsigned) -1;
1514         n_struct = strlen(types);
1515
1516         for (;;) {
1517                 const char *t;
1518
1519                 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
1520                         r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
1521                         if (r < 0)
1522                                 return r;
1523                         if (r == 0)
1524                                 break;
1525
1526                         r = sd_bus_message_close_container(m);
1527                         if (r < 0)
1528                                 return r;
1529
1530                         continue;
1531                 }
1532
1533                 t = types;
1534                 if (n_array != (unsigned) -1)
1535                         n_array --;
1536                 else {
1537                         types ++;
1538                         n_struct--;
1539                 }
1540
1541                 switch (*t) {
1542
1543                 case SD_BUS_TYPE_BYTE: {
1544                         uint8_t x;
1545
1546                         x = (uint8_t) va_arg(ap, int);
1547                         r = sd_bus_message_append_basic(m, *t, &x);
1548                         break;
1549                 }
1550
1551                 case SD_BUS_TYPE_BOOLEAN:
1552                 case SD_BUS_TYPE_INT32:
1553                 case SD_BUS_TYPE_UINT32:
1554                 case SD_BUS_TYPE_UNIX_FD: {
1555                         uint32_t x;
1556
1557                         /* We assume a boolean is the same as int32_t */
1558                         assert_cc(sizeof(int32_t) == sizeof(int));
1559
1560                         x = va_arg(ap, uint32_t);
1561                         r = sd_bus_message_append_basic(m, *t, &x);
1562                         break;
1563                 }
1564
1565                 case SD_BUS_TYPE_INT16:
1566                 case SD_BUS_TYPE_UINT16: {
1567                         uint16_t x;
1568
1569                         x = (uint16_t) va_arg(ap, int);
1570                         r = sd_bus_message_append_basic(m, *t, &x);
1571                         break;
1572                 }
1573
1574                 case SD_BUS_TYPE_INT64:
1575                 case SD_BUS_TYPE_UINT64:
1576                 case SD_BUS_TYPE_DOUBLE: {
1577                         uint64_t x;
1578
1579                         x = va_arg(ap, uint64_t);
1580                         r = sd_bus_message_append_basic(m, *t, &x);
1581                         break;
1582                 }
1583
1584                 case SD_BUS_TYPE_STRING:
1585                 case SD_BUS_TYPE_OBJECT_PATH:
1586                 case SD_BUS_TYPE_SIGNATURE: {
1587                         const char *x;
1588
1589                         x = va_arg(ap, const char*);
1590                         r = sd_bus_message_append_basic(m, *t, x);
1591                         break;
1592                 }
1593
1594                 case SD_BUS_TYPE_ARRAY: {
1595                         size_t k;
1596
1597                         r = signature_element_length(t + 1, &k);
1598                         if (r < 0)
1599                                 return r;
1600
1601                         {
1602                                 char s[k + 1];
1603                                 memcpy(s, t + 1, k);
1604                                 s[k] = 0;
1605
1606                                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
1607                                 if (r < 0)
1608                                         return r;
1609                         }
1610
1611                         if (n_array == (unsigned) -1) {
1612                                 types += k;
1613                                 n_struct -= k;
1614                         }
1615
1616                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
1617                         if (r < 0)
1618                                 return r;
1619
1620                         types = t + 1;
1621                         n_struct = k;
1622                         n_array = va_arg(ap, unsigned);
1623
1624                         break;
1625                 }
1626
1627                 case SD_BUS_TYPE_VARIANT: {
1628                         const char *s;
1629
1630                         s = va_arg(ap, const char*);
1631                         if (!s)
1632                                 return -EINVAL;
1633
1634                         r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, s);
1635                         if (r < 0)
1636                                 return r;
1637
1638                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
1639                         if (r < 0)
1640                                 return r;
1641
1642                         types = s;
1643                         n_struct = strlen(s);
1644                         n_array = (unsigned) -1;
1645
1646                         break;
1647                 }
1648
1649                 case SD_BUS_TYPE_STRUCT_BEGIN:
1650                 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
1651                         size_t k;
1652
1653                         r = signature_element_length(t, &k);
1654                         if (r < 0)
1655                                 return r;
1656
1657                         {
1658                                 char s[k - 1];
1659
1660                                 memcpy(s, t + 1, k - 2);
1661                                 s[k - 2] = 0;
1662
1663                                 r = sd_bus_message_open_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
1664                                 if (r < 0)
1665                                         return r;
1666                         }
1667
1668                         if (n_array == (unsigned) -1) {
1669                                 types += k - 1;
1670                                 n_struct -= k - 1;
1671                         }
1672
1673                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
1674                         if (r < 0)
1675                                 return r;
1676
1677                         types = t + 1;
1678                         n_struct = k - 2;
1679                         n_array = (unsigned) -1;
1680
1681                         break;
1682                 }
1683
1684                 default:
1685                         r = -EINVAL;
1686                 }
1687
1688                 if (r < 0)
1689                         return r;
1690         }
1691
1692         return 0;
1693 }
1694
1695 int sd_bus_message_append(sd_bus_message *m, const char *types, ...) {
1696         va_list ap;
1697         int r;
1698
1699         if (!m)
1700                 return -EINVAL;
1701         if (m->sealed)
1702                 return -EPERM;
1703         if (!types)
1704                 return 0;
1705
1706         va_start(ap, types);
1707         r = bus_message_append_ap(m, types, ap);
1708         va_end(ap);
1709
1710         return r;
1711 }
1712
1713 static int buffer_peek(const void *p, uint32_t sz, size_t *rindex, size_t align, size_t nbytes, void **r) {
1714         size_t k, start, n;
1715
1716         assert(rindex);
1717         assert(align > 0);
1718
1719         start = ALIGN_TO((size_t) *rindex, align);
1720         n = start + nbytes;
1721
1722         if (n > sz)
1723                 return -EBADMSG;
1724
1725         /* Verify that padding is 0 */
1726         for (k = *rindex; k < start; k++)
1727                 if (((const uint8_t*) p)[k] != 0)
1728                         return -EBADMSG;
1729
1730         if (r)
1731                 *r = (uint8_t*) p + start;
1732
1733         *rindex = n;
1734
1735         return 1;
1736 }
1737
1738 static bool message_end_of_array(sd_bus_message *m, size_t index) {
1739         struct bus_container *c;
1740
1741         assert(m);
1742
1743         c = message_get_container(m);
1744         if (!c->array_size)
1745                 return false;
1746
1747         return index >= c->begin + BUS_MESSAGE_BSWAP32(m, *c->array_size);
1748 }
1749
1750 static int message_peek_body(sd_bus_message *m, size_t *rindex, size_t align, size_t nbytes, void **ret) {
1751         assert(m);
1752         assert(rindex);
1753         assert(align > 0);
1754
1755         if (message_end_of_array(m, *rindex))
1756                 return 0;
1757
1758         return buffer_peek(m->body, BUS_MESSAGE_BODY_SIZE(m), rindex, align, nbytes, ret);
1759 }
1760
1761 static bool validate_nul(const char *s, size_t l) {
1762
1763         /* Check for NUL chars in the string */
1764         if (memchr(s, 0, l))
1765                 return false;
1766
1767         /* Check for NUL termination */
1768         if (s[l] != 0)
1769                 return false;
1770
1771         return true;
1772 }
1773
1774 static bool validate_string(const char *s, size_t l) {
1775
1776         if (!validate_nul(s, l))
1777                 return false;
1778
1779         /* Check if valid UTF8 */
1780         if (!utf8_is_valid(s))
1781                 return false;
1782
1783         return true;
1784 }
1785
1786 static bool validate_signature(const char *s, size_t l) {
1787
1788         if (!validate_nul(s, l))
1789                 return false;
1790
1791         /* Check if valid signature */
1792         if (!signature_is_valid(s, true))
1793                 return false;
1794
1795         return true;
1796 }
1797
1798 static bool validate_object_path(const char *s, size_t l) {
1799
1800         if (!validate_nul(s, l))
1801                 return false;
1802
1803         if (!object_path_is_valid(s))
1804                 return false;
1805
1806         return true;
1807 }
1808
1809 int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p) {
1810         struct bus_container *c;
1811         int r;
1812         void *q;
1813
1814         if (!m)
1815                 return -EINVAL;
1816         if (!m->sealed)
1817                 return -EPERM;
1818         if (!bus_type_is_basic(type))
1819                 return -EINVAL;
1820         if (!p)
1821                 return -EINVAL;
1822
1823         c = message_get_container(m);
1824
1825         if (!c->signature || c->signature[c->index] == 0)
1826                 return 0;
1827
1828         if (c->signature[c->index] != type)
1829                 return -ENXIO;
1830
1831         switch (type) {
1832
1833         case SD_BUS_TYPE_STRING:
1834         case SD_BUS_TYPE_OBJECT_PATH: {
1835                 uint32_t l;
1836                 size_t rindex;
1837
1838                 rindex = m->rindex;
1839                 r = message_peek_body(m, &rindex, 4, 4, &q);
1840                 if (r <= 0)
1841                         return r;
1842
1843                 l = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
1844                 r = message_peek_body(m, &rindex, 1, l+1, &q);
1845                 if (r < 0)
1846                         return r;
1847                 if (r == 0)
1848                         return -EBADMSG;
1849
1850                 if (type == SD_BUS_TYPE_OBJECT_PATH) {
1851                         if (!validate_object_path(q, l))
1852                                 return -EBADMSG;
1853                 } else {
1854                         if (!validate_string(q, l))
1855                                 return -EBADMSG;
1856                 }
1857
1858                 m->rindex = rindex;
1859                 *(const char**) p = q;
1860                 break;
1861         }
1862
1863         case SD_BUS_TYPE_SIGNATURE: {
1864                 uint8_t l;
1865                 size_t rindex;
1866
1867                 rindex = m->rindex;
1868                 r = message_peek_body(m, &rindex, 1, 1, &q);
1869                 if (r <= 0)
1870                         return r;
1871
1872                 l = *(uint8_t*) q;
1873                 r = message_peek_body(m, &rindex, 1, l+1, &q);
1874                 if (r < 0)
1875                         return r;
1876                 if (r == 0)
1877                         return -EBADMSG;
1878
1879                 if (!validate_signature(q, l))
1880                         return -EBADMSG;
1881
1882                 m->rindex = rindex;
1883                 *(const char**) p = q;
1884                 break;
1885         }
1886
1887         default: {
1888                 ssize_t sz, align;
1889                 size_t rindex;
1890
1891                 align = bus_type_get_alignment(type);
1892                 sz = bus_type_get_size(type);
1893                 assert(align > 0 && sz > 0);
1894
1895                 rindex = m->rindex;
1896                 r = message_peek_body(m, &rindex, align, sz, &q);
1897                 if (r <= 0)
1898                         return r;
1899
1900                 switch (type) {
1901
1902                 case SD_BUS_TYPE_BYTE:
1903                         *(uint8_t*) p = *(uint8_t*) q;
1904                         break;
1905
1906                 case SD_BUS_TYPE_BOOLEAN:
1907                         *(int*) p = !!*(uint32_t*) q;
1908                         break;
1909
1910                 case SD_BUS_TYPE_INT16:
1911                 case SD_BUS_TYPE_UINT16:
1912                         *(uint16_t*) p = BUS_MESSAGE_BSWAP16(m, *(uint16_t*) q);
1913                         break;
1914
1915                 case SD_BUS_TYPE_INT32:
1916                 case SD_BUS_TYPE_UINT32:
1917                         *(uint32_t*) p = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
1918                         break;
1919
1920                 case SD_BUS_TYPE_INT64:
1921                 case SD_BUS_TYPE_UINT64:
1922                 case SD_BUS_TYPE_DOUBLE:
1923                         *(uint64_t*) p = BUS_MESSAGE_BSWAP64(m, *(uint64_t*) q);
1924                         break;
1925
1926                 case SD_BUS_TYPE_UNIX_FD: {
1927                         uint32_t j;
1928
1929                         j = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
1930                         if (j >= m->n_fds)
1931                                 return -EBADMSG;
1932
1933                         *(int*) p = m->fds[j];
1934                         break;
1935                 }
1936
1937                 default:
1938                         assert_not_reached("Unknown basic type...");
1939                 }
1940
1941                         m->rindex = rindex;
1942
1943                 break;
1944         }
1945         }
1946
1947         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1948                 c->index++;
1949
1950         return 1;
1951 }
1952
1953 static int bus_message_enter_array(
1954                 sd_bus_message *m,
1955                 struct bus_container *c,
1956                 const char *contents,
1957                 uint32_t **array_size) {
1958
1959         size_t rindex;
1960         void *q;
1961         int r, alignment;
1962
1963         assert(m);
1964         assert(c);
1965         assert(contents);
1966         assert(array_size);
1967
1968         if (!signature_is_single(contents))
1969                 return -EINVAL;
1970
1971         alignment = bus_type_get_alignment(contents[0]);
1972         if (alignment < 0)
1973                 return alignment;
1974
1975         if (!c->signature || c->signature[c->index] == 0)
1976                 return 0;
1977
1978         if (c->signature[c->index] != SD_BUS_TYPE_ARRAY)
1979                 return -ENXIO;
1980
1981         if (!startswith(c->signature + c->index + 1, contents))
1982                 return -ENXIO;
1983
1984         rindex = m->rindex;
1985         r = message_peek_body(m, &rindex, 4, 4, &q);
1986         if (r <= 0)
1987                 return r;
1988
1989         if (BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q) > BUS_ARRAY_MAX_SIZE)
1990                 return -EBADMSG;
1991
1992         r = message_peek_body(m, &rindex, alignment, 0, NULL);
1993         if (r < 0)
1994                 return r;
1995         if (r == 0)
1996                 return -EBADMSG;
1997
1998         if (c->enclosing != SD_BUS_TYPE_ARRAY)
1999                 c->index += 1 + strlen(contents);
2000
2001         m->rindex = rindex;
2002
2003         *array_size = (uint32_t*) q;
2004
2005         return 1;
2006 }
2007
2008 static int bus_message_enter_variant(
2009                 sd_bus_message *m,
2010                 struct bus_container *c,
2011                 const char *contents) {
2012
2013         size_t rindex;
2014         uint8_t l;
2015         void *q;
2016         int r;
2017
2018         assert(m);
2019         assert(c);
2020         assert(contents);
2021
2022         if (!signature_is_single(contents))
2023                 return -EINVAL;
2024
2025         if (*contents == SD_BUS_TYPE_DICT_ENTRY_BEGIN)
2026                 return -EINVAL;
2027
2028         if (!c->signature || c->signature[c->index] == 0)
2029                 return 0;
2030
2031         if (c->signature[c->index] != SD_BUS_TYPE_VARIANT)
2032                 return -ENXIO;
2033
2034         rindex = m->rindex;
2035         r = message_peek_body(m, &rindex, 1, 1, &q);
2036         if (r <= 0)
2037                 return r;
2038
2039         l = *(uint8_t*) q;
2040         r = message_peek_body(m, &rindex, 1, l+1, &q);
2041         if (r < 0)
2042                 return r;
2043         if (r == 0)
2044                 return -EBADMSG;
2045
2046         if (!validate_signature(q, l))
2047                 return -EBADMSG;
2048
2049         if (!streq(q, contents))
2050                 return -ENXIO;
2051
2052         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2053                 c->index++;
2054
2055         m->rindex = rindex;
2056
2057         return 1;
2058 }
2059
2060 static int bus_message_enter_struct(
2061                 sd_bus_message *m,
2062                 struct bus_container *c,
2063                 const char *contents) {
2064
2065         size_t l;
2066         int r;
2067
2068         assert(m);
2069         assert(c);
2070         assert(contents);
2071
2072         if (!signature_is_valid(contents, false))
2073                 return -EINVAL;
2074
2075         if (!c->signature || c->signature[c->index] == 0)
2076                 return 0;
2077
2078         l = strlen(contents);
2079
2080         if (c->signature[c->index] != SD_BUS_TYPE_STRUCT_BEGIN ||
2081             !startswith(c->signature + c->index + 1, contents) ||
2082             c->signature[c->index + 1 + l] != SD_BUS_TYPE_STRUCT_END)
2083                 return -ENXIO;
2084
2085         r = message_peek_body(m, &m->rindex, 8, 0, NULL);
2086         if (r <= 0)
2087                 return r;
2088
2089         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2090                 c->index += 1 + l + 1;
2091
2092         return 1;
2093 }
2094
2095 static int bus_message_enter_dict_entry(
2096                 sd_bus_message *m,
2097                 struct bus_container *c,
2098                 const char *contents) {
2099
2100         size_t l;
2101         int r;
2102
2103         assert(m);
2104         assert(c);
2105         assert(contents);
2106
2107         if (!signature_is_pair(contents))
2108                 return -EINVAL;
2109
2110         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2111                 return -ENXIO;
2112
2113         if (!c->signature || c->signature[c->index] == 0)
2114                 return 0;
2115
2116         l = strlen(contents);
2117
2118         if (c->signature[c->index] != SD_BUS_TYPE_DICT_ENTRY_BEGIN ||
2119             !startswith(c->signature + c->index + 1, contents) ||
2120             c->signature[c->index + 1 + l] != SD_BUS_TYPE_DICT_ENTRY_END)
2121                 return -ENXIO;
2122
2123         r = message_peek_body(m, &m->rindex, 8, 0, NULL);
2124         if (r <= 0)
2125                 return r;
2126
2127         if (c->enclosing != SD_BUS_TYPE_ARRAY)
2128                 c->index += 1 + l + 1;
2129
2130         return 1;
2131 }
2132
2133 int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents) {
2134         struct bus_container *c, *w;
2135         uint32_t *array_size = NULL;
2136         char *signature;
2137         int r;
2138
2139         if (!m)
2140                 return -EINVAL;
2141         if (!m->sealed)
2142                 return -EPERM;
2143         if (!contents)
2144                 return -EINVAL;
2145
2146         /*
2147          * We enforce a global limit on container depth, that is much
2148          * higher than the 32 structs and 32 arrays the specification
2149          * mandates. This is simpler to implement for us, and we need
2150          * this only to ensure our container array doesn't grow
2151          * without bounds. We are happy to return any data from a
2152          * message as long as the data itself is valid, even if the
2153          * overall message might be not.
2154          *
2155          * Note that the message signature is validated when
2156          * parsing the headers, and that validation does check the
2157          * 32/32 limit.
2158          *
2159          * Note that the specification defines no limits on the depth
2160          * of stacked variants, but we do.
2161          */
2162         if (m->n_containers >= BUS_CONTAINER_DEPTH)
2163                 return -EBADMSG;
2164
2165         w = realloc(m->containers, sizeof(struct bus_container) * (m->n_containers + 1));
2166         if (!w)
2167                 return -ENOMEM;
2168         m->containers = w;
2169
2170         c = message_get_container(m);
2171
2172         if (!c->signature || c->signature[c->index] == 0)
2173                 return 0;
2174
2175         signature = strdup(contents);
2176         if (!signature)
2177                 return -ENOMEM;
2178
2179         if (type == SD_BUS_TYPE_ARRAY)
2180                 r = bus_message_enter_array(m, c, contents, &array_size);
2181         else if (type == SD_BUS_TYPE_VARIANT)
2182                 r = bus_message_enter_variant(m, c, contents);
2183         else if (type == SD_BUS_TYPE_STRUCT)
2184                 r = bus_message_enter_struct(m, c, contents);
2185         else if (type == SD_BUS_TYPE_DICT_ENTRY)
2186                 r = bus_message_enter_dict_entry(m, c, contents);
2187         else
2188                 r = -EINVAL;
2189
2190         if (r <= 0) {
2191                 free(signature);
2192                 return r;
2193         }
2194
2195         /* OK, let's fill it in */
2196         w += m->n_containers++;
2197         w->enclosing = type;
2198         w->signature = signature;
2199         w->index = 0;
2200         w->array_size = array_size;
2201         w->begin = m->rindex;
2202
2203         return 1;
2204 }
2205
2206 int sd_bus_message_exit_container(sd_bus_message *m) {
2207         struct bus_container *c;
2208
2209         if (!m)
2210                 return -EINVAL;
2211         if (!m->sealed)
2212                 return -EPERM;
2213         if (m->n_containers <= 0)
2214                 return -EINVAL;
2215
2216         c = message_get_container(m);
2217         if (c->enclosing == SD_BUS_TYPE_ARRAY) {
2218                 uint32_t l;
2219
2220                 l = BUS_MESSAGE_BSWAP32(m, *c->array_size);
2221                 if (c->begin + l != m->rindex)
2222                         return -EBUSY;
2223
2224         } else {
2225                 if (c->signature && c->signature[c->index] != 0)
2226                         return -EINVAL;
2227         }
2228
2229         free(c->signature);
2230         m->n_containers--;
2231
2232         return 1;
2233 }
2234
2235 int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents) {
2236         struct bus_container *c;
2237         int r;
2238
2239         if (!m)
2240                 return -EINVAL;
2241         if (!m->sealed)
2242                 return -EPERM;
2243
2244         c = message_get_container(m);
2245
2246         if (!c->signature || c->signature[c->index] == 0)
2247                 goto eof;
2248
2249         if (message_end_of_array(m, m->rindex))
2250                 goto eof;
2251
2252         if (bus_type_is_basic(c->signature[c->index])) {
2253                 if (contents)
2254                         *contents = NULL;
2255                 if (type)
2256                         *type = c->signature[c->index];
2257                 return 1;
2258         }
2259
2260         if (c->signature[c->index] == SD_BUS_TYPE_ARRAY) {
2261
2262                 if (contents) {
2263                         size_t l;
2264                         char *sig;
2265
2266                         r = signature_element_length(c->signature+c->index+1, &l);
2267                         if (r < 0)
2268                                 return r;
2269
2270                         assert(l >= 1);
2271
2272                         sig = strndup(c->signature + c->index + 1, l);
2273                         if (!sig)
2274                                 return -ENOMEM;
2275
2276                         free(m->peeked_signature);
2277                         m->peeked_signature = sig;
2278
2279                         *contents = sig;
2280                 }
2281
2282                 if (type)
2283                         *type = SD_BUS_TYPE_ARRAY;
2284
2285                 return 1;
2286         }
2287
2288         if (c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ||
2289             c->signature[c->index] == SD_BUS_TYPE_DICT_ENTRY_BEGIN) {
2290
2291                 if (contents) {
2292                         size_t l;
2293                         char *sig;
2294
2295                         r = signature_element_length(c->signature+c->index, &l);
2296                         if (r < 0)
2297                                 return r;
2298
2299                         assert(l >= 2);
2300                         sig = strndup(c->signature + c->index + 1, l - 2);
2301                         if (!sig)
2302                                 return -ENOMEM;
2303
2304                         free(m->peeked_signature);
2305                         m->peeked_signature = sig;
2306
2307                         *contents = sig;
2308                 }
2309
2310                 if (type)
2311                         *type = c->signature[c->index] == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
2312
2313                 return 1;
2314         }
2315
2316         if (c->signature[c->index] == SD_BUS_TYPE_VARIANT) {
2317                 if (contents) {
2318                         size_t rindex, l;
2319                         void *q;
2320
2321                         rindex = m->rindex;
2322                         r = message_peek_body(m, &rindex, 1, 1, &q);
2323                         if (r < 0)
2324                                 return r;
2325                         if (r == 0)
2326                                 goto eof;
2327
2328                         l = *(uint8_t*) q;
2329                         r = message_peek_body(m, &rindex, 1, l+1, &q);
2330                         if (r < 0)
2331                                 return r;
2332                         if (r == 0)
2333                                 return -EBADMSG;
2334
2335                         if (!validate_signature(q, l))
2336                                 return -EBADMSG;
2337
2338                         *contents = q;
2339                 }
2340
2341                 if (type)
2342                         *type = SD_BUS_TYPE_VARIANT;
2343
2344                 return 1;
2345         }
2346
2347         return -EINVAL;
2348
2349 eof:
2350         if (type)
2351                 *type = c->enclosing;
2352         if (contents)
2353                 *contents = NULL;
2354         return 0;
2355 }
2356
2357 int sd_bus_message_rewind(sd_bus_message *m, int complete) {
2358         struct bus_container *c;
2359
2360         if (!m)
2361                 return -EINVAL;
2362         if (!m->sealed)
2363                 return -EPERM;
2364
2365         if (complete) {
2366                 reset_containers(m);
2367                 m->rindex = 0;
2368                 m->root_container.index = 0;
2369
2370                 c = message_get_container(m);
2371         } else {
2372                 c = message_get_container(m);
2373
2374                 c->index = 0;
2375                 m->rindex = c->begin;
2376         }
2377
2378         return !isempty(c->signature);
2379 }
2380 static int message_read_ap(
2381                 sd_bus_message *m,
2382                 const char *types,
2383                 va_list ap) {
2384
2385         unsigned n_array, n_struct;
2386         TypeStack stack[BUS_CONTAINER_DEPTH];
2387         unsigned stack_ptr = 0;
2388         int r;
2389
2390         assert(m);
2391
2392         if (!types)
2393                 return 0;
2394
2395         /* Ideally, we'd just call ourselves recursively on every
2396          * complex type. However, the state of a va_list that is
2397          * passed to a function is undefined after that function
2398          * returns. This means we need to docode the va_list linearly
2399          * in a single stackframe. We hence implement our own
2400          * home-grown stack in an array. */
2401
2402         n_array = (unsigned) -1;
2403         n_struct = strlen(types);
2404
2405         for (;;) {
2406                 const char *t;
2407
2408                 if (n_array == 0 || (n_array == (unsigned) -1 && n_struct == 0)) {
2409                         r = type_stack_pop(stack, ELEMENTSOF(stack), &stack_ptr, &types, &n_struct, &n_array);
2410                         if (r < 0)
2411                                 return r;
2412                         if (r == 0)
2413                                 break;
2414
2415                         r = sd_bus_message_exit_container(m);
2416                         if (r < 0)
2417                                 return r;
2418
2419                         continue;
2420                 }
2421
2422                 t = types;
2423                 if (n_array != (unsigned) -1)
2424                         n_array --;
2425                 else {
2426                         types ++;
2427                         n_struct--;
2428                 }
2429
2430                 switch (*t) {
2431
2432                 case SD_BUS_TYPE_BYTE:
2433                 case SD_BUS_TYPE_BOOLEAN:
2434                 case SD_BUS_TYPE_INT16:
2435                 case SD_BUS_TYPE_UINT16:
2436                 case SD_BUS_TYPE_INT32:
2437                 case SD_BUS_TYPE_UINT32:
2438                 case SD_BUS_TYPE_INT64:
2439                 case SD_BUS_TYPE_UINT64:
2440                 case SD_BUS_TYPE_DOUBLE:
2441                 case SD_BUS_TYPE_STRING:
2442                 case SD_BUS_TYPE_OBJECT_PATH:
2443                 case SD_BUS_TYPE_SIGNATURE:
2444                 case SD_BUS_TYPE_UNIX_FD: {
2445                         void *p;
2446
2447                         p = va_arg(ap, void*);
2448                         r = sd_bus_message_read_basic(m, *t, p);
2449                         if (r < 0)
2450                                 return r;
2451                         if (r == 0)
2452                                 return -ENXIO;
2453
2454                         break;
2455                 }
2456
2457                 case SD_BUS_TYPE_ARRAY: {
2458                         size_t k;
2459
2460                         r = signature_element_length(t + 1, &k);
2461                         if (r < 0)
2462                                 return r;
2463
2464                         {
2465                                 char s[k + 1];
2466                                 memcpy(s, t + 1, k);
2467                                 s[k] = 0;
2468
2469                                 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, s);
2470                                 if (r < 0)
2471                                         return r;
2472                                 if (r == 0)
2473                                         return -ENXIO;
2474                         }
2475
2476                         if (n_array == (unsigned) -1) {
2477                                 types += k;
2478                                 n_struct -= k;
2479                         }
2480
2481                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2482                         if (r < 0)
2483                                 return r;
2484
2485                         types = t + 1;
2486                         n_struct = k;
2487                         n_array = va_arg(ap, unsigned);
2488
2489                         break;
2490                 }
2491
2492                 case SD_BUS_TYPE_VARIANT: {
2493                         const char *s;
2494
2495                         s = va_arg(ap, const char *);
2496                         if (!s)
2497                                 return -EINVAL;
2498
2499                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, s);
2500                         if (r < 0)
2501                                 return r;
2502                         if (r == 0)
2503                                 return -ENXIO;
2504
2505                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2506                         if (r < 0)
2507                                 return r;
2508
2509                         types = s;
2510                         n_struct = strlen(s);
2511                         n_array = (unsigned) -1;
2512
2513                         break;
2514                 }
2515
2516                 case SD_BUS_TYPE_STRUCT_BEGIN:
2517                 case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
2518                         size_t k;
2519
2520                         r = signature_element_length(t, &k);
2521                         if (r < 0)
2522                                 return r;
2523
2524                         {
2525                                 char s[k - 1];
2526                                 memcpy(s, t + 1, k - 2);
2527                                 s[k - 2] = 0;
2528
2529                                 r = sd_bus_message_enter_container(m, *t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);
2530                                 if (r < 0)
2531                                         return r;
2532                                 if (r == 0)
2533                                         return -ENXIO;
2534                         }
2535
2536                         if (n_array == (unsigned) -1) {
2537                                 types += k - 1;
2538                                 n_struct -= k - 1;
2539                         }
2540
2541                         r = type_stack_push(stack, ELEMENTSOF(stack), &stack_ptr, types, n_struct, n_array);
2542                         if (r < 0)
2543                                 return r;
2544
2545                         types = t + 1;
2546                         n_struct = k - 2;
2547                         n_array = (unsigned) -1;
2548
2549                         break;
2550                 }
2551
2552                 default:
2553                         return -EINVAL;
2554                 }
2555         }
2556
2557         return 1;
2558 }
2559
2560 int sd_bus_message_read(sd_bus_message *m, const char *types, ...) {
2561         va_list ap;
2562         int r;
2563
2564         if (!m)
2565                 return -EINVAL;
2566         if (!m->sealed)
2567                 return -EPERM;
2568         if (!types)
2569                 return -EINVAL;
2570
2571         va_start(ap, types);
2572         r = message_read_ap(m, types, ap);
2573         va_end(ap);
2574
2575         return r;
2576 }
2577
2578 static int message_peek_fields(
2579                 sd_bus_message *m,
2580                 size_t *rindex,
2581                 size_t align,
2582                 size_t nbytes,
2583                 void **ret) {
2584
2585         assert(m);
2586         assert(rindex);
2587         assert(align > 0);
2588
2589         return buffer_peek(m->fields, BUS_MESSAGE_FIELDS_SIZE(m), rindex, align, nbytes, ret);
2590 }
2591
2592 static int message_peek_field_uint32(
2593                 sd_bus_message *m,
2594                 size_t *ri,
2595                 uint32_t *ret) {
2596
2597         int r;
2598         void *q;
2599
2600         assert(m);
2601         assert(ri);
2602
2603         r = message_peek_fields(m, ri, 4, 4, &q);
2604         if (r < 0)
2605                 return r;
2606
2607         if (ret)
2608                 *ret = BUS_MESSAGE_BSWAP32(m, *(uint32_t*) q);
2609
2610         return 0;
2611 }
2612
2613 static int message_peek_field_string(
2614                 sd_bus_message *m,
2615                 bool (*validate)(const char *p),
2616                 size_t *ri,
2617                 const char **ret) {
2618
2619         uint32_t l;
2620         int r;
2621         void *q;
2622
2623         assert(m);
2624         assert(ri);
2625
2626         r = message_peek_field_uint32(m, ri, &l);
2627         if (r < 0)
2628                 return r;
2629
2630         r = message_peek_fields(m, ri, 1, l+1, &q);
2631         if (r < 0)
2632                 return r;
2633
2634         if (validate) {
2635                 if (!validate_nul(q, l))
2636                         return -EBADMSG;
2637
2638                 if (!validate(q))
2639                         return -EBADMSG;
2640         } else {
2641                 if (!validate_string(q, l))
2642                         return -EBADMSG;
2643         }
2644
2645         if (ret)
2646                 *ret = q;
2647
2648         return 0;
2649 }
2650
2651 static int message_peek_field_signature(
2652                 sd_bus_message *m,
2653                 size_t *ri,
2654                 const char **ret) {
2655
2656         size_t l;
2657         int r;
2658         void *q;
2659
2660         assert(m);
2661         assert(ri);
2662
2663         r = message_peek_fields(m, ri, 1, 1, &q);
2664         if (r < 0)
2665                 return r;
2666
2667         l = *(uint8_t*) q;
2668         r = message_peek_fields(m, ri, 1, l+1, &q);
2669         if (r < 0)
2670                 return r;
2671
2672         if (!validate_signature(q, l))
2673                 return -EBADMSG;
2674
2675         if (ret)
2676                 *ret = q;
2677
2678         return 0;
2679 }
2680
2681 static int message_skip_fields(
2682                 sd_bus_message *m,
2683                 size_t *ri,
2684                 uint32_t array_size,
2685                 const char **signature) {
2686
2687         size_t original_index;
2688         int r;
2689
2690         assert(m);
2691         assert(ri);
2692         assert(signature);
2693
2694         original_index = *ri;
2695
2696         for (;;) {
2697                 char t;
2698                 size_t l;
2699
2700                 if (array_size != (uint32_t) -1 &&
2701                     array_size <= *ri - original_index)
2702                         return 0;
2703
2704                 t = **signature;
2705                 if (!t)
2706                         return 0;
2707
2708                 if (t == SD_BUS_TYPE_STRING) {
2709
2710                         r = message_peek_field_string(m, NULL, ri, NULL);
2711                         if (r < 0)
2712                                 return r;
2713
2714                         (*signature)++;
2715
2716                 } else if (t == SD_BUS_TYPE_OBJECT_PATH) {
2717
2718                         r = message_peek_field_string(m, object_path_is_valid, ri, NULL);
2719                         if (r < 0)
2720                                 return r;
2721
2722                         (*signature)++;
2723
2724                 } else if (t == SD_BUS_TYPE_SIGNATURE) {
2725
2726                         r = message_peek_field_signature(m, ri, NULL);
2727                         if (r < 0)
2728                                 return r;
2729
2730                         (*signature)++;
2731
2732                 } else if (bus_type_is_basic(t)) {
2733                         ssize_t align, k;
2734
2735                         align = bus_type_get_alignment(t);
2736                         k = bus_type_get_size(t);
2737                         assert(align > 0 && k > 0);
2738
2739                         r = message_peek_fields(m, ri, align, k, NULL);
2740                         if (r < 0)
2741                                 return r;
2742
2743                         (*signature)++;
2744
2745                 } else if (t == SD_BUS_TYPE_ARRAY) {
2746
2747                         r = signature_element_length(*signature+1, &l);
2748                         if (r < 0)
2749                                 return r;
2750
2751                         assert(l >= 1);
2752                         {
2753                                 char sig[l-1], *s;
2754                                 uint32_t nas;
2755                                 int alignment;
2756
2757                                 strncpy(sig, *signature + 1, l-1);
2758                                 s = sig;
2759
2760                                 alignment = bus_type_get_alignment(sig[0]);
2761                                 if (alignment < 0)
2762                                         return alignment;
2763
2764                                 r = message_peek_field_uint32(m, ri, &nas);
2765                                 if (r < 0)
2766                                         return r;
2767                                 if (nas > BUS_ARRAY_MAX_SIZE)
2768                                         return -EBADMSG;
2769
2770                                 r = message_peek_fields(m, ri, alignment, 0, NULL);
2771                                 if (r < 0)
2772                                         return r;
2773
2774                                 r = message_skip_fields(m, ri, nas, (const char**) &s);
2775                                 if (r < 0)
2776                                         return r;
2777                         }
2778
2779                         (*signature) += 1 + l;
2780
2781                 } else if (t == SD_BUS_TYPE_VARIANT) {
2782                         const char *s;
2783
2784                         r = message_peek_field_signature(m, ri, &s);
2785                         if (r < 0)
2786                                 return r;
2787
2788                         r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
2789                         if (r < 0)
2790                                 return r;
2791
2792                         (*signature)++;
2793
2794                 } else if (t == SD_BUS_TYPE_STRUCT ||
2795                            t == SD_BUS_TYPE_DICT_ENTRY) {
2796
2797                         r = signature_element_length(*signature, &l);
2798                         if (r < 0)
2799                                 return r;
2800
2801                         assert(l >= 2);
2802                         {
2803                                 char sig[l-1], *s;
2804                                 strncpy(sig, *signature + 1, l-1);
2805                                 s = sig;
2806
2807                                 r = message_skip_fields(m, ri, (uint32_t) -1, (const char**) &s);
2808                                 if (r < 0)
2809                                         return r;
2810                         }
2811
2812                         *signature += l;
2813                 } else
2814                         return -EINVAL;
2815         }
2816 }
2817
2818 int bus_message_parse_fields(sd_bus_message *m) {
2819         size_t ri;
2820         int r;
2821         uint32_t unix_fds = 0;
2822
2823         assert(m);
2824
2825         for (ri = 0; ri < BUS_MESSAGE_FIELDS_SIZE(m); ) {
2826                 const char *signature;
2827                 uint8_t *header;
2828
2829                 r = message_peek_fields(m, &ri, 8, 1, (void**) &header);
2830                 if (r < 0)
2831                         return r;
2832
2833                 r = message_peek_field_signature(m, &ri, &signature);
2834                 if (r < 0)
2835                         return r;
2836
2837                 switch (*header) {
2838                 case _SD_BUS_MESSAGE_HEADER_INVALID:
2839                         return -EBADMSG;
2840
2841                 case SD_BUS_MESSAGE_HEADER_PATH:
2842
2843                         if (m->path)
2844                                 return -EBADMSG;
2845
2846                         if (!streq(signature, "o"))
2847                                 return -EBADMSG;
2848
2849                         r = message_peek_field_string(m, object_path_is_valid, &ri, &m->path);
2850                         break;
2851
2852                 case SD_BUS_MESSAGE_HEADER_INTERFACE:
2853
2854                         if (m->interface)
2855                                 return -EBADMSG;
2856
2857                         if (!streq(signature, "s"))
2858                                 return -EBADMSG;
2859
2860                         r = message_peek_field_string(m, interface_name_is_valid, &ri, &m->interface);
2861                         break;
2862
2863                 case SD_BUS_MESSAGE_HEADER_MEMBER:
2864
2865                         if (m->member)
2866                                 return -EBADMSG;
2867
2868                         if (!streq(signature, "s"))
2869                                 return -EBADMSG;
2870
2871                         r = message_peek_field_string(m, member_name_is_valid, &ri, &m->member);
2872                         break;
2873
2874                 case SD_BUS_MESSAGE_HEADER_ERROR_NAME:
2875
2876                         if (m->error.name)
2877                                 return -EBADMSG;
2878
2879                         if (!streq(signature, "s"))
2880                                 return -EBADMSG;
2881
2882                         r = message_peek_field_string(m, error_name_is_valid, &ri, &m->error.name);
2883                         break;
2884
2885                 case SD_BUS_MESSAGE_HEADER_DESTINATION:
2886
2887                         if (m->destination)
2888                                 return -EBADMSG;
2889
2890                         if (!streq(signature, "s"))
2891                                 return -EBADMSG;
2892
2893                         r = message_peek_field_string(m, service_name_is_valid, &ri, &m->destination);
2894                         break;
2895
2896                 case SD_BUS_MESSAGE_HEADER_SENDER:
2897
2898                         if (m->sender)
2899                                 return -EBADMSG;
2900
2901                         if (!streq(signature, "s"))
2902                                 return -EBADMSG;
2903
2904                         r = message_peek_field_string(m, service_name_is_valid, &ri, &m->sender);
2905                         break;
2906
2907
2908                 case SD_BUS_MESSAGE_HEADER_SIGNATURE: {
2909                         const char *s;
2910                         char *c;
2911
2912                         if (m->root_container.signature)
2913                                 return -EBADMSG;
2914
2915                         if (!streq(signature, "g"))
2916                                 return -EBADMSG;
2917
2918                         r = message_peek_field_signature(m, &ri, &s);
2919                         if (r < 0)
2920                                 return r;
2921
2922                         c = strdup(s);
2923                         if (!c)
2924                                 return -ENOMEM;
2925
2926                         free(m->root_container.signature);
2927                         m->root_container.signature = c;
2928                         break;
2929                 }
2930
2931                 case SD_BUS_MESSAGE_HEADER_REPLY_SERIAL:
2932                         if (m->reply_serial != 0)
2933                                 return -EBADMSG;
2934
2935                         if (!streq(signature, "u"))
2936                                 return -EBADMSG;
2937
2938                         r = message_peek_field_uint32(m, &ri, &m->reply_serial);
2939                         if (r < 0)
2940                                 return r;
2941
2942                         if (m->reply_serial == 0)
2943                                 return -EBADMSG;
2944
2945                         break;
2946
2947                 case SD_BUS_MESSAGE_HEADER_UNIX_FDS:
2948                         if (unix_fds != 0)
2949                                 return -EBADMSG;
2950
2951                         if (!streq(signature, "u"))
2952                                 return -EBADMSG;
2953
2954                         r = message_peek_field_uint32(m, &ri, &unix_fds);
2955                         if (r < 0)
2956                                 return -EBADMSG;
2957
2958                         if (unix_fds == 0)
2959                                 return -EBADMSG;
2960
2961                         break;
2962
2963                 default:
2964                         r = message_skip_fields(m, &ri, (uint32_t) -1, (const char **) &signature);
2965                 }
2966
2967                 if (r < 0)
2968                         return r;
2969         }
2970
2971         if (m->n_fds != unix_fds)
2972                 return -EBADMSG;
2973
2974         if (isempty(m->root_container.signature) != (BUS_MESSAGE_BODY_SIZE(m) == 0))
2975                 return -EBADMSG;
2976
2977         switch (m->header->type) {
2978
2979         case SD_BUS_MESSAGE_TYPE_SIGNAL:
2980                 if (!m->path || !m->interface || !m->member)
2981                         return -EBADMSG;
2982                 break;
2983
2984         case SD_BUS_MESSAGE_TYPE_METHOD_CALL:
2985
2986                 if (!m->path || !m->member)
2987                         return -EBADMSG;
2988
2989                 break;
2990
2991         case SD_BUS_MESSAGE_TYPE_METHOD_RETURN:
2992
2993                 if (m->reply_serial == 0)
2994                         return -EBADMSG;
2995                 break;
2996
2997         case SD_BUS_MESSAGE_TYPE_METHOD_ERROR:
2998
2999                 if (m->reply_serial == 0 || !m->error.name)
3000                         return -EBADMSG;
3001                 break;
3002         }
3003
3004         /* Try to read the error message, but if we can't it's a non-issue */
3005         if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
3006                 sd_bus_message_read(m, "s", &m->error.message);
3007
3008         return 0;
3009 }
3010
3011 int bus_message_seal(sd_bus_message *m, uint64_t serial) {
3012         int r;
3013         size_t l, a;
3014
3015         assert(m);
3016
3017         if (m->sealed)
3018                 return -EPERM;
3019
3020         if (m->n_containers > 0)
3021                 return -EBADMSG;
3022
3023         /* If there's a non-trivial signature set, then add it in here */
3024         if (!isempty(m->root_container.signature)) {
3025                 r = message_append_field_signature(m, SD_BUS_MESSAGE_HEADER_SIGNATURE, m->root_container.signature, NULL);
3026                 if (r < 0)
3027                         return r;
3028         }
3029
3030         if (m->n_fds > 0) {
3031                 r = message_append_field_uint32(m, SD_BUS_MESSAGE_HEADER_UNIX_FDS, m->n_fds);
3032                 if (r < 0)
3033                         return r;
3034         }
3035
3036         l = BUS_MESSAGE_FIELDS_SIZE(m);
3037         a = ALIGN8(l) - l;
3038
3039         if (a > 0) {
3040                 /* Add padding at the end, since we know the body
3041                  * needs to start at an 8 byte alignment. */
3042                 void *p;
3043
3044                 p = message_extend_fields(m, 1, a);
3045                 if (!p)
3046                         return -ENOMEM;
3047
3048                 memset(p, 0, a);
3049                 m->header->fields_size -= a;
3050         }
3051
3052         m->header->serial = serial;
3053         m->sealed = true;
3054
3055         return 0;
3056 }
3057
3058 int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) {
3059         if (!m)
3060                 return -EINVAL;
3061         if (!destination)
3062                 return -EINVAL;
3063         if (m->sealed)
3064                 return -EPERM;
3065         if (m->destination)
3066                 return -EEXIST;
3067
3068         return message_append_field_string(m, SD_BUS_MESSAGE_HEADER_DESTINATION, SD_BUS_TYPE_STRING, destination, &m->destination);
3069 }
3070
3071 int bus_message_dump(sd_bus_message *m) {
3072         const char *u = NULL, *uu = NULL, *s = NULL;
3073         char **cmdline = NULL;
3074         unsigned level = 1;
3075         int r;
3076
3077         assert(m);
3078
3079         printf("Message %p\n"
3080                "\tn_ref=%u\n"
3081                "\tendian=%c\n"
3082                "\ttype=%i\n"
3083                "\tflags=%u\n"
3084                "\tversion=%u\n"
3085                "\tserial=%u\n"
3086                "\tfields_size=%u\n"
3087                "\tbody_size=%u\n"
3088                "\tpath=%s\n"
3089                "\tinterface=%s\n"
3090                "\tmember=%s\n"
3091                "\tdestination=%s\n"
3092                "\tsender=%s\n"
3093                "\tsignature=%s\n"
3094                "\treply_serial=%u\n"
3095                "\terror.name=%s\n"
3096                "\terror.message=%s\n"
3097                "\tsealed=%s\n",
3098                m,
3099                m->n_ref,
3100                m->header->endian,
3101                m->header->type,
3102                m->header->flags,
3103                m->header->version,
3104                BUS_MESSAGE_SERIAL(m),
3105                BUS_MESSAGE_FIELDS_SIZE(m),
3106                BUS_MESSAGE_BODY_SIZE(m),
3107                strna(m->path),
3108                strna(m->interface),
3109                strna(m->member),
3110                strna(m->destination),
3111                strna(m->sender),
3112                strna(m->root_container.signature),
3113                m->reply_serial,
3114                strna(m->error.name),
3115                strna(m->error.message),
3116                yes_no(m->sealed));
3117
3118         if (m->pid != 0)
3119                 printf("\tpid=%lu\n", (unsigned long) m->pid);
3120         if (m->tid != 0)
3121                 printf("\ttid=%lu\n", (unsigned long) m->tid);
3122         if (m->uid_valid)
3123                 printf("\tuid=%lu\n", (unsigned long) m->uid);
3124         if (m->gid_valid)
3125                 printf("\tgid=%lu\n", (unsigned long) m->gid);
3126         if (m->pid_starttime != 0)
3127                 printf("\tpid_starttime=%llu\n", (unsigned long long) m->pid_starttime);
3128         if (m->monotonic != 0)
3129                 printf("\tmonotonic=%llu\n", (unsigned long long) m->monotonic);
3130         if (m->realtime != 0)
3131                 printf("\trealtime=%llu\n", (unsigned long long) m->realtime);
3132         if (m->exe)
3133                 printf("\texe=[%s]\n", m->exe);
3134         if (m->comm)
3135                 printf("\tcomm=[%s]\n", m->comm);
3136         if (m->tid_comm)
3137                 printf("\ttid_comm=[%s]\n", m->tid_comm);
3138         if (m->label)
3139                 printf("\tlabel=[%s]\n", m->label);
3140         if (m->cgroup)
3141                 printf("\tcgroup=[%s]\n", m->cgroup);
3142
3143         sd_bus_message_get_unit(m, &u);
3144         if (u)
3145                 printf("\tunit=[%s]\n", u);
3146         sd_bus_message_get_user_unit(m, &uu);
3147         if (uu)
3148                 printf("\tuser_unit=[%s]\n", uu);
3149         sd_bus_message_get_session(m, &s);
3150         if (s)
3151                 printf("\tsession=[%s]\n", s);
3152
3153         if (sd_bus_message_get_cmdline(m, &cmdline) >= 0) {
3154                 char **c;
3155
3156                 fputs("\tcmdline=[", stdout);
3157                 STRV_FOREACH(c, cmdline) {
3158                         if (c != cmdline)
3159                                 putchar(' ');
3160
3161                         fputs(*c, stdout);
3162                 }
3163
3164                 fputs("]\n", stdout);
3165         }
3166
3167         r = sd_bus_message_rewind(m, true);
3168         if (r < 0) {
3169                 log_error("Failed to rewind: %s", strerror(-r));
3170                 return r;
3171         }
3172
3173         printf("BEGIN_MESSAGE \"%s\" {\n", strempty(m->root_container.signature));
3174
3175         for(;;) {
3176                 _cleanup_free_ char *prefix = NULL;
3177                 const char *contents = NULL;
3178                 char type;
3179                 union {
3180                         uint8_t u8;
3181                         uint16_t u16;
3182                         int16_t s16;
3183                         uint32_t u32;
3184                         int32_t s32;
3185                         uint64_t u64;
3186                         int64_t s64;
3187                         double d64;
3188                         const char *string;
3189                         int i;
3190                 } basic;
3191
3192                 r = sd_bus_message_peek_type(m, &type, &contents);
3193                 if (r < 0) {
3194                         log_error("Failed to peek type: %s", strerror(-r));
3195                         return r;
3196                 }
3197                 if (r == 0) {
3198                         if (level <= 1)
3199                                 break;
3200
3201                         r = sd_bus_message_exit_container(m);
3202                         if (r < 0) {
3203                                 log_error("Failed to exit container: %s", strerror(-r));
3204                                 return r;
3205                         }
3206
3207                         level--;
3208
3209                         prefix = strrep("\t", level);
3210                         if (!prefix)
3211                                 return log_oom();
3212
3213                         if (type == SD_BUS_TYPE_ARRAY)
3214                                 printf("%s} END_ARRAY \n", prefix);
3215                         else if (type == SD_BUS_TYPE_VARIANT)
3216                                 printf("%s} END_VARIANT\n", prefix);
3217                         else if (type == SD_BUS_TYPE_STRUCT)
3218                                 printf("%s} END_STRUCT\n", prefix);
3219                         else if (type == SD_BUS_TYPE_DICT_ENTRY)
3220                                 printf("%s} END_DICT_ENTRY\n", prefix);
3221
3222                         continue;
3223                 }
3224
3225                 prefix = strrep("\t", level);
3226                 if (!prefix)
3227                         return log_oom();
3228
3229                 if (bus_type_is_container(type) > 0) {
3230                         r = sd_bus_message_enter_container(m, type, contents);
3231                         if (r < 0) {
3232                                 log_error("Failed to enter container: %s", strerror(-r));
3233                                 return r;
3234                         }
3235
3236                         if (type == SD_BUS_TYPE_ARRAY)
3237                                 printf("%sBEGIN_ARRAY \"%s\" {\n", prefix, contents);
3238                         else if (type == SD_BUS_TYPE_VARIANT)
3239                                 printf("%sBEGIN_VARIANT \"%s\" {\n", prefix, contents);
3240                         else if (type == SD_BUS_TYPE_STRUCT)
3241                                 printf("%sBEGIN_STRUCT \"%s\" {\n", prefix, contents);
3242                         else if (type == SD_BUS_TYPE_DICT_ENTRY)
3243                                 printf("%sBEGIN_DICT_ENTRY \"%s\" {\n", prefix, contents);
3244
3245                         level ++;
3246
3247                         continue;
3248                 }
3249
3250                 r = sd_bus_message_read_basic(m, type, &basic);
3251                 if (r < 0) {
3252                         log_error("Failed to get basic: %s", strerror(-r));
3253                         return r;
3254                 }
3255
3256                 switch (type) {
3257
3258                 case SD_BUS_TYPE_BYTE:
3259                         printf("%sBYTE: %u\n", prefix, basic.u8);
3260                         break;
3261
3262                 case SD_BUS_TYPE_BOOLEAN:
3263                         printf("%sBOOLEAN: %s\n", prefix, yes_no(basic.i));
3264                         break;
3265
3266                 case SD_BUS_TYPE_INT16:
3267                         printf("%sINT16: %i\n", prefix, basic.s16);
3268                         break;
3269
3270                 case SD_BUS_TYPE_UINT16:
3271                         printf("%sUINT16: %u\n", prefix, basic.u16);
3272                         break;
3273
3274                 case SD_BUS_TYPE_INT32:
3275                         printf("%sINT32: %i\n", prefix, basic.s32);
3276                         break;
3277
3278                 case SD_BUS_TYPE_UINT32:
3279                         printf("%sUINT32: %u\n", prefix, basic.u32);
3280                         break;
3281
3282                 case SD_BUS_TYPE_INT64:
3283                         printf("%sINT64: %lli\n", prefix, (long long) basic.s64);
3284                         break;
3285
3286                 case SD_BUS_TYPE_UINT64:
3287                         printf("%sUINT64: %llu\n", prefix, (unsigned long long) basic.u64);
3288                         break;
3289
3290                 case SD_BUS_TYPE_DOUBLE:
3291                         printf("%sDOUBLE: %g\n", prefix, basic.d64);
3292                         break;
3293
3294                 case SD_BUS_TYPE_STRING:
3295                         printf("%sSTRING: \"%s\"\n", prefix, basic.string);
3296                         break;
3297
3298                 case SD_BUS_TYPE_OBJECT_PATH:
3299                         printf("%sOBJECT_PATH: \"%s\"\n", prefix, basic.string);
3300                         break;
3301
3302                 case SD_BUS_TYPE_SIGNATURE:
3303                         printf("%sSIGNATURE: \"%s\"\n", prefix, basic.string);
3304                         break;
3305
3306                 case SD_BUS_TYPE_UNIX_FD:
3307                         printf("%sUNIX_FD: %i\n", prefix, basic.i);
3308                         break;
3309
3310                 default:
3311                         assert_not_reached("Unknown basic type.");
3312                 }
3313         }
3314
3315         printf("} END_MESSAGE\n");
3316         return 0;
3317 }
3318
3319 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz) {
3320         size_t total;
3321         void *p, *e;
3322
3323         assert(m);
3324         assert(buffer);
3325         assert(sz);
3326
3327         total = BUS_MESSAGE_SIZE(m);
3328
3329         p = malloc(total);
3330         if (!p)
3331                 return -ENOMEM;
3332
3333         e = mempcpy(p, m->header, sizeof(*m->header));
3334
3335         if (m->fields) {
3336                 e = mempcpy(e, m->fields, m->header->fields_size);
3337
3338                 if (m->header->fields_size % 8 != 0)
3339                         e = mempset(e, 0, 8 - (m->header->fields_size % 8));
3340         }
3341
3342         if (m->body)
3343                 e = mempcpy(e, m->body, m->header->body_size);
3344
3345         assert(total == (size_t) ((uint8_t*) e - (uint8_t*) p));
3346
3347         *buffer = p;
3348         *sz = total;
3349
3350         return 0;
3351 }
3352
3353 int bus_message_read_strv_extend(sd_bus_message *m, char ***l) {
3354         int r;
3355
3356         assert(m);
3357         assert(l);
3358
3359         r = sd_bus_message_enter_container(m, 'a', "s");
3360         if (r < 0)
3361                 return r;
3362
3363         for (;;) {
3364                 const char *s;
3365
3366                 r = sd_bus_message_read_basic(m, 's', &s);
3367                 if (r < 0)
3368                         return r;
3369                 if (r == 0)
3370                         break;
3371
3372                 r = strv_extend(l, s);
3373                 if (r < 0)
3374                         return r;
3375         }
3376
3377         r = sd_bus_message_exit_container(m);
3378         if (r < 0)
3379                 return r;
3380
3381         return 0;
3382 }
3383
3384 const char* bus_message_get_arg(sd_bus_message *m, unsigned i) {
3385         int r;
3386         const char *t = NULL;
3387         unsigned j;
3388
3389         assert(m);
3390
3391         r = sd_bus_message_rewind(m, true);
3392         if (r < 0)
3393                 return NULL;
3394
3395         for (j = 0; j <= i; j++) {
3396                 char type;
3397
3398                 r = sd_bus_message_peek_type(m, &type, NULL);
3399                 if (r < 0)
3400                         return NULL;
3401
3402                 if (type != SD_BUS_TYPE_STRING &&
3403                     type != SD_BUS_TYPE_OBJECT_PATH &&
3404                     type != SD_BUS_TYPE_SIGNATURE)
3405                         return NULL;
3406
3407                 r = sd_bus_message_read_basic(m, type, &t);
3408                 if (r < 0)
3409                         return NULL;
3410         }
3411
3412         return t;
3413 }
3414
3415 int bus_header_size(struct bus_header *h, size_t *sum) {
3416         size_t fs, bs;
3417
3418         assert(h);
3419         assert(sum);
3420
3421         if (h->endian == SD_BUS_NATIVE_ENDIAN) {
3422                 fs = h->fields_size;
3423                 bs = h->body_size;
3424         } else if (h->endian == SD_BUS_REVERSE_ENDIAN) {
3425                 fs = bswap_32(h->fields_size);
3426                 bs = bswap_32(h->body_size);
3427         } else
3428                 return -EBADMSG;
3429
3430         *sum = sizeof(struct bus_header) + ALIGN8(fs) + bs;
3431         return 0;
3432 }