ipsec_mbuf.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2002, 2003 Sam Leffler, Errno Consulting
    5  * All rights reserved.
    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  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  *
   28  * $FreeBSD$
   29  */
   30 
   31 /*
   32  * IPsec-specific mbuf routines.
   33  */
   34 
   35 #include "opt_ipsec.h"
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/malloc.h>
   40 #include <sys/mbuf.h>
   41 #include <sys/socket.h>
   42 
   43 #include <net/vnet.h>
   44 #include <netinet/in.h>
   45 #include <netipsec/ipsec.h>
   46 
   47 /*
   48  * Make space for a new header of length hlen at skip bytes
   49  * into the packet.  When doing this we allocate new mbufs only
   50  * when absolutely necessary.  The mbuf where the new header
   51  * is to go is returned together with an offset into the mbuf.
   52  * If NULL is returned then the mbuf chain may have been modified;
   53  * the caller is assumed to always free the chain.
   54  */
   55 struct mbuf *
   56 m_makespace(struct mbuf *m0, int skip, int hlen, int *off)
   57 {
   58         struct mbuf *m;
   59         unsigned remain;
   60 
   61         IPSEC_ASSERT(m0 != NULL, ("null mbuf"));
   62         IPSEC_ASSERT(hlen < MHLEN, ("hlen too big: %u", hlen));
   63 
   64         for (m = m0; m && skip > m->m_len; m = m->m_next)
   65                 skip -= m->m_len;
   66         if (m == NULL)
   67                 return (NULL);
   68         /*
   69          * At this point skip is the offset into the mbuf m
   70          * where the new header should be placed.  Figure out
   71          * if there's space to insert the new header.  If so,
   72          * and copying the remainder makes sense then do so.
   73          * Otherwise insert a new mbuf in the chain, splitting
   74          * the contents of m as needed.
   75          */
   76         remain = m->m_len - skip;               /* data to move */
   77         if (remain > skip &&
   78             hlen + max_linkhdr < M_LEADINGSPACE(m)) {
   79                 /*
   80                  * mbuf has enough free space at the beginning.
   81                  * XXX: which operation is the most heavy - copying of
   82                  *      possible several hundred of bytes or allocation
   83                  *      of new mbuf? We can remove max_linkhdr check
   84                  *      here, but it is possible that this will lead
   85                  *      to allocation of new mbuf in Layer 2 code.
   86                  */
   87                 m->m_data -= hlen;
   88                 bcopy(mtodo(m, hlen), mtod(m, caddr_t), skip);
   89                 m->m_len += hlen;
   90                 *off = skip;
   91         } else if (hlen > M_TRAILINGSPACE(m)) {
   92                 struct mbuf *n0, *n, **np;
   93                 int todo, len, done;
   94 
   95                 n0 = NULL;
   96                 np = &n0;
   97                 done = 0;
   98                 todo = remain;
   99                 while (todo > 0) {
  100                         if (todo > MHLEN) {
  101                                 n = m_getcl(M_NOWAIT, m->m_type, 0);
  102                                 len = MCLBYTES;
  103                         }
  104                         else {
  105                                 n = m_get(M_NOWAIT, m->m_type);
  106                                 len = MHLEN;
  107                         }
  108                         if (n == NULL) {
  109                                 m_freem(n0);
  110                                 return NULL;
  111                         }
  112                         *np = n;
  113                         np = &n->m_next;
  114                         len = min(todo, len);
  115                         memcpy(n->m_data, mtod(m, char *) + skip + done, len);
  116                         n->m_len = len;
  117                         done += len;
  118                         todo -= len;
  119                 }
  120 
  121                 if (hlen <= M_TRAILINGSPACE(m) + remain) {
  122                         m->m_len = skip + hlen;
  123                         *off = skip;
  124                         if (n0 != NULL) {
  125                                 *np = m->m_next;
  126                                 m->m_next = n0;
  127                         }
  128                 }
  129                 else {
  130                         n = m_get(M_NOWAIT, m->m_type);
  131                         if (n == NULL) {
  132                                 m_freem(n0);
  133                                 return NULL;
  134                         }
  135 
  136                         if ((n->m_next = n0) == NULL)
  137                                 np = &n->m_next;
  138                         n0 = n;
  139 
  140                         *np = m->m_next;
  141                         m->m_next = n0;
  142 
  143                         n->m_len = hlen;
  144                         m->m_len = skip;
  145 
  146                         m = n;                  /* header is at front ... */
  147                         *off = 0;               /* ... of new mbuf */
  148                 }
  149                 IPSECSTAT_INC(ips_mbinserted);
  150         } else {
  151                 /*
  152                  * Copy the remainder to the back of the mbuf
  153                  * so there's space to write the new header.
  154                  */
  155                 bcopy(mtod(m, caddr_t) + skip,
  156                     mtod(m, caddr_t) + skip + hlen, remain);
  157                 m->m_len += hlen;
  158                 *off = skip;
  159         }
  160         m0->m_pkthdr.len += hlen;               /* adjust packet length */
  161         return m;
  162 }
  163 
  164 /*
  165  * m_pad(m, n) pads <m> with <n> bytes at the end. The packet header
  166  * length is updated, and a pointer to the first byte of the padding
  167  * (which is guaranteed to be all in one mbuf) is returned.
  168  */
  169 caddr_t
  170 m_pad(struct mbuf *m, int n)
  171 {
  172         struct mbuf *m0, *m1;
  173         int len, pad;
  174         caddr_t retval;
  175 
  176         if (n <= 0) {  /* No stupid arguments. */
  177                 DPRINTF(("%s: pad length invalid (%d)\n", __func__, n));
  178                 m_freem(m);
  179                 return NULL;
  180         }
  181 
  182         len = m->m_pkthdr.len;
  183         pad = n;
  184         m0 = m;
  185 
  186         while (m0->m_len < len) {
  187                 len -= m0->m_len;
  188                 m0 = m0->m_next;
  189         }
  190 
  191         if (m0->m_len != len) {
  192                 DPRINTF(("%s: length mismatch (should be %d instead of %d)\n",
  193                         __func__, m->m_pkthdr.len,
  194                         m->m_pkthdr.len + m0->m_len - len));
  195 
  196                 m_freem(m);
  197                 return NULL;
  198         }
  199 
  200         /* Check for zero-length trailing mbufs, and find the last one. */
  201         for (m1 = m0; m1->m_next; m1 = m1->m_next) {
  202                 if (m1->m_next->m_len != 0) {
  203                         DPRINTF(("%s: length mismatch (should be %d instead "
  204                                 "of %d)\n", __func__,
  205                                 m->m_pkthdr.len,
  206                                 m->m_pkthdr.len + m1->m_next->m_len));
  207 
  208                         m_freem(m);
  209                         return NULL;
  210                 }
  211 
  212                 m0 = m1->m_next;
  213         }
  214 
  215         if (pad > M_TRAILINGSPACE(m0)) {
  216                 /* Add an mbuf to the chain. */
  217                 MGET(m1, M_NOWAIT, MT_DATA);
  218                 if (m1 == NULL) {
  219                         m_freem(m0);
  220                         DPRINTF(("%s: unable to get extra mbuf\n", __func__));
  221                         return NULL;
  222                 }
  223 
  224                 m0->m_next = m1;
  225                 m0 = m1;
  226                 m0->m_len = 0;
  227         }
  228 
  229         retval = m0->m_data + m0->m_len;
  230         m0->m_len += pad;
  231         m->m_pkthdr.len += pad;
  232 
  233         return retval;
  234 }
  235 
  236 /*
  237  * Remove hlen data at offset skip in the packet.  This is used by
  238  * the protocols strip protocol headers and associated data (e.g. IV,
  239  * authenticator) on input.
  240  */
  241 int
  242 m_striphdr(struct mbuf *m, int skip, int hlen)
  243 {
  244         struct mbuf *m1;
  245         int roff;
  246 
  247         /* Find beginning of header */
  248         m1 = m_getptr(m, skip, &roff);
  249         if (m1 == NULL)
  250                 return (EINVAL);
  251 
  252         /* Remove the header and associated data from the mbuf. */
  253         if (roff == 0) {
  254                 /* The header was at the beginning of the mbuf */
  255                 IPSECSTAT_INC(ips_input_front);
  256                 m_adj(m1, hlen);
  257                 if (m1 != m)
  258                         m->m_pkthdr.len -= hlen;
  259         } else if (roff + hlen >= m1->m_len) {
  260                 struct mbuf *mo;
  261                 int adjlen;
  262 
  263                 /*
  264                  * Part or all of the header is at the end of this mbuf,
  265                  * so first let's remove the remainder of the header from
  266                  * the beginning of the remainder of the mbuf chain, if any.
  267                  */
  268                 IPSECSTAT_INC(ips_input_end);
  269                 if (roff + hlen > m1->m_len) {
  270                         adjlen = roff + hlen - m1->m_len;
  271 
  272                         /* Adjust the next mbuf by the remainder */
  273                         m_adj(m1->m_next, adjlen);
  274 
  275                         /* The second mbuf is guaranteed not to have a pkthdr... */
  276                         m->m_pkthdr.len -= adjlen;
  277                 }
  278 
  279                 /* Now, let's unlink the mbuf chain for a second...*/
  280                 mo = m1->m_next;
  281                 m1->m_next = NULL;
  282 
  283                 /* ...and trim the end of the first part of the chain...sick */
  284                 adjlen = m1->m_len - roff;
  285                 m_adj(m1, -adjlen);
  286                 if (m1 != m)
  287                         m->m_pkthdr.len -= adjlen;
  288 
  289                 /* Finally, let's relink */
  290                 m1->m_next = mo;
  291         } else {
  292                 /*
  293                  * The header lies in the "middle" of the mbuf; copy
  294                  * the remainder of the mbuf down over the header.
  295                  */
  296                 IPSECSTAT_INC(ips_input_middle);
  297                 bcopy(mtod(m1, u_char *) + roff + hlen,
  298                       mtod(m1, u_char *) + roff,
  299                       m1->m_len - (roff + hlen));
  300                 m1->m_len -= hlen;
  301                 m->m_pkthdr.len -= hlen;
  302         }
  303         return (0);
  304 }
  305 
  306 /*
  307  * Diagnostic routine to check mbuf alignment as required by the
  308  * crypto device drivers (that use DMA).
  309  */
  310 void
  311 m_checkalignment(const char* where, struct mbuf *m0, int off, int len)
  312 {
  313         int roff;
  314         struct mbuf *m = m_getptr(m0, off, &roff);
  315         caddr_t addr;
  316 
  317         if (m == NULL)
  318                 return;
  319         printf("%s (off %u len %u): ", where, off, len);
  320         addr = mtod(m, caddr_t) + roff;
  321         do {
  322                 int mlen;
  323 
  324                 if (((uintptr_t) addr) & 3) {
  325                         printf("addr misaligned %p,", addr);
  326                         break;
  327                 }
  328                 mlen = m->m_len;
  329                 if (mlen > len)
  330                         mlen = len;
  331                 len -= mlen;
  332                 if (len && (mlen & 3)) {
  333                         printf("len mismatch %u,", mlen);
  334                         break;
  335                 }
  336                 m = m->m_next;
  337                 addr = m ? mtod(m, caddr_t) : NULL;
  338         } while (m && len > 0);
  339         for (m = m0; m; m = m->m_next)
  340                 printf(" [%p:%u]", mtod(m, caddr_t), m->m_len);
  341         printf("\n");
  342 }
Cache object: 7f5426478b82c8bb3fc9a92c63b14e20
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netipsec/ipsec_mbuf.c

FreeBSD/Linux Kernel Cross Reference
sys/netipsec/ipsec_mbuf.c
