src/network/networkd-link-bus.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2015 Tom Gundersen
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "alloc-util.h"
  21 #include "bus-util.h"
  22 #include "networkd-link.h"
  23 #include "networkd.h"
  24 #include "parse-util.h"
  25 #include "strv.h"
  26 #include "dhcp-lease-internal.h"
  27
  28 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_operational_state, link_operstate, LinkOperationalState);
  29 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_administrative_state, link_state, LinkState);
  30
  31 const sd_bus_vtable link_vtable[] = {
  32         SD_BUS_VTABLE_START(0),
  33
  34         SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state, offsetof(Link, operstate), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  35         SD_BUS_PROPERTY("AdministrativeState", "s", property_get_administrative_state, offsetof(Link, state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  36
  37         SD_BUS_VTABLE_END
  38 };
  39
  40 static int get_private_options(sd_bus *bus,
  41                        const char *path,
  42                        const char *interface,
  43                        const char *property,
  44                        sd_bus_message *reply,
  45                        void *userdata,
  46                        sd_bus_error *error) {
  47         sd_dhcp_lease *lease = userdata;
  48         struct sd_dhcp_raw_option *option = NULL;
  49         int r;
  50
  51         assert(bus);
  52         assert(reply);
  53         assert(lease);
  54
  55         r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "{yay}");
  56         if (r < 0)
  57                 return r;
  58
  59         LIST_FOREACH(options, option, lease->private_options) {
  60                 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_DICT_ENTRY, "yay");
  61                 if (r < 0)
  62                         return r;
  63                 r = sd_bus_message_append(reply, "y", option->tag);
  64                 if (r < 0)
  65                         return r;
  66                 r = sd_bus_message_append_array(reply, 'y', option->data, option->length);
  67                 if (r < 0)
  68                         return r;
  69                 r = sd_bus_message_close_container(reply);
  70                 if (r < 0)
  71                         return r;
  72         }
  73         return sd_bus_message_close_container(reply);
  74 }
  75
  76 const sd_bus_vtable lease_vtable[] = {
  77         SD_BUS_VTABLE_START(0),
  78
  79         SD_BUS_PROPERTY("PrivateOptions", "a{yay}", get_private_options, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
  80
  81         SD_BUS_VTABLE_END
  82 };
  83
  84 static char *link_bus_path(Link *link) {
  85         _cleanup_free_ char *ifindex = NULL;
  86         char *p;
  87         int r;
  88
  89         assert(link);
  90         assert(link->ifindex > 0);
  91
  92         if (asprintf(&ifindex, "%d", link->ifindex) < 0)
  93                 return NULL;
  94
  95         r = sd_bus_path_encode("/org/freedesktop/network1/link", ifindex, &p);
  96         if (r < 0)
  97                 return NULL;
  98
  99         return p;
 100 }
 101
 102 static char *lease_bus_path(Link *link) {
 103         _cleanup_free_ char *p = NULL;
 104         char *ret = NULL;
 105         int r;
 106
 107         assert(link);
 108
 109         p = link_bus_path(link);
 110         if (!p)
 111                 return NULL;
 112
 113         r = sd_bus_path_encode(p, "lease", &ret);
 114         if (r < 0)
 115                 return NULL;
 116
 117         return ret;
 118 }
 119
 120 int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 121         _cleanup_strv_free_ char **l = NULL;
 122         Manager *m = userdata;
 123         unsigned c = 0;
 124         Link *link;
 125         Iterator i;
 126
 127         assert(bus);
 128         assert(path);
 129         assert(m);
 130         assert(nodes);
 131
 132         l = new0(char*, hashmap_size(m->links) + 1);
 133         if (!l)
 134                 return -ENOMEM;
 135
 136         HASHMAP_FOREACH(link, m->links, i) {
 137                 char *p;
 138
 139                 p = link_bus_path(link);
 140                 if (!p)
 141                         return -ENOMEM;
 142
 143                 l[c++] = p;
 144         }
 145
 146         l[c] = NULL;
 147         *nodes = l;
 148         l = NULL;
 149
 150         return 1;
 151 }
 152
 153 int lease_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 154         _cleanup_strv_free_ char **l = NULL;
 155         Manager *m = userdata;
 156         unsigned c = 0;
 157         Link *link;
 158         Iterator i;
 159
 160         assert(bus);
 161         assert(path);
 162         assert(m);
 163         assert(nodes);
 164
 165         l = new0(char*, hashmap_size(m->links) + 1);
 166         if (!l)
 167                 return -ENOMEM;
 168
 169         HASHMAP_FOREACH(link, m->links, i) {
 170                 char *p;
 171
 172                 if (!link->dhcp_lease)
 173                         continue;
 174
 175                 p = lease_bus_path(link);
 176                 if (!p)
 177                         return -ENOMEM;
 178
 179                 l[c++] = p;
 180         }
 181
 182         l[c] = NULL;
 183         *nodes = l;
 184         l = NULL;
 185
 186         return 1;
 187 }
 188
 189 int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 190         _cleanup_free_ char *identifier = NULL;
 191         Manager *m = userdata;
 192         Link *link;
 193         int ifindex, r;
 194
 195         assert(bus);
 196         assert(path);
 197         assert(interface);
 198         assert(m);
 199         assert(found);
 200
 201         r = sd_bus_path_decode(path, "/org/freedesktop/network1/link", &identifier);
 202         if (r <= 0)
 203                 return 0;
 204
 205         r = parse_ifindex(identifier, &ifindex);
 206         if (r < 0)
 207                 return 0;
 208
 209         r = link_get(m, ifindex, &link);
 210         if (r < 0)
 211                 return 0;
 212
 213         *found = link;
 214
 215         return 1;
 216 }
 217
 218 int lease_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 219         _cleanup_free_ char *identifier = NULL;
 220         Manager *m = userdata;
 221         Link *link;
 222         int ifindex, r;
 223
 224         assert(bus);
 225         assert(path);
 226         assert(interface);
 227         assert(m);
 228         assert(found);
 229
 230         r = sd_bus_path_decode_many(path, "/org/freedesktop/network1/link/%/lease", &identifier);
 231         if (r <= 0)
 232                 return 0;
 233
 234         r = parse_ifindex(identifier, &ifindex);
 235         if (r < 0)
 236                 return 0;
 237
 238         r = link_get(m, ifindex, &link);
 239         if (r < 0)
 240                 return 0;
 241
 242         if (!link->dhcp_lease)
 243                 return 0;
 244
 245         *found = link->dhcp_lease;
 246
 247         return 1;
 248 }
 249
 250 int link_send_changed(Link *link, const char *property, ...) {
 251         _cleanup_free_ char *p = NULL;
 252         char **l;
 253
 254         assert(link);
 255         assert(link->manager);
 256
 257         if (!link->manager->bus)
 258                 return 0; /* replace with assert when we have kdbus */
 259
 260         l = strv_from_stdarg_alloca(property);
 261
 262         p = link_bus_path(link);
 263         if (!p)
 264                 return -ENOMEM;
 265
 266         return sd_bus_emit_properties_changed_strv(
 267                         link->manager->bus,
 268                         p,
 269                         "org.freedesktop.network1.Link",
 270                         l);
 271 }