1/*
2 * Copyright (c) 2000-2004,2011-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 */
27#ifndef _SECURITY_REFCOUNT_H_
28#define _SECURITY_REFCOUNT_H_
29
30#include <security_utilities/threading.h>
31#include <libkern/OSAtomic.h>
32
33namespace Security {
34
35
36//
37// RefCount/RefPointer - a simple reference counting facility.
38//
39// To make an object reference-counted, inherit from RefCount. To track refcounted
40// objects, use RefPointer<TheType>, where TheType must inherit from RefCount.
41//
42// RefCount is thread safe - any number of threads can hold and manipulate references
43// in parallel. It does however NOT protect the contents of your object - just the
44// reference count itself. If you need to share your object contents, you must provide
45// appropriate locking yourself.
46//
47// There is no (thread safe) way to determine whether you are the only thread holding
48// a pointer to a particular RefCount object. Thus there is no (thread safe)
49// way to "demand copy" a RefCount subclass. Trust me; it's been tried. Don't.
50//
51
52#if !defined(DEBUG_REFCOUNTS)
53# define DEBUG_REFCOUNTS 1
54#endif
55
56#if DEBUG_REFCOUNTS
57# define RCDEBUG(_kind, _args...)	SECURITY_DEBUG_REFCOUNT_##_kind((void *)this, ##_args)
58#else
59# define RCDEBUG(kind)	/* nothing */
60#endif
61
62
63//
64// Base class for reference counted objects
65//
66class RefCount {
67public:
68	RefCount() : mRefCount(0) { RCDEBUG(CREATE); }
69
70protected:
71	template <class T> friend class RefPointer;
72
73	void ref() const
74    {
75        OSAtomicIncrement32(&mRefCount);
76        RCDEBUG(UP, mRefCount);
77    }
78
79    unsigned int unref() const
80    {
81        RCDEBUG(DOWN, mRefCount - 1);
82        return OSAtomicDecrement32(&mRefCount);
83    }
84
85	// if you call this for anything but debug output, you will go to hell (free handbasket included)
86	unsigned int refCountForDebuggingOnly() const { return mRefCount; }
87
88private:
89    volatile mutable int32_t mRefCount;
90};
91
92
93//
94// A pointer type supported by reference counts.
95// T must be derived from RefCount.
96//
97template <class T>
98class RefPointer {
99	template <class Sub> friend class RefPointer; // share with other instances
100public:
101	RefPointer() : ptr(0) {}			// default to NULL pointer
102	RefPointer(const RefPointer& p) { if (p) p->ref(); ptr = p.ptr; }
103	RefPointer(T *p) { if (p) p->ref(); ptr = p; }
104
105	template <class Sub>
106	RefPointer(const RefPointer<Sub>& p) { if (p) p->ref(); ptr = p.ptr; }
107
108	~RefPointer() { release(); }
109
110	RefPointer& operator = (const RefPointer& p)	{ setPointer(p.ptr); return *this; }
111 	RefPointer& operator = (T * p)					{ setPointer(p); return *this; }
112
113	template <class Sub>
114	RefPointer& operator = (const RefPointer<Sub>& p) { setPointer(p.ptr); return *this; }
115
116	// dereference operations
117    T* get () const				{ _check(); return ptr; }	// mimic auto_ptr
118	operator T * () const		{ _check(); return ptr; }
119	T * operator -> () const	{ _check(); return ptr; }
120	T & operator * () const		{ _check(); return *ptr; }
121
122protected:
123	void release_internal()
124    {
125        if (ptr && ptr->unref() == 0)
126        {
127            delete ptr;
128            ptr = NULL;
129        }
130    }
131
132    void release()
133    {
134        StLock<Mutex> mutexLock(mMutex);
135        release_internal();
136    }
137
138    void setPointer(T *p)
139    {
140        StLock<Mutex> mutexLock(mMutex);
141        if (p)
142        {
143            p->ref();
144        }
145
146        release_internal();
147        ptr = p;
148    }
149
150	void _check() const { }
151
152	T *ptr;
153    Mutex mMutex;
154};
155
156template <class T>
157bool operator <(const RefPointer<T> &r1, const RefPointer<T> &r2)
158{
159	T *p1 = r1.get(), *p2 = r2.get();
160	return p1 && p2 ? *p1 < *p2 : p1 < p2;
161}
162
163template <class T>
164bool operator ==(const RefPointer<T> &r1, const RefPointer<T> &r2)
165{
166	T *p1 = r1.get(), *p2 = r2.get();
167	return p1 && p2 ? *p1 == *p2 : p1 == p2;
168}
169
170template <class T>
171bool operator !=(const RefPointer<T> &r1, const RefPointer<T> &r2)
172{
173	T *p1 = r1.get(), *p2 = r2.get();
174	return p1 && p2 ? *p1 != *p2 : p1 != p2;
175}
176
177} // end namespace Security
178
179#endif // !_SECURITY_REFCOUNT_H_
180