From: Ben Pfaff Date: Thu, 3 Apr 2008 00:10:16 +0000 (-0700) Subject: Add new functions for pretty-printing an OpenFlow message to a string. X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=c2fa32706eafe208b947440ff4207156e6e3b1cb;p=openvswitch Add new functions for pretty-printing an OpenFlow message to a string. This makes it possible to send pretty-printed versions of OpenFlow messages to vlog. --- diff --git a/include/dynamic-string.h b/include/dynamic-string.h index c23dfb7e..e43d006a 100644 --- a/include/dynamic-string.h +++ b/include/dynamic-string.h @@ -35,7 +35,9 @@ #define DYNAMIC_STRING_H 1 #include +#include #include +#include #include "compiler.h" struct ds { @@ -48,9 +50,13 @@ struct ds { void ds_init(struct ds *); void ds_reserve(struct ds *, size_t min_length); +void ds_put_char(struct ds *, char); +void ds_put_cstr(struct ds *, const char *); void ds_put_format(struct ds *, const char *, ...) PRINTF_FORMAT(2, 3); void ds_put_format_valist(struct ds *, const char *, va_list) PRINTF_FORMAT(2, 0); +void ds_put_hex_dump(struct ds *ds, const void *buf_, size_t size, + uintptr_t ofs, bool ascii); char *ds_cstr(struct ds *); void ds_destroy(struct ds *); diff --git a/include/ofp-print.h b/include/ofp-print.h index 36981dec..167809ad 100644 --- a/include/ofp-print.h +++ b/include/ofp-print.h @@ -47,11 +47,11 @@ extern "C" { void ofp_print(FILE *, const void *, size_t, int verbosity); void ofp_print_table(FILE *stream, const struct ofp_table* ot); -void ofp_print_flow_mod(FILE *stream, const void *data, size_t len, int verbosity); -void ofp_print_flow_expired(FILE *stream, const void *data, size_t len, int verbosity); -void ofp_print_data_hello(FILE *stream, const void *data, size_t len, int verbosity); void ofp_print_packet(FILE *stream, const void *data, size_t len, size_t total_len); -void ofp_print_port_status(FILE *stream, const void *oh, size_t len, int verbosity); + +char *ofp_to_string(const void *, size_t, int verbosity); +char *ofp_table_to_string(const struct ofp_table* ot); +char *ofp_packet_to_string(const void *data, size_t len, size_t total_len); #ifdef __cplusplus } diff --git a/lib/dpif.c b/lib/dpif.c index b36df5f4..791c4bec 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -300,7 +300,7 @@ dpif_show(struct dpif *dp) } len = nl_attr_get_size(attrs[DP_GENL_A_DP_INFO]); - ofp_print_data_hello(stdout, odh, len, 1); + ofp_print(stdout, odh, len, 1); return retval; } @@ -431,8 +431,7 @@ dpif_dump_flows(struct dpif *dp, int table, struct ofp_match *match) return EPROTO; } - ofp_print_flow_mod(stdout, &ofm->ofm, - sizeof(struct ofp_flow_mod), 1); + ofp_print(stdout, &ofm->ofm, sizeof(struct ofp_flow_mod), 1); putc('\n', stdout); } diff --git a/lib/dynamic-string.c b/lib/dynamic-string.c index 01d63fe5..68dd3419 100644 --- a/lib/dynamic-string.c +++ b/lib/dynamic-string.c @@ -34,6 +34,7 @@ #include "dynamic-string.h" #include #include +#include #include "util.h" void @@ -54,6 +55,23 @@ ds_reserve(struct ds *ds, size_t min_length) } } +void +ds_put_char(struct ds *ds, char c) +{ + ds_reserve(ds, ds->length + 1); + ds->string[ds->length++] = c; + ds->string[ds->length] = '\0'; +} + +void +ds_put_cstr(struct ds *ds, const char *s) +{ + size_t s_len = strlen(s); + ds_reserve(ds, ds->length + s_len); + memcpy(&ds->string[ds->length], s, s_len + 1); + ds->length += s_len; +} + void ds_put_format(struct ds *ds, const char *format, ...) { @@ -108,3 +126,56 @@ ds_destroy(struct ds *ds) { free(ds->string); } + +/* Writes the 'size' bytes in 'buf' to 'string' as hex bytes arranged 16 per + * line. Numeric offsets are also included, starting at 'ofs' for the first + * byte in 'buf'. If 'ascii' is true then the corresponding ASCII characters + * are also rendered alongside. */ +void +ds_put_hex_dump(struct ds *ds, const void *buf_, size_t size, + uintptr_t ofs, bool ascii) +{ + const uint8_t *buf = buf_; + const size_t per_line = 16; /* Maximum bytes per line. */ + + while (size > 0) + { + size_t start, end, n; + size_t i; + + /* Number of bytes on this line. */ + start = ofs % per_line; + end = per_line; + if (end - start > size) + end = start + size; + n = end - start; + + /* Print line. */ + ds_put_format(ds, "%08jx ", (uintmax_t) ROUND_DOWN(ofs, per_line)); + for (i = 0; i < start; i++) + ds_put_format(ds, " "); + for (; i < end; i++) + ds_put_format(ds, "%02hhx%c", + buf[i - start], i == per_line / 2 - 1? '-' : ' '); + if (ascii) + { + for (; i < per_line; i++) + ds_put_format(ds, " "); + ds_put_format(ds, "|"); + for (i = 0; i < start; i++) + ds_put_format(ds, " "); + for (; i < end; i++) { + int c = buf[i - start]; + ds_put_char(ds, c >= 32 && c < 127 ? c : '.'); + } + for (; i < per_line; i++) + ds_put_format(ds, " "); + ds_put_format(ds, "|"); + } + ds_put_format(ds, "\n"); + + ofs += n; + buf += n; + size -= n; + } +} diff --git a/lib/ofp-print.c b/lib/ofp-print.c index 8ee1af58..98190a4f 100644 --- a/lib/ofp-print.c +++ b/lib/ofp-print.c @@ -43,17 +43,21 @@ #include #include "compiler.h" +#include "dynamic-string.h" #include "util.h" #include "openflow.h" #include "packets.h" -/* Dumps the contents of the Ethernet frame in the 'len' bytes starting at - * 'data' to 'stream' using tcpdump. 'total_len' specifies the full length of - * the Ethernet frame (of which 'len' bytes were captured). +/* Returns a string that represents the contents of the Ethernet frame in the + * 'len' bytes starting at 'data' to 'stream' as output by tcpdump. + * 'total_len' specifies the full length of the Ethernet frame (of which 'len' + * bytes were captured). + * + * The caller must free the returned string. * * This starts and kills a tcpdump subprocess so it's quite expensive. */ -void ofp_print_packet(FILE *stream, const void *data, size_t len, - size_t total_len) +char * +ofp_packet_to_string(const void *data, size_t len, size_t total_len) { struct pcap_hdr { uint32_t magic_number; /* magic number */ @@ -75,17 +79,18 @@ void ofp_print_packet(FILE *stream, const void *data, size_t len, struct pcap_hdr ph; struct pcaprec_hdr prh; + struct ds ds = DS_EMPTY_INITIALIZER; + char command[128]; + FILE *pcap; FILE *tcpdump; int status; + int c; - fflush(stream); - snprintf(command, sizeof command, "tcpdump -n -r - %d>&1 2>/dev/null", - fileno(stream)); - tcpdump = popen(command, "w"); - if (!tcpdump) { - error(errno, "exec(\"%s\")", command); - return; + pcap = tmpfile(); + if (!pcap) { + error(errno, "tmpfile"); + return xstrdup(""); } /* The pcap reader is responsible for figuring out endianness based on the @@ -103,13 +108,28 @@ void ofp_print_packet(FILE *stream, const void *data, size_t len, prh.incl_len = len; prh.orig_len = total_len; - fwrite(&ph, 1, sizeof ph, tcpdump); - fwrite(&prh, 1, sizeof prh, tcpdump); - fwrite(data, 1, len, tcpdump); + fwrite(&ph, 1, sizeof ph, pcap); + fwrite(&prh, 1, sizeof prh, pcap); + fwrite(data, 1, len, pcap); + + fflush(pcap); + if (ferror(pcap)) { + error(errno, "error writing temporary file"); + } + rewind(pcap); + + snprintf(command, sizeof command, "tcpdump -n -r /dev/fd/%d 2>/dev/null", + fileno(pcap)); + tcpdump = popen(command, "r"); + fclose(pcap); + if (!tcpdump) { + error(errno, "exec(\"%s\")", command); + return xstrdup(""); + } - fflush(tcpdump); - if (ferror(tcpdump)) - error(errno, "error writing \"%s\" subprocess", command); + while ((c = getc(tcpdump)) != EOF) { + ds_put_char(&ds, c); + } status = pclose(tcpdump); if (WIFEXITED(status)) { @@ -118,116 +138,124 @@ void ofp_print_packet(FILE *stream, const void *data, size_t len, } else if (WIFSIGNALED(status)) { error(0, "tcpdump exited with signal %d", WTERMSIG(status)); } + return ds_cstr(&ds); } /* Pretty-print the OFPT_PACKET_IN packet of 'len' bytes at 'oh' to 'stream' * at the given 'verbosity' level. */ -static void ofp_packet_in(FILE *stream, const void *oh, size_t len, - int verbosity) +static void +ofp_packet_in(struct ds *string, const void *oh, size_t len, int verbosity) { const struct ofp_packet_in *op = oh; size_t data_len; - fprintf(stream, " total_len=%"PRIu16" in_port=%"PRIu8, + ds_put_format(string, " total_len=%"PRIu16" in_port=%"PRIu8, ntohs(op->total_len), ntohs(op->in_port)); if (op->reason == OFPR_ACTION) - fputs(" (via action)", stream); + ds_put_cstr(string, " (via action)"); else if (op->reason != OFPR_NO_MATCH) - fprintf(stream, " (***reason %"PRIu8"***)", op->reason); + ds_put_format(string, " (***reason %"PRIu8"***)", op->reason); data_len = len - offsetof(struct ofp_packet_in, data); - fprintf(stream, " data_len=%zu", data_len); + ds_put_format(string, " data_len=%zu", data_len); if (htonl(op->buffer_id) == UINT32_MAX) { - fprintf(stream, " (unbuffered)"); + ds_put_format(string, " (unbuffered)"); if (ntohs(op->total_len) != data_len) - fprintf(stream, " (***total_len != data_len***)"); + ds_put_format(string, " (***total_len != data_len***)"); } else { - fprintf(stream, " buffer=%08"PRIx32, ntohl(op->buffer_id)); + ds_put_format(string, " buffer=%08"PRIx32, ntohl(op->buffer_id)); if (ntohs(op->total_len) < data_len) - fprintf(stream, " (***total_len < data_len***)"); + ds_put_format(string, " (***total_len < data_len***)"); } - putc('\n', stream); + ds_put_char(string, '\n'); - if (verbosity > 0) - ofp_print_packet(stream, op->data, data_len, ntohs(op->total_len)); + if (verbosity > 0) { + char *packet = ofp_packet_to_string(op->data, data_len, + ntohs(op->total_len)); + ds_put_cstr(string, packet); + free(packet); + } } -static void ofp_print_port_name(FILE *stream, uint16_t port) +static void ofp_print_port_name(struct ds *string, uint16_t port) { if (port == UINT16_MAX) { - fputs("none", stream); + ds_put_cstr(string, "none"); } else if (port == OFPP_FLOOD) { - fputs("flood", stream); + ds_put_cstr(string, "flood"); } else if (port == OFPP_CONTROLLER) { - fputs("controller", stream); + ds_put_cstr(string, "controller"); } else { - fprintf(stream, "%"PRIu16, port); + ds_put_format(string, "%"PRIu16, port); } } -static void ofp_print_action(FILE *stream, const struct ofp_action *a) +static void +ofp_print_action(struct ds *string, const struct ofp_action *a) { switch (ntohs(a->type)) { case OFPAT_OUTPUT: - fputs("output(", stream); - ofp_print_port_name(stream, ntohs(a->arg.output.port)); + ds_put_cstr(string, "output("); + ofp_print_port_name(string, ntohs(a->arg.output.port)); if (a->arg.output.port == htons(OFPP_CONTROLLER)) { - fprintf(stream, ", max %"PRIu16" bytes", ntohs(a->arg.output.max_len)); + ds_put_format(string, ", max %"PRIu16" bytes", ntohs(a->arg.output.max_len)); } - fputs(")", stream); + ds_put_cstr(string, ")"); break; default: - fprintf(stream, "(decoder %"PRIu16" not implemented)", ntohs(a->type)); + ds_put_format(string, "(decoder %"PRIu16" not implemented)", ntohs(a->type)); break; } } -static void ofp_print_actions(FILE *stream, - const struct ofp_action actions[], - size_t n_bytes) +static void ofp_print_actions(struct ds *string, + const struct ofp_action actions[], + size_t n_bytes) { size_t i; - fputs(" actions[", stream); + ds_put_cstr(string, " actions["); for (i = 0; i < n_bytes / sizeof *actions; i++) { if (i) { - fputs("; ", stream); + ds_put_cstr(string, "; "); } - ofp_print_action(stream, &actions[i]); + ofp_print_action(string, &actions[i]); } if (n_bytes % sizeof *actions) { if (i) { - fputs("; ", stream); + ds_put_cstr(string, "; "); } - fputs("; ***trailing garbage***", stream); + ds_put_cstr(string, "; ***trailing garbage***"); } - fputs("]", stream); + ds_put_cstr(string, "]"); } -/* Pretty-print the OFPT_PACKET_OUT packet of 'len' bytes at 'oh' to 'stream' +/* Pretty-print the OFPT_PACKET_OUT packet of 'len' bytes at 'oh' to 'string' * at the given 'verbosity' level. */ -static void ofp_packet_out(FILE *stream, const void *oh, size_t len, - int verbosity) +static void ofp_packet_out(struct ds *string, const void *oh, size_t len, + int verbosity) { const struct ofp_packet_out *opo = oh; - fputs(" in_port=", stream); - ofp_print_port_name(stream, ntohs(opo->in_port)); + ds_put_cstr(string, " in_port="); + ofp_print_port_name(string, ntohs(opo->in_port)); if (ntohl(opo->buffer_id) == UINT32_MAX) { - fputs(" out_port=", stream); - ofp_print_port_name(stream, ntohs(opo->out_port)); + ds_put_cstr(string, " out_port="); + ofp_print_port_name(string, ntohs(opo->out_port)); if (verbosity > 0 && len > sizeof *opo) { - ofp_print_packet(stream, opo->u.data, len - sizeof *opo, - len - sizeof *opo); + char *packet = ofp_packet_to_string(opo->u.data, len - sizeof *opo, + len - sizeof *opo); + ds_put_cstr(string, packet); + free(packet); } } else { - fprintf(stream, " buffer=%08"PRIx32, ntohl(opo->buffer_id)); - ofp_print_actions(stream, opo->u.actions, len - sizeof *opo); + ds_put_format(string, " buffer=%08"PRIx32, ntohl(opo->buffer_id)); + ofp_print_actions(string, opo->u.actions, len - sizeof *opo); } - putc('\n', stream); + ds_put_char(string, '\n'); } /* qsort comparison function. */ @@ -242,8 +270,8 @@ compare_ports(const void *a_, const void *b_) return ap < bp ? -1 : ap > bp; } -static -void ofp_print_phy_port(FILE *stream, const struct ofp_phy_port *port) +static void +ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port) { uint8_t name[OFP_MAX_PORT_NAME_LEN]; int j; @@ -256,7 +284,7 @@ void ofp_print_phy_port(FILE *stream, const struct ofp_phy_port *port) } name[j] = '\0'; - fprintf(stream, " %2d(%s): addr:"ETH_ADDR_FMT", speed:%d, flags:%#x, " + ds_put_format(string, " %2d(%s): addr:"ETH_ADDR_FMT", speed:%d, flags:%#x, " "feat:%#x\n", ntohs(port->port_no), name, ETH_ADDR_ARGS(port->hw_addr), ntohl(port->speed), ntohl(port->flags), ntohl(port->features)); @@ -264,7 +292,7 @@ void ofp_print_phy_port(FILE *stream, const struct ofp_phy_port *port) /* Pretty-print the OFPT_DATA_HELLO packet of 'len' bytes at 'oh' to 'stream' * at the given 'verbosity' level. */ -void ofp_print_data_hello(FILE *stream, const void *oh, size_t len, +void ofp_print_data_hello(struct ds *string, const void *oh, size_t len, int verbosity) { const struct ofp_data_hello *odh = oh; @@ -273,14 +301,14 @@ void ofp_print_data_hello(FILE *stream, const void *oh, size_t len, int i; - fprintf(stream, "dp id:%"PRIx64"\n", ntohll(odh->datapath_id)); - fprintf(stream, "tables: exact:%d, mac:%d, compressed:%d, general:%d\n", + ds_put_format(string, "dp id:%"PRIx64"\n", ntohll(odh->datapath_id)); + ds_put_format(string, "tables: exact:%d, mac:%d, compressed:%d, general:%d\n", ntohl(odh->n_exact), ntohl(odh->n_mac_only), ntohl(odh->n_compression), ntohl(odh->n_general)); - fprintf(stream, "buffers: size:%d, number:%d, miss_len:%d\n", + ds_put_format(string, "buffers: size:%d, number:%d, miss_len:%d\n", ntohl(odh->buffer_mb), ntohl(odh->n_buffers), ntohs(odh->miss_send_len)); - fprintf(stream, "features: capabilities:%#x, actions:%#x\n", + ds_put_format(string, "features: capabilities:%#x, actions:%#x\n", ntohl(odh->capabilities), ntohl(odh->actions)); if (ntohs(odh->header.length) >= sizeof *odh) { @@ -291,30 +319,30 @@ void ofp_print_data_hello(FILE *stream, const void *oh, size_t len, memcpy(port_list, odh->ports, (len - sizeof *odh)); qsort(port_list, n_ports, sizeof port_list[0], compare_ports); for (i = 0; i < n_ports; i++) { - ofp_print_phy_port(stream, &port_list[i]); + ofp_print_phy_port(string, &port_list[i]); } } -static void print_wild(FILE *stream, const char *leader, int is_wild, +static void print_wild(struct ds *string, const char *leader, int is_wild, const char *format, ...) __attribute__((format(printf, 4, 5))); -static void print_wild(FILE *stream, const char *leader, int is_wild, +static void print_wild(struct ds *string, const char *leader, int is_wild, const char *format, ...) { - fputs(leader, stream); + ds_put_cstr(string, leader); if (!is_wild) { va_list args; va_start(args, format); - vfprintf(stream, format, args); + ds_put_format_valist(string, format, args); va_end(args); } else { - putc('?', stream); + ds_put_char(string, '?'); } } /* Pretty-print the ofp_match structure */ -static void ofp_print_match(FILE *f, const struct ofp_match *om) +static void ofp_print_match(struct ds *f, const struct ofp_match *om) { uint16_t w = ntohs(om->wildcards); @@ -330,58 +358,59 @@ static void ofp_print_match(FILE *f, const struct ofp_match *om) print_wild(f, "] proto", w & OFPFW_NW_PROTO, "%u", om->nw_proto); print_wild(f, " tport[", w & OFPFW_TP_SRC, "%d", ntohs(om->tp_src)); print_wild(f, "->", w & OFPFW_TP_DST, "%d", ntohs(om->tp_dst)); - fputs("]\n", f); + ds_put_cstr(f, "]\n"); } -/* Pretty-print the OFPT_FLOW_MOD packet of 'len' bytes at 'oh' to 'stream' +/* Pretty-print the OFPT_FLOW_MOD packet of 'len' bytes at 'oh' to 'string' * at the given 'verbosity' level. */ -void ofp_print_flow_mod(FILE *stream, const void *oh, size_t len, - int verbosity) +static void +ofp_print_flow_mod(struct ds *string, const void *oh, size_t len, + int verbosity) { const struct ofp_flow_mod *ofm = oh; - ofp_print_match(stream, &ofm->match); - fprintf(stream, " cmd:%d idle:%d buf:%#x grp:%d\n", ntohs(ofm->command), + ofp_print_match(string, &ofm->match); + ds_put_format(string, " cmd:%d idle:%d buf:%#x grp:%d\n", ntohs(ofm->command), ntohs(ofm->max_idle), ntohl(ofm->buffer_id), ntohl(ofm->group_id)); } -/* Pretty-print the OFPT_FLOW_EXPIRED packet of 'len' bytes at 'oh' to 'stream' +/* Pretty-print the OFPT_FLOW_EXPIRED packet of 'len' bytes at 'oh' to 'string' * at the given 'verbosity' level. */ -void ofp_print_flow_expired(FILE *stream, const void *oh, size_t len, +void ofp_print_flow_expired(struct ds *string, const void *oh, size_t len, int verbosity) { const struct ofp_flow_expired *ofe = oh; - ofp_print_match(stream, &ofe->match); - fprintf(stream, + ofp_print_match(string, &ofe->match); + ds_put_format(string, " secs%d pkts%lld bytes%lld\n", ntohl(ofe->duration), ntohll(ofe->packet_count), ntohll(ofe->byte_count)); } -/* Pretty-print the OFPT_PORT_STATUS packet of 'len' bytes at 'oh' to 'stream' +/* Pretty-print the OFPT_PORT_STATUS packet of 'len' bytes at 'oh' to 'string' * at the given 'verbosity' level. */ -void ofp_print_port_status(FILE *stream, const void *oh, size_t len, +void ofp_print_port_status(struct ds *string, const void *oh, size_t len, int verbosity) { const struct ofp_port_status *ops = oh; if (ops->reason == OFPPR_ADD) { - fprintf(stream, "add:"); + ds_put_format(string, "add:"); } else if (ops->reason == OFPPR_DELETE) { - fprintf(stream, "del:"); + ds_put_format(string, "del:"); } else if (ops->reason == OFPPR_MOD) { - fprintf(stream, "mod:"); + ds_put_format(string, "mod:"); } else { - fprintf(stream, "err:"); + ds_put_format(string, "err:"); } - ofp_print_phy_port(stream, &ops->desc); + ofp_print_phy_port(string, &ops->desc); } struct openflow_packet { const char *name; size_t min_size; - void (*printer)(FILE *, const void *, size_t len, int verbosity); + void (*printer)(struct ds *, const void *, size_t len, int verbosity); }; static const struct openflow_packet packets[] = { @@ -427,58 +456,97 @@ static const struct openflow_packet packets[] = { }, }; -/* Pretty-print the OpenFlow packet of 'len' bytes at 'oh' to 'stream' at the - * given 'verbosity' level. 0 is a minimal amount of verbosity and higher - * numbers increase verbosity. */ -void ofp_print(FILE *stream, const void *oh_, size_t len, int verbosity) +/* Composes and returns a string representing the OpenFlow packet of 'len' + * bytes at 'oh' at the given 'verbosity' level. 0 is a minimal amount of + * verbosity and higher numbers increase verbosity. The caller is responsible + * for freeing the string. */ +char * +ofp_to_string(const void *oh_, size_t len, int verbosity) { + struct ds string = DS_EMPTY_INITIALIZER; const struct ofp_header *oh = oh_; const struct openflow_packet *pkt; if (len < sizeof(struct ofp_header)) { - fprintf(stream, "OpenFlow packet too short:\n"); - hex_dump(stream, oh, len, 0, true); - return; + ds_put_cstr(&string, "OpenFlow packet too short:\n"); + ds_put_hex_dump(&string, oh, len, 0, true); + return ds_cstr(&string); } else if (oh->version != 1) { - fprintf(stream, "Bad OpenFlow version %"PRIu8":\n", oh->version); - hex_dump(stream, oh, len, 0, true); - return; + ds_put_format(&string, "Bad OpenFlow version %"PRIu8":\n", oh->version); + ds_put_hex_dump(&string, oh, len, 0, true); + return ds_cstr(&string); } else if (oh->type >= ARRAY_SIZE(packets) || !packets[oh->type].name) { - fprintf(stream, "Unknown OpenFlow packet type %"PRIu8":\n", + ds_put_format(&string, "Unknown OpenFlow packet type %"PRIu8":\n", oh->type); - hex_dump(stream, oh, len, 0, true); - return; + ds_put_hex_dump(&string, oh, len, 0, true); + return ds_cstr(&string); } pkt = &packets[oh->type]; - fprintf(stream, "%s (xid=%"PRIx32"):", pkt->name, oh->xid); + ds_put_format(&string, "%s (xid=%"PRIx32"):", pkt->name, oh->xid); if (ntohs(oh->length) > len) - fprintf(stream, " (***truncated to %zu bytes from %"PRIu16"***)", + ds_put_format(&string, " (***truncated to %zu bytes from %"PRIu16"***)", len, ntohs(oh->length)); else if (ntohs(oh->length) < len) { - fprintf(stream, " (***only uses %"PRIu16" bytes out of %zu***)\n", + ds_put_format(&string, " (***only uses %"PRIu16" bytes out of %zu***)\n", ntohs(oh->length), len); len = ntohs(oh->length); } if (len < pkt->min_size) { - fprintf(stream, " (***length=%zu < min_size=%zu***)\n", + ds_put_format(&string, " (***length=%zu < min_size=%zu***)\n", len, pkt->min_size); } else if (!pkt->printer) { - fprintf(stream, " length=%zu (decoder not implemented)\n", + ds_put_format(&string, " length=%zu (decoder not implemented)\n", ntohs(oh->length)); } else { - pkt->printer(stream, oh, len, verbosity); + pkt->printer(&string, oh, len, verbosity); + } + if (verbosity >= 3) { + ds_put_hex_dump(&string, oh, len, 0, true); } - if (verbosity >= 3) - hex_dump(stream, oh, len, 0, true); + return ds_cstr(&string); +} + +char * +ofp_table_to_string(const struct ofp_table* ot) +{ + return xasprintf("id: %d name: %-8s n_flows: %6d max_flows: %6d", + ntohs(ot->table_id), ot->name, ntohl(ot->n_flows), + ntohl(ot->max_flows)); +} + +static void +print_and_free(FILE *stream, char *string) +{ + fputs(string, stream); + free(string); +} + +/* Pretty-print the OpenFlow packet of 'len' bytes at 'oh' to 'stream' at the + * given 'verbosity' level. 0 is a minimal amount of verbosity and higher + * numbers increase verbosity. */ +void +ofp_print(FILE *stream, const void *oh, size_t len, int verbosity) +{ + print_and_free(stream, ofp_to_string(oh, len, verbosity)); } /* Pretty print a openflow table */ -void ofp_print_table(FILE *stream, const struct ofp_table* ot) +void +ofp_print_table(FILE *stream, const struct ofp_table *ot) +{ + print_and_free(stream, ofp_table_to_string(ot)); +} + +/* Dumps the contents of the Ethernet frame in the 'len' bytes starting at + * 'data' to 'stream' using tcpdump. 'total_len' specifies the full length of + * the Ethernet frame (of which 'len' bytes were captured). + * + * This starts and kills a tcpdump subprocess so it's quite expensive. */ +void +ofp_print_packet(FILE *stream, const void *data, size_t len, size_t total_len) { - fprintf(stream, "id: %d name: %-8s n_flows: %6d max_flows: %6d", - ntohs(ot->table_id), ot->name, ntohl(ot->n_flows), - ntohl(ot->max_flows)); + print_and_free(stream, ofp_packet_to_string(data, len, total_len)); }