nat_api.c

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

	}

	iaddr.s_addr = htonl (nat.global_address);
	inet_ntoa_b(iaddr, addr);
	printf("\nGlobal Address: %s\n", addr);

	iaddr.s_addr = htonl (nat.global_address_mask);
	inet_ntoa_b(iaddr, addr);
	printf("\nGlobal Address Mask: %s\n", addr);

	if(nat.single_global_address_enabled == TRUE)	/* NAPT */
	{
		/* Show NAPT-specific details */
		
	}
	else /* Basic NAT */
	{
		iaddr.s_addr = htonl (nat.starting_global_address);
		inet_ntoa_b(iaddr, addr);
		printf("\nBasic NAT Starting Global Address (static entries exempted): %s\n", addr);
	}

	printf("\nGlobal Addresses In Use\n");
	printf("------------------------\n");

	if(nat.natg.global_address_pool_size)
	{
		for(addr_index=1; addr_index < (nat.natg.global_address_pool_size - 1); addr_index++)
		{	
			if (addr_index >= nat.natg.global_address_index_start)
			{	/* don't show global addresses below the configured starting address */
				if(nat.natg.global_address_pool[addr_index].address_in_use == TRUE)
				{
					iaddr.s_addr = htonl (nat.natg.global_address_pool[addr_index].address);
					inet_ntoa_b(iaddr, addr);

					printf("%s\t", addr);

					if (nat.natg.global_address_pool[addr_index].static_entry == true)
					{
						printf("Static\n");
					}
					else
					{
						printf("Dynamic\n");
					}
				}
			}
			else	/* unless it is a static entry */
			{
				if(nat.natg.global_address_pool[addr_index].static_entry == true)
				{
					iaddr.s_addr = htonl (nat.natg.global_address_pool[addr_index].address);
					inet_ntoa_b(iaddr, addr);

					printf("%s\tStatic\n", addr);
				}
			}
		}
	}
	/* Static List (static entries only) */

	for(entry_num=0;entry_num<MAXIMUM_NUMBER_OF_TCP_STATIC_ENTRIES;entry_num++) 
	{			
		if (entry_num==0)
		{
			printf("\n");
			printf("Static TCP Server Translation Entries\n");
			printf("-------------------------------------\n");
		}

		if (nat.tcp_static_entries[entry_num].local_address == 0) /* End of list */
		{
			/* don't print anything */
		}
		else
		{
			iaddr.s_addr = htonl (nat.tcp_static_entries[entry_num].local_address);
			inet_ntoa_b(iaddr, addr);
			printf("Global IP Port: %-5d Local IP Port: %-5d  Address: %s\n"
				,nat.tcp_static_entries[entry_num].global_port_number
				,nat.tcp_static_entries[entry_num].local_port_number
				,addr);
		}
	}
	for(entry_num=0;entry_num<MAXIMUM_NUMBER_OF_UDP_STATIC_ENTRIES;entry_num++) 
	{		
		if (entry_num==0)
		{
			printf("\n");
			printf("Static UDP Server Translation Entries\n");
			printf("-------------------------------------\n");
		}

		if (nat.udp_static_entries[entry_num].local_address == 0) 
		{
			/* don't print anything */
		}
		else
		{
			iaddr.s_addr = htonl(nat.udp_static_entries[entry_num].local_address);
			inet_ntoa_b(iaddr, addr);
			printf("Global IP Port: %-5d Server IP Port: %-5d  Address: %s\n"
				,nat.udp_static_entries[entry_num].global_port_number
				,nat.udp_static_entries[entry_num].local_port_number
				,addr);
		}
	}
	return(OK);
}
#endif

/******************************************************************************
* 
* natEnable - enable or disable the NAT agent
* 
* Use this routine to enable or disable the NAT agent. 
*
* RETURNS
* 
* OK (success) always.
*
*/
IMPORT STATUS natInit (void);
IMPORT void nat_parameter_initialize();
STATUS natEnable
    (
    BOOL enable /* TRUE to enable NAT agent, FALSE to disable. */
    )
{
	if(nat.enabled&&(!enable))
	{
		natClearAllEntry();
	}
	if(enable&&!nat.enabled)
	{
		nat.enabled = TRUE;
		natInit();
	}
	else if(nat.enabled&&!enable)
	{
		nat.enabled=FALSE;
		nat_cleanup();
		natFtpend();
		natH323end();
		natPPTPPTEnd();
		natIPSecPTEnd();
		#ifdef NATDNSPROXY
		natdnsproxy_terminated();
		#endif
		nat_parameter_initialize();
	}
	
	return(OK);
}

