3 files changed, 33 insertions, 33 deletions

diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
index f813e02aab3..f8771e058b9 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
@@ -363,32 +363,32 @@ getorigdst(struct sock *sk, int optval, void __user *user, int *len)
 static int ipv4_tuple_to_nfattr(struct sk_buff *skb,
                                 const struct nf_conntrack_tuple *tuple)
 {
-        NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t),
+        NLA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t),
                 &tuple->src.u3.ip);
-        NFA_PUT(skb, CTA_IP_V4_DST, sizeof(u_int32_t),
+        NLA_PUT(skb, CTA_IP_V4_DST, sizeof(u_int32_t),
                 &tuple->dst.u3.ip);
         return 0;
 
-nfattr_failure:
+nla_put_failure:
         return -1;
 }
 
-static const size_t cta_min_ip[CTA_IP_MAX] = {
-        [CTA_IP_V4_SRC-1]       = sizeof(u_int32_t),
-        [CTA_IP_V4_DST-1]       = sizeof(u_int32_t),
+static const size_t cta_min_ip[CTA_IP_MAX+1] = {
+        [CTA_IP_V4_SRC] = sizeof(u_int32_t),
+        [CTA_IP_V4_DST] = sizeof(u_int32_t),
 };
 
-static int ipv4_nfattr_to_tuple(struct nfattr *tb[],
+static int ipv4_nfattr_to_tuple(struct nlattr *tb[],
                                 struct nf_conntrack_tuple *t)
 {
-        if (!tb[CTA_IP_V4_SRC-1] || !tb[CTA_IP_V4_DST-1])
+        if (!tb[CTA_IP_V4_SRC] || !tb[CTA_IP_V4_DST])
                 return -EINVAL;
 
         if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip))
                 return -EINVAL;
 
-        t->src.u3.ip = *(__be32 *)NFA_DATA(tb[CTA_IP_V4_SRC-1]);
-        t->dst.u3.ip = *(__be32 *)NFA_DATA(tb[CTA_IP_V4_DST-1]);
+        t->src.u3.ip = *(__be32 *)nla_data(tb[CTA_IP_V4_SRC]);
+        t->dst.u3.ip = *(__be32 *)nla_data(tb[CTA_IP_V4_DST]);
 
         return 0;
 }
diff --git a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
index 6593fd2c5b1..714332b8869 100644
--- a/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
+++ b/net/ipv4/netfilter/nf_conntrack_proto_icmp.c
@@ -235,42 +235,42 @@ icmp_error(struct sk_buff *skb, unsigned int dataoff,
 static int icmp_tuple_to_nfattr(struct sk_buff *skb,
                                 const struct nf_conntrack_tuple *t)
 {
-        NFA_PUT(skb, CTA_PROTO_ICMP_ID, sizeof(u_int16_t),
+        NLA_PUT(skb, CTA_PROTO_ICMP_ID, sizeof(u_int16_t),
                 &t->src.u.icmp.id);
-        NFA_PUT(skb, CTA_PROTO_ICMP_TYPE, sizeof(u_int8_t),
+        NLA_PUT(skb, CTA_PROTO_ICMP_TYPE, sizeof(u_int8_t),
                 &t->dst.u.icmp.type);
-        NFA_PUT(skb, CTA_PROTO_ICMP_CODE, sizeof(u_int8_t),
+        NLA_PUT(skb, CTA_PROTO_ICMP_CODE, sizeof(u_int8_t),
                 &t->dst.u.icmp.code);
 
         return 0;
 
-nfattr_failure:
+nla_put_failure:
         return -1;
 }
 
-static const size_t cta_min_proto[CTA_PROTO_MAX] = {
-        [CTA_PROTO_ICMP_TYPE-1] = sizeof(u_int8_t),
-        [CTA_PROTO_ICMP_CODE-1] = sizeof(u_int8_t),
-        [CTA_PROTO_ICMP_ID-1]   = sizeof(u_int16_t)
+static const size_t cta_min_proto[CTA_PROTO_MAX+1] = {
+        [CTA_PROTO_ICMP_TYPE]   = sizeof(u_int8_t),
+        [CTA_PROTO_ICMP_CODE]   = sizeof(u_int8_t),
+        [CTA_PROTO_ICMP_ID]     = sizeof(u_int16_t)
 };
 
-static int icmp_nfattr_to_tuple(struct nfattr *tb[],
+static int icmp_nfattr_to_tuple(struct nlattr *tb[],
                                 struct nf_conntrack_tuple *tuple)
 {
-        if (!tb[CTA_PROTO_ICMP_TYPE-1]
-            || !tb[CTA_PROTO_ICMP_CODE-1]
-            || !tb[CTA_PROTO_ICMP_ID-1])
+        if (!tb[CTA_PROTO_ICMP_TYPE]
+            || !tb[CTA_PROTO_ICMP_CODE]
+            || !tb[CTA_PROTO_ICMP_ID])
                 return -EINVAL;
 
         if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto))
                 return -EINVAL;
 
         tuple->dst.u.icmp.type =
-                        *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_TYPE-1]);
+                        *(u_int8_t *)nla_data(tb[CTA_PROTO_ICMP_TYPE]);
         tuple->dst.u.icmp.code =
-                        *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_CODE-1]);
+                        *(u_int8_t *)nla_data(tb[CTA_PROTO_ICMP_CODE]);
         tuple->src.u.icmp.id =
-                        *(__be16 *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]);
+                        *(__be16 *)nla_data(tb[CTA_PROTO_ICMP_ID]);
 
         if (tuple->dst.u.icmp.type >= sizeof(invmap)
             || !invmap[tuple->dst.u.icmp.type])
