Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016-2019 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             : #ifndef __UDP_ENCAP_H__
      17             : #define __UDP_ENCAP_H__
      18             : 
      19             : #include <vnet/ip/ip.h>
      20             : #include <vnet/udp/udp_packet.h>
      21             : #include <vnet/fib/fib_node.h>
      22             : 
      23             : /**
      24             :  * UDP encapsulation.
      25             :  * A representation of the encapsulation of packets in UDP-over-IP.
      26             :  * This is encapsulation only, there is no tunnel interface, hence
      27             :  * it is uni-directional. For decap register a handler with the UDP port
      28             :  * dispatcher.
      29             :  */
      30             : 
      31             : /**
      32             :  * Fixup behaviour. Actions performed on the encap in the data-plane
      33             :  */
      34             : typedef enum udp_encap_fixup_flags_t_
      35             : {
      36             :   UDP_ENCAP_FIXUP_NONE = 0,
      37             :   /**
      38             :    * UDP source port contains an entropy/hash value for load-balancing by downstream peers.
      39             :    */
      40             :   UDP_ENCAP_FIXUP_UDP_SRC_PORT_ENTROPY = (1 << 0),
      41             : } udp_encap_fixup_flags_t;
      42             : 
      43             : /**
      44             :  * The UDP encap representation
      45             :  */
      46             : typedef struct udp_encap_t_
      47             : {
      48             :   /**
      49             :    * The first cacheline contains the data used in the data-plane
      50             :    */
      51             :   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
      52             : 
      53             :   /**
      54             :    * The headers to paint, in packet painting order
      55             :    */
      56             :   union
      57             :   {
      58             :     struct
      59             :     {
      60             :       ip4_header_t ue_ip4;
      61             :       udp_header_t ue_udp;
      62             :     } __attribute__ ((packed)) ip4;
      63             :     struct
      64             :     {
      65             :       ip6_header_t ue_ip6;
      66             :       udp_header_t ue_udp;
      67             :     } __attribute__ ((packed)) ip6;
      68             :   } __attribute__ ((packed)) ue_hdrs;
      69             : 
      70             :   /**
      71             :    * The DPO used to forward to the next node in the VLIB graph
      72             :    */
      73             :   dpo_id_t ue_dpo;
      74             : 
      75             :   /**
      76             :    * Flags controlling fixup behaviour
      77             :    */
      78             :   udp_encap_fixup_flags_t ue_flags;
      79             : 
      80             :   /**
      81             :    * the protocol of the IP header imposed
      82             :    */
      83             :   fib_protocol_t ue_ip_proto;
      84             : 
      85             :   /**
      86             :    * The second cacheline contains control-plane data
      87             :    */
      88             :   CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
      89             : 
      90             :   /**
      91             :    * linkage into the FIB graph
      92             :    */
      93             :   fib_node_t ue_fib_node;
      94             : 
      95             :   /**
      96             :    * Tracking information for the IP destination
      97             :    */
      98             :   fib_node_index_t ue_fib_entry_index;
      99             :   u32 ue_fib_sibling;
     100             : 
     101             :   /**
     102             :    * The FIB index in which the encap destination resides
     103             :    */
     104             :   index_t ue_fib_index;
     105             : } udp_encap_t;
     106             : 
     107             : extern index_t udp_encap_add_and_lock (fib_protocol_t proto,
     108             :                                        index_t fib_index,
     109             :                                        const ip46_address_t * src_ip,
     110             :                                        const ip46_address_t * dst_ip,
     111             :                                        u16 src_port,
     112             :                                        u16 dst_port,
     113             :                                        udp_encap_fixup_flags_t flags);
     114             : 
     115             : extern void udp_encap_lock (index_t uei);
     116             : extern void udp_encap_unlock (index_t uei);
     117             : extern u8 *format_udp_encap (u8 * s, va_list * args);
     118             : extern u8 *format_udp_encap_fixup_flags (u8 *s, va_list *args);
     119             : extern void udp_encap_contribute_forwarding (index_t uei,
     120             :                                              dpo_proto_t proto,
     121             :                                              dpo_id_t * dpo);
     122             : 
     123             : extern void udp_encap_get_stats (index_t uei, u64 * packets, u64 * bytes);
     124             : 
     125             : /**
     126             :  * Callback function invoked when walking all encap objects.
     127             :  * Return non-zero to continue the walk.
     128             :  */
     129             : typedef walk_rc_t (*udp_encap_walk_cb_t) (index_t uei, void *ctx);
     130             : 
     131             : /**
     132             :  * Walk each of the encap objects
     133             :  */
     134             : extern void udp_encap_walk (udp_encap_walk_cb_t cb, void *ctx);
     135             : 
     136             : /**
     137             :  * Pool of encaps
     138             :  */
     139             : extern udp_encap_t *udp_encap_pool;
     140             : 
     141             : static inline udp_encap_t *
     142         756 : udp_encap_get (index_t uei)
     143             : {
     144         756 :   return (pool_elt_at_index (udp_encap_pool, uei));
     145             : }
     146             : 
     147             : /*
     148             :  * fd.io coding-style-patch-verification: ON
     149             :  *
     150             :  * Local Variables:
     151             :  * eval: (c-set-style "gnu")
     152             :  * End:
     153             :  */
     154             : 
     155             : #endif