1 /* 2 * lib/route/link/vxlan.c VXLAN Link Info 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) 2013 Yasunobu Chiba <yasu (at) dsl.gr.jp> 10 */ 11 12 /** 13 * @ingroup link 14 * @defgroup vxlan VXLAN 15 * Virtual eXtensible Local Area Network link module 16 * 17 * @details 18 * \b Link Type Name: "vxlan" 19 * 20 * @route_doc{link_vxlan, VXLAN Documentation} 21 * 22 * @{ 23 */ 24 25 #include <netlink-private/netlink.h> 26 #include <netlink/netlink.h> 27 #include <netlink/attr.h> 28 #include <netlink/utils.h> 29 #include <netlink/object.h> 30 #include <netlink/route/rtnl.h> 31 #include <netlink-private/route/link/api.h> 32 #include <netlink/route/link/vxlan.h> 33 34 #include <linux/if_link.h> 35 36 /** @cond SKIP */ 37 #define VXLAN_HAS_ID (1<<0) 38 #define VXLAN_HAS_GROUP (1<<1) 39 #define VXLAN_HAS_LINK (1<<2) 40 #define VXLAN_HAS_LOCAL (1<<3) 41 #define VXLAN_HAS_TTL (1<<4) 42 #define VXLAN_HAS_TOS (1<<5) 43 #define VXLAN_HAS_LEARNING (1<<6) 44 #define VXLAN_HAS_AGEING (1<<7) 45 #define VXLAN_HAS_LIMIT (1<<8) 46 #define VXLAN_HAS_PORT_RANGE (1<<9) 47 #define VXLAN_HAS_PROXY (1<<10) 48 #define VXLAN_HAS_RSC (1<<11) 49 #define VXLAN_HAS_L2MISS (1<<12) 50 #define VXLAN_HAS_L3MISS (1<<13) 51 52 struct vxlan_info 53 { 54 uint32_t vxi_id; 55 uint32_t vxi_group; 56 uint32_t vxi_link; 57 uint32_t vxi_local; 58 uint8_t vxi_ttl; 59 uint8_t vxi_tos; 60 uint8_t vxi_learning; 61 uint32_t vxi_ageing; 62 uint32_t vxi_limit; 63 struct ifla_vxlan_port_range vxi_port_range; 64 uint8_t vxi_proxy; 65 uint8_t vxi_rsc; 66 uint8_t vxi_l2miss; 67 uint8_t vxi_l3miss; 68 uint32_t vxi_mask; 69 }; 70 71 /** @endcond */ 72 73 static struct nla_policy vxlan_policy[IFLA_VXLAN_MAX+1] = { 74 [IFLA_VXLAN_ID] = { .type = NLA_U32 }, 75 [IFLA_VXLAN_GROUP] = { .minlen = sizeof(uint32_t) }, 76 [IFLA_VXLAN_LINK] = { .type = NLA_U32 }, 77 [IFLA_VXLAN_LOCAL] = { .minlen = sizeof(uint32_t) }, 78 [IFLA_VXLAN_TTL] = { .type = NLA_U8 }, 79 [IFLA_VXLAN_TOS] = { .type = NLA_U8 }, 80 [IFLA_VXLAN_LEARNING] = { .type = NLA_U8 }, 81 [IFLA_VXLAN_AGEING] = { .type = NLA_U32 }, 82 [IFLA_VXLAN_LIMIT] = { .type = NLA_U32 }, 83 [IFLA_VXLAN_PORT_RANGE] = { .minlen = sizeof(struct ifla_vxlan_port_range) }, 84 [IFLA_VXLAN_PROXY] = { .type = NLA_U8 }, 85 [IFLA_VXLAN_RSC] = { .type = NLA_U8 }, 86 [IFLA_VXLAN_L2MISS] = { .type = NLA_U8 }, 87 [IFLA_VXLAN_L3MISS] = { .type = NLA_U8 }, 88 }; 89 90 static int vxlan_alloc(struct rtnl_link *link) 91 { 92 struct vxlan_info *vxi; 93 94 if ((vxi = calloc(1, sizeof(*vxi))) == NULL) 95 return -NLE_NOMEM; 96 97 link->l_info = vxi; 98 99 return 0; 100 } 101 102 static int vxlan_parse(struct rtnl_link *link, struct nlattr *data, 103 struct nlattr *xstats) 104 { 105 struct nlattr *tb[IFLA_VXLAN_MAX+1]; 106 struct vxlan_info *vxi; 107 int err; 108 109 NL_DBG(3, "Parsing VXLAN link info"); 110 111 if ((err = nla_parse_nested(tb, IFLA_VXLAN_MAX, data, vxlan_policy)) < 0) 112 goto errout; 113 114 if ((err = vxlan_alloc(link)) < 0) 115 goto errout; 116 117 vxi = link->l_info; 118 119 if (tb[IFLA_VXLAN_ID]) { 120 vxi->vxi_id = nla_get_u32(tb[IFLA_VXLAN_ID]); 121 vxi->vxi_mask |= VXLAN_HAS_ID; 122 } 123 124 if (tb[IFLA_VXLAN_GROUP]) { 125 nla_memcpy(&vxi->vxi_group, tb[IFLA_VXLAN_GROUP], 126 sizeof(vxi->vxi_group)); 127 vxi->vxi_mask |= VXLAN_HAS_GROUP; 128 } 129 130 if (tb[IFLA_VXLAN_LINK]) { 131 vxi->vxi_link = nla_get_u32(tb[IFLA_VXLAN_LINK]); 132 vxi->vxi_mask |= VXLAN_HAS_LINK; 133 } 134 135 if (tb[IFLA_VXLAN_LOCAL]) { 136 nla_memcpy(&vxi->vxi_local, tb[IFLA_VXLAN_LOCAL], 137 sizeof(vxi->vxi_local)); 138 vxi->vxi_mask |= VXLAN_HAS_LOCAL; 139 } 140 141 if (tb[IFLA_VXLAN_TTL]) { 142 vxi->vxi_ttl = nla_get_u8(tb[IFLA_VXLAN_TTL]); 143 vxi->vxi_mask |= VXLAN_HAS_TTL; 144 } 145 146 if (tb[IFLA_VXLAN_TOS]) { 147 vxi->vxi_tos = nla_get_u8(tb[IFLA_VXLAN_TOS]); 148 vxi->vxi_mask |= VXLAN_HAS_TOS; 149 } 150 151 if (tb[IFLA_VXLAN_LEARNING]) { 152 vxi->vxi_learning = nla_get_u8(tb[IFLA_VXLAN_LEARNING]); 153 vxi->vxi_mask |= VXLAN_HAS_LEARNING; 154 } 155 156 if (tb[IFLA_VXLAN_AGEING]) { 157 vxi->vxi_ageing = nla_get_u32(tb[IFLA_VXLAN_AGEING]); 158 vxi->vxi_mask |= VXLAN_HAS_AGEING; 159 } 160 161 if (tb[IFLA_VXLAN_LIMIT]) { 162 vxi->vxi_limit = nla_get_u32(tb[IFLA_VXLAN_LIMIT]); 163 vxi->vxi_mask |= VXLAN_HAS_LIMIT; 164 } 165 166 if (tb[IFLA_VXLAN_PORT_RANGE]) { 167 nla_memcpy(&vxi->vxi_port_range, tb[IFLA_VXLAN_PORT_RANGE], 168 sizeof(vxi->vxi_port_range)); 169 vxi->vxi_mask |= VXLAN_HAS_PORT_RANGE; 170 } 171 172 if (tb[IFLA_VXLAN_PROXY]) { 173 vxi->vxi_proxy = nla_get_u8(tb[IFLA_VXLAN_PROXY]); 174 vxi->vxi_mask |= VXLAN_HAS_PROXY; 175 } 176 177 if (tb[IFLA_VXLAN_RSC]) { 178 vxi->vxi_rsc = nla_get_u8(tb[IFLA_VXLAN_RSC]); 179 vxi->vxi_mask |= VXLAN_HAS_RSC; 180 } 181 182 if (tb[IFLA_VXLAN_L2MISS]) { 183 vxi->vxi_l2miss = nla_get_u8(tb[IFLA_VXLAN_L2MISS]); 184 vxi->vxi_mask |= VXLAN_HAS_L2MISS; 185 } 186 187 if (tb[IFLA_VXLAN_L3MISS]) { 188 vxi->vxi_l3miss = nla_get_u8(tb[IFLA_VXLAN_L3MISS]); 189 vxi->vxi_mask |= VXLAN_HAS_L3MISS; 190 } 191 192 err = 0; 193 194 errout: 195 return err; 196 } 197 198 static void vxlan_free(struct rtnl_link *link) 199 { 200 struct vxlan_info *vxi = link->l_info; 201 202 free(vxi); 203 link->l_info = NULL; 204 } 205 206 static void vxlan_dump_line(struct rtnl_link *link, struct nl_dump_params *p) 207 { 208 struct vxlan_info *vxi = link->l_info; 209 210 nl_dump(p, "vxlan-id %u", vxi->vxi_id); 211 } 212 213 static void vxlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p) 214 { 215 struct vxlan_info *vxi = link->l_info; 216 char *name, addr[INET_ADDRSTRLEN]; 217 218 nl_dump_line(p, " vxlan-id %u\n", vxi->vxi_id); 219 220 if (vxi->vxi_mask & VXLAN_HAS_GROUP) { 221 nl_dump(p, " group "); 222 if(inet_ntop(AF_INET, &vxi->vxi_group, addr, sizeof(addr))) 223 nl_dump_line(p, "%s\n", addr); 224 else 225 nl_dump_line(p, "%#x\n", ntohs(vxi->vxi_group)); 226 } 227 228 if (vxi->vxi_mask & VXLAN_HAS_LINK) { 229 nl_dump(p, " link "); 230 name = rtnl_link_get_name(link); 231 if (name) 232 nl_dump_line(p, "%s\n", name); 233 else 234 nl_dump_line(p, "%u\n", vxi->vxi_link); 235 } 236 237 if (vxi->vxi_mask & VXLAN_HAS_LOCAL) { 238 nl_dump(p, " local "); 239 if(inet_ntop(AF_INET, &vxi->vxi_local, addr, sizeof(addr))) 240 nl_dump_line(p, "%s\n", addr); 241 else 242 nl_dump_line(p, "%#x\n", ntohs(vxi->vxi_local)); 243 } 244 245 if (vxi->vxi_mask & VXLAN_HAS_TTL) { 246 nl_dump(p, " ttl "); 247 if(vxi->vxi_ttl) 248 nl_dump_line(p, "%u\n", vxi->vxi_ttl); 249 else 250 nl_dump_line(p, "inherit\n"); 251 } 252 253 if (vxi->vxi_mask & VXLAN_HAS_TOS) { 254 nl_dump(p, " tos "); 255 if (vxi->vxi_tos == 1) 256 nl_dump_line(p, "inherit\n", vxi->vxi_tos); 257 else 258 nl_dump_line(p, "%#x\n", vxi->vxi_tos); 259 } 260 261 if (vxi->vxi_mask & VXLAN_HAS_LEARNING) { 262 nl_dump(p, " learning "); 263 if (vxi->vxi_learning) 264 nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_learning); 265 else 266 nl_dump_line(p, "disabled\n"); 267 } 268 269 if (vxi->vxi_mask & VXLAN_HAS_AGEING) { 270 nl_dump(p, " ageing "); 271 if (vxi->vxi_ageing) 272 nl_dump_line(p, "%u seconds\n", vxi->vxi_ageing); 273 else 274 nl_dump_line(p, "disabled\n"); 275 } 276 277 if (vxi->vxi_mask & VXLAN_HAS_LIMIT) { 278 nl_dump(p, " limit "); 279 if (vxi->vxi_limit) 280 nl_dump_line(p, "%u\n", vxi->vxi_limit); 281 else 282 nl_dump_line(p, "unlimited\n"); 283 } 284 285 if (vxi->vxi_mask & VXLAN_HAS_PORT_RANGE) 286 nl_dump_line(p, " port range %u - %u\n", 287 ntohs(vxi->vxi_port_range.low), 288 ntohs(vxi->vxi_port_range.high)); 289 290 if (vxi->vxi_mask & VXLAN_HAS_PROXY) { 291 nl_dump(p, " proxy "); 292 if (vxi->vxi_proxy) 293 nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_proxy); 294 else 295 nl_dump_line(p, "disabled\n"); 296 } 297 298 if (vxi->vxi_mask & VXLAN_HAS_RSC) { 299 nl_dump(p, " rsc "); 300 if (vxi->vxi_rsc) 301 nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_rsc); 302 else 303 nl_dump_line(p, "disabled\n"); 304 } 305 306 if (vxi->vxi_mask & VXLAN_HAS_L2MISS) { 307 nl_dump(p, " l2miss "); 308 if (vxi->vxi_l2miss) 309 nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_l2miss); 310 else 311 nl_dump_line(p, "disabled\n"); 312 } 313 314 if (vxi->vxi_mask & VXLAN_HAS_L3MISS) { 315 nl_dump(p, " l3miss "); 316 if (vxi->vxi_l3miss) 317 nl_dump_line(p, "enabled (%#x)\n", vxi->vxi_l3miss); 318 else 319 nl_dump_line(p, "disabled\n"); 320 } 321 } 322 323 static int vxlan_clone(struct rtnl_link *dst, struct rtnl_link *src) 324 { 325 struct vxlan_info *vdst, *vsrc = src->l_info; 326 int err; 327 328 dst->l_info = NULL; 329 if ((err = rtnl_link_set_type(dst, "vxlan")) < 0) 330 return err; 331 vdst = dst->l_info; 332 333 if (!vdst || !vsrc) 334 return -NLE_NOMEM; 335 336 memcpy(vdst, vsrc, sizeof(struct vxlan_info)); 337 338 return 0; 339 } 340 341 static int vxlan_put_attrs(struct nl_msg *msg, struct rtnl_link *link) 342 { 343 struct vxlan_info *vxi = link->l_info; 344 struct nlattr *data; 345 346 if (!(data = nla_nest_start(msg, IFLA_INFO_DATA))) 347 return -NLE_MSGSIZE; 348 349 if (vxi->vxi_mask & VXLAN_HAS_ID) 350 NLA_PUT_U32(msg, IFLA_VXLAN_ID, vxi->vxi_id); 351 352 if (vxi->vxi_mask & VXLAN_HAS_GROUP) 353 NLA_PUT(msg, IFLA_VXLAN_GROUP, sizeof(vxi->vxi_group), &vxi->vxi_group); 354 355 if (vxi->vxi_mask & VXLAN_HAS_LINK) 356 NLA_PUT_U32(msg, IFLA_VXLAN_LINK, vxi->vxi_link); 357 358 if (vxi->vxi_mask & VXLAN_HAS_LOCAL) 359 NLA_PUT(msg, IFLA_VXLAN_LOCAL, sizeof(vxi->vxi_local), &vxi->vxi_local); 360 361 if (vxi->vxi_mask & VXLAN_HAS_TTL) 362 NLA_PUT_U8(msg, IFLA_VXLAN_TTL, vxi->vxi_ttl); 363 364 if (vxi->vxi_mask & VXLAN_HAS_TOS) 365 NLA_PUT_U8(msg, IFLA_VXLAN_TOS, vxi->vxi_tos); 366 367 if (vxi->vxi_mask & VXLAN_HAS_LEARNING) 368 NLA_PUT_U8(msg, IFLA_VXLAN_LEARNING, vxi->vxi_learning); 369 370 if (vxi->vxi_mask & VXLAN_HAS_AGEING) 371 NLA_PUT_U32(msg, IFLA_VXLAN_AGEING, vxi->vxi_ageing); 372 373 if (vxi->vxi_mask & VXLAN_HAS_LIMIT) 374 NLA_PUT_U32(msg, IFLA_VXLAN_LIMIT, vxi->vxi_limit); 375 376 if (vxi->vxi_mask & VXLAN_HAS_PORT_RANGE) 377 NLA_PUT(msg, IFLA_VXLAN_PORT_RANGE, sizeof(vxi->vxi_port_range), 378 &vxi->vxi_port_range); 379 380 if (vxi->vxi_mask & VXLAN_HAS_PROXY) 381 NLA_PUT_U8(msg, IFLA_VXLAN_PROXY, vxi->vxi_proxy); 382 383 if (vxi->vxi_mask & VXLAN_HAS_RSC) 384 NLA_PUT_U8(msg, IFLA_VXLAN_RSC, vxi->vxi_rsc); 385 386 if (vxi->vxi_mask & VXLAN_HAS_L2MISS) 387 NLA_PUT_U8(msg, IFLA_VXLAN_L2MISS, vxi->vxi_l2miss); 388 389 if (vxi->vxi_mask & VXLAN_HAS_L3MISS) 390 NLA_PUT_U8(msg, IFLA_VXLAN_L3MISS, vxi->vxi_l3miss); 391 392 nla_nest_end(msg, data); 393 394 nla_put_failure: 395 396 return 0; 397 } 398 399 static struct rtnl_link_info_ops vxlan_info_ops = { 400 .io_name = "vxlan", 401 .io_alloc = vxlan_alloc, 402 .io_parse = vxlan_parse, 403 .io_dump = { 404 [NL_DUMP_LINE] = vxlan_dump_line, 405 [NL_DUMP_DETAILS] = vxlan_dump_details, 406 }, 407 .io_clone = vxlan_clone, 408 .io_put_attrs = vxlan_put_attrs, 409 .io_free = vxlan_free, 410 }; 411 412 /** @cond SKIP */ 413 #define IS_VXLAN_LINK_ASSERT(link) \ 414 if ((link)->l_info_ops != &vxlan_info_ops) { \ 415 APPBUG("Link is not a vxlan link. set type \"vxlan\" first."); \ 416 return -NLE_OPNOTSUPP; \ 417 } 418 /** @endcond */ 419 420 /** 421 * @name VXLAN Object 422 * @{ 423 */ 424 425 /** 426 * Allocate link object of type VXLAN 427 * 428 * @return Allocated link object or NULL. 429 */ 430 struct rtnl_link *rtnl_link_vxlan_alloc(void) 431 { 432 struct rtnl_link *link; 433 int err; 434 435 if (!(link = rtnl_link_alloc())) 436 return NULL; 437 438 if ((err = rtnl_link_set_type(link, "vxlan")) < 0) { 439 rtnl_link_put(link); 440 return NULL; 441 } 442 443 return link; 444 } 445 446 /** 447 * Check if link is a VXLAN link 448 * @arg link Link object 449 * 450 * @return True if link is a VXLAN link, otherwise false is returned. 451 */ 452 int rtnl_link_is_vxlan(struct rtnl_link *link) 453 { 454 return link->l_info_ops && !strcmp(link->l_info_ops->io_name, "vxlan"); 455 } 456 457 /** 458 * Set VXLAN Network Identifier 459 * @arg link Link object 460 * @arg id VXLAN network identifier (or VXLAN segment identifier) 461 * 462 * @return 0 on success or a negative error code 463 */ 464 int rtnl_link_vxlan_set_id(struct rtnl_link *link, uint32_t id) 465 { 466 struct vxlan_info *vxi = link->l_info; 467 468 IS_VXLAN_LINK_ASSERT(link); 469 470 if (id > VXLAN_ID_MAX) 471 return -NLE_INVAL; 472 473 vxi->vxi_id = id; 474 vxi->vxi_mask |= VXLAN_HAS_ID; 475 476 return 0; 477 } 478 479 /** 480 * Get VXLAN Network Identifier 481 * @arg link Link object 482 * @arg id Pointer to store network identifier 483 * 484 * @return 0 on success or a negative error code 485 */ 486 int rtnl_link_vxlan_get_id(struct rtnl_link *link, uint32_t *id) 487 { 488 struct vxlan_info *vxi = link->l_info; 489 490 IS_VXLAN_LINK_ASSERT(link); 491 492 if(!id) 493 return -NLE_INVAL; 494 495 if (vxi->vxi_mask & VXLAN_HAS_ID) 496 *id = vxi->vxi_id; 497 else 498 return -NLE_AGAIN; 499 500 return 0; 501 } 502 503 /** 504 * Set VXLAN multicast IP address 505 * @arg link Link object 506 * @arg addr Multicast IP address to join 507 * 508 * @return 0 on success or a negative error code 509 */ 510 int rtnl_link_vxlan_set_group(struct rtnl_link *link, struct nl_addr *addr) 511 { 512 struct vxlan_info *vxi = link->l_info; 513 514 IS_VXLAN_LINK_ASSERT(link); 515 516 if ((nl_addr_get_family(addr) != AF_INET) || 517 (nl_addr_get_len(addr) != sizeof(vxi->vxi_group))) 518 return -NLE_INVAL; 519 520 memcpy(&vxi->vxi_group, nl_addr_get_binary_addr(addr), 521 sizeof(vxi->vxi_group)); 522 vxi->vxi_mask |= VXLAN_HAS_GROUP; 523 524 return 0; 525 } 526 527 /** 528 * Get VXLAN multicast IP address 529 * @arg link Link object 530 * @arg addr Pointer to store multicast IP address 531 * 532 * @return 0 on success or a negative error code 533 */ 534 int rtnl_link_vxlan_get_group(struct rtnl_link *link, struct nl_addr **addr) 535 { 536 struct vxlan_info *vxi = link->l_info; 537 538 IS_VXLAN_LINK_ASSERT(link); 539 540 if (!addr) 541 return -NLE_INVAL; 542 543 if (!(vxi->vxi_mask & VXLAN_HAS_GROUP)) 544 return -NLE_AGAIN; 545 546 *addr = nl_addr_build(AF_INET, &vxi->vxi_group, sizeof(vxi->vxi_group)); 547 548 return 0; 549 } 550 551 /** 552 * Set physical device to use for VXLAN 553 * @arg link Link object 554 * @arg index Interface index 555 * 556 * @return 0 on success or a negative error code 557 */ 558 int rtnl_link_vxlan_set_link(struct rtnl_link *link, uint32_t index) 559 { 560 struct vxlan_info *vxi = link->l_info; 561 562 IS_VXLAN_LINK_ASSERT(link); 563 564 vxi->vxi_link = index; 565 vxi->vxi_mask |= VXLAN_HAS_LINK; 566 567 return 0; 568 } 569 570 /** 571 * Get physical device to use for VXLAN 572 * @arg link Link object 573 * @arg index Pointer to store interface index 574 * 575 * @return 0 on success or a negative error code 576 */ 577 int rtnl_link_vxlan_get_link(struct rtnl_link *link, uint32_t *index) 578 { 579 struct vxlan_info *vxi = link->l_info; 580 581 IS_VXLAN_LINK_ASSERT(link); 582 583 if (!index) 584 return -NLE_INVAL; 585 586 if (!(vxi->vxi_mask & VXLAN_HAS_LINK)) 587 return -NLE_AGAIN; 588 589 *index = vxi->vxi_link; 590 591 return 0; 592 } 593 594 /** 595 * Set source address to use for VXLAN 596 * @arg link Link object 597 * @arg addr Local address 598 * 599 * @return 0 on success or a negative error code 600 */ 601 int rtnl_link_vxlan_set_local(struct rtnl_link *link, struct nl_addr *addr) 602 { 603 struct vxlan_info *vxi = link->l_info; 604 605 IS_VXLAN_LINK_ASSERT(link); 606 607 if ((nl_addr_get_family(addr) != AF_INET) || 608 (nl_addr_get_len(addr) != sizeof(vxi->vxi_local))) 609 return -NLE_INVAL; 610 611 memcpy(&vxi->vxi_local, nl_addr_get_binary_addr(addr), 612 sizeof(vxi->vxi_local)); 613 vxi->vxi_mask |= VXLAN_HAS_LOCAL; 614 615 return 0; 616 } 617 618 /** 619 * Get source address to use for VXLAN 620 * @arg link Link object 621 * @arg addr Pointer to store local address 622 * 623 * @return 0 on success or a negative error code 624 */ 625 int rtnl_link_vxlan_get_local(struct rtnl_link *link, struct nl_addr **addr) 626 { 627 struct vxlan_info *vxi = link->l_info; 628 629 IS_VXLAN_LINK_ASSERT(link); 630 631 if (!addr) 632 return -NLE_INVAL; 633 634 if (!(vxi->vxi_mask & VXLAN_HAS_LOCAL)) 635 return -NLE_AGAIN; 636 637 *addr = nl_addr_build(AF_INET, &vxi->vxi_local, sizeof(vxi->vxi_local)); 638 639 return 0; 640 } 641 642 /** 643 * Set IP TTL value to use for VXLAN 644 * @arg link Link object 645 * @arg ttl TTL value 646 * 647 * @return 0 on success or a negative error code 648 */ 649 int rtnl_link_vxlan_set_ttl(struct rtnl_link *link, uint8_t ttl) 650 { 651 struct vxlan_info *vxi = link->l_info; 652 653 IS_VXLAN_LINK_ASSERT(link); 654 655 vxi->vxi_ttl = ttl; 656 vxi->vxi_mask |= VXLAN_HAS_TTL; 657 658 return 0; 659 } 660 661 /** 662 * Get IP TTL value to use for VXLAN 663 * @arg link Link object 664 * 665 * @return TTL value on success or a negative error code 666 */ 667 int rtnl_link_vxlan_get_ttl(struct rtnl_link *link) 668 { 669 struct vxlan_info *vxi = link->l_info; 670 671 IS_VXLAN_LINK_ASSERT(link); 672 673 if (!(vxi->vxi_mask & VXLAN_HAS_TTL)) 674 return -NLE_AGAIN; 675 676 return vxi->vxi_ttl; 677 } 678 679 /** 680 * Set IP ToS value to use for VXLAN 681 * @arg link Link object 682 * @arg tos ToS value 683 * 684 * @return 0 on success or a negative error code 685 */ 686 int rtnl_link_vxlan_set_tos(struct rtnl_link *link, uint8_t tos) 687 { 688 struct vxlan_info *vxi = link->l_info; 689 690 IS_VXLAN_LINK_ASSERT(link); 691 692 vxi->vxi_tos = tos; 693 vxi->vxi_mask |= VXLAN_HAS_TOS; 694 695 return 0; 696 } 697 698 /** 699 * Get IP ToS value to use for VXLAN 700 * @arg link Link object 701 * 702 * @return ToS value on success or a negative error code 703 */ 704 int rtnl_link_vxlan_get_tos(struct rtnl_link *link) 705 { 706 struct vxlan_info *vxi = link->l_info; 707 708 IS_VXLAN_LINK_ASSERT(link); 709 710 if (!(vxi->vxi_mask & VXLAN_HAS_TOS)) 711 return -NLE_AGAIN; 712 713 return vxi->vxi_tos; 714 } 715 716 /** 717 * Set VXLAN learning status 718 * @arg link Link object 719 * @arg learning Learning status value 720 * 721 * @return 0 on success or a negative error code 722 */ 723 int rtnl_link_vxlan_set_learning(struct rtnl_link *link, uint8_t learning) 724 { 725 struct vxlan_info *vxi = link->l_info; 726 727 IS_VXLAN_LINK_ASSERT(link); 728 729 vxi->vxi_learning = learning; 730 vxi->vxi_mask |= VXLAN_HAS_LEARNING; 731 732 return 0; 733 } 734 735 /** 736 * Get VXLAN learning status 737 * @arg link Link object 738 * 739 * @return Learning status value on success or a negative error code 740 */ 741 int rtnl_link_vxlan_get_learning(struct rtnl_link *link) 742 { 743 struct vxlan_info *vxi = link->l_info; 744 745 IS_VXLAN_LINK_ASSERT(link); 746 747 if (!(vxi->vxi_mask & VXLAN_HAS_LEARNING)) 748 return -NLE_AGAIN; 749 750 return vxi->vxi_learning; 751 } 752 753 /** 754 * Enable VXLAN address learning 755 * @arg link Link object 756 * 757 * @return 0 on success or a negative error code 758 */ 759 int rtnl_link_vxlan_enable_learning(struct rtnl_link *link) 760 { 761 return rtnl_link_vxlan_set_learning(link, 1); 762 } 763 764 /** 765 * Disable VXLAN address learning 766 * @arg link Link object 767 * 768 * @return 0 on success or a negative error code 769 */ 770 int rtnl_link_vxlan_disable_learning(struct rtnl_link *link) 771 { 772 return rtnl_link_vxlan_set_learning(link, 0); 773 } 774 775 /** 776 * Set expiration timer value to use for VXLAN 777 * @arg link Link object 778 * @arg expiry Expiration timer value 779 * 780 * @return 0 on success or a negative error code 781 */ 782 int rtnl_link_vxlan_set_ageing(struct rtnl_link *link, uint32_t expiry) 783 { 784 struct vxlan_info *vxi = link->l_info; 785 786 IS_VXLAN_LINK_ASSERT(link); 787 788 vxi->vxi_ageing = expiry; 789 vxi->vxi_mask |= VXLAN_HAS_AGEING; 790 791 return 0; 792 } 793 794 /** 795 * Get expiration timer value to use for VXLAN 796 * @arg link Link object 797 * @arg expiry Pointer to store expiration timer value 798 * 799 * @return 0 on success or a negative error code 800 */ 801 int rtnl_link_vxlan_get_ageing(struct rtnl_link *link, uint32_t *expiry) 802 { 803 struct vxlan_info *vxi = link->l_info; 804 805 IS_VXLAN_LINK_ASSERT(link); 806 807 if (!expiry) 808 return -NLE_INVAL; 809 810 if (vxi->vxi_mask & VXLAN_HAS_AGEING) 811 *expiry = vxi->vxi_ageing; 812 else 813 return -NLE_AGAIN; 814 815 return 0; 816 } 817 818 /** 819 * Set maximum number of forwarding database entries to use for VXLAN 820 * @arg link Link object 821 * @arg limit Maximum number 822 * 823 * @return 0 on success or a negative error code 824 */ 825 int rtnl_link_vxlan_set_limit(struct rtnl_link *link, uint32_t limit) 826 { 827 struct vxlan_info *vxi = link->l_info; 828 829 IS_VXLAN_LINK_ASSERT(link); 830 831 vxi->vxi_limit = limit; 832 vxi->vxi_mask |= VXLAN_HAS_LIMIT; 833 834 return 0; 835 } 836 837 /** 838 * Get maximum number of forwarding database entries to use for VXLAN 839 * @arg link Link object 840 * @arg limit Pointer to store maximum number 841 * 842 * @return 0 on success or a negative error code 843 */ 844 int rtnl_link_vxlan_get_limit(struct rtnl_link *link, uint32_t *limit) 845 { 846 struct vxlan_info *vxi = link->l_info; 847 848 IS_VXLAN_LINK_ASSERT(link); 849 850 if (!limit) 851 return -NLE_INVAL; 852 853 if (vxi->vxi_mask & VXLAN_HAS_LIMIT) 854 *limit = vxi->vxi_limit; 855 else 856 return -NLE_AGAIN; 857 858 return 0; 859 } 860 861 /** 862 * Set range of UDP port numbers to use for VXLAN 863 * @arg link Link object 864 * @arg range Port number range 865 * 866 * @return 0 on success or a negative error code 867 */ 868 int rtnl_link_vxlan_set_port_range(struct rtnl_link *link, 869 struct ifla_vxlan_port_range *range) 870 { 871 struct vxlan_info *vxi = link->l_info; 872 873 IS_VXLAN_LINK_ASSERT(link); 874 875 if (!range) 876 return -NLE_INVAL; 877 878 memcpy(&vxi->vxi_port_range, range, sizeof(vxi->vxi_port_range)); 879 vxi->vxi_mask |= VXLAN_HAS_PORT_RANGE; 880 881 return 0; 882 } 883 884 /** 885 * Get range of UDP port numbers to use for VXLAN 886 * @arg link Link object 887 * @arg range Pointer to store port range 888 * 889 * @return 0 on success or a negative error code 890 */ 891 int rtnl_link_vxlan_get_port_range(struct rtnl_link *link, 892 struct ifla_vxlan_port_range *range) 893 { 894 struct vxlan_info *vxi = link->l_info; 895 896 IS_VXLAN_LINK_ASSERT(link); 897 898 if (!range) 899 return -NLE_INVAL; 900 901 if (vxi->vxi_mask & VXLAN_HAS_PORT_RANGE) 902 memcpy(range, &vxi->vxi_port_range, sizeof(*range)); 903 else 904 return -NLE_AGAIN; 905 906 return 0; 907 } 908 909 /** 910 * Set ARP proxy status to use for VXLAN 911 * @arg link Link object 912 * @arg proxy Status value 913 * 914 * @return 0 on success or a negative error code 915 */ 916 int rtnl_link_vxlan_set_proxy(struct rtnl_link *link, uint8_t proxy) 917 { 918 struct vxlan_info *vxi = link->l_info; 919 920 IS_VXLAN_LINK_ASSERT(link); 921 922 vxi->vxi_proxy = proxy; 923 vxi->vxi_mask |= VXLAN_HAS_PROXY; 924 925 return 0; 926 } 927 928 /** 929 * Get ARP proxy status to use for VXLAN 930 * @arg link Link object 931 * 932 * @return Status value on success or a negative error code 933 */ 934 int rtnl_link_vxlan_get_proxy(struct rtnl_link *link) 935 { 936 struct vxlan_info *vxi = link->l_info; 937 938 IS_VXLAN_LINK_ASSERT(link); 939 940 if (!(vxi->vxi_mask & VXLAN_HAS_PROXY)) 941 return -NLE_AGAIN; 942 943 return vxi->vxi_proxy; 944 } 945 946 /** 947 * Enable ARP proxy 948 * @arg link Link object 949 * 950 * @return 0 on success or a negative error code 951 */ 952 int rtnl_link_vxlan_enable_proxy(struct rtnl_link *link) 953 { 954 return rtnl_link_vxlan_set_proxy(link, 1); 955 } 956 957 /** 958 * Disable ARP proxy 959 * @arg link Link object 960 * 961 * @return 0 on success or a negative error code 962 */ 963 int rtnl_link_vxlan_disable_proxy(struct rtnl_link *link) 964 { 965 return rtnl_link_vxlan_set_proxy(link, 0); 966 } 967 968 /** 969 * Set Route Short Circuit status to use for VXLAN 970 * @arg link Link object 971 * @arg rsc Status value 972 * 973 * @return 0 on success or a negative error code 974 */ 975 int rtnl_link_vxlan_set_rsc(struct rtnl_link *link, uint8_t rsc) 976 { 977 struct vxlan_info *vxi = link->l_info; 978 979 IS_VXLAN_LINK_ASSERT(link); 980 981 vxi->vxi_rsc = rsc; 982 vxi->vxi_mask |= VXLAN_HAS_RSC; 983 984 return 0; 985 } 986 987 /** 988 * Get Route Short Circuit status to use for VXLAN 989 * @arg link Link object 990 * 991 * @return Status value on success or a negative error code 992 */ 993 int rtnl_link_vxlan_get_rsc(struct rtnl_link *link) 994 { 995 struct vxlan_info *vxi = link->l_info; 996 997 IS_VXLAN_LINK_ASSERT(link); 998 999 if (!(vxi->vxi_mask & VXLAN_HAS_RSC)) 1000 return -NLE_AGAIN; 1001 1002 return vxi->vxi_rsc; 1003 } 1004 1005 /** 1006 * Enable Route Short Circuit 1007 * @arg link Link object 1008 * 1009 * @return 0 on success or a negative error code 1010 */ 1011 int rtnl_link_vxlan_enable_rsc(struct rtnl_link *link) 1012 { 1013 return rtnl_link_vxlan_set_rsc(link, 1); 1014 } 1015 1016 /** 1017 * Disable Route Short Circuit 1018 * @arg link Link object 1019 * 1020 * @return 0 on success or a negative error code 1021 */ 1022 int rtnl_link_vxlan_disable_rsc(struct rtnl_link *link) 1023 { 1024 return rtnl_link_vxlan_set_rsc(link, 0); 1025 } 1026 1027 /** 1028 * Set netlink LLADDR miss notification status to use for VXLAN 1029 * @arg link Link object 1030 * @arg miss Status value 1031 * 1032 * @return 0 on success or a negative error code 1033 */ 1034 int rtnl_link_vxlan_set_l2miss(struct rtnl_link *link, uint8_t miss) 1035 { 1036 struct vxlan_info *vxi = link->l_info; 1037 1038 IS_VXLAN_LINK_ASSERT(link); 1039 1040 vxi->vxi_l2miss = miss; 1041 vxi->vxi_mask |= VXLAN_HAS_L2MISS; 1042 1043 return 0; 1044 } 1045 1046 /** 1047 * Get netlink LLADDR miss notification status to use for VXLAN 1048 * @arg link Link object 1049 * 1050 * @return Status value on success or a negative error code 1051 */ 1052 int rtnl_link_vxlan_get_l2miss(struct rtnl_link *link) 1053 { 1054 struct vxlan_info *vxi = link->l_info; 1055 1056 IS_VXLAN_LINK_ASSERT(link); 1057 1058 if (!(vxi->vxi_mask & VXLAN_HAS_L2MISS)) 1059 return -NLE_AGAIN; 1060 1061 return vxi->vxi_l2miss; 1062 } 1063 1064 /** 1065 * Enable netlink LLADDR miss notifications 1066 * @arg link Link object 1067 * 1068 * @return 0 on success or a negative error code 1069 */ 1070 int rtnl_link_vxlan_enable_l2miss(struct rtnl_link *link) 1071 { 1072 return rtnl_link_vxlan_set_l2miss(link, 1); 1073 } 1074 1075 /** 1076 * Disable netlink LLADDR miss notifications 1077 * @arg link Link object 1078 * 1079 * @return 0 on success or a negative error code 1080 */ 1081 int rtnl_link_vxlan_disable_l2miss(struct rtnl_link *link) 1082 { 1083 return rtnl_link_vxlan_set_l2miss(link, 0); 1084 } 1085 1086 /** 1087 * Set netlink IP ADDR miss notification status to use for VXLAN 1088 * @arg link Link object 1089 * @arg miss Status value 1090 * 1091 * @return 0 on success or a negative error code 1092 */ 1093 int rtnl_link_vxlan_set_l3miss(struct rtnl_link *link, uint8_t miss) 1094 { 1095 struct vxlan_info *vxi = link->l_info; 1096 1097 IS_VXLAN_LINK_ASSERT(link); 1098 1099 vxi->vxi_l3miss = miss; 1100 vxi->vxi_mask |= VXLAN_HAS_L3MISS; 1101 1102 return 0; 1103 } 1104 1105 /** 1106 * Get netlink IP ADDR miss notification status to use for VXLAN 1107 * @arg link Link object 1108 * 1109 * @return Status value on success or a negative error code 1110 */ 1111 int rtnl_link_vxlan_get_l3miss(struct rtnl_link *link) 1112 { 1113 struct vxlan_info *vxi = link->l_info; 1114 1115 IS_VXLAN_LINK_ASSERT(link); 1116 1117 if (!(vxi->vxi_mask & VXLAN_HAS_L3MISS)) 1118 return -NLE_AGAIN; 1119 1120 return vxi->vxi_l3miss; 1121 } 1122 1123 /** 1124 * Enable netlink IP DDR miss notifications 1125 * @arg link Link object 1126 * 1127 * @return 0 on success or a negative error code 1128 */ 1129 int rtnl_link_vxlan_enable_l3miss(struct rtnl_link *link) 1130 { 1131 return rtnl_link_vxlan_set_l3miss(link, 1); 1132 } 1133 1134 /** 1135 * Disable netlink IP ADDR miss notifications 1136 * @arg link Link object 1137 * 1138 * @return 0 on success or a negative error code 1139 */ 1140 int rtnl_link_vxlan_disable_l3miss(struct rtnl_link *link) 1141 { 1142 return rtnl_link_vxlan_set_l3miss(link, 0); 1143 } 1144 1145 /** @} */ 1146 1147 static void __init vxlan_init(void) 1148 { 1149 rtnl_link_register_info(&vxlan_info_ops); 1150 } 1151 1152 static void __exit vxlan_exit(void) 1153 { 1154 rtnl_link_unregister_info(&vxlan_info_ops); 1155 } 1156 1157 /** @} */ 1158
