static u32 flow_get_src(const struct sk_buff *skb)
{
        switch (skb->protocol) {
        case __constant_htons(ETH_P_IP):
                return ntohl(ip_hdr(skb)->saddr);
        case __constant_htons(ETH_P_IPV6):
                return ntohl(ipv6_hdr(skb)->saddr.s6_addr32[3]);
        default:
                return addr_fold(skb->sk);
        }
}
                    has_ports(iph->protocol))
                        res = ntohs(*(__be16 *)((void *)iph + iph->ihl * 4 + 2)))
;
                break;
        }
        case __constant_htons(ETH_P_IPV6): {
                struct ipv6hdr *iph = ipv6_hdr(skb);
                if (has_ports(iph->nexthdr))
                        res = ntohs(*(__be16 *)((void *)&iph[1] + 2));
                break;
        }
        if (skb->dst)
                return skb->dst->tclassid;
#endif
        return 0;
}
static u32 flow_get_skuid(const struct sk_buff *skb)
{
        if (skb->sk && skb->sk->sk_socket && skb->sk->sk_socket->file)
                return skb->sk->sk_socket->file->f_uid;
        return 0;
{
        if (vlan_get_tag(skb, &tag) < 0)
                return 0;
        return tag & VLAN_VID_MASK;
}
static u32 flow_key_get(const struct sk_buff *skb, int key)
{
        switch (key) {
        case FLOW_KEY_SRC:
                return flow_get_src(skb);
        case FLOW_KEY_DST:
        [TCA_FLOW_MASK]         = { .type = NLA_U32 },
        [TCA_FLOW_XOR]          = { .type = NLA_U32 },
        [TCA_FLOW_DIVISOR]      = { .type = NLA_U32 },
        [TCA_FLOW_ACT]          = { .type = NLA_NESTED },
        [TCA_FLOW_POLICE]       = { .type = NLA_NESTED },
        [TCA_FLOW_EMATCHES]     = { .type = NLA_NESTED },
};
static int flow_change(struct tcf_proto *tp, unsigned long base,
                       u32 handle, struct nlattr **tca,
                       unsigned long *arg)
                f->keymask = keymask;
                f->nkeys   = nkeys;
        }
        f->mode = mode;
        if (tb[TCA_FLOW_MASK])
                f->mask = nla_get_u32(tb[TCA_FLOW_MASK]);
        if (tb[TCA_FLOW_XOR])
                f->xor = nla_get_u32(tb[TCA_FLOW_XOR]);
        if (tb[TCA_FLOW_RSHIFT])
{
        struct flow_filter *f = (struct flow_filter *)fh;
        struct nlattr *nest;
        if (f == NULL)
                return skb->len;
        t->tcm_handle = f->handle;
        nest = nla_nest_start(skb, TCA_OPTIONS);
        if (nest == NULL)
static void __exit cls_flow_exit(void)
{
        unregister_tcf_proto_ops(&cls_flow_ops);
}
module_init(cls_flow_init);
module_exit(cls_flow_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
MODULE_DESCRIPTION("TC flow classifier");