libsecurity_cdsa_plugin/lib/DatabaseSession.cpp

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, 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 // DatabaseSession.cpp - DL Session.
  21 //
  22 #include <security_cdsa_plugin/DatabaseSession.h>
  23
  24 #include <security_cdsa_plugin/Database.h>
  25 #include <security_cdsa_plugin/DbContext.h>
  26 #include <security_cdsa_utilities/cssmbridge.h>
  27 #include <memory>
  28 #include <security_utilities/debugging.h>
  29
  30 /* log open/close events */
  31 #define DOCDebug(args...)       secdebug("DBOpen", ## args)
  32
  33
  34 using namespace std;
  35
  36 extern "C" char* cssmErrorString(CSSM_RETURN errCode);
  37
  38 //
  39 // Session constructor
  40 //
  41 DatabaseSession::DatabaseSession(DatabaseManager &inDatabaseManager)
  42 : mDatabaseManager(inDatabaseManager)
  43 {
  44 }
  45
  46 DatabaseSession::~DatabaseSession()
  47 {
  48 }
  49
  50
  51 // Utility functions
  52 void
  53 DatabaseSession::GetDbNames(CSSM_NAME_LIST_PTR &outNameList)
  54 {
  55         secdebug("dbsession", "GetDbNames");
  56         outNameList = mDatabaseManager.getDbNames (*this);
  57
  58 #ifndef NDEBUG
  59         // dump the returned names
  60         uint32 n;
  61         secdebug("dbsession", "GetDbNames returned %d names", outNameList->NumStrings);
  62         for (n = 0; n < outNameList->NumStrings; ++n)
  63         {
  64                 secdebug("dbsession", "%d: %s", n, outNameList->String[n]);
  65         }
  66 #endif
  67
  68         secdebug("dbsession", "********************");
  69 }
  70
  71
  72 void
  73 DatabaseSession::FreeNameList(CSSM_NAME_LIST &inNameList)
  74 {
  75         secdebug("dbsession", "FreeNameList");
  76         mDatabaseManager.freeNameList (*this, inNameList);
  77         secdebug("dbsession", "********************");
  78 }
  79
  80
  81 void
  82 DatabaseSession::DbDelete(const char *inDbName,
  83                           const CSSM_NET_ADDRESS *inDbLocation,
  84                           const AccessCredentials *inAccessCred)
  85 {
  86     // The databaseManager will notify all its DbContext instances
  87     // that the database is question is being deleted.
  88         secdebug("dbsession", "DbDelete of %s", inDbName);
  89     mDatabaseManager.dbDelete(*this, DbName(inDbName, CssmNetAddress::optional(inDbLocation)), inAccessCred);
  90         secdebug("dbsession", "********************");
  91 }
  92
  93 // DbContext creation and destruction.
  94 void
  95 DatabaseSession::DbCreate(const char *inDbName,
  96                           const CSSM_NET_ADDRESS *inDbLocation,
  97                           const CSSM_DBINFO &inDBInfo,
  98                           CSSM_DB_ACCESS_TYPE inAccessRequest,
  99                           const CSSM_RESOURCE_CONTROL_CONTEXT *inCredAndAclEntry,
 100                           const void *inOpenParameters,
 101                           CSSM_DB_HANDLE &outDbHandle)
 102 {
 103         outDbHandle = CSSM_INVALID_HANDLE;      // CDSA 2.0 says to set this if we fail
 104         secdebug("dbsession", "DbCreate of %s", inDbName);
 105
 106     outDbHandle = insertDbContext(mDatabaseManager.dbCreate(*this,
 107                                                             DbName(inDbName, CssmNetAddress::optional(inDbLocation)),
 108                                                             inDBInfo,
 109                                                             inAccessRequest,
 110                                                             inCredAndAclEntry,
 111                                                             inOpenParameters));
 112         secdebug("dbsession", "DbCreate returned handle %#lx", outDbHandle);
 113
 114         secdebug("dbsession", "********************");
 115 }
 116
 117 void
 118 DatabaseSession::DbOpen(const char *inDbName,
 119                         const CSSM_NET_ADDRESS *inDbLocation,
 120                         CSSM_DB_ACCESS_TYPE inAccessRequest,
 121                         const AccessCredentials *inAccessCred,
 122                         const void *inOpenParameters,
 123                         CSSM_DB_HANDLE &outDbHandle)
 124 {
 125         DOCDebug("DatabaseSession::DbOpen: dbName %s", inDbName);
 126         secdebug("dbsession", "DbOpen of %s", inDbName);
 127         outDbHandle = CSSM_INVALID_HANDLE;      // CDSA 2.0 says to set this if we fail
 128     outDbHandle = insertDbContext(mDatabaseManager.dbOpen(*this,
 129                                                           DbName(inDbName, CssmNetAddress::optional(inDbLocation)),
 130                                                           inAccessRequest,
 131                                                           inAccessCred,
 132                                                           inOpenParameters));
 133         secdebug("dbsession", "DbOpen returned handle %#lx", outDbHandle);
 134         secdebug("dbsession", "********************");
 135 }
 136
 137 CSSM_DB_HANDLE
 138 DatabaseSession::insertDbContext(DbContext &inDbContext)
 139 {
 140     CSSM_DB_HANDLE aDbHandle;
 141     try
 142     {
 143         aDbHandle = inDbContext.handle ();
 144         StLock<Mutex> _(mDbContextMapLock);
 145         mDbContextMap.insert(DbContextMap::value_type(aDbHandle, &inDbContext));
 146     }
 147     catch (...)
 148     {
 149         // Close the context
 150         mDatabaseManager.dbClose(inDbContext);
 151         throw;
 152     }
 153
 154     return aDbHandle;
 155 }
 156
 157 DbContext &
 158 DatabaseSession::findDbContext(CSSM_DB_HANDLE inDbHandle)
 159 {
 160     StLock<Mutex> _(mDbContextMapLock);
 161     DbContextMap::iterator it = mDbContextMap.find(inDbHandle);
 162     if (it == mDbContextMap.end())
 163         CssmError::throwMe(CSSM_ERRCODE_INVALID_DB_HANDLE);
 164     return *it->second;
 165 }
 166
 167 void
 168 DatabaseSession::closeAll()
 169 {
 170     StLock<Mutex> _(mDbContextMapLock);
 171     for (DbContextMap::iterator it = mDbContextMap.begin();
 172          it != mDbContextMap.end();
 173          it++)
 174     {
 175         DbContext *aDbContext = it->second;
 176         try
 177         {
 178             mDatabaseManager.dbClose(*aDbContext);
 179             // This is done by the database itself which owns the context.
 180             //delete aDbContext;
 181         }
 182         catch (...)
 183         {
 184             // Ignore exceptions since we want to close as many DBs as possible.
 185             // XXX @@@ log an error or something.
 186         }
 187     }
 188
 189     mDbContextMap.clear();
 190         secdebug("dbsession", "********************");
 191 }
 192
 193 // Operations using DbContext instances.
 194 void
 195 DatabaseSession::DbClose(CSSM_DB_HANDLE inDbHandle)
 196 {
 197     StLock<Mutex> _(mDbContextMapLock);
 198         DOCDebug("DatabaseSession::Close");
 199         secdebug("dbsession", "DbClose of handle %ld", inDbHandle);
 200     DbContextMap::iterator it = mDbContextMap.find(inDbHandle);
 201     if (it == mDbContextMap.end())
 202         CssmError::throwMe(CSSM_ERRCODE_INVALID_DB_HANDLE);
 203     auto_ptr<DbContext> aDbContext(it->second);
 204     mDbContextMap.erase(it);
 205     mDatabaseManager.dbClose(*aDbContext);
 206         secdebug("dbsession", "********************");
 207 }
 208
 209 void
 210 DatabaseSession::CreateRelation(CSSM_DB_HANDLE inDbHandle,
 211                                 CSSM_DB_RECORDTYPE inRelationID,
 212                                 const char *inRelationName,
 213                                 uint32 inNumberOfAttributes,
 214                                 const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *inAttributeInfo,
 215                                 uint32 inNumberOfIndexes,
 216                                 const CSSM_DB_SCHEMA_INDEX_INFO &inIndexInfo)
 217 {
 218         secdebug("dbsession", "CreateRelation from handle %ld of record type %X with relation name %s", inDbHandle, inRelationID, inRelationName);
 219         secdebug("dbsession", "number of attributes = %d", inNumberOfAttributes);
 220 #ifndef NDEBUG
 221         unsigned n;
 222         for (n = 0; n < inNumberOfAttributes; ++n)
 223         {
 224                 secdebug("dbsession", "%d: id %d name %s, data type %d", n, inAttributeInfo[n].AttributeId,
 225                                                                                                                                         inAttributeInfo[n].AttributeName,
 226                                                                                                                                         inAttributeInfo[n].DataType);
 227         }
 228 #endif
 229
 230         secdebug("dbsession", "number of indexes: %d", inNumberOfIndexes);
 231 #ifndef NDEBUG
 232         for (n = 0; n < inNumberOfIndexes; ++n)
 233         {
 234                 secdebug("dbsession", "%d: id %d indexid %d indextype %d location %d", n, inIndexInfo.AttributeId,
 235                                                                                                                                                                   inIndexInfo.IndexedDataLocation,
 236                                                                                                                                                                   inIndexInfo.IndexId,
 237                                                                                                                                                                   inIndexInfo.IndexType);
 238         }
 239 #endif
 240
 241     DbContext &aDbContext = findDbContext(inDbHandle);
 242     return aDbContext.mDatabase.createRelation(aDbContext, inRelationID, inRelationName,
 243                                                 inNumberOfAttributes, inAttributeInfo,
 244                                                 inNumberOfIndexes, inIndexInfo);
 245         secdebug("dbsession", "********************");
 246 }
 247
 248 void
 249 DatabaseSession::DestroyRelation(CSSM_DB_HANDLE inDbHandle,
 250                                  CSSM_DB_RECORDTYPE inRelationID)
 251 {
 252         secdebug("dbsession", "DestroyRelation (handle %ld) %d", inDbHandle, inRelationID);
 253     DbContext &aDbContext = findDbContext(inDbHandle);
 254     aDbContext.mDatabase.destroyRelation(aDbContext, inRelationID);
 255         secdebug("dbsession", "********************");
 256 }
 257
 258 void
 259 DatabaseSession::Authenticate(CSSM_DB_HANDLE inDbHandle,
 260                               CSSM_DB_ACCESS_TYPE inAccessRequest,
 261                               const AccessCredentials &inAccessCred)
 262 {
 263         secdebug("dbsession", "Authenticate (handle %ld) inAccessRequest %d", inDbHandle, inAccessRequest);
 264     DbContext &aDbContext = findDbContext(inDbHandle);
 265     aDbContext.mDatabase.authenticate(aDbContext, inAccessRequest, inAccessCred);
 266         secdebug("dbsession", "********************");
 267 }
 268
 269
 270 void
 271 DatabaseSession::GetDbAcl(CSSM_DB_HANDLE inDbHandle,
 272                           const CSSM_STRING *inSelectionTag,
 273                           uint32 &outNumberOfAclInfos,
 274                           CSSM_ACL_ENTRY_INFO_PTR &outAclInfos)
 275 {
 276         secdebug("dbsession", "GetDbAcl (handle %ld)", inDbHandle);
 277     DbContext &aDbContext = findDbContext(inDbHandle);
 278     aDbContext.mDatabase.getDbAcl(aDbContext, inSelectionTag, outNumberOfAclInfos, outAclInfos);
 279         secdebug("dbsession", "********************");
 280 }
 281
 282 void
 283 DatabaseSession::ChangeDbAcl(CSSM_DB_HANDLE inDbHandle,
 284                              const AccessCredentials &inAccessCred,
 285                              const CSSM_ACL_EDIT &inAclEdit)
 286 {
 287         secdebug("dbsession", "ChangeDbAcl (handle %ld)", inDbHandle);
 288     DbContext &aDbContext = findDbContext(inDbHandle);
 289     aDbContext.mDatabase.changeDbAcl(aDbContext, inAccessCred, inAclEdit);
 290         secdebug("dbsession", "********************");
 291 }
 292
 293 void
 294 DatabaseSession::GetDbOwner(CSSM_DB_HANDLE inDbHandle,
 295                             CSSM_ACL_OWNER_PROTOTYPE &outOwner)
 296 {
 297         secdebug("dbsession", "GetDbOwner (handle %ld)", inDbHandle);
 298     DbContext &aDbContext = findDbContext(inDbHandle);
 299     aDbContext.mDatabase.getDbOwner(aDbContext, outOwner);
 300         secdebug("dbsession", "********************");
 301 }
 302
 303 void
 304 DatabaseSession::ChangeDbOwner(CSSM_DB_HANDLE inDbHandle,
 305                                const AccessCredentials &inAccessCred,
 306                                const CSSM_ACL_OWNER_PROTOTYPE &inNewOwner)
 307 {
 308         secdebug("dbsession", "ChangeDbOwner (handle %ld)", inDbHandle);
 309     DbContext &aDbContext = findDbContext(inDbHandle);
 310     aDbContext.mDatabase.changeDbOwner(aDbContext, inAccessCred, inNewOwner);
 311         secdebug("dbsession", "********************");
 312 }
 313
 314 void
 315 DatabaseSession::GetDbNameFromHandle(CSSM_DB_HANDLE inDbHandle,
 316                                      char **outDbName)
 317 {
 318         secdebug("dbsession", "GetDbNameFromHandle (handle %ld)", inDbHandle);
 319     DbContext &aDbContext = findDbContext(inDbHandle);
 320     Required(outDbName) = aDbContext.mDatabase.getDbNameFromHandle(aDbContext);
 321         secdebug("dbsession", "name: %s", *outDbName);
 322         secdebug("dbsession", "********************");
 323 }
 324
 325 #ifndef NDEBUG
 326 void DumpAttributeInfo(const CSSM_DB_ATTRIBUTE_INFO &info)
 327 {
 328         const char* attrNameType;
 329         switch (info.AttributeFormat)
 330         {
 331                 case CSSM_DB_ATTRIBUTE_NAME_AS_STRING:
 332                         attrNameType = "CSSM_DB_ATTRIBUTE_NAME_AS_STRING";
 333                         break;
 334
 335                 case CSSM_DB_ATTRIBUTE_NAME_AS_OID:
 336                         attrNameType = "CSSM_DB_ATTRIBUTE_NAME_AS_OID";
 337                         break;
 338
 339                 case CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER:
 340                         attrNameType = "CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER";
 341                         break;
 342         }
 343
 344         secdebug("dbsession", "  Attribute name type: %s", attrNameType);
 345         switch (info.AttributeFormat)
 346         {
 347                 case CSSM_DB_ATTRIBUTE_NAME_AS_STRING:
 348                         secdebug("dbsession", "  name: %s", info.Label.AttributeName);
 349                         break;
 350
 351                 case CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER:
 352                         secdebug("dbsession", "  name: %d", info.Label.AttributeID);
 353                         break;
 354
 355                 case CSSM_DB_ATTRIBUTE_NAME_AS_OID:
 356                         secdebug("dbsession", "  name is oid");
 357                         break;
 358         }
 359
 360         const char* s;
 361         switch (info.AttributeFormat)
 362         {
 363                 case CSSM_DB_ATTRIBUTE_FORMAT_STRING:
 364                         s = "CSSM_DB_ATTRIBUTE_FORMAT_STRING";
 365                         break;
 366                 case CSSM_DB_ATTRIBUTE_FORMAT_SINT32:
 367                         s = "CSSM_DB_ATTRIBUTE_FORMAT_SINT32";
 368                         break;
 369                 case CSSM_DB_ATTRIBUTE_FORMAT_UINT32:
 370                         s = "CSSM_DB_ATTRIBUTE_FORMAT_UINT32";
 371                         break;
 372                 case CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM:
 373                         s = "CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM";
 374                         break;
 375                 case CSSM_DB_ATTRIBUTE_FORMAT_REAL:
 376                         s = "CSSM_DB_ATTRIBUTE_FORMAT_REAL";
 377                         break;
 378                 case CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE:
 379                         s = "CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE";
 380                         break;
 381                 case CSSM_DB_ATTRIBUTE_FORMAT_BLOB:
 382                         s = "CSSM_DB_ATTRIBUTE_FORMAT_BLOB";
 383                         break;
 384                 case CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32:
 385                         s = "CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32";
 386                         break;
 387                 case CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX:
 388                         s = "CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX";
 389                         break;
 390         }
 391
 392         secdebug("dbsession", "  attribute format: %s", s);
 393 }
 394
 395
 396
 397 void DumpAttributes(const CSSM_DB_RECORD_ATTRIBUTE_DATA *inAttributes)
 398 {
 399         if (!inAttributes)
 400         {
 401                 secdebug("dbsession", "No attributes defined.");
 402                 return;
 403         }
 404
 405         secdebug("dbsession", "insert into %d", inAttributes->DataRecordType);
 406         secdebug("dbsession", "Semantic information %d", inAttributes->SemanticInformation);
 407         secdebug("dbsession", "Number of attributes: %d", inAttributes->NumberOfAttributes);
 408
 409         unsigned n;
 410         for (n = 0; n < inAttributes->NumberOfAttributes; ++n)
 411         {
 412                 DumpAttributeInfo(inAttributes->AttributeData[n].Info);
 413                 secdebug("dbsession", "Attribute %d\n", n);
 414                 secdebug("dbsession", "  number of values: %d", inAttributes->AttributeData[n].NumberOfValues);
 415                 unsigned i;
 416                 for (i = 0; i < inAttributes->AttributeData[n].NumberOfValues; ++i)
 417                 {
 418                         switch (inAttributes->AttributeData[n].Info.AttributeFormat)
 419                         {
 420                                 case CSSM_DB_ATTRIBUTE_FORMAT_STRING:
 421                                 {
 422                                         std::string ss((char*) inAttributes->AttributeData[n].Value[i].Data, inAttributes->AttributeData[n].Value[i].Length);
 423                                         secdebug("dbsession", "    Value %d: %s", i, ss.c_str());
 424                                         break;
 425                                 }
 426                                 case CSSM_DB_ATTRIBUTE_FORMAT_SINT32:
 427                                         secdebug("dbsession", "    Value %d: %d", i, *(sint32*)inAttributes->AttributeData[n].Value[i].Data);
 428                                         break;
 429                                 case CSSM_DB_ATTRIBUTE_FORMAT_UINT32:
 430                                         secdebug("dbsession", "    Value %d: %u", i, *(uint32*)inAttributes->AttributeData[n].Value[i].Data);
 431                                         break;
 432                                 case CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM:
 433                                         secdebug("dbsession", "    Value %d: (bignum)", i);
 434                                         break;
 435                                 case CSSM_DB_ATTRIBUTE_FORMAT_REAL:
 436                                         secdebug("dbsession", "    Value %d: %f", i, *(double*)inAttributes->AttributeData[n].Value[i].Data);
 437                                         break;
 438                                 case CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE:
 439                                         secdebug("dbsession", "    Value %d: %s", i, (char*)inAttributes->AttributeData[n].Value[i].Data);
 440                                         break;
 441                                 case CSSM_DB_ATTRIBUTE_FORMAT_BLOB:
 442                                         secdebug("dbsession", "    Value %d: (blob)", i);
 443                                         break;
 444                                 case CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32:
 445                                 {
 446                                         unsigned j;
 447                                         unsigned numInts = inAttributes->AttributeData[n].Value[i].Length / sizeof(UInt32);
 448                                         for (j = 0; j < numInts; ++j)
 449                                         {
 450                                                 uint32* nums = (uint32*) inAttributes->AttributeData[n].Value[i].Data;
 451                                                 secdebug("dbsession", "      %d", nums[j]);
 452                                         }
 453
 454                                         break;
 455                                 }
 456
 457                                 case CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX:
 458                                         secdebug("dbsession", "    Value %d: (complex)", i);
 459                                         break;
 460                         }
 461                 }
 462         }
 463 }
 464
 465
 466
 467 void
 468 DumpUniqueRecord(const CSSM_DB_UNIQUE_RECORD &record)
 469 {
 470         const char* s;
 471
 472 /*
 473         switch (record.RecordLocator.IndexType)
 474         {
 475                 case CSSM_DB_INDEX_UNIQUE:
 476                 {
 477                         s = "CSSM_DB_INDEX_UNIQUE";
 478                         break;
 479                 }
 480
 481                 case CSSM_DB_INDEX_NONUNIQUE:
 482                 {
 483                         s = "CSSM_DB_INDEX_NONUNIQUE";
 484                         break;
 485                 }
 486         }
 487
 488         secdebug("dbsession", "RecordLocator.IndexType: %s", s);
 489
 490         switch (record.RecordLocator.IndexedDataLocation)
 491         {
 492                 case CSSM_DB_INDEX_ON_UNKNOWN:
 493                 {
 494                         s = "CSSM_DB_INDEX_ON_UNKNOWN";
 495                         break;
 496                 }
 497
 498                 case CSSM_DB_INDEX_ON_ATTRIBUTE:
 499                 {
 500                         s = "CSSM_DB_INDEX_ON_ATTRIBUTE";
 501                         break;
 502                 }
 503
 504                 case CSSM_DB_INDEX_ON_RECORD:
 505                 {
 506                         s = "CSSM_DB_INDEX_ON_RECORD";
 507                         break;
 508                 }
 509         }
 510
 511         secdebug("dbsession", "RecordLocator.IndexedDataLocation: %s", s);
 512
 513         secdebug("dbsession", "Attribute info:");
 514
 515         DumpAttributeInfo(record.RecordLocator.Info);
 516 */
 517
 518         // put the record ID into hex
 519         std::string output;
 520         char hexBuffer[4];
 521         unsigned i;
 522         for (i = 0; i < record.RecordIdentifier.Length; ++i)
 523         {
 524                 sprintf(hexBuffer, "%02X", record.RecordIdentifier.Data[i]);
 525                 output += hexBuffer;
 526         }
 527
 528         secdebug("dbsession", "    RecordIdentifier.Data: %s", output.c_str());
 529 }
 530 #endif
 531
 532 void
 533 DatabaseSession::DataInsert(CSSM_DB_HANDLE inDbHandle,
 534                             CSSM_DB_RECORDTYPE inRecordType,
 535                             const CSSM_DB_RECORD_ATTRIBUTE_DATA *inAttributes,
 536                             const CssmData *inData,
 537                             CSSM_DB_UNIQUE_RECORD_PTR &outUniqueId)
 538 {
 539         secdebug("dbsession", "%p DataInsert(%lx,%x)", this, inDbHandle, inRecordType);
 540     DbContext &aDbContext = findDbContext(inDbHandle);
 541     outUniqueId = aDbContext.mDatabase.dataInsert(aDbContext, inRecordType, inAttributes, inData);
 542
 543 #ifndef NDEBUG
 544         secdebug("dbsession", "Returned unique id:");
 545         DumpUniqueRecord(*outUniqueId);
 546 #endif
 547
 548         secdebug("dbsession", "********************");
 549 }
 550
 551
 552 void
 553 DatabaseSession::DataDelete(CSSM_DB_HANDLE inDbHandle,
 554                             const CSSM_DB_UNIQUE_RECORD &inUniqueRecordIdentifier)
 555 {
 556         secdebug("dbsession", "%p DataDelete(%lx)", this, inDbHandle);
 557     DbContext &aDbContext = findDbContext(inDbHandle);
 558     aDbContext.mDatabase.dataDelete(aDbContext, inUniqueRecordIdentifier);
 559
 560 #ifndef NDEBUG
 561         secdebug("dbsession", "Record identifier:");
 562         DumpUniqueRecord(inUniqueRecordIdentifier);
 563 #endif
 564         secdebug("dbsession", "********************");
 565 }
 566
 567
 568 void
 569 DatabaseSession::DataModify(CSSM_DB_HANDLE inDbHandle,
 570                             CSSM_DB_RECORDTYPE inRecordType,
 571                             CSSM_DB_UNIQUE_RECORD &inoutUniqueRecordIdentifier,
 572                             const CSSM_DB_RECORD_ATTRIBUTE_DATA *inAttributesToBeModified,
 573                             const CssmData *inDataToBeModified,
 574                             CSSM_DB_MODIFY_MODE inModifyMode)
 575 {
 576         secdebug("dbsession", "%p DataModify(%lx,%x)", this, inDbHandle, inRecordType);
 577     DbContext &aDbContext = findDbContext(inDbHandle);
 578     aDbContext.mDatabase.dataModify(aDbContext, inRecordType, inoutUniqueRecordIdentifier,
 579                                      inAttributesToBeModified, inDataToBeModified, inModifyMode);
 580 #ifndef NDEBUG
 581         secdebug("dbsession", "Out record identifier:");
 582         DumpUniqueRecord(inoutUniqueRecordIdentifier);
 583 #endif
 584         secdebug("dbsession", "********************");
 585 }
 586
 587 CSSM_HANDLE
 588 DatabaseSession::DataGetFirst(CSSM_DB_HANDLE inDbHandle,
 589                               const CssmQuery *inQuery,
 590                               CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
 591                               CssmData *inoutData,
 592                               CSSM_DB_UNIQUE_RECORD_PTR &outUniqueId)
 593 {
 594         secdebug("dbsession", "%p DataGetFirst(%lx)", this, inDbHandle);
 595     DbContext &aDbContext = findDbContext(inDbHandle);
 596
 597         CSSM_HANDLE result = aDbContext.mDatabase.dataGetFirst(aDbContext, inQuery,
 598                                                                                                                    inoutAttributes, inoutData, outUniqueId);
 599 #ifndef NDEBUG
 600         secdebug("dbsession", "result handle: %lx", result);
 601         if (result != 0)
 602         {
 603                 secdebug("dbsession", "Returned ID:");
 604                 DumpUniqueRecord(*outUniqueId);
 605         }
 606 #endif
 607
 608         secdebug("dbsession", "********************");
 609         return result;
 610 }
 611
 612 bool
 613 DatabaseSession::DataGetNext(CSSM_DB_HANDLE inDbHandle,
 614                              CSSM_HANDLE inResultsHandle,
 615                              CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
 616                              CssmData *inoutData,
 617                              CSSM_DB_UNIQUE_RECORD_PTR &outUniqueRecord)
 618 {
 619         secdebug("dbsession", "DataGetNext(%lx)", inDbHandle);
 620     DbContext &aDbContext = findDbContext(inDbHandle);
 621
 622         bool result = aDbContext.mDatabase.dataGetNext(aDbContext, inResultsHandle, inoutAttributes,
 623                         inoutData, outUniqueRecord);
 624
 625 #ifndef NDEBUG
 626         if (result)
 627         {
 628                 secdebug("dbsession", "Returned ID:");
 629                 DumpUniqueRecord(*outUniqueRecord);
 630         }
 631 #endif
 632
 633         secdebug("dbsession", "********************");
 634         return result;
 635 }
 636
 637 void
 638 DatabaseSession::DataAbortQuery(CSSM_DB_HANDLE inDbHandle,
 639                                 CSSM_HANDLE inResultsHandle)
 640 {
 641         secdebug("dbsession", "%p DataAbortQuery(%lx)", this, inDbHandle);
 642     DbContext &aDbContext = findDbContext(inDbHandle);
 643     aDbContext.mDatabase.dataAbortQuery(aDbContext, inResultsHandle);
 644         secdebug("dbsession", "********************");
 645 }
 646
 647 void
 648 DatabaseSession::DataGetFromUniqueRecordId(CSSM_DB_HANDLE inDbHandle,
 649                                            const CSSM_DB_UNIQUE_RECORD &inUniqueRecord,
 650                                            CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
 651                                            CssmData *inoutData)
 652 {
 653         secdebug("dbsession", "%p DataGetFromUniqueId(%lx)", this, inDbHandle);
 654 #ifndef NDEBUG
 655         secdebug("dbsession", "inUniqueRecord:");
 656         DumpUniqueRecord(inUniqueRecord);
 657 #endif
 658
 659     DbContext &aDbContext = findDbContext(inDbHandle);
 660     aDbContext.mDatabase.dataGetFromUniqueRecordId(aDbContext, inUniqueRecord,
 661                                                    inoutAttributes, inoutData);
 662         secdebug("dbsession", "********************");
 663 }
 664
 665 void
 666 DatabaseSession::FreeUniqueRecord(CSSM_DB_HANDLE inDbHandle,
 667                                   CSSM_DB_UNIQUE_RECORD &inUniqueRecordIdentifier)
 668 {
 669         secdebug("dbsession", "FreeUniqueRecord: %lx", inDbHandle);
 670 #ifndef NDEBUG
 671         secdebug("dbsession", "inUniqueRecordIdentifier follows:");
 672         DumpUniqueRecord(inUniqueRecordIdentifier);
 673 #endif
 674     DbContext &aDbContext = findDbContext(inDbHandle);
 675     aDbContext.mDatabase.freeUniqueRecord(aDbContext, inUniqueRecordIdentifier);
 676         secdebug("dbsession", "********************");
 677 }
 678
 679 void
 680 DatabaseSession::PassThrough(CSSM_DB_HANDLE inDbHandle,
 681                              uint32 passThroughId,
 682                              const void *inputParams,
 683                              void **outputParams)
 684 {
 685         DbContext &aDbContext = findDbContext(inDbHandle);
 686         aDbContext.mDatabase.passThrough(aDbContext, passThroughId, inputParams, outputParams);
 687 }