nat_api.c

vxworks NAT 实现部分源代码。有兴趣可以参考下

				nat.global_address_mask = inMask;
			}
		}
		else
		{
			if(!Work_Mode)
			{
				nat.port[if_number].ifunit=NULL;
				nat.port[if_number].enabled=FALSE;
			}
		}
	}
	nat_add_local_interfaces_to_passthru_list();
	return(OK);
}

/******************************************************************************
* 
* natStaticXlatEnable - enable or disable static translations 
* 
* Use this routine to enable or disable static translations. 
*
* RETURNS
* 
* OK (success) always. 
*
*/

STATUS natStaticXlatEnable
    (
     BOOL enable /* TRUE to enable static translations, FALSE to disable. */
     )
{
	nat.static_entries_enabled = enable;

	return(OK);
}
/******************************************************************************
* 
* natTcpXlatDelete - clear  tcp nat active translations with s_ip d_ip s_port d_port
* 
* Use this routine to enable or disable static translations. 
*
* RETURNS
* 
* OK (success) always. 
*
*/
/* TCP Translation Entry Delete Routine (NAPT mode only) */
STATUS 	natTcpXlatDelete(NAT_CURRENCY_TRANSLATION_ENTRY *sptr_translation_entry)
{
	unsigned short status;
	NAT_BIND_INFO* bind_info;

	if(natFreeBind ((u_long)&nat, 0, sptr_translation_entry->bind_id)!=NAT_OK)
	{
		bind_info=(NAT_BIND_INFO*)sptr_translation_entry->bind_id;
		if(bind_info)
		{
			free(bind_info);
			bind_info=NULL;
		}
	}

	semTake(natentrylock, WAIT_FOREVER);
	status=natDelete_entrys(sptr_translation_entry);
	
	semGive(natentrylock);
	return (status);
}
/******************************************************************************
* 
* natUdpXlatDelete - clear  udp nat active translations with s_ip d_ip s_port d_port
* 
* Use this routine to enable or disable static translations. 
*
* RETURNS
* 
* OK (success) always. 
*
*/
/* UDP Translation Entry Delete Routine (NAPT mode only) */
STATUS 	natUdpXlatDelete(NAT_CURRENCY_TRANSLATION_ENTRY *sptr_translation_entry)
{
	unsigned short status;
	NAT_BIND_INFO* bind_info;

	if(natFreeBind ((u_long)&nat, 0, sptr_translation_entry->bind_id)!=NAT_OK)
	{
		bind_info=(NAT_BIND_INFO*)sptr_translation_entry->bind_id;
		if(bind_info)
		{
			free(bind_info);
			bind_info=NULL;
		}
	}

	semTake(natentrylock, WAIT_FOREVER);
	status=natDelete_entrys(sptr_translation_entry);
	
	semGive(natentrylock);
	return (status);
}
/******************************************************************************
* 
* natIcmpXlatDelete - clear  icmp nat active translations with  s_ip s_identifier and d_ip
* 
* Use this routine to enable or disable static translations. 
*
* RETURNS
* 
* OK (success) always. 
*
*/
/* ICMP Translation Entry Delete Routine (NAPT mode only) */
STATUS 	natIcmpXlatDelete(NAT_CURRENCY_TRANSLATION_ENTRY *sptr_translation_entry)
{
	unsigned short status;
	NAT_BIND_INFO* bind_info;

	if(natFreeBind ((u_long)&nat, 0, sptr_translation_entry->bind_id)!=NAT_OK)
	{
		bind_info=(NAT_BIND_INFO*)sptr_translation_entry->bind_id;
		if(bind_info)
		{
			free(bind_info);
			bind_info=NULL;
		}
	}

	semTake(natentrylock, WAIT_FOREVER);
	status=natDelete_entrys(sptr_translation_entry);
	
	semGive(natentrylock);
	return (status);
}

