QString QRec::operator [](int i) const
{
ASSERTVALID();
switch ( m_outputAttributeData[i].Info.AttributeFormat )
{
case CSSM_DB_ATTRIBUTE_FORMAT_STRING:
return AttributeFormatString( i );
break;
case CSSM_DB_ATTRIBUTE_FORMAT_UINT32:
return AttributeFormatUint32( i );
break;
case CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32:
return AttributeFormatMultiUint32( i );
break;
case CSSM_DB_ATTRIBUTE_FORMAT_BLOB:
return AttributeFormatBlob( i );
break;
case CSSM_DB_ATTRIBUTE_FORMAT_SINT32:
return AttributeFormatSint32( i );
break;
default:
return _T("Error: Unsupported attribute data" );
break;
} //switch
}
CSSM_RETURN QMDS::DataDelete(MDS_DB_HANDLE MdsDbHandle,
const CSSM_DB_UNIQUE_RECORD *UniqueRecordIdentifier)
{
ASSERTVALID();
return m_dlFunctions.DataDelete( MdsDbHandle, UniqueRecordIdentifier );
}
CSSM_DB_UNIQUE_RECORD_PTR CRecType::NextRecordId(CSSM_DB_RECORD_ATTRIBUTE_DATA & outputAttributes)
{
ASSERTVALID();
if ( m_resultsHandle == 0 )
{
return NULL;
}
CSSM_DB_UNIQUE_RECORD_PTR recordId = NULL;
CMDS * pMds = m_pDir->m_pMds;
CSSM_RETURN ret = pMds->DataGetNext(
m_pDir->m_hDb,
m_resultsHandle,
&outputAttributes,
NULL,
&recordId);
if ((ret != CSSM_OK) && (ret != CSSMERR_DL_ENDOFDATA))
{
//char buffer[128];
//GetErrorMsgString(ret,buffer,sizeof(buffer));
CString strMsg;
strMsg.Format(
_T("Error occurred during DataGetFirst. MDS may be corrupted"));
AfxMessageBox( strMsg );
}
return recordId;
}
CSSM_RETURN QMDS::DataAbortQuery(MDS_DB_HANDLE MdsDbHandle,
CSSM_HANDLE ResultsHandle)
{
ASSERTVALID();
return m_dlFunctions.DataAbortQuery( MdsDbHandle, ResultsHandle );
}
QString QRec::AttributeFormatMultiUint32(int i) const
{
ASSERTVALID();
ASSERT(m_outputAttributeData[i].Info.AttributeFormat ==
CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32 );
if ( m_outputAttributeData[i].Value->Data == NULL )
{
return "<NULL>";
}
QString str = "{ ";
QString strTmp;
for ( uint32 j = 0; j < m_outputAttributeData[i].Value->Length; j+=4 )
{
uint32 u32Val = *((uint32 *) (m_outputAttributeData[i].Value->Data+j));
//QT: alternative to Format()
//strTmp.Format( "0x%.8X", u32Val );
strTmp = QStringFormat("0x%.8X", u32Val);
str += strTmp;
str += " ";
}
str += "}";
return str;
}
CSSM_RETURN QDirectory::Open(QMDS *pMds, const char *szDirName)
{
ASSERTVALID();
m_pMds = pMds;
m_strDirName = szDirName;
return OpenDirectory();
}
CSSM_RETURN QMDS::FreeUniqueRecord(MDS_DB_HANDLE MdsDbHandle,
CSSM_DB_UNIQUE_RECORD_PTR UniqueRecord)
{
ASSERTVALID();
return m_dlFunctions.FreeUniqueRecord(MdsDbHandle,
UniqueRecord);
}
CSSM_RETURN QMDS::DataGetFromUniqueRecordId(MDS_DB_HANDLE MdsDbHandle,
CSSM_DB_UNIQUE_RECORD_PTR UniqueRecord,
CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
CSSM_DATA_PTR Data)
{
ASSERTVALID();
return m_dlFunctions.DataGetFromUniqueRecordId(MdsDbHandle,
UniqueRecord,
Attributes,
Data);
}
CSSM_RETURN QDirectory::CloseDirectory()
{
ASSERTVALID();
CSSM_RETURN crStatus = m_pMds->DbClose( m_hDb );
if ( crStatus == CSSM_OK )
{
memset( &m_hDb, 0, sizeof(MDS_DB_HANDLE) );
}
return crStatus;
}
CSSM_RETURN QMDS::DataInsert(MDS_DB_HANDLE MdsDbHandle,
CSSM_DB_RECORDTYPE RecordType,
const CSSM_DB_RECORD_ATTRIBUTE_DATA *Attributes,
const CSSM_DATA *Data,
CSSM_DB_UNIQUE_RECORD_PTR *UniqueId)
{
ASSERTVALID();
return m_dlFunctions.DataInsert(MdsDbHandle,
RecordType,
Attributes,
Data,
UniqueId);
}
CString CRec::AttributeFormatBlob(int i) const
{
ASSERTVALID();
ASSERT(m_outputAttributeData[i].Info.AttributeFormat ==
CSSM_DB_ATTRIBUTE_FORMAT_BLOB );
if ( m_outputAttributeData[i].Value->Data == NULL )
{
return "<NULL>";
}
CString str;
uint32 u32NumBytesToDisplay = 0;
const uint32 u32MaxNumBytesToDisplay = 12;
if ( s_bViewBlobAsString )
{
u32NumBytesToDisplay =
__min(2*u32MaxNumBytesToDisplay, m_outputAttributeData[i].Value->Length);
CString strTmp(
(LPCTSTR) m_outputAttributeData[i].Value->Data,
u32NumBytesToDisplay);
str = strTmp + " ";
}
else
{
u32NumBytesToDisplay =
__min(u32MaxNumBytesToDisplay, m_outputAttributeData[i].Value->Length);
CString strTmp;
for ( uint32 j = 0; j < u32NumBytesToDisplay; j++ )
{
uint8 u8Val = *((uint8 *) (m_outputAttributeData[i].Value->Data+j));
strTmp.Format( "0x%.2X", u8Val );
str += strTmp;
str += " ";
}
}
if ( m_outputAttributeData[i].Value->Length > u32NumBytesToDisplay )
{
str += "...";
}
return str;
}
CSSM_RETURN QMDS::DataGetNext(MDS_DB_HANDLE MdsDbHandle,
CSSM_HANDLE ResultsHandle,
CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
CSSM_DATA_PTR Data,
CSSM_DB_UNIQUE_RECORD_PTR *UniqueID)
{
ASSERTVALID();
return m_dlFunctions.DataGetNext(MdsDbHandle,
ResultsHandle,
Attributes,
Data,
UniqueID);
}
CString CRec::AttributeFormatString(int i) const
{
ASSERTVALID();
ASSERT(m_outputAttributeData[i].Info.AttributeFormat ==
CSSM_DB_ATTRIBUTE_FORMAT_STRING );
if ( m_outputAttributeData[i].Value->Data == NULL )
{
return "<NULL>";
}
CString str;
str.Format( "\"%s\"", m_outputAttributeData[i].Value->Data );
return str;
}
CString CRec::AttributeFormatUint32(int i) const
{
ASSERTVALID();
ASSERT(m_outputAttributeData[i].Info.AttributeFormat ==
CSSM_DB_ATTRIBUTE_FORMAT_UINT32 );
if ( m_outputAttributeData[i].Value->Data == NULL )
{
return "<NULL>";
}
CString str;
uint32 u32Val = *((uint32 *) m_outputAttributeData[i].Value->Data);
str.Format( "0x%.8X", u32Val );
return str;
}
CSSM_RETURN QMDS::DataModify(MDS_DB_HANDLE MdsDbHandle,
CSSM_DB_RECORDTYPE RecordType,
CSSM_DB_UNIQUE_RECORD_PTR UniqueRecordIdentifier,
const CSSM_DB_RECORD_ATTRIBUTE_DATA *AttributesToBeModified,
const CSSM_DATA *DataToBeModified,
const CSSM_DB_MODIFY_MODE ModifyMode)
{
ASSERTVALID();
return m_dlFunctions.DataModify(MdsDbHandle,
RecordType,
UniqueRecordIdentifier,
AttributesToBeModified,
DataToBeModified,
ModifyMode);
}
QString QRec::AttributeFormatString(int i) const
{
ASSERTVALID();
ASSERT(m_outputAttributeData[i].Info.AttributeFormat ==
CSSM_DB_ATTRIBUTE_FORMAT_STRING );
if ( m_outputAttributeData[i].Value->Data == NULL )
{
return "<NULL>";
}
QString str;
//QT: alternative to Format()
//str.Format( "\"%s\"", m_outputAttributeData[i].Value->Data );
str += "\"";
str += (const char *)m_outputAttributeData[i].Value->Data;
str += "\"";
return str;
}
QString QRec::AttributeFormatSint32(int i) const
{
ASSERTVALID();
ASSERT(m_outputAttributeData[i].Info.AttributeFormat ==
CSSM_DB_ATTRIBUTE_FORMAT_SINT32 );
if ( m_outputAttributeData[i].Value->Data == NULL )
{
return "<NULL>";
}
QString str;
sint32 s32Val = *((sint32 *) m_outputAttributeData[i].Value->Data);
//QT: alternative to Format()
//str.Format( "0x%.8X", s32Val );
str = QStringFormat("0x%.8X", s32Val );
return str;
}
CSSM_RETURN QDirectory::OpenDirectory()
{
ASSERTVALID();
CSSM_DB_ACCESS_TYPE access =
CSSM_DB_ACCESS_READ | CSSM_DB_ACCESS_WRITE;
m_hDb.DLHandle = m_pMds->m_hMds;
m_hDb.DBHandle = 0;
CSSM_RETURN ret = m_pMds->DbOpen(m_strDirName,
NULL,
access,
NULL,
NULL,
&m_hDb.DBHandle);
return ret;
}
//////////////////////////////////////////////////////////////////////
//Wrappers Around MDS_FUNCS Function Pointers
//////////////////////////////////////////////////////////////////////
CSSM_RETURN QMDS::DbOpen(const char *DbName,
const CSSM_NET_ADDRESS *DbLocation,
CSSM_DB_ACCESS_TYPE AccessRequest,
const CSSM_ACCESS_CREDENTIALS *AccessCred,
const void *OpenParameters,
CSSM_DB_HANDLE *hMds)
/*
CSSM_DB_HANDLE QMDS::DbOpen(const char *DbName,
const CSSM_NET_ADDRESS *DbLocation,
const CSSM_DB_ACCESS_TYPE *AccessRequest,
const CSSM_USER_AUTHENTICATION *UserAuthentication,
const void *OpenParameters)
*/
{
ASSERTVALID();
return m_dlFunctions.DbOpen(m_hMds,
DbName,
DbLocation,
AccessRequest,
AccessCred,
OpenParameters,
hMds);
}
CSSM_RETURN QMDS::DbClose(MDS_DB_HANDLE MdsDbHandle)
{
ASSERTVALID();
return m_dlFunctions.DbClose( MdsDbHandle );
}
CSSM_RETURN QMDS::GetDbNames(CSSM_NAME_LIST_PTR *pNameList)
{
ASSERTVALID();
return m_dlFunctions.GetDbNames( m_hMds, pNameList );
}
CSSM_RETURN QMDS::GetDbNameFromHandle(MDS_DB_HANDLE MdsHandle, char** dbName)
{
ASSERTVALID();
return m_dlFunctions.GetDbNameFromHandle( MdsHandle,dbName);
}
void CRec::Serialize( CArchive& archive )
{
ASSERTVALID();
// call base class function first
// base class is CObject in this case
CObject::Serialize( archive );
// now do the stuff for our specific class
if ( archive.IsStoring() )
{
archive.Write(
&m_outputAttributes.DataRecordType,
4);
archive.Write(
&m_outputAttributes.SemanticInformation,
4);
archive.Write(
&m_outputAttributes.NumberOfAttributes,
4);
for ( uint32 i = 0; i < m_outputAttributes.NumberOfAttributes; i++ )
{
//store attribute name
archive.Write(
&m_outputAttributes.AttributeData[i].Info.AttributeNameFormat,
4);
ASSERT( m_outputAttributes.AttributeData[i].Info.AttributeNameFormat ==
CSSM_DB_ATTRIBUTE_NAME_AS_STRING );
//Need to fix this if you want to extend it to CSSM_DB_ATTRIBUTE_NAME_AS_OID
//store attribute info
// store attribute info label
DWORD dwAttrNameLength =
strlen(m_outputAttributes.AttributeData[i].Info.Label.AttributeName) + 1;
archive.Write(
&dwAttrNameLength,
4);
archive.Write(
m_outputAttributes.AttributeData[i].Info.Label.AttributeName,
dwAttrNameLength);
//store attribute value format
archive.Write(
&m_outputAttributes.AttributeData[i].Info.AttributeFormat,
4);
//store attribute value;
archive.Write(
&m_outputAttributes.AttributeData[i].Value->Length,
4);
if ( m_outputAttributes.AttributeData[i].Value->Length )
{
archive.Write(
m_outputAttributes.AttributeData[i].Value->Data,
m_outputAttributes.AttributeData[i].Value->Length);
}
}
}
else
{
archive.Read(
&m_outputAttributes.DataRecordType,
4);
archive.Read(
&m_outputAttributes.SemanticInformation,
4);
archive.Read(
&m_outputAttributes.NumberOfAttributes,
4);
for ( uint32 i = 0; i < m_outputAttributes.NumberOfAttributes; i++ )
{
//retrieve attribute name
// retrieve attribute info label
archive.Read(
&m_outputAttributes.AttributeData[i].Info.AttributeNameFormat,
4);
ASSERT( m_outputAttributes.AttributeData[i].Info.AttributeNameFormat ==
CSSM_DB_ATTRIBUTE_NAME_AS_STRING );
//Need to fix this if you want to extend it to CSSM_DB_ATTRIBUTE_NAME_AS_OID
DWORD dwAttrNameLength = 0;
archive.Read(
&dwAttrNameLength,
4);
ASSERT( dwAttrNameLength );
//allocate memory for the attribute name
m_outputAttributes.AttributeData[i].Info.Label.AttributeName =
(char *) CMdsUtil_malloc( dwAttrNameLength, &CMdsUtil_AllocRef );
if ( !m_outputAttributes.AttributeData[i].Info.Label.AttributeName )
{
AfxThrowMemoryException();
}
archive.Read(
m_outputAttributes.AttributeData[i].Info.Label.AttributeName,
dwAttrNameLength);
//retrieve attribute value format
archive.Read(
&m_outputAttributes.AttributeData[i].Info.AttributeFormat,
4);
//retrieve attribute value;
archive.Read(
&m_outputAttributes.AttributeData[i].Value->Length,
4);
m_outputAttributes.AttributeData[i].Value->Data = NULL;
if ( m_outputAttributes.AttributeData[i].Value->Length )
{
//allocate memory for the data
m_outputAttributes.AttributeData[i].Value->Data =
(uint8 *) CMdsUtil_malloc(
m_outputAttributes.AttributeData[i].Value->Length,
&CMdsUtil_AllocRef);
if ( !m_outputAttributes.AttributeData[i].Value->Data )
{
AfxThrowMemoryException();
}
archive.Read(
m_outputAttributes.AttributeData[i].Value->Data,
m_outputAttributes.AttributeData[i].Value->Length);
}
//do some error checking and use static memory to represent name
for ( int j = 0; j < sizeof(s_pMdsAttrInfo)/sizeof(CSSM_DB_ATTRIBUTE_INFO_PTR); j++ )
{
if (strcmp(
s_pMdsAttrInfo[j]->Label.AttributeName,
m_outputAttributes.AttributeData[i].Info.Label.AttributeName) == 0)
{
ASSERT(
m_outputAttributes.AttributeData[i].Info.AttributeNameFormat ==
s_pMdsAttrInfo[j]->AttributeNameFormat);
ASSERT(
m_outputAttributes.AttributeData[i].Info.AttributeFormat ==
s_pMdsAttrInfo[j]->AttributeFormat);
CMdsUtil_free(
m_outputAttributes.AttributeData[i].Info.Label.AttributeName,
&CMdsUtil_AllocRef);
m_outputAttributes.AttributeData[i].Info = *s_pMdsAttrInfo[j];
break;
}
}
if ( j == sizeof(s_pMdsAttrInfo)/sizeof(CSSM_DB_ATTRIBUTE_INFO_PTR) )
{
AfxMessageBox( _T("Unsupported attribute name found in MDS file") );
}
}
}
}
CSSM_RETURN QMDS::FreeNameList(CSSM_NAME_LIST_PTR NameList)
{
ASSERTVALID();
return m_dlFunctions.FreeNameList( m_hMds, NameList );
}
