src/libelogind/sd-bus/bus-message.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2013 Lennart Poettering
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <byteswap.h>
  24 #include <stdbool.h>
  25 #include <sys/socket.h>
  26
  27 #include "sd-bus.h"
  28
  29 #include "bus-creds.h"
  30 #include "bus-protocol.h"
  31 #include "macro.h"
  32 #include "time-util.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_fds:1;
  97         bool poisoned:1;
  98
  99         /* The first and last bytes of the message */
 100         struct bus_header *header;
 101         void *footer;
 102
 103         /* How many bytes are accessible in the above pointers */
 104         size_t header_accessible;
 105         size_t footer_accessible;
 106
 107         size_t fields_size;
 108         size_t body_size;
 109         size_t user_body_size;
 110
 111         struct bus_body_part body;
 112         struct bus_body_part *body_end;
 113         unsigned n_body_parts;
 114
 115         size_t rindex;
 116         struct bus_body_part *cached_rindex_part;
 117         size_t cached_rindex_part_begin;
 118
 119         uint32_t n_fds;
 120         int *fds;
 121
 122         struct bus_container root_container, *containers;
 123         size_t n_containers;
 124         size_t containers_allocated;
 125
 126         struct iovec *iovec;
 127         struct iovec iovec_fixed[2];
 128         unsigned n_iovec;
 129
 130         char *peeked_signature;
 131
 132         /* If set replies to this message must carry the signature
 133          * specified here to successfully seal. This is initialized
 134          * from the vtable data */
 135         const char *enforced_reply_signature;
 136
 137         usec_t timeout;
 138
 139         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 140         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 141         char *destination_ptr;
 142
 143         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 144         unsigned n_header_offsets;
 145 };
 146
 147 static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
 148         return m->header->endian != BUS_NATIVE_ENDIAN;
 149 }
 150
 151 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 152         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 153 }
 154
 155 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 156         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 157 }
 158
 159 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 160         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 161 }
 162
 163 static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
 164         if (m->header->version == 2)
 165                 return BUS_MESSAGE_BSWAP64(m, m->header->dbus2.cookie);
 166
 167         return BUS_MESSAGE_BSWAP32(m, m->header->dbus1.serial);
 168 }
 169
 170 static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 171         return
 172                 sizeof(struct bus_header) +
 173                 ALIGN8(m->fields_size) +
 174                 m->body_size;
 175 }
 176
 177 static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 178         return
 179                 sizeof(struct bus_header) +
 180                 ALIGN8(m->fields_size);
 181 }
 182
 183 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 184         return (uint8_t*) m->header + sizeof(struct bus_header);
 185 }
 186
 187 static inline bool BUS_MESSAGE_IS_GVARIANT(sd_bus_message *m) {
 188         return m->header->version == 2;
 189 }
 190
 191 #if 0 /// UNNEEDED by elogind
 192 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 193 #endif // 0
 194 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 195
 196 int bus_message_from_header(
 197                 sd_bus *bus,
 198                 void *header,
 199                 size_t header_accessible,
 200                 void *footer,
 201                 size_t footer_accessible,
 202                 size_t message_size,
 203                 int *fds,
 204                 unsigned n_fds,
 205                 const char *label,
 206                 size_t extra,
 207                 sd_bus_message **ret);
 208
 209 int bus_message_from_malloc(
 210                 sd_bus *bus,
 211                 void *buffer,
 212                 size_t length,
 213                 int *fds,
 214                 unsigned n_fds,
 215                 const char *label,
 216                 sd_bus_message **ret);
 217
 218 int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str);
 219 int bus_message_get_arg_strv(sd_bus_message *m, unsigned i, char ***strv);
 220
 221 int bus_message_parse_fields(sd_bus_message *m);
 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 #if 0 /// UNNEEDED by elogind
 238 int bus_message_append_sender(sd_bus_message *m, const char *sender);
 239 #endif // 0
 240
 241 void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
 242 void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);