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