pintos-os.org Git - openvswitch/blob - secchan/in-band.c

   1 /*
   2  * Copyright (c) 2008, 2009 Nicira Networks.
   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 #include "in-band.h"
  19 #include <arpa/inet.h>
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <net/if.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include "flow.h"
  26 #include "mac-learning.h"
  27 #include "netdev.h"
  28 #include "odp-util.h"
  29 #include "ofp-print.h"
  30 #include "ofproto.h"
  31 #include "ofpbuf.h"
  32 #include "openflow/openflow.h"
  33 #include "packets.h"
  34 #include "poll-loop.h"
  35 #include "rconn.h"
  36 #include "status.h"
  37 #include "timeval.h"
  38 #include "vconn.h"
  39
  40 #define THIS_MODULE VLM_in_band
  41 #include "vlog.h"
  42
  43 #define IB_BASE_PRIORITY 18181800
  44
  45 enum {
  46     IBR_FROM_LOCAL_PORT,        /* Sent by the local port. */
  47     IBR_OFP_TO_LOCAL,           /* Sent to secure channel on local port. */
  48     IBR_ARP_FROM_LOCAL,         /* ARP from the local port. */
  49     IBR_ARP_FROM_CTL,           /* ARP from the controller. */
  50     IBR_TO_CTL_OFP_SRC,         /* To controller, OpenFlow source port. */
  51     IBR_TO_CTL_OFP_DST,         /* To controller, OpenFlow dest port. */
  52     IBR_FROM_CTL_OFP_SRC,       /* From controller, OpenFlow source port. */
  53     IBR_FROM_CTL_OFP_DST,       /* From controller, OpenFlow dest port. */
  54 #if OFP_TCP_PORT != OFP_SSL_PORT
  55 #error Need to support separate TCP and SSL flows.
  56 #endif
  57     N_IB_RULES
  58 };
  59
  60 struct ib_rule {
  61     bool installed;
  62     flow_t flow;
  63     uint32_t wildcards;
  64     unsigned int priority;
  65 };
  66
  67 struct in_band {
  68     struct ofproto *ofproto;
  69     struct rconn *controller;
  70     struct status_category *ss_cat;
  71
  72     /* Keeping track of controller's MAC address. */
  73     uint32_t ip;                /* Current IP, 0 if unknown. */
  74     uint32_t last_ip;           /* Last known IP, 0 if never known. */
  75     uint8_t mac[ETH_ADDR_LEN];  /* Current MAC, 0 if unknown. */
  76     uint8_t last_mac[ETH_ADDR_LEN]; /* Last known MAC, 0 if never known */
  77     char *dev_name;
  78     time_t next_refresh;        /* Next time to refresh MAC address. */
  79
  80     /* Keeping track of the local port's MAC address. */
  81     uint8_t local_mac[ETH_ADDR_LEN]; /* Current MAC. */
  82     time_t next_local_refresh;  /* Next time to refresh MAC address. */
  83
  84     /* Rules that we set up. */
  85     struct ib_rule rules[N_IB_RULES];
  86 };
  87
  88 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
  89
  90 static const uint8_t *
  91 get_controller_mac(struct in_band *ib)
  92 {
  93     time_t now = time_now();
  94     uint32_t controller_ip;
  95
  96     controller_ip = rconn_get_remote_ip(ib->controller);
  97     if (controller_ip != ib->ip || now >= ib->next_refresh) {
  98         bool have_mac;
  99
 100         ib->ip = controller_ip;
 101
 102         /* Look up MAC address. */
 103         memset(ib->mac, 0, sizeof ib->mac);
 104         if (ib->ip) {
 105             uint32_t local_ip = rconn_get_local_ip(ib->controller);
 106             struct in_addr in4;
 107             int retval;
 108
 109             in4.s_addr = local_ip;
 110             if (netdev_find_dev_by_in4(&in4, &ib->dev_name)) {
 111                 retval = netdev_nodev_arp_lookup(ib->dev_name, ib->ip,
 112                         ib->mac);
 113                 if (retval) {
 114                     VLOG_DBG_RL(&rl, "cannot look up controller MAC address "
 115                                 "("IP_FMT"): %s",
 116                                 IP_ARGS(&ib->ip), strerror(retval));
 117                 }
 118             } else {
 119                 VLOG_DBG_RL(&rl, "cannot find device with IP address "IP_FMT,
 120                     IP_ARGS(&local_ip));
 121             }
 122         }
 123         have_mac = !eth_addr_is_zero(ib->mac);
 124
 125         /* Log changes in IP, MAC addresses. */
 126         if (ib->ip && ib->ip != ib->last_ip) {
 127             VLOG_DBG("controller IP address changed from "IP_FMT
 128                      " to "IP_FMT, IP_ARGS(&ib->last_ip), IP_ARGS(&ib->ip));
 129             ib->last_ip = ib->ip;
 130         }
 131         if (have_mac && memcmp(ib->last_mac, ib->mac, ETH_ADDR_LEN)) {
 132             VLOG_DBG("controller MAC address changed from "ETH_ADDR_FMT" to "
 133                      ETH_ADDR_FMT,
 134                      ETH_ADDR_ARGS(ib->last_mac), ETH_ADDR_ARGS(ib->mac));
 135             memcpy(ib->last_mac, ib->mac, ETH_ADDR_LEN);
 136         }
 137
 138         /* Schedule next refresh.
 139          *
 140          * If we have an IP address but not a MAC address, then refresh
 141          * quickly, since we probably will get a MAC address soon (via ARP).
 142          * Otherwise, we can afford to wait a little while. */
 143         ib->next_refresh = now + (!ib->ip || have_mac ? 10 : 1);
 144     }
 145     return !eth_addr_is_zero(ib->mac) ? ib->mac : NULL;
 146 }
 147
 148 static const uint8_t *
 149 get_local_mac(struct in_band *ib)
 150 {
 151     time_t now = time_now();
 152     if (now >= ib->next_local_refresh) {
 153         uint8_t ea[ETH_ADDR_LEN];
 154         if (ib->dev_name && (!netdev_nodev_get_etheraddr(ib->dev_name, ea))) {
 155             memcpy(ib->local_mac, ea, ETH_ADDR_LEN);
 156         }
 157         ib->next_local_refresh = now + 1;
 158     }
 159     return !eth_addr_is_zero(ib->local_mac) ? ib->local_mac : NULL;
 160 }
 161
 162 static void
 163 in_band_status_cb(struct status_reply *sr, void *in_band_)
 164 {
 165     struct in_band *in_band = in_band_;
 166
 167     if (!eth_addr_is_zero(in_band->local_mac)) {
 168         status_reply_put(sr, "local-mac="ETH_ADDR_FMT,
 169                          ETH_ADDR_ARGS(in_band->local_mac));
 170     }
 171
 172     if (!eth_addr_is_zero(in_band->mac)) {
 173         status_reply_put(sr, "controller-mac="ETH_ADDR_FMT,
 174                          ETH_ADDR_ARGS(in_band->mac));
 175     }
 176 }
 177
 178 static void
 179 drop_flow(struct in_band *in_band, int rule_idx)
 180 {
 181     struct ib_rule *rule = &in_band->rules[rule_idx];
 182
 183     if (rule->installed) {
 184         rule->installed = false;
 185         ofproto_delete_flow(in_band->ofproto, &rule->flow, rule->wildcards,
 186                             rule->priority);
 187     }
 188 }
 189
 190 /* out_port and fixed_fields are assumed never to change. */
 191 static void
 192 setup_flow(struct in_band *in_band, int rule_idx, const flow_t *flow,
 193            uint32_t fixed_fields, uint16_t out_port)
 194 {
 195     struct ib_rule *rule = &in_band->rules[rule_idx];
 196
 197     if (!rule->installed || memcmp(flow, &rule->flow, sizeof *flow)) {
 198         union ofp_action action;
 199
 200         drop_flow(in_band, rule_idx);
 201
 202         rule->installed = true;
 203         rule->flow = *flow;
 204         rule->wildcards = OFPFW_ALL & ~fixed_fields;
 205         rule->priority = IB_BASE_PRIORITY + (N_IB_RULES - rule_idx);
 206
 207         action.type = htons(OFPAT_OUTPUT);
 208         action.output.len = htons(sizeof action);
 209         action.output.port = htons(out_port);
 210         action.output.max_len = htons(0);
 211         ofproto_add_flow(in_band->ofproto, &rule->flow, rule->wildcards,
 212                          rule->priority, &action, 1, 0);
 213     }
 214 }
 215
 216 void
 217 in_band_run(struct in_band *in_band)
 218 {
 219     const uint8_t *controller_mac;
 220     const uint8_t *local_mac;
 221     flow_t flow;
 222
 223     if (time_now() < MIN(in_band->next_refresh, in_band->next_local_refresh)) {
 224         return;
 225     }
 226     controller_mac = get_controller_mac(in_band);
 227     local_mac = get_local_mac(in_band);
 228
 229     /* Switch traffic sent by the local port. */
 230     memset(&flow, 0, sizeof flow);
 231     flow.in_port = ODPP_LOCAL;
 232     setup_flow(in_band, IBR_FROM_LOCAL_PORT, &flow, OFPFW_IN_PORT,
 233                OFPP_NORMAL);
 234
 235     if (local_mac) {
 236         /* Deliver traffic sent to the connection's interface. */
 237         memset(&flow, 0, sizeof flow);
 238         memcpy(flow.dl_dst, local_mac, ETH_ADDR_LEN);
 239         setup_flow(in_band, IBR_OFP_TO_LOCAL, &flow, OFPFW_DL_DST,
 240                     OFPP_NORMAL);
 241
 242         /* Allow the connection's interface to be the source of ARP traffic. */
 243         memset(&flow, 0, sizeof flow);
 244         flow.dl_type = htons(ETH_TYPE_ARP);
 245         memcpy(flow.dl_src, local_mac, ETH_ADDR_LEN);
 246         setup_flow(in_band, IBR_ARP_FROM_LOCAL, &flow,
 247                    OFPFW_DL_TYPE | OFPFW_DL_SRC, OFPP_NORMAL);
 248     } else {
 249         drop_flow(in_band, IBR_OFP_TO_LOCAL);
 250         drop_flow(in_band, IBR_ARP_FROM_LOCAL);
 251     }
 252
 253     if (controller_mac) {
 254         /* Switch ARP requests sent by the controller.  (OFPP_NORMAL will "do
 255          * the right thing" regarding VLANs here.) */
 256         memset(&flow, 0, sizeof flow);
 257         flow.dl_type = htons(ETH_TYPE_ARP);
 258         memcpy(flow.dl_dst, eth_addr_broadcast, ETH_ADDR_LEN);
 259         memcpy(flow.dl_src, controller_mac, ETH_ADDR_LEN);
 260         setup_flow(in_band, IBR_ARP_FROM_CTL, &flow,
 261                    OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_DL_SRC,
 262                    OFPP_NORMAL);
 263
 264         /* OpenFlow traffic to or from the controller.
 265          *
 266          * (A given field's value is completely ignored if it is wildcarded,
 267          * which is why we can get away with using a single 'flow' in each
 268          * case here.) */
 269         memset(&flow, 0, sizeof flow);
 270         flow.dl_type = htons(ETH_TYPE_IP);
 271         memcpy(flow.dl_src, controller_mac, ETH_ADDR_LEN);
 272         memcpy(flow.dl_dst, controller_mac, ETH_ADDR_LEN);
 273         flow.nw_proto = IP_TYPE_TCP;
 274         flow.tp_src = htons(OFP_TCP_PORT);
 275         flow.tp_dst = htons(OFP_TCP_PORT);
 276         setup_flow(in_band, IBR_TO_CTL_OFP_SRC, &flow,
 277                    (OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_NW_PROTO
 278                     | OFPFW_TP_SRC), OFPP_NORMAL);
 279         setup_flow(in_band, IBR_TO_CTL_OFP_DST, &flow,
 280                    (OFPFW_DL_TYPE | OFPFW_DL_DST | OFPFW_NW_PROTO
 281                     | OFPFW_TP_DST), OFPP_NORMAL);
 282         setup_flow(in_band, IBR_FROM_CTL_OFP_SRC, &flow,
 283                    (OFPFW_DL_TYPE | OFPFW_DL_SRC | OFPFW_NW_PROTO
 284                     | OFPFW_TP_SRC), OFPP_NORMAL);
 285         setup_flow(in_band, IBR_FROM_CTL_OFP_DST, &flow,
 286                    (OFPFW_DL_TYPE | OFPFW_DL_SRC | OFPFW_NW_PROTO
 287                     | OFPFW_TP_DST), OFPP_NORMAL);
 288     } else {
 289         drop_flow(in_band, IBR_ARP_FROM_CTL);
 290         drop_flow(in_band, IBR_TO_CTL_OFP_DST);
 291         drop_flow(in_band, IBR_TO_CTL_OFP_SRC);
 292         drop_flow(in_band, IBR_FROM_CTL_OFP_DST);
 293         drop_flow(in_band, IBR_FROM_CTL_OFP_SRC);
 294     }
 295 }
 296
 297 void
 298 in_band_wait(struct in_band *in_band)
 299 {
 300     time_t now = time_now();
 301     time_t wakeup = MIN(in_band->next_refresh, in_band->next_local_refresh);
 302     if (wakeup > now) {
 303         poll_timer_wait((wakeup - now) * 1000);
 304     } else {
 305         poll_immediate_wake();
 306     }
 307 }
 308
 309 void
 310 in_band_flushed(struct in_band *in_band)
 311 {
 312     int i;
 313
 314     for (i = 0; i < N_IB_RULES; i++) {
 315         in_band->rules[i].installed = false;
 316     }
 317 }
 318
 319 void
 320 in_band_create(struct ofproto *ofproto, struct switch_status *ss,
 321                struct rconn *controller, struct in_band **in_bandp)
 322 {
 323     struct in_band *in_band;
 324
 325     in_band = xcalloc(1, sizeof *in_band);
 326     in_band->ofproto = ofproto;
 327     in_band->controller = controller;
 328     in_band->ss_cat = switch_status_register(ss, "in-band",
 329                                              in_band_status_cb, in_band);
 330     in_band->next_refresh = TIME_MIN;
 331     in_band->next_local_refresh = TIME_MIN;
 332     in_band->dev_name = NULL;
 333
 334     *in_bandp = in_band;
 335 }
 336
 337 void
 338 in_band_destroy(struct in_band *in_band)
 339 {
 340     if (in_band) {
 341         switch_status_unregister(in_band->ss_cat);
 342         /* We don't own the rconn. */
 343     }
 344 }
 345