networking: make skb_put & friends return void pointers

It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.

Make these functions (skb_put, __skb_put and pskb_put) return void *
and remove all the casts across the tree, adding a (u8 *) cast only
where the unsigned char pointer was used directly, all done with the
following spatch:

    @@
    expression SKB, LEN;
    typedef u8;
    identifier fn = { skb_put, __skb_put };
    @@
    - *(fn(SKB, LEN))
    + *(u8 *)fn(SKB, LEN)

    @@
    expression E, SKB, LEN;
    identifier fn = { skb_put, __skb_put };
    type T;
    @@
    - E = ((T *)(fn(SKB, LEN)))
    + E = fn(SKB, LEN)

which actually doesn't cover pskb_put since there are only three
users overall.

A handful of stragglers were converted manually, notably a macro in
drivers/isdn/i4l/isdn_bsdcomp.c and, oddly enough, one of the many
instances in net/bluetooth/hci_sock.c. In the former file, I also
had to fix one whitespace problem spatch introduced.

Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 50 insertions, 66 deletions

diff --git a/net/key/af_key.c b/net/key/af_key.c
index 3ebb4268973b..daa4e90dc4db 100644
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -349,7 +349,7 @@ static int pfkey_error(const struct sadb_msg *orig, int err, struct sock *sk)
                 err = EINVAL;
         BUG_ON(err <= 0 || err >= 256);
 
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         pfkey_hdr_dup(hdr, orig);
         hdr->sadb_msg_errno = (uint8_t) err;
         hdr->sadb_msg_len = (sizeof(struct sadb_msg) /
@@ -810,12 +810,12 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                 return ERR_PTR(-ENOBUFS);
 
         /* call should fill header later */
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         memset(hdr, 0, size);   /* XXX do we need this ? */
         hdr->sadb_msg_len = size / sizeof(uint64_t);
 
         /* sa */
-        sa = (struct sadb_sa *)  skb_put(skb, sizeof(struct sadb_sa));
+        sa = skb_put(skb, sizeof(struct sadb_sa));
         sa->sadb_sa_len = sizeof(struct sadb_sa)/sizeof(uint64_t);
         sa->sadb_sa_exttype = SADB_EXT_SA;
         sa->sadb_sa_spi = x->id.spi;
@@ -862,8 +862,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
         /* hard time */
         if (hsc & 2) {
-                lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                             sizeof(struct sadb_lifetime));
+                lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
                 lifetime->sadb_lifetime_len =
                         sizeof(struct sadb_lifetime)/sizeof(uint64_t);
                 lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
@@ -874,8 +873,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
         }
         /* soft time */
         if (hsc & 1) {
-                lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                             sizeof(struct sadb_lifetime));
+                lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
                 lifetime->sadb_lifetime_len =
                         sizeof(struct sadb_lifetime)/sizeof(uint64_t);
                 lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
@@ -885,8 +883,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                 lifetime->sadb_lifetime_usetime = x->lft.soft_use_expires_seconds;
         }
         /* current time */
-        lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                     sizeof(struct sadb_lifetime));
+        lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
         lifetime->sadb_lifetime_len =
                 sizeof(struct sadb_lifetime)/sizeof(uint64_t);
         lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
@@ -895,8 +892,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
         lifetime->sadb_lifetime_addtime = x->curlft.add_time;
         lifetime->sadb_lifetime_usetime = x->curlft.use_time;
         /* src address */
