libnl  3.2.21
addr.c
1 /*
2  * lib/route/addr.c Addresses
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-2012 Thomas Graf <tgraf@suug.ch>
10  * Copyright (c) 2003-2006 Baruch Even <baruch@ev-en.org>,
11  * Mediatrix Telecom, inc. <ericb@mediatrix.com>
12  */
13 
14 /**
15  * @ingroup rtnl
16  * @defgroup rtaddr Addresses
17  * @brief
18  *
19  * @note The maximum size of an address label is IFNAMSIZ.
20  *
21  * @note The address may not contain a prefix length if the peer address
22  * has been specified already.
23  *
24  * @par 1) Address Addition
25  * @code
26  * // Allocate an empty address object to be filled out with the attributes
27  * // of the new address.
28  * struct rtnl_addr *addr = rtnl_addr_alloc();
29  *
30  * // Fill out the mandatory attributes of the new address. Setting the
31  * // local address will automatically set the address family and the
32  * // prefix length to the correct values.
33  * rtnl_addr_set_ifindex(addr, ifindex);
34  * rtnl_addr_set_local(addr, local_addr);
35  *
36  * // The label of the address can be specified, currently only supported
37  * // by IPv4 and DECnet.
38  * rtnl_addr_set_label(addr, "mylabel");
39  *
40  * // The peer address can be specified if necessary, in either case a peer
41  * // address will be sent to the kernel in order to fullfil the interface
42  * // requirements. If none is set, it will equal the local address.
43  * // Note: Real peer addresses are only supported by IPv4 for now.
44  * rtnl_addr_set_peer(addr, peer_addr);
45  *
46  * // In case you want to have the address have a scope other than global
47  * // it may be overwritten using rtnl_addr_set_scope(). The scope currently
48  * // cannot be set for IPv6 addresses.
49  * rtnl_addr_set_scope(addr, rtnl_str2scope("site"));
50  *
51  * // Broadcast address may be specified using the relevant
52  * // functions, the address family will be verified if one of the other
53  * // addresses has been set already. Currently only works for IPv4.
54  * rtnl_addr_set_broadcast(addr, broadcast_addr);
55  *
56  * // Build the netlink message and send it to the kernel, the operation will
57  * // block until the operation has been completed. Alternatively the required
58  * // netlink message can be built using rtnl_addr_build_add_request() to be
59  * // sent out using nl_send_auto_complete().
60  * rtnl_addr_add(sk, addr, 0);
61  *
62  * // Free the memory
63  * rtnl_addr_put(addr);
64  * @endcode
65  *
66  * @par 2) Address Deletion
67  * @code
68  * // Allocate an empty address object to be filled out with the attributes
69  * // matching the address to be deleted. Alternatively a fully equipped
70  * // address object out of a cache can be used instead.
71  * struct rtnl_addr *addr = rtnl_addr_alloc();
72  *
73  * // The only mandatory parameter besides the address family is the interface
74  * // index the address is on, i.e. leaving out all other parameters will
75  * // result in all addresses of the specified address family interface tuple
76  * // to be deleted.
77  * rtnl_addr_set_ifindex(addr, ifindex);
78  *
79  * // Specyfing the address family manually is only required if neither the
80  * // local nor peer address have been specified.
81  * rtnl_addr_set_family(addr, AF_INET);
82  *
83  * // Specyfing the local address is optional but the best choice to delete
84  * // specific addresses.
85  * rtnl_addr_set_local(addr, local_addr);
86  *
87  * // The label of the address can be specified, currently only supported
88  * // by IPv4 and DECnet.
89  * rtnl_addr_set_label(addr, "mylabel");
90  *
91  * // The peer address can be specified if necessary, in either case a peer
92  * // address will be sent to the kernel in order to fullfil the interface
93  * // requirements. If none is set, it will equal the local address.
94  * // Note: Real peer addresses are only supported by IPv4 for now.
95  * rtnl_addr_set_peer(addr, peer_addr);
96  *
97  * // Build the netlink message and send it to the kernel, the operation will
98  * // block until the operation has been completed. Alternatively the required
99  * // netlink message can be built using rtnl_addr_build_delete_request()
100  * // to be sent out using nl_send_auto_complete().
101  * rtnl_addr_delete(sk, addr, 0);
102  *
103  * // Free the memory
104  * rtnl_addr_put(addr);
105  * @endcode
106  * @{
107  */
108 
109 #include <netlink-private/netlink.h>
110 #include <netlink/netlink.h>
111 #include <netlink/route/rtnl.h>
112 #include <netlink/route/addr.h>
113 #include <netlink/route/route.h>
114 #include <netlink/route/link.h>
115 #include <netlink/utils.h>
116 
117 /** @cond SKIP */
118 #define ADDR_ATTR_FAMILY 0x0001
119 #define ADDR_ATTR_PREFIXLEN 0x0002
120 #define ADDR_ATTR_FLAGS 0x0004
121 #define ADDR_ATTR_SCOPE 0x0008
122 #define ADDR_ATTR_IFINDEX 0x0010
123 #define ADDR_ATTR_LABEL 0x0020
124 #define ADDR_ATTR_CACHEINFO 0x0040
125 #define ADDR_ATTR_PEER 0x0080
126 #define ADDR_ATTR_LOCAL 0x0100
127 #define ADDR_ATTR_BROADCAST 0x0200
128 #define ADDR_ATTR_MULTICAST 0x0400
129 #define ADDR_ATTR_ANYCAST 0x0800
130 
131 static struct nl_cache_ops rtnl_addr_ops;
132 static struct nl_object_ops addr_obj_ops;
133 /** @endcond */
134 
135 static void addr_constructor(struct nl_object *obj)
136 {
137  struct rtnl_addr *addr = nl_object_priv(obj);
138 
139  addr->a_scope = RT_SCOPE_NOWHERE;
140 }
141 
142 static void addr_free_data(struct nl_object *obj)
143 {
144  struct rtnl_addr *addr = nl_object_priv(obj);
145 
146  if (!addr)
147  return;
148 
149  nl_addr_put(addr->a_peer);
150  nl_addr_put(addr->a_local);
151  nl_addr_put(addr->a_bcast);
152  nl_addr_put(addr->a_multicast);
153  nl_addr_put(addr->a_anycast);
154  rtnl_link_put(addr->a_link);
155 }
156 
157 static int addr_clone(struct nl_object *_dst, struct nl_object *_src)
158 {
159  struct rtnl_addr *dst = nl_object_priv(_dst);
160  struct rtnl_addr *src = nl_object_priv(_src);
161 
162  if (src->a_link) {
163  nl_object_get(OBJ_CAST(src->a_link));
164  dst->a_link = src->a_link;
165  }
166 
167  if (src->a_peer)
168  if (!(dst->a_peer = nl_addr_clone(src->a_peer)))
169  return -NLE_NOMEM;
170 
171  if (src->a_local)
172  if (!(dst->a_local = nl_addr_clone(src->a_local)))
173  return -NLE_NOMEM;
174 
175  if (src->a_bcast)
176  if (!(dst->a_bcast = nl_addr_clone(src->a_bcast)))
177  return -NLE_NOMEM;
178 
179  if (src->a_multicast)
180  if (!(dst->a_multicast = nl_addr_clone(src->a_multicast)))
181  return -NLE_NOMEM;
182 
183  if (src->a_anycast)
184  if (!(dst->a_anycast = nl_addr_clone(src->a_anycast)))
185  return -NLE_NOMEM;
186 
187  return 0;
188 }
189 
190 static struct nla_policy addr_policy[IFA_MAX+1] = {
191  [IFA_LABEL] = { .type = NLA_STRING,
192  .maxlen = IFNAMSIZ },
193  [IFA_CACHEINFO] = { .minlen = sizeof(struct ifa_cacheinfo) },
194 };
195 
196 static int addr_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
197  struct nlmsghdr *nlh, struct nl_parser_param *pp)
198 {
199  struct rtnl_addr *addr;
200  struct ifaddrmsg *ifa;
201  struct nlattr *tb[IFA_MAX+1];
202  int err, family;
203  struct nl_cache *link_cache;
204  struct nl_addr *plen_addr = NULL;
205 
206  addr = rtnl_addr_alloc();
207  if (!addr)
208  return -NLE_NOMEM;
209 
210  addr->ce_msgtype = nlh->nlmsg_type;
211 
212  err = nlmsg_parse(nlh, sizeof(*ifa), tb, IFA_MAX, addr_policy);
213  if (err < 0)
214  goto errout;
215 
216  ifa = nlmsg_data(nlh);
217  addr->a_family = family = ifa->ifa_family;
218  addr->a_prefixlen = ifa->ifa_prefixlen;
219  addr->a_flags = ifa->ifa_flags;
220  addr->a_scope = ifa->ifa_scope;
221  addr->a_ifindex = ifa->ifa_index;
222 
223  addr->ce_mask = (ADDR_ATTR_FAMILY | ADDR_ATTR_PREFIXLEN |
224  ADDR_ATTR_FLAGS | ADDR_ATTR_SCOPE | ADDR_ATTR_IFINDEX);
225 
226  if (tb[IFA_LABEL]) {
227  nla_strlcpy(addr->a_label, tb[IFA_LABEL], IFNAMSIZ);
228  addr->ce_mask |= ADDR_ATTR_LABEL;
229  }
230 
231  /* IPv6 only */
232  if (tb[IFA_CACHEINFO]) {
233  struct ifa_cacheinfo *ca;
234 
235  ca = nla_data(tb[IFA_CACHEINFO]);
236  addr->a_cacheinfo.aci_prefered = ca->ifa_prefered;
237  addr->a_cacheinfo.aci_valid = ca->ifa_valid;
238  addr->a_cacheinfo.aci_cstamp = ca->cstamp;
239  addr->a_cacheinfo.aci_tstamp = ca->tstamp;
240  addr->ce_mask |= ADDR_ATTR_CACHEINFO;
241  }
242 
243  if (tb[IFA_LOCAL]) {
244  addr->a_local = nl_addr_alloc_attr(tb[IFA_LOCAL], family);
245  if (!addr->a_local)
246  goto errout_nomem;
247  addr->ce_mask |= ADDR_ATTR_LOCAL;
248  plen_addr = addr->a_local;
249  }
250 
251  if (tb[IFA_ADDRESS]) {
252  struct nl_addr *a;
253 
254  a = nl_addr_alloc_attr(tb[IFA_ADDRESS], family);
255  if (!a)
256  goto errout_nomem;
257 
258  /* IPv6 sends the local address as IFA_ADDRESS with
259  * no IFA_LOCAL, IPv4 sends both IFA_LOCAL and IFA_ADDRESS
260  * with IFA_ADDRESS being the peer address if they differ */
261  if (!tb[IFA_LOCAL] || !nl_addr_cmp(a, addr->a_local)) {
262  nl_addr_put(addr->a_local);
263  addr->a_local = a;
264  addr->ce_mask |= ADDR_ATTR_LOCAL;
265  } else {
266  addr->a_peer = a;
267  addr->ce_mask |= ADDR_ATTR_PEER;
268  }
269 
270  plen_addr = a;
271  }
272 
273  if (plen_addr)
274  nl_addr_set_prefixlen(plen_addr, addr->a_prefixlen);
275 
276  /* IPv4 only */
277  if (tb[IFA_BROADCAST]) {
278  addr->a_bcast = nl_addr_alloc_attr(tb[IFA_BROADCAST], family);
279  if (!addr->a_bcast)
280  goto errout_nomem;
281 
282  addr->ce_mask |= ADDR_ATTR_BROADCAST;
283  }
284 
285  /* IPv6 only */
286  if (tb[IFA_MULTICAST]) {
287  addr->a_multicast = nl_addr_alloc_attr(tb[IFA_MULTICAST],
288  family);
289  if (!addr->a_multicast)
290  goto errout_nomem;
291 
292  addr->ce_mask |= ADDR_ATTR_MULTICAST;
293  }
294 
295  /* IPv6 only */
296  if (tb[IFA_ANYCAST]) {
297  addr->a_anycast = nl_addr_alloc_attr(tb[IFA_ANYCAST],
298  family);
299  if (!addr->a_anycast)
300  goto errout_nomem;
301 
302  addr->ce_mask |= ADDR_ATTR_ANYCAST;
303  }
304 
305  if ((link_cache = __nl_cache_mngt_require("route/link"))) {
306  struct rtnl_link *link;
307 
308  if ((link = rtnl_link_get(link_cache, addr->a_ifindex))) {
309  rtnl_addr_set_link(addr, link);
310 
311  /* rtnl_addr_set_link incs refcnt */
312  rtnl_link_put(link);
313  }
314  }
315 
316  err = pp->pp_cb((struct nl_object *) addr, pp);
317 errout:
318  rtnl_addr_put(addr);
319 
320  return err;
321 
322 errout_nomem:
323  err = -NLE_NOMEM;
324  goto errout;
325 }
326 
327 static int addr_request_update(struct nl_cache *cache, struct nl_sock *sk)
328 {
329  return nl_rtgen_request(sk, RTM_GETADDR, AF_UNSPEC, NLM_F_DUMP);
330 }
331 
332 static void addr_dump_line(struct nl_object *obj, struct nl_dump_params *p)
333 {
334  struct rtnl_addr *addr = (struct rtnl_addr *) obj;
335  struct nl_cache *link_cache;
336  char buf[128];
337 
338  link_cache = nl_cache_mngt_require_safe("route/link");
339 
340  if (addr->ce_mask & ADDR_ATTR_LOCAL)
341  nl_dump_line(p, "%s",
342  nl_addr2str(addr->a_local, buf, sizeof(buf)));
343  else
344  nl_dump_line(p, "none");
345 
346  if (addr->ce_mask & ADDR_ATTR_PEER)
347  nl_dump(p, " peer %s",
348  nl_addr2str(addr->a_peer, buf, sizeof(buf)));
349 
350  nl_dump(p, " %s ", nl_af2str(addr->a_family, buf, sizeof(buf)));
351 
352  if (link_cache)
353  nl_dump(p, "dev %s ",
354  rtnl_link_i2name(link_cache, addr->a_ifindex,
355  buf, sizeof(buf)));
356  else
357  nl_dump(p, "dev %d ", addr->a_ifindex);
358 
359  nl_dump(p, "scope %s",
360  rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
361 
362  rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
363  if (buf[0])
364  nl_dump(p, " <%s>", buf);
365 
366  nl_dump(p, "\n");
367 
368  if (link_cache)
369  nl_cache_put(link_cache);
370 }
371 
372 static void addr_dump_details(struct nl_object *obj, struct nl_dump_params *p)
373 {
374  struct rtnl_addr *addr = (struct rtnl_addr *) obj;
375  char buf[128];
376 
377  addr_dump_line(obj, p);
378 
379  if (addr->ce_mask & (ADDR_ATTR_LABEL | ADDR_ATTR_BROADCAST |
380  ADDR_ATTR_MULTICAST)) {
381  nl_dump_line(p, " ");
382 
383  if (addr->ce_mask & ADDR_ATTR_LABEL)
384  nl_dump(p, " label %s", addr->a_label);
385 
386  if (addr->ce_mask & ADDR_ATTR_BROADCAST)
387  nl_dump(p, " broadcast %s",
388  nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
389 
390  if (addr->ce_mask & ADDR_ATTR_MULTICAST)
391  nl_dump(p, " multicast %s",
392  nl_addr2str(addr->a_multicast, buf,
393  sizeof(buf)));
394 
395  if (addr->ce_mask & ADDR_ATTR_ANYCAST)
396  nl_dump(p, " anycast %s",
397  nl_addr2str(addr->a_anycast, buf,
398  sizeof(buf)));
399 
400  nl_dump(p, "\n");
401  }
402 
403  if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
404  struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
405 
406  nl_dump_line(p, " valid-lifetime %s",
407  ci->aci_valid == 0xFFFFFFFFU ? "forever" :
408  nl_msec2str(ci->aci_valid * 1000,
409  buf, sizeof(buf)));
410 
411  nl_dump(p, " preferred-lifetime %s\n",
412  ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
413  nl_msec2str(ci->aci_prefered * 1000,
414  buf, sizeof(buf)));
415 
416  nl_dump_line(p, " created boot-time+%s ",
417  nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
418  buf, sizeof(buf)));
419 
420  nl_dump(p, "last-updated boot-time+%s\n",
421  nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
422  buf, sizeof(buf)));
423  }
424 }
425 
426 static void addr_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
427 {
428  addr_dump_details(obj, p);
429 }
430 
431 static int addr_compare(struct nl_object *_a, struct nl_object *_b,
432  uint32_t attrs, int flags)
433 {
434  struct rtnl_addr *a = (struct rtnl_addr *) _a;
435  struct rtnl_addr *b = (struct rtnl_addr *) _b;
436  int diff = 0;
437 
438 #define ADDR_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ADDR_ATTR_##ATTR, a, b, EXPR)
439 
440  diff |= ADDR_DIFF(IFINDEX, a->a_ifindex != b->a_ifindex);
441  diff |= ADDR_DIFF(FAMILY, a->a_family != b->a_family);
442  diff |= ADDR_DIFF(SCOPE, a->a_scope != b->a_scope);
443  diff |= ADDR_DIFF(LABEL, strcmp(a->a_label, b->a_label));
444  diff |= ADDR_DIFF(PEER, nl_addr_cmp(a->a_peer, b->a_peer));
445  diff |= ADDR_DIFF(LOCAL, nl_addr_cmp(a->a_local, b->a_local));
446  diff |= ADDR_DIFF(MULTICAST, nl_addr_cmp(a->a_multicast,
447  b->a_multicast));
448  diff |= ADDR_DIFF(BROADCAST, nl_addr_cmp(a->a_bcast, b->a_bcast));
449  diff |= ADDR_DIFF(ANYCAST, nl_addr_cmp(a->a_anycast, b->a_anycast));
450 
451  if (flags & LOOSE_COMPARISON)
452  diff |= ADDR_DIFF(FLAGS,
453  (a->a_flags ^ b->a_flags) & b->a_flag_mask);
454  else
455  diff |= ADDR_DIFF(FLAGS, a->a_flags != b->a_flags);
456 
457 #undef ADDR_DIFF
458 
459  return diff;
460 }
461 
462 static const struct trans_tbl addr_attrs[] = {
463  __ADD(ADDR_ATTR_FAMILY, family)
464  __ADD(ADDR_ATTR_PREFIXLEN, prefixlen)
465  __ADD(ADDR_ATTR_FLAGS, flags)
466  __ADD(ADDR_ATTR_SCOPE, scope)
467  __ADD(ADDR_ATTR_IFINDEX, ifindex)
468  __ADD(ADDR_ATTR_LABEL, label)
469  __ADD(ADDR_ATTR_CACHEINFO, cacheinfo)
470  __ADD(ADDR_ATTR_PEER, peer)
471  __ADD(ADDR_ATTR_LOCAL, local)
472  __ADD(ADDR_ATTR_BROADCAST, broadcast)
473  __ADD(ADDR_ATTR_MULTICAST, multicast)
474 };
475 
476 static char *addr_attrs2str(int attrs, char *buf, size_t len)
477 {
478  return __flags2str(attrs, buf, len, addr_attrs,
479  ARRAY_SIZE(addr_attrs));
480 }
481 
482 /**
483  * @name Allocation/Freeing
484  * @{
485  */
486 
487 struct rtnl_addr *rtnl_addr_alloc(void)
488 {
489  return (struct rtnl_addr *) nl_object_alloc(&addr_obj_ops);
490 }
491 
492 void rtnl_addr_put(struct rtnl_addr *addr)
493 {
494  nl_object_put((struct nl_object *) addr);
495 }
496 
497 /** @} */
498 
499 /**
500  * @name Cache Management
501  * @{
502  */
503 
504 int rtnl_addr_alloc_cache(struct nl_sock *sk, struct nl_cache **result)
505 {
506  return nl_cache_alloc_and_fill(&rtnl_addr_ops, sk, result);
507 }
508 
509 /**
510  * Search address in cache
511  * @arg cache Address cache
512  * @arg ifindex Interface index of address
513  * @arg addr Local address part
514  *
515  * Searches address cache previously allocated with rtnl_addr_alloc_cache()
516  * for an address with a matching local address.
517  *
518  * The reference counter is incremented before returning the address, therefore
519  * the reference must be given back with rtnl_addr_put() after usage.
520  *
521  * @return Address object or NULL if no match was found.
522  */
523 struct rtnl_addr *rtnl_addr_get(struct nl_cache *cache, int ifindex,
524  struct nl_addr *addr)
525 {
526  struct rtnl_addr *a;
527 
528  if (cache->c_ops != &rtnl_addr_ops)
529  return NULL;
530 
531  nl_list_for_each_entry(a, &cache->c_items, ce_list) {
532  if (ifindex && a->a_ifindex != ifindex)
533  continue;
534 
535  if (a->ce_mask & ADDR_ATTR_LOCAL &&
536  !nl_addr_cmp(a->a_local, addr)) {
537  nl_object_get((struct nl_object *) a);
538  return a;
539  }
540  }
541 
542  return NULL;
543 }
544 
545 /** @} */
546 
547 static int build_addr_msg(struct rtnl_addr *tmpl, int cmd, int flags,
548  struct nl_msg **result)
549 {
550  struct nl_msg *msg;
551  struct ifaddrmsg am = {
552  .ifa_family = tmpl->a_family,
553  .ifa_index = tmpl->a_ifindex,
554  .ifa_prefixlen = tmpl->a_prefixlen,
555  };
556 
557  if (tmpl->ce_mask & ADDR_ATTR_SCOPE)
558  am.ifa_scope = tmpl->a_scope;
559  else {
560  /* compatibility hack */
561  if (tmpl->a_family == AF_INET &&
562  tmpl->ce_mask & ADDR_ATTR_LOCAL &&
563  *((char *) nl_addr_get_binary_addr(tmpl->a_local)) == 127)
564  am.ifa_scope = RT_SCOPE_HOST;
565  else
566  am.ifa_scope = RT_SCOPE_UNIVERSE;
567  }
568 
569  msg = nlmsg_alloc_simple(cmd, flags);
570  if (!msg)
571  return -NLE_NOMEM;
572 
573  if (nlmsg_append(msg, &am, sizeof(am), NLMSG_ALIGNTO) < 0)
574  goto nla_put_failure;
575 
576  if (tmpl->ce_mask & ADDR_ATTR_LOCAL)
577  NLA_PUT_ADDR(msg, IFA_LOCAL, tmpl->a_local);
578 
579  if (tmpl->ce_mask & ADDR_ATTR_PEER)
580  NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_peer);
581  else if (tmpl->ce_mask & ADDR_ATTR_LOCAL)
582  NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_local);
583 
584  if (tmpl->ce_mask & ADDR_ATTR_LABEL)
585  NLA_PUT_STRING(msg, IFA_LABEL, tmpl->a_label);
586 
587  if (tmpl->ce_mask & ADDR_ATTR_BROADCAST)
588  NLA_PUT_ADDR(msg, IFA_BROADCAST, tmpl->a_bcast);
589 
590  if (tmpl->ce_mask & ADDR_ATTR_CACHEINFO) {
591  struct ifa_cacheinfo ca = {
592  .ifa_valid = tmpl->a_cacheinfo.aci_valid,
593  .ifa_prefered = tmpl->a_cacheinfo.aci_prefered,
594  };
595 
596  NLA_PUT(msg, IFA_CACHEINFO, sizeof(ca), &ca);
597  }
598 
599 
600  *result = msg;
601  return 0;
602 
603 nla_put_failure:
604  nlmsg_free(msg);
605  return -NLE_MSGSIZE;
606 }
607 
608 /**
609  * @name Addition
610  * @{
611  */
612 
613 /**
614  * Build netlink request message to request addition of new address
615  * @arg addr Address object representing the new address.
616  * @arg flags Additional netlink message flags.
617  * @arg result Pointer to store resulting message.
618  *
619  * Builds a new netlink message requesting the addition of a new
620  * address. 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.
623  *
624  * Minimal required attributes:
625  * - interface index (rtnl_addr_set_ifindex())
626  * - local address (rtnl_addr_set_local())
627  *
628  * The scope will default to universe except for loopback addresses in
629  * which case a host scope is used if not specified otherwise.
630  *
631  * @note Free the memory after usage using nlmsg_free().
632  *
633  * @return 0 on success or a negative error code.
634  */
635 int rtnl_addr_build_add_request(struct rtnl_addr *addr, int flags,
636  struct nl_msg **result)
637 {
638  uint32_t required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY |
639  ADDR_ATTR_PREFIXLEN | ADDR_ATTR_LOCAL;
640 
641  if ((addr->ce_mask & required) != required)
642  return -NLE_MISSING_ATTR;
643 
644  return build_addr_msg(addr, RTM_NEWADDR, NLM_F_CREATE | flags, result);
645 }
646 
647 /**
648  * Request addition of new address
649  * @arg sk Netlink socket.
650  * @arg addr Address object representing the new address.
651  * @arg flags Additional netlink message flags.
652  *
653  * Builds a netlink message by calling rtnl_addr_build_add_request(),
654  * sends the request to the kernel and waits for the next ACK to be
655  * received and thus blocks until the request has been fullfilled.
656  *
657  * @see rtnl_addr_build_add_request()
658  *
659  * @return 0 on sucess or a negative error if an error occured.
660  */
661 int rtnl_addr_add(struct nl_sock *sk, struct rtnl_addr *addr, int flags)
662 {
663  struct nl_msg *msg;
664  int err;
665 
666  if ((err = rtnl_addr_build_add_request(addr, flags, &msg)) < 0)
667  return err;
668 
669  err = nl_send_auto_complete(sk, msg);
670  nlmsg_free(msg);
671  if (err < 0)
672  return err;
673 
674  return wait_for_ack(sk);
675 }
676 
677 /** @} */
678 
679 /**
680  * @name Deletion
681  * @{
682  */
683 
684 /**
685  * Build a netlink request message to request deletion of an address
686  * @arg addr Address object to be deleteted.
687  * @arg flags Additional netlink message flags.
688  * @arg result Pointer to store resulting message.
689  *
690  * Builds a new netlink message requesting a deletion of an address.
691  * The netlink message header isn't fully equipped with all relevant
692  * fields and must thus be sent out via nl_send_auto_complete()
693  * or supplemented as needed.
694  *
695  * Minimal required attributes:
696  * - interface index (rtnl_addr_set_ifindex())
697  * - address family (rtnl_addr_set_family())
698  *
699  * Optional attributes:
700  * - local address (rtnl_addr_set_local())
701  * - label (rtnl_addr_set_label(), IPv4/DECnet only)
702  * - peer address (rtnl_addr_set_peer(), IPv4 only)
703  *
704  * @note Free the memory after usage using nlmsg_free().
705  *
706  * @return 0 on success or a negative error code.
707  */
708 int rtnl_addr_build_delete_request(struct rtnl_addr *addr, int flags,
709  struct nl_msg **result)
710 {
711  uint32_t required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY;
712 
713  if ((addr->ce_mask & required) != required)
714  return -NLE_MISSING_ATTR;
715 
716  return build_addr_msg(addr, RTM_DELADDR, flags, result);
717 }
718 
719 /**
720  * Request deletion of an address
721  * @arg sk Netlink socket.
722  * @arg addr Address object to be deleted.
723  * @arg flags Additional netlink message flags.
724  *
725  * Builds a netlink message by calling rtnl_addr_build_delete_request(),
726  * sends the request to the kernel and waits for the next ACK to be
727  * received and thus blocks until the request has been fullfilled.
728  *
729  * @see rtnl_addr_build_delete_request();
730  *
731  * @return 0 on sucess or a negative error if an error occured.
732  */
733 int rtnl_addr_delete(struct nl_sock *sk, struct rtnl_addr *addr, int flags)
734 {
735  struct nl_msg *msg;
736  int err;
737 
738  if ((err = rtnl_addr_build_delete_request(addr, flags, &msg)) < 0)
739  return err;
740 
741  err = nl_send_auto_complete(sk, msg);
742  nlmsg_free(msg);
743  if (err < 0)
744  return err;
745 
746  return wait_for_ack(sk);
747 }
748 
749 /** @} */
750 
751 /**
752  * @name Attributes
753  * @{
754  */
755 
756 int rtnl_addr_set_label(struct rtnl_addr *addr, const char *label)
757 {
758  if (strlen(label) > sizeof(addr->a_label) - 1)
759  return -NLE_RANGE;
760 
761  strcpy(addr->a_label, label);
762  addr->ce_mask |= ADDR_ATTR_LABEL;
763 
764  return 0;
765 }
766 
767 char *rtnl_addr_get_label(struct rtnl_addr *addr)
768 {
769  if (addr->ce_mask & ADDR_ATTR_LABEL)
770  return addr->a_label;
771  else
772  return NULL;
773 }
774 
775 void rtnl_addr_set_ifindex(struct rtnl_addr *addr, int ifindex)
776 {
777  addr->a_ifindex = ifindex;
778  addr->ce_mask |= ADDR_ATTR_IFINDEX;
779 }
780 
781 int rtnl_addr_get_ifindex(struct rtnl_addr *addr)
782 {
783  return addr->a_ifindex;
784 }
785 
786 void rtnl_addr_set_link(struct rtnl_addr *addr, struct rtnl_link *link)
787 {
788  rtnl_link_put(addr->a_link);
789 
790  if (!link)
791  return;
792 
793  nl_object_get(OBJ_CAST(link));
794  addr->a_link = link;
795  addr->a_ifindex = link->l_index;
796  addr->ce_mask |= ADDR_ATTR_IFINDEX;
797 }
798 
799 struct rtnl_link *rtnl_addr_get_link(struct rtnl_addr *addr)
800 {
801  if (addr->a_link) {
802  nl_object_get(OBJ_CAST(addr->a_link));
803  return addr->a_link;
804  }
805 
806  return NULL;
807 }
808 
809 void rtnl_addr_set_family(struct rtnl_addr *addr, int family)
810 {
811  addr->a_family = family;
812  addr->ce_mask |= ADDR_ATTR_FAMILY;
813 }
814 
815 int rtnl_addr_get_family(struct rtnl_addr *addr)
816 {
817  return addr->a_family;
818 }
819 
820 /**
821  * Set the prefix length / netmask
822  * @arg addr Address
823  * @arg prefixlen Length of prefix (netmask)
824  *
825  * Modifies the length of the prefix. If the address object contains a peer
826  * address the prefix length will apply to it, otherwise the prefix length
827  * will apply to the local address of the address.
828  *
829  * If the address object contains a peer or local address the corresponding
830  * `struct nl_addr` will be updated with the new prefix length.
831  *
832  * @note Specifying a length of 0 will remove the prefix length alltogether.
833  *
834  * @see rtnl_addr_get_prefixlen()
835  */
836 void rtnl_addr_set_prefixlen(struct rtnl_addr *addr, int prefixlen)
837 {
838  addr->a_prefixlen = prefixlen;
839 
840  if (prefixlen)
841  addr->ce_mask |= ADDR_ATTR_PREFIXLEN;
842  else
843  addr->ce_mask &= ~ADDR_ATTR_PREFIXLEN;
844 
845  /*
846  * The prefix length always applies to the peer address if
847  * a peer address is present.
848  */
849  if (addr->a_peer)
850  nl_addr_set_prefixlen(addr->a_peer, prefixlen);
851  else if (addr->a_local)
852  nl_addr_set_prefixlen(addr->a_local, prefixlen);
853 }
854 
855 int rtnl_addr_get_prefixlen(struct rtnl_addr *addr)
856 {
857  return addr->a_prefixlen;
858 }
859 
860 void rtnl_addr_set_scope(struct rtnl_addr *addr, int scope)
861 {
862  addr->a_scope = scope;
863  addr->ce_mask |= ADDR_ATTR_SCOPE;
864 }
865 
866 int rtnl_addr_get_scope(struct rtnl_addr *addr)
867 {
868  return addr->a_scope;
869 }
870 
871 void rtnl_addr_set_flags(struct rtnl_addr *addr, unsigned int flags)
872 {
873  addr->a_flag_mask |= flags;
874  addr->a_flags |= flags;
875  addr->ce_mask |= ADDR_ATTR_FLAGS;
876 }
877 
878 void rtnl_addr_unset_flags(struct rtnl_addr *addr, unsigned int flags)
879 {
880  addr->a_flag_mask |= flags;
881  addr->a_flags &= ~flags;
882  addr->ce_mask |= ADDR_ATTR_FLAGS;
883 }
884 
885 unsigned int rtnl_addr_get_flags(struct rtnl_addr *addr)
886 {
887  return addr->a_flags;
888 }
889 
890 static inline int __assign_addr(struct rtnl_addr *addr, struct nl_addr **pos,
891  struct nl_addr *new, int flag)
892 {
893  if (new) {
894  if (addr->ce_mask & ADDR_ATTR_FAMILY) {
895  if (new->a_family != addr->a_family)
896  return -NLE_AF_MISMATCH;
897  } else
898  addr->a_family = new->a_family;
899 
900  if (*pos)
901  nl_addr_put(*pos);
902 
903  *pos = nl_addr_get(new);
904  addr->ce_mask |= (flag | ADDR_ATTR_FAMILY);
905  } else {
906  if (*pos)
907  nl_addr_put(*pos);
908 
909  *pos = NULL;
910  addr->ce_mask &= ~flag;
911  }
912 
913  return 0;
914 }
915 
916 int rtnl_addr_set_local(struct rtnl_addr *addr, struct nl_addr *local)
917 {
918  int err;
919 
920  /* Prohibit local address with prefix length if peer address is present */
921  if ((addr->ce_mask & ADDR_ATTR_PEER) && local &&
922  nl_addr_get_prefixlen(local))
923  return -NLE_INVAL;
924 
925  err = __assign_addr(addr, &addr->a_local, local, ADDR_ATTR_LOCAL);
926  if (err < 0)
927  return err;
928 
929  /* Never overwrite the prefix length if a peer address is present */
930  if (!(addr->ce_mask & ADDR_ATTR_PEER))
931  rtnl_addr_set_prefixlen(addr, local ? nl_addr_get_prefixlen(local) : 0);
932 
933  return 0;
934 }
935 
936 struct nl_addr *rtnl_addr_get_local(struct rtnl_addr *addr)
937 {
938  return addr->a_local;
939 }
940 
941 int rtnl_addr_set_peer(struct rtnl_addr *addr, struct nl_addr *peer)
942 {
943  int err;
944 
945  if (peer && peer->a_family != AF_INET)
946  return -NLE_AF_NOSUPPORT;
947 
948  err = __assign_addr(addr, &addr->a_peer, peer, ADDR_ATTR_PEER);
949  if (err < 0)
950  return err;
951 
952  rtnl_addr_set_prefixlen(addr, peer ? nl_addr_get_prefixlen(peer) : 0);
953 
954  return 0;
955 }
956 
957 struct nl_addr *rtnl_addr_get_peer(struct rtnl_addr *addr)
958 {
959  return addr->a_peer;
960 }
961 
962 int rtnl_addr_set_broadcast(struct rtnl_addr *addr, struct nl_addr *bcast)
963 {
964  if (bcast && bcast->a_family != AF_INET)
965  return -NLE_AF_NOSUPPORT;
966 
967  return __assign_addr(addr, &addr->a_bcast, bcast, ADDR_ATTR_BROADCAST);
968 }
969 
970 struct nl_addr *rtnl_addr_get_broadcast(struct rtnl_addr *addr)
971 {
972  return addr->a_bcast;
973 }
974 
975 int rtnl_addr_set_multicast(struct rtnl_addr *addr, struct nl_addr *multicast)
976 {
977  if (multicast && multicast->a_family != AF_INET6)
978  return -NLE_AF_NOSUPPORT;
979 
980  return __assign_addr(addr, &addr->a_multicast, multicast,
981  ADDR_ATTR_MULTICAST);
982 }
983 
984 struct nl_addr *rtnl_addr_get_multicast(struct rtnl_addr *addr)
985 {
986  return addr->a_multicast;
987 }
988 
989 int rtnl_addr_set_anycast(struct rtnl_addr *addr, struct nl_addr *anycast)
990 {
991  if (anycast && anycast->a_family != AF_INET6)
992  return -NLE_AF_NOSUPPORT;
993 
994  return __assign_addr(addr, &addr->a_anycast, anycast,
995  ADDR_ATTR_ANYCAST);
996 }
997 
998 struct nl_addr *rtnl_addr_get_anycast(struct rtnl_addr *addr)
999 {
1000  return addr->a_anycast;
1001 }
1002 
1003 uint32_t rtnl_addr_get_valid_lifetime(struct rtnl_addr *addr)
1004 {
1005  if (addr->ce_mask & ADDR_ATTR_CACHEINFO)
1006  return addr->a_cacheinfo.aci_valid;
1007  else
1008  return 0xFFFFFFFFU;
1009 }
1010 
1011 void rtnl_addr_set_valid_lifetime(struct rtnl_addr *addr, uint32_t lifetime)
1012 {
1013  addr->a_cacheinfo.aci_valid = lifetime;
1014  addr->ce_mask |= ADDR_ATTR_CACHEINFO;
1015 }
1016 
1017 uint32_t rtnl_addr_get_preferred_lifetime(struct rtnl_addr *addr)
1018 {
1019  if (addr->ce_mask & ADDR_ATTR_CACHEINFO)
1020  return addr->a_cacheinfo.aci_prefered;
1021  else
1022  return 0xFFFFFFFFU;
1023 }
1024 
1025 void rtnl_addr_set_preferred_lifetime(struct rtnl_addr *addr, uint32_t lifetime)
1026 {
1027  addr->a_cacheinfo.aci_prefered = lifetime;
1028  addr->ce_mask |= ADDR_ATTR_CACHEINFO;
1029 }
1030 
1031 uint32_t rtnl_addr_get_create_time(struct rtnl_addr *addr)
1032 {
1033  return addr->a_cacheinfo.aci_cstamp;
1034 }
1035 
1036 uint32_t rtnl_addr_get_last_update_time(struct rtnl_addr *addr)
1037 {
1038  return addr->a_cacheinfo.aci_tstamp;
1039 }
1040 
1041 /** @} */
1042 
1043 /**
1044  * @name Flags Translations
1045  * @{
1046  */
1047 
1048 static const struct trans_tbl addr_flags[] = {
1049  __ADD(IFA_F_SECONDARY, secondary)
1050  __ADD(IFA_F_NODAD, nodad)
1051  __ADD(IFA_F_OPTIMISTIC, optimistic)
1052  __ADD(IFA_F_HOMEADDRESS, homeaddress)
1053  __ADD(IFA_F_DEPRECATED, deprecated)
1054  __ADD(IFA_F_TENTATIVE, tentative)
1055  __ADD(IFA_F_PERMANENT, permanent)
1056 };
1057 
1058 char *rtnl_addr_flags2str(int flags, char *buf, size_t size)
1059 {
1060  return __flags2str(flags, buf, size, addr_flags,
1061  ARRAY_SIZE(addr_flags));
1062 }
1063 
1064 int rtnl_addr_str2flags(const char *name)
1065 {
1066  return __str2flags(name, addr_flags, ARRAY_SIZE(addr_flags));
1067 }
1068 
1069 /** @} */
1070 
1071 static struct nl_object_ops addr_obj_ops = {
1072  .oo_name = "route/addr",
1073  .oo_size = sizeof(struct rtnl_addr),
1074  .oo_constructor = addr_constructor,
1075  .oo_free_data = addr_free_data,
1076  .oo_clone = addr_clone,
1077  .oo_dump = {
1078  [NL_DUMP_LINE] = addr_dump_line,
1079  [NL_DUMP_DETAILS] = addr_dump_details,
1080  [NL_DUMP_STATS] = addr_dump_stats,
1081  },
1082  .oo_compare = addr_compare,
1083  .oo_attrs2str = addr_attrs2str,
1084  .oo_id_attrs = (ADDR_ATTR_FAMILY | ADDR_ATTR_IFINDEX |
1085  ADDR_ATTR_LOCAL | ADDR_ATTR_PREFIXLEN),
1086 };
1087 
1088 static struct nl_af_group addr_groups[] = {
1089  { AF_INET, RTNLGRP_IPV4_IFADDR },
1090  { AF_INET6, RTNLGRP_IPV6_IFADDR },
1091  { END_OF_GROUP_LIST },
1092 };
1093 
1094 static struct nl_cache_ops rtnl_addr_ops = {
1095  .co_name = "route/addr",
1096  .co_hdrsize = sizeof(struct ifaddrmsg),
1097  .co_msgtypes = {
1098  { RTM_NEWADDR, NL_ACT_NEW, "new" },
1099  { RTM_DELADDR, NL_ACT_DEL, "del" },
1100  { RTM_GETADDR, NL_ACT_GET, "get" },
1101  END_OF_MSGTYPES_LIST,
1102  },
1103  .co_protocol = NETLINK_ROUTE,
1104  .co_groups = addr_groups,
1105  .co_request_update = addr_request_update,
1106  .co_msg_parser = addr_msg_parser,
1107  .co_obj_ops = &addr_obj_ops,
1108 };
1109 
1110 static void __init addr_init(void)
1111 {
1112  nl_cache_mngt_register(&rtnl_addr_ops);
1113 }
1114 
1115 static void __exit addr_exit(void)
1116 {
1117  nl_cache_mngt_unregister(&rtnl_addr_ops);
1118 }
1119 
1120 /** @} */