private static ProxyAddress GetLegacyProxyAddress(IRuleEvaluationContext context, byte[] entryId)
{
if (entryId.Length == 0)
{
context.TraceDebug("GetLegacyProxyAddress: entry ID is zero-length");
return(null);
}
ParticipantEntryId participantEntryId = ParticipantEntryId.TryFromEntryId(entryId);
context.TraceDebug <string>("GetLegacyProxyAddress: entry ID is {0}", participantEntryId.GetType().Name);
Participant.Builder builder = new Participant.Builder();
builder.SetPropertiesFrom(participantEntryId);
Participant participant = builder.ToParticipant();
string routingType = participant.RoutingType;
string emailAddress = participant.EmailAddress;
if (routingType != "EX" || string.IsNullOrEmpty(emailAddress))
{
context.TraceDebug <string, string>("GetLegacyProxyAddress: returning null, address is {0}:{1}", routingType ?? "(null)", emailAddress ?? "(null)");
return(null);
}
ProxyAddress proxyAddress = ProxyAddress.Parse(routingType, emailAddress);
if (proxyAddress is InvalidProxyAddress)
{
context.TraceDebug <string>("GetLegacyProxyAddress: legacyDN {0} is not valid", emailAddress);
return(null);
}
context.TraceDebug <string>("GetLegacyProxyAddress: returning EX:{0}", emailAddress);
return(proxyAddress);
}
private static bool EvaluateAttachmentRestriction(Restriction.AttachmentRestriction restriction, IRuleEvaluationContext context)
{
context.TraceFunction("AttachmentRestriction");
context.NestedLevel++;
bool flag = false;
foreach (AttachmentHandle handle in context.Message.AttachmentCollection)
{
using (Attachment attachment = context.Message.AttachmentCollection.Open(handle))
{
context.TraceFunction <string>("Attachment {0}", attachment.DisplayName);
using (IRuleEvaluationContext attachmentContext = context.GetAttachmentContext(attachment))
{
if (RestrictionEvaluator.Evaluate(restriction.Restriction, attachmentContext))
{
flag = true;
break;
}
}
}
}
context.NestedLevel--;
context.TraceFunction <bool>("AttachmentRestriction evaluates to {0}", flag);
return(flag);
}
private static bool MatchMultiValueWithPattern(IRuleEvaluationContext context, PropTag tag, object content, object pattern, ContentFlags flags)
{
if (RuleUtil.IsTextProp(tag))
{
string[] array = (string[])content;
string pattern2 = (string)pattern;
foreach (string content2 in array)
{
if (RestrictionEvaluator.MatchString(context.LimitChecker, context.CultureInfo, content2, pattern2, flags))
{
return(true);
}
}
}
else if (RuleUtil.IsBinaryProp(tag))
{
byte[][] array3 = (byte[][])content;
byte[] pattern3 = pattern as byte[];
foreach (byte[] content3 in array3)
{
if (RestrictionEvaluator.MatchByteArray(context.LimitChecker, content3, pattern3, flags))
{
return(true);
}
}
}
return(false);
}
internal static bool SetRecipients(IRuleEvaluationContext context, MessageItem message, IList <ProxyAddress> senderAddresses, AdrEntry[] recipients, bool promoteToEnvelope)
{
message.Recipients.Clear();
int num = 0;
foreach (AdrEntry entry in recipients)
{
Participant participant = RuleUtil.ParticipantFromAddressEntry(entry);
if (participant != null)
{
if (promoteToEnvelope && RuleUtil.IsRecipientSameAsSender(senderAddresses, participant.EmailAddress))
{
context.TraceDebug <string>("Skipping recipient {0} because that was the original sender.", participant.EmailAddress);
}
else
{
context.TraceDebug <Participant>("Adding recipient {0}.", participant);
Recipient recipient = message.Recipients.Add(participant);
recipient[ItemSchema.Responsibility] = promoteToEnvelope;
num++;
}
}
}
return(num > 0);
}
public DelegateWorkItem(IRuleEvaluationContext context, AdrEntry[] recipients, int actionIndex) : base(context, actionIndex)
{
if (RuleUtil.IsNullOrEmpty(recipients))
{
throw new ArgumentException("Delegate recipient list is empty");
}
this.recipients = recipients;
}
public FolderEvaluationResult(IRuleEvaluationContext context, List <Rule> rules)
{
this.context = context;
this.targetFolder = context.CurrentFolder;
this.hasOofRules = RuleLoader.HasOofRule(rules);
this.ruleSet = new FolderEvaluationResult.RuleSet(this, rules);
this.workItems = new List <WorkItem>();
}
public ForwardWorkItem(IRuleEvaluationContext context, AdrEntry[] recipients, RuleAction.Forward.ActionFlags flags, int actionIndex) : base(context, actionIndex)
{
if (RuleUtil.IsNullOrEmpty(recipients))
{
throw new ArgumentException("Forward recipient list is empty");
}
this.flags = flags;
this.recipients = recipients;
}
private static bool CompareValueWithMultiValue(IRuleEvaluationContext context, PropTag tag, Restriction.RelOp op, object messageValue, object ruleValueObject)
{
Array array = (Array)ruleValueObject;
bool flag = false;
foreach (object y in array)
{
flag = context.CompareSingleValue(tag, Restriction.RelOp.Equal, messageValue, y);
if (flag)
{
break;
}
}
if (op == Restriction.RelOp.NotEqual)
{
flag = !flag;
}
return(flag);
}
internal static bool IsSameUser(IRuleEvaluationContext context, IADRecipientCache recipientCache, ProxyAddress addressToResolve, ProxyAddress addressToCompare)
{
if (addressToResolve == null || addressToResolve is InvalidProxyAddress)
{
return(false);
}
if (addressToCompare == null || addressToCompare is InvalidProxyAddress)
{
return(false);
}
if (addressToResolve.Equals(addressToCompare))
{
return(true);
}
ADRawEntry data = recipientCache.FindAndCacheRecipient(addressToResolve).Data;
if (data == null)
{
context.TraceDebug <string>("Message recipient {0} did not resolve, IsSameUser returning false.", addressToResolve.ToString());
return(false);
}
string text = (string)data[ADRecipientSchema.LegacyExchangeDN];
if (text != null && addressToCompare.ValueString.Equals(text, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
ProxyAddressCollection proxyAddressCollection = (ProxyAddressCollection)data[ADRecipientSchema.EmailAddresses];
if (proxyAddressCollection == null)
{
return(false);
}
foreach (ProxyAddress proxyAddress in proxyAddressCollection)
{
if (addressToCompare.ValueString.Equals(proxyAddress.ValueString, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
return(false);
}
internal static bool IsMemberOf(IRuleEvaluationContext context, byte[] recipientEntryId, byte[] groupEntryId)
{
ProxyAddress legacyProxyAddress = RuleUtil.GetLegacyProxyAddress(context, recipientEntryId);
if (legacyProxyAddress == null)
{
context.TraceDebug("IsMemberOf: unable to get legacy DN for recipient.");
return(false);
}
ProxyAddress legacyProxyAddress2 = RuleUtil.GetLegacyProxyAddress(context, groupEntryId);
if (legacyProxyAddress2 == null)
{
context.TraceDebug("IsMemberOf: unable to get address for group, this rule is in error.");
throw new InvalidRuleException(ServerStrings.FolderRuleErrorInvalidGroup(BitConverter.ToString(groupEntryId)));
}
context.TraceDebug <string, string>("IsMemberOf: Recipient=\"{0}\" Group=\"{1}\"", legacyProxyAddress.AddressString, legacyProxyAddress2.AddressString);
Result <ADRawEntry> result = context.RecipientCache.FindAndCacheRecipient(legacyProxyAddress);
if (result.Data == null)
{
context.TraceDebug("Recipient doesn't exist in AD");
context.RecordError(ServerStrings.FolderRuleErrorGroupDoesNotResolve(legacyProxyAddress.ToString()));
return(false);
}
bool result2;
try
{
IsMemberOfResolver <string> isMemberOfResolver = context.IsMemberOfResolver;
bool flag = isMemberOfResolver.IsMemberOf(context.RecipientCache.ADSession, result.Data.Id, legacyProxyAddress2.AddressString);
context.TraceDebug <bool>("IsMemberOf: {0}", flag);
result2 = flag;
}
catch (AddressBookTransientException exception)
{
context.RecordError(exception, ServerStrings.FolderRuleStageEvaluation);
result2 = false;
}
return(result2);
}
internal static bool SetRecipients(IRuleEvaluationContext context, MessageItem message, IList <ProxyAddress> senderAddresses, RecipientCollection recipients, bool promoteToEnvelope)
{
int num = 0;
message.Recipients.Clear();
foreach (Recipient recipient in recipients)
{
if (promoteToEnvelope && RuleUtil.IsRecipientSameAsSender(senderAddresses, recipient.Participant.EmailAddress))
{
context.TraceDebug <string>("Skipping recipient {0} because that was the original sender.", recipient.Participant.EmailAddress);
}
else
{
context.TraceDebug <string>("Adding recipient {0}.", recipient.Participant.ToString());
Recipient recipient2 = message.Recipients.Add(recipient.Participant, recipient.RecipientItemType);
recipient2[ItemSchema.Responsibility] = promoteToEnvelope;
num++;
}
}
return(num > 0);
}
private static bool EvaluateRecipientRestriction(Restriction.RecipientRestriction restriction, IRuleEvaluationContext context)
{
context.TraceFunction("RecipientRestriction");
context.NestedLevel++;
bool flag = false;
foreach (Recipient recipient in context.Message.Recipients)
{
using (IRuleEvaluationContext recipientContext = context.GetRecipientContext(recipient))
{
context.TraceFunction <string>("Recipient {0}", recipient.Participant.DisplayName);
if (RestrictionEvaluator.Evaluate(restriction.Restriction, recipientContext))
{
flag = true;
break;
}
}
}
context.NestedLevel--;
context.TraceFunction <bool>("RecipientRestriction evaluates to {0}", flag);
return(flag);
}
private static bool CompareMultiValueWithValue(IRuleEvaluationContext context, PropTag tag, Restriction.RelOp op, object messageValueObject, object ruleValue)
{
Array array = (Array)messageValueObject;
bool flag = false;
foreach (object x in array)
{
flag = context.CompareSingleValue(tag, op, x, ruleValue);
if (flag)
{
if (op != Restriction.RelOp.NotEqual)
{
break;
}
}
else if (op == Restriction.RelOp.NotEqual)
{
break;
}
}
return(flag);
}
public TagWorkItem(IRuleEvaluationContext context, PropValue value, int actionIndex) : base(context, actionIndex)
{
this.value = value;
}
public WorkItem(IRuleEvaluationContext context, int actionIndex)
{
this.context = context;
this.rule = this.context.CurrentRule;
this.actionIndex = actionIndex;
}
public RuleEvaluator(IRuleEvaluationContext context)
{
this.context = context;
}
public OofHistory(byte[] senderAddress, byte[] globalRuleId, IRuleEvaluationContext context)
{
this.senderAddress = senderAddress;
this.globalRuleId = globalRuleId;
this.context = context;
}
private static bool EvaluateSizeRestriction(Restriction.SizeRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidateSizeRestriction(restriction);
context.TraceFunction <PropTag, Restriction.RelOp, int>("SizeRestriction [{0}] {1} [{2}]", restriction.Tag, restriction.Op, restriction.Size);
PropType type = restriction.Tag.ValueType();
int num = 0;
bool flag = false;
object obj = null;
if (RuleUtil.GetPropTypeSize(type, out num))
{
flag = RestrictionEvaluator.GetOperationResultFromOrder(restriction.Op, num.CompareTo(restriction.Size));
}
else if (RuleUtil.IsMultiValueTag(restriction.Tag))
{
obj = context[restriction.Tag];
object[] array = obj as object[];
if (array != null)
{
foreach (object value in array)
{
int size = RuleUtil.GetSize(value);
if (RestrictionEvaluator.GetOperationResultFromOrder(restriction.Op, size.CompareTo(restriction.Size)))
{
flag = true;
break;
}
}
}
}
else
{
obj = context[restriction.Tag];
int size2 = RuleUtil.GetSize(obj);
flag = RestrictionEvaluator.GetOperationResultFromOrder(restriction.Op, size2.CompareTo(restriction.Size));
}
context.TraceFunction <bool, object>("SizeRestriction evaluated to {0} with property value [{1}]", flag, obj);
return(flag);
}
public static bool Evaluate(Restriction restriction, IRuleEvaluationContext context)
{
if (restriction == null)
{
context.TraceDebug <string>("Empty restriction evaluated to true in rule {0}", context.CurrentRule.Name);
return(true);
}
Restriction.ResType type = restriction.Type;
switch (type)
{
case Restriction.ResType.And:
return(RestrictionEvaluator.EvaluateAndRestriction((Restriction.AndRestriction)restriction, context));
case Restriction.ResType.Or:
return(RestrictionEvaluator.EvaluateOrRestriction((Restriction.OrRestriction)restriction, context));
case Restriction.ResType.Not:
return(RestrictionEvaluator.EvaluateNotRestriction((Restriction.NotRestriction)restriction, context));
case Restriction.ResType.Content:
return(RestrictionEvaluator.EvaluateContentRestriction((Restriction.ContentRestriction)restriction, context));
case Restriction.ResType.Property:
return(RestrictionEvaluator.EvaluatePropertyRestriction((Restriction.PropertyRestriction)restriction, context));
case Restriction.ResType.CompareProps:
return(RestrictionEvaluator.EvaluateComparePropertyRestriction((Restriction.ComparePropertyRestriction)restriction, context));
case Restriction.ResType.BitMask:
return(RestrictionEvaluator.EvaluateBitMaskRestriction((Restriction.BitMaskRestriction)restriction, context));
case Restriction.ResType.Size:
return(RestrictionEvaluator.EvaluateSizeRestriction((Restriction.SizeRestriction)restriction, context));
case Restriction.ResType.Exist:
return(RestrictionEvaluator.EvaluateExistRestriction((Restriction.ExistRestriction)restriction, context));
case Restriction.ResType.SubRestriction:
if (restriction is Restriction.AttachmentRestriction)
{
return(RestrictionEvaluator.EvaluateAttachmentRestriction((Restriction.AttachmentRestriction)restriction, context));
}
if (restriction is Restriction.RecipientRestriction)
{
return(RestrictionEvaluator.EvaluateRecipientRestriction((Restriction.RecipientRestriction)restriction, context));
}
throw new InvalidRuleException(string.Format("SubRestriction Type {0} is not supported!", restriction.GetType()));
case Restriction.ResType.Comment:
return(RestrictionEvaluator.EvaluateCommentRestriction((Restriction.CommentRestriction)restriction, context));
case Restriction.ResType.Count:
return(RestrictionEvaluator.EvaluateCountRestriction((Restriction.CountRestriction)restriction, context));
default:
switch (type)
{
case Restriction.ResType.True:
context.TraceFunction("True Restriction");
return(true);
case Restriction.ResType.False:
context.TraceFunction("False Restriction");
return(false);
default:
throw new InvalidRuleException(string.Format("Restriction Type {0} is not supported!", restriction.Type));
}
break;
}
}
private static bool EvaluateOrRestriction(Restriction.OrRestriction restriction, IRuleEvaluationContext context)
{
context.NestedLevel++;
bool flag = false;
foreach (Restriction restriction2 in restriction.Restrictions)
{
if (RestrictionEvaluator.Evaluate(restriction2, context))
{
flag = true;
break;
}
}
context.NestedLevel--;
context.TraceFunction <bool>("OrRestriction evaluated to {0}", flag);
return(flag);
}
private static bool EvaluateNotRestriction(Restriction.NotRestriction restriction, IRuleEvaluationContext context)
{
context.NestedLevel++;
bool flag = !RestrictionEvaluator.Evaluate(restriction.Restriction, context);
context.NestedLevel--;
context.TraceFunction <bool>("NotRestriction evaluated to {0}", flag);
return(flag);
}
private static bool EvaluateExistRestriction(Restriction.ExistRestriction restriction, IRuleEvaluationContext context)
{
object obj = context[restriction.Tag];
bool flag = obj != null;
context.TraceFunction <PropTag, bool>("ExistRestriction on tag [{0}] evaluted to {1}", restriction.Tag, flag);
return(flag);
}
protected RuleLoader(IRuleEvaluationContext context)
{
this.context = context;
}
public MailboxEvaluationResult(IRuleEvaluationContext context)
{
this.context = context;
this.folderResults = new List <FolderEvaluationResult>();
this.targetFolder = this.context.CurrentFolder;
}
private static bool EvaluateBitMaskRestriction(Restriction.BitMaskRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidateBitMaskRestriction(restriction);
object obj = context[restriction.Tag];
if (obj is int)
{
int num = (int)obj;
bool flag;
if ((num & restriction.Mask) != 0)
{
flag = (restriction.Bmr == Restriction.RelBmr.NotEqualToZero);
}
else
{
flag = (restriction.Bmr == Restriction.RelBmr.EqualToZero);
}
context.TraceFunction <object, Restriction.RelBmr, int, bool>("BitMaskRestriction [{0}] {1} [{2}] evaluates to {3}", obj, restriction.Bmr, restriction.Mask, flag);
return(flag);
}
context.TraceError <object>("Invalid BitMaskRestriction value: {0}", obj);
return(false);
}
public static List <Rule> LoadRules(IRuleEvaluationContext context)
{
RuleLoader ruleLoader = new RuleLoader(context);
return(ruleLoader.Load());
}
private static bool EvaluateComparePropertyRestriction(Restriction.ComparePropertyRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidateComparePropertyRestriction(restriction);
object obj = context[restriction.TagLeft];
object obj2 = context[restriction.TagRight];
context.TraceFunction <PropTag, Restriction.RelOp, PropTag>("ComparePropertyRestriction [{0}] {1} [{2}]", restriction.TagLeft, restriction.Op, restriction.TagRight);
bool flag = false;
if (obj != null && obj2 != null)
{
flag = context.CompareSingleValue(restriction.TagLeft, restriction.Op, obj, obj2);
}
context.TraceFunction <object, Restriction.RelOp, object, bool>("[{0}] {1} [{2}] evaluated to {3}", obj, restriction.Op, obj2, flag);
return(flag);
}
private static bool EvaluatePropertyRestriction(Restriction.PropertyRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidatePropertyRestriction(restriction);
PropTag propTag = restriction.PropTag;
if (restriction.MultiValued)
{
propTag = RuleUtil.GetMultiValuePropTag(propTag);
}
context.TraceFunction <PropTag, Restriction.RelOp, object>("PropertyRestriction [{0}] {1} [{2}]", propTag, restriction.Op, restriction.PropValue.Value);
object obj = context[propTag];
bool flag;
if (obj == null)
{
flag = false;
}
else if (restriction.MultiValued)
{
flag = RestrictionEvaluator.CompareMultiValueWithValue(context, RuleUtil.GetSingleValuePropTag(restriction.PropTag), restriction.Op, obj, restriction.PropValue.Value);
}
else if (RuleUtil.IsMultiValueTag(restriction.PropValue.PropTag))
{
flag = RestrictionEvaluator.CompareValueWithMultiValue(context, restriction.PropTag, restriction.Op, obj, restriction.PropValue.Value);
}
else
{
flag = context.CompareSingleValue(restriction.PropTag, restriction.Op, obj, restriction.PropValue.Value);
}
context.TraceFunction <bool, object>("PropertyRestriction evaluated to {0} with property value [{1}]", flag, obj);
return(flag);
}
public OofReplyWorkItem(IRuleEvaluationContext context, byte[] messageTemplateEntryId, int actionIndex) : base(context, actionIndex)
{
this.messageTemplateEntryId = messageTemplateEntryId;
}
private static bool EvaluateContentRestriction(Restriction.ContentRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidateContentRestriction(restriction);
PropTag propTag = restriction.PropTag;
if (restriction.MultiValued)
{
propTag = RuleUtil.GetMultiValuePropTag(propTag);
}
context.TraceFunction <PropTag, ContentFlags, object>("ContentRestriction tag [{0}] flags [{1}] value [{2}]", propTag, restriction.Flags, restriction.PropValue.Value);
object obj = context[propTag];
bool flag;
if (obj == null)
{
flag = false;
}
else if (restriction.MultiValued)
{
flag = RestrictionEvaluator.MatchMultiValueWithPattern(context, restriction.PropTag, obj, restriction.PropValue.Value, restriction.Flags);
}
else if (RuleUtil.IsTextProp(restriction.PropTag))
{
flag = RestrictionEvaluator.MatchString(context.LimitChecker, context.CultureInfo, (string)obj, (string)restriction.PropValue.Value, restriction.Flags);
}
else
{
if (!RuleUtil.IsBinaryProp(restriction.PropTag))
{
throw new InvalidRuleException(string.Format("Content restriction can't be used on tag {0}", restriction.PropTag));
}
flag = RestrictionEvaluator.MatchByteArray(context.LimitChecker, (byte[])obj, (byte[])restriction.PropValue.Value, restriction.Flags);
}
context.TraceFunction <bool, object>("ContentRestriction Evaluated to {0} with property value [{1}]", flag, obj);
if (!flag && propTag == PropTag.SenderSearchKey)
{
object obj2 = context[PropTag.SenderSmtpAddress];
if (obj2 != null)
{
string @string = CTSGlobals.AsciiEncoding.GetString((byte[])restriction.PropValue.Value);
ContentFlags contentFlags = ContentFlags.SubString | ContentFlags.IgnoreCase;
context.TraceFunction("No match found in SenderSearchKey, searching for string in SenderSmtpAddress...");
context.TraceFunction <PropTag, ContentFlags, string>("ContentRestriction tag [{0}] flags [{1}] value [{2}]", PropTag.SenderSmtpAddress, contentFlags, @string);
flag = RestrictionEvaluator.MatchString(context.LimitChecker, context.CultureInfo, (string)obj2, @string, contentFlags);
}
}
return(flag);
}
