private static void WatsonThreadProc(object stateInfo)
{
Thread.CurrentThread.IsBackground = false;
DisposeTrackerObject <T> .WatsonThreadStateInfo watsonThreadStateInfo = (DisposeTrackerObject <T> .WatsonThreadStateInfo)stateInfo;
string text = DisposeTrackerObject <T> .StackTraceToString(watsonThreadStateInfo.StackTrace);
if (text != null)
{
ObjectNotDisposedException <T> exception = new ObjectNotDisposedException <T>(text, watsonThreadStateInfo.StackTraceWasReset);
try
{
if (watsonThreadStateInfo.ExtraDataList != null)
{
foreach (WatsonExtraDataReportAction action in watsonThreadStateInfo.ExtraDataList)
{
ExWatson.RegisterReportAction(action, WatsonActionScope.Thread);
}
}
ExWatson.HandleException(new UnhandledExceptionEventArgs(exception, DisposeTrackerOptions.TerminateOnReport), ReportOptions.DoNotCollectDumps | ReportOptions.DeepStackTraceHash | ReportOptions.DoNotLogProcessAndThreadIds | ReportOptions.DoNotFreezeThreads);
}
finally
{
if (watsonThreadStateInfo.ExtraDataList != null)
{
foreach (WatsonExtraDataReportAction action2 in watsonThreadStateInfo.ExtraDataList)
{
ExWatson.UnregisterReportAction(action2, WatsonActionScope.Thread);
}
}
}
}
Thread.CurrentThread.IsBackground = true;
}
private static void DoWithExtraWatsonData(Action action)
{
Command currentCommand = Command.CurrentCommand;
string text = null;
if (currentCommand != null && GlobalSettings.IncludeRequestInWatson)
{
text = "Request: \r\n" + currentCommand.Request.GetHeadersAsString();
if (currentCommand.Request.XmlDocument != null && currentCommand.Request.XmlDocument.DocumentElement != null)
{
text = text + "\r\n" + currentCommand.Request.XmlDocument.DocumentElement.OuterXml;
}
else
{
text += "\r\n[No Body]";
}
}
WatsonExtraDataReportAction watsonExtraDataReportAction = string.IsNullOrEmpty(text) ? null : new WatsonExtraDataReportAction(text);
if (watsonExtraDataReportAction != null)
{
ExWatson.RegisterReportAction(watsonExtraDataReportAction, WatsonActionScope.Thread);
}
try
{
action();
}
finally
{
if (watsonExtraDataReportAction != null)
{
ExWatson.UnregisterReportAction(watsonExtraDataReportAction, WatsonActionScope.Thread);
}
}
}
private static void Main(string[] args)
{
new LocalizedString("Workaround for bug # 72378");
int num = Privileges.RemoveAllExcept(AssistantsService.requiredPrivileges);
if (num != 0)
{
Environment.Exit(num);
}
ExWatson.Register();
ExWatson.RegisterReportAction(new WatsonRegKeyReportAction("HKLM\\SYSTEM\\CurrentControlSet\\Services\\MSExchangeIS\\ImagePath"), WatsonActionScope.Process);
AssistantsService.ReadRegParams();
Globals.InitializeMultiPerfCounterInstance("MSExchMbxAsst");
ResourceHealthMonitorManager.Initialize(ResourceHealthComponent.Assistants);
AssistantsService service = new AssistantsService();
if (Environment.UserInteractive && args.Length >= 1 && string.Compare(args[0], "-crash", true) == 0)
{
throw new Exception("Startup crash to test ExWatson stuff");
}
if (Environment.UserInteractive && args.Length >= 1 && string.Compare(args[0], "-console", true) == 0)
{
AssistantsService.TracerPfd.TracePfd <int>(3L, "PFD IWS {0} Starting the Mailbox Assistants Service in Console Mode", 28055);
ExServiceBase.RunAsConsole(service);
return;
}
ServiceBase.Run(service);
}
internal static WatsonReportAction RegisterAdditionalWatsonData()
{
string watsonExtraData = Diagnostics.GetWatsonExtraData();
WatsonReportAction watsonReportAction = new WatsonExtraDataReportAction(watsonExtraData);
ExWatson.RegisterReportAction(watsonReportAction, WatsonActionScope.Thread);
return(watsonReportAction);
}
// Token: 0x0600000F RID: 15 RVA: 0x00002494 File Offset: 0x00000694
private static void MainUnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs eventArgs)
{
ExTraceGlobals.GeneralTracer.TraceDebug(0L, "MainUnhandledExceptionHandler");
if (Program.main.isExiting)
{
Environment.Exit(0);
}
int num = Interlocked.Exchange(ref Program.main.busyUnhandledException, 1);
if (num == 1)
{
return;
}
string text = null;
if (Program.main.transportComponents != null)
{
text = Components.OnUnhandledException((Exception)eventArgs.ExceptionObject);
}
if (Components.IsActive)
{
PoisonMessage.SavePoisonContext((Exception)eventArgs.ExceptionObject);
}
ExTraceGlobals.GeneralTracer.TraceDebug(0L, "Process unhandled exception");
WatsonReportAction action = new WatsonExtraDataReportAction(text);
ExWatson.RegisterReportAction(action, WatsonActionScope.Thread);
try
{
ExWatson.HandleException(sender, eventArgs);
}
finally
{
ExWatson.UnregisterReportAction(action, WatsonActionScope.Thread);
}
ExTraceGlobals.GeneralTracer.TraceDebug(0L, "Done processing unhandled exception. Return to CLR.");
}
// Token: 0x0600000E RID: 14 RVA: 0x000022C0 File Offset: 0x000004C0
public static void Main(string[] args)
{
CommonDiagnosticsLog.Initialize(HostId.MailboxTransportSubmissionService);
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.StartProcess);
int num = Privileges.RemoveAllExcept(new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege"
});
if (num != 0)
{
Environment.Exit(num);
}
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.RegisterWatson);
ExWatson.Register();
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.RegisterWatsonAction);
ExWatson.RegisterReportAction(new WatsonRegKeyReportAction(MailboxTransportSubmissionService.watsonRegKeyReportActionString), WatsonActionScope.Process);
MailboxTransportSubmissionService.runningAsService = !Environment.UserInteractive;
bool flag = false;
bool flag2 = false;
foreach (string text in args)
{
if (text.StartsWith("-?", StringComparison.Ordinal))
{
MailboxTransportSubmissionService.Usage();
Environment.Exit(0);
}
else if (text.StartsWith("-console"))
{
flag = true;
}
else if (text.StartsWith("-wait"))
{
flag2 = true;
}
}
if (!MailboxTransportSubmissionService.runningAsService)
{
if (!flag)
{
MailboxTransportSubmissionService.Usage();
Environment.Exit(0);
}
Console.WriteLine("Starting {0}, running in console mode.", Assembly.GetExecutingAssembly().GetName().Name);
if (flag2)
{
Console.WriteLine("Press ENTER to continue.");
Console.ReadLine();
}
}
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.InitializePerformanceCounterInstance);
Globals.InitializeSinglePerfCounterInstance();
SettingOverrideSync.Instance.Start(true);
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.LoadLatencyTrackerConfiguration);
try
{
LatencyTracker.Configuration = TransportAppConfig.LatencyTrackerConfig.Load();
}
catch (ConfigurationErrorsException)
{
}
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.LoadTransportAppConfig);
string text2;
if (!Components.TryLoadTransportAppConfig(out text2))
{
MailboxTransportSubmissionEventLogger.LogEvent(MSExchangeSubmissionEventLogConstants.Tuple_SubmissionServiceStartFailure, null, new object[]
{
text2
});
Environment.Exit(1);
}
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.CreateService);
MailboxTransportSubmissionService.mailboxTransportSubmissionService = new MailboxTransportSubmissionService();
MailboxTransportSubmissionService.LogStage(MailboxTransportSubmissionService.Stage.RunService);
if (!MailboxTransportSubmissionService.runningAsService)
{
ExServiceBase.RunAsConsole(MailboxTransportSubmissionService.mailboxTransportSubmissionService);
return;
}
ServiceBase.Run(MailboxTransportSubmissionService.mailboxTransportSubmissionService);
}
private void ReportProblem(MemoryTraceBuilder contextTraceBuilder, Exception exception, string functionName, bool isExceptionReport, bool isExceptionReportTerminating, bool verbose)
{
using (TempFileStream tempFileStream = TempFileStream.CreateInstance("Traces_", false))
{
using (StreamWriter streamWriter = new StreamWriter(tempFileStream))
{
bool addHeader = true;
if (contextTraceBuilder != null)
{
lock (this)
{
contextTraceBuilder.Dump(streamWriter, addHeader, verbose);
}
addHeader = false;
}
MemoryTraceBuilder memoryTraceBuilder = ExTraceInternal.GetMemoryTraceBuilder();
if (memoryTraceBuilder != null)
{
memoryTraceBuilder.Dump(streamWriter, addHeader, verbose);
}
streamWriter.Flush();
}
StringBuilder stringBuilder = new StringBuilder(1024);
TroubleshootingContext.DumpExceptionInfo(exception, stringBuilder);
if (TroubleshootingContext.IsTestTopology())
{
string path = ExWatson.AppName + "_" + DateTime.UtcNow.ToString("yyyyMMdd_hhmmss") + ".trace";
try
{
File.Copy(tempFileStream.FilePath, Path.Combine(Path.Combine(Environment.GetEnvironmentVariable("SystemDrive"), "\\dumps"), path));
}
catch
{
}
}
if (exception != TroubleshootingContext.FaultInjectionInvalidOperationException)
{
if (isExceptionReport)
{
WatsonExtraFileReportAction watsonExtraFileReportAction = null;
try
{
watsonExtraFileReportAction = new WatsonExtraFileReportAction(tempFileStream.FilePath);
ExWatson.RegisterReportAction(watsonExtraFileReportAction, WatsonActionScope.Thread);
ExWatson.SendReport(exception, isExceptionReportTerminating ? ReportOptions.ReportTerminateAfterSend : ReportOptions.None, null);
goto IL_152;
}
finally
{
if (watsonExtraFileReportAction != null)
{
ExWatson.UnregisterReportAction(watsonExtraFileReportAction, WatsonActionScope.Thread);
}
}
}
ExWatson.SendTroubleshootingWatsonReport("15.00.1497.012", this.location, "UnexpectedCondition:" + exception.GetType().Name, exception.StackTrace, functionName, stringBuilder.ToString(), tempFileStream.FilePath);
IL_152:
File.Delete(tempFileStream.FilePath);
}
}
}
