private static MapiStream OpenAndLockStream(MapiFolder oofHistoryFolder, byte[] initialBytes, long hashCode, out bool isNew)
{
MapiStream mapiStream = null;
isNew = false;
OpenPropertyFlags openPropertyFlags = OpenPropertyFlags.Modify | OpenPropertyFlags.DeferredErrors;
try
{
mapiStream = oofHistoryFolder.OpenStream(PropTag.OofHistory, openPropertyFlags);
OofHistory.LockStreamWithRetry(mapiStream, hashCode);
}
catch (MapiExceptionNotFound)
{
if (mapiStream != null)
{
mapiStream.Dispose();
mapiStream = null;
}
OofHistory.Tracer.TraceDebug(hashCode, "OOF history property does not exist, trying to open with create flag.");
openPropertyFlags |= OpenPropertyFlags.Create;
mapiStream = oofHistoryFolder.OpenStream(PropTag.OofHistory, openPropertyFlags);
OofHistory.LockStreamWithRetry(mapiStream, hashCode);
OofHistory.ResetOofHistoryProperty(mapiStream, initialBytes, hashCode);
isNew = true;
}
return(mapiStream);
}
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);
}
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);
}
internal static void ClearOofHistory(MailboxSession itemStore, bool oofEnabled)
{
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 num = (long)itemStore.GetHashCode();
bool flag2;
mapiStream = OofHistory.OpenAndLockStream(mapiFolder2, initialBytes, num, out flag2);
flag = true;
if (!flag2)
{
byte[] array = new byte[2];
if (2 != mapiStream.Read(array, 0, 2))
{
OofHistory.ResetOofHistoryProperty(mapiStream, initialBytes, num);
}
else
{
bool flag3 = 0 != array[1];
if (flag3 == oofEnabled)
{
OofHistory.Tracer.TraceDebug <bool>(num, "Current OOF state {0} matches in OOF history and mailbox properties, clear is not executed.", oofEnabled);
}
else
{
OofHistory.ResetOofHistoryProperty(mapiStream, initialBytes, num);
}
}
}
}
}
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 void UpdateOofRule(Rule rule, ReplyBody reply, string ruleName, string messageClass, OofReplyType oofReplyType, RuleGenerator.ConditionType conditionType, int sequenceNumber, OofState mailboxOofState)
{
bool flag = false;
bool flag2 = false;
Restriction restriction = this.GetRestriction(conditionType);
RuleAction.OOFReply ruleAction = (RuleAction.OOFReply)rule.Actions[0];
ReplyTemplate replyTemplate = null;
try
{
replyTemplate = ReplyTemplate.Find(this.itemStore, ruleAction);
if (replyTemplate != null)
{
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Updating ReplyTemplate to Body: '{1}'", this.itemStore.MailboxOwner, reply.RawMessage);
if (this.userOofSettings.SetByLegacyClient)
{
flag2 = !replyTemplate.PlainTextBody.Equals(reply.RawMessage, StringComparison.Ordinal);
replyTemplate.PlainTextBody = reply.RawMessage;
}
else
{
string value = TextUtil.ConvertHtmlToPlainText(reply.RawMessage);
flag2 = !replyTemplate.PlainTextBody.Equals(value, StringComparison.Ordinal);
replyTemplate.CharSet = this.GetDefaultCharsetForCountryCode(reply.LanguageTag);
replyTemplate.HtmlBody = reply.RawMessage;
}
replyTemplate.OofReplyType = oofReplyType;
replyTemplate.ClassName = messageClass;
replyTemplate.SaveChanges();
if (flag2)
{
rule.StateFlags |= RuleStateFlags.ClearOOFHistory;
byte[] propValue = this.itemStore.__ContainedMapiStore.GlobalIdFromId(rule.ID);
OofHistory.RemoveOofHistoryEntriesWithProperty(this.itemStore, mailboxOofState != OofState.Disabled, OofHistory.PropId.GlobalRuleId, propValue);
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Updated reply template for global rule '{1}'", this.itemStore.MailboxOwner, ruleName);
}
}
else
{
Guid guid = Guid.NewGuid();
byte[] replyTemplateMessageEntryID = this.CreateOofReplyTemplate(this.itemStore, guid, reply, messageClass, oofReplyType);
rule.Actions = new RuleAction[]
{
new RuleAction.OOFReply(replyTemplateMessageEntryID, guid)
};
flag = true;
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Created new reply template and updated global rule '{1}'", this.itemStore.MailboxOwner, ruleName);
}
RuleGenerator.TracerPfd.TracePfd <int, string, IExchangePrincipal>((long)this.GetHashCode(), "PFD IWO {0} Updated OOF Rule '{1}' for Mailbox:{2}", 25495, ruleName, this.itemStore.MailboxOwner);
}
finally
{
if (replyTemplate != null)
{
replyTemplate.Dispose();
}
}
if (!ConditionComparer.Equals(rule.Condition, restriction))
{
rule.Condition = restriction;
flag = true;
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Updated rule '{1}' with new condition", this.itemStore.MailboxOwner, ruleName);
}
if (flag || flag2)
{
this.ruleManager.Update(rule);
}
}
