#include "in-band.h"
#include "odp-util.h"
#include "ofp-actions.h"
+#include "ofp-msgs.h"
#include "ofp-util.h"
#include "ofpbuf.h"
#include "ofproto-provider.h"
static void ofservice_reconfigure(struct ofservice *,
const struct ofproto_controller *);
-static int ofservice_create(struct connmgr *, const char *target, uint8_t dscp);
+static int ofservice_create(struct connmgr *mgr, const char *target,
+ uint32_t allowed_versions, uint8_t dscp);
static void ofservice_destroy(struct connmgr *, struct ofservice *);
static struct ofservice *ofservice_lookup(struct connmgr *,
const char *target);
struct vconn *vconn;
int retval;
- retval = pvconn_accept(ofservice->pvconn, OFP10_VERSION, &vconn);
+ retval = pvconn_accept(ofservice->pvconn, &vconn);
if (!retval) {
struct rconn *rconn;
char *name;
/* Passing default value for creation of the rconn */
- rconn = rconn_create(ofservice->probe_interval, 0, ofservice->dscp);
+ rconn = rconn_create(ofservice->probe_interval, 0, ofservice->dscp,
+ vconn_get_allowed_versions(vconn));
name = ofconn_make_name(mgr, vconn_get_name(vconn));
rconn_connect_unreliably(rconn, vconn, name);
free(name);
struct vconn *vconn;
int retval;
- retval = pvconn_accept(mgr->snoops[i], OFP10_VERSION, &vconn);
+ retval = pvconn_accept(mgr->snoops[i], &vconn);
if (!retval) {
add_snooper(mgr, vconn);
} else if (retval != EAGAIN) {
\f
/* OpenFlow configuration. */
-static void add_controller(struct connmgr *, const char *target, uint8_t dscp);
+static void add_controller(struct connmgr *, const char *target, uint8_t dscp,
+ uint32_t allowed_versions);
static struct ofconn *find_controller_by_target(struct connmgr *,
const char *target);
static void update_fail_open(struct connmgr *);
SHASH_FOR_EACH (node, info) {
struct ofproto_controller_info *cinfo = node->data;
while (cinfo->pairs.n) {
- free((char *) cinfo->pairs.values[--cinfo->pairs.n]);
+ free(CONST_CAST(char *, cinfo->pairs.values[--cinfo->pairs.n]));
}
free(cinfo);
}
void
connmgr_set_controllers(struct connmgr *mgr,
const struct ofproto_controller *controllers,
- size_t n_controllers)
+ size_t n_controllers, uint32_t allowed_versions)
{
bool had_controllers = connmgr_has_controllers(mgr);
struct shash new_controllers;
if (!find_controller_by_target(mgr, c->target)) {
VLOG_INFO("%s: added primary controller \"%s\"",
mgr->name, c->target);
- add_controller(mgr, c->target, c->dscp);
+ add_controller(mgr, c->target, c->dscp, allowed_versions);
}
} else if (!pvconn_verify_name(c->target)) {
if (!ofservice_lookup(mgr, c->target)) {
VLOG_INFO("%s: added service controller \"%s\"",
mgr->name, c->target);
- ofservice_create(mgr, c->target, c->dscp);
+ ofservice_create(mgr, c->target, allowed_versions, c->dscp);
}
} else {
VLOG_WARN_RL(&rl, "%s: unsupported controller \"%s\"",
/* Creates a new controller for 'target' in 'mgr'. update_controller() needs
* to be called later to finish the new ofconn's configuration. */
static void
-add_controller(struct connmgr *mgr, const char *target, uint8_t dscp)
+add_controller(struct connmgr *mgr, const char *target, uint8_t dscp,
+ uint32_t allowed_versions)
{
char *name = ofconn_make_name(mgr, target);
struct ofconn *ofconn;
- ofconn = ofconn_create(mgr, rconn_create(5, 8, dscp), OFCONN_PRIMARY, true);
+ ofconn = ofconn_create(mgr, rconn_create(5, 8, dscp, allowed_versions),
+ OFCONN_PRIMARY, true);
ofconn->pktbuf = pktbuf_create();
rconn_connect(ofconn->rconn, target, name);
hmap_insert(&mgr->controllers, &ofconn->hmap_node, hash_string(target, 0));
SSET_FOR_EACH (name, sset) {
struct pvconn *pvconn;
int error;
-
- error = pvconn_open(name, &pvconn, 0);
+ error = pvconn_open(name, 0, &pvconn, 0);
if (!error) {
pvconns[n_pvconns++] = pvconn;
} else {
/* Returns the currently configured protocol for 'ofconn', one of OFPUTIL_P_*.
*
- * The default, if no other format has been set, is OFPUTIL_P_OPENFLOW10. */
+ * The default, if no other format has been set, is OFPUTIL_P_OF10_STD. */
enum ofputil_protocol
ofconn_get_protocol(struct ofconn *ofconn)
{
static struct vlog_rate_limit err_rl = VLOG_RATE_LIMIT_INIT(10, 10);
if (!VLOG_DROP_INFO(&err_rl)) {
- const struct ofputil_msg_type *type;
const char *type_name;
size_t request_len;
+ enum ofpraw raw;
request_len = ntohs(request->length);
- type_name = (!ofputil_decode_msg_type_partial(request,
- MIN(64, request_len),
- &type)
- ? ofputil_msg_type_name(type)
+ type_name = (!ofpraw_decode_partial(&raw, request,
+ MIN(64, request_len))
+ ? ofpraw_get_name(raw)
: "invalid");
VLOG_INFO("%s: sending %s error reply to %s message",
int i;
ofconn->role = NX_ROLE_OTHER;
- ofconn->protocol = OFPUTIL_P_OF10;
+ ofconn->protocol = OFPUTIL_P_OF10_STD;
ofconn->packet_in_format = NXPIF_OPENFLOW10;
/* Disassociate 'ofconn' from all of the ofopgroups that it initiated that
ofconn_send(const struct ofconn *ofconn, struct ofpbuf *msg,
struct rconn_packet_counter *counter)
{
- update_openflow_length(msg);
+ ofpmsg_update_length(msg);
rconn_send(ofconn->rconn, msg, counter);
}
\f
* while (until a later call to pinsched_run()). */
pinsched_send(ofconn->schedulers[pin.reason == OFPR_NO_MATCH ? 0 : 1],
pin.fmd.in_port,
- ofputil_encode_packet_in(&pin, ofconn->packet_in_format),
+ ofputil_encode_packet_in(&pin, ofconn->protocol,
+ ofconn->packet_in_format),
do_send_packet_in, ofconn);
}
\f
if (!connmgr_has_controllers(mgr)
&& mgr->fail_mode == OFPROTO_FAIL_STANDALONE) {
struct ofpbuf ofpacts;
- struct cls_rule rule;
+ struct match match;
ofpbuf_init(&ofpacts, OFPACT_OUTPUT_SIZE);
ofpact_put_OUTPUT(&ofpacts)->port = OFPP_NORMAL;
ofpact_pad(&ofpacts);
- cls_rule_init_catchall(&rule, 0);
- ofproto_add_flow(mgr->ofproto, &rule, ofpacts.data, ofpacts.size);
+ match_init_catchall(&match);
+ ofproto_add_flow(mgr->ofproto, &match, 0, ofpacts.data, ofpacts.size);
ofpbuf_uninit(&ofpacts);
}
* ofservice_reconfigure() must be called to fully configure the new
* ofservice. */
static int
-ofservice_create(struct connmgr *mgr, const char *target, uint8_t dscp)
+ofservice_create(struct connmgr *mgr, const char *target,
+ uint32_t allowed_versions, uint8_t dscp)
{
struct ofservice *ofservice;
struct pvconn *pvconn;
int error;
- error = pvconn_open(target, &pvconn, dscp);
+ error = pvconn_open(target, allowed_versions, &pvconn, dscp);
if (error) {
return error;
}
m->flags = request->flags;
m->out_port = request->out_port;
m->table_id = request->table_id;
- m->match = request->match;
+ minimatch_init(&m->match, &request->match);
*monitorp = m;
return 0;
if (ofconn != abbrev_ofconn || ofconn->monitor_paused) {
struct ofputil_flow_update fu;
+ struct match match;
fu.event = event;
fu.reason = event == NXFME_DELETED ? reason : 0;
fu.hard_timeout = rule->hard_timeout;
fu.table_id = rule->table_id;
fu.cookie = rule->flow_cookie;
- fu.match = &rule->cr;
+ minimatch_expand(&rule->cr.match, &match);
+ fu.match = &match;
+ fu.priority = rule->cr.priority;
if (flags & NXFMF_ACTIONS) {
fu.ofpacts = rule->ofpacts;
fu.ofpacts_len = rule->ofpacts_len;
COVERAGE_INC(ofmonitor_pause);
ofconn->monitor_paused = monitor_seqno++;
- make_nxmsg_xid(sizeof(struct nicira_header),
- NXT_FLOW_MONITOR_PAUSED, htonl(0), &pause);
+ pause = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_MONITOR_PAUSED,
+ OFP10_VERSION, htonl(0), 0);
ofconn_send(ofconn, pause, ofconn->monitor_counter);
}
}
static void
ofmonitor_resume(struct ofconn *ofconn)
{
- struct ofpbuf *resume;
+ struct ofpbuf *resumed;
struct ofmonitor *m;
struct list rules;
struct list msgs;
list_init(&msgs);
ofmonitor_compose_refresh_updates(&rules, &msgs);
- make_nxmsg_xid(sizeof(struct nicira_header),
- NXT_FLOW_MONITOR_RESUMED, htonl(0), &resume);
- list_push_back(&msgs, &resume->list_node);
+ resumed = ofpraw_alloc_xid(OFPRAW_NXT_FLOW_MONITOR_RESUMED, OFP10_VERSION,
+ htonl(0), 0);
+ list_push_back(&msgs, &resumed->list_node);
ofconn_send_replies(ofconn, &msgs);
ofconn->monitor_paused = 0;