/*
- * Copyright (c) 2008, 2009 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <string.h>
#include "coverage.h"
#include "dynamic-string.h"
+#include "fatal-signal.h"
#include "flow.h"
#include "ofp-print.h"
+#include "ofp-util.h"
#include "ofpbuf.h"
#include "openflow/nicira-ext.h"
#include "openflow/openflow.h"
#include "poll-loop.h"
#include "random.h"
#include "util.h"
-
-#define THIS_MODULE VLM_vconn
#include "vlog.h"
+VLOG_DEFINE_THIS_MODULE(vconn)
+
/* State of an active vconn.*/
enum vconn_state {
/* This is the ordinary progression of states. */
struct vconn_class *class = vconn_classes[i];
assert(class->name != NULL);
assert(class->open != NULL);
- if (class->close || class->recv || class->send || class->wait) {
+ if (class->close || class->recv || class->send
+ || class->run || class->run_wait || class->wait) {
assert(class->close != NULL);
assert(class->recv != NULL);
assert(class->send != NULL);
* connection methods supported by the vconn. If 'bootstrap' is true, also
* advertises options to bootstrap the CA certificate. */
void
-vconn_usage(bool active, bool passive, bool bootstrap UNUSED)
+vconn_usage(bool active, bool passive, bool bootstrap OVS_UNUSED)
{
/* Really this should be implemented via callbacks into the vconn
* providers, but that seems too heavy-weight to bother with at the
* moment. */
-
+
printf("\n");
if (active) {
printf("Active OpenFlow connection methods:\n");
if (passive) {
printf("Passive OpenFlow connection methods:\n");
- printf(" ptcp:[PORT] "
- "listen to TCP PORT (default: %d)\n",
+ printf(" ptcp:[PORT][:IP] "
+ "listen to TCP PORT (default: %d) on IP\n",
OFP_TCP_PORT);
#ifdef HAVE_OPENSSL
- printf(" pssl:[PORT] "
- "listen for SSL on PORT (default: %d)\n",
+ printf(" pssl:[PORT][:IP] "
+ "listen for SSL on PORT (default: %d) on IP\n",
OFP_SSL_PORT);
#endif
printf(" punix:FILE "
#endif
}
+/* Given 'name', a connection name in the form "TYPE:ARGS", stores the class
+ * named "TYPE" into '*classp' and returns 0. Returns EAFNOSUPPORT and stores
+ * a null pointer into '*classp' if 'name' is in the wrong form or if no such
+ * class exists. */
+static int
+vconn_lookup_class(const char *name, struct vconn_class **classp)
+{
+ size_t prefix_len;
+
+ prefix_len = strcspn(name, ":");
+ if (name[prefix_len] != '\0') {
+ size_t i;
+
+ for (i = 0; i < ARRAY_SIZE(vconn_classes); i++) {
+ struct vconn_class *class = vconn_classes[i];
+ if (strlen(class->name) == prefix_len
+ && !memcmp(class->name, name, prefix_len)) {
+ *classp = class;
+ return 0;
+ }
+ }
+ }
+
+ *classp = NULL;
+ return EAFNOSUPPORT;
+}
+
+/* Returns 0 if 'name' is a connection name in the form "TYPE:ARGS" and TYPE is
+ * a supported connection type, otherwise EAFNOSUPPORT. */
+int
+vconn_verify_name(const char *name)
+{
+ struct vconn_class *class;
+ return vconn_lookup_class(name, &class);
+}
+
/* Attempts to connect to an OpenFlow device. 'name' is a connection name in
* the form "TYPE:ARGS", where TYPE is an active vconn class's name and ARGS
* are vconn class-specific.
int
vconn_open(const char *name, int min_version, struct vconn **vconnp)
{
- size_t prefix_len;
- size_t i;
+ struct vconn_class *class;
+ struct vconn *vconn;
+ char *suffix_copy;
+ int error;
COVERAGE_INC(vconn_open);
check_vconn_classes();
+ /* Look up the class. */
+ error = vconn_lookup_class(name, &class);
+ if (!class) {
+ goto error;
+ }
+
+ /* Call class's "open" function. */
+ suffix_copy = xstrdup(strchr(name, ':') + 1);
+ error = class->open(name, suffix_copy, &vconn);
+ free(suffix_copy);
+ if (error) {
+ goto error;
+ }
+
+ /* Success. */
+ assert(vconn->state != VCS_CONNECTING || vconn->class->connect);
+ vconn->min_version = min_version;
+ *vconnp = vconn;
+ return 0;
+
+error:
*vconnp = NULL;
- prefix_len = strcspn(name, ":");
- if (prefix_len == strlen(name)) {
- return EAFNOSUPPORT;
+ return error;
+}
+
+/* Allows 'vconn' to perform maintenance activities, such as flushing output
+ * buffers. */
+void
+vconn_run(struct vconn *vconn)
+{
+ if (vconn->class->run) {
+ (vconn->class->run)(vconn);
}
- for (i = 0; i < ARRAY_SIZE(vconn_classes); i++) {
- struct vconn_class *class = vconn_classes[i];
- if (strlen(class->name) == prefix_len
- && !memcmp(class->name, name, prefix_len)) {
- struct vconn *vconn;
- char *suffix_copy = xstrdup(name + prefix_len + 1);
- int retval = class->open(name, suffix_copy, &vconn);
- free(suffix_copy);
- if (!retval) {
- assert(vconn->state != VCS_CONNECTING
- || vconn->class->connect);
- vconn->min_version = min_version;
- *vconnp = vconn;
- }
- return retval;
- }
+}
+
+/* Arranges for the poll loop to wake up when 'vconn' needs to perform
+ * maintenance activities. */
+void
+vconn_run_wait(struct vconn *vconn)
+{
+ if (vconn->class->run_wait) {
+ (vconn->class->run_wait)(vconn);
}
- return EAFNOSUPPORT;
}
int
struct vconn *vconn;
int error;
+ fatal_signal_run();
+
error = vconn_open(name, min_version, &vconn);
- while (error == EAGAIN) {
- vconn_connect_wait(vconn);
- poll_block();
- error = vconn_connect(vconn);
+ if (!error) {
+ while ((error == vconn_connect(vconn)) == EAGAIN) {
+ vconn_run(vconn);
+ vconn_run_wait(vconn);
+ vconn_connect_wait(vconn);
+ poll_block();
+ }
assert(error != EINPROGRESS);
}
+
if (error) {
vconn_close(vconn);
*vconnp = NULL;
/* Returns the IP address of the peer, or 0 if the peer is not connected over
* an IP-based protocol or if its IP address is not yet known. */
uint32_t
-vconn_get_remote_ip(const struct vconn *vconn)
+vconn_get_remote_ip(const struct vconn *vconn)
{
return vconn->remote_ip;
}
-/* Returns the transport port of the peer, or 0 if the connection does not
+/* Returns the transport port of the peer, or 0 if the connection does not
* contain a port or if the port is not yet known. */
uint16_t
-vconn_get_remote_port(const struct vconn *vconn)
+vconn_get_remote_port(const struct vconn *vconn)
{
return vconn->remote_port;
}
-/* Returns the IP address used to connect to the peer, or 0 if the
- * connection is not an IP-based protocol or if its IP address is not
+/* Returns the IP address used to connect to the peer, or 0 if the
+ * connection is not an IP-based protocol or if its IP address is not
* yet known. */
uint32_t
-vconn_get_local_ip(const struct vconn *vconn)
+vconn_get_local_ip(const struct vconn *vconn)
{
return vconn->local_ip;
}
-/* Returns the transport port used to connect to the peer, or 0 if the
+/* Returns the transport port used to connect to the peer, or 0 if the
* connection does not contain a port or if the port is not yet known. */
uint16_t
-vconn_get_local_port(const struct vconn *vconn)
+vconn_get_local_port(const struct vconn *vconn)
{
return vconn->local_port;
}
static void
-vcs_connecting(struct vconn *vconn)
+vcs_connecting(struct vconn *vconn)
{
int retval = (vconn->class->connect)(vconn);
assert(retval != EINPROGRESS);
if (retval != EAGAIN) {
vconn->state = VCS_DISCONNECTED;
- vconn->error = retval;
+ vconn->error = retval == EOF ? ECONNRESET : retval;
}
}
}
}
-/* Tries to complete the connection on 'vconn', which must be an active
- * vconn. If 'vconn''s connection is complete, returns 0 if the connection
- * was successful or a positive errno value if it failed. If the
- * connection is still in progress, returns EAGAIN. */
+/* Tries to complete the connection on 'vconn'. If 'vconn''s connection is
+ * complete, returns 0 if the connection was successful or a positive errno
+ * value if it failed. If the connection is still in progress, returns
+ * EAGAIN. */
int
vconn_connect(struct vconn *vconn)
{
return EAGAIN;
}
-/* Tries to receive an OpenFlow message from 'vconn', which must be an active
- * vconn. If successful, stores the received message into '*msgp' and returns
- * 0. The caller is responsible for destroying the message with
- * ofpbuf_delete(). On failure, returns a positive errno value and stores a
- * null pointer into '*msgp'. On normal connection close, returns EOF.
+/* Tries to receive an OpenFlow message from 'vconn'. If successful, stores
+ * the received message into '*msgp' and returns 0. The caller is responsible
+ * for destroying the message with ofpbuf_delete(). On failure, returns a
+ * positive errno value and stores a null pointer into '*msgp'. On normal
+ * connection close, returns EOF.
*
* vconn_recv will not block waiting for a packet to arrive. If no packets
* have been received, it returns EAGAIN immediately. */
static int
do_recv(struct vconn *vconn, struct ofpbuf **msgp)
{
- int retval;
-
-again:
- retval = (vconn->class->recv)(vconn, msgp);
+ int retval = (vconn->class->recv)(vconn, msgp);
if (!retval) {
struct ofp_header *oh;
&& oh->type != OFPT_VENDOR)
{
if (vconn->version < 0) {
- if (oh->type == OFPT_PACKET_IN
- || oh->type == OFPT_FLOW_EXPIRED
- || oh->type == OFPT_PORT_STATUS) {
- /* The kernel datapath is stateless and doesn't really
- * support version negotiation, so it can end up sending
- * these asynchronous message before version negotiation
- * is complete. Just ignore them.
- *
- * (After we move OFPT_PORT_STATUS messages from the kernel
- * into secchan, we won't get those here, since secchan
- * does proper version negotiation.) */
- ofpbuf_delete(*msgp);
- goto again;
- }
VLOG_ERR_RL(&bad_ofmsg_rl,
"%s: received OpenFlow message type %"PRIu8" "
"before version negotiation complete",
return retval;
}
-/* Tries to queue 'msg' for transmission on 'vconn', which must be an active
- * vconn. If successful, returns 0, in which case ownership of 'msg' is
- * transferred to the vconn. Success does not guarantee that 'msg' has been or
- * ever will be delivered to the peer, only that it has been queued for
- * transmission.
+/* Tries to queue 'msg' for transmission on 'vconn'. If successful, returns 0,
+ * in which case ownership of 'msg' is transferred to the vconn. Success does
+ * not guarantee that 'msg' has been or ever will be delivered to the peer,
+ * only that it has been queued for transmission.
*
* Returns a positive errno value on failure, in which case the caller
* retains ownership of 'msg'.
vconn_send_block(struct vconn *vconn, struct ofpbuf *msg)
{
int retval;
+
+ fatal_signal_run();
+
while ((retval = vconn_send(vconn, msg)) == EAGAIN) {
+ vconn_run(vconn);
+ vconn_run_wait(vconn);
vconn_send_wait(vconn);
poll_block();
}
vconn_recv_block(struct vconn *vconn, struct ofpbuf **msgp)
{
int retval;
+
+ fatal_signal_run();
+
while ((retval = vconn_recv(vconn, msgp)) == EAGAIN) {
+ vconn_run(vconn);
+ vconn_run_wait(vconn);
vconn_recv_wait(vconn);
poll_block();
}
vconn_wait(vconn, WAIT_SEND);
}
+/* Given 'name', a connection name in the form "TYPE:ARGS", stores the class
+ * named "TYPE" into '*classp' and returns 0. Returns EAFNOSUPPORT and stores
+ * a null pointer into '*classp' if 'name' is in the wrong form or if no such
+ * class exists. */
+static int
+pvconn_lookup_class(const char *name, struct pvconn_class **classp)
+{
+ size_t prefix_len;
+
+ prefix_len = strcspn(name, ":");
+ if (name[prefix_len] != '\0') {
+ size_t i;
+
+ for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
+ struct pvconn_class *class = pvconn_classes[i];
+ if (strlen(class->name) == prefix_len
+ && !memcmp(class->name, name, prefix_len)) {
+ *classp = class;
+ return 0;
+ }
+ }
+ }
+
+ *classp = NULL;
+ return EAFNOSUPPORT;
+}
+
+/* Returns 0 if 'name' is a connection name in the form "TYPE:ARGS" and TYPE is
+ * a supported connection type, otherwise EAFNOSUPPORT. */
+int
+pvconn_verify_name(const char *name)
+{
+ struct pvconn_class *class;
+ return pvconn_lookup_class(name, &class);
+}
+
/* Attempts to start listening for OpenFlow connections. 'name' is a
* connection name in the form "TYPE:ARGS", where TYPE is an passive vconn
* class's name and ARGS are vconn class-specific.
int
pvconn_open(const char *name, struct pvconn **pvconnp)
{
- size_t prefix_len;
- size_t i;
+ struct pvconn_class *class;
+ struct pvconn *pvconn;
+ char *suffix_copy;
+ int error;
check_vconn_classes();
- *pvconnp = NULL;
- prefix_len = strcspn(name, ":");
- if (prefix_len == strlen(name)) {
- return EAFNOSUPPORT;
+ /* Look up the class. */
+ error = pvconn_lookup_class(name, &class);
+ if (!class) {
+ goto error;
}
- for (i = 0; i < ARRAY_SIZE(pvconn_classes); i++) {
- struct pvconn_class *class = pvconn_classes[i];
- if (strlen(class->name) == prefix_len
- && !memcmp(class->name, name, prefix_len)) {
- char *suffix_copy = xstrdup(name + prefix_len + 1);
- int retval = class->listen(name, suffix_copy, pvconnp);
- free(suffix_copy);
- if (retval) {
- *pvconnp = NULL;
- }
- return retval;
- }
+
+ /* Call class's "open" function. */
+ suffix_copy = xstrdup(strchr(name, ':') + 1);
+ error = class->listen(name, suffix_copy, &pvconn);
+ free(suffix_copy);
+ if (error) {
+ goto error;
}
- return EAFNOSUPPORT;
+
+ /* Success. */
+ *pvconnp = pvconn;
+ return 0;
+
+error:
+ *pvconnp = NULL;
+ return error;
}
/* Returns the name that was used to open 'pvconn'. The caller must not
(pvconn->class->wait)(pvconn);
}
-/* XXX we should really use consecutive xids to avoid probabilistic
- * failures. */
-static inline uint32_t
-alloc_xid(void)
-{
- return random_uint32();
-}
-
-/* Allocates and stores in '*bufferp' a new ofpbuf with a size of
- * 'openflow_len', starting with an OpenFlow header with the given 'type' and
- * an arbitrary transaction id. Allocated bytes beyond the header, if any, are
- * zeroed.
- *
- * The caller is responsible for freeing '*bufferp' when it is no longer
- * needed.
- *
- * The OpenFlow header length is initially set to 'openflow_len'; if the
- * message is later extended, the length should be updated with
- * update_openflow_length() before sending.
- *
- * Returns the header. */
-void *
-make_openflow(size_t openflow_len, uint8_t type, struct ofpbuf **bufferp)
-{
- *bufferp = ofpbuf_new(openflow_len);
- return put_openflow_xid(openflow_len, type, alloc_xid(), *bufferp);
-}
-
-/* Allocates and stores in '*bufferp' a new ofpbuf with a size of
- * 'openflow_len', starting with an OpenFlow header with the given 'type' and
- * transaction id 'xid'. Allocated bytes beyond the header, if any, are
- * zeroed.
+/* Initializes 'vconn' as a new vconn named 'name', implemented via 'class'.
+ * The initial connection status, supplied as 'connect_status', is interpreted
+ * as follows:
*
- * The caller is responsible for freeing '*bufferp' when it is no longer
- * needed.
+ * - 0: 'vconn' is connected. Its 'send' and 'recv' functions may be
+ * called in the normal fashion.
*
- * The OpenFlow header length is initially set to 'openflow_len'; if the
- * message is later extended, the length should be updated with
- * update_openflow_length() before sending.
+ * - EAGAIN: 'vconn' is trying to complete a connection. Its 'connect'
+ * function should be called to complete the connection.
*
- * Returns the header. */
-void *
-make_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
- struct ofpbuf **bufferp)
-{
- *bufferp = ofpbuf_new(openflow_len);
- return put_openflow_xid(openflow_len, type, xid, *bufferp);
-}
-
-/* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
- * with the given 'type' and an arbitrary transaction id. Allocated bytes
- * beyond the header, if any, are zeroed.
- *
- * The OpenFlow header length is initially set to 'openflow_len'; if the
- * message is later extended, the length should be updated with
- * update_openflow_length() before sending.
- *
- * Returns the header. */
-void *
-put_openflow(size_t openflow_len, uint8_t type, struct ofpbuf *buffer)
-{
- return put_openflow_xid(openflow_len, type, alloc_xid(), buffer);
-}
-
-/* Appends 'openflow_len' bytes to 'buffer', starting with an OpenFlow header
- * with the given 'type' and an transaction id 'xid'. Allocated bytes beyond
- * the header, if any, are zeroed.
+ * - Other positive errno values indicate that the connection failed with
+ * the specified error.
*
- * The OpenFlow header length is initially set to 'openflow_len'; if the
- * message is later extended, the length should be updated with
- * update_openflow_length() before sending.
+ * After calling this function, vconn_close() must be used to destroy 'vconn',
+ * otherwise resources will be leaked.
*
- * Returns the header. */
-void *
-put_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
- struct ofpbuf *buffer)
-{
- struct ofp_header *oh;
-
- assert(openflow_len >= sizeof *oh);
- assert(openflow_len <= UINT16_MAX);
-
- oh = ofpbuf_put_uninit(buffer, openflow_len);
- oh->version = OFP_VERSION;
- oh->type = type;
- oh->length = htons(openflow_len);
- oh->xid = xid;
- memset(oh + 1, 0, openflow_len - sizeof *oh);
- return oh;
-}
-
-/* Updates the 'length' field of the OpenFlow message in 'buffer' to
- * 'buffer->size'. */
-void
-update_openflow_length(struct ofpbuf *buffer)
-{
- struct ofp_header *oh = ofpbuf_at_assert(buffer, 0, sizeof *oh);
- oh->length = htons(buffer->size);
-}
-
-struct ofpbuf *
-make_flow_mod(uint16_t command, const flow_t *flow, size_t actions_len)
-{
- struct ofp_flow_mod *ofm;
- size_t size = sizeof *ofm + actions_len;
- struct ofpbuf *out = ofpbuf_new(size);
- ofm = ofpbuf_put_zeros(out, sizeof *ofm);
- ofm->header.version = OFP_VERSION;
- ofm->header.type = OFPT_FLOW_MOD;
- ofm->header.length = htons(size);
- ofm->match.wildcards = htonl(0);
- ofm->match.in_port = htons(flow->in_port == ODPP_LOCAL ? OFPP_LOCAL
- : flow->in_port);
- memcpy(ofm->match.dl_src, flow->dl_src, sizeof ofm->match.dl_src);
- memcpy(ofm->match.dl_dst, flow->dl_dst, sizeof ofm->match.dl_dst);
- ofm->match.dl_vlan = flow->dl_vlan;
- ofm->match.dl_type = flow->dl_type;
- ofm->match.nw_src = flow->nw_src;
- ofm->match.nw_dst = flow->nw_dst;
- ofm->match.nw_proto = flow->nw_proto;
- ofm->match.tp_src = flow->tp_src;
- ofm->match.tp_dst = flow->tp_dst;
- ofm->command = htons(command);
- return out;
-}
-
-struct ofpbuf *
-make_add_flow(const flow_t *flow, uint32_t buffer_id,
- uint16_t idle_timeout, size_t actions_len)
-{
- struct ofpbuf *out = make_flow_mod(OFPFC_ADD, flow, actions_len);
- struct ofp_flow_mod *ofm = out->data;
- ofm->idle_timeout = htons(idle_timeout);
- ofm->hard_timeout = htons(OFP_FLOW_PERMANENT);
- ofm->buffer_id = htonl(buffer_id);
- return out;
-}
-
-struct ofpbuf *
-make_del_flow(const flow_t *flow)
-{
- struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, flow, 0);
- struct ofp_flow_mod *ofm = out->data;
- ofm->out_port = htons(OFPP_NONE);
- return out;
-}
-
-struct ofpbuf *
-make_add_simple_flow(const flow_t *flow,
- uint32_t buffer_id, uint16_t out_port,
- uint16_t idle_timeout)
-{
- struct ofp_action_output *oao;
- struct ofpbuf *buffer = make_add_flow(flow, buffer_id, idle_timeout,
- sizeof *oao);
- oao = ofpbuf_put_zeros(buffer, sizeof *oao);
- oao->type = htons(OFPAT_OUTPUT);
- oao->len = htons(sizeof *oao);
- oao->port = htons(out_port);
- return buffer;
-}
-
-struct ofpbuf *
-make_packet_in(uint32_t buffer_id, uint16_t in_port, uint8_t reason,
- const struct ofpbuf *payload, int max_send_len)
-{
- struct ofp_packet_in *opi;
- struct ofpbuf *buf;
- int send_len;
-
- send_len = MIN(max_send_len, payload->size);
- buf = ofpbuf_new(sizeof *opi + send_len);
- opi = put_openflow_xid(offsetof(struct ofp_packet_in, data),
- OFPT_PACKET_IN, 0, buf);
- opi->buffer_id = htonl(buffer_id);
- opi->total_len = htons(payload->size);
- opi->in_port = htons(in_port);
- opi->reason = reason;
- ofpbuf_put(buf, payload->data, send_len);
- update_openflow_length(buf);
-
- return buf;
-}
-
-struct ofpbuf *
-make_packet_out(const struct ofpbuf *packet, uint32_t buffer_id,
- uint16_t in_port,
- const struct ofp_action_header *actions, size_t n_actions)
-{
- size_t actions_len = n_actions * sizeof *actions;
- struct ofp_packet_out *opo;
- size_t size = sizeof *opo + actions_len + (packet ? packet->size : 0);
- struct ofpbuf *out = ofpbuf_new(size);
-
- opo = ofpbuf_put_uninit(out, sizeof *opo);
- opo->header.version = OFP_VERSION;
- opo->header.type = OFPT_PACKET_OUT;
- opo->header.length = htons(size);
- opo->header.xid = htonl(0);
- opo->buffer_id = htonl(buffer_id);
- opo->in_port = htons(in_port == ODPP_LOCAL ? OFPP_LOCAL : in_port);
- opo->actions_len = htons(actions_len);
- ofpbuf_put(out, actions, actions_len);
- if (packet) {
- ofpbuf_put(out, packet->data, packet->size);
- }
- return out;
-}
-
-struct ofpbuf *
-make_unbuffered_packet_out(const struct ofpbuf *packet,
- uint16_t in_port, uint16_t out_port)
-{
- struct ofp_action_output action;
- action.type = htons(OFPAT_OUTPUT);
- action.len = htons(sizeof action);
- action.port = htons(out_port);
- return make_packet_out(packet, UINT32_MAX, in_port,
- (struct ofp_action_header *) &action, 1);
-}
-
-struct ofpbuf *
-make_buffered_packet_out(uint32_t buffer_id,
- uint16_t in_port, uint16_t out_port)
-{
- struct ofp_action_output action;
- action.type = htons(OFPAT_OUTPUT);
- action.len = htons(sizeof action);
- action.port = htons(out_port);
- return make_packet_out(NULL, buffer_id, in_port,
- (struct ofp_action_header *) &action, 1);
-}
-
-/* Creates and returns an OFPT_ECHO_REQUEST message with an empty payload. */
-struct ofpbuf *
-make_echo_request(void)
-{
- struct ofp_header *rq;
- struct ofpbuf *out = ofpbuf_new(sizeof *rq);
- rq = ofpbuf_put_uninit(out, sizeof *rq);
- rq->version = OFP_VERSION;
- rq->type = OFPT_ECHO_REQUEST;
- rq->length = htons(sizeof *rq);
- rq->xid = 0;
- return out;
-}
-
-/* Creates and returns an OFPT_ECHO_REPLY message matching the
- * OFPT_ECHO_REQUEST message in 'rq'. */
-struct ofpbuf *
-make_echo_reply(const struct ofp_header *rq)
-{
- size_t size = ntohs(rq->length);
- struct ofpbuf *out = ofpbuf_new(size);
- struct ofp_header *reply = ofpbuf_put(out, rq, size);
- reply->type = OFPT_ECHO_REPLY;
- return out;
-}
-
-static int
-check_message_type(uint8_t got_type, uint8_t want_type)
-{
- if (got_type != want_type) {
- char *want_type_name = ofp_message_type_to_string(want_type);
- char *got_type_name = ofp_message_type_to_string(got_type);
- VLOG_WARN_RL(&bad_ofmsg_rl,
- "received bad message type %s (expected %s)",
- got_type_name, want_type_name);
- free(want_type_name);
- free(got_type_name);
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
- }
- return 0;
-}
-
-/* Checks that 'msg' has type 'type' and that it is exactly 'size' bytes long.
- * Returns 0 if the checks pass, otherwise an OpenFlow error code (produced
- * with ofp_mkerr()). */
-int
-check_ofp_message(const struct ofp_header *msg, uint8_t type, size_t size)
-{
- size_t got_size;
- int error;
-
- error = check_message_type(msg->type, type);
- if (error) {
- return error;
- }
-
- got_size = ntohs(msg->length);
- if (got_size != size) {
- char *type_name = ofp_message_type_to_string(type);
- VLOG_WARN_RL(&bad_ofmsg_rl,
- "received %s message of length %zu (expected %zu)",
- type_name, got_size, size);
- free(type_name);
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
- }
-
- return 0;
-}
-
-/* Checks that 'msg' has type 'type' and that 'msg' is 'size' plus a
- * nonnegative integer multiple of 'array_elt_size' bytes long. Returns 0 if
- * the checks pass, otherwise an OpenFlow error code (produced with
- * ofp_mkerr()).
- *
- * If 'n_array_elts' is nonnull, then '*n_array_elts' is set to the number of
- * 'array_elt_size' blocks in 'msg' past the first 'min_size' bytes, when
- * successful. */
-int
-check_ofp_message_array(const struct ofp_header *msg, uint8_t type,
- size_t min_size, size_t array_elt_size,
- size_t *n_array_elts)
-{
- size_t got_size;
- int error;
-
- assert(array_elt_size);
-
- error = check_message_type(msg->type, type);
- if (error) {
- return error;
- }
-
- got_size = ntohs(msg->length);
- if (got_size < min_size) {
- char *type_name = ofp_message_type_to_string(type);
- VLOG_WARN_RL(&bad_ofmsg_rl, "received %s message of length %zu "
- "(expected at least %zu)",
- type_name, got_size, min_size);
- free(type_name);
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
- }
- if ((got_size - min_size) % array_elt_size) {
- char *type_name = ofp_message_type_to_string(type);
- VLOG_WARN_RL(&bad_ofmsg_rl,
- "received %s message of bad length %zu: the "
- "excess over %zu (%zu) is not evenly divisible by %zu "
- "(remainder is %zu)",
- type_name, got_size, min_size, got_size - min_size,
- array_elt_size, (got_size - min_size) % array_elt_size);
- free(type_name);
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
- }
- if (n_array_elts) {
- *n_array_elts = (got_size - min_size) / array_elt_size;
- }
- return 0;
-}
-
-int
-check_ofp_packet_out(const struct ofp_header *oh, struct ofpbuf *data,
- int *n_actionsp, int max_ports)
-{
- const struct ofp_packet_out *opo;
- unsigned int actions_len, n_actions;
- size_t extra;
- int error;
-
- *n_actionsp = 0;
- error = check_ofp_message_array(oh, OFPT_PACKET_OUT,
- sizeof *opo, 1, &extra);
- if (error) {
- return error;
- }
- opo = (const struct ofp_packet_out *) oh;
-
- actions_len = ntohs(opo->actions_len);
- if (actions_len > extra) {
- VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %u bytes of actions "
- "but message has room for only %zu bytes",
- actions_len, extra);
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
- }
- if (actions_len % sizeof(union ofp_action)) {
- VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out claims %u bytes of actions, "
- "which is not a multiple of %zu",
- actions_len, sizeof(union ofp_action));
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
- }
-
- n_actions = actions_len / sizeof(union ofp_action);
- error = validate_actions((const union ofp_action *) opo->actions,
- n_actions, max_ports);
- if (error) {
- return error;
- }
-
- data->data = (void *) &opo->actions[n_actions];
- data->size = extra - actions_len;
- *n_actionsp = n_actions;
- return 0;
-}
-
-const struct ofp_flow_stats *
-flow_stats_first(struct flow_stats_iterator *iter,
- const struct ofp_stats_reply *osr)
-{
- iter->pos = osr->body;
- iter->end = osr->body + (ntohs(osr->header.length)
- - offsetof(struct ofp_stats_reply, body));
- return flow_stats_next(iter);
-}
-
-const struct ofp_flow_stats *
-flow_stats_next(struct flow_stats_iterator *iter)
-{
- ptrdiff_t bytes_left = iter->end - iter->pos;
- const struct ofp_flow_stats *fs;
- size_t length;
-
- if (bytes_left < sizeof *fs) {
- if (bytes_left != 0) {
- VLOG_WARN_RL(&bad_ofmsg_rl,
- "%td leftover bytes in flow stats reply", bytes_left);
- }
- return NULL;
- }
-
- fs = (const void *) iter->pos;
- length = ntohs(fs->length);
- if (length < sizeof *fs) {
- VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu is shorter than "
- "min %zu", length, sizeof *fs);
- return NULL;
- } else if (length > bytes_left) {
- VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu but only %td "
- "bytes left", length, bytes_left);
- return NULL;
- } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
- VLOG_WARN_RL(&bad_ofmsg_rl, "flow stats length %zu has %zu bytes "
- "left over in final action", length,
- (length - sizeof *fs) % sizeof fs->actions[0]);
- return NULL;
- }
- iter->pos += length;
- return fs;
-}
-
-/* Alignment of ofp_actions. */
-#define ACTION_ALIGNMENT 8
-
-static int
-check_action_exact_len(const union ofp_action *a, unsigned int len,
- unsigned int required_len)
-{
- if (len != required_len) {
- VLOG_DBG_RL(&bad_ofmsg_rl,
- "action %u has invalid length %"PRIu16" (must be %u)\n",
- a->type, ntohs(a->header.len), required_len);
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
- }
- return 0;
-}
-
-static int
-check_action_port(int port, int max_ports)
-{
- switch (port) {
- case OFPP_IN_PORT:
- case OFPP_TABLE:
- case OFPP_NORMAL:
- case OFPP_FLOOD:
- case OFPP_ALL:
- case OFPP_CONTROLLER:
- case OFPP_LOCAL:
- return 0;
-
- default:
- if (port >= 0 && port < max_ports) {
- return 0;
- }
- VLOG_WARN_RL(&bad_ofmsg_rl, "unknown output port %x", port);
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
- }
-}
-
-static int
-check_nicira_action(const union ofp_action *a, unsigned int len)
-{
- const struct nx_action_header *nah;
-
- if (len < 16) {
- VLOG_DBG_RL(&bad_ofmsg_rl,
- "Nicira vendor action only %u bytes", len);
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
- }
- nah = (const struct nx_action_header *) a;
-
- switch (ntohs(nah->subtype)) {
- case NXAST_RESUBMIT:
- return check_action_exact_len(a, len, 16);
- default:
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
- }
-}
-
-static int
-check_action(const union ofp_action *a, unsigned int len, int max_ports)
-{
- int error;
-
- if (!len) {
- VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0");
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
- }
-
- if (len % ACTION_ALIGNMENT) {
- VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple of %d",
- len, ACTION_ALIGNMENT);
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
- }
-
- switch (ntohs(a->type)) {
- case OFPAT_OUTPUT:
- error = check_action_port(ntohs(a->output.port), max_ports);
- if (error) {
- return error;
- }
- return check_action_exact_len(a, len, 8);
-
- case OFPAT_SET_VLAN_VID:
- case OFPAT_SET_VLAN_PCP:
- case OFPAT_STRIP_VLAN:
- case OFPAT_SET_NW_SRC:
- case OFPAT_SET_NW_DST:
- case OFPAT_SET_TP_SRC:
- case OFPAT_SET_TP_DST:
- return check_action_exact_len(a, len, 8);
-
- case OFPAT_SET_DL_SRC:
- case OFPAT_SET_DL_DST:
- return check_action_exact_len(a, len, 16);
-
- case OFPAT_VENDOR:
- if (a->vendor.vendor == htonl(NX_VENDOR_ID)) {
- return check_nicira_action(a, len);
- } else {
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR);
- }
- break;
-
- default:
- VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %"PRIu16, a->type);
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE);
- }
-}
-
-int
-validate_actions(const union ofp_action *actions, size_t n_actions,
- int max_ports)
-{
- const union ofp_action *a;
-
- for (a = actions; a < &actions[n_actions]; ) {
- unsigned int len = ntohs(a->header.len);
- unsigned int n_slots = len / ACTION_ALIGNMENT;
- unsigned int slots_left = &actions[n_actions] - a;
- int error;
-
- if (n_slots > slots_left) {
- VLOG_DBG_RL(&bad_ofmsg_rl,
- "action requires %u slots but only %u remain",
- n_slots, slots_left);
- return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
- }
- error = check_action(a, len, max_ports);
- if (error) {
- return error;
- }
- a += n_slots;
- }
- return 0;
-}
-
-/* The set of actions must either come from a trusted source or have been
- * previously validated with validate_actions(). */
-const union ofp_action *
-actions_first(struct actions_iterator *iter,
- const union ofp_action *oa, size_t n_actions)
-{
- iter->pos = oa;
- iter->end = oa + n_actions;
- return actions_next(iter);
-}
-
-const union ofp_action *
-actions_next(struct actions_iterator *iter)
-{
- if (iter->pos < iter->end) {
- const union ofp_action *a = iter->pos;
- unsigned int len = ntohs(a->header.len);
- iter->pos += len / ACTION_ALIGNMENT;
- return a;
- } else {
- return NULL;
- }
-}
-
-void
-normalize_match(struct ofp_match *m)
-{
- enum { OFPFW_NW = OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK | OFPFW_NW_PROTO };
- enum { OFPFW_TP = OFPFW_TP_SRC | OFPFW_TP_DST };
- uint32_t wc;
-
- wc = ntohl(m->wildcards) & OFPFW_ALL;
- if (wc & OFPFW_DL_TYPE) {
- m->dl_type = 0;
-
- /* Can't sensibly match on network or transport headers if the
- * data link type is unknown. */
- wc |= OFPFW_NW | OFPFW_TP;
- m->nw_src = m->nw_dst = m->nw_proto = 0;
- m->tp_src = m->tp_dst = 0;
- } else if (m->dl_type == htons(ETH_TYPE_IP)) {
- if (wc & OFPFW_NW_PROTO) {
- m->nw_proto = 0;
-
- /* Can't sensibly match on transport headers if the network
- * protocol is unknown. */
- wc |= OFPFW_TP;
- m->tp_src = m->tp_dst = 0;
- } else if (m->nw_proto == IPPROTO_TCP ||
- m->nw_proto == IPPROTO_UDP ||
- m->nw_proto == IPPROTO_ICMP) {
- if (wc & OFPFW_TP_SRC) {
- m->tp_src = 0;
- }
- if (wc & OFPFW_TP_DST) {
- m->tp_dst = 0;
- }
- } else {
- /* Transport layer fields will always be extracted as zeros, so we
- * can do an exact-match on those values. */
- wc &= ~OFPFW_TP;
- m->tp_src = m->tp_dst = 0;
- }
- if (wc & OFPFW_NW_SRC_MASK) {
- m->nw_src &= flow_nw_bits_to_mask(wc, OFPFW_NW_SRC_SHIFT);
- }
- if (wc & OFPFW_NW_DST_MASK) {
- m->nw_dst &= flow_nw_bits_to_mask(wc, OFPFW_NW_DST_SHIFT);
- }
- } else {
- /* Network and transport layer fields will always be extracted as
- * zeros, so we can do an exact-match on those values. */
- wc &= ~(OFPFW_NW | OFPFW_TP);
- m->nw_proto = m->nw_src = m->nw_dst = 0;
- m->tp_src = m->tp_dst = 0;
- }
- if (wc & OFPFW_DL_SRC) {
- memset(m->dl_src, 0, sizeof m->dl_src);
- }
- if (wc & OFPFW_DL_DST) {
- memset(m->dl_dst, 0, sizeof m->dl_dst);
- }
- m->wildcards = htonl(wc);
-}
-
+ * The caller retains ownership of 'name'. */
void
vconn_init(struct vconn *vconn, struct vconn_class *class, int connect_status,
- const char *name, bool reconnectable)
+ const char *name)
{
vconn->class = class;
vconn->state = (connect_status == EAGAIN ? VCS_CONNECTING
vconn->local_ip = 0;
vconn->local_port = 0;
vconn->name = xstrdup(name);
- vconn->reconnectable = reconnectable;
+ assert(vconn->state != VCS_CONNECTING || class->connect);
}
void
vconn->remote_port = port;
}
-void
+void
vconn_set_local_ip(struct vconn *vconn, uint32_t ip)
{
vconn->local_ip = ip;
}
-void
+void
vconn_set_local_port(struct vconn *vconn, uint16_t port)
{
vconn->local_port = port;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff