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); }
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); }
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); }
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); }
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; } }