int WorkSettingsChain(DWORD ofsContact,DBContact *dbc,int firstTime)
{
DBContactSettings *dbcsNew,dbcsOld;
DWORD ofsDestThis;
int ret;
if(firstTime) {
ofsDestPrevSettings=0;
ofsThisSettings=dbc->ofsFirstSettings;
dbc->ofsFirstSettings=0;
}
if(ofsThisSettings==0)
return ERROR_NO_MORE_ITEMS;
if(!SignatureValid(ofsThisSettings,DBCONTACTSETTINGS_SIGNATURE)) {
AddToStatus(STATUS_ERROR,TranslateT("Settings chain corrupted, further entries ignored"));
return ERROR_NO_MORE_ITEMS;
}
if(PeekSegment(ofsThisSettings,&dbcsOld,sizeof(dbcsOld))!=ERROR_SUCCESS)
return ERROR_NO_MORE_ITEMS;
if(dbcsOld.cbBlob>256*1024 || dbcsOld.cbBlob==0) {
AddToStatus(STATUS_ERROR,TranslateT("Infeasibly large settings blob: skipping"));
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
dbcsNew=(DBContactSettings*)_malloca(offsetof(DBContactSettings,blob)+dbcsOld.cbBlob);
if((ret=ReadSegment(ofsThisSettings,dbcsNew,offsetof(DBContactSettings,blob)+dbcsOld.cbBlob))!=ERROR_SUCCESS) {
if(ret!=ERROR_HANDLE_EOF) { //eof is OK because blank space at the end doesn't matter
return ERROR_NO_MORE_ITEMS;
}
}
if((dbcsNew->ofsModuleName=ConvertModuleNameOfs(dbcsOld.ofsModuleName))==0) {
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
if(dbcsNew->blob[0]==0) {
AddToStatus(STATUS_MESSAGE,TranslateT("Empty settings group at %08X: deleting"),ofsThisSettings);
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
dbcsNew->ofsNext=0;
//TODO? validate all settings in blob/compact if necessary
if((ofsDestThis=WriteSegment(WSOFS_END,dbcsNew,offsetof(DBContactSettings,blob)+dbcsNew->cbBlob))==WS_ERROR) {
return ERROR_HANDLE_DISK_FULL;
}
if(ofsDestPrevSettings) WriteSegment(ofsDestPrevSettings+offsetof(DBContactSettings,ofsNext),&ofsDestThis,sizeof(DWORD));
else dbc->ofsFirstSettings=ofsDestThis;
ofsDestPrevSettings=ofsDestThis;
ofsThisSettings=dbcsOld.ofsNext;
return ERROR_SUCCESS;
}
int CDb3Mmap::WorkEventChain(DWORD ofsContact, DBContact *dbc, int firstTime)
{
int isUnread = 0;
if (firstTime) {
dbePrevEvent = NULL;
ofsPrevEvent = 0;
ofsDestPrevEvent = 0;
ofsThisEvent = dbc->ofsFirstEvent;
eventCount = 0;
backLookup = 0;
lastTimestamp = 0;
ofsFirstUnread = tsFirstUnread = 0;
if (cb->bEraseHistory) {
dbc->eventCount = 0;
dbc->ofsFirstEvent = 0;
dbc->ofsLastEvent = 0;
dbc->ofsFirstUnread = 0;
dbc->tsFirstUnread = 0;
return ERROR_NO_MORE_ITEMS;
}
}
if (ofsThisEvent == 0) {
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
DBEvent dbeOld;
if (!SignatureValid(ofsThisEvent, DBEVENT_SIGNATURE)) {
DWORD ofsNew = 0;
DWORD ofsTmp = dbc->ofsLastEvent;
if (!backLookup && ofsTmp) {
backLookup = 1;
while (SignatureValid(ofsTmp, DBEVENT_SIGNATURE)) {
if (PeekEvent(ofsTmp, dbc->dwContactID, dbeOld) != ERROR_SUCCESS)
break;
ofsNew = ofsTmp;
ofsTmp = dbeOld.ofsPrev;
}
}
if (ofsNew) {
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event chain corrupted, trying to recover..."));
ofsThisEvent = ofsNew;
}
else {
cb->pfnAddLogMessage(STATUS_ERROR, TranslateT("Event chain corrupted, further entries ignored"));
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
}
if (PeekEvent(ofsThisEvent, dbc->dwContactID, dbeOld) != ERROR_SUCCESS) {
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
if (firstTime) {
if (dbeOld.ofsPrev != 0)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("First event not marked as such: correcting"));
dbeOld.ofsPrev = 0;
lastTimestamp = dbeOld.timestamp;
}
if (dbeOld.flags & 1)
dbeOld.flags &= ~1;
if (dbeOld.flags & ~DBEF_ALL) {
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Extra flags found in event: removing"));
dbeOld.flags &= DBEF_ALL;
}
if (!(dbeOld.flags & (DBEF_READ | DBEF_SENT))) {
if (cb->bMarkRead) dbeOld.flags |= DBEF_READ;
else if (ofsFirstUnread == 0) {
if (dbc->ofsFirstUnread != ofsThisEvent || dbc->tsFirstUnread != dbeOld.timestamp)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("First unread event marked wrong: fixing"));
isUnread = 1;
}
}
if (dbeOld.cbBlob > 1024 * 1024 || dbeOld.cbBlob == 0) {
cb->pfnAddLogMessage(STATUS_ERROR, TranslateT("Infeasibly large event blob: skipping"));
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
DBEvent *dbePrev = NULL;
if (dbePrevEvent && dbeOld.timestamp == lastTimestamp) {
int len = offsetof(DBEvent, blob) + dbePrevEvent->cbBlob;
dbePrev = (DBEvent*)malloc(len);
memcpy(dbePrev, dbePrevEvent, len);
}
if (offsetof(DBEvent, blob) + dbeOld.cbBlob > memsize) {
memsize = offsetof(DBEvent, blob) + dbeOld.cbBlob;
memblock = (DBEvent*)realloc(memblock, memsize);
}
DBEvent *dbeNew = memblock;
DWORD ret;
if (m_dbHeader.version < DB_095_1_VERSION) {
DBEvent_094 oldEvent;
ret = ReadSegment(ofsThisEvent, &oldEvent, offsetof(DBEvent_094, blob));
if (ret == ERROR_SUCCESS) {
dbeNew->signature = oldEvent.signature;
dbeNew->contactID = dbc->dwContactID;
memcpy(&dbeNew->ofsPrev, &oldEvent.ofsPrev, offsetof(DBEvent_094, blob) - sizeof(DWORD));
ret = ReadSegment(ofsThisEvent + offsetof(DBEvent_094, blob), &dbeNew->blob, dbeOld.cbBlob);
}
}
else ret = ReadSegment(ofsThisEvent, dbeNew, offsetof(DBEvent, blob) + dbeOld.cbBlob);
if (ret != ERROR_SUCCESS) {
FinishUp(ofsDestPrevEvent, dbc);
return ERROR_NO_MORE_ITEMS;
}
if ((dbeNew->ofsModuleName = ConvertModuleNameOfs(dbeOld.ofsModuleName)) == 0) {
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
if (!firstTime && dbeOld.ofsPrev != ofsPrevEvent)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event not backlinked correctly: fixing"));
dbeNew->flags = dbeOld.flags;
dbeNew->ofsPrev = ofsDestPrevEvent;
dbeNew->ofsNext = 0;
if (dbeNew->contactID == 0)
dbeNew->contactID = dbc->dwContactID;
if (dbeOld.wEventType == EVENTTYPE_MESSAGE && cb->bConvertUtf && !(dbeOld.flags & DBEF_ENCRYPTED))
ConvertOldEvent(dbeNew);
if (dbePrev) {
if (dbePrev->cbBlob == dbeNew->cbBlob &&
dbePrev->ofsModuleName == dbeNew->ofsModuleName &&
dbePrev->wEventType == dbeNew->wEventType &&
(dbePrev->flags & DBEF_SENT) == (dbeNew->flags & DBEF_SENT) && !memcmp(dbePrev->blob, dbeNew->blob, dbeNew->cbBlob))
{
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Duplicate event was found: skipping"));
if (dbc->eventCount)
dbc->eventCount--;
free(dbePrev);
// ofsDestPrevEvent is still the same!
ofsPrevEvent = ofsThisEvent;
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
free(dbePrev);
}
else if (!firstTime && dbeNew->timestamp < lastTimestamp) {
DWORD found = 0;
DBEvent dbeTmp = { 0 };
DWORD ofsTmp = 0;
if (cb->bCheckOnly) {
if (!cb->bAggressive) {
ofsTmp = dbeOld.ofsPrev;
while (PeekEvent(ofsTmp, dbc->dwContactID, dbeTmp) == ERROR_SUCCESS) {
if (dbeTmp.ofsPrev == ofsContact) {
found = 1;
break;
}
if (dbeTmp.timestamp < dbeNew->timestamp) {
found = 2;
break;
}
ofsTmp = dbeTmp.ofsPrev;
}
}
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct"));
}
else {
ofsTmp = ofsDestPrevEvent;
while (ReadWrittenSegment(ofsTmp, &dbeTmp, sizeof(dbeTmp)) == ERROR_SUCCESS) {
if (dbeTmp.ofsPrev == ofsContact) {
found = 1;
break;
}
if (dbeTmp.timestamp < dbeNew->timestamp) {
found = 2;
break;
}
ofsTmp = dbeTmp.ofsPrev;
}
if (found)
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct: fixing"));
else
cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct: unable to fix"));
}
// insert before FIRST
if (found == 1 && !cb->bCheckOnly) {
dbeNew->ofsPrev = 0;
dbeNew->ofsNext = dbc->ofsFirstEvent;
DWORD ofsDestThis = WriteEvent(dbeNew);
if (!ofsDestThis)
return ERROR_HANDLE_DISK_FULL;
if (isUnread && tsFirstUnread >= dbeNew->timestamp) {
ofsFirstUnread = ofsDestThis;
tsFirstUnread = dbeNew->timestamp;
}
// fix first event
WriteOfsNextToPrevious(0, dbc, ofsDestThis);
// fix next event
WriteSegment(dbeNew->ofsNext + offsetof(DBEvent, ofsPrev), &ofsDestThis, sizeof(DWORD));
}
else if (found == 2 && !cb->bCheckOnly) {
dbeNew->ofsPrev = ofsTmp;
dbeNew->ofsNext = dbeTmp.ofsNext;
DWORD ofsDestThis = WriteEvent(dbeNew);
if (!ofsDestThis)
return ERROR_HANDLE_DISK_FULL;
if (isUnread && tsFirstUnread >= dbeNew->timestamp) {
ofsFirstUnread = ofsDestThis;
tsFirstUnread = dbeNew->timestamp;
}
// fix previous event
WriteOfsNextToPrevious(dbeNew->ofsPrev, dbc, ofsDestThis);
// fix next event
WriteSegment(dbeNew->ofsNext + offsetof(DBEvent, ofsPrev), &ofsDestThis, sizeof(DWORD));
}
if (found) {
eventCount++;
// ofsDestPrevEvent is still the same!
ofsPrevEvent = ofsThisEvent;
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
}
lastTimestamp = dbeNew->timestamp;
dbePrevEvent = dbeNew;
DWORD ofsDestThis = WriteEvent(dbeNew);
if (!ofsDestThis)
return ERROR_HANDLE_DISK_FULL;
if (isUnread) {
ofsFirstUnread = ofsDestThis;
tsFirstUnread = dbeOld.timestamp;
}
eventCount++;
WriteOfsNextToPrevious(ofsDestPrevEvent, dbc, ofsDestThis);
ofsDestPrevEvent = ofsDestThis;
ofsPrevEvent = ofsThisEvent;
ofsThisEvent = dbeOld.ofsNext;
return ERROR_SUCCESS;
}
