src/libsystemd/sd-netlink/netlink-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "sd-netlink.h"
   4
   5 #include "ether-addr-util.h"
   6 #include "fd-util.h"
   7 #include "hashmap.h"
   8 #include "iovec-util.h"
   9 #include "log.h"
  10 #include "memory-util.h"
  11 #include "netlink-internal.h"
  12 #include "netlink-util.h"
  13 #include "parse-util.h"
  14 #include "process-util.h"
  15 #include "socket-util.h"
  16 #include "string-util.h"
  17 #include "strv.h"
  18
  19 static int parse_newlink_message(
  20                   sd_netlink_message *message,
  21                   char **ret_name,
  22                   char ***ret_altnames) {
  23
  24         _cleanup_strv_free_ char **altnames = NULL;
  25         int r, ifindex;
  26
  27         assert(message);
  28
  29         uint16_t type;
  30         r = sd_netlink_message_get_type(message, &type);
  31         if (r < 0)
  32                 return r;
  33         if (type != RTM_NEWLINK)
  34                 return -EPROTO;
  35
  36         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
  37         if (r < 0)
  38                 return r;
  39         if (ifindex <= 0)
  40                 return -EPROTO;
  41
  42         if (ret_altnames) {
  43                 r = sd_netlink_message_read_strv(message, IFLA_PROP_LIST, IFLA_ALT_IFNAME, &altnames);
  44                 if (r < 0 && r != -ENODATA)
  45                         return r;
  46         }
  47
  48         if (ret_name) {
  49                 r = sd_netlink_message_read_string_strdup(message, IFLA_IFNAME, ret_name);
  50                 if (r < 0)
  51                         return r;
  52         }
  53
  54         if (ret_altnames)
  55                 *ret_altnames = TAKE_PTR(altnames);
  56
  57         return ifindex;
  58 }
  59
  60 int rtnl_resolve_ifname_full(
  61                   sd_netlink **rtnl,
  62                   ResolveInterfaceNameFlag flags,
  63                   const char *name,
  64                   char **ret_name,
  65                   char ***ret_altnames) {
  66
  67         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
  68         int r;
  69
  70         assert(name);
  71         assert(flags > 0);
  72
  73         /* This is similar to if_nametoindex(), but also resolves alternative names and decimal formatted
  74          * ifindex too. Returns ifindex, and optionally provides the main interface name and alternative
  75          * names. */
  76
  77         if (!rtnl)
  78                 rtnl = &our_rtnl;
  79         if (!*rtnl) {
  80                 r = sd_netlink_open(rtnl);
  81                 if (r < 0)
  82                         return r;
  83         }
  84
  85         /* First, use IFLA_IFNAME */
  86         if (FLAGS_SET(flags, RESOLVE_IFNAME_MAIN) && ifname_valid(name)) {
  87                 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL, *reply = NULL;
  88
  89                 r = sd_rtnl_message_new_link(*rtnl, &message, RTM_GETLINK, 0);
  90                 if (r < 0)
  91                         return r;
  92
  93                 r = sd_netlink_message_append_string(message, IFLA_IFNAME, name);
  94                 if (r < 0)
  95                         return r;
  96
  97                 r = sd_netlink_call(*rtnl, message, 0, &reply);
  98                 if (r >= 0)
  99                         return parse_newlink_message(reply, ret_name, ret_altnames);
 100                 if (r != -ENODEV)
 101                         return r;
 102         }
 103
 104         /* Next, try IFLA_ALT_IFNAME */
 105         if (FLAGS_SET(flags, RESOLVE_IFNAME_ALTERNATIVE) &&
 106             ifname_valid_full(name, IFNAME_VALID_ALTERNATIVE)) {
 107                 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL, *reply = NULL;
 108
 109                 r = sd_rtnl_message_new_link(*rtnl, &message, RTM_GETLINK, 0);
 110                 if (r < 0)
 111                         return r;
 112
 113                 r = sd_netlink_message_append_string(message, IFLA_ALT_IFNAME, name);
 114                 if (r < 0)
 115                         return r;
 116
 117                 r = sd_netlink_call(*rtnl, message, 0, &reply);
 118                 if (r >= 0)
 119                         return parse_newlink_message(reply, ret_name, ret_altnames);
 120                 /* The kernels older than 76c9ac0ee878f6693d398d3a95ccaf85e1f597a6 (v5.5) return -EINVAL. */
 121                 if (!IN_SET(r, -ENODEV, -EINVAL))
 122                         return r;
 123         }
 124
 125         /* Finally, assume the string is a decimal formatted ifindex. */
 126         if (FLAGS_SET(flags, RESOLVE_IFNAME_NUMERIC)) {
 127                 int ifindex;
 128
 129                 ifindex = parse_ifindex(name);
 130                 if (ifindex <= 0)
 131                         return -ENODEV;
 132
 133                 return rtnl_get_ifname_full(rtnl, ifindex, ret_name, ret_altnames);
 134         }
 135
 136         return -ENODEV;
 137 }
 138
 139 int rtnl_resolve_interface_or_warn(sd_netlink **rtnl, const char *name) {
 140         int r;
 141
 142         assert(name);
 143
 144         r = rtnl_resolve_interface(rtnl, name);
 145         if (r < 0)
 146                 return log_error_errno(r, "Failed to resolve interface \"%s\": %m", name);
 147         return r;
 148 }
 149
 150 static int set_link_name(sd_netlink *rtnl, int ifindex, const char *name) {
 151         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL;
 152         int r;
 153
 154         assert(rtnl);
 155         assert(ifindex > 0);
 156         assert(name);
 157
 158         /* Assign the requested name. */
 159
 160         r = sd_rtnl_message_new_link(rtnl, &message, RTM_SETLINK, ifindex);
 161         if (r < 0)
 162                 return r;
 163
 164         r = sd_netlink_message_append_string(message, IFLA_IFNAME, name);
 165         if (r < 0)
 166                 return r;
 167
 168         return sd_netlink_call(rtnl, message, 0, NULL);
 169 }
 170
 171 int rtnl_rename_link(sd_netlink **rtnl, const char *orig_name, const char *new_name) {
 172         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
 173         int r, ifindex;
 174
 175         assert(orig_name);
 176         assert(new_name);
 177
 178         /* This does not check alternative names. Callers must check the requested name is not used as an
 179          * alternative name. */
 180
 181         if (streq(orig_name, new_name))
 182                 return 0;
 183
 184         if (!ifname_valid(new_name))
 185                 return -EINVAL;
 186
 187         if (!rtnl)
 188                 rtnl = &our_rtnl;
 189         if (!*rtnl) {
 190                 r = sd_netlink_open(rtnl);
 191                 if (r < 0)
 192                         return r;
 193         }
 194
 195         ifindex = rtnl_resolve_ifname(rtnl, orig_name);
 196         if (ifindex < 0)
 197                 return ifindex;
 198
 199         return set_link_name(*rtnl, ifindex, new_name);
 200 }
 201
 202 int rtnl_set_link_name(sd_netlink **rtnl, int ifindex, const char *name, char* const *alternative_names) {
 203         _cleanup_strv_free_ char **original_altnames = NULL, **new_altnames = NULL;
 204         bool altname_deleted = false;
 205         int r;
 206
 207         assert(ifindex > 0);
 208
 209         if (isempty(name) && strv_isempty(alternative_names))
 210                 return 0;
 211
 212         if (name && !ifname_valid(name))
 213                 return -EINVAL;
 214
 215         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
 216         if (!rtnl)
 217                 rtnl = &our_rtnl;
 218
 219         /* If the requested name is already assigned as an alternative name, then first drop it. */
 220         r = rtnl_get_link_alternative_names(rtnl, ifindex, &original_altnames);
 221         if (r < 0)
 222                 log_debug_errno(r, "Failed to get alternative names on network interface %i, ignoring: %m",
 223                                 ifindex);
 224
 225         if (name) {
 226                 if (strv_contains(original_altnames, name)) {
 227                         r = rtnl_delete_link_alternative_names(rtnl, ifindex, STRV_MAKE(name));
 228                         if (r < 0)
 229                                 return log_debug_errno(r, "Failed to remove '%s' from alternative names on network interface %i: %m",
 230                                                        name, ifindex);
 231
 232                         altname_deleted = true;
 233                 }
 234
 235                 r = set_link_name(*rtnl, ifindex, name);
 236                 if (r < 0)
 237                         goto fail;
 238         }
 239
 240         /* Filter out already assigned names from requested alternative names. Also, dedup the request. */
 241         STRV_FOREACH(a, alternative_names) {
 242                 if (streq_ptr(name, *a))
 243                         continue;
 244
 245                 if (strv_contains(original_altnames, *a))
 246                         continue;
 247
 248                 if (strv_contains(new_altnames, *a))
 249                         continue;
 250
 251                 if (!ifname_valid_full(*a, IFNAME_VALID_ALTERNATIVE))
 252                         continue;
 253
 254                 r = strv_extend(&new_altnames, *a);
 255                 if (r < 0)
 256                         return r;
 257         }
 258
 259         strv_sort(new_altnames);
 260
 261         /* Finally, assign alternative names. */
 262         r = rtnl_set_link_alternative_names(rtnl, ifindex, new_altnames);
 263         if (r == -EEXIST) /* Already assigned to another interface? */
 264                 STRV_FOREACH(a, new_altnames) {
 265                         r = rtnl_set_link_alternative_names(rtnl, ifindex, STRV_MAKE(*a));
 266                         if (r < 0)
 267                                 log_debug_errno(r, "Failed to assign '%s' as an alternative name on network interface %i, ignoring: %m",
 268                                                 *a, ifindex);
 269                 }
 270         else if (r < 0)
 271                 log_debug_errno(r, "Failed to assign alternative names on network interface %i, ignoring: %m", ifindex);
 272
 273         return 0;
 274
 275 fail:
 276         if (altname_deleted) {
 277                 int q = rtnl_set_link_alternative_names(rtnl, ifindex, STRV_MAKE(name));
 278                 if (q < 0)
 279                         log_debug_errno(q, "Failed to restore '%s' as an alternative name on network interface %i, ignoring: %m",
 280                                         name, ifindex);
 281         }
 282
 283         return r;
 284 }
 285
 286 int rtnl_set_link_properties(
 287                 sd_netlink **rtnl,
 288                 int ifindex,
 289                 const char *alias,
 290                 const struct hw_addr_data *hw_addr,
 291                 uint32_t txqueues,
 292                 uint32_t rxqueues,
 293                 uint32_t txqueuelen,
 294                 uint32_t mtu,
 295                 uint32_t gso_max_size,
 296                 size_t gso_max_segments) {
 297
 298         int r;
 299
 300         assert(ifindex > 0);
 301
 302         if (!alias &&
 303             (!hw_addr || hw_addr->length == 0) &&
 304             txqueues == 0 &&
 305             rxqueues == 0 &&
 306             txqueuelen == UINT32_MAX &&
 307             mtu == 0 &&
 308             gso_max_size == 0 &&
 309             gso_max_segments == 0)
 310                 return 0;
 311
 312         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
 313         if (!rtnl)
 314                 rtnl = &our_rtnl;
 315         if (!*rtnl) {
 316                 r = sd_netlink_open(rtnl);
 317                 if (r < 0)
 318                         return r;
 319         }
 320
 321         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL;
 322         r = sd_rtnl_message_new_link(*rtnl, &message, RTM_SETLINK, ifindex);
 323         if (r < 0)
 324                 return r;
 325
 326         if (alias) {
 327                 r = sd_netlink_message_append_string(message, IFLA_IFALIAS, alias);
 328                 if (r < 0)
 329                         return r;
 330         }
 331
 332         if (hw_addr && hw_addr->length > 0) {
 333                 r = netlink_message_append_hw_addr(message, IFLA_ADDRESS, hw_addr);
 334                 if (r < 0)
 335                         return r;
 336         }
 337
 338         if (txqueues > 0) {
 339                 r = sd_netlink_message_append_u32(message, IFLA_NUM_TX_QUEUES, txqueues);
 340                 if (r < 0)
 341                         return r;
 342         }
 343
 344         if (rxqueues > 0) {
 345                 r = sd_netlink_message_append_u32(message, IFLA_NUM_RX_QUEUES, rxqueues);
 346                 if (r < 0)
 347                         return r;
 348         }
 349
 350         if (txqueuelen < UINT32_MAX) {
 351                 r = sd_netlink_message_append_u32(message, IFLA_TXQLEN, txqueuelen);
 352                 if (r < 0)
 353                         return r;
 354         }
 355
 356         if (mtu != 0) {
 357                 r = sd_netlink_message_append_u32(message, IFLA_MTU, mtu);
 358                 if (r < 0)
 359                         return r;
 360         }
 361
 362         if (gso_max_size > 0) {
 363                 r = sd_netlink_message_append_u32(message, IFLA_GSO_MAX_SIZE, gso_max_size);
 364                 if (r < 0)
 365                         return r;
 366         }
 367
 368         if (gso_max_segments > 0) {
 369                 r = sd_netlink_message_append_u32(message, IFLA_GSO_MAX_SEGS, gso_max_segments);
 370                 if (r < 0)
 371                         return r;
 372         }
 373
 374         r = sd_netlink_call(*rtnl, message, 0, NULL);
 375         if (r < 0)
 376                 return r;
 377
 378         return 0;
 379 }
 380
 381 static int rtnl_update_link_alternative_names(
 382                 sd_netlink **rtnl,
 383                 uint16_t nlmsg_type,
 384                 int ifindex,
 385                 char* const *alternative_names) {
 386
 387         int r;
 388
 389         assert(ifindex > 0);
 390         assert(IN_SET(nlmsg_type, RTM_NEWLINKPROP, RTM_DELLINKPROP));
 391
 392         if (strv_isempty(alternative_names))
 393                 return 0;
 394
 395         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
 396         if (!rtnl)
 397                 rtnl = &our_rtnl;
 398         if (!*rtnl) {
 399                 r = sd_netlink_open(rtnl);
 400                 if (r < 0)
 401                         return r;
 402         }
 403
 404         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL;
 405         r = sd_rtnl_message_new_link(*rtnl, &message, nlmsg_type, ifindex);
 406         if (r < 0)
 407                 return r;
 408
 409         r = sd_netlink_message_open_container(message, IFLA_PROP_LIST);
 410         if (r < 0)
 411                 return r;
 412
 413         r = sd_netlink_message_append_strv(message, IFLA_ALT_IFNAME, (const char**) alternative_names);
 414         if (r < 0)
 415                 return r;
 416
 417         r = sd_netlink_message_close_container(message);
 418         if (r < 0)
 419                 return r;
 420
 421         r = sd_netlink_call(*rtnl, message, 0, NULL);
 422         if (r < 0)
 423                 return r;
 424
 425         return 0;
 426 }
 427
 428 int rtnl_set_link_alternative_names(sd_netlink **rtnl, int ifindex, char* const *alternative_names) {
 429         return rtnl_update_link_alternative_names(rtnl, RTM_NEWLINKPROP, ifindex, alternative_names);
 430 }
 431
 432 int rtnl_delete_link_alternative_names(sd_netlink **rtnl, int ifindex, char* const *alternative_names) {
 433         return rtnl_update_link_alternative_names(rtnl, RTM_DELLINKPROP, ifindex, alternative_names);
 434 }
 435
 436 int rtnl_set_link_alternative_names_by_ifname(
 437                 sd_netlink **rtnl,
 438                 const char *ifname,
 439                 char* const *alternative_names) {
 440
 441         int r;
 442
 443         assert(rtnl);
 444         assert(ifname);
 445
 446         if (strv_isempty(alternative_names))
 447                 return 0;
 448
 449         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
 450         if (!rtnl)
 451                 rtnl = &our_rtnl;
 452         if (!*rtnl) {
 453                 r = sd_netlink_open(rtnl);
 454                 if (r < 0)
 455                         return r;
 456         }
 457
 458         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL;
 459         r = sd_rtnl_message_new_link(*rtnl, &message, RTM_NEWLINKPROP, 0);
 460         if (r < 0)
 461                 return r;
 462
 463         r = sd_netlink_message_append_string(message, IFLA_IFNAME, ifname);
 464         if (r < 0)
 465                 return r;
 466
 467         r = sd_netlink_message_open_container(message, IFLA_PROP_LIST);
 468         if (r < 0)
 469                 return r;
 470
 471         r = sd_netlink_message_append_strv(message, IFLA_ALT_IFNAME, (const char**) alternative_names);
 472         if (r < 0)
 473                 return r;
 474
 475         r = sd_netlink_message_close_container(message);
 476         if (r < 0)
 477                 return r;
 478
 479         r = sd_netlink_call(*rtnl, message, 0, NULL);
 480         if (r < 0)
 481                 return r;
 482
 483         return 0;
 484 }
 485
 486 int rtnl_get_link_info_full(
 487                 sd_netlink **rtnl,
 488                 int ifindex,
 489                 char **ret_name,
 490                 char ***ret_altnames,
 491                 unsigned short *ret_iftype,
 492                 unsigned *ret_flags,
 493                 char **ret_kind,
 494                 struct hw_addr_data *ret_hw_addr,
 495                 struct hw_addr_data *ret_permanent_hw_addr) {
 496
 497         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *message = NULL, *reply = NULL;
 498         _cleanup_(sd_netlink_unrefp) sd_netlink *our_rtnl = NULL;
 499         struct hw_addr_data addr = HW_ADDR_NULL, perm_addr = HW_ADDR_NULL;
 500         _cleanup_free_ char *name = NULL, *kind = NULL;
 501         _cleanup_strv_free_ char **altnames = NULL;
 502         unsigned short iftype;
 503         unsigned flags;
 504         int r;
 505
 506         assert(ifindex > 0);
 507
 508         if (!rtnl)
 509                 rtnl = &our_rtnl;
 510         if (!*rtnl) {
 511                 r = sd_netlink_open(rtnl);
 512                 if (r < 0)
 513                         return r;
 514         }
 515
 516         r = sd_rtnl_message_new_link(*rtnl, &message, RTM_GETLINK, ifindex);
 517         if (r < 0)
 518                 return r;
 519
 520         r = sd_netlink_call(*rtnl, message, 0, &reply);
 521         if (r == -EINVAL)
 522                 return -ENODEV; /* The device does not exist */
 523         if (r < 0)
 524                 return r;
 525
 526         r = parse_newlink_message(reply, ret_name ? &name : NULL, ret_altnames ? &altnames : NULL);
 527         if (r < 0)
 528                 return r;
 529         if (r != ifindex)
 530                 return -EIO;
 531
 532         if (ret_iftype) {
 533                 r = sd_rtnl_message_link_get_type(reply, &iftype);
 534                 if (r < 0)
 535                         return r;
 536         }
 537
 538         if (ret_flags) {
 539                 r = sd_rtnl_message_link_get_flags(reply, &flags);
 540                 if (r < 0)
 541                         return r;
 542         }
 543
 544         if (ret_kind) {
 545                 r = sd_netlink_message_enter_container(reply, IFLA_LINKINFO);
 546                 if (r >= 0) {
 547                         r = sd_netlink_message_read_string_strdup(reply, IFLA_INFO_KIND, &kind);
 548                         if (r < 0 && r != -ENODATA)
 549                                 return r;
 550
 551                         r = sd_netlink_message_exit_container(reply);
 552                         if (r < 0)
 553                                 return r;
 554                 }
 555         }
 556
 557         if (ret_hw_addr) {
 558                 r = netlink_message_read_hw_addr(reply, IFLA_ADDRESS, &addr);
 559                 if (r < 0 && r != -ENODATA)
 560                         return r;
 561         }
 562
 563         if (ret_permanent_hw_addr) {
 564                 r = netlink_message_read_hw_addr(reply, IFLA_PERM_ADDRESS, &perm_addr);
 565                 if (r < 0 && r != -ENODATA)
 566                         return r;
 567         }
 568
 569         if (ret_name)
 570                 *ret_name = TAKE_PTR(name);
 571         if (ret_altnames)
 572                 *ret_altnames = TAKE_PTR(altnames);
 573         if (ret_iftype)
 574                 *ret_iftype = iftype;
 575         if (ret_flags)
 576                 *ret_flags = flags;
 577         if (ret_kind)
 578                 *ret_kind = TAKE_PTR(kind);
 579         if (ret_hw_addr)
 580                 *ret_hw_addr = addr;
 581         if (ret_permanent_hw_addr)
 582                 *ret_permanent_hw_addr = perm_addr;
 583         return ifindex;
 584 }
 585
 586 int rtnl_log_parse_error(int r) {
 587         return log_error_errno(r, "Failed to parse netlink message: %m");
 588 }
 589
 590 int rtnl_log_create_error(int r) {
 591         return log_error_errno(r, "Failed to create netlink message: %m");
 592 }
 593
 594 void rtattr_append_attribute_internal(struct rtattr *rta, unsigned short type, const void *data, size_t data_length) {
 595         size_t padding_length;
 596         uint8_t *padding;
 597
 598         assert(rta);
 599         assert(!data || data_length > 0);
 600
 601         /* fill in the attribute */
 602         rta->rta_type = type;
 603         rta->rta_len = RTA_LENGTH(data_length);
 604         if (data)
 605                 /* we don't deal with the case where the user lies about the type
 606                  * and gives us too little data (so don't do that)
 607                  */
 608                 padding = mempcpy(RTA_DATA(rta), data, data_length);
 609
 610         else
 611                 /* if no data was passed, make sure we still initialize the padding
 612                    note that we can have data_length > 0 (used by some containers) */
 613                 padding = RTA_DATA(rta);
 614
 615         /* make sure also the padding at the end of the message is initialized */
 616         padding_length = (uint8_t *) rta + RTA_SPACE(data_length) - padding;
 617         memzero(padding, padding_length);
 618 }
 619
 620 int rtattr_append_attribute(struct rtattr **rta, unsigned short type, const void *data, size_t data_length) {
 621         struct rtattr *new_rta, *sub_rta;
 622         size_t message_length;
 623
 624         assert(rta);
 625         assert(!data || data_length > 0);
 626
 627         /* get the new message size (with padding at the end) */
 628         message_length = RTA_ALIGN(rta ? (*rta)->rta_len : 0) + RTA_SPACE(data_length);
 629
 630         /* buffer should be smaller than both one page or 8K to be accepted by the kernel */
 631         if (message_length > MIN(page_size(), 8192UL))
 632                 return -ENOBUFS;
 633
 634         /* realloc to fit the new attribute */
 635         new_rta = realloc(*rta, message_length);
 636         if (!new_rta)
 637                 return -ENOMEM;
 638         *rta = new_rta;
 639
 640         /* get pointer to the attribute we are about to add */
 641         sub_rta = (struct rtattr *) ((uint8_t *) *rta + RTA_ALIGN((*rta)->rta_len));
 642
 643         rtattr_append_attribute_internal(sub_rta, type, data, data_length);
 644
 645         /* update rta_len */
 646         (*rta)->rta_len = message_length;
 647
 648         return 0;
 649 }
 650
 651 bool netlink_pid_changed(sd_netlink *nl) {
 652         /* We don't support people creating an nl connection and
 653          * keeping it around over a fork(). Let's complain. */
 654         return ASSERT_PTR(nl)->original_pid != getpid_cached();
 655 }
 656
 657 static int socket_open(int family) {
 658         int fd;
 659
 660         fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, family);
 661         if (fd < 0)
 662                 return -errno;
 663
 664         return fd_move_above_stdio(fd);
 665 }
 666
 667 int netlink_open_family(sd_netlink **ret, int family) {
 668         _cleanup_close_ int fd = -EBADF;
 669         int r;
 670
 671         fd = socket_open(family);
 672         if (fd < 0)
 673                 return fd;
 674
 675         r = sd_netlink_open_fd(ret, fd);
 676         if (r < 0)
 677                 return r;
 678         TAKE_FD(fd);
 679
 680         return 0;
 681 }
 682
 683 static bool serial_used(sd_netlink *nl, uint32_t serial) {
 684         assert(nl);
 685
 686         return
 687                 hashmap_contains(nl->reply_callbacks, UINT32_TO_PTR(serial)) ||
 688                 hashmap_contains(nl->rqueue_by_serial, UINT32_TO_PTR(serial)) ||
 689                 hashmap_contains(nl->rqueue_partial_by_serial, UINT32_TO_PTR(serial));
 690 }
 691
 692 void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m) {
 693         uint32_t picked;
 694
 695         assert(nl);
 696         assert(!netlink_pid_changed(nl));
 697         assert(m);
 698         assert(m->hdr);
 699
 700         /* Avoid collisions with outstanding requests */
 701         do {
 702                 picked = nl->serial;
 703
 704                 /* Don't use seq == 0, as that is used for broadcasts, so we would get confused by replies to
 705                    such messages */
 706                 nl->serial = nl->serial == UINT32_MAX ? 1 : nl->serial + 1;
 707
 708         } while (serial_used(nl, picked));
 709
 710         m->hdr->nlmsg_seq = picked;
 711         message_seal(m);
 712 }
 713
 714 static int socket_writev_message(sd_netlink *nl, sd_netlink_message **m, size_t msgcount) {
 715         _cleanup_free_ struct iovec *iovs = NULL;
 716         ssize_t k;
 717
 718         assert(nl);
 719         assert(m);
 720         assert(msgcount > 0);
 721
 722         iovs = new(struct iovec, msgcount);
 723         if (!iovs)
 724                 return -ENOMEM;
 725
 726         for (size_t i = 0; i < msgcount; i++) {
 727                 assert(m[i]->hdr);
 728                 assert(m[i]->hdr->nlmsg_len > 0);
 729
 730                 iovs[i] = IOVEC_MAKE(m[i]->hdr, m[i]->hdr->nlmsg_len);
 731         }
 732
 733         k = writev(nl->fd, iovs, msgcount);
 734         if (k < 0)
 735                 return -errno;
 736
 737         return k;
 738 }
 739
 740 int sd_netlink_sendv(
 741                 sd_netlink *nl,
 742                 sd_netlink_message **messages,
 743                 size_t msgcount,
 744                 uint32_t **ret_serial) {
 745
 746         _cleanup_free_ uint32_t *serials = NULL;
 747         int r;
 748
 749         assert_return(nl, -EINVAL);
 750         assert_return(!netlink_pid_changed(nl), -ECHILD);
 751         assert_return(messages, -EINVAL);
 752         assert_return(msgcount > 0, -EINVAL);
 753
 754         if (ret_serial) {
 755                 serials = new(uint32_t, msgcount);
 756                 if (!serials)
 757                         return -ENOMEM;
 758         }
 759
 760         for (size_t i = 0; i < msgcount; i++) {
 761                 assert_return(!messages[i]->sealed, -EPERM);
 762
 763                 netlink_seal_message(nl, messages[i]);
 764                 if (serials)
 765                         serials[i] = message_get_serial(messages[i]);
 766         }
 767
 768         r = socket_writev_message(nl, messages, msgcount);
 769         if (r < 0)
 770                 return r;
 771
 772         if (ret_serial)
 773                 *ret_serial = TAKE_PTR(serials);
 774
 775         return r;
 776 }