src/libsystemd-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         uint32_t serial;
  62         uint32_t fields_size;
  63 } _packed_;
  64
  65 struct bus_body_part {
  66         struct bus_body_part *next;
  67         void *data;
  68         size_t size;
  69         size_t mapped;
  70         size_t allocated;
  71         int memfd;
  72         bool free_this:1;
  73         bool munmap_this:1;
  74         bool sealed:1;
  75         bool is_zero:1;
  76 };
  77
  78 struct sd_bus_message {
  79         unsigned n_ref;
  80
  81         sd_bus *bus;
  82
  83         uint32_t reply_serial;
  84
  85         const char *path;
  86         const char *interface;
  87         const char *member;
  88         const char *destination;
  89         const char *sender;
  90
  91         sd_bus_error error;
  92
  93         sd_bus_creds creds;
  94
  95         usec_t monotonic;
  96         usec_t realtime;
  97
  98         bool sealed:1;
  99         bool dont_send:1;
 100         bool allow_fds:1;
 101         bool free_header:1;
 102         bool free_kdbus:1;
 103         bool free_fds:1;
 104         bool release_kdbus:1;
 105         bool poisoned:1;
 106
 107         struct bus_header *header;
 108         struct bus_body_part body;
 109         struct bus_body_part *body_end;
 110         unsigned n_body_parts;
 111
 112         size_t rindex;
 113         struct bus_body_part *cached_rindex_part;
 114         size_t cached_rindex_part_begin;
 115
 116         uint32_t n_fds;
 117         int *fds;
 118
 119         struct bus_container root_container, *containers;
 120         unsigned n_containers;
 121         size_t containers_allocated;
 122
 123         struct iovec *iovec;
 124         struct iovec iovec_fixed[2];
 125         unsigned n_iovec;
 126
 127         struct kdbus_msg *kdbus;
 128
 129         char *peeked_signature;
 130
 131         /* If set replies to this message must carry the signature
 132          * specified here to successfully seal. This is initialized
 133          * from the vtable data */
 134         const char *enforced_reply_signature;
 135
 136         usec_t timeout;
 137
 138         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 139         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 140
 141         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 142         unsigned n_header_offsets;
 143 };
 144
 145 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != BUS_NATIVE_ENDIAN)
 146
 147 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 148         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 149 }
 150
 151 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 152         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 153 }
 154
 155 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 156         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 157 }
 158
 159 static inline uint32_t BUS_MESSAGE_SERIAL(sd_bus_message *m) {
 160         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 161 }
 162
 163 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 164         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 165 }
 166
 167 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 168         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 169 }
 170
 171 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 172         return
 173                 sizeof(struct bus_header) +
 174                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 175                 BUS_MESSAGE_BODY_SIZE(m);
 176 }
 177
 178 static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 179         return
 180                 sizeof(struct bus_header) +
 181                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 182 }
 183
 184 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 185         return (uint8_t*) m->header + sizeof(struct bus_header);
 186 }
 187
 188 static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
 189         return m->header->version == 2;
 190 }
 191
 192 int bus_message_seal(sd_bus_message *m, uint64_t serial, usec_t timeout);
 193 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 194 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 195
 196 int bus_message_from_header(
 197                 sd_bus *bus,
 198                 void *header,
 199                 size_t length,
 200                 int *fds,
 201                 unsigned n_fds,
 202                 const struct ucred *ucred,
 203                 const char *label,
 204                 size_t extra,
 205                 sd_bus_message **ret);
 206
 207 int bus_message_from_malloc(
 208                 sd_bus *bus,
 209                 void *buffer,
 210                 size_t length,
 211                 int *fds,
 212                 unsigned n_fds,
 213                 const struct ucred *ucred,
 214                 const char *label,
 215                 sd_bus_message **ret);
 216
 217 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 218
 219 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 220
 221 int bus_message_parse_fields(sd_bus_message *m);
 222
 223 bool bus_header_is_complete(struct bus_header *h, size_t size);
 224 int bus_header_message_size(struct bus_header *h, size_t *sum);
 225
 226 struct bus_body_part *message_append_part(sd_bus_message *m);
 227
 228 #define MESSAGE_FOREACH_PART(part, i, m) \
 229         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 230
 231 int bus_body_part_map(struct bus_body_part *part);
 232 void bus_body_part_unmap(struct bus_body_part *part);
 233
 234 int bus_message_to_errno(sd_bus_message *m);
 235
 236 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
 237
 238 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 239
 240 int bus_message_append_sender(sd_bus_message *m, const char *sender);