xnu-2422.115.4.tar.gz

[apple/xnu.git] / bsd / netinet6 / ipcomp_input.c

diff --git a/bsd/netinet6/ipcomp_input.c b/bsd/netinet6/ipcomp_input.c
index 43039d9c7ec00637cae16123e15c7bca005f06af..c3b33030576d09d633828465d9e72e3a76011b8e 100644 (file)
--- a/bsd/netinet6/ipcomp_input.c
+++ b/bsd/netinet6/ipcomp_input.c
@@ -1,4 +1,5 @@
-/*     $KAME: ipcomp_input.c,v 1.11 2000/02/22 14:04:23 itojun Exp $   */
+/*     $FreeBSD: src/sys/netinet6/ipcomp_input.c,v 1.1.2.2 2001/07/03 11:01:54 ume Exp $       */
+/*     $KAME: ipcomp_input.c,v 1.25 2001/03/01 09:12:09 itojun Exp $   */

 
 /*
  * Copyright (C) 1999 WIDE Project.
 
 /*
  * Copyright (C) 1999 WIDE Project.


@@ -33,15 +34,12 @@
  * RFC2393 IP payload compression protocol (IPComp).
  */
 
  * RFC2393 IP payload compression protocol (IPComp).
  */
 

-#define _IP_VHL
-#if (defined(__FreeBSD__) && __FreeBSD__ >= 3) || defined(__NetBSD__)
-#include "opt_inet.h"
-#endif

 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>

+#include <sys/mcache.h>

 #include <sys/domain.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/domain.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>


@@ -52,9 +50,9 @@
 
 #include <net/if.h>
 #include <net/route.h>
 
 #include <net/if.h>
 #include <net/route.h>

-#include <net/netisr.h>
-#include <net/zlib.h>
+#include <libkern/zlib.h>

 #include <kern/cpu_number.h>
 #include <kern/cpu_number.h>

+#include <kern/locks.h>

 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>


@@ -62,35 +60,36 @@
 #include <netinet/ip.h>
 #include <netinet/ip_var.h>
 #include <netinet/ip_ecn.h>
 #include <netinet/ip.h>
 #include <netinet/ip_var.h>
 #include <netinet/ip_ecn.h>

+#include <netinet/kpi_ipfilter_var.h>

 
 #if INET6
 #include <netinet/ip6.h>
 #include <netinet6/ip6_var.h>
 #endif
 #include <netinet6/ipcomp.h>
 
 #if INET6
 #include <netinet/ip6.h>
 #include <netinet6/ip6_var.h>
 #endif
 #include <netinet6/ipcomp.h>

+#if INET6
+#include <netinet6/ipcomp6.h>
+#endif

 
 #include <netinet6/ipsec.h>
 
 #include <netinet6/ipsec.h>

+#if INET6
+#include <netinet6/ipsec6.h>
+#endif

 #include <netkey/key.h>
 #include <netkey/keydb.h>
 #include <netkey/key.h>
 #include <netkey/keydb.h>

-#include <netkey/key_debug.h>

 
 #include <net/net_osdep.h>
 
 #include <net/net_osdep.h>

+#include <mach/sdt.h>

 
 #define IPLEN_FLIPPED
 
 
 #define IPLEN_FLIPPED
 

