Piteball
/
android_kernel_samsung_msm8976
mirror of https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git
1
1
Fork 0
Code Issues Projects Releases Wiki Activity

[NETFILTER]: x_tables: make use of mass registation helpers 

Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Patrick McHardy 2006-08-22 00:34:04 -07:00 committed by David S. Miller
parent 52d9c42ef2
commit 4470bbc749
32 changed files with 679 additions and 1007 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
net/ipv6/netfilter/ip6t_REJECT.c
View File

@ -257,9 +257,7 @@ static struct ip6t_target ip6t_reject_reg = {
static int __init ip6t_reject_init(void)
{
if (ip6t_register_target(&ip6t_reject_reg))
return -EINVAL;
return 0;
return ip6t_register_target(&ip6t_reject_reg);
}
static void __exit ip6t_reject_fini(void)

60
net/netfilter/xt_CLASSIFY.c
View File

@ -40,47 +40,41 @@ target(struct sk_buff **pskb,
return XT_CONTINUE;
}
static struct xt_target classify_reg = {
.name = "CLASSIFY",
.target = target,
.targetsize = sizeof(struct xt_classify_target_info),
.table = "mangle",
.hooks = (1 << NF_IP_LOCAL_OUT) | (1 << NF_IP_FORWARD) |
(1 << NF_IP_POST_ROUTING),
.family = AF_INET,
.me = THIS_MODULE,
static struct xt_target xt_classify_target[] = {
{
.family = AF_INET,
.name = "CLASSIFY",
.target = target,
.targetsize = sizeof(struct xt_classify_target_info),
.table = "mangle",
.hooks = (1 << NF_IP_LOCAL_OUT) |
(1 << NF_IP_FORWARD) |
(1 << NF_IP_POST_ROUTING),
.me = THIS_MODULE,
},
{
.name = "CLASSIFY",
.family = AF_INET6,
.target = target,
.targetsize = sizeof(struct xt_classify_target_info),
.table = "mangle",
.hooks = (1 << NF_IP_LOCAL_OUT) |
(1 << NF_IP_FORWARD) |
(1 << NF_IP_POST_ROUTING),
.me = THIS_MODULE,
},
};
static struct xt_target classify6_reg = {
.name = "CLASSIFY",
.target = target,
.targetsize = sizeof(struct xt_classify_target_info),
.table = "mangle",
.hooks = (1 << NF_IP_LOCAL_OUT) | (1 << NF_IP_FORWARD) |
(1 << NF_IP_POST_ROUTING),
.family = AF_INET6,
.me = THIS_MODULE,
};
static int __init xt_classify_init(void)
{
int ret;
ret = xt_register_target(&classify_reg);
if (ret)
return ret;
ret = xt_register_target(&classify6_reg);
if (ret)
xt_unregister_target(&classify_reg);
return ret;
return xt_register_targets(xt_classify_target,
ARRAY_SIZE(xt_classify_target));
}
static void __exit xt_classify_fini(void)
{
xt_unregister_target(&classify_reg);
xt_unregister_target(&classify6_reg);
xt_unregister_targets(xt_classify_target,
ARRAY_SIZE(xt_classify_target));
}
module_init(xt_classify_init);

51
net/netfilter/xt_CONNMARK.c
View File

@ -110,45 +110,36 @@ checkentry(const char *tablename,
return 1;
}
static struct xt_target connmark_reg = {
.name = "CONNMARK",
.target = target,
.targetsize = sizeof(struct xt_connmark_target_info),
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE
};
static struct xt_target connmark6_reg = {
.name = "CONNMARK",
.target = target,
.targetsize = sizeof(struct xt_connmark_target_info),
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE
static struct xt_target xt_connmark_target[] = {
{
.name = "CONNMARK",
.family = AF_INET,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_connmark_target_info),
.me = THIS_MODULE
},
{
.name = "CONNMARK",
.family = AF_INET6,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_connmark_target_info),
.me = THIS_MODULE
},
};
static int __init xt_connmark_init(void)
{
int ret;
need_conntrack();
ret = xt_register_target(&connmark_reg);
if (ret)
return ret;
ret = xt_register_target(&connmark6_reg);
if (ret)
xt_unregister_target(&connmark_reg);
return ret;
return xt_register_targets(xt_connmark_target,
ARRAY_SIZE(xt_connmark_target));
}
static void __exit xt_connmark_fini(void)
{
xt_unregister_target(&connmark_reg);
xt_unregister_target(&connmark6_reg);
xt_unregister_targets(xt_connmark_target,
ARRAY_SIZE(xt_connmark_target));
}
module_init(xt_connmark_init);

57
net/netfilter/xt_CONNSECMARK.c
View File

@ -106,49 +106,38 @@ static int checkentry(const char *tablename, const void *entry,
return 1;
}
static struct xt_target ipt_connsecmark_reg = {
.name = "CONNSECMARK",
.target = target,
.targetsize = sizeof(struct xt_connsecmark_target_info),
.table = "mangle",
.checkentry = checkentry,
.me = THIS_MODULE,
.family = AF_INET,
.revision = 0,
};
static struct xt_target ip6t_connsecmark_reg = {
.name = "CONNSECMARK",
.target = target,
.targetsize = sizeof(struct xt_connsecmark_target_info),
.table = "mangle",
.checkentry = checkentry,
.me = THIS_MODULE,
.family = AF_INET6,
.revision = 0,
static struct xt_target xt_connsecmark_target[] = {
{
.name = "CONNSECMARK",
.family = AF_INET,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_connsecmark_target_info),
.table = "mangle",
.me = THIS_MODULE,
},
{
.name = "CONNSECMARK",
.family = AF_INET6,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_connsecmark_target_info),
.table = "mangle",
.me = THIS_MODULE,
},
};
static int __init xt_connsecmark_init(void)
{
int err;
need_conntrack();
err = xt_register_target(&ipt_connsecmark_reg);
if (err)
return err;
err = xt_register_target(&ip6t_connsecmark_reg);
if (err)
xt_unregister_target(&ipt_connsecmark_reg);
return err;
return xt_register_targets(xt_connsecmark_targets,
ARRAY_SIZE(xt_connsecmark_targets));
}
static void __exit xt_connsecmark_fini(void)
{
xt_unregister_target(&ip6t_connsecmark_reg);
xt_unregister_target(&ipt_connsecmark_reg);
xt_unregister_targets(xt_connsecmark_targets,
ARRAY_SIZE(xt_connsecmark_targets));
}
module_init(xt_connsecmark_init);

51
net/netfilter/xt_DSCP.c
View File

