mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-12-18 15:59:43 +02:00
1048c7b452
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@34060 3c298f89-4303-0410-b956-a3cf2f4a3e73
1570 lines
41 KiB
C
1570 lines
41 KiB
C
/******************************************************************************
|
|
|
|
Copyright (c) 2009
|
|
Lantiq Deutschland GmbH
|
|
Am Campeon 3; 81726 Munich, Germany
|
|
|
|
THE DELIVERY OF THIS SOFTWARE AS WELL AS THE HEREBY GRANTED NON-EXCLUSIVE,
|
|
WORLDWIDE LICENSE TO USE, COPY, MODIFY, DISTRIBUTE AND SUBLICENSE THIS
|
|
SOFTWARE IS FREE OF CHARGE.
|
|
|
|
THE LICENSED SOFTWARE IS PROVIDED "AS IS" AND INFINEON EXPRESSLY DISCLAIMS
|
|
ALL REPRESENTATIONS AND WARRANTIES, WHETHER EXPRESS OR IMPLIED, INCLUDING
|
|
WITHOUT LIMITATION, WARRANTIES OR REPRESENTATIONS OF WORKMANSHIP,
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, DURABILITY, THAT THE
|
|
OPERATING OF THE LICENSED SOFTWARE WILL BE ERROR FREE OR FREE OF ANY THIRD
|
|
PARTY CLAIMS, INCLUDING WITHOUT LIMITATION CLAIMS OF THIRD PARTY INTELLECTUAL
|
|
PROPERTY INFRINGEMENT.
|
|
|
|
EXCEPT FOR ANY LIABILITY DUE TO WILFUL ACTS OR GROSS NEGLIGENCE AND EXCEPT
|
|
FOR ANY PERSONAL INJURY INFINEON SHALL IN NO EVENT BE LIABLE FOR ANY CLAIM
|
|
OR DAMAGES OF ANY KIND, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
DEALINGS IN THE SOFTWARE.
|
|
|
|
****************************************************************************
|
|
|
|
Description : This file contains implementation of Custom NAT function
|
|
for Infineon's VINETIC-SVIP16
|
|
*******************************************************************************/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/netfilter_ipv4.h>
|
|
#include <linux/if_ether.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/inetdevice.h>
|
|
#include <linux/in.h>
|
|
#include <linux/ip.h>
|
|
#include <linux/if_vlan.h>
|
|
#include <linux/udp.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/version.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/in6.h> /* just to shut up a warning */
|
|
#include <linux/miscdevice.h>
|
|
#include <asm/checksum.h>
|
|
|
|
#include <linux/svip_nat.h>
|
|
|
|
MODULE_AUTHOR("Lantiq Deutschland GmbH");
|
|
MODULE_DESCRIPTION("SVIP Network Address Translation module");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#define SVIP_NAT_INFO_STR "@(#)SVIP NAT, version "SVIP_NAT_VERSION
|
|
|
|
/** maximum voice packet channels possible on the SVIP LC system
|
|
(equals maximum number of Codec channels possible) */
|
|
#define SVIP_SYS_CODEC_NUM ((SVIP_SYS_NUM) * (SVIP_CODEC_NUM))
|
|
|
|
/** end UDP port number of the SVIP Linecard System */
|
|
#define SVIP_UDP_TO ((SVIP_UDP_FROM) + (SVIP_SYS_CODEC_NUM) - 1)
|
|
|
|
/** end UDP port number of the Master SVIP in SVIP Linecard System */
|
|
#define SVIP_UDP_TO_VOFW0 ((SVIP_UDP_FROM) + (SVIP_CODEC_NUM) - 1)
|
|
|
|
#define SVIP_PORT_INRANGE(nPort) \
|
|
((nPort) >= (SVIP_UDP_FROM) && (nPort) <= (SVIP_UDP_TO))
|
|
|
|
#define SVIP_PORT_INDEX(nPort) (nPort - SVIP_UDP_FROM)
|
|
|
|
#define SVIP_NET_DEV_ETH0_IDX 0
|
|
#define SVIP_NET_DEV_VETH0_IDX 1
|
|
#define SVIP_NET_DEV_LO_IDX 2
|
|
|
|
#define SVIP_NET_DEV_ETH0_NAME "eth0"
|
|
#define SVIP_NET_DEV_ETH1_NAME "eth1"
|
|
#define SVIP_NET_DEV_VETH1_NAME "veth0"
|
|
#define SVIP_NET_DEV_LO_NAME "lo"
|
|
|
|
#define SVIP_NAT_STATS_LOC2REM 0
|
|
#define SVIP_NAT_STATS_REM2LOC 1
|
|
#define SVIP_NAT_STATS_TYPES 2
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
|
|
#define SVIP_NAT_FOR_EACH_NETDEV(d) for_each_netdev(&init_net, dev)
|
|
#define SVIP_NAT_IP_HDR(ethhdr) ip_hdr(ethhdr)
|
|
#else
|
|
#define SVIP_NAT_FOR_EACH_NETDEV(d) for(d=dev_base; dev; dev = dev->next)
|
|
#define SVIP_NAT_IP_HDR(ethhdr) (ethhdr)->nh.iph
|
|
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
#define SVIP_NAT_SKB_MAC_HEADER(ethhdr) (ethhdr)->mac.ethernet
|
|
#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
|
|
#define SVIP_NAT_SKB_MAC_HEADER(ethhdr) (ethhdr)->mac.raw
|
|
#else
|
|
#define SVIP_NAT_SKB_MAC_HEADER(ethhdr) skb_mac_header(ethhdr)
|
|
#endif
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
|
|
#define VLAN_DEV_REAL_DEV(dev) vlan_dev_real_dev(dev)
|
|
#define VLAN_DEV_VLAN_ID(dev) vlan_dev_vlan_id(dev)
|
|
#else
|
|
#define VLAN_DEV_REAL_DEV(dev) (VLAN_DEV_INFO(dev)->real_dev)
|
|
#define VLAN_DEV_VLAN_ID(dev) (VLAN_DEV_INFO(dev)->vlan_id)
|
|
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
|
|
|
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
|
|
#define MOD_INC_USE_COUNT
|
|
#define MOD_DEC_USE_COUNT
|
|
#endif
|
|
|
|
#if ! ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)) && \
|
|
(defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)))
|
|
#define VLAN_8021Q_UNUSED
|
|
#endif
|
|
|
|
|
|
extern spinlock_t vlan_group_lock;
|
|
extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev, unsigned short VID);
|
|
|
|
typedef struct SVIP_NAT_stats
|
|
{
|
|
unsigned long inPackets;
|
|
unsigned long outPackets;
|
|
unsigned long outErrors;
|
|
} SVIP_NAT_stats_t;
|
|
|
|
typedef struct SVIP_NAT_table_entry
|
|
{
|
|
SVIP_NAT_IO_Rule_t natRule;
|
|
SVIP_NAT_stats_t natStats[SVIP_NAT_STATS_TYPES];
|
|
} SVIP_NAT_table_entry_t;
|
|
|
|
/* pointer to the SVIP NAT table */
|
|
static SVIP_NAT_table_entry_t *pNatTable = NULL;
|
|
|
|
struct net_device *net_devs[3];
|
|
static u32 *paddr_eth0;
|
|
static u32 *paddr_eth0_0;
|
|
static u32 *paddr_veth0;
|
|
static u32 *pmask_veth0;
|
|
|
|
static struct semaphore *sem_nat_tbl_access;
|
|
static int proc_read_in_progress = 0;
|
|
|
|
static int nDeviceOpen = 0;
|
|
|
|
/* saves the NAT table index between subsequent invocation */
|
|
static int nProcReadIdx = 0;
|
|
|
|
static long SVIP_NAT_device_ioctl(struct file *,unsigned int ,unsigned long);
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
|
|
static int SVIP_NAT_device_release (struct inode *,struct file *);
|
|
#else
|
|
static void SVIP_NAT_device_release (struct inode *,struct file *);
|
|
#endif
|
|
static int SVIP_NAT_device_open (struct inode *,struct file *);
|
|
|
|
/* This structure holds the interface functions supported by
|
|
the SVIP NAT configuration device. */
|
|
struct file_operations SVIP_NAT_Fops = {
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
|
|
owner: THIS_MODULE,
|
|
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) */
|
|
llseek: NULL, /* seek */
|
|
read: NULL,
|
|
write: NULL,
|
|
readdir: NULL, /* readdir */
|
|
poll: NULL, /* select */
|
|
unlocked_ioctl: SVIP_NAT_device_ioctl, /* ioctl */
|
|
mmap: NULL, /* mmap */
|
|
open: SVIP_NAT_device_open, /* open, */
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
|
|
flush: NULL, /* flush */
|
|
#endif
|
|
release: SVIP_NAT_device_release /* close */
|
|
};
|
|
|
|
/** Structure holding MISC module operations */
|
|
static struct miscdevice SVIP_NAT_miscdev =
|
|
{
|
|
minor: MINOR_NUM_SVIP_NAT,
|
|
name: SVIP_NAT_DEVICE_NAME,
|
|
fops: &SVIP_NAT_Fops
|
|
};
|
|
|
|
#ifdef CONFIG_SVIP_FW_PKT_SNIFFER
|
|
int nSVIP_NAT_Sniffer;
|
|
unsigned char pSVIP_NAT_SnifferMAC[ETH_ALEN];
|
|
int nSVIP_NAT_SnifferMacSet;
|
|
#endif
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Function to read /proc/net/svip_nat/nat proc entry
|
|
|
|
\arguments
|
|
page - pointer to page buffer
|
|
start - pointer to start address pointer
|
|
off - offset
|
|
count - maximum data length to read
|
|
eof - end of file flag
|
|
data - proc read data (provided by the function
|
|
pointed to by data)
|
|
|
|
\return
|
|
length of read data
|
|
|
|
\remarks:
|
|
Each call of this routine forces a copy_to_user of the data returned by
|
|
'fn'. This routine will be called by the user until 'len = 0'.
|
|
****************************************************************************/
|
|
static int SVIP_NAT_ProcRead (char *page, char **start, off_t off,
|
|
int count, int *eof, void *data)
|
|
{
|
|
unsigned long flags;
|
|
int (*fn)(char *buf, int size);
|
|
int len;
|
|
|
|
/* If the NAT table index is negative, the reading has completed */
|
|
if (nProcReadIdx < 0)
|
|
{
|
|
nProcReadIdx = 0;
|
|
*eof = 1;
|
|
proc_read_in_progress = 0;
|
|
up(sem_nat_tbl_access);
|
|
return 0;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
if (!proc_read_in_progress)
|
|
{
|
|
proc_read_in_progress = 1;
|
|
local_irq_restore(flags);
|
|
/* we use this semaphore in order to ensure no other party(could be ioctl
|
|
FIO_SVIP_NAT_RULE_LIST), uses function SVIP_NAT_ProcReadNAT(), during
|
|
the time read of the proc file takes place */
|
|
down(sem_nat_tbl_access);
|
|
}
|
|
else
|
|
{
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
if (data != NULL)
|
|
{
|
|
fn = data;
|
|
len = fn (page, count);
|
|
/* In this setup each read of the proc entries returns the read data by
|
|
'fn' to the user. The user keeps issuing read requests as long as the
|
|
returned value of 'len' is greater than zero. */
|
|
*eof = 1;
|
|
*start = page;
|
|
}
|
|
else
|
|
{
|
|
len = 0;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
#ifdef CONFIG_SVIP_FW_PKT_SNIFFER
|
|
/**
|
|
Function to read remaining proc entries
|
|
*/
|
|
static int SVIP_NAT_ProcReadGen (char *page, char **start, off_t off,
|
|
int count, int *eof, void *data)
|
|
{
|
|
int (*fn)(char *buf, int size);
|
|
int len = 0;
|
|
|
|
MOD_INC_USE_COUNT;
|
|
|
|
if (data == NULL)
|
|
{
|
|
MOD_DEC_USE_COUNT;
|
|
return 0;
|
|
}
|
|
|
|
fn = data;
|
|
len = fn (page, count);
|
|
|
|
if (len <= off + count)
|
|
{
|
|
*eof = 1;
|
|
}
|
|
*start = page + off;
|
|
len -= off;
|
|
if (len > count)
|
|
{
|
|
len = count;
|
|
}
|
|
if (len < 0)
|
|
{
|
|
len = 0;
|
|
}
|
|
|
|
MOD_DEC_USE_COUNT;
|
|
|
|
return len;
|
|
}
|
|
#endif
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Function for setting up /proc/net/svip_nat read data
|
|
|
|
\arguments
|
|
buf - pointer to read buffer
|
|
count - size of read buffer
|
|
|
|
\return
|
|
length of read data into buffer
|
|
|
|
\remarks:
|
|
The global variable 'nProcReadIdx' is used to save the table index where
|
|
the reading of the NAT table stopped. Reading is stopped when the end of
|
|
the read buffer is approached. On the next itteration the reading continues
|
|
from the saved index.
|
|
*******************************************************************************/
|
|
static int SVIP_NAT_ProcReadNAT(char *buf, int count)
|
|
{
|
|
int i, j;
|
|
int len = 0;
|
|
SVIP_NAT_IO_Rule_t *pNatRule;
|
|
|
|
if (nProcReadIdx == -1)
|
|
{
|
|
nProcReadIdx = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (nProcReadIdx == 0)
|
|
{
|
|
len = sprintf(buf+len,
|
|
"Remote host IP " /* 16 char */
|
|
"Remote host MAC " /* 19 char */
|
|
"Local host IP " /* 15 char */
|
|
"Local host MAC " /* 19 char */
|
|
"Local host UDP " /* 16 char */
|
|
"Loc->Rem(in/out/err) " /* 22 char */
|
|
"Rem->Loc(in/out/err)\n\r");
|
|
}
|
|
|
|
for (i = nProcReadIdx; i < SVIP_SYS_CODEC_NUM; i++)
|
|
{
|
|
int slen;
|
|
|
|
pNatRule = &pNatTable[i].natRule;
|
|
|
|
if (pNatRule->remIP != 0)
|
|
{
|
|
/* make sure not to overwrite the buffer */
|
|
if (count < len+120)
|
|
break;
|
|
|
|
/* remIP */
|
|
slen = sprintf(buf+len, "%d.%d.%d.%d",
|
|
(int)((pNatRule->remIP >> 24) & 0xff),
|
|
(int)((pNatRule->remIP >> 16) & 0xff),
|
|
(int)((pNatRule->remIP >> 8) & 0xff),
|
|
(int)((pNatRule->remIP >> 0) & 0xff));
|
|
len += slen;
|
|
for (j = 0; j < (16-slen); j++)
|
|
len += sprintf(buf+len, " ");
|
|
|
|
/* remMAC */
|
|
slen = 0;
|
|
for (j = 0; j < ETH_ALEN; j++)
|
|
{
|
|
slen += sprintf(buf+len+slen, "%02x%s",
|
|
pNatRule->remMAC[j], j < ETH_ALEN-1 ? ":" : " ");
|
|
}
|
|
len += slen;
|
|
for (j = 0; j < (19-slen); j++)
|
|
len += sprintf(buf+len, " ");
|
|
|
|
/* locIP */
|
|
slen = sprintf(buf+len, "%d.%d.%d.%d",
|
|
(int)((pNatRule->locIP >> 24) & 0xff),
|
|
(int)((pNatRule->locIP >> 16) & 0xff),
|
|
(int)((pNatRule->locIP >> 8) & 0xff),
|
|
(int)((pNatRule->locIP >> 0) & 0xff));
|
|
len += slen;
|
|
for (j = 0; j < (15-slen); j++)
|
|
len += sprintf(buf+len, " ");
|
|
|
|
/* locMAC */
|
|
slen = 0;
|
|
for (j = 0; j < ETH_ALEN; j++)
|
|
{
|
|
slen += sprintf(buf+len+slen, "%02x%s",
|
|
pNatRule->locMAC[j], j < ETH_ALEN-1 ? ":" : " ");
|
|
}
|
|
len += slen;
|
|
for (j = 0; j < (19-slen); j++)
|
|
len += sprintf(buf+len, " ");
|
|
|
|
/* locUDP */
|
|
slen = sprintf(buf+len, "%d", pNatRule->locUDP);
|
|
len += slen;
|
|
for (j = 0; j < (16-slen); j++)
|
|
len += sprintf(buf+len, " ");
|
|
|
|
/* NAT statistics, Local to Remote translation */
|
|
slen = sprintf(buf+len, "(%ld/%ld/%ld)",
|
|
pNatTable[i].natStats[SVIP_NAT_STATS_LOC2REM].inPackets,
|
|
pNatTable[i].natStats[SVIP_NAT_STATS_LOC2REM].outPackets,
|
|
pNatTable[i].natStats[SVIP_NAT_STATS_LOC2REM].outErrors);
|
|
len += slen;
|
|
for (j = 0; j < (22-slen); j++)
|
|
len += sprintf(buf+len, " ");
|
|
|
|
/* NAT statistics, Remote to Local translation */
|
|
len += sprintf(buf+len, "(%ld/%ld/%ld)\n\r",
|
|
pNatTable[i].natStats[SVIP_NAT_STATS_REM2LOC].inPackets,
|
|
pNatTable[i].natStats[SVIP_NAT_STATS_REM2LOC].outPackets,
|
|
pNatTable[i].natStats[SVIP_NAT_STATS_REM2LOC].outErrors);
|
|
}
|
|
}
|
|
if (i == SVIP_SYS_CODEC_NUM)
|
|
nProcReadIdx = -1; /* reading completed */
|
|
else
|
|
nProcReadIdx = i; /* reading still in process, buffer was full */
|
|
|
|
return len;
|
|
}
|
|
|
|
#ifdef CONFIG_SVIP_FW_PKT_SNIFFER
|
|
/**
|
|
Converts MAC address from ascii to hex respesentaion
|
|
*/
|
|
static int SVIP_NAT_MacAsciiToHex(const char *pMacStr, unsigned char *pMacHex)
|
|
{
|
|
int i=0, c=0, b=0, n=0;
|
|
|
|
memset(pMacHex, 0, ETH_ALEN);
|
|
while (pMacStr[i] != '\0')
|
|
{
|
|
if (n >= 0)
|
|
{
|
|
unsigned char nToHex = 0;
|
|
|
|
/* check for hex digit */
|
|
if (pMacStr[i] >= '0' && pMacStr[i] <= '9')
|
|
nToHex = 0x30;
|
|
else if (pMacStr[i] >= 'a' && pMacStr[i] <= 'f')
|
|
nToHex = 0x57;
|
|
else if (pMacStr[i] >= 'A' && pMacStr[i] <= 'F')
|
|
nToHex = 0x37;
|
|
else
|
|
{
|
|
if (n != 0)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: invalid MAC address format[%s]\n", pMacStr);
|
|
return -1;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
n^=1;
|
|
pMacHex[b] |= ((pMacStr[i] - nToHex)&0xf) << (4*n);
|
|
if (n == 0)
|
|
{
|
|
/* advance to next byte, check if complete */
|
|
if (++b >= ETH_ALEN)
|
|
return 0;
|
|
/* byte completed, next we expect a colon... */
|
|
c = 1;
|
|
/* and, do not check for hex digit */
|
|
n = -1;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (c == 1)
|
|
{
|
|
if (pMacStr[i] == ':')
|
|
{
|
|
/* next we expect hex digit, again */
|
|
n = 0;
|
|
}
|
|
else
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: invalid MAC address format[%s]\n", pMacStr);
|
|
return -1;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
Used to set the destination MAC address of a host where incoming
|
|
SVIP VoFW packets are to be addressed. In case the address is set
|
|
to 00:00:00:00:00:00 (the default case), the packets will written
|
|
out to eth0 with its original MAC addess.
|
|
|
|
\remark
|
|
usage: 'echo "00:03:19:00:15:D1" > cat /proc/net/svip_nat/snifferMAC'
|
|
*/
|
|
int SVIP_NAT_ProcWriteSnifferMAC (struct file *file, const char *buffer,
|
|
unsigned long count, void *data)
|
|
{
|
|
/* at least strlen("xx:xx:xx:xx:xx:xx") characters, followed by '\0' */
|
|
if (count >= 18)
|
|
{
|
|
int ret;
|
|
|
|
ret = SVIP_NAT_MacAsciiToHex(buffer, pSVIP_NAT_SnifferMAC);
|
|
|
|
if (ret != 0)
|
|
return 0;
|
|
|
|
if (!(pSVIP_NAT_SnifferMAC[0]==0 && pSVIP_NAT_SnifferMAC[1]==0 &&
|
|
pSVIP_NAT_SnifferMAC[2]==0 && pSVIP_NAT_SnifferMAC[3]==0 &&
|
|
pSVIP_NAT_SnifferMAC[4]==0 && pSVIP_NAT_SnifferMAC[5]==0))
|
|
{
|
|
nSVIP_NAT_SnifferMacSet = 1;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
Used to read the destination MAC address of a sniffer host
|
|
*/
|
|
int SVIP_NAT_ProcReadSnifferMAC (char *buf, int count)
|
|
{
|
|
int len = 0;
|
|
|
|
len = snprintf(buf, count, "%02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
pSVIP_NAT_SnifferMAC[0], pSVIP_NAT_SnifferMAC[1],
|
|
pSVIP_NAT_SnifferMAC[2], pSVIP_NAT_SnifferMAC[3],
|
|
pSVIP_NAT_SnifferMAC[4], pSVIP_NAT_SnifferMAC[5]);
|
|
|
|
if (len > count)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: Only part of the text could be put into the buffer\n");
|
|
return count;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
Used to switch VoFW message sniffer on/off
|
|
|
|
\remark
|
|
usage: 'echo "1" > cat /proc/net/svip_nat/snifferOnOff'
|
|
*/
|
|
int SVIP_NAT_ProcWriteSnifferOnOff (struct file *file, const char *buffer,
|
|
unsigned long count, void *data)
|
|
{
|
|
/* at least one digit expected, followed by '\0' */
|
|
if (count >= 2)
|
|
{
|
|
int ret, nSnifferOnOff;
|
|
|
|
ret = sscanf(buffer, "%d", &nSnifferOnOff);
|
|
|
|
if (ret != 1)
|
|
return count;
|
|
|
|
if (nSnifferOnOff > 0)
|
|
nSnifferOnOff = 1;
|
|
|
|
nSVIP_NAT_Sniffer = nSnifferOnOff;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
Used to read the VoFW message sniffer configuration (on/off)
|
|
*/
|
|
int SVIP_NAT_ProcReadSnifferOnOff (char *buf, int count)
|
|
{
|
|
int len = 0;
|
|
|
|
len = snprintf(buf, count, "%d\n", nSVIP_NAT_Sniffer);
|
|
|
|
if (len > count)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: Only part of the text could be put into the buffer\n");
|
|
return count;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
#endif
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Creates proc read/write entries
|
|
|
|
\return
|
|
0 on success, -1 on error
|
|
*/
|
|
/******************************************************************************/
|
|
static int SVIP_NAT_ProcInstall(void)
|
|
{
|
|
struct proc_dir_entry *pProcParentDir, *pProcDir;
|
|
struct proc_dir_entry *pProcNode;
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
|
|
pProcParentDir = proc_net;
|
|
#else
|
|
pProcParentDir = init_net.proc_net;
|
|
#endif
|
|
pProcDir = proc_mkdir(SVIP_NAT_DEVICE_NAME, pProcParentDir);
|
|
if (pProcDir == NULL)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: cannot create proc dir %s/%s\n\r",
|
|
pProcParentDir->name, SVIP_NAT_DEVICE_NAME);
|
|
return -1;
|
|
}
|
|
|
|
pProcNode = create_proc_read_entry("nat", S_IFREG|S_IRUGO, pProcDir,
|
|
SVIP_NAT_ProcRead, (void *)SVIP_NAT_ProcReadNAT);
|
|
if (pProcNode == NULL)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: cannot create proc entry %s/%s",
|
|
pProcDir->name, "nat");
|
|
return -1;
|
|
}
|
|
|
|
#ifdef CONFIG_SVIP_FW_PKT_SNIFFER
|
|
nSVIP_NAT_Sniffer = 0;
|
|
/* creates proc entry for switching on/off sniffer to VoFW messages */
|
|
pProcNode = create_proc_read_entry("snifferOnOff", S_IFREG|S_IRUGO|S_IWUGO,
|
|
pProcDir, SVIP_NAT_ProcReadGen, (void *)SVIP_NAT_ProcReadSnifferOnOff);
|
|
if (pProcNode == NULL)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: cannot create proc entry %s/%s\n\r",
|
|
pProcDir->name, "snifferOnOff");
|
|
return -1;
|
|
}
|
|
pProcNode->write_proc = SVIP_NAT_ProcWriteSnifferOnOff;
|
|
|
|
memset (pSVIP_NAT_SnifferMAC, 0, ETH_ALEN);
|
|
nSVIP_NAT_SnifferMacSet = 0;
|
|
/* creates proc entry for setting MAC address of sniffer host to VoFW messages */
|
|
pProcNode = create_proc_read_entry("snifferMAC", S_IFREG|S_IRUGO|S_IWUGO,
|
|
pProcDir, SVIP_NAT_ProcReadGen, (void *)SVIP_NAT_ProcReadSnifferMAC);
|
|
if (pProcNode == NULL)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: cannot create proc entry %s/%s\n\r",
|
|
pProcDir->name, "snifferMAC");
|
|
return -1;
|
|
}
|
|
pProcNode->write_proc = SVIP_NAT_ProcWriteSnifferMAC;
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
No actions done here, simply a check is performed if an open has already
|
|
been performed. Currently only a single open is allowed as it is a sufficient
|
|
to have hat a single process configuring the SVIP NAT at one time.
|
|
|
|
\arguments
|
|
inode - pointer to disk file data
|
|
file - pointer to device file data
|
|
|
|
\return
|
|
0 on success, else -1
|
|
*/
|
|
/******************************************************************************/
|
|
static int SVIP_NAT_device_open(struct inode *inode, struct file *file)
|
|
{
|
|
unsigned long flags;
|
|
struct in_device *in_dev;
|
|
struct in_ifaddr *ifa;
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
local_irq_save(flags);
|
|
#else
|
|
local_save_flags(flags);
|
|
#endif
|
|
|
|
if (nDeviceOpen)
|
|
{
|
|
MOD_INC_USE_COUNT;
|
|
local_irq_restore(flags);
|
|
nDeviceOpen++;
|
|
return 0;
|
|
}
|
|
|
|
/* find pointer to IP address of eth0 */
|
|
if ((in_dev=in_dev_get(net_devs[SVIP_NET_DEV_ETH0_IDX])) != NULL)
|
|
{
|
|
for (ifa = in_dev->ifa_list; ifa != NULL; ifa = ifa->ifa_next)
|
|
{
|
|
if (!paddr_eth0 && ifa->ifa_address != 0)
|
|
{
|
|
paddr_eth0 = &ifa->ifa_address;
|
|
continue;
|
|
}
|
|
if (paddr_eth0 && ifa->ifa_address != 0)
|
|
{
|
|
paddr_eth0_0 = &ifa->ifa_address;
|
|
break;
|
|
}
|
|
}
|
|
in_dev_put(in_dev);
|
|
}
|
|
if (paddr_eth0 == NULL || paddr_eth0_0 == NULL)
|
|
{
|
|
local_irq_restore(flags);
|
|
return -ENODATA;
|
|
}
|
|
|
|
/* find pointer to IP address of veth0 */
|
|
if ((in_dev=in_dev_get(net_devs[SVIP_NET_DEV_VETH0_IDX])) != NULL)
|
|
{
|
|
for (ifa = in_dev->ifa_list; ifa != NULL; ifa = ifa->ifa_next)
|
|
{
|
|
if (ifa->ifa_address != 0)
|
|
{
|
|
paddr_veth0 = &ifa->ifa_address;
|
|
pmask_veth0 = &ifa->ifa_mask;
|
|
break;
|
|
}
|
|
}
|
|
in_dev_put(in_dev);
|
|
}
|
|
if (paddr_veth0 == NULL)
|
|
{
|
|
local_irq_restore(flags);
|
|
return -ENODATA;
|
|
}
|
|
|
|
MOD_INC_USE_COUNT;
|
|
nDeviceOpen++;
|
|
local_irq_restore(flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
This function is called when a process closes the SVIP NAT device file
|
|
|
|
\arguments
|
|
inode - pointer to disk file data
|
|
file - pointer to device file data
|
|
|
|
\return
|
|
0 on success, else -1
|
|
|
|
*/
|
|
/******************************************************************************/
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
|
|
static int SVIP_NAT_device_release(struct inode *inode,
|
|
struct file *file)
|
|
#else
|
|
static void SVIP_NAT_device_release(struct inode *inode,
|
|
struct file *file)
|
|
#endif
|
|
{
|
|
unsigned long flags;
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
save_flags(flags);
|
|
cli();
|
|
#else
|
|
local_save_flags(flags);
|
|
#endif
|
|
|
|
/* The device can now be openned by the next caller */
|
|
nDeviceOpen--;
|
|
|
|
MOD_DEC_USE_COUNT;
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
restore_flags(flags);
|
|
#else
|
|
local_irq_restore(flags);
|
|
#endif
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
This function is called when a process closes the SVIP NAT device file
|
|
|
|
\arguments
|
|
inode - pointer to disk file data
|
|
file - pointer to device file data
|
|
ioctl_num - ioctl number requested
|
|
ioctl_param - pointer to data related to the ioctl number
|
|
|
|
\return
|
|
0 on success, else -1
|
|
|
|
*/
|
|
/******************************************************************************/
|
|
long SVIP_NAT_device_ioctl (struct file *file,
|
|
unsigned int ioctl_num, unsigned long ioctl_param)
|
|
{
|
|
int ret = 0;
|
|
SVIP_NAT_IO_Rule_t *pNatRule, *pNatRuleIn;
|
|
SVIP_UDP_PORT_t nPort;
|
|
int nNatIdx;
|
|
int bWrite = 0;
|
|
int bRead = 0;
|
|
unsigned char *pData = 0;
|
|
int nSize;
|
|
|
|
if (_IOC_DIR(ioctl_num) & _IOC_WRITE)
|
|
bWrite = 1;
|
|
if (_IOC_DIR(ioctl_num) & _IOC_READ)
|
|
bRead = 1;
|
|
nSize = _IOC_SIZE(ioctl_num);
|
|
|
|
if (nSize > sizeof(int))
|
|
{
|
|
if (bRead || bWrite)
|
|
{
|
|
pData = kmalloc (nSize, GFP_KERNEL);
|
|
if (bWrite)
|
|
{
|
|
if (copy_from_user ((void *)pData, (void *)ioctl_param, nSize) != 0)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: ioctl %x: copy_from_user() failed!\n", ioctl_num);
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (ioctl_num)
|
|
{
|
|
case FIO_SVIP_NAT_RULE_ADD:
|
|
|
|
pNatRuleIn = (SVIP_NAT_IO_Rule_t *)pData;
|
|
|
|
/* check if destination UDP port is within range */
|
|
nPort = ntohs(pNatRuleIn->locUDP);
|
|
|
|
if (!SVIP_PORT_INRANGE(nPort))
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: Error, UDP port(%d) is out of range(%d..%d)\n",
|
|
nPort, SVIP_UDP_FROM, SVIP_UDP_TO);
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
nNatIdx = SVIP_PORT_INDEX(nPort);
|
|
|
|
down(sem_nat_tbl_access);
|
|
pNatRule = &pNatTable[nNatIdx].natRule;
|
|
|
|
/* add rule to the NAT table */
|
|
pNatRule->remIP = pNatRuleIn->remIP;
|
|
memcpy((char *)pNatRule->remMAC, (char *)pNatRuleIn->remMAC, ETH_ALEN);
|
|
pNatRule->locIP = pNatRuleIn->locIP;
|
|
memcpy((char *)pNatRule->locMAC, (char *)pNatRuleIn->locMAC, ETH_ALEN);
|
|
pNatRule->locUDP = pNatRuleIn->locUDP;
|
|
|
|
memset(pNatTable[nNatIdx].natStats, 0,
|
|
sizeof(SVIP_NAT_stats_t)*SVIP_NAT_STATS_TYPES);
|
|
up(sem_nat_tbl_access);
|
|
break;
|
|
|
|
case FIO_SVIP_NAT_RULE_REMOVE:
|
|
|
|
pNatRuleIn = (SVIP_NAT_IO_Rule_t *)pData;
|
|
|
|
/* check if destination UDP port is within range */
|
|
nPort = ntohs(pNatRuleIn->locUDP);
|
|
if (!SVIP_PORT_INRANGE(nPort))
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: Error, UDP port(%d) is out of range(%d..%d)\n",
|
|
nPort, SVIP_UDP_FROM, SVIP_UDP_TO);
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
nNatIdx = SVIP_PORT_INDEX(nPort);
|
|
down(sem_nat_tbl_access);
|
|
/* remove rule from the NAT table */
|
|
memset(&pNatTable[nNatIdx], 0, sizeof(SVIP_NAT_table_entry_t));
|
|
up(sem_nat_tbl_access);
|
|
break;
|
|
|
|
case FIO_SVIP_NAT_RULE_LIST:
|
|
{
|
|
int len;
|
|
char buf[256];
|
|
|
|
down(sem_nat_tbl_access);
|
|
while (nProcReadIdx != -1)
|
|
{
|
|
len = SVIP_NAT_ProcReadNAT(buf, 256);
|
|
if (len > 0)
|
|
printk("%s", buf);
|
|
}
|
|
nProcReadIdx = 0;
|
|
up(sem_nat_tbl_access);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
printk(KERN_ERR "SVIP NAT: unsupported ioctl (%x) command for device %s\n",
|
|
ioctl_num, PATH_SVIP_NAT_DEVICE_NAME);
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
|
|
if (nSize > sizeof(int))
|
|
{
|
|
if (bRead)
|
|
{
|
|
if (copy_to_user ((void *)ioctl_param, (void *)pData, nSize) != 0)
|
|
{
|
|
printk(KERN_ERR "SVIP NAT: ioctl %x: copy_to_user() failed!\n", ioctl_num);
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
}
|
|
}
|
|
|
|
error:
|
|
if (pData)
|
|
kfree(pData);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#if 0
|
|
void dump_msg(unsigned char *pData, unsigned int nLen)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<nLen; i++)
|
|
{
|
|
if (!i || !(i%16))
|
|
printk("\n ");
|
|
else if (i && !(i%4))
|
|
printk(" ");
|
|
printk("%02x", pData[i]);
|
|
}
|
|
if (--i%16)
|
|
printk("\n");
|
|
}
|
|
#endif
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Used to recalculate IP/UDP checksum using the original IP/UDP checksum
|
|
coming with the packet. The original source and destination IP addresses
|
|
are accounted for, and, the checksum is updated using the new source and
|
|
destination IP addresses.
|
|
|
|
\arguments
|
|
skb - pointer to the receiving socket buffer
|
|
csum_old - original checksum
|
|
saddr_old - pointer to original source IP address
|
|
saddr_new - pointer to new source IP address
|
|
daddr_old - pointer to original destination IP address
|
|
daddr_new - pointer to new destination IP address
|
|
|
|
\return
|
|
recalculated IP/UDP checksum
|
|
*/
|
|
/******************************************************************************/
|
|
static inline u16 ip_udp_quick_csum(u16 csum_old, u16 *saddr_old, u16 *saddr_new,
|
|
u16 *daddr_old, u16 *daddr_new)
|
|
{
|
|
u32 sum;
|
|
|
|
sum = csum_old;
|
|
|
|
/* convert back from one's complement */
|
|
sum = ~sum & 0xffff;
|
|
|
|
if (sum < saddr_old[0]) sum += 0xffff;
|
|
sum -= saddr_old[0];
|
|
if (sum < saddr_old[1]) sum += 0xffff;
|
|
sum -= saddr_old[1];
|
|
if (sum < daddr_old[0]) sum += 0xffff;
|
|
sum -= daddr_old[0];
|
|
if (sum < daddr_old[1]) sum += 0xffff;
|
|
sum -= daddr_old[1];
|
|
|
|
sum += saddr_new[0];
|
|
sum += saddr_new[1];
|
|
sum += daddr_new[0];
|
|
sum += daddr_new[1];
|
|
|
|
/* take only 16 bits out of the 32 bit sum and add up the carries */
|
|
while (sum >> 16)
|
|
sum = (sum & 0xffff)+((sum >> 16) & 0xffff);
|
|
|
|
/* one's complement the result */
|
|
sum = ~sum;
|
|
|
|
return (u16)(sum & 0xffff);
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Returns a pointer to an ipv4 address assigned to device dev. The ipv4
|
|
instance checked is pointed to by ifa_start. The function is suited for
|
|
itterative calls.
|
|
|
|
\arguments
|
|
dev - pointer to network interface
|
|
ifa_start - pointer to ipv4 instance to return ipv4 address assigned
|
|
to, NULL for the first one
|
|
ppifa_addr - output parameter
|
|
|
|
\return
|
|
pointer to the next ipv4 instance, which can be null if ifa_start was
|
|
the last instance present
|
|
*/
|
|
/******************************************************************************/
|
|
static struct in_ifaddr *get_ifaddr(struct net_device *dev,
|
|
struct in_ifaddr *ifa_start, unsigned int **ppifa_addr)
|
|
{
|
|
struct in_device *in_dev;
|
|
struct in_ifaddr *ifa = NULL;
|
|
|
|
if ((in_dev=in_dev_get(dev)) != NULL)
|
|
{
|
|
if (ifa_start == NULL)
|
|
ifa = in_dev->ifa_list;
|
|
else
|
|
ifa = ifa_start;
|
|
if (ifa)
|
|
{
|
|
*ppifa_addr = &ifa->ifa_address;
|
|
ifa = ifa->ifa_next;
|
|
}
|
|
in_dev_put(in_dev);
|
|
return ifa;
|
|
}
|
|
*ppifa_addr = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
This function performs IP NAT for received packets satisfying the
|
|
following requirements:
|
|
|
|
- packet is destined to local IP host
|
|
- transport protocol type is UDP
|
|
- destination UDP port is within range
|
|
|
|
\arguments
|
|
skb - pointer to the receiving socket buffer
|
|
|
|
\return
|
|
returns 1 on performed SVIP NAT, else returns 0
|
|
|
|
\remarks
|
|
When function returns 0, it indicates the caller to pass the
|
|
packet up the IP stack to make further decision about it
|
|
*/
|
|
/******************************************************************************/
|
|
int do_SVIP_NAT (struct sk_buff *skb)
|
|
{
|
|
struct net_device *real_dev;
|
|
struct iphdr *iph;
|
|
struct udphdr *udph;
|
|
SVIP_NAT_IO_Rule_t *pNatRule;
|
|
int nNatIdx, in_eth0, nDir;
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
int vlan;
|
|
unsigned short vid;
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
SVIP_UDP_PORT_t nPort;
|
|
u32 orgSrcIp, orgDstIp, *pSrcIp, *pDstIp;
|
|
struct ethhdr *ethh;
|
|
|
|
/* do not consider if SVIP NAT device not open. */
|
|
if (!nDeviceOpen)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* consider only UDP packets. */
|
|
iph = SVIP_NAT_IP_HDR(skb);
|
|
if (iph->protocol != IPPROTO_UDP)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
udph = (struct udphdr *)((u_int32_t *)iph + iph->ihl);
|
|
/* consider only packets which UDP port numbers reside within
|
|
the predefined SVIP NAT UDP port range. */
|
|
if ((!SVIP_PORT_INRANGE(ntohs(udph->dest))) &&
|
|
(!SVIP_PORT_INRANGE(ntohs(udph->source))))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
/* check if packet delivered over VLAN. VLAN packets will be routed over
|
|
the VLAN interfaces of the respective real Ethernet interface, if one
|
|
exists(VIDs must match). Else, the packet will be send out as IEEE 802.3
|
|
Ethernet frame */
|
|
if (skb->dev->priv_flags & IFF_802_1Q_VLAN)
|
|
{
|
|
vlan = 1;
|
|
vid = VLAN_DEV_VLAN_ID(skb->dev);
|
|
real_dev = VLAN_DEV_REAL_DEV(skb->dev);
|
|
}
|
|
else
|
|
{
|
|
vlan = 0;
|
|
vid = 0;
|
|
real_dev = skb->dev;
|
|
}
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
|
|
#ifdef CONFIG_SVIP_FW_PKT_SNIFFER
|
|
/** Debugging feature which can be enabled by writing,
|
|
'echo 1 > /proc/net/svip_nat/snifferOnOff'.
|
|
It copies all packets received on veth0 and, sends them out over eth0.
|
|
When a destination MAC address is specified through
|
|
/proc/net/svip_nat/snifferMAC, this MAC addess will substitute the
|
|
original MAC address of the packet.
|
|
It is recommended to specify a MAC address of some host where Wireshark
|
|
runs and sniffs for this traffic, else you may flood your LAN with
|
|
undeliverable traffic.
|
|
|
|
NOTE: In case of VLAN traffic the VLAN header information is lost. */
|
|
if (nSVIP_NAT_Sniffer)
|
|
{
|
|
if (real_dev == net_devs[SVIP_NET_DEV_VETH0_IDX])
|
|
{
|
|
struct sk_buff *copied_skb;
|
|
|
|
/* gain the Ethernet header from the skb */
|
|
skb_push(skb, ETH_HLEN);
|
|
|
|
copied_skb = skb_copy (skb, GFP_ATOMIC);
|
|
|
|
if (nSVIP_NAT_SnifferMacSet == 1)
|
|
{
|
|
ethh = (struct ethhdr *)SVIP_NAT_SKB_MAC_HEADER(copied_skb);
|
|
memcpy((char *)ethh->h_dest, (char *)pSVIP_NAT_SnifferMAC, ETH_ALEN);
|
|
}
|
|
copied_skb->dev = net_devs[SVIP_NET_DEV_ETH0_IDX];
|
|
dev_queue_xmit(copied_skb);
|
|
|
|
/* skip the ETH header again */
|
|
skb_pull(skb, ETH_HLEN);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/* check if packet arrived on eth0 */
|
|
if (real_dev == net_devs[SVIP_NET_DEV_ETH0_IDX])
|
|
{
|
|
/* check if destination IP address equals the primary assigned IP address
|
|
of interface eth0. This is the case of packets originating from a
|
|
remote peer that are to be delivered to a channel residing on THIS
|
|
voice linecard system. This is typical SVIP NAT case, therefore this
|
|
rule is placed on top. */
|
|
if (iph->daddr == *paddr_eth0)
|
|
{
|
|
nPort = ntohs(udph->dest);
|
|
nDir = SVIP_NAT_STATS_REM2LOC;
|
|
}
|
|
/* check if destination IP address equals the secondary assigned IP address
|
|
of interface eth0. This is not a typical SVIP NAT case. It is basically
|
|
there, as someone might like for debugging purpose to use the LCC to route
|
|
Slave SVIP packets which are part of voice/fax streaming. */
|
|
else if (iph->daddr == *paddr_eth0_0)
|
|
{
|
|
nPort = ntohs(udph->source);
|
|
nDir = SVIP_NAT_STATS_LOC2REM;
|
|
}
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
/* when the packet did not hit the top two rules, here we check if the packet
|
|
has addressed any of the IP addresses assigned to the VLAN interface attached
|
|
to eth0. This is not recommended approach because of the CPU cost incurred. */
|
|
else if (vlan)
|
|
{
|
|
unsigned int *pifa_addr;
|
|
struct in_ifaddr *ifa_start = NULL;
|
|
int i = 0;
|
|
|
|
do
|
|
{
|
|
ifa_start = get_ifaddr(skb->dev, ifa_start, &pifa_addr);
|
|
if (!pifa_addr)
|
|
{
|
|
/* VLAN packet received on vlan interface attached to eth0,
|
|
however no IP address assigned to the interface.
|
|
The packet is ignored. */
|
|
return 0;
|
|
}
|
|
if (iph->daddr == *pifa_addr)
|
|
{
|
|
/* packet destined to... */
|
|
break;
|
|
}
|
|
if (!ifa_start)
|
|
{
|
|
return 0;
|
|
}
|
|
i++;
|
|
} while (ifa_start);
|
|
if (!i)
|
|
{
|
|
/* ...primary assigned IP address to the VLAN interface. */
|
|
nPort = ntohs(udph->dest);
|
|
nDir = SVIP_NAT_STATS_REM2LOC;
|
|
}
|
|
else
|
|
{
|
|
/* ...secondary assigned IP address to the VLAN interface. */
|
|
nPort = ntohs(udph->source);
|
|
nDir = SVIP_NAT_STATS_LOC2REM;
|
|
}
|
|
}
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
in_eth0 = 1;
|
|
}
|
|
/* check if packet arrived on veth0 */
|
|
else if (real_dev == net_devs[SVIP_NET_DEV_VETH0_IDX])
|
|
{
|
|
nPort = ntohs(udph->source);
|
|
nDir = SVIP_NAT_STATS_LOC2REM;
|
|
in_eth0 = 0;
|
|
}
|
|
else
|
|
{
|
|
/* packet arrived neither on eth0, nor veth0 */
|
|
return 0;
|
|
}
|
|
|
|
/* calculate the respective index of the NAT table */
|
|
nNatIdx = SVIP_PORT_INDEX(nPort);
|
|
/* process the packet if a respective NAT rule exists */
|
|
pNatRule = &pNatTable[nNatIdx].natRule;
|
|
|
|
ethh = (struct ethhdr *)SVIP_NAT_SKB_MAC_HEADER(skb);
|
|
|
|
/* copy packet's original source and destination IP addresses to use
|
|
later on to perform efficient checksum recalculation */
|
|
orgSrcIp = iph->saddr;
|
|
orgDstIp = iph->daddr;
|
|
|
|
if (in_eth0)
|
|
{
|
|
u8 *pDstMac;
|
|
|
|
/* Process packet arrived on eth0 */
|
|
|
|
if (nDir == SVIP_NAT_STATS_REM2LOC && iph->saddr == pNatRule->remIP)
|
|
{
|
|
pDstIp = &pNatRule->locIP;
|
|
pDstMac = pNatRule->locMAC;
|
|
}
|
|
else if (nDir == SVIP_NAT_STATS_LOC2REM && iph->saddr == pNatRule->locIP)
|
|
{
|
|
pDstIp = &pNatRule->remIP;
|
|
pDstMac = pNatRule->remMAC;
|
|
}
|
|
else
|
|
{
|
|
/* Rule check failed. The packet is passed up the layers,
|
|
it will be dropped by UDP */
|
|
return 0;
|
|
}
|
|
|
|
if ((*pDstIp & *pmask_veth0) == (*paddr_veth0 & *pmask_veth0))
|
|
{
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
if (vlan)
|
|
{
|
|
struct net_device *vlan_dev;
|
|
|
|
spin_lock_bh(&vlan_group_lock);
|
|
vlan_dev = __vlan_find_dev_deep(net_devs[SVIP_NET_DEV_VETH0_IDX], vid);
|
|
spin_unlock_bh(&vlan_group_lock);
|
|
if (vlan_dev)
|
|
{
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
struct vlan_ethhdr *vethh;
|
|
|
|
skb_push(skb, VLAN_ETH_HLEN);
|
|
/* reconstruct the VLAN header.
|
|
NOTE: priority information is lost */
|
|
vethh = (struct vlan_ethhdr *)skb->data;
|
|
vethh->h_vlan_proto = htons(ETH_P_8021Q);
|
|
vethh->h_vlan_TCI = htons(vid);
|
|
vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
|
|
ethh = (struct ethhdr *)vethh;
|
|
#else
|
|
skb_push(skb, ETH_HLEN);
|
|
#endif
|
|
skb->dev = vlan_dev;
|
|
}
|
|
else
|
|
{
|
|
skb->dev = net_devs[SVIP_NET_DEV_VETH0_IDX];
|
|
skb_push(skb, ETH_HLEN);
|
|
}
|
|
}
|
|
else
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
{
|
|
skb->dev = net_devs[SVIP_NET_DEV_VETH0_IDX];
|
|
skb_push(skb, ETH_HLEN);
|
|
}
|
|
pSrcIp = paddr_veth0;
|
|
}
|
|
else
|
|
{
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
if (vlan)
|
|
{
|
|
struct vlan_ethhdr *vethh;
|
|
|
|
/* reconstruct the VLAN header.
|
|
NOTE: priority information is lost */
|
|
skb_push(skb, VLAN_ETH_HLEN);
|
|
vethh = (struct vlan_ethhdr *)skb->data;
|
|
vethh->h_vlan_proto = htons(ETH_P_8021Q);
|
|
vethh->h_vlan_TCI = htons(vid);
|
|
vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
|
|
ethh = (struct ethhdr *)vethh;
|
|
}
|
|
else
|
|
#endif
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
{
|
|
skb_push(skb, ETH_HLEN);
|
|
}
|
|
/* source IP address equals the destination IP address
|
|
of the incoming packet */
|
|
pSrcIp = &iph->daddr;
|
|
}
|
|
iph->saddr = *pSrcIp;
|
|
memcpy((char *)ethh->h_source, (char *)skb->dev->dev_addr, ETH_ALEN);
|
|
iph->daddr = *pDstIp;
|
|
memcpy((char *)ethh->h_dest, (char *)pDstMac, ETH_ALEN);
|
|
}
|
|
else
|
|
{
|
|
/* Process packet arrived on veth0 */
|
|
|
|
if (iph->saddr != pNatRule->locIP)
|
|
{
|
|
/* Rule check failed. The packet is passed up the layers,
|
|
it will be dropped by UDP */
|
|
return 0;
|
|
}
|
|
|
|
if (!((pNatRule->remIP & *pmask_veth0) == (*paddr_veth0 & *pmask_veth0)))
|
|
{
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
if (vlan)
|
|
{
|
|
struct net_device *vlan_dev;
|
|
|
|
spin_lock_bh(&vlan_group_lock);
|
|
vlan_dev = __vlan_find_dev_deep(net_devs[SVIP_NET_DEV_ETH0_IDX], vid);
|
|
spin_unlock_bh(&vlan_group_lock);
|
|
if (vlan_dev)
|
|
{
|
|
unsigned int *pifa_addr;
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
struct vlan_ethhdr *vethh;
|
|
|
|
skb_push(skb, VLAN_ETH_HLEN);
|
|
/* construct the VLAN header, note priority information is lost */
|
|
vethh = (struct vlan_ethhdr *)skb->data;
|
|
vethh->h_vlan_proto = htons(ETH_P_8021Q);
|
|
vethh->h_vlan_TCI = htons(vid);
|
|
vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
|
|
ethh = (struct ethhdr *)vethh;
|
|
#else
|
|
skb_push(skb, ETH_HLEN);
|
|
#endif
|
|
skb->dev = vlan_dev;
|
|
|
|
get_ifaddr(skb->dev, NULL, &pifa_addr);
|
|
if (pifa_addr)
|
|
{
|
|
pSrcIp = pifa_addr;
|
|
}
|
|
else
|
|
{
|
|
pSrcIp = paddr_eth0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
skb->dev = net_devs[SVIP_NET_DEV_ETH0_IDX];
|
|
pSrcIp = paddr_eth0;
|
|
skb_push(skb, ETH_HLEN);
|
|
}
|
|
}
|
|
else
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
{
|
|
skb->dev = net_devs[SVIP_NET_DEV_ETH0_IDX];
|
|
pSrcIp = paddr_eth0;
|
|
skb_push(skb, ETH_HLEN);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSrcIp = paddr_veth0;
|
|
#ifndef VLAN_8021Q_UNUSED
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
if (vlan)
|
|
{
|
|
struct vlan_ethhdr *vethh;
|
|
|
|
skb_push(skb, VLAN_ETH_HLEN);
|
|
/* reconstruct the VLAN header.
|
|
NOTE: priority information is lost. */
|
|
vethh = (struct vlan_ethhdr *)skb->data;
|
|
vethh->h_vlan_proto = htons(ETH_P_8021Q);
|
|
vethh->h_vlan_TCI = htons(vid);
|
|
vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
|
|
ethh = (struct ethhdr *)vethh;
|
|
}
|
|
else
|
|
#endif
|
|
#endif /* ! VLAN_8021Q_UNUSED */
|
|
{
|
|
skb_push(skb, ETH_HLEN);
|
|
}
|
|
}
|
|
iph->saddr = *pSrcIp;
|
|
memcpy((char *)ethh->h_source, (char *)skb->dev->dev_addr, ETH_ALEN);
|
|
iph->daddr = pNatRule->remIP;
|
|
memcpy((char *)ethh->h_dest, (char *)pNatRule->remMAC, ETH_ALEN);
|
|
}
|
|
pNatTable[nNatIdx].natStats[nDir].inPackets++;
|
|
|
|
iph->check = ip_udp_quick_csum(iph->check, (u16 *)&orgSrcIp, (u16 *)&iph->saddr,
|
|
(u16 *)&orgDstIp, (u16 *)&iph->daddr);
|
|
if (udph->check != 0)
|
|
{
|
|
udph->check = ip_udp_quick_csum(udph->check, (u16 *)&orgSrcIp, (u16 *)&iph->saddr,
|
|
(u16 *)&orgDstIp, (u16 *)&iph->daddr);
|
|
}
|
|
|
|
/* write the packet out, directly to the network device */
|
|
if (dev_queue_xmit(skb) < 0)
|
|
pNatTable[nNatIdx].natStats[nDir].outErrors++;
|
|
else
|
|
pNatTable[nNatIdx].natStats[nDir].outPackets++;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Function executed upon unloading of the SVIP NAT module. It unregisters the
|
|
SVIP NAT configuration device and frees the memory used for the NAT table.
|
|
|
|
\remarks:
|
|
Currently the SVIP NAT module is statically linked into the Linux kernel
|
|
therefore this routine cannot be executed.
|
|
*******************************************************************************/
|
|
static int __init init(void)
|
|
{
|
|
int ret = 0;
|
|
struct net_device *dev;
|
|
|
|
if (misc_register(&SVIP_NAT_miscdev) != 0)
|
|
{
|
|
printk(KERN_ERR "%s: cannot register SVIP NAT device node.\n",
|
|
SVIP_NAT_miscdev.name);
|
|
return -EIO;
|
|
}
|
|
|
|
/* allocation of memory for NAT table */
|
|
pNatTable = (SVIP_NAT_table_entry_t *)kmalloc(
|
|
sizeof(SVIP_NAT_table_entry_t) * SVIP_SYS_CODEC_NUM, GFP_ATOMIC);
|
|
if (pNatTable == NULL)
|
|
{
|
|
printk (KERN_ERR "SVIP NAT: Error(%d), allocating memory for NAT table\n", ret);
|
|
return -1;
|
|
}
|
|
|
|
/* clear the NAT table */
|
|
memset((void *)pNatTable, 0, sizeof(SVIP_NAT_table_entry_t) * SVIP_SYS_CODEC_NUM);
|
|
|
|
if ((sem_nat_tbl_access = kmalloc(sizeof(struct semaphore), GFP_KERNEL)))
|
|
{
|
|
sema_init(sem_nat_tbl_access, 1);
|
|
}
|
|
|
|
SVIP_NAT_ProcInstall();
|
|
|
|
/* find pointers to 'struct net_device' of eth0 and veth0, respectevely */
|
|
read_lock(&dev_base_lock);
|
|
SVIP_NAT_FOR_EACH_NETDEV(dev)
|
|
{
|
|
if (!strcmp(dev->name, SVIP_NET_DEV_ETH0_NAME))
|
|
{
|
|
net_devs[SVIP_NET_DEV_ETH0_IDX] = dev;
|
|
}
|
|
if (!strcmp(dev->name, SVIP_NET_DEV_VETH1_NAME))
|
|
{
|
|
net_devs[SVIP_NET_DEV_VETH0_IDX] = dev;
|
|
}
|
|
else if (!strcmp(dev->name, SVIP_NET_DEV_ETH1_NAME))
|
|
{
|
|
net_devs[SVIP_NET_DEV_VETH0_IDX] = dev;
|
|
}
|
|
}
|
|
read_unlock(&dev_base_lock);
|
|
|
|
if (net_devs[SVIP_NET_DEV_ETH0_IDX] == NULL ||
|
|
net_devs[SVIP_NET_DEV_VETH0_IDX] == NULL)
|
|
{
|
|
printk (KERN_ERR "SVIP NAT: Error, unable to locate eth0 and veth0 interfaces\n");
|
|
return -1;
|
|
}
|
|
|
|
printk ("%s, (c) 2009, Lantiq Deutschland GmbH\n", &SVIP_NAT_INFO_STR[4]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
Function executed upon unloading of the SVIP NAT module. It unregisters the
|
|
SVIP NAT configuration device and frees the memory used for the NAT table.
|
|
|
|
\remarks:
|
|
Currently the SVIP NAT module is statically linked into the Linux kernel
|
|
therefore this routine cannot be executed.
|
|
*******************************************************************************/
|
|
static void __exit fini(void)
|
|
{
|
|
MOD_DEC_USE_COUNT;
|
|
|
|
/* unregister SVIP NAT configuration device */
|
|
misc_deregister(&SVIP_NAT_miscdev);
|
|
|
|
/* release memory of SVIP NAT table */
|
|
if (pNatTable != NULL)
|
|
{
|
|
kfree (pNatTable);
|
|
}
|
|
}
|
|
|
|
module_init(init);
|
|
module_exit(fini);
|