home *** CD-ROM | disk | FTP | other *** search
/ Hacks & Cracks / Hacks_and_Cracks.iso / hackersclub / km / downloads / c_scripts / ip_masq.c < prev    next >
C/C++ Source or Header  |  1998-03-25  |  33KB  |  1,271 lines
  1. From nik@netaxs.comTue Jul 18 09:26:08 1995
  2. Date: Mon, 17 Jul 1995 17:25:26 -0400 (EDT)
  3. From: Nik Weidenbacher <nik@netaxs.com>
  4. To: masq@eves.com
  5. Subject: The 1.2 patch.
  6.  
  7. I have heard many requests for this, so here it is.  I also posted it to
  8. c.o.l.networking.  
  9.  
  10. nik
  11.  
  12. diff -rc linux/arch/i386/config.in linux+masq/arch/i386/config.in
  13. *** linux/arch/i386/config.in    Tue Mar  7 15:25:26 1995
  14. --- linux+masq/arch/i386/config.in    Thu Mar  9 10:00:25 1995
  15. ***************
  16. *** 46,51 ****
  17. --- 46,54 ----
  18.   bool 'IP multicasting' CONFIG_IP_MULTICAST n
  19.   bool 'IP firewalling' CONFIG_IP_FIREWALL n
  20.   bool 'IP accounting' CONFIG_IP_ACCT n
  21. + if [ "$CONFIG_IP_FORWARD" = "y" -a "$CONFIG_IP_FIREWALL" = "y" ]; then
  22. +   bool 'IP masquerading (ALPHA)' CONFIG_IP_MASQUERADE n
  23. + fi
  24.   comment '(it is safe to leave these untouched)'
  25.   bool 'PC/TCP compatibility mode' CONFIG_INET_PCTCP n
  26.   bool 'Reverse ARP' CONFIG_INET_RARP n
  27. diff -rc linux/include/linux/ip_fw.h linux+masq/include/linux/ip_fw.h
  28. *** linux/include/linux/ip_fw.h    Thu Mar  9 19:33:55 1995
  29. --- linux+masq/include/linux/ip_fw.h    Sat Mar 18 10:46:39 1995
  30. ***************
  31. *** 15,20 ****
  32. --- 15,23 ----
  33.    *        Alan.
  34.    *
  35.    *    All the real work was done by .....
  36. +  *
  37. +  * Fixes:
  38. +  *    Pauline Middelink    :    Added masquerading.
  39.    */
  40.   
  41.   /*
  42. ***************
  43. *** 83,89 ****
  44.   #define IP_FW_F_BIDIR    0x040    /* For bidirectional firewalls        */
  45.   #define IP_FW_F_TCPSYN    0x080    /* For tcp packets-check SYN only     */
  46.   #define IP_FW_F_ICMPRPL 0x100    /* Send back icmp unreachable packet  */
  47. ! #define IP_FW_F_MASK    0x1FF    /* All possible flag bits mask        */
  48.   
  49.   /*    
  50.    *    New IP firewall options for [gs]etsockopt at the RAW IP level.
  51. --- 86,93 ----
  52.   #define IP_FW_F_BIDIR    0x040    /* For bidirectional firewalls        */
  53.   #define IP_FW_F_TCPSYN    0x080    /* For tcp packets-check SYN only     */
  54.   #define IP_FW_F_ICMPRPL 0x100    /* Send back icmp unreachable packet  */
  55. ! #define IP_FW_F_MASQ    0x200    /* Masquerading                  */
  56. ! #define IP_FW_F_MASK    0x3FF    /* All possible flag bits mask        */
  57.   
  58.   /*    
  59.    *    New IP firewall options for [gs]etsockopt at the RAW IP level.
  60. ***************
  61. *** 134,147 ****
  62.   extern struct ip_fw *ip_fw_fwd_chain;
  63.   extern int ip_fw_blk_policy;
  64.   extern int ip_fw_fwd_policy;
  65.   extern int ip_fw_ctl(int, void *, int);
  66.   #endif
  67.   #ifdef CONFIG_IP_ACCT
  68.   extern struct ip_fw *ip_acct_chain;
  69. - extern void ip_acct_cnt(struct iphdr *, struct device *, struct ip_fw *);
  70.   extern int ip_acct_ctl(int, void *, int);
  71.   #endif
  72. ! extern int ip_fw_chk(struct iphdr *, struct device *rif,struct ip_fw *, int, int);
  73.   #endif /* KERNEL */
  74.   
  75.   #endif /* _IP_FW_H */
  76. --- 138,166 ----
  77.   extern struct ip_fw *ip_fw_fwd_chain;
  78.   extern int ip_fw_blk_policy;
  79.   extern int ip_fw_fwd_policy;
  80. + extern int ip_fw_chk(struct iphdr *, struct device *rif,struct ip_fw *, int, int);
  81.   extern int ip_fw_ctl(int, void *, int);
  82.   #endif
  83.   #ifdef CONFIG_IP_ACCT
  84.   extern struct ip_fw *ip_acct_chain;
  85.   extern int ip_acct_ctl(int, void *, int);
  86.   #endif
  87. ! #ifdef CONFIG_IP_MASQUERADE
  88. ! struct ip_masq {
  89. !     struct ip_masq    *next;        /* next member in list */
  90. !     struct timer_list timer;    /* Expiration timer */
  91. !     __u16         protocol;    /* Which protocol are we talking? */
  92. !     __u32         src, dst;    /* Source and destination IP addresses */
  93. !     __u16        sport,dport;    /* Source and destoination ports */
  94. !     __u16        mport;        /* Masquaraded port */
  95. !     __u32        init_seq;    /* Add delta from this seq. on */
  96. !     short        delta;        /* Delta in sequence numbers */
  97. !     char        sawfin;        /* Did we saw an FIN packet? */
  98. ! };
  99. ! extern struct ip_masq *ip_msq_hosts;
  100. ! extern void ip_fw_masquerade(struct sk_buff *, struct device *);
  101. ! extern int ip_fw_demasquerade(struct sk_buff *);
  102. ! #endif
  103.   #endif /* KERNEL */
  104.   
  105.   #endif /* _IP_FW_H */
  106. diff -rc linux/include/linux/proc_fs.h linux+masq/include/linux/proc_fs.h
  107. *** linux/include/linux/proc_fs.h    Sun Feb 12 20:11:02 1995
  108. --- linux+masq/include/linux/proc_fs.h    Thu Mar  9 10:00:26 1995
  109. ***************
  110. *** 74,79 ****
  111. --- 74,82 ----
  112.   #ifdef CONFIG_IP_ACCT
  113.       PROC_NET_IPACCT,
  114.   #endif
  115. + #ifdef CONFIG_IP_MASQUERADE
  116. +     PROC_NET_IPMSQHST,
  117. + #endif
  118.   #if    defined(CONFIG_WAVELAN)
  119.       PROC_NET_WAVELAN,
  120.   #endif    /* defined(CONFIG_WAVELAN) */
  121. diff -rc linux/net/inet/ip.c linux+masq/net/inet/ip.c
  122. *** linux/net/inet/ip.c    Thu Mar  9 19:33:55 1995
  123. --- linux+masq/net/inet/ip.c    Sat Mar 18 10:44:03 1995
  124. ***************
  125. *** 62,67 ****
  126. --- 62,69 ----
  127.    *        Alan Cox    :    RAW sockets demultiplex in the BSD style.
  128.    *        Gunther Mayer    :    Fix the SNMP reporting typo
  129.    *        Alan Cox    :    Always in group 224.0.0.1
  130. +  *    Pauline Middelink    :    Fast ip_checksum update when forwarding
  131. +  *                    Masquerading support.
  132.    *        Alan Cox    :    Multicast loopback error for 224.0.0.1
  133.    *        Alan Cox    :    IP_MULTICAST_LOOP option.
  134.    *        Alan Cox    :    Use notifiers.
  135. ***************
  136. *** 1263,1280 ****
  137.       struct rtable *rt;    /* Route we use */
  138.       unsigned char *ptr;    /* Data pointer */
  139.       unsigned long raddr;    /* Router IP address */
  140. !     
  141.       /* 
  142.        *    See if we are allowed to forward this.
  143.        */
  144.   
  145. ! #ifdef CONFIG_IP_FIREWALL
  146. !     int err;
  147. !     
  148. !     if((err=ip_fw_chk(skb->h.iph, dev, ip_fw_fwd_chain, ip_fw_fwd_policy, 0))!=1)
  149. !     {
  150. !         if(err==-1)
  151. !             icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
  152.           return;
  153.       }
  154.   #endif
  155. --- 1265,1282 ----
  156.       struct rtable *rt;    /* Route we use */
  157.       unsigned char *ptr;    /* Data pointer */
  158.       unsigned long raddr;    /* Router IP address */
  159. ! #ifdef CONFIG_IP_FIREWALL
  160. !     int fw_res = 0;        /* Forwarding Result */
  161. ! 
  162.       /* 
  163.        *    See if we are allowed to forward this.
  164. +      *    Note: demasqueraded fragments are always 'back'warded.
  165.        */
  166.   
  167. !      if( !(is_frag&4) && (fw_res=ip_fw_chk(skb->h.iph, dev, ip_fw_fwd_chain, ip_fw_fwd_policy, 0))<1)
  168. !       {
  169. !          if(fw_res==-1)
  170. !              icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
  171.           return;
  172.       }
  173.   #endif
  174. ***************
  175. *** 1291,1302 ****
  176.   
  177.       iph = skb->h.iph;
  178.       iph->ttl--;
  179. -     if (iph->ttl <= 0)
  180. -     {
  181. -         /* Tell the sender its packet died... */
  182. -         icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0, dev);
  183. -         return;
  184. -     }
  185.   
  186.       /*
  187.        *    Re-compute the IP header checksum.
  188. --- 1293,1298 ----
  189. ***************
  190. *** 1304,1310 ****
  191. --- 1300,1324 ----
  192.        *    and could thus adjust the checksum as Phil Karn does in KA9Q
  193.        */
  194.   
  195. + #if 0
  196.       ip_send_check(iph);
  197. + #else
  198. +     /*
  199. +      * Like this?
  200. +      *     Notice we must do the additions in HOST format!
  201. +      */
  202. +     iph->check = ntohs(iph->check) + 0x0100;
  203. +     if ((iph->check & 0xFF00) == 0)
  204. +         iph->check++;        /* carry overflow */
  205. +     iph->check = htons(iph->check);
  206. + #endif
  207. + 
  208. +     if (iph->ttl <= 0)
  209. +     {
  210. +         /* Tell the sender its packet died... */
  211. +         icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0, dev);
  212. +         return;
  213. +     }
  214.   
  215.       /*
  216.        * OK, the packet is still valid.  Fetch its destination address,
  217. ***************
  218. *** 1380,1385 ****
  219. --- 1394,1407 ----
  220.   
  221.       if (dev2->flags & IFF_UP)
  222.       {
  223. + #ifdef CONFIG_IP_MASQUERADE
  224. +         /*
  225. +          * If this fragment needs masquerading, make it so...
  226. +          * (Dont masquerade de-masqueraded fragments)
  227. +          */
  228. +         if (!(is_frag&4) && fw_res==2)
  229. +             ip_fw_masquerade(skb, dev2);
  230. + #endif
  231.   
  232.           /*
  233.            *    Current design decrees we copy the packet. For identical header
  234. ***************
  235. *** 1430,1436 ****
  236.                *    Count mapping we shortcut
  237.                */
  238.                
  239. !             ip_acct_cnt(iph,dev,ip_acct_chain);
  240.   #endif            
  241.               
  242.               /*
  243. --- 1452,1458 ----
  244.                *    Count mapping we shortcut
  245.                */
  246.                
  247. !             ip_fw_chk(iph,dev,ip_acct_chain,0,1);
  248.   #endif            
  249.               
  250.               /*
  251. ***************
  252. *** 1501,1507 ****
  253.   
  254.   #ifdef    CONFIG_IP_FIREWALL
  255.       
  256. !     if ((err=ip_fw_chk(iph,dev,ip_fw_blk_chain,ip_fw_blk_policy, 0))!=1)
  257.       {
  258.           if(err==-1)
  259.               icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
  260. --- 1523,1529 ----
  261.   
  262.   #ifdef    CONFIG_IP_FIREWALL
  263.       
  264. !     if ((err=ip_fw_chk(iph,dev,ip_fw_blk_chain,ip_fw_blk_policy,0))<1)
  265.       {
  266.           if(err==-1)
  267.               icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
  268. ***************
  269. *** 1613,1624 ****
  270.           while(1);
  271.       }
  272.   #endif
  273.       /*
  274.        *    Account for the packet
  275.        */
  276. !      
  277.   #ifdef CONFIG_IP_ACCT
  278. !     ip_acct_cnt(iph,dev, ip_acct_chain);
  279.   #endif    
  280.   
  281.       /*
  282. --- 1635,1658 ----
  283.           while(1);
  284.       }
  285.   #endif
  286. + 
  287. + #ifdef CONFIG_IP_MASQUERADE
  288. +     /*
  289. +      * Do we need to de-masquerade this fragment?
  290. +      */
  291. +     if (ip_fw_demasquerade(skb)) {
  292. +         ip_forward(skb, dev, is_frag|4);
  293. +         kfree_skb(skb, FREE_WRITE);
  294. +         return(0);
  295. +     }
  296. + #endif
  297. + 
  298.       /*
  299.        *    Account for the packet
  300.        */
  301. !  
  302.   #ifdef CONFIG_IP_ACCT
  303. !     ip_fw_chk(iph,dev,ip_acct_chain,0,1);
  304.   #endif    
  305.   
  306.       /*
  307. ***************
  308. *** 1634,1641 ****
  309.           skb->dev = dev;
  310.           iph=skb->h.iph;
  311.       }
  312. -     
  313. -          
  314.   
  315.       /*
  316.        *    Point into the IP datagram, just past the header.
  317. --- 1668,1673 ----
  318. ***************
  319. *** 1643,1655 ****
  320.   
  321.       skb->ip_hdr = iph;
  322.       skb->h.raw += iph->ihl*4;
  323. !     
  324.       /*
  325.        *    Deliver to raw sockets. This is fun as to avoid copies we want to make no surplus copies.
  326.        */
  327. !      
  328.       hash = iph->protocol & (SOCK_ARRAY_SIZE-1);
  329. !     
  330.       /* If there maybe a raw socket we must check - if not we don't care less */
  331.       if((raw_sk=raw_prot.sock_array[hash])!=NULL)
  332.       {
  333. --- 1675,1687 ----
  334.   
  335.       skb->ip_hdr = iph;
  336.       skb->h.raw += iph->ihl*4;
  337. ! 
  338.       /*
  339.        *    Deliver to raw sockets. This is fun as to avoid copies we want to make no surplus copies.
  340.        */
  341. !  
  342.       hash = iph->protocol & (SOCK_ARRAY_SIZE-1);
  343. ! 
  344.       /* If there maybe a raw socket we must check - if not we don't care less */
  345.       if((raw_sk=raw_prot.sock_array[hash])!=NULL)
  346.       {
  347. ***************
  348. *** 1921,1927 ****
  349.        
  350.       ip_statistics.IpOutRequests++;
  351.   #ifdef CONFIG_IP_ACCT
  352. !     ip_acct_cnt(iph,dev, ip_acct_chain);
  353.   #endif    
  354.       
  355.   #ifdef CONFIG_IP_MULTICAST    
  356. --- 1953,1959 ----
  357.        
  358.       ip_statistics.IpOutRequests++;
  359.   #ifdef CONFIG_IP_ACCT
  360. !     ip_fw_chk(iph,dev,ip_acct_chain,0,1);
  361.   #endif    
  362.       
  363.   #ifdef CONFIG_IP_MULTICAST    
  364. diff -rc linux/net/inet/ip_fw.c linux+masq/net/inet/ip_fw.c
  365. *** linux/net/inet/ip_fw.c    Fri Mar 10 09:07:14 1995
  366. --- linux+masq/net/inet/ip_fw.c    Sat Mar 18 11:15:41 1995
  367. ***************
  368. *** 21,26 ****
  369. --- 21,41 ----
  370.    *        Jos Vos 5/Mar/1995.
  371.    *
  372.    *    All the real work was done by .....
  373. +  *
  374. +  * Fixes:
  375. +  *    Pauline Middelink    :    Added masquerading.
  376. +  */
  377. + 
  378. + /*
  379. +  * Masquerading functionality
  380. +  *
  381. +  * Copyright (c) 1994 Pauline Middelink
  382. +  *
  383. +  * The pieces which added masquerading functionality are totaly
  384. +  * my responsibility and have nothing to with the original authors
  385. +  * copyright or doing.
  386. +  *
  387. +  * Parts distributed under GPL.
  388.    */
  389.   
  390.   /*
  391. ***************
  392. *** 58,63 ****
  393. --- 73,79 ----
  394.   #include "protocol.h"
  395.   #include "route.h"
  396.   #include "tcp.h"
  397. + #include "udp.h"
  398.   #include <linux/skbuff.h>
  399.   #include "sock.h"
  400.   #include "icmp.h"
  401. ***************
  402. *** 104,109 ****
  403. --- 120,148 ----
  404.   #define IP_INFO_FWD    1
  405.   #define IP_INFO_ACCT    2
  406.   
  407. + /*
  408. +  *    Implement IP packet masquerading
  409. +  */
  410. + 
  411. + #ifdef CONFIG_IP_MASQUERADE
  412. + 
  413. + #undef DEBUG_MASQ
  414. + 
  415. + #define MASQUERADE_EXPIRE_TCP     15*60*HZ
  416. + #define MASQUERADE_EXPIRE_TCP_FIN  2*60*HZ
  417. + #define MASQUERADE_EXPIRE_UDP      5*60*HZ
  418. + 
  419. + /*
  420. +  * Linux ports don't get allocated above 32K. I used a extra 4K port-space
  421. +  */
  422. + #define PORT_MASQ_BEGIN    32768
  423. + #define PORT_MASQ_END    (PORT_MASQ_BEGIN+4096)
  424. + 
  425. + static unsigned short masq_port = PORT_MASQ_BEGIN;
  426. + static char *strProt[] = {"UDP","TCP"};
  427. + struct ip_masq *ip_msq_hosts;
  428. + 
  429. + #endif
  430.   
  431.   /*
  432.    *    Returns 1 if the port is matched by the vector, 0 otherwise
  433. ***************
  434. *** 136,143 ****
  435.   
  436.   
  437.   /*
  438. !  *    Returns 0 if packet should be dropped, 1 if it should be accepted,
  439. !  *    and -1 if an ICMP host unreachable packet should be sent.
  440.    *    Also does accounting so you can feed it the accounting chain.
  441.    *    If opt is set to 1, it means that we do this for accounting
  442.    *    purposes (searches all entries and handles fragments different).
  443. --- 175,184 ----
  444.   
  445.   
  446.   /*
  447. !  *    Returns 0 if packet should be dropped, 1 if it should be
  448. !  *    accepted and -1 if an ICMP host unreachable packet should
  449. !  *    be sent. Returns 2 to indicate it as matched by a masquerading rule.
  450. !  *
  451.    *    Also does accounting so you can feed it the accounting chain.
  452.    *    If opt is set to 1, it means that we do this for accounting
  453.    *    purposes (searches all entries and handles fragments different).
  454. ***************
  455. *** 149,173 ****
  456.   int ip_fw_chk(struct iphdr *ip, struct device *rif, struct ip_fw *chain, int policy, int opt)
  457.   {
  458.       struct ip_fw *f;
  459. !     struct tcphdr        *tcp=(struct tcphdr *)((unsigned long *)ip+ip->ihl);
  460. !     struct udphdr        *udp=(struct udphdr *)((unsigned long *)ip+ip->ihl);
  461.       __u32            src, dst;
  462.       __u16            src_port=0, dst_port=0;
  463.       unsigned short        f_prt=0, prt;
  464.       char            notcpsyn=1, frag1, match;
  465.       unsigned short        f_flag;
  466.   
  467. -     /*
  468. -      *    If the chain is empty follow policy. The BSD one
  469. -      *    accepts anything giving you a time window while
  470. -      *    flushing and rebuilding the tables.
  471. -      */
  472. -      
  473. -     src = ip->saddr;
  474. -     dst = ip->daddr;
  475. - 
  476.       /* 
  477. !      *    This way we handle fragmented packets.
  478.        *    we ignore all fragments but the first one
  479.        *    so the whole packet can't be reassembled.
  480.        *    This way we relay on the full info which
  481. --- 190,205 ----
  482.   int ip_fw_chk(struct iphdr *ip, struct device *rif, struct ip_fw *chain, int policy, int opt)
  483.   {
  484.       struct ip_fw *f;
  485. !     struct tcphdr        *tcp=(struct tcphdr *)((unsigned char *)ip+ip->ihl*4);
  486. !     struct udphdr        *udp=(struct udphdr *)((unsigned char *)ip+ip->ihl*4);
  487.       __u32            src, dst;
  488.       __u16            src_port=0, dst_port=0;
  489.       unsigned short        f_prt=0, prt;
  490.       char            notcpsyn=1, frag1, match;
  491.       unsigned short        f_flag;
  492.   
  493.       /* 
  494. !      *    This way we handle fragmented packets:
  495.        *    we ignore all fragments but the first one
  496.        *    so the whole packet can't be reassembled.
  497.        *    This way we relay on the full info which
  498. ***************
  499. *** 195,201 ****
  500.        *    per device. We have a device per address with dummy
  501.        *    devices instead.
  502.        */
  503. !      
  504.       dprintf1("Packet ");
  505.       switch(ip->protocol) 
  506.       {
  507. --- 227,233 ----
  508.        *    per device. We have a device per address with dummy
  509.        *    devices instead.
  510.        */
  511. ! 
  512.       dprintf1("Packet ");
  513.       switch(ip->protocol) 
  514.       {
  515. ***************
  516. *** 388,399 ****
  517.       else
  518.           f_flag=policy;
  519.       if(f_flag&IP_FW_F_ACCEPT)
  520. !         return 1;
  521.       if(f_flag&IP_FW_F_ICMPRPL)
  522.           return -1;
  523.       return 0;
  524.   }
  525.   
  526.   
  527.   static void zero_fw_chain(struct ip_fw *chainptr)
  528.   {
  529. --- 420,811 ----
  530.       else
  531.           f_flag=policy;
  532.       if(f_flag&IP_FW_F_ACCEPT)
  533. !         return (f_flag&IP_FW_F_MASQ) ? 2 : 1;
  534.       if(f_flag&IP_FW_F_ICMPRPL)
  535.           return -1;
  536.       return 0;
  537.   }
  538.   
  539. + #ifdef CONFIG_IP_MASQUERADE
  540. + 
  541. + static
  542. + void masq_expire(unsigned long data)
  543. + {
  544. +     struct ip_masq *ms = (struct ip_masq *)data;
  545. +     struct ip_masq *old,*cur;
  546. +     unsigned long flags;
  547. + 
  548. + #ifdef DEBUG_MASQ
  549. +     printk("Masqueraded %s %lX:%X expired\n",
  550. +             strProt[ms->protocol==IPPROTO_TCP],
  551. +             ntohl(ms->src),ntohs(ms->sport));
  552. + #endif
  553. +     
  554. +     save_flags(flags);
  555. +     cli();
  556. + 
  557. +     /* delete from list of hosts */
  558. +     old = NULL;
  559. +     cur = ip_msq_hosts;
  560. +     while (cur!=NULL) {
  561. +         if (cur==ms) {
  562. +             if (old==NULL) ip_msq_hosts = ms->next;
  563. +             else old->next = ms->next;
  564. +             kfree_s(ms,sizeof(*ms));
  565. +             break;
  566. +         }
  567. +         old = cur;
  568. +         cur=cur->next;
  569. +     }
  570. +     restore_flags(flags);
  571. + }
  572. + 
  573. + /*
  574. +  * Create a new masquerade list entry, also allocate an
  575. +  * unused mport, keeping the portnumber between the
  576. +  * given boundaries MASQ_BEGIN and MASQ_END.
  577. +  *
  578. +  * FIXME: possible deadlock if all free ports are exhausted! 
  579. +  */
  580. + static
  581. + struct ip_masq *alloc_masq_entry(void)
  582. + {
  583. +     struct ip_masq *ms, *mst;
  584. +     unsigned long flags;
  585. + 
  586. +     ms = (struct ip_masq *) kmalloc(sizeof(struct ip_masq), GFP_ATOMIC);
  587. +     if (ms==NULL) 
  588. +         return NULL;
  589. + 
  590. +     memset(ms,0,sizeof(*ms));
  591. +     init_timer(&ms->timer);
  592. +     ms->timer.data     = (unsigned long)ms;
  593. +     ms->timer.function = masq_expire;
  594. + 
  595. +     save_flags(flags);
  596. +     cli();
  597. +     do {
  598. +         /* Try the next available port number */
  599. +         ms->mport = htons(masq_port++);
  600. +         if (masq_port==PORT_MASQ_END)
  601. +             masq_port = PORT_MASQ_BEGIN;
  602. + 
  603. +         /* Now hunt through the used ports to see if
  604. +          * this port is in use... */
  605. +         mst = ip_msq_hosts;
  606. +         while (mst && mst->mport!=ms->mport)
  607. +             mst = mst->next;
  608. +     }
  609. +     while (mst!=NULL); 
  610. + 
  611. +     /* add new entry in front of list to minimize lookup-time */
  612. +     ms->next  = ip_msq_hosts;
  613. +     ip_msq_hosts = ms;
  614. +     restore_flags(flags);
  615. + 
  616. +     return ms;
  617. + }
  618. + 
  619. + #ifdef notdef
  620. + 
  621. + /*
  622. +  * When passing an FTP 'PORT' command, try to replace the IP
  623. +  * address with an newly assigned (masquereded) port on this
  624. +  * host, so the ftp-data connect FROM the site will succeed...
  625. +  *
  626. +  * Also, when the size of the packet changes, create an delta
  627. +  * offset, which will be added to every th->seq (and subtracted for
  628. +  * (th->acqseq) whose seq > init_seq.
  629. +  *
  630. +  * Not for the faint of heart!
  631. +  */
  632. + static
  633. + struct sk_buff *revamp(struct sk_buff *skb, struct device *dev, struct ip_masq *ftp)
  634. + {
  635. +     struct iphdr *iph = skb->h.iph;
  636. +     struct tcphdr *th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]);
  637. +     struct sk_buff *skb2;
  638. +     char *p, *data = (char *)&th[1];
  639. +     unsigned char p1,p2,p3,p4,p5,p6;
  640. +     unsigned long from;
  641. +     unsigned short port;
  642. +     struct ip_masq *ms;
  643. +     char buf[20];        /* xxx.xxx.xxx.xxx\r\n */
  644. +     
  645. +     /*
  646. +      * Adjust seq and ack_seq with delta-offset for
  647. +      * the packets AFTER this one...
  648. +      */
  649. +     if (ftp->delta && after(ftp->init_seq,th->seq)) {
  650. +         th->seq += ftp->delta;
  651. +         th->ack_seq += ftp->delta;
  652. +     }
  653. + 
  654. +     while (skb->len - ((unsigned char *)data - skb->h.raw) > 18)
  655. +     {
  656. +         if (memcmp(data,"PORT ",5)!=0 && memcmp(data,"port ",5)!=0) {
  657. +             data += 5;
  658. +             continue;
  659. +         }
  660. +         p = data+5;
  661. +         p1 = simple_strtoul(data+5,&data,10);
  662. +         if (*data!=',')
  663. +             continue;
  664. +         p2 = simple_strtoul(data+1,&data,10);
  665. +         if (*data!=',')
  666. +             continue;
  667. +         p3 = simple_strtoul(data+1,&data,10);
  668. +         if (*data!=',')
  669. +             continue;
  670. +         p4 = simple_strtoul(data+1,&data,10);
  671. +         if (*data!=',')
  672. +             continue;
  673. +         p5 = simple_strtoul(data+1,&data,10);
  674. +         if (*data!=',')
  675. +             continue;
  676. +         p6 = simple_strtoul(data+1,&data,10);
  677. +         if (*data!='\r' && *data!='\n')
  678. +             continue;
  679. + 
  680. +         from = (p1<<24) | (p2<<16) | (p3<<8) | p4;
  681. +         port = (p5<<8) | p6;
  682. + printk("PORT %lX:%X detected\n",from,port);
  683. +     
  684. +         /*
  685. +          * Now create an masquerade entry for it
  686. +          */
  687. +         ms = alloc_masq_entry();
  688. +         if (ms==NULL)
  689. +             return skb;
  690. +         ms->protocol = IPPROTO_TCP;
  691. +         ms->src      = htonl(from);    /* derived from PORT cmd */
  692. +         ms->sport    = htons(port);    /* derived from PORT cmd */
  693. +         ms->dst      = iph->daddr;
  694. +         ms->dport    = htons(20);    /* ftp-data */
  695. +         ms->timer.expires = MASQUERADE_EXPIRE_TCP_FIN;
  696. +         add_timer(&ms->timer);
  697. + 
  698. +         /*
  699. +          * Replace the old PORT with the new one
  700. +          */
  701. +         from = ntohl(dev->pa_addr);
  702. +         port = ntohs(ms->mport);
  703. +         sprintf(buf,"%ld,%ld,%ld,%ld,%d,%d",
  704. +             from>>24&255,from>>16&255,from>>8&255,from&255,
  705. +             port>>8&255,port&255);
  706. + 
  707. +         /*
  708. +          * Calculate required delta-offset to keep TCP happy
  709. +          */
  710. +         ftp->delta += strlen(buf) - (data-p);
  711. +         if (ftp->delta==0) {
  712. +             /*
  713. +              * simple case, just replace the old PORT cmd
  714. +              */
  715. +             ftp->init_seq = 0;
  716. +             memcpy(p,buf,strlen(buf));
  717. +             return skb;
  718. +         }
  719. + 
  720. +         /*
  721. +          * Sizes differ, make a copy
  722. +          */
  723. + printk("MASQUERADE: resizing needed for %d bytes (%ld)\n",ftp->delta, skb->len);
  724. +         if (!ftp->init_seq)
  725. +             ftp->init_seq = th->seq;
  726. + 
  727. +         skb2 = alloc_skb(skb->mem_len-sizeof(struct sk_buff)+ftp->delta, GFP_ATOMIC);
  728. +         if (skb2 == NULL) {
  729. +             printk("MASQUERADE: No memory available\n");
  730. +             return skb;
  731. +         }
  732. +         skb2->free = skb->free;
  733. +         skb2->len = skb->len + ftp->delta;
  734. +         skb2->h.raw = &skb2->data[skb->h.raw - skb->data];
  735. + 
  736. +         /*
  737. +          *    Copy the packet data into the new buffer.
  738. +          *    Thereby replacing the PORT cmd.
  739. +          */
  740. +         memcpy(skb2->data, skb->data, (p - (char *)skb->data));
  741. +         memcpy(&skb2->data[(p - (char *)skb->data)], buf, strlen(buf));
  742. +         memcpy(&skb2->data[(p - (char *)skb->data) + strlen(buf)], data,
  743. +             skb->mem_len - sizeof(struct sk_buff) - ((char *)skb->h.raw - data));
  744. + 
  745. +         /*
  746. +          * Problem, how to replace the new skb with old one,
  747. +          * preferably inplace, so all the pointers in the
  748. +          * calling tree keep ok :(
  749. +          */
  750. +         kfree_skb(skb, FREE_WRITE);
  751. +         return skb2;
  752. +     }
  753. +     return skb;
  754. + }
  755. + #endif
  756. + 
  757. + void ip_fw_masquerade(struct sk_buff *skb, struct device *dev)
  758. + {
  759. +     struct iphdr    *iph = skb->h.iph;
  760. +     unsigned short    *portptr;
  761. +     struct ip_masq    *ms;
  762. +     int        size;
  763. + 
  764. +     /*
  765. +      * We can only masquerade protocols with ports...
  766. +      */
  767. +     if (iph->protocol!=IPPROTO_UDP && iph->protocol!=IPPROTO_TCP)
  768. +         return;
  769. + 
  770. +     /*
  771. +      * Now hunt the list to see if we have an old entry
  772. +      */
  773. +     portptr = (unsigned short *)&(((char *)iph)[iph->ihl*4]);
  774. +     ms = ip_msq_hosts;
  775. + 
  776. + #ifdef DEBUG_MASQ
  777. +     printk("Outgoing %s %lX:%X -> %lX:%X\n",
  778. +         strProt[iph->protocol==IPPROTO_TCP],
  779. +         ntohl(iph->saddr), ntohs(portptr[0]),
  780. +         ntohl(iph->daddr), ntohs(portptr[1]));
  781. + #endif
  782. +     while (ms!=NULL) {
  783. +         if (iph->protocol == ms->protocol &&
  784. +             iph->saddr == ms->src   && iph->daddr == ms->dst &&
  785. +             portptr[0] == ms->sport && portptr[1] == ms->dport) {
  786. +             del_timer(&ms->timer);
  787. +             break;
  788. +         }
  789. +         ms = ms->next;
  790. +     }
  791. + 
  792. +     /*
  793. +      * Nope, not found, create a new entry for it
  794. +      */
  795. +     if (ms==NULL) {
  796. +         ms = alloc_masq_entry();
  797. +         if (ms==NULL) {
  798. +             printk("MASQUERADE: no memory left !\n");
  799. +             return;
  800. +         }
  801. +         ms->protocol = iph->protocol;
  802. +         ms->src      = iph->saddr;
  803. +         ms->dst      = iph->daddr;
  804. +         ms->sport    = portptr[0];
  805. +         ms->dport    = portptr[1];
  806. +     }
  807. + 
  808. +     /*
  809. +      * Change the fragments origin
  810. +      */
  811. +     size = skb->len - ((unsigned char *)portptr - skb->h.raw);
  812. +     iph->saddr = dev->pa_addr; /* my own address */
  813. +     portptr[0] = ms->mport;
  814. + 
  815. +     /*
  816. +      * Adjust packet accordingly to protocol
  817. +      */
  818. +     if (iph->protocol==IPPROTO_UDP) {
  819. +         ms->timer.expires = MASQUERADE_EXPIRE_UDP;
  820. +         udp_send_check((struct udphdr *)portptr,iph->saddr,iph->daddr,size,skb->sk);
  821. +     }
  822. +     else {
  823. +         struct tcphdr *th;
  824. + #ifdef notdef
  825. +         if (portptr[1]==htons(21)) {
  826. +             skb = revamp(skb, dev, ms);
  827. +             iph = skb->h.iph;
  828. +             portptr = (unsigned short *)&(((char *)iph)[iph->ihl*4]);
  829. +         }
  830. + #endif
  831. +         th = (struct tcphdr *)portptr;
  832. + 
  833. +         /*
  834. +          * Timeout depends if FIN packet was seen
  835. +          */
  836. +         if (ms->sawfin || th->fin) {
  837. +             ms->timer.expires = MASQUERADE_EXPIRE_TCP_FIN;
  838. +             ms->sawfin = 1;
  839. +         }
  840. +         else ms->timer.expires = MASQUERADE_EXPIRE_TCP;
  841. + 
  842. +         tcp_send_check(th,iph->saddr,iph->daddr,size,skb->sk);
  843. +     }
  844. +     add_timer(&ms->timer);
  845. +     ip_send_check(iph);
  846. + 
  847. + #ifdef DEBUG_MASQ
  848. +     printk("O-routed from %lX:%X over %s\n",ntohl(dev->pa_addr),ntohs(ms->mport),dev->name);
  849. + #endif
  850. + }
  851. + 
  852. + /*
  853. +  *    Check if it's an masqueraded port, look it up,
  854. +  *    and send it on it's way...
  855. +  *
  856. +  *    Better not have many hosts using the designated portrange
  857. +  *    as 'normal' ports, or you'll be spending lots of time in
  858. +  *    this function.
  859. +  */
  860. + int ip_fw_demasquerade(struct sk_buff *skb)
  861. + {
  862. +     struct iphdr    *iph = skb->h.iph;
  863. +     unsigned short    *portptr;
  864. +     struct ip_masq    *ms;
  865. +     int        size;
  866. + 
  867. +     if (iph->protocol!=IPPROTO_UDP && iph->protocol!=IPPROTO_TCP)
  868. +         return 0;
  869. + 
  870. +     portptr = (unsigned short *)&(((char *)iph)[iph->ihl*4]);
  871. +     if (ntohs(portptr[1]) < PORT_MASQ_BEGIN ||
  872. +         ntohs(portptr[1]) > PORT_MASQ_END)
  873. +         return 0;
  874. + 
  875. + #ifdef DEBUG_MASQ
  876. +     printk("Incoming %s %lX:%X -> %lX:%X\n",
  877. +         strProt[iph->protocol==IPPROTO_TCP],
  878. +         ntohl(iph->saddr), ntohs(portptr[0]),
  879. +         ntohl(iph->daddr), ntohs(portptr[1]));
  880. + #endif
  881. +     /*
  882. +      * reroute to original host:port if found...
  883. +      *
  884. +      * NB. Cannot check destination address, just for the incoming port.
  885. +      * reason: archie.doc.ac.uk has 6 interfaces, you send to
  886. +      * phoenix and get a reply from any other interface(==dst)!
  887. +      */
  888. +     ms = ip_msq_hosts;
  889. +     while (ms!=NULL) {
  890. +         if (iph->protocol==ms->protocol &&
  891. + /*            iph->saddr==ms->dst && */
  892. +             portptr[0]==ms->dport &&
  893. +             portptr[1]==ms->mport)
  894. +         {
  895. +             size = skb->len - ((unsigned char *)portptr - skb->h.raw);
  896. +             iph->daddr = ms->src;
  897. +             portptr[1] = ms->sport;
  898. +             
  899. +             /*
  900. +              * Yug! adjust UDP/TCP and IP checksums
  901. +              */
  902. +             if (iph->protocol==IPPROTO_UDP)
  903. +                 udp_send_check((struct udphdr *)portptr,iph->saddr,iph->daddr,size,skb->sk);
  904. +             else
  905. +                 tcp_send_check((struct tcphdr *)portptr,iph->saddr,iph->daddr,size,skb->sk);
  906. +             ip_send_check(iph);
  907. + #ifdef DEBUG_MASQ
  908. +             printk("I-routed to %lX:%X\n",ntohl(iph->daddr),ntohs(portptr[1]));
  909. + #endif
  910. +             return 1;
  911. +         }
  912. +         ms = ms->next;
  913. +     }
  914. + 
  915. +     /* sorry, all this trouble for a no-hit :) */
  916. +     return 0;
  917. + }
  918. + #endif
  919.   
  920.   static void zero_fw_chain(struct ip_fw *chainptr)
  921.   {
  922. ***************
  923. *** 442,448 ****
  924.       if ( ftmp == NULL ) 
  925.       {
  926.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  927. !         printf("ip_fw_ctl:  malloc said no\n");
  928.   #endif
  929.           return( ENOMEM );
  930.       }
  931. --- 854,860 ----
  932.       if ( ftmp == NULL ) 
  933.       {
  934.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  935. !         printk("ip_fw_ctl:  malloc said no\n");
  936.   #endif
  937.           return( ENOMEM );
  938.       }
  939. ***************
  940. *** 511,518 ****
  941.                       addb4--;
  942.               }
  943.   
  944. !             if (((o_da & o_dm) == (n_da & n_dm))
  945. !                            &&((o_sa & o_sm) == (n_sa & n_sm)))
  946.               {
  947.                   if (newkind!=IP_FW_F_ALL &&
  948.                       oldkind==IP_FW_F_ALL)
  949. --- 923,930 ----
  950.                       addb4--;
  951.               }
  952.   
  953. !             if (((o_da & o_dm) == (n_da & n_dm)) &&
  954. !                 ((o_sa & o_sm) == (n_sa & n_sm)))
  955.               {
  956.                   if (newkind!=IP_FW_F_ALL &&
  957.                       oldkind==IP_FW_F_ALL)
  958. ***************
  959. *** 603,609 ****
  960.       if (chtmp_prev)
  961.           chtmp_prev->fw_next=ftmp;
  962.       else
  963. !             *chainptr=ftmp;
  964.       restore_flags(flags);
  965.       return(0);
  966.   }
  967. --- 1015,1021 ----
  968.       if (chtmp_prev)
  969.           chtmp_prev->fw_next=ftmp;
  970.       else
  971. !         *chainptr=ftmp;
  972.       restore_flags(flags);
  973.       return(0);
  974.   }
  975. ***************
  976. *** 635,647 ****
  977.       while( ftmp != NULL )
  978.       {
  979.           matches=1;
  980. !          if (ftmp->fw_src.s_addr!=frwl->fw_src.s_addr 
  981.                ||  ftmp->fw_dst.s_addr!=frwl->fw_dst.s_addr
  982.                ||  ftmp->fw_smsk.s_addr!=frwl->fw_smsk.s_addr
  983.                ||  ftmp->fw_dmsk.s_addr!=frwl->fw_dmsk.s_addr
  984.                ||  ftmp->fw_via.s_addr!=frwl->fw_via.s_addr
  985.                ||  ftmp->fw_flg!=frwl->fw_flg)
  986. !                 matches=0;
  987.   
  988.           tport1=ftmp->fw_nsp+ftmp->fw_ndp;
  989.           tport2=frwl->fw_nsp+frwl->fw_ndp;
  990. --- 1047,1059 ----
  991.       while( ftmp != NULL )
  992.       {
  993.           matches=1;
  994. !         if (ftmp->fw_src.s_addr!=frwl->fw_src.s_addr 
  995.                ||  ftmp->fw_dst.s_addr!=frwl->fw_dst.s_addr
  996.                ||  ftmp->fw_smsk.s_addr!=frwl->fw_smsk.s_addr
  997.                ||  ftmp->fw_dmsk.s_addr!=frwl->fw_dmsk.s_addr
  998.                ||  ftmp->fw_via.s_addr!=frwl->fw_via.s_addr
  999.                ||  ftmp->fw_flg!=frwl->fw_flg)
  1000. !             matches=0;
  1001.   
  1002.           tport1=ftmp->fw_nsp+ftmp->fw_ndp;
  1003.           tport2=frwl->fw_nsp+frwl->fw_ndp;
  1004. ***************
  1005. *** 650,657 ****
  1006.           else if (tport1!=0)
  1007.           {
  1008.               for (tmpnum=0;tmpnum < tport1 && tmpnum < IP_FW_MAX_PORTS;tmpnum++)
  1009. !                 if (ftmp->fw_pts[tmpnum]!=frwl->fw_pts[tmpnum])
  1010. !                     matches=0;
  1011.           }
  1012.           if(matches)
  1013.           {
  1014. --- 1062,1069 ----
  1015.           else if (tport1!=0)
  1016.           {
  1017.               for (tmpnum=0;tmpnum < tport1 && tmpnum < IP_FW_MAX_PORTS;tmpnum++)
  1018. !             if (ftmp->fw_pts[tmpnum]!=frwl->fw_pts[tmpnum])
  1019. !                 matches=0;
  1020.           }
  1021.           if(matches)
  1022.           {
  1023. ***************
  1024. *** 661,671 ****
  1025.                   ltmp->fw_next=ftmp->fw_next;
  1026.                   kfree_s(ftmp,sizeof(*ftmp));
  1027.                   ftmp=ltmp->fw_next;
  1028. !                 }
  1029. !                   else
  1030. !                   {
  1031. !                       *chainptr=ftmp->fw_next; 
  1032. !                  kfree_s(ftmp,sizeof(*ftmp));
  1033.                   ftmp=*chainptr;
  1034.               }       
  1035.           }
  1036. --- 1073,1083 ----
  1037.                   ltmp->fw_next=ftmp->fw_next;
  1038.                   kfree_s(ftmp,sizeof(*ftmp));
  1039.                   ftmp=ltmp->fw_next;
  1040. !             }
  1041. !             else
  1042. !             {
  1043. !                 *chainptr=ftmp->fw_next; 
  1044. !                 kfree_s(ftmp,sizeof(*ftmp));
  1045.                   ftmp=*chainptr;
  1046.               }       
  1047.           }
  1048. ***************
  1049. *** 708,714 ****
  1050.       if ( (frwl->fw_flg & IP_FW_F_SRNG) && frwl->fw_nsp < 2 ) 
  1051.       {
  1052.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1053. !         printk("ip_fw_ctl: src range set but n_src_p=%d\n",
  1054.               frwl->fw_nsp);
  1055.   #endif
  1056.           return(NULL);
  1057. --- 1120,1126 ----
  1058.       if ( (frwl->fw_flg & IP_FW_F_SRNG) && frwl->fw_nsp < 2 ) 
  1059.       {
  1060.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1061. !         printk("ip_fw_ctl: src range set but fw_nsp=%d\n",
  1062.               frwl->fw_nsp);
  1063.   #endif
  1064.           return(NULL);
  1065. ***************
  1066. *** 717,723 ****
  1067.       if ( (frwl->fw_flg & IP_FW_F_DRNG) && frwl->fw_ndp < 2 ) 
  1068.       {
  1069.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1070. !         printk("ip_fw_ctl: dst range set but n_dst_p=%d\n",
  1071.               frwl->fw_ndp);
  1072.   #endif
  1073.           return(NULL);
  1074. --- 1129,1135 ----
  1075.       if ( (frwl->fw_flg & IP_FW_F_DRNG) && frwl->fw_ndp < 2 ) 
  1076.       {
  1077.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1078. !         printk("ip_fw_ctl: dst range set but fw_ndp=%d\n",
  1079.               frwl->fw_ndp);
  1080.   #endif
  1081.           return(NULL);
  1082. ***************
  1083. *** 740,751 ****
  1084.   
  1085.   #ifdef CONFIG_IP_ACCT
  1086.   
  1087. - void ip_acct_cnt(struct iphdr *iph, struct device *dev, struct ip_fw *f)
  1088. - {
  1089. -     (void) ip_fw_chk(iph, dev, f, 0, 1);
  1090. -     return;
  1091. - }
  1092. - 
  1093.   int ip_acct_ctl(int stage, void *m, int len)
  1094.   {
  1095.       if ( stage == IP_ACCT_FLUSH )
  1096. --- 1152,1157 ----
  1097. ***************
  1098. *** 775,790 ****
  1099.                   return( del_from_chain(&ip_acct_chain,frwl));
  1100.               default:
  1101.                   /*
  1102. !                   *    Should be panic but... (Why ??? - AC)
  1103.                    */
  1104.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1105. !                 printf("ip_acct_ctl:  unknown request %d\n",stage);
  1106.   #endif
  1107.                   return(EINVAL);
  1108.           }
  1109.       }
  1110.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1111. !     printf("ip_acct_ctl:  unknown request %d\n",stage);
  1112.   #endif
  1113.       return(EINVAL);
  1114.   }
  1115. --- 1181,1196 ----
  1116.                   return( del_from_chain(&ip_acct_chain,frwl));
  1117.               default:
  1118.                   /*
  1119. !                  *    Should be panic but... (Why ??? - AC)
  1120.                    */
  1121.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1122. !                 printk("ip_acct_ctl:  unknown request %d\n",stage);
  1123.   #endif
  1124.                   return(EINVAL);
  1125.           }
  1126.       }
  1127.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1128. !     printk("ip_acct_ctl:  unknown request %d\n",stage);
  1129.   #endif
  1130.       return(EINVAL);
  1131.   }
  1132. ***************
  1133. *** 839,845 ****
  1134.           if ( len < sizeof(struct ip_fwpkt) )
  1135.           {
  1136.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1137. !             printf("ip_fw_ctl: length=%d, expected %d\n",
  1138.                   len, sizeof(struct ip_fwpkt));
  1139.   #endif
  1140.               return( EINVAL );
  1141. --- 1245,1251 ----
  1142.           if ( len < sizeof(struct ip_fwpkt) )
  1143.           {
  1144.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1145. !             printk("ip_fw_ctl: length=%d, expected %d\n",
  1146.                   len, sizeof(struct ip_fwpkt));
  1147.   #endif
  1148.               return( EINVAL );
  1149. ***************
  1150. *** 851,857 ****
  1151.           if ( ip->ihl != sizeof(struct iphdr) / sizeof(int))
  1152.           {
  1153.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1154. !             printf("ip_fw_ctl: ip->ihl=%d, want %d\n",ip->ihl,
  1155.                       sizeof(struct ip)/sizeof(int));
  1156.   #endif
  1157.               return(EINVAL);
  1158. --- 1257,1263 ----
  1159.           if ( ip->ihl != sizeof(struct iphdr) / sizeof(int))
  1160.           {
  1161.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1162. !             printk("ip_fw_ctl: ip->ihl=%d, want %d\n",ip->ihl,
  1163.                       sizeof(struct ip)/sizeof(int));
  1164.   #endif
  1165.               return(EINVAL);
  1166. ***************
  1167. *** 908,914 ****
  1168.       } 
  1169.   
  1170.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1171. !     printf("ip_fw_ctl:  unknown request %d\n",stage);
  1172.   #endif
  1173.       return(EINVAL);
  1174.   }
  1175. --- 1314,1320 ----
  1176.       } 
  1177.   
  1178.   #ifdef DEBUG_CONFIG_IP_FIREWALL
  1179. !     printk("ip_fw_ctl:  unknown request %d\n",stage);
  1180.   #endif
  1181.       return(EINVAL);
  1182.   }
  1183. ***************
  1184. *** 1013,1016 ****
  1185. --- 1419,1467 ----
  1186.       return ip_chain_procinfo(IP_INFO_FWD, buffer,start,offset,length,reset);
  1187.   }
  1188.   
  1189. + #endif
  1190. + 
  1191. + #ifdef CONFIG_IP_MASQUERADE
  1192. + 
  1193. + int ip_msqhst_procinfo(char *buffer, char **start, off_t offset, int length)
  1194. + {
  1195. +     off_t pos=0, begin=0;
  1196. +     struct ip_masq *ms;
  1197. +     unsigned long flags;
  1198. +     int len=0;
  1199. + 
  1200. +     len=sprintf(buffer,"Prc FromIP   FPrt ToIP     TPrt Masq Init-seq Delta Expires\n"); 
  1201. +     save_flags(flags);
  1202. +     cli();
  1203. + 
  1204. +     ms=ip_msq_hosts;
  1205. +     while (ms!=NULL) {
  1206. +         int timer_active = del_timer(&ms->timer);
  1207. +         if (!timer_active)
  1208. +             ms->timer.expires = 0;
  1209. +         len+=sprintf(buffer+len,"%s %08lX:%04X %08lX:%04X %04X %08lX %5d %lu\n",
  1210. +             strProt[ms->protocol==IPPROTO_TCP],
  1211. +             ntohl(ms->src),ntohs(ms->sport),
  1212. +             ntohl(ms->dst),ntohs(ms->dport),
  1213. +             ntohs(ms->mport),
  1214. +             ms->init_seq,ms->delta,ms->timer.expires);
  1215. +         if (timer_active)
  1216. +             add_timer(&ms->timer);
  1217. + 
  1218. +         pos=begin+len;
  1219. +         if(pos<offset) {
  1220. +             len=0;
  1221. +             begin=pos;
  1222. +         }
  1223. +         if(pos>offset+length)
  1224. +             break;
  1225. +         ms=ms->next;
  1226. +     }
  1227. +     restore_flags(flags);
  1228. +     *start=buffer+(offset-begin);
  1229. +     len-=(offset-begin);
  1230. +     if(len>length)
  1231. +         len=length;
  1232. +     return len;
  1233. + }
  1234.   #endif
  1235. diff -rc linux/net/inet/udp.c linux+masq/net/inet/udp.c
  1236. *** linux/net/inet/udp.c    Thu Jan 26 06:25:54 1995
  1237. --- linux+masq/net/inet/udp.c    Thu Mar  9 10:00:27 1995
  1238. ***************
  1239. *** 230,236 ****
  1240.    *    doing or get burned...
  1241.    */
  1242.   
  1243. ! static void udp_send_check(struct udphdr *uh, unsigned long saddr, 
  1244.              unsigned long daddr, int len, struct sock *sk)
  1245.   {
  1246.       uh->check = 0;
  1247. --- 230,236 ----
  1248.    *    doing or get burned...
  1249.    */
  1250.   
  1251. ! void udp_send_check(struct udphdr *uh, unsigned long saddr, 
  1252.              unsigned long daddr, int len, struct sock *sk)
  1253.   {
  1254.       uh->check = 0;
  1255. diff -rc linux/net/inet/udp.h linux+masq/net/inet/udp.h
  1256. *** linux/net/inet/udp.h    Wed Dec  1 13:44:15 1993
  1257. --- linux+masq/net/inet/udp.h    Thu Mar  9 10:00:27 1995
  1258. ***************
  1259. *** 33,38 ****
  1260. --- 33,40 ----
  1261.   
  1262.   extern void    udp_err(int err, unsigned char *header, unsigned long daddr,
  1263.               unsigned long saddr, struct inet_protocol *protocol);
  1264. + extern void    udp_send_check(struct udphdr *uh, unsigned long saddr, 
  1265. +             unsigned long daddr, int len, struct sock *sk);
  1266.   extern int    udp_recvfrom(struct sock *sk, unsigned char *to,
  1267.                    int len, int noblock, unsigned flags,
  1268.                    struct sockaddr_in *sin, int *addr_len);
  1269.  
  1270.  
  1271.