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