/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_CRYPTO_OPS_IMPL_H
#define _SYS_CRYPTO_OPS_IMPL_H

/*
 * Scheduler internal structures.
 */

#ifdef __cplusplus
extern "C" {
#endif

#include <sys/types.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/crypto/api.h>
#include <sys/crypto/spi.h>
#include <sys/crypto/impl.h>
#include <sys/crypto/common.h>

/*
 * The parameters needed for each function group are batched
 * in one structure. This is much simpler than having a
 * separate structure for each function.
 *
 * In some cases, a field is generically named to keep the
 * structure small. The comments indicate these cases.
 */
typedef struct kcf_digest_ops_params {
        crypto_session_id_t     do_sid;
        crypto_mech_type_t      do_framework_mechtype;
        crypto_mechanism_t      do_mech;
        crypto_data_t           *do_data;
        crypto_data_t           *do_digest;
        crypto_key_t            *do_digest_key; /* Argument for digest_key() */
} kcf_digest_ops_params_t;

typedef struct kcf_mac_ops_params {
        crypto_session_id_t             mo_sid;
        crypto_mech_type_t              mo_framework_mechtype;
        crypto_mechanism_t              mo_mech;
        crypto_key_t                    *mo_key;
        crypto_data_t                   *mo_data;
        crypto_data_t                   *mo_mac;
        crypto_spi_ctx_template_t       mo_templ;
} kcf_mac_ops_params_t;

typedef struct kcf_encrypt_ops_params {
        crypto_session_id_t             eo_sid;
        crypto_mech_type_t              eo_framework_mechtype;
        crypto_mechanism_t              eo_mech;
        crypto_key_t                    *eo_key;
        crypto_data_t                   *eo_plaintext;
        crypto_data_t                   *eo_ciphertext;
        crypto_spi_ctx_template_t       eo_templ;
} kcf_encrypt_ops_params_t;

typedef struct kcf_decrypt_ops_params {
        crypto_session_id_t             dop_sid;
        crypto_mech_type_t              dop_framework_mechtype;
        crypto_mechanism_t              dop_mech;
        crypto_key_t                    *dop_key;
        crypto_data_t                   *dop_ciphertext;
        crypto_data_t                   *dop_plaintext;
        crypto_spi_ctx_template_t       dop_templ;
} kcf_decrypt_ops_params_t;

typedef struct kcf_sign_ops_params {
        crypto_session_id_t             so_sid;
        crypto_mech_type_t              so_framework_mechtype;
        crypto_mechanism_t              so_mech;
        crypto_key_t                    *so_key;
        crypto_data_t                   *so_data;
        crypto_data_t                   *so_signature;
        crypto_spi_ctx_template_t       so_templ;
} kcf_sign_ops_params_t;

typedef struct kcf_verify_ops_params {
        crypto_session_id_t             vo_sid;
        crypto_mech_type_t              vo_framework_mechtype;
        crypto_mechanism_t              vo_mech;
        crypto_key_t                    *vo_key;
        crypto_data_t                   *vo_data;
        crypto_data_t                   *vo_signature;
        crypto_spi_ctx_template_t       vo_templ;
} kcf_verify_ops_params_t;

typedef struct kcf_encrypt_mac_ops_params {
        crypto_session_id_t             em_sid;
        crypto_mech_type_t              em_framework_encr_mechtype;
        crypto_mechanism_t              em_encr_mech;
        crypto_key_t                    *em_encr_key;
        crypto_mech_type_t              em_framework_mac_mechtype;
        crypto_mechanism_t              em_mac_mech;
        crypto_key_t                    *em_mac_key;
        crypto_data_t                   *em_plaintext;
        crypto_dual_data_t              *em_ciphertext;
        crypto_data_t                   *em_mac;
        crypto_spi_ctx_template_t       em_encr_templ;
        crypto_spi_ctx_template_t       em_mac_templ;
} kcf_encrypt_mac_ops_params_t;

typedef struct kcf_mac_decrypt_ops_params {
        crypto_session_id_t             md_sid;
        crypto_mech_type_t              md_framework_mac_mechtype;
        crypto_mechanism_t              md_mac_mech;
        crypto_key_t                    *md_mac_key;
        crypto_mech_type_t              md_framework_decr_mechtype;
        crypto_mechanism_t              md_decr_mech;
        crypto_key_t                    *md_decr_key;
        crypto_dual_data_t              *md_ciphertext;
        crypto_data_t                   *md_mac;
        crypto_data_t                   *md_plaintext;
        crypto_spi_ctx_template_t       md_mac_templ;
        crypto_spi_ctx_template_t       md_decr_templ;
} kcf_mac_decrypt_ops_params_t;

typedef struct kcf_random_number_ops_params {
        crypto_session_id_t     rn_sid;
        uchar_t                 *rn_buf;
        size_t                  rn_buflen;
        uint_t                  rn_entropy_est;
        uint32_t                rn_flags;
} kcf_random_number_ops_params_t;

/*
 * so_pd is useful when the provider descriptor (pd) supplying the
 * provider handle is different from the pd supplying the ops vector.
 * This is the case for session open/close where so_pd can be the pd
 * of a logical provider. The pd supplying the ops vector is passed
 * as an argument to kcf_submit_request().
 */
typedef struct kcf_session_ops_params {
        crypto_session_id_t     *so_sid_ptr;
        crypto_session_id_t     so_sid;
        crypto_user_type_t      so_user_type;
        char                    *so_pin;
        size_t                  so_pin_len;
        kcf_provider_desc_t     *so_pd;
} kcf_session_ops_params_t;

typedef struct kcf_object_ops_params {
        crypto_session_id_t             oo_sid;
        crypto_object_id_t              oo_object_id;
        crypto_object_attribute_t       *oo_template;
        uint_t                          oo_attribute_count;
        crypto_object_id_t              *oo_object_id_ptr;
        size_t                          *oo_object_size;
        void                            **oo_find_init_pp_ptr;
        void                            *oo_find_pp;
        uint_t                          oo_max_object_count;
        uint_t                          *oo_object_count_ptr;
} kcf_object_ops_params_t;

/*
 * ko_key is used to encode wrapping key in key_wrap() and
 * unwrapping key in key_unwrap(). ko_key_template and
 * ko_key_attribute_count are used to encode public template
 * and public template attr count in key_generate_pair().
 * kops->ko_key_object_id_ptr is used to encode public key
 * in key_generate_pair().
 */
typedef struct kcf_key_ops_params {
        crypto_session_id_t             ko_sid;
        crypto_mech_type_t              ko_framework_mechtype;
        crypto_mechanism_t              ko_mech;
        crypto_object_attribute_t       *ko_key_template;
        uint_t                          ko_key_attribute_count;
        crypto_object_id_t              *ko_key_object_id_ptr;
        crypto_object_attribute_t       *ko_private_key_template;
        uint_t                          ko_private_key_attribute_count;
        crypto_object_id_t              *ko_private_key_object_id_ptr;
        crypto_key_t                    *ko_key;
        uchar_t                         *ko_wrapped_key;
        size_t                          *ko_wrapped_key_len_ptr;
        crypto_object_attribute_t       *ko_out_template1;
        crypto_object_attribute_t       *ko_out_template2;
        uint_t                          ko_out_attribute_count1;
        uint_t                          ko_out_attribute_count2;
} kcf_key_ops_params_t;

/*
 * po_pin and po_pin_len are used to encode new_pin and new_pin_len
 * when wrapping set_pin() function parameters.
 *
 * po_pd is useful when the provider descriptor (pd) supplying the
 * provider handle is different from the pd supplying the ops vector.
 * This is true for the ext_info provider entry point where po_pd
 * can be the pd of a logical provider. The pd supplying the ops vector
 * is passed as an argument to kcf_submit_request().
 */
typedef struct kcf_provmgmt_ops_params {
        crypto_session_id_t             po_sid;
        char                            *po_pin;
        size_t                          po_pin_len;
        char                            *po_old_pin;
        size_t                          po_old_pin_len;
        char                            *po_label;
        crypto_provider_ext_info_t      *po_ext_info;
        kcf_provider_desc_t             *po_pd;
} kcf_provmgmt_ops_params_t;

/*
 * The operation type within a function group.
 */
typedef enum kcf_op_type {
        /* common ops for all mechanisms */
        KCF_OP_INIT = 1,
        KCF_OP_SINGLE,  /* pkcs11 sense. So, INIT is already done */
        KCF_OP_UPDATE,
        KCF_OP_FINAL,
        KCF_OP_ATOMIC,

        /* digest_key op */
        KCF_OP_DIGEST_KEY,

        /* mac specific op */
        KCF_OP_MAC_VERIFY_ATOMIC,

        /* mac/cipher specific op */
        KCF_OP_MAC_VERIFY_DECRYPT_ATOMIC,

        /* sign_recover ops */
        KCF_OP_SIGN_RECOVER_INIT,
        KCF_OP_SIGN_RECOVER,
        KCF_OP_SIGN_RECOVER_ATOMIC,

        /* verify_recover ops */
        KCF_OP_VERIFY_RECOVER_INIT,
        KCF_OP_VERIFY_RECOVER,
        KCF_OP_VERIFY_RECOVER_ATOMIC,

        /* random number ops */
        KCF_OP_RANDOM_SEED,
        KCF_OP_RANDOM_GENERATE,

        /* session management ops */
        KCF_OP_SESSION_OPEN,
        KCF_OP_SESSION_CLOSE,
        KCF_OP_SESSION_LOGIN,
        KCF_OP_SESSION_LOGOUT,

        /* object management ops */
        KCF_OP_OBJECT_CREATE,
        KCF_OP_OBJECT_COPY,
        KCF_OP_OBJECT_DESTROY,
        KCF_OP_OBJECT_GET_SIZE,
        KCF_OP_OBJECT_GET_ATTRIBUTE_VALUE,
        KCF_OP_OBJECT_SET_ATTRIBUTE_VALUE,
        KCF_OP_OBJECT_FIND_INIT,
        KCF_OP_OBJECT_FIND,
        KCF_OP_OBJECT_FIND_FINAL,

        /* key management ops */
        KCF_OP_KEY_GENERATE,
        KCF_OP_KEY_GENERATE_PAIR,
        KCF_OP_KEY_WRAP,
        KCF_OP_KEY_UNWRAP,
        KCF_OP_KEY_DERIVE,
        KCF_OP_KEY_CHECK,

        /* provider management ops */
        KCF_OP_MGMT_EXTINFO,
        KCF_OP_MGMT_INITTOKEN,
        KCF_OP_MGMT_INITPIN,
        KCF_OP_MGMT_SETPIN
} kcf_op_type_t;

/*
 * The operation groups that need wrapping of parameters. This is somewhat
 * similar to the function group type in spi.h except that this also includes
 * all the functions that don't have a mechanism.
 *
 * The wrapper macros should never take these enum values as an argument.
 * Rather, they are assigned in the macro itself since they are known
 * from the macro name.
 */
typedef enum kcf_op_group {
        KCF_OG_DIGEST = 1,
        KCF_OG_MAC,
        KCF_OG_ENCRYPT,
        KCF_OG_DECRYPT,
        KCF_OG_SIGN,
        KCF_OG_VERIFY,
        KCF_OG_ENCRYPT_MAC,
        KCF_OG_MAC_DECRYPT,
        KCF_OG_RANDOM,
        KCF_OG_SESSION,
        KCF_OG_OBJECT,
        KCF_OG_KEY,
        KCF_OG_PROVMGMT,
        KCF_OG_NOSTORE_KEY
} kcf_op_group_t;

/*
 * The kcf_op_type_t enum values used here should be only for those
 * operations for which there is a k-api routine in sys/crypto/api.h.
 */
#define IS_INIT_OP(ftype)       ((ftype) == KCF_OP_INIT)
#define IS_SINGLE_OP(ftype)     ((ftype) == KCF_OP_SINGLE)
#define IS_UPDATE_OP(ftype)     ((ftype) == KCF_OP_UPDATE)
#define IS_FINAL_OP(ftype)      ((ftype) == KCF_OP_FINAL)
#define IS_ATOMIC_OP(ftype)     ( \
        (ftype) == KCF_OP_ATOMIC || (ftype) == KCF_OP_MAC_VERIFY_ATOMIC || \
        (ftype) == KCF_OP_MAC_VERIFY_DECRYPT_ATOMIC || \
        (ftype) == KCF_OP_SIGN_RECOVER_ATOMIC || \
        (ftype) == KCF_OP_VERIFY_RECOVER_ATOMIC)

