src/vnet/session/session_rules_table.h - fdio/vpp - Gitiles

 /*
  * Copyright (c) 2017-2019 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef SRC_VNET_SESSION_SESSION_RULES_TABLE_H_
 #define SRC_VNET_SESSION_SESSION_RULES_TABLE_H_

 #include <vnet/vnet.h>
 #include <vnet/fib/fib.h>
 #include <vnet/session/session_types.h>
 #include <vnet/session/transport.h>
 #include <vnet/session/mma_16.h>
 #include <vnet/session/mma_40.h>
 #include <vnet/session/session_lookup.h>
 #include <vnet/session/session_table.h>

 #define SESSION_SRTG_HANDLE_INVALID ~0

 typedef CLIB_PACKED (struct
 {
   union
     {
       struct
         {
           ip4_address_t rmt_ip;
           ip4_address_t lcl_ip;
           u16 rmt_port;
           u16 lcl_port;
         };
       u64 as_u64[2];
     };
 }) session_mask_or_match_4_t;

 typedef CLIB_PACKED (struct
 {
   union
     {
       struct
         {
           ip6_address_t rmt_ip;
           ip6_address_t lcl_ip;
           u16 rmt_port;
           u16 lcl_port;
         };
       u64 as_u64[5];
     };
 }) session_mask_or_match_6_t;

 #define SESSION_RULE_TAG_MAX_LEN 64
 #define SESSION_RULES_TABLE_INVALID_INDEX MMA_TABLE_INVALID_INDEX
 #define SESSION_RULES_TABLE_ACTION_DROP (MMA_TABLE_INVALID_INDEX - 1)
 #define SESSION_RULES_TABLE_ACTION_ALLOW (MMA_TABLE_INVALID_INDEX - 2)

 typedef struct _rule_tag
 {
   u8 *tag;
 } session_rule_tag_t;

 typedef struct session_sdl_block
 {
   u32 ip_table_id;
   u32 ip6_table_id;
   u32 ip_fib_index;
   u32 ip6_fib_index;
 } session_sdl_block_t;

 typedef struct _session_rules_table_t
 {
   union
   {
     /**
      * Per fib proto session rules tables
      */
     struct
     {
       mma_rules_table_16_t session_rules_tables_16;
       mma_rules_table_40_t session_rules_tables_40;
     };
     /**
      * sdl table
      */
     struct session_sdl_block sdl_block;
   };
   /**
    * Hash table that maps tags to rules
    */
   uword *rules_by_tag;
   /**
    * Pool of rules tags
    */
   session_rule_tag_t *rule_tags;
   /**
    * Hash table that maps rule indices to tags
    */
   uword *tags_by_rules;
 } session_rules_table_t;

 typedef struct _session_rules_table_group_t
 {
   session_rules_table_t *session_rules;
 } session_rules_table_group_t;

 session_error_t
 session_rules_table_add_del_ (u32 srtg_handle, u32 proto,
 			      session_rule_table_add_del_args_t *args);
 u8 *session_rules_table_rule_tag (session_rules_table_t * srt, u32 ri,
 				  u8 is_ip4);
 void session_rules_table_init_ (struct _session_lookup_table *st,
 				u8 fib_proto);
 void session_rules_table_free_ (struct _session_lookup_table *st,
 				u8 fib_proto);

 typedef u32 (*rules_table_lookup4) (u32 srtg_handle, u32 proto,
 				    ip4_address_t *lcl_ip,
 				    ip4_address_t *rmt_ip, u16 lcl_port,
 				    u16 rmt_port);
 typedef u32 (*rules_table_lookup6) (u32 srtg_handle, u32 proto,
 				    ip6_address_t *lcl_ip,
 				    ip6_address_t *rmt_ip, u16 lcl_port,
 				    u16 rmt_port);
 typedef void (*rules_table_cli_dump) (vlib_main_t *vm, u32 srtg_handle,
 				      u32 proto, u8 fib_proto);
 typedef void (*rules_table_show_rule) (vlib_main_t *vm, u32 srtg_handle,
 				       u32 proto, ip46_address_t *lcl_ip,
 				       u16 lcl_port, ip46_address_t *rmt_ip,
 				       u16 rmt_port, u8 is_ip4);
 typedef session_error_t (*rules_table_add_del) (
   u32 srtg_handle, u32 proto, session_rule_table_add_del_args_t *args);
 typedef void (*rules_table_init) (struct _session_lookup_table *st,
 				  u8 fib_proto);
 typedef void (*rules_table_free) (struct _session_lookup_table *st,
 				  u8 fib_proto);

 #define foreach_session_rt_engine_vft_method_name                             \
   _ (lookup4)                                                                 \
   _ (lookup6)                                                                 \
   _ (cli_dump)                                                                \
   _ (show_rule)                                                               \
   _ (add_del)                                                                 \
   _ (init)                                                                    \
   _ (free)

 #define _(name) rules_table_##name table_##name;
 typedef struct session_rt_engine_vft
 {
   u32 backend_engine;
   foreach_session_rt_engine_vft_method_name
 } session_rt_engine_vft_t;
 #undef _

 extern u8 *format_session_rule_tag (u8 *s, va_list *args);
 extern u8 *session_rules_table_rule_tag (session_rules_table_t *srt, u32 ri,
 					 u8 is_ip4);
 extern u32 session_rules_table_rule_for_tag (session_rules_table_t *srt,
 					     u8 *tag);
 extern void session_rules_table_add_tag (session_rules_table_t *srt, u8 *tag,
 					 u32 rule_index, u8 is_ip4);
 extern void session_rules_table_del_tag (session_rules_table_t *srt, u8 *tag,
 					 u8 is_ip4);

 extern const session_rt_engine_vft_t *session_rt_engine_vft;
 extern clib_error_t *session_rules_table_enable_disable (int enable);
 extern clib_error_t *
 session_rt_backend_enable_disable (session_rt_engine_type_t rt_engine_type);

 static_always_inline void
 session_rules_table_init (struct _session_lookup_table *st, u8 fib_proto)
 {
   if (!session_rt_engine_vft)
     return;
   if (st->srtg_handle != SESSION_SRTG_HANDLE_INVALID)
     return;
   session_rt_engine_vft->table_init (st, fib_proto);
 }

 static_always_inline void
 session_rules_table_free (struct _session_lookup_table *st, u8 fib_proto)
 {
   if (!session_rt_engine_vft)
     return;
   if (st->srtg_handle == SESSION_SRTG_HANDLE_INVALID)
     return;
   session_rt_engine_vft->table_free (st, fib_proto);
 }

 static_always_inline void
 session_rules_table_show_rule (vlib_main_t *vm, u32 srtg_handle, u32 proto,
 			       ip46_address_t *lcl_ip, u16 lcl_port,
 			       ip46_address_t *rmt_ip, u16 rmt_port, u8 is_ip4)
 {
   if (!session_rt_engine_vft)
     return;
   if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
     return;
   session_rt_engine_vft->table_show_rule (vm, srtg_handle, proto, lcl_ip,
 					  lcl_port, rmt_ip, rmt_port, is_ip4);
 }

 static_always_inline u32
 session_rules_table_lookup6 (u32 srtg_handle, u32 proto, ip6_address_t *lcl_ip,
 			     ip6_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
 {
   if (!session_rt_engine_vft)
     return SESSION_RULES_TABLE_ACTION_ALLOW;
   if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
     return SESSION_RULES_TABLE_ACTION_ALLOW;
   return session_rt_engine_vft->table_lookup6 (srtg_handle, proto, lcl_ip,
 					       rmt_ip, lcl_port, rmt_port);
 }

 static_always_inline void
 session_rules_table_cli_dump (vlib_main_t *vm, u32 srtg_handle, u32 proto,
 			      u8 fib_proto)
 {
   if (!session_rt_engine_vft)
     return;
   if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
     return;
   session_rt_engine_vft->table_cli_dump (vm, srtg_handle, proto, fib_proto);
 }

 static_always_inline u32
 session_rules_table_lookup4 (u32 srtg_handle, u32 proto, ip4_address_t *lcl_ip,
 			     ip4_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
 {
   if (!session_rt_engine_vft)
     return SESSION_RULES_TABLE_ACTION_ALLOW;
   if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
     return SESSION_RULES_TABLE_ACTION_ALLOW;
   return session_rt_engine_vft->table_lookup4 (srtg_handle, proto, lcl_ip,
 					       rmt_ip, lcl_port, rmt_port);
 }

 static_always_inline session_error_t
 session_rules_table_add_del (u32 srtg_handle, u32 proto,
 			     session_rule_table_add_del_args_t *args)
 {
   if (!session_rt_engine_vft)
     return SESSION_E_NOSUPPORT;
   if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
     return SESSION_E_NOSUPPORT;
   return session_rt_engine_vft->table_add_del (srtg_handle, proto, args);
 }

 clib_error_t *
 session_rule_table_register_engine (const session_rt_engine_vft_t *vft);
 clib_error_t *
 session_rule_table_deregister_engine (const session_rt_engine_vft_t *vft);

 extern session_rules_table_t *srtg_handle_to_srt (u32 srtg_handle, u32 proto);
 extern session_rules_table_group_t *srtg_instance_alloc (session_table_t *st,
 							 u32 n_proto);
 extern void srtg_instance_free (session_table_t *st);

 #endif /* SRC_VNET_SESSION_SESSION_RULES_TABLE_H_ */
 /*
  * fd.io coding-style-patch-verification: ON
  *
  * Local Variables:
  * eval: (c-set-style "gnu")
  * End:
  */
	/*
	* Copyright (c) 2017-2019 Cisco and/or its affiliates.
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef SRC_VNET_SESSION_SESSION_RULES_TABLE_H_
	#define SRC_VNET_SESSION_SESSION_RULES_TABLE_H_

	#include <vnet/vnet.h>
	#include <vnet/fib/fib.h>
	#include <vnet/session/session_types.h>
	#include <vnet/session/transport.h>
	#include <vnet/session/mma_16.h>
	#include <vnet/session/mma_40.h>
	#include <vnet/session/session_lookup.h>
	#include <vnet/session/session_table.h>

	#define SESSION_SRTG_HANDLE_INVALID ~0

	typedef CLIB_PACKED (struct
	{
	union
	{
	struct
	{
	ip4_address_t rmt_ip;
	ip4_address_t lcl_ip;
	u16 rmt_port;
	u16 lcl_port;
	};
	u64 as_u64[2];
	};
	}) session_mask_or_match_4_t;

	typedef CLIB_PACKED (struct
	{
	union
	{
	struct
	{
	ip6_address_t rmt_ip;
	ip6_address_t lcl_ip;
	u16 rmt_port;
	u16 lcl_port;
	};
	u64 as_u64[5];
	};
	}) session_mask_or_match_6_t;

	#define SESSION_RULE_TAG_MAX_LEN 64
	#define SESSION_RULES_TABLE_INVALID_INDEX MMA_TABLE_INVALID_INDEX
	#define SESSION_RULES_TABLE_ACTION_DROP (MMA_TABLE_INVALID_INDEX - 1)
	#define SESSION_RULES_TABLE_ACTION_ALLOW (MMA_TABLE_INVALID_INDEX - 2)

	typedef struct _rule_tag
	{
	u8 *tag;
	} session_rule_tag_t;

	typedef struct session_sdl_block
	{
	u32 ip_table_id;
	u32 ip6_table_id;
	u32 ip_fib_index;
	u32 ip6_fib_index;
	} session_sdl_block_t;

	typedef struct _session_rules_table_t
	{
	union
	{
	/**
	* Per fib proto session rules tables
	*/
	struct
	{
	mma_rules_table_16_t session_rules_tables_16;
	mma_rules_table_40_t session_rules_tables_40;
	};
	/**
	* sdl table
	*/
	struct session_sdl_block sdl_block;
	};
	/**
	* Hash table that maps tags to rules
	*/
	uword *rules_by_tag;
	/**
	* Pool of rules tags
	*/
	session_rule_tag_t *rule_tags;
	/**
	* Hash table that maps rule indices to tags
	*/
	uword *tags_by_rules;
	} session_rules_table_t;

	typedef struct _session_rules_table_group_t
	{
	session_rules_table_t *session_rules;
	} session_rules_table_group_t;

	session_error_t
	session_rules_table_add_del_ (u32 srtg_handle, u32 proto,
	session_rule_table_add_del_args_t *args);
	u8 session_rules_table_rule_tag (session_rules_table_t srt, u32 ri,
	u8 is_ip4);
	void session_rules_table_init_ (struct _session_lookup_table *st,
	u8 fib_proto);
	void session_rules_table_free_ (struct _session_lookup_table *st,
	u8 fib_proto);

	typedef u32 (*rules_table_lookup4) (u32 srtg_handle, u32 proto,
	ip4_address_t *lcl_ip,
	ip4_address_t *rmt_ip, u16 lcl_port,
	u16 rmt_port);
	typedef u32 (*rules_table_lookup6) (u32 srtg_handle, u32 proto,
	ip6_address_t *lcl_ip,
	ip6_address_t *rmt_ip, u16 lcl_port,
	u16 rmt_port);
	typedef void (rules_table_cli_dump) (vlib_main_t vm, u32 srtg_handle,
	u32 proto, u8 fib_proto);
	typedef void (rules_table_show_rule) (vlib_main_t vm, u32 srtg_handle,
	u32 proto, ip46_address_t *lcl_ip,
	u16 lcl_port, ip46_address_t *rmt_ip,
	u16 rmt_port, u8 is_ip4);
	typedef session_error_t (*rules_table_add_del) (
	u32 srtg_handle, u32 proto, session_rule_table_add_del_args_t *args);
	typedef void (rules_table_init) (struct _session_lookup_table st,
	u8 fib_proto);
	typedef void (rules_table_free) (struct _session_lookup_table st,
	u8 fib_proto);

	#define foreach_session_rt_engine_vft_method_name \
	_ (lookup4) \
	_ (lookup6) \
	_ (cli_dump) \
	_ (show_rule) \
	_ (add_del) \
	_ (init) \
	_ (free)

	#define _(name) rules_table_##name table_##name;
	typedef struct session_rt_engine_vft
	{
	u32 backend_engine;
	foreach_session_rt_engine_vft_method_name
	} session_rt_engine_vft_t;
	#undef _

	extern u8 format_session_rule_tag (u8 s, va_list *args);
	extern u8 session_rules_table_rule_tag (session_rules_table_t srt, u32 ri,
	u8 is_ip4);
	extern u32 session_rules_table_rule_for_tag (session_rules_table_t *srt,
	u8 *tag);
	extern void session_rules_table_add_tag (session_rules_table_t srt, u8 tag,
	u32 rule_index, u8 is_ip4);
	extern void session_rules_table_del_tag (session_rules_table_t srt, u8 tag,
	u8 is_ip4);

	extern const session_rt_engine_vft_t *session_rt_engine_vft;
	extern clib_error_t *session_rules_table_enable_disable (int enable);
	extern clib_error_t *
	session_rt_backend_enable_disable (session_rt_engine_type_t rt_engine_type);

	static_always_inline void
	session_rules_table_init (struct _session_lookup_table *st, u8 fib_proto)
	{
	if (!session_rt_engine_vft)
	return;
	if (st->srtg_handle != SESSION_SRTG_HANDLE_INVALID)
	return;
	session_rt_engine_vft->table_init (st, fib_proto);
	}

	static_always_inline void
	session_rules_table_free (struct _session_lookup_table *st, u8 fib_proto)
	{
	if (!session_rt_engine_vft)
	return;
	if (st->srtg_handle == SESSION_SRTG_HANDLE_INVALID)
	return;
	session_rt_engine_vft->table_free (st, fib_proto);
	}

	static_always_inline void
	session_rules_table_show_rule (vlib_main_t *vm, u32 srtg_handle, u32 proto,
	ip46_address_t *lcl_ip, u16 lcl_port,
	ip46_address_t *rmt_ip, u16 rmt_port, u8 is_ip4)
	{
	if (!session_rt_engine_vft)
	return;
	if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
	return;
	session_rt_engine_vft->table_show_rule (vm, srtg_handle, proto, lcl_ip,
	lcl_port, rmt_ip, rmt_port, is_ip4);
	}

	static_always_inline u32
	session_rules_table_lookup6 (u32 srtg_handle, u32 proto, ip6_address_t *lcl_ip,
	ip6_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
	{
	if (!session_rt_engine_vft)
	return SESSION_RULES_TABLE_ACTION_ALLOW;
	if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
	return SESSION_RULES_TABLE_ACTION_ALLOW;
	return session_rt_engine_vft->table_lookup6 (srtg_handle, proto, lcl_ip,
	rmt_ip, lcl_port, rmt_port);
	}

	static_always_inline void
	session_rules_table_cli_dump (vlib_main_t *vm, u32 srtg_handle, u32 proto,
	u8 fib_proto)
	{
	if (!session_rt_engine_vft)
	return;
	if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
	return;
	session_rt_engine_vft->table_cli_dump (vm, srtg_handle, proto, fib_proto);
	}

	static_always_inline u32
	session_rules_table_lookup4 (u32 srtg_handle, u32 proto, ip4_address_t *lcl_ip,
	ip4_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
	{
	if (!session_rt_engine_vft)
	return SESSION_RULES_TABLE_ACTION_ALLOW;
	if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
	return SESSION_RULES_TABLE_ACTION_ALLOW;
	return session_rt_engine_vft->table_lookup4 (srtg_handle, proto, lcl_ip,
	rmt_ip, lcl_port, rmt_port);
	}

	static_always_inline session_error_t
	session_rules_table_add_del (u32 srtg_handle, u32 proto,
	session_rule_table_add_del_args_t *args)
	{
	if (!session_rt_engine_vft)
	return SESSION_E_NOSUPPORT;
	if (srtg_handle == SESSION_SRTG_HANDLE_INVALID)
	return SESSION_E_NOSUPPORT;
	return session_rt_engine_vft->table_add_del (srtg_handle, proto, args);
	}

	clib_error_t *
	session_rule_table_register_engine (const session_rt_engine_vft_t *vft);
	clib_error_t *
	session_rule_table_deregister_engine (const session_rt_engine_vft_t *vft);

	extern session_rules_table_t *srtg_handle_to_srt (u32 srtg_handle, u32 proto);
	extern session_rules_table_group_t srtg_instance_alloc (session_table_t st,
	u32 n_proto);
	extern void srtg_instance_free (session_table_t *st);

	#endif /* SRC_VNET_SESSION_SESSION_RULES_TABLE_H_ */
	/*
	* fd.io coding-style-patch-verification: ON
	*
	* Local Variables:
	* eval: (c-set-style "gnu")
	* End:
	*/