ofp-print: Cleanup typos in print OpenFlow Flow Stats Reply
[sliver-openvswitch.git] / lib / ofp-print.c
1 /*
2  * Copyright (c) 2008, 2009, 2010 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "ofp-print.h"
19
20 #include <errno.h>
21 #include <inttypes.h>
22 #include <sys/types.h>
23 #include <netinet/in.h>
24 #include <sys/wait.h>
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <ctype.h>
28
29 #include "compiler.h"
30 #include "dynamic-string.h"
31 #include "flow.h"
32 #include "ofpbuf.h"
33 #include "openflow/openflow.h"
34 #include "openflow/nicira-ext.h"
35 #include "packets.h"
36 #include "pcap.h"
37 #include "util.h"
38 #include "xtoxll.h"
39
40 static void ofp_print_port_name(struct ds *string, uint16_t port);
41
42 /* Returns a string that represents the contents of the Ethernet frame in the
43  * 'len' bytes starting at 'data' to 'stream' as output by tcpdump.
44  * 'total_len' specifies the full length of the Ethernet frame (of which 'len'
45  * bytes were captured).
46  *
47  * The caller must free the returned string.
48  *
49  * This starts and kills a tcpdump subprocess so it's quite expensive. */
50 char *
51 ofp_packet_to_string(const void *data, size_t len, size_t total_len OVS_UNUSED)
52 {
53     struct ds ds = DS_EMPTY_INITIALIZER;
54     struct ofpbuf buf;
55
56     char command[128];
57     FILE *pcap;
58     FILE *tcpdump;
59     int status;
60     int c;
61
62     buf.data = (void *) data;
63     buf.size = len;
64
65     pcap = tmpfile();
66     if (!pcap) {
67         ovs_error(errno, "tmpfile");
68         return xstrdup("<error>");
69     }
70     pcap_write_header(pcap);
71     pcap_write(pcap, &buf);
72     fflush(pcap);
73     if (ferror(pcap)) {
74         ovs_error(errno, "error writing temporary file");
75     }
76     rewind(pcap);
77
78     snprintf(command, sizeof command, "/usr/sbin/tcpdump -e -n -r /dev/fd/%d 2>/dev/null",
79              fileno(pcap));
80     tcpdump = popen(command, "r");
81     fclose(pcap);
82     if (!tcpdump) {
83         ovs_error(errno, "exec(\"%s\")", command);
84         return xstrdup("<error>");
85     }
86
87     while ((c = getc(tcpdump)) != EOF) {
88         ds_put_char(&ds, c);
89     }
90
91     status = pclose(tcpdump);
92     if (WIFEXITED(status)) {
93         if (WEXITSTATUS(status))
94             ovs_error(0, "tcpdump exited with status %d", WEXITSTATUS(status));
95     } else if (WIFSIGNALED(status)) {
96         ovs_error(0, "tcpdump exited with signal %d", WTERMSIG(status)); 
97     }
98     return ds_cstr(&ds);
99 }
100
101 /* Pretty-print the OFPT_PACKET_IN packet of 'len' bytes at 'oh' to 'stream'
102  * at the given 'verbosity' level. */
103 static void
104 ofp_packet_in(struct ds *string, const void *oh, size_t len, int verbosity)
105 {
106     const struct ofp_packet_in *op = oh;
107     size_t data_len;
108
109     ds_put_format(string, " total_len=%"PRIu16" in_port=",
110                   ntohs(op->total_len));
111     ofp_print_port_name(string, ntohs(op->in_port));
112
113     if (op->reason == OFPR_ACTION)
114         ds_put_cstr(string, " (via action)");
115     else if (op->reason != OFPR_NO_MATCH)
116         ds_put_format(string, " (***reason %"PRIu8"***)", op->reason);
117
118     data_len = len - offsetof(struct ofp_packet_in, data);
119     ds_put_format(string, " data_len=%zu", data_len);
120     if (htonl(op->buffer_id) == UINT32_MAX) {
121         ds_put_format(string, " (unbuffered)");
122         if (ntohs(op->total_len) != data_len)
123             ds_put_format(string, " (***total_len != data_len***)");
124     } else {
125         ds_put_format(string, " buffer=0x%08"PRIx32, ntohl(op->buffer_id));
126         if (ntohs(op->total_len) < data_len)
127             ds_put_format(string, " (***total_len < data_len***)");
128     }
129     ds_put_char(string, '\n');
130
131     if (verbosity > 0) {
132         flow_t flow;
133         struct ofpbuf packet;
134         struct ofp_match match;
135         packet.data = (void *) op->data;
136         packet.size = data_len;
137         flow_extract(&packet, ntohs(op->in_port), &flow);
138         flow_to_match(&flow, 0, &match);
139         ofp_print_match(string, &match, verbosity);
140         ds_put_char(string, '\n');
141     }
142     if (verbosity > 1) {
143         char *packet = ofp_packet_to_string(op->data, data_len,
144                                             ntohs(op->total_len)); 
145         ds_put_cstr(string, packet);
146         free(packet);
147     }
148 }
149
150 static void ofp_print_port_name(struct ds *string, uint16_t port) 
151 {
152     const char *name;
153     switch (port) {
154     case OFPP_IN_PORT:
155         name = "IN_PORT";
156         break;
157     case OFPP_TABLE:
158         name = "TABLE";
159         break;
160     case OFPP_NORMAL:
161         name = "NORMAL";
162         break;
163     case OFPP_FLOOD:
164         name = "FLOOD";
165         break;
166     case OFPP_ALL:
167         name = "ALL";
168         break;
169     case OFPP_CONTROLLER:
170         name = "CONTROLLER";
171         break;
172     case OFPP_LOCAL:
173         name = "LOCAL";
174         break;
175     case OFPP_NONE:
176         name = "NONE";
177         break;
178     default:
179         ds_put_format(string, "%"PRIu16, port);
180         return;
181     }
182     ds_put_cstr(string, name);
183 }
184
185 static void
186 ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah)
187 {
188     switch (ntohs(nah->subtype)) {
189     case NXAST_RESUBMIT: {
190         const struct nx_action_resubmit *nar = (struct nx_action_resubmit *)nah;
191         ds_put_format(string, "resubmit:");
192         ofp_print_port_name(string, ntohs(nar->in_port));
193         break;
194     }
195
196     default:
197         ds_put_format(string, "***unknown Nicira action:%d***\n",
198                       ntohs(nah->subtype));
199     }
200 }
201
202 static int
203 ofp_print_action(struct ds *string, const struct ofp_action_header *ah, 
204         size_t actions_len) 
205 {
206     uint16_t type;
207     size_t len;
208
209     struct openflow_action {
210         size_t min_size;
211         size_t max_size;
212     };
213
214     const struct openflow_action of_actions[] = {
215         [OFPAT_OUTPUT] = {
216             sizeof(struct ofp_action_output),
217             sizeof(struct ofp_action_output),
218         },
219         [OFPAT_SET_VLAN_VID] = {
220             sizeof(struct ofp_action_vlan_vid),
221             sizeof(struct ofp_action_vlan_vid),
222         },
223         [OFPAT_SET_VLAN_PCP] = {
224             sizeof(struct ofp_action_vlan_pcp),
225             sizeof(struct ofp_action_vlan_pcp),
226         },
227         [OFPAT_STRIP_VLAN] = {
228             sizeof(struct ofp_action_header),
229             sizeof(struct ofp_action_header),
230         },
231         [OFPAT_SET_DL_SRC] = {
232             sizeof(struct ofp_action_dl_addr),
233             sizeof(struct ofp_action_dl_addr),
234         },
235         [OFPAT_SET_DL_DST] = {
236             sizeof(struct ofp_action_dl_addr),
237             sizeof(struct ofp_action_dl_addr),
238         },
239         [OFPAT_SET_NW_SRC] = {
240             sizeof(struct ofp_action_nw_addr),
241             sizeof(struct ofp_action_nw_addr),
242         },
243         [OFPAT_SET_NW_DST] = {
244             sizeof(struct ofp_action_nw_addr),
245             sizeof(struct ofp_action_nw_addr),
246         },
247         [OFPAT_SET_NW_TOS] = {
248             sizeof(struct ofp_action_nw_tos),
249             sizeof(struct ofp_action_nw_tos),
250         },
251         [OFPAT_SET_TP_SRC] = {
252             sizeof(struct ofp_action_tp_port),
253             sizeof(struct ofp_action_tp_port),
254         },
255         [OFPAT_SET_TP_DST] = {
256             sizeof(struct ofp_action_tp_port),
257             sizeof(struct ofp_action_tp_port),
258         }
259         /* OFPAT_VENDOR is not here, since it would blow up the array size. */
260     };
261
262     if (actions_len < sizeof *ah) {
263         ds_put_format(string, "***action array too short for next action***\n");
264         return -1;
265     }
266
267     type = ntohs(ah->type);
268     len = ntohs(ah->len);
269     if (actions_len < len) {
270         ds_put_format(string, "***truncated action %"PRIu16"***\n", type);
271         return -1;
272     }
273
274     if ((len % 8) != 0) {
275         ds_put_format(string, 
276                 "***action %"PRIu16" length not a multiple of 8***\n",
277                 type);
278         return -1;
279     }
280
281     if (type < ARRAY_SIZE(of_actions)) {
282         const struct openflow_action *act = &of_actions[type];
283         if ((len < act->min_size) || (len > act->max_size)) {
284             ds_put_format(string, 
285                     "***action %"PRIu16" wrong length: %zu***\n", type, len);
286             return -1;
287         }
288     }
289     
290     switch (type) {
291     case OFPAT_OUTPUT: {
292         struct ofp_action_output *oa = (struct ofp_action_output *)ah;
293         uint16_t port = ntohs(oa->port); 
294         if (port < OFPP_MAX) {
295             ds_put_format(string, "output:%"PRIu16, port);
296         } else {
297             ofp_print_port_name(string, port);
298             if (port == OFPP_CONTROLLER) {
299                 if (oa->max_len) {
300                     ds_put_format(string, ":%"PRIu16, ntohs(oa->max_len));
301                 } else {
302                     ds_put_cstr(string, ":all");
303                 }
304             }
305         }
306         break;
307     }
308
309     case OFPAT_SET_VLAN_VID: {
310         struct ofp_action_vlan_vid *va = (struct ofp_action_vlan_vid *)ah;
311         ds_put_format(string, "mod_vlan_vid:%"PRIu16, ntohs(va->vlan_vid));
312         break;
313     }
314
315     case OFPAT_SET_VLAN_PCP: {
316         struct ofp_action_vlan_pcp *va = (struct ofp_action_vlan_pcp *)ah;
317         ds_put_format(string, "mod_vlan_pcp:%"PRIu8, va->vlan_pcp);
318         break;
319     }
320
321     case OFPAT_STRIP_VLAN:
322         ds_put_cstr(string, "strip_vlan");
323         break;
324
325     case OFPAT_SET_DL_SRC: {
326         struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah;
327         ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT, 
328                 ETH_ADDR_ARGS(da->dl_addr));
329         break;
330     }
331
332     case OFPAT_SET_DL_DST: {
333         struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah;
334         ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT, 
335                 ETH_ADDR_ARGS(da->dl_addr));
336         break;
337     }
338
339     case OFPAT_SET_NW_SRC: {
340         struct ofp_action_nw_addr *na = (struct ofp_action_nw_addr *)ah;
341         ds_put_format(string, "mod_nw_src:"IP_FMT, IP_ARGS(&na->nw_addr));
342         break;
343     }
344
345     case OFPAT_SET_NW_DST: {
346         struct ofp_action_nw_addr *na = (struct ofp_action_nw_addr *)ah;
347         ds_put_format(string, "mod_nw_dst:"IP_FMT, IP_ARGS(&na->nw_addr));
348         break;
349     }
350
351     case OFPAT_SET_NW_TOS: {
352         struct ofp_action_nw_tos *nt = (struct ofp_action_nw_tos *)ah;
353         ds_put_format(string, "mod_nw_tos:%d", nt->nw_tos);
354         break;
355     }
356
357     case OFPAT_SET_TP_SRC: {
358         struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah;
359         ds_put_format(string, "mod_tp_src:%d", ntohs(ta->tp_port));
360         break;
361     }
362
363     case OFPAT_SET_TP_DST: {
364         struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah;
365         ds_put_format(string, "mod_tp_dst:%d", ntohs(ta->tp_port));
366         break;
367     }
368
369     case OFPAT_VENDOR: {
370         struct ofp_action_vendor_header *avh 
371                 = (struct ofp_action_vendor_header *)ah;
372         if (len < sizeof *avh) {
373             ds_put_format(string, "***ofpat_vendor truncated***\n");
374             return -1;
375         }
376         if (avh->vendor == htonl(NX_VENDOR_ID)) {
377             ofp_print_nx_action(string, (struct nx_action_header *)avh);
378         } else {
379             ds_put_format(string, "vendor action:0x%x", ntohl(avh->vendor));
380         }
381         break;
382     }
383
384     default:
385         ds_put_format(string, "(decoder %"PRIu16" not implemented)", type);
386         break;
387     }
388
389     return len;
390 }
391
392 void 
393 ofp_print_actions(struct ds *string, const struct ofp_action_header *action,
394                   size_t actions_len) 
395 {
396     uint8_t *p = (uint8_t *)action;
397     int len = 0;
398
399     ds_put_cstr(string, "actions=");
400     if (!actions_len) {
401         ds_put_cstr(string, "drop");
402     }
403     while (actions_len > 0) {
404         if (len) {
405             ds_put_cstr(string, ",");
406         }
407         len = ofp_print_action(string, (struct ofp_action_header *)p, 
408                 actions_len);
409         if (len < 0) {
410             return;
411         }
412         p += len;
413         actions_len -= len;
414     }
415 }
416
417 /* Pretty-print the OFPT_PACKET_OUT packet of 'len' bytes at 'oh' to 'string'
418  * at the given 'verbosity' level. */
419 static void ofp_packet_out(struct ds *string, const void *oh, size_t len,
420                            int verbosity) 
421 {
422     const struct ofp_packet_out *opo = oh;
423     size_t actions_len = ntohs(opo->actions_len);
424
425     ds_put_cstr(string, " in_port=");
426     ofp_print_port_name(string, ntohs(opo->in_port));
427
428     ds_put_format(string, " actions_len=%zu ", actions_len);
429     if (actions_len > (ntohs(opo->header.length) - sizeof *opo)) {
430         ds_put_format(string, "***packet too short for action length***\n");
431         return;
432     }
433     ofp_print_actions(string, opo->actions, actions_len);
434
435     if (ntohl(opo->buffer_id) == UINT32_MAX) {
436         int data_len = len - sizeof *opo - actions_len;
437         ds_put_format(string, " data_len=%d", data_len);
438         if (verbosity > 0 && len > sizeof *opo) {
439             char *packet = ofp_packet_to_string(
440                     (uint8_t *)opo->actions + actions_len, data_len, data_len);
441             ds_put_char(string, '\n');
442             ds_put_cstr(string, packet);
443             free(packet);
444         }
445     } else {
446         ds_put_format(string, " buffer=0x%08"PRIx32, ntohl(opo->buffer_id));
447     }
448     ds_put_char(string, '\n');
449 }
450
451 /* qsort comparison function. */
452 static int
453 compare_ports(const void *a_, const void *b_)
454 {
455     const struct ofp_phy_port *a = a_;
456     const struct ofp_phy_port *b = b_;
457     uint16_t ap = ntohs(a->port_no);
458     uint16_t bp = ntohs(b->port_no);
459
460     return ap < bp ? -1 : ap > bp;
461 }
462
463 static void ofp_print_port_features(struct ds *string, uint32_t features)
464 {
465     if (features == 0) {
466         ds_put_cstr(string, "Unsupported\n");
467         return;
468     }
469     if (features & OFPPF_10MB_HD) {
470         ds_put_cstr(string, "10MB-HD ");
471     }
472     if (features & OFPPF_10MB_FD) {
473         ds_put_cstr(string, "10MB-FD ");
474     }
475     if (features & OFPPF_100MB_HD) {
476         ds_put_cstr(string, "100MB-HD ");
477     }
478     if (features & OFPPF_100MB_FD) {
479         ds_put_cstr(string, "100MB-FD ");
480     }
481     if (features & OFPPF_1GB_HD) {
482         ds_put_cstr(string, "1GB-HD ");
483     }
484     if (features & OFPPF_1GB_FD) {
485         ds_put_cstr(string, "1GB-FD ");
486     }
487     if (features & OFPPF_10GB_FD) {
488         ds_put_cstr(string, "10GB-FD ");
489     }
490     if (features & OFPPF_COPPER) {
491         ds_put_cstr(string, "COPPER ");
492     }
493     if (features & OFPPF_FIBER) {
494         ds_put_cstr(string, "FIBER ");
495     }
496     if (features & OFPPF_AUTONEG) {
497         ds_put_cstr(string, "AUTO_NEG ");
498     }
499     if (features & OFPPF_PAUSE) {
500         ds_put_cstr(string, "AUTO_PAUSE ");
501     }
502     if (features & OFPPF_PAUSE_ASYM) {
503         ds_put_cstr(string, "AUTO_PAUSE_ASYM ");
504     }
505     ds_put_char(string, '\n');
506 }
507
508 static void
509 ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port)
510 {
511     uint8_t name[OFP_MAX_PORT_NAME_LEN];
512     int j;
513
514     memcpy(name, port->name, sizeof name);
515     for (j = 0; j < sizeof name - 1; j++) {
516         if (!isprint(name[j])) {
517             break;
518         }
519     }
520     name[j] = '\0';
521
522     ds_put_char(string, ' ');
523     ofp_print_port_name(string, ntohs(port->port_no));
524     ds_put_format(string, "(%s): addr:"ETH_ADDR_FMT", config: %#x, state:%#x\n",
525             name, ETH_ADDR_ARGS(port->hw_addr), ntohl(port->config),
526             ntohl(port->state));
527     if (port->curr) {
528         ds_put_format(string, "     current:    ");
529         ofp_print_port_features(string, ntohl(port->curr));
530     }
531     if (port->advertised) {
532         ds_put_format(string, "     advertised: ");
533         ofp_print_port_features(string, ntohl(port->advertised));
534     }
535     if (port->supported) {
536         ds_put_format(string, "     supported:  ");
537         ofp_print_port_features(string, ntohl(port->supported));
538     }
539     if (port->peer) {
540         ds_put_format(string, "     peer:       ");
541         ofp_print_port_features(string, ntohl(port->peer));
542     }
543 }
544
545 /* Pretty-print the struct ofp_switch_features of 'len' bytes at 'oh' to
546  * 'string' at the given 'verbosity' level. */
547 static void
548 ofp_print_switch_features(struct ds *string, const void *oh, size_t len,
549                           int verbosity OVS_UNUSED)
550 {
551     const struct ofp_switch_features *osf = oh;
552     struct ofp_phy_port *port_list;
553     int n_ports;
554     int i;
555
556     ds_put_format(string, " ver:0x%x, dpid:%016"PRIx64"\n", 
557             osf->header.version, ntohll(osf->datapath_id));
558     ds_put_format(string, "n_tables:%d, n_buffers:%d\n", osf->n_tables,
559             ntohl(osf->n_buffers));
560     ds_put_format(string, "features: capabilities:%#x, actions:%#x\n",
561            ntohl(osf->capabilities), ntohl(osf->actions));
562
563     if (ntohs(osf->header.length) >= sizeof *osf) {
564         len = MIN(len, ntohs(osf->header.length));
565     }
566     n_ports = (len - sizeof *osf) / sizeof *osf->ports;
567
568     port_list = xmemdup(osf->ports, len - sizeof *osf); 
569     qsort(port_list, n_ports, sizeof *port_list, compare_ports);
570     for (i = 0; i < n_ports; i++) {
571         ofp_print_phy_port(string, &port_list[i]);
572     }
573     free(port_list);
574 }
575
576 /* Pretty-print the struct ofp_switch_config of 'len' bytes at 'oh' to 'string'
577  * at the given 'verbosity' level. */
578 static void
579 ofp_print_switch_config(struct ds *string, const void *oh,
580                         size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
581 {
582     const struct ofp_switch_config *osc = oh;
583     uint16_t flags;
584
585     flags = ntohs(osc->flags);
586     if (flags) {
587         ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", flags);
588     }
589
590     ds_put_format(string, " miss_send_len=%"PRIu16"\n", ntohs(osc->miss_send_len));
591 }
592
593 static void print_wild(struct ds *string, const char *leader, int is_wild,
594             int verbosity, const char *format, ...) 
595             __attribute__((format(printf, 5, 6)));
596
597 static void print_wild(struct ds *string, const char *leader, int is_wild,
598                        int verbosity, const char *format, ...) 
599 {
600     if (is_wild && verbosity < 2) {
601         return;
602     }
603     ds_put_cstr(string, leader);
604     if (!is_wild) {
605         va_list args;
606
607         va_start(args, format);
608         ds_put_format_valist(string, format, args);
609         va_end(args);
610     } else {
611         ds_put_char(string, '*');
612     }
613     ds_put_char(string, ',');
614 }
615
616 static void
617 print_ip_netmask(struct ds *string, const char *leader, uint32_t ip,
618                  uint32_t wild_bits, int verbosity)
619 {
620     if (wild_bits >= 32 && verbosity < 2) {
621         return;
622     }
623     ds_put_cstr(string, leader);
624     if (wild_bits < 32) {
625         ds_put_format(string, IP_FMT, IP_ARGS(&ip));
626         if (wild_bits) {
627             ds_put_format(string, "/%d", 32 - wild_bits);
628         }
629     } else {
630         ds_put_char(string, '*');
631     }
632     ds_put_char(string, ',');
633 }
634
635 void
636 ofp_print_match(struct ds *f, const struct ofp_match *om, int verbosity)
637 {
638     char *s = ofp_match_to_string(om, verbosity);
639     ds_put_cstr(f, s);
640     free(s);
641 }
642
643 char *
644 ofp_match_to_string(const struct ofp_match *om, int verbosity)
645 {
646     struct ds f = DS_EMPTY_INITIALIZER;
647     uint32_t w = ntohl(om->wildcards);
648     bool skip_type = false;
649     bool skip_proto = false;
650
651     if (!(w & OFPFW_DL_TYPE)) {
652         skip_type = true;
653         if (om->dl_type == htons(ETH_TYPE_IP)) {
654             if (!(w & OFPFW_NW_PROTO)) {
655                 skip_proto = true;
656                 if (om->nw_proto == IP_TYPE_ICMP) {
657                     ds_put_cstr(&f, "icmp,");
658                 } else if (om->nw_proto == IP_TYPE_TCP) {
659                     ds_put_cstr(&f, "tcp,");
660                 } else if (om->nw_proto == IP_TYPE_UDP) {
661                     ds_put_cstr(&f, "udp,");
662                 } else {
663                     ds_put_cstr(&f, "ip,");
664                     skip_proto = false;
665                 }
666             } else {
667                 ds_put_cstr(&f, "ip,");
668             }
669         } else if (om->dl_type == htons(ETH_TYPE_ARP)) {
670             ds_put_cstr(&f, "arp,");
671         } else {
672             skip_type = false;
673         }
674     }
675     print_wild(&f, "in_port=", w & OFPFW_IN_PORT, verbosity,
676                "%d", ntohs(om->in_port));
677     print_wild(&f, "dl_vlan=", w & OFPFW_DL_VLAN, verbosity,
678                "0x%04x", ntohs(om->dl_vlan));
679     print_wild(&f, "dl_vlan_pcp=", w & OFPFW_DL_VLAN_PCP, verbosity,
680                "%d", om->dl_vlan_pcp);
681     print_wild(&f, "dl_src=", w & OFPFW_DL_SRC, verbosity,
682                ETH_ADDR_FMT, ETH_ADDR_ARGS(om->dl_src));
683     print_wild(&f, "dl_dst=", w & OFPFW_DL_DST, verbosity,
684                ETH_ADDR_FMT, ETH_ADDR_ARGS(om->dl_dst));
685     if (!skip_type) {
686         print_wild(&f, "dl_type=", w & OFPFW_DL_TYPE, verbosity,
687                    "0x%04x", ntohs(om->dl_type));
688     }
689     print_ip_netmask(&f, "nw_src=", om->nw_src,
690                      (w & OFPFW_NW_SRC_MASK) >> OFPFW_NW_SRC_SHIFT, verbosity);
691     print_ip_netmask(&f, "nw_dst=", om->nw_dst,
692                      (w & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT, verbosity);
693     if (!skip_proto) {
694         if (om->dl_type == htons(ETH_TYPE_ARP)) {
695             print_wild(&f, "opcode=", w & OFPFW_NW_PROTO, verbosity,
696                        "%u", om->nw_proto);
697         } else {
698             print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity,
699                        "%u", om->nw_proto);
700             print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity,
701                        "%u", om->nw_tos);
702         }
703     }
704     if (om->nw_proto == IP_TYPE_ICMP) {
705         print_wild(&f, "icmp_type=", w & OFPFW_ICMP_TYPE, verbosity,
706                    "%d", ntohs(om->icmp_type));
707         print_wild(&f, "icmp_code=", w & OFPFW_ICMP_CODE, verbosity,
708                    "%d", ntohs(om->icmp_code));
709     } else {
710         print_wild(&f, "tp_src=", w & OFPFW_TP_SRC, verbosity,
711                    "%d", ntohs(om->tp_src));
712         print_wild(&f, "tp_dst=", w & OFPFW_TP_DST, verbosity,
713                    "%d", ntohs(om->tp_dst));
714     }
715     return ds_cstr(&f);
716 }
717
718 /* Pretty-print the OFPT_FLOW_MOD packet of 'len' bytes at 'oh' to 'string'
719  * at the given 'verbosity' level. */
720 static void
721 ofp_print_flow_mod(struct ds *string, const void *oh, size_t len, 
722                    int verbosity)
723 {
724     const struct ofp_flow_mod *ofm = oh;
725
726     ofp_print_match(string, &ofm->match, verbosity);
727     switch (ntohs(ofm->command)) {
728     case OFPFC_ADD:
729         ds_put_cstr(string, " ADD: ");
730         break;
731     case OFPFC_MODIFY:
732         ds_put_cstr(string, " MOD: ");
733         break;
734     case OFPFC_MODIFY_STRICT:
735         ds_put_cstr(string, " MOD_STRICT: ");
736         break;
737     case OFPFC_DELETE:
738         ds_put_cstr(string, " DEL: ");
739         break;
740     case OFPFC_DELETE_STRICT:
741         ds_put_cstr(string, " DEL_STRICT: ");
742         break;
743     default:
744         ds_put_format(string, " cmd:%d ", ntohs(ofm->command));
745     }
746     ds_put_format(string, "cookie:%"PRIx64" idle:%d hard:%d pri:%d "
747             "buf:%#x flags:%"PRIx16" ", ntohll(ofm->cookie), 
748             ntohs(ofm->idle_timeout), ntohs(ofm->hard_timeout),
749             ofm->match.wildcards ? ntohs(ofm->priority) : (uint16_t)-1,
750             ntohl(ofm->buffer_id), ntohs(ofm->flags));
751     ofp_print_actions(string, ofm->actions,
752                       len - offsetof(struct ofp_flow_mod, actions));
753     ds_put_char(string, '\n');
754 }
755
756 /* Pretty-print the OFPT_FLOW_REMOVED packet of 'len' bytes at 'oh' to 'string'
757  * at the given 'verbosity' level. */
758 static void
759 ofp_print_flow_removed(struct ds *string, const void *oh, 
760                        size_t len OVS_UNUSED, int verbosity)
761 {
762     const struct ofp_flow_removed *ofr = oh;
763
764     ofp_print_match(string, &ofr->match, verbosity);
765     ds_put_cstr(string, " reason=");
766     switch (ofr->reason) {
767     case OFPRR_IDLE_TIMEOUT:
768         ds_put_cstr(string, "idle");
769         break;
770     case OFPRR_HARD_TIMEOUT:
771         ds_put_cstr(string, "hard");
772         break;
773     case OFPRR_DELETE:
774         ds_put_cstr(string, "delete");
775         break;
776     default:
777         ds_put_format(string, "**%"PRIu8"**", ofr->reason);
778         break;
779     }
780     ds_put_format(string, 
781          " cookie%"PRIx64" pri%"PRIu16" secs%"PRIu32" nsecs%"PRIu32
782          " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n", 
783          ntohll(ofr->cookie),
784          ofr->match.wildcards ? ntohs(ofr->priority) : (uint16_t)-1,
785          ntohl(ofr->duration_sec), ntohl(ofr->duration_nsec),
786          ntohs(ofr->idle_timeout), ntohll(ofr->packet_count), 
787          ntohll(ofr->byte_count));
788 }
789
790 static void
791 ofp_print_port_mod(struct ds *string, const void *oh, size_t len OVS_UNUSED,
792                    int verbosity OVS_UNUSED)
793 {
794     const struct ofp_port_mod *opm = oh;
795
796     ds_put_format(string, "port: %d: addr:"ETH_ADDR_FMT", config: %#x, mask:%#x\n",
797             ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr), 
798             ntohl(opm->config), ntohl(opm->mask));
799     ds_put_format(string, "     advertise: ");
800     if (opm->advertise) {
801         ofp_print_port_features(string, ntohl(opm->advertise));
802     } else {
803         ds_put_format(string, "UNCHANGED\n");
804     }
805 }
806
807 struct error_type {
808     int type;
809     int code;
810     const char *name;
811 };
812
813 static const struct error_type error_types[] = {
814 #define ERROR_TYPE(TYPE) {TYPE, -1, #TYPE}
815 #define ERROR_CODE(TYPE, CODE) {TYPE, CODE, #CODE}
816     ERROR_TYPE(OFPET_HELLO_FAILED),
817     ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE),
818     ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_EPERM),
819
820     ERROR_TYPE(OFPET_BAD_REQUEST),
821     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VERSION),
822     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE),
823     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT),
824     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR),
825     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE),
826     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_EPERM),
827     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN),
828     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_EMPTY),
829     ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN),
830
831     ERROR_TYPE(OFPET_BAD_ACTION),
832     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE),
833     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_LEN),
834     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR),
835     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE),
836     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT),
837     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT),
838     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_EPERM),
839     ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_TOO_MANY),
840
841     ERROR_TYPE(OFPET_FLOW_MOD_FAILED),
842     ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_ALL_TABLES_FULL),
843     ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP),
844     ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_EPERM),
845     ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_EMERG_TIMEOUT),
846     ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND),
847
848     ERROR_TYPE(OFPET_PORT_MOD_FAILED),
849     ERROR_CODE(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_PORT),
850     ERROR_CODE(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR)
851 };
852 #define N_ERROR_TYPES ARRAY_SIZE(error_types)
853
854 static const char *
855 lookup_error_type(int type)
856 {
857     const struct error_type *t;
858
859     for (t = error_types; t < &error_types[N_ERROR_TYPES]; t++) {
860         if (t->type == type && t->code == -1) {
861             return t->name;
862         }
863     }
864     return "?";
865 }
866
867 static const char *
868 lookup_error_code(int type, int code)
869 {
870     const struct error_type *t;
871
872     for (t = error_types; t < &error_types[N_ERROR_TYPES]; t++) {
873         if (t->type == type && t->code == code) {
874             return t->name;
875         }
876     }
877     return "?";
878 }
879
880 /* Pretty-print the OFPT_ERROR packet of 'len' bytes at 'oh' to 'string'
881  * at the given 'verbosity' level. */
882 static void
883 ofp_print_error_msg(struct ds *string, const void *oh, size_t len, 
884                        int verbosity OVS_UNUSED)
885 {
886     const struct ofp_error_msg *oem = oh;
887     int type = ntohs(oem->type);
888     int code = ntohs(oem->code);
889     char *s;
890
891     ds_put_format(string, " type%d(%s) code%d(%s) payload:\n",
892                   type, lookup_error_type(type),
893                   code, lookup_error_code(type, code));
894
895     switch (type) {
896     case OFPET_HELLO_FAILED:
897         ds_put_printable(string, (char *) oem->data, len - sizeof *oem);
898         break;
899
900     case OFPET_BAD_REQUEST:
901         s = ofp_to_string(oem->data, len - sizeof *oem, 1);
902         ds_put_cstr(string, s);
903         free(s);
904         break;
905
906     default:
907         ds_put_hex_dump(string, oem->data, len - sizeof *oem, 0, true);
908         break;
909     }
910 }
911
912 /* Pretty-print the OFPT_PORT_STATUS packet of 'len' bytes at 'oh' to 'string'
913  * at the given 'verbosity' level. */
914 static void
915 ofp_print_port_status(struct ds *string, const void *oh, size_t len OVS_UNUSED,
916                       int verbosity OVS_UNUSED)
917 {
918     const struct ofp_port_status *ops = oh;
919
920     if (ops->reason == OFPPR_ADD) {
921         ds_put_format(string, " ADD:");
922     } else if (ops->reason == OFPPR_DELETE) {
923         ds_put_format(string, " DEL:");
924     } else if (ops->reason == OFPPR_MODIFY) {
925         ds_put_format(string, " MOD:");
926     }
927
928     ofp_print_phy_port(string, &ops->desc);
929 }
930
931 static void
932 ofp_desc_stats_reply(struct ds *string, const void *body,
933                      size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
934 {
935     const struct ofp_desc_stats *ods = body;
936
937     ds_put_format(string, "Manufacturer: %.*s\n", 
938             (int) sizeof ods->mfr_desc, ods->mfr_desc);
939     ds_put_format(string, "Hardware: %.*s\n",
940             (int) sizeof ods->hw_desc, ods->hw_desc);
941     ds_put_format(string, "Software: %.*s\n",
942             (int) sizeof ods->sw_desc, ods->sw_desc);
943     ds_put_format(string, "Serial Num: %.*s\n",
944             (int) sizeof ods->serial_num, ods->serial_num);
945     ds_put_format(string, "DP Description: %.*s\n",
946             (int) sizeof ods->dp_desc, ods->dp_desc);
947 }
948
949 static void
950 ofp_flow_stats_request(struct ds *string, const void *oh,
951                        size_t len OVS_UNUSED, int verbosity)
952 {
953     const struct ofp_flow_stats_request *fsr = oh;
954
955     if (fsr->table_id == 0xff) {
956         ds_put_format(string, " table_id=any, ");
957     } else {
958         ds_put_format(string, " table_id=%"PRIu8", ", fsr->table_id);
959     }
960
961     ofp_print_match(string, &fsr->match, verbosity);
962 }
963
964 static void
965 ofp_flow_stats_reply(struct ds *string, const void *body_, size_t len,
966                      int verbosity)
967 {
968     const char *body = body_;
969     const char *pos = body;
970     for (;;) {
971         const struct ofp_flow_stats *fs;
972         ptrdiff_t bytes_left = body + len - pos;
973         size_t length;
974
975         if (bytes_left < sizeof *fs) {
976             if (bytes_left != 0) {
977                 ds_put_format(string, " ***%td leftover bytes at end***",
978                               bytes_left);
979             }
980             break;
981         }
982
983         fs = (const void *) pos;
984         length = ntohs(fs->length);
985         if (length < sizeof *fs) {
986             ds_put_format(string, " ***length=%zu shorter than minimum %zu***",
987                           length, sizeof *fs);
988             break;
989         } else if (length > bytes_left) {
990             ds_put_format(string,
991                           " ***length=%zu but only %td bytes left***",
992                           length, bytes_left);
993             break;
994         } else if ((length - sizeof *fs) % sizeof fs->actions[0]) {
995             ds_put_format(string,
996                           " ***length=%zu has %zu bytes leftover in "
997                           "final action***",
998                           length,
999                           (length - sizeof *fs) % sizeof fs->actions[0]);
1000             break;
1001         }
1002
1003         ds_put_format(string, "  cookie=%"PRIu64", ", ntohll(fs->cookie));
1004         ds_put_format(string, "duration_sec=%"PRIu32"s, ", 
1005                     ntohl(fs->duration_sec));
1006         ds_put_format(string, "duration_nsec=%"PRIu32"ns, ", 
1007                     ntohl(fs->duration_nsec));
1008         ds_put_format(string, "table_id=%"PRIu8", ", fs->table_id);
1009         ds_put_format(string, "priority=%"PRIu16", ", 
1010                     fs->match.wildcards ? ntohs(fs->priority) : (uint16_t)-1);
1011         ds_put_format(string, "n_packets=%"PRIu64", ",
1012                     ntohll(fs->packet_count));
1013         ds_put_format(string, "n_bytes=%"PRIu64", ", ntohll(fs->byte_count));
1014         if (fs->idle_timeout != htons(OFP_FLOW_PERMANENT)) {
1015             ds_put_format(string, "idle_timeout=%"PRIu16",",
1016                           ntohs(fs->idle_timeout));
1017         }
1018         if (fs->hard_timeout != htons(OFP_FLOW_PERMANENT)) {
1019             ds_put_format(string, "hard_timeout=%"PRIu16",",
1020                           ntohs(fs->hard_timeout));
1021         }
1022         ofp_print_match(string, &fs->match, verbosity);
1023         ofp_print_actions(string, fs->actions, length - sizeof *fs);
1024         ds_put_char(string, '\n');
1025
1026         pos += length;
1027      }
1028 }
1029
1030 static void
1031 ofp_aggregate_stats_request(struct ds *string, const void *oh,
1032                             size_t len OVS_UNUSED, int verbosity)
1033 {
1034     const struct ofp_aggregate_stats_request *asr = oh;
1035
1036     if (asr->table_id == 0xff) {
1037         ds_put_format(string, " table_id=any, ");
1038     } else {
1039         ds_put_format(string, " table_id=%"PRIu8", ", asr->table_id);
1040     }
1041
1042     ofp_print_match(string, &asr->match, verbosity);
1043 }
1044
1045 static void
1046 ofp_aggregate_stats_reply(struct ds *string, const void *body_,
1047                           size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
1048 {
1049     const struct ofp_aggregate_stats_reply *asr = body_;
1050
1051     ds_put_format(string, " packet_count=%"PRIu64, ntohll(asr->packet_count));
1052     ds_put_format(string, " byte_count=%"PRIu64, ntohll(asr->byte_count));
1053     ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count));
1054 }
1055
1056 static void print_port_stat(struct ds *string, const char *leader, 
1057                             uint64_t stat, int more)
1058 {
1059     ds_put_cstr(string, leader);
1060     if (stat != -1) {
1061         ds_put_format(string, "%"PRIu64, stat);
1062     } else {
1063         ds_put_char(string, '?');
1064     }
1065     if (more) {
1066         ds_put_cstr(string, ", ");
1067     } else {
1068         ds_put_cstr(string, "\n");
1069     }
1070 }
1071
1072 static void
1073 ofp_port_stats_request(struct ds *string, const void *body_,
1074                        size_t len OVS_UNUSED, int verbosity OVS_UNUSED)
1075 {
1076     const struct ofp_port_stats_request *psr = body_;
1077     ds_put_format(string, "port_no=%"PRIu16, ntohs(psr->port_no));
1078 }
1079
1080 static void
1081 ofp_port_stats_reply(struct ds *string, const void *body, size_t len,
1082                      int verbosity)
1083 {
1084     const struct ofp_port_stats *ps = body;
1085     size_t n = len / sizeof *ps;
1086     ds_put_format(string, " %zu ports\n", n);
1087     if (verbosity < 1) {
1088         return;
1089     }
1090
1091     for (; n--; ps++) {
1092         ds_put_format(string, "  port %2"PRIu16": ", ntohs(ps->port_no));
1093
1094         ds_put_cstr(string, "rx ");
1095         print_port_stat(string, "pkts=", ntohll(ps->rx_packets), 1);
1096         print_port_stat(string, "bytes=", ntohll(ps->rx_bytes), 1);
1097         print_port_stat(string, "drop=", ntohll(ps->rx_dropped), 1);
1098         print_port_stat(string, "errs=", ntohll(ps->rx_errors), 1);
1099         print_port_stat(string, "frame=", ntohll(ps->rx_frame_err), 1);
1100         print_port_stat(string, "over=", ntohll(ps->rx_over_err), 1);
1101         print_port_stat(string, "crc=", ntohll(ps->rx_crc_err), 0);
1102
1103         ds_put_cstr(string, "           tx ");
1104         print_port_stat(string, "pkts=", ntohll(ps->tx_packets), 1);
1105         print_port_stat(string, "bytes=", ntohll(ps->tx_bytes), 1);
1106         print_port_stat(string, "drop=", ntohll(ps->tx_dropped), 1);
1107         print_port_stat(string, "errs=", ntohll(ps->tx_errors), 1);
1108         print_port_stat(string, "coll=", ntohll(ps->collisions), 0);
1109     }
1110 }
1111
1112 static void
1113 ofp_table_stats_reply(struct ds *string, const void *body, size_t len,
1114                      int verbosity)
1115 {
1116     const struct ofp_table_stats *ts = body;
1117     size_t n = len / sizeof *ts;
1118     ds_put_format(string, " %zu tables\n", n);
1119     if (verbosity < 1) {
1120         return;
1121     }
1122
1123     for (; n--; ts++) {
1124         char name[OFP_MAX_TABLE_NAME_LEN + 1];
1125         strncpy(name, ts->name, sizeof name);
1126         name[OFP_MAX_TABLE_NAME_LEN] = '\0';
1127
1128         ds_put_format(string, "  %d: %-8s: ", ts->table_id, name);
1129         ds_put_format(string, "wild=0x%05"PRIx32", ", ntohl(ts->wildcards));
1130         ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries));
1131         ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
1132         ds_put_cstr(string, "               ");
1133         ds_put_format(string, "lookup=%"PRIu64", ", 
1134                     ntohll(ts->lookup_count));
1135         ds_put_format(string, "matched=%"PRIu64"\n",
1136                     ntohll(ts->matched_count));
1137      }
1138 }
1139
1140 static void
1141 vendor_stat(struct ds *string, const void *body, size_t len,
1142             int verbosity OVS_UNUSED)
1143 {
1144     ds_put_format(string, " vendor=%08"PRIx32, ntohl(*(uint32_t *) body));
1145     ds_put_format(string, " %zu bytes additional data",
1146                   len - sizeof(uint32_t));
1147 }
1148
1149 enum stats_direction {
1150     REQUEST,
1151     REPLY
1152 };
1153
1154 static void
1155 print_stats(struct ds *string, int type, const void *body, size_t body_len,
1156             int verbosity, enum stats_direction direction)
1157 {
1158     struct stats_msg {
1159         size_t min_body, max_body;
1160         void (*printer)(struct ds *, const void *, size_t len, int verbosity);
1161     };
1162
1163     struct stats_type {
1164         int type;
1165         const char *name;
1166         struct stats_msg request;
1167         struct stats_msg reply;
1168     };
1169
1170     static const struct stats_type stats_types[] = {
1171         {
1172             OFPST_DESC,
1173             "description",
1174             { 0, 0, NULL },
1175             { 0, SIZE_MAX, ofp_desc_stats_reply },
1176         },
1177         {
1178             OFPST_FLOW,
1179             "flow",
1180             { sizeof(struct ofp_flow_stats_request),
1181               sizeof(struct ofp_flow_stats_request),
1182               ofp_flow_stats_request },
1183             { 0, SIZE_MAX, ofp_flow_stats_reply },
1184         },
1185         {
1186             OFPST_AGGREGATE,
1187             "aggregate",
1188             { sizeof(struct ofp_aggregate_stats_request),
1189               sizeof(struct ofp_aggregate_stats_request),
1190               ofp_aggregate_stats_request },
1191             { sizeof(struct ofp_aggregate_stats_reply),
1192               sizeof(struct ofp_aggregate_stats_reply),
1193               ofp_aggregate_stats_reply },
1194         },
1195         {
1196             OFPST_TABLE,
1197             "table",
1198             { 0, 0, NULL },
1199             { 0, SIZE_MAX, ofp_table_stats_reply },
1200         },
1201         {
1202             OFPST_PORT,
1203             "port",
1204             { sizeof(struct ofp_port_stats_request), 
1205               sizeof(struct ofp_port_stats_request), 
1206               ofp_port_stats_request },
1207             { 0, SIZE_MAX, ofp_port_stats_reply },
1208         },
1209         {
1210             OFPST_VENDOR,
1211             "vendor-specific",
1212             { sizeof(uint32_t), SIZE_MAX, vendor_stat },
1213             { sizeof(uint32_t), SIZE_MAX, vendor_stat },
1214         },
1215         {
1216             -1,
1217             "unknown",
1218             { 0, 0, NULL, },
1219             { 0, 0, NULL, },
1220         },
1221     };
1222
1223     const struct stats_type *s;
1224     const struct stats_msg *m;
1225
1226     if (type >= ARRAY_SIZE(stats_types) || !stats_types[type].name) {
1227         ds_put_format(string, " ***unknown type %d***", type);
1228         return;
1229     }
1230     for (s = stats_types; s->type >= 0; s++) {
1231         if (s->type == type) {
1232             break;
1233         }
1234     }
1235     ds_put_format(string, " type=%d(%s)\n", type, s->name);
1236
1237     m = direction == REQUEST ? &s->request : &s->reply;
1238     if (body_len < m->min_body || body_len > m->max_body) {
1239         ds_put_format(string, " ***body_len=%zu not in %zu...%zu***",
1240                       body_len, m->min_body, m->max_body);
1241         return;
1242     }
1243     if (m->printer) {
1244         m->printer(string, body, body_len, verbosity);
1245     }
1246 }
1247
1248 static void
1249 ofp_stats_request(struct ds *string, const void *oh, size_t len, int verbosity)
1250 {
1251     const struct ofp_stats_request *srq = oh;
1252
1253     if (srq->flags) {
1254         ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***",
1255                       ntohs(srq->flags));
1256     }
1257
1258     print_stats(string, ntohs(srq->type), srq->body,
1259                 len - offsetof(struct ofp_stats_request, body),
1260                 verbosity, REQUEST);
1261 }
1262
1263 static void
1264 ofp_stats_reply(struct ds *string, const void *oh, size_t len, int verbosity)
1265 {
1266     const struct ofp_stats_reply *srp = oh;
1267
1268     ds_put_cstr(string, " flags=");
1269     if (!srp->flags) {
1270         ds_put_cstr(string, "none");
1271     } else {
1272         uint16_t flags = ntohs(srp->flags);
1273         if (flags & OFPSF_REPLY_MORE) {
1274             ds_put_cstr(string, "[more]");
1275             flags &= ~OFPSF_REPLY_MORE;
1276         }
1277         if (flags) {
1278             ds_put_format(string, "[***unknown flags 0x%04"PRIx16"***]", flags);
1279         }
1280     }
1281
1282     print_stats(string, ntohs(srp->type), srp->body,
1283                 len - offsetof(struct ofp_stats_reply, body),
1284                 verbosity, REPLY);
1285 }
1286
1287 static void
1288 ofp_echo(struct ds *string, const void *oh, size_t len, int verbosity)
1289 {
1290     const struct ofp_header *hdr = oh;
1291
1292     ds_put_format(string, " %zu bytes of payload\n", len - sizeof *hdr);
1293     if (verbosity > 1) {
1294         ds_put_hex_dump(string, hdr, len - sizeof *hdr, 0, true); 
1295     }
1296 }
1297
1298 struct openflow_packet {
1299     uint8_t type;
1300     const char *name;
1301     size_t min_size;
1302     void (*printer)(struct ds *, const void *, size_t len, int verbosity);
1303 };
1304
1305 static const struct openflow_packet packets[] = {
1306     {
1307         OFPT_HELLO,
1308         "hello",
1309         sizeof (struct ofp_header),
1310         NULL,
1311     },
1312     {
1313         OFPT_FEATURES_REQUEST,
1314         "features_request",
1315         sizeof (struct ofp_header),
1316         NULL,
1317     },
1318     {
1319         OFPT_FEATURES_REPLY,
1320         "features_reply",
1321         sizeof (struct ofp_switch_features),
1322         ofp_print_switch_features,
1323     },
1324     {
1325         OFPT_GET_CONFIG_REQUEST,
1326         "get_config_request",
1327         sizeof (struct ofp_header),
1328         NULL,
1329     },
1330     {
1331         OFPT_GET_CONFIG_REPLY,
1332         "get_config_reply",
1333         sizeof (struct ofp_switch_config),
1334         ofp_print_switch_config,
1335     },
1336     {
1337         OFPT_SET_CONFIG,
1338         "set_config",
1339         sizeof (struct ofp_switch_config),
1340         ofp_print_switch_config,
1341     },
1342     {
1343         OFPT_PACKET_IN,
1344         "packet_in",
1345         offsetof(struct ofp_packet_in, data),
1346         ofp_packet_in,
1347     },
1348     {
1349         OFPT_PACKET_OUT,
1350         "packet_out",
1351         sizeof (struct ofp_packet_out),
1352         ofp_packet_out,
1353     },
1354     {
1355         OFPT_FLOW_MOD,
1356         "flow_mod",
1357         sizeof (struct ofp_flow_mod),
1358         ofp_print_flow_mod,
1359     },
1360     {
1361         OFPT_FLOW_REMOVED,
1362         "flow_removed",
1363         sizeof (struct ofp_flow_removed),
1364         ofp_print_flow_removed,
1365     },
1366     {
1367         OFPT_PORT_MOD,
1368         "port_mod",
1369         sizeof (struct ofp_port_mod),
1370         ofp_print_port_mod,
1371     },
1372     {
1373         OFPT_PORT_STATUS,
1374         "port_status",
1375         sizeof (struct ofp_port_status),
1376         ofp_print_port_status
1377     },
1378     {
1379         OFPT_ERROR,
1380         "error_msg",
1381         sizeof (struct ofp_error_msg),
1382         ofp_print_error_msg,
1383     },
1384     {
1385         OFPT_STATS_REQUEST,
1386         "stats_request",
1387         sizeof (struct ofp_stats_request),
1388         ofp_stats_request,
1389     },
1390     {
1391         OFPT_STATS_REPLY,
1392         "stats_reply",
1393         sizeof (struct ofp_stats_reply),
1394         ofp_stats_reply,
1395     },
1396     {
1397         OFPT_ECHO_REQUEST,
1398         "echo_request",
1399         sizeof (struct ofp_header),
1400         ofp_echo,
1401     },
1402     {
1403         OFPT_ECHO_REPLY,
1404         "echo_reply",
1405         sizeof (struct ofp_header),
1406         ofp_echo,
1407     },
1408     {
1409         OFPT_VENDOR,
1410         "vendor",
1411         sizeof (struct ofp_vendor_header),
1412         NULL,
1413     },
1414     {
1415         OFPT_BARRIER_REQUEST,
1416         "barrier_request",
1417         sizeof (struct ofp_header),
1418         NULL,
1419     },
1420     {
1421         OFPT_BARRIER_REPLY,
1422         "barrier_reply",
1423         sizeof (struct ofp_header),
1424         NULL,
1425     }
1426 };
1427
1428 /* Composes and returns a string representing the OpenFlow packet of 'len'
1429  * bytes at 'oh' at the given 'verbosity' level.  0 is a minimal amount of
1430  * verbosity and higher numbers increase verbosity.  The caller is responsible
1431  * for freeing the string. */
1432 char *
1433 ofp_to_string(const void *oh_, size_t len, int verbosity)
1434 {
1435     struct ds string = DS_EMPTY_INITIALIZER;
1436     const struct ofp_header *oh = oh_;
1437     const struct openflow_packet *pkt;
1438
1439     if (len < sizeof(struct ofp_header)) {
1440         ds_put_cstr(&string, "OpenFlow packet too short:\n");
1441         ds_put_hex_dump(&string, oh, len, 0, true);
1442         return ds_cstr(&string);
1443     } else if (oh->version != OFP_VERSION) {
1444         ds_put_format(&string, "Bad OpenFlow version %"PRIu8":\n", oh->version);
1445         ds_put_hex_dump(&string, oh, len, 0, true);
1446         return ds_cstr(&string);
1447     }
1448
1449     for (pkt = packets; ; pkt++) {
1450         if (pkt >= &packets[ARRAY_SIZE(packets)]) {
1451             ds_put_format(&string, "Unknown OpenFlow packet type %"PRIu8":\n",
1452                           oh->type);
1453             ds_put_hex_dump(&string, oh, len, 0, true);
1454             return ds_cstr(&string);
1455         } else if (oh->type == pkt->type) {
1456             break;
1457         }
1458     }
1459
1460     ds_put_format(&string, "%s (xid=0x%"PRIx32"):", pkt->name, oh->xid);
1461
1462     if (ntohs(oh->length) > len)
1463         ds_put_format(&string, " (***truncated to %zu bytes from %"PRIu16"***)",
1464                 len, ntohs(oh->length));
1465     else if (ntohs(oh->length) < len) {
1466         ds_put_format(&string, " (***only uses %"PRIu16" bytes out of %zu***)\n",
1467                 ntohs(oh->length), len);
1468         len = ntohs(oh->length);
1469     }
1470
1471     if (len < pkt->min_size) {
1472         ds_put_format(&string, " (***length=%zu < min_size=%zu***)\n",
1473                 len, pkt->min_size);
1474     } else if (!pkt->printer) {
1475         if (len > sizeof *oh) {
1476             ds_put_format(&string, " length=%"PRIu16" (decoder not implemented)\n",
1477                           ntohs(oh->length)); 
1478         }
1479     } else {
1480         pkt->printer(&string, oh, len, verbosity);
1481     }
1482     if (verbosity >= 3) {
1483         ds_put_hex_dump(&string, oh, len, 0, true);
1484     }
1485     if (string.string[string.length - 1] != '\n') {
1486         ds_put_char(&string, '\n');
1487     }
1488     return ds_cstr(&string);
1489 }
1490
1491 /* Returns the name for the specified OpenFlow message type as a string,
1492  * e.g. "OFPT_FEATURES_REPLY".  If no name is known, the string returned is a
1493  * hex number, e.g. "0x55".
1494  *
1495  * The caller must free the returned string when it is no longer needed. */
1496 char *
1497 ofp_message_type_to_string(uint8_t type)
1498 {
1499     struct ds s = DS_EMPTY_INITIALIZER;
1500     const struct openflow_packet *pkt;
1501     for (pkt = packets; ; pkt++) {
1502         if (pkt >= &packets[ARRAY_SIZE(packets)]) {
1503             ds_put_format(&s, "0x%02"PRIx8, type);
1504             break;
1505         } else if (type == pkt->type) {
1506             const char *p;
1507
1508             ds_put_cstr(&s, "OFPT_");
1509             for (p = pkt->name; *p; p++) {
1510                 ds_put_char(&s, toupper((unsigned char) *p));
1511             }
1512             break;
1513         }
1514     }
1515     return ds_cstr(&s);
1516 }
1517 \f
1518 static void
1519 print_and_free(FILE *stream, char *string) 
1520 {
1521     fputs(string, stream);
1522     free(string);
1523 }
1524
1525 /* Pretty-print the OpenFlow packet of 'len' bytes at 'oh' to 'stream' at the
1526  * given 'verbosity' level.  0 is a minimal amount of verbosity and higher
1527  * numbers increase verbosity. */
1528 void
1529 ofp_print(FILE *stream, const void *oh, size_t len, int verbosity)
1530 {
1531     print_and_free(stream, ofp_to_string(oh, len, verbosity));
1532 }
1533
1534 /* Dumps the contents of the Ethernet frame in the 'len' bytes starting at
1535  * 'data' to 'stream' using tcpdump.  'total_len' specifies the full length of
1536  * the Ethernet frame (of which 'len' bytes were captured).
1537  *
1538  * This starts and kills a tcpdump subprocess so it's quite expensive. */
1539 void
1540 ofp_print_packet(FILE *stream, const void *data, size_t len, size_t total_len)
1541 {
1542     print_and_free(stream, ofp_packet_to_string(data, len, total_len));
1543 }