lib/ofp-print.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira Networks.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "ofp-print.h"
  19
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <sys/types.h>
  23 #include <netinet/in.h>
  24 #include <sys/wait.h>
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <ctype.h>
  28
  29 #include "bundle.h"
  30 #include "byte-order.h"
  31 #include "compiler.h"
  32 #include "dynamic-string.h"
  33 #include "flow.h"
  34 #include "learn.h"
  35 #include "multipath.h"
  36 #include "meta-flow.h"
  37 #include "nx-match.h"
  38 #include "ofp-errors.h"
  39 #include "ofp-util.h"
  40 #include "ofpbuf.h"
  41 #include "openflow/openflow.h"
  42 #include "openflow/nicira-ext.h"
  43 #include "packets.h"
  44 #include "pcap.h"
  45 #include "type-props.h"
  46 #include "unaligned.h"
  47 #include "util.h"
  48
  49 static void ofp_print_queue_name(struct ds *string, uint32_t port);
  50 static void ofp_print_error(struct ds *, enum ofperr);
  51
  52
  53 /* Returns a string that represents the contents of the Ethernet frame in the
  54  * 'len' bytes starting at 'data'.  The caller must free the returned string.*/
  55 char *
  56 ofp_packet_to_string(const void *data, size_t len)
  57 {
  58     struct ds ds = DS_EMPTY_INITIALIZER;
  59     struct ofpbuf buf;
  60     struct flow flow;
  61
  62     ofpbuf_use_const(&buf, data, len);
  63     flow_extract(&buf, 0, 0, 0, &flow);
  64     flow_format(&ds, &flow);
  65
  66     if (buf.l7) {
  67         if (flow.nw_proto == IPPROTO_TCP) {
  68             struct tcp_header *th = buf.l4;
  69             ds_put_format(&ds, " tcp_csum:%"PRIx16,
  70                           ntohs(th->tcp_csum));
  71         } else if (flow.nw_proto == IPPROTO_UDP) {
  72             struct udp_header *uh = buf.l4;
  73             ds_put_format(&ds, " udp_csum:%"PRIx16,
  74                           ntohs(uh->udp_csum));
  75         }
  76     }
  77
  78     ds_put_char(&ds, '\n');
  79
  80     return ds_cstr(&ds);
  81 }
  82
  83 static const char *
  84 ofp_packet_in_reason_to_string(enum ofp_packet_in_reason reason)
  85 {
  86     static char s[32];
  87
  88     switch (reason) {
  89     case OFPR_NO_MATCH:
  90         return "no_match";
  91     case OFPR_ACTION:
  92         return "action";
  93     case OFPR_INVALID_TTL:
  94         return "invalid_ttl";
  95     default:
  96         sprintf(s, "%d", (int) reason);
  97         return s;
  98     }
  99 }
 100
 101 static void
 102 ofp_print_packet_in(struct ds *string, const struct ofp_header *oh,
 103                     int verbosity)
 104 {
 105     struct ofputil_packet_in pin;
 106     int error;
 107     int i;
 108
 109     error = ofputil_decode_packet_in(&pin, oh);
 110     if (error) {
 111         ofp_print_error(string, error);
 112         return;
 113     }
 114
 115     if (pin.table_id) {
 116         ds_put_format(string, " table_id=%"PRIu8, pin.table_id);
 117     }
 118
 119     if (pin.cookie) {
 120         ds_put_format(string, " cookie=0x%"PRIx64, ntohll(pin.cookie));
 121     }
 122
 123     ds_put_format(string, " total_len=%"PRIu16" in_port=", pin.total_len);
 124     ofputil_format_port(pin.fmd.in_port, string);
 125
 126     if (pin.fmd.tun_id_mask) {
 127         ds_put_format(string, " tun_id=0x%"PRIx64, ntohll(pin.fmd.tun_id));
 128         if (pin.fmd.tun_id_mask != htonll(UINT64_MAX)) {
 129             ds_put_format(string, "/0x%"PRIx64, ntohll(pin.fmd.tun_id_mask));
 130         }
 131     }
 132
 133     for (i = 0; i < FLOW_N_REGS; i++) {
 134         if (pin.fmd.reg_masks[i]) {
 135             ds_put_format(string, " reg%d=0x%"PRIx32, i, pin.fmd.regs[i]);
 136             if (pin.fmd.reg_masks[i] != UINT32_MAX) {
 137                 ds_put_format(string, "/0x%"PRIx32, pin.fmd.reg_masks[i]);
 138             }
 139         }
 140     }
 141
 142     ds_put_format(string, " (via %s)",
 143                   ofp_packet_in_reason_to_string(pin.reason));
 144
 145     ds_put_format(string, " data_len=%zu", pin.packet_len);
 146     if (pin.buffer_id == UINT32_MAX) {
 147         ds_put_format(string, " (unbuffered)");
 148         if (pin.total_len != pin.packet_len) {
 149             ds_put_format(string, " (***total_len != data_len***)");
 150         }
 151     } else {
 152         ds_put_format(string, " buffer=0x%08"PRIx32, pin.buffer_id);
 153         if (pin.total_len < pin.packet_len) {
 154             ds_put_format(string, " (***total_len < data_len***)");
 155         }
 156     }
 157     ds_put_char(string, '\n');
 158
 159     if (verbosity > 0) {
 160         char *packet = ofp_packet_to_string(pin.packet, pin.packet_len);
 161         ds_put_cstr(string, packet);
 162         free(packet);
 163     }
 164 }
 165
 166 static void
 167 print_note(struct ds *string, const struct nx_action_note *nan)
 168 {
 169     size_t len;
 170     size_t i;
 171
 172     ds_put_cstr(string, "note:");
 173     len = ntohs(nan->len) - offsetof(struct nx_action_note, note);
 174     for (i = 0; i < len; i++) {
 175         if (i) {
 176             ds_put_char(string, '.');
 177         }
 178         ds_put_format(string, "%02"PRIx8, nan->note[i]);
 179     }
 180 }
 181
 182 static void
 183 ofp_print_action(struct ds *s, const union ofp_action *a,
 184                  enum ofputil_action_code code)
 185 {
 186     const struct ofp_action_enqueue *oae;
 187     const struct ofp_action_dl_addr *oada;
 188     const struct nx_action_set_tunnel64 *nast64;
 189     const struct nx_action_set_tunnel *nast;
 190     const struct nx_action_set_queue *nasq;
 191     const struct nx_action_resubmit *nar;
 192     const struct nx_action_reg_move *move;
 193     const struct nx_action_reg_load *load;
 194     const struct nx_action_multipath *nam;
 195     const struct nx_action_autopath *naa;
 196     const struct nx_action_output_reg *naor;
 197     struct mf_subfield subfield;
 198     uint16_t port;
 199
 200     switch (code) {
 201     case OFPUTIL_OFPAT_OUTPUT:
 202         port = ntohs(a->output.port);
 203         if (port < OFPP_MAX) {
 204             ds_put_format(s, "output:%"PRIu16, port);
 205         } else {
 206             ofputil_format_port(port, s);
 207             if (port == OFPP_CONTROLLER) {
 208                 if (a->output.max_len != htons(0)) {
 209                     ds_put_format(s, ":%"PRIu16, ntohs(a->output.max_len));
 210                 } else {
 211                     ds_put_cstr(s, ":all");
 212                 }
 213             }
 214         }
 215         break;
 216
 217     case OFPUTIL_OFPAT_ENQUEUE:
 218         oae = (const struct ofp_action_enqueue *) a;
 219         ds_put_format(s, "enqueue:");
 220         ofputil_format_port(ntohs(oae->port), s);
 221         ds_put_format(s, "q%"PRIu32, ntohl(oae->queue_id));
 222         break;
 223
 224     case OFPUTIL_OFPAT_SET_VLAN_VID:
 225         ds_put_format(s, "mod_vlan_vid:%"PRIu16,
 226                       ntohs(a->vlan_vid.vlan_vid));
 227         break;
 228
 229     case OFPUTIL_OFPAT_SET_VLAN_PCP:
 230         ds_put_format(s, "mod_vlan_pcp:%"PRIu8, a->vlan_pcp.vlan_pcp);
 231         break;
 232
 233     case OFPUTIL_OFPAT_STRIP_VLAN:
 234         ds_put_cstr(s, "strip_vlan");
 235         break;
 236
 237     case OFPUTIL_OFPAT_SET_DL_SRC:
 238         oada = (const struct ofp_action_dl_addr *) a;
 239         ds_put_format(s, "mod_dl_src:"ETH_ADDR_FMT,
 240                       ETH_ADDR_ARGS(oada->dl_addr));
 241         break;
 242
 243     case OFPUTIL_OFPAT_SET_DL_DST:
 244         oada = (const struct ofp_action_dl_addr *) a;
 245         ds_put_format(s, "mod_dl_dst:"ETH_ADDR_FMT,
 246                       ETH_ADDR_ARGS(oada->dl_addr));
 247         break;
 248
 249     case OFPUTIL_OFPAT_SET_NW_SRC:
 250         ds_put_format(s, "mod_nw_src:"IP_FMT, IP_ARGS(&a->nw_addr.nw_addr));
 251         break;
 252
 253     case OFPUTIL_OFPAT_SET_NW_DST:
 254         ds_put_format(s, "mod_nw_dst:"IP_FMT, IP_ARGS(&a->nw_addr.nw_addr));
 255         break;
 256
 257     case OFPUTIL_OFPAT_SET_NW_TOS:
 258         ds_put_format(s, "mod_nw_tos:%d", a->nw_tos.nw_tos);
 259         break;
 260
 261     case OFPUTIL_OFPAT_SET_TP_SRC:
 262         ds_put_format(s, "mod_tp_src:%d", ntohs(a->tp_port.tp_port));
 263         break;
 264
 265     case OFPUTIL_OFPAT_SET_TP_DST:
 266         ds_put_format(s, "mod_tp_dst:%d", ntohs(a->tp_port.tp_port));
 267         break;
 268
 269     case OFPUTIL_NXAST_RESUBMIT:
 270         nar = (struct nx_action_resubmit *)a;
 271         ds_put_format(s, "resubmit:");
 272         ofputil_format_port(ntohs(nar->in_port), s);
 273         break;
 274
 275     case OFPUTIL_NXAST_RESUBMIT_TABLE:
 276         nar = (struct nx_action_resubmit *)a;
 277         ds_put_format(s, "resubmit(");
 278         if (nar->in_port != htons(OFPP_IN_PORT)) {
 279             ofputil_format_port(ntohs(nar->in_port), s);
 280         }
 281         ds_put_char(s, ',');
 282         if (nar->table != 255) {
 283             ds_put_format(s, "%"PRIu8, nar->table);
 284         }
 285         ds_put_char(s, ')');
 286         break;
 287
 288     case OFPUTIL_NXAST_SET_TUNNEL:
 289         nast = (struct nx_action_set_tunnel *)a;
 290         ds_put_format(s, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id));
 291         break;
 292
 293     case OFPUTIL_NXAST_SET_QUEUE:
 294         nasq = (struct nx_action_set_queue *)a;
 295         ds_put_format(s, "set_queue:%u", ntohl(nasq->queue_id));
 296         break;
 297
 298     case OFPUTIL_NXAST_POP_QUEUE:
 299         ds_put_cstr(s, "pop_queue");
 300         break;
 301
 302     case OFPUTIL_NXAST_NOTE:
 303         print_note(s, (const struct nx_action_note *) a);
 304         break;
 305
 306     case OFPUTIL_NXAST_REG_MOVE:
 307         move = (const struct nx_action_reg_move *) a;
 308         nxm_format_reg_move(move, s);
 309         break;
 310
 311     case OFPUTIL_NXAST_REG_LOAD:
 312         load = (const struct nx_action_reg_load *) a;
 313         nxm_format_reg_load(load, s);
 314         break;
 315
 316     case OFPUTIL_NXAST_SET_TUNNEL64:
 317         nast64 = (const struct nx_action_set_tunnel64 *) a;
 318         ds_put_format(s, "set_tunnel64:%#"PRIx64,
 319                       ntohll(nast64->tun_id));
 320         break;
 321
 322     case OFPUTIL_NXAST_MULTIPATH:
 323         nam = (const struct nx_action_multipath *) a;
 324         multipath_format(nam, s);
 325         break;
 326
 327     case OFPUTIL_NXAST_AUTOPATH:
 328         naa = (const struct nx_action_autopath *)a;
 329         ds_put_format(s, "autopath(%u,", ntohl(naa->id));
 330         nxm_decode(&subfield, naa->dst, naa->ofs_nbits);
 331         mf_format_subfield(&subfield, s);
 332         ds_put_char(s, ')');
 333         break;
 334
 335     case OFPUTIL_NXAST_BUNDLE:
 336     case OFPUTIL_NXAST_BUNDLE_LOAD:
 337         bundle_format((const struct nx_action_bundle *) a, s);
 338         break;
 339
 340     case OFPUTIL_NXAST_OUTPUT_REG:
 341         naor = (const struct nx_action_output_reg *) a;
 342         ds_put_cstr(s, "output:");
 343         nxm_decode(&subfield, naor->src, naor->ofs_nbits);
 344         mf_format_subfield(&subfield, s);
 345         break;
 346
 347     case OFPUTIL_NXAST_LEARN:
 348         learn_format((const struct nx_action_learn *) a, s);
 349         break;
 350
 351     case OFPUTIL_NXAST_DEC_TTL:
 352         ds_put_cstr(s, "dec_ttl");
 353         break;
 354
 355     case OFPUTIL_NXAST_EXIT:
 356         ds_put_cstr(s, "exit");
 357         break;
 358
 359     default:
 360         break;
 361     }
 362 }
 363
 364 void
 365 ofp_print_actions(struct ds *string, const union ofp_action *actions,
 366                   size_t n_actions)
 367 {
 368     const union ofp_action *a;
 369     size_t left;
 370
 371     ds_put_cstr(string, "actions=");
 372     if (!n_actions) {
 373         ds_put_cstr(string, "drop");
 374     }
 375
 376     OFPUTIL_ACTION_FOR_EACH (a, left, actions, n_actions) {
 377         int code = ofputil_decode_action(a);
 378         if (code >= 0) {
 379             if (a != actions) {
 380                 ds_put_cstr(string, ",");
 381             }
 382             ofp_print_action(string, a, code);
 383         } else {
 384             ofp_print_error(string, -code);
 385         }
 386     }
 387     if (left > 0) {
 388         ds_put_format(string, " ***%zu leftover bytes following actions",
 389                       left * sizeof *a);
 390     }
 391 }
 392
 393 static void
 394 ofp_print_packet_out(struct ds *string, const struct ofp_packet_out *opo,
 395                      int verbosity)
 396 {
 397     struct ofputil_packet_out po;
 398     enum ofperr error;
 399
 400     error = ofputil_decode_packet_out(&po, opo);
 401     if (error) {
 402         ofp_print_error(string, error);
 403         return;
 404     }
 405
 406     ds_put_cstr(string, " in_port=");
 407     ofputil_format_port(po.in_port, string);
 408
 409     ds_put_char(string, ' ');
 410     ofp_print_actions(string, po.actions, po.n_actions);
 411
 412     if (po.buffer_id == UINT32_MAX) {
 413         ds_put_format(string, " data_len=%d", po.packet_len);
 414         if (verbosity > 0 && po.packet_len > 0) {
 415             char *packet = ofp_packet_to_string(po.packet, po.packet_len);
 416             ds_put_char(string, '\n');
 417             ds_put_cstr(string, packet);
 418             free(packet);
 419         }
 420     } else {
 421         ds_put_format(string, " buffer=0x%08"PRIx32, po.buffer_id);
 422     }
 423     ds_put_char(string, '\n');
 424 }
 425
 426 /* qsort comparison function. */
 427 static int
 428 compare_ports(const void *a_, const void *b_)
 429 {
 430     const struct ofp_phy_port *a = a_;
 431     const struct ofp_phy_port *b = b_;
 432     uint16_t ap = ntohs(a->port_no);
 433     uint16_t bp = ntohs(b->port_no);
 434
 435     return ap < bp ? -1 : ap > bp;
 436 }
 437
 438 struct bit_name {
 439     uint32_t bit;
 440     const char *name;
 441 };
 442
 443 static void
 444 ofp_print_bit_names(struct ds *string, uint32_t bits,
 445                     const struct bit_name bit_names[])
 446 {
 447     int n = 0;
 448
 449     if (!bits) {
 450         ds_put_cstr(string, "0");
 451         return;
 452     }
 453
 454     for (; bits && bit_names->name; bit_names++) {
 455         if (bits & bit_names->bit) {
 456             if (n++) {
 457                 ds_put_char(string, ' ');
 458             }
 459             ds_put_cstr(string, bit_names->name);
 460             bits &= ~bit_names->bit;
 461         }
 462     }
 463
 464     if (bits) {
 465         if (n++) {
 466             ds_put_char(string, ' ');
 467         }
 468         ds_put_format(string, "0x%"PRIx32, bits);
 469     }
 470 }
 471
 472 static void
 473 ofp_print_port_features(struct ds *string, uint32_t features)
 474 {
 475     static const struct bit_name feature_bits[] = {
 476         { OFPPF_10MB_HD,    "10MB-HD" },
 477         { OFPPF_10MB_FD,    "10MB-FD" },
 478         { OFPPF_100MB_HD,   "100MB-HD" },
 479         { OFPPF_100MB_FD,   "100MB-FD" },
 480         { OFPPF_1GB_HD,     "1GB-HD" },
 481         { OFPPF_1GB_FD,     "1GB-FD" },
 482         { OFPPF_10GB_FD,    "10GB-FD" },
 483         { OFPPF_COPPER,     "COPPER" },
 484         { OFPPF_FIBER,      "FIBER" },
 485         { OFPPF_AUTONEG,    "AUTO_NEG" },
 486         { OFPPF_PAUSE,      "AUTO_PAUSE" },
 487         { OFPPF_PAUSE_ASYM, "AUTO_PAUSE_ASYM" },
 488         { 0,                NULL },
 489     };
 490
 491     ofp_print_bit_names(string, features, feature_bits);
 492     ds_put_char(string, '\n');
 493 }
 494
 495 static void
 496 ofp_print_port_config(struct ds *string, uint32_t config)
 497 {
 498     static const struct bit_name config_bits[] = {
 499         { OFPPC_PORT_DOWN,    "PORT_DOWN" },
 500         { OFPPC_NO_STP,       "NO_STP" },
 501         { OFPPC_NO_RECV,      "NO_RECV" },
 502         { OFPPC_NO_RECV_STP,  "NO_RECV_STP" },
 503         { OFPPC_NO_FLOOD,     "NO_FLOOD" },
 504         { OFPPC_NO_FWD,       "NO_FWD" },
 505         { OFPPC_NO_PACKET_IN, "NO_PACKET_IN" },
 506         { 0,                  NULL },
 507     };
 508
 509     ofp_print_bit_names(string, config, config_bits);
 510     ds_put_char(string, '\n');
 511 }
 512
 513 static void
 514 ofp_print_port_state(struct ds *string, uint32_t state)
 515 {
 516     static const struct bit_name state_bits[] = {
 517         { OFPPS_LINK_DOWN, "LINK_DOWN" },
 518         { 0,               NULL },
 519     };
 520     uint32_t stp_state;
 521
 522     /* The STP state is a 2-bit field so it doesn't fit in with the bitmask
 523      * pattern.  We have to special case it.
 524      *
 525      * OVS doesn't support STP, so this field will always be 0 if we are
 526      * talking to OVS, so we'd always print STP_LISTEN in that case.
 527      * Therefore, we don't print anything at all if the value is STP_LISTEN, to
 528      * avoid confusing users. */
 529     stp_state = state & OFPPS_STP_MASK;
 530     if (stp_state) {
 531         ds_put_cstr(string, (stp_state == OFPPS_STP_LEARN ? "STP_LEARN"
 532                              : stp_state == OFPPS_STP_FORWARD ? "STP_FORWARD"
 533                              : "STP_BLOCK"));
 534         state &= ~OFPPS_STP_MASK;
 535         if (state) {
 536             ofp_print_bit_names(string, state, state_bits);
 537         }
 538     } else {
 539         ofp_print_bit_names(string, state, state_bits);
 540     }
 541     ds_put_char(string, '\n');
 542 }
 543
 544 static void
 545 ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port)
 546 {
 547     char name[OFP_MAX_PORT_NAME_LEN];
 548     int j;
 549
 550     memcpy(name, port->name, sizeof name);
 551     for (j = 0; j < sizeof name - 1; j++) {
 552         if (!isprint((unsigned char) name[j])) {
 553             break;
 554         }
 555     }
 556     name[j] = '\0';
 557
 558     ds_put_char(string, ' ');
 559     ofputil_format_port(ntohs(port->port_no), string);
 560     ds_put_format(string, "(%s): addr:"ETH_ADDR_FMT"\n",
 561                   name, ETH_ADDR_ARGS(port->hw_addr));
 562
 563     ds_put_cstr(string, "     config:     ");
 564     ofp_print_port_config(string, ntohl(port->config));
 565
 566     ds_put_cstr(string, "     state:      ");
 567     ofp_print_port_state(string, ntohl(port->state));
 568
 569     if (port->curr) {
 570         ds_put_format(string, "     current:    ");
 571         ofp_print_port_features(string, ntohl(port->curr));
 572     }
 573     if (port->advertised) {
 574         ds_put_format(string, "     advertised: ");
 575         ofp_print_port_features(string, ntohl(port->advertised));
 576     }
 577     if (port->supported) {
 578         ds_put_format(string, "     supported:  ");
 579         ofp_print_port_features(string, ntohl(port->supported));
 580     }
 581     if (port->peer) {
 582         ds_put_format(string, "     peer:       ");
 583         ofp_print_port_features(string, ntohl(port->peer));
 584     }
 585 }
 586
 587 static void
 588 ofp_print_switch_features(struct ds *string,
 589                           const struct ofp_switch_features *osf)
 590 {
 591     size_t len = ntohs(osf->header.length);
 592     struct ofp_phy_port *port_list;
 593     int n_ports;
 594     int i;
 595
 596     ds_put_format(string, " ver:0x%x, dpid:%016"PRIx64"\n",
 597             osf->header.version, ntohll(osf->datapath_id));
 598     ds_put_format(string, "n_tables:%d, n_buffers:%d\n", osf->n_tables,
 599             ntohl(osf->n_buffers));
 600     ds_put_format(string, "features: capabilities:%#x, actions:%#x\n",
 601            ntohl(osf->capabilities), ntohl(osf->actions));
 602
 603     n_ports = (len - sizeof *osf) / sizeof *osf->ports;
 604
 605     port_list = xmemdup(osf->ports, len - sizeof *osf);
 606     qsort(port_list, n_ports, sizeof *port_list, compare_ports);
 607     for (i = 0; i < n_ports; i++) {
 608         ofp_print_phy_port(string, &port_list[i]);
 609     }
 610     free(port_list);
 611 }
 612
 613 static void
 614 ofp_print_switch_config(struct ds *string, const struct ofp_switch_config *osc)
 615 {
 616     enum ofp_config_flags flags;
 617
 618     flags = ntohs(osc->flags);
 619
 620     ds_put_format(string, " frags=%s", ofputil_frag_handling_to_string(flags));
 621     flags &= ~OFPC_FRAG_MASK;
 622
 623     if (flags & OFPC_INVALID_TTL_TO_CONTROLLER) {
 624         ds_put_format(string, " invalid_ttl_to_controller");
 625         flags &= ~OFPC_INVALID_TTL_TO_CONTROLLER;
 626     }
 627
 628     if (flags) {
 629         ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", flags);
 630     }
 631
 632     ds_put_format(string, " miss_send_len=%"PRIu16"\n", ntohs(osc->miss_send_len));
 633 }
 634
 635 static void print_wild(struct ds *string, const char *leader, int is_wild,
 636             int verbosity, const char *format, ...)
 637             __attribute__((format(printf, 5, 6)));
 638
 639 static void print_wild(struct ds *string, const char *leader, int is_wild,
 640                        int verbosity, const char *format, ...)
 641 {
 642     if (is_wild && verbosity < 2) {
 643         return;
 644     }
 645     ds_put_cstr(string, leader);
 646     if (!is_wild) {
 647         va_list args;
 648
 649         va_start(args, format);
 650         ds_put_format_valist(string, format, args);
 651         va_end(args);
 652     } else {
 653         ds_put_char(string, '*');
 654     }
 655     ds_put_char(string, ',');
 656 }
 657
 658 static void
 659 print_ip_netmask(struct ds *string, const char *leader, ovs_be32 ip,
 660                  uint32_t wild_bits, int verbosity)
 661 {
 662     if (wild_bits >= 32 && verbosity < 2) {
 663         return;
 664     }
 665     ds_put_cstr(string, leader);
 666     if (wild_bits < 32) {
 667         ds_put_format(string, IP_FMT, IP_ARGS(&ip));
 668         if (wild_bits) {
 669             ds_put_format(string, "/%d", 32 - wild_bits);
 670         }
 671     } else {
 672         ds_put_char(string, '*');
 673     }
 674     ds_put_char(string, ',');
 675 }
 676
 677 void
 678 ofp_print_match(struct ds *f, const struct ofp_match *om, int verbosity)
 679 {
 680     char *s = ofp_match_to_string(om, verbosity);
 681     ds_put_cstr(f, s);
 682     free(s);
 683 }
 684
 685 char *
 686 ofp_match_to_string(const struct ofp_match *om, int verbosity)
 687 {
 688     struct ds f = DS_EMPTY_INITIALIZER;
 689     uint32_t w = ntohl(om->wildcards);
 690     bool skip_type = false;
 691     bool skip_proto = false;
 692
 693     if (!(w & OFPFW_DL_TYPE)) {
 694         skip_type = true;
 695         if (om->dl_type == htons(ETH_TYPE_IP)) {
 696             if (!(w & OFPFW_NW_PROTO)) {
 697                 skip_proto = true;
 698                 if (om->nw_proto == IPPROTO_ICMP) {
 699                     ds_put_cstr(&f, "icmp,");
 700                 } else if (om->nw_proto == IPPROTO_TCP) {
 701                     ds_put_cstr(&f, "tcp,");
 702                 } else if (om->nw_proto == IPPROTO_UDP) {
 703                     ds_put_cstr(&f, "udp,");
 704                 } else {
 705                     ds_put_cstr(&f, "ip,");
 706                     skip_proto = false;
 707                 }
 708             } else {
 709                 ds_put_cstr(&f, "ip,");
 710             }
 711         } else if (om->dl_type == htons(ETH_TYPE_ARP)) {
 712             ds_put_cstr(&f, "arp,");
 713         } else {
 714             skip_type = false;
 715         }
 716     }
 717     print_wild(&f, "in_port=", w & OFPFW_IN_PORT, verbosity,
 718                "%d", ntohs(om->in_port));
 719     print_wild(&f, "dl_vlan=", w & OFPFW_DL_VLAN, verbosity,
 720                "%d", ntohs(om->dl_vlan));
 721     print_wild(&f, "dl_vlan_pcp=", w & OFPFW_DL_VLAN_PCP, verbosity,
 722                "%d", om->dl_vlan_pcp);
 723     print_wild(&f, "dl_src=", w & OFPFW_DL_SRC, verbosity,
 724                ETH_ADDR_FMT, ETH_ADDR_ARGS(om->dl_src));
 725     print_wild(&f, "dl_dst=", w & OFPFW_DL_DST, verbosity,
 726                ETH_ADDR_FMT, ETH_ADDR_ARGS(om->dl_dst));
 727     if (!skip_type) {
 728         print_wild(&f, "dl_type=", w & OFPFW_DL_TYPE, verbosity,
 729                    "0x%04x", ntohs(om->dl_type));
 730     }
 731     print_ip_netmask(&f, "nw_src=", om->nw_src,
 732                      (w & OFPFW_NW_SRC_MASK) >> OFPFW_NW_SRC_SHIFT, verbosity);
 733     print_ip_netmask(&f, "nw_dst=", om->nw_dst,
 734                      (w & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT, verbosity);
 735     if (!skip_proto) {
 736         if (om->dl_type == htons(ETH_TYPE_ARP)) {
 737             print_wild(&f, "arp_op=", w & OFPFW_NW_PROTO, verbosity,
 738                        "%u", om->nw_proto);
 739         } else {
 740             print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity,
 741                        "%u", om->nw_proto);
 742         }
 743     }
 744     print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity,
 745                "%u", om->nw_tos);
 746     if (om->nw_proto == IPPROTO_ICMP) {
 747         print_wild(&f, "icmp_type=", w & OFPFW_ICMP_TYPE, verbosity,
 748                    "%d", ntohs(om->tp_src));
 749         print_wild(&f, "icmp_code=", w & OFPFW_ICMP_CODE, verbosity,
 750                    "%d", ntohs(om->tp_dst));
 751     } else {
 752         print_wild(&f, "tp_src=", w & OFPFW_TP_SRC, verbosity,
 753                    "%d", ntohs(om->tp_src));
 754         print_wild(&f, "tp_dst=", w & OFPFW_TP_DST, verbosity,
 755                    "%d", ntohs(om->tp_dst));
 756     }
 757     if (ds_last(&f) == ',') {
 758         f.length--;
 759     }
 760     return ds_cstr(&f);
 761 }
 762
 763 static void
 764 ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh,
 765                    enum ofputil_msg_code code, int verbosity)
 766 {
 767     struct ofputil_flow_mod fm;
 768     bool need_priority;
 769     enum ofperr error;
 770
 771     error = ofputil_decode_flow_mod(&fm, oh, true);
 772     if (error) {
 773         ofp_print_error(s, error);
 774         return;
 775     }
 776
 777     ds_put_char(s, ' ');
 778     switch (fm.command) {
 779     case OFPFC_ADD:
 780         ds_put_cstr(s, "ADD");
 781         break;
 782     case OFPFC_MODIFY:
 783         ds_put_cstr(s, "MOD");
 784         break;
 785     case OFPFC_MODIFY_STRICT:
 786         ds_put_cstr(s, "MOD_STRICT");
 787         break;
 788     case OFPFC_DELETE:
 789         ds_put_cstr(s, "DEL");
 790         break;
 791     case OFPFC_DELETE_STRICT:
 792         ds_put_cstr(s, "DEL_STRICT");
 793         break;
 794     default:
 795         ds_put_format(s, "cmd:%d", fm.command);
 796     }
 797     if (fm.table_id != 0) {
 798         ds_put_format(s, " table:%d", fm.table_id);
 799     }
 800
 801     ds_put_char(s, ' ');
 802     if (verbosity >= 3 && code == OFPUTIL_OFPT_FLOW_MOD) {
 803         const struct ofp_flow_mod *ofm = (const struct ofp_flow_mod *) oh;
 804         ofp_print_match(s, &ofm->match, verbosity);
 805
 806         /* ofp_print_match() doesn't print priority. */
 807         need_priority = true;
 808     } else if (verbosity >= 3 && code == OFPUTIL_NXT_FLOW_MOD) {
 809         const struct nx_flow_mod *nfm = (const struct nx_flow_mod *) oh;
 810         const void *nxm = nfm + 1;
 811         char *nxm_s;
 812
 813         nxm_s = nx_match_to_string(nxm, ntohs(nfm->match_len));
 814         ds_put_cstr(s, nxm_s);
 815         free(nxm_s);
 816
 817         /* nx_match_to_string() doesn't print priority. */
 818         need_priority = true;
 819     } else {
 820         cls_rule_format(&fm.cr, s);
 821
 822         /* cls_rule_format() does print priority. */
 823         need_priority = false;
 824     }
 825
 826     if (ds_last(s) != ' ') {
 827         ds_put_char(s, ' ');
 828     }
 829     if (fm.cookie != htonll(0)) {
 830         ds_put_format(s, "cookie:0x%"PRIx64" ", ntohll(fm.cookie));
 831     }
 832     if (fm.idle_timeout != OFP_FLOW_PERMANENT) {
 833         ds_put_format(s, "idle:%"PRIu16" ", fm.idle_timeout);
 834     }
 835     if (fm.hard_timeout != OFP_FLOW_PERMANENT) {
 836         ds_put_format(s, "hard:%"PRIu16" ", fm.hard_timeout);
 837     }
 838     if (fm.cr.priority != OFP_DEFAULT_PRIORITY && need_priority) {
 839         ds_put_format(s, "pri:%"PRIu16" ", fm.cr.priority);
 840     }
 841     if (fm.buffer_id != UINT32_MAX) {
 842         ds_put_format(s, "buf:0x%"PRIx32" ", fm.buffer_id);
 843     }
 844     if (fm.flags != 0) {
 845         uint16_t flags = fm.flags;
 846
 847         if (flags & OFPFF_SEND_FLOW_REM) {
 848             ds_put_cstr(s, "send_flow_rem ");
 849         }
 850         if (flags & OFPFF_CHECK_OVERLAP) {
 851             ds_put_cstr(s, "check_overlap ");
 852         }
 853         if (flags & OFPFF_EMERG) {
 854             ds_put_cstr(s, "emerg ");
 855         }
 856
 857         flags &= ~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP | OFPFF_EMERG);
 858         if (flags) {
 859             ds_put_format(s, "flags:0x%"PRIx16" ", flags);
 860         }
 861     }
 862
 863     ofp_print_actions(s, fm.actions, fm.n_actions);
 864 }
 865
 866 static void
 867 ofp_print_duration(struct ds *string, unsigned int sec, unsigned int nsec)
 868 {
 869     ds_put_format(string, "%u", sec);
 870     if (nsec > 0) {
 871         ds_put_format(string, ".%09u", nsec);
 872         while (string->string[string->length - 1] == '0') {
 873             string->length--;
 874         }
 875     }
 876     ds_put_char(string, 's');
 877 }
 878
 879 static const char *
 880 ofp_flow_removed_reason_to_string(enum ofp_flow_removed_reason reason)
 881 {
 882     static char s[32];
 883
 884     switch (reason) {
 885     case OFPRR_IDLE_TIMEOUT:
 886         return "idle";
 887     case OFPRR_HARD_TIMEOUT:
 888         return "hard";
 889     case OFPRR_DELETE:
 890         return "delete";
 891     default:
 892         sprintf(s, "%d", (int) reason);
 893         return s;
 894     }
 895 }
 896
 897 static void
 898 ofp_print_flow_removed(struct ds *string, const struct ofp_header *oh)
 899 {
 900     struct ofputil_flow_removed fr;
 901     enum ofperr error;
 902
 903     error = ofputil_decode_flow_removed(&fr, oh);
 904     if (error) {
 905         ofp_print_error(string, error);
 906         return;
 907     }
 908
 909     ds_put_char(string, ' ');
 910     cls_rule_format(&fr.rule, string);
 911
 912     ds_put_format(string, " reason=%s",
 913                   ofp_flow_removed_reason_to_string(fr.reason));
 914
 915     if (fr.cookie != htonll(0)) {
 916         ds_put_format(string, " cookie:0x%"PRIx64, ntohll(fr.cookie));
 917     }
 918     ds_put_cstr(string, " duration");
 919     ofp_print_duration(string, fr.duration_sec, fr.duration_nsec);
 920     ds_put_format(string, " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n",
 921          fr.idle_timeout, fr.packet_count, fr.byte_count);
 922 }
 923
 924 static void
 925 ofp_print_port_mod(struct ds *string, const struct ofp_port_mod *opm)
 926 {
 927     ds_put_format(string, "port: %d: addr:"ETH_ADDR_FMT", config: %#x, mask:%#x\n",
 928             ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr),
 929             ntohl(opm->config), ntohl(opm->mask));
 930     ds_put_format(string, "     advertise: ");
 931     if (opm->advertise) {
 932         ofp_print_port_features(string, ntohl(opm->advertise));
 933     } else {
 934         ds_put_format(string, "UNCHANGED\n");
 935     }
 936 }
 937
 938 static void
 939 ofp_print_error(struct ds *string, enum ofperr error)
 940 {
 941     if (string->length) {
 942         ds_put_char(string, ' ');
 943     }
 944     ds_put_format(string, "***decode error: %s***\n", ofperr_get_name(error));
 945 }
 946
 947 static void
 948 ofp_print_error_msg(struct ds *string, const struct ofp_error_msg *oem)
 949 {
 950     size_t len = ntohs(oem->header.length);
 951     size_t payload_ofs, payload_len;
 952     const void *payload;
 953     enum ofperr error;
 954     char *s;
 955
 956     error = ofperr_decode_msg(&oem->header, &payload_ofs);
 957     if (!error) {
 958         ds_put_cstr(string, "***decode error***");
 959         ds_put_hex_dump(string, oem->data, len - sizeof *oem, 0, true);
 960         return;
 961     }
 962
 963     ds_put_format(string, " %s\n", ofperr_get_name(error));
 964
 965     payload = (const uint8_t *) oem + payload_ofs;
 966     payload_len = len - payload_ofs;
 967     if (error == OFPERR_OFPHFC_INCOMPATIBLE || error == OFPERR_OFPHFC_EPERM) {
 968         ds_put_printable(string, payload, payload_len);
 969     } else {
 970         s = ofp_to_string(payload, payload_len, 1);
 971         ds_put_cstr(string, s);
 972         free(s);
 973     }
 974 }
 975
 976 static void
 977 ofp_print_port_status(struct ds *string, const struct ofp_port_status *ops)
 978 {
 979     if (ops->reason == OFPPR_ADD) {
 980         ds_put_format(string, " ADD:");
 981     } else if (ops->reason == OFPPR_DELETE) {
 982         ds_put_format(string, " DEL:");
 983     } else if (ops->reason == OFPPR_MODIFY) {
 984         ds_put_format(string, " MOD:");
 985     }
 986
 987     ofp_print_phy_port(string, &ops->desc);
 988 }
 989
 990 static void
 991 ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_desc_stats *ods)
 992 {
 993     ds_put_char(string, '\n');
 994     ds_put_format(string, "Manufacturer: %.*s\n",
 995             (int) sizeof ods->mfr_desc, ods->mfr_desc);
 996     ds_put_format(string, "Hardware: %.*s\n",
 997             (int) sizeof ods->hw_desc, ods->hw_desc);
 998     ds_put_format(string, "Software: %.*s\n",
 999             (int) sizeof ods->sw_desc, ods->sw_desc);
1000     ds_put_format(string, "Serial Num: %.*s\n",
1001             (int) sizeof ods->serial_num, ods->serial_num);
1002     ds_put_format(string, "DP Description: %.*s\n",
1003             (int) sizeof ods->dp_desc, ods->dp_desc);
1004 }
1005
1006 static void
1007 ofp_print_flow_stats_request(struct ds *string,
1008                              const struct ofp_stats_msg *osm)
1009 {
1010     struct ofputil_flow_stats_request fsr;
1011     enum ofperr error;
1012
1013     error = ofputil_decode_flow_stats_request(&fsr, &osm->header);
1014     if (error) {
1015         ofp_print_error(string, error);
1016         return;
1017     }
1018
1019     if (fsr.table_id != 0xff) {
1020         ds_put_format(string, " table=%"PRIu8, fsr.table_id);
1021     }
1022
1023     if (fsr.out_port != OFPP_NONE) {
1024         ds_put_cstr(string, " out_port=");
1025         ofputil_format_port(fsr.out_port, string);
1026     }
1027
1028     /* A flow stats request doesn't include a priority, but cls_rule_format()
1029      * will print one unless it is OFP_DEFAULT_PRIORITY. */
1030     fsr.match.priority = OFP_DEFAULT_PRIORITY;
1031
1032     ds_put_char(string, ' ');
1033     cls_rule_format(&fsr.match, string);
1034 }
1035
1036 static void
1037 ofp_print_flow_stats_reply(struct ds *string, const struct ofp_header *oh)
1038 {
1039     struct ofpbuf b;
1040
1041     ofpbuf_use_const(&b, oh, ntohs(oh->length));
1042     for (;;) {
1043         struct ofputil_flow_stats fs;
1044         int retval;
1045
1046         retval = ofputil_decode_flow_stats_reply(&fs, &b, true);
1047         if (retval) {
1048             if (retval != EOF) {
1049                 ds_put_cstr(string, " ***parse error***");
1050             }
1051             break;
1052         }
1053
1054         ds_put_char(string, '\n');
1055
1056         ds_put_format(string, " cookie=0x%"PRIx64", duration=",
1057                       ntohll(fs.cookie));
1058         ofp_print_duration(string, fs.duration_sec, fs.duration_nsec);
1059         ds_put_format(string, ", table=%"PRIu8", ", fs.table_id);
1060         ds_put_format(string, "n_packets=%"PRIu64", ", fs.packet_count);
1061         ds_put_format(string, "n_bytes=%"PRIu64", ", fs.byte_count);
1062         if (fs.idle_timeout != OFP_FLOW_PERMANENT) {
1063             ds_put_format(string, "idle_timeout=%"PRIu16",", fs.idle_timeout);
1064         }
1065         if (fs.hard_timeout != OFP_FLOW_PERMANENT) {
1066             ds_put_format(string, "hard_timeout=%"PRIu16",", fs.hard_timeout);
1067         }
1068         if (fs.idle_age >= 0) {
1069             ds_put_format(string, "idle_age=%d,", fs.idle_age);
1070         }
1071         if (fs.hard_age >= 0 && fs.hard_age != fs.duration_sec) {
1072             ds_put_format(string, "hard_age=%d,", fs.hard_age);
1073         }
1074
1075         cls_rule_format(&fs.rule, string);
1076         if (string->string[string->length - 1] != ' ') {
1077             ds_put_char(string, ' ');
1078         }
1079         ofp_print_actions(string, fs.actions, fs.n_actions);
1080      }
1081 }
1082
1083 static void
1084 ofp_print_ofpst_aggregate_reply(struct ds *string,
1085                                 const struct ofp_aggregate_stats_reply *asr)
1086 {
1087     ds_put_format(string, " packet_count=%"PRIu64,
1088                   ntohll(get_32aligned_be64(&asr->packet_count)));
1089     ds_put_format(string, " byte_count=%"PRIu64,
1090                   ntohll(get_32aligned_be64(&asr->byte_count)));
1091     ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count));
1092 }
1093
1094 static void
1095 ofp_print_nxst_aggregate_reply(struct ds *string,
1096                                const struct nx_aggregate_stats_reply *nasr)
1097 {
1098     ds_put_format(string, " packet_count=%"PRIu64, ntohll(nasr->packet_count));
1099     ds_put_format(string, " byte_count=%"PRIu64, ntohll(nasr->byte_count));
1100     ds_put_format(string, " flow_count=%"PRIu32, ntohl(nasr->flow_count));
1101 }
1102
1103 static void print_port_stat(struct ds *string, const char *leader,
1104                             const ovs_32aligned_be64 *statp, int more)
1105 {
1106     uint64_t stat = ntohll(get_32aligned_be64(statp));
1107
1108     ds_put_cstr(string, leader);
1109     if (stat != UINT64_MAX) {
1110         ds_put_format(string, "%"PRIu64, stat);
1111     } else {
1112         ds_put_char(string, '?');
1113     }
1114     if (more) {
1115         ds_put_cstr(string, ", ");
1116     } else {
1117         ds_put_cstr(string, "\n");
1118     }
1119 }
1120
1121 static void
1122 ofp_print_ofpst_port_request(struct ds *string,
1123                              const struct ofp_port_stats_request *psr)
1124 {
1125     ds_put_format(string, " port_no=%"PRIu16, ntohs(psr->port_no));
1126 }
1127
1128 static void
1129 ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh,
1130                            int verbosity)
1131 {
1132     const struct ofp_port_stats *ps = ofputil_stats_body(oh);
1133     size_t n = ofputil_stats_body_len(oh) / sizeof *ps;
1134     ds_put_format(string, " %zu ports\n", n);
1135     if (verbosity < 1) {
1136         return;
1137     }
1138
1139     for (; n--; ps++) {
1140         ds_put_format(string, "  port %2"PRIu16": ", ntohs(ps->port_no));
1141
1142         ds_put_cstr(string, "rx ");
1143         print_port_stat(string, "pkts=", &ps->rx_packets, 1);
1144         print_port_stat(string, "bytes=", &ps->rx_bytes, 1);
1145         print_port_stat(string, "drop=", &ps->rx_dropped, 1);
1146         print_port_stat(string, "errs=", &ps->rx_errors, 1);
1147         print_port_stat(string, "frame=", &ps->rx_frame_err, 1);
1148         print_port_stat(string, "over=", &ps->rx_over_err, 1);
1149         print_port_stat(string, "crc=", &ps->rx_crc_err, 0);
1150
1151         ds_put_cstr(string, "           tx ");
1152         print_port_stat(string, "pkts=", &ps->tx_packets, 1);
1153         print_port_stat(string, "bytes=", &ps->tx_bytes, 1);
1154         print_port_stat(string, "drop=", &ps->tx_dropped, 1);
1155         print_port_stat(string, "errs=", &ps->tx_errors, 1);
1156         print_port_stat(string, "coll=", &ps->collisions, 0);
1157     }
1158 }
1159
1160 static void
1161 ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh,
1162                             int verbosity)
1163 {
1164     const struct ofp_table_stats *ts = ofputil_stats_body(oh);
1165     size_t n = ofputil_stats_body_len(oh) / sizeof *ts;
1166     ds_put_format(string, " %zu tables\n", n);
1167     if (verbosity < 1) {
1168         return;
1169     }
1170
1171     for (; n--; ts++) {
1172         char name[OFP_MAX_TABLE_NAME_LEN + 1];
1173         ovs_strlcpy(name, ts->name, sizeof name);
1174
1175         ds_put_format(string, "  %d: %-8s: ", ts->table_id, name);
1176         ds_put_format(string, "wild=0x%05"PRIx32", ", ntohl(ts->wildcards));
1177         ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries));
1178         ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
1179         ds_put_cstr(string, "               ");
1180         ds_put_format(string, "lookup=%"PRIu64", ",
1181                       ntohll(get_32aligned_be64(&ts->lookup_count)));
1182         ds_put_format(string, "matched=%"PRIu64"\n",
1183                       ntohll(get_32aligned_be64(&ts->matched_count)));
1184      }
1185 }
1186
1187 static void
1188 ofp_print_queue_name(struct ds *string, uint32_t queue_id)
1189 {
1190     if (queue_id == OFPQ_ALL) {
1191         ds_put_cstr(string, "ALL");
1192     } else {
1193         ds_put_format(string, "%"PRIu32, queue_id);
1194     }
1195 }
1196
1197 static void
1198 ofp_print_ofpst_queue_request(struct ds *string,
1199                               const struct ofp_queue_stats_request *qsr)
1200 {
1201     ds_put_cstr(string, "port=");
1202     ofputil_format_port(ntohs(qsr->port_no), string);
1203
1204     ds_put_cstr(string, " queue=");
1205     ofp_print_queue_name(string, ntohl(qsr->queue_id));
1206 }
1207
1208 static void
1209 ofp_print_ofpst_queue_reply(struct ds *string, const struct ofp_header *oh,
1210                             int verbosity)
1211 {
1212     const struct ofp_queue_stats *qs = ofputil_stats_body(oh);
1213     size_t n = ofputil_stats_body_len(oh) / sizeof *qs;
1214     ds_put_format(string, " %zu queues\n", n);
1215     if (verbosity < 1) {
1216         return;
1217     }
1218
1219     for (; n--; qs++) {
1220         ds_put_cstr(string, "  port ");
1221         ofputil_format_port(ntohs(qs->port_no), string);
1222         ds_put_cstr(string, " queue ");
1223         ofp_print_queue_name(string, ntohl(qs->queue_id));
1224         ds_put_cstr(string, ": ");
1225
1226         print_port_stat(string, "bytes=", &qs->tx_bytes, 1);
1227         print_port_stat(string, "pkts=", &qs->tx_packets, 1);
1228         print_port_stat(string, "errors=", &qs->tx_errors, 0);
1229     }
1230 }
1231
1232 static void
1233 ofp_print_stats_request(struct ds *string, const struct ofp_header *oh)
1234 {
1235     const struct ofp_stats_msg *srq = (const struct ofp_stats_msg *) oh;
1236
1237     if (srq->flags) {
1238         ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***",
1239                       ntohs(srq->flags));
1240     }
1241 }
1242
1243 static void
1244 ofp_print_stats_reply(struct ds *string, const struct ofp_header *oh)
1245 {
1246     const struct ofp_stats_msg *srp = (const struct ofp_stats_msg *) oh;
1247
1248     if (srp->flags) {
1249         uint16_t flags = ntohs(srp->flags);
1250
1251         ds_put_cstr(string, " flags=");
1252         if (flags & OFPSF_REPLY_MORE) {
1253             ds_put_cstr(string, "[more]");
1254             flags &= ~OFPSF_REPLY_MORE;
1255         }
1256         if (flags) {
1257             ds_put_format(string, "[***unknown flags 0x%04"PRIx16"***]",
1258                           flags);
1259         }
1260     }
1261 }
1262
1263 static void
1264 ofp_print_echo(struct ds *string, const struct ofp_header *oh, int verbosity)
1265 {
1266     size_t len = ntohs(oh->length);
1267
1268     ds_put_format(string, " %zu bytes of payload\n", len - sizeof *oh);
1269     if (verbosity > 1) {
1270         ds_put_hex_dump(string, oh + 1, len - sizeof *oh, 0, true);
1271     }
1272 }
1273
1274 static void
1275 ofp_print_nxt_role_message(struct ds *string,
1276                            const struct nx_role_request *nrr)
1277 {
1278     unsigned int role = ntohl(nrr->role);
1279
1280     ds_put_cstr(string, " role=");
1281     if (role == NX_ROLE_OTHER) {
1282         ds_put_cstr(string, "other");
1283     } else if (role == NX_ROLE_MASTER) {
1284         ds_put_cstr(string, "master");
1285     } else if (role == NX_ROLE_SLAVE) {
1286         ds_put_cstr(string, "slave");
1287     } else {
1288         ds_put_format(string, "%u", role);
1289     }
1290 }
1291
1292 static void
1293 ofp_print_nxt_flow_mod_table_id(struct ds *string,
1294                                 const struct nx_flow_mod_table_id *nfmti)
1295 {
1296     ds_put_format(string, " %s", nfmti->set ? "enable" : "disable");
1297 }
1298
1299 static void
1300 ofp_print_nxt_set_flow_format(struct ds *string,
1301                               const struct nx_set_flow_format *nsff)
1302 {
1303     uint32_t format = ntohl(nsff->format);
1304
1305     ds_put_cstr(string, " format=");
1306     if (ofputil_flow_format_is_valid(format)) {
1307         ds_put_cstr(string, ofputil_flow_format_to_string(format));
1308     } else {
1309         ds_put_format(string, "%"PRIu32, format);
1310     }
1311 }
1312
1313 static void
1314 ofp_print_nxt_set_packet_in_format(struct ds *string,
1315                                    const struct nx_set_packet_in_format *nspf)
1316 {
1317     uint32_t format = ntohl(nspf->format);
1318
1319     ds_put_cstr(string, " format=");
1320     if (ofputil_packet_in_format_is_valid(format)) {
1321         ds_put_cstr(string, ofputil_packet_in_format_to_string(format));
1322     } else {
1323         ds_put_format(string, "%"PRIu32, format);
1324     }
1325 }
1326
1327 static const char *
1328 ofp_port_reason_to_string(enum ofp_port_reason reason)
1329 {
1330     static char s[32];
1331
1332     switch (reason) {
1333     case OFPPR_ADD:
1334         return "add";
1335
1336     case OFPPR_DELETE:
1337         return "delete";
1338
1339     case OFPPR_MODIFY:
1340         return "modify";
1341
1342     default:
1343         sprintf(s, "%d", (int) reason);
1344         return s;
1345     }
1346 }
1347
1348 static void
1349 ofp_print_nxt_set_async_config(struct ds *string,
1350                                const struct nx_async_config *nac)
1351 {
1352     int i;
1353
1354     for (i = 0; i < 2; i++) {
1355         int j;
1356
1357         ds_put_format(string, "\n %s:\n", i == 0 ? "master" : "slave");
1358
1359         ds_put_cstr(string, "       PACKET_IN:");
1360         for (j = 0; j < 32; j++) {
1361             if (nac->packet_in_mask[i] & htonl(1u << j)) {
1362                 ds_put_format(string, " %s",
1363                               ofp_packet_in_reason_to_string(j));
1364             }
1365         }
1366         if (!nac->packet_in_mask[i]) {
1367             ds_put_cstr(string, " (off)");
1368         }
1369         ds_put_char(string, '\n');
1370
1371         ds_put_cstr(string, "     PORT_STATUS:");
1372         for (j = 0; j < 32; j++) {
1373             if (nac->port_status_mask[i] & htonl(1u << j)) {
1374                 ds_put_format(string, " %s", ofp_port_reason_to_string(j));
1375             }
1376         }
1377         if (!nac->port_status_mask[i]) {
1378             ds_put_cstr(string, " (off)");
1379         }
1380         ds_put_char(string, '\n');
1381
1382         ds_put_cstr(string, "    FLOW_REMOVED:");
1383         for (j = 0; j < 32; j++) {
1384             if (nac->flow_removed_mask[i] & htonl(1u << j)) {
1385                 ds_put_format(string, " %s",
1386                               ofp_flow_removed_reason_to_string(j));
1387             }
1388         }
1389         if (!nac->flow_removed_mask[i]) {
1390             ds_put_cstr(string, " (off)");
1391         }
1392         ds_put_char(string, '\n');
1393     }
1394 }
1395
1396 static void
1397 ofp_to_string__(const struct ofp_header *oh,
1398                 const struct ofputil_msg_type *type, struct ds *string,
1399                 int verbosity)
1400 {
1401     enum ofputil_msg_code code;
1402     const void *msg = oh;
1403
1404     ds_put_format(string, "%s (xid=0x%"PRIx32"):",
1405                   ofputil_msg_type_name(type), ntohl(oh->xid));
1406
1407     code = ofputil_msg_type_code(type);
1408     switch (code) {
1409     case OFPUTIL_MSG_INVALID:
1410         break;
1411
1412     case OFPUTIL_OFPT_HELLO:
1413         ds_put_char(string, '\n');
1414         ds_put_hex_dump(string, oh + 1, ntohs(oh->length) - sizeof *oh,
1415                         0, true);
1416         break;
1417
1418     case OFPUTIL_OFPT_ERROR:
1419         ofp_print_error_msg(string, msg);
1420         break;
1421
1422     case OFPUTIL_OFPT_ECHO_REQUEST:
1423     case OFPUTIL_OFPT_ECHO_REPLY:
1424         ofp_print_echo(string, oh, verbosity);
1425         break;
1426
1427     case OFPUTIL_OFPT_FEATURES_REQUEST:
1428         break;
1429
1430     case OFPUTIL_OFPT_FEATURES_REPLY:
1431         ofp_print_switch_features(string, msg);
1432         break;
1433
1434     case OFPUTIL_OFPT_GET_CONFIG_REQUEST:
1435         break;
1436
1437     case OFPUTIL_OFPT_GET_CONFIG_REPLY:
1438     case OFPUTIL_OFPT_SET_CONFIG:
1439         ofp_print_switch_config(string, msg);
1440         break;
1441
1442     case OFPUTIL_OFPT_PACKET_IN:
1443     case OFPUTIL_NXT_PACKET_IN:
1444         ofp_print_packet_in(string, msg, verbosity);
1445         break;
1446
1447     case OFPUTIL_OFPT_FLOW_REMOVED:
1448     case OFPUTIL_NXT_FLOW_REMOVED:
1449         ofp_print_flow_removed(string, msg);
1450         break;
1451
1452     case OFPUTIL_OFPT_PORT_STATUS:
1453         ofp_print_port_status(string, msg);
1454         break;
1455
1456     case OFPUTIL_OFPT_PACKET_OUT:
1457         ofp_print_packet_out(string, msg, verbosity);
1458         break;
1459
1460     case OFPUTIL_OFPT_FLOW_MOD:
1461     case OFPUTIL_NXT_FLOW_MOD:
1462         ofp_print_flow_mod(string, msg, code, verbosity);
1463         break;
1464
1465     case OFPUTIL_OFPT_PORT_MOD:
1466         ofp_print_port_mod(string, msg);
1467         break;
1468
1469     case OFPUTIL_OFPT_BARRIER_REQUEST:
1470     case OFPUTIL_OFPT_BARRIER_REPLY:
1471         break;
1472
1473     case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REQUEST:
1474     case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REPLY:
1475         /* XXX */
1476         break;
1477
1478     case OFPUTIL_OFPST_DESC_REQUEST:
1479         ofp_print_stats_request(string, oh);
1480         break;
1481
1482     case OFPUTIL_OFPST_FLOW_REQUEST:
1483     case OFPUTIL_NXST_FLOW_REQUEST:
1484     case OFPUTIL_OFPST_AGGREGATE_REQUEST:
1485     case OFPUTIL_NXST_AGGREGATE_REQUEST:
1486         ofp_print_stats_request(string, oh);
1487         ofp_print_flow_stats_request(string, msg);
1488         break;
1489
1490     case OFPUTIL_OFPST_TABLE_REQUEST:
1491         ofp_print_stats_request(string, oh);
1492         break;
1493
1494     case OFPUTIL_OFPST_PORT_REQUEST:
1495         ofp_print_stats_request(string, oh);
1496         ofp_print_ofpst_port_request(string, msg);
1497         break;
1498
1499     case OFPUTIL_OFPST_QUEUE_REQUEST:
1500         ofp_print_stats_request(string, oh);
1501         ofp_print_ofpst_queue_request(string, msg);
1502         break;
1503
1504     case OFPUTIL_OFPST_DESC_REPLY:
1505         ofp_print_stats_reply(string, oh);
1506         ofp_print_ofpst_desc_reply(string, msg);
1507         break;
1508
1509     case OFPUTIL_OFPST_FLOW_REPLY:
1510     case OFPUTIL_NXST_FLOW_REPLY:
1511         ofp_print_stats_reply(string, oh);
1512         ofp_print_flow_stats_reply(string, oh);
1513         break;
1514
1515     case OFPUTIL_OFPST_QUEUE_REPLY:
1516         ofp_print_stats_reply(string, oh);
1517         ofp_print_ofpst_queue_reply(string, oh, verbosity);
1518         break;
1519
1520     case OFPUTIL_OFPST_PORT_REPLY:
1521         ofp_print_stats_reply(string, oh);
1522         ofp_print_ofpst_port_reply(string, oh, verbosity);
1523         break;
1524
1525     case OFPUTIL_OFPST_TABLE_REPLY:
1526         ofp_print_stats_reply(string, oh);
1527         ofp_print_ofpst_table_reply(string, oh, verbosity);
1528         break;
1529
1530     case OFPUTIL_OFPST_AGGREGATE_REPLY:
1531         ofp_print_stats_reply(string, oh);
1532         ofp_print_ofpst_aggregate_reply(string, msg);
1533         break;
1534
1535     case OFPUTIL_NXT_ROLE_REQUEST:
1536     case OFPUTIL_NXT_ROLE_REPLY:
1537         ofp_print_nxt_role_message(string, msg);
1538         break;
1539
1540     case OFPUTIL_NXT_FLOW_MOD_TABLE_ID:
1541         ofp_print_nxt_flow_mod_table_id(string, msg);
1542         break;
1543
1544     case OFPUTIL_NXT_SET_FLOW_FORMAT:
1545         ofp_print_nxt_set_flow_format(string, msg);
1546         break;
1547
1548     case OFPUTIL_NXT_SET_PACKET_IN_FORMAT:
1549         ofp_print_nxt_set_packet_in_format(string, msg);
1550         break;
1551
1552     case OFPUTIL_NXT_FLOW_AGE:
1553         break;
1554
1555     case OFPUTIL_NXT_SET_ASYNC_CONFIG:
1556         ofp_print_nxt_set_async_config(string, msg);
1557         break;
1558
1559     case OFPUTIL_NXST_AGGREGATE_REPLY:
1560         ofp_print_stats_reply(string, oh);
1561         ofp_print_nxst_aggregate_reply(string, msg);
1562         break;
1563     }
1564 }
1565
1566 /* Composes and returns a string representing the OpenFlow packet of 'len'
1567  * bytes at 'oh' at the given 'verbosity' level.  0 is a minimal amount of
1568  * verbosity and higher numbers increase verbosity.  The caller is responsible
1569  * for freeing the string. */
1570 char *
1571 ofp_to_string(const void *oh_, size_t len, int verbosity)
1572 {
1573     struct ds string = DS_EMPTY_INITIALIZER;
1574     const struct ofp_header *oh = oh_;
1575
1576     if (!len) {
1577         ds_put_cstr(&string, "OpenFlow message is empty\n");
1578     } else if (len < sizeof(struct ofp_header)) {
1579         ds_put_format(&string, "OpenFlow packet too short (only %zu bytes):\n",
1580                       len);
1581     } else if (ntohs(oh->length) > len) {
1582         ds_put_format(&string,
1583                       "(***truncated to %zu bytes from %"PRIu16"***)\n",
1584                       len, ntohs(oh->length));
1585     } else if (ntohs(oh->length) < len) {
1586         ds_put_format(&string,
1587                       "(***only uses %"PRIu16" bytes out of %zu***)\n",
1588                       ntohs(oh->length), len);
1589     } else {
1590         const struct ofputil_msg_type *type;
1591         enum ofperr error;
1592
1593         error = ofputil_decode_msg_type(oh, &type);
1594         if (!error) {
1595             ofp_to_string__(oh, type, &string, verbosity);
1596             if (verbosity >= 5) {
1597                 if (ds_last(&string) != '\n') {
1598                     ds_put_char(&string, '\n');
1599                 }
1600                 ds_put_hex_dump(&string, oh, len, 0, true);
1601             }
1602             if (ds_last(&string) != '\n') {
1603                 ds_put_char(&string, '\n');
1604             }
1605             return ds_steal_cstr(&string);
1606         }
1607
1608         ofp_print_error(&string, error);
1609     }
1610     ds_put_hex_dump(&string, oh, len, 0, true);
1611     return ds_steal_cstr(&string);
1612 }
1613
1614 /* Returns the name for the specified OpenFlow message type as a string,
1615  * e.g. "OFPT_FEATURES_REPLY".  If no name is known, the string returned is a
1616  * hex number, e.g. "0x55".
1617  *
1618  * The caller must free the returned string when it is no longer needed. */
1619 char *
1620 ofp_message_type_to_string(uint8_t type)
1621 {
1622     const char *name;
1623
1624     switch (type) {
1625     case OFPT_HELLO:
1626         name = "HELLO";
1627         break;
1628     case OFPT_ERROR:
1629         name = "ERROR";
1630         break;
1631     case OFPT_ECHO_REQUEST:
1632         name = "ECHO_REQUEST";
1633         break;
1634     case OFPT_ECHO_REPLY:
1635         name = "ECHO_REPLY";
1636         break;
1637     case OFPT_VENDOR:
1638         name = "VENDOR";
1639         break;
1640     case OFPT_FEATURES_REQUEST:
1641         name = "FEATURES_REQUEST";
1642         break;
1643     case OFPT_FEATURES_REPLY:
1644         name = "FEATURES_REPLY";
1645         break;
1646     case OFPT_GET_CONFIG_REQUEST:
1647         name = "GET_CONFIG_REQUEST";
1648         break;
1649     case OFPT_GET_CONFIG_REPLY:
1650         name = "GET_CONFIG_REPLY";
1651         break;
1652     case OFPT_SET_CONFIG:
1653         name = "SET_CONFIG";
1654         break;
1655     case OFPT_PACKET_IN:
1656         name = "PACKET_IN";
1657         break;
1658     case OFPT_FLOW_REMOVED:
1659         name = "FLOW_REMOVED";
1660         break;
1661     case OFPT_PORT_STATUS:
1662         name = "PORT_STATUS";
1663         break;
1664     case OFPT_PACKET_OUT:
1665         name = "PACKET_OUT";
1666         break;
1667     case OFPT_FLOW_MOD:
1668         name = "FLOW_MOD";
1669         break;
1670     case OFPT_PORT_MOD:
1671         name = "PORT_MOD";
1672         break;
1673     case OFPT_STATS_REQUEST:
1674         name = "STATS_REQUEST";
1675         break;
1676     case OFPT_STATS_REPLY:
1677         name = "STATS_REPLY";
1678         break;
1679     case OFPT_BARRIER_REQUEST:
1680         name = "BARRIER_REQUEST";
1681         break;
1682     case OFPT_BARRIER_REPLY:
1683         name = "BARRIER_REPLY";
1684         break;
1685     case OFPT_QUEUE_GET_CONFIG_REQUEST:
1686         name = "QUEUE_GET_CONFIG_REQUEST";
1687         break;
1688     case OFPT_QUEUE_GET_CONFIG_REPLY:
1689         name = "QUEUE_GET_CONFIG_REPLY";
1690         break;
1691     default:
1692         name = NULL;
1693         break;
1694     }
1695
1696     return name ? xasprintf("OFPT_%s", name) : xasprintf("0x%02"PRIx8, type);
1697 }
1698 \f
1699 static void
1700 print_and_free(FILE *stream, char *string)
1701 {
1702     fputs(string, stream);
1703     free(string);
1704 }
1705
1706 /* Pretty-print the OpenFlow packet of 'len' bytes at 'oh' to 'stream' at the
1707  * given 'verbosity' level.  0 is a minimal amount of verbosity and higher
1708  * numbers increase verbosity. */
1709 void
1710 ofp_print(FILE *stream, const void *oh, size_t len, int verbosity)
1711 {
1712     print_and_free(stream, ofp_to_string(oh, len, verbosity));
1713 }
1714
1715 /* Dumps the contents of the Ethernet frame in the 'len' bytes starting at
1716  * 'data' to 'stream'. */
1717 void
1718 ofp_print_packet(FILE *stream, const void *data, size_t len)
1719 {
1720     print_and_free(stream, ofp_packet_to_string(data, len));
1721 }