pfe/common/query_ipsec.c - vendor/mindspeed/drivers - Git at Google

 /*
  *  Copyright (c) 2009 Mindspeed Technologies, Inc.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License
  *  as published by the Free Software Foundation; either version 2
  *  of the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
 */

 #include "module_ipsec.h"
 #include "module_tunnel.h"
 #include "fe.h"


 /* This function returns total SA entries configured with a given handle */
 static int IPsec_Get_Hash_SAEntries(int sa_handle_index)
 {

 	int tot_sa_entries = 0;
 	PSAEntry  pSAEntry;
 	struct slist_entry *entry;

 	slist_for_each(pSAEntry, entry, &sa_cache_by_h[sa_handle_index], list_h)
 	{
 		tot_sa_entries++;
 	}


 	return tot_sa_entries;

 }

 /* This function fills the snapshot of SA entries in a given handle hash index */
 static int IPsec_SA_Get_Handle_Snapshot(int sa_handle_index, int sa_entries, PSAQueryCommand pSAHandleSnapshot)
 {

 	int tot_sa_entries=0;
 	PSAEntry pSAEntry;
 	struct slist_entry *entry;

 	slist_for_each(pSAEntry, entry, &sa_cache_by_h[sa_handle_index], list_h)
 	{

 	    pSAHandleSnapshot->src_ip[0] = pSAEntry->id.saddr[0];
 	    pSAHandleSnapshot->src_ip[1] = pSAEntry->id.saddr[1];
 	    pSAHandleSnapshot->src_ip[2] = pSAEntry->id.saddr[2];
 	    pSAHandleSnapshot->src_ip[3] = pSAEntry->id.saddr[3];
 	    pSAHandleSnapshot->dst_ip[0] = pSAEntry->id.daddr.a6[0];
 	    pSAHandleSnapshot->dst_ip[1] = pSAEntry->id.daddr.a6[1];
 	    pSAHandleSnapshot->dst_ip[2] = pSAEntry->id.daddr.a6[2];
 	    pSAHandleSnapshot->dst_ip[3] = pSAEntry->id.daddr.a6[3];
 	    pSAHandleSnapshot->spi       = pSAEntry->id.spi;
 	    pSAHandleSnapshot->sa_type 	 = pSAEntry->id.proto;
 	    pSAHandleSnapshot->family 	 = pSAEntry->family;
 	    pSAHandleSnapshot->handle 	 = pSAEntry->handle;
 	    pSAHandleSnapshot->mtu	 	 = pSAEntry->mtu;
 	    pSAHandleSnapshot->state 	 = pSAEntry->state;

 	    if (pSAEntry->elp_sa)
 	    {
 	    	pSAHandleSnapshot->flags = pSAEntry->elp_sa->flags;
 	    	if (pSAEntry->elp_sa->flags & ESPAH_ANTI_REPLAY_ENABLE)
 	       		pSAHandleSnapshot->replay_window = 0x1;
 	    	else
 	    		pSAHandleSnapshot->replay_window = 0x0;


 	    	pSAHandleSnapshot->key_alg   = pSAEntry->elp_sa->algo;
 	    	if (pSAEntry->elp_sa->algo & 0x7)
 	    	{


 #if defined(COMCERTO_1000) || defined(COMCERTO_2000)
 				*((U32*)&pSAHandleSnapshot->auth_key[0]) = htonl(*(U32*)&pSAEntry->elp_sa->auth_key0);
 				*((U32*)&pSAHandleSnapshot->auth_key[4]) = htonl(*(U32*)&pSAEntry->elp_sa->auth_key1);
 				*((U32*)&pSAHandleSnapshot->auth_key[8]) = htonl(*(U32*)&pSAEntry->elp_sa->auth_key2);
 				*((U32*)&pSAHandleSnapshot->auth_key[12]) = htonl(*(U32*)&pSAEntry->elp_sa->auth_key3);
 				*((U32*)&pSAHandleSnapshot->auth_key[16]) = htonl(*(U32*)&pSAEntry->elp_sa->auth_key4);

 				*((U32*)&pSAHandleSnapshot->ext_auth_key[0]) = htonl(*(U32*)&pSAEntry->elp_sa->ext_auth_key0);
 				*((U32*)&pSAHandleSnapshot->ext_auth_key[4]) = htonl(*(U32*)&pSAEntry->elp_sa->ext_auth_key1);
 				*((U32*)&pSAHandleSnapshot->ext_auth_key[8]) = htonl(*(U32*)&pSAEntry->elp_sa->ext_auth_key2);

 #else
 				int i;
 			   for (i =0; i < 5; i++)
 					*((U32*)&pSAHandleSnapshot->auth_key[i*4]) = htonl(*(U32*)&pSAEntry->elp_sa->auth_key[i*4]);

 				for (i =0; i < 3; i++)
 					*((U32*)&pSAHandleSnapshot->ext_auth_key[i*4]) = htonl(*(U32*)&pSAEntry->elp_sa->ext_auth_key[i*4]);

 #endif
 	    	}
 	    	if ((pSAEntry->elp_sa->algo >> 3) & 0x1F)
 	    	{
 #if defined(COMCERTO_1000) || defined(COMCERTO_2000)
 	    		*((U32*)&pSAHandleSnapshot->cipher_key[0]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher0);
 				*((U32*)&pSAHandleSnapshot->cipher_key[4]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher1);
 				*((U32*)&pSAHandleSnapshot->cipher_key[8]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher2);
 				*((U32*)&pSAHandleSnapshot->cipher_key[12]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher3);
 				*((U32*)&pSAHandleSnapshot->cipher_key[16]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher4);
 				*((U32*)&pSAHandleSnapshot->cipher_key[20]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher5);
 				*((U32*)&pSAHandleSnapshot->cipher_key[24]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher6);
 				*((U32*)&pSAHandleSnapshot->cipher_key[28]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher7);
 #else
 				int i;
 				for (i =0; i < 7; i++)
 					*((U32*)&pSAHandleSnapshot->cipher_key[i*4]) = htonl(*(U32*)&pSAEntry->elp_sa->cipher_key[i*4]);

 #endif
 	    	}


 	    }


 	    if (pSAEntry->mode == SA_MODE_TUNNEL)
 	    {
 	    	pSAHandleSnapshot->mode = SA_MODE_TUNNEL;
 	    	if (pSAEntry->header_len == IPV4_HDR_SIZE)
 	    	{
 			pSAHandleSnapshot->tunnel_proto_family = PROTO_FAMILY_IPV4;
 			pSAHandleSnapshot->tnl.ipv4.DestinationAddress = pSAEntry->tunnel.ip4.DestinationAddress;
 			pSAHandleSnapshot->tnl.ipv4.SourceAddress = pSAEntry->tunnel.ip4.SourceAddress;
 			pSAHandleSnapshot->tnl.ipv4.TypeOfService   = pSAEntry->tunnel.ip4.TypeOfService;
 			pSAHandleSnapshot->tnl.ipv4.Protocol = pSAEntry->tunnel.ip4.Protocol;
 			pSAHandleSnapshot->tnl.ipv4.TotalLength = pSAEntry->tunnel.ip4.TotalLength;
 	    	}
 	    	else
 	    	{
 			pSAHandleSnapshot->tunnel_proto_family = PROTO_FAMILY_IPV6;
 			pSAHandleSnapshot->tnl.ipv6.DestinationAddress[0] = pSAEntry->tunnel.ip6.DestinationAddress[0];
 			pSAHandleSnapshot->tnl.ipv6.DestinationAddress[1] = pSAEntry->tunnel.ip6.DestinationAddress[1];
 			pSAHandleSnapshot->tnl.ipv6.DestinationAddress[2] = pSAEntry->tunnel.ip6.DestinationAddress[2];
 			pSAHandleSnapshot->tnl.ipv6.DestinationAddress[3] = pSAEntry->tunnel.ip6.DestinationAddress[3];

 			pSAHandleSnapshot->tnl.ipv6.SourceAddress[0] = pSAEntry->tunnel.ip6.SourceAddress[0];
 			pSAHandleSnapshot->tnl.ipv6.SourceAddress[1] = pSAEntry->tunnel.ip6.SourceAddress[1];
 			pSAHandleSnapshot->tnl.ipv6.SourceAddress[2] = pSAEntry->tunnel.ip6.SourceAddress[2];
 			pSAHandleSnapshot->tnl.ipv6.SourceAddress[3] = pSAEntry->tunnel.ip6.SourceAddress[3];
 			IPV6_SET_TRAFFIC_CLASS(&pSAHandleSnapshot->tnl.ipv6, IPV6_GET_TRAFFIC_CLASS(&pSAEntry->tunnel.ip6));
 			IPV6_SET_VERSION(&pSAHandleSnapshot->tnl.ipv6, IPV6_GET_VERSION(&pSAEntry->tunnel.ip6));
 			IPV6_COPY_FLOW_LABEL(&pSAHandleSnapshot->tnl.ipv6, &pSAEntry->tunnel.ip6);
 	    	}
 	    }


 	    pSAHandleSnapshot->soft_byte_limit = pSAEntry->lft_conf.soft_byte_limit;
 	    pSAHandleSnapshot->hard_byte_limit = pSAEntry->lft_conf.hard_byte_limit;
 	    pSAHandleSnapshot->soft_packet_limit = pSAEntry->lft_conf.soft_packet_limit;
 	    pSAHandleSnapshot->hard_packet_limit = pSAEntry->lft_conf.hard_packet_limit;


 	    pSAHandleSnapshot++;
 	    tot_sa_entries++;
 	    if(--sa_entries <= 0)
 		break;
 	}


 	return tot_sa_entries;

 }


 /* This function creates the snapshot memory  for SAs and returns the
    next SA entry from the snapshot of the SA entries of a
    single handle to the caller  */

 int IPsec_Get_Next_SAEntry(PSAQueryCommand  pSAQueryCmd, int reset_action)
 {
 	int ipsec_sa_hash_entries;
 	PSAQueryCommand pSACmd;
 	static PSAQueryCommand pSASnapshot = NULL;
 	static int sa_hash_index = 0, sa_snapshot_entries =0, sa_snapshot_index=0 , sa_snapshot_buf_entries = 0;

 	if(reset_action)
 	{
 		sa_hash_index = 0;
 		sa_snapshot_entries =0;
 		sa_snapshot_index=0;
 		if(pSASnapshot)
 		{
 			Heap_Free(pSASnapshot);
 			pSASnapshot = NULL;
 		}
 		sa_snapshot_buf_entries = 0;
 	}

 	if (sa_snapshot_index == 0)
 	{
 		while( sa_hash_index < NUM_SA_ENTRIES)
 		{

 			ipsec_sa_hash_entries = IPsec_Get_Hash_SAEntries(sa_hash_index);
 			if(ipsec_sa_hash_entries == 0)
 			{
 				sa_hash_index++;
 				continue;
 			}

 	   		if(ipsec_sa_hash_entries > sa_snapshot_buf_entries)
 	   		{
 	   			if(pSASnapshot)
 	   				Heap_Free(pSASnapshot);

 				pSASnapshot = Heap_Alloc(ipsec_sa_hash_entries * sizeof(SAQueryCommand));

 				if (!pSASnapshot)
 				{
 			    	sa_hash_index = 0;
 			    	sa_snapshot_buf_entries = 0;
 					return ERR_NOT_ENOUGH_MEMORY;
 				}
 				sa_snapshot_buf_entries = ipsec_sa_hash_entries;
 	   		}
 			sa_snapshot_entries = IPsec_SA_Get_Handle_Snapshot(sa_hash_index , ipsec_sa_hash_entries,pSASnapshot);

 			break;
 		}

 		if (sa_hash_index >= NUM_SA_ENTRIES)
 		{
 			sa_hash_index = 0;
 			if (pSASnapshot)
 			{
 				Heap_Free(pSASnapshot);
 				pSASnapshot = NULL;
 			}
 			sa_snapshot_buf_entries = 0;
 			return ERR_SA_ENTRY_NOT_FOUND;
 		}

 	}


 	pSACmd = &pSASnapshot[sa_snapshot_index++];
 	SFL_memcpy(pSAQueryCmd, pSACmd, sizeof(SAQueryCommand));
 	if (sa_snapshot_index == sa_snapshot_entries)
 	{
 		sa_snapshot_index = 0;
 		sa_hash_index ++;
 	}


 	return NO_ERR;

 }


 #ifdef CFG_STATS

 /* This function fills the snapshot of SA entries
    in a given hash index, statReset = 1 resets the stats of SA. */

 static int stat_Get_SA_Hash_Snapshot(int sa_hash_index, int sa_entries,
                                      PStatIpsecEntryResponse pStatSASnapshot)
 {

 	int tot_sa_entries=0;
 	PSAEntry pSAEntry;
 	struct slist_entry *entry;
 	u32 last_bytes, last_bytes_up32;

 	slist_for_each(pSAEntry, entry, &sa_cache_by_h[sa_hash_index], list_h)
 	{
 		pStatSASnapshot->spi  		= ntohl(pSAEntry->id.spi);
 		pStatSASnapshot->proto		= pSAEntry->id.proto;
 		pStatSASnapshot->family		= pSAEntry->family;
 		pStatSASnapshot->dstIP[0] 	= pSAEntry->id.daddr.a6[0];
 		pStatSASnapshot->dstIP[1] 	= pSAEntry->id.daddr.a6[1];
 		pStatSASnapshot->dstIP[2] 	= pSAEntry->id.daddr.a6[2];
 		pStatSASnapshot->dstIP[3] 	= pSAEntry->id.daddr.a6[3];

 #if defined(COMCERTO_2000)
 		pStatSASnapshot->total_pkts_processed 		=
 		                    be32_to_cpu(pSAEntry->hw_sa->stats.last_pkts_processed);
 		last_bytes = pSAEntry->hw_sa->stats.last_bytes_processed & 0xffffffff;
 		last_bytes_up32=  (pSAEntry->hw_sa->stats.last_bytes_processed >> 32)& 0xffffffff;

 		pStatSASnapshot->total_bytes_processed[0] = be32_to_cpu(last_bytes_up32);
 		pStatSASnapshot->total_bytes_processed[1] = be32_to_cpu(last_bytes);
 #else
               pStatSASnapshot->total_pkts_processed           =
                                     pSAEntry->total_pkts_processed;
                 pStatSASnapshot->total_bytes_processed[0]       =
                                     pSAEntry->total_bytes_processed & 0xffffffff;

                 pStatSASnapshot->total_bytes_processed[1]       =
                                     (pSAEntry->total_bytes_processed >> 32) & 0xffffffff;

 #endif
 		pStatSASnapshot->eof = 0;

 #if !defined(COMCERTO_2000)
 		if(gStatIpsecQueryStatus & STAT_IPSEC_QUERY_RESET)
 		{
 			pSAEntry->total_pkts_processed =  pSAEntry->total_bytes_processed = 0;
 		}
 #endif

 		pStatSASnapshot->sagd = pSAEntry->handle;

 		pStatSASnapshot++;
 		tot_sa_entries++;

 		if(--sa_entries <= 0)
 			break;

 	}

 	printk (KERN_ERR "total_sa_entries:%x\n", tot_sa_entries);
 	return tot_sa_entries;

 }

 /* This function creates the snapshot memory and returns the
    next SA entry from the snapshop of the SA entries of a
    single hash to the caller (statReset = 1 resets the stats) */

 int stat_Get_Next_SAEntry(PStatIpsecEntryResponse pSACmd, int reset_action)
 {
 	int stat_sa_hash_entries;
 	PStatIpsecEntryResponse pSA;
 	static PStatIpsecEntryResponse pStatSASnapshot = NULL;
 	static int stat_sa_hash_index = 0, stat_sa_snapshot_entries =0, stat_sa_snapshot_index=0, stat_sa_snapshot_buf_entries = 0;

 	if(reset_action)
 	{
 		stat_sa_hash_index = 0;
 		stat_sa_snapshot_entries =0;
 		stat_sa_snapshot_index=0;
 		if(pStatSASnapshot)
 		{
 			Heap_Free(pStatSASnapshot);
 			pStatSASnapshot = NULL;
 		}
 		stat_sa_snapshot_buf_entries = 0;
 		return NO_ERR;
 	}

 	if (stat_sa_snapshot_index == 0)
 	{
 		while( stat_sa_hash_index < NUM_SA_ENTRIES)
 		{

 			stat_sa_hash_entries = IPsec_Get_Hash_SAEntries(stat_sa_hash_index);
 			if(stat_sa_hash_entries == 0)
 			{
 				stat_sa_hash_index++;
 				continue;
 			}

 		   	if (stat_sa_hash_entries > stat_sa_snapshot_buf_entries)
 		   	{
 		   		if(pStatSASnapshot)
 					Heap_Free(pStatSASnapshot);
 				pStatSASnapshot = Heap_Alloc(stat_sa_hash_entries * sizeof(StatIpsecEntryResponse));

 				if (!pStatSASnapshot)
 				{
 			    	stat_sa_hash_index = 0;
 			    	stat_sa_snapshot_buf_entries = 0;
 					return ERR_NOT_ENOUGH_MEMORY;
 				}
 				stat_sa_snapshot_buf_entries = 	stat_sa_hash_entries;
 		   	}
 			stat_sa_snapshot_entries = stat_Get_SA_Hash_Snapshot(stat_sa_hash_index , stat_sa_hash_entries, pStatSASnapshot);
 			break;
 		}

 		if (stat_sa_hash_index >= NUM_SA_ENTRIES)
 		{
 			stat_sa_hash_index = 0;
 			if(pStatSASnapshot)
 			{
 				Heap_Free(pStatSASnapshot);
 				pStatSASnapshot = NULL;
 			}
 			stat_sa_snapshot_buf_entries = 0;
 			return ERR_SA_ENTRY_NOT_FOUND;
 		}

 	}

 	pSA = &pStatSASnapshot[stat_sa_snapshot_index++];
 	SFL_memcpy(pSACmd, pSA, sizeof(StatIpsecEntryResponse));
 	if (stat_sa_snapshot_index == stat_sa_snapshot_entries)
 	{
 		stat_sa_snapshot_index = 0;
 		stat_sa_hash_index ++;
 	}


 	return NO_ERR;
 }

 #endif /* CFG_STATS */
	/*
	* Copyright (c) 2009 Mindspeed Technologies, Inc.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*
	*/

	#include "module_ipsec.h"
	#include "module_tunnel.h"
	#include "fe.h"


	/* This function returns total SA entries configured with a given handle */
	static int IPsec_Get_Hash_SAEntries(int sa_handle_index)
	{

	int tot_sa_entries = 0;
	PSAEntry pSAEntry;
	struct slist_entry *entry;

	slist_for_each(pSAEntry, entry, &sa_cache_by_h[sa_handle_index], list_h)
	{
	tot_sa_entries++;
	}


	return tot_sa_entries;

	}

	/* This function fills the snapshot of SA entries in a given handle hash index */
	static int IPsec_SA_Get_Handle_Snapshot(int sa_handle_index, int sa_entries, PSAQueryCommand pSAHandleSnapshot)
	{

	int tot_sa_entries=0;
	PSAEntry pSAEntry;
	struct slist_entry *entry;

	slist_for_each(pSAEntry, entry, &sa_cache_by_h[sa_handle_index], list_h)
	{

	pSAHandleSnapshot->src_ip[0] = pSAEntry->id.saddr[0];
	pSAHandleSnapshot->src_ip[1] = pSAEntry->id.saddr[1];
	pSAHandleSnapshot->src_ip[2] = pSAEntry->id.saddr[2];
	pSAHandleSnapshot->src_ip[3] = pSAEntry->id.saddr[3];
	pSAHandleSnapshot->dst_ip[0] = pSAEntry->id.daddr.a6[0];
	pSAHandleSnapshot->dst_ip[1] = pSAEntry->id.daddr.a6[1];
	pSAHandleSnapshot->dst_ip[2] = pSAEntry->id.daddr.a6[2];
	pSAHandleSnapshot->dst_ip[3] = pSAEntry->id.daddr.a6[3];
	pSAHandleSnapshot->spi = pSAEntry->id.spi;
	pSAHandleSnapshot->sa_type = pSAEntry->id.proto;
	pSAHandleSnapshot->family = pSAEntry->family;
	pSAHandleSnapshot->handle = pSAEntry->handle;
	pSAHandleSnapshot->mtu = pSAEntry->mtu;
	pSAHandleSnapshot->state = pSAEntry->state;

	if (pSAEntry->elp_sa)
	{
	pSAHandleSnapshot->flags = pSAEntry->elp_sa->flags;
	if (pSAEntry->elp_sa->flags & ESPAH_ANTI_REPLAY_ENABLE)
	pSAHandleSnapshot->replay_window = 0x1;
	else
	pSAHandleSnapshot->replay_window = 0x0;


	pSAHandleSnapshot->key_alg = pSAEntry->elp_sa->algo;
	if (pSAEntry->elp_sa->algo & 0x7)
	{


	#if defined(COMCERTO_1000) \|\| defined(COMCERTO_2000)
	((U32)&pSAHandleSnapshot->auth_key[0]) = htonl((U32)&pSAEntry->elp_sa->auth_key0);
	((U32)&pSAHandleSnapshot->auth_key[4]) = htonl((U32)&pSAEntry->elp_sa->auth_key1);
	((U32)&pSAHandleSnapshot->auth_key[8]) = htonl((U32)&pSAEntry->elp_sa->auth_key2);
	((U32)&pSAHandleSnapshot->auth_key[12]) = htonl((U32)&pSAEntry->elp_sa->auth_key3);
	((U32)&pSAHandleSnapshot->auth_key[16]) = htonl((U32)&pSAEntry->elp_sa->auth_key4);

	((U32)&pSAHandleSnapshot->ext_auth_key[0]) = htonl((U32)&pSAEntry->elp_sa->ext_auth_key0);
	((U32)&pSAHandleSnapshot->ext_auth_key[4]) = htonl((U32)&pSAEntry->elp_sa->ext_auth_key1);
	((U32)&pSAHandleSnapshot->ext_auth_key[8]) = htonl((U32)&pSAEntry->elp_sa->ext_auth_key2);

	#else
	int i;
	for (i =0; i < 5; i++)
	((U32)&pSAHandleSnapshot->auth_key[i4]) = htonl((U32)&pSAEntry->elp_sa->auth_key[i4]);

	for (i =0; i < 3; i++)
	((U32)&pSAHandleSnapshot->ext_auth_key[i4]) = htonl((U32)&pSAEntry->elp_sa->ext_auth_key[i4]);

	#endif
	}
	if ((pSAEntry->elp_sa->algo >> 3) & 0x1F)
	{
	#if defined(COMCERTO_1000) \|\| defined(COMCERTO_2000)
	((U32)&pSAHandleSnapshot->cipher_key[0]) = htonl((U32)&pSAEntry->elp_sa->cipher0);
	((U32)&pSAHandleSnapshot->cipher_key[4]) = htonl((U32)&pSAEntry->elp_sa->cipher1);
	((U32)&pSAHandleSnapshot->cipher_key[8]) = htonl((U32)&pSAEntry->elp_sa->cipher2);
	((U32)&pSAHandleSnapshot->cipher_key[12]) = htonl((U32)&pSAEntry->elp_sa->cipher3);
	((U32)&pSAHandleSnapshot->cipher_key[16]) = htonl((U32)&pSAEntry->elp_sa->cipher4);
	((U32)&pSAHandleSnapshot->cipher_key[20]) = htonl((U32)&pSAEntry->elp_sa->cipher5);
	((U32)&pSAHandleSnapshot->cipher_key[24]) = htonl((U32)&pSAEntry->elp_sa->cipher6);
	((U32)&pSAHandleSnapshot->cipher_key[28]) = htonl((U32)&pSAEntry->elp_sa->cipher7);
	#else
	int i;
	for (i =0; i < 7; i++)
	((U32)&pSAHandleSnapshot->cipher_key[i4]) = htonl((U32)&pSAEntry->elp_sa->cipher_key[i4]);

	#endif
	}


	}


	if (pSAEntry->mode == SA_MODE_TUNNEL)
	{
	pSAHandleSnapshot->mode = SA_MODE_TUNNEL;
	if (pSAEntry->header_len == IPV4_HDR_SIZE)
	{
	pSAHandleSnapshot->tunnel_proto_family = PROTO_FAMILY_IPV4;
	pSAHandleSnapshot->tnl.ipv4.DestinationAddress = pSAEntry->tunnel.ip4.DestinationAddress;
	pSAHandleSnapshot->tnl.ipv4.SourceAddress = pSAEntry->tunnel.ip4.SourceAddress;
	pSAHandleSnapshot->tnl.ipv4.TypeOfService = pSAEntry->tunnel.ip4.TypeOfService;
	pSAHandleSnapshot->tnl.ipv4.Protocol = pSAEntry->tunnel.ip4.Protocol;
	pSAHandleSnapshot->tnl.ipv4.TotalLength = pSAEntry->tunnel.ip4.TotalLength;
	}
	else
	{
	pSAHandleSnapshot->tunnel_proto_family = PROTO_FAMILY_IPV6;
	pSAHandleSnapshot->tnl.ipv6.DestinationAddress[0] = pSAEntry->tunnel.ip6.DestinationAddress[0];
	pSAHandleSnapshot->tnl.ipv6.DestinationAddress[1] = pSAEntry->tunnel.ip6.DestinationAddress[1];
	pSAHandleSnapshot->tnl.ipv6.DestinationAddress[2] = pSAEntry->tunnel.ip6.DestinationAddress[2];
	pSAHandleSnapshot->tnl.ipv6.DestinationAddress[3] = pSAEntry->tunnel.ip6.DestinationAddress[3];

	pSAHandleSnapshot->tnl.ipv6.SourceAddress[0] = pSAEntry->tunnel.ip6.SourceAddress[0];
	pSAHandleSnapshot->tnl.ipv6.SourceAddress[1] = pSAEntry->tunnel.ip6.SourceAddress[1];
	pSAHandleSnapshot->tnl.ipv6.SourceAddress[2] = pSAEntry->tunnel.ip6.SourceAddress[2];
	pSAHandleSnapshot->tnl.ipv6.SourceAddress[3] = pSAEntry->tunnel.ip6.SourceAddress[3];
	IPV6_SET_TRAFFIC_CLASS(&pSAHandleSnapshot->tnl.ipv6, IPV6_GET_TRAFFIC_CLASS(&pSAEntry->tunnel.ip6));
	IPV6_SET_VERSION(&pSAHandleSnapshot->tnl.ipv6, IPV6_GET_VERSION(&pSAEntry->tunnel.ip6));
	IPV6_COPY_FLOW_LABEL(&pSAHandleSnapshot->tnl.ipv6, &pSAEntry->tunnel.ip6);
	}
	}


	pSAHandleSnapshot->soft_byte_limit = pSAEntry->lft_conf.soft_byte_limit;
	pSAHandleSnapshot->hard_byte_limit = pSAEntry->lft_conf.hard_byte_limit;
	pSAHandleSnapshot->soft_packet_limit = pSAEntry->lft_conf.soft_packet_limit;
	pSAHandleSnapshot->hard_packet_limit = pSAEntry->lft_conf.hard_packet_limit;



	pSAHandleSnapshot++;
	tot_sa_entries++;
	if(--sa_entries <= 0)
	break;
	}


	return tot_sa_entries;

	}


	/* This function creates the snapshot memory for SAs and returns the
	next SA entry from the snapshot of the SA entries of a
	single handle to the caller */

	int IPsec_Get_Next_SAEntry(PSAQueryCommand pSAQueryCmd, int reset_action)
	{
	int ipsec_sa_hash_entries;
	PSAQueryCommand pSACmd;
	static PSAQueryCommand pSASnapshot = NULL;
	static int sa_hash_index = 0, sa_snapshot_entries =0, sa_snapshot_index=0 , sa_snapshot_buf_entries = 0;

	if(reset_action)
	{
	sa_hash_index = 0;
	sa_snapshot_entries =0;
	sa_snapshot_index=0;
	if(pSASnapshot)
	{
	Heap_Free(pSASnapshot);
	pSASnapshot = NULL;
	}
	sa_snapshot_buf_entries = 0;
	}

	if (sa_snapshot_index == 0)
	{
	while( sa_hash_index < NUM_SA_ENTRIES)
	{

	ipsec_sa_hash_entries = IPsec_Get_Hash_SAEntries(sa_hash_index);
	if(ipsec_sa_hash_entries == 0)
	{
	sa_hash_index++;
	continue;
	}

	if(ipsec_sa_hash_entries > sa_snapshot_buf_entries)
	{
	if(pSASnapshot)
	Heap_Free(pSASnapshot);

	pSASnapshot = Heap_Alloc(ipsec_sa_hash_entries * sizeof(SAQueryCommand));

	if (!pSASnapshot)
	{
	sa_hash_index = 0;
	sa_snapshot_buf_entries = 0;
	return ERR_NOT_ENOUGH_MEMORY;
	}
	sa_snapshot_buf_entries = ipsec_sa_hash_entries;
	}
	sa_snapshot_entries = IPsec_SA_Get_Handle_Snapshot(sa_hash_index , ipsec_sa_hash_entries,pSASnapshot);

	break;
	}

	if (sa_hash_index >= NUM_SA_ENTRIES)
	{
	sa_hash_index = 0;
	if (pSASnapshot)
	{
	Heap_Free(pSASnapshot);
	pSASnapshot = NULL;
	}
	sa_snapshot_buf_entries = 0;
	return ERR_SA_ENTRY_NOT_FOUND;
	}

	}


	pSACmd = &pSASnapshot[sa_snapshot_index++];
	SFL_memcpy(pSAQueryCmd, pSACmd, sizeof(SAQueryCommand));
	if (sa_snapshot_index == sa_snapshot_entries)
	{
	sa_snapshot_index = 0;
	sa_hash_index ++;
	}


	return NO_ERR;

	}




	#ifdef CFG_STATS

	/* This function fills the snapshot of SA entries
	in a given hash index, statReset = 1 resets the stats of SA. */

	static int stat_Get_SA_Hash_Snapshot(int sa_hash_index, int sa_entries,
	PStatIpsecEntryResponse pStatSASnapshot)
	{

	int tot_sa_entries=0;
	PSAEntry pSAEntry;
	struct slist_entry *entry;
	u32 last_bytes, last_bytes_up32;

	slist_for_each(pSAEntry, entry, &sa_cache_by_h[sa_hash_index], list_h)
	{
	pStatSASnapshot->spi = ntohl(pSAEntry->id.spi);
	pStatSASnapshot->proto = pSAEntry->id.proto;
	pStatSASnapshot->family = pSAEntry->family;
	pStatSASnapshot->dstIP[0] = pSAEntry->id.daddr.a6[0];
	pStatSASnapshot->dstIP[1] = pSAEntry->id.daddr.a6[1];
	pStatSASnapshot->dstIP[2] = pSAEntry->id.daddr.a6[2];
	pStatSASnapshot->dstIP[3] = pSAEntry->id.daddr.a6[3];

	#if defined(COMCERTO_2000)
	pStatSASnapshot->total_pkts_processed =
	be32_to_cpu(pSAEntry->hw_sa->stats.last_pkts_processed);
	last_bytes = pSAEntry->hw_sa->stats.last_bytes_processed & 0xffffffff;
	last_bytes_up32= (pSAEntry->hw_sa->stats.last_bytes_processed >> 32)& 0xffffffff;

	pStatSASnapshot->total_bytes_processed[0] = be32_to_cpu(last_bytes_up32);
	pStatSASnapshot->total_bytes_processed[1] = be32_to_cpu(last_bytes);
	#else
	pStatSASnapshot->total_pkts_processed =
	pSAEntry->total_pkts_processed;
	pStatSASnapshot->total_bytes_processed[0] =
	pSAEntry->total_bytes_processed & 0xffffffff;

	pStatSASnapshot->total_bytes_processed[1] =
	(pSAEntry->total_bytes_processed >> 32) & 0xffffffff;

	#endif
	pStatSASnapshot->eof = 0;

	#if !defined(COMCERTO_2000)
	if(gStatIpsecQueryStatus & STAT_IPSEC_QUERY_RESET)
	{
	pSAEntry->total_pkts_processed = pSAEntry->total_bytes_processed = 0;
	}
	#endif

	pStatSASnapshot->sagd = pSAEntry->handle;

	pStatSASnapshot++;
	tot_sa_entries++;

	if(--sa_entries <= 0)
	break;

	}

	printk (KERN_ERR "total_sa_entries:%x\n", tot_sa_entries);
	return tot_sa_entries;

	}

	/* This function creates the snapshot memory and returns the
	next SA entry from the snapshop of the SA entries of a
	single hash to the caller (statReset = 1 resets the stats) */

	int stat_Get_Next_SAEntry(PStatIpsecEntryResponse pSACmd, int reset_action)
	{
	int stat_sa_hash_entries;
	PStatIpsecEntryResponse pSA;
	static PStatIpsecEntryResponse pStatSASnapshot = NULL;
	static int stat_sa_hash_index = 0, stat_sa_snapshot_entries =0, stat_sa_snapshot_index=0, stat_sa_snapshot_buf_entries = 0;

	if(reset_action)
	{
	stat_sa_hash_index = 0;
	stat_sa_snapshot_entries =0;
	stat_sa_snapshot_index=0;
	if(pStatSASnapshot)
	{
	Heap_Free(pStatSASnapshot);
	pStatSASnapshot = NULL;
	}
	stat_sa_snapshot_buf_entries = 0;
	return NO_ERR;
	}

	if (stat_sa_snapshot_index == 0)
	{
	while( stat_sa_hash_index < NUM_SA_ENTRIES)
	{

	stat_sa_hash_entries = IPsec_Get_Hash_SAEntries(stat_sa_hash_index);
	if(stat_sa_hash_entries == 0)
	{
	stat_sa_hash_index++;
	continue;
	}

	if (stat_sa_hash_entries > stat_sa_snapshot_buf_entries)
	{
	if(pStatSASnapshot)
	Heap_Free(pStatSASnapshot);
	pStatSASnapshot = Heap_Alloc(stat_sa_hash_entries * sizeof(StatIpsecEntryResponse));

	if (!pStatSASnapshot)
	{
	stat_sa_hash_index = 0;
	stat_sa_snapshot_buf_entries = 0;
	return ERR_NOT_ENOUGH_MEMORY;
	}
	stat_sa_snapshot_buf_entries = stat_sa_hash_entries;
	}
	stat_sa_snapshot_entries = stat_Get_SA_Hash_Snapshot(stat_sa_hash_index , stat_sa_hash_entries, pStatSASnapshot);
	break;
	}

	if (stat_sa_hash_index >= NUM_SA_ENTRIES)
	{
	stat_sa_hash_index = 0;
	if(pStatSASnapshot)
	{
	Heap_Free(pStatSASnapshot);
	pStatSASnapshot = NULL;
	}
	stat_sa_snapshot_buf_entries = 0;
	return ERR_SA_ENTRY_NOT_FOUND;
	}

	}

	pSA = &pStatSASnapshot[stat_sa_snapshot_index++];
	SFL_memcpy(pSACmd, pSA, sizeof(StatIpsecEntryResponse));
	if (stat_sa_snapshot_index == stat_sa_snapshot_entries)
	{
	stat_sa_snapshot_index = 0;
	stat_sa_hash_index ++;
	}


	return NO_ERR;
	}

	#endif /* CFG_STATS */