]> git.proxmox.com Git - mirror_frr.git/blame - zebra/kernel_netlink.c
Merge pull request #12798 from donaldsharp/rib_match_multicast
[mirror_frr.git] / zebra / kernel_netlink.c
CommitLineData
acddc0ed 1// SPDX-License-Identifier: GPL-2.0-or-later
718e3744 2/* Kernel communication using netlink interface.
3 * Copyright (C) 1999 Kunihiro Ishiguro
718e3744 4 */
1fdc9eae 5
6#include <zebra.h>
7
ddfeb486
DL
8#ifdef HAVE_NETLINK
9
1fdc9eae 10#include "linklist.h"
11#include "if.h"
12#include "log.h"
13#include "prefix.h"
14#include "connected.h"
15#include "table.h"
16#include "memory.h"
1fdc9eae 17#include "rib.h"
18#include "thread.h"
19#include "privs.h"
20#include "nexthop.h"
21#include "vrf.h"
22#include "mpls.h"
174482ef 23#include "lib_errors.h"
d4000d7b 24#include "hash.h"
1fdc9eae 25
3801e764 26#include "zebra/zebra_router.h"
1fdc9eae 27#include "zebra/zebra_ns.h"
28#include "zebra/zebra_vrf.h"
05f7f5db 29#include "zebra/rt.h"
1fdc9eae 30#include "zebra/debug.h"
31#include "zebra/kernel_netlink.h"
32#include "zebra/rt_netlink.h"
33#include "zebra/if_netlink.h"
942bf97b 34#include "zebra/rule_netlink.h"
449a30ed 35#include "zebra/tc_netlink.h"
ebb61fca 36#include "zebra/netconf_netlink.h"
43e52561 37#include "zebra/zebra_errors.h"
1fdc9eae 38
39#ifndef SO_RCVBUFFORCE
40#define SO_RCVBUFFORCE (33)
41#endif
42
43/* Hack for GNU libc version 2. */
44#ifndef MSG_TRUNC
45#define MSG_TRUNC 0x20
46#endif /* MSG_TRUNC */
47
48#ifndef NLMSG_TAIL
d62a17ae 49#define NLMSG_TAIL(nmsg) \
d7c0a89a
QY
50 ((struct rtattr *)(((uint8_t *)(nmsg)) \
51 + NLMSG_ALIGN((nmsg)->nlmsg_len)))
1fdc9eae 52#endif
53
54#ifndef RTA_TAIL
d62a17ae 55#define RTA_TAIL(rta) \
d7c0a89a 56 ((struct rtattr *)(((uint8_t *)(rta)) + RTA_ALIGN((rta)->rta_len)))
1fdc9eae 57#endif
58
f909c673
DS
59#ifndef RTNL_FAMILY_IP6MR
60#define RTNL_FAMILY_IP6MR 129
61#endif
62
63#ifndef RTPROT_MROUTED
64#define RTPROT_MROUTED 17
65#endif
66
531c92b8 67#define NL_DEFAULT_BATCH_BUFSIZE (16 * NL_PKT_BUF_SIZE)
e63c7622
JU
68
69/*
70 * We limit the batch's size to a number smaller than the length of the
71 * underlying buffer since the last message that wouldn't fit the batch would go
72 * over the upper boundary and then it would have to be encoded again into a new
73 * buffer. If the difference between the limit and the length of the buffer is
74 * big enough (bigger than the biggest Netlink message) then this situation
75 * won't occur.
76 */
531c92b8
JU
77#define NL_DEFAULT_BATCH_SEND_THRESHOLD (15 * NL_PKT_BUF_SIZE)
78
d62a17ae 79static const struct message nlmsg_str[] = {{RTM_NEWROUTE, "RTM_NEWROUTE"},
80 {RTM_DELROUTE, "RTM_DELROUTE"},
81 {RTM_GETROUTE, "RTM_GETROUTE"},
82 {RTM_NEWLINK, "RTM_NEWLINK"},
5d414138 83 {RTM_SETLINK, "RTM_SETLINK"},
d62a17ae 84 {RTM_DELLINK, "RTM_DELLINK"},
85 {RTM_GETLINK, "RTM_GETLINK"},
86 {RTM_NEWADDR, "RTM_NEWADDR"},
87 {RTM_DELADDR, "RTM_DELADDR"},
88 {RTM_GETADDR, "RTM_GETADDR"},
89 {RTM_NEWNEIGH, "RTM_NEWNEIGH"},
90 {RTM_DELNEIGH, "RTM_DELNEIGH"},
91 {RTM_GETNEIGH, "RTM_GETNEIGH"},
942bf97b 92 {RTM_NEWRULE, "RTM_NEWRULE"},
93 {RTM_DELRULE, "RTM_DELRULE"},
94 {RTM_GETRULE, "RTM_GETRULE"},
79580b5a
SW
95 {RTM_NEWNEXTHOP, "RTM_NEWNEXTHOP"},
96 {RTM_DELNEXTHOP, "RTM_DELNEXTHOP"},
97 {RTM_GETNEXTHOP, "RTM_GETNEXTHOP"},
ebb61fca
DS
98 {RTM_NEWNETCONF, "RTM_NEWNETCONF"},
99 {RTM_DELNETCONF, "RTM_DELNETCONF"},
acc8e687
CS
100 {RTM_NEWTUNNEL, "RTM_NEWTUNNEL"},
101 {RTM_DELTUNNEL, "RTM_DELTUNNEL"},
102 {RTM_GETTUNNEL, "RTM_GETTUNNEL"},
449a30ed
SY
103 {RTM_NEWQDISC, "RTM_NEWQDISC"},
104 {RTM_DELQDISC, "RTM_DELQDISC"},
105 {RTM_GETQDISC, "RTM_GETQDISC"},
106 {RTM_NEWTCLASS, "RTM_NEWTCLASS"},
107 {RTM_DELTCLASS, "RTM_DELTCLASS"},
108 {RTM_GETTCLASS, "RTM_GETTCLASS"},
109 {RTM_NEWTFILTER, "RTM_NEWTFILTER"},
110 {RTM_DELTFILTER, "RTM_DELTFILTER"},
111 {RTM_GETTFILTER, "RTM_GETTFILTER"},
a26daa77
SW
112 {RTM_NEWVLAN, "RTM_NEWVLAN"},
113 {RTM_DELVLAN, "RTM_DELVLAN"},
114 {RTM_GETVLAN, "RTM_GETVLAN"},
d62a17ae 115 {0}};
1fdc9eae 116
117static const struct message rtproto_str[] = {
d62a17ae 118 {RTPROT_REDIRECT, "redirect"},
119 {RTPROT_KERNEL, "kernel"},
120 {RTPROT_BOOT, "boot"},
121 {RTPROT_STATIC, "static"},
122 {RTPROT_GATED, "GateD"},
123 {RTPROT_RA, "router advertisement"},
124 {RTPROT_MRT, "MRT"},
125 {RTPROT_ZEBRA, "Zebra"},
1fdc9eae 126#ifdef RTPROT_BIRD
d62a17ae 127 {RTPROT_BIRD, "BIRD"},
1fdc9eae 128#endif /* RTPROT_BIRD */
d62a17ae 129 {RTPROT_MROUTED, "mroute"},
130 {RTPROT_BGP, "BGP"},
131 {RTPROT_OSPF, "OSPF"},
132 {RTPROT_ISIS, "IS-IS"},
133 {RTPROT_RIP, "RIP"},
134 {RTPROT_RIPNG, "RIPNG"},
d4d71f11 135 {RTPROT_ZSTATIC, "static"},
d62a17ae 136 {0}};
137
138static const struct message family_str[] = {{AF_INET, "ipv4"},
139 {AF_INET6, "ipv6"},
140 {AF_BRIDGE, "bridge"},
141 {RTNL_FAMILY_IPMR, "ipv4MR"},
142 {RTNL_FAMILY_IP6MR, "ipv6MR"},
143 {0}};
144
8c8f250b
DS
145static const struct message rttype_str[] = {{RTN_UNSPEC, "none"},
146 {RTN_UNICAST, "unicast"},
147 {RTN_LOCAL, "local"},
148 {RTN_BROADCAST, "broadcast"},
149 {RTN_ANYCAST, "anycast"},
d62a17ae 150 {RTN_MULTICAST, "multicast"},
8c8f250b
DS
151 {RTN_BLACKHOLE, "blackhole"},
152 {RTN_UNREACHABLE, "unreachable"},
153 {RTN_PROHIBIT, "prohibited"},
154 {RTN_THROW, "throw"},
155 {RTN_NAT, "nat"},
156 {RTN_XRESOLVE, "resolver"},
d62a17ae 157 {0}};
b339bde7 158
1fdc9eae 159extern struct thread_master *master;
1fdc9eae 160
161extern struct zebra_privs_t zserv_privs;
162
bf8d3d6a 163DEFINE_MTYPE_STATIC(ZEBRA, NL_BUF, "Zebra Netlink buffers");
531c92b8 164
34869809
MS
165/* Hashtable and mutex to allow lookup of nlsock structs by socket/fd value.
166 * We have both the main and dplane pthreads using these structs, so we have
167 * to protect the hash with a lock.
168 */
169static struct hash *nlsock_hash;
170pthread_mutex_t nlsock_mutex;
171
172/* Lock and unlock wrappers for nlsock hash */
173#define NLSOCK_LOCK() pthread_mutex_lock(&nlsock_mutex)
174#define NLSOCK_UNLOCK() pthread_mutex_unlock(&nlsock_mutex)
175
531c92b8
JU
176size_t nl_batch_tx_bufsize;
177char *nl_batch_tx_buf;
178
531c92b8
JU
179_Atomic uint32_t nl_batch_bufsize = NL_DEFAULT_BATCH_BUFSIZE;
180_Atomic uint32_t nl_batch_send_threshold = NL_DEFAULT_BATCH_SEND_THRESHOLD;
181
e63c7622
JU
182struct nl_batch {
183 void *buf;
184 size_t bufsiz;
185 size_t limit;
186
187 void *buf_head;
188 size_t curlen;
189 size_t msgcnt;
190
191 const struct zebra_dplane_info *zns;
e63c7622 192
ac96497c 193 struct dplane_ctx_list_head ctx_list;
e63c7622 194
f6feb48b
JU
195 /*
196 * Pointer to the queue of completed contexts outbound back
197 * towards the dataplane module.
198 */
ac96497c 199 struct dplane_ctx_list_head *ctx_out_q;
e63c7622
JU
200};
201
531c92b8
JU
202int netlink_config_write_helper(struct vty *vty)
203{
204 uint32_t size =
205 atomic_load_explicit(&nl_batch_bufsize, memory_order_relaxed);
206 uint32_t threshold = atomic_load_explicit(&nl_batch_send_threshold,
207 memory_order_relaxed);
208
209 if (size != NL_DEFAULT_BATCH_BUFSIZE
210 || threshold != NL_DEFAULT_BATCH_SEND_THRESHOLD)
211 vty_out(vty, "zebra kernel netlink batch-tx-buf %u %u\n", size,
212 threshold);
213
c40e1b1c
SW
214 if (if_netlink_frr_protodown_r_bit_is_set())
215 vty_out(vty, "zebra protodown reason-bit %u\n",
216 if_netlink_get_frr_protodown_r_bit());
217
531c92b8
JU
218 return 0;
219}
220
221void netlink_set_batch_buffer_size(uint32_t size, uint32_t threshold, bool set)
222{
223 if (!set) {
224 size = NL_DEFAULT_BATCH_BUFSIZE;
225 threshold = NL_DEFAULT_BATCH_SEND_THRESHOLD;
226 }
227
228 atomic_store_explicit(&nl_batch_bufsize, size, memory_order_relaxed);
229 atomic_store_explicit(&nl_batch_send_threshold, threshold,
230 memory_order_relaxed);
231}
232
2414abd3 233int netlink_talk_filter(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1fdc9eae 234{
3575d9e8
DS
235 /*
236 * This is an error condition that must be handled during
237 * development.
238 *
239 * The netlink_talk_filter function is used for communication
240 * down the netlink_cmd pipe and we are expecting
241 * an ack being received. So if we get here
242 * then we did not receive the ack and instead
243 * received some other message in an unexpected
244 * way.
245 */
43e52561
QY
246 zlog_debug("%s: ignoring message type 0x%04x(%s) NS %u", __func__,
247 h->nlmsg_type, nl_msg_type_to_str(h->nlmsg_type), ns_id);
d62a17ae 248 return 0;
1fdc9eae 249}
250
d62a17ae 251static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
1fdc9eae 252{
d7c0a89a 253 uint32_t oldsize;
d62a17ae 254 socklen_t newlen = sizeof(newsize);
255 socklen_t oldlen = sizeof(oldsize);
256 int ret;
257
258 ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
259 if (ret < 0) {
450971aa 260 flog_err_sys(EC_LIB_SOCKET,
09c866e3
QY
261 "Can't get %s receive buffer size: %s", nl->name,
262 safe_strerror(errno));
d62a17ae 263 return -1;
264 }
265
266 /* Try force option (linux >= 2.6.14) and fall back to normal set */
0cf6db21 267 frr_with_privs(&zserv_privs) {
01b9e3fd 268 ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUFFORCE,
9fb83b55 269 &rcvbufsize, sizeof(rcvbufsize));
01b9e3fd 270 }
d62a17ae 271 if (ret < 0)
9fb83b55
DS
272 ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &rcvbufsize,
273 sizeof(rcvbufsize));
d62a17ae 274 if (ret < 0) {
450971aa 275 flog_err_sys(EC_LIB_SOCKET,
09c866e3
QY
276 "Can't set %s receive buffer size: %s", nl->name,
277 safe_strerror(errno));
d62a17ae 278 return -1;
279 }
280
281 ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
282 if (ret < 0) {
450971aa 283 flog_err_sys(EC_LIB_SOCKET,
09c866e3
QY
284 "Can't get %s receive buffer size: %s", nl->name,
285 safe_strerror(errno));
d62a17ae 286 return -1;
287 }
d62a17ae 288 return 0;
1fdc9eae 289}
290
fe953d7c
DS
291static const char *group2str(uint32_t group)
292{
293 switch (group) {
294 case RTNLGRP_TUNNEL:
295 return "RTNLGRP_TUNNEL";
296 default:
297 return "UNKNOWN";
298 }
299}
300
1fdc9eae 301/* Make socket for Linux netlink interface. */
d62a17ae 302static int netlink_socket(struct nlsock *nl, unsigned long groups,
fe953d7c
DS
303 uint32_t ext_groups[], uint8_t ext_group_size,
304 ns_id_t ns_id)
1fdc9eae 305{
d62a17ae 306 int ret;
307 struct sockaddr_nl snl;
308 int sock;
309 int namelen;
d62a17ae 310
0cf6db21 311 frr_with_privs(&zserv_privs) {
6bb30c2c
DL
312 sock = ns_socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE, ns_id);
313 if (sock < 0) {
314 zlog_err("Can't open %s socket: %s", nl->name,
315 safe_strerror(errno));
316 return -1;
317 }
d62a17ae 318
0d6f7fd6 319 memset(&snl, 0, sizeof(snl));
6bb30c2c
DL
320 snl.nl_family = AF_NETLINK;
321 snl.nl_groups = groups;
d62a17ae 322
fe953d7c
DS
323 if (ext_group_size) {
324 uint8_t i;
325
326 for (i = 0; i < ext_group_size; i++) {
cc408c06 327#if defined SOL_NETLINK
fe953d7c
DS
328 ret = setsockopt(sock, SOL_NETLINK,
329 NETLINK_ADD_MEMBERSHIP,
330 &ext_groups[i],
331 sizeof(ext_groups[i]));
332 if (ret < 0) {
333 zlog_notice(
334 "can't setsockopt NETLINK_ADD_MEMBERSHIP for group %s(%u), this linux kernel does not support it: %s(%d)",
335 group2str(ext_groups[i]),
336 ext_groups[i],
337 safe_strerror(errno), errno);
338 }
cc408c06
DS
339#else
340 zlog_notice(
341 "Unable to use NETLINK_ADD_MEMBERSHIP via SOL_NETLINK for %s(%u) since the linux kernel does not support the socket option",
342 group2str(ext_groups[i]),
343 ext_groups[i]);
344#endif
e5b1de8a
CS
345 }
346 }
47e2eb27 347
6bb30c2c 348 /* Bind the socket to the netlink structure for anything. */
0d6f7fd6 349 ret = bind(sock, (struct sockaddr *)&snl, sizeof(snl));
6bb30c2c 350 }
d62a17ae 351
352 if (ret < 0) {
6bb30c2c
DL
353 zlog_err("Can't bind %s socket to group 0x%x: %s", nl->name,
354 snl.nl_groups, safe_strerror(errno));
d62a17ae 355 close(sock);
356 return -1;
357 }
358
359 /* multiple netlink sockets will have different nl_pid */
0d6f7fd6 360 namelen = sizeof(snl);
d62a17ae 361 ret = getsockname(sock, (struct sockaddr *)&snl, (socklen_t *)&namelen);
0d6f7fd6 362 if (ret < 0 || namelen != sizeof(snl)) {
450971aa 363 flog_err_sys(EC_LIB_SOCKET, "Can't get %s socket name: %s",
09c866e3 364 nl->name, safe_strerror(errno));
d62a17ae 365 close(sock);
366 return -1;
367 }
368
369 nl->snl = snl;
370 nl->sock = sock;
2cf7651f
DS
371 nl->buflen = NL_RCV_PKT_BUF_SIZE;
372 nl->buf = XMALLOC(MTYPE_NL_BUF, nl->buflen);
373
d62a17ae 374 return ret;
1fdc9eae 375}
376
d166308b
MS
377/*
378 * Dispatch an incoming netlink message; used by the zebra main pthread's
379 * netlink event reader.
380 */
2414abd3 381static int netlink_information_fetch(struct nlmsghdr *h, ns_id_t ns_id,
d62a17ae 382 int startup)
1fdc9eae 383{
3575d9e8
DS
384 /*
385 * When we handle new message types here
386 * because we are starting to install them
387 * then lets check the netlink_install_filter
388 * and see if we should add the corresponding
389 * allow through entry there.
390 * Probably not needed to do but please
391 * think about it.
392 */
d62a17ae 393 switch (h->nlmsg_type) {
394 case RTM_NEWROUTE:
2414abd3 395 return netlink_route_change(h, ns_id, startup);
d62a17ae 396 case RTM_DELROUTE:
2414abd3 397 return netlink_route_change(h, ns_id, startup);
d62a17ae 398 case RTM_NEWLINK:
2414abd3 399 return netlink_link_change(h, ns_id, startup);
d62a17ae 400 case RTM_DELLINK:
2414abd3 401 return netlink_link_change(h, ns_id, startup);
d62a17ae 402 case RTM_NEWNEIGH:
d62a17ae 403 case RTM_DELNEIGH:
951f8bcb 404 case RTM_GETNEIGH:
7a52f27e 405 return netlink_neigh_change(h, ns_id);
942bf97b 406 case RTM_NEWRULE:
2414abd3 407 return netlink_rule_change(h, ns_id, startup);
942bf97b 408 case RTM_DELRULE:
2414abd3 409 return netlink_rule_change(h, ns_id, startup);
79580b5a 410 case RTM_NEWNEXTHOP:
d9f5b2f5 411 return netlink_nexthop_change(h, ns_id, startup);
79580b5a 412 case RTM_DELNEXTHOP:
d9f5b2f5 413 return netlink_nexthop_change(h, ns_id, startup);
c317d3f2
SY
414 case RTM_NEWQDISC:
415 case RTM_DELQDISC:
416 return netlink_qdisc_change(h, ns_id, startup);
417 case RTM_NEWTCLASS:
418 case RTM_DELTCLASS:
419 return netlink_tclass_change(h, ns_id, startup);
420 case RTM_NEWTFILTER:
421 case RTM_DELTFILTER:
422 return netlink_tfilter_change(h, ns_id, startup);
a26daa77
SW
423 case RTM_NEWVLAN:
424 return netlink_vlan_change(h, ns_id, startup);
425 case RTM_DELVLAN:
426 return netlink_vlan_change(h, ns_id, startup);
d166308b
MS
427
428 /* Messages handled in the dplane thread */
429 case RTM_NEWADDR:
430 case RTM_DELADDR:
cd787a8a
MS
431 case RTM_NEWNETCONF:
432 case RTM_DELNETCONF:
acc8e687
CS
433 case RTM_NEWTUNNEL:
434 case RTM_DELTUNNEL:
435 case RTM_GETTUNNEL:
d166308b 436 return 0;
d62a17ae 437 default:
3575d9e8
DS
438 /*
439 * If we have received this message then
440 * we have made a mistake during development
441 * and we need to write some code to handle
442 * this message type or not ask for
443 * it to be sent up to us
444 */
e914ccbe 445 flog_err(EC_ZEBRA_UNKNOWN_NLMSG,
1d5453d6 446 "Unknown netlink nlmsg_type %s(%d) vrf %u",
1c50c1c0
QY
447 nl_msg_type_to_str(h->nlmsg_type), h->nlmsg_type,
448 ns_id);
d62a17ae 449 break;
450 }
451 return 0;
1fdc9eae 452}
453
d166308b
MS
454/*
455 * Dispatch an incoming netlink message; used by the dataplane pthread's
456 * netlink event reader code.
457 */
458static int dplane_netlink_information_fetch(struct nlmsghdr *h, ns_id_t ns_id,
459 int startup)
460{
461 /*
462 * Dispatch the incoming messages that the dplane pthread handles
463 */
464 switch (h->nlmsg_type) {
465 case RTM_NEWADDR:
466 case RTM_DELADDR:
467 return netlink_interface_addr_dplane(h, ns_id, startup);
468
9f3f1486
MS
469 case RTM_NEWNETCONF:
470 case RTM_DELNETCONF:
471 return netlink_netconf_change(h, ns_id, startup);
472
473 /* TODO -- other messages for the dplane socket and pthread */
474
d166308b
MS
475 case RTM_NEWLINK:
476 case RTM_DELLINK:
477
478 default:
479 break;
480 }
481
482 return 0;
483}
484
cc9f21da 485static void kernel_read(struct thread *thread)
1fdc9eae 486{
d62a17ae 487 struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG(thread);
85a75f1e
MS
488 struct zebra_dplane_info dp_info;
489
490 /* Capture key info from ns struct */
491 zebra_dplane_info_from_zns(&dp_info, zns, false);
492
493 netlink_parse_info(netlink_information_fetch, &zns->netlink, &dp_info,
9bfadae8 494 5, false);
d166308b 495
3801e764 496 thread_add_read(zrouter.master, kernel_read, zns, zns->netlink.sock,
d62a17ae 497 &zns->t_netlink);
1fdc9eae 498}
499
d166308b
MS
500/*
501 * Called by the dplane pthread to read incoming OS messages and dispatch them.
502 */
503int kernel_dplane_read(struct zebra_dplane_info *info)
504{
d4000d7b
DS
505 struct nlsock *nl = kernel_netlink_nlsock_lookup(info->sock);
506
507 netlink_parse_info(dplane_netlink_information_fetch, nl, info, 5,
508 false);
d166308b
MS
509
510 return 0;
511}
512
3575d9e8
DS
513/*
514 * Filter out messages from self that occur on listener socket,
62b8bb7a 515 * caused by our actions on the command socket(s)
3575d9e8
DS
516 *
517 * When we add new Netlink message types we probably
518 * do not need to add them here as that we are filtering
519 * on the routes we actually care to receive( which is rarer
520 * then the normal course of operations). We are intentionally
521 * allowing some messages from ourselves through
522 * ( I'm looking at you Interface based netlink messages )
9f3f1486
MS
523 * so that we only have to write one way to handle incoming
524 * address add/delete and xxxNETCONF changes.
1fdc9eae 525 */
ff45112c 526static void netlink_install_filter(int sock, uint32_t pid, uint32_t dplane_pid)
1fdc9eae 527{
3575d9e8
DS
528 /*
529 * BPF_JUMP instructions and where you jump to are based upon
530 * 0 as being the next statement. So count from 0. Writing
531 * this down because every time I look at this I have to
532 * re-remember it.
533 */
d62a17ae 534 struct sock_filter filter[] = {
3575d9e8
DS
535 /*
536 * Logic:
62b8bb7a
MS
537 * if (nlmsg_pid == pid ||
538 * nlmsg_pid == dplane_pid) {
3575d9e8 539 * if (the incoming nlmsg_type ==
9f3f1486
MS
540 * RTM_NEWADDR || RTM_DELADDR || RTM_NEWNETCONF ||
541 * RTM_DELNETCONF)
3575d9e8
DS
542 * keep this message
543 * else
544 * skip this message
545 * } else
546 * keep this netlink message
547 */
548 /*
549 * 0: Load the nlmsg_pid into the BPF register
550 */
d62a17ae 551 BPF_STMT(BPF_LD | BPF_ABS | BPF_W,
552 offsetof(struct nlmsghdr, nlmsg_pid)),
3575d9e8
DS
553 /*
554 * 1: Compare to pid
555 */
62b8bb7a 556 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htonl(pid), 1, 0),
3575d9e8 557 /*
62b8bb7a
MS
558 * 2: Compare to dplane pid
559 */
9f3f1486 560 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htonl(dplane_pid), 0, 6),
62b8bb7a
MS
561 /*
562 * 3: Load the nlmsg_type into BPF register
3575d9e8
DS
563 */
564 BPF_STMT(BPF_LD | BPF_ABS | BPF_H,
565 offsetof(struct nlmsghdr, nlmsg_type)),
566 /*
62b8bb7a 567 * 4: Compare to RTM_NEWADDR
3575d9e8 568 */
9f3f1486 569 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_NEWADDR), 4, 0),
3575d9e8 570 /*
62b8bb7a 571 * 5: Compare to RTM_DELADDR
3575d9e8 572 */
9f3f1486
MS
573 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_DELADDR), 3, 0),
574 /*
575 * 6: Compare to RTM_NEWNETCONF
576 */
577 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_NEWNETCONF), 2,
578 0),
579 /*
580 * 7: Compare to RTM_DELNETCONF
581 */
582 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_DELNETCONF), 1,
583 0),
3575d9e8 584 /*
9f3f1486 585 * 8: This is the end state of we want to skip the
3575d9e8
DS
586 * message
587 */
d62a17ae 588 BPF_STMT(BPF_RET | BPF_K, 0),
9f3f1486 589 /* 9: This is the end state of we want to keep
3575d9e8
DS
590 * the message
591 */
d62a17ae 592 BPF_STMT(BPF_RET | BPF_K, 0xffff),
593 };
594
595 struct sock_fprog prog = {
9d303b37 596 .len = array_size(filter), .filter = filter,
d62a17ae 597 };
598
599 if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))
600 < 0)
1d5453d6 601 flog_err_sys(EC_LIB_SOCKET, "Can't install socket filter: %s",
9df414fe 602 safe_strerror(errno));
1fdc9eae 603}
604
d166308b
MS
605void netlink_parse_rtattr_flags(struct rtattr **tb, int max, struct rtattr *rta,
606 int len, unsigned short flags)
4bcdb608
NA
607{
608 unsigned short type;
609
269b69d7 610 memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
4bcdb608
NA
611 while (RTA_OK(rta, len)) {
612 type = rta->rta_type & ~flags;
613 if ((type <= max) && (!tb[type]))
614 tb[type] = rta;
615 rta = RTA_NEXT(rta, len);
616 }
617}
618
d62a17ae 619void netlink_parse_rtattr(struct rtattr **tb, int max, struct rtattr *rta,
620 int len)
1fdc9eae 621{
269b69d7 622 memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
d62a17ae 623 while (RTA_OK(rta, len)) {
624 if (rta->rta_type <= max)
625 tb[rta->rta_type] = rta;
626 rta = RTA_NEXT(rta, len);
627 }
1fdc9eae 628}
629
87da6a60
SW
630/**
631 * netlink_parse_rtattr_nested() - Parses a nested route attribute
632 * @tb: Pointer to array for storing rtattr in.
633 * @max: Max number to store.
634 * @rta: Pointer to rtattr to look for nested items in.
635 */
636void netlink_parse_rtattr_nested(struct rtattr **tb, int max,
637 struct rtattr *rta)
638{
639 netlink_parse_rtattr(tb, max, RTA_DATA(rta), RTA_PAYLOAD(rta));
640}
641
f8f3e484
CS
642bool nl_addraw_l(struct nlmsghdr *n, unsigned int maxlen, const void *data,
643 unsigned int len)
644{
645 if (NLMSG_ALIGN(n->nlmsg_len) + NLMSG_ALIGN(len) > maxlen) {
1b3cf91b 646 zlog_err("ERROR message exceeded bound of %d", maxlen);
f8f3e484
CS
647 return false;
648 }
649
650 memcpy(NLMSG_TAIL(n), data, len);
651 memset((uint8_t *)NLMSG_TAIL(n) + len, 0, NLMSG_ALIGN(len) - len);
652 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + NLMSG_ALIGN(len);
653
654 return true;
655}
656
312a6bee
JU
657bool nl_attr_put(struct nlmsghdr *n, unsigned int maxlen, int type,
658 const void *data, unsigned int alen)
1fdc9eae 659{
d62a17ae 660 int len;
661 struct rtattr *rta;
1fdc9eae 662
d62a17ae 663 len = RTA_LENGTH(alen);
1fdc9eae 664
d62a17ae 665 if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len) > maxlen)
312a6bee 666 return false;
1fdc9eae 667
d62a17ae 668 rta = (struct rtattr *)(((char *)n) + NLMSG_ALIGN(n->nlmsg_len));
669 rta->rta_type = type;
670 rta->rta_len = len;
4b2792b5 671
d62a17ae 672 if (data)
673 memcpy(RTA_DATA(rta), data, alen);
674 else
675 assert(alen == 0);
4b2792b5 676
d62a17ae 677 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len);
1fdc9eae 678
312a6bee 679 return true;
1fdc9eae 680}
681
94d70a65
DS
682bool nl_attr_put8(struct nlmsghdr *n, unsigned int maxlen, int type,
683 uint8_t data)
684{
685 return nl_attr_put(n, maxlen, type, &data, sizeof(uint8_t));
686}
687
312a6bee
JU
688bool nl_attr_put16(struct nlmsghdr *n, unsigned int maxlen, int type,
689 uint16_t data)
bbc16902 690{
312a6bee 691 return nl_attr_put(n, maxlen, type, &data, sizeof(uint16_t));
bbc16902 692}
693
312a6bee
JU
694bool nl_attr_put32(struct nlmsghdr *n, unsigned int maxlen, int type,
695 uint32_t data)
1fdc9eae 696{
312a6bee 697 return nl_attr_put(n, maxlen, type, &data, sizeof(uint32_t));
1fdc9eae 698}
699
5fa6bfff
SW
700bool nl_attr_put64(struct nlmsghdr *n, unsigned int maxlen, int type,
701 uint64_t data)
702{
703 return nl_attr_put(n, maxlen, type, &data, sizeof(uint64_t));
704}
705
312a6bee 706struct rtattr *nl_attr_nest(struct nlmsghdr *n, unsigned int maxlen, int type)
1fdc9eae 707{
d62a17ae 708 struct rtattr *nest = NLMSG_TAIL(n);
1fdc9eae 709
312a6bee
JU
710 if (!nl_attr_put(n, maxlen, type, NULL, 0))
711 return NULL;
712
40d86eba 713 nest->rta_type |= NLA_F_NESTED;
d62a17ae 714 return nest;
1fdc9eae 715}
716
312a6bee 717int nl_attr_nest_end(struct nlmsghdr *n, struct rtattr *nest)
1fdc9eae 718{
d7c0a89a 719 nest->rta_len = (uint8_t *)NLMSG_TAIL(n) - (uint8_t *)nest;
d62a17ae 720 return n->nlmsg_len;
1fdc9eae 721}
722
312a6bee 723struct rtnexthop *nl_attr_rtnh(struct nlmsghdr *n, unsigned int maxlen)
1fdc9eae 724{
312a6bee 725 struct rtnexthop *rtnh = (struct rtnexthop *)NLMSG_TAIL(n);
1fdc9eae 726
312a6bee
JU
727 if (NLMSG_ALIGN(n->nlmsg_len) + RTNH_ALIGN(sizeof(struct rtnexthop))
728 > maxlen)
729 return NULL;
730
731 memset(rtnh, 0, sizeof(struct rtnexthop));
732 n->nlmsg_len =
733 NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(sizeof(struct rtnexthop));
734
735 return rtnh;
1fdc9eae 736}
737
312a6bee 738void nl_attr_rtnh_end(struct nlmsghdr *n, struct rtnexthop *rtnh)
1fdc9eae 739{
312a6bee 740 rtnh->rtnh_len = (uint8_t *)NLMSG_TAIL(n) - (uint8_t *)rtnh;
1fdc9eae 741}
742
f8f3e484
CS
743bool nl_rta_put(struct rtattr *rta, unsigned int maxlen, int type,
744 const void *data, int alen)
745{
746 struct rtattr *subrta;
747 int len = RTA_LENGTH(alen);
748
749 if (RTA_ALIGN(rta->rta_len) + RTA_ALIGN(len) > maxlen) {
750 zlog_err("ERROR max allowed bound %d exceeded for rtattr",
751 maxlen);
752 return false;
753 }
754 subrta = (struct rtattr *)(((char *)rta) + RTA_ALIGN(rta->rta_len));
755 subrta->rta_type = type;
756 subrta->rta_len = len;
757 if (alen)
758 memcpy(RTA_DATA(subrta), data, alen);
759 rta->rta_len = NLMSG_ALIGN(rta->rta_len) + RTA_ALIGN(len);
760
761 return true;
762}
763
764bool nl_rta_put16(struct rtattr *rta, unsigned int maxlen, int type,
765 uint16_t data)
766{
767 return nl_rta_put(rta, maxlen, type, &data, sizeof(uint16_t));
768}
769
770bool nl_rta_put64(struct rtattr *rta, unsigned int maxlen, int type,
771 uint64_t data)
772{
773 return nl_rta_put(rta, maxlen, type, &data, sizeof(uint64_t));
774}
775
776struct rtattr *nl_rta_nest(struct rtattr *rta, unsigned int maxlen, int type)
777{
778 struct rtattr *nest = RTA_TAIL(rta);
779
780 if (nl_rta_put(rta, maxlen, type, NULL, 0))
781 return NULL;
782
783 nest->rta_type |= NLA_F_NESTED;
784
785 return nest;
786}
787
788int nl_rta_nest_end(struct rtattr *rta, struct rtattr *nest)
789{
790 nest->rta_len = (uint8_t *)RTA_TAIL(rta) - (uint8_t *)nest;
791
792 return rta->rta_len;
793}
794
d62a17ae 795const char *nl_msg_type_to_str(uint16_t msg_type)
1fdc9eae 796{
d62a17ae 797 return lookup_msg(nlmsg_str, msg_type, "");
1fdc9eae 798}
799
d7c0a89a 800const char *nl_rtproto_to_str(uint8_t rtproto)
1fdc9eae 801{
d62a17ae 802 return lookup_msg(rtproto_str, rtproto, "");
1fdc9eae 803}
b339bde7 804
d7c0a89a 805const char *nl_family_to_str(uint8_t family)
b339bde7 806{
d62a17ae 807 return lookup_msg(family_str, family, "");
b339bde7
DS
808}
809
d7c0a89a 810const char *nl_rttype_to_str(uint8_t rttype)
b339bde7 811{
d62a17ae 812 return lookup_msg(rttype_str, rttype, "");
b339bde7
DS
813}
814
4cebb2b6 815#define NLA_OK(nla, len) \
5d307d5d
DS
816 ((len) >= (int)sizeof(struct nlattr) \
817 && (nla)->nla_len >= sizeof(struct nlattr) \
818 && (nla)->nla_len <= (len))
4cebb2b6
SW
819#define NLA_NEXT(nla, attrlen) \
820 ((attrlen) -= NLA_ALIGN((nla)->nla_len), \
821 (struct nlattr *)(((char *)(nla)) + NLA_ALIGN((nla)->nla_len)))
822#define NLA_LENGTH(len) (NLA_ALIGN(sizeof(struct nlattr)) + (len))
823#define NLA_DATA(nla) ((struct nlattr *)(((char *)(nla)) + NLA_LENGTH(0)))
824
825#define ERR_NLA(err, inner_len) \
826 ((struct nlattr *)(((char *)(err)) \
827 + NLMSG_ALIGN(sizeof(struct nlmsgerr)) \
828 + NLMSG_ALIGN((inner_len))))
5d307d5d
DS
829
830static void netlink_parse_nlattr(struct nlattr **tb, int max,
831 struct nlattr *nla, int len)
832{
4cebb2b6 833 while (NLA_OK(nla, len)) {
5d307d5d
DS
834 if (nla->nla_type <= max)
835 tb[nla->nla_type] = nla;
4cebb2b6 836 nla = NLA_NEXT(nla, len);
5d307d5d
DS
837 }
838}
839
840static void netlink_parse_extended_ack(struct nlmsghdr *h)
841{
4cebb2b6
SW
842 struct nlattr *tb[NLMSGERR_ATTR_MAX + 1] = {};
843 const struct nlmsgerr *err = (const struct nlmsgerr *)NLMSG_DATA(h);
5d307d5d 844 const struct nlmsghdr *err_nlh = NULL;
4cebb2b6
SW
845 /* Length not including nlmsghdr */
846 uint32_t len = 0;
847 /* Inner error netlink message length */
848 uint32_t inner_len = 0;
5d307d5d
DS
849 const char *msg = NULL;
850 uint32_t off = 0;
851
852 if (!(h->nlmsg_flags & NLM_F_CAPPED))
4cebb2b6
SW
853 inner_len = (uint32_t)NLMSG_PAYLOAD(&err->msg, 0);
854
855 len = (uint32_t)(NLMSG_PAYLOAD(h, sizeof(struct nlmsgerr)) - inner_len);
5d307d5d 856
4cebb2b6
SW
857 netlink_parse_nlattr(tb, NLMSGERR_ATTR_MAX, ERR_NLA(err, inner_len),
858 len);
5d307d5d
DS
859
860 if (tb[NLMSGERR_ATTR_MSG])
4cebb2b6 861 msg = (const char *)NLA_DATA(tb[NLMSGERR_ATTR_MSG]);
5d307d5d
DS
862
863 if (tb[NLMSGERR_ATTR_OFFS]) {
4cebb2b6 864 off = *(uint32_t *)NLA_DATA(tb[NLMSGERR_ATTR_OFFS]);
5d307d5d
DS
865
866 if (off > h->nlmsg_len) {
9165c5f5 867 zlog_err("Invalid offset for NLMSGERR_ATTR_OFFS");
5d307d5d
DS
868 } else if (!(h->nlmsg_flags & NLM_F_CAPPED)) {
869 /*
870 * Header of failed message
871 * we are not doing anything currently with it
872 * but noticing it for later.
873 */
874 err_nlh = &err->msg;
15569c58 875 zlog_debug("%s: Received %s extended Ack", __func__,
87b5d1b0 876 nl_msg_type_to_str(err_nlh->nlmsg_type));
5d307d5d
DS
877 }
878 }
879
880 if (msg && *msg != '\0') {
881 bool is_err = !!err->error;
882
883 if (is_err)
884 zlog_err("Extended Error: %s", msg);
885 else
e914ccbe 886 flog_warn(EC_ZEBRA_NETLINK_EXTENDED_WARNING,
9df414fe 887 "Extended Warning: %s", msg);
5d307d5d
DS
888 }
889}
890
ae6138bf
JU
891/*
892 * netlink_send_msg - send a netlink message of a certain size.
893 *
894 * Returns -1 on error. Otherwise, it returns the number of bytes sent.
895 */
f8653393
JU
896static ssize_t netlink_send_msg(const struct nlsock *nl, void *buf,
897 size_t buflen)
ae6138bf 898{
f8653393
JU
899 struct sockaddr_nl snl = {};
900 struct iovec iov = {};
901 struct msghdr msg = {};
902 ssize_t status;
903 int save_errno = 0;
ae6138bf
JU
904
905 iov.iov_base = buf;
906 iov.iov_len = buflen;
f8653393 907 msg.msg_name = &snl;
ae6138bf
JU
908 msg.msg_namelen = sizeof(snl);
909 msg.msg_iov = &iov;
910 msg.msg_iovlen = 1;
911
912 snl.nl_family = AF_NETLINK;
913
914 /* Send message to netlink interface. */
915 frr_with_privs(&zserv_privs) {
916 status = sendmsg(nl->sock, &msg, 0);
917 save_errno = errno;
918 }
919
920 if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
921 zlog_debug("%s: >> netlink message dump [sent]", __func__);
eead0bc4
RZ
922#ifdef NETLINK_DEBUG
923 nl_dump(buf, buflen);
924#else
ae6138bf 925 zlog_hexdump(buf, buflen);
eead0bc4 926#endif /* NETLINK_DEBUG */
ae6138bf
JU
927 }
928
f8653393 929 if (status == -1) {
ae6138bf
JU
930 flog_err_sys(EC_LIB_SOCKET, "%s error: %s", __func__,
931 safe_strerror(save_errno));
932 return -1;
933 }
934
935 return status;
936}
937
938/*
939 * netlink_recv_msg - receive a netlink message.
940 *
941 * Returns -1 on error, 0 if read would block or the number of bytes received.
942 */
2cf7651f 943static int netlink_recv_msg(struct nlsock *nl, struct msghdr *msg)
ae6138bf
JU
944{
945 struct iovec iov;
946 int status;
947
2cf7651f
DS
948 iov.iov_base = nl->buf;
949 iov.iov_len = nl->buflen;
950 msg->msg_iov = &iov;
951 msg->msg_iovlen = 1;
ae6138bf
JU
952
953 do {
2cf7651f
DS
954 int bytes;
955
956 bytes = recv(nl->sock, NULL, 0, MSG_PEEK | MSG_TRUNC);
957
958 if (bytes >= 0 && (size_t)bytes > nl->buflen) {
959 nl->buf = XREALLOC(MTYPE_NL_BUF, nl->buf, bytes);
960 nl->buflen = bytes;
961 iov.iov_base = nl->buf;
962 iov.iov_len = nl->buflen;
963 }
964
965 status = recvmsg(nl->sock, msg, 0);
f8653393 966 } while (status == -1 && errno == EINTR);
ae6138bf 967
f8653393 968 if (status == -1) {
ae6138bf
JU
969 if (errno == EWOULDBLOCK || errno == EAGAIN)
970 return 0;
971 flog_err(EC_ZEBRA_RECVMSG_OVERRUN, "%s recvmsg overrun: %s",
972 nl->name, safe_strerror(errno));
973 /*
974 * In this case we are screwed. There is no good way to recover
975 * zebra at this point.
976 */
977 exit(-1);
978 }
979
980 if (status == 0) {
981 flog_err_sys(EC_LIB_SOCKET, "%s EOF", nl->name);
982 return -1;
983 }
984
2cf7651f 985 if (msg->msg_namelen != sizeof(struct sockaddr_nl)) {
ae6138bf
JU
986 flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
987 "%s sender address length error: length %d", nl->name,
2cf7651f 988 msg->msg_namelen);
ae6138bf
JU
989 return -1;
990 }
991
992 if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
993 zlog_debug("%s: << netlink message dump [recv]", __func__);
eead0bc4 994#ifdef NETLINK_DEBUG
2cf7651f 995 nl_dump(nl->buf, status);
eead0bc4 996#else
2cf7651f 997 zlog_hexdump(nl->buf, status);
eead0bc4 998#endif /* NETLINK_DEBUG */
ae6138bf
JU
999 }
1000
ae6138bf
JU
1001 return status;
1002}
1003
1004/*
1005 * netlink_parse_error - parse a netlink error message
1006 *
1007 * Returns 1 if this message is acknowledgement, 0 if this error should be
1008 * ignored, -1 otherwise.
1009 */
1010static int netlink_parse_error(const struct nlsock *nl, struct nlmsghdr *h,
d166308b 1011 bool is_cmd, bool startup)
ae6138bf
JU
1012{
1013 struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(h);
1014 int errnum = err->error;
1015 int msg_type = err->msg.nlmsg_type;
1016
1017 if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
1018 flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
1019 "%s error: message truncated", nl->name);
1020 return -1;
1021 }
1022
1023 /*
1024 * Parse the extended information before we actually handle it. At this
1025 * point in time we do not do anything other than report the issue.
1026 */
1027 if (h->nlmsg_flags & NLM_F_ACK_TLVS)
1028 netlink_parse_extended_ack(h);
1029
1030 /* If the error field is zero, then this is an ACK. */
1031 if (err->error == 0) {
1032 if (IS_ZEBRA_DEBUG_KERNEL) {
1033 zlog_debug("%s: %s ACK: type=%s(%u), seq=%u, pid=%u",
1034 __func__, nl->name,
1035 nl_msg_type_to_str(err->msg.nlmsg_type),
1036 err->msg.nlmsg_type, err->msg.nlmsg_seq,
1037 err->msg.nlmsg_pid);
1038 }
1039
1040 return 1;
1041 }
1042
f09428e4 1043 /*
1044 * Deal with errors that occur because of races in link handling
1045 * or types are not supported in kernel.
1046 */
1047 if (is_cmd &&
1048 ((msg_type == RTM_DELROUTE &&
1049 (-errnum == ENODEV || -errnum == ESRCH)) ||
1050 (msg_type == RTM_NEWROUTE &&
1051 (-errnum == ENETDOWN || -errnum == EEXIST)) ||
1052 ((msg_type == RTM_NEWTUNNEL || msg_type == RTM_DELTUNNEL ||
1053 msg_type == RTM_GETTUNNEL) &&
1054 (-errnum == EOPNOTSUPP)))) {
ae6138bf
JU
1055 if (IS_ZEBRA_DEBUG_KERNEL)
1056 zlog_debug("%s: error: %s type=%s(%u), seq=%u, pid=%u",
1057 nl->name, safe_strerror(-errnum),
1058 nl_msg_type_to_str(msg_type), msg_type,
1059 err->msg.nlmsg_seq, err->msg.nlmsg_pid);
1060 return 0;
1061 }
1062
1063 /*
1064 * We see RTM_DELNEIGH when shutting down an interface with an IPv4
1065 * link-local. The kernel should have already deleted the neighbor so
1066 * do not log these as an error.
1067 */
1068 if (msg_type == RTM_DELNEIGH
d166308b 1069 || (is_cmd && msg_type == RTM_NEWROUTE
ae6138bf
JU
1070 && (-errnum == ESRCH || -errnum == ENETUNREACH))) {
1071 /*
1072 * This is known to happen in some situations, don't log as
1073 * error.
1074 */
1075 if (IS_ZEBRA_DEBUG_KERNEL)
1076 zlog_debug("%s error: %s, type=%s(%u), seq=%u, pid=%u",
1077 nl->name, safe_strerror(-errnum),
1078 nl_msg_type_to_str(msg_type), msg_type,
1079 err->msg.nlmsg_seq, err->msg.nlmsg_pid);
1080 } else {
d9ea9e7a
SW
1081 if ((msg_type != RTM_GETNEXTHOP && msg_type != RTM_GETVLAN) ||
1082 !startup)
ae6138bf
JU
1083 flog_err(EC_ZEBRA_UNEXPECTED_MESSAGE,
1084 "%s error: %s, type=%s(%u), seq=%u, pid=%u",
1085 nl->name, safe_strerror(-errnum),
1086 nl_msg_type_to_str(msg_type), msg_type,
1087 err->msg.nlmsg_seq, err->msg.nlmsg_pid);
1088 }
1089
1090 return -1;
1091}
1092
936ebf0a
DS
1093/*
1094 * netlink_parse_info
1095 *
1096 * Receive message from netlink interface and pass those information
1097 * to the given function.
1098 *
1099 * filter -> Function to call to read the results
1100 * nl -> netlink socket information
1101 * zns -> The zebra namespace data
1102 * count -> How many we should read in, 0 means as much as possible
1103 * startup -> Are we reading in under startup conditions? passed to
1104 * the filter.
1105 */
2414abd3 1106int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
2cf7651f 1107 struct nlsock *nl, const struct zebra_dplane_info *zns,
9bfadae8 1108 int count, bool startup)
1fdc9eae 1109{
d62a17ae 1110 int status;
1111 int ret = 0;
1112 int error;
1113 int read_in = 0;
1114
1115 while (1) {
d62a17ae 1116 struct sockaddr_nl snl;
1117 struct msghdr msg = {.msg_name = (void *)&snl,
ae6138bf 1118 .msg_namelen = sizeof(snl)};
d62a17ae 1119 struct nlmsghdr *h;
1120
1121 if (count && read_in >= count)
1122 return 0;
1123
2cf7651f 1124 status = netlink_recv_msg(nl, &msg);
ae6138bf 1125 if (status == -1)
d62a17ae 1126 return -1;
ae6138bf
JU
1127 else if (status == 0)
1128 break;
81a2f870 1129
d62a17ae 1130 read_in++;
2cf7651f 1131 for (h = (struct nlmsghdr *)nl->buf;
e6a0e0d1 1132 (status >= 0 && NLMSG_OK(h, (unsigned int)status));
d62a17ae 1133 h = NLMSG_NEXT(h, status)) {
1134 /* Finish of reading. */
1135 if (h->nlmsg_type == NLMSG_DONE)
1136 return ret;
1137
1138 /* Error handling. */
1139 if (h->nlmsg_type == NLMSG_ERROR) {
d166308b
MS
1140 int err = netlink_parse_error(
1141 nl, h, zns->is_cmd, startup);
1142
ae6138bf 1143 if (err == 1) {
d62a17ae 1144 if (!(h->nlmsg_flags & NLM_F_MULTI))
1145 return 0;
1146 continue;
ae6138bf
JU
1147 } else
1148 return err;
d62a17ae 1149 }
1150
2f71996a
DS
1151 /*
1152 * What is the right thing to do? The kernel
1153 * is telling us that the dump request was interrupted
1154 * and we more than likely are out of luck and have
1155 * missed data from the kernel. At this point in time
1156 * lets just note that this is happening.
1157 */
1158 if (h->nlmsg_flags & NLM_F_DUMP_INTR)
1159 flog_err(
1160 EC_ZEBRA_NETLINK_BAD_SEQUENCE,
1161 "netlink recvmsg: The Dump request was interrupted");
1162
d62a17ae 1163 /* OK we got netlink message. */
1164 if (IS_ZEBRA_DEBUG_KERNEL)
1165 zlog_debug(
d166308b
MS
1166 "%s: %s type %s(%u), len=%d, seq=%u, pid=%u",
1167 __func__, nl->name,
d62a17ae 1168 nl_msg_type_to_str(h->nlmsg_type),
1169 h->nlmsg_type, h->nlmsg_len,
1170 h->nlmsg_seq, h->nlmsg_pid);
1171
783827ae
DS
1172
1173 /*
1174 * Ignore messages that maybe sent from
1175 * other actors besides the kernel
1176 */
1177 if (snl.nl_pid != 0) {
43e52561
QY
1178 zlog_debug("Ignoring message from pid %u",
1179 snl.nl_pid);
d62a17ae 1180 continue;
1181 }
1182
2414abd3 1183 error = (*filter)(h, zns->ns_id, startup);
d62a17ae 1184 if (error < 0) {
9df414fe
QY
1185 zlog_debug("%s filter function error",
1186 nl->name);
d62a17ae 1187 ret = error;
1188 }
1189 }
1190
1191 /* After error care. */
1192 if (msg.msg_flags & MSG_TRUNC) {
e914ccbe 1193 flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
1c50c1c0 1194 "%s error: message truncated", nl->name);
d62a17ae 1195 continue;
1196 }
1197 if (status) {
e914ccbe 1198 flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
1c50c1c0
QY
1199 "%s error: data remnant size %d", nl->name,
1200 status);
d62a17ae 1201 return -1;
1202 }
1203 }
1204 return ret;
1fdc9eae 1205}
1206
936ebf0a 1207/*
7cdb1a84 1208 * netlink_talk_info
936ebf0a
DS
1209 *
1210 * sendmsg() to netlink socket then recvmsg().
1211 * Calls netlink_parse_info to parse returned data
1212 *
1213 * filter -> The filter to read final results from kernel
1214 * nlmsghdr -> The data to send to the kernel
8b962e77 1215 * dp_info -> The dataplane and netlink socket information
936ebf0a
DS
1216 * startup -> Are we reading in under startup conditions
1217 * This is passed through eventually to filter.
1218 */
2cf7651f
DS
1219static int netlink_talk_info(int (*filter)(struct nlmsghdr *, ns_id_t,
1220 int startup),
1221 struct nlmsghdr *n,
1222 struct zebra_dplane_info *dp_info, bool startup)
1fdc9eae 1223{
d4000d7b 1224 struct nlsock *nl;
d62a17ae 1225
d4000d7b 1226 nl = kernel_netlink_nlsock_lookup(dp_info->sock);
3670f504 1227 n->nlmsg_seq = dp_info->seq;
d62a17ae 1228 n->nlmsg_pid = nl->snl.nl_pid;
1229
d62a17ae 1230 if (IS_ZEBRA_DEBUG_KERNEL)
1231 zlog_debug(
1232 "netlink_talk: %s type %s(%u), len=%d seq=%u flags 0x%x",
1233 nl->name, nl_msg_type_to_str(n->nlmsg_type),
1234 n->nlmsg_type, n->nlmsg_len, n->nlmsg_seq,
1235 n->nlmsg_flags);
1236
f8653393 1237 if (netlink_send_msg(nl, n, n->nlmsg_len) == -1)
d62a17ae 1238 return -1;
d62a17ae 1239
d62a17ae 1240 /*
1241 * Get reply from netlink socket.
1242 * The reply should either be an acknowlegement or an error.
1243 */
7cdb1a84
MS
1244 return netlink_parse_info(filter, nl, dp_info, 0, startup);
1245}
1246
1247/*
1248 * Synchronous version of netlink_talk_info. Converts args to suit the
1249 * common version, which is suitable for both sync and async use.
7cdb1a84
MS
1250 */
1251int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
1252 struct nlmsghdr *n, struct nlsock *nl, struct zebra_ns *zns,
9bfadae8 1253 bool startup)
7cdb1a84
MS
1254{
1255 struct zebra_dplane_info dp_info;
1256
1257 /* Increment sequence number before capturing snapshot of ns socket
1258 * info.
1259 */
1260 nl->seq++;
1261
1262 /* Capture info in intermediate info struct */
85a75f1e 1263 zebra_dplane_info_from_zns(&dp_info, zns, (nl == &(zns->netlink_cmd)));
7cdb1a84 1264
5709131c 1265 return netlink_talk_info(filter, n, &dp_info, startup);
1fdc9eae 1266}
1267
289602d7 1268/* Issue request message to kernel via netlink socket. GET messages
1269 * are issued through this interface.
1270 */
fd3f8e52 1271int netlink_request(struct nlsock *nl, void *req)
1fdc9eae 1272{
fd3f8e52 1273 struct nlmsghdr *n = (struct nlmsghdr *)req;
d62a17ae 1274
1275 /* Check netlink socket. */
1276 if (nl->sock < 0) {
450971aa 1277 flog_err_sys(EC_LIB_SOCKET, "%s socket isn't active.",
09c866e3 1278 nl->name);
d62a17ae 1279 return -1;
1280 }
1281
1282 /* Fill common fields for all requests. */
d62a17ae 1283 n->nlmsg_pid = nl->snl.nl_pid;
1284 n->nlmsg_seq = ++nl->seq;
1285
f8653393 1286 if (netlink_send_msg(nl, req, n->nlmsg_len) == -1)
d62a17ae 1287 return -1;
d62a17ae 1288
1289 return 0;
1fdc9eae 1290}
1291
e63c7622
JU
1292static int nl_batch_read_resp(struct nl_batch *bth)
1293{
1294 struct nlmsghdr *h;
1295 struct sockaddr_nl snl;
9d06e121 1296 struct msghdr msg = {};
f6feb48b 1297 int status, seq;
d4000d7b 1298 struct nlsock *nl;
f6feb48b
JU
1299 struct zebra_dplane_ctx *ctx;
1300 bool ignore_msg;
e63c7622 1301
d4000d7b 1302 nl = kernel_netlink_nlsock_lookup(bth->zns->sock);
e63c7622
JU
1303
1304 msg.msg_name = (void *)&snl;
1305 msg.msg_namelen = sizeof(snl);
1306
2f9dbd3a
JU
1307 /*
1308 * The responses are not batched, so we need to read and process one
1309 * message at a time.
1310 */
1311 while (true) {
2cf7651f 1312 status = netlink_recv_msg(nl, &msg);
00249e25
DS
1313 /*
1314 * status == -1 is a full on failure somewhere
1315 * since we don't know where the problem happened
1316 * we must mark all as failed
1317 *
1318 * Else we mark everything as worked
1319 *
1320 */
1321 if (status == -1 || status == 0) {
1322 while ((ctx = dplane_ctx_dequeue(&(bth->ctx_list))) !=
1323 NULL) {
1324 if (status == -1)
1325 dplane_ctx_set_status(
1326 ctx,
1327 ZEBRA_DPLANE_REQUEST_FAILURE);
1328 dplane_ctx_enqueue_tail(bth->ctx_out_q, ctx);
1329 }
2f9dbd3a 1330 return status;
00249e25 1331 }
e63c7622 1332
2cf7651f 1333 h = (struct nlmsghdr *)nl->buf;
f6feb48b
JU
1334 ignore_msg = false;
1335 seq = h->nlmsg_seq;
e63c7622 1336 /*
f6feb48b
JU
1337 * Find the corresponding context object. Received responses are
1338 * in the same order as requests we sent, so we can simply
1339 * iterate over the context list and match responses with
1340 * requests at same time.
e63c7622 1341 */
f6feb48b 1342 while (true) {
c8453cd7
DS
1343 ctx = dplane_ctx_get_head(&(bth->ctx_list));
1344 if (ctx == NULL) {
1345 /*
1346 * This is a situation where we have gotten
1347 * into a bad spot. We need to know that
1348 * this happens( does it? )
1349 */
1350 zlog_err(
1351 "%s:WARNING Received netlink Response for an error and no Contexts to associate with it",
1352 __func__);
e63c7622 1353 break;
c8453cd7 1354 }
f6feb48b
JU
1355
1356 /*
1357 * 'update' context objects take two consecutive
1358 * sequence numbers.
1359 */
3670f504
DS
1360 if (dplane_ctx_is_update(ctx) &&
1361 dplane_ctx_get_ns(ctx)->seq + 1 == seq) {
f6feb48b
JU
1362 /*
1363 * This is the situation where we get a response
1364 * to a message that should be ignored.
1365 */
1366 ignore_msg = true;
1367 break;
1368 }
c8453cd7
DS
1369
1370 ctx = dplane_ctx_dequeue(&(bth->ctx_list));
1371 dplane_ctx_enqueue_tail(bth->ctx_out_q, ctx);
1372
1373 /* We have found corresponding context object. */
3670f504 1374 if (dplane_ctx_get_ns(ctx)->seq == seq)
c8453cd7
DS
1375 break;
1376
3670f504 1377 if (dplane_ctx_get_ns(ctx)->seq > seq)
c8453cd7 1378 zlog_warn(
b9d95135 1379 "%s:WARNING Received %u is less than any context on the queue ctx->seq %u",
c8453cd7 1380 __func__, seq,
3670f504 1381 dplane_ctx_get_ns(ctx)->seq);
e63c7622
JU
1382 }
1383
c8453cd7
DS
1384 if (ignore_msg) {
1385 /*
1386 * If we ignore the message due to an update
1387 * above we should still fricking decode the
1388 * message for our operator to understand
1389 * what is going on
1390 */
1391 int err = netlink_parse_error(nl, h, bth->zns->is_cmd,
1392 false);
1393
1394 zlog_debug("%s: netlink error message seq=%d %d",
1395 __func__, h->nlmsg_seq, err);
f6feb48b 1396 continue;
c8453cd7 1397 }
f6feb48b 1398
e63c7622
JU
1399 /*
1400 * We received a message with the sequence number that isn't
1401 * associated with any dplane context object.
1402 */
f6feb48b 1403 if (ctx == NULL) {
4c99d413
MS
1404 if (IS_ZEBRA_DEBUG_KERNEL)
1405 zlog_debug(
1406 "%s: skipping unassociated response, seq number %d NS %u",
1407 __func__, h->nlmsg_seq,
1408 bth->zns->ns_id);
e63c7622
JU
1409 continue;
1410 }
1411
1412 if (h->nlmsg_type == NLMSG_ERROR) {
d166308b
MS
1413 int err = netlink_parse_error(nl, h, bth->zns->is_cmd,
1414 false);
e63c7622
JU
1415
1416 if (err == -1)
f6feb48b
JU
1417 dplane_ctx_set_status(
1418 ctx, ZEBRA_DPLANE_REQUEST_FAILURE);
e63c7622 1419
4c99d413
MS
1420 if (IS_ZEBRA_DEBUG_KERNEL)
1421 zlog_debug("%s: netlink error message seq=%d ",
1422 __func__, h->nlmsg_seq);
e63c7622
JU
1423 continue;
1424 }
1425
1426 /*
1427 * If we get here then we did not receive neither the ack nor
1428 * the error and instead received some other message in an
1429 * unexpected way.
1430 */
4c99d413
MS
1431 if (IS_ZEBRA_DEBUG_KERNEL)
1432 zlog_debug("%s: ignoring message type 0x%04x(%s) NS %u",
1433 __func__, h->nlmsg_type,
1434 nl_msg_type_to_str(h->nlmsg_type),
1435 bth->zns->ns_id);
e63c7622
JU
1436 }
1437
1438 return 0;
1439}
1440
1441static void nl_batch_reset(struct nl_batch *bth)
1442{
e63c7622
JU
1443 bth->buf_head = bth->buf;
1444 bth->curlen = 0;
1445 bth->msgcnt = 0;
1446 bth->zns = NULL;
1447
ac96497c 1448 dplane_ctx_q_init(&(bth->ctx_list));
e63c7622
JU
1449}
1450
ac96497c
MS
1451static void nl_batch_init(struct nl_batch *bth,
1452 struct dplane_ctx_list_head *ctx_out_q)
e63c7622 1453{
531c92b8
JU
1454 /*
1455 * If the size of the buffer has changed, free and then allocate a new
1456 * one.
1457 */
1458 size_t bufsize =
1459 atomic_load_explicit(&nl_batch_bufsize, memory_order_relaxed);
1460 if (bufsize != nl_batch_tx_bufsize) {
1461 if (nl_batch_tx_buf)
1462 XFREE(MTYPE_NL_BUF, nl_batch_tx_buf);
1463
1464 nl_batch_tx_buf = XCALLOC(MTYPE_NL_BUF, bufsize);
1465 nl_batch_tx_bufsize = bufsize;
1466 }
1467
f6feb48b 1468 bth->buf = nl_batch_tx_buf;
531c92b8
JU
1469 bth->bufsiz = bufsize;
1470 bth->limit = atomic_load_explicit(&nl_batch_send_threshold,
1471 memory_order_relaxed);
e63c7622 1472
f6feb48b 1473 bth->ctx_out_q = ctx_out_q;
e63c7622 1474
f6feb48b
JU
1475 nl_batch_reset(bth);
1476}
1477
1478static void nl_batch_send(struct nl_batch *bth)
1479{
1480 struct zebra_dplane_ctx *ctx;
1481 bool err = false;
e63c7622 1482
f6feb48b 1483 if (bth->curlen != 0 && bth->zns != NULL) {
d4000d7b
DS
1484 struct nlsock *nl =
1485 kernel_netlink_nlsock_lookup(bth->zns->sock);
1486
f6feb48b
JU
1487 if (IS_ZEBRA_DEBUG_KERNEL)
1488 zlog_debug("%s: %s, batch size=%zu, msg cnt=%zu",
d4000d7b 1489 __func__, nl->name, bth->curlen,
f6feb48b 1490 bth->msgcnt);
e63c7622 1491
d4000d7b 1492 if (netlink_send_msg(nl, bth->buf, bth->curlen) == -1)
e63c7622 1493 err = true;
e63c7622 1494
f6feb48b
JU
1495 if (!err) {
1496 if (nl_batch_read_resp(bth) == -1)
1497 err = true;
1498 }
1499 }
e63c7622 1500
f6feb48b
JU
1501 /* Move remaining contexts to the outbound queue. */
1502 while (true) {
1503 ctx = dplane_ctx_dequeue(&(bth->ctx_list));
1504 if (ctx == NULL)
1505 break;
e63c7622 1506
f6feb48b
JU
1507 if (err)
1508 dplane_ctx_set_status(ctx,
1509 ZEBRA_DPLANE_REQUEST_FAILURE);
e63c7622 1510
f6feb48b 1511 dplane_ctx_enqueue_tail(bth->ctx_out_q, ctx);
e63c7622
JU
1512 }
1513
1514 nl_batch_reset(bth);
1515}
1516
e63c7622
JU
1517enum netlink_msg_status netlink_batch_add_msg(
1518 struct nl_batch *bth, struct zebra_dplane_ctx *ctx,
1519 ssize_t (*msg_encoder)(struct zebra_dplane_ctx *, void *, size_t),
f6feb48b 1520 bool ignore_res)
e63c7622
JU
1521{
1522 int seq;
1523 ssize_t size;
1524 struct nlmsghdr *msgh;
d4000d7b 1525 struct nlsock *nl;
e63c7622 1526
e63c7622
JU
1527 size = (*msg_encoder)(ctx, bth->buf_head, bth->bufsiz - bth->curlen);
1528
1529 /*
1530 * If there was an error while encoding the message (other than buffer
1531 * overflow) then return an error.
1532 */
1533 if (size < 0)
1534 return FRR_NETLINK_ERROR;
1535
1536 /*
1537 * If the message doesn't fit entirely in the buffer then send the batch
1538 * and retry.
1539 */
1540 if (size == 0) {
1541 nl_batch_send(bth);
1542 size = (*msg_encoder)(ctx, bth->buf_head,
1543 bth->bufsiz - bth->curlen);
1544 /*
1545 * If the message doesn't fit in the empty buffer then just
1546 * return an error.
1547 */
1548 if (size <= 0)
1549 return FRR_NETLINK_ERROR;
1550 }
1551
3670f504 1552 seq = dplane_ctx_get_ns(ctx)->seq;
d4000d7b
DS
1553 nl = kernel_netlink_nlsock_lookup(dplane_ctx_get_ns_sock(ctx));
1554
f6feb48b 1555 if (ignore_res)
e63c7622
JU
1556 seq++;
1557
1558 msgh = (struct nlmsghdr *)bth->buf_head;
1559 msgh->nlmsg_seq = seq;
d4000d7b 1560 msgh->nlmsg_pid = nl->snl.nl_pid;
e63c7622 1561
e63c7622
JU
1562 bth->zns = dplane_ctx_get_ns(ctx);
1563 bth->buf_head = ((char *)bth->buf_head) + size;
1564 bth->curlen += size;
1565 bth->msgcnt++;
1566
e63c7622
JU
1567 return FRR_NETLINK_QUEUED;
1568}
1569
67e3369e
JU
1570static enum netlink_msg_status nl_put_msg(struct nl_batch *bth,
1571 struct zebra_dplane_ctx *ctx)
1572{
1573 if (dplane_ctx_is_skip_kernel(ctx))
1574 return FRR_NETLINK_SUCCESS;
1575
1576 switch (dplane_ctx_get_op(ctx)) {
1577
1578 case DPLANE_OP_ROUTE_INSTALL:
1579 case DPLANE_OP_ROUTE_UPDATE:
1580 case DPLANE_OP_ROUTE_DELETE:
1581 return netlink_put_route_update_msg(bth, ctx);
1582
1583 case DPLANE_OP_NH_INSTALL:
1584 case DPLANE_OP_NH_UPDATE:
1585 case DPLANE_OP_NH_DELETE:
1586 return netlink_put_nexthop_update_msg(bth, ctx);
1587
1588 case DPLANE_OP_LSP_INSTALL:
1589 case DPLANE_OP_LSP_UPDATE:
1590 case DPLANE_OP_LSP_DELETE:
1591 return netlink_put_lsp_update_msg(bth, ctx);
1592
1593 case DPLANE_OP_PW_INSTALL:
1594 case DPLANE_OP_PW_UNINSTALL:
1595 return netlink_put_pw_update_msg(bth, ctx);
1596
1597 case DPLANE_OP_ADDR_INSTALL:
1598 case DPLANE_OP_ADDR_UNINSTALL:
1599 return netlink_put_address_update_msg(bth, ctx);
1600
1601 case DPLANE_OP_MAC_INSTALL:
1602 case DPLANE_OP_MAC_DELETE:
1603 return netlink_put_mac_update_msg(bth, ctx);
1604
1605 case DPLANE_OP_NEIGH_INSTALL:
1606 case DPLANE_OP_NEIGH_UPDATE:
1607 case DPLANE_OP_NEIGH_DELETE:
1608 case DPLANE_OP_VTEP_ADD:
1609 case DPLANE_OP_VTEP_DELETE:
d68e74b4 1610 case DPLANE_OP_NEIGH_DISCOVER:
0a27a2fe
PG
1611 case DPLANE_OP_NEIGH_IP_INSTALL:
1612 case DPLANE_OP_NEIGH_IP_DELETE:
e18747a9 1613 case DPLANE_OP_NEIGH_TABLE_UPDATE:
67e3369e
JU
1614 return netlink_put_neigh_update_msg(bth, ctx);
1615
1616 case DPLANE_OP_RULE_ADD:
1617 case DPLANE_OP_RULE_DELETE:
1618 case DPLANE_OP_RULE_UPDATE:
1619 return netlink_put_rule_update_msg(bth, ctx);
1620
1621 case DPLANE_OP_SYS_ROUTE_ADD:
1622 case DPLANE_OP_SYS_ROUTE_DELETE:
1623 case DPLANE_OP_ROUTE_NOTIFY:
1624 case DPLANE_OP_LSP_NOTIFY:
c60522f7 1625 case DPLANE_OP_BR_PORT_UPDATE:
67e3369e
JU
1626 return FRR_NETLINK_SUCCESS;
1627
5162e000
PG
1628 case DPLANE_OP_IPTABLE_ADD:
1629 case DPLANE_OP_IPTABLE_DELETE:
ef524230
PG
1630 case DPLANE_OP_IPSET_ADD:
1631 case DPLANE_OP_IPSET_DELETE:
1632 case DPLANE_OP_IPSET_ENTRY_ADD:
1633 case DPLANE_OP_IPSET_ENTRY_DELETE:
5162e000
PG
1634 return FRR_NETLINK_ERROR;
1635
62b4b7e4
PG
1636 case DPLANE_OP_GRE_SET:
1637 return netlink_put_gre_set_msg(bth, ctx);
1638
9d59df63
MS
1639 case DPLANE_OP_INTF_ADDR_ADD:
1640 case DPLANE_OP_INTF_ADDR_DEL:
67e3369e
JU
1641 case DPLANE_OP_NONE:
1642 return FRR_NETLINK_ERROR;
5d414138 1643
39ffa8e8
DS
1644 case DPLANE_OP_INTF_NETCONFIG:
1645 return netlink_put_intf_netconfig(bth, ctx);
1646
5d414138
SW
1647 case DPLANE_OP_INTF_INSTALL:
1648 case DPLANE_OP_INTF_UPDATE:
1649 case DPLANE_OP_INTF_DELETE:
1650 return netlink_put_intf_update_msg(bth, ctx);
449a30ed 1651
c317d3f2
SY
1652 case DPLANE_OP_TC_QDISC_INSTALL:
1653 case DPLANE_OP_TC_QDISC_UNINSTALL:
1654 return netlink_put_tc_qdisc_update_msg(bth, ctx);
1655 case DPLANE_OP_TC_CLASS_ADD:
1656 case DPLANE_OP_TC_CLASS_DELETE:
1657 case DPLANE_OP_TC_CLASS_UPDATE:
1658 return netlink_put_tc_class_update_msg(bth, ctx);
1659 case DPLANE_OP_TC_FILTER_ADD:
1660 case DPLANE_OP_TC_FILTER_DELETE:
1661 case DPLANE_OP_TC_FILTER_UPDATE:
1662 return netlink_put_tc_filter_update_msg(bth, ctx);
67e3369e
JU
1663 }
1664
1665 return FRR_NETLINK_ERROR;
1666}
1667
ac96497c 1668void kernel_update_multi(struct dplane_ctx_list_head *ctx_list)
fef24b03 1669{
67e3369e
JU
1670 struct nl_batch batch;
1671 struct zebra_dplane_ctx *ctx;
ac96497c 1672 struct dplane_ctx_list_head handled_list;
67e3369e
JU
1673 enum netlink_msg_status res;
1674
ac96497c 1675 dplane_ctx_q_init(&handled_list);
f6feb48b 1676 nl_batch_init(&batch, &handled_list);
67e3369e
JU
1677
1678 while (true) {
1679 ctx = dplane_ctx_dequeue(ctx_list);
1680 if (ctx == NULL)
1681 break;
1682
f6feb48b
JU
1683 if (batch.zns != NULL
1684 && batch.zns->ns_id != dplane_ctx_get_ns(ctx)->ns_id)
1685 nl_batch_send(&batch);
67e3369e
JU
1686
1687 /*
f6feb48b
JU
1688 * Assume all messages will succeed and then mark only the ones
1689 * that failed.
67e3369e 1690 */
f6feb48b
JU
1691 dplane_ctx_set_status(ctx, ZEBRA_DPLANE_REQUEST_SUCCESS);
1692
1693 res = nl_put_msg(&batch, ctx);
1694
1695 dplane_ctx_enqueue_tail(&(batch.ctx_list), ctx);
1696 if (res == FRR_NETLINK_ERROR)
67e3369e
JU
1697 dplane_ctx_set_status(ctx,
1698 ZEBRA_DPLANE_REQUEST_FAILURE);
1699
f6feb48b
JU
1700 if (batch.curlen > batch.limit)
1701 nl_batch_send(&batch);
67e3369e
JU
1702 }
1703
1704 nl_batch_send(&batch);
1705
ac96497c 1706 dplane_ctx_q_init(ctx_list);
67e3369e 1707 dplane_ctx_list_append(ctx_list, &handled_list);
fef24b03
JU
1708}
1709
d4000d7b
DS
1710struct nlsock *kernel_netlink_nlsock_lookup(int sock)
1711{
34869809 1712 struct nlsock lookup, *retval;
d4000d7b
DS
1713
1714 lookup.sock = sock;
1715
34869809
MS
1716 NLSOCK_LOCK();
1717 retval = hash_lookup(nlsock_hash, &lookup);
1718 NLSOCK_UNLOCK();
1719
1720 return retval;
1721}
1722
1723/* Insert nlsock entry into hash */
1724static void kernel_netlink_nlsock_insert(struct nlsock *nls)
1725{
1726 NLSOCK_LOCK();
1727 (void)hash_get(nlsock_hash, nls, hash_alloc_intern);
1728 NLSOCK_UNLOCK();
1729}
1730
1731/* Remove nlsock entry from hash */
1732static void kernel_netlink_nlsock_remove(struct nlsock *nls)
1733{
1734 NLSOCK_LOCK();
1735 (void)hash_release(nlsock_hash, nls);
1736 NLSOCK_UNLOCK();
d4000d7b
DS
1737}
1738
1739static uint32_t kernel_netlink_nlsock_key(const void *arg)
1740{
1741 const struct nlsock *nl = arg;
1742
1743 return nl->sock;
1744}
1745
1746static bool kernel_netlink_nlsock_hash_equal(const void *arg1, const void *arg2)
1747{
1748 const struct nlsock *nl1 = arg1;
1749 const struct nlsock *nl2 = arg2;
1750
1751 if (nl1->sock == nl2->sock)
1752 return true;
1753
1754 return false;
1755}
1756
1fdc9eae 1757/* Exported interface function. This function simply calls
1758 netlink_socket (). */
d62a17ae 1759void kernel_init(struct zebra_ns *zns)
1fdc9eae 1760{
47e2eb27 1761 uint32_t groups, dplane_groups, ext_groups;
5d307d5d 1762#if defined SOL_NETLINK
313c1c8e 1763 int one, ret, grp;
5d307d5d 1764#endif
d62a17ae 1765
026a316f
DS
1766 /*
1767 * Initialize netlink sockets
1768 *
1769 * If RTMGRP_XXX exists use that, but at some point
1770 * I think the kernel developers realized that
1771 * keeping track of all the different values would
1772 * lead to confusion, so we need to convert the
1773 * RTNLGRP_XXX to a bit position for ourself
313c1c8e
SW
1774 *
1775 *
1776 * NOTE: If the bit is >= 32, you must use setsockopt(). Those
1777 * groups are added further below after SOL_NETLINK is verified to
1778 * exist.
026a316f
DS
1779 */
1780 groups = RTMGRP_LINK |
c317d3f2
SY
1781 RTMGRP_IPV4_ROUTE |
1782 RTMGRP_IPV4_IFADDR |
1783 RTMGRP_IPV6_ROUTE |
1784 RTMGRP_IPV6_IFADDR |
1785 RTMGRP_IPV4_MROUTE |
1786 RTMGRP_NEIGH |
1787 ((uint32_t) 1 << (RTNLGRP_IPV4_RULE - 1)) |
1788 ((uint32_t) 1 << (RTNLGRP_IPV6_RULE - 1)) |
1789 ((uint32_t) 1 << (RTNLGRP_NEXTHOP - 1)) |
1790 ((uint32_t) 1 << (RTNLGRP_TC - 1));
d62a17ae 1791
ceab66b7
MS
1792 dplane_groups = (RTMGRP_LINK |
1793 RTMGRP_IPV4_IFADDR |
cd787a8a
MS
1794 RTMGRP_IPV6_IFADDR |
1795 ((uint32_t) 1 << (RTNLGRP_IPV4_NETCONF - 1)) |
1796 ((uint32_t) 1 << (RTNLGRP_IPV6_NETCONF - 1)) |
1797 ((uint32_t) 1 << (RTNLGRP_MPLS_NETCONF - 1)));
1798
47e2eb27
CS
1799 /* Use setsockopt for > 31 group */
1800 ext_groups = RTNLGRP_TUNNEL;
ceab66b7 1801
d62a17ae 1802 snprintf(zns->netlink.name, sizeof(zns->netlink.name),
1803 "netlink-listen (NS %u)", zns->ns_id);
1804 zns->netlink.sock = -1;
fe953d7c
DS
1805 if (netlink_socket(&zns->netlink, groups, &ext_groups, 1, zns->ns_id) <
1806 0) {
19d5a4fe
DS
1807 zlog_err("Failure to create %s socket",
1808 zns->netlink.name);
1809 exit(-1);
1810 }
34869809
MS
1811
1812 kernel_netlink_nlsock_insert(&zns->netlink);
d62a17ae 1813
1814 snprintf(zns->netlink_cmd.name, sizeof(zns->netlink_cmd.name),
1815 "netlink-cmd (NS %u)", zns->ns_id);
1816 zns->netlink_cmd.sock = -1;
fe953d7c 1817 if (netlink_socket(&zns->netlink_cmd, 0, 0, 0, zns->ns_id) < 0) {
19d5a4fe
DS
1818 zlog_err("Failure to create %s socket",
1819 zns->netlink_cmd.name);
1820 exit(-1);
1821 }
34869809
MS
1822
1823 kernel_netlink_nlsock_insert(&zns->netlink_cmd);
d62a17ae 1824
80dcc388
MS
1825 /* Outbound socket for dplane programming of the host OS. */
1826 snprintf(zns->netlink_dplane_out.name,
1827 sizeof(zns->netlink_dplane_out.name), "netlink-dp (NS %u)",
1828 zns->ns_id);
1829 zns->netlink_dplane_out.sock = -1;
fe953d7c 1830 if (netlink_socket(&zns->netlink_dplane_out, 0, 0, 0, zns->ns_id) < 0) {
62b8bb7a 1831 zlog_err("Failure to create %s socket",
80dcc388
MS
1832 zns->netlink_dplane_out.name);
1833 exit(-1);
1834 }
34869809
MS
1835
1836 kernel_netlink_nlsock_insert(&zns->netlink_dplane_out);
80dcc388
MS
1837
1838 /* Inbound socket for OS events coming to the dplane. */
1839 snprintf(zns->netlink_dplane_in.name,
1840 sizeof(zns->netlink_dplane_in.name), "netlink-dp-in (NS %u)",
1841 zns->ns_id);
1842 zns->netlink_dplane_in.sock = -1;
fe953d7c 1843 if (netlink_socket(&zns->netlink_dplane_in, dplane_groups, 0, 0,
ceab66b7 1844 zns->ns_id) < 0) {
80dcc388
MS
1845 zlog_err("Failure to create %s socket",
1846 zns->netlink_dplane_in.name);
62b8bb7a
MS
1847 exit(-1);
1848 }
34869809
MS
1849
1850 kernel_netlink_nlsock_insert(&zns->netlink_dplane_in);
62b8bb7a 1851
5d307d5d
DS
1852 /*
1853 * SOL_NETLINK is not available on all platforms yet
1854 * apparently. It's in bits/socket.h which I am not
1855 * sure that we want to pull into our build system.
1856 */
1857#if defined SOL_NETLINK
313c1c8e
SW
1858
1859 /*
1860 * setsockopt multicast group subscriptions that don't fit in nl_groups
1861 */
1862 grp = RTNLGRP_BRVLAN;
1863 ret = setsockopt(zns->netlink.sock, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,
1864 &grp, sizeof(grp));
1865
9e67a067
SW
1866 if (ret < 0)
1867 zlog_notice(
1868 "Registration for RTNLGRP_BRVLAN Membership failed : %d %s",
1869 errno, safe_strerror(errno));
5d307d5d
DS
1870 /*
1871 * Let's tell the kernel that we want to receive extended
62b8bb7a 1872 * ACKS over our command socket(s)
5d307d5d
DS
1873 */
1874 one = 1;
1875 ret = setsockopt(zns->netlink_cmd.sock, SOL_NETLINK, NETLINK_EXT_ACK,
1876 &one, sizeof(one));
1877
1878 if (ret < 0)
62b8bb7a
MS
1879 zlog_notice("Registration for extended cmd ACK failed : %d %s",
1880 errno, safe_strerror(errno));
1881
1882 one = 1;
80dcc388
MS
1883 ret = setsockopt(zns->netlink_dplane_out.sock, SOL_NETLINK,
1884 NETLINK_EXT_ACK, &one, sizeof(one));
62b8bb7a
MS
1885
1886 if (ret < 0)
1887 zlog_notice("Registration for extended dp ACK failed : %d %s",
5d307d5d 1888 errno, safe_strerror(errno));
97f85144
JU
1889
1890 /*
1891 * Trim off the payload of the original netlink message in the
1892 * acknowledgment. This option is available since Linux 4.2, so if
1893 * setsockopt fails, ignore the error.
1894 */
1895 one = 1;
80dcc388
MS
1896 ret = setsockopt(zns->netlink_dplane_out.sock, SOL_NETLINK,
1897 NETLINK_CAP_ACK, &one, sizeof(one));
9781e6a0
DS
1898 if (ret < 0)
1899 zlog_notice(
1900 "Registration for reduced ACK packet size failed, probably running an early kernel");
5d307d5d
DS
1901#endif
1902
d62a17ae 1903 /* Register kernel socket. */
19d5a4fe 1904 if (fcntl(zns->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
450971aa 1905 flog_err_sys(EC_LIB_SOCKET, "Can't set %s socket flags: %s",
09c866e3 1906 zns->netlink.name, safe_strerror(errno));
8c85e8ea
DS
1907
1908 if (fcntl(zns->netlink_cmd.sock, F_SETFL, O_NONBLOCK) < 0)
1909 zlog_err("Can't set %s socket error: %s(%d)",
1910 zns->netlink_cmd.name, safe_strerror(errno), errno);
19d5a4fe 1911
80dcc388 1912 if (fcntl(zns->netlink_dplane_out.sock, F_SETFL, O_NONBLOCK) < 0)
62b8bb7a 1913 zlog_err("Can't set %s socket error: %s(%d)",
80dcc388
MS
1914 zns->netlink_dplane_out.name, safe_strerror(errno),
1915 errno);
1916
1917 if (fcntl(zns->netlink_dplane_in.sock, F_SETFL, O_NONBLOCK) < 0)
1918 zlog_err("Can't set %s socket error: %s(%d)",
1919 zns->netlink_dplane_in.name, safe_strerror(errno),
1920 errno);
62b8bb7a 1921
19d5a4fe 1922 /* Set receive buffer size if it's set from command line */
9fb83b55
DS
1923 if (rcvbufsize) {
1924 netlink_recvbuf(&zns->netlink, rcvbufsize);
1925 netlink_recvbuf(&zns->netlink_cmd, rcvbufsize);
1926 netlink_recvbuf(&zns->netlink_dplane_out, rcvbufsize);
1927 netlink_recvbuf(&zns->netlink_dplane_in, rcvbufsize);
97f85144 1928 }
19d5a4fe 1929
80dcc388
MS
1930 /* Set filter for inbound sockets, to exclude events we've generated
1931 * ourselves.
1932 */
1933 netlink_install_filter(zns->netlink.sock, zns->netlink_cmd.snl.nl_pid,
1934 zns->netlink_dplane_out.snl.nl_pid);
1935
1936 netlink_install_filter(zns->netlink_dplane_in.sock,
62b8bb7a 1937 zns->netlink_cmd.snl.nl_pid,
80dcc388 1938 zns->netlink_dplane_out.snl.nl_pid);
62b8bb7a 1939
19d5a4fe
DS
1940 zns->t_netlink = NULL;
1941
3801e764 1942 thread_add_read(zrouter.master, kernel_read, zns,
19d5a4fe 1943 zns->netlink.sock, &zns->t_netlink);
d62a17ae 1944
1945 rt_netlink_init();
1fdc9eae 1946}
1947
34869809
MS
1948/* Helper to clean up an nlsock */
1949static void kernel_nlsock_fini(struct nlsock *nls)
1950{
1951 if (nls && nls->sock >= 0) {
1952 kernel_netlink_nlsock_remove(nls);
1953 close(nls->sock);
1954 nls->sock = -1;
1955 XFREE(MTYPE_NL_BUF, nls->buf);
1956 nls->buflen = 0;
1957 }
1958}
1959
62b8bb7a 1960void kernel_terminate(struct zebra_ns *zns, bool complete)
1fdc9eae 1961{
146bcb9b 1962 THREAD_OFF(zns->t_netlink);
d62a17ae 1963
34869809 1964 kernel_nlsock_fini(&zns->netlink);
d62a17ae 1965
34869809 1966 kernel_nlsock_fini(&zns->netlink_cmd);
ddfeb486 1967
34869809 1968 kernel_nlsock_fini(&zns->netlink_dplane_in);
80dcc388 1969
62b8bb7a
MS
1970 /* During zebra shutdown, we need to leave the dataplane socket
1971 * around until all work is done.
1972 */
34869809
MS
1973 if (complete)
1974 kernel_nlsock_fini(&zns->netlink_dplane_out);
1975}
d4000d7b 1976
34869809
MS
1977/*
1978 * Global init for platform-/OS-specific things
1979 */
1980void kernel_router_init(void)
1981{
1982 /* Init nlsock hash and lock */
1983 pthread_mutex_init(&nlsock_mutex, NULL);
1984 nlsock_hash = hash_create_size(8, kernel_netlink_nlsock_key,
1985 kernel_netlink_nlsock_hash_equal,
1986 "Netlink Socket Hash");
1987}
1988
1989/*
1990 * Global deinit for platform-/OS-specific things
1991 */
1992void kernel_router_terminate(void)
1993{
1994 pthread_mutex_destroy(&nlsock_mutex);
1995
1996 hash_free(nlsock_hash);
1997 nlsock_hash = NULL;
62b8bb7a 1998}
34869809 1999
ddfeb486 2000#endif /* HAVE_NETLINK */