1 files changed, 36 insertions, 36 deletions

diff --git a/net/netfilter/nf_conntrack_proto.c b/net/netfilter/nf_conntrack_proto.c
index 24c61a38471..330b9acc62d 100644
--- a/net/netfilter/nf_conntrack_proto.c
+++ b/net/netfilter/nf_conntrack_proto.c
@@ -24,38 +24,38 @@
 
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_l3proto.h>
-#include <net/netfilter/nf_conntrack_protocol.h>
+#include <net/netfilter/nf_conntrack_l4proto.h>
 #include <net/netfilter/nf_conntrack_core.h>
 
-struct nf_conntrack_protocol **nf_ct_protos[PF_MAX] __read_mostly;
+struct nf_conntrack_l4proto **nf_ct_protos[PF_MAX] __read_mostly;
 struct nf_conntrack_l3proto *nf_ct_l3protos[PF_MAX] __read_mostly;
 
-struct nf_conntrack_protocol *
-__nf_ct_proto_find(u_int16_t l3proto, u_int8_t protocol)
+struct nf_conntrack_l4proto *
+__nf_ct_l4proto_find(u_int16_t l3proto, u_int8_t l4proto)
 {
         if (unlikely(l3proto >= AF_MAX || nf_ct_protos[l3proto] == NULL))
-                return &nf_conntrack_generic_protocol;
+                return &nf_conntrack_l4proto_generic;
 
-        return nf_ct_protos[l3proto][protocol];
+        return nf_ct_protos[l3proto][l4proto];
 }
 
 /* this is guaranteed to always return a valid protocol helper, since
  * it falls back to generic_protocol */
-struct nf_conntrack_protocol *
-nf_ct_proto_find_get(u_int16_t l3proto, u_int8_t protocol)
+struct nf_conntrack_l4proto *
+nf_ct_l4proto_find_get(u_int16_t l3proto, u_int8_t l4proto)
 {
-        struct nf_conntrack_protocol *p;
+        struct nf_conntrack_l4proto *p;
 
         preempt_disable();
-        p = __nf_ct_proto_find(l3proto, protocol);
+        p = __nf_ct_l4proto_find(l3proto, l4proto);
         if (!try_module_get(p->me))
-                p = &nf_conntrack_generic_protocol;
+                p = &nf_conntrack_l4proto_generic;
         preempt_enable();
 
         return p;
 }
 
-void nf_ct_proto_put(struct nf_conntrack_protocol *p)
+void nf_ct_l4proto_put(struct nf_conntrack_l4proto *p)
 {
         module_put(p->me);
 }
@@ -68,7 +68,7 @@ nf_ct_l3proto_find_get(u_int16_t l3proto)
         preempt_disable();
         p = __nf_ct_l3proto_find(l3proto);
         if (!try_module_get(p->me))
-                p = &nf_conntrack_generic_l3proto;
+                p = &nf_conntrack_l3proto_generic;
         preempt_enable();
 
         return p;
@@ -86,7 +86,7 @@ nf_ct_l3proto_try_module_get(unsigned short l3proto)
         struct nf_conntrack_l3proto *p;
 
 retry:  p = nf_ct_l3proto_find_get(l3proto);
-        if (p == &nf_conntrack_generic_l3proto) {
+        if (p == &nf_conntrack_l3proto_generic) {
                 ret = request_module("nf_conntrack-%d", l3proto);
                 if (!ret)
                         goto retry;
@@ -114,14 +114,14 @@ static int kill_l3proto(struct nf_conn *i, void *data)
                         ((struct nf_conntrack_l3proto *)data)->l3proto);
 }
 
-static int kill_proto(struct nf_conn *i, void *data)
+static int kill_l4proto(struct nf_conn *i, void *data)
 {
-        struct nf_conntrack_protocol *proto;
-        proto = (struct nf_conntrack_protocol *)data;
+        struct nf_conntrack_l4proto *l4proto;
+        l4proto = (struct nf_conntrack_l4proto *)data;
         return (i->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum ==
-                        proto->proto) &&
+                        l4proto->l4proto) &&
                (i->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num ==
-                        proto->l3proto);
+                        l4proto->l3proto);
 }
 
 int nf_conntrack_l3proto_register(struct nf_conntrack_l3proto *proto)
@@ -129,7 +129,7 @@ int nf_conntrack_l3proto_register(struct nf_conntrack_l3proto *proto)
         int ret = 0;
 
         write_lock_bh(&nf_conntrack_lock);
