#include <security_utilities/debugging.h>
/* log open/close events */
-#define DOCDebug(args...) secdebug("DBOpen", ## args)
+#define DOCDebug(args...) secinfo("DBOpen", ## args)
using namespace std;
void
DatabaseSession::GetDbNames(CSSM_NAME_LIST_PTR &outNameList)
{
- secdebug("dbsession", "GetDbNames");
+ secinfo("dbsession", "GetDbNames");
outNameList = mDatabaseManager.getDbNames (*this);
#ifndef NDEBUG
// dump the returned names
uint32 n;
- secdebug("dbsession", "GetDbNames returned %d names", outNameList->NumStrings);
+ secinfo("dbsession", "GetDbNames returned %d names", outNameList->NumStrings);
for (n = 0; n < outNameList->NumStrings; ++n)
{
- secdebug("dbsession", "%d: %s", n, outNameList->String[n]);
+ secinfo("dbsession", "%d: %s", n, outNameList->String[n]);
}
#endif
-
- secdebug("dbsession", "********************");
}
void
DatabaseSession::FreeNameList(CSSM_NAME_LIST &inNameList)
{
- secdebug("dbsession", "FreeNameList");
+ secinfo("dbsession", "FreeNameList");
mDatabaseManager.freeNameList (*this, inNameList);
- secdebug("dbsession", "********************");
}
{
// The databaseManager will notify all its DbContext instances
// that the database is question is being deleted.
- secdebug("dbsession", "DbDelete of %s", inDbName);
+ secinfo("dbsession", "DbDelete of %s", inDbName);
mDatabaseManager.dbDelete(*this, DbName(inDbName, CssmNetAddress::optional(inDbLocation)), inAccessCred);
- secdebug("dbsession", "********************");
}
// DbContext creation and destruction.
CSSM_DB_HANDLE &outDbHandle)
{
outDbHandle = CSSM_INVALID_HANDLE; // CDSA 2.0 says to set this if we fail
- secdebug("dbsession", "DbCreate of %s", inDbName);
+ secinfo("dbsession", "DbCreate of %s", inDbName);
outDbHandle = insertDbContext(mDatabaseManager.dbCreate(*this,
DbName(inDbName, CssmNetAddress::optional(inDbLocation)),
inAccessRequest,
inCredAndAclEntry,
inOpenParameters));
- secdebug("dbsession", "DbCreate returned handle %#lx", outDbHandle);
-
- secdebug("dbsession", "********************");
+ secinfo("dbsession", "DbCreate returned handle %#lx", outDbHandle);
}
void
CSSM_DB_HANDLE &outDbHandle)
{
DOCDebug("DatabaseSession::DbOpen: dbName %s", inDbName);
- secdebug("dbsession", "DbOpen of %s", inDbName);
+ secinfo("dbsession", "DbOpen of %s", inDbName);
outDbHandle = CSSM_INVALID_HANDLE; // CDSA 2.0 says to set this if we fail
outDbHandle = insertDbContext(mDatabaseManager.dbOpen(*this,
DbName(inDbName, CssmNetAddress::optional(inDbLocation)),
inAccessRequest,
inAccessCred,
inOpenParameters));
- secdebug("dbsession", "DbOpen returned handle %#lx", outDbHandle);
- secdebug("dbsession", "********************");
+ secinfo("dbsession", "DbOpen returned handle %#lx", outDbHandle);
}
CSSM_DB_HANDLE
}
mDbContextMap.clear();
- secdebug("dbsession", "********************");
}
// Operations using DbContext instances.
{
StLock<Mutex> _(mDbContextMapLock);
DOCDebug("DatabaseSession::Close");
- secdebug("dbsession", "DbClose of handle %ld", inDbHandle);
+ secinfo("dbsession", "DbClose of handle %ld", inDbHandle);
DbContextMap::iterator it = mDbContextMap.find(inDbHandle);
if (it == mDbContextMap.end())
CssmError::throwMe(CSSM_ERRCODE_INVALID_DB_HANDLE);
- auto_ptr<DbContext> aDbContext(it->second);
+ unique_ptr<DbContext> aDbContext(it->second);
mDbContextMap.erase(it);
mDatabaseManager.dbClose(*aDbContext);
- secdebug("dbsession", "********************");
}
void
uint32 inNumberOfIndexes,
const CSSM_DB_SCHEMA_INDEX_INFO &inIndexInfo)
{
- secdebug("dbsession", "CreateRelation from handle %ld of record type %X with relation name %s", inDbHandle, inRelationID, inRelationName);
- secdebug("dbsession", "number of attributes = %d", inNumberOfAttributes);
+ secinfo("dbsession", "CreateRelation from handle %ld of record type %X with relation name %s", inDbHandle, inRelationID, inRelationName);
+ secinfo("dbsession", "number of attributes = %d", inNumberOfAttributes);
#ifndef NDEBUG
unsigned n;
for (n = 0; n < inNumberOfAttributes; ++n)
{
- secdebug("dbsession", "%d: id %d name %s, data type %d", n, inAttributeInfo[n].AttributeId,
+ secinfo("dbsession", "%d: id %d name %s, data type %d", n, inAttributeInfo[n].AttributeId,
inAttributeInfo[n].AttributeName,
inAttributeInfo[n].DataType);
}
#endif
- secdebug("dbsession", "number of indexes: %d", inNumberOfIndexes);
+ secinfo("dbsession", "number of indexes: %d", inNumberOfIndexes);
#ifndef NDEBUG
for (n = 0; n < inNumberOfIndexes; ++n)
{
- secdebug("dbsession", "%d: id %d indexid %d indextype %d location %d", n, inIndexInfo.AttributeId,
+ secinfo("dbsession", "%d: id %d indexid %d indextype %d location %d", n, inIndexInfo.AttributeId,
inIndexInfo.IndexedDataLocation,
inIndexInfo.IndexId,
inIndexInfo.IndexType);
return aDbContext.mDatabase.createRelation(aDbContext, inRelationID, inRelationName,
inNumberOfAttributes, inAttributeInfo,
inNumberOfIndexes, inIndexInfo);
- secdebug("dbsession", "********************");
}
void
DatabaseSession::DestroyRelation(CSSM_DB_HANDLE inDbHandle,
CSSM_DB_RECORDTYPE inRelationID)
{
- secdebug("dbsession", "DestroyRelation (handle %ld) %d", inDbHandle, inRelationID);
+ secinfo("dbsession", "DestroyRelation (handle %ld) %d", inDbHandle, inRelationID);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.destroyRelation(aDbContext, inRelationID);
- secdebug("dbsession", "********************");
}
void
CSSM_DB_ACCESS_TYPE inAccessRequest,
const AccessCredentials &inAccessCred)
{
- secdebug("dbsession", "Authenticate (handle %ld) inAccessRequest %d", inDbHandle, inAccessRequest);
+ secinfo("dbsession", "Authenticate (handle %ld) inAccessRequest %d", inDbHandle, inAccessRequest);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.authenticate(aDbContext, inAccessRequest, inAccessCred);
- secdebug("dbsession", "********************");
}
uint32 &outNumberOfAclInfos,
CSSM_ACL_ENTRY_INFO_PTR &outAclInfos)
{
- secdebug("dbsession", "GetDbAcl (handle %ld)", inDbHandle);
+ secinfo("dbsession", "GetDbAcl (handle %ld)", inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.getDbAcl(aDbContext, inSelectionTag, outNumberOfAclInfos, outAclInfos);
- secdebug("dbsession", "********************");
}
void
const AccessCredentials &inAccessCred,
const CSSM_ACL_EDIT &inAclEdit)
{
- secdebug("dbsession", "ChangeDbAcl (handle %ld)", inDbHandle);
+ secinfo("dbsession", "ChangeDbAcl (handle %ld)", inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.changeDbAcl(aDbContext, inAccessCred, inAclEdit);
- secdebug("dbsession", "********************");
}
void
DatabaseSession::GetDbOwner(CSSM_DB_HANDLE inDbHandle,
CSSM_ACL_OWNER_PROTOTYPE &outOwner)
{
- secdebug("dbsession", "GetDbOwner (handle %ld)", inDbHandle);
+ secinfo("dbsession", "GetDbOwner (handle %ld)", inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.getDbOwner(aDbContext, outOwner);
- secdebug("dbsession", "********************");
}
void
const AccessCredentials &inAccessCred,
const CSSM_ACL_OWNER_PROTOTYPE &inNewOwner)
{
- secdebug("dbsession", "ChangeDbOwner (handle %ld)", inDbHandle);
+ secinfo("dbsession", "ChangeDbOwner (handle %ld)", inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.changeDbOwner(aDbContext, inAccessCred, inNewOwner);
- secdebug("dbsession", "********************");
}
void
DatabaseSession::GetDbNameFromHandle(CSSM_DB_HANDLE inDbHandle,
char **outDbName)
{
- secdebug("dbsession", "GetDbNameFromHandle (handle %ld)", inDbHandle);
+ secinfo("dbsession", "GetDbNameFromHandle (handle %ld)", inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
Required(outDbName) = aDbContext.mDatabase.getDbNameFromHandle(aDbContext);
- secdebug("dbsession", "name: %s", *outDbName);
- secdebug("dbsession", "********************");
+ secinfo("dbsession", "name: %s", *outDbName);
}
break;
}
- secdebug("dbsession", " Attribute name type: %s", attrNameType);
+ secinfo("dbsession", " Attribute name type: %s", attrNameType);
switch (info.AttributeFormat)
{
case CSSM_DB_ATTRIBUTE_NAME_AS_STRING:
- secdebug("dbsession", " name: %s", info.Label.AttributeName);
+ secinfo("dbsession", " name: %s", info.Label.AttributeName);
break;
case CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER:
- secdebug("dbsession", " name: %d", info.Label.AttributeID);
+ secinfo("dbsession", " name: %d", info.Label.AttributeID);
break;
case CSSM_DB_ATTRIBUTE_NAME_AS_OID:
- secdebug("dbsession", " name is oid");
+ secinfo("dbsession", " name is oid");
break;
}
break;
}
- secdebug("dbsession", " attribute format: %s", s);
+ secinfo("dbsession", " attribute format: %s", s);
}
{
if (!inAttributes)
{
- secdebug("dbsession", "No attributes defined.");
+ secinfo("dbsession", "No attributes defined.");
return;
}
- secdebug("dbsession", "insert into %d", inAttributes->DataRecordType);
- secdebug("dbsession", "Semantic information %d", inAttributes->SemanticInformation);
- secdebug("dbsession", "Number of attributes: %d", inAttributes->NumberOfAttributes);
+ secinfo("dbsession", "insert into %d", inAttributes->DataRecordType);
+ secinfo("dbsession", "Semantic information %d", inAttributes->SemanticInformation);
+ secinfo("dbsession", "Number of attributes: %d", inAttributes->NumberOfAttributes);
unsigned n;
for (n = 0; n < inAttributes->NumberOfAttributes; ++n)
{
DumpAttributeInfo(inAttributes->AttributeData[n].Info);
- secdebug("dbsession", "Attribute %d\n", n);
- secdebug("dbsession", " number of values: %d", inAttributes->AttributeData[n].NumberOfValues);
+ secinfo("dbsession", "Attribute %d\n", n);
+ secinfo("dbsession", " number of values: %d", inAttributes->AttributeData[n].NumberOfValues);
unsigned i;
for (i = 0; i < inAttributes->AttributeData[n].NumberOfValues; ++i)
{
case CSSM_DB_ATTRIBUTE_FORMAT_STRING:
{
std::string ss((char*) inAttributes->AttributeData[n].Value[i].Data, inAttributes->AttributeData[n].Value[i].Length);
- secdebug("dbsession", " Value %d: %s", i, ss.c_str());
+ secinfo("dbsession", " Value %d: %s", i, ss.c_str());
break;
}
case CSSM_DB_ATTRIBUTE_FORMAT_SINT32:
- secdebug("dbsession", " Value %d: %d", i, *(sint32*)inAttributes->AttributeData[n].Value[i].Data);
+ secinfo("dbsession", " Value %d: %d", i, *(sint32*)inAttributes->AttributeData[n].Value[i].Data);
break;
case CSSM_DB_ATTRIBUTE_FORMAT_UINT32:
- secdebug("dbsession", " Value %d: %u", i, *(uint32*)inAttributes->AttributeData[n].Value[i].Data);
+ secinfo("dbsession", " Value %d: %u", i, *(uint32*)inAttributes->AttributeData[n].Value[i].Data);
break;
case CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM:
- secdebug("dbsession", " Value %d: (bignum)", i);
+ secinfo("dbsession", " Value %d: (bignum)", i);
break;
case CSSM_DB_ATTRIBUTE_FORMAT_REAL:
- secdebug("dbsession", " Value %d: %f", i, *(double*)inAttributes->AttributeData[n].Value[i].Data);
+ secinfo("dbsession", " Value %d: %f", i, *(double*)inAttributes->AttributeData[n].Value[i].Data);
break;
case CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE:
- secdebug("dbsession", " Value %d: %s", i, (char*)inAttributes->AttributeData[n].Value[i].Data);
+ secinfo("dbsession", " Value %d: %s", i, (char*)inAttributes->AttributeData[n].Value[i].Data);
break;
case CSSM_DB_ATTRIBUTE_FORMAT_BLOB:
- secdebug("dbsession", " Value %d: (blob)", i);
+ secinfo("dbsession", " Value %d: (blob)", i);
break;
case CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32:
{
for (j = 0; j < numInts; ++j)
{
uint32* nums = (uint32*) inAttributes->AttributeData[n].Value[i].Data;
- secdebug("dbsession", " %d", nums[j]);
+ secinfo("dbsession", " %d", nums[j]);
}
break;
}
case CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX:
- secdebug("dbsession", " Value %d: (complex)", i);
+ secinfo("dbsession", " Value %d: (complex)", i);
break;
}
}
}
}
- secdebug("dbsession", "RecordLocator.IndexType: %s", s);
+ secinfo("dbsession", "RecordLocator.IndexType: %s", s);
switch (record.RecordLocator.IndexedDataLocation)
{
}
}
- secdebug("dbsession", "RecordLocator.IndexedDataLocation: %s", s);
+ secinfo("dbsession", "RecordLocator.IndexedDataLocation: %s", s);
- secdebug("dbsession", "Attribute info:");
+ secinfo("dbsession", "Attribute info:");
DumpAttributeInfo(record.RecordLocator.Info);
*/
output += hexBuffer;
}
- secdebug("dbsession", " RecordIdentifier.Data: %s", output.c_str());
+ secinfo("dbsession", " RecordIdentifier.Data: %s", output.c_str());
}
#endif /* NDEBUG */
const CssmData *inData,
CSSM_DB_UNIQUE_RECORD_PTR &outUniqueId)
{
- secdebug("dbsession", "%p DataInsert(%lx,%x)", this, inDbHandle, inRecordType);
+ secinfo("dbsession", "%p DataInsert(%lx,%x)", this, inDbHandle, inRecordType);
DbContext &aDbContext = findDbContext(inDbHandle);
outUniqueId = aDbContext.mDatabase.dataInsert(aDbContext, inRecordType, inAttributes, inData);
#ifndef NDEBUG
- secdebug("dbsession", "Returned unique id:");
+ secinfo("dbsession", "Returned unique id:");
DumpUniqueRecord(*outUniqueId);
#endif
-
- secdebug("dbsession", "********************");
}
DatabaseSession::DataDelete(CSSM_DB_HANDLE inDbHandle,
const CSSM_DB_UNIQUE_RECORD &inUniqueRecordIdentifier)
{
- secdebug("dbsession", "%p DataDelete(%lx)", this, inDbHandle);
+ secinfo("dbsession", "%p DataDelete(%lx)", this, inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.dataDelete(aDbContext, inUniqueRecordIdentifier);
#ifndef NDEBUG
- secdebug("dbsession", "Record identifier:");
+ secinfo("dbsession", "Record identifier:");
DumpUniqueRecord(inUniqueRecordIdentifier);
#endif
- secdebug("dbsession", "********************");
}
const CssmData *inDataToBeModified,
CSSM_DB_MODIFY_MODE inModifyMode)
{
- secdebug("dbsession", "%p DataModify(%lx,%x)", this, inDbHandle, inRecordType);
+ secinfo("dbsession", "%p DataModify(%lx,%x)", this, inDbHandle, inRecordType);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.dataModify(aDbContext, inRecordType, inoutUniqueRecordIdentifier,
inAttributesToBeModified, inDataToBeModified, inModifyMode);
#ifndef NDEBUG
- secdebug("dbsession", "Out record identifier:");
+ secinfo("dbsession", "Out record identifier:");
DumpUniqueRecord(inoutUniqueRecordIdentifier);
#endif
- secdebug("dbsession", "********************");
}
CSSM_HANDLE
CssmData *inoutData,
CSSM_DB_UNIQUE_RECORD_PTR &outUniqueId)
{
- secdebug("dbsession", "%p DataGetFirst(%lx)", this, inDbHandle);
+ secinfo("dbsession", "%p DataGetFirst(%lx)", this, inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
CSSM_HANDLE result = aDbContext.mDatabase.dataGetFirst(aDbContext, inQuery,
inoutAttributes, inoutData, outUniqueId);
#ifndef NDEBUG
- secdebug("dbsession", "result handle: %lx", result);
+ secinfo("dbsession", "result handle: %lx", result);
if (result != 0)
{
- secdebug("dbsession", "Returned ID:");
+ secinfo("dbsession", "Returned ID:");
DumpUniqueRecord(*outUniqueId);
}
#endif
- secdebug("dbsession", "********************");
return result;
}
CssmData *inoutData,
CSSM_DB_UNIQUE_RECORD_PTR &outUniqueRecord)
{
- secdebug("dbsession", "DataGetNext(%lx)", inDbHandle);
+ secinfo("dbsession", "DataGetNext(%lx)", inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
bool result = aDbContext.mDatabase.dataGetNext(aDbContext, inResultsHandle, inoutAttributes,
#ifndef NDEBUG
if (result)
{
- secdebug("dbsession", "Returned ID:");
+ secinfo("dbsession", "Returned ID:");
DumpUniqueRecord(*outUniqueRecord);
}
#endif
- secdebug("dbsession", "********************");
return result;
}
DatabaseSession::DataAbortQuery(CSSM_DB_HANDLE inDbHandle,
CSSM_HANDLE inResultsHandle)
{
- secdebug("dbsession", "%p DataAbortQuery(%lx)", this, inDbHandle);
+ secinfo("dbsession", "%p DataAbortQuery(%lx)", this, inDbHandle);
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.dataAbortQuery(aDbContext, inResultsHandle);
- secdebug("dbsession", "********************");
}
void
CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR inoutAttributes,
CssmData *inoutData)
{
- secdebug("dbsession", "%p DataGetFromUniqueId(%lx)", this, inDbHandle);
+ secinfo("dbsession", "%p DataGetFromUniqueId(%lx)", this, inDbHandle);
#ifndef NDEBUG
- secdebug("dbsession", "inUniqueRecord:");
+ secinfo("dbsession", "inUniqueRecord:");
DumpUniqueRecord(inUniqueRecord);
#endif
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.dataGetFromUniqueRecordId(aDbContext, inUniqueRecord,
inoutAttributes, inoutData);
- secdebug("dbsession", "********************");
}
void
DatabaseSession::FreeUniqueRecord(CSSM_DB_HANDLE inDbHandle,
CSSM_DB_UNIQUE_RECORD &inUniqueRecordIdentifier)
{
- secdebug("dbsession", "FreeUniqueRecord: %lx", inDbHandle);
+ secinfo("dbsession", "FreeUniqueRecord: %lx", inDbHandle);
#ifndef NDEBUG
- secdebug("dbsession", "inUniqueRecordIdentifier follows:");
+ secinfo("dbsession", "inUniqueRecordIdentifier follows:");
DumpUniqueRecord(inUniqueRecordIdentifier);
#endif
DbContext &aDbContext = findDbContext(inDbHandle);
aDbContext.mDatabase.freeUniqueRecord(aDbContext, inUniqueRecordIdentifier);
- secdebug("dbsession", "********************");
}
void
projects / apple / security.git / blobdiff