@ -86,44 +86,35 @@ static int checkentry(const char *tablename,
return 1;
}
static struct xt_target xt_dscp_reg = {
.name = "DSCP",
.target = target,
.targetsize = sizeof(struct xt_DSCP_info),
.table = "mangle",
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_target xt_dscp6_reg = {
.name = "DSCP",
.target = target6,
.targetsize = sizeof(struct xt_DSCP_info),
.table = "mangle",
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_target xt_dscp_target[] = {
{
.name = "DSCP",
.family = AF_INET,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_DSCP_info),
.table = "mangle",
.me = THIS_MODULE,
},
{
.name = "DSCP",
.family = AF_INET6,
.checkentry = checkentry,
.target = target6,
.targetsize = sizeof(struct xt_DSCP_info),
.table = "mangle",
.me = THIS_MODULE,
},
};
static int __init xt_dscp_target_init(void)
{
int ret;
ret = xt_register_target(&xt_dscp_reg);
if (ret)
return ret;
ret = xt_register_target(&xt_dscp6_reg);
if (ret)
xt_unregister_target(&xt_dscp_reg);
return ret;
return xt_register_targets(xt_dscp_target, ARRAY_SIZE(xt_dscp_target));
}
static void __exit xt_dscp_target_fini(void)
{
xt_unregister_target(&xt_dscp_reg);
xt_unregister_target(&xt_dscp6_reg);
xt_unregister_targets(xt_dscp_target, ARRAY_SIZE(xt_dscp_target));
}
module_init(xt_dscp_target_init);

84
net/netfilter/xt_MARK.c
View File

@ -112,65 +112,47 @@ checkentry_v1(const char *tablename,
return 1;
}
static struct xt_target ipt_mark_reg_v0 = {
.name = "MARK",
.target = target_v0,
.targetsize = sizeof(struct xt_mark_target_info),
.table = "mangle",
.checkentry = checkentry_v0,
.me = THIS_MODULE,
.family = AF_INET,
.revision = 0,
};
static struct xt_target ipt_mark_reg_v1 = {
.name = "MARK",
.target = target_v1,
.targetsize = sizeof(struct xt_mark_target_info_v1),
.table = "mangle",
.checkentry = checkentry_v1,
.me = THIS_MODULE,
.family = AF_INET,
.revision = 1,
};
static struct xt_target ip6t_mark_reg_v0 = {
.name = "MARK",
.target = target_v0,
.targetsize = sizeof(struct xt_mark_target_info),
.table = "mangle",
.checkentry = checkentry_v0,
.me = THIS_MODULE,
.family = AF_INET6,
.revision = 0,
static struct xt_target xt_mark_target[] = {
{
.name = "MARK",
.family = AF_INET,
.revision = 0,
.checkentry = checkentry_v0,
.target = target_v0,
.targetsize = sizeof(struct xt_mark_target_info),
.table = "mangle",
.me = THIS_MODULE,
},
{
.name = "MARK",
.family = AF_INET,
.revision = 1,
.checkentry = checkentry_v1,
.target = target_v1,
.targetsize = sizeof(struct xt_mark_target_info_v1),
.table = "mangle",
.me = THIS_MODULE,
},
{
.name = "MARK",
.family = AF_INET6,
.revision = 0,
.checkentry = checkentry_v0,
.target = target_v0,
.targetsize = sizeof(struct xt_mark_target_info),
.table = "mangle",
.me = THIS_MODULE,
},
};
static int __init xt_mark_init(void)
{
int err;
err = xt_register_target(&ipt_mark_reg_v0);
if (err)
return err;
err = xt_register_target(&ipt_mark_reg_v1);
if (err)
xt_unregister_target(&ipt_mark_reg_v0);
err = xt_register_target(&ip6t_mark_reg_v0);
if (err) {
xt_unregister_target(&ipt_mark_reg_v0);
xt_unregister_target(&ipt_mark_reg_v1);
}
return err;
return xt_register_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
}
static void __exit xt_mark_fini(void)
{
xt_unregister_target(&ipt_mark_reg_v0);
xt_unregister_target(&ipt_mark_reg_v1);
xt_unregister_target(&ip6t_mark_reg_v0);
xt_unregister_targets(xt_mark_target, ARRAY_SIZE(xt_mark_target));
}
module_init(xt_mark_init);

68
net/netfilter/xt_NFQUEUE.c
View File

@ -37,57 +37,39 @@ target(struct sk_buff **pskb,
return NF_QUEUE_NR(tinfo->queuenum);
}
static struct xt_target ipt_NFQ_reg = {
.name = "NFQUEUE",
.target = target,
.targetsize = sizeof(struct xt_NFQ_info),
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_target ip6t_NFQ_reg = {
.name = "NFQUEUE",
.target = target,
.targetsize = sizeof(struct xt_NFQ_info),
.family = AF_INET6,
.me = THIS_MODULE,
};
static struct xt_target arpt_NFQ_reg = {
.name = "NFQUEUE",
.target = target,
.targetsize = sizeof(struct xt_NFQ_info),
.family = NF_ARP,
.me = THIS_MODULE,
static struct xt_target xt_nfqueue_target[] = {
{
.name = "NFQUEUE",
.family = AF_INET,
.target = target,
.targetsize = sizeof(struct xt_NFQ_info),
.me = THIS_MODULE,
},
{
.name = "NFQUEUE",
.family = AF_INET6,
.target = target,
.targetsize = sizeof(struct xt_NFQ_info),
.me = THIS_MODULE,
},
{
.name = "NFQUEUE",
.family = NF_ARP,
.target = target,
.targetsize = sizeof(struct xt_NFQ_info),
.me = THIS_MODULE,
},
};
static int __init xt_nfqueue_init(void)
{
int ret;
ret = xt_register_target(&ipt_NFQ_reg);
if (ret)
return ret;
ret = xt_register_target(&ip6t_NFQ_reg);
if (ret)
goto out_ip;
ret = xt_register_target(&arpt_NFQ_reg);
if (ret)
goto out_ip6;
return ret;
out_ip6:
xt_unregister_target(&ip6t_NFQ_reg);
out_ip:
xt_unregister_target(&ipt_NFQ_reg);
return ret;
return xt_register_targets(xt_nfqueue_target,
ARRAY_SIZE(xt_nfqueue_target));
}
static void __exit xt_nfqueue_fini(void)
{
xt_unregister_target(&arpt_NFQ_reg);
xt_unregister_target(&ip6t_NFQ_reg);
xt_unregister_target(&ipt_NFQ_reg);
xt_register_targets(xt_nfqueue_target, ARRAY_SIZE(xt_nfqueue_target));
}
module_init(xt_nfqueue_init);

47
net/netfilter/xt_NOTRACK.c
View File

@ -34,43 +34,32 @@ target(struct sk_buff **pskb,
return XT_CONTINUE;
}
static struct xt_target notrack_reg = {
.name = "NOTRACK",
.target = target,
.targetsize = 0,
.table = "raw",
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_target notrack6_reg = {
.name = "NOTRACK",
.target = target,
.targetsize = 0,
.table = "raw",
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_target xt_notrack_target[] = {
{
.name = "NOTRACK",
.family = AF_INET,
.target = target,
.table = "raw",
.me = THIS_MODULE,
},
{
.name = "NOTRACK",
.family = AF_INET6,
.target = target,
.table = "raw",
.me = THIS_MODULE,
},
};
static int __init xt_notrack_init(void)
{
int ret;
ret = xt_register_target(&notrack_reg);
if (ret)
return ret;
ret = xt_register_target(&notrack6_reg);
if (ret)
xt_unregister_target(&notrack_reg);
return ret;
return xt_register_targets(xt_notrack_target,
ARRAY_SIZE(xt_notrack_target));
}
static void __exit xt_notrack_fini(void)
{
xt_unregister_target(&notrack6_reg);
xt_unregister_target(&notrack_reg);
xt_unregister_targets(xt_notrack_target, ARRAY_SIZE(xt_notrack_target));
}
module_init(xt_notrack_init);

55
net/netfilter/xt_SECMARK.c
View File

@ -111,47 +111,36 @@ static int checkentry(const char *tablename, const void *entry,
return 1;
}
static struct xt_target ipt_secmark_reg = {
.name = "SECMARK",
.target = target,
.targetsize = sizeof(struct xt_secmark_target_info),
.table = "mangle",
.checkentry = checkentry,
.me = THIS_MODULE,
.family = AF_INET,
.revision = 0,
};
static struct xt_target ip6t_secmark_reg = {
.name = "SECMARK",
.target = target,
.targetsize = sizeof(struct xt_secmark_target_info),
.table = "mangle",
.checkentry = checkentry,
.me = THIS_MODULE,
.family = AF_INET6,
.revision = 0,
static struct xt_target xt_secmark_target = {
{
.name = "SECMARK",
.family = AF_INET,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_secmark_target_info),
.table = "mangle",
.me = THIS_MODULE,
},
{
.name = "SECMARK",
.family = AF_INET6,
.checkentry = checkentry,
.target = target,
.targetsize = sizeof(struct xt_secmark_target_info),
.table = "mangle",
.me = THIS_MODULE,
},
};
static int __init xt_secmark_init(void)
{
int err;
err = xt_register_target(&ipt_secmark_reg);
if (err)
return err;
err = xt_register_target(&ip6t_secmark_reg);
if (err)
xt_unregister_target(&ipt_secmark_reg);
return err;
return xt_register_targets(xt_secmark_target,
ARRAY_SIZE(xt_secmark_target));
}
static void __exit xt_secmark_fini(void)
{
xt_unregister_target(&ip6t_secmark_reg);
xt_unregister_target(&ipt_secmark_reg);
xt_unregister_targets(xt_secmark_target, ARRAY_SIZE(xt_secmark_target));
}
module_init(xt_secmark_init);

45
net/netfilter/xt_comment.c
View File

@ -29,41 +29,32 @@ match(const struct sk_buff *skb,
return 1;
}
static struct xt_match comment_match = {
.name = "comment",
.match = match,
.matchsize = sizeof(struct xt_comment_info),
.family = AF_INET,
.me = THIS_MODULE
};
static struct xt_match comment6_match = {
.name = "comment",
.match = match,
.matchsize = sizeof(struct xt_comment_info),
.family = AF_INET6,
.me = THIS_MODULE
static struct xt_match xt_comment_match[] = {
{
.name = "comment",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_comment_info),
.me = THIS_MODULE
},
{
.name = "comment",
.family = AF_INET6,
.match = match,
.matchsize = sizeof(struct xt_comment_info),
.me = THIS_MODULE
},
};
static int __init xt_comment_init(void)
{
int ret;
ret = xt_register_match(&comment_match);
if (ret)
return ret;
ret = xt_register_match(&comment6_match);
if (ret)
xt_unregister_match(&comment_match);
return ret;
return xt_register_matches(xt_comment_match,
ARRAY_SIZE(xt_comment_match));
}
static void __exit xt_comment_fini(void)
{
xt_unregister_match(&comment_match);
xt_unregister_match(&comment6_match);
xt_unregister_matches(xt_comment_match, ARRAY_SIZE(xt_comment_match));
}
module_init(xt_comment_init);

47
net/netfilter/xt_connbytes.c
View File

@ -143,40 +143,35 @@ static int check(const char *tablename,
return 1;
}
static struct xt_match connbytes_match = {
.name = "connbytes",
.match = match,
.checkentry = check,
.matchsize = sizeof(struct xt_connbytes_info),
.family = AF_INET,
.me = THIS_MODULE
};
static struct xt_match connbytes6_match = {
.name = "connbytes",
.match = match,
.checkentry = check,
.matchsize = sizeof(struct xt_connbytes_info),
.family = AF_INET6,
.me = THIS_MODULE
static struct xt_match xt_connbytes_match = {
{
.name = "connbytes",
.family = AF_INET,
.checkentry = check,
.match = match,
.matchsize = sizeof(struct xt_connbytes_info),
.me = THIS_MODULE
},
{
.name = "connbytes",
.family = AF_INET6,
.checkentry = check,
.match = match,
.matchsize = sizeof(struct xt_connbytes_info),
.me = THIS_MODULE
},
};
static int __init xt_connbytes_init(void)
{
int ret;
ret = xt_register_match(&connbytes_match);
if (ret)
return ret;
ret = xt_register_match(&connbytes6_match);
if (ret)
xt_unregister_match(&connbytes_match);
return ret;
return xt_register_matches(xt_connbytes_match,
ARRAY_SIZE(xt_connbytes_match));
}
static void __exit xt_connbytes_fini(void)
{
xt_unregister_match(&connbytes_match);
xt_unregister_match(&connbytes6_match);
xt_unregister_matches(xt_connbytes_match,
ARRAY_SIZE(xt_connbytes_match));
}
module_init(xt_connbytes_init);

53
net/netfilter/xt_connmark.c
View File

@ -82,46 +82,37 @@ destroy(const struct xt_match *match, void *matchinfo, unsigned int matchsize)
#endif
}
static struct xt_match connmark_match = {
.name = "connmark",
.match = match,
.matchsize = sizeof(struct xt_connmark_info),
.checkentry = checkentry,
.destroy = destroy,
.family = AF_INET,
.me = THIS_MODULE
};
static struct xt_match connmark6_match = {
.name = "connmark",
.match = match,
.matchsize = sizeof(struct xt_connmark_info),
.checkentry = checkentry,
.destroy = destroy,
.family = AF_INET6,
.me = THIS_MODULE
static struct xt_match xt_connmark_match[] = {
{
.name = "connmark",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_connmark_info),
.me = THIS_MODULE
},
{
.name = "connmark",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_connmark_info),
.me = THIS_MODULE
},
};
static int __init xt_connmark_init(void)
{
int ret;
need_conntrack();
ret = xt_register_match(&connmark_match);
if (ret)
return ret;
ret = xt_register_match(&connmark6_match);
if (ret)
xt_unregister_match(&connmark_match);
return ret;
return xt_register_matches(xt_connmark_match,
ARRAY_SIZE(xt_connmark_match));
}
static void __exit xt_connmark_fini(void)
{
xt_unregister_match(&connmark6_match);
xt_unregister_match(&connmark_match);
xt_register_matches(xt_connmark_match, ARRAY_SIZE(xt_connmark_match));
}
module_init(xt_connmark_init);

5
net/netfilter/xt_conntrack.c
View File

@ -241,11 +241,8 @@ static struct xt_match conntrack_match = {
static int __init xt_conntrack_init(void)
{
int ret;
need_conntrack();
ret = xt_register_match(&conntrack_match);
return ret;
return xt_register_match(&conntrack_match);
}
static void __exit xt_conntrack_fini(void)

51
net/netfilter/xt_dccp.c
View File

@ -141,27 +141,26 @@ checkentry(const char *tablename,
&& !(info->invflags & ~info->flags);
}
static struct xt_match dccp_match =
{
.name = "dccp",
.match = match,
.matchsize = sizeof(struct xt_dccp_info),
.proto = IPPROTO_DCCP,
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE,
static struct xt_match xt_dccp_match[] = {
{
.name = "dccp",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_dccp_info),
.proto = IPPROTO_DCCP,
.me = THIS_MODULE,
},
{
.name = "dccp",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_dccp_info),
.proto = IPPROTO_DCCP,
.me = THIS_MODULE,
},
};
static struct xt_match dccp6_match =
{
.name = "dccp",
.match = match,
.matchsize = sizeof(struct xt_dccp_info),
.proto = IPPROTO_DCCP,
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
};
static int __init xt_dccp_init(void)
{
@ -173,27 +172,19 @@ static int __init xt_dccp_init(void)
dccp_optbuf = kmalloc(256 * 4, GFP_KERNEL);
if (!dccp_optbuf)
return -ENOMEM;
ret = xt_register_match(&dccp_match);
ret = xt_register_matches(xt_dccp_match, ARRAY_SIZE(xt_dccp_match));
if (ret)
goto out_kfree;
ret = xt_register_match(&dccp6_match);
if (ret)
goto out_unreg;
return ret;
out_unreg:
xt_unregister_match(&dccp_match);
out_kfree:
kfree(dccp_optbuf);
return ret;
}
static void __exit xt_dccp_fini(void)
{
xt_unregister_match(&dccp6_match);
xt_unregister_match(&dccp_match);
xt_unregister_matches(xt_dccp_match, ARRAY_SIZE(xt_dccp_match));
kfree(dccp_optbuf);
}

47
net/netfilter/xt_dscp.c
View File

@ -71,42 +71,33 @@ static int checkentry(const char *tablename,
return 1;
}
static struct xt_match dscp_match = {
.name = "dscp",
.match = match,
.checkentry = checkentry,
.matchsize = sizeof(struct xt_dscp_info),
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match dscp6_match = {
.name = "dscp",
.match = match6,
.checkentry = checkentry,
.matchsize = sizeof(struct xt_dscp_info),
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_dscp_match[] = {
{
.name = "dscp",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_dscp_info),
.me = THIS_MODULE,
},
{
.name = "dscp",
.family = AF_INET6,
.checkentry = checkentry,
.match = match6,
.matchsize = sizeof(struct xt_dscp_info),
.me = THIS_MODULE,
},
};
static int __init xt_dscp_match_init(void)
{
int ret;
ret = xt_register_match(&dscp_match);
if (ret)
return ret;
ret = xt_register_match(&dscp6_match);
if (ret)
xt_unregister_match(&dscp_match);
return ret;
return xt_register_matches(xt_dscp_match, ARRAY_SIZE(xt_dscp_match));
}
static void __exit xt_dscp_match_fini(void)
{
xt_unregister_match(&dscp_match);
xt_unregister_match(&dscp6_match);
xt_unregister_matches(xt_dscp_match, ARRAY_SIZE(xt_dscp_match));
}
module_init(xt_dscp_match_init);

51
net/netfilter/xt_esp.c
View File

@ -92,44 +92,35 @@ checkentry(const char *tablename,
return 1;
}
static struct xt_match esp_match = {
.name = "esp",
.family = AF_INET,
.proto = IPPROTO_ESP,
.match = &match,
.matchsize = sizeof(struct xt_esp),
.checkentry = &checkentry,
.me = THIS_MODULE,
};
static struct xt_match esp6_match = {
.name = "esp",
.family = AF_INET6,
.proto = IPPROTO_ESP,
.match = &match,
.matchsize = sizeof(struct xt_esp),
.checkentry = &checkentry,
.me = THIS_MODULE,
static struct xt_match xt_esp_match[] = {
{
.name = "esp",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_esp),
.proto = IPPROTO_ESP,
.me = THIS_MODULE,
},
{
.name = "esp",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_esp),
.proto = IPPROTO_ESP,
.me = THIS_MODULE,
},
};
static int __init xt_esp_init(void)
{
int ret;
ret = xt_register_match(&esp_match);
if (ret)
return ret;
ret = xt_register_match(&esp6_match);
if (ret)
xt_unregister_match(&esp_match);
return ret;
return xt_register_matches(xt_esp_match, ARRAY_SIZE(xt_esp_match));
}
static void __exit xt_esp_cleanup(void)
{
xt_unregister_match(&esp_match);
xt_unregister_match(&esp6_match);
xt_unregister_matches(xt_esp_match, ARRAY_SIZE(xt_esp_match));
}
module_init(xt_esp_init);

52
net/netfilter/xt_helper.c
View File

@ -163,45 +163,37 @@ destroy(const struct xt_match *match, void *matchinfo, unsigned int matchsize)
#endif
}
static struct xt_match helper_match = {
.name = "helper",
.match = match,
.matchsize = sizeof(struct xt_helper_info),
.checkentry = check,
.destroy = destroy,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match helper6_match = {
.name = "helper",
.match = match,
.matchsize = sizeof(struct xt_helper_info),
.checkentry = check,
.destroy = destroy,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_helper_match[] = {
{
.name = "helper",
.family = AF_INET,
.checkentry = check,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_helper_info),
.me = THIS_MODULE,
},
{
.name = "helper",
.family = AF_INET6,
.checkentry = check,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_helper_info),
.me = THIS_MODULE,
},
};
static int __init xt_helper_init(void)
{
int ret;
need_conntrack();
ret = xt_register_match(&helper_match);
if (ret < 0)
return ret;
ret = xt_register_match(&helper6_match);
if (ret < 0)
xt_unregister_match(&helper_match);
return ret;
return xt_register_matches(xt_helper_match,
ARRAY_SIZE(xt_helper_match));
}
static void __exit xt_helper_fini(void)
{
xt_unregister_match(&helper_match);
xt_unregister_match(&helper6_match);
xt_unregister_matches(xt_helper_match, ARRAY_SIZE(xt_helper_match));
}
module_init(xt_helper_init);

43
net/netfilter/xt_length.c
View File

@ -52,39 +52,32 @@ match6(const struct sk_buff *skb,
return (pktlen >= info->min && pktlen <= info->max) ^ info->invert;
}
static struct xt_match length_match = {
.name = "length",
.match = match,
.matchsize = sizeof(struct xt_length_info),
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match length6_match = {
.name = "length",
.match = match6,
.matchsize = sizeof(struct xt_length_info),
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_length_match[] = {
{
.name = "length",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_length_info),
.me = THIS_MODULE,
},
{
.name = "length",
.family = AF_INET6,
.match = match6,
.matchsize = sizeof(struct xt_length_info),
.me = THIS_MODULE,
},
};
static int __init xt_length_init(void)
{
int ret;
ret = xt_register_match(&length_match);
if (ret)
return ret;
ret = xt_register_match(&length6_match);
if (ret)
xt_unregister_match(&length_match);
return ret;
return xt_register_matches(xt_length_match,
ARRAY_SIZE(xt_length_match));
}
static void __exit xt_length_fini(void)
{
xt_unregister_match(&length_match);
xt_unregister_match(&length6_match);
xt_unregister_matches(xt_length_match, ARRAY_SIZE(xt_length_match));
}
module_init(xt_length_init);

47
net/netfilter/xt_limit.c
View File

@ -136,42 +136,33 @@ ipt_limit_checkentry(const char *tablename,
return 1;
}
static struct xt_match ipt_limit_reg = {
.name = "limit",
.match = ipt_limit_match,
.matchsize = sizeof(struct xt_rateinfo),
.checkentry = ipt_limit_checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match limit6_reg = {
.name = "limit",
.match = ipt_limit_match,
.matchsize = sizeof(struct xt_rateinfo),
.checkentry = ipt_limit_checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_limit_match[] = {
{
.name = "limit",
.family = AF_INET,
.checkentry = ipt_limit_checkentry,
.match = ipt_limit_match,
.matchsize = sizeof(struct xt_rateinfo),
.me = THIS_MODULE,
},
{
.name = "limit",
.family = AF_INET6,
.checkentry = ipt_limit_checkentry,
.match = ipt_limit_match,
.matchsize = sizeof(struct xt_rateinfo),
.me = THIS_MODULE,
},
};
static int __init xt_limit_init(void)
{
int ret;
ret = xt_register_match(&ipt_limit_reg);
if (ret)
return ret;
ret = xt_register_match(&limit6_reg);
if (ret)
xt_unregister_match(&ipt_limit_reg);
return ret;
return xt_register_matches(xt_limit_match, ARRAY_SIZE(xt_limit_match));
}
static void __exit xt_limit_fini(void)
{
xt_unregister_match(&ipt_limit_reg);
xt_unregister_match(&limit6_reg);
xt_unregister_matches(xt_limit_match, ARRAY_SIZE(xt_limit_match));
}
module_init(xt_limit_init);

52
net/netfilter/xt_mac.c
View File

@ -43,43 +43,37 @@ match(const struct sk_buff *skb,
^ info->invert));
}
static struct xt_match mac_match = {
.name = "mac",
.match = match,
.matchsize = sizeof(struct xt_mac_info),
.hooks = (1 << NF_IP_PRE_ROUTING) | (1 << NF_IP_LOCAL_IN) |
(1 << NF_IP_FORWARD),
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match mac6_match = {
.name = "mac",
.match = match,
.matchsize = sizeof(struct xt_mac_info),
.hooks = (1 << NF_IP_PRE_ROUTING) | (1 << NF_IP_LOCAL_IN) |
(1 << NF_IP_FORWARD),
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_mac_match[] = {
{
.name = "mac",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_mac_info),
.hooks = (1 << NF_IP_PRE_ROUTING) |
(1 << NF_IP_LOCAL_IN) |
(1 << NF_IP_FORWARD),
.me = THIS_MODULE,
},
{
.name = "mac",
.family = AF_INET6,
.match = match,
.matchsize = sizeof(struct xt_mac_info),
.hooks = (1 << NF_IP_PRE_ROUTING) |
(1 << NF_IP_LOCAL_IN) |
(1 << NF_IP_FORWARD),
.me = THIS_MODULE,
},
};
static int __init xt_mac_init(void)
{
int ret;
ret = xt_register_match(&mac_match);
if (ret)
return ret;
ret = xt_register_match(&mac6_match);
if (ret)
xt_unregister_match(&mac_match);
return ret;
return xt_register_matches(xt_mac_match, ARRAY_SIZE(xt_mac_match));
}
static void __exit xt_mac_fini(void)
{
xt_unregister_match(&mac_match);
xt_unregister_match(&mac6_match);
xt_unregister_matches(xt_mac_match, ARRAY_SIZE(xt_mac_match));
}
module_init(xt_mac_init);

47
net/netfilter/xt_mark.c
View File

@ -51,42 +51,33 @@ checkentry(const char *tablename,
return 1;
}
static struct xt_match mark_match = {
.name = "mark",
.match = match,
.matchsize = sizeof(struct xt_mark_info),
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match mark6_match = {
.name = "mark",
.match = match,
.matchsize = sizeof(struct xt_mark_info),
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_mark_match[] = {
{
.name = "mark",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_mark_info),
.me = THIS_MODULE,
},
{
.name = "mark",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_mark_info),
.me = THIS_MODULE,
},
};
static int __init xt_mark_init(void)
{
int ret;
ret = xt_register_match(&mark_match);
if (ret)
return ret;
ret = xt_register_match(&mark6_match);
if (ret)
xt_unregister_match(&mark_match);
return ret;
return xt_register_matches(xt_mark_match, ARRAY_SIZE(xt_mark_match));
}
static void __exit xt_mark_fini(void)
{
xt_unregister_match(&mark_match);
xt_unregister_match(&mark6_match);
xt_unregister_matches(xt_mark_match, ARRAY_SIZE(xt_mark_match));
}
module_init(xt_mark_init);

111
net/netfilter/xt_multiport.c
View File

@ -231,84 +231,55 @@ checkentry6_v1(const char *tablename,
multiinfo->count);
}
static struct xt_match multiport_match = {
.name = "multiport",
.revision = 0,
.matchsize = sizeof(struct xt_multiport),
.match = &match,
.checkentry = &checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match multiport_match_v1 = {
.name = "multiport",
.revision = 1,
.matchsize = sizeof(struct xt_multiport_v1),
.match = &match_v1,
.checkentry = &checkentry_v1,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match multiport6_match = {
.name = "multiport",
.revision = 0,
.matchsize = sizeof(struct xt_multiport),
.match = &match,
.checkentry = &checkentry6,
.family = AF_INET6,
.me = THIS_MODULE,
};
static struct xt_match multiport6_match_v1 = {
.name = "multiport",
.revision = 1,
.matchsize = sizeof(struct xt_multiport_v1),
.match = &match_v1,
.checkentry = &checkentry6_v1,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_multiport_match[] = {
{
.name = "multiport",
.family = AF_INET,
.revision = 0,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_multiport),
.me = THIS_MODULE,
},
{
.name = "multiport",
.family = AF_INET,
.revision = 1,
.checkentry = checkentry_v1,
.match = match_v1,
.matchsize = sizeof(struct xt_multiport_v1),
.me = THIS_MODULE,
},
{
.name = "multiport",
.family = AF_INET6,
.revision = 0,
.checkentry = checkentry6,
.match = match,
.matchsize = sizeof(struct xt_multiport),
.me = THIS_MODULE,
},
{
.name = "multiport",
.family = AF_INET6,
.revision = 1,
.checkentry = checkentry6_v1,
.match = match_v1,
.matchsize = sizeof(struct xt_multiport_v1),
.me = THIS_MODULE,
},
};
static int __init xt_multiport_init(void)
{
int ret;
ret = xt_register_match(&multiport_match);
if (ret)
goto out;
ret = xt_register_match(&multiport_match_v1);
if (ret)
goto out_unreg_multi_v0;
ret = xt_register_match(&multiport6_match);
if (ret)
goto out_unreg_multi_v1;
ret = xt_register_match(&multiport6_match_v1);
if (ret)
goto out_unreg_multi6_v0;
return ret;
out_unreg_multi6_v0:
xt_unregister_match(&multiport6_match);
out_unreg_multi_v1:
xt_unregister_match(&multiport_match_v1);
out_unreg_multi_v0:
xt_unregister_match(&multiport_match);
out:
return ret;
return xt_register_matches(xt_multiport_match,
ARRAY_SIZE(xt_multiport_match));
}
static void __exit xt_multiport_fini(void)
{
xt_unregister_match(&multiport_match);
xt_unregister_match(&multiport_match_v1);
xt_unregister_match(&multiport6_match);
xt_unregister_match(&multiport6_match_v1);
xt_unregister_matches(xt_multiport_match,
ARRAY_SIZE(xt_multiport_match));
}
module_init(xt_multiport_init);

49
net/netfilter/xt_physdev.c
View File

@ -132,43 +132,34 @@ checkentry(const char *tablename,
return 1;
}
static struct xt_match physdev_match = {
.name = "physdev",
.match = match,
.matchsize = sizeof(struct xt_physdev_info),
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match physdev6_match = {
.name = "physdev",
.match = match,
.matchsize = sizeof(struct xt_physdev_info),
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_physdev_match[] = {
{
.name = "physdev",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_physdev_info),
.me = THIS_MODULE,
},
{
.name = "physdev",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_physdev_info),
.me = THIS_MODULE,
},
};
static int __init xt_physdev_init(void)
{
int ret;
ret = xt_register_match(&physdev_match);
if (ret < 0)
return ret;
ret = xt_register_match(&physdev6_match);
if (ret < 0)
xt_unregister_match(&physdev_match);
return ret;
return xt_register_matches(xt_physdev_match,
ARRAY_SIZE(xt_physdev_match));
}
static void __exit xt_physdev_fini(void)
{
xt_unregister_match(&physdev_match);
xt_unregister_match(&physdev6_match);
xt_unregister_matches(xt_physdev_match, ARRAY_SIZE(xt_physdev_match));
}
module_init(xt_physdev_init);

44
net/netfilter/xt_pkttype.c
View File

@ -43,40 +43,32 @@ static int match(const struct sk_buff *skb,
return (type == info->pkttype) ^ info->invert;
}
static struct xt_match pkttype_match = {
.name = "pkttype",
.match = match,
.matchsize = sizeof(struct xt_pkttype_info),
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match pkttype6_match = {
.name = "pkttype",
.match = match,
.matchsize = sizeof(struct xt_pkttype_info),
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_pkttype_match[] = {
{
.name = "pkttype",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_pkttype_info),
.me = THIS_MODULE,
},
{
.name = "pkttype",
.family = AF_INET6,
.match = match,
.matchsize = sizeof(struct xt_pkttype_info),
.me = THIS_MODULE,
},
};
static int __init xt_pkttype_init(void)
{
int ret;
ret = xt_register_match(&pkttype_match);
if (ret)
return ret;
ret = xt_register_match(&pkttype6_match);
if (ret)
xt_unregister_match(&pkttype_match);
return ret;
return xt_register_matches(xt_pkttype_match,
ARRAY_SIZE(xt_pkttype_match));
}
static void __exit xt_pkttype_fini(void)
{
xt_unregister_match(&pkttype_match);
xt_unregister_match(&pkttype6_match);
xt_unregister_matches(xt_pkttype_match, ARRAY_SIZE(xt_pkttype_match));
}
module_init(xt_pkttype_init);

51
net/netfilter/xt_policy.c
View File

@ -165,43 +165,36 @@ static int checkentry(const char *tablename, const void *ip_void,
return 1;
}
static struct xt_match policy_match = {
.name = "policy",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_policy_info),
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match policy6_match = {
.name = "policy",
.family = AF_INET6,
.match = match,
.matchsize = sizeof(struct xt_policy_info),
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_policy_match[] = {
{
.name = "policy",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_policy_info),
.family = AF_INET,
.me = THIS_MODULE,
},
{
.name = "policy",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_policy_info),
.family = AF_INET6,
.me = THIS_MODULE,
},
};
static int __init init(void)
{
int ret;
ret = xt_register_match(&policy_match);
if (ret)
return ret;
ret = xt_register_match(&policy6_match);
if (ret)
xt_unregister_match(&policy_match);
return ret;
return xt_register_matches(xt_policy_match,
ARRAY_SIZE(xt_policy_match));
}
static void __exit fini(void)
{
xt_unregister_match(&policy6_match);
xt_unregister_match(&policy_match);
xt_unregister_matches(xt_policy_match, ARRAY_SIZE(xt_policy_match));
}
module_init(init);

51
net/netfilter/xt_quota.c
View File

@ -52,46 +52,33 @@ checkentry(const char *tablename, const void *entry,
return 1;
}
static struct xt_match quota_match = {
.name = "quota",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_quota_info),
.checkentry = checkentry,
.me = THIS_MODULE
};
static struct xt_match quota_match6 = {
.name = "quota",
.family = AF_INET6,
.match = match,
.matchsize = sizeof(struct xt_quota_info),
.checkentry = checkentry,
.me = THIS_MODULE
static struct xt_match xt_quota_match[] = {
{
.name = "quota",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_quota_info),
.me = THIS_MODULE
},
{
.name = "quota",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_quota_info),
.me = THIS_MODULE
},
};
static int __init xt_quota_init(void)
{
int ret;
ret = xt_register_match(&quota_match);
if (ret)
goto err1;
ret = xt_register_match(&quota_match6);
if (ret)
goto err2;
return ret;
err2:
xt_unregister_match(&quota_match);
err1:
return ret;
return xt_register_matches(xt_quota_match, ARRAY_SIZE(xt_quota_match));
}
static void __exit xt_quota_fini(void)
{
xt_unregister_match(&quota_match6);
xt_unregister_match(&quota_match);
xt_unregister_matches(xt_quota_match, ARRAY_SIZE(xt_quota_match));
}
module_init(xt_quota_init);

51
net/netfilter/xt_sctp.c
View File

@ -178,44 +178,35 @@ checkentry(const char *tablename,
| SCTP_CHUNK_MATCH_ONLY)));
}
static struct xt_match sctp_match = {
.name = "sctp",
.match = match,
.matchsize = sizeof(struct xt_sctp_info),
.proto = IPPROTO_SCTP,
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE
};
static struct xt_match sctp6_match = {
.name = "sctp",
.match = match,
.matchsize = sizeof(struct xt_sctp_info),
.proto = IPPROTO_SCTP,
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE
static struct xt_match xt_sctp_match[] = {
{
.name = "sctp",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_sctp_info),
.proto = IPPROTO_SCTP,
.me = THIS_MODULE
},
{
.name = "sctp",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_sctp_info),
.proto = IPPROTO_SCTP,
.me = THIS_MODULE
},
};
static int __init xt_sctp_init(void)
{
int ret;
ret = xt_register_match(&sctp_match);
if (ret)
return ret;
ret = xt_register_match(&sctp6_match);
if (ret)
xt_unregister_match(&sctp_match);
return ret;
return xt_register_matches(xt_sctp_match, ARRAY_SIZE(xt_sctp_match));
}
static void __exit xt_sctp_fini(void)
{
xt_unregister_match(&sctp6_match);
xt_unregister_match(&sctp_match);
xt_unregister_matches(xt_sctp_match, ARRAY_SIZE(xt_sctp_match));
}
module_init(xt_sctp_init);

53
net/netfilter/xt_state.c
View File

@ -69,47 +69,36 @@ destroy(const struct xt_match *match, void *matchinfo, unsigned int matchsize)
#endif
}
static struct xt_match state_match = {
.name = "state",
.match = match,
.checkentry = check,
.destroy = destroy,
.matchsize = sizeof(struct xt_state_info),
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match state6_match = {
.name = "state",
.match = match,
.checkentry = check,
.destroy = destroy,
.matchsize = sizeof(struct xt_state_info),
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_state_match[] = {
{
.name = "state",
.family = AF_INET,
.checkentry = check,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_state_info),
.me = THIS_MODULE,
},
{
.name = "state",
.family = AF_INET6,
.checkentry = check,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_state_info),
.me = THIS_MODULE,
},
};
static int __init xt_state_init(void)
{
int ret;
need_conntrack();
ret = xt_register_match(&state_match);
if (ret < 0)
return ret;
ret = xt_register_match(&state6_match);
if (ret < 0)
xt_unregister_match(&state_match);
return ret;
return xt_register_matches(xt_state_match, ARRAY_SIZE(xt_state_match));
}
static void __exit xt_state_fini(void)
{
xt_unregister_match(&state_match);
xt_unregister_match(&state6_match);
xt_unregister_matches(xt_state_match, ARRAY_SIZE(xt_state_match));
}
module_init(xt_state_init);

