Home | History | Annotate | Line # | Download | only in opencrypto
cryptodev.c revision 1.38
      1  1.38     rmind /*	$NetBSD: cryptodev.c,v 1.38 2008/04/11 10:28:10 rmind Exp $ */
      2   1.4  jonathan /*	$FreeBSD: src/sys/opencrypto/cryptodev.c,v 1.4.2.4 2003/06/03 00:09:02 sam Exp $	*/
      3   1.1  jonathan /*	$OpenBSD: cryptodev.c,v 1.53 2002/07/10 22:21:30 mickey Exp $	*/
      4   1.1  jonathan 
      5  1.36       tls /*-
      6  1.36       tls  * Copyright (c) 2008 The NetBSD Foundation, Inc.
      7  1.36       tls  * All rights reserved.
      8  1.36       tls  *
      9  1.36       tls  * This code is derived from software contributed to The NetBSD Foundation
     10  1.36       tls  * by Coyote Point Systems, Inc.
     11  1.36       tls  *
     12  1.36       tls  * Redistribution and use in source and binary forms, with or without
     13  1.36       tls  * modification, are permitted provided that the following conditions
     14  1.36       tls  * are met:
     15  1.36       tls  * 1. Redistributions of source code must retain the above copyright
     16  1.36       tls  *    notice, this list of conditions and the following disclaimer.
     17  1.36       tls  * 2. Redistributions in binary form must reproduce the above copyright
     18  1.36       tls  *    notice, this list of conditions and the following disclaimer in the
     19  1.36       tls  *    documentation and/or other materials provided with the distribution.
     20  1.36       tls  * 3. All advertising materials mentioning features or use of this software
     21  1.36       tls  *    must display the following acknowledgement:
     22  1.36       tls  *	This product includes software developed by the NetBSD
     23  1.36       tls  *	Foundation, Inc. and its contributors.
     24  1.36       tls  * 4. Neither the name of The NetBSD Foundation nor the names of its
     25  1.36       tls  *    contributors may be used to endorse or promote products derived
     26  1.36       tls  *    from this software without specific prior written permission.
     27  1.36       tls  *
     28  1.36       tls  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     29  1.36       tls  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     30  1.36       tls  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     31  1.36       tls  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     32  1.36       tls  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     33  1.36       tls  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     34  1.36       tls  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     35  1.36       tls  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     36  1.36       tls  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     37  1.36       tls  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     38  1.36       tls  * POSSIBILITY OF SUCH DAMAGE.
     39  1.36       tls  */
     40  1.36       tls 
     41   1.1  jonathan /*
     42   1.1  jonathan  * Copyright (c) 2001 Theo de Raadt
     43   1.1  jonathan  *
     44   1.1  jonathan  * Redistribution and use in source and binary forms, with or without
     45   1.1  jonathan  * modification, are permitted provided that the following conditions
     46   1.1  jonathan  * are met:
     47   1.1  jonathan  *
     48   1.1  jonathan  * 1. Redistributions of source code must retain the above copyright
     49   1.1  jonathan  *   notice, this list of conditions and the following disclaimer.
     50   1.1  jonathan  * 2. Redistributions in binary form must reproduce the above copyright
     51   1.1  jonathan  *   notice, this list of conditions and the following disclaimer in the
     52   1.1  jonathan  *   documentation and/or other materials provided with the distribution.
     53   1.1  jonathan  * 3. The name of the author may not be used to endorse or promote products
     54   1.1  jonathan  *   derived from this software without specific prior written permission.
     55   1.1  jonathan  *
     56   1.1  jonathan  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     57   1.1  jonathan  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     58   1.1  jonathan  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     59   1.1  jonathan  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     60   1.1  jonathan  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     61   1.1  jonathan  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     62   1.1  jonathan  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     63   1.1  jonathan  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     64   1.1  jonathan  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     65   1.1  jonathan  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     66   1.1  jonathan  *
     67   1.1  jonathan  * Effort sponsored in part by the Defense Advanced Research Projects
     68   1.1  jonathan  * Agency (DARPA) and Air Force Research Laboratory, Air Force
     69   1.1  jonathan  * Materiel Command, USAF, under agreement number F30602-01-2-0537.
     70   1.1  jonathan  *
     71   1.1  jonathan  */
     72   1.1  jonathan 
     73   1.1  jonathan #include <sys/cdefs.h>
     74  1.38     rmind __KERNEL_RCSID(0, "$NetBSD: cryptodev.c,v 1.38 2008/04/11 10:28:10 rmind Exp $");
     75   1.1  jonathan 
     76   1.1  jonathan #include <sys/param.h>
     77   1.1  jonathan #include <sys/systm.h>
     78  1.36       tls #include <sys/kmem.h>
     79   1.1  jonathan #include <sys/malloc.h>
     80   1.1  jonathan #include <sys/mbuf.h>
     81  1.29       tls #include <sys/pool.h>
     82   1.1  jonathan #include <sys/sysctl.h>
     83   1.1  jonathan #include <sys/file.h>
     84   1.1  jonathan #include <sys/filedesc.h>
     85   1.1  jonathan #include <sys/errno.h>
     86   1.2  jonathan #include <sys/md5.h>
     87   1.1  jonathan #include <sys/sha1.h>
     88   1.1  jonathan #include <sys/conf.h>
     89   1.1  jonathan #include <sys/device.h>
     90  1.21      elad #include <sys/kauth.h>
     91  1.36       tls #include <sys/select.h>
     92  1.36       tls #include <sys/poll.h>
     93  1.37    dogcow #include <sys/atomic.h>
     94   1.1  jonathan 
     95  1.33       tls #include "opt_ocf.h"
     96   1.1  jonathan #include <opencrypto/cryptodev.h>
     97   1.1  jonathan #include <opencrypto/xform.h>
     98   1.1  jonathan 
     99   1.1  jonathan struct csession {
    100   1.1  jonathan 	TAILQ_ENTRY(csession) next;
    101   1.1  jonathan 	u_int64_t	sid;
    102   1.1  jonathan 	u_int32_t	ses;
    103   1.1  jonathan 
    104   1.1  jonathan 	u_int32_t	cipher;
    105   1.1  jonathan 	struct enc_xform *txform;
    106   1.1  jonathan 	u_int32_t	mac;
    107   1.1  jonathan 	struct auth_hash *thash;
    108   1.1  jonathan 
    109  1.26  christos 	void *		key;
    110   1.1  jonathan 	int		keylen;
    111   1.1  jonathan 	u_char		tmp_iv[EALG_MAX_BLOCK_LEN];
    112   1.1  jonathan 
    113  1.26  christos 	void *		mackey;
    114   1.1  jonathan 	int		mackeylen;
    115   1.1  jonathan 	u_char		tmp_mac[CRYPTO_MAX_MAC_LEN];
    116   1.1  jonathan 
    117  1.29       tls 	struct iovec	iovec[1];	/* user requests never have more */
    118   1.1  jonathan 	struct uio	uio;
    119   1.1  jonathan 	int		error;
    120   1.1  jonathan };
    121   1.1  jonathan 
    122   1.1  jonathan struct fcrypt {
    123   1.1  jonathan 	TAILQ_HEAD(csessionlist, csession) csessions;
    124  1.36       tls 	TAILQ_HEAD(crprethead, cryptop) crp_ret_mq;
    125  1.36       tls 	TAILQ_HEAD(krprethead, cryptkop) crp_ret_mkq;
    126   1.1  jonathan 	int		sesn;
    127  1.36       tls 	struct selinfo	sinfo;
    128  1.36       tls 	u_int32_t	requestid;
    129   1.1  jonathan };
    130   1.1  jonathan 
    131  1.29       tls /* For our fixed-size allocations */
    132  1.38     rmind static struct pool fcrpl;
    133  1.38     rmind static struct pool csepl;
    134   1.1  jonathan 
    135   1.1  jonathan /* Declaration of master device (fd-cloning/ctxt-allocating) entrypoints */
    136  1.16  christos static int	cryptoopen(dev_t dev, int flag, int mode, struct lwp *l);
    137   1.1  jonathan static int	cryptoread(dev_t dev, struct uio *uio, int ioflag);
    138   1.1  jonathan static int	cryptowrite(dev_t dev, struct uio *uio, int ioflag);
    139  1.16  christos static int	cryptoselect(dev_t dev, int rw, struct lwp *l);
    140   1.1  jonathan 
    141   1.1  jonathan /* Declaration of cloned-device (per-ctxt) entrypoints */
    142  1.36       tls static int	cryptof_read(struct file *, off_t *, struct uio *,
    143  1.36       tls 			     kauth_cred_t, int);
    144  1.36       tls static int	cryptof_write(struct file *, off_t *, struct uio *,
    145  1.36       tls 			      kauth_cred_t, int);
    146  1.36       tls static int	cryptof_ioctl(struct file *, u_long, void *);
    147  1.36       tls static int	cryptof_close(struct file *);
    148  1.36       tls static int 	cryptof_poll(struct file *, int);
    149   1.1  jonathan 
    150  1.12  christos static const struct fileops cryptofops = {
    151   1.1  jonathan     cryptof_read,
    152   1.1  jonathan     cryptof_write,
    153   1.1  jonathan     cryptof_ioctl,
    154  1.12  christos     fnullop_fcntl,
    155  1.36       tls     cryptof_poll,
    156  1.12  christos     fbadop_stat,
    157   1.1  jonathan     cryptof_close,
    158  1.12  christos     fnullop_kqfilter
    159   1.1  jonathan };
    160   1.1  jonathan 
    161   1.1  jonathan static struct	csession *csefind(struct fcrypt *, u_int);
    162   1.1  jonathan static int	csedelete(struct fcrypt *, struct csession *);
    163   1.1  jonathan static struct	csession *cseadd(struct fcrypt *, struct csession *);
    164  1.26  christos static struct	csession *csecreate(struct fcrypt *, u_int64_t, void *, u_int64_t,
    165  1.26  christos     void *, u_int64_t, u_int32_t, u_int32_t, struct enc_xform *,
    166   1.1  jonathan     struct auth_hash *);
    167   1.1  jonathan static int	csefree(struct csession *);
    168   1.1  jonathan 
    169  1.16  christos static int	cryptodev_op(struct csession *, struct crypt_op *, struct lwp *);
    170  1.36       tls static int	cryptodev_mop(struct fcrypt *, struct crypt_n_op *, int, struct
    171  1.36       tls 			      lwp *);
    172   1.1  jonathan static int	cryptodev_key(struct crypt_kop *);
    173  1.36       tls static int	cryptodev_mkey(struct fcrypt *, struct crypt_n_kop *, int);
    174  1.36       tls static int	cryptodev_session(struct fcrypt *, struct session_op *);
    175  1.36       tls static int	cryptodev_msession(struct fcrypt *, struct session_n_op *,
    176  1.36       tls 				       int);
    177  1.36       tls static int	cryptodev_msessionfin(struct fcrypt *, int, u_int32_t *);
    178   1.1  jonathan 
    179   1.1  jonathan static int	cryptodev_cb(void *);
    180   1.1  jonathan static int	cryptodevkey_cb(void *);
    181   1.1  jonathan 
    182  1.36       tls static int	cryptodev_mcb(void *);
    183  1.36       tls static int	cryptodevkey_mcb(void *);
    184  1.36       tls 
    185  1.36       tls static int 	cryptodev_getmstatus(struct fcrypt *, struct crypt_result *,
    186  1.36       tls 				     int);
    187  1.36       tls static int	cryptodev_getstatus(struct fcrypt *, struct crypt_result *);
    188  1.36       tls 
    189   1.9  jonathan /*
    190   1.9  jonathan  * sysctl-able control variables for /dev/crypto now defined in crypto.c:
    191   1.9  jonathan  * crypto_usercrypto, crypto_userasmcrypto, crypto_devallowsoft.
    192   1.9  jonathan  */
    193   1.1  jonathan 
    194   1.1  jonathan /* ARGSUSED */
    195   1.1  jonathan int
    196  1.35        ad cryptof_read(file_t *fp, off_t *poff,
    197  1.25  christos     struct uio *uio, kauth_cred_t cred, int flags)
    198   1.1  jonathan {
    199   1.1  jonathan 	return (EIO);
    200   1.1  jonathan }
    201   1.1  jonathan 
    202   1.1  jonathan /* ARGSUSED */
    203   1.1  jonathan int
    204  1.35        ad cryptof_write(file_t *fp, off_t *poff,
    205  1.25  christos     struct uio *uio, kauth_cred_t cred, int flags)
    206   1.1  jonathan {
    207   1.1  jonathan 	return (EIO);
    208   1.1  jonathan }
    209   1.1  jonathan 
    210   1.1  jonathan /* ARGSUSED */
    211   1.1  jonathan int
    212  1.36       tls cryptof_ioctl(struct file *fp, u_long cmd, void *data)
    213   1.1  jonathan {
    214  1.35        ad 	struct fcrypt *fcr = fp->f_data;
    215   1.1  jonathan 	struct csession *cse;
    216   1.1  jonathan 	struct session_op *sop;
    217  1.36       tls 	struct session_n_op *snop;
    218   1.1  jonathan 	struct crypt_op *cop;
    219  1.36       tls 	struct crypt_mop *mop;
    220  1.36       tls 	struct crypt_mkop *mkop;
    221  1.36       tls 	struct crypt_n_op *cnop;
    222  1.36       tls 	struct crypt_n_kop *knop;
    223  1.36       tls 	struct crypt_sgop *sgop;
    224  1.36       tls 	struct crypt_sfop *sfop;
    225  1.36       tls 	struct cryptret *crypt_ret;
    226  1.36       tls 	struct crypt_result *crypt_res;
    227   1.1  jonathan 	u_int32_t ses;
    228  1.36       tls 	u_int32_t *sesid;
    229   1.1  jonathan 	int error = 0;
    230  1.36       tls 	size_t count;
    231   1.1  jonathan 
    232  1.29       tls 	/* backwards compatibility */
    233  1.35        ad         file_t *criofp;
    234  1.29       tls 	struct fcrypt *criofcr;
    235  1.29       tls 	int criofd;
    236  1.29       tls 
    237  1.36       tls 	switch (cmd) {
    238  1.29       tls         case CRIOGET:   /* XXX deprecated, remove after 5.0 */
    239  1.36       tls 		if ((error = fd_allocfile(&criofp, &criofd)) != 0)
    240  1.36       tls 			return error;
    241  1.36       tls 		criofcr = pool_get(&fcrpl, PR_WAITOK);
    242  1.36       tls 		if (criofcr == NULL) {
    243  1.36       tls 			fd_abort(curproc, criofp, criofd);
    244  1.36       tls 			return ENOMEM;
    245  1.36       tls 		}
    246  1.33       tls 		mutex_spin_enter(&crypto_mtx);
    247  1.36       tls 		TAILQ_INIT(&criofcr->csessions);
    248  1.36       tls 		TAILQ_INIT(&criofcr->crp_ret_mq);
    249  1.36       tls 		TAILQ_INIT(&criofcr->crp_ret_mkq);
    250  1.36       tls 		selinit(&criofcr->sinfo);
    251  1.36       tls 
    252  1.29       tls                 /*
    253  1.29       tls                  * Don't ever return session 0, to allow detection of
    254  1.29       tls                  * failed creation attempts with multi-create ioctl.
    255  1.29       tls                  */
    256  1.36       tls 		criofcr->sesn = 1;
    257  1.36       tls 		criofcr->requestid = 1;
    258  1.33       tls 		mutex_spin_exit(&crypto_mtx);
    259  1.36       tls 		(void)fd_clone(criofp, criofd, (FREAD|FWRITE),
    260  1.29       tls 			      &cryptofops, criofcr);
    261  1.36       tls 		*(u_int32_t *)data = criofd;
    262  1.29       tls 		return error;
    263  1.36       tls 		break;
    264   1.1  jonathan 	case CIOCGSESSION:
    265   1.1  jonathan 		sop = (struct session_op *)data;
    266  1.36       tls 		error = cryptodev_session(fcr, sop);
    267  1.36       tls 		break;
    268  1.36       tls 	case CIOCNGSESSION:
    269  1.36       tls 		sgop = (struct crypt_sgop *)data;
    270  1.36       tls 		snop = kmem_alloc((sgop->count *
    271  1.36       tls 				  sizeof(struct session_n_op)), KM_SLEEP);
    272  1.36       tls 		if (!snop) {
    273  1.36       tls 			error = EINVAL;
    274  1.36       tls 			goto mbail;
    275   1.1  jonathan 		}
    276  1.36       tls 		error = copyin(sgop->sessions, snop, sgop->count *
    277  1.36       tls 			       sizeof(struct session_n_op));
    278  1.36       tls 		if (error) {
    279  1.36       tls 			goto mbail;
    280   1.1  jonathan 		}
    281   1.1  jonathan 
    282  1.36       tls 		error = cryptodev_msession(fcr, snop, sgop->count);
    283  1.36       tls 		if (error) {
    284  1.36       tls 			goto mbail;
    285   1.1  jonathan 		}
    286   1.1  jonathan 
    287  1.36       tls 		error = copyout(snop, sgop->sessions, sgop->count *
    288  1.36       tls 					sizeof(struct session_n_op));
    289  1.36       tls mbail:
    290  1.36       tls 		if(snop) {
    291  1.36       tls 			kmem_free(snop, sgop->count *
    292  1.36       tls 				  sizeof(struct session_n_op));
    293   1.1  jonathan 		}
    294   1.1  jonathan 		break;
    295   1.1  jonathan 	case CIOCFSESSION:
    296  1.33       tls 		mutex_spin_enter(&crypto_mtx);
    297   1.1  jonathan 		ses = *(u_int32_t *)data;
    298   1.1  jonathan 		cse = csefind(fcr, ses);
    299   1.1  jonathan 		if (cse == NULL)
    300   1.1  jonathan 			return (EINVAL);
    301   1.1  jonathan 		csedelete(fcr, cse);
    302   1.1  jonathan 		error = csefree(cse);
    303  1.33       tls 		mutex_spin_exit(&crypto_mtx);
    304   1.1  jonathan 		break;
    305  1.36       tls 	case CIOCNFSESSION:
    306  1.36       tls 		sfop = (struct crypt_sfop *)data;
    307  1.36       tls 		sesid = kmem_alloc((sfop->count * sizeof(u_int32_t)),
    308  1.36       tls 				   KM_SLEEP);
    309  1.36       tls 		if (!sesid)
    310  1.36       tls 			return (EINVAL);
    311  1.36       tls 		error = copyin(sfop->sesid, sesid,
    312  1.36       tls 			    (sfop->count * sizeof(u_int32_t)));
    313  1.36       tls 		if (!error) {
    314  1.36       tls 			error = cryptodev_msessionfin(fcr, sfop->count, sesid);
    315  1.36       tls 		}
    316  1.36       tls 		kmem_free(sesid, (sfop->count * sizeof(u_int32_t)));
    317  1.36       tls 		break;
    318   1.1  jonathan 	case CIOCCRYPT:
    319  1.33       tls 		mutex_spin_enter(&crypto_mtx);
    320   1.1  jonathan 		cop = (struct crypt_op *)data;
    321   1.1  jonathan 		cse = csefind(fcr, cop->ses);
    322  1.33       tls 		mutex_spin_exit(&crypto_mtx);
    323  1.18  christos 		if (cse == NULL) {
    324  1.18  christos 			DPRINTF(("csefind failed\n"));
    325   1.1  jonathan 			return (EINVAL);
    326  1.18  christos 		}
    327  1.35        ad 		error = cryptodev_op(cse, cop, curlwp);
    328  1.34       tls 		DPRINTF(("cryptodev_op error = %d\n", error));
    329   1.1  jonathan 		break;
    330  1.36       tls 	case CIOCNCRYPTM:
    331  1.36       tls 		mop = (struct crypt_mop *)data;
    332  1.36       tls 		cnop = kmem_alloc((mop->count * sizeof(struct crypt_n_op)),
    333  1.36       tls 				  KM_SLEEP);
    334  1.36       tls 		if(!cnop) {
    335  1.36       tls 			return(EINVAL);
    336  1.36       tls 		}
    337  1.36       tls 		error = copyin(mop->reqs, cnop,
    338  1.36       tls 			    (mop->count * sizeof(struct crypt_n_op)));
    339  1.36       tls 		if(!error) {
    340  1.36       tls 			error = cryptodev_mop(fcr, cnop, mop->count,
    341  1.36       tls 					      curlwp);
    342  1.36       tls 			if (!error) {
    343  1.36       tls 				error = copyout(cnop, mop->reqs,
    344  1.36       tls 					        (mop->count *
    345  1.36       tls 						 sizeof(struct crypt_n_op)));
    346  1.36       tls 			}
    347  1.36       tls 		}
    348  1.36       tls 		kmem_free(cnop, (mop->count * sizeof(struct crypt_n_op)));
    349  1.36       tls 		break;
    350   1.1  jonathan 	case CIOCKEY:
    351   1.1  jonathan 		error = cryptodev_key((struct crypt_kop *)data);
    352  1.34       tls 		DPRINTF(("cryptodev_key error = %d\n", error));
    353   1.1  jonathan 		break;
    354  1.36       tls 	case CIOCNFKEYM:
    355  1.36       tls 		mkop = (struct crypt_mkop *)data;
    356  1.36       tls 		knop = kmem_alloc((mkop->count * sizeof(struct crypt_n_kop)),
    357  1.36       tls 				  KM_SLEEP);
    358  1.36       tls 		if (!knop) {
    359  1.36       tls 			return(EINVAL);
    360  1.36       tls 		}
    361  1.36       tls 		error = copyin(mkop->reqs, knop,
    362  1.36       tls 			    (mkop->count * sizeof(struct crypt_n_kop)));
    363  1.36       tls 		if (!error) {
    364  1.36       tls 			error = cryptodev_mkey(fcr, knop, mkop->count);
    365  1.36       tls 			if (!error)
    366  1.36       tls 				error = copyout(knop, mkop->reqs,
    367  1.36       tls 			    			(mkop->count *
    368  1.36       tls 						 sizeof(struct crypt_n_kop)));
    369  1.36       tls 		}
    370  1.36       tls 		kmem_free(knop, (mkop->count * sizeof(struct crypt_n_kop)));
    371  1.36       tls 		break;
    372   1.1  jonathan 	case CIOCASYMFEAT:
    373   1.1  jonathan 		error = crypto_getfeat((int *)data);
    374   1.1  jonathan 		break;
    375  1.36       tls 	case CIOCNCRYPTRETM:
    376  1.36       tls 		crypt_ret = (struct cryptret *)data;
    377  1.36       tls 		count = crypt_ret->count;
    378  1.36       tls 		crypt_res = kmem_alloc((count *
    379  1.36       tls 				      sizeof(struct crypt_result)),
    380  1.36       tls 				      KM_SLEEP);
    381  1.36       tls 		if(!crypt_res)
    382  1.36       tls 			return(EINVAL);
    383  1.36       tls 		error = copyin(crypt_ret->results, crypt_res,
    384  1.36       tls 			    (count * sizeof(struct crypt_result)));
    385  1.36       tls 		if (error)
    386  1.36       tls 			goto reterr;
    387  1.36       tls 		crypt_ret->count = cryptodev_getmstatus(fcr, crypt_res,
    388  1.36       tls 					crypt_ret->count);
    389  1.36       tls 		/* sanity check count */
    390  1.36       tls 		if (crypt_ret->count > count) {
    391  1.37    dogcow 			printf("%s.%d: error returned count %zd > original "
    392  1.37    dogcow 			       " count %zd\n",
    393  1.36       tls 				__FILE__, __LINE__, crypt_ret->count, count);
    394  1.36       tls 			crypt_ret->count = count;
    395  1.36       tls 
    396  1.36       tls 		}
    397  1.36       tls 		error = copyout(crypt_res, crypt_ret->results,
    398  1.36       tls 			    (crypt_ret->count * sizeof(struct crypt_result)));
    399  1.36       tls reterr:
    400  1.36       tls 		kmem_free(crypt_res,
    401  1.36       tls 			  (count * sizeof(struct crypt_result)));
    402  1.36       tls 		break;
    403  1.36       tls 	case CIOCNCRYPTRET:
    404  1.36       tls 		error = cryptodev_getstatus(fcr, (struct crypt_result *)data);
    405  1.36       tls 		break;
    406   1.1  jonathan 	default:
    407  1.18  christos 		DPRINTF(("invalid ioctl cmd %ld\n", cmd));
    408   1.1  jonathan 		error = EINVAL;
    409   1.1  jonathan 	}
    410   1.1  jonathan 	return (error);
    411   1.1  jonathan }
    412   1.1  jonathan 
    413   1.1  jonathan static int
    414  1.25  christos cryptodev_op(struct csession *cse, struct crypt_op *cop, struct lwp *l)
    415   1.1  jonathan {
    416   1.1  jonathan 	struct cryptop *crp = NULL;
    417   1.1  jonathan 	struct cryptodesc *crde = NULL, *crda = NULL;
    418  1.33       tls 	int error;
    419   1.1  jonathan 
    420   1.1  jonathan 	if (cop->len > 256*1024-4)
    421   1.1  jonathan 		return (E2BIG);
    422   1.1  jonathan 
    423  1.13  jonathan 	if (cse->txform) {
    424  1.13  jonathan 		if (cop->len == 0 || (cop->len % cse->txform->blocksize) != 0)
    425  1.13  jonathan 			return (EINVAL);
    426  1.13  jonathan 	}
    427   1.1  jonathan 
    428   1.1  jonathan 	bzero(&cse->uio, sizeof(cse->uio));
    429   1.1  jonathan 	cse->uio.uio_iovcnt = 1;
    430   1.1  jonathan 	cse->uio.uio_resid = 0;
    431   1.1  jonathan 	cse->uio.uio_rw = UIO_WRITE;
    432   1.1  jonathan 	cse->uio.uio_iov = cse->iovec;
    433  1.17      yamt 	UIO_SETUP_SYSSPACE(&cse->uio);
    434  1.29       tls 	memset(&cse->iovec, 0, sizeof(cse->iovec));
    435   1.1  jonathan 	cse->uio.uio_iov[0].iov_len = cop->len;
    436  1.36       tls 	cse->uio.uio_iov[0].iov_base = kmem_alloc(cop->len, KM_SLEEP);
    437  1.29       tls 	cse->uio.uio_resid = cse->uio.uio_iov[0].iov_len;
    438   1.1  jonathan 
    439   1.1  jonathan 	crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL));
    440   1.1  jonathan 	if (crp == NULL) {
    441   1.1  jonathan 		error = ENOMEM;
    442   1.1  jonathan 		goto bail;
    443   1.1  jonathan 	}
    444   1.1  jonathan 
    445   1.1  jonathan 	if (cse->thash) {
    446   1.1  jonathan 		crda = crp->crp_desc;
    447   1.1  jonathan 		if (cse->txform)
    448   1.1  jonathan 			crde = crda->crd_next;
    449   1.1  jonathan 	} else {
    450   1.1  jonathan 		if (cse->txform)
    451   1.1  jonathan 			crde = crp->crp_desc;
    452   1.1  jonathan 		else {
    453   1.1  jonathan 			error = EINVAL;
    454   1.1  jonathan 			goto bail;
    455   1.1  jonathan 		}
    456   1.1  jonathan 	}
    457   1.1  jonathan 
    458   1.1  jonathan 	if ((error = copyin(cop->src, cse->uio.uio_iov[0].iov_base, cop->len)))
    459  1.36       tls 	{
    460  1.36       tls 		printf("copyin failed %s %d \n", (char *)cop->src, error);
    461   1.1  jonathan 		goto bail;
    462  1.36       tls 	}
    463   1.1  jonathan 
    464   1.1  jonathan 	if (crda) {
    465   1.1  jonathan 		crda->crd_skip = 0;
    466   1.1  jonathan 		crda->crd_len = cop->len;
    467   1.1  jonathan 		crda->crd_inject = 0;	/* ??? */
    468   1.1  jonathan 
    469   1.1  jonathan 		crda->crd_alg = cse->mac;
    470   1.1  jonathan 		crda->crd_key = cse->mackey;
    471   1.1  jonathan 		crda->crd_klen = cse->mackeylen * 8;
    472   1.1  jonathan 	}
    473   1.1  jonathan 
    474   1.1  jonathan 	if (crde) {
    475   1.1  jonathan 		if (cop->op == COP_ENCRYPT)
    476   1.1  jonathan 			crde->crd_flags |= CRD_F_ENCRYPT;
    477   1.1  jonathan 		else
    478   1.1  jonathan 			crde->crd_flags &= ~CRD_F_ENCRYPT;
    479   1.1  jonathan 		crde->crd_len = cop->len;
    480   1.1  jonathan 		crde->crd_inject = 0;
    481   1.1  jonathan 
    482   1.1  jonathan 		crde->crd_alg = cse->cipher;
    483   1.1  jonathan 		crde->crd_key = cse->key;
    484   1.1  jonathan 		crde->crd_klen = cse->keylen * 8;
    485   1.1  jonathan 	}
    486   1.1  jonathan 
    487   1.1  jonathan 	crp->crp_ilen = cop->len;
    488  1.36       tls 	crp->crp_flags = CRYPTO_F_IOV | (cop->flags & COP_F_BATCH);
    489  1.26  christos 	crp->crp_buf = (void *)&cse->uio;
    490   1.1  jonathan 	crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_cb;
    491   1.1  jonathan 	crp->crp_sid = cse->sid;
    492   1.1  jonathan 	crp->crp_opaque = (void *)cse;
    493   1.1  jonathan 
    494   1.1  jonathan 	if (cop->iv) {
    495   1.1  jonathan 		if (crde == NULL) {
    496   1.1  jonathan 			error = EINVAL;
    497   1.1  jonathan 			goto bail;
    498   1.1  jonathan 		}
    499   1.1  jonathan 		if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
    500   1.1  jonathan 			error = EINVAL;
    501   1.1  jonathan 			goto bail;
    502   1.1  jonathan 		}
    503  1.36       tls 		if ((error = copyin(cop->iv, cse->tmp_iv,
    504  1.36       tls 				    cse->txform->blocksize)))
    505   1.1  jonathan 			goto bail;
    506   1.1  jonathan 		bcopy(cse->tmp_iv, crde->crd_iv, cse->txform->blocksize);
    507   1.1  jonathan 		crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
    508   1.1  jonathan 		crde->crd_skip = 0;
    509   1.1  jonathan 	} else if (crde) {
    510  1.20  christos 		if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
    511  1.20  christos 			crde->crd_skip = 0;
    512  1.20  christos 		} else {
    513  1.20  christos 			crde->crd_flags |= CRD_F_IV_PRESENT;
    514  1.20  christos 			crde->crd_skip = cse->txform->blocksize;
    515  1.20  christos 			crde->crd_len -= cse->txform->blocksize;
    516  1.20  christos 		}
    517   1.1  jonathan 	}
    518   1.1  jonathan 
    519   1.1  jonathan 	if (cop->mac) {
    520   1.1  jonathan 		if (crda == NULL) {
    521   1.1  jonathan 			error = EINVAL;
    522   1.1  jonathan 			goto bail;
    523   1.1  jonathan 		}
    524   1.1  jonathan 		crp->crp_mac=cse->tmp_mac;
    525   1.1  jonathan 	}
    526   1.1  jonathan 
    527  1.33       tls 	/*
    528  1.33       tls 	 * XXX there was a comment here which said that we went to
    529  1.33       tls 	 * XXX splcrypto() but needed to only if CRYPTO_F_CBIMM,
    530  1.33       tls 	 * XXX disabled on NetBSD since 1.6O due to a race condition.
    531  1.33       tls 	 * XXX But crypto_dispatch went to splcrypto() itself!  (And
    532  1.33       tls 	 * XXX now takes the crypto_mtx mutex itself).  We do, however,
    533  1.33       tls 	 * XXX need to hold the mutex across the call to cv_wait().
    534  1.33       tls 	 * XXX     (should we arrange for crypto_dispatch to return to
    535  1.33       tls 	 * XXX      us with it held?  it seems quite ugly to do so.)
    536  1.33       tls 	 */
    537  1.36       tls #ifdef notyet
    538  1.36       tls eagain:
    539  1.36       tls #endif
    540   1.1  jonathan 	error = crypto_dispatch(crp);
    541  1.33       tls 	mutex_spin_enter(&crypto_mtx);
    542  1.36       tls 
    543  1.36       tls 	switch (error) {
    544  1.36       tls #ifdef notyet	/* don't loop forever -- but EAGAIN not possible here yet */
    545  1.36       tls 	case EAGAIN:
    546  1.36       tls 		mutex_spin_exit(&crypto_mtx);
    547  1.36       tls 		goto eagain;
    548  1.36       tls 		break;
    549  1.36       tls #endif
    550  1.36       tls 	case 0:
    551  1.36       tls 		break;
    552  1.36       tls 	default:
    553  1.33       tls 		DPRINTF(("cryptodev_op: not waiting, error.\n"));
    554  1.33       tls 		mutex_spin_exit(&crypto_mtx);
    555   1.1  jonathan 		goto bail;
    556   1.1  jonathan 	}
    557  1.36       tls 
    558  1.33       tls 	while (!(crp->crp_flags & CRYPTO_F_DONE)) {
    559  1.33       tls 		DPRINTF(("cryptodev_op: sleeping on cv %08x for crp %08x\n", \
    560  1.33       tls 			(uint32_t)&crp->crp_cv, (uint32_t)crp));
    561  1.33       tls 		cv_wait(&crp->crp_cv, &crypto_mtx);	/* XXX cv_wait_sig? */
    562  1.33       tls 	}
    563  1.33       tls 	if (crp->crp_flags & CRYPTO_F_ONRETQ) {
    564  1.33       tls 		DPRINTF(("cryptodev_op: DONE, not woken by cryptoret.\n"));
    565  1.33       tls 		(void)crypto_ret_q_remove(crp);
    566  1.33       tls 	}
    567  1.33       tls 	mutex_spin_exit(&crypto_mtx);
    568   1.1  jonathan 
    569   1.1  jonathan 	if (crp->crp_etype != 0) {
    570  1.34       tls 		DPRINTF(("cryptodev_op: crp_etype %d\n", crp->crp_etype));
    571   1.1  jonathan 		error = crp->crp_etype;
    572   1.1  jonathan 		goto bail;
    573   1.1  jonathan 	}
    574   1.1  jonathan 
    575   1.1  jonathan 	if (cse->error) {
    576  1.34       tls 		DPRINTF(("cryptodev_op: cse->error %d\n", cse->error));
    577   1.1  jonathan 		error = cse->error;
    578   1.1  jonathan 		goto bail;
    579   1.1  jonathan 	}
    580   1.1  jonathan 
    581   1.1  jonathan 	if (cop->dst &&
    582  1.36       tls 	    (error = copyout(cse->uio.uio_iov[0].iov_base, cop->dst, cop->len)))
    583  1.36       tls 	{
    584  1.34       tls 		DPRINTF(("cryptodev_op: copyout error %d\n", error));
    585   1.1  jonathan 		goto bail;
    586  1.34       tls 	}
    587   1.1  jonathan 
    588   1.1  jonathan 	if (cop->mac &&
    589  1.34       tls 	    (error = copyout(crp->crp_mac, cop->mac, cse->thash->authsize))) {
    590  1.34       tls 		DPRINTF(("cryptodev_op: mac copyout error %d\n", error));
    591   1.1  jonathan 		goto bail;
    592  1.34       tls 	}
    593   1.1  jonathan 
    594   1.1  jonathan bail:
    595   1.1  jonathan 	if (crp)
    596   1.1  jonathan 		crypto_freereq(crp);
    597   1.1  jonathan 	if (cse->uio.uio_iov[0].iov_base)
    598  1.36       tls 		kmem_free(cse->uio.uio_iov[0].iov_base,
    599  1.36       tls 			  cse->uio.uio_iov[0].iov_len);
    600   1.1  jonathan 
    601   1.1  jonathan 	return (error);
    602   1.1  jonathan }
    603   1.1  jonathan 
    604   1.1  jonathan static int
    605   1.1  jonathan cryptodev_cb(void *op)
    606   1.1  jonathan {
    607   1.1  jonathan 	struct cryptop *crp = (struct cryptop *) op;
    608   1.1  jonathan 	struct csession *cse = (struct csession *)crp->crp_opaque;
    609  1.33       tls 	int error = 0;
    610   1.1  jonathan 
    611  1.33       tls 	mutex_spin_enter(&crypto_mtx);
    612   1.1  jonathan 	cse->error = crp->crp_etype;
    613  1.33       tls 	if (crp->crp_etype == EAGAIN) {
    614  1.33       tls 		/* always drop mutex to call dispatch routine */
    615  1.33       tls 		mutex_spin_exit(&crypto_mtx);
    616  1.33       tls 		error = crypto_dispatch(crp);
    617  1.33       tls 		mutex_spin_enter(&crypto_mtx);
    618  1.33       tls 	}
    619  1.33       tls 	if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
    620  1.33       tls 		cv_signal(&crp->crp_cv);
    621  1.33       tls 	}
    622  1.33       tls 	mutex_spin_exit(&crypto_mtx);
    623   1.1  jonathan 	return (0);
    624   1.1  jonathan }
    625   1.1  jonathan 
    626   1.1  jonathan static int
    627  1.36       tls cryptodev_mcb(void *op)
    628  1.36       tls {
    629  1.36       tls 	struct cryptop *crp = (struct cryptop *) op;
    630  1.36       tls 	struct csession *cse = (struct csession *)crp->crp_opaque;
    631  1.36       tls 	int  error=0;
    632  1.36       tls 
    633  1.36       tls 	mutex_spin_enter(&crypto_mtx);
    634  1.36       tls 	cse->error = crp->crp_etype;
    635  1.36       tls 	if (crp->crp_etype == EAGAIN) {
    636  1.36       tls 		mutex_spin_exit(&crypto_mtx);
    637  1.36       tls 		error = crypto_dispatch(crp);
    638  1.36       tls 		mutex_spin_enter(&crypto_mtx);
    639  1.36       tls 	}
    640  1.36       tls 	if (error != 0 || (crp->crp_flags & CRYPTO_F_DONE)) {
    641  1.36       tls 		cv_signal(&crp->crp_cv);
    642  1.36       tls 	}
    643  1.36       tls 
    644  1.36       tls 	TAILQ_INSERT_TAIL(&crp->fcrp->crp_ret_mq, crp, crp_next);
    645  1.38     rmind 	selnotify(&crp->fcrp->sinfo, 0, 0);
    646  1.36       tls 	mutex_spin_exit(&crypto_mtx);
    647  1.36       tls 	return (0);
    648  1.36       tls }
    649  1.36       tls 
    650  1.36       tls static int
    651   1.1  jonathan cryptodevkey_cb(void *op)
    652   1.1  jonathan {
    653   1.1  jonathan 	struct cryptkop *krp = (struct cryptkop *) op;
    654  1.36       tls 
    655  1.36       tls 	mutex_spin_enter(&crypto_mtx);
    656  1.36       tls 	cv_signal(&krp->krp_cv);
    657  1.36       tls 	mutex_spin_exit(&crypto_mtx);
    658  1.36       tls 	return (0);
    659  1.36       tls }
    660  1.36       tls 
    661  1.36       tls static int
    662  1.36       tls cryptodevkey_mcb(void *op)
    663  1.36       tls {
    664  1.36       tls 	struct cryptkop *krp = (struct cryptkop *) op;
    665   1.1  jonathan 
    666  1.33       tls 	mutex_spin_enter(&crypto_mtx);
    667  1.33       tls 	cv_signal(&krp->krp_cv);
    668  1.36       tls 	TAILQ_INSERT_TAIL(&krp->fcrp->crp_ret_mkq, krp, krp_next);
    669  1.38     rmind 	selnotify(&krp->fcrp->sinfo, 0, 0);
    670  1.33       tls 	mutex_spin_exit(&crypto_mtx);
    671   1.1  jonathan 	return (0);
    672   1.1  jonathan }
    673   1.1  jonathan 
    674   1.1  jonathan static int
    675   1.1  jonathan cryptodev_key(struct crypt_kop *kop)
    676   1.1  jonathan {
    677   1.1  jonathan 	struct cryptkop *krp = NULL;
    678   1.1  jonathan 	int error = EINVAL;
    679   1.1  jonathan 	int in, out, size, i;
    680   1.1  jonathan 
    681   1.1  jonathan 	if (kop->crk_iparams + kop->crk_oparams > CRK_MAXPARAM) {
    682   1.1  jonathan 		return (EFBIG);
    683   1.1  jonathan 	}
    684   1.1  jonathan 
    685   1.1  jonathan 	in = kop->crk_iparams;
    686   1.1  jonathan 	out = kop->crk_oparams;
    687   1.1  jonathan 	switch (kop->crk_op) {
    688   1.1  jonathan 	case CRK_MOD_EXP:
    689   1.1  jonathan 		if (in == 3 && out == 1)
    690   1.1  jonathan 			break;
    691   1.1  jonathan 		return (EINVAL);
    692   1.1  jonathan 	case CRK_MOD_EXP_CRT:
    693   1.1  jonathan 		if (in == 6 && out == 1)
    694   1.1  jonathan 			break;
    695   1.1  jonathan 		return (EINVAL);
    696   1.1  jonathan 	case CRK_DSA_SIGN:
    697   1.1  jonathan 		if (in == 5 && out == 2)
    698   1.1  jonathan 			break;
    699   1.1  jonathan 		return (EINVAL);
    700   1.1  jonathan 	case CRK_DSA_VERIFY:
    701   1.1  jonathan 		if (in == 7 && out == 0)
    702   1.1  jonathan 			break;
    703   1.1  jonathan 		return (EINVAL);
    704   1.1  jonathan 	case CRK_DH_COMPUTE_KEY:
    705   1.1  jonathan 		if (in == 3 && out == 1)
    706   1.1  jonathan 			break;
    707   1.1  jonathan 		return (EINVAL);
    708  1.27       tls 	case CRK_MOD_ADD:
    709  1.27       tls 		if (in == 3 && out == 1)
    710  1.27       tls 			break;
    711  1.27       tls 		return (EINVAL);
    712  1.27       tls 	case CRK_MOD_ADDINV:
    713  1.27       tls 		if (in == 2 && out == 1)
    714  1.27       tls 			break;
    715  1.27       tls 		return (EINVAL);
    716  1.27       tls 	case CRK_MOD_SUB:
    717  1.27       tls 		if (in == 3 && out == 1)
    718  1.27       tls 			break;
    719  1.27       tls 		return (EINVAL);
    720  1.27       tls 	case CRK_MOD_MULT:
    721  1.27       tls 		if (in == 3 && out == 1)
    722  1.27       tls 			break;
    723  1.27       tls 		return (EINVAL);
    724  1.27       tls 	case CRK_MOD_MULTINV:
    725  1.27       tls 		if (in == 2 && out == 1)
    726  1.27       tls 			break;
    727  1.27       tls 		return (EINVAL);
    728  1.27       tls 	case CRK_MOD:
    729  1.27       tls 		if (in == 2 && out == 1)
    730  1.27       tls 			break;
    731  1.27       tls 		return (EINVAL);
    732   1.1  jonathan 	default:
    733   1.1  jonathan 		return (EINVAL);
    734   1.1  jonathan 	}
    735   1.1  jonathan 
    736  1.33       tls 	krp = pool_get(&cryptkop_pool, PR_WAITOK);
    737   1.1  jonathan 	if (!krp)
    738   1.1  jonathan 		return (ENOMEM);
    739   1.1  jonathan 	bzero(krp, sizeof *krp);
    740  1.33       tls 	cv_init(&krp->krp_cv, "crykdev");
    741   1.1  jonathan 	krp->krp_op = kop->crk_op;
    742   1.1  jonathan 	krp->krp_status = kop->crk_status;
    743   1.1  jonathan 	krp->krp_iparams = kop->crk_iparams;
    744   1.1  jonathan 	krp->krp_oparams = kop->crk_oparams;
    745   1.1  jonathan 	krp->krp_status = 0;
    746   1.1  jonathan 	krp->krp_callback = (int (*) (struct cryptkop *)) cryptodevkey_cb;
    747   1.1  jonathan 
    748   1.1  jonathan 	for (i = 0; i < CRK_MAXPARAM; i++)
    749   1.1  jonathan 		krp->krp_param[i].crp_nbits = kop->crk_param[i].crp_nbits;
    750   1.1  jonathan 	for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
    751   1.1  jonathan 		size = (krp->krp_param[i].crp_nbits + 7) / 8;
    752   1.1  jonathan 		if (size == 0)
    753   1.1  jonathan 			continue;
    754  1.36       tls 		krp->krp_param[i].crp_p = kmem_alloc(size, KM_SLEEP);
    755   1.1  jonathan 		if (i >= krp->krp_iparams)
    756   1.1  jonathan 			continue;
    757   1.1  jonathan 		error = copyin(kop->crk_param[i].crp_p, krp->krp_param[i].crp_p, size);
    758   1.1  jonathan 		if (error)
    759   1.1  jonathan 			goto fail;
    760   1.1  jonathan 	}
    761   1.1  jonathan 
    762   1.1  jonathan 	error = crypto_kdispatch(krp);
    763  1.33       tls 	if (error != 0) {
    764   1.1  jonathan 		goto fail;
    765  1.33       tls 	}
    766  1.33       tls 
    767  1.33       tls 	mutex_spin_enter(&crypto_mtx);
    768  1.33       tls 	while (!(krp->krp_flags & CRYPTO_F_DONE)) {
    769  1.33       tls 		cv_wait(&krp->krp_cv, &crypto_mtx);	/* XXX cv_wait_sig? */
    770  1.33       tls 	}
    771  1.33       tls 	if (krp->krp_flags & CRYPTO_F_ONRETQ) {
    772  1.33       tls 		DPRINTF(("cryptodev_key: DONE early, not via cryptoret.\n"));
    773  1.33       tls 		(void)crypto_ret_kq_remove(krp);
    774  1.33       tls 	}
    775  1.33       tls 	mutex_spin_exit(&crypto_mtx);
    776   1.1  jonathan 
    777   1.1  jonathan 	if (krp->krp_status != 0) {
    778  1.34       tls 		DPRINTF(("cryptodev_key: krp->krp_status 0x%08x\n", krp->krp_status));
    779   1.1  jonathan 		error = krp->krp_status;
    780   1.1  jonathan 		goto fail;
    781   1.1  jonathan 	}
    782   1.1  jonathan 
    783   1.1  jonathan 	for (i = krp->krp_iparams; i < krp->krp_iparams + krp->krp_oparams; i++) {
    784   1.1  jonathan 		size = (krp->krp_param[i].crp_nbits + 7) / 8;
    785   1.1  jonathan 		if (size == 0)
    786   1.1  jonathan 			continue;
    787   1.1  jonathan 		error = copyout(krp->krp_param[i].crp_p, kop->crk_param[i].crp_p, size);
    788  1.34       tls 		if (error) {
    789  1.34       tls 			DPRINTF(("cryptodev_key: copyout oparam %d failed, error=%d\n", i-krp->krp_iparams, error));
    790   1.1  jonathan 			goto fail;
    791  1.34       tls 		}
    792   1.1  jonathan 	}
    793   1.1  jonathan 
    794   1.1  jonathan fail:
    795   1.1  jonathan 	if (krp) {
    796   1.1  jonathan 		kop->crk_status = krp->krp_status;
    797   1.1  jonathan 		for (i = 0; i < CRK_MAXPARAM; i++) {
    798  1.36       tls 			struct crparam *kp = &(krp->krp_param[i]);
    799  1.36       tls 			if (krp->krp_param[i].crp_p) {
    800  1.36       tls 				size = (kp->crp_nbits + 7)  / 8;
    801  1.36       tls 				KASSERT(size > 0);
    802  1.36       tls 				memset(kp->crp_p, 0, size);
    803  1.36       tls 				kmem_free(kp->crp_p, size);
    804  1.36       tls 			}
    805   1.1  jonathan 		}
    806  1.33       tls 		pool_put(&cryptkop_pool, krp);
    807   1.1  jonathan 	}
    808  1.34       tls 	DPRINTF(("cryptodev_key: error=0x%08x\n", error));
    809   1.1  jonathan 	return (error);
    810   1.1  jonathan }
    811   1.1  jonathan 
    812   1.1  jonathan /* ARGSUSED */
    813   1.1  jonathan static int
    814  1.36       tls cryptof_close(struct file *fp)
    815   1.1  jonathan {
    816  1.35        ad 	struct fcrypt *fcr = fp->f_data;
    817   1.1  jonathan 	struct csession *cse;
    818   1.1  jonathan 
    819  1.33       tls 	mutex_spin_enter(&crypto_mtx);
    820   1.1  jonathan 	while ((cse = TAILQ_FIRST(&fcr->csessions))) {
    821   1.1  jonathan 		TAILQ_REMOVE(&fcr->csessions, cse, next);
    822   1.1  jonathan 		(void)csefree(cse);
    823   1.1  jonathan 	}
    824  1.36       tls 	seldestroy(&fcr->sinfo);
    825   1.1  jonathan 	fp->f_data = NULL;
    826  1.33       tls 	mutex_spin_exit(&crypto_mtx);
    827   1.1  jonathan 
    828  1.38     rmind 	pool_put(&fcrpl, fcr);
    829   1.1  jonathan 	return 0;
    830   1.1  jonathan }
    831   1.1  jonathan 
    832  1.33       tls /* csefind: call with crypto_mtx held. */
    833   1.1  jonathan static struct csession *
    834   1.1  jonathan csefind(struct fcrypt *fcr, u_int ses)
    835   1.1  jonathan {
    836  1.33       tls 	struct csession *cse, *ret = NULL;
    837   1.1  jonathan 
    838  1.33       tls 	KASSERT(mutex_owned(&crypto_mtx));
    839   1.1  jonathan 	TAILQ_FOREACH(cse, &fcr->csessions, next)
    840   1.1  jonathan 		if (cse->ses == ses)
    841  1.33       tls 			ret = cse;
    842  1.36       tls 
    843  1.33       tls 	return (ret);
    844   1.1  jonathan }
    845   1.1  jonathan 
    846  1.33       tls /* csedelete: call with crypto_mtx held. */
    847   1.1  jonathan static int
    848   1.1  jonathan csedelete(struct fcrypt *fcr, struct csession *cse_del)
    849   1.1  jonathan {
    850   1.1  jonathan 	struct csession *cse;
    851  1.33       tls 	int ret = 0;
    852   1.1  jonathan 
    853  1.33       tls 	KASSERT(mutex_owned(&crypto_mtx));
    854   1.1  jonathan 	TAILQ_FOREACH(cse, &fcr->csessions, next) {
    855   1.1  jonathan 		if (cse == cse_del) {
    856   1.1  jonathan 			TAILQ_REMOVE(&fcr->csessions, cse, next);
    857  1.33       tls 			ret = 1;
    858   1.1  jonathan 		}
    859   1.1  jonathan 	}
    860  1.33       tls 	return (ret);
    861   1.1  jonathan }
    862   1.1  jonathan 
    863  1.33       tls /* cseadd: call with crypto_mtx held. */
    864   1.1  jonathan static struct csession *
    865   1.1  jonathan cseadd(struct fcrypt *fcr, struct csession *cse)
    866   1.1  jonathan {
    867  1.33       tls 	KASSERT(mutex_owned(&crypto_mtx));
    868  1.33       tls 	/* don't let session ID wrap! */
    869  1.33       tls 	if (fcr->sesn + 1 == 0) return NULL;
    870   1.1  jonathan 	TAILQ_INSERT_TAIL(&fcr->csessions, cse, next);
    871   1.1  jonathan 	cse->ses = fcr->sesn++;
    872   1.1  jonathan 	return (cse);
    873   1.1  jonathan }
    874   1.1  jonathan 
    875  1.33       tls /* csecreate: call with crypto_mtx held. */
    876   1.1  jonathan static struct csession *
    877  1.26  christos csecreate(struct fcrypt *fcr, u_int64_t sid, void *key, u_int64_t keylen,
    878  1.26  christos     void *mackey, u_int64_t mackeylen, u_int32_t cipher, u_int32_t mac,
    879   1.1  jonathan     struct enc_xform *txform, struct auth_hash *thash)
    880   1.1  jonathan {
    881   1.1  jonathan 	struct csession *cse;
    882   1.1  jonathan 
    883  1.33       tls 	KASSERT(mutex_owned(&crypto_mtx));
    884  1.29       tls 	cse = pool_get(&csepl, PR_NOWAIT);
    885   1.1  jonathan 	if (cse == NULL)
    886   1.1  jonathan 		return NULL;
    887   1.1  jonathan 	cse->key = key;
    888   1.1  jonathan 	cse->keylen = keylen/8;
    889   1.1  jonathan 	cse->mackey = mackey;
    890   1.1  jonathan 	cse->mackeylen = mackeylen/8;
    891   1.1  jonathan 	cse->sid = sid;
    892   1.1  jonathan 	cse->cipher = cipher;
    893   1.1  jonathan 	cse->mac = mac;
    894   1.1  jonathan 	cse->txform = txform;
    895   1.1  jonathan 	cse->thash = thash;
    896  1.34       tls 	cse->error = 0;
    897  1.28       tls 	if (cseadd(fcr, cse))
    898  1.28       tls 		return (cse);
    899  1.28       tls 	else {
    900  1.33       tls 		pool_put(&csepl, cse);
    901  1.28       tls 		return NULL;
    902  1.28       tls 	}
    903   1.1  jonathan }
    904   1.1  jonathan 
    905  1.33       tls /* csefree: call with crypto_mtx held. */
    906   1.1  jonathan static int
    907   1.1  jonathan csefree(struct csession *cse)
    908   1.1  jonathan {
    909   1.1  jonathan 	int error;
    910   1.1  jonathan 
    911  1.33       tls 	KASSERT(mutex_owned(&crypto_mtx));
    912   1.1  jonathan 	error = crypto_freesession(cse->sid);
    913   1.1  jonathan 	if (cse->key)
    914  1.36       tls 		free(cse->key, M_XDATA);
    915   1.1  jonathan 	if (cse->mackey)
    916  1.36       tls 		free(cse->mackey, M_XDATA);
    917  1.29       tls 	pool_put(&csepl, cse);
    918   1.1  jonathan 	return (error);
    919   1.1  jonathan }
    920   1.1  jonathan 
    921   1.1  jonathan static int
    922  1.25  christos cryptoopen(dev_t dev, int flag, int mode,
    923  1.25  christos     struct lwp *l)
    924   1.1  jonathan {
    925  1.35        ad 	file_t *fp;
    926  1.29       tls         struct fcrypt *fcr;
    927  1.29       tls         int fd, error;
    928  1.29       tls 
    929   1.1  jonathan 	if (crypto_usercrypto == 0)
    930   1.1  jonathan 		return (ENXIO);
    931  1.29       tls 
    932  1.35        ad 	if ((error = fd_allocfile(&fp, &fd)) != 0)
    933  1.29       tls 		return error;
    934  1.29       tls 
    935  1.29       tls 	fcr = pool_get(&fcrpl, PR_WAITOK);
    936  1.36       tls 	if (fcr == NULL) {
    937  1.36       tls 		fd_abort(curproc, fp, fd);
    938  1.36       tls 		return ENOMEM;
    939  1.36       tls 	}
    940  1.33       tls 	mutex_spin_enter(&crypto_mtx);
    941  1.29       tls 	TAILQ_INIT(&fcr->csessions);
    942  1.36       tls 	TAILQ_INIT(&fcr->crp_ret_mq);
    943  1.36       tls 	TAILQ_INIT(&fcr->crp_ret_mkq);
    944  1.36       tls 	selinit(&fcr->sinfo);
    945  1.29       tls 	/*
    946  1.29       tls 	 * Don't ever return session 0, to allow detection of
    947  1.29       tls 	 * failed creation attempts with multi-create ioctl.
    948  1.29       tls 	 */
    949  1.29       tls 	fcr->sesn = 1;
    950  1.36       tls 	fcr->requestid = 1;
    951  1.33       tls 	mutex_spin_exit(&crypto_mtx);
    952  1.35        ad 	return fd_clone(fp, fd, flag, &cryptofops, fcr);
    953   1.1  jonathan }
    954   1.1  jonathan 
    955   1.1  jonathan static int
    956  1.25  christos cryptoread(dev_t dev, struct uio *uio, int ioflag)
    957   1.1  jonathan {
    958   1.1  jonathan 	return (EIO);
    959   1.1  jonathan }
    960   1.1  jonathan 
    961   1.1  jonathan static int
    962  1.25  christos cryptowrite(dev_t dev, struct uio *uio, int ioflag)
    963   1.1  jonathan {
    964   1.1  jonathan 	return (EIO);
    965   1.1  jonathan }
    966   1.1  jonathan 
    967   1.1  jonathan int
    968  1.25  christos cryptoselect(dev_t dev, int rw, struct lwp *l)
    969   1.1  jonathan {
    970   1.1  jonathan 	return (0);
    971   1.1  jonathan }
    972   1.1  jonathan 
    973   1.1  jonathan /*static*/
    974   1.1  jonathan struct cdevsw crypto_cdevsw = {
    975   1.1  jonathan 	/* open */	cryptoopen,
    976  1.29       tls 	/* close */	noclose,
    977   1.1  jonathan 	/* read */	cryptoread,
    978   1.1  jonathan 	/* write */	cryptowrite,
    979  1.29       tls 	/* ioctl */	noioctl,
    980   1.1  jonathan 	/* ttstop?*/	nostop,
    981   1.1  jonathan 	/* ??*/		notty,
    982   1.1  jonathan 	/* poll */	cryptoselect /*nopoll*/,
    983   1.1  jonathan 	/* mmap */	nommap,
    984   1.1  jonathan 	/* kqfilter */	nokqfilter,
    985  1.23  christos 	/* type */	D_OTHER,
    986   1.1  jonathan };
    987   1.1  jonathan 
    988  1.36       tls static int
    989  1.36       tls cryptodev_mop(struct fcrypt *fcr,
    990  1.36       tls               struct crypt_n_op * cnop,
    991  1.36       tls               int count, struct lwp *l)
    992  1.36       tls {
    993  1.36       tls 	struct cryptop *crp = NULL;
    994  1.36       tls 	struct cryptodesc *crde = NULL, *crda = NULL;
    995  1.36       tls 	int req, error=0;
    996  1.36       tls 	struct csession *cse;
    997  1.36       tls 
    998  1.36       tls 	for (req = 0; req < count; req++) {
    999  1.36       tls 		mutex_spin_enter(&crypto_mtx);
   1000  1.36       tls 		cse = csefind(fcr, cnop[req].ses);
   1001  1.36       tls 		if (cse == NULL) {
   1002  1.36       tls 			DPRINTF(("csefind failed\n"));
   1003  1.36       tls 			cnop[req].status = EINVAL;
   1004  1.36       tls 			mutex_spin_exit(&crypto_mtx);
   1005  1.36       tls 			continue;
   1006  1.36       tls 		}
   1007  1.36       tls 		mutex_spin_exit(&crypto_mtx);
   1008  1.36       tls 
   1009  1.36       tls 		if (cnop[req].len > 256*1024-4) {
   1010  1.36       tls 			DPRINTF(("length failed\n"));
   1011  1.36       tls 			cnop[req].status = EINVAL;
   1012  1.36       tls 			continue;
   1013  1.36       tls 		}
   1014  1.36       tls 		if (cse->txform) {
   1015  1.36       tls 			if (cnop[req].len == 0 ||
   1016  1.36       tls 			    (cnop[req].len % cse->txform->blocksize) != 0) {
   1017  1.36       tls 				cnop[req].status = EINVAL;
   1018  1.36       tls 				continue;
   1019  1.36       tls 			}
   1020  1.36       tls 		}
   1021  1.36       tls 
   1022  1.36       tls 		crp = crypto_getreq((cse->txform != NULL) + (cse->thash != NULL));
   1023  1.36       tls 		if (crp == NULL) {
   1024  1.36       tls 			cnop[req].status = ENOMEM;
   1025  1.36       tls 			goto bail;
   1026  1.36       tls 		}
   1027  1.36       tls 
   1028  1.36       tls 		bzero(&crp->uio, sizeof(crp->uio));
   1029  1.36       tls 		crp->uio.uio_iovcnt = 1;
   1030  1.36       tls 		crp->uio.uio_resid = 0;
   1031  1.36       tls 		crp->uio.uio_rw = UIO_WRITE;
   1032  1.36       tls 		crp->uio.uio_iov = crp->iovec;
   1033  1.36       tls 		UIO_SETUP_SYSSPACE(&crp->uio);
   1034  1.36       tls 		memset(&crp->iovec, 0, sizeof(crp->iovec));
   1035  1.36       tls 		crp->uio.uio_iov[0].iov_len = cnop[req].len;
   1036  1.36       tls 		crp->uio.uio_iov[0].iov_base = kmem_alloc(cnop[req].len,
   1037  1.36       tls 							  KM_SLEEP);
   1038  1.36       tls 		crp->uio.uio_resid = crp->uio.uio_iov[0].iov_len;
   1039  1.36       tls 
   1040  1.36       tls 		if (cse->thash) {
   1041  1.36       tls 			crda = crp->crp_desc;
   1042  1.36       tls 			if (cse->txform)
   1043  1.36       tls 				crde = crda->crd_next;
   1044  1.36       tls 		} else {
   1045  1.36       tls 			if (cse->txform)
   1046  1.36       tls 				crde = crp->crp_desc;
   1047  1.36       tls 			else {
   1048  1.36       tls 				cnop[req].status = EINVAL;
   1049  1.36       tls 				goto bail;
   1050  1.36       tls 			}
   1051  1.36       tls 		}
   1052  1.36       tls 
   1053  1.36       tls 		if ((copyin(cnop[req].src,
   1054  1.36       tls 		    crp->uio.uio_iov[0].iov_base, cnop[req].len))) {
   1055  1.36       tls 			cnop[req].status = EINVAL;
   1056  1.36       tls 			goto bail;
   1057  1.36       tls 		}
   1058  1.36       tls 
   1059  1.36       tls 		if (crda) {
   1060  1.36       tls 			crda->crd_skip = 0;
   1061  1.36       tls 			crda->crd_len = cnop[req].len;
   1062  1.36       tls 			crda->crd_inject = 0;	/* ??? */
   1063  1.36       tls 
   1064  1.36       tls 			crda->crd_alg = cse->mac;
   1065  1.36       tls 			crda->crd_key = cse->mackey;
   1066  1.36       tls 			crda->crd_klen = cse->mackeylen * 8;
   1067  1.36       tls 		}
   1068  1.36       tls 
   1069  1.36       tls 		if (crde) {
   1070  1.36       tls 			if (cnop[req].op == COP_ENCRYPT)
   1071  1.36       tls 				crde->crd_flags |= CRD_F_ENCRYPT;
   1072  1.36       tls 			else
   1073  1.36       tls 				crde->crd_flags &= ~CRD_F_ENCRYPT;
   1074  1.36       tls 			crde->crd_len = cnop[req].len;
   1075  1.36       tls 			crde->crd_inject = 0;
   1076  1.36       tls 
   1077  1.36       tls 			crde->crd_alg = cse->cipher;
   1078  1.36       tls #ifdef notyet		/* XXX must notify h/w driver new key, drain */
   1079  1.36       tls 			if(cnop[req].key && cnop[req].keylen) {
   1080  1.36       tls 				crde->crd_key = malloc(cnop[req].keylen,
   1081  1.36       tls 						    M_XDATA, M_WAITOK);
   1082  1.36       tls 				if((error = copyin(cnop[req].key,
   1083  1.36       tls 				    crde->crd_key, cnop[req].keylen))) {
   1084  1.36       tls 					cnop[req].status = EINVAL;
   1085  1.36       tls 					goto bail;
   1086  1.36       tls 				}
   1087  1.36       tls 				crde->crd_klen =  cnop[req].keylen * 8;
   1088  1.36       tls 			} else { ... }
   1089  1.36       tls #endif
   1090  1.36       tls 			crde->crd_key = cse->key;
   1091  1.36       tls 			crde->crd_klen = cse->keylen * 8;
   1092  1.36       tls 		}
   1093  1.36       tls 
   1094  1.36       tls 		crp->crp_ilen = cnop[req].len;
   1095  1.36       tls 		crp->crp_flags = CRYPTO_F_IOV | CRYPTO_F_CBIMM
   1096  1.36       tls 				    | (cnop[req].flags & COP_F_BATCH);
   1097  1.36       tls 		crp->crp_buf = (void *)&crp->uio;
   1098  1.36       tls 		crp->crp_callback = (int (*) (struct cryptop *)) cryptodev_mcb;
   1099  1.36       tls 		crp->crp_sid = cse->sid;
   1100  1.36       tls 		crp->crp_opaque = (void *)cse;
   1101  1.36       tls 		crp->fcrp = fcr;
   1102  1.36       tls 		crp->dst = cnop[req].dst;
   1103  1.36       tls 		/* we can use the crp_ilen in cryptop(crp) for this */
   1104  1.36       tls 		crp->len = cnop[req].len;
   1105  1.36       tls 		crp->mac = cnop[req].mac;
   1106  1.36       tls 
   1107  1.36       tls 		if (cnop[req].iv) {
   1108  1.36       tls 			if (crde == NULL) {
   1109  1.36       tls 				cnop[req].status = EINVAL;
   1110  1.36       tls 				goto bail;
   1111  1.36       tls 			}
   1112  1.36       tls 			if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
   1113  1.36       tls 				cnop[req].status = EINVAL;
   1114  1.36       tls 				goto bail;
   1115  1.36       tls 			}
   1116  1.36       tls 			if ((error = copyin(cnop[req].iv, crp->tmp_iv,
   1117  1.36       tls 			    cse->txform->blocksize))) {
   1118  1.36       tls 				cnop[req].status = EINVAL;
   1119  1.36       tls 				goto bail;
   1120  1.36       tls 			}
   1121  1.36       tls 			bcopy(crp->tmp_iv, crde->crd_iv, cse->txform->blocksize);
   1122  1.36       tls 			crde->crd_flags |= CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
   1123  1.36       tls 			crde->crd_skip = 0;
   1124  1.36       tls 		} else if (crde) {
   1125  1.36       tls 			if (cse->cipher == CRYPTO_ARC4) { /* XXX use flag? */
   1126  1.36       tls 				crde->crd_skip = 0;
   1127  1.36       tls 			} else {
   1128  1.36       tls 				crde->crd_flags |= CRD_F_IV_PRESENT;
   1129  1.36       tls 				crde->crd_skip = cse->txform->blocksize;
   1130  1.36       tls 				crde->crd_len -= cse->txform->blocksize;
   1131  1.36       tls 			}
   1132  1.36       tls 		}
   1133  1.36       tls 
   1134  1.36       tls 		if (cnop[req].mac) {
   1135  1.36       tls 			if (crda == NULL) {
   1136  1.36       tls 				cnop[req].status = EINVAL;
   1137  1.36       tls 				goto bail;
   1138  1.36       tls 			}
   1139  1.36       tls 			crp->crp_mac=cse->tmp_mac;
   1140  1.36       tls 		}
   1141  1.36       tls 		cnop[req].reqid = atomic_inc_32_nv(&(fcr->requestid));
   1142  1.36       tls 		crp->crp_reqid = cnop[req].reqid;
   1143  1.36       tls 		crp->crp_usropaque = cnop[req].opaque;
   1144  1.36       tls #ifdef notyet
   1145  1.36       tls eagain:
   1146  1.36       tls #endif
   1147  1.36       tls 		cnop[req].status = crypto_dispatch(crp);
   1148  1.36       tls 		mutex_spin_enter(&crypto_mtx);	/* XXX why mutex? */
   1149  1.36       tls 
   1150  1.36       tls 		switch (cnop[req].status) {
   1151  1.36       tls #ifdef notyet	/* don't loop forever -- but EAGAIN not possible here yet */
   1152  1.36       tls 		case EAGAIN:
   1153  1.36       tls 			mutex_spin_exit(&crypto_mtx);
   1154  1.36       tls 			goto eagain;
   1155  1.36       tls 			break;
   1156  1.36       tls #endif
   1157  1.36       tls 		case 0:
   1158  1.36       tls 			break;
   1159  1.36       tls 		default:
   1160  1.36       tls 			DPRINTF(("cryptodev_op: not waiting, error.\n"));
   1161  1.36       tls 			mutex_spin_exit(&crypto_mtx);
   1162  1.36       tls 			goto bail;
   1163  1.36       tls 		}
   1164  1.36       tls 
   1165  1.36       tls 		mutex_spin_exit(&crypto_mtx);
   1166  1.36       tls bail:
   1167  1.36       tls 		if (cnop[req].status) {
   1168  1.36       tls 			if (crp) {
   1169  1.36       tls 				crypto_freereq(crp);
   1170  1.36       tls 				if(cse->uio.uio_iov[0].iov_base) {
   1171  1.36       tls 					kmem_free(cse->uio.uio_iov[0].iov_base,
   1172  1.36       tls 						  cse->uio.uio_iov[0].iov_len);
   1173  1.36       tls 				}
   1174  1.36       tls 			}
   1175  1.36       tls 			error = 0;
   1176  1.36       tls 		}
   1177  1.36       tls 	}
   1178  1.36       tls 	return (error);
   1179  1.36       tls }
   1180  1.36       tls 
   1181  1.36       tls static int
   1182  1.36       tls cryptodev_mkey(struct fcrypt *fcr, struct crypt_n_kop *kop, int count)
   1183  1.36       tls {
   1184  1.36       tls 	struct cryptkop *krp = NULL;
   1185  1.36       tls 	int error = EINVAL;
   1186  1.36       tls 	int in, out, size, i, req;
   1187  1.36       tls 
   1188  1.36       tls 	for (req = 0; req < count; req++) {
   1189  1.36       tls 		if (kop[req].crk_iparams + kop[req].crk_oparams > CRK_MAXPARAM) {
   1190  1.36       tls 			return (EFBIG);
   1191  1.36       tls 		}
   1192  1.36       tls 
   1193  1.36       tls 		in = kop[req].crk_iparams;
   1194  1.36       tls 		out = kop[req].crk_oparams;
   1195  1.36       tls 		switch (kop[req].crk_op) {
   1196  1.36       tls 		case CRK_MOD_EXP:
   1197  1.36       tls 			if (in == 3 && out == 1)
   1198  1.36       tls 				break;
   1199  1.36       tls 			kop[req].crk_status = EINVAL;
   1200  1.36       tls 			continue;
   1201  1.36       tls 		case CRK_MOD_EXP_CRT:
   1202  1.36       tls 			if (in == 6 && out == 1)
   1203  1.36       tls 				break;
   1204  1.36       tls 			kop[req].crk_status = EINVAL;
   1205  1.36       tls 			continue;
   1206  1.36       tls 		case CRK_DSA_SIGN:
   1207  1.36       tls 			if (in == 5 && out == 2)
   1208  1.36       tls 				break;
   1209  1.36       tls 			kop[req].crk_status = EINVAL;
   1210  1.36       tls 			continue;
   1211  1.36       tls 		case CRK_DSA_VERIFY:
   1212  1.36       tls 			if (in == 7 && out == 0)
   1213  1.36       tls 				break;
   1214  1.36       tls 			kop[req].crk_status = EINVAL;
   1215  1.36       tls 			continue;
   1216  1.36       tls 		case CRK_DH_COMPUTE_KEY:
   1217  1.36       tls 			if (in == 3 && out == 1)
   1218  1.36       tls 				break;
   1219  1.36       tls 			kop[req].crk_status = EINVAL;
   1220  1.36       tls 			continue;
   1221  1.36       tls 		case CRK_MOD_ADD:
   1222  1.36       tls 			if (in == 3 && out == 1)
   1223  1.36       tls 				break;
   1224  1.36       tls 			kop[req].crk_status = EINVAL;
   1225  1.36       tls 			continue;
   1226  1.36       tls 		case CRK_MOD_ADDINV:
   1227  1.36       tls 			if (in == 2 && out == 1)
   1228  1.36       tls 				break;
   1229  1.36       tls 			kop[req].crk_status = EINVAL;
   1230  1.36       tls 			continue;
   1231  1.36       tls 		case CRK_MOD_SUB:
   1232  1.36       tls 			if (in == 3 && out == 1)
   1233  1.36       tls 				break;
   1234  1.36       tls 			kop[req].crk_status = EINVAL;
   1235  1.36       tls 			continue;
   1236  1.36       tls 		case CRK_MOD_MULT:
   1237  1.36       tls 			if (in == 3 && out == 1)
   1238  1.36       tls 				break;
   1239  1.36       tls 			kop[req].crk_status = EINVAL;
   1240  1.36       tls 			continue;
   1241  1.36       tls 		case CRK_MOD_MULTINV:
   1242  1.36       tls 			if (in == 2 && out == 1)
   1243  1.36       tls 				break;
   1244  1.36       tls 			kop[req].crk_status = EINVAL;
   1245  1.36       tls 			continue;
   1246  1.36       tls 		case CRK_MOD:
   1247  1.36       tls 			if (in == 2 && out == 1)
   1248  1.36       tls 				break;
   1249  1.36       tls 			kop[req].crk_status = EINVAL;
   1250  1.36       tls 			continue;
   1251  1.36       tls 		default:
   1252  1.36       tls 			kop[req].crk_status = EINVAL;
   1253  1.36       tls 			continue;
   1254  1.36       tls 		}
   1255  1.36       tls 
   1256  1.36       tls 		krp = pool_get(&cryptkop_pool, PR_WAITOK);
   1257  1.36       tls 		if (!krp) {
   1258  1.36       tls 			kop[req].crk_status = ENOMEM;
   1259  1.36       tls 			goto fail;
   1260  1.36       tls 		}
   1261  1.36       tls 		bzero(krp, sizeof *krp);
   1262  1.36       tls 		cv_init(&krp->krp_cv, "crykdev");
   1263  1.36       tls 		krp->krp_op = kop[req].crk_op;
   1264  1.36       tls 		krp->krp_status = kop[req].crk_status;
   1265  1.36       tls 		krp->krp_iparams = kop[req].crk_iparams;
   1266  1.36       tls 		krp->krp_oparams = kop[req].crk_oparams;
   1267  1.36       tls 		krp->krp_status = 0;
   1268  1.36       tls 		krp->krp_callback =
   1269  1.36       tls 		    (int (*) (struct cryptkop *)) cryptodevkey_mcb;
   1270  1.36       tls 		bcopy(kop[req].crk_param,
   1271  1.36       tls 		      krp->crk_param,
   1272  1.36       tls 		      sizeof(kop[req].crk_param));
   1273  1.36       tls 
   1274  1.36       tls 		krp->krp_flags = CRYPTO_F_CBIMM;
   1275  1.36       tls 
   1276  1.36       tls 		for (i = 0; i < CRK_MAXPARAM; i++)
   1277  1.36       tls 			krp->krp_param[i].crp_nbits =
   1278  1.36       tls 			    kop[req].crk_param[i].crp_nbits;
   1279  1.36       tls 		for (i = 0; i < krp->krp_iparams + krp->krp_oparams; i++) {
   1280  1.36       tls 			size = (krp->krp_param[i].crp_nbits + 7) / 8;
   1281  1.36       tls 			if (size == 0)
   1282  1.36       tls 				continue;
   1283  1.36       tls 			krp->krp_param[i].crp_p =
   1284  1.36       tls 			    kmem_alloc(size, KM_SLEEP);
   1285  1.36       tls 			if (i >= krp->krp_iparams)
   1286  1.36       tls 				continue;
   1287  1.36       tls 			kop[req].crk_status = copyin(kop[req].crk_param[i].crp_p,
   1288  1.36       tls 						krp->krp_param[i].crp_p, size);
   1289  1.36       tls 			if (kop[req].crk_status)
   1290  1.36       tls 				goto fail;
   1291  1.36       tls 		}
   1292  1.36       tls 		krp->fcrp = fcr;
   1293  1.36       tls 
   1294  1.36       tls 		kop[req].crk_reqid = atomic_inc_32_nv(&(fcr->requestid));
   1295  1.36       tls 		krp->krp_reqid = kop[req].crk_reqid;
   1296  1.36       tls 		krp->krp_usropaque = kop[req].crk_opaque;
   1297  1.36       tls 
   1298  1.36       tls 		kop[req].crk_status = crypto_kdispatch(krp);
   1299  1.36       tls 		if (kop[req].crk_status != 0) {
   1300  1.36       tls 			goto fail;
   1301  1.36       tls 		}
   1302  1.36       tls 
   1303  1.36       tls fail:
   1304  1.36       tls 		if(kop[req].crk_status) {
   1305  1.36       tls 			if (krp) {
   1306  1.36       tls 				kop[req].crk_status = krp->krp_status;
   1307  1.36       tls 				for (i = 0; i < CRK_MAXPARAM; i++) {
   1308  1.36       tls 					struct crparam *kp =
   1309  1.36       tls 						&(krp->krp_param[i]);
   1310  1.36       tls 					if (kp->crp_p) {
   1311  1.36       tls 						size = (kp->crp_nbits + 7) / 8;
   1312  1.36       tls 						KASSERT(size > 0);
   1313  1.36       tls 						memset(kp->crp_p, 0, size);
   1314  1.36       tls 						kmem_free(kp->crp_p, size);
   1315  1.36       tls 					}
   1316  1.36       tls 				}
   1317  1.36       tls 				pool_put(&cryptkop_pool, krp);
   1318  1.36       tls 			}
   1319  1.36       tls 		}
   1320  1.36       tls 		error = 0;
   1321  1.36       tls 	}
   1322  1.36       tls 	DPRINTF(("cryptodev_key: error=0x%08x\n", error));
   1323  1.36       tls 	return (error);
   1324  1.36       tls }
   1325  1.36       tls 
   1326  1.36       tls static int
   1327  1.36       tls cryptodev_session(struct fcrypt *fcr, struct session_op *sop) {
   1328  1.36       tls 	struct cryptoini cria, crie;
   1329  1.36       tls 	struct enc_xform *txform = NULL;
   1330  1.36       tls 	struct auth_hash *thash = NULL;
   1331  1.36       tls 	struct csession *cse;
   1332  1.36       tls 	u_int64_t sid;
   1333  1.36       tls 	int error = 0;
   1334  1.36       tls 
   1335  1.36       tls 	/* XXX there must be a way to not embed the list of xforms here */
   1336  1.36       tls 	switch (sop->cipher) {
   1337  1.36       tls 	case 0:
   1338  1.36       tls 		break;
   1339  1.36       tls 	case CRYPTO_DES_CBC:
   1340  1.36       tls 		txform = &enc_xform_des;
   1341  1.36       tls 		break;
   1342  1.36       tls 	case CRYPTO_3DES_CBC:
   1343  1.36       tls 		txform = &enc_xform_3des;
   1344  1.36       tls 		break;
   1345  1.36       tls 	case CRYPTO_BLF_CBC:
   1346  1.36       tls 		txform = &enc_xform_blf;
   1347  1.36       tls 		break;
   1348  1.36       tls 	case CRYPTO_CAST_CBC:
   1349  1.36       tls 		txform = &enc_xform_cast5;
   1350  1.36       tls 	case CRYPTO_SKIPJACK_CBC:
   1351  1.36       tls 		txform = &enc_xform_skipjack;
   1352  1.36       tls 		break;
   1353  1.36       tls 	case CRYPTO_AES_CBC:
   1354  1.36       tls 		txform = &enc_xform_rijndael128;
   1355  1.36       tls 		break;
   1356  1.36       tls 	case CRYPTO_NULL_CBC:
   1357  1.36       tls 		txform = &enc_xform_null;
   1358  1.36       tls 		break;
   1359  1.36       tls 	case CRYPTO_ARC4:
   1360  1.36       tls 		txform = &enc_xform_arc4;
   1361  1.36       tls 		break;
   1362  1.36       tls 	default:
   1363  1.36       tls 		DPRINTF(("Invalid cipher %d\n", sop->cipher));
   1364  1.36       tls 		return EINVAL;
   1365  1.36       tls 	}
   1366  1.36       tls 
   1367  1.36       tls 	switch (sop->mac) {
   1368  1.36       tls 	case 0:
   1369  1.36       tls 		break;
   1370  1.36       tls 	case CRYPTO_MD5_HMAC:
   1371  1.36       tls 		thash = &auth_hash_hmac_md5;
   1372  1.36       tls 		break;
   1373  1.36       tls 	case CRYPTO_SHA1_HMAC:
   1374  1.36       tls 		thash = &auth_hash_hmac_sha1;
   1375  1.36       tls 		break;
   1376  1.36       tls 	case CRYPTO_MD5_HMAC_96:
   1377  1.36       tls 		thash = &auth_hash_hmac_md5_96;
   1378  1.36       tls 		break;
   1379  1.36       tls 	case CRYPTO_SHA1_HMAC_96:
   1380  1.36       tls 		thash = &auth_hash_hmac_sha1_96;
   1381  1.36       tls 		break;
   1382  1.36       tls 	case CRYPTO_SHA2_HMAC:
   1383  1.36       tls 		/* XXX switching on key length seems questionable */
   1384  1.36       tls 		if (sop->mackeylen == auth_hash_hmac_sha2_256.keysize) {
   1385  1.36       tls 			thash = &auth_hash_hmac_sha2_256;
   1386  1.36       tls 		} else if (sop->mackeylen == auth_hash_hmac_sha2_384.keysize) {
   1387  1.36       tls 			thash = &auth_hash_hmac_sha2_384;
   1388  1.36       tls 		} else if (sop->mackeylen == auth_hash_hmac_sha2_512.keysize) {
   1389  1.36       tls 			thash = &auth_hash_hmac_sha2_512;
   1390  1.36       tls 		} else {
   1391  1.36       tls 			DPRINTF(("Invalid mackeylen %d\n", sop->mackeylen));
   1392  1.36       tls 			return EINVAL;
   1393  1.36       tls 		}
   1394  1.36       tls 		break;
   1395  1.36       tls 	case CRYPTO_RIPEMD160_HMAC:
   1396  1.36       tls 		thash = &auth_hash_hmac_ripemd_160;
   1397  1.36       tls 		break;
   1398  1.36       tls 	case CRYPTO_RIPEMD160_HMAC_96:
   1399  1.36       tls 		thash = &auth_hash_hmac_ripemd_160_96;
   1400  1.36       tls 		break;
   1401  1.36       tls 	case CRYPTO_MD5:
   1402  1.36       tls 		thash = &auth_hash_md5;
   1403  1.36       tls 		break;
   1404  1.36       tls 	case CRYPTO_SHA1:
   1405  1.36       tls 		thash = &auth_hash_sha1;
   1406  1.36       tls 		break;
   1407  1.36       tls 	case CRYPTO_NULL_HMAC:
   1408  1.36       tls 		thash = &auth_hash_null;
   1409  1.36       tls 		break;
   1410  1.36       tls 	default:
   1411  1.36       tls 		DPRINTF(("Invalid mac %d\n", sop->mac));
   1412  1.36       tls 		return (EINVAL);
   1413  1.36       tls 	}
   1414  1.36       tls 
   1415  1.36       tls 	memset(&crie, 0, sizeof(crie));
   1416  1.36       tls 	memset(&cria, 0, sizeof(cria));
   1417  1.36       tls 
   1418  1.36       tls 	if (txform) {
   1419  1.36       tls 		crie.cri_alg = txform->type;
   1420  1.36       tls 		crie.cri_klen = sop->keylen * 8;
   1421  1.36       tls 		if (sop->keylen > txform->maxkey ||
   1422  1.36       tls 		    sop->keylen < txform->minkey) {
   1423  1.36       tls 			DPRINTF(("keylen %d not in [%d,%d]\n",
   1424  1.36       tls 				 sop->keylen, txform->minkey,
   1425  1.36       tls 				 txform->maxkey));
   1426  1.36       tls 			error = EINVAL ;
   1427  1.36       tls 			goto bail;
   1428  1.36       tls 		}
   1429  1.36       tls 
   1430  1.36       tls 		crie.cri_key = malloc(crie.cri_klen / 8, M_XDATA, M_WAITOK);
   1431  1.36       tls 		if ((error = copyin(sop->key, crie.cri_key,
   1432  1.36       tls 				    crie.cri_klen / 8))) {
   1433  1.36       tls 			goto bail;
   1434  1.36       tls 		}
   1435  1.36       tls 		if (thash) {
   1436  1.36       tls 			crie.cri_next = &cria;	/* XXX forces enc then hash? */
   1437  1.36       tls 		}
   1438  1.36       tls 	}
   1439  1.36       tls 
   1440  1.36       tls 	if (thash) {
   1441  1.36       tls 		cria.cri_alg = thash->type;
   1442  1.36       tls 		cria.cri_klen = sop->mackeylen * 8;
   1443  1.36       tls 		if (sop->mackeylen != thash->keysize) {
   1444  1.36       tls 			DPRINTF(("mackeylen %d != keysize %d\n",
   1445  1.36       tls 				 sop->mackeylen, thash->keysize));
   1446  1.36       tls 			error = EINVAL;
   1447  1.36       tls 			goto bail;
   1448  1.36       tls 		}
   1449  1.36       tls 		if (cria.cri_klen) {
   1450  1.36       tls 			cria.cri_key = malloc(cria.cri_klen / 8, M_XDATA,
   1451  1.36       tls 					      M_WAITOK);
   1452  1.36       tls 			if ((error = copyin(sop->mackey, cria.cri_key,
   1453  1.36       tls 					    cria.cri_klen / 8))) {
   1454  1.36       tls 				goto bail;
   1455  1.36       tls 			}
   1456  1.36       tls 		}
   1457  1.36       tls 	}
   1458  1.36       tls 	/* crypto_newsession requires that we hold the mutex. */
   1459  1.36       tls 	mutex_spin_enter(&crypto_mtx);
   1460  1.36       tls 	error = crypto_newsession(&sid, (txform ? &crie : &cria),
   1461  1.36       tls 				  crypto_devallowsoft);
   1462  1.36       tls 	if (!error) {
   1463  1.36       tls 		cse = csecreate(fcr, sid, crie.cri_key, crie.cri_klen,
   1464  1.36       tls 				cria.cri_key, cria.cri_klen, sop->cipher,
   1465  1.36       tls 				sop->mac, txform, thash);
   1466  1.36       tls 		if (cse != NULL) {
   1467  1.36       tls 			sop->ses = cse->ses;
   1468  1.36       tls 		} else {
   1469  1.36       tls 			DPRINTF(("csecreate failed\n"));
   1470  1.36       tls 			crypto_freesession(sid);
   1471  1.36       tls 			error = EINVAL;
   1472  1.36       tls 		}
   1473  1.36       tls 	} else {
   1474  1.36       tls 		DPRINTF(("SIOCSESSION violates kernel parameters %d\n",
   1475  1.36       tls 			 error));
   1476  1.36       tls 	}
   1477  1.36       tls 	mutex_spin_exit(&crypto_mtx);
   1478  1.36       tls bail:
   1479  1.36       tls 	if (error) {
   1480  1.36       tls 		if (crie.cri_key) {
   1481  1.36       tls 			memset(crie.cri_key, 0, crie.cri_klen / 8);
   1482  1.36       tls 			free(crie.cri_key, M_XDATA);
   1483  1.36       tls 		}
   1484  1.36       tls 		if (cria.cri_key) {
   1485  1.36       tls 			memset(cria.cri_key, 0, cria.cri_klen / 8);
   1486  1.36       tls 			free(cria.cri_key, M_XDATA);
   1487  1.36       tls 		}
   1488  1.36       tls 	}
   1489  1.36       tls 	return error;
   1490  1.36       tls }
   1491  1.36       tls 
   1492  1.36       tls static int
   1493  1.36       tls cryptodev_msession(struct fcrypt *fcr, struct session_n_op *sn_ops,
   1494  1.36       tls 		   int count)
   1495  1.36       tls {
   1496  1.36       tls 	int i;
   1497  1.36       tls 
   1498  1.36       tls 	for (i = 0; i < count; i++, sn_ops++) {
   1499  1.36       tls 		struct session_op s_op;
   1500  1.36       tls 		s_op.cipher =		sn_ops->cipher;
   1501  1.36       tls 		s_op.mac =		sn_ops->mac;
   1502  1.36       tls 		s_op.keylen =		sn_ops->keylen;
   1503  1.36       tls 		s_op.key =		sn_ops->key;
   1504  1.36       tls 		s_op.mackeylen =	sn_ops->mackeylen;
   1505  1.36       tls 		s_op.mackey =		sn_ops->mackey;
   1506  1.36       tls 
   1507  1.36       tls 		sn_ops->status = cryptodev_session(fcr, &s_op);
   1508  1.36       tls 		sn_ops->ses =		s_op.ses;
   1509  1.36       tls 	}
   1510  1.36       tls 
   1511  1.36       tls 	return 0;
   1512  1.36       tls }
   1513  1.36       tls 
   1514  1.36       tls static int
   1515  1.36       tls cryptodev_msessionfin(struct fcrypt *fcr, int count, u_int32_t *sesid)
   1516  1.36       tls {
   1517  1.36       tls 	struct csession *cse;
   1518  1.36       tls 	int req, error = 0;
   1519  1.36       tls 
   1520  1.36       tls 	mutex_spin_enter(&crypto_mtx);
   1521  1.36       tls 	for(req = 0; req < count; req++) {
   1522  1.36       tls 		cse = csefind(fcr, sesid[req]);
   1523  1.36       tls 		if (cse == NULL)
   1524  1.36       tls 			continue;
   1525  1.36       tls 		csedelete(fcr, cse);
   1526  1.36       tls 		error = csefree(cse);
   1527  1.36       tls 	}
   1528  1.36       tls 	mutex_spin_exit(&crypto_mtx);
   1529  1.36       tls 	return 0;
   1530  1.36       tls }
   1531  1.36       tls 
   1532  1.36       tls /*
   1533  1.36       tls  * collect as many completed requests as are availble, or count completed requests
   1534  1.36       tls  * whichever is less.
   1535  1.36       tls  * return the number of requests.
   1536  1.36       tls  */
   1537  1.36       tls static int
   1538  1.36       tls cryptodev_getmstatus(struct fcrypt *fcr, struct crypt_result *crypt_res,
   1539  1.36       tls 		  int count)
   1540  1.36       tls {
   1541  1.36       tls 	struct cryptop *crp = NULL;
   1542  1.36       tls 	struct cryptkop *krp = NULL;
   1543  1.36       tls 	struct csession *cse;
   1544  1.36       tls 	int i, size, req = 0;
   1545  1.36       tls 	int completed=0;
   1546  1.36       tls 
   1547  1.36       tls 	/* On stack so nobody else can grab them -- no locking */
   1548  1.36       tls 	SLIST_HEAD(, cryptop) crp_delfree_l =
   1549  1.36       tls 	    SLIST_HEAD_INITIALIZER(crp_delfree_l);
   1550  1.36       tls 	SLIST_HEAD(, cryptkop) krp_delfree_l =
   1551  1.36       tls 	    SLIST_HEAD_INITIALIZER(krp_delfree_l);
   1552  1.36       tls 
   1553  1.36       tls 	mutex_spin_enter(&crypto_mtx);
   1554  1.36       tls 
   1555  1.36       tls 	/* at this point we do not know which response user is requesting for
   1556  1.36       tls 	 * (symmetric or asymmetric) so we copyout one from each i.e if the
   1557  1.36       tls 	 * count is 2 then 1 from symmetric and 1 from asymmetric queue and
   1558  1.36       tls 	 * if 3 then 2 symmetric and 1 asymmetric and so on */
   1559  1.36       tls 	for(; req < count ;) {
   1560  1.36       tls 		crp = TAILQ_FIRST(&fcr->crp_ret_mq);
   1561  1.36       tls 		if(crp) {
   1562  1.36       tls 			cse = (struct csession *)crp->crp_opaque;
   1563  1.36       tls 			crypt_res[req].reqid = crp->crp_reqid;
   1564  1.36       tls 			crypt_res[req].opaque = crp->crp_usropaque;
   1565  1.36       tls 			completed++;
   1566  1.36       tls 			cse = csefind(fcr, cse->ses);
   1567  1.36       tls 			if (cse == NULL) {
   1568  1.36       tls 				DPRINTF(("csefind failed\n"));
   1569  1.36       tls 				crypt_res[req].status = EINVAL;
   1570  1.36       tls 				goto bail;
   1571  1.36       tls 			}
   1572  1.36       tls 
   1573  1.36       tls 			if (crp->crp_etype != 0) {
   1574  1.36       tls 				crypt_res[req].status = crp->crp_etype;
   1575  1.36       tls 				goto bail;
   1576  1.36       tls 			}
   1577  1.36       tls 
   1578  1.36       tls 			if (cse->error) {
   1579  1.36       tls 				crypt_res[req].status = cse->error;
   1580  1.36       tls 				goto bail;
   1581  1.36       tls 			}
   1582  1.36       tls 
   1583  1.36       tls 			if (crp->dst &&
   1584  1.36       tls 			    (crypt_res[req].status = copyout
   1585  1.36       tls 						(crp->uio.uio_iov[0].iov_base,
   1586  1.36       tls 			    			crp->dst, crp->len)))
   1587  1.36       tls 				goto bail;
   1588  1.36       tls 
   1589  1.36       tls 			if (crp->mac &&
   1590  1.36       tls 			    (crypt_res[req].status = copyout
   1591  1.36       tls 						(crp->crp_mac, crp->mac,
   1592  1.36       tls 			    			cse->thash->authsize)))
   1593  1.36       tls 				goto bail;
   1594  1.36       tls bail:
   1595  1.36       tls 			TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
   1596  1.36       tls 			SLIST_INSERT_HEAD(&crp_delfree_l, crp,
   1597  1.36       tls 					  crp_qun.crp_lnext);
   1598  1.36       tls 			req++;
   1599  1.36       tls 		}
   1600  1.36       tls 
   1601  1.36       tls 		if(req < count) {
   1602  1.36       tls 			krp = TAILQ_FIRST(&fcr->crp_ret_mkq);
   1603  1.36       tls 			if (krp) {
   1604  1.36       tls 				crypt_res[req].reqid = krp->krp_reqid;
   1605  1.36       tls 				crypt_res[req].opaque = krp->krp_usropaque;
   1606  1.36       tls 				completed++;
   1607  1.36       tls 				if (krp->krp_status != 0) {
   1608  1.36       tls 					DPRINTF(("cryptodev_key: "
   1609  1.36       tls 						 "krp->krp_status"
   1610  1.36       tls 						"0x%08x\n", krp->krp_status));
   1611  1.36       tls 					crypt_res[req].status =
   1612  1.36       tls 					    krp->krp_status;
   1613  1.36       tls 					goto fail;
   1614  1.36       tls 				}
   1615  1.36       tls 
   1616  1.36       tls 				for (i = krp->krp_iparams; i < krp->krp_iparams
   1617  1.36       tls 						 + krp->krp_oparams; i++) {
   1618  1.36       tls 					size = (krp->krp_param[i].crp_nbits
   1619  1.36       tls 						+ 7) / 8;
   1620  1.36       tls 					if (size == 0)
   1621  1.36       tls 						continue;
   1622  1.36       tls 					crypt_res[req].status = copyout
   1623  1.36       tls 					    (krp->krp_param[i].crp_p,
   1624  1.36       tls 					    krp->crk_param[i].crp_p, size);
   1625  1.36       tls 					if (crypt_res[req].status) {
   1626  1.36       tls 						DPRINTF(("cryptodev_key: "
   1627  1.36       tls 							 "copyout oparam "
   1628  1.36       tls 						  	 "%d failed, "
   1629  1.36       tls 							 "error=%d\n",
   1630  1.36       tls 							 i-krp->krp_iparams,
   1631  1.36       tls 						  crypt_res[req].status));
   1632  1.36       tls 						goto fail;
   1633  1.36       tls 					}
   1634  1.36       tls 				}
   1635  1.36       tls fail:
   1636  1.36       tls 				TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
   1637  1.36       tls 				/* not sure what to do for this */
   1638  1.36       tls 				/* kop[req].crk_status = krp->krp_status; */
   1639  1.36       tls 				SLIST_INSERT_HEAD(&krp_delfree_l, krp,
   1640  1.36       tls 						  krp_qun.krp_lnext);
   1641  1.36       tls 			}
   1642  1.36       tls 			req++;
   1643  1.36       tls 		}
   1644  1.36       tls 	}
   1645  1.36       tls 	mutex_spin_exit(&crypto_mtx);
   1646  1.36       tls 
   1647  1.36       tls 	while(!SLIST_EMPTY(&crp_delfree_l)) {
   1648  1.36       tls 		crp = SLIST_FIRST(&crp_delfree_l);
   1649  1.36       tls 		SLIST_REMOVE_HEAD(&crp_delfree_l, crp_qun.crp_lnext);
   1650  1.36       tls 		kmem_free(crp->uio.uio_iov[0].iov_base,
   1651  1.36       tls 			  crp->uio.uio_iov[0].iov_len);
   1652  1.36       tls 		crypto_freereq(crp);
   1653  1.36       tls 	}
   1654  1.36       tls 
   1655  1.36       tls 	while(!SLIST_EMPTY(&krp_delfree_l)) {
   1656  1.36       tls 		krp = SLIST_FIRST(&krp_delfree_l);
   1657  1.36       tls 		for (i = 0; i < CRK_MAXPARAM; i++) {
   1658  1.36       tls 			struct crparam *kp = &(krp->krp_param[i]);
   1659  1.36       tls 			if (kp->crp_p) {
   1660  1.36       tls 			    size = (kp->crp_nbits + 7) / 8;
   1661  1.36       tls 			    KASSERT(size > 0);
   1662  1.36       tls 			    memset(kp->crp_p, 0, size);
   1663  1.36       tls 			    kmem_free(kp->crp_p, size);
   1664  1.36       tls 			}
   1665  1.36       tls 		}
   1666  1.36       tls 		SLIST_REMOVE_HEAD(&krp_delfree_l, krp_qun.krp_lnext);
   1667  1.36       tls 		pool_put(&cryptkop_pool, krp);
   1668  1.36       tls 	}
   1669  1.36       tls 	return completed;
   1670  1.36       tls }
   1671  1.36       tls 
   1672  1.36       tls static int
   1673  1.36       tls cryptodev_getstatus (struct fcrypt *fcr, struct crypt_result *crypt_res)
   1674  1.36       tls {
   1675  1.36       tls         struct cryptop *crp = NULL;
   1676  1.36       tls         struct cryptkop *krp = NULL;
   1677  1.36       tls         struct csession *cse;
   1678  1.36       tls         int i, size, req = 0;
   1679  1.36       tls 
   1680  1.36       tls 	mutex_spin_enter(&crypto_mtx);
   1681  1.36       tls 	/* Here we dont know for which request the user is requesting the
   1682  1.36       tls 	 * response so checking in both the queues */
   1683  1.36       tls 	TAILQ_FOREACH(crp, &fcr->crp_ret_mq, crp_next) {
   1684  1.36       tls 		if(crp && (crp->crp_reqid == crypt_res->reqid)) {
   1685  1.36       tls 			cse = (struct csession *)crp->crp_opaque;
   1686  1.36       tls 		        crypt_res->opaque = crp->crp_usropaque;
   1687  1.36       tls 			cse = csefind(fcr, cse->ses);
   1688  1.36       tls 			if (cse == NULL) {
   1689  1.36       tls 				DPRINTF(("csefind failed\n"));
   1690  1.36       tls 				crypt_res->status = EINVAL;
   1691  1.36       tls 				goto bail;
   1692  1.36       tls 			}
   1693  1.36       tls 
   1694  1.36       tls 			if (crp->crp_etype != 0) {
   1695  1.36       tls 				crypt_res->status = crp->crp_etype;
   1696  1.36       tls 				goto bail;
   1697  1.36       tls 			}
   1698  1.36       tls 
   1699  1.36       tls 			if (cse->error) {
   1700  1.36       tls 				crypt_res->status = cse->error;
   1701  1.36       tls 				goto bail;
   1702  1.36       tls 			}
   1703  1.36       tls 
   1704  1.36       tls 			if (crp->dst &&
   1705  1.36       tls 			    (crypt_res->status = copyout
   1706  1.36       tls 						(crp->uio.uio_iov[0].iov_base,
   1707  1.36       tls 						crp->dst, crp->len)))
   1708  1.36       tls 				goto bail;
   1709  1.36       tls 
   1710  1.36       tls 			if (crp->mac &&
   1711  1.36       tls 			    (crypt_res->status = copyout(crp->crp_mac,
   1712  1.36       tls 					crp->mac, cse->thash->authsize)))
   1713  1.36       tls 				goto bail;
   1714  1.36       tls bail:
   1715  1.36       tls 			TAILQ_REMOVE(&fcr->crp_ret_mq, crp, crp_next);
   1716  1.36       tls 
   1717  1.36       tls 			mutex_spin_exit(&crypto_mtx);
   1718  1.36       tls 			crypto_freereq(crp);
   1719  1.36       tls 			return 0;
   1720  1.36       tls 		}
   1721  1.36       tls 	}
   1722  1.36       tls 
   1723  1.36       tls 	TAILQ_FOREACH(krp, &fcr->crp_ret_mkq, krp_next) {
   1724  1.36       tls 		if(krp && (krp->krp_reqid == crypt_res->reqid)) {
   1725  1.36       tls 			crypt_res[req].opaque = krp->krp_usropaque;
   1726  1.36       tls 			if (krp->krp_status != 0) {
   1727  1.36       tls 				DPRINTF(("cryptodev_key: "
   1728  1.36       tls 					 "krp->krp_status 0x%08x\n",
   1729  1.36       tls 					 krp->krp_status));
   1730  1.36       tls 				crypt_res[req].status = krp->krp_status;
   1731  1.36       tls 				goto fail;
   1732  1.36       tls 			}
   1733  1.36       tls 
   1734  1.36       tls 			for (i = krp->krp_iparams; i < krp->krp_iparams
   1735  1.36       tls 						+ krp->krp_oparams; i++) {
   1736  1.36       tls 				size = (krp->krp_param[i].crp_nbits + 7) / 8;
   1737  1.36       tls 				if (size == 0)
   1738  1.36       tls 					continue;
   1739  1.36       tls 				crypt_res[req].status = copyout
   1740  1.36       tls 						(krp->krp_param[i].crp_p,
   1741  1.36       tls 						krp->crk_param[i].crp_p, size);
   1742  1.36       tls 				if (crypt_res[req].status) {
   1743  1.36       tls 					DPRINTF(("cryptodev_key: copyout oparam"
   1744  1.36       tls 						"%d failed, error=%d\n",
   1745  1.36       tls 						i-krp->krp_iparams,
   1746  1.36       tls 						crypt_result[req].status));
   1747  1.36       tls 					goto fail;
   1748  1.36       tls 				}
   1749  1.36       tls 			}
   1750  1.36       tls fail:
   1751  1.36       tls 			TAILQ_REMOVE(&fcr->crp_ret_mkq, krp, krp_next);
   1752  1.36       tls 			mutex_spin_exit(&crypto_mtx);
   1753  1.36       tls 			/* not sure what to do for this */
   1754  1.36       tls 			/* kop[req].crk_status = krp->krp_status; */
   1755  1.36       tls 			for (i = 0; i < CRK_MAXPARAM; i++) {
   1756  1.36       tls 				struct crparam *kp = &(krp->krp_param[i]);
   1757  1.36       tls 				if (kp->crp_p) {
   1758  1.36       tls 					size = (kp->crp_nbits + 7) / 8;
   1759  1.36       tls 					KASSERT(size > 0);
   1760  1.36       tls 					memset(kp->crp_p, 0, size);
   1761  1.36       tls 					kmem_free(kp->crp_p, size);
   1762  1.36       tls 				}
   1763  1.36       tls 			}
   1764  1.36       tls 			pool_put(&cryptkop_pool, krp);
   1765  1.36       tls 			return 0;
   1766  1.36       tls 		}
   1767  1.36       tls 	}
   1768  1.36       tls 	mutex_spin_exit(&crypto_mtx);
   1769  1.36       tls 	return EINPROGRESS;
   1770  1.36       tls }
   1771  1.36       tls 
   1772  1.36       tls static int
   1773  1.36       tls cryptof_poll(struct file *fp, int events)
   1774  1.36       tls {
   1775  1.36       tls 	struct fcrypt *fcr = (struct fcrypt *)fp->f_data;
   1776  1.38     rmind 	int revents = 0;
   1777  1.36       tls 
   1778  1.36       tls 	if (!(events & (POLLIN | POLLRDNORM))) {
   1779  1.36       tls 		/* only support read and POLLIN */
   1780  1.36       tls 		return 0;
   1781  1.36       tls 	}
   1782  1.36       tls 
   1783  1.38     rmind 	mutex_spin_enter(&crypto_mtx);
   1784  1.36       tls 	if (TAILQ_EMPTY(&fcr->crp_ret_mq) && TAILQ_EMPTY(&fcr->crp_ret_mkq)) {
   1785  1.38     rmind 		/* no completed requests pending, save the poll for later */
   1786  1.36       tls 		selrecord(curlwp, &fcr->sinfo);
   1787  1.36       tls 	} else {
   1788  1.36       tls 		/* let the app(s) know that there are completed requests */
   1789  1.38     rmind 		revents = events & (POLLIN | POLLRDNORM);
   1790  1.36       tls 	}
   1791  1.38     rmind 	mutex_spin_exit(&crypto_mtx);
   1792  1.38     rmind 
   1793  1.38     rmind 	return revents;
   1794  1.36       tls }
   1795  1.36       tls 
   1796  1.15   thorpej /*
   1797  1.15   thorpej  * Pseudo-device initialization routine for /dev/crypto
   1798  1.15   thorpej  */
   1799  1.15   thorpej void	cryptoattach(int);
   1800  1.15   thorpej 
   1801  1.15   thorpej void
   1802  1.25  christos cryptoattach(int num)
   1803  1.15   thorpej {
   1804  1.29       tls 	pool_init(&fcrpl, sizeof(struct fcrypt), 0, 0, 0, "fcrpl",
   1805  1.29       tls 		  NULL, IPL_NET);	/* XXX IPL_NET ("splcrypto") */
   1806  1.29       tls 	pool_init(&csepl, sizeof(struct csession), 0, 0, 0, "csepl",
   1807  1.29       tls 		  NULL, IPL_NET);	/* XXX IPL_NET ("splcrypto") */
   1808  1.29       tls 
   1809  1.29       tls 	/*
   1810  1.29       tls 	 * Preallocate space for 64 users, with 5 sessions each.
   1811  1.29       tls 	 * (consider that a TLS protocol session requires at least
   1812  1.29       tls 	 * 3DES, MD5, and SHA1 (both hashes are used in the PRF) for
   1813  1.29       tls 	 * the negotiation, plus HMAC_SHA1 for the actual SSL records,
   1814  1.29       tls 	 * consuming one session here for each algorithm.
   1815  1.29       tls 	 */
   1816  1.29       tls 	pool_prime(&fcrpl, 64);
   1817  1.29       tls 	pool_prime(&csepl, 64 * 5);
   1818  1.15   thorpej }
   1819