/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "fatal-signal.h"
#include "flow.h"
#include "ofp-errors.h"
+#include "ofp-msgs.h"
#include "ofp-print.h"
#include "ofp-util.h"
#include "ofpbuf.h"
}
int
-vconn_open_block(const char *name, int min_version, struct vconn **vconnp)
+vconn_open_block(const char *name, enum ofp_version min_version,
+ struct vconn **vconnp)
{
struct vconn *vconn;
int error;
error = vconn_open(name, min_version, &vconn, DSCP_DEFAULT);
if (!error) {
- while ((error = vconn_connect(vconn)) == EAGAIN) {
- vconn_run(vconn);
- vconn_run_wait(vconn);
- vconn_connect_wait(vconn);
- poll_block();
- }
- assert(error != EINPROGRESS);
+ error = vconn_connect_block(vconn);
}
if (error) {
*
* A vconn that has successfully connected (that is, vconn_connect() or
* vconn_send() or vconn_recv() has returned 0) always negotiated a version. */
-int
+enum ofp_version
vconn_get_version(const struct vconn *vconn)
{
return vconn->version;
struct ofpbuf *b;
int retval;
- make_openflow(sizeof(struct ofp_header), OFPT_HELLO, &b);
+ b = ofpraw_alloc(OFPRAW_OFPT_HELLO, OFP10_VERSION, 0);
retval = do_send(vconn, b);
if (!retval) {
vconn->state = VCS_RECV_HELLO;
retval = do_recv(vconn, &b);
if (!retval) {
- struct ofp_header *oh = b->data;
+ const struct ofp_header *oh = b->data;
+ enum ofptype type;
+ enum ofperr error;
- if (oh->type == OFPT_HELLO) {
+ error = ofptype_decode(&type, b->data);
+ if (!error && type == OFPTYPE_HELLO) {
if (b->size > sizeof *oh) {
struct ds msg = DS_EMPTY_INITIALIZER;
ds_put_format(&msg, "%s: extra-long hello:\n", vconn->name);
int
vconn_recv(struct vconn *vconn, struct ofpbuf **msgp)
{
- int retval = vconn_connect(vconn);
+ struct ofpbuf *msg;
+ int retval;
+
+ retval = vconn_connect(vconn);
if (!retval) {
- retval = do_recv(vconn, msgp);
+ retval = do_recv(vconn, &msg);
}
+ if (!retval) {
+ const struct ofp_header *oh = msg->data;
+ if (oh->version != vconn->version) {
+ enum ofptype type;
+
+ if (ofptype_decode(&type, msg->data)
+ || (type != OFPTYPE_HELLO &&
+ type != OFPTYPE_ERROR &&
+ type != OFPTYPE_ECHO_REQUEST &&
+ type != OFPTYPE_ECHO_REPLY)) {
+ VLOG_ERR_RL(&bad_ofmsg_rl, "%s: received OpenFlow version "
+ "0x%02"PRIx8" != expected %02x",
+ vconn->name, oh->version, vconn->version);
+ ofpbuf_delete(msg);
+ retval = EPROTO;
+ }
+ }
+ }
+
+ *msgp = retval ? NULL : msg;
return retval;
}
{
int retval = (vconn->class->recv)(vconn, msgp);
if (!retval) {
- struct ofp_header *oh;
-
COVERAGE_INC(vconn_received);
if (VLOG_IS_DBG_ENABLED()) {
char *s = ofp_to_string((*msgp)->data, (*msgp)->size, 1);
VLOG_DBG_RL(&ofmsg_rl, "%s: received: %s", vconn->name, s);
free(s);
}
-
- oh = ofpbuf_at_assert(*msgp, 0, sizeof *oh);
- if ((oh->version != vconn->version || oh->version == 0)
- && oh->type != OFPT_HELLO
- && oh->type != OFPT_ERROR
- && oh->type != OFPT_ECHO_REQUEST
- && oh->type != OFPT_ECHO_REPLY
- && oh->type != OFPT_VENDOR)
- {
- if (vconn->version == 0) {
- VLOG_ERR_RL(&bad_ofmsg_rl,
- "%s: received OpenFlow message type %"PRIu8" "
- "before version negotiation complete",
- vconn->name, oh->type);
- } else {
- VLOG_ERR_RL(&bad_ofmsg_rl,
- "%s: received OpenFlow version 0x%02"PRIx8" "
- "!= expected %02x",
- vconn->name, oh->version, vconn->version);
- }
- ofpbuf_delete(*msgp);
- retval = EPROTO;
- }
- }
- if (retval) {
- *msgp = NULL;
}
return retval;
}
int retval;
assert(msg->size >= sizeof(struct ofp_header));
- assert(((struct ofp_header *) msg->data)->length == htons(msg->size));
+
+ ofpmsg_update_length(msg);
if (!VLOG_IS_DBG_ENABLED()) {
COVERAGE_INC(vconn_sent);
retval = (vconn->class->send)(vconn, msg);
return retval;
}
+/* Same as vconn_connect(), except that it waits until the connection on
+ * 'vconn' completes or fails. Thus, it will never return EAGAIN. */
+int
+vconn_connect_block(struct vconn *vconn)
+{
+ int error;
+
+ while ((error = vconn_connect(vconn)) == EAGAIN) {
+ vconn_run(vconn);
+ vconn_run_wait(vconn);
+ vconn_connect_wait(vconn);
+ poll_block();
+ }
+ assert(error != EINPROGRESS);
+
+ return error;
+}
+
/* Same as vconn_send, except that it waits until 'msg' can be transmitted. */
int
vconn_send_block(struct vconn *vconn, struct ofpbuf *msg)