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