1/* 2 * lib/route/neightbl.c neighbour tables 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 */ 11 12/** 13 * @ingroup rtnl 14 * @defgroup neightbl Neighbour Tables 15 * @brief 16 * @{ 17 */ 18 19#include <netlink-private/netlink.h> 20#include <netlink/netlink.h> 21#include <netlink/utils.h> 22#include <netlink/route/rtnl.h> 23#include <netlink/route/neightbl.h> 24#include <netlink/route/link.h> 25 26/** @cond SKIP */ 27#define NEIGHTBL_ATTR_FAMILY 0x001 28#define NEIGHTBL_ATTR_STATS 0x002 29#define NEIGHTBL_ATTR_NAME 0x004 30#define NEIGHTBL_ATTR_THRESH1 0x008 31#define NEIGHTBL_ATTR_THRESH2 0x010 32#define NEIGHTBL_ATTR_THRESH3 0x020 33#define NEIGHTBL_ATTR_CONFIG 0x040 34#define NEIGHTBL_ATTR_PARMS 0x080 35#define NEIGHTBL_ATTR_GC_INTERVAL 0x100 36 37#define NEIGHTBLPARM_ATTR_IFINDEX 0x0001 38#define NEIGHTBLPARM_ATTR_REFCNT 0x0002 39#define NEIGHTBLPARM_ATTR_QUEUE_LEN 0x0004 40#define NEIGHTBLPARM_ATTR_APP_PROBES 0x0008 41#define NEIGHTBLPARM_ATTR_UCAST_PROBES 0x0010 42#define NEIGHTBLPARM_ATTR_MCAST_PROBES 0x0020 43#define NEIGHTBLPARM_ATTR_PROXY_QLEN 0x0040 44#define NEIGHTBLPARM_ATTR_REACHABLE_TIME 0x0080 45#define NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME 0x0100 46#define NEIGHTBLPARM_ATTR_RETRANS_TIME 0x0200 47#define NEIGHTBLPARM_ATTR_GC_STALETIME 0x0400 48#define NEIGHTBLPARM_ATTR_DELAY_PROBE_TIME 0x0800 49#define NEIGHTBLPARM_ATTR_ANYCAST_DELAY 0x1000 50#define NEIGHTBLPARM_ATTR_PROXY_DELAY 0x2000 51#define NEIGHTBLPARM_ATTR_LOCKTIME 0x4000 52 53static struct nl_cache_ops rtnl_neightbl_ops; 54static struct nl_object_ops neightbl_obj_ops; 55/** @endcond */ 56 57static int neightbl_compare(struct nl_object *_a, struct nl_object *_b, 58 uint32_t attrs, int flags) 59{ 60 struct rtnl_neightbl *a = (struct rtnl_neightbl *) _a; 61 struct rtnl_neightbl *b = (struct rtnl_neightbl *) _b; 62 int diff = 0; 63 64#define NT_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NEIGHTBL_ATTR_##ATTR, a, b, EXPR) 65 66 diff |= NT_DIFF(FAMILY, a->nt_family != b->nt_family); 67 diff |= NT_DIFF(NAME, strcmp(a->nt_name, b->nt_name)); 68 diff |= NT_DIFF(THRESH1, a->nt_gc_thresh1 != b->nt_gc_thresh1); 69 diff |= NT_DIFF(THRESH2, a->nt_gc_thresh2 != b->nt_gc_thresh2); 70 diff |= NT_DIFF(THRESH3, a->nt_gc_thresh3 != b->nt_gc_thresh3); 71 diff |= NT_DIFF(GC_INTERVAL, a->nt_gc_interval != b->nt_gc_interval); 72 73#undef NT_DIFF 74 75 if (!(a->ce_mask & NEIGHTBL_ATTR_PARMS) && 76 !(b->ce_mask & NEIGHTBL_ATTR_PARMS)) 77 return diff; 78 79 /* XXX: FIXME: Compare parameter table */ 80 81 82#if 0 83#define REQ(F) (fp->ntp_mask & NEIGHTBLPARM_ATTR_##F) 84#define AVAIL(F) (op->ntp_mask & NEIGHTBLPARM_ATTR_##F) 85#define _C(F, N) (REQ(F) && (!AVAIL(F) || (op->N != fp->N))) 86 if (_C(IFINDEX, ntp_ifindex) || 87 _C(QUEUE_LEN, ntp_queue_len) || 88 _C(APP_PROBES, ntp_app_probes) || 89 _C(UCAST_PROBES, ntp_ucast_probes) || 90 _C(MCAST_PROBES, ntp_mcast_probes) || 91 _C(PROXY_QLEN, ntp_proxy_qlen) || 92 _C(LOCKTIME, ntp_locktime) || 93 _C(RETRANS_TIME, ntp_retrans_time) || 94 _C(BASE_REACHABLE_TIME, ntp_base_reachable_time) || 95 _C(GC_STALETIME, ntp_gc_stale_time) || 96 _C(DELAY_PROBE_TIME, ntp_probe_delay) || 97 _C(ANYCAST_DELAY, ntp_anycast_delay) || 98 _C(PROXY_DELAY, ntp_proxy_delay)) 99 return 0; 100#undef REQ 101#undef AVAIL 102#undef _C 103#endif 104 105 return diff; 106} 107 108 109static struct nla_policy neightbl_policy[NDTA_MAX+1] = { 110 [NDTA_NAME] = { .type = NLA_STRING, 111 .maxlen = NTBLNAMSIZ }, 112 [NDTA_THRESH1] = { .type = NLA_U32 }, 113 [NDTA_THRESH2] = { .type = NLA_U32 }, 114 [NDTA_THRESH3] = { .type = NLA_U32 }, 115 [NDTA_GC_INTERVAL] = { .type = NLA_U32 }, 116 [NDTA_CONFIG] = { .minlen = sizeof(struct ndt_config) }, 117 [NDTA_STATS] = { .minlen = sizeof(struct ndt_stats) }, 118 [NDTA_PARMS] = { .type = NLA_NESTED }, 119}; 120 121static int neightbl_msg_parser(struct nl_cache_ops *ops, 122 struct sockaddr_nl *who, struct nlmsghdr *n, 123 struct nl_parser_param *pp) 124{ 125 struct rtnl_neightbl *ntbl; 126 struct nlattr *tb[NDTA_MAX + 1]; 127 struct rtgenmsg *rtmsg; 128 int err; 129 130 ntbl = rtnl_neightbl_alloc(); 131 if (!ntbl) { 132 err = -NLE_NOMEM; 133 goto errout; 134 } 135 136 ntbl->ce_msgtype = n->nlmsg_type; 137 rtmsg = nlmsg_data(n); 138 139 err = nlmsg_parse(n, sizeof(*rtmsg), tb, NDTA_MAX, neightbl_policy); 140 if (err < 0) 141 goto errout; 142 143 ntbl->nt_family = rtmsg->rtgen_family; 144 145 if (tb[NDTA_NAME] == NULL) { 146 err = -NLE_MISSING_ATTR; 147 goto errout; 148 } 149 150 nla_strlcpy(ntbl->nt_name, tb[NDTA_NAME], NTBLNAMSIZ); 151 ntbl->ce_mask |= NEIGHTBL_ATTR_NAME; 152 153 if (tb[NDTA_THRESH1]) { 154 ntbl->nt_gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]); 155 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH1; 156 } 157 158 if (tb[NDTA_THRESH2]) { 159 ntbl->nt_gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]); 160 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH2; 161 } 162 163 if (tb[NDTA_THRESH3]) { 164 ntbl->nt_gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]); 165 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH3; 166 } 167 168 if (tb[NDTA_GC_INTERVAL]) { 169 ntbl->nt_gc_interval = nla_get_u32(tb[NDTA_GC_INTERVAL]); 170 ntbl->ce_mask |= NEIGHTBL_ATTR_GC_INTERVAL; 171 } 172 173 if (tb[NDTA_CONFIG]) { 174 nla_memcpy(&ntbl->nt_config, tb[NDTA_CONFIG], 175 sizeof(ntbl->nt_config)); 176 ntbl->ce_mask |= NEIGHTBL_ATTR_CONFIG; 177 } 178 179 if (tb[NDTA_STATS]) { 180 nla_memcpy(&ntbl->nt_stats, tb[NDTA_STATS], 181 sizeof(ntbl->nt_stats)); 182 ntbl->ce_mask |= NEIGHTBL_ATTR_STATS; 183 } 184 185 if (tb[NDTA_PARMS]) { 186 struct nlattr *tbp[NDTPA_MAX + 1]; 187 struct rtnl_neightbl_parms *p = &ntbl->nt_parms; 188 189 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS], NULL); 190 if (err < 0) 191 goto errout; 192 193#define COPY_ENTRY(name, var) \ 194 if (tbp[NDTPA_ ##name]) { \ 195 p->ntp_ ##var = nla_get_u32(tbp[NDTPA_ ##name]); \ 196 p->ntp_mask |= NEIGHTBLPARM_ATTR_ ##name; \ 197 } 198 199 COPY_ENTRY(IFINDEX, ifindex); 200 COPY_ENTRY(REFCNT, refcnt); 201 COPY_ENTRY(QUEUE_LEN, queue_len); 202 COPY_ENTRY(APP_PROBES, app_probes); 203 COPY_ENTRY(UCAST_PROBES, ucast_probes); 204 COPY_ENTRY(MCAST_PROBES, mcast_probes); 205 COPY_ENTRY(PROXY_QLEN, proxy_qlen); 206 COPY_ENTRY(PROXY_DELAY, proxy_delay); 207 COPY_ENTRY(ANYCAST_DELAY, anycast_delay); 208 COPY_ENTRY(LOCKTIME, locktime); 209 COPY_ENTRY(REACHABLE_TIME, reachable_time); 210 COPY_ENTRY(BASE_REACHABLE_TIME, base_reachable_time); 211 COPY_ENTRY(RETRANS_TIME, retrans_time); 212 COPY_ENTRY(GC_STALETIME, gc_stale_time); 213 COPY_ENTRY(DELAY_PROBE_TIME, probe_delay); 214#undef COPY_ENTRY 215 216 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 217 } 218 219 err = pp->pp_cb((struct nl_object *) ntbl, pp); 220errout: 221 rtnl_neightbl_put(ntbl); 222 return err; 223} 224 225static int neightbl_request_update(struct nl_cache *c, struct nl_sock *h) 226{ 227 return nl_rtgen_request(h, RTM_GETNEIGHTBL, AF_UNSPEC, NLM_F_DUMP); 228} 229 230 231static void neightbl_dump_line(struct nl_object *arg, struct nl_dump_params *p) 232{ 233 struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg; 234 235 nl_dump_line(p, "%s", ntbl->nt_name); 236 237 if (ntbl->nt_parms.ntp_mask & NEIGHTBLPARM_ATTR_IFINDEX) { 238 struct nl_cache *link_cache; 239 240 link_cache = nl_cache_mngt_require_safe("route/link"); 241 242 if (link_cache) { 243 char buf[32]; 244 nl_dump(p, "<%s> ", 245 rtnl_link_i2name(link_cache, 246 ntbl->nt_parms.ntp_ifindex, 247 buf, sizeof(buf))); 248 nl_cache_put(link_cache); 249 } else 250 nl_dump(p, "<%u> ", ntbl->nt_parms.ntp_ifindex); 251 } else 252 nl_dump(p, " "); 253 254 if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG) 255 nl_dump(p, "entries %u ", ntbl->nt_config.ndtc_entries); 256 257 if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) { 258 char rt[32], rt2[32]; 259 struct rtnl_neightbl_parms *pa = &ntbl->nt_parms; 260 261 nl_dump(p, "reachable-time %s retransmit-time %s", 262 nl_msec2str(pa->ntp_reachable_time, rt, sizeof(rt)), 263 nl_msec2str(pa->ntp_retrans_time, rt2, sizeof(rt2))); 264 } 265 266 nl_dump(p, "\n"); 267} 268 269static void neightbl_dump_details(struct nl_object *arg, struct nl_dump_params *p) 270{ 271 char x[32], y[32], z[32]; 272 struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg; 273 274 neightbl_dump_line(arg, p); 275 276 if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG) { 277 nl_dump_line(p, " key-len %u entry-size %u last-flush %s\n", 278 ntbl->nt_config.ndtc_key_len, 279 ntbl->nt_config.ndtc_entry_size, 280 nl_msec2str(ntbl->nt_config.ndtc_last_flush, 281 x, sizeof(x))); 282 283 nl_dump_line(p, " gc threshold %u/%u/%u interval %s " \ 284 "chain-position %u\n", 285 ntbl->nt_gc_thresh1, ntbl->nt_gc_thresh2, 286 ntbl->nt_gc_thresh3, 287 nl_msec2str(ntbl->nt_gc_interval, x, sizeof(x)), 288 ntbl->nt_config.ndtc_hash_chain_gc); 289 290 nl_dump_line(p, " hash-rand 0x%08X/0x%08X last-rand %s\n", 291 ntbl->nt_config.ndtc_hash_rnd, 292 ntbl->nt_config.ndtc_hash_mask, 293 nl_msec2str(ntbl->nt_config.ndtc_last_rand, 294 x, sizeof(x))); 295 } 296 297 if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) { 298 struct rtnl_neightbl_parms *pa = &ntbl->nt_parms; 299 300 nl_dump_line(p, " refcnt %u pending-queue-limit %u " \ 301 "proxy-delayed-queue-limit %u\n", 302 pa->ntp_refcnt, 303 pa->ntp_queue_len, 304 pa->ntp_proxy_qlen); 305 306 nl_dump_line(p, " num-userspace-probes %u num-unicast-probes " \ 307 "%u num-multicast-probes %u\n", 308 pa->ntp_app_probes, 309 pa->ntp_ucast_probes, 310 pa->ntp_mcast_probes); 311 312 nl_dump_line(p, " min-age %s base-reachable-time %s " \ 313 "stale-check-interval %s\n", 314 nl_msec2str(pa->ntp_locktime, x, sizeof(x)), 315 nl_msec2str(pa->ntp_base_reachable_time, 316 y, sizeof(y)), 317 nl_msec2str(pa->ntp_gc_stale_time, z, sizeof(z))); 318 319 nl_dump_line(p, " initial-probe-delay %s answer-delay %s " \ 320 "proxy-answer-delay %s\n", 321 nl_msec2str(pa->ntp_probe_delay, x, sizeof(x)), 322 nl_msec2str(pa->ntp_anycast_delay, y, sizeof(y)), 323 nl_msec2str(pa->ntp_proxy_delay, z, sizeof(z))); 324 } 325} 326 327static void neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p) 328{ 329 struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg; 330 331 neightbl_dump_details(arg, p); 332 333 if (!(ntbl->ce_mask & NEIGHTBL_ATTR_STATS)) 334 return; 335 336 nl_dump_line(p, " " \ 337 " lookups %" PRIu64 \ 338 " hits %" PRIu64 \ 339 " failed %" PRIu64 \ 340 " allocations %" PRIu64 \ 341 " destroys %" PRIu64 \ 342 "\n", 343 ntbl->nt_stats.ndts_lookups, 344 ntbl->nt_stats.ndts_hits, 345 ntbl->nt_stats.ndts_res_failed, 346 ntbl->nt_stats.ndts_allocs, 347 ntbl->nt_stats.ndts_destroys); 348 349 nl_dump_line(p, " " \ 350 " hash-grows %" PRIu64 \ 351 " forced-gc-runs %" PRIu64 \ 352 " periodic-gc-runs %" PRIu64 \ 353 "\n", 354 ntbl->nt_stats.ndts_hash_grows, 355 ntbl->nt_stats.ndts_forced_gc_runs, 356 ntbl->nt_stats.ndts_periodic_gc_runs); 357 358 nl_dump_line(p, " " \ 359 " rcv-unicast-probes %" PRIu64 \ 360 " rcv-multicast-probes %" PRIu64 \ 361 "\n", 362 ntbl->nt_stats.ndts_rcv_probes_ucast, 363 ntbl->nt_stats.ndts_rcv_probes_mcast); 364} 365 366/** 367 * @name Allocation/Freeing 368 * @{ 369 */ 370 371struct rtnl_neightbl *rtnl_neightbl_alloc(void) 372{ 373 return (struct rtnl_neightbl *) nl_object_alloc(&neightbl_obj_ops); 374} 375 376void rtnl_neightbl_put(struct rtnl_neightbl *neightbl) 377{ 378 nl_object_put((struct nl_object *) neightbl); 379} 380 381/** @} */ 382 383/** 384 * @name Neighbour Table Cache Management 385 * @{ 386 */ 387 388/** 389 * Build a neighbour table cache including all neighbour tables currently configured in the kernel. 390 * @arg sk Netlink socket. 391 * @arg result Pointer to store resulting cache. 392 * 393 * Allocates a new neighbour table cache, initializes it properly and 394 * updates it to include all neighbour tables currently configured in 395 * the kernel. 396 * 397 * @return 0 on success or a negative error code. 398 */ 399int rtnl_neightbl_alloc_cache(struct nl_sock *sk, struct nl_cache **result) 400{ 401 return nl_cache_alloc_and_fill(&rtnl_neightbl_ops, sk, result); 402} 403 404/** 405 * Lookup neighbour table by name and optional interface index 406 * @arg cache neighbour table cache 407 * @arg name name of table 408 * @arg ifindex optional interface index 409 * 410 * Looks up the neighbour table matching the specified name and 411 * optionally the specified ifindex to retrieve device specific 412 * parameter sets. 413 * 414 * @return ptr to neighbour table inside the cache or NULL if no 415 * match was found. 416 */ 417struct rtnl_neightbl *rtnl_neightbl_get(struct nl_cache *cache, 418 const char *name, int ifindex) 419{ 420 struct rtnl_neightbl *nt; 421 422 if (cache->c_ops != &rtnl_neightbl_ops) 423 return NULL; 424 425 nl_list_for_each_entry(nt, &cache->c_items, ce_list) { 426 if (!strcasecmp(nt->nt_name, name) && 427 ((!ifindex && !nt->nt_parms.ntp_ifindex) || 428 (ifindex && ifindex == nt->nt_parms.ntp_ifindex))) { 429 nl_object_get((struct nl_object *) nt); 430 return nt; 431 } 432 } 433 434 return NULL; 435} 436 437/** @} */ 438 439/** 440 * @name Neighbour Table Modifications 441 * @{ 442 */ 443 444/** 445 * Builds a netlink change request message to change neighbour table attributes 446 * @arg old neighbour table to change 447 * @arg tmpl template with requested changes 448 * @arg result Pointer to store resulting message. 449 * 450 * Builds a new netlink message requesting a change of neighbour table 451 * attributes. The netlink message header isn't fully equipped with all 452 * relevant fields and must be sent out via nl_send_auto_complete() or 453 * supplemented as needed. 454 * \a old must point to a neighbour table currently configured in the 455 * kernel and \a tmpl must contain the attributes to be changed set via 456 * \c rtnl_neightbl_set_* functions. 457 * 458 * @return 0 on success or a negative error code. 459 */ 460int rtnl_neightbl_build_change_request(struct rtnl_neightbl *old, 461 struct rtnl_neightbl *tmpl, 462 struct nl_msg **result) 463{ 464 struct nl_msg *m, *parms = NULL; 465 struct ndtmsg ndt = { 466 .ndtm_family = old->nt_family, 467 }; 468 469 m = nlmsg_alloc_simple(RTM_SETNEIGHTBL, 0); 470 if (!m) 471 return -NLE_NOMEM; 472 473 if (nlmsg_append(m, &ndt, sizeof(ndt), NLMSG_ALIGNTO) < 0) 474 goto nla_put_failure; 475 476 NLA_PUT_STRING(m, NDTA_NAME, old->nt_name); 477 478 if (tmpl->ce_mask & NEIGHTBL_ATTR_THRESH1) 479 NLA_PUT_U32(m, NDTA_THRESH1, tmpl->nt_gc_thresh1); 480 481 if (tmpl->ce_mask & NEIGHTBL_ATTR_THRESH2) 482 NLA_PUT_U32(m, NDTA_THRESH2, tmpl->nt_gc_thresh2); 483 484 if (tmpl->ce_mask & NEIGHTBL_ATTR_THRESH2) 485 NLA_PUT_U32(m, NDTA_THRESH2, tmpl->nt_gc_thresh2); 486 487 if (tmpl->ce_mask & NEIGHTBL_ATTR_GC_INTERVAL) 488 NLA_PUT_U64(m, NDTA_GC_INTERVAL, 489 tmpl->nt_gc_interval); 490 491 if (tmpl->ce_mask & NEIGHTBL_ATTR_PARMS) { 492 struct rtnl_neightbl_parms *p = &tmpl->nt_parms; 493 494 parms = nlmsg_alloc(); 495 if (!parms) 496 goto nla_put_failure; 497 498 if (old->nt_parms.ntp_mask & NEIGHTBLPARM_ATTR_IFINDEX) 499 NLA_PUT_U32(parms, NDTPA_IFINDEX, 500 old->nt_parms.ntp_ifindex); 501 502 503 if (p->ntp_mask & NEIGHTBLPARM_ATTR_QUEUE_LEN) 504 NLA_PUT_U32(parms, NDTPA_QUEUE_LEN, p->ntp_queue_len); 505 506 if (p->ntp_mask & NEIGHTBLPARM_ATTR_APP_PROBES) 507 NLA_PUT_U32(parms, NDTPA_APP_PROBES, p->ntp_app_probes); 508 509 if (p->ntp_mask & NEIGHTBLPARM_ATTR_UCAST_PROBES) 510 NLA_PUT_U32(parms, NDTPA_UCAST_PROBES, 511 p->ntp_ucast_probes); 512 513 if (p->ntp_mask & NEIGHTBLPARM_ATTR_MCAST_PROBES) 514 NLA_PUT_U32(parms, NDTPA_MCAST_PROBES, 515 p->ntp_mcast_probes); 516 517 if (p->ntp_mask & NEIGHTBLPARM_ATTR_PROXY_QLEN) 518 NLA_PUT_U32(parms, NDTPA_PROXY_QLEN, 519 p->ntp_proxy_qlen); 520 521 if (p->ntp_mask & NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME) 522 NLA_PUT_U64(parms, NDTPA_BASE_REACHABLE_TIME, 523 p->ntp_base_reachable_time); 524 525 if (p->ntp_mask & NEIGHTBLPARM_ATTR_RETRANS_TIME) 526 NLA_PUT_U64(parms, NDTPA_RETRANS_TIME, 527 p->ntp_retrans_time); 528 529 if (p->ntp_mask & NEIGHTBLPARM_ATTR_GC_STALETIME) 530 NLA_PUT_U64(parms, NDTPA_GC_STALETIME, 531 p->ntp_gc_stale_time); 532 533 if (p->ntp_mask & NEIGHTBLPARM_ATTR_DELAY_PROBE_TIME) 534 NLA_PUT_U64(parms, NDTPA_DELAY_PROBE_TIME, 535 p->ntp_proxy_delay); 536 537 if (p->ntp_mask & NEIGHTBLPARM_ATTR_ANYCAST_DELAY) 538 NLA_PUT_U64(parms, NDTPA_ANYCAST_DELAY, 539 p->ntp_anycast_delay); 540 541 if (p->ntp_mask & NEIGHTBLPARM_ATTR_PROXY_DELAY) 542 NLA_PUT_U64(parms, NDTPA_PROXY_DELAY, 543 p->ntp_proxy_delay); 544 545 if (p->ntp_mask & NEIGHTBLPARM_ATTR_LOCKTIME) 546 NLA_PUT_U64(parms, NDTPA_LOCKTIME, p->ntp_locktime); 547 548 if (nla_put_nested(m, NDTA_PARMS, parms) < 0) 549 goto nla_put_failure; 550 551 nlmsg_free(parms); 552 } 553 554 *result = m; 555 return 0; 556 557nla_put_failure: 558 if (parms) 559 nlmsg_free(parms); 560 nlmsg_free(m); 561 return -NLE_MSGSIZE; 562} 563 564/** 565 * Change neighbour table attributes 566 * @arg sk Netlink socket. 567 * @arg old neighbour table to be changed 568 * @arg tmpl template with requested changes 569 * 570 * Builds a new netlink message by calling 571 * rtnl_neightbl_build_change_request(), sends the request to the 572 * kernel and waits for the next ACK to be received, i.e. blocks 573 * until the request has been processed. 574 * 575 * @return 0 on success or a negative error code 576 */ 577int rtnl_neightbl_change(struct nl_sock *sk, struct rtnl_neightbl *old, 578 struct rtnl_neightbl *tmpl) 579{ 580 struct nl_msg *msg; 581 int err; 582 583 if ((err = rtnl_neightbl_build_change_request(old, tmpl, &msg)) < 0) 584 return err; 585 586 err = nl_send_auto_complete(sk, msg); 587 nlmsg_free(msg); 588 if (err < 0) 589 return err; 590 591 return wait_for_ack(sk); 592} 593 594/** @} */ 595 596/** 597 * @name Attribute Modification 598 * @{ 599 */ 600 601void rtnl_neightbl_set_family(struct rtnl_neightbl *ntbl, int family) 602{ 603 ntbl->nt_family = family; 604 ntbl->ce_mask |= NEIGHTBL_ATTR_FAMILY; 605} 606 607void rtnl_neightbl_set_gc_interval(struct rtnl_neightbl *ntbl, uint64_t ms) 608{ 609 ntbl->nt_gc_interval = ms; 610 ntbl->ce_mask |= NEIGHTBL_ATTR_GC_INTERVAL; 611} 612 613void rtnl_neightbl_set_gc_tresh1(struct rtnl_neightbl *ntbl, int thresh) 614{ 615 ntbl->nt_gc_thresh1 = thresh; 616 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH1; 617} 618 619void rtnl_neightbl_set_gc_tresh2(struct rtnl_neightbl *ntbl, int thresh) 620{ 621 ntbl->nt_gc_thresh2 = thresh; 622 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH2; 623} 624 625void rtnl_neightbl_set_gc_tresh3(struct rtnl_neightbl *ntbl, int thresh) 626{ 627 ntbl->nt_gc_thresh3 = thresh; 628 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH3; 629} 630 631void rtnl_neightbl_set_name(struct rtnl_neightbl *ntbl, const char *name) 632{ 633 strncpy(ntbl->nt_name, name, sizeof(ntbl->nt_name) - 1); 634 ntbl->ce_mask |= NEIGHTBL_ATTR_NAME; 635} 636 637void rtnl_neightbl_set_dev(struct rtnl_neightbl *ntbl, int ifindex) 638{ 639 ntbl->nt_parms.ntp_ifindex = ifindex; 640 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_IFINDEX; 641 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 642} 643 644/** 645 * Set the queue length for pending requests of a neighbour table to the specified value 646 * @arg ntbl neighbour table to change 647 * @arg len new queue len 648 */ 649void rtnl_neightbl_set_queue_len(struct rtnl_neightbl *ntbl, int len) 650{ 651 ntbl->nt_parms.ntp_queue_len = len; 652 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_QUEUE_LEN; 653 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 654} 655 656/** 657 * Set the queue length for delay proxy arp requests of a neighbour table to the specified value 658 * @arg ntbl neighbour table to change 659 * @arg len new queue len 660 */ 661void rtnl_neightbl_set_proxy_queue_len(struct rtnl_neightbl *ntbl, int len) 662{ 663 ntbl->nt_parms.ntp_proxy_qlen = len; 664 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_PROXY_QLEN; 665 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 666} 667 668/** 669 * Set the number of application probes of a neighbour table to the specified value 670 * @arg ntbl neighbour table to change 671 * @arg probes new probes value 672 */ 673void rtnl_neightbl_set_app_probes(struct rtnl_neightbl *ntbl, int probes) 674{ 675 ntbl->nt_parms.ntp_app_probes = probes; 676 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_APP_PROBES; 677 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 678} 679 680/** 681 * Set the number of unicast probes of a neighbour table to the specified value 682 * @arg ntbl neighbour table to change 683 * @arg probes new probes value 684 */ 685void rtnl_neightbl_set_ucast_probes(struct rtnl_neightbl *ntbl, int probes) 686{ 687 ntbl->nt_parms.ntp_ucast_probes = probes; 688 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_UCAST_PROBES; 689 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 690} 691 692/** 693 * Set the number of multicast probes of a neighbour table to the specified value 694 * @arg ntbl neighbour table to change 695 * @arg probes new probes value 696 */ 697void rtnl_neightbl_set_mcast_probes(struct rtnl_neightbl *ntbl, int probes) 698{ 699 ntbl->nt_parms.ntp_mcast_probes = probes; 700 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_MCAST_PROBES; 701 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 702} 703 704/** 705 * Set the base reachable time of a neighbour table to the specified value 706 * @arg ntbl neighbour table to change 707 * @arg ms new base reachable time in milliseconds 708 */ 709void rtnl_neightbl_set_base_reachable_time(struct rtnl_neightbl *ntbl, 710 uint64_t ms) 711{ 712 ntbl->nt_parms.ntp_base_reachable_time = ms; 713 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME; 714 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 715} 716 717/** 718 * Set the retransmit time of a neighbour table to the specified value 719 * @arg ntbl neighbour table to change 720 * @arg ms new retransmit time 721 */ 722void rtnl_neightbl_set_retrans_time(struct rtnl_neightbl *ntbl, uint64_t ms) 723{ 724 ntbl->nt_parms.ntp_retrans_time = ms; 725 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_RETRANS_TIME; 726 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 727} 728 729/** 730 * Set the gc stale time of a neighbour table to the specified value 731 * @arg ntbl neighbour table to change 732 * @arg ms new gc stale time in milliseconds 733 */ 734void rtnl_neightbl_set_gc_stale_time(struct rtnl_neightbl *ntbl, uint64_t ms) 735{ 736 ntbl->nt_parms.ntp_gc_stale_time = ms; 737 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_GC_STALETIME; 738 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 739} 740 741/** 742 * Set the first probe delay time of a neighbour table to the specified value 743 * @arg ntbl neighbour table to change 744 * @arg ms new first probe delay time in milliseconds 745 */ 746void rtnl_neightbl_set_delay_probe_time(struct rtnl_neightbl *ntbl, uint64_t ms) 747{ 748 ntbl->nt_parms.ntp_probe_delay = ms; 749 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_DELAY_PROBE_TIME; 750 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 751} 752 753/** 754 * Set the anycast delay of a neighbour table to the specified value 755 * @arg ntbl neighbour table to change 756 * @arg ms new anycast delay in milliseconds 757 */ 758void rtnl_neightbl_set_anycast_delay(struct rtnl_neightbl *ntbl, uint64_t ms) 759{ 760 ntbl->nt_parms.ntp_anycast_delay = ms; 761 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_ANYCAST_DELAY; 762 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 763} 764 765/** 766 * Set the proxy delay of a neighbour table to the specified value 767 * @arg ntbl neighbour table to change 768 * @arg ms new proxy delay in milliseconds 769 */ 770void rtnl_neightbl_set_proxy_delay(struct rtnl_neightbl *ntbl, uint64_t ms) 771{ 772 ntbl->nt_parms.ntp_proxy_delay = ms; 773 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_PROXY_DELAY; 774 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 775} 776 777/** 778 * Set the locktime of a neighbour table to the specified value 779 * @arg ntbl neighbour table to change 780 * @arg ms new locktime in milliseconds 781 */ 782void rtnl_neightbl_set_locktime(struct rtnl_neightbl *ntbl, uint64_t ms) 783{ 784 ntbl->nt_parms.ntp_locktime = ms; 785 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_LOCKTIME; 786 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 787} 788 789/** @} */ 790 791static struct nl_object_ops neightbl_obj_ops = { 792 .oo_name = "route/neightbl", 793 .oo_size = sizeof(struct rtnl_neightbl), 794 .oo_dump = { 795 [NL_DUMP_LINE] = neightbl_dump_line, 796 [NL_DUMP_DETAILS] = neightbl_dump_details, 797 [NL_DUMP_STATS] = neightbl_dump_stats, 798 }, 799 .oo_compare = neightbl_compare, 800}; 801 802static struct nl_cache_ops rtnl_neightbl_ops = { 803 .co_name = "route/neightbl", 804 .co_hdrsize = sizeof(struct rtgenmsg), 805 .co_msgtypes = { 806 { RTM_NEWNEIGHTBL, NL_ACT_NEW, "new" }, 807 { RTM_SETNEIGHTBL, NL_ACT_SET, "set" }, 808 { RTM_GETNEIGHTBL, NL_ACT_GET, "get" }, 809 END_OF_MSGTYPES_LIST, 810 }, 811 .co_protocol = NETLINK_ROUTE, 812 .co_request_update = neightbl_request_update, 813 .co_msg_parser = neightbl_msg_parser, 814 .co_obj_ops = &neightbl_obj_ops, 815}; 816 817static void __init neightbl_init(void) 818{ 819 nl_cache_mngt_register(&rtnl_neightbl_ops); 820} 821 822static void __exit neightbl_exit(void) 823{ 824 nl_cache_mngt_unregister(&rtnl_neightbl_ops); 825} 826 827/** @} */ 828