+++ /dev/null
-/*
- * Copyright (c) 2000-2004 Apple Computer, Inc. All Rights Reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-
-//
-//CoreFoundation related utilities
-//
-#ifndef _H_CFUTILITIES
-#define _H_CFUTILITIES
-
-#include <security_utilities/utilities.h>
-#include <security_utilities/globalizer.h>
-#include <CoreFoundation/CoreFoundation.h>
-#include <algorithm>
-#include <Security/SecBase.h>
-#undef check
-
-
-namespace Security {
-
-
-//
-// Traits of popular CF types
-//
-template <class CFType> struct CFTraits { };
-
-template <> struct CFTraits<CFTypeRef> {
- static bool check(CFTypeRef ref) { return true; }
-};
-
-#define __SEC_CFTYPE(name) \
- template <> struct CFTraits<name##Ref> { \
- static CFTypeID cfid() { return name##GetTypeID(); } \
- static bool check(CFTypeRef ref) { return CFGetTypeID(ref) == cfid(); } \
- };
-
-__SEC_CFTYPE(CFNull)
-__SEC_CFTYPE(CFBoolean)
-__SEC_CFTYPE(CFNumber)
-__SEC_CFTYPE(CFString)
-__SEC_CFTYPE(CFData)
-__SEC_CFTYPE(CFDate)
-__SEC_CFTYPE(CFURL)
-__SEC_CFTYPE(CFBundle)
-__SEC_CFTYPE(CFArray)
-__SEC_CFTYPE(CFDictionary)
-__SEC_CFTYPE(CFSet)
-
-
-//
-// Initialize-only self-releasing CF object handler (lightweight).
-//
-template <class CFType> class CFRef {
-public:
- CFRef() : mRef(NULL) { }
- CFRef(CFType ref) : mRef(ref) { }
- ~CFRef() { this->release(); }
- CFRef(const CFRef &ref) : mRef(ref) {}
- template <class _T> CFRef(const CFRef<_T> &ref) : mRef(ref) {}
-
- CFRef(CFTypeRef ref, OSStatus err)
- : mRef(CFType(ref))
- {
- if (ref && !CFTraits<CFType>::check(ref))
- MacOSError::throwMe(err);
- }
-
- CFRef &take(CFType ref)
- { this->release(); mRef = ref; return *this; }
-
- CFType yield()
- { CFType r = mRef; mRef = NULL; return r; }
-
- CFRef &operator = (CFType ref)
- { if (ref) CFRetain(ref); return take(ref); }
-
- CFRef &operator = (const CFRef &ref)
- { if (ref) CFRetain(ref); return take(ref); }
-
- // take variant for when newly created CFType is returned
- // via a ptr-to-CFType argument.
- CFType *take()
- { if (mRef) CFRelease(mRef); mRef = NULL; return &mRef; }
-
- operator CFType () const { return mRef; }
- operator bool () const { return mRef != NULL; }
- bool operator ! () const { return mRef == NULL; }
-
- CFType get() const { return mRef; }
-
- CFType &aref()
- { take(NULL); return mRef; }
-
- CFType retain() const
- { if (mRef) CFRetain(mRef); return mRef; }
-
- void release() const
- { if (mRef) CFRelease(mRef); }
-
- template <class NewType>
- bool is() const { return CFTraits<NewType>::check(mRef); }
-
- template <class OldType>
- static CFType check(OldType cf, OSStatus err)
- {
- if (cf && !CFTraits<CFType>::check(cf))
- MacOSError::throwMe(err);
- return CFType(cf);
- }
-
- template <class NewType>
- NewType as() const { return NewType(mRef); }
-
- template <class NewType>
- NewType as(OSStatus err) const { return CFRef<NewType>::check(mRef, err); }
-
-private:
- CFType mRef;
-};
-
-
-template <class CFType> class CFCopyRef : public CFRef<CFType> {
- typedef CFRef<CFType> _Base;
-public:
- CFCopyRef() { }
- CFCopyRef(CFType ref) : _Base(ref) { this->retain(); }
- CFCopyRef(const CFCopyRef &ref) : _Base(ref) { this->retain(); }
- template <class _T> CFCopyRef(const CFRef<_T> &ref) : _Base(ref) { this->retain(); }
- CFCopyRef(CFTypeRef ref, OSStatus err) : _Base(ref, err) { this->retain(); }
-
- CFCopyRef &take(CFType ref)
- { _Base::take(ref); return *this; }
-
- CFCopyRef &operator = (CFType ref)
- { if (ref) CFRetain(ref); return take(ref); }
-
- CFCopyRef &operator = (const CFCopyRef &ref)
- { _Base::operator = (ref); return *this; }
-
- template <class _T> CFCopyRef &operator = (const CFRef<_T> &ref)
- { _Base::operator = (ref); return *this; }
-};
-
-
-//
-// A simple function that turns a non-array CFTypeRef into
-// an array of one with that element. This will retain its argument
-// (directly or indirectly).
-//
-inline CFArrayRef cfArrayize(CFTypeRef arrayOrItem)
-{
- if (arrayOrItem == NULL)
- return NULL; // NULL is NULL
- else if (CFGetTypeID(arrayOrItem) == CFArrayGetTypeID()) {
- CFRetain(arrayOrItem);
- return CFArrayRef(arrayOrItem); // already an array
- } else {
- return CFArrayCreate(NULL,
- (const void **)&arrayOrItem, 1, &kCFTypeArrayCallBacks);
- }
-}
-
-
-//
-// An empty CFArray.
-// Since CFArrays are type-neutral, a single immutable empty array will
-// serve for all uses. So keep it.
-//
-struct CFEmptyArray {
- operator CFArrayRef () { return mArray; }
- CFEmptyArray();
-private:
- CFArrayRef mArray;
-};
-
-extern ModuleNexus<CFEmptyArray> cfEmptyArray;
-
-
-//
-// Translate CFStringRef or CFURLRef to (UTF8-encoded) C++ string.
-// If release==true, a CFRelease will be performed on the CFWhatever argument
-// whether the call succeeds or not(!).
-//
-string cfString(CFStringRef str); // extract UTF8 string
-string cfString(CFURLRef url); // path of file: URL (only)
-string cfString(CFBundleRef bundle); // path to bundle root
-
-string cfStringRelease(CFStringRef str CF_CONSUMED); // extract UTF8 string
-string cfStringRelease(CFURLRef url CF_CONSUMED); // path of file: URL (only)
-string cfStringRelease(CFBundleRef bundle CF_CONSUMED); // path to bundle root
-
-
-string cfString(CFTypeRef anything, OSStatus err); // dynamic form; throws err on NULL
-
-
-//
-// Handle CFNumberRefs.
-// This is nasty because CFNumber does not support unsigned types, and there's really no portably-safe
-// way of working around this. So the handling of unsigned numbers is "almost correct."
-//
-template <class Number>
-struct CFNumberTraits;
-
-template <> struct CFNumberTraits<char> {
- static const CFNumberType cfnType = kCFNumberCharType;
- typedef char ValueType;
-};
-template <> struct CFNumberTraits<short> {
- static const CFNumberType cfnType = kCFNumberShortType;
- typedef short ValueType;
-};
-template <> struct CFNumberTraits<int> {
- static const CFNumberType cfnType = kCFNumberIntType;
- typedef int ValueType;
-};
-template <> struct CFNumberTraits<long> {
- static const CFNumberType cfnType = kCFNumberLongType;
- typedef long ValueType;
-};
-template <> struct CFNumberTraits<long long> {
- static const CFNumberType cfnType = kCFNumberLongLongType;
- typedef long long ValueType;
-};
-template <> struct CFNumberTraits<float> {
- static const CFNumberType cfnType = kCFNumberFloatType;
- typedef float ValueType;
-};
-template <> struct CFNumberTraits<double> {
- static const CFNumberType cfnType = kCFNumberDoubleType;
- typedef double ValueType;
-};
-
-template <> struct CFNumberTraits<unsigned char> {
- static const CFNumberType cfnType = kCFNumberIntType;
- typedef int ValueType;
-};
-template <> struct CFNumberTraits<unsigned short> {
- static const CFNumberType cfnType = kCFNumberIntType;
- typedef int ValueType;
-};
-template <> struct CFNumberTraits<unsigned int> {
- static const CFNumberType cfnType = kCFNumberLongLongType;
- typedef long long ValueType;
-};
-template <> struct CFNumberTraits<unsigned long> {
- static const CFNumberType cfnType = kCFNumberLongLongType;
- typedef long long ValueType;
-};
-template <> struct CFNumberTraits<unsigned long long> {
- static const CFNumberType cfnType = kCFNumberLongLongType;
- typedef long long ValueType;
-};
-
-template <class Number>
-Number cfNumber(CFNumberRef number)
-{
- typename CFNumberTraits<Number>::ValueType value;
- if (CFNumberGetValue(number, CFNumberTraits<Number>::cfnType, &value))
- return (Number)value;
- else
- CFError::throwMe();
-}
-
-template <class Number>
-Number cfNumber(CFNumberRef number, Number defaultValue)
-{
- typename CFNumberTraits<Number>::ValueType value;
- if (CFNumberGetValue(number, CFNumberTraits<Number>::cfnType, &value))
- return value;
- else
- return defaultValue;
-}
-
-template <class Number>
-CFNumberRef makeCFNumber(Number value)
-{
- typename CFNumberTraits<Number>::ValueType cfValue = value;
- return CFNumberCreate(NULL, CFNumberTraits<Number>::cfnType, &cfValue);
-}
-
-// legacy form
-inline uint32_t cfNumber(CFNumberRef number) { return cfNumber<uint32_t>(number); }
-
-
-//
-// Translate strings into CFStrings
-//
-inline CFStringRef makeCFString(const char *s, CFStringEncoding encoding = kCFStringEncodingUTF8)
-{
- return s ? CFStringCreateWithCString(NULL, s, encoding) : NULL;
-}
-
-inline CFStringRef makeCFString(const string &s, CFStringEncoding encoding = kCFStringEncodingUTF8)
-{
- return CFStringCreateWithCString(NULL, s.c_str(), encoding);
-}
-
-inline CFStringRef makeCFString(CFDataRef data, CFStringEncoding encoding = kCFStringEncodingUTF8)
-{
- return CFStringCreateFromExternalRepresentation(NULL, data, encoding);
-}
-
-
-//
-// Create CFURL objects from various sources
-//
-CFURLRef makeCFURL(const char *s, bool isDirectory = false, CFURLRef base = NULL);
-CFURLRef makeCFURL(CFStringRef s, bool isDirectory = false, CFURLRef base = NULL);
-
-inline CFURLRef makeCFURL(const string &s, bool isDirectory = false, CFURLRef base = NULL)
-{
- return makeCFURL(s.c_str(), isDirectory, base);
-}
-
-
-//
-// Make temporary CF objects.
-//
-class CFTempString : public CFRef<CFStringRef> {
-public:
- template <class Source>
- CFTempString(Source s) : CFRef<CFStringRef>(makeCFString(s)) { }
-};
-
-class CFTempURL : public CFRef<CFURLRef> {
-public:
- template <class Source>
- CFTempURL(Source s, bool isDirectory = false, CFURLRef base = NULL)
- : CFRef<CFURLRef>(makeCFURL(s, isDirectory, base)) { }
-};
-
-
-//
-// A temporary CFNumber
-//
-class CFTempNumber : public CFRef<CFNumberRef> {
-public:
- template <class Value>
- CFTempNumber(Value value) : CFRef<CFNumberRef>(makeCFNumber(value)) { }
-};
-
-
-//
-// A temporary CFData.
-//
-class CFTempData : public CFRef<CFDataRef> {
-public:
- CFTempData(const void *data, size_t length)
- : CFRef<CFDataRef>(CFDataCreate(NULL, (const UInt8 *)data, length)) { }
-
- template <class Dataoid>
- CFTempData(const Dataoid &dataoid)
- : CFRef<CFDataRef>(CFDataCreate(NULL, (const UInt8 *)dataoid.data(), dataoid.length())) { }
-};
-
-class CFTempDataWrap : public CFRef<CFDataRef> {
-public:
- CFTempDataWrap(const void *data, size_t length)
- : CFRef<CFDataRef>(CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)data, length, kCFAllocatorNull)) { }
-
- template <class Dataoid>
- CFTempDataWrap(const Dataoid &dataoid)
- : CFRef<CFDataRef>(CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)dataoid.data(), dataoid.length(), kCFAllocatorNull)) { }
-};
-
-
-//
-// Create CFData objects from various sources.
-//
-inline CFDataRef makeCFData(const void *data, size_t size)
-{
- return CFDataCreate(NULL, (const UInt8 *)data, size);
-}
-
-inline CFDataRef makeCFData(CFDictionaryRef dictionary)
-{
- return CFPropertyListCreateXMLData(NULL, dictionary);
-}
-
-template <class Data>
-inline CFDataRef makeCFData(const Data &source)
-{
- return CFDataCreate(NULL, reinterpret_cast<const UInt8 *>(source.data()), source.length());
-}
-
-inline CFDataRef makeCFDataMalloc(const void *data, size_t size)
-{
- return CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)data, size, kCFAllocatorMalloc);
-}
-
-template <class Data>
-inline CFDataRef makeCFDataMalloc(const Data &source)
-{
- return CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)source.data(), source.length(), kCFAllocatorMalloc);
-}
-
-
-//
-// Create a CFDataRef from malloc'ed data, exception-safely
-//
-class CFMallocData {
-public:
- CFMallocData(size_t size)
- : mData(::malloc(size)), mSize(size)
- {
- if (!mData)
- UnixError::throwMe();
- }
-
- ~CFMallocData()
- {
- if (mData)
- ::free(mData);
- }
-
- template <class T>
- operator T * ()
- { return static_cast<T *>(mData); }
-
- operator CFDataRef ();
-
- void *data() { return mData; }
- const void *data() const { return mData; }
- size_t length() const { return mSize; }
-
-private:
- void *mData;
- size_t mSize;
-};
-
-
-//
-// Make CFDictionaries from stuff
-//
-CFDictionaryRef makeCFDictionary(unsigned count, ...); // key/value pairs
-CFMutableDictionaryRef makeCFMutableDictionary(); // empty
-CFMutableDictionaryRef makeCFMutableDictionary(unsigned count, ...); // (count) key/value pairs
-CFMutableDictionaryRef makeCFMutableDictionary(CFDictionaryRef dict); // copy of dictionary
-
-CFDictionaryRef makeCFDictionaryFrom(CFDataRef data) CF_RETURNS_RETAINED;// interpret plist form
-CFDictionaryRef makeCFDictionaryFrom(const void *data, size_t length) CF_RETURNS_RETAINED; // ditto
-
-
-//
-// Parsing out a CFDictionary without losing your lunch
-//
-class CFDictionary : public CFCopyRef<CFDictionaryRef> {
- typedef CFCopyRef<CFDictionaryRef> _Base;
-public:
- CFDictionary(CFDictionaryRef ref, OSStatus error) : _Base(ref), mDefaultError(error)
- { if (!ref) MacOSError::throwMe(error); }
- CFDictionary(CFTypeRef ref, OSStatus error) : _Base(ref, error), mDefaultError(error)
- { if (!ref) MacOSError::throwMe(error); }
- CFDictionary(OSStatus error) : _Base(NULL), mDefaultError(error) { }
-
- using CFCopyRef<CFDictionaryRef>::get;
-
- CFTypeRef get(CFStringRef key) { return CFDictionaryGetValue(*this, key); }
- CFTypeRef get(const char *key) { return CFDictionaryGetValue(*this, CFTempString(key)); }
-
- template <class CFType>
- CFType get(CFStringRef key, OSStatus err = errSecSuccess) const
- {
- CFTypeRef elem = CFDictionaryGetValue(*this, key);
- return CFRef<CFType>::check(elem, err ? err : mDefaultError);
- }
-
- template <class CFType>
- CFType get(const char *key, OSStatus err = errSecSuccess) const
- { return get<CFType>(CFTempString(key), err); }
-
- void apply(CFDictionaryApplierFunction func, void *context)
- { return CFDictionaryApplyFunction(*this, func, context); }
-
-private:
- template <class T>
- struct Applier {
- T *object;
- void (T::*func)(CFTypeRef key, CFTypeRef value);
- static void apply(CFTypeRef key, CFTypeRef value, void *context)
- { Applier *me = (Applier *)context; return ((me->object)->*(me->func))(key, value); }
- };
-
- template <class Key, class Value>
- struct BlockApplier {
- void (^action)(Key key, Value value);
- static void apply(CFTypeRef key, CFTypeRef value, void* context)
- { BlockApplier *me = (BlockApplier *)context; return me->action(Key(key), Value(value)); }
- };
-
-public:
- template <class T>
- void apply(T *object, void (T::*func)(CFTypeRef key, CFTypeRef value))
- { Applier<T> app; app.object = object; app.func = func; return apply(app.apply, &app); }
-
- template <class Key = CFTypeRef, class Value = CFTypeRef>
- void apply(void (^action)(Key key, Value value))
- { BlockApplier<Key, Value> app; app.action = action; return apply(app.apply, &app); }
-
-private:
- OSStatus mDefaultError;
-};
-
-
-//
-// CFURLAccess wrappers for specific purposes
-//
-CFDataRef cfLoadFile(CFURLRef url);
-CFDataRef cfLoadFile(int fd, size_t bytes);
-inline CFDataRef cfLoadFile(CFStringRef path) { return cfLoadFile(CFTempURL(path)); }
-inline CFDataRef cfLoadFile(const std::string &path) { return cfLoadFile(CFTempURL(path)); }
-inline CFDataRef cfLoadFile(const char *path) { return cfLoadFile(CFTempURL(path)); }
-
-
-//
-// Internally used STL adapters. Should probably be in utilities.h.
-//
-template <class Self>
-Self projectPair(const Self &me)
-{ return me; }
-
-template <class First, class Second>
-Second projectPair(const pair<First, Second> &me)
-{ return me.second; }
-
-
-//
-// A CFToVector turns a CFArrayRef of items into a flat
-// C vector of some type, using a conversion function
-// (from CFTypeRef) specified. As a special bonus, if
-// you provide a CFTypeRef (other than CFArrayRef), it
-// will be transparently handled as an array-of-one.
-// The array will be automatically released on destruction
-// of the CFToVector object. Any internal structure shared
-// with the CFTypeRef inputs will be left alone.
-//
-template <class VectorBase, class CFRefType, VectorBase convert(CFRefType)>
-class CFToVector {
-public:
- CFToVector(CFArrayRef arrayRef);
- ~CFToVector() { delete[] mVector; }
- operator UInt32 () const { return mCount; }
- operator VectorBase *() const { return mVector; }
- bool empty() const { return mCount == 0; }
-
- VectorBase *begin() const { return mVector; }
- VectorBase *end() const { return mVector + mCount; }
-
- VectorBase &operator [] (UInt32 ix) const { assert(ix < mCount); return mVector[ix]; }
-
-private:
- VectorBase *mVector;
- UInt32 mCount;
-};
-
-template <class VectorBase, class CFRefType, VectorBase convert(CFRefType)>
-CFToVector<VectorBase, CFRefType, convert>::CFToVector(CFArrayRef arrayRef)
-{
- if (arrayRef == NULL) {
- mCount = 0;
- mVector = NULL;
- } else {
- mCount = (UInt32)CFArrayGetCount(arrayRef);
- mVector = new VectorBase[mCount];
- for (UInt32 n = 0; n < mCount; n++)
- mVector[n] = convert(CFRefType(CFArrayGetValueAtIndex(arrayRef, n)));
- }
-}
-
-
-//
-// Make CFArrays from stuff.
-//
-template <class Iterator, class Generator>
-inline CFArrayRef makeCFArray(Generator &generate, Iterator first, Iterator last)
-{
- // how many elements?
- size_t size = distance(first, last);
-
- // do the CFArrayCreate tango
- auto_array<CFTypeRef> vec(size);
- for (UInt32 n = 0; n < size; n++)
- vec[n] = generate(projectPair(*first++));
- assert(first == last);
- return CFArrayCreate(NULL, (const void **)vec.get(), size, &kCFTypeArrayCallBacks);
-}
-
-template <class Container, class Generator>
-inline CFArrayRef makeCFArray(Generator &generate, const Container &container)
-{
- return makeCFArray(generate, container.begin(), container.end());
-}
-
-CFArrayRef makeCFArray(CFIndex count, ...) CF_RETURNS_RETAINED;
-CFMutableArrayRef makeCFMutableArray(CFIndex count, ...) CF_RETURNS_RETAINED;
-
-
-} // end namespace Security
-
-#endif //_H_CFUTILITIES
projects / apple / security.git / blobdiff