contrib/tcpdump/print-openflow-1.0.c

   1 /*
   2  * This module implements decoding of OpenFlow protocol version 1.0 (wire
   3  * protocol 0x01). The decoder implements terse (default), detailed (-v) and
   4  * full (-vv) output formats and, as much as each format implies, detects and
   5  * tries to work around sizing anomalies inside the messages. The decoder marks
   6  * up bogus values of selected message fields and decodes partially captured
   7  * messages up to the snapshot end. It is based on the specification below:
   8  *
   9  * [OF10] http://www.openflow.org/documents/openflow-spec-v1.0.0.pdf
  10  *
  11  * Most functions in this file take 3 arguments into account:
  12  * * cp -- the pointer to the first octet to decode
  13  * * len -- the length of the current structure as declared on the wire
  14  * * ep -- the pointer to the end of the captured frame
  15  * They return either the pointer to the next not-yet-decoded part of the frame
  16  * or the value of ep, which means the current frame processing is over as it
  17  * has been fully decoded or is invalid or truncated. This way it is possible
  18  * to chain and nest such functions uniformly to decode an OF1.0 message, which
  19  * consists of several layers of nested structures.
  20  *
  21  * Decoding of Ethernet frames nested in OFPT_PACKET_IN and OFPT_PACKET_OUT
  22  * messages is done only when the verbosity level set by command-line argument
  23  * is "-vvv" or higher. In that case the verbosity level is temporarily
  24  * decremented by 3 during the nested frame decoding. For example, running
  25  * tcpdump with "-vvvv" will do full decoding of OpenFlow and "-v" decoding of
  26  * the nested frames.
  27  *
  28  * Partial decoding of Big Switch Networks vendor extensions is done after the
  29  * oftest (OpenFlow Testing Framework) and Loxigen (library generator) source
  30  * code.
  31  *
  32  *
  33  * Copyright (c) 2013 The TCPDUMP project
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the distribution.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  46  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  47  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  48  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  49  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  50  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  51  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  52  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  53  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  54  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  55  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  56  * POSSIBILITY OF SUCH DAMAGE.
  57  */
  58
  59 /* \summary: OpenFlow protocol version 1.0 printer */
  60
  61 #ifdef HAVE_CONFIG_H
  62 #include "config.h"
  63 #endif
  64
  65 #include <netdissect-stdinc.h>
  66
  67 #include "netdissect.h"
  68 #include "extract.h"
  69 #include "addrtoname.h"
  70 #include "ether.h"
  71 #include "ethertype.h"
  72 #include "ipproto.h"
  73 #include "oui.h"
  74 #include "openflow.h"
  75
  76 static const char tstr[] = " [|openflow]";
  77
  78 #define OFPT_HELLO                    0x00
  79 #define OFPT_ERROR                    0x01
  80 #define OFPT_ECHO_REQUEST             0x02
  81 #define OFPT_ECHO_REPLY               0x03
  82 #define OFPT_VENDOR                   0x04
  83 #define OFPT_FEATURES_REQUEST         0x05
  84 #define OFPT_FEATURES_REPLY           0x06
  85 #define OFPT_GET_CONFIG_REQUEST       0x07
  86 #define OFPT_GET_CONFIG_REPLY         0x08
  87 #define OFPT_SET_CONFIG               0x09
  88 #define OFPT_PACKET_IN                0x0a
  89 #define OFPT_FLOW_REMOVED             0x0b
  90 #define OFPT_PORT_STATUS              0x0c
  91 #define OFPT_PACKET_OUT               0x0d
  92 #define OFPT_FLOW_MOD                 0x0e
  93 #define OFPT_PORT_MOD                 0x0f
  94 #define OFPT_STATS_REQUEST            0x10
  95 #define OFPT_STATS_REPLY              0x11
  96 #define OFPT_BARRIER_REQUEST          0x12
  97 #define OFPT_BARRIER_REPLY            0x13
  98 #define OFPT_QUEUE_GET_CONFIG_REQUEST 0x14
  99 #define OFPT_QUEUE_GET_CONFIG_REPLY   0x15
 100 static const struct tok ofpt_str[] = {
 101         { OFPT_HELLO,                    "HELLO"                    },
 102         { OFPT_ERROR,                    "ERROR"                    },
 103         { OFPT_ECHO_REQUEST,             "ECHO_REQUEST"             },
 104         { OFPT_ECHO_REPLY,               "ECHO_REPLY"               },
 105         { OFPT_VENDOR,                   "VENDOR"                   },
 106         { OFPT_FEATURES_REQUEST,         "FEATURES_REQUEST"         },
 107         { OFPT_FEATURES_REPLY,           "FEATURES_REPLY"           },
 108         { OFPT_GET_CONFIG_REQUEST,       "GET_CONFIG_REQUEST"       },
 109         { OFPT_GET_CONFIG_REPLY,         "GET_CONFIG_REPLY"         },
 110         { OFPT_SET_CONFIG,               "SET_CONFIG"               },
 111         { OFPT_PACKET_IN,                "PACKET_IN"                },
 112         { OFPT_FLOW_REMOVED,             "FLOW_REMOVED"             },
 113         { OFPT_PORT_STATUS,              "PORT_STATUS"              },
 114         { OFPT_PACKET_OUT,               "PACKET_OUT"               },
 115         { OFPT_FLOW_MOD,                 "FLOW_MOD"                 },
 116         { OFPT_PORT_MOD,                 "PORT_MOD"                 },
 117         { OFPT_STATS_REQUEST,            "STATS_REQUEST"            },
 118         { OFPT_STATS_REPLY,              "STATS_REPLY"              },
 119         { OFPT_BARRIER_REQUEST,          "BARRIER_REQUEST"          },
 120         { OFPT_BARRIER_REPLY,            "BARRIER_REPLY"            },
 121         { OFPT_QUEUE_GET_CONFIG_REQUEST, "QUEUE_GET_CONFIG_REQUEST" },
 122         { OFPT_QUEUE_GET_CONFIG_REPLY,   "QUEUE_GET_CONFIG_REPLY"   },
 123         { 0, NULL }
 124 };
 125
 126 #define OFPPC_PORT_DOWN    (1 << 0)
 127 #define OFPPC_NO_STP       (1 << 1)
 128 #define OFPPC_NO_RECV      (1 << 2)
 129 #define OFPPC_NO_RECV_STP  (1 << 3)
 130 #define OFPPC_NO_FLOOD     (1 << 4)
 131 #define OFPPC_NO_FWD       (1 << 5)
 132 #define OFPPC_NO_PACKET_IN (1 << 6)
 133 static const struct tok ofppc_bm[] = {
 134         { OFPPC_PORT_DOWN,    "PORT_DOWN"    },
 135         { OFPPC_NO_STP,       "NO_STP"       },
 136         { OFPPC_NO_RECV,      "NO_RECV"      },
 137         { OFPPC_NO_RECV_STP,  "NO_RECV_STP"  },
 138         { OFPPC_NO_FLOOD,     "NO_FLOOD"     },
 139         { OFPPC_NO_FWD,       "NO_FWD"       },
 140         { OFPPC_NO_PACKET_IN, "NO_PACKET_IN" },
 141         { 0, NULL }
 142 };
 143 #define OFPPC_U (~(OFPPC_PORT_DOWN | OFPPC_NO_STP | OFPPC_NO_RECV | \
 144                    OFPPC_NO_RECV_STP | OFPPC_NO_FLOOD | OFPPC_NO_FWD | \
 145                    OFPPC_NO_PACKET_IN))
 146
 147 #define OFPPS_LINK_DOWN   (1 << 0)
 148 #define OFPPS_STP_LISTEN  (0 << 8)
 149 #define OFPPS_STP_LEARN   (1 << 8)
 150 #define OFPPS_STP_FORWARD (2 << 8)
 151 #define OFPPS_STP_BLOCK   (3 << 8)
 152 #define OFPPS_STP_MASK    (3 << 8)
 153 static const struct tok ofpps_bm[] = {
 154         { OFPPS_LINK_DOWN,   "LINK_DOWN"   },
 155         { OFPPS_STP_LISTEN,  "STP_LISTEN"  },
 156         { OFPPS_STP_LEARN,   "STP_LEARN"   },
 157         { OFPPS_STP_FORWARD, "STP_FORWARD" },
 158         { OFPPS_STP_BLOCK,   "STP_BLOCK"   },
 159         { 0, NULL }
 160 };
 161 #define OFPPS_U (~(OFPPS_LINK_DOWN | OFPPS_STP_LISTEN | OFPPS_STP_LEARN | \
 162                    OFPPS_STP_FORWARD | OFPPS_STP_BLOCK))
 163
 164 #define OFPP_MAX        0xff00
 165 #define OFPP_IN_PORT    0xfff8
 166 #define OFPP_TABLE      0xfff9
 167 #define OFPP_NORMAL     0xfffa
 168 #define OFPP_FLOOD      0xfffb
 169 #define OFPP_ALL        0xfffc
 170 #define OFPP_CONTROLLER 0xfffd
 171 #define OFPP_LOCAL      0xfffe
 172 #define OFPP_NONE       0xffff
 173 static const struct tok ofpp_str[] = {
 174         { OFPP_MAX,        "MAX"        },
 175         { OFPP_IN_PORT,    "IN_PORT"    },
 176         { OFPP_TABLE,      "TABLE"      },
 177         { OFPP_NORMAL,     "NORMAL"     },
 178         { OFPP_FLOOD,      "FLOOD"      },
 179         { OFPP_ALL,        "ALL"        },
 180         { OFPP_CONTROLLER, "CONTROLLER" },
 181         { OFPP_LOCAL,      "LOCAL"      },
 182         { OFPP_NONE,       "NONE"       },
 183         { 0, NULL }
 184 };
 185
 186 #define OFPPF_10MB_HD    (1 <<  0)
 187 #define OFPPF_10MB_FD    (1 <<  1)
 188 #define OFPPF_100MB_HD   (1 <<  2)
 189 #define OFPPF_100MB_FD   (1 <<  3)
 190 #define OFPPF_1GB_HD     (1 <<  4)
 191 #define OFPPF_1GB_FD     (1 <<  5)
 192 #define OFPPF_10GB_FD    (1 <<  6)
 193 #define OFPPF_COPPER     (1 <<  7)
 194 #define OFPPF_FIBER      (1 <<  8)
 195 #define OFPPF_AUTONEG    (1 <<  9)
 196 #define OFPPF_PAUSE      (1 << 10)
 197 #define OFPPF_PAUSE_ASYM (1 << 11)
 198 static const struct tok ofppf_bm[] = {
 199         { OFPPF_10MB_HD,    "10MB_HD"    },
 200         { OFPPF_10MB_FD,    "10MB_FD"    },
 201         { OFPPF_100MB_HD,   "100MB_HD"   },
 202         { OFPPF_100MB_FD,   "100MB_FD"   },
 203         { OFPPF_1GB_HD,     "1GB_HD"     },
 204         { OFPPF_1GB_FD,     "1GB_FD"     },
 205         { OFPPF_10GB_FD,    "10GB_FD"    },
 206         { OFPPF_COPPER,     "COPPER"     },
 207         { OFPPF_FIBER,      "FIBER"      },
 208         { OFPPF_AUTONEG,    "AUTONEG"    },
 209         { OFPPF_PAUSE,      "PAUSE"      },
 210         { OFPPF_PAUSE_ASYM, "PAUSE_ASYM" },
 211         { 0, NULL }
 212 };
 213 #define OFPPF_U (~(OFPPF_10MB_HD | OFPPF_10MB_FD | OFPPF_100MB_HD | \
 214                    OFPPF_100MB_FD | OFPPF_1GB_HD | OFPPF_1GB_FD | \
 215                    OFPPF_10GB_FD | OFPPF_COPPER | OFPPF_FIBER | \
 216                    OFPPF_AUTONEG | OFPPF_PAUSE | OFPPF_PAUSE_ASYM))
 217
 218 #define OFPQT_NONE     0x0000
 219 #define OFPQT_MIN_RATE 0x0001
 220 static const struct tok ofpqt_str[] = {
 221         { OFPQT_NONE,     "NONE"     },
 222         { OFPQT_MIN_RATE, "MIN_RATE" },
 223         { 0, NULL }
 224 };
 225
 226 #define OFPFW_IN_PORT      (1 << 0)
 227 #define OFPFW_DL_VLAN      (1 << 1)
 228 #define OFPFW_DL_SRC       (1 << 2)
 229 #define OFPFW_DL_DST       (1 << 3)
 230 #define OFPFW_DL_TYPE      (1 << 4)
 231 #define OFPFW_NW_PROTO     (1 << 5)
 232 #define OFPFW_TP_SRC       (1 << 6)
 233 #define OFPFW_TP_DST       (1 << 7)
 234 #define OFPFW_NW_SRC_SHIFT 8
 235 #define OFPFW_NW_SRC_BITS  6
 236 #define OFPFW_NW_SRC_MASK  (((1 << OFPFW_NW_SRC_BITS) - 1) << OFPFW_NW_SRC_SHIFT)
 237 #define OFPFW_NW_DST_SHIFT 14
 238 #define OFPFW_NW_DST_BITS  6
 239 #define OFPFW_NW_DST_MASK  (((1 << OFPFW_NW_DST_BITS) - 1) << OFPFW_NW_DST_SHIFT)
 240 #define OFPFW_DL_VLAN_PCP  (1 << 20)
 241 #define OFPFW_NW_TOS       (1 << 21)
 242 #define OFPFW_ALL          ((1 << 22) - 1)
 243 static const struct tok ofpfw_bm[] = {
 244         { OFPFW_IN_PORT,     "IN_PORT"     },
 245         { OFPFW_DL_VLAN,     "DL_VLAN"     },
 246         { OFPFW_DL_SRC,      "DL_SRC"      },
 247         { OFPFW_DL_DST,      "DL_DST"      },
 248         { OFPFW_DL_TYPE,     "DL_TYPE"     },
 249         { OFPFW_NW_PROTO,    "NW_PROTO"    },
 250         { OFPFW_TP_SRC,      "TP_SRC"      },
 251         { OFPFW_TP_DST,      "TP_DST"      },
 252         { OFPFW_DL_VLAN_PCP, "DL_VLAN_PCP" },
 253         { OFPFW_NW_TOS,      "NW_TOS"      },
 254         { 0, NULL }
 255 };
 256 /* The above array does not include bits 8~13 (OFPFW_NW_SRC_*) and 14~19
 257  * (OFPFW_NW_DST_*), which are not a part of the bitmap and require decoding
 258  * other than that of tok2str(). The macro below includes these bits such that
 259  * they are not reported as bogus in the decoding. */
 260 #define OFPFW_U (~(OFPFW_ALL))
 261
 262 #define OFPAT_OUTPUT       0x0000
 263 #define OFPAT_SET_VLAN_VID 0x0001
 264 #define OFPAT_SET_VLAN_PCP 0x0002
 265 #define OFPAT_STRIP_VLAN   0x0003
 266 #define OFPAT_SET_DL_SRC   0x0004
 267 #define OFPAT_SET_DL_DST   0x0005
 268 #define OFPAT_SET_NW_SRC   0x0006
 269 #define OFPAT_SET_NW_DST   0x0007
 270 #define OFPAT_SET_NW_TOS   0x0008
 271 #define OFPAT_SET_TP_SRC   0x0009
 272 #define OFPAT_SET_TP_DST   0x000a
 273 #define OFPAT_ENQUEUE      0x000b
 274 #define OFPAT_VENDOR       0xffff
 275 static const struct tok ofpat_str[] = {
 276         { OFPAT_OUTPUT,       "OUTPUT"       },
 277         { OFPAT_SET_VLAN_VID, "SET_VLAN_VID" },
 278         { OFPAT_SET_VLAN_PCP, "SET_VLAN_PCP" },
 279         { OFPAT_STRIP_VLAN,   "STRIP_VLAN"   },
 280         { OFPAT_SET_DL_SRC,   "SET_DL_SRC"   },
 281         { OFPAT_SET_DL_DST,   "SET_DL_DST"   },
 282         { OFPAT_SET_NW_SRC,   "SET_NW_SRC"   },
 283         { OFPAT_SET_NW_DST,   "SET_NW_DST"   },
 284         { OFPAT_SET_NW_TOS,   "SET_NW_TOS"   },
 285         { OFPAT_SET_TP_SRC,   "SET_TP_SRC"   },
 286         { OFPAT_SET_TP_DST,   "SET_TP_DST"   },
 287         { OFPAT_ENQUEUE,      "ENQUEUE"      },
 288         { OFPAT_VENDOR,       "VENDOR"       },
 289         { 0, NULL }
 290 };
 291
 292 /* bit-shifted, w/o vendor action */
 293 static const struct tok ofpat_bm[] = {
 294         { 1 << OFPAT_OUTPUT,       "OUTPUT"       },
 295         { 1 << OFPAT_SET_VLAN_VID, "SET_VLAN_VID" },
 296         { 1 << OFPAT_SET_VLAN_PCP, "SET_VLAN_PCP" },
 297         { 1 << OFPAT_STRIP_VLAN,   "STRIP_VLAN"   },
 298         { 1 << OFPAT_SET_DL_SRC,   "SET_DL_SRC"   },
 299         { 1 << OFPAT_SET_DL_DST,   "SET_DL_DST"   },
 300         { 1 << OFPAT_SET_NW_SRC,   "SET_NW_SRC"   },
 301         { 1 << OFPAT_SET_NW_DST,   "SET_NW_DST"   },
 302         { 1 << OFPAT_SET_NW_TOS,   "SET_NW_TOS"   },
 303         { 1 << OFPAT_SET_TP_SRC,   "SET_TP_SRC"   },
 304         { 1 << OFPAT_SET_TP_DST,   "SET_TP_DST"   },
 305         { 1 << OFPAT_ENQUEUE,      "ENQUEUE"      },
 306         { 0, NULL }
 307 };
 308 #define OFPAT_U (~(1 << OFPAT_OUTPUT | 1 << OFPAT_SET_VLAN_VID | \
 309                    1 << OFPAT_SET_VLAN_PCP | 1 << OFPAT_STRIP_VLAN | \
 310                    1 << OFPAT_SET_DL_SRC | 1 << OFPAT_SET_DL_DST | \
 311                    1 << OFPAT_SET_NW_SRC | 1 << OFPAT_SET_NW_DST | \
 312                    1 << OFPAT_SET_NW_TOS | 1 << OFPAT_SET_TP_SRC | \
 313                    1 << OFPAT_SET_TP_DST | 1 << OFPAT_ENQUEUE))
 314
 315 #define OFPC_FLOW_STATS   (1 << 0)
 316 #define OFPC_TABLE_STATS  (1 << 1)
 317 #define OFPC_PORT_STATS   (1 << 2)
 318 #define OFPC_STP          (1 << 3)
 319 #define OFPC_RESERVED     (1 << 4)
 320 #define OFPC_IP_REASM     (1 << 5)
 321 #define OFPC_QUEUE_STATS  (1 << 6)
 322 #define OFPC_ARP_MATCH_IP (1 << 7)
 323 static const struct tok ofp_capabilities_bm[] = {
 324         { OFPC_FLOW_STATS,   "FLOW_STATS"   },
 325         { OFPC_TABLE_STATS,  "TABLE_STATS"  },
 326         { OFPC_PORT_STATS,   "PORT_STATS"   },
 327         { OFPC_STP,          "STP"          },
 328         { OFPC_RESERVED,     "RESERVED"     }, /* not in the mask below */
 329         { OFPC_IP_REASM,     "IP_REASM"     },
 330         { OFPC_QUEUE_STATS,  "QUEUE_STATS"  },
 331         { OFPC_ARP_MATCH_IP, "ARP_MATCH_IP" },
 332         { 0, NULL }
 333 };
 334 #define OFPCAP_U (~(OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | \
 335                     OFPC_STP | OFPC_IP_REASM | OFPC_QUEUE_STATS | \
 336                     OFPC_ARP_MATCH_IP))
 337
 338 #define OFPC_FRAG_NORMAL 0x0000
 339 #define OFPC_FRAG_DROP   0x0001
 340 #define OFPC_FRAG_REASM  0x0002
 341 #define OFPC_FRAG_MASK   0x0003
 342 static const struct tok ofp_config_str[] = {
 343         { OFPC_FRAG_NORMAL, "FRAG_NORMAL" },
 344         { OFPC_FRAG_DROP,   "FRAG_DROP"   },
 345         { OFPC_FRAG_REASM,  "FRAG_REASM"  },
 346         { 0, NULL }
 347 };
 348
 349 #define OFPFC_ADD           0x0000
 350 #define OFPFC_MODIFY        0x0001
 351 #define OFPFC_MODIFY_STRICT 0x0002
 352 #define OFPFC_DELETE        0x0003
 353 #define OFPFC_DELETE_STRICT 0x0004
 354 static const struct tok ofpfc_str[] = {
 355         { OFPFC_ADD,           "ADD"           },
 356         { OFPFC_MODIFY,        "MODIFY"        },
 357         { OFPFC_MODIFY_STRICT, "MODIFY_STRICT" },
 358         { OFPFC_DELETE,        "DELETE"        },
 359         { OFPFC_DELETE_STRICT, "DELETE_STRICT" },
 360         { 0, NULL }
 361 };
 362
 363 static const struct tok bufferid_str[] = {
 364         { 0xffffffff, "NONE" },
 365         { 0, NULL }
 366 };
 367
 368 #define OFPFF_SEND_FLOW_REM (1 << 0)
 369 #define OFPFF_CHECK_OVERLAP (1 << 1)
 370 #define OFPFF_EMERG         (1 << 2)
 371 static const struct tok ofpff_bm[] = {
 372         { OFPFF_SEND_FLOW_REM, "SEND_FLOW_REM" },
 373         { OFPFF_CHECK_OVERLAP, "CHECK_OVERLAP" },
 374         { OFPFF_EMERG,         "EMERG"         },
 375         { 0, NULL }
 376 };
 377 #define OFPFF_U (~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP | OFPFF_EMERG))
 378
 379 #define OFPST_DESC      0x0000
 380 #define OFPST_FLOW      0x0001
 381 #define OFPST_AGGREGATE 0x0002
 382 #define OFPST_TABLE     0x0003
 383 #define OFPST_PORT      0x0004
 384 #define OFPST_QUEUE     0x0005
 385 #define OFPST_VENDOR    0xffff
 386 static const struct tok ofpst_str[] = {
 387         { OFPST_DESC,      "DESC"      },
 388         { OFPST_FLOW,      "FLOW"      },
 389         { OFPST_AGGREGATE, "AGGREGATE" },
 390         { OFPST_TABLE,     "TABLE"     },
 391         { OFPST_PORT,      "PORT"      },
 392         { OFPST_QUEUE,     "QUEUE"     },
 393         { OFPST_VENDOR,    "VENDOR"    },
 394         { 0, NULL }
 395 };
 396
 397 static const struct tok tableid_str[] = {
 398         { 0xfe, "EMERG" },
 399         { 0xff, "ALL"   },
 400         { 0, NULL }
 401 };
 402
 403 #define OFPQ_ALL      0xffffffff
 404 static const struct tok ofpq_str[] = {
 405         { OFPQ_ALL, "ALL" },
 406         { 0, NULL }
 407 };
 408
 409 #define OFPSF_REPLY_MORE 0x0001
 410 static const struct tok ofpsf_reply_bm[] = {
 411         { OFPSF_REPLY_MORE, "MORE" },
 412         { 0, NULL }
 413 };
 414 #define OFPSF_REPLY_U (~(OFPSF_REPLY_MORE))
 415
 416 #define OFPR_NO_MATCH 0x00
 417 #define OFPR_ACTION   0x01
 418 static const struct tok ofpr_str[] = {
 419         { OFPR_NO_MATCH, "NO_MATCH" },
 420         { OFPR_ACTION,   "ACTION"   },
 421         { 0, NULL }
 422 };
 423
 424 #define OFPRR_IDLE_TIMEOUT 0x00
 425 #define OFPRR_HARD_TIMEOUT 0x01
 426 #define OFPRR_DELETE       0x02
 427 static const struct tok ofprr_str[] = {
 428         { OFPRR_IDLE_TIMEOUT, "IDLE_TIMEOUT" },
 429         { OFPRR_HARD_TIMEOUT, "HARD_TIMEOUT" },
 430         { OFPRR_DELETE,       "DELETE"       },
 431         { 0, NULL }
 432 };
 433
 434 #define OFPPR_ADD    0x00
 435 #define OFPPR_DELETE 0x01
 436 #define OFPPR_MODIFY 0x02
 437 static const struct tok ofppr_str[] = {
 438         { OFPPR_ADD,    "ADD"    },
 439         { OFPPR_DELETE, "DELETE" },
 440         { OFPPR_MODIFY, "MODIFY" },
 441         { 0, NULL }
 442 };
 443
 444 #define OFPET_HELLO_FAILED    0x0000
 445 #define OFPET_BAD_REQUEST     0x0001
 446 #define OFPET_BAD_ACTION      0x0002
 447 #define OFPET_FLOW_MOD_FAILED 0x0003
 448 #define OFPET_PORT_MOD_FAILED 0x0004
 449 #define OFPET_QUEUE_OP_FAILED 0x0005
 450 static const struct tok ofpet_str[] = {
 451         { OFPET_HELLO_FAILED,    "HELLO_FAILED"    },
 452         { OFPET_BAD_REQUEST,     "BAD_REQUEST"     },
 453         { OFPET_BAD_ACTION,      "BAD_ACTION"      },
 454         { OFPET_FLOW_MOD_FAILED, "FLOW_MOD_FAILED" },
 455         { OFPET_PORT_MOD_FAILED, "PORT_MOD_FAILED" },
 456         { OFPET_QUEUE_OP_FAILED, "QUEUE_OP_FAILED" },
 457         { 0, NULL }
 458 };
 459
 460 #define OFPHFC_INCOMPATIBLE 0x0000
 461 #define OFPHFC_EPERM        0x0001
 462 static const struct tok ofphfc_str[] = {
 463         { OFPHFC_INCOMPATIBLE, "INCOMPATIBLE" },
 464         { OFPHFC_EPERM,        "EPERM"        },
 465         { 0, NULL }
 466 };
 467
 468 #define OFPBRC_BAD_VERSION    0x0000
 469 #define OFPBRC_BAD_TYPE       0x0001
 470 #define OFPBRC_BAD_STAT       0x0002
 471 #define OFPBRC_BAD_VENDOR     0x0003
 472 #define OFPBRC_BAD_SUBTYPE    0x0004
 473 #define OFPBRC_EPERM          0x0005
 474 #define OFPBRC_BAD_LEN        0x0006
 475 #define OFPBRC_BUFFER_EMPTY   0x0007
 476 #define OFPBRC_BUFFER_UNKNOWN 0x0008
 477 static const struct tok ofpbrc_str[] = {
 478         { OFPBRC_BAD_VERSION,    "BAD_VERSION"    },
 479         { OFPBRC_BAD_TYPE,       "BAD_TYPE"       },
 480         { OFPBRC_BAD_STAT,       "BAD_STAT"       },
 481         { OFPBRC_BAD_VENDOR,     "BAD_VENDOR"     },
 482         { OFPBRC_BAD_SUBTYPE,    "BAD_SUBTYPE"    },
 483         { OFPBRC_EPERM,          "EPERM"          },
 484         { OFPBRC_BAD_LEN,        "BAD_LEN"        },
 485         { OFPBRC_BUFFER_EMPTY,   "BUFFER_EMPTY"   },
 486         { OFPBRC_BUFFER_UNKNOWN, "BUFFER_UNKNOWN" },
 487         { 0, NULL }
 488 };
 489
 490 #define OFPBAC_BAD_TYPE        0x0000
 491 #define OFPBAC_BAD_LEN         0x0001
 492 #define OFPBAC_BAD_VENDOR      0x0002
 493 #define OFPBAC_BAD_VENDOR_TYPE 0x0003
 494 #define OFPBAC_BAD_OUT_PORT    0x0004
 495 #define OFPBAC_BAD_ARGUMENT    0x0005
 496 #define OFPBAC_EPERM           0x0006
 497 #define OFPBAC_TOO_MANY        0x0007
 498 #define OFPBAC_BAD_QUEUE       0x0008
 499 static const struct tok ofpbac_str[] = {
 500         { OFPBAC_BAD_TYPE,        "BAD_TYPE"        },
 501         { OFPBAC_BAD_LEN,         "BAD_LEN"         },
 502         { OFPBAC_BAD_VENDOR,      "BAD_VENDOR"      },
 503         { OFPBAC_BAD_VENDOR_TYPE, "BAD_VENDOR_TYPE" },
 504         { OFPBAC_BAD_OUT_PORT,    "BAD_OUT_PORT"    },
 505         { OFPBAC_BAD_ARGUMENT,    "BAD_ARGUMENT"    },
 506         { OFPBAC_EPERM,           "EPERM"           },
 507         { OFPBAC_TOO_MANY,        "TOO_MANY"        },
 508         { OFPBAC_BAD_QUEUE,       "BAD_QUEUE"       },
 509         { 0, NULL }
 510 };
 511
 512 #define OFPFMFC_ALL_TABLES_FULL   0x0000
 513 #define OFPFMFC_OVERLAP           0x0001
 514 #define OFPFMFC_EPERM             0x0002
 515 #define OFPFMFC_BAD_EMERG_TIMEOUT 0x0003
 516 #define OFPFMFC_BAD_COMMAND       0x0004
 517 #define OFPFMFC_UNSUPPORTED       0x0005
 518 static const struct tok ofpfmfc_str[] = {
 519         { OFPFMFC_ALL_TABLES_FULL,   "ALL_TABLES_FULL"   },
 520         { OFPFMFC_OVERLAP,           "OVERLAP"           },
 521         { OFPFMFC_EPERM,             "EPERM"             },
 522         { OFPFMFC_BAD_EMERG_TIMEOUT, "BAD_EMERG_TIMEOUT" },
 523         { OFPFMFC_BAD_COMMAND,       "BAD_COMMAND"       },
 524         { OFPFMFC_UNSUPPORTED,       "UNSUPPORTED"       },
 525         { 0, NULL }
 526 };
 527
 528 #define OFPPMFC_BAD_PORT    0x0000
 529 #define OFPPMFC_BAD_HW_ADDR 0x0001
 530 static const struct tok ofppmfc_str[] = {
 531         { OFPPMFC_BAD_PORT,    "BAD_PORT"    },
 532         { OFPPMFC_BAD_HW_ADDR, "BAD_HW_ADDR" },
 533         { 0, NULL }
 534 };
 535
 536 #define OFPQOFC_BAD_PORT  0x0000
 537 #define OFPQOFC_BAD_QUEUE 0x0001
 538 #define OFPQOFC_EPERM     0x0002
 539 static const struct tok ofpqofc_str[] = {
 540         { OFPQOFC_BAD_PORT,  "BAD_PORT"  },
 541         { OFPQOFC_BAD_QUEUE, "BAD_QUEUE" },
 542         { OFPQOFC_EPERM,     "EPERM"     },
 543         { 0, NULL }
 544 };
 545
 546 static const struct tok empty_str[] = {
 547         { 0, NULL }
 548 };
 549
 550 /* lengths (fixed or minimal) of particular protocol structures */
 551 #define OF_SWITCH_CONFIG_LEN              12
 552 #define OF_PHY_PORT_LEN                   48
 553 #define OF_SWITCH_FEATURES_LEN            32
 554 #define OF_PORT_STATUS_LEN                64
 555 #define OF_PORT_MOD_LEN                   32
 556 #define OF_PACKET_IN_LEN                  20
 557 #define OF_ACTION_OUTPUT_LEN               8
 558 #define OF_ACTION_VLAN_VID_LEN             8
 559 #define OF_ACTION_VLAN_PCP_LEN             8
 560 #define OF_ACTION_DL_ADDR_LEN             16
 561 #define OF_ACTION_NW_ADDR_LEN              8
 562 #define OF_ACTION_TP_PORT_LEN              8
 563 #define OF_ACTION_NW_TOS_LEN               8
 564 #define OF_ACTION_VENDOR_HEADER_LEN        8
 565 #define OF_ACTION_HEADER_LEN               8
 566 #define OF_PACKET_OUT_LEN                 16
 567 #define OF_MATCH_LEN                      40
 568 #define OF_FLOW_MOD_LEN                   72
 569 #define OF_FLOW_REMOVED_LEN               88
 570 #define OF_ERROR_MSG_LEN                  12
 571 #define OF_STATS_REQUEST_LEN              12
 572 #define OF_STATS_REPLY_LEN                12
 573 #define OF_DESC_STATS_LEN               1056
 574 #define OF_FLOW_STATS_REQUEST_LEN         44
 575 #define OF_FLOW_STATS_LEN                 88
 576 #define OF_AGGREGATE_STATS_REQUEST_LEN    44
 577 #define OF_AGGREGATE_STATS_REPLY_LEN      24
 578 #define OF_TABLE_STATS_LEN                64
 579 #define OF_PORT_STATS_REQUEST_LEN          8
 580 #define OF_PORT_STATS_LEN                104
 581 #define OF_VENDOR_HEADER_LEN              12
 582 #define OF_QUEUE_PROP_HEADER_LEN           8
 583 #define OF_QUEUE_PROP_MIN_RATE_LEN        16
 584 #define OF_PACKET_QUEUE_LEN                8
 585 #define OF_QUEUE_GET_CONFIG_REQUEST_LEN   12
 586 #define OF_QUEUE_GET_CONFIG_REPLY_LEN     16
 587 #define OF_ACTION_ENQUEUE_LEN             16
 588 #define OF_QUEUE_STATS_REQUEST_LEN         8
 589 #define OF_QUEUE_STATS_LEN                32
 590
 591 /* miscellaneous constants from [OF10] */
 592 #define OFP_MAX_TABLE_NAME_LEN     32
 593 #define OFP_MAX_PORT_NAME_LEN      16
 594 #define DESC_STR_LEN              256
 595 #define SERIAL_NUM_LEN             32
 596 #define OFP_VLAN_NONE          0xffff
 597
 598 /* vendor extensions */
 599 #define BSN_SET_IP_MASK                    0
 600 #define BSN_GET_IP_MASK_REQUEST            1
 601 #define BSN_GET_IP_MASK_REPLY              2
 602 #define BSN_SET_MIRRORING                  3
 603 #define BSN_GET_MIRRORING_REQUEST          4
 604 #define BSN_GET_MIRRORING_REPLY            5
 605 #define BSN_SHELL_COMMAND                  6
 606 #define BSN_SHELL_OUTPUT                   7
 607 #define BSN_SHELL_STATUS                   8
 608 #define BSN_GET_INTERFACES_REQUEST         9
 609 #define BSN_GET_INTERFACES_REPLY          10
 610 #define BSN_SET_PKTIN_SUPPRESSION_REQUEST 11
 611 #define BSN_SET_L2_TABLE_REQUEST          12
 612 #define BSN_GET_L2_TABLE_REQUEST          13
 613 #define BSN_GET_L2_TABLE_REPLY            14
 614 #define BSN_VIRTUAL_PORT_CREATE_REQUEST   15
 615 #define BSN_VIRTUAL_PORT_CREATE_REPLY     16
 616 #define BSN_VIRTUAL_PORT_REMOVE_REQUEST   17
 617 #define BSN_BW_ENABLE_SET_REQUEST         18
 618 #define BSN_BW_ENABLE_GET_REQUEST         19
 619 #define BSN_BW_ENABLE_GET_REPLY           20
 620 #define BSN_BW_CLEAR_DATA_REQUEST         21
 621 #define BSN_BW_CLEAR_DATA_REPLY           22
 622 #define BSN_BW_ENABLE_SET_REPLY           23
 623 #define BSN_SET_L2_TABLE_REPLY            24
 624 #define BSN_SET_PKTIN_SUPPRESSION_REPLY   25
 625 #define BSN_VIRTUAL_PORT_REMOVE_REPLY     26
 626 #define BSN_HYBRID_GET_REQUEST            27
 627 #define BSN_HYBRID_GET_REPLY              28
 628                                        /* 29 */
 629                                        /* 30 */
 630 #define BSN_PDU_TX_REQUEST                31
 631 #define BSN_PDU_TX_REPLY                  32
 632 #define BSN_PDU_RX_REQUEST                33
 633 #define BSN_PDU_RX_REPLY                  34
 634 #define BSN_PDU_RX_TIMEOUT                35
 635
 636 static const struct tok bsn_subtype_str[] = {
 637         { BSN_SET_IP_MASK,                   "SET_IP_MASK"                   },
 638         { BSN_GET_IP_MASK_REQUEST,           "GET_IP_MASK_REQUEST"           },
 639         { BSN_GET_IP_MASK_REPLY,             "GET_IP_MASK_REPLY"             },
 640         { BSN_SET_MIRRORING,                 "SET_MIRRORING"                 },
 641         { BSN_GET_MIRRORING_REQUEST,         "GET_MIRRORING_REQUEST"         },
 642         { BSN_GET_MIRRORING_REPLY,           "GET_MIRRORING_REPLY"           },
 643         { BSN_SHELL_COMMAND,                 "SHELL_COMMAND"                 },
 644         { BSN_SHELL_OUTPUT,                  "SHELL_OUTPUT"                  },
 645         { BSN_SHELL_STATUS,                  "SHELL_STATUS"                  },
 646         { BSN_GET_INTERFACES_REQUEST,        "GET_INTERFACES_REQUEST"        },
 647         { BSN_GET_INTERFACES_REPLY,          "GET_INTERFACES_REPLY"          },
 648         { BSN_SET_PKTIN_SUPPRESSION_REQUEST, "SET_PKTIN_SUPPRESSION_REQUEST" },
 649         { BSN_SET_L2_TABLE_REQUEST,          "SET_L2_TABLE_REQUEST"          },
 650         { BSN_GET_L2_TABLE_REQUEST,          "GET_L2_TABLE_REQUEST"          },
 651         { BSN_GET_L2_TABLE_REPLY,            "GET_L2_TABLE_REPLY"            },
 652         { BSN_VIRTUAL_PORT_CREATE_REQUEST,   "VIRTUAL_PORT_CREATE_REQUEST"   },
 653         { BSN_VIRTUAL_PORT_CREATE_REPLY,     "VIRTUAL_PORT_CREATE_REPLY"     },
 654         { BSN_VIRTUAL_PORT_REMOVE_REQUEST,   "VIRTUAL_PORT_REMOVE_REQUEST"   },
 655         { BSN_BW_ENABLE_SET_REQUEST,         "BW_ENABLE_SET_REQUEST"         },
 656         { BSN_BW_ENABLE_GET_REQUEST,         "BW_ENABLE_GET_REQUEST"         },
 657         { BSN_BW_ENABLE_GET_REPLY,           "BW_ENABLE_GET_REPLY"           },
 658         { BSN_BW_CLEAR_DATA_REQUEST,         "BW_CLEAR_DATA_REQUEST"         },
 659         { BSN_BW_CLEAR_DATA_REPLY,           "BW_CLEAR_DATA_REPLY"           },
 660         { BSN_BW_ENABLE_SET_REPLY,           "BW_ENABLE_SET_REPLY"           },
 661         { BSN_SET_L2_TABLE_REPLY,            "SET_L2_TABLE_REPLY"            },
 662         { BSN_SET_PKTIN_SUPPRESSION_REPLY,   "SET_PKTIN_SUPPRESSION_REPLY"   },
 663         { BSN_VIRTUAL_PORT_REMOVE_REPLY,     "VIRTUAL_PORT_REMOVE_REPLY"     },
 664         { BSN_HYBRID_GET_REQUEST,            "HYBRID_GET_REQUEST"            },
 665         { BSN_HYBRID_GET_REPLY,              "HYBRID_GET_REPLY"              },
 666         { BSN_PDU_TX_REQUEST,                "PDU_TX_REQUEST"                },
 667         { BSN_PDU_TX_REPLY,                  "PDU_TX_REPLY"                  },
 668         { BSN_PDU_RX_REQUEST,                "PDU_RX_REQUEST"                },
 669         { BSN_PDU_RX_REPLY,                  "PDU_RX_REPLY"                  },
 670         { BSN_PDU_RX_TIMEOUT,                "PDU_RX_TIMEOUT"                },
 671         { 0, NULL }
 672 };
 673
 674 #define BSN_ACTION_MIRROR                  1
 675 #define BSN_ACTION_SET_TUNNEL_DST          2
 676                                         /* 3 */
 677 #define BSN_ACTION_CHECKSUM                4
 678
 679 static const struct tok bsn_action_subtype_str[] = {
 680         { BSN_ACTION_MIRROR,                 "MIRROR"                        },
 681         { BSN_ACTION_SET_TUNNEL_DST,         "SET_TUNNEL_DST"                },
 682         { BSN_ACTION_CHECKSUM,               "CHECKSUM"                      },
 683         { 0, NULL }
 684 };
 685
 686 static const struct tok bsn_mirror_copy_stage_str[] = {
 687         { 0, "INGRESS" },
 688         { 1, "EGRESS"  },
 689         { 0, NULL },
 690 };
 691
 692 static const struct tok bsn_onoff_str[] = {
 693         { 0, "OFF" },
 694         { 1, "ON"  },
 695         { 0, NULL },
 696 };
 697
 698 static const char *
 699 vlan_str(const uint16_t vid)
 700 {
 701         static char buf[sizeof("65535 (bogus)")];
 702         const char *fmt;
 703
 704         if (vid == OFP_VLAN_NONE)
 705                 return "NONE";
 706         fmt = (vid > 0 && vid < 0x0fff) ? "%u" : "%u (bogus)";
 707         snprintf(buf, sizeof(buf), fmt, vid);
 708         return buf;
 709 }
 710
 711 static const char *
 712 pcp_str(const uint8_t pcp)
 713 {
 714         static char buf[sizeof("255 (bogus)")];
 715         snprintf(buf, sizeof(buf), pcp <= 7 ? "%u" : "%u (bogus)", pcp);
 716         return buf;
 717 }
 718
 719 static void
 720 of10_bitmap_print(netdissect_options *ndo,
 721                   const struct tok *t, const uint32_t v, const uint32_t u)
 722 {
 723         const char *sep = " (";
 724
 725         if (v == 0)
 726                 return;
 727         /* assigned bits */
 728         for (; t->s != NULL; t++)
 729                 if (v & t->v) {
 730                         ND_PRINT((ndo, "%s%s", sep, t->s));
 731                         sep = ", ";
 732                 }
 733         /* unassigned bits? */
 734         ND_PRINT((ndo, v & u ? ") (bogus)" : ")"));
 735 }
 736
 737 static const u_char *
 738 of10_data_print(netdissect_options *ndo,
 739                 const u_char *cp, const u_char *ep, const u_int len)
 740 {
 741         if (len == 0)
 742                 return cp;
 743         /* data */
 744         ND_PRINT((ndo, "\n\t data (%u octets)", len));
 745         ND_TCHECK2(*cp, len);
 746         if (ndo->ndo_vflag >= 2)
 747                 hex_and_ascii_print(ndo, "\n\t  ", cp, len);
 748         return cp + len;
 749
 750 trunc:
 751         ND_PRINT((ndo, "%s", tstr));
 752         return ep;
 753 }
 754
 755 static const u_char *
 756 of10_bsn_message_print(netdissect_options *ndo,
 757                        const u_char *cp, const u_char *ep, const u_int len)
 758 {
 759         const u_char *cp0 = cp;
 760         uint32_t subtype;
 761
 762         if (len < 4)
 763                 goto invalid;
 764         /* subtype */
 765         ND_TCHECK2(*cp, 4);
 766         subtype = EXTRACT_32BITS(cp);
 767         cp += 4;
 768         ND_PRINT((ndo, "\n\t subtype %s", tok2str(bsn_subtype_str, "unknown (0x%08x)", subtype)));
 769         switch (subtype) {
 770         case BSN_GET_IP_MASK_REQUEST:
 771                 /*
 772                  *  0                   1                   2                   3
 773                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 774                  * +---------------+---------------+---------------+---------------+
 775                  * |                            subtype                            |
 776                  * +---------------+---------------+---------------+---------------+
 777                  * |     index     |                      pad                      |
 778                  * +---------------+---------------+---------------+---------------+
 779                  * |                              pad                              |
 780                  * +---------------+---------------+---------------+---------------+
 781                  *
 782                  */
 783                 if (len != 12)
 784                         goto invalid;
 785                 /* index */
 786                 ND_TCHECK2(*cp, 1);
 787                 ND_PRINT((ndo, ", index %u", *cp));
 788                 cp += 1;
 789                 /* pad */
 790                 ND_TCHECK2(*cp, 7);
 791                 cp += 7;
 792                 break;
 793         case BSN_SET_IP_MASK:
 794         case BSN_GET_IP_MASK_REPLY:
 795                 /*
 796                  *  0                   1                   2                   3
 797                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 798                  * +---------------+---------------+---------------+---------------+
 799                  * |                            subtype                            |
 800                  * +---------------+---------------+---------------+---------------+
 801                  * |     index     |                      pad                      |
 802                  * +---------------+---------------+---------------+---------------+
 803                  * |                              mask                             |
 804                  * +---------------+---------------+---------------+---------------+
 805                  *
 806                  */
 807                 if (len != 12)
 808                         goto invalid;
 809                 /* index */
 810                 ND_TCHECK2(*cp, 1);
 811                 ND_PRINT((ndo, ", index %u", *cp));
 812                 cp += 1;
 813                 /* pad */
 814                 ND_TCHECK2(*cp, 3);
 815                 cp += 3;
 816                 /* mask */
 817                 ND_TCHECK2(*cp, 4);
 818                 ND_PRINT((ndo, ", mask %s", ipaddr_string(ndo, cp)));
 819                 cp += 4;
 820                 break;
 821         case BSN_SET_MIRRORING:
 822         case BSN_GET_MIRRORING_REQUEST:
 823         case BSN_GET_MIRRORING_REPLY:
 824                 /*
 825                  *  0                   1                   2                   3
 826                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 827                  * +---------------+---------------+---------------+---------------+
 828                  * |                            subtype                            |
 829                  * +---------------+---------------+---------------+---------------+
 830                  * | report m. p.  |                      pad                      |
 831                  * +---------------+---------------+---------------+---------------+
 832                  *
 833                  */
 834                 if (len != 8)
 835                         goto invalid;
 836                 /* report_mirror_ports */
 837                 ND_TCHECK2(*cp, 1);
 838                 ND_PRINT((ndo, ", report_mirror_ports %s", tok2str(bsn_onoff_str, "bogus (%u)", *cp)));
 839                 cp += 1;
 840                 /* pad */
 841                 ND_TCHECK2(*cp, 3);
 842                 cp += 3;
 843                 break;
 844         case BSN_GET_INTERFACES_REQUEST:
 845         case BSN_GET_L2_TABLE_REQUEST:
 846         case BSN_BW_ENABLE_GET_REQUEST:
 847         case BSN_BW_CLEAR_DATA_REQUEST:
 848         case BSN_HYBRID_GET_REQUEST:
 849                 /*
 850                  *  0                   1                   2                   3
 851                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 852                  * +---------------+---------------+---------------+---------------+
 853                  * |                            subtype                            |
 854                  * +---------------+---------------+---------------+---------------+
 855                  *
 856                  */
 857                 if (len != 4)
 858                         goto invalid;
 859                 break;
 860         case BSN_VIRTUAL_PORT_REMOVE_REQUEST:
 861                 /*
 862                  *  0                   1                   2                   3
 863                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 864                  * +---------------+---------------+---------------+---------------+
 865                  * |                            subtype                            |
 866                  * +---------------+---------------+---------------+---------------+
 867                  * |                           vport_no                            |
 868                  * +---------------+---------------+---------------+---------------+
 869                  *
 870                  */
 871                 if (len != 8)
 872                         goto invalid;
 873                 /* vport_no */
 874                 ND_TCHECK2(*cp, 4);
 875                 ND_PRINT((ndo, ", vport_no %u", EXTRACT_32BITS(cp)));
 876                 cp += 4;
 877                 break;
 878         case BSN_SHELL_COMMAND:
 879                 /*
 880                  *  0                   1                   2                   3
 881                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 882                  * +---------------+---------------+---------------+---------------+
 883                  * |                            subtype                            |
 884                  * +---------------+---------------+---------------+---------------+
 885                  * |                            service                            |
 886                  * +---------------+---------------+---------------+---------------+
 887                  * |                             data ...
 888                  * +---------------+---------------+--------
 889                  *
 890                  */
 891                 if (len < 8)
 892                         goto invalid;
 893                 /* service */
 894                 ND_TCHECK2(*cp, 4);
 895                 ND_PRINT((ndo, ", service %u", EXTRACT_32BITS(cp)));
 896                 cp += 4;
 897                 /* data */
 898                 ND_PRINT((ndo, ", data '"));
 899                 if (fn_printn(ndo, cp, len - 8, ep)) {
 900                         ND_PRINT((ndo, "'"));
 901                         goto trunc;
 902                 }
 903                 ND_PRINT((ndo, "'"));
 904                 cp += len - 8;
 905                 break;
 906         case BSN_SHELL_OUTPUT:
 907                 /*
 908                  *  0                   1                   2                   3
 909                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 910                  * +---------------+---------------+---------------+---------------+
 911                  * |                            subtype                            |
 912                  * +---------------+---------------+---------------+---------------+
 913                  * |                             data ...
 914                  * +---------------+---------------+--------
 915                  *
 916                  */
 917                 /* already checked that len >= 4 */
 918                 /* data */
 919                 ND_PRINT((ndo, ", data '"));
 920                 if (fn_printn(ndo, cp, len - 4, ep)) {
 921                         ND_PRINT((ndo, "'"));
 922                         goto trunc;
 923                 }
 924                 ND_PRINT((ndo, "'"));
 925                 cp += len - 4;
 926                 break;
 927         case BSN_SHELL_STATUS:
 928                 /*
 929                  *  0                   1                   2                   3
 930                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 931                  * +---------------+---------------+---------------+---------------+
 932                  * |                            subtype                            |
 933                  * +---------------+---------------+---------------+---------------+
 934                  * |                            status                             |
 935                  * +---------------+---------------+---------------+---------------+
 936                  *
 937                  */
 938                 if (len != 8)
 939                         goto invalid;
 940                 /* status */
 941                 ND_TCHECK2(*cp, 4);
 942                 ND_PRINT((ndo, ", status 0x%08x", EXTRACT_32BITS(cp)));
 943                 cp += 4;
 944                 break;
 945         default:
 946                 ND_TCHECK2(*cp, len - 4);
 947                 cp += len - 4;
 948         }
 949         return cp;
 950
 951 invalid: /* skip the undersized data */
 952         ND_PRINT((ndo, "%s", istr));
 953         ND_TCHECK2(*cp0, len);
 954         return cp0 + len;
 955 trunc:
 956         ND_PRINT((ndo, "%s", tstr));
 957         return ep;
 958 }
 959
 960 static const u_char *
 961 of10_bsn_actions_print(netdissect_options *ndo,
 962                        const u_char *cp, const u_char *ep, const u_int len)
 963 {
 964         const u_char *cp0 = cp;
 965         uint32_t subtype, vlan_tag;
 966
 967         if (len < 4)
 968                 goto invalid;
 969         /* subtype */
 970         ND_TCHECK2(*cp, 4);
 971         subtype = EXTRACT_32BITS(cp);
 972         cp += 4;
 973         ND_PRINT((ndo, "\n\t  subtype %s", tok2str(bsn_action_subtype_str, "unknown (0x%08x)", subtype)));
 974         switch (subtype) {
 975         case BSN_ACTION_MIRROR:
 976                 /*
 977                  *  0                   1                   2                   3
 978                  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 979                  * +---------------+---------------+---------------+---------------+
 980                  * |                            subtype                            |
 981                  * +---------------+---------------+---------------+---------------+
 982                  * |                           dest_port                           |
 983                  * +---------------+---------------+---------------+---------------+
 984                  * |                           vlan_tag                            |
 985                  * +---------------+---------------+---------------+---------------+
 986                  * |  copy_stage   |                      pad                      |
 987                  * +---------------+---------------+---------------+---------------+
 988                  *
 989                  */
 990                 if (len != 16)
 991                         goto invalid;
 992                 /* dest_port */
 993                 ND_TCHECK2(*cp, 4);
 994                 ND_PRINT((ndo, ", dest_port %u", EXTRACT_32BITS(cp)));
 995                 cp += 4;
 996                 /* vlan_tag */
 997                 ND_TCHECK2(*cp, 4);
 998                 vlan_tag = EXTRACT_32BITS(cp);
 999                 cp += 4;
1000                 switch (vlan_tag >> 16) {
1001                 case 0:
1002                         ND_PRINT((ndo, ", vlan_tag none"));
1003                         break;
1004                 case ETHERTYPE_8021Q:
1005                         ND_PRINT((ndo, ", vlan_tag 802.1Q (%s)", ieee8021q_tci_string(vlan_tag & 0xffff)));
1006                         break;
1007                 default:
1008                         ND_PRINT((ndo, ", vlan_tag unknown (0x%04x)", vlan_tag >> 16));
1009                 }
1010                 /* copy_stage */
1011                 ND_TCHECK2(*cp, 1);
1012                 ND_PRINT((ndo, ", copy_stage %s", tok2str(bsn_mirror_copy_stage_str, "unknown (%u)", *cp)));
1013                 cp += 1;
1014                 /* pad */
1015                 ND_TCHECK2(*cp, 3);
1016                 cp += 3;
1017                 break;
1018         default:
1019                 ND_TCHECK2(*cp, len - 4);
1020                 cp += len - 4;
1021         }
1022
1023         return cp;
1024
1025 invalid:
1026         ND_PRINT((ndo, "%s", istr));
1027         ND_TCHECK2(*cp0, len);
1028         return cp0 + len;
1029 trunc:
1030         ND_PRINT((ndo, "%s", tstr));
1031         return ep;
1032 }
1033
1034 static const u_char *
1035 of10_vendor_action_print(netdissect_options *ndo,
1036                          const u_char *cp, const u_char *ep, const u_int len)
1037 {
1038         uint32_t vendor;
1039         const u_char *(*decoder)(netdissect_options *, const u_char *, const u_char *, const u_int);
1040
1041         if (len < 4)
1042                 goto invalid;
1043         /* vendor */
1044         ND_TCHECK2(*cp, 4);
1045         vendor = EXTRACT_32BITS(cp);
1046         cp += 4;
1047         ND_PRINT((ndo, ", vendor 0x%08x (%s)", vendor, of_vendor_name(vendor)));
1048         /* data */
1049         decoder =
1050                 vendor == OUI_BSN         ? of10_bsn_actions_print         :
1051                 of10_data_print;
1052         return decoder(ndo, cp, ep, len - 4);
1053
1054 invalid: /* skip the undersized data */
1055         ND_PRINT((ndo, "%s", istr));
1056         ND_TCHECK2(*cp, len);
1057         return cp + len;
1058 trunc:
1059         ND_PRINT((ndo, "%s", tstr));
1060         return ep;
1061 }
1062
1063 static const u_char *
1064 of10_vendor_message_print(netdissect_options *ndo,
1065                           const u_char *cp, const u_char *ep, const u_int len)
1066 {
1067         uint32_t vendor;
1068         const u_char *(*decoder)(netdissect_options *, const u_char *, const u_char *, u_int);
1069
1070         if (len < 4)
1071                 goto invalid;
1072         /* vendor */
1073         ND_TCHECK2(*cp, 4);
1074         vendor = EXTRACT_32BITS(cp);
1075         cp += 4;
1076         ND_PRINT((ndo, ", vendor 0x%08x (%s)", vendor, of_vendor_name(vendor)));
1077         /* data */
1078         decoder =
1079                 vendor == OUI_BSN         ? of10_bsn_message_print         :
1080                 of10_data_print;
1081         return decoder(ndo, cp, ep, len - 4);
1082
1083 invalid: /* skip the undersized data */
1084         ND_PRINT((ndo, "%s", istr));
1085         ND_TCHECK2(*cp, len);
1086         return cp + len;
1087 trunc:
1088         ND_PRINT((ndo, "%s", tstr));
1089         return ep;
1090 }
1091
1092 /* Vendor ID is mandatory, data is optional. */
1093 static const u_char *
1094 of10_vendor_data_print(netdissect_options *ndo,
1095                        const u_char *cp, const u_char *ep, const u_int len)
1096 {
1097         uint32_t vendor;
1098
1099         if (len < 4)
1100                 goto invalid;
1101         /* vendor */
1102         ND_TCHECK2(*cp, 4);
1103         vendor = EXTRACT_32BITS(cp);
1104         cp += 4;
1105         ND_PRINT((ndo, ", vendor 0x%08x (%s)", vendor, of_vendor_name(vendor)));
1106         /* data */
1107         return of10_data_print(ndo, cp, ep, len - 4);
1108
1109 invalid: /* skip the undersized data */
1110         ND_PRINT((ndo, "%s", istr));
1111         ND_TCHECK2(*cp, len);
1112         return cp + len;
1113 trunc:
1114         ND_PRINT((ndo, "%s", tstr));
1115         return ep;
1116 }
1117
1118 static const u_char *
1119 of10_packet_data_print(netdissect_options *ndo,
1120                        const u_char *cp, const u_char *ep, const u_int len)
1121 {
1122         if (len == 0)
1123                 return cp;
1124         /* data */
1125         ND_PRINT((ndo, "\n\t data (%u octets)", len));
1126         if (ndo->ndo_vflag < 3)
1127                 return cp + len;
1128         ND_TCHECK2(*cp, len);
1129         ndo->ndo_vflag -= 3;
1130         ND_PRINT((ndo, ", frame decoding below\n"));
1131         ether_print(ndo, cp, len, ndo->ndo_snapend - cp, NULL, NULL);
1132         ndo->ndo_vflag += 3;
1133         return cp + len;
1134
1135 trunc:
1136         ND_PRINT((ndo, "%s", tstr));
1137         return ep;
1138 }
1139
1140 /* [OF10] Section 5.2.1 */
1141 static const u_char *
1142 of10_phy_ports_print(netdissect_options *ndo,
1143                      const u_char *cp, const u_char *ep, u_int len)
1144 {
1145         const u_char *cp0 = cp;
1146         const u_int len0 = len;
1147
1148         while (len) {
1149                 if (len < OF_PHY_PORT_LEN)
1150                         goto invalid;
1151                 /* port_no */
1152                 ND_TCHECK2(*cp, 2);
1153                 ND_PRINT((ndo, "\n\t  port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1154                 cp += 2;
1155                 /* hw_addr */
1156                 ND_TCHECK2(*cp, ETHER_ADDR_LEN);
1157                 ND_PRINT((ndo, ", hw_addr %s", etheraddr_string(ndo, cp)));
1158                 cp += ETHER_ADDR_LEN;
1159                 /* name */
1160                 ND_TCHECK2(*cp, OFP_MAX_PORT_NAME_LEN);
1161                 ND_PRINT((ndo, ", name '"));
1162                 fn_print(ndo, cp, cp + OFP_MAX_PORT_NAME_LEN);
1163                 ND_PRINT((ndo, "'"));
1164                 cp += OFP_MAX_PORT_NAME_LEN;
1165
1166                 if (ndo->ndo_vflag < 2) {
1167                         ND_TCHECK2(*cp, 24);
1168                         cp += 24;
1169                         goto next_port;
1170                 }
1171                 /* config */
1172                 ND_TCHECK2(*cp, 4);
1173                 ND_PRINT((ndo, "\n\t   config 0x%08x", EXTRACT_32BITS(cp)));
1174                 of10_bitmap_print(ndo, ofppc_bm, EXTRACT_32BITS(cp), OFPPC_U);
1175                 cp += 4;
1176                 /* state */
1177                 ND_TCHECK2(*cp, 4);
1178                 ND_PRINT((ndo, "\n\t   state 0x%08x", EXTRACT_32BITS(cp)));
1179                 of10_bitmap_print(ndo, ofpps_bm, EXTRACT_32BITS(cp), OFPPS_U);
1180                 cp += 4;
1181                 /* curr */
1182                 ND_TCHECK2(*cp, 4);
1183                 ND_PRINT((ndo, "\n\t   curr 0x%08x", EXTRACT_32BITS(cp)));
1184                 of10_bitmap_print(ndo, ofppf_bm, EXTRACT_32BITS(cp), OFPPF_U);
1185                 cp += 4;
1186                 /* advertised */
1187                 ND_TCHECK2(*cp, 4);
1188                 ND_PRINT((ndo, "\n\t   advertised 0x%08x", EXTRACT_32BITS(cp)));
1189                 of10_bitmap_print(ndo, ofppf_bm, EXTRACT_32BITS(cp), OFPPF_U);
1190                 cp += 4;
1191                 /* supported */
1192                 ND_TCHECK2(*cp, 4);
1193                 ND_PRINT((ndo, "\n\t   supported 0x%08x", EXTRACT_32BITS(cp)));
1194                 of10_bitmap_print(ndo, ofppf_bm, EXTRACT_32BITS(cp), OFPPF_U);
1195                 cp += 4;
1196                 /* peer */
1197                 ND_TCHECK2(*cp, 4);
1198                 ND_PRINT((ndo, "\n\t   peer 0x%08x", EXTRACT_32BITS(cp)));
1199                 of10_bitmap_print(ndo, ofppf_bm, EXTRACT_32BITS(cp), OFPPF_U);
1200                 cp += 4;
1201 next_port:
1202                 len -= OF_PHY_PORT_LEN;
1203         } /* while */
1204         return cp;
1205
1206 invalid: /* skip the undersized trailing data */
1207         ND_PRINT((ndo, "%s", istr));
1208         ND_TCHECK2(*cp0, len0);
1209         return cp0 + len0;
1210 trunc:
1211         ND_PRINT((ndo, "%s", tstr));
1212         return ep;
1213 }
1214
1215 /* [OF10] Section 5.2.2 */
1216 static const u_char *
1217 of10_queue_props_print(netdissect_options *ndo,
1218                        const u_char *cp, const u_char *ep, u_int len)
1219 {
1220         const u_char *cp0 = cp;
1221         const u_int len0 = len;
1222         uint16_t property, plen, rate;
1223
1224         while (len) {
1225                 u_char plen_bogus = 0, skip = 0;
1226
1227                 if (len < OF_QUEUE_PROP_HEADER_LEN)
1228                         goto invalid;
1229                 /* property */
1230                 ND_TCHECK2(*cp, 2);
1231                 property = EXTRACT_16BITS(cp);
1232                 cp += 2;
1233                 ND_PRINT((ndo, "\n\t   property %s", tok2str(ofpqt_str, "invalid (0x%04x)", property)));
1234                 /* len */
1235                 ND_TCHECK2(*cp, 2);
1236                 plen = EXTRACT_16BITS(cp);
1237                 cp += 2;
1238                 ND_PRINT((ndo, ", len %u", plen));
1239                 if (plen < OF_QUEUE_PROP_HEADER_LEN || plen > len)
1240                         goto invalid;
1241                 /* pad */
1242                 ND_TCHECK2(*cp, 4);
1243                 cp += 4;
1244                 /* property-specific constraints and decoding */
1245                 switch (property) {
1246                 case OFPQT_NONE:
1247                         plen_bogus = plen != OF_QUEUE_PROP_HEADER_LEN;
1248                         break;
1249                 case OFPQT_MIN_RATE:
1250                         plen_bogus = plen != OF_QUEUE_PROP_MIN_RATE_LEN;
1251                         break;
1252                 default:
1253                         skip = 1;
1254                 }
1255                 if (plen_bogus) {
1256                         ND_PRINT((ndo, " (bogus)"));
1257                         skip = 1;
1258                 }
1259                 if (skip) {
1260                         ND_TCHECK2(*cp, plen - 4);
1261                         cp += plen - 4;
1262                         goto next_property;
1263                 }
1264                 if (property == OFPQT_MIN_RATE) { /* the only case of property decoding */
1265                         /* rate */
1266                         ND_TCHECK2(*cp, 2);
1267                         rate = EXTRACT_16BITS(cp);
1268                         cp += 2;
1269                         if (rate > 1000)
1270                                 ND_PRINT((ndo, ", rate disabled"));
1271                         else
1272                                 ND_PRINT((ndo, ", rate %u.%u%%", rate / 10, rate % 10));
1273                         /* pad */
1274                         ND_TCHECK2(*cp, 6);
1275                         cp += 6;
1276                 }
1277 next_property:
1278                 len -= plen;
1279         } /* while */
1280         return cp;
1281
1282 invalid: /* skip the rest of queue properties */
1283         ND_PRINT((ndo, "%s", istr));
1284         ND_TCHECK2(*cp0, len0);
1285         return cp0 + len0;
1286 trunc:
1287         ND_PRINT((ndo, "%s", tstr));
1288         return ep;
1289 }
1290
1291 /* ibid */
1292 static const u_char *
1293 of10_queues_print(netdissect_options *ndo,
1294                   const u_char *cp, const u_char *ep, u_int len)
1295 {
1296         const u_char *cp0 = cp;
1297         const u_int len0 = len;
1298         uint16_t desclen;
1299
1300         while (len) {
1301                 if (len < OF_PACKET_QUEUE_LEN)
1302                         goto invalid;
1303                 /* queue_id */
1304                 ND_TCHECK2(*cp, 4);
1305                 ND_PRINT((ndo, "\n\t  queue_id %u", EXTRACT_32BITS(cp)));
1306                 cp += 4;
1307                 /* len */
1308                 ND_TCHECK2(*cp, 2);
1309                 desclen = EXTRACT_16BITS(cp);
1310                 cp += 2;
1311                 ND_PRINT((ndo, ", len %u", desclen));
1312                 if (desclen < OF_PACKET_QUEUE_LEN || desclen > len)
1313                         goto invalid;
1314                 /* pad */
1315                 ND_TCHECK2(*cp, 2);
1316                 cp += 2;
1317                 /* properties */
1318                 if (ndo->ndo_vflag < 2) {
1319                         ND_TCHECK2(*cp, desclen - OF_PACKET_QUEUE_LEN);
1320                         cp += desclen - OF_PACKET_QUEUE_LEN;
1321                         goto next_queue;
1322                 }
1323                 if (ep == (cp = of10_queue_props_print(ndo, cp, ep, desclen - OF_PACKET_QUEUE_LEN)))
1324                         return ep; /* end of snapshot */
1325 next_queue:
1326                 len -= desclen;
1327         } /* while */
1328         return cp;
1329
1330 invalid: /* skip the rest of queues */
1331         ND_PRINT((ndo, "%s", istr));
1332         ND_TCHECK2(*cp0, len0);
1333         return cp0 + len0;
1334 trunc:
1335         ND_PRINT((ndo, "%s", tstr));
1336         return ep;
1337 }
1338
1339 /* [OF10] Section 5.2.3 */
1340 static const u_char *
1341 of10_match_print(netdissect_options *ndo,
1342                  const char *pfx, const u_char *cp, const u_char *ep)
1343 {
1344         uint32_t wildcards;
1345         uint16_t dl_type;
1346         uint8_t nw_proto;
1347         u_char nw_bits;
1348         const char *field_name;
1349
1350         /* wildcards */
1351         ND_TCHECK2(*cp, 4);
1352         wildcards = EXTRACT_32BITS(cp);
1353         if (wildcards & OFPFW_U)
1354                 ND_PRINT((ndo, "%swildcards 0x%08x (bogus)", pfx, wildcards));
1355         cp += 4;
1356         /* in_port */
1357         ND_TCHECK2(*cp, 2);
1358         if (! (wildcards & OFPFW_IN_PORT))
1359                 ND_PRINT((ndo, "%smatch in_port %s", pfx, tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1360         cp += 2;
1361         /* dl_src */
1362         ND_TCHECK2(*cp, ETHER_ADDR_LEN);
1363         if (! (wildcards & OFPFW_DL_SRC))
1364                 ND_PRINT((ndo, "%smatch dl_src %s", pfx, etheraddr_string(ndo, cp)));
1365         cp += ETHER_ADDR_LEN;
1366         /* dl_dst */
1367         ND_TCHECK2(*cp, ETHER_ADDR_LEN);
1368         if (! (wildcards & OFPFW_DL_DST))
1369                 ND_PRINT((ndo, "%smatch dl_dst %s", pfx, etheraddr_string(ndo, cp)));
1370         cp += ETHER_ADDR_LEN;
1371         /* dl_vlan */
1372         ND_TCHECK2(*cp, 2);
1373         if (! (wildcards & OFPFW_DL_VLAN))
1374                 ND_PRINT((ndo, "%smatch dl_vlan %s", pfx, vlan_str(EXTRACT_16BITS(cp))));
1375         cp += 2;
1376         /* dl_vlan_pcp */
1377         ND_TCHECK2(*cp, 1);
1378         if (! (wildcards & OFPFW_DL_VLAN_PCP))
1379                 ND_PRINT((ndo, "%smatch dl_vlan_pcp %s", pfx, pcp_str(*cp)));
1380         cp += 1;
1381         /* pad1 */
1382         ND_TCHECK2(*cp, 1);
1383         cp += 1;
1384         /* dl_type */
1385         ND_TCHECK2(*cp, 2);
1386         dl_type = EXTRACT_16BITS(cp);
1387         cp += 2;
1388         if (! (wildcards & OFPFW_DL_TYPE))
1389                 ND_PRINT((ndo, "%smatch dl_type 0x%04x", pfx, dl_type));
1390         /* nw_tos */
1391         ND_TCHECK2(*cp, 1);
1392         if (! (wildcards & OFPFW_NW_TOS))
1393                 ND_PRINT((ndo, "%smatch nw_tos 0x%02x", pfx, *cp));
1394         cp += 1;
1395         /* nw_proto */
1396         ND_TCHECK2(*cp, 1);
1397         nw_proto = *cp;
1398         cp += 1;
1399         if (! (wildcards & OFPFW_NW_PROTO)) {
1400                 field_name = ! (wildcards & OFPFW_DL_TYPE) && dl_type == ETHERTYPE_ARP
1401                   ? "arp_opcode" : "nw_proto";
1402                 ND_PRINT((ndo, "%smatch %s %u", pfx, field_name, nw_proto));
1403         }
1404         /* pad2 */
1405         ND_TCHECK2(*cp, 2);
1406         cp += 2;
1407         /* nw_src */
1408         ND_TCHECK2(*cp, 4);
1409         nw_bits = (wildcards & OFPFW_NW_SRC_MASK) >> OFPFW_NW_SRC_SHIFT;
1410         if (nw_bits < 32)
1411                 ND_PRINT((ndo, "%smatch nw_src %s/%u", pfx, ipaddr_string(ndo, cp), 32 - nw_bits));
1412         cp += 4;
1413         /* nw_dst */
1414         ND_TCHECK2(*cp, 4);
1415         nw_bits = (wildcards & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT;
1416         if (nw_bits < 32)
1417                 ND_PRINT((ndo, "%smatch nw_dst %s/%u", pfx, ipaddr_string(ndo, cp), 32 - nw_bits));
1418         cp += 4;
1419         /* tp_src */
1420         ND_TCHECK2(*cp, 2);
1421         if (! (wildcards & OFPFW_TP_SRC)) {
1422                 field_name = ! (wildcards & OFPFW_DL_TYPE) && dl_type == ETHERTYPE_IP
1423                   && ! (wildcards & OFPFW_NW_PROTO) && nw_proto == IPPROTO_ICMP
1424                   ? "icmp_type" : "tp_src";
1425                 ND_PRINT((ndo, "%smatch %s %u", pfx, field_name, EXTRACT_16BITS(cp)));
1426         }
1427         cp += 2;
1428         /* tp_dst */
1429         ND_TCHECK2(*cp, 2);
1430         if (! (wildcards & OFPFW_TP_DST)) {
1431                 field_name = ! (wildcards & OFPFW_DL_TYPE) && dl_type == ETHERTYPE_IP
1432                   && ! (wildcards & OFPFW_NW_PROTO) && nw_proto == IPPROTO_ICMP
1433                   ? "icmp_code" : "tp_dst";
1434                 ND_PRINT((ndo, "%smatch %s %u", pfx, field_name, EXTRACT_16BITS(cp)));
1435         }
1436         return cp + 2;
1437
1438 trunc:
1439         ND_PRINT((ndo, "%s", tstr));
1440         return ep;
1441 }
1442
1443 /* [OF10] Section 5.2.4 */
1444 static const u_char *
1445 of10_actions_print(netdissect_options *ndo,
1446                    const char *pfx, const u_char *cp, const u_char *ep,
1447                    u_int len)
1448 {
1449         const u_char *cp0 = cp;
1450         const u_int len0 = len;
1451         uint16_t type, alen, output_port;
1452
1453         while (len) {
1454                 u_char alen_bogus = 0, skip = 0;
1455
1456                 if (len < OF_ACTION_HEADER_LEN)
1457                         goto invalid;
1458                 /* type */
1459                 ND_TCHECK2(*cp, 2);
1460                 type = EXTRACT_16BITS(cp);
1461                 cp += 2;
1462                 ND_PRINT((ndo, "%saction type %s", pfx, tok2str(ofpat_str, "invalid (0x%04x)", type)));
1463                 /* length */
1464                 ND_TCHECK2(*cp, 2);
1465                 alen = EXTRACT_16BITS(cp);
1466                 cp += 2;
1467                 ND_PRINT((ndo, ", len %u", alen));
1468                 /* On action size underrun/overrun skip the rest of the action list. */
1469                 if (alen < OF_ACTION_HEADER_LEN || alen > len)
1470                         goto invalid;
1471                 /* On action size inappropriate for the given type or invalid type just skip
1472                  * the current action, as the basic length constraint has been met. */
1473                 switch (type) {
1474                 case OFPAT_OUTPUT:
1475                 case OFPAT_SET_VLAN_VID:
1476                 case OFPAT_SET_VLAN_PCP:
1477                 case OFPAT_STRIP_VLAN:
1478                 case OFPAT_SET_NW_SRC:
1479                 case OFPAT_SET_NW_DST:
1480                 case OFPAT_SET_NW_TOS:
1481                 case OFPAT_SET_TP_SRC:
1482                 case OFPAT_SET_TP_DST:
1483                         alen_bogus = alen != 8;
1484                         break;
1485                 case OFPAT_SET_DL_SRC:
1486                 case OFPAT_SET_DL_DST:
1487                 case OFPAT_ENQUEUE:
1488                         alen_bogus = alen != 16;
1489                         break;
1490                 case OFPAT_VENDOR:
1491                         alen_bogus = alen % 8 != 0; /* already >= 8 so far */
1492                         break;
1493                 default:
1494                         skip = 1;
1495                 }
1496                 if (alen_bogus) {
1497                         ND_PRINT((ndo, " (bogus)"));
1498                         skip = 1;
1499                 }
1500                 if (skip) {
1501                         ND_TCHECK2(*cp, alen - 4);
1502                         cp += alen - 4;
1503                         goto next_action;
1504                 }
1505                 /* OK to decode the rest of the action structure */
1506                 switch (type) {
1507                 case OFPAT_OUTPUT:
1508                         /* port */
1509                         ND_TCHECK2(*cp, 2);
1510                         output_port = EXTRACT_16BITS(cp);
1511                         cp += 2;
1512                         ND_PRINT((ndo, ", port %s", tok2str(ofpp_str, "%u", output_port)));
1513                         /* max_len */
1514                         ND_TCHECK2(*cp, 2);
1515                         if (output_port == OFPP_CONTROLLER)
1516                                 ND_PRINT((ndo, ", max_len %u", EXTRACT_16BITS(cp)));
1517                         cp += 2;
1518                         break;
1519                 case OFPAT_SET_VLAN_VID:
1520                         /* vlan_vid */
1521                         ND_TCHECK2(*cp, 2);
1522                         ND_PRINT((ndo, ", vlan_vid %s", vlan_str(EXTRACT_16BITS(cp))));
1523                         cp += 2;
1524                         /* pad */
1525                         ND_TCHECK2(*cp, 2);
1526                         cp += 2;
1527                         break;
1528                 case OFPAT_SET_VLAN_PCP:
1529                         /* vlan_pcp */
1530                         ND_TCHECK2(*cp, 1);
1531                         ND_PRINT((ndo, ", vlan_pcp %s", pcp_str(*cp)));
1532                         cp += 1;
1533                         /* pad */
1534                         ND_TCHECK2(*cp, 3);
1535                         cp += 3;
1536                         break;
1537                 case OFPAT_SET_DL_SRC:
1538                 case OFPAT_SET_DL_DST:
1539                         /* dl_addr */
1540                         ND_TCHECK2(*cp, ETHER_ADDR_LEN);
1541                         ND_PRINT((ndo, ", dl_addr %s", etheraddr_string(ndo, cp)));
1542                         cp += ETHER_ADDR_LEN;
1543                         /* pad */
1544                         ND_TCHECK2(*cp, 6);
1545                         cp += 6;
1546                         break;
1547                 case OFPAT_SET_NW_SRC:
1548                 case OFPAT_SET_NW_DST:
1549                         /* nw_addr */
1550                         ND_TCHECK2(*cp, 4);
1551                         ND_PRINT((ndo, ", nw_addr %s", ipaddr_string(ndo, cp)));
1552                         cp += 4;
1553                         break;
1554                 case OFPAT_SET_NW_TOS:
1555                         /* nw_tos */
1556                         ND_TCHECK2(*cp, 1);
1557                         ND_PRINT((ndo, ", nw_tos 0x%02x", *cp));
1558                         cp += 1;
1559                         /* pad */
1560                         ND_TCHECK2(*cp, 3);
1561                         cp += 3;
1562                         break;
1563                 case OFPAT_SET_TP_SRC:
1564                 case OFPAT_SET_TP_DST:
1565                         /* nw_tos */
1566                         ND_TCHECK2(*cp, 2);
1567                         ND_PRINT((ndo, ", tp_port %u", EXTRACT_16BITS(cp)));
1568                         cp += 2;
1569                         /* pad */
1570                         ND_TCHECK2(*cp, 2);
1571                         cp += 2;
1572                         break;
1573                 case OFPAT_ENQUEUE:
1574                         /* port */
1575                         ND_TCHECK2(*cp, 2);
1576                         ND_PRINT((ndo, ", port %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1577                         cp += 2;
1578                         /* pad */
1579                         ND_TCHECK2(*cp, 6);
1580                         cp += 6;
1581                         /* queue_id */
1582                         ND_TCHECK2(*cp, 4);
1583                         ND_PRINT((ndo, ", queue_id %s", tok2str(ofpq_str, "%u", EXTRACT_32BITS(cp))));
1584                         cp += 4;
1585                         break;
1586                 case OFPAT_VENDOR:
1587                         if (ep == (cp = of10_vendor_action_print(ndo, cp, ep, alen - 4)))
1588                                 return ep; /* end of snapshot */
1589                         break;
1590                 case OFPAT_STRIP_VLAN:
1591                         /* pad */
1592                         ND_TCHECK2(*cp, 4);
1593                         cp += 4;
1594                         break;
1595                 } /* switch */
1596 next_action:
1597                 len -= alen;
1598         } /* while */
1599         return cp;
1600
1601 invalid: /* skip the rest of actions */
1602         ND_PRINT((ndo, "%s", istr));
1603         ND_TCHECK2(*cp0, len0);
1604         return cp0 + len0;
1605 trunc:
1606         ND_PRINT((ndo, "%s", tstr));
1607         return ep;
1608 }
1609
1610 /* [OF10] Section 5.3.1 */
1611 static const u_char *
1612 of10_features_reply_print(netdissect_options *ndo,
1613                           const u_char *cp, const u_char *ep, const u_int len)
1614 {
1615         /* datapath_id */
1616         ND_TCHECK2(*cp, 8);
1617         ND_PRINT((ndo, "\n\t dpid 0x%016" PRIx64, EXTRACT_64BITS(cp)));
1618         cp += 8;
1619         /* n_buffers */
1620         ND_TCHECK2(*cp, 4);
1621         ND_PRINT((ndo, ", n_buffers %u", EXTRACT_32BITS(cp)));
1622         cp += 4;
1623         /* n_tables */
1624         ND_TCHECK2(*cp, 1);
1625         ND_PRINT((ndo, ", n_tables %u", *cp));
1626         cp += 1;
1627         /* pad */
1628         ND_TCHECK2(*cp, 3);
1629         cp += 3;
1630         /* capabilities */
1631         ND_TCHECK2(*cp, 4);
1632         ND_PRINT((ndo, "\n\t capabilities 0x%08x", EXTRACT_32BITS(cp)));
1633         of10_bitmap_print(ndo, ofp_capabilities_bm, EXTRACT_32BITS(cp), OFPCAP_U);
1634         cp += 4;
1635         /* actions */
1636         ND_TCHECK2(*cp, 4);
1637         ND_PRINT((ndo, "\n\t actions 0x%08x", EXTRACT_32BITS(cp)));
1638         of10_bitmap_print(ndo, ofpat_bm, EXTRACT_32BITS(cp), OFPAT_U);
1639         cp += 4;
1640         /* ports */
1641         return of10_phy_ports_print(ndo, cp, ep, len - OF_SWITCH_FEATURES_LEN);
1642
1643 trunc:
1644         ND_PRINT((ndo, "%s", tstr));
1645         return ep;
1646 }
1647
1648 /* [OF10] Section 5.3.3 */
1649 static const u_char *
1650 of10_flow_mod_print(netdissect_options *ndo,
1651                     const u_char *cp, const u_char *ep, const u_int len)
1652 {
1653         uint16_t command;
1654
1655         /* match */
1656         if (ep == (cp = of10_match_print(ndo, "\n\t ", cp, ep)))
1657                 return ep; /* end of snapshot */
1658         /* cookie */
1659         ND_TCHECK2(*cp, 8);
1660         ND_PRINT((ndo, "\n\t cookie 0x%016" PRIx64, EXTRACT_64BITS(cp)));
1661         cp += 8;
1662         /* command */
1663         ND_TCHECK2(*cp, 2);
1664         command = EXTRACT_16BITS(cp);
1665         ND_PRINT((ndo, ", command %s", tok2str(ofpfc_str, "invalid (0x%04x)", command)));
1666         cp += 2;
1667         /* idle_timeout */
1668         ND_TCHECK2(*cp, 2);
1669         if (EXTRACT_16BITS(cp))
1670                 ND_PRINT((ndo, ", idle_timeout %u", EXTRACT_16BITS(cp)));
1671         cp += 2;
1672         /* hard_timeout */
1673         ND_TCHECK2(*cp, 2);
1674         if (EXTRACT_16BITS(cp))
1675                 ND_PRINT((ndo, ", hard_timeout %u", EXTRACT_16BITS(cp)));
1676         cp += 2;
1677         /* priority */
1678         ND_TCHECK2(*cp, 2);
1679         if (EXTRACT_16BITS(cp))
1680                 ND_PRINT((ndo, ", priority %u", EXTRACT_16BITS(cp)));
1681         cp += 2;
1682         /* buffer_id */
1683         ND_TCHECK2(*cp, 4);
1684         if (command == OFPFC_ADD || command == OFPFC_MODIFY ||
1685             command == OFPFC_MODIFY_STRICT)
1686                 ND_PRINT((ndo, ", buffer_id %s", tok2str(bufferid_str, "0x%08x", EXTRACT_32BITS(cp))));
1687         cp += 4;
1688         /* out_port */
1689         ND_TCHECK2(*cp, 2);
1690         if (command == OFPFC_DELETE || command == OFPFC_DELETE_STRICT)
1691                 ND_PRINT((ndo, ", out_port %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1692         cp += 2;
1693         /* flags */
1694         ND_TCHECK2(*cp, 2);
1695         ND_PRINT((ndo, ", flags 0x%04x", EXTRACT_16BITS(cp)));
1696         of10_bitmap_print(ndo, ofpff_bm, EXTRACT_16BITS(cp), OFPFF_U);
1697         cp += 2;
1698         /* actions */
1699         return of10_actions_print(ndo, "\n\t ", cp, ep, len - OF_FLOW_MOD_LEN);
1700
1701 trunc:
1702         ND_PRINT((ndo, "%s", tstr));
1703         return ep;
1704 }
1705
1706 /* ibid */
1707 static const u_char *
1708 of10_port_mod_print(netdissect_options *ndo,
1709                     const u_char *cp, const u_char *ep)
1710 {
1711         /* port_no */
1712         ND_TCHECK2(*cp, 2);
1713         ND_PRINT((ndo, "\n\t port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1714         cp += 2;
1715         /* hw_addr */
1716         ND_TCHECK2(*cp, ETHER_ADDR_LEN);
1717         ND_PRINT((ndo, ", hw_addr %s", etheraddr_string(ndo, cp)));
1718         cp += ETHER_ADDR_LEN;
1719         /* config */
1720         ND_TCHECK2(*cp, 4);
1721         ND_PRINT((ndo, "\n\t config 0x%08x", EXTRACT_32BITS(cp)));
1722         of10_bitmap_print(ndo, ofppc_bm, EXTRACT_32BITS(cp), OFPPC_U);
1723         cp += 4;
1724         /* mask */
1725         ND_TCHECK2(*cp, 4);
1726         ND_PRINT((ndo, "\n\t mask 0x%08x", EXTRACT_32BITS(cp)));
1727         of10_bitmap_print(ndo, ofppc_bm, EXTRACT_32BITS(cp), OFPPC_U);
1728         cp += 4;
1729         /* advertise */
1730         ND_TCHECK2(*cp, 4);
1731         ND_PRINT((ndo, "\n\t advertise 0x%08x", EXTRACT_32BITS(cp)));
1732         of10_bitmap_print(ndo, ofppf_bm, EXTRACT_32BITS(cp), OFPPF_U);
1733         cp += 4;
1734         /* pad */
1735         ND_TCHECK2(*cp, 4);
1736         return cp + 4;
1737
1738 trunc:
1739         ND_PRINT((ndo, "%s", tstr));
1740         return ep;
1741 }
1742
1743 /* [OF10] Section 5.3.5 */
1744 static const u_char *
1745 of10_stats_request_print(netdissect_options *ndo,
1746                          const u_char *cp, const u_char *ep, u_int len)
1747 {
1748         const u_char *cp0 = cp;
1749         const u_int len0 = len;
1750         uint16_t type;
1751
1752         /* type */
1753         ND_TCHECK2(*cp, 2);
1754         type = EXTRACT_16BITS(cp);
1755         cp += 2;
1756         ND_PRINT((ndo, "\n\t type %s", tok2str(ofpst_str, "invalid (0x%04x)", type)));
1757         /* flags */
1758         ND_TCHECK2(*cp, 2);
1759         ND_PRINT((ndo, ", flags 0x%04x", EXTRACT_16BITS(cp)));
1760         if (EXTRACT_16BITS(cp))
1761                 ND_PRINT((ndo, " (bogus)"));
1762         cp += 2;
1763         /* type-specific body of one of fixed lengths */
1764         len -= OF_STATS_REQUEST_LEN;
1765         switch(type) {
1766         case OFPST_DESC:
1767         case OFPST_TABLE:
1768                 if (len)
1769                         goto invalid;
1770                 return cp;
1771         case OFPST_FLOW:
1772         case OFPST_AGGREGATE:
1773                 if (len != OF_FLOW_STATS_REQUEST_LEN)
1774                         goto invalid;
1775                 /* match */
1776                 if (ep == (cp = of10_match_print(ndo, "\n\t ", cp, ep)))
1777                         return ep; /* end of snapshot */
1778                 /* table_id */
1779                 ND_TCHECK2(*cp, 1);
1780                 ND_PRINT((ndo, "\n\t table_id %s", tok2str(tableid_str, "%u", *cp)));
1781                 cp += 1;
1782                 /* pad */
1783                 ND_TCHECK2(*cp, 1);
1784                 cp += 1;
1785                 /* out_port */
1786                 ND_TCHECK2(*cp, 2);
1787                 ND_PRINT((ndo, ", out_port %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1788                 return cp + 2;
1789         case OFPST_PORT:
1790                 if (len != OF_PORT_STATS_REQUEST_LEN)
1791                         goto invalid;
1792                 /* port_no */
1793                 ND_TCHECK2(*cp, 2);
1794                 ND_PRINT((ndo, "\n\t port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1795                 cp += 2;
1796                 /* pad */
1797                 ND_TCHECK2(*cp, 6);
1798                 return cp + 6;
1799         case OFPST_QUEUE:
1800                 if (len != OF_QUEUE_STATS_REQUEST_LEN)
1801                         goto invalid;
1802                 /* port_no */
1803                 ND_TCHECK2(*cp, 2);
1804                 ND_PRINT((ndo, "\n\t port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
1805                 cp += 2;
1806                 /* pad */
1807                 ND_TCHECK2(*cp, 2);
1808                 cp += 2;
1809                 /* queue_id */
1810                 ND_TCHECK2(*cp, 4);
1811                 ND_PRINT((ndo, ", queue_id %s", tok2str(ofpq_str, "%u", EXTRACT_32BITS(cp))));
1812                 return cp + 4;
1813         case OFPST_VENDOR:
1814                 return of10_vendor_data_print(ndo, cp, ep, len);
1815         }
1816         return cp;
1817
1818 invalid: /* skip the message body */
1819         ND_PRINT((ndo, "%s", istr));
1820         ND_TCHECK2(*cp0, len0);
1821         return cp0 + len0;
1822 trunc:
1823         ND_PRINT((ndo, "%s", tstr));
1824         return ep;
1825 }
1826
1827 /* ibid */
1828 static const u_char *
1829 of10_desc_stats_reply_print(netdissect_options *ndo,
1830                             const u_char *cp, const u_char *ep, const u_int len)
1831 {
1832         if (len != OF_DESC_STATS_LEN)
1833                 goto invalid;
1834         /* mfr_desc */
1835         ND_TCHECK2(*cp, DESC_STR_LEN);
1836         ND_PRINT((ndo, "\n\t  mfr_desc '"));
1837         fn_print(ndo, cp, cp + DESC_STR_LEN);
1838         ND_PRINT((ndo, "'"));
1839         cp += DESC_STR_LEN;
1840         /* hw_desc */
1841         ND_TCHECK2(*cp, DESC_STR_LEN);
1842         ND_PRINT((ndo, "\n\t  hw_desc '"));
1843         fn_print(ndo, cp, cp + DESC_STR_LEN);
1844         ND_PRINT((ndo, "'"));
1845         cp += DESC_STR_LEN;
1846         /* sw_desc */
1847         ND_TCHECK2(*cp, DESC_STR_LEN);
1848         ND_PRINT((ndo, "\n\t  sw_desc '"));
1849         fn_print(ndo, cp, cp + DESC_STR_LEN);
1850         ND_PRINT((ndo, "'"));
1851         cp += DESC_STR_LEN;
1852         /* serial_num */
1853         ND_TCHECK2(*cp, SERIAL_NUM_LEN);
1854         ND_PRINT((ndo, "\n\t  serial_num '"));
1855         fn_print(ndo, cp, cp + SERIAL_NUM_LEN);
1856         ND_PRINT((ndo, "'"));
1857         cp += SERIAL_NUM_LEN;
1858         /* dp_desc */
1859         ND_TCHECK2(*cp, DESC_STR_LEN);
1860         ND_PRINT((ndo, "\n\t  dp_desc '"));
1861         fn_print(ndo, cp, cp + DESC_STR_LEN);
1862         ND_PRINT((ndo, "'"));
1863         return cp + DESC_STR_LEN;
1864
1865 invalid: /* skip the message body */
1866         ND_PRINT((ndo, "%s", istr));
1867         ND_TCHECK2(*cp, len);
1868         return cp + len;
1869 trunc:
1870         ND_PRINT((ndo, "%s", tstr));
1871         return ep;
1872 }
1873
1874 /* ibid */
1875 static const u_char *
1876 of10_flow_stats_reply_print(netdissect_options *ndo,
1877                             const u_char *cp, const u_char *ep, u_int len)
1878 {
1879         const u_char *cp0 = cp;
1880         const u_int len0 = len;
1881         uint16_t entry_len;
1882
1883         while (len) {
1884                 if (len < OF_FLOW_STATS_LEN)
1885                         goto invalid;
1886                 /* length */
1887                 ND_TCHECK2(*cp, 2);
1888                 entry_len = EXTRACT_16BITS(cp);
1889                 ND_PRINT((ndo, "\n\t length %u", entry_len));
1890                 if (entry_len < OF_FLOW_STATS_LEN || entry_len > len)
1891                         goto invalid;
1892                 cp += 2;
1893                 /* table_id */
1894                 ND_TCHECK2(*cp, 1);
1895                 ND_PRINT((ndo, ", table_id %s", tok2str(tableid_str, "%u", *cp)));
1896                 cp += 1;
1897                 /* pad */
1898                 ND_TCHECK2(*cp, 1);
1899                 cp += 1;
1900                 /* match */
1901                 if (ep == (cp = of10_match_print(ndo, "\n\t  ", cp, ep)))
1902                         return ep; /* end of snapshot */
1903                 /* duration_sec */
1904                 ND_TCHECK2(*cp, 4);
1905                 ND_PRINT((ndo, "\n\t  duration_sec %u", EXTRACT_32BITS(cp)));
1906                 cp += 4;
1907                 /* duration_nsec */
1908                 ND_TCHECK2(*cp, 4);
1909                 ND_PRINT((ndo, ", duration_nsec %u", EXTRACT_32BITS(cp)));
1910                 cp += 4;
1911                 /* priority */
1912                 ND_TCHECK2(*cp, 2);
1913                 ND_PRINT((ndo, ", priority %u", EXTRACT_16BITS(cp)));
1914                 cp += 2;
1915                 /* idle_timeout */
1916                 ND_TCHECK2(*cp, 2);
1917                 ND_PRINT((ndo, ", idle_timeout %u", EXTRACT_16BITS(cp)));
1918                 cp += 2;
1919                 /* hard_timeout */
1920                 ND_TCHECK2(*cp, 2);
1921                 ND_PRINT((ndo, ", hard_timeout %u", EXTRACT_16BITS(cp)));
1922                 cp += 2;
1923                 /* pad2 */
1924                 ND_TCHECK2(*cp, 6);
1925                 cp += 6;
1926                 /* cookie */
1927                 ND_TCHECK2(*cp, 8);
1928                 ND_PRINT((ndo, ", cookie 0x%016" PRIx64, EXTRACT_64BITS(cp)));
1929                 cp += 8;
1930                 /* packet_count */
1931                 ND_TCHECK2(*cp, 8);
1932                 ND_PRINT((ndo, ", packet_count %" PRIu64, EXTRACT_64BITS(cp)));
1933                 cp += 8;
1934                 /* byte_count */
1935                 ND_TCHECK2(*cp, 8);
1936                 ND_PRINT((ndo, ", byte_count %" PRIu64, EXTRACT_64BITS(cp)));
1937                 cp += 8;
1938                 /* actions */
1939                 if (ep == (cp = of10_actions_print(ndo, "\n\t  ", cp, ep, entry_len - OF_FLOW_STATS_LEN)))
1940                         return ep; /* end of snapshot */
1941
1942                 len -= entry_len;
1943         } /* while */
1944         return cp;
1945
1946 invalid: /* skip the rest of flow statistics entries */
1947         ND_PRINT((ndo, "%s", istr));
1948         ND_TCHECK2(*cp0, len0);
1949         return cp0 + len0;
1950 trunc:
1951         ND_PRINT((ndo, "%s", tstr));
1952         return ep;
1953 }
1954
1955 /* ibid */
1956 static const u_char *
1957 of10_aggregate_stats_reply_print(netdissect_options *ndo,
1958                                  const u_char *cp, const u_char *ep,
1959                                  const u_int len)
1960 {
1961         if (len != OF_AGGREGATE_STATS_REPLY_LEN)
1962                 goto invalid;
1963         /* packet_count */
1964         ND_TCHECK2(*cp, 8);
1965         ND_PRINT((ndo, "\n\t packet_count %" PRIu64, EXTRACT_64BITS(cp)));
1966         cp += 8;
1967         /* byte_count */
1968         ND_TCHECK2(*cp, 8);
1969         ND_PRINT((ndo, ", byte_count %" PRIu64, EXTRACT_64BITS(cp)));
1970         cp += 8;
1971         /* flow_count */
1972         ND_TCHECK2(*cp, 4);
1973         ND_PRINT((ndo, ", flow_count %u", EXTRACT_32BITS(cp)));
1974         cp += 4;
1975         /* pad */
1976         ND_TCHECK2(*cp, 4);
1977         return cp + 4;
1978
1979 invalid: /* skip the message body */
1980         ND_PRINT((ndo, "%s", istr));
1981         ND_TCHECK2(*cp, len);
1982         return cp + len;
1983 trunc:
1984         ND_PRINT((ndo, "%s", tstr));
1985         return ep;
1986 }
1987
1988 /* ibid */
1989 static const u_char *
1990 of10_table_stats_reply_print(netdissect_options *ndo,
1991                              const u_char *cp, const u_char *ep, u_int len)
1992 {
1993         const u_char *cp0 = cp;
1994         const u_int len0 = len;
1995
1996         while (len) {
1997                 if (len < OF_TABLE_STATS_LEN)
1998                         goto invalid;
1999                 /* table_id */
2000                 ND_TCHECK2(*cp, 1);
2001                 ND_PRINT((ndo, "\n\t table_id %s", tok2str(tableid_str, "%u", *cp)));
2002                 cp += 1;
2003                 /* pad */
2004                 ND_TCHECK2(*cp, 3);
2005                 cp += 3;
2006                 /* name */
2007                 ND_TCHECK2(*cp, OFP_MAX_TABLE_NAME_LEN);
2008                 ND_PRINT((ndo, ", name '"));
2009                 fn_print(ndo, cp, cp + OFP_MAX_TABLE_NAME_LEN);
2010                 ND_PRINT((ndo, "'"));
2011                 cp += OFP_MAX_TABLE_NAME_LEN;
2012                 /* wildcards */
2013                 ND_TCHECK2(*cp, 4);
2014                 ND_PRINT((ndo, "\n\t  wildcards 0x%08x", EXTRACT_32BITS(cp)));
2015                 of10_bitmap_print(ndo, ofpfw_bm, EXTRACT_32BITS(cp), OFPFW_U);
2016                 cp += 4;
2017                 /* max_entries */
2018                 ND_TCHECK2(*cp, 4);
2019                 ND_PRINT((ndo, "\n\t  max_entries %u", EXTRACT_32BITS(cp)));
2020                 cp += 4;
2021                 /* active_count */
2022                 ND_TCHECK2(*cp, 4);
2023                 ND_PRINT((ndo, ", active_count %u", EXTRACT_32BITS(cp)));
2024                 cp += 4;
2025                 /* lookup_count */
2026                 ND_TCHECK2(*cp, 8);
2027                 ND_PRINT((ndo, ", lookup_count %" PRIu64, EXTRACT_64BITS(cp)));
2028                 cp += 8;
2029                 /* matched_count */
2030                 ND_TCHECK2(*cp, 8);
2031                 ND_PRINT((ndo, ", matched_count %" PRIu64, EXTRACT_64BITS(cp)));
2032                 cp += 8;
2033
2034                 len -= OF_TABLE_STATS_LEN;
2035         } /* while */
2036         return cp;
2037
2038 invalid: /* skip the undersized trailing data */
2039         ND_PRINT((ndo, "%s", istr));
2040         ND_TCHECK2(*cp0, len0);
2041         return cp0 + len0;
2042 trunc:
2043         ND_PRINT((ndo, "%s", tstr));
2044         return ep;
2045 }
2046
2047 /* ibid */
2048 static const u_char *
2049 of10_port_stats_reply_print(netdissect_options *ndo,
2050                             const u_char *cp, const u_char *ep, u_int len)
2051 {
2052         const u_char *cp0 = cp;
2053         const u_int len0 = len;
2054
2055         while (len) {
2056                 if (len < OF_PORT_STATS_LEN)
2057                         goto invalid;
2058                 /* port_no */
2059                 ND_TCHECK2(*cp, 2);
2060                 ND_PRINT((ndo, "\n\t  port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
2061                 cp += 2;
2062                 if (ndo->ndo_vflag < 2) {
2063                         ND_TCHECK2(*cp, OF_PORT_STATS_LEN - 2);
2064                         cp += OF_PORT_STATS_LEN - 2;
2065                         goto next_port;
2066                 }
2067                 /* pad */
2068                 ND_TCHECK2(*cp, 6);
2069                 cp += 6;
2070                 /* rx_packets */
2071                 ND_TCHECK2(*cp, 8);
2072                 ND_PRINT((ndo, ", rx_packets %" PRIu64, EXTRACT_64BITS(cp)));
2073                 cp += 8;
2074                 /* tx_packets */
2075                 ND_TCHECK2(*cp, 8);
2076                 ND_PRINT((ndo, ", tx_packets %" PRIu64, EXTRACT_64BITS(cp)));
2077                 cp += 8;
2078                 /* rx_bytes */
2079                 ND_TCHECK2(*cp, 8);
2080                 ND_PRINT((ndo, ", rx_bytes %" PRIu64, EXTRACT_64BITS(cp)));
2081                 cp += 8;
2082                 /* tx_bytes */
2083                 ND_TCHECK2(*cp, 8);
2084                 ND_PRINT((ndo, ", tx_bytes %" PRIu64, EXTRACT_64BITS(cp)));
2085                 cp += 8;
2086                 /* rx_dropped */
2087                 ND_TCHECK2(*cp, 8);
2088                 ND_PRINT((ndo, ", rx_dropped %" PRIu64, EXTRACT_64BITS(cp)));
2089                 cp += 8;
2090                 /* tx_dropped */
2091                 ND_TCHECK2(*cp, 8);
2092                 ND_PRINT((ndo, ", tx_dropped %" PRIu64, EXTRACT_64BITS(cp)));
2093                 cp += 8;
2094                 /* rx_errors */
2095                 ND_TCHECK2(*cp, 8);
2096                 ND_PRINT((ndo, ", rx_errors %" PRIu64, EXTRACT_64BITS(cp)));
2097                 cp += 8;
2098                 /* tx_errors */
2099                 ND_TCHECK2(*cp, 8);
2100                 ND_PRINT((ndo, ", tx_errors %" PRIu64, EXTRACT_64BITS(cp)));
2101                 cp += 8;
2102                 /* rx_frame_err */
2103                 ND_TCHECK2(*cp, 8);
2104                 ND_PRINT((ndo, ", rx_frame_err %" PRIu64, EXTRACT_64BITS(cp)));
2105                 cp += 8;
2106                 /* rx_over_err */
2107                 ND_TCHECK2(*cp, 8);
2108                 ND_PRINT((ndo, ", rx_over_err %" PRIu64, EXTRACT_64BITS(cp)));
2109                 cp += 8;
2110                 /* rx_crc_err */
2111                 ND_TCHECK2(*cp, 8);
2112                 ND_PRINT((ndo, ", rx_crc_err %" PRIu64, EXTRACT_64BITS(cp)));
2113                 cp += 8;
2114                 /* collisions */
2115                 ND_TCHECK2(*cp, 8);
2116                 ND_PRINT((ndo, ", collisions %" PRIu64, EXTRACT_64BITS(cp)));
2117                 cp += 8;
2118 next_port:
2119                 len -= OF_PORT_STATS_LEN;
2120         } /* while */
2121         return cp;
2122
2123 invalid: /* skip the undersized trailing data */
2124         ND_PRINT((ndo, "%s", istr));
2125         ND_TCHECK2(*cp0, len0);
2126         return cp0 + len0;
2127 trunc:
2128         ND_PRINT((ndo, "%s", tstr));
2129         return ep;
2130 }
2131
2132 /* ibid */
2133 static const u_char *
2134 of10_queue_stats_reply_print(netdissect_options *ndo,
2135                              const u_char *cp, const u_char *ep, u_int len)
2136 {
2137         const u_char *cp0 = cp;
2138         const u_int len0 = len;
2139
2140         while (len) {
2141                 if (len < OF_QUEUE_STATS_LEN)
2142                         goto invalid;
2143                 /* port_no */
2144                 ND_TCHECK2(*cp, 2);
2145                 ND_PRINT((ndo, "\n\t  port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
2146                 cp += 2;
2147                 /* pad */
2148                 ND_TCHECK2(*cp, 2);
2149                 cp += 2;
2150                 /* queue_id */
2151                 ND_TCHECK2(*cp, 4);
2152                 ND_PRINT((ndo, ", queue_id %u", EXTRACT_32BITS(cp)));
2153                 cp += 4;
2154                 /* tx_bytes */
2155                 ND_TCHECK2(*cp, 8);
2156                 ND_PRINT((ndo, ", tx_bytes %" PRIu64, EXTRACT_64BITS(cp)));
2157                 cp += 8;
2158                 /* tx_packets */
2159                 ND_TCHECK2(*cp, 8);
2160                 ND_PRINT((ndo, ", tx_packets %" PRIu64, EXTRACT_64BITS(cp)));
2161                 cp += 8;
2162                 /* tx_errors */
2163                 ND_TCHECK2(*cp, 8);
2164                 ND_PRINT((ndo, ", tx_errors %" PRIu64, EXTRACT_64BITS(cp)));
2165                 cp += 8;
2166
2167                 len -= OF_QUEUE_STATS_LEN;
2168         } /* while */
2169         return cp;
2170
2171 invalid: /* skip the undersized trailing data */
2172         ND_PRINT((ndo, "%s", istr));
2173         ND_TCHECK2(*cp0, len0);
2174         return cp0 + len0;
2175 trunc:
2176         ND_PRINT((ndo, "%s", tstr));
2177         return ep;
2178 }
2179
2180 /* ibid */
2181 static const u_char *
2182 of10_stats_reply_print(netdissect_options *ndo,
2183                        const u_char *cp, const u_char *ep, const u_int len)
2184 {
2185         const u_char *cp0 = cp;
2186         uint16_t type;
2187
2188         /* type */
2189         ND_TCHECK2(*cp, 2);
2190         type = EXTRACT_16BITS(cp);
2191         ND_PRINT((ndo, "\n\t type %s", tok2str(ofpst_str, "invalid (0x%04x)", type)));
2192         cp += 2;
2193         /* flags */
2194         ND_TCHECK2(*cp, 2);
2195         ND_PRINT((ndo, ", flags 0x%04x", EXTRACT_16BITS(cp)));
2196         of10_bitmap_print(ndo, ofpsf_reply_bm, EXTRACT_16BITS(cp), OFPSF_REPLY_U);
2197         cp += 2;
2198
2199         if (ndo->ndo_vflag > 0) {
2200                 const u_char *(*decoder)(netdissect_options *, const u_char *, const u_char *, u_int) =
2201                         type == OFPST_DESC      ? of10_desc_stats_reply_print      :
2202                         type == OFPST_FLOW      ? of10_flow_stats_reply_print      :
2203                         type == OFPST_AGGREGATE ? of10_aggregate_stats_reply_print :
2204                         type == OFPST_TABLE     ? of10_table_stats_reply_print     :
2205                         type == OFPST_PORT      ? of10_port_stats_reply_print      :
2206                         type == OFPST_QUEUE     ? of10_queue_stats_reply_print     :
2207                         type == OFPST_VENDOR    ? of10_vendor_data_print           :
2208                         NULL;
2209                 if (decoder != NULL)
2210                         return decoder(ndo, cp, ep, len - OF_STATS_REPLY_LEN);
2211         }
2212         ND_TCHECK2(*cp0, len);
2213         return cp0 + len;
2214
2215 trunc:
2216         ND_PRINT((ndo, "%s", tstr));
2217         return ep;
2218 }
2219
2220 /* [OF10] Section 5.3.6 */
2221 static const u_char *
2222 of10_packet_out_print(netdissect_options *ndo,
2223                       const u_char *cp, const u_char *ep, const u_int len)
2224 {
2225         const u_char *cp0 = cp;
2226         const u_int len0 = len;
2227         uint16_t actions_len;
2228
2229         /* buffer_id */
2230         ND_TCHECK2(*cp, 4);
2231         ND_PRINT((ndo, "\n\t buffer_id 0x%08x", EXTRACT_32BITS(cp)));
2232         cp += 4;
2233         /* in_port */
2234         ND_TCHECK2(*cp, 2);
2235         ND_PRINT((ndo, ", in_port %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
2236         cp += 2;
2237         /* actions_len */
2238         ND_TCHECK2(*cp, 2);
2239         actions_len = EXTRACT_16BITS(cp);
2240         cp += 2;
2241         if (actions_len > len - OF_PACKET_OUT_LEN)
2242                 goto invalid;
2243         /* actions */
2244         if (ep == (cp = of10_actions_print(ndo, "\n\t ", cp, ep, actions_len)))
2245                 return ep; /* end of snapshot */
2246         /* data */
2247         return of10_packet_data_print(ndo, cp, ep, len - OF_PACKET_OUT_LEN - actions_len);
2248
2249 invalid: /* skip the rest of the message body */
2250         ND_PRINT((ndo, "%s", istr));
2251         ND_TCHECK2(*cp0, len0);
2252         return cp0 + len0;
2253 trunc:
2254         ND_PRINT((ndo, "%s", tstr));
2255         return ep;
2256 }
2257
2258 /* [OF10] Section 5.4.1 */
2259 static const u_char *
2260 of10_packet_in_print(netdissect_options *ndo,
2261                      const u_char *cp, const u_char *ep, const u_int len)
2262 {
2263         /* buffer_id */
2264         ND_TCHECK2(*cp, 4);
2265         ND_PRINT((ndo, "\n\t buffer_id %s", tok2str(bufferid_str, "0x%08x", EXTRACT_32BITS(cp))));
2266         cp += 4;
2267         /* total_len */
2268         ND_TCHECK2(*cp, 2);
2269         ND_PRINT((ndo, ", total_len %u", EXTRACT_16BITS(cp)));
2270         cp += 2;
2271         /* in_port */
2272         ND_TCHECK2(*cp, 2);
2273         ND_PRINT((ndo, ", in_port %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
2274         cp += 2;
2275         /* reason */
2276         ND_TCHECK2(*cp, 1);
2277         ND_PRINT((ndo, ", reason %s", tok2str(ofpr_str, "invalid (0x%02x)", *cp)));
2278         cp += 1;
2279         /* pad */
2280         ND_TCHECK2(*cp, 1);
2281         cp += 1;
2282         /* data */
2283         /* 2 mock octets count in OF_PACKET_IN_LEN but not in len */
2284         return of10_packet_data_print(ndo, cp, ep, len - (OF_PACKET_IN_LEN - 2));
2285
2286 trunc:
2287         ND_PRINT((ndo, "%s", tstr));
2288         return ep;
2289 }
2290
2291 /* [OF10] Section 5.4.2 */
2292 static const u_char *
2293 of10_flow_removed_print(netdissect_options *ndo,
2294                         const u_char *cp, const u_char *ep)
2295 {
2296         /* match */
2297         if (ep == (cp = of10_match_print(ndo, "\n\t ", cp, ep)))
2298                 return ep; /* end of snapshot */
2299         /* cookie */
2300         ND_TCHECK2(*cp, 8);
2301         ND_PRINT((ndo, "\n\t cookie 0x%016" PRIx64, EXTRACT_64BITS(cp)));
2302         cp += 8;
2303         /* priority */
2304         ND_TCHECK2(*cp, 2);
2305         if (EXTRACT_16BITS(cp))
2306                 ND_PRINT((ndo, ", priority %u", EXTRACT_16BITS(cp)));
2307         cp += 2;
2308         /* reason */
2309         ND_TCHECK2(*cp, 1);
2310         ND_PRINT((ndo, ", reason %s", tok2str(ofprr_str, "unknown (0x%02x)", *cp)));
2311         cp += 1;
2312         /* pad */
2313         ND_TCHECK2(*cp, 1);
2314         cp += 1;
2315         /* duration_sec */
2316         ND_TCHECK2(*cp, 4);
2317         ND_PRINT((ndo, ", duration_sec %u", EXTRACT_32BITS(cp)));
2318         cp += 4;
2319         /* duration_nsec */
2320         ND_TCHECK2(*cp, 4);
2321         ND_PRINT((ndo, ", duration_nsec %u", EXTRACT_32BITS(cp)));
2322         cp += 4;
2323         /* idle_timeout */
2324         ND_TCHECK2(*cp, 2);
2325         if (EXTRACT_16BITS(cp))
2326                 ND_PRINT((ndo, ", idle_timeout %u", EXTRACT_16BITS(cp)));
2327         cp += 2;
2328         /* pad2 */
2329         ND_TCHECK2(*cp, 2);
2330         cp += 2;
2331         /* packet_count */
2332         ND_TCHECK2(*cp, 8);
2333         ND_PRINT((ndo, ", packet_count %" PRIu64, EXTRACT_64BITS(cp)));
2334         cp += 8;
2335         /* byte_count */
2336         ND_TCHECK2(*cp, 8);
2337         ND_PRINT((ndo, ", byte_count %" PRIu64, EXTRACT_64BITS(cp)));
2338         return cp + 8;
2339
2340 trunc:
2341         ND_PRINT((ndo, "%s", tstr));
2342         return ep;
2343 }
2344
2345 /* [OF10] Section 5.4.4 */
2346 static const u_char *
2347 of10_error_print(netdissect_options *ndo,
2348                  const u_char *cp, const u_char *ep, const u_int len)
2349 {
2350         uint16_t type;
2351         const struct tok *code_str;
2352
2353         /* type */
2354         ND_TCHECK2(*cp, 2);
2355         type = EXTRACT_16BITS(cp);
2356         cp += 2;
2357         ND_PRINT((ndo, "\n\t type %s", tok2str(ofpet_str, "invalid (0x%04x)", type)));
2358         /* code */
2359         ND_TCHECK2(*cp, 2);
2360         code_str =
2361                 type == OFPET_HELLO_FAILED    ? ofphfc_str  :
2362                 type == OFPET_BAD_REQUEST     ? ofpbrc_str  :
2363                 type == OFPET_BAD_ACTION      ? ofpbac_str  :
2364                 type == OFPET_FLOW_MOD_FAILED ? ofpfmfc_str :
2365                 type == OFPET_PORT_MOD_FAILED ? ofppmfc_str :
2366                 type == OFPET_QUEUE_OP_FAILED ? ofpqofc_str :
2367                 empty_str;
2368         ND_PRINT((ndo, ", code %s", tok2str(code_str, "invalid (0x%04x)", EXTRACT_16BITS(cp))));
2369         cp += 2;
2370         /* data */
2371         return of10_data_print(ndo, cp, ep, len - OF_ERROR_MSG_LEN);
2372
2373 trunc:
2374         ND_PRINT((ndo, "%s", tstr));
2375         return ep;
2376 }
2377
2378 const u_char *
2379 of10_header_body_print(netdissect_options *ndo,
2380                        const u_char *cp, const u_char *ep, const uint8_t type,
2381                        const uint16_t len, const uint32_t xid)
2382 {
2383         const u_char *cp0 = cp;
2384         const u_int len0 = len;
2385         /* Thus far message length is not less than the basic header size, but most
2386          * message types have additional assorted constraints on the length. Wherever
2387          * possible, check that message length meets the constraint, in remaining
2388          * cases check that the length is OK to begin decoding and leave any final
2389          * verification up to a lower-layer function. When the current message is
2390          * invalid, proceed to the next message. */
2391
2392         /* [OF10] Section 5.1 */
2393         ND_PRINT((ndo, "\n\tversion 1.0, type %s, length %u, xid 0x%08x",
2394                tok2str(ofpt_str, "invalid (0x%02x)", type), len, xid));
2395         switch (type) {
2396         /* OpenFlow header only. */
2397         case OFPT_FEATURES_REQUEST: /* [OF10] Section 5.3.1 */
2398         case OFPT_GET_CONFIG_REQUEST: /* [OF10] Section 5.3.2 */
2399         case OFPT_BARRIER_REQUEST: /* [OF10] Section 5.3.7 */
2400         case OFPT_BARRIER_REPLY: /* ibid */
2401                 if (len != OF_HEADER_LEN)
2402                         goto invalid;
2403                 break;
2404
2405         /* OpenFlow header and fixed-size message body. */
2406         case OFPT_SET_CONFIG: /* [OF10] Section 5.3.2 */
2407         case OFPT_GET_CONFIG_REPLY: /* ibid */
2408                 if (len != OF_SWITCH_CONFIG_LEN)
2409                         goto invalid;
2410                 if (ndo->ndo_vflag < 1)
2411                         goto next_message;
2412                 /* flags */
2413                 ND_TCHECK2(*cp, 2);
2414                 ND_PRINT((ndo, "\n\t flags %s", tok2str(ofp_config_str, "invalid (0x%04x)", EXTRACT_16BITS(cp))));
2415                 cp += 2;
2416                 /* miss_send_len */
2417                 ND_TCHECK2(*cp, 2);
2418                 ND_PRINT((ndo, ", miss_send_len %u", EXTRACT_16BITS(cp)));
2419                 return cp + 2;
2420         case OFPT_PORT_MOD:
2421                 if (len != OF_PORT_MOD_LEN)
2422                         goto invalid;
2423                 if (ndo->ndo_vflag < 1)
2424                         goto next_message;
2425                 return of10_port_mod_print(ndo, cp, ep);
2426         case OFPT_QUEUE_GET_CONFIG_REQUEST: /* [OF10] Section 5.3.4 */
2427                 if (len != OF_QUEUE_GET_CONFIG_REQUEST_LEN)
2428                         goto invalid;
2429                 if (ndo->ndo_vflag < 1)
2430                         goto next_message;
2431                 /* port */
2432                 ND_TCHECK2(*cp, 2);
2433                 ND_PRINT((ndo, "\n\t port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
2434                 cp += 2;
2435                 /* pad */
2436                 ND_TCHECK2(*cp, 2);
2437                 return cp + 2;
2438         case OFPT_FLOW_REMOVED:
2439                 if (len != OF_FLOW_REMOVED_LEN)
2440                         goto invalid;
2441                 if (ndo->ndo_vflag < 1)
2442                         goto next_message;
2443                 return of10_flow_removed_print(ndo, cp, ep);
2444         case OFPT_PORT_STATUS: /* [OF10] Section 5.4.3 */
2445                 if (len != OF_PORT_STATUS_LEN)
2446                         goto invalid;
2447                 if (ndo->ndo_vflag < 1)
2448                         goto next_message;
2449                 /* reason */
2450                 ND_TCHECK2(*cp, 1);
2451                 ND_PRINT((ndo, "\n\t reason %s", tok2str(ofppr_str, "invalid (0x%02x)", *cp)));
2452                 cp += 1;
2453                 /* pad */
2454                 ND_TCHECK2(*cp, 7);
2455                 cp += 7;
2456                 /* desc */
2457                 return of10_phy_ports_print(ndo, cp, ep, OF_PHY_PORT_LEN);
2458
2459         /* OpenFlow header, fixed-size message body and n * fixed-size data units. */
2460         case OFPT_FEATURES_REPLY:
2461                 if (len < OF_SWITCH_FEATURES_LEN)
2462                         goto invalid;
2463                 if (ndo->ndo_vflag < 1)
2464                         goto next_message;
2465                 return of10_features_reply_print(ndo, cp, ep, len);
2466
2467         /* OpenFlow header and variable-size data. */
2468         case OFPT_HELLO: /* [OF10] Section 5.5.1 */
2469         case OFPT_ECHO_REQUEST: /* [OF10] Section 5.5.2 */
2470         case OFPT_ECHO_REPLY: /* [OF10] Section 5.5.3 */
2471                 if (ndo->ndo_vflag < 1)
2472                         goto next_message;
2473                 return of10_data_print(ndo, cp, ep, len - OF_HEADER_LEN);
2474
2475         /* OpenFlow header, fixed-size message body and variable-size data. */
2476         case OFPT_ERROR:
2477                 if (len < OF_ERROR_MSG_LEN)
2478                         goto invalid;
2479                 if (ndo->ndo_vflag < 1)
2480                         goto next_message;
2481                 return of10_error_print(ndo, cp, ep, len);
2482         case OFPT_VENDOR:
2483           /* [OF10] Section 5.5.4 */
2484                 if (len < OF_VENDOR_HEADER_LEN)
2485                         goto invalid;
2486                 if (ndo->ndo_vflag < 1)
2487                         goto next_message;
2488                 return of10_vendor_message_print(ndo, cp, ep, len - OF_HEADER_LEN);
2489         case OFPT_PACKET_IN:
2490                 /* 2 mock octets count in OF_PACKET_IN_LEN but not in len */
2491                 if (len < OF_PACKET_IN_LEN - 2)
2492                         goto invalid;
2493                 if (ndo->ndo_vflag < 1)
2494                         goto next_message;
2495                 return of10_packet_in_print(ndo, cp, ep, len);
2496
2497         /* a. OpenFlow header. */
2498         /* b. OpenFlow header and one of the fixed-size message bodies. */
2499         /* c. OpenFlow header, fixed-size message body and variable-size data. */
2500         case OFPT_STATS_REQUEST:
2501                 if (len < OF_STATS_REQUEST_LEN)
2502                         goto invalid;
2503                 if (ndo->ndo_vflag < 1)
2504                         goto next_message;
2505                 return of10_stats_request_print(ndo, cp, ep, len);
2506
2507         /* a. OpenFlow header and fixed-size message body. */
2508         /* b. OpenFlow header and n * fixed-size data units. */
2509         /* c. OpenFlow header and n * variable-size data units. */
2510         /* d. OpenFlow header, fixed-size message body and variable-size data. */
2511         case OFPT_STATS_REPLY:
2512                 if (len < OF_STATS_REPLY_LEN)
2513                         goto invalid;
2514                 if (ndo->ndo_vflag < 1)
2515                         goto next_message;
2516                 return of10_stats_reply_print(ndo, cp, ep, len);
2517
2518         /* OpenFlow header and n * variable-size data units and variable-size data. */
2519         case OFPT_PACKET_OUT:
2520                 if (len < OF_PACKET_OUT_LEN)
2521                         goto invalid;
2522                 if (ndo->ndo_vflag < 1)
2523                         goto next_message;
2524                 return of10_packet_out_print(ndo, cp, ep, len);
2525
2526         /* OpenFlow header, fixed-size message body and n * variable-size data units. */
2527         case OFPT_FLOW_MOD:
2528                 if (len < OF_FLOW_MOD_LEN)
2529                         goto invalid;
2530                 if (ndo->ndo_vflag < 1)
2531                         goto next_message;
2532                 return of10_flow_mod_print(ndo, cp, ep, len);
2533
2534         /* OpenFlow header, fixed-size message body and n * variable-size data units. */
2535         case OFPT_QUEUE_GET_CONFIG_REPLY: /* [OF10] Section 5.3.4 */
2536                 if (len < OF_QUEUE_GET_CONFIG_REPLY_LEN)
2537                         goto invalid;
2538                 if (ndo->ndo_vflag < 1)
2539                         goto next_message;
2540                 /* port */
2541                 ND_TCHECK2(*cp, 2);
2542                 ND_PRINT((ndo, "\n\t port_no %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
2543                 cp += 2;
2544                 /* pad */
2545                 ND_TCHECK2(*cp, 6);
2546                 cp += 6;
2547                 /* queues */
2548                 return of10_queues_print(ndo, cp, ep, len - OF_QUEUE_GET_CONFIG_REPLY_LEN);
2549         } /* switch (type) */
2550         goto next_message;
2551
2552 invalid: /* skip the message body */
2553         ND_PRINT((ndo, "%s", istr));
2554 next_message:
2555         ND_TCHECK2(*cp0, len0 - OF_HEADER_LEN);
2556         return cp0 + len0 - OF_HEADER_LEN;
2557 trunc:
2558         ND_PRINT((ndo, "%s", tstr));
2559         return ep;
2560 }