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