/******************************************************************************
* 
* natClearAllEntry - clear  all nat active translations 
* 
* Use this routine to enable or disable static translations. 
*
* RETURNS
* 
* OK (success) always. 
*
*/
STATUS natClearAllEntry(void)
{
	NAT_CURRENCY_TRANSLATION_ENTRY *sptr_translation_entry=NULL;
	unsigned long nat_count;
	NAT_BIND_INFO* bind_info=NULL;
	
	if (nat.single_global_address_enabled == TRUE)
	{
		for(nat_count=0;nat_count < MAX_NAT_ENTRYS; nat_count++)
		{
			sptr_translation_entry=&natTabArray[nat_count];
			if(!sptr_translation_entry)
				continue;
			if(sptr_translation_entry->local_address==0)
			{
				continue;
			}
			
			if(sptr_translation_entry->bind_id)
			{
				if(natFreeBind ((u_long)&nat, 0, sptr_translation_entry->bind_id)!=NAT_OK)
				{
					if(sptr_translation_entry->bind_id)
					{
						bind_info=(NAT_BIND_INFO*)sptr_translation_entry->bind_id;
						if(bind_info)
						{
							free(bind_info);
							bind_info=NULL;
						}
					}
				}
			}
			
			semTake(natentrylock, WAIT_FOREVER);
			natDelete_entrys(sptr_translation_entry);
			
			semGive(natentrylock);
		}
	}
	return (OK);
}
/******************************************************************************
* 
* natClearSpecificEntry - clear specific nat active translations 
* 
* Use this routine to enable or disable static translations. 
*
* RETURNS
* 
* OK (success) always. 
*
*/
STATUS natClearSpecificEntry(char clear_mode,char protocol_type,
	char * S_ip,char * D_ip,unsigned short S_port,unsigned short D_port)
{
	unsigned long nat_timeisup_count;
	NAT_CURRENCY_TRANSLATION_ENTRY *sptr_translation_entry=NULL;
	unsigned long sip,dip;
	
	sip = ntohl(inet_addr(S_ip));
	dip = ntohl(inet_addr(D_ip));
	if (nat.single_global_address_enabled == TRUE)
	{
		for(nat_timeisup_count=0;nat_timeisup_count < MAX_NAT_ENTRYS; nat_timeisup_count++)
		{
			sptr_translation_entry=&natTabArray[nat_timeisup_count];
			if(!sptr_translation_entry)
				continue;
			if(sptr_translation_entry->local_address==0)
			{
				continue;
			}
			if(sptr_translation_entry->protocol_type!=protocol_type)
			{
				continue;
			}
			switch(protocol_type)
			{
				case IPPROTO_ICMP :
						if((sip==sptr_translation_entry->local_address)&&(S_port==sptr_translation_entry->local_port)
							&&(dip==sptr_translation_entry->remote_address))
						{
							
							if(natIcmpXlatDelete(sptr_translation_entry)==OK)
								return (OK);
							else
								return(ERROR);
						}
							
				break;
				case IPPROTO_TCP :
						if((sip==sptr_translation_entry->local_address)&&(S_port==sptr_translation_entry->local_port)
							&&(dip==sptr_translation_entry->remote_address)
							&&(sptr_translation_entry->remote_port==D_port))
						{
							if(natTcpXlatDelete(sptr_translation_entry)==OK)
								return (OK);
							else
								return (ERROR);
						}
				break;
				case IPPROTO_UDP :
						if((sip==sptr_translation_entry->local_address)&&(S_port==sptr_translation_entry->local_port)
							&&(dip==sptr_translation_entry->remote_address)
							&&(sptr_translation_entry->remote_port==D_port))
						{
							printf("delete udp entry!\n");
							if(natUdpXlatDelete(sptr_translation_entry)==OK)
								return (OK);
							else
								return (ERROR);
						}
				break;
				default :
					break;
			}
			
		}
		
	}
	return (OK);
}
/******************************************************************************
*
* natEntryTimeOut - set protocol nat translation list timeout
* 
* This routine set nat translation lists timeout in secends.
*
* RETURNS 
* 
* OK (success), or ERROR (failure). 
enum NAT_TCP_PORT_STATE
{
	NAT_SYNCH_STATE,
	NAT_FIN_STATE,
	NAT_ESTABLISHED_STATE,
	NAT_INITIAL_STATE,
	NAT_DISCONNECTED_STATE,
	NAT_ILLEGAL_STATE
};
*
*/
STATUS natEntryTimeOut(char protocol,unsigned long timeout,unsigned short flag)
{

	/*here!ensure timeout is even because nat entry timeout decrease 2 per!*/
	if(timeout&1)
		timeout+=1;
	switch(protocol)
	{
		case IPPROTO_TCP:
			if(flag==NAT_SYNCH_STATE)
			{
				
				nat.tcp_connecting_timer=timeout;
			}
			else if(flag==NAT_FIN_STATE)
			{
				nat.tcp_closing_timer=timeout;
				
			}
			else
				nat.tcp_disconnected_timer=timeout;
			break;
		case IPPROTO_UDP:
			nat.udp_translation_entry_timer=timeout;
			break;
		case IPPROTO_ICMP:
			nat.icmp_translation_entry_timer=timeout;
			break;
		case IPPROTO_IP:/*set all protocol timeout!*/
			nat.tcp_disconnected_timer=timeout;
			nat.udp_translation_entry_timer=timeout;
			nat.icmp_translation_entry_timer=timeout;
			break;
		default:
			break;
	}
	return (OK);
}

