lib/route/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, "    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
 359 struct rtnl_neightbl *rtnl_neightbl_alloc(void)
 360 {
 361         return (struct rtnl_neightbl *) nl_object_alloc(&neightbl_obj_ops);
 362 }
 363
 364 void 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  */
 387 int 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  */
 405 struct 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  */
 448 int 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
 545 nla_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  */
 565 int 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
 589 void 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
 595 void 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
 601 void 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
 607 void 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
 613 void 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
 619 void 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
 625 void 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  */
 637 void 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  */
 649 void 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  */
 661 void 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  */
 673 void 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  */
 685 void 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  */
 697 void 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  */
 710 void 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  */
 722 void 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  */
 734 void 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  */
 746 void 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  */
 758 void 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  */
 770 void 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
 779 static 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
 790 static 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
 805 static void __init neightbl_init(void)
 806 {
 807         nl_cache_mngt_register(&rtnl_neightbl_ops);
 808 }
 809
 810 static void __exit neightbl_exit(void)
 811 {
 812         nl_cache_mngt_unregister(&rtnl_neightbl_ops);
 813 }
 814
 815 /** @} */