Lines Matching defs:rv
851 int rv;
865 rv = crypto_get_provider_list(cm, NULL, NULL, DONT_RETURN_LIST);
866 if (rv != CRYPTO_SUCCESS) {
876 rv = CRYPTO_ARGUMENTS_BAD;
902 rv = CRYPTO_SUCCESS;
907 get_function_list.fl_return_value = rv;
928 int rv;
937 rv = CRYPTO_ARGUMENTS_BAD;
955 rv = CRYPTO_ARGUMENTS_BAD;
962 rv = CRYPTO_SUCCESS;
964 STRUCT_FSET(get_number, pn_return_value, rv);
1094 int rv;
1109 rv = CRYPTO_ARGUMENTS_BAD;
1113 rv = crypto_get_all_mech_info(mech_type, &mech_infos, &num_mech_infos,
1115 if (rv != CRYPTO_SUCCESS) {
1118 /* rv is CRYPTO_SUCCESS at this point */
1127 rv = CRYPTO_BUFFER_TOO_SMALL;
1131 STRUCT_FSET(get_all_mech, mi_return_value, rv);
1141 * or rv is not CRYPTO_SUCCESS due to buffer too small or some other
1144 if (req_count == 0 || num_mech_infos == 0 || rv != CRYPTO_SUCCESS ||
1236 int rv;
1250 rv = crypto_get_provider_list(cm, &count, &entries, RETURN_LIST);
1251 if (rv != CRYPTO_SUCCESS) {
1253 STRUCT_FSET(get_list, pl_return_value, rv);
1419 int rv;
1435 if ((rv = crypto_buffer_check(need)) != CRYPTO_SUCCESS) {
1442 rv = crypto_get_provider_list(cm, NULL, NULL, DONT_RETURN_LIST);
1443 if (rv != CRYPTO_SUCCESS) {
1455 rv = CRYPTO_ARGUMENTS_BAD;
1473 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms,
1475 ASSERT(rv != CRYPTO_NOT_SUPPORTED);
1480 rv = CRYPTO_SUCCESS;
1484 if (rv == CRYPTO_SUCCESS) {
1499 STRUCT_FSET(get_info, gi_return_value, rv);
1619 int rv = CRYPTO_SUCCESS;
1635 rv = crypto_get_provider_list(cm, NULL, NULL, DONT_RETURN_LIST);
1636 if (rv != CRYPTO_SUCCESS) {
1648 rv = CRYPTO_ARGUMENTS_BAD;
1665 rv = CRYPTO_ARGUMENTS_BAD;
1671 rv = CRYPTO_MECHANISM_INVALID;
1682 mechanism_info.mi_return_value = rv;
1705 int rv;
1740 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms,
1742 if (rv != CRYPTO_SUCCESS) {
1745 return (rv);
1843 int rv;
1858 if ((rv = crypto_buffer_check(new_allocation - current_allocation)) !=
1860 return (rv);
1896 int rv;
1907 rv = crypto_get_provider_list(cm, NULL, NULL, DONT_RETURN_LIST);
1908 if (rv != 0) {
1910 return (rv);
1923 rv = crypto_get_provider_session(cm, provider_id, &ps);
1924 if (rv != CRYPTO_SUCCESS) {
1927 return (rv);
1942 if ((rv = grow_session_table(cm)) != CRYPTO_SUCCESS) {
1946 return (rv);
1968 if ((rv = crypto_buffer_check(crypto_pre_approved_limit)) !=
2055 int rv;
2060 rv = crypto_open_session(dev, open_session.os_flags,
2062 if (rv != CRYPTO_SUCCESS) {
2063 open_session.os_return_value = rv;
2087 int rv;
2092 rv = crypto_close_session(dev, close_session.cs_session);
2093 close_session.cs_return_value = rv;
2114 int rv = 0;
2128 rv = CRYPTO_ARGUMENTS_BAD;
2132 rv = CRYPTO_BUFFER_CHECK(sp, param_len, *out_rctl_chk);
2133 if (rv != CRYPTO_SUCCESS) {
2149 *out_rv = rv;
2151 return ((rv | error) ? B_FALSE : B_TRUE);
2243 int rv = 0;
2249 rv = CRYPTO_SUCCESS;
2254 rv = CRYPTO_ARGUMENTS_BAD;
2278 rv = CRYPTO_ARGUMENTS_BAD;
2289 rv = CRYPTO_BUFFER_CHECK(sp, k_attrs_total_len, *out_rctl_chk);
2290 if (rv != CRYPTO_SUCCESS) {
2330 if (error != 0 || rv != CRYPTO_SUCCESS || u_attrs_out == NULL) {
2342 *out_rv = rv;
2344 return ((rv | error) ? B_FALSE : B_TRUE);
2351 * if both error and rv are set to 0.
2365 int rv = CRYPTO_SUCCESS;
2379 rv = CRYPTO_ARGUMENTS_BAD;
2384 rv = CRYPTO_BUFFER_CHECK(sp, key_bytes,
2386 if (rv != CRYPTO_SUCCESS) {
2410 &rv, &error, &rctl_bytes, out_rctl_chk, B_TRUE)) {
2425 rv = CRYPTO_ARGUMENTS_BAD;
2430 *out_rv = rv;
2432 return ((rv | error) ? B_FALSE : B_TRUE);
2447 int rv = CRYPTO_SESSION_HANDLE_INVALID;
2474 rv = CRYPTO_DEVICE_ERROR;
2478 rv = CRYPTO_SUCCESS;
2487 *out_rv = rv;
2488 return ((rv == CRYPTO_SUCCESS && error == 0) ? B_TRUE : B_FALSE);
2529 int rv;
2537 rv = KCF_PROV_COPYIN_MECH(pd, umech, kmech, error, mode);
2540 return (rv);
2561 int rv;
2567 rv = KCF_PROV_COPYOUT_MECH(pd, kmech, umech, error, mode);
2570 return (rv);
2620 int rv;
2642 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
2657 &key_rctl_bytes, &key_rctl_chk, &rv, &error)) {
2661 if ((rv = kcf_get_hardware_provider(mech.cm_type, &key,
2667 rv = crypto_provider_copyin_mech_param(real_provider,
2670 if (rv == CRYPTO_NOT_SUPPORTED) {
2673 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
2677 if (rv != CRYPTO_SUCCESS)
2681 rv = (init)(real_provider, sp->sd_provider_session->ps_session,
2693 *ctxpp = (rv == CRYPTO_SUCCESS) ? cc : NULL;
2713 STRUCT_FSET(encrypt_init, ei_return_value, rv);
2755 int rv;
2789 rv = CRYPTO_ARGUMENTS_BAD;
2795 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
2803 if ((rv = CRYPTO_BUFFER_CHECK(sp, need, rctl_chk)) !=
2830 rv = (single)(*ctxpp, &encr, NULL, NULL);
2832 rv = (single)(*ctxpp, &data, &encr, NULL);
2834 if (KCF_CONTEXT_DONE(rv))
2837 if (rv == CRYPTO_SUCCESS) {
2848 if (rv == CRYPTO_BUFFER_TOO_SMALL) {
2855 rv = CRYPTO_SUCCESS;
2874 STRUCT_FSET(encrypt, ce_return_value, rv);
2914 int rv;
2949 rv = CRYPTO_ARGUMENTS_BAD;
2955 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
2963 if ((rv = CRYPTO_BUFFER_CHECK(sp, need, rctl_chk)) !=
2990 rv = (update)(*ctxpp, &encr, NULL, NULL);
2992 rv = (update)(*ctxpp, &data, &encr, NULL);
2994 if (rv == CRYPTO_SUCCESS || rv == CRYPTO_BUFFER_TOO_SMALL) {
2995 if (rv == CRYPTO_SUCCESS) {
3010 rv = CRYPTO_SUCCESS;
3031 STRUCT_FSET(encrypt_update, eu_return_value, rv);
3070 int rv;
3103 rv = CRYPTO_ARGUMENTS_BAD;
3109 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
3113 if ((rv = CRYPTO_BUFFER_CHECK(sp, encrlen, rctl_chk)) !=
3138 rv = (final)(*ctxpp, &encr, NULL);
3139 if (KCF_CONTEXT_DONE(rv))
3142 if (rv == CRYPTO_SUCCESS) {
3153 if (rv == CRYPTO_BUFFER_TOO_SMALL) {
3160 rv = CRYPTO_SUCCESS;
3176 STRUCT_FSET(encrypt_final, ef_return_value, rv);
3198 int rv;
3217 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
3222 &rctl_bytes, &rctl_chk, &rv, &error)) {
3226 if ((rv = kcf_get_hardware_provider(mech.cm_type, NULL,
3232 rv = crypto_digest_init_prov(real_provider,
3241 sp->sd_digest_ctx = (rv == CRYPTO_SUCCESS) ? cc : NULL;
3256 STRUCT_FSET(digest_init, di_return_value, rv);
3275 int rv;
3298 rv = CRYPTO_ARGUMENTS_BAD;
3304 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
3308 if ((rv = CRYPTO_BUFFER_CHECK(sp, datalen, rctl_chk)) !=
3326 rv = crypto_digest_update(sp->sd_digest_ctx, &data, NULL);
3327 if (rv != CRYPTO_SUCCESS)
3341 STRUCT_FSET(digest_update, du_return_value, rv);
3361 int rv;
3379 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
3384 &rctl_bytes, &key_rctl_chk, &rv, &error)) {
3388 rv = crypto_digest_key_prov(sp->sd_digest_ctx, &key, NULL);
3389 if (rv != CRYPTO_SUCCESS)
3401 STRUCT_FSET(digest_key, dk_return_value, rv);
3441 int rv;
3476 rv = CRYPTO_ARGUMENTS_BAD;
3482 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
3487 if ((rv = CRYPTO_BUFFER_CHECK(sp, need, rctl_chk)) !=
3517 rv = (single)(*ctxpp, &data, &digest, NULL);
3518 if (KCF_CONTEXT_DONE(rv))
3521 if (rv == CRYPTO_SUCCESS) {
3532 if (rv == CRYPTO_BUFFER_TOO_SMALL) {
3539 rv = CRYPTO_SUCCESS;
3558 STRUCT_FSET(crypto_digest, cd_return_value, rv);
3574 int *rv, int *error)
3593 *rv = tmp_rv;
3612 int rv;
3631 &sp, &rv, &error) != 0)
3636 rv = CRYPTO_PIN_LEN_RANGE;
3647 if ((rv = kcf_get_hardware_provider_nomech(
3657 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
3679 STRUCT_FSET(set_pin, sp_return_value, rv);
3699 int rv;
3719 &sp, &rv, &error) != 0) {
3720 if (rv == CRYPTO_PIN_LEN_RANGE)
3721 rv = CRYPTO_PIN_INCORRECT;
3725 if ((rv = kcf_get_hardware_provider_nomech(
3736 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
3753 STRUCT_FSET(login, co_return_value, rv);
3770 int rv;
3782 if (!get_session_ptr(logout.cl_session, cm, &sp, &error, &rv)) {
3786 if ((rv = kcf_get_hardware_provider_nomech(
3795 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
3807 logout.cl_return_value = rv;
3869 int rv;
3890 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
3918 &key_rctl_bytes, &key_rctl_chk, &rv, &error)) {
3922 if ((rv = kcf_get_hardware_provider(mech.cm_type, &key,
3928 rv = crypto_provider_copyin_mech_param(real_provider,
3931 if (rv == CRYPTO_NOT_SUPPORTED) {
3934 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
3938 if (rv != CRYPTO_SUCCESS)
3942 rv = (init)(real_provider, sp->sd_provider_session->ps_session,
3951 *ctxpp = (rv == CRYPTO_SUCCESS) ? cc : NULL;
3970 STRUCT_FSET(sign_init, si_return_value, rv);
4002 int rv;
4026 rv = CRYPTO_ARGUMENTS_BAD;
4032 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4037 if ((rv = CRYPTO_BUFFER_CHECK(sp, need, rctl_chk)) !=
4058 rv = crypto_verify_single(sp->sd_verify_ctx, &data, &sign, NULL);
4059 if (KCF_CONTEXT_DONE(rv))
4076 STRUCT_FSET(verify, cv_return_value, rv);
4120 int rv;
4142 rv = CRYPTO_ARGUMENTS_BAD;
4148 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4152 if ((rv = CRYPTO_BUFFER_CHECK(sp, datalen, rctl_chk)) !=
4169 rv = (update)(*ctxpp, &data, NULL);
4170 if (rv != CRYPTO_SUCCESS)
4184 STRUCT_FSET(sign_update, su_return_value, rv);
4214 int rv;
4236 rv = CRYPTO_ARGUMENTS_BAD;
4242 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4246 if ((rv = CRYPTO_BUFFER_CHECK(sp, signlen, rctl_chk)) !=
4260 rv = crypto_verify_final(sp->sd_verify_ctx, &sign, NULL);
4261 if (KCF_CONTEXT_DONE(rv))
4275 STRUCT_FSET(verify_final, vf_return_value, rv);
4297 int rv;
4317 rv = CRYPTO_ARGUMENTS_BAD;
4323 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4327 if ((rv = CRYPTO_BUFFER_CHECK(sp, seed_len, rctl_chk)) !=
4340 if ((rv = kcf_get_hardware_provider_nomech(
4350 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4366 STRUCT_FSET(seed_random, sr_return_value, rv);
4388 int rv;
4408 rv = CRYPTO_ARGUMENTS_BAD;
4414 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4418 if ((rv = CRYPTO_BUFFER_CHECK(sp, len, rctl_chk)) !=
4425 if ((rv = kcf_get_hardware_provider_nomech(
4435 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4437 if (rv == CRYPTO_SUCCESS) {
4461 STRUCT_FSET(generate_random, gr_return_value, rv);
4537 int rv;
4557 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4561 &k_attrs_size, NULL, &rv, &error, &rctl_bytes,
4566 if ((rv = kcf_get_hardware_provider_nomech(
4577 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4579 if (rv == CRYPTO_SUCCESS)
4591 STRUCT_FSET(object_create, oc_return_value, rv);
4594 if (rv == CRYPTO_SUCCESS) {
4631 int rv;
4652 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4656 &k_attrs_size, NULL, &rv, &error, &rctl_bytes,
4661 if ((rv = kcf_get_hardware_provider_nomech(
4673 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4675 if (rv == CRYPTO_SUCCESS)
4687 STRUCT_FSET(object_copy, oc_return_value, rv);
4690 if (rv == CRYPTO_SUCCESS) {
4722 int rv;
4739 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4743 if ((rv = kcf_get_hardware_provider_nomech(
4755 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4767 STRUCT_FSET(object_destroy, od_return_value, rv);
4800 int rv;
4823 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4827 &k_attrs_size, &u_attrs, &rv, &error, &rctl_bytes,
4832 if ((rv = kcf_get_hardware_provider_nomech(
4844 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4848 if (rv == CRYPTO_SUCCESS || rv == CRYPTO_ATTRIBUTE_SENSITIVE ||
4849 rv == CRYPTO_ATTRIBUTE_TYPE_INVALID ||
4850 rv == CRYPTO_BUFFER_TOO_SMALL) {
4870 STRUCT_FSET(get_attribute_value, og_return_value, rv);
4891 int rv;
4908 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4912 if ((rv = kcf_get_hardware_provider_nomech(
4924 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
4927 if (rv == CRYPTO_SUCCESS) {
4938 STRUCT_FSET(object_get_size, gs_return_value, rv);
4963 int rv;
4985 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
4989 &k_attrs_size, NULL, &rv, &error, &rctl_bytes,
4994 if ((rv = kcf_get_hardware_provider_nomech(
5006 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5020 STRUCT_FSET(set_attribute_value, sa_return_value, rv);
5044 int rv;
5065 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5069 &k_attrs_size, NULL, &rv, &error, &rctl_bytes,
5074 if ((rv = kcf_get_hardware_provider_nomech(
5083 rv = CRYPTO_OPERATION_IS_ACTIVE;
5091 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5093 if (rv == CRYPTO_SUCCESS) {
5118 STRUCT_FSET(find_init, fi_return_value, rv);
5138 int rv, error = 0;
5158 rv = CRYPTO_ARGUMENTS_BAD;
5164 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5167 if ((rv = CRYPTO_BUFFER_CHECK(sp, len, rctl_chk)) !=
5174 if ((rv = kcf_get_hardware_provider_nomech(
5185 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5188 if (rv == CRYPTO_SUCCESS) {
5191 rv = CRYPTO_FAILED;
5216 STRUCT_FSET(find_update, fu_return_value, rv);
5233 int rv;
5235 if ((rv = kcf_get_hardware_provider_nomech(
5239 return (rv);
5246 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5248 return (rv);
5260 int rv;
5277 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5281 if ((rv = crypto_free_find_ctx(sp)) == CRYPTO_SUCCESS) {
5293 STRUCT_FSET(object_find_final, ff_return_value, rv);
5322 int rv;
5340 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5347 if ((rv = kcf_get_hardware_provider(mech.cm_type, NULL,
5353 rv = crypto_provider_copyin_mech_param(real_provider,
5356 if (rv == CRYPTO_NOT_SUPPORTED) {
5360 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
5364 if (rv != CRYPTO_SUCCESS)
5371 &k_attrs_size, NULL, &rv, &error, &key_rctl_bytes,
5380 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5382 if (rv == CRYPTO_SUCCESS)
5395 STRUCT_FSET(generate_key, gk_return_value, rv);
5398 if (rv == CRYPTO_SUCCESS) {
5453 int rv;
5473 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5480 if ((rv = kcf_get_hardware_provider(mech.cm_type, NULL,
5486 rv = crypto_provider_copyin_mech_param(real_provider,
5489 if (rv == CRYPTO_NOT_SUPPORTED) {
5493 &mech_rctl_chk, &rv, &error)) {
5497 if (rv != CRYPTO_SUCCESS)
5504 &k_in_attrs_size, NULL, &rv, &error, &in_key_rctl_bytes,
5513 &k_out_attrs_size, &u_attrs, &rv, &error, &out_key_rctl_bytes,
5522 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5524 if (rv == CRYPTO_SUCCESS) {
5547 STRUCT_FSET(generate_key, ngk_return_value, rv);
5591 int rv;
5610 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5617 if ((rv = kcf_get_hardware_provider(mech.cm_type, NULL,
5623 rv = crypto_provider_copyin_mech_param(real_provider,
5626 if (rv == CRYPTO_NOT_SUPPORTED) {
5630 &mech_rctl_chk, &rv, &error)) {
5634 if (rv != CRYPTO_SUCCESS)
5643 &k_pub_attrs, &k_pub_attrs_size, NULL, &rv, &error, &pub_rctl_bytes,
5650 &k_pri_attrs, &k_pri_attrs_size, NULL, &rv, &error,
5660 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5662 if (rv == CRYPTO_SUCCESS) {
5681 STRUCT_FSET(generate_key_pair, kp_return_value, rv);
5684 if (rv == CRYPTO_SUCCESS) {
5758 int rv;
5780 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5787 if ((rv = kcf_get_hardware_provider(mech.cm_type, NULL,
5793 rv = crypto_provider_copyin_mech_param(real_provider,
5797 if (rv == CRYPTO_NOT_SUPPORTED) {
5801 &mech_rctl_chk, &rv, &error)) {
5805 if (rv != CRYPTO_SUCCESS)
5815 &k_in_pub_attrs, &k_in_pub_attrs_size, NULL, &rv, &error,
5823 &k_in_pri_attrs, &k_in_pri_attrs_size, NULL, &rv, &error,
5834 &k_out_pub_attrs, &k_out_pub_attrs_size, &u_pub_attrs, &rv, &error,
5842 &k_out_pri_attrs, &k_out_pri_attrs_size, &u_pri_attrs, &rv, &error,
5852 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
5854 if (rv == CRYPTO_SUCCESS) {
5895 STRUCT_FSET(generate_key_pair, nkp_return_value, rv);
5934 int rv;
5953 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
5962 &key_rctl_bytes, &key_rctl_chk, &rv, &error)) {
5968 if ((rv = kcf_get_hardware_provider(mech.cm_type, &key,
5974 rv = crypto_provider_copyin_mech_param(real_provider,
5977 if (rv == CRYPTO_NOT_SUPPORTED) {
5980 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
5984 if (rv != CRYPTO_SUCCESS)
6000 rv = CRYPTO_ARGUMENTS_BAD;
6004 if ((rv = CRYPTO_BUFFER_CHECK(sp, wrapped_key_len,
6018 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
6020 if (rv == CRYPTO_SUCCESS) {
6029 if (rv == CRYPTO_BUFFER_TOO_SMALL) {
6036 rv = CRYPTO_SUCCESS;
6064 STRUCT_FSET(wrap_key, wk_return_value, rv);
6095 int rv;
6116 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
6126 &unwrapping_key_rctl_chk, &rv, &error)) {
6130 if ((rv = kcf_get_hardware_provider(mech.cm_type, &unwrapping_key,
6136 rv = crypto_provider_copyin_mech_param(real_provider,
6139 if (rv == CRYPTO_NOT_SUPPORTED) {
6143 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
6147 if (rv != CRYPTO_SUCCESS)
6154 &k_attrs_size, NULL, &rv, &error, &k_attrs_rctl_bytes,
6163 rv = CRYPTO_ARGUMENTS_BAD;
6167 if ((rv = CRYPTO_BUFFER_CHECK(sp, wrapped_key_len,
6185 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
6187 if (rv == CRYPTO_SUCCESS)
6210 STRUCT_FSET(unwrap_key, uk_return_value, rv);
6213 if (rv == CRYPTO_SUCCESS) {
6261 int rv;
6281 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
6290 &base_key, &key_rctl_bytes, &key_rctl_chk, &rv, &error)) {
6294 if ((rv = kcf_get_hardware_provider(mech.cm_type, &base_key,
6300 rv = crypto_provider_copyin_mech_param(real_provider,
6303 if (rv == CRYPTO_NOT_SUPPORTED) {
6307 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
6311 if (rv != CRYPTO_SUCCESS)
6319 &k_attrs_size, NULL, &rv, &error,
6328 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
6330 if (rv == CRYPTO_SUCCESS) {
6333 rv = crypto_provider_copyout_mech_param(real_provider,
6337 if (rv == CRYPTO_NOT_SUPPORTED) {
6338 rv = CRYPTO_SUCCESS;
6342 if (rv != CRYPTO_SUCCESS)
6360 STRUCT_FSET(derive_key, dk_return_value, rv);
6363 if (rv == CRYPTO_SUCCESS) {
6420 int rv;
6441 if (!get_session_ptr(session_id, cm, &sp, &error, &rv)) {
6450 &base_key, &key_rctl_bytes, &key_rctl_chk, &rv, &error)) {
6454 if ((rv = kcf_get_hardware_provider(mech.cm_type, &base_key,
6460 rv = crypto_provider_copyin_mech_param(real_provider,
6463 if (rv == CRYPTO_NOT_SUPPORTED) {
6467 &mech, &mech_rctl_bytes, &mech_rctl_chk, &rv, &error)) {
6471 if (rv != CRYPTO_SUCCESS)
6480 &k_in_attrs_size, NULL, &rv, &error, &in_attributes_rctl_bytes,
6487 &k_out_attrs, &k_out_attrs_size, &u_attrs, &rv, &error,
6497 rv = kcf_submit_request(real_provider, NULL, NULL, ¶ms, B_FALSE);
6499 if (rv == CRYPTO_SUCCESS) {
6500 rv = crypto_provider_copyout_mech_param(real_provider,
6504 if (rv == CRYPTO_NOT_SUPPORTED) {
6505 rv = CRYPTO_SUCCESS;
6536 STRUCT_FSET(derive_key, ndk_return_value, rv);