1  /*
  2   * Copyright (c) 2015 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  /*	CFPlugIn_Factory.c
 25  	Copyright (c) 1999-2014, Apple Inc.  All rights reserved.
 26          Responsibility: Tony Parker
 27  */
 28  
 29  #include "CFBundle_Internal.h"
 30  #include "CFInternal.h"
 31  
 32  static CFTypeID __kCFPFactoryTypeID = _kCFRuntimeNotATypeID;
 33  
 34  struct __CFPFactory {
 35      CFRuntimeBase _base;
 36          
 37      CFUUIDRef _uuid;
 38      Boolean _enabled;
 39      char _padding[3];
 40      
 41      CFPlugInFactoryFunction _func;
 42      
 43      CFPlugInRef _plugIn;
 44      CFStringRef _funcName;
 45      
 46      CFMutableArrayRef _types;
 47      CFLock_t _lock;
 48  };
 49  
 50  static void _CFPFactoryDeallocate(CFTypeRef factory);
 51  
 52  static const CFRuntimeClass __CFPFactoryClass = {
 53      0,
 54      "_CFPFactory",
 55      NULL,	// init
 56      NULL,	// copy
 57      _CFPFactoryDeallocate,
 58      NULL,	// equal
 59      NULL,	// hash
 60      NULL,       // formatting desc
 61      NULL,       // debug desc
 62  };
 63  
 64  CF_PRIVATE void __CFPFactoryInitialize(void) {
 65      static dispatch_once_t initOnce;
 66      dispatch_once(&initOnce, ^{ __kCFPFactoryTypeID = _CFRuntimeRegisterClass(&__CFPFactoryClass); });
 67  }
 68  
 69  static CFTypeID _CFPFactoryGetTypeID(void) {
 70      return __kCFPFactoryTypeID;
 71  }
 72  
 73  static CFLock_t CFPlugInGlobalDataLock = CFLockInit;
 74  static CFMutableDictionaryRef _factoriesByFactoryID = NULL; /* Value is _CFPFactoryRef */
 75  static CFMutableDictionaryRef _factoriesByTypeID = NULL; /* Value is array of _CFPFactoryRef */
 76  
 77  static void _CFPFactoryAddToTable(_CFPFactoryRef factory) {
 78      __CFLock(&factory->_lock);
 79      CFUUIDRef uuid = (CFUUIDRef)CFRetain(factory->_uuid);
 80      CFRetain(factory);
 81      __CFUnlock(&factory->_lock);
 82      
 83      __CFLock(&CFPlugInGlobalDataLock);    
 84      if (!_factoriesByFactoryID) {
 85          CFDictionaryValueCallBacks _factoryDictValueCallbacks = {0, NULL, NULL, NULL, NULL};
 86          _factoriesByFactoryID = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, &_factoryDictValueCallbacks);
 87      }
 88      CFDictionarySetValue(_factoriesByFactoryID, uuid, factory);
 89      __CFUnlock(&CFPlugInGlobalDataLock);
 90      
 91      if (uuid) CFRelease(uuid);
 92      CFRelease(factory);
 93  }
 94  
 95  static void _CFPFactoryRemoveFromTable(_CFPFactoryRef factory) {
 96      __CFLock(&factory->_lock);
 97      CFUUIDRef uuid = factory->_uuid;
 98      if (uuid) CFRetain(uuid);
 99      __CFUnlock(&factory->_lock);
100      
101      __CFLock(&CFPlugInGlobalDataLock);
102      if (uuid && _factoriesByTypeID) CFDictionaryRemoveValue(_factoriesByFactoryID, uuid);
103      __CFUnlock(&CFPlugInGlobalDataLock);
104      
105      if (uuid) CFRelease(uuid);
106  }
107  
108  CF_PRIVATE _CFPFactoryRef _CFPFactoryFind(CFUUIDRef factoryID, Boolean enabled) {
109      _CFPFactoryRef result = NULL;
110      
111      __CFLock(&CFPlugInGlobalDataLock);
112      if (_factoriesByFactoryID) {
113          result = (_CFPFactoryRef )CFDictionaryGetValue(_factoriesByFactoryID, factoryID);
114          if (result && result->_enabled != enabled) result = NULL;
115      }
116      __CFUnlock(&CFPlugInGlobalDataLock);
117      return result;
118  }
119  
120  static void _CFPFactoryDeallocate(CFTypeRef ty) {
121      SInt32 c;
122      _CFPFactoryRef factory = (_CFPFactoryRef)ty;
123      
124      _CFPFactoryRemoveFromTable(factory);
125  
126      if (factory->_plugIn) {
127          _CFPlugInRemoveFactory(factory->_plugIn, factory);
128          CFRelease(factory->_plugIn);
129      }
130      
131      /* Remove all types for this factory. */
132      c = CFArrayGetCount(factory->_types);
133      while (c-- > 0) _CFPFactoryRemoveType(factory, (CFUUIDRef)CFArrayGetValueAtIndex(factory->_types, c));
134      CFRelease(factory->_types);
135  
136      if (factory->_funcName) CFRelease(factory->_funcName);
137      if (factory->_uuid) CFRelease(factory->_uuid);
138  }
139  
140  static _CFPFactoryRef _CFPFactoryCommonCreate(CFAllocatorRef allocator, CFUUIDRef factoryID) {
141      _CFPFactoryRef factory;
142      uint32_t size;
143      size = sizeof(struct __CFPFactory) - sizeof(CFRuntimeBase);
144      factory = (_CFPFactoryRef)_CFRuntimeCreateInstance(allocator, _CFPFactoryGetTypeID(), size, NULL);
145      if (!factory) return NULL;
146  
147      factory->_uuid = (CFUUIDRef)CFRetain(factoryID);
148      factory->_enabled = true;
149      factory->_types = CFArrayCreateMutable(allocator, 0, &kCFTypeArrayCallBacks);
150      factory->_lock = CFLockInit; // WARNING: grab global lock before this lock
151          
152      _CFPFactoryAddToTable(factory);
153  
154      return factory;
155  }
156  
157  CF_PRIVATE _CFPFactoryRef _CFPFactoryCreate(CFAllocatorRef allocator, CFUUIDRef factoryID, CFPlugInFactoryFunction func) {
158      _CFPFactoryRef factory = _CFPFactoryCommonCreate(allocator, factoryID);
159  
160      __CFLock(&factory->_lock);    
161      factory->_func = func;
162      factory->_plugIn = NULL;
163      factory->_funcName = NULL;
164      __CFUnlock(&factory->_lock);
165  
166      return factory;
167  }
168  
169  CF_PRIVATE _CFPFactoryRef _CFPFactoryCreateByName(CFAllocatorRef allocator, CFUUIDRef factoryID, CFPlugInRef plugIn, CFStringRef funcName) {
170      _CFPFactoryRef factory = _CFPFactoryCommonCreate(allocator, factoryID);
171  
172      __CFLock(&factory->_lock);    
173      factory->_func = NULL;
174      factory->_plugIn = (CFPlugInRef)CFRetain(plugIn);
175      if (plugIn) _CFPlugInAddFactory(plugIn, factory);
176      factory->_funcName = (funcName ? (CFStringRef)CFStringCreateCopy(allocator, funcName) : NULL);
177      __CFUnlock(&factory->_lock);
178  
179      return factory;
180  }
181  
182  CF_PRIVATE CFUUIDRef _CFPFactoryCopyFactoryID(_CFPFactoryRef factory) {
183      __CFLock(&factory->_lock);
184      CFUUIDRef uuid = factory->_uuid;
185      if (uuid) CFRetain(uuid);
186      __CFUnlock(&factory->_lock);
187      return uuid;
188  }
189  
190  CF_PRIVATE CFPlugInRef _CFPFactoryCopyPlugIn(_CFPFactoryRef factory) {
191      __CFLock(&factory->_lock);
192      CFPlugInRef result = factory->_plugIn;
193      if (result) CFRetain(result);
194      __CFUnlock(&factory->_lock);
195      return result;
196  }
197  
198  CF_PRIVATE void *_CFPFactoryCreateInstance(CFAllocatorRef allocator, _CFPFactoryRef factory, CFUUIDRef typeID) {
199      void *result = NULL;
200  
201      __CFLock(&factory->_lock);
202      if (factory->_enabled) {
203          if (!factory->_func) {
204              factory->_func = (CFPlugInFactoryFunction)CFBundleGetFunctionPointerForName(factory->_plugIn, factory->_funcName);
205              if (!factory->_func) CFLog(__kCFLogPlugIn, CFSTR("Cannot find function pointer %@ for factory %@ in %@"), factory->_funcName, factory->_uuid, factory->_plugIn);
206          }
207          if (factory->_func) {
208              // UPPGOOP
209              CFPlugInFactoryFunction f = factory->_func;
210              __CFUnlock(&factory->_lock);
211              FAULT_CALLBACK((void **)&(f));
212              result = (void *)INVOKE_CALLBACK2(f, allocator, typeID);
213              __CFLock(&factory->_lock);
214          }
215      } else {
216          CFLog(__kCFLogPlugIn, CFSTR("Factory %@ is disabled"), factory->_uuid);
217      }    
218      __CFUnlock(&factory->_lock);
219  
220      return result;
221  }
222  
223  CF_PRIVATE void _CFPFactoryDisable(_CFPFactoryRef factory) {
224      __CFLock(&factory->_lock);    
225      factory->_enabled = false;
226      __CFUnlock(&factory->_lock);
227      CFRelease(factory);
228  }
229  
230  CF_PRIVATE void _CFPFactoryFlushFunctionCache(_CFPFactoryRef factory) {
231      /* MF:!!! Assert that this factory belongs to a plugIn. */
232      /* This is called by the factory's plugIn when the plugIn unloads its code. */
233      __CFLock(&factory->_lock);
234      factory->_func = NULL;
235      __CFUnlock(&factory->_lock);
236  }
237  
238  CF_PRIVATE void _CFPFactoryAddType(_CFPFactoryRef factory, CFUUIDRef typeID) {
239      /* Add the factory to the type's array of factories */
240      __CFLock(&factory->_lock);
241      /* Add the type to the factory's type list */
242      CFArrayAppendValue(factory->_types, typeID);
243      __CFUnlock(&factory->_lock);
244  
245      __CFLock(&CFPlugInGlobalDataLock);
246      if (!_factoriesByTypeID) _factoriesByTypeID = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
247      CFMutableArrayRef array = (CFMutableArrayRef)CFDictionaryGetValue(_factoriesByTypeID, typeID);
248      if (!array) {
249          CFArrayCallBacks _factoryArrayCallbacks = {0, NULL, NULL, NULL, NULL};
250          // Create this from default allocator
251          array = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &_factoryArrayCallbacks);
252          CFDictionarySetValue(_factoriesByTypeID, typeID, array);
253          CFRelease(array);
254      }
255      CFArrayAppendValue(array, factory);
256      __CFUnlock(&CFPlugInGlobalDataLock);
257  }
258  
259  CF_PRIVATE void _CFPFactoryRemoveType(_CFPFactoryRef factory, CFUUIDRef typeID) {
260      /* Remove it from the factory's type list */
261      SInt32 idx;
262  
263      __CFLock(&factory->_lock);
264      idx = CFArrayGetFirstIndexOfValue(factory->_types, CFRangeMake(0, CFArrayGetCount(factory->_types)), typeID);
265      if (idx >= 0) CFArrayRemoveValueAtIndex(factory->_types, idx);
266      __CFUnlock(&factory->_lock);
267  
268      /* Remove the factory from the type's list of factories */
269      __CFLock(&CFPlugInGlobalDataLock);
270      if (_factoriesByTypeID) {
271          CFMutableArrayRef array = (CFMutableArrayRef)CFDictionaryGetValue(_factoriesByTypeID, typeID);
272          if (array) {
273              idx = CFArrayGetFirstIndexOfValue(array, CFRangeMake(0, CFArrayGetCount(array)), factory);
274              if (idx >= 0) {
275                  CFArrayRemoveValueAtIndex(array, idx);
276                  if (CFArrayGetCount(array) == 0) CFDictionaryRemoveValue(_factoriesByTypeID, typeID);
277              }
278          }
279      }
280      __CFUnlock(&CFPlugInGlobalDataLock);
281  }
282  
283  CF_PRIVATE Boolean _CFPFactorySupportsType(_CFPFactoryRef factory, CFUUIDRef typeID) {
284      SInt32 idx;
285  
286      __CFLock(&factory->_lock);
287      idx = CFArrayGetFirstIndexOfValue(factory->_types, CFRangeMake(0, CFArrayGetCount(factory->_types)), typeID);
288      __CFUnlock(&factory->_lock);
289      
290      return (idx >= 0 ? true : false);
291  }
292  
293  CF_PRIVATE CFArrayRef _CFPFactoryFindCopyForType(CFUUIDRef typeID) {
294      CFArrayRef result = NULL;
295      __CFLock(&CFPlugInGlobalDataLock);
296      if (_factoriesByTypeID) {
297          result = (CFArrayRef)CFDictionaryGetValue(_factoriesByTypeID, typeID);
298          if (result) CFRetain(result);
299      }
300      __CFUnlock(&CFPlugInGlobalDataLock);
301  
302      return result;
303  }
304  
305  /* These methods are called by CFPlugInInstance when an instance is created or destroyed.  If a factory's instance count goes to 0 and the factory has been disabled, the factory is destroyed. */
306  CF_PRIVATE void _CFPFactoryAddInstance(_CFPFactoryRef factory) {
307      /* MF:!!! Assert that factory is enabled. */
308      CFRetain(factory);
309      __CFLock(&factory->_lock);
310      CFPlugInRef plugin = factory->_plugIn;
311      if (plugin) CFRetain(plugin);
312      __CFUnlock(&factory->_lock);
313      if (plugin) {
314          _CFPlugInAddPlugInInstance(plugin);
315          CFRelease(plugin);
316      }    
317  }
318  
319  CF_PRIVATE void _CFPFactoryRemoveInstance(_CFPFactoryRef factory) {
320      __CFLock(&factory->_lock);
321      CFPlugInRef plugin = factory->_plugIn;
322      if (plugin) CFRetain(plugin);
323      __CFUnlock(&factory->_lock);
324      if (plugin) {
325          _CFPlugInRemovePlugInInstance(factory->_plugIn);
326          CFRelease(plugin);
327      }
328      CFRelease(factory);
329  }