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