--- netfilter-2.6.14.git/net/ipv4/netfilter/ip_conntrack_netlink.c 2005-11-22 20:18:21.000000000 +0100 +++ netfilter-2.6.14.git/net/netfilter/nf_conntrack_netlink.c 2005-11-22 20:11:02.000000000 +0100 @@ -16,6 +16,8 @@ * * This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. + * + * Derived from ip_conntrack_netlink.c: Port by Pablo Neira Ayuso (05/11/14) */ #include @@ -30,10 +32,11 @@ #include #include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include #include @@ -41,7 +44,7 @@ MODULE_LICENSE("GPL"); -static char __initdata version[] = "0.90"; +static char __initdata version[] = "0.92"; #if 0 #define DEBUGP printk @@ -52,20 +55,20 @@ static char __initdata version[] = "0.90 static inline int ctnetlink_dump_tuples_proto(struct sk_buff *skb, - const struct ip_conntrack_tuple *tuple) + const struct nf_conntrack_tuple *tuple) { - struct ip_conntrack_protocol *proto; + struct nf_conntrack_protocol *proto; int ret = 0; NFA_PUT(skb, CTA_PROTO_NUM, sizeof(u_int8_t), &tuple->dst.protonum); /* If no protocol helper is found, this function will return the * generic protocol helper, so proto won't *ever* be NULL */ - proto = ip_conntrack_proto_find_get(tuple->dst.protonum); + proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum); if (likely(proto->tuple_to_nfattr)) ret = proto->tuple_to_nfattr(skb, tuple); - ip_conntrack_proto_put(proto); + nf_ct_proto_put(proto); return ret; @@ -75,27 +78,33 @@ nfattr_failure: static inline int ctnetlink_dump_tuples(struct sk_buff *skb, - const struct ip_conntrack_tuple *tuple) + const struct nf_conntrack_tuple *tuple) { struct nfattr *nest_parms; + struct nf_conntrack_l3proto *l3proto; + int ret = 0; + + l3proto = nf_ct_l3proto_find_get(tuple->src.l3num); nest_parms = NFA_NEST(skb, CTA_TUPLE_IP); - NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t), &tuple->src.ip); - NFA_PUT(skb, CTA_IP_V4_DST, sizeof(u_int32_t), &tuple->dst.ip); + if (likely(l3proto->tuple_to_nfattr)) + ret = l3proto->tuple_to_nfattr(skb, tuple); NFA_NEST_END(skb, nest_parms); + nf_ct_l3proto_put(l3proto); + nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO); ctnetlink_dump_tuples_proto(skb, tuple); NFA_NEST_END(skb, nest_parms); - return 0; + return ret; nfattr_failure: return -1; } static inline int -ctnetlink_dump_status(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_status(struct sk_buff *skb, const struct nf_conn *ct) { u_int32_t status = htonl((u_int32_t) ct->status); NFA_PUT(skb, CTA_STATUS, sizeof(status), &status); @@ -106,7 +115,7 @@ nfattr_failure: } static inline int -ctnetlink_dump_timeout(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_timeout(struct sk_buff *skb, const struct nf_conn *ct) { long timeout_l = ct->timeout.expires - jiffies; u_int32_t timeout; @@ -124,15 +133,14 @@ nfattr_failure: } static inline int -ctnetlink_dump_protoinfo(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_protoinfo(struct sk_buff *skb, const struct nf_conn *ct) { - struct ip_conntrack_protocol *proto = ip_conntrack_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum); - + struct nf_conntrack_protocol *proto = nf_ct_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num, ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum); struct nfattr *nest_proto; int ret; if (!proto->to_nfattr) { - ip_conntrack_proto_put(proto); + nf_ct_proto_put(proto); return 0; } @@ -140,7 +148,7 @@ ctnetlink_dump_protoinfo(struct sk_buff ret = proto->to_nfattr(skb, nest_proto, ct); - ip_conntrack_proto_put(proto); + nf_ct_proto_put(proto); NFA_NEST_END(skb, nest_proto); @@ -151,7 +159,7 @@ nfattr_failure: } static inline int -ctnetlink_dump_helpinfo(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_helpinfo(struct sk_buff *skb, const struct nf_conn *ct) { struct nfattr *nest_helper; @@ -172,9 +180,9 @@ nfattr_failure: return -1; } -#ifdef CONFIG_IP_NF_CT_ACCT +#ifdef CONFIG_NF_CT_ACCT static inline int -ctnetlink_dump_counters(struct sk_buff *skb, const struct ip_conntrack *ct, +ctnetlink_dump_counters(struct sk_buff *skb, const struct nf_conn *ct, enum ip_conntrack_dir dir) { enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG; @@ -198,9 +206,9 @@ nfattr_failure: #define ctnetlink_dump_counters(a, b, c) (0) #endif -#ifdef CONFIG_IP_NF_CONNTRACK_MARK +#ifdef CONFIG_NF_CONNTRACK_MARK static inline int -ctnetlink_dump_mark(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_mark(struct sk_buff *skb, const struct nf_conn *ct) { u_int32_t mark = htonl(ct->mark); @@ -215,7 +223,7 @@ nfattr_failure: #endif static inline int -ctnetlink_dump_id(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_id(struct sk_buff *skb, const struct nf_conn *ct) { u_int32_t id = htonl(ct->id); NFA_PUT(skb, CTA_ID, sizeof(u_int32_t), &id); @@ -226,7 +234,7 @@ nfattr_failure: } static inline int -ctnetlink_dump_use(struct sk_buff *skb, const struct ip_conntrack *ct) +ctnetlink_dump_use(struct sk_buff *skb, const struct nf_conn *ct) { unsigned int use = htonl(atomic_read(&ct->ct_general.use)); @@ -242,7 +250,7 @@ nfattr_failure: static int ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event, int nowait, - const struct ip_conntrack *ct) + const struct nf_conn *ct) { struct nlmsghdr *nlh; struct nfgenmsg *nfmsg; @@ -256,7 +264,8 @@ ctnetlink_fill_info(struct sk_buff *skb, nfmsg = NLMSG_DATA(nlh); nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0; - nfmsg->nfgen_family = AF_INET; + nfmsg->nfgen_family = + ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num; nfmsg->version = NFNETLINK_V0; nfmsg->res_id = 0; @@ -290,21 +299,21 @@ nfattr_failure: return -1; } -#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS +#ifdef CONFIG_NF_CONNTRACK_EVENTS static int ctnetlink_conntrack_event(struct notifier_block *this, unsigned long events, void *ptr) { struct nlmsghdr *nlh; struct nfgenmsg *nfmsg; struct nfattr *nest_parms; - struct ip_conntrack *ct = (struct ip_conntrack *)ptr; + struct nf_conn *ct = (struct nf_conn *)ptr; struct sk_buff *skb; unsigned int type; unsigned char *b; unsigned int flags = 0, group; /* ignore our fake conntrack entry */ - if (ct == &ip_conntrack_untracked) + if (ct == &nf_conntrack_untracked) return NOTIFY_DONE; if (events & IPCT_DESTROY) { @@ -387,7 +396,7 @@ nfattr_failure: kfree_skb(skb); return NOTIFY_DONE; } -#endif /* CONFIG_IP_NF_CONNTRACK_EVENTS */ +#endif /* CONFIG_NF_CONNTRACK_EVENTS */ static int ctnetlink_done(struct netlink_callback *cb) { @@ -398,21 +407,21 @@ static int ctnetlink_done(struct netlink static int ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) { - struct ip_conntrack *ct = NULL; - struct ip_conntrack_tuple_hash *h; + struct nf_conn *ct = NULL; + struct nf_conntrack_tuple_hash *h; struct list_head *i; u_int32_t *id = (u_int32_t *) &cb->args[1]; DEBUGP("entered %s, last bucket=%lu id=%u\n", __FUNCTION__, cb->args[0], *id); - read_lock_bh(&ip_conntrack_lock); - for (; cb->args[0] < ip_conntrack_htable_size; cb->args[0]++, *id = 0) { - list_for_each_prev(i, &ip_conntrack_hash[cb->args[0]]) { - h = (struct ip_conntrack_tuple_hash *) i; + read_lock_bh(&nf_conntrack_lock); + for (; cb->args[0] < nf_conntrack_htable_size; cb->args[0]++, *id = 0) { + list_for_each_prev(i, &nf_conntrack_hash[cb->args[0]]) { + h = (struct nf_conntrack_tuple_hash *) i; if (DIRECTION(h) != IP_CT_DIR_ORIGINAL) continue; - ct = tuplehash_to_ctrack(h); + ct = nf_ct_tuplehash_to_ctrack(h); if (ct->id <= *id) continue; if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid, @@ -424,32 +433,32 @@ ctnetlink_dump_table(struct sk_buff *skb } } out: - read_unlock_bh(&ip_conntrack_lock); + read_unlock_bh(&nf_conntrack_lock); DEBUGP("leaving, last bucket=%lu id=%u\n", cb->args[0], *id); return skb->len; } -#ifdef CONFIG_IP_NF_CT_ACCT +#ifdef CONFIG_NF_CT_ACCT static int ctnetlink_dump_table_w(struct sk_buff *skb, struct netlink_callback *cb) { - struct ip_conntrack *ct = NULL; - struct ip_conntrack_tuple_hash *h; + struct nf_conn *ct = NULL; + struct nf_conntrack_tuple_hash *h; struct list_head *i; u_int32_t *id = (u_int32_t *) &cb->args[1]; DEBUGP("entered %s, last bucket=%u id=%u\n", __FUNCTION__, cb->args[0], *id); - write_lock_bh(&ip_conntrack_lock); - for (; cb->args[0] < ip_conntrack_htable_size; cb->args[0]++, *id = 0) { - list_for_each_prev(i, &ip_conntrack_hash[cb->args[0]]) { - h = (struct ip_conntrack_tuple_hash *) i; + write_lock_bh(&nf_conntrack_lock); + for (; cb->args[0] < nf_conntrack_htable_size; cb->args[0]++, *id = 0) { + list_for_each_prev(i, &nf_conntrack_hash[cb->args[0]]) { + h = (struct nf_conntrack_tuple_hash *) i; if (DIRECTION(h) != IP_CT_DIR_ORIGINAL) continue; - ct = tuplehash_to_ctrack(h); + ct = nf_ct_tuplehash_to_ctrack(h); if (ct->id <= *id) continue; if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid, @@ -463,7 +472,7 @@ ctnetlink_dump_table_w(struct sk_buff *s } } out: - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); DEBUGP("leaving, last bucket=%lu id=%u\n", cb->args[0], *id); @@ -477,9 +486,11 @@ static const size_t cta_min_ip[CTA_IP_MA }; static inline int -ctnetlink_parse_tuple_ip(struct nfattr *attr, struct ip_conntrack_tuple *tuple) +ctnetlink_parse_tuple_ip(struct nfattr *attr, struct nf_conntrack_tuple *tuple) { struct nfattr *tb[CTA_IP_MAX]; + struct nf_conntrack_l3proto *l3proto; + int ret = 0; DEBUGP("entered %s\n", __FUNCTION__); @@ -488,17 +499,16 @@ ctnetlink_parse_tuple_ip(struct nfattr * if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip)) return -EINVAL; - if (!tb[CTA_IP_V4_SRC-1]) - return -EINVAL; - tuple->src.ip = *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_SRC-1]); + l3proto = nf_ct_l3proto_find_get(tuple->src.l3num); - if (!tb[CTA_IP_V4_DST-1]) - return -EINVAL; - tuple->dst.ip = *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_DST-1]); + if (likely(l3proto->nfattr_to_tuple)) + ret = l3proto->nfattr_to_tuple(tb, tuple); + + nf_ct_l3proto_put(l3proto); DEBUGP("leaving\n"); - return 0; + return ret; } static const size_t cta_min_proto[CTA_PROTO_MAX] = { @@ -512,10 +522,10 @@ static const size_t cta_min_proto[CTA_PR static inline int ctnetlink_parse_tuple_proto(struct nfattr *attr, - struct ip_conntrack_tuple *tuple) + struct nf_conntrack_tuple *tuple) { struct nfattr *tb[CTA_PROTO_MAX]; - struct ip_conntrack_protocol *proto; + struct nf_conntrack_protocol *proto; int ret = 0; DEBUGP("entered %s\n", __FUNCTION__); @@ -529,19 +539,19 @@ ctnetlink_parse_tuple_proto(struct nfatt return -EINVAL; tuple->dst.protonum = *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_NUM-1]); - proto = ip_conntrack_proto_find_get(tuple->dst.protonum); + proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum); if (likely(proto->nfattr_to_tuple)) ret = proto->nfattr_to_tuple(tb, tuple); - - ip_conntrack_proto_put(proto); + + nf_ct_proto_put(proto); return ret; } static inline int -ctnetlink_parse_tuple(struct nfattr *cda[], struct ip_conntrack_tuple *tuple, - enum ctattr_tuple type) +ctnetlink_parse_tuple(struct nfattr *cda[], struct nf_conntrack_tuple *tuple, + enum ctattr_tuple type, u_int8_t l3num) { struct nfattr *tb[CTA_TUPLE_MAX]; int err; @@ -555,6 +565,8 @@ ctnetlink_parse_tuple(struct nfattr *cda if (!tb[CTA_TUPLE_IP-1]) return -EINVAL; + tuple->src.l3num = l3num; + err = ctnetlink_parse_tuple_ip(tb[CTA_TUPLE_IP-1], tuple); if (err < 0) return err; @@ -572,7 +584,7 @@ ctnetlink_parse_tuple(struct nfattr *cda else tuple->dst.dir = IP_CT_DIR_ORIGINAL; - DUMP_TUPLE(tuple); + NF_CT_DUMP_TUPLE(tuple); DEBUGP("leaving\n"); @@ -586,7 +598,7 @@ static const size_t cta_min_protonat[CTA }; static int ctnetlink_parse_nat_proto(struct nfattr *attr, - const struct ip_conntrack *ct, + const struct nf_conn *ct, struct ip_nat_range *range) { struct nfattr *tb[CTA_PROTONAT_MAX]; @@ -623,7 +635,7 @@ static const size_t cta_min_nat[CTA_NAT_ static inline int ctnetlink_parse_nat(struct nfattr *cda[], - const struct ip_conntrack *ct, struct ip_nat_range *range) + const struct nf_conn *ct, struct ip_nat_range *range) { struct nfattr *tb[CTA_NAT_MAX]; int err; @@ -689,9 +701,11 @@ static int ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb, struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) { - struct ip_conntrack_tuple_hash *h; - struct ip_conntrack_tuple tuple; - struct ip_conntrack *ct; + struct nf_conntrack_tuple_hash *h; + struct nf_conntrack_tuple tuple; + struct nf_conn *ct; + struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); + u_int8_t u3 = nfmsg->nfgen_family; int err = 0; DEBUGP("entered %s\n", __FUNCTION__); @@ -700,39 +714,39 @@ ctnetlink_del_conntrack(struct sock *ctn return -EINVAL; if (cda[CTA_TUPLE_ORIG-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3); else if (cda[CTA_TUPLE_REPLY-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3); else { /* Flush the whole table */ - ip_conntrack_flush(); + nf_conntrack_flush(); return 0; } if (err < 0) return err; - h = ip_conntrack_find_get(&tuple, NULL); + h = nf_conntrack_find_get(&tuple, NULL); if (!h) { DEBUGP("tuple not found in conntrack hash\n"); return -ENOENT; } - ct = tuplehash_to_ctrack(h); + ct = nf_ct_tuplehash_to_ctrack(h); if (cda[CTA_ID-1]) { u_int32_t id = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_ID-1])); if (ct->id != id) { - ip_conntrack_put(ct); + nf_ct_put(ct); return -ENOENT; } } if (del_timer(&ct->timeout)) { - ip_conntrack_put(ct); + nf_ct_put(ct); ct->timeout.function((unsigned long)ct); return 0; } - ip_conntrack_put(ct); + nf_ct_put(ct); DEBUGP("leaving\n"); return 0; @@ -742,24 +756,25 @@ static int ctnetlink_get_conntrack(struct sock *ctnl, struct sk_buff *skb, struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) { - struct ip_conntrack_tuple_hash *h; - struct ip_conntrack_tuple tuple; - struct ip_conntrack *ct; + struct nf_conntrack_tuple_hash *h; + struct nf_conntrack_tuple tuple; + struct nf_conn *ct; struct sk_buff *skb2 = NULL; + struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); + u_int8_t u3 = nfmsg->nfgen_family; int err = 0; DEBUGP("entered %s\n", __FUNCTION__); if (nlh->nlmsg_flags & NLM_F_DUMP) { - struct nfgenmsg *msg = NLMSG_DATA(nlh); u32 rlen; - if (msg->nfgen_family != AF_INET) + if (nfmsg->nfgen_family != AF_INET) return -EAFNOSUPPORT; if (NFNL_MSG_TYPE(nlh->nlmsg_type) == IPCTNL_MSG_CT_GET_CTRZERO) { -#ifdef CONFIG_IP_NF_CT_ACCT +#ifdef CONFIG_NF_CT_ACCT if ((*errp = netlink_dump_start(ctnl, skb, nlh, ctnetlink_dump_table_w, ctnetlink_done)) != 0) @@ -785,34 +800,34 @@ ctnetlink_get_conntrack(struct sock *ctn return -EINVAL; if (cda[CTA_TUPLE_ORIG-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3); else if (cda[CTA_TUPLE_REPLY-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3); else return -EINVAL; if (err < 0) return err; - h = ip_conntrack_find_get(&tuple, NULL); + h = nf_conntrack_find_get(&tuple, NULL); if (!h) { DEBUGP("tuple not found in conntrack hash"); return -ENOENT; } DEBUGP("tuple found\n"); - ct = tuplehash_to_ctrack(h); + ct = nf_ct_tuplehash_to_ctrack(h); err = -ENOMEM; skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); if (!skb2) { - ip_conntrack_put(ct); + nf_ct_put(ct); return -ENOMEM; } NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid; err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, IPCTNL_MSG_CT_NEW, 1, ct); - ip_conntrack_put(ct); + nf_ct_put(ct); if (err <= 0) goto free; @@ -830,7 +845,7 @@ out: } static inline int -ctnetlink_change_status(struct ip_conntrack *ct, struct nfattr *cda[]) +ctnetlink_change_status(struct nf_conn *ct, struct nfattr *cda[]) { unsigned long d; unsigned status = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_STATUS-1])); @@ -894,9 +909,9 @@ ctnetlink_change_status(struct ip_conntr static inline int -ctnetlink_change_helper(struct ip_conntrack *ct, struct nfattr *cda[]) +ctnetlink_change_helper(struct nf_conn *ct, struct nfattr *cda[]) { - struct ip_conntrack_helper *helper; + struct nf_conntrack_helper *helper; char *helpname; int err; @@ -910,7 +925,7 @@ ctnetlink_change_helper(struct ip_conntr if (err < 0) return err; - helper = __ip_conntrack_helper_find_byname(helpname); + helper = __nf_conntrack_helper_find_byname(helpname); if (!helper) { if (!strcmp(helpname, "")) helper = NULL; @@ -921,7 +936,7 @@ ctnetlink_change_helper(struct ip_conntr if (ct->helper) { if (!helper) { /* we had a helper before ... */ - ip_ct_remove_expectations(ct); + nf_ct_remove_expectations(ct); ct->helper = NULL; } else { /* need to zero data of old helper */ @@ -935,7 +950,7 @@ ctnetlink_change_helper(struct ip_conntr } static inline int -ctnetlink_change_timeout(struct ip_conntrack *ct, struct nfattr *cda[]) +ctnetlink_change_timeout(struct nf_conn *ct, struct nfattr *cda[]) { u_int32_t timeout = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_TIMEOUT-1])); @@ -949,26 +964,27 @@ ctnetlink_change_timeout(struct ip_connt } static inline int -ctnetlink_change_protoinfo(struct ip_conntrack *ct, struct nfattr *cda[]) +ctnetlink_change_protoinfo(struct nf_conn *ct, struct nfattr *cda[]) { struct nfattr *tb[CTA_PROTOINFO_MAX], *attr = cda[CTA_PROTOINFO-1]; - struct ip_conntrack_protocol *proto; + struct nf_conntrack_protocol *proto; u_int16_t npt = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum; + u_int16_t l3num = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num; int err = 0; nfattr_parse_nested(tb, CTA_PROTOINFO_MAX, attr); - proto = ip_conntrack_proto_find_get(npt); + proto = nf_ct_proto_find_get(l3num, npt); if (proto->from_nfattr) err = proto->from_nfattr(tb, ct); - ip_conntrack_proto_put(proto); + nf_ct_proto_put(proto); return err; } static int -ctnetlink_change_conntrack(struct ip_conntrack *ct, struct nfattr *cda[]) +ctnetlink_change_conntrack(struct nf_conn *ct, struct nfattr *cda[]) { int err; @@ -1009,15 +1025,15 @@ ctnetlink_change_conntrack(struct ip_con static int ctnetlink_create_conntrack(struct nfattr *cda[], - struct ip_conntrack_tuple *otuple, - struct ip_conntrack_tuple *rtuple) + struct nf_conntrack_tuple *otuple, + struct nf_conntrack_tuple *rtuple) { - struct ip_conntrack *ct; + struct nf_conn *ct; int err = -EINVAL; DEBUGP("entered %s\n", __FUNCTION__); - ct = ip_conntrack_alloc(otuple, rtuple); + ct = nf_conntrack_alloc(otuple, rtuple); if (ct == NULL || IS_ERR(ct)) return -ENOMEM; @@ -1038,13 +1054,13 @@ ctnetlink_create_conntrack(struct nfattr return err; } - ct->helper = ip_conntrack_helper_find_get(rtuple); + ct->helper = nf_ct_helper_find_get(rtuple); add_timer(&ct->timeout); - ip_conntrack_hash_insert(ct); + nf_conntrack_hash_insert(ct); if (ct->helper) - ip_conntrack_helper_put(ct->helper); + nf_ct_helper_put(ct->helper); #if defined(CONFIG_IP_NF_CONNTRACK_MARK) if (cda[CTA_MARK-1]) @@ -1055,7 +1071,7 @@ ctnetlink_create_conntrack(struct nfattr return 0; err: - ip_conntrack_free(ct); + nf_conntrack_free(ct); return err; } @@ -1063,8 +1079,10 @@ static int ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb, struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) { - struct ip_conntrack_tuple otuple, rtuple; - struct ip_conntrack_tuple_hash *h = NULL; + struct nf_conntrack_tuple otuple, rtuple; + struct nf_conntrack_tuple_hash *h = NULL; + struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); + u_int8_t u3 = nfmsg->nfgen_family; int err = 0; DEBUGP("entered %s\n", __FUNCTION__); @@ -1073,25 +1091,25 @@ ctnetlink_new_conntrack(struct sock *ctn return -EINVAL; if (cda[CTA_TUPLE_ORIG-1]) { - err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG); + err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG, u3); if (err < 0) return err; } if (cda[CTA_TUPLE_REPLY-1]) { - err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY); + err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY, u3); if (err < 0) return err; } - write_lock_bh(&ip_conntrack_lock); + write_lock_bh(&nf_conntrack_lock); if (cda[CTA_TUPLE_ORIG-1]) - h = __ip_conntrack_find(&otuple, NULL); + h = __nf_conntrack_find(&otuple, NULL); else if (cda[CTA_TUPLE_REPLY-1]) - h = __ip_conntrack_find(&rtuple, NULL); + h = __nf_conntrack_find(&rtuple, NULL); if (h == NULL) { - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); DEBUGP("no such conntrack, create new\n"); err = -ENOENT; if (nlh->nlmsg_flags & NLM_F_CREATE) @@ -1111,10 +1129,10 @@ ctnetlink_new_conntrack(struct sock *ctn DEBUGP("conntrack found\n"); err = -EEXIST; if (!(nlh->nlmsg_flags & NLM_F_EXCL)) - err = ctnetlink_change_conntrack(tuplehash_to_ctrack(h), cda); + err = ctnetlink_change_conntrack(nf_ct_tuplehash_to_ctrack(h), cda); out_unlock: - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); return err; } @@ -1124,7 +1142,7 @@ out_unlock: static inline int ctnetlink_exp_dump_tuple(struct sk_buff *skb, - const struct ip_conntrack_tuple *tuple, + const struct nf_conntrack_tuple *tuple, enum ctattr_expect type) { struct nfattr *nest_parms = NFA_NEST(skb, type); @@ -1142,9 +1160,9 @@ nfattr_failure: static inline int ctnetlink_exp_dump_expect(struct sk_buff *skb, - const struct ip_conntrack_expect *exp) + const struct nf_conntrack_expect *exp) { - struct ip_conntrack *master = exp->master; + struct nf_conn *master = exp->master; u_int32_t timeout = htonl((exp->timeout.expires - jiffies) / HZ); u_int32_t id = htonl(exp->id); @@ -1170,7 +1188,7 @@ static int ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event, int nowait, - const struct ip_conntrack_expect *exp) + const struct nf_conntrack_expect *exp) { struct nlmsghdr *nlh; struct nfgenmsg *nfmsg; @@ -1199,13 +1217,13 @@ nfattr_failure: return -1; } -#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS +#ifdef CONFIG_NF_CONNTRACK_EVENTS static int ctnetlink_expect_event(struct notifier_block *this, unsigned long events, void *ptr) { struct nlmsghdr *nlh; struct nfgenmsg *nfmsg; - struct ip_conntrack_expect *exp = (struct ip_conntrack_expect *)ptr; + struct nf_conntrack_expect *exp = (struct nf_conntrack_expect *)ptr; struct sk_buff *skb; unsigned int type; unsigned char *b; @@ -1251,15 +1269,15 @@ nfattr_failure: static int ctnetlink_exp_dump_table(struct sk_buff *skb, struct netlink_callback *cb) { - struct ip_conntrack_expect *exp = NULL; + struct nf_conntrack_expect *exp = NULL; struct list_head *i; u_int32_t *id = (u_int32_t *) &cb->args[0]; DEBUGP("entered %s, last id=%llu\n", __FUNCTION__, *id); - read_lock_bh(&ip_conntrack_lock); - list_for_each_prev(i, &ip_conntrack_expect_list) { - exp = (struct ip_conntrack_expect *) i; + read_lock_bh(&nf_conntrack_lock); + list_for_each_prev(i, &nf_conntrack_expect_list) { + exp = (struct nf_conntrack_expect *) i; if (exp->id <= *id) continue; if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid, @@ -1270,7 +1288,7 @@ ctnetlink_exp_dump_table(struct sk_buff *id = exp->id; } out: - read_unlock_bh(&ip_conntrack_lock); + read_unlock_bh(&nf_conntrack_lock); DEBUGP("leaving, last id=%llu\n", *id); @@ -1286,9 +1304,11 @@ static int ctnetlink_get_expect(struct sock *ctnl, struct sk_buff *skb, struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) { - struct ip_conntrack_tuple tuple; - struct ip_conntrack_expect *exp; + struct nf_conntrack_tuple tuple; + struct nf_conntrack_expect *exp; struct sk_buff *skb2; + struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); + u_int8_t u3 = nfmsg->nfgen_family; int err = 0; DEBUGP("entered %s\n", __FUNCTION__); @@ -1297,10 +1317,9 @@ ctnetlink_get_expect(struct sock *ctnl, return -EINVAL; if (nlh->nlmsg_flags & NLM_F_DUMP) { - struct nfgenmsg *msg = NLMSG_DATA(nlh); u32 rlen; - if (msg->nfgen_family != AF_INET) + if (nfmsg->nfgen_family != AF_INET) return -EAFNOSUPPORT; if ((*errp = netlink_dump_start(ctnl, skb, nlh, @@ -1315,21 +1334,21 @@ ctnetlink_get_expect(struct sock *ctnl, } if (cda[CTA_EXPECT_MASTER-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER, u3); else return -EINVAL; if (err < 0) return err; - exp = ip_conntrack_expect_find(&tuple); + exp = nf_conntrack_expect_find(&tuple); if (!exp) return -ENOENT; if (cda[CTA_EXPECT_ID-1]) { u_int32_t id = *(u_int32_t *)NFA_DATA(cda[CTA_EXPECT_ID-1]); if (exp->id != ntohl(id)) { - ip_conntrack_expect_put(exp); + nf_conntrack_expect_put(exp); return -ENOENT; } } @@ -1346,14 +1365,14 @@ ctnetlink_get_expect(struct sock *ctnl, if (err <= 0) goto free; - ip_conntrack_expect_put(exp); + nf_conntrack_expect_put(exp); return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT); free: kfree_skb(skb2); out: - ip_conntrack_expect_put(exp); + nf_conntrack_expect_put(exp); return err; } @@ -1361,9 +1380,11 @@ static int ctnetlink_del_expect(struct sock *ctnl, struct sk_buff *skb, struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) { - struct ip_conntrack_expect *exp, *tmp; - struct ip_conntrack_tuple tuple; - struct ip_conntrack_helper *h; + struct nf_conntrack_expect *exp, *tmp; + struct nf_conntrack_tuple tuple; + struct nf_conntrack_helper *h; + struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); + u_int8_t u3 = nfmsg->nfgen_family; int err; if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp)) @@ -1371,12 +1392,12 @@ ctnetlink_del_expect(struct sock *ctnl, if (cda[CTA_EXPECT_TUPLE-1]) { /* delete a single expect by tuple */ - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3); if (err < 0) return err; /* bump usage count to 2 */ - exp = ip_conntrack_expect_find(&tuple); + exp = nf_conntrack_expect_find(&tuple); if (!exp) return -ENOENT; @@ -1384,83 +1405,83 @@ ctnetlink_del_expect(struct sock *ctnl, u_int32_t id = *(u_int32_t *)NFA_DATA(cda[CTA_EXPECT_ID-1]); if (exp->id != ntohl(id)) { - ip_conntrack_expect_put(exp); + nf_conntrack_expect_put(exp); return -ENOENT; } } /* after list removal, usage count == 1 */ - ip_conntrack_unexpect_related(exp); + nf_conntrack_unexpect_related(exp); /* have to put what we 'get' above. * after this line usage count == 0 */ - ip_conntrack_expect_put(exp); + nf_conntrack_expect_put(exp); } else if (cda[CTA_EXPECT_HELP_NAME-1]) { char *name = NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]); /* delete all expectations for this helper */ - write_lock_bh(&ip_conntrack_lock); - h = __ip_conntrack_helper_find_byname(name); + write_lock_bh(&nf_conntrack_lock); + h = __nf_conntrack_helper_find_byname(name); if (!h) { - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); return -EINVAL; } - list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list, + list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list, list) { if (exp->master->helper == h && del_timer(&exp->timeout)) { - ip_ct_unlink_expect(exp); - ip_conntrack_expect_put(exp); + nf_ct_unlink_expect(exp); + nf_conntrack_expect_put(exp); } } - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); } else { /* This basically means we have to flush everything*/ - write_lock_bh(&ip_conntrack_lock); - list_for_each_entry_safe(exp, tmp, &ip_conntrack_expect_list, + write_lock_bh(&nf_conntrack_lock); + list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list, list) { if (del_timer(&exp->timeout)) { - ip_ct_unlink_expect(exp); - ip_conntrack_expect_put(exp); + nf_ct_unlink_expect(exp); + nf_conntrack_expect_put(exp); } } - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); } return 0; } static int -ctnetlink_change_expect(struct ip_conntrack_expect *x, struct nfattr *cda[]) +ctnetlink_change_expect(struct nf_conntrack_expect *x, struct nfattr *cda[]) { return -EOPNOTSUPP; } static int -ctnetlink_create_expect(struct nfattr *cda[]) +ctnetlink_create_expect(struct nfattr *cda[], u_int8_t u3) { - struct ip_conntrack_tuple tuple, mask, master_tuple; - struct ip_conntrack_tuple_hash *h = NULL; - struct ip_conntrack_expect *exp; - struct ip_conntrack *ct; + struct nf_conntrack_tuple tuple, mask, master_tuple; + struct nf_conntrack_tuple_hash *h = NULL; + struct nf_conntrack_expect *exp; + struct nf_conn *ct; int err = 0; DEBUGP("entered %s\n", __FUNCTION__); /* caller guarantees that those three CTA_EXPECT_* exist */ - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3); if (err < 0) return err; - err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK); + err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK, u3); if (err < 0) return err; - err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER); + err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER, u3); if (err < 0) return err; /* Look for master conntrack of this expectation */ - h = ip_conntrack_find_get(&master_tuple, NULL); + h = nf_conntrack_find_get(&master_tuple, NULL); if (!h) return -ENOENT; - ct = tuplehash_to_ctrack(h); + ct = nf_ct_tuplehash_to_ctrack(h); if (!ct->helper) { /* such conntrack hasn't got any helper, abort */ @@ -1468,7 +1489,7 @@ ctnetlink_create_expect(struct nfattr *c goto out; } - exp = ip_conntrack_expect_alloc(ct); + exp = nf_conntrack_expect_alloc(ct); if (!exp) { err = -ENOMEM; goto out; @@ -1477,14 +1498,14 @@ ctnetlink_create_expect(struct nfattr *c exp->expectfn = NULL; exp->flags = 0; exp->master = ct; - memcpy(&exp->tuple, &tuple, sizeof(struct ip_conntrack_tuple)); - memcpy(&exp->mask, &mask, sizeof(struct ip_conntrack_tuple)); + memcpy(&exp->tuple, &tuple, sizeof(struct nf_conntrack_tuple)); + memcpy(&exp->mask, &mask, sizeof(struct nf_conntrack_tuple)); - err = ip_conntrack_expect_related(exp); - ip_conntrack_expect_put(exp); + err = nf_conntrack_expect_related(exp); + nf_conntrack_expect_put(exp); out: - ip_conntrack_put(tuplehash_to_ctrack(h)); + nf_ct_put(nf_ct_tuplehash_to_ctrack(h)); return err; } @@ -1492,8 +1513,10 @@ static int ctnetlink_new_expect(struct sock *ctnl, struct sk_buff *skb, struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) { - struct ip_conntrack_tuple tuple; - struct ip_conntrack_expect *exp; + struct nf_conntrack_tuple tuple; + struct nf_conntrack_expect *exp; + struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); + u_int8_t u3 = nfmsg->nfgen_family; int err = 0; DEBUGP("entered %s\n", __FUNCTION__); @@ -1506,32 +1529,32 @@ ctnetlink_new_expect(struct sock *ctnl, || !cda[CTA_EXPECT_MASTER-1]) return -EINVAL; - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE); + err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3); if (err < 0) return err; - write_lock_bh(&ip_conntrack_lock); - exp = __ip_conntrack_expect_find(&tuple); + write_lock_bh(&nf_conntrack_lock); + exp = __nf_conntrack_expect_find(&tuple); if (!exp) { - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); err = -ENOENT; if (nlh->nlmsg_flags & NLM_F_CREATE) - err = ctnetlink_create_expect(cda); + err = ctnetlink_create_expect(cda, u3); return err; } err = -EEXIST; if (!(nlh->nlmsg_flags & NLM_F_EXCL)) err = ctnetlink_change_expect(exp, cda); - write_unlock_bh(&ip_conntrack_lock); + write_unlock_bh(&nf_conntrack_lock); DEBUGP("leaving\n"); return err; } -#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS +#ifdef CONFIG_NF_CONNTRACK_EVENTS static struct notifier_block ctnl_notifier = { .notifier_call = ctnetlink_conntrack_event, }; @@ -1594,14 +1617,14 @@ static int __init ctnetlink_init(void) goto err_unreg_subsys; } -#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS - ret = ip_conntrack_register_notifier(&ctnl_notifier); +#ifdef CONFIG_NF_CONNTRACK_EVENTS + ret = nf_conntrack_register_notifier(&ctnl_notifier); if (ret < 0) { printk("ctnetlink_init: cannot register notifier.\n"); goto err_unreg_exp_subsys; } - ret = ip_conntrack_expect_register_notifier(&ctnl_notifier_exp); + ret = nf_conntrack_expect_register_notifier(&ctnl_notifier_exp); if (ret < 0) { printk("ctnetlink_init: cannot expect register notifier.\n"); goto err_unreg_notifier; @@ -1610,9 +1633,9 @@ static int __init ctnetlink_init(void) return 0; -#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS +#ifdef CONFIG_NF_CONNTRACK_EVENTS err_unreg_notifier: - ip_conntrack_unregister_notifier(&ctnl_notifier); + nf_conntrack_unregister_notifier(&ctnl_notifier); err_unreg_exp_subsys: nfnetlink_subsys_unregister(&ctnl_exp_subsys); #endif @@ -1626,9 +1649,9 @@ static void __exit ctnetlink_exit(void) { printk("ctnetlink: unregistering from nfnetlink.\n"); -#ifdef CONFIG_IP_NF_CONNTRACK_EVENTS - ip_conntrack_unregister_notifier(&ctnl_notifier_exp); - ip_conntrack_unregister_notifier(&ctnl_notifier); +#ifdef CONFIG_NF_CONNTRACK_EVENTS + nf_conntrack_unregister_notifier(&ctnl_notifier_exp); + nf_conntrack_unregister_notifier(&ctnl_notifier); #endif nfnetlink_subsys_unregister(&ctnl_exp_subsys);