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