cdsa/cdsa/cssmspi.h

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, 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    File:      cssmspi.h
  21
  22    Contains:  Service Provider Interface for CSSM Modules
  23
  24    Copyright: (c) 1999-2000 Apple Computer, Inc., all rights reserved.
  25 */
  26
  27 #ifndef _CSSMSPI_H_
  28 #define _CSSMSPI_H_  1
  29
  30 #include <Security/cssmtype.h>
  31
  32 #ifdef __cplusplus
  33 extern "C" {
  34 #endif
  35
  36 typedef CSSM_RETURN (CSSMAPI *CSSM_SPI_ModuleEventHandler)
  37     (const CSSM_GUID *ModuleGuid,
  38      void *CssmNotifyCallbackCtx,
  39      uint32 SubserviceId,
  40      CSSM_SERVICE_TYPE ServiceType,
  41      CSSM_MODULE_EVENT EventType);
  42
  43 typedef uint32 CSSM_CONTEXT_EVENT;
  44 enum {
  45     CSSM_CONTEXT_EVENT_CREATE = 1,
  46     CSSM_CONTEXT_EVENT_DELETE = 2,
  47     CSSM_CONTEXT_EVENT_UPDATE = 3
  48 };
  49
  50 typedef struct cssm_module_funcs {
  51     CSSM_SERVICE_TYPE ServiceType;
  52     uint32 NumberOfServiceFuncs;
  53     const CSSM_PROC_ADDR *ServiceFuncs;
  54 } CSSM_MODULE_FUNCS, *CSSM_MODULE_FUNCS_PTR;
  55
  56 typedef void *(CSSMAPI *CSSM_UPCALLS_MALLOC)
  57     (CSSM_HANDLE AddInHandle,
  58      uint32 size);
  59
  60 typedef void (CSSMAPI *CSSM_UPCALLS_FREE)
  61     (CSSM_HANDLE AddInHandle,
  62      void *memblock);
  63
  64 typedef void *(CSSMAPI *CSSM_UPCALLS_REALLOC)
  65     (CSSM_HANDLE AddInHandle,
  66      void *memblock,
  67      uint32 size);
  68
  69 typedef void *(CSSMAPI *CSSM_UPCALLS_CALLOC)
  70     (CSSM_HANDLE AddInHandle,
  71      uint32 num,
  72      uint32 size);
  73
  74 typedef struct cssm_upcalls {
  75     CSSM_UPCALLS_MALLOC malloc_func;
  76     CSSM_UPCALLS_FREE free_func;
  77     CSSM_UPCALLS_REALLOC realloc_func;
  78     CSSM_UPCALLS_CALLOC calloc_func;
  79     CSSM_RETURN (CSSMAPI *CcToHandle_func)
  80         (CSSM_CC_HANDLE Cc,
  81          CSSM_MODULE_HANDLE_PTR ModuleHandle);
  82     CSSM_RETURN (CSSMAPI *GetModuleInfo_func)
  83         (CSSM_MODULE_HANDLE Module,
  84          CSSM_GUID_PTR Guid,
  85          CSSM_VERSION_PTR Version,
  86          uint32 *SubServiceId,
  87          CSSM_SERVICE_TYPE *SubServiceType,
  88          CSSM_ATTACH_FLAGS *AttachFlags,
  89          CSSM_KEY_HIERARCHY *KeyHierarchy,
  90          CSSM_API_MEMORY_FUNCS_PTR AttachedMemFuncs,
  91          CSSM_FUNC_NAME_ADDR_PTR FunctionTable,
  92          uint32 NumFunctions);
  93 } CSSM_UPCALLS, *CSSM_UPCALLS_PTR;
  94
  95 CSSM_RETURN CSSMSPI
  96 CSSM_SPI_ModuleLoad (const CSSM_GUID *CssmGuid,
  97                      const CSSM_GUID *ModuleGuid,
  98                      CSSM_SPI_ModuleEventHandler CssmNotifyCallback,
  99                      void *CssmNotifyCallbackCtx);
 100
 101 CSSM_RETURN CSSMSPI
 102 CSSM_SPI_ModuleUnload (const CSSM_GUID *CssmGuid,
 103                        const CSSM_GUID *ModuleGuid,
 104                        CSSM_SPI_ModuleEventHandler CssmNotifyCallback,
 105                        void *CssmNotifyCallbackCtx);
 106
 107 CSSM_RETURN CSSMSPI
 108 CSSM_SPI_ModuleAttach (const CSSM_GUID *ModuleGuid,
 109                        const CSSM_VERSION *Version,
 110                        uint32 SubserviceID,
 111                        CSSM_SERVICE_TYPE SubServiceType,
 112                        CSSM_ATTACH_FLAGS AttachFlags,
 113                        CSSM_MODULE_HANDLE ModuleHandle,
 114                        CSSM_KEY_HIERARCHY KeyHierarchy,
 115                        const CSSM_GUID *CssmGuid,
 116                        const CSSM_GUID *ModuleManagerGuid,
 117                        const CSSM_GUID *CallerGuid,
 118                        const CSSM_UPCALLS *Upcalls,
 119                        CSSM_MODULE_FUNCS_PTR *FuncTbl);
 120
 121 CSSM_RETURN CSSMSPI
 122 CSSM_SPI_ModuleDetach (CSSM_MODULE_HANDLE ModuleHandle);
 123
 124 #if 0
 125 /* XXX You should call these though the Upcalls structure passed into
 126    moduleattach, --Michael. */
 127
 128 /* CSSM Upcalls for Service Provider Modules */
 129
 130 CSSM_RETURN CSSMAPI
 131 cssm_CcToHandle (CSSM_CC_HANDLE Cc,
 132                  CSSM_MODULE_HANDLE *ModuleHandle);
 133
 134 CSSM_RETURN CSSMAPI
 135 cssm_GetModuleInfo (CSSM_MODULE_HANDLE Module,
 136                     CSSM_GUID_PTR Guid,
 137                     CSSM_VERSION_PTR Version,
 138                     uint32 *SubServiceId,
 139                     CSSM_SERVICE_TYPE *SubServiceType,
 140                     CSSM_ATTACH_FLAGS *AttachFlags,
 141                     CSSM_KEY_HIERARCHY *KeyHierarchy,
 142                     CSSM_API_MEMORY_FUNCS_PTR AttachedMemFuncs,
 143                     CSSM_FUNC_NAME_ADDR_PTR FunctionTable,
 144                     uint32 NumFunctions);
 145 #endif
 146
 147 #ifdef __cplusplus
 148 }
 149 #endif
 150
 151 #endif /* _CSSMSPI_H_ */