X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-print.c;h=97fd0653d8c3ae5212420e3c35c03d1903fc2b00;hb=1d87ef5cb22d4d1709af6b4d0460b0c3e2af9a22;hp=b392d83ea507e6eca42221cbe8b3f26ac2fc7139;hpb=dd70b47582e7619367840c5befe9dcfe235e6839;p=sliver-openvswitch.git

diff --git a/lib/ofp-print.c b/lib/ofp-print.c
index b392d83ea..97fd0653d 100644
--- a/lib/ofp-print.c
+++ b/lib/ofp-print.c
@@ -16,19 +16,21 @@
 
 #include <config.h>
 #include "ofp-print.h"
-#include "xtoxll.h"
 
 #include <errno.h>
 #include <inttypes.h>
+#include <sys/types.h>
 #include <netinet/in.h>
 #include <sys/wait.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <ctype.h>
 
+#include "byte-order.h"
 #include "compiler.h"
 #include "dynamic-string.h"
 #include "flow.h"
+#include "ofp-util.h"
 #include "ofpbuf.h"
 #include "openflow/openflow.h"
 #include "openflow/nicira-ext.h"
@@ -37,6 +39,7 @@
 #include "util.h"
 
 static void ofp_print_port_name(struct ds *string, uint16_t port);
+static void ofp_print_queue_name(struct ds *string, uint32_t port);
 
 /* Returns a string that represents the contents of the Ethernet frame in the
  * 'len' bytes starting at 'data' to 'stream' as output by tcpdump.
@@ -92,7 +95,7 @@ ofp_packet_to_string(const void *data, size_t len, size_t total_len OVS_UNUSED)
         if (WEXITSTATUS(status))
             ovs_error(0, "tcpdump exited with status %d", WEXITSTATUS(status));
     } else if (WIFSIGNALED(status)) {
-        ovs_error(0, "tcpdump exited with signal %d", WTERMSIG(status)); 
+        ovs_error(0, "tcpdump exited with signal %d", WTERMSIG(status));
     }
     return ds_cstr(&ds);
 }
@@ -128,25 +131,24 @@ ofp_packet_in(struct ds *string, const void *oh, size_t len, int verbosity)
     ds_put_char(string, '\n');
 
     if (verbosity > 0) {
-        flow_t flow;
+        struct flow flow;
         struct ofpbuf packet;
-        struct ofp_match match;
+
         packet.data = (void *) op->data;
         packet.size = data_len;
-        flow_extract(&packet, ntohs(op->in_port), &flow);
-        flow_to_match(&flow, 0, &match);
-        ofp_print_match(string, &match, verbosity);
+        flow_extract(&packet, 0, ntohs(op->in_port), &flow);
+        flow_format(string, &flow);
         ds_put_char(string, '\n');
     }
     if (verbosity > 1) {
         char *packet = ofp_packet_to_string(op->data, data_len,
-                                            ntohs(op->total_len)); 
+                                            ntohs(op->total_len));
         ds_put_cstr(string, packet);
         free(packet);
     }
 }
 
-static void ofp_print_port_name(struct ds *string, uint16_t port) 
+static void ofp_print_port_name(struct ds *string, uint16_t port)
 {
     const char *name;
     switch (port) {
@@ -181,6 +183,22 @@ 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)
+{
+    size_t len;
+    size_t i;
+
+    ds_put_cstr(string, "note:");
+    len = ntohs(nan->len) - offsetof(struct nx_action_note, note);
+    for (i = 0; i < len; i++) {
+        if (i) {
+            ds_put_char(string, '.');
+        }
+        ds_put_format(string, "%02"PRIx8, nan->note[i]);
+    }
+}
+
 static void
 ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah)
 {
@@ -192,15 +210,41 @@ ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah)
         break;
     }
 
+    case NXAST_SET_TUNNEL: {
+        const struct nx_action_set_tunnel *nast =
+                                            (struct nx_action_set_tunnel *)nah;
+        ds_put_format(string, "set_tunnel:0x%08"PRIx32, ntohl(nast->tun_id));
+        break;
+    }
+
+    case NXAST_DROP_SPOOFED_ARP:
+        ds_put_cstr(string, "drop_spoofed_arp");
+        break;
+
+    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_POP_QUEUE:
+        ds_put_cstr(string, "pop_queue");
+        break;
+
+    case NXAST_NOTE:
+        print_note(string, (const struct nx_action_note *) nah);
+        break;
+
     default:
-        ds_put_format(string, "***unknown Nicira action:%d***\n",
+        ds_put_format(string, "***unknown Nicira action:%d***",
                       ntohs(nah->subtype));
     }
 }
 
 static int
-ofp_print_action(struct ds *string, const struct ofp_action_header *ah, 
-        size_t actions_len) 
+ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
+        size_t actions_len)
 {
     uint16_t type;
     size_t len;
@@ -270,26 +314,31 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
         return -1;
     }
 
-    if ((len % 8) != 0) {
-        ds_put_format(string, 
-                "***action %"PRIu16" length not a multiple of 8***\n",
-                type);
+    if (!len) {
+        ds_put_format(string, "***zero-length action***\n");
+        return 8;
+    }
+
+    if ((len % OFP_ACTION_ALIGN) != 0) {
+        ds_put_format(string,
+                      "***action %"PRIu16" length not a multiple of %d***\n",
+                      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, 
+            ds_put_format(string,
                     "***action %"PRIu16" wrong length: %zu***\n", type, len);
             return -1;
         }
     }
-    
+
     switch (type) {
     case OFPAT_OUTPUT: {
         struct ofp_action_output *oa = (struct ofp_action_output *)ah;
-        uint16_t port = ntohs(oa->port); 
+        uint16_t port = ntohs(oa->port);
         if (port < OFPP_MAX) {
             ds_put_format(string, "output:%"PRIu16, port);
         } else {
@@ -305,6 +354,20 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
         break;
     }
 
+    case OFPAT_ENQUEUE: {
+        struct ofp_action_enqueue *ea = (struct ofp_action_enqueue *)ah;
+        unsigned int port = ntohs(ea->port);
+        unsigned int queue_id = ntohl(ea->queue_id);
+        ds_put_format(string, "enqueue:");
+        if (port != OFPP_IN_PORT) {
+            ds_put_format(string, "%u", port);
+        } else {
+            ds_put_cstr(string, "IN_PORT");
+        }
+        ds_put_format(string, "q%u", queue_id);
+        break;
+    }
+
     case OFPAT_SET_VLAN_VID: {
         struct ofp_action_vlan_vid *va = (struct ofp_action_vlan_vid *)ah;
         ds_put_format(string, "mod_vlan_vid:%"PRIu16, ntohs(va->vlan_vid));
@@ -323,14 +386,14 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
 
     case OFPAT_SET_DL_SRC: {
         struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah;
-        ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT, 
+        ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT,
                 ETH_ADDR_ARGS(da->dl_addr));
         break;
     }
 
     case OFPAT_SET_DL_DST: {
         struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah;
-        ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT, 
+        ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT,
                 ETH_ADDR_ARGS(da->dl_addr));
         break;
     }
@@ -366,7 +429,7 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
     }
 
     case OFPAT_VENDOR: {
-        struct ofp_action_vendor_header *avh 
+        struct ofp_action_vendor_header *avh
                 = (struct ofp_action_vendor_header *)ah;
         if (len < sizeof *avh) {
             ds_put_format(string, "***ofpat_vendor truncated***\n");
@@ -388,9 +451,9 @@ ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
     return len;
 }
 
-void 
+void
 ofp_print_actions(struct ds *string, const struct ofp_action_header *action,
-                  size_t actions_len) 
+                  size_t actions_len)
 {
     uint8_t *p = (uint8_t *)action;
     int len = 0;
@@ -403,7 +466,7 @@ ofp_print_actions(struct ds *string, const struct ofp_action_header *action,
         if (len) {
             ds_put_cstr(string, ",");
         }
-        len = ofp_print_action(string, (struct ofp_action_header *)p, 
+        len = ofp_print_action(string, (struct ofp_action_header *)p,
                 actions_len);
         if (len < 0) {
             return;
@@ -416,7 +479,7 @@ ofp_print_actions(struct ds *string, const struct ofp_action_header *action,
 /* Pretty-print the OFPT_PACKET_OUT packet of 'len' bytes at 'oh' to 'string'
  * at the given 'verbosity' level. */
 static void ofp_packet_out(struct ds *string, const void *oh, size_t len,
-                           int verbosity) 
+                           int verbosity)
 {
     const struct ofp_packet_out *opo = oh;
     size_t actions_len = ntohs(opo->actions_len);
@@ -507,7 +570,7 @@ static void ofp_print_port_features(struct ds *string, uint32_t features)
 static void
 ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port)
 {
-    uint8_t name[OFP_MAX_PORT_NAME_LEN];
+    char name[OFP_MAX_PORT_NAME_LEN];
     int j;
 
     memcpy(name, port->name, sizeof name);
@@ -552,7 +615,7 @@ ofp_print_switch_features(struct ds *string, const void *oh, size_t len,
     int n_ports;
     int i;
 
-    ds_put_format(string, " ver:0x%x, dpid:%016"PRIx64"\n", 
+    ds_put_format(string, " ver:0x%x, dpid:%016"PRIx64"\n",
             osf->header.version, ntohll(osf->datapath_id));
     ds_put_format(string, "n_tables:%d, n_buffers:%d\n", osf->n_tables,
             ntohl(osf->n_buffers));
@@ -564,7 +627,7 @@ ofp_print_switch_features(struct ds *string, const void *oh, size_t len,
     }
     n_ports = (len - sizeof *osf) / sizeof *osf->ports;
 
-    port_list = xmemdup(osf->ports, len - sizeof *osf); 
+    port_list = xmemdup(osf->ports, len - sizeof *osf);
     qsort(port_list, n_ports, sizeof *port_list, compare_ports);
     for (i = 0; i < n_ports; i++) {
         ofp_print_phy_port(string, &port_list[i]);
@@ -590,11 +653,11 @@ ofp_print_switch_config(struct ds *string, const void *oh,
 }
 
 static void print_wild(struct ds *string, const char *leader, int is_wild,
-            int verbosity, const char *format, ...) 
+            int verbosity, const char *format, ...)
             __attribute__((format(printf, 5, 6)));
 
 static void print_wild(struct ds *string, const char *leader, int is_wild,
-                       int verbosity, const char *format, ...) 
+                       int verbosity, const char *format, ...)
 {
     if (is_wild && verbosity < 2) {
         return;
@@ -671,10 +734,13 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity)
             skip_type = false;
         }
     }
+    if (w & NXFW_TUN_ID) {
+        ds_put_cstr(&f, "tun_id_wild,");
+    }
     print_wild(&f, "in_port=", w & OFPFW_IN_PORT, verbosity,
                "%d", ntohs(om->in_port));
     print_wild(&f, "dl_vlan=", w & OFPFW_DL_VLAN, verbosity,
-               "0x%04x", ntohs(om->dl_vlan));
+               "%d", ntohs(om->dl_vlan));
     print_wild(&f, "dl_vlan_pcp=", w & OFPFW_DL_VLAN_PCP, verbosity,
                "%d", om->dl_vlan_pcp);
     print_wild(&f, "dl_src=", w & OFPFW_DL_SRC, verbosity,
@@ -696,10 +762,10 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity)
         } else {
             print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity,
                        "%u", om->nw_proto);