-
-#if INET
-extern struct protosw * ip_protox[];
-#if defined(__bsdi__) || defined(__NetBSD__)
-extern u_char ip_protox[];
-#endif
-

 void
 ipcomp4_input(struct mbuf *m, int off)
 {
 void
 ipcomp4_input(struct mbuf *m, int off)
 {

+       struct mbuf *md;

        struct ip *ip;
        struct ipcomp *ipcomp;
        struct ip *ip;
        struct ipcomp *ipcomp;

-       struct ipcomp_algorithm *algo;
+       const struct ipcomp_algorithm *algo;

        u_int16_t cpi;  /* host order */
        u_int16_t nxt;
        size_t hlen;
        u_int16_t cpi;  /* host order */
        u_int16_t nxt;
        size_t hlen;


@@ -98,43 +97,27 @@ ipcomp4_input(struct mbuf *m, int off)
        size_t newlen, olen;
        struct secasvar *sav = NULL;
 
        size_t newlen, olen;
        struct secasvar *sav = NULL;
 

-
-       if (off + sizeof(struct ipcomp) > MHLEN) {
-               /*XXX the restriction should be relaxed*/
+       if (m->m_pkthdr.len < off + sizeof(struct ipcomp)) {

                ipseclog((LOG_DEBUG, "IPv4 IPComp input: assumption failed "
                ipseclog((LOG_DEBUG, "IPv4 IPComp input: assumption failed "

-                   "(header too long)\n"));
-               ipsecstat.in_inval++;
+                   "(packet too short)\n"));
+               IPSEC_STAT_INCREMENT(ipsecstat.in_inval);

                goto fail;
        }
                goto fail;
        }

-       if (m->m_len < off + sizeof(struct ipcomp)) {
-               m = m_pullup(m, off + sizeof(struct ipcomp));
-               if (!m) {
-                       ipseclog((LOG_DEBUG, "IPv4 IPComp input: can't pullup;"
-                               "dropping the packet for simplicity\n"));
-                       ipsecstat.in_nomem++;
-                       goto fail;
-               }
-       } else if (m->m_len > off + sizeof(struct ipcomp)) {
-               /* chop header part from the packet header chain */
-               struct mbuf *n;
-               MGETHDR(n, M_DONTWAIT, MT_HEADER);
-               if (!n) {
-                       ipsecstat.in_nomem++;
-                       goto fail;
-               }
-               M_COPY_PKTHDR(n, m);
-               MH_ALIGN(n, off + sizeof(struct ipcomp));
-               n->m_len = off + sizeof(struct ipcomp);
-               bcopy(mtod(m, caddr_t), mtod(n, caddr_t),
-                       off + sizeof(struct ipcomp));
-               m_adj(m, off + sizeof(struct ipcomp));
-               m->m_flags &= ~M_PKTHDR;
-               n->m_next = m;
-               m = n;
+
+       md = m_pulldown(m, off, sizeof(*ipcomp), NULL);
+       if (!md) {
+               m = NULL;       /*already freed*/
+               ipseclog((LOG_DEBUG, "IPv4 IPComp input: assumption failed "
+                   "(pulldown failure)\n"));
+               IPSEC_STAT_INCREMENT(ipsecstat.in_inval);
+               goto fail;

        }
        }

+       ipcomp = mtod(md, struct ipcomp *);
+
+       /* Expect 32-bit aligned data pointer on strict-align platforms */
+       MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);

 
        ip = mtod(m, struct ip *);
 
        ip = mtod(m, struct ip *);

-       ipcomp = (struct ipcomp *)(((caddr_t)ip) + off);

        nxt = ipcomp->comp_nxt;
 #ifdef _IP_VHL
        hlen = IP_VHL_HL(ip->ip_vhl) << 2;
        nxt = ipcomp->comp_nxt;
 #ifdef _IP_VHL
        hlen = IP_VHL_HL(ip->ip_vhl) << 2;


@@ -154,20 +137,18 @@ ipcomp4_input(struct mbuf *m, int off)
                        /* other parameters to look at? */
                }
        }
                        /* other parameters to look at? */
                }
        }

-       if (cpi < IPCOMP_MAX && ipcomp_algorithms[cpi].decompress != NULL)
-               algo = &ipcomp_algorithms[cpi];
-       else
-               algo = NULL;
+       algo = ipcomp_algorithm_lookup(cpi);

        if (!algo) {
                ipseclog((LOG_WARNING, "IPv4 IPComp input: unknown cpi %u\n",
                        cpi));
        if (!algo) {
                ipseclog((LOG_WARNING, "IPv4 IPComp input: unknown cpi %u\n",
                        cpi));

-               ipsecstat.in_nosa++;
+               IPSEC_STAT_INCREMENT(ipsecstat.in_nosa);

                goto fail;
        }
 
        /* chop ipcomp header */
        ipcomp = NULL;
                goto fail;
        }
 
        /* chop ipcomp header */
        ipcomp = NULL;

