src/libsystemd/sd-bus/bus-slot.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2013 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include "sd-bus.h"
  22
  23 #include "alloc-util.h"
  24 #include "bus-control.h"
  25 #include "bus-objects.h"
  26 #include "bus-slot.h"
  27 #include "string-util.h"
  28
  29 sd_bus_slot *bus_slot_allocate(
  30                 sd_bus *bus,
  31                 bool floating,
  32                 BusSlotType type,
  33                 size_t extra,
  34                 void *userdata) {
  35
  36         sd_bus_slot *slot;
  37
  38         assert(bus);
  39
  40         slot = malloc0(offsetof(sd_bus_slot, reply_callback) + extra);
  41         if (!slot)
  42                 return NULL;
  43
  44         slot->n_ref = 1;
  45         slot->type = type;
  46         slot->bus = bus;
  47         slot->floating = floating;
  48         slot->userdata = userdata;
  49
  50         if (!floating)
  51                 sd_bus_ref(bus);
  52
  53         LIST_PREPEND(slots, bus->slots, slot);
  54
  55         return slot;
  56 }
  57
  58 _public_ sd_bus_slot* sd_bus_slot_ref(sd_bus_slot *slot) {
  59
  60         if (!slot)
  61                 return NULL;
  62
  63         assert(slot->n_ref > 0);
  64
  65         slot->n_ref++;
  66         return slot;
  67 }
  68
  69 void bus_slot_disconnect(sd_bus_slot *slot) {
  70         sd_bus *bus;
  71
  72         assert(slot);
  73
  74         if (!slot->bus)
  75                 return;
  76
  77         switch (slot->type) {
  78
  79         case BUS_REPLY_CALLBACK:
  80
  81                 if (slot->reply_callback.cookie != 0)
  82                         ordered_hashmap_remove(slot->bus->reply_callbacks, &slot->reply_callback.cookie);
  83
  84                 if (slot->reply_callback.timeout != 0)
  85                         prioq_remove(slot->bus->reply_callbacks_prioq, &slot->reply_callback, &slot->reply_callback.prioq_idx);
  86
  87                 break;
  88
  89         case BUS_FILTER_CALLBACK:
  90                 slot->bus->filter_callbacks_modified = true;
  91                 LIST_REMOVE(callbacks, slot->bus->filter_callbacks, &slot->filter_callback);
  92                 break;
  93
  94         case BUS_MATCH_CALLBACK:
  95
  96                 if (slot->match_added)
  97                         bus_remove_match_internal(slot->bus, slot->match_callback.match_string);
  98
  99                 slot->bus->match_callbacks_modified = true;
 100                 bus_match_remove(&slot->bus->match_callbacks, &slot->match_callback);
 101
 102                 free(slot->match_callback.match_string);
 103
 104                 break;
 105
 106         case BUS_NODE_CALLBACK:
 107
 108                 if (slot->node_callback.node) {
 109                         LIST_REMOVE(callbacks, slot->node_callback.node->callbacks, &slot->node_callback);
 110                         slot->bus->nodes_modified = true;
 111
 112                         bus_node_gc(slot->bus, slot->node_callback.node);
 113                 }
 114
 115                 break;
 116
 117         case BUS_NODE_ENUMERATOR:
 118
 119                 if (slot->node_enumerator.node) {
 120                         LIST_REMOVE(enumerators, slot->node_enumerator.node->enumerators, &slot->node_enumerator);
 121                         slot->bus->nodes_modified = true;
 122
 123                         bus_node_gc(slot->bus, slot->node_enumerator.node);
 124                 }
 125
 126                 break;
 127
 128         case BUS_NODE_OBJECT_MANAGER:
 129
 130                 if (slot->node_object_manager.node) {
 131                         LIST_REMOVE(object_managers, slot->node_object_manager.node->object_managers, &slot->node_object_manager);
 132                         slot->bus->nodes_modified = true;
 133
 134                         bus_node_gc(slot->bus, slot->node_object_manager.node);
 135                 }
 136
 137                 break;
 138
 139         case BUS_NODE_VTABLE:
 140
 141                 if (slot->node_vtable.node && slot->node_vtable.interface && slot->node_vtable.vtable) {
 142                         const sd_bus_vtable *v;
 143
 144                         for (v = slot->node_vtable.vtable; v->type != _SD_BUS_VTABLE_END; v++) {
 145                                 struct vtable_member *x = NULL;
 146
 147                                 switch (v->type) {
 148
 149                                 case _SD_BUS_VTABLE_METHOD: {
 150                                         struct vtable_member key;
 151
 152                                         key.path = slot->node_vtable.node->path;
 153                                         key.interface = slot->node_vtable.interface;
 154                                         key.member = v->x.method.member;
 155
 156                                         x = hashmap_remove(slot->bus->vtable_methods, &key);
 157                                         break;
 158                                 }
 159
 160                                 case _SD_BUS_VTABLE_PROPERTY:
 161                                 case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
 162                                         struct vtable_member key;
 163
 164                                         key.path = slot->node_vtable.node->path;
 165                                         key.interface = slot->node_vtable.interface;
 166                                         key.member = v->x.method.member;
 167
 168
 169                                         x = hashmap_remove(slot->bus->vtable_properties, &key);
 170                                         break;
 171                                 }}
 172
 173                                 free(x);
 174                         }
 175                 }
 176
 177                 free(slot->node_vtable.interface);
 178
 179                 if (slot->node_vtable.node) {
 180                         LIST_REMOVE(vtables, slot->node_vtable.node->vtables, &slot->node_vtable);
 181                         slot->bus->nodes_modified = true;
 182
 183                         bus_node_gc(slot->bus, slot->node_vtable.node);
 184                 }
 185
 186                 break;
 187
 188         default:
 189                 assert_not_reached("Wut? Unknown slot type?");
 190         }
 191
 192         bus = slot->bus;
 193
 194         slot->type = _BUS_SLOT_INVALID;
 195         slot->bus = NULL;
 196         LIST_REMOVE(slots, bus->slots, slot);
 197
 198         if (!slot->floating)
 199                 sd_bus_unref(bus);
 200 }
 201
 202 _public_ sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) {
 203
 204         if (!slot)
 205                 return NULL;
 206
 207         assert(slot->n_ref > 0);
 208
 209         if (slot->n_ref > 1) {
 210                 slot->n_ref--;
 211                 return NULL;
 212         }
 213
 214         bus_slot_disconnect(slot);
 215         free(slot->description);
 216         return mfree(slot);
 217 }
 218
 219 _public_ sd_bus* sd_bus_slot_get_bus(sd_bus_slot *slot) {
 220         assert_return(slot, NULL);
 221
 222         return slot->bus;
 223 }
 224
 225 _public_ void *sd_bus_slot_get_userdata(sd_bus_slot *slot) {
 226         assert_return(slot, NULL);
 227
 228         return slot->userdata;
 229 }
 230
 231 _public_ void *sd_bus_slot_set_userdata(sd_bus_slot *slot, void *userdata) {
 232         void *ret;
 233
 234         assert_return(slot, NULL);
 235
 236         ret = slot->userdata;
 237         slot->userdata = userdata;
 238
 239         return ret;
 240 }
 241
 242 _public_ sd_bus_message *sd_bus_slot_get_current_message(sd_bus_slot *slot) {
 243         assert_return(slot, NULL);
 244         assert_return(slot->type >= 0, NULL);
 245
 246         if (slot->bus->current_slot != slot)
 247                 return NULL;
 248
 249         return slot->bus->current_message;
 250 }
 251
 252 _public_ sd_bus_message_handler_t sd_bus_slot_get_current_handler(sd_bus_slot *slot) {
 253         assert_return(slot, NULL);
 254         assert_return(slot->type >= 0, NULL);
 255
 256         if (slot->bus->current_slot != slot)
 257                 return NULL;
 258
 259         return slot->bus->current_handler;
 260 }
 261
 262 _public_ void* sd_bus_slot_get_current_userdata(sd_bus_slot *slot) {
 263         assert_return(slot, NULL);
 264         assert_return(slot->type >= 0, NULL);
 265
 266         if (slot->bus->current_slot != slot)
 267                 return NULL;
 268
 269         return slot->bus->current_userdata;
 270 }
 271
 272 _public_ int sd_bus_slot_set_description(sd_bus_slot *slot, const char *description) {
 273         assert_return(slot, -EINVAL);
 274
 275         return free_and_strdup(&slot->description, description);
 276 }
 277
 278 _public_ int sd_bus_slot_get_description(sd_bus_slot *slot, const char **description) {
 279         assert_return(slot, -EINVAL);
 280         assert_return(description, -EINVAL);
 281         assert_return(slot->description, -ENXIO);
 282
 283         *description = slot->description;
 284         return 0;
 285 }