// Token: 0x06001AA9 RID: 6825 RVA: 0x0006FC14 File Offset: 0x0006DE14
private static ExpansionControl InvokeFailureDelegate(ADRecipientExpansion.HandleFailureDelegate handleFailure, ExpansionFailure failure, ADRawEntry recipient, ExpansionType expansionType, ADRecipientExpansion.ExpandableEntry parent)
{
if (handleFailure == null)
{
return(ExpansionControl.Continue);
}
ExpansionType expansionType2 = (parent == null) ? ExpansionType.None : parent.ExpansionType;
ExTraceGlobals.ADExpansionTracer.TraceDebug(0L, "Invoking failure delegate: failure={0}; recipient={1}; expansion-type={2}; parent={3}; parent-expansion-type={4}", new object[]
{
ADRecipientExpansion.GetExpansionFailureString(failure),
recipient[ADObjectSchema.Id],
ADRecipientExpansion.GetExpansionTypeString(expansionType),
(parent == null) ? "<null>" : parent.Entry[ADObjectSchema.Id],
ADRecipientExpansion.GetExpansionTypeString(expansionType2)
});
ExpansionControl expansionControl = handleFailure(failure, recipient, expansionType, (parent == null) ? null : parent.Entry, expansionType2);
ExTraceGlobals.ADExpansionTracer.TraceDebug <string>(0L, "Delegate returned '{0}'", ADRecipientExpansion.GetExpansionControlString(expansionControl));
return(expansionControl);
}
private EmailAddressWrapper[] GetCertsFromDirectory(Participant p, bool isCurrent)
{
bool flag = false;
EmailAddressWrapper[] result;
try
{
this.timeoutTimeForDLExpansion = new ExDateTime?(ExDateTime.UtcNow.AddMilliseconds(this.smimeAdminOptions.DLExpansionTimeout));
ADRawEntry adentry = ((DirectoryParticipantOrigin)p.Origin).ADEntry;
if (adentry == null)
{
result = this.GetCurrent(p, isCurrent, "Unknown");
}
else if (this.IsHiddenMembership(adentry))
{
result = this.GetCurrent(p, isCurrent, "PublicDL");
}
else
{
Dictionary <string, EmailAddressWrapper> invalidRecipients = new Dictionary <string, EmailAddressWrapper>();
Action <ADRawEntry> addInvalidRecipient = delegate(ADRawEntry recipient)
{
invalidRecipients[recipient[ADObjectSchema.Id].ToString()] = this.GetEmailAddressWrapper(recipient);
};
Action <ADRawEntry> addCertsOrInvalidRecipients = delegate(ADRawEntry recipient)
{
try
{
string text = recipient[ADRecipientSchema.LegacyExchangeDN] as string;
if (text == null)
{
addInvalidRecipient(recipient);
}
else
{
text = text.ToLower();
byte[][] array = this.MultiValuePropertyToByteArray(recipient[ADRecipientSchema.Certificate] as MultiValuedProperty <byte[]>);
byte[][] array2 = this.MultiValuePropertyToByteArray(recipient[ADRecipientSchema.SMimeCertificate] as MultiValuedProperty <byte[]>);
if (array.Length == 0 && array2.Length == 0)
{
addInvalidRecipient(recipient);
}
else
{
string[] array3;
if (this.smimeAdminOptions.UseSecondaryProxiesWhenFindingCertificates)
{
ProxyAddressCollection proxyAddressCollection = recipient[ADRecipientSchema.EmailAddresses] as ProxyAddressCollection;
if (proxyAddressCollection != null && proxyAddressCollection.Count > 0)
{
array3 = new string[proxyAddressCollection.Count];
for (int i = 0; i < proxyAddressCollection.Count; i++)
{
array3[i] = proxyAddressCollection[i].AddressString;
}
}
else
{
array3 = new string[]
{
recipient[ADRecipientSchema.PrimarySmtpAddress].ToString()
};
}
}
else
{
array3 = new string[]
{
recipient[ADRecipientSchema.PrimarySmtpAddress].ToString()
};
}
X509Certificate2 x509Certificate = this.FindBestCert(array3, false, new byte[][][]
{
array,
array2
});
if (x509Certificate != null)
{
this.AddCertToCurrentParticipant(x509Certificate.RawData);
}
else
{
addInvalidRecipient(recipient);
}
}
}
}
catch (Exception ex3)
{
this.LogException(ex3, "Error occurred when getting cert from Directory User: {0}", new object[]
{
recipient.GetDistinguishedNameOrName()
});
addInvalidRecipient(recipient);
}
};
if (flag = this.IsDistributionList(adentry))
{
ADRecipientExpansion.HandleRecipientDelegate handleRecipient = delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (this.IsDLExpansionTimedOut())
{
throw new TimeoutException("The DL expansion is timeout.");
}
if (this.IsHiddenMembership(recipient))
{
addInvalidRecipient(recipient);
return(ExpansionControl.Skip);
}
if (!this.IsDistributionList(recipient))
{
addCertsOrInvalidRecipients(recipient);
}
return(ExpansionControl.Continue);
};
ADRecipientExpansion.HandleFailureDelegate handleFailure = delegate(ExpansionFailure failure, ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (this.IsDLExpansionTimedOut())
{
throw new TimeoutException("The DL expansion is timeout.");
}
ExTraceGlobals.RequestTracer.TraceDebug <string, string, ExpansionFailure>((long)this.GetHashCode(), "Error occured when expanding DL: {0}: {1} {2}", recipient.GetDistinguishedNameOrName(), failure.ToString(), failure);
addInvalidRecipient(recipient);
return(ExpansionControl.Continue);
};
try
{
this.adRecipientExpansion.Expand(adentry, handleRecipient, handleFailure);
goto IL_13C;
}
catch (Exception ex)
{
this.LogException(ex, "Error occurred when expanding PublicDL: {0}", new object[]
{
adentry.GetDistinguishedNameOrName()
});
addInvalidRecipient(adentry);
goto IL_13C;
}
}
addCertsOrInvalidRecipients(adentry);
IL_13C:
if (invalidRecipients.Count > 0)
{
Queue <EmailAddressWrapper> queue = new Queue <EmailAddressWrapper>(invalidRecipients.Count);
foreach (EmailAddressWrapper item in invalidRecipients.Values)
{
queue.Enqueue(item);
}
result = queue.ToArray();
}
else
{
result = null;
}
}
}
catch (Exception ex2)
{
this.LogException(ex2, "Error occurred when getting cert from Directory Object: {0}", new object[]
{
this.ParticipantToString(p)
});
result = this.GetCurrent(p, isCurrent, flag ? "PublicDL" : "MailBox");
}
return(result);
}
public IEnumerable <SearchRecipient> Query(ISearchPolicy policy, DirectoryQueryParameters request)
{
Recorder.Trace(5L, TraceType.InfoTrace, new object[]
{
"ActiveDirectoryProvider.Query Query:",
request.Query,
"PageSize:",
request.PageSize,
"Properties:",
request.Properties,
"ExpandGroups:",
request.ExpandGroups
});
ADPagedReader <ADRawEntry> pagedReader = policy.RecipientSession.FindPagedADRawEntry(null, QueryScope.SubTree, request.Query, null, request.PageSize, request.Properties);
new List <SearchRecipient>();
foreach (ADRawEntry entry in pagedReader)
{
if (request.ExpandGroups && SearchRecipient.IsMembershipGroup(entry))
{
Recorder.Trace(5L, TraceType.InfoTrace, "ActiveDirectoryProvider.Query Expanding:", entry);
List <ADRawEntry> groupEntries = new List <ADRawEntry>();
ADRecipientExpansion expansion = new ADRecipientExpansion(policy.RecipientSession, false, request.Properties);
ADRecipientExpansion.HandleRecipientDelegate handleDelegate = delegate(ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
if (recipientExpansionType == ExpansionType.GroupMembership)
{
return(ExpansionControl.Continue);
}
groupEntries.Add(recipient);
return(ExpansionControl.Skip);
};
ADRecipientExpansion.HandleFailureDelegate failureDelegate = delegate(ExpansionFailure expansionFailure, ADRawEntry recipient, ExpansionType recipientExpansionType, ADRawEntry parent, ExpansionType parentExpansionType)
{
Recorder.Trace(5L, TraceType.ErrorTrace, new object[]
{
"ActiveDirectoryProvider.Query Expansion Failed:",
recipient,
"Error:",
expansionFailure,
"ExpansionType:",
recipientExpansionType,
"Parent:",
parent,
"ParentyExpansionType:",
parentExpansionType
});
return(ExpansionControl.Skip);
};
expansion.Expand(entry, handleDelegate, failureDelegate);
foreach (ADRawEntry groupEntry in groupEntries)
{
yield return(new SearchRecipient(groupEntry, entry));
}
}
else
{
yield return(new SearchRecipient(entry, null));
}
}
yield break;
}
// Token: 0x06001AA4 RID: 6820 RVA: 0x0006F970 File Offset: 0x0006DB70
public void Expand(ADRawEntry recipientToExpand, ADRecipientExpansion.HandleRecipientDelegate handleRecipient, ADRecipientExpansion.HandleFailureDelegate handleFailure)
{
if (recipientToExpand == null)
{
throw new ArgumentNullException("recipientToExpand");
}
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Requested to expand recipient: {0}", new object[]
{
recipientToExpand[ADObjectSchema.Id]
});
Stack <ADRecipientExpansion.ExpandableEntry> stack = new Stack <ADRecipientExpansion.ExpandableEntry>();
if (!this.ProcessChild(recipientToExpand, null, handleRecipient, handleFailure, stack))
{
return;
}
while (stack.Count > 0)
{
ADRecipientExpansion.ExpandableEntry expandableEntry = stack.Pop();
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expanding recipient: {0}", new object[]
{
expandableEntry.Entry[ADObjectSchema.Id]
});
if (!this.ExpandEntry(expandableEntry, handleRecipient, handleFailure, stack))
{
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expansion terminated by delegate");
return;
}
}
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expansion completed");
}
// Token: 0x06001AB3 RID: 6835 RVA: 0x000700C4 File Offset: 0x0006E2C4
private bool ProcessChild(ADRawEntry child, ADRecipientExpansion.ExpandableEntry parent, ADRecipientExpansion.HandleRecipientDelegate handleRecipient, ADRecipientExpansion.HandleFailureDelegate handleFailure, Stack <ADRecipientExpansion.ExpandableEntry> expansionStack)
{
ExpansionFailure failure = ExpansionFailure.NotMailEnabled;
bool flag = false;
ExpansionType expansionType = ADRecipientExpansion.GetExpansionType(child);
ExTraceGlobals.ADExpansionTracer.TraceDebug <object, string>((long)this.GetHashCode(), "Processing recipient {0} with expansion type {1}", child[ADObjectSchema.Id], ADRecipientExpansion.GetExpansionTypeString(expansionType));
if (!this.ignoreMailEnabledCase && !this.IsMailEnabled(child))
{
failure = ExpansionFailure.NotMailEnabled;
flag = true;
}
if (!flag && !this.IsAuthorized(child))
{
failure = ExpansionFailure.NotAuthorized;
flag = true;
}
if (!flag && expansionType != ExpansionType.None && this.IsLoopDetected(child, parent))
{
failure = ExpansionFailure.LoopDetected;
flag = true;
}
if (flag)
{
return(ADRecipientExpansion.InvokeFailureDelegate(handleFailure, failure, child, expansionType, parent) != ExpansionControl.Terminate);
}
ExpansionControl expansionControl = ExpansionControl.Continue;
if (expansionType != ExpansionType.ContactChain)
{
expansionControl = ADRecipientExpansion.InvokeRecipientDelegate(handleRecipient, child, expansionType, parent);
}
if (expansionControl == ExpansionControl.Terminate)
{
return(false);
}
if (expansionControl != ExpansionControl.Skip && expansionType != ExpansionType.None)
{
expansionStack.Push(new ADRecipientExpansion.ExpandableEntry(child, expansionType, parent));
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Recipient {0} pushed on the expansion stack", new object[]
{
child[ADObjectSchema.Id]
});
}
return(true);
}
// Token: 0x06001AB2 RID: 6834 RVA: 0x0006FFDC File Offset: 0x0006E1DC
private bool ExpandContactChain(ADRecipientExpansion.ExpandableEntry contact, ADRecipientExpansion.HandleRecipientDelegate handleRecipient, ADRecipientExpansion.HandleFailureDelegate handleFailure, Stack <ADRecipientExpansion.ExpandableEntry> expansionStack)
{
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expanding possible contact chain for: {0}", new object[]
{
contact.Entry[ADObjectSchema.Id]
});
ADRawEntry adrawEntry = this.session.FindByProxyAddress((ProxyAddress)contact.Entry[ADRecipientSchema.ExternalEmailAddress], this.allProperties);
if (handleRecipient != null)
{
ExpansionType expansionType = (adrawEntry == null) ? ExpansionType.None : ExpansionType.ContactChain;
ExpansionControl expansionControl = ADRecipientExpansion.InvokeRecipientDelegate(handleRecipient, contact.Entry, expansionType, contact.Parent);
if (expansionControl != ExpansionControl.Continue)
{
return(expansionControl != ExpansionControl.Terminate);
}
}
if (adrawEntry != null)
{
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Found chained object: {0}", new object[]
{
adrawEntry[ADObjectSchema.Id]
});
return(this.ProcessChild(adrawEntry, contact, handleRecipient, handleFailure, expansionStack));
}
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "No contact chain found");
return(true);
}
// Token: 0x06001AB1 RID: 6833 RVA: 0x0006FF18 File Offset: 0x0006E118
private bool ExpandAlternateRecipient(ADRecipientExpansion.ExpandableEntry recipient, ADRecipientExpansion.HandleRecipientDelegate handleRecipient, ADRecipientExpansion.HandleFailureDelegate handleFailure, Stack <ADRecipientExpansion.ExpandableEntry> expansionStack)
{
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expanding alternate recipient for: {0}", new object[]
{
recipient.Entry[ADObjectSchema.Id]
});
ADRawEntry adrawEntry = this.session.ReadADRawEntry((ADObjectId)recipient.Entry[ADRecipientSchema.ForwardingAddress], this.allProperties);
if (adrawEntry == null)
{
ExTraceGlobals.ADExpansionTracer.TraceError((long)this.GetHashCode(), "Alternate recipient {0} for recipient {1} not found", new object[]
{
recipient.Entry[ADRecipientSchema.ForwardingAddress],
recipient.Entry[ADObjectSchema.Id]
});
return(ADRecipientExpansion.InvokeFailureDelegate(handleFailure, ExpansionFailure.AlternateRecipientNotFound, recipient));
}
return(this.ProcessChild(adrawEntry, recipient, handleRecipient, handleFailure, expansionStack));
}
// Token: 0x06001AB0 RID: 6832 RVA: 0x0006FDC8 File Offset: 0x0006DFC8
private bool ExpandGroup(ADRecipientExpansion.ExpandableEntry group, ADRecipientExpansion.HandleRecipientDelegate handleRecipient, ADRecipientExpansion.HandleFailureDelegate handleFailure, Stack <ADRecipientExpansion.ExpandableEntry> expansionStack)
{
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expanding group: {0}", new object[]
{
group.Entry[ADObjectSchema.Id]
});
IADDistributionList iaddistributionList = this.session.FindByObjectGuid((Guid)group.Entry[ADObjectSchema.Guid]) as IADDistributionList;
if (iaddistributionList == null)
{
ExTraceGlobals.ADExpansionTracer.TraceError((long)this.GetHashCode(), "Could not find group object by GUID {0}; treating the group as empty", new object[]
{
group.Entry[ADObjectSchema.Guid]
});
return(ADRecipientExpansion.InvokeFailureDelegate(handleFailure, ExpansionFailure.NoMembers, group));
}
ADPagedReader <ADRawEntry> adpagedReader = iaddistributionList.Expand(1000, this.allProperties);
bool flag = false;
foreach (ADRawEntry child in adpagedReader)
{
flag = true;
if (!this.ProcessChild(child, group, handleRecipient, handleFailure, expansionStack))
{
return(false);
}
}
if (!flag)
{
ExTraceGlobals.ADExpansionTracer.TraceDebug((long)this.GetHashCode(), "Expanded empty group: {0}", new object[]
{
group.Entry[ADObjectSchema.Id]
});
return(ADRecipientExpansion.InvokeFailureDelegate(handleFailure, ExpansionFailure.NoMembers, group));
}
return(true);
}
// Token: 0x06001AAF RID: 6831 RVA: 0x0006FD54 File Offset: 0x0006DF54
private bool ExpandEntry(ADRecipientExpansion.ExpandableEntry entry, ADRecipientExpansion.HandleRecipientDelegate handleRecipient, ADRecipientExpansion.HandleFailureDelegate handleFailure, Stack <ADRecipientExpansion.ExpandableEntry> expansionStack)
{
switch (entry.ExpansionType)
{
case ExpansionType.GroupMembership:
return(this.ExpandGroup(entry, handleRecipient, handleFailure, expansionStack));
case ExpansionType.AlternateRecipientForward:
case ExpansionType.AlternateRecipientDeliverAndForward:
return(this.ExpandAlternateRecipient(entry, handleRecipient, handleFailure, expansionStack));
case ExpansionType.ContactChain:
return(this.ExpandContactChain(entry, handleRecipient, handleFailure, expansionStack));
default:
throw new InvalidOperationException("Invalid expansion type: " + entry.ExpansionType.ToString());
}
}
// Token: 0x06001AAD RID: 6829 RVA: 0x0006FCE2 File Offset: 0x0006DEE2
private static bool InvokeFailureDelegate(ADRecipientExpansion.HandleFailureDelegate handleFailure, ExpansionFailure failure, ADRecipientExpansion.ExpandableEntry recipient)
{
return(ADRecipientExpansion.InvokeFailureDelegate(handleFailure, failure, recipient.Entry, recipient.ExpansionType, recipient.Parent) != ExpansionControl.Terminate);
}
