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