1  /*
  2   * Copyright (c) 2000-2004,2011,2014 Apple 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  // dliterators - DL/MDS table access as C++ iterators
 21  //
 22  // This is currently an almost read-only implementation.
 23  // (You can erase but you can't create or modify.)
 24  //
 25  #ifndef _H_CDSA_CLIENT_DLITERATORS
 26  #define _H_CDSA_CLIENT_DLITERATORS
 27  
 28  #include <security_utilities/threading.h>
 29  #include <security_utilities/globalizer.h>
 30  #include <security_utilities/refcount.h>
 31  #include <security_cdsa_utilities/cssmalloc.h>
 32  #include <security_cdsa_utilities/cssmpods.h>
 33  #include <security_cdsa_utilities/cssmerrors.h>
 34  #include <security_cdsa_utilities/cssmdb.h>
 35  #include <security_cdsa_client/dlquery.h>
 36  
 37  
 38  namespace Security {
 39  namespace CssmClient {
 40  
 41  
 42  //
 43  // An abstract interface to a (partial) DLDb-style object.
 44  // This is a particular (open) database that you can perform CSSM database
 45  // operations on.
 46  //
 47  class DLAccess {
 48  public:
 49  	virtual ~DLAccess();
 50  	
 51  	virtual CSSM_HANDLE dlGetFirst(const CSSM_QUERY &query,
 52  		CSSM_DB_RECORD_ATTRIBUTE_DATA &attributes, CSSM_DATA *data,
 53  		CSSM_DB_UNIQUE_RECORD *&id) = 0;
 54  	virtual bool dlGetNext(CSSM_HANDLE handle,
 55  		CSSM_DB_RECORD_ATTRIBUTE_DATA &attributes, CSSM_DATA *data,
 56  		CSSM_DB_UNIQUE_RECORD *&id) = 0;
 57  	virtual void dlAbortQuery(CSSM_HANDLE handle) = 0;
 58  	virtual void dlFreeUniqueId(CSSM_DB_UNIQUE_RECORD *id) = 0;
 59  	virtual void dlDeleteRecord(CSSM_DB_UNIQUE_RECORD *id) = 0;
 60  	virtual Allocator &allocator() = 0;
 61  };
 62  
 63  
 64  //
 65  // Abstract Database Records.
 66  // Each database record type has a subclass of this.
 67  // These are RefCounted; you can hang on to them as long as you like,
 68  // stick (RefPointers to) them into maps, and so on. Just go for it.
 69  //
 70  class Record : public RefCount, public CssmAutoData {
 71  public:
 72  	Record() : CssmAutoData(Allocator::standard(Allocator::sensitive)) { }
 73  	Record(const char * const * attributeNames);	// sets mAttributes
 74  	virtual ~Record();
 75  	static const CSSM_DB_RECORDTYPE recordType = CSSM_DL_DB_RECORD_ANY;
 76  
 77  	void addAttributes(const char * const * attributeNames); // add more
 78  
 79  	// raw attribute access
 80  	CssmDbRecordAttributeData &attributes() { return mAttributes; }
 81  	const CssmDbRecordAttributeData &attributes() const { return mAttributes; }
 82  	CSSM_DB_RECORDTYPE actualRecordType() const { return mAttributes.recordType(); }
 83  	
 84  	CssmAutoData &recordData() { return *this; }	// my data nature
 85  
 86  protected:
 87  	CssmAutoDbRecordAttributeData mAttributes;
 88  };
 89  
 90  
 91  //
 92  // TableBase is an implementation class for template Table below.
 93  // Do not use it directly (you'll be sorry).
 94  // Continue reading at template Table below.
 95  //
 96  class TableBase {
 97  public:
 98  	DLAccess &database;
 99  
100  	CSSM_DB_RECORDTYPE recordType() const { return mRecordType; }
101  	void recordType(CSSM_DB_RECORDTYPE t) { mRecordType = t; }	// override
102  	
103  	// erase all elements matching a query
104  	uint32 erase(const CSSM_QUERY &query);
105  	uint32 erase(const Query &query);
106  
107  protected:
108  	TableBase(DLAccess &source, CSSM_DB_RECORDTYPE type, bool getData = true);
109  	
110  	class AccessRef : public RefCount {
111  	protected:
112  		AccessRef() : mAccess(NULL) { }
113  		AccessRef(DLAccess *ac) : mAccess(ac) { }
114  		DLAccess *mAccess;
115  	};
116  	
117  	struct Handle : public AccessRef {
118  		CSSM_HANDLE query;
119  		Handle(DLAccess *ac, CSSM_HANDLE q) : AccessRef(ac), query(q) { }
120  		~Handle();
121  	};
122  	
123  	struct Uid : public AccessRef {
124  		CSSM_DB_UNIQUE_RECORD *uid;
125  		Uid(DLAccess *ac, CSSM_DB_UNIQUE_RECORD *id) : AccessRef(ac), uid(id) { }
126  		~Uid();
127  	};
128  	
129  	class Iterator {
130  	public:
131  		const CSSM_DB_UNIQUE_RECORD *recordHandle() const
132  		{ assert(mUid); return mUid->uid; }
133  	
134  	protected:
135  		Iterator() { }
136  		Iterator(DLAccess *ac, CSSM_HANDLE query, CSSM_DB_UNIQUE_RECORD *id,
137  			Record *record, bool getData);
138  		void advance(Record *newRecord); // generic operator ++ helper
139  	
140  		DLAccess *mAccess;				// data source
141  		RefPointer<Handle> mQuery;		// DL/MDS query handle
142  		RefPointer<Uid> mUid;			// record unique identifier
143  		RefPointer<Record> mRecord;		// current record value
144  		bool mGetData;					// ask for data on iteration
145  	};
146  	
147  protected:
148  	CSSM_DB_RECORDTYPE mRecordType;		// CSSM/MDS record type
149  	bool mGetData;						// ask for record data on primary iteration
150  };
151  
152  
153  //
154  // A Table represents a single relation in a database (of some kind)
155  //
156  template <class RecordType>
157  class Table : private TableBase {
158  	typedef RefPointer<RecordType> RecPtr;
159  public:
160  	Table(DLAccess &source) : TableBase(source, RecordType::recordType) { }
161  	Table(DLAccess &source, CSSM_DB_RECORDTYPE type) : TableBase(source, type) { }
162  	Table(DLAccess &source, bool getData) : TableBase(source, RecordType::recordType, getData) { }
163  	
164  public:
165  	class iterator : public Iterator,
166  			public std::iterator<forward_iterator_tag, RefPointer<RecordType> > {
167  		friend class Table;
168  	public:
169  		iterator() { }
170  
171  		bool operator == (const iterator &other) const
172  		{ return mUid.get() == other.mUid.get(); }
173  		bool operator != (const iterator &other) const
174  		{ return mUid.get() != other.mUid.get(); }
175  
176  		RecPtr operator * () const { return static_cast<RecordType *>(mRecord.get()); }
177  		RecordType *operator -> () const { return static_cast<RecordType *>(mRecord.get()); }
178  		iterator operator ++ () { advance(new RecordType); return *this; }
179  		iterator operator ++ (int) { iterator old = *this; operator ++ (); return old; }
180  		
181  		void erase();
182  		
183  	private:
184  		iterator(DLAccess *ac, CSSM_HANDLE query, CSSM_DB_UNIQUE_RECORD *id,
185  			RecordType *record, bool getData)
186  			: Iterator(ac, query, id, record, getData) { }
187  	};
188  	
189  public:
190  	iterator begin();
191  	iterator find(const CSSM_QUERY &query);
192  	iterator find(const Query &query);
193  	iterator end()		{ return iterator(); }
194  	RecPtr fetch(const Query &query, CSSM_RETURN err = CSSM_OK) // one-stop shopping
195  	{ return fetchFirst(find(query), err); }
196  	RecPtr fetch(CSSM_RETURN err = CSSM_OK)	// fetch first of type
197  	{ return fetchFirst(begin(), err); }
198  
199  	// erase all records matching a query
200  	void erase(const CSSM_QUERY &query);
201  	void erase(const Query &query);
202  	
203  	void erase(iterator it) { it.erase(); }
204  	
205  private:
206  	iterator startQuery(const CssmQuery &query, bool getData);
207  	RecPtr fetchFirst(iterator it, CSSM_RETURN err);
208  };
209  
210  
211  //
212  // Template out-of-line functions
213  //
214  template <class RecordType>
215  typename Table<RecordType>::iterator Table<RecordType>::begin()
216  {
217  	return startQuery(CssmQuery(mRecordType), mGetData);
218  }
219  
220  template <class RecordType>
221  typename Table<RecordType>::iterator Table<RecordType>::find(const CSSM_QUERY &query)
222  {
223  	return startQuery(CssmQuery(CssmQuery::overlay(query), mRecordType), mGetData);
224  }
225  
226  template <class RecordType>
227  typename Table<RecordType>::iterator Table<RecordType>::find(const Query &query)
228  {
229  	return startQuery(CssmQuery(query.cssmQuery(), mRecordType), mGetData);
230  }
231  
232  template <class RecordType>
233  RefPointer<RecordType> Table<RecordType>::fetchFirst(iterator it, CSSM_RETURN err)
234  {
235  	if (it == end())
236  		if (err)
237  			CssmError::throwMe(err);
238  		else
239  			return NULL;
240  	else
241  		return *it;
242  }
243  
244  
245  template <class RecordType>
246  typename Table<RecordType>::iterator Table<RecordType>::startQuery(const CssmQuery &query, bool getData)
247  {
248  	RefPointer<RecordType> record = new RecordType;
249  	CSSM_DB_UNIQUE_RECORD *id;
250  	CssmAutoData data(database.allocator());
251  	CSSM_HANDLE queryHandle = database.dlGetFirst(query, record->attributes(),
252  		getData ? &data.get() : NULL, id);
253  	if (queryHandle == CSSM_INVALID_HANDLE)
254  		return end();  // not found
255  	if (getData)
256  		record->recordData() = data;
257  	return iterator(&database, queryHandle, id, record, getData);
258  }
259  
260  
261  template <class RecordType>
262  void Table<RecordType>::iterator::erase()
263  {
264  	mAccess->dlDeleteRecord(mUid->uid);
265  	mUid->uid = NULL;
266  }
267  
268  
269  } // end namespace CssmClient
270  } // end namespace Security
271  
272  #endif // _H_CDSA_CLIENT_DLITERATORS