X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-print.c;h=5f43b81e4b1abf8f728dabae3a6f19251ec5e43b;hb=6d9e6eb44fc82ae985e6e8db4f156ba56f8bea39;hp=840356c5b30f8444217dfd5e61d2f0dd77c78582;hpb=9b045a0c66e9dfa6dd0266efb023823eefe82045;p=sliver-openvswitch.git diff --git a/lib/ofp-print.c b/lib/ofp-print.c index 840356c5b..5f43b81e4 100644 --- a/lib/ofp-print.c +++ b/lib/ofp-print.c @@ -30,6 +30,7 @@ #include "compiler.h" #include "dynamic-string.h" #include "flow.h" +#include "multipath.h" #include "nx-match.h" #include "ofp-util.h" #include "ofpbuf.h" @@ -37,6 +38,7 @@ #include "openflow/nicira-ext.h" #include "packets.h" #include "pcap.h" +#include "type-props.h" #include "util.h" static void ofp_print_port_name(struct ds *string, uint16_t port); @@ -183,6 +185,7 @@ static void ofp_print_port_name(struct ds *string, uint16_t port) ds_put_cstr(string, name); } + static void print_note(struct ds *string, const struct nx_action_note *nan) { @@ -199,46 +202,125 @@ print_note(struct ds *string, const struct nx_action_note *nan) } } +static int +nx_action_len(enum nx_action_subtype subtype) +{ + switch (subtype) { + case NXAST_SNAT__OBSOLETE: return -1; + case NXAST_RESUBMIT: return sizeof(struct nx_action_resubmit); + case NXAST_SET_TUNNEL: return sizeof(struct nx_action_set_tunnel); + case NXAST_DROP_SPOOFED_ARP: + return sizeof(struct nx_action_drop_spoofed_arp); + case NXAST_SET_QUEUE: return sizeof(struct nx_action_set_queue); + case NXAST_POP_QUEUE: return sizeof(struct nx_action_pop_queue); + case NXAST_REG_MOVE: return sizeof(struct nx_action_reg_move); + case NXAST_REG_LOAD: return sizeof(struct nx_action_reg_load); + case NXAST_NOTE: return -1; + case NXAST_SET_TUNNEL64: return sizeof(struct nx_action_set_tunnel64); + case NXAST_MULTIPATH: return sizeof(struct nx_action_multipath); + default: return -1; + } +} + static void ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah) { - switch (ntohs(nah->subtype)) { - case NXAST_RESUBMIT: { - const struct nx_action_resubmit *nar = (struct nx_action_resubmit *)nah; - ds_put_format(string, "resubmit:"); - ofp_print_port_name(string, ntohs(nar->in_port)); - break; - } + uint16_t subtype = ntohs(nah->subtype); + int required_len = nx_action_len(subtype); + int len = ntohs(nah->len); - case NXAST_SET_TUNNEL: { - const struct nx_action_set_tunnel *nast = - (struct nx_action_set_tunnel *)nah; - ds_put_format(string, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id)); - break; + if (required_len != -1 && required_len != len) { + ds_put_format(string, "***Nicira action %"PRIu16" wrong length: %d***", + subtype, len); + return; } - case NXAST_DROP_SPOOFED_ARP: - ds_put_cstr(string, "drop_spoofed_arp"); - break; + if (subtype <= TYPE_MAXIMUM(enum nx_action_subtype)) { + const struct nx_action_set_tunnel64 *nast64; + const struct nx_action_set_tunnel *nast; + const struct nx_action_set_queue *nasq; + const struct nx_action_resubmit *nar; + const struct nx_action_reg_move *move; + const struct nx_action_reg_load *load; + const struct nx_action_multipath *nam; + + switch ((enum nx_action_subtype) subtype) { + case NXAST_RESUBMIT: + nar = (struct nx_action_resubmit *)nah; + ds_put_format(string, "resubmit:"); + ofp_print_port_name(string, ntohs(nar->in_port)); + return; - case NXAST_SET_QUEUE: { - const struct nx_action_set_queue *nasq = - (struct nx_action_set_queue *)nah; - ds_put_format(string, "set_queue:%u", ntohl(nasq->queue_id)); - break; - } + case NXAST_SET_TUNNEL: + nast = (struct nx_action_set_tunnel *)nah; + ds_put_format(string, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id)); + return; - case NXAST_POP_QUEUE: - ds_put_cstr(string, "pop_queue"); - break; + case NXAST_DROP_SPOOFED_ARP: + ds_put_cstr(string, "drop_spoofed_arp"); + return; - case NXAST_NOTE: - print_note(string, (const struct nx_action_note *) nah); - break; + case NXAST_SET_QUEUE: + nasq = (struct nx_action_set_queue *)nah; + ds_put_format(string, "set_queue:%u", ntohl(nasq->queue_id)); + return; - default: - ds_put_format(string, "***unknown Nicira action:%d***", - ntohs(nah->subtype)); + case NXAST_POP_QUEUE: + ds_put_cstr(string, "pop_queue"); + return; + + case NXAST_NOTE: + print_note(string, (const struct nx_action_note *) nah); + return; + + case NXAST_REG_MOVE: + move = (const struct nx_action_reg_move *) nah; + nxm_format_reg_move(move, string); + return; + + case NXAST_REG_LOAD: + load = (const struct nx_action_reg_load *) nah; + nxm_format_reg_load(load, string); + return; + + case NXAST_SET_TUNNEL64: + nast64 = (const struct nx_action_set_tunnel64 *) nah; + ds_put_format(string, "set_tunnel64:%#"PRIx64, + ntohll(nast64->tun_id)); + return; + + case NXAST_MULTIPATH: + nam = (const struct nx_action_multipath *) nah; + multipath_format(nam, string); + return; + + case NXAST_SNAT__OBSOLETE: + default: + break; + } + } + + ds_put_format(string, "***unknown Nicira action:%"PRIu16"***", subtype); +} + +static int +ofp_action_len(enum ofp_action_type type) +{ + switch (type) { + case OFPAT_OUTPUT: return sizeof(struct ofp_action_output); + case OFPAT_SET_VLAN_VID: return sizeof(struct ofp_action_vlan_vid); + case OFPAT_SET_VLAN_PCP: return sizeof(struct ofp_action_vlan_pcp); + case OFPAT_STRIP_VLAN: return sizeof(struct ofp_action_header); + case OFPAT_SET_DL_SRC: return sizeof(struct ofp_action_dl_addr); + case OFPAT_SET_DL_DST: return sizeof(struct ofp_action_dl_addr); + case OFPAT_SET_NW_SRC: return sizeof(struct ofp_action_nw_addr); + case OFPAT_SET_NW_DST: return sizeof(struct ofp_action_nw_addr); + case OFPAT_SET_NW_TOS: return sizeof(struct ofp_action_nw_tos); + case OFPAT_SET_TP_SRC: return sizeof(struct ofp_action_tp_port); + case OFPAT_SET_TP_DST: return sizeof(struct ofp_action_tp_port); + case OFPAT_ENQUEUE: return sizeof(struct ofp_action_enqueue); + case OFPAT_VENDOR: return -1; + default: return -1; } } @@ -246,66 +328,10 @@ static int ofp_print_action(struct ds *string, const struct ofp_action_header *ah, size_t actions_len) { - uint16_t type; + enum ofp_action_type type; + int required_len; size_t len; - struct openflow_action { - size_t min_size; - size_t max_size; - }; - - const struct openflow_action of_actions[] = { - [OFPAT_OUTPUT] = { - sizeof(struct ofp_action_output), - sizeof(struct ofp_action_output), - }, - [OFPAT_SET_VLAN_VID] = { - sizeof(struct ofp_action_vlan_vid), - sizeof(struct ofp_action_vlan_vid), - }, - [OFPAT_SET_VLAN_PCP] = { - sizeof(struct ofp_action_vlan_pcp), - sizeof(struct ofp_action_vlan_pcp), - }, - [OFPAT_STRIP_VLAN] = { - sizeof(struct ofp_action_header), - sizeof(struct ofp_action_header), - }, - [OFPAT_SET_DL_SRC] = { - sizeof(struct ofp_action_dl_addr), - sizeof(struct ofp_action_dl_addr), - }, - [OFPAT_SET_DL_DST] = { - sizeof(struct ofp_action_dl_addr), - sizeof(struct ofp_action_dl_addr), - }, - [OFPAT_SET_NW_SRC] = { - sizeof(struct ofp_action_nw_addr), - sizeof(struct ofp_action_nw_addr), - }, - [OFPAT_SET_NW_DST] = { - sizeof(struct ofp_action_nw_addr), - sizeof(struct ofp_action_nw_addr), - }, - [OFPAT_SET_NW_TOS] = { - sizeof(struct ofp_action_nw_tos), - sizeof(struct ofp_action_nw_tos), - }, - [OFPAT_SET_TP_SRC] = { - sizeof(struct ofp_action_tp_port), - sizeof(struct ofp_action_tp_port), - }, - [OFPAT_SET_TP_DST] = { - sizeof(struct ofp_action_tp_port), - sizeof(struct ofp_action_tp_port), - }, - [OFPAT_ENQUEUE] = { - sizeof(struct ofp_action_enqueue), - sizeof(struct ofp_action_enqueue), - } - /* OFPAT_VENDOR is not here, since it would blow up the array size. */ - }; - if (actions_len < sizeof *ah) { ds_put_format(string, "***action array too short for next action***\n"); return -1; @@ -314,7 +340,7 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah, type = ntohs(ah->type); len = ntohs(ah->len); if (actions_len < len) { - ds_put_format(string, "***truncated action %"PRIu16"***\n", type); + ds_put_format(string, "***truncated action %d***\n", (int) type); return -1; } @@ -325,18 +351,16 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah, if ((len % OFP_ACTION_ALIGN) != 0) { ds_put_format(string, - "***action %"PRIu16" length not a multiple of %d***\n", - type, OFP_ACTION_ALIGN); + "***action %d length not a multiple of %d***\n", + (int) type, OFP_ACTION_ALIGN); return -1; } - if (type < ARRAY_SIZE(of_actions)) { - const struct openflow_action *act = &of_actions[type]; - if ((len < act->min_size) || (len > act->max_size)) { - ds_put_format(string, - "***action %"PRIu16" wrong length: %zu***\n", type, len); - return -1; - } + required_len = ofp_action_len(type); + if (required_len >= 0 && len != required_len) { + ds_put_format(string, + "***action %d wrong length: %zu***\n", (int) type, len); + return -1; } switch (type) { @@ -448,7 +472,7 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah, } default: - ds_put_format(string, "(decoder %"PRIu16" not implemented)", type); + ds_put_format(string, "(decoder %d not implemented)", (int) type); break; } @@ -639,6 +663,22 @@ ofp_print_switch_config(struct ds *string, const struct ofp_switch_config *osc) uint16_t flags; flags = ntohs(osc->flags); + + ds_put_cstr(string, " frags="); + switch (flags & OFPC_FRAG_MASK) { + case OFPC_FRAG_NORMAL: + ds_put_cstr(string, "normal"); + flags &= ~OFPC_FRAG_MASK; + break; + case OFPC_FRAG_DROP: + ds_put_cstr(string, "drop"); + flags &= ~OFPC_FRAG_MASK; + break; + case OFPC_FRAG_REASM: + ds_put_cstr(string, "reassemble"); + flags &= ~OFPC_FRAG_MASK; + break; + } if (flags) { ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", flags); } @@ -782,6 +822,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, enum ofputil_msg_code code, int verbosity) { struct flow_mod fm; + bool need_priority; int error; error = ofputil_decode_flow_mod(&fm, oh, NXFF_OPENFLOW10); @@ -814,16 +855,26 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, ds_put_char(s, ' '); if (verbosity >= 3 && code == OFPUTIL_OFPT_FLOW_MOD) { const struct ofp_flow_mod *ofm = (const struct ofp_flow_mod *) oh; - ofp_print_match(s, &ofm->match, verbosity); + + /* ofp_print_match() doesn't print priority. */ + need_priority = true; } else if (verbosity >= 3 && code == OFPUTIL_NXT_FLOW_MOD) { const struct nx_flow_mod *nfm = (const struct nx_flow_mod *) oh; const void *nxm = nfm + 1; - char *nxm_s = nx_match_to_string(nxm, ntohs(nfm->match_len)); + char *nxm_s; + + nxm_s = nx_match_to_string(nxm, ntohs(nfm->match_len)); ds_put_cstr(s, nxm_s); free(nxm_s); + + /* nx_match_to_string() doesn't print priority. */ + need_priority = true; } else { cls_rule_format(&fm.cr, s); + + /* cls_rule_format() does print priority. */ + need_priority = false; } if (ds_last(s) != ' ') { @@ -838,7 +889,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, if (fm.hard_timeout != OFP_FLOW_PERMANENT) { ds_put_format(s, "hard:%"PRIu16" ", fm.hard_timeout); } - if (fm.cr.priority != OFP_DEFAULT_PRIORITY && verbosity >= 3) { + if (fm.cr.priority != OFP_DEFAULT_PRIORITY && need_priority) { ds_put_format(s, "pri:%"PRIu16" ", fm.cr.priority); } if (fm.buffer_id != UINT32_MAX) { @@ -877,6 +928,7 @@ ofp_print_flow_removed(struct ds *string, const struct ofp_header *oh) return; } + ds_put_char(string, ' '); cls_rule_format(&fr.rule, string); ds_put_cstr(string, " reason="); @@ -918,158 +970,52 @@ ofp_print_port_mod(struct ds *string, const struct ofp_port_mod *opm) } } -struct error_type { - int type; - int code; - const char *name; -}; - -static const struct error_type error_types[] = { -#define ERROR_TYPE(TYPE) {TYPE, -1, #TYPE} -#define ERROR_CODE(TYPE, CODE) {TYPE, CODE, #CODE} - ERROR_TYPE(OFPET_HELLO_FAILED), - ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE), - ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_EPERM), - - ERROR_TYPE(OFPET_BAD_REQUEST), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VERSION), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_EPERM), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_EMPTY), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN), - /* Nicira error extensions. */ - ERROR_CODE(OFPET_BAD_REQUEST, NXBRC_NXM_INVALID), - ERROR_CODE(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_TYPE), - ERROR_CODE(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_VALUE), - ERROR_CODE(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_MASK), - ERROR_CODE(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_PREREQ), - ERROR_CODE(OFPET_BAD_REQUEST, NXBRC_NXM_DUP_TYPE), - - ERROR_TYPE(OFPET_BAD_ACTION), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_LEN), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_EPERM), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_TOO_MANY), - - ERROR_TYPE(OFPET_FLOW_MOD_FAILED), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_ALL_TABLES_FULL), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_EPERM), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_EMERG_TIMEOUT), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND), - /* Nicira error extenstions. */ - ERROR_CODE(OFPET_FLOW_MOD_FAILED, NXFMFC_HARDWARE), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, NXFMFC_BAD_TABLE_ID), - - ERROR_TYPE(OFPET_PORT_MOD_FAILED), - ERROR_CODE(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_PORT), - ERROR_CODE(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR) -}; -#define N_ERROR_TYPES ARRAY_SIZE(error_types) - -static const char * -lookup_error_type(int type) -{ - const struct error_type *t; - - for (t = error_types; t < &error_types[N_ERROR_TYPES]; t++) { - if (t->type == type && t->code == -1) { - return t->name; - } - } - return "?"; -} - -static const char * -lookup_error_code(int type, int code) -{ - const struct error_type *t; - - for (t = error_types; t < &error_types[N_ERROR_TYPES]; t++) { - if (t->type == type && t->code == code) { - return t->name; - } - } - return "?"; -} - static void ofp_print_error(struct ds *string, int error) { - int type = get_ofp_err_type(error); - int code = get_ofp_err_code(error); if (string->length) { ds_put_char(string, ' '); } - ds_put_format(string, " ***decode error type:%d(%s) code:%d(%s)***", - type, lookup_error_type(type), - code, lookup_error_code(type, code)); -} - -static void -ofp_print_nx_error_msg(struct ds *string, const struct ofp_error_msg *oem) -{ - size_t len = ntohs(oem->header.length); - const struct nx_vendor_error *nve = (struct nx_vendor_error *)oem->data; - int vendor = ntohl(nve->vendor); - int type = ntohs(nve->type); - int code = ntohs(nve->code); - - ds_put_format(string, " vendor:%x type:%d(%s) code:%d(%s) payload:\n", - vendor, - type, lookup_error_type(type), - code, lookup_error_code(type, code)); - - ds_put_hex_dump(string, nve + 1, len - sizeof *oem - sizeof *nve, - 0, true); + ds_put_cstr(string, "***decode error: "); + ofputil_format_error(string, error); + ds_put_cstr(string, "***\n"); } static void ofp_print_error_msg(struct ds *string, const struct ofp_error_msg *oem) { size_t len = ntohs(oem->header.length); - int type = ntohs(oem->type); - int code = ntohs(oem->code); + size_t payload_ofs, payload_len; + const void *payload; + int error; char *s; - - if (type == NXET_VENDOR && code == NXVC_VENDOR_ERROR) { - if (len < sizeof *oem + sizeof(struct nx_vendor_error)) { - ds_put_format(string, - "(***truncated extended error message is %zu bytes " - "when it should be at least %zu***)\n", - len, sizeof(struct nx_vendor_error)); - return; - } - - return ofp_print_nx_error_msg(string, oem); + error = ofputil_decode_error_msg(&oem->header, &payload_ofs); + if (!is_ofp_error(error)) { + ofp_print_error(string, error); + ds_put_hex_dump(string, oem->data, len - sizeof *oem, 0, true); + return; } - ds_put_format(string, " type:%d(%s) code:%d(%s) payload:\n", - type, lookup_error_type(type), - code, lookup_error_code(type, code)); + ds_put_char(string, ' '); + ofputil_format_error(string, error); + ds_put_char(string, '\n'); - switch (type) { + payload = (const uint8_t *) oem + payload_ofs; + payload_len = len - payload_ofs; + switch (get_ofp_err_type(error)) { case OFPET_HELLO_FAILED: - ds_put_printable(string, (char *) oem->data, len - sizeof *oem); + ds_put_printable(string, payload, payload_len); break; case OFPET_BAD_REQUEST: - s = ofp_to_string(oem->data, len - sizeof *oem, 1); + s = ofp_to_string(payload, payload_len, 1); ds_put_cstr(string, s); free(s); break; default: - ds_put_hex_dump(string, oem->data, len - sizeof *oem, 0, true); + ds_put_hex_dump(string, payload, payload_len, 0, true); break; } } @@ -1093,6 +1039,7 @@ ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_header *oh) { const struct ofp_desc_stats *ods = ofputil_stats_body(oh); + ds_put_char(string, '\n'); ds_put_format(string, "Manufacturer: %.*s\n", (int) sizeof ods->mfr_desc, ods->mfr_desc); ds_put_format(string, "Hardware: %.*s\n", @@ -1213,6 +1160,8 @@ ofp_print_nxst_flow_reply(struct ds *string, const struct ofp_header *oh) int match_len; int error; + ds_put_char(string, '\n'); + fs = ofpbuf_try_pull(&b, sizeof *fs); if (!fs) { ds_put_format(string, " ***%td leftover bytes at end***", b.size); @@ -1238,7 +1187,6 @@ ofp_print_nxst_flow_reply(struct ds *string, const struct ofp_header *oh) ofp_print_duration(string, ntohl(fs->duration_sec), ntohl(fs->duration_nsec)); ds_put_format(string, ", table_id=%"PRIu8", ", fs->table_id); - ds_put_format(string, "priority=%"PRIu16", ", ntohs(fs->priority)); ds_put_format(string, "n_packets=%"PRIu64", ", ntohll(fs->packet_count)); ds_put_format(string, "n_bytes=%"PRIu64", ", ntohll(fs->byte_count)); @@ -1268,7 +1216,6 @@ ofp_print_nxst_flow_reply(struct ds *string, const struct ofp_header *oh) ds_put_char(string, ' '); ofp_print_actions(string, (const struct ofp_action_header *) actions, n_actions * sizeof *actions); - ds_put_char(string, '\n'); } } @@ -1314,7 +1261,7 @@ static void ofp_print_ofpst_port_request(struct ds *string, const struct ofp_header *oh) { const struct ofp_port_stats_request *psr = ofputil_stats_body(oh); - ds_put_format(string, "port_no=%"PRIu16, ntohs(psr->port_no)); + ds_put_format(string, " port_no=%"PRIu16, ntohs(psr->port_no)); } static void @@ -1472,8 +1419,8 @@ ofp_print_nxt_status_message(struct ds *string, const struct ofp_header *oh) struct ofpbuf b; ofpbuf_use_const(&b, oh, ntohs(oh->length)); - ofpbuf_pull(&b, sizeof *oh); - ds_put_char(string, '"'); + ofpbuf_pull(&b, sizeof(struct nicira_header)); + ds_put_cstr(string, " \""); ds_put_printable(string, b.data, b.size); ds_put_char(string, '"'); } @@ -1534,6 +1481,9 @@ ofp_to_string__(const struct ofp_header *oh, break; case OFPUTIL_OFPT_HELLO: + ds_put_char(string, '\n'); + ds_put_hex_dump(string, oh + 1, ntohs(oh->length) - sizeof *oh, + 0, true); break; case OFPUTIL_OFPT_ERROR: @@ -1693,14 +1643,17 @@ ofp_to_string(const void *oh_, size_t len, int verbosity) struct ds string = DS_EMPTY_INITIALIZER; const struct ofp_header *oh = oh_; - if (len < sizeof(struct ofp_header)) { - ds_put_cstr(&string, "OpenFlow packet too short:\n"); + if (!len) { + ds_put_cstr(&string, "OpenFlow message is empty\n"); + } else if (len < sizeof(struct ofp_header)) { + ds_put_format(&string, "OpenFlow packet too short (only %zu bytes):\n", + len); } else if (oh->version != OFP_VERSION) { ds_put_format(&string, "Bad OpenFlow version %"PRIu8":\n", oh->version); } else if (ntohs(oh->length) > len) { ds_put_format(&string, - "(***truncated to %zu bytes from %"PRIu16"***)", + "(***truncated to %zu bytes from %"PRIu16"***)\n", len, ntohs(oh->length)); } else if (ntohs(oh->length) < len) { ds_put_format(&string,