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         uint32_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
 102         bool sealed:1;
 103         bool dont_send:1;
 104         bool allow_fds:1;
 105         bool free_header:1;
 106         bool free_kdbus:1;
 107         bool free_fds:1;
 108         bool release_kdbus:1;
 109         bool poisoned:1;
 110
 111         struct bus_header *header;
 112         struct bus_body_part body;
 113         struct bus_body_part *body_end;
 114         unsigned n_body_parts;
 115
 116         size_t rindex;
 117         struct bus_body_part *cached_rindex_part;
 118         size_t cached_rindex_part_begin;
 119
 120         uint32_t n_fds;
 121         int *fds;
 122
 123         struct bus_container root_container, *containers;
 124         unsigned n_containers;
 125         size_t containers_allocated;
 126
 127         struct iovec *iovec;
 128         struct iovec iovec_fixed[2];
 129         unsigned n_iovec;
 130
 131         struct kdbus_msg *kdbus;
 132
 133         char *peeked_signature;
 134
 135         /* If set replies to this message must carry the signature
 136          * specified here to successfully seal. This is initialized
 137          * from the vtable data */
 138         const char *enforced_reply_signature;
 139
 140         usec_t timeout;
 141
 142         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 143         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 144
 145         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 146         unsigned n_header_offsets;
 147 };
 148
 149 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != BUS_NATIVE_ENDIAN)
 150
 151 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 152         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 153 }
 154
 155 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 156         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 157 }
 158
 159 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 160         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 161 }
 162
 163 static inline uint32_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
 164         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 165 }
 166
 167 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 168         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 169 }
 170
 171 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 172         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 173 }
 174
 175 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 176         return
 177                 sizeof(struct bus_header) +
 178                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 179                 BUS_MESSAGE_BODY_SIZE(m);
 180 }
 181
 182 static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 183         return
 184                 sizeof(struct bus_header) +
 185                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 186 }
 187
 188 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 189         return (uint8_t*) m->header + sizeof(struct bus_header);
 190 }
 191
 192 static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
 193         return m->header->version == 2;
 194 }
 195
 196 int bus_message_seal(sd_bus_message *m, uint64_t serial, usec_t timeout);
 197 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 198 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 199
 200 int bus_message_from_header(
 201                 sd_bus *bus,
 202                 void *header,
 203                 size_t length,
 204                 int *fds,
 205                 unsigned n_fds,
 206                 const struct ucred *ucred,
 207                 const char *label,
 208                 size_t extra,
 209                 sd_bus_message **ret);
 210
 211 int bus_message_from_malloc(
 212                 sd_bus *bus,
 213                 void *buffer,
 214                 size_t length,
 215                 int *fds,
 216                 unsigned n_fds,
 217                 const struct ucred *ucred,
 218                 const char *label,
 219                 sd_bus_message **ret);
 220
 221 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 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 bool bus_header_is_complete(struct bus_header *h, size_t size);
 228 int bus_header_message_size(struct bus_header *h, size_t *sum);
 229
 230 struct bus_body_part *message_append_part(sd_bus_message *m);
 231
 232 #define MESSAGE_FOREACH_PART(part, i, m) \
 233         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 234
 235 int bus_body_part_map(struct bus_body_part *part);
 236 void bus_body_part_unmap(struct bus_body_part *part);
 237
 238 int bus_message_to_errno(sd_bus_message *m);
 239
 240 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
 241
 242 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 243
 244 int bus_message_append_sender(sd_bus_message *m, const char *sender);