1/* 2 * Copyright (c) 2000-2001,2003-2004,2006,2011-2012,2014 Apple Inc. All Rights Reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. Please obtain a copy of the License at 10 * http://www.opensource.apple.com/apsl/ and read it before using this 11 * file. 12 * 13 * The Original Code and all software distributed under the License are 14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 18 * Please see the License for the specific language governing rights and 19 * limitations under the License. 20 * 21 * @APPLE_LICENSE_HEADER_END@ 22 */ 23 24 25// 26// Encapsulate the callback mechanism of CSSM. 27// 28#ifndef _H_CALLBACK 29#define _H_CALLBACK 30 31#include <Security/cssm.h> 32#include <security_utilities/threading.h> 33#include <security_cdsa_utilities/cssmpods.h> 34#include <map> 35 36namespace Security 37{ 38 39// 40// A single module-specific callback as requested by the user. 41// 42class ModuleCallback { 43public: 44 ModuleCallback() : mCallback(0), mContext(0) { } 45 ModuleCallback(CSSM_API_ModuleEventHandler callback, void *context) 46 : mCallback(callback), mContext(context) { } 47 48 void operator () (CSSM_MODULE_EVENT event, 49 const Guid &guid, uint32 subId, 50 CSSM_SERVICE_TYPE serviceType) const; 51 52 operator bool () const { return mCallback || mContext; } 53 bool operator ! () const { return !bool(*this); } 54 55 bool operator == (const ModuleCallback &cb) const 56 { return mCallback == cb.mCallback && mContext == cb.mContext; } 57 bool operator < (const ModuleCallback &cb) const 58 { return mCallback < cb.mCallback 59 || (mCallback == cb.mCallback && mContext < cb.mContext); } 60 61private: 62 CSSM_API_ModuleEventHandler mCallback; 63 void *mContext; 64}; 65 66 67// 68// A set of callbacks that can be invoked automatically in a thread-safe manner. 69// THREADS: The set itself is not interlocked by the ModuleCallbackSet class; you 70// are responsible for ensuring single access to the set object. The class ensures 71// that any threads it spawns to execute the callbacks will not step on each other 72// or on you, and that you will not be able to erase() a callback while it has 73// activity scheduled against it. This also applies to the invocation method 74// (operator ()) - you must lock against multiple accesses to it until it returns. 75// 76class ModuleCallbackSet { 77public: 78 unsigned int size() const { return (int)callbacks.size(); } 79 void insert(const ModuleCallback &newCallback); 80 void erase(const ModuleCallback &oldCallback); 81 82 void operator () (CSSM_MODULE_EVENT event, 83 const Guid &guid, uint32 subId, 84 CSSM_SERVICE_TYPE serviceType) const; 85 86private: 87 // note mutex *: we don't want to rely on copy-ability of Mutex objects 88 typedef multimap<ModuleCallback, CountingMutex *> CallbackMap; 89 mutable CallbackMap callbacks; 90 91 struct Runner : public Thread { 92 Runner(CallbackMap &inCallbacks, 93 CSSM_MODULE_EVENT inEvent, 94 const Guid &inGuid, 95 uint32 inSSId, 96 CSSM_SERVICE_TYPE inServiceType) 97 : callbacks(inCallbacks), event(inEvent), guid(inGuid), 98 subserviceId(inSSId), serviceType(inServiceType) { } 99 100 CallbackMap callbacks; // note that we share the CountingMutex * values! 101 const CSSM_MODULE_EVENT event; 102 const Guid guid; 103 const uint32 subserviceId; 104 const CSSM_SERVICE_TYPE serviceType; 105 106 void action(); 107 }; 108}; 109 110} // end namespace Security 111 112 113#endif //_H_CALLBACK 114