Merge git://oss.sgi.com:8090/xfs/xfs-2.6

[linux-drm-fsl-dcu.git] / net / ipv4 / ah4.c

diff --git a/net/ipv4/ah4.c b/net/ipv4/ah4.c
index 1366bc6ce6a5cfc968d5a45a930e3742dbb6fb53..7194eb40b6d08cbd2304fb8dd8d9eb415b9a73de 100644 (file)
--- a/net/ipv4/ah4.c
+++ b/net/ipv4/ah4.c
@@ -1,3 +1,4 @@
+#include <linux/err.h>
 #include <linux/module.h>
 #include <net/ip.h>
 #include <net/xfrm.h>
@@ -13,7 +14,7 @@
  * into IP header for icv calculation. Options are already checked
  * for validity, so paranoia is not required. */
 
-static int ip_clear_mutable_options(struct iphdr *iph, u32 *daddr)
+static int ip_clear_mutable_options(struct iphdr *iph, __be32 *daddr)
 {
        unsigned char * optptr = (unsigned char*)(iph+1);
        int  l = iph->ihl*4 - sizeof(struct iphdr);
@@ -34,7 +35,7 @@ static int ip_clear_mutable_options(struct iphdr *iph, u32 *daddr)
                switch (*optptr) {
                case IPOPT_SEC:
                case 0x85:      /* Some "Extended Security" crap. */
-               case 0x86:      /* Another "Commercial Security" crap. */
+               case IPOPT_CIPSO:
                case IPOPT_RA:
                case 0x80|21:   /* RFC1770 */
                        break;
@@ -90,14 +91,17 @@ static int ah_output(struct xfrm_state *x, struct sk_buff *skb)
        top_iph->check = 0;
 
        ahp = x->data;
-       ah->hdrlen  = (XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + 
+       ah->hdrlen  = (XFRM_ALIGN8(sizeof(struct ip_auth_hdr) +
                                   ahp->icv_trunc_len) >> 2) - 2;
 
        ah->reserved = 0;
        ah->spi = x->id.spi;
        ah->seq_no = htonl(++x->replay.oseq);
        xfrm_aevent_doreplay(x);
-       ahp->icv(ahp, skb, ah->auth_data);
+       err = ah_mac_digest(ahp, skb, ah->auth_data);
+       if (err)
+               goto error;
+       memcpy(ah->auth_data, ahp->work_icv, ahp->icv_trunc_len);
 
        top_iph->tos = iph->tos;
        top_iph->ttl = iph->ttl;
@@ -119,6 +123,7 @@ static int ah_input(struct xfrm_state *x, struct sk_buff *skb)
 {
        int ah_hlen;
        int ihl;
+       int err = -EINVAL;
        struct iphdr *iph;
        struct ip_auth_hdr *ah;
        struct ah_data *ahp;
@@ -130,9 +135,9 @@ static int ah_input(struct xfrm_state *x, struct sk_buff *skb)
        ah = (struct ip_auth_hdr*)skb->data;
        ahp = x->data;
        ah_hlen = (ah->hdrlen + 2) << 2;
-       
+
        if (ah_hlen != XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + ahp->icv_full_len) &&
-           ah_hlen != XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + ahp->icv_trunc_len)) 
+           ah_hlen != XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + ahp->icv_trunc_len))
                goto out;
 
        if (!pskb_may_pull(skb, ah_hlen))
@@ -157,17 +162,20 @@ static int ah_input(struct xfrm_state *x, struct sk_buff *skb)
        iph->frag_off = 0;
        iph->check = 0;
        if (ihl > sizeof(*iph)) {
-               u32 dummy;
+               __be32 dummy;
                if (ip_clear_mutable_options(iph, &dummy))
                        goto out;
        }