53
net/netfilter/xt_statistic.c
View File

@ -66,46 +66,35 @@ checkentry(const char *tablename, const void *entry,
return 1;
}
static struct xt_match statistic_match = {
.name = "statistic",
.match = match,
.matchsize = sizeof(struct xt_statistic_info),
.checkentry = checkentry,
.family = AF_INET,
.me = THIS_MODULE,
};
static struct xt_match statistic_match6 = {
.name = "statistic",
.match = match,
.matchsize = sizeof(struct xt_statistic_info),
.checkentry = checkentry,
.family = AF_INET6,
.me = THIS_MODULE,
static struct xt_match xt_statistic_match[] = {
{
.name = "statistic",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_statistic_info),
.me = THIS_MODULE,
},
{
.name = "statistic",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.matchsize = sizeof(struct xt_statistic_info),
.me = THIS_MODULE,
},
};
static int __init xt_statistic_init(void)
{
int ret;
ret = xt_register_match(&statistic_match);
if (ret)
goto err1;
ret = xt_register_match(&statistic_match6);
if (ret)
goto err2;
return ret;
err2:
xt_unregister_match(&statistic_match);
err1:
return ret;
return xt_register_matches(xt_statistic_match,
ARRAY_SIZE(xt_statistic_match));
}
static void __exit xt_statistic_fini(void)
{
xt_unregister_match(&statistic_match6);
xt_unregister_match(&statistic_match);
xt_unregister_matches(xt_statistic_match,
ARRAY_SIZE(xt_statistic_match));
}
module_init(xt_statistic_init);