STATUS natEntryIpTimeOut(unsigned long timeout)
{

	/*here!ensure timeout is even because nat entry timeout decrease 2 per!*/
	if(timeout&1)
		timeout+=1;
	nat.ip_translation_entry_timer=timeout;
	return (OK);
}
#ifdef NATDNSPROXY
LOCAL STATUS	 natdnsproxy_init(void)
{
	int e;

	
	if(natdnsproxy_sock!=-1)
	{
		close(natdnsproxy_sock);
		natdnsproxy_sock=-1;
	}
	natdnsproxy_sock=socket(AF_INET,SOCK_DGRAM,0);
	if(natdnsproxy_sock==ERROR)
	{
		return ERROR;
	}
	dnssock.sin_family = AF_INET;
	dnssock.sin_addr.s_addr = htonl(INADDR_ANY);
	dnssock.sin_port = htons(NAT_DDNSPORT);
	
	e = bind(natdnsproxy_sock, (struct sockaddr*)&dnssock,sizeof(dnssock));
	if(e==ERROR)
	{

		close(natdnsproxy_sock);
		natdnsproxy_sock=ERROR;
		return ERROR;
	}

	e=taskSpawn("natdnsproxy",NATDNSPROXY_DAEMON_PRIOR,0,2*1024,
		(FUNCPTR)(natdnsproxy),0,0,0,0,0,0,0,0,0,0);
	if(e==ERROR)
	{
		printf("Create task natdnsproxy error.\n");
		natdnsproxy_end();
		return (ERROR);
	}
	
	return OK;
}

LOCAL STATUS natdnsproxy_end(void)
{
	
	if(natdnsproxy_sock!=-1)
	{
		close(natdnsproxy_sock);
		natdnsproxy_sock=-1;
	}
	return OK;
}

LOCAL STATUS natdnsproxy_terminated(void)
{
	int natdnsDelay;
	
	natdnsproxy_terminate= TRUE;

	natdnsDelay = 1 * sysClkRateGet();
	while(natdnsproxy_terminate == TRUE && natdnsDelay > 0 )
	{
		taskDelay(10);
		natdnsDelay -= 20;
	}
	
	if (natdnsproxy_terminate == FALSE)
		return OK;
	else
		return ERROR;
}

LOCAL STATUS natdnsproxy(char * buffer,struct  sockaddr_in *from,int len)
{
	
	return OK;
}

LOCAL STATUS natdnsproxyrecv(void)
{
	int  len=0,i;
	struct  sockaddr_in from;
	char Rbuffer[NATDNS_DATA_BUFFER]={0};
	struct  timeval timeout;
	fd_set  rfds;



	while(natdnsproxy_terminate)
	{
		timeout.tv_sec  = 3;
		timeout.tv_usec = 0;

		FD_ZERO(&rfds);
		FD_SET(natdnsproxy_sock, &rfds);

		i = select(natdnsproxy_sock + 1, &rfds, NULL, NULL, &timeout);
		if (i >= 0 ) 
		{
			if (!FD_ISSET(natdnsproxy_sock,&rfds))
				continue;
			len=sizeof(from);
			len = recvfrom (natdnsproxy_sock, Rbuffer, NATDNS_DATA_BUFFER, 0,(struct sockaddr *)&from, &len);
			if (len < 0)
				continue;
			natdnsproxy(Rbuffer,&from,len);
		}
	}
	
	natdnsproxy_end();
	natdnsproxy_terminate=FALSE;
	return OK;
}
#endif

#if 0
/******************************************************************************
*
* natXlatPortShow - display specific translation lists
* 
* This routine displays all translation lists.
*
* RETURNS 
* 
* OK (success), or ERROR (failure). 
*