X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-print.c;h=32e8e7c32fe78cbe2e77117abccf2bae1bf7df94;hb=7f740af44fb340fb556560e0ec9c4ae710d76035;hp=5f43b81e4b1abf8f728dabae3a6f19251ec5e43b;hpb=fbd76b2eefbb48ada78624f63d7c94f7e8a0ce7a;p=sliver-openvswitch.git

diff --git a/lib/ofp-print.c b/lib/ofp-print.c
index 5f43b81e4..32e8e7c32 100644
--- a/lib/ofp-print.c
+++ b/lib/ofp-print.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009, 2010 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,6 +39,7 @@
 #include "packets.h"
 #include "pcap.h"
 #include "type-props.h"
+#include "unaligned.h"
 #include "util.h"
 
 static void ofp_print_port_name(struct ds *string, uint16_t port);
@@ -81,7 +82,7 @@ ofp_packet_to_string(const void *data, size_t len, size_t total_len OVS_UNUSED)
     }
     rewind(pcap);
 
-    snprintf(command, sizeof command, "/usr/sbin/tcpdump -e -n -r /dev/fd/%d 2>/dev/null",
+    snprintf(command, sizeof command, "/usr/sbin/tcpdump -t -e -n -r /dev/fd/%d 2>/dev/null",
              fileno(pcap));
     tcpdump = popen(command, "r");
     fclose(pcap);
@@ -602,7 +603,7 @@ ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port)
 
     memcpy(name, port->name, sizeof name);
     for (j = 0; j < sizeof name - 1; j++) {
-        if (!isprint(name[j])) {
+        if (!isprint((unsigned char) name[j])) {
             break;
         }
     }
@@ -749,11 +750,11 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity)
         if (om->dl_type == htons(ETH_TYPE_IP)) {
             if (!(w & OFPFW_NW_PROTO)) {
                 skip_proto = true;
-                if (om->nw_proto == IP_TYPE_ICMP) {
+                if (om->nw_proto == IPPROTO_ICMP) {
                     ds_put_cstr(&f, "icmp,");
-                } else if (om->nw_proto == IP_TYPE_TCP) {
+                } else if (om->nw_proto == IPPROTO_TCP) {
                     ds_put_cstr(&f, "tcp,");
-                } else if (om->nw_proto == IP_TYPE_UDP) {
+                } else if (om->nw_proto == IPPROTO_UDP) {
                     ds_put_cstr(&f, "udp,");
                 } else {
                     ds_put_cstr(&f, "ip,");
@@ -800,7 +801,7 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity)
     }
     print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity,
                "%u", om->nw_tos);
-    if (om->nw_proto == IP_TYPE_ICMP) {
+    if (om->nw_proto == IPPROTO_ICMP) {
         print_wild(&f, "icmp_type=", w & OFPFW_ICMP_TYPE, verbosity,
                    "%d", ntohs(om->icmp_type));
         print_wild(&f, "icmp_code=", w & OFPFW_ICMP_CODE, verbosity,
@@ -1073,149 +1074,52 @@ ofp_print_flow_stats_request(struct ds *string, const struct ofp_header *oh)
         ofp_print_port_name(string, fsr.out_port);
     }
 
+    /* A flow stats request doesn't include a priority, but cls_rule_format()
+     * will print one unless it is OFP_DEFAULT_PRIORITY. */
+    fsr.match.priority = OFP_DEFAULT_PRIORITY;
+
     ds_put_char(string, ' ');
     cls_rule_format(&fsr.match, string);
 }
 
 static void
-ofp_print_ofpst_flow_reply(struct ds *string, const struct ofp_header *oh,
-                           int verbosity)
+ofp_print_flow_stats_reply(struct ds *string, const struct ofp_header *oh)
 {
-    size_t len = ofputil_stats_body_len(oh);
-    const char *body = ofputil_stats_body(oh);
-    const char *pos = body;
-    for (;;) {
-        const struct ofp_flow_stats *fs;
-        ptrdiff_t bytes_left = body + len - pos;
-        size_t length;
+    struct ofpbuf b;
 
-        ds_put_char(string, '\n');
+    ofpbuf_use_const(&b, oh, ntohs(oh->length));
+    for (;;) {
+        struct ofputil_flow_stats fs;
+        int retval;
 
-        if (bytes_left < sizeof *fs) {
-            if (bytes_left != 0) {
-                ds_put_format(string, " ***%td leftover bytes at end***",
-                              bytes_left);
+        retval = ofputil_decode_flow_stats_reply(&fs, &b, NXFF_OPENFLOW10);
+        if (retval) {
+            if (retval != EOF) {
+                ds_put_cstr(string, " ***parse error***");
             }
             break;
         }
 
-        fs = (const void *) pos;
-        length = ntohs(fs->length);
-        if (length < sizeof *fs) {
-            ds_put_format(string, " ***length=%zu shorter than minimum %zu***",
-                          length, sizeof *fs);
-            break;
-        } else if (length > bytes_left) {
-            ds_put_format(string,
-                          " ***length=%zu but only %td bytes left***",
-                          length, bytes_left);
-            break;
-        } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
-            ds_put_format(string,
-                          " ***length=%zu has %zu bytes leftover in "
-                          "final action***",
-                          length,
-                          (length - sizeof *fs) % sizeof fs->actions[0]);
-            break;
-        }
-
-        ds_put_format(string, " cookie=0x%"PRIx64", duration=",
-                      ntohll(fs->cookie));
-        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));
-        if (fs->idle_timeout != htons(OFP_FLOW_PERMANENT)) {
-            ds_put_format(string, "idle_timeout=%"PRIu16",",
-                          ntohs(fs->idle_timeout));
-        }
-        if (fs->hard_timeout != htons(OFP_FLOW_PERMANENT)) {
-            ds_put_format(string, "hard_timeout=%"PRIu16",",
-                          ntohs(fs->hard_timeout));
-        }
-        ofp_print_match(string, &fs->match, verbosity);
-        ds_put_char(string, ' ');
-        ofp_print_actions(string, fs->actions, length - sizeof *fs);
-
-        pos += length;
-     }
-}
-
-static void
-ofp_print_nxst_flow_reply(struct ds *string, const struct ofp_header *oh)
-{
-    struct ofpbuf b;
-
-    ofpbuf_use_const(&b, ofputil_nxstats_body(oh),
-                     ofputil_nxstats_body_len(oh));
-    while (b.size > 0) {
-        const struct nx_flow_stats *fs;
-        union ofp_action *actions;
-        struct cls_rule rule;
-        size_t actions_len, n_actions;
-        size_t length;
-        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);
-            break;
-        }
-
-        length = ntohs(fs->length);
-        if (length < sizeof *fs) {
-            ds_put_format(string, " ***nx_flow_stats claims length %zu***",
-                          length);
-            break;
-        }
-
-        match_len = ntohs(fs->match_len);
-        if (match_len > length - sizeof *fs) {
-            ds_put_format(string, " ***length=%zu match_len=%d***",
-                          length, match_len);
-            break;
-        }
-
         ds_put_format(string, " cookie=0x%"PRIx64", duration=",
-                      ntohll(fs->cookie));
-        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, "n_packets=%"PRIu64", ",
-                    ntohll(fs->packet_count));
-        ds_put_format(string, "n_bytes=%"PRIu64", ", ntohll(fs->byte_count));
-        if (fs->idle_timeout != htons(OFP_FLOW_PERMANENT)) {
-            ds_put_format(string, "idle_timeout=%"PRIu16",",
-                          ntohs(fs->idle_timeout));
+                      ntohll(fs.cookie));
+        ofp_print_duration(string, fs.duration_sec, fs.duration_nsec);
+        ds_put_format(string, ", table_id=%"PRIu8", ", fs.table_id);
+        ds_put_format(string, "n_packets=%"PRIu64", ", fs.packet_count);
+        ds_put_format(string, "n_bytes=%"PRIu64", ", fs.byte_count);
+        if (fs.idle_timeout != OFP_FLOW_PERMANENT) {
+            ds_put_format(string, "idle_timeout=%"PRIu16",", fs.idle_timeout);
         }
-        if (fs->hard_timeout != htons(OFP_FLOW_PERMANENT)) {
-            ds_put_format(string, "hard_timeout=%"PRIu16",",
-                          ntohs(fs->hard_timeout));
+        if (fs.hard_timeout != OFP_FLOW_PERMANENT) {
+            ds_put_format(string, "hard_timeout=%"PRIu16",", fs.hard_timeout);
         }
 
-        error = nx_pull_match(&b, match_len, ntohs(fs->priority), &rule);
-        if (error) {
-            ofp_print_error(string, error);
-            break;
-        }
-
-        actions_len = length - sizeof *fs - ROUND_UP(match_len, 8);
-        error = ofputil_pull_actions(&b, actions_len, &actions, &n_actions);
-        if (error) {
-            ofp_print_error(string, error);
-            break;
-        }
-
-        cls_rule_format(&rule, string);
+        cls_rule_format(&fs.rule, string);
         ds_put_char(string, ' ');
-        ofp_print_actions(string, (const struct ofp_action_header *) actions,
-                          n_actions * sizeof *actions);
+        ofp_print_actions(string,
+                          (const struct ofp_action_header *) fs.actions,
+                          fs.n_actions * sizeof *fs.actions);
      }
 }
 
