lib/ovs-router.c

   1 /*
   2  * Copyright (c) 2014, 2015 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "ovs-router.h"
  20
  21 #include <arpa/inet.h>
  22 #include <errno.h>
  23 #include <inttypes.h>
  24 #include <sys/socket.h>
  25 #include <net/if.h>
  26 #include <netinet/in.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 #include "classifier.h"
  33 #include "command-line.h"
  34 #include "compiler.h"
  35 #include "dpif.h"
  36 #include "dynamic-string.h"
  37 #include "netdev.h"
  38 #include "packets.h"
  39 #include "seq.h"
  40 #include "ovs-thread.h"
  41 #include "route-table.h"
  42 #include "tnl-ports.h"
  43 #include "unixctl.h"
  44 #include "util.h"
  45
  46 static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
  47 static struct classifier cls;
  48
  49 struct ovs_router_entry {
  50     struct cls_rule cr;
  51     char output_bridge[IFNAMSIZ];
  52     struct in6_addr gw;
  53     struct in6_addr nw_addr;
  54     uint8_t plen;
  55     uint8_t priority;
  56 };
  57
  58 static struct ovs_router_entry *
  59 ovs_router_entry_cast(const struct cls_rule *cr)
  60 {
  61     if (offsetof(struct ovs_router_entry, cr) == 0) {
  62         return CONTAINER_OF(cr, struct ovs_router_entry, cr);
  63     } else {
  64         return cr ? CONTAINER_OF(cr, struct ovs_router_entry, cr) : NULL;
  65     }
  66 }
  67
  68 bool
  69 ovs_router_lookup(const struct in6_addr *ip6_dst, char output_bridge[],
  70                   struct in6_addr *gw)
  71 {
  72     const struct cls_rule *cr;
  73     struct flow flow = {.ipv6_dst = *ip6_dst};
  74
  75     cr = classifier_lookup(&cls, CLS_MAX_VERSION, &flow, NULL);
  76     if (cr) {
  77         struct ovs_router_entry *p = ovs_router_entry_cast(cr);
  78
  79         ovs_strlcpy(output_bridge, p->output_bridge, IFNAMSIZ);
  80         *gw = p->gw;
  81         return true;
  82     }
  83     return false;
  84 }
  85
  86 bool
  87 ovs_router_lookup4(ovs_be32 ip_dst, char output_bridge[], ovs_be32 *gw)
  88 {
  89     struct in6_addr ip6_dst;
  90     struct in6_addr gw6;
  91
  92     in6_addr_set_mapped_ipv4(&ip6_dst, ip_dst);
  93     if (ovs_router_lookup(&ip6_dst, output_bridge, &gw6)) {
  94         *gw = in6_addr_get_mapped_ipv4(&gw6);
  95         return true;
  96     }
  97     return route_table_fallback_lookup(ip_dst, output_bridge, gw);
  98 }
  99
 100 static void
 101 rt_entry_free(struct ovs_router_entry *p)
 102 {
 103     cls_rule_destroy(&p->cr);
 104     free(p);
 105 }
 106
 107 static void rt_init_match(struct match *match, const struct in6_addr *ip6_dst,
 108                           uint8_t plen)
 109 {
 110     struct in6_addr dst;
 111     struct in6_addr mask;
 112
 113     mask = ipv6_create_mask(plen);
 114
 115     dst = ipv6_addr_bitand(ip6_dst, &mask);
 116     memset(match, 0, sizeof *match);
 117     match->flow.ipv6_dst = dst;
 118     match->wc.masks.ipv6_dst = mask;
 119 }
 120
 121 static void
 122 ovs_router_insert__(uint8_t priority, const struct in6_addr *ip6_dst,
 123                     uint8_t plen, const char output_bridge[],
 124                     const struct in6_addr *gw)
 125 {
 126     const struct cls_rule *cr;
 127     struct ovs_router_entry *p;
 128     struct match match;
 129
 130     rt_init_match(&match, ip6_dst, plen);
 131
 132     p = xzalloc(sizeof *p);
 133     ovs_strlcpy(p->output_bridge, output_bridge, sizeof p->output_bridge);
 134     if (ipv6_addr_is_set(gw)) {
 135         p->gw = *gw;
 136     }
 137     p->nw_addr = match.flow.ipv6_dst;
 138     p->plen = plen;
 139     p->priority = priority;
 140     /* Longest prefix matches first. */
 141     cls_rule_init(&p->cr, &match, priority);
 142
 143     ovs_mutex_lock(&mutex);
 144     cr = classifier_replace(&cls, &p->cr, CLS_MIN_VERSION, NULL, 0);
 145     ovs_mutex_unlock(&mutex);
 146
 147     if (cr) {
 148         /* An old rule with the same match was displaced. */
 149         ovsrcu_postpone(rt_entry_free, ovs_router_entry_cast(cr));
 150     }
 151     tnl_port_map_insert_ipdev(output_bridge);
 152     seq_change(tnl_conf_seq);
 153 }
 154
 155 void
 156 ovs_router_insert(const struct in6_addr *ip_dst, uint8_t plen,
 157                   const char output_bridge[], const struct in6_addr *gw)
 158 {
 159     ovs_router_insert__(plen, ip_dst, plen, output_bridge, gw);
 160 }
 161
 162
 163 static bool
 164 __rt_entry_delete(const struct cls_rule *cr)
 165 {
 166     struct ovs_router_entry *p = ovs_router_entry_cast(cr);
 167
 168     tnl_port_map_delete_ipdev(p->output_bridge);
 169     /* Remove it. */
 170     cr = classifier_remove(&cls, cr);
 171     if (cr) {
 172         ovsrcu_postpone(rt_entry_free, ovs_router_entry_cast(cr));
 173         return true;
 174     }
 175     return false;
 176 }
 177
 178 static bool
 179 rt_entry_delete(uint8_t priority, const struct in6_addr *ip6_dst, uint8_t plen)
 180 {
 181     const struct cls_rule *cr;
 182     struct cls_rule rule;
 183     struct match match;
 184     bool res = false;
 185
 186     rt_init_match(&match, ip6_dst, plen);
 187
 188     cls_rule_init(&rule, &match, priority);
 189
 190     /* Find the exact rule. */
 191     cr = classifier_find_rule_exactly(&cls, &rule, CLS_MAX_VERSION);
 192     if (cr) {
 193         ovs_mutex_lock(&mutex);
 194         res = __rt_entry_delete(cr);
 195         ovs_mutex_unlock(&mutex);
 196     }
 197     return res;
 198 }
 199
 200 static bool
 201 scan_ipv6_route(const char *s, struct in6_addr *addr, unsigned int *plen)
 202 {
 203     int len, n;
 204     int slen = strlen(s);
 205     char ipv6_s[IPV6_SCAN_LEN + 1];
 206
 207     if (ovs_scan(s, IPV6_SCAN_FMT"%n", ipv6_s, &len)
 208         && inet_pton(AF_INET6, ipv6_s, addr) == 1) {
 209         if (len == slen) {
 210             *plen = 128;
 211             return true;
 212         }
 213         if (ovs_scan(s + len, "/%u%n", plen, &n)
 214             && len + n == slen && *plen <= 128) {
 215             return true;
 216         }
 217     }
 218     return false;
 219 }
 220
 221 static bool
 222 scan_ipv4_route(const char *s, ovs_be32 *addr, unsigned int *plen)
 223 {
 224     int len, max_plen, n;
 225     int slen = strlen(s);
 226     uint8_t *ip = (uint8_t *)addr;
 227
 228     *addr = htonl(0);
 229     if (!ovs_scan(s, "%"SCNu8"%n", &ip[0], &n)) {
 230         return false;
 231     }
 232     len = n;
 233     max_plen = 8;
 234     for (int i = 1; i < 4; i++) {
 235         if (ovs_scan(s + len, ".%"SCNu8"%n", &ip[i], &n)) {
 236             len += n;
 237             max_plen += 8;
 238         } else {
 239             break;
 240         }
 241     }
 242     if (len == slen && max_plen == 32) {
 243         *plen = 32;
 244         return true;
 245     }
 246     if (ovs_scan(s + len, "/%u%n", plen, &n)
 247         && len + n == slen && *plen <= max_plen) {
 248         return true;
 249     }
 250     return false;
 251 }
 252
 253 static void
 254 ovs_router_add(struct unixctl_conn *conn, int argc,
 255               const char *argv[], void *aux OVS_UNUSED)
 256 {
 257     ovs_be32 ip, gw;
 258     unsigned int plen;
 259     struct in6_addr ip6;
 260     struct in6_addr gw6;
 261
 262     if (scan_ipv4_route(argv[1], &ip, &plen)) {
 263         if (argc > 3) {
 264             inet_pton(AF_INET, argv[3], (struct in_addr *)&gw);
 265         } else {
 266             gw = 0;
 267         }
 268         in6_addr_set_mapped_ipv4(&ip6, ip);
 269         in6_addr_set_mapped_ipv4(&gw6, gw);
 270         plen += 96;
 271     } else if (scan_ipv6_route(argv[1], &ip6, &plen)) {
 272         if (argc > 3) {
 273             inet_pton(AF_INET6, argv[3], &gw6);
 274         } else {
 275             gw6 = in6addr_any;
 276         }
 277     } else {
 278         unixctl_command_reply(conn, "Invalid parameters");
 279     }
 280     ovs_router_insert__(plen + 32, &ip6, plen, argv[2], &gw6);
 281     unixctl_command_reply(conn, "OK");
 282 }
 283
 284 static void
 285 ovs_router_del(struct unixctl_conn *conn, int argc OVS_UNUSED,
 286               const char *argv[], void *aux OVS_UNUSED)
 287 {
 288     ovs_be32 ip;
 289     unsigned int plen;
 290     struct in6_addr ip6;
 291
 292     if (scan_ipv4_route(argv[1], &ip, &plen)) {
 293         in6_addr_set_mapped_ipv4(&ip6, ip);
 294         plen += 96;
 295     } else if (!scan_ipv6_route(argv[1], &ip6, &plen)) {
 296         unixctl_command_reply(conn, "Invalid parameters");
 297     }
 298     if (rt_entry_delete(plen + 32, &ip6, plen)) {
 299         unixctl_command_reply(conn, "OK");
 300         seq_change(tnl_conf_seq);
 301     } else {
 302         unixctl_command_reply(conn, "Not found");
 303     }
 304 }
 305
 306 static void
 307 ovs_router_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 308                const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 309 {
 310     struct ovs_router_entry *rt;
 311     struct ds ds = DS_EMPTY_INITIALIZER;
 312
 313     ds_put_format(&ds, "Route Table:\n");
 314     CLS_FOR_EACH(rt, cr, &cls) {
 315         uint8_t plen;
 316         if (rt->priority == rt->plen) {
 317             ds_put_format(&ds, "Cached: ");
 318         } else {
 319             ds_put_format(&ds, "User: ");
 320         }
 321         print_ipv6_mapped(&ds, &rt->nw_addr);
 322         plen = rt->plen;
 323         if (IN6_IS_ADDR_V4MAPPED(&rt->nw_addr)) {
 324             plen -= 96;
 325         }
 326         ds_put_format(&ds, "/%"PRIu16" dev %s", plen, rt->output_bridge);
 327         if (ipv6_addr_is_set(&rt->gw)) {
 328             ds_put_format(&ds, " GW ");
 329             print_ipv6_mapped(&ds, &rt->gw);
 330         }
 331         ds_put_format(&ds, "\n");
 332     }
 333     unixctl_command_reply(conn, ds_cstr(&ds));
 334     ds_destroy(&ds);
 335 }
 336
 337 static void
 338 ovs_router_lookup_cmd(struct unixctl_conn *conn, int argc OVS_UNUSED,
 339                       const char *argv[], void *aux OVS_UNUSED)
 340 {
 341     ovs_be32 ip;
 342     struct in6_addr ip6;
 343     unsigned int plen;
 344     char iface[IFNAMSIZ];
 345     struct in6_addr gw;
 346
 347     if (scan_ipv4_route(argv[1], &ip, &plen) && plen == 32) {
 348         in6_addr_set_mapped_ipv4(&ip6, ip);
 349     } else if (!(scan_ipv6_route(argv[1], &ip6, &plen) && plen == 128)) {
 350         unixctl_command_reply(conn, "Invalid parameters");
 351     }
 352
 353     if (ovs_router_lookup(&ip6, iface, &gw)) {
 354         struct ds ds = DS_EMPTY_INITIALIZER;
 355         ds_put_format(&ds, "gateway ");
 356         print_ipv6_mapped(&ds, &ip6);
 357         ds_put_format(&ds, "\ndev %s\n", iface);
 358         unixctl_command_reply(conn, ds_cstr(&ds));
 359         ds_destroy(&ds);
 360     } else {
 361         unixctl_command_reply(conn, "Not found");
 362     }
 363 }
 364
 365 void
 366 ovs_router_flush(void)
 367 {
 368     struct ovs_router_entry *rt;
 369
 370     ovs_mutex_lock(&mutex);
 371     classifier_defer(&cls);
 372     CLS_FOR_EACH(rt, cr, &cls) {
 373         if (rt->priority == rt->plen) {
 374             __rt_entry_delete(&rt->cr);
 375         }
 376     }
 377     classifier_publish(&cls);
 378     ovs_mutex_unlock(&mutex);
 379     seq_change(tnl_conf_seq);
 380 }
 381
 382 /* May not be called more than once. */
 383 void
 384 ovs_router_init(void)
 385 {
 386     classifier_init(&cls, NULL);
 387     unixctl_command_register("ovs/route/add", "ip_addr/prefix_len out_br_name gw", 2, 3,
 388                              ovs_router_add, NULL);
 389     unixctl_command_register("ovs/route/show", "", 0, 0, ovs_router_show, NULL);
 390     unixctl_command_register("ovs/route/del", "ip_addr/prefix_len", 1, 1, ovs_router_del,
 391                              NULL);
 392     unixctl_command_register("ovs/route/lookup", "ip_addr", 1, 1,
 393                              ovs_router_lookup_cmd, NULL);
 394 }