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
  33 struct bus_container {
  34         char enclosing;
  35
  36         unsigned index, saved_index;
  37
  38         char *signature;
  39
  40         uint32_t *array_size;
  41         size_t before, begin;
  42 };
  43
  44 struct bus_header {
  45         uint8_t endian;
  46         uint8_t type;
  47         uint8_t flags;
  48         uint8_t version;
  49         uint32_t body_size;
  50         uint32_t serial;
  51         uint32_t fields_size;
  52 } _packed_;
  53
  54 struct bus_body_part {
  55         struct bus_body_part *next;
  56         void *data;
  57         size_t size;
  58         size_t mapped;
  59         int memfd;
  60         bool free_this:1;
  61         bool munmap_this:1;
  62         bool sealed:1;
  63         bool is_zero:1;
  64 };
  65
  66 struct sd_bus_message {
  67         unsigned n_ref;
  68
  69         sd_bus *bus;
  70
  71         uint32_t reply_serial;
  72
  73         const char *path;
  74         const char *interface;
  75         const char *member;
  76         const char *destination;
  77         const char *sender;
  78
  79         sd_bus_error error;
  80
  81         uid_t uid;
  82         gid_t gid;
  83         pid_t pid;
  84         pid_t tid;
  85         usec_t pid_starttime;
  86         usec_t monotonic;
  87         usec_t realtime;
  88
  89         bool sealed:1;
  90         bool dont_send:1;
  91         bool allow_fds:1;
  92         bool uid_valid:1;
  93         bool gid_valid:1;
  94         bool free_header:1;
  95         bool free_kdbus:1;
  96         bool free_fds:1;
  97         bool release_kdbus:1;
  98         bool poisoned:1;
  99
 100         struct bus_header *header;
 101         struct bus_body_part body;
 102         struct bus_body_part *body_end;
 103         unsigned n_body_parts;
 104
 105         char *label;
 106
 107         size_t rindex;
 108         struct bus_body_part *cached_rindex_part;
 109         size_t cached_rindex_part_begin;
 110
 111         uint32_t n_fds;
 112         int *fds;
 113
 114         struct bus_container root_container, *containers;
 115         unsigned n_containers;
 116
 117         struct iovec *iovec;
 118         struct iovec iovec_fixed[2];
 119         unsigned n_iovec;
 120
 121         struct kdbus_msg *kdbus;
 122
 123         char *peeked_signature;
 124
 125         usec_t timeout;
 126
 127         char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 128         char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
 129
 130         const char *exe;
 131         const char *comm;
 132         const char *tid_comm;
 133         const char *cgroup;
 134
 135         const char *cmdline;
 136         size_t cmdline_length;
 137         char **cmdline_array;
 138
 139         char *session;
 140         char *unit;
 141         char *user_unit;
 142
 143         struct kdbus_audit *audit;
 144
 145         uint8_t *capability;
 146         size_t capability_size;
 147 };
 148
 149 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != SD_BUS_NATIVE_ENDIAN)
 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 uint32_t BUS_MESSAGE_SERIAL(sd_bus_message *m) {
 164         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 165 }
 166
 167 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 168         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 169 }
 170
 171 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 172         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 173 }
 174
 175 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 176         return
 177                 sizeof(struct bus_header) +
 178                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 179                 BUS_MESSAGE_BODY_SIZE(m);
 180 }
 181
 182 static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
 183         return
 184                 sizeof(struct bus_header) +
 185                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
 186 }
 187
 188 static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
 189         return (uint8_t*) m->header + sizeof(struct bus_header);
 190 }
 191
 192 static inline void bus_message_unrefp(sd_bus_message **m) {
 193         sd_bus_message_unref(*m);
 194 }
 195
 196 #define _cleanup_bus_message_unref_ __attribute__((cleanup(bus_message_unrefp)))
 197
 198 int bus_message_seal(sd_bus_message *m, uint64_t serial);
 199 int bus_message_dump(sd_bus_message *m);
 200 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 201 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 202
 203 int bus_message_from_header(
 204                 void *header,
 205                 size_t length,
 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                 void *buffer,
 215                 size_t length,
 216                 int *fds,
 217                 unsigned n_fds,
 218                 const struct ucred *ucred,
 219                 const char *label,
 220                 sd_bus_message **ret);
 221
 222 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 223
 224 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 225
 226 int bus_message_parse_fields(sd_bus_message *m);
 227
 228 bool bus_header_is_complete(struct bus_header *h, size_t size);
 229 int bus_header_message_size(struct bus_header *h, size_t *sum);
 230
 231 struct bus_body_part *message_append_part(sd_bus_message *m);
 232
 233 #define MESSAGE_FOREACH_PART(part, i, m) \
 234         for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
 235
 236 int bus_body_part_map(struct bus_body_part *part);
 237 void bus_body_part_unmap(struct bus_body_part *part);
 238
 239 int bus_message_to_errno(sd_bus_message *m);
 240
 241 int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);