private static void LogRetryExceptionInConnectionLog(RetryException exception, MbxTransportMailItem mbxItem, string sourceContext, ulong sessionId, ulong bytesDelivered, ulong recipientCount)
{
StringBuilder stringBuilder = new StringBuilder(400);
stringBuilder.Append("Lost connection - scheduling retry. ");
if (exception.MessageStatus.Exception != null)
{
string exceptionTypeString = StorageExceptionHandler.GetExceptionTypeString(exception.MessageStatus.Exception);
string exceptionDiagnosticInfo = StorageExceptionHandler.GetExceptionDiagnosticInfo(exception.MessageStatus.Exception);
if (string.IsNullOrEmpty(exceptionDiagnosticInfo))
{
stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "SmtpResponse: {0}: {1}: {2}.", new object[]
{
exception.MessageStatus.Response,
exception.StoreDriverContext,
exceptionTypeString
});
}
else
{
stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "SmtpResponse: {0}: {1}: {2}: {3}", new object[]
{
exception.MessageStatus.Response,
exception.StoreDriverContext,
exceptionTypeString,
exceptionDiagnosticInfo
});
}
}
ConnectionLog.MapiDeliveryConnectionLost(sessionId, mbxItem.DatabaseName, stringBuilder.ToString(), 1UL, bytesDelivered, recipientCount);
}
private MailSubmissionResult SubmitMessageImpl(MapiSubmissionInfo submissionInfo, SubmissionPoisonHandler submissionPoisonHandler, QuarantineHandler quarantineHandler)
{
MailSubmissionResult mailSubmissionResult = new MailSubmissionResult();
if (this.Retired)
{
mailSubmissionResult.ErrorCode = 2214592514U;
return(mailSubmissionResult);
}
string mailboxFqdn = submissionInfo.MailboxFqdn;
string database = submissionInfo.MdbGuid.ToString();
MailSubmissionResult result;
using (submissionInfo.GetTraceFilter())
{
using (SubmissionConnectionWrapper connection = SubmissionConnectionPool.GetConnection(mailboxFqdn, database))
{
using (SubmissionThreadLimiter submissionThreadLimiter = new SubmissionThreadLimiter())
{
SubmissionPoisonContext submissionPoisonContext = null;
try
{
submissionThreadLimiter.BeginSubmission(connection.Id, mailboxFqdn, database);
if (this.Retired)
{
mailSubmissionResult.ErrorCode = 2214592514U;
connection.SubmissionAborted("Retiring.");
result = mailSubmissionResult;
}
else
{
this.storeDriverTracer.StoreDriverSubmissionTracer.TracePfdPass <int, MapiSubmissionInfo>(this.storeDriverTracer.MessageProbeActivityId, 0L, "PFD ESD {0} Processing SubmitMessage for {1}", 27547, submissionInfo);
submissionPoisonContext = submissionInfo.GetPoisonContext();
MailItemSubmitter mailItemSubmitter2;
MailItemSubmitter mailItemSubmitter = mailItemSubmitter2 = new MailItemSubmitter(connection.Id, submissionInfo, this.sendAsManager, submissionPoisonHandler, submissionPoisonContext, this);
try
{
QuarantineInfoContext quarantineInfoContext;
TimeSpan timeSpan;
if (SubmissionConfiguration.Instance.App.EnableMailboxQuarantine && quarantineHandler.IsResourceQuarantined(submissionPoisonContext.ResourceGuid, out quarantineInfoContext, out timeSpan))
{
mailSubmissionResult.ErrorCode = 1140850696U;
mailSubmissionResult.QuarantineTimeSpan = timeSpan;
mailSubmissionResult.DiagnosticInfo = string.Format("{0}:{1}, QuarantineRemainingTimeSpan:{2}", "QuarantineStart", quarantineInfoContext.QuarantineStartTime, timeSpan);
connection.SubmissionFailed(string.Format("Resource {0} is in quarantined state", submissionPoisonContext.ResourceGuid));
return(mailSubmissionResult);
}
if (this.PoisonMessageDectionEnabled && submissionPoisonHandler.VerifyPoisonMessage(submissionPoisonContext))
{
this.LogPoisonMessageMTL(submissionInfo, submissionPoisonContext);
if (SubmissionConfiguration.Instance.App.EnableSendNdrForPoisonMessage)
{
if (!submissionPoisonHandler.VerifyPoisonNdrSent(submissionPoisonContext))
{
mailItemSubmitter.HandlePoisonMessageNdrSubmission();
mailSubmissionResult.ErrorCode = StoreDriverSubmissionUtils.MapSubmissionStatusErrorCodeToPoisonErrorCode(mailItemSubmitter.Result.ErrorCode);
}
}
else
{
mailSubmissionResult.ErrorCode = 3U;
}
connection.SubmissionAborted(string.Format("Poison Context Info: Resource = {0};EventCounter = {1}.", submissionPoisonContext.ResourceGuid, submissionPoisonContext.MapiEventCounter));
return(mailSubmissionResult);
}
Thread currentThread = Thread.CurrentThread;
try
{
this.SubmissionsInProgress[currentThread] = mailItemSubmitter;
mailItemSubmitter.Submit();
mailSubmissionResult.RemoteHostName = mailItemSubmitter.Result.RemoteHostName;
}
finally
{
this.SubmissionsInProgress.Remove(currentThread);
}
}
finally
{
if (mailItemSubmitter2 != null)
{
((IDisposable)mailItemSubmitter2).Dispose();
}
}
if (mailItemSubmitter.Result.ErrorCode == 0U)
{
connection.SubmissionSuccessful(mailItemSubmitter.MessageSize, mailItemSubmitter.RecipientCount);
}
else
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("HResult: ");
stringBuilder.Append(mailItemSubmitter.Result.ErrorCode.ToString());
stringBuilder.Append("; DiagnosticInfo: ");
stringBuilder.Append(mailItemSubmitter.Result.DiagnosticInfo);
connection.SubmissionFailed(stringBuilder.ToString());
}
if (mailItemSubmitter.Result.ErrorCode == 3U)
{
submissionInfo.LogEvent(SubmissionInfo.Event.StoreDriverSubmissionPoisonMessageInSubmission);
}
result = mailItemSubmitter.Result;
}
}
catch (ThreadLimitExceededException ex)
{
connection.SubmissionAborted(ex.Message);
mailSubmissionResult.ErrorCode = 1090519042U;
mailSubmissionResult.DiagnosticInfo = ex.Message;
result = mailSubmissionResult;
}
catch (Exception exception)
{
try
{
submissionPoisonHandler.SavePoisonContext(submissionPoisonContext);
string exceptionDiagnosticInfo = StorageExceptionHandler.GetExceptionDiagnosticInfo(exception);
connection.SubmissionFailed("Exception: " + exceptionDiagnosticInfo);
submissionInfo.LogEvent(SubmissionInfo.Event.StoreDriverSubmissionPoisonMessage, exception);
FailFast.Fail(exception);
}
catch (Exception ex2)
{
StoreDriverSubmission.LogEvent(MSExchangeStoreDriverSubmissionEventLogConstants.Tuple_StoreDriverSubmissionFailFastFailure, null, new object[]
{
ex2
});
}
result = mailSubmissionResult;
}
}
}
}
return(result);
}
// Token: 0x06000018 RID: 24 RVA: 0x0000283C File Offset: 0x00000A3C
private void OnStartInternalHelper()
{
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StartService);
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, DateTime>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "PFD EMS {0} Starting MailboxTransportSubmissionService ({1})", 24475, DateTime.UtcNow);
bool flag = false;
bool flag2 = false;
string text = null;
try
{
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.RegisterPamComponent);
ProcessAccessManager.RegisterComponent(this);
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.InitializePerformanceMonitoring);
MailboxTransportSubmissionService.InitializePerfMon();
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, DateTime>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "PFD EMS {0} Finished Loading Perfmon ({1})", 32667, DateTime.UtcNow);
TransportADNotificationAdapter.Instance.RegisterForSubmissionServiceEvents();
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.LoadConfiguration);
StorageExceptionHandler.Init();
this.ConstructComponentLoadTree();
SubmissionConfiguration.Instance.Load();
int num;
ThreadPool.GetMaxThreads(out this.maxThreads, out num);
ITimeBasedAssistantType[] timeBasedAssistantTypeArray = null;
IEventBasedAssistantType[] eventBasedAssistantTypeArray = new IEventBasedAssistantType[]
{
new MailboxTransportSubmissionAssistantType()
};
this.databaseManager = new DatabaseManager("Microsoft Exchange Mailbox Transport Submission", MailboxTransportSubmissionAssistant.MaxConcurrentSubmissions, eventBasedAssistantTypeArray, timeBasedAssistantTypeArray, false);
MailboxTransportSubmissionEventLogger.LogEvent(MSExchangeSubmissionEventLogConstants.Tuple_SubmissionServiceStartSuccess, null, new object[0]);
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.CreateBackgroundThread);
MailboxTransportSubmissionService.backgroundThread = new BackgroundProcessingThread();
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StartBackgroundThread);
MailboxTransportSubmissionService.backgroundThread.Start(false, ServiceState.Active);
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StartDatabaseManager);
this.databaseManager.Start();
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.ServiceStarted);
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "PFD EMS {0} MailTransportSubmissionService Started", 26523);
flag = true;
}
catch (ConfigurationErrorsException ex)
{
text = ex.Message;
flag2 = true;
}
catch (HandlerParseException ex2)
{
text = ex2.Message;
flag2 = true;
}
finally
{
if (!flag)
{
MailboxTransportSubmissionEventLogger.LogEvent(MSExchangeSubmissionEventLogConstants.Tuple_SubmissionServiceStartFailure, null, new object[]
{
text
});
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, 0L, "Failed to start MailboxTransportSubmissionService");
base.ExRequestAdditionalTime(60000);
if (flag2)
{
base.Stop();
}
}
}
}
// 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();
}
}
}
}
protected virtual MessageStatus RunUnderStorageExceptionHandler(StoreDriverDelegate action)
{
return(StorageExceptionHandler.RunUnderExceptionHandler(this.mailItemDeliver, action));
}
private static ApprovalRequestUpdater.Result FindAndUpdateExistingApprovalRequest(MessageItem updateMessage, int decision, string decisionMaker, ExDateTime decisionTime, string messageId)
{
bool updated = false;
string local;
string domain;
if (!FindMessageUtils.TryParseMessageId(messageId, out local, out domain))
{
return(ApprovalRequestUpdater.Result.InvalidUpdateMessage);
}
ApprovalRequestUpdater.diag.TraceDebug <string>(0L, "Update approval request: messageid={0}", messageId);
MessageStatus messageStatus = StorageExceptionHandler.RunUnderExceptionHandler(ApprovalRequestUpdater.MessageConverterInstance, delegate
{
MailboxSession mailboxSession = (MailboxSession)updateMessage.Session;
StoreObjectId storeObjectId = null;
for (int i = 0; i < 25; i++)
{
string internetMessageId = ApprovalRequestWriter.FormatApprovalRequestMessageId(local, i, domain, false);
IStorePropertyBag[] array = AllItemsFolderHelper.FindItemsFromInternetId(mailboxSession, internetMessageId, new PropertyDefinition[]
{
ItemSchema.Id
});
if (array != null && array.Length > 0)
{
ApprovalRequestUpdater.diag.TraceDebug <int>(0L, "Found {0} to update, picking the first.", array.Length);
storeObjectId = ((VersionedId)array[0][ItemSchema.Id]).ObjectId;
break;
}
}
if (storeObjectId != null)
{
using (MessageItem messageItem = MessageItem.Bind(mailboxSession, storeObjectId))
{
if (ApprovalRequestUpdater.VerifyAndUpdateApprovalRequest(mailboxSession, updateMessage.Sender, decision, decisionMaker, decisionTime, messageItem))
{
ConflictResolutionResult conflictResolutionResult = messageItem.Save(SaveMode.ResolveConflicts);
if (conflictResolutionResult.SaveStatus != SaveResult.Success)
{
ApprovalRequestUpdater.diag.TraceDebug <string, SaveResult>(0L, "Saving message: {0}, resulted in an update conflict ({1}). Ignored", messageId, conflictResolutionResult.SaveStatus);
}
AggregateOperationResult aggregateOperationResult = mailboxSession.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
storeObjectId
});
if (aggregateOperationResult.OperationResult != OperationResult.Succeeded)
{
ApprovalRequestUpdater.diag.TraceDebug <string, OperationResult>(0L, "Delete message: {0}, resulted in failure {1} Ignored", messageId, aggregateOperationResult.OperationResult);
}
updated = true;
}
}
}
});
if (!updated)
{
ApprovalRequestUpdater.diag.TraceDebug <string>(0L, "Couldn't find message: {0}, ignored", messageId);
return(ApprovalRequestUpdater.Result.NotFound);
}
if (MessageStatus.Success != messageStatus)
{
ApprovalRequestUpdater.diag.TraceDebug <string, string>(0L, "Message ({0}) processing was not successful ({1}), ignoring..", messageId, (messageStatus.Exception == null) ? "NULL exception" : messageStatus.Exception.Message);
return(ApprovalRequestUpdater.Result.SaveConflict);
}
return(ApprovalRequestUpdater.Result.UpdatedSucessfully);
}
