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