sys/opencrypto/criov.c

   1 /*      $FreeBSD: src/sys/opencrypto/criov.c,v 1.1.2.1 2002/11/21 23:34:23 sam Exp $    */
   2 /*      $OpenBSD: criov.c,v 1.9 2002/01/29 15:48:29 jason Exp $ */
   3
   4 /*
   5  * Copyright (c) 1999 Theo de Raadt
   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 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/proc.h>
  34 #include <sys/errno.h>
  35 #include <sys/malloc.h>
  36 #include <sys/kernel.h>
  37 #include <sys/uio.h>
  38
  39 #include <opencrypto/cryptodev.h>
  40
  41 void
  42 cuio_copydata(struct uio* uio, int off, int len, caddr_t cp)
  43 {
  44         struct iovec *iov = uio->uio_iov;
  45         int iol = uio->uio_iovcnt;
  46         unsigned count;
  47
  48         if (off < 0)
  49                 panic("cuio_copydata: off %d < 0", off);
  50         if (len < 0)
  51                 panic("cuio_copydata: len %d < 0", len);
  52         while (off > 0) {
  53                 if (iol == 0)
  54                         panic("iov_copydata: empty in skip");
  55                 if (off < iov->iov_len)
  56                         break;
  57                 off -= iov->iov_len;
  58                 iol--;
  59                 iov++;
  60         }
  61         while (len > 0) {
  62                 if (iol == 0)
  63                         panic("cuio_copydata: empty");
  64                 count = min(iov->iov_len - off, len);
  65                 bcopy(((caddr_t)iov->iov_base) + off, cp, count);
  66                 len -= count;
  67                 cp += count;
  68                 off = 0;
  69                 iol--;
  70                 iov++;
  71         }
  72 }
  73
  74 void
  75 cuio_copyback(struct uio* uio, int off, int len, caddr_t cp)
  76 {
  77         struct iovec *iov = uio->uio_iov;
  78         int iol = uio->uio_iovcnt;
  79         unsigned count;
  80
  81         if (off < 0)
  82                 panic("cuio_copyback: off %d < 0", off);
  83         if (len < 0)
  84                 panic("cuio_copyback: len %d < 0", len);
  85         while (off > 0) {
  86                 if (iol == 0)
  87                         panic("cuio_copyback: empty in skip");
  88                 if (off < iov->iov_len)
  89                         break;
  90                 off -= iov->iov_len;
  91                 iol--;
  92                 iov++;
  93         }
  94         while (len > 0) {
  95                 if (iol == 0)
  96                         panic("uio_copyback: empty");
  97                 count = min(iov->iov_len - off, len);
  98                 bcopy(cp, ((caddr_t)iov->iov_base) + off, count);
  99                 len -= count;
 100                 cp += count;
 101                 off = 0;
 102                 iol--;
 103                 iov++;
 104         }
 105 }
 106
 107 /*
 108  * Return a pointer to iov/offset of location in iovec list.
 109  */
 110 struct iovec *
 111 cuio_getptr(struct uio *uio, int loc, int *off)
 112 {
 113         struct iovec *iov = uio->uio_iov;
 114         int iol = uio->uio_iovcnt;
 115
 116         while (loc >= 0) {
 117                 /* Normal end of search */
 118                 if (loc < iov->iov_len) {
 119                         *off = loc;
 120                         return (iov);
 121                 }
 122
 123                 loc -= iov->iov_len;
 124                 if (iol == 0) {
 125                         if (loc == 0) {
 126                                 /* Point at the end of valid data */
 127                                 *off = iov->iov_len;
 128                                 return (iov);
 129                         } else
 130                                 return (NULL);
 131                 } else {
 132                         iov++, iol--;
 133                 }
 134         }
 135
 136         return (NULL);
 137 }