ia64/linux-2.6.18-xen.hg

view net/netfilter/xt_dccp.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 14 10:09:15 2009 +0100 (2009-05-14)
parents 831230e53067
children
line source
1 /*
2 * iptables module for DCCP protocol header matching
3 *
4 * (C) 2005 by Harald Welte <laforge@netfilter.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
11 #include <linux/module.h>
12 #include <linux/skbuff.h>
13 #include <linux/spinlock.h>
14 #include <net/ip.h>
15 #include <linux/dccp.h>
17 #include <linux/netfilter/x_tables.h>
18 #include <linux/netfilter/xt_dccp.h>
20 #include <linux/netfilter_ipv4/ip_tables.h>
21 #include <linux/netfilter_ipv6/ip6_tables.h>
23 MODULE_LICENSE("GPL");
24 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
25 MODULE_DESCRIPTION("Match for DCCP protocol packets");
26 MODULE_ALIAS("ipt_dccp");
28 #define DCCHECK(cond, option, flag, invflag) (!((flag) & (option)) \
29 || (!!((invflag) & (option)) ^ (cond)))
31 static unsigned char *dccp_optbuf;
32 static DEFINE_SPINLOCK(dccp_buflock);
34 static inline int
35 dccp_find_option(u_int8_t option,
36 const struct sk_buff *skb,
37 unsigned int protoff,
38 const struct dccp_hdr *dh,
39 int *hotdrop)
40 {
41 /* tcp.doff is only 4 bits, ie. max 15 * 4 bytes */
42 unsigned char *op;
43 unsigned int optoff = __dccp_hdr_len(dh);
44 unsigned int optlen = dh->dccph_doff*4 - __dccp_hdr_len(dh);
45 unsigned int i;
47 if (dh->dccph_doff * 4 < __dccp_hdr_len(dh)) {
48 *hotdrop = 1;
49 return 0;
50 }
52 if (!optlen)
53 return 0;
55 spin_lock_bh(&dccp_buflock);
56 op = skb_header_pointer(skb, protoff + optoff, optlen, dccp_optbuf);
57 if (op == NULL) {
58 /* If we don't have the whole header, drop packet. */
59 spin_unlock_bh(&dccp_buflock);
60 *hotdrop = 1;
61 return 0;
62 }
64 for (i = 0; i < optlen; ) {
65 if (op[i] == option) {
66 spin_unlock_bh(&dccp_buflock);
67 return 1;
68 }
70 if (op[i] < 2)
71 i++;
72 else
73 i += op[i+1]?:1;
74 }
76 spin_unlock_bh(&dccp_buflock);
77 return 0;
78 }
81 static inline int
82 match_types(const struct dccp_hdr *dh, u_int16_t typemask)
83 {
84 return (typemask & (1 << dh->dccph_type));
85 }
87 static inline int
88 match_option(u_int8_t option, const struct sk_buff *skb, unsigned int protoff,
89 const struct dccp_hdr *dh, int *hotdrop)
90 {
91 return dccp_find_option(option, skb, protoff, dh, hotdrop);
92 }
94 static int
95 match(const struct sk_buff *skb,
96 const struct net_device *in,
97 const struct net_device *out,
98 const struct xt_match *match,
99 const void *matchinfo,
100 int offset,
101 unsigned int protoff,
102 int *hotdrop)
103 {
104 const struct xt_dccp_info *info = matchinfo;
105 struct dccp_hdr _dh, *dh;
107 if (offset)
108 return 0;
110 dh = skb_header_pointer(skb, protoff, sizeof(_dh), &_dh);
111 if (dh == NULL) {
112 *hotdrop = 1;
113 return 0;
114 }
116 return DCCHECK(((ntohs(dh->dccph_sport) >= info->spts[0])
117 && (ntohs(dh->dccph_sport) <= info->spts[1])),
118 XT_DCCP_SRC_PORTS, info->flags, info->invflags)
119 && DCCHECK(((ntohs(dh->dccph_dport) >= info->dpts[0])
120 && (ntohs(dh->dccph_dport) <= info->dpts[1])),
121 XT_DCCP_DEST_PORTS, info->flags, info->invflags)
122 && DCCHECK(match_types(dh, info->typemask),
123 XT_DCCP_TYPE, info->flags, info->invflags)
124 && DCCHECK(match_option(info->option, skb, protoff, dh,
125 hotdrop),
126 XT_DCCP_OPTION, info->flags, info->invflags);
127 }
129 static int
130 checkentry(const char *tablename,
131 const void *inf,
132 const struct xt_match *match,
133 void *matchinfo,
134 unsigned int matchsize,
135 unsigned int hook_mask)
136 {
137 const struct xt_dccp_info *info = matchinfo;
139 return !(info->flags & ~XT_DCCP_VALID_FLAGS)
140 && !(info->invflags & ~XT_DCCP_VALID_FLAGS)
141 && !(info->invflags & ~info->flags);
142 }
144 static struct xt_match dccp_match =
145 {
146 .name = "dccp",
147 .match = match,
148 .matchsize = sizeof(struct xt_dccp_info),
149 .proto = IPPROTO_DCCP,
150 .checkentry = checkentry,
151 .family = AF_INET,
152 .me = THIS_MODULE,
153 };
154 static struct xt_match dccp6_match =
155 {
156 .name = "dccp",
157 .match = match,
158 .matchsize = sizeof(struct xt_dccp_info),
159 .proto = IPPROTO_DCCP,
160 .checkentry = checkentry,
161 .family = AF_INET6,
162 .me = THIS_MODULE,
163 };
166 static int __init xt_dccp_init(void)
167 {
168 int ret;
170 /* doff is 8 bits, so the maximum option size is (4*256). Don't put
171 * this in BSS since DaveM is worried about locked TLB's for kernel
172 * BSS. */
173 dccp_optbuf = kmalloc(256 * 4, GFP_KERNEL);
174 if (!dccp_optbuf)
175 return -ENOMEM;
176 ret = xt_register_match(&dccp_match);
177 if (ret)
178 goto out_kfree;
179 ret = xt_register_match(&dccp6_match);
180 if (ret)
181 goto out_unreg;
183 return ret;
185 out_unreg:
186 xt_unregister_match(&dccp_match);
187 out_kfree:
188 kfree(dccp_optbuf);
190 return ret;
191 }
193 static void __exit xt_dccp_fini(void)
194 {
195 xt_unregister_match(&dccp6_match);
196 xt_unregister_match(&dccp_match);
197 kfree(dccp_optbuf);
198 }
200 module_init(xt_dccp_init);
201 module_exit(xt_dccp_fini);