50
net/netfilter/xt_string.c
View File

@ -75,43 +75,35 @@ static void destroy(const struct xt_match *match, void *matchinfo,
textsearch_destroy(STRING_TEXT_PRIV(matchinfo)->config);
}
static struct xt_match string_match = {
.name = "string",
.match = match,
.matchsize = sizeof(struct xt_string_info),
.checkentry = checkentry,
.destroy = destroy,
.family = AF_INET,
.me = THIS_MODULE
};
static struct xt_match string6_match = {
.name = "string",
.match = match,
.matchsize = sizeof(struct xt_string_info),
.checkentry = checkentry,
.destroy = destroy,
.family = AF_INET6,
.me = THIS_MODULE
static struct xt_match xt_string_match[] = {
{
.name = "string",
.family = AF_INET,
.checkentry = checkentry,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_string_info),
.me = THIS_MODULE
},
{
.name = "string",
.family = AF_INET6,
.checkentry = checkentry,
.match = match,
.destroy = destroy,
.matchsize = sizeof(struct xt_string_info),
.me = THIS_MODULE
},
};
static int __init xt_string_init(void)
{
int ret;
ret = xt_register_match(&string_match);
if (ret)
return ret;
ret = xt_register_match(&string6_match);
if (ret)
xt_unregister_match(&string_match);
return ret;
return xt_register_matches(xt_string_match, ARRAY_SIZE(xt_string_match));
}
static void __exit xt_string_fini(void)
{
xt_unregister_match(&string_match);
xt_unregister_match(&string6_match);
xt_unregister_matches(xt_string_match, ARRAY_SIZE(xt_string_match));
}
module_init(xt_string_init);