-       m->m_len -= sizeof(struct ipcomp);
+       md->m_data += sizeof(struct ipcomp);
+       md->m_len -= sizeof(struct ipcomp);

        m->m_pkthdr.len -= sizeof(struct ipcomp);
 #ifdef IPLEN_FLIPPED
        ip->ip_len -= sizeof(struct ipcomp);
        m->m_pkthdr.len -= sizeof(struct ipcomp);
 #ifdef IPLEN_FLIPPED
        ip->ip_len -= sizeof(struct ipcomp);


@@ -179,14 +160,14 @@ ipcomp4_input(struct mbuf *m, int off)
        newlen = m->m_pkthdr.len - off;
        error = (*algo->decompress)(m, m->m_next, &newlen);
        if (error != 0) {
        newlen = m->m_pkthdr.len - off;
        error = (*algo->decompress)(m, m->m_next, &newlen);
        if (error != 0) {

-               if (error == EINVAL)
-                       ipsecstat.in_inval++;
-               else if (error == ENOBUFS)
-                       ipsecstat.in_nomem++;
+               if (error == EINVAL) {
+                       IPSEC_STAT_INCREMENT(ipsecstat.in_inval);
+               } else if (error == ENOBUFS)
+                       IPSEC_STAT_INCREMENT(ipsecstat.in_nomem);

                m = NULL;
                goto fail;
        }
                m = NULL;
                goto fail;
        }

-       ipsecstat.in_comphist[cpi]++;
+       IPSEC_STAT_INCREMENT(ipsecstat.in_comphist[cpi]);

 
        /*
         * returning decompressed packet onto icmp is meaningless.
 
        /*
         * returning decompressed packet onto icmp is meaningless.


@@ -211,7 +192,7 @@ ipcomp4_input(struct mbuf *m, int off)
        len -= olen;
        if (len & ~0xffff) {
                /* packet too big after decompress */
        len -= olen;
        if (len & ~0xffff) {
                /* packet too big after decompress */

-               ipsecstat.in_inval++;
+               IPSEC_STAT_INCREMENT(ipsecstat.in_inval);

                goto fail;
        }
 #ifdef IPLEN_FLIPPED
                goto fail;
        }
 #ifdef IPLEN_FLIPPED


@@ -224,97 +205,78 @@ ipcomp4_input(struct mbuf *m, int off)
 
        if (sav) {
                key_sa_recordxfer(sav, m);
 
        if (sav) {
                key_sa_recordxfer(sav, m);

-               key_freesav(sav);
+               if (ipsec_addhist(m, IPPROTO_IPCOMP, (u_int32_t)cpi) != 0) {
+                       IPSEC_STAT_INCREMENT(ipsecstat.in_nomem);
+                       goto fail;
+               }
+               key_freesav(sav, KEY_SADB_UNLOCKED);

                sav = NULL;
        }
 
                sav = NULL;
        }
 

-       if (nxt != IPPROTO_DONE)
-               (*ip_protox[nxt]->pr_input)(m, off);
-       else
+       if (nxt != IPPROTO_DONE) {
+               if ((ip_protox[nxt]->pr_flags & PR_LASTHDR) != 0 &&
+                   ipsec4_in_reject(m, NULL)) {
+                       IPSEC_STAT_INCREMENT(ipsecstat.in_polvio);
+                       goto fail;
+               }
+
+               DTRACE_IP6(receive, struct mbuf *, m, struct inpcb *, NULL,
+                        struct ip *, ip, struct ifnet *, m->m_pkthdr.rcvif,
+                        struct ip *, ip, struct ip6_hdr *, NULL);
+
+               ip_proto_dispatch_in(m, off, nxt, 0);
+       } else

                m_freem(m);
        m = NULL;
 
                m_freem(m);
        m = NULL;
 

-       ipsecstat.in_success++;
+       IPSEC_STAT_INCREMENT(ipsecstat.in_success);

        return;
 
 fail:
        if (sav)
        return;
 
 fail:
        if (sav)

-               key_freesav(sav);
+               key_freesav(sav, KEY_SADB_UNLOCKED);
+

        if (m)
                m_freem(m);
        return;
 }
        if (m)
                m_freem(m);
        return;
 }

-#endif /* INET */

 
 #if INET6
 int
 
 #if INET6
 int

