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