Line data Source code
1 : /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2 :
3 : #pragma once
4 :
5 : /***
6 : This file is part of systemd.
7 :
8 : Copyright 2013 Lennart Poettering
9 :
10 : systemd is free software; you can redistribute it and/or modify it
11 : under the terms of the GNU Lesser General Public License as published by
12 : the Free Software Foundation; either version 2.1 of the License, or
13 : (at your option) any later version.
14 :
15 : systemd is distributed in the hope that it will be useful, but
16 : WITHOUT ANY WARRANTY; without even the implied warranty of
17 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : Lesser General Public License for more details.
19 :
20 : You should have received a copy of the GNU Lesser General Public License
21 : along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 : ***/
23 :
24 : #include <stdbool.h>
25 : #include <byteswap.h>
26 : #include <sys/socket.h>
27 :
28 : #include "macro.h"
29 : #include "sd-bus.h"
30 : #include "time-util.h"
31 : #include "bus-creds.h"
32 : #include "bus-protocol.h"
33 :
34 : struct bus_container {
35 : char enclosing;
36 : bool need_offsets:1;
37 :
38 : /* Indexes into the signature string */
39 : unsigned index, saved_index;
40 : char *signature;
41 :
42 : size_t before, begin, end;
43 :
44 : /* dbus1: pointer to the array size value, if this is a value */
45 : uint32_t *array_size;
46 :
47 : /* gvariant: list of offsets to end of children if this is struct/dict entry/array */
48 : size_t *offsets, n_offsets, offsets_allocated, offset_index;
49 : size_t item_size;
50 :
51 : char *peeked_signature;
52 : };
53 :
54 : struct bus_body_part {
55 : struct bus_body_part *next;
56 : void *data;
57 : void *mmap_begin;
58 : size_t size;
59 : size_t mapped;
60 : size_t allocated;
61 : uint64_t memfd_offset;
62 : int memfd;
63 : bool free_this:1;
64 : bool munmap_this:1;
65 : bool sealed:1;
66 : bool is_zero:1;
67 : };
68 :
69 : struct sd_bus_message {
70 : unsigned n_ref;
71 :
72 : sd_bus *bus;
73 :
74 : uint64_t reply_cookie;
75 :
76 : const char *path;
77 : const char *interface;
78 : const char *member;
79 : const char *destination;
80 : const char *sender;
81 :
82 : sd_bus_error error;
83 :
84 : sd_bus_creds creds;
85 :
86 : usec_t monotonic;
87 : usec_t realtime;
88 : uint64_t seqnum;
89 : int64_t priority;
90 : uint64_t verify_destination_id;
91 :
92 : bool sealed:1;
93 : bool dont_send:1;
94 : bool allow_fds:1;
95 : bool free_header:1;
96 : bool free_kdbus:1;
97 : bool free_fds:1;
98 : bool release_kdbus:1;
99 : bool poisoned:1;
100 :
101 : /* The first and last bytes of the message */
102 : struct bus_header *header;
103 : void *footer;
104 :
105 : /* How many bytes are accessible in the above pointers */
106 : size_t header_accessible;
107 : size_t footer_accessible;
108 :
109 : size_t fields_size;
110 : size_t body_size;
111 : size_t user_body_size;
112 :
113 : struct bus_body_part body;
114 : struct bus_body_part *body_end;
115 : unsigned n_body_parts;
116 :
117 : size_t rindex;
118 : struct bus_body_part *cached_rindex_part;
119 : size_t cached_rindex_part_begin;
120 :
121 : uint32_t n_fds;
122 : int *fds;
123 :
124 : struct bus_container root_container, *containers;
125 : size_t n_containers;
126 : size_t containers_allocated;
127 :
128 : struct iovec *iovec;
129 : struct iovec iovec_fixed[2];
130 : unsigned n_iovec;
131 :
132 : struct kdbus_msg *kdbus;
133 :
134 : char *peeked_signature;
135 :
136 : /* If set replies to this message must carry the signature
137 : * specified here to successfully seal. This is initialized
138 : * from the vtable data */
139 : const char *enforced_reply_signature;
140 :
141 : usec_t timeout;
142 :
143 : char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
144 : char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
145 : char *destination_ptr;
146 :
147 : size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
148 : unsigned n_header_offsets;
149 : };
150 :
151 93952 : static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
152 93952 : return m->header->endian != BUS_NATIVE_ENDIAN;
153 : }
154 :
155 0 : static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
156 0 : return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
157 : }
158 :
159 809 : static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
160 809 : return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
161 : }
162 :
163 77658 : static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
164 77658 : return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
165 : }
166 :
167 15701 : static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
168 15701 : if (m->header->version == 2)
169 15576 : return BUS_MESSAGE_BSWAP64(m, m->header->dbus2.cookie);
170 :
171 125 : return BUS_MESSAGE_BSWAP32(m, m->header->dbus1.serial);
172 : }
173 :
174 15733 : static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
175 : return
176 15733 : sizeof(struct bus_header) +
177 31466 : ALIGN8(m->fields_size) +
178 15733 : m->body_size;
179 : }
180 :
181 61277 : static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
182 : return
183 61277 : sizeof(struct bus_header) +
184 61277 : ALIGN8(m->fields_size);
185 : }
186 :
187 233831 : static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
188 233831 : return (uint8_t*) m->header + sizeof(struct bus_header);
189 : }
190 :
191 440344 : static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
192 440344 : return m->header->version == 2;
193 : }
194 :
195 : int bus_message_seal(sd_bus_message *m, uint64_t serial, usec_t timeout);
196 : int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
197 : int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
198 :
199 : int bus_message_from_header(
200 : sd_bus *bus,
201 : void *header,
202 : size_t header_accessible,
203 : void *footer,
204 : size_t footer_accessible,
205 : size_t message_size,
206 : int *fds,
207 : unsigned n_fds,
208 : const char *label,
209 : size_t extra,
210 : sd_bus_message **ret);
211 :
212 : int bus_message_from_malloc(
213 : sd_bus *bus,
214 : void *buffer,
215 : size_t length,
216 : int *fds,
217 : unsigned n_fds,
218 : const char *label,
219 : sd_bus_message **ret);
220 :
221 : int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str, char ***strv);
222 :
223 : int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
224 :
225 : int bus_message_parse_fields(sd_bus_message *m);
226 :
227 : struct bus_body_part *message_append_part(sd_bus_message *m);
228 :
229 : #define MESSAGE_FOREACH_PART(part, i, m) \
230 : for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
231 :
232 : int bus_body_part_map(struct bus_body_part *part);
233 : void bus_body_part_unmap(struct bus_body_part *part);
234 :
235 : int bus_message_to_errno(sd_bus_message *m);
236 :
237 : int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
238 :
239 : int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
240 :
241 : int bus_message_append_sender(sd_bus_message *m, const char *sender);
242 :
243 : void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
244 : void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);
|
