/* Constructs and returns an OFPT_QUEUE_GET_CONFIG request for the specified
* 'port' and 'queue', suitable for OpenFlow version 'version'.
*
* 'queue' is honored only for OpenFlow 1.4 and later; older versions always
* request all queues. */
struct ofpbuf *
ofputil_encode_queue_get_config_request(enum ofp_version version,
ofp_port_t port,
uint32_t queue)
{
struct ofpbuf *request;
if (version == OFP10_VERSION) {
struct ofp10_queue_get_config_request *qgcr10;
request = ofpraw_alloc(OFPRAW_OFPT10_QUEUE_GET_CONFIG_REQUEST,
version, 0);
qgcr10 = ofpbuf_put_zeros(request, sizeof *qgcr10);
qgcr10->port = htons(ofp_to_u16(port));
} else if (version < OFP14_VERSION) {
struct ofp11_queue_get_config_request *qgcr11;
request = ofpraw_alloc(OFPRAW_OFPT11_QUEUE_GET_CONFIG_REQUEST,
version, 0);
qgcr11 = ofpbuf_put_zeros(request, sizeof *qgcr11);
qgcr11->port = ofputil_port_to_ofp11(port);
} else {
struct ofp14_queue_desc_request *qdr14;
request = ofpraw_alloc(OFPRAW_OFPST14_QUEUE_DESC_REQUEST,
version, 0);
qdr14 = ofpbuf_put_zeros(request, sizeof *qdr14);
qdr14->port = ofputil_port_to_ofp11(port);
qdr14->queue = htonl(queue);
}
return request;
}
struct ofpbuf *
ofputil_encode_set_config(const struct ofputil_switch_config *config,
enum ofp_version version)
{
struct ofpbuf *b = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, version, 0);
return ofputil_put_switch_config(config, b);
}
struct ofpbuf *
ofputil_encode_bundle_ctrl_request(enum ofp_version ofp_version,
struct ofputil_bundle_ctrl_msg *bc)
{
struct ofpbuf *request;
struct ofp14_bundle_ctrl_msg *m;
switch (ofp_version) {
case OFP10_VERSION:
case OFP11_VERSION:
case OFP12_VERSION:
ovs_fatal(0, "bundles need OpenFlow 1.3 or later "
"(\'-O OpenFlow14\')");
case OFP13_VERSION:
case OFP14_VERSION:
case OFP15_VERSION:
request = ofpraw_alloc(ofp_version == OFP13_VERSION
? OFPRAW_ONFT13_BUNDLE_CONTROL
: OFPRAW_OFPT14_BUNDLE_CONTROL, ofp_version, 0);
m = ofpbuf_put_zeros(request, sizeof *m);
m->bundle_id = htonl(bc->bundle_id);
m->type = htons(bc->type);
m->flags = htons(bc->flags);
break;
default:
OVS_NOT_REACHED();
}
return request;
}
static void
run_S_NEW(void)
{
struct ofpbuf *buf = ofpraw_alloc(OFPRAW_NXT_TLV_TABLE_REQUEST,
rconn_get_version(swconn), 0);
xid = queue_msg(buf);
state = S_TLV_TABLE_REQUESTED;
}
/* Returns an OpenFlow message that can be used to turn the flow_mod_table_id
* extension on or off (according to 'enable'). */
struct ofpbuf *
ofputil_encode_nx_flow_mod_table_id(bool enable)
{
struct ofpbuf *msg = ofpraw_alloc(OFPRAW_NXT_FLOW_MOD_TABLE_ID,
OFP10_VERSION, 0);
uint8_t *p = ofpbuf_put_zeros(msg, 8);
*p = enable;
return msg;
}
static void
get_switch_config(struct rconn *swconn)
{
struct ofpbuf *request;
request = ofpraw_alloc(OFPRAW_OFPT_GET_CONFIG_REQUEST,
rconn_get_version(swconn), 0);
queue_msg(request);
}
static void
set_switch_config(struct rconn *swconn, const struct ofp_switch_config *config)
{
struct ofpbuf *request;
request =
ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, rconn_get_version(swconn), 0);
ofpbuf_put(request, config, sizeof *config);
queue_msg(request);
}
/* Encode a queue stats request for 'oqsr', the encoded message
* will be for OpenFlow version 'ofp_version'. Returns message
* as a struct ofpbuf. Returns encoded message on success, NULL on error. */
struct ofpbuf *
ofputil_encode_queue_stats_request(
enum ofp_version ofp_version,
const struct ofputil_queue_stats_request *oqsr)
{
struct ofpbuf *request;
switch (ofp_version) {
case OFP11_VERSION:
case OFP12_VERSION:
case OFP13_VERSION:
case OFP14_VERSION:
case OFP15_VERSION:
case OFP16_VERSION: {
struct ofp11_queue_stats_request *req;
request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0);
req = ofpbuf_put_zeros(request, sizeof *req);
req->port_no = ofputil_port_to_ofp11(oqsr->port_no);
req->queue_id = htonl(oqsr->queue_id);
break;
}
case OFP10_VERSION: {
struct ofp10_queue_stats_request *req;
request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST, ofp_version, 0);
req = ofpbuf_put_zeros(request, sizeof *req);
/* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */
req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY
? OFPP_ALL : oqsr->port_no));
req->queue_id = htonl(oqsr->queue_id);
break;
}
default:
OVS_NOT_REACHED();
}
return request;
}
static void
send_controller_id(struct lswitch *sw)
{
struct ofpbuf *b;
int ofp_version = rconn_get_version(sw->rconn);
ovs_assert(ofp_version > 0 && ofp_version < 0xff);
b = ofpraw_alloc(OFPRAW_NXT_SET_CONTROLLER_ID, ofp_version, 0);
struct nx_controller_id *nci = ofpbuf_put_zeros(b, sizeof *nci);
nci->controller_id = htons(100);
queue_tx(sw, b);
}
/* Returns an NXT_SET_FLOW_FORMAT message that can be used to set the flow
* format to 'protocol'. */
struct ofpbuf *
ofputil_encode_nx_set_flow_format(enum ofputil_protocol protocol)
{
struct ofpbuf *msg = ofpraw_alloc(OFPRAW_NXT_SET_FLOW_FORMAT,
OFP10_VERSION, 0);
ovs_be32 *nxff = ofpbuf_put_uninit(msg, sizeof *nxff);
if (protocol == OFPUTIL_P_OF10_STD) {
*nxff = htonl(NXFF_OPENFLOW10);
} else if (protocol == OFPUTIL_P_OF10_NXM) {
*nxff = htonl(NXFF_NXM);
} else {
OVS_NOT_REACHED();
}
return msg;
}
static void
send_features_request(struct lswitch *sw)
{
struct ofpbuf *b;
int ofp_version = rconn_get_version(sw->rconn);
ovs_assert(ofp_version > 0 && ofp_version < 0xff);
/* Send OFPT_FEATURES_REQUEST. */
b = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, ofp_version, 0);
queue_tx(sw, b);
/* Send OFPT_SET_CONFIG. */
struct ofputil_switch_config config = {
.miss_send_len = OFP_DEFAULT_MISS_SEND_LEN
};
queue_tx(sw, ofputil_encode_set_config(&config, ofp_version));
}
