Security-57740.1.18.tar.gz

[apple/security.git] / OSX / libsecurity_apple_cspdl / lib / SSDatabase.cpp

diff --git a/OSX/libsecurity_apple_cspdl/lib/SSDatabase.cpp b/OSX/libsecurity_apple_cspdl/lib/SSDatabase.cpp
index 755d232af87da4d44859a26a2f22d6846272a879..e4468f4d60c59cc63e57bacfe9cccf37339b490a 100644 (file)
--- a/OSX/libsecurity_apple_cspdl/lib/SSDatabase.cpp
+++ b/OSX/libsecurity_apple_cspdl/lib/SSDatabase.cpp
@@ -49,9 +49,9 @@ catch (...)
 }
 
 SSUniqueRecord
 }
 
 SSUniqueRecord

-SSDatabaseImpl::insert(CSSM_DB_RECORDTYPE recordType,
+SSDatabaseImpl::ssInsert(CSSM_DB_RECORDTYPE recordType,

                                           const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
                                           const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,

-                                          const CSSM_DATA *data, bool)
+                                          const CSSM_DATA *data)

 {
        SSUniqueRecord uniqueId(SSDatabase(this));
        check(CSSM_DL_DataInsert(handle(), recordType,
 {
        SSUniqueRecord uniqueId(SSDatabase(this));
        check(CSSM_DL_DataInsert(handle(), recordType,


@@ -238,7 +238,7 @@ SSDatabaseImpl::commonCreate(const DLDbIdentifier &dlDbIdentifier, bool &autoCom
 }
 
 void
 }
 
 void

-SSDatabaseImpl::create(const DLDbIdentifier &dlDbIdentifier)
+SSDatabaseImpl::ssCreate(const DLDbIdentifier &dlDbIdentifier)

 {
        try
        {
 {
        try
        {


@@ -260,7 +260,7 @@ SSDatabaseImpl::create(const DLDbIdentifier &dlDbIdentifier)
                mSSDbHandle = mClientSession.createDb(dlDbIdentifier, cred, owner, dbParameters);
                CssmDataContainer dbb(allocator());
                mClientSession.encodeDb(mSSDbHandle, dbb, allocator());
                mSSDbHandle = mClientSession.createDb(dlDbIdentifier, cred, owner, dbParameters);
                CssmDataContainer dbb(allocator());
                mClientSession.encodeDb(mSSDbHandle, dbb, allocator());

-        secdebugfunc("integrity", "opening %s", name());
+        secnotice("integrity", "opening %s", name());

                Db::Impl::insert(DBBlobRelationID, NULL, &dbb);
                if (autoCommit)
                {
                Db::Impl::insert(DBBlobRelationID, NULL, &dbb);
                if (autoCommit)
                {


@@ -285,13 +285,13 @@ SSDatabaseImpl::create(const DLDbIdentifier &dlDbIdentifier)
 }
 
 void
 }
 
 void

-SSDatabaseImpl::createWithBlob(const DLDbIdentifier &dlDbIdentifier, const CSSM_DATA &blob)
+SSDatabaseImpl::ssCreateWithBlob(const DLDbIdentifier &dlDbIdentifier, const CSSM_DATA &blob)

 {
        try
        {
                bool autoCommit;
                commonCreate(dlDbIdentifier, autoCommit);
 {
        try
        {
                bool autoCommit;
                commonCreate(dlDbIdentifier, autoCommit);

-        secdebugfunc("integrity", "opening %s", name());
+        secnotice("integrity", "opening %s", name());

                Db::Impl::insert(DBBlobRelationID, NULL, &blob);
                if (autoCommit)
                {
                Db::Impl::insert(DBBlobRelationID, NULL, &blob);
                if (autoCommit)
                {


@@ -308,22 +308,30 @@ SSDatabaseImpl::createWithBlob(const DLDbIdentifier &dlDbIdentifier, const CSSM_
 }
 
 void
 }
 
 void

-SSDatabaseImpl::open(const DLDbIdentifier &dlDbIdentifier)
+SSDatabaseImpl::ssOpen(const DLDbIdentifier &dlDbIdentifier)

 {
 {

-       mIdentifier = dlDbIdentifier;
-       Db::Impl::open();
-
-       CssmDataContainer dbb(allocator());
-       getDbBlobId(&dbb);
+    load(dlDbIdentifier);

 
 

-    secdebugfunc("integrity", "opening %s", name());
+    CssmDataContainer dbb(allocator());
+    getDbBlobId(&dbb);

 
     // Pull our version out of the database blob
        mSSDbHandle = mClientSession.decodeDb(dlDbIdentifier, AccessCredentials::overlay(accessCredentials()), dbb);
 }
 
 void
 
     // Pull our version out of the database blob
        mSSDbHandle = mClientSession.decodeDb(dlDbIdentifier, AccessCredentials::overlay(accessCredentials()), dbb);
 }
 
 void

-SSDatabaseImpl::recode(const CssmData &dbHandleArray, const CssmData &agentData)
+SSDatabaseImpl::load(const DLDbIdentifier &dlDbIdentifier) {
+    mIdentifier = dlDbIdentifier;
+    Db::Impl::open();
+
+    CssmDataContainer dbb(allocator());
+    getDbBlobId(&dbb);
+
+    secnotice("integrity", "loading %s", name());
+}
+
+void
+SSDatabaseImpl::ssRecode(const CssmData &dbHandleArray, const CssmData &agentData)

 {
     // Start a transaction (Implies activate()).
     passThrough(CSSM_APPLEFILEDL_TOGGLE_AUTOCOMMIT, 0);
 {
     // Start a transaction (Implies activate()).
     passThrough(CSSM_APPLEFILEDL_TOGGLE_AUTOCOMMIT, 0);


@@ -375,9 +383,9 @@ SSDatabaseImpl::recodeDbToVersion(uint32 newBlobVersion) {
     try
     {
         if(isLocked()) {
     try
     {
         if(isLocked()) {

-            secdebugfunc("integrity", "is currently locked");
+            secnotice("integrity", "is currently locked");

         } else {
         } else {

-            secdebugfunc("integrity", "is already unlocked");
+            secnotice("integrity", "is already unlocked");

         }
 
         CssmDataContainer dbb(allocator());
         }
 
         CssmDataContainer dbb(allocator());


@@ -389,18 +397,18 @@ SSDatabaseImpl::recodeDbToVersion(uint32 newBlobVersion) {
         dbb.clear();
 
         // Create a newDbHandle using the master secrets from the dbBlob we are recoding to.
         dbb.clear();
 
         // Create a newDbHandle using the master secrets from the dbBlob we are recoding to.

-        secdebugfunc("integrity", "recoding db with handle %d", mSSDbHandle);
+        secnotice("integrity", "recoding db with handle %d", mSSDbHandle);

         SecurityServer::DbHandle clonedDbHandle = mClientSession.recodeDbToVersion(newBlobVersion, mSSDbHandle);
         SecurityServer::DbHandle clonedDbHandle = mClientSession.recodeDbToVersion(newBlobVersion, mSSDbHandle);

-        secdebugfunc("integrity", "received db with handle %d", clonedDbHandle);
+        secnotice("integrity", "received db with handle %d", clonedDbHandle);

 
         // @@@ If the dbb changed since we fetched it we should abort or
         // retry the operation here.
 
         uint32 newBlobVersion = recodeHelper(clonedDbHandle, dbBlobId);
 
         // @@@ If the dbb changed since we fetched it we should abort or
         // retry the operation here.
 
         uint32 newBlobVersion = recodeHelper(clonedDbHandle, dbBlobId);

-        secdebugfunc("integrity", "committing transaction %d", clonedDbHandle);
+        secnotice("integrity", "committing transaction %d", clonedDbHandle);

 
         // Commit the transaction to the db
 
         // Commit the transaction to the db

-        transaction.success();
+        transaction.commit();

         return newBlobVersion;
     }
     catch (...)
         return newBlobVersion;
     }
     catch (...)


@@ -409,6 +417,11 @@ SSDatabaseImpl::recodeDbToVersion(uint32 newBlobVersion) {
     }
 }
 
     }
 }
 

+void
+SSDatabaseImpl::recodeFinished() {
+    mClientSession.recodeFinished(mSSDbHandle);
+}
+

 void SSDatabaseImpl::takeFileLock() {
     if(mTransaction) {
         // you're already in the middle of a file lock.
 void SSDatabaseImpl::takeFileLock() {
     if(mTransaction) {
         // you're already in the middle of a file lock.


@@ -422,9 +435,9 @@ void SSDatabaseImpl::releaseFileLock(bool success) {
     if(mTransaction) {
         try {
             if(success) {
     if(mTransaction) {
         try {
             if(success) {

-                mTransaction->success();
+                mTransaction->commit();

             }
             }

-            // The destructor will commit the database and re-enable autocommit (if needed)
+            // If we didn't commit, the destructor will roll back and re-enable autocommit

             delete mTransaction;
             mTransaction = NULL;
         } catch(...) {
             delete mTransaction;
             mTransaction = NULL;
         } catch(...) {


@@ -438,6 +451,25 @@ void SSDatabaseImpl::makeBackup() {
     passThrough(CSSM_APPLEFILEDL_MAKE_BACKUP, NULL, NULL);
 }
 
     passThrough(CSSM_APPLEFILEDL_MAKE_BACKUP, NULL, NULL);
 }
 

+void SSDatabaseImpl::makeCopy(const char* path) {
+    passThrough(CSSM_APPLEFILEDL_MAKE_COPY, path, NULL);
+}
+
+void SSDatabaseImpl::deleteFile() {
+    passThrough(CSSM_APPLEFILEDL_DELETE_FILE, NULL, NULL);
+}
+
+SSDatabase SSDatabaseImpl::ssCloneTo(const DLDbIdentifier& dldbidentifier) {
+    makeCopy(dldbidentifier.dbName());
+    SSDatabase db(mClientSession, dl(), dldbidentifier.dbName(), dldbidentifier.dbLocation());
+
+    db->load(dldbidentifier);
+    db->mSSDbHandle = mClientSession.cloneDb(dldbidentifier, mSSDbHandle);
+
+    return db;
+}
+
+

 
 uint32 SSDatabaseImpl::recodeHelper(SecurityServer::DbHandle clonedDbHandle, CssmClient::DbUniqueRecord& dbBlobId) {
     // Recode all keys
 
 uint32 SSDatabaseImpl::recodeHelper(SecurityServer::DbHandle clonedDbHandle, CssmClient::DbUniqueRecord& dbBlobId) {
     // Recode all keys


@@ -463,8 +495,8 @@ uint32 SSDatabaseImpl::recodeHelper(SecurityServer::DbHandle clonedDbHandle, Css
                     CSSM_DB_MODIFY_ATTRIBUTE_NONE);
         } catch (CssmError cssme) {
             const char* errStr = cssmErrorString(cssme.error);
                     CSSM_DB_MODIFY_ATTRIBUTE_NONE);
         } catch (CssmError cssme) {
             const char* errStr = cssmErrorString(cssme.error);

-            secdebugfunc("integrity", "corrupt item while recoding: %d %s", (int) cssme.error, errStr);
-            secdebugfunc("integrity", "deleting corrupt item");
+            secnotice("integrity", "corrupt item while recoding: %d %s", (int) cssme.error, errStr);
+            secnotice("integrity", "deleting corrupt item");

 
 
             keyBlobId->deleteRecord();
 
 
             keyBlobId->deleteRecord();


@@ -472,12 +504,12 @@ uint32 SSDatabaseImpl::recodeHelper(SecurityServer::DbHandle clonedDbHandle, Css
             if(keyHandle != 0) {
                 // tell securityd not to worry about this key again
                 try {
             if(keyHandle != 0) {
                 // tell securityd not to worry about this key again
                 try {

-                    secdebugfunc("integrity", "releasing corrupt key");
+                    secnotice("integrity", "releasing corrupt key");

                     mClientSession.releaseKey(keyHandle);
                 } catch(CssmError cssme) {
                     // swallow the error
                     const char* errStr = cssmErrorString(cssme.error);
                     mClientSession.releaseKey(keyHandle);
                 } catch(CssmError cssme) {
                     // swallow the error
                     const char* errStr = cssmErrorString(cssme.error);

-                    secdebugfunc("integrity", "couldn't release corrupt key: %d %s", (int) cssme.error, errStr);
+                    secnotice("integrity", "couldn't release corrupt key: %d %s", (int) cssme.error, errStr);

                 }
             }
         }
                 }
             }
         }


@@ -486,7 +518,7 @@ uint32 SSDatabaseImpl::recodeHelper(SecurityServer::DbHandle clonedDbHandle, Css
     // Commit the new blob to securityd, reencode the db blob, release the
     // cloned db handle and commit the new blob to the db.
     CssmDataContainer dbb(allocator());
     // Commit the new blob to securityd, reencode the db blob, release the
     // cloned db handle and commit the new blob to the db.
     CssmDataContainer dbb(allocator());

-    secdebugfunc("integrity", "committing %d", clonedDbHandle);
+    secnotice("integrity", "committing %d", clonedDbHandle);

     mClientSession.commitDbForSync(mSSDbHandle, clonedDbHandle,
             dbb, allocator());
     dbBlobId->modify(DBBlobRelationID, NULL, &dbb,
     mClientSession.commitDbForSync(mSSDbHandle, clonedDbHandle,
             dbb, allocator());
     dbBlobId->modify(DBBlobRelationID, NULL, &dbb,


@@ -512,7 +544,7 @@ void SSDatabaseImpl::getRecordIdentifier(CSSM_DB_UNIQUE_RECORD_PTR uniqueRecord,
        dest[3] = 0;
 }
 
        dest[3] = 0;
 }
 

-void SSDatabaseImpl::copyBlob(CSSM_DATA &data)
+void SSDatabaseImpl::ssCopyBlob(CSSM_DATA& data)

 {
        // get the blob from the database
        CssmDataContainer dbb(allocator());
 {
        // get the blob from the database
        CssmDataContainer dbb(allocator());