+static int
+ofputil_decode_ofpst_request(const struct ofp_header *oh,
+ const struct ofputil_msg_type **typep)
+{
+ enum { OSR_SIZE = sizeof(struct ofp_stats_request) };
+ static const struct ofputil_msg_type ofpst_requests[] = {
+ { OFPUTIL_OFPST_DESC_REQUEST,
+ OFPST_DESC, "OFPST_DESC request",
+ OSR_SIZE, 0 },
+
+ { OFPUTIL_OFPST_FLOW_REQUEST,
+ OFPST_FLOW, "OFPST_FLOW request",
+ OSR_SIZE + sizeof(struct ofp_flow_stats_request), 0 },
+
+ { OFPUTIL_OFPST_AGGREGATE_REQUEST,
+ OFPST_AGGREGATE, "OFPST_AGGREGATE request",
+ OSR_SIZE + sizeof(struct ofp_aggregate_stats_request), 0 },
+
+ { OFPUTIL_OFPST_TABLE_REQUEST,
+ OFPST_TABLE, "OFPST_TABLE request",
+ OSR_SIZE, 0 },
+
+ { OFPUTIL_OFPST_PORT_REQUEST,
+ OFPST_PORT, "OFPST_PORT request",
+ OSR_SIZE + sizeof(struct ofp_port_stats_request), 0 },
+
+ { OFPUTIL_OFPST_QUEUE_REQUEST,
+ OFPST_QUEUE, "OFPST_QUEUE request",
+ OSR_SIZE + sizeof(struct ofp_queue_stats_request), 0 },
+
+ { 0,
+ OFPST_VENDOR, "OFPST_VENDOR request",
+ OSR_SIZE + sizeof(uint32_t), 1 },
+ };
+
+ static const struct ofputil_msg_category ofpst_request_category = {
+ "OpenFlow statistics",
+ ofpst_requests, ARRAY_SIZE(ofpst_requests),
+ OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT)
+ };
+
+ const struct ofp_stats_request *osr;
+ int error;
+
+ osr = (const struct ofp_stats_request *) oh;
+ error = ofputil_lookup_openflow_message(&ofpst_request_category,
+ ntohs(osr->type),
+ ntohs(oh->length), typep);
+ if (!error && osr->type == htons(OFPST_VENDOR)) {
+ error = ofputil_decode_nxst_request(oh, typep);
+ }
+ return error;
+}
+
+static int
+ofputil_decode_ofpst_reply(const struct ofp_header *oh,
+ const struct ofputil_msg_type **typep)
+{
+ enum { OSR_SIZE = sizeof(struct ofp_stats_reply) };
+ static const struct ofputil_msg_type ofpst_replies[] = {
+ { OFPUTIL_OFPST_DESC_REPLY,
+ OFPST_DESC, "OFPST_DESC reply",
+ OSR_SIZE + sizeof(struct ofp_desc_stats), 0 },
+
+ { OFPUTIL_OFPST_FLOW_REPLY,
+ OFPST_FLOW, "OFPST_FLOW reply",
+ OSR_SIZE, 1 },
+
+ { OFPUTIL_OFPST_AGGREGATE_REPLY,
+ OFPST_AGGREGATE, "OFPST_AGGREGATE reply",
+ OSR_SIZE + sizeof(struct ofp_aggregate_stats_reply), 0 },
+
+ { OFPUTIL_OFPST_TABLE_REPLY,
+ OFPST_TABLE, "OFPST_TABLE reply",
+ OSR_SIZE, sizeof(struct ofp_table_stats) },
+
+ { OFPUTIL_OFPST_PORT_REPLY,
+ OFPST_PORT, "OFPST_PORT reply",
+ OSR_SIZE, sizeof(struct ofp_port_stats) },
+
+ { OFPUTIL_OFPST_QUEUE_REPLY,
+ OFPST_QUEUE, "OFPST_QUEUE reply",
+ OSR_SIZE, sizeof(struct ofp_queue_stats) },
+
+ { 0,
+ OFPST_VENDOR, "OFPST_VENDOR reply",
+ OSR_SIZE + sizeof(uint32_t), 1 },
+ };
+
+ static const struct ofputil_msg_category ofpst_reply_category = {
+ "OpenFlow statistics",
+ ofpst_replies, ARRAY_SIZE(ofpst_replies),
+ OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT)
+ };
+
+ const struct ofp_stats_reply *osr = (const struct ofp_stats_reply *) oh;
+ int error;
+
+ error = ofputil_lookup_openflow_message(&ofpst_reply_category,
+ ntohs(osr->type),
+ ntohs(oh->length), typep);
+ if (!error && osr->type == htons(OFPST_VENDOR)) {
+ error = ofputil_decode_nxst_reply(oh, typep);
+ }
+ return error;
+}
+
+/* Decodes the message type represented by 'oh'. Returns 0 if successful or
+ * an OpenFlow error code constructed with ofp_mkerr() on failure. Either
+ * way, stores in '*typep' a type structure that can be inspected with the
+ * ofputil_msg_type_*() functions.
+ *
+ * oh->length must indicate the correct length of the message (and must be at
+ * least sizeof(struct ofp_header)).
+ *
+ * Success indicates that 'oh' is at least as long as the minimum-length
+ * message of its type. */
+int
+ofputil_decode_msg_type(const struct ofp_header *oh,
+ const struct ofputil_msg_type **typep)
+{
+ static const struct ofputil_msg_type ofpt_messages[] = {
+ { OFPUTIL_OFPT_HELLO,
+ OFPT_HELLO, "OFPT_HELLO",
+ sizeof(struct ofp_hello), 1 },
+
+ { OFPUTIL_OFPT_ERROR,
+ OFPT_ERROR, "OFPT_ERROR",
+ sizeof(struct ofp_error_msg), 1 },
+
+ { OFPUTIL_OFPT_ECHO_REQUEST,
+ OFPT_ECHO_REQUEST, "OFPT_ECHO_REQUEST",
+ sizeof(struct ofp_header), 1 },
+
+ { OFPUTIL_OFPT_ECHO_REPLY,
+ OFPT_ECHO_REPLY, "OFPT_ECHO_REPLY",
+ sizeof(struct ofp_header), 1 },
+
+ { OFPUTIL_OFPT_FEATURES_REQUEST,
+ OFPT_FEATURES_REQUEST, "OFPT_FEATURES_REQUEST",
+ sizeof(struct ofp_header), 0 },
+
+ { OFPUTIL_OFPT_FEATURES_REPLY,
+ OFPT_FEATURES_REPLY, "OFPT_FEATURES_REPLY",
+ sizeof(struct ofp_switch_features), sizeof(struct ofp_phy_port) },
+
+ { OFPUTIL_OFPT_GET_CONFIG_REQUEST,
+ OFPT_GET_CONFIG_REQUEST, "OFPT_GET_CONFIG_REQUEST",
+ sizeof(struct ofp_header), 0 },
+
+ { OFPUTIL_OFPT_GET_CONFIG_REPLY,
+ OFPT_GET_CONFIG_REPLY, "OFPT_GET_CONFIG_REPLY",
+ sizeof(struct ofp_switch_config), 0 },
+
+ { OFPUTIL_OFPT_SET_CONFIG,
+ OFPT_SET_CONFIG, "OFPT_SET_CONFIG",
+ sizeof(struct ofp_switch_config), 0 },
+
+ { OFPUTIL_OFPT_PACKET_IN,
+ OFPT_PACKET_IN, "OFPT_PACKET_IN",
+ offsetof(struct ofp_packet_in, data), 1 },
+
+ { OFPUTIL_OFPT_FLOW_REMOVED,
+ OFPT_FLOW_REMOVED, "OFPT_FLOW_REMOVED",
+ sizeof(struct ofp_flow_removed), 0 },
+
+ { OFPUTIL_OFPT_PORT_STATUS,
+ OFPT_PORT_STATUS, "OFPT_PORT_STATUS",
+ sizeof(struct ofp_port_status), 0 },
+
+ { OFPUTIL_OFPT_PACKET_OUT,
+ OFPT_PACKET_OUT, "OFPT_PACKET_OUT",
+ sizeof(struct ofp_packet_out), 1 },
+
+ { OFPUTIL_OFPT_FLOW_MOD,
+ OFPT_FLOW_MOD, "OFPT_FLOW_MOD",
+ sizeof(struct ofp_flow_mod), 1 },
+
+ { OFPUTIL_OFPT_PORT_MOD,
+ OFPT_PORT_MOD, "OFPT_PORT_MOD",
+ sizeof(struct ofp_port_mod), 0 },
+
+ { 0,
+ OFPT_STATS_REQUEST, "OFPT_STATS_REQUEST",
+ sizeof(struct ofp_stats_request), 1 },
+
+ { 0,
+ OFPT_STATS_REPLY, "OFPT_STATS_REPLY",
+ sizeof(struct ofp_stats_reply), 1 },
+
+ { OFPUTIL_OFPT_BARRIER_REQUEST,
+ OFPT_BARRIER_REQUEST, "OFPT_BARRIER_REQUEST",
+ sizeof(struct ofp_header), 0 },
+
+ { OFPUTIL_OFPT_BARRIER_REPLY,
+ OFPT_BARRIER_REPLY, "OFPT_BARRIER_REPLY",
+ sizeof(struct ofp_header), 0 },
+
+ { 0,
+ OFPT_VENDOR, "OFPT_VENDOR",
+ sizeof(struct ofp_vendor_header), 1 },
+ };
+
+ static const struct ofputil_msg_category ofpt_category = {
+ "OpenFlow message",
+ ofpt_messages, ARRAY_SIZE(ofpt_messages),
+ OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE)
+ };
+
+ int error;
+
+ error = ofputil_lookup_openflow_message(&ofpt_category, oh->type,
+ ntohs(oh->length), typep);
+ if (!error) {
+ switch (oh->type) {
+ case OFPT_VENDOR:
+ error = ofputil_decode_vendor(oh, typep);
+ break;
+
+ case OFPT_STATS_REQUEST:
+ error = ofputil_decode_ofpst_request(oh, typep);
+ break;
+
+ case OFPT_STATS_REPLY:
+ error = ofputil_decode_ofpst_reply(oh, typep);
+
+ default:
+ break;
+ }
+ }
+ if (error) {
+ static const struct ofputil_msg_type ofputil_invalid_type = {
+ OFPUTIL_INVALID,
+ 0, "OFPUTIL_INVALID",
+ 0, 0
+ };
+
+ *typep = &ofputil_invalid_type;
+ }
+ return error;
+}
+
+/* Returns an OFPUTIL_* message type code for 'type'. */
+enum ofputil_msg_code
+ofputil_msg_type_code(const struct ofputil_msg_type *type)
+{
+ return type->code;
+}
+
+/* Returns a string representing the message type of 'type'. The string is the
+ * enumeration constant for the type, e.g. "OFPT_HELLO". For statistics
+ * messages, the constant is followed by "request" or "reply",
+ * e.g. "OFPST_AGGREGATE reply". */
+const char *
+ofputil_msg_type_name(const struct ofputil_msg_type *type)
+{
+ return type->name;
+}
+\f