src/libelogind/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 "time-util.h"
  31 #include "bus-creds.h"
  32 #include "bus-protocol.h"
  33
  34 struct bus_container {
  35         char enclosing;
  36         bool need_offsets:1;
  37
  38         /* Indexes into the signature  string */
  39         unsigned index, saved_index;
  40         char *signature;
  41
  42         size_t before, begin, end;
  43
  44         /* dbus1: pointer to the array size value, if this is a value */
  45         uint32_t *array_size;
  46
  47         /* gvariant: list of offsets to end of children if this is struct/dict entry/array */
  48         size_t *offsets, n_offsets, offsets_allocated, offset_index;
  49         size_t item_size;
  50
  51         char *peeked_signature;
  52 };
  53
  54 struct bus_body_part {
  55         struct bus_body_part *next;
  56         void *data;
  57         void *mmap_begin;
  58         size_t size;
  59         size_t mapped;
  60         size_t allocated;
  61         uint64_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         /* The first and last bytes of the message */
 102         struct bus_header *header;
 103         void *footer;
 104
 105         /* How many bytes are accessible in the above pointers */
 106         size_t header_accessible;
 107         size_t footer_accessible;
 108
 109         size_t fields_size;
 110         size_t body_size;
 111         size_t user_body_size;
 112
 113         struct bus_body_part body;
 114         struct bus_body_part *body_end;
 115         unsigned n_body_parts;
 116
 117         size_t rindex;
 118         struct bus_body_part *cached_rindex_part;
 119         size_t cached_rindex_part_begin;
 120
 121         uint32_t n_fds;
 122         int *fds;
 123
 124         struct bus_container root_container, *containers;
 125         size_t n_containers;
 126         size_t containers_allocated;
 127
 128         struct iovec *iovec;
 129         struct iovec iovec_fixed[2];
 130         unsigned n_iovec;
 131
 132         struct kdbus_msg *kdbus;
 133
 134         char *peeked_signature;
 135
 136         /* If set replies to this message must carry the signature
 137          * specified here to successfully seal. This is initialized
 138          * from the vtable data */
 139         const char *enforced_reply_signature;
 140
 141         usec_t timeout;
 142
 143         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 144         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 145         char *destination_ptr;
 146
 147         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 148         unsigned n_header_offsets;
 149 };
 150
 151 static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
 152         return m->header->endian != BUS_NATIVE_ENDIAN;
 153 }
 154
 155 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 156         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 157 }
 158
 159 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 160         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 161 }
 162
 163 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 164         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 165 }
 166
 167 static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
 168         if (m->header->version == 2)
 169                 return BUS_MESSAGE_BSWAP64(m, m->header->dbus2.cookie);
 170
 171         return BUS_MESSAGE_BSWAP32(m, m->header->dbus1.serial);
 172 }
 173
 174 static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 175         return
 176                 sizeof(struct bus_header) +
 177                 ALIGN8(m->fields_size) +
 178                 m->body_size;
 179 }
 180
 181 static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 182         return
 183                 sizeof(struct bus_header) +
 184                 ALIGN8(m->fields_size);
 185 }
 186
 187 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 188         return (uint8_t*) m->header + sizeof(struct bus_header);
 189 }
 190
 191 static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
 192         return m->header->version == 2;
 193 }
 194
 195 int bus_message_seal(sd_bus_message *m, uint64_t serial, usec_t timeout);
 196 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 197 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 198
 199 int bus_message_from_header(
 200                 sd_bus *bus,
 201                 void *header,
 202                 size_t header_accessible,
 203                 void *footer,
 204                 size_t footer_accessible,
 205                 size_t message_size,
 206                 int *fds,
 207                 unsigned n_fds,
 208                 const struct ucred *ucred,
 209                 const char *label,
 210                 size_t extra,
 211                 sd_bus_message **ret);
 212
 213 int bus_message_from_malloc(
 214                 sd_bus *bus,
 215                 void *buffer,
 216                 size_t length,
 217                 int *fds,
 218                 unsigned n_fds,
 219                 const struct ucred *ucred,
 220                 const char *label,
 221                 sd_bus_message **ret);
 222
 223 int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str, char ***strv);
 224
 225 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 226
 227 int bus_message_parse_fields(sd_bus_message *m);
 228
 229 struct bus_body_part *message_append_part(sd_bus_message *m);
 230
 231 #define MESSAGE_FOREACH_PART(part, i, m) \
 232         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 233
 234 int bus_body_part_map(struct bus_body_part *part);
 235 void bus_body_part_unmap(struct bus_body_part *part);
 236
 237 int bus_message_to_errno(sd_bus_message *m);
 238
 239 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
 240
 241 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 242
 243 int bus_message_append_sender(sd_bus_message *m, const char *sender);
 244
 245 void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
 246 void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);