1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * 25 * Copyright 2014, OmniTI Computer Consulting, Inc. All rights reserved. 26 */ 27 /* 28 * General-Purpose Functions 29 * (as defined in PKCS#11 spec section 11.4) 30 */ 31 32 #include <unistd.h> 33 #include <errno.h> 34 #include <string.h> 35 #include "metaGlobal.h" 36 37 extern meta_session_t *meta_sessionlist_head; 38 39 struct CK_FUNCTION_LIST metaslot_functionList = { 40 { 2, 20 }, /* version */ 41 meta_Initialize, 42 meta_Finalize, 43 meta_GetInfo, 44 meta_GetFunctionList, 45 meta_GetSlotList, 46 meta_GetSlotInfo, 47 meta_GetTokenInfo, 48 meta_GetMechanismList, 49 meta_GetMechanismInfo, 50 meta_InitToken, 51 meta_InitPIN, 52 meta_SetPIN, 53 meta_OpenSession, 54 meta_CloseSession, 55 meta_CloseAllSessions, 56 meta_GetSessionInfo, 57 meta_GetOperationState, 58 meta_SetOperationState, 59 meta_Login, 60 meta_Logout, 61 meta_CreateObject, 62 meta_CopyObject, 63 meta_DestroyObject, 64 meta_GetObjectSize, 65 meta_GetAttributeValue, 66 meta_SetAttributeValue, 67 meta_FindObjectsInit, 68 meta_FindObjects, 69 meta_FindObjectsFinal, 70 meta_EncryptInit, 71 meta_Encrypt, 72 meta_EncryptUpdate, 73 meta_EncryptFinal, 74 meta_DecryptInit, 75 meta_Decrypt, 76 meta_DecryptUpdate, 77 meta_DecryptFinal, 78 meta_DigestInit, 79 meta_Digest, 80 meta_DigestUpdate, 81 meta_DigestKey, 82 meta_DigestFinal, 83 meta_SignInit, 84 meta_Sign, 85 meta_SignUpdate, 86 meta_SignFinal, 87 meta_SignRecoverInit, 88 meta_SignRecover, 89 meta_VerifyInit, 90 meta_Verify, 91 meta_VerifyUpdate, 92 meta_VerifyFinal, 93 meta_VerifyRecoverInit, 94 meta_VerifyRecover, 95 meta_DigestEncryptUpdate, 96 meta_DecryptDigestUpdate, 97 meta_SignEncryptUpdate, 98 meta_DecryptVerifyUpdate, 99 meta_GenerateKey, 100 meta_GenerateKeyPair, 101 meta_WrapKey, 102 meta_UnwrapKey, 103 meta_DeriveKey, 104 meta_SeedRandom, 105 meta_GenerateRandom, 106 meta_GetFunctionStatus, 107 meta_CancelFunction, 108 meta_WaitForSlotEvent 109 }; 110 111 pthread_mutex_t initmutex = PTHREAD_MUTEX_INITIALIZER; 112 113 ses_to_be_freed_list_t ses_delay_freed; 114 object_to_be_freed_list_t obj_delay_freed; 115 116 /* 117 * meta_Initialize 118 * 119 * This function is never called by the application. It is only 120 * called by uCF to initialize metaslot. The pInitArgs argument is ignored. 121 * 122 */ 123 /*ARGSUSED*/ 124 CK_RV 125 meta_Initialize(CK_VOID_PTR pInitArgs) 126 { 127 CK_RV rv; 128 129 /* Make sure function hasn't been called twice */ 130 (void) pthread_mutex_lock(&initmutex); 131 132 rv = meta_slotManager_initialize(); 133 if (rv != CKR_OK) { 134 (void) pthread_mutex_unlock(&initmutex); 135 return (rv); 136 } 137 138 rv = meta_mechManager_initialize(); 139 if (rv != CKR_OK) { 140 (void) meta_slotManager_finalize(); 141 (void) pthread_mutex_unlock(&initmutex); 142 return (rv); 143 } 144 145 rv = meta_objectManager_initialize(); 146 if (rv != CKR_OK) { 147 (void) meta_slotManager_finalize(); 148 (void) meta_mechManager_finalize(); 149 (void) pthread_mutex_unlock(&initmutex); 150 return (rv); 151 } 152 153 rv = meta_sessionManager_initialize(); 154 if (rv != CKR_OK) { 155 (void) meta_slotManager_finalize(); 156 (void) meta_mechManager_finalize(); 157 (void) meta_objectManager_finalize(); 158 (void) pthread_mutex_unlock(&initmutex); 159 return (rv); 160 } 161 162 meta_slotManager_find_object_token(); 163 164 /* Initialize the object_to_be_freed list */ 165 (void) pthread_mutex_init(&obj_delay_freed.obj_to_be_free_mutex, NULL); 166 obj_delay_freed.count = 0; 167 obj_delay_freed.first = NULL; 168 obj_delay_freed.last = NULL; 169 170 /* Initialize the session_to_be_freed list */ 171 (void) pthread_mutex_init(&ses_delay_freed.ses_to_be_free_mutex, NULL); 172 ses_delay_freed.count = 0; 173 ses_delay_freed.first = NULL; 174 ses_delay_freed.last = NULL; 175 176 (void) pthread_mutex_unlock(&initmutex); 177 178 return (CKR_OK); 179 } 180 181 182 /* 183 * meta_Finalize 184 * 185 * Called by uCF only, "pReserved" argument is ignored. 186 */ 187 /*ARGSUSED*/ 188 CK_RV 189 meta_Finalize(CK_VOID_PTR pReserved) 190 { 191 CK_RV rv = CKR_OK; 192 meta_object_t *delay_free_obj, *tmpo; 193 meta_session_t *delay_free_ses, *tmps; 194 195 if (pReserved != NULL) 196 return (CKR_ARGUMENTS_BAD); 197 198 (void) pthread_mutex_lock(&initmutex); 199 200 /* 201 * There used to be calls to cleanup libcryptoutil here. Given that 202 * libcryptoutil can be linked and invoked independently of PKCS#11, 203 * cleaning up libcryptoutil here makes no sense. Decoupling these 204 * two also prevent deadlocks and other artificial dependencies. 205 */ 206 207 meta_objectManager_finalize(); 208 209 meta_sessionManager_finalize(); 210 211 meta_mechManager_finalize(); 212 213 meta_slotManager_finalize(); 214 215 /* 216 * free all entries in the delay_freed list 217 */ 218 delay_free_obj = obj_delay_freed.first; 219 while (delay_free_obj != NULL) { 220 tmpo = delay_free_obj->next; 221 free(delay_free_obj); 222 delay_free_obj = tmpo; 223 } 224 (void) pthread_mutex_destroy(&obj_delay_freed.obj_to_be_free_mutex); 225 226 delay_free_ses = ses_delay_freed.first; 227 while (delay_free_ses != NULL) { 228 tmps = delay_free_ses->next; 229 free(delay_free_ses); 230 delay_free_ses = tmps; 231 } 232 (void) pthread_mutex_destroy(&ses_delay_freed.ses_to_be_free_mutex); 233 234 (void) pthread_mutex_unlock(&initmutex); 235 236 return (rv); 237 } 238 239 /* 240 * meta_GetInfo 241 * 242 * NOTE: This function will never be called by applications because it's 243 * hidden behind the uCF C_GetInfo. So, it is not implemented. 244 */ 245 /*ARGSUSED*/ 246 CK_RV 247 meta_GetInfo(CK_INFO_PTR pInfo) 248 { 249 return (CKR_FUNCTION_NOT_SUPPORTED); 250 } 251 252 253 /* 254 * meta_GetFunctionList 255 * 256 * This function is not implemented because metaslot is part of the framework, 257 * so, the framework can just do a static assignment to metaslot's 258 * function list instead of calling this function. 259 */ 260 /*ARGSUSED*/ 261 CK_RV 262 meta_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) 263 { 264 return (CKR_FUNCTION_NOT_SUPPORTED); 265 } 266 267 268 /* 269 * Parallel Function Management Function 270 * (as defined in PKCS#11 spec section 11.16) 271 */ 272 273 /* 274 * This function is no longer supported in this revision of the PKCS#11 275 * standard. It is maintained for backwards compatibility only. 276 */ 277 /* ARGSUSED */ 278 CK_RV 279 meta_GetFunctionStatus(CK_SESSION_HANDLE hSession) 280 { 281 return (CKR_FUNCTION_NOT_PARALLEL); 282 } 283 284 285 /* 286 * This function is no longer supported in this revision of the PKCS#11 287 * standard. It is maintained for backwards compatibility only. 288 */ 289 /* ARGSUSED */ 290 CK_RV 291 meta_CancelFunction(CK_SESSION_HANDLE hSession) 292 { 293 return (CKR_FUNCTION_NOT_PARALLEL); 294 } 295