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         usec_t timeout;
 120
 121         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 122         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 123 };
 124
 125 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != SD_BUS_NATIVE_ENDIAN)
 126
 127 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 128         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 129 }
 130
 131 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 132         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 133 }
 134
 135 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 136         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 137 }
 138
 139 static inline uint32_t BUS_MESSAGE_SERIAL(sd_bus_message *m) {
 140         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 141 }
 142
 143 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 144         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 145 }
 146
 147 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 148         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 149 }
 150
 151 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 152         return
 153                 sizeof(struct bus_header) +
 154                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 155                 BUS_MESSAGE_BODY_SIZE(m);
 156 }
 157
 158 static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 159         return
 160                 sizeof(struct bus_header) +
 161                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 162 }
 163
 164 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 165         return (uint8_t*) m->header + sizeof(struct bus_header);
 166 }
 167
 168 int bus_message_seal(sd_bus_message *m, uint64_t serial);
 169 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 170 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 171
 172 int bus_message_from_header(
 173                 sd_bus *bus,
 174                 void *header,
 175                 size_t length,
 176                 int *fds,
 177                 unsigned n_fds,
 178                 const struct ucred *ucred,
 179                 const char *label,
 180                 size_t extra,
 181                 sd_bus_message **ret);
 182
 183 int bus_message_from_malloc(
 184                 sd_bus *bus,
 185                 void *buffer,
 186                 size_t length,
 187                 int *fds,
 188                 unsigned n_fds,
 189                 const struct ucred *ucred,
 190                 const char *label,
 191                 sd_bus_message **ret);
 192
 193 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 194
 195 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 196
 197 int bus_message_parse_fields(sd_bus_message *m);
 198
 199 bool bus_header_is_complete(struct bus_header *h, size_t size);
 200 int bus_header_message_size(struct bus_header *h, size_t *sum);
 201
 202 struct bus_body_part *message_append_part(sd_bus_message *m);
 203
 204 #define MESSAGE_FOREACH_PART(part, i, m) \
 205         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 206
 207 int bus_body_part_map(struct bus_body_part *part);
 208 void bus_body_part_unmap(struct bus_body_part *part);
 209
 210 int bus_message_to_errno(sd_bus_message *m);
 211
 212 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);