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-2008 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-local.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 131static struct nl_cache_ops rtnl_addr_ops; 132static struct nl_object_ops addr_obj_ops; 133/** @endcond */ 134 135static 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 142static 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} 155 156static int addr_clone(struct nl_object *_dst, struct nl_object *_src) 157{ 158 struct rtnl_addr *dst = nl_object_priv(_dst); 159 struct rtnl_addr *src = nl_object_priv(_src); 160 161 if (src->a_peer) 162 if (!(dst->a_peer = nl_addr_clone(src->a_peer))) 163 return -NLE_NOMEM; 164 165 if (src->a_local) 166 if (!(dst->a_local = nl_addr_clone(src->a_local))) 167 return -NLE_NOMEM; 168 169 if (src->a_bcast) 170 if (!(dst->a_bcast = nl_addr_clone(src->a_bcast))) 171 return -NLE_NOMEM; 172 173 if (src->a_multicast) 174 if (!(dst->a_multicast = nl_addr_clone(src->a_multicast))) 175 return -NLE_NOMEM; 176 177 if (src->a_anycast) 178 if (!(dst->a_anycast = nl_addr_clone(src->a_anycast))) 179 return -NLE_NOMEM; 180 181 return 0; 182} 183 184static struct nla_policy addr_policy[IFA_MAX+1] = { 185 [IFA_LABEL] = { .type = NLA_STRING, 186 .maxlen = IFNAMSIZ }, 187 [IFA_CACHEINFO] = { .minlen = sizeof(struct ifa_cacheinfo) }, 188}; 189 190static int addr_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who, 191 struct nlmsghdr *nlh, struct nl_parser_param *pp) 192{ 193 struct rtnl_addr *addr; 194 struct ifaddrmsg *ifa; 195 struct nlattr *tb[IFA_MAX+1]; 196 int err, peer_prefix = 0, family; 197 198 addr = rtnl_addr_alloc(); 199 if (!addr) 200 return -NLE_NOMEM; 201 202 addr->ce_msgtype = nlh->nlmsg_type; 203 204 err = nlmsg_parse(nlh, sizeof(*ifa), tb, IFA_MAX, addr_policy); 205 if (err < 0) 206 goto errout; 207 208 ifa = nlmsg_data(nlh); 209 addr->a_family = family = ifa->ifa_family; 210 addr->a_prefixlen = ifa->ifa_prefixlen; 211 addr->a_flags = ifa->ifa_flags; 212 addr->a_scope = ifa->ifa_scope; 213 addr->a_ifindex = ifa->ifa_index; 214 215 addr->ce_mask = (ADDR_ATTR_FAMILY | ADDR_ATTR_PREFIXLEN | 216 ADDR_ATTR_FLAGS | ADDR_ATTR_SCOPE | ADDR_ATTR_IFINDEX); 217 218 if (tb[IFA_LABEL]) { 219 nla_strlcpy(addr->a_label, tb[IFA_LABEL], IFNAMSIZ); 220 addr->ce_mask |= ADDR_ATTR_LABEL; 221 } 222 223 if (tb[IFA_CACHEINFO]) { 224 struct ifa_cacheinfo *ca; 225 226 ca = nla_data(tb[IFA_CACHEINFO]); 227 addr->a_cacheinfo.aci_prefered = ca->ifa_prefered; 228 addr->a_cacheinfo.aci_valid = ca->ifa_valid; 229 addr->a_cacheinfo.aci_cstamp = ca->cstamp; 230 addr->a_cacheinfo.aci_tstamp = ca->tstamp; 231 addr->ce_mask |= ADDR_ATTR_CACHEINFO; 232 } 233 234 if (tb[IFA_LOCAL]) { 235 addr->a_local = nl_addr_alloc_attr(tb[IFA_LOCAL], family); 236 if (!addr->a_local) 237 goto errout_nomem; 238 addr->ce_mask |= ADDR_ATTR_LOCAL; 239 } 240 241 if (tb[IFA_ADDRESS]) { 242 struct nl_addr *a; 243 244 a = nl_addr_alloc_attr(tb[IFA_ADDRESS], family); 245 if (!a) 246 goto errout_nomem; 247 248 /* IPv6 sends the local address as IFA_ADDRESS with 249 * no IFA_LOCAL, IPv4 sends both IFA_LOCAL and IFA_ADDRESS 250 * with IFA_ADDRESS being the peer address if they differ */ 251 if (!tb[IFA_LOCAL] || !nl_addr_cmp(a, addr->a_local)) { 252 nl_addr_put(addr->a_local); 253 addr->a_local = a; 254 addr->ce_mask |= ADDR_ATTR_LOCAL; 255 } else { 256 addr->a_peer = a; 257 addr->ce_mask |= ADDR_ATTR_PEER; 258 peer_prefix = 1; 259 } 260 } 261 262 nl_addr_set_prefixlen(peer_prefix ? addr->a_peer : addr->a_local, 263 addr->a_prefixlen); 264 265 if (tb[IFA_BROADCAST]) { 266 addr->a_bcast = nl_addr_alloc_attr(tb[IFA_BROADCAST], family); 267 if (!addr->a_bcast) 268 goto errout_nomem; 269 270 addr->ce_mask |= ADDR_ATTR_BROADCAST; 271 } 272 273 if (tb[IFA_MULTICAST]) { 274 addr->a_multicast = nl_addr_alloc_attr(tb[IFA_MULTICAST], 275 family); 276 if (!addr->a_multicast) 277 goto errout_nomem; 278 279 addr->ce_mask |= ADDR_ATTR_MULTICAST; 280 } 281 282 if (tb[IFA_ANYCAST]) { 283 addr->a_anycast = nl_addr_alloc_attr(tb[IFA_ANYCAST], 284 family); 285 if (!addr->a_anycast) 286 goto errout_nomem; 287 288 addr->ce_mask |= ADDR_ATTR_ANYCAST; 289 } 290 291 err = pp->pp_cb((struct nl_object *) addr, pp); 292errout: 293 rtnl_addr_put(addr); 294 295 return err; 296 297errout_nomem: 298 err = -NLE_NOMEM; 299 goto errout; 300} 301 302static int addr_request_update(struct nl_cache *cache, struct nl_sock *sk) 303{ 304 return nl_rtgen_request(sk, RTM_GETADDR, AF_UNSPEC, NLM_F_DUMP); 305} 306 307static void addr_dump_line(struct nl_object *obj, struct nl_dump_params *p) 308{ 309 struct rtnl_addr *addr = (struct rtnl_addr *) obj; 310 struct nl_cache *link_cache; 311 char buf[128]; 312 313 link_cache = nl_cache_mngt_require("route/link"); 314 315 if (addr->ce_mask & ADDR_ATTR_LOCAL) 316 nl_dump_line(p, "%s", 317 nl_addr2str(addr->a_local, buf, sizeof(buf))); 318 else 319 nl_dump_line(p, "none"); 320 321 if (addr->ce_mask & ADDR_ATTR_PEER) 322 nl_dump(p, " peer %s", 323 nl_addr2str(addr->a_peer, buf, sizeof(buf))); 324 325 nl_dump(p, " %s ", nl_af2str(addr->a_family, buf, sizeof(buf))); 326 327 if (link_cache) 328 nl_dump(p, "dev %s ", 329 rtnl_link_i2name(link_cache, addr->a_ifindex, 330 buf, sizeof(buf))); 331 else 332 nl_dump(p, "dev %d ", addr->a_ifindex); 333 334 nl_dump(p, "scope %s", 335 rtnl_scope2str(addr->a_scope, buf, sizeof(buf))); 336 337 rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf)); 338 if (buf[0]) 339 nl_dump(p, " <%s>", buf); 340 341 nl_dump(p, "\n"); 342} 343 344static void addr_dump_details(struct nl_object *obj, struct nl_dump_params *p) 345{ 346 struct rtnl_addr *addr = (struct rtnl_addr *) obj; 347 char buf[128]; 348 349 addr_dump_line(obj, p); 350 351 if (addr->ce_mask & (ADDR_ATTR_LABEL | ADDR_ATTR_BROADCAST | 352 ADDR_ATTR_MULTICAST)) { 353 nl_dump_line(p, " "); 354 355 if (addr->ce_mask & ADDR_ATTR_LABEL) 356 nl_dump(p, " label %s", addr->a_label); 357 358 if (addr->ce_mask & ADDR_ATTR_BROADCAST) 359 nl_dump(p, " broadcast %s", 360 nl_addr2str(addr->a_bcast, buf, sizeof(buf))); 361 362 if (addr->ce_mask & ADDR_ATTR_MULTICAST) 363 nl_dump(p, " multicast %s", 364 nl_addr2str(addr->a_multicast, buf, 365 sizeof(buf))); 366 367 if (addr->ce_mask & ADDR_ATTR_ANYCAST) 368 nl_dump(p, " anycast %s", 369 nl_addr2str(addr->a_anycast, buf, 370 sizeof(buf))); 371 372 nl_dump(p, "\n"); 373 } 374 375 if (addr->ce_mask & ADDR_ATTR_CACHEINFO) { 376 struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo; 377 378 nl_dump_line(p, " valid-lifetime %s", 379 ci->aci_valid == 0xFFFFFFFFU ? "forever" : 380 nl_msec2str(ci->aci_valid * 1000, 381 buf, sizeof(buf))); 382 383 nl_dump(p, " preferred-lifetime %s\n", 384 ci->aci_prefered == 0xFFFFFFFFU ? "forever" : 385 nl_msec2str(ci->aci_prefered * 1000, 386 buf, sizeof(buf))); 387 388 nl_dump_line(p, " created boot-time+%s ", 389 nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10, 390 buf, sizeof(buf))); 391 392 nl_dump(p, "last-updated boot-time+%s\n", 393 nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10, 394 buf, sizeof(buf))); 395 } 396} 397 398static void addr_dump_stats(struct nl_object *obj, struct nl_dump_params *p) 399{ 400 addr_dump_details(obj, p); 401} 402 403static void addr_dump_env(struct nl_object *obj, struct nl_dump_params *p) 404{ 405 struct rtnl_addr *addr = (struct rtnl_addr *) obj; 406 struct nl_cache *link_cache; 407 char buf[128]; 408 409 nl_dump_line(p, "ADDR_FAMILY=%s\n", 410 nl_af2str(addr->a_family, buf, sizeof(buf))); 411 412 if (addr->ce_mask & ADDR_ATTR_LOCAL) 413 nl_dump_line(p, "ADDR_LOCAL=%s\n", 414 nl_addr2str(addr->a_local, buf, sizeof(buf))); 415 416 if (addr->ce_mask & ADDR_ATTR_PEER) 417 nl_dump_line(p, "ADDR_PEER=%s\n", 418 nl_addr2str(addr->a_peer, buf, sizeof(buf))); 419 420 if (addr->ce_mask & ADDR_ATTR_BROADCAST) 421 nl_dump_line(p, "ADDR_BROADCAST=%s\n", 422 nl_addr2str(addr->a_bcast, buf, sizeof(buf))); 423 424 if (addr->ce_mask & ADDR_ATTR_ANYCAST) 425 nl_dump_line(p, "ADDR_ANYCAST=%s\n", 426 nl_addr2str(addr->a_anycast, buf, sizeof(buf))); 427 428 if (addr->ce_mask & ADDR_ATTR_MULTICAST) 429 nl_dump_line(p, "ADDR_MULTICAST=%s\n", 430 nl_addr2str(addr->a_multicast, buf, 431 sizeof(buf))); 432 433 if (addr->ce_mask & ADDR_ATTR_PREFIXLEN) 434 nl_dump_line(p, "ADDR_PREFIXLEN=%u\n", 435 addr->a_prefixlen); 436 link_cache = nl_cache_mngt_require("route/link"); 437 438 nl_dump_line(p, "ADDR_IFINDEX=%u\n", addr->a_ifindex); 439 if (link_cache) 440 nl_dump_line(p, "ADDR_IFNAME=%s\n", 441 rtnl_link_i2name(link_cache, addr->a_ifindex, 442 buf, sizeof(buf))); 443 444 if (addr->ce_mask & ADDR_ATTR_SCOPE) 445 nl_dump_line(p, "ADDR_SCOPE=%s\n", 446 rtnl_scope2str(addr->a_scope, buf, sizeof(buf))); 447 448 if (addr->ce_mask & ADDR_ATTR_LABEL) 449 nl_dump_line(p, "ADDR_LABEL=%s\n", addr->a_label); 450 451 rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf)); 452 if (buf[0]) 453 nl_dump_line(p, "ADDR_FLAGS=%s\n", buf); 454 455 if (addr->ce_mask & ADDR_ATTR_CACHEINFO) { 456 struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo; 457 458 nl_dump_line(p, "ADDR_CACHEINFO_VALID=%s\n", 459 ci->aci_valid == 0xFFFFFFFFU ? "forever" : 460 nl_msec2str(ci->aci_valid * 1000, 461 buf, sizeof(buf))); 462 463 nl_dump_line(p, "ADDR_CACHEINFO_PREFERED=%s\n", 464 ci->aci_prefered == 0xFFFFFFFFU ? "forever" : 465 nl_msec2str(ci->aci_prefered * 1000, 466 buf, sizeof(buf))); 467 468 nl_dump_line(p, "ADDR_CACHEINFO_CREATED=%s\n", 469 nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10, 470 buf, sizeof(buf))); 471 472 nl_dump_line(p, "ADDR_CACHEINFO_LASTUPDATE=%s\n", 473 nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10, 474 buf, sizeof(buf))); 475 } 476} 477 478static int addr_compare(struct nl_object *_a, struct nl_object *_b, 479 uint32_t attrs, int flags) 480{ 481 struct rtnl_addr *a = (struct rtnl_addr *) _a; 482 struct rtnl_addr *b = (struct rtnl_addr *) _b; 483 int diff = 0; 484 485#define ADDR_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ADDR_ATTR_##ATTR, a, b, EXPR) 486 487 diff |= ADDR_DIFF(IFINDEX, a->a_ifindex != b->a_ifindex); 488 diff |= ADDR_DIFF(FAMILY, a->a_family != b->a_family); 489 diff |= ADDR_DIFF(SCOPE, a->a_scope != b->a_scope); 490 diff |= ADDR_DIFF(LABEL, strcmp(a->a_label, b->a_label)); 491 diff |= ADDR_DIFF(PEER, nl_addr_cmp(a->a_peer, b->a_peer)); 492 diff |= ADDR_DIFF(LOCAL, nl_addr_cmp(a->a_local, b->a_local)); 493 diff |= ADDR_DIFF(MULTICAST, nl_addr_cmp(a->a_multicast, 494 b->a_multicast)); 495 diff |= ADDR_DIFF(BROADCAST, nl_addr_cmp(a->a_bcast, b->a_bcast)); 496 diff |= ADDR_DIFF(ANYCAST, nl_addr_cmp(a->a_anycast, b->a_anycast)); 497 498 if (flags & LOOSE_COMPARISON) 499 diff |= ADDR_DIFF(FLAGS, 500 (a->a_flags ^ b->a_flags) & b->a_flag_mask); 501 else 502 diff |= ADDR_DIFF(FLAGS, a->a_flags != b->a_flags); 503 504#undef ADDR_DIFF 505 506 return diff; 507} 508 509static struct trans_tbl addr_attrs[] = { 510 __ADD(ADDR_ATTR_FAMILY, family) 511 __ADD(ADDR_ATTR_PREFIXLEN, prefixlen) 512 __ADD(ADDR_ATTR_FLAGS, flags) 513 __ADD(ADDR_ATTR_SCOPE, scope) 514 __ADD(ADDR_ATTR_IFINDEX, ifindex) 515 __ADD(ADDR_ATTR_LABEL, label) 516 __ADD(ADDR_ATTR_CACHEINFO, cacheinfo) 517 __ADD(ADDR_ATTR_PEER, peer) 518 __ADD(ADDR_ATTR_LOCAL, local) 519 __ADD(ADDR_ATTR_BROADCAST, broadcast) 520 __ADD(ADDR_ATTR_MULTICAST, multicast) 521}; 522 523static char *addr_attrs2str(int attrs, char *buf, size_t len) 524{ 525 return __flags2str(attrs, buf, len, addr_attrs, 526 ARRAY_SIZE(addr_attrs)); 527} 528 529/** 530 * @name Allocation/Freeing 531 * @{ 532 */ 533 534struct rtnl_addr *rtnl_addr_alloc(void) 535{ 536 return (struct rtnl_addr *) nl_object_alloc(&addr_obj_ops); 537} 538 539void rtnl_addr_put(struct rtnl_addr *addr) 540{ 541 nl_object_put((struct nl_object *) addr); 542} 543 544/** @} */ 545 546/** 547 * @name Cache Management 548 * @{ 549 */ 550 551int rtnl_addr_alloc_cache(struct nl_sock *sk, struct nl_cache **result) 552{ 553 return nl_cache_alloc_and_fill(&rtnl_addr_ops, sk, result); 554} 555 556/** @} */ 557 558static int build_addr_msg(struct rtnl_addr *tmpl, int cmd, int flags, 559 struct nl_msg **result) 560{ 561 struct nl_msg *msg; 562 struct ifaddrmsg am = { 563 .ifa_family = tmpl->a_family, 564 .ifa_index = tmpl->a_ifindex, 565 .ifa_prefixlen = tmpl->a_prefixlen, 566 }; 567 568 if (tmpl->ce_mask & ADDR_ATTR_SCOPE) 569 am.ifa_scope = tmpl->a_scope; 570 else { 571 /* compatibility hack */ 572 if (tmpl->a_family == AF_INET && 573 tmpl->ce_mask & ADDR_ATTR_LOCAL && 574 *((char *) nl_addr_get_binary_addr(tmpl->a_local)) == 127) 575 am.ifa_scope = RT_SCOPE_HOST; 576 else 577 am.ifa_scope = RT_SCOPE_UNIVERSE; 578 } 579 580 msg = nlmsg_alloc_simple(cmd, flags); 581 if (!msg) 582 return -NLE_NOMEM; 583 584 if (nlmsg_append(msg, &am, sizeof(am), NLMSG_ALIGNTO) < 0) 585 goto nla_put_failure; 586 587 if (tmpl->ce_mask & ADDR_ATTR_LOCAL) 588 NLA_PUT_ADDR(msg, IFA_LOCAL, tmpl->a_local); 589 590 if (tmpl->ce_mask & ADDR_ATTR_PEER) 591 NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_peer); 592 else if (tmpl->ce_mask & ADDR_ATTR_LOCAL) 593 NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_local); 594 595 if (tmpl->ce_mask & ADDR_ATTR_LABEL) 596 NLA_PUT_STRING(msg, IFA_LABEL, tmpl->a_label); 597 598 if (tmpl->ce_mask & ADDR_ATTR_BROADCAST) 599 NLA_PUT_ADDR(msg, IFA_BROADCAST, tmpl->a_bcast); 600 601 if (tmpl->ce_mask & ADDR_ATTR_CACHEINFO) { 602 struct ifa_cacheinfo ca = { 603 .ifa_valid = tmpl->a_cacheinfo.aci_valid, 604 .ifa_prefered = tmpl->a_cacheinfo.aci_prefered, 605 }; 606 607 NLA_PUT(msg, IFA_CACHEINFO, sizeof(ca), &ca); 608 } 609 610 611 *result = msg; 612 return 0; 613 614nla_put_failure: 615 nlmsg_free(msg); 616 return -NLE_MSGSIZE; 617} 618 619/** 620 * @name Addition 621 * @{ 622 */ 623 624/** 625 * Build netlink request message to request addition of new address 626 * @arg addr Address object representing the new address. 627 * @arg flags Additional netlink message flags. 628 * @arg result Pointer to store resulting message. 629 * 630 * Builds a new netlink message requesting the addition of a new 631 * address. The netlink message header isn't fully equipped with 632 * all relevant fields and must thus be sent out via nl_send_auto_complete() 633 * or supplemented as needed. 634 * 635 * Minimal required attributes: 636 * - interface index (rtnl_addr_set_ifindex()) 637 * - local address (rtnl_addr_set_local()) 638 * 639 * The scope will default to universe except for loopback addresses in 640 * which case a host scope is used if not specified otherwise. 641 * 642 * @note Free the memory after usage using nlmsg_free(). 643 * 644 * @return 0 on success or a negative error code. 645 */ 646int rtnl_addr_build_add_request(struct rtnl_addr *addr, int flags, 647 struct nl_msg **result) 648{ 649 int required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY | 650 ADDR_ATTR_PREFIXLEN | ADDR_ATTR_LOCAL; 651 652 if ((addr->ce_mask & required) != required) 653 return -NLE_MISSING_ATTR; 654 655 return build_addr_msg(addr, RTM_NEWADDR, NLM_F_CREATE | flags, result); 656} 657 658/** 659 * Request addition of new address 660 * @arg sk Netlink socket. 661 * @arg addr Address object representing the new address. 662 * @arg flags Additional netlink message flags. 663 * 664 * Builds a netlink message by calling rtnl_addr_build_add_request(), 665 * sends the request to the kernel and waits for the next ACK to be 666 * received and thus blocks until the request has been fullfilled. 667 * 668 * @see rtnl_addr_build_add_request() 669 * 670 * @return 0 on sucess or a negative error if an error occured. 671 */ 672int rtnl_addr_add(struct nl_sock *sk, struct rtnl_addr *addr, int flags) 673{ 674 struct nl_msg *msg; 675 int err; 676 677 if ((err = rtnl_addr_build_add_request(addr, flags, &msg)) < 0) 678 return err; 679 680 err = nl_send_auto_complete(sk, msg); 681 nlmsg_free(msg); 682 if (err < 0) 683 return err; 684 685 return wait_for_ack(sk); 686} 687 688/** @} */ 689 690/** 691 * @name Deletion 692 * @{ 693 */ 694 695/** 696 * Build a netlink request message to request deletion of an address 697 * @arg addr Address object to be deleteted. 698 * @arg flags Additional netlink message flags. 699 * @arg result Pointer to store resulting message. 700 * 701 * Builds a new netlink message requesting a deletion of an address. 702 * The netlink message header isn't fully equipped with all relevant 703 * fields and must thus be sent out via nl_send_auto_complete() 704 * or supplemented as needed. 705 * 706 * Minimal required attributes: 707 * - interface index (rtnl_addr_set_ifindex()) 708 * - address family (rtnl_addr_set_family()) 709 * 710 * Optional attributes: 711 * - local address (rtnl_addr_set_local()) 712 * - label (rtnl_addr_set_label(), IPv4/DECnet only) 713 * - peer address (rtnl_addr_set_peer(), IPv4 only) 714 * 715 * @note Free the memory after usage using nlmsg_free(). 716 * 717 * @return 0 on success or a negative error code. 718 */ 719int rtnl_addr_build_delete_request(struct rtnl_addr *addr, int flags, 720 struct nl_msg **result) 721{ 722 int required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY; 723 724 if ((addr->ce_mask & required) != required) 725 return -NLE_MISSING_ATTR; 726 727 return build_addr_msg(addr, RTM_DELADDR, flags, result); 728} 729 730/** 731 * Request deletion of an address 732 * @arg sk Netlink socket. 733 * @arg addr Address object to be deleted. 734 * @arg flags Additional netlink message flags. 735 * 736 * Builds a netlink message by calling rtnl_addr_build_delete_request(), 737 * sends the request to the kernel and waits for the next ACK to be 738 * received and thus blocks until the request has been fullfilled. 739 * 740 * @see rtnl_addr_build_delete_request(); 741 * 742 * @return 0 on sucess or a negative error if an error occured. 743 */ 744int rtnl_addr_delete(struct nl_sock *sk, struct rtnl_addr *addr, int flags) 745{ 746 struct nl_msg *msg; 747 int err; 748 749 if ((err = rtnl_addr_build_delete_request(addr, flags, &msg)) < 0) 750 return err; 751 752 err = nl_send_auto_complete(sk, msg); 753 nlmsg_free(msg); 754 if (err < 0) 755 return err; 756 757 return wait_for_ack(sk); 758} 759 760/** @} */ 761 762/** 763 * @name Attributes 764 * @{ 765 */ 766 767int rtnl_addr_set_label(struct rtnl_addr *addr, const char *label) 768{ 769 if (strlen(label) > sizeof(addr->a_label) - 1) 770 return -NLE_RANGE; 771 772 strcpy(addr->a_label, label); 773 addr->ce_mask |= ADDR_ATTR_LABEL; 774 775 return 0; 776} 777 778char *rtnl_addr_get_label(struct rtnl_addr *addr) 779{ 780 if (addr->ce_mask & ADDR_ATTR_LABEL) 781 return addr->a_label; 782 else 783 return NULL; 784} 785 786void rtnl_addr_set_ifindex(struct rtnl_addr *addr, int ifindex) 787{ 788 addr->a_ifindex = ifindex; 789 addr->ce_mask |= ADDR_ATTR_IFINDEX; 790} 791 792int rtnl_addr_get_ifindex(struct rtnl_addr *addr) 793{ 794 return addr->a_ifindex; 795} 796 797void rtnl_addr_set_family(struct rtnl_addr *addr, int family) 798{ 799 addr->a_family = family; 800 addr->ce_mask |= ADDR_ATTR_FAMILY; 801} 802 803int rtnl_addr_get_family(struct rtnl_addr *addr) 804{ 805 return addr->a_family; 806} 807 808void rtnl_addr_set_prefixlen(struct rtnl_addr *addr, int prefix) 809{ 810 addr->a_prefixlen = prefix; 811 addr->ce_mask |= ADDR_ATTR_PREFIXLEN; 812} 813 814int rtnl_addr_get_prefixlen(struct rtnl_addr *addr) 815{ 816 return addr->a_prefixlen; 817} 818 819void rtnl_addr_set_scope(struct rtnl_addr *addr, int scope) 820{ 821 addr->a_scope = scope; 822 addr->ce_mask |= ADDR_ATTR_SCOPE; 823} 824 825int rtnl_addr_get_scope(struct rtnl_addr *addr) 826{ 827 return addr->a_scope; 828} 829 830void rtnl_addr_set_flags(struct rtnl_addr *addr, unsigned int flags) 831{ 832 addr->a_flag_mask |= flags; 833 addr->a_flags |= flags; 834 addr->ce_mask |= ADDR_ATTR_FLAGS; 835} 836 837void rtnl_addr_unset_flags(struct rtnl_addr *addr, unsigned int flags) 838{ 839 addr->a_flag_mask |= flags; 840 addr->a_flags &= ~flags; 841 addr->ce_mask |= ADDR_ATTR_FLAGS; 842} 843 844unsigned int rtnl_addr_get_flags(struct rtnl_addr *addr) 845{ 846 return addr->a_flags; 847} 848 849static inline int __assign_addr(struct rtnl_addr *addr, struct nl_addr **pos, 850 struct nl_addr *new, int flag) 851{ 852 if (addr->ce_mask & ADDR_ATTR_FAMILY) { 853 if (new->a_family != addr->a_family) 854 return -NLE_AF_MISMATCH; 855 } else 856 addr->a_family = new->a_family; 857 858 if (*pos) 859 nl_addr_put(*pos); 860 861 *pos = nl_addr_get(new); 862 addr->ce_mask |= (flag | ADDR_ATTR_FAMILY); 863 864 return 0; 865} 866 867int rtnl_addr_set_local(struct rtnl_addr *addr, struct nl_addr *local) 868{ 869 int err; 870 871 err = __assign_addr(addr, &addr->a_local, local, ADDR_ATTR_LOCAL); 872 if (err < 0) 873 return err; 874 875 if (!(addr->ce_mask & ADDR_ATTR_PEER)) { 876 addr->a_prefixlen = nl_addr_get_prefixlen(addr->a_local); 877 addr->ce_mask |= ADDR_ATTR_PREFIXLEN; 878 } 879 880 return 0; 881} 882 883struct nl_addr *rtnl_addr_get_local(struct rtnl_addr *addr) 884{ 885 return addr->a_local; 886} 887 888int rtnl_addr_set_peer(struct rtnl_addr *addr, struct nl_addr *peer) 889{ 890 return __assign_addr(addr, &addr->a_peer, peer, ADDR_ATTR_PEER); 891 892 addr->a_prefixlen = nl_addr_get_prefixlen(addr->a_peer); 893 addr->ce_mask |= ADDR_ATTR_PREFIXLEN; 894 895 return 0; 896} 897 898struct nl_addr *rtnl_addr_get_peer(struct rtnl_addr *addr) 899{ 900 return addr->a_peer; 901} 902 903int rtnl_addr_set_broadcast(struct rtnl_addr *addr, struct nl_addr *bcast) 904{ 905 return __assign_addr(addr, &addr->a_bcast, bcast, ADDR_ATTR_BROADCAST); 906} 907 908struct nl_addr *rtnl_addr_get_broadcast(struct rtnl_addr *addr) 909{ 910 return addr->a_bcast; 911} 912 913int rtnl_addr_set_multicast(struct rtnl_addr *addr, struct nl_addr *multicast) 914{ 915 return __assign_addr(addr, &addr->a_multicast, multicast, 916 ADDR_ATTR_MULTICAST); 917} 918 919struct nl_addr *rtnl_addr_get_multicast(struct rtnl_addr *addr) 920{ 921 return addr->a_multicast; 922} 923 924int rtnl_addr_set_anycast(struct rtnl_addr *addr, struct nl_addr *anycast) 925{ 926 return __assign_addr(addr, &addr->a_anycast, anycast, 927 ADDR_ATTR_ANYCAST); 928} 929 930struct nl_addr *rtnl_addr_get_anycast(struct rtnl_addr *addr) 931{ 932 return addr->a_anycast; 933} 934 935uint32_t rtnl_addr_get_valid_lifetime(struct rtnl_addr *addr) 936{ 937 if (addr->ce_mask & ADDR_ATTR_CACHEINFO) 938 return addr->a_cacheinfo.aci_valid; 939 else 940 return 0xFFFFFFFFU; 941} 942 943void rtnl_addr_set_valid_lifetime(struct rtnl_addr *addr, uint32_t lifetime) 944{ 945 addr->a_cacheinfo.aci_valid = lifetime; 946 addr->ce_mask |= ADDR_ATTR_CACHEINFO; 947} 948 949uint32_t rtnl_addr_get_preferred_lifetime(struct rtnl_addr *addr) 950{ 951 if (addr->ce_mask & ADDR_ATTR_CACHEINFO) 952 return addr->a_cacheinfo.aci_prefered; 953 else 954 return 0xFFFFFFFFU; 955} 956 957void rtnl_addr_set_preferred_lifetime(struct rtnl_addr *addr, uint32_t lifetime) 958{ 959 addr->a_cacheinfo.aci_prefered = lifetime; 960 addr->ce_mask |= ADDR_ATTR_CACHEINFO; 961} 962 963uint32_t rtnl_addr_get_create_time(struct rtnl_addr *addr) 964{ 965 return addr->a_cacheinfo.aci_cstamp; 966} 967 968uint32_t rtnl_addr_get_last_update_time(struct rtnl_addr *addr) 969{ 970 return addr->a_cacheinfo.aci_tstamp; 971} 972 973/** @} */ 974 975/** 976 * @name Flags Translations 977 * @{ 978 */ 979 980static struct trans_tbl addr_flags[] = { 981 __ADD(IFA_F_SECONDARY, secondary) 982 __ADD(IFA_F_NODAD, nodad) 983 __ADD(IFA_F_OPTIMISTIC, optimistic) 984 __ADD(IFA_F_HOMEADDRESS, homeaddress) 985 __ADD(IFA_F_DEPRECATED, deprecated) 986 __ADD(IFA_F_TENTATIVE, tentative) 987 __ADD(IFA_F_PERMANENT, permanent) 988}; 989 990char *rtnl_addr_flags2str(int flags, char *buf, size_t size) 991{ 992 return __flags2str(flags, buf, size, addr_flags, 993 ARRAY_SIZE(addr_flags)); 994} 995 996int rtnl_addr_str2flags(const char *name) 997{ 998 return __str2flags(name, addr_flags, ARRAY_SIZE(addr_flags)); 999} 1000 1001/** @} */ 1002 1003static struct nl_object_ops addr_obj_ops = { 1004 .oo_name = "route/addr", 1005 .oo_size = sizeof(struct rtnl_addr), 1006 .oo_constructor = addr_constructor, 1007 .oo_free_data = addr_free_data, 1008 .oo_clone = addr_clone, 1009 .oo_dump = { 1010 [NL_DUMP_LINE] = addr_dump_line, 1011 [NL_DUMP_DETAILS] = addr_dump_details, 1012 [NL_DUMP_STATS] = addr_dump_stats, 1013 [NL_DUMP_ENV] = addr_dump_env, 1014 }, 1015 .oo_compare = addr_compare, 1016 .oo_attrs2str = addr_attrs2str, 1017 .oo_id_attrs = (ADDR_ATTR_FAMILY | ADDR_ATTR_IFINDEX | 1018 ADDR_ATTR_LOCAL | ADDR_ATTR_PREFIXLEN), 1019}; 1020 1021static struct nl_af_group addr_groups[] = { 1022 { AF_INET, RTNLGRP_IPV4_IFADDR }, 1023 { AF_INET6, RTNLGRP_IPV6_IFADDR }, 1024 { END_OF_GROUP_LIST }, 1025}; 1026 1027static struct nl_cache_ops rtnl_addr_ops = { 1028 .co_name = "route/addr", 1029 .co_hdrsize = sizeof(struct ifaddrmsg), 1030 .co_msgtypes = { 1031 { RTM_NEWADDR, NL_ACT_NEW, "new" }, 1032 { RTM_DELADDR, NL_ACT_DEL, "del" }, 1033 { RTM_GETADDR, NL_ACT_GET, "get" }, 1034 END_OF_MSGTYPES_LIST, 1035 }, 1036 .co_protocol = NETLINK_ROUTE, 1037 .co_groups = addr_groups, 1038 .co_request_update = addr_request_update, 1039 .co_msg_parser = addr_msg_parser, 1040 .co_obj_ops = &addr_obj_ops, 1041}; 1042 1043static void __init addr_init(void) 1044{ 1045 nl_cache_mngt_register(&rtnl_addr_ops); 1046} 1047 1048static void __exit addr_exit(void) 1049{ 1050 nl_cache_mngt_unregister(&rtnl_addr_ops); 1051} 1052 1053/** @} */ 1054