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;
  38
  39         uint32_t *array_size;
  40         size_t 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 sd_bus_message {
  54         unsigned n_ref;
  55
  56         uint32_t reply_serial;
  57
  58         const char *path;
  59         const char *interface;
  60         const char *member;
  61         const char *destination;
  62         const char *sender;
  63
  64         sd_bus_error error;
  65
  66         uid_t uid;
  67         gid_t gid;
  68         pid_t pid;
  69         pid_t tid;
  70
  71         bool sealed:1;
  72         bool dont_send:1;
  73         bool allow_fds:1;
  74         bool uid_valid:1;
  75         bool gid_valid:1;
  76         bool free_header:1;
  77         bool free_fields:1;
  78         bool free_body:1;
  79         bool free_kdbus:1;
  80         bool free_fds:1;
  81
  82         struct bus_header *header;
  83         void *fields;
  84         void *body;
  85         struct kdbus_msg *kdbus;
  86
  87         char *label;
  88
  89         size_t rindex;
  90
  91         uint32_t n_fds;
  92         int *fds;
  93
  94         struct bus_container root_container, *containers;
  95         unsigned n_containers;
  96
  97         struct iovec iovec[4];
  98         unsigned n_iovec;
  99
 100         char *peeked_signature;
 101
 102         usec_t timeout;
 103 };
 104
 105 #define BUS_MESSAGE_NEED_BSWAP(m) ((m)->header->endian != SD_BUS_NATIVE_ENDIAN)
 106
 107 static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
 108         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
 109 }
 110
 111 static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
 112         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
 113 }
 114
 115 static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
 116         return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
 117 }
 118
 119 static inline uint32_t BUS_MESSAGE_SERIAL(sd_bus_message *m) {
 120         return BUS_MESSAGE_BSWAP32(m, m->header->serial);
 121 }
 122
 123 static inline uint32_t BUS_MESSAGE_BODY_SIZE(sd_bus_message *m) {
 124         return BUS_MESSAGE_BSWAP32(m, m->header->body_size);
 125 }
 126
 127 static inline uint32_t BUS_MESSAGE_FIELDS_SIZE(sd_bus_message *m) {
 128         return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
 129 }
 130
 131 static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
 132         return
 133                 sizeof(struct bus_header) +
 134                 ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
 135                 BUS_MESSAGE_BODY_SIZE(m);
 136 }
 137
 138 static inline void bus_message_unrefp(sd_bus_message **m) {
 139         sd_bus_message_unref(*m);
 140 }
 141
 142 #define _cleanup_bus_message_unref_ __attribute__((cleanup(bus_message_unrefp)))
 143
 144 int bus_message_seal(sd_bus_message *m, uint64_t serial);
 145 int bus_message_dump(sd_bus_message *m);
 146 int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
 147 int bus_message_read_strv_extend(sd_bus_message *m, char ***l);
 148
 149 int bus_message_from_header(
 150                 void *header,
 151                 size_t length,
 152                 int *fds,
 153                 unsigned n_fds,
 154                 const struct ucred *ucred,
 155                 const char *label,
 156                 size_t extra,
 157                 sd_bus_message **ret);
 158
 159 int bus_message_from_malloc(
 160                 void *buffer,
 161                 size_t length,
 162                 int *fds,
 163                 unsigned n_fds,
 164                 const struct ucred *ucred,
 165                 const char *label,
 166                 sd_bus_message **ret);
 167
 168 const char* bus_message_get_arg(sd_bus_message *m, unsigned i);
 169
 170 int bus_message_append_ap(sd_bus_message *m, const char *types, va_list ap);
 171
 172 int bus_message_parse_fields(sd_bus_message *m);
 173
 174 int bus_header_size(struct bus_header *h, size_t *sum);