-        addr = (struct sadb_address*) skb_put(skb,
-                                              sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -915,8 +911,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                 BUG();
 
         /* dst address */
-        addr = (struct sadb_address*) skb_put(skb,
-                                              sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -933,8 +928,8 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
         if (!xfrm_addr_equal(&x->sel.saddr, &x->props.saddr,
                              x->props.family)) {
-                addr = (struct sadb_address*) skb_put(skb,
-                        sizeof(struct sadb_address)+sockaddr_size);
+                addr = skb_put(skb,
+                               sizeof(struct sadb_address) + sockaddr_size);
                 addr->sadb_address_len =
                         (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -951,8 +946,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
         /* auth key */
         if (add_keys && auth_key_size) {
-                key = (struct sadb_key *) skb_put(skb,
-                                                  sizeof(struct sadb_key)+auth_key_size);
+                key = skb_put(skb, sizeof(struct sadb_key) + auth_key_size);
                 key->sadb_key_len = (sizeof(struct sadb_key) + auth_key_size) /
                         sizeof(uint64_t);
                 key->sadb_key_exttype = SADB_EXT_KEY_AUTH;
@@ -962,8 +956,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
         }
         /* encrypt key */
         if (add_keys && encrypt_key_size) {
-                key = (struct sadb_key *) skb_put(skb,
-                                                  sizeof(struct sadb_key)+encrypt_key_size);
+                key = skb_put(skb, sizeof(struct sadb_key) + encrypt_key_size);
                 key->sadb_key_len = (sizeof(struct sadb_key) +
                                      encrypt_key_size) / sizeof(uint64_t);
                 key->sadb_key_exttype = SADB_EXT_KEY_ENCRYPT;
@@ -974,7 +967,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
         }
 
         /* sa */
-        sa2 = (struct sadb_x_sa2 *)  skb_put(skb, sizeof(struct sadb_x_sa2));
+        sa2 = skb_put(skb, sizeof(struct sadb_x_sa2));
         sa2->sadb_x_sa2_len = sizeof(struct sadb_x_sa2)/sizeof(uint64_t);
         sa2->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
         if ((mode = pfkey_mode_from_xfrm(x->props.mode)) < 0) {
@@ -992,7 +985,7 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                 struct sadb_x_nat_t_port *n_port;
 
                 /* type */
-                n_type = (struct sadb_x_nat_t_type*) skb_put(skb, sizeof(*n_type));
+                n_type = skb_put(skb, sizeof(*n_type));
                 n_type->sadb_x_nat_t_type_len = sizeof(*n_type)/sizeof(uint64_t);
                 n_type->sadb_x_nat_t_type_exttype = SADB_X_EXT_NAT_T_TYPE;
                 n_type->sadb_x_nat_t_type_type = natt->encap_type;
@@ -1001,14 +994,14 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
                 n_type->sadb_x_nat_t_type_reserved[2] = 0;
 
                 /* source port */
-                n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+                n_port = skb_put(skb, sizeof(*n_port));
                 n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
                 n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_SPORT;
                 n_port->sadb_x_nat_t_port_port = natt->encap_sport;
                 n_port->sadb_x_nat_t_port_reserved = 0;
 
                 /* dest port */
-                n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+                n_port = skb_put(skb, sizeof(*n_port));
                 n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
                 n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_DPORT;
                 n_port->sadb_x_nat_t_port_port = natt->encap_dport;
@@ -1017,8 +1010,8 @@ static struct sk_buff *__pfkey_xfrm_state2msg(const struct xfrm_state *x,
 
         /* security context */
         if (xfrm_ctx) {
-                sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb,
-                                sizeof(struct sadb_x_sec_ctx) + ctx_size);
+                sec_ctx = skb_put(skb,
+                                  sizeof(struct sadb_x_sec_ctx) + ctx_size);
                 sec_ctx->sadb_x_sec_len =
                   (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t);
                 sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
@@ -1617,7 +1610,7 @@ static struct sk_buff *compose_sadb_supported(const struct sadb_msg *orig,
         if (!skb)
                 goto out_put_algs;
 
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(*hdr));
+        hdr = skb_put(skb, sizeof(*hdr));
         pfkey_hdr_dup(hdr, orig);
         hdr->sadb_msg_errno = 0;
         hdr->sadb_msg_len = len / sizeof(uint64_t);
@@ -1626,7 +1619,7 @@ static struct sk_buff *compose_sadb_supported(const struct sadb_msg *orig,
                 struct sadb_supported *sp;
                 struct sadb_alg *ap;
 
-                sp = (struct sadb_supported *) skb_put(skb, auth_len);
+                sp = skb_put(skb, auth_len);
                 ap = (struct sadb_alg *) (sp + 1);
 
                 sp->sadb_supported_len = auth_len / sizeof(uint64_t);
@@ -1647,7 +1640,7 @@ static struct sk_buff *compose_sadb_supported(const struct sadb_msg *orig,
                 struct sadb_supported *sp;
                 struct sadb_alg *ap;
 
-                sp = (struct sadb_supported *) skb_put(skb, enc_len);
+                sp = skb_put(skb, enc_len);
                 ap = (struct sadb_alg *) (sp + 1);
 
                 sp->sadb_supported_len = enc_len / sizeof(uint64_t);
@@ -1721,7 +1714,7 @@ static int key_notify_sa_flush(const struct km_event *c)
         skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
         if (!skb)
                 return -ENOBUFS;
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
         hdr->sadb_msg_type = SADB_FLUSH;
         hdr->sadb_msg_seq = c->seq;
@@ -2046,12 +2039,11 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
         size = pfkey_xfrm_policy2msg_size(xp);
 
         /* call should fill header later */
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         memset(hdr, 0, size);   /* XXX do we need this ? */
 
         /* src address */
-        addr = (struct sadb_address*) skb_put(skb,
-                                              sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -2066,8 +2058,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
                 BUG();
 
         /* dst address */
-        addr = (struct sadb_address*) skb_put(skb,
-                                              sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -2081,8 +2072,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
                             xp->family);
 
         /* hard time */
-        lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                     sizeof(struct sadb_lifetime));
+        lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
         lifetime->sadb_lifetime_len =
                 sizeof(struct sadb_lifetime)/sizeof(uint64_t);
         lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
@@ -2091,8 +2081,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
         lifetime->sadb_lifetime_addtime = xp->lft.hard_add_expires_seconds;
         lifetime->sadb_lifetime_usetime = xp->lft.hard_use_expires_seconds;
         /* soft time */
-        lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                     sizeof(struct sadb_lifetime));
+        lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
         lifetime->sadb_lifetime_len =
                 sizeof(struct sadb_lifetime)/sizeof(uint64_t);
         lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
@@ -2101,8 +2090,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
         lifetime->sadb_lifetime_addtime = xp->lft.soft_add_expires_seconds;
         lifetime->sadb_lifetime_usetime = xp->lft.soft_use_expires_seconds;
         /* current time */
-        lifetime = (struct sadb_lifetime *)  skb_put(skb,
-                                                     sizeof(struct sadb_lifetime));
+        lifetime = skb_put(skb, sizeof(struct sadb_lifetime));
         lifetime->sadb_lifetime_len =
                 sizeof(struct sadb_lifetime)/sizeof(uint64_t);
         lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
@@ -2111,7 +2099,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
         lifetime->sadb_lifetime_addtime = xp->curlft.add_time;
         lifetime->sadb_lifetime_usetime = xp->curlft.use_time;
 
-        pol = (struct sadb_x_policy *)  skb_put(skb, sizeof(struct sadb_x_policy));
+        pol = skb_put(skb, sizeof(struct sadb_x_policy));
         pol->sadb_x_policy_len = sizeof(struct sadb_x_policy)/sizeof(uint64_t);
         pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
         pol->sadb_x_policy_type = IPSEC_POLICY_DISCARD;
@@ -2139,7 +2127,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
                 } else {
                         size -= 2*socklen;
                 }
-                rq = (void*)skb_put(skb, req_size);
+                rq = skb_put(skb, req_size);
                 pol->sadb_x_policy_len += req_size/8;
                 memset(rq, 0, sizeof(*rq));
                 rq->sadb_x_ipsecrequest_len = req_size;
@@ -2169,7 +2157,7 @@ static int pfkey_xfrm_policy2msg(struct sk_buff *skb, const struct xfrm_policy *
         if ((xfrm_ctx = xp->security)) {
                 int ctx_size = pfkey_xfrm_policy2sec_ctx_size(xp);
 
-                sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb, ctx_size);
+                sec_ctx = skb_put(skb, ctx_size);
                 sec_ctx->sadb_x_sec_len = ctx_size / sizeof(uint64_t);
                 sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
                 sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi;
@@ -2733,7 +2721,7 @@ static int key_notify_policy_flush(const struct km_event *c)
         skb_out = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
         if (!skb_out)
                 return -ENOBUFS;
-        hdr = (struct sadb_msg *) skb_put(skb_out, sizeof(struct sadb_msg));
+        hdr = skb_put(skb_out, sizeof(struct sadb_msg));
         hdr->sadb_msg_type = SADB_X_SPDFLUSH;
         hdr->sadb_msg_seq = c->seq;
         hdr->sadb_msg_pid = c->portid;
@@ -2917,7 +2905,7 @@ static void dump_ah_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
         struct sadb_prop *p;
         int i;
 
-        p = (struct sadb_prop*)skb_put(skb, sizeof(struct sadb_prop));
+        p = skb_put(skb, sizeof(struct sadb_prop));
         p->sadb_prop_len = sizeof(struct sadb_prop)/8;
         p->sadb_prop_exttype = SADB_EXT_PROPOSAL;
         p->sadb_prop_replay = 32;
@@ -2951,7 +2939,7 @@ static void dump_esp_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
         struct sadb_prop *p;
         int i, k;
 
-        p = (struct sadb_prop*)skb_put(skb, sizeof(struct sadb_prop));
+        p = skb_put(skb, sizeof(struct sadb_prop));
         p->sadb_prop_len = sizeof(struct sadb_prop)/8;
         p->sadb_prop_exttype = SADB_EXT_PROPOSAL;
         p->sadb_prop_replay = 32;
@@ -2977,7 +2965,7 @@ static void dump_esp_combs(struct sk_buff *skb, const struct xfrm_tmpl *t)
                                 continue;
                         if (!(aalg_tmpl_set(t, aalg) && aalg->available))
                                 continue;
-                        c = (struct sadb_comb*)skb_put(skb, sizeof(struct sadb_comb));
+                        c = skb_put(skb, sizeof(struct sadb_comb));
                         memset(c, 0, sizeof(*c));
                         p->sadb_prop_len += sizeof(struct sadb_comb)/8;
                         c->sadb_comb_auth = aalg->desc.sadb_alg_id;
@@ -3144,7 +3132,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
         if (skb == NULL)
                 return -ENOMEM;
 
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         hdr->sadb_msg_version = PF_KEY_V2;
         hdr->sadb_msg_type = SADB_ACQUIRE;
         hdr->sadb_msg_satype = pfkey_proto2satype(x->id.proto);
@@ -3155,8 +3143,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
         hdr->sadb_msg_pid = 0;
 
         /* src address */
-        addr = (struct sadb_address*) skb_put(skb,
-                                              sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -3171,8 +3158,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
                 BUG();
 
         /* dst address */
-        addr = (struct sadb_address*) skb_put(skb,
-                                              sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -3186,7 +3172,7 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
         if (!addr->sadb_address_prefixlen)
                 BUG();
 
-        pol = (struct sadb_x_policy *)  skb_put(skb, sizeof(struct sadb_x_policy));
+        pol = skb_put(skb, sizeof(struct sadb_x_policy));
         pol->sadb_x_policy_len = sizeof(struct sadb_x_policy)/sizeof(uint64_t);
         pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
         pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;
@@ -3203,8 +3189,8 @@ static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct
 
         /* security context */
         if (xfrm_ctx) {
-                sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb,
-                                sizeof(struct sadb_x_sec_ctx) + ctx_size);
+                sec_ctx = skb_put(skb,
+                                  sizeof(struct sadb_x_sec_ctx) + ctx_size);
                 sec_ctx->sadb_x_sec_len =
                   (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t);
                 sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
@@ -3346,7 +3332,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
         if (skb == NULL)
                 return -ENOMEM;
 
-        hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         hdr->sadb_msg_version = PF_KEY_V2;
         hdr->sadb_msg_type = SADB_X_NAT_T_NEW_MAPPING;
         hdr->sadb_msg_satype = satype;
@@ -3357,7 +3343,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
         hdr->sadb_msg_pid = 0;
 
         /* SA */
-        sa = (struct sadb_sa *) skb_put(skb, sizeof(struct sadb_sa));
+        sa = skb_put(skb, sizeof(struct sadb_sa));
         sa->sadb_sa_len = sizeof(struct sadb_sa)/sizeof(uint64_t);
         sa->sadb_sa_exttype = SADB_EXT_SA;
         sa->sadb_sa_spi = x->id.spi;
@@ -3368,8 +3354,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
         sa->sadb_sa_flags = 0;
 
         /* ADDRESS_SRC (old addr) */
-        addr = (struct sadb_address*)
-                skb_put(skb, sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -3384,15 +3369,14 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
                 BUG();
 
         /* NAT_T_SPORT (old port) */
-        n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+        n_port = skb_put(skb, sizeof(*n_port));
         n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
         n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_SPORT;
         n_port->sadb_x_nat_t_port_port = natt->encap_sport;
         n_port->sadb_x_nat_t_port_reserved = 0;
 
         /* ADDRESS_DST (new addr) */
-        addr = (struct sadb_address*)
-                skb_put(skb, sizeof(struct sadb_address)+sockaddr_size);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sockaddr_size);
         addr->sadb_address_len =
                 (sizeof(struct sadb_address)+sockaddr_size)/
                         sizeof(uint64_t);
@@ -3407,7 +3391,7 @@ static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
                 BUG();
 
         /* NAT_T_DPORT (new port) */
-        n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
+        n_port = skb_put(skb, sizeof(*n_port));
         n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
         n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_DPORT;
         n_port->sadb_x_nat_t_port_port = sport;
@@ -3421,7 +3405,7 @@ static int set_sadb_address(struct sk_buff *skb, int sasize, int type,
                             const struct xfrm_selector *sel)
 {
         struct sadb_address *addr;
-        addr = (struct sadb_address *)skb_put(skb, sizeof(struct sadb_address) + sasize);
+        addr = skb_put(skb, sizeof(struct sadb_address) + sasize);
         addr->sadb_address_len = (sizeof(struct sadb_address) + sasize)/8;
         addr->sadb_address_exttype = type;
         addr->sadb_address_proto = sel->proto;
@@ -3553,7 +3537,7 @@ static int pfkey_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
         if (skb == NULL)
                 return -ENOMEM;
 
-        hdr = (struct sadb_msg *)skb_put(skb, sizeof(struct sadb_msg));
+        hdr = skb_put(skb, sizeof(struct sadb_msg));
         hdr->sadb_msg_version = PF_KEY_V2;
         hdr->sadb_msg_type = SADB_X_MIGRATE;
         hdr->sadb_msg_satype = pfkey_proto2satype(m->proto);
@@ -3574,7 +3558,7 @@ static int pfkey_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
         set_sadb_address(skb, sasize_sel, SADB_EXT_ADDRESS_DST, sel);
 
         /* policy information */
-        pol = (struct sadb_x_policy *)skb_put(skb, sizeof(struct sadb_x_policy));
+        pol = skb_put(skb, sizeof(struct sadb_x_policy));
         pol->sadb_x_policy_len = size_pol / 8;
         pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
         pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;