FAQ: Describe the state of MPLS in Open vSwitch.
[sliver-openvswitch.git] / tests / test-netflow.c
1 /*
2  * Copyright (c) 2011, 2012, 2013 Nicira, Inc.
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
19 #include <errno.h>
20 #include <getopt.h>
21 #include <signal.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24
25 #include "command-line.h"
26 #include "daemon.h"
27 #include "dynamic-string.h"
28 #include "netflow.h"
29 #include "ofpbuf.h"
30 #include "packets.h"
31 #include "poll-loop.h"
32 #include "socket-util.h"
33 #include "unixctl.h"
34 #include "util.h"
35 #include "vlog.h"
36
37 static void usage(void) NO_RETURN;
38 static void parse_options(int argc, char *argv[]);
39
40 static unixctl_cb_func test_netflow_exit;
41
42 static void
43 print_netflow(struct ofpbuf *buf)
44 {
45     const struct netflow_v5_header *hdr;
46     int i;
47
48     hdr = ofpbuf_try_pull(buf, sizeof *hdr);
49     if (!hdr) {
50         printf("truncated NetFlow packet header\n");
51         return;
52     }
53     printf("header: v%"PRIu16", "
54            "uptime %"PRIu32", "
55            "now %"PRIu32".%09"PRIu32", "
56            "seq %"PRIu32", "
57            "engine %"PRIu8",%"PRIu8,
58            ntohs(hdr->version),
59            ntohl(hdr->sysuptime),
60            ntohl(hdr->unix_secs), ntohl(hdr->unix_nsecs),
61            ntohl(hdr->flow_seq),
62            hdr->engine_type, hdr->engine_id);
63     if (hdr->sampling_interval != htons(0)) {
64         printf(", interval %"PRIu16, ntohs(hdr->sampling_interval));
65     }
66     putchar('\n');
67
68     for (i = 0; i < ntohs(hdr->count); i++) {
69         struct netflow_v5_record *rec;
70
71         rec = ofpbuf_try_pull(buf, sizeof *rec);
72         if (!rec) {
73             printf("truncated NetFlow records\n");
74             return;
75         }
76
77         printf("seq %"PRIu32": "IP_FMT" > "IP_FMT, ntohl(hdr->flow_seq),
78                IP_ARGS(rec->src_addr), IP_ARGS(rec->dst_addr));
79
80         printf(", if %"PRIu16" > %"PRIu16,
81                ntohs(rec->input), ntohs(rec->output));
82
83         printf(", %"PRIu32" pkts, %"PRIu32" bytes",
84                ntohl(rec->packet_count), ntohl(rec->byte_count));
85
86         switch (rec->ip_proto) {
87         case IPPROTO_TCP:
88             printf(", TCP %"PRIu16" > %"PRIu16,
89                    ntohs(rec->src_port), ntohs(rec->dst_port));
90             if (rec->tcp_flags) {
91                 struct ds s = DS_EMPTY_INITIALIZER;
92                 packet_format_tcp_flags(&s, rec->tcp_flags);
93                 printf(" %s", ds_cstr(&s));
94                 ds_destroy(&s);
95             }
96             break;
97
98         case IPPROTO_UDP:
99             printf(", UDP %"PRIu16" > %"PRIu16,
100                    ntohs(rec->src_port), ntohs(rec->dst_port));
101             break;
102
103         case IPPROTO_SCTP:
104             printf(", SCTP %"PRIu16" > %"PRIu16,
105                    ntohs(rec->src_port), ntohs(rec->dst_port));
106             break;
107
108         case IPPROTO_ICMP:
109             printf(", ICMP %"PRIu16":%"PRIu16,
110                    ntohs(rec->dst_port) >> 8,
111                    ntohs(rec->dst_port) & 0xff);
112             if (rec->src_port != htons(0)) {
113                 printf(", src_port=%"PRIu16, ntohs(rec->src_port));
114             }
115             break;
116
117         default:
118             printf(", proto %"PRIu8, rec->ip_proto);
119             break;
120         }
121
122         if (rec->ip_proto != IPPROTO_TCP && rec->tcp_flags != 0) {
123             printf(", flags %"PRIx8, rec->tcp_flags);
124         }
125
126         if (rec->ip_proto != IPPROTO_TCP &&
127             rec->ip_proto != IPPROTO_UDP &&
128             rec->ip_proto != IPPROTO_SCTP &&
129             rec->ip_proto != IPPROTO_ICMP) {
130             if (rec->src_port != htons(0)) {
131                 printf(", src_port %"PRIu16, ntohs(rec->src_port));
132             }
133             if (rec->dst_port != htons(0)) {
134                 printf(", dst_port %"PRIu16, ntohs(rec->dst_port));
135             }
136         }
137
138         if (rec->ip_tos) {
139             printf(", TOS %"PRIx8, rec->ip_tos);
140         }
141
142         printf(", time %"PRIu32"...%"PRIu32,
143                ntohl(rec->init_time), ntohl(rec->used_time));
144
145         if (rec->nexthop != htonl(0)) {
146             printf(", nexthop "IP_FMT, IP_ARGS(rec->nexthop));
147         }
148         if (rec->src_as != htons(0) || rec->dst_as != htons(0)) {
149             printf(", AS %"PRIu16" > %"PRIu16,
150                    ntohs(rec->src_as), ntohs(rec->dst_as));
151         }
152         if (rec->src_mask != 0 || rec->dst_mask != 0) {
153             printf(", mask %"PRIu8" > %"PRIu8, rec->src_mask, rec->dst_mask);
154         }
155         if (rec->pad1) {
156             printf(", pad1 %"PRIu8, rec->pad1);
157         }
158         if (rec->pad[0] || rec->pad[1]) {
159             printf(", pad %"PRIu8", %"PRIu8, rec->pad[0], rec->pad[1]);
160         }
161         putchar('\n');
162     }
163
164     if (buf->size) {
165         printf("%"PRIuSIZE" extra bytes after last record\n", buf->size);
166     }
167 }
168
169 int
170 main(int argc, char *argv[])
171 {
172     struct unixctl_server *server;
173     enum { MAX_RECV = 1500 };
174     const char *target;
175     struct ofpbuf buf;
176     bool exiting = false;
177     int error;
178     int sock;
179     int n;
180
181     proctitle_init(argc, argv);
182     set_program_name(argv[0]);
183     parse_options(argc, argv);
184
185     if (argc - optind != 1) {
186         ovs_fatal(0, "exactly one non-option argument required "
187                   "(use --help for help)");
188     }
189     target = argv[optind];
190
191     sock = inet_open_passive(SOCK_DGRAM, target, 0, NULL, 0);
192     if (sock < 0) {
193         ovs_fatal(0, "%s: failed to open (%s)", argv[1], ovs_strerror(-sock));
194     }
195
196     daemon_save_fd(STDOUT_FILENO);
197     daemonize_start();
198
199     error = unixctl_server_create(NULL, &server);
200     if (error) {
201         ovs_fatal(error, "failed to create unixctl server");
202     }
203     unixctl_command_register("exit", "", 0, 0, test_netflow_exit, &exiting);
204
205     daemonize_complete();
206
207     ofpbuf_init(&buf, MAX_RECV);
208     n = 0;
209     for (;;) {
210         int retval;
211
212         unixctl_server_run(server);
213
214         ofpbuf_clear(&buf);
215         do {
216             retval = read(sock, buf.data, buf.allocated);
217         } while (retval < 0 && errno == EINTR);
218         if (retval > 0) {
219             ofpbuf_put_uninit(&buf, retval);
220             if (n++ > 0) {
221                 putchar('\n');
222             }
223             print_netflow(&buf);
224             fflush(stdout);
225         }
226
227         if (exiting) {
228             break;
229         }
230
231         poll_fd_wait(sock, POLLIN);
232         unixctl_server_wait(server);
233         poll_block();
234     }
235
236     return 0;
237 }
238
239 static void
240 parse_options(int argc, char *argv[])
241 {
242     enum {
243         DAEMON_OPTION_ENUMS,
244         VLOG_OPTION_ENUMS
245     };
246     static const struct option long_options[] = {
247         {"help", no_argument, NULL, 'h'},
248         DAEMON_LONG_OPTIONS,
249         VLOG_LONG_OPTIONS,
250         {NULL, 0, NULL, 0},
251     };
252     char *short_options = long_options_to_short_options(long_options);
253
254     for (;;) {
255         int c = getopt_long(argc, argv, short_options, long_options, NULL);
256         if (c == -1) {
257             break;
258         }
259
260         switch (c) {
261         case 'h':
262             usage();
263
264         DAEMON_OPTION_HANDLERS
265         VLOG_OPTION_HANDLERS
266
267         case '?':
268             exit(EXIT_FAILURE);
269
270         default:
271             abort();
272         }
273     }
274     free(short_options);
275 }
276
277 static void
278 usage(void)
279 {
280     printf("%s: netflow collector test utility\n"
281            "usage: %s [OPTIONS] PORT[:IP]\n"
282            "where PORT is the UDP port to listen on and IP is optionally\n"
283            "the IP address to listen on.\n",
284            program_name, program_name);
285     daemon_usage();
286     vlog_usage();
287     printf("\nOther options:\n"
288            "  -h, --help                  display this help message\n");
289     exit(EXIT_SUCCESS);
290 }
291
292 static void
293 test_netflow_exit(struct unixctl_conn *conn,
294                   int argc OVS_UNUSED, const char *argv[] OVS_UNUSED,
295                   void *exiting_)
296 {
297     bool *exiting = exiting_;
298     *exiting = true;
299     unixctl_command_reply(conn, NULL);
300 }