/*
 * Keep the parameters associated with a request around.
 * We need to pass them to the SPI.
 */
typedef struct kcf_req_params {
        kcf_op_group_t          rp_opgrp;
        kcf_op_type_t           rp_optype;

        union {
                kcf_digest_ops_params_t         digest_params;
                kcf_mac_ops_params_t            mac_params;
                kcf_encrypt_ops_params_t        encrypt_params;
                kcf_decrypt_ops_params_t        decrypt_params;
                kcf_sign_ops_params_t           sign_params;
                kcf_verify_ops_params_t         verify_params;
                kcf_encrypt_mac_ops_params_t    encrypt_mac_params;
                kcf_mac_decrypt_ops_params_t    mac_decrypt_params;
                kcf_random_number_ops_params_t  random_number_params;
                kcf_session_ops_params_t        session_params;
                kcf_object_ops_params_t         object_params;
                kcf_key_ops_params_t            key_params;
                kcf_provmgmt_ops_params_t       provmgmt_params;
        } rp_u;
} kcf_req_params_t;


/*
 * The ioctl/k-api code should bundle the parameters into a kcf_req_params_t
 * structure before calling a scheduler routine. The following macros are
 * available for that purpose.
 *
 * For the most part, the macro arguments closely correspond to the
 * function parameters. In some cases, we use generic names. The comments
 * for the structure should indicate these cases.
 */
