2 * Copyright (c) 2014, Bryan Venteicher <bryanv@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/ioctl.h>
32 #include <sys/socket.h>
33 #include <sys/sockio.h>
40 #include <net/ethernet.h>
42 #include <net/if_vxlan.h>
43 #include <net/route.h>
44 #include <netinet/in.h>
56 static struct ifvxlanparam params = {
57 .vxlp_vni = VXLAN_VNI_MAX,
61 get_val(const char *cp, u_long *valp)
67 val = strtoul(cp, &endptr, 0);
68 if (cp[0] == '\0' || endptr[0] != '\0' || errno == ERANGE)
76 do_cmd(int sock, u_long op, void *arg, size_t argsize, int set)
80 bzero(&ifd, sizeof(ifd));
82 strlcpy(ifd.ifd_name, ifr.ifr_name, sizeof(ifd.ifd_name));
84 ifd.ifd_len = argsize;
87 return (ioctl(sock, set ? SIOCSDRVSPEC : SIOCGDRVSPEC, &ifd));
91 vxlan_exists(int sock)
93 struct ifvxlancfg cfg;
95 bzero(&cfg, sizeof(cfg));
97 return (do_cmd(sock, VXLAN_CMD_GET_CONFIG, &cfg, sizeof(cfg), 0) != -1);
103 struct ifvxlancfg cfg;
104 char src[NI_MAXHOST], dst[NI_MAXHOST];
105 char srcport[NI_MAXSERV], dstport[NI_MAXSERV];
106 struct sockaddr *lsa, *rsa;
109 bzero(&cfg, sizeof(cfg));
111 if (do_cmd(s, VXLAN_CMD_GET_CONFIG, &cfg, sizeof(cfg), 0) < 0)
115 lsa = &cfg.vxlc_local_sa.sa;
116 rsa = &cfg.vxlc_remote_sa.sa;
117 ipv6 = rsa->sa_family == AF_INET6;
119 /* Just report nothing if the network identity isn't set yet. */
120 if (vni >= VXLAN_VNI_MAX)
123 if (getnameinfo(lsa, lsa->sa_len, src, sizeof(src),
124 srcport, sizeof(srcport), NI_NUMERICHOST | NI_NUMERICSERV) != 0)
125 src[0] = srcport[0] = '\0';
126 if (getnameinfo(rsa, rsa->sa_len, dst, sizeof(dst),
127 dstport, sizeof(dstport), NI_NUMERICHOST | NI_NUMERICSERV) != 0)
128 dst[0] = dstport[0] = '\0';
131 struct sockaddr_in *sin = (struct sockaddr_in *)rsa;
132 mc = IN_MULTICAST(ntohl(sin->sin_addr.s_addr));
134 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)rsa;
135 mc = IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr);
138 printf("\tvxlan vni %d", vni);
139 printf(" local %s%s%s:%s", ipv6 ? "[" : "", src, ipv6 ? "]" : "",
141 printf(" %s %s%s%s:%s", mc ? "group" : "remote", ipv6 ? "[" : "",
142 dst, ipv6 ? "]" : "", dstport);
145 printf("\n\t\tconfig: ");
146 printf("%slearning portrange %d-%d ttl %d",
147 cfg.vxlc_learn ? "" : "no", cfg.vxlc_port_min,
148 cfg.vxlc_port_max, cfg.vxlc_ttl);
149 printf("\n\t\tftable: ");
150 printf("cnt %d max %d timeout %d",
151 cfg.vxlc_ftable_cnt, cfg.vxlc_ftable_max,
152 cfg.vxlc_ftable_timeout);
158 #define _LOCAL_ADDR46 \
159 (VXLAN_PARAM_WITH_LOCAL_ADDR4 | VXLAN_PARAM_WITH_LOCAL_ADDR6)
160 #define _REMOTE_ADDR46 \
161 (VXLAN_PARAM_WITH_REMOTE_ADDR4 | VXLAN_PARAM_WITH_REMOTE_ADDR6)
164 vxlan_check_params(void)
167 if ((params.vxlp_with & _LOCAL_ADDR46) == _LOCAL_ADDR46)
168 errx(1, "cannot specify both local IPv4 and IPv6 addresses");
169 if ((params.vxlp_with & _REMOTE_ADDR46) == _REMOTE_ADDR46)
170 errx(1, "cannot specify both remote IPv4 and IPv6 addresses");
171 if ((params.vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR4 &&
172 params.vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) ||
173 (params.vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6 &&
174 params.vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR4))
175 errx(1, "cannot mix IPv4 and IPv6 addresses");
179 #undef _REMOTE_ADDR46
182 vxlan_cb(int s, void *arg)
188 vxlan_create(int s, struct ifreq *ifr)
191 vxlan_check_params();
193 ifr->ifr_data = (caddr_t) ¶ms;
194 if (ioctl(s, SIOCIFCREATE2, ifr) < 0)
195 err(1, "SIOCIFCREATE2");
199 DECL_CMD_FUNC(setvxlan_vni, arg, d)
201 struct ifvxlancmd cmd;
204 if (get_val(arg, &val) < 0 || val >= VXLAN_VNI_MAX)
205 errx(1, "invalid network identifier: %s", arg);
207 if (!vxlan_exists(s)) {
208 params.vxlp_with |= VXLAN_PARAM_WITH_VNI;
209 params.vxlp_vni = val;
213 bzero(&cmd, sizeof(cmd));
214 cmd.vxlcmd_vni = val;
216 if (do_cmd(s, VXLAN_CMD_SET_VNI, &cmd, sizeof(cmd), 1) < 0)
217 err(1, "VXLAN_CMD_SET_VNI");
221 DECL_CMD_FUNC(setvxlan_local, addr, d)
223 struct ifvxlancmd cmd;
228 bzero(&cmd, sizeof(cmd));
230 if ((error = getaddrinfo(addr, NULL, NULL, &ai)) != 0)
231 errx(1, "error in parsing local address string: %s",
232 gai_strerror(error));
236 switch (ai->ai_family) {
239 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
241 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
242 errx(1, "local address cannot be multicast");
244 cmd.vxlcmd_sa.in4 = *sin;
250 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
252 if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
253 errx(1, "local address cannot be multicast");
255 cmd.vxlcmd_sa.in6 = *sin6;
260 errx(1, "local address %s not supported", addr);
265 if (!vxlan_exists(s)) {
266 if (cmd.vxlcmd_sa.sa.sa_family == AF_INET) {
267 params.vxlp_with |= VXLAN_PARAM_WITH_LOCAL_ADDR4;
268 params.vxlp_local_sa.in4 = cmd.vxlcmd_sa.in4;
270 params.vxlp_with |= VXLAN_PARAM_WITH_LOCAL_ADDR6;
271 params.vxlp_local_sa.in6 = cmd.vxlcmd_sa.in6;
276 if (do_cmd(s, VXLAN_CMD_SET_LOCAL_ADDR, &cmd, sizeof(cmd), 1) < 0)
277 err(1, "VXLAN_CMD_SET_LOCAL_ADDR");
281 DECL_CMD_FUNC(setvxlan_remote, addr, d)
283 struct ifvxlancmd cmd;
288 bzero(&cmd, sizeof(cmd));
290 if ((error = getaddrinfo(addr, NULL, NULL, &ai)) != 0)
291 errx(1, "error in parsing remote address string: %s",
292 gai_strerror(error));
296 switch (ai->ai_family) {
299 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
301 if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
302 errx(1, "remote address cannot be multicast");
304 cmd.vxlcmd_sa.in4 = *sin;
310 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
312 if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
313 errx(1, "remote address cannot be multicast");
315 cmd.vxlcmd_sa.in6 = *sin6;
320 errx(1, "remote address %s not supported", addr);
325 if (!vxlan_exists(s)) {
326 if (cmd.vxlcmd_sa.sa.sa_family == AF_INET) {
327 params.vxlp_with |= VXLAN_PARAM_WITH_REMOTE_ADDR4;
328 params.vxlp_remote_sa.in4 = cmd.vxlcmd_sa.in4;
330 params.vxlp_with |= VXLAN_PARAM_WITH_REMOTE_ADDR6;
331 params.vxlp_remote_sa.in6 = cmd.vxlcmd_sa.in6;
336 if (do_cmd(s, VXLAN_CMD_SET_REMOTE_ADDR, &cmd, sizeof(cmd), 1) < 0)
337 err(1, "VXLAN_CMD_SET_REMOTE_ADDR");
341 DECL_CMD_FUNC(setvxlan_group, addr, d)
343 struct ifvxlancmd cmd;
348 bzero(&cmd, sizeof(cmd));
350 if ((error = getaddrinfo(addr, NULL, NULL, &ai)) != 0)
351 errx(1, "error in parsing group address string: %s",
352 gai_strerror(error));
356 switch (ai->ai_family) {
359 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
361 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
362 errx(1, "group address must be multicast");
364 cmd.vxlcmd_sa.in4 = *sin;
370 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
372 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
373 errx(1, "group address must be multicast");
375 cmd.vxlcmd_sa.in6 = *sin6;
380 errx(1, "group address %s not supported", addr);
385 if (!vxlan_exists(s)) {
386 if (cmd.vxlcmd_sa.sa.sa_family == AF_INET) {
387 params.vxlp_with |= VXLAN_PARAM_WITH_REMOTE_ADDR4;
388 params.vxlp_remote_sa.in4 = cmd.vxlcmd_sa.in4;
390 params.vxlp_with |= VXLAN_PARAM_WITH_REMOTE_ADDR6;
391 params.vxlp_remote_sa.in6 = cmd.vxlcmd_sa.in6;
396 if (do_cmd(s, VXLAN_CMD_SET_REMOTE_ADDR, &cmd, sizeof(cmd), 1) < 0)
397 err(1, "VXLAN_CMD_SET_REMOTE_ADDR");
401 DECL_CMD_FUNC(setvxlan_local_port, arg, d)
403 struct ifvxlancmd cmd;
406 if (get_val(arg, &val) < 0 || val >= UINT16_MAX)
407 errx(1, "invalid local port: %s", arg);
409 if (!vxlan_exists(s)) {
410 params.vxlp_with |= VXLAN_PARAM_WITH_LOCAL_PORT;
411 params.vxlp_local_port = val;
415 bzero(&cmd, sizeof(cmd));
416 cmd.vxlcmd_port = val;
418 if (do_cmd(s, VXLAN_CMD_SET_LOCAL_PORT, &cmd, sizeof(cmd), 1) < 0)
419 err(1, "VXLAN_CMD_SET_LOCAL_PORT");
423 DECL_CMD_FUNC(setvxlan_remote_port, arg, d)
425 struct ifvxlancmd cmd;
428 if (get_val(arg, &val) < 0 || val >= UINT16_MAX)
429 errx(1, "invalid remote port: %s", arg);
431 if (!vxlan_exists(s)) {
432 params.vxlp_with |= VXLAN_PARAM_WITH_REMOTE_PORT;
433 params.vxlp_remote_port = val;
437 bzero(&cmd, sizeof(cmd));
438 cmd.vxlcmd_port = val;
440 if (do_cmd(s, VXLAN_CMD_SET_REMOTE_PORT, &cmd, sizeof(cmd), 1) < 0)
441 err(1, "VXLAN_CMD_SET_REMOTE_PORT");
445 DECL_CMD_FUNC2(setvxlan_port_range, arg1, arg2)
447 struct ifvxlancmd cmd;
450 if (get_val(arg1, &min) < 0 || min >= UINT16_MAX)
451 errx(1, "invalid port range minimum: %s", arg1);
452 if (get_val(arg2, &max) < 0 || max >= UINT16_MAX)
453 errx(1, "invalid port range maximum: %s", arg2);
455 errx(1, "invalid port range");
457 if (!vxlan_exists(s)) {
458 params.vxlp_with |= VXLAN_PARAM_WITH_PORT_RANGE;
459 params.vxlp_min_port = min;
460 params.vxlp_max_port = max;
464 bzero(&cmd, sizeof(cmd));
465 cmd.vxlcmd_port_min = min;
466 cmd.vxlcmd_port_max = max;
468 if (do_cmd(s, VXLAN_CMD_SET_PORT_RANGE, &cmd, sizeof(cmd), 1) < 0)
469 err(1, "VXLAN_CMD_SET_PORT_RANGE");
473 DECL_CMD_FUNC(setvxlan_timeout, arg, d)
475 struct ifvxlancmd cmd;
478 if (get_val(arg, &val) < 0 || (val & ~0xFFFFFFFF) != 0)
479 errx(1, "invalid timeout value: %s", arg);
481 if (!vxlan_exists(s)) {
482 params.vxlp_with |= VXLAN_PARAM_WITH_FTABLE_TIMEOUT;
483 params.vxlp_ftable_timeout = val & 0xFFFFFFFF;
487 bzero(&cmd, sizeof(cmd));
488 cmd.vxlcmd_ftable_timeout = val & 0xFFFFFFFF;
490 if (do_cmd(s, VXLAN_CMD_SET_FTABLE_TIMEOUT, &cmd, sizeof(cmd), 1) < 0)
491 err(1, "VXLAN_CMD_SET_FTABLE_TIMEOUT");
495 DECL_CMD_FUNC(setvxlan_maxaddr, arg, d)
497 struct ifvxlancmd cmd;
500 if (get_val(arg, &val) < 0 || (val & ~0xFFFFFFFF) != 0)
501 errx(1, "invalid maxaddr value: %s", arg);
503 if (!vxlan_exists(s)) {
504 params.vxlp_with |= VXLAN_PARAM_WITH_FTABLE_MAX;
505 params.vxlp_ftable_max = val & 0xFFFFFFFF;
509 bzero(&cmd, sizeof(cmd));
510 cmd.vxlcmd_ftable_max = val & 0xFFFFFFFF;
512 if (do_cmd(s, VXLAN_CMD_SET_FTABLE_MAX, &cmd, sizeof(cmd), 1) < 0)
513 err(1, "VXLAN_CMD_SET_FTABLE_MAX");
517 DECL_CMD_FUNC(setvxlan_dev, arg, d)
519 struct ifvxlancmd cmd;
521 if (!vxlan_exists(s)) {
522 params.vxlp_with |= VXLAN_PARAM_WITH_MULTICAST_IF;
523 strlcpy(params.vxlp_mc_ifname, arg,
524 sizeof(params.vxlp_mc_ifname));
528 bzero(&cmd, sizeof(cmd));
529 strlcpy(cmd.vxlcmd_ifname, arg, sizeof(cmd.vxlcmd_ifname));
531 if (do_cmd(s, VXLAN_CMD_SET_MULTICAST_IF, &cmd, sizeof(cmd), 1) < 0)
532 err(1, "VXLAN_CMD_SET_MULTICAST_IF");
536 DECL_CMD_FUNC(setvxlan_ttl, arg, d)
538 struct ifvxlancmd cmd;
541 if (get_val(arg, &val) < 0 || val > 256)
542 errx(1, "invalid TTL value: %s", arg);
544 if (!vxlan_exists(s)) {
545 params.vxlp_with |= VXLAN_PARAM_WITH_TTL;
546 params.vxlp_ttl = val;
550 bzero(&cmd, sizeof(cmd));
551 cmd.vxlcmd_ttl = val;
553 if (do_cmd(s, VXLAN_CMD_SET_TTL, &cmd, sizeof(cmd), 1) < 0)
554 err(1, "VXLAN_CMD_SET_TTL");
558 DECL_CMD_FUNC(setvxlan_learn, arg, d)
560 struct ifvxlancmd cmd;
562 if (!vxlan_exists(s)) {
563 params.vxlp_with |= VXLAN_PARAM_WITH_LEARN;
564 params.vxlp_learn = d;
568 bzero(&cmd, sizeof(cmd));
570 cmd.vxlcmd_flags |= VXLAN_CMD_FLAG_LEARN;
572 if (do_cmd(s, VXLAN_CMD_SET_LEARN, &cmd, sizeof(cmd), 1) < 0)
573 err(1, "VXLAN_CMD_SET_LEARN");
577 setvxlan_flush(const char *val, int d, int s, const struct afswtch *afp)
579 struct ifvxlancmd cmd;
581 bzero(&cmd, sizeof(cmd));
583 cmd.vxlcmd_flags |= VXLAN_CMD_FLAG_FLUSH_ALL;
585 if (do_cmd(s, VXLAN_CMD_FLUSH, &cmd, sizeof(cmd), 1) < 0)
586 err(1, "VXLAN_CMD_FLUSH");
589 static struct cmd vxlan_cmds[] = {
591 DEF_CLONE_CMD_ARG("vni", setvxlan_vni),
592 DEF_CLONE_CMD_ARG("vxlanid", setvxlan_vni),
593 DEF_CLONE_CMD_ARG("vxlanlocal", setvxlan_local),
594 DEF_CLONE_CMD_ARG("vxlanremote", setvxlan_remote),
595 DEF_CLONE_CMD_ARG("vxlangroup", setvxlan_group),
596 DEF_CLONE_CMD_ARG("vxlanlocalport", setvxlan_local_port),
597 DEF_CLONE_CMD_ARG("vxlanremoteport", setvxlan_remote_port),
598 DEF_CLONE_CMD_ARG2("vxlanportrange", setvxlan_port_range),
599 DEF_CLONE_CMD_ARG("vxlantimeout", setvxlan_timeout),
600 DEF_CLONE_CMD_ARG("vxlanmaxaddr", setvxlan_maxaddr),
601 DEF_CLONE_CMD_ARG("vxlandev", setvxlan_dev),
602 DEF_CLONE_CMD_ARG("vxlanttl", setvxlan_ttl),
603 DEF_CLONE_CMD("vxlanlearn", 1, setvxlan_learn),
604 DEF_CLONE_CMD("-vxlanlearn", 0, setvxlan_learn),
606 DEF_CMD_ARG("vni", setvxlan_vni),
607 DEF_CMD_ARG("vxlanid", setvxlan_vni),
608 DEF_CMD_ARG("vxlanlocal", setvxlan_local),
609 DEF_CMD_ARG("vxlanremote", setvxlan_remote),
610 DEF_CMD_ARG("vxlangroup", setvxlan_group),
611 DEF_CMD_ARG("vxlanlocalport", setvxlan_local_port),
612 DEF_CMD_ARG("vxlanremoteport", setvxlan_remote_port),
613 DEF_CMD_ARG2("vxlanportrange", setvxlan_port_range),
614 DEF_CMD_ARG("vxlantimeout", setvxlan_timeout),
615 DEF_CMD_ARG("vxlanmaxaddr", setvxlan_maxaddr),
616 DEF_CMD_ARG("vxlandev", setvxlan_dev),
617 DEF_CMD_ARG("vxlanttl", setvxlan_ttl),
618 DEF_CMD("vxlanlearn", 1, setvxlan_learn),
619 DEF_CMD("-vxlanlearn", 0, setvxlan_learn),
621 DEF_CMD("vxlanflush", 0, setvxlan_flush),
622 DEF_CMD("vxlanflushall", 1, setvxlan_flush),
624 DEF_CMD("vxlanhwcsum", IFCAP_VXLAN_HWCSUM, setifcap),
625 DEF_CMD("-vxlanhwcsum", -IFCAP_VXLAN_HWCSUM, setifcap),
626 DEF_CMD("vxlanhwtso", IFCAP_VXLAN_HWTSO, setifcap),
627 DEF_CMD("-vxlanhwtso", -IFCAP_VXLAN_HWTSO, setifcap),
630 static struct afswtch af_vxlan = {
631 .af_name = "af_vxlan",
633 .af_other_status = vxlan_status,
636 static __constructor void
641 for (i = 0; i < nitems(vxlan_cmds); i++)
642 cmd_register(&vxlan_cmds[i]);
643 af_register(&af_vxlan);
644 callback_register(vxlan_cb, NULL);
645 clone_setdefcallback_prefix("vxlan", vxlan_create);