2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
18 #include <vppinfra/atomics.h>
19 #include <vnet/ipfix-export/flow_report.h>
20 #include <vnet/api_errno.h>
21 #include <vnet/udp/udp.h>
23 flow_report_main_t flow_report_main;
25 static_always_inline u8
26 stream_index_valid (ipfix_exporter_t *exp, u32 index)
28 return index < vec_len (exp->streams) && exp->streams[index].domain_id != ~0;
31 static_always_inline flow_report_stream_t *
32 add_stream (ipfix_exporter_t *exp)
35 for (i = 0; i < vec_len (exp->streams); i++)
36 if (!stream_index_valid (exp, i))
37 return &exp->streams[i];
38 u32 index = vec_len (exp->streams);
39 vec_validate (exp->streams, index);
40 return &exp->streams[index];
43 static_always_inline void
44 delete_stream (ipfix_exporter_t *exp, u32 index)
46 ASSERT (index < vec_len (exp->streams));
47 ASSERT (exp->streams[index].domain_id != ~0);
48 exp->streams[index].domain_id = ~0;
52 find_stream (ipfix_exporter_t *exp, u32 domain_id, u16 src_port)
54 flow_report_stream_t *stream;
56 for (i = 0; i < vec_len (exp->streams); i++)
57 if (stream_index_valid (exp, i))
59 stream = &exp->streams[i];
60 if (domain_id == stream->domain_id)
62 if (src_port != stream->src_port)
66 else if (src_port == stream->src_port)
75 send_template_packet (flow_report_main_t *frm, ipfix_exporter_t *exp,
76 flow_report_t *fr, u32 *buffer_indexp)
80 ip4_ipfix_template_packet_t *tp4;
81 ip6_ipfix_template_packet_t *tp6;
82 ipfix_message_header_t *h;
87 vlib_main_t *vm = frm->vlib_main;
88 flow_report_stream_t *stream;
90 ASSERT (buffer_indexp);
92 if (fr->update_rewrite || fr->rewrite == 0)
94 if (ip_address_is_zero (&exp->ipfix_collector) ||
95 ip_address_is_zero (&exp->src_address))
97 vlib_node_set_state (frm->vlib_main, flow_report_process_node.index,
98 VLIB_NODE_STATE_DISABLED);
101 vec_free (fr->rewrite);
102 fr->update_rewrite = 1;
105 if (fr->update_rewrite)
107 fr->rewrite = fr->rewrite_callback (
108 exp, fr, exp->collector_port, fr->report_elements,
109 fr->n_report_elements, fr->stream_indexp);
110 fr->update_rewrite = 0;
113 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
116 b0 = vlib_get_buffer (vm, bi0);
118 ASSERT (vec_len (fr->rewrite) < vlib_buffer_get_default_data_size (vm));
120 clib_memcpy_fast (b0->data, fr->rewrite, vec_len (fr->rewrite));
121 b0->current_data = 0;
122 b0->current_length = vec_len (fr->rewrite);
123 b0->flags |= (VLIB_BUFFER_TOTAL_LENGTH_VALID | VNET_BUFFER_F_FLOW_REPORT);
124 vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
125 vnet_buffer (b0)->sw_if_index[VLIB_TX] = exp->fib_index;
127 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
129 tp4 = vlib_buffer_get_current (b0);
130 ip4 = (ip4_header_t *) &tp4->ip4;
132 udp = (udp_header_t *) (ip4 + 1);
136 tp6 = vlib_buffer_get_current (b0);
137 ip6 = (ip6_header_t *) &tp6->ip6;
139 udp = (udp_header_t *) (ip6 + 1);
141 h = (ipfix_message_header_t *) (udp + 1);
143 /* FIXUP: message header export_time */
144 h->export_time = (u32)
145 (((f64) frm->unix_time_0) +
146 (vlib_time_now (frm->vlib_main) - frm->vlib_time_0));
147 h->export_time = clib_host_to_net_u32 (h->export_time);
149 stream = &exp->streams[fr->stream_index];
151 /* FIXUP: message header sequence_number. Templates do not increase it */
152 h->sequence_number = clib_host_to_net_u32 (stream->sequence_number);
154 /* FIXUP: udp length */
155 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
156 udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip4));
158 udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip6));
160 if (exp->udp_checksum || ip_addr_version (&exp->ipfix_collector) == AF_IP6)
162 /* RFC 7011 section 10.3.2. */
164 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
165 udp->checksum = ip4_tcp_udp_compute_checksum (vm, b0, ip);
170 ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip, &bogus);
173 if (udp->checksum == 0)
174 udp->checksum = 0xffff;
177 *buffer_indexp = bi0;
179 fr->last_template_sent = vlib_time_now (vm);
185 ipfix_write_headers (ipfix_exporter_t *exp, void *data, void **ip,
186 udp_header_t **udp, u32 len)
188 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
190 ip4_ipfix_template_packet_t *tp4;
193 tp4 = (ip4_ipfix_template_packet_t *) data;
194 ip4 = (ip4_header_t *) &tp4->ip4;
195 ip4->ip_version_and_header_length = 0x45;
197 ip4->protocol = IP_PROTOCOL_UDP;
198 ip4->flags_and_fragment_offset = 0;
199 ip4->src_address.as_u32 = exp->src_address.ip.ip4.as_u32;
200 ip4->dst_address.as_u32 = exp->ipfix_collector.ip.ip4.as_u32;
202 *udp = (udp_header_t *) (ip4 + 1);
204 (*udp)->length = clib_host_to_net_u16 (len - sizeof (*ip4));
205 return sizeof (*ip4);
209 ip6_ipfix_template_packet_t *tp6;
212 tp6 = (ip6_ipfix_template_packet_t *) data;
213 ip6 = (ip6_header_t *) &tp6->ip6;
214 ip6->ip_version_traffic_class_and_flow_label =
215 clib_host_to_net_u32 (6 << 28);
216 ip6->hop_limit = 254;
217 ip6->protocol = IP_PROTOCOL_UDP;
218 ip6->src_address = exp->src_address.ip.ip6;
219 ip6->dst_address = exp->ipfix_collector.ip.ip6;
221 *udp = (udp_header_t *) (ip6 + 1);
222 (*udp)->length = clib_host_to_net_u16 (len - sizeof (*ip6));
223 return sizeof (*ip6);
228 vnet_flow_rewrite_generic_callback (ipfix_exporter_t *exp, flow_report_t *fr,
230 ipfix_report_element_t *report_elts,
231 u32 n_elts, u32 *stream_indexp)
237 ipfix_message_header_t *h;
238 ipfix_set_header_t *s;
239 ipfix_template_header_t *t;
240 ipfix_field_specifier_t *f;
241 ipfix_field_specifier_t *first_field;
243 flow_report_stream_t *stream;
245 ipfix_report_element_t *ep;
248 ASSERT (stream_indexp);
250 ASSERT (report_elts);
252 stream = &exp->streams[fr->stream_index];
253 *stream_indexp = fr->stream_index;
255 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
256 size = sizeof (ip4_ipfix_template_packet_t);
258 size = sizeof (ip6_ipfix_template_packet_t);
259 /* allocate rewrite space */
260 vec_validate_aligned (rewrite,
261 size + n_elts * sizeof (ipfix_field_specifier_t) - 1,
262 CLIB_CACHE_LINE_BYTES);
264 /* create the packet rewrite string */
265 ipfix_write_headers (exp, rewrite, &ip, &udp, vec_len (rewrite));
267 h = (ipfix_message_header_t *) (udp + 1);
268 s = (ipfix_set_header_t *) (h + 1);
269 t = (ipfix_template_header_t *) (s + 1);
270 first_field = f = (ipfix_field_specifier_t *) (t + 1);
271 udp->src_port = clib_host_to_net_u16 (stream->src_port);
272 udp->dst_port = clib_host_to_net_u16 (collector_port);
274 /* FIXUP LATER: message header export_time */
275 h->domain_id = clib_host_to_net_u32 (stream->domain_id);
279 for (i = 0; i < n_elts; i++)
281 f->e_id_length = ipfix_e_id_length (0, ep->info_element, ep->size);
286 ASSERT (f - first_field);
287 /* Field count in this template */
288 t->id_count = ipfix_id_count (fr->template_id, f - first_field);
290 /* set length in octets */
292 ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
294 /* message length in octets */
295 h->version_length = version_length ((u8 *) f - (u8 *) h);
297 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
299 ip4 = (ip4_header_t *) ip;
300 ip4->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip4);
301 ip4->checksum = ip4_header_checksum (ip4);
305 ip6 = (ip6_header_t *) ip;
306 /* IPv6 payload length does not include the IPv6 header */
307 ip6->payload_length = clib_host_to_net_u16 ((u8 *) f - (u8 *) udp);
314 vnet_ipfix_exp_get_buffer (vlib_main_t *vm, ipfix_exporter_t *exp,
315 flow_report_t *fr, u32 thread_index)
320 if (fr->per_thread_data[thread_index].buffer)
321 return fr->per_thread_data[thread_index].buffer;
323 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
326 /* Initialize the buffer */
327 b0 = fr->per_thread_data[thread_index].buffer = vlib_get_buffer (vm, bi0);
329 b0->current_data = 0;
330 b0->current_length = exp->all_headers_size;
331 b0->flags |= (VLIB_BUFFER_TOTAL_LENGTH_VALID | VNET_BUFFER_F_FLOW_REPORT);
332 vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
333 vnet_buffer (b0)->sw_if_index[VLIB_TX] = exp->fib_index;
334 fr->per_thread_data[thread_index].next_data_offset = b0->current_length;
340 * Send a buffer that is mostly populated. Has flow records but needs some
341 * header fields updated.
344 vnet_ipfix_exp_send_buffer (vlib_main_t *vm, ipfix_exporter_t *exp,
345 flow_report_t *fr, flow_report_stream_t *stream,
346 u32 thread_index, vlib_buffer_t *b0)
348 flow_report_main_t *frm = &flow_report_main;
350 ipfix_set_header_t *s;
351 ipfix_message_header_t *h;
352 ip4_header_t *ip4 = 0;
353 ip6_header_t *ip6 = 0;
358 /* nothing to send */
359 if (fr->per_thread_data[thread_index].next_data_offset <=
360 exp->all_headers_size)
363 ip_len = ipfix_write_headers (exp, (void *) vlib_buffer_get_current (b0),
364 &ip, &udp, b0->current_length);
366 h = (ipfix_message_header_t *) (udp + 1);
367 s = (ipfix_set_header_t *) (h + 1);
369 udp->src_port = clib_host_to_net_u16 (stream->src_port);
370 udp->dst_port = clib_host_to_net_u16 (exp->collector_port);
373 /* FIXUP: message header export_time */
375 (u32) (((f64) frm->unix_time_0) + (vlib_time_now (vm) - frm->vlib_time_0));
376 h->export_time = clib_host_to_net_u32 (h->export_time);
377 h->domain_id = clib_host_to_net_u32 (stream->domain_id);
380 * RFC 7011: Section 3.2
382 * Incremental sequence counter modulo 2^32 of all IPFIX Data Records
383 * sent in the current stream from the current Observation Domain by
384 * the Exporting Process
387 clib_atomic_fetch_add (&stream->sequence_number,
388 fr->per_thread_data[thread_index].n_data_records);
389 h->sequence_number = clib_host_to_net_u32 (h->sequence_number);
392 * For data records we use the template ID as the set ID.
395 s->set_id_length = ipfix_set_id_length (
397 b0->current_length - (ip_len + sizeof (*udp) + sizeof (*h)));
399 version_length (b0->current_length - (ip_len + sizeof (*udp)));
401 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
403 ip4 = (ip4_header_t *) ip;
404 ip4->length = clib_host_to_net_u16 (b0->current_length);
405 ip4->checksum = ip4_header_checksum (ip4);
406 udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip4));
407 ASSERT (ip4_header_checksum_is_valid (ip4));
411 ip6 = (ip6_header_t *) ip;
412 /* Ipv6 payload length does not include the IPv6 header */
413 ip6->payload_length =
414 clib_host_to_net_u16 (b0->current_length - sizeof (*ip6));
415 udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip6));
418 if (exp->udp_checksum || ip_addr_version (&exp->ipfix_collector) == AF_IP6)
420 /* RFC 7011 section 10.3.2. */
421 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
422 udp->checksum = ip4_tcp_udp_compute_checksum (vm, b0, ip4);
427 ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip6, &bogus);
429 if (udp->checksum == 0)
430 udp->checksum = 0xffff;
433 /* Find or allocate a frame */
434 f = fr->per_thread_data[thread_index].frame;
435 if (PREDICT_FALSE (f == 0))
438 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
439 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
441 f = vlib_get_frame_to_node (vm, ip6_lookup_node.index);
442 fr->per_thread_data[thread_index].frame = f;
443 u32 bi0 = vlib_get_buffer_index (vm, b0);
445 /* Enqueue the buffer */
446 to_next = vlib_frame_vector_args (f);
451 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
452 vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
454 vlib_put_frame_to_node (vm, ip6_lookup_node.index, f);
456 fr->per_thread_data[thread_index].frame = NULL;
457 fr->per_thread_data[thread_index].buffer = NULL;
458 fr->per_thread_data[thread_index].next_data_offset = 0;
462 flow_report_process_send (vlib_main_t *vm, flow_report_main_t *frm,
463 ipfix_exporter_t *exp, flow_report_t *fr,
464 u32 next_node, u32 template_bi)
466 vlib_frame_t *nf = 0;
469 nf = vlib_get_frame_to_node (vm, next_node);
471 to_next = vlib_frame_vector_args (nf);
473 if (template_bi != ~0)
475 to_next[0] = template_bi;
480 nf = fr->flow_data_callback (frm, exp, fr, nf, to_next, next_node);
484 vlib_put_frame_to_node (vm, next_node, nf);
487 vlib_frame_free (vm, nf);
493 flow_report_process (vlib_main_t * vm,
494 vlib_node_runtime_t * rt, vlib_frame_t * f)
496 flow_report_main_t *frm = &flow_report_main;
498 u32 ip4_lookup_node_index;
499 vlib_node_t *ip4_lookup_node;
500 u32 ip6_lookup_node_index;
501 vlib_node_t *ip6_lookup_node;
505 f64 def_wait_time = 5.0;
508 uword *event_data = 0;
510 /* Wait for Godot... */
511 vlib_process_wait_for_event_or_clock (vm, 1e9);
512 event_type = vlib_process_get_events (vm, &event_data);
514 clib_warning ("bogus kickoff event received, %d", event_type);
515 vec_reset_length (event_data);
517 /* Enqueue pkts to ip4-lookup */
518 ip4_lookup_node = vlib_get_node_by_name (vm, (u8 *) "ip4-lookup");
519 ip4_lookup_node_index = ip4_lookup_node->index;
521 /* Enqueue pkts to ip6-lookup */
522 ip6_lookup_node = vlib_get_node_by_name (vm, (u8 *) "ip6-lookup");
523 ip6_lookup_node_index = ip6_lookup_node->index;
525 wait_time = def_wait_time;
529 vlib_process_wait_for_event_or_clock (vm, wait_time);
530 event_type = vlib_process_get_events (vm, &event_data);
531 vec_reset_length (event_data);
532 ipfix_exporter_t *exp;
533 pool_foreach (exp, frm->exporters)
536 /* 5s delay by default, possibly reduced by template intervals */
537 wait_time = def_wait_time;
539 vec_foreach (fr, exp->reports)
542 now = vlib_time_now (vm);
544 /* Need to send a template packet? */
546 now > (fr->last_template_sent + exp->template_interval);
547 send_template += fr->last_template_sent == 0;
552 rv = send_template_packet (frm, exp, fr, &template_bi);
558 * decide if template should be sent sooner than current wait
562 (fr->last_template_sent + exp->template_interval) - now;
563 wait_time = clib_min (wait_time, next_template);
565 if (ip_addr_version (&exp->ipfix_collector) == AF_IP4)
567 flow_report_process_send (
568 vm, frm, exp, fr, ip4_lookup_node_index, template_bi);
572 flow_report_process_send (
573 vm, frm, exp, fr, ip6_lookup_node_index, template_bi);
579 return 0; /* not so much */
583 VLIB_REGISTER_NODE (flow_report_process_node) = {
584 .function = flow_report_process,
585 .type = VLIB_NODE_TYPE_PROCESS,
586 .name = "flow-report-process",
591 vnet_flow_report_add_del (ipfix_exporter_t *exp,
592 vnet_flow_report_add_del_args_t *a, u16 *template_id)
595 int found_index = ~0;
597 flow_report_stream_t *stream;
599 vlib_thread_main_t *tm = &vlib_thread_main;
600 flow_report_main_t *frm = &flow_report_main;
601 vlib_main_t *vm = frm->vlib_main;
604 si = find_stream (exp, a->domain_id, a->src_port);
606 return VNET_API_ERROR_INVALID_VALUE;
607 if (si == -1 && a->is_add == 0)
608 return VNET_API_ERROR_NO_SUCH_ENTRY;
610 for (i = 0; i < vec_len (exp->reports); i++)
612 fr = vec_elt_at_index (exp->reports, i);
613 if (fr->opaque.as_uword == a->opaque.as_uword
614 && fr->rewrite_callback == a->rewrite_callback
615 && fr->flow_data_callback == a->flow_data_callback)
619 *template_id = fr->template_id;
626 if (found_index != ~0)
629 i < vec_len (exp->reports[found_index].per_thread_data); i++)
632 if (exp->reports[found_index].per_thread_data[i].buffer)
634 bi = vlib_get_buffer_index (
635 vm, exp->reports[found_index].per_thread_data[i].buffer);
636 vlib_buffer_free (vm, &bi, 1);
639 vec_free (exp->reports[found_index].per_thread_data);
641 vec_delete (exp->reports, 1, found_index);
642 stream = &exp->streams[si];
644 if (stream->n_reports == 0)
645 delete_stream (exp, si);
648 return VNET_API_ERROR_NO_SUCH_ENTRY;
651 if (found_index != ~0)
652 return VNET_API_ERROR_VALUE_EXIST;
656 stream = add_stream (exp);
657 stream->domain_id = a->domain_id;
658 stream->src_port = a->src_port;
659 stream->sequence_number = 0;
660 stream->n_reports = 0;
661 si = stream - exp->streams;
664 stream = &exp->streams[si];
668 vec_add2 (exp->reports, fr, 1);
670 fr->stream_index = si;
671 fr->template_id = 256 + stream->next_template_no;
672 stream->next_template_no = (stream->next_template_no + 1) % (65536 - 256);
673 fr->update_rewrite = 1;
674 fr->opaque = a->opaque;
675 fr->rewrite_callback = a->rewrite_callback;
676 fr->flow_data_callback = a->flow_data_callback;
677 fr->report_elements = a->report_elements;
678 fr->n_report_elements = a->n_report_elements;
679 fr->stream_indexp = a->stream_indexp;
680 vec_validate (fr->per_thread_data, tm->n_threads);
681 /* Store the flow_report index back in the args struct */
682 a->flow_report_index = fr - exp->reports;
685 for (int i = 0; i < fr->n_report_elements; i++)
686 size += fr->report_elements[i].size;
687 fr->data_record_size = size;
689 *template_id = fr->template_id;
695 flow_report_add_del_error_to_clib_error (int error)
701 case VNET_API_ERROR_NO_SUCH_ENTRY:
702 return clib_error_return (0, "Flow report not found");
703 case VNET_API_ERROR_VALUE_EXIST:
704 return clib_error_return (0, "Flow report already exists");
705 case VNET_API_ERROR_INVALID_VALUE:
706 return clib_error_return (0, "Expecting either still unused values "
707 "for both domain_id and src_port "
708 "or already used values for both fields");
710 return clib_error_return (0, "vnet_flow_report_add_del returned %d",
716 vnet_flow_reports_reset (ipfix_exporter_t *exp)
721 for (i = 0; i < vec_len (exp->streams); i++)
722 if (stream_index_valid (exp, i))
723 exp->streams[i].sequence_number = 0;
725 vec_foreach (fr, exp->reports)
727 fr->update_rewrite = 1;
728 fr->last_template_sent = 0;
733 vnet_stream_reset (ipfix_exporter_t *exp, u32 stream_index)
737 exp->streams[stream_index].sequence_number = 0;
739 vec_foreach (fr, exp->reports)
740 if (exp->reports->stream_index == stream_index)
742 fr->update_rewrite = 1;
743 fr->last_template_sent = 0;
748 vnet_stream_change (ipfix_exporter_t *exp, u32 old_domain_id, u16 old_src_port,
749 u32 new_domain_id, u16 new_src_port)
751 i32 stream_index = find_stream (exp, old_domain_id, old_src_port);
753 if (stream_index < 0)
755 flow_report_stream_t *stream = &exp->streams[stream_index];
756 stream->domain_id = new_domain_id;
757 stream->src_port = new_src_port;
758 if (old_domain_id != new_domain_id || old_src_port != new_src_port)
759 vnet_stream_reset (exp, stream_index);
763 static clib_error_t *
764 set_ipfix_exporter_command_fn (vlib_main_t * vm,
765 unformat_input_t * input,
766 vlib_cli_command_t * cmd)
768 flow_report_main_t *frm = &flow_report_main;
769 ip_address_t collector = IP_ADDRESS_V4_ALL_0S, src = IP_ADDRESS_V4_ALL_0S;
770 u16 collector_port = UDP_DST_PORT_ipfix;
774 u32 path_mtu = 512; // RFC 7011 section 10.3.3.
775 u32 template_interval = 20;
777 ipfix_exporter_t *exp = pool_elt_at_index (frm->exporters, 0);
780 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
782 if (unformat (input, "collector %U", unformat_ip4_address,
785 else if (unformat (input, "port %U", unformat_udp_port,
788 else if (unformat (input, "src %U", unformat_ip4_address, &src.ip.ip4))
790 else if (unformat (input, "fib-id %u", &fib_id))
792 ip4_main_t *im = &ip4_main;
793 uword *p = hash_get (im->fib_index_by_table_id, fib_id);
795 return clib_error_return (0, "fib ID %d doesn't exist\n", fib_id);
798 else if (unformat (input, "path-mtu %u", &path_mtu))
800 else if (unformat (input, "template-interval %u", &template_interval))
802 else if (unformat (input, "udp-checksum"))
809 * If the collector address is set then the src must be too.
810 * Collector address can be set to 0 to disable exporter
812 if (!ip_address_is_zero (&collector) && ip_address_is_zero (&src))
813 return clib_error_return (0, "src address required");
814 if (collector.version != src.version)
815 return clib_error_return (
816 0, "src address and dest address must use same IP version");
818 if (path_mtu > 1450 /* vpp does not support fragmentation */ )
819 return clib_error_return (0, "too big path-mtu value, maximum is 1450");
822 return clib_error_return (0, "too small path-mtu value, minimum is 68");
824 /* Calculate how much header data we need. */
825 if (collector.version == AF_IP4)
826 ip_header_size = sizeof (ip4_header_t);
828 ip_header_size = sizeof (ip6_header_t);
829 exp->all_headers_size = ip_header_size + sizeof (udp_header_t) +
830 sizeof (ipfix_message_header_t) +
831 sizeof (ipfix_set_header_t);
833 /* Reset report streams if we are reconfiguring IP addresses */
834 if (ip_address_cmp (&exp->ipfix_collector, &collector) ||
835 ip_address_cmp (&exp->src_address, &src) ||
836 exp->collector_port != collector_port)
837 vnet_flow_reports_reset (exp);
839 exp->ipfix_collector = collector;
840 exp->collector_port = collector_port;
841 exp->src_address = src;
842 exp->fib_index = fib_index;
843 exp->path_mtu = path_mtu;
844 exp->template_interval = template_interval;
845 exp->udp_checksum = udp_checksum;
847 if (collector.ip.ip4.as_u32)
849 "Collector %U, src address %U, "
850 "fib index %d, path MTU %u, "
851 "template resend interval %us, "
853 format_ip4_address, &exp->ipfix_collector.ip.ip4,
854 format_ip4_address, &exp->src_address.ip.ip4, fib_index,
855 path_mtu, template_interval,
856 udp_checksum ? "enabled" : "disabled");
858 vlib_cli_output (vm, "IPFIX Collector is disabled");
860 /* Turn on the flow reporting process */
861 vlib_process_signal_event (vm, flow_report_process_node.index, 1, 0);
866 VLIB_CLI_COMMAND (set_ipfix_exporter_command, static) = {
867 .path = "set ipfix exporter",
868 .short_help = "set ipfix exporter "
869 "collector <ip4-address> [port <port>] "
870 "src <ip4-address> [fib-id <fib-id>] "
871 "[path-mtu <path-mtu>] "
872 "[template-interval <template-interval>] "
874 .function = set_ipfix_exporter_command_fn,
879 static clib_error_t *
880 ipfix_flush_command_fn (vlib_main_t * vm,
881 unformat_input_t * input, vlib_cli_command_t * cmd)
883 /* poke the flow reporting process */
884 vlib_process_signal_event (vm, flow_report_process_node.index, 1, 0);
889 VLIB_CLI_COMMAND (ipfix_flush_command, static) = {
890 .path = "ipfix flush",
891 .short_help = "flush the current ipfix data [for make test]",
892 .function = ipfix_flush_command_fn,
896 static clib_error_t *
897 flow_report_init (vlib_main_t * vm)
899 flow_report_main_t *frm = &flow_report_main;
900 ipfix_exporter_t *exp;
903 frm->vnet_main = vnet_get_main ();
904 frm->unix_time_0 = time (0);
905 frm->vlib_time_0 = vlib_time_now (frm->vlib_main);
907 * Make sure that we can always access the first exporter for
908 * backwards compatibility reasons.
910 pool_alloc (frm->exporters, IPFIX_EXPORTERS_MAX);
911 pool_get (frm->exporters, exp);
912 /* Verify that this is at index 0 */
913 ASSERT (frm->exporters == exp);
918 VLIB_INIT_FUNCTION (flow_report_init);
920 * fd.io coding-style-patch-verification: ON
923 * eval: (c-set-style "gnu")