@@ -1223,8 +1127,10 @@ static void
 ofp_print_ofp_aggregate_stats_reply (
     struct ds *string, const struct ofp_aggregate_stats_reply *asr)
 {
-    ds_put_format(string, " packet_count=%"PRIu64, ntohll(asr->packet_count));
-    ds_put_format(string, " byte_count=%"PRIu64, ntohll(asr->byte_count));
+    ds_put_format(string, " packet_count=%"PRIu64,
+                  ntohll(get_32aligned_be64(&asr->packet_count)));
+    ds_put_format(string, " byte_count=%"PRIu64,
+                  ntohll(get_32aligned_be64(&asr->byte_count)));
     ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count));
 }
 
@@ -1242,10 +1148,12 @@ ofp_print_nxst_aggregate_reply(struct ds *string,
 }
 
 static void print_port_stat(struct ds *string, const char *leader,
-                            uint64_t stat, int more)
+                            const ovs_32aligned_be64 *statp, int more)
 {
+    uint64_t stat = ntohll(get_32aligned_be64(statp));
+
     ds_put_cstr(string, leader);
-    if (stat != -1) {
+    if (stat != UINT64_MAX) {
         ds_put_format(string, "%"PRIu64, stat);
     } else {
         ds_put_char(string, '?');
@@ -1279,20 +1187,20 @@ ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh,
         ds_put_format(string, "  port %2"PRIu16": ", ntohs(ps->port_no));
 
         ds_put_cstr(string, "rx ");
-        print_port_stat(string, "pkts=", ntohll(ps->rx_packets), 1);
-        print_port_stat(string, "bytes=", ntohll(ps->rx_bytes), 1);
-        print_port_stat(string, "drop=", ntohll(ps->rx_dropped), 1);
-        print_port_stat(string, "errs=", ntohll(ps->rx_errors), 1);
-        print_port_stat(string, "frame=", ntohll(ps->rx_frame_err), 1);
-        print_port_stat(string, "over=", ntohll(ps->rx_over_err), 1);
-        print_port_stat(string, "crc=", ntohll(ps->rx_crc_err), 0);
+        print_port_stat(string, "pkts=", &ps->rx_packets, 1);
+        print_port_stat(string, "bytes=", &ps->rx_bytes, 1);
+        print_port_stat(string, "drop=", &ps->rx_dropped, 1);
+        print_port_stat(string, "errs=", &ps->rx_errors, 1);
+        print_port_stat(string, "frame=", &ps->rx_frame_err, 1);
+        print_port_stat(string, "over=", &ps->rx_over_err, 1);
+        print_port_stat(string, "crc=", &ps->rx_crc_err, 0);
 
         ds_put_cstr(string, "           tx ");
-        print_port_stat(string, "pkts=", ntohll(ps->tx_packets), 1);
-        print_port_stat(string, "bytes=", ntohll(ps->tx_bytes), 1);
-        print_port_stat(string, "drop=", ntohll(ps->tx_dropped), 1);
-        print_port_stat(string, "errs=", ntohll(ps->tx_errors), 1);
-        print_port_stat(string, "coll=", ntohll(ps->collisions), 0);
+        print_port_stat(string, "pkts=", &ps->tx_packets, 1);
+        print_port_stat(string, "bytes=", &ps->tx_bytes, 1);
+        print_port_stat(string, "drop=", &ps->tx_dropped, 1);
+        print_port_stat(string, "errs=", &ps->tx_errors, 1);
+        print_port_stat(string, "coll=", &ps->collisions, 0);
     }
 }
 
@@ -1309,8 +1217,7 @@ ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh,
 
     for (; n--; ts++) {
         char name[OFP_MAX_TABLE_NAME_LEN + 1];
-        strncpy(name, ts->name, sizeof name);
-        name[OFP_MAX_TABLE_NAME_LEN] = '\0';
+        ovs_strlcpy(name, ts->name, sizeof name);
 
         ds_put_format(string, "  %d: %-8s: ", ts->table_id, name);
         ds_put_format(string, "wild=0x%05"PRIx32", ", ntohl(ts->wildcards));
@@ -1318,9 +1225,9 @@ ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh,
         ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
         ds_put_cstr(string, "               ");
         ds_put_format(string, "lookup=%"PRIu64", ",
-                    ntohll(ts->lookup_count));
+                      ntohll(get_32aligned_be64(&ts->lookup_count)));
         ds_put_format(string, "matched=%"PRIu64"\n",
-                    ntohll(ts->matched_count));
+                      ntohll(get_32aligned_be64(&ts->matched_count)));
      }
 }
 
