vnet/vnet/flow/flow_report.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * flow_report.c
  17  */
  18 #include <vnet/flow/flow_report.h>
  19 #include <vnet/api_errno.h>
  20
  21 int send_template_packet (flow_report_main_t *frm,
  22                           flow_report_t *fr,
  23                           u32 * buffer_indexp)
  24 {
  25   u32 bi0;
  26   vlib_buffer_t * b0;
  27   ip4_ipfix_template_packet_t * tp;
  28   ipfix_message_header_t * h;
  29   ip4_header_t * ip;
  30   udp_header_t * udp;
  31   vlib_main_t * vm = frm->vlib_main;
  32
  33   ASSERT (buffer_indexp);
  34
  35   if (fr->update_rewrite || fr->rewrite == 0)
  36     {
  37       if (frm->ipfix_collector.as_u32 == 0
  38           || frm->src_address.as_u32 == 0)
  39         {
  40           clib_warning ("no collector: disabling flow collector process");
  41           vlib_node_set_state (frm->vlib_main, flow_report_process_node.index,
  42                                VLIB_NODE_STATE_DISABLED);
  43           return -1;
  44         }
  45       vec_free (fr->rewrite);
  46       fr->update_rewrite = 1;
  47     }
  48
  49   if (fr->update_rewrite)
  50     {
  51       fr->rewrite = fr->rewrite_callback (frm, fr,
  52                                           &frm->ipfix_collector,
  53                                           &frm->src_address);
  54       fr->update_rewrite = 0;
  55     }
  56
  57   if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
  58     return -1;
  59
  60   b0 = vlib_get_buffer (vm, bi0);
  61
  62   ASSERT (vec_len (fr->rewrite) < VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES);
  63
  64   clib_memcpy (b0->data, fr->rewrite, vec_len (fr->rewrite));
  65   b0->current_data = 0;
  66   b0->current_length = vec_len (fr->rewrite);
  67   b0->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
  68   vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
  69   /* $$$ for now, look up in fib-0. Later: arbitrary TX fib */
  70   vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
  71
  72   tp = vlib_buffer_get_current (b0);
  73   ip = (ip4_header_t *) &tp->ip4;
  74   udp = (udp_header_t *) (ip+1);
  75   h = (ipfix_message_header_t *)(udp+1);
  76
  77   /* FIXUP: message header export_time */
  78   h->export_time = (u32)
  79     (((f64)frm->unix_time_0) +
  80      (vlib_time_now(frm->vlib_main) - frm->vlib_time_0));
  81   h->export_time = clib_host_to_net_u32(h->export_time);
  82
  83   /* FIXUP: message header sequence_number. Templates do not increase it */
  84   h->sequence_number = clib_host_to_net_u32(fr->sequence_number);
  85
  86   /* FIXUP: udp length */
  87   udp->length = clib_host_to_net_u16 (b0->current_length - sizeof (*ip));
  88
  89   *buffer_indexp = bi0;
  90
  91   fr->last_template_sent = vlib_time_now (vm);
  92
  93   return 0;
  94 }
  95
  96 static uword
  97 flow_report_process (vlib_main_t * vm,
  98                      vlib_node_runtime_t * rt,
  99                      vlib_frame_t * f)
 100 {
 101   flow_report_main_t * frm = &flow_report_main;
 102   flow_report_t * fr;
 103   u32 ip4_lookup_node_index;
 104   vlib_node_t * ip4_lookup_node;
 105   vlib_frame_t * nf = 0;
 106   u32 template_bi;
 107   u32 * to_next;
 108   int send_template;
 109   f64 now;
 110   int rv;
 111   uword event_type;
 112   uword *event_data = 0;
 113
 114   /* Wait for Godot... */
 115   vlib_process_wait_for_event_or_clock (vm, 1e9);
 116   event_type = vlib_process_get_events (vm, &event_data);
 117   if (event_type != 1)
 118       clib_warning ("bogus kickoff event received, %d", event_type);
 119   vec_reset_length (event_data);
 120
 121   /* Enqueue pkts to ip4-lookup */
 122   ip4_lookup_node = vlib_get_node_by_name (vm, (u8 *) "ip4-lookup");
 123   ip4_lookup_node_index = ip4_lookup_node->index;
 124
 125   while (1)
 126     {
 127       vlib_process_suspend (vm, 5.0);
 128
 129       vec_foreach (fr, frm->reports)
 130         {
 131           now = vlib_time_now (vm);
 132
 133           /* Need to send a template packet? */
 134           send_template = now > (fr->last_template_sent + 20.0);
 135           send_template += fr->last_template_sent == 0;
 136           template_bi = ~0;
 137           rv = 0;
 138
 139           if (send_template)
 140             rv = send_template_packet (frm, fr, &template_bi);
 141
 142           if (rv < 0)
 143             continue;
 144
 145           nf = vlib_get_frame_to_node (vm, ip4_lookup_node_index);
 146           nf->n_vectors = 0;
 147           to_next = vlib_frame_vector_args (nf);
 148
 149           if (template_bi != ~0)
 150             {
 151               to_next[0] = template_bi;
 152               to_next++;
 153               nf->n_vectors++;
 154             }
 155
 156           nf = fr->flow_data_callback (frm, fr,
 157                                        nf, to_next, ip4_lookup_node_index);
 158           if (nf)
 159             vlib_put_frame_to_node (vm, ip4_lookup_node_index, nf);
 160         }
 161     }
 162
 163   return 0; /* not so much */
 164 }
 165
 166 VLIB_REGISTER_NODE (flow_report_process_node) = {
 167     .function = flow_report_process,
 168     .type = VLIB_NODE_TYPE_PROCESS,
 169     .name = "flow-report-process",
 170 };
 171
 172 int vnet_flow_report_add_del (flow_report_main_t *frm,
 173                               vnet_flow_report_add_del_args_t *a)
 174 {
 175   int i;
 176   int found_index = ~0;
 177   flow_report_t *fr;
 178
 179   for (i = 0; i < vec_len(frm->reports); i++)
 180     {
 181       fr = vec_elt_at_index (frm->reports, i);
 182       if (fr->opaque == a->opaque
 183           && fr->rewrite_callback == a->rewrite_callback
 184           && fr->flow_data_callback == a->flow_data_callback)
 185         {
 186           found_index = i;
 187           break;
 188         }
 189     }
 190
 191   if (a->is_add == 0)
 192     {
 193       if (found_index != ~0)
 194         {
 195           vec_delete (frm->reports, 1, found_index);
 196           return 0;
 197         }
 198       return VNET_API_ERROR_NO_SUCH_ENTRY;
 199     }
 200
 201   vec_add2 (frm->reports, fr, 1);
 202
 203   fr->sequence_number = 0;
 204   fr->domain_id = a->domain_id;
 205   fr->update_rewrite = 1;
 206   fr->opaque = a->opaque;
 207   fr->rewrite_callback = a->rewrite_callback;
 208   fr->flow_data_callback = a->flow_data_callback;
 209
 210   return 0;
 211 }
 212
 213 static clib_error_t *
 214 set_ipfix_command_fn (vlib_main_t * vm,
 215                  unformat_input_t * input,
 216                  vlib_cli_command_t * cmd)
 217 {
 218   flow_report_main_t * frm = &flow_report_main;
 219   ip4_address_t collector, src;
 220
 221   collector.as_u32 = 0;
 222   src.as_u32 = 0;
 223
 224   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
 225     if (unformat (input, "collector %U", unformat_ip4_address, &collector))
 226       ;
 227     else if (unformat (input, "src %U", unformat_ip4_address, &src))
 228       ;
 229     else
 230       break;
 231   }
 232
 233   if (collector.as_u32 == 0)
 234     return clib_error_return (0, "collector address required");
 235
 236   if (src.as_u32 == 0)
 237     return clib_error_return (0, "src address required");
 238
 239   frm->ipfix_collector.as_u32 = collector.as_u32;
 240   frm->src_address.as_u32 = src.as_u32;
 241
 242   vlib_cli_output (vm, "Collector %U, src address %U",
 243                    format_ip4_address, &frm->ipfix_collector,
 244                    format_ip4_address, &frm->src_address);
 245
 246   /* Turn on the flow reporting process */
 247   vlib_process_signal_event (vm, flow_report_process_node.index,
 248                              1, 0);
 249   return 0;
 250 }
 251
 252 VLIB_CLI_COMMAND (set_ipfix_command, static) = {
 253     .path = "set ipfix",
 254     .short_help = "set ipfix collector <ip4-address> src <ip4-address>",
 255     .function = set_ipfix_command_fn,
 256 };
 257
 258 static clib_error_t *
 259 flow_report_init (vlib_main_t *vm)
 260 {
 261   flow_report_main_t * frm = &flow_report_main;
 262
 263   frm->vlib_main = vm;
 264   frm->vnet_main = vnet_get_main();
 265   frm->unix_time_0 = time(0);
 266   frm->vlib_time_0 = vlib_time_now(frm->vlib_main);
 267
 268   return 0;
 269 }
 270
 271 VLIB_INIT_FUNCTION (flow_report_init)