src/network/netdev/bond.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <netinet/ether.h>
   4 #include <linux/if_bonding.h>
   5
   6 #include "sd-netlink.h"
   7
   8 #include "alloc-util.h"
   9 #include "conf-parser.h"
  10 #include "ether-addr-util.h"
  11 #include "extract-word.h"
  12 #include "missing.h"
  13 #include "netdev/bond.h"
  14 #include "string-table.h"
  15 #include "string-util.h"
  16
  17 /*
  18  * Number of seconds between instances where the bonding
  19  * driver sends learning packets to each slaves peer switch
  20  */
  21 #define LEARNING_PACKETS_INTERVAL_MIN_SEC       (1 * USEC_PER_SEC)
  22 #define LEARNING_PACKETS_INTERVAL_MAX_SEC       (0x7fffffff * USEC_PER_SEC)
  23
  24 /* Number of IGMP membership reports to be issued after
  25  * a failover event.
  26  */
  27 #define RESEND_IGMP_MIN           0
  28 #define RESEND_IGMP_MAX           255
  29 #define RESEND_IGMP_DEFAULT       1
  30
  31 /*
  32  * Number of packets to transmit through a slave before
  33  * moving to the next one.
  34  */
  35 #define PACKETS_PER_SLAVE_MIN     0
  36 #define PACKETS_PER_SLAVE_MAX     65535
  37 #define PACKETS_PER_SLAVE_DEFAULT 1
  38
  39 /*
  40  * Number of peer notifications (gratuitous ARPs and
  41  * unsolicited IPv6 Neighbor Advertisements) to be issued after a
  42  * failover event.
  43  */
  44 #define GRATUITOUS_ARP_MIN        0
  45 #define GRATUITOUS_ARP_MAX        255
  46 #define GRATUITOUS_ARP_DEFAULT    1
  47
  48 static const char* const bond_mode_table[_NETDEV_BOND_MODE_MAX] = {
  49         [NETDEV_BOND_MODE_BALANCE_RR] = "balance-rr",
  50         [NETDEV_BOND_MODE_ACTIVE_BACKUP] = "active-backup",
  51         [NETDEV_BOND_MODE_BALANCE_XOR] = "balance-xor",
  52         [NETDEV_BOND_MODE_BROADCAST] = "broadcast",
  53         [NETDEV_BOND_MODE_802_3AD] = "802.3ad",
  54         [NETDEV_BOND_MODE_BALANCE_TLB] = "balance-tlb",
  55         [NETDEV_BOND_MODE_BALANCE_ALB] = "balance-alb",
  56 };
  57
  58 DEFINE_STRING_TABLE_LOOKUP(bond_mode, BondMode);
  59 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_mode, bond_mode, BondMode, "Failed to parse bond mode");
  60
  61 static const char* const bond_xmit_hash_policy_table[_NETDEV_BOND_XMIT_HASH_POLICY_MAX] = {
  62         [NETDEV_BOND_XMIT_HASH_POLICY_LAYER2] = "layer2",
  63         [NETDEV_BOND_XMIT_HASH_POLICY_LAYER34] = "layer3+4",
  64         [NETDEV_BOND_XMIT_HASH_POLICY_LAYER23] = "layer2+3",
  65         [NETDEV_BOND_XMIT_HASH_POLICY_ENCAP23] = "encap2+3",
  66         [NETDEV_BOND_XMIT_HASH_POLICY_ENCAP34] = "encap3+4",
  67 };
  68
  69 DEFINE_STRING_TABLE_LOOKUP(bond_xmit_hash_policy, BondXmitHashPolicy);
  70 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_xmit_hash_policy,
  71                          bond_xmit_hash_policy,
  72                          BondXmitHashPolicy,
  73                          "Failed to parse bond transmit hash policy")
  74
  75 static const char* const bond_lacp_rate_table[_NETDEV_BOND_LACP_RATE_MAX] = {
  76         [NETDEV_BOND_LACP_RATE_SLOW] = "slow",
  77         [NETDEV_BOND_LACP_RATE_FAST] = "fast",
  78 };
  79
  80 DEFINE_STRING_TABLE_LOOKUP(bond_lacp_rate, BondLacpRate);
  81 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_lacp_rate, bond_lacp_rate, BondLacpRate, "Failed to parse bond lacp rate")
  82
  83 static const char* const bond_ad_select_table[_NETDEV_BOND_AD_SELECT_MAX] = {
  84         [NETDEV_BOND_AD_SELECT_STABLE] = "stable",
  85         [NETDEV_BOND_AD_SELECT_BANDWIDTH] = "bandwidth",
  86         [NETDEV_BOND_AD_SELECT_COUNT] = "count",
  87 };
  88
  89 DEFINE_STRING_TABLE_LOOKUP(bond_ad_select, BondAdSelect);
  90 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_ad_select, bond_ad_select, BondAdSelect, "Failed to parse bond AD select");
  91
  92 static const char* const bond_fail_over_mac_table[_NETDEV_BOND_FAIL_OVER_MAC_MAX] = {
  93         [NETDEV_BOND_FAIL_OVER_MAC_NONE] = "none",
  94         [NETDEV_BOND_FAIL_OVER_MAC_ACTIVE] = "active",
  95         [NETDEV_BOND_FAIL_OVER_MAC_FOLLOW] = "follow",
  96 };
  97
  98 DEFINE_STRING_TABLE_LOOKUP(bond_fail_over_mac, BondFailOverMac);
  99 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_fail_over_mac, bond_fail_over_mac, BondFailOverMac, "Failed to parse bond fail over MAC");
 100
 101 static const char *const bond_arp_validate_table[_NETDEV_BOND_ARP_VALIDATE_MAX] = {
 102         [NETDEV_BOND_ARP_VALIDATE_NONE] = "none",
 103         [NETDEV_BOND_ARP_VALIDATE_ACTIVE]= "active",
 104         [NETDEV_BOND_ARP_VALIDATE_BACKUP]= "backup",
 105         [NETDEV_BOND_ARP_VALIDATE_ALL]= "all",
 106 };
 107
 108 DEFINE_STRING_TABLE_LOOKUP(bond_arp_validate, BondArpValidate);
 109 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_validate, bond_arp_validate, BondArpValidate, "Failed to parse bond arp validate");
 110
 111 static const char *const bond_arp_all_targets_table[_NETDEV_BOND_ARP_ALL_TARGETS_MAX] = {
 112         [NETDEV_BOND_ARP_ALL_TARGETS_ANY] = "any",
 113         [NETDEV_BOND_ARP_ALL_TARGETS_ALL] = "all",
 114 };
 115
 116 DEFINE_STRING_TABLE_LOOKUP(bond_arp_all_targets, BondArpAllTargets);
 117 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_arp_all_targets, bond_arp_all_targets, BondArpAllTargets, "Failed to parse bond Arp all targets");
 118
 119 static const char *bond_primary_reselect_table[_NETDEV_BOND_PRIMARY_RESELECT_MAX] = {
 120         [NETDEV_BOND_PRIMARY_RESELECT_ALWAYS] = "always",
 121         [NETDEV_BOND_PRIMARY_RESELECT_BETTER]= "better",
 122         [NETDEV_BOND_PRIMARY_RESELECT_FAILURE]= "failure",
 123 };
 124
 125 DEFINE_STRING_TABLE_LOOKUP(bond_primary_reselect, BondPrimaryReselect);
 126 DEFINE_CONFIG_PARSE_ENUM(config_parse_bond_primary_reselect, bond_primary_reselect, BondPrimaryReselect, "Failed to parse bond primary reselect");
 127
 128 static uint8_t bond_mode_to_kernel(BondMode mode) {
 129         switch (mode) {
 130         case NETDEV_BOND_MODE_BALANCE_RR:
 131                 return BOND_MODE_ROUNDROBIN;
 132         case NETDEV_BOND_MODE_ACTIVE_BACKUP:
 133                 return BOND_MODE_ACTIVEBACKUP;
 134         case NETDEV_BOND_MODE_BALANCE_XOR:
 135                 return BOND_MODE_XOR;
 136         case NETDEV_BOND_MODE_BROADCAST:
 137                 return BOND_MODE_BROADCAST;
 138         case NETDEV_BOND_MODE_802_3AD:
 139                 return BOND_MODE_8023AD;
 140         case NETDEV_BOND_MODE_BALANCE_TLB:
 141                 return BOND_MODE_TLB;
 142         case NETDEV_BOND_MODE_BALANCE_ALB:
 143                 return BOND_MODE_ALB;
 144         default:
 145                 return (uint8_t) -1;
 146         }
 147 }
 148
 149 static uint8_t bond_xmit_hash_policy_to_kernel(BondXmitHashPolicy policy) {
 150         switch (policy) {
 151         case NETDEV_BOND_XMIT_HASH_POLICY_LAYER2:
 152                 return BOND_XMIT_POLICY_LAYER2;
 153         case NETDEV_BOND_XMIT_HASH_POLICY_LAYER34:
 154                 return BOND_XMIT_POLICY_LAYER34;
 155         case NETDEV_BOND_XMIT_HASH_POLICY_LAYER23:
 156                 return BOND_XMIT_POLICY_LAYER23;
 157         case NETDEV_BOND_XMIT_HASH_POLICY_ENCAP23:
 158                 return BOND_XMIT_POLICY_ENCAP23;
 159         case NETDEV_BOND_XMIT_HASH_POLICY_ENCAP34:
 160                 return BOND_XMIT_POLICY_ENCAP34;
 161         default:
 162                 return (uint8_t) -1;
 163         }
 164 }
 165
 166 static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
 167         Bond *b;
 168         ArpIpTarget *target = NULL;
 169         int r, i = 0;
 170
 171         assert(netdev);
 172         assert(!link);
 173         assert(m);
 174
 175         b = BOND(netdev);
 176
 177         assert(b);
 178
 179         if (b->mode != _NETDEV_BOND_MODE_INVALID) {
 180                 r = sd_netlink_message_append_u8(m, IFLA_BOND_MODE,
 181                                               bond_mode_to_kernel(b->mode));
 182                 if (r < 0)
 183                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MODE attribute: %m");
 184         }
 185
 186         if (b->xmit_hash_policy != _NETDEV_BOND_XMIT_HASH_POLICY_INVALID) {
 187                 r = sd_netlink_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY,
 188                                               bond_xmit_hash_policy_to_kernel(b->xmit_hash_policy));
 189                 if (r < 0)
 190                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_XMIT_HASH_POLICY attribute: %m");
 191         }
 192
 193         if (b->lacp_rate != _NETDEV_BOND_LACP_RATE_INVALID &&
 194             b->mode == NETDEV_BOND_MODE_802_3AD) {
 195                 r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate );
 196                 if (r < 0)
 197                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_LACP_RATE attribute: %m");
 198         }
 199
 200         if (b->miimon != 0) {
 201                 r = sd_netlink_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC);
 202                 if (r < 0)
 203                         log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_BOND_MIIMON attribute: %m");
 204         }
 205
 206         if (b->downdelay != 0) {
 207                 r = sd_netlink_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC);
 208                 if (r < 0)
 209                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_DOWNDELAY attribute: %m");
 210         }
 211
 212         if (b->updelay != 0) {
 213                 r = sd_netlink_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC);
 214                 if (r < 0)
 215                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_UPDELAY attribute: %m");
 216         }
 217
 218         if (b->arp_interval != 0) {
 219                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC);
 220                 if (r < 0)
 221                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_INTERVAL attribute: %m");
 222
 223                 if ((b->lp_interval >= LEARNING_PACKETS_INTERVAL_MIN_SEC) &&
 224                     (b->lp_interval <= LEARNING_PACKETS_INTERVAL_MAX_SEC)) {
 225                         r = sd_netlink_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC);
 226                         if (r < 0)
 227                                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_LP_INTERVAL attribute: %m");
 228                 }
 229         }
 230
 231         if (b->ad_select != _NETDEV_BOND_AD_SELECT_INVALID &&
 232             b->mode == NETDEV_BOND_MODE_802_3AD) {
 233                 r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select);
 234                 if (r < 0)
 235                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_SELECT attribute: %m");
 236         }
 237
 238         if (b->fail_over_mac != _NETDEV_BOND_FAIL_OVER_MAC_INVALID &&
 239             b->mode == NETDEV_BOND_MODE_ACTIVE_BACKUP) {
 240                 r = sd_netlink_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac);
 241                 if (r < 0)
 242                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_FAIL_OVER_MAC attribute: %m");
 243         }
 244
 245         if (b->arp_validate != _NETDEV_BOND_ARP_VALIDATE_INVALID) {
 246                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate);
 247                 if (r < 0)
 248                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_VALIDATE attribute: %m");
 249         }
 250
 251         if (b->arp_all_targets != _NETDEV_BOND_ARP_ALL_TARGETS_INVALID) {
 252                 r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets);
 253                 if (r < 0)
 254                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
 255         }
 256
 257         if (b->primary_reselect != _NETDEV_BOND_PRIMARY_RESELECT_INVALID) {
 258                 r = sd_netlink_message_append_u8(m, IFLA_BOND_PRIMARY_RESELECT, b->primary_reselect);
 259                 if (r < 0)
 260                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PRIMARY_RESELECT attribute: %m");
 261         }
 262
 263         if (b->resend_igmp <= RESEND_IGMP_MAX) {
 264                 r = sd_netlink_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp);
 265                 if (r < 0)
 266                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_RESEND_IGMP attribute: %m");
 267         }
 268
 269         if (b->packets_per_slave <= PACKETS_PER_SLAVE_MAX &&
 270             b->mode == NETDEV_BOND_MODE_BALANCE_RR) {
 271                 r = sd_netlink_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave);
 272                 if (r < 0)
 273                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PACKETS_PER_SLAVE attribute: %m");
 274         }
 275
 276         if (b->num_grat_arp <= GRATUITOUS_ARP_MAX) {
 277                 r = sd_netlink_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp);
 278                 if (r < 0)
 279                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_NUM_PEER_NOTIF attribute: %m");
 280         }
 281
 282         if (b->min_links != 0) {
 283                 r = sd_netlink_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links);
 284                 if (r < 0)
 285                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MIN_LINKS attribute: %m");
 286         }
 287
 288         if (b->ad_actor_sys_prio != 0) {
 289                 r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_ACTOR_SYS_PRIO, b->ad_actor_sys_prio);
 290                 if (r < 0)
 291                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYS_PRIO attribute: %m");
 292         }
 293
 294         if (b->ad_user_port_key != 0) {
 295                 r = sd_netlink_message_append_u16(m, IFLA_BOND_AD_USER_PORT_KEY, b->ad_user_port_key);
 296                 if (r < 0)
 297                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_USER_PORT_KEY attribute: %m");
 298         }
 299
 300         if (b->ad_actor_system) {
 301                 r = sd_netlink_message_append_ether_addr(m, IFLA_BOND_AD_ACTOR_SYSTEM, b->ad_actor_system);
 302                 if (r < 0)
 303                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_ACTOR_SYSTEM attribute: %m");
 304         }
 305
 306         r = sd_netlink_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active);
 307         if (r < 0)
 308                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ALL_SLAVES_ACTIVE attribute: %m");
 309
 310         if (b->arp_interval > 0)  {
 311                 if (b->n_arp_ip_targets > 0) {
 312
 313                         r = sd_netlink_message_open_container(m, IFLA_BOND_ARP_IP_TARGET);
 314                         if (r < 0)
 315                                 return log_netdev_error_errno(netdev, r, "Could not open contaniner IFLA_BOND_ARP_IP_TARGET : %m");
 316
 317                         LIST_FOREACH(arp_ip_target, target, b->arp_ip_targets) {
 318                                 r = sd_netlink_message_append_u32(m, i++, target->ip.in.s_addr);
 319                                 if (r < 0)
 320                                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
 321                         }
 322
 323                         r = sd_netlink_message_close_container(m);
 324                         if (r < 0)
 325                                 return log_netdev_error_errno(netdev, r, "Could not close contaniner IFLA_BOND_ARP_IP_TARGET : %m");
 326                 }
 327         }
 328
 329         return 0;
 330 }
 331
 332 int config_parse_arp_ip_target_address(const char *unit,
 333                                        const char *filename,
 334                                        unsigned line,
 335                                        const char *section,
 336                                        unsigned section_line,
 337                                        const char *lvalue,
 338                                        int ltype,
 339                                        const char *rvalue,
 340                                        void *data,
 341                                        void *userdata) {
 342         Bond *b = userdata;
 343         int r;
 344
 345         assert(filename);
 346         assert(lvalue);
 347         assert(rvalue);
 348         assert(data);
 349
 350         for (;;) {
 351                 _cleanup_free_ ArpIpTarget *buffer = NULL;
 352                 _cleanup_free_ char *n = NULL;
 353                 int f;
 354
 355                 r = extract_first_word(&rvalue, &n, NULL, 0);
 356                 if (r < 0) {
 357                         log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse Bond ARP ip target address, ignoring assignment: %s", rvalue);
 358                         return 0;
 359                 }
 360
 361                 if (r == 0)
 362                         break;
 363
 364                 buffer = new0(ArpIpTarget, 1);
 365                 if (!buffer)
 366                         return -ENOMEM;
 367
 368                 r = in_addr_from_string_auto(n, &f, &buffer->ip);
 369                 if (r < 0) {
 370                         log_syntax(unit, LOG_ERR, filename, line, r, "Bond ARP ip target address is invalid, ignoring assignment: %s", n);
 371                         return 0;
 372                 }
 373
 374                 if (f != AF_INET) {
 375                         log_syntax(unit, LOG_ERR, filename, line, 0, "Bond ARP ip target address is invalid, ignoring assignment: %s", n);
 376                         return 0;
 377                 }
 378
 379                 LIST_PREPEND(arp_ip_target, b->arp_ip_targets, TAKE_PTR(buffer));
 380                 b->n_arp_ip_targets++;
 381         }
 382
 383         if (b->n_arp_ip_targets > NETDEV_BOND_ARP_TARGETS_MAX)
 384                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 385                            "More than the maximum number of kernel-supported ARP ip targets specified: %d > %d",
 386                            b->n_arp_ip_targets, NETDEV_BOND_ARP_TARGETS_MAX);
 387
 388         return 0;
 389 }
 390
 391 int config_parse_ad_actor_sys_prio(const char *unit,
 392                                    const char *filename,
 393                                    unsigned line,
 394                                    const char *section,
 395                                    unsigned section_line,
 396                                    const char *lvalue,
 397                                    int ltype,
 398                                    const char *rvalue,
 399                                    void *data,
 400                                    void *userdata) {
 401         Bond *b = userdata;
 402         uint16_t v;
 403         int r;
 404
 405         assert(filename);
 406         assert(lvalue);
 407         assert(rvalue);
 408         assert(data);
 409
 410         r = safe_atou16(rvalue, &v);
 411         if (r < 0) {
 412                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse actor system priority '%s', ignoring: %m", rvalue);
 413                 return 0;
 414         }
 415
 416         if (v == 0) {
 417                 log_syntax(unit, LOG_ERR, filename, line, 0, "Failed to parse actor system priority '%s'. Range is [1,65535], ignoring.", rvalue);
 418                 return 0;
 419         }
 420
 421         b->ad_actor_sys_prio = v;
 422
 423         return 0;
 424 }
 425
 426 int config_parse_ad_user_port_key(const char *unit,
 427                                   const char *filename,
 428                                   unsigned line,
 429                                   const char *section,
 430                                   unsigned section_line,
 431                                   const char *lvalue,
 432                                   int ltype,
 433                                   const char *rvalue,
 434                                   void *data,
 435                                   void *userdata) {
 436         Bond *b = userdata;
 437         uint16_t v;
 438         int r;
 439
 440         assert(filename);
 441         assert(lvalue);
 442         assert(rvalue);
 443         assert(data);
 444
 445         r = safe_atou16(rvalue, &v);
 446         if (r < 0) {
 447                 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse user port key '%s', ignoring: %m", rvalue);
 448                 return 0;
 449         }
 450
 451         if (v > 1023) {
 452                 log_syntax(unit, LOG_ERR, filename, line, 0, "Failed to parse user port key '%s'. Range is [0,1023], ignoring.", rvalue);
 453                 return 0;
 454         }
 455
 456         b->ad_user_port_key = v;
 457
 458         return 0;
 459 }
 460
 461 int config_parse_ad_actor_system(const char *unit,
 462                                  const char *filename,
 463                                  unsigned line,
 464                                  const char *section,
 465                                  unsigned section_line,
 466                                  const char *lvalue,
 467                                  int ltype,
 468                                  const char *rvalue,
 469                                  void *data,
 470                                  void *userdata) {
 471         Bond *b = userdata;
 472         _cleanup_free_ struct ether_addr *n = NULL;
 473         int r;
 474
 475         assert(filename);
 476         assert(lvalue);
 477         assert(rvalue);
 478         assert(data);
 479
 480         n = new0(struct ether_addr, 1);
 481         if (!n)
 482                 return log_oom();
 483
 484         r = ether_addr_from_string(rvalue, n);
 485         if (r < 0) {
 486                 log_syntax(unit, LOG_ERR, filename, line, r, "Not a valid MAC address %s. Ignoring assignment: %m", rvalue);
 487                 return 0;
 488         }
 489
 490         if (ether_addr_is_null(n) || (n->ether_addr_octet[0] & 0x01)) {
 491                 log_syntax(unit, LOG_ERR, filename, line, 0, "Not a valid MAC address %s, can not be null or multicast. Ignoring assignment.", rvalue);
 492                 return 0;
 493         }
 494
 495         free_and_replace(b->ad_actor_system, n);
 496
 497         return 0;
 498 }
 499
 500 static void bond_done(NetDev *netdev) {
 501         ArpIpTarget *t = NULL, *n = NULL;
 502         Bond *b;
 503
 504         assert(netdev);
 505
 506         b = BOND(netdev);
 507
 508         assert(b);
 509
 510         free(b->ad_actor_system);
 511
 512         LIST_FOREACH_SAFE(arp_ip_target, t, n, b->arp_ip_targets)
 513                 free(t);
 514
 515         b->arp_ip_targets = NULL;
 516 }
 517
 518 static void bond_init(NetDev *netdev) {
 519         Bond *b;
 520
 521         assert(netdev);
 522
 523         b = BOND(netdev);
 524
 525         assert(b);
 526
 527         b->mode = _NETDEV_BOND_MODE_INVALID;
 528         b->xmit_hash_policy = _NETDEV_BOND_XMIT_HASH_POLICY_INVALID;
 529         b->lacp_rate = _NETDEV_BOND_LACP_RATE_INVALID;
 530         b->ad_select = _NETDEV_BOND_AD_SELECT_INVALID;
 531         b->fail_over_mac = _NETDEV_BOND_FAIL_OVER_MAC_INVALID;
 532         b->arp_validate = _NETDEV_BOND_ARP_VALIDATE_INVALID;
 533         b->arp_all_targets = _NETDEV_BOND_ARP_ALL_TARGETS_INVALID;
 534         b->primary_reselect = _NETDEV_BOND_PRIMARY_RESELECT_INVALID;
 535
 536         b->all_slaves_active = false;
 537
 538         b->resend_igmp = RESEND_IGMP_DEFAULT;
 539         b->packets_per_slave = PACKETS_PER_SLAVE_DEFAULT;
 540         b->num_grat_arp = GRATUITOUS_ARP_DEFAULT;
 541         b->lp_interval = LEARNING_PACKETS_INTERVAL_MIN_SEC;
 542
 543         LIST_HEAD_INIT(b->arp_ip_targets);
 544         b->n_arp_ip_targets = 0;
 545 }
 546
 547 const NetDevVTable bond_vtable = {
 548         .object_size = sizeof(Bond),
 549         .init = bond_init,
 550         .done = bond_done,
 551         .sections = "Match\0NetDev\0Bond\0",
 552         .fill_message_create = netdev_bond_fill_message_create,
 553         .create_type = NETDEV_CREATE_MASTER,
 554 };