@@ -1364,9 +1271,9 @@ ofp_print_ofpst_queue_reply(struct ds *string, const struct ofp_header *oh,
         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);
+        print_port_stat(string, "bytes=", &qs->tx_bytes, 1);
+        print_port_stat(string, "pkts=", &qs->tx_packets, 1);
+        print_port_stat(string, "errors=", &qs->tx_errors, 0);
     }
 }
 
@@ -1413,18 +1320,6 @@ ofp_print_echo(struct ds *string, const struct ofp_header *oh, int verbosity)
     }
 }
 
-static void
-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(struct nicira_header));
-    ds_put_cstr(string, " \"");
-    ds_put_printable(string, b.data, b.size);
-    ds_put_char(string, '"');
-}
-
 static void
 ofp_print_nxt_tun_id_from_cookie(struct ds *string,
                                  const struct nxt_tun_id_cookie *ntic)
@@ -1576,8 +1471,9 @@ ofp_to_string__(const struct ofp_header *oh,
         break;
 
     case OFPUTIL_OFPST_FLOW_REPLY:
+    case OFPUTIL_NXST_FLOW_REPLY:
         ofp_print_stats_reply(string, oh);
-        ofp_print_ofpst_flow_reply(string, oh, verbosity);
+        ofp_print_flow_stats_reply(string, oh);
         break;
 
     case OFPUTIL_OFPST_QUEUE_REPLY:
@@ -1600,11 +1496,6 @@ ofp_to_string__(const struct ofp_header *oh,
         ofp_print_ofpst_aggregate_reply(string, oh);
         break;
 
-    case OFPUTIL_NXT_STATUS_REQUEST:
-    case OFPUTIL_NXT_STATUS_REPLY:
-        ofp_print_nxt_status_message(string, oh);
-        break;
-
     case OFPUTIL_NXT_TUN_ID_FROM_COOKIE:
         ofp_print_nxt_tun_id_from_cookie(string, msg);
         break;
@@ -1622,10 +1513,6 @@ ofp_to_string__(const struct ofp_header *oh,
         ofp_print_flow_mod(string, msg, code, verbosity);
         break;
 
-    case OFPUTIL_NXST_FLOW_REPLY:
-        ofp_print_nxst_flow_reply(string, oh);
-        break;
-
     case OFPUTIL_NXST_AGGREGATE_REPLY:
         ofp_print_stats_reply(string, oh);
         ofp_print_nxst_aggregate_reply(string, msg);