#define KCF_WRAP_DIGEST_OPS_PARAMS(req, ftype, _sid, _mech, _key,       \
        _data, _digest) {                                               \
        kcf_digest_ops_params_t *dops = &(req)->rp_u.digest_params;     \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_DIGEST;                                \
        (req)->rp_optype = ftype;                                       \
        dops->do_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                dops->do_mech = *mechp;                                 \
                dops->do_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        dops->do_digest_key = _key;                                     \
        dops->do_data = _data;                                          \
        dops->do_digest = _digest;                                      \
}

#define KCF_WRAP_MAC_OPS_PARAMS(req, ftype, _sid, _mech, _key,          \
        _data, _mac, _templ) {                                          \
        kcf_mac_ops_params_t *mops = &(req)->rp_u.mac_params;           \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_MAC;                                   \
        (req)->rp_optype = ftype;                                       \
        mops->mo_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                mops->mo_mech = *mechp;                                 \
                mops->mo_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        mops->mo_key = _key;                                            \
        mops->mo_data = _data;                                          \
        mops->mo_mac = _mac;                                            \
        mops->mo_templ = _templ;                                        \
}

#define KCF_WRAP_ENCRYPT_OPS_PARAMS(req, ftype, _sid, _mech, _key,      \
        _plaintext, _ciphertext, _templ) {                              \
        kcf_encrypt_ops_params_t *cops = &(req)->rp_u.encrypt_params;   \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_ENCRYPT;                               \
        (req)->rp_optype = ftype;                                       \
        cops->eo_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                cops->eo_mech = *mechp;                                 \
                cops->eo_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        cops->eo_key = _key;                                            \
        cops->eo_plaintext = _plaintext;                                \
        cops->eo_ciphertext = _ciphertext;                              \
        cops->eo_templ = _templ;                                        \
}

