datapath: Allow minimum headroom to be set when copying buffers.
[sliver-openvswitch.git] / ofproto / netflow.c
1 /*
2  * Copyright (c) 2008, 2009 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 "netflow.h"
19 #include <arpa/inet.h>
20 #include <errno.h>
21 #include <stdlib.h>
22 #include <unistd.h>
23 #include "cfg.h"
24 #include "flow.h"
25 #include "netflow.h"
26 #include "ofpbuf.h"
27 #include "ofproto.h"
28 #include "packets.h"
29 #include "socket-util.h"
30 #include "svec.h"
31 #include "timeval.h"
32 #include "util.h"
33 #include "xtoxll.h"
34
35 #define THIS_MODULE VLM_netflow
36 #include "vlog.h"
37
38 #define NETFLOW_V5_VERSION 5
39
40 static const int ACTIVE_TIMEOUT_DEFAULT = 600;
41
42 /* Every NetFlow v5 message contains the header that follows.  This is
43  * followed by up to thirty records that describe a terminating flow.
44  * We only send a single record per NetFlow message.
45  */
46 struct netflow_v5_header {
47     uint16_t version;              /* NetFlow version is 5. */
48     uint16_t count;                /* Number of records in this message. */
49     uint32_t sysuptime;            /* System uptime in milliseconds. */
50     uint32_t unix_secs;            /* Number of seconds since Unix epoch. */
51     uint32_t unix_nsecs;           /* Number of residual nanoseconds
52                                       after epoch seconds. */
53     uint32_t flow_seq;             /* Number of flows since sending
54                                       messages began. */
55     uint8_t  engine_type;          /* Engine type. */
56     uint8_t  engine_id;            /* Engine id. */
57     uint16_t sampling_interval;    /* Set to zero. */
58 };
59 BUILD_ASSERT_DECL(sizeof(struct netflow_v5_header) == 24);
60
61 /* A NetFlow v5 description of a terminating flow.  It is preceded by a
62  * NetFlow v5 header.
63  */
64 struct netflow_v5_record {
65     uint32_t src_addr;             /* Source IP address. */
66     uint32_t dst_addr;             /* Destination IP address. */
67     uint32_t nexthop;              /* IP address of next hop.  Set to 0. */
68     uint16_t input;                /* Input interface index. */
69     uint16_t output;               /* Output interface index. */
70     uint32_t packet_count;         /* Number of packets. */
71     uint32_t byte_count;           /* Number of bytes. */
72     uint32_t init_time;            /* Value of sysuptime on first packet. */
73     uint32_t used_time;            /* Value of sysuptime on last packet. */
74
75     /* The 'src_port' and 'dst_port' identify the source and destination
76      * port, respectively, for TCP and UDP.  For ICMP, the high-order
77      * byte identifies the type and low-order byte identifies the code
78      * in the 'dst_port' field. */
79     uint16_t src_port;
80     uint16_t dst_port;
81
82     uint8_t  pad1;
83     uint8_t  tcp_flags;            /* Union of seen TCP flags. */
84     uint8_t  ip_proto;             /* IP protocol. */
85     uint8_t  ip_tos;               /* IP TOS value. */
86     uint16_t src_as;               /* Source AS ID.  Set to 0. */
87     uint16_t dst_as;               /* Destination AS ID.  Set to 0. */
88     uint8_t  src_mask;             /* Source mask bits.  Set to 0. */
89     uint8_t  dst_mask;             /* Destination mask bits.  Set to 0. */
90     uint8_t  pad[2];
91 };
92 BUILD_ASSERT_DECL(sizeof(struct netflow_v5_record) == 48);
93
94 struct netflow {
95     uint8_t engine_type;          /* Value of engine_type to use. */
96     uint8_t engine_id;            /* Value of engine_id to use. */
97     long long int boot_time;      /* Time when netflow_create() was called. */
98     int *fds;                     /* Sockets for NetFlow collectors. */
99     size_t n_fds;                 /* Number of Netflow collectors. */
100     bool add_id_to_iface;         /* Put the 7 least signficiant bits of 
101                                    * 'engine_id' into the most signficant 
102                                    * bits of the interface fields. */
103     uint32_t netflow_cnt;         /* Flow sequence number for NetFlow. */
104     struct ofpbuf packet;         /* NetFlow packet being accumulated. */
105     long long int active_timeout; /* Timeout for flows that are still active. */
106     long long int reconfig_time;  /* When we reconfigured the timeouts. */
107 };
108
109 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
110
111 static int
112 open_collector(char *dst)
113 {
114     char *save_ptr = NULL;
115     const char *host_name;
116     const char *port_string;
117     struct sockaddr_in sin;
118     int retval;
119     int fd;
120
121     /* Glibc 2.7 has a bug in strtok_r when compiling with optimization that
122      * can cause segfaults here:
123      * http://sources.redhat.com/bugzilla/show_bug.cgi?id=5614.
124      * Using "::" instead of the obvious ":" works around it. */
125     host_name = strtok_r(dst, ":", &save_ptr);
126     port_string = strtok_r(NULL, ":", &save_ptr);
127     if (!host_name) {
128         ovs_error(0, "%s: bad peer name format", dst);
129         return -EAFNOSUPPORT;
130     }
131     if (!port_string) {
132         ovs_error(0, "%s: bad port format", dst);
133         return -EAFNOSUPPORT;
134     }
135
136     memset(&sin, 0, sizeof sin);
137     sin.sin_family = AF_INET;
138     if (lookup_ip(host_name, &sin.sin_addr)) {
139         return -ENOENT;
140     }
141     sin.sin_port = htons(atoi(port_string));
142
143     fd = socket(AF_INET, SOCK_DGRAM, 0);
144     if (fd < 0) {
145         VLOG_ERR("%s: socket: %s", dst, strerror(errno));
146         return -errno;
147     }
148
149     retval = set_nonblocking(fd);
150     if (retval) {
151         close(fd);
152         return -retval;
153     }
154
155     retval = connect(fd, (struct sockaddr *) &sin, sizeof sin);
156     if (retval < 0) {
157         int error = errno;
158         VLOG_ERR("%s: connect: %s", dst, strerror(error));
159         close(fd);
160         return -error;
161     }
162
163     return fd;
164 }
165
166 void
167 netflow_expire(struct netflow *nf, struct netflow_flow *nf_flow,
168                struct ofexpired *expired)
169 {
170     struct netflow_v5_header *nf_hdr;
171     struct netflow_v5_record *nf_rec;
172     struct timeval now;
173
174     nf_flow->last_expired += nf->active_timeout;
175
176     /* NetFlow only reports on IP packets and we should only report flows
177      * that actually have traffic. */
178     if (expired->flow.dl_type != htons(ETH_TYPE_IP) ||
179         expired->packet_count - nf_flow->packet_count_off == 0) {
180         return;
181     }
182
183     time_timeval(&now);
184
185     if (!nf->packet.size) {
186         nf_hdr = ofpbuf_put_zeros(&nf->packet, sizeof *nf_hdr);
187         nf_hdr->version = htons(NETFLOW_V5_VERSION);
188         nf_hdr->count = htons(0);
189         nf_hdr->sysuptime = htonl(time_msec() - nf->boot_time);
190         nf_hdr->unix_secs = htonl(now.tv_sec);
191         nf_hdr->unix_nsecs = htonl(now.tv_usec * 1000);
192         nf_hdr->flow_seq = htonl(nf->netflow_cnt++);
193         nf_hdr->engine_type = nf->engine_type;
194         nf_hdr->engine_id = nf->engine_id;
195         nf_hdr->sampling_interval = htons(0);
196     }
197
198     nf_hdr = nf->packet.data;
199     nf_hdr->count = htons(ntohs(nf_hdr->count) + 1);
200
201     nf_rec = ofpbuf_put_zeros(&nf->packet, sizeof *nf_rec);
202     nf_rec->src_addr = expired->flow.nw_src;
203     nf_rec->dst_addr = expired->flow.nw_dst;
204     nf_rec->nexthop = htons(0);
205     if (nf->add_id_to_iface) {
206         uint16_t iface = (nf->engine_id & 0x7f) << 9;
207         nf_rec->input = htons(iface | (expired->flow.in_port & 0x1ff));
208         nf_rec->output = htons(iface | (nf_flow->output_iface & 0x1ff));
209     } else {
210         nf_rec->input = htons(expired->flow.in_port);
211         nf_rec->output = htons(nf_flow->output_iface);
212     }
213     nf_rec->packet_count = htonl(MIN(expired->packet_count -
214                                      nf_flow->packet_count_off, UINT32_MAX));
215     nf_rec->byte_count = htonl(MIN(expired->byte_count -
216                                    nf_flow->byte_count_off, UINT32_MAX));
217     nf_rec->init_time = htonl(nf_flow->created - nf->boot_time);
218     nf_rec->used_time = htonl(MAX(nf_flow->created, expired->used)
219                              - nf->boot_time);
220     if (expired->flow.nw_proto == IP_TYPE_ICMP) {
221         /* In NetFlow, the ICMP type and code are concatenated and
222          * placed in the 'dst_port' field. */
223         uint8_t type = ntohs(expired->flow.tp_src);
224         uint8_t code = ntohs(expired->flow.tp_dst);
225         nf_rec->src_port = htons(0);
226         nf_rec->dst_port = htons((type << 8) | code);
227     } else {
228         nf_rec->src_port = expired->flow.tp_src;
229         nf_rec->dst_port = expired->flow.tp_dst;
230     }
231     nf_rec->tcp_flags = nf_flow->tcp_flags;
232     nf_rec->ip_proto = expired->flow.nw_proto;
233     nf_rec->ip_tos = nf_flow->ip_tos;
234
235     /* Update flow tracking data. */
236     nf_flow->created = 0;
237     nf_flow->packet_count_off = expired->packet_count;
238     nf_flow->byte_count_off = expired->byte_count;
239     nf_flow->tcp_flags = 0;
240
241     /* NetFlow messages are limited to 30 records. */
242     if (ntohs(nf_hdr->count) >= 30) {
243         netflow_run(nf);
244     }
245 }
246
247 void
248 netflow_run(struct netflow *nf)
249 {
250     size_t i;
251
252     if (!nf->packet.size) {
253         return;
254     }
255
256     for (i = 0; i < nf->n_fds; i++) {
257         if (send(nf->fds[i], nf->packet.data, nf->packet.size, 0) == -1) {
258             VLOG_WARN_RL(&rl, "netflow message send failed: %s",
259                          strerror(errno));
260         }
261     }
262     nf->packet.size = 0;
263 }
264
265 static void
266 clear_collectors(struct netflow *nf)
267 {
268     size_t i;
269
270     for (i = 0; i < nf->n_fds; i++) {
271         close(nf->fds[i]);
272     }
273     free(nf->fds);
274     nf->fds = NULL;
275     nf->n_fds = 0;
276 }
277
278 int
279 netflow_set_options(struct netflow *nf,
280                     const struct netflow_options *nf_options)
281 {
282     struct svec collectors;
283     int error = 0;
284     size_t i;
285     long long int old_timeout;
286
287     nf->engine_type = nf_options->engine_type;
288     nf->engine_id = nf_options->engine_id;
289     nf->add_id_to_iface = nf_options->add_id_to_iface;
290
291     clear_collectors(nf);
292
293     svec_clone(&collectors, &nf_options->collectors);
294     svec_sort_unique(&collectors);
295
296     nf->fds = xmalloc(sizeof *nf->fds * collectors.n);
297     for (i = 0; i < collectors.n; i++) {
298         const char *name = collectors.names[i];
299         char *tmpname = xstrdup(name);
300         int fd = open_collector(tmpname);
301         free(tmpname);
302         if (fd >= 0) {
303             nf->fds[nf->n_fds++] = fd;
304         } else {
305             VLOG_WARN("couldn't open connection to collector (%s), "
306                       "ignoring %s\n", strerror(-fd), name);
307             if (!error) {
308                 error = -fd;
309             }
310         }
311     }
312
313     svec_destroy(&collectors);
314
315     old_timeout = nf->active_timeout;
316     if (nf_options->active_timeout != -1) {
317         nf->active_timeout = nf_options->active_timeout;
318     } else {
319         nf->active_timeout = ACTIVE_TIMEOUT_DEFAULT;
320     }
321     nf->active_timeout *= 1000;
322     if (old_timeout != nf->active_timeout) {
323         nf->reconfig_time = time_msec();
324     }
325
326     return error;
327 }
328
329 struct netflow *
330 netflow_create(void)
331 {
332     struct netflow *nf = xmalloc(sizeof *nf);
333     nf->engine_type = 0;
334     nf->engine_id = 0;
335     nf->boot_time = time_msec();
336     nf->fds = NULL;
337     nf->n_fds = 0;
338     nf->add_id_to_iface = false;
339     nf->netflow_cnt = 0;
340     ofpbuf_init(&nf->packet, 1500);
341     return nf;
342 }
343
344 void
345 netflow_destroy(struct netflow *nf)
346 {
347     if (nf) {
348         ofpbuf_uninit(&nf->packet);
349         clear_collectors(nf);
350         free(nf);
351     }
352 }
353
354 void
355 netflow_flow_clear(struct netflow_flow *nf_flow)
356 {
357     uint16_t output_iface = nf_flow->output_iface;
358
359     memset(nf_flow, 0, sizeof *nf_flow);
360     nf_flow->output_iface = output_iface;
361 }
362
363 void
364 netflow_flow_update_time(struct netflow *nf, struct netflow_flow *nf_flow,
365                          long long int used)
366 {
367     if (!nf_flow->created) {
368         nf_flow->created = used;
369     }
370
371     if (!nf || !nf->active_timeout || !nf_flow->last_expired ||
372         nf->reconfig_time > nf_flow->last_expired) {
373         /* Keep the time updated to prevent a flood of expiration in
374          * the future. */
375         nf_flow->last_expired = time_msec();
376     }
377 }
378
379 void
380 netflow_flow_update_flags(struct netflow_flow *nf_flow, uint8_t ip_tos,
381                           uint8_t tcp_flags)
382 {
383     nf_flow->ip_tos = ip_tos;
384     nf_flow->tcp_flags |= tcp_flags;
385 }
386
387 bool
388 netflow_active_timeout_expired(struct netflow *nf, struct netflow_flow *nf_flow)
389 {
390     if (nf->active_timeout) {
391         return time_msec() > nf_flow->last_expired + nf->active_timeout;
392     }
393
394     return false;
395 }