extern void xfrm_state_delete_tunnel(struct xfrm_state *x);
 
-struct xfrm_decap_state;
 struct xfrm_type
 {
        char                    *description;
 
 extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 
-/* Decapsulation state, used by the input to store data during
- * decapsulation procedure, to be used later (during the policy
- * check
- */
-struct xfrm_decap_state {
-       char    decap_data[20];
-       __u16   decap_type;
-};   
-
-struct sec_decap_state {
-       struct xfrm_state       *xvec;
-       struct xfrm_decap_state decap;
-};
-
 struct sec_path
 {
        atomic_t                refcnt;
        int                     len;
-       struct sec_decap_state  x[XFRM_MAX_DEPTH];
+       struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
 };
 
 static inline struct sec_path *
 
 {
        int err;
        u32 spi, seq;
-       struct sec_decap_state xfrm_vec[XFRM_MAX_DEPTH];
+       struct xfrm_state *xfrm_vec[XFRM_MAX_DEPTH];
        struct xfrm_state *x;
        int xfrm_nr = 0;
        int decaps = 0;
                if (xfrm_state_check_expire(x))
                        goto drop_unlock;
 
-               xfrm_vec[xfrm_nr].decap.decap_type = encap_type;
                if (x->type->input(x, skb))
                        goto drop_unlock;
 
 
                spin_unlock(&x->lock);
 
-               xfrm_vec[xfrm_nr++].xvec = x;
+               xfrm_vec[xfrm_nr++] = x;
 
                iph = skb->nh.iph;
 
        if (xfrm_nr + skb->sp->len > XFRM_MAX_DEPTH)
                goto drop;
 
-       memcpy(skb->sp->x+skb->sp->len, xfrm_vec, xfrm_nr*sizeof(struct sec_decap_state));
+       memcpy(skb->sp->xvec + skb->sp->len, xfrm_vec,
+              xfrm_nr * sizeof(xfrm_vec[0]));
        skb->sp->len += xfrm_nr;
 
        nf_reset(skb);
        xfrm_state_put(x);
 drop:
        while (--xfrm_nr >= 0)
-               xfrm_state_put(xfrm_vec[xfrm_nr].xvec);
+               xfrm_state_put(xfrm_vec[xfrm_nr]);
 
        kfree_skb(skb);
        return 0;
 
 {
        int err;
        u32 seq;
-       struct sec_decap_state xfrm_vec[XFRM_MAX_DEPTH];
+       struct xfrm_state *xfrm_vec[XFRM_MAX_DEPTH];
        struct xfrm_state *x;
        int xfrm_nr = 0;
        int decaps = 0;
 
                spin_unlock(&x->lock);
 
-               xfrm_vec[xfrm_nr++].xvec = x;
+               xfrm_vec[xfrm_nr++] = x;
 
                if (x->props.mode) { /* XXX */
                        if (nexthdr != IPPROTO_IPV6)
        if (xfrm_nr + skb->sp->len > XFRM_MAX_DEPTH)
                goto drop;
 
-       memcpy(skb->sp->x+skb->sp->len, xfrm_vec, xfrm_nr*sizeof(struct sec_decap_state));
+       memcpy(skb->sp->xvec + skb->sp->len, xfrm_vec,
+              xfrm_nr * sizeof(xfrm_vec[0]));
        skb->sp->len += xfrm_nr;
        skb->ip_summed = CHECKSUM_NONE;
 
        xfrm_state_put(x);
 drop:
        while (--xfrm_nr >= 0)
-               xfrm_state_put(xfrm_vec[xfrm_nr].xvec);
+               xfrm_state_put(xfrm_vec[xfrm_nr]);
        kfree_skb(skb);
        return -1;
 }
 
                        return 0;
                e = &info->pol[pos];
 
-               if (match_xfrm_state(sp->x[i].xvec, e, family)) {
+               if (match_xfrm_state(sp->xvec[i], e, family)) {
                        if (!strict)
                                return 1;
                } else if (strict)
 
 {
        int i;
        for (i = 0; i < sp->len; i++)
-               xfrm_state_put(sp->x[i].xvec);
+               xfrm_state_put(sp->xvec[i]);
        kmem_cache_free(secpath_cachep, sp);
 }
 EXPORT_SYMBOL(__secpath_destroy);
 
                memcpy(sp, src, sizeof(*sp));
                for (i = 0; i < sp->len; i++)
-                       xfrm_state_hold(sp->x[i].xvec);
+                       xfrm_state_hold(sp->xvec[i]);
        }
        atomic_set(&sp->refcnt, 1);
        return sp;
 
        } else
                start = -1;
        for (; idx < sp->len; idx++) {
-               if (xfrm_state_ok(tmpl, sp->x[idx].xvec, family))
+               if (xfrm_state_ok(tmpl, sp->xvec[idx], family))
                        return ++idx;
-               if (sp->x[idx].xvec->props.mode)
+               if (sp->xvec[idx]->props.mode)
                        break;
        }
        return start;
 static inline int secpath_has_tunnel(struct sec_path *sp, int k)
 {
        for (; k < sp->len; k++) {
-               if (sp->x[k].xvec->props.mode)
+               if (sp->xvec[k]->props.mode)
                        return 1;
        }
 
                int i;
 
                for (i=skb->sp->len-1; i>=0; i--) {
-                       struct sec_decap_state *xvec = &(skb->sp->x[i]);
-                       if (!xfrm_selector_match(&xvec->xvec->sel, &fl, family))
+                       struct xfrm_state *x = skb->sp->xvec[i];
+                       if (!xfrm_selector_match(&x->sel, &fl, family))
                                return 0;
                }
        }