-ipcomp6_input(mp, offp)
-       struct mbuf **mp;
-       int *offp;
+ipcomp6_input(struct mbuf **mp, int *offp, int proto)

 {
 {

+#pragma unused(proto)

        struct mbuf *m, *md;
        int off;
        struct ip6_hdr *ip6;
        struct mbuf *m, *md;
        int off;
        struct ip6_hdr *ip6;

-       struct mbuf *ipcompm;

        struct ipcomp *ipcomp;
        struct ipcomp *ipcomp;

-       struct ipcomp_algorithm *algo;
+       const struct ipcomp_algorithm *algo;

        u_int16_t cpi;  /* host order */
        u_int16_t nxt;
        int error;
        size_t newlen;
        struct secasvar *sav = NULL;
        u_int16_t cpi;  /* host order */
        u_int16_t nxt;
        int error;
        size_t newlen;
        struct secasvar *sav = NULL;

+       char *prvnxtp;

 
        m = *mp;
        off = *offp;
 
 
        m = *mp;
        off = *offp;
 

-       IP6_EXTHDR_CHECK(m, off, sizeof(struct ipcomp), IPPROTO_DONE);
-
-    {
-       int skip;
-       struct mbuf *n;
-       struct mbuf *p, *q;
-       size_t l;
-
-       skip = off;
-       for (n = m; n && skip > 0; n = n->m_next) {
-               if (n->m_len <= skip) {
-                       skip -= n->m_len;
-                       continue;
-               }
-               break;
-       }
-       if (!n) {
-               ipseclog((LOG_DEBUG, "IPv6 IPComp input: wrong mbuf chain\n"));
-               ipsecstat.in_inval++;
-               goto fail;
-       }
-       if (n->m_len < skip + sizeof(struct ipcomp)) {
-               ipseclog((LOG_DEBUG, "IPv6 IPComp input: wrong mbuf chain\n"));
-               ipsecstat.in_inval++;
+       md = m_pulldown(m, off, sizeof(*ipcomp), NULL);
+       if (!md) {
+               m = NULL;       /*already freed*/
+               ipseclog((LOG_DEBUG, "IPv6 IPComp input: assumption failed "
+                   "(pulldown failure)\n"));
+               IPSEC_STAT_INCREMENT(ipsec6stat.in_inval);

                goto fail;
        }
                goto fail;
        }

-       ip6 = mtod(m, struct ip6_hdr *);
-       ipcompm = n;
-       ipcomp = (struct ipcomp *)(mtod(n, caddr_t) + skip);
-       if (n->m_len > skip + sizeof(struct ipcomp)) {
-               /* split mbuf to ease the following steps*/
-               l = n->m_len - (skip + sizeof(struct ipcomp));
-               p = m_copym(n, skip + sizeof(struct ipcomp), l , M_DONTWAIT);
-               if (!p) {
-                       ipsecstat.in_nomem++;
-                       goto fail;
-               }
-               for (q = p; q && q->m_next; q = q->m_next)
-                       ;
-               q->m_next = n->m_next;
-               n->m_next = p;
-               n->m_len -= l;
-               md = p;
-       } else
-               md = n->m_next;
-    }
+       ipcomp = mtod(md, struct ipcomp *);

 
 

+       /* Expect 32-bit aligned data pointer on strict-align platforms */
+       MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
+
+       ip6 = mtod(m, struct ip6_hdr *);

        nxt = ipcomp->comp_nxt;
        nxt = ipcomp->comp_nxt;

+

        cpi = ntohs(ipcomp->comp_cpi);
 
        if (cpi >= IPCOMP_CPI_NEGOTIATE_MIN) {
        cpi = ntohs(ipcomp->comp_cpi);
 
        if (cpi >= IPCOMP_CPI_NEGOTIATE_MIN) {


@@ -327,29 +289,32 @@ ipcomp6_input(mp, offp)
                        /* other parameters to look at? */
                }
        }
                        /* other parameters to look at? */
                }
        }

-       if (cpi < IPCOMP_MAX && ipcomp_algorithms[cpi].decompress != NULL)
-               algo = &ipcomp_algorithms[cpi];
-       else
-               algo = NULL;
+       algo = ipcomp_algorithm_lookup(cpi);

        if (!algo) {
                ipseclog((LOG_WARNING, "IPv6 IPComp input: unknown cpi %u; "
                        "dropping the packet for simplicity\n", cpi));
        if (!algo) {
                ipseclog((LOG_WARNING, "IPv6 IPComp input: unknown cpi %u; "
                        "dropping the packet for simplicity\n", cpi));

-               ipsec6stat.in_nosa++;
+               IPSEC_STAT_INCREMENT(ipsec6stat.in_nosa);

                goto fail;
        }
 
                goto fail;
        }
 

