2 * snat_ipfix_logging.c - NAT Events IPFIX logging
4 * Copyright (c) 2016 Cisco and/or its affiliates.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #include <vnet/flow/flow_report.h>
19 #include <vlibmemory/api.h>
20 #include <snat/snat.h>
21 #include <snat/snat_ipfix_logging.h>
23 snat_ipfix_logging_main_t snat_ipfix_logging_main;
25 #define NAT44_SESSION_CREATE_LEN 26
26 #define NAT_ADDRESSES_EXHAUTED_LEN 13
27 #define MAX_ENTRIES_PER_USER_LEN 17
29 #define NAT44_SESSION_CREATE_FIELD_COUNT 8
30 #define NAT_ADDRESSES_EXHAUTED_FIELD_COUNT 3
31 #define MAX_ENTRIES_PER_USER_FIELD_COUNT 4
37 snat_protocol_t snat_proto;
41 } snat_ipfix_logging_nat44_ses_args_t;
45 } snat_ipfix_logging_addr_exhausted_args_t;
49 } snat_ipfix_logging_max_entries_per_user_args_t;
52 * @brief Create an IPFIX template packet rewrite string
54 * @param frm flow report main
55 * @param fr flow report
56 * @param collector_address collector address
57 * @param src_address source address
58 * @param collector_port collector
59 * @param event NAT event ID
60 * @param quota_event NAT quota exceeded event ID
62 * @returns template packet
65 snat_template_rewrite (flow_report_main_t * frm,
67 ip4_address_t * collector_address,
68 ip4_address_t * src_address,
71 quota_exceed_event_t quota_event)
73 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
76 ipfix_message_header_t *h;
77 ipfix_set_header_t *s;
78 ipfix_template_header_t *t;
79 ipfix_field_specifier_t *f;
80 ipfix_field_specifier_t *first_field;
82 ip4_ipfix_template_packet_t *tp;
84 flow_report_stream_t *stream;
86 stream = &frm->streams[fr->stream_index];
87 silm->stream_index = fr->stream_index;
89 if (event == NAT_ADDRESSES_EXHAUTED)
91 field_count = NAT_ADDRESSES_EXHAUTED_FIELD_COUNT;
92 silm->addr_exhausted_template_id = fr->template_id;
94 else if (event == NAT44_SESSION_CREATE)
96 field_count = NAT44_SESSION_CREATE_FIELD_COUNT;
97 silm->nat44_session_template_id = fr->template_id;
99 else if (event == QUOTA_EXCEEDED)
101 if (quota_event == MAX_ENTRIES_PER_USER)
103 field_count = MAX_ENTRIES_PER_USER_FIELD_COUNT;
104 silm->max_entries_per_user_template_id = fr->template_id;
108 /* allocate rewrite space */
109 vec_validate_aligned (rewrite,
110 sizeof (ip4_ipfix_template_packet_t)
111 + field_count * sizeof (ipfix_field_specifier_t) - 1,
112 CLIB_CACHE_LINE_BYTES);
114 tp = (ip4_ipfix_template_packet_t *) rewrite;
115 ip = (ip4_header_t *) & tp->ip4;
116 udp = (udp_header_t *) (ip + 1);
117 h = (ipfix_message_header_t *) (udp + 1);
118 s = (ipfix_set_header_t *) (h + 1);
119 t = (ipfix_template_header_t *) (s + 1);
120 first_field = f = (ipfix_field_specifier_t *) (t + 1);
122 ip->ip_version_and_header_length = 0x45;
124 ip->protocol = IP_PROTOCOL_UDP;
125 ip->src_address.as_u32 = src_address->as_u32;
126 ip->dst_address.as_u32 = collector_address->as_u32;
127 udp->src_port = clib_host_to_net_u16 (stream->src_port);
128 udp->dst_port = clib_host_to_net_u16 (collector_port);
129 udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
131 /* FIXUP: message header export_time */
132 h->domain_id = clib_host_to_net_u32 (stream->domain_id);
134 /* Add TLVs to the template */
135 if (event == NAT_ADDRESSES_EXHAUTED)
137 f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
139 f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
141 f->e_id_length = ipfix_e_id_length (0, natPoolId, 4);
144 else if (event == NAT44_SESSION_CREATE)
146 f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
148 f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
150 f->e_id_length = ipfix_e_id_length (0, sourceIPv4Address, 4);
152 f->e_id_length = ipfix_e_id_length (0, postNATSourceIPv4Address, 4);
154 f->e_id_length = ipfix_e_id_length (0, protocolIdentifier, 1);
156 f->e_id_length = ipfix_e_id_length (0, sourceTransportPort, 2);
158 f->e_id_length = ipfix_e_id_length (0, postNAPTSourceTransportPort, 2);
160 f->e_id_length = ipfix_e_id_length (0, ingressVRFID, 4);
163 else if (event == QUOTA_EXCEEDED)
165 if (quota_event == MAX_ENTRIES_PER_USER)
167 f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds,
170 f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
172 f->e_id_length = ipfix_e_id_length (0, natQuotaExceededEvent, 4);
174 f->e_id_length = ipfix_e_id_length (0, sourceIPv4Address, 4);
179 /* Back to the template packet... */
180 ip = (ip4_header_t *) & tp->ip4;
181 udp = (udp_header_t *) (ip + 1);
183 ASSERT (f - first_field);
184 /* Field count in this template */
185 t->id_count = ipfix_id_count (fr->template_id, f - first_field);
187 /* set length in octets */
189 ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
191 /* message length in octets */
192 h->version_length = version_length ((u8 *) f - (u8 *) h);
194 ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
195 ip->checksum = ip4_header_checksum (ip);
201 snat_template_rewrite_addr_exhausted (flow_report_main_t * frm,
203 ip4_address_t * collector_address,
204 ip4_address_t * src_address,
207 return snat_template_rewrite (frm, fr, collector_address, src_address,
208 collector_port, NAT_ADDRESSES_EXHAUTED, 0);
212 snat_template_rewrite_nat44_session (flow_report_main_t * frm,
214 ip4_address_t * collector_address,
215 ip4_address_t * src_address,
218 return snat_template_rewrite (frm, fr, collector_address, src_address,
219 collector_port, NAT44_SESSION_CREATE, 0);
223 snat_template_rewrite_max_entries_per_usr (flow_report_main_t * frm,
225 ip4_address_t * collector_address,
226 ip4_address_t * src_address,
229 return snat_template_rewrite (frm, fr, collector_address, src_address,
230 collector_port, QUOTA_EXCEEDED,
231 MAX_ENTRIES_PER_USER);
235 snat_ipfix_header_create (flow_report_main_t * frm,
239 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
240 flow_report_stream_t *stream;
241 ip4_ipfix_template_packet_t * tp;
242 ipfix_message_header_t * h = 0;
243 ipfix_set_header_t * s = 0;
247 stream = &frm->streams[silm->stream_index];
249 b0->current_data = 0;
250 b0->current_length = sizeof (*ip) + sizeof (*udp) + sizeof (*h) +
252 b0->flags |= (VLIB_BUFFER_TOTAL_LENGTH_VALID | VLIB_BUFFER_FLOW_REPORT);
253 vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
254 vnet_buffer (b0)->sw_if_index[VLIB_TX] = frm->fib_index;
255 tp = vlib_buffer_get_current (b0);
256 ip = (ip4_header_t *) &tp->ip4;
257 udp = (udp_header_t *) (ip+1);
258 h = (ipfix_message_header_t *)(udp+1);
259 s = (ipfix_set_header_t *)(h+1);
261 ip->ip_version_and_header_length = 0x45;
263 ip->protocol = IP_PROTOCOL_UDP;
264 ip->flags_and_fragment_offset = 0;
265 ip->src_address.as_u32 = frm->src_address.as_u32;
266 ip->dst_address.as_u32 = frm->ipfix_collector.as_u32;
267 udp->src_port = clib_host_to_net_u16 (stream->src_port);
268 udp->dst_port = clib_host_to_net_u16 (frm->collector_port);
271 h->export_time = clib_host_to_net_u32 (
272 (u32) (((f64)frm->unix_time_0) + (vlib_time_now(frm->vlib_main) -
274 h->sequence_number = clib_host_to_net_u32 (stream->sequence_number++);
275 h->domain_id = clib_host_to_net_u32 (stream->domain_id);
277 *offset = (u32) (((u8 *)(s+1)) - (u8 *)tp);
281 snat_ipfix_send (flow_report_main_t * frm,
286 ip4_ipfix_template_packet_t * tp;
287 ipfix_message_header_t * h = 0;
288 ipfix_set_header_t * s = 0;
291 vlib_main_t * vm = frm->vlib_main;
293 tp = vlib_buffer_get_current (b0);
294 ip = (ip4_header_t *) & tp->ip4;
295 udp = (udp_header_t *) (ip + 1);
296 h = (ipfix_message_header_t *) (udp + 1);
297 s = (ipfix_set_header_t *) (h + 1);
299 s->set_id_length = ipfix_set_id_length (template_id,
301 (sizeof (*ip) + sizeof (*udp) +
303 h->version_length = version_length (b0->current_length -
304 (sizeof (*ip) + sizeof (*udp)));
306 ip->length = clib_host_to_net_u16 (b0->current_length);
307 ip->checksum = ip4_header_checksum (ip);
308 udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip));
310 if (frm->udp_checksum)
312 udp->checksum = ip4_tcp_udp_compute_checksum (vm, b0, ip);
313 if (udp->checksum == 0)
314 udp->checksum = 0xffff;
317 ASSERT (ip->checksum == ip4_header_checksum (ip));
319 vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
323 snat_ipfix_logging_nat44_ses (u8 nat_event, u32 src_ip, u32 nat_src_ip,
324 snat_protocol_t snat_proto, u16 src_port,
325 u16 nat_src_port, u32 vrf_id, int do_flush)
327 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
328 flow_report_main_t *frm = &flow_report_main;
330 vlib_buffer_t *b0 = 0;
333 vlib_main_t * vm = frm->vlib_main;
335 vlib_buffer_free_list_t *fl;
341 proto = snat_proto_to_ip_proto (snat_proto);
343 now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
344 now += silm->milisecond_time_0;
346 b0 = silm->nat44_session_buffer;
348 if (PREDICT_FALSE (b0 == 0))
353 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
355 clib_warning ("can't allocate buffer for NAT IPFIX event");
359 b0 = silm->nat44_session_buffer =
360 vlib_get_buffer (vm, bi0);
361 fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
362 vlib_buffer_init_for_free_list (b0, fl);
363 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
368 bi0 = vlib_get_buffer_index (vm, b0);
369 offset = silm->nat44_session_next_record_offset;
372 f = silm->nat44_session_frame;
373 if (PREDICT_FALSE (f == 0))
376 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
377 silm->nat44_session_frame = f;
378 to_next = vlib_frame_vector_args (f);
383 if (PREDICT_FALSE (offset == 0))
384 snat_ipfix_header_create (frm, b0, &offset);
386 if (PREDICT_TRUE (do_flush == 0))
388 u64 time_stamp = clib_host_to_net_u64 (now);
389 clib_memcpy (b0->data + offset, &time_stamp, sizeof (time_stamp));
390 offset += sizeof (time_stamp);
392 clib_memcpy (b0->data + offset, &nat_event, sizeof (nat_event));
393 offset += sizeof (nat_event);
395 clib_memcpy (b0->data + offset, &src_ip, sizeof (src_ip));
396 offset += sizeof (src_ip);
398 clib_memcpy (b0->data + offset, &nat_src_ip, sizeof (nat_src_ip));
399 offset += sizeof (nat_src_ip);
401 clib_memcpy (b0->data + offset, &proto, sizeof (proto));
402 offset += sizeof (proto);
404 clib_memcpy (b0->data + offset, &src_port, sizeof (src_port));
405 offset += sizeof (src_port);
407 clib_memcpy (b0->data + offset, &nat_src_port, sizeof (nat_src_port));
408 offset += sizeof (nat_src_port);
410 clib_memcpy (b0->data + offset, &vrf_id, sizeof(vrf_id));
411 offset += sizeof (vrf_id);
413 b0->current_length += NAT44_SESSION_CREATE_LEN;
416 if (PREDICT_FALSE (do_flush || (offset + NAT44_SESSION_CREATE_LEN) > frm->path_mtu))
418 snat_ipfix_send (frm, f, b0, silm->nat44_session_template_id);
419 silm->nat44_session_frame = 0;
420 silm->nat44_session_buffer = 0;
423 silm->nat44_session_next_record_offset = offset;
427 snat_ipfix_logging_addr_exhausted (u32 pool_id, int do_flush)
429 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
430 flow_report_main_t *frm = &flow_report_main;
432 vlib_buffer_t *b0 = 0;
435 vlib_main_t * vm = frm->vlib_main;
437 vlib_buffer_free_list_t *fl;
438 u8 nat_event = NAT_ADDRESSES_EXHAUTED;
443 now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
444 now += silm->milisecond_time_0;
446 b0 = silm->addr_exhausted_buffer;
448 if (PREDICT_FALSE (b0 == 0))
453 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
455 clib_warning ("can't allocate buffer for NAT IPFIX event");
459 b0 = silm->addr_exhausted_buffer =
460 vlib_get_buffer (vm, bi0);
461 fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
462 vlib_buffer_init_for_free_list (b0, fl);
463 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
468 bi0 = vlib_get_buffer_index (vm, b0);
469 offset = silm->addr_exhausted_next_record_offset;
472 f = silm->addr_exhausted_frame;
473 if (PREDICT_FALSE (f == 0))
476 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
477 silm->addr_exhausted_frame = f;
478 to_next = vlib_frame_vector_args (f);
483 if (PREDICT_FALSE (offset == 0))
484 snat_ipfix_header_create (frm, b0, &offset);
486 if (PREDICT_TRUE (do_flush == 0))
488 u64 time_stamp = clib_host_to_net_u64 (now);
489 clib_memcpy (b0->data + offset, &time_stamp, sizeof (time_stamp));
490 offset += sizeof (time_stamp);
492 clib_memcpy (b0->data + offset, &nat_event, sizeof (nat_event));
493 offset += sizeof (nat_event);
495 clib_memcpy (b0->data + offset, &pool_id, sizeof(pool_id));
496 offset += sizeof (pool_id);
498 b0->current_length += NAT_ADDRESSES_EXHAUTED_LEN;
501 if (PREDICT_FALSE (do_flush || (offset + NAT_ADDRESSES_EXHAUTED_LEN) > frm->path_mtu))
503 snat_ipfix_send (frm, f, b0, silm->addr_exhausted_template_id);
504 silm->addr_exhausted_frame = 0;
505 silm->addr_exhausted_buffer = 0;
508 silm->addr_exhausted_next_record_offset = offset;
512 snat_ipfix_logging_max_entries_per_usr (u32 src_ip, int do_flush)
514 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
515 flow_report_main_t *frm = &flow_report_main;
517 vlib_buffer_t *b0 = 0;
520 vlib_main_t * vm = frm->vlib_main;
522 vlib_buffer_free_list_t *fl;
523 u8 nat_event = QUOTA_EXCEEDED;
524 u32 quota_event = MAX_ENTRIES_PER_USER;
529 now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
530 now += silm->milisecond_time_0;
532 b0 = silm->max_entries_per_user_buffer;
534 if (PREDICT_FALSE (b0 == 0))
539 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
541 clib_warning ("can't allocate buffer for NAT IPFIX event");
545 b0 = silm->max_entries_per_user_buffer =
546 vlib_get_buffer (vm, bi0);
547 fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
548 vlib_buffer_init_for_free_list (b0, fl);
549 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
554 bi0 = vlib_get_buffer_index (vm, b0);
555 offset = silm->max_entries_per_user_next_record_offset;
558 f = silm->max_entries_per_user_frame;
559 if (PREDICT_FALSE (f == 0))
562 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
563 silm->max_entries_per_user_frame = f;
564 to_next = vlib_frame_vector_args (f);
569 if (PREDICT_FALSE (offset == 0))
570 snat_ipfix_header_create (frm, b0, &offset);
572 if (PREDICT_TRUE (do_flush == 0))
574 u64 time_stamp = clib_host_to_net_u64 (now);
575 clib_memcpy (b0->data + offset, &time_stamp, sizeof (time_stamp));
576 offset += sizeof (time_stamp);
578 clib_memcpy (b0->data + offset, &nat_event, sizeof (nat_event));
579 offset += sizeof (nat_event);
581 clib_memcpy (b0->data + offset, "a_event, sizeof(quota_event));
582 offset += sizeof (quota_event);
584 clib_memcpy (b0->data + offset, &src_ip, sizeof (src_ip));
585 offset += sizeof (src_ip);
587 b0->current_length += MAX_ENTRIES_PER_USER_LEN;
590 if (PREDICT_FALSE (do_flush || (offset + MAX_ENTRIES_PER_USER_LEN) > frm->path_mtu))
592 snat_ipfix_send (frm, f, b0, silm->max_entries_per_user_template_id);
593 silm->max_entries_per_user_frame = 0;
594 silm->max_entries_per_user_buffer = 0;
597 silm->max_entries_per_user_next_record_offset = offset;
601 snat_ipfix_logging_nat44_ses_rpc_cb (snat_ipfix_logging_nat44_ses_args_t *a)
603 snat_ipfix_logging_nat44_ses(a->nat_event, a->src_ip, a->nat_src_ip,
604 a->snat_proto, a->src_port, a->nat_src_port,
609 * @brief Generate NAT44 session create event
611 * @param src_ip source IPv4 address
612 * @param nat_src_ip transaltes source IPv4 address
613 * @param snat_proto SNAT transport protocol
614 * @param src_port source port
615 * @param nat_src_port translated source port
616 * @param vrf_id VRF ID
619 snat_ipfix_logging_nat44_ses_create (u32 src_ip,
621 snat_protocol_t snat_proto,
626 snat_ipfix_logging_nat44_ses_args_t a;
628 a.nat_event = NAT44_SESSION_CREATE;
630 a.nat_src_ip = nat_src_ip;
631 a.snat_proto = snat_proto;
632 a.src_port = src_port;
633 a.nat_src_port = nat_src_port;
636 vl_api_rpc_call_main_thread (snat_ipfix_logging_nat44_ses_rpc_cb, (u8 *) &a,
641 * @brief Generate NAT44 session delete event
643 * @param src_ip source IPv4 address
644 * @param nat_src_ip transaltes source IPv4 address
645 * @param snat_proto SNAT transport protocol
646 * @param src_port source port
647 * @param nat_src_port translated source port
648 * @param vrf_id VRF ID
651 snat_ipfix_logging_nat44_ses_delete (u32 src_ip,
653 snat_protocol_t snat_proto,
658 snat_ipfix_logging_nat44_ses_args_t a;
660 a.nat_event = NAT44_SESSION_DELETE;
662 a.nat_src_ip = nat_src_ip;
663 a.snat_proto = snat_proto;
664 a.src_port = src_port;
665 a.nat_src_port = nat_src_port;
668 vl_api_rpc_call_main_thread (snat_ipfix_logging_nat44_ses_rpc_cb, (u8 *) &a,
673 snat_data_callback_nat44_session (flow_report_main_t * frm,
679 snat_ipfix_logging_nat44_ses(0, 0, 0, 0, 0, 0, 0, 1);
684 snat_ipfix_logging_addr_exhausted_rpc_cb
685 (snat_ipfix_logging_addr_exhausted_args_t * a)
687 snat_ipfix_logging_addr_exhausted(a->pool_id, 0);
691 * @brief Generate NAT addresses exhausted event
693 * @param pool_id NAT pool ID
696 snat_ipfix_logging_addresses_exhausted(u32 pool_id)
698 //TODO: This event SHOULD be rate limited
699 snat_ipfix_logging_addr_exhausted_args_t a;
703 vl_api_rpc_call_main_thread (snat_ipfix_logging_addr_exhausted_rpc_cb,
704 (u8 *) &a, sizeof (a));
708 snat_data_callback_addr_exhausted (flow_report_main_t * frm,
714 snat_ipfix_logging_addr_exhausted(0, 1);
719 snat_ipfix_logging_max_entries_per_usr_rpc_cb
720 (snat_ipfix_logging_max_entries_per_user_args_t * a)
722 snat_ipfix_logging_max_entries_per_usr(a->src_ip, 0);
726 * @brief Generate maximum entries per user exceeded event
728 * @param src_ip source IPv4 address
731 snat_ipfix_logging_max_entries_per_user(u32 src_ip)
733 //TODO: This event SHOULD be rate limited
734 snat_ipfix_logging_max_entries_per_user_args_t a;
738 vl_api_rpc_call_main_thread (snat_ipfix_logging_max_entries_per_usr_rpc_cb,
739 (u8 *) &a, sizeof (a));
743 snat_data_callback_max_entries_per_usr (flow_report_main_t * frm,
749 snat_ipfix_logging_max_entries_per_usr(0, 1);
754 * @brief Enable/disable SNAT IPFIX logging
756 * @param enable 1 if enable, 0 if disable
757 * @param domain_id observation domain ID
758 * @param src_port source port number
760 * @returns 0 if success
763 snat_ipfix_logging_enable_disable (int enable, u32 domain_id, u16 src_port)
765 snat_main_t * sm = &snat_main;
766 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
767 flow_report_main_t *frm = &flow_report_main;
768 vnet_flow_report_add_del_args_t a;
770 u8 e = enable ? 1 : 0;
772 if (silm->enabled == e)
777 memset (&a, 0, sizeof (a));
779 a.domain_id = domain_id ? domain_id : 1;
780 a.src_port = src_port ? src_port : UDP_DST_PORT_ipfix;
782 if (sm->deterministic)
784 a.rewrite_callback = snat_template_rewrite_max_entries_per_usr;
785 a.flow_data_callback = snat_data_callback_max_entries_per_usr;
787 rv = vnet_flow_report_add_del (frm, &a, NULL);
790 clib_warning ("vnet_flow_report_add_del returned %d", rv);
796 a.rewrite_callback = snat_template_rewrite_nat44_session;
797 a.flow_data_callback = snat_data_callback_nat44_session;
799 rv = vnet_flow_report_add_del (frm, &a, NULL);
802 clib_warning ("vnet_flow_report_add_del returned %d", rv);
806 a.rewrite_callback = snat_template_rewrite_addr_exhausted;
807 a.flow_data_callback = snat_data_callback_addr_exhausted;
809 rv = vnet_flow_report_add_del (frm, &a, NULL);
812 clib_warning ("vnet_flow_report_add_del returned %d", rv);
821 * @brief Initialize SNAT IPFIX logging
823 * @param vm vlib main
826 snat_ipfix_logging_init (vlib_main_t * vm)
828 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
832 /* Set up time reference pair */
833 silm->vlib_time_0 = vlib_time_now (vm);
834 silm->milisecond_time_0 = unix_time_now_nsec () * 1e-6;