cdsa/cdsa_utilities/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 #ifdef __MWERKS__
  23 #define _CPP_DATABASESESSION
  24 #endif
  25 #include <Security/DatabaseSession.h>
  26
  27 #include <Security/Database.h>
  28 #include <Security/DbContext.h>
  29 #include <memory>
  30
  31 using namespace std;
  32
  33 //
  34 // Session constructor
  35 //
  36 DatabaseSession::DatabaseSession(DatabaseManager &inDatabaseManager)
  37 : mDatabaseManager(inDatabaseManager)
  38 {
  39 }
  40
  41 DatabaseSession::~DatabaseSession()
  42 {
  43 }
  44
  45
  46 // Utility functions
  47 void
  48 DatabaseSession::GetDbNames(CSSM_NAME_LIST_PTR &outNameList)
  49 {
  50         outNameList = mDatabaseManager.getDbNames (*this);
  51 }
  52
  53
  54 void
  55 DatabaseSession::FreeNameList(CSSM_NAME_LIST &inNameList)
  56 {
  57         mDatabaseManager.freeNameList (*this, inNameList);
  58 }
  59
  60
  61 void
  62 DatabaseSession::DbDelete(const char *inDbName,
  63                           const CSSM_NET_ADDRESS *inDbLocation,
  64                           const AccessCredentials *inAccessCred)
  65 {
  66     // The databaseManager will notify all its DbContext instances
  67     // that the database is question is being deleted.
  68     mDatabaseManager.dbDelete(*this, DbName(inDbName, CssmNetAddress::optional(inDbLocation)), inAccessCred);
  69 }
  70
  71 // DbContext creation and destruction.
  72 void
  73 DatabaseSession::DbCreate(const char *inDbName,
  74                           const CSSM_NET_ADDRESS *inDbLocation,
  75                           const CSSM_DBINFO &inDBInfo,
  76                           CSSM_DB_ACCESS_TYPE inAccessRequest,
  77                           const CSSM_RESOURCE_CONTROL_CONTEXT *inCredAndAclEntry,
  78                           const void *inOpenParameters,
  79                           CSSM_DB_HANDLE &outDbHandle)
  80 {
  81         outDbHandle = CSSM_INVALID_HANDLE;      // CDSA 2.0 says to set this if we fail
  82     outDbHandle = insertDbContext(mDatabaseManager.dbCreate(*this,
  83                                                             DbName(inDbName, CssmNetAddress::optional(inDbLocation)),
  84                                                             inDBInfo,
  85                                                             inAccessRequest,
  86                                                             inCredAndAclEntry,
  87                                                             inOpenParameters));
  88
  89 }
  90
  91 void
  92 DatabaseSession::DbOpen(const char *inDbName,
  93                         const CSSM_NET_ADDRESS *inDbLocation,
  94                         CSSM_DB_ACCESS_TYPE inAccessRequest,
  95                         const AccessCredentials *inAccessCred,
  96                         const void *inOpenParameters,
  97                         CSSM_DB_HANDLE &outDbHandle)
  98 {
  99         outDbHandle = CSSM_INVALID_HANDLE;      // CDSA 2.0 says to set this if we fail
 100     outDbHandle = insertDbContext(mDatabaseManager.dbOpen(*this,
 101                                                           DbName(inDbName, CssmNetAddress::optional(inDbLocation)),
 102                                                           inAccessRequest,
 103                                                           inAccessCred,
 104                                                           inOpenParameters));
 105 }
 106
 107 CSSM_DB_HANDLE
 108 DatabaseSession::insertDbContext(DbContext &inDbContext)
 109 {
 110     CSSM_DB_HANDLE aDbHandle;
 111     try
 112     {
 113         aDbHandle = inDbContext.handle ();
 114         StLock<Mutex> _(mDbContextMapLock);
 115         mDbContextMap.insert(DbContextMap::value_type(aDbHandle, &inDbContext));
 116     }
 117     catch (...)
 118     {
 119         // Close the context
 120         mDatabaseManager.dbClose(inDbContext);
 121         throw;
 122     }
 123
 124     return aDbHandle;
 125 }
 126
 127 DbContext &
 128 DatabaseSession::findDbContext(CSSM_DB_HANDLE inDbHandle)
 129 {
 130     StLock<Mutex> _(mDbContextMapLock);
 131     DbContextMap::iterator it = mDbContextMap.find(inDbHandle);
 132     if (it == mDbContextMap.end())
 133         CssmError::throwMe(CSSM_ERRCODE_INVALID_DB_HANDLE);
 134     return *it->second;
 135 }
 136
 137 void
 138 DatabaseSession::closeAll()
 139 {
 140     StLock<Mutex> _(mDbContextMapLock);
 141     for (DbContextMap::iterator it = mDbContextMap.begin();
 142          it != mDbContextMap.end();
 143          it++)
 144     {
 145         DbContext *aDbContext = it->second;
 146         try
 147         {
 148             mDatabaseManager.dbClose(*aDbContext);
 149             // This is done by the database itself which owns the context.
 150             //delete aDbContext;
 151         }
 152         catch (...)
 153         {
 154             // Ignore exceptions since we want to close as many DBs as possible.
 155             // XXX @@@ log an error or something.
 156         }
 157     }
 158
 159     mDbContextMap.clear();
 160 }
 161
 162 // Operations using DbContext instances.
 163 void
 164 DatabaseSession::DbClose(CSSM_DB_HANDLE inDbHandle)
 165 {
 166     StLock<Mutex> _(mDbContextMapLock);
 167     DbContextMap::iterator it = mDbContextMap.find(inDbHandle);
 168     if (it == mDbContextMap.end())
 169         CssmError::throwMe(CSSM_ERRCODE_INVALID_DB_HANDLE);
 170     auto_ptr<DbContext> aDbContext(it->second);
 171     mDbContextMap.erase(it);
 172     mDatabaseManager.dbClose(*aDbContext);
 173 }
 174
 175 void
 176 DatabaseSession::CreateRelation(CSSM_DB_HANDLE inDbHandle,
 177                                 CSSM_DB_RECORDTYPE inRelationID,
 178                                 const char *inRelationName,
 179                                 uint32 inNumberOfAttributes,
 180                                 const CSSM_DB_SCHEMA_ATTRIBUTE_INFO &inAttributeInfo,
 181                                 uint32 inNumberOfIndexes,
 182                                 const CSSM_DB_SCHEMA_INDEX_INFO &inIndexInfo)
 183 {
 184     DbContext &aDbContext = findDbContext(inDbHandle);
 185     return aDbContext.mDatabase.createRelation(aDbContext, inRelationID, inRelationName,
 186                                                 inNumberOfAttributes, inAttributeInfo,
 187                                                 inNumberOfIndexes, inIndexInfo);
 188 }
 189
 190 void
 191 DatabaseSession::DestroyRelation(CSSM_DB_HANDLE inDbHandle,
 192                                  CSSM_DB_RECORDTYPE inRelationID)
 193 {
 194     DbContext &aDbContext = findDbContext(inDbHandle);
 195     return aDbContext.mDatabase.destroyRelation(aDbContext, inRelationID);
 196 }
 197
 198 void
 199 DatabaseSession::Authenticate(CSSM_DB_HANDLE inDbHandle,
 200                               CSSM_DB_ACCESS_TYPE inAccessRequest,
 201                               const AccessCredentials &inAccessCred)
 202 {
 203     DbContext &aDbContext = findDbContext(inDbHandle);
 204     aDbContext.mDatabase.authenticate(aDbContext, inAccessRequest, inAccessCred);
 205 }
 206
 207
 208 void
 209 DatabaseSession::GetDbAcl(CSSM_DB_HANDLE inDbHandle,
 210                           const CSSM_STRING *inSelectionTag,
 211                           uint32 &outNumberOfAclInfos,
 212                           CSSM_ACL_ENTRY_INFO_PTR &outAclInfos)
 213 {
 214     DbContext &aDbContext = findDbContext(inDbHandle);
 215     aDbContext.mDatabase.getDbAcl(aDbContext, inSelectionTag, outNumberOfAclInfos, outAclInfos);
 216 }
 217
 218 void
 219 DatabaseSession::ChangeDbAcl(CSSM_DB_HANDLE inDbHandle,
 220                              const AccessCredentials &inAccessCred,
 221                              const CSSM_ACL_EDIT &inAclEdit)
 222 {
 223     DbContext &aDbContext = findDbContext(inDbHandle);
 224     aDbContext.mDatabase.changeDbAcl(aDbContext, inAccessCred, inAclEdit);
 225 }
 226
 227 void
 228 DatabaseSession::GetDbOwner(CSSM_DB_HANDLE inDbHandle,
 229                             CSSM_ACL_OWNER_PROTOTYPE &outOwner)
 230 {
 231     DbContext &aDbContext = findDbContext(inDbHandle);
 232     aDbContext.mDatabase.getDbOwner(aDbContext, outOwner);
 233 }
 234
 235 void
 236 DatabaseSession::ChangeDbOwner(CSSM_DB_HANDLE inDbHandle,
 237                                const AccessCredentials &inAccessCred,
 238                                const CSSM_ACL_OWNER_PROTOTYPE &inNewOwner)
 239 {
 240     DbContext &aDbContext = findDbContext(inDbHandle);
 241     aDbContext.mDatabase.changeDbOwner(aDbContext, inAccessCred, inNewOwner);
 242 }
 243
 244 void
 245 DatabaseSession::GetDbNameFromHandle(CSSM_DB_HANDLE inDbHandle,
 246                                      char **outDbName)
 247 {
 248     DbContext &aDbContext = findDbContext(inDbHandle);
 249     Required(outDbName) = aDbContext.mDatabase.getDbNameFromHandle(aDbContext);
 250 }
 251
 252 void
 253 DatabaseSession::DataInsert(CSSM_DB_HANDLE inDbHandle,
 254                             CSSM_DB_RECORDTYPE inRecordType,
 255                             const CSSM_DB_RECORD_ATTRIBUTE_DATA *inAttributes,
 256                             const CssmData *inData,
 257                             CSSM_DB_UNIQUE_RECORD_PTR &outUniqueId)
 258 {
 259     DbContext &aDbContext = findDbContext(inDbHandle);
 260     outUniqueId = aDbContext.mDatabase.dataInsert(aDbContext, inRecordType, inAttributes, inData);
 261 }
 262
 263
 264 void
 265 DatabaseSession::DataDelete(CSSM_DB_HANDLE inDbHandle,
 266                             const CSSM_DB_UNIQUE_RECORD &inUniqueRecordIdentifier)
 267 {
 268     DbContext &aDbContext = findDbContext(inDbHandle);
 269     aDbContext.mDatabase.dataDelete(aDbContext, inUniqueRecordIdentifier);
 270 }
 271
 272
 273 void
 274 DatabaseSession::DataModify(CSSM_DB_HANDLE inDbHandle,
 275                             CSSM_DB_RECORDTYPE inRecordType,
 276                             CSSM_DB_UNIQUE_RECORD &inoutUniqueRecordIdentifier,
 277                             const CSSM_DB_RECORD_ATTRIBUTE_DATA *inAttributesToBeModified,
 278                             const CssmData *inDataToBeModified,
 279                             CSSM_DB_MODIFY_MODE inModifyMode)
 280 {
 281     DbContext &aDbContext = findDbContext(inDbHandle);
 282     aDbContext.mDatabase.dataModify(aDbContext, inRecordType, inoutUniqueRecordIdentifier,
 283                                      inAttributesToBeModified, inDataToBeModified, inModifyMode);
 284 }
 285
 286 CSSM_HANDLE
 287 DatabaseSession::DataGetFirst(CSSM_DB_HANDLE inDbHandle,
 288                               const DLQuery *inQuery,
 289                               CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
 290                               CssmData *inoutData,
 291                               CSSM_DB_UNIQUE_RECORD_PTR &outUniqueId)
 292 {
 293     DbContext &aDbContext = findDbContext(inDbHandle);
 294
 295         return aDbContext.mDatabase.dataGetFirst(aDbContext, inQuery,
 296                 inoutAttributes, inoutData, outUniqueId);
 297 }
 298
 299 bool
 300 DatabaseSession::DataGetNext(CSSM_DB_HANDLE inDbHandle,
 301                              CSSM_HANDLE inResultsHandle,
 302                              CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
 303                              CssmData *inoutData,
 304                              CSSM_DB_UNIQUE_RECORD_PTR &outUniqueRecord)
 305 {
 306     DbContext &aDbContext = findDbContext(inDbHandle);
 307
 308         return aDbContext.mDatabase.dataGetNext(aDbContext, inResultsHandle, inoutAttributes,
 309                         inoutData, outUniqueRecord);
 310 }
 311
 312 void
 313 DatabaseSession::DataAbortQuery(CSSM_DB_HANDLE inDbHandle,
 314                                 CSSM_HANDLE inResultsHandle)
 315 {
 316     DbContext &aDbContext = findDbContext(inDbHandle);
 317     aDbContext.mDatabase.dataAbortQuery(aDbContext, inResultsHandle);
 318 }
 319
 320 void
 321 DatabaseSession::DataGetFromUniqueRecordId(CSSM_DB_HANDLE inDbHandle,
 322                                            const CSSM_DB_UNIQUE_RECORD &inUniqueRecord,
 323                                            CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
 324                                            CssmData *inoutData)
 325 {
 326     DbContext &aDbContext = findDbContext(inDbHandle);
 327     aDbContext.mDatabase.dataGetFromUniqueRecordId(aDbContext, inUniqueRecord,
 328                                                    inoutAttributes, inoutData);
 329 }
 330
 331 void
 332 DatabaseSession::FreeUniqueRecord(CSSM_DB_HANDLE inDbHandle,
 333                                   CSSM_DB_UNIQUE_RECORD &inUniqueRecordIdentifier)
 334 {
 335     DbContext &aDbContext = findDbContext(inDbHandle);
 336     aDbContext.mDatabase.freeUniqueRecord(aDbContext, inUniqueRecordIdentifier);
 337 }
 338
 339 void
 340 DatabaseSession::PassThrough(CSSM_DB_HANDLE inDbHandle,
 341                              uint32 passThroughId,
 342                              const void *inputParams,
 343                              void **outputParams)
 344 {
 345         DbContext &aDbContext = findDbContext(inDbHandle);
 346         aDbContext.mDatabase.passThrough(aDbContext, passThroughId, inputParams, outputParams);
 347 }