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