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