#define KCF_WRAP_DECRYPT_OPS_PARAMS(req, ftype, _sid, _mech, _key,      \
        _ciphertext, _plaintext, _templ) {                              \
        kcf_decrypt_ops_params_t *cops = &(req)->rp_u.decrypt_params;   \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_DECRYPT;                               \
        (req)->rp_optype = ftype;                                       \
        cops->dop_sid = _sid;                                           \
        if (mechp != NULL) {                                            \
                cops->dop_mech = *mechp;                                \
                cops->dop_framework_mechtype = mechp->cm_type;          \
        }                                                               \
        cops->dop_key = _key;                                           \
        cops->dop_ciphertext = _ciphertext;                             \
        cops->dop_plaintext = _plaintext;                               \
        cops->dop_templ = _templ;                                       \
}

#define KCF_WRAP_SIGN_OPS_PARAMS(req, ftype, _sid, _mech, _key,         \
        _data, _signature, _templ) {                                    \
        kcf_sign_ops_params_t *sops = &(req)->rp_u.sign_params;         \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_SIGN;                                  \
        (req)->rp_optype = ftype;                                       \
        sops->so_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                sops->so_mech = *mechp;                                 \
                sops->so_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        sops->so_key = _key;                                            \
        sops->so_data = _data;                                          \
        sops->so_signature = _signature;                                \
        sops->so_templ = _templ;                                        \
}

