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