// Token: 0x0600025A RID: 602 RVA: 0x0000FCC4 File Offset: 0x0000DEC4
private void Application_Start(object sender, EventArgs e)
{
Globals.InitializeMultiPerfCounterInstance("AutoDisc");
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug <string>((long)this.GetHashCode(), "[Application_Start()] Privileges.RemoveAllExcept(,,\"{0}\");", "MSExchangeAutodiscoverAppPool");
string[] privilegesToKeep = new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege"
};
int num = Privileges.RemoveAllExcept(privilegesToKeep, "MSExchangeAutodiscoverAppPool");
if (num != 0)
{
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceError <TimeSpan, int>((long)this.GetHashCode(), "[Application_Start()] 'Failed to remove privileges, exiting. Time=\"{0}\",win32Error=\"{1}\"'", ExDateTime.Now.TimeOfDay, num);
Environment.Exit(num);
}
PerformanceCounters.Initialize();
ExchangeDiagnosticsHelper.RegisterDiagnosticsComponents();
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug((long)this.GetHashCode(), "[Application_Start()] 'ApplicationStarted'");
Common.EventLog.LogEvent(AutodiscoverEventLogConstants.Tuple_InfoWebApplicationStart, Common.PeriodicKey, new object[0]);
string text = ExEnvironment.IsTest ? "E12" : "E12IIS";
ExWatson.Register(text);
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FaultInjectionTracer.RegisterExceptionInjectionCallback(new ExceptionInjectionCallback(FaultInjection.Callback));
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug <string, string>((long)this.GetHashCode(), "[Application_Start()] ExWatson.Register(\"{0}\");AppName=\"{1}\";", text, ExWatson.AppName);
}
// Token: 0x06000001 RID: 1 RVA: 0x000020D0 File Offset: 0x000002D0
public static void Main(string[] args)
{
List <string> list = new List <string>();
list.Add("SeAuditPrivilege");
list.Add("SeChangeNotifyPrivilege");
list.Add("SeCreateGlobalPrivilege");
list.Add("SeImpersonatePrivilege");
bool isSystem;
using (WindowsIdentity current = WindowsIdentity.GetCurrent())
{
isSystem = current.IsSystem;
}
if (isSystem)
{
list.Add("SeIncreaseQuotaPrivilege");
list.Add("SeAssignPrimaryTokenPrivilege");
}
int num = Privileges.RemoveAllExcept(list.ToArray());
if (num != 0)
{
Program.main.StopService(Strings.PrivilegeRemovalFailure(num), true, false, false);
}
ExWatson.Init();
AppDomain.CurrentDomain.UnhandledException += Program.MainUnhandledExceptionHandler;
if (!Program.AddTokenReadPermissionForAdminGroup())
{
ExTraceGlobals.GeneralTracer.TraceDebug(0L, "Failed to update the process security descriptor with TOKEN_READ. The result is the managed debugger may fail to attach.");
}
Program.main.Run(args);
Program.Exit(Program.main.immediateRetryAfterExit ? 200 : 0);
}
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);
}
// Token: 0x06000014 RID: 20 RVA: 0x0000236C File Offset: 0x0000056C
private static int MainInternal(string[] args)
{
string userName = Environment.UserName;
DagMgmtService.Tracer.TraceDebug <string>(0L, "Running as {0}", userName);
int num = Privileges.RemoveAllExcept(DagMgmtService.requiredPrivileges);
if (num != 0)
{
return(num);
}
Globals.InitializeSinglePerfCounterInstance();
bool flag = !DagMgmtService.IsRunningAsService();
bool flag2 = false;
bool flag3 = false;
foreach (string text in args)
{
if (DagMgmtService.IsArgumentEqual(text, "-wait"))
{
flag3 = true;
}
else
{
DagMgmtService.ReportError("Invalid option specified :{0}\n", new object[]
{
text
});
flag2 = true;
}
}
if (flag2)
{
DagMgmtService.Tracer.TraceError(0L, "Invalid argument specified. Exiting process.");
return(1);
}
if (flag)
{
DagMgmtService.Tracer.TraceDebug <string, DateTime>(0L, "{0} Service starting in console mode at {1}", DagMgmtService.serviceName, DateTime.UtcNow);
Console.WriteLine("Starting {0}, running in console mode.", Assembly.GetExecutingAssembly().GetName().Name);
if (flag3)
{
Console.WriteLine("Press <ENTER> to continue.");
Console.ReadLine();
}
ExServiceBase.RunAsConsole(new DagMgmtService(flag));
}
else
{
ServiceBase.Run(new DagMgmtService(flag));
}
return(0);
}
private void ExecuteApplicationStart(object sender, EventArgs e)
{
int num = 0;
num = Privileges.RemoveAllExcept(new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege",
"SeImpersonatePrivilege",
"SeIncreaseQuotaPrivilege",
"SeAssignPrimaryTokenPrivilege",
"SeTcbPrivilege"
}, "MSExchangeServicesSyncPool");
if (num != 0)
{
string name;
using (WindowsIdentity current = WindowsIdentity.GetCurrent())
{
name = current.Name;
}
AirSyncDiagnostics.LogPeriodicEvent(AirSyncEventLogConstants.Tuple_SetPrivilegesFailure, "SetPrivilegesFailure: " + name, new string[]
{
name,
num.ToString(CultureInfo.InvariantCulture)
});
Environment.Exit(num);
}
ExWatson.Init("E12");
AppDomain.CurrentDomain.UnhandledException += Global.HandledExceptionProxy;
Globals.InitializeMultiPerfCounterInstance("AirSync");
ExRpcModule.Bind();
AirSyncDiagnostics.TraceInfo <ResourceManagerHandle>(ExTraceGlobals.RequestsTracer, null, "AuthzAuthorization.ResourceManagerHandle static instance loaded", AuthzAuthorization.ResourceManagerHandle);
AirSyncSyncStateTypeFactory.EnsureSyncStateTypesRegistered();
FolderSyncState.RegisterCustomDataVersioningHandler(new FolderSyncState.HandleCustomDataVersioningDelegate(FolderSyncStateCustomDataInfo.HandlerCustomDataVersioning));
FolderHierarchySyncState.RegisterCustomDataVersioningHandler(new FolderHierarchySyncState.HandleCustomDataVersioningDelegate(FolderHierarchySyncStateCustomDataInfo.HandlerCustomDataVersioning));
EventQueue.PollingInterval = GlobalSettings.EventQueuePollingInterval;
this.resetAutoBlockedDeviceCounterTimer = new Timer(new TimerCallback(Global.ResetAutoBlockedDeviceCounter), null, 86400000, 86400000);
}
// Token: 0x06000005 RID: 5 RVA: 0x00002158 File Offset: 0x00000358
internal static void Main(string[] args)
{
List <string> list = new List <string>();
list.Add("SeAuditPrivilege");
list.Add("SeChangeNotifyPrivilege");
list.Add("SeCreateGlobalPrivilege");
list.Add("SeImpersonatePrivilege");
bool isSystem;
using (WindowsIdentity current = WindowsIdentity.GetCurrent())
{
isSystem = current.IsSystem;
}
if (isSystem)
{
list.Add("SeIncreaseQuotaPrivilege");
list.Add("SeAssignPrimaryTokenPrivilege");
}
int num = Privileges.RemoveAllExcept(list.ToArray());
if (num != 0)
{
Environment.Exit(num);
}
Globals.InitializeSinglePerfCounterInstance();
ExWatson.Register();
bool flag = !Environment.UserInteractive;
bool flag2 = false;
bool flag3 = false;
foreach (string text in args)
{
if (text.StartsWith("-?", StringComparison.OrdinalIgnoreCase))
{
TransportService.Usage();
Environment.Exit(0);
}
else if (text.StartsWith("-console", StringComparison.OrdinalIgnoreCase))
{
flag2 = true;
}
else if (text.StartsWith("-wait", StringComparison.OrdinalIgnoreCase))
{
flag3 = true;
}
}
if (!flag)
{
if (!flag2)
{
TransportService.Usage();
Environment.Exit(0);
}
Console.WriteLine("Starting {0}, running in console mode.", Assembly.GetExecutingAssembly().GetName().Name);
if (flag3)
{
Console.WriteLine("Press ENTER to continue.");
Console.ReadLine();
}
}
SettingOverrideSync.Instance.Start(true);
if (!VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Transport.ADExceptionHandling.Enabled)
{
TransportService.adConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 324, "Main", "f:\\15.00.1497\\sources\\dev\\Transport\\src\\TransportService\\TransportService.cs");
}
else
{
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
TransportService.adConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 334, "Main", "f:\\15.00.1497\\sources\\dev\\Transport\\src\\TransportService\\TransportService.cs");
}, 0);
if (!adoperationResult.Succeeded)
{
ExTraceGlobals.ServiceTracer.TraceError <Exception>(0L, "Error when getting AD configuration session: {0}", adoperationResult.Exception);
TransportService.logger.LogEvent(TransportEventLogConstants.Tuple_MSExchangeTransportInitializationFailure, null, new object[]
{
adoperationResult.Exception.ToString()
});
Environment.Exit(1);
}
}
TransportService.transportService = new TransportService(flag);
if (!TransportService.transportService.Initialize())
{
ExTraceGlobals.ServiceTracer.TraceError(0L, "Failed to initialize the service. Exiting.");
ProcessManagerService.StopService();
}
if (!flag)
{
TransportService.transportService.OnStartInternal(args);
bool flag4 = false;
while (!flag4)
{
Console.WriteLine("Enter 'q' to shutdown.");
string text2 = Console.ReadLine();
if (string.IsNullOrEmpty(text2))
{
break;
}
switch (text2[0])
{
case 'q':
flag4 = true;
break;
case 'r':
TransportService.transportService.OnCustomCommandInternal(200);
break;
case 'u':
TransportService.transportService.OnCustomCommandInternal(201);
break;
}
}
Console.WriteLine("Shutting down ...");
TransportService.transportService.OnStopInternal();
Console.WriteLine("Done.");
return;
}
ServiceBase.Run(TransportService.transportService);
}
// Token: 0x06000007 RID: 7 RVA: 0x0000289C File Offset: 0x00000A9C
public static void Main(string[] args)
{
int num = Privileges.RemoveAllExcept(new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege"
});
if (num != 0)
{
Environment.Exit(num);
}
ExWatson.Register();
AntispamUpdateSvc.runningAsService = !Environment.UserInteractive;
bool flag = false;
int i = 0;
while (i < args.Length)
{
string text = args[i];
string a;
if ((a = text.Trim()) == null)
{
goto IL_BD;
}
if (!(a == "-?"))
{
if (!(a == "-console"))
{
if (!(a == "-wait"))
{
if (!(a == "-60"))
{
goto IL_BD;
}
AntispamUpdateSvc.pollInterval = 60;
}
else
{
AntispamUpdateSvc.waitToContinue = true;
}
}
else
{
flag = true;
}
}
else
{
AntispamUpdateSvc.Usage();
Environment.Exit(0);
}
IL_D3:
i++;
continue;
IL_BD:
Console.WriteLine("{0}", text);
AntispamUpdateSvc.Usage();
Environment.Exit(0);
goto IL_D3;
}
if (AntispamUpdateSvc.runningAsService)
{
ServiceBase.Run(new AntispamUpdateSvc());
return;
}
if (flag)
{
AntispamUpdateSvc.RunConsole();
return;
}
Console.WriteLine("Use the '-console' argument to run from the command line");
AntispamUpdateSvc.Usage();
Environment.Exit(0);
}
// Token: 0x06000110 RID: 272 RVA: 0x00008194 File Offset: 0x00006394
public static void Main(string[] args)
{
int num = Privileges.RemoveAllExcept(new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege"
});
if (num != 0)
{
Environment.Exit(num);
}
if (!Debugger.IsAttached)
{
ExWatson.Register();
}
LogSearchService.runningAsService = !Environment.UserInteractive;
bool flag = false;
bool flag2 = false;
foreach (string text in args)
{
if (text.StartsWith("-?", StringComparison.Ordinal))
{
LogSearchService.Usage();
Environment.Exit(0);
}
else if (text.StartsWith("-console"))
{
flag = true;
}
else if (text.StartsWith("-wait"))
{
flag2 = true;
}
}
Globals.InitializeMultiPerfCounterInstance("LogSearchSvc");
ADSession.DisableAdminTopologyMode();
if (!LogSearchService.runningAsService)
{
if (!flag)
{
LogSearchService.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();
}
}
SettingOverrideSync.Instance.Start(true);
if (!VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Transport.ADExceptionHandling.Enabled)
{
LogSearchService.logSearchService = new LogSearchService(!LogSearchService.runningAsService);
}
else
{
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
LogSearchService.logSearchService = new LogSearchService(!LogSearchService.runningAsService);
}, 0);
if (!adoperationResult.Succeeded)
{
ExTraceGlobals.ServiceTracer.TraceError <Exception>(0L, "Create Log Search Service failed: {0}", adoperationResult.Exception);
Environment.Exit(1);
}
}
try
{
Kerberos.FlushTicketCache();
}
catch (Win32Exception arg)
{
ExTraceGlobals.ServiceTracer.TraceDebug <Win32Exception>(0L, "MsExchangeLogSearch caught a Win32Exception when flushing the Kerberos Ticket Cache at startup: {0}", arg);
}
if (!LogSearchService.runningAsService)
{
LogSearchService.logSearchService.OnStartInternal(args);
bool flag3 = false;
while (!flag3)
{
Console.WriteLine("Enter 'q' to shutdown.");
string text2 = Console.ReadLine();
if (string.IsNullOrEmpty(text2))
{
break;
}
switch (text2[0])
{
case 'q':
flag3 = true;
break;
case 's':
LogSearchService.logSearchService.sessionManager.ShowSessions();
break;
}
}
Console.WriteLine("Shutting down ...");
LogSearchService.logSearchService.OnStopInternal();
Console.WriteLine("Done.");
return;
}
ServiceBase.Run(LogSearchService.logSearchService);
}
// 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);
}
// Token: 0x06000356 RID: 854 RVA: 0x0000D224 File Offset: 0x0000B424
internal void ExecuteApplicationStart(object sender, EventArgs e)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "Global.Application_Start");
try
{
int num = Privileges.RemoveAllExcept(new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege",
"SeImpersonatePrivilege",
"SeIncreaseQuotaPrivilege",
"SeAssignPrimaryTokenPrivilege"
}, "MSExchangeOWAAppPool");
if (num != 0)
{
throw new OwaWin32Exception(num, "Failed to remove unnecessary privileges");
}
if (BaseApplication.IsRunningDfpowa)
{
string localPath = new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath;
DirectoryInfo[] directories = Directory.GetParent(Directory.GetParent(localPath).FullName).GetDirectories("Config");
if (directories.Length > 0)
{
VariantConfiguration.Initialize(directories[0].FullName);
}
}
string applicationName = this.IsPreCheckinApp ? "PCDFOWA" : "OWA";
Globals.InitializeMultiPerfCounterInstance(applicationName);
Globals.Initialize();
Kerberos.FlushTicketCache();
ExRpcModule.Bind();
this.ExecuteApplicationSpecificStart();
}
catch (OwaWin32Exception ex)
{
ExTraceGlobals.CoreTracer.TraceDebug <int>(0L, "Application initialization failed with a win32 error: {0}", ex.LastError);
Globals.InitializationError = ex;
return;
}
catch (Exception initializationError)
{
ExTraceGlobals.CoreTracer.TraceDebug(0L, "Application initialization failed");
Globals.InitializationError = initializationError;
throw;
}
Globals.IsInitialized = true;
ExTraceGlobals.CoreTracer.TraceDebug(0L, "Application initialization succeeded");
int id = Process.GetCurrentProcess().Id;
if (Globals.IsPreCheckinApp)
{
OwaDiagnostics.Logger.LogEvent(ClientsEventLogConstants.Tuple_DfpOwaStartedSuccessfully, string.Empty, new object[]
{
id
});
return;
}
OwaDiagnostics.Logger.LogEvent(ClientsEventLogConstants.Tuple_OwaStartedSuccessfully, string.Empty, new object[]
{
id
});
OwaDiagnostics.PublishMonitoringEventNotification(ExchangeComponent.Owa.Name, "OwaWebAppStarted", "Outlook Web App started successfully", ResultSeverityLevel.Error);
}
// Token: 0x0600002F RID: 47 RVA: 0x00002CA0 File Offset: 0x00000EA0
public static void Main(string[] args)
{
ThrottlingService.StartStopBreadcrumbs.Drop("Execution began", new object[0]);
int num = Privileges.RemoveAllExcept(new string[]
{
"SeAuditPrivilege",
"SeChangeNotifyPrivilege",
"SeCreateGlobalPrivilege"
});
if (num != 0)
{
ThrottlingService.StartStopBreadcrumbs.Drop("Failed to remove excessive privileges; Win32 error: {0}", new object[]
{
num
});
ThrottlingService.tracer.TraceError <int>(0L, "Failed to remove excessive privileges; Win32 error: {0}", num);
ThrottlingService.eventLogger.LogEvent(ThrottlingServiceEventLogConstants.Tuple_RemovePrivilegesFailure, null, new object[]
{
num
});
Environment.Exit(num);
}
ExWatson.Register();
ThrottlingService.runningAsService = !Environment.UserInteractive;
Globals.InitializeSinglePerfCounterInstance();
bool flag = false;
bool flag2 = false;
foreach (string text in args)
{
if (text.StartsWith("-?", StringComparison.Ordinal))
{
ThrottlingService.Usage();
Environment.Exit(0);
}
else if (text.StartsWith("-console"))
{
flag = true;
}
else if (text.StartsWith("-wait"))
{
flag2 = true;
}
}
ThrottlingService.StartStopBreadcrumbs.Drop("runningAsService={0}", new object[]
{
ThrottlingService.runningAsService
});
if (!ThrottlingService.runningAsService)
{
if (!flag)
{
ThrottlingService.Usage();
ThrottlingService.StartStopBreadcrumbs.Drop("Usage shown", new object[0]);
Environment.Exit(0);
}
Console.WriteLine("Starting {0}, running in console mode.", Assembly.GetExecutingAssembly().GetName().Name);
if (flag2)
{
ThrottlingService.StartStopBreadcrumbs.Drop("Waiting for user input to proceed with initialization", new object[0]);
Console.WriteLine("Press ENTER to continue.");
Console.ReadLine();
}
}
ThrottlingService.instance = new ThrottlingService();
if (!ThrottlingService.runningAsService)
{
ExServiceBase.RunAsConsole(ThrottlingService.instance);
}
else
{
ServiceBase.Run(ThrottlingService.instance);
}
ThrottlingService.StartStopBreadcrumbs.Drop("Execution ended", new object[0]);
}
