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
  27 #include "macro.h"
  28 #include "sd-bus.h"
  29 #include "time-util.h"
  30 #include "bus-creds.h"
  31 #include "bus-protocol.h"
  32
  33 struct bus_container {
  34         char enclosing;
  35         bool need_offsets:1;
  36
  37         /* Indexes into the signature  string */
  38         unsigned index, saved_index;
  39         char *signature;
  40
  41         size_t before, begin, end;
  42
  43         /* dbus1: pointer to the array size value, if this is a value */
  44         uint32_t *array_size;
  45
  46         /* gvariant: list of offsets to end of children if this is struct/dict entry/array */
  47         size_t *offsets, n_offsets, offsets_allocated, offset_index;
  48         size_t item_size;
  49
  50         char *peeked_signature;
  51 };
  52
  53 struct bus_body_part {
  54         struct bus_body_part *next;
  55         void *data;
  56         void *mmap_begin;
  57         size_t size;
  58         size_t mapped;
  59         size_t allocated;
  60         uint64_t memfd_offset;
  61         int memfd;
  62         bool free_this:1;
  63         bool munmap_this:1;
  64         bool sealed:1;
  65         bool is_zero:1;
  66 };
  67
  68 struct sd_bus_message {
  69         unsigned n_ref;
  70
  71         sd_bus *bus;
  72
  73         uint64_t reply_cookie;
  74
  75         const char *path;
  76         const char *interface;
  77         const char *member;
  78         const char *destination;
  79         const char *sender;
  80
  81         sd_bus_error error;
  82
  83         sd_bus_creds creds;
  84
  85         usec_t monotonic;
  86         usec_t realtime;
  87         uint64_t seqnum;
  88         int64_t priority;
  89         uint64_t verify_destination_id;
  90
  91         bool sealed:1;
  92         bool dont_send:1;
  93         bool allow_fds:1;
  94         bool free_header:1;
  95         bool free_kdbus:1;
  96         bool free_fds:1;
  97         bool release_kdbus:1;
  98         bool poisoned:1;
  99
 100         /* The first and last bytes of the message */
 101         struct bus_header *header;
 102         void *footer;
 103
 104         /* How many bytes are accessible in the above pointers */
 105         size_t header_accessible;
 106         size_t footer_accessible;
 107
 108         size_t fields_size;
 109         size_t body_size;
 110         size_t user_body_size;
 111
 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         size_t 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         char *destination_ptr;
 145
 146         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 147         unsigned n_header_offsets;
 148 };
 149
 150 static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
 151         return m->header->endian != BUS_NATIVE_ENDIAN;
 152 }
 153
 154 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 155         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 156 }
 157
 158 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 159         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 160 }
 161
 162 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 163         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 164 }
 165
 166 static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
 167         if (m->header->version == 2)
 168                 return BUS_MESSAGE_BSWAP64(m, m->header->dbus2.cookie);
 169
 170         return BUS_MESSAGE_BSWAP32(m, m->header->dbus1.serial);
 171 }
 172
 173 static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 174         return
 175                 sizeof(struct bus_header) +
 176                 ALIGN8(m->fields_size) +
 177                 m->body_size;
 178 }
 179
 180 static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 181         return
 182                 sizeof(struct bus_header) +
 183                 ALIGN8(m->fields_size);
 184 }
 185
 186 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 187         return (uint8_t*) m->header + sizeof(struct bus_header);
 188 }
 189
 190 static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
 191         return m->header->version == 2;
 192 }
 193
 194 int bus_message_seal(sd_bus_message *m, uint64_t serial, usec_t timeout);
 195 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 196 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 197
 198 int bus_message_from_header(
 199                 sd_bus *bus,
 200                 void *header,
 201                 size_t header_accessible,
 202                 void *footer,
 203                 size_t footer_accessible,
 204                 size_t message_size,
 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 int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str, char ***strv);
 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 struct bus_body_part *message_append_part(sd_bus_message *m);
 229
 230 #define MESSAGE_FOREACH_PART(part, i, m) \
 231         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 232
 233 int bus_body_part_map(struct bus_body_part *part);
 234 void bus_body_part_unmap(struct bus_body_part *part);
 235
 236 int bus_message_to_errno(sd_bus_message *m);
 237
 238 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
 239
 240 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 241
 242 int bus_message_append_sender(sd_bus_message *m, const char *sender);
 243
 244 void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
 245 void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);