STDMETHODIMP_(BOOL) CDbxMdb::EnumContactSettings(MCONTACT contactID, DBCONTACTENUMSETTINGS* dbces)
{
if (!dbces->szModule)
return -1;
int result = -1;
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(dbces->szModule);
memset(keySearch.szSettingName, 0, _countof(keySearch.szSettingName));
mir_cslockfull lck(m_csDbAccess);
txn_ptr_ro trnlck(m_txn);
cursor_ptr_ro cursor(m_curSettings);
MDB_val key = { sizeof(keySearch), &keySearch }, data;
if (mdb_cursor_get(cursor, &key, &data, MDB_SET_RANGE) == MDB_SUCCESS)
{
do
{
const DBSettingKey *pKey = (const DBSettingKey*)key.mv_data;
if (pKey->dwContactID != contactID || pKey->dwOfsModule != keySearch.dwOfsModule)
return result;
char szSetting[256];
strncpy_s(szSetting, pKey->szSettingName, key.mv_size - sizeof(DWORD) * 2);
result = (dbces->pfnEnumProc)(szSetting, dbces->lParam);
}
while (mdb_cursor_get(cursor, &key, &data, MDB_NEXT) == MDB_SUCCESS);
}
return result;
}
STDMETHODIMP_(BOOL) CDbxKV::EnumContactSettings(MCONTACT contactID, DBCONTACTENUMSETTINGS* dbces)
{
if (!dbces->szModule)
return -1;
mir_cslock lck(m_csDbAccess);
DBSettingSortingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(dbces->szModule);
memset(keySearch.szSettingName, 0, SIZEOF(keySearch.szSettingName));
int result = -1;
ham_record_t rec = { 0 };
ham_key_t key = { sizeof(keySearch), &keySearch };
cursor_ptr cursor(m_dbSettings);
if (ham_cursor_find(cursor, &key, &rec, HAM_FIND_GEQ_MATCH) == HAM_SUCCESS) {
do {
DBSettingSortingKey *pKey = (DBSettingSortingKey*)key.data;
if (pKey->dwContactID != contactID || pKey->dwOfsModule != keySearch.dwOfsModule)
break;
char szSetting[256];
strncpy_s(szSetting, pKey->szSettingName, key.size - sizeof(DWORD) * 2);
result = (dbces->pfnEnumProc)(szSetting, dbces->lParam);
} while (ham_cursor_move(cursor, &key, &rec, HAM_CURSOR_NEXT) == HAM_SUCCESS);
}
return result;
}
STDMETHODIMP_(BOOL) CDbxMdb::DeleteContactSetting(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting)
{
if (!szModule || !szSetting)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)strlen(szSetting);
int moduleNameLen = (int)strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
MCONTACT saveContact = contactID;
{
mir_cslock lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
if (szCachedSettingName[-1] == 0) { // it's not a resident variable
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(szModule);
strncpy_s(keySearch.szSettingName, szSetting, _TRUNCATE);
MDB_val key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch }, data;
for (;; Remap()) {
txn_ptr trnlck(m_pMdbEnv);
if (mdb_del(trnlck, m_dbSettings, &key, &data))
return 1;
if (trnlck.commit())
break;
}
}
m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1);
}
// notify
DBCONTACTWRITESETTING dbcws = { 0 };
dbcws.szModule = szModule;
dbcws.szSetting = szSetting;
dbcws.value.type = DBVT_DELETED;
NotifyEventHooks(hSettingChangeEvent, saveContact, (LPARAM)&dbcws);
return 0;
}
STDMETHODIMP_(BOOL) CDbxMdb::EnumContactSettings(MCONTACT contactID, DBCONTACTENUMSETTINGS* dbces)
{
if (!dbces->szModule)
return -1;
int result = 0;
mir_cslock lck(m_csDbAccess);
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(dbces->szModule);
memset(keySearch.szSettingName, 0, SIZEOF(keySearch.szSettingName));
LIST<char> arSettings(50);
{
txn_ptr trnlck(m_pMdbEnv, true);
cursor_ptr cursor(trnlck, m_dbSettings);
MDB_val key = { sizeof(keySearch), &keySearch }, data;
if (mdb_cursor_get(cursor, &key, &data, MDB_SET_RANGE) == MDB_SUCCESS) {
do {
DBSettingKey *pKey = (DBSettingKey*)key.mv_data;
if (pKey->dwContactID != contactID || pKey->dwOfsModule != keySearch.dwOfsModule)
break;
char szSetting[256];
strncpy_s(szSetting, pKey->szSettingName, key.mv_size - sizeof(DWORD) * 2);
arSettings.insert(mir_strdup(szSetting));
}
while (mdb_cursor_get(cursor, &key, &data, MDB_NEXT) == MDB_SUCCESS);
}
}
if (arSettings.getCount() == 0)
return -1;
for (int i = 0; i < arSettings.getCount(); i++) {
result = (dbces->pfnEnumProc)(arSettings[i], dbces->lParam);
mir_free(arSettings[i]);
}
return result;
}
STDMETHODIMP_(BOOL) CDb3Mmap::EnumContactSettings(MCONTACT contactID, DBCONTACTENUMSETTINGS* dbces)
{
if (!dbces->szModule)
return -1;
mir_cslock lck(m_csDbAccess);
DWORD ofsContact = GetContactOffset(contactID);
if (ofsContact == 0)
return -1;
DBContact *dbc = (DBContact*)DBRead(ofsContact, NULL);
if (dbc->signature != DBCONTACT_SIGNATURE)
return -1;
DWORD ofsModuleName = GetModuleNameOfs(dbces->szModule);
dbces->ofsSettings = GetSettingsGroupOfsByModuleNameOfs(dbc, ofsModuleName);
if (!dbces->ofsSettings)
return -1;
DWORD ofsBlobPtr = dbces->ofsSettings + offsetof(DBContactSettings, blob);
int bytesRemaining;
PBYTE pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
if (pBlob[0] == 0)
return -1;
int result = 0;
while (pBlob[0]) {
NeedBytes(1);
NeedBytes(1 + pBlob[0]);
char szSetting[256];
memcpy(szSetting, pBlob + 1, pBlob[0]); szSetting[pBlob[0]] = 0;
result = (dbces->pfnEnumProc)(szSetting, dbces->lParam);
MoveAlong(1 + pBlob[0]);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
return result;
}
STDMETHODIMP_(BOOL) CDbxMdb::DeleteContactSetting(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting)
{
if (!szModule || !szSetting)
return 1;
int settingNameLen = (int)strlen(szSetting);
int moduleNameLen = (int)strlen(szModule);
MCONTACT saveContact = contactID;
{
mir_cslock lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
if (szCachedSettingName[-1] == 0) { // it's not a resident variable
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(szModule);
strncpy_s(keySearch.szSettingName, szSetting, _TRUNCATE);
MDB_val key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch }, data;
for (;; Remap())
{
txn_ptr trnlck(m_pMdbEnv);
MDB_CHECK(mdb_del(trnlck, m_dbSettings, &key, &data), 1);
if (trnlck.commit())
break;
}
}
m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1);
}
// notify
DBCONTACTWRITESETTING dbcws = { 0 };
dbcws.szModule = szModule;
dbcws.szSetting = szSetting;
dbcws.value.type = DBVT_DELETED;
NotifyEventHooks(hSettingChangeEvent, saveContact, (LPARAM)&dbcws);
return 0;
}
static __inline int GetContactSettingWorker(HANDLE hContact,DBCONTACTGETSETTING *dbcgs,int isStatic)
{
struct DBContact dbc;
struct DBContactSettings dbcs;
DWORD ofsModuleName,ofsContact,ofsSettingsGroup,ofsBlobPtr;
int settingNameLen;
int bytesRemaining;
PBYTE pBlob;
char* szCachedSettingName;
if ((!dbcgs->szSetting) || (!dbcgs->szModule))
return 1;
settingNameLen=(int)strlen(dbcgs->szSetting);
EnterCriticalSection(&csDbAccess);
log3("get [%08p] %s/%s",hContact,dbcgs->szModule,dbcgs->szSetting);
szCachedSettingName = GetCachedSetting(dbcgs->szModule,dbcgs->szSetting,settingNameLen);
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 0 );
if ( pCachedValue != NULL ) {
if ( pCachedValue->type == DBVT_ASCIIZ || pCachedValue->type == DBVT_UTF8 ) {
int cbOrigLen = dbcgs->pValue->cchVal;
char* cbOrigPtr = dbcgs->pValue->pszVal;
memcpy( dbcgs->pValue, pCachedValue, sizeof( DBVARIANT ));
if ( isStatic ) {
int cbLen = 0;
if ( pCachedValue->pszVal != NULL )
cbLen = (int)strlen( pCachedValue->pszVal );
cbOrigLen--;
dbcgs->pValue->pszVal = cbOrigPtr;
if(cbLen<cbOrigLen) cbOrigLen=cbLen;
CopyMemory(dbcgs->pValue->pszVal,pCachedValue->pszVal,cbOrigLen);
dbcgs->pValue->pszVal[cbOrigLen]=0;
dbcgs->pValue->cchVal=cbLen;
}
else {
dbcgs->pValue->pszVal = (char*)mir_alloc(strlen(pCachedValue->pszVal)+1);
strcpy(dbcgs->pValue->pszVal,pCachedValue->pszVal);
}
}
else
memcpy( dbcgs->pValue, pCachedValue, sizeof( DBVARIANT ));
switch( dbcgs->pValue->type ) {
case DBVT_BYTE: log1( "get cached byte: %d", dbcgs->pValue->bVal ); break;
case DBVT_WORD: log1( "get cached word: %d", dbcgs->pValue->wVal ); break;
case DBVT_DWORD: log1( "get cached dword: %d", dbcgs->pValue->dVal ); break;
case DBVT_UTF8:
case DBVT_ASCIIZ: log1( "get cached string: '%s'", dbcgs->pValue->pszVal); break;
default: log1( "get cached crap: %d", dbcgs->pValue->type ); break;
}
LeaveCriticalSection(&csDbAccess);
return ( pCachedValue->type == DBVT_DELETED ) ? 1 : 0;
} }
ofsModuleName=GetModuleNameOfs(dbcgs->szModule);
if(hContact==NULL) ofsContact=dbHeader.ofsUser;
else ofsContact=(DWORD)hContact;
dbc=*(struct DBContact*)DBRead(ofsContact,sizeof(struct DBContact),NULL);
if(dbc.signature!=DBCONTACT_SIGNATURE) {
LeaveCriticalSection(&csDbAccess);
return 1;
}
ofsSettingsGroup=GetSettingsGroupOfsByModuleNameOfs(&dbc,ofsContact,ofsModuleName);
if(ofsSettingsGroup) {
dbcs=*(struct DBContactSettings*)DBRead(ofsSettingsGroup,sizeof(struct DBContactSettings),&bytesRemaining);
ofsBlobPtr=ofsSettingsGroup+offsetof(struct DBContactSettings,blob);
pBlob=(PBYTE)DBRead(ofsBlobPtr,1,&bytesRemaining);
while(pBlob[0]) {
NeedBytes(1+settingNameLen);
if(pBlob[0]==settingNameLen && !memcmp(pBlob+1,dbcgs->szSetting,settingNameLen)) {
MoveAlong(1+settingNameLen);
NeedBytes(5);
if(isStatic && pBlob[0]&DBVTF_VARIABLELENGTH && VLT(dbcgs->pValue->type) != VLT(pBlob[0])) {
LeaveCriticalSection(&csDbAccess);
return 1;
}
dbcgs->pValue->type=pBlob[0];
switch(pBlob[0]) {
case DBVT_DELETED: { /* this setting is deleted */
dbcgs->pValue->type=DBVT_DELETED;
LeaveCriticalSection(&csDbAccess);
return 2;
}
case DBVT_BYTE: dbcgs->pValue->bVal=pBlob[1]; break;
case DBVT_WORD: dbcgs->pValue->wVal=*(PWORD)(pBlob+1); break;
case DBVT_DWORD: dbcgs->pValue->dVal=*(PDWORD)(pBlob+1); break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
NeedBytes(3+*(PWORD)(pBlob+1));
if(isStatic) {
dbcgs->pValue->cchVal--;
if(*(PWORD)(pBlob+1)<dbcgs->pValue->cchVal) dbcgs->pValue->cchVal=*(PWORD)(pBlob+1);
CopyMemory(dbcgs->pValue->pszVal,pBlob+3,dbcgs->pValue->cchVal);
dbcgs->pValue->pszVal[dbcgs->pValue->cchVal]=0;
dbcgs->pValue->cchVal=*(PWORD)(pBlob+1);
}
else {
dbcgs->pValue->pszVal=(char*)mir_alloc(1+*(PWORD)(pBlob+1));
CopyMemory(dbcgs->pValue->pszVal,pBlob+3,*(PWORD)(pBlob+1));
dbcgs->pValue->pszVal[*(PWORD)(pBlob+1)]=0;
}
break;
case DBVT_BLOB:
NeedBytes(3+*(PWORD)(pBlob+1));
if(isStatic) {
if(*(PWORD)(pBlob+1)<dbcgs->pValue->cpbVal) dbcgs->pValue->cpbVal=*(PWORD)(pBlob+1);
CopyMemory(dbcgs->pValue->pbVal,pBlob+3,dbcgs->pValue->cpbVal);
}
else {
dbcgs->pValue->pbVal=(char*)mir_alloc(*(PWORD)(pBlob+1));
CopyMemory(dbcgs->pValue->pbVal,pBlob+3,*(PWORD)(pBlob+1));
}
dbcgs->pValue->cpbVal=*(PWORD)(pBlob+1);
break;
}
/**** add to cache **********************/
if ( dbcgs->pValue->type != DBVT_BLOB )
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 1 );
if ( pCachedValue != NULL )
SetCachedVariant(dbcgs->pValue,pCachedValue);
}
LeaveCriticalSection(&csDbAccess);
logg();
return 0;
}
NeedBytes(1);
MoveAlong(pBlob[0]+1);
NeedBytes(3);
MoveAlong(1+GetSettingValueLength(pBlob));
NeedBytes(1);
} }
/**** add missing setting to cache **********************/
if ( dbcgs->pValue->type != DBVT_BLOB )
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 1 );
if ( pCachedValue != NULL )
pCachedValue->type = DBVT_DELETED;
}
LeaveCriticalSection(&csDbAccess);
logg();
return 1;
}
static INT_PTR AddEvent(WPARAM wParam,LPARAM lParam)
{
DBEVENTINFO *dbei=(DBEVENTINFO*)lParam;
struct DBContact dbc;
struct DBEvent dbe,*dbeTest;
DWORD ofsNew,ofsModuleName,ofsContact,ofsThis;
if(dbei==NULL||dbei->cbSize!=sizeof(DBEVENTINFO)) return 0;
if(dbei->timestamp==0) return 0;
if (NotifyEventHooks(hEventFilterAddedEvent,wParam,lParam)) {
return 0;
}
EnterCriticalSection(&csDbAccess);
if(wParam==0) ofsContact=dbHeader.ofsUser;
else ofsContact=wParam;
dbc=*(struct DBContact*)DBRead(ofsContact,sizeof(struct DBContact),NULL);
if(dbc.signature!=DBCONTACT_SIGNATURE) {
LeaveCriticalSection(&csDbAccess);
return 0;
}
ofsNew=CreateNewSpace(offsetof(struct DBEvent,blob)+dbei->cbBlob);
ofsModuleName=GetModuleNameOfs(dbei->szModule);
dbe.signature=DBEVENT_SIGNATURE;
dbe.ofsModuleName=ofsModuleName;
dbe.timestamp=dbei->timestamp;
dbe.flags=dbei->flags;
dbe.eventType=dbei->eventType;
dbe.cbBlob=dbei->cbBlob;
//find where to put it - sort by timestamp
if(dbc.eventCount==0) {
dbe.ofsPrev=wParam;
dbe.ofsNext=0;
dbe.flags|=DBEF_FIRST;
dbc.ofsFirstEvent=dbc.ofsLastEvent=ofsNew;
}
else {
dbeTest=(struct DBEvent*)DBRead(dbc.ofsFirstEvent,sizeof(struct DBEvent),NULL);
// Should new event be placed before first event in chain?
if (dbei->timestamp < dbeTest->timestamp) {
dbe.ofsPrev=wParam;
dbe.ofsNext=dbc.ofsFirstEvent;
dbe.flags|=DBEF_FIRST;
dbc.ofsFirstEvent=ofsNew;
dbeTest=(struct DBEvent*)DBRead(dbe.ofsNext,sizeof(struct DBEvent),NULL);
dbeTest->flags&=~DBEF_FIRST;
dbeTest->ofsPrev=ofsNew;
DBWrite(dbe.ofsNext,dbeTest,sizeof(struct DBEvent));
}
else {
// Loop through the chain, starting at the end
ofsThis = dbc.ofsLastEvent;
dbeTest = (struct DBEvent*)DBRead(ofsThis, sizeof(struct DBEvent), NULL);
for(;;) {
// If the new event's timesstamp is equal to or greater than the
// current dbevent, it will be inserted after. If not, continue
// with the previous dbevent in chain.
if (dbe.timestamp >= dbeTest->timestamp) {
dbe.ofsPrev = ofsThis;
dbe.ofsNext = dbeTest->ofsNext;
dbeTest->ofsNext = ofsNew;
DBWrite(ofsThis, dbeTest, sizeof(struct DBEvent));
if (dbe.ofsNext == 0)
dbc.ofsLastEvent = ofsNew;
else {
dbeTest = (struct DBEvent*)DBRead(dbe.ofsNext, sizeof(struct DBEvent), NULL);
dbeTest->ofsPrev = ofsNew;
DBWrite(dbe.ofsNext, dbeTest, sizeof(struct DBEvent));
}
break;
}
ofsThis = dbeTest->ofsPrev;
dbeTest = (struct DBEvent*)DBRead(ofsThis, sizeof(struct DBEvent), NULL);
}
}
}
dbc.eventCount++;
if(!(dbe.flags&(DBEF_READ|DBEF_SENT))) {
if(dbe.timestamp<dbc.timestampFirstUnread || dbc.timestampFirstUnread==0) {
dbc.timestampFirstUnread=dbe.timestamp;
dbc.ofsFirstUnreadEvent=ofsNew;
}
}
DBWrite(ofsContact,&dbc,sizeof(struct DBContact));
DBWrite(ofsNew,&dbe,offsetof(struct DBEvent,blob));
DBWrite(ofsNew+offsetof(struct DBEvent,blob),dbei->pBlob,dbei->cbBlob);
DBFlush(0);
LeaveCriticalSection(&csDbAccess);
log1("add event @ %08x",ofsNew);
NotifyEventHooks(hEventAddedEvent,wParam,(LPARAM)ofsNew);
return (INT_PTR)ofsNew;
}
STDMETHODIMP_(BOOL) CDb3Mmap::DeleteContactSetting(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting)
{
if (!szModule || !szSetting)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)mir_strlen(szSetting);
int moduleNameLen = (int)mir_strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
MCONTACT saveContact = contactID;
{
mir_cslock lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
if (szCachedSettingName[-1] == 0) { // it's not a resident variable
DWORD ofsModuleName = GetModuleNameOfs(szModule);
DWORD ofsContact = GetContactOffset(contactID);
DBContact *dbc = (DBContact*)DBRead(ofsContact, NULL);
if (dbc->signature != DBCONTACT_SIGNATURE)
return 1;
// make sure the module group exists
DWORD ofsSettingsGroup = GetSettingsGroupOfsByModuleNameOfs(dbc, ofsModuleName);
if (ofsSettingsGroup == 0)
return 1;
// find if the setting exists
DWORD ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
int bytesRemaining;
PBYTE pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
while (pBlob[0]) {
NeedBytes(settingNameLen + 1);
if (pBlob[0] == settingNameLen && !memcmp(pBlob + 1, szSetting, settingNameLen))
break;
NeedBytes(1);
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
if (!pBlob[0]) //setting didn't exist
return 1;
// bin it
MoveAlong(1 + settingNameLen);
NeedBytes(3);
int nameLen = 1 + settingNameLen;
int valLen = 1 + GetSettingValueLength(pBlob);
DWORD ofsSettingToCut = ofsBlobPtr - nameLen;
MoveAlong(valLen);
NeedBytes(1);
while (pBlob[0]) {
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
DBMoveChunk(ofsSettingToCut, ofsSettingToCut + nameLen + valLen, ofsBlobPtr + 1 - ofsSettingToCut);
DBFlush(1);
}
m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1);
}
// notify
DBCONTACTWRITESETTING dbcws = { 0 };
dbcws.szModule = szModule;
dbcws.szSetting = szSetting;
dbcws.value.type = DBVT_DELETED;
NotifyEventHooks(hSettingChangeEvent, saveContact, (LPARAM)&dbcws);
return 0;
}
int CDb3Mmap::GetContactSettingWorker(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting, DBVARIANT *dbv, int isStatic)
{
if (szSetting == NULL || szModule == NULL)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)mir_strlen(szSetting);
int moduleNameLen = (int)mir_strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 module name length. \n");
#endif
return 1;
}
mir_cslock lck(m_csDbAccess);
LBL_Seek:
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
log3("get [%08p] %s (%p)", hContact, szCachedSettingName, szCachedSettingName);
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 0);
if (pCachedValue != NULL) {
if (pCachedValue->type == DBVT_ASCIIZ || pCachedValue->type == DBVT_UTF8) {
int cbOrigLen = dbv->cchVal;
char *cbOrigPtr = dbv->pszVal;
memcpy(dbv, pCachedValue, sizeof(DBVARIANT));
if (isStatic) {
int cbLen = 0;
if (pCachedValue->pszVal != NULL)
cbLen = (int)mir_strlen(pCachedValue->pszVal);
cbOrigLen--;
dbv->pszVal = cbOrigPtr;
if (cbLen < cbOrigLen)
cbOrigLen = cbLen;
memcpy(dbv->pszVal, pCachedValue->pszVal, cbOrigLen);
dbv->pszVal[cbOrigLen] = 0;
dbv->cchVal = cbLen;
}
else {
dbv->pszVal = (char*)mir_alloc(mir_strlen(pCachedValue->pszVal) + 1);
mir_strcpy(dbv->pszVal, pCachedValue->pszVal);
}
}
else memcpy(dbv, pCachedValue, sizeof(DBVARIANT));
log2("get cached %s (%p)", printVariant(dbv), pCachedValue);
return (pCachedValue->type == DBVT_DELETED) ? 1 : 0;
}
// never look db for the resident variable
if (szCachedSettingName[-1] != 0)
return 1;
DBCachedContact *cc;
DWORD ofsContact = GetContactOffset(contactID, &cc);
DWORD ofsModuleName = GetModuleNameOfs(szModule);
DBContact dbc = *(DBContact*)DBRead(ofsContact, NULL);
if (dbc.signature != DBCONTACT_SIGNATURE)
return 1;
DWORD ofsSettingsGroup = GetSettingsGroupOfsByModuleNameOfs(&dbc, ofsModuleName);
if (ofsSettingsGroup) {
int bytesRemaining;
unsigned varLen;
DWORD ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
PBYTE pBlob = DBRead(ofsBlobPtr, &bytesRemaining);
while (pBlob[0]) {
NeedBytes(1 + settingNameLen);
if (pBlob[0] == settingNameLen && !memcmp(pBlob + 1, szSetting, settingNameLen)) {
MoveAlong(1 + settingNameLen);
NeedBytes(5);
if (isStatic && (pBlob[0] & DBVTF_VARIABLELENGTH) && VLT(dbv->type) != VLT(pBlob[0]))
return 1;
BYTE iType = dbv->type = pBlob[0];
switch (iType) {
case DBVT_DELETED: /* this setting is deleted */
dbv->type = DBVT_DELETED;
return 2;
case DBVT_BYTE: dbv->bVal = pBlob[1]; break;
case DBVT_WORD: memmove(&(dbv->wVal), (PWORD)(pBlob + 1), 2); break;
case DBVT_DWORD: memmove(&(dbv->dVal), (PDWORD)(pBlob + 1), 4); break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
varLen = *(PWORD)(pBlob + 1);
NeedBytes(int(3 + varLen));
if (isStatic) {
dbv->cchVal--;
if (varLen < dbv->cchVal)
dbv->cchVal = varLen;
memmove(dbv->pszVal, pBlob + 3, dbv->cchVal); // decode
dbv->pszVal[dbv->cchVal] = 0;
dbv->cchVal = varLen;
}
else {
dbv->pszVal = (char*)mir_alloc(1 + varLen);
memmove(dbv->pszVal, pBlob + 3, varLen);
dbv->pszVal[varLen] = 0;
}
break;
case DBVT_BLOB:
varLen = *(PWORD)(pBlob + 1);
NeedBytes(int(3 + varLen));
if (isStatic) {
if (varLen < dbv->cpbVal)
dbv->cpbVal = varLen;
memmove(dbv->pbVal, pBlob + 3, dbv->cpbVal);
}
else {
dbv->pbVal = (BYTE *)mir_alloc(varLen);
memmove(dbv->pbVal, pBlob + 3, varLen);
}
dbv->cpbVal = varLen;
break;
case DBVT_ENCRYPTED:
if (m_crypto == NULL)
return 1;
else {
varLen = *(PWORD)(pBlob + 1);
NeedBytes(int(3 + varLen));
size_t realLen;
ptrA decoded(m_crypto->decodeString(pBlob + 3, varLen, &realLen));
if (decoded == NULL)
return 1;
varLen = (WORD)realLen;
dbv->type = DBVT_UTF8;
if (isStatic) {
dbv->cchVal--;
if (varLen < dbv->cchVal)
dbv->cchVal = varLen;
memmove(dbv->pszVal, decoded, dbv->cchVal);
dbv->pszVal[dbv->cchVal] = 0;
dbv->cchVal = varLen;
}
else {
dbv->pszVal = (char*)mir_alloc(1 + varLen);
memmove(dbv->pszVal, decoded, varLen);
dbv->pszVal[varLen] = 0;
}
}
break;
}
/**** add to cache **********************/
if (iType != DBVT_BLOB && iType != DBVT_ENCRYPTED) {
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL) {
m_cache->SetCachedVariant(dbv, pCachedValue);
log3("set cached [%08p] %s (%p)", hContact, szCachedSettingName, pCachedValue);
}
}
return 0;
}
NeedBytes(1);
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
}
// try to get the missing mc setting from the active sub
if (cc && cc->IsMeta() && ValidLookupName(szModule, szSetting)) {
if (contactID = db_mc_getDefault(contactID)) {
if (szModule = GetContactProto(contactID)) {
moduleNameLen = (int)mir_strlen(szModule);
goto LBL_Seek;
}
}
}
logg();
return 1;
}
STDMETHODIMP_(BOOL) CDb3Mmap::WriteContactSetting(MCONTACT contactID, DBCONTACTWRITESETTING *dbcws)
{
if (dbcws == NULL || dbcws->szSetting == NULL || dbcws->szModule == NULL || m_bReadOnly)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)mir_strlen(dbcws->szSetting);
int moduleNameLen = (int)mir_strlen(dbcws->szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
// used for notifications
DBCONTACTWRITESETTING dbcwNotif = *dbcws;
if (dbcwNotif.value.type == DBVT_WCHAR) {
if (dbcwNotif.value.pszVal != NULL) {
char* val = mir_utf8encodeW(dbcwNotif.value.pwszVal);
if (val == NULL)
return 1;
dbcwNotif.value.pszVal = (char*)alloca(mir_strlen(val) + 1);
mir_strcpy(dbcwNotif.value.pszVal, val);
mir_free(val);
dbcwNotif.value.type = DBVT_UTF8;
}
else return 1;
}
if (dbcwNotif.szModule == NULL || dbcwNotif.szSetting == NULL)
return 1;
DBCONTACTWRITESETTING dbcwWork = dbcwNotif;
mir_ptr<BYTE> pEncoded(NULL);
bool bIsEncrypted = false;
switch (dbcwWork.value.type) {
case DBVT_BYTE: case DBVT_WORD: case DBVT_DWORD:
break;
case DBVT_ASCIIZ: case DBVT_UTF8:
bIsEncrypted = m_bEncrypted || IsSettingEncrypted(dbcws->szModule, dbcws->szSetting);
LBL_WriteString:
if (dbcwWork.value.pszVal == NULL)
return 1;
dbcwWork.value.cchVal = (WORD)mir_strlen(dbcwWork.value.pszVal);
if (bIsEncrypted) {
size_t len;
BYTE *pResult = m_crypto->encodeString(dbcwWork.value.pszVal, &len);
if (pResult != NULL) {
pEncoded = dbcwWork.value.pbVal = pResult;
dbcwWork.value.cpbVal = (WORD)len;
dbcwWork.value.type = DBVT_ENCRYPTED;
}
}
break;
case DBVT_UNENCRYPTED:
dbcwNotif.value.type = dbcwWork.value.type = DBVT_UTF8;
goto LBL_WriteString;
case DBVT_BLOB: case DBVT_ENCRYPTED:
if (dbcwWork.value.pbVal == NULL)
return 1;
break;
default:
return 1;
}
mir_cslockfull lck(m_csDbAccess);
DWORD ofsBlobPtr, ofsContact = GetContactOffset(contactID);
if (ofsContact == 0) {
_ASSERT(false); // contact doesn't exist?
return 2;
}
char *szCachedSettingName = m_cache->GetCachedSetting(dbcwWork.szModule, dbcwWork.szSetting, moduleNameLen, settingNameLen);
log3("set [%08p] %s (%p)", hContact, szCachedSettingName, szCachedSettingName);
// we don't cache blobs and passwords
if (dbcwWork.value.type != DBVT_BLOB && dbcwWork.value.type != DBVT_ENCRYPTED && !bIsEncrypted) {
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL) {
bool bIsIdentical = false;
if (pCachedValue->type == dbcwWork.value.type) {
switch (dbcwWork.value.type) {
case DBVT_BYTE: bIsIdentical = pCachedValue->bVal == dbcwWork.value.bVal; break;
case DBVT_WORD: bIsIdentical = pCachedValue->wVal == dbcwWork.value.wVal; break;
case DBVT_DWORD: bIsIdentical = pCachedValue->dVal == dbcwWork.value.dVal; break;
case DBVT_UTF8:
case DBVT_ASCIIZ: bIsIdentical = mir_strcmp(pCachedValue->pszVal, dbcwWork.value.pszVal) == 0; break;
}
if (bIsIdentical)
return 0;
}
m_cache->SetCachedVariant(&dbcwWork.value, pCachedValue);
}
if (szCachedSettingName[-1] != 0) {
lck.unlock();
log2(" set resident as %s (%p)", printVariant(&dbcwWork.value), pCachedValue);
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwWork);
return 0;
}
}
else m_cache->GetCachedValuePtr(contactID, szCachedSettingName, -1);
log1(" write database as %s", printVariant(&dbcwWork.value));
DWORD ofsModuleName = GetModuleNameOfs(dbcwWork.szModule);
DBContact dbc = *(DBContact*)DBRead(ofsContact, NULL);
if (dbc.signature != DBCONTACT_SIGNATURE)
return 1;
// make sure the module group exists
PBYTE pBlob;
int bytesRequired, bytesRemaining;
DBContactSettings dbcs;
DWORD ofsSettingsGroup = GetSettingsGroupOfsByModuleNameOfs(&dbc, ofsModuleName);
if (ofsSettingsGroup == 0) { //module group didn't exist - make it
switch (dbcwWork.value.type) {
case DBVT_ASCIIZ: case DBVT_UTF8:
bytesRequired = dbcwWork.value.cchVal + 2;
break;
case DBVT_BLOB: case DBVT_ENCRYPTED:
bytesRequired = dbcwWork.value.cpbVal + 2;
break;
default:
bytesRequired = dbcwWork.value.type;
}
bytesRequired += 2 + settingNameLen;
bytesRequired += (DB_SETTINGS_RESIZE_GRANULARITY - (bytesRequired % DB_SETTINGS_RESIZE_GRANULARITY)) % DB_SETTINGS_RESIZE_GRANULARITY;
ofsSettingsGroup = CreateNewSpace(bytesRequired + offsetof(DBContactSettings, blob));
dbcs.signature = DBCONTACTSETTINGS_SIGNATURE;
dbcs.ofsNext = dbc.ofsFirstSettings;
dbcs.ofsModuleName = ofsModuleName;
dbcs.cbBlob = bytesRequired;
dbcs.blob[0] = 0;
dbc.ofsFirstSettings = ofsSettingsGroup;
DBWrite(ofsContact, &dbc, sizeof(DBContact));
DBWrite(ofsSettingsGroup, &dbcs, sizeof(DBContactSettings));
ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
}
else {
dbcs = *(DBContactSettings*)DBRead(ofsSettingsGroup, &bytesRemaining);
// find if the setting exists
ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
while (pBlob[0]) {
NeedBytes(settingNameLen + 1);
if (pBlob[0] == settingNameLen && !memcmp(pBlob + 1, dbcwWork.szSetting, settingNameLen))
break;
NeedBytes(1);
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
// setting already existed, and up to end of name is in cache
if (pBlob[0]) {
MoveAlong(1 + settingNameLen);
// if different type or variable length and length is different
NeedBytes(3);
if (pBlob[0] != dbcwWork.value.type ||
((pBlob[0] == DBVT_ASCIIZ || pBlob[0] == DBVT_UTF8) && *(PWORD)(pBlob + 1) != dbcwWork.value.cchVal) ||
((pBlob[0] == DBVT_BLOB || pBlob[0] == DBVT_ENCRYPTED) && *(PWORD)(pBlob + 1) != dbcwWork.value.cpbVal))
{
// bin it
NeedBytes(3);
int nameLen = 1 + settingNameLen;
int valLen = 1 + GetSettingValueLength(pBlob);
DWORD ofsSettingToCut = ofsBlobPtr - nameLen;
MoveAlong(valLen);
NeedBytes(1);
while (pBlob[0]) {
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
DBMoveChunk(ofsSettingToCut, ofsSettingToCut + nameLen + valLen, ofsBlobPtr + 1 - ofsSettingToCut);
ofsBlobPtr -= nameLen + valLen;
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
}
else {
// replace existing setting at pBlob
MoveAlong(1); // skip data type
switch (dbcwWork.value.type) {
case DBVT_BYTE: DBWrite(ofsBlobPtr, &dbcwWork.value.bVal, 1); break;
case DBVT_WORD: DBWrite(ofsBlobPtr, &dbcwWork.value.wVal, 2); break;
case DBVT_DWORD: DBWrite(ofsBlobPtr, &dbcwWork.value.dVal, 4); break;
case DBVT_BLOB:
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
break;
case DBVT_ENCRYPTED:
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
break;
}
// quit
DBFlush(1);
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
}
}
// cannot do a simple replace, add setting to end of list
// pBlob already points to end of list
// see if it fits
switch (dbcwWork.value.type) {
case DBVT_ASCIIZ: case DBVT_UTF8:
bytesRequired = dbcwWork.value.cchVal + 2;
break;
case DBVT_BLOB: case DBVT_ENCRYPTED:
bytesRequired = dbcwWork.value.cpbVal + 2;
break;
default:
bytesRequired = dbcwWork.value.type;
}
bytesRequired += 2 + settingNameLen;
bytesRequired += ofsBlobPtr + 1 - (ofsSettingsGroup + offsetof(DBContactSettings, blob));
if ((DWORD)bytesRequired > dbcs.cbBlob) {
// doesn't fit: move entire group
DBContactSettings *dbcsPrev;
DWORD ofsDbcsPrev, ofsNew;
InvalidateSettingsGroupOfsCacheEntry(ofsSettingsGroup);
bytesRequired += (DB_SETTINGS_RESIZE_GRANULARITY - (bytesRequired % DB_SETTINGS_RESIZE_GRANULARITY)) % DB_SETTINGS_RESIZE_GRANULARITY;
// find previous group to change its offset
ofsDbcsPrev = dbc.ofsFirstSettings;
if (ofsDbcsPrev == ofsSettingsGroup) ofsDbcsPrev = 0;
else {
dbcsPrev = (DBContactSettings*)DBRead(ofsDbcsPrev, NULL);
while (dbcsPrev->ofsNext != ofsSettingsGroup) {
if (dbcsPrev->ofsNext == 0) DatabaseCorruption(NULL);
ofsDbcsPrev = dbcsPrev->ofsNext;
dbcsPrev = (DBContactSettings*)DBRead(ofsDbcsPrev, NULL);
}
}
// create the new one
ofsNew = ReallocSpace(ofsSettingsGroup, dbcs.cbBlob + offsetof(DBContactSettings, blob), bytesRequired + offsetof(DBContactSettings, blob));
dbcs.cbBlob = bytesRequired;
DBWrite(ofsNew, &dbcs, offsetof(DBContactSettings, blob));
if (ofsDbcsPrev == 0) {
dbc.ofsFirstSettings = ofsNew;
DBWrite(ofsContact, &dbc, sizeof(DBContact));
}
else {
dbcsPrev = (DBContactSettings*)DBRead(ofsDbcsPrev, NULL);
dbcsPrev->ofsNext = ofsNew;
DBWrite(ofsDbcsPrev, dbcsPrev, offsetof(DBContactSettings, blob));
}
ofsBlobPtr += ofsNew - ofsSettingsGroup;
ofsSettingsGroup = ofsNew;
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
}
// we now have a place to put it and enough space: make it
DBWrite(ofsBlobPtr, &settingNameLen, 1);
DBWrite(ofsBlobPtr + 1, (PVOID)dbcwWork.szSetting, settingNameLen);
MoveAlong(1 + settingNameLen);
DBWrite(ofsBlobPtr, &dbcwWork.value.type, 1);
MoveAlong(1);
switch (dbcwWork.value.type) {
case DBVT_BYTE: DBWrite(ofsBlobPtr, &dbcwWork.value.bVal, 1); MoveAlong(1); break;
case DBVT_WORD: DBWrite(ofsBlobPtr, &dbcwWork.value.wVal, 2); MoveAlong(2); break;
case DBVT_DWORD: DBWrite(ofsBlobPtr, &dbcwWork.value.dVal, 4); MoveAlong(4); break;
case DBVT_BLOB:
DBWrite(ofsBlobPtr, &dbcwWork.value.cpbVal, 2);
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
MoveAlong(2 + dbcwWork.value.cpbVal);
break;
case DBVT_ENCRYPTED:
DBWrite(ofsBlobPtr, &dbcwWork.value.cpbVal, 2);
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
MoveAlong(2 + dbcwWork.value.cpbVal);
break;
case DBVT_UTF8: case DBVT_ASCIIZ:
DBWrite(ofsBlobPtr, &dbcwWork.value.cchVal, 2);
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
MoveAlong(2 + dbcwWork.value.cchVal);
break;
}
BYTE zero = 0;
DBWrite(ofsBlobPtr, &zero, 1);
// quit
DBFlush(1);
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
STDMETHODIMP_(BOOL) CDbxMdb::WriteContactSetting(MCONTACT contactID, DBCONTACTWRITESETTING *dbcws)
{
if (dbcws == NULL || dbcws->szSetting == NULL || dbcws->szModule == NULL || m_bReadOnly)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)strlen(dbcws->szSetting);
int moduleNameLen = (int)strlen(dbcws->szModule);
// used for notifications
DBCONTACTWRITESETTING dbcwNotif = *dbcws;
if (dbcwNotif.value.type == DBVT_WCHAR)
{
if (dbcwNotif.value.pszVal != NULL)
{
char* val = mir_utf8encodeW(dbcwNotif.value.pwszVal);
if (val == NULL)
return 1;
dbcwNotif.value.pszVal = (char*)alloca(strlen(val) + 1);
strcpy(dbcwNotif.value.pszVal, val);
mir_free(val);
dbcwNotif.value.type = DBVT_UTF8;
}
else return 1;
}
if (dbcwNotif.szModule == NULL || dbcwNotif.szSetting == NULL)
return 1;
DBCONTACTWRITESETTING dbcwWork = dbcwNotif;
mir_ptr<BYTE> pEncoded(NULL);
bool bIsEncrypted = false;
switch (dbcwWork.value.type) {
case DBVT_BYTE: case DBVT_WORD: case DBVT_DWORD:
break;
case DBVT_ASCIIZ: case DBVT_UTF8:
bIsEncrypted = m_bEncrypted || IsSettingEncrypted(dbcws->szModule, dbcws->szSetting);
LBL_WriteString:
if (dbcwWork.value.pszVal == NULL)
return 1;
dbcwWork.value.cchVal = (WORD)strlen(dbcwWork.value.pszVal);
if (bIsEncrypted)
{
size_t len;
BYTE *pResult = m_crypto->encodeString(dbcwWork.value.pszVal, &len);
if (pResult != NULL)
{
pEncoded = dbcwWork.value.pbVal = pResult;
dbcwWork.value.cpbVal = (WORD)len;
dbcwWork.value.type = DBVT_ENCRYPTED;
}
}
break;
case DBVT_UNENCRYPTED:
dbcwNotif.value.type = dbcwWork.value.type = DBVT_UTF8;
goto LBL_WriteString;
case DBVT_BLOB: case DBVT_ENCRYPTED:
if (dbcwWork.value.pbVal == NULL)
return 1;
break;
default:
return 1;
}
mir_cslockfull lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(dbcwWork.szModule, dbcwWork.szSetting, moduleNameLen, settingNameLen);
// we don't cache blobs and passwords
if (dbcwWork.value.type != DBVT_BLOB && dbcwWork.value.type != DBVT_ENCRYPTED && !bIsEncrypted)
{
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL)
{
bool bIsIdentical = false;
if (pCachedValue->type == dbcwWork.value.type)
{
switch (dbcwWork.value.type) {
case DBVT_BYTE: bIsIdentical = pCachedValue->bVal == dbcwWork.value.bVal; break;
case DBVT_WORD: bIsIdentical = pCachedValue->wVal == dbcwWork.value.wVal; break;
case DBVT_DWORD: bIsIdentical = pCachedValue->dVal == dbcwWork.value.dVal; break;
case DBVT_UTF8:
case DBVT_ASCIIZ: bIsIdentical = strcmp(pCachedValue->pszVal, dbcwWork.value.pszVal) == 0; break;
}
if (bIsIdentical)
return 0;
}
m_cache->SetCachedVariant(&dbcwWork.value, pCachedValue);
}
if (szCachedSettingName[-1] != 0)
{
lck.unlock();
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwWork);
return 0;
}
}
else m_cache->GetCachedValuePtr(contactID, szCachedSettingName, -1);
DBSettingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(dbcws->szModule);
strncpy_s(keySearch.szSettingName, dbcws->szSetting, _TRUNCATE);
MDB_val key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch }, data;
switch (dbcwWork.value.type) {
case DBVT_BYTE: data.mv_size = 2; break;
case DBVT_WORD: data.mv_size = 3; break;
case DBVT_DWORD: data.mv_size = 5; break;
case DBVT_ASCIIZ:
case DBVT_UTF8:
data.mv_size = 3 + dbcwWork.value.cchVal; break;
case DBVT_BLOB:
case DBVT_ENCRYPTED:
data.mv_size = 3 + dbcwWork.value.cpbVal; break;
}
for (;; Remap()) {
txn_ptr trnlck(m_pMdbEnv);
MDB_CHECK(mdb_put(trnlck, m_dbSettings, &key, &data, MDB_RESERVE), 1);
BYTE *pBlob = (BYTE*)data.mv_data;
*pBlob++ = dbcwWork.value.type;
switch (dbcwWork.value.type) {
case DBVT_BYTE: *pBlob = dbcwWork.value.bVal; break;
case DBVT_WORD: *(WORD*)pBlob = dbcwWork.value.wVal; break;
case DBVT_DWORD: *(DWORD*)pBlob = dbcwWork.value.dVal; break;
case DBVT_ASCIIZ:
case DBVT_UTF8:
data.mv_size = *(WORD*)pBlob = dbcwWork.value.cchVal;
pBlob += 2;
memcpy(pBlob, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
break;
case DBVT_BLOB:
case DBVT_ENCRYPTED:
data.mv_size = *(WORD*)pBlob = dbcwWork.value.cpbVal;
pBlob += 2;
memcpy(pBlob, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
}
if (trnlck.commit())
break;
}
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
int CDbxKV::GetContactSettingWorker(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting, DBVARIANT *dbv, int isStatic)
{
if (szSetting == NULL || szModule == NULL)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)strlen(szSetting);
int moduleNameLen = (int)strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 module name length. \n");
#endif
return 1;
}
mir_cslock lck(m_csDbAccess);
LBL_Seek:
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 0);
if (pCachedValue != NULL) {
if (pCachedValue->type == DBVT_ASCIIZ || pCachedValue->type == DBVT_UTF8) {
int cbOrigLen = dbv->cchVal;
char *cbOrigPtr = dbv->pszVal;
memcpy(dbv, pCachedValue, sizeof(DBVARIANT));
if (isStatic) {
int cbLen = 0;
if (pCachedValue->pszVal != NULL)
cbLen = (int)strlen(pCachedValue->pszVal);
cbOrigLen--;
dbv->pszVal = cbOrigPtr;
if (cbLen < cbOrigLen)
cbOrigLen = cbLen;
memcpy(dbv->pszVal, pCachedValue->pszVal, cbOrigLen);
dbv->pszVal[cbOrigLen] = 0;
dbv->cchVal = cbLen;
}
else {
dbv->pszVal = (char*)mir_alloc(strlen(pCachedValue->pszVal) + 1);
strcpy(dbv->pszVal, pCachedValue->pszVal);
}
}
else memcpy(dbv, pCachedValue, sizeof(DBVARIANT));
return (pCachedValue->type == DBVT_DELETED) ? 1 : 0;
}
// never look db for the resident variable
if (szCachedSettingName[-1] != 0)
return 1;
DBCachedContact *cc = (contactID) ? m_cache->GetCachedContact(contactID) : NULL;
DBSettingSortingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(szModule);
strncpy_s(keySearch.szSettingName, szSetting, _TRUNCATE);
ham_key_t key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch };
ham_record_t rec = { 0 };
if (ham_db_find(m_dbSettings, NULL, &key, &rec, 0)) {
// try to get the missing mc setting from the active sub
if (cc && cc->IsMeta() && ValidLookupName(szModule, szSetting)) {
if (contactID = db_mc_getDefault(contactID)) {
if (szModule = GetContactProto(contactID)) {
moduleNameLen = (int)strlen(szModule);
goto LBL_Seek;
}
}
}
return 1;
}
BYTE *pBlob = (BYTE*)rec.data;
if (isStatic && (pBlob[0] & DBVTF_VARIABLELENGTH) && VLT(dbv->type) != VLT(pBlob[0]))
return 1;
int varLen;
BYTE iType = dbv->type = pBlob[0]; pBlob++;
switch (iType) {
case DBVT_DELETED: /* this setting is deleted */
dbv->type = DBVT_DELETED;
return 2;
case DBVT_BYTE: dbv->bVal = *pBlob; break;
case DBVT_WORD: dbv->wVal = *(WORD*)pBlob; break;
case DBVT_DWORD: dbv->dVal = *(DWORD*)pBlob; break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
varLen = *(WORD*)pBlob;
pBlob += 2;
if (isStatic) {
dbv->cchVal--;
if (varLen < dbv->cchVal)
dbv->cchVal = varLen;
memmove(dbv->pszVal, pBlob, dbv->cchVal); // decode
dbv->pszVal[dbv->cchVal] = 0;
dbv->cchVal = varLen;
}
else {
dbv->pszVal = (char*)mir_alloc(1 + varLen);
memmove(dbv->pszVal, pBlob, varLen);
dbv->pszVal[varLen] = 0;
}
break;
case DBVT_BLOB:
varLen = *(WORD*)pBlob;
pBlob += 2;
if (isStatic) {
if (varLen < dbv->cpbVal)
dbv->cpbVal = varLen;
memmove(dbv->pbVal, pBlob, dbv->cpbVal);
}
else {
dbv->pbVal = (BYTE *)mir_alloc(varLen);
memmove(dbv->pbVal, pBlob, varLen);
}
dbv->cpbVal = varLen;
break;
case DBVT_ENCRYPTED:
if (m_crypto == NULL)
return 1;
varLen = *(WORD*)pBlob;
pBlob += 2;
size_t realLen;
ptrA decoded(m_crypto->decodeString(pBlob, varLen, &realLen));
if (decoded == NULL)
return 1;
varLen = (WORD)realLen;
dbv->type = DBVT_UTF8;
if (isStatic) {
dbv->cchVal--;
if (varLen < dbv->cchVal)
dbv->cchVal = varLen;
memmove(dbv->pszVal, decoded, dbv->cchVal);
dbv->pszVal[dbv->cchVal] = 0;
dbv->cchVal = varLen;
}
else {
dbv->pszVal = (char*)mir_alloc(1 + varLen);
memmove(dbv->pszVal, decoded, varLen);
dbv->pszVal[varLen] = 0;
}
break;
}
/**** add to cache **********************/
if (iType != DBVT_BLOB && iType != DBVT_ENCRYPTED) {
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL)
m_cache->SetCachedVariant(dbv, pCachedValue);
}
return 0;
}
STDMETHODIMP_(BOOL) CDbxKV::WriteContactSetting(MCONTACT contactID, DBCONTACTWRITESETTING *dbcws)
{
if (dbcws == NULL || dbcws->szSetting == NULL || dbcws->szModule == NULL || m_bReadOnly)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)strlen(dbcws->szSetting);
int moduleNameLen = (int)strlen(dbcws->szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
// used for notifications
DBCONTACTWRITESETTING dbcwNotif = *dbcws;
if (dbcwNotif.value.type == DBVT_WCHAR) {
if (dbcwNotif.value.pszVal != NULL) {
char* val = mir_utf8encodeW(dbcwNotif.value.pwszVal);
if (val == NULL)
return 1;
dbcwNotif.value.pszVal = (char*)alloca(strlen(val) + 1);
strcpy(dbcwNotif.value.pszVal, val);
mir_free(val);
dbcwNotif.value.type = DBVT_UTF8;
}
else return 1;
}
if (dbcwNotif.szModule == NULL || dbcwNotif.szSetting == NULL)
return 1;
DBCONTACTWRITESETTING dbcwWork = dbcwNotif;
mir_ptr<BYTE> pEncoded(NULL);
bool bIsEncrypted = false;
switch (dbcwWork.value.type) {
case DBVT_BYTE: case DBVT_WORD: case DBVT_DWORD:
break;
case DBVT_ASCIIZ: case DBVT_UTF8:
bIsEncrypted = m_bEncrypted || IsSettingEncrypted(dbcws->szModule, dbcws->szSetting);
LBL_WriteString:
if (dbcwWork.value.pszVal == NULL)
return 1;
dbcwWork.value.cchVal = (WORD)strlen(dbcwWork.value.pszVal);
if (bIsEncrypted) {
size_t len;
BYTE *pResult = m_crypto->encodeString(dbcwWork.value.pszVal, &len);
if (pResult != NULL) {
pEncoded = dbcwWork.value.pbVal = pResult;
dbcwWork.value.cpbVal = (WORD)len;
dbcwWork.value.type = DBVT_ENCRYPTED;
}
}
break;
case DBVT_UNENCRYPTED:
dbcwNotif.value.type = dbcwWork.value.type = DBVT_UTF8;
goto LBL_WriteString;
case DBVT_BLOB: case DBVT_ENCRYPTED:
if (dbcwWork.value.pbVal == NULL)
return 1;
break;
default:
return 1;
}
mir_cslockfull lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(dbcwWork.szModule, dbcwWork.szSetting, moduleNameLen, settingNameLen);
// we don't cache blobs and passwords
if (dbcwWork.value.type != DBVT_BLOB && dbcwWork.value.type != DBVT_ENCRYPTED && !bIsEncrypted) {
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL) {
bool bIsIdentical = false;
if (pCachedValue->type == dbcwWork.value.type) {
switch (dbcwWork.value.type) {
case DBVT_BYTE: bIsIdentical = pCachedValue->bVal == dbcwWork.value.bVal; break;
case DBVT_WORD: bIsIdentical = pCachedValue->wVal == dbcwWork.value.wVal; break;
case DBVT_DWORD: bIsIdentical = pCachedValue->dVal == dbcwWork.value.dVal; break;
case DBVT_UTF8:
case DBVT_ASCIIZ: bIsIdentical = strcmp(pCachedValue->pszVal, dbcwWork.value.pszVal) == 0; break;
}
if (bIsIdentical)
return 0;
}
m_cache->SetCachedVariant(&dbcwWork.value, pCachedValue);
}
if (szCachedSettingName[-1] != 0) {
lck.unlock();
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwWork);
return 0;
}
}
else m_cache->GetCachedValuePtr(contactID, szCachedSettingName, -1);
DBSettingSortingKey keySearch;
keySearch.dwContactID = contactID;
keySearch.dwOfsModule = GetModuleNameOfs(dbcws->szModule);
strncpy_s(keySearch.szSettingName, dbcws->szSetting, _TRUNCATE);
ham_key_t key = { 2 * sizeof(DWORD) + settingNameLen, &keySearch };
ham_record_t rec = { 0 };
switch (dbcwWork.value.type) {
case DBVT_BYTE: rec.size = 2; break;
case DBVT_WORD: rec.size = 3; break;
case DBVT_DWORD: rec.size = 5; break;
case DBVT_ASCIIZ:
case DBVT_UTF8:
rec.size = 3 + dbcwWork.value.cchVal; break;
case DBVT_BLOB:
case DBVT_ENCRYPTED:
rec.size = 3 + dbcwWork.value.cpbVal; break;
default:
return 1;
}
rec.data = _alloca(rec.size);
BYTE *pBlob = (BYTE*)rec.data;
*pBlob++ = dbcwWork.value.type;
switch (dbcwWork.value.type) {
case DBVT_BYTE: *pBlob = dbcwWork.value.bVal; break;
case DBVT_WORD: *(WORD*)pBlob = dbcwWork.value.wVal; break;
case DBVT_DWORD: *(DWORD*)pBlob = dbcwWork.value.dVal; break;
case DBVT_ASCIIZ:
case DBVT_UTF8:
*(WORD*)pBlob = dbcwWork.value.cchVal;
memcpy(pBlob+2, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
break;
case DBVT_BLOB:
case DBVT_ENCRYPTED:
*(WORD*)pBlob = dbcwWork.value.cpbVal;
memcpy(pBlob+2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
}
ham_db_insert(m_dbSettings, NULL, &key, &rec, HAM_OVERWRITE);
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
STDMETHODIMP_(MEVENT) CDbxKyoto::AddEvent(MCONTACT contactID, DBEVENTINFO *dbei)
{
if (dbei == NULL || dbei->cbSize != sizeof(DBEVENTINFO)) return 0;
if (dbei->timestamp == 0) return 0;
DBEvent dbe;
dbe.dwSignature = DBEVENT_SIGNATURE;
dbe.contactID = contactID; // store native or subcontact's id
dbe.ofsModuleName = GetModuleNameOfs(dbei->szModule);
dbe.timestamp = dbei->timestamp;
dbe.flags = dbei->flags;
dbe.wEventType = dbei->eventType;
dbe.cbBlob = dbei->cbBlob;
BYTE *pBlob = dbei->pBlob;
MCONTACT contactNotifyID = contactID;
DBCachedContact *cc, *ccSub = NULL;
if ((cc = m_cache->GetCachedContact(contactID)) == NULL)
return 0;
if (cc->IsSub()) {
ccSub = cc;
if ((cc = m_cache->GetCachedContact(cc->parentID)) == NULL)
return 0;
// set default sub to the event's source
if (!(dbei->flags & DBEF_SENT))
db_mc_setDefault(cc->contactID, contactID, false);
contactID = cc->contactID; // and add an event to a metahistory
if (db_mc_isEnabled())
contactNotifyID = contactID;
}
if (m_safetyMode)
if (NotifyEventHooks(hEventFilterAddedEvent, contactNotifyID, (LPARAM)dbei))
return NULL;
mir_ptr<BYTE> pCryptBlob;
if (m_bEncrypted) {
size_t len;
BYTE *pResult = m_crypto->encodeBuffer(pBlob, dbe.cbBlob, &len);
if (pResult != NULL) {
pCryptBlob = pBlob = pResult;
dbe.cbBlob = (DWORD)len;
dbe.flags |= DBEF_ENCRYPTED;
}
}
DWORD dwEventId;
{
mir_cslock lck(m_csDbAccess);
dwEventId = ++m_dwMaxEventId;
BYTE *pDest = (BYTE*)_alloca(sizeof(DBEvent) + dbe.cbBlob);
memcpy(pDest, &dbe, sizeof(DBEvent));
memcpy(pDest + sizeof(DBEvent), pBlob, dbe.cbBlob);
m_dbEvents.set((LPCSTR)&dwEventId, sizeof(int), (LPCSTR)pDest, sizeof(DBEvent) + dbe.cbBlob);
// add a sorting key
DBEventSortingKey key2 = { contactID, dbe.timestamp, dwEventId };
m_dbEventsSort.set((LPCSTR)&key2, sizeof(key2), "", 1);
cc->Advance(dwEventId, dbe);
m_dbContacts.set((LPCSTR)&contactID, sizeof(int), (LPCSTR)&cc->dbc, sizeof(DBContact));
// insert an event into a sub's history too
if (ccSub != NULL) {
key2.dwContactId = ccSub->contactID;
m_dbEventsSort.set((LPCSTR)&key2, sizeof(key2), "", 1);
ccSub->Advance(dwEventId, dbe);
m_dbContacts.set((LPCSTR)&ccSub->contactID, sizeof(int), (LPCSTR)&ccSub->dbc, sizeof(DBContact));
}
}
// Notify only in safe mode or on really new events
if (m_safetyMode)
NotifyEventHooks(hEventAddedEvent, contactNotifyID, dwEventId);
return dwEventId;
}
static __inline int GetContactSettingWorker(HANDLE hContact,DBCONTACTGETSETTING *dbcgs,int isStatic)
{
struct DBContact *dbc;
DWORD ofsModuleName,ofsContact,ofsSettingsGroup,ofsBlobPtr;
int settingNameLen,moduleNameLen;
int bytesRemaining;
PBYTE pBlob;
char* szCachedSettingName;
if ((!dbcgs->szSetting) || (!dbcgs->szModule))
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
settingNameLen = (int)strlen(dbcgs->szSetting);
moduleNameLen = (int)strlen(dbcgs->szModule);
if ( settingNameLen > 0xFE )
{
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 setting name length. \n");
#endif
return 1;
}
if ( moduleNameLen > 0xFE )
{
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 module name length. \n");
#endif
return 1;
}
EnterCriticalSection(&csDbAccess);
log3("get [%08p] %s/%s",hContact,dbcgs->szModule,dbcgs->szSetting);
szCachedSettingName = GetCachedSetting(dbcgs->szModule,dbcgs->szSetting,moduleNameLen,settingNameLen);
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 0 );
if ( pCachedValue != NULL ) {
if ( pCachedValue->type == DBVT_ASCIIZ || pCachedValue->type == DBVT_UTF8 ) {
int cbOrigLen = dbcgs->pValue->cchVal;
char* cbOrigPtr = dbcgs->pValue->pszVal;
memcpy( dbcgs->pValue, pCachedValue, sizeof( DBVARIANT ));
if ( isStatic ) {
int cbLen = 0;
if ( pCachedValue->pszVal != NULL )
cbLen = (int)strlen( pCachedValue->pszVal );
cbOrigLen--;
dbcgs->pValue->pszVal = cbOrigPtr;
if(cbLen<cbOrigLen) cbOrigLen=cbLen;
CopyMemory(dbcgs->pValue->pszVal,pCachedValue->pszVal,cbOrigLen);
dbcgs->pValue->pszVal[cbOrigLen]=0;
dbcgs->pValue->cchVal=cbLen;
}
else {
dbcgs->pValue->pszVal = (char*)mir_alloc(strlen(pCachedValue->pszVal)+1);
strcpy(dbcgs->pValue->pszVal,pCachedValue->pszVal);
}
}
else
memcpy( dbcgs->pValue, pCachedValue, sizeof( DBVARIANT ));
switch( dbcgs->pValue->type ) {
case DBVT_BYTE: log1( "get cached byte: %d", dbcgs->pValue->bVal ); break;
case DBVT_WORD: log1( "get cached word: %d", dbcgs->pValue->wVal ); break;
case DBVT_DWORD: log1( "get cached dword: %d", dbcgs->pValue->dVal ); break;
case DBVT_UTF8:
case DBVT_ASCIIZ: log1( "get cached string: '%s'", dbcgs->pValue->pszVal); break;
default: log1( "get cached crap: %d", dbcgs->pValue->type ); break;
}
LeaveCriticalSection(&csDbAccess);
return ( pCachedValue->type == DBVT_DELETED ) ? 1 : 0;
} }
ofsModuleName=GetModuleNameOfs(dbcgs->szModule);
if(hContact==NULL) ofsContact=dbHeader.ofsUser;
else ofsContact=(DWORD)hContact;
dbc=(struct DBContact*)DBRead(ofsContact,sizeof(struct DBContact),NULL);
if(dbc->signature!=DBCONTACT_SIGNATURE) {
LeaveCriticalSection(&csDbAccess);
return 1;
}
ofsSettingsGroup=GetSettingsGroupOfsByModuleNameOfs(dbc,ofsModuleName);
if(ofsSettingsGroup) {
ofsBlobPtr=ofsSettingsGroup+offsetof(struct DBContactSettings,blob);
pBlob = DBRead(ofsBlobPtr,sizeof(struct DBContactSettings),&bytesRemaining);
while(pBlob[0]) {
NeedBytes(1+settingNameLen);
if(pBlob[0]==settingNameLen && !memcmp(pBlob+1,dbcgs->szSetting,settingNameLen)) {
MoveAlong(1+settingNameLen);
NeedBytes(5);
if(isStatic && pBlob[0]&DBVTF_VARIABLELENGTH && VLT(dbcgs->pValue->type) != VLT(pBlob[0])) {
LeaveCriticalSection(&csDbAccess);
return 1;
}
dbcgs->pValue->type=pBlob[0];
switch(pBlob[0]) {
case DBVT_DELETED: { /* this setting is deleted */
dbcgs->pValue->type=DBVT_DELETED;
LeaveCriticalSection(&csDbAccess);
return 2;
}
case DBVT_BYTE: dbcgs->pValue->bVal=pBlob[1]; break;
case DBVT_WORD: DecodeCopyMemory(&(dbcgs->pValue->wVal), (PWORD)(pBlob+1), 2); break;
case DBVT_DWORD: DecodeCopyMemory(&(dbcgs->pValue->dVal), (PDWORD)(pBlob+1), 4); break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
NeedBytes(3+*(PWORD)(pBlob+1));
if(isStatic) {
dbcgs->pValue->cchVal--;
if(*(PWORD)(pBlob+1)<dbcgs->pValue->cchVal) dbcgs->pValue->cchVal=*(PWORD)(pBlob+1);
DecodeCopyMemory(dbcgs->pValue->pszVal,pBlob+3,dbcgs->pValue->cchVal);
dbcgs->pValue->pszVal[dbcgs->pValue->cchVal]=0;
dbcgs->pValue->cchVal=*(PWORD)(pBlob+1);
}
else {
dbcgs->pValue->pszVal=(char*)mir_alloc(1+*(PWORD)(pBlob+1));
DecodeCopyMemory(dbcgs->pValue->pszVal,pBlob+3,*(PWORD)(pBlob+1));
dbcgs->pValue->pszVal[*(PWORD)(pBlob+1)]=0;
}
break;
case DBVT_BLOB:
NeedBytes(3+*(PWORD)(pBlob+1));
if(isStatic) {
if(*(PWORD)(pBlob+1)<dbcgs->pValue->cpbVal) dbcgs->pValue->cpbVal=*(PWORD)(pBlob+1);
DecodeCopyMemory(dbcgs->pValue->pbVal,pBlob+3,dbcgs->pValue->cpbVal);
}
else {
dbcgs->pValue->pbVal=(char*)mir_alloc(*(PWORD)(pBlob+1));
DecodeCopyMemory(dbcgs->pValue->pbVal,pBlob+3,*(PWORD)(pBlob+1));
}
dbcgs->pValue->cpbVal=*(PWORD)(pBlob+1);
break;
}
/**** add to cache **********************/
if ( dbcgs->pValue->type != DBVT_BLOB )
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 1 );
if ( pCachedValue != NULL )
SetCachedVariant(dbcgs->pValue,pCachedValue);
}
LeaveCriticalSection(&csDbAccess);
logg();
return 0;
}
NeedBytes(1);
MoveAlong(pBlob[0]+1);
NeedBytes(3);
MoveAlong(1+GetSettingValueLength(pBlob));
NeedBytes(1);
} }
/**** nullbie: query info from preset **********************/
if (!hContact && DBPreset_QuerySetting(dbcgs->szModule, dbcgs->szSetting, dbcgs->pValue, isStatic))
{
/**** add to cache **********************/
if ( dbcgs->pValue->type != DBVT_BLOB )
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 1 );
if ( pCachedValue != NULL )
SetCachedVariant(dbcgs->pValue,pCachedValue);
}
return 0;
}
/**** add missing setting to cache **********************/
if ( dbcgs->pValue->type != DBVT_BLOB )
{
DBVARIANT* pCachedValue = GetCachedValuePtr( hContact, szCachedSettingName, 1 );
if ( pCachedValue != NULL )
pCachedValue->type = DBVT_DELETED;
}
LeaveCriticalSection(&csDbAccess);
logg();
return 1;
}
static INT_PTR WriteContactSetting(WPARAM wParam, LPARAM lParam)
{
DBCONTACTWRITESETTING *dbcws=(DBCONTACTWRITESETTING*)lParam;
DBCONTACTWRITESETTING tmp;
struct DBContact dbc;
DWORD ofsModuleName;
struct DBContactSettings dbcs;
PBYTE pBlob;
int settingNameLen=0;
int moduleNameLen=0;
int settingDataLen=0;
int bytesRequired,bytesRemaining;
DWORD ofsContact,ofsSettingsGroup,ofsBlobPtr;
if (dbcws == NULL || dbcws->szSetting==NULL || dbcws->szModule==NULL )
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
settingNameLen=(int)strlen(dbcws->szSetting);
moduleNameLen=(int)strlen(dbcws->szModule);
if ( settingNameLen > 0xFE )
{
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if ( moduleNameLen > 0xFE )
{
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
tmp = *dbcws;
if (tmp.value.type == DBVT_WCHAR) {
if (tmp.value.pszVal != NULL) {
char* val = mir_utf8encodeW(tmp.value.pwszVal);
if ( val == NULL )
return 1;
tmp.value.pszVal = ( char* )_malloca( strlen( val )+1 );
strcpy( tmp.value.pszVal, val );
mir_free(val);
tmp.value.type = DBVT_UTF8;
}
else return 1;
}
if(tmp.value.type!=DBVT_BYTE && tmp.value.type!=DBVT_WORD && tmp.value.type!=DBVT_DWORD && tmp.value.type!=DBVT_ASCIIZ && tmp.value.type!=DBVT_UTF8 && tmp.value.type!=DBVT_BLOB)
return 1;
if ((!tmp.szModule) || (!tmp.szSetting) || ((tmp.value.type == DBVT_ASCIIZ || tmp.value.type == DBVT_UTF8 )&& tmp.value.pszVal == NULL) || (tmp.value.type == DBVT_BLOB && tmp.value.pbVal == NULL) )
return 1;
// the db can not tolerate strings/blobs longer than 0xFFFF since the format writes 2 lengths
switch( tmp.value.type ) {
case DBVT_ASCIIZ: case DBVT_BLOB: case DBVT_UTF8:
{ size_t len = ( tmp.value.type != DBVT_BLOB ) ? (int)strlen(tmp.value.pszVal) : tmp.value.cpbVal;
if ( len >= 0xFFFF ) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() writing huge string/blob, rejecting ( >= 0xFFFF ) \n");
#endif
return 1;
}
}
}
EnterCriticalSection(&csDbAccess);
{
char* szCachedSettingName = GetCachedSetting(tmp.szModule, tmp.szSetting, moduleNameLen, settingNameLen);
if ( tmp.value.type != DBVT_BLOB ) {
DBVARIANT* pCachedValue = GetCachedValuePtr((HANDLE)wParam, szCachedSettingName, 1);
if ( pCachedValue != NULL ) {
BOOL bIsIdentical = FALSE;
if ( pCachedValue->type == tmp.value.type ) {
switch(tmp.value.type) {
case DBVT_BYTE: bIsIdentical = pCachedValue->bVal == tmp.value.bVal; break;
case DBVT_WORD: bIsIdentical = pCachedValue->wVal == tmp.value.wVal; break;
case DBVT_DWORD: bIsIdentical = pCachedValue->dVal == tmp.value.dVal; break;
case DBVT_UTF8:
case DBVT_ASCIIZ: bIsIdentical = strcmp( pCachedValue->pszVal, tmp.value.pszVal ) == 0; break;
}
if ( bIsIdentical ) {
LeaveCriticalSection(&csDbAccess);
return 0;
}
}
SetCachedVariant(&tmp.value, pCachedValue);
}
if ( szCachedSettingName[-1] != 0 ) {
LeaveCriticalSection(&csDbAccess);
NotifyEventHooks(hSettingChangeEvent,wParam,(LPARAM)&tmp);
return 0;
}
}
else GetCachedValuePtr((HANDLE)wParam, szCachedSettingName, -1);
}
ofsModuleName=GetModuleNameOfs(tmp.szModule);
if(wParam==0) ofsContact=dbHeader.ofsUser;
else ofsContact=wParam;
dbc=*(struct DBContact*)DBRead(ofsContact,sizeof(struct DBContact),NULL);
if(dbc.signature!=DBCONTACT_SIGNATURE) {
LeaveCriticalSection(&csDbAccess);
return 1;
}
log0("write setting");
//make sure the module group exists
ofsSettingsGroup=GetSettingsGroupOfsByModuleNameOfs(&dbc,ofsModuleName);
if(ofsSettingsGroup==0) { //module group didn't exist - make it
if(tmp.value.type&DBVTF_VARIABLELENGTH) {
if(tmp.value.type==DBVT_ASCIIZ || tmp.value.type==DBVT_UTF8) bytesRequired = (int)strlen(tmp.value.pszVal)+2;
else if(tmp.value.type==DBVT_BLOB) bytesRequired=tmp.value.cpbVal+2;
}
else bytesRequired=tmp.value.type;
bytesRequired+=2+settingNameLen;
bytesRequired+=(DB_SETTINGS_RESIZE_GRANULARITY-(bytesRequired%DB_SETTINGS_RESIZE_GRANULARITY))%DB_SETTINGS_RESIZE_GRANULARITY;
ofsSettingsGroup=CreateNewSpace(bytesRequired+offsetof(struct DBContactSettings,blob));
dbcs.signature=DBCONTACTSETTINGS_SIGNATURE;
dbcs.ofsNext=dbc.ofsFirstSettings;
dbcs.ofsModuleName=ofsModuleName;
dbcs.cbBlob=bytesRequired;
dbcs.blob[0]=0;
dbc.ofsFirstSettings=ofsSettingsGroup;
DBWrite(ofsContact,&dbc,sizeof(struct DBContact));
DBWrite(ofsSettingsGroup,&dbcs,sizeof(struct DBContactSettings));
ofsBlobPtr=ofsSettingsGroup+offsetof(struct DBContactSettings,blob);
pBlob=(PBYTE)DBRead(ofsBlobPtr,1,&bytesRemaining);
}
else {
STDMETHODIMP_(HANDLE) CDb3Mmap::AddEvent(MCONTACT contactID, DBEVENTINFO *dbei)
{
if (dbei == NULL || dbei->cbSize != sizeof(DBEVENTINFO)) return 0;
if (dbei->timestamp == 0) return 0;
DBEvent dbe;
dbe.signature = DBEVENT_SIGNATURE;
dbe.contactID = contactID; // store native or subcontact's id
dbe.timestamp = dbei->timestamp;
dbe.flags = dbei->flags;
dbe.wEventType = dbei->eventType;
dbe.cbBlob = dbei->cbBlob;
BYTE *pBlob = dbei->pBlob;
MCONTACT contactNotifyID = contactID;
DBCachedContact *ccSub = NULL;
if (contactID != 0) {
DBCachedContact *cc = m_cache->GetCachedContact(contactID);
if (cc == NULL)
return NULL;
if (cc->IsSub()) {
ccSub = cc;
// set default sub to the event's source
db_mc_setDefault(cc->parentID, contactID, false);
contactID = cc->parentID; // and add an event to a metahistory
if (db_mc_isEnabled())
contactNotifyID = contactID;
}
}
if (NotifyEventHooks(hEventFilterAddedEvent, contactNotifyID, (LPARAM)dbei))
return NULL;
mir_ptr<BYTE> pCryptBlob;
if (m_bEncrypted) {
size_t len;
BYTE *pResult = m_crypto->encodeBuffer(pBlob, dbe.cbBlob, &len);
if (pResult != NULL) {
pCryptBlob = pBlob = pResult;
dbe.cbBlob = (DWORD)len;
dbe.flags |= DBEF_ENCRYPTED;
}
}
bool neednotify;
mir_cslockfull lck(m_csDbAccess);
DWORD ofsContact = GetContactOffset(contactID);
DBContact dbc = *(DBContact*)DBRead(ofsContact, sizeof(DBContact), NULL);
if (dbc.signature != DBCONTACT_SIGNATURE)
return NULL;
DWORD ofsNew = CreateNewSpace(offsetof(DBEvent, blob) + dbe.cbBlob);
dbe.ofsModuleName = GetModuleNameOfs(dbei->szModule);
// find where to put it - sort by timestamp
if (dbc.eventCount == 0) {
dbe.ofsPrev = dbe.ofsNext = 0;
dbc.ofsFirstEvent = dbc.ofsLastEvent = ofsNew;
}
else {
DBEvent *dbeTest = (DBEvent*)DBRead(dbc.ofsFirstEvent, sizeof(DBEvent), NULL);
// Should new event be placed before first event in chain?
if (dbe.timestamp < dbeTest->timestamp) {
dbe.ofsPrev = 0;
dbe.ofsNext = dbc.ofsFirstEvent;
dbc.ofsFirstEvent = ofsNew;
dbeTest = (DBEvent*)DBRead(dbe.ofsNext, sizeof(DBEvent), NULL);
dbeTest->ofsPrev = ofsNew;
DBWrite(dbe.ofsNext, dbeTest, sizeof(DBEvent));
}
else {
// Loop through the chain, starting at the end
DWORD ofsThis = dbc.ofsLastEvent;
dbeTest = (DBEvent*)DBRead(ofsThis, sizeof(DBEvent), NULL);
for (;;) {
// If the new event's timesstamp is equal to or greater than the
// current dbevent, it will be inserted after. If not, continue
// with the previous dbevent in chain.
if (dbe.timestamp >= dbeTest->timestamp) {
dbe.ofsPrev = ofsThis;
dbe.ofsNext = dbeTest->ofsNext;
dbeTest->ofsNext = ofsNew;
DBWrite(ofsThis, dbeTest, sizeof(DBEvent));
if (dbe.ofsNext == 0)
dbc.ofsLastEvent = ofsNew;
else {
dbeTest = (DBEvent*)DBRead(dbe.ofsNext, sizeof(DBEvent), NULL);
dbeTest->ofsPrev = ofsNew;
DBWrite(dbe.ofsNext, dbeTest, sizeof(DBEvent));
}
break;
}
ofsThis = dbeTest->ofsPrev;
dbeTest = (DBEvent*)DBRead(ofsThis, sizeof(DBEvent), NULL);
}
}
}
dbc.eventCount++;
if (!(dbe.flags & (DBEF_READ | DBEF_SENT))) {
if (dbe.timestamp < dbc.tsFirstUnread || dbc.tsFirstUnread == 0) {
dbc.tsFirstUnread = dbe.timestamp;
dbc.ofsFirstUnread = ofsNew;
}
neednotify = true;
}
else neednotify = m_safetyMode;
if (ccSub != NULL) {
DBContact *pSub = (DBContact*)DBRead(ccSub->dwDriverData, sizeof(DBContact), NULL);
pSub->eventCount++;
}
DBWrite(ofsContact, &dbc, sizeof(DBContact));
DBWrite(ofsNew, &dbe, offsetof(DBEvent, blob));
DBWrite(ofsNew + offsetof(DBEvent, blob), pBlob, dbe.cbBlob);
DBFlush(0);
lck.unlock();
log1("add event @ %08x", ofsNew);
// Notify only in safe mode or on really new events
if (neednotify)
NotifyEventHooks(hEventAddedEvent, contactNotifyID, (LPARAM)ofsNew);
return (HANDLE)ofsNew;
}
