sys/netipsec/xform_ipcomp.c

   1 /*      $FreeBSD$       */
   2 /* $OpenBSD: ip_ipcomp.c,v 1.1 2001/07/05 12:08:52 jjbg Exp $ */
   3
   4 /*-
   5  * SPDX-License-Identifier: BSD-3-Clause
   6  *
   7  * Copyright (c) 2001 Jean-Jacques Bernard-Gundol (jj@wabbitt.org)
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *   notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *   notice, this list of conditions and the following disclaimer in the
  17  *   documentation and/or other materials provided with the distribution.
  18  * 3. The name of the author may not be used to endorse or promote products
  19  *   derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /* IP payload compression protocol (IPComp), see RFC 2393 */
  34 #include "opt_inet.h"
  35 #include "opt_inet6.h"
  36 #include "opt_ipsec.h"
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/mbuf.h>
  41 #include <sys/lock.h>
  42 #include <sys/mutex.h>
  43 #include <sys/socket.h>
  44 #include <sys/kernel.h>
  45 #include <sys/protosw.h>
  46 #include <sys/sysctl.h>
  47
  48 #include <netinet/in.h>
  49 #include <netinet/in_systm.h>
  50 #include <netinet/ip.h>
  51 #include <netinet/ip_var.h>
  52 #include <netinet/ip_encap.h>
  53
  54 #include <net/netisr.h>
  55 #include <net/vnet.h>
  56 #include <net/if.h>     /* XXXGL: net_epoch should move out there */
  57 #include <net/if_var.h> /* XXXGL: net_epoch should move out there */
  58
  59 #include <netipsec/ipsec.h>
  60 #include <netipsec/xform.h>
  61
  62 #ifdef INET6
  63 #include <netinet/ip6.h>
  64 #include <netinet6/ip6_var.h>
  65 #include <netipsec/ipsec6.h>
  66 #endif
  67
  68 #include <netipsec/ipcomp.h>
  69 #include <netipsec/ipcomp_var.h>
  70
  71 #include <netipsec/key.h>
  72 #include <netipsec/key_debug.h>
  73
  74 #include <opencrypto/cryptodev.h>
  75 #include <opencrypto/deflate.h>
  76 #include <opencrypto/xform.h>
  77
  78 VNET_DEFINE(int, ipcomp_enable) = 1;
  79 VNET_PCPUSTAT_DEFINE(struct ipcompstat, ipcompstat);
  80 VNET_PCPUSTAT_SYSINIT(ipcompstat);
  81
  82 #ifdef VIMAGE
  83 VNET_PCPUSTAT_SYSUNINIT(ipcompstat);
  84 #endif /* VIMAGE */
  85
  86 SYSCTL_DECL(_net_inet_ipcomp);
  87 SYSCTL_INT(_net_inet_ipcomp, OID_AUTO, ipcomp_enable,
  88         CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(ipcomp_enable), 0, "");
  89 SYSCTL_VNET_PCPUSTAT(_net_inet_ipcomp, IPSECCTL_STATS, stats,
  90     struct ipcompstat, ipcompstat,
  91     "IPCOMP statistics (struct ipcompstat, netipsec/ipcomp_var.h");
  92
  93 static int ipcomp_input_cb(struct cryptop *crp);
  94 static int ipcomp_output_cb(struct cryptop *crp);
  95
  96 /*
  97  * RFC 3173 p 2.2. Non-Expansion Policy:
  98  * If the total size of a compressed payload and the IPComp header, as
  99  * defined in section 3, is not smaller than the size of the original
 100  * payload, the IP datagram MUST be sent in the original non-compressed
 101  * form.
 102  *
 103  * When we use IPComp in tunnel mode, for small packets we will receive
 104  * encapsulated IP-IP datagrams without any compression and without IPComp
 105  * header.
 106  */
 107 static int
 108 ipcomp_encapcheck(union sockaddr_union *src, union sockaddr_union *dst)
 109 {
 110         struct secasvar *sav;
 111
 112         sav = key_allocsa_tunnel(src, dst, IPPROTO_IPCOMP);
 113         if (sav == NULL)
 114                 return (0);
 115         key_freesav(&sav);
 116
 117         if (src->sa.sa_family == AF_INET)
 118                 return (sizeof(struct in_addr) << 4);
 119         else
 120                 return (sizeof(struct in6_addr) << 4);
 121 }
 122
 123 static int
 124 ipcomp_nonexp_input(struct mbuf *m, int off, int proto, void *arg __unused)
 125 {
 126         int isr;
 127
 128         NET_EPOCH_ASSERT();
 129
 130         switch (proto) {
 131 #ifdef INET
 132         case IPPROTO_IPV4:
 133                 isr = NETISR_IP;
 134                 break;
 135 #endif
 136 #ifdef INET6
 137         case IPPROTO_IPV6:
 138                 isr = NETISR_IPV6;
 139                 break;
 140 #endif
 141         default:
 142                 IPCOMPSTAT_INC(ipcomps_nopf);
 143                 m_freem(m);
 144                 return (IPPROTO_DONE);
 145         }
 146         m_adj(m, off);
 147         IPCOMPSTAT_ADD(ipcomps_ibytes, m->m_pkthdr.len);
 148         IPCOMPSTAT_INC(ipcomps_input);
 149         netisr_dispatch(isr, m);
 150         return (IPPROTO_DONE);
 151 }
 152
 153 /*
 154  * ipcomp_init() is called when an CPI is being set up.
 155  */
 156 static int
 157 ipcomp_init(struct secasvar *sav, struct xformsw *xsp)
 158 {
 159         const struct comp_algo *tcomp;
 160         struct crypto_session_params csp;
 161
 162         /* NB: algorithm really comes in alg_enc and not alg_comp! */
 163         tcomp = comp_algorithm_lookup(sav->alg_enc);
 164         if (tcomp == NULL) {
 165                 DPRINTF(("%s: unsupported compression algorithm %d\n", __func__,
 166                          sav->alg_comp));
 167                 return EINVAL;
 168         }
 169         sav->alg_comp = sav->alg_enc;           /* set for doing histogram */
 170         sav->tdb_xform = xsp;
 171         sav->tdb_compalgxform = tcomp;
 172
 173         /* Initialize crypto session */
 174         memset(&csp, 0, sizeof(csp));
 175         csp.csp_mode = CSP_MODE_COMPRESS;
 176         csp.csp_cipher_alg = sav->tdb_compalgxform->type;
 177
 178         return crypto_newsession(&sav->tdb_cryptoid, &csp, V_crypto_support);
 179 }
 180
 181 /*
 182  * ipcomp_zeroize() used when IPCA is deleted
 183  */
 184 static int
 185 ipcomp_zeroize(struct secasvar *sav)
 186 {
 187
 188         crypto_freesession(sav->tdb_cryptoid);
 189         sav->tdb_cryptoid = NULL;
 190         return 0;
 191 }
 192
 193 /*
 194  * ipcomp_input() gets called to uncompress an input packet
 195  */
 196 static int
 197 ipcomp_input(struct mbuf *m, struct secasvar *sav, int skip, int protoff)
 198 {
 199         struct xform_data *xd;
 200         struct cryptop *crp;
 201         struct ipcomp *ipcomp;
 202         crypto_session_t cryptoid;
 203         caddr_t addr;
 204         int error, hlen = IPCOMP_HLENGTH;
 205
 206         /*
 207          * Check that the next header of the IPComp is not IPComp again, before
 208          * doing any real work.  Given it is not possible to do double
 209          * compression it means someone is playing tricks on us.
 210          */
 211         error = ENOBUFS;
 212         if (m->m_len < skip + hlen && (m = m_pullup(m, skip + hlen)) == NULL) {
 213                 IPCOMPSTAT_INC(ipcomps_hdrops);         /*XXX*/
 214                 DPRINTF(("%s: m_pullup failed\n", __func__));
 215                 key_freesav(&sav);
 216                 return (error);
 217         }
 218         addr = (caddr_t) mtod(m, struct ip *) + skip;
 219         ipcomp = (struct ipcomp *)addr;
 220         if (ipcomp->comp_nxt == IPPROTO_IPCOMP) {
 221                 IPCOMPSTAT_INC(ipcomps_pdrops); /* XXX have our own stats? */
 222                 DPRINTF(("%s: recursive compression detected\n", __func__));
 223                 error = EINVAL;
 224                 goto bad;
 225         }
 226
 227         SECASVAR_LOCK(sav);
 228         cryptoid = sav->tdb_cryptoid;
 229         SECASVAR_UNLOCK(sav);
 230
 231         /* Get crypto descriptors */
 232         crp = crypto_getreq(cryptoid, M_NOWAIT);
 233         if (crp == NULL) {
 234                 DPRINTF(("%s: no crypto descriptors\n", __func__));
 235                 IPCOMPSTAT_INC(ipcomps_crypto);
 236                 goto bad;
 237         }
 238         /* Get IPsec-specific opaque pointer */
 239         xd = malloc(sizeof(*xd), M_XDATA, M_NOWAIT | M_ZERO);
 240         if (xd == NULL) {
 241                 DPRINTF(("%s: cannot allocate xform_data\n", __func__));
 242                 IPCOMPSTAT_INC(ipcomps_crypto);
 243                 crypto_freereq(crp);
 244                 goto bad;
 245         }
 246
 247         /* Decompression operation */
 248         crp->crp_op = CRYPTO_OP_DECOMPRESS;
 249         crp->crp_payload_start = skip + hlen;
 250         crp->crp_payload_length = m->m_pkthdr.len - (skip + hlen);
 251
 252         /* Crypto operation descriptor */
 253         crp->crp_flags = CRYPTO_F_CBIFSYNC;
 254         crypto_use_mbuf(crp, m);
 255         crp->crp_callback = ipcomp_input_cb;
 256         crp->crp_opaque = xd;
 257
 258         /* These are passed as-is to the callback */
 259         xd->sav = sav;
 260         xd->protoff = protoff;
 261         xd->skip = skip;
 262         xd->vnet = curvnet;
 263         xd->cryptoid = cryptoid;
 264
 265         SECASVAR_LOCK(sav);
 266         crp->crp_session = xd->cryptoid = sav->tdb_cryptoid;
 267         SECASVAR_UNLOCK(sav);
 268
 269         return crypto_dispatch(crp);
 270 bad:
 271         m_freem(m);
 272         key_freesav(&sav);
 273         return (error);
 274 }
 275
 276 /*
 277  * IPComp input callback from the crypto driver.
 278  */
 279 static int
 280 ipcomp_input_cb(struct cryptop *crp)
 281 {
 282         IPSEC_DEBUG_DECLARE(char buf[IPSEC_ADDRSTRLEN]);
 283         struct xform_data *xd;
 284         struct mbuf *m;
 285         struct secasvar *sav;
 286         struct secasindex *saidx;
 287         caddr_t addr;
 288         crypto_session_t cryptoid;
 289         int hlen = IPCOMP_HLENGTH, error, clen;
 290         int skip, protoff;
 291         uint8_t nproto;
 292
 293         m = crp->crp_buf.cb_mbuf;
 294         xd = crp->crp_opaque;
 295         CURVNET_SET(xd->vnet);
 296         sav = xd->sav;
 297         skip = xd->skip;
 298         protoff = xd->protoff;
 299         cryptoid = xd->cryptoid;
 300         saidx = &sav->sah->saidx;
 301         IPSEC_ASSERT(saidx->dst.sa.sa_family == AF_INET ||
 302                 saidx->dst.sa.sa_family == AF_INET6,
 303                 ("unexpected protocol family %u", saidx->dst.sa.sa_family));
 304
 305         /* Check for crypto errors */
 306         if (crp->crp_etype) {
 307                 if (crp->crp_etype == EAGAIN) {
 308                         /* Reset the session ID */
 309                         if (ipsec_updateid(sav, &crp->crp_session, &cryptoid) != 0)
 310                                 crypto_freesession(cryptoid);
 311                         xd->cryptoid = crp->crp_session;
 312                         CURVNET_RESTORE();
 313                         return (crypto_dispatch(crp));
 314                 }
 315                 IPCOMPSTAT_INC(ipcomps_noxform);
 316                 DPRINTF(("%s: crypto error %d\n", __func__, crp->crp_etype));
 317                 error = crp->crp_etype;
 318                 goto bad;
 319         }
 320         /* Shouldn't happen... */
 321         if (m == NULL) {
 322                 IPCOMPSTAT_INC(ipcomps_crypto);
 323                 DPRINTF(("%s: null mbuf returned from crypto\n", __func__));
 324                 error = EINVAL;
 325                 goto bad;
 326         }
 327         IPCOMPSTAT_INC(ipcomps_hist[sav->alg_comp]);
 328
 329         clen = crp->crp_olen;           /* Length of data after processing */
 330
 331         /* Release the crypto descriptors */
 332         free(xd, M_XDATA), xd = NULL;
 333         crypto_freereq(crp), crp = NULL;
 334
 335         /* In case it's not done already, adjust the size of the mbuf chain */
 336         m->m_pkthdr.len = clen + hlen + skip;
 337
 338         if (m->m_len < skip + hlen && (m = m_pullup(m, skip + hlen)) == NULL) {
 339                 IPCOMPSTAT_INC(ipcomps_hdrops);         /*XXX*/
 340                 DPRINTF(("%s: m_pullup failed\n", __func__));
 341                 error = EINVAL;                         /*XXX*/
 342                 goto bad;
 343         }
 344
 345         /* Keep the next protocol field */
 346         addr = (caddr_t) mtod(m, struct ip *) + skip;
 347         nproto = ((struct ipcomp *) addr)->comp_nxt;
 348
 349         /* Remove the IPCOMP header */
 350         error = m_striphdr(m, skip, hlen);
 351         if (error) {
 352                 IPCOMPSTAT_INC(ipcomps_hdrops);
 353                 DPRINTF(("%s: bad mbuf chain, IPCA %s/%08lx\n", __func__,
 354                     ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)),
 355                     (u_long) ntohl(sav->spi)));
 356                 goto bad;
 357         }
 358
 359         /* Restore the Next Protocol field */
 360         m_copyback(m, protoff, sizeof (u_int8_t), (u_int8_t *) &nproto);
 361
 362         switch (saidx->dst.sa.sa_family) {
 363 #ifdef INET6
 364         case AF_INET6:
 365                 error = ipsec6_common_input_cb(m, sav, skip, protoff);
 366                 break;
 367 #endif
 368 #ifdef INET
 369         case AF_INET:
 370                 error = ipsec4_common_input_cb(m, sav, skip, protoff);
 371                 break;
 372 #endif
 373         default:
 374                 panic("%s: Unexpected address family: %d saidx=%p", __func__,
 375                     saidx->dst.sa.sa_family, saidx);
 376         }
 377         CURVNET_RESTORE();
 378         return error;
 379 bad:
 380         CURVNET_RESTORE();
 381         if (sav != NULL)
 382                 key_freesav(&sav);
 383         if (m != NULL)
 384                 m_freem(m);
 385         if (xd != NULL)
 386                 free(xd, M_XDATA);
 387         if (crp != NULL)
 388                 crypto_freereq(crp);
 389         return error;
 390 }
 391
 392 /*
 393  * IPComp output routine, called by ipsec[46]_perform_request()
 394  */
 395 static int
 396 ipcomp_output(struct mbuf *m, struct secpolicy *sp, struct secasvar *sav,
 397     u_int idx, int skip, int protoff)
 398 {
 399         IPSEC_DEBUG_DECLARE(char buf[IPSEC_ADDRSTRLEN]);
 400         const struct comp_algo *ipcompx;
 401         struct cryptop *crp;
 402         struct xform_data *xd;
 403         crypto_session_t cryptoid;
 404         int error, ralen, maxpacketsize;
 405
 406         IPSEC_ASSERT(sav != NULL, ("null SA"));
 407         ipcompx = sav->tdb_compalgxform;
 408         IPSEC_ASSERT(ipcompx != NULL, ("null compression xform"));
 409
 410         /*
 411          * Do not touch the packet in case our payload to compress
 412          * is lower than the minimal threshold of the compression
 413          * alogrithm.  We will just send out the data uncompressed.
 414          * See RFC 3173, 2.2. Non-Expansion Policy.
 415          */
 416         if (m->m_pkthdr.len <= ipcompx->minlen) {
 417                 IPCOMPSTAT_INC(ipcomps_threshold);
 418                 return ipsec_process_done(m, sp, sav, idx);
 419         }
 420
 421         ralen = m->m_pkthdr.len - skip; /* Raw payload length before comp. */
 422         IPCOMPSTAT_INC(ipcomps_output);
 423
 424         /* Check for maximum packet size violations. */
 425         switch (sav->sah->saidx.dst.sa.sa_family) {
 426 #ifdef INET
 427         case AF_INET:
 428                 maxpacketsize = IP_MAXPACKET;
 429                 break;
 430 #endif /* INET */
 431 #ifdef INET6
 432         case AF_INET6:
 433                 maxpacketsize = IPV6_MAXPACKET;
 434                 break;
 435 #endif /* INET6 */
 436         default:
 437                 IPCOMPSTAT_INC(ipcomps_nopf);
 438                 DPRINTF(("%s: unknown/unsupported protocol family %d, "
 439                     "IPCA %s/%08lx\n", __func__,
 440                     sav->sah->saidx.dst.sa.sa_family,
 441                     ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)),
 442                     (u_long) ntohl(sav->spi)));
 443                 error = EPFNOSUPPORT;
 444                 goto bad;
 445         }
 446         if (ralen + skip + IPCOMP_HLENGTH > maxpacketsize) {
 447                 IPCOMPSTAT_INC(ipcomps_toobig);
 448                 DPRINTF(("%s: packet in IPCA %s/%08lx got too big "
 449                     "(len %u, max len %u)\n", __func__,
 450                     ipsec_address(&sav->sah->saidx.dst, buf, sizeof(buf)),
 451                     (u_long) ntohl(sav->spi),
 452                     ralen + skip + IPCOMP_HLENGTH, maxpacketsize));
 453                 error = EMSGSIZE;
 454                 goto bad;
 455         }
 456
 457         /* Update the counters */
 458         IPCOMPSTAT_ADD(ipcomps_obytes, m->m_pkthdr.len - skip);
 459
 460         m = m_unshare(m, M_NOWAIT);
 461         if (m == NULL) {
 462                 IPCOMPSTAT_INC(ipcomps_hdrops);
 463                 DPRINTF(("%s: cannot clone mbuf chain, IPCA %s/%08lx\n",
 464                     __func__, ipsec_address(&sav->sah->saidx.dst, buf,
 465                     sizeof(buf)), (u_long) ntohl(sav->spi)));
 466                 error = ENOBUFS;
 467                 goto bad;
 468         }
 469
 470         /* Ok now, we can pass to the crypto processing. */
 471         SECASVAR_LOCK(sav);
 472         cryptoid = sav->tdb_cryptoid;
 473         SECASVAR_UNLOCK(sav);
 474
 475         /* Get crypto descriptors */
 476         crp = crypto_getreq(cryptoid, M_NOWAIT);
 477         if (crp == NULL) {
 478                 IPCOMPSTAT_INC(ipcomps_crypto);
 479                 DPRINTF(("%s: failed to acquire crypto descriptor\n",__func__));
 480                 error = ENOBUFS;
 481                 goto bad;
 482         }
 483
 484         /* Compression descriptor */
 485         crp->crp_op = CRYPTO_OP_COMPRESS;
 486         crp->crp_payload_start = skip;
 487         crp->crp_payload_length = ralen;
 488
 489         /* IPsec-specific opaque crypto info */
 490         xd =  malloc(sizeof(struct xform_data), M_XDATA, M_NOWAIT | M_ZERO);
 491         if (xd == NULL) {
 492                 IPCOMPSTAT_INC(ipcomps_crypto);
 493                 DPRINTF(("%s: failed to allocate xform_data\n", __func__));
 494                 crypto_freereq(crp);
 495                 error = ENOBUFS;
 496                 goto bad;
 497         }
 498
 499         xd->sp = sp;
 500         xd->sav = sav;
 501         xd->idx = idx;
 502         xd->skip = skip;
 503         xd->protoff = protoff;
 504         xd->vnet = curvnet;
 505         xd->cryptoid = cryptoid;
 506
 507         /* Crypto operation descriptor */
 508         crp->crp_flags = CRYPTO_F_CBIFSYNC;
 509         crypto_use_mbuf(crp, m);
 510         crp->crp_callback = ipcomp_output_cb;
 511         crp->crp_opaque = xd;
 512
 513         return crypto_dispatch(crp);
 514 bad:
 515         if (m)
 516                 m_freem(m);
 517         key_freesav(&sav);
 518         key_freesp(&sp);
 519         return (error);
 520 }
 521
 522 /*
 523  * IPComp output callback from the crypto driver.
 524  */
 525 static int
 526 ipcomp_output_cb(struct cryptop *crp)
 527 {
 528         IPSEC_DEBUG_DECLARE(char buf[IPSEC_ADDRSTRLEN]);
 529         struct xform_data *xd;
 530         struct secpolicy *sp;
 531         struct secasvar *sav;
 532         struct mbuf *m;
 533         crypto_session_t cryptoid;
 534         u_int idx;
 535         int error, skip, protoff;
 536
 537         m = crp->crp_buf.cb_mbuf;
 538         xd = crp->crp_opaque;
 539         CURVNET_SET(xd->vnet);
 540         idx = xd->idx;
 541         sp = xd->sp;
 542         sav = xd->sav;
 543         skip = xd->skip;
 544         protoff = xd->protoff;
 545         cryptoid = xd->cryptoid;
 546
 547         /* Check for crypto errors */
 548         if (crp->crp_etype) {
 549                 if (crp->crp_etype == EAGAIN) {
 550                         /* Reset the session ID */
 551                         if (ipsec_updateid(sav, &crp->crp_session, &cryptoid) != 0)
 552                                 crypto_freesession(cryptoid);
 553                         xd->cryptoid = crp->crp_session;
 554                         CURVNET_RESTORE();
 555                         return (crypto_dispatch(crp));
 556                 }
 557                 IPCOMPSTAT_INC(ipcomps_noxform);
 558                 DPRINTF(("%s: crypto error %d\n", __func__, crp->crp_etype));
 559                 error = crp->crp_etype;
 560                 goto bad;
 561         }
 562         /* Shouldn't happen... */
 563         if (m == NULL) {
 564                 IPCOMPSTAT_INC(ipcomps_crypto);
 565                 DPRINTF(("%s: bogus return buffer from crypto\n", __func__));
 566                 error = EINVAL;
 567                 goto bad;
 568         }
 569         IPCOMPSTAT_INC(ipcomps_hist[sav->alg_comp]);
 570
 571         if (crp->crp_payload_length > crp->crp_olen) {
 572                 struct mbuf *mo;
 573                 struct ipcomp *ipcomp;
 574                 int roff;
 575                 uint8_t prot;
 576
 577                 /* Compression helped, inject IPCOMP header. */
 578                 mo = m_makespace(m, skip, IPCOMP_HLENGTH, &roff);
 579                 if (mo == NULL) {
 580                         IPCOMPSTAT_INC(ipcomps_wrap);
 581                         DPRINTF(("%s: IPCOMP header inject failed "
 582                             "for IPCA %s/%08lx\n",
 583                             __func__, ipsec_address(&sav->sah->saidx.dst, buf,
 584                             sizeof(buf)), (u_long) ntohl(sav->spi)));
 585                         error = ENOBUFS;
 586                         goto bad;
 587                 }
 588                 ipcomp = (struct ipcomp *)(mtod(mo, caddr_t) + roff);
 589
 590                 /* Initialize the IPCOMP header */
 591                 /* XXX alignment always correct? */
 592                 switch (sav->sah->saidx.dst.sa.sa_family) {
 593 #ifdef INET
 594                 case AF_INET:
 595                         ipcomp->comp_nxt = mtod(m, struct ip *)->ip_p;
 596                         break;
 597 #endif /* INET */
 598 #ifdef INET6
 599                 case AF_INET6:
 600                         ipcomp->comp_nxt = mtod(m, struct ip6_hdr *)->ip6_nxt;
 601                         break;
 602 #endif
 603                 }
 604                 ipcomp->comp_flags = 0;
 605                 ipcomp->comp_cpi = htons((u_int16_t) ntohl(sav->spi));
 606
 607                 /* Fix Next Protocol in IPv4/IPv6 header */
 608                 prot = IPPROTO_IPCOMP;
 609                 m_copyback(m, protoff, sizeof(u_int8_t),
 610                     (u_char *)&prot);
 611
 612                 /* Adjust the length in the IP header */
 613                 switch (sav->sah->saidx.dst.sa.sa_family) {
 614 #ifdef INET
 615                 case AF_INET:
 616                         mtod(m, struct ip *)->ip_len = htons(m->m_pkthdr.len);
 617                         break;
 618 #endif /* INET */
 619 #ifdef INET6
 620                 case AF_INET6:
 621                         mtod(m, struct ip6_hdr *)->ip6_plen =
 622                                 htons(m->m_pkthdr.len) - sizeof(struct ip6_hdr);
 623                         break;
 624 #endif /* INET6 */
 625                 default:
 626                         IPCOMPSTAT_INC(ipcomps_nopf);
 627                         DPRINTF(("%s: unknown/unsupported protocol "
 628                             "family %d, IPCA %s/%08lx\n", __func__,
 629                             sav->sah->saidx.dst.sa.sa_family,
 630                             ipsec_address(&sav->sah->saidx.dst, buf,
 631                                 sizeof(buf)), (u_long) ntohl(sav->spi)));
 632                         error = EPFNOSUPPORT;
 633                         goto bad;
 634                 }
 635         } else {
 636                 /* Compression was useless, we have lost time. */
 637                 IPCOMPSTAT_INC(ipcomps_uncompr);
 638                 DPRINTF(("%s: compressions was useless %d <= %d\n",
 639                     __func__, crp->crp_payload_length, crp->crp_olen));
 640                 /* XXX remember state to not compress the next couple
 641                  *     of packets, RFC 3173, 2.2. Non-Expansion Policy */
 642         }
 643
 644         /* Release the crypto descriptor */
 645         free(xd, M_XDATA);
 646         crypto_freereq(crp);
 647
 648         /* NB: m is reclaimed by ipsec_process_done. */
 649         error = ipsec_process_done(m, sp, sav, idx);
 650         CURVNET_RESTORE();
 651         return (error);
 652 bad:
 653         if (m)
 654                 m_freem(m);
 655         CURVNET_RESTORE();
 656         free(xd, M_XDATA);
 657         crypto_freereq(crp);
 658         key_freesav(&sav);
 659         key_freesp(&sp);
 660         return (error);
 661 }
 662
 663 #ifdef INET
 664 static int
 665 ipcomp4_nonexp_encapcheck(const struct mbuf *m, int off, int proto,
 666     void *arg __unused)
 667 {
 668         union sockaddr_union src, dst;
 669         const struct ip *ip;
 670
 671         if (V_ipcomp_enable == 0)
 672                 return (0);
 673         if (proto != IPPROTO_IPV4 && proto != IPPROTO_IPV6)
 674                 return (0);
 675         bzero(&src, sizeof(src));
 676         bzero(&dst, sizeof(dst));
 677         src.sa.sa_family = dst.sa.sa_family = AF_INET;
 678         src.sin.sin_len = dst.sin.sin_len = sizeof(struct sockaddr_in);
 679         ip = mtod(m, const struct ip *);
 680         src.sin.sin_addr = ip->ip_src;
 681         dst.sin.sin_addr = ip->ip_dst;
 682         return (ipcomp_encapcheck(&src, &dst));
 683 }
 684
 685 static const struct encaptab *ipe4_cookie = NULL;
 686 static const struct encap_config ipv4_encap_cfg = {
 687         .proto = -1,
 688         .min_length = sizeof(struct ip),
 689         .exact_match = sizeof(in_addr_t) << 4,
 690         .check = ipcomp4_nonexp_encapcheck,
 691         .input = ipcomp_nonexp_input
 692 };
 693 #endif
 694 #ifdef INET6
 695 static int
 696 ipcomp6_nonexp_encapcheck(const struct mbuf *m, int off, int proto,
 697     void *arg __unused)
 698 {
 699         union sockaddr_union src, dst;
 700         const struct ip6_hdr *ip6;
 701
 702         if (V_ipcomp_enable == 0)
 703                 return (0);
 704         if (proto != IPPROTO_IPV4 && proto != IPPROTO_IPV6)
 705                 return (0);
 706         bzero(&src, sizeof(src));
 707         bzero(&dst, sizeof(dst));
 708         src.sa.sa_family = dst.sa.sa_family = AF_INET;
 709         src.sin6.sin6_len = dst.sin6.sin6_len = sizeof(struct sockaddr_in6);
 710         ip6 = mtod(m, const struct ip6_hdr *);
 711         src.sin6.sin6_addr = ip6->ip6_src;
 712         dst.sin6.sin6_addr = ip6->ip6_dst;
 713         if (IN6_IS_SCOPE_LINKLOCAL(&src.sin6.sin6_addr)) {
 714                 /* XXX: sa6_recoverscope() */
 715                 src.sin6.sin6_scope_id =
 716                     ntohs(src.sin6.sin6_addr.s6_addr16[1]);
 717                 src.sin6.sin6_addr.s6_addr16[1] = 0;
 718         }
 719         if (IN6_IS_SCOPE_LINKLOCAL(&dst.sin6.sin6_addr)) {
 720                 /* XXX: sa6_recoverscope() */
 721                 dst.sin6.sin6_scope_id =
 722                     ntohs(dst.sin6.sin6_addr.s6_addr16[1]);
 723                 dst.sin6.sin6_addr.s6_addr16[1] = 0;
 724         }
 725         return (ipcomp_encapcheck(&src, &dst));
 726 }
 727
 728 static const struct encaptab *ipe6_cookie = NULL;
 729 static const struct encap_config ipv6_encap_cfg = {
 730         .proto = -1,
 731         .min_length = sizeof(struct ip6_hdr),
 732         .exact_match = sizeof(struct in6_addr) << 4,
 733         .check = ipcomp6_nonexp_encapcheck,
 734         .input = ipcomp_nonexp_input
 735 };
 736 #endif
 737
 738 static struct xformsw ipcomp_xformsw = {
 739         .xf_type =      XF_IPCOMP,
 740         .xf_name =      "IPcomp",
 741         .xf_init =      ipcomp_init,
 742         .xf_zeroize =   ipcomp_zeroize,
 743         .xf_input =     ipcomp_input,
 744         .xf_output =    ipcomp_output,
 745 };
 746
 747 static void
 748 ipcomp_attach(void)
 749 {
 750
 751 #ifdef INET
 752         ipe4_cookie = ip_encap_attach(&ipv4_encap_cfg, NULL, M_WAITOK);
 753 #endif
 754 #ifdef INET6
 755         ipe6_cookie = ip6_encap_attach(&ipv6_encap_cfg, NULL, M_WAITOK);
 756 #endif
 757         xform_attach(&ipcomp_xformsw);
 758 }
 759
 760 static void
 761 ipcomp_detach(void)
 762 {
 763
 764 #ifdef INET
 765         ip_encap_detach(ipe4_cookie);
 766 #endif
 767 #ifdef INET6
 768         ip6_encap_detach(ipe6_cookie);
 769 #endif
 770         xform_detach(&ipcomp_xformsw);
 771 }
 772
 773 SYSINIT(ipcomp_xform_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_MIDDLE,
 774     ipcomp_attach, NULL);
 775 SYSUNINIT(ipcomp_xform_uninit, SI_SUB_PROTO_DOMAIN, SI_ORDER_MIDDLE,
 776     ipcomp_detach, NULL);