#define KCF_WRAP_VERIFY_OPS_PARAMS(req, ftype, _sid, _mech, _key,       \
        _data, _signature, _templ) {                                    \
        kcf_verify_ops_params_t *vops = &(req)->rp_u.verify_params;     \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_VERIFY;                                \
        (req)->rp_optype = ftype;                                       \
        vops->vo_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                vops->vo_mech = *mechp;                                 \
                vops->vo_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        vops->vo_key = _key;                                            \
        vops->vo_data = _data;                                          \
        vops->vo_signature = _signature;                                \
        vops->vo_templ = _templ;                                        \
}

#define KCF_WRAP_ENCRYPT_MAC_OPS_PARAMS(req, ftype, _sid, _encr_key,    \
        _mac_key, _plaintext, _ciphertext, _mac, _encr_templ, _mac_templ) { \
        kcf_encrypt_mac_ops_params_t *cmops = &(req)->rp_u.encrypt_mac_params; \
                                                                        \
        (req)->rp_opgrp = KCF_OG_ENCRYPT_MAC;                           \
        (req)->rp_optype = ftype;                                       \
        cmops->em_sid = _sid;                                           \
        cmops->em_encr_key = _encr_key;                                 \
        cmops->em_mac_key = _mac_key;                                   \
        cmops->em_plaintext = _plaintext;                               \
        cmops->em_ciphertext = _ciphertext;                             \
        cmops->em_mac = _mac;                                           \
        cmops->em_encr_templ = _encr_templ;                             \
        cmops->em_mac_templ = _mac_templ;                               \
}

#define KCF_WRAP_MAC_DECRYPT_OPS_PARAMS(req, ftype, _sid, _mac_key,     \
        _decr_key, _ciphertext, _mac, _plaintext, _mac_templ, _decr_templ) { \
        kcf_mac_decrypt_ops_params_t *cmops = &(req)->rp_u.mac_decrypt_params; \
                                                                        \
        (req)->rp_opgrp = KCF_OG_MAC_DECRYPT;                           \
        (req)->rp_optype = ftype;                                       \
        cmops->md_sid = _sid;                                           \
        cmops->md_mac_key = _mac_key;                                   \
        cmops->md_decr_key = _decr_key;                                 \
        cmops->md_ciphertext = _ciphertext;                             \
        cmops->md_mac = _mac;                                           \
        cmops->md_plaintext = _plaintext;                               \
        cmops->md_mac_templ = _mac_templ;                               \
        cmops->md_decr_templ = _decr_templ;                             \
}

#define KCF_WRAP_RANDOM_OPS_PARAMS(req, ftype, _sid, _buf, _buflen,     \
        _est, _flags) {                                                 \
        kcf_random_number_ops_params_t *rops =                          \
                &(req)->rp_u.random_number_params;                      \
                                                                        \
        (req)->rp_opgrp = KCF_OG_RANDOM;                                \
        (req)->rp_optype = ftype;                                       \
        rops->rn_sid = _sid;                                            \
        rops->rn_buf = _buf;                                            \
        rops->rn_buflen = _buflen;                                      \
        rops->rn_entropy_est = _est;                                    \
        rops->rn_flags = _flags;                                        \
}

#define KCF_WRAP_SESSION_OPS_PARAMS(req, ftype, _sid_ptr, _sid,         \
        _user_type, _pin, _pin_len, _pd) {                              \
        kcf_session_ops_params_t *sops = &(req)->rp_u.session_params;   \
                                                                        \
        (req)->rp_opgrp = KCF_OG_SESSION;                               \
        (req)->rp_optype = ftype;                                       \
        sops->so_sid_ptr = _sid_ptr;                                    \
        sops->so_sid = _sid;                                            \
        sops->so_user_type = _user_type;                                \
        sops->so_pin = _pin;                                            \
        sops->so_pin_len = _pin_len;                                    \
        sops->so_pd = _pd;                                              \
}

#define KCF_WRAP_OBJECT_OPS_PARAMS(req, ftype, _sid, _object_id,        \
        _template, _attribute_count, _object_id_ptr, _object_size,      \
        _find_init_pp_ptr, _find_pp, _max_object_count, _object_count_ptr) { \
        kcf_object_ops_params_t *jops = &(req)->rp_u.object_params;     \
                                                                        \
        (req)->rp_opgrp = KCF_OG_OBJECT;                                \
        (req)->rp_optype = ftype;                                       \
        jops->oo_sid = _sid;                                            \
        jops->oo_object_id = _object_id;                                \
        jops->oo_template = _template;                                  \
        jops->oo_attribute_count = _attribute_count;                    \
        jops->oo_object_id_ptr = _object_id_ptr;                        \
        jops->oo_object_size = _object_size;                            \
        jops->oo_find_init_pp_ptr = _find_init_pp_ptr;                  \
        jops->oo_find_pp = _find_pp;                                    \
        jops->oo_max_object_count = _max_object_count;                  \
        jops->oo_object_count_ptr = _object_count_ptr;                  \
}

