const char *controller_name; /* Controller (if not discovery mode). */
const char *listener_names[MAX_MGMT]; /* Listen for mgmt connections. */
size_t n_listeners; /* Number of mgmt connection listeners. */
+ const char *monitor_name; /* Listen for traffic monitor connections. */
/* Failure behavior. */
enum fail_mode fail_mode; /* Act as learning switch if no controller? */
static void parse_options(int argc, char *argv[], struct settings *);
static void usage(void) NO_RETURN;
+static struct vconn *open_passive_vconn(const char *name);
+static struct vconn *accept_vconn(struct vconn *vconn);
+
static struct relay *relay_create(struct rconn *local, struct rconn *remote,
bool is_mgmt_conn);
static struct relay *relay_accept(const struct settings *, struct vconn *);
struct hook hooks[8];
size_t n_hooks = 0;
+ struct vconn *monitor;
+
struct vconn *listeners[MAX_MGMT];
size_t n_listeners;
parse_options(argc, argv, &s);
signal(SIGPIPE, SIG_IGN);
- /* Start listening for management connections. */
+ /* Start listening for management and monitoring connections. */
n_listeners = 0;
for (i = 0; i < s.n_listeners; i++) {
- const char *name = s.listener_names[i];
- struct vconn *listener;
- retval = vconn_open(name, &listener);
- if (retval && retval != EAGAIN) {
- fatal(retval, "opening %s", name);
- }
- if (!vconn_is_passive(listener)) {
- fatal(0, "%s is not a passive vconn", name);
- }
- listeners[n_listeners++] = listener;
+ listeners[n_listeners++] = open_passive_vconn(s.listener_names[i]);
}
+ monitor = s.monitor_name ? open_passive_vconn(s.monitor_name) : NULL;
/* Initialize switch status hook. */
hooks[n_hooks++] = switch_status_hook_create(&s, &switch_status);
list_push_back(&relays, &r->node);
}
}
+ if (monitor) {
+ struct vconn *new = accept_vconn(monitor);
+ if (new) {
+ rconn_add_monitor(local_rconn, new);
+ }
+ }
for (i = 0; i < n_hooks; i++) {
if (hooks[i].periodic_cb) {
hooks[i].periodic_cb(hooks[i].aux);
for (i = 0; i < n_listeners; i++) {
vconn_accept_wait(listeners[i]);
}
+ if (monitor) {
+ vconn_accept_wait(monitor);
+ }
for (i = 0; i < n_hooks; i++) {
if (hooks[i].wait_cb) {
hooks[i].wait_cb(hooks[i].aux);
return 0;
}
+static struct vconn *
+open_passive_vconn(const char *name)
+{
+ struct vconn *vconn;
+ int retval;
+
+ retval = vconn_open(name, &vconn);
+ if (retval && retval != EAGAIN) {
+ fatal(retval, "opening %s", name);
+ }
+ if (!vconn_is_passive(vconn)) {
+ fatal(0, "%s is not a passive vconn", name);
+ }
+ return vconn;
+}
+
+static struct vconn *
+accept_vconn(struct vconn *vconn)
+{
+ struct vconn *new;
+ int retval;
+
+ retval = vconn_accept(vconn, &new);
+ if (retval && retval != EAGAIN) {
+ VLOG_WARN_RL(&vrl, "accept failed (%s)", strerror(retval));
+ }
+ return new;
+}
+
static struct hook
make_hook(bool (*packet_cb)(struct relay *, int half, void *aux),
void (*periodic_cb)(void *aux),
struct rconn *r1, *r2;
int retval;
- retval = vconn_accept(listen_vconn, &new_remote);
- if (retval) {
- if (retval != EAGAIN) {
- VLOG_WARN_RL(&vrl, "accept failed (%s)", strerror(retval));
- }
+ new_remote = accept_vconn(listen_vconn);
+ if (!new_remote) {
return NULL;
}
return mac && eth_addr_equals(mac, dl_addr);
}
+static void
+in_band_learn_mac(struct in_band_data *in_band, const struct flow *flow)
+{
+ uint16_t in_port = ntohs(flow->in_port);
+ if (mac_learning_learn(in_band->ml, flow->dl_src, in_port)) {
+ VLOG_DBG_RL(&vrl, "learned that "ETH_ADDR_FMT" is on port %"PRIu16,
+ ETH_ADDR_ARGS(flow->dl_src), in_port);
+ }
+}
+
static bool
in_band_packet_cb(struct relay *r, int half, void *in_band_)
{
struct buffer pkt;
struct flow flow;
uint16_t in_port, out_port;
- const uint8_t *controller_mac;
if (half != HALF_LOCAL || r->is_mgmt_conn) {
return false;
flow_extract(&pkt, in_port, &flow);
/* Deal with local stuff. */
- controller_mac = get_controller_mac(in_band);
if (in_port == OFPP_LOCAL) {
/* Sent by secure channel. */
out_port = mac_learning_lookup(in_band->ml, flow.dl_dst);
} else if (eth_addr_equals(flow.dl_dst, in_band->mac)) {
/* Sent to secure channel. */
out_port = OFPP_LOCAL;
- if (mac_learning_learn(in_band->ml, flow.dl_src, in_port)) {
- VLOG_DBG_RL(&vrl, "learned that "ETH_ADDR_FMT" is on port %"PRIu16,
- ETH_ADDR_ARGS(flow.dl_src), in_port);
- }
+ in_band_learn_mac(in_band, &flow);
} else if (flow.dl_type == htons(ETH_TYPE_ARP)
&& eth_addr_is_broadcast(flow.dl_dst)
&& is_controller_mac(flow.dl_src, in_band)) {
/* ARP sent by controller. */
out_port = OFPP_FLOOD;
- } else if (is_controller_mac(flow.dl_dst, in_band)) {
- if (mac_learning_learn(in_band->ml, flow.dl_src, in_port)) {
- VLOG_DBG_RL(&vrl, "learned that "ETH_ADDR_FMT" is on port %"PRIu16,
- ETH_ADDR_ARGS(flow.dl_src), in_port);
- }
-
- out_port = mac_learning_lookup(in_band->ml, controller_mac);
- if (in_port != out_port) {
- return false;
- }
-
- /* This is controller traffic that arrived on the controller port.
- * It will get dropped below. */
- } else if (is_controller_mac(flow.dl_src, in_band)) {
+ } else if (is_controller_mac(flow.dl_dst, in_band)
+ || is_controller_mac(flow.dl_src, in_band)) {
+ /* Traffic to or from controller. Switch it by hand. */
+ in_band_learn_mac(in_band, &flow);
out_port = mac_learning_lookup(in_band->ml, flow.dl_dst);
} else {
return false;
{"max-idle", required_argument, 0, OPT_MAX_IDLE},
{"max-backoff", required_argument, 0, OPT_MAX_BACKOFF},
{"listen", required_argument, 0, 'l'},
+ {"monitor", required_argument, 0, 'm'},
{"rate-limit", optional_argument, 0, OPT_RATE_LIMIT},
{"burst-limit", required_argument, 0, OPT_BURST_LIMIT},
{"detach", no_argument, 0, 'D'},
/* Set defaults that we can figure out before parsing options. */
s->n_listeners = 0;
+ s->monitor_name = NULL;
s->fail_mode = FAIL_OPEN;
s->max_idle = 15;
s->probe_interval = 15;
s->listener_names[s->n_listeners++] = optarg;
break;
+ case 'm':
+ if (s->monitor_name) {
+ fatal(0, "-m or --monitor may only be specified once");
+ }
+ s->monitor_name = optarg;
+ break;
+
case 'h':
usage();
" attempts (default: 15 seconds)\n"
" -l, --listen=METHOD allow management connections on METHOD\n"
" (a passive OpenFlow connection method)\n"
+ " -m, --monitor=METHOD copy traffic to/from kernel to METHOD\n"
+ " (a passive OpenFlow connection method)\n"
"\nRate-limiting of \"packet-in\" messages to the controller:\n"
" --rate-limit[=PACKETS] max rate, in packets/s (default: 1000)\n"
" --burst-limit=BURST limit on packet credit for idle time\n"