+/* Port status watcher. */
+
+typedef void port_changed_cb_func(uint16_t port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new,
+ void *aux);
+
+struct port_watcher_cb {
+ port_changed_cb_func *port_changed;
+ void *aux;
+};
+
+typedef void local_port_changed_cb_func(const struct ofp_phy_port *new,
+ void *aux);
+
+struct port_watcher_local_cb {
+ local_port_changed_cb_func *local_port_changed;
+ void *aux;
+};
+
+struct port_watcher {
+ struct rconn *local_rconn;
+ struct rconn *remote_rconn;
+ struct ofp_phy_port ports[OFPP_MAX + 1];
+ time_t last_feature_request;
+ bool got_feature_reply;
+ int n_txq;
+ struct port_watcher_cb cbs[2];
+ int n_cbs;
+ struct port_watcher_local_cb local_cbs[2];
+ int n_local_cbs;
+ char local_port_name[OFP_MAX_PORT_NAME_LEN + 1];
+};
+
+/* Returns the number of fields that differ from 'a' to 'b'. */
+static int
+opp_differs(const struct ofp_phy_port *a, const struct ofp_phy_port *b)
+{
+ BUILD_ASSERT_DECL(sizeof *a == 48); /* Trips when we add or remove fields. */
+ return ((a->port_no != b->port_no)
+ + (memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr) != 0)
+ + (memcmp(a->name, b->name, sizeof a->name) != 0)
+ + (a->config != b->config)
+ + (a->state != b->state)
+ + (a->curr != b->curr)
+ + (a->advertised != b->advertised)
+ + (a->supported != b->supported)
+ + (a->peer != b->peer));
+}
+
+static void
+sanitize_opp(struct ofp_phy_port *opp)
+{
+ size_t i;
+
+ for (i = 0; i < sizeof opp->name; i++) {
+ char c = opp->name[i];
+ if (c && (c < 0x20 || c > 0x7e)) {
+ opp->name[i] = '.';
+ }
+ }
+ opp->name[sizeof opp->name - 1] = '\0';
+}
+
+static int
+port_no_to_pw_idx(int port_no)
+{
+ return (port_no < OFPP_MAX ? port_no
+ : port_no == OFPP_LOCAL ? OFPP_MAX
+ : -1);
+}
+
+static void
+call_port_changed_callbacks(struct port_watcher *pw, int port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new)
+{
+ if (opp_differs(old, new)) {
+ int i;
+ for (i = 0; i < pw->n_cbs; i++) {
+ port_changed_cb_func *port_changed = pw->cbs[i].port_changed;
+ (port_changed)(port_no, old, new, pw->cbs[i].aux);
+ }
+ }
+}
+
+static void
+get_port_name(const struct ofp_phy_port *port, char *name, size_t name_size)
+{
+ char *p;
+
+ memcpy(name, port->name, MIN(name_size, sizeof port->name));
+ name[name_size - 1] = '\0';
+ for (p = name; *p != '\0'; p++) {
+ if (*p < 32 || *p > 126) {
+ *p = '.';
+ }
+ }
+}
+
+static void
+call_local_port_changed_callbacks(struct port_watcher *pw)
+{
+ char name[OFP_MAX_PORT_NAME_LEN + 1];
+ const struct ofp_phy_port *port;
+ int i;
+
+ /* Pass the local port to the callbacks, if it exists.
+ Pass a null pointer if there is no local port. */
+ port = &pw->ports[port_no_to_pw_idx(OFPP_LOCAL)];
+ if (port->port_no != htons(OFPP_LOCAL)) {
+ port = NULL;
+ }
+
+ /* Log the name of the local port. */
+ if (port) {
+ get_port_name(port, name, sizeof name);
+ } else {
+ name[0] = '\0';
+ }
+ if (strcmp(pw->local_port_name, name)) {
+ if (name[0]) {
+ VLOG_WARN("Identified data path local port as \"%s\".", name);
+ } else {
+ VLOG_WARN("Data path has no local port.");
+ }
+ strcpy(pw->local_port_name, name);
+ }
+
+ /* Invoke callbacks. */
+ for (i = 0; i < pw->n_local_cbs; i++) {
+ local_port_changed_cb_func *cb = pw->local_cbs[i].local_port_changed;
+ (cb)(port, pw->local_cbs[i].aux);
+ }
+}
+
+static void
+update_phy_port(struct port_watcher *pw, struct ofp_phy_port *opp,
+ uint8_t reason, bool seen[OFPP_MAX + 1])
+{
+ struct ofp_phy_port *pw_opp;
+ struct ofp_phy_port old;
+ uint16_t port_no;
+ int idx;
+
+ port_no = ntohs(opp->port_no);
+ idx = port_no_to_pw_idx(port_no);
+ if (idx < 0) {
+ return;
+ }
+
+ if (seen) {
+ seen[idx] = true;
+ }
+
+ pw_opp = &pw->ports[idx];
+ old = *pw_opp;
+ if (reason == OFPPR_DELETE) {
+ memset(pw_opp, 0, sizeof *pw_opp);
+ pw_opp->port_no = htons(OFPP_NONE);
+ } else if (reason == OFPPR_MODIFY || reason == OFPPR_ADD) {
+ *pw_opp = *opp;
+ sanitize_opp(pw_opp);
+ }
+ call_port_changed_callbacks(pw, port_no, &old, pw_opp);
+}
+
+static bool
+port_watcher_local_packet_cb(struct relay *r, void *pw_)
+{
+ struct port_watcher *pw = pw_;
+ struct ofpbuf *msg = r->halves[HALF_LOCAL].rxbuf;
+ struct ofp_header *oh = msg->data;
+
+ if (oh->type == OFPT_FEATURES_REPLY
+ && msg->size >= offsetof(struct ofp_switch_features, ports)) {
+ struct ofp_switch_features *osf = msg->data;
+ bool seen[ARRAY_SIZE(pw->ports)];
+ size_t n_ports;
+ size_t i;
+
+ pw->got_feature_reply = true;
+
+ /* Update each port included in the message. */
+ memset(seen, 0, sizeof seen);
+ n_ports = ((msg->size - offsetof(struct ofp_switch_features, ports))
+ / sizeof *osf->ports);
+ for (i = 0; i < n_ports; i++) {
+ struct ofp_phy_port *opp = &osf->ports[i];
+ update_phy_port(pw, opp, OFPPR_MODIFY, seen);
+ }
+
+ /* Delete all the ports not included in the message. */
+ for (i = 0; i < ARRAY_SIZE(pw->ports); i++) {
+ if (!seen[i]) {
+ update_phy_port(pw, &pw->ports[i], OFPPR_DELETE, NULL);
+ }
+ }
+
+ call_local_port_changed_callbacks(pw);
+ } else if (oh->type == OFPT_PORT_STATUS
+ && msg->size >= sizeof(struct ofp_port_status)) {
+ struct ofp_port_status *ops = msg->data;
+ update_phy_port(pw, &ops->desc, ops->reason, NULL);
+ if (ops->desc.port_no == htons(OFPP_LOCAL)) {
+ call_local_port_changed_callbacks(pw);
+ }
+ }
+ return false;
+}
+
+static bool
+port_watcher_remote_packet_cb(struct relay *r, void *pw_)
+{
+ struct port_watcher *pw = pw_;
+ struct ofpbuf *msg = r->halves[HALF_REMOTE].rxbuf;
+ struct ofp_header *oh = msg->data;
+
+ if (oh->type == OFPT_PORT_MOD
+ && msg->size >= sizeof(struct ofp_port_mod)) {
+ struct ofp_port_mod *opm = msg->data;
+ uint16_t port_no = ntohs(opm->port_no);
+ int idx = port_no_to_pw_idx(port_no);
+ if (idx >= 0) {
+ struct ofp_phy_port *pw_opp = &pw->ports[idx];
+ if (pw_opp->port_no != htons(OFPP_NONE)) {
+ struct ofp_phy_port old = *pw_opp;
+ pw_opp->config = ((pw_opp->config & ~opm->mask)
+ | (opm->config & opm->mask));
+ call_port_changed_callbacks(pw, port_no, &old, pw_opp);
+ if (pw_opp->port_no == htons(OFPP_LOCAL)) {
+ call_local_port_changed_callbacks(pw);
+ }
+ }
+ }
+ }
+ return false;
+}
+
+static void
+port_watcher_periodic_cb(void *pw_)
+{
+ struct port_watcher *pw = pw_;
+
+ if (!pw->got_feature_reply
+ && time_now() >= pw->last_feature_request + 5
+ && rconn_is_connected(pw->local_rconn)) {
+ struct ofpbuf *b;
+ make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &b);
+ rconn_send_with_limit(pw->local_rconn, b, &pw->n_txq, 1);
+ pw->last_feature_request = time_now();
+ }
+}
+
+static void
+port_watcher_wait_cb(void *pw_)
+{
+ struct port_watcher *pw = pw_;
+ if (!pw->got_feature_reply && rconn_is_connected(pw->local_rconn)) {
+ if (pw->last_feature_request != TIME_MIN) {
+ poll_timer_wait(pw->last_feature_request + 5 - time_now());
+ } else {
+ poll_immediate_wake();
+ }
+ }
+}
+
+static void
+put_duplexes(struct ds *ds, const char *name, uint32_t features,
+ uint32_t hd_bit, uint32_t fd_bit)
+{
+ if (features & (hd_bit | fd_bit)) {
+ ds_put_format(ds, " %s", name);
+ if (features & hd_bit) {
+ ds_put_cstr(ds, "(HD)");
+ }
+ if (features & fd_bit) {
+ ds_put_cstr(ds, "(FD)");
+ }
+ }
+}
+
+static void
+put_features(struct ds *ds, const char *name, uint32_t features)
+{
+ if (features & (OFPPF_10MB_HD | OFPPF_10MB_FD
+ | OFPPF_100MB_HD | OFPPF_100MB_FD
+ | OFPPF_1GB_HD | OFPPF_1GB_FD | OFPPF_10GB_FD)) {
+ ds_put_cstr(ds, name);
+ put_duplexes(ds, "10M", features, OFPPF_10MB_HD, OFPPF_10MB_FD);
+ put_duplexes(ds, "100M", features,
+ OFPPF_100MB_HD, OFPPF_100MB_FD);
+ put_duplexes(ds, "1G", features, OFPPF_100MB_HD, OFPPF_100MB_FD);
+ if (features & OFPPF_10GB_FD) {
+ ds_put_cstr(ds, " 10G");
+ }
+ if (features & OFPPF_AUTONEG) {
+ ds_put_cstr(ds, " AUTO_NEG");
+ }
+ if (features & OFPPF_PAUSE) {
+ ds_put_cstr(ds, " PAUSE");
+ }
+ if (features & OFPPF_PAUSE_ASYM) {
+ ds_put_cstr(ds, " PAUSE_ASYM");
+ }
+ }
+}
+
+static void
+log_port_status(uint16_t port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new,
+ void *aux)
+{
+ if (VLOG_IS_DBG_ENABLED()) {
+ bool was_enabled = old->port_no != htons(OFPP_NONE);
+ bool now_enabled = new->port_no != htons(OFPP_NONE);
+ uint32_t curr = ntohl(new->curr);
+ uint32_t supported = ntohl(new->supported);
+ struct ds ds;
+
+ if (((old->config != new->config) || (old->state != new->state))
+ && opp_differs(old, new) == 1) {
+ /* Don't care if only flags changed. */
+ return;
+ }
+
+ ds_init(&ds);
+ ds_put_format(&ds, "\"%s\", "ETH_ADDR_FMT, new->name,
+ ETH_ADDR_ARGS(new->hw_addr));
+ if (curr) {
+ put_features(&ds, ", current", curr);
+ }
+ if (supported) {
+ put_features(&ds, ", supports", supported);
+ }
+ if (was_enabled != now_enabled) {
+ if (now_enabled) {
+ VLOG_DBG("Port %d added: %s", port_no, ds_cstr(&ds));
+ } else {
+ VLOG_DBG("Port %d deleted", port_no);
+ }
+ } else {
+ VLOG_DBG("Port %d changed: %s", port_no, ds_cstr(&ds));
+ }
+ ds_destroy(&ds);
+ }
+}
+
+static void
+port_watcher_register_callback(struct port_watcher *pw,
+ port_changed_cb_func *port_changed,
+ void *aux)
+{
+ assert(pw->n_cbs < ARRAY_SIZE(pw->cbs));
+ pw->cbs[pw->n_cbs].port_changed = port_changed;
+ pw->cbs[pw->n_cbs].aux = aux;
+ pw->n_cbs++;
+}
+
+static void
+port_watcher_register_local_port_callback(struct port_watcher *pw,
+ local_port_changed_cb_func *cb,
+ void *aux)
+{
+ assert(pw->n_local_cbs < ARRAY_SIZE(pw->local_cbs));
+ pw->local_cbs[pw->n_local_cbs].local_port_changed = cb;
+ pw->local_cbs[pw->n_local_cbs].aux = aux;
+ pw->n_local_cbs++;
+}
+
+static uint32_t
+port_watcher_get_config(const struct port_watcher *pw, int port_no)
+{
+ int idx = port_no_to_pw_idx(port_no);
+ return idx >= 0 ? ntohl(pw->ports[idx].config) : 0;
+}
+
+static void
+port_watcher_set_flags(struct port_watcher *pw, int port_no,
+ uint32_t config, uint32_t c_mask,
+ uint32_t state, uint32_t s_mask)
+{
+ struct ofp_phy_port old;
+ struct ofp_phy_port *p;
+ struct ofp_port_mod *opm;
+ struct ofp_port_status *ops;
+ struct ofpbuf *b;
+ int idx;
+
+ idx = port_no_to_pw_idx(port_no);
+ if (idx < 0) {
+ return;
+ }
+
+ p = &pw->ports[idx];
+ if (!((ntohl(p->state) ^ state) & s_mask)
+ && (!((ntohl(p->config) ^ config) & c_mask))) {
+ return;
+ }
+ old = *p;
+
+ /* Update our idea of the flags. */
+ p->config = htonl((ntohl(p->config) & ~c_mask) | (config & c_mask));
+ p->state = htonl((ntohl(p->state) & ~s_mask) | (state & s_mask));
+ call_port_changed_callbacks(pw, port_no, &old, p);
+
+ /* Change the flags in the datapath. */
+ opm = make_openflow(sizeof *opm, OFPT_PORT_MOD, &b);
+ opm->port_no = p->port_no;
+ memcpy(opm->hw_addr, p->hw_addr, OFP_ETH_ALEN);
+ opm->config = p->config;
+ opm->mask = htonl(c_mask);
+ opm->advertise = htonl(0);
+ rconn_send(pw->local_rconn, b, NULL);
+
+ /* Notify the controller that the flags changed. */
+ ops = make_openflow(sizeof *ops, OFPT_PORT_STATUS, &b);
+ ops->reason = OFPPR_MODIFY;
+ ops->desc = *p;
+ rconn_send(pw->remote_rconn, b, NULL);
+}
+
+static bool
+port_watcher_is_ready(const struct port_watcher *pw)
+{
+ return pw->got_feature_reply;
+}
+
+static struct hook
+port_watcher_create(struct rconn *local_rconn, struct rconn *remote_rconn,
+ struct port_watcher **pwp)
+{
+ struct port_watcher *pw;
+ int i;
+
+ pw = *pwp = xcalloc(1, sizeof *pw);
+ pw->local_rconn = local_rconn;
+ pw->remote_rconn = remote_rconn;
+ pw->last_feature_request = TIME_MIN;
+ for (i = 0; i < OFPP_MAX; i++) {
+ pw->ports[i].port_no = htons(OFPP_NONE);
+ }
+ pw->local_port_name[0] = '\0';
+ port_watcher_register_callback(pw, log_port_status, NULL);
+ return make_hook(port_watcher_local_packet_cb,
+ port_watcher_remote_packet_cb,
+ port_watcher_periodic_cb,
+ port_watcher_wait_cb, pw);
+}
+\f
+/* Spanning tree protocol. */
+
+/* Extra time, in seconds, at boot before going into fail-open, to give the
+ * spanning tree protocol time to figure out the network layout. */
+#define STP_EXTRA_BOOT_TIME 30
+
+struct stp_data {
+ struct stp *stp;
+ struct port_watcher *pw;
+ struct rconn *local_rconn;
+ struct rconn *remote_rconn;
+ long long int last_tick_256ths;
+ int n_txq;
+};
+
+static bool
+stp_local_packet_cb(struct relay *r, void *stp_)
+{
+ struct ofpbuf *msg = r->halves[HALF_LOCAL].rxbuf;
+ struct ofp_header *oh;
+ struct stp_data *stp = stp_;
+ struct ofp_packet_in *opi;
+ struct eth_header *eth;
+ struct llc_header *llc;
+ struct ofpbuf payload;
+ uint16_t port_no;
+ struct flow flow;
+
+ oh = msg->data;
+ if (oh->type == OFPT_FEATURES_REPLY
+ && msg->size >= offsetof(struct ofp_switch_features, ports)) {
+ struct ofp_switch_features *osf = msg->data;
+ osf->capabilities |= htonl(OFPC_STP);
+ return false;
+ }
+
+ if (!get_ofp_packet_eth_header(r, &opi, ð)
+ || !eth_addr_equals(eth->eth_dst, stp_eth_addr)) {
+ return false;
+ }
+
+ port_no = ntohs(opi->in_port);
+ if (port_no >= STP_MAX_PORTS) {
+ /* STP only supports 255 ports. */
+ return false;
+ }
+ if (port_watcher_get_config(stp->pw, port_no) & OFPPC_NO_STP) {
+ /* We're not doing STP on this port. */
+ return false;
+ }
+
+ if (opi->reason == OFPR_ACTION) {
+ /* The controller set up a flow for this, so we won't intercept it. */
+ return false;
+ }
+
+ get_ofp_packet_payload(opi, &payload);
+ flow_extract(&payload, port_no, &flow);
+ if (flow.dl_type != htons(OFP_DL_TYPE_NOT_ETH_TYPE)) {
+ VLOG_DBG("non-LLC frame received on STP multicast address");
+ return false;
+ }
+ llc = ofpbuf_at_assert(&payload, sizeof *eth, sizeof *llc);
+ if (llc->llc_dsap != STP_LLC_DSAP) {
+ VLOG_DBG("bad DSAP 0x%02"PRIx8" received on STP multicast address",
+ llc->llc_dsap);
+ return false;
+ }
+
+ /* Trim off padding on payload. */
+ if (payload.size > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
+ payload.size = ntohs(eth->eth_type) + ETH_HEADER_LEN;
+ }
+ if (ofpbuf_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
+ struct stp_port *p = stp_get_port(stp->stp, port_no);
+ stp_received_bpdu(p, payload.data, payload.size);
+ }
+
+ return true;
+}
+
+static long long int
+time_256ths(void)
+{
+ return time_msec() * 256 / 1000;
+}
+
+static void
+stp_periodic_cb(void *stp_)
+{
+ struct stp_data *stp = stp_;
+ long long int now_256ths = time_256ths();
+ long long int elapsed_256ths = now_256ths - stp->last_tick_256ths;
+ struct stp_port *p;
+
+ if (!port_watcher_is_ready(stp->pw)) {
+ /* Can't start STP until we know port flags, because port flags can
+ * disable STP. */
+ return;
+ }
+ if (elapsed_256ths <= 0) {
+ return;
+ }
+
+ stp_tick(stp->stp, MIN(INT_MAX, elapsed_256ths));
+ stp->last_tick_256ths = now_256ths;
+
+ while (stp_get_changed_port(stp->stp, &p)) {
+ int port_no = stp_port_no(p);
+ enum stp_state s_state = stp_port_get_state(p);
+
+ if (s_state != STP_DISABLED) {
+ VLOG_WARN("STP: Port %d entered %s state",
+ port_no, stp_state_name(s_state));
+ }
+ if (!(port_watcher_get_config(stp->pw, port_no) & OFPPC_NO_STP)) {
+ uint32_t p_config = 0;
+ uint32_t p_state;
+ switch (s_state) {
+ case STP_LISTENING:
+ p_state = OFPPS_STP_LISTEN;
+ break;
+ case STP_LEARNING:
+ p_state = OFPPS_STP_LEARN;
+ break;
+ case STP_DISABLED:
+ case STP_FORWARDING:
+ p_state = OFPPS_STP_FORWARD;
+ break;
+ case STP_BLOCKING:
+ p_state = OFPPS_STP_BLOCK;
+ break;
+ default:
+ VLOG_DBG_RL(&vrl, "STP: Port %d has bad state %x",
+ port_no, s_state);
+ p_state = OFPPS_STP_FORWARD;
+ break;
+ }
+ if (!stp_forward_in_state(s_state)) {
+ p_config = OFPPC_NO_FLOOD;
+ }
+ port_watcher_set_flags(stp->pw, port_no,
+ p_config, OFPPC_NO_FLOOD,
+ p_state, OFPPS_STP_MASK);
+ } else {
+ /* We don't own those flags. */
+ }
+ }
+}
+
+static void
+stp_wait_cb(void *stp_ UNUSED)
+{
+ poll_timer_wait(1000);
+}
+
+static void
+send_bpdu(const void *bpdu, size_t bpdu_size, int port_no, void *stp_)
+{
+ struct stp_data *stp = stp_;
+ struct eth_header *eth;
+ struct llc_header *llc;
+ struct ofpbuf pkt, *opo;
+
+ /* Packet skeleton. */
+ ofpbuf_init(&pkt, ETH_HEADER_LEN + LLC_HEADER_LEN + bpdu_size);
+ eth = ofpbuf_put_uninit(&pkt, sizeof *eth);
+ llc = ofpbuf_put_uninit(&pkt, sizeof *llc);
+ ofpbuf_put(&pkt, bpdu, bpdu_size);
+
+ /* 802.2 header. */
+ memcpy(eth->eth_dst, stp_eth_addr, ETH_ADDR_LEN);
+ memcpy(eth->eth_src, stp->pw->ports[port_no].hw_addr, ETH_ADDR_LEN);
+ eth->eth_type = htons(pkt.size - ETH_HEADER_LEN);
+
+ /* LLC header. */
+ llc->llc_dsap = STP_LLC_DSAP;
+ llc->llc_ssap = STP_LLC_SSAP;
+ llc->llc_cntl = STP_LLC_CNTL;
+
+ opo = make_unbuffered_packet_out(&pkt, OFPP_NONE, port_no);
+ ofpbuf_uninit(&pkt);
+ rconn_send_with_limit(stp->local_rconn, opo, &stp->n_txq, OFPP_MAX);
+}
+
+static bool
+stp_is_port_supported(uint16_t port_no)
+{
+ /* We should be able to support STP on all possible OpenFlow physical
+ * ports. (But we don't support STP on OFPP_LOCAL.) */
+ BUILD_ASSERT_DECL(STP_MAX_PORTS >= OFPP_MAX);
+ return port_no < STP_MAX_PORTS;
+}
+
+static void
+stp_port_changed_cb(uint16_t port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new,
+ void *stp_)
+{
+ struct stp_data *stp = stp_;
+ struct stp_port *p;
+
+ if (!stp_is_port_supported(port_no)) {
+ return;
+ }
+
+ p = stp_get_port(stp->stp, port_no);
+ if (new->port_no == htons(OFPP_NONE)
+ || new->config & htonl(OFPPC_NO_STP | OFPPC_PORT_DOWN)
+ || new->state & htonl(OFPPS_LINK_DOWN)) {
+ stp_port_disable(p);
+ } else {
+ int speed = 0;
+ stp_port_enable(p);
+ if (new->curr & (OFPPF_10MB_HD | OFPPF_10MB_FD)) {
+ speed = 10;
+ } else if (new->curr & (OFPPF_100MB_HD | OFPPF_100MB_FD)) {
+ speed = 100;
+ } else if (new->curr & (OFPPF_1GB_HD | OFPPF_1GB_FD)) {
+ speed = 1000;
+ } else if (new->curr & OFPPF_100MB_FD) {
+ speed = 10000;
+ }
+ stp_port_set_speed(p, speed);
+ }
+}
+
+static void
+stp_local_port_changed_cb(const struct ofp_phy_port *port, void *stp_)
+{
+ struct stp_data *stp = stp_;
+ if (port) {
+ stp_set_bridge_id(stp->stp, eth_addr_to_uint64(port->hw_addr));
+ }
+}
+
+static struct hook
+stp_hook_create(const struct settings *s, struct port_watcher *pw,
+ struct rconn *local, struct rconn *remote)
+{
+ uint8_t dpid[ETH_ADDR_LEN];
+ struct stp_data *stp;
+
+ stp = xcalloc(1, sizeof *stp);
+ eth_addr_random(dpid);
+ stp->stp = stp_create("stp", eth_addr_to_uint64(dpid), send_bpdu, stp);
+ stp->pw = pw;
+ stp->local_rconn = local;
+ stp->remote_rconn = remote;
+ stp->last_tick_256ths = time_256ths();
+
+ port_watcher_register_callback(pw, stp_port_changed_cb, stp);
+ port_watcher_register_local_port_callback(pw, stp_local_port_changed_cb,
+ stp);
+ return make_hook(stp_local_packet_cb, NULL,
+ stp_periodic_cb, stp_wait_cb, stp);
+}
+\f