dlclient.h
1 /* 2 * Copyright (c) 2000-2001,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 // dlclient - client interface to CSSM DLs and their operations 21 // 22 23 #ifndef _H_CDSA_CLIENT_DLCLIENT 24 #define _H_CDSA_CLIENT_DLCLIENT 1 25 26 #include <security_cdsa_client/cssmclient.h> 27 #include <security_cdsa_client/dliterators.h> 28 #include <security_cdsa_client/aclclient.h> 29 #include <security_cdsa_client/DLDBList.h> 30 #include <security_cdsa_utilities/cssmacl.h> 31 #include <security_cdsa_utilities/cssmdb.h> 32 #include <security_cdsa_utilities/cssmdata.h> 33 34 35 namespace Security 36 { 37 38 namespace CssmClient 39 { 40 41 #define CSSM_DB_ATTR(ATTR) ATTR 42 #define CSSM_DB_ATTR_SCHEMA(ATTR) ATTR ## Schema 43 44 #define CSSM_DB_INDEX(ATTR) ATTR ## Index 45 #define CSSM_DB_UNIQUE(ATTR) ATTR ## Unique 46 47 // 48 // Helper macro for declaring and defining a Db index unique and non-unique attributes 49 // 50 #define CSSM_DB_INDEX_DECL(ATTR) static const CSSM_DB_INDEX_INFO CSSM_DB_INDEX(ATTR) 51 #define CSSM_DB_UNIQUE_DECL(ATTR) static const CSSM_DB_INDEX_INFO CSSM_DB_UNIQUE(ATTR) 52 53 54 // 55 // Use this macro for defining a non-unique attribute 56 // 57 #define CSSM_DB_INDEX_DEF(ATTR) \ 58 const CSSM_DB_INDEX_INFO CSSM_DB_INDEX(ATTR) = \ 59 { \ 60 CSSM_DB_INDEX_NONUNIQUE, \ 61 CSSM_DB_INDEX_ON_ATTRIBUTE, \ 62 CSSM_DB_ATTR(ATTR) \ 63 } 64 65 // 66 // Use this macro for defining a unique attribute 67 68 // 69 #define CSSM_DB_UNIQUE_DEF(ATTR) \ 70 const CSSM_DB_INDEX_INFO CSSM_DB_UNIQUE(ATTR) = \ 71 { \ 72 CSSM_DB_INDEX_UNIQUE, \ 73 CSSM_DB_INDEX_ON_ATTRIBUTE, \ 74 CSSM_DB_ATTR(ATTR) \ 75 } 76 77 78 79 // 80 // Helper macro for declaring and defining a Db schema attributes 81 // Use this macro in your header to declare each attribute you require. 82 // 83 #define CSSM_DB_ATTR_DECL(ATTR) \ 84 static const CSSM_DB_ATTRIBUTE_INFO CSSM_DB_ATTR(ATTR); \ 85 static const CSSM_DB_SCHEMA_ATTRIBUTE_INFO CSSM_DB_ATTR_SCHEMA(ATTR) 86 87 // 88 // Don't directly use this macro use one of the below instead. 89 // 90 #define CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \ 91 const CSSM_DB_SCHEMA_ATTRIBUTE_INFO CSSM_DB_ATTR_SCHEMA(ATTR) = \ 92 { \ 93 INTEGER, \ 94 NAME, \ 95 { OID_LEN, OID_DATA }, \ 96 CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \ 97 } 98 99 100 // 101 // Use one of the following macros to defined each declared attribute required by your application. 102 // 103 // 104 // Use this macro to define attributes which are looked up by integer AttributeID. 105 // 106 #define CSSM_DB_INTEGER_ATTR(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \ 107 const CSSM_DB_ATTRIBUTE_INFO ATTR = \ 108 { \ 109 CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER, \ 110 {(char *)INTEGER}, \ 111 CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \ 112 };\ 113 \ 114 CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) 115 116 // 117 // Use this macro to define attributes which are looked up by string AttributeName. 118 // 119 #define CSSM_DB_NAME_ATTR(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \ 120 const CSSM_DB_ATTRIBUTE_INFO ATTR = \ 121 { \ 122 CSSM_DB_ATTRIBUTE_NAME_AS_STRING, \ 123 {NAME}, \ 124 CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \ 125 };\ 126 \ 127 CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) 128 129 // 130 // Use this macro to define attributes which are looked up by OID AttributeNameID. 131 // XXX This does not work yet. 132 // 133 #define CSSM_DB_OID_ATTR(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) \ 134 const CSSM_DB_ATTRIBUTE_INFO ATTR = \ 135 { \ 136 CSSM_DB_ATTRIBUTE_NAME_AS_OID, \ 137 {{OID_LEN, OID_DATA}}, \ 138 CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \ 139 };\ 140 \ 141 CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) 142 143 144 // 145 // Use this macro to define attributes which are part of the primary key. 146 // 147 #define CSSM_DB_PRIMARKEY_ATTR(ATTR, NAME) \ 148 const CSSM_DB_ATTRIBUTE_INFO ATTR = \ 149 { \ 150 CSSM_DB_INDEX_UNIQUE, \ 151 CSSM_DB_INDEX_ON_ATTRIBUTE, \ 152 CSSM_DB_ATTRIBUTE_FORMAT_ ## VALUETYPE \ 153 };\ 154 \ 155 CSSM_DB_ATTR_DEFINE_SCHEMA(ATTR, INTEGER, NAME, OID_LEN, OID_DATA, VALUETYPE) 156 157 158 159 // 160 // Maker interfaces used by various Impl objects 161 // 162 163 // DbMaker -- someone who can create a new DbImpl. 164 class DbImpl; 165 class DbMaker 166 { 167 public: 168 virtual ~DbMaker(); 169 virtual DbImpl *newDb(const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation) = 0; 170 }; 171 172 // DbCursorMaker -- someone who can create a new DbCursorImpl. 173 class DbCursorImpl; 174 class DbCursorMaker 175 { 176 public: 177 virtual ~DbCursorMaker(); 178 virtual DbCursorImpl *newDbCursor(const CSSM_QUERY &query, Allocator &allocator) = 0; 179 virtual DbCursorImpl *newDbCursor(uint32 capacity, Allocator &allocator) = 0; 180 }; 181 182 // DbUniqueRecordMaker -- someone who can create a new DbUniqueRecordImpl. 183 class DbUniqueRecordImpl; 184 class DbUniqueRecordMaker 185 { 186 public: 187 virtual ~DbUniqueRecordMaker(); 188 virtual DbUniqueRecordImpl *newDbUniqueRecord() = 0; 189 }; 190 191 192 // 193 // A DL attachment 194 // 195 class DLImpl : public AttachmentImpl, public DbMaker 196 { 197 public: 198 DLImpl(const Guid &guid); 199 DLImpl(const Module &module); 200 virtual ~DLImpl(); 201 202 virtual void getDbNames(char **); 203 virtual void freeNameList(char **); 204 205 // DbMaker 206 virtual DbImpl *newDb(const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation); 207 private: 208 }; 209 210 class DL : public Attachment 211 { 212 public: 213 typedef DLImpl Impl; 214 215 explicit DL(Impl *impl) : Attachment(impl) {} 216 DL() : Attachment(NULL) {} 217 DL(const Guid &guid) : Attachment(new Impl(guid)) {} 218 DL(const Module &module) : Attachment(new Impl(module)) {} 219 220 Impl *operator ->() const { return &impl<Impl>(); } 221 Impl &operator *() const { return impl<Impl>(); } 222 223 // Conversion to DbMaker. 224 operator DbMaker &() const { return impl<Impl>(); } 225 }; 226 227 228 class DbAttributes; 229 class DbUniqueRecord; 230 class Db; 231 232 233 // 234 // A CSSM_DLDB handle. 235 // Dbs always belong to DLs (DL attachments) 236 // 237 class DbImpl : public ObjectImpl, public AclBearer, 238 public DbCursorMaker, public DbUniqueRecordMaker 239 { 240 public: 241 DbImpl(const DL &dl, const char *inDbName = NULL, const CSSM_NET_ADDRESS *inDbLocation = NULL); 242 virtual ~DbImpl(); 243 244 DL dl() const { return parent<DL>(); } 245 Module module() const { return dl()->module(); } 246 247 virtual void open(); 248 virtual void create(); 249 virtual void createWithBlob (CssmData &blob); 250 virtual void close(); 251 virtual void deleteDb(); 252 virtual void rename(const char *newName); 253 virtual void authenticate(CSSM_DB_ACCESS_TYPE inAccessRequest, 254 const CSSM_ACCESS_CREDENTIALS *inAccessCredentials); 255 virtual void name(char *&outName); // CSSM_DL_GetDbNameFromHandle() 256 257 virtual void createRelation(CSSM_DB_RECORDTYPE inRelationID, 258 const char *inRelationName, 259 uint32 inNumberOfAttributes, 260 const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *pAttributeInfo, 261 uint32 inNumberOfIndexes, 262 const CSSM_DB_SCHEMA_INDEX_INFO *pIndexInfo); 263 virtual void destroyRelation(CSSM_DB_RECORDTYPE inRelationID); 264 265 virtual DbUniqueRecord insert(CSSM_DB_RECORDTYPE recordType, 266 const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes, 267 const CSSM_DATA *data); 268 269 virtual DbUniqueRecord insertWithoutEncryption(CSSM_DB_RECORDTYPE recordType, 270 const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes, 271 CSSM_DATA *data); 272 273 const CSSM_DL_DB_HANDLE &handle() { StLock<Mutex> _(mActivateMutex); activate(); return mHandle; } 274 275 const DbName &dbName() { return mDbName; } 276 void dbName(const DbName &dbName) { mDbName = dbName; } 277 278 // Attempt to get a (cached) name from CSSM_DL_GetDbNameFromHandle(), falls 279 // back to the name passed in to the constructor if this fails. 280 const char *name(); 281 282 const CSSM_NET_ADDRESS *dbLocation() const { return mDbName.dbLocation(); } 283 284 CSSM_DB_ACCESS_TYPE accessRequest() const { return mAccessRequest; } 285 void accessRequest(CSSM_DB_ACCESS_TYPE inAccessRequest) 286 { mAccessRequest = inAccessRequest; } 287 288 const CSSM_ACCESS_CREDENTIALS *accessCredentials() const 289 { return mAccessCredentials; } 290 void accessCredentials(const CSSM_ACCESS_CREDENTIALS *inAccessCredentials) 291 { mAccessCredentials = inAccessCredentials; } 292 293 const void *openParameters() const { return mOpenParameters; } 294 void openParameters(const void *inOpenParameters) 295 { mOpenParameters = inOpenParameters; } 296 297 const CSSM_DBINFO *dbInfo() const { return mDbInfo; } 298 void dbInfo(const CSSM_DBINFO *inDbInfo) { mDbInfo = inDbInfo; } 299 300 const ResourceControlContext *resourceControlContext() const 301 { return mResourceControlContext; } 302 void resourceControlContext(const CSSM_RESOURCE_CONTROL_CONTEXT *inResourceControlContext) 303 { mResourceControlContext = ResourceControlContext::overlay(inResourceControlContext); } 304 305 void passThrough(uint32 passThroughId, const void *in, void **out = NULL); 306 307 template <class TIn, class TOut> 308 void passThrough(uint32 passThroughId, const TIn *in, TOut *out = NULL) 309 { passThrough(passThroughId, (const void *)in, (void **)out); } 310 311 // Passthrough functions (only implemented by AppleCSPDL). 312 virtual void lock(); 313 virtual void unlock(); 314 virtual void unlock(const CSSM_DATA &password); 315 virtual void stash(); 316 virtual void stashCheck(); 317 virtual void getSettings(uint32 &outIdleTimeout, bool &outLockOnSleep); 318 virtual void setSettings(uint32 inIdleTimeout, bool inLockOnSleep); 319 virtual bool isLocked(); 320 virtual void changePassphrase(const CSSM_ACCESS_CREDENTIALS *cred); 321 virtual void recode(const CSSM_DATA &data, const CSSM_DATA &extraData); 322 virtual void copyBlob(CssmData &data); 323 virtual void setBatchMode(Boolean mode, Boolean rollback); 324 325 // Get the version of this database's encoding 326 virtual uint32 dbBlobVersion(); 327 328 // Attempt to recode this database to the new version 329 virtual uint32 recodeDbToVersion(uint32 version); 330 331 // Declare that the recode operation is complete 332 virtual void recodeFinished(); 333 334 // Try to take or release the file lock on the underlying database. 335 // You _must_ call these as a pair. They start a transaction on the 336 // underlying DL object, and that transaction is only finished when release 337 // is called. Pass success=true if you want the transaction to commit; otherwise 338 // it will roll back. 339 virtual void takeFileLock(); 340 virtual void releaseFileLock(bool success); 341 342 // Make a backup of this database on the filesystem 343 virtual void makeBackup(); 344 345 // Make a copy of this database on the filesystem 346 // Throws a UnixError if anything goes wrong 347 virtual void makeCopy(const char* path); 348 349 // Make a clone of this database in a new location. 350 // This method handles telling securityd about the clone, and copying the 351 // file over. 352 virtual Db cloneTo(const DLDbIdentifier& dldbidentifier); 353 354 // Transfer this database to a new location. If the database is open in 355 // securityd, transfer the lock status as well. 356 virtual void transferTo(const DLDbIdentifier& dldbidentifier); 357 358 // This will attempt to delete the file underlying this database. 359 // Don't call this unless you really, really mean to. 360 virtual void deleteFile(); 361 362 // Utility methods 363 364 // Always use the dbName and dbLocation that were passed in during 365 // construction. 366 virtual DLDbIdentifier dlDbIdentifier(); 367 368 // DbCursorMaker 369 virtual DbCursorImpl *newDbCursor(const CSSM_QUERY &query, Allocator &allocator); 370 virtual DbCursorImpl *newDbCursor(uint32 capacity, Allocator &allocator); 371 372 // DbUniqueRecordMaker 373 virtual DbUniqueRecordImpl *newDbUniqueRecord(); 374 375 // Acl manipulation 376 void getAcl(AutoAclEntryInfoList &aclInfos, const char *selectionTag = NULL) const; 377 void changeAcl(const CSSM_ACL_EDIT &aclEdit, 378 const CSSM_ACCESS_CREDENTIALS *accessCred); 379 380 // Acl owner manipulation 381 void getOwner(AutoAclOwnerPrototype &owner) const; 382 void changeOwner(const CSSM_ACL_OWNER_PROTOTYPE &newOwner, 383 const CSSM_ACCESS_CREDENTIALS *accessCred = NULL); 384 385 // default-credential hook 386 class DefaultCredentialsMaker { 387 public: 388 virtual ~DefaultCredentialsMaker(); 389 virtual const AccessCredentials *makeCredentials() = 0; 390 }; 391 392 void defaultCredentials(DefaultCredentialsMaker *maker); // NULL to turn off 393 394 void activate(); 395 396 protected: 397 void deactivate(); 398 399 private: 400 CSSM_DL_DB_HANDLE mHandle; // CSSM DLDB handle 401 402 DbName mDbName; 403 bool mUseNameFromHandle; // false if CSSM_DL_GetDbNameFromHandle failed 404 char *mNameFromHandle; // Cached CSSM_DL_GetDbNameFromHandle result. 405 CSSM_DB_ACCESS_TYPE mAccessRequest; 406 const CSSM_ACCESS_CREDENTIALS *mAccessCredentials; 407 DefaultCredentialsMaker *mDefaultCredentials; 408 const void *mOpenParameters; 409 410 // Arguments to create 411 const CSSM_DBINFO *mDbInfo; 412 const ResourceControlContext *mResourceControlContext; 413 }; 414 415 416 class Db : public Object, public DLAccess 417 { 418 public: 419 typedef DbImpl Impl; 420 typedef Impl::DefaultCredentialsMaker DefaultCredentialsMaker; 421 422 explicit Db(Impl *impl) : Object(impl) {} 423 Db() : Object(NULL) {} 424 Db(DbMaker &maker, const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation = NULL) 425 : Object(maker.newDb(inDbName, inDbLocation)) {} 426 427 Impl *operator ->() const { return &impl<Impl>(); } 428 Impl &operator *() const { return impl<Impl>(); } 429 430 // Conversion to DbCursorMaker. 431 operator DbCursorMaker &() const { return impl<Impl>(); } 432 // Conversion to DbUniqueRecordMaker. 433 operator DbUniqueRecordMaker &() const { return impl<Impl>(); } 434 435 const CSSM_DL_DB_HANDLE &handle() { return impl<Impl>().handle(); } 436 437 protected: 438 // DLAccess adapters 439 CSSM_HANDLE dlGetFirst(const CSSM_QUERY &query, 440 CSSM_DB_RECORD_ATTRIBUTE_DATA &attributes, CSSM_DATA *data, 441 CSSM_DB_UNIQUE_RECORD *&id); 442 bool dlGetNext(CSSM_HANDLE handle, 443 CSSM_DB_RECORD_ATTRIBUTE_DATA &attributes, CSSM_DATA *data, 444 CSSM_DB_UNIQUE_RECORD *&id); 445 void dlAbortQuery(CSSM_HANDLE handle); 446 void dlFreeUniqueId(CSSM_DB_UNIQUE_RECORD *id); 447 void dlDeleteRecord(CSSM_DB_UNIQUE_RECORD *id); 448 Allocator &allocator(); 449 }; 450 451 // 452 // DbCursor 453 // 454 455 // This class is still abstract. You must subclass it in order to be able to instantiate an instance. 456 class DbCursorImpl : public ObjectImpl, public CssmAutoQuery 457 { 458 public: 459 DbCursorImpl(const Object &parent, const CSSM_QUERY &query, Allocator &allocator); 460 DbCursorImpl(const Object &parent, uint32 capacity, Allocator &allocator); 461 462 virtual Allocator &allocator() const; 463 virtual void allocator(Allocator &alloc); 464 465 virtual bool next(DbAttributes *attributes, ::CssmDataContainer *data, DbUniqueRecord &uniqueId) = 0; 466 void abort() { deactivate(); } 467 }; 468 469 class DbCursor : public Object 470 { 471 public: 472 typedef DbCursorImpl Impl; 473 474 explicit DbCursor(Impl *impl) : Object(impl) {} 475 DbCursor() : Object(NULL) {} 476 DbCursor(DbCursorMaker &maker, const CSSM_QUERY &query, 477 Allocator &allocator = Allocator::standard()) 478 : Object(maker.newDbCursor(query, allocator)) {} 479 DbCursor(DbCursorMaker &maker, uint32 capacity = 0, 480 Allocator &allocator = Allocator::standard()) 481 : Object(maker.newDbCursor(capacity, allocator)) {} 482 483 Impl *operator ->() const { return &impl<Impl>(); } 484 Impl &operator *() const { return impl<Impl>(); } 485 }; 486 487 488 // 489 // DbUniqueRecord 490 // 491 class DbUniqueRecordImpl : public ObjectImpl 492 { 493 public: 494 DbUniqueRecordImpl(const Db &db); 495 virtual ~DbUniqueRecordImpl(); 496 497 virtual void deleteRecord(); 498 virtual void modify(CSSM_DB_RECORDTYPE recordType, 499 const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes, 500 const CSSM_DATA *data, 501 CSSM_DB_MODIFY_MODE modifyMode); 502 503 virtual void modifyWithoutEncryption (CSSM_DB_RECORDTYPE recordType, 504 const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes, 505 const CSSM_DATA *data, 506 CSSM_DB_MODIFY_MODE modifyMode); 507 508 virtual void get(DbAttributes *attributes, ::CssmDataContainer *data); 509 510 virtual void getWithoutEncryption(DbAttributes *attributes, ::CssmDataContainer *data); 511 512 Db database() const { return parent<Db>(); } 513 514 void free() { deactivate(); } 515 516 // Client must call activate() after calling this function if mUniqueId is successfully set. 517 operator CSSM_DB_UNIQUE_RECORD_PTR *() { if (mActive) free(); return &mUniqueId; } 518 519 operator CSSM_DB_UNIQUE_RECORD *() { return mUniqueId; } 520 operator const CSSM_DB_UNIQUE_RECORD *() const { return mUniqueId; } 521 522 void activate(); 523 524 void getRecordIdentifier(CSSM_DATA &data); 525 526 void setUniqueRecordPtr (CSSM_DB_UNIQUE_RECORD_PTR uniquePtr); // because cast overloading is evil! 527 528 protected: 529 void deactivate(); 530 531 CSSM_DB_UNIQUE_RECORD_PTR mUniqueId; 532 bool mDestroyID; 533 RecursiveMutex mActivateMutex; 534 }; 535 536 class DbUniqueRecord : public Object 537 { 538 public: 539 typedef DbUniqueRecordImpl Impl; 540 541 explicit DbUniqueRecord(Impl *impl) : Object(impl) {} 542 DbUniqueRecord() : Object(NULL) {} 543 DbUniqueRecord(DbUniqueRecordMaker &maker) : Object(maker.newDbUniqueRecord()) {} 544 545 Impl *operator ->() { return &impl<Impl>(); } 546 Impl &operator *() { return impl<Impl>(); } 547 const Impl &operator *() const { return impl<Impl>(); } 548 549 // Conversion operators must be here. 550 551 // Client must activate after calling this function if mUniqueId is successfully set. 552 operator CSSM_DB_UNIQUE_RECORD_PTR *() { return **this; } 553 554 operator CSSM_DB_UNIQUE_RECORD *() { return **this; } 555 operator const CSSM_DB_UNIQUE_RECORD *() const { return **this; } 556 }; 557 558 559 // 560 // DbAttributes 561 // 562 class DbAttributes : public CssmAutoDbRecordAttributeData 563 { 564 public: 565 DbAttributes(); 566 DbAttributes(const Db &db, uint32 capacity = 0, Allocator &allocator = Allocator::standard()); 567 568 // Similar to CssmAutoDbRecordAttributeData::updateWith, but a different 569 // signature. Will canonicalize the elements in both this and the newValues dbAttributes. 570 void updateWithDbAttributes(DbAttributes* newValues); 571 572 // Try to change the infos in this database to a canonicalized form 573 void canonicalize(); 574 }; 575 576 577 // 578 // DbDbCursor -- concrete subclass of DbCursorImpl for querying Db's 579 // 580 class DbDbCursorImpl : public DbCursorImpl 581 { 582 public: 583 DbDbCursorImpl(const Db &db, const CSSM_QUERY &query, Allocator &allocator); 584 DbDbCursorImpl(const Db &db, uint32 capacity, Allocator &allocator); 585 virtual ~DbDbCursorImpl(); 586 587 bool next(DbAttributes *attributes, ::CssmDataContainer *data, DbUniqueRecord &uniqueId); 588 589 protected: 590 Db database() { return parent<Db>(); } 591 592 void activate(); 593 void deactivate(); 594 595 private: 596 CSSM_HANDLE mResultsHandle; 597 RecursiveMutex mActivateMutex; 598 }; 599 600 } // end namespace CssmClient 601 602 } // end namespace Security 603 604 #endif // _H_CDSA_CLIENT_DLCLIENT