-            print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity,
-                       "%u", om->nw_tos);
         }
     }
+    print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity,
+               "%u", om->nw_tos);
     if (om->nw_proto == IP_TYPE_ICMP) {
         print_wild(&f, "icmp_type=", w & OFPFW_ICMP_TYPE, verbosity,
                    "%d", ntohs(om->icmp_type));
@@ -717,36 +783,55 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity)
 /* Pretty-print the OFPT_FLOW_MOD packet of 'len' bytes at 'oh' to 'string'
  * at the given 'verbosity' level. */
 static void
-ofp_print_flow_mod(struct ds *string, const void *oh, size_t len, 
+ofp_print_flow_mod(struct ds *string, const void *oh, size_t len,
                    int verbosity)
 {
     const struct ofp_flow_mod *ofm = oh;
 
+    ds_put_char(string, ' ');
     ofp_print_match(string, &ofm->match, verbosity);
+    if (ds_last(string) != ' ') {
+        ds_put_char(string, ' ');
+    }
+
     switch (ntohs(ofm->command)) {
     case OFPFC_ADD:
-        ds_put_cstr(string, " ADD: ");
+        ds_put_cstr(string, "ADD:");
         break;
     case OFPFC_MODIFY:
-        ds_put_cstr(string, " MOD: ");
+        ds_put_cstr(string, "MOD:");
         break;
     case OFPFC_MODIFY_STRICT:
-        ds_put_cstr(string, " MOD_STRICT: ");
+        ds_put_cstr(string, "MOD_STRICT:");
         break;
     case OFPFC_DELETE:
-        ds_put_cstr(string, " DEL: ");
+        ds_put_cstr(string, "DEL:");
         break;
     case OFPFC_DELETE_STRICT:
-        ds_put_cstr(string, " DEL_STRICT: ");
+        ds_put_cstr(string, "DEL_STRICT:");
         break;
     default:
-        ds_put_format(string, " cmd:%d ", ntohs(ofm->command));
+        ds_put_format(string, "cmd:%d", ntohs(ofm->command));
     }
-    ds_put_format(string, "cookie:%"PRIx64" idle:%d hard:%d pri:%d "
-            "buf:%#x flags:%"PRIx16" ", ntohll(ofm->cookie), 
-            ntohs(ofm->idle_timeout), ntohs(ofm->hard_timeout),
-            ofm->match.wildcards ? ntohs(ofm->priority) : (uint16_t)-1,
-            ntohl(ofm->buffer_id), ntohs(ofm->flags));
+    if (ofm->cookie != htonll(0)) {
+        ds_put_format(string, " cookie:0x%"PRIx64, ntohll(ofm->cookie));
+    }
+    if (ofm->idle_timeout != htons(OFP_FLOW_PERMANENT)) {
+        ds_put_format(string, " idle:%d", ntohs(ofm->idle_timeout));
+    }
+    if (ofm->hard_timeout != htons(OFP_FLOW_PERMANENT)) {
+        ds_put_format(string, " hard:%d", ntohs(ofm->hard_timeout));
+    }
+    if (ofm->priority != htons(32768)) {
+        ds_put_format(string, " pri:%"PRIu16, ntohs(ofm->priority));
+    }
+    if (ofm->buffer_id != htonl(UINT32_MAX)) {
+        ds_put_format(string, " buf:%#"PRIx32, ntohl(ofm->buffer_id));
+    }
+    if (ofm->flags != htons(0)) {
+        ds_put_format(string, " flags:%"PRIx16, ntohs(ofm->flags));
+    }
+    ds_put_cstr(string, " ");
     ofp_print_actions(string, ofm->actions,
                       len - offsetof(struct ofp_flow_mod, actions));
     ds_put_char(string, '\n');
@@ -755,7 +840,7 @@ ofp_print_flow_mod(struct ds *string, const void *oh, size_t len,
 /* Pretty-print the OFPT_FLOW_REMOVED packet of 'len' bytes at 'oh' to 'string'
  * at the given 'verbosity' level. */
 static void
-ofp_print_flow_removed(struct ds *string, const void *oh, 
+ofp_print_flow_removed(struct ds *string, const void *oh,
                        size_t len OVS_UNUSED, int verbosity)
 {
     const struct ofp_flow_removed *ofr = oh;
@@ -776,13 +861,17 @@ ofp_print_flow_removed(struct ds *string, const void *oh,
         ds_put_format(string, "**%"PRIu8"**", ofr->reason);
         break;
     }
-    ds_put_format(string, 
-         " cookie%"PRIx64" pri%"PRIu16" secs%"PRIu32" nsecs%"PRIu32
-         " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n", 
-         ntohll(ofr->cookie),
-         ofr->match.wildcards ? ntohs(ofr->priority) : (uint16_t)-1,
+
+    if (ofr->cookie != htonll(0)) {
+        ds_put_format(string, " cookie:0x%"PRIx64, ntohll(ofr->cookie));
+    }
+    if (ofr->priority != htons(32768)) {
+        ds_put_format(string, " pri:%"PRIu16, ntohs(ofr->priority));
+    }
+    ds_put_format(string, " secs%"PRIu32" nsecs%"PRIu32
+         " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n",
          ntohl(ofr->duration_sec), ntohl(ofr->duration_nsec),
-         ntohs(ofr->idle_timeout), ntohll(ofr->packet_count), 
+         ntohs(ofr->idle_timeout), ntohll(ofr->packet_count),
          ntohll(ofr->byte_count));
 }
 
@@ -793,7 +882,7 @@ ofp_print_port_mod(struct ds *string, const void *oh, size_t len OVS_UNUSED,
     const struct ofp_port_mod *opm = oh;
 
     ds_put_format(string, "port: %d: addr:"ETH_ADDR_FMT", config: %#x, mask:%#x\n",
-            ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr), 
+            ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr),
             ntohl(opm->config), ntohl(opm->mask));
     ds_put_format(string, "     advertise: ");
     if (opm->advertise) {
@@ -879,7 +968,7 @@ lookup_error_code(int type, int code)
 /* Pretty-print the OFPT_ERROR packet of 'len' bytes at 'oh' to 'string'
  * at the given 'verbosity' level. */
 static void
-ofp_print_error_msg(struct ds *string, const void *oh, size_t len, 
+ofp_print_error_msg(struct ds *string, const void *oh, size_t len,
                        int verbosity OVS_UNUSED)
 {
     const struct ofp_error_msg *oem = oh;
@@ -933,7 +1022,7 @@ ofp_desc_stats_reply(struct ds *string, const void *body,
 {
     const struct ofp_desc_stats *ods = body;
 
-    ds_put_format(string, "Manufacturer: %.*s\n", 
+    ds_put_format(string, "Manufacturer: %.*s\n",
             (int) sizeof ods->mfr_desc, ods->mfr_desc);
     ds_put_format(string, "Hardware: %.*s\n",
             (int) sizeof ods->hw_desc, ods->hw_desc);
@@ -999,13 +1088,13 @@ ofp_flow_stats_reply(struct ds *string, const void *body_, size_t len,
             break;
         }
 
-        ds_put_format(string, "  cookie=%"PRIu64"s, ", ntohll(fs->cookie));
-        ds_put_format(string, "duration_sec=%"PRIu32"s, ", 
+        ds_put_format(string, "  cookie=0x%"PRIx64", ", ntohll(fs->cookie));
+        ds_put_format(string, "duration_sec=%"PRIu32"s, ",
                     ntohl(fs->duration_sec));
-        ds_put_format(string, "duration_nsec=%"PRIu32"s, ", 
+        ds_put_format(string, "duration_nsec=%"PRIu32"ns, ",
                     ntohl(fs->duration_nsec));
         ds_put_format(string, "table_id=%"PRIu8", ", fs->table_id);
-        ds_put_format(string, "priority=%"PRIu16", ", 
+        ds_put_format(string, "priority=%"PRIu16", ",
                     fs->match.wildcards ? ntohs(fs->priority) : (uint16_t)-1);
         ds_put_format(string, "n_packets=%"PRIu64", ",
                     ntohll(fs->packet_count));
@@ -1052,7 +1141,7 @@ ofp_aggregate_stats_reply(struct ds *string, const void *body_,
     ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count));
 }
 
-static void print_port_stat(struct ds *string, const char *leader, 
+static void print_port_stat(struct ds *string, const char *leader,
                             uint64_t stat, int more)
 {
     ds_put_cstr(string, leader);
@@ -1129,13 +1218,60 @@ ofp_table_stats_reply(struct ds *string, const void *body, size_t len,
         ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries));
         ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
         ds_put_cstr(string, "               ");
-        ds_put_format(string, "lookup=%"PRIu64", ", 
+        ds_put_format(string, "lookup=%"PRIu64", ",
                     ntohll(ts->lookup_count));
         ds_put_format(string, "matched=%"PRIu64"\n",
                     ntohll(ts->matched_count));
      }
 }
 
+static void
+ofp_print_queue_name(struct ds *string, uint32_t queue_id)
+{
+    if (queue_id == OFPQ_ALL) {
+        ds_put_cstr(string, "ALL");
+    } else {
+        ds_put_format(string, "%"PRIu32, queue_id);
+    }
+}
+
+static void
+ofp_queue_stats_request(struct ds *string, const void *body_,
+                       size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
+{
+    const struct ofp_queue_stats_request *qsr = body_;
+
+    ds_put_cstr(string, "port=");
+    ofp_print_port_name(string, ntohs(qsr->port_no));
+
+    ds_put_cstr(string, " queue=");
+    ofp_print_queue_name(string, ntohl(qsr->queue_id));
+}
+
+static void
+ofp_queue_stats_reply(struct ds *string, const void *body, size_t len,
+                     int verbosity)
+{
+    const struct ofp_queue_stats *qs = body;
+    size_t n = len / sizeof *qs;
+    ds_put_format(string, " %zu queues\n", n);
+    if (verbosity < 1) {
+        return;
+    }
+
+    for (; n--; qs++) {
+        ds_put_cstr(string, "  port ");
+        ofp_print_port_name(string, ntohs(qs->port_no));
+        ds_put_cstr(string, " queue ");
+        ofp_print_queue_name(string, ntohl(qs->queue_id));
+        ds_put_cstr(string, ": ");
+
+        print_port_stat(string, "bytes=", ntohll(qs->tx_bytes), 1);
+        print_port_stat(string, "pkts=", ntohll(qs->tx_packets), 1);
+        print_port_stat(string, "errors=", ntohll(qs->tx_errors), 0);
+    }
+}
+
 static void
 vendor_stat(struct ds *string, const void *body, size_t len,
             int verbosity OVS_UNUSED)
@@ -1200,11 +1336,19 @@ print_stats(struct ds *string, int type, const void *body, size_t body_len,
         {
             OFPST_PORT,
             "port",
-            { sizeof(struct ofp_port_stats_request), 
-              sizeof(struct ofp_port_stats_request), 
+            { sizeof(struct ofp_port_stats_request),
+              sizeof(struct ofp_port_stats_request),
               ofp_port_stats_request },
             { 0, SIZE_MAX, ofp_port_stats_reply },
         },
+        {
+            OFPST_QUEUE,
+            "queue",
+            { sizeof(struct ofp_queue_stats_request),
+              sizeof(struct ofp_queue_stats_request),
+              ofp_queue_stats_request },
+            { 0, SIZE_MAX, ofp_queue_stats_reply },
+        },
         {
             OFPST_VENDOR,
             "vendor-specific",
@@ -1290,7 +1434,7 @@ ofp_echo(struct ds *string, const void *oh, size_t len, int verbosity)
 
     ds_put_format(string, " %zu bytes of payload\n", len - sizeof *hdr);
     if (verbosity > 1) {
-        ds_put_hex_dump(string, hdr, len - sizeof *hdr, 0, true); 
+        ds_put_hex_dump(string, hdr, len - sizeof *hdr, 0, true);
     }
 }
 
@@ -1456,7 +1600,7 @@ ofp_to_string(const void *oh_, size_t len, int verbosity)
         }
     }
 
-    ds_put_format(&string, "%s (xid=0x%"PRIx32"):", pkt->name, oh->xid);
+    ds_put_format(&string, "%s (xid=0x%"PRIx32"):", pkt->name, ntohl(oh->xid));
 
     if (ntohs(oh->length) > len)
         ds_put_format(&string, " (***truncated to %zu bytes from %"PRIu16"***)",
@@ -1473,7 +1617,7 @@ ofp_to_string(const void *oh_, size_t len, int verbosity)
     } else if (!pkt->printer) {
         if (len > sizeof *oh) {
             ds_put_format(&string, " length=%"PRIu16" (decoder not implemented)\n",
-                          ntohs(oh->length)); 
+                          ntohs(oh->length));
         }
     } else {
         pkt->printer(&string, oh, len, verbosity);
@@ -1515,7 +1659,7 @@ ofp_message_type_to_string(uint8_t type)
 }
 
 static void
-print_and_free(FILE *stream, char *string) 
+print_and_free(FILE *stream, char *string)
 {
     fputs(string, stream);
     free(string);