Changeset 2699


Ignore:
Timestamp:
2005-12-16T14:38:40+01:00 (11 years ago)
Author:
wbx
Message:

fix one of the iptables 1.3.4 compile errors on 2.4, backport of ipt_string from 2.6, need runtime testing

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/openwrt/target/linux/linux-2.4/patches/generic/609-netfilter_string.patch

    r2478 r2699  
    1 --- linux/net/ipv4/netfilter/Config.in.org      2005-11-08 23:11:47.011929664 +0100 
    2 +++ linux/net/ipv4/netfilter/Config.in  2005-11-08 23:10:33.329131152 +0100 
    3 @@ -50,6 +50,7 @@ 
     1diff -Nur linux-2.4.32/include/linux/netfilter_ipv4/ipt_string.h linux-2.4.32.patch/include/linux/netfilter_ipv4/ipt_string.h 
     2--- linux-2.4.32/include/linux/netfilter_ipv4/ipt_string.h      1970-01-01 01:00:00.000000000 +0100 
     3+++ linux-2.4.32.patch/include/linux/netfilter_ipv4/ipt_string.h        2005-12-16 00:40:19.082509250 +0100 
     4@@ -0,0 +1,18 @@ 
     5+#ifndef _IPT_STRING_H 
     6+#define _IPT_STRING_H 
     7+ 
     8+#define IPT_STRING_MAX_PATTERN_SIZE 128 
     9+#define IPT_STRING_MAX_ALGO_NAME_SIZE 16 
     10+ 
     11+struct ipt_string_info 
     12+{ 
     13+       u_int16_t from_offset; 
     14+       u_int16_t to_offset; 
     15+       char      algo[IPT_STRING_MAX_ALGO_NAME_SIZE]; 
     16+       char      pattern[IPT_STRING_MAX_PATTERN_SIZE]; 
     17+       u_int8_t  patlen; 
     18+       u_int8_t  invert; 
     19+       struct ts_config __attribute__((aligned(8))) *config; 
     20+}; 
     21+ 
     22+#endif /*_IPT_STRING_H*/ 
     23diff -Nur linux-2.4.32/include/linux/textsearch.h linux-2.4.32.patch/include/linux/textsearch.h 
     24--- linux-2.4.32/include/linux/textsearch.h     1970-01-01 01:00:00.000000000 +0100 
     25+++ linux-2.4.32.patch/include/linux/textsearch.h       2005-12-16 11:15:34.838073000 +0100 
     26@@ -0,0 +1,205 @@ 
     27+#ifndef __LINUX_TEXTSEARCH_H 
     28+#define __LINUX_TEXTSEARCH_H 
     29+ 
     30+#ifdef __KERNEL__ 
     31+ 
     32+#include <linux/types.h> 
     33+#include <linux/list.h> 
     34+#include <linux/kernel.h> 
     35+#include <linux/module.h> 
     36+#include <linux/slab.h> 
     37+ 
     38+#ifdef __CHECKER__ 
     39+#define __bitwise__ __attribute__((bitwise)) 
     40+#else 
     41+#define __bitwise__ 
     42+#endif 
     43+#ifdef __CHECK_ENDIAN__ 
     44+#define __bitwise __bitwise__ 
     45+#else 
     46+#define __bitwise 
     47+#endif 
     48+ 
     49+typedef __u16 __bitwise __le16; 
     50+typedef __u16 __bitwise __be16; 
     51+typedef __u32 __bitwise __le32; 
     52+typedef __u32 __bitwise __be32; 
     53+#if defined(__GNUC__) && !defined(__STRICT_ANSI__) 
     54+typedef __u64 __bitwise __le64; 
     55+typedef __u64 __bitwise __be64; 
     56+#endif 
     57+ 
     58+#ifdef __KERNEL__ 
     59+typedef unsigned __bitwise__ gfp_t; 
     60+#endif 
     61+ 
     62+struct ts_config; 
     63+ 
     64+/** 
     65+ * TS_AUTOLOAD - Automatically load textsearch modules when needed 
     66+ */ 
     67+#define TS_AUTOLOAD    1 
     68+ 
     69+/** 
     70+ * struct ts_state - search state 
     71+ * @offset: offset for next match 
     72+ * @cb: control buffer, for persistant variables of get_next_block() 
     73+ */ 
     74+struct ts_state 
     75+{ 
     76+       unsigned int            offset; 
     77+       char                    cb[40]; 
     78+}; 
     79+ 
     80+/** 
     81+ * struct ts_ops - search module operations 
     82+ * @name: name of search algorithm 
     83+ * @init: initialization function to prepare a search 
     84+ * @find: find the next occurrence of the pattern 
     85+ * @destroy: destroy algorithm specific parts of a search configuration 
     86+ * @get_pattern: return head of pattern 
     87+ * @get_pattern_len: return length of pattern 
     88+ * @owner: module reference to algorithm 
     89+ */ 
     90+struct ts_ops 
     91+{ 
     92+       const char              *name; 
     93+       struct ts_config *      (*init)(const void *, unsigned int, gfp_t); 
     94+       unsigned int            (*find)(struct ts_config *, 
     95+                                       struct ts_state *); 
     96+       void                    (*destroy)(struct ts_config *); 
     97+       void *                  (*get_pattern)(struct ts_config *); 
     98+       unsigned int            (*get_pattern_len)(struct ts_config *); 
     99+       struct module           *owner; 
     100+       struct list_head        list; 
     101+}; 
     102+ 
     103+/** 
     104+ * struct ts_config - search configuration 
     105+ * @ops: operations of chosen algorithm 
     106+ * @get_next_block: callback to fetch the next block to search in 
     107+ * @finish: callback to finalize a search 
     108+ */ 
     109+struct ts_config 
     110+{ 
     111+       struct ts_ops           *ops; 
     112+ 
     113+       /** 
     114+        * get_next_block - fetch next block of data 
     115+        * @consumed: number of bytes consumed by the caller 
     116+        * @dst: destination buffer 
     117+        * @conf: search configuration 
     118+        * @state: search state 
     119+        * 
     120+        * Called repeatedly until 0 is returned. Must assign the 
     121+        * head of the next block of data to &*dst and return the length 
     122+        * of the block or 0 if at the end. consumed == 0 indicates 
     123+        * a new search. May store/read persistant values in state->cb. 
     124+        */ 
     125+       unsigned int            (*get_next_block)(unsigned int consumed, 
     126+                                                 const u8 **dst, 
     127+                                                 struct ts_config *conf, 
     128+                                                 struct ts_state *state); 
     129+ 
     130+       /** 
     131+        * finish - finalize/clean a series of get_next_block() calls 
     132+        * @conf: search configuration 
     133+        * @state: search state 
     134+        * 
     135+        * Called after the last use of get_next_block(), may be used 
     136+        * to cleanup any leftovers. 
     137+        */ 
     138+       void                    (*finish)(struct ts_config *conf, 
     139+                                         struct ts_state *state); 
     140+}; 
     141+ 
     142+/** 
     143+ * textsearch_next - continue searching for a pattern 
     144+ * @conf: search configuration 
     145+ * @state: search state 
     146+ * 
     147+ * Continues a search looking for more occurrences of the pattern. 
     148+ * textsearch_find() must be called to find the first occurrence 
     149+ * in order to reset the state. 
     150+ * 
     151+ * Returns the position of the next occurrence of the pattern or 
     152+ * UINT_MAX if not match was found. 
     153+ */  
     154+static inline unsigned int textsearch_next(struct ts_config *conf, 
     155+                                          struct ts_state *state) 
     156+{ 
     157+       unsigned int ret = conf->ops->find(conf, state); 
     158+ 
     159+       if (conf->finish) 
     160+               conf->finish(conf, state); 
     161+ 
     162+       return ret; 
     163+} 
     164+ 
     165+/** 
     166+ * textsearch_find - start searching for a pattern 
     167+ * @conf: search configuration 
     168+ * @state: search state 
     169+ * 
     170+ * Returns the position of first occurrence of the pattern or 
     171+ * UINT_MAX if no match was found. 
     172+ */  
     173+static inline unsigned int textsearch_find(struct ts_config *conf, 
     174+                                          struct ts_state *state) 
     175+{ 
     176+       state->offset = 0; 
     177+       return textsearch_next(conf, state); 
     178+} 
     179+ 
     180+/** 
     181+ * textsearch_get_pattern - return head of the pattern 
     182+ * @conf: search configuration 
     183+ */ 
     184+static inline void *textsearch_get_pattern(struct ts_config *conf) 
     185+{ 
     186+       return conf->ops->get_pattern(conf); 
     187+} 
     188+ 
     189+/** 
     190+ * textsearch_get_pattern_len - return length of the pattern 
     191+ * @conf: search configuration 
     192+ */ 
     193+static inline unsigned int textsearch_get_pattern_len(struct ts_config *conf) 
     194+{ 
     195+       return conf->ops->get_pattern_len(conf); 
     196+} 
     197+ 
     198+extern int textsearch_register(struct ts_ops *); 
     199+extern int textsearch_unregister(struct ts_ops *); 
     200+extern struct ts_config *textsearch_prepare(const char *, const void *, 
     201+                                           unsigned int, gfp_t, int); 
     202+extern void textsearch_destroy(struct ts_config *conf); 
     203+extern unsigned int textsearch_find_continuous(struct ts_config *, 
     204+                                              struct ts_state *, 
     205+                                              const void *, unsigned int); 
     206+ 
     207+ 
     208+#define TS_PRIV_ALIGNTO        8 
     209+#define TS_PRIV_ALIGN(len) (((len) + TS_PRIV_ALIGNTO-1) & ~(TS_PRIV_ALIGNTO-1)) 
     210+ 
     211+static inline struct ts_config *alloc_ts_config(size_t payload, 
     212+                                               gfp_t gfp_mask) 
     213+{ 
     214+       struct ts_config *conf; 
     215+ 
     216+       conf = kmalloc(TS_PRIV_ALIGN(sizeof(*conf)) + payload, gfp_mask); 
     217+       if (conf == NULL) 
     218+               return -ENOMEM; 
     219+ 
     220+       memset(conf, 0, TS_PRIV_ALIGN(sizeof(*conf)) + payload); 
     221+       return conf; 
     222+} 
     223+ 
     224+static inline void *ts_config_priv(struct ts_config *conf) 
     225+{ 
     226+       return ((u8 *) conf + TS_PRIV_ALIGN(sizeof(struct ts_config))); 
     227+} 
     228+ 
     229+#endif /* __KERNEL__ */ 
     230+ 
     231+#endif 
     232diff -Nur linux-2.4.32/net/ipv4/netfilter/Config.in linux-2.4.32.patch/net/ipv4/netfilter/Config.in 
     233--- linux-2.4.32/net/ipv4/netfilter/Config.in   2005-01-19 15:10:13.000000000 +0100 
     234+++ linux-2.4.32.patch/net/ipv4/netfilter/Config.in     2005-12-16 00:41:43.023755250 +0100 
     235@@ -42,6 +42,7 @@ 
    4236   fi 
    5237   if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then 
     
    7239+    dep_tristate '  String match support (EXPERIMENTAL) ' CONFIG_IP_NF_MATCH_STRING $CONFIG_IP_NF_IPTABLES 
    8240     dep_tristate '  Owner match support (EXPERIMENTAL)' CONFIG_IP_NF_MATCH_OWNER $CONFIG_IP_NF_IPTABLES 
    9      dep_tristate '  Layer 7 match support (EXPERIMENTAL)' CONFIG_IP_NF_MATCH_LAYER7 $CONFIG_IP_NF_CONNTRACK 
    10      dep_mbool '  Layer 7 debugging output (EXPERIMENTAL)' CONFIG_IP_NF_MATCH_LAYER7_DEBUG $CONFIG_IP_NF_MATCH_LAYER7 
    11 --- linux/net/ipv4/netfilter/Makefile.org       2005-11-08 23:11:57.214378656 +0100 
    12 +++ linux/net/ipv4/netfilter/Makefile   2005-11-08 23:11:20.980886984 +0100 
    13 @@ -97,6 +97,7 @@ 
    14  obj-$(CONFIG_IP_NF_MATCH_CONNBYTES) += ipt_connbytes.o 
     241   fi 
     242 # The targets 
     243diff -Nur linux-2.4.32/net/ipv4/netfilter/ipt_string.c linux-2.4.32.patch/net/ipv4/netfilter/ipt_string.c 
     244--- linux-2.4.32/net/ipv4/netfilter/ipt_string.c        1970-01-01 01:00:00.000000000 +0100 
     245+++ linux-2.4.32.patch/net/ipv4/netfilter/ipt_string.c  2005-12-16 00:40:48.436343750 +0100 
     246@@ -0,0 +1,91 @@ 
     247+/* String matching match for iptables 
     248+ *  
     249+ * (C) 2005 Pablo Neira Ayuso <pablo@eurodev.net> 
     250+ * 
     251+ * This program is free software; you can redistribute it and/or modify 
     252+ * it under the terms of the GNU General Public License version 2 as 
     253+ * published by the Free Software Foundation. 
     254+ */ 
     255+ 
     256+#include <linux/init.h> 
     257+#include <linux/module.h> 
     258+#include <linux/kernel.h> 
     259+#include <linux/skbuff.h> 
     260+#include <linux/netfilter_ipv4/ip_tables.h> 
     261+#include <linux/netfilter_ipv4/ipt_string.h> 
     262+#include <linux/textsearch.h> 
     263+ 
     264+MODULE_AUTHOR("Pablo Neira Ayuso <pablo@eurodev.net>"); 
     265+MODULE_DESCRIPTION("IP tables string match module"); 
     266+MODULE_LICENSE("GPL"); 
     267+ 
     268+static int match(const struct sk_buff *skb, 
     269+                const struct net_device *in, 
     270+                const struct net_device *out, 
     271+                const void *matchinfo, 
     272+                int offset, 
     273+                int *hotdrop) 
     274+{ 
     275+       struct ts_state state; 
     276+       struct ipt_string_info *conf = (struct ipt_string_info *) matchinfo; 
     277+ 
     278+       memset(&state, 0, sizeof(struct ts_state)); 
     279+ 
     280+       return (skb_find_text((struct sk_buff *)skb, conf->from_offset,  
     281+                            conf->to_offset, conf->config, &state)  
     282+                            != UINT_MAX) && !conf->invert; 
     283+} 
     284+ 
     285+#define STRING_TEXT_PRIV(m) ((struct ipt_string_info *) m) 
     286+ 
     287+static int checkentry(const char *tablename, 
     288+                     const struct ipt_ip *ip, 
     289+                     void *matchinfo, 
     290+                     unsigned int matchsize, 
     291+                     unsigned int hook_mask) 
     292+{ 
     293+       struct ipt_string_info *conf = matchinfo; 
     294+       struct ts_config *ts_conf; 
     295+ 
     296+       if (matchsize != IPT_ALIGN(sizeof(struct ipt_string_info))) 
     297+               return 0; 
     298+ 
     299+       /* Damn, can't handle this case properly with iptables... */ 
     300+       if (conf->from_offset > conf->to_offset) 
     301+               return 0; 
     302+ 
     303+       ts_conf = textsearch_prepare(conf->algo, conf->pattern, conf->patlen, 
     304+                                    GFP_KERNEL, TS_AUTOLOAD); 
     305+       if (IS_ERR(ts_conf)) 
     306+               return 0; 
     307+ 
     308+       conf->config = ts_conf; 
     309+ 
     310+       return 1; 
     311+} 
     312+ 
     313+static void destroy(void *matchinfo, unsigned int matchsize) 
     314+{ 
     315+       textsearch_destroy(STRING_TEXT_PRIV(matchinfo)->config); 
     316+} 
     317+ 
     318+static struct ipt_match string_match = { 
     319+       .name           = "string", 
     320+       .match          = match, 
     321+       .checkentry     = checkentry, 
     322+       .destroy        = destroy, 
     323+       .me             = THIS_MODULE 
     324+}; 
     325+ 
     326+static int __init init(void) 
     327+{ 
     328+       return ipt_register_match(&string_match); 
     329+} 
     330+ 
     331+static void __exit fini(void) 
     332+{ 
     333+       ipt_unregister_match(&string_match); 
     334+} 
     335+ 
     336+module_init(init); 
     337+module_exit(fini); 
     338diff -Nur linux-2.4.32/net/ipv4/netfilter/Makefile linux-2.4.32.patch/net/ipv4/netfilter/Makefile 
     339--- linux-2.4.32/net/ipv4/netfilter/Makefile    2003-08-25 13:44:44.000000000 +0200 
     340+++ linux-2.4.32.patch/net/ipv4/netfilter/Makefile      2005-12-16 00:42:10.929499250 +0100 
     341@@ -85,6 +85,7 @@ 
     342 obj-$(CONFIG_IP_NF_MATCH_STATE) += ipt_state.o 
    15343 obj-$(CONFIG_IP_NF_MATCH_CONNTRACK) += ipt_conntrack.o 
    16344 obj-$(CONFIG_IP_NF_MATCH_UNCLEAN) += ipt_unclean.o 
     
    18346 obj-$(CONFIG_IP_NF_MATCH_TCPMSS) += ipt_tcpmss.o 
    19347  
    20  obj-$(CONFIG_IP_NF_MATCH_LAYER7) += ipt_layer7.o 
    21 --- linux/net/ipv4/netfilter/ipt_string.c       1970-01-01 01:00:00.000000000 +0100 
    22 +++ linux/net/ipv4/netfilter/ipt_string.c       2005-11-08 23:08:51.531606728 +0100 
    23 @@ -0,0 +1,218 @@ 
    24 +/* Kernel module to match a string into a packet. 
    25 + * 
    26 + * Copyright (C) 2000 Emmanuel Roger  <winfield@freegates.be> 
    27 + *  
    28 + * ChangeLog 
    29 + *     19.02.2002: Gianni Tedesco <gianni@ecsc.co.uk> 
    30 + *             Fixed SMP re-entrancy problem using per-cpu data areas 
    31 + *             for the skip/shift tables. 
    32 + *     02.05.2001: Gianni Tedesco <gianni@ecsc.co.uk> 
    33 + *             Fixed kernel panic, due to overrunning boyer moore string 
    34 + *             tables. Also slightly tweaked heuristic for deciding what 
    35 + *             search algo to use. 
    36 + *     27.01.2001: Gianni Tedesco <gianni@ecsc.co.uk> 
    37 + *             Implemented Boyer Moore Sublinear search algorithm 
    38 + *             alongside the existing linear search based on memcmp(). 
    39 + *             Also a quick check to decide which method to use on a per 
    40 + *             packet basis. 
    41 + */ 
    42 + 
    43 +#include <linux/smp.h> 
    44 +#include <linux/module.h> 
    45 +#include <linux/skbuff.h> 
    46 +#include <linux/file.h> 
    47 +#include <net/sock.h> 
    48 + 
    49 +#include <linux/netfilter_ipv4/ip_tables.h> 
    50 +#include <linux/netfilter_ipv4/ipt_string.h> 
    51 + 
    52 +MODULE_LICENSE("GPL"); 
    53 + 
    54 +struct string_per_cpu { 
    55 +       int *skip; 
    56 +       int *shift; 
    57 +       int *len; 
    58 +}; 
    59 + 
    60 +struct string_per_cpu *bm_string_data=NULL; 
    61 + 
    62 +/* Boyer Moore Sublinear string search - VERY FAST */ 
    63 +char *search_sublinear (char *needle, char *haystack, int needle_len, int haystack_len)  
    64 +{ 
    65 +       int M1, right_end, sk, sh;   
    66 +       int ended, j, i; 
    67 + 
    68 +       int *skip, *shift, *len; 
    69 +        
    70 +       /* use data suitable for this CPU */ 
    71 +       shift=bm_string_data[smp_processor_id()].shift; 
    72 +       skip=bm_string_data[smp_processor_id()].skip; 
    73 +       len=bm_string_data[smp_processor_id()].len; 
    74 +        
    75 +       /* Setup skip/shift tables */ 
    76 +       M1 = right_end = needle_len-1; 
    77 +       for (i = 0; i < BM_MAX_HLEN; i++) skip[i] = needle_len;   
    78 +       for (i = 0; needle[i]; i++) skip[needle[i]] = M1 - i;   
    79 + 
    80 +       for (i = 1; i < needle_len; i++) {    
    81 +               for (j = 0; j < needle_len && needle[M1 - j] == needle[M1 - i - j]; j++);   
    82 +               len[i] = j;   
    83 +       }   
    84 + 
    85 +       shift[0] = 1;   
    86 +       for (i = 1; i < needle_len; i++) shift[i] = needle_len;   
    87 +       for (i = M1; i > 0; i--) shift[len[i]] = i;   
    88 +       ended = 0;   
    89 +        
    90 +       for (i = 0; i < needle_len; i++) {   
    91 +               if (len[i] == M1 - i) ended = i;   
    92 +               if (ended) shift[i] = ended;   
    93 +       }   
    94 + 
    95 +       /* Do the search*/   
    96 +       while (right_end < haystack_len) 
    97 +       { 
    98 +               for (i = 0; i < needle_len && haystack[right_end - i] == needle[M1 - i]; i++);   
    99 +               if (i == needle_len) { 
    100 +                       return haystack+(right_end - M1); 
    101 +               } 
    102 +                
    103 +               sk = skip[haystack[right_end - i]];   
    104 +               sh = shift[i]; 
    105 +               right_end = max(right_end - i + sk, right_end + sh);   
    106 +       } 
    107 + 
    108 +       return NULL; 
    109 +}   
    110 + 
    111 +/* Linear string search based on memcmp() */ 
    112 +char *search_linear (char *needle, char *haystack, int needle_len, int haystack_len)  
    113 +{ 
    114 +       char *k = haystack + (haystack_len-needle_len); 
    115 +       char *t = haystack; 
    116 +        
    117 +       while ( t <= k ) { 
    118 +               if (memcmp(t, needle, needle_len) == 0) 
    119 +                       return t; 
    120 +               t++; 
    121 +       } 
    122 + 
    123 +       return NULL; 
    124 +} 
    125 + 
    126 + 
    127 +static int 
    128 +match(const struct sk_buff *skb, 
    129 +      const struct net_device *in, 
    130 +      const struct net_device *out, 
    131 +      const void *matchinfo, 
    132 +      int offset, 
    133 +      const void *hdr, 
    134 +      u_int16_t datalen, 
    135 +      int *hotdrop) 
    136 +{ 
    137 +       const struct ipt_string_info *info = matchinfo; 
    138 +       struct iphdr *ip = skb->nh.iph; 
    139 +       int hlen, nlen; 
    140 +       char *needle, *haystack; 
    141 +       proc_ipt_search search=search_linear; 
    142 + 
    143 +       if ( !ip ) return 0; 
    144 + 
    145 +       /* get lenghts, and validate them */ 
    146 +       nlen=info->len; 
    147 +       hlen=ntohs(ip->tot_len)-(ip->ihl*4); 
    148 +       if ( nlen > hlen ) return 0; 
    149 + 
    150 +       needle=(char *)&info->string; 
    151 +       haystack=(char *)ip+(ip->ihl*4); 
    152 + 
    153 +       /* The sublinear search comes in to its own 
    154 +        * on the larger packets */ 
    155 +       if ( (hlen>IPT_STRING_HAYSTACK_THRESH) && 
    156 +               (nlen>IPT_STRING_NEEDLE_THRESH) ) { 
    157 +               if ( hlen < BM_MAX_HLEN ) { 
    158 +                       search=search_sublinear; 
    159 +               }else{ 
    160 +                       if (net_ratelimit()) 
    161 +                               printk(KERN_INFO "ipt_string: Packet too big " 
    162 +                                       "to attempt sublinear string search " 
    163 +                                       "(%d bytes)\n", hlen ); 
    164 +               } 
    165 +       } 
    166 +        
    167 +    return ((search(needle, haystack, nlen, hlen)!=NULL) ^ info->invert); 
    168 +} 
    169 + 
    170 +static int 
    171 +checkentry(const char *tablename, 
    172 +           const struct ipt_ip *ip, 
    173 +           void *matchinfo, 
    174 +           unsigned int matchsize, 
    175 +           unsigned int hook_mask) 
    176 +{ 
    177 + 
    178 +       if (matchsize != IPT_ALIGN(sizeof(struct ipt_string_info))) 
    179 +               return 0; 
    180 + 
    181 +       return 1; 
    182 +} 
    183 + 
    184 +void string_freeup_data(void) 
    185 +{ 
    186 +       int c; 
    187 +        
    188 +       if ( bm_string_data ) { 
    189 +               for(c=0; c<smp_num_cpus; c++) { 
    190 +                       if ( bm_string_data[c].shift ) kfree(bm_string_data[c].shift); 
    191 +                       if ( bm_string_data[c].skip ) kfree(bm_string_data[c].skip); 
    192 +                       if ( bm_string_data[c].len ) kfree(bm_string_data[c].len); 
    193 +               } 
    194 +               kfree(bm_string_data); 
    195 +       } 
    196 +} 
    197 + 
    198 +static struct ipt_match string_match 
    199 += { { NULL, NULL }, "string", &match, &checkentry, NULL, THIS_MODULE }; 
    200 + 
    201 +static int __init init(void) 
    202 +{ 
    203 +       int c; 
    204 +       size_t tlen; 
    205 +       size_t alen; 
    206 + 
    207 +       tlen=sizeof(struct string_per_cpu)*smp_num_cpus; 
    208 +       alen=sizeof(int)*BM_MAX_HLEN; 
    209 +        
    210 +       /* allocate array of structures */ 
    211 +       if ( !(bm_string_data=kmalloc(tlen,GFP_KERNEL)) ) { 
    212 +               return 0; 
    213 +       } 
    214 +        
    215 +       memset(bm_string_data, 0, tlen); 
    216 +        
    217 +       /* allocate our skip/shift tables */ 
    218 +       for(c=0; c<smp_num_cpus; c++) { 
    219 +               if ( !(bm_string_data[c].shift=kmalloc(alen, GFP_KERNEL)) ) 
    220 +                       goto alloc_fail; 
    221 +               if ( !(bm_string_data[c].skip=kmalloc(alen, GFP_KERNEL)) ) 
    222 +                       goto alloc_fail; 
    223 +               if ( !(bm_string_data[c].len=kmalloc(alen, GFP_KERNEL)) ) 
    224 +                       goto alloc_fail; 
    225 +       } 
    226 +        
    227 +       return ipt_register_match(&string_match); 
    228 + 
    229 +alloc_fail: 
    230 +       string_freeup_data(); 
    231 +       return 0; 
    232 +} 
    233 + 
    234 +static void __exit fini(void) 
    235 +{ 
    236 +       ipt_unregister_match(&string_match); 
    237 +       string_freeup_data(); 
    238 +} 
    239 + 
    240 +module_init(init); 
    241 +module_exit(fini); 
    242 --- linux/include/linux/netfilter_ipv4/ipt_string.h     1970-01-01 01:00:00.000000000 +0100 
    243 +++ linux/include/linux/netfilter_ipv4/ipt_string.h     2005-11-08 23:09:45.219444936 +0100 
    244 @@ -0,0 +1,21 @@ 
    245 +#ifndef _IPT_STRING_H 
    246 +#define _IPT_STRING_H 
    247 + 
    248 +/* *** PERFORMANCE TWEAK *** 
    249 + * Packet size and search string threshold, 
    250 + * above which sublinear searches is used. */ 
    251 +#define IPT_STRING_HAYSTACK_THRESH     100 
    252 +#define IPT_STRING_NEEDLE_THRESH       20 
    253 + 
    254 +#define BM_MAX_NLEN 256 
    255 +#define BM_MAX_HLEN 1024 
    256 + 
    257 +typedef char *(*proc_ipt_search) (char *, char *, int, int); 
    258 + 
    259 +struct ipt_string_info { 
    260 +    char string[BM_MAX_NLEN]; 
    261 +    u_int16_t invert; 
    262 +    u_int16_t len; 
    263 +}; 
    264 + 
    265 +#endif /* _IPT_STRING_H */ 
     348 # targets 
Note: See TracChangeset for help on using the changeset viewer.