src/libsystemd/sd-bus/bus-message.h

   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 "kdbus.h"
  31 #include "time-util.h"
  32 #include "bus-creds.h"
  33 #include "bus-protocol.h"
  34
  35 struct bus_container {
  36         char enclosing;
  37         bool need_offsets:1;
  38
  39         /* Indexes into the signature  string */
  40         unsigned index, saved_index;
  41         char *signature;
  42
  43         size_t before, begin, end;
  44
  45         /* dbus1: pointer to the array size value, if this is a value */
  46         uint32_t *array_size;
  47
  48         /* gvariant: list of offsets to end of children if this is struct/dict entry/array */
  49         size_t *offsets, n_offsets, offsets_allocated, offset_index;
  50         size_t item_size;
  51
  52         char *peeked_signature;
  53 };
  54
  55 struct bus_header {
  56         uint8_t endian;
  57         uint8_t type;
  58         uint8_t flags;
  59         uint8_t version;
  60         uint32_t body_size;
  61
  62         /* Note that what the bus spec calls "serial" we'll call
  63         "cookie" instead, because we don't want to imply that the
  64         cookie was in any way monotonically increasing. */
  65         uint32_t serial;
  66         uint32_t fields_size;
  67 } _packed_;
  68
  69 struct bus_body_part {
  70         struct bus_body_part *next;
  71         void *data;
  72         size_t size;
  73         size_t mapped;
  74         size_t allocated;
  75         int memfd;
  76         bool free_this:1;
  77         bool munmap_this:1;
  78         bool sealed:1;
  79         bool is_zero:1;
  80 };
  81
  82 struct sd_bus_message {
  83         unsigned n_ref;
  84
  85         sd_bus *bus;
  86
  87         uint64_t reply_cookie;
  88
  89         const char *path;
  90         const char *interface;
  91         const char *member;
  92         const char *destination;
  93         const char *sender;
  94
  95         sd_bus_error error;
  96
  97         sd_bus_creds creds;
  98
  99         usec_t monotonic;
 100         usec_t realtime;
 101         uint64_t seqnum;
 102         int64_t priority;
 103         uint64_t verify_destination_id;
 104
 105         bool sealed:1;
 106         bool dont_send:1;
 107         bool allow_fds:1;
 108         bool free_header:1;
 109         bool free_kdbus:1;
 110         bool free_fds:1;
 111         bool release_kdbus:1;
 112         bool poisoned:1;
 113
 114         struct bus_header *header;
 115         struct bus_body_part body;
 116         struct bus_body_part *body_end;
 117         unsigned n_body_parts;
 118
 119         size_t rindex;
 120         struct bus_body_part *cached_rindex_part;
 121         size_t cached_rindex_part_begin;
 122
 123         uint32_t n_fds;
 124         int *fds;
 125
 126         struct bus_container root_container, *containers;
 127         unsigned n_containers;
 128         size_t containers_allocated;
 129
 130         struct iovec *iovec;
 131         struct iovec iovec_fixed[2];
 132         unsigned n_iovec;
 133
 134         struct kdbus_msg *kdbus;
 135
 136         char *peeked_signature;
 137
 138         /* If set replies to this message must carry the signature
 139          * specified here to successfully seal. This is initialized
 140          * from the vtable data */
 141         const char *enforced_reply_signature;
 142
 143         usec_t timeout;
 144
 145         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 146         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 147         char *destination_ptr;
 148
 149         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 150         unsigned n_header_offsets;
 151 };
 152
 153 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != BUS_NATIVE_ENDIAN)
 154
 155 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 156         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 157 }
 158
 159 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 160         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 161 }
 162
 163 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 164         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 165 }
 166
 167 static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
 168         /* Note that we return the serial converted to a 64bit value here */
 169         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 170 }
 171
 172 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 173         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 174 }
 175
 176 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 177         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 178 }
 179
 180 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 181         return
 182                 sizeof(struct bus_header) +
 183                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 184                 BUS_MESSAGE_BODY_SIZE(m);
 185 }
 186
 187 static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 188         return
 189                 sizeof(struct bus_header) +
 190                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 191 }
 192
 193 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 194         return (uint8_t*) m->header + sizeof(struct bus_header);
 195 }
 196
 197 static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
 198         return m->header->version == 2;
 199 }
 200
 201 int bus_message_seal(sd_bus_message *m, uint64_t serial, usec_t timeout);
 202 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 203 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 204
 205 int bus_message_from_header(
 206                 sd_bus *bus,
 207                 void *header,
 208                 size_t length,
 209                 int *fds,
 210                 unsigned n_fds,
 211                 const struct ucred *ucred,
 212                 const char *label,
 213                 size_t extra,
 214                 sd_bus_message **ret);
 215
 216 int bus_message_from_malloc(
 217                 sd_bus *bus,
 218                 void *buffer,
 219                 size_t length,
 220                 int *fds,
 221                 unsigned n_fds,
 222                 const struct ucred *ucred,
 223                 const char *label,
 224                 sd_bus_message **ret);
 225
 226 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 227
 228 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 229
 230 int bus_message_parse_fields(sd_bus_message *m);
 231
 232 bool bus_header_is_complete(struct bus_header *h, size_t size);
 233 int bus_header_message_size(struct bus_header *h, size_t *sum);
 234
 235 struct bus_body_part *message_append_part(sd_bus_message *m);
 236
 237 #define MESSAGE_FOREACH_PART(part, i, m) \
 238         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 239
 240 int bus_body_part_map(struct bus_body_part *part);
 241 void bus_body_part_unmap(struct bus_body_part *part);
 242
 243 int bus_message_to_errno(sd_bus_message *m);
 244
 245 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
 246
 247 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 248
 249 int bus_message_append_sender(sd_bus_message *m, const char *sender);