src/libsystemd-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
  34 struct bus_container {
  35         char enclosing;
  36
  37         unsigned index, saved_index;
  38
  39         char *signature;
  40
  41         uint32_t *array_size;
  42         size_t before, begin;
  43 };
  44
  45 struct bus_header {
  46         uint8_t endian;
  47         uint8_t type;
  48         uint8_t flags;
  49         uint8_t version;
  50         uint32_t body_size;
  51         uint32_t serial;
  52         uint32_t fields_size;
  53 } _packed_;
  54
  55 struct bus_body_part {
  56         struct bus_body_part *next;
  57         void *data;
  58         size_t size;
  59         size_t mapped;
  60         int memfd;
  61         bool free_this:1;
  62         bool munmap_this:1;
  63         bool sealed:1;
  64         bool is_zero:1;
  65 };
  66
  67 struct sd_bus_message {
  68         unsigned n_ref;
  69
  70         sd_bus *bus;
  71
  72         uint32_t reply_serial;
  73
  74         const char *path;
  75         const char *interface;
  76         const char *member;
  77         const char *destination;
  78         const char *sender;
  79
  80         sd_bus_error error;
  81
  82         sd_bus_creds creds;
  83
  84         usec_t monotonic;
  85         usec_t realtime;
  86
  87         bool sealed:1;
  88         bool dont_send:1;
  89         bool allow_fds:1;
  90         bool free_header:1;
  91         bool free_kdbus:1;
  92         bool free_fds:1;
  93         bool release_kdbus:1;
  94         bool poisoned:1;
  95
  96         struct bus_header *header;
  97         struct bus_body_part body;
  98         struct bus_body_part *body_end;
  99         unsigned n_body_parts;
 100
 101         size_t rindex;
 102         struct bus_body_part *cached_rindex_part;
 103         size_t cached_rindex_part_begin;
 104
 105         uint32_t n_fds;
 106         int *fds;
 107
 108         struct bus_container root_container, *containers;
 109         unsigned n_containers;
 110
 111         struct iovec *iovec;
 112         struct iovec iovec_fixed[2];
 113         unsigned n_iovec;
 114
 115         struct kdbus_msg *kdbus;
 116
 117         char *peeked_signature;
 118
 119         /* If set replies to this message must carry the signature
 120          * specified here to successfully seal. This is initialized
 121          * from the vtable data */
 122         const char *enforced_reply_signature;
 123
 124         usec_t timeout;
 125
 126         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 127         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 128 };
 129
 130 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != SD_BUS_NATIVE_ENDIAN)
 131
 132 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 133         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 134 }
 135
 136 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 137         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 138 }
 139
 140 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 141         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 142 }
 143
 144 static inline uint32_t BUS_MESSAGE_SERIAL(sd_bus_message *m) {
 145         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 146 }
 147
 148 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 149         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 150 }
 151
 152 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 153         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 154 }
 155
 156 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 157         return
 158                 sizeof(struct bus_header) +
 159                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 160                 BUS_MESSAGE_BODY_SIZE(m);
 161 }
 162
 163 static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 164         return
 165                 sizeof(struct bus_header) +
 166                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 167 }
 168
 169 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 170         return (uint8_t*) m->header + sizeof(struct bus_header);
 171 }
 172
 173 int bus_message_seal(sd_bus_message *m, uint64_t serial);
 174 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 175 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 176
 177 int bus_message_from_header(
 178                 sd_bus *bus,
 179                 void *header,
 180                 size_t length,
 181                 int *fds,
 182                 unsigned n_fds,
 183                 const struct ucred *ucred,
 184                 const char *label,
 185                 size_t extra,
 186                 sd_bus_message **ret);
 187
 188 int bus_message_from_malloc(
 189                 sd_bus *bus,
 190                 void *buffer,
 191                 size_t length,
 192                 int *fds,
 193                 unsigned n_fds,
 194                 const struct ucred *ucred,
 195                 const char *label,
 196                 sd_bus_message **ret);
 197
 198 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 199
 200 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 201
 202 int bus_message_parse_fields(sd_bus_message *m);
 203
 204 bool bus_header_is_complete(struct bus_header *h, size_t size);
 205 int bus_header_message_size(struct bus_header *h, size_t *sum);
 206
 207 struct bus_body_part *message_append_part(sd_bus_message *m);
 208
 209 #define MESSAGE_FOREACH_PART(part, i, m) \
 210         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 211
 212 int bus_body_part_map(struct bus_body_part *part);
 213 void bus_body_part_unmap(struct bus_body_part *part);
 214
 215 int bus_message_to_errno(sd_bus_message *m);
 216
 217 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);