src/libsystemd/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         size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
 140         unsigned n_header_offsets;
 141 };
 142
 143 static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
 144         return m->header->endian != BUS_NATIVE_ENDIAN;
 145 }
 146
 147 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 148         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 149 }
 150
 151 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 152         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 153 }
 154
 155 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 156         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 157 }
 158
 159 static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
 160         if (m->header->version == 2)
 161                 return BUS_MESSAGE_BSWAP64(m, m->header->dbus2.cookie);
 162
 163         return BUS_MESSAGE_BSWAP32(m, m->header->dbus1.serial);
 164 }
 165
 166 static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 167         return
 168                 sizeof(struct bus_header) +
 169                 ALIGN8(m->fields_size) +
 170                 m->body_size;
 171 }
 172
 173 static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 174         return
 175                 sizeof(struct bus_header) +
 176                 ALIGN8(m->fields_size);
 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_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 188 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 189
 190 int bus_message_from_header(
 191                 sd_bus *bus,
 192                 void *header,
 193                 size_t header_accessible,
 194                 void *footer,
 195                 size_t footer_accessible,
 196                 size_t message_size,
 197                 int *fds,
 198                 unsigned n_fds,
 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 char *label,
 210                 sd_bus_message **ret);
 211
 212 int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str);
 213 int bus_message_get_arg_strv(sd_bus_message *m, unsigned i, char ***strv);
 214
 215 int bus_message_parse_fields(sd_bus_message *m);
 216
 217 struct bus_body_part *message_append_part(sd_bus_message *m);
 218
 219 #define MESSAGE_FOREACH_PART(part, i, m) \
 220         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 221
 222 int bus_body_part_map(struct bus_body_part *part);
 223 void bus_body_part_unmap(struct bus_body_part *part);
 224
 225 int bus_message_to_errno(sd_bus_message *m);
 226
 227 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
 228
 229 int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
 230
 231 int bus_message_append_sender(sd_bus_message *m, const char *sender);
 232
 233 void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
 234 void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);