#define KCF_WRAP_KEY_OPS_PARAMS(req, ftype, _sid, _mech, _key_template, \
        _key_attribute_count, _key_object_id_ptr, _private_key_template, \
        _private_key_attribute_count, _private_key_object_id_ptr,       \
        _key, _wrapped_key, _wrapped_key_len_ptr) {                     \
        kcf_key_ops_params_t *kops = &(req)->rp_u.key_params;           \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_KEY;                                   \
        (req)->rp_optype = ftype;                                       \
        kops->ko_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                kops->ko_mech = *mechp;                                 \
                kops->ko_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        kops->ko_key_template = _key_template;                          \
        kops->ko_key_attribute_count = _key_attribute_count;            \
        kops->ko_key_object_id_ptr = _key_object_id_ptr;                \
        kops->ko_private_key_template = _private_key_template;          \
        kops->ko_private_key_attribute_count = _private_key_attribute_count; \
        kops->ko_private_key_object_id_ptr = _private_key_object_id_ptr; \
        kops->ko_key = _key;                                            \
        kops->ko_wrapped_key = _wrapped_key;                            \
        kops->ko_wrapped_key_len_ptr = _wrapped_key_len_ptr;            \
}

#define KCF_WRAP_PROVMGMT_OPS_PARAMS(req, ftype, _sid, _old_pin,        \
        _old_pin_len, _pin, _pin_len, _label, _ext_info, _pd) {         \
        kcf_provmgmt_ops_params_t *pops = &(req)->rp_u.provmgmt_params; \
                                                                        \
        (req)->rp_opgrp = KCF_OG_PROVMGMT;                              \
        (req)->rp_optype = ftype;                                       \
        pops->po_sid = _sid;                                            \
        pops->po_pin = _pin;                                            \
        pops->po_pin_len = _pin_len;                                    \
        pops->po_old_pin = _old_pin;                                    \
        pops->po_old_pin_len = _old_pin_len;                            \
        pops->po_label = _label;                                        \
        pops->po_ext_info = _ext_info;                                  \
        pops->po_pd = _pd;                                              \
}

#define KCF_WRAP_NOSTORE_KEY_OPS_PARAMS(req, ftype, _sid, _mech,        \
        _key_template, _key_attribute_count, _private_key_template,     \
        _private_key_attribute_count, _key, _out_template1,             \
        _out_attribute_count1, _out_template2, _out_attribute_count2) { \
        kcf_key_ops_params_t *kops = &(req)->rp_u.key_params;           \
        crypto_mechanism_t *mechp = _mech;                              \
                                                                        \
        (req)->rp_opgrp = KCF_OG_NOSTORE_KEY;                           \
        (req)->rp_optype = ftype;                                       \
        kops->ko_sid = _sid;                                            \
        if (mechp != NULL) {                                            \
                kops->ko_mech = *mechp;                                 \
                kops->ko_framework_mechtype = mechp->cm_type;           \
        }                                                               \
        kops->ko_key_template = _key_template;                          \
        kops->ko_key_attribute_count = _key_attribute_count;            \
        kops->ko_key_object_id_ptr = NULL;                              \
        kops->ko_private_key_template = _private_key_template;          \
        kops->ko_private_key_attribute_count = _private_key_attribute_count; \
        kops->ko_private_key_object_id_ptr = NULL;                      \
        kops->ko_key = _key;                                            \
        kops->ko_wrapped_key = NULL;                                    \
        kops->ko_wrapped_key_len_ptr = 0;                               \
        kops->ko_out_template1 = _out_template1;                        \
        kops->ko_out_template2 = _out_template2;                        \
        kops->ko_out_attribute_count1 = _out_attribute_count1;          \
        kops->ko_out_attribute_count2 = _out_attribute_count2;          \
}

#define KCF_SET_PROVIDER_MECHNUM(fmtype, pd, mechp)                     \
        (mechp)->cm_type =                                              \
            KCF_TO_PROV_MECHNUM(pd, fmtype);

#ifdef __cplusplus
}
#endif

#endif /* _SYS_CRYPTO_OPS_IMPL_H */