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-local.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 return -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("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 } else 249 nl_dump(p, "<%u> ", ntbl->nt_parms.ntp_ifindex); 250 } else 251 nl_dump(p, " "); 252 253 if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG) 254 nl_dump(p, "entries %u ", ntbl->nt_config.ndtc_entries); 255 256 if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) { 257 char rt[32], rt2[32]; 258 struct rtnl_neightbl_parms *pa = &ntbl->nt_parms; 259 260 nl_dump(p, "reachable-time %s retransmit-time %s", 261 nl_msec2str(pa->ntp_reachable_time, rt, sizeof(rt)), 262 nl_msec2str(pa->ntp_retrans_time, rt2, sizeof(rt2))); 263 } 264 265 nl_dump(p, "\n"); 266} 267 268static void neightbl_dump_details(struct nl_object *arg, struct nl_dump_params *p) 269{ 270 char x[32], y[32], z[32]; 271 struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg; 272 273 neightbl_dump_line(arg, p); 274 275 if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG) { 276 nl_dump_line(p, " key-len %u entry-size %u last-flush %s\n", 277 ntbl->nt_config.ndtc_key_len, 278 ntbl->nt_config.ndtc_entry_size, 279 nl_msec2str(ntbl->nt_config.ndtc_last_flush, 280 x, sizeof(x))); 281 282 nl_dump_line(p, " gc threshold %u/%u/%u interval %s " \ 283 "chain-position %u\n", 284 ntbl->nt_gc_thresh1, ntbl->nt_gc_thresh2, 285 ntbl->nt_gc_thresh3, 286 nl_msec2str(ntbl->nt_gc_interval, x, sizeof(x)), 287 ntbl->nt_config.ndtc_hash_chain_gc); 288 289 nl_dump_line(p, " hash-rand 0x%08X/0x%08X last-rand %s\n", 290 ntbl->nt_config.ndtc_hash_rnd, 291 ntbl->nt_config.ndtc_hash_mask, 292 nl_msec2str(ntbl->nt_config.ndtc_last_rand, 293 x, sizeof(x))); 294 } 295 296 if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) { 297 struct rtnl_neightbl_parms *pa = &ntbl->nt_parms; 298 299 nl_dump_line(p, " refcnt %u pending-queue-limit %u " \ 300 "proxy-delayed-queue-limit %u\n", 301 pa->ntp_refcnt, 302 pa->ntp_queue_len, 303 pa->ntp_proxy_qlen); 304 305 nl_dump_line(p, " num-userspace-probes %u num-unicast-probes " \ 306 "%u num-multicast-probes %u\n", 307 pa->ntp_app_probes, 308 pa->ntp_ucast_probes, 309 pa->ntp_mcast_probes); 310 311 nl_dump_line(p, " min-age %s base-reachable-time %s " \ 312 "stale-check-interval %s\n", 313 nl_msec2str(pa->ntp_locktime, x, sizeof(x)), 314 nl_msec2str(pa->ntp_base_reachable_time, 315 y, sizeof(y)), 316 nl_msec2str(pa->ntp_gc_stale_time, z, sizeof(z))); 317 318 nl_dump_line(p, " initial-probe-delay %s answer-delay %s " \ 319 "proxy-answer-delay %s\n", 320 nl_msec2str(pa->ntp_probe_delay, x, sizeof(x)), 321 nl_msec2str(pa->ntp_anycast_delay, y, sizeof(y)), 322 nl_msec2str(pa->ntp_proxy_delay, z, sizeof(z))); 323 } 324} 325 326static void neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p) 327{ 328 struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg; 329 330 neightbl_dump_details(arg, p); 331 332 if (!(ntbl->ce_mask & NEIGHTBL_ATTR_STATS)) 333 return; 334 335 nl_dump_line(p, " lookups %lld hits %lld failed %lld " \ 336 "allocations %lld destroys %lld\n", 337 ntbl->nt_stats.ndts_lookups, 338 ntbl->nt_stats.ndts_hits, 339 ntbl->nt_stats.ndts_res_failed, 340 ntbl->nt_stats.ndts_allocs, 341 ntbl->nt_stats.ndts_destroys); 342 343 nl_dump_line(p, " hash-grows %lld forced-gc-runs %lld " \ 344 "periodic-gc-runs %lld\n", 345 ntbl->nt_stats.ndts_hash_grows, 346 ntbl->nt_stats.ndts_forced_gc_runs, 347 ntbl->nt_stats.ndts_periodic_gc_runs); 348 349 nl_dump_line(p, " rcv-unicast-probes %lld rcv-multicast-probes %lld\n", 350 ntbl->nt_stats.ndts_rcv_probes_ucast, 351 ntbl->nt_stats.ndts_rcv_probes_mcast); 352} 353 354/** 355 * @name Allocation/Freeing 356 * @{ 357 */ 358 359struct rtnl_neightbl *rtnl_neightbl_alloc(void) 360{ 361 return (struct rtnl_neightbl *) nl_object_alloc(&neightbl_obj_ops); 362} 363 364void rtnl_neightbl_put(struct rtnl_neightbl *neightbl) 365{ 366 nl_object_put((struct nl_object *) neightbl); 367} 368 369/** @} */ 370 371/** 372 * @name Neighbour Table Cache Management 373 * @{ 374 */ 375 376/** 377 * Build a neighbour table cache including all neighbour tables currently configured in the kernel. 378 * @arg sk Netlink socket. 379 * @arg result Pointer to store resulting cache. 380 * 381 * Allocates a new neighbour table cache, initializes it properly and 382 * updates it to include all neighbour tables currently configured in 383 * the kernel. 384 * 385 * @return 0 on success or a negative error code. 386 */ 387int rtnl_neightbl_alloc_cache(struct nl_sock *sk, struct nl_cache **result) 388{ 389 return nl_cache_alloc_and_fill(&rtnl_neightbl_ops, sk, result); 390} 391 392/** 393 * Lookup neighbour table by name and optional interface index 394 * @arg cache neighbour table cache 395 * @arg name name of table 396 * @arg ifindex optional interface index 397 * 398 * Looks up the neighbour table matching the specified name and 399 * optionally the specified ifindex to retrieve device specific 400 * parameter sets. 401 * 402 * @return ptr to neighbour table inside the cache or NULL if no 403 * match was found. 404 */ 405struct rtnl_neightbl *rtnl_neightbl_get(struct nl_cache *cache, 406 const char *name, int ifindex) 407{ 408 struct rtnl_neightbl *nt; 409 410 if (cache->c_ops != &rtnl_neightbl_ops) 411 return NULL; 412 413 nl_list_for_each_entry(nt, &cache->c_items, ce_list) { 414 if (!strcasecmp(nt->nt_name, name) && 415 ((!ifindex && !nt->nt_parms.ntp_ifindex) || 416 (ifindex && ifindex == nt->nt_parms.ntp_ifindex))) { 417 nl_object_get((struct nl_object *) nt); 418 return nt; 419 } 420 } 421 422 return NULL; 423} 424 425/** @} */ 426 427/** 428 * @name Neighbour Table Modifications 429 * @{ 430 */ 431 432/** 433 * Builds a netlink change request message to change neighbour table attributes 434 * @arg old neighbour table to change 435 * @arg tmpl template with requested changes 436 * @arg result Pointer to store resulting message. 437 * 438 * Builds a new netlink message requesting a change of neighbour table 439 * attributes. The netlink message header isn't fully equipped with all 440 * relevant fields and must be sent out via nl_send_auto_complete() or 441 * supplemented as needed. 442 * \a old must point to a neighbour table currently configured in the 443 * kernel and \a tmpl must contain the attributes to be changed set via 444 * \c rtnl_neightbl_set_* functions. 445 * 446 * @return 0 on success or a negative error code. 447 */ 448int rtnl_neightbl_build_change_request(struct rtnl_neightbl *old, 449 struct rtnl_neightbl *tmpl, 450 struct nl_msg **result) 451{ 452 struct nl_msg *m, *parms = NULL; 453 struct ndtmsg ndt = { 454 .ndtm_family = old->nt_family, 455 }; 456 457 m = nlmsg_alloc_simple(RTM_SETNEIGHTBL, 0); 458 if (!m) 459 return -NLE_NOMEM; 460 461 if (nlmsg_append(m, &ndt, sizeof(ndt), NLMSG_ALIGNTO) < 0) 462 goto nla_put_failure; 463 464 NLA_PUT_STRING(m, NDTA_NAME, old->nt_name); 465 466 if (tmpl->ce_mask & NEIGHTBL_ATTR_THRESH1) 467 NLA_PUT_U32(m, NDTA_THRESH1, tmpl->nt_gc_thresh1); 468 469 if (tmpl->ce_mask & NEIGHTBL_ATTR_THRESH2) 470 NLA_PUT_U32(m, NDTA_THRESH2, tmpl->nt_gc_thresh2); 471 472 if (tmpl->ce_mask & NEIGHTBL_ATTR_THRESH2) 473 NLA_PUT_U32(m, NDTA_THRESH2, tmpl->nt_gc_thresh2); 474 475 if (tmpl->ce_mask & NEIGHTBL_ATTR_GC_INTERVAL) 476 NLA_PUT_U64(m, NDTA_GC_INTERVAL, 477 tmpl->nt_gc_interval); 478 479 if (tmpl->ce_mask & NEIGHTBL_ATTR_PARMS) { 480 struct rtnl_neightbl_parms *p = &tmpl->nt_parms; 481 482 parms = nlmsg_alloc(); 483 if (!parms) 484 goto nla_put_failure; 485 486 if (old->nt_parms.ntp_mask & NEIGHTBLPARM_ATTR_IFINDEX) 487 NLA_PUT_U32(parms, NDTPA_IFINDEX, 488 old->nt_parms.ntp_ifindex); 489 490 491 if (p->ntp_mask & NEIGHTBLPARM_ATTR_QUEUE_LEN) 492 NLA_PUT_U32(parms, NDTPA_QUEUE_LEN, p->ntp_queue_len); 493 494 if (p->ntp_mask & NEIGHTBLPARM_ATTR_APP_PROBES) 495 NLA_PUT_U32(parms, NDTPA_APP_PROBES, p->ntp_app_probes); 496 497 if (p->ntp_mask & NEIGHTBLPARM_ATTR_UCAST_PROBES) 498 NLA_PUT_U32(parms, NDTPA_UCAST_PROBES, 499 p->ntp_ucast_probes); 500 501 if (p->ntp_mask & NEIGHTBLPARM_ATTR_MCAST_PROBES) 502 NLA_PUT_U32(parms, NDTPA_MCAST_PROBES, 503 p->ntp_mcast_probes); 504 505 if (p->ntp_mask & NEIGHTBLPARM_ATTR_PROXY_QLEN) 506 NLA_PUT_U32(parms, NDTPA_PROXY_QLEN, 507 p->ntp_proxy_qlen); 508 509 if (p->ntp_mask & NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME) 510 NLA_PUT_U64(parms, NDTPA_BASE_REACHABLE_TIME, 511 p->ntp_base_reachable_time); 512 513 if (p->ntp_mask & NEIGHTBLPARM_ATTR_RETRANS_TIME) 514 NLA_PUT_U64(parms, NDTPA_RETRANS_TIME, 515 p->ntp_retrans_time); 516 517 if (p->ntp_mask & NEIGHTBLPARM_ATTR_GC_STALETIME) 518 NLA_PUT_U64(parms, NDTPA_GC_STALETIME, 519 p->ntp_gc_stale_time); 520 521 if (p->ntp_mask & NEIGHTBLPARM_ATTR_DELAY_PROBE_TIME) 522 NLA_PUT_U64(parms, NDTPA_DELAY_PROBE_TIME, 523 p->ntp_proxy_delay); 524 525 if (p->ntp_mask & NEIGHTBLPARM_ATTR_ANYCAST_DELAY) 526 NLA_PUT_U64(parms, NDTPA_ANYCAST_DELAY, 527 p->ntp_anycast_delay); 528 529 if (p->ntp_mask & NEIGHTBLPARM_ATTR_PROXY_DELAY) 530 NLA_PUT_U64(parms, NDTPA_PROXY_DELAY, 531 p->ntp_proxy_delay); 532 533 if (p->ntp_mask & NEIGHTBLPARM_ATTR_LOCKTIME) 534 NLA_PUT_U64(parms, NDTPA_LOCKTIME, p->ntp_locktime); 535 536 if (nla_put_nested(m, NDTA_PARMS, parms) < 0) 537 goto nla_put_failure; 538 539 nlmsg_free(parms); 540 } 541 542 *result = m; 543 return 0; 544 545nla_put_failure: 546 if (parms) 547 nlmsg_free(parms); 548 nlmsg_free(m); 549 return -NLE_MSGSIZE; 550} 551 552/** 553 * Change neighbour table attributes 554 * @arg sk Netlink socket. 555 * @arg old neighbour table to be changed 556 * @arg tmpl template with requested changes 557 * 558 * Builds a new netlink message by calling 559 * rtnl_neightbl_build_change_request(), sends the request to the 560 * kernel and waits for the next ACK to be received, i.e. blocks 561 * until the request has been processed. 562 * 563 * @return 0 on success or a negative error code 564 */ 565int rtnl_neightbl_change(struct nl_sock *sk, struct rtnl_neightbl *old, 566 struct rtnl_neightbl *tmpl) 567{ 568 struct nl_msg *msg; 569 int err; 570 571 if ((err = rtnl_neightbl_build_change_request(old, tmpl, &msg)) < 0) 572 return err; 573 574 err = nl_send_auto_complete(sk, msg); 575 nlmsg_free(msg); 576 if (err < 0) 577 return err; 578 579 return wait_for_ack(sk); 580} 581 582/** @} */ 583 584/** 585 * @name Attribute Modification 586 * @{ 587 */ 588 589void rtnl_neightbl_set_family(struct rtnl_neightbl *ntbl, int family) 590{ 591 ntbl->nt_family = family; 592 ntbl->ce_mask |= NEIGHTBL_ATTR_FAMILY; 593} 594 595void rtnl_neightbl_set_gc_interval(struct rtnl_neightbl *ntbl, uint64_t ms) 596{ 597 ntbl->nt_gc_interval = ms; 598 ntbl->ce_mask |= NEIGHTBL_ATTR_GC_INTERVAL; 599} 600 601void rtnl_neightbl_set_gc_tresh1(struct rtnl_neightbl *ntbl, int thresh) 602{ 603 ntbl->nt_gc_thresh1 = thresh; 604 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH1; 605} 606 607void rtnl_neightbl_set_gc_tresh2(struct rtnl_neightbl *ntbl, int thresh) 608{ 609 ntbl->nt_gc_thresh2 = thresh; 610 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH2; 611} 612 613void rtnl_neightbl_set_gc_tresh3(struct rtnl_neightbl *ntbl, int thresh) 614{ 615 ntbl->nt_gc_thresh3 = thresh; 616 ntbl->ce_mask |= NEIGHTBL_ATTR_THRESH3; 617} 618 619void rtnl_neightbl_set_name(struct rtnl_neightbl *ntbl, const char *name) 620{ 621 strncpy(ntbl->nt_name, name, sizeof(ntbl->nt_name) - 1); 622 ntbl->ce_mask |= NEIGHTBL_ATTR_NAME; 623} 624 625void rtnl_neightbl_set_dev(struct rtnl_neightbl *ntbl, int ifindex) 626{ 627 ntbl->nt_parms.ntp_ifindex = ifindex; 628 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_IFINDEX; 629 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 630} 631 632/** 633 * Set the queue length for pending requests of a neighbour table to the specified value 634 * @arg ntbl neighbour table to change 635 * @arg len new queue len 636 */ 637void rtnl_neightbl_set_queue_len(struct rtnl_neightbl *ntbl, int len) 638{ 639 ntbl->nt_parms.ntp_queue_len = len; 640 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_QUEUE_LEN; 641 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 642} 643 644/** 645 * Set the queue length for delay proxy arp 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_proxy_queue_len(struct rtnl_neightbl *ntbl, int len) 650{ 651 ntbl->nt_parms.ntp_proxy_qlen = len; 652 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_PROXY_QLEN; 653 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 654} 655 656/** 657 * Set the number of application probes of a neighbour table to the specified value 658 * @arg ntbl neighbour table to change 659 * @arg probes new probes value 660 */ 661void rtnl_neightbl_set_app_probes(struct rtnl_neightbl *ntbl, int probes) 662{ 663 ntbl->nt_parms.ntp_app_probes = probes; 664 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_APP_PROBES; 665 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 666} 667 668/** 669 * Set the number of unicast 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_ucast_probes(struct rtnl_neightbl *ntbl, int probes) 674{ 675 ntbl->nt_parms.ntp_ucast_probes = probes; 676 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_UCAST_PROBES; 677 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 678} 679 680/** 681 * Set the number of multicast 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_mcast_probes(struct rtnl_neightbl *ntbl, int probes) 686{ 687 ntbl->nt_parms.ntp_mcast_probes = probes; 688 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_MCAST_PROBES; 689 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 690} 691 692/** 693 * Set the base reachable time of a neighbour table to the specified value 694 * @arg ntbl neighbour table to change 695 * @arg ms new base reachable time in milliseconds 696 */ 697void rtnl_neightbl_set_base_reachable_time(struct rtnl_neightbl *ntbl, 698 uint64_t ms) 699{ 700 ntbl->nt_parms.ntp_base_reachable_time = ms; 701 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME; 702 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 703} 704 705/** 706 * Set the retransmit time of a neighbour table to the specified value 707 * @arg ntbl neighbour table to change 708 * @arg ms new retransmit time 709 */ 710void rtnl_neightbl_set_retrans_time(struct rtnl_neightbl *ntbl, uint64_t ms) 711{ 712 ntbl->nt_parms.ntp_retrans_time = ms; 713 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_RETRANS_TIME; 714 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 715} 716 717/** 718 * Set the gc stale time of a neighbour table to the specified value 719 * @arg ntbl neighbour table to change 720 * @arg ms new gc stale time in milliseconds 721 */ 722void rtnl_neightbl_set_gc_stale_time(struct rtnl_neightbl *ntbl, uint64_t ms) 723{ 724 ntbl->nt_parms.ntp_gc_stale_time = ms; 725 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_GC_STALETIME; 726 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 727} 728 729/** 730 * Set the first probe delay time of a neighbour table to the specified value 731 * @arg ntbl neighbour table to change 732 * @arg ms new first probe delay time in milliseconds 733 */ 734void rtnl_neightbl_set_delay_probe_time(struct rtnl_neightbl *ntbl, uint64_t ms) 735{ 736 ntbl->nt_parms.ntp_probe_delay = ms; 737 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_DELAY_PROBE_TIME; 738 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 739} 740 741/** 742 * Set the anycast delay of a neighbour table to the specified value 743 * @arg ntbl neighbour table to change 744 * @arg ms new anycast delay in milliseconds 745 */ 746void rtnl_neightbl_set_anycast_delay(struct rtnl_neightbl *ntbl, uint64_t ms) 747{ 748 ntbl->nt_parms.ntp_anycast_delay = ms; 749 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_ANYCAST_DELAY; 750 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 751} 752 753/** 754 * Set the proxy delay of a neighbour table to the specified value 755 * @arg ntbl neighbour table to change 756 * @arg ms new proxy delay in milliseconds 757 */ 758void rtnl_neightbl_set_proxy_delay(struct rtnl_neightbl *ntbl, uint64_t ms) 759{ 760 ntbl->nt_parms.ntp_proxy_delay = ms; 761 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_PROXY_DELAY; 762 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 763} 764 765/** 766 * Set the locktime of a neighbour table to the specified value 767 * @arg ntbl neighbour table to change 768 * @arg ms new locktime in milliseconds 769 */ 770void rtnl_neightbl_set_locktime(struct rtnl_neightbl *ntbl, uint64_t ms) 771{ 772 ntbl->nt_parms.ntp_locktime = ms; 773 ntbl->nt_parms.ntp_mask |= NEIGHTBLPARM_ATTR_LOCKTIME; 774 ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS; 775} 776 777/** @} */ 778 779static struct nl_object_ops neightbl_obj_ops = { 780 .oo_name = "route/neightbl", 781 .oo_size = sizeof(struct rtnl_neightbl), 782 .oo_dump = { 783 [NL_DUMP_LINE] = neightbl_dump_line, 784 [NL_DUMP_DETAILS] = neightbl_dump_details, 785 [NL_DUMP_STATS] = neightbl_dump_stats, 786 }, 787 .oo_compare = neightbl_compare, 788}; 789 790static struct nl_cache_ops rtnl_neightbl_ops = { 791 .co_name = "route/neightbl", 792 .co_hdrsize = sizeof(struct rtgenmsg), 793 .co_msgtypes = { 794 { RTM_NEWNEIGHTBL, NL_ACT_NEW, "new" }, 795 { RTM_SETNEIGHTBL, NL_ACT_SET, "set" }, 796 { RTM_GETNEIGHTBL, NL_ACT_GET, "get" }, 797 END_OF_MSGTYPES_LIST, 798 }, 799 .co_protocol = NETLINK_ROUTE, 800 .co_request_update = neightbl_request_update, 801 .co_msg_parser = neightbl_msg_parser, 802 .co_obj_ops = &neightbl_obj_ops, 803}; 804 805static void __init neightbl_init(void) 806{ 807 nl_cache_mngt_register(&rtnl_neightbl_ops); 808} 809 810static void __exit neightbl_exit(void) 811{ 812 nl_cache_mngt_unregister(&rtnl_neightbl_ops); 813} 814 815/** @} */ 816