src/network/networkd.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #pragma once
  23
  24 #include <arpa/inet.h>
  25
  26 #include "sd-event.h"
  27 #include "sd-rtnl.h"
  28 #include "sd-bus.h"
  29 #include "sd-dhcp-client.h"
  30 #include "sd-dhcp-server.h"
  31 #include "sd-ipv4ll.h"
  32 #include "sd-icmp6-nd.h"
  33 #include "sd-dhcp6-client.h"
  34 #include "udev.h"
  35
  36 #include "rtnl-util.h"
  37 #include "hashmap.h"
  38 #include "list.h"
  39 #include "set.h"
  40 #include "condition-util.h"
  41 #include "in-addr-util.h"
  42
  43 #define CACHE_INFO_INFINITY_LIFE_TIME 0xFFFFFFFFU
  44 #define DHCP_ROUTE_METRIC 1024
  45 #define IPV4LL_ROUTE_METRIC 2048
  46
  47 typedef struct NetDev NetDev;
  48 typedef struct Network Network;
  49 typedef struct Link Link;
  50 typedef struct Address Address;
  51 typedef struct Route Route;
  52 typedef struct Manager Manager;
  53 typedef struct AddressPool AddressPool;
  54
  55 typedef enum DHCPSupport {
  56         DHCP_SUPPORT_NONE,
  57         DHCP_SUPPORT_BOTH,
  58         DHCP_SUPPORT_V4,
  59         DHCP_SUPPORT_V6,
  60         _DHCP_SUPPORT_MAX,
  61         _DHCP_SUPPORT_INVALID = -1,
  62 } DHCPSupport;
  63
  64 struct Network {
  65         Manager *manager;
  66
  67         char *filename;
  68
  69         struct ether_addr *match_mac;
  70         char *match_path;
  71         char *match_driver;
  72         char *match_type;
  73         char *match_name;
  74         char *dhcp_vendor_class_identifier;
  75
  76         Condition *match_host;
  77         Condition *match_virt;
  78         Condition *match_kernel;
  79         Condition *match_arch;
  80
  81         char *description;
  82         NetDev *bridge;
  83         NetDev *bond;
  84         Hashmap *stacked_netdevs;
  85         DHCPSupport dhcp;
  86         bool dhcp_dns;
  87         bool dhcp_ntp;
  88         bool dhcp_mtu;
  89         bool dhcp_hostname;
  90         bool dhcp_domainname;
  91         bool dhcp_sendhost;
  92         bool dhcp_broadcast;
  93         bool dhcp_critical;
  94         bool dhcp_routes;
  95         bool ipv4ll;
  96         bool ipv4ll_route;
  97
  98         bool dhcp_server;
  99
 100         LIST_HEAD(Address, static_addresses);
 101         LIST_HEAD(Route, static_routes);
 102
 103         Hashmap *addresses_by_section;
 104         Hashmap *routes_by_section;
 105
 106         char **dns, **ntp;
 107
 108         LIST_FIELDS(Network, networks);
 109 };
 110
 111 struct Address {
 112         Network *network;
 113         unsigned section;
 114
 115         int family;
 116         unsigned char prefixlen;
 117         unsigned char scope;
 118         char *label;
 119
 120         struct in_addr broadcast;
 121         struct ifa_cacheinfo cinfo;
 122
 123         union in_addr_union in_addr;
 124         union in_addr_union in_addr_peer;
 125
 126         LIST_FIELDS(Address, addresses);
 127 };
 128
 129 struct Route {
 130         Network *network;
 131         unsigned section;
 132
 133         int family;
 134         unsigned char dst_prefixlen;
 135         unsigned char scope;
 136         uint32_t metrics;
 137         unsigned char protocol;  /* RTPROT_* */
 138
 139         union in_addr_union in_addr;
 140         union in_addr_union dst_addr;
 141
 142         LIST_FIELDS(Route, routes);
 143 };
 144
 145 typedef enum LinkState {
 146         LINK_STATE_INITIALIZING,
 147         LINK_STATE_ENSLAVING,
 148         LINK_STATE_SETTING_ADDRESSES,
 149         LINK_STATE_SETTING_ROUTES,
 150         LINK_STATE_CONFIGURED,
 151         LINK_STATE_UNMANAGED,
 152         LINK_STATE_FAILED,
 153         LINK_STATE_LINGER,
 154         _LINK_STATE_MAX,
 155         _LINK_STATE_INVALID = -1
 156 } LinkState;
 157
 158 typedef enum LinkOperationalState {
 159         LINK_OPERSTATE_UNKNOWN,
 160         LINK_OPERSTATE_DORMANT,
 161         LINK_OPERSTATE_CARRIER,
 162         LINK_OPERSTATE_DEGRADED,
 163         LINK_OPERSTATE_ROUTABLE,
 164         _LINK_OPERSTATE_MAX,
 165         _LINK_OPERSTATE_INVALID = -1
 166 } LinkOperationalState;
 167
 168 struct Link {
 169         Manager *manager;
 170
 171         int n_ref;
 172
 173         int ifindex;
 174         char *ifname;
 175         char *state_file;
 176         struct ether_addr mac;
 177         struct udev_device *udev_device;
 178
 179         unsigned flags;
 180         uint8_t kernel_operstate;
 181
 182         Network *network;
 183
 184         LinkState state;
 185         LinkOperationalState operstate;
 186
 187         unsigned addr_messages;
 188         unsigned route_messages;
 189         unsigned enslaving;
 190
 191         LIST_HEAD(Address, addresses);
 192
 193         sd_dhcp_client *dhcp_client;
 194         sd_dhcp_lease *dhcp_lease;
 195         char *lease_file;
 196         uint16_t original_mtu;
 197         sd_ipv4ll *ipv4ll;
 198
 199         LIST_HEAD(Address, pool_addresses);
 200
 201         sd_dhcp_server *dhcp_server;
 202
 203         sd_icmp6_nd *icmp6_router_discovery;
 204         sd_dhcp6_client *dhcp6_client;
 205 };
 206
 207 struct AddressPool {
 208         Manager *manager;
 209
 210         int family;
 211         unsigned prefixlen;
 212
 213         union in_addr_union in_addr;
 214
 215         LIST_FIELDS(AddressPool, address_pools);
 216 };
 217
 218 struct Manager {
 219         sd_rtnl *rtnl;
 220         sd_event *event;
 221         sd_bus *bus;
 222         struct udev *udev;
 223         struct udev_monitor *udev_monitor;
 224         sd_event_source *udev_event_source;
 225         sd_event_source *sigterm_event_source;
 226         sd_event_source *sigint_event_source;
 227
 228         char *state_file;
 229
 230         Hashmap *links;
 231         Hashmap *netdevs;
 232         LIST_HEAD(Network, networks);
 233         LIST_HEAD(AddressPool, address_pools);
 234
 235         usec_t network_dirs_ts_usec;
 236 };
 237
 238 extern const char* const network_dirs[];
 239
 240 /* Manager */
 241
 242 int manager_new(Manager **ret);
 243 void manager_free(Manager *m);
 244
 245 int manager_load_config(Manager *m);
 246 bool manager_should_reload(Manager *m);
 247
 248 int manager_rtnl_enumerate_links(Manager *m);
 249
 250 int manager_rtnl_listen(Manager *m);
 251 int manager_udev_listen(Manager *m);
 252 int manager_bus_listen(Manager *m);
 253
 254 int manager_save(Manager *m);
 255
 256 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found);
 257
 258 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 259 #define _cleanup_manager_free_ _cleanup_(manager_freep)
 260
 261 /* Network */
 262
 263 int network_load(Manager *manager);
 264
 265 void network_free(Network *network);
 266
 267 DEFINE_TRIVIAL_CLEANUP_FUNC(Network*, network_free);
 268 #define _cleanup_network_free_ _cleanup_(network_freep)
 269
 270 int network_get(Manager *manager, struct udev_device *device,
 271                 const char *ifname, const struct ether_addr *mac,
 272                 Network **ret);
 273 int network_apply(Manager *manager, Network *network, Link *link);
 274
 275 int config_parse_netdev(const char *unit, const char *filename, unsigned line,
 276                         const char *section, unsigned section_line, const char *lvalue,
 277                         int ltype, const char *rvalue, void *data, void *userdata);
 278
 279 int config_parse_tunnel(const char *unit,
 280                         const char *filename,
 281                         unsigned line,
 282                         const char *section,
 283                         unsigned section_line,
 284                         const char *lvalue,
 285                         int ltype,
 286                         const char *rvalue,
 287                         void *data,
 288                         void *userdata);
 289
 290 int config_parse_tunnel_address(const char *unit,
 291                                 const char *filename,
 292                                 unsigned line,
 293                                 const char *section,
 294                                 unsigned section_line,
 295                                 const char *lvalue,
 296                                 int ltype,
 297                                 const char *rvalue,
 298                                 void *data,
 299                                 void *userdata);
 300
 301 /* gperf */
 302 const struct ConfigPerfItem* network_network_gperf_lookup(const char *key, unsigned length);
 303
 304 /* Route */
 305 int route_new_static(Network *network, unsigned section, Route **ret);
 306 int route_new_dynamic(Route **ret, unsigned char rtm_protocol);
 307 void route_free(Route *route);
 308 int route_configure(Route *route, Link *link, sd_rtnl_message_handler_t callback);
 309 int route_drop(Route *route, Link *link, sd_rtnl_message_handler_t callback);
 310
 311
 312 DEFINE_TRIVIAL_CLEANUP_FUNC(Route*, route_free);
 313 #define _cleanup_route_free_ _cleanup_(route_freep)
 314
 315 int config_parse_gateway(const char *unit, const char *filename, unsigned line,
 316                          const char *section, unsigned section_line, const char *lvalue,
 317                          int ltype, const char *rvalue, void *data, void *userdata);
 318
 319 int config_parse_destination(const char *unit, const char *filename, unsigned line,
 320                              const char *section, unsigned section_line, const char *lvalue,
 321                              int ltype, const char *rvalue, void *data, void *userdata);
 322
 323 int config_parse_route_priority(const char *unit, const char *filename, unsigned line,
 324                                 const char *section, unsigned section_line, const char *lvalue,
 325                                 int ltype, const char *rvalue, void *data, void *userdata);
 326 /* Address */
 327 int address_new_static(Network *network, unsigned section, Address **ret);
 328 int address_new_dynamic(Address **ret);
 329 void address_free(Address *address);
 330 int address_configure(Address *address, Link *link, sd_rtnl_message_handler_t callback);
 331 int address_update(Address *address, Link *link, sd_rtnl_message_handler_t callback);
 332 int address_drop(Address *address, Link *link, sd_rtnl_message_handler_t callback);
 333 bool address_equal(Address *a1, Address *a2);
 334
 335 DEFINE_TRIVIAL_CLEANUP_FUNC(Address*, address_free);
 336 #define _cleanup_address_free_ _cleanup_(address_freep)
 337
 338 int config_parse_address(const char *unit, const char *filename, unsigned line,
 339                          const char *section, unsigned section_line, const char *lvalue,
 340                          int ltype, const char *rvalue, void *data, void *userdata);
 341
 342 int config_parse_broadcast(const char *unit, const char *filename, unsigned line,
 343                            const char *section, unsigned section_line, const char *lvalue,
 344                            int ltype, const char *rvalue, void *data, void *userdata);
 345
 346 int config_parse_label(const char *unit, const char *filename, unsigned line,
 347                        const char *section, unsigned section_line, const char *lvalue,
 348                        int ltype, const char *rvalue, void *data, void *userdata);
 349
 350 /* Link */
 351
 352 Link *link_unref(Link *link);
 353 Link *link_ref(Link *link);
 354 int link_get(Manager *m, int ifindex, Link **ret);
 355 int link_add(Manager *manager, sd_rtnl_message *message, Link **ret);
 356 void link_drop(Link *link);
 357
 358 int link_update(Link *link, sd_rtnl_message *message);
 359 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata);
 360
 361 int link_initialized(Link *link, struct udev_device *device);
 362
 363 int link_save(Link *link);
 364
 365 bool link_has_carrier(unsigned flags, uint8_t operstate);
 366
 367 const char* link_state_to_string(LinkState s) _const_;
 368 LinkState link_state_from_string(const char *s) _pure_;
 369
 370 const char* link_operstate_to_string(LinkOperationalState s) _const_;
 371 LinkOperationalState link_operstate_from_string(const char *s) _pure_;
 372
 373 DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_unref);
 374 #define _cleanup_link_unref_ _cleanup_(link_unrefp)
 375
 376 /* DHCP support */
 377
 378 const char* dhcp_support_to_string(DHCPSupport i) _const_;
 379 DHCPSupport dhcp_support_from_string(const char *s) _pure_;
 380
 381 int config_parse_dhcp(const char *unit, const char *filename, unsigned line,
 382                       const char *section, unsigned section_line, const char *lvalue,
 383                       int ltype, const char *rvalue, void *data, void *userdata);
 384
 385 /* Address Pool */
 386
 387 int address_pool_new(Manager *m, AddressPool **ret, int family, const union in_addr_union *u, unsigned prefixlen);
 388 int address_pool_new_from_string(Manager *m, AddressPool **ret, int family, const char *p, unsigned prefixlen);
 389 void address_pool_free(AddressPool *p);
 390
 391 int address_pool_acquire(AddressPool *p, unsigned prefixlen, union in_addr_union *found);
 392
 393 /* Macros which append INTERFACE= to the message */
 394
 395 #define log_full_link(level, link, fmt, ...) log_meta_object(level, __FILE__, __LINE__, __func__, "INTERFACE=", link->ifname, "%-*s: " fmt, IFNAMSIZ, link->ifname, ##__VA_ARGS__)
 396 #define log_debug_link(link, ...)       log_full_link(LOG_DEBUG, link, ##__VA_ARGS__)
 397 #define log_info_link(link, ...)        log_full_link(LOG_INFO, link, ##__VA_ARGS__)
 398 #define log_notice_link(link, ...)      log_full_link(LOG_NOTICE, link, ##__VA_ARGS__)
 399 #define log_warning_link(link, ...)     log_full_link(LOG_WARNING, link, ##__VA_ARGS__)
 400 #define log_error_link(link, ...)       log_full_link(LOG_ERR, link, ##__VA_ARGS__)
 401
 402 #define log_struct_link(level, link, ...) log_struct(level, "INTERFACE=%s", link->ifname, __VA_ARGS__)
 403
 404 #define ADDRESS_FMT_VAL(address)            \
 405         (address).s_addr & 0xFF,            \
 406         ((address).s_addr >> 8) & 0xFF,     \
 407         ((address).s_addr >> 16) & 0xFF,    \
 408         (address).s_addr >> 24