projects / openwrt / svn-archive / archive.git / blob
? search:


04a0d223a216cb5d43da213cc0b870a99bcb966a
[openwrt/svn-archive/archive.git] / target / linux / lantiq / files-3.3 / net / ipv4 / svip_nat.c
1 /******************************************************************************
2
3 Copyright (c) 2009
4 Lantiq Deutschland GmbH
5 Am Campeon 3; 81726 Munich, Germany
6
7 THE DELIVERY OF THIS SOFTWARE AS WELL AS THE HEREBY GRANTED NON-EXCLUSIVE,
8 WORLDWIDE LICENSE TO USE, COPY, MODIFY, DISTRIBUTE AND SUBLICENSE THIS
9 SOFTWARE IS FREE OF CHARGE.
10
11 THE LICENSED SOFTWARE IS PROVIDED "AS IS" AND INFINEON EXPRESSLY DISCLAIMS
12 ALL REPRESENTATIONS AND WARRANTIES, WHETHER EXPRESS OR IMPLIED, INCLUDING
13 WITHOUT LIMITATION, WARRANTIES OR REPRESENTATIONS OF WORKMANSHIP,
14 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, DURABILITY, THAT THE
15 OPERATING OF THE LICENSED SOFTWARE WILL BE ERROR FREE OR FREE OF ANY THIRD
16 PARTY CLAIMS, INCLUDING WITHOUT LIMITATION CLAIMS OF THIRD PARTY INTELLECTUAL
17 PROPERTY INFRINGEMENT.
18
19 EXCEPT FOR ANY LIABILITY DUE TO WILFUL ACTS OR GROSS NEGLIGENCE AND EXCEPT
20 FOR ANY PERSONAL INJURY INFINEON SHALL IN NO EVENT BE LIABLE FOR ANY CLAIM
21 OR DAMAGES OF ANY KIND, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 DEALINGS IN THE SOFTWARE.
24
25 ****************************************************************************
26
27 Description : This file contains implementation of Custom NAT function
28 for Infineon's VINETIC-SVIP16
29 *******************************************************************************/
30
31 #include <linux/module.h>
32 #include <linux/netfilter_ipv4.h>
33 #include <linux/if_ether.h>
34 #include <linux/netdevice.h>
35 #include <linux/inetdevice.h>
36 #include <linux/in.h>
37 #include <linux/ip.h>
38 #include <linux/if_vlan.h>
39 #include <linux/udp.h>
40 #include <linux/kernel.h>
41 #include <linux/version.h>
42 #include <linux/proc_fs.h>
43 #include <linux/in6.h> /* just to shut up a warning */
44 #include <linux/miscdevice.h>
45 #include <asm/checksum.h>
46
47 #include <linux/svip_nat.h>
48
49 MODULE_AUTHOR("Lantiq Deutschland GmbH");
50 MODULE_DESCRIPTION("SVIP Network Address Translation module");
51 MODULE_LICENSE("GPL");
52
53 #define SVIP_NAT_INFO_STR "@(#)SVIP NAT, version "SVIP_NAT_VERSION
54
55 /** maximum voice packet channels possible on the SVIP LC system
56 (equals maximum number of Codec channels possible) */
57 #define SVIP_SYS_CODEC_NUM ((SVIP_SYS_NUM) * (SVIP_CODEC_NUM))
58
59 /** end UDP port number of the SVIP Linecard System */
60 #define SVIP_UDP_TO ((SVIP_UDP_FROM) + (SVIP_SYS_CODEC_NUM) - 1)
61
62 /** end UDP port number of the Master SVIP in SVIP Linecard System */
63 #define SVIP_UDP_TO_VOFW0 ((SVIP_UDP_FROM) + (SVIP_CODEC_NUM) - 1)
64
65 #define SVIP_PORT_INRANGE(nPort) \
66 ((nPort) >= (SVIP_UDP_FROM) && (nPort) <= (SVIP_UDP_TO))
67
68 #define SVIP_PORT_INDEX(nPort) (nPort - SVIP_UDP_FROM)
69
70 #define SVIP_NET_DEV_ETH0_IDX 0
71 #define SVIP_NET_DEV_VETH0_IDX 1
72 #define SVIP_NET_DEV_LO_IDX 2
73
74 #define SVIP_NET_DEV_ETH0_NAME "eth0"
75 #define SVIP_NET_DEV_ETH1_NAME "eth1"
76 #define SVIP_NET_DEV_VETH1_NAME "veth0"
77 #define SVIP_NET_DEV_LO_NAME "lo"
78
79 #define SVIP_NAT_STATS_LOC2REM 0
80 #define SVIP_NAT_STATS_REM2LOC 1
81 #define SVIP_NAT_STATS_TYPES 2
82
83 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
84 #define SVIP_NAT_FOR_EACH_NETDEV(d) for_each_netdev(&init_net, dev)
85 #define SVIP_NAT_IP_HDR(ethhdr) ip_hdr(ethhdr)
86 #else
87 #define SVIP_NAT_FOR_EACH_NETDEV(d) for(d=dev_base; dev; dev = dev->next)
88 #define SVIP_NAT_IP_HDR(ethhdr) (ethhdr)->nh.iph
89 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
90
91 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
92 #define SVIP_NAT_SKB_MAC_HEADER(ethhdr) (ethhdr)->mac.ethernet
93 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
94 #define SVIP_NAT_SKB_MAC_HEADER(ethhdr) (ethhdr)->mac.raw
95 #else
96 #define SVIP_NAT_SKB_MAC_HEADER(ethhdr) skb_mac_header(ethhdr)
97 #endif
98
99 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
100 #define VLAN_DEV_REAL_DEV(dev) vlan_dev_real_dev(dev)
101 #define VLAN_DEV_VLAN_ID(dev) vlan_dev_vlan_id(dev)
102 #else
103 #define VLAN_DEV_REAL_DEV(dev) (VLAN_DEV_INFO(dev)->real_dev)
104 #define VLAN_DEV_VLAN_ID(dev) (VLAN_DEV_INFO(dev)->vlan_id)
105 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
106
107 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
108 #define MOD_INC_USE_COUNT
109 #define MOD_DEC_USE_COUNT
110 #endif
111
112 #if ! ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)) && \
113 (defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)))
114 #define VLAN_8021Q_UNUSED
115 #endif
116
117
118 extern spinlock_t vlan_group_lock;
119 extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev, unsigned short VID);
120
121 typedef struct SVIP_NAT_stats
122 {
123 unsigned long inPackets;
124 unsigned long outPackets;
125 unsigned long outErrors;
126 } SVIP_NAT_stats_t;
127
128 typedef struct SVIP_NAT_table_entry
129 {
130 SVIP_NAT_IO_Rule_t natRule;
131 SVIP_NAT_stats_t natStats[SVIP_NAT_STATS_TYPES];
132 } SVIP_NAT_table_entry_t;
133
134 /* pointer to the SVIP NAT table */
135 static SVIP_NAT_table_entry_t *pNatTable = NULL;
136
137 struct net_device *net_devs[3];
138 static u32 *paddr_eth0;
139 static u32 *paddr_eth0_0;
140 static u32 *paddr_veth0;
141 static u32 *pmask_veth0;
142
143 static struct semaphore *sem_nat_tbl_access;
144 static int proc_read_in_progress = 0;
145
146 static int nDeviceOpen = 0;
147
148 /* saves the NAT table index between subsequent invocation */
149 static int nProcReadIdx = 0;
150
151 static long SVIP_NAT_device_ioctl(struct file *,unsigned int ,unsigned long);
152 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
153 static int SVIP_NAT_device_release (struct inode *,struct file *);
154 #else
155 static void SVIP_NAT_device_release (struct inode *,struct file *);
156 #endif
157 static int SVIP_NAT_device_open (struct inode *,struct file *);
158
159 /* This structure holds the interface functions supported by
160 the SVIP NAT configuration device. */
161 struct file_operations SVIP_NAT_Fops = {
162 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
163 owner: THIS_MODULE,
164 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0) */
165 llseek: NULL, /* seek */
166 read: NULL,
167 write: NULL,
168 readdir: NULL, /* readdir */
169 poll: NULL, /* select */
170 unlocked_ioctl: SVIP_NAT_device_ioctl, /* ioctl */
171 mmap: NULL, /* mmap */
172 open: SVIP_NAT_device_open, /* open, */
173 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
174 flush: NULL, /* flush */
175 #endif
176 release: SVIP_NAT_device_release /* close */
177 };
178
179 /** Structure holding MISC module operations */
180 static struct miscdevice SVIP_NAT_miscdev =
181 {
182 minor: MINOR_NUM_SVIP_NAT,
183 name: SVIP_NAT_DEVICE_NAME,
184 fops: &SVIP_NAT_Fops
185 };
186
187 #ifdef CONFIG_SVIP_FW_PKT_SNIFFER
188 int nSVIP_NAT_Sniffer;
189 unsigned char pSVIP_NAT_SnifferMAC[ETH_ALEN];
190 int nSVIP_NAT_SnifferMacSet;
191 #endif
192
193 /******************************************************************************/
194 /**
195 Function to read /proc/net/svip_nat/nat proc entry
196
197 \arguments
198 page - pointer to page buffer
199 start - pointer to start address pointer
200 off - offset
201 count - maximum data length to read
202 eof - end of file flag
203 data - proc read data (provided by the function
204 pointed to by data)
205
206 \return
207 length of read data
208
209 \remarks:
210 Each call of this routine forces a copy_to_user of the data returned by
211 'fn'. This routine will be called by the user until 'len = 0'.
212 ****************************************************************************/
213 static int SVIP_NAT_ProcRead (char *page, char **start, off_t off,
214 int count, int *eof, void *data)
215 {
216 unsigned long flags;
217 int (*fn)(char *buf, int size);
218 int len;
219
220 /* If the NAT table index is negative, the reading has completed */
221 if (nProcReadIdx < 0)
222 {
223 nProcReadIdx = 0;
224 *eof = 1;
225 proc_read_in_progress = 0;
226 up(sem_nat_tbl_access);
227 return 0;
228 }
229
230 local_irq_save(flags);
231 if (!proc_read_in_progress)
232 {
233 proc_read_in_progress = 1;
234 local_irq_restore(flags);
235 /* we use this semaphore in order to ensure no other party(could be ioctl
236 FIO_SVIP_NAT_RULE_LIST), uses function SVIP_NAT_ProcReadNAT(), during
237 the time read of the proc file takes place */
238 down(sem_nat_tbl_access);
239 }
240 else
241 {
242 local_irq_restore(flags);
243 }
244
245 if (data != NULL)
246 {
247 fn = data;
248 len = fn (page, count);
249 /* In this setup each read of the proc entries returns the read data by
250 'fn' to the user. The user keeps issuing read requests as long as the
251 returned value of 'len' is greater than zero. */
252 *eof = 1;
253 *start = page;
254 }
255 else
256 {
257 len = 0;
258 }
259
260 return len;
261 }
262
263 #ifdef CONFIG_SVIP_FW_PKT_SNIFFER
264 /**
265 Function to read remaining proc entries
266 */
267 static int SVIP_NAT_ProcReadGen (char *page, char **start, off_t off,
268 int count, int *eof, void *data)
269 {
270 int (*fn)(char *buf, int size);
271 int len = 0;
272
273 MOD_INC_USE_COUNT;
274
275 if (data == NULL)
276 {
277 MOD_DEC_USE_COUNT;
278 return 0;
279 }
280
281 fn = data;
282 len = fn (page, count);
283
284 if (len <= off + count)
285 {
286 *eof = 1;
287 }
288 *start = page + off;
289 len -= off;
290 if (len > count)
291 {
292 len = count;
293 }
294 if (len < 0)
295 {
296 len = 0;
297 }
298
299 MOD_DEC_USE_COUNT;
300
301 return len;
302 }
303 #endif
304
305 /******************************************************************************/
306 /**
307 Function for setting up /proc/net/svip_nat read data
308
309 \arguments
310 buf - pointer to read buffer
311 count - size of read buffer
312
313 \return
314 length of read data into buffer
315
316 \remarks:
317 The global variable 'nProcReadIdx' is used to save the table index where
318 the reading of the NAT table stopped. Reading is stopped when the end of
319 the read buffer is approached. On the next itteration the reading continues
320 from the saved index.
321 *******************************************************************************/
322 static int SVIP_NAT_ProcReadNAT(char *buf, int count)
323 {
324 int i, j;
325 int len = 0;
326 SVIP_NAT_IO_Rule_t *pNatRule;
327
328 if (nProcReadIdx == -1)
329 {
330 nProcReadIdx = 0;
331 return 0;
332 }
333
334 if (nProcReadIdx == 0)
335 {
336 len = sprintf(buf+len,
337 "Remote host IP " /* 16 char */
338 "Remote host MAC " /* 19 char */
339 "Local host IP " /* 15 char */
340 "Local host MAC " /* 19 char */
341 "Local host UDP " /* 16 char */
342 "Loc->Rem(in/out/err) " /* 22 char */
343 "Rem->Loc(in/out/err)\n\r");
344 }
345
346 for (i = nProcReadIdx; i < SVIP_SYS_CODEC_NUM; i++)
347 {
348 int slen;
349
350 pNatRule = &pNatTable[i].natRule;
351
352 if (pNatRule->remIP != 0)
353 {
354 /* make sure not to overwrite the buffer */
355 if (count < len+120)
356 break;
357
358 /* remIP */
359 slen = sprintf(buf+len, "%d.%d.%d.%d",
360 (int)((pNatRule->remIP >> 24) & 0xff),
361 (int)((pNatRule->remIP >> 16) & 0xff),
362 (int)((pNatRule->remIP >> 8) & 0xff),
363 (int)((pNatRule->remIP >> 0) & 0xff));
364 len += slen;
365 for (j = 0; j < (16-slen); j++)
366 len += sprintf(buf+len, " ");
367
368 /* remMAC */
369 slen = 0;
370 for (j = 0; j < ETH_ALEN; j++)
371 {
372 slen += sprintf(buf+len+slen, "%02x%s",
373 pNatRule->remMAC[j], j < ETH_ALEN-1 ? ":" : " ");
374 }
375 len += slen;
376 for (j = 0; j < (19-slen); j++)
377 len += sprintf(buf+len, " ");
378
379 /* locIP */
380 slen = sprintf(buf+len, "%d.%d.%d.%d",
381 (int)((pNatRule->locIP >> 24) & 0xff),
382 (int)((pNatRule->locIP >> 16) & 0xff),
383 (int)((pNatRule->locIP >> 8) & 0xff),
384 (int)((pNatRule->locIP >> 0) & 0xff));
385 len += slen;
386 for (j = 0; j < (15-slen); j++)
387 len += sprintf(buf+len, " ");
388
389 /* locMAC */
390 slen = 0;
391 for (j = 0; j < ETH_ALEN; j++)
392 {
393 slen += sprintf(buf+len+slen, "%02x%s",
394 pNatRule->locMAC[j], j < ETH_ALEN-1 ? ":" : " ");
395 }
396 len += slen;
397 for (j = 0; j < (19-slen); j++)
398 len += sprintf(buf+len, " ");
399
400 /* locUDP */
401 slen = sprintf(buf+len, "%d", pNatRule->locUDP);
402 len += slen;
403 for (j = 0; j < (16-slen); j++)
404 len += sprintf(buf+len, " ");
405
406 /* NAT statistics, Local to Remote translation */
407 slen = sprintf(buf+len, "(%ld/%ld/%ld)",
408 pNatTable[i].natStats[SVIP_NAT_STATS_LOC2REM].inPackets,
409 pNatTable[i].natStats[SVIP_NAT_STATS_LOC2REM].outPackets,
410 pNatTable[i].natStats[SVIP_NAT_STATS_LOC2REM].outErrors);
411 len += slen;
412 for (j = 0; j < (22-slen); j++)
413 len += sprintf(buf+len, " ");
414
415 /* NAT statistics, Remote to Local translation */
416 len += sprintf(buf+len, "(%ld/%ld/%ld)\n\r",
417 pNatTable[i].natStats[SVIP_NAT_STATS_REM2LOC].inPackets,
418 pNatTable[i].natStats[SVIP_NAT_STATS_REM2LOC].outPackets,
419 pNatTable[i].natStats[SVIP_NAT_STATS_REM2LOC].outErrors);
420 }
421 }
422 if (i == SVIP_SYS_CODEC_NUM)
423 nProcReadIdx = -1; /* reading completed */
424 else
425 nProcReadIdx = i; /* reading still in process, buffer was full */
426
427 return len;
428 }
429
430 #ifdef CONFIG_SVIP_FW_PKT_SNIFFER
431 /**
432 Converts MAC address from ascii to hex respesentaion
433 */
434 static int SVIP_NAT_MacAsciiToHex(const char *pMacStr, unsigned char *pMacHex)
435 {
436 int i=0, c=0, b=0, n=0;
437
438 memset(pMacHex, 0, ETH_ALEN);
439 while (pMacStr[i] != '\0')
440 {
441 if (n >= 0)
442 {
443 unsigned char nToHex = 0;
444
445 /* check for hex digit */
446 if (pMacStr[i] >= '0' && pMacStr[i] <= '9')
447 nToHex = 0x30;
448 else if (pMacStr[i] >= 'a' && pMacStr[i] <= 'f')
449 nToHex = 0x57;
450 else if (pMacStr[i] >= 'A' && pMacStr[i] <= 'F')
451 nToHex = 0x37;
452 else
453 {
454 if (n != 0)
455 {
456 printk(KERN_ERR "SVIP NAT: invalid MAC address format[%s]\n", pMacStr);
457 return -1;
458 }
459 i++;
460 continue;
461 }
462 n^=1;
463 pMacHex[b] |= ((pMacStr[i] - nToHex)&0xf) << (4*n);
464 if (n == 0)
465 {
466 /* advance to next byte, check if complete */
467 if (++b >= ETH_ALEN)
468 return 0;
469 /* byte completed, next we expect a colon... */
470 c = 1;
471 /* and, do not check for hex digit */
472 n = -1;
473 }
474 i++;
475 continue;
476 }
477 if (c == 1)
478 {
479 if (pMacStr[i] == ':')
480 {
481 /* next we expect hex digit, again */
482 n = 0;
483 }
484 else
485 {
486 printk(KERN_ERR "SVIP NAT: invalid MAC address format[%s]\n", pMacStr);
487 return -1;
488 }
489 }
490 i++;
491 }
492 return 0;
493 }
494
495 /**
496 Used to set the destination MAC address of a host where incoming
497 SVIP VoFW packets are to be addressed. In case the address is set
498 to 00:00:00:00:00:00 (the default case), the packets will written
499 out to eth0 with its original MAC addess.
500
501 \remark
502 usage: 'echo "00:03:19:00:15:D1" > cat /proc/net/svip_nat/snifferMAC'
503 */
504 int SVIP_NAT_ProcWriteSnifferMAC (struct file *file, const char *buffer,
505 unsigned long count, void *data)
506 {
507 /* at least strlen("xx:xx:xx:xx:xx:xx") characters, followed by '\0' */
508 if (count >= 18)
509 {
510 int ret;
511
512 ret = SVIP_NAT_MacAsciiToHex(buffer, pSVIP_NAT_SnifferMAC);
513
514 if (ret != 0)
515 return 0;
516
517 if (!(pSVIP_NAT_SnifferMAC[0]==0 && pSVIP_NAT_SnifferMAC[1]==0 &&
518 pSVIP_NAT_SnifferMAC[2]==0 && pSVIP_NAT_SnifferMAC[3]==0 &&
519 pSVIP_NAT_SnifferMAC[4]==0 && pSVIP_NAT_SnifferMAC[5]==0))
520 {
521 nSVIP_NAT_SnifferMacSet = 1;
522 }
523 }
524 return count;
525 }
526
527 /**
528 Used to read the destination MAC address of a sniffer host
529 */
530 int SVIP_NAT_ProcReadSnifferMAC (char *buf, int count)
531 {
532 int len = 0;
533
534 len = snprintf(buf, count, "%02x:%02x:%02x:%02x:%02x:%02x\n",
535 pSVIP_NAT_SnifferMAC[0], pSVIP_NAT_SnifferMAC[1],
536 pSVIP_NAT_SnifferMAC[2], pSVIP_NAT_SnifferMAC[3],
537 pSVIP_NAT_SnifferMAC[4], pSVIP_NAT_SnifferMAC[5]);
538
539 if (len > count)
540 {
541 printk(KERN_ERR "SVIP NAT: Only part of the text could be put into the buffer\n");
542 return count;
543 }
544
545 return len;
546 }
547
548 /**
549 Used to switch VoFW message sniffer on/off
550
551 \remark
552 usage: 'echo "1" > cat /proc/net/svip_nat/snifferOnOff'
553 */
554 int SVIP_NAT_ProcWriteSnifferOnOff (struct file *file, const char *buffer,
555 unsigned long count, void *data)
556 {
557 /* at least one digit expected, followed by '\0' */
558 if (count >= 2)
559 {
560 int ret, nSnifferOnOff;
561
562 ret = sscanf(buffer, "%d", &nSnifferOnOff);
563
564 if (ret != 1)
565 return count;
566
567 if (nSnifferOnOff > 0)
568 nSnifferOnOff = 1;
569
570 nSVIP_NAT_Sniffer = nSnifferOnOff;
571 }
572 return count;
573 }
574
575 /**
576 Used to read the VoFW message sniffer configuration (on/off)
577 */
578 int SVIP_NAT_ProcReadSnifferOnOff (char *buf, int count)
579 {
580 int len = 0;
581
582 len = snprintf(buf, count, "%d\n", nSVIP_NAT_Sniffer);
583
584 if (len > count)
585 {
586 printk(KERN_ERR "SVIP NAT: Only part of the text could be put into the buffer\n");
587 return count;
588 }
589
590 return len;
591 }
592 #endif
593
594 /******************************************************************************/
595 /**
596 Creates proc read/write entries
597
598 \return
599 0 on success, -1 on error
600 */
601 /******************************************************************************/
602 static int SVIP_NAT_ProcInstall(void)
603 {
604 struct proc_dir_entry *pProcParentDir, *pProcDir;
605 struct proc_dir_entry *pProcNode;
606
607 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
608 pProcParentDir = proc_net;
609 #else
610 pProcParentDir = init_net.proc_net;
611 #endif
612 pProcDir = proc_mkdir(SVIP_NAT_DEVICE_NAME, pProcParentDir);
613 if (pProcDir == NULL)
614 {
615 printk(KERN_ERR "SVIP NAT: cannot create proc dir %s/%s\n\r",
616 pProcParentDir->name, SVIP_NAT_DEVICE_NAME);
617 return -1;
618 }
619
620 pProcNode = create_proc_read_entry("nat", S_IFREG|S_IRUGO, pProcDir,
621 SVIP_NAT_ProcRead, (void *)SVIP_NAT_ProcReadNAT);
622 if (pProcNode == NULL)
623 {
624 printk(KERN_ERR "SVIP NAT: cannot create proc entry %s/%s",
625 pProcDir->name, "nat");
626 return -1;
627 }
628
629 #ifdef CONFIG_SVIP_FW_PKT_SNIFFER
630 nSVIP_NAT_Sniffer = 0;
631 /* creates proc entry for switching on/off sniffer to VoFW messages */
632 pProcNode = create_proc_read_entry("snifferOnOff", S_IFREG|S_IRUGO|S_IWUGO,
633 pProcDir, SVIP_NAT_ProcReadGen, (void *)SVIP_NAT_ProcReadSnifferOnOff);
634 if (pProcNode == NULL)
635 {
636 printk(KERN_ERR "SVIP NAT: cannot create proc entry %s/%s\n\r",
637 pProcDir->name, "snifferOnOff");
638 return -1;
639 }
640 pProcNode->write_proc = SVIP_NAT_ProcWriteSnifferOnOff;
641
642 memset (pSVIP_NAT_SnifferMAC, 0, ETH_ALEN);
643 nSVIP_NAT_SnifferMacSet = 0;
644 /* creates proc entry for setting MAC address of sniffer host to VoFW messages */
645 pProcNode = create_proc_read_entry("snifferMAC", S_IFREG|S_IRUGO|S_IWUGO,
646 pProcDir, SVIP_NAT_ProcReadGen, (void *)SVIP_NAT_ProcReadSnifferMAC);
647 if (pProcNode == NULL)
648 {
649 printk(KERN_ERR "SVIP NAT: cannot create proc entry %s/%s\n\r",
650 pProcDir->name, "snifferMAC");
651 return -1;
652 }
653 pProcNode->write_proc = SVIP_NAT_ProcWriteSnifferMAC;
654 #endif
655
656 return 0;
657 }
658
659 /******************************************************************************/
660 /**
661 No actions done here, simply a check is performed if an open has already
662 been performed. Currently only a single open is allowed as it is a sufficient
663 to have hat a single process configuring the SVIP NAT at one time.
664
665 \arguments
666 inode - pointer to disk file data
667 file - pointer to device file data
668
669 \return
670 0 on success, else -1
671 */
672 /******************************************************************************/
673 static int SVIP_NAT_device_open(struct inode *inode, struct file *file)
674 {
675 unsigned long flags;
676 struct in_device *in_dev;
677 struct in_ifaddr *ifa;
678
679 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
680 local_irq_save(flags);
681 #else
682 local_save_flags(flags);
683 #endif
684
685 if (nDeviceOpen)
686 {
687 MOD_INC_USE_COUNT;
688 local_irq_restore(flags);
689 nDeviceOpen++;
690 return 0;
691 }
692
693 /* find pointer to IP address of eth0 */
694 if ((in_dev=in_dev_get(net_devs[SVIP_NET_DEV_ETH0_IDX])) != NULL)
695 {
696 for (ifa = in_dev->ifa_list; ifa != NULL; ifa = ifa->ifa_next)
697 {
698 if (!paddr_eth0 && ifa->ifa_address != 0)
699 {
700 paddr_eth0 = &ifa->ifa_address;
701 continue;
702 }
703 if (paddr_eth0 && ifa->ifa_address != 0)
704 {
705 paddr_eth0_0 = &ifa->ifa_address;
706 break;
707 }
708 }
709 in_dev_put(in_dev);
710 }
711 if (paddr_eth0 == NULL || paddr_eth0_0 == NULL)
712 {
713 local_irq_restore(flags);
714 return -ENODATA;
715 }
716
717 /* find pointer to IP address of veth0 */
718 if ((in_dev=in_dev_get(net_devs[SVIP_NET_DEV_VETH0_IDX])) != NULL)
719 {
720 for (ifa = in_dev->ifa_list; ifa != NULL; ifa = ifa->ifa_next)
721 {
722 if (ifa->ifa_address != 0)
723 {
724 paddr_veth0 = &ifa->ifa_address;
725 pmask_veth0 = &ifa->ifa_mask;
726 break;
727 }
728 }
729 in_dev_put(in_dev);
730 }
731 if (paddr_veth0 == NULL)
732 {
733 local_irq_restore(flags);
734 return -ENODATA;
735 }
736
737 MOD_INC_USE_COUNT;
738 nDeviceOpen++;
739 local_irq_restore(flags);
740
741 return 0;
742 }
743
744
745 /******************************************************************************/
746 /**
747 This function is called when a process closes the SVIP NAT device file
748
749 \arguments
750 inode - pointer to disk file data
751 file - pointer to device file data
752
753 \return
754 0 on success, else -1
755
756 */
757 /******************************************************************************/
758 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
759 static int SVIP_NAT_device_release(struct inode *inode,
760 struct file *file)
761 #else
762 static void SVIP_NAT_device_release(struct inode *inode,
763 struct file *file)
764 #endif
765 {
766 unsigned long flags;
767
768 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
769 save_flags(flags);
770 cli();
771 #else
772 local_save_flags(flags);
773 #endif
774
775 /* The device can now be openned by the next caller */
776 nDeviceOpen--;
777
778 MOD_DEC_USE_COUNT;
779
780 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
781 restore_flags(flags);
782 #else
783 local_irq_restore(flags);
784 #endif
785
786 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
787 return 0;
788 #endif
789 }
790
791
792 /******************************************************************************/
793 /**
794 This function is called when a process closes the SVIP NAT device file
795
796 \arguments
797 inode - pointer to disk file data
798 file - pointer to device file data
799 ioctl_num - ioctl number requested
800 ioctl_param - pointer to data related to the ioctl number
801
802 \return
803 0 on success, else -1
804
805 */
806 /******************************************************************************/
807 long SVIP_NAT_device_ioctl (struct file *file,
808 unsigned int ioctl_num, unsigned long ioctl_param)
809 {
810 int ret = 0;
811 SVIP_NAT_IO_Rule_t *pNatRule, *pNatRuleIn;
812 SVIP_UDP_PORT_t nPort;
813 int nNatIdx;
814 int bWrite = 0;
815 int bRead = 0;
816 unsigned char *pData = 0;
817 int nSize;
818
819 if (_IOC_DIR(ioctl_num) & _IOC_WRITE)
820 bWrite = 1;
821 if (_IOC_DIR(ioctl_num) & _IOC_READ)
822 bRead = 1;
823 nSize = _IOC_SIZE(ioctl_num);
824
825 if (nSize > sizeof(int))
826 {
827 if (bRead || bWrite)
828 {
829 pData = kmalloc (nSize, GFP_KERNEL);
830 if (bWrite)
831 {
832 if (copy_from_user ((void *)pData, (void *)ioctl_param, nSize) != 0)
833 {
834 printk(KERN_ERR "SVIP NAT: ioctl %x: copy_from_user() failed!\n", ioctl_num);
835 ret = -1;
836 goto error;
837 }
838 }
839 }
840 }
841
842 switch (ioctl_num)
843 {
844 case FIO_SVIP_NAT_RULE_ADD:
845
846 pNatRuleIn = (SVIP_NAT_IO_Rule_t *)pData;
847
848 /* check if destination UDP port is within range */
849 nPort = ntohs(pNatRuleIn->locUDP);
850
851 if (!SVIP_PORT_INRANGE(nPort))
852 {
853 printk(KERN_ERR "SVIP NAT: Error, UDP port(%d) is out of range(%d..%d)\n",
854 nPort, SVIP_UDP_FROM, SVIP_UDP_TO);
855 ret = -1;
856 goto error;
857 }
858 nNatIdx = SVIP_PORT_INDEX(nPort);
859
860 down(sem_nat_tbl_access);
861 pNatRule = &pNatTable[nNatIdx].natRule;
862
863 /* add rule to the NAT table */
864 pNatRule->remIP = pNatRuleIn->remIP;
865 memcpy((char *)pNatRule->remMAC, (char *)pNatRuleIn->remMAC, ETH_ALEN);
866 pNatRule->locIP = pNatRuleIn->locIP;
867 memcpy((char *)pNatRule->locMAC, (char *)pNatRuleIn->locMAC, ETH_ALEN);
868 pNatRule->locUDP = pNatRuleIn->locUDP;
869
870 memset(pNatTable[nNatIdx].natStats, 0,
871 sizeof(SVIP_NAT_stats_t)*SVIP_NAT_STATS_TYPES);
872 up(sem_nat_tbl_access);
873 break;
874
875 case FIO_SVIP_NAT_RULE_REMOVE:
876
877 pNatRuleIn = (SVIP_NAT_IO_Rule_t *)pData;
878
879 /* check if destination UDP port is within range */
880 nPort = ntohs(pNatRuleIn->locUDP);
881 if (!SVIP_PORT_INRANGE(nPort))
882 {
883 printk(KERN_ERR "SVIP NAT: Error, UDP port(%d) is out of range(%d..%d)\n",
884 nPort, SVIP_UDP_FROM, SVIP_UDP_TO);
885 ret = -1;
886 goto error;
887 }
888 nNatIdx = SVIP_PORT_INDEX(nPort);
889 down(sem_nat_tbl_access);
890 /* remove rule from the NAT table */
891 memset(&pNatTable[nNatIdx], 0, sizeof(SVIP_NAT_table_entry_t));
892 up(sem_nat_tbl_access);
893 break;
894
895 case FIO_SVIP_NAT_RULE_LIST:
896 {
897 int len;
898 char buf[256];
899
900 down(sem_nat_tbl_access);
901 while (nProcReadIdx != -1)
902 {
903 len = SVIP_NAT_ProcReadNAT(buf, 256);
904 if (len > 0)
905 printk("%s", buf);
906 }
907 nProcReadIdx = 0;
908 up(sem_nat_tbl_access);
909 break;
910 }
911
912 default:
913 printk(KERN_ERR "SVIP NAT: unsupported ioctl (%x) command for device %s\n",
914 ioctl_num, PATH_SVIP_NAT_DEVICE_NAME);
915 ret = -1;
916 goto error;
917 }
918
919 if (nSize > sizeof(int))
920 {
921 if (bRead)
922 {
923 if (copy_to_user ((void *)ioctl_param, (void *)pData, nSize) != 0)
924 {
925 printk(KERN_ERR "SVIP NAT: ioctl %x: copy_to_user() failed!\n", ioctl_num);
926 ret = -1;
927 goto error;
928 }
929 }
930 }
931
932 error:
933 if (pData)
934 kfree(pData);
935
936 return ret;
937 }
938
939 #if 0
940 void dump_msg(unsigned char *pData, unsigned int nLen)
941 {
942 int i;
943
944 for (i=0; i<nLen; i++)
945 {
946 if (!i || !(i%16))
947 printk("\n ");
948 else if (i && !(i%4))
949 printk(" ");
950 printk("%02x", pData[i]);
951 }
952 if (--i%16)
953 printk("\n");
954 }
955 #endif
956
957 /******************************************************************************/
958 /**
959 Used to recalculate IP/UDP checksum using the original IP/UDP checksum
960 coming with the packet. The original source and destination IP addresses
961 are accounted for, and, the checksum is updated using the new source and
962 destination IP addresses.
963
964 \arguments
965 skb - pointer to the receiving socket buffer
966 csum_old - original checksum
967 saddr_old - pointer to original source IP address
968 saddr_new - pointer to new source IP address
969 daddr_old - pointer to original destination IP address
970 daddr_new - pointer to new destination IP address
971
972 \return
973 recalculated IP/UDP checksum
974 */
975 /******************************************************************************/
976 static inline u16 ip_udp_quick_csum(u16 csum_old, u16 *saddr_old, u16 *saddr_new,
977 u16 *daddr_old, u16 *daddr_new)
978 {
979 u32 sum;
980
981 sum = csum_old;
982
983 /* convert back from one's complement */
984 sum = ~sum & 0xffff;
985
986 if (sum < saddr_old[0]) sum += 0xffff;
987 sum -= saddr_old[0];
988 if (sum < saddr_old[1]) sum += 0xffff;
989 sum -= saddr_old[1];
990 if (sum < daddr_old[0]) sum += 0xffff;
991 sum -= daddr_old[0];
992 if (sum < daddr_old[1]) sum += 0xffff;
993 sum -= daddr_old[1];
994
995 sum += saddr_new[0];
996 sum += saddr_new[1];
997 sum += daddr_new[0];
998 sum += daddr_new[1];
999
1000 /* take only 16 bits out of the 32 bit sum and add up the carries */
1001 while (sum >> 16)
1002 sum = (sum & 0xffff)+((sum >> 16) & 0xffff);
1003
1004 /* one's complement the result */
1005 sum = ~sum;
1006
1007 return (u16)(sum & 0xffff);
1008 }
1009
1010
1011 /******************************************************************************/
1012 /**
1013 Returns a pointer to an ipv4 address assigned to device dev. The ipv4
1014 instance checked is pointed to by ifa_start. The function is suited for
1015 itterative calls.
1016
1017 \arguments
1018 dev - pointer to network interface
1019 ifa_start - pointer to ipv4 instance to return ipv4 address assigned
1020 to, NULL for the first one
1021 ppifa_addr - output parameter
1022
1023 \return
1024 pointer to the next ipv4 instance, which can be null if ifa_start was
1025 the last instance present
1026 */
1027 /******************************************************************************/
1028 static struct in_ifaddr *get_ifaddr(struct net_device *dev,
1029 struct in_ifaddr *ifa_start, unsigned int **ppifa_addr)
1030 {
1031 struct in_device *in_dev;
1032 struct in_ifaddr *ifa = NULL;
1033
1034 if ((in_dev=in_dev_get(dev)) != NULL)
1035 {
1036 if (ifa_start == NULL)
1037 ifa = in_dev->ifa_list;
1038 else
1039 ifa = ifa_start;
1040 if (ifa)
1041 {
1042 *ppifa_addr = &ifa->ifa_address;
1043 ifa = ifa->ifa_next;
1044 }
1045 in_dev_put(in_dev);
1046 return ifa;
1047 }
1048 *ppifa_addr = NULL;
1049 return NULL;
1050 }
1051
1052 /******************************************************************************/
1053 /**
1054 This function performs IP NAT for received packets satisfying the
1055 following requirements:
1056
1057 - packet is destined to local IP host
1058 - transport protocol type is UDP
1059 - destination UDP port is within range
1060
1061 \arguments
1062 skb - pointer to the receiving socket buffer
1063
1064 \return
1065 returns 1 on performed SVIP NAT, else returns 0
1066
1067 \remarks
1068 When function returns 0, it indicates the caller to pass the
1069 packet up the IP stack to make further decision about it
1070 */
1071 /******************************************************************************/
1072 int do_SVIP_NAT (struct sk_buff *skb)
1073 {
1074 struct net_device *real_dev;
1075 struct iphdr *iph;
1076 struct udphdr *udph;
1077 SVIP_NAT_IO_Rule_t *pNatRule;
1078 int nNatIdx, in_eth0, nDir;
1079 #ifndef VLAN_8021Q_UNUSED
1080 int vlan;
1081 unsigned short vid;
1082 #endif /* ! VLAN_8021Q_UNUSED */
1083 SVIP_UDP_PORT_t nPort;
1084 u32 orgSrcIp, orgDstIp, *pSrcIp, *pDstIp;
1085 struct ethhdr *ethh;
1086
1087 /* do not consider if SVIP NAT device not open. */
1088 if (!nDeviceOpen)
1089 {
1090 return 0;
1091 }
1092
1093 /* consider only UDP packets. */
1094 iph = SVIP_NAT_IP_HDR(skb);
1095 if (iph->protocol != IPPROTO_UDP)
1096 {
1097 return 0;
1098 }
1099
1100 udph = (struct udphdr *)((u_int32_t *)iph + iph->ihl);
1101 /* consider only packets which UDP port numbers reside within
1102 the predefined SVIP NAT UDP port range. */
1103 if ((!SVIP_PORT_INRANGE(ntohs(udph->dest))) &&
1104 (!SVIP_PORT_INRANGE(ntohs(udph->source))))
1105 {
1106 return 0;
1107 }
1108
1109 #ifndef VLAN_8021Q_UNUSED
1110 /* check if packet delivered over VLAN. VLAN packets will be routed over
1111 the VLAN interfaces of the respective real Ethernet interface, if one
1112 exists(VIDs must match). Else, the packet will be send out as IEEE 802.3
1113 Ethernet frame */
1114 if (skb->dev->priv_flags & IFF_802_1Q_VLAN)
1115 {
1116 vlan = 1;
1117 vid = VLAN_DEV_VLAN_ID(skb->dev);
1118 real_dev = VLAN_DEV_REAL_DEV(skb->dev);
1119 }
1120 else
1121 {
1122 vlan = 0;
1123 vid = 0;
1124 real_dev = skb->dev;
1125 }
1126 #endif /* ! VLAN_8021Q_UNUSED */
1127
1128 #ifdef CONFIG_SVIP_FW_PKT_SNIFFER
1129 /** Debugging feature which can be enabled by writing,
1130 'echo 1 > /proc/net/svip_nat/snifferOnOff'.
1131 It copies all packets received on veth0 and, sends them out over eth0.
1132 When a destination MAC address is specified through
1133 /proc/net/svip_nat/snifferMAC, this MAC addess will substitute the
1134 original MAC address of the packet.
1135 It is recommended to specify a MAC address of some host where Wireshark
1136 runs and sniffs for this traffic, else you may flood your LAN with
1137 undeliverable traffic.
1138
1139 NOTE: In case of VLAN traffic the VLAN header information is lost. */
1140 if (nSVIP_NAT_Sniffer)
1141 {
1142 if (real_dev == net_devs[SVIP_NET_DEV_VETH0_IDX])
1143 {
1144 struct sk_buff *copied_skb;
1145
1146 /* gain the Ethernet header from the skb */
1147 skb_push(skb, ETH_HLEN);
1148
1149 copied_skb = skb_copy (skb, GFP_ATOMIC);
1150
1151 if (nSVIP_NAT_SnifferMacSet == 1)
1152 {
1153 ethh = (struct ethhdr *)SVIP_NAT_SKB_MAC_HEADER(copied_skb);
1154 memcpy((char *)ethh->h_dest, (char *)pSVIP_NAT_SnifferMAC, ETH_ALEN);
1155 }
1156 copied_skb->dev = net_devs[SVIP_NET_DEV_ETH0_IDX];
1157 dev_queue_xmit(copied_skb);
1158
1159 /* skip the ETH header again */
1160 skb_pull(skb, ETH_HLEN);
1161 }
1162 }
1163 #endif
1164
1165
1166 /* check if packet arrived on eth0 */
1167 if (real_dev == net_devs[SVIP_NET_DEV_ETH0_IDX])
1168 {
1169 /* check if destination IP address equals the primary assigned IP address
1170 of interface eth0. This is the case of packets originating from a
1171 remote peer that are to be delivered to a channel residing on THIS
1172 voice linecard system. This is typical SVIP NAT case, therefore this
1173 rule is placed on top. */
1174 if (iph->daddr == *paddr_eth0)
1175 {
1176 nPort = ntohs(udph->dest);
1177 nDir = SVIP_NAT_STATS_REM2LOC;
1178 }
1179 /* check if destination IP address equals the secondary assigned IP address
1180 of interface eth0. This is not a typical SVIP NAT case. It is basically
1181 there, as someone might like for debugging purpose to use the LCC to route
1182 Slave SVIP packets which are part of voice/fax streaming. */
1183 else if (iph->daddr == *paddr_eth0_0)
1184 {
1185 nPort = ntohs(udph->source);
1186 nDir = SVIP_NAT_STATS_LOC2REM;
1187 }
1188 #ifndef VLAN_8021Q_UNUSED
1189 /* when the packet did not hit the top two rules, here we check if the packet
1190 has addressed any of the IP addresses assigned to the VLAN interface attached
1191 to eth0. This is not recommended approach because of the CPU cost incurred. */
1192 else if (vlan)
1193 {
1194 unsigned int *pifa_addr;
1195 struct in_ifaddr *ifa_start = NULL;
1196 int i = 0;
1197
1198 do
1199 {
1200 ifa_start = get_ifaddr(skb->dev, ifa_start, &pifa_addr);
1201 if (!pifa_addr)
1202 {
1203 /* VLAN packet received on vlan interface attached to eth0,
1204 however no IP address assigned to the interface.
1205 The packet is ignored. */
1206 return 0;
1207 }
1208 if (iph->daddr == *pifa_addr)
1209 {
1210 /* packet destined to... */
1211 break;
1212 }
1213 if (!ifa_start)
1214 {
1215 return 0;
1216 }
1217 i++;
1218 } while (ifa_start);
1219 if (!i)
1220 {
1221 /* ...primary assigned IP address to the VLAN interface. */
1222 nPort = ntohs(udph->dest);
1223 nDir = SVIP_NAT_STATS_REM2LOC;
1224 }
1225 else
1226 {
1227 /* ...secondary assigned IP address to the VLAN interface. */
1228 nPort = ntohs(udph->source);
1229 nDir = SVIP_NAT_STATS_LOC2REM;
1230 }
1231 }
1232 #endif /* ! VLAN_8021Q_UNUSED */
1233 else
1234 {
1235 return 0;
1236 }
1237 in_eth0 = 1;
1238 }
1239 /* check if packet arrived on veth0 */
1240 else if (real_dev == net_devs[SVIP_NET_DEV_VETH0_IDX])
1241 {
1242 nPort = ntohs(udph->source);
1243 nDir = SVIP_NAT_STATS_LOC2REM;
1244 in_eth0 = 0;
1245 }
1246 else
1247 {
1248 /* packet arrived neither on eth0, nor veth0 */
1249 return 0;
1250 }
1251
1252 /* calculate the respective index of the NAT table */
1253 nNatIdx = SVIP_PORT_INDEX(nPort);
1254 /* process the packet if a respective NAT rule exists */
1255 pNatRule = &pNatTable[nNatIdx].natRule;
1256
1257 ethh = (struct ethhdr *)SVIP_NAT_SKB_MAC_HEADER(skb);
1258
1259 /* copy packet's original source and destination IP addresses to use
1260 later on to perform efficient checksum recalculation */
1261 orgSrcIp = iph->saddr;
1262 orgDstIp = iph->daddr;
1263
1264 if (in_eth0)
1265 {
1266 u8 *pDstMac;
1267
1268 /* Process packet arrived on eth0 */
1269
1270 if (nDir == SVIP_NAT_STATS_REM2LOC && iph->saddr == pNatRule->remIP)
1271 {
1272 pDstIp = &pNatRule->locIP;
1273 pDstMac = pNatRule->locMAC;
1274 }
1275 else if (nDir == SVIP_NAT_STATS_LOC2REM && iph->saddr == pNatRule->locIP)
1276 {
1277 pDstIp = &pNatRule->remIP;
1278 pDstMac = pNatRule->remMAC;
1279 }
1280 else
1281 {
1282 /* Rule check failed. The packet is passed up the layers,
1283 it will be dropped by UDP */
1284 return 0;
1285 }
1286
1287 if ((*pDstIp & *pmask_veth0) == (*paddr_veth0 & *pmask_veth0))
1288 {
1289 #ifndef VLAN_8021Q_UNUSED
1290 if (vlan)
1291 {
1292 struct net_device *vlan_dev;
1293
1294 spin_lock_bh(&vlan_group_lock);
1295 vlan_dev = __vlan_find_dev_deep(net_devs[SVIP_NET_DEV_VETH0_IDX], vid);
1296 spin_unlock_bh(&vlan_group_lock);
1297 if (vlan_dev)
1298 {
1299 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1300 struct vlan_ethhdr *vethh;
1301
1302 skb_push(skb, VLAN_ETH_HLEN);
1303 /* reconstruct the VLAN header.
1304 NOTE: priority information is lost */
1305 vethh = (struct vlan_ethhdr *)skb->data;
1306 vethh->h_vlan_proto = htons(ETH_P_8021Q);
1307 vethh->h_vlan_TCI = htons(vid);
1308 vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
1309 ethh = (struct ethhdr *)vethh;
1310 #else
1311 skb_push(skb, ETH_HLEN);
1312 #endif
1313 skb->dev = vlan_dev;
1314 }
1315 else
1316 {
1317 skb->dev = net_devs[SVIP_NET_DEV_VETH0_IDX];
1318 skb_push(skb, ETH_HLEN);
1319 }
1320 }
1321 else
1322 #endif /* ! VLAN_8021Q_UNUSED */
1323 {
1324 skb->dev = net_devs[SVIP_NET_DEV_VETH0_IDX];
1325 skb_push(skb, ETH_HLEN);
1326 }
1327 pSrcIp = paddr_veth0;
1328 }
1329 else
1330 {
1331 #ifndef VLAN_8021Q_UNUSED
1332 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1333 if (vlan)
1334 {
1335 struct vlan_ethhdr *vethh;
1336
1337 /* reconstruct the VLAN header.
1338 NOTE: priority information is lost */
1339 skb_push(skb, VLAN_ETH_HLEN);
1340 vethh = (struct vlan_ethhdr *)skb->data;
1341 vethh->h_vlan_proto = htons(ETH_P_8021Q);
1342 vethh->h_vlan_TCI = htons(vid);
1343 vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
1344 ethh = (struct ethhdr *)vethh;
1345 }
1346 else
1347 #endif
1348 #endif /* ! VLAN_8021Q_UNUSED */
1349 {
1350 skb_push(skb, ETH_HLEN);
1351 }
1352 /* source IP address equals the destination IP address
1353 of the incoming packet */
1354 pSrcIp = &iph->daddr;
1355 }
1356 iph->saddr = *pSrcIp;
1357 memcpy((char *)ethh->h_source, (char *)skb->dev->dev_addr, ETH_ALEN);
1358 iph->daddr = *pDstIp;
1359 memcpy((char *)ethh->h_dest, (char *)pDstMac, ETH_ALEN);
1360 }
1361 else
1362 {
1363 /* Process packet arrived on veth0 */
1364
1365 if (iph->saddr != pNatRule->locIP)
1366 {
1367 /* Rule check failed. The packet is passed up the layers,
1368 it will be dropped by UDP */
1369 return 0;
1370 }
1371
1372 if (!((pNatRule->remIP & *pmask_veth0) == (*paddr_veth0 & *pmask_veth0)))
1373 {
1374 #ifndef VLAN_8021Q_UNUSED
1375 if (vlan)
1376 {
1377 struct net_device *vlan_dev;
1378
1379 spin_lock_bh(&vlan_group_lock);
1380 vlan_dev = __vlan_find_dev_deep(net_devs[SVIP_NET_DEV_ETH0_IDX], vid);
1381 spin_unlock_bh(&vlan_group_lock);
1382 if (vlan_dev)
1383 {
1384 unsigned int *pifa_addr;
1385 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1386 struct vlan_ethhdr *vethh;
1387
1388 skb_push(skb, VLAN_ETH_HLEN);
1389 /* construct the VLAN header, note priority information is lost */
1390 vethh = (struct vlan_ethhdr *)skb->data;
1391 vethh->h_vlan_proto = htons(ETH_P_8021Q);
1392 vethh->h_vlan_TCI = htons(vid);
1393 vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
1394 ethh = (struct ethhdr *)vethh;
1395 #else
1396 skb_push(skb, ETH_HLEN);
1397 #endif
1398 skb->dev = vlan_dev;
1399
1400 get_ifaddr(skb->dev, NULL, &pifa_addr);
1401 if (pifa_addr)
1402 {
1403 pSrcIp = pifa_addr;
1404 }
1405 else
1406 {
1407 pSrcIp = paddr_eth0;
1408 }
1409 }
1410 else
1411 {
1412 skb->dev = net_devs[SVIP_NET_DEV_ETH0_IDX];
1413 pSrcIp = paddr_eth0;
1414 skb_push(skb, ETH_HLEN);
1415 }
1416 }
1417 else
1418 #endif /* ! VLAN_8021Q_UNUSED */
1419 {
1420 skb->dev = net_devs[SVIP_NET_DEV_ETH0_IDX];
1421 pSrcIp = paddr_eth0;
1422 skb_push(skb, ETH_HLEN);
1423 }
1424 }
1425 else
1426 {
1427 pSrcIp = paddr_veth0;
1428 #ifndef VLAN_8021Q_UNUSED
1429 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
1430 if (vlan)
1431 {
1432 struct vlan_ethhdr *vethh;
1433
1434 skb_push(skb, VLAN_ETH_HLEN);
1435 /* reconstruct the VLAN header.
1436 NOTE: priority information is lost. */
1437 vethh = (struct vlan_ethhdr *)skb->data;
1438 vethh->h_vlan_proto = htons(ETH_P_8021Q);
1439 vethh->h_vlan_TCI = htons(vid);
1440 vethh->h_vlan_encapsulated_proto = htons(ETH_P_IP);
1441 ethh = (struct ethhdr *)vethh;
1442 }
1443 else
1444 #endif
1445 #endif /* ! VLAN_8021Q_UNUSED */
1446 {
1447 skb_push(skb, ETH_HLEN);
1448 }
1449 }
1450 iph->saddr = *pSrcIp;
1451 memcpy((char *)ethh->h_source, (char *)skb->dev->dev_addr, ETH_ALEN);
1452 iph->daddr = pNatRule->remIP;
1453 memcpy((char *)ethh->h_dest, (char *)pNatRule->remMAC, ETH_ALEN);
1454 }
1455 pNatTable[nNatIdx].natStats[nDir].inPackets++;
1456
1457 iph->check = ip_udp_quick_csum(iph->check, (u16 *)&orgSrcIp, (u16 *)&iph->saddr,
1458 (u16 *)&orgDstIp, (u16 *)&iph->daddr);
1459 if (udph->check != 0)
1460 {
1461 udph->check = ip_udp_quick_csum(udph->check, (u16 *)&orgSrcIp, (u16 *)&iph->saddr,
1462 (u16 *)&orgDstIp, (u16 *)&iph->daddr);
1463 }
1464
1465 /* write the packet out, directly to the network device */
1466 if (dev_queue_xmit(skb) < 0)
1467 pNatTable[nNatIdx].natStats[nDir].outErrors++;
1468 else
1469 pNatTable[nNatIdx].natStats[nDir].outPackets++;
1470
1471 return 1;
1472 }
1473
1474 /******************************************************************************/
1475 /**
1476 Function executed upon unloading of the SVIP NAT module. It unregisters the
1477 SVIP NAT configuration device and frees the memory used for the NAT table.
1478
1479 \remarks:
1480 Currently the SVIP NAT module is statically linked into the Linux kernel
1481 therefore this routine cannot be executed.
1482 *******************************************************************************/
1483 static int __init init(void)
1484 {
1485 int ret = 0;
1486 struct net_device *dev;
1487
1488 if (misc_register(&SVIP_NAT_miscdev) != 0)
1489 {
1490 printk(KERN_ERR "%s: cannot register SVIP NAT device node.\n",
1491 SVIP_NAT_miscdev.name);
1492 return -EIO;
1493 }
1494
1495 /* allocation of memory for NAT table */
1496 pNatTable = (SVIP_NAT_table_entry_t *)kmalloc(
1497 sizeof(SVIP_NAT_table_entry_t) * SVIP_SYS_CODEC_NUM, GFP_ATOMIC);
1498 if (pNatTable == NULL)
1499 {
1500 printk (KERN_ERR "SVIP NAT: Error(%d), allocating memory for NAT table\n", ret);
1501 return -1;
1502 }
1503
1504 /* clear the NAT table */
1505 memset((void *)pNatTable, 0, sizeof(SVIP_NAT_table_entry_t) * SVIP_SYS_CODEC_NUM);
1506
1507 if ((sem_nat_tbl_access = kmalloc(sizeof(struct semaphore), GFP_KERNEL)))
1508 {
1509 sema_init(sem_nat_tbl_access, 1);
1510 }
1511
1512 SVIP_NAT_ProcInstall();
1513
1514 /* find pointers to 'struct net_device' of eth0 and veth0, respectevely */
1515 read_lock(&dev_base_lock);
1516 SVIP_NAT_FOR_EACH_NETDEV(dev)
1517 {
1518 if (!strcmp(dev->name, SVIP_NET_DEV_ETH0_NAME))
1519 {
1520 net_devs[SVIP_NET_DEV_ETH0_IDX] = dev;
1521 }
1522 if (!strcmp(dev->name, SVIP_NET_DEV_VETH1_NAME))
1523 {
1524 net_devs[SVIP_NET_DEV_VETH0_IDX] = dev;
1525 }
1526 else if (!strcmp(dev->name, SVIP_NET_DEV_ETH1_NAME))
1527 {
1528 net_devs[SVIP_NET_DEV_VETH0_IDX] = dev;
1529 }
1530 }
1531 read_unlock(&dev_base_lock);
1532
1533 if (net_devs[SVIP_NET_DEV_ETH0_IDX] == NULL ||
1534 net_devs[SVIP_NET_DEV_VETH0_IDX] == NULL)
1535 {
1536 printk (KERN_ERR "SVIP NAT: Error, unable to locate eth0 and veth0 interfaces\n");
1537 return -1;
1538 }
1539
1540 printk ("%s, (c) 2009, Lantiq Deutschland GmbH\n", &SVIP_NAT_INFO_STR[4]);
1541
1542 return ret;
1543 }
1544
1545 /******************************************************************************/
1546 /**
1547 Function executed upon unloading of the SVIP NAT module. It unregisters the
1548 SVIP NAT configuration device and frees the memory used for the NAT table.
1549
1550 \remarks:
1551 Currently the SVIP NAT module is statically linked into the Linux kernel
1552 therefore this routine cannot be executed.
1553 *******************************************************************************/
1554 static void __exit fini(void)
1555 {
1556 MOD_DEC_USE_COUNT;
1557
1558 /* unregister SVIP NAT configuration device */
1559 misc_deregister(&SVIP_NAT_miscdev);
1560
1561 /* release memory of SVIP NAT table */
1562 if (pNatTable != NULL)
1563 {
1564 kfree (pNatTable);
1565 }
1566 }
1567
1568 module_init(init);
1569 module_exit(fini);
OpenWrt SVN history