int nat_connectionAllGet(void)
{
	return (natStats.tcpCons+natStats.udpCons+natStats.icmpCons);
}

int nat_connectionTCPGet(void)
{
	return (natStats.tcpCons);
}

int nat_connectionUdpGet(void)
{
	return (natStats.udpCons);
}

int nat_connectionIcmpGet(void)
{
	return (natStats.icmpCons);
}


STATUS nat_Reinit(void)
{
	natClearAllEntry();
	nat.enabled=FALSE;
	natWorkMode(FALSE);

	natPortWorkMode("ks1",0,1);
	natPortWorkMode("ks0",1,0);

	
	natWorkMode(TRUE);
	nat.enabled=TRUE;
	return OK;
}

/******************************************************************************
* 
* natPortEnable - enable or disable translations on a specific port 
* 
* Use this routine to enable or disable translations on the specified port. 
*
* RETURNS
* 
* OK (success), or ERROR (failure). 
*
*/

STATUS natPortEnable
    (
    int port,   /* The port or interface to enable or disable. */
    BOOL enable /* TRUE to enable translations, FALSE to disable. */
    )
{
	if (port >=NUMBER_OF_IP_PORTS)
	{
		return(ERROR);
	}

	nat.port[port].enabled = enable;

	return(OK);
}
/******************************************************************************
* 
* natWorkMode - enable or disable translations on a specific port 
* 
* Use this routine to enable or disable translations on the specified port. 
*
* RETURNS
* 
* OK (success), or ERROR (failure). 
*
*/

STATUS natWorkMode
    (
    BOOL enable /* TRUE to enable translations, FALSE to disable. */
    )
{

	nat.single_global_address_enabled = enable;

	return(OK);
}


STATUS natfilterunknown
    (
    BOOL enable /* TRUE to enable translations, FALSE to disable. */
    )
{

	nat.filter_unknown_protocols = enable;

	return(OK);
}
STATUS natdebugprint
    (
    BOOL enable /* TRUE to enable translations, FALSE to disable. */
    )
{

	nat.printing_enabled = enable;
	nat.error_printing_enabled = enable;
	nat.initialization_printing_enabled = enable;
	nat.printing_debug=enable;
	nat.trace_printing_enabled=enable;
	nat.data_printing_enabled=enable;


	return(OK);
}
STATUS natdebuglogging
    (
    BOOL enable /* TRUE to enable translations, FALSE to disable. */
    )
{
	nat.logging_enabled=enable;
	nat.error_logging_enabled = enable;
	nat.initialization_logging_enabled = enable;
	nat.trace_logging_enabled = enable;
	nat.data_logging_enabled = enable;


	return(OK);
}
/******************************************************************************
* 
* EnnatWorkMode - enable or disable translations on fast mode 
* 
* Use this routine to enable or disable translations on the specified port. 
*
* RETURNS
* 
* OK (success), or ERROR (failure). 
*
*/

STATUS natExtendConfig
    (
    BOOL enable /* TRUE to enable translations, FALSE to disable. */
    )
{

	nat.fastnat=enable;

	return(OK);
}
/******************************************************************************
* 
* Get_Nat_Status - return nat work status enable or disable 
* 
* Use this routine to enable or disable translations on the specified port. 
*
* RETURNS
* 
* TRUE (enable), or FALSE (disable). 
*
*/
STATUS Get_Nat_Status()
{
	if(nat.enabled)
		return 1;
	else
		return 0;
}
/******************************************************************************
* 
* natPortEnable - enable or disable translations on a specific port 
* 
* Use this routine to enable or disable translations on the specified port. 
*
*Work_Mode 0 is inside and 1 is outside
* RETURNS
* 
* OK (success), or ERROR (failure). 
*
*/

