libsecurity_ssl/lib/ModuleAttacher.c

   1 /*
   2  * Copyright (c) 2000-2001,2005-2007,2010-2012 Apple Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /*
  20  * ModuleAttacher.c
  21  *
  22  * Process-wide class which loads and attaches to {CSP, TP, CL} at most
  23  * once, and detaches and unloads the modules when this code is unloaded.
  24  */
  25
  26 #include "ssl.h"
  27 #if USE_CDSA_CRYPTO
  28
  29 #include "ModuleAttacher.h"
  30 #include "sslDebug.h"
  31 #include "appleCdsa.h"
  32 #include <Security/cssmapple.h>
  33 #include <Security/cssmtype.h>
  34 #include <Security/cssmapi.h>
  35
  36 #include <pthread.h>
  37
  38 static pthread_mutex_t gAttachLock = PTHREAD_MUTEX_INITIALIZER;
  39 static CSSM_CSP_HANDLE gCSPHandle = CSSM_INVALID_HANDLE;
  40 static CSSM_CL_HANDLE gCLHandle = CSSM_INVALID_HANDLE;
  41 static CSSM_TP_HANDLE gTPHandle = CSSM_INVALID_HANDLE;
  42
  43 static const CSSM_API_MEMORY_FUNCS CA_memFuncs = {
  44         stAppMalloc,
  45         stAppFree,
  46         stAppRealloc,
  47         stAppCalloc,
  48         NULL
  49 };
  50 static const CSSM_VERSION cssmVers = {2, 0};
  51 static const CSSM_GUID testGuid = { 0xFADE, 0, 0, { 1,2,3,4,5,6,7,0 }};
  52
  53 static CSSM_HANDLE loadModule(
  54         CSSM_SERVICE_TYPE svcType,      // CSSM_SERVICE_CSP, etc.
  55         const CSSM_GUID *guid,
  56         const char *modName)
  57 {
  58         CSSM_RETURN crtn;
  59         CSSM_HANDLE hand;
  60
  61         crtn = CSSM_ModuleLoad(guid,
  62                 CSSM_KEY_HIERARCHY_NONE,
  63                 NULL,                   // eventHandler
  64                 NULL);                  // AppNotifyCallbackCtx
  65         if(crtn) {
  66                 #ifndef NDEBUG
  67                 sslErrorLog("loadModule: error (%lu) loading %s\n",
  68                         (unsigned long)crtn, modName);
  69                 #endif
  70                 return CSSM_INVALID_HANDLE;
  71         }
  72         crtn = CSSM_ModuleAttach (guid,
  73                 &cssmVers,
  74                 &CA_memFuncs,                   // memFuncs
  75                 0,                                              // SubserviceID
  76                 svcType,                                // SubserviceFlags
  77                 0,                                              // AttachFlags
  78                 CSSM_KEY_HIERARCHY_NONE,
  79                 NULL,                                   // FunctionTable
  80                 0,                                              // NumFuncTable
  81                 NULL,                                   // reserved
  82                 &hand);
  83         if(crtn) {
  84                 #ifndef NDEBUG
  85                 sslErrorLog("loadModule: error (%lu) attaching to %s\n",
  86                         (unsigned long)crtn, modName);
  87                 #endif
  88                 return CSSM_INVALID_HANDLE;
  89         }
  90         return hand;
  91 }
  92
  93
  94 static CSSM_RETURN doAttachToModules(void)
  95 {
  96         CSSM_RETURN  crtn;
  97     CSSM_PVC_MODE pvcPolicy = CSSM_PVC_NONE;
  98         CSSM_HANDLE cspHandle, clHandle, tpHandle;
  99
 100         /* Check if we got the lock after some other thread did the
 101            initialization. */
 102         if (gCSPHandle)
 103                 return CSSM_OK;
 104
 105         crtn = CSSM_Init (&cssmVers,
 106                 CSSM_PRIVILEGE_SCOPE_NONE,
 107                 &testGuid,
 108                 CSSM_KEY_HIERARCHY_NONE,
 109                 &pvcPolicy,
 110                 NULL /* reserved */);
 111         if(crtn != CSSM_OK) {
 112                 #ifndef NDEBUG
 113                 sslErrorLog("CSSM_Init returned %lu", (unsigned long)crtn);
 114                 #endif
 115                 return crtn;
 116         }
 117
 118         cspHandle = loadModule(CSSM_SERVICE_CSP, &gGuidAppleCSP, "AppleCSP");
 119         if (cspHandle == CSSM_INVALID_HANDLE)
 120                 return CSSMERR_CSSM_ADDIN_LOAD_FAILED;
 121         clHandle = loadModule(CSSM_SERVICE_CL, &gGuidAppleX509CL, "AppleCL");
 122         if (clHandle == CSSM_INVALID_HANDLE)
 123                 return CSSMERR_CSSM_ADDIN_LOAD_FAILED;
 124         tpHandle = loadModule(CSSM_SERVICE_TP, &gGuidAppleX509TP, "AppleTP");
 125         if (tpHandle == CSSM_INVALID_HANDLE)
 126                 return CSSMERR_CSSM_ADDIN_LOAD_FAILED;
 127
 128         gCSPHandle = cspHandle;
 129         gCLHandle = clHandle;
 130         gTPHandle = tpHandle;
 131
 132         return CSSM_OK;
 133 }
 134
 135 /* Public C function to load and attach to all three modules. */
 136 CSSM_RETURN attachToModules(
 137         CSSM_CSP_HANDLE         *cspHand,
 138         CSSM_CL_HANDLE          *clHand,
 139         CSSM_TP_HANDLE          *tpHand)
 140 {
 141         CSSM_RETURN result;
 142         if (gCSPHandle && gCLHandle && gTPHandle)
 143                 result = CSSM_OK;
 144         else
 145         {
 146                 pthread_mutex_lock(&gAttachLock);
 147                 result = doAttachToModules();
 148                 pthread_mutex_unlock(&gAttachLock);
 149         }
 150
 151         *cspHand = gCSPHandle;
 152         *clHand = gCLHandle;
 153         *tpHand = gTPHandle;
 154
 155         return result;
 156 }
 157
 158 #endif  /* USE_CDSA_CRYPTO */
 159