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         NetDev *tunnel;
  85         Hashmap *vlans;
  86         Hashmap *macvlans;
  87         Hashmap *vxlans;
  88         DHCPSupport dhcp;
  89         bool dhcp_dns;
  90         bool dhcp_ntp;
  91         bool dhcp_mtu;
  92         bool dhcp_hostname;
  93         bool dhcp_domainname;
  94         bool dhcp_sendhost;
  95         bool dhcp_broadcast;
  96         bool dhcp_critical;
  97         bool dhcp_routes;
  98         bool ipv4ll;
  99
 100         bool dhcp_server;
 101
 102         LIST_HEAD(Address, static_addresses);
 103         LIST_HEAD(Route, static_routes);
 104
 105         Hashmap *addresses_by_section;
 106         Hashmap *routes_by_section;
 107
 108         char **dns, **ntp;
 109
 110         LIST_FIELDS(Network, networks);
 111 };
 112
 113 struct Address {
 114         Network *network;
 115         uint64_t section;
 116
 117         int family;
 118         unsigned char prefixlen;
 119         unsigned char scope;
 120         char *label;
 121
 122         struct in_addr broadcast;
 123         struct ifa_cacheinfo cinfo;
 124
 125         union in_addr_union in_addr;
 126         union in_addr_union in_addr_peer;
 127
 128         LIST_FIELDS(Address, addresses);
 129 };
 130
 131 struct Route {
 132         Network *network;
 133         uint64_t section;
 134
 135         int family;
 136         unsigned char dst_prefixlen;
 137         unsigned char scope;
 138         uint32_t metrics;
 139         unsigned char protocol;  /* RTPROT_* */
 140
 141         union in_addr_union in_addr;
 142         union in_addr_union dst_addr;
 143
 144         LIST_FIELDS(Route, routes);
 145 };
 146
 147 typedef enum LinkState {
 148         LINK_STATE_INITIALIZING,
 149         LINK_STATE_ENSLAVING,
 150         LINK_STATE_SETTING_ADDRESSES,
 151         LINK_STATE_SETTING_ROUTES,
 152         LINK_STATE_CONFIGURED,
 153         LINK_STATE_UNMANAGED,
 154         LINK_STATE_FAILED,
 155         LINK_STATE_LINGER,
 156         _LINK_STATE_MAX,
 157         _LINK_STATE_INVALID = -1
 158 } LinkState;
 159
 160 typedef enum LinkOperationalState {
 161         LINK_OPERSTATE_UNKNOWN,
 162         LINK_OPERSTATE_DORMANT,
 163         LINK_OPERSTATE_CARRIER,
 164         LINK_OPERSTATE_DEGRADED,
 165         LINK_OPERSTATE_ROUTABLE,
 166         _LINK_OPERSTATE_MAX,
 167         _LINK_OPERSTATE_INVALID = -1
 168 } LinkOperationalState;
 169
 170 struct Link {
 171         Manager *manager;
 172
 173         int n_ref;
 174
 175         uint64_t ifindex;
 176         char *ifname;
 177         char *state_file;
 178         struct ether_addr mac;
 179         struct udev_device *udev_device;
 180
 181         unsigned flags;
 182         uint8_t kernel_operstate;
 183
 184         Network *network;
 185
 186         LinkState state;
 187         LinkOperationalState operstate;
 188
 189         unsigned addr_messages;
 190         unsigned route_messages;
 191         unsigned enslaving;
 192
 193         LIST_HEAD(Address, addresses);
 194
 195         sd_dhcp_client *dhcp_client;
 196         sd_dhcp_lease *dhcp_lease;
 197         char *lease_file;
 198         uint16_t original_mtu;
 199         sd_ipv4ll *ipv4ll;
 200
 201         LIST_HEAD(Address, pool_addresses);
 202
 203         sd_dhcp_server *dhcp_server;
 204
 205         sd_icmp6_nd *icmp6_router_discovery;
 206         sd_dhcp6_client *dhcp6_client;
 207 };
 208
 209 struct AddressPool {
 210         Manager *manager;
 211
 212         int family;
 213         unsigned prefixlen;
 214
 215         union in_addr_union in_addr;
 216
 217         LIST_FIELDS(AddressPool, address_pools);
 218 };
 219
 220 struct Manager {
 221         sd_rtnl *rtnl;
 222         sd_event *event;
 223         sd_bus *bus;
 224         struct udev *udev;
 225         struct udev_monitor *udev_monitor;
 226         sd_event_source *udev_event_source;
 227         sd_event_source *sigterm_event_source;
 228         sd_event_source *sigint_event_source;
 229
 230         char *state_file;
 231
 232         Hashmap *links;
 233         Hashmap *netdevs;
 234         LIST_HEAD(Network, networks);
 235         LIST_HEAD(AddressPool, address_pools);
 236
 237         usec_t network_dirs_ts_usec;
 238 };
 239
 240 extern const char* const network_dirs[];
 241
 242 /* Manager */
 243
 244 int manager_new(Manager **ret);
 245 void manager_free(Manager *m);
 246
 247 int manager_load_config(Manager *m);
 248 bool manager_should_reload(Manager *m);
 249
 250 int manager_rtnl_enumerate_links(Manager *m);
 251
 252 int manager_rtnl_listen(Manager *m);
 253 int manager_udev_listen(Manager *m);
 254 int manager_bus_listen(Manager *m);
 255
 256 int manager_save(Manager *m);
 257
 258 int manager_address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found);
 259
 260 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
 261 #define _cleanup_manager_free_ _cleanup_(manager_freep)
 262
 263 /* Network */
 264
 265 int network_load(Manager *manager);
 266
 267 void network_free(Network *network);
 268
 269 DEFINE_TRIVIAL_CLEANUP_FUNC(Network*, network_free);
 270 #define _cleanup_network_free_ _cleanup_(network_freep)
 271
 272 int network_get(Manager *manager, struct udev_device *device,
 273                 const char *ifname, const struct ether_addr *mac,
 274                 Network **ret);
 275 int network_apply(Manager *manager, Network *network, Link *link);
 276
 277 int config_parse_netdev(const char *unit, const char *filename, unsigned line,
 278                         const char *section, unsigned section_line, const char *lvalue,
 279                         int ltype, const char *rvalue, void *data, void *userdata);
 280
 281 int config_parse_tunnel(const char *unit,
 282                         const char *filename,
 283                         unsigned line,
 284                         const char *section,
 285                         unsigned section_line,
 286                         const char *lvalue,
 287                         int ltype,
 288                         const char *rvalue,
 289                         void *data,
 290                         void *userdata);
 291
 292 int config_parse_tunnel_address(const char *unit,
 293                                 const char *filename,
 294                                 unsigned line,
 295                                 const char *section,
 296                                 unsigned section_line,
 297                                 const char *lvalue,
 298                                 int ltype,
 299                                 const char *rvalue,
 300                                 void *data,
 301                                 void *userdata);
 302
 303 /* gperf */
 304 const struct ConfigPerfItem* network_network_gperf_lookup(const char *key, unsigned length);
 305
 306 /* Route */
 307 int route_new_static(Network *network, unsigned section, Route **ret);
 308 int route_new_dynamic(Route **ret, unsigned char rtm_protocol);
 309 void route_free(Route *route);
 310 int route_configure(Route *route, Link *link, sd_rtnl_message_handler_t callback);
 311 int route_drop(Route *route, Link *link, sd_rtnl_message_handler_t callback);
 312
 313
 314 DEFINE_TRIVIAL_CLEANUP_FUNC(Route*, route_free);
 315 #define _cleanup_route_free_ _cleanup_(route_freep)
 316
 317 int config_parse_gateway(const char *unit, const char *filename, unsigned line,
 318                          const char *section, unsigned section_line, const char *lvalue,
 319                          int ltype, const char *rvalue, void *data, void *userdata);
 320
 321 int config_parse_destination(const char *unit, const char *filename, unsigned line,
 322                              const char *section, unsigned section_line, const char *lvalue,
 323                              int ltype, const char *rvalue, void *data, void *userdata);
 324
 325 int config_parse_route_priority(const char *unit, const char *filename, unsigned line,
 326                                 const char *section, unsigned section_line, const char *lvalue,
 327                                 int ltype, const char *rvalue, void *data, void *userdata);
 328 /* Address */
 329 int address_new_static(Network *network, unsigned section, Address **ret);
 330 int address_new_dynamic(Address **ret);
 331 void address_free(Address *address);
 332 int address_configure(Address *address, Link *link, sd_rtnl_message_handler_t callback);
 333 int address_update(Address *address, Link *link, sd_rtnl_message_handler_t callback);
 334 int address_drop(Address *address, Link *link, sd_rtnl_message_handler_t callback);
 335 bool address_equal(Address *a1, Address *a2);
 336
 337 DEFINE_TRIVIAL_CLEANUP_FUNC(Address*, address_free);
 338 #define _cleanup_address_free_ _cleanup_(address_freep)
 339
 340 int config_parse_address(const char *unit, const char *filename, unsigned line,
 341                          const char *section, unsigned section_line, const char *lvalue,
 342                          int ltype, const char *rvalue, void *data, void *userdata);
 343
 344 int config_parse_broadcast(const char *unit, const char *filename, unsigned line,
 345                            const char *section, unsigned section_line, const char *lvalue,
 346                            int ltype, const char *rvalue, void *data, void *userdata);
 347
 348 int config_parse_label(const char *unit, const char *filename, unsigned line,
 349                        const char *section, unsigned section_line, const char *lvalue,
 350                        int ltype, const char *rvalue, void *data, void *userdata);
 351
 352 /* Link */
 353
 354 Link *link_unref(Link *link);
 355 Link *link_ref(Link *link);
 356 int link_get(Manager *m, int ifindex, Link **ret);
 357 int link_add(Manager *manager, sd_rtnl_message *message, Link **ret);
 358 void link_drop(Link *link);
 359
 360 int link_update(Link *link, sd_rtnl_message *message);
 361 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata);
 362
 363 int link_initialized(Link *link, struct udev_device *device);
 364
 365 int link_save(Link *link);
 366
 367 bool link_has_carrier(unsigned flags, uint8_t operstate);
 368
 369 const char* link_state_to_string(LinkState s) _const_;
 370 LinkState link_state_from_string(const char *s) _pure_;
 371
 372 const char* link_operstate_to_string(LinkOperationalState s) _const_;
 373 LinkOperationalState link_operstate_from_string(const char *s) _pure_;
 374
 375 DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_unref);
 376 #define _cleanup_link_unref_ _cleanup_(link_unrefp)
 377
 378 /* DHCP support */
 379
 380 const char* dhcp_support_to_string(DHCPSupport i) _const_;
 381 DHCPSupport dhcp_support_from_string(const char *s) _pure_;
 382
 383 int config_parse_dhcp(const char *unit, const char *filename, unsigned line,
 384                       const char *section, unsigned section_line, const char *lvalue,
 385                       int ltype, const char *rvalue, void *data, void *userdata);
 386
 387 /* Address Pool */
 388
 389 int address_pool_new(Manager *m, AddressPool **ret, int family, const union in_addr_union *u, unsigned prefixlen);
 390 int address_pool_new_from_string(Manager *m, AddressPool **ret, int family, const char *p, unsigned prefixlen);
 391 void address_pool_free(AddressPool *p);
 392
 393 int address_pool_acquire(AddressPool *p, unsigned prefixlen, union in_addr_union *found);
 394
 395 /* Macros which append INTERFACE= to the message */
 396
 397 #define log_full_link(level, link, fmt, ...) log_meta_object(level, __FILE__, __LINE__, __func__, "INTERFACE=", link->ifname, "%-*s: " fmt, IFNAMSIZ, link->ifname, ##__VA_ARGS__)
 398 #define log_debug_link(link, ...)       log_full_link(LOG_DEBUG, link, ##__VA_ARGS__)
 399 #define log_info_link(link, ...)        log_full_link(LOG_INFO, link, ##__VA_ARGS__)
 400 #define log_notice_link(link, ...)      log_full_link(LOG_NOTICE, link, ##__VA_ARGS__)
 401 #define log_warning_link(link, ...)     log_full_link(LOG_WARNING, link, ##__VA_ARGS__)
 402 #define log_error_link(link, ...)       log_full_link(LOG_ERR, link, ##__VA_ARGS__)
 403
 404 #define log_struct_link(level, link, ...) log_struct(level, "INTERFACE=%s", link->ifname, __VA_ARGS__)
 405
 406 #define ADDRESS_FMT_VAL(address)            \
 407         (address).s_addr & 0xFF,            \
 408         ((address).s_addr >> 8) & 0xFF,     \
 409         ((address).s_addr >> 16) & 0xFF,    \
 410         (address).s_addr >> 24