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