public static void Shutdown(ShutdownReason reasonFlag)
		{
			int			Result;
			bool		BooleanResult;
			TokenPrivileges	tp	= new TokenPrivileges ();
			long			LocallyUniqueIdentifier;

			IntPtr hproc	= (IntPtr)ApiNativeMethods.GetCurrentProcess();
			int		htok	= 0;

			BooleanResult	= ApiNativeMethods.OpenProcessToken( (int)hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok );
			if( BooleanResult == false)
				throw new NolmeGenericException (string.Format (CultureInfo.InvariantCulture, "OpenProcessToken Failed"));

			tp.Count					= 1;
			tp.LocallyUniqueIdentifier	= 0;
			tp.Attributes				= SE_PRIVILEGE_ENABLED;
			LocallyUniqueIdentifier		= 0;
			BooleanResult				= ApiNativeMethods.LookupPrivilegeValue( null, SE_SHUTDOWN_NAME, ref LocallyUniqueIdentifier);
			if( BooleanResult == false)
				throw new NolmeGenericException (string.Format (CultureInfo.InvariantCulture, "LookupPrivilegeValue Failed"));

			tp.LocallyUniqueIdentifier	= LocallyUniqueIdentifier;
			BooleanResult	= ApiNativeMethods.AdjustTokenPrivileges( htok, false, ref tp, 0, 0, 0);
			if( BooleanResult == false)
				throw new NolmeGenericException (string.Format (CultureInfo.InvariantCulture, "AdjustTokenPrivileges Failed"));

			Result = User32ApiNativeMethods.ExitWindowsEx(ExitWindows.PowerOff | ExitWindows.Shutdown, reasonFlag);
			if( Result == 0)
				throw new NolmeGenericException (string.Format (CultureInfo.InvariantCulture, "Shutdown Failed"));
		}

 public static bool ExitWindows(ExitWindows exitWindows, ShutdownReason reason, bool ajustToken)
 {
     if (ajustToken && !TokenAdjuster.EnablePrivilege("SeShutdownPrivilege", true)) {
         return false;
     }
     return ExitWindowsEx(exitWindows, reason) != 0;
 }

 /// <summary> Creates a ShutdownParams object with given parameters.
 /// <param name="customReason"/> and <param name="initiatedBy"/> may be null. </summary>
 public ShutdownParams(ShutdownReason reason, TimeSpan delay,
                       bool restart, [CanBeNull] string customReason,
                       [CanBeNull] Player initiatedBy)
     : this(reason, delay, restart) {
     customReasonString = customReason;
     InitiatedBy = initiatedBy;
 }

 void Shutdown( ShutdownReason reason, bool quit ) {
     if( shutdownPending ) return;
     shutdownPending = true;
     uriDisplay.Enabled = false;
     console.Enabled = false;
     console.Text = "Shutting down...";
     Server.Shutdown( new ShutdownParams( reason, TimeSpan.Zero, quit, false ), false );
 }

		public static void LogOff(ShutdownReason reasonFlag) 
		{
			int Result;
			Result = User32ApiNativeMethods.ExitWindowsEx(ExitWindows.LogOff, reasonFlag);
			if( Result == 0)
			{
				throw new NolmeGenericException (string.Format (CultureInfo.InvariantCulture, "LogOff Failed"));
			}
		}

        void Shutdown( ShutdownReason reason, bool quit ) {
            if( shutdownPending ) return;

            //Log( "Shutting down...", LogType.ConsoleOutput ); // write to console only

            shutdownPending = true;
            urlDisplay.Enabled = false;
            console.Enabled = false;
            Server.Shutdown( new ShutdownParams( reason, 0, quit, false ), false );
        }

 static void ReportFailure( ShutdownReason reason ) {
     Console.Title = String.Format( "fCraft {0} {1}", Updater.CurrentRelease.VersionString, reason );
     if( useColor ) Console.ForegroundColor = ConsoleColor.Red;
     Console.Error.WriteLine( "** {0} **", reason );
     if( useColor ) Console.ResetColor();
     Server.Shutdown( new ShutdownParams( reason, TimeSpan.Zero, false, false ), true );
     if( !Server.HasArg( ArgKey.ExitOnCrash ) ) {
         Console.ReadLine();
     }
 }

 public NestResult Shutdown(ShutdownReason reason)
 {
     // host shutdown is called by UI thread.
      application.Dispatcher.Invoke(() => { application.Shutdown(); });
      return NestResult.Success;
 }

 public ShutdownParams( ShutdownReason reason, TimeSpan delay, bool killProcess, bool restart )
 {
     Reason = reason;
     Delay = delay;
     KillProcess = killProcess;
     Restart = restart;
 }

 public DefaultShutdownInput(ShutdownReason reason, Checkpointer checkpointer)
 {
     _reason = reason;
     _checkpointer = checkpointer;
 }

 private void ChannelOnDisconnected(IChannel channel, ShutdownReason reason)
 {
     ChangeTimerState(false);
     _sentBatch = false;
     FailedQueuedLetters();
     ChannelDisconnected(this, reason);
 }

        private void ChannelDisconnected(IChannel channel, ShutdownReason reason)
        {
            Binding binding = channel.Binding;

            _routeChannels.Remove(channel.RemoteNodeId);

            if(channel.Direction == Direction.Inbound || reason == ShutdownReason.Requested) {
                _channels.Remove(binding);
                UnhookChannel(channel);
            }

            Action<IHyperSocket, IDisconnectedEventArgs> evnt = Disconnected;
            if(evnt != null) evnt(this, new DisconnectedEventArgs {Binding = binding, Reason = reason, Socket = this, RemoteNodeId = channel.RemoteNodeId});
        }

 public ShutdownEventArgs(Exception exception) {
     Reason = ShutdownReason.Exception;
     Exception = exception;
 }

 static bool Kernel32_ProcessShuttingDown(ShutdownReason sig) {
     ShutdownEventArgs args = new ShutdownEventArgs(sig);
     RaiseShutdownEvent(args);
     return false;
 }

 private void ChannelDisconnecting(IChannel channel, ShutdownReason shutdownReason)
 {
     _letterDispatcher.DequeueChannel(channel);
     Action<IHyperSocket, IDisconnectingEventArgs> evnt = Disconnecting;
     if(evnt != null)
         evnt(this, new DisconnectingEventArgs {Binding = channel.Binding, Reason = shutdownReason, RemoteNodeId = channel.RemoteNodeId, Socket = this});
 }

        /// <summary>
        ///   Handles the event of the dispatcher closing (and disposing)
        ///   because of a disconnect or a user request.
        /// </summary>
        /// <param name="reason"> The reason why the dispatcher closed. </param>
        internal void HandleDispatcherClosed(ShutdownReason reason)
        {
            this.ShutdownReason = reason;
            this.dispatcher = null;

#if DEBUG
            this.runningLock.Set();
#endif

            this.OnDisconnected(new DisconnectedEventArgs(reason));
        }

 void Shutdown( ShutdownReason reason, bool quit )
 {
     if( shutdownPending ) return;
     shutdownPending = true;
     SetURIDisplayEnabled(false);
     SetConsoleEnabled(false);
     SetConsoleText("Shutting down...");
     Server.Shutdown( new ShutdownParams( reason, TimeSpan.Zero, quit, false ), false );
 }

        private void DispatchAction(Action a)
        {
            var initAction = a as InitializeAction;
            if (initAction != null)
            {
                ShardId = initAction.ShardId;
                _stateMachine.Fire(Trigger.BeginInitialize);
                return;
            }

            var processRecordAction = a as ProcessRecordsAction;
            if (processRecordAction != null)
            {
                Records = processRecordAction.Records;
                _stateMachine.Fire(Trigger.BeginProcessRecords);
                return;
            }

            var shutdownAction = a as ShutdownAction;
            if (shutdownAction != null)
            {
                ShutdownReason = (ShutdownReason)Enum.Parse(typeof(ShutdownReason), shutdownAction.Reason);
                _stateMachine.Fire(Trigger.BeginShutdown);
                return;
            }

            var checkpointAction = a as CheckpointAction;
            if (checkpointAction != null)
            {
                CheckpointError = checkpointAction.Error;
                CheckpointSeqNo = checkpointAction.SequenceNumber;
                _stateMachine.Fire(Trigger.FinishCheckpoint);
                return;
            }

            throw new MalformedActionException("Received an action which couldn't be understood: " + a.Type);
        }

 private static extern bool ExitWindowsEx(EXIT_WINDOWS uFlags, ShutdownReason dwReason);

		internal static extern int		ExitWindowsEx			(ExitWindows exitFlags, ShutdownReason shutDownReason);