private void AppendProperty(OofHistory.PropId propId, byte[] propertyValue)
{
this.data[this.dataPosition++] = (byte)propId;
ushort num = (ushort)propertyValue.Length;
ExBitConverter.Write(num, this.data, this.dataPosition);
this.dataPosition += 2;
Buffer.BlockCopy(propertyValue, 0, this.data, this.dataPosition, (int)num);
this.dataPosition += (int)num;
}
private static bool MatchProperty(byte[] buffer, byte currentPropId, OofHistory.PropId propId, ushort currentPropertySize, byte[] propValue, ref int index)
{
if (currentPropId == (byte)propId && (int)currentPropertySize == propValue.Length)
{
for (ushort num = 0; num < currentPropertySize; num += 1)
{
if (propValue[(int)num] != buffer[index++])
{
index += (int)(currentPropertySize - num - 1);
return(false);
}
}
return(true);
}
index += (int)currentPropertySize;
return(false);
}
internal static void RemoveOofHistoryEntriesWithProperty(MailboxSession itemStore, bool oofEnabled, OofHistory.PropId propId, byte[] propValue)
{
MapiFolder mapiFolder = null;
MapiFolder mapiFolder2 = null;
MapiStream mapiStream = null;
bool flag = false;
byte[] initialBytes = oofEnabled ? OofHistory.InitialBytesOofStateOn : OofHistory.InitialBytesOofStateOff;
try
{
if (OofHistory.TryOpenFolder(itemStore, out mapiFolder, out mapiFolder2))
{
long hashCode = (long)itemStore.GetHashCode();
bool flag2;
mapiStream = OofHistory.OpenAndLockStream(mapiFolder2, initialBytes, hashCode, out flag2);
flag = true;
if (!flag2)
{
int num;
if (OofHistory.TryGetStreamLengthForEntryRemoval(hashCode, mapiStream, out num))
{
byte[] buffer;
if (OofHistory.TryReadAllFromStream(hashCode, mapiStream, num, out buffer))
{
int num2 = OofHistory.RemoveEntriesWithProperty(num, buffer, propId, propValue, hashCode);
if (num2 < num)
{
mapiStream.Seek(0L, SeekOrigin.Begin);
mapiStream.Write(buffer, 0, num2);
mapiStream.SetLength((long)num2);
}
}
}
}
}
}
finally
{
if (mapiStream != null)
{
try
{
if (flag)
{
mapiStream.UnlockRegion(0L, 1L, 1);
}
}
finally
{
mapiStream.Dispose();
}
}
if (mapiFolder != null)
{
mapiFolder.Dispose();
mapiFolder = null;
}
if (mapiFolder2 != null)
{
mapiFolder2.Dispose();
mapiFolder2 = null;
}
}
}
private static bool MatchAnyPropertiesInEntry(byte[] buffer, OofHistory.PropId propId, byte[] propValue, byte propertyCount, int historyLength, uint currentEntry, long hashCode, ref int index, out bool isCorrupt)
{
isCorrupt = false;
bool flag = false;
for (byte b = 0; b < propertyCount; b += 1)
{
if (index >= historyLength)
{
OofHistory.HandleInsufficientDataCorruption(hashCode, string.Concat(new object[]
{
"Unable to get property id of property ",
b,
" entry ",
currentEntry
}));
isCorrupt = true;
return(false);
}
byte b2 = buffer[index++];
if (index + 2 >= historyLength)
{
OofHistory.HandleInsufficientDataCorruption(hashCode, string.Concat(new object[]
{
"Unable to get property size of property ",
b,
" entry ",
currentEntry,
" property id ",
b2,
" index ",
index
}));
isCorrupt = true;
return(false);
}
ushort num = BitConverter.ToUInt16(buffer, index);
index += 2;
if (index + (int)num > historyLength)
{
OofHistory.HandleInsufficientDataCorruption(hashCode, string.Concat(new object[]
{
"Unable to get property content of property ",
b,
" entry ",
currentEntry,
" property id ",
b2,
" property size ",
num,
" index ",
index
}));
isCorrupt = true;
return(false);
}
if (flag)
{
index += (int)num;
}
else if (OofHistory.MatchProperty(buffer, b2, propId, num, propValue, ref index))
{
flag = true;
}
}
return(flag);
}
private static int RemoveEntriesWithProperty(int historyLength, byte[] buffer, OofHistory.PropId propId, byte[] propValue, long hashCode)
{
int num = 6;
int currentEntryStart = 6;
int result = 6;
uint num2 = BitConverter.ToUInt32(buffer, 2);
if (10000U < num2)
{
num2 = 10000U;
}
uint num3 = num2;
for (uint num4 = 0U; num4 < num2; num4 += 1U)
{
if (num >= historyLength)
{
OofHistory.HandleInsufficientDataCorruption(hashCode, "Unable to get property count of entry " + num4);
return(result);
}
byte propertyCount = buffer[num++];
bool flag;
if (OofHistory.MatchAnyPropertiesInEntry(buffer, propId, propValue, propertyCount, historyLength, num4, hashCode, ref num, out flag))
{
num3 -= 1U;
}
else
{
if (flag)
{
return(result);
}
OofHistory.HandleNonMatchingProperty(buffer, num, currentEntryStart, ref result);
}
currentEntryStart = num;
}
if (num3 < num2)
{
ExBitConverter.Write(num3, buffer, 2);
}
return(result);
}
public void ReadEntry()
{
this.ThrowIfNotInitialized();
if (!this.HasMoreEntries)
{
throw new InvalidOperationException("There are no more entries to read.");
}
if (this.currentEntryAddressBytes == null)
{
this.currentEntryAddressBytes = new VirtualList <byte>(true);
}
if (this.currentEntryRuleIdBytes == null)
{
this.currentEntryRuleIdBytes = new VirtualList <byte>(true);
}
if (!this.EnsureDataSufficiency(1))
{
throw new OofHistoryCorruptionException(string.Concat(new object[]
{
"Insufficient data in stream to read property count for entry ",
this.entriesRead,
" at buffer position ",
this.dataPosition
}));
}
byte b = this.data[this.dataPosition++];
for (byte b2 = 0; b2 < b; b2 += 1)
{
if (!this.EnsureDataSufficiency(3))
{
throw new OofHistoryCorruptionException(string.Concat(new object[]
{
"Insufficient data in stream to read property id and size. Current entry ",
this.entriesRead,
", current property: ",
b2,
", total entries: ",
this.entryCount
}));
}
OofHistory.PropId propId = (OofHistory.PropId) this.data[this.dataPosition];
ushort num = BitConverter.ToUInt16(this.data, this.dataPosition + 1);
if (num > 1000)
{
throw new OofHistoryCorruptionException(string.Concat(new object[]
{
"Current entry: ",
this.entriesRead,
"Property with id ",
propId,
" has property size: ",
num,
", which is over the maximum allowed size of ",
1000
}));
}
this.dataPosition += 3;
if (!this.EnsureDataSufficiency((int)num))
{
throw new OofHistoryCorruptionException(string.Concat(new object[]
{
"Insufficient data in stream to match property values. Current entry: ",
this.entriesRead,
", property with id ",
this.data[this.dataPosition],
" has property size: ",
num
}));
}
switch (propId)
{
case OofHistory.PropId.SenderAddress:
this.currentEntryAddressBytes.SetRange(this.data, this.dataPosition, (int)num);
break;
case OofHistory.PropId.GlobalRuleId:
this.currentEntryRuleIdBytes.SetRange(this.data, this.dataPosition, (int)num);
break;
}
this.dataPosition += (int)num;
}
this.entriesRead++;
}
