/*
- * Copyright (c) 2008, 2009 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <config.h>
#include "ofp-print.h"
-#include "xtoxll.h"
#include <errno.h>
#include <inttypes.h>
+#include <sys/types.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <stdarg.h>
#include "packets.h"
#include "pcap.h"
#include "util.h"
+#include "xtoxll.h"
static void ofp_print_port_name(struct ds *string, uint16_t port);
*
* This starts and kills a tcpdump subprocess so it's quite expensive. */
char *
-ofp_packet_to_string(const void *data, size_t len, size_t total_len UNUSED)
+ofp_packet_to_string(const void *data, size_t len, size_t total_len OVS_UNUSED)
{
struct ds ds = DS_EMPTY_INITIALIZER;
struct ofpbuf buf;
if (WEXITSTATUS(status))
ovs_error(0, "tcpdump exited with status %d", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
- ovs_error(0, "tcpdump exited with signal %d", WTERMSIG(status));
+ ovs_error(0, "tcpdump exited with signal %d", WTERMSIG(status));
}
return ds_cstr(&ds);
}
struct ofp_match match;
packet.data = (void *) op->data;
packet.size = data_len;
- flow_extract(&packet, ntohs(op->in_port), &flow);
- flow_to_match(&flow, 0, &match);
+ flow_extract(&packet, 0, ntohs(op->in_port), &flow);
+ flow_to_match(&flow, 0, false, &match);
ofp_print_match(string, &match, verbosity);
ds_put_char(string, '\n');
}
if (verbosity > 1) {
char *packet = ofp_packet_to_string(op->data, data_len,
- ntohs(op->total_len));
+ ntohs(op->total_len));
ds_put_cstr(string, packet);
free(packet);
}
}
-static void ofp_print_port_name(struct ds *string, uint16_t port)
+static void ofp_print_port_name(struct ds *string, uint16_t port)
{
const char *name;
switch (port) {
break;
}
+ case NXAST_SET_TUNNEL: {
+ const struct nx_action_set_tunnel *nast =
+ (struct nx_action_set_tunnel *)nah;
+ ds_put_format(string, "set_tunnel:0x%08"PRIx32, ntohl(nast->tun_id));
+ break;
+ }
+
default:
ds_put_format(string, "***unknown Nicira action:%d***\n",
ntohs(nah->subtype));
}
static int
-ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
- size_t actions_len)
+ofp_print_action(struct ds *string, const struct ofp_action_header *ah,
+ size_t actions_len)
{
uint16_t type;
size_t len;
sizeof(struct ofp_action_nw_addr),
sizeof(struct ofp_action_nw_addr),
},
+ [OFPAT_SET_NW_TOS] = {
+ sizeof(struct ofp_action_nw_tos),
+ sizeof(struct ofp_action_nw_tos),
+ },
[OFPAT_SET_TP_SRC] = {
sizeof(struct ofp_action_tp_port),
sizeof(struct ofp_action_tp_port),
}
if ((len % 8) != 0) {
- ds_put_format(string,
+ ds_put_format(string,
"***action %"PRIu16" length not a multiple of 8***\n",
type);
return -1;
if (type < ARRAY_SIZE(of_actions)) {
const struct openflow_action *act = &of_actions[type];
if ((len < act->min_size) || (len > act->max_size)) {
- ds_put_format(string,
+ ds_put_format(string,
"***action %"PRIu16" wrong length: %zu***\n", type, len);
return -1;
}
}
-
+
switch (type) {
case OFPAT_OUTPUT: {
struct ofp_action_output *oa = (struct ofp_action_output *)ah;
- uint16_t port = ntohs(oa->port);
+ uint16_t port = ntohs(oa->port);
if (port < OFPP_MAX) {
ds_put_format(string, "output:%"PRIu16, port);
} else {
break;
}
+ case OFPAT_ENQUEUE: {
+ struct ofp_action_enqueue *ea = (struct ofp_action_enqueue *)ah;
+ unsigned int port = ntohs(ea->port);
+ unsigned int queue_id = ntohl(ea->queue_id);
+ ds_put_format(string, "enqueue:");
+ if (port != OFPP_IN_PORT) {
+ ds_put_format(string, "%u", port);
+ } else {
+ ds_put_cstr(string, "IN_PORT");
+ }
+ ds_put_format(string, "q%u", queue_id);
+ break;
+ }
+
case OFPAT_SET_VLAN_VID: {
struct ofp_action_vlan_vid *va = (struct ofp_action_vlan_vid *)ah;
ds_put_format(string, "mod_vlan_vid:%"PRIu16, ntohs(va->vlan_vid));
case OFPAT_SET_DL_SRC: {
struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah;
- ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT,
+ ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT,
ETH_ADDR_ARGS(da->dl_addr));
break;
}
case OFPAT_SET_DL_DST: {
struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah;
- ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT,
+ ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT,
ETH_ADDR_ARGS(da->dl_addr));
break;
}
break;
}
+ case OFPAT_SET_NW_TOS: {
+ struct ofp_action_nw_tos *nt = (struct ofp_action_nw_tos *)ah;
+ ds_put_format(string, "mod_nw_tos:%d", nt->nw_tos);
+ break;
+ }
+
case OFPAT_SET_TP_SRC: {
struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah;
ds_put_format(string, "mod_tp_src:%d", ntohs(ta->tp_port));
}
case OFPAT_VENDOR: {
- struct ofp_action_vendor_header *avh
+ struct ofp_action_vendor_header *avh
= (struct ofp_action_vendor_header *)ah;
if (len < sizeof *avh) {
ds_put_format(string, "***ofpat_vendor truncated***\n");
return len;
}
-void
+void
ofp_print_actions(struct ds *string, const struct ofp_action_header *action,
- size_t actions_len)
+ size_t actions_len)
{
uint8_t *p = (uint8_t *)action;
int len = 0;
if (len) {
ds_put_cstr(string, ",");
}
- len = ofp_print_action(string, (struct ofp_action_header *)p,
+ len = ofp_print_action(string, (struct ofp_action_header *)p,
actions_len);
if (len < 0) {
return;
/* Pretty-print the OFPT_PACKET_OUT packet of 'len' bytes at 'oh' to 'string'
* at the given 'verbosity' level. */
static void ofp_packet_out(struct ds *string, const void *oh, size_t len,
- int verbosity)
+ int verbosity)
{
const struct ofp_packet_out *opo = oh;
size_t actions_len = ntohs(opo->actions_len);
* 'string' at the given 'verbosity' level. */
static void
ofp_print_switch_features(struct ds *string, const void *oh, size_t len,
- int verbosity UNUSED)
+ int verbosity OVS_UNUSED)
{
const struct ofp_switch_features *osf = oh;
struct ofp_phy_port *port_list;
int n_ports;
int i;
- ds_put_format(string, " ver:0x%x, dpid:%"PRIx64"\n",
+ ds_put_format(string, " ver:0x%x, dpid:%016"PRIx64"\n",
osf->header.version, ntohll(osf->datapath_id));
ds_put_format(string, "n_tables:%d, n_buffers:%d\n", osf->n_tables,
ntohl(osf->n_buffers));
}
n_ports = (len - sizeof *osf) / sizeof *osf->ports;
- port_list = xmemdup(osf->ports, len - sizeof *osf);
+ port_list = xmemdup(osf->ports, len - sizeof *osf);
qsort(port_list, n_ports, sizeof *port_list, compare_ports);
for (i = 0; i < n_ports; i++) {
ofp_print_phy_port(string, &port_list[i]);
/* Pretty-print the struct ofp_switch_config of 'len' bytes at 'oh' to 'string'
* at the given 'verbosity' level. */
static void
-ofp_print_switch_config(struct ds *string, const void *oh, size_t len UNUSED,
- int verbosity UNUSED)
+ofp_print_switch_config(struct ds *string, const void *oh,
+ size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
{
const struct ofp_switch_config *osc = oh;
uint16_t flags;
flags = ntohs(osc->flags);
- if (flags & OFPC_SEND_FLOW_EXP) {
- flags &= ~OFPC_SEND_FLOW_EXP;
- ds_put_format(string, " (sending flow expirations)");
- }
if (flags) {
ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", flags);
}
}
static void print_wild(struct ds *string, const char *leader, int is_wild,
- int verbosity, const char *format, ...)
+ int verbosity, const char *format, ...)
__attribute__((format(printf, 5, 6)));
static void print_wild(struct ds *string, const char *leader, int is_wild,
- int verbosity, const char *format, ...)
+ int verbosity, const char *format, ...)
{
if (is_wild && verbosity < 2) {
return;
skip_type = false;
}
}
+ if (w & NXFW_TUN_ID) {
+ ds_put_cstr(&f, "tun_id_wild,");
+ }
print_wild(&f, "in_port=", w & OFPFW_IN_PORT, verbosity,
"%d", ntohs(om->in_port));
print_wild(&f, "dl_vlan=", w & OFPFW_DL_VLAN, verbosity,
- "0x%04x", ntohs(om->dl_vlan));
+ "%d", ntohs(om->dl_vlan));
+ print_wild(&f, "dl_vlan_pcp=", w & OFPFW_DL_VLAN_PCP, verbosity,
+ "%d", om->dl_vlan_pcp);
print_wild(&f, "dl_src=", w & OFPFW_DL_SRC, verbosity,
ETH_ADDR_FMT, ETH_ADDR_ARGS(om->dl_src));
print_wild(&f, "dl_dst=", w & OFPFW_DL_DST, verbosity,
print_ip_netmask(&f, "nw_dst=", om->nw_dst,
(w & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT, verbosity);
if (!skip_proto) {
- print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity,
- "%u", om->nw_proto);
+ if (om->dl_type == htons(ETH_TYPE_ARP)) {
+ print_wild(&f, "opcode=", w & OFPFW_NW_PROTO, verbosity,
+ "%u", om->nw_proto);
+ } else {
+ print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity,
+ "%u", om->nw_proto);
+ print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity,
+ "%u", om->nw_tos);
+ }
}
if (om->nw_proto == IP_TYPE_ICMP) {
print_wild(&f, "icmp_type=", w & OFPFW_ICMP_TYPE, verbosity,
/* Pretty-print the OFPT_FLOW_MOD packet of 'len' bytes at 'oh' to 'string'
* at the given 'verbosity' level. */
static void
-ofp_print_flow_mod(struct ds *string, const void *oh, size_t len,
+ofp_print_flow_mod(struct ds *string, const void *oh, size_t len,
int verbosity)
{
const struct ofp_flow_mod *ofm = oh;
default:
ds_put_format(string, " cmd:%d ", ntohs(ofm->command));
}
- ds_put_format(string, "idle:%d hard:%d pri:%d buf:%#x",
+ ds_put_format(string, "cookie:0x%"PRIx64" idle:%d hard:%d pri:%d "
+ "buf:%#x flags:%"PRIx16" ", ntohll(ofm->cookie),
ntohs(ofm->idle_timeout), ntohs(ofm->hard_timeout),
ofm->match.wildcards ? ntohs(ofm->priority) : (uint16_t)-1,
- ntohl(ofm->buffer_id));
+ ntohl(ofm->buffer_id), ntohs(ofm->flags));
ofp_print_actions(string, ofm->actions,
len - offsetof(struct ofp_flow_mod, actions));
ds_put_char(string, '\n');
}
-/* Pretty-print the OFPT_FLOW_EXPIRED packet of 'len' bytes at 'oh' to 'string'
+/* Pretty-print the OFPT_FLOW_REMOVED packet of 'len' bytes at 'oh' to 'string'
* at the given 'verbosity' level. */
static void
-ofp_print_flow_expired(struct ds *string, const void *oh, size_t len UNUSED,
- int verbosity)
+ofp_print_flow_removed(struct ds *string, const void *oh,
+ size_t len OVS_UNUSED, int verbosity)
{
- const struct ofp_flow_expired *ofe = oh;
+ const struct ofp_flow_removed *ofr = oh;
- ofp_print_match(string, &ofe->match, verbosity);
+ ofp_print_match(string, &ofr->match, verbosity);
ds_put_cstr(string, " reason=");
- switch (ofe->reason) {
- case OFPER_IDLE_TIMEOUT:
+ switch (ofr->reason) {
+ case OFPRR_IDLE_TIMEOUT:
ds_put_cstr(string, "idle");
break;
- case OFPER_HARD_TIMEOUT:
+ case OFPRR_HARD_TIMEOUT:
ds_put_cstr(string, "hard");
break;
+ case OFPRR_DELETE:
+ ds_put_cstr(string, "delete");
+ break;
default:
- ds_put_format(string, "**%"PRIu8"**", ofe->reason);
+ ds_put_format(string, "**%"PRIu8"**", ofr->reason);
break;
}
- ds_put_format(string,
- " pri%"PRIu16" secs%"PRIu32" pkts%"PRIu64" bytes%"PRIu64"\n",
- ofe->match.wildcards ? ntohs(ofe->priority) : (uint16_t)-1,
- ntohl(ofe->duration), ntohll(ofe->packet_count),
- ntohll(ofe->byte_count));
+ ds_put_format(string,
+ " cookie0x%"PRIx64" pri%"PRIu16" secs%"PRIu32" nsecs%"PRIu32
+ " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n",
+ ntohll(ofr->cookie),
+ ofr->match.wildcards ? ntohs(ofr->priority) : (uint16_t)-1,
+ ntohl(ofr->duration_sec), ntohl(ofr->duration_nsec),
+ ntohs(ofr->idle_timeout), ntohll(ofr->packet_count),
+ ntohll(ofr->byte_count));
}
static void
-ofp_print_port_mod(struct ds *string, const void *oh, size_t len UNUSED,
- int verbosity UNUSED)
+ofp_print_port_mod(struct ds *string, const void *oh, size_t len OVS_UNUSED,
+ int verbosity OVS_UNUSED)
{
const struct ofp_port_mod *opm = oh;
ds_put_format(string, "port: %d: addr:"ETH_ADDR_FMT", config: %#x, mask:%#x\n",
- ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr),
+ ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr),
ntohl(opm->config), ntohl(opm->mask));
ds_put_format(string, " advertise: ");
if (opm->advertise) {
#define ERROR_CODE(TYPE, CODE) {TYPE, CODE, #CODE}
ERROR_TYPE(OFPET_HELLO_FAILED),
ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE),
+ ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_EPERM),
ERROR_TYPE(OFPET_BAD_REQUEST),
ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VERSION),
ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT),
ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR),
ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE),
- ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH),
+ ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_EPERM),
+ ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN),
ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_EMPTY),
- ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_COOKIE),
+ ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN),
ERROR_TYPE(OFPET_BAD_ACTION),
ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE),
ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE),
ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT),
ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT),
+ ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_EPERM),
ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_TOO_MANY),
ERROR_TYPE(OFPET_FLOW_MOD_FAILED),
ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_ALL_TABLES_FULL),
+ ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP),
+ ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_EPERM),
+ ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_EMERG_TIMEOUT),
ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND),
ERROR_TYPE(OFPET_PORT_MOD_FAILED),
/* Pretty-print the OFPT_ERROR packet of 'len' bytes at 'oh' to 'string'
* at the given 'verbosity' level. */
static void
-ofp_print_error_msg(struct ds *string, const void *oh, size_t len,
- int verbosity UNUSED)
+ofp_print_error_msg(struct ds *string, const void *oh, size_t len,
+ int verbosity OVS_UNUSED)
{
const struct ofp_error_msg *oem = oh;
int type = ntohs(oem->type);
/* Pretty-print the OFPT_PORT_STATUS packet of 'len' bytes at 'oh' to 'string'
* at the given 'verbosity' level. */
static void
-ofp_print_port_status(struct ds *string, const void *oh, size_t len UNUSED,
- int verbosity UNUSED)
+ofp_print_port_status(struct ds *string, const void *oh, size_t len OVS_UNUSED,
+ int verbosity OVS_UNUSED)
{
const struct ofp_port_status *ops = oh;
}
static void
-ofp_desc_stats_reply(struct ds *string, const void *body, size_t len UNUSED,
- int verbosity UNUSED)
+ofp_desc_stats_reply(struct ds *string, const void *body,
+ size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
{
const struct ofp_desc_stats *ods = body;
- ds_put_format(string, "Manufacturer: %s\n", ods->mfr_desc);
- ds_put_format(string, "Hardware: %s\n", ods->hw_desc);
- ds_put_format(string, "Software: %s\n", ods->sw_desc);
- ds_put_format(string, "Serial Num: %s\n", ods->serial_num);
+ ds_put_format(string, "Manufacturer: %.*s\n",
+ (int) sizeof ods->mfr_desc, ods->mfr_desc);
+ ds_put_format(string, "Hardware: %.*s\n",
+ (int) sizeof ods->hw_desc, ods->hw_desc);
+ ds_put_format(string, "Software: %.*s\n",
+ (int) sizeof ods->sw_desc, ods->sw_desc);
+ ds_put_format(string, "Serial Num: %.*s\n",
+ (int) sizeof ods->serial_num, ods->serial_num);
+ ds_put_format(string, "DP Description: %.*s\n",
+ (int) sizeof ods->dp_desc, ods->dp_desc);
}
static void
-ofp_flow_stats_request(struct ds *string, const void *oh, size_t len UNUSED,
- int verbosity)
+ofp_flow_stats_request(struct ds *string, const void *oh,
+ size_t len OVS_UNUSED, int verbosity)
{
const struct ofp_flow_stats_request *fsr = oh;
break;
}
- ds_put_format(string, " duration=%"PRIu32"s, ", ntohl(fs->duration));
+ ds_put_format(string, " cookie=0x%"PRIx64", ", ntohll(fs->cookie));
+ ds_put_format(string, "duration_sec=%"PRIu32"s, ",
+ ntohl(fs->duration_sec));
+ ds_put_format(string, "duration_nsec=%"PRIu32"ns, ",
+ ntohl(fs->duration_nsec));
ds_put_format(string, "table_id=%"PRIu8", ", fs->table_id);
- ds_put_format(string, "priority=%"PRIu16", ",
+ ds_put_format(string, "priority=%"PRIu16", ",
fs->match.wildcards ? ntohs(fs->priority) : (uint16_t)-1);
ds_put_format(string, "n_packets=%"PRIu64", ",
ntohll(fs->packet_count));
static void
ofp_aggregate_stats_request(struct ds *string, const void *oh,
- size_t len UNUSED, int verbosity)
+ size_t len OVS_UNUSED, int verbosity)
{
const struct ofp_aggregate_stats_request *asr = oh;
static void
ofp_aggregate_stats_reply(struct ds *string, const void *body_,
- size_t len UNUSED, int verbosity UNUSED)
+ size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
{
const struct ofp_aggregate_stats_reply *asr = body_;
ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count));
}
-static void print_port_stat(struct ds *string, const char *leader,
+static void print_port_stat(struct ds *string, const char *leader,
uint64_t stat, int more)
{
ds_put_cstr(string, leader);
}
}
+static void
+ofp_port_stats_request(struct ds *string, const void *body_,
+ size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
+{
+ const struct ofp_port_stats_request *psr = body_;
+ ds_put_format(string, "port_no=%"PRIu16, ntohs(psr->port_no));
+}
+
static void
ofp_port_stats_reply(struct ds *string, const void *body, size_t len,
int verbosity)
ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries));
ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
ds_put_cstr(string, " ");
- ds_put_format(string, "lookup=%"PRIu64", ",
+ ds_put_format(string, "lookup=%"PRIu64", ",
ntohll(ts->lookup_count));
ds_put_format(string, "matched=%"PRIu64"\n",
ntohll(ts->matched_count));
static void
vendor_stat(struct ds *string, const void *body, size_t len,
- int verbosity UNUSED)
+ int verbosity OVS_UNUSED)
{
ds_put_format(string, " vendor=%08"PRIx32, ntohl(*(uint32_t *) body));
ds_put_format(string, " %zu bytes additional data",
{
OFPST_PORT,
"port",
- { 0, 0, NULL, },
+ { sizeof(struct ofp_port_stats_request),
+ sizeof(struct ofp_port_stats_request),
+ ofp_port_stats_request },
{ 0, SIZE_MAX, ofp_port_stats_reply },
},
{
ds_put_format(string, " %zu bytes of payload\n", len - sizeof *hdr);
if (verbosity > 1) {
- ds_put_hex_dump(string, hdr, len - sizeof *hdr, 0, true);
+ ds_put_hex_dump(string, hdr, len - sizeof *hdr, 0, true);
}
}
ofp_print_flow_mod,
},
{
- OFPT_FLOW_EXPIRED,
- "flow_expired",
- sizeof (struct ofp_flow_expired),
- ofp_print_flow_expired,
+ OFPT_FLOW_REMOVED,
+ "flow_removed",
+ sizeof (struct ofp_flow_removed),
+ ofp_print_flow_removed,
},
{
OFPT_PORT_MOD,
sizeof (struct ofp_vendor_header),
NULL,
},
+ {
+ OFPT_BARRIER_REQUEST,
+ "barrier_request",
+ sizeof (struct ofp_header),
+ NULL,
+ },
+ {
+ OFPT_BARRIER_REPLY,
+ "barrier_reply",
+ sizeof (struct ofp_header),
+ NULL,
+ }
};
/* Composes and returns a string representing the OpenFlow packet of 'len'
} else if (!pkt->printer) {
if (len > sizeof *oh) {
ds_put_format(&string, " length=%"PRIu16" (decoder not implemented)\n",
- ntohs(oh->length));
+ ntohs(oh->length));
}
} else {
pkt->printer(&string, oh, len, verbosity);
}
\f
static void
-print_and_free(FILE *stream, char *string)
+print_and_free(FILE *stream, char *string)
{
fputs(string, stream);
free(string);