Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : #pragma once
3 :
4 : #include <byteswap.h>
5 : #include <stdbool.h>
6 : #include <sys/socket.h>
7 :
8 : #include "sd-bus.h"
9 :
10 : #include "bus-creds.h"
11 : #include "bus-protocol.h"
12 : #include "macro.h"
13 : #include "time-util.h"
14 :
15 : struct bus_container {
16 : char enclosing;
17 : bool need_offsets:1;
18 :
19 : /* Indexes into the signature string */
20 : unsigned index, saved_index;
21 : char *signature;
22 :
23 : size_t before, begin, end;
24 :
25 : /* dbus1: pointer to the array size value, if this is a value */
26 : uint32_t *array_size;
27 :
28 : /* gvariant: list of offsets to end of children if this is struct/dict entry/array */
29 : size_t *offsets, n_offsets, offsets_allocated, offset_index;
30 : size_t item_size;
31 :
32 : char *peeked_signature;
33 : };
34 :
35 : struct bus_body_part {
36 : struct bus_body_part *next;
37 : void *data;
38 : void *mmap_begin;
39 : size_t size;
40 : size_t mapped;
41 : size_t allocated;
42 : uint64_t memfd_offset;
43 : int memfd;
44 : bool free_this:1;
45 : bool munmap_this:1;
46 : bool sealed:1;
47 : bool is_zero:1;
48 : };
49 :
50 : struct sd_bus_message {
51 : /* Caveat: a message can be referenced in two different ways: the main (user-facing) way will also
52 : * pin the bus connection object the message is associated with. The secondary way ("queued") is used
53 : * when a message is in the read or write queues of the bus connection object, which will not pin the
54 : * bus connection object. This is necessary so that we don't have to have a pair of cyclic references
55 : * between a message that is queued and its connection: as soon as a message is only referenced by
56 : * the connection (by means of being queued) and the connection itself has no other references it
57 : * will be freed. */
58 :
59 : unsigned n_ref; /* Counter of references that pin the connection */
60 : unsigned n_queued; /* Counter of references that do not pin the connection */
61 :
62 : sd_bus *bus;
63 :
64 : uint64_t reply_cookie;
65 :
66 : const char *path;
67 : const char *interface;
68 : const char *member;
69 : const char *destination;
70 : const char *sender;
71 :
72 : sd_bus_error error;
73 :
74 : sd_bus_creds creds;
75 :
76 : usec_t monotonic;
77 : usec_t realtime;
78 : uint64_t seqnum;
79 : int64_t priority;
80 : uint64_t verify_destination_id;
81 :
82 : bool sealed:1;
83 : bool dont_send:1;
84 : bool allow_fds:1;
85 : bool free_header:1;
86 : bool free_fds:1;
87 : bool poisoned:1;
88 :
89 : /* The first and last bytes of the message */
90 : struct bus_header *header;
91 : void *footer;
92 :
93 : /* How many bytes are accessible in the above pointers */
94 : size_t header_accessible;
95 : size_t footer_accessible;
96 :
97 : size_t fields_size;
98 : size_t body_size;
99 : size_t user_body_size;
100 :
101 : struct bus_body_part body;
102 : struct bus_body_part *body_end;
103 : unsigned n_body_parts;
104 :
105 : size_t rindex;
106 : struct bus_body_part *cached_rindex_part;
107 : size_t cached_rindex_part_begin;
108 :
109 : uint32_t n_fds;
110 : int *fds;
111 :
112 : struct bus_container root_container, *containers;
113 : size_t n_containers;
114 : size_t containers_allocated;
115 :
116 : struct iovec *iovec;
117 : struct iovec iovec_fixed[2];
118 : unsigned n_iovec;
119 :
120 : char *peeked_signature;
121 :
122 : /* If set replies to this message must carry the signature
123 : * specified here to successfully seal. This is initialized
124 : * from the vtable data */
125 : const char *enforced_reply_signature;
126 :
127 : usec_t timeout;
128 :
129 : size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
130 : unsigned n_header_offsets;
131 :
132 : uint64_t read_counter;
133 : };
134 :
135 2201 : static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
136 2201 : return m->header->endian != BUS_NATIVE_ENDIAN;
137 : }
138 :
139 0 : static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
140 0 : return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
141 : }
142 :
143 2159 : static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
144 2159 : return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
145 : }
146 :
147 40 : static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
148 40 : return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
149 : }
150 :
151 327 : static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
152 327 : if (m->header->version == 2)
153 6 : return BUS_MESSAGE_BSWAP64(m, m->header->dbus2.cookie);
154 :
155 321 : return BUS_MESSAGE_BSWAP32(m, m->header->dbus1.serial);
156 : }
157 :
158 405 : static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
159 : return
160 : sizeof(struct bus_header) +
161 1215 : ALIGN8(m->fields_size) +
162 405 : m->body_size;
163 : }
164 :
165 136 : static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
166 : return
167 272 : sizeof(struct bus_header) +
168 136 : ALIGN8(m->fields_size);
169 : }
170 :
171 2724 : static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
172 2724 : return (uint8_t*) m->header + sizeof(struct bus_header);
173 : }
174 :
175 7276 : static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
176 7276 : return m->header->version == 2;
177 : }
178 :
179 : int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
180 : int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
181 :
182 : int bus_message_from_header(
183 : sd_bus *bus,
184 : void *header,
185 : size_t header_accessible,
186 : void *footer,
187 : size_t footer_accessible,
188 : size_t message_size,
189 : int *fds,
190 : size_t n_fds,
191 : const char *label,
192 : size_t extra,
193 : sd_bus_message **ret);
194 :
195 : int bus_message_from_malloc(
196 : sd_bus *bus,
197 : void *buffer,
198 : size_t length,
199 : int *fds,
200 : size_t n_fds,
201 : const char *label,
202 : sd_bus_message **ret);
203 :
204 : int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str);
205 : int bus_message_get_arg_strv(sd_bus_message *m, unsigned i, char ***strv);
206 :
207 : int bus_message_parse_fields(sd_bus_message *m);
208 :
209 : struct bus_body_part *message_append_part(sd_bus_message *m);
210 :
211 : #define MESSAGE_FOREACH_PART(part, i, m) \
212 : for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
213 :
214 : int bus_body_part_map(struct bus_body_part *part);
215 : void bus_body_part_unmap(struct bus_body_part *part);
216 :
217 : int bus_message_to_errno(sd_bus_message *m);
218 :
219 : int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
220 :
221 : int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
222 :
223 : void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
224 : void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);
225 :
226 : sd_bus_message* bus_message_ref_queued(sd_bus_message *m, sd_bus *bus);
227 : sd_bus_message* bus_message_unref_queued(sd_bus_message *m, sd_bus *bus);
|
