lib/route/addr.c

   1 /*
   2  * lib/route/addr.c             Addresses
   3  *
   4  *      This library is free software; you can redistribute it and/or
   5  *      modify it under the terms of the GNU Lesser General Public
   6  *      License as published by the Free Software Foundation version 2.1
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2012 Thomas Graf <tgraf@suug.ch>
  10  * Copyright (c) 2003-2006 Baruch Even <baruch@ev-en.org>,
  11  *                         Mediatrix Telecom, inc. <ericb@mediatrix.com>
  12  */
  13
  14 /**
  15  * @ingroup rtnl
  16  * @defgroup rtaddr Addresses
  17  * @brief
  18  *
  19  * @note The maximum size of an address label is IFNAMSIZ.
  20  *
  21  * @note The address may not contain a prefix length if the peer address
  22  *       has been specified already.
  23  *
  24  * @par 1) Address Addition
  25  * @code
  26  * // Allocate an empty address object to be filled out with the attributes
  27  * // of the new address.
  28  * struct rtnl_addr *addr = rtnl_addr_alloc();
  29  *
  30  * // Fill out the mandatory attributes of the new address. Setting the
  31  * // local address will automatically set the address family and the
  32  * // prefix length to the correct values.
  33  * rtnl_addr_set_ifindex(addr, ifindex);
  34  * rtnl_addr_set_local(addr, local_addr);
  35  *
  36  * // The label of the address can be specified, currently only supported
  37  * // by IPv4 and DECnet.
  38  * rtnl_addr_set_label(addr, "mylabel");
  39  *
  40  * // The peer address can be specified if necessary, in either case a peer
  41  * // address will be sent to the kernel in order to fullfil the interface
  42  * // requirements. If none is set, it will equal the local address.
  43  * // Note: Real peer addresses are only supported by IPv4 for now.
  44  * rtnl_addr_set_peer(addr, peer_addr);
  45  *
  46  * // In case you want to have the address have a scope other than global
  47  * // it may be overwritten using rtnl_addr_set_scope(). The scope currently
  48  * // cannot be set for IPv6 addresses.
  49  * rtnl_addr_set_scope(addr, rtnl_str2scope("site"));
  50  *
  51  * // Broadcast address may be specified using the relevant
  52  * // functions, the address family will be verified if one of the other
  53  * // addresses has been set already. Currently only works for IPv4.
  54  * rtnl_addr_set_broadcast(addr, broadcast_addr);
  55  *
  56  * // Build the netlink message and send it to the kernel, the operation will
  57  * // block until the operation has been completed. Alternatively the required
  58  * // netlink message can be built using rtnl_addr_build_add_request() to be
  59  * // sent out using nl_send_auto_complete().
  60  * rtnl_addr_add(sk, addr, 0);
  61  *
  62  * // Free the memory
  63  * rtnl_addr_put(addr);
  64  * @endcode
  65  *
  66  * @par 2) Address Deletion
  67  * @code
  68  * // Allocate an empty address object to be filled out with the attributes
  69  * // matching the address to be deleted. Alternatively a fully equipped
  70  * // address object out of a cache can be used instead.
  71  * struct rtnl_addr *addr = rtnl_addr_alloc();
  72  *
  73  * // The only mandatory parameter besides the address family is the interface
  74  * // index the address is on, i.e. leaving out all other parameters will
  75  * // result in all addresses of the specified address family interface tuple
  76  * // to be deleted.
  77  * rtnl_addr_set_ifindex(addr, ifindex);
  78  *
  79  * // Specyfing the address family manually is only required if neither the
  80  * // local nor peer address have been specified.
  81  * rtnl_addr_set_family(addr, AF_INET);
  82  *
  83  * // Specyfing the local address is optional but the best choice to delete
  84  * // specific addresses.
  85  * rtnl_addr_set_local(addr, local_addr);
  86  *
  87  * // The label of the address can be specified, currently only supported
  88  * // by IPv4 and DECnet.
  89  * rtnl_addr_set_label(addr, "mylabel");
  90  *
  91  * // The peer address can be specified if necessary, in either case a peer
  92  * // address will be sent to the kernel in order to fullfil the interface
  93  * // requirements. If none is set, it will equal the local address.
  94  * // Note: Real peer addresses are only supported by IPv4 for now.
  95  * rtnl_addr_set_peer(addr, peer_addr);
  96  *
  97  * // Build the netlink message and send it to the kernel, the operation will
  98  * // block until the operation has been completed. Alternatively the required
  99  * // netlink message can be built using rtnl_addr_build_delete_request()
 100  * // to be sent out using nl_send_auto_complete().
 101  * rtnl_addr_delete(sk, addr, 0);
 102  *
 103  * // Free the memory
 104  * rtnl_addr_put(addr);
 105  * @endcode
 106  * @{
 107  */
 108
 109 #include <netlink-private/netlink.h>
 110 #include <netlink/netlink.h>
 111 #include <netlink/route/rtnl.h>
 112 #include <netlink/route/addr.h>
 113 #include <netlink/route/route.h>
 114 #include <netlink/route/link.h>
 115 #include <netlink/utils.h>
 116
 117 /** @cond SKIP */
 118 #define ADDR_ATTR_FAMILY        0x0001
 119 #define ADDR_ATTR_PREFIXLEN     0x0002
 120 #define ADDR_ATTR_FLAGS         0x0004
 121 #define ADDR_ATTR_SCOPE         0x0008
 122 #define ADDR_ATTR_IFINDEX       0x0010
 123 #define ADDR_ATTR_LABEL         0x0020
 124 #define ADDR_ATTR_CACHEINFO     0x0040
 125 #define ADDR_ATTR_PEER          0x0080
 126 #define ADDR_ATTR_LOCAL         0x0100
 127 #define ADDR_ATTR_BROADCAST     0x0200
 128 #define ADDR_ATTR_MULTICAST     0x0400
 129 #define ADDR_ATTR_ANYCAST       0x0800
 130
 131 static struct nl_cache_ops rtnl_addr_ops;
 132 static struct nl_object_ops addr_obj_ops;
 133 /** @endcond */
 134
 135 static void addr_constructor(struct nl_object *obj)
 136 {
 137         struct rtnl_addr *addr = nl_object_priv(obj);
 138
 139         addr->a_scope = RT_SCOPE_NOWHERE;
 140 }
 141
 142 static void addr_free_data(struct nl_object *obj)
 143 {
 144         struct rtnl_addr *addr = nl_object_priv(obj);
 145
 146         if (!addr)
 147                 return;
 148
 149         nl_addr_put(addr->a_peer);
 150         nl_addr_put(addr->a_local);
 151         nl_addr_put(addr->a_bcast);
 152         nl_addr_put(addr->a_multicast);
 153         nl_addr_put(addr->a_anycast);
 154         rtnl_link_put(addr->a_link);
 155 }
 156
 157 static int addr_clone(struct nl_object *_dst, struct nl_object *_src)
 158 {
 159         struct rtnl_addr *dst = nl_object_priv(_dst);
 160         struct rtnl_addr *src = nl_object_priv(_src);
 161
 162         if (src->a_link) {
 163                 nl_object_get(OBJ_CAST(src->a_link));
 164                 dst->a_link = src->a_link;
 165         }
 166
 167         if (src->a_peer)
 168                 if (!(dst->a_peer = nl_addr_clone(src->a_peer)))
 169                         return -NLE_NOMEM;
 170
 171         if (src->a_local)
 172                 if (!(dst->a_local = nl_addr_clone(src->a_local)))
 173                         return -NLE_NOMEM;
 174
 175         if (src->a_bcast)
 176                 if (!(dst->a_bcast = nl_addr_clone(src->a_bcast)))
 177                         return -NLE_NOMEM;
 178
 179         if (src->a_multicast)
 180                 if (!(dst->a_multicast = nl_addr_clone(src->a_multicast)))
 181                         return -NLE_NOMEM;
 182
 183         if (src->a_anycast)
 184                 if (!(dst->a_anycast = nl_addr_clone(src->a_anycast)))
 185                         return -NLE_NOMEM;
 186
 187         return 0;
 188 }
 189
 190 static struct nla_policy addr_policy[IFA_MAX+1] = {
 191         [IFA_LABEL]     = { .type = NLA_STRING,
 192                             .maxlen = IFNAMSIZ },
 193         [IFA_CACHEINFO] = { .minlen = sizeof(struct ifa_cacheinfo) },
 194 };
 195
 196 static int addr_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 197                            struct nlmsghdr *nlh, struct nl_parser_param *pp)
 198 {
 199         struct rtnl_addr *addr;
 200         struct ifaddrmsg *ifa;
 201         struct nlattr *tb[IFA_MAX+1];
 202         int err, family;
 203         struct nl_cache *link_cache;
 204         struct nl_addr *plen_addr = NULL;
 205
 206         addr = rtnl_addr_alloc();
 207         if (!addr)
 208                 return -NLE_NOMEM;
 209
 210         addr->ce_msgtype = nlh->nlmsg_type;
 211
 212         err = nlmsg_parse(nlh, sizeof(*ifa), tb, IFA_MAX, addr_policy);
 213         if (err < 0)
 214                 goto errout;
 215
 216         ifa = nlmsg_data(nlh);
 217         addr->a_family = family = ifa->ifa_family;
 218         addr->a_prefixlen = ifa->ifa_prefixlen;
 219         addr->a_flags = ifa->ifa_flags;
 220         addr->a_scope = ifa->ifa_scope;
 221         addr->a_ifindex = ifa->ifa_index;
 222
 223         addr->ce_mask = (ADDR_ATTR_FAMILY | ADDR_ATTR_PREFIXLEN |
 224                          ADDR_ATTR_FLAGS | ADDR_ATTR_SCOPE | ADDR_ATTR_IFINDEX);
 225
 226         if (tb[IFA_LABEL]) {
 227                 nla_strlcpy(addr->a_label, tb[IFA_LABEL], IFNAMSIZ);
 228                 addr->ce_mask |= ADDR_ATTR_LABEL;
 229         }
 230
 231         /* IPv6 only */
 232         if (tb[IFA_CACHEINFO]) {
 233                 struct ifa_cacheinfo *ca;
 234
 235                 ca = nla_data(tb[IFA_CACHEINFO]);
 236                 addr->a_cacheinfo.aci_prefered = ca->ifa_prefered;
 237                 addr->a_cacheinfo.aci_valid = ca->ifa_valid;
 238                 addr->a_cacheinfo.aci_cstamp = ca->cstamp;
 239                 addr->a_cacheinfo.aci_tstamp = ca->tstamp;
 240                 addr->ce_mask |= ADDR_ATTR_CACHEINFO;
 241         }
 242
 243         if (tb[IFA_LOCAL]) {
 244                 addr->a_local = nl_addr_alloc_attr(tb[IFA_LOCAL], family);
 245                 if (!addr->a_local)
 246                         goto errout_nomem;
 247                 addr->ce_mask |= ADDR_ATTR_LOCAL;
 248                 plen_addr = addr->a_local;
 249         }
 250
 251         if (tb[IFA_ADDRESS]) {
 252                 struct nl_addr *a;
 253
 254                 a = nl_addr_alloc_attr(tb[IFA_ADDRESS], family);
 255                 if (!a)
 256                         goto errout_nomem;
 257
 258                 /* IPv6 sends the local address as IFA_ADDRESS with
 259                  * no IFA_LOCAL, IPv4 sends both IFA_LOCAL and IFA_ADDRESS
 260                  * with IFA_ADDRESS being the peer address if they differ */
 261                 if (!tb[IFA_LOCAL] || !nl_addr_cmp(a, addr->a_local)) {
 262                         nl_addr_put(addr->a_local);
 263                         addr->a_local = a;
 264                         addr->ce_mask |= ADDR_ATTR_LOCAL;
 265                 } else {
 266                         addr->a_peer = a;
 267                         addr->ce_mask |= ADDR_ATTR_PEER;
 268                 }
 269
 270                 plen_addr = a;
 271         }
 272
 273         if (plen_addr)
 274                 nl_addr_set_prefixlen(plen_addr, addr->a_prefixlen);
 275
 276         /* IPv4 only */
 277         if (tb[IFA_BROADCAST]) {
 278                 addr->a_bcast = nl_addr_alloc_attr(tb[IFA_BROADCAST], family);
 279                 if (!addr->a_bcast)
 280                         goto errout_nomem;
 281
 282                 addr->ce_mask |= ADDR_ATTR_BROADCAST;
 283         }
 284
 285         /* IPv6 only */
 286         if (tb[IFA_MULTICAST]) {
 287                 addr->a_multicast = nl_addr_alloc_attr(tb[IFA_MULTICAST],
 288                                                        family);
 289                 if (!addr->a_multicast)
 290                         goto errout_nomem;
 291
 292                 addr->ce_mask |= ADDR_ATTR_MULTICAST;
 293         }
 294
 295         /* IPv6 only */
 296         if (tb[IFA_ANYCAST]) {
 297                 addr->a_anycast = nl_addr_alloc_attr(tb[IFA_ANYCAST],
 298                                                        family);
 299                 if (!addr->a_anycast)
 300                         goto errout_nomem;
 301
 302                 addr->ce_mask |= ADDR_ATTR_ANYCAST;
 303         }
 304
 305         if ((link_cache = __nl_cache_mngt_require("route/link"))) {
 306                 struct rtnl_link *link;
 307
 308                 if ((link = rtnl_link_get(link_cache, addr->a_ifindex))) {
 309                         rtnl_addr_set_link(addr, link);
 310
 311                         /* rtnl_addr_set_link incs refcnt */
 312                         rtnl_link_put(link);
 313                 }
 314         }
 315
 316         err = pp->pp_cb((struct nl_object *) addr, pp);
 317 errout:
 318         rtnl_addr_put(addr);
 319
 320         return err;
 321
 322 errout_nomem:
 323         err = -NLE_NOMEM;
 324         goto errout;
 325 }
 326
 327 static int addr_request_update(struct nl_cache *cache, struct nl_sock *sk)
 328 {
 329         return nl_rtgen_request(sk, RTM_GETADDR, AF_UNSPEC, NLM_F_DUMP);
 330 }
 331
 332 static void addr_dump_line(struct nl_object *obj, struct nl_dump_params *p)
 333 {
 334         struct rtnl_addr *addr = (struct rtnl_addr *) obj;
 335         struct nl_cache *link_cache;
 336         char buf[128];
 337
 338         link_cache = nl_cache_mngt_require_safe("route/link");
 339
 340         if (addr->ce_mask & ADDR_ATTR_LOCAL)
 341                 nl_dump_line(p, "%s",
 342                         nl_addr2str(addr->a_local, buf, sizeof(buf)));
 343         else
 344                 nl_dump_line(p, "none");
 345
 346         if (addr->ce_mask & ADDR_ATTR_PEER)
 347                 nl_dump(p, " peer %s",
 348                         nl_addr2str(addr->a_peer, buf, sizeof(buf)));
 349
 350         nl_dump(p, " %s ", nl_af2str(addr->a_family, buf, sizeof(buf)));
 351
 352         if (link_cache)
 353                 nl_dump(p, "dev %s ",
 354                         rtnl_link_i2name(link_cache, addr->a_ifindex,
 355                                          buf, sizeof(buf)));
 356         else
 357                 nl_dump(p, "dev %d ", addr->a_ifindex);
 358
 359         nl_dump(p, "scope %s",
 360                 rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
 361
 362         rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
 363         if (buf[0])
 364                 nl_dump(p, " <%s>", buf);
 365
 366         nl_dump(p, "\n");
 367
 368         if (link_cache)
 369                 nl_cache_put(link_cache);
 370 }
 371
 372 static void addr_dump_details(struct nl_object *obj, struct nl_dump_params *p)
 373 {
 374         struct rtnl_addr *addr = (struct rtnl_addr *) obj;
 375         char buf[128];
 376
 377         addr_dump_line(obj, p);
 378
 379         if (addr->ce_mask & (ADDR_ATTR_LABEL | ADDR_ATTR_BROADCAST |
 380                              ADDR_ATTR_MULTICAST)) {
 381                 nl_dump_line(p, "  ");
 382
 383                 if (addr->ce_mask & ADDR_ATTR_LABEL)
 384                         nl_dump(p, " label %s", addr->a_label);
 385
 386                 if (addr->ce_mask & ADDR_ATTR_BROADCAST)
 387                         nl_dump(p, " broadcast %s",
 388                                 nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
 389
 390                 if (addr->ce_mask & ADDR_ATTR_MULTICAST)
 391                         nl_dump(p, " multicast %s",
 392                                 nl_addr2str(addr->a_multicast, buf,
 393                                               sizeof(buf)));
 394
 395                 if (addr->ce_mask & ADDR_ATTR_ANYCAST)
 396                         nl_dump(p, " anycast %s",
 397                                 nl_addr2str(addr->a_anycast, buf,
 398                                               sizeof(buf)));
 399
 400                 nl_dump(p, "\n");
 401         }
 402
 403         if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
 404                 struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
 405
 406                 nl_dump_line(p, "   valid-lifetime %s",
 407                              ci->aci_valid == 0xFFFFFFFFU ? "forever" :
 408                              nl_msec2str(ci->aci_valid * 1000,
 409                                            buf, sizeof(buf)));
 410
 411                 nl_dump(p, " preferred-lifetime %s\n",
 412                         ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
 413                         nl_msec2str(ci->aci_prefered * 1000,
 414                                       buf, sizeof(buf)));
 415
 416                 nl_dump_line(p, "   created boot-time+%s ",
 417                              nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
 418                                            buf, sizeof(buf)));
 419
 420                 nl_dump(p, "last-updated boot-time+%s\n",
 421                         nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
 422                                       buf, sizeof(buf)));
 423         }
 424 }
 425
 426 static void addr_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
 427 {
 428         addr_dump_details(obj, p);
 429 }
 430
 431 static int addr_compare(struct nl_object *_a, struct nl_object *_b,
 432                         uint32_t attrs, int flags)
 433 {
 434         struct rtnl_addr *a = (struct rtnl_addr *) _a;
 435         struct rtnl_addr *b = (struct rtnl_addr *) _b;
 436         int diff = 0;
 437
 438 #define ADDR_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ADDR_ATTR_##ATTR, a, b, EXPR)
 439
 440         diff |= ADDR_DIFF(IFINDEX,      a->a_ifindex != b->a_ifindex);
 441         diff |= ADDR_DIFF(FAMILY,       a->a_family != b->a_family);
 442         diff |= ADDR_DIFF(SCOPE,        a->a_scope != b->a_scope);
 443         diff |= ADDR_DIFF(LABEL,        strcmp(a->a_label, b->a_label));
 444         diff |= ADDR_DIFF(PEER,         nl_addr_cmp(a->a_peer, b->a_peer));
 445         diff |= ADDR_DIFF(LOCAL,        nl_addr_cmp(a->a_local, b->a_local));
 446         diff |= ADDR_DIFF(MULTICAST,    nl_addr_cmp(a->a_multicast,
 447                                                     b->a_multicast));
 448         diff |= ADDR_DIFF(BROADCAST,    nl_addr_cmp(a->a_bcast, b->a_bcast));
 449         diff |= ADDR_DIFF(ANYCAST,      nl_addr_cmp(a->a_anycast, b->a_anycast));
 450
 451         if (flags & LOOSE_COMPARISON)
 452                 diff |= ADDR_DIFF(FLAGS,
 453                                   (a->a_flags ^ b->a_flags) & b->a_flag_mask);
 454         else
 455                 diff |= ADDR_DIFF(FLAGS, a->a_flags != b->a_flags);
 456
 457 #undef ADDR_DIFF
 458
 459         return diff;
 460 }
 461
 462 static const struct trans_tbl addr_attrs[] = {
 463         __ADD(ADDR_ATTR_FAMILY, family)
 464         __ADD(ADDR_ATTR_PREFIXLEN, prefixlen)
 465         __ADD(ADDR_ATTR_FLAGS, flags)
 466         __ADD(ADDR_ATTR_SCOPE, scope)
 467         __ADD(ADDR_ATTR_IFINDEX, ifindex)
 468         __ADD(ADDR_ATTR_LABEL, label)
 469         __ADD(ADDR_ATTR_CACHEINFO, cacheinfo)
 470         __ADD(ADDR_ATTR_PEER, peer)
 471         __ADD(ADDR_ATTR_LOCAL, local)
 472         __ADD(ADDR_ATTR_BROADCAST, broadcast)
 473         __ADD(ADDR_ATTR_MULTICAST, multicast)
 474 };
 475
 476 static char *addr_attrs2str(int attrs, char *buf, size_t len)
 477 {
 478         return __flags2str(attrs, buf, len, addr_attrs,
 479                            ARRAY_SIZE(addr_attrs));
 480 }
 481
 482 /**
 483  * @name Allocation/Freeing
 484  * @{
 485  */
 486
 487 struct rtnl_addr *rtnl_addr_alloc(void)
 488 {
 489         return (struct rtnl_addr *) nl_object_alloc(&addr_obj_ops);
 490 }
 491
 492 void rtnl_addr_put(struct rtnl_addr *addr)
 493 {
 494         nl_object_put((struct nl_object *) addr);
 495 }
 496
 497 /** @} */
 498
 499 /**
 500  * @name Cache Management
 501  * @{
 502  */
 503
 504 int rtnl_addr_alloc_cache(struct nl_sock *sk, struct nl_cache **result)
 505 {
 506         return nl_cache_alloc_and_fill(&rtnl_addr_ops, sk, result);
 507 }
 508
 509 /**
 510  * Search address in cache
 511  * @arg cache           Address cache
 512  * @arg ifindex         Interface index of address
 513  * @arg addr            Local address part
 514  *
 515  * Searches address cache previously allocated with rtnl_addr_alloc_cache()
 516  * for an address with a matching local address.
 517  *
 518  * The reference counter is incremented before returning the address, therefore
 519  * the reference must be given back with rtnl_addr_put() after usage.
 520  *
 521  * @return Address object or NULL if no match was found.
 522  */
 523 struct rtnl_addr *rtnl_addr_get(struct nl_cache *cache, int ifindex,
 524                                 struct nl_addr *addr)
 525 {
 526         struct rtnl_addr *a;
 527
 528         if (cache->c_ops != &rtnl_addr_ops)
 529                 return NULL;
 530
 531         nl_list_for_each_entry(a, &cache->c_items, ce_list) {
 532                 if (ifindex && a->a_ifindex != ifindex)
 533                         continue;
 534
 535                 if (a->ce_mask & ADDR_ATTR_LOCAL &&
 536                     !nl_addr_cmp(a->a_local, addr)) {
 537                         nl_object_get((struct nl_object *) a);
 538                         return a;
 539                 }
 540         }
 541
 542         return NULL;
 543 }
 544
 545 /** @} */
 546
 547 static int build_addr_msg(struct rtnl_addr *tmpl, int cmd, int flags,
 548                           struct nl_msg **result)
 549 {
 550         struct nl_msg *msg;
 551         struct ifaddrmsg am = {
 552                 .ifa_family = tmpl->a_family,
 553                 .ifa_index = tmpl->a_ifindex,
 554                 .ifa_prefixlen = tmpl->a_prefixlen,
 555         };
 556
 557         if (tmpl->ce_mask & ADDR_ATTR_SCOPE)
 558                 am.ifa_scope = tmpl->a_scope;
 559         else {
 560                 /* compatibility hack */
 561                 if (tmpl->a_family == AF_INET &&
 562                     tmpl->ce_mask & ADDR_ATTR_LOCAL &&
 563                     *((char *) nl_addr_get_binary_addr(tmpl->a_local)) == 127)
 564                         am.ifa_scope = RT_SCOPE_HOST;
 565                 else
 566                         am.ifa_scope = RT_SCOPE_UNIVERSE;
 567         }
 568
 569         msg = nlmsg_alloc_simple(cmd, flags);
 570         if (!msg)
 571                 return -NLE_NOMEM;
 572
 573         if (nlmsg_append(msg, &am, sizeof(am), NLMSG_ALIGNTO) < 0)
 574                 goto nla_put_failure;
 575
 576         if (tmpl->ce_mask & ADDR_ATTR_LOCAL)
 577                 NLA_PUT_ADDR(msg, IFA_LOCAL, tmpl->a_local);
 578
 579         if (tmpl->ce_mask & ADDR_ATTR_PEER)
 580                 NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_peer);
 581         else if (tmpl->ce_mask & ADDR_ATTR_LOCAL)
 582                 NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_local);
 583
 584         if (tmpl->ce_mask & ADDR_ATTR_LABEL)
 585                 NLA_PUT_STRING(msg, IFA_LABEL, tmpl->a_label);
 586
 587         if (tmpl->ce_mask & ADDR_ATTR_BROADCAST)
 588                 NLA_PUT_ADDR(msg, IFA_BROADCAST, tmpl->a_bcast);
 589
 590         if (tmpl->ce_mask & ADDR_ATTR_CACHEINFO) {
 591                 struct ifa_cacheinfo ca = {
 592                         .ifa_valid = tmpl->a_cacheinfo.aci_valid,
 593                         .ifa_prefered = tmpl->a_cacheinfo.aci_prefered,
 594                 };
 595
 596                 NLA_PUT(msg, IFA_CACHEINFO, sizeof(ca), &ca);
 597         }
 598
 599
 600         *result = msg;
 601         return 0;
 602
 603 nla_put_failure:
 604         nlmsg_free(msg);
 605         return -NLE_MSGSIZE;
 606 }
 607
 608 /**
 609  * @name Addition
 610  * @{
 611  */
 612
 613 /**
 614  * Build netlink request message to request addition of new address
 615  * @arg addr            Address object representing the new address.
 616  * @arg flags           Additional netlink message flags.
 617  * @arg result          Pointer to store resulting message.
 618  *
 619  * Builds a new netlink message requesting the addition of a new
 620  * address. The netlink message header isn't fully equipped with
 621  * all relevant fields and must thus be sent out via nl_send_auto_complete()
 622  * or supplemented as needed.
 623  *
 624  * Minimal required attributes:
 625  *   - interface index (rtnl_addr_set_ifindex())
 626  *   - local address (rtnl_addr_set_local())
 627  *
 628  * The scope will default to universe except for loopback addresses in
 629  * which case a host scope is used if not specified otherwise.
 630  *
 631  * @note Free the memory after usage using nlmsg_free().
 632  *
 633  * @return 0 on success or a negative error code.
 634  */
 635 int rtnl_addr_build_add_request(struct rtnl_addr *addr, int flags,
 636                                 struct nl_msg **result)
 637 {
 638         uint32_t required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY |
 639                        ADDR_ATTR_PREFIXLEN | ADDR_ATTR_LOCAL;
 640
 641         if ((addr->ce_mask & required) != required)
 642                 return -NLE_MISSING_ATTR;
 643
 644         return build_addr_msg(addr, RTM_NEWADDR, NLM_F_CREATE | flags, result);
 645 }
 646
 647 /**
 648  * Request addition of new address
 649  * @arg sk              Netlink socket.
 650  * @arg addr            Address object representing the new address.
 651  * @arg flags           Additional netlink message flags.
 652  *
 653  * Builds a netlink message by calling rtnl_addr_build_add_request(),
 654  * sends the request to the kernel and waits for the next ACK to be
 655  * received and thus blocks until the request has been fullfilled.
 656  *
 657  * @see rtnl_addr_build_add_request()
 658  *
 659  * @return 0 on sucess or a negative error if an error occured.
 660  */
 661 int rtnl_addr_add(struct nl_sock *sk, struct rtnl_addr *addr, int flags)
 662 {
 663         struct nl_msg *msg;
 664         int err;
 665
 666         if ((err = rtnl_addr_build_add_request(addr, flags, &msg)) < 0)
 667                 return err;
 668
 669         err = nl_send_auto_complete(sk, msg);
 670         nlmsg_free(msg);
 671         if (err < 0)
 672                 return err;
 673
 674         return wait_for_ack(sk);
 675 }
 676
 677 /** @} */
 678
 679 /**
 680  * @name Deletion
 681  * @{
 682  */
 683
 684 /**
 685  * Build a netlink request message to request deletion of an address
 686  * @arg addr            Address object to be deleteted.
 687  * @arg flags           Additional netlink message flags.
 688  * @arg result          Pointer to store resulting message.
 689  *
 690  * Builds a new netlink message requesting a deletion of an address.
 691  * The netlink message header isn't fully equipped with all relevant
 692  * fields and must thus be sent out via nl_send_auto_complete()
 693  * or supplemented as needed.
 694  *
 695  * Minimal required attributes:
 696  *   - interface index (rtnl_addr_set_ifindex())
 697  *   - address family (rtnl_addr_set_family())
 698  *
 699  * Optional attributes:
 700  *   - local address (rtnl_addr_set_local())
 701  *   - label (rtnl_addr_set_label(), IPv4/DECnet only)
 702  *   - peer address (rtnl_addr_set_peer(), IPv4 only)
 703  *
 704  * @note Free the memory after usage using nlmsg_free().
 705  *
 706  * @return 0 on success or a negative error code.
 707  */
 708 int rtnl_addr_build_delete_request(struct rtnl_addr *addr, int flags,
 709                                    struct nl_msg **result)
 710 {
 711         uint32_t required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY;
 712
 713         if ((addr->ce_mask & required) != required)
 714                 return -NLE_MISSING_ATTR;
 715
 716         return build_addr_msg(addr, RTM_DELADDR, flags, result);
 717 }
 718
 719 /**
 720  * Request deletion of an address
 721  * @arg sk              Netlink socket.
 722  * @arg addr            Address object to be deleted.
 723  * @arg flags           Additional netlink message flags.
 724  *
 725  * Builds a netlink message by calling rtnl_addr_build_delete_request(),
 726  * sends the request to the kernel and waits for the next ACK to be
 727  * received and thus blocks until the request has been fullfilled.
 728  *
 729  * @see rtnl_addr_build_delete_request();
 730  *
 731  * @return 0 on sucess or a negative error if an error occured.
 732  */
 733 int rtnl_addr_delete(struct nl_sock *sk, struct rtnl_addr *addr, int flags)
 734 {
 735         struct nl_msg *msg;
 736         int err;
 737
 738         if ((err = rtnl_addr_build_delete_request(addr, flags, &msg)) < 0)
 739                 return err;
 740
 741         err = nl_send_auto_complete(sk, msg);
 742         nlmsg_free(msg);
 743         if (err < 0)
 744                 return err;
 745
 746         return wait_for_ack(sk);
 747 }
 748
 749 /** @} */
 750
 751 /**
 752  * @name Attributes
 753  * @{
 754  */
 755
 756 int rtnl_addr_set_label(struct rtnl_addr *addr, const char *label)
 757 {
 758         if (strlen(label) > sizeof(addr->a_label) - 1)
 759                 return -NLE_RANGE;
 760
 761         strcpy(addr->a_label, label);
 762         addr->ce_mask |= ADDR_ATTR_LABEL;
 763
 764         return 0;
 765 }
 766
 767 char *rtnl_addr_get_label(struct rtnl_addr *addr)
 768 {
 769         if (addr->ce_mask & ADDR_ATTR_LABEL)
 770                 return addr->a_label;
 771         else
 772                 return NULL;
 773 }
 774
 775 void rtnl_addr_set_ifindex(struct rtnl_addr *addr, int ifindex)
 776 {
 777         addr->a_ifindex = ifindex;
 778         addr->ce_mask |= ADDR_ATTR_IFINDEX;
 779 }
 780
 781 int rtnl_addr_get_ifindex(struct rtnl_addr *addr)
 782 {
 783         return addr->a_ifindex;
 784 }
 785
 786 void rtnl_addr_set_link(struct rtnl_addr *addr, struct rtnl_link *link)
 787 {
 788         rtnl_link_put(addr->a_link);
 789
 790         if (!link)
 791                 return;
 792
 793         nl_object_get(OBJ_CAST(link));
 794         addr->a_link = link;
 795         addr->a_ifindex = link->l_index;
 796         addr->ce_mask |= ADDR_ATTR_IFINDEX;
 797 }
 798
 799 struct rtnl_link *rtnl_addr_get_link(struct rtnl_addr *addr)
 800 {
 801         if (addr->a_link) {
 802                 nl_object_get(OBJ_CAST(addr->a_link));
 803                 return addr->a_link;
 804         }
 805
 806         return NULL;
 807 }
 808
 809 void rtnl_addr_set_family(struct rtnl_addr *addr, int family)
 810 {
 811         addr->a_family = family;
 812         addr->ce_mask |= ADDR_ATTR_FAMILY;
 813 }
 814
 815 int rtnl_addr_get_family(struct rtnl_addr *addr)
 816 {
 817         return addr->a_family;
 818 }
 819
 820 /**
 821  * Set the prefix length / netmask
 822  * @arg addr            Address
 823  * @arg prefixlen       Length of prefix (netmask)
 824  *
 825  * Modifies the length of the prefix. If the address object contains a peer
 826  * address the prefix length will apply to it, otherwise the prefix length
 827  * will apply to the local address of the address.
 828  *
 829  * If the address object contains a peer or local address the corresponding
 830  * `struct nl_addr` will be updated with the new prefix length.
 831  *
 832  * @note Specifying a length of 0 will remove the prefix length alltogether.
 833  *
 834  * @see rtnl_addr_get_prefixlen()
 835  */
 836 void rtnl_addr_set_prefixlen(struct rtnl_addr *addr, int prefixlen)
 837 {
 838         addr->a_prefixlen = prefixlen;
 839
 840         if (prefixlen)
 841                 addr->ce_mask |= ADDR_ATTR_PREFIXLEN;
 842         else
 843                 addr->ce_mask &= ~ADDR_ATTR_PREFIXLEN;
 844
 845         /*
 846          * The prefix length always applies to the peer address if
 847          * a peer address is present.
 848          */
 849         if (addr->a_peer)
 850                 nl_addr_set_prefixlen(addr->a_peer, prefixlen);
 851         else if (addr->a_local)
 852                 nl_addr_set_prefixlen(addr->a_local, prefixlen);
 853 }
 854
 855 int rtnl_addr_get_prefixlen(struct rtnl_addr *addr)
 856 {
 857         return addr->a_prefixlen;
 858 }
 859
 860 void rtnl_addr_set_scope(struct rtnl_addr *addr, int scope)
 861 {
 862         addr->a_scope = scope;
 863         addr->ce_mask |= ADDR_ATTR_SCOPE;
 864 }
 865
 866 int rtnl_addr_get_scope(struct rtnl_addr *addr)
 867 {
 868         return addr->a_scope;
 869 }
 870
 871 void rtnl_addr_set_flags(struct rtnl_addr *addr, unsigned int flags)
 872 {
 873         addr->a_flag_mask |= flags;
 874         addr->a_flags |= flags;
 875         addr->ce_mask |= ADDR_ATTR_FLAGS;
 876 }
 877
 878 void rtnl_addr_unset_flags(struct rtnl_addr *addr, unsigned int flags)
 879 {
 880         addr->a_flag_mask |= flags;
 881         addr->a_flags &= ~flags;
 882         addr->ce_mask |= ADDR_ATTR_FLAGS;
 883 }
 884
 885 unsigned int rtnl_addr_get_flags(struct rtnl_addr *addr)
 886 {
 887         return addr->a_flags;
 888 }
 889
 890 static inline int __assign_addr(struct rtnl_addr *addr, struct nl_addr **pos,
 891                                 struct nl_addr *new, int flag)
 892 {
 893         if (new) {
 894                 if (addr->ce_mask & ADDR_ATTR_FAMILY) {
 895                         if (new->a_family != addr->a_family)
 896                                 return -NLE_AF_MISMATCH;
 897                 } else
 898                         addr->a_family = new->a_family;
 899
 900                 if (*pos)
 901                         nl_addr_put(*pos);
 902
 903                 *pos = nl_addr_get(new);
 904                 addr->ce_mask |= (flag | ADDR_ATTR_FAMILY);
 905         } else {
 906                 if (*pos)
 907                         nl_addr_put(*pos);
 908
 909                 *pos = NULL;
 910                 addr->ce_mask &= ~flag;
 911         }
 912
 913         return 0;
 914 }
 915
 916 int rtnl_addr_set_local(struct rtnl_addr *addr, struct nl_addr *local)
 917 {
 918         int err;
 919
 920         /* Prohibit local address with prefix length if peer address is present */
 921         if ((addr->ce_mask & ADDR_ATTR_PEER) && local &&
 922             nl_addr_get_prefixlen(local))
 923                 return -NLE_INVAL;
 924
 925         err = __assign_addr(addr, &addr->a_local, local, ADDR_ATTR_LOCAL);
 926         if (err < 0)
 927                 return err;
 928
 929         /* Never overwrite the prefix length if a peer address is present */
 930         if (!(addr->ce_mask & ADDR_ATTR_PEER))
 931                 rtnl_addr_set_prefixlen(addr, local ? nl_addr_get_prefixlen(local) : 0);
 932
 933         return 0;
 934 }
 935
 936 struct nl_addr *rtnl_addr_get_local(struct rtnl_addr *addr)
 937 {
 938         return addr->a_local;
 939 }
 940
 941 int rtnl_addr_set_peer(struct rtnl_addr *addr, struct nl_addr *peer)
 942 {
 943         int err;
 944
 945         if (peer && peer->a_family != AF_INET)
 946                 return -NLE_AF_NOSUPPORT;
 947
 948         err = __assign_addr(addr, &addr->a_peer, peer, ADDR_ATTR_PEER);
 949         if (err < 0)
 950                 return err;
 951
 952         rtnl_addr_set_prefixlen(addr, peer ? nl_addr_get_prefixlen(peer) : 0);
 953
 954         return 0;
 955 }
 956
 957 struct nl_addr *rtnl_addr_get_peer(struct rtnl_addr *addr)
 958 {
 959         return addr->a_peer;
 960 }
 961
 962 int rtnl_addr_set_broadcast(struct rtnl_addr *addr, struct nl_addr *bcast)
 963 {
 964         if (bcast && bcast->a_family != AF_INET)
 965                 return -NLE_AF_NOSUPPORT;
 966
 967         return __assign_addr(addr, &addr->a_bcast, bcast, ADDR_ATTR_BROADCAST);
 968 }
 969
 970 struct nl_addr *rtnl_addr_get_broadcast(struct rtnl_addr *addr)
 971 {
 972         return addr->a_bcast;
 973 }
 974
 975 int rtnl_addr_set_multicast(struct rtnl_addr *addr, struct nl_addr *multicast)
 976 {
 977         if (multicast && multicast->a_family != AF_INET6)
 978                 return -NLE_AF_NOSUPPORT;
 979
 980         return __assign_addr(addr, &addr->a_multicast, multicast,
 981                              ADDR_ATTR_MULTICAST);
 982 }
 983
 984 struct nl_addr *rtnl_addr_get_multicast(struct rtnl_addr *addr)
 985 {
 986         return addr->a_multicast;
 987 }
 988
 989 int rtnl_addr_set_anycast(struct rtnl_addr *addr, struct nl_addr *anycast)
 990 {
 991         if (anycast && anycast->a_family != AF_INET6)
 992                 return -NLE_AF_NOSUPPORT;
 993
 994         return __assign_addr(addr, &addr->a_anycast, anycast,
 995                              ADDR_ATTR_ANYCAST);
 996 }
 997
 998 struct nl_addr *rtnl_addr_get_anycast(struct rtnl_addr *addr)
 999 {
1000         return addr->a_anycast;
1001 }
1002
1003 uint32_t rtnl_addr_get_valid_lifetime(struct rtnl_addr *addr)
1004 {
1005         if (addr->ce_mask & ADDR_ATTR_CACHEINFO)
1006                 return addr->a_cacheinfo.aci_valid;
1007         else
1008                 return 0xFFFFFFFFU;
1009 }
1010
1011 void rtnl_addr_set_valid_lifetime(struct rtnl_addr *addr, uint32_t lifetime)
1012 {
1013         addr->a_cacheinfo.aci_valid = lifetime;
1014         addr->ce_mask |= ADDR_ATTR_CACHEINFO;
1015 }
1016
1017 uint32_t rtnl_addr_get_preferred_lifetime(struct rtnl_addr *addr)
1018 {
1019         if (addr->ce_mask & ADDR_ATTR_CACHEINFO)
1020                 return addr->a_cacheinfo.aci_prefered;
1021         else
1022                 return 0xFFFFFFFFU;
1023 }
1024
1025 void rtnl_addr_set_preferred_lifetime(struct rtnl_addr *addr, uint32_t lifetime)
1026 {
1027         addr->a_cacheinfo.aci_prefered = lifetime;
1028         addr->ce_mask |= ADDR_ATTR_CACHEINFO;
1029 }
1030
1031 uint32_t rtnl_addr_get_create_time(struct rtnl_addr *addr)
1032 {
1033         return addr->a_cacheinfo.aci_cstamp;
1034 }
1035
1036 uint32_t rtnl_addr_get_last_update_time(struct rtnl_addr *addr)
1037 {
1038         return addr->a_cacheinfo.aci_tstamp;
1039 }
1040
1041 /** @} */
1042
1043 /**
1044  * @name Flags Translations
1045  * @{
1046  */
1047
1048 static const struct trans_tbl addr_flags[] = {
1049         __ADD(IFA_F_SECONDARY, secondary)
1050         __ADD(IFA_F_NODAD, nodad)
1051         __ADD(IFA_F_OPTIMISTIC, optimistic)
1052         __ADD(IFA_F_HOMEADDRESS, homeaddress)
1053         __ADD(IFA_F_DEPRECATED, deprecated)
1054         __ADD(IFA_F_TENTATIVE, tentative)
1055         __ADD(IFA_F_PERMANENT, permanent)
1056 };
1057
1058 char *rtnl_addr_flags2str(int flags, char *buf, size_t size)
1059 {
1060         return __flags2str(flags, buf, size, addr_flags,
1061                            ARRAY_SIZE(addr_flags));
1062 }
1063
1064 int rtnl_addr_str2flags(const char *name)
1065 {
1066         return __str2flags(name, addr_flags, ARRAY_SIZE(addr_flags));
1067 }
1068
1069 /** @} */
1070
1071 static struct nl_object_ops addr_obj_ops = {
1072         .oo_name                = "route/addr",
1073         .oo_size                = sizeof(struct rtnl_addr),
1074         .oo_constructor         = addr_constructor,
1075         .oo_free_data           = addr_free_data,
1076         .oo_clone               = addr_clone,
1077         .oo_dump = {
1078             [NL_DUMP_LINE]      = addr_dump_line,
1079             [NL_DUMP_DETAILS]   = addr_dump_details,
1080             [NL_DUMP_STATS]     = addr_dump_stats,
1081         },
1082         .oo_compare             = addr_compare,
1083         .oo_attrs2str           = addr_attrs2str,
1084         .oo_id_attrs            = (ADDR_ATTR_FAMILY | ADDR_ATTR_IFINDEX |
1085                                    ADDR_ATTR_LOCAL | ADDR_ATTR_PREFIXLEN),
1086 };
1087
1088 static struct nl_af_group addr_groups[] = {
1089         { AF_INET,      RTNLGRP_IPV4_IFADDR },
1090         { AF_INET6,     RTNLGRP_IPV6_IFADDR },
1091         { END_OF_GROUP_LIST },
1092 };
1093
1094 static struct nl_cache_ops rtnl_addr_ops = {
1095         .co_name                = "route/addr",
1096         .co_hdrsize             = sizeof(struct ifaddrmsg),
1097         .co_msgtypes            = {
1098                                         { RTM_NEWADDR, NL_ACT_NEW, "new" },
1099                                         { RTM_DELADDR, NL_ACT_DEL, "del" },
1100                                         { RTM_GETADDR, NL_ACT_GET, "get" },
1101                                         END_OF_MSGTYPES_LIST,
1102                                   },
1103         .co_protocol            = NETLINK_ROUTE,
1104         .co_groups              = addr_groups,
1105         .co_request_update      = addr_request_update,
1106         .co_msg_parser          = addr_msg_parser,
1107         .co_obj_ops             = &addr_obj_ops,
1108 };
1109
1110 static void __init addr_init(void)
1111 {
1112         nl_cache_mngt_register(&rtnl_addr_ops);
1113 }
1114
1115 static void __exit addr_exit(void)
1116 {
1117         nl_cache_mngt_unregister(&rtnl_addr_ops);
1118 }
1119
1120 /** @} */