src/plugins/nat/lib/ipfix_logging.c

   1 /*
   2  * nat_ipfix_logging.c - NAT Events IPFIX logging
   3  *
   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:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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.
  16  */
  17
  18 #include <vnet/ipfix-export/flow_report.h>
  19 #include <vnet/ip/ip4.h>
  20 #include <vnet/udp/udp_local.h>
  21 #include <vlibmemory/api.h>
  22 #include <vppinfra/atomics.h>
  23 #include <nat/lib/ipfix_logging.h>
  24 #include <nat/lib/inlines.h>
  25
  26 vlib_node_registration_t nat_ipfix_flush_node;
  27 nat_ipfix_logging_main_t nat_ipfix_logging_main;
  28
  29 #define NAT44_SESSION_CREATE_LEN 26
  30 #define NAT_ADDRESSES_EXHAUTED_LEN 13
  31 #define MAX_ENTRIES_PER_USER_LEN 21
  32 #define MAX_SESSIONS_LEN 17
  33 #define MAX_BIBS_LEN 17
  34 #define MAX_FRAGMENTS_IP4_LEN 21
  35 #define MAX_FRAGMENTS_IP6_LEN 33
  36 #define NAT64_BIB_LEN 38
  37 #define NAT64_SES_LEN 62
  38
  39 #define NAT44_SESSION_CREATE_FIELD_COUNT 8
  40 #define NAT_ADDRESSES_EXHAUTED_FIELD_COUNT 3
  41 #define MAX_ENTRIES_PER_USER_FIELD_COUNT 5
  42 #define MAX_SESSIONS_FIELD_COUNT 4
  43 #define MAX_BIBS_FIELD_COUNT 4
  44 #define MAX_FRAGMENTS_FIELD_COUNT 5
  45 #define NAT64_BIB_FIELD_COUNT 8
  46 #define NAT64_SES_FIELD_COUNT 12
  47
  48 typedef struct
  49 {
  50   u8 nat_event;
  51   u32 src_ip;
  52   u32 nat_src_ip;
  53   nat_protocol_t nat_proto;
  54   u16 src_port;
  55   u16 nat_src_port;
  56   u32 vrf_id;
  57 } nat_ipfix_logging_nat44_ses_args_t;
  58
  59 typedef struct
  60 {
  61   u32 pool_id;
  62 } nat_ipfix_logging_addr_exhausted_args_t;
  63
  64 typedef struct
  65 {
  66   u32 limit;
  67   u32 src_ip;
  68 } nat_ipfix_logging_max_entries_per_user_args_t;
  69
  70 typedef struct
  71 {
  72   u32 limit;
  73 } nat_ipfix_logging_max_sessions_args_t;
  74
  75 typedef struct
  76 {
  77   u32 limit;
  78 } nat_ipfix_logging_max_bibs_args_t;
  79
  80 typedef struct
  81 {
  82   u32 limit;
  83   u32 src;
  84 } nat_ipfix_logging_max_frags_ip4_args_t;
  85
  86 typedef struct
  87 {
  88   u32 limit;
  89   u64 src[2];
  90 } nat_ipfix_logging_max_frags_ip6_args_t;
  91
  92 typedef struct
  93 {
  94   u8 nat_event;
  95   u64 src_ip[2];
  96   u32 nat_src_ip;
  97   u8 proto;
  98   u16 src_port;
  99   u16 nat_src_port;
 100   u64 dst_ip[2];
 101   u32 nat_dst_ip;
 102   u32 vrf_id;
 103   u16 dst_port;
 104   u16 nat_dst_port;
 105 } nat_ipfix_logging_nat64_ses_args_t;
 106
 107 typedef struct
 108 {
 109   u8 nat_event;
 110   u64 src_ip[2];
 111   u32 nat_src_ip;
 112   u8 proto;
 113   u16 src_port;
 114   u16 nat_src_port;
 115   u32 vrf_id;
 116 } nat_ipfix_logging_nat64_bib_args_t;
 117
 118 #define skip_if_disabled()                                        \
 119 do {                                                              \
 120   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;     \
 121   if (PREDICT_TRUE (!clib_atomic_fetch_or(&silm->enabled, 0)))    \
 122     return;                                                       \
 123 } while (0)
 124
 125 #define update_template_id(old_id, new_id)                \
 126 do {                                                      \
 127   u16 template_id = clib_atomic_fetch_or(old_id, 0);      \
 128   clib_atomic_cmp_and_swap(old_id, template_id, new_id);  \
 129 } while (0)
 130
 131 /**
 132  * @brief Create an IPFIX template packet rewrite string
 133  *
 134  * @param frm               flow report main
 135  * @param fr                flow report
 136  * @param collector_address collector address
 137  * @param src_address       source address
 138  * @param collector_port    collector
 139  * @param event             NAT event ID
 140  * @param quota_event       NAT quota exceeded event ID
 141  *
 142  * @returns template packet
 143  */
 144 static inline u8 *
 145 nat_template_rewrite (flow_report_main_t * frm,
 146                        flow_report_t * fr,
 147                        ip4_address_t * collector_address,
 148                        ip4_address_t * src_address,
 149                        u16 collector_port,
 150                        nat_event_t event, quota_exceed_event_t quota_event)
 151 {
 152   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 153   ip4_header_t *ip;
 154   udp_header_t *udp;
 155   ipfix_message_header_t *h;
 156   ipfix_set_header_t *s;
 157   ipfix_template_header_t *t;
 158   ipfix_field_specifier_t *f;
 159   ipfix_field_specifier_t *first_field;
 160   u8 *rewrite = 0;
 161   ip4_ipfix_template_packet_t *tp;
 162   u32 field_count = 0;
 163   flow_report_stream_t *stream;
 164   u32 stream_index;
 165
 166   stream = &frm->streams[fr->stream_index];
 167
 168   stream_index = clib_atomic_fetch_or(&silm->stream_index, 0);
 169   clib_atomic_cmp_and_swap (&silm->stream_index,
 170                             stream_index, fr->stream_index);
 171
 172   if (event == NAT_ADDRESSES_EXHAUTED)
 173     {
 174       field_count = NAT_ADDRESSES_EXHAUTED_FIELD_COUNT;
 175
 176       update_template_id(&silm->addr_exhausted_template_id,
 177                          fr->template_id);
 178     }
 179   else if (event == NAT44_SESSION_CREATE)
 180     {
 181       field_count = NAT44_SESSION_CREATE_FIELD_COUNT;
 182
 183       update_template_id(&silm->nat44_session_template_id,
 184                          fr->template_id);
 185     }
 186   else if (event == NAT64_BIB_CREATE)
 187     {
 188       field_count = NAT64_BIB_FIELD_COUNT;
 189
 190       update_template_id(&silm->nat64_bib_template_id,
 191                          fr->template_id);
 192     }
 193   else if (event == NAT64_SESSION_CREATE)
 194     {
 195       field_count = NAT64_SES_FIELD_COUNT;
 196
 197       update_template_id(&silm->nat64_ses_template_id,
 198                          fr->template_id);
 199     }
 200   else if (event == QUOTA_EXCEEDED)
 201     {
 202       if (quota_event == MAX_ENTRIES_PER_USER)
 203         {
 204           field_count = MAX_ENTRIES_PER_USER_FIELD_COUNT;
 205
 206           update_template_id(&silm->max_entries_per_user_template_id,
 207                              fr->template_id);
 208
 209         }
 210       else if (quota_event == MAX_SESSION_ENTRIES)
 211         {
 212           field_count = MAX_SESSIONS_FIELD_COUNT;
 213
 214           update_template_id(&silm->max_sessions_template_id,
 215                              fr->template_id);
 216         }
 217       else if (quota_event == MAX_BIB_ENTRIES)
 218         {
 219           field_count = MAX_BIBS_FIELD_COUNT;
 220
 221           update_template_id(&silm->max_bibs_template_id,
 222                              fr->template_id);
 223         }
 224     }
 225
 226   /* allocate rewrite space */
 227   vec_validate_aligned (rewrite,
 228                         sizeof (ip4_ipfix_template_packet_t)
 229                         + field_count * sizeof (ipfix_field_specifier_t) - 1,
 230                         CLIB_CACHE_LINE_BYTES);
 231
 232   tp = (ip4_ipfix_template_packet_t *) rewrite;
 233   ip = (ip4_header_t *) & tp->ip4;
 234   udp = (udp_header_t *) (ip + 1);
 235   h = (ipfix_message_header_t *) (udp + 1);
 236   s = (ipfix_set_header_t *) (h + 1);
 237   t = (ipfix_template_header_t *) (s + 1);
 238   first_field = f = (ipfix_field_specifier_t *) (t + 1);
 239
 240   ip->ip_version_and_header_length = 0x45;
 241   ip->ttl = 254;
 242   ip->protocol = IP_PROTOCOL_UDP;
 243   ip->src_address.as_u32 = src_address->as_u32;
 244   ip->dst_address.as_u32 = collector_address->as_u32;
 245   udp->src_port = clib_host_to_net_u16 (stream->src_port);
 246   udp->dst_port = clib_host_to_net_u16 (collector_port);
 247   udp->length = clib_host_to_net_u16 (vec_len (rewrite) - sizeof (*ip));
 248
 249   /* FIXUP: message header export_time */
 250   h->domain_id = clib_host_to_net_u32 (stream->domain_id);
 251
 252   /* Add TLVs to the template */
 253   if (event == NAT_ADDRESSES_EXHAUTED)
 254     {
 255       f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
 256       f++;
 257       f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 258       f++;
 259       f->e_id_length = ipfix_e_id_length (0, natPoolId, 4);
 260       f++;
 261     }
 262   else if (event == NAT44_SESSION_CREATE)
 263     {
 264       f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
 265       f++;
 266       f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 267       f++;
 268       f->e_id_length = ipfix_e_id_length (0, sourceIPv4Address, 4);
 269       f++;
 270       f->e_id_length = ipfix_e_id_length (0, postNATSourceIPv4Address, 4);
 271       f++;
 272       f->e_id_length = ipfix_e_id_length (0, protocolIdentifier, 1);
 273       f++;
 274       f->e_id_length = ipfix_e_id_length (0, sourceTransportPort, 2);
 275       f++;
 276       f->e_id_length = ipfix_e_id_length (0, postNAPTSourceTransportPort, 2);
 277       f++;
 278       f->e_id_length = ipfix_e_id_length (0, ingressVRFID, 4);
 279       f++;
 280     }
 281   else if (event == NAT64_BIB_CREATE)
 282     {
 283       f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
 284       f++;
 285       f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 286       f++;
 287       f->e_id_length = ipfix_e_id_length (0, sourceIPv6Address, 16);
 288       f++;
 289       f->e_id_length = ipfix_e_id_length (0, postNATSourceIPv4Address, 4);
 290       f++;
 291       f->e_id_length = ipfix_e_id_length (0, protocolIdentifier, 1);
 292       f++;
 293       f->e_id_length = ipfix_e_id_length (0, sourceTransportPort, 2);
 294       f++;
 295       f->e_id_length = ipfix_e_id_length (0, postNAPTSourceTransportPort, 2);
 296       f++;
 297       f->e_id_length = ipfix_e_id_length (0, ingressVRFID, 4);
 298       f++;
 299     }
 300   else if (event == NAT64_SESSION_CREATE)
 301     {
 302       f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds, 8);
 303       f++;
 304       f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 305       f++;
 306       f->e_id_length = ipfix_e_id_length (0, sourceIPv6Address, 16);
 307       f++;
 308       f->e_id_length = ipfix_e_id_length (0, postNATSourceIPv4Address, 4);
 309       f++;
 310       f->e_id_length = ipfix_e_id_length (0, protocolIdentifier, 1);
 311       f++;
 312       f->e_id_length = ipfix_e_id_length (0, sourceTransportPort, 2);
 313       f++;
 314       f->e_id_length = ipfix_e_id_length (0, postNAPTSourceTransportPort, 2);
 315       f++;
 316       f->e_id_length = ipfix_e_id_length (0, destinationIPv6Address, 16);
 317       f++;
 318       f->e_id_length = ipfix_e_id_length (0, postNATDestinationIPv4Address, 4);
 319       f++;
 320       f->e_id_length = ipfix_e_id_length (0, destinationTransportPort, 2);
 321       f++;
 322       f->e_id_length = ipfix_e_id_length (0, postNAPTDestinationTransportPort,
 323                                           2);
 324       f++;
 325       f->e_id_length = ipfix_e_id_length (0, ingressVRFID, 4);
 326       f++;
 327     }
 328   else if (event == QUOTA_EXCEEDED)
 329     {
 330       if (quota_event == MAX_ENTRIES_PER_USER)
 331         {
 332           f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds,
 333                                               8);
 334           f++;
 335           f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 336           f++;
 337           f->e_id_length = ipfix_e_id_length (0, natQuotaExceededEvent, 4);
 338           f++;
 339           f->e_id_length = ipfix_e_id_length (0, maxEntriesPerUser, 4);
 340           f++;
 341           f->e_id_length = ipfix_e_id_length (0, sourceIPv4Address, 4);
 342           f++;
 343         }
 344       else if (quota_event == MAX_SESSION_ENTRIES)
 345         {
 346           f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds,
 347                                               8);
 348           f++;
 349           f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 350           f++;
 351           f->e_id_length = ipfix_e_id_length (0, natQuotaExceededEvent, 4);
 352           f++;
 353           f->e_id_length = ipfix_e_id_length (0, maxSessionEntries, 4);
 354           f++;
 355         }
 356       else if (quota_event == MAX_BIB_ENTRIES)
 357         {
 358           f->e_id_length = ipfix_e_id_length (0, observationTimeMilliseconds,
 359                                               8);
 360           f++;
 361           f->e_id_length = ipfix_e_id_length (0, natEvent, 1);
 362           f++;
 363           f->e_id_length = ipfix_e_id_length (0, natQuotaExceededEvent, 4);
 364           f++;
 365           f->e_id_length = ipfix_e_id_length (0, maxBIBEntries, 4);
 366           f++;
 367         }
 368     }
 369
 370   /* Back to the template packet... */
 371   ip = (ip4_header_t *) & tp->ip4;
 372   udp = (udp_header_t *) (ip + 1);
 373
 374   ASSERT (f - first_field);
 375   /* Field count in this template */
 376   t->id_count = ipfix_id_count (fr->template_id, f - first_field);
 377
 378   /* set length in octets */
 379   s->set_id_length =
 380     ipfix_set_id_length (2 /* set_id */ , (u8 *) f - (u8 *) s);
 381
 382   /* message length in octets */
 383   h->version_length = version_length ((u8 *) f - (u8 *) h);
 384
 385   ip->length = clib_host_to_net_u16 ((u8 *) f - (u8 *) ip);
 386   ip->checksum = ip4_header_checksum (ip);
 387
 388   return rewrite;
 389 }
 390
 391 u8 *
 392 nat_template_rewrite_addr_exhausted (flow_report_main_t * frm,
 393                                       flow_report_t * fr,
 394                                       ip4_address_t * collector_address,
 395                                       ip4_address_t * src_address,
 396                                       u16 collector_port,
 397                                       ipfix_report_element_t *elts,
 398                                       u32 n_elts, u32 *stream_index)
 399 {
 400   return nat_template_rewrite (frm, fr, collector_address, src_address,
 401                                 collector_port, NAT_ADDRESSES_EXHAUTED, 0);
 402 }
 403
 404 u8 *
 405 nat_template_rewrite_nat44_session (flow_report_main_t * frm,
 406                                      flow_report_t * fr,
 407                                      ip4_address_t * collector_address,
 408                                      ip4_address_t * src_address,
 409                                      u16 collector_port,
 410                                      ipfix_report_element_t *elts,
 411                                      u32 n_elts, u32 *stream_index)
 412 {
 413   return nat_template_rewrite (frm, fr, collector_address, src_address,
 414                                 collector_port, NAT44_SESSION_CREATE, 0);
 415 }
 416
 417 u8 *
 418 nat_template_rewrite_max_entries_per_usr (flow_report_main_t * frm,
 419                                            flow_report_t * fr,
 420                                            ip4_address_t * collector_address,
 421                                            ip4_address_t * src_address,
 422                                            u16 collector_port,
 423                                            ipfix_report_element_t *elts,
 424                                            u32 n_elts, u32 *stream_index)
 425 {
 426   return nat_template_rewrite (frm, fr, collector_address, src_address,
 427                                 collector_port, QUOTA_EXCEEDED,
 428                                 MAX_ENTRIES_PER_USER);
 429 }
 430
 431 u8 *
 432 nat_template_rewrite_max_sessions (flow_report_main_t * frm,
 433                                    flow_report_t * fr,
 434                                    ip4_address_t * collector_address,
 435                                    ip4_address_t * src_address,
 436                                    u16 collector_port,
 437                                    ipfix_report_element_t *elts,
 438                                    u32 n_elts, u32 *stream_index)
 439 {
 440   return nat_template_rewrite (frm, fr, collector_address, src_address,
 441                                 collector_port, QUOTA_EXCEEDED,
 442                                 MAX_SESSION_ENTRIES);
 443 }
 444
 445 u8 *
 446 nat_template_rewrite_max_bibs (flow_report_main_t * frm,
 447                                flow_report_t * fr,
 448                                ip4_address_t * collector_address,
 449                                ip4_address_t * src_address,
 450                                u16 collector_port,
 451                                ipfix_report_element_t *elts,
 452                                u32 n_elts, u32 *stream_index)
 453 {
 454   return nat_template_rewrite (frm, fr, collector_address, src_address,
 455                                 collector_port, QUOTA_EXCEEDED,
 456                                 MAX_BIB_ENTRIES);
 457 }
 458
 459 u8 *
 460 nat_template_rewrite_nat64_bib (flow_report_main_t * frm,
 461                                 flow_report_t * fr,
 462                                 ip4_address_t * collector_address,
 463                                 ip4_address_t * src_address,
 464                                 u16 collector_port,
 465                                 ipfix_report_element_t *elts,
 466                                 u32 n_elts, u32 *stream_index)
 467 {
 468   return nat_template_rewrite (frm, fr, collector_address, src_address,
 469                                 collector_port, NAT64_BIB_CREATE, 0);
 470 }
 471
 472 u8 *
 473 nat_template_rewrite_nat64_session (flow_report_main_t * frm,
 474                                     flow_report_t * fr,
 475                                     ip4_address_t * collector_address,
 476                                     ip4_address_t * src_address,
 477                                     u16 collector_port,
 478                                     ipfix_report_element_t *elts,
 479                                     u32 n_elts, u32 *stream_index)
 480 {
 481   return nat_template_rewrite (frm, fr, collector_address, src_address,
 482                                 collector_port, NAT64_SESSION_CREATE, 0);
 483 }
 484
 485 static inline void
 486 nat_ipfix_header_create (flow_report_main_t * frm,
 487                           vlib_buffer_t * b0, u32 * offset)
 488 {
 489   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 490   flow_report_stream_t *stream;
 491   ip4_ipfix_template_packet_t *tp;
 492   ipfix_message_header_t *h = 0;
 493   ipfix_set_header_t *s = 0;
 494   u32 sequence_number;
 495   u32 stream_index;
 496   ip4_header_t *ip;
 497   udp_header_t *udp;
 498   vlib_main_t *vm = vlib_get_main ();
 499
 500   stream_index = clib_atomic_fetch_or(&silm->stream_index, 0);
 501   stream = &frm->streams[stream_index];
 502
 503   b0->current_data = 0;
 504   b0->current_length = sizeof (*ip) + sizeof (*udp) + sizeof (*h) +
 505     sizeof (*s);
 506   b0->flags |= (VLIB_BUFFER_TOTAL_LENGTH_VALID | VNET_BUFFER_F_FLOW_REPORT);
 507   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
 508   vnet_buffer (b0)->sw_if_index[VLIB_TX] = frm->fib_index;
 509   tp = vlib_buffer_get_current (b0);
 510   ip = (ip4_header_t *) & tp->ip4;
 511   udp = (udp_header_t *) (ip + 1);
 512   h = (ipfix_message_header_t *) (udp + 1);
 513   s = (ipfix_set_header_t *) (h + 1);
 514
 515   ip->ip_version_and_header_length = 0x45;
 516   ip->ttl = 254;
 517   ip->protocol = IP_PROTOCOL_UDP;
 518   ip->flags_and_fragment_offset = 0;
 519   ip->src_address.as_u32 = frm->src_address.as_u32;
 520   ip->dst_address.as_u32 = frm->ipfix_collector.as_u32;
 521   udp->src_port = clib_host_to_net_u16 (stream->src_port);
 522   udp->dst_port = clib_host_to_net_u16 (frm->collector_port);
 523   udp->checksum = 0;
 524
 525   h->export_time = clib_host_to_net_u32 ((u32)
 526                                          (((f64) frm->unix_time_0) +
 527                                           (vlib_time_now (vm) -
 528                                            frm->vlib_time_0)));
 529
 530   sequence_number = clib_atomic_fetch_add (&stream->sequence_number, 1);
 531   h->sequence_number = clib_host_to_net_u32 (sequence_number);
 532   h->domain_id = clib_host_to_net_u32 (stream->domain_id);
 533
 534   *offset = (u32) (((u8 *) (s + 1)) - (u8 *) tp);
 535 }
 536
 537 static inline void
 538 nat_ipfix_send (u32 thread_index, flow_report_main_t * frm,
 539                  vlib_frame_t * f, vlib_buffer_t * b0, u16 template_id)
 540 {
 541   ip4_ipfix_template_packet_t *tp;
 542   ipfix_message_header_t *h = 0;
 543   ipfix_set_header_t *s = 0;
 544   ip4_header_t *ip;
 545   udp_header_t *udp;
 546   vlib_main_t *vm = vlib_mains[thread_index];
 547
 548   tp = vlib_buffer_get_current (b0);
 549   ip = (ip4_header_t *) & tp->ip4;
 550   udp = (udp_header_t *) (ip + 1);
 551   h = (ipfix_message_header_t *) (udp + 1);
 552   s = (ipfix_set_header_t *) (h + 1);
 553
 554   s->set_id_length = ipfix_set_id_length (template_id,
 555                                           b0->current_length -
 556                                           (sizeof (*ip) + sizeof (*udp) +
 557                                            sizeof (*h)));
 558   h->version_length = version_length (b0->current_length -
 559                                       (sizeof (*ip) + sizeof (*udp)));
 560
 561   ip->length = clib_host_to_net_u16 (b0->current_length);
 562   ip->checksum = ip4_header_checksum (ip);
 563   udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip));
 564
 565   if (frm->udp_checksum)
 566     {
 567       udp->checksum = ip4_tcp_udp_compute_checksum (vm, b0, ip);
 568       if (udp->checksum == 0)
 569         udp->checksum = 0xffff;
 570     }
 571
 572   ASSERT (ip4_header_checksum_is_valid (ip));
 573
 574   vlib_put_frame_to_node (vm, ip4_lookup_node.index, f);
 575 }
 576
 577 static void
 578 nat_ipfix_logging_nat44_ses (u32 thread_index, u8 nat_event, u32 src_ip,
 579                               u32 nat_src_ip, nat_protocol_t nat_proto,
 580                               u16 src_port, u16 nat_src_port, u32 vrf_id,
 581                               int do_flush)
 582 {
 583   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 584   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
 585   flow_report_main_t *frm = &flow_report_main;
 586   vlib_frame_t *f;
 587   vlib_buffer_t *b0 = 0;
 588   u32 bi0 = ~0;
 589   u32 offset;
 590   vlib_main_t *vm = vlib_mains[thread_index];
 591   u64 now;
 592   u8 proto;
 593   u16 template_id;
 594
 595   proto = nat_proto_to_ip_proto (nat_proto);
 596
 597   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
 598   now += silm->milisecond_time_0;
 599
 600   b0 = sitd->nat44_session_buffer;
 601
 602   if (PREDICT_FALSE (b0 == 0))
 603     {
 604       if (do_flush)
 605         return;
 606
 607       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
 608         {
 609           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
 610           return;
 611         }
 612
 613       b0 = sitd->nat44_session_buffer = vlib_get_buffer (vm, bi0);
 614       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 615       offset = 0;
 616     }
 617   else
 618     {
 619       bi0 = vlib_get_buffer_index (vm, b0);
 620       offset = sitd->nat44_session_next_record_offset;
 621     }
 622
 623   f = sitd->nat44_session_frame;
 624   if (PREDICT_FALSE (f == 0))
 625     {
 626       u32 *to_next;
 627       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
 628       sitd->nat44_session_frame = f;
 629       to_next = vlib_frame_vector_args (f);
 630       to_next[0] = bi0;
 631       f->n_vectors = 1;
 632     }
 633
 634   if (PREDICT_FALSE (offset == 0))
 635     nat_ipfix_header_create (frm, b0, &offset);
 636
 637   if (PREDICT_TRUE (do_flush == 0))
 638     {
 639       u64 time_stamp = clib_host_to_net_u64 (now);
 640       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
 641       offset += sizeof (time_stamp);
 642
 643       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
 644       offset += sizeof (nat_event);
 645
 646       clib_memcpy_fast (b0->data + offset, &src_ip, sizeof (src_ip));
 647       offset += sizeof (src_ip);
 648
 649       clib_memcpy_fast (b0->data + offset, &nat_src_ip, sizeof (nat_src_ip));
 650       offset += sizeof (nat_src_ip);
 651
 652       clib_memcpy_fast (b0->data + offset, &proto, sizeof (proto));
 653       offset += sizeof (proto);
 654
 655       clib_memcpy_fast (b0->data + offset, &src_port, sizeof (src_port));
 656       offset += sizeof (src_port);
 657
 658       clib_memcpy_fast (b0->data + offset, &nat_src_port, sizeof (nat_src_port));
 659       offset += sizeof (nat_src_port);
 660
 661       clib_memcpy_fast (b0->data + offset, &vrf_id, sizeof (vrf_id));
 662       offset += sizeof (vrf_id);
 663
 664       b0->current_length += NAT44_SESSION_CREATE_LEN;
 665     }
 666
 667   if (PREDICT_FALSE
 668       (do_flush || (offset + NAT44_SESSION_CREATE_LEN) > frm->path_mtu))
 669     {
 670       template_id = clib_atomic_fetch_or (
 671         &silm->nat44_session_template_id,
 672         0);
 673       nat_ipfix_send (thread_index, frm, f, b0, template_id);
 674       sitd->nat44_session_frame = 0;
 675       sitd->nat44_session_buffer = 0;
 676       offset = 0;
 677     }
 678   sitd->nat44_session_next_record_offset = offset;
 679 }
 680
 681 static void
 682 nat_ipfix_logging_addr_exhausted (u32 thread_index, u32 pool_id, int do_flush)
 683 {
 684   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 685   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
 686   flow_report_main_t *frm = &flow_report_main;
 687   vlib_frame_t *f;
 688   vlib_buffer_t *b0 = 0;
 689   u32 bi0 = ~0;
 690   u32 offset;
 691   vlib_main_t *vm = vlib_mains[thread_index];
 692   u64 now;
 693   u8 nat_event = NAT_ADDRESSES_EXHAUTED;
 694   u16 template_id;
 695
 696   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
 697   now += silm->milisecond_time_0;
 698
 699   b0 = sitd->addr_exhausted_buffer;
 700
 701   if (PREDICT_FALSE (b0 == 0))
 702     {
 703       if (do_flush)
 704         return;
 705
 706       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
 707         {
 708           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
 709           return;
 710         }
 711
 712       b0 = sitd->addr_exhausted_buffer = vlib_get_buffer (vm, bi0);
 713       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 714       offset = 0;
 715     }
 716   else
 717     {
 718       bi0 = vlib_get_buffer_index (vm, b0);
 719       offset = sitd->addr_exhausted_next_record_offset;
 720     }
 721
 722   f = sitd->addr_exhausted_frame;
 723   if (PREDICT_FALSE (f == 0))
 724     {
 725       u32 *to_next;
 726       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
 727       sitd->addr_exhausted_frame = f;
 728       to_next = vlib_frame_vector_args (f);
 729       to_next[0] = bi0;
 730       f->n_vectors = 1;
 731     }
 732
 733   if (PREDICT_FALSE (offset == 0))
 734     nat_ipfix_header_create (frm, b0, &offset);
 735
 736   if (PREDICT_TRUE (do_flush == 0))
 737     {
 738       u64 time_stamp = clib_host_to_net_u64 (now);
 739       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
 740       offset += sizeof (time_stamp);
 741
 742       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
 743       offset += sizeof (nat_event);
 744
 745       clib_memcpy_fast (b0->data + offset, &pool_id, sizeof (pool_id));
 746       offset += sizeof (pool_id);
 747
 748       b0->current_length += NAT_ADDRESSES_EXHAUTED_LEN;
 749     }
 750
 751   if (PREDICT_FALSE
 752       (do_flush || (offset + NAT_ADDRESSES_EXHAUTED_LEN) > frm->path_mtu))
 753     {
 754       template_id = clib_atomic_fetch_or (
 755           &silm->addr_exhausted_template_id,
 756           0);
 757       nat_ipfix_send (thread_index, frm, f, b0, template_id);
 758       sitd->addr_exhausted_frame = 0;
 759       sitd->addr_exhausted_buffer = 0;
 760       offset = 0;
 761     }
 762   sitd->addr_exhausted_next_record_offset = offset;
 763 }
 764
 765 static void
 766 nat_ipfix_logging_max_entries_per_usr (u32 thread_index,
 767                                         u32 limit, u32 src_ip, int do_flush)
 768 {
 769   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 770   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
 771   flow_report_main_t *frm = &flow_report_main;
 772   vlib_frame_t *f;
 773   vlib_buffer_t *b0 = 0;
 774   u32 bi0 = ~0;
 775   u32 offset;
 776   vlib_main_t *vm = vlib_mains[thread_index];
 777   u64 now;
 778   u8 nat_event = QUOTA_EXCEEDED;
 779   u32 quota_event = MAX_ENTRIES_PER_USER;
 780   u16 template_id;
 781
 782   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
 783   now += silm->milisecond_time_0;
 784
 785   b0 = sitd->max_entries_per_user_buffer;
 786
 787   if (PREDICT_FALSE (b0 == 0))
 788     {
 789       if (do_flush)
 790         return;
 791
 792       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
 793         {
 794           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
 795           return;
 796         }
 797
 798       b0 = sitd->max_entries_per_user_buffer = vlib_get_buffer (vm, bi0);
 799       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 800       offset = 0;
 801     }
 802   else
 803     {
 804       bi0 = vlib_get_buffer_index (vm, b0);
 805       offset = sitd->max_entries_per_user_next_record_offset;
 806     }
 807
 808   f = sitd->max_entries_per_user_frame;
 809   if (PREDICT_FALSE (f == 0))
 810     {
 811       u32 *to_next;
 812       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
 813       sitd->max_entries_per_user_frame = f;
 814       to_next = vlib_frame_vector_args (f);
 815       to_next[0] = bi0;
 816       f->n_vectors = 1;
 817     }
 818
 819   if (PREDICT_FALSE (offset == 0))
 820     nat_ipfix_header_create (frm, b0, &offset);
 821
 822   if (PREDICT_TRUE (do_flush == 0))
 823     {
 824       u64 time_stamp = clib_host_to_net_u64 (now);
 825       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
 826       offset += sizeof (time_stamp);
 827
 828       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
 829       offset += sizeof (nat_event);
 830
 831       clib_memcpy_fast (b0->data + offset, &quota_event, sizeof (quota_event));
 832       offset += sizeof (quota_event);
 833
 834       clib_memcpy_fast (b0->data + offset, &limit, sizeof (limit));
 835       offset += sizeof (limit);
 836
 837       clib_memcpy_fast (b0->data + offset, &src_ip, sizeof (src_ip));
 838       offset += sizeof (src_ip);
 839
 840       b0->current_length += MAX_ENTRIES_PER_USER_LEN;
 841     }
 842
 843   if (PREDICT_FALSE
 844       (do_flush || (offset + MAX_ENTRIES_PER_USER_LEN) > frm->path_mtu))
 845     {
 846       template_id = clib_atomic_fetch_or (
 847           &silm->max_entries_per_user_template_id,
 848           0);
 849       nat_ipfix_send (thread_index, frm, f, b0, template_id);
 850       sitd->max_entries_per_user_frame = 0;
 851       sitd->max_entries_per_user_buffer = 0;
 852       offset = 0;
 853     }
 854   sitd->max_entries_per_user_next_record_offset = offset;
 855 }
 856
 857 static void
 858 nat_ipfix_logging_max_ses (u32 thread_index, u32 limit, int do_flush)
 859 {
 860   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 861   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
 862   flow_report_main_t *frm = &flow_report_main;
 863   vlib_frame_t *f;
 864   vlib_buffer_t *b0 = 0;
 865   u32 bi0 = ~0;
 866   u32 offset;
 867   vlib_main_t *vm = vlib_mains[thread_index];
 868   u64 now;
 869   u8 nat_event = QUOTA_EXCEEDED;
 870   u32 quota_event = MAX_SESSION_ENTRIES;
 871   u16 template_id;
 872
 873   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
 874   now += silm->milisecond_time_0;
 875
 876   b0 = sitd->max_sessions_buffer;
 877
 878   if (PREDICT_FALSE (b0 == 0))
 879     {
 880       if (do_flush)
 881         return;
 882
 883       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
 884         {
 885           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
 886           return;
 887         }
 888
 889       b0 = sitd->max_sessions_buffer = vlib_get_buffer (vm, bi0);
 890       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 891       offset = 0;
 892     }
 893   else
 894     {
 895       bi0 = vlib_get_buffer_index (vm, b0);
 896       offset = sitd->max_sessions_next_record_offset;
 897     }
 898
 899   f = sitd->max_sessions_frame;
 900   if (PREDICT_FALSE (f == 0))
 901     {
 902       u32 *to_next;
 903       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
 904       sitd->max_sessions_frame = f;
 905       to_next = vlib_frame_vector_args (f);
 906       to_next[0] = bi0;
 907       f->n_vectors = 1;
 908     }
 909
 910   if (PREDICT_FALSE (offset == 0))
 911     nat_ipfix_header_create (frm, b0, &offset);
 912
 913   if (PREDICT_TRUE (do_flush == 0))
 914     {
 915       u64 time_stamp = clib_host_to_net_u64 (now);
 916       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
 917       offset += sizeof (time_stamp);
 918
 919       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
 920       offset += sizeof (nat_event);
 921
 922       clib_memcpy_fast (b0->data + offset, &quota_event, sizeof (quota_event));
 923       offset += sizeof (quota_event);
 924
 925       clib_memcpy_fast (b0->data + offset, &limit, sizeof (limit));
 926       offset += sizeof (limit);
 927
 928       b0->current_length += MAX_SESSIONS_LEN;
 929     }
 930
 931   if (PREDICT_FALSE
 932       (do_flush || (offset + MAX_SESSIONS_LEN) > frm->path_mtu))
 933     {
 934       template_id = clib_atomic_fetch_or (
 935         &silm->max_sessions_template_id,
 936         0);
 937       nat_ipfix_send (thread_index, frm, f, b0, template_id);
 938       sitd->max_sessions_frame = 0;
 939       sitd->max_sessions_buffer = 0;
 940       offset = 0;
 941     }
 942   sitd->max_sessions_next_record_offset = offset;
 943 }
 944
 945 static void
 946 nat_ipfix_logging_max_bib (u32 thread_index, u32 limit, int do_flush)
 947 {
 948   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
 949   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
 950   flow_report_main_t *frm = &flow_report_main;
 951   vlib_frame_t *f;
 952   vlib_buffer_t *b0 = 0;
 953   u32 bi0 = ~0;
 954   u32 offset;
 955   vlib_main_t *vm = vlib_mains[thread_index];
 956   u64 now;
 957   u8 nat_event = QUOTA_EXCEEDED;
 958   u32 quota_event = MAX_BIB_ENTRIES;
 959   u16 template_id;
 960
 961   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
 962   now += silm->milisecond_time_0;
 963
 964   b0 = sitd->max_bibs_buffer;
 965
 966   if (PREDICT_FALSE (b0 == 0))
 967     {
 968       if (do_flush)
 969         return;
 970
 971       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
 972         {
 973           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
 974           return;
 975         }
 976
 977       b0 = sitd->max_bibs_buffer = vlib_get_buffer (vm, bi0);
 978       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
 979       offset = 0;
 980     }
 981   else
 982     {
 983       bi0 = vlib_get_buffer_index (vm, b0);
 984       offset = sitd->max_bibs_next_record_offset;
 985     }
 986
 987   f = sitd->max_bibs_frame;
 988   if (PREDICT_FALSE (f == 0))
 989     {
 990       u32 *to_next;
 991       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
 992       sitd->max_bibs_frame = f;
 993       to_next = vlib_frame_vector_args (f);
 994       to_next[0] = bi0;
 995       f->n_vectors = 1;
 996     }
 997
 998   if (PREDICT_FALSE (offset == 0))
 999     nat_ipfix_header_create (frm, b0, &offset);
1000
1001   if (PREDICT_TRUE (do_flush == 0))
1002     {
1003       u64 time_stamp = clib_host_to_net_u64 (now);
1004       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
1005       offset += sizeof (time_stamp);
1006
1007       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
1008       offset += sizeof (nat_event);
1009
1010       clib_memcpy_fast (b0->data + offset, &quota_event, sizeof (quota_event));
1011       offset += sizeof (quota_event);
1012
1013       clib_memcpy_fast (b0->data + offset, &limit, sizeof (limit));
1014       offset += sizeof (limit);
1015
1016       b0->current_length += MAX_BIBS_LEN;
1017     }
1018
1019   if (PREDICT_FALSE
1020       (do_flush || (offset + MAX_BIBS_LEN) > frm->path_mtu))
1021     {
1022       template_id = clib_atomic_fetch_or (
1023         &silm->max_bibs_template_id,
1024         0);
1025       nat_ipfix_send (thread_index, frm, f, b0, template_id);
1026       sitd->max_bibs_frame = 0;
1027       sitd->max_bibs_buffer = 0;
1028       offset = 0;
1029     }
1030   sitd->max_bibs_next_record_offset = offset;
1031 }
1032
1033 static void
1034 nat_ipfix_logging_nat64_bibe (u32 thread_index, u8 nat_event,
1035                               ip6_address_t * src_ip, u32 nat_src_ip,
1036                               u8 proto, u16 src_port, u16 nat_src_port,
1037                               u32 vrf_id, int do_flush)
1038 {
1039   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
1040   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
1041   flow_report_main_t *frm = &flow_report_main;
1042   vlib_frame_t *f;
1043   vlib_buffer_t *b0 = 0;
1044   u32 bi0 = ~0;
1045   u32 offset;
1046   vlib_main_t *vm = vlib_mains[thread_index];
1047   u64 now;
1048   u16 template_id;
1049
1050   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
1051   now += silm->milisecond_time_0;
1052
1053   b0 = sitd->nat64_bib_buffer;
1054
1055   if (PREDICT_FALSE (b0 == 0))
1056     {
1057       if (do_flush)
1058         return;
1059
1060       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
1061         {
1062           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
1063           return;
1064         }
1065
1066       b0 = sitd->nat64_bib_buffer = vlib_get_buffer (vm, bi0);
1067       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
1068       offset = 0;
1069     }
1070   else
1071     {
1072       bi0 = vlib_get_buffer_index (vm, b0);
1073       offset = sitd->nat64_bib_next_record_offset;
1074     }
1075
1076   f = sitd->nat64_bib_frame;
1077   if (PREDICT_FALSE (f == 0))
1078     {
1079       u32 *to_next;
1080       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
1081       sitd->nat64_bib_frame = f;
1082       to_next = vlib_frame_vector_args (f);
1083       to_next[0] = bi0;
1084       f->n_vectors = 1;
1085     }
1086
1087   if (PREDICT_FALSE (offset == 0))
1088     nat_ipfix_header_create (frm, b0, &offset);
1089
1090   if (PREDICT_TRUE (do_flush == 0))
1091     {
1092       u64 time_stamp = clib_host_to_net_u64 (now);
1093       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
1094       offset += sizeof (time_stamp);
1095
1096       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
1097       offset += sizeof (nat_event);
1098
1099       clib_memcpy_fast (b0->data + offset, src_ip, sizeof (ip6_address_t));
1100       offset += sizeof (ip6_address_t);
1101
1102       clib_memcpy_fast (b0->data + offset, &nat_src_ip, sizeof (nat_src_ip));
1103       offset += sizeof (nat_src_ip);
1104
1105       clib_memcpy_fast (b0->data + offset, &proto, sizeof (proto));
1106       offset += sizeof (proto);
1107
1108       clib_memcpy_fast (b0->data + offset, &src_port, sizeof (src_port));
1109       offset += sizeof (src_port);
1110
1111       clib_memcpy_fast (b0->data + offset, &nat_src_port, sizeof (nat_src_port));
1112       offset += sizeof (nat_src_port);
1113
1114       clib_memcpy_fast (b0->data + offset, &vrf_id, sizeof (vrf_id));
1115       offset += sizeof (vrf_id);
1116
1117       b0->current_length += NAT64_BIB_LEN;
1118     }
1119
1120   if (PREDICT_FALSE
1121       (do_flush || (offset + NAT64_BIB_LEN) > frm->path_mtu))
1122     {
1123       template_id = clib_atomic_fetch_or (
1124         &silm->nat64_bib_template_id,
1125         0);
1126       nat_ipfix_send (thread_index, frm, f, b0, template_id);
1127       sitd->nat64_bib_frame = 0;
1128       sitd->nat64_bib_buffer = 0;
1129       offset = 0;
1130     }
1131   sitd->nat64_bib_next_record_offset = offset;
1132 }
1133
1134 static void
1135 nat_ipfix_logging_nat64_ses (u32 thread_index, u8 nat_event,
1136                              ip6_address_t * src_ip, u32 nat_src_ip,
1137                              u8 proto, u16 src_port, u16 nat_src_port,
1138                              ip6_address_t * dst_ip, u32 nat_dst_ip,
1139                              u16 dst_port, u16 nat_dst_port,
1140                              u32 vrf_id, int do_flush)
1141 {
1142   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
1143   nat_ipfix_per_thread_data_t *sitd = &silm->per_thread_data[thread_index];
1144   flow_report_main_t *frm = &flow_report_main;
1145   vlib_frame_t *f;
1146   vlib_buffer_t *b0 = 0;
1147   u32 bi0 = ~0;
1148   u32 offset;
1149   vlib_main_t *vm = vlib_mains[thread_index];
1150   u64 now;
1151   u16 template_id;
1152
1153   now = (u64) ((vlib_time_now (vm) - silm->vlib_time_0) * 1e3);
1154   now += silm->milisecond_time_0;
1155
1156   b0 = sitd->nat64_ses_buffer;
1157
1158   if (PREDICT_FALSE (b0 == 0))
1159     {
1160       if (do_flush)
1161         return;
1162
1163       if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
1164         {
1165           //nat_elog_err ("can't allocate buffer for NAT IPFIX event");
1166           return;
1167         }
1168
1169       b0 = sitd->nat64_ses_buffer = vlib_get_buffer (vm, bi0);
1170       VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
1171       offset = 0;
1172     }
1173   else
1174     {
1175       bi0 = vlib_get_buffer_index (vm, b0);
1176       offset = sitd->nat64_ses_next_record_offset;
1177     }
1178
1179   f = sitd->nat64_ses_frame;
1180   if (PREDICT_FALSE (f == 0))
1181     {
1182       u32 *to_next;
1183       f = vlib_get_frame_to_node (vm, ip4_lookup_node.index);
1184       sitd->nat64_ses_frame = f;
1185       to_next = vlib_frame_vector_args (f);
1186       to_next[0] = bi0;
1187       f->n_vectors = 1;
1188     }
1189
1190   if (PREDICT_FALSE (offset == 0))
1191     nat_ipfix_header_create (frm, b0, &offset);
1192
1193   if (PREDICT_TRUE (do_flush == 0))
1194     {
1195       u64 time_stamp = clib_host_to_net_u64 (now);
1196       clib_memcpy_fast (b0->data + offset, &time_stamp, sizeof (time_stamp));
1197       offset += sizeof (time_stamp);
1198
1199       clib_memcpy_fast (b0->data + offset, &nat_event, sizeof (nat_event));
1200       offset += sizeof (nat_event);
1201
1202       clib_memcpy_fast (b0->data + offset, src_ip, sizeof (ip6_address_t));
1203       offset += sizeof (ip6_address_t);
1204
1205       clib_memcpy_fast (b0->data + offset, &nat_src_ip, sizeof (nat_src_ip));
1206       offset += sizeof (nat_src_ip);
1207
1208       clib_memcpy_fast (b0->data + offset, &proto, sizeof (proto));
1209       offset += sizeof (proto);
1210
1211       clib_memcpy_fast (b0->data + offset, &src_port, sizeof (src_port));
1212       offset += sizeof (src_port);
1213
1214       clib_memcpy_fast (b0->data + offset, &nat_src_port, sizeof (nat_src_port));
1215       offset += sizeof (nat_src_port);
1216
1217       clib_memcpy_fast (b0->data + offset, dst_ip, sizeof (ip6_address_t));
1218       offset += sizeof (ip6_address_t);
1219
1220       clib_memcpy_fast (b0->data + offset, &nat_dst_ip, sizeof (nat_dst_ip));
1221       offset += sizeof (nat_dst_ip);
1222
1223       clib_memcpy_fast (b0->data + offset, &dst_port, sizeof (dst_port));
1224       offset += sizeof (dst_port);
1225
1226       clib_memcpy_fast (b0->data + offset, &nat_dst_port, sizeof (nat_dst_port));
1227       offset += sizeof (nat_dst_port);
1228
1229       clib_memcpy_fast (b0->data + offset, &vrf_id, sizeof (vrf_id));
1230       offset += sizeof (vrf_id);
1231
1232       b0->current_length += NAT64_SES_LEN;
1233     }
1234
1235   if (PREDICT_FALSE
1236       (do_flush || (offset + NAT64_SES_LEN) > frm->path_mtu))
1237     {
1238       template_id = clib_atomic_fetch_or (
1239         &silm->nat64_ses_template_id,
1240         0);
1241       nat_ipfix_send (thread_index, frm, f, b0, template_id);
1242       sitd->nat64_ses_frame = 0;
1243       sitd->nat64_ses_buffer = 0;
1244       offset = 0;
1245     }
1246   sitd->nat64_ses_next_record_offset = offset;
1247 }
1248
1249 void
1250 nat_ipfix_flush (u32 thread_index)
1251 {
1252   int do_flush = 1;
1253
1254   nat_ipfix_logging_nat44_ses (thread_index,
1255                                 0, 0, 0, 0, 0, 0, 0, do_flush);
1256   nat_ipfix_logging_addr_exhausted (thread_index, 0, do_flush);
1257   nat_ipfix_logging_max_entries_per_usr (thread_index, 0, 0, do_flush);
1258   nat_ipfix_logging_max_ses (thread_index, 0, do_flush);
1259   nat_ipfix_logging_max_bib (thread_index, 0, do_flush);
1260   nat_ipfix_logging_nat64_bibe (thread_index,
1261                                 0, 0, 0, 0, 0, 0, 0, do_flush);
1262   nat_ipfix_logging_nat64_ses (thread_index,
1263                                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, do_flush);
1264 }
1265
1266 void
1267 nat_ipfix_flush_from_main (void)
1268 {
1269   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
1270   vlib_main_t *worker_vm;
1271   int i;
1272
1273   if (PREDICT_TRUE (!clib_atomic_fetch_or(&silm->enabled, 0)))
1274     return;
1275
1276   if (PREDICT_FALSE (!silm->worker_vms))
1277     {
1278       for (i = 1; i < vec_len (vlib_mains); i++)
1279         {
1280           worker_vm = vlib_mains[i];
1281           if (worker_vm)
1282             vec_add1 (silm->worker_vms, worker_vm);
1283         }
1284     }
1285
1286   /* Trigger flush for each worker thread */
1287   for (i = 0; i < vec_len (silm->worker_vms); i++)
1288     {
1289       worker_vm = silm->worker_vms[i];
1290       if (worker_vm)
1291         vlib_node_set_interrupt_pending (worker_vm,
1292                                          nat_ipfix_flush_node.index);
1293     }
1294
1295   /* Finally flush main thread */
1296   nat_ipfix_flush (0);
1297 }
1298
1299 /**
1300  * @brief Generate NAT44 session create event
1301  *
1302  * @param thread_index thread index
1303  * @param src_ip       source IPv4 address
1304  * @param nat_src_ip   transaltes source IPv4 address
1305  * @param nat_proto   NAT transport protocol
1306  * @param src_port     source port
1307  * @param nat_src_port translated source port
1308  * @param vrf_id       VRF ID
1309  */
1310 void
1311 nat_ipfix_logging_nat44_ses_create (u32 thread_index,
1312                                      u32 src_ip,
1313                                      u32 nat_src_ip,
1314                                      nat_protocol_t nat_proto,
1315                                      u16 src_port,
1316                                      u16 nat_src_port, u32 vrf_id)
1317 {
1318   skip_if_disabled ();
1319
1320   nat_ipfix_logging_nat44_ses (thread_index, NAT44_SESSION_CREATE, src_ip,
1321                                 nat_src_ip, nat_proto, src_port, nat_src_port,
1322                                 vrf_id, 0);
1323 }
1324
1325 /**
1326  * @brief Generate NAT44 session delete event
1327  *
1328  * @param thread_index thread index
1329  * @param src_ip       source IPv4 address
1330  * @param nat_src_ip   transaltes source IPv4 address
1331  * @param nat_proto   NAT transport protocol
1332  * @param src_port     source port
1333  * @param nat_src_port translated source port
1334  * @param vrf_id       VRF ID
1335  */
1336 void
1337 nat_ipfix_logging_nat44_ses_delete (u32 thread_index,
1338                                      u32 src_ip,
1339                                      u32 nat_src_ip,
1340                                      nat_protocol_t nat_proto,
1341                                      u16 src_port,
1342                                      u16 nat_src_port, u32 vrf_id)
1343 {
1344   skip_if_disabled ();
1345
1346   nat_ipfix_logging_nat44_ses (thread_index, NAT44_SESSION_DELETE, src_ip,
1347                                 nat_src_ip, nat_proto, src_port, nat_src_port,
1348                                 vrf_id, 0);
1349 }
1350
1351 /**
1352  * @brief Generate NAT addresses exhausted event
1353  *
1354  * @param thread_index thread index
1355  * @param pool_id NAT pool ID
1356  */
1357 void
1358 nat_ipfix_logging_addresses_exhausted (u32 thread_index, u32 pool_id)
1359 {
1360   //TODO: This event SHOULD be rate limited
1361   skip_if_disabled ();
1362
1363   nat_ipfix_logging_addr_exhausted (thread_index, pool_id, 0);
1364 }
1365
1366 /**
1367  * @brief Generate maximum entries per user exceeded event
1368  *
1369  * @param thread_index thread index
1370  * @param limit maximum NAT entries that can be created per user
1371  * @param src_ip source IPv4 address
1372  */
1373 void
1374 nat_ipfix_logging_max_entries_per_user (u32 thread_index, u32 limit, u32 src_ip)
1375 {
1376   //TODO: This event SHOULD be rate limited
1377   skip_if_disabled ();
1378
1379   nat_ipfix_logging_max_entries_per_usr (thread_index, limit, src_ip, 0);
1380 }
1381
1382 vlib_frame_t *
1383 deterministic_nat_data_callback
1384 (flow_report_main_t * frm,
1385                                         flow_report_t * fr,
1386                                         vlib_frame_t * f,
1387                                         u32 * to_next, u32 node_index)
1388 {
1389   nat_ipfix_flush_from_main();
1390
1391   return f;
1392 }
1393
1394 /**
1395  * @brief Generate maximum session entries exceeded event
1396  *
1397  * @param thread_index thread index
1398  * @param limit configured limit
1399  */
1400 void
1401 nat_ipfix_logging_max_sessions (u32 thread_index, u32 limit)
1402 {
1403   //TODO: This event SHOULD be rate limited
1404   skip_if_disabled ();
1405
1406   nat_ipfix_logging_max_ses (thread_index, limit, 0);
1407 }
1408
1409 /**
1410  * @brief Generate maximum BIB entries exceeded event
1411  *
1412  * @param thread_index thread index
1413  * @param limit configured limit
1414  */
1415 void
1416 nat_ipfix_logging_max_bibs (u32 thread_index, u32 limit)
1417 {
1418   //TODO: This event SHOULD be rate limited
1419   skip_if_disabled ();
1420
1421   nat_ipfix_logging_max_bib (thread_index, limit, 0);
1422 }
1423
1424 /**
1425  * @brief Generate NAT64 BIB create and delete events
1426  *
1427  * @param thread_index thread index
1428  * @param src_ip       source IPv6 address
1429  * @param nat_src_ip   transaltes source IPv4 address
1430  * @param proto        L4 protocol
1431  * @param src_port     source port
1432  * @param nat_src_port translated source port
1433  * @param vrf_id       VRF ID
1434  * @param is_create    non-zero value if create event otherwise delete event
1435  */
1436 void
1437 nat_ipfix_logging_nat64_bib (u32 thread_index, ip6_address_t * src_ip,
1438                              ip4_address_t * nat_src_ip, u8 proto,
1439                              u16 src_port, u16 nat_src_port, u32 vrf_id,
1440                              u8 is_create)
1441 {
1442   u8 nat_event;
1443
1444   skip_if_disabled ();
1445
1446   nat_event = is_create ? NAT64_BIB_CREATE : NAT64_BIB_DELETE;
1447
1448   nat_ipfix_logging_nat64_bibe (thread_index, nat_event, src_ip,
1449                                 nat_src_ip->as_u32, proto, src_port,
1450                                 nat_src_port, vrf_id, 0);
1451 }
1452
1453 /**
1454  * @brief Generate NAT64 session create and delete events
1455  *
1456  * @param thread_index thread index
1457  * @param src_ip       source IPv6 address
1458  * @param nat_src_ip   transaltes source IPv4 address
1459  * @param proto        L4 protocol
1460  * @param src_port     source port
1461  * @param nat_src_port translated source port
1462  * @param dst_ip       destination IPv6 address
1463  * @param nat_dst_ip   destination IPv4 address
1464  * @param dst_port     destination port
1465  * @param nat_dst_port translated destination port
1466  * @param vrf_id       VRF ID
1467  * @param is_create    non-zero value if create event otherwise delete event
1468  */
1469 void
1470 nat_ipfix_logging_nat64_session (u32 thread_index,
1471                                  ip6_address_t * src_ip,
1472                                  ip4_address_t * nat_src_ip, u8 proto,
1473                                  u16 src_port, u16 nat_src_port,
1474                                  ip6_address_t * dst_ip,
1475                                  ip4_address_t * nat_dst_ip, u16 dst_port,
1476                                  u16 nat_dst_port, u32 vrf_id, u8 is_create)
1477 {
1478   u8 nat_event;
1479
1480   skip_if_disabled ();
1481
1482   nat_event = is_create ? NAT64_SESSION_CREATE : NAT64_SESSION_DELETE;
1483
1484   nat_ipfix_logging_nat64_ses (thread_index, nat_event, src_ip,
1485                                nat_src_ip->as_u32, proto, src_port,
1486                                nat_src_port, dst_ip, nat_dst_ip->as_u32,
1487                                dst_port, nat_dst_port, vrf_id, 0);
1488 }
1489
1490 vlib_frame_t *
1491 data_callback (flow_report_main_t * frm, flow_report_t * fr,
1492                vlib_frame_t * f, u32 * to_next, u32 node_index)
1493 {
1494   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
1495
1496   if (PREDICT_FALSE (++silm->call_counter >= vec_len (frm->reports)))
1497     {
1498       nat_ipfix_flush_from_main();
1499       silm->call_counter = 0;
1500     }
1501
1502   return f;
1503 }
1504
1505 /**
1506  * @brief Enable/disable NAT plugin IPFIX logging
1507  *
1508  * @param enable    1 if enable, 0 if disable
1509  * @param domain_id observation domain ID
1510  * @param src_port  source port number
1511  *
1512  * @returns 0 if success
1513  */
1514 int
1515 nat_ipfix_logging_enable_disable (int enable, u32 domain_id, u16 src_port)
1516 {
1517   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
1518   flow_report_main_t *frm = &flow_report_main;
1519   vnet_flow_report_add_del_args_t a;
1520   int rv;
1521   u8 e = enable ? 1 : 0;
1522
1523   if (clib_atomic_cmp_and_swap (&silm->enabled, e ^ 1, e) == e)
1524     return 0;
1525
1526   clib_memset (&a, 0, sizeof (a));
1527   a.is_add = enable;
1528   a.domain_id = domain_id ? domain_id : 1;
1529   a.src_port = src_port ? src_port : UDP_DST_PORT_ipfix;
1530   a.flow_data_callback = data_callback;
1531
1532   a.rewrite_callback = nat_template_rewrite_nat44_session;
1533   rv = vnet_flow_report_add_del (frm, &a, NULL);
1534   if (rv)
1535     {
1536       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1537       return -1;
1538     }
1539
1540   a.rewrite_callback = nat_template_rewrite_addr_exhausted;
1541   rv = vnet_flow_report_add_del (frm, &a, NULL);
1542   if (rv)
1543     {
1544       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1545       return -1;
1546     }
1547
1548   a.rewrite_callback = nat_template_rewrite_max_sessions;
1549   rv = vnet_flow_report_add_del (frm, &a, NULL);
1550   if (rv)
1551     {
1552       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1553       return -1;
1554     }
1555
1556   a.rewrite_callback = nat_template_rewrite_max_bibs;
1557   rv = vnet_flow_report_add_del (frm, &a, NULL);
1558   if (rv)
1559     {
1560       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1561       return -1;
1562     }
1563
1564   a.rewrite_callback = nat_template_rewrite_nat64_bib;
1565   rv = vnet_flow_report_add_del (frm, &a, NULL);
1566   if (rv)
1567     {
1568       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1569       return -1;
1570     }
1571
1572   a.rewrite_callback = nat_template_rewrite_nat64_session;
1573   rv = vnet_flow_report_add_del (frm, &a, NULL);
1574   if (rv)
1575     {
1576       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1577       return -1;
1578     }
1579
1580   // if endpoint dependent per user max entries is also required
1581   /*
1582   a.rewrite_callback = nat_template_rewrite_max_entries_per_usr;
1583   rv = vnet_flow_report_add_del (frm, &a, NULL);
1584   if (rv)
1585     {
1586       //nat_elog_warn_X1 ("vnet_flow_report_add_del returned %d", "i4", rv);
1587       return -1;
1588     }
1589   */
1590
1591   return 0;
1592 }
1593
1594 /**
1595  * @brief Initialize NAT plugin IPFIX logging
1596  *
1597  * @param vm vlib main
1598  */
1599 void
1600 nat_ipfix_logging_init (vlib_main_t * vm)
1601 {
1602   nat_ipfix_logging_main_t *silm = &nat_ipfix_logging_main;
1603   vlib_thread_main_t *tm = vlib_get_thread_main ();
1604
1605   silm->enabled = 0;
1606   silm->worker_vms = 0;
1607   silm->call_counter = 0;
1608
1609   /* Set up time reference pair */
1610   silm->vlib_time_0 = vlib_time_now (vm);
1611   silm->milisecond_time_0 = unix_time_now_nsec () * 1e-6;
1612
1613   vec_validate (silm->per_thread_data, tm->n_vlib_mains - 1);
1614 }
1615
1616 static uword
1617 ipfix_flush_process (vlib_main_t *vm,
1618                      vlib_node_runtime_t *rt,
1619                      vlib_frame_t *f)
1620 {
1621   nat_ipfix_flush(vm->thread_index);
1622   return 0;
1623 }
1624
1625 /* *INDENT-OFF* */
1626 VLIB_REGISTER_NODE (nat_ipfix_flush_node) = {
1627   .function = ipfix_flush_process,
1628   .name = "nat-ipfix-flush",
1629   .type = VLIB_NODE_TYPE_INPUT,
1630   .state = VLIB_NODE_STATE_INTERRUPT,
1631 };
1632 /* *INDENT-ON* */