path: root/target/linux/lantiq/files/net/ipv4/svip_nat.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);