49
net/netfilter/xt_tcpmss.c
View File

@ -93,43 +93,34 @@ match(const struct sk_buff *skb,
info->invert, hotdrop);
}
static struct xt_match tcpmss_match = {
.name = "tcpmss",
.match = match,
.matchsize = sizeof(struct xt_tcpmss_match_info),
.proto = IPPROTO_TCP,
.family = AF_INET,
.me = THIS_MODULE,
static struct xt_match xt_tcpmss_match[] = {
{
.name = "tcpmss",
.family = AF_INET,
.match = match,
.matchsize = sizeof(struct xt_tcpmss_match_info),
.proto = IPPROTO_TCP,
.me = THIS_MODULE,
},
{
.name = "tcpmss",
.family = AF_INET6,
.match = match,
.matchsize = sizeof(struct xt_tcpmss_match_info),
.proto = IPPROTO_TCP,
.me = THIS_MODULE,
},
};
static struct xt_match tcpmss6_match = {
.name = "tcpmss",
.match = match,
.matchsize = sizeof(struct xt_tcpmss_match_info),
.proto = IPPROTO_TCP,
.family = AF_INET6,
.me = THIS_MODULE,
};
static int __init xt_tcpmss_init(void)
{
int ret;
ret = xt_register_match(&tcpmss_match);
if (ret)
return ret;
ret = xt_register_match(&tcpmss6_match);
if (ret)
xt_unregister_match(&tcpmss_match);
return ret;
return xt_register_matches(xt_tcpmss_match,
ARRAY_SIZE(xt_tcpmss_match));
}
static void __exit xt_tcpmss_fini(void)
{
xt_unregister_match(&tcpmss6_match);
xt_unregister_match(&tcpmss_match);
xt_unregister_matches(xt_tcpmss_match, ARRAY_SIZE(xt_tcpmss_match));
}
module_init(xt_tcpmss_init);

107
net/netfilter/xt_tcpudp.c
View File

@ -199,81 +199,54 @@ udp_checkentry(const char *tablename,
return !(udpinfo->invflags & ~XT_UDP_INV_MASK);
}
static struct xt_match tcp_matchstruct = {
.name = "tcp",
.match = tcp_match,
.matchsize = sizeof(struct xt_tcp),
.proto = IPPROTO_TCP,
.family = AF_INET,
.checkentry = tcp_checkentry,
.me = THIS_MODULE,
};
static struct xt_match tcp6_matchstruct = {
.name = "tcp",
.match = tcp_match,
.matchsize = sizeof(struct xt_tcp),
.proto = IPPROTO_TCP,
.family = AF_INET6,
.checkentry = tcp_checkentry,
.me = THIS_MODULE,
};
static struct xt_match udp_matchstruct = {
.name = "udp",
.match = udp_match,
.matchsize = sizeof(struct xt_udp),
.proto = IPPROTO_UDP,
.family = AF_INET,
.checkentry = udp_checkentry,
.me = THIS_MODULE,
};
static struct xt_match udp6_matchstruct = {
.name = "udp",
.match = udp_match,
.matchsize = sizeof(struct xt_udp),
.proto = IPPROTO_UDP,
.family = AF_INET6,
.checkentry = udp_checkentry,
.me = THIS_MODULE,
static struct xt_match xt_tcpudp_match[] = {
{
.name = "tcp",
.family = AF_INET,
.checkentry = tcp_checkentry,
.match = tcp_match,
.matchsize = sizeof(struct xt_tcp),
.proto = IPPROTO_TCP,
.me = THIS_MODULE,
},
{
.name = "tcp",
.family = AF_INET6,
.checkentry = tcp_checkentry,
.match = tcp_match,
.matchsize = sizeof(struct xt_tcp),
.proto = IPPROTO_TCP,
.me = THIS_MODULE,
},
{
.name = "udp",
.family = AF_INET,
.checkentry = udp_checkentry,
.match = udp_match,
.matchsize = sizeof(struct xt_udp),
.proto = IPPROTO_UDP,
.me = THIS_MODULE,
},
{
.name = "udp",
.family = AF_INET6,
.checkentry = udp_checkentry,
.match = udp_match,
.matchsize = sizeof(struct xt_udp),
.proto = IPPROTO_UDP,
.me = THIS_MODULE,
},
};
static int __init xt_tcpudp_init(void)
{
int ret;
ret = xt_register_match(&tcp_matchstruct);
if (ret)
return ret;
ret = xt_register_match(&tcp6_matchstruct);
if (ret)
goto out_unreg_tcp;
ret = xt_register_match(&udp_matchstruct);
if (ret)
goto out_unreg_tcp6;
ret = xt_register_match(&udp6_matchstruct);
if (ret)
goto out_unreg_udp;
return ret;
out_unreg_udp:
xt_unregister_match(&udp_matchstruct);
out_unreg_tcp6:
xt_unregister_match(&tcp6_matchstruct);
out_unreg_tcp:
xt_unregister_match(&tcp_matchstruct);
return ret;
return xt_register_matches(xt_tcpudp_match,
ARRAY_SIZE(xt_tcpudp_match));
}
static void __exit xt_tcpudp_fini(void)
{
xt_unregister_match(&udp6_matchstruct);
xt_unregister_match(&udp_matchstruct);
xt_unregister_match(&tcp6_matchstruct);
xt_unregister_match(&tcp_matchstruct);
xt_unregister_matches(xt_tcpudp_match, ARRAY_SIZE(xt_tcpudp_match));
}
module_init(xt_tcpudp_init);