STATUS natPortWorkMode
    (
    char * if_name,   /* The if_name if interface name. */
    unsigned short    if_number,
    BOOL Work_Mode /* Work_Mode 1 is inside and 0 is outside */
    )
{
	unsigned short port_number;
	/* Find port for this interface */
	unsigned char * pStr;
	struct ifnet* 		global_if;
	IP_ADDRESS		inAddr, inMask;
	struct	ifaddr*			ifaddr;

		/* convert the string to all lower case letters */

	pStr = (unsigned char *)if_name;
	while (*pStr != (unsigned char)(ULONG)NULL)
	{
		*pStr = tolower(*pStr);
		pStr++;
	}
	if(strlen(if_name)>=16)
		return (ERROR);
	/*find match ifname from nat.port table!*/
	for (port_number = 0; port_number < sizeof(nat.port)/sizeof(nat.port[0]);
		port_number++)
	{
		if(strncmp(nat.port[port_number].ifname,if_name,16)==0)
		{
			if(Work_Mode)
			{
				nat.port[port_number].type=NAT_LOCAL_PORT;
				memcpy(nat.port[port_number].type_string,"local",5);
				nat.port[port_number].enabled=TRUE;
				
			}
			else
			{
				nat.port[port_number].type=NAT_GLOBAL_PORT;
				memcpy(nat.port[port_number].type_string,"global",6);
				nat.port[port_number].enabled=TRUE;
				nat.global_port_number=port_number;
				
			}
			global_if = ifunit(if_name);
			if(!global_if)
				return (ERROR);
			for (ifaddr = global_if->if_addrlist; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
			{
				if(ifaddr->ifa_addr->sa_family == AF_INET)
					break;
			}

			if (ifaddr != NULL)	/* IP Address found */
			{
				inAddr = ntohl(((struct sockaddr_in*) ifaddr->ifa_addr)->sin_addr.s_addr);
				inMask = ntohl(((struct sockaddr_in*) ifaddr->ifa_netmask)->sin_addr.s_addr);

				nat.port[port_number].address = inAddr;
				nat.port[port_number].mask = inMask;
				nat.port[port_number].ifunit=global_if;
				if(!Work_Mode)
				{
					nat.global_address = inAddr;
					nat.global_address_mask = inMask;
				}
			}
			else
			{
				if(!Work_Mode)
				{
					nat.port[port_number].ifunit=NULL;
					nat.port[port_number].enabled=FALSE;
				}
			}
			nat_add_local_interfaces_to_passthru_list();
			return(OK);
		}
	}
	/*find match ifname from interface table!*/
	if (port_number >= sizeof(nat.port)/sizeof(nat.port[0]))
	{
		
		if (if_number >=NUMBER_OF_IP_PORTS)
		{
			return(ERROR);
		}
		/*
		ifIndexToIfName(if_number,if_number_name);
		if(strncmp(if_number_name,if_name,16))
			return (ERROR);
			*/
		if(Work_Mode)
		{
			nat.port[if_number].type=NAT_LOCAL_PORT;
			memcpy(nat.port[if_number].type_string,"local",5);
			memcpy(nat.port[if_number].ifname,if_name,strlen(if_name));
			nat.port[if_number].enabled=TRUE;
		}
		else
		{
			nat.port[if_number].type=NAT_GLOBAL_PORT;
			memcpy(nat.port[if_number].type_string,"global",6);
			memcpy(nat.port[if_number].ifname,if_name,strlen(if_name));
			nat.global_port_number=if_number;
			nat.port[if_number].enabled=TRUE;
		}
		global_if = ifunit(if_name);
		if(!global_if)
			return (ERROR);
		for (ifaddr = global_if->if_addrlist; ifaddr != NULL; ifaddr = ifaddr->ifa_next)
		{
			if(ifaddr->ifa_addr->sa_family == AF_INET)
				break;
		}
	
		if (ifaddr != NULL)	/* IP Address found */
		{
			inAddr = ntohl(((struct sockaddr_in*) ifaddr->ifa_addr)->sin_addr.s_addr);
			inMask = ntohl(((struct sockaddr_in*) ifaddr->ifa_netmask)->sin_addr.s_addr);

			nat.port[if_number].address = inAddr;
			nat.port[if_number].mask = inMask;
			nat.port[if_number].ifunit=global_if;
			if(!Work_Mode)
			{
				nat.global_address = inAddr;