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