diff --git a/net/ipv4/netfilter/nf_nat_core.c b/net/ipv4/netfilter/nf_nat_core.c
index deab27facba..4bdbb128fe5 100644
--- a/net/ipv4/netfilter/nf_nat_core.c
+++ b/net/ipv4/netfilter/nf_nat_core.c
@@ -547,38 +547,38 @@ int
 nf_nat_port_range_to_nfattr(struct sk_buff *skb,
                             const struct nf_nat_range *range)
 {
-        NFA_PUT(skb, CTA_PROTONAT_PORT_MIN, sizeof(__be16),
+        NLA_PUT(skb, CTA_PROTONAT_PORT_MIN, sizeof(__be16),
                 &range->min.tcp.port);
-        NFA_PUT(skb, CTA_PROTONAT_PORT_MAX, sizeof(__be16),
+        NLA_PUT(skb, CTA_PROTONAT_PORT_MAX, sizeof(__be16),
                 &range->max.tcp.port);
 
         return 0;
 
-nfattr_failure:
+nla_put_failure:
         return -1;
 }
 EXPORT_SYMBOL_GPL(nf_nat_port_nfattr_to_range);
 
 int
-nf_nat_port_nfattr_to_range(struct nfattr *tb[], struct nf_nat_range *range)
+nf_nat_port_nfattr_to_range(struct nlattr *tb[], struct nf_nat_range *range)
 {
         int ret = 0;
 
         /* we have to return whether we actually parsed something or not */
 
-        if (tb[CTA_PROTONAT_PORT_MIN-1]) {
+        if (tb[CTA_PROTONAT_PORT_MIN]) {
                 ret = 1;
                 range->min.tcp.port =
-                        *(__be16 *)NFA_DATA(tb[CTA_PROTONAT_PORT_MIN-1]);
+                        *(__be16 *)nla_data(tb[CTA_PROTONAT_PORT_MIN]);
         }
 
-        if (!tb[CTA_PROTONAT_PORT_MAX-1]) {
+        if (!tb[CTA_PROTONAT_PORT_MAX]) {
                 if (ret)
                         range->max.tcp.port = range->min.tcp.port;
         } else {
                 ret = 1;
                 range->max.tcp.port =
-                        *(__be16 *)NFA_DATA(tb[CTA_PROTONAT_PORT_MAX-1]);
+                        *(__be16 *)nla_data(tb[CTA_PROTONAT_PORT_MAX]);
         }
 
         return ret;