-       newlen = m->m_pkthdr.len - off - sizeof(struct ipcomp);
+       /* chop ipcomp header */
+       ipcomp = NULL;
+       md->m_data += sizeof(struct ipcomp);
+       md->m_len -= sizeof(struct ipcomp);
+       m->m_pkthdr.len -= sizeof(struct ipcomp);
+
+       newlen = m->m_pkthdr.len - off;

        error = (*algo->decompress)(m, md, &newlen);
        if (error != 0) {
        error = (*algo->decompress)(m, md, &newlen);
        if (error != 0) {

-               if (error == EINVAL)
-                       ipsec6stat.in_inval++;
-               else if (error == ENOBUFS)
-                       ipsec6stat.in_nomem++;
+               if (error == EINVAL) {
+                       IPSEC_STAT_INCREMENT(ipsec6stat.in_inval);
+               } else if (error == ENOBUFS)
+                       IPSEC_STAT_INCREMENT(ipsec6stat.in_nomem);

                m = NULL;
                goto fail;
        }
                m = NULL;
                goto fail;
        }

-       ipsec6stat.in_comphist[cpi]++;
-       m->m_pkthdr.len = off + sizeof(struct ipcomp) + newlen;
+       IPSEC_STAT_INCREMENT(ipsec6stat.in_comphist[cpi]);
+       m->m_pkthdr.len = off + newlen;

 
        /*
         * returning decompressed packet onto icmp is meaningless.
 
        /*
         * returning decompressed packet onto icmp is meaningless.


@@ -357,38 +322,34 @@ ipcomp6_input(mp, offp)
         */
        m->m_flags |= M_DECRYPTED;
 
         */
        m->m_flags |= M_DECRYPTED;
 

-    {
-       char *prvnxtp;
-
-       /* chop IPComp header */
+       /* update next header field */

        prvnxtp = ip6_get_prevhdr(m, off);
        *prvnxtp = nxt;
        prvnxtp = ip6_get_prevhdr(m, off);
        *prvnxtp = nxt;

-       ipcompm->m_len -= sizeof(struct ipcomp);
-       ipcompm->m_pkthdr.len -= sizeof(struct ipcomp);

 
 

-       /* adjust payload length */
-       ip6 = mtod(m, struct ip6_hdr *);
-       if (((m->m_pkthdr.len - sizeof(struct ip6_hdr)) & ~0xffff) != 0)
-               ip6->ip6_plen = 0;      /*now a jumbogram*/
-       else
-               ip6->ip6_plen = htons(m->m_pkthdr.len - sizeof(struct ip6_hdr));
-    }
+       /*
+        * no need to adjust payload length, as all the IPv6 protocols
+        * look at m->m_pkthdr.len
+        */

 
        if (sav) {
                key_sa_recordxfer(sav, m);
 
        if (sav) {
                key_sa_recordxfer(sav, m);

-               key_freesav(sav);
+               if (ipsec_addhist(m, IPPROTO_IPCOMP, (u_int32_t)cpi) != 0) {
+                       IPSEC_STAT_INCREMENT(ipsec6stat.in_nomem);
+                       goto fail;
+               }
+               key_freesav(sav, KEY_SADB_UNLOCKED);

                sav = NULL;
        }
        *offp = off;
        *mp = m;
                sav = NULL;
        }
        *offp = off;
        *mp = m;

-       ipsec6stat.in_success++;
+       IPSEC_STAT_INCREMENT(ipsec6stat.in_success);

        return nxt;
 
 fail:
        if (m)
                m_freem(m);
        if (sav)
        return nxt;
 
 fail:
        if (m)
                m_freem(m);
        if (sav)

-               key_freesav(sav);
+               key_freesav(sav, KEY_SADB_UNLOCKED);

        return IPPROTO_DONE;
 }
 #endif /* INET6 */
        return IPPROTO_DONE;
 }
 #endif /* INET6 */