2 * nat_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>
21 #include <nat/nat_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
38 snat_protocol_t snat_proto;
42 } snat_ipfix_logging_nat44_ses_args_t;
47 } snat_ipfix_logging_addr_exhausted_args_t;
52 } snat_ipfix_logging_max_entries_per_user_args_t;
54 #define skip_if_disabled() \
56 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main; \
57 if (PREDICT_TRUE (!silm->enabled)) \
62 * @brief Create an IPFIX template packet rewrite string
64 * @param frm flow report main
65 * @param fr flow report
66 * @param collector_address collector address
67 * @param src_address source address
68 * @param collector_port collector
69 * @param event NAT event ID
70 * @param quota_event NAT quota exceeded event ID
72 * @returns template packet
75 snat_template_rewrite (flow_report_main_t * frm,
77 ip4_address_t * collector_address,
78 ip4_address_t * src_address,
80 nat_event_t event, quota_exceed_event_t quota_event)
82 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
85 ipfix_message_header_t *h;
86 ipfix_set_header_t *s;
87 ipfix_template_header_t *t;
88 ipfix_field_specifier_t *f;
89 ipfix_field_specifier_t *first_field;
91 ip4_ipfix_template_packet_t *tp;
93 flow_report_stream_t *stream;
95 stream = &frm->streams[fr->stream_index];
96 silm->stream_index = fr->stream_index;
98 if (event == NAT_ADDRESSES_EXHAUTED)
100 field_count = NAT_ADDRESSES_EXHAUTED_FIELD_COUNT;
101 silm->addr_exhausted_template_id = fr->template_id;
103 else if (event == NAT44_SESSION_CREATE)
105 field_count = NAT44_SESSION_CREATE_FIELD_COUNT;
106 silm->nat44_session_template_id = fr->template_id;
108 else if (event == QUOTA_EXCEEDED)
110 if (quota_event == MAX_ENTRIES_PER_USER)
112 field_count = MAX_ENTRIES_PER_USER_FIELD_COUNT;
113 silm->max_entries_per_user_template_id = fr->template_id;
117 /* allocate rewrite space */
118 vec_validate_aligned (rewrite,
119 sizeof (ip4_ipfix_template_packet_t)
120 + field_count * sizeof (ipfix_field_specifier_t) - 1,
121 CLIB_CACHE_LINE_BYTES);
123 tp = (ip4_ipfix_template_packet_t *) rewrite;
124 ip = (ip4_header_t *) & tp->ip4;
125 udp = (udp_header_t *) (ip + 1);
126 h = (ipfix_message_header_t *) (udp + 1);
127 s = (ipfix_set_header_t *) (h + 1);
128 t = (ipfix_template_header_t *) (s + 1);
129 first_field = f = (ipfix_field_specifier_t *) (t + 1);
131 ip->ip_version_and_header_length = 0x45;
133 ip->protocol = IP_PROTOCOL_UDP;
134 ip->src_address.as_u32 = src_address->as_u32;
135 ip->dst_address.as_u32 = collector_address->as_u32;
136 udp->src_port = clib_host_to_net_u16 (stream->src_port);
137 udp->dst_port = clib_host_to_net_u16 (collector_port);
138 udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
140 /* FIXUP: message header export_time */
141 h->domain_id = clib_host_to_net_u32 (stream->domain_id);
143 /* Add TLVs to the template */
144 if (event == NAT_ADDRESSES_EXHAUTED)
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, natPoolId, 4);
153 else if (event == NAT44_SESSION_CREATE)
155 f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
157 f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
159 f->e_id_length = ipfix_e_id_length (0, sourceIPv4Address, 4);
161 f->e_id_length = ipfix_e_id_length (0, postNATSourceIPv4Address, 4);
163 f->e_id_length = ipfix_e_id_length (0, protocolIdentifier, 1);
165 f->e_id_length = ipfix_e_id_length (0, sourceTransportPort, 2);
167 f->e_id_length = ipfix_e_id_length (0, postNAPTSourceTransportPort, 2);
169 f->e_id_length = ipfix_e_id_length (0, ingressVRFID, 4);
172 else if (event == QUOTA_EXCEEDED)
174 if (quota_event == MAX_ENTRIES_PER_USER)
176 f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds,
179 f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
181 f->e_id_length = ipfix_e_id_length (0, natQuotaExceededEvent, 4);
183 f->e_id_length = ipfix_e_id_length (0, sourceIPv4Address, 4);
188 /* Back to the template packet... */
189 ip = (ip4_header_t *) & tp->ip4;
190 udp = (udp_header_t *) (ip + 1);
192 ASSERT (f - first_field);
193 /* Field count in this template */
194 t->id_count = ipfix_id_count (fr->template_id, f - first_field);
196 /* set length in octets */
198 ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
200 /* message length in octets */
201 h->version_length = version_length ((u8 *) f - (u8 *) h);
203 ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
204 ip->checksum = ip4_header_checksum (ip);
210 snat_template_rewrite_addr_exhausted (flow_report_main_t * frm,
212 ip4_address_t * collector_address,
213 ip4_address_t * src_address,
216 return snat_template_rewrite (frm, fr, collector_address, src_address,
217 collector_port, NAT_ADDRESSES_EXHAUTED, 0);
221 snat_template_rewrite_nat44_session (flow_report_main_t * frm,
223 ip4_address_t * collector_address,
224 ip4_address_t * src_address,
227 return snat_template_rewrite (frm, fr, collector_address, src_address,
228 collector_port, NAT44_SESSION_CREATE, 0);
232 snat_template_rewrite_max_entries_per_usr (flow_report_main_t * frm,
234 ip4_address_t * collector_address,
235 ip4_address_t * src_address,
238 return snat_template_rewrite (frm, fr, collector_address, src_address,
239 collector_port, QUOTA_EXCEEDED,
240 MAX_ENTRIES_PER_USER);
244 snat_ipfix_header_create (flow_report_main_t * frm,
245 vlib_buffer_t * b0, u32 * offset)
247 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
248 flow_report_stream_t *stream;
249 ip4_ipfix_template_packet_t *tp;
250 ipfix_message_header_t *h = 0;
251 ipfix_set_header_t *s = 0;
255 stream = &frm->streams[silm->stream_index];
257 b0->current_data = 0;
258 b0->current_length = sizeof (*ip) + sizeof (*udp) + sizeof (*h) +
260 b0->flags |= (VLIB_BUFFER_TOTAL_LENGTH_VALID | VLIB_BUFFER_FLOW_REPORT);
261 vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
262 vnet_buffer (b0)->sw_if_index[VLIB_TX] = frm->fib_index;
263 tp = vlib_buffer_get_current (b0);
264 ip = (ip4_header_t *) & tp->ip4;
265 udp = (udp_header_t *) (ip + 1);
266 h = (ipfix_message_header_t *) (udp + 1);
267 s = (ipfix_set_header_t *) (h + 1);
269 ip->ip_version_and_header_length = 0x45;
271 ip->protocol = IP_PROTOCOL_UDP;
272 ip->flags_and_fragment_offset = 0;
273 ip->src_address.as_u32 = frm->src_address.as_u32;
274 ip->dst_address.as_u32 = frm->ipfix_collector.as_u32;
275 udp->src_port = clib_host_to_net_u16 (stream->src_port);
276 udp->dst_port = clib_host_to_net_u16 (frm->collector_port);
279 h->export_time = clib_host_to_net_u32 ((u32)
280 (((f64) frm->unix_time_0) +
281 (vlib_time_now (frm->vlib_main) -
283 h->sequence_number = clib_host_to_net_u32 (stream->sequence_number++);
284 h->domain_id = clib_host_to_net_u32 (stream->domain_id);
286 *offset = (u32) (((u8 *) (s + 1)) - (u8 *) tp);
290 snat_ipfix_send (flow_report_main_t * frm,
291 vlib_frame_t * f, vlib_buffer_t * b0, u16 template_id)
293 ip4_ipfix_template_packet_t *tp;
294 ipfix_message_header_t *h = 0;
295 ipfix_set_header_t *s = 0;
298 vlib_main_t *vm = frm->vlib_main;
300 tp = vlib_buffer_get_current (b0);
301 ip = (ip4_header_t *) & tp->ip4;
302 udp = (udp_header_t *) (ip + 1);
303 h = (ipfix_message_header_t *) (udp + 1);
304 s = (ipfix_set_header_t *) (h + 1);
306 s->set_id_length = ipfix_set_id_length (template_id,
308 (sizeof (*ip) + sizeof (*udp) +
310 h->version_length = version_length (b0->current_length -
311 (sizeof (*ip) + sizeof (*udp)));
313 ip->length = clib_host_to_net_u16 (b0->current_length);
314 ip->checksum = ip4_header_checksum (ip);
315 udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip));
317 if (frm->udp_checksum)
319 udp->checksum = ip4_tcp_udp_compute_checksum (vm, b0, ip);
320 if (udp->checksum == 0)
321 udp->checksum = 0xffff;
324 ASSERT (ip->checksum == ip4_header_checksum (ip));
326 vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
330 snat_ipfix_logging_nat44_ses (u8 nat_event, u32 src_ip, u32 nat_src_ip,
331 snat_protocol_t snat_proto, u16 src_port,
332 u16 nat_src_port, u32 vrf_id, int do_flush)
334 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
335 flow_report_main_t *frm = &flow_report_main;
337 vlib_buffer_t *b0 = 0;
340 vlib_main_t *vm = frm->vlib_main;
342 vlib_buffer_free_list_t *fl;
348 proto = snat_proto_to_ip_proto (snat_proto);
350 now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
351 now += silm->milisecond_time_0;
353 b0 = silm->nat44_session_buffer;
355 if (PREDICT_FALSE (b0 == 0))
360 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
362 clib_warning ("can't allocate buffer for NAT IPFIX event");
366 b0 = silm->nat44_session_buffer = vlib_get_buffer (vm, bi0);
368 vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
369 vlib_buffer_init_for_free_list (b0, fl);
370 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
375 bi0 = vlib_get_buffer_index (vm, b0);
376 offset = silm->nat44_session_next_record_offset;
379 f = silm->nat44_session_frame;
380 if (PREDICT_FALSE (f == 0))
383 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
384 silm->nat44_session_frame = f;
385 to_next = vlib_frame_vector_args (f);
390 if (PREDICT_FALSE (offset == 0))
391 snat_ipfix_header_create (frm, b0, &offset);
393 if (PREDICT_TRUE (do_flush == 0))
395 u64 time_stamp = clib_host_to_net_u64 (now);
396 clib_memcpy (b0->data + offset, &time_stamp, sizeof (time_stamp));
397 offset += sizeof (time_stamp);
399 clib_memcpy (b0->data + offset, &nat_event, sizeof (nat_event));
400 offset += sizeof (nat_event);
402 clib_memcpy (b0->data + offset, &src_ip, sizeof (src_ip));
403 offset += sizeof (src_ip);
405 clib_memcpy (b0->data + offset, &nat_src_ip, sizeof (nat_src_ip));
406 offset += sizeof (nat_src_ip);
408 clib_memcpy (b0->data + offset, &proto, sizeof (proto));
409 offset += sizeof (proto);
411 clib_memcpy (b0->data + offset, &src_port, sizeof (src_port));
412 offset += sizeof (src_port);
414 clib_memcpy (b0->data + offset, &nat_src_port, sizeof (nat_src_port));
415 offset += sizeof (nat_src_port);
417 clib_memcpy (b0->data + offset, &vrf_id, sizeof (vrf_id));
418 offset += sizeof (vrf_id);
420 b0->current_length += NAT44_SESSION_CREATE_LEN;
424 (do_flush || (offset + NAT44_SESSION_CREATE_LEN) > frm->path_mtu))
426 snat_ipfix_send (frm, f, b0, silm->nat44_session_template_id);
427 silm->nat44_session_frame = 0;
428 silm->nat44_session_buffer = 0;
431 silm->nat44_session_next_record_offset = offset;
435 snat_ipfix_logging_addr_exhausted (u32 pool_id, int do_flush)
437 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
438 flow_report_main_t *frm = &flow_report_main;
440 vlib_buffer_t *b0 = 0;
443 vlib_main_t *vm = frm->vlib_main;
445 vlib_buffer_free_list_t *fl;
446 u8 nat_event = NAT_ADDRESSES_EXHAUTED;
451 now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
452 now += silm->milisecond_time_0;
454 b0 = silm->addr_exhausted_buffer;
456 if (PREDICT_FALSE (b0 == 0))
461 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
463 clib_warning ("can't allocate buffer for NAT IPFIX event");
467 b0 = silm->addr_exhausted_buffer = vlib_get_buffer (vm, bi0);
469 vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
470 vlib_buffer_init_for_free_list (b0, fl);
471 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
476 bi0 = vlib_get_buffer_index (vm, b0);
477 offset = silm->addr_exhausted_next_record_offset;
480 f = silm->addr_exhausted_frame;
481 if (PREDICT_FALSE (f == 0))
484 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
485 silm->addr_exhausted_frame = f;
486 to_next = vlib_frame_vector_args (f);
491 if (PREDICT_FALSE (offset == 0))
492 snat_ipfix_header_create (frm, b0, &offset);
494 if (PREDICT_TRUE (do_flush == 0))
496 u64 time_stamp = clib_host_to_net_u64 (now);
497 clib_memcpy (b0->data + offset, &time_stamp, sizeof (time_stamp));
498 offset += sizeof (time_stamp);
500 clib_memcpy (b0->data + offset, &nat_event, sizeof (nat_event));
501 offset += sizeof (nat_event);
503 clib_memcpy (b0->data + offset, &pool_id, sizeof (pool_id));
504 offset += sizeof (pool_id);
506 b0->current_length += NAT_ADDRESSES_EXHAUTED_LEN;
510 (do_flush || (offset + NAT_ADDRESSES_EXHAUTED_LEN) > frm->path_mtu))
512 snat_ipfix_send (frm, f, b0, silm->addr_exhausted_template_id);
513 silm->addr_exhausted_frame = 0;
514 silm->addr_exhausted_buffer = 0;
517 silm->addr_exhausted_next_record_offset = offset;
521 snat_ipfix_logging_max_entries_per_usr (u32 src_ip, int do_flush)
523 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
524 flow_report_main_t *frm = &flow_report_main;
526 vlib_buffer_t *b0 = 0;
529 vlib_main_t *vm = frm->vlib_main;
531 vlib_buffer_free_list_t *fl;
532 u8 nat_event = QUOTA_EXCEEDED;
533 u32 quota_event = MAX_ENTRIES_PER_USER;
538 now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
539 now += silm->milisecond_time_0;
541 b0 = silm->max_entries_per_user_buffer;
543 if (PREDICT_FALSE (b0 == 0))
548 if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
550 clib_warning ("can't allocate buffer for NAT IPFIX event");
554 b0 = silm->max_entries_per_user_buffer = vlib_get_buffer (vm, bi0);
556 vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
557 vlib_buffer_init_for_free_list (b0, fl);
558 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
563 bi0 = vlib_get_buffer_index (vm, b0);
564 offset = silm->max_entries_per_user_next_record_offset;
567 f = silm->max_entries_per_user_frame;
568 if (PREDICT_FALSE (f == 0))
571 f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
572 silm->max_entries_per_user_frame = f;
573 to_next = vlib_frame_vector_args (f);
578 if (PREDICT_FALSE (offset == 0))
579 snat_ipfix_header_create (frm, b0, &offset);
581 if (PREDICT_TRUE (do_flush == 0))
583 u64 time_stamp = clib_host_to_net_u64 (now);
584 clib_memcpy (b0->data + offset, &time_stamp, sizeof (time_stamp));
585 offset += sizeof (time_stamp);
587 clib_memcpy (b0->data + offset, &nat_event, sizeof (nat_event));
588 offset += sizeof (nat_event);
590 clib_memcpy (b0->data + offset, "a_event, sizeof (quota_event));
591 offset += sizeof (quota_event);
593 clib_memcpy (b0->data + offset, &src_ip, sizeof (src_ip));
594 offset += sizeof (src_ip);
596 b0->current_length += MAX_ENTRIES_PER_USER_LEN;
600 (do_flush || (offset + MAX_ENTRIES_PER_USER_LEN) > frm->path_mtu))
602 snat_ipfix_send (frm, f, b0, silm->max_entries_per_user_template_id);
603 silm->max_entries_per_user_frame = 0;
604 silm->max_entries_per_user_buffer = 0;
607 silm->max_entries_per_user_next_record_offset = offset;
611 snat_ipfix_logging_nat44_ses_rpc_cb (snat_ipfix_logging_nat44_ses_args_t * a)
613 snat_ipfix_logging_nat44_ses (a->nat_event, a->src_ip, a->nat_src_ip,
614 a->snat_proto, a->src_port, a->nat_src_port,
619 * @brief Generate NAT44 session create event
621 * @param src_ip source IPv4 address
622 * @param nat_src_ip transaltes source IPv4 address
623 * @param snat_proto NAT transport protocol
624 * @param src_port source port
625 * @param nat_src_port translated source port
626 * @param vrf_id VRF ID
629 snat_ipfix_logging_nat44_ses_create (u32 src_ip,
631 snat_protocol_t snat_proto,
633 u16 nat_src_port, u32 vrf_id)
635 snat_ipfix_logging_nat44_ses_args_t a;
639 a.nat_event = NAT44_SESSION_CREATE;
641 a.nat_src_ip = nat_src_ip;
642 a.snat_proto = snat_proto;
643 a.src_port = src_port;
644 a.nat_src_port = nat_src_port;
647 vl_api_rpc_call_main_thread (snat_ipfix_logging_nat44_ses_rpc_cb,
648 (u8 *) & a, sizeof (a));
652 * @brief Generate NAT44 session delete event
654 * @param src_ip source IPv4 address
655 * @param nat_src_ip transaltes source IPv4 address
656 * @param snat_proto NAT transport protocol
657 * @param src_port source port
658 * @param nat_src_port translated source port
659 * @param vrf_id VRF ID
662 snat_ipfix_logging_nat44_ses_delete (u32 src_ip,
664 snat_protocol_t snat_proto,
666 u16 nat_src_port, u32 vrf_id)
668 snat_ipfix_logging_nat44_ses_args_t a;
672 a.nat_event = NAT44_SESSION_DELETE;
674 a.nat_src_ip = nat_src_ip;
675 a.snat_proto = snat_proto;
676 a.src_port = src_port;
677 a.nat_src_port = nat_src_port;
680 vl_api_rpc_call_main_thread (snat_ipfix_logging_nat44_ses_rpc_cb,
681 (u8 *) & a, sizeof (a));
685 snat_data_callback_nat44_session (flow_report_main_t * frm,
688 u32 * to_next, u32 node_index)
690 snat_ipfix_logging_nat44_ses (0, 0, 0, 0, 0, 0, 0, 1);
695 snat_ipfix_logging_addr_exhausted_rpc_cb
696 (snat_ipfix_logging_addr_exhausted_args_t * a)
698 snat_ipfix_logging_addr_exhausted (a->pool_id, 0);
702 * @brief Generate NAT addresses exhausted event
704 * @param pool_id NAT pool ID
707 snat_ipfix_logging_addresses_exhausted (u32 pool_id)
709 //TODO: This event SHOULD be rate limited
710 snat_ipfix_logging_addr_exhausted_args_t a;
716 vl_api_rpc_call_main_thread (snat_ipfix_logging_addr_exhausted_rpc_cb,
717 (u8 *) & a, sizeof (a));
721 snat_data_callback_addr_exhausted (flow_report_main_t * frm,
724 u32 * to_next, u32 node_index)
726 snat_ipfix_logging_addr_exhausted (0, 1);
731 snat_ipfix_logging_max_entries_per_usr_rpc_cb
732 (snat_ipfix_logging_max_entries_per_user_args_t * a)
734 snat_ipfix_logging_max_entries_per_usr (a->src_ip, 0);
738 * @brief Generate maximum entries per user exceeded event
740 * @param src_ip source IPv4 address
743 snat_ipfix_logging_max_entries_per_user (u32 src_ip)
745 //TODO: This event SHOULD be rate limited
746 snat_ipfix_logging_max_entries_per_user_args_t a;
752 vl_api_rpc_call_main_thread (snat_ipfix_logging_max_entries_per_usr_rpc_cb,
753 (u8 *) & a, sizeof (a));
757 snat_data_callback_max_entries_per_usr (flow_report_main_t * frm,
760 u32 * to_next, u32 node_index)
762 snat_ipfix_logging_max_entries_per_usr (0, 1);
767 * @brief Enable/disable NAT plugin IPFIX logging
769 * @param enable 1 if enable, 0 if disable
770 * @param domain_id observation domain ID
771 * @param src_port source port number
773 * @returns 0 if success
776 snat_ipfix_logging_enable_disable (int enable, u32 domain_id, u16 src_port)
778 snat_main_t *sm = &snat_main;
779 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
780 flow_report_main_t *frm = &flow_report_main;
781 vnet_flow_report_add_del_args_t a;
783 u8 e = enable ? 1 : 0;
785 if (silm->enabled == e)
790 memset (&a, 0, sizeof (a));
792 a.domain_id = domain_id ? domain_id : 1;
793 a.src_port = src_port ? src_port : UDP_DST_PORT_ipfix;
795 if (sm->deterministic)
797 a.rewrite_callback = snat_template_rewrite_max_entries_per_usr;
798 a.flow_data_callback = snat_data_callback_max_entries_per_usr;
800 rv = vnet_flow_report_add_del (frm, &a, NULL);
803 clib_warning ("vnet_flow_report_add_del returned %d", rv);
809 a.rewrite_callback = snat_template_rewrite_nat44_session;
810 a.flow_data_callback = snat_data_callback_nat44_session;
812 rv = vnet_flow_report_add_del (frm, &a, NULL);
815 clib_warning ("vnet_flow_report_add_del returned %d", rv);
819 a.rewrite_callback = snat_template_rewrite_addr_exhausted;
820 a.flow_data_callback = snat_data_callback_addr_exhausted;
822 rv = vnet_flow_report_add_del (frm, &a, NULL);
825 clib_warning ("vnet_flow_report_add_del returned %d", rv);
834 * @brief Initialize NAT plugin IPFIX logging
836 * @param vm vlib main
839 snat_ipfix_logging_init (vlib_main_t * vm)
841 snat_ipfix_logging_main_t *silm = &snat_ipfix_logging_main;
845 /* Set up time reference pair */
846 silm->vlib_time_0 = vlib_time_now (vm);
847 silm->milisecond_time_0 = unix_time_now_nsec () * 1e-6;