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
53 static struct nl_cache_ops rtnl_neightbl_ops;
54 static struct nl_object_ops neightbl_obj_ops;
55 /** @endcond */
56
neightbl_compare(struct nl_object * _a,struct nl_object * _b,uint32_t attrs,int flags)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
neightbl_msg_parser(struct nl_cache_ops * ops,struct sockaddr_nl * who,struct nlmsghdr * n,struct nl_parser_param * pp)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 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);
220 errout:
221 rtnl_neightbl_put(ntbl);
222 return err;
223 }
224
neightbl_request_update(struct nl_cache * c,struct nl_sock * h)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
neightbl_dump_line(struct nl_object * arg,struct nl_dump_params * p)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_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
neightbl_dump_details(struct nl_object * arg,struct nl_dump_params * p)269 static 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
neightbl_dump_stats(struct nl_object * arg,struct nl_dump_params * p)327 static 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
rtnl_neightbl_alloc(void)371 struct rtnl_neightbl *rtnl_neightbl_alloc(void)
372 {
373 return (struct rtnl_neightbl *) nl_object_alloc(&neightbl_obj_ops);
374 }
375
rtnl_neightbl_put(struct rtnl_neightbl * neightbl)376 void 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 */
rtnl_neightbl_alloc_cache(struct nl_sock * sk,struct nl_cache ** result)399 int 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 */
rtnl_neightbl_get(struct nl_cache * cache,const char * name,int ifindex)417 struct 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 */
rtnl_neightbl_build_change_request(struct rtnl_neightbl * old,struct rtnl_neightbl * tmpl,struct nl_msg ** result)460 int 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
557 nla_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 */
rtnl_neightbl_change(struct nl_sock * sk,struct rtnl_neightbl * old,struct rtnl_neightbl * tmpl)577 int 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
rtnl_neightbl_set_family(struct rtnl_neightbl * ntbl,int family)601 void 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
rtnl_neightbl_set_gc_interval(struct rtnl_neightbl * ntbl,uint64_t ms)607 void 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
rtnl_neightbl_set_gc_tresh1(struct rtnl_neightbl * ntbl,int thresh)613 void 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
rtnl_neightbl_set_gc_tresh2(struct rtnl_neightbl * ntbl,int thresh)619 void 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
rtnl_neightbl_set_gc_tresh3(struct rtnl_neightbl * ntbl,int thresh)625 void 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
rtnl_neightbl_set_name(struct rtnl_neightbl * ntbl,const char * name)631 void 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
rtnl_neightbl_set_dev(struct rtnl_neightbl * ntbl,int ifindex)637 void 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 */
rtnl_neightbl_set_queue_len(struct rtnl_neightbl * ntbl,int len)649 void 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 */
rtnl_neightbl_set_proxy_queue_len(struct rtnl_neightbl * ntbl,int len)661 void 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 */
rtnl_neightbl_set_app_probes(struct rtnl_neightbl * ntbl,int probes)673 void 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 */
rtnl_neightbl_set_ucast_probes(struct rtnl_neightbl * ntbl,int probes)685 void 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 */
rtnl_neightbl_set_mcast_probes(struct rtnl_neightbl * ntbl,int probes)697 void 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 */
rtnl_neightbl_set_base_reachable_time(struct rtnl_neightbl * ntbl,uint64_t ms)709 void 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 */
rtnl_neightbl_set_retrans_time(struct rtnl_neightbl * ntbl,uint64_t ms)722 void 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 */
rtnl_neightbl_set_gc_stale_time(struct rtnl_neightbl * ntbl,uint64_t ms)734 void 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 */
rtnl_neightbl_set_delay_probe_time(struct rtnl_neightbl * ntbl,uint64_t ms)746 void 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 */
rtnl_neightbl_set_anycast_delay(struct rtnl_neightbl * ntbl,uint64_t ms)758 void 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 */
rtnl_neightbl_set_proxy_delay(struct rtnl_neightbl * ntbl,uint64_t ms)770 void 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 */
rtnl_neightbl_set_locktime(struct rtnl_neightbl * ntbl,uint64_t ms)782 void 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
791 static 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
802 static 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
neightbl_init(void)817 static void __init neightbl_init(void)
818 {
819 nl_cache_mngt_register(&rtnl_neightbl_ops);
820 }
821
neightbl_exit(void)822 static void __exit neightbl_exit(void)
823 {
824 nl_cache_mngt_unregister(&rtnl_neightbl_ops);
825 }
826
827 /** @} */
828