1 /*
2 * Copyright (C) 2016 by Open Source Routing.
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #ifdef OPEN_BSD
24
25 #include <netmpls/mpls.h>
26 #include "zebra/rt.h"
27 #include "zebra/zebra_mpls.h"
28 #include "zebra/debug.h"
29 #include "zebra/zebra_errors.h"
30 #include "zebra/zebra_router.h"
31
32 #include "privs.h"
33 #include "prefix.h"
34 #include "interface.h"
35 #include "log.h"
36 #include "lib_errors.h"
37
38 extern struct zebra_privs_t zserv_privs;
39
40 struct {
41 uint32_t rtseq;
42 int fd;
43 int ioctl_fd;
44 } kr_state;
45
kernel_send_rtmsg_v4(int action,mpls_label_t in_label,const zebra_nhlfe_t * nhlfe)46 static int kernel_send_rtmsg_v4(int action, mpls_label_t in_label,
47 const zebra_nhlfe_t *nhlfe)
48 {
49 struct iovec iov[5];
50 struct rt_msghdr hdr;
51 struct sockaddr_mpls sa_label_in, sa_label_out;
52 struct sockaddr_in nexthop;
53 int iovcnt = 0;
54 int ret;
55
56 if (IS_ZEBRA_DEBUG_KERNEL)
57 zlog_debug("%s: 0x%x, label=%u", __func__, action, in_label);
58
59 /* initialize header */
60 memset(&hdr, 0, sizeof(hdr));
61 hdr.rtm_version = RTM_VERSION;
62
63 hdr.rtm_type = action;
64 hdr.rtm_flags = RTF_UP;
65 hdr.rtm_fmask = RTF_MPLS;
66 hdr.rtm_seq = kr_state.rtseq++; /* overflow doesn't matter */
67 hdr.rtm_msglen = sizeof(hdr);
68 hdr.rtm_hdrlen = sizeof(struct rt_msghdr);
69 hdr.rtm_priority = 0;
70 /* adjust iovec */
71 iov[iovcnt].iov_base = &hdr;
72 iov[iovcnt++].iov_len = sizeof(hdr);
73
74 /* in label */
75 memset(&sa_label_in, 0, sizeof(sa_label_in));
76 sa_label_in.smpls_len = sizeof(sa_label_in);
77 sa_label_in.smpls_family = AF_MPLS;
78 sa_label_in.smpls_label = htonl(in_label << MPLS_LABEL_OFFSET);
79 /* adjust header */
80 hdr.rtm_flags |= RTF_MPLS | RTF_MPATH;
81 hdr.rtm_addrs |= RTA_DST;
82 hdr.rtm_msglen += sizeof(sa_label_in);
83 /* adjust iovec */
84 iov[iovcnt].iov_base = &sa_label_in;
85 iov[iovcnt++].iov_len = sizeof(sa_label_in);
86
87 /* nexthop */
88 memset(&nexthop, 0, sizeof(nexthop));
89 nexthop.sin_len = sizeof(nexthop);
90 nexthop.sin_family = AF_INET;
91 nexthop.sin_addr = nhlfe->nexthop->gate.ipv4;
92 /* adjust header */
93 hdr.rtm_flags |= RTF_GATEWAY;
94 hdr.rtm_addrs |= RTA_GATEWAY;
95 hdr.rtm_msglen += sizeof(nexthop);
96 /* adjust iovec */
97 iov[iovcnt].iov_base = &nexthop;
98 iov[iovcnt++].iov_len = sizeof(nexthop);
99
100 /* If action is RTM_DELETE we have to get rid of MPLS infos */
101 if (action != RTM_DELETE) {
102 memset(&sa_label_out, 0, sizeof(sa_label_out));
103 sa_label_out.smpls_len = sizeof(sa_label_out);
104 sa_label_out.smpls_family = AF_MPLS;
105 sa_label_out.smpls_label =
106 htonl(nhlfe->nexthop->nh_label->label[0]
107 << MPLS_LABEL_OFFSET);
108 /* adjust header */
109 hdr.rtm_addrs |= RTA_SRC;
110 hdr.rtm_flags |= RTF_MPLS;
111 hdr.rtm_msglen += sizeof(sa_label_out);
112 /* adjust iovec */
113 iov[iovcnt].iov_base = &sa_label_out;
114 iov[iovcnt++].iov_len = sizeof(sa_label_out);
115
116 if (nhlfe->nexthop->nh_label->label[0] == MPLS_LABEL_IMPLNULL)
117 hdr.rtm_mpls = MPLS_OP_POP;
118 else
119 hdr.rtm_mpls = MPLS_OP_SWAP;
120 }
121
122 frr_with_privs(&zserv_privs) {
123 ret = writev(kr_state.fd, iov, iovcnt);
124 }
125
126 if (ret == -1)
127 flog_err_sys(EC_LIB_SOCKET, "%s: %s", __func__,
128 safe_strerror(errno));
129
130 return ret;
131 }
132
133 #if !defined(ROUNDUP)
134 #define ROUNDUP(a) \
135 (((a) & (sizeof(long) - 1)) ? (1 + ((a) | (sizeof(long) - 1))) : (a))
136 #endif
137
kernel_send_rtmsg_v6(int action,mpls_label_t in_label,const zebra_nhlfe_t * nhlfe)138 static int kernel_send_rtmsg_v6(int action, mpls_label_t in_label,
139 const zebra_nhlfe_t *nhlfe)
140 {
141 struct iovec iov[5];
142 struct rt_msghdr hdr;
143 struct sockaddr_mpls sa_label_in, sa_label_out;
144 struct pad {
145 struct sockaddr_in6 addr;
146 char pad[sizeof(long)]; /* thank you IPv6 */
147 } nexthop;
148 int iovcnt = 0;
149 int ret;
150
151 if (IS_ZEBRA_DEBUG_KERNEL)
152 zlog_debug("%s: 0x%x, label=%u", __func__, action, in_label);
153
154 /* initialize header */
155 memset(&hdr, 0, sizeof(hdr));
156 hdr.rtm_version = RTM_VERSION;
157
158 hdr.rtm_type = action;
159 hdr.rtm_flags = RTF_UP;
160 hdr.rtm_fmask = RTF_MPLS;
161 hdr.rtm_seq = kr_state.rtseq++; /* overflow doesn't matter */
162 hdr.rtm_msglen = sizeof(hdr);
163 hdr.rtm_hdrlen = sizeof(struct rt_msghdr);
164 hdr.rtm_priority = 0;
165 /* adjust iovec */
166 iov[iovcnt].iov_base = &hdr;
167 iov[iovcnt++].iov_len = sizeof(hdr);
168
169 /* in label */
170 memset(&sa_label_in, 0, sizeof(sa_label_in));
171 sa_label_in.smpls_len = sizeof(sa_label_in);
172 sa_label_in.smpls_family = AF_MPLS;
173 sa_label_in.smpls_label = htonl(in_label << MPLS_LABEL_OFFSET);
174 /* adjust header */
175 hdr.rtm_flags |= RTF_MPLS | RTF_MPATH;
176 hdr.rtm_addrs |= RTA_DST;
177 hdr.rtm_msglen += sizeof(sa_label_in);
178 /* adjust iovec */
179 iov[iovcnt].iov_base = &sa_label_in;
180 iov[iovcnt++].iov_len = sizeof(sa_label_in);
181
182 /* nexthop */
183 memset(&nexthop, 0, sizeof(nexthop));
184 nexthop.addr.sin6_len = sizeof(struct sockaddr_in6);
185 nexthop.addr.sin6_family = AF_INET6;
186 nexthop.addr.sin6_addr = nhlfe->nexthop->gate.ipv6;
187 if (IN6_IS_ADDR_LINKLOCAL(&nexthop.addr.sin6_addr)) {
188 uint16_t tmp16;
189 struct sockaddr_in6 *sin6 = &nexthop.addr;
190
191 nexthop.addr.sin6_scope_id = nhlfe->nexthop->ifindex;
192
193 memcpy(&tmp16, &sin6->sin6_addr.s6_addr[2], sizeof(tmp16));
194 tmp16 = htons(sin6->sin6_scope_id);
195 memcpy(&sin6->sin6_addr.s6_addr[2], &tmp16, sizeof(tmp16));
196 sin6->sin6_scope_id = 0;
197 }
198
199 /* adjust header */
200 hdr.rtm_flags |= RTF_GATEWAY;
201 hdr.rtm_addrs |= RTA_GATEWAY;
202 hdr.rtm_msglen += ROUNDUP(sizeof(struct sockaddr_in6));
203 /* adjust iovec */
204 iov[iovcnt].iov_base = &nexthop;
205 iov[iovcnt++].iov_len = ROUNDUP(sizeof(struct sockaddr_in6));
206
207 /* If action is RTM_DELETE we have to get rid of MPLS infos */
208 if (action != RTM_DELETE) {
209 memset(&sa_label_out, 0, sizeof(sa_label_out));
210 sa_label_out.smpls_len = sizeof(sa_label_out);
211 sa_label_out.smpls_family = AF_MPLS;
212 sa_label_out.smpls_label =
213 htonl(nhlfe->nexthop->nh_label->label[0]
214 << MPLS_LABEL_OFFSET);
215 /* adjust header */
216 hdr.rtm_addrs |= RTA_SRC;
217 hdr.rtm_flags |= RTF_MPLS;
218 hdr.rtm_msglen += sizeof(sa_label_out);
219 /* adjust iovec */
220 iov[iovcnt].iov_base = &sa_label_out;
221 iov[iovcnt++].iov_len = sizeof(sa_label_out);
222
223 if (nhlfe->nexthop->nh_label->label[0] == MPLS_LABEL_IMPLNULL)
224 hdr.rtm_mpls = MPLS_OP_POP;
225 else
226 hdr.rtm_mpls = MPLS_OP_SWAP;
227 }
228
229 frr_with_privs(&zserv_privs) {
230 ret = writev(kr_state.fd, iov, iovcnt);
231 }
232
233 if (ret == -1)
234 flog_err_sys(EC_LIB_SOCKET, "%s: %s", __func__,
235 safe_strerror(errno));
236
237 return ret;
238 }
239
kernel_lsp_cmd(struct zebra_dplane_ctx * ctx)240 static int kernel_lsp_cmd(struct zebra_dplane_ctx *ctx)
241 {
242 const struct nhlfe_list_head *head;
243 const zebra_nhlfe_t *nhlfe;
244 const struct nexthop *nexthop = NULL;
245 unsigned int nexthop_num = 0;
246 int action;
247
248 switch (dplane_ctx_get_op(ctx)) {
249 case DPLANE_OP_LSP_DELETE:
250 action = RTM_DELETE;
251 break;
252 case DPLANE_OP_LSP_INSTALL:
253 action = RTM_ADD;
254 break;
255 case DPLANE_OP_LSP_UPDATE:
256 action = RTM_CHANGE;
257 break;
258 default:
259 return -1;
260 }
261
262 head = dplane_ctx_get_nhlfe_list(ctx);
263 frr_each(nhlfe_list_const, head, nhlfe) {
264 nexthop = nhlfe->nexthop;
265 if (!nexthop)
266 continue;
267
268 if (nexthop_num >= zrouter.multipath_num)
269 break;
270
271 if (((action == RTM_ADD || action == RTM_CHANGE)
272 && (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_SELECTED)
273 && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE)))
274 || (action == RTM_DELETE
275 && (CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED)
276 && CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)))) {
277 if (nhlfe->nexthop->nh_label->num_labels > 1) {
278 flog_warn(EC_ZEBRA_MAX_LABELS_PUSH,
279 "%s: can't push %u labels at once (maximum is 1)",
280 __func__,
281 nhlfe->nexthop->nh_label->num_labels);
282 continue;
283 }
284
285 nexthop_num++;
286
287 switch (NHLFE_FAMILY(nhlfe)) {
288 case AF_INET:
289 kernel_send_rtmsg_v4(
290 action,
291 dplane_ctx_get_in_label(ctx),
292 nhlfe);
293 break;
294 case AF_INET6:
295 kernel_send_rtmsg_v6(
296 action,
297 dplane_ctx_get_in_label(ctx),
298 nhlfe);
299 break;
300 default:
301 break;
302 }
303 }
304 }
305
306 return 0;
307 }
308
kernel_lsp_update(struct zebra_dplane_ctx * ctx)309 enum zebra_dplane_result kernel_lsp_update(struct zebra_dplane_ctx *ctx)
310 {
311 int ret;
312
313 ret = kernel_lsp_cmd(ctx);
314
315 return (ret == 0 ?
316 ZEBRA_DPLANE_REQUEST_SUCCESS : ZEBRA_DPLANE_REQUEST_FAILURE);
317 }
318
kmpw_install(struct zebra_dplane_ctx * ctx)319 static enum zebra_dplane_result kmpw_install(struct zebra_dplane_ctx *ctx)
320 {
321 struct ifreq ifr;
322 struct ifmpwreq imr;
323 struct sockaddr_storage ss;
324 struct sockaddr_in *sa_in = (struct sockaddr_in *)&ss;
325 struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)&ss;
326 const union g_addr *gaddr;
327
328 memset(&imr, 0, sizeof(imr));
329 switch (dplane_ctx_get_pw_type(ctx)) {
330 case PW_TYPE_ETHERNET:
331 imr.imr_type = IMR_TYPE_ETHERNET;
332 break;
333 case PW_TYPE_ETHERNET_TAGGED:
334 imr.imr_type = IMR_TYPE_ETHERNET_TAGGED;
335 break;
336 default:
337 zlog_debug("%s: unhandled pseudowire type (%#X)", __func__,
338 dplane_ctx_get_pw_type(ctx));
339 return ZEBRA_DPLANE_REQUEST_FAILURE;
340 }
341
342 if (dplane_ctx_get_pw_flags(ctx) & F_PSEUDOWIRE_CWORD)
343 imr.imr_flags |= IMR_FLAG_CONTROLWORD;
344
345 /* pseudowire nexthop */
346 memset(&ss, 0, sizeof(ss));
347 gaddr = dplane_ctx_get_pw_dest(ctx);
348 switch (dplane_ctx_get_pw_af(ctx)) {
349 case AF_INET:
350 sa_in->sin_family = AF_INET;
351 sa_in->sin_len = sizeof(struct sockaddr_in);
352 sa_in->sin_addr = gaddr->ipv4;
353 break;
354 case AF_INET6:
355 sa_in6->sin6_family = AF_INET6;
356 sa_in6->sin6_len = sizeof(struct sockaddr_in6);
357 sa_in6->sin6_addr = gaddr->ipv6;
358 break;
359 default:
360 zlog_debug("%s: unhandled pseudowire address-family (%u)",
361 __func__, dplane_ctx_get_pw_af(ctx));
362 return ZEBRA_DPLANE_REQUEST_FAILURE;
363 }
364 memcpy(&imr.imr_nexthop, (struct sockaddr *)&ss,
365 sizeof(imr.imr_nexthop));
366
367 /* pseudowire local/remote labels */
368 imr.imr_lshim.shim_label = dplane_ctx_get_pw_local_label(ctx);
369 imr.imr_rshim.shim_label = dplane_ctx_get_pw_remote_label(ctx);
370
371 /* ioctl */
372 memset(&ifr, 0, sizeof(ifr));
373 strlcpy(ifr.ifr_name, dplane_ctx_get_ifname(ctx),
374 sizeof(ifr.ifr_name));
375 ifr.ifr_data = (caddr_t)&imr;
376 if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
377 flog_err_sys(EC_LIB_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
378 safe_strerror(errno));
379 return ZEBRA_DPLANE_REQUEST_FAILURE;
380 }
381
382 return ZEBRA_DPLANE_REQUEST_SUCCESS;
383 }
384
kmpw_uninstall(struct zebra_dplane_ctx * ctx)385 static enum zebra_dplane_result kmpw_uninstall(struct zebra_dplane_ctx *ctx)
386 {
387 struct ifreq ifr;
388 struct ifmpwreq imr;
389
390 memset(&ifr, 0, sizeof(ifr));
391 memset(&imr, 0, sizeof(imr));
392 strlcpy(ifr.ifr_name, dplane_ctx_get_ifname(ctx),
393 sizeof(ifr.ifr_name));
394 ifr.ifr_data = (caddr_t)&imr;
395 if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
396 flog_err_sys(EC_LIB_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
397 safe_strerror(errno));
398 return ZEBRA_DPLANE_REQUEST_FAILURE;
399 }
400
401 return ZEBRA_DPLANE_REQUEST_SUCCESS;
402 }
403
404 /*
405 * Pseudowire update api for openbsd.
406 */
kernel_pw_update(struct zebra_dplane_ctx * ctx)407 enum zebra_dplane_result kernel_pw_update(struct zebra_dplane_ctx *ctx)
408 {
409 enum zebra_dplane_result result = ZEBRA_DPLANE_REQUEST_FAILURE;
410
411 switch (dplane_ctx_get_op(ctx)) {
412 case DPLANE_OP_PW_INSTALL:
413 result = kmpw_install(ctx);
414 break;
415 case DPLANE_OP_PW_UNINSTALL:
416 result = kmpw_uninstall(ctx);
417 break;
418 default:
419 break;
420 }
421
422 return result;
423 }
424
425 #define MAX_RTSOCK_BUF 128 * 1024
mpls_kernel_init(void)426 int mpls_kernel_init(void)
427 {
428 int rcvbuf, default_rcvbuf;
429 socklen_t optlen;
430
431 if ((kr_state.fd = socket(AF_ROUTE, SOCK_RAW, 0)) == -1) {
432 flog_err_sys(EC_LIB_SOCKET, "%s: socket", __func__);
433 return -1;
434 }
435
436 if ((kr_state.ioctl_fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, 0))
437 == -1) {
438 flog_err_sys(EC_LIB_SOCKET, "%s: ioctl socket", __func__);
439 return -1;
440 }
441
442 /* grow receive buffer, don't wanna miss messages */
443 optlen = sizeof(default_rcvbuf);
444 if (getsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, &default_rcvbuf,
445 &optlen)
446 == -1)
447 flog_err_sys(EC_LIB_SOCKET,
448 "kr_init getsockopt SOL_SOCKET SO_RCVBUF");
449 else
450 for (rcvbuf = MAX_RTSOCK_BUF;
451 rcvbuf > default_rcvbuf
452 && setsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
453 sizeof(rcvbuf))
454 == -1
455 && errno == ENOBUFS;
456 rcvbuf /= 2)
457 ; /* nothing */
458
459 kr_state.rtseq = 1;
460
461 return 0;
462 }
463
464 #endif /* OPEN_BSD */
465