lib/route/neigh.c

   1 /*
   2  * lib/route/neigh.c    Neighbours
   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-2006 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup rtnl
  14  * @defgroup neigh Neighbours
  15  * @brief
  16  *
  17  * The neighbour table establishes bindings between protocol addresses and
  18  * link layer addresses for hosts sharing the same physical link. This
  19  * module allows you to access and manipulate the content of these tables.
  20  *
  21  * @par Neighbour States
  22  * @code
  23  * NUD_INCOMPLETE
  24  * NUD_REACHABLE
  25  * NUD_STALE
  26  * NUD_DELAY
  27  * NUD_PROBE
  28  * NUD_FAILED
  29  * NUD_NOARP
  30  * NUD_PERMANENT
  31  * @endcode
  32  *
  33  * @par Neighbour Flags
  34  * @code
  35  * NTF_PROXY
  36  * NTF_ROUTER
  37  * @endcode
  38  *
  39  * @par Neighbour Identification
  40  * A neighbour is uniquely identified by the attributes listed below, whenever
  41  * you refer to an existing neighbour all of the attributes must be set.
  42  * Neighbours from caches automatically have all required attributes set.
  43  *   - interface index (rtnl_neigh_set_ifindex())
  44  *   - destination address (rtnl_neigh_set_dst())
  45  *
  46  * @par Changeable Attributes
  47  * \anchor neigh_changeable
  48  *  - state (rtnl_neigh_set_state())
  49  *  - link layer address (rtnl_neigh_set_lladdr())
  50  *
  51  * @par Required Caches for Dumping
  52  * In order to dump neighbour attributes you must provide the following
  53  * caches via nl_cache_provide()
  54  *  - link cache holding all links
  55  *
  56  * @par TODO
  57  *   - Document proxy settings
  58  *   - Document states and their influence
  59  *
  60  * @par 1) Retrieving information about configured neighbours
  61  * @code
  62  * // The first step is to retrieve a list of all available neighbour within
  63  * // the kernel and put them into a cache.
  64  * struct nl_cache *cache = rtnl_neigh_alloc_cache(handle);
  65  *
  66  * // Neighbours can then be looked up by the interface and destination
  67  * // address:
  68  * struct rtnl_neigh *neigh = rtnl_neigh_get(cache, ifindex, dst_addr);
  69  *
  70  * // After successful usage, the object must be given back to the cache
  71  * rtnl_neigh_put(neigh);
  72  * @endcode
  73  *
  74  * @par 2) Adding new neighbours
  75  * @code
  76  * // Allocate an empty neighbour handle to be filled out with the attributes
  77  * // of the new neighbour.
  78  * struct rtnl_neigh *neigh = rtnl_neigh_alloc();
  79  *
  80  * // Fill out the attributes of the new neighbour
  81  * rtnl_neigh_set_ifindex(neigh, ifindex);
  82  * rtnl_neigh_set_dst(neigh, dst_addr);
  83  * rtnl_neigh_set_state(neigh, rtnl_neigh_str2state("permanent"));
  84  *
  85  * // Build the netlink message and send it to the kernel, the operation will
  86  * // block until the operation has been completed. Alternatively the required
  87  * // netlink message can be built using rtnl_neigh_build_add_request()
  88  * // to be sent out using nl_send_auto_complete().
  89  * rtnl_neigh_add(nl_handle, neigh, NLM_F_REPLACE);
  90  *
  91  * // Free the memory
  92  * rtnl_neigh_put(neigh);
  93  * @endcode
  94  *
  95  * @par 3) Deleting an existing neighbour
  96  * @code
  97  * // Allocate an empty neighbour object to be filled out with the attributes
  98  * // matching the neighbour to be deleted. Alternatively a fully equipped
  99  * // neighbour object out of a cache can be used instead.
 100  * struct rtnl_neigh *neigh = rtnl_neigh_alloc();
 101  *
 102  * // Neighbours are uniquely identified by their interface index and
 103  * // destination address, you may fill out other attributes but they
 104  * // will have no influence.
 105  * rtnl_neigh_set_ifindex(neigh, ifindex);
 106  * rtnl_neigh_set_dst(neigh, dst_addr);
 107  *
 108  * // Build the netlink message and send it to the kernel, the operation will
 109  * // block until the operation has been completed. Alternatively the required
 110  * // netlink message can be built using rtnl_neigh_build_delete_request()
 111  * // to be sent out using nl_send_auto_complete().
 112  * rtnl_neigh_delete(handle, neigh, 0);
 113  *
 114  * // Free the memory
 115  * rtnl_neigh_put(neigh);
 116  * @endcode
 117  *
 118  * @par 4) Changing neighbour attributes
 119  * @code
 120  * // Allocate an empty neighbour object to be filled out with the attributes
 121  * // matching the neighbour to be changed and the new parameters. Alternatively
 122  * // a fully equipped modified neighbour object out of a cache can be used.
 123  * struct rtnl_neigh *neigh = rtnl_neigh_alloc();
 124  *
 125  * // Identify the neighbour to be changed by its interface index and
 126  * // destination address
 127  * rtnl_neigh_set_ifindex(neigh, ifindex);
 128  * rtnl_neigh_set_dst(neigh, dst_addr);
 129  *
 130  * // The link layer address may be modified, if so it is wise to change
 131  * // its state to "permanent" in order to avoid having it overwritten.
 132  * rtnl_neigh_set_lladdr(neigh, lladdr);
 133  *
 134  * // Secondly the state can be modified allowing normal neighbours to be
 135  * // converted into permanent entries or to manually confirm a neighbour.
 136  * rtnl_neigh_set_state(neigh, state);
 137  *
 138  * // Build the netlink message and send it to the kernel, the operation will
 139  * // block until the operation has been completed. Alternatively the required
 140  * // netlink message can be built using rtnl_neigh_build_change_request()
 141  * // to be sent out using nl_send_auto_complete().
 142  * rtnl_neigh_change(handle, neigh, 0);
 143  *
 144  * // Free the memory
 145  * rtnl_neigh_put(neigh);
 146  * @endcode
 147  * @{
 148  */
 149
 150 #include <netlink-local.h>
 151 #include <netlink/netlink.h>
 152 #include <netlink/utils.h>
 153 #include <netlink/route/rtnl.h>
 154 #include <netlink/route/neighbour.h>
 155 #include <netlink/route/link.h>
 156
 157 /** @cond SKIP */
 158 #define NEIGH_ATTR_FLAGS        0x01
 159 #define NEIGH_ATTR_STATE        0x02
 160 #define NEIGH_ATTR_LLADDR       0x04
 161 #define NEIGH_ATTR_DST          0x08
 162 #define NEIGH_ATTR_CACHEINFO    0x10
 163 #define NEIGH_ATTR_IFINDEX      0x20
 164 #define NEIGH_ATTR_FAMILY       0x40
 165 #define NEIGH_ATTR_TYPE         0x80
 166 #define NEIGH_ATTR_PROBES       0x100
 167
 168 static struct nl_cache_ops rtnl_neigh_ops;
 169 static struct nl_object_ops neigh_obj_ops;
 170 /** @endcond */
 171
 172 static void neigh_free_data(struct nl_object *c)
 173 {
 174         struct rtnl_neigh *neigh = nl_object_priv(c);
 175
 176         if (!neigh)
 177                 return;
 178
 179         nl_addr_put(neigh->n_lladdr);
 180         nl_addr_put(neigh->n_dst);
 181 }
 182
 183 static int neigh_clone(struct nl_object *_dst, struct nl_object *_src)
 184 {
 185         struct rtnl_neigh *dst = nl_object_priv(_dst);
 186         struct rtnl_neigh *src = nl_object_priv(_src);
 187
 188         if (src->n_lladdr)
 189                 if (!(dst->n_lladdr = nl_addr_clone(src->n_lladdr)))
 190                         goto errout;
 191
 192         if (src->n_dst)
 193                 if (!(dst->n_dst = nl_addr_clone(src->n_dst)))
 194                         goto errout;
 195
 196         return 0;
 197 errout:
 198         return nl_get_errno();
 199 }
 200
 201 static int neigh_compare(struct nl_object *_a, struct nl_object *_b,
 202                         uint32_t attrs, int flags)
 203 {
 204         struct rtnl_neigh *a = (struct rtnl_neigh *) _a;
 205         struct rtnl_neigh *b = (struct rtnl_neigh *) _b;
 206         int diff = 0;
 207
 208 #define NEIGH_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NEIGH_ATTR_##ATTR, a, b, EXPR)
 209
 210         diff |= NEIGH_DIFF(IFINDEX,     a->n_ifindex != b->n_ifindex);
 211         diff |= NEIGH_DIFF(FAMILY,      a->n_family != b->n_family);
 212         diff |= NEIGH_DIFF(TYPE,        a->n_type != b->n_type);
 213         diff |= NEIGH_DIFF(LLADDR,      nl_addr_cmp(a->n_lladdr, b->n_lladdr));
 214         diff |= NEIGH_DIFF(DST,         nl_addr_cmp(a->n_dst, b->n_dst));
 215
 216         if (flags & LOOSE_FLAG_COMPARISON) {
 217                 diff |= NEIGH_DIFF(STATE,
 218                                   (a->n_state ^ b->n_state) & b->n_state_mask);
 219                 diff |= NEIGH_DIFF(FLAGS,
 220                                   (a->n_flags ^ b->n_flags) & b->n_flag_mask);
 221         } else {
 222                 diff |= NEIGH_DIFF(STATE, a->n_state != b->n_state);
 223                 diff |= NEIGH_DIFF(FLAGS, a->n_flags != b->n_flags);
 224         }
 225
 226 #undef NEIGH_DIFF
 227
 228         return diff;
 229 }
 230
 231 static struct trans_tbl neigh_attrs[] = {
 232         __ADD(NEIGH_ATTR_FLAGS, flags)
 233         __ADD(NEIGH_ATTR_STATE, state)
 234         __ADD(NEIGH_ATTR_LLADDR, lladdr)
 235         __ADD(NEIGH_ATTR_DST, dst)
 236         __ADD(NEIGH_ATTR_CACHEINFO, cacheinfo)
 237         __ADD(NEIGH_ATTR_IFINDEX, ifindex)
 238         __ADD(NEIGH_ATTR_FAMILY, family)
 239         __ADD(NEIGH_ATTR_TYPE, type)
 240         __ADD(NEIGH_ATTR_PROBES, probes)
 241 };
 242
 243 static char *neigh_attrs2str(int attrs, char *buf, size_t len)
 244 {
 245         return __flags2str(attrs, buf, len, neigh_attrs,
 246                            ARRAY_SIZE(neigh_attrs));
 247 }
 248
 249 static struct nla_policy neigh_policy[NDA_MAX+1] = {
 250         [NDA_CACHEINFO] = { .minlen = sizeof(struct nda_cacheinfo) },
 251         [NDA_PROBES]    = { .type = NLA_U32 },
 252 };
 253
 254 static int neigh_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 255                             struct nlmsghdr *n, struct nl_parser_param *pp)
 256 {
 257         struct rtnl_neigh *neigh;
 258         struct nlattr *tb[NDA_MAX + 1];
 259         struct ndmsg *nm;
 260         int err;
 261
 262         neigh = rtnl_neigh_alloc();
 263         if (!neigh) {
 264                 err = nl_errno(ENOMEM);
 265                 goto errout;
 266         }
 267
 268         neigh->ce_msgtype = n->nlmsg_type;
 269         nm = nlmsg_data(n);
 270
 271         err = nlmsg_parse(n, sizeof(*nm), tb, NDA_MAX, neigh_policy);
 272         if (err < 0)
 273                 goto errout;
 274
 275         neigh->n_family  = nm->ndm_family;
 276         neigh->n_ifindex = nm->ndm_ifindex;
 277         neigh->n_state   = nm->ndm_state;
 278         neigh->n_flags   = nm->ndm_flags;
 279         neigh->n_type    = nm->ndm_type;
 280
 281         neigh->ce_mask |= (NEIGH_ATTR_FAMILY | NEIGH_ATTR_IFINDEX |
 282                            NEIGH_ATTR_STATE | NEIGH_ATTR_FLAGS |
 283                            NEIGH_ATTR_TYPE);
 284
 285         if (tb[NDA_LLADDR]) {
 286                 neigh->n_lladdr = nla_get_addr(tb[NDA_LLADDR], AF_UNSPEC);
 287                 if (!neigh->n_lladdr)
 288                         goto errout;
 289                 nl_addr_set_family(neigh->n_lladdr,
 290                                    nl_addr_guess_family(neigh->n_lladdr));
 291                 neigh->ce_mask |= NEIGH_ATTR_LLADDR;
 292         }
 293
 294         if (tb[NDA_DST]) {
 295                 neigh->n_dst = nla_get_addr(tb[NDA_DST], neigh->n_family);
 296                 if (!neigh->n_dst)
 297                         goto errout;
 298                 neigh->ce_mask |= NEIGH_ATTR_DST;
 299         }
 300
 301         if (tb[NDA_CACHEINFO]) {
 302                 struct nda_cacheinfo *ci = nla_data(tb[NDA_CACHEINFO]);
 303
 304                 neigh->n_cacheinfo.nci_confirmed = ci->ndm_confirmed;
 305                 neigh->n_cacheinfo.nci_used = ci->ndm_used;
 306                 neigh->n_cacheinfo.nci_updated = ci->ndm_updated;
 307                 neigh->n_cacheinfo.nci_refcnt = ci->ndm_refcnt;
 308
 309                 neigh->ce_mask |= NEIGH_ATTR_CACHEINFO;
 310         }
 311
 312         if (tb[NDA_PROBES]) {
 313                 neigh->n_probes = nla_get_u32(tb[NDA_PROBES]);
 314                 neigh->ce_mask |= NEIGH_ATTR_PROBES;
 315         }
 316
 317         err = pp->pp_cb((struct nl_object *) neigh, pp);
 318         if (err < 0)
 319                 goto errout;
 320
 321         err = P_ACCEPT;
 322
 323 errout:
 324         rtnl_neigh_put(neigh);
 325         return err;
 326 }
 327
 328 static int neigh_request_update(struct nl_cache *c, struct nl_handle *h)
 329 {
 330         return nl_rtgen_request(h, RTM_GETNEIGH, AF_UNSPEC, NLM_F_DUMP);
 331 }
 332
 333
 334 static int neigh_dump_brief(struct nl_object *a, struct nl_dump_params *p)
 335 {
 336         char dst[INET6_ADDRSTRLEN+5], lladdr[INET6_ADDRSTRLEN+5];
 337         struct rtnl_neigh *n = (struct rtnl_neigh *) a;
 338         struct nl_cache *link_cache;
 339         char state[128], flags[64];
 340
 341         link_cache = nl_cache_mngt_require("route/link");
 342
 343         dp_dump(p, "%s ", nl_addr2str(n->n_dst, dst, sizeof(dst)));
 344
 345         if (link_cache)
 346                 dp_dump(p, "dev %s ",
 347                         rtnl_link_i2name(link_cache, n->n_ifindex,
 348                                          state, sizeof(state)));
 349         else
 350                 dp_dump(p, "dev %d ", n->n_ifindex);
 351
 352         if (n->ce_mask & NEIGH_ATTR_LLADDR)
 353                 dp_dump(p, "lladdr %s ",
 354                         nl_addr2str(n->n_lladdr, lladdr, sizeof(lladdr)));
 355
 356         rtnl_neigh_state2str(n->n_state, state, sizeof(state));
 357         rtnl_neigh_flags2str(n->n_flags, flags, sizeof(flags));
 358
 359         if (state[0])
 360                 dp_dump(p, "<%s", state);
 361         if (flags[0])
 362                 dp_dump(p, "%s%s", state[0] ? "," : "<", flags);
 363         if (state[0] || flags[0])
 364                 dp_dump(p, ">");
 365         dp_dump(p, "\n");
 366
 367         return 1;
 368 }
 369
 370 static int neigh_dump_full(struct nl_object *a, struct nl_dump_params *p)
 371 {
 372         char rtn_type[32];
 373         struct rtnl_neigh *n = (struct rtnl_neigh *) a;
 374         int hz = nl_get_hz();
 375
 376         int line = neigh_dump_brief(a, p);
 377
 378         dp_dump_line(p, line++, "    refcnt %u type %s confirmed %u used "
 379                                 "%u updated %u\n",
 380                 n->n_cacheinfo.nci_refcnt,
 381                 nl_rtntype2str(n->n_type, rtn_type, sizeof(rtn_type)),
 382                 n->n_cacheinfo.nci_confirmed/hz,
 383                 n->n_cacheinfo.nci_used/hz, n->n_cacheinfo.nci_updated/hz);
 384
 385         return line;
 386 }
 387
 388 static int neigh_dump_stats(struct nl_object *a, struct nl_dump_params *p)
 389 {
 390         return neigh_dump_full(a, p);
 391 }
 392
 393 static int neigh_dump_xml(struct nl_object *obj, struct nl_dump_params *p)
 394 {
 395         struct rtnl_neigh *neigh = (struct rtnl_neigh *) obj;
 396         char buf[128];
 397         int line = 0;
 398
 399         dp_dump_line(p, line++, "<neighbour>\n");
 400         dp_dump_line(p, line++, "  <family>%s</family>\n",
 401                      nl_af2str(neigh->n_family, buf, sizeof(buf)));
 402
 403         if (neigh->ce_mask & NEIGH_ATTR_LLADDR)
 404                 dp_dump_line(p, line++, "  <lladdr>%s</lladdr>\n",
 405                              nl_addr2str(neigh->n_lladdr, buf, sizeof(buf)));
 406
 407         if (neigh->ce_mask & NEIGH_ATTR_DST)
 408                 dp_dump_line(p, line++, "  <dst>%s</dst>\n",
 409                              nl_addr2str(neigh->n_dst, buf, sizeof(buf)));
 410
 411         if (neigh->ce_mask & NEIGH_ATTR_IFINDEX) {
 412                 struct nl_cache *link_cache;
 413
 414                 link_cache = nl_cache_mngt_require("route/link");
 415
 416                 if (link_cache)
 417                         dp_dump_line(p, line++, "  <device>%s</device>\n",
 418                                      rtnl_link_i2name(link_cache,
 419                                                       neigh->n_ifindex,
 420                                                       buf, sizeof(buf)));
 421                 else
 422                         dp_dump_line(p, line++, "  <device>%u</device>\n",
 423                                      neigh->n_ifindex);
 424         }
 425
 426         if (neigh->ce_mask & NEIGH_ATTR_PROBES)
 427                 dp_dump_line(p, line++, "  <probes>%u</probes>\n",
 428                              neigh->n_probes);
 429
 430         if (neigh->ce_mask & NEIGH_ATTR_TYPE)
 431                 dp_dump_line(p, line++, "  <type>%s</type>\n",
 432                              nl_rtntype2str(neigh->n_type, buf, sizeof(buf)));
 433
 434         rtnl_neigh_flags2str(neigh->n_flags, buf, sizeof(buf));
 435         if (buf[0])
 436                 dp_dump_line(p, line++, "  <flags>%s</flags>\n", buf);
 437
 438         rtnl_neigh_state2str(neigh->n_state, buf, sizeof(buf));
 439         if (buf[0])
 440                 dp_dump_line(p, line++, "  <state>%s</state>\n", buf);
 441
 442         dp_dump_line(p, line++, "</neighbour>\n");
 443
 444 #if 0
 445         struct rtnl_ncacheinfo n_cacheinfo;
 446 #endif
 447
 448         return line;
 449 }
 450
 451 static int neigh_dump_env(struct nl_object *obj, struct nl_dump_params *p)
 452 {
 453         struct rtnl_neigh *neigh = (struct rtnl_neigh *) obj;
 454         char buf[128];
 455         int line = 0;
 456
 457         dp_dump_line(p, line++, "NEIGH_FAMILY=%s\n",
 458                      nl_af2str(neigh->n_family, buf, sizeof(buf)));
 459
 460         if (neigh->ce_mask & NEIGH_ATTR_LLADDR)
 461                 dp_dump_line(p, line++, "NEIGHT_LLADDR=%s\n",
 462                              nl_addr2str(neigh->n_lladdr, buf, sizeof(buf)));
 463
 464         if (neigh->ce_mask & NEIGH_ATTR_DST)
 465                 dp_dump_line(p, line++, "NEIGH_DST=%s\n",
 466                              nl_addr2str(neigh->n_dst, buf, sizeof(buf)));
 467
 468         if (neigh->ce_mask & NEIGH_ATTR_IFINDEX) {
 469                 struct nl_cache *link_cache;
 470
 471                 dp_dump_line(p, line++, "NEIGH_IFINDEX=%u\n",
 472                              neigh->n_ifindex);
 473
 474                 link_cache = nl_cache_mngt_require("route/link");
 475                 if (link_cache)
 476                         dp_dump_line(p, line++, "NEIGH_IFNAME=%s\n",
 477                                      rtnl_link_i2name(link_cache,
 478                                                       neigh->n_ifindex,
 479                                                       buf, sizeof(buf)));
 480         }
 481
 482         if (neigh->ce_mask & NEIGH_ATTR_PROBES)
 483                 dp_dump_line(p, line++, "NEIGH_PROBES=%u\n",
 484                              neigh->n_probes);
 485
 486         if (neigh->ce_mask & NEIGH_ATTR_TYPE)
 487                 dp_dump_line(p, line++, "NEIGH_TYPE=%s\n",
 488                              nl_rtntype2str(neigh->n_type, buf, sizeof(buf)));
 489
 490         rtnl_neigh_flags2str(neigh->n_flags, buf, sizeof(buf));
 491         if (buf[0])
 492                 dp_dump_line(p, line++, "NEIGH_FLAGS=%s\n", buf);
 493
 494         rtnl_neigh_state2str(neigh->n_state, buf, sizeof(buf));
 495         if (buf[0])
 496                 dp_dump_line(p, line++, "NEIGH_STATE=%s\n", buf);
 497
 498         return line;
 499 }
 500
 501 /**
 502  * @name Neighbour Object Allocation/Freeage
 503  * @{
 504  */
 505
 506 struct rtnl_neigh *rtnl_neigh_alloc(void)
 507 {
 508         return (struct rtnl_neigh *) nl_object_alloc(&neigh_obj_ops);
 509 }
 510
 511 void rtnl_neigh_put(struct rtnl_neigh *neigh)
 512 {
 513         nl_object_put((struct nl_object *) neigh);
 514 }
 515
 516 /** @} */
 517
 518 /**
 519  * @name Neighbour Cache Managament
 520  * @{
 521  */
 522
 523 /**
 524  * Build a neighbour cache including all neighbours currently configured in the kernel.
 525  * @arg handle          netlink handle
 526  *
 527  * Allocates a new neighbour cache, initializes it properly and updates it
 528  * to include all neighbours currently configured in the kernel.
 529  *
 530  * @note The caller is responsible for destroying and freeing the
 531  *       cache after using it.
 532  * @return The new cache or NULL if an error occured.
 533  */
 534 struct nl_cache *rtnl_neigh_alloc_cache(struct nl_handle *handle)
 535 {
 536         struct nl_cache *cache;
 537
 538         cache = nl_cache_alloc(&rtnl_neigh_ops);
 539         if (cache == NULL)
 540                 return NULL;
 541
 542         if (handle && nl_cache_refill(handle, cache) < 0) {
 543                 nl_cache_free(cache);
 544                 return NULL;
 545         }
 546
 547         NL_DBG(2, "Returning new cache %p\n", cache);
 548
 549         return cache;
 550 }
 551
 552 /**
 553  * Look up a neighbour by interface index and destination address
 554  * @arg cache           neighbour cache
 555  * @arg ifindex         interface index the neighbour is on
 556  * @arg dst             destination address of the neighbour
 557  * @return neighbour handle or NULL if no match was found.
 558  */
 559 struct rtnl_neigh * rtnl_neigh_get(struct nl_cache *cache, int ifindex,
 560                                    struct nl_addr *dst)
 561 {
 562         struct rtnl_neigh *neigh;
 563
 564         nl_list_for_each_entry(neigh, &cache->c_items, ce_list) {
 565                 if (neigh->n_ifindex == ifindex &&
 566                     !nl_addr_cmp(neigh->n_dst, dst)) {
 567                         nl_object_get((struct nl_object *) neigh);
 568                         return neigh;
 569                 }
 570         }
 571
 572         return NULL;
 573 }
 574
 575 /** @} */
 576
 577 /**
 578  * @name Neighbour Addition
 579  * @{
 580  */
 581
 582 static struct nl_msg * build_neigh_msg(struct rtnl_neigh *tmpl, int cmd,
 583                                        int flags)
 584 {
 585         struct nl_msg *msg;
 586         struct ndmsg nhdr = {
 587                 .ndm_ifindex = tmpl->n_ifindex,
 588                 .ndm_family = nl_addr_get_family(tmpl->n_dst),
 589                 .ndm_state = NUD_PERMANENT,
 590         };
 591
 592         if (tmpl->ce_mask & NEIGH_ATTR_STATE)
 593                 nhdr.ndm_state = tmpl->n_state;
 594
 595         msg = nlmsg_alloc_simple(cmd, flags);
 596         if (!msg)
 597                 return NULL;
 598
 599         if (nlmsg_append(msg, &nhdr, sizeof(nhdr), NLMSG_ALIGNTO) < 0)
 600                 goto nla_put_failure;
 601
 602         NLA_PUT_ADDR(msg, NDA_DST, tmpl->n_dst);
 603
 604         if (tmpl->ce_mask & NEIGH_ATTR_LLADDR)
 605                 NLA_PUT_ADDR(msg, NDA_LLADDR, tmpl->n_lladdr);
 606
 607         return msg;
 608
 609 nla_put_failure:
 610         nlmsg_free(msg);
 611         return NULL;
 612 }
 613
 614 /**
 615  * Build netlink request message to add a new neighbour
 616  * @arg tmpl            template with data of new neighbour
 617  * @arg flags           additional netlink message flags
 618  *
 619  * Builds a new netlink message requesting a addition of a new
 620  * neighbour. The netlink message header isn't fully equipped with
 621  * all relevant fields and must thus be sent out via nl_send_auto_complete()
 622  * or supplemented as needed. \a tmpl must contain the attributes of the new
 623  * neighbour set via \c rtnl_neigh_set_* functions.
 624  *
 625  * The following attributes must be set in the template:
 626  *  - Interface index (rtnl_neigh_set_ifindex())
 627  *  - State (rtnl_neigh_set_state())
 628  *  - Destination address (rtnl_neigh_set_dst())
 629  *  - Link layer address (rtnl_neigh_set_lladdr())
 630  *
 631  * @return The netlink message
 632  */
 633 struct nl_msg * rtnl_neigh_build_add_request(struct rtnl_neigh *tmpl, int flags)
 634 {
 635         return build_neigh_msg(tmpl, RTM_NEWNEIGH, NLM_F_CREATE | flags);
 636 }
 637
 638 /**
 639  * Add a new neighbour
 640  * @arg handle          netlink handle
 641  * @arg tmpl            template with requested changes
 642  * @arg flags           additional netlink message flags
 643  *
 644  * Builds a netlink message by calling rtnl_neigh_build_add_request(),
 645  * sends the request to the kernel and waits for the next ACK to be
 646  * received and thus blocks until the request has been fullfilled.
 647  *
 648  * The following attributes must be set in the template:
 649  *  - Interface index (rtnl_neigh_set_ifindex())
 650  *  - State (rtnl_neigh_set_state())
 651  *  - Destination address (rtnl_neigh_set_dst())
 652  *  - Link layer address (rtnl_neigh_set_lladdr())
 653  *
 654  * @return 0 on sucess or a negative error if an error occured.
 655  */
 656 int rtnl_neigh_add(struct nl_handle *handle, struct rtnl_neigh *tmpl, int flags)
 657 {
 658         int err;
 659         struct nl_msg *msg;
 660
 661         msg = rtnl_neigh_build_add_request(tmpl, flags);
 662         if (!msg)
 663                 return nl_errno(ENOMEM);
 664
 665         err = nl_send_auto_complete(handle, msg);
 666         if (err < 0)
 667                 return err;
 668
 669         nlmsg_free(msg);
 670         return nl_wait_for_ack(handle);
 671 }
 672
 673 /** @} */
 674
 675 /**
 676  * @name Neighbour Deletion
 677  * @{
 678  */
 679
 680 /**
 681  * Build a netlink request message to delete a neighbour
 682  * @arg neigh           neighbour to delete
 683  * @arg flags           additional netlink message flags
 684  *
 685  * Builds a new netlink message requesting a deletion of a neighbour.
 686  * The netlink message header isn't fully equipped with all relevant
 687  * fields and must thus be sent out via nl_send_auto_complete()
 688  * or supplemented as needed. \a neigh must point to an existing
 689  * neighbour.
 690  *
 691  * @return The netlink message
 692  */
 693 struct nl_msg *rtnl_neigh_build_delete_request(struct rtnl_neigh *neigh,
 694                                                int flags)
 695 {
 696         return build_neigh_msg(neigh, RTM_DELNEIGH, flags);
 697 }
 698
 699 /**
 700  * Delete a neighbour
 701  * @arg handle          netlink handle
 702  * @arg neigh           neighbour to delete
 703  * @arg flags           additional netlink message flags
 704  *
 705  * Builds a netlink message by calling rtnl_neigh_build_delete_request(),
 706  * sends the request to the kernel and waits for the next ACK to be
 707  * received and thus blocks until the request has been fullfilled.
 708  *
 709  * @return 0 on sucess or a negative error if an error occured.
 710  */
 711 int rtnl_neigh_delete(struct nl_handle *handle, struct rtnl_neigh *neigh,
 712                       int flags)
 713 {
 714         int err;
 715         struct nl_msg *msg;
 716
 717         msg = rtnl_neigh_build_delete_request(neigh, flags);
 718         if (!msg)
 719                 return nl_errno(ENOMEM);
 720
 721         err = nl_send_auto_complete(handle, msg);
 722         if (err < 0)
 723                 return err;
 724
 725         nlmsg_free(msg);
 726         return nl_wait_for_ack(handle);
 727 }
 728
 729 /** @} */
 730
 731 /**
 732  * @name Neighbour Modification
 733  * @{
 734  */
 735
 736 /**
 737  * Build a netlink request message to change neighbour attributes
 738  * @arg neigh           the neighbour to change
 739  * @arg flags           additional netlink message flags
 740  *
 741  * Builds a new netlink message requesting a change of a neigh
 742  * attributes. The netlink message header isn't fully equipped with
 743  * all relevant fields and must thus be sent out via nl_send_auto_complete()
 744  * or supplemented as needed.
 745  *
 746  * @return The netlink message
 747  * @note Not all attributes can be changed, see
 748  *       \ref neigh_changeable "Changeable Attributes" for a list.
 749  */
 750 struct nl_msg *rtnl_neigh_build_change_request(struct rtnl_neigh *neigh,
 751                                                int flags)
 752 {
 753         return build_neigh_msg(neigh, RTM_NEWNEIGH, NLM_F_REPLACE | flags);
 754 }
 755
 756 /**
 757  * Change neighbour attributes
 758  * @arg handle          netlink handle
 759  * @arg neigh           neighbour to be changed
 760  * @arg flags           additional netlink message flags
 761  *
 762  * Builds a netlink message by calling rtnl_neigh_build_change_request(),
 763  * sends the request to the kernel and waits for the next ACK to be
 764  * received and thus blocks until the request has been fullfilled.
 765  *
 766  * @return 0 on sucess or a negative error if an error occured.
 767  * @note Not all attributes can be changed, see
 768  *       \ref neigh_changeable "Changeable Attributes" for a list.
 769  */
 770 int rtnl_neigh_change(struct nl_handle *handle, struct rtnl_neigh *neigh,
 771                       int flags)
 772 {
 773         int err;
 774         struct nl_msg *msg;
 775
 776         msg = rtnl_neigh_build_change_request(neigh, flags);
 777         if (!msg)
 778                 return nl_errno(ENOMEM);
 779
 780         err = nl_send_auto_complete(handle, msg);
 781         if (err < 0)
 782                 return err;
 783
 784         nlmsg_free(msg);
 785         return nl_wait_for_ack(handle);
 786 }
 787
 788 /** @} */
 789
 790 /**
 791  * @name Neighbour States Translations
 792  * @{
 793  */
 794
 795 static struct trans_tbl neigh_states[] = {
 796         __ADD(NUD_INCOMPLETE, incomplete)
 797         __ADD(NUD_REACHABLE, reachable)
 798         __ADD(NUD_STALE, stale)
 799         __ADD(NUD_DELAY, delay)
 800         __ADD(NUD_PROBE, probe)
 801         __ADD(NUD_FAILED, failed)
 802         __ADD(NUD_NOARP, norarp)
 803         __ADD(NUD_PERMANENT, permanent)
 804 };
 805
 806 char * rtnl_neigh_state2str(int state, char *buf, size_t len)
 807 {
 808         return __flags2str(state, buf, len, neigh_states,
 809             ARRAY_SIZE(neigh_states));
 810 }
 811
 812 int rtnl_neigh_str2state(const char *name)
 813 {
 814         return __str2type(name, neigh_states, ARRAY_SIZE(neigh_states));
 815 }
 816
 817 /** @} */
 818
 819 /**
 820  * @name Neighbour Flags Translations
 821  * @{
 822  */
 823
 824 static struct trans_tbl neigh_flags[] = {
 825         __ADD(NTF_PROXY, proxy)
 826         __ADD(NTF_ROUTER, router)
 827 };
 828
 829 char * rtnl_neigh_flags2str(int flags, char *buf, size_t len)
 830 {
 831         return __flags2str(flags, buf, len, neigh_flags,
 832             ARRAY_SIZE(neigh_flags));
 833 }
 834
 835 int rtnl_neigh_str2flag(const char *name)
 836 {
 837         return __str2type(name, neigh_flags, ARRAY_SIZE(neigh_flags));
 838 }
 839
 840 /** @} */
 841
 842 /**
 843  * @name Attributes
 844  * @{
 845  */
 846
 847 void rtnl_neigh_set_state(struct rtnl_neigh *neigh, int state)
 848 {
 849         neigh->n_state_mask |= state;
 850         neigh->n_state |= state;
 851         neigh->ce_mask |= NEIGH_ATTR_STATE;
 852 }
 853
 854 int rtnl_neigh_get_state(struct rtnl_neigh *neigh)
 855 {
 856         if (neigh->ce_mask & NEIGH_ATTR_STATE)
 857                 return neigh->n_state;
 858         else
 859                 return -1;
 860 }
 861
 862 void rtnl_neigh_unset_state(struct rtnl_neigh *neigh, int state)
 863 {
 864         neigh->n_state_mask |= state;
 865         neigh->n_state &= ~state;
 866         neigh->ce_mask |= NEIGH_ATTR_STATE;
 867 }
 868
 869 void rtnl_neigh_set_flags(struct rtnl_neigh *neigh, unsigned int flags)
 870 {
 871         neigh->n_flag_mask |= flags;
 872         neigh->n_flags |= flags;
 873         neigh->ce_mask |= NEIGH_ATTR_FLAGS;
 874 }
 875
 876 unsigned int rtnl_neigh_get_flags(struct rtnl_neigh *neigh)
 877 {
 878         return neigh->n_flags;
 879 }
 880
 881 void rtnl_neigh_unset_flags(struct rtnl_neigh *neigh, unsigned int flags)
 882 {
 883         neigh->n_flag_mask |= flags;
 884         neigh->n_flags &= ~flags;
 885         neigh->ce_mask |= NEIGH_ATTR_FLAGS;
 886 }
 887
 888 void rtnl_neigh_set_ifindex(struct rtnl_neigh *neigh, int ifindex)
 889 {
 890         neigh->n_ifindex = ifindex;
 891         neigh->ce_mask |= NEIGH_ATTR_IFINDEX;
 892 }
 893
 894 int rtnl_neigh_get_ifindex(struct rtnl_neigh *neigh)
 895 {
 896         if (neigh->ce_mask & NEIGH_ATTR_IFINDEX)
 897                 return neigh->n_ifindex;
 898         else
 899                 return RTNL_LINK_NOT_FOUND;
 900 }
 901
 902 static inline int __assign_addr(struct rtnl_neigh *neigh, struct nl_addr **pos,
 903                                 struct nl_addr *new, int flag, int nocheck)
 904 {
 905         if (!nocheck) {
 906                 if (neigh->ce_mask & NEIGH_ATTR_FAMILY) {
 907                         if (new->a_family != neigh->n_family)
 908                                 return nl_error(EINVAL,
 909                                                 "Address family mismatch");
 910                 } else {
 911                         neigh->n_family = new->a_family;
 912                         neigh->ce_mask |= NEIGH_ATTR_FAMILY;
 913                 }
 914         }
 915
 916         if (*pos)
 917                 nl_addr_put(*pos);
 918
 919         nl_addr_get(new);
 920         *pos = new;
 921
 922         neigh->ce_mask |= flag;
 923
 924         return 0;
 925 }
 926
 927 void rtnl_neigh_set_lladdr(struct rtnl_neigh *neigh, struct nl_addr *addr)
 928 {
 929         __assign_addr(neigh, &neigh->n_lladdr, addr, NEIGH_ATTR_LLADDR, 1);
 930 }
 931
 932 struct nl_addr *rtnl_neigh_get_lladdr(struct rtnl_neigh *neigh)
 933 {
 934         if (neigh->ce_mask & NEIGH_ATTR_LLADDR)
 935                 return neigh->n_lladdr;
 936         else
 937                 return NULL;
 938 }
 939
 940 int rtnl_neigh_set_dst(struct rtnl_neigh *neigh, struct nl_addr *addr)
 941 {
 942         return __assign_addr(neigh, &neigh->n_dst, addr,
 943                              NEIGH_ATTR_DST, 0);
 944 }
 945
 946 struct nl_addr *rtnl_neigh_get_dst(struct rtnl_neigh *neigh)
 947 {
 948         if (neigh->ce_mask & NEIGH_ATTR_DST)
 949                 return neigh->n_dst;
 950         else
 951                 return NULL;
 952 }
 953
 954 void rtnl_neigh_set_family(struct rtnl_neigh *neigh, int family)
 955 {
 956         neigh->n_family = family;
 957         neigh->ce_mask |= NEIGH_ATTR_FAMILY;
 958 }
 959
 960 void rtnl_neigh_set_type(struct rtnl_neigh *neigh, int type)
 961 {
 962         neigh->n_type = type;
 963         neigh->ce_mask = NEIGH_ATTR_TYPE;
 964 }
 965
 966 int rtnl_neigh_get_type(struct rtnl_neigh *neigh)
 967 {
 968         if (neigh->ce_mask & NEIGH_ATTR_TYPE)
 969                 return neigh->n_type;
 970         else
 971                 return -1;
 972 }
 973
 974 /** @} */
 975
 976 static struct nl_object_ops neigh_obj_ops = {
 977         .oo_name                = "route/neigh",
 978         .oo_size                = sizeof(struct rtnl_neigh),
 979         .oo_free_data           = neigh_free_data,
 980         .oo_clone               = neigh_clone,
 981         .oo_dump[NL_DUMP_BRIEF] = neigh_dump_brief,
 982         .oo_dump[NL_DUMP_FULL]  = neigh_dump_full,
 983         .oo_dump[NL_DUMP_STATS] = neigh_dump_stats,
 984         .oo_dump[NL_DUMP_XML]   = neigh_dump_xml,
 985         .oo_dump[NL_DUMP_ENV]   = neigh_dump_env,
 986         .oo_compare             = neigh_compare,
 987         .oo_attrs2str           = neigh_attrs2str,
 988         .oo_id_attrs            = (NEIGH_ATTR_DST | NEIGH_ATTR_FAMILY),
 989 };
 990
 991 static struct nl_af_group neigh_groups[] = {
 992         { AF_UNSPEC, RTNLGRP_NEIGH },
 993         { END_OF_GROUP_LIST },
 994 };
 995
 996 static struct nl_cache_ops rtnl_neigh_ops = {
 997         .co_name                = "route/neigh",
 998         .co_hdrsize             = sizeof(struct ndmsg),
 999         .co_msgtypes            = {
1000                                         { RTM_NEWNEIGH, NL_ACT_NEW, "new" },
1001                                         { RTM_DELNEIGH, NL_ACT_DEL, "del" },
1002                                         { RTM_GETNEIGH, NL_ACT_GET, "get" },
1003                                         END_OF_MSGTYPES_LIST,
1004                                   },
1005         .co_protocol            = NETLINK_ROUTE,
1006         .co_groups              = neigh_groups,
1007         .co_request_update      = neigh_request_update,
1008         .co_msg_parser          = neigh_msg_parser,
1009         .co_obj_ops             = &neigh_obj_ops,
1010 };
1011
1012 static void __init neigh_init(void)
1013 {
1014         nl_cache_mngt_register(&rtnl_neigh_ops);
1015 }
1016
1017 static void __exit neigh_exit(void)
1018 {
1019         nl_cache_mngt_unregister(&rtnl_neigh_ops);
1020 }
1021
1022 /** @} */