开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ipchains_core.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：49k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ipchains_core.c：源码内容
  1. /* Minor modifications to fit on compatibility framework:
  2.    Rusty.Russell@rustcorp.com.au
  3. */
  5. /*
  6.  * This code is heavily based on the code on the old ip_fw.c code; see below for
  7.  * copyrights and attributions of the old code.  This code is basically GPL.
  8.  *
  9.  * 15-Aug-1997: Major changes to allow graphs for firewall rules.
  10.  *              Paul Russell <Paul.Russell@rustcorp.com.au> and
  11.  * Michael Neuling <Michael.Neuling@rustcorp.com.au>
  12.  * 24-Aug-1997: Generalised protocol handling (not just TCP/UDP/ICMP).
  13.  *              Added explicit RETURN from chains.
  14.  *              Removed TOS mangling (done in ipchains 1.0.1).
  15.  *              Fixed read & reset bug by reworking proc handling.
  16.  *              Paul Russell <Paul.Russell@rustcorp.com.au>
  17.  * 28-Sep-1997: Added packet marking for net sched code.
  18.  *              Removed fw_via comparisons: all done on device name now,
  19.  *              similar to changes in ip_fw.c in DaveM's CVS970924 tree.
  20.  *              Paul Russell <Paul.Russell@rustcorp.com.au>
  21.  * 2-Nov-1997:  Moved types across to __u16, etc.
  22.  *              Added inverse flags.
  23.  *              Fixed fragment bug (in args to port_match).
  24.  *              Changed mark to only one flag (MARKABS).
  25.  * 21-Nov-1997: Added ability to test ICMP code.
  26.  * 19-Jan-1998: Added wildcard interfaces.
  27.  * 6-Feb-1998:  Merged 2.0 and 2.1 versions.
  28.  *              Initialised ip_masq for 2.0.x version.
  29.  *              Added explicit NETLINK option for 2.1.x version.
  30.  *              Added packet and byte counters for policy matches.
  31.  * 26-Feb-1998: Fixed race conditions, added SMP support.
  32.  * 18-Mar-1998: Fix SMP, fix race condition fix.
  33.  * 1-May-1998:  Remove caching of device pointer.
  34.  * 12-May-1998: Allow tiny fragment case for TCP/UDP.
  35.  * 15-May-1998: Treat short packets as fragments, don't just block.
  36.  * 3-Jan-1999:  Fixed serious procfs security hole -- users should never
  37.  *              be allowed to view the chains!
  38.  *              Marc Santoro <ultima@snicker.emoti.com>
  39.  * 29-Jan-1999: Locally generated bogus IPs dealt with, rather than crash
  40.  *              during dump_packet. --RR.
  41.  * 19-May-1999: Star Wars: The Phantom Menace opened.  Rule num
  42.  * printed in log (modified from Michael Hasenstein's patch).
  43.  * Added SYN in log message. --RR
  44.  * 23-Jul-1999: Fixed small fragment security exposure opened on 15-May-1998.
  45.  *              John McDonald <jm@dataprotect.com>
  46.  *              Thomas Lopatic <tl@dataprotect.com>
  47.  */
  49. /*
  50.  *
  51.  * The origina Linux port was done Alan Cox, with changes/fixes from
  52.  * Pauline Middlelink, Jos Vos, Thomas Quinot, Wouter Gadeyne, Juan
  53.  * Jose Ciarlante, Bernd Eckenfels, Keith Owens and others.
  54.  *
  55.  * Copyright from the original FreeBSD version follows:
  56.  *
  57.  * Copyright (c) 1993 Daniel Boulet
  58.  * Copyright (c) 1994 Ugen J.S.Antsilevich
  59.  *
  60.  * Redistribution and use in source forms, with and without modification,
  61.  * are permitted provided that this entire comment appears intact.
  62.  *
  63.  * Redistribution in binary form may occur without any restrictions.
  64.  * Obviously, it would be nice if you gave credit where credit is due
  65.  * but requiring it would be too onerous.
  66.  *
  67.  * This software is provided ``AS IS'' without any warranties of any kind.  */
  69. #include <linux/config.h>
  71. #include <asm/uaccess.h>
  72. #include <asm/system.h>
  73. #include <linux/types.h>
  74. #include <linux/sched.h>
  75. #include <linux/string.h>
  76. #include <linux/errno.h>
  77. #include <linux/module.h>
  79. #include <linux/socket.h>
  80. #include <linux/sockios.h>
  81. #include <linux/in.h>
  82. #include <linux/inet.h>
  83. #include <linux/netdevice.h>
  84. #include <linux/icmp.h>
  85. #include <linux/udp.h>
  86. #include <net/ip.h>
  87. #include <net/protocol.h>
  88. #include <net/route.h>
  89. #include <net/tcp.h>
  90. #include <net/udp.h>
  91. #include <net/sock.h>
  92. #include <net/icmp.h>
  93. #include <linux/netlink.h>
  94. #include <linux/netfilter.h>
  95. #include <linux/netfilter_ipv4/compat_firewall.h>
  96. #include <linux/netfilter_ipv4/ipchains_core.h>
  98. #include <net/checksum.h>
  99. #include <linux/proc_fs.h>
  100. #include <linux/stat.h>
  102. /* Understanding locking in this code: (thanks to Alan Cox for using
  103.  * little words to explain this to me). -- PR
  104.  *
  105.  * In UP, there can be two packets traversing the chains:
  106.  * 1) A packet from the current userspace context
  107.  * 2) A packet off the bh handlers (timer or net).
  108.  *
  109.  * For SMP (kernel v2.1+), multiply this by # CPUs.
  110.  *
  111.  * [Note that this in not correct for 2.2 - because the socket code always
  112.  *  uses lock_kernel() to serialize, and bottom halves (timers and net_bhs)
  113.  *  only run on one CPU at a time.  This will probably change for 2.3.
  114.  *  It is still good to use spinlocks because that avoids the global cli()
  115.  *  for updating the tables, which is rather costly in SMP kernels -AK]
  116.  *
  117.  * This means counters and backchains can get corrupted if no precautions
  118.  * are taken.
  119.  *
  120.  * To actually alter a chain on UP, we need only do a cli(), as this will
  121.  * stop a bh handler firing, as we are in the current userspace context
  122.  * (coming from a setsockopt()).
  123.  *
  124.  * On SMP, we need a write_lock_irqsave(), which is a simple cli() in
  125.  * UP.
  126.  *
  127.  * For backchains and counters, we use an array, indexed by
  128.  * [cpu_number_map[smp_processor_id()]*2 + !in_interrupt()]; the array is of
  129.  * size [smp_num_cpus*2].  For v2.0, smp_num_cpus is effectively 1.  So,
  130.  * confident of uniqueness, we modify counters even though we only
  131.  * have a read lock (to read the counters, you need a write lock,
  132.  * though).  */
  134. /* Why I didn't use straight locking... -- PR
  135.  *
  136.  * The backchains can be separated out of the ip_chains structure, and
  137.  * allocated as needed inside ip_fw_check().
  138.  *
  139.  * The counters, however, can't.  Trying to lock these means blocking
  140.  * interrupts every time we want to access them.  This would suck HARD
  141.  * performance-wise.  Not locking them leads to possible corruption,
  142.  * made worse on 32-bit machines (counters are 64-bit).  */
  144. /*#define DEBUG_IP_FIREWALL*/
  145. /*#define DEBUG_ALLOW_ALL*/ /* Useful for remote debugging */
  146. /*#define DEBUG_IP_FIREWALL_USER*/
  147. /*#define DEBUG_IP_FIREWALL_LOCKING*/
  149. #if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE)
  150. static struct sock *ipfwsk;
  151. #endif
  153. #ifdef CONFIG_SMP
  154. #define SLOT_NUMBER() (cpu_number_map(smp_processor_id())*2 + !in_interrupt())
  155. #else /* !SMP */
  156. #define SLOT_NUMBER() (!in_interrupt())
  157. #endif /* CONFIG_SMP */
  158. #define NUM_SLOTS (smp_num_cpus*2)
  160. #define SIZEOF_STRUCT_IP_CHAIN (sizeof(struct ip_chain) 
  161. + NUM_SLOTS*sizeof(struct ip_reent))
  162. #define SIZEOF_STRUCT_IP_FW_KERNEL (sizeof(struct ip_fwkernel) 
  163.     + NUM_SLOTS*sizeof(struct ip_counters))
  165. #ifdef DEBUG_IP_FIREWALL_LOCKING
  166. static unsigned int fwc_rlocks, fwc_wlocks;
  167. #define FWC_DEBUG_LOCK(d)
  168. do {
  169. FWC_DONT_HAVE_LOCK(d);
  170. d |= (1 << SLOT_NUMBER());
  171. } while (0)
  173. #define FWC_DEBUG_UNLOCK(d)
  174. do {
  175. FWC_HAVE_LOCK(d);
  176. d &= ~(1 << SLOT_NUMBER());
  177. } while (0)
  179. #define FWC_DONT_HAVE_LOCK(d)
  180. do {
  181. if ((d) & (1 << SLOT_NUMBER()))
  182. printk("%s:%i: Got lock on %i already!n", 
  183.        __FILE__, __LINE__, SLOT_NUMBER());
  184. } while(0)
  186. #define FWC_HAVE_LOCK(d)
  187. do {
  188. if (!((d) & (1 << SLOT_NUMBER())))
  189. printk("%s:%i:No lock on %i!n", 
  190.        __FILE__, __LINE__, SLOT_NUMBER());
  191. } while (0)
  193. #else
  194. #define FWC_DEBUG_LOCK(d) do { } while(0)
  195. #define FWC_DEBUG_UNLOCK(d) do { } while(0)
  196. #define FWC_DONT_HAVE_LOCK(d) do { } while(0)
  197. #define FWC_HAVE_LOCK(d) do { } while(0)
  198. #endif /*DEBUG_IP_FIRWALL_LOCKING*/
  200. #define FWC_READ_LOCK(l) do { FWC_DEBUG_LOCK(fwc_rlocks); read_lock(l); } while (0)
  201. #define FWC_WRITE_LOCK(l) do { FWC_DEBUG_LOCK(fwc_wlocks); write_lock(l); } while (0)
  202. #define FWC_READ_LOCK_IRQ(l,f) do { FWC_DEBUG_LOCK(fwc_rlocks); read_lock_irqsave(l,f); } while (0)
  203. #define FWC_WRITE_LOCK_IRQ(l,f) do { FWC_DEBUG_LOCK(fwc_wlocks); write_lock_irqsave(l,f); } while (0)
  204. #define FWC_READ_UNLOCK(l) do { FWC_DEBUG_UNLOCK(fwc_rlocks); read_unlock(l); } while (0)
  205. #define FWC_WRITE_UNLOCK(l) do { FWC_DEBUG_UNLOCK(fwc_wlocks); write_unlock(l); } while (0)
  206. #define FWC_READ_UNLOCK_IRQ(l,f) do { FWC_DEBUG_UNLOCK(fwc_rlocks); read_unlock_irqrestore(l,f); } while (0)
  207. #define FWC_WRITE_UNLOCK_IRQ(l,f) do { FWC_DEBUG_UNLOCK(fwc_wlocks); write_unlock_irqrestore(l,f); } while (0)
  209. struct ip_chain;
  211. struct ip_counters
  212. {
  213. __u64 pcnt, bcnt; /* Packet and byte counters */
  214. };
  216. struct ip_fwkernel
  217. {
  218. struct ip_fw ipfw;
  219. struct ip_fwkernel *next; /* where to go next if current
  220.  * rule doesn't match */
  221. struct ip_chain *branch; /* which branch to jump to if
  222.  * current rule matches */
  223. int simplebranch; /* Use this if branch == NULL */
  224. struct ip_counters counters[0]; /* Actually several of these */
  225. };
  227. struct ip_reent
  228. {
  229. struct ip_chain *prevchain; /* Pointer to referencing chain */
  230. struct ip_fwkernel *prevrule; /* Pointer to referencing rule */
  231. struct ip_counters counters;
  232. };
  234. struct ip_chain
  235. {
  236. ip_chainlabel label;     /* Defines the label for each block */
  237.   struct ip_chain *next;     /* Pointer to next block */
  238. struct ip_fwkernel *chain;  /* Pointer to first rule in block */
  239. __u32 refcount;      /* Number of refernces to block */
  240. int policy;     /* Default rule for chain.  Only *
  241.      * used in built in chains */
  242. struct ip_reent reent[0];   /* Actually several of these */
  243. };
  245. /*
  246.  * Implement IP packet firewall
  247.  */
  249. #ifdef DEBUG_IP_FIREWALL
  250. #define dprintf(format, args...)  printk(format , ## args)
  251. #else
  252. #define dprintf(format, args...)
  253. #endif
  255. #ifdef DEBUG_IP_FIREWALL_USER
  256. #define duprintf(format, args...) printk(format , ## args)
  257. #else
  258. #define duprintf(format, args...)
  259. #endif
  261. /* Lock around ip_fw_chains linked list structure */
  262. rwlock_t ip_fw_lock = RW_LOCK_UNLOCKED;
  264. /* Head of linked list of fw rules */
  265. static struct ip_chain *ip_fw_chains;
  267. #define IP_FW_INPUT_CHAIN ip_fw_chains
  268. #define IP_FW_FORWARD_CHAIN (ip_fw_chains->next)
  269. #define IP_FW_OUTPUT_CHAIN (ip_fw_chains->next->next)
  271. /* Returns 1 if the port is matched by the range, 0 otherwise */
  272. extern inline int port_match(__u16 min, __u16 max, __u16 port,
  273.      int frag, int invert)
  274. {
  275. if (frag) /* Fragments fail ANY port test. */
  276. return (min == 0 && max == 0xFFFF);
  277. else return (port >= min && port <= max) ^ invert;
  278. }
  280. /* Returns whether matches rule or not. */
  281. static int ip_rule_match(struct ip_fwkernel *f,
  282.  const char *ifname,
  283.  struct iphdr *ip,
  284.  char tcpsyn,
  285.  __u16 src_port, __u16 dst_port,
  286.  char isfrag)
  287. {
  288. #define FWINV(bool,invflg) ((bool) ^ !!(f->ipfw.fw_invflg & invflg))
  289. /*
  290.  * This is a bit simpler as we don't have to walk
  291.  * an interface chain as you do in BSD - same logic
  292.  * however.
  293.  */
  295. if (FWINV((ip->saddr&f->ipfw.fw_smsk.s_addr) != f->ipfw.fw_src.s_addr,
  296.   IP_FW_INV_SRCIP)
  297.     || FWINV((ip->daddr&f->ipfw.fw_dmsk.s_addr)!=f->ipfw.fw_dst.s_addr,
  298.      IP_FW_INV_DSTIP)) {
  299. dprintf("Source or dest mismatch.n");
  301. dprintf("SRC: %u. Mask: %u. Target: %u.%sn", ip->saddr,
  302. f->ipfw.fw_smsk.s_addr, f->ipfw.fw_src.s_addr,
  303. f->ipfw.fw_invflg & IP_FW_INV_SRCIP ? " (INV)" : "");
  304. dprintf("DST: %u. Mask: %u. Target: %u.%sn", ip->daddr,
  305. f->ipfw.fw_dmsk.s_addr, f->ipfw.fw_dst.s_addr,
  306. f->ipfw.fw_invflg & IP_FW_INV_DSTIP ? " (INV)" : "");
  307. return 0;
  308. }
  310. /*
  311.  * Look for a VIA device match
  312.  */
  313. if (f->ipfw.fw_flg & IP_FW_F_WILDIF) {
  314.     if (FWINV(strncmp(ifname, f->ipfw.fw_vianame,
  315.       strlen(f->ipfw.fw_vianame)) != 0,
  316.       IP_FW_INV_VIA)) {
  317. dprintf("Wildcard interface mismatch.%sn",
  318. f->ipfw.fw_invflg & IP_FW_INV_VIA ? " (INV)" : "");
  319. return 0; /* Mismatch */
  320.     }
  321. }
  322. else if (FWINV(strcmp(ifname, f->ipfw.fw_vianame) != 0,
  323.        IP_FW_INV_VIA)) {
  324.     dprintf("Interface name does not match.%sn",
  325.     f->ipfw.fw_invflg & IP_FW_INV_VIA
  326.     ? " (INV)" : "");
  327.     return 0; /* Mismatch */
  328. }
  330. /*
  331.  * Ok the chain addresses match.
  332.  */
  334. /* If we have a fragment rule but the packet is not a fragment
  335.  * the we return zero */
  336. if (FWINV((f->ipfw.fw_flg&IP_FW_F_FRAG) && !isfrag, IP_FW_INV_FRAG)) {
  337. dprintf("Fragment rule but not fragment.%sn",
  338. f->ipfw.fw_invflg & IP_FW_INV_FRAG ? " (INV)" : "");
  339. return 0;
  340. }
  342. /* Fragment NEVER passes a SYN test, even an inverted one. */
  343. if (FWINV((f->ipfw.fw_flg&IP_FW_F_TCPSYN) && !tcpsyn, IP_FW_INV_SYN)
  344.     || (isfrag && (f->ipfw.fw_flg&IP_FW_F_TCPSYN))) {
  345. dprintf("Rule requires SYN and packet has no SYN.%sn",
  346. f->ipfw.fw_invflg & IP_FW_INV_SYN ? " (INV)" : "");
  347. return 0;
  348. }
  350. if (f->ipfw.fw_proto) {
  351. /*
  352.  * Specific firewall - packet's protocol
  353.  * must match firewall's.
  354.  */
  356. if (FWINV(ip->protocol!=f->ipfw.fw_proto, IP_FW_INV_PROTO)) {
  357. dprintf("Packet protocol %hi does not match %hi.%sn",
  358. ip->protocol, f->ipfw.fw_proto,
  359. f->ipfw.fw_invflg&IP_FW_INV_PROTO ? " (INV)":"");
  360. return 0;
  361. }
  363. /* For non TCP/UDP/ICMP, port range is max anyway. */
  364. if (!port_match(f->ipfw.fw_spts[0],
  365. f->ipfw.fw_spts[1],
  366. src_port, isfrag,
  367. !!(f->ipfw.fw_invflg&IP_FW_INV_SRCPT))
  368.     || !port_match(f->ipfw.fw_dpts[0],
  369.    f->ipfw.fw_dpts[1],
  370.    dst_port, isfrag,
  371.    !!(f->ipfw.fw_invflg
  372.       &IP_FW_INV_DSTPT))) {
  373.     dprintf("Port match failed.n");
  374.     return 0;
  375. }
  376. }
  378. dprintf("Match succeeded.n");
  379. return 1;
  380. }
  382. static const char *branchname(struct ip_chain *branch,int simplebranch)
  383. {
  384. if (branch)
  385. return branch->label;
  386. switch (simplebranch)
  387. {
  388. case FW_BLOCK: return IP_FW_LABEL_BLOCK;
  389. case FW_ACCEPT: return IP_FW_LABEL_ACCEPT;
  390. case FW_REJECT: return IP_FW_LABEL_REJECT;
  391. case FW_REDIRECT: return IP_FW_LABEL_REDIRECT;
  392. case FW_MASQUERADE: return IP_FW_LABEL_MASQUERADE;
  393. case FW_SKIP: return "-";
  394. case FW_SKIP+1: return IP_FW_LABEL_RETURN;
  395. default:
  396. return "UNKNOWN";
  397. }
  398. }
  400. /*
  401.  * VERY ugly piece of code which actually
  402.  * makes kernel printf for matching packets...
  403.  */
  404. static void dump_packet(const struct iphdr *ip,
  405. const char *ifname,
  406. struct ip_fwkernel *f,
  407. const ip_chainlabel chainlabel,
  408. __u16 src_port,
  409. __u16 dst_port,
  410. unsigned int count,
  411. int syn)
  412. {
  413. __u32 *opt = (__u32 *) (ip + 1);
  414. int opti;
  416. if (f) {
  417. printk(KERN_INFO "Packet log: %s ",chainlabel);
  418. printk("%s ",branchname(f->branch,f->simplebranch));
  419. if (f->simplebranch==FW_REDIRECT)
  420. printk("%d ",f->ipfw.fw_redirpt);
  421. }
  423. printk("%s PROTO=%d %u.%u.%u.%u:%hu %u.%u.%u.%u:%hu"
  424.        " L=%hu S=0x%2.2hX I=%hu F=0x%4.4hX T=%hu",
  425.        ifname, ip->protocol, NIPQUAD(ip->saddr),
  426.        src_port, NIPQUAD(ip->daddr),
  427.        dst_port,
  428.        ntohs(ip->tot_len), ip->tos, ntohs(ip->id),
  429.        ntohs(ip->frag_off), ip->ttl);
  431. for (opti = 0; opti < (ip->ihl - sizeof(struct iphdr) / 4); opti++)
  432. printk(" O=0x%8.8X", *opt++);
  433. printk(" %s(#%d)n", syn ? "SYN " : /* "PENANCE" */ "", count);
  434. }
  436. /* function for checking chain labels for user space. */
  437. static int check_label(ip_chainlabel label)
  438. {
  439. unsigned int i;
  440. /* strlen must be < IP_FW_MAX_LABEL_LENGTH. */
  441. for (i = 0; i < IP_FW_MAX_LABEL_LENGTH + 1; i++)
  442. if (label[i] == '') return 1;
  444. return 0;
  445. }
  447. /* This function returns a pointer to the first chain with a label
  448.  * that matches the one given. */
  449. static struct ip_chain *find_label(ip_chainlabel label)
  450. {
  451. struct ip_chain *tmp;
  452. FWC_HAVE_LOCK(fwc_rlocks | fwc_wlocks);
  453. for (tmp = ip_fw_chains; tmp; tmp = tmp->next)
  454. if (strcmp(tmp->label,label) == 0)
  455. break;
  456. return tmp;
  457. }
  459. /* This function returns a boolean which when true sets answer to one
  460.    of the FW_*. */
  461. static int find_special(ip_chainlabel label, int *answer)
  462. {
  463. if (label[0] == '') {
  464. *answer = FW_SKIP; /* => pass-through rule */
  465. return 1;
  466. } else if (strcmp(label,IP_FW_LABEL_ACCEPT) == 0) {
  467. *answer = FW_ACCEPT;
  468. return 1;
  469. } else if (strcmp(label,IP_FW_LABEL_BLOCK) == 0) {
  470. *answer = FW_BLOCK;
  471. return 1;
  472. } else if (strcmp(label,IP_FW_LABEL_REJECT) == 0) {
  473. *answer = FW_REJECT;
  474. return 1;
  475. } else if (strcmp(label,IP_FW_LABEL_REDIRECT) == 0) {
  476. *answer = FW_REDIRECT;
  477. return 1;
  478. } else if (strcmp(label,IP_FW_LABEL_MASQUERADE) == 0) {
  479. *answer = FW_MASQUERADE;
  480. return 1;
  481. } else if (strcmp(label, IP_FW_LABEL_RETURN) == 0) {
  482. *answer = FW_SKIP+1;
  483. return 1;
  484. } else {
  485. return 0;
  486. }
  487. }
  489. /* This function cleans up the prevchain and prevrule.  If the verbose
  490.  * flag is set then he names of the chains will be printed as it
  491.  * cleans up.  */
  492. static void cleanup(struct ip_chain *chain,
  493.     const int verbose,
  494.     unsigned int slot)
  495. {
  496. struct ip_chain *tmpchain = chain->reent[slot].prevchain;
  497. if (verbose)
  498. printk(KERN_ERR "Chain backtrace: ");
  499. while (tmpchain) {
  500. if (verbose)
  501. printk("%s<-",chain->label);
  502. chain->reent[slot].prevchain = NULL;
  503. chain = tmpchain;
  504. tmpchain = chain->reent[slot].prevchain;
  505. }
  506. if (verbose)
  507. printk("%sn",chain->label);
  508. }
  510. static inline int
  511. ip_fw_domatch(struct ip_fwkernel *f,
  512.       struct iphdr *ip,
  513.       const char *rif,
  514.       const ip_chainlabel label,
  515.       struct sk_buff *skb,
  516.       unsigned int slot,
  517.       __u16 src_port, __u16 dst_port,
  518.       unsigned int count,
  519.       int tcpsyn)
  520. {
  521. f->counters[slot].bcnt+=ntohs(ip->tot_len);
  522. f->counters[slot].pcnt++;
  523. if (f->ipfw.fw_flg & IP_FW_F_PRN) {
  524. dump_packet(ip,rif,f,label,src_port,dst_port,count,tcpsyn);
  525. }
  526. ip->tos = (ip->tos & f->ipfw.fw_tosand) ^ f->ipfw.fw_tosxor;
  528. /* This functionality is useless in stock 2.0.x series, but we don't
  529.  * discard the mark thing altogether, to avoid breaking ipchains (and,
  530.  * more importantly, the ipfwadm wrapper) --PR */
  531. if (f->ipfw.fw_flg & IP_FW_F_MARKABS) {
  532. skb->nfmark = f->ipfw.fw_mark;
  533. } else {
  534. skb->nfmark += f->ipfw.fw_mark;
  535. }
  536. if (f->ipfw.fw_flg & IP_FW_F_NETLINK) {
  537. #if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE)
  538. size_t len = min_t(unsigned int, f->ipfw.fw_outputsize, ntohs(ip->tot_len))
  539. + sizeof(__u32) + sizeof(skb->nfmark) + IFNAMSIZ;
  540. struct sk_buff *outskb=alloc_skb(len, GFP_ATOMIC);
  542. duprintf("Sending packet out NETLINK (length = %u).n",
  543.  (unsigned int)len);
  544. if (outskb) {
  545. /* Prepend length, mark & interface */
  546. skb_put(outskb, len);
  547. *((__u32 *)outskb->data) = (__u32)len;
  548. *((__u32 *)(outskb->data+sizeof(__u32))) = skb->nfmark;
  549. strcpy(outskb->data+sizeof(__u32)*2, rif);
  550. memcpy(outskb->data+sizeof(__u32)*2+IFNAMSIZ, ip,
  551.        len-(sizeof(__u32)*2+IFNAMSIZ));
  552. netlink_broadcast(ipfwsk, outskb, 0, ~0, GFP_KERNEL);
  553. }
  554. else {
  555. #endif
  556. if (net_ratelimit())
  557. printk(KERN_WARNING "ip_fw: packet drop due to "
  558.        "netlink failuren");
  559. return 0;
  560. #if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE)
  561. }
  562. #endif
  563. }
  564. return 1;
  565. }
  567. /*
  568.  * Returns one of the generic firewall policies, like FW_ACCEPT.
  569.  *
  570.  * The testing is either false for normal firewall mode or true for
  571.  * user checking mode (counters are not updated, TOS & mark not done).
  572.  */
  573. static int
  574. ip_fw_check(struct iphdr *ip,
  575.     const char *rif,
  576.     __u16 *redirport,
  577.     struct ip_chain *chain,
  578.     struct sk_buff *skb,
  579.     unsigned int slot,
  580.     int testing)
  581. {
  582. struct tcphdr *tcp=(struct tcphdr *)((__u32 *)ip+ip->ihl);
  583. struct udphdr *udp=(struct udphdr *)((__u32 *)ip+ip->ihl);
  584. struct icmphdr *icmp=(struct icmphdr *)((__u32 *)ip+ip->ihl);
  585. __u32 src, dst;
  586. __u16 src_port = 0xFFFF, dst_port = 0xFFFF;
  587. char tcpsyn=0;
  588. __u16 offset;
  589. unsigned char oldtos;
  590. struct ip_fwkernel *f;
  591. int ret = FW_SKIP+2;
  592. unsigned int count;
  594. /* We handle fragments by dealing with the first fragment as
  595.  * if it was a normal packet.  All other fragments are treated
  596.  * normally, except that they will NEVER match rules that ask
  597.  * things we don't know, ie. tcp syn flag or ports).  If the
  598.  * rule is also a fragment-specific rule, non-fragments won't
  599.  * match it. */
  601. offset = ntohs(ip->frag_off) & IP_OFFSET;
  603. /*
  604.  * Don't allow a fragment of TCP 8 bytes in. Nobody
  605.  * normal causes this. Its a cracker trying to break
  606.  * in by doing a flag overwrite to pass the direction
  607.  * checks.
  608.  */
  609. if (offset == 1 && ip->protocol == IPPROTO_TCP) {
  610. if (!testing && net_ratelimit()) {
  611. printk("Suspect TCP fragment.n");
  612. dump_packet(ip,rif,NULL,NULL,0,0,0,0);
  613. }
  614. return FW_BLOCK;
  615. }
  617. /* If we can't investigate ports, treat as fragment.  It's
  618.  * either a trucated whole packet, or a truncated first
  619.  * fragment, or a TCP first fragment of length 8-15, in which
  620.  * case the above rule stops reassembly.
  621.  */
  622. if (offset == 0) {
  623. unsigned int size_req;
  624. switch (ip->protocol) {
  625. case IPPROTO_TCP:
  626. /* Don't care about things past flags word */
  627. size_req = 16;
  628. break;
  630. case IPPROTO_UDP:
  631. case IPPROTO_ICMP:
  632. size_req = 8;
  633. break;
  635. default:
  636. size_req = 0;
  637. }
  639. /* If it is a truncated first fragment then it can be
  640.  * used to rewrite port information, and thus should
  641.  * be blocked.
  642.  */
  643. if (ntohs(ip->tot_len) < (ip->ihl<<2)+size_req) {
  644. if (!testing && net_ratelimit()) {
  645. printk("Suspect short first fragment.n");
  646. dump_packet(ip,rif,NULL,NULL,0,0,0,0);
  647. }
  648. return FW_BLOCK;
  649. }
  650. }
  652. src = ip->saddr;
  653. dst = ip->daddr;
  654. oldtos = ip->tos;
  656. /*
  657.  * If we got interface from which packet came
  658.  * we can use the address directly. Linux 2.1 now uses address
  659.  * chains per device too, but unlike BSD we first check if the
  660.  * incoming packet matches a device address and the routing
  661.  * table before calling the firewall.
  662.  */
  664. dprintf("Packet ");
  665. switch(ip->protocol)
  666. {
  667. case IPPROTO_TCP:
  668. dprintf("TCP ");
  669. if (!offset) {
  670. src_port=ntohs(tcp->source);
  671. dst_port=ntohs(tcp->dest);
  673. /* Connection initilisation can only
  674.  * be made when the syn bit is set and
  675.  * neither of the ack or reset is
  676.  * set. */
  677. if(tcp->syn && !(tcp->ack || tcp->rst))
  678. tcpsyn=1;
  679. }
  680. break;
  681. case IPPROTO_UDP:
  682. dprintf("UDP ");
  683. if (!offset) {
  684. src_port=ntohs(udp->source);
  685. dst_port=ntohs(udp->dest);
  686. }
  687. break;
  688. case IPPROTO_ICMP:
  689. if (!offset) {
  690. src_port=(__u16)icmp->type;
  691. dst_port=(__u16)icmp->code;
  692. }
  693. dprintf("ICMP ");
  694. break;
  695. default:
  696. dprintf("p=%d ",ip->protocol);
  697. break;
  698. }
  699. #ifdef DEBUG_IP_FIREWALL
  700. print_ip(ip->saddr);
  702. if (offset)
  703. dprintf(":fragment (%i) ", ((int)offset)<<2);
  704. else if (ip->protocol==IPPROTO_TCP || ip->protocol==IPPROTO_UDP
  705.  || ip->protocol==IPPROTO_ICMP)
  706. dprintf(":%hu:%hu", src_port, dst_port);
  707. dprintf("n");
  708. #endif
  710. if (!testing) FWC_READ_LOCK(&ip_fw_lock);
  711. else FWC_HAVE_LOCK(fwc_rlocks);
  713. f = chain->chain;
  714. do {
  715. count = 0;
  716. for (; f; f = f->next) {
  717. count++;
  718. if (ip_rule_match(f,rif,ip,
  719.   tcpsyn,src_port,dst_port,offset)) {
  720. if (!testing
  721.     && !ip_fw_domatch(f, ip, rif, chain->label,
  722.       skb, slot,
  723.       src_port, dst_port,
  724.       count, tcpsyn)) {
  725. ret = FW_BLOCK;
  726. goto out;
  727. }
  728. break;
  729. }
  730. }
  731. if (f) {
  732. if (f->branch) {
  733. /* Do sanity check to see if we have
  734.                                  * already set prevchain and if so we
  735.                                  * must be in a loop */
  736. if (f->branch->reent[slot].prevchain) {
  737. if (!testing) {
  738. printk(KERN_ERR
  739.        "IP firewall: "
  740.        "Loop detected "
  741.        "at `%s'.n",
  742.        f->branch->label);
  743. cleanup(chain, 1, slot);
  744. ret = FW_BLOCK;
  745. } else {
  746. cleanup(chain, 0, slot);
  747. ret = FW_SKIP+1;
  748. }
  749. }
  750. else {
  751. f->branch->reent[slot].prevchain
  752. = chain;
  753. f->branch->reent[slot].prevrule
  754. = f->next;
  755. chain = f->branch;
  756. f = chain->chain;
  757. }
  758. }
  759. else if (f->simplebranch == FW_SKIP)
  760. f = f->next;
  761. else if (f->simplebranch == FW_SKIP+1) {
  762. /* Just like falling off the chain */
  763. goto fall_off_chain;
  764. } else {
  765. cleanup(chain, 0, slot);
  766. ret = f->simplebranch;
  767. }
  768. } /* f == NULL */
  769. else {
  770. fall_off_chain:
  771. if (chain->reent[slot].prevchain) {
  772. struct ip_chain *tmp = chain;
  773. f = chain->reent[slot].prevrule;
  774. chain = chain->reent[slot].prevchain;
  775. tmp->reent[slot].prevchain = NULL;
  776. }
  777. else {
  778. ret = chain->policy;
  779. if (!testing) {
  780. chain->reent[slot].counters.pcnt++;
  781. chain->reent[slot].counters.bcnt
  782. += ntohs(ip->tot_len);
  783. }
  784. }
  785. }
  786. } while (ret == FW_SKIP+2);
  788.  out:
  789. if (!testing) FWC_READ_UNLOCK(&ip_fw_lock);
  791. /* Recalculate checksum if not going to reject, and TOS changed. */
  792. if (ip->tos != oldtos
  793.     && ret != FW_REJECT && ret != FW_BLOCK
  794.     && !testing)
  795. ip_send_check(ip);
  797. if (ret == FW_REDIRECT && redirport) {
  798. if ((*redirport = htons(f->ipfw.fw_redirpt)) == 0) {
  799. /* Wildcard redirection.
  800.  * Note that redirport will become
  801.  * 0xFFFF for non-TCP/UDP packets.
  802.  */
  803. *redirport = htons(dst_port);
  804. }
  805. }
  807. #ifdef DEBUG_ALLOW_ALL
  808. return (testing ? ret : FW_ACCEPT);
  809. #else
  810. return ret;
  811. #endif
  812. }
  814. /* Must have write lock & interrupts off for any of these */
  816. /* This function sets all the byte counters in a chain to zero.  The
  817.  * input is a pointer to the chain required for zeroing */
  818. static int zero_fw_chain(struct ip_chain *chainptr)
  819. {
  820. struct ip_fwkernel *i;
  822. FWC_HAVE_LOCK(fwc_wlocks);
  823. for (i = chainptr->chain; i; i = i->next)
  824. memset(i->counters, 0, sizeof(struct ip_counters)*NUM_SLOTS);
  825. return 0;
  826. }
  828. static int clear_fw_chain(struct ip_chain *chainptr)
  829. {
  830. struct ip_fwkernel *i= chainptr->chain;
  832. FWC_HAVE_LOCK(fwc_wlocks);
  833. chainptr->chain=NULL;
  835. while (i) {
  836. struct ip_fwkernel *tmp = i->next;
  837. if (i->branch)
  838. i->branch->refcount--;
  839. kfree(i);
  840. i = tmp;
  841. MOD_DEC_USE_COUNT;
  842. }
  843. return 0;
  844. }
  846. static int replace_in_chain(struct ip_chain *chainptr,
  847.     struct ip_fwkernel *frwl,
  848.     __u32 position)
  849. {
  850. struct ip_fwkernel *f = chainptr->chain;
  852. FWC_HAVE_LOCK(fwc_wlocks);
  854. while (--position && f != NULL) f = f->next;
  855. if (f == NULL)
  856. return EINVAL;
  858. if (f->branch) f->branch->refcount--;
  859. if (frwl->branch) frwl->branch->refcount++;
  861. frwl->next = f->next;
  862. memcpy(f,frwl,sizeof(struct ip_fwkernel));
  863. kfree(frwl);
  864. return 0;
  865. }
  867. static int append_to_chain(struct ip_chain *chainptr, struct ip_fwkernel *rule)
  868. {
  869. struct ip_fwkernel *i;
  871. FWC_HAVE_LOCK(fwc_wlocks);
  872. /* Special case if no rules already present */
  873. if (chainptr->chain == NULL) {
  875. /* If pointer writes are atomic then turning off
  876.  * interrupts is not necessary. */
  877. chainptr->chain = rule;
  878. if (rule->branch) rule->branch->refcount++;
  879. goto append_successful;
  880. }
  882. /* Find the rule before the end of the chain */
  883. for (i = chainptr->chain; i->next; i = i->next);
  884. i->next = rule;
  885. if (rule->branch) rule->branch->refcount++;
  887. append_successful:
  888. MOD_INC_USE_COUNT;
  889. return 0;
  890. }
  892. /* This function inserts a rule at the position of position in the
  893.  * chain refenced by chainptr.  If position is 1 then this rule will
  894.  * become the new rule one. */
  895. static int insert_in_chain(struct ip_chain *chainptr,
  896.    struct ip_fwkernel *frwl,
  897.    __u32 position)
  898. {
  899. struct ip_fwkernel *f = chainptr->chain;
  901. FWC_HAVE_LOCK(fwc_wlocks);
  902. /* special case if the position is number 1 */
  903. if (position == 1) {
  904. frwl->next = chainptr->chain;
  905. if (frwl->branch) frwl->branch->refcount++;
  906. chainptr->chain = frwl;
  907. goto insert_successful;
  908. }
  909. position--;
  910. while (--position && f != NULL) f = f->next;
  911. if (f == NULL)
  912. return EINVAL;
  913. if (frwl->branch) frwl->branch->refcount++;
  914. frwl->next = f->next;
  916. f->next = frwl;
  918. insert_successful:
  919. MOD_INC_USE_COUNT;
  920. return 0;
  921. }
  923. /* This function deletes the a rule from a given rulenum and chain.
  924.  * With rulenum = 1 is the first rule is deleted. */
  926. static int del_num_from_chain(struct ip_chain *chainptr, __u32 rulenum)
  927. {
  928. struct ip_fwkernel *i=chainptr->chain,*tmp;
  930. FWC_HAVE_LOCK(fwc_wlocks);
  932. if (!chainptr->chain)
  933. return ENOENT;
  935. /* Need a special case for the first rule */
  936. if (rulenum == 1) {
  937. /* store temp to allow for freeing up of memory */
  938. tmp = chainptr->chain;
  939.         if (chainptr->chain->branch) chainptr->chain->branch->refcount--;
  940. chainptr->chain = chainptr->chain->next;
  941. kfree(tmp); /* free memory that is now unused */
  942. } else {
  943. rulenum--;
  944. while (--rulenum && i->next ) i = i->next;
  945. if (!i->next)
  946. return ENOENT;
  947. tmp = i->next;
  948. if (i->next->branch)
  949. i->next->branch->refcount--;
  950. i->next = i->next->next;
  951. kfree(tmp);
  952. }
  954. MOD_DEC_USE_COUNT;
  955. return 0;
  956. }
  959. /* This function deletes the a rule from a given rule and chain.
  960.  * The rule that is deleted is the first occursance of that rule. */
  961. static int del_rule_from_chain(struct ip_chain *chainptr,
  962.        struct ip_fwkernel *frwl)
  963. {
  964. struct ip_fwkernel *ltmp,*ftmp = chainptr->chain ;
  965. int was_found;
  967. FWC_HAVE_LOCK(fwc_wlocks);
  969. /* Sure, we should compare marks, but since the `ipfwadm'
  970.  * script uses it for an unholy hack... well, life is easier
  971.  * this way.  We also mask it out of the flags word. --PR */
  972. for (ltmp=NULL, was_found=0;
  973.      !was_found && ftmp != NULL;
  974.      ltmp = ftmp,ftmp = ftmp->next) {
  975. if (ftmp->ipfw.fw_src.s_addr!=frwl->ipfw.fw_src.s_addr
  976.     || ftmp->ipfw.fw_dst.s_addr!=frwl->ipfw.fw_dst.s_addr
  977.     || ftmp->ipfw.fw_smsk.s_addr!=frwl->ipfw.fw_smsk.s_addr
  978.     || ftmp->ipfw.fw_dmsk.s_addr!=frwl->ipfw.fw_dmsk.s_addr
  979. #if 0
  980.     || ftmp->ipfw.fw_flg!=frwl->ipfw.fw_flg
  981. #else
  982.     || ((ftmp->ipfw.fw_flg & ~IP_FW_F_MARKABS)
  983. != (frwl->ipfw.fw_flg & ~IP_FW_F_MARKABS))
  984. #endif
  985.     || ftmp->ipfw.fw_invflg!=frwl->ipfw.fw_invflg
  986.     || ftmp->ipfw.fw_proto!=frwl->ipfw.fw_proto
  987. #if 0
  988.     || ftmp->ipfw.fw_mark!=frwl->ipfw.fw_mark
  989. #endif
  990.     || ftmp->ipfw.fw_redirpt!=frwl->ipfw.fw_redirpt
  991.     || ftmp->ipfw.fw_spts[0]!=frwl->ipfw.fw_spts[0]
  992.     || ftmp->ipfw.fw_spts[1]!=frwl->ipfw.fw_spts[1]
  993.     || ftmp->ipfw.fw_dpts[0]!=frwl->ipfw.fw_dpts[0]
  994.     || ftmp->ipfw.fw_dpts[1]!=frwl->ipfw.fw_dpts[1]
  995.     || ftmp->ipfw.fw_outputsize!=frwl->ipfw.fw_outputsize) {
  996. duprintf("del_rule_from_chain: mismatch:"
  997.  "src:%u/%u dst:%u/%u smsk:%u/%u dmsk:%u/%u "
  998.  "flg:%hX/%hX invflg:%hX/%hX proto:%u/%u "
  999.  "mark:%u/%u "
  1000.  "ports:%hu-%hu/%hu-%hu %hu-%hu/%hu-%hu "
  1001.  "outputsize:%hu-%hun",
  1002.  ftmp->ipfw.fw_src.s_addr,
  1003.  frwl->ipfw.fw_src.s_addr,
  1004.  ftmp->ipfw.fw_dst.s_addr,
  1005.  frwl->ipfw.fw_dst.s_addr,
  1006.  ftmp->ipfw.fw_smsk.s_addr,
  1007.  frwl->ipfw.fw_smsk.s_addr,
  1008.  ftmp->ipfw.fw_dmsk.s_addr,
  1009.  frwl->ipfw.fw_dmsk.s_addr,
  1010.  ftmp->ipfw.fw_flg,
  1011.  frwl->ipfw.fw_flg,
  1012.  ftmp->ipfw.fw_invflg,
  1013.  frwl->ipfw.fw_invflg,
  1014.  ftmp->ipfw.fw_proto,
  1015.  frwl->ipfw.fw_proto,
  1016.  ftmp->ipfw.fw_mark,
  1017.  frwl->ipfw.fw_mark,
  1018.  ftmp->ipfw.fw_spts[0],
  1019.  frwl->ipfw.fw_spts[0],
  1020.  ftmp->ipfw.fw_spts[1],
  1021.  frwl->ipfw.fw_spts[1],
  1022.  ftmp->ipfw.fw_dpts[0],
  1023.  frwl->ipfw.fw_dpts[0],
  1024.  ftmp->ipfw.fw_dpts[1],
  1025.  frwl->ipfw.fw_dpts[1],
  1026.  ftmp->ipfw.fw_outputsize,
  1027.  frwl->ipfw.fw_outputsize);
  1028. continue;
  1029. }
  1031. if (strncmp(ftmp->ipfw.fw_vianame,
  1032.     frwl->ipfw.fw_vianame,
  1033.     IFNAMSIZ)) {
  1034. duprintf("del_rule_from_chain: if mismatch: %s/%sn",
  1035.  ftmp->ipfw.fw_vianame,
  1036.  frwl->ipfw.fw_vianame);
  1037.         continue;
  1038. }
  1039. if (ftmp->branch != frwl->branch) {
  1040. duprintf("del_rule_from_chain: branch mismatch: "
  1041.  "%s/%sn",
  1042.  ftmp->branch?ftmp->branch->label:"(null)",
  1043.  frwl->branch?frwl->branch->label:"(null)");
  1044. continue;
  1045. }
  1046. if (ftmp->branch == NULL
  1047.     && ftmp->simplebranch != frwl->simplebranch) {
  1048. duprintf("del_rule_from_chain: simplebranch mismatch: "
  1049.  "%i/%in",
  1050.  ftmp->simplebranch, frwl->simplebranch);
  1051. continue;
  1052. }
  1053. was_found = 1;
  1054. if (ftmp->branch)
  1055. ftmp->branch->refcount--;
  1056. if (ltmp)
  1057. ltmp->next = ftmp->next;
  1058. else
  1059. chainptr->chain = ftmp->next;
  1060. kfree(ftmp);
  1061. MOD_DEC_USE_COUNT;
  1062. break;
  1063. }
  1065. if (was_found)
  1066. return 0;
  1067. else {
  1068. duprintf("del_rule_from_chain: no matching rule foundn");
  1069. return EINVAL;
  1070. }
  1071. }
  1073. /* This function takes the label of a chain and deletes the first
  1074.  * chain with that name.  No special cases required for the built in
  1075.  * chains as they have their refcount initilised to 1 so that they are
  1076.  * never deleted.  */
  1077. static int del_chain(ip_chainlabel label)
  1078. {
  1079. struct ip_chain *tmp,*tmp2;
  1081. FWC_HAVE_LOCK(fwc_wlocks);
  1082. /* Corner case: return EBUSY not ENOENT for first elem ("input") */
  1083. if (strcmp(label, ip_fw_chains->label) == 0)
  1084. return EBUSY;
  1086. for (tmp = ip_fw_chains; tmp->next; tmp = tmp->next)
  1087. if(strcmp(tmp->next->label,label) == 0)
  1088. break;
  1090. tmp2 = tmp->next;
  1091. if (!tmp2)
  1092. return ENOENT;
  1094. if (tmp2->refcount)
  1095. return EBUSY;
  1097. if (tmp2->chain)
  1098. return ENOTEMPTY;
  1100. tmp->next = tmp2->next;
  1101. kfree(tmp2);
  1103. MOD_DEC_USE_COUNT;
  1104. return 0;
  1105. }
  1107. /* This is a function to initilise a chain.  Built in rules start with
  1108.  * refcount = 1 so that they cannot be deleted.  User defined rules
  1109.  * start with refcount = 0 so they can be deleted. */
  1110. static struct ip_chain *ip_init_chain(ip_chainlabel name,
  1111.       __u32 ref,
  1112.       int policy)
  1113. {
  1114. unsigned int i;
  1115. struct ip_chain *label
  1116. = kmalloc(SIZEOF_STRUCT_IP_CHAIN, GFP_KERNEL);
  1117. if (label == NULL)
  1118. panic("Can't kmalloc for firewall chains.n");
  1119. strcpy(label->label,name);
  1120. label->next = NULL;
  1121. label->chain = NULL;
  1122. label->refcount = ref;
  1123. label->policy = policy;
  1124. for (i = 0; i < smp_num_cpus*2; i++) {
  1125. label->reent[i].counters.pcnt = label->reent[i].counters.bcnt
  1126. = 0;
  1127. label->reent[i].prevchain = NULL;
  1128. label->reent[i].prevrule = NULL;
  1129. }
  1131. return label;
  1132. }
  1134. /* This is a function for reating a new chain.  The chains is not
  1135.  * created if a chain of the same name already exists */
  1136. static int create_chain(ip_chainlabel label)
  1137. {
  1138. struct ip_chain *tmp;
  1140. if (!check_label(label))
  1141. return EINVAL;
  1143. FWC_HAVE_LOCK(fwc_wlocks);
  1144. for (tmp = ip_fw_chains; tmp->next; tmp = tmp->next)
  1145. if (strcmp(tmp->label,label) == 0)
  1146. return EEXIST;
  1148. if (strcmp(tmp->label,label) == 0)
  1149. return EEXIST;
  1151. tmp->next = ip_init_chain(label, 0, FW_SKIP); /* refcount is
  1152.       * zero since this is a
  1153.       * user defined chain *
  1154.       * and therefore can be
  1155.       * deleted */
  1156. MOD_INC_USE_COUNT;
  1157. return 0;
  1158. }
  1160. /* This function simply changes the policy on one of the built in
  1161.  * chains.  checking must be done before this is call to ensure that
  1162.  * chainptr is pointing to one of the three possible chains */
  1163. static int change_policy(struct ip_chain *chainptr, int policy)
  1164. {
  1165. FWC_HAVE_LOCK(fwc_wlocks);
  1166. chainptr->policy = policy;
  1167. return 0;
  1168. }
  1170. /* This function takes an ip_fwuser and converts it to a ip_fwkernel.  It also
  1171.  * performs some checks in the structure. */
  1172. static struct ip_fwkernel *convert_ipfw(struct ip_fwuser *fwuser, int *errno)
  1173. {
  1174. struct ip_fwkernel *fwkern;
  1176. if ( (fwuser->ipfw.fw_flg & ~IP_FW_F_MASK) != 0 ) {
  1177. duprintf("convert_ipfw: undefined flag bits set (flags=%x)n",
  1178.  fwuser->ipfw.fw_flg);
  1179. *errno = EINVAL;
  1180. return NULL;
  1181. }
  1183. #ifdef DEBUG_IP_FIREWALL_USER
  1184. /* These are sanity checks that don't really matter.
  1185.  * We can get rid of these once testing is complete.
  1186.  */
  1187. if ((fwuser->ipfw.fw_flg & IP_FW_F_TCPSYN)
  1188.     && ((fwuser->ipfw.fw_invflg & IP_FW_INV_PROTO)
  1189. || fwuser->ipfw.fw_proto != IPPROTO_TCP)) {
  1190. duprintf("convert_ipfw: TCP SYN flag set but proto != TCP!n");
  1191. *errno = EINVAL;
  1192. return NULL;
  1193. }
  1195. if (strcmp(fwuser->label, IP_FW_LABEL_REDIRECT) != 0
  1196.     && fwuser->ipfw.fw_redirpt != 0) {
  1197. duprintf("convert_ipfw: Target not REDIR but redirpt != 0!n");
  1198. *errno = EINVAL;
  1199. return NULL;
  1200. }
  1202. if ((!(fwuser->ipfw.fw_flg & IP_FW_F_FRAG)
  1203.      && (fwuser->ipfw.fw_invflg & IP_FW_INV_FRAG))
  1204.     || (!(fwuser->ipfw.fw_flg & IP_FW_F_TCPSYN)
  1205. && (fwuser->ipfw.fw_invflg & IP_FW_INV_SYN))) {
  1206. duprintf("convert_ipfw: Can't have INV flag if flag unset!n");
  1207. *errno = EINVAL;
  1208. return NULL;
  1209. }
  1211. if (((fwuser->ipfw.fw_invflg & IP_FW_INV_SRCPT)
  1212.      && fwuser->ipfw.fw_spts[0] == 0
  1213.      && fwuser->ipfw.fw_spts[1] == 0xFFFF)
  1214.     || ((fwuser->ipfw.fw_invflg & IP_FW_INV_DSTPT)
  1215. && fwuser->ipfw.fw_dpts[0] == 0
  1216. && fwuser->ipfw.fw_dpts[1] == 0xFFFF)
  1217.     || ((fwuser->ipfw.fw_invflg & IP_FW_INV_VIA)
  1218. && (fwuser->ipfw.fw_vianame)[0] == '')
  1219.     || ((fwuser->ipfw.fw_invflg & IP_FW_INV_SRCIP)
  1220. && fwuser->ipfw.fw_smsk.s_addr == 0)
  1221.     || ((fwuser->ipfw.fw_invflg & IP_FW_INV_DSTIP)
  1222. && fwuser->ipfw.fw_dmsk.s_addr == 0)) {
  1223. duprintf("convert_ipfw: INV flag makes rule unmatchable!n");
  1224. *errno = EINVAL;
  1225. return NULL;
  1226. }
  1228. if ((fwuser->ipfw.fw_flg & IP_FW_F_FRAG)
  1229.     && !(fwuser->ipfw.fw_invflg & IP_FW_INV_FRAG)
  1230.     && (fwuser->ipfw.fw_spts[0] != 0
  1231. || fwuser->ipfw.fw_spts[1] != 0xFFFF
  1232. || fwuser->ipfw.fw_dpts[0] != 0
  1233. || fwuser->ipfw.fw_dpts[1] != 0xFFFF
  1234. || (fwuser->ipfw.fw_flg & IP_FW_F_TCPSYN))) {
  1235. duprintf("convert_ipfw: Can't test ports or SYN with frag!n");
  1236. *errno = EINVAL;
  1237. return NULL;
  1238. }
  1239. #endif
  1241. if ((fwuser->ipfw.fw_spts[0] != 0
  1242.      || fwuser->ipfw.fw_spts[1] != 0xFFFF
  1243.      || fwuser->ipfw.fw_dpts[0] != 0
  1244.      || fwuser->ipfw.fw_dpts[1] != 0xFFFF)
  1245.     && ((fwuser->ipfw.fw_invflg & IP_FW_INV_PROTO)
  1246. || (fwuser->ipfw.fw_proto != IPPROTO_TCP
  1247.     && fwuser->ipfw.fw_proto != IPPROTO_UDP
  1248.     && fwuser->ipfw.fw_proto != IPPROTO_ICMP))) {
  1249. duprintf("convert_ipfw: Can only test ports for TCP/UDP/ICMP!n");
  1250. *errno = EINVAL;
  1251. return NULL;
  1252. }
  1254. fwkern = kmalloc(SIZEOF_STRUCT_IP_FW_KERNEL, GFP_KERNEL);
  1255. if (!fwkern) {
  1256. duprintf("convert_ipfw: kmalloc failed!n");
  1257. *errno = ENOMEM;
  1258. return NULL;
  1259. }
  1260. memcpy(&fwkern->ipfw,&fwuser->ipfw,sizeof(struct ip_fw));
  1262. if (!find_special(fwuser->label, &fwkern->simplebranch)) {
  1263. fwkern->branch = find_label(fwuser->label);
  1264. if (!fwkern->branch) {
  1265. duprintf("convert_ipfw: chain doesn't exist `%s'.n",
  1266.  fwuser->label);
  1267. kfree(fwkern);
  1268. *errno = ENOENT;
  1269. return NULL;
  1270. } else if (fwkern->branch == IP_FW_INPUT_CHAIN
  1271.    || fwkern->branch == IP_FW_FORWARD_CHAIN
  1272.    || fwkern->branch == IP_FW_OUTPUT_CHAIN) {
  1273. duprintf("convert_ipfw: Can't branch to builtin chain `%s'.n",
  1274.  fwuser->label);
  1275. kfree(fwkern);
  1276. *errno = ENOENT;
  1277. return NULL;
  1278. }
  1279. } else
  1280. fwkern->branch = NULL;
  1281. memset(fwkern->counters, 0, sizeof(struct ip_counters)*NUM_SLOTS);
  1283. /* Handle empty vianame by making it a wildcard */
  1284. if ((fwkern->ipfw.fw_vianame)[0] == '')
  1285.     fwkern->ipfw.fw_flg |= IP_FW_F_WILDIF;
  1287. fwkern->next = NULL;
  1288. return fwkern;
  1289. }
  1291. int ip_fw_ctl(int cmd, void *m, int len)
  1292. {
  1293. int ret;
  1294. struct ip_chain *chain;
  1295. unsigned long flags;
  1297. FWC_WRITE_LOCK_IRQ(&ip_fw_lock, flags);
  1299. switch (cmd) {
  1300. case IP_FW_FLUSH:
  1301. if (len != sizeof(ip_chainlabel) || !check_label(m))
  1302. ret = EINVAL;
  1303. else if ((chain = find_label(m)) == NULL)
  1304. ret = ENOENT;
  1305. else ret = clear_fw_chain(chain);
  1306. break;
  1308. case IP_FW_ZERO:
  1309. if (len != sizeof(ip_chainlabel) || !check_label(m))
  1310. ret = EINVAL;
  1311. else if ((chain = find_label(m)) == NULL)
  1312. ret = ENOENT;
  1313. else ret = zero_fw_chain(chain);
  1314. break;
  1316. case IP_FW_CHECK: {
  1317. struct ip_fwtest *new = m;
  1318. struct iphdr *ip;
  1320. /* Don't need write lock. */
  1321. FWC_WRITE_UNLOCK_IRQ(&ip_fw_lock, flags);
  1323. if (len != sizeof(struct ip_fwtest) || !check_label(m))
  1324. return EINVAL;
  1326. /* Need readlock to do find_label */
  1327. FWC_READ_LOCK(&ip_fw_lock);
  1329. if ((chain = find_label(new->fwt_label)) == NULL)
  1330. ret = ENOENT;
  1331. else {
  1332. ip = &(new->fwt_packet.fwp_iph);
  1334. if (ip->ihl != sizeof(struct iphdr) / sizeof(int)) {
  1335.     duprintf("ip_fw_ctl: ip->ihl=%d, want %dn",
  1336.      ip->ihl,
  1337.      sizeof(struct iphdr) / sizeof(int));
  1338.     ret = EINVAL;
  1339. }
  1340. else {
  1341. ret = ip_fw_check(ip, new->fwt_packet.fwp_vianame,
  1342.   NULL, chain,
  1343.   NULL, SLOT_NUMBER(), 1);
  1344. switch (ret) {
  1345. case FW_ACCEPT:
  1346. ret = 0; break;
  1347. case FW_REDIRECT:
  1348. ret = ECONNABORTED; break;
  1349. case FW_MASQUERADE:
  1350. ret = ECONNRESET; break;
  1351. case FW_REJECT:
  1352. ret = ECONNREFUSED; break;
  1353. /* Hack to help diag; these only get
  1354.    returned when testing. */
  1355. case FW_SKIP+1:
  1356. ret = ELOOP; break;
  1357. case FW_SKIP:
  1358. ret = ENFILE; break;
  1359. default: /* FW_BLOCK */
  1360. ret = ETIMEDOUT; break;
  1361. }
  1362. }
  1363. }
  1364. FWC_READ_UNLOCK(&ip_fw_lock);
  1365. return ret;
  1366. }
  1368. case IP_FW_MASQ_TIMEOUTS: {
  1369. ret = ip_fw_masq_timeouts(m, len);
  1370. }
  1371. break;
  1373. case IP_FW_REPLACE: {
  1374. struct ip_fwkernel *ip_fwkern;
  1375. struct ip_fwnew *new = m;
  1377. if (len != sizeof(struct ip_fwnew)
  1378.     || !check_label(new->fwn_label))
  1379. ret = EINVAL;
  1380. else if ((chain = find_label(new->fwn_label)) == NULL)
  1381. ret = ENOENT;
  1382. else if ((ip_fwkern = convert_ipfw(&new->fwn_rule, &ret))
  1383.  != NULL)
  1384. ret = replace_in_chain(chain, ip_fwkern,
  1385.        new->fwn_rulenum);
  1386. }
  1387. break;
  1389. case IP_FW_APPEND: {
  1390. struct ip_fwchange *new = m;
  1391. struct ip_fwkernel *ip_fwkern;
  1393. if (len != sizeof(struct ip_fwchange)
  1394.     || !check_label(new->fwc_label))
  1395. ret = EINVAL;
  1396. else if ((chain = find_label(new->fwc_label)) == NULL)
  1397. ret = ENOENT;
  1398. else if ((ip_fwkern = convert_ipfw(&new->fwc_rule, &ret))
  1399.  != NULL)
  1400. ret = append_to_chain(chain, ip_fwkern);
  1401. }
  1402. break;
  1404. case IP_FW_INSERT: {
  1405. struct ip_fwkernel *ip_fwkern;
  1406. struct ip_fwnew *new = m;
  1408. if (len != sizeof(struct ip_fwnew)
  1409.     || !check_label(new->fwn_label))
  1410. ret = EINVAL;
  1411. else if ((chain = find_label(new->fwn_label)) == NULL)
  1412. ret = ENOENT;
  1413. else if ((ip_fwkern = convert_ipfw(&new->fwn_rule, &ret))
  1414.  != NULL)
  1415. ret = insert_in_chain(chain, ip_fwkern,
  1416.       new->fwn_rulenum);
  1417. }
  1418. break;
  1420. case IP_FW_DELETE: {
  1421. struct ip_fwchange *new = m;
  1422. struct ip_fwkernel *ip_fwkern;
  1424. if (len != sizeof(struct ip_fwchange)
  1425.     || !check_label(new->fwc_label))
  1426. ret = EINVAL;
  1427. else if ((chain = find_label(new->fwc_label)) == NULL)
  1428. ret = ENOENT;
  1429. else if ((ip_fwkern = convert_ipfw(&new->fwc_rule, &ret))
  1430.  != NULL) {
  1431. ret = del_rule_from_chain(chain, ip_fwkern);
  1432. kfree(ip_fwkern);
  1433. }
  1434. }
  1435. break;
  1437. case IP_FW_DELETE_NUM: {
  1438. struct ip_fwdelnum *new = m;
  1440. if (len != sizeof(struct ip_fwdelnum)
  1441.     || !check_label(new->fwd_label))
  1442. ret = EINVAL;
  1443. else if ((chain = find_label(new->fwd_label)) == NULL)
  1444. ret = ENOENT;
  1445. else ret = del_num_from_chain(chain, new->fwd_rulenum);
  1446. }
  1447. break;
  1449. case IP_FW_CREATECHAIN: {
  1450. if (len != sizeof(ip_chainlabel)) {
  1451. duprintf("create_chain: bad size %in", len);
  1452. ret = EINVAL;
  1453. }
  1454. else ret = create_chain(m);
  1455. }
  1456. break;
  1458. case IP_FW_DELETECHAIN: {
  1459. if (len != sizeof(ip_chainlabel)) {
  1460. duprintf("delete_chain: bad size %in", len);
  1461. ret = EINVAL;
  1462. }
  1463. else ret = del_chain(m);
  1464. }
  1465. break;
  1467. case IP_FW_POLICY: {
  1468. struct ip_fwpolicy *new = m;
  1470. if (len != sizeof(struct ip_fwpolicy)
  1471.     || !check_label(new->fwp_label))
  1472. ret = EINVAL;
  1473. else if ((chain = find_label(new->fwp_label)) == NULL)
  1474. ret = ENOENT;
  1475. else if (chain != IP_FW_INPUT_CHAIN
  1476.  && chain != IP_FW_FORWARD_CHAIN
  1477.  && chain != IP_FW_OUTPUT_CHAIN) {
  1478. duprintf("change_policy: can't change policy on user"
  1479.  " defined chain.n");
  1480. ret = EINVAL;
  1481. }
  1482. else {
  1483.         int pol = FW_SKIP;
  1484. find_special(new->fwp_policy, &pol);
  1486. switch(pol) {
  1487. case FW_MASQUERADE:
  1488. if (chain != IP_FW_FORWARD_CHAIN) {
  1489. ret = EINVAL;
  1490. break;
  1491. }
  1492. /* Fall thru... */
  1493. case FW_BLOCK:
  1494. case FW_ACCEPT:
  1495. case FW_REJECT:
  1496. ret = change_policy(chain, pol);
  1497. break;
  1498. default:
  1499.         duprintf("change_policy: bad policy `%s'n",
  1500.  new->fwp_policy);
  1501. ret = EINVAL;
  1502. }
  1503. }
  1504. break;
  1505. }
  1506. default:
  1507. duprintf("ip_fw_ctl:  unknown request %dn",cmd);
  1508. ret = ENOPROTOOPT;
  1509. }
  1511. FWC_WRITE_UNLOCK_IRQ(&ip_fw_lock, flags);
  1512. return ret;
  1513. }
  1515. /* Returns bytes used - doesn't NUL terminate */
  1516. static int dump_rule(char *buffer,
  1517.      const char *chainlabel,
  1518.      const struct ip_fwkernel *rule)
  1519. {
  1520. int len;
  1521. unsigned int i;
  1522. __u64 packets = 0, bytes = 0;
  1524. FWC_HAVE_LOCK(fwc_wlocks);
  1525. for (i = 0; i < NUM_SLOTS; i++) {
  1526. packets += rule->counters[i].pcnt;
  1527. bytes += rule->counters[i].bcnt;
  1528. }
  1530. len=sprintf(buffer,
  1531.     "%9s " /* Chain name */
  1532.     "%08X/%08X->%08X/%08X " /* Source & Destination IPs */
  1533.     "%.16s " /* Interface */
  1534.     "%X %X " /* fw_flg and fw_invflg fields */
  1535.     "%u " /* Protocol */
  1536.     "%-9u %-9u %-9u %-9u " /* Packet & byte counters */
  1537.     "%u-%u %u-%u " /* Source & Dest port ranges */
  1538.     "A%02X X%02X " /* TOS and and xor masks */
  1539.     "%08X " /* Redirection port */
  1540.     "%u " /* fw_mark field */
  1541.     "%u " /* output size */
  1542.     "%9sn", /* Target */
  1543.     chainlabel,
  1544.     ntohl(rule->ipfw.fw_src.s_addr),
  1545.     ntohl(rule->ipfw.fw_smsk.s_addr),
  1546.     ntohl(rule->ipfw.fw_dst.s_addr),
  1547.     ntohl(rule->ipfw.fw_dmsk.s_addr),
  1548.     (rule->ipfw.fw_vianame)[0] ? rule->ipfw.fw_vianame : "-",
  1549.     rule->ipfw.fw_flg,
  1550.     rule->ipfw.fw_invflg,
  1551.     rule->ipfw.fw_proto,
  1552.     (__u32)(packets >> 32), (__u32)packets,
  1553.     (__u32)(bytes >> 32), (__u32)bytes,
  1554.     rule->ipfw.fw_spts[0], rule->ipfw.fw_spts[1],
  1555.     rule->ipfw.fw_dpts[0], rule->ipfw.fw_dpts[1],
  1556.     rule->ipfw.fw_tosand, rule->ipfw.fw_tosxor,
  1557.     rule->ipfw.fw_redirpt,
  1558.     rule->ipfw.fw_mark,
  1559.     rule->ipfw.fw_outputsize,
  1560.     branchname(rule->branch,rule->simplebranch));
  1562. duprintf("dump_rule: %i bytes done.n", len);
  1563. return len;
  1564. }
  1566. /* File offset is actually in records, not bytes. */
  1567. static int ip_chain_procinfo(char *buffer, char **start,
  1568.      off_t offset, int length
  1569. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,29)
  1570.      , int reset
  1571. #endif
  1572. )
  1573. {
  1574. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,29)
  1575. /* FIXME: No more `atomic' read and reset.  Wonderful 8-( --RR */
  1576. int reset = 0;
  1577. #endif
  1578. struct ip_chain *i;
  1579. struct ip_fwkernel *j = ip_fw_chains->chain;
  1580. unsigned long flags;
  1581. int len = 0;
  1582. int last_len = 0;
  1583. off_t upto = 0;
  1585. duprintf("Offset starts at %lun", offset);
  1586. duprintf("ip_fw_chains is 0x%0lXn", (unsigned long int)ip_fw_chains);
  1588. /* Need a write lock to lock out ``readers'' which update counters. */
  1589. FWC_WRITE_LOCK_IRQ(&ip_fw_lock, flags);
  1591. for (i = ip_fw_chains; i; i = i->next) {
  1592.     for (j = i->chain; j; j = j->next) {
  1593. if (upto == offset) break;
  1594. duprintf("Skipping rule in chain `%s'n",
  1595.  i->label);
  1596. upto++;
  1597.     }
  1598.     if (upto == offset) break;
  1599. }
  1601. /* Don't init j first time, or once i = NULL */
  1602. for (; i; (void)((i = i->next) && (j = i->chain))) {
  1603. duprintf("Dumping chain `%s'n", i->label);
  1604. for (; j; j = j->next, upto++, last_len = len)
  1605. {
  1606. len += dump_rule(buffer+len, i->label, j);
  1607. if (len > length) {
  1608. duprintf("Dumped to %i (past %i).  "
  1609.  "Moving back to %i.n",
  1610.  len, length, last_len);
  1611. len = last_len;
  1612. goto outside;
  1613. }
  1614. else if (reset)
  1615. memset(j->counters, 0,
  1616.        sizeof(struct ip_counters)*NUM_SLOTS);
  1617. }
  1618. }
  1619. outside:
  1620. FWC_WRITE_UNLOCK_IRQ(&ip_fw_lock, flags);
  1621. buffer[len] = '';
  1623. duprintf("ip_chain_procinfo: Length = %i (of %i).  Offset = %li.n",
  1624.  len, length, upto);
  1625. /* `start' hack - see fs/proc/generic.c line ~165 */
  1626. *start=(char *)((unsigned int)upto-offset);
  1627. return len;
  1628. }
  1630. static int ip_chain_name_procinfo(char *buffer, char **start,
  1631.   off_t offset, int length)
  1632. {
  1633. struct ip_chain *i;
  1634. int len = 0,last_len = 0;
  1635. off_t pos = 0,begin = 0;
  1636. unsigned long flags;
  1638. /* Need a write lock to lock out ``readers'' which update counters. */
  1639. FWC_WRITE_LOCK_IRQ(&ip_fw_lock, flags);
  1641. for (i = ip_fw_chains; i; i = i->next)
  1642. {
  1643. unsigned int j;
  1644. __u32 packetsHi = 0, packetsLo = 0, bytesHi = 0, bytesLo = 0;
  1646. for (j = 0; j < NUM_SLOTS; j++) {
  1647. packetsLo += i->reent[j].counters.pcnt & 0xFFFFFFFF;
  1648. packetsHi += ((i->reent[j].counters.pcnt >> 32)
  1649.       & 0xFFFFFFFF);
  1650. bytesLo += i->reent[j].counters.bcnt & 0xFFFFFFFF;
  1651. bytesHi += ((i->reent[j].counters.bcnt >> 32)
  1652.     & 0xFFFFFFFF);
  1653. }
  1655. /* print the label and the policy */
  1656. len+=sprintf(buffer+len,"%s %s %i %u %u %u %un",
  1657.      i->label,branchname(NULL, i->policy),i->refcount,
  1658.      packetsHi, packetsLo, bytesHi, bytesLo);
  1659. pos=begin+len;
  1660. if(pos<offset) {
  1661. len=0;
  1662. begin=pos;
  1663. }
  1664. else if(pos>offset+length) {
  1665. len = last_len;
  1666. break;
  1667. }
  1669. last_len = len;
  1670. }
  1671. FWC_WRITE_UNLOCK_IRQ(&ip_fw_lock, flags);
  1673. *start = buffer+(offset-begin);
  1674. len-=(offset-begin);
  1675. if(len>length)
  1676. len=length;
  1677. return len;
  1678. }
  1680. /*
  1681.  * Interface to the generic firewall chains.
  1682.  */
  1683. int ipfw_input_check(struct firewall_ops *this, int pf,
  1684.      struct net_device *dev, void *phdr, void *arg,
  1685.      struct sk_buff **pskb)
  1686. {
  1687. return ip_fw_check(phdr, dev->name,
  1688.    arg, IP_FW_INPUT_CHAIN, *pskb, SLOT_NUMBER(), 0);
  1689. }
  1691. int ipfw_output_check(struct firewall_ops *this, int pf,
  1692.       struct net_device *dev, void *phdr, void *arg,
  1693.       struct sk_buff **pskb)
  1694. {
  1695. /* Locally generated bogus packets by root. <SIGH>. */
  1696. if (((struct iphdr *)phdr)->ihl * 4 < sizeof(struct iphdr)
  1697.     || (*pskb)->len < sizeof(struct iphdr))
  1698. return FW_ACCEPT;
  1699. return ip_fw_check(phdr, dev->name,
  1700.    arg, IP_FW_OUTPUT_CHAIN, *pskb, SLOT_NUMBER(), 0);
  1701. }
  1703. int ipfw_forward_check(struct firewall_ops *this, int pf,
  1704.        struct net_device *dev, void *phdr, void *arg,
  1705.        struct sk_buff **pskb)
  1706. {
  1707. return ip_fw_check(phdr, dev->name,
  1708.    arg, IP_FW_FORWARD_CHAIN, *pskb, SLOT_NUMBER(), 0);
  1709. }
  1711. struct firewall_ops ipfw_ops=
  1712. {
  1713. NULL,
  1714. ipfw_forward_check,
  1715. ipfw_input_check,
  1716. ipfw_output_check,
  1717. NULL,
  1718. NULL
  1719. };
  1721. int ipfw_init_or_cleanup(int init)
  1722. {
  1723. struct proc_dir_entry *proc;
  1724. int ret = 0;
  1725. unsigned long flags;
  1727. if (!init) goto cleanup;
  1729. #ifdef DEBUG_IP_FIREWALL_LOCKING
  1730. fwc_wlocks = fwc_rlocks = 0;
  1731. #endif
  1733. #if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE)
  1734. ipfwsk = netlink_kernel_create(NETLINK_FIREWALL, NULL);
  1735. if (ipfwsk == NULL)
  1736. goto cleanup_nothing;
  1737. #endif
  1739. ret = register_firewall(PF_INET, &ipfw_ops);
  1740. if (ret < 0)
  1741. goto cleanup_netlink;
  1743. proc = proc_net_create(IP_FW_PROC_CHAINS, S_IFREG | S_IRUSR | S_IWUSR,
  1744.        ip_chain_procinfo);
  1745. if (proc) proc->owner = THIS_MODULE;
  1746. proc = proc_net_create(IP_FW_PROC_CHAIN_NAMES,
  1747.        S_IFREG | S_IRUSR | S_IWUSR,
  1748.        ip_chain_name_procinfo);
  1749. if (proc) proc->owner = THIS_MODULE;
  1751. IP_FW_INPUT_CHAIN = ip_init_chain(IP_FW_LABEL_INPUT, 1, FW_ACCEPT);
  1752. IP_FW_FORWARD_CHAIN = ip_init_chain(IP_FW_LABEL_FORWARD, 1, FW_ACCEPT);
  1753. IP_FW_OUTPUT_CHAIN = ip_init_chain(IP_FW_LABEL_OUTPUT, 1, FW_ACCEPT);
  1755. return ret;
  1757.  cleanup:
  1758. unregister_firewall(PF_INET, &ipfw_ops);
  1760. FWC_WRITE_LOCK_IRQ(&ip_fw_lock, flags);
  1761. while (ip_fw_chains) {
  1762. struct ip_chain *next = ip_fw_chains->next;
  1764. clear_fw_chain(ip_fw_chains);
  1765. kfree(ip_fw_chains);
  1766. ip_fw_chains = next;
  1767. }
  1768. FWC_WRITE_UNLOCK_IRQ(&ip_fw_lock, flags);
  1770. proc_net_remove(IP_FW_PROC_CHAINS);
  1771. proc_net_remove(IP_FW_PROC_CHAIN_NAMES);
  1773.  cleanup_netlink:
  1774. #if defined(CONFIG_NETLINK_DEV) || defined(CONFIG_NETLINK_DEV_MODULE)
  1775. sock_release(ipfwsk->socket);
  1777.  cleanup_nothing:
  1778. #endif
  1779. return ret;
  1780. }
  1781. MODULE_LICENSE("BSD without advertisement clause");