// Token: 0x06000036 RID: 54 RVA: 0x00003A30 File Offset: 0x00001C30
private void TrackDecision(MessageItem messageItem, bool isApproved)
{
string valueOrDefault = messageItem.GetValueOrDefault <string>(ItemSchema.InternetReferences, string.Empty);
string valueOrDefault2 = messageItem.GetValueOrDefault <string>(MessageItemSchema.ApprovalRequestor);
MessageTrackingLog.TrackModeratorDecision(MessageTrackingSource.APPROVAL, messageItem.InternetMessageId, valueOrDefault, valueOrDefault2, this.GetModeratedRecipients(messageItem, true), isApproved, ModeratedDLApplication.GetOrganizationIdFromMessage(messageItem));
}
// Token: 0x0600000E RID: 14 RVA: 0x00002471 File Offset: 0x00000671
public void HandleLogFlush()
{
Components.SmtpInComponent.FlushProtocolLog();
Components.SmtpOutConnectionHandler.FlushProtocolLog();
ConnectionLog.FlushBuffer();
MessageTrackingLog.FlushBuffer();
}
// Token: 0x06000013 RID: 19 RVA: 0x00002448 File Offset: 0x00000648
protected override void OnCustomCommandInternal(int command)
{
switch (command)
{
case 201:
this.components.ConfigUpdate();
return;
case 202:
case 204:
break;
case 203:
Components.Configuration.ClearCaches();
return;
case 205:
Kerberos.FlushTicketCache();
return;
case 206:
Components.SmtpInComponent.FlushProtocolLog();
Components.SmtpOutConnectionHandler.FlushProtocolLog();
ConnectionLog.FlushBuffer();
MessageTrackingLog.FlushBuffer();
break;
default:
return;
}
}
// Token: 0x0600002B RID: 43 RVA: 0x000035DC File Offset: 0x000017DC
internal override void OnStart()
{
lock (ModeratedDLApplication.SyncRoot)
{
if (ModeratedDLApplication.refCount == 0)
{
MessageTrackingLog.Start("MSGTRKMA");
Server server = null;
ADNotificationAdapter.TryRunADOperation(delegate()
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 144, "OnStart", "f:\\15.00.1497\\sources\\dev\\Approval\\src\\Applications\\ModeratedDLApplication\\ModeratedDLApplication.cs");
this.serverConfigNotificationCookie = ADNotificationAdapter.RegisterChangeNotification <Server>(topologyConfigurationSession.GetOrgContainerId(), new ADNotificationCallback(ModeratedDLApplication.ServerChangeCallback));
server = topologyConfigurationSession.ReadLocalServer();
Microsoft.Exchange.Data.Directory.SystemConfiguration.AcceptedDomain acceptedDomain = topologyConfigurationSession.GetDefaultAcceptedDomain();
if (acceptedDomain != null && acceptedDomain.DomainName.SmtpDomain != null)
{
this.defaultAcceptedDomain = acceptedDomain.DomainName.SmtpDomain.Domain;
}
});
if (server == null)
{
ModeratedDLApplication.diag.TraceError((long)this.GetHashCode(), "Cannot read local server for message tracking");
}
MessageTrackingLog.Configure(server);
}
ModeratedDLApplication.refCount++;
}
base.OnStart();
}
// Token: 0x06000025 RID: 37 RVA: 0x00003428 File Offset: 0x00001628
public void OnSkipEvent(MapiEvent mapiEvent, Exception exception)
{
try
{
MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.Remove(mapiEvent.EventCounter);
string text = this.FormatMapiEventInfo(mapiEvent);
Exception ex = exception;
if (ex != null)
{
while (ex.InnerException != null)
{
ex = ex.InnerException;
}
}
string text2 = "Error: SkipEvent";
if (ex != null)
{
text2 = text2 + ", Diagnostic Information: " + ex.GetType().Name;
}
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <string, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "{0} will be skipped due to error {1}", text, text2);
MsgTrackMapiSubmitInfo msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, string.Empty, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, string.Empty, string.Empty, mapiEvent.ItemEntryId, string.Empty, text2, true, false);
MessageTrackingLog.TrackMapiSubmit(msgTrackInfo);
}
catch (Exception arg)
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail <Exception>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Unexpected exception {0} during skipped event logging", arg);
}
}
// Token: 0x0600003A RID: 58 RVA: 0x00003ACC File Offset: 0x00001CCC
private void LogMessageTrackingInfo(string remoteHostName, IPAddress localIP, string localServerName, MapiEvent mapiEvent, MailSubmissionResult result, string latencyString)
{
SubmissionRecord.Drop(this.successHistory, this.failureHistory, mapiEvent, result);
string text = this.FormatMapiEventInfo(mapiEvent);
MsgTrackMapiSubmitInfo msgTrackInfo;
if (result.ErrorCode == 0U)
{
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePass <string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission succeeded for {0}", text);
msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, remoteHostName, localIP, localServerName, result.Sender, result.From, result.MessageId, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), Components.Configuration.LocalServer.TransportServer.MessageTrackingLogSubjectLoggingEnabled ? result.Subject : "[Undisclosed]", latencyString, result.DiagnosticInfo, null != mapiEvent, result.ExternalOrganizationId, result.OrganizationId, result.RecipientAddresses, MailDirectionality.Originating, result.NetworkMessageId, result.OriginalClientIPAddress);
}
else
{
string text2 = HResult.GetStringForErrorCode(result.ErrorCode);
if (!string.IsNullOrEmpty(result.DiagnosticInfo))
{
text2 = "Error: " + text2 + ", Diagnostic Information: " + result.DiagnosticInfo;
}
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePass <string, string>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "Submission failed for {0}, error: {1}", text, text2);
if (!HResult.IsHandled(result.ErrorCode) && !MailboxTransportSubmissionAssistant.ShouldLogTemporaryFailures)
{
return;
}
msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, remoteHostName, localIP, localServerName, result.Sender, result.MessageId, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), latencyString, text2, HResult.IsHandled(result.ErrorCode), null != mapiEvent, result.ExternalOrganizationId, result.OrganizationId, result.RecipientAddresses, MailDirectionality.Originating, result.NetworkMessageId);
}
if (11U == result.ErrorCode)
{
MessageTrackingLog.TrackThrottle(MessageTrackingSource.STOREDRIVER, msgTrackInfo, result.Sender, result.MessageId, MailDirectionality.Originating);
return;
}
MessageTrackingLog.TrackMapiSubmit(msgTrackInfo);
}
internal static bool ResubmitApprovedMessage(MessageItem messageItem, TransportMailItem transportMailItem, string approverAddress)
{
DateTime utcNow = DateTime.UtcNow;
HeaderList headerList = (transportMailItem.RootPart != null) ? transportMailItem.RootPart.Headers : null;
if (!ModerationHelper.RestoreOriginalMessage(messageItem, transportMailItem, TraceHelper.ModeratedTransportTracer, TraceHelper.MessageProbeActivityId))
{
return(false);
}
transportMailItem.RootPart.Headers.RemoveAll("X-MS-Exchange-Organization-Approval-Approved");
TextHeader textHeader = (TextHeader)Header.Create("X-MS-Exchange-Organization-Approval-Approved");
textHeader.Value = (string)transportMailItem.Recipients[0].Email;
foreach (MailRecipient mailRecipient in transportMailItem.Recipients)
{
if (mailRecipient.Status == Status.Ready)
{
textHeader.Value = (string)mailRecipient.Email;
break;
}
}
transportMailItem.RootPart.Headers.AppendChild(textHeader);
if (transportMailItem.RootPart.Headers.FindFirst("X-MS-Exchange-Organization-Moderation-SavedArrivalTime") == null)
{
Header header = transportMailItem.RootPart.Headers.FindFirst("X-MS-Exchange-Organization-OriginalArrivalTime");
string value = null;
if (header != null)
{
value = header.Value;
}
if (!string.IsNullOrEmpty(value))
{
transportMailItem.RootPart.Headers.AppendChild(new AsciiTextHeader("X-MS-Exchange-Organization-Moderation-SavedArrivalTime", value));
}
}
TextHeader textHeader2 = (TextHeader)Header.Create("X-Moderation-Data");
ExDateTime?valueAsNullable = messageItem.GetValueAsNullable <ExDateTime>(MessageItemSchema.ApprovalDecisionTime);
if (valueAsNullable != null)
{
textHeader2.Value = valueAsNullable.ToString();
transportMailItem.RootPart.Headers.AppendChild(textHeader2);
}
if (headerList != null)
{
Header[] array = headerList.FindAll(HeaderId.Received);
foreach (Header header2 in array)
{
Header header3 = Header.Create(HeaderId.Received);
header2.CopyTo(header3);
transportMailItem.RootPart.Headers.PrependChild(header3);
}
}
transportMailItem.RootPart.Headers.RemoveAll("X-MS-Exchange-Organization-OriginalArrivalTime");
transportMailItem.RootPart.Headers.AppendChild(new AsciiTextHeader("X-MS-Exchange-Organization-OriginalArrivalTime", Util.FormatOrganizationalMessageArrivalTime(utcNow)));
transportMailItem.UpdateDirectionalityAndScopeHeaders();
transportMailItem.UpdateCachedHeaders();
MessageTrackingLog.TrackReceiveForApprovalRelease(transportMailItem, approverAddress, messageItem.InternetMessageId);
return(true);
}
public override void SubmitMailItem(TransportMailItem mailItem, bool suppressDSNs)
{
StoreDriverDeliveryEventArgs storeDriverDeliveryEventArgs = null;
if (base.AssociatedAgent != null && base.AssociatedAgent.Session != null && base.AssociatedAgent.Session.CurrentEventArgs != null)
{
storeDriverDeliveryEventArgs = (base.AssociatedAgent.Session.CurrentEventArgs as StoreDriverDeliveryEventArgs);
}
bool flag = this.agentLoopChecker.IsEnabledInSubmission();
bool flag2 = false;
if (storeDriverDeliveryEventArgs != null && !string.IsNullOrEmpty(base.AssociatedAgent.Name))
{
flag2 = this.agentLoopChecker.CheckAndStampInSubmission(storeDriverDeliveryEventArgs.MailItem.Message.RootPart.Headers, mailItem.RootPart.Headers, base.AssociatedAgent.Name);
if (flag2)
{
MessageTrackingLog.TrackAgentGeneratedMessageRejected(MessageTrackingSource.STOREDRIVER, flag, mailItem);
}
}
if (flag2 && flag)
{
using (IEnumerator <MailRecipient> enumerator = mailItem.Recipients.GetEnumerator())
{
while (enumerator.MoveNext())
{
MailRecipient mailRecipient = enumerator.Current;
mailRecipient.Ack(AckStatus.Fail, SmtpResponse.AgentGeneratedMessageDepthExceeded);
}
return;
}
}
Utils.SubmitMailItem(mailItem, suppressDSNs);
}
// Token: 0x06000024 RID: 36 RVA: 0x000030E0 File Offset: 0x000012E0
public void HandleEvent(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item)
{
MailboxTransportSubmissionAssistant.IdentifyProbeMessage(mapiEvent);
Thread currentThread = Thread.CurrentThread;
try
{
Interlocked.Increment(ref this.concurrentEvents);
this.SubmissionsInProgress[currentThread] = new SubmissionsInProgress.Entry(ExDateTime.UtcNow, this.databaseInfo.Guid, mapiEvent);
using (new SenderGuidTraceFilter(this.databaseInfo.Guid, mapiEvent.MailboxGuid))
{
bool flag = true;
MailboxTransportSubmissionAssistant.LatencyRecord latencyRecord;
LatencyTracker latencyTracker;
if (MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.TryGetValue(mapiEvent.EventCounter, out latencyRecord))
{
MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.Remove(mapiEvent.EventCounter);
latencyTracker = latencyRecord.LatencyTracker;
LatencyTracker.EndTrackLatency(latencyRecord.LatencyComponent, latencyTracker, true);
flag = false;
}
else
{
latencyTracker = LatencyTracker.CreateInstance(LatencyComponent.MailboxTransportSubmissionService);
LatencyTracker.TrackPreProcessLatency(LatencyComponent.SubmissionAssistant, latencyTracker, mapiEvent.CreateTime);
}
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
string text = this.FormatMapiEventInfo(mapiEvent);
this.LogMapiEventIntoCrimsonChannelPeriodically(text);
this.SubmissionsInProgress[Thread.CurrentThread].LatencyTracker = latencyTracker;
if (MailboxTransportSubmissionAssistant.ShouldLogNotifyEvents && (flag || MailboxTransportSubmissionAssistant.ShouldLogTemporaryFailures))
{
LatencyFormatter latencyFormatter = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, mapiEvent.CreateTime, mapiEvent.CreateTime, true, false, false);
MsgTrackMapiSubmitInfo msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, string.Empty, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, string.Empty, string.Empty, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), latencyFormatter.FormatAndUpdatePerfCounters(), null, false, true);
MessageTrackingLog.TrackNotify(msgTrackInfo, false);
}
MSExchangeSubmission.PendingSubmissions.Increment();
new HashSet <string>();
DateTime createTime = mapiEvent.CreateTime;
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, Guid, long>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "PFD EMS {0} SubmitMail for mailbox {1} at entry {2}", 22427, mapiEvent.MailboxGuid, mapiEvent.EventCounter);
LatencyFormatter latencyFormatter2 = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, createTime, createTime, false, true, false);
bool isPublicFolder = mapiEvent.ExtendedEventFlags.HasFlag(MapiExtendedEventFlags.PublicFolderMailbox);
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
ISubmissionProvider submissionProvider = (ISubmissionProvider)Components.StoreDriverSubmission;
MailSubmissionResult mailSubmissionResult = submissionProvider.SubmitMessage(Components.Configuration.LocalServer.TransportServer.ExchangeLegacyDN, mapiEvent.MailboxGuid, this.databaseInfo.Guid, this.databaseInfo.DatabaseName, mapiEvent.EventCounter, mapiEvent.ItemEntryId, mapiEvent.ParentEntryId, Components.Configuration.LocalServer.TransportServer.Fqdn, new IPAddress(StoreDriverSubmission.LocalIPAddress.GetAddressBytes()), mapiEvent.CreateTime, isPublicFolder, (mapiEvent.TenantHint == null) ? null : TenantPartitionHint.FromPersistablePartitionHint(mapiEvent.TenantHint), latencyFormatter2.FormatAndUpdatePerfCounters(), MailboxTransportSubmissionService.QuarantineHandler, MailboxTransportSubmissionService.SubmissionPoisonHandler, latencyTracker);
MailSubmissionResult result = mailSubmissionResult;
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
this.LogAndUpdateCounters(mapiEvent, latencyTracker, createTime, result);
this.HandleEventError(mapiEvent, result, latencyTracker, text);
}
}
finally
{
MSExchangeSubmission.PendingSubmissions.Decrement();
Interlocked.Decrement(ref this.concurrentEvents);
this.SubmissionsInProgress.Remove(currentThread);
}
}
private void LogPoisonMessageMTL(SubmissionInfo submissionInfo, SubmissionPoisonContext submissionPoisonContext)
{
this.storeDriverTracer.StoreDriverSubmissionTracer.TracePass <SubmissionInfo>(this.storeDriverTracer.MessageProbeActivityId, 0L, "Found poison message for {0}", submissionInfo);
MsgTrackPoisonInfo msgTrackingPoisonInfo = new MsgTrackPoisonInfo(submissionInfo.NetworkAddress, submissionInfo.MailboxFqdn, StoreDriverSubmission.LocalIPAddress, submissionPoisonContext.MapiEventCounter.ToString() + ": " + submissionPoisonContext.ResourceGuid.ToString());
MessageTrackingLog.TrackPoisonMessage(MessageTrackingSource.STOREDRIVER, msgTrackingPoisonInfo);
submissionInfo.LogEvent(SubmissionInfo.Event.StoreDriverSubmissionPoisonMessageInSubmission);
}
// Token: 0x06000030 RID: 48 RVA: 0x00003784 File Offset: 0x00001984
internal override void OnAllDecisionMakersNdred(MessageItem messageItem)
{
string valueOrDefault = messageItem.GetValueOrDefault <string>(ItemSchema.InternetReferences, string.Empty);
string valueOrDefault2 = messageItem.GetValueOrDefault <string>(MessageItemSchema.ApprovalRequestor);
MessageTrackingLog.TrackModeratorsAllNdr(MessageTrackingSource.APPROVAL, messageItem.InternetMessageId, valueOrDefault, valueOrDefault2, this.GetModeratedRecipients(messageItem, true), ModeratedDLApplication.GetOrganizationIdFromMessage(messageItem));
this.SendExpiryNdrOofNotification(messageItem, ApprovalInformation.ApprovalNotificationType.ModeratorsNdrNotification);
}
public void Load(IMbxDeliveryListener submitHandler)
{
if (!this.isInitialized)
{
DeliveryConfiguration.app.Load();
this.submitHandler = submitHandler;
this.ConstructComponentLoadTree();
DeliveryConfiguration.components.Start(new Components.StopServiceHandler(DeliveryConfiguration.OnStopServiceBecauseOfFailure), false, false, true, true);
DeliveryConfiguration.components.Continue();
MessageTrackingLog.Configure(Components.Configuration.LocalServer.TransportServer);
LatencyTracker.Start(Components.TransportAppConfig.LatencyTracker, ProcessTransportRole.MailboxDelivery);
this.isInitialized = true;
}
}
protected override void MessageTrackThrottle <C, L>(string limitType, C count, L limit)
{
if (base.ServerIPAddress == null)
{
base.ServerIPAddress = this.context.LocalServerNetworkAddress;
}
RuleEvaluationContext ruleEvaluationContext = this.context as RuleEvaluationContext;
MessageTrackingLog.TrackThrottle(MessageTrackingSource.MAILBOXRULE, ruleEvaluationContext.MbxTransportMailItem, base.ServerIPAddress, this.context.CurrentFolderDisplayName, string.Format(CultureInfo.InvariantCulture, "{0}:{1}/{2}", new object[]
{
limitType,
count,
limit
}), this.context.Recipient, this.context.CurrentRule.Name);
}
// Token: 0x06000031 RID: 49 RVA: 0x000037D4 File Offset: 0x000019D4
internal override bool OnExpire(MessageItem messageItem, out bool sendUpdate)
{
sendUpdate = false;
string valueOrDefault = messageItem.GetValueOrDefault <string>(ItemSchema.InternetReferences, string.Empty);
string valueOrDefault2 = messageItem.GetValueOrDefault <string>(MessageItemSchema.ApprovalRequestor);
if ((!VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && !Datacenter.IsPartnerHostedOnly(true)) || ModeratedDLApplication.ExpiryNotificationCounterWrapper.Instance.IncrementCountAndCheckLimit())
{
sendUpdate = true;
this.SendExpiryNdrOofNotification(messageItem, ApprovalInformation.ApprovalNotificationType.ExpiryNotification);
this.SendModeratorExpiryNotification(messageItem, ApprovalInformation.ApprovalNotificationType.ModeratorExpiryNotification);
}
MessageTrackingLog.TrackModeratorExpired(MessageTrackingSource.APPROVAL, messageItem.InternetMessageId, valueOrDefault, valueOrDefault2, this.GetModeratedRecipients(messageItem, true), ModeratedDLApplication.GetOrganizationIdFromMessage(messageItem), sendUpdate);
return(true);
}
// Token: 0x06000006 RID: 6 RVA: 0x00002558 File Offset: 0x00000758
protected override void OnStopInternal()
{
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StopService);
MailboxTransportDeliveryService.isExiting = true;
ADNotificationListener.Stop();
MailboxTransportDeliveryService.diag.TraceDebug <DateTime>(0L, "Stopping MailTransportDeliveryService ({0})", DateTime.UtcNow);
bool flag = false;
try
{
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StopBackgroundThread);
if (MailboxTransportDeliveryService.backgroundThread != null)
{
MailboxTransportDeliveryService.backgroundThread.Stop();
}
if (this.isDiagnosticHandlerRegisteredForSettingOverrideSync)
{
try
{
ProcessAccessManager.UnregisterComponent(SettingOverrideSync.Instance);
}
catch (RpcException ex)
{
MailboxTransportDeliveryService.diag.TraceError <string>(0L, "Failed to unregister SettingOverride component with Rpc Server. Error : {0}", ex.ToString());
}
}
SettingOverrideSync.Instance.Stop();
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StopMessageTracking);
MessageTrackingLog.Stop();
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StopConfiguration);
DeliveryConfiguration.Instance.Unload();
MailboxTransportEventLogger.LogEvent(MSExchangeDeliveryEventLogConstants.Tuple_DeliveryServiceStopSuccess, null, new string[0]);
MailboxTransportDeliveryService.diag.TraceDebug(0L, "Stopped MailboxDeliveryService");
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.UngregisterPamComponent);
ProcessAccessManager.UnregisterComponent(this);
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.ServiceStopped);
flag = true;
}
finally
{
if (!flag)
{
MailboxTransportEventLogger.LogEvent(MSExchangeDeliveryEventLogConstants.Tuple_DeliveryServiceStopFailure, null, new string[0]);
MailboxTransportDeliveryService.diag.TraceError(0L, "Failed to stop MailboxDeliveryService");
}
}
DeliveryThrottling.Instance.Dispose();
}
// Token: 0x06000032 RID: 50 RVA: 0x0000389C File Offset: 0x00001A9C
private static void ServerChangeCallback(ADNotificationEventArgs args)
{
Server server = null;
ADNotificationAdapter.TryReadConfiguration <Server>(delegate()
{
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 362, "ServerChangeCallback", "f:\\15.00.1497\\sources\\dev\\Approval\\src\\Applications\\ModeratedDLApplication\\ModeratedDLApplication.cs");
return(topologyConfigurationSession.ReadLocalServer());
}, out server);
if (server == null)
{
ModeratedDLApplication.diag.TraceError(0L, "Cannot read local server for updating message tracking config. Continue with previous config.");
return;
}
MessageTrackingLog.Configure(server);
}
// Token: 0x0600002C RID: 44 RVA: 0x00003688 File Offset: 0x00001888
internal override void OnStop()
{
lock (ModeratedDLApplication.SyncRoot)
{
ModeratedDLApplication.refCount--;
if (ModeratedDLApplication.refCount == 0)
{
if (this.serverConfigNotificationCookie != null)
{
ADNotificationAdapter.UnregisterChangeNotification(this.serverConfigNotificationCookie);
this.serverConfigNotificationCookie = null;
}
MessageTrackingLog.Stop();
}
}
base.OnStop();
}
private void MessageTrackMailItem(TransportMailItem mailItem, IList <string> invalidRecipients)
{
MsgTrackReceiveInfo msgTrackInfo = new MsgTrackReceiveInfo(StoreDriverDelivery.LocalIPAddress, ((ulong)this.workItem.Rule.ID).ToString(), this.context.Message.InternetMessageId, mailItem.MessageTrackingSecurityInfo, invalidRecipients);
if (mailItem.Recipients.Count == 0)
{
MessageTrackingLog.TrackReceive(MessageTrackingSource.MAILBOXRULE, mailItem, msgTrackInfo);
this.context.TraceDebug("SmtpSubmissionItem: Rule generated mail without valid recipients");
return;
}
if (this.context.ProcessingTestMessage)
{
this.context.TraceDebug("SmtpSubmissionItem: Do not commit rule generated message from diagnostic test message");
return;
}
MessageTrackingLog.TrackReceive(MessageTrackingSource.MAILBOXRULE, mailItem, msgTrackInfo);
this.context.TraceDebug <long>("SmtpSubmissionItem committed new message {0}", mailItem.RecordId);
}
public void Submit(MessageTrackingSource messageTrackingSource, MemorySubmissionItem.OnConvertedToTransportMailItemDelegate transportMailItemHandler, MbxTransportMailItem relatedMailItem)
{
TransportMailItem transportMailItem;
if (relatedMailItem == null)
{
transportMailItem = TransportMailItem.NewMailItem(this.organizationId, LatencyComponent.StoreDriverSubmit, MailDirectionality.Originating, default(Guid));
}
else
{
transportMailItem = TransportMailItem.NewSideEffectMailItem(relatedMailItem, this.organizationId, LatencyComponent.StoreDriverSubmit, MailDirectionality.Originating, relatedMailItem.ExternalOrganizationId);
}
base.CopyContentTo(transportMailItem);
base.DecorateMessage(transportMailItem);
base.ApplySecurityAttributesTo(transportMailItem);
if (relatedMailItem != null)
{
transportMailItem.PrioritizationReason = relatedMailItem.PrioritizationReason;
transportMailItem.Priority = relatedMailItem.Priority;
}
SubmissionItemUtils.CopySenderTo(this, transportMailItem);
List <string> invalidRecipients = null;
List <string> list = null;
SubmissionItemUtils.CopyRecipientsTo(this, transportMailItem, null, ref invalidRecipients, ref list);
ClassificationUtils.PromoteStoreClassifications(transportMailItem.RootPart.Headers);
SubmissionItemUtils.PatchQuarantineSender(transportMailItem, base.QuarantineOriginalSender);
bool flag = transportMailItem.Recipients.Count > 0;
if (relatedMailItem != null)
{
MimeInternalHelpers.CopyHeaderBetweenList(relatedMailItem.RootPart.Headers, transportMailItem.RootPart.Headers, "X-MS-Exchange-Moderation-Loop");
}
bool flag2 = transportMailItemHandler(transportMailItem, flag);
if (flag && flag2)
{
MsgTrackReceiveInfo msgTrackInfo = new MsgTrackReceiveInfo(StoreDriverDelivery.LocalIPAddress, (relatedMailItem != null) ? new long?(relatedMailItem.RecordId) : null, transportMailItem.MessageTrackingSecurityInfo, invalidRecipients);
MessageTrackingLog.TrackReceive(messageTrackingSource, transportMailItem, msgTrackInfo);
Utils.SubmitMailItem(transportMailItem, false);
}
}
// Token: 0x06000019 RID: 25 RVA: 0x00002A5C File Offset: 0x00000C5C
private void OnStopInternalHelper()
{
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StopService);
ADNotificationListener.Stop();
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePass <DateTime>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "Stopping MailboxTransportSubmissionService ({0})", DateTime.UtcNow);
bool flag = false;
try
{
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StopBackgroundThread);
if (MailboxTransportSubmissionService.backgroundThread != null)
{
MailboxTransportSubmissionService.backgroundThread.Stop();
}
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StopDatabaseManager);
if (this.databaseManager != null)
{
this.databaseManager.Stop();
this.databaseManager.Dispose();
}
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StopMessageTracking);
MessageTrackingLog.Stop();
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StopConfiguration);
SubmissionConfiguration.Instance.Unload();
MailboxTransportSubmissionEventLogger.LogEvent(MSExchangeSubmissionEventLogConstants.Tuple_SubmissionServiceStopSuccess, null, new object[0]);
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePass(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "Stopped MailboxTransportSubmissionService");
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.UngregisterPamComponent);
ProcessAccessManager.UnregisterComponent(this);
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.ServiceStopped);
flag = true;
}
finally
{
if (!flag)
{
MailboxTransportSubmissionEventLogger.LogEvent(MSExchangeSubmissionEventLogConstants.Tuple_SubmissionServiceStopFailure, null, new object[0]);
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TraceFail(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "Failed to stop MailboxTransportSubmissionService");
}
}
}
public void TrackAgentInfo()
{
MessageTrackingLog.TrackAgentInfo(this.mailItem);
}
// Token: 0x06000005 RID: 5 RVA: 0x00002340 File Offset: 0x00000540
protected override void OnStartInternal(string[] args)
{
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StartService);
MailboxTransportDeliveryService.diag.TracePfd <int, DateTime>(0L, "PFD EMS {0} Starting MailboxDeliveryService ({1})", 24475, DateTime.UtcNow);
bool flag = false;
bool flag2 = false;
string text = string.Empty;
try
{
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.RegisterPamComponent);
ProcessAccessManager.RegisterComponent(this);
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StartMessageTracking);
MessageTrackingLog.Start("MSGTRKMD");
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.LoadConfiguration);
StorageExceptionHandler.Init();
DeliveryConfiguration.Instance.Load(MailboxTransportDeliveryService.messageListener);
try
{
ProcessAccessManager.RegisterComponent(SettingOverrideSync.Instance);
this.isDiagnosticHandlerRegisteredForSettingOverrideSync = true;
}
catch (RpcException ex)
{
MailboxTransportDeliveryService.diag.TraceError <string>(0L, "Failed to register SettingOverride component with Rpc Server. Error : {0}", ex.ToString());
}
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.StartBackgroundThread);
MailboxTransportDeliveryService.backgroundThread = new BackgroundThreadDelivery();
MailboxTransportDeliveryService.backgroundThread.Start(false, ServiceState.Active);
MailboxTransportEventLogger.LogEvent(MSExchangeDeliveryEventLogConstants.Tuple_DeliveryServiceStartSuccess, null, new string[0]);
MailboxTransportDeliveryService.LogStage(MailboxTransportDeliveryService.Stage.ServiceStarted);
MailboxTransportDeliveryService.diag.TracePfd <int>(0L, "PFD EMS {0} MailTransportDeliveryService Started", 26523);
flag = true;
}
catch (ADTransientException ex2)
{
MailboxTransportDeliveryService.diag.TraceError <string>(0L, "Failed to start MailboxDeliveryService. Error: {0}", ex2.ToString());
MailboxTransportEventLogger.LogEvent(MSExchangeDeliveryEventLogConstants.Tuple_DeliveryServiceStartFailure, null, new string[]
{
ex2.ToString()
});
MailboxTransportDeliveryService.PublishServiceStartFailureNotification(ex2.Message);
Environment.Exit(1);
}
catch (ConfigurationErrorsException ex3)
{
text = ex3.Message;
flag2 = true;
}
catch (HandlerParseException ex4)
{
text = ex4.Message;
flag2 = true;
}
finally
{
if (!flag)
{
MailboxTransportEventLogger.LogEvent(MSExchangeDeliveryEventLogConstants.Tuple_DeliveryServiceStartFailure, null, new string[]
{
text
});
MailboxTransportDeliveryService.PublishServiceStartFailureNotification(text);
MailboxTransportDeliveryService.diag.TraceError(0L, "Failed to start MailboxDeliveryService");
if (flag2)
{
base.Stop();
}
}
}
}
