X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fofp-print.c;h=30f6d37423d498e07cda18a094bcbab84bec1cf6;hb=b0387df4e0ac796af05765834bb6e7750b8b6ae6;hp=73820e8beb0eb72a484089e491f98639bdda145c;hpb=6767a2cce9a6412b3a41a927c4d56b9f0e1ec36f;p=openvswitch

diff --git a/lib/ofp-print.c b/lib/ofp-print.c
index 73820e8b..30f6d374 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);
@@ -218,6 +219,7 @@ nx_action_len(enum nx_action_subtype subtype)
     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);
+    case NXAST_AUTOPATH: return sizeof (struct nx_action_autopath);
     default: return -1;
     }
 }
@@ -225,7 +227,7 @@ nx_action_len(enum nx_action_subtype subtype)
 static void
 ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah)
 {
-    uint16_t subtype = ntohs(nah->subtype);
+    int subtype = ntohs(nah->subtype);
     int required_len = nx_action_len(subtype);
     int len = ntohs(nah->len);
 
@@ -243,6 +245,7 @@ ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah)
         const struct nx_action_reg_move *move;
         const struct nx_action_reg_load *load;
         const struct nx_action_multipath *nam;
+        const struct nx_action_autopath *naa;
 
         switch ((enum nx_action_subtype) subtype) {
         case NXAST_RESUBMIT:
@@ -294,13 +297,22 @@ ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah)
             multipath_format(nam, string);
             return;
 
+        case NXAST_AUTOPATH:
+            naa = (const struct nx_action_autopath *)nah;
+            ds_put_format(string, "autopath(%u,", ntohl(naa->id));
+            nxm_format_field_bits(string, ntohl(naa->dst),
+                                  nxm_decode_ofs(naa->ofs_nbits),
+                                  nxm_decode_n_bits(naa->ofs_nbits));
+            ds_put_char(string, ')');
+            return;
+
         case NXAST_SNAT__OBSOLETE:
         default:
             break;
         }
     }
 
-    ds_put_format(string, "***unknown Nicira action:%"PRIu16"***", subtype);
+    ds_put_format(string, "***unknown Nicira action:%d***", subtype);
 }
 
 static int
@@ -602,7 +614,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;
         }
     }
@@ -1073,149 +1085,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));
-        }
-        if (fs->hard_timeout != htons(OFP_FLOW_PERMANENT)) {
-            ds_put_format(string, "hard_timeout=%"PRIu16",",
-                          ntohs(fs->hard_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);
         }
-
-        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;
+        if (fs.hard_timeout != OFP_FLOW_PERMANENT) {
+            ds_put_format(string, "hard_timeout=%"PRIu16",", fs.hard_timeout);
         }
 
-        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 +1138,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 +1159,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 +1198,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 +1228,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 +1236,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 +1282,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 +1331,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 +1482,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 +1507,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 +1524,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);