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