sctp: remove useless arguments from get_saddr() call
[linux-2.6.git] / include / net / pkt_cls.h
1 #ifndef __NET_PKT_CLS_H
2 #define __NET_PKT_CLS_H
3
4 #include <linux/pkt_cls.h>
5 #include <net/sch_generic.h>
6 #include <net/act_api.h>
7
8 /* Basic packet classifier frontend definitions. */
9
10 struct tcf_walker {
11         int     stop;
12         int     skip;
13         int     count;
14         int     (*fn)(struct tcf_proto *, unsigned long node, struct tcf_walker *);
15 };
16
17 extern int register_tcf_proto_ops(struct tcf_proto_ops *ops);
18 extern int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
19
20 static inline unsigned long
21 __cls_set_class(unsigned long *clp, unsigned long cl)
22 {
23         unsigned long old_cl;
24  
25         old_cl = *clp;
26         *clp = cl;
27         return old_cl;
28 }
29
30 static inline unsigned long
31 cls_set_class(struct tcf_proto *tp, unsigned long *clp, 
32         unsigned long cl)
33 {
34         unsigned long old_cl;
35         
36         tcf_tree_lock(tp);
37         old_cl = __cls_set_class(clp, cl);
38         tcf_tree_unlock(tp);
39  
40         return old_cl;
41 }
42
43 static inline void
44 tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
45 {
46         unsigned long cl;
47
48         cl = tp->q->ops->cl_ops->bind_tcf(tp->q, base, r->classid);
49         cl = cls_set_class(tp, &r->class, cl);
50         if (cl)
51                 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
52 }
53
54 static inline void
55 tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
56 {
57         unsigned long cl;
58
59         if ((cl = __cls_set_class(&r->class, 0)) != 0)
60                 tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
61 }
62
63 struct tcf_exts {
64 #ifdef CONFIG_NET_CLS_ACT
65         struct tc_action *action;
66 #endif
67 };
68
69 /* Map to export classifier specific extension TLV types to the
70  * generic extensions API. Unsupported extensions must be set to 0.
71  */
72 struct tcf_ext_map {
73         int action;
74         int police;
75 };
76
77 /**
78  * tcf_exts_is_predicative - check if a predicative extension is present
79  * @exts: tc filter extensions handle
80  *
81  * Returns 1 if a predicative extension is present, i.e. an extension which
82  * might cause further actions and thus overrule the regular tcf_result.
83  */
84 static inline int
85 tcf_exts_is_predicative(struct tcf_exts *exts)
86 {
87 #ifdef CONFIG_NET_CLS_ACT
88         return !!exts->action;
89 #else
90         return 0;
91 #endif
92 }
93
94 /**
95  * tcf_exts_is_available - check if at least one extension is present
96  * @exts: tc filter extensions handle
97  *
98  * Returns 1 if at least one extension is present.
99  */
100 static inline int
101 tcf_exts_is_available(struct tcf_exts *exts)
102 {
103         /* All non-predicative extensions must be added here. */
104         return tcf_exts_is_predicative(exts);
105 }
106
107 /**
108  * tcf_exts_exec - execute tc filter extensions
109  * @skb: socket buffer
110  * @exts: tc filter extensions handle
111  * @res: desired result
112  *
113  * Executes all configured extensions. Returns 0 on a normal execution,
114  * a negative number if the filter must be considered unmatched or
115  * a positive action code (TC_ACT_*) which must be returned to the
116  * underlying layer.
117  */
118 static inline int
119 tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
120                struct tcf_result *res)
121 {
122 #ifdef CONFIG_NET_CLS_ACT
123         if (exts->action)
124                 return tcf_action_exec(skb, exts->action, res);
125 #endif
126         return 0;
127 }
128
129 extern int tcf_exts_validate(struct tcf_proto *tp, struct nlattr **tb,
130                              struct nlattr *rate_tlv, struct tcf_exts *exts,
131                              const struct tcf_ext_map *map);
132 extern void tcf_exts_destroy(struct tcf_proto *tp, struct tcf_exts *exts);
133 extern void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
134                              struct tcf_exts *src);
135 extern int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts,
136                          const struct tcf_ext_map *map);
137 extern int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts,
138                                const struct tcf_ext_map *map);
139
140 /**
141  * struct tcf_pkt_info - packet information
142  */
143 struct tcf_pkt_info {
144         unsigned char *         ptr;
145         int                     nexthdr;
146 };
147
148 #ifdef CONFIG_NET_EMATCH
149
150 struct tcf_ematch_ops;
151
152 /**
153  * struct tcf_ematch - extended match (ematch)
154  * 
155  * @matchid: identifier to allow userspace to reidentify a match
156  * @flags: flags specifying attributes and the relation to other matches
157  * @ops: the operations lookup table of the corresponding ematch module
158  * @datalen: length of the ematch specific configuration data
159  * @data: ematch specific data
160  */
161 struct tcf_ematch {
162         struct tcf_ematch_ops * ops;
163         unsigned long           data;
164         unsigned int            datalen;
165         u16                     matchid;
166         u16                     flags;
167 };
168
169 static inline int tcf_em_is_container(struct tcf_ematch *em)
170 {
171         return !em->ops;
172 }
173
174 static inline int tcf_em_is_simple(struct tcf_ematch *em)
175 {
176         return em->flags & TCF_EM_SIMPLE;
177 }
178
179 static inline int tcf_em_is_inverted(struct tcf_ematch *em)
180 {
181         return em->flags & TCF_EM_INVERT;
182 }
183
184 static inline int tcf_em_last_match(struct tcf_ematch *em)
185 {
186         return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END;
187 }
188
189 static inline int tcf_em_early_end(struct tcf_ematch *em, int result)
190 {
191         if (tcf_em_last_match(em))
192                 return 1;
193
194         if (result == 0 && em->flags & TCF_EM_REL_AND)
195                 return 1;
196
197         if (result != 0 && em->flags & TCF_EM_REL_OR)
198                 return 1;
199
200         return 0;
201 }
202         
203 /**
204  * struct tcf_ematch_tree - ematch tree handle
205  *
206  * @hdr: ematch tree header supplied by userspace
207  * @matches: array of ematches
208  */
209 struct tcf_ematch_tree {
210         struct tcf_ematch_tree_hdr hdr;
211         struct tcf_ematch *     matches;
212         
213 };
214
215 /**
216  * struct tcf_ematch_ops - ematch module operations
217  * 
218  * @kind: identifier (kind) of this ematch module
219  * @datalen: length of expected configuration data (optional)
220  * @change: called during validation (optional)
221  * @match: called during ematch tree evaluation, must return 1/0
222  * @destroy: called during destroyage (optional)
223  * @dump: called during dumping process (optional)
224  * @owner: owner, must be set to THIS_MODULE
225  * @link: link to previous/next ematch module (internal use)
226  */
227 struct tcf_ematch_ops {
228         int                     kind;
229         int                     datalen;
230         int                     (*change)(struct tcf_proto *, void *,
231                                           int, struct tcf_ematch *);
232         int                     (*match)(struct sk_buff *, struct tcf_ematch *,
233                                          struct tcf_pkt_info *);
234         void                    (*destroy)(struct tcf_proto *,
235                                            struct tcf_ematch *);
236         int                     (*dump)(struct sk_buff *, struct tcf_ematch *);
237         struct module           *owner;
238         struct list_head        link;
239 };
240
241 extern int tcf_em_register(struct tcf_ematch_ops *);
242 extern void tcf_em_unregister(struct tcf_ematch_ops *);
243 extern int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
244                                 struct tcf_ematch_tree *);
245 extern void tcf_em_tree_destroy(struct tcf_proto *, struct tcf_ematch_tree *);
246 extern int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int);
247 extern int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *,
248                                struct tcf_pkt_info *);
249
250 /**
251  * tcf_em_tree_change - replace ematch tree of a running classifier
252  *
253  * @tp: classifier kind handle
254  * @dst: destination ematch tree variable
255  * @src: source ematch tree (temporary tree from tcf_em_tree_validate)
256  *
257  * This functions replaces the ematch tree in @dst with the ematch
258  * tree in @src. The classifier in charge of the ematch tree may be
259  * running.
260  */
261 static inline void tcf_em_tree_change(struct tcf_proto *tp,
262                                       struct tcf_ematch_tree *dst,
263                                       struct tcf_ematch_tree *src)
264 {
265         tcf_tree_lock(tp);
266         memcpy(dst, src, sizeof(*dst));
267         tcf_tree_unlock(tp);
268 }
269
270 /**
271  * tcf_em_tree_match - evaulate an ematch tree
272  *
273  * @skb: socket buffer of the packet in question
274  * @tree: ematch tree to be used for evaluation
275  * @info: packet information examined by classifier
276  *
277  * This function matches @skb against the ematch tree in @tree by going
278  * through all ematches respecting their logic relations returning
279  * as soon as the result is obvious.
280  *
281  * Returns 1 if the ematch tree as-one matches, no ematches are configured
282  * or ematch is not enabled in the kernel, otherwise 0 is returned.
283  */
284 static inline int tcf_em_tree_match(struct sk_buff *skb,
285                                     struct tcf_ematch_tree *tree,
286                                     struct tcf_pkt_info *info)
287 {
288         if (tree->hdr.nmatches)
289                 return __tcf_em_tree_match(skb, tree, info);
290         else
291                 return 1;
292 }
293
294 #define MODULE_ALIAS_TCF_EMATCH(kind)   MODULE_ALIAS("ematch-kind-" __stringify(kind))
295
296 #else /* CONFIG_NET_EMATCH */
297
298 struct tcf_ematch_tree {
299 };
300
301 #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
302 #define tcf_em_tree_destroy(tp, t) do { (void)(t); } while(0)
303 #define tcf_em_tree_dump(skb, t, tlv) (0)
304 #define tcf_em_tree_change(tp, dst, src) do { } while(0)
305 #define tcf_em_tree_match(skb, t, info) ((void)(info), 1)
306
307 #endif /* CONFIG_NET_EMATCH */
308
309 static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
310 {
311         switch (layer) {
312                 case TCF_LAYER_LINK:
313                         return skb->data;
314                 case TCF_LAYER_NETWORK:
315                         return skb_network_header(skb);
316                 case TCF_LAYER_TRANSPORT:
317                         return skb_transport_header(skb);
318         }
319
320         return NULL;
321 }
322
323 static inline int tcf_valid_offset(const struct sk_buff *skb,
324                                    const unsigned char *ptr, const int len)
325 {
326         return likely((ptr + len) <= skb_tail_pointer(skb) &&
327                       ptr >= skb->head &&
328                       (ptr <= (ptr + len)));
329 }
330
331 #ifdef CONFIG_NET_CLS_IND
332 #include <net/net_namespace.h>
333
334 static inline int
335 tcf_change_indev(struct tcf_proto *tp, char *indev, struct nlattr *indev_tlv)
336 {
337         if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
338                 return -EINVAL;
339         return 0;
340 }
341
342 static inline int
343 tcf_match_indev(struct sk_buff *skb, char *indev)
344 {
345         struct net_device *dev;
346
347         if (indev[0]) {
348                 if  (!skb->skb_iif)
349                         return 0;
350                 dev = __dev_get_by_index(dev_net(skb->dev), skb->skb_iif);
351                 if (!dev || strcmp(indev, dev->name))
352                         return 0;
353         }
354
355         return 1;
356 }
357 #endif /* CONFIG_NET_CLS_IND */
358
359 #endif