-        if (nf_ct_l3protos[proto->l3proto] != &nf_conntrack_generic_l3proto) {
+        if (nf_ct_l3protos[proto->l3proto] != &nf_conntrack_l3proto_generic) {
                 ret = -EBUSY;
                 goto out;
         }
@@ -143,7 +143,7 @@ out:
 void nf_conntrack_l3proto_unregister(struct nf_conntrack_l3proto *proto)
 {
         write_lock_bh(&nf_conntrack_lock);
-        nf_ct_l3protos[proto->l3proto] = &nf_conntrack_generic_l3proto;
+        nf_ct_l3protos[proto->l3proto] = &nf_conntrack_l3proto_generic;
         write_unlock_bh(&nf_conntrack_lock);
 
         /* Somebody could be still looking at the proto in bh. */
@@ -155,43 +155,43 @@ void nf_conntrack_l3proto_unregister(struct nf_conntrack_l3proto *proto)
 
 /* FIXME: Allow NULL functions and sub in pointers to generic for
    them. --RR */
-int nf_conntrack_protocol_register(struct nf_conntrack_protocol *proto)
+int nf_conntrack_l4proto_register(struct nf_conntrack_l4proto *l4proto)
 {
         int ret = 0;
 
 retry:
         write_lock_bh(&nf_conntrack_lock);
-        if (nf_ct_protos[proto->l3proto]) {
-                if (nf_ct_protos[proto->l3proto][proto->proto]
-                                != &nf_conntrack_generic_protocol) {
+        if (nf_ct_protos[l4proto->l3proto]) {
+                if (nf_ct_protos[l4proto->l3proto][l4proto->l4proto]
+                                != &nf_conntrack_l4proto_generic) {
                         ret = -EBUSY;
                         goto out_unlock;
                 }
         } else {
                 /* l3proto may be loaded latter. */
-                struct nf_conntrack_protocol **proto_array;
+                struct nf_conntrack_l4proto **proto_array;
                 int i;
 
                 write_unlock_bh(&nf_conntrack_lock);
 
-                proto_array = (struct nf_conntrack_protocol **)
+                proto_array = (struct nf_conntrack_l4proto **)
                                 kmalloc(MAX_NF_CT_PROTO *
-                                         sizeof(struct nf_conntrack_protocol *),
+                                         sizeof(struct nf_conntrack_l4proto *),
                                         GFP_KERNEL);
                 if (proto_array == NULL) {
                         ret = -ENOMEM;
                         goto out;
                 }
                 for (i = 0; i < MAX_NF_CT_PROTO; i++)
-                        proto_array[i] = &nf_conntrack_generic_protocol;
+                        proto_array[i] = &nf_conntrack_l4proto_generic;
 
                 write_lock_bh(&nf_conntrack_lock);
-                if (nf_ct_protos[proto->l3proto]) {
+                if (nf_ct_protos[l4proto->l3proto]) {
                         /* bad timing, but no problem */
                         write_unlock_bh(&nf_conntrack_lock);
                         kfree(proto_array);
                 } else {
-                        nf_ct_protos[proto->l3proto] = proto_array;
+                        nf_ct_protos[l4proto->l3proto] = proto_array;
                         write_unlock_bh(&nf_conntrack_lock);
                 }
 
@@ -202,7 +202,7 @@ retry:
                 goto retry;
         }
 
-        nf_ct_protos[proto->l3proto][proto->proto] = proto;
+        nf_ct_protos[l4proto->l3proto][l4proto->l4proto] = l4proto;
 
 out_unlock:
         write_unlock_bh(&nf_conntrack_lock);
@@ -210,16 +210,16 @@ out:
         return ret;
 }
 
-void nf_conntrack_protocol_unregister(struct nf_conntrack_protocol *proto)
+void nf_conntrack_l4proto_unregister(struct nf_conntrack_l4proto *l4proto)
 {
         write_lock_bh(&nf_conntrack_lock);
-        nf_ct_protos[proto->l3proto][proto->proto]
-                = &nf_conntrack_generic_protocol;
+        nf_ct_protos[l4proto->l3proto][l4proto->l4proto]
+                = &nf_conntrack_l4proto_generic;
         write_unlock_bh(&nf_conntrack_lock);
 
         /* Somebody could be still looking at the proto in bh. */
         synchronize_net();
 
         /* Remove all contrack entries for this protocol */
-        nf_ct_iterate_cleanup(kill_proto, proto);
+        nf_ct_iterate_cleanup(kill_l4proto, l4proto);
 }