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, peer_prefix = 0, family;
203  struct nl_cache *link_cache;
204 
205  addr = rtnl_addr_alloc();
206  if (!addr)
207  return -NLE_NOMEM;
208 
209  addr->ce_msgtype = nlh->nlmsg_type;
210 
211  err = nlmsg_parse(nlh, sizeof(*ifa), tb, IFA_MAX, addr_policy);
212  if (err < 0)
213  goto errout;
214 
215  ifa = nlmsg_data(nlh);
216  addr->a_family = family = ifa->ifa_family;
217  addr->a_prefixlen = ifa->ifa_prefixlen;
218  addr->a_flags = ifa->ifa_flags;
219  addr->a_scope = ifa->ifa_scope;
220  addr->a_ifindex = ifa->ifa_index;
221 
222  addr->ce_mask = (ADDR_ATTR_FAMILY | ADDR_ATTR_PREFIXLEN |
223  ADDR_ATTR_FLAGS | ADDR_ATTR_SCOPE | ADDR_ATTR_IFINDEX);
224 
225  if (tb[IFA_LABEL]) {
226  nla_strlcpy(addr->a_label, tb[IFA_LABEL], IFNAMSIZ);
227  addr->ce_mask |= ADDR_ATTR_LABEL;
228  }
229 
230  /* IPv6 only */
231  if (tb[IFA_CACHEINFO]) {
232  struct ifa_cacheinfo *ca;
233 
234  ca = nla_data(tb[IFA_CACHEINFO]);
235  addr->a_cacheinfo.aci_prefered = ca->ifa_prefered;
236  addr->a_cacheinfo.aci_valid = ca->ifa_valid;
237  addr->a_cacheinfo.aci_cstamp = ca->cstamp;
238  addr->a_cacheinfo.aci_tstamp = ca->tstamp;
239  addr->ce_mask |= ADDR_ATTR_CACHEINFO;
240  }
241 
242  if (tb[IFA_LOCAL]) {
243  addr->a_local = nl_addr_alloc_attr(tb[IFA_LOCAL], family);
244  if (!addr->a_local)
245  goto errout_nomem;
246  addr->ce_mask |= ADDR_ATTR_LOCAL;
247  }
248 
249  if (tb[IFA_ADDRESS]) {
250  struct nl_addr *a;
251 
252  a = nl_addr_alloc_attr(tb[IFA_ADDRESS], family);
253  if (!a)
254  goto errout_nomem;
255 
256  /* IPv6 sends the local address as IFA_ADDRESS with
257  * no IFA_LOCAL, IPv4 sends both IFA_LOCAL and IFA_ADDRESS
258  * with IFA_ADDRESS being the peer address if they differ */
259  if (!tb[IFA_LOCAL] || !nl_addr_cmp(a, addr->a_local)) {
260  nl_addr_put(addr->a_local);
261  addr->a_local = a;
262  addr->ce_mask |= ADDR_ATTR_LOCAL;
263  } else {
264  addr->a_peer = a;
265  addr->ce_mask |= ADDR_ATTR_PEER;
266  peer_prefix = 1;
267  }
268  }
269 
270  nl_addr_set_prefixlen(peer_prefix ? addr->a_peer : addr->a_local,
271  addr->a_prefixlen);
272 
273  /* IPv4 only */
274  if (tb[IFA_BROADCAST]) {
275  addr->a_bcast = nl_addr_alloc_attr(tb[IFA_BROADCAST], family);
276  if (!addr->a_bcast)
277  goto errout_nomem;
278 
279  addr->ce_mask |= ADDR_ATTR_BROADCAST;
280  }
281 
282  /* IPv6 only */
283  if (tb[IFA_MULTICAST]) {
284  addr->a_multicast = nl_addr_alloc_attr(tb[IFA_MULTICAST],
285  family);
286  if (!addr->a_multicast)
287  goto errout_nomem;
288 
289  addr->ce_mask |= ADDR_ATTR_MULTICAST;
290  }
291 
292  /* IPv6 only */
293  if (tb[IFA_ANYCAST]) {
294  addr->a_anycast = nl_addr_alloc_attr(tb[IFA_ANYCAST],
295  family);
296  if (!addr->a_anycast)
297  goto errout_nomem;
298 
299  addr->ce_mask |= ADDR_ATTR_ANYCAST;
300  }
301 
302  if ((link_cache = __nl_cache_mngt_require("route/link"))) {
303  struct rtnl_link *link;
304 
305  if ((link = rtnl_link_get(link_cache, addr->a_ifindex))) {
306  rtnl_addr_set_link(addr, link);
307 
308  /* rtnl_addr_set_link incs refcnt */
309  rtnl_link_put(link);
310  }
311  }
312 
313  err = pp->pp_cb((struct nl_object *) addr, pp);
314 errout:
315  rtnl_addr_put(addr);
316 
317  return err;
318 
319 errout_nomem:
320  err = -NLE_NOMEM;
321  goto errout;
322 }
323 
324 static int addr_request_update(struct nl_cache *cache, struct nl_sock *sk)
325 {
326  return nl_rtgen_request(sk, RTM_GETADDR, AF_UNSPEC, NLM_F_DUMP);
327 }
328 
329 static void addr_dump_line(struct nl_object *obj, struct nl_dump_params *p)
330 {
331  struct rtnl_addr *addr = (struct rtnl_addr *) obj;
332  struct nl_cache *link_cache;
333  char buf[128];
334 
335  link_cache = nl_cache_mngt_require_safe("route/link");
336 
337  if (addr->ce_mask & ADDR_ATTR_LOCAL)
338  nl_dump_line(p, "%s",
339  nl_addr2str(addr->a_local, buf, sizeof(buf)));
340  else
341  nl_dump_line(p, "none");
342 
343  if (addr->ce_mask & ADDR_ATTR_PEER)
344  nl_dump(p, " peer %s",
345  nl_addr2str(addr->a_peer, buf, sizeof(buf)));
346 
347  nl_dump(p, " %s ", nl_af2str(addr->a_family, buf, sizeof(buf)));
348 
349  if (link_cache)
350  nl_dump(p, "dev %s ",
351  rtnl_link_i2name(link_cache, addr->a_ifindex,
352  buf, sizeof(buf)));
353  else
354  nl_dump(p, "dev %d ", addr->a_ifindex);
355 
356  nl_dump(p, "scope %s",
357  rtnl_scope2str(addr->a_scope, buf, sizeof(buf)));
358 
359  rtnl_addr_flags2str(addr->a_flags, buf, sizeof(buf));
360  if (buf[0])
361  nl_dump(p, " <%s>", buf);
362 
363  nl_dump(p, "\n");
364 
365  if (link_cache)
366  nl_cache_put(link_cache);
367 }
368 
369 static void addr_dump_details(struct nl_object *obj, struct nl_dump_params *p)
370 {
371  struct rtnl_addr *addr = (struct rtnl_addr *) obj;
372  char buf[128];
373 
374  addr_dump_line(obj, p);
375 
376  if (addr->ce_mask & (ADDR_ATTR_LABEL | ADDR_ATTR_BROADCAST |
377  ADDR_ATTR_MULTICAST)) {
378  nl_dump_line(p, " ");
379 
380  if (addr->ce_mask & ADDR_ATTR_LABEL)
381  nl_dump(p, " label %s", addr->a_label);
382 
383  if (addr->ce_mask & ADDR_ATTR_BROADCAST)
384  nl_dump(p, " broadcast %s",
385  nl_addr2str(addr->a_bcast, buf, sizeof(buf)));
386 
387  if (addr->ce_mask & ADDR_ATTR_MULTICAST)
388  nl_dump(p, " multicast %s",
389  nl_addr2str(addr->a_multicast, buf,
390  sizeof(buf)));
391 
392  if (addr->ce_mask & ADDR_ATTR_ANYCAST)
393  nl_dump(p, " anycast %s",
394  nl_addr2str(addr->a_anycast, buf,
395  sizeof(buf)));
396 
397  nl_dump(p, "\n");
398  }
399 
400  if (addr->ce_mask & ADDR_ATTR_CACHEINFO) {
401  struct rtnl_addr_cacheinfo *ci = &addr->a_cacheinfo;
402 
403  nl_dump_line(p, " valid-lifetime %s",
404  ci->aci_valid == 0xFFFFFFFFU ? "forever" :
405  nl_msec2str(ci->aci_valid * 1000,
406  buf, sizeof(buf)));
407 
408  nl_dump(p, " preferred-lifetime %s\n",
409  ci->aci_prefered == 0xFFFFFFFFU ? "forever" :
410  nl_msec2str(ci->aci_prefered * 1000,
411  buf, sizeof(buf)));
412 
413  nl_dump_line(p, " created boot-time+%s ",
414  nl_msec2str(addr->a_cacheinfo.aci_cstamp * 10,
415  buf, sizeof(buf)));
416 
417  nl_dump(p, "last-updated boot-time+%s\n",
418  nl_msec2str(addr->a_cacheinfo.aci_tstamp * 10,
419  buf, sizeof(buf)));
420  }
421 }
422 
423 static void addr_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
424 {
425  addr_dump_details(obj, p);
426 }
427 
428 static int addr_compare(struct nl_object *_a, struct nl_object *_b,
429  uint32_t attrs, int flags)
430 {
431  struct rtnl_addr *a = (struct rtnl_addr *) _a;
432  struct rtnl_addr *b = (struct rtnl_addr *) _b;
433  int diff = 0;
434 
435 #define ADDR_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ADDR_ATTR_##ATTR, a, b, EXPR)
436 
437  diff |= ADDR_DIFF(IFINDEX, a->a_ifindex != b->a_ifindex);
438  diff |= ADDR_DIFF(FAMILY, a->a_family != b->a_family);
439  diff |= ADDR_DIFF(SCOPE, a->a_scope != b->a_scope);
440  diff |= ADDR_DIFF(LABEL, strcmp(a->a_label, b->a_label));
441  diff |= ADDR_DIFF(PEER, nl_addr_cmp(a->a_peer, b->a_peer));
442  diff |= ADDR_DIFF(LOCAL, nl_addr_cmp(a->a_local, b->a_local));
443  diff |= ADDR_DIFF(MULTICAST, nl_addr_cmp(a->a_multicast,
444  b->a_multicast));
445  diff |= ADDR_DIFF(BROADCAST, nl_addr_cmp(a->a_bcast, b->a_bcast));
446  diff |= ADDR_DIFF(ANYCAST, nl_addr_cmp(a->a_anycast, b->a_anycast));
447 
448  if (flags & LOOSE_COMPARISON)
449  diff |= ADDR_DIFF(FLAGS,
450  (a->a_flags ^ b->a_flags) & b->a_flag_mask);
451  else
452  diff |= ADDR_DIFF(FLAGS, a->a_flags != b->a_flags);
453 
454 #undef ADDR_DIFF
455 
456  return diff;
457 }
458 
459 static const struct trans_tbl addr_attrs[] = {
460  __ADD(ADDR_ATTR_FAMILY, family)
461  __ADD(ADDR_ATTR_PREFIXLEN, prefixlen)
462  __ADD(ADDR_ATTR_FLAGS, flags)
463  __ADD(ADDR_ATTR_SCOPE, scope)
464  __ADD(ADDR_ATTR_IFINDEX, ifindex)
465  __ADD(ADDR_ATTR_LABEL, label)
466  __ADD(ADDR_ATTR_CACHEINFO, cacheinfo)
467  __ADD(ADDR_ATTR_PEER, peer)
468  __ADD(ADDR_ATTR_LOCAL, local)
469  __ADD(ADDR_ATTR_BROADCAST, broadcast)
470  __ADD(ADDR_ATTR_MULTICAST, multicast)
471 };
472 
473 static char *addr_attrs2str(int attrs, char *buf, size_t len)
474 {
475  return __flags2str(attrs, buf, len, addr_attrs,
476  ARRAY_SIZE(addr_attrs));
477 }
478 
479 /**
480  * @name Allocation/Freeing
481  * @{
482  */
483 
484 struct rtnl_addr *rtnl_addr_alloc(void)
485 {
486  return (struct rtnl_addr *) nl_object_alloc(&addr_obj_ops);
487 }
488 
489 void rtnl_addr_put(struct rtnl_addr *addr)
490 {
491  nl_object_put((struct nl_object *) addr);
492 }
493 
494 /** @} */
495 
496 /**
497  * @name Cache Management
498  * @{
499  */
500 
501 int rtnl_addr_alloc_cache(struct nl_sock *sk, struct nl_cache **result)
502 {
503  return nl_cache_alloc_and_fill(&rtnl_addr_ops, sk, result);
504 }
505 
506 /**
507  * Search address in cache
508  * @arg cache Address cache
509  * @arg ifindex Interface index of address
510  * @arg addr Local address part
511  *
512  * Searches address cache previously allocated with rtnl_addr_alloc_cache()
513  * for an address with a matching local address.
514  *
515  * The reference counter is incremented before returning the address, therefore
516  * the reference must be given back with rtnl_addr_put() after usage.
517  *
518  * @return Address object or NULL if no match was found.
519  */
520 struct rtnl_addr *rtnl_addr_get(struct nl_cache *cache, int ifindex,
521  struct nl_addr *addr)
522 {
523  struct rtnl_addr *a;
524 
525  if (cache->c_ops != &rtnl_addr_ops)
526  return NULL;
527 
528  nl_list_for_each_entry(a, &cache->c_items, ce_list) {
529  if (ifindex && a->a_ifindex != ifindex)
530  continue;
531 
532  if (a->ce_mask & ADDR_ATTR_LOCAL &&
533  !nl_addr_cmp(a->a_local, addr)) {
534  nl_object_get((struct nl_object *) a);
535  return a;
536  }
537  }
538 
539  return NULL;
540 }
541 
542 /** @} */
543 
544 static int build_addr_msg(struct rtnl_addr *tmpl, int cmd, int flags,
545  struct nl_msg **result)
546 {
547  struct nl_msg *msg;
548  struct ifaddrmsg am = {
549  .ifa_family = tmpl->a_family,
550  .ifa_index = tmpl->a_ifindex,
551  .ifa_prefixlen = tmpl->a_prefixlen,
552  };
553 
554  if (tmpl->ce_mask & ADDR_ATTR_SCOPE)
555  am.ifa_scope = tmpl->a_scope;
556  else {
557  /* compatibility hack */
558  if (tmpl->a_family == AF_INET &&
559  tmpl->ce_mask & ADDR_ATTR_LOCAL &&
560  *((char *) nl_addr_get_binary_addr(tmpl->a_local)) == 127)
561  am.ifa_scope = RT_SCOPE_HOST;
562  else
563  am.ifa_scope = RT_SCOPE_UNIVERSE;
564  }
565 
566  msg = nlmsg_alloc_simple(cmd, flags);
567  if (!msg)
568  return -NLE_NOMEM;
569 
570  if (nlmsg_append(msg, &am, sizeof(am), NLMSG_ALIGNTO) < 0)
571  goto nla_put_failure;
572 
573  if (tmpl->ce_mask & ADDR_ATTR_LOCAL)
574  NLA_PUT_ADDR(msg, IFA_LOCAL, tmpl->a_local);
575 
576  if (tmpl->ce_mask & ADDR_ATTR_PEER)
577  NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_peer);
578  else if (tmpl->ce_mask & ADDR_ATTR_LOCAL)
579  NLA_PUT_ADDR(msg, IFA_ADDRESS, tmpl->a_local);
580 
581  if (tmpl->ce_mask & ADDR_ATTR_LABEL)
582  NLA_PUT_STRING(msg, IFA_LABEL, tmpl->a_label);
583 
584  if (tmpl->ce_mask & ADDR_ATTR_BROADCAST)
585  NLA_PUT_ADDR(msg, IFA_BROADCAST, tmpl->a_bcast);
586 
587  if (tmpl->ce_mask & ADDR_ATTR_CACHEINFO) {
588  struct ifa_cacheinfo ca = {
589  .ifa_valid = tmpl->a_cacheinfo.aci_valid,
590  .ifa_prefered = tmpl->a_cacheinfo.aci_prefered,
591  };
592 
593  NLA_PUT(msg, IFA_CACHEINFO, sizeof(ca), &ca);
594  }
595 
596 
597  *result = msg;
598  return 0;
599 
600 nla_put_failure:
601  nlmsg_free(msg);
602  return -NLE_MSGSIZE;
603 }
604 
605 /**
606  * @name Addition
607  * @{
608  */
609 
610 /**
611  * Build netlink request message to request addition of new address
612  * @arg addr Address object representing the new address.
613  * @arg flags Additional netlink message flags.
614  * @arg result Pointer to store resulting message.
615  *
616  * Builds a new netlink message requesting the addition of a new
617  * address. The netlink message header isn't fully equipped with
618  * all relevant fields and must thus be sent out via nl_send_auto_complete()
619  * or supplemented as needed.
620  *
621  * Minimal required attributes:
622  * - interface index (rtnl_addr_set_ifindex())
623  * - local address (rtnl_addr_set_local())
624  *
625  * The scope will default to universe except for loopback addresses in
626  * which case a host scope is used if not specified otherwise.
627  *
628  * @note Free the memory after usage using nlmsg_free().
629  *
630  * @return 0 on success or a negative error code.
631  */
632 int rtnl_addr_build_add_request(struct rtnl_addr *addr, int flags,
633  struct nl_msg **result)
634 {
635  uint32_t required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY |
636  ADDR_ATTR_PREFIXLEN | ADDR_ATTR_LOCAL;
637 
638  if ((addr->ce_mask & required) != required)
639  return -NLE_MISSING_ATTR;
640 
641  return build_addr_msg(addr, RTM_NEWADDR, NLM_F_CREATE | flags, result);
642 }
643 
644 /**
645  * Request addition of new address
646  * @arg sk Netlink socket.
647  * @arg addr Address object representing the new address.
648  * @arg flags Additional netlink message flags.
649  *
650  * Builds a netlink message by calling rtnl_addr_build_add_request(),
651  * sends the request to the kernel and waits for the next ACK to be
652  * received and thus blocks until the request has been fullfilled.
653  *
654  * @see rtnl_addr_build_add_request()
655  *
656  * @return 0 on sucess or a negative error if an error occured.
657  */
658 int rtnl_addr_add(struct nl_sock *sk, struct rtnl_addr *addr, int flags)
659 {
660  struct nl_msg *msg;
661  int err;
662 
663  if ((err = rtnl_addr_build_add_request(addr, flags, &msg)) < 0)
664  return err;
665 
666  err = nl_send_auto_complete(sk, msg);
667  nlmsg_free(msg);
668  if (err < 0)
669  return err;
670 
671  return wait_for_ack(sk);
672 }
673 
674 /** @} */
675 
676 /**
677  * @name Deletion
678  * @{
679  */
680 
681 /**
682  * Build a netlink request message to request deletion of an address
683  * @arg addr Address object to be deleteted.
684  * @arg flags Additional netlink message flags.
685  * @arg result Pointer to store resulting message.
686  *
687  * Builds a new netlink message requesting a deletion of an address.
688  * The netlink message header isn't fully equipped with all relevant
689  * fields and must thus be sent out via nl_send_auto_complete()
690  * or supplemented as needed.
691  *
692  * Minimal required attributes:
693  * - interface index (rtnl_addr_set_ifindex())
694  * - address family (rtnl_addr_set_family())
695  *
696  * Optional attributes:
697  * - local address (rtnl_addr_set_local())
698  * - label (rtnl_addr_set_label(), IPv4/DECnet only)
699  * - peer address (rtnl_addr_set_peer(), IPv4 only)
700  *
701  * @note Free the memory after usage using nlmsg_free().
702  *
703  * @return 0 on success or a negative error code.
704  */
705 int rtnl_addr_build_delete_request(struct rtnl_addr *addr, int flags,
706  struct nl_msg **result)
707 {
708  uint32_t required = ADDR_ATTR_IFINDEX | ADDR_ATTR_FAMILY;
709 
710  if ((addr->ce_mask & required) != required)
711  return -NLE_MISSING_ATTR;
712 
713  return build_addr_msg(addr, RTM_DELADDR, flags, result);
714 }
715 
716 /**
717  * Request deletion of an address
718  * @arg sk Netlink socket.
719  * @arg addr Address object to be deleted.
720  * @arg flags Additional netlink message flags.
721  *
722  * Builds a netlink message by calling rtnl_addr_build_delete_request(),
723  * sends the request to the kernel and waits for the next ACK to be
724  * received and thus blocks until the request has been fullfilled.
725  *
726  * @see rtnl_addr_build_delete_request();
727  *
728  * @return 0 on sucess or a negative error if an error occured.
729  */
730 int rtnl_addr_delete(struct nl_sock *sk, struct rtnl_addr *addr, int flags)
731 {
732  struct nl_msg *msg;
733  int err;
734 
735  if ((err = rtnl_addr_build_delete_request(addr, flags, &msg)) < 0)
736  return err;
737 
738  err = nl_send_auto_complete(sk, msg);
739  nlmsg_free(msg);
740  if (err < 0)
741  return err;
742 
743  return wait_for_ack(sk);
744 }
745 
746 /** @} */
747 
748 /**
749  * @name Attributes
750  * @{
751  */
752 
753 int rtnl_addr_set_label(struct rtnl_addr *addr, const char *label)
754 {
755  if (strlen(label) > sizeof(addr->a_label) - 1)
756  return -NLE_RANGE;
757 
758  strcpy(addr->a_label, label);
759  addr->ce_mask |= ADDR_ATTR_LABEL;
760 
761  return 0;
762 }
763 
764 char *rtnl_addr_get_label(struct rtnl_addr *addr)
765 {
766  if (addr->ce_mask & ADDR_ATTR_LABEL)
767  return addr->a_label;
768  else
769  return NULL;
770 }
771 
772 void rtnl_addr_set_ifindex(struct rtnl_addr *addr, int ifindex)
773 {
774  addr->a_ifindex = ifindex;
775  addr->ce_mask |= ADDR_ATTR_IFINDEX;
776 }
777 
778 int rtnl_addr_get_ifindex(struct rtnl_addr *addr)
779 {
780  return addr->a_ifindex;
781 }
782 
783 void rtnl_addr_set_link(struct rtnl_addr *addr, struct rtnl_link *link)
784 {
785  rtnl_link_put(addr->a_link);
786 
787  if (!link)
788  return;
789 
790  nl_object_get(OBJ_CAST(link));
791  addr->a_link = link;
792  addr->a_ifindex = link->l_index;
793  addr->ce_mask |= ADDR_ATTR_IFINDEX;
794 }
795 
796 struct rtnl_link *rtnl_addr_get_link(struct rtnl_addr *addr)
797 {
798  if (addr->a_link) {
799  nl_object_get(OBJ_CAST(addr->a_link));
800  return addr->a_link;
801  }
802 
803  return NULL;
804 }
805 
806 void rtnl_addr_set_family(struct rtnl_addr *addr, int family)
807 {
808  addr->a_family = family;
809  addr->ce_mask |= ADDR_ATTR_FAMILY;
810 }
811 
812 int rtnl_addr_get_family(struct rtnl_addr *addr)
813 {
814  return addr->a_family;
815 }
816 
817 void rtnl_addr_set_prefixlen(struct rtnl_addr *addr, int prefix)
818 {
819  addr->a_prefixlen = prefix;
820  addr->ce_mask |= ADDR_ATTR_PREFIXLEN;
821 }
822 
823 int rtnl_addr_get_prefixlen(struct rtnl_addr *addr)
824 {
825  return addr->a_prefixlen;
826 }
827 
828 void rtnl_addr_set_scope(struct rtnl_addr *addr, int scope)
829 {
830  addr->a_scope = scope;
831  addr->ce_mask |= ADDR_ATTR_SCOPE;
832 }
833 
834 int rtnl_addr_get_scope(struct rtnl_addr *addr)
835 {
836  return addr->a_scope;
837 }
838 
839 void rtnl_addr_set_flags(struct rtnl_addr *addr, unsigned int flags)
840 {
841  addr->a_flag_mask |= flags;
842  addr->a_flags |= flags;
843  addr->ce_mask |= ADDR_ATTR_FLAGS;
844 }
845 
846 void rtnl_addr_unset_flags(struct rtnl_addr *addr, unsigned int flags)
847 {
848  addr->a_flag_mask |= flags;
849  addr->a_flags &= ~flags;
850  addr->ce_mask |= ADDR_ATTR_FLAGS;
851 }
852 
853 unsigned int rtnl_addr_get_flags(struct rtnl_addr *addr)
854 {
855  return addr->a_flags;
856 }
857 
858 static inline int __assign_addr(struct rtnl_addr *addr, struct nl_addr **pos,
859  struct nl_addr *new, int flag)
860 {
861  if (new) {
862  if (addr->ce_mask & ADDR_ATTR_FAMILY) {
863  if (new->a_family != addr->a_family)
864  return -NLE_AF_MISMATCH;
865  } else
866  addr->a_family = new->a_family;
867 
868  if (*pos)
869  nl_addr_put(*pos);
870 
871  *pos = nl_addr_get(new);
872  addr->ce_mask |= (flag | ADDR_ATTR_FAMILY);
873  } else {
874  if (*pos)
875  nl_addr_put(*pos);
876 
877  *pos = NULL;
878  addr->ce_mask &= ~flag;
879  }
880 
881  return 0;
882 }
883 
884 int rtnl_addr_set_local(struct rtnl_addr *addr, struct nl_addr *local)
885 {
886  int err;
887 
888  /* Prohibit local address with prefix length if peer address is present */
889  if ((addr->ce_mask & ADDR_ATTR_PEER) && local &&
890  nl_addr_get_prefixlen(local))
891  return -NLE_INVAL;
892 
893  err = __assign_addr(addr, &addr->a_local, local, ADDR_ATTR_LOCAL);
894  if (err < 0)
895  return err;
896 
897  /* Never overwrite the prefix length if a peer address is present */
898  if (!(addr->ce_mask & ADDR_ATTR_PEER))
899  rtnl_addr_set_prefixlen(addr, local ? nl_addr_get_prefixlen(local) : 0);
900 
901  return 0;
902 }
903 
904 struct nl_addr *rtnl_addr_get_local(struct rtnl_addr *addr)
905 {
906  return addr->a_local;
907 }
908 
909 int rtnl_addr_set_peer(struct rtnl_addr *addr, struct nl_addr *peer)
910 {
911  int err;
912 
913  if (peer && peer->a_family != AF_INET)
914  return -NLE_AF_NOSUPPORT;
915 
916  err = __assign_addr(addr, &addr->a_peer, peer, ADDR_ATTR_PEER);
917  if (err < 0)
918  return err;
919 
920  rtnl_addr_set_prefixlen(addr, peer ? nl_addr_get_prefixlen(peer) : 0);
921 
922  return 0;
923 }
924 
925 struct nl_addr *rtnl_addr_get_peer(struct rtnl_addr *addr)
926 {
927  return addr->a_peer;
928 }
929 
930 int rtnl_addr_set_broadcast(struct rtnl_addr *addr, struct nl_addr *bcast)
931 {
932  if (bcast && bcast->a_family != AF_INET)
933  return -NLE_AF_NOSUPPORT;
934 
935  return __assign_addr(addr, &addr->a_bcast, bcast, ADDR_ATTR_BROADCAST);
936 }
937 
938 struct nl_addr *rtnl_addr_get_broadcast(struct rtnl_addr *addr)
939 {
940  return addr->a_bcast;
941 }
942 
943 int rtnl_addr_set_multicast(struct rtnl_addr *addr, struct nl_addr *multicast)
944 {
945  if (multicast && multicast->a_family != AF_INET6)
946  return -NLE_AF_NOSUPPORT;
947 
948  return __assign_addr(addr, &addr->a_multicast, multicast,
949  ADDR_ATTR_MULTICAST);
950 }
951 
952 struct nl_addr *rtnl_addr_get_multicast(struct rtnl_addr *addr)
953 {
954  return addr->a_multicast;
955 }
956 
957 int rtnl_addr_set_anycast(struct rtnl_addr *addr, struct nl_addr *anycast)
958 {
959  if (anycast && anycast->a_family != AF_INET6)
960  return -NLE_AF_NOSUPPORT;
961 
962  return __assign_addr(addr, &addr->a_anycast, anycast,
963  ADDR_ATTR_ANYCAST);
964 }
965 
966 struct nl_addr *rtnl_addr_get_anycast(struct rtnl_addr *addr)
967 {
968  return addr->a_anycast;
969 }
970 
971 uint32_t rtnl_addr_get_valid_lifetime(struct rtnl_addr *addr)
972 {
973  if (addr->ce_mask & ADDR_ATTR_CACHEINFO)
974  return addr->a_cacheinfo.aci_valid;
975  else
976  return 0xFFFFFFFFU;
977 }
978 
979 void rtnl_addr_set_valid_lifetime(struct rtnl_addr *addr, uint32_t lifetime)
980 {
981  addr->a_cacheinfo.aci_valid = lifetime;
982  addr->ce_mask |= ADDR_ATTR_CACHEINFO;
983 }
984 
985 uint32_t rtnl_addr_get_preferred_lifetime(struct rtnl_addr *addr)
986 {
987  if (addr->ce_mask & ADDR_ATTR_CACHEINFO)
988  return addr->a_cacheinfo.aci_prefered;
989  else
990  return 0xFFFFFFFFU;
991 }
992 
993 void rtnl_addr_set_preferred_lifetime(struct rtnl_addr *addr, uint32_t lifetime)
994 {
995  addr->a_cacheinfo.aci_prefered = lifetime;
996  addr->ce_mask |= ADDR_ATTR_CACHEINFO;
997 }
998 
999 uint32_t rtnl_addr_get_create_time(struct rtnl_addr *addr)
1000 {
1001  return addr->a_cacheinfo.aci_cstamp;
1002 }
1003 
1004 uint32_t rtnl_addr_get_last_update_time(struct rtnl_addr *addr)
1005 {
1006  return addr->a_cacheinfo.aci_tstamp;
1007 }
1008 
1009 /** @} */
1010 
1011 /**
1012  * @name Flags Translations
1013  * @{
1014  */
1015 
1016 static const struct trans_tbl addr_flags[] = {
1017  __ADD(IFA_F_SECONDARY, secondary)
1018  __ADD(IFA_F_NODAD, nodad)
1019  __ADD(IFA_F_OPTIMISTIC, optimistic)
1020  __ADD(IFA_F_HOMEADDRESS, homeaddress)
1021  __ADD(IFA_F_DEPRECATED, deprecated)
1022  __ADD(IFA_F_TENTATIVE, tentative)
1023  __ADD(IFA_F_PERMANENT, permanent)
1024 };
1025 
1026 char *rtnl_addr_flags2str(int flags, char *buf, size_t size)
1027 {
1028  return __flags2str(flags, buf, size, addr_flags,
1029  ARRAY_SIZE(addr_flags));
1030 }
1031 
1032 int rtnl_addr_str2flags(const char *name)
1033 {
1034  return __str2flags(name, addr_flags, ARRAY_SIZE(addr_flags));
1035 }
1036 
1037 /** @} */
1038 
1039 static struct nl_object_ops addr_obj_ops = {
1040  .oo_name = "route/addr",
1041  .oo_size = sizeof(struct rtnl_addr),
1042  .oo_constructor = addr_constructor,
1043  .oo_free_data = addr_free_data,
1044  .oo_clone = addr_clone,
1045  .oo_dump = {
1046  [NL_DUMP_LINE] = addr_dump_line,
1047  [NL_DUMP_DETAILS] = addr_dump_details,
1048  [NL_DUMP_STATS] = addr_dump_stats,
1049  },
1050  .oo_compare = addr_compare,
1051  .oo_attrs2str = addr_attrs2str,
1052  .oo_id_attrs = (ADDR_ATTR_FAMILY | ADDR_ATTR_IFINDEX |
1053  ADDR_ATTR_LOCAL | ADDR_ATTR_PREFIXLEN),
1054 };
1055 
1056 static struct nl_af_group addr_groups[] = {
1057  { AF_INET, RTNLGRP_IPV4_IFADDR },
1058  { AF_INET6, RTNLGRP_IPV6_IFADDR },
1059  { END_OF_GROUP_LIST },
1060 };
1061 
1062 static struct nl_cache_ops rtnl_addr_ops = {
1063  .co_name = "route/addr",
1064  .co_hdrsize = sizeof(struct ifaddrmsg),
1065  .co_msgtypes = {
1066  { RTM_NEWADDR, NL_ACT_NEW, "new" },
1067  { RTM_DELADDR, NL_ACT_DEL, "del" },
1068  { RTM_GETADDR, NL_ACT_GET, "get" },
1069  END_OF_MSGTYPES_LIST,
1070  },
1071  .co_protocol = NETLINK_ROUTE,
1072  .co_groups = addr_groups,
1073  .co_request_update = addr_request_update,
1074  .co_msg_parser = addr_msg_parser,
1075  .co_obj_ops = &addr_obj_ops,
1076 };
1077 
1078 static void __init addr_init(void)
1079 {
1080  nl_cache_mngt_register(&rtnl_addr_ops);
1081 }
1082 
1083 static void __exit addr_exit(void)
1084 {
1085  nl_cache_mngt_unregister(&rtnl_addr_ops);
1086 }
1087 
1088 /** @} */