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