1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2021 Ng Peng Nam Sean
5 * Copyright (c) 2022 Alexander V. Chernikov <melifaro@FreeBSD.org>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 #include "opt_inet.h"
31 #include "opt_inet6.h"
32 #include "opt_route.h"
33 #include <sys/types.h>
34 #include <sys/malloc.h>
35 #include <sys/rmlock.h>
36 #include <sys/socket.h>
37
38 #include <net/if.h>
39 #include <net/route.h>
40 #include <net/route/nhop.h>
41 #include <net/route/route_ctl.h>
42 #include <net/route/route_var.h>
43 #include <netinet6/scope6_var.h>
44 #include <netlink/netlink.h>
45 #include <netlink/netlink_ctl.h>
46 #include <netlink/netlink_route.h>
47 #include <netlink/route/route_var.h>
48
49 #define DEBUG_MOD_NAME nl_route
50 #define DEBUG_MAX_LEVEL LOG_DEBUG3
51 #include <netlink/netlink_debug.h>
52 _DECLARE_DEBUG(LOG_DEBUG);
53
54 static unsigned char
get_rtm_type(const struct nhop_object * nh)55 get_rtm_type(const struct nhop_object *nh)
56 {
57 int nh_flags = nh->nh_flags;
58
59 /* Use the fact that nhg runtime flags are only NHF_MULTIPATH */
60 if (nh_flags & NHF_BLACKHOLE)
61 return (RTN_BLACKHOLE);
62 else if (nh_flags & NHF_REJECT)
63 return (RTN_PROHIBIT);
64 return (RTN_UNICAST);
65 }
66
67 static uint8_t
nl_get_rtm_protocol(const struct nhop_object * nh)68 nl_get_rtm_protocol(const struct nhop_object *nh)
69 {
70 #ifdef ROUTE_MPATH
71 if (NH_IS_NHGRP(nh)) {
72 const struct nhgrp_object *nhg = (const struct nhgrp_object *)nh;
73 uint8_t origin = nhgrp_get_origin(nhg);
74 if (origin != RTPROT_UNSPEC)
75 return (origin);
76 nh = nhg->nhops[0];
77 }
78 #endif
79 uint8_t origin = nhop_get_origin(nh);
80 if (origin != RTPROT_UNSPEC)
81 return (origin);
82 /* TODO: remove guesswork once all kernel users fill in origin */
83 int rt_flags = nhop_get_rtflags(nh);
84 if (rt_flags & RTF_PROTO1)
85 return (RTPROT_ZEBRA);
86 if (rt_flags & RTF_STATIC)
87 return (RTPROT_STATIC);
88 return (RTPROT_KERNEL);
89 }
90
91 static int
get_rtmsg_type_from_rtsock(int cmd)92 get_rtmsg_type_from_rtsock(int cmd)
93 {
94 switch (cmd) {
95 case RTM_ADD:
96 case RTM_CHANGE:
97 case RTM_GET:
98 return NL_RTM_NEWROUTE;
99 case RTM_DELETE:
100 return NL_RTM_DELROUTE;
101 }
102
103 return (0);
104 }
105
106 /*
107 * fibnum heuristics
108 *
109 * if (dump && rtm_table == 0 && !rta_table) RT_ALL_FIBS
110 * msg rtm_table RTA_TABLE result
111 * RTM_GETROUTE/dump 0 - RT_ALL_FIBS
112 * RTM_GETROUTE/dump 1 - 1
113 * RTM_GETROUTE/get 0 - 0
114 *
115 */
116
117 static struct nhop_object *
rc_get_nhop(const struct rib_cmd_info * rc)118 rc_get_nhop(const struct rib_cmd_info *rc)
119 {
120 return ((rc->rc_cmd == RTM_DELETE) ? rc->rc_nh_old : rc->rc_nh_new);
121 }
122
123 static void
dump_rc_nhop_gw(struct nl_writer * nw,const struct nhop_object * nh)124 dump_rc_nhop_gw(struct nl_writer *nw, const struct nhop_object *nh)
125 {
126 #ifdef INET6
127 int upper_family;
128 #endif
129
130 switch (nhop_get_neigh_family(nh)) {
131 case AF_LINK:
132 /* onlink prefix, skip */
133 break;
134 case AF_INET:
135 nlattr_add(nw, NL_RTA_GATEWAY, 4, &nh->gw4_sa.sin_addr);
136 break;
137 #ifdef INET6
138 case AF_INET6:
139 upper_family = nhop_get_upper_family(nh);
140 if (upper_family == AF_INET6) {
141 struct in6_addr gw6 = nh->gw6_sa.sin6_addr;
142 in6_clearscope(&gw6);
143
144 nlattr_add(nw, NL_RTA_GATEWAY, 16, &gw6);
145 } else if (upper_family == AF_INET) {
146 /* IPv4 over IPv6 */
147 struct in6_addr gw6 = nh->gw6_sa.sin6_addr;
148 in6_clearscope(&gw6);
149
150 char buf[20];
151 struct rtvia *via = (struct rtvia *)&buf[0];
152 via->rtvia_family = AF_INET6;
153 memcpy(via->rtvia_addr, &gw6, 16);
154 nlattr_add(nw, NL_RTA_VIA, 17, via);
155 }
156 break;
157 #endif
158 }
159 }
160
161 static void
dump_rc_nhop_mtu(struct nl_writer * nw,const struct nhop_object * nh)162 dump_rc_nhop_mtu(struct nl_writer *nw, const struct nhop_object *nh)
163 {
164 int nla_len = sizeof(struct nlattr) * 2 + sizeof(uint32_t);
165 struct nlattr *nla = nlmsg_reserve_data(nw, nla_len, struct nlattr);
166
167 if (nla == NULL)
168 return;
169 nla->nla_type = NL_RTA_METRICS;
170 nla->nla_len = nla_len;
171 nla++;
172 nla->nla_type = NL_RTAX_MTU;
173 nla->nla_len = sizeof(struct nlattr) + sizeof(uint32_t);
174 *((uint32_t *)(nla + 1)) = nh->nh_mtu;
175 }
176
177 #ifdef ROUTE_MPATH
178 static void
dump_rc_nhg(struct nl_writer * nw,const struct nhgrp_object * nhg,struct rtmsg * rtm)179 dump_rc_nhg(struct nl_writer *nw, const struct nhgrp_object *nhg, struct rtmsg *rtm)
180 {
181 uint32_t uidx = nhgrp_get_uidx(nhg);
182 uint32_t num_nhops;
183 const struct weightened_nhop *wn = nhgrp_get_nhops(nhg, &num_nhops);
184 uint32_t base_rtflags = nhop_get_rtflags(wn[0].nh);
185
186 if (uidx != 0)
187 nlattr_add_u32(nw, NL_RTA_NH_ID, uidx);
188 nlattr_add_u32(nw, NL_RTA_KNH_ID, nhgrp_get_idx(nhg));
189
190 nlattr_add_u32(nw, NL_RTA_RTFLAGS, base_rtflags);
191 int off = nlattr_add_nested(nw, NL_RTA_MULTIPATH);
192 if (off == 0)
193 return;
194
195 for (int i = 0; i < num_nhops; i++) {
196 int nh_off = nlattr_save_offset(nw);
197 struct rtnexthop *rtnh = nlmsg_reserve_object(nw, struct rtnexthop);
198 if (rtnh == NULL)
199 return;
200 rtnh->rtnh_flags = 0;
201 rtnh->rtnh_ifindex = wn[i].nh->nh_ifp->if_index;
202 rtnh->rtnh_hops = wn[i].weight;
203 dump_rc_nhop_gw(nw, wn[i].nh);
204 uint32_t rtflags = nhop_get_rtflags(wn[i].nh);
205 if (rtflags != base_rtflags)
206 nlattr_add_u32(nw, NL_RTA_RTFLAGS, rtflags);
207 if (rtflags & RTF_FIXEDMTU)
208 dump_rc_nhop_mtu(nw, wn[i].nh);
209 rtnh = nlattr_restore_offset(nw, nh_off, struct rtnexthop);
210 /*
211 * nlattr_add() allocates 4-byte aligned storage, no need to aligh
212 * length here
213 * */
214 rtnh->rtnh_len = nlattr_save_offset(nw) - nh_off;
215 }
216 nlattr_set_len(nw, off);
217 }
218 #endif
219
220 static void
dump_rc_nhop(struct nl_writer * nw,const struct route_nhop_data * rnd,struct rtmsg * rtm)221 dump_rc_nhop(struct nl_writer *nw, const struct route_nhop_data *rnd, struct rtmsg *rtm)
222 {
223 #ifdef ROUTE_MPATH
224 if (NH_IS_NHGRP(rnd->rnd_nhop)) {
225 dump_rc_nhg(nw, rnd->rnd_nhgrp, rtm);
226 return;
227 }
228 #endif
229 const struct nhop_object *nh = rnd->rnd_nhop;
230 uint32_t rtflags = nhop_get_rtflags(nh);
231
232 /*
233 * IPv4 over IPv6
234 * ('RTA_VIA', {'family': 10, 'addr': 'fe80::20c:29ff:fe67:2dd'}), ('RTA_OIF', 2),
235 * IPv4 w/ gw
236 * ('RTA_GATEWAY', '172.16.107.131'), ('RTA_OIF', 2)],
237 * Direct route:
238 * ('RTA_OIF', 2)
239 */
240 if (nh->nh_flags & NHF_GATEWAY)
241 dump_rc_nhop_gw(nw, nh);
242
243 uint32_t uidx = nhop_get_uidx(nh);
244 if (uidx != 0)
245 nlattr_add_u32(nw, NL_RTA_NH_ID, uidx);
246 nlattr_add_u32(nw, NL_RTA_KNH_ID, nhop_get_idx(nh));
247 nlattr_add_u32(nw, NL_RTA_RTFLAGS, rtflags);
248
249 if (rtflags & RTF_FIXEDMTU)
250 dump_rc_nhop_mtu(nw, nh);
251 uint32_t nh_expire = nhop_get_expire(nh);
252 if (nh_expire > 0)
253 nlattr_add_u32(nw, NL_RTA_EXPIRES, nh_expire - time_uptime);
254
255 /* In any case, fill outgoing interface */
256 nlattr_add_u32(nw, NL_RTA_OIF, nh->nh_ifp->if_index);
257
258 if (rnd->rnd_weight != RT_DEFAULT_WEIGHT)
259 nlattr_add_u32(nw, NL_RTA_WEIGHT, rnd->rnd_weight);
260 }
261
262 /*
263 * Dumps output from a rib command into an rtmsg
264 */
265
266 static int
dump_px(uint32_t fibnum,const struct nlmsghdr * hdr,const struct rtentry * rt,struct route_nhop_data * rnd,struct nl_writer * nw)267 dump_px(uint32_t fibnum, const struct nlmsghdr *hdr,
268 const struct rtentry *rt, struct route_nhop_data *rnd,
269 struct nl_writer *nw)
270 {
271 struct rtmsg *rtm;
272 int error = 0;
273
274 NET_EPOCH_ASSERT();
275
276 if (!nlmsg_reply(nw, hdr, sizeof(struct rtmsg)))
277 goto enomem;
278
279 int family = rt_get_family(rt);
280 int rtm_off = nlattr_save_offset(nw);
281 rtm = nlmsg_reserve_object(nw, struct rtmsg);
282 rtm->rtm_family = family;
283 rtm->rtm_dst_len = 0;
284 rtm->rtm_src_len = 0;
285 rtm->rtm_tos = 0;
286 if (fibnum < 255)
287 rtm->rtm_table = (unsigned char)fibnum;
288 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
289 rtm->rtm_protocol = nl_get_rtm_protocol(rnd->rnd_nhop);
290 rtm->rtm_type = get_rtm_type(rnd->rnd_nhop);
291
292 nlattr_add_u32(nw, NL_RTA_TABLE, fibnum);
293
294 int plen = 0;
295 #if defined(INET) || defined(INET6)
296 uint32_t scopeid;
297 #endif
298 switch (family) {
299 #ifdef INET
300 case AF_INET:
301 {
302 struct in_addr addr;
303 rt_get_inet_prefix_plen(rt, &addr, &plen, &scopeid);
304 nlattr_add(nw, NL_RTA_DST, 4, &addr);
305 break;
306 }
307 #endif
308 #ifdef INET6
309 case AF_INET6:
310 {
311 struct in6_addr addr;
312 rt_get_inet6_prefix_plen(rt, &addr, &plen, &scopeid);
313 nlattr_add(nw, NL_RTA_DST, 16, &addr);
314 break;
315 }
316 #endif
317 default:
318 FIB_LOG(LOG_NOTICE, fibnum, family, "unsupported rt family: %d", family);
319 error = EAFNOSUPPORT;
320 goto flush;
321 }
322
323 rtm = nlattr_restore_offset(nw, rtm_off, struct rtmsg);
324 if (plen > 0)
325 rtm->rtm_dst_len = plen;
326 dump_rc_nhop(nw, rnd, rtm);
327
328 if (nlmsg_end(nw))
329 return (0);
330 enomem:
331 error = ENOMEM;
332 flush:
333 nlmsg_abort(nw);
334 return (error);
335 }
336
337 static int
family_to_group(int family)338 family_to_group(int family)
339 {
340 switch (family) {
341 case AF_INET:
342 return (RTNLGRP_IPV4_ROUTE);
343 case AF_INET6:
344 return (RTNLGRP_IPV6_ROUTE);
345 }
346 return (0);
347 }
348
349
350 static void
report_operation(uint32_t fibnum,struct rib_cmd_info * rc,struct nlpcb * nlp,struct nlmsghdr * hdr)351 report_operation(uint32_t fibnum, struct rib_cmd_info *rc,
352 struct nlpcb *nlp, struct nlmsghdr *hdr)
353 {
354 struct nl_writer nw = {};
355 uint32_t group_id = family_to_group(rt_get_family(rc->rc_rt));
356
357 if (nlmsg_get_group_writer(&nw, NLMSG_SMALL, NETLINK_ROUTE, group_id)) {
358 struct route_nhop_data rnd = {
359 .rnd_nhop = rc_get_nhop(rc),
360 .rnd_weight = rc->rc_nh_weight,
361 };
362 hdr->nlmsg_flags &= ~(NLM_F_REPLACE | NLM_F_CREATE);
363 hdr->nlmsg_flags &= ~(NLM_F_EXCL | NLM_F_APPEND);
364 switch (rc->rc_cmd) {
365 case RTM_ADD:
366 hdr->nlmsg_type = NL_RTM_NEWROUTE;
367 hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_EXCL;
368 break;
369 case RTM_CHANGE:
370 hdr->nlmsg_type = NL_RTM_NEWROUTE;
371 hdr->nlmsg_flags |= NLM_F_REPLACE;
372 break;
373 case RTM_DELETE:
374 hdr->nlmsg_type = NL_RTM_DELROUTE;
375 break;
376 }
377 dump_px(fibnum, hdr, rc->rc_rt, &rnd, &nw);
378 nlmsg_flush(&nw);
379 }
380
381 rtsock_callback_p->route_f(fibnum, rc);
382 }
383
384 struct rta_mpath_nh {
385 struct sockaddr *gw;
386 struct ifnet *ifp;
387 uint8_t rtnh_flags;
388 uint8_t rtnh_weight;
389 };
390
391 #define _IN(_field) offsetof(struct rtnexthop, _field)
392 #define _OUT(_field) offsetof(struct rta_mpath_nh, _field)
393 const static struct nlattr_parser nla_p_rtnh[] = {
394 { .type = NL_RTA_GATEWAY, .off = _OUT(gw), .cb = nlattr_get_ip },
395 { .type = NL_RTA_VIA, .off = _OUT(gw), .cb = nlattr_get_ipvia },
396 };
397 const static struct nlfield_parser nlf_p_rtnh[] = {
398 { .off_in = _IN(rtnh_flags), .off_out = _OUT(rtnh_flags), .cb = nlf_get_u8 },
399 { .off_in = _IN(rtnh_hops), .off_out = _OUT(rtnh_weight), .cb = nlf_get_u8 },
400 { .off_in = _IN(rtnh_ifindex), .off_out = _OUT(ifp), .cb = nlf_get_ifpz },
401 };
402 #undef _IN
403 #undef _OUT
404 NL_DECLARE_PARSER(mpath_parser, struct rtnexthop, nlf_p_rtnh, nla_p_rtnh);
405
406 struct rta_mpath {
407 int num_nhops;
408 struct rta_mpath_nh nhops[0];
409 };
410
411 static int
nlattr_get_multipath(struct nlattr * nla,struct nl_pstate * npt,const void * arg,void * target)412 nlattr_get_multipath(struct nlattr *nla, struct nl_pstate *npt, const void *arg, void *target)
413 {
414 int data_len = nla->nla_len - sizeof(struct nlattr);
415 struct rtnexthop *rtnh;
416
417 int max_nhops = data_len / sizeof(struct rtnexthop);
418
419 struct rta_mpath *mp = npt_alloc(npt, (max_nhops + 2) * sizeof(struct rta_mpath_nh));
420 mp->num_nhops = 0;
421
422 for (rtnh = (struct rtnexthop *)(nla + 1); data_len > 0; ) {
423 struct rta_mpath_nh *mpnh = &mp->nhops[mp->num_nhops++];
424
425 int error = nl_parse_header(rtnh, rtnh->rtnh_len, &mpath_parser,
426 npt, mpnh);
427 if (error != 0) {
428 NLMSG_REPORT_ERR_MSG(npt, "RTA_MULTIPATH: nexhop %d: parse failed",
429 mp->num_nhops - 1);
430 return (error);
431 }
432
433 int len = NL_ITEM_ALIGN(rtnh->rtnh_len);
434 data_len -= len;
435 rtnh = (struct rtnexthop *)((char *)rtnh + len);
436 }
437 if (data_len != 0 || mp->num_nhops == 0) {
438 NLMSG_REPORT_ERR_MSG(npt, "invalid RTA_MULTIPATH attr");
439 return (EINVAL);
440 }
441
442 *((struct rta_mpath **)target) = mp;
443 return (0);
444 }
445
446
447 struct nl_parsed_route {
448 struct sockaddr *rta_dst;
449 struct sockaddr *rta_gw;
450 struct ifnet *rta_oif;
451 struct rta_mpath *rta_multipath;
452 uint32_t rta_table;
453 uint32_t rta_rtflags;
454 uint32_t rta_nh_id;
455 uint32_t rta_weight;
456 uint32_t rtax_mtu;
457 uint8_t rtm_family;
458 uint8_t rtm_dst_len;
459 uint8_t rtm_protocol;
460 uint8_t rtm_type;
461 };
462
463 #define _IN(_field) offsetof(struct rtmsg, _field)
464 #define _OUT(_field) offsetof(struct nl_parsed_route, _field)
465 static struct nlattr_parser nla_p_rtmetrics[] = {
466 { .type = NL_RTAX_MTU, .off = _OUT(rtax_mtu), .cb = nlattr_get_uint32 },
467 };
468 NL_DECLARE_ATTR_PARSER(metrics_parser, nla_p_rtmetrics);
469
470 static const struct nlattr_parser nla_p_rtmsg[] = {
471 { .type = NL_RTA_DST, .off = _OUT(rta_dst), .cb = nlattr_get_ip },
472 { .type = NL_RTA_OIF, .off = _OUT(rta_oif), .cb = nlattr_get_ifp },
473 { .type = NL_RTA_GATEWAY, .off = _OUT(rta_gw), .cb = nlattr_get_ip },
474 { .type = NL_RTA_METRICS, .arg = &metrics_parser, .cb = nlattr_get_nested },
475 { .type = NL_RTA_MULTIPATH, .off = _OUT(rta_multipath), .cb = nlattr_get_multipath },
476 { .type = NL_RTA_WEIGHT, .off = _OUT(rta_weight), .cb = nlattr_get_uint32 },
477 { .type = NL_RTA_RTFLAGS, .off = _OUT(rta_rtflags), .cb = nlattr_get_uint32 },
478 { .type = NL_RTA_TABLE, .off = _OUT(rta_table), .cb = nlattr_get_uint32 },
479 { .type = NL_RTA_VIA, .off = _OUT(rta_gw), .cb = nlattr_get_ipvia },
480 { .type = NL_RTA_NH_ID, .off = _OUT(rta_nh_id), .cb = nlattr_get_uint32 },
481 };
482
483 static const struct nlfield_parser nlf_p_rtmsg[] = {
484 { .off_in = _IN(rtm_family), .off_out = _OUT(rtm_family), .cb = nlf_get_u8 },
485 { .off_in = _IN(rtm_dst_len), .off_out = _OUT(rtm_dst_len), .cb = nlf_get_u8 },
486 { .off_in = _IN(rtm_protocol), .off_out = _OUT(rtm_protocol), .cb = nlf_get_u8 },
487 { .off_in = _IN(rtm_type), .off_out = _OUT(rtm_type), .cb = nlf_get_u8 },
488 };
489 #undef _IN
490 #undef _OUT
491 NL_DECLARE_PARSER(rtm_parser, struct rtmsg, nlf_p_rtmsg, nla_p_rtmsg);
492
493 struct netlink_walkargs {
494 struct nl_writer *nw;
495 struct route_nhop_data rnd;
496 struct nlmsghdr hdr;
497 struct nlpcb *nlp;
498 uint32_t fibnum;
499 int family;
500 int error;
501 int count;
502 int dumped;
503 int dumped_tables;
504 };
505
506 static int
dump_rtentry(struct rtentry * rt,void * _arg)507 dump_rtentry(struct rtentry *rt, void *_arg)
508 {
509 struct netlink_walkargs *wa = (struct netlink_walkargs *)_arg;
510 int error;
511
512 wa->count++;
513 if (wa->error != 0)
514 return (0);
515 wa->dumped++;
516
517 rt_get_rnd(rt, &wa->rnd);
518
519 error = dump_px(wa->fibnum, &wa->hdr, rt, &wa->rnd, wa->nw);
520
521 IF_DEBUG_LEVEL(LOG_DEBUG3) {
522 char rtbuf[INET6_ADDRSTRLEN + 5];
523 FIB_LOG(LOG_DEBUG3, wa->fibnum, wa->family,
524 "Dump %s, offset %u, error %d",
525 rt_print_buf(rt, rtbuf, sizeof(rtbuf)),
526 wa->nw->offset, error);
527 }
528 wa->error = error;
529
530 return (0);
531 }
532
533 static void
dump_rtable_one(struct netlink_walkargs * wa,uint32_t fibnum,int family)534 dump_rtable_one(struct netlink_walkargs *wa, uint32_t fibnum, int family)
535 {
536 FIB_LOG(LOG_DEBUG2, fibnum, family, "Start dump");
537 wa->count = 0;
538 wa->dumped = 0;
539
540 rib_walk(fibnum, family, false, dump_rtentry, wa);
541
542 wa->dumped_tables++;
543
544 FIB_LOG(LOG_DEBUG2, fibnum, family, "End dump, iterated %d dumped %d",
545 wa->count, wa->dumped);
546 NL_LOG(LOG_DEBUG2, "Current offset: %d", wa->nw->offset);
547 }
548
549 static int
dump_rtable_fib(struct netlink_walkargs * wa,uint32_t fibnum,int family)550 dump_rtable_fib(struct netlink_walkargs *wa, uint32_t fibnum, int family)
551 {
552 wa->fibnum = fibnum;
553
554 if (family == AF_UNSPEC) {
555 for (int i = 0; i < AF_MAX; i++) {
556 if (rt_tables_get_rnh(fibnum, i) != 0) {
557 wa->family = i;
558 dump_rtable_one(wa, fibnum, i);
559 if (wa->error != 0)
560 break;
561 }
562 }
563 } else {
564 if (rt_tables_get_rnh(fibnum, family) != 0) {
565 wa->family = family;
566 dump_rtable_one(wa, fibnum, family);
567 }
568 }
569
570 return (wa->error);
571 }
572
573 static int
handle_rtm_getroute(struct nlpcb * nlp,struct nl_parsed_route * attrs,struct nlmsghdr * hdr,struct nl_pstate * npt)574 handle_rtm_getroute(struct nlpcb *nlp, struct nl_parsed_route *attrs,
575 struct nlmsghdr *hdr, struct nl_pstate *npt)
576 {
577 RIB_RLOCK_TRACKER;
578 struct rib_head *rnh;
579 struct rtentry *rt;
580 uint32_t fibnum = attrs->rta_table;
581 sa_family_t family = attrs->rtm_family;
582
583 if (attrs->rta_dst == NULL) {
584 NLMSG_REPORT_ERR_MSG(npt, "No RTA_DST supplied");
585 return (EINVAL);
586 }
587
588 FIB_LOG(LOG_DEBUG, fibnum, family, "getroute called");
589
590 rnh = rt_tables_get_rnh(fibnum, family);
591 if (rnh == NULL)
592 return (EAFNOSUPPORT);
593
594 RIB_RLOCK(rnh);
595
596 rt = (struct rtentry *)rnh->rnh_matchaddr(attrs->rta_dst, &rnh->head);
597 if (rt == NULL) {
598 RIB_RUNLOCK(rnh);
599 return (ESRCH);
600 }
601
602 struct route_nhop_data rnd;
603 rt_get_rnd(rt, &rnd);
604 rnd.rnd_nhop = nhop_select_func(rnd.rnd_nhop, 0);
605
606 RIB_RUNLOCK(rnh);
607
608 IF_DEBUG_LEVEL(LOG_DEBUG2) {
609 char rtbuf[NHOP_PRINT_BUFSIZE] __unused, nhbuf[NHOP_PRINT_BUFSIZE] __unused;
610 FIB_LOG(LOG_DEBUG2, fibnum, family, "getroute completed: got %s for %s",
611 nhop_print_buf_any(rnd.rnd_nhop, nhbuf, sizeof(nhbuf)),
612 rt_print_buf(rt, rtbuf, sizeof(rtbuf)));
613 }
614
615 hdr->nlmsg_type = NL_RTM_NEWROUTE;
616 dump_px(fibnum, hdr, rt, &rnd, npt->nw);
617
618 return (0);
619 }
620
621 static int
handle_rtm_dump(struct nlpcb * nlp,uint32_t fibnum,int family,struct nlmsghdr * hdr,struct nl_writer * nw)622 handle_rtm_dump(struct nlpcb *nlp, uint32_t fibnum, int family,
623 struct nlmsghdr *hdr, struct nl_writer *nw)
624 {
625 struct netlink_walkargs wa = {
626 .nlp = nlp,
627 .nw = nw,
628 .hdr.nlmsg_pid = hdr->nlmsg_pid,
629 .hdr.nlmsg_seq = hdr->nlmsg_seq,
630 .hdr.nlmsg_type = NL_RTM_NEWROUTE,
631 .hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI,
632 };
633
634 if (fibnum == RT_TABLE_UNSPEC) {
635 for (int i = 0; i < V_rt_numfibs; i++) {
636 dump_rtable_fib(&wa, fibnum, family);
637 if (wa.error != 0)
638 break;
639 }
640 } else
641 dump_rtable_fib(&wa, fibnum, family);
642
643 if (wa.error == 0 && wa.dumped_tables == 0) {
644 FIB_LOG(LOG_DEBUG, fibnum, family, "incorrect fibnum/family");
645 wa.error = ESRCH;
646 // How do we propagate it?
647 }
648
649 if (!nlmsg_end_dump(wa.nw, wa.error, &wa.hdr)) {
650 NL_LOG(LOG_DEBUG, "Unable to finalize the dump");
651 return (ENOMEM);
652 }
653
654 return (wa.error);
655 }
656
657 static struct nhop_object *
finalize_nhop(struct nhop_object * nh,int * perror)658 finalize_nhop(struct nhop_object *nh, int *perror)
659 {
660 /*
661 * The following MUST be filled:
662 * nh_ifp, nh_ifa, nh_gw
663 */
664 if (nh->gw_sa.sa_family == 0) {
665 /*
666 * Empty gateway. Can be direct route with RTA_OIF set.
667 */
668 if (nh->nh_ifp != NULL)
669 nhop_set_direct_gw(nh, nh->nh_ifp);
670 else {
671 NL_LOG(LOG_DEBUG, "empty gateway and interface, skipping");
672 *perror = EINVAL;
673 return (NULL);
674 }
675 /* Both nh_ifp and gateway are set */
676 } else {
677 /* Gateway is set up, we can derive ifp if not set */
678 if (nh->nh_ifp == NULL) {
679 struct ifaddr *ifa = ifa_ifwithnet(&nh->gw_sa, 1, nhop_get_fibnum(nh));
680 if (ifa == NULL) {
681 NL_LOG(LOG_DEBUG, "Unable to determine ifp, skipping");
682 *perror = EINVAL;
683 return (NULL);
684 }
685 nhop_set_transmit_ifp(nh, ifa->ifa_ifp);
686 }
687 }
688 /* Both nh_ifp and gateway are set */
689 if (nh->nh_ifa == NULL) {
690 struct ifaddr *ifa = ifaof_ifpforaddr(&nh->gw_sa, nh->nh_ifp);
691 if (ifa == NULL) {
692 NL_LOG(LOG_DEBUG, "Unable to determine ifa, skipping");
693 *perror = EINVAL;
694 return (NULL);
695 }
696 nhop_set_src(nh, ifa);
697 }
698
699 return (nhop_get_nhop(nh, perror));
700 }
701
702 static int
get_pxflag(const struct nl_parsed_route * attrs)703 get_pxflag(const struct nl_parsed_route *attrs)
704 {
705 int pxflag = 0;
706 switch (attrs->rtm_family) {
707 case AF_INET:
708 if (attrs->rtm_dst_len == 32)
709 pxflag = NHF_HOST;
710 else if (attrs->rtm_dst_len == 0)
711 pxflag = NHF_DEFAULT;
712 break;
713 case AF_INET6:
714 if (attrs->rtm_dst_len == 32)
715 pxflag = NHF_HOST;
716 else if (attrs->rtm_dst_len == 0)
717 pxflag = NHF_DEFAULT;
718 break;
719 }
720
721 return (pxflag);
722 }
723
724 static int
get_op_flags(int nlm_flags)725 get_op_flags(int nlm_flags)
726 {
727 int op_flags = 0;
728
729 op_flags |= (nlm_flags & NLM_F_REPLACE) ? RTM_F_REPLACE : 0;
730 op_flags |= (nlm_flags & NLM_F_EXCL) ? RTM_F_EXCL : 0;
731 op_flags |= (nlm_flags & NLM_F_CREATE) ? RTM_F_CREATE : 0;
732 op_flags |= (nlm_flags & NLM_F_APPEND) ? RTM_F_APPEND : 0;
733
734 return (op_flags);
735 }
736
737 #ifdef ROUTE_MPATH
738 static int
create_nexthop_one(struct nl_parsed_route * attrs,struct rta_mpath_nh * mpnh,struct nl_pstate * npt,struct nhop_object ** pnh)739 create_nexthop_one(struct nl_parsed_route *attrs, struct rta_mpath_nh *mpnh,
740 struct nl_pstate *npt, struct nhop_object **pnh)
741 {
742 int error;
743
744 if (mpnh->gw == NULL)
745 return (EINVAL);
746
747 struct nhop_object *nh = nhop_alloc(attrs->rta_table, attrs->rtm_family);
748 if (nh == NULL)
749 return (ENOMEM);
750
751 error = nl_set_nexthop_gw(nh, mpnh->gw, mpnh->ifp, npt);
752 if (error != 0) {
753 nhop_free(nh);
754 return (error);
755 }
756 if (mpnh->ifp != NULL)
757 nhop_set_transmit_ifp(nh, mpnh->ifp);
758 nhop_set_rtflags(nh, attrs->rta_rtflags);
759 if (attrs->rtm_protocol > RTPROT_STATIC)
760 nhop_set_origin(nh, attrs->rtm_protocol);
761
762 *pnh = finalize_nhop(nh, &error);
763
764 return (error);
765 }
766 #endif
767
768 static struct nhop_object *
create_nexthop_from_attrs(struct nl_parsed_route * attrs,struct nl_pstate * npt,int * perror)769 create_nexthop_from_attrs(struct nl_parsed_route *attrs,
770 struct nl_pstate *npt, int *perror)
771 {
772 struct nhop_object *nh = NULL;
773 int error = 0;
774
775 if (attrs->rta_multipath != NULL) {
776 #ifdef ROUTE_MPATH
777 /* Multipath w/o explicit nexthops */
778 int num_nhops = attrs->rta_multipath->num_nhops;
779 struct weightened_nhop *wn = npt_alloc(npt, sizeof(*wn) * num_nhops);
780
781 for (int i = 0; i < num_nhops; i++) {
782 struct rta_mpath_nh *mpnh = &attrs->rta_multipath->nhops[i];
783
784 error = create_nexthop_one(attrs, mpnh, npt, &wn[i].nh);
785 if (error != 0) {
786 for (int j = 0; j < i; j++)
787 nhop_free(wn[j].nh);
788 break;
789 }
790 wn[i].weight = mpnh->rtnh_weight > 0 ? mpnh->rtnh_weight : 1;
791 }
792 if (error == 0) {
793 struct rib_head *rh = nhop_get_rh(wn[0].nh);
794 struct nhgrp_object *nhg;
795
796 nhg = nhgrp_alloc(rh->rib_fibnum, rh->rib_family,
797 wn, num_nhops, perror);
798 if (nhg != NULL) {
799 if (attrs->rtm_protocol > RTPROT_STATIC)
800 nhgrp_set_origin(nhg, attrs->rtm_protocol);
801 nhg = nhgrp_get_nhgrp(nhg, perror);
802 }
803 for (int i = 0; i < num_nhops; i++)
804 nhop_free(wn[i].nh);
805 if (nhg != NULL)
806 return ((struct nhop_object *)nhg);
807 error = *perror;
808 }
809 #else
810 error = ENOTSUP;
811 #endif
812 *perror = error;
813 } else {
814 nh = nhop_alloc(attrs->rta_table, attrs->rtm_family);
815 if (nh == NULL) {
816 *perror = ENOMEM;
817 return (NULL);
818 }
819 if (attrs->rta_gw != NULL) {
820 *perror = nl_set_nexthop_gw(nh, attrs->rta_gw, attrs->rta_oif, npt);
821 if (*perror != 0) {
822 nhop_free(nh);
823 return (NULL);
824 }
825 }
826 if (attrs->rta_oif != NULL)
827 nhop_set_transmit_ifp(nh, attrs->rta_oif);
828 if (attrs->rtax_mtu != 0)
829 nhop_set_mtu(nh, attrs->rtax_mtu, true);
830 if (attrs->rta_rtflags & RTF_BROADCAST)
831 nhop_set_broadcast(nh, true);
832 if (attrs->rtm_protocol > RTPROT_STATIC)
833 nhop_set_origin(nh, attrs->rtm_protocol);
834 nhop_set_rtflags(nh, attrs->rta_rtflags);
835
836 switch (attrs->rtm_type) {
837 case RTN_UNICAST:
838 break;
839 case RTN_BLACKHOLE:
840 nhop_set_blackhole(nh, RTF_BLACKHOLE);
841 break;
842 case RTN_PROHIBIT:
843 case RTN_UNREACHABLE:
844 nhop_set_blackhole(nh, RTF_REJECT);
845 break;
846 /* TODO: return ENOTSUP for other types if strict option is set */
847 }
848
849 nh = finalize_nhop(nh, perror);
850 }
851
852 return (nh);
853 }
854
855 static int
rtnl_handle_newroute(struct nlmsghdr * hdr,struct nlpcb * nlp,struct nl_pstate * npt)856 rtnl_handle_newroute(struct nlmsghdr *hdr, struct nlpcb *nlp,
857 struct nl_pstate *npt)
858 {
859 struct rib_cmd_info rc = {};
860 struct nhop_object *nh = NULL;
861 int error;
862
863 struct nl_parsed_route attrs = {};
864 error = nl_parse_nlmsg(hdr, &rtm_parser, npt, &attrs);
865 if (error != 0)
866 return (error);
867
868 /* Check if we have enough data */
869 if (attrs.rta_dst == NULL) {
870 NL_LOG(LOG_DEBUG, "missing RTA_DST");
871 return (EINVAL);
872 }
873
874 if (attrs.rta_table >= V_rt_numfibs) {
875 NLMSG_REPORT_ERR_MSG(npt, "invalid fib");
876 return (EINVAL);
877 }
878
879 if (attrs.rta_nh_id != 0) {
880 /* Referenced uindex */
881 int pxflag = get_pxflag(&attrs);
882 nh = nl_find_nhop(attrs.rta_table, attrs.rtm_family, attrs.rta_nh_id,
883 pxflag, &error);
884 if (error != 0)
885 return (error);
886 } else {
887 nh = create_nexthop_from_attrs(&attrs, npt, &error);
888 if (error != 0) {
889 NL_LOG(LOG_DEBUG, "Error creating nexthop");
890 return (error);
891 }
892 }
893
894 if (!NH_IS_NHGRP(nh) && attrs.rta_weight == 0)
895 attrs.rta_weight = RT_DEFAULT_WEIGHT;
896 struct route_nhop_data rnd = { .rnd_nhop = nh, .rnd_weight = attrs.rta_weight };
897 int op_flags = get_op_flags(hdr->nlmsg_flags);
898
899 error = rib_add_route_px(attrs.rta_table, attrs.rta_dst, attrs.rtm_dst_len,
900 &rnd, op_flags, &rc);
901 if (error == 0)
902 report_operation(attrs.rta_table, &rc, nlp, hdr);
903 return (error);
904 }
905
906 static int
path_match_func(const struct rtentry * rt,const struct nhop_object * nh,void * _data)907 path_match_func(const struct rtentry *rt, const struct nhop_object *nh, void *_data)
908 {
909 struct nl_parsed_route *attrs = (struct nl_parsed_route *)_data;
910
911 if ((attrs->rta_gw != NULL) && !rib_match_gw(rt, nh, attrs->rta_gw))
912 return (0);
913
914 if ((attrs->rta_oif != NULL) && (attrs->rta_oif != nh->nh_ifp))
915 return (0);
916
917 return (1);
918 }
919
920 static int
rtnl_handle_delroute(struct nlmsghdr * hdr,struct nlpcb * nlp,struct nl_pstate * npt)921 rtnl_handle_delroute(struct nlmsghdr *hdr, struct nlpcb *nlp,
922 struct nl_pstate *npt)
923 {
924 struct rib_cmd_info rc;
925 int error;
926
927 struct nl_parsed_route attrs = {};
928 error = nl_parse_nlmsg(hdr, &rtm_parser, npt, &attrs);
929 if (error != 0)
930 return (error);
931
932 if (attrs.rta_dst == NULL) {
933 NLMSG_REPORT_ERR_MSG(npt, "RTA_DST is not set");
934 return (ESRCH);
935 }
936
937 if (attrs.rta_table >= V_rt_numfibs) {
938 NLMSG_REPORT_ERR_MSG(npt, "invalid fib");
939 return (EINVAL);
940 }
941
942 error = rib_del_route_px(attrs.rta_table, attrs.rta_dst,
943 attrs.rtm_dst_len, path_match_func, &attrs,
944 (attrs.rta_rtflags & RTF_PINNED) ? RTM_F_FORCE : 0, &rc);
945 if (error == 0)
946 report_operation(attrs.rta_table, &rc, nlp, hdr);
947 return (error);
948 }
949
950 static int
rtnl_handle_getroute(struct nlmsghdr * hdr,struct nlpcb * nlp,struct nl_pstate * npt)951 rtnl_handle_getroute(struct nlmsghdr *hdr, struct nlpcb *nlp, struct nl_pstate *npt)
952 {
953 int error;
954
955 struct nl_parsed_route attrs = {};
956 error = nl_parse_nlmsg(hdr, &rtm_parser, npt, &attrs);
957 if (error != 0)
958 return (error);
959
960 if (attrs.rta_table >= V_rt_numfibs) {
961 NLMSG_REPORT_ERR_MSG(npt, "invalid fib");
962 return (EINVAL);
963 }
964
965 if (hdr->nlmsg_flags & NLM_F_DUMP)
966 error = handle_rtm_dump(nlp, attrs.rta_table, attrs.rtm_family, hdr, npt->nw);
967 else
968 error = handle_rtm_getroute(nlp, &attrs, hdr, npt);
969
970 return (error);
971 }
972
973 void
rtnl_handle_route_event(uint32_t fibnum,const struct rib_cmd_info * rc)974 rtnl_handle_route_event(uint32_t fibnum, const struct rib_cmd_info *rc)
975 {
976 struct nl_writer nw = {};
977 int family, nlm_flags = 0;
978
979 family = rt_get_family(rc->rc_rt);
980
981 /* XXX: check if there are active listeners first */
982
983 /* TODO: consider passing PID/type/seq */
984 switch (rc->rc_cmd) {
985 case RTM_ADD:
986 nlm_flags = NLM_F_EXCL | NLM_F_CREATE;
987 break;
988 case RTM_CHANGE:
989 nlm_flags = NLM_F_REPLACE;
990 break;
991 case RTM_DELETE:
992 nlm_flags = 0;
993 break;
994 }
995 IF_DEBUG_LEVEL(LOG_DEBUG2) {
996 char rtbuf[NHOP_PRINT_BUFSIZE] __unused;
997 FIB_LOG(LOG_DEBUG2, fibnum, family,
998 "received event %s for %s / nlm_flags=%X",
999 rib_print_cmd(rc->rc_cmd),
1000 rt_print_buf(rc->rc_rt, rtbuf, sizeof(rtbuf)),
1001 nlm_flags);
1002 }
1003
1004 struct nlmsghdr hdr = {
1005 .nlmsg_flags = nlm_flags,
1006 .nlmsg_type = get_rtmsg_type_from_rtsock(rc->rc_cmd),
1007 };
1008
1009 struct route_nhop_data rnd = {
1010 .rnd_nhop = rc_get_nhop(rc),
1011 .rnd_weight = rc->rc_nh_weight,
1012 };
1013
1014 uint32_t group_id = family_to_group(family);
1015 if (!nlmsg_get_group_writer(&nw, NLMSG_SMALL, NETLINK_ROUTE, group_id)) {
1016 NL_LOG(LOG_DEBUG, "error allocating event buffer");
1017 return;
1018 }
1019
1020 dump_px(fibnum, &hdr, rc->rc_rt, &rnd, &nw);
1021 nlmsg_flush(&nw);
1022 }
1023
1024 static const struct rtnl_cmd_handler cmd_handlers[] = {
1025 {
1026 .cmd = NL_RTM_GETROUTE,
1027 .name = "RTM_GETROUTE",
1028 .cb = &rtnl_handle_getroute,
1029 },
1030 {
1031 .cmd = NL_RTM_DELROUTE,
1032 .name = "RTM_DELROUTE",
1033 .cb = &rtnl_handle_delroute,
1034 .priv = PRIV_NET_ROUTE,
1035 },
1036 {
1037 .cmd = NL_RTM_NEWROUTE,
1038 .name = "RTM_NEWROUTE",
1039 .cb = &rtnl_handle_newroute,
1040 .priv = PRIV_NET_ROUTE,
1041 }
1042 };
1043
1044 static const struct nlhdr_parser *all_parsers[] = {&mpath_parser, &metrics_parser, &rtm_parser};
1045
1046 void
rtnl_routes_init(void)1047 rtnl_routes_init(void)
1048 {
1049 NL_VERIFY_PARSERS(all_parsers);
1050 rtnl_register_messages(cmd_handlers, NL_ARRAY_LEN(cmd_handlers));
1051 }
1052