#include <limits.h>
#include <stdlib.h>
#include <string.h>
-#include "buffer.h"
-#include "openflow.h"
+#include "ofpbuf.h"
+#include "openflow/openflow.h"
#include "poll-loop.h"
-#include "ofp-print.h"
#include "sat-math.h"
#include "timeval.h"
#include "util.h"
char *name;
bool reliable;
- struct queue txq;
+ struct ofp_queue txq;
int backoff;
int max_backoff;
time_t last_connected;
unsigned int packets_sent;
+ /* In S_ACTIVE and S_IDLE, probably_admitted reports whether we believe
+ * that the peer has made a (positive) admission control decision on our
+ * connection. If we have not yet been (probably) admitted, then the
+ * connection does not reset the timer used for deciding whether the switch
+ * should go into fail-open mode.
+ *
+ * last_admitted reports the last time we believe such a positive admission
+ * control decision was made. */
+ bool probably_admitted;
+ time_t last_admitted;
+
/* These values are simply for statistics reporting, not used directly by
* anything internal to the rconn (or the secchan for that matter). */
unsigned int packets_received;
static void disconnect(struct rconn *, int error);
static void flush_queue(struct rconn *);
static void question_connectivity(struct rconn *);
-static void copy_to_monitor(struct rconn *, const struct buffer *);
+static void copy_to_monitor(struct rconn *, const struct ofpbuf *);
+static bool is_connected_state(enum state);
+static bool is_admitted_msg(const struct ofpbuf *);
/* Creates a new rconn, connects it (reliably) to 'name', and returns it. */
struct rconn *
rc->packets_sent = 0;
+ rc->probably_admitted = false;
+ rc->last_admitted = time_now();
+
rc->packets_received = 0;
rc->n_attempted_connections = 0;
rc->n_successful_connections = 0;
void
rconn_disconnect(struct rconn *rc)
{
- if (rc->vconn) {
- vconn_close(rc->vconn);
- rc->vconn = NULL;
- }
- free(rc->name);
- rc->name = xstrdup("void");
- rc->reliable = false;
+ if (rc->state != S_VOID) {
+ if (rc->vconn) {
+ vconn_close(rc->vconn);
+ rc->vconn = NULL;
+ }
+ free(rc->name);
+ rc->name = xstrdup("void");
+ rc->reliable = false;
- rc->backoff = 0;
- rc->backoff_deadline = TIME_MIN;
+ rc->backoff = 0;
+ rc->backoff_deadline = TIME_MIN;
- state_transition(rc, S_VOID);
+ state_transition(rc, S_VOID);
+ }
}
/* Disconnects 'rc' and frees the underlying storage. */
rconn_destroy(struct rconn *rc)
{
if (rc) {
+ size_t i;
+
free(rc->name);
vconn_close(rc->vconn);
flush_queue(rc);
queue_destroy(&rc->txq);
+ for (i = 0; i < rc->n_monitors; i++) {
+ vconn_close(rc->monitors[i]);
+ }
free(rc);
}
}
state_transition(rc, S_CONNECTING);
} else {
VLOG_WARN("%s: connection failed (%s)", rc->name, strerror(retval));
+ rc->backoff_deadline = TIME_MAX; /* Prevent resetting backoff. */
disconnect(rc, 0);
}
return retval;
/* Attempts to receive a packet from 'rc'. If successful, returns the packet;
* otherwise, returns a null pointer. The caller is responsible for freeing
- * the packet (with buffer_delete()). */
-struct buffer *
+ * the packet (with ofpbuf_delete()). */
+struct ofpbuf *
rconn_recv(struct rconn *rc)
{
if (rc->state & (S_ACTIVE | S_IDLE)) {
- struct buffer *buffer;
+ struct ofpbuf *buffer;
int error = vconn_recv(rc->vconn, &buffer);
if (!error) {
copy_to_monitor(rc, buffer);
+ if (is_admitted_msg(buffer)
+ || time_now() - rc->last_connected >= 30) {
+ rc->probably_admitted = true;
+ rc->last_admitted = time_now();
+ }
rc->last_received = time_now();
rc->packets_received++;
if (rc->state == S_IDLE) {
* takes care of sending if you call rconn_run(), which will have the side
* effect of waking up poll_block(). */
int
-rconn_send(struct rconn *rc, struct buffer *b, int *n_queued)
+rconn_send(struct rconn *rc, struct ofpbuf *b, int *n_queued)
{
if (rconn_is_connected(rc)) {
copy_to_monitor(rc, b);
* takes care of sending if you call rconn_run(), which will have the side
* effect of waking up poll_block(). */
int
-rconn_send_with_limit(struct rconn *rc, struct buffer *b,
+rconn_send_with_limit(struct rconn *rc, struct ofpbuf *b,
int *n_queued, int queue_limit)
{
int retval;
retval = *n_queued >= queue_limit ? EAGAIN : rconn_send(rc, b, n_queued);
if (retval) {
- buffer_delete(b);
+ ofpbuf_delete(b);
}
return retval;
}
bool
rconn_is_connected(const struct rconn *rconn)
{
- return rconn->state & (S_ACTIVE | S_IDLE);
+ return is_connected_state(rconn->state);
}
-/* Returns 0 if 'rconn' is connected, otherwise the number of seconds that it
- * has been disconnected. */
+/* Returns 0 if 'rconn' is connected. Otherwise, if 'rconn' is in a "failure
+ * mode" (that is, it is not connected), returns the number of seconds that it
+ * has been in failure mode, ignoring any times that it connected but the
+ * controller's admission control policy caused it to be quickly
+ * disconnected. */
int
-rconn_disconnected_duration(const struct rconn *rconn)
+rconn_failure_duration(const struct rconn *rconn)
{
- return rconn_is_connected(rconn) ? 0 : time_now() - rconn->last_received;
+ return rconn_is_connected(rconn) ? 0 : time_now() - rconn->last_admitted;
}
/* Returns the IP address of the peer, or 0 if the peer is not connected over
try_send(struct rconn *rc)
{
int retval = 0;
- struct buffer *next = rc->txq.head->next;
+ struct ofpbuf *next = rc->txq.head->next;
int *n_queued = rc->txq.head->private;
retval = vconn_send(rc->vconn, rc->txq.head);
if (retval) {
rc->name, strerror(error));
} else if (error == EOF) {
if (rc->reliable) {
- VLOG_WARN("%s: connection closed", rc->name);
+ VLOG_WARN("%s: connection closed by peer", rc->name);
}
} else {
VLOG_WARN("%s: connection dropped", rc->name);
return;
}
while (rc->txq.n > 0) {
- struct buffer *b = queue_pop_head(&rc->txq);
+ struct ofpbuf *b = queue_pop_head(&rc->txq);
int *n_queued = b->private;
if (n_queued) {
--*n_queued;
}
- buffer_delete(b);
+ ofpbuf_delete(b);
}
poll_immediate_wake();
}
static void
state_transition(struct rconn *rc, enum state state)
{
+ if (is_connected_state(state) && !is_connected_state(rc->state)) {
+ rc->probably_admitted = false;
+ }
if (rconn_is_connected(rc)) {
rc->total_time_connected += elapsed_in_this_state(rc);
}
}
static void
-copy_to_monitor(struct rconn *rc, const struct buffer *b)
+copy_to_monitor(struct rconn *rc, const struct ofpbuf *b)
{
- struct buffer *clone = NULL;
+ struct ofpbuf *clone = NULL;
int retval;
size_t i;
struct vconn *vconn = rc->monitors[i];
if (!clone) {
- clone = buffer_clone(b);
+ clone = ofpbuf_clone(b);
}
retval = vconn_send(vconn, clone);
if (!retval) {
}
i++;
}
- buffer_delete(clone);
+ ofpbuf_delete(clone);
+}
+
+static bool
+is_connected_state(enum state state)
+{
+ return (state & (S_ACTIVE | S_IDLE)) != 0;
+}
+
+static bool
+is_admitted_msg(const struct ofpbuf *b)
+{
+ struct ofp_header *oh = b->data;
+ uint8_t type = oh->type;
+ return !(type < 32
+ && (1u << type) & ((1u << OFPT_HELLO) |
+ (1u << OFPT_ERROR) |
+ (1u << OFPT_ECHO_REQUEST) |
+ (1u << OFPT_ECHO_REPLY) |
+ (1u << OFPT_VENDOR) |
+ (1u << OFPT_FEATURES_REQUEST) |
+ (1u << OFPT_FEATURES_REPLY) |
+ (1u << OFPT_GET_CONFIG_REQUEST) |
+ (1u << OFPT_GET_CONFIG_REPLY) |
+ (1u << OFPT_SET_CONFIG)));
}