src/libsystemd/sd-rtnl/rtnl-message.c

   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 #include <netinet/in.h>
  23 #include <netinet/ether.h>
  24 #include <stdbool.h>
  25 #include <unistd.h>
  26 #include <linux/netlink.h>
  27 #include <linux/veth.h>
  28 #include <linux/if.h>
  29 #include <linux/ip.h>
  30 #include <linux/if_tunnel.h>
  31 #include <linux/if_bridge.h>
  32
  33 #include "util.h"
  34 #include "refcnt.h"
  35 #include "missing.h"
  36
  37 #include "sd-rtnl.h"
  38 #include "rtnl-util.h"
  39 #include "rtnl-internal.h"
  40 #include "rtnl-types.h"
  41
  42 #define GET_CONTAINER(m, i) ((i) < (m)->n_containers ? (struct rtattr*)((uint8_t*)(m)->hdr + (m)->container_offsets[i]) : NULL)
  43 #define PUSH_CONTAINER(m, new) (m)->container_offsets[(m)->n_containers ++] = (uint8_t*)(new) - (uint8_t*)(m)->hdr;
  44
  45 static int message_new_empty(sd_rtnl *rtnl, sd_rtnl_message **ret) {
  46         sd_rtnl_message *m;
  47
  48         assert_return(ret, -EINVAL);
  49
  50         /* Note that 'rtnl' is curretly unused, if we start using it internally
  51            we must take care to avoid problems due to mutual references between
  52            busses and their queued messages. See sd-bus.
  53          */
  54
  55         m = new0(sd_rtnl_message, 1);
  56         if (!m)
  57                 return -ENOMEM;
  58
  59         m->n_ref = REFCNT_INIT;
  60
  61         m->sealed = false;
  62
  63         *ret = m;
  64
  65         return 0;
  66 }
  67
  68 int message_new(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t type) {
  69         _cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
  70         const NLType *nl_type;
  71         size_t size;
  72         int r;
  73
  74         r = type_system_get_type(NULL, &nl_type, type);
  75         if (r < 0)
  76                 return r;
  77
  78         assert(nl_type->type == NLA_NESTED);
  79
  80         r = message_new_empty(rtnl, &m);
  81         if (r < 0)
  82                 return r;
  83
  84         size = NLMSG_SPACE(nl_type->size);
  85
  86         assert(size >= sizeof(struct nlmsghdr));
  87         m->hdr = malloc0(size);
  88         if (!m->hdr)
  89                 return -ENOMEM;
  90
  91         m->hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
  92
  93         m->container_type_system[0] = nl_type->type_system;
  94         m->hdr->nlmsg_len = size;
  95         m->hdr->nlmsg_type = type;
  96
  97         *ret = m;
  98         m = NULL;
  99
 100         return 0;
 101 }
 102
 103 int sd_rtnl_message_route_set_dst_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
 104         struct rtmsg *rtm;
 105
 106         assert_return(m, -EINVAL);
 107         assert_return(m->hdr, -EINVAL);
 108         assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
 109
 110         rtm = NLMSG_DATA(m->hdr);
 111
 112         if ((rtm->rtm_family == AF_INET && prefixlen > 32) ||
 113             (rtm->rtm_family == AF_INET6 && prefixlen > 128))
 114                 return -ERANGE;
 115
 116         rtm->rtm_dst_len = prefixlen;
 117
 118         return 0;
 119 }
 120
 121 int sd_rtnl_message_route_set_scope(sd_rtnl_message *m, unsigned char scope) {
 122         struct rtmsg *rtm;
 123
 124         assert_return(m, -EINVAL);
 125         assert_return(m->hdr, -EINVAL);
 126         assert_return(rtnl_message_type_is_route(m->hdr->nlmsg_type), -EINVAL);
 127
 128         rtm = NLMSG_DATA(m->hdr);
 129
 130         rtm->rtm_scope = scope;
 131
 132         return 0;
 133 }
 134
 135 int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret,
 136                               uint16_t nlmsg_type, unsigned char rtm_family) {
 137         struct rtmsg *rtm;
 138         int r;
 139
 140         assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL);
 141         assert_return(rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL);
 142         assert_return(ret, -EINVAL);
 143
 144         r = message_new(rtnl, ret, nlmsg_type);
 145         if (r < 0)
 146                 return r;
 147
 148         if (nlmsg_type == RTM_NEWROUTE)
 149                 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
 150
 151         rtm = NLMSG_DATA((*ret)->hdr);
 152
 153         rtm->rtm_family = rtm_family;
 154         rtm->rtm_scope = RT_SCOPE_UNIVERSE;
 155         rtm->rtm_type = RTN_UNICAST;
 156         rtm->rtm_table = RT_TABLE_MAIN;
 157         rtm->rtm_protocol = RTPROT_BOOT;
 158
 159         return 0;
 160 }
 161
 162 int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags, unsigned change) {
 163         struct ifinfomsg *ifi;
 164
 165         assert_return(m, -EINVAL);
 166         assert_return(m->hdr, -EINVAL);
 167         assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
 168         assert_return(change, -EINVAL);
 169
 170         ifi = NLMSG_DATA(m->hdr);
 171
 172         ifi->ifi_flags = flags;
 173         ifi->ifi_change = change;
 174
 175         return 0;
 176 }
 177
 178 int sd_rtnl_message_link_set_type(sd_rtnl_message *m, unsigned type) {
 179         struct ifinfomsg *ifi;
 180
 181         assert_return(m, -EINVAL);
 182         assert_return(m->hdr, -EINVAL);
 183         assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
 184
 185         ifi = NLMSG_DATA(m->hdr);
 186
 187         ifi->ifi_type = type;
 188
 189         return 0;
 190 }
 191
 192 int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret,
 193                              uint16_t nlmsg_type, int index) {
 194         struct ifinfomsg *ifi;
 195         int r;
 196
 197         assert_return(rtnl_message_type_is_link(nlmsg_type), -EINVAL);
 198         assert_return(nlmsg_type != RTM_DELLINK || index > 0, -EINVAL);
 199         assert_return(ret, -EINVAL);
 200
 201         r = message_new(rtnl, ret, nlmsg_type);
 202         if (r < 0)
 203                 return r;
 204
 205         if (nlmsg_type == RTM_NEWLINK)
 206                 (*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
 207
 208         ifi = NLMSG_DATA((*ret)->hdr);
 209
 210         ifi->ifi_family = AF_UNSPEC;
 211         ifi->ifi_index = index;
 212
 213         return 0;
 214 }
 215
 216 int sd_rtnl_message_addr_set_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
 217         struct ifaddrmsg *ifa;
 218
 219         assert_return(m, -EINVAL);
 220         assert_return(m->hdr, -EINVAL);
 221         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 222
 223         ifa = NLMSG_DATA(m->hdr);
 224
 225         if ((ifa->ifa_family == AF_INET && prefixlen > 32) ||
 226             (ifa->ifa_family == AF_INET6 && prefixlen > 128))
 227                 return -ERANGE;
 228
 229         ifa->ifa_prefixlen = prefixlen;
 230
 231         return 0;
 232 }
 233
 234 int sd_rtnl_message_addr_set_flags(sd_rtnl_message *m, unsigned char flags) {
 235         struct ifaddrmsg *ifa;
 236
 237         assert_return(m, -EINVAL);
 238         assert_return(m->hdr, -EINVAL);
 239         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 240
 241         ifa = NLMSG_DATA(m->hdr);
 242
 243         ifa->ifa_flags = flags;
 244
 245         return 0;
 246 }
 247
 248 int sd_rtnl_message_addr_set_scope(sd_rtnl_message *m, unsigned char scope) {
 249         struct ifaddrmsg *ifa;
 250
 251         assert_return(m, -EINVAL);
 252         assert_return(m->hdr, -EINVAL);
 253         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 254
 255         ifa = NLMSG_DATA(m->hdr);
 256
 257         ifa->ifa_scope = scope;
 258
 259         return 0;
 260 }
 261
 262 int sd_rtnl_message_addr_get_family(sd_rtnl_message *m, unsigned char *family) {
 263         struct ifaddrmsg *ifa;
 264
 265         assert_return(m, -EINVAL);
 266         assert_return(m->hdr, -EINVAL);
 267         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 268         assert_return(family, -EINVAL);
 269
 270         ifa = NLMSG_DATA(m->hdr);
 271
 272         *family = ifa->ifa_family;
 273
 274         return 0;
 275 }
 276
 277 int sd_rtnl_message_addr_get_scope(sd_rtnl_message *m, unsigned char *scope) {
 278         struct ifaddrmsg *ifa;
 279
 280         assert_return(m, -EINVAL);
 281         assert_return(m->hdr, -EINVAL);
 282         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 283         assert_return(scope, -EINVAL);
 284
 285         ifa = NLMSG_DATA(m->hdr);
 286
 287         *scope = ifa->ifa_scope;
 288
 289         return 0;
 290 }
 291
 292 int sd_rtnl_message_addr_get_flags(sd_rtnl_message *m, unsigned char *flags) {
 293         struct ifaddrmsg *ifa;
 294
 295         assert_return(m, -EINVAL);
 296         assert_return(m->hdr, -EINVAL);
 297         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 298         assert_return(flags, -EINVAL);
 299
 300         ifa = NLMSG_DATA(m->hdr);
 301
 302         *flags = ifa->ifa_flags;
 303
 304         return 0;
 305 }
 306
 307 int sd_rtnl_message_addr_get_ifindex(sd_rtnl_message *m, int *ifindex) {
 308         struct ifaddrmsg *ifa;
 309
 310         assert_return(m, -EINVAL);
 311         assert_return(m->hdr, -EINVAL);
 312         assert_return(rtnl_message_type_is_addr(m->hdr->nlmsg_type), -EINVAL);
 313         assert_return(ifindex, -EINVAL);
 314
 315         ifa = NLMSG_DATA(m->hdr);
 316
 317         *ifindex = ifa->ifa_index;
 318
 319         return 0;
 320 }
 321
 322 int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret,
 323                              uint16_t nlmsg_type, int index,
 324                              unsigned char family) {
 325         struct ifaddrmsg *ifa;
 326         int r;
 327
 328         assert_return(rtnl_message_type_is_addr(nlmsg_type), -EINVAL);
 329         assert_return(index > 0, -EINVAL);
 330         assert_return(family == AF_INET || family == AF_INET6, -EINVAL);
 331         assert_return(ret, -EINVAL);
 332
 333         r = message_new(rtnl, ret, nlmsg_type);
 334         if (r < 0)
 335                 return r;
 336
 337         if (nlmsg_type == RTM_GETADDR && family == AF_INET)
 338                 (*ret)->hdr->nlmsg_flags |= NLM_F_DUMP;
 339
 340         ifa = NLMSG_DATA((*ret)->hdr);
 341
 342         ifa->ifa_index = index;
 343         ifa->ifa_family = family;
 344         if (family == AF_INET)
 345                 ifa->ifa_prefixlen = 32;
 346         else if (family == AF_INET6)
 347                 ifa->ifa_prefixlen = 128;
 348
 349         return 0;
 350 }
 351
 352 int sd_rtnl_message_new_addr_update(sd_rtnl *rtnl, sd_rtnl_message **ret,
 353                              int index, unsigned char family) {
 354         int r;
 355
 356         r = sd_rtnl_message_new_addr(rtnl, ret, RTM_NEWADDR, index, family);
 357         if (r < 0)
 358                 return r;
 359
 360         (*ret)->hdr->nlmsg_flags |= NLM_F_REPLACE;
 361
 362         return 0;
 363 }
 364
 365 sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m) {
 366         if (m)
 367                 assert_se(REFCNT_INC(m->n_ref) >= 2);
 368
 369         return m;
 370 }
 371
 372 sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) {
 373         if (m && REFCNT_DEC(m->n_ref) <= 0) {
 374                 unsigned i;
 375
 376                 free(m->hdr);
 377
 378                 for (i = 0; i <= m->n_containers; i++)
 379                         free(m->rta_offset_tb[i]);
 380
 381                 free(m);
 382         }
 383
 384         return NULL;
 385 }
 386
 387 int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) {
 388         assert_return(m, -EINVAL);
 389         assert_return(type, -EINVAL);
 390
 391         *type = m->hdr->nlmsg_type;
 392
 393         return 0;
 394 }
 395
 396 int sd_rtnl_message_is_broadcast(sd_rtnl_message *m) {
 397         assert_return(m, -EINVAL);
 398
 399         return !m->hdr->nlmsg_pid;
 400 }
 401
 402 int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) {
 403         struct ifinfomsg *ifi;
 404
 405         assert_return(m, -EINVAL);
 406         assert_return(m->hdr, -EINVAL);
 407         assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
 408         assert_return(ifindex, -EINVAL);
 409
 410         ifi = NLMSG_DATA(m->hdr);
 411
 412         *ifindex = ifi->ifi_index;
 413
 414         return 0;
 415 }
 416
 417 int sd_rtnl_message_link_get_flags(sd_rtnl_message *m, unsigned *flags) {
 418         struct ifinfomsg *ifi;
 419
 420         assert_return(m, -EINVAL);
 421         assert_return(m->hdr, -EINVAL);
 422         assert_return(rtnl_message_type_is_link(m->hdr->nlmsg_type), -EINVAL);
 423         assert_return(flags, -EINVAL);
 424
 425         ifi = NLMSG_DATA(m->hdr);
 426
 427         *flags = ifi->ifi_flags;
 428
 429         return 0;
 430 }
 431
 432 /* If successful the updated message will be correctly aligned, if
 433    unsuccessful the old message is untouched. */
 434 static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, size_t data_length) {
 435         uint32_t rta_length, message_length;
 436         struct nlmsghdr *new_hdr;
 437         struct rtattr *rta;
 438         char *padding;
 439         unsigned i;
 440
 441         assert(m);
 442         assert(m->hdr);
 443         assert(!m->sealed);
 444         assert(NLMSG_ALIGN(m->hdr->nlmsg_len) == m->hdr->nlmsg_len);
 445         assert(!data || data_length > 0);
 446         assert(data || m->n_containers < RTNL_CONTAINER_DEPTH);
 447
 448         /* get the size of the new rta attribute (with padding at the end) */
 449         rta_length = RTA_LENGTH(data_length);
 450
 451         /* get the new message size (with padding at the end) */
 452         message_length = m->hdr->nlmsg_len + RTA_ALIGN(rta_length);
 453
 454         /* realloc to fit the new attribute */
 455         new_hdr = realloc(m->hdr, message_length);
 456         if (!new_hdr)
 457                 return -ENOMEM;
 458         m->hdr = new_hdr;
 459
 460         /* get pointer to the attribute we are about to add */
 461         rta = (struct rtattr *) ((uint8_t *) m->hdr + m->hdr->nlmsg_len);
 462
 463         /* if we are inside containers, extend them */
 464         for (i = 0; i < m->n_containers; i++)
 465                 GET_CONTAINER(m, i)->rta_len += message_length - m->hdr->nlmsg_len;
 466
 467         /* fill in the attribute */
 468         rta->rta_type = type;
 469         rta->rta_len = rta_length;
 470         if (!data) {
 471                 //TODO: simply return this value rather than check for !data
 472                 /* this is the start of a new container */
 473                 m->container_offsets[m->n_containers ++] = m->hdr->nlmsg_len;
 474         } else {
 475                 /* we don't deal with the case where the user lies about the type
 476                  * and gives us too little data (so don't do that)
 477                 */
 478                 padding = mempcpy(RTA_DATA(rta), data, data_length);
 479                 /* make sure also the padding at the end of the message is initialized */
 480                 memzero(padding,
 481                         (uint8_t *) m->hdr + message_length - (uint8_t *) padding);
 482         }
 483
 484         /* update message size */
 485         m->hdr->nlmsg_len = message_length;
 486
 487         return 0;
 488 }
 489
 490 static int message_attribute_has_type(sd_rtnl_message *m, uint16_t attribute_type, uint16_t data_type) {
 491         const NLType *type;
 492         int r;
 493
 494         r = type_system_get_type(m->container_type_system[m->n_containers], &type, attribute_type);
 495         if (r < 0)
 496                 return r;
 497
 498         if (type->type != data_type)
 499                 return -EINVAL;
 500
 501         return type->size;
 502 }
 503
 504 int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const char *data) {
 505         size_t length, size;
 506         int r;
 507
 508         assert_return(m, -EINVAL);
 509         assert_return(!m->sealed, -EPERM);
 510         assert_return(data, -EINVAL);
 511
 512         r = message_attribute_has_type(m, type, NLA_STRING);
 513         if (r < 0)
 514                 return r;
 515         else
 516                 size = (size_t)r;
 517
 518         if (size) {
 519                 length = strnlen(data, size);
 520                 if (length >= size)
 521                         return -EINVAL;
 522         } else
 523                 length = strlen(data);
 524
 525         r = add_rtattr(m, type, data, length + 1);
 526         if (r < 0)
 527                 return r;
 528
 529         return 0;
 530 }
 531
 532 int sd_rtnl_message_append_u8(sd_rtnl_message *m, unsigned short type, uint8_t data) {
 533         int r;
 534
 535         assert_return(m, -EINVAL);
 536         assert_return(!m->sealed, -EPERM);
 537
 538         r = message_attribute_has_type(m, type, NLA_U8);
 539         if (r < 0)
 540                 return r;
 541
 542         r = add_rtattr(m, type, &data, sizeof(uint8_t));
 543         if (r < 0)
 544                 return r;
 545
 546         return 0;
 547 }
 548
 549
 550 int sd_rtnl_message_append_u16(sd_rtnl_message *m, unsigned short type, uint16_t data) {
 551         int r;
 552
 553         assert_return(m, -EINVAL);
 554         assert_return(!m->sealed, -EPERM);
 555
 556         r = message_attribute_has_type(m, type, NLA_U16);
 557         if (r < 0)
 558                 return r;
 559
 560         r = add_rtattr(m, type, &data, sizeof(uint16_t));
 561         if (r < 0)
 562                 return r;
 563
 564         return 0;
 565 }
 566
 567 int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t data) {
 568         int r;
 569
 570         assert_return(m, -EINVAL);
 571         assert_return(!m->sealed, -EPERM);
 572
 573         r = message_attribute_has_type(m, type, NLA_U32);
 574         if (r < 0)
 575                 return r;
 576
 577         r = add_rtattr(m, type, &data, sizeof(uint32_t));
 578         if (r < 0)
 579                 return r;
 580
 581         return 0;
 582 }
 583
 584 int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, const struct in_addr *data) {
 585         int r;
 586
 587         assert_return(m, -EINVAL);
 588         assert_return(!m->sealed, -EPERM);
 589         assert_return(data, -EINVAL);
 590
 591         r = message_attribute_has_type(m, type, NLA_IN_ADDR);
 592         if (r < 0)
 593                 return r;
 594
 595         r = add_rtattr(m, type, data, sizeof(struct in_addr));
 596         if (r < 0)
 597                 return r;
 598
 599         return 0;
 600 }
 601
 602 int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, const struct in6_addr *data) {
 603         int r;
 604
 605         assert_return(m, -EINVAL);
 606         assert_return(!m->sealed, -EPERM);
 607         assert_return(data, -EINVAL);
 608
 609         r = message_attribute_has_type(m, type, NLA_IN_ADDR);
 610         if (r < 0)
 611                 return r;
 612
 613         r = add_rtattr(m, type, data, sizeof(struct in6_addr));
 614         if (r < 0)
 615                 return r;
 616
 617         return 0;
 618 }
 619
 620 int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, const struct ether_addr *data) {
 621         int r;
 622
 623         assert_return(m, -EINVAL);
 624         assert_return(!m->sealed, -EPERM);
 625         assert_return(data, -EINVAL);
 626
 627         r = message_attribute_has_type(m, type, NLA_ETHER_ADDR);
 628         if (r < 0)
 629                 return r;
 630
 631         r = add_rtattr(m, type, data, ETH_ALEN);
 632         if (r < 0)
 633                 return r;
 634
 635         return 0;
 636 }
 637
 638 int sd_rtnl_message_append_cache_info(sd_rtnl_message *m, unsigned short type, const struct ifa_cacheinfo *info) {
 639         int r;
 640
 641         assert_return(m, -EINVAL);
 642         assert_return(!m->sealed, -EPERM);
 643         assert_return(info, -EINVAL);
 644
 645         r = message_attribute_has_type(m, type, NLA_CACHE_INFO);
 646         if (r < 0)
 647                 return r;
 648
 649         r = add_rtattr(m, type, info, sizeof(struct ifa_cacheinfo));
 650         if (r < 0)
 651                 return r;
 652
 653         return 0;
 654 }
 655
 656 int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) {
 657         size_t size;
 658         int r;
 659
 660         assert_return(m, -EINVAL);
 661         assert_return(!m->sealed, -EPERM);
 662
 663         r = message_attribute_has_type(m, type, NLA_NESTED);
 664         if (r < 0)
 665                 return r;
 666         else
 667                 size = (size_t)r;
 668
 669         r = type_system_get_type_system(m->container_type_system[m->n_containers],
 670                                         &m->container_type_system[m->n_containers + 1],
 671                                         type);
 672         if (r < 0)
 673                 return r;
 674
 675         r = add_rtattr(m, type, NULL, size);
 676         if (r < 0)
 677                 return r;
 678
 679         return 0;
 680 }
 681
 682 int sd_rtnl_message_open_container_union(sd_rtnl_message *m, unsigned short type, const char *key) {
 683         const NLTypeSystemUnion *type_system_union;
 684         int r;
 685
 686         assert_return(m, -EINVAL);
 687         assert_return(!m->sealed, -EPERM);
 688
 689         r = type_system_get_type_system_union(m->container_type_system[m->n_containers], &type_system_union, type);
 690         if (r < 0)
 691                 return r;
 692
 693         r = type_system_union_get_type_system(type_system_union,
 694                                               &m->container_type_system[m->n_containers + 1],
 695                                               key);
 696         if (r < 0)
 697                 return r;
 698
 699         r = sd_rtnl_message_append_string(m, type_system_union->match, key);
 700         if (r < 0)
 701                 return r;
 702
 703         /* do we evere need non-null size */
 704         r = add_rtattr(m, type, NULL, 0);
 705         if (r < 0)
 706                 return r;
 707
 708         return 0;
 709 }
 710
 711
 712 int sd_rtnl_message_close_container(sd_rtnl_message *m) {
 713         assert_return(m, -EINVAL);
 714         assert_return(!m->sealed, -EPERM);
 715         assert_return(m->n_containers > 0, -EINVAL);
 716
 717         m->container_type_system[m->n_containers] = NULL;
 718         m->n_containers --;
 719
 720         return 0;
 721 }
 722
 723 int rtnl_message_read_internal(sd_rtnl_message *m, unsigned short type, void **data) {
 724         struct rtattr *rta;
 725
 726         assert_return(m, -EINVAL);
 727         assert_return(m->sealed, -EPERM);
 728         assert_return(data, -EINVAL);
 729         assert(m->n_containers <= RTNL_CONTAINER_DEPTH);
 730         assert(m->rta_offset_tb[m->n_containers]);
 731         assert(type < m->rta_tb_size[m->n_containers]);
 732
 733         if(!m->rta_offset_tb[m->n_containers][type])
 734                 return -ENODATA;
 735
 736         rta = (struct rtattr*)((uint8_t *) m->hdr + m->rta_offset_tb[m->n_containers][type]);
 737
 738         *data = RTA_DATA(rta);
 739
 740         return RTA_PAYLOAD(rta);
 741 }
 742
 743 int sd_rtnl_message_read_string(sd_rtnl_message *m, unsigned short type, char **data) {
 744         int r;
 745         void *attr_data;
 746
 747         r = message_attribute_has_type(m, type, NLA_STRING);
 748         if (r < 0)
 749                 return r;
 750
 751         r = rtnl_message_read_internal(m, type, &attr_data);
 752         if (r < 0)
 753                 return r;
 754         else if (strnlen(attr_data, r) >= (size_t) r)
 755                 return -EIO;
 756
 757         *data = (char *) attr_data;
 758
 759         return 0;
 760 }
 761
 762 int sd_rtnl_message_read_u8(sd_rtnl_message *m, unsigned short type, uint8_t *data) {
 763         int r;
 764         void *attr_data;
 765
 766         r = message_attribute_has_type(m, type, NLA_U8);
 767         if (r < 0)
 768                 return r;
 769
 770         r = rtnl_message_read_internal(m, type, &attr_data);
 771         if (r < 0)
 772                 return r;
 773         else if ((size_t) r < sizeof(uint8_t))
 774                 return -EIO;
 775
 776         *data = *(uint8_t *) attr_data;
 777
 778         return 0;
 779 }
 780
 781 int sd_rtnl_message_read_u16(sd_rtnl_message *m, unsigned short type, uint16_t *data) {
 782         int r;
 783         void *attr_data;
 784
 785         r = message_attribute_has_type(m, type, NLA_U16);
 786         if (r < 0)
 787                 return r;
 788
 789         r = rtnl_message_read_internal(m, type, &attr_data);
 790         if (r < 0)
 791                 return r;
 792         else if ((size_t) r < sizeof(uint16_t))
 793                 return -EIO;
 794
 795         *data = *(uint16_t *) attr_data;
 796
 797         return 0;
 798 }
 799
 800 int sd_rtnl_message_read_u32(sd_rtnl_message *m, unsigned short type, uint32_t *data) {
 801         int r;
 802         void *attr_data;
 803
 804         r = message_attribute_has_type(m, type, NLA_U32);
 805         if (r < 0)
 806                 return r;
 807
 808         r = rtnl_message_read_internal(m, type, &attr_data);
 809         if (r < 0)
 810                 return r;
 811         else if ((size_t)r < sizeof(uint32_t))
 812                 return -EIO;
 813
 814         *data = *(uint32_t *) attr_data;
 815
 816         return 0;
 817 }
 818
 819 int sd_rtnl_message_read_ether_addr(sd_rtnl_message *m, unsigned short type, struct ether_addr *data) {
 820         int r;
 821         void *attr_data;
 822
 823         r = message_attribute_has_type(m, type, NLA_ETHER_ADDR);
 824         if (r < 0)
 825                 return r;
 826
 827         r = rtnl_message_read_internal(m, type, &attr_data);
 828         if (r < 0)
 829                 return r;
 830         else if ((size_t)r < sizeof(struct ether_addr))
 831                 return -EIO;
 832
 833         memcpy(data, attr_data, sizeof(struct ether_addr));
 834
 835         return 0;
 836 }
 837
 838 int sd_rtnl_message_read_cache_info(sd_rtnl_message *m, unsigned short type, struct ifa_cacheinfo *info) {
 839         int r;
 840         void *attr_data;
 841
 842         r = message_attribute_has_type(m, type, NLA_CACHE_INFO);
 843         if (r < 0)
 844                 return r;
 845
 846         r = rtnl_message_read_internal(m, type, &attr_data);
 847         if (r < 0)
 848                 return r;
 849         else if ((size_t)r < sizeof(struct ifa_cacheinfo))
 850                 return -EIO;
 851
 852         memcpy(info, attr_data, sizeof(struct ifa_cacheinfo));
 853
 854         return 0;
 855 }
 856
 857 int sd_rtnl_message_read_in_addr(sd_rtnl_message *m, unsigned short type, struct in_addr *data) {
 858         int r;
 859         void *attr_data;
 860
 861         r = message_attribute_has_type(m, type, NLA_IN_ADDR);
 862         if (r < 0)
 863                 return r;
 864
 865         r = rtnl_message_read_internal(m, type, &attr_data);
 866         if (r < 0)
 867                 return r;
 868         else if ((size_t)r < sizeof(struct in_addr))
 869                 return -EIO;
 870
 871         memcpy(data, attr_data, sizeof(struct in_addr));
 872
 873         return 0;
 874 }
 875
 876 int sd_rtnl_message_read_in6_addr(sd_rtnl_message *m, unsigned short type, struct in6_addr *data) {
 877         int r;
 878         void *attr_data;
 879
 880         r = message_attribute_has_type(m, type, NLA_IN_ADDR);
 881         if (r < 0)
 882                 return r;
 883
 884         r = rtnl_message_read_internal(m, type, &attr_data);
 885         if (r < 0)
 886                 return r;
 887         else if ((size_t)r < sizeof(struct in6_addr))
 888                 return -EIO;
 889
 890         memcpy(data, attr_data, sizeof(struct in6_addr));
 891
 892         return 0;
 893 }
 894
 895 int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
 896         const NLType *nl_type;
 897         const NLTypeSystem *type_system;
 898         void *container;
 899         size_t size;
 900         int r;
 901
 902         assert_return(m, -EINVAL);
 903         assert_return(m->n_containers < RTNL_CONTAINER_DEPTH, -EINVAL);
 904
 905         r = type_system_get_type(m->container_type_system[m->n_containers],
 906                                  &nl_type,
 907                                  type);
 908         if (r < 0)
 909                 return r;
 910
 911         if (nl_type->type == NLA_NESTED) {
 912                 r = type_system_get_type_system(m->container_type_system[m->n_containers],
 913                                                 &type_system,
 914                                                 type);
 915                 if (r < 0)
 916                         return r;
 917         } else if (nl_type->type == NLA_UNION) {
 918                 const NLTypeSystemUnion *type_system_union;
 919                 char *key;
 920
 921                 r = type_system_get_type_system_union(m->container_type_system[m->n_containers],
 922                                                       &type_system_union,
 923                                                       type);
 924                 if (r < 0)
 925                         return r;
 926
 927                 r = sd_rtnl_message_read_string(m, type_system_union->match, &key);
 928                 if (r < 0)
 929                         return r;
 930
 931                 r = type_system_union_get_type_system(type_system_union,
 932                                                       &type_system,
 933                                                       key);
 934                 if (r < 0)
 935                         return r;
 936         } else
 937                 return -EINVAL;
 938
 939         r = rtnl_message_read_internal(m, type, &container);
 940         if (r < 0)
 941                 return r;
 942         else
 943                 size = (size_t)r;
 944
 945         m->n_containers ++;
 946
 947         r = rtnl_message_parse(m,
 948                                &m->rta_offset_tb[m->n_containers],
 949                                &m->rta_tb_size[m->n_containers],
 950                                type_system->max,
 951                                container,
 952                                size);
 953         if (r < 0) {
 954                 m->n_containers --;
 955                 return r;
 956         }
 957
 958         m->container_type_system[m->n_containers] = type_system;
 959
 960         return 0;
 961 }
 962
 963 int sd_rtnl_message_exit_container(sd_rtnl_message *m) {
 964         assert_return(m, -EINVAL);
 965         assert_return(m->sealed, -EINVAL);
 966         assert_return(m->n_containers > 0, -EINVAL);
 967
 968         free(m->rta_offset_tb[m->n_containers]);
 969         m->rta_offset_tb[m->n_containers] = NULL;
 970         m->container_type_system[m->n_containers] = NULL;
 971
 972         m->n_containers --;
 973
 974         return 0;
 975 }
 976
 977 uint32_t rtnl_message_get_serial(sd_rtnl_message *m) {
 978         assert(m);
 979         assert(m->hdr);
 980
 981         return m->hdr->nlmsg_seq;
 982 }
 983
 984 int sd_rtnl_message_get_errno(sd_rtnl_message *m) {
 985         struct nlmsgerr *err;
 986
 987         assert_return(m, -EINVAL);
 988         assert_return(m->hdr, -EINVAL);
 989
 990         if (m->hdr->nlmsg_type != NLMSG_ERROR)
 991                 return 0;
 992
 993         err = NLMSG_DATA(m->hdr);
 994
 995         return err->error;
 996 }
 997
 998 static int message_receive_need(sd_rtnl *rtnl, size_t *need) {
 999         assert(rtnl);
1000         assert(need);
1001
1002         /* ioctl(rtnl->fd, FIONREAD, &need)
1003            Does not appear to work on netlink sockets. libnl uses
1004            MSG_PEEK instead. I don't know if that is worth the
1005            extra roundtrip.
1006
1007            For now we simply use the maximum message size the kernel
1008            may use (NLMSG_GOODSIZE), and then realloc to the actual
1009            size after reading the message (hence avoiding huge memory
1010            usage in case many small messages are kept around) */
1011         *need = page_size();
1012         if (*need > 8192UL)
1013                 *need = 8192UL;
1014
1015         return 0;
1016 }
1017
1018 int rtnl_message_parse(sd_rtnl_message *m,
1019                        size_t **rta_offset_tb,
1020                        unsigned short *rta_tb_size,
1021                        int max,
1022                        struct rtattr *rta,
1023                        unsigned int rt_len) {
1024         unsigned short type;
1025         size_t *tb;
1026
1027         tb = new0(size_t, max + 1);
1028         if(!tb)
1029                 return -ENOMEM;
1030
1031         *rta_tb_size = max + 1;
1032
1033         for (; RTA_OK(rta, rt_len); rta = RTA_NEXT(rta, rt_len)) {
1034                 type = rta->rta_type;
1035
1036                 /* if the kernel is newer than the headers we used
1037                    when building, we ignore out-of-range attributes
1038                  */
1039                 if (type > max)
1040                         continue;
1041
1042                 if (tb[type])
1043                         log_debug("rtnl: message parse - overwriting repeated attribute");
1044
1045                 tb[type] = (uint8_t *) rta - (uint8_t *) m->hdr;
1046         }
1047
1048         *rta_offset_tb = tb;
1049
1050         return 0;
1051 }
1052
1053 /* returns the number of bytes sent, or a negative error code */
1054 int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m) {
1055         union {
1056                 struct sockaddr sa;
1057                 struct sockaddr_nl nl;
1058         } addr = {
1059                 .nl.nl_family = AF_NETLINK,
1060         };
1061         ssize_t k;
1062
1063         assert(nl);
1064         assert(m);
1065         assert(m->hdr);
1066
1067         k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len,
1068                         0, &addr.sa, sizeof(addr));
1069         if (k < 0)
1070                 return (errno == EAGAIN) ? 0 : -errno;
1071
1072         return k;
1073 }
1074
1075 /* On success, the number of bytes received is returned and *ret points to the received message
1076  * which has a valid header and the correct size.
1077  * If nothing useful was received 0 is returned.
1078  * On failure, a negative error code is returned.
1079  */
1080 int socket_read_message(sd_rtnl *rtnl) {
1081         _cleanup_free_ void *buffer = NULL;
1082         uint8_t cred_buffer[CMSG_SPACE(sizeof(struct ucred))];
1083         struct iovec iov = {};
1084         struct msghdr msg = {
1085                 .msg_iov = &iov,
1086                 .msg_iovlen = 1,
1087                 .msg_control = cred_buffer,
1088                 .msg_controllen = sizeof(cred_buffer),
1089         };
1090         struct cmsghdr *cmsg;
1091         bool auth = false;
1092         struct nlmsghdr *new_msg;
1093         size_t need, len;
1094         int r, ret = 0;
1095
1096         assert(rtnl);
1097
1098         r = message_receive_need(rtnl, &need);
1099         if (r < 0)
1100                 return r;
1101
1102         buffer = malloc0(need);
1103         if (!buffer)
1104                 return -ENOMEM;
1105
1106         iov.iov_base = buffer;
1107         iov.iov_len = need;
1108
1109         r = recvmsg(rtnl->fd, &msg, 0);
1110         if (r < 0)
1111                 /* no data */
1112                 return (errno == EAGAIN) ? 0 : -errno;
1113         else if (r == 0)
1114                 /* connection was closed by the kernel */
1115                 return -ECONNRESET;
1116         else
1117                 len = (size_t)r;
1118
1119         for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
1120                 if (cmsg->cmsg_level == SOL_SOCKET &&
1121                     cmsg->cmsg_type == SCM_CREDENTIALS &&
1122                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1123                         struct ucred *ucred = (void *)CMSG_DATA(cmsg);
1124
1125                         /* from the kernel */
1126                         if (ucred->uid == 0 && ucred->pid == 0) {
1127                                 auth = true;
1128                                 break;
1129                         }
1130                 }
1131         }
1132
1133         if (!auth)
1134                 /* not from the kernel, ignore */
1135                 return 0;
1136
1137         for (new_msg = buffer; NLMSG_OK(new_msg, len); new_msg = NLMSG_NEXT(new_msg, len)) {
1138                 _cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
1139                 const NLType *nl_type;
1140
1141                 if (new_msg->nlmsg_pid && new_msg->nlmsg_pid != rtnl->sockaddr.nl.nl_pid)
1142                         /* not broadcast and not for us */
1143                         continue;
1144
1145                 /* silently drop noop messages */
1146                 if (new_msg->nlmsg_type == NLMSG_NOOP)
1147                         continue;
1148
1149                 /* check that we support this message type */
1150                 r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
1151                 if (r < 0) {
1152                         if (r == -ENOTSUP)
1153                                 log_debug("sd-rtnl: ignored message with unknown type: %u",
1154                                           new_msg->nlmsg_type);
1155
1156                         continue;
1157                 }
1158
1159                 /* check that the size matches the message type */
1160                 if (new_msg->nlmsg_len < NLMSG_LENGTH(nl_type->size))
1161                         continue;
1162
1163                 r = message_new_empty(rtnl, &m);
1164                 if (r < 0)
1165                         return r;
1166
1167                 m->hdr = memdup(new_msg, new_msg->nlmsg_len);
1168                 if (!m->hdr)
1169                         return -ENOMEM;
1170
1171                 /* seal and parse the top-level message */
1172                 r = sd_rtnl_message_rewind(m);
1173                 if (r < 0)
1174                         return r;
1175
1176                 r = rtnl_rqueue_make_room(rtnl);
1177                 if (r < 0)
1178                         return r;
1179
1180                 rtnl->rqueue[rtnl->rqueue_size ++] = m;
1181                 m = NULL;
1182                 ret += new_msg->nlmsg_len;
1183
1184                 /* reached end of multi-part message, or not a multi-part
1185                    message at all */
1186                 if (new_msg->nlmsg_type == NLMSG_DONE ||
1187                     !(new_msg->nlmsg_flags & NLM_F_MULTI))
1188                         break;
1189         }
1190
1191         return ret;
1192 }
1193
1194 int sd_rtnl_message_rewind(sd_rtnl_message *m) {
1195         const NLType *type;
1196         unsigned i;
1197         int r;
1198
1199         assert_return(m, -EINVAL);
1200
1201         /* don't allow appending to message once parsed */
1202         if (!m->sealed)
1203                 rtnl_message_seal(m);
1204
1205         for (i = 1; i <= m->n_containers; i++) {
1206                 free(m->rta_offset_tb[i]);
1207                 m->rta_offset_tb[i] = NULL;
1208                 m->rta_tb_size[i] = 0;
1209                 m->container_type_system[i] = NULL;
1210         }
1211
1212         m->n_containers = 0;
1213
1214         if (m->rta_offset_tb[0]) {
1215                 /* top-level attributes have already been parsed */
1216                 return 0;
1217         }
1218
1219         assert(m->hdr);
1220
1221         r = type_system_get_type(NULL, &type, m->hdr->nlmsg_type);
1222         if (r < 0)
1223                 return r;
1224
1225         if (type->type == NLA_NESTED) {
1226                 const NLTypeSystem *type_system = type->type_system;
1227
1228                 assert(type_system);
1229
1230                 m->container_type_system[0] = type_system;
1231
1232                 r = rtnl_message_parse(m,
1233                                        &m->rta_offset_tb[m->n_containers],
1234                                        &m->rta_tb_size[m->n_containers],
1235                                        type_system->max,
1236                                        (struct rtattr*)((uint8_t*)NLMSG_DATA(m->hdr) +
1237                                                         NLMSG_ALIGN(type->size)),
1238                                        NLMSG_PAYLOAD(m->hdr, type->size));
1239                 if (r < 0)
1240                         return r;
1241         }
1242
1243         return 0;
1244 }
1245
1246 void rtnl_message_seal(sd_rtnl_message *m) {
1247         assert(m);
1248         assert(!m->sealed);
1249
1250         m->sealed = true;
1251 }