PageRenderTime 15ms CodeModel.GetById 5ms app.highlight 8ms RepoModel.GetById 0ms app.codeStats 0ms

/include/net/pkt_cls.h

https://bitbucket.org/thekraven/iscream_thunderc-2.6.35
C++ Header | 357 lines | 222 code | 51 blank | 84 comment | 20 complexity | 03f2b45da3c31585773f21667b50417c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  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
 10struct 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
 17extern int register_tcf_proto_ops(struct tcf_proto_ops *ops);
 18extern int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
 19
 20static 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
 30static inline unsigned long
 31cls_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
 43static inline void
 44tcf_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
 54static inline void
 55tcf_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
 63struct 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 */
 72struct 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 */
 84static inline int
 85tcf_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 */
100static inline int
101tcf_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 */
118static inline int
119tcf_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
129extern 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);
132extern void tcf_exts_destroy(struct tcf_proto *tp, struct tcf_exts *exts);
133extern void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
134	                     struct tcf_exts *src);
135extern int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts,
136	                 const struct tcf_ext_map *map);
137extern 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 */
143struct tcf_pkt_info {
144	unsigned char *		ptr;
145	int			nexthdr;
146};
147
148#ifdef CONFIG_NET_EMATCH
149
150struct 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 */
161struct tcf_ematch {
162	struct tcf_ematch_ops * ops;
163	unsigned long		data;
164	unsigned int		datalen;
165	u16			matchid;
166	u16			flags;
167};
168
169static inline int tcf_em_is_container(struct tcf_ematch *em)
170{
171	return !em->ops;
172}
173
174static inline int tcf_em_is_simple(struct tcf_ematch *em)
175{
176	return em->flags & TCF_EM_SIMPLE;
177}
178
179static inline int tcf_em_is_inverted(struct tcf_ematch *em)
180{
181	return em->flags & TCF_EM_INVERT;
182}
183
184static 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
189static 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 */
209struct 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 */
227struct 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
241extern int tcf_em_register(struct tcf_ematch_ops *);
242extern void tcf_em_unregister(struct tcf_ematch_ops *);
243extern int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
244				struct tcf_ematch_tree *);
245extern void tcf_em_tree_destroy(struct tcf_proto *, struct tcf_ematch_tree *);
246extern int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int);
247extern 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 */
261static 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 */
284static 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
298struct 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
309static 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
323static inline int tcf_valid_offset(const struct sk_buff *skb,
324				   const unsigned char *ptr, const int len)
325{
326	return unlikely((ptr + len) < skb_tail_pointer(skb) && ptr > skb->head);
327}
328
329#ifdef CONFIG_NET_CLS_IND
330#include <net/net_namespace.h>
331
332static inline int
333tcf_change_indev(struct tcf_proto *tp, char *indev, struct nlattr *indev_tlv)
334{
335	if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
336		return -EINVAL;
337	return 0;
338}
339
340static inline int
341tcf_match_indev(struct sk_buff *skb, char *indev)
342{
343	struct net_device *dev;
344
345	if (indev[0]) {
346		if  (!skb->skb_iif)
347			return 0;
348		dev = __dev_get_by_index(dev_net(skb->dev), skb->skb_iif);
349		if (!dev || strcmp(indev, dev->name))
350			return 0;
351	}
352
353	return 1;
354}
355#endif /* CONFIG_NET_CLS_IND */
356
357#endif