-        {
+       {
                u8 auth_data[MAX_AH_AUTH_LEN];
-               
+
                memcpy(auth_data, ah->auth_data, ahp->icv_trunc_len);
                skb_push(skb, ihl);
-               ahp->icv(ahp, skb, ah->auth_data);
-               if (memcmp(ah->auth_data, auth_data, ahp->icv_trunc_len)) {
+               err = ah_mac_digest(ahp, skb, ah->auth_data);
+               if (err)
+                       goto out;
+               err = -EINVAL;
+               if (memcmp(ahp->work_icv, auth_data, ahp->icv_trunc_len)) {
                        x->stats.integrity_failed++;
                        goto out;
                }
@@ -179,7 +187,7 @@ static int ah_input(struct xfrm_state *x, struct sk_buff *skb)
        return 0;
 
 out:
-       return -EINVAL;
+       return err;
 }
 
 static void ah4_err(struct sk_buff *skb, u32 info)
@@ -204,6 +212,7 @@ static int ah_init_state(struct xfrm_state *x)
 {
        struct ah_data *ahp = NULL;
        struct xfrm_algo_desc *aalg_desc;
+       struct crypto_hash *tfm;
 
        if (!x->aalg)
                goto error;
@@ -221,39 +230,42 @@ static int ah_init_state(struct xfrm_state *x)
 
        ahp->key = x->aalg->alg_key;
        ahp->key_len = (x->aalg->alg_key_len+7)/8;
-       ahp->tfm = crypto_alloc_tfm(x->aalg->alg_name, 0);
-       if (!ahp->tfm)
+       tfm = crypto_alloc_hash(x->aalg->alg_name, 0, CRYPTO_ALG_ASYNC);
+       if (IS_ERR(tfm))
                goto error;
-       ahp->icv = ah_hmac_digest;
-       
+
+       ahp->tfm = tfm;
+       if (crypto_hash_setkey(tfm, ahp->key, ahp->key_len))
+               goto error;
+
        /*
         * Lookup the algorithm description maintained by xfrm_algo,
         * verify crypto transform properties, and store information
         * we need for AH processing.  This lookup cannot fail here
-        * after a successful crypto_alloc_tfm().
+        * after a successful crypto_alloc_hash().
         */
        aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0);
        BUG_ON(!aalg_desc);
 
        if (aalg_desc->uinfo.auth.icv_fullbits/8 !=
-           crypto_tfm_alg_digestsize(ahp->tfm)) {
+           crypto_hash_digestsize(tfm)) {
                printk(KERN_INFO "AH: %s digestsize %u != %hu\n",
-                      x->aalg->alg_name, crypto_tfm_alg_digestsize(ahp->tfm),
+                      x->aalg->alg_name, crypto_hash_digestsize(tfm),
                       aalg_desc->uinfo.auth.icv_fullbits/8);
                goto error;
        }
-       
+
        ahp->icv_full_len = aalg_desc->uinfo.auth.icv_fullbits/8;
        ahp->icv_trunc_len = aalg_desc->uinfo.auth.icv_truncbits/8;
-       
+
        BUG_ON(ahp->icv_trunc_len > MAX_AH_AUTH_LEN);
-       
+
        ahp->work_icv = kmalloc(ahp->icv_full_len, GFP_KERNEL);
        if (!ahp->work_icv)
                goto error;
-       
+
        x->props.header_len = XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + ahp->icv_trunc_len);
-       if (x->props.mode)
+       if (x->props.mode == XFRM_MODE_TUNNEL)
                x->props.header_len += sizeof(struct iphdr);
        x->data = ahp;
 
@@ -262,7 +274,7 @@ static int ah_init_state(struct xfrm_state *x)
 error:
        if (ahp) {
                kfree(ahp->work_icv);
-               crypto_free_tfm(ahp->tfm);
+               crypto_free_hash(ahp->tfm);
                kfree(ahp);
        }
        return -EINVAL;
@@ -277,7 +289,7 @@ static void ah_destroy(struct xfrm_state *x)
 
        kfree(ahp->work_icv);
        ahp->work_icv = NULL;
-       crypto_free_tfm(ahp->tfm);
+       crypto_free_hash(ahp->tfm);
        ahp->tfm = NULL;
        kfree(ahp);
 }