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