haiku.git

/*
 * Copyright 2005-2008, Ingo Weinhold, bonefish@users.sf.net.
 * Copyright 2006-2009, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2006-2008, Stephan Aßmus.
 * Copyright 2006, Ryan Leavengood.
 * Copyright 2021, Jacob Secunda.
 *
 * Distributed under the terms of the MIT License.
 */

#include "ShutdownProcess.h"

#include <new>
#include <string.h>

#include <signal.h>
#include <unistd.h>

#include <Alert.h>
#include <AppFileInfo.h>
#include <AppMisc.h>
#include <Autolock.h>
#include <Bitmap.h>
#include <Button.h>
#include <ControlLook.h>
#include <Catalog.h>
#include <File.h>
#include <Message.h>
#include <MessagePrivate.h>
#include <RegistrarDefs.h>
#include <Roster.h>		// for B_REQUEST_QUIT
#include <Screen.h>
#include <String.h>
#include <TextView.h>
#include <Window.h>

#include <TokenSpace.h>
#include <util/DoublyLinkedList.h>

#include <syscalls.h>

#include "AppInfoListMessagingTargetSet.h"
#include "Debug.h"
#include "EventQueue.h"
#include "MessageDeliverer.h"
#include "MessageEvent.h"
#include "Registrar.h"
#include "RosterAppInfo.h"
#include "TRoster.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "ShutdownProcess"


using std::nothrow;
using namespace BPrivate;

// The time span a non-background application has after the quit message has
// been delivered (more precisely: has been handed over to the
// MessageDeliverer).
static const bigtime_t kAppQuitTimeout = 3000000; // 3 s

// The time span a background application has after the quit message has been
// delivered (more precisely: has been handed over to the MessageDeliverer).
static const bigtime_t kBackgroundAppQuitTimeout = 3000000; // 3 s

// The time span non-app processes have after the TERM signal has been send
// to them before they get a KILL signal.
static const bigtime_t kNonAppQuitTimeout = 500000; // 0.5 s

// The time span the app that has aborted the shutdown shall be displayed in
// the shutdown window before closing it automatically.
static const bigtime_t kDisplayAbortingAppTimeout = 3000000; // 3 s

// The speed of the animation played when an application is blocked on a modal
// panel.
static const bigtime_t kIconAnimateInterval = 50000 * B_LARGE_ICON; // 0.05 s

// message what fields (must not clobber the registrar's message namespace)
enum {
	MSG_PHASE_TIMED_OUT		= 'phto',
	MSG_DONE				= 'done',
	MSG_KILL_APPLICATION	= 'kill',
	MSG_CANCEL_SHUTDOWN		= 'cncl',
	MSG_REBOOT_SYSTEM		= 'lbot',
};

// internal events
enum {
	NO_EVENT,
	ABORT_EVENT,
	TIMEOUT_EVENT,
	APP_QUIT_EVENT,
	KILL_APP_EVENT,
	REBOOT_SYSTEM_EVENT,
	DEBUG_EVENT
};

// phases
enum {
	INVALID_PHASE						= -1,
	USER_APP_TERMINATION_PHASE			= 0,
	SYSTEM_APP_TERMINATION_PHASE		= 1,
	BACKGROUND_APP_TERMINATION_PHASE	= 2,
	OTHER_PROCESSES_TERMINATION_PHASE	= 3,
	ABORTED_PHASE						= 4,
	DONE_PHASE							= 5,
};


static bool
inverse_compare_by_registration_time(const RosterAppInfo* info1,
	const RosterAppInfo* info2)
{
	return (info2->registration_time < info1->registration_time);
}


/*!	\brief Used to avoid type matching problems when throwing a constant.
*/
static inline
void
throw_error(status_t error)
{
	throw error;
}


class ShutdownProcess::TimeoutEvent : public MessageEvent {
public:
	TimeoutEvent(BHandler* target)
		: MessageEvent(0, target, MSG_PHASE_TIMED_OUT)
	{
		SetAutoDelete(false);

		fMessage.AddInt32("phase", INVALID_PHASE);
		fMessage.AddInt32("team", -1);
	}

	void SetPhase(int32 phase)
	{
		fMessage.ReplaceInt32("phase", phase);
	}

	void SetTeam(team_id team)
	{
		fMessage.ReplaceInt32("team", team);
	}

	static int32 GetMessagePhase(BMessage* message)
	{
		int32 phase;
		if (message->FindInt32("phase", &phase) != B_OK)
			phase = INVALID_PHASE;

		return phase;
	}

	static int32 GetMessageTeam(BMessage* message)
	{
		team_id team;
		if (message->FindInt32("team", &team) != B_OK)
			team = -1;

		return team;
	}
};


class ShutdownProcess::InternalEvent
	: public DoublyLinkedListLinkImpl<InternalEvent> {
public:
	InternalEvent(uint32 type, team_id team, int32 phase)
		:
		fType(type),
		fTeam(team),
		fPhase(phase)
	{
	}

	uint32 Type() const			{ return fType; }
	team_id Team() const		{ return fTeam; }
	int32 Phase() const			{ return fPhase; }

private:
	uint32	fType;
	int32	fTeam;
	int32	fPhase;
};


struct ShutdownProcess::InternalEventList : DoublyLinkedList<InternalEvent> {
};


class ShutdownProcess::QuitRequestReplyHandler : public BHandler {
public:
	QuitRequestReplyHandler(ShutdownProcess* shutdownProcess)
		: BHandler("shutdown quit reply handler"),
		fShutdownProcess(shutdownProcess)
	{
	}

	virtual void MessageReceived(BMessage* message)
	{
		switch (message->what) {
			case B_REPLY:
			{
				bool result;
				thread_id thread;
				if (message->FindBool("result", &result) == B_OK
					&& message->FindInt32("thread", &thread) == B_OK) {
					if (!result)
						fShutdownProcess->_NegativeQuitRequestReply(thread);
				}

				break;
			}

			default:
				BHandler::MessageReceived(message);
				break;
		}
	}

private:
	ShutdownProcess	*fShutdownProcess;
};


class ShutdownProcess::ShutdownWindow : public BAlert {
public:
	ShutdownWindow()
		:
		BAlert(),
		fKillAppMessage(NULL),
		fCurrentApp(-1),

		fCurrentIconBitmap(NULL),
		fNormalIconBitmap(NULL),
		fTintedIconBitmap(NULL),
		fAnimationActive(false),
		fAnimationWorker(-1),
		fCurrentAnimationRow(-1),
		fAnimationLightenPhase(true)
	{
		SetTitle(B_TRANSLATE("Shutdown status"));
		SetWorkspaces(B_ALL_WORKSPACES);
		SetLook(B_TITLED_WINDOW_LOOK);
		SetFlags(Flags() | B_NOT_MINIMIZABLE | B_NOT_ZOOMABLE);

		SetButtonWidth(B_WIDTH_AS_USUAL);
		SetType(B_EMPTY_ALERT);
	}

	~ShutdownWindow()
	{
		atomic_set(&fAnimationActive, false);
		wait_for_thread(fAnimationWorker, NULL);

		delete fNormalIconBitmap;
		delete fTintedIconBitmap;

		for (int32 i = 0; AppInfo* info = (AppInfo*)fAppInfos.ItemAt(i); i++) {
			delete info;
		}
	}

	virtual bool QuitRequested()
	{
		return false;
	}

	status_t Init(BMessenger target)
	{
		// kill app button
		AddButton(B_TRANSLATE("Kill application"));
		fKillAppButton = ButtonAt(CountButtons() - 1);

		BMessage* message = new BMessage(MSG_KILL_APPLICATION);
		if (!message)
			return B_NO_MEMORY;
		message->AddInt32("team", -1);
		fKillAppMessage = message;
		fKillAppButton->SetMessage(message);
		fKillAppButton->SetTarget(target);

		// cancel shutdown button
		AddButton(B_TRANSLATE("Cancel shutdown"));
		fCancelShutdownButton = ButtonAt(CountButtons() - 1);

		message = new BMessage(MSG_CANCEL_SHUTDOWN);
		if (!message)
			return B_NO_MEMORY;
		fCancelShutdownButton->SetMessage(message);
		fCancelShutdownButton->SetTarget(target);

		// reboot system button
		AddButton(B_TRANSLATE("Restart system"));
		fRebootSystemButton = ButtonAt(CountButtons() - 1);
		fRebootSystemButton->Hide();

		message = new BMessage(MSG_REBOOT_SYSTEM);
		if (!message)
			return B_NO_MEMORY;
		fRebootSystemButton->SetMessage(message);
		fRebootSystemButton->SetTarget(target);

		// aborted OK button
		AddButton(B_TRANSLATE("OK"));
		fAbortedOKButton = ButtonAt(CountButtons() - 1);
		fAbortedOKButton->Hide();

		message = new BMessage(MSG_CANCEL_SHUTDOWN);
		if (!message)
			return B_NO_MEMORY;
		fAbortedOKButton->SetMessage(message);
		fAbortedOKButton->SetTarget(target);

		return B_OK;
	}

	status_t AddApp(team_id team, BBitmap* appIcon)
	{
		AppInfo* info = new(nothrow) AppInfo;
		if (!info) {
			delete appIcon;
			return B_NO_MEMORY;
		}

		info->team = team;
		info->appIcon = appIcon;

		if (!fAppInfos.AddItem(info)) {
			delete info;
			return B_NO_MEMORY;
		}

		return B_OK;
	}

	void RemoveApp(team_id team)
	{
		int32 index = _AppInfoIndexOf(team);
		if (index < 0)
			return;

		if (team == fCurrentApp)
			SetCurrentApp(-1);

		AppInfo* info = (AppInfo*)fAppInfos.RemoveItem(index);
		delete info;
	}

	void SetCurrentApp(team_id team)
	{
		AppInfo* info = (team >= 0 ? _AppInfoFor(team) : NULL);

		fCurrentApp = team;
		SetAppInfo(info);

		fKillAppMessage->ReplaceInt32("team", team);
	}

	void SetText(const char* text)
	{
		const int32 initialLength = TextView()->TextLength(),
			initialLines = TextView()->CountLines();

		BAlert::SetText(text);

		if (TextView()->CountLines() > initialLines
				|| TextView()->CountLines() > (initialLength * 2))
			ResizeToPreferred();
	}

	void SetCancelShutdownButtonEnabled(bool enable)
	{
		fCancelShutdownButton->SetEnabled(enable);
	}

	void SetKillAppButtonEnabled(bool enable)
	{
		if (enable != fKillAppButton->IsEnabled()) {
			fKillAppButton->SetEnabled(enable);

			if (enable)
				fKillAppButton->Show();
			else
				fKillAppButton->Hide();
			ResizeToPreferred();
		}
	}

	void SetWaitAnimationEnabled(bool enable)
	{
		IconWaitAnimationEnabled(enable);
	}

	void SetWaitForShutdown()
	{
		fKillAppButton->Hide();
		fCancelShutdownButton->Hide();
		fRebootSystemButton->MakeDefault(true);
		fRebootSystemButton->Show();

		SetTitle(B_TRANSLATE("System is shut down"));
		SetText(B_TRANSLATE("It's now safe to turn off the computer."));
	}

	void SetWaitForAbortedOK()
	{
		fKillAppButton->Hide();
		fCancelShutdownButton->Hide();
		fAbortedOKButton->MakeDefault(true);
		fAbortedOKButton->Show();
		ResizeToPreferred();

		SetTitle(B_TRANSLATE("Shutdown aborted"));
	}

private:
	struct AppInfo {
		team_id		team;
		BBitmap*	appIcon;

		~AppInfo()
		{
			delete appIcon;
		}
	};

	int32 _AppInfoIndexOf(team_id team)
	{
		if (team < 0)
			return -1;

		for (int32 i = 0; AppInfo* info = (AppInfo*)fAppInfos.ItemAt(i); i++) {
			if (info->team == team)
				return i;
		}

		return -1;
	}

	AppInfo* _AppInfoFor(team_id team)
	{
		int32 index = _AppInfoIndexOf(team);
		return (index >= 0 ? (AppInfo*)fAppInfos.ItemAt(index) : NULL);
	}

private:
	void SetAppInfo(AppInfo* info)
	{
		IconWaitAnimationEnabled(false);

		BAutolock lock(this);
		if (!lock.IsLocked())
			return;

		delete fNormalIconBitmap;
		fNormalIconBitmap = NULL;

		delete fTintedIconBitmap;
		fTintedIconBitmap = NULL;

		// We do not delete the present fCurrentIconBitmap as the BAlert owns it.
		fCurrentIconBitmap = NULL;

		if (info != NULL && info->appIcon != NULL
			&& info->appIcon->IsValid()) {
			fCurrentIconBitmap = new BBitmap(info->appIcon->Bounds(), B_RGBA32);

			if (fCurrentIconBitmap == NULL
				|| fCurrentIconBitmap->ImportBits(info->appIcon) != B_OK) {
				delete fCurrentIconBitmap;
				fCurrentIconBitmap = NULL;
			} else
				SetIcon(fCurrentIconBitmap);
		} else
			SetIcon(NULL);
	}

	void IconWaitAnimationEnabled(bool enable)
	{
		if (atomic_get(&fAnimationActive) == enable)
			return;

		BAutolock lock(this);
		if (!lock.IsLocked())
			return;

		if (enable) {
			if (fCurrentIconBitmap == NULL
				|| !fCurrentIconBitmap->IsValid())
				return;

			if (fNormalIconBitmap == NULL
				|| !fNormalIconBitmap->IsValid()) {
				delete fNormalIconBitmap;
				fNormalIconBitmap = NULL;

				fNormalIconBitmap = new BBitmap(fCurrentIconBitmap->Bounds(),
					B_BITMAP_NO_SERVER_LINK, B_RGBA32);

				if (fNormalIconBitmap == NULL
					|| fNormalIconBitmap->ImportBits(fCurrentIconBitmap)
						!= B_OK) {
					delete fNormalIconBitmap;
					fNormalIconBitmap = NULL;

					return;
				}
			}

			if (fTintedIconBitmap == NULL
				|| !fTintedIconBitmap->IsValid()) {
				delete fTintedIconBitmap;
				fTintedIconBitmap = NULL;

				fTintedIconBitmap = new BBitmap(fNormalIconBitmap->Bounds(),
					B_BITMAP_NO_SERVER_LINK, B_RGBA32);

				if (fTintedIconBitmap == NULL
					|| fTintedIconBitmap->ImportBits(fNormalIconBitmap)
						!= B_OK) {
					delete fTintedIconBitmap;
					fTintedIconBitmap = NULL;

					return;
				}

				int32 width =
					fTintedIconBitmap->Bounds().IntegerWidth() + 1;
				int32 height =
					fTintedIconBitmap->Bounds().IntegerHeight() + 1;
				int32 rowLength = fTintedIconBitmap->BytesPerRow();

				uint8* iconBits = (uint8*)fTintedIconBitmap->Bits();

				for (int32 y = 0; y < height; y++) {
					for (int32 x = 0; x < width; x++) {
						int32 offset = (y * rowLength) + (x * 4);

						rgb_color pixelColor = make_color(iconBits[offset],
							iconBits[offset + 1], iconBits[offset + 2],
							iconBits[offset + 3]);

						pixelColor = tint_color(pixelColor,
							B_DARKEN_2_TINT);

						iconBits[offset] = pixelColor.red;
						iconBits[offset + 1] = pixelColor.green;
						iconBits[offset + 2] = pixelColor.blue;
						iconBits[offset + 3] = pixelColor.alpha;
					}
				}
			}

			fAnimationWorker = spawn_thread(&_AnimateWaitIconWorker,
				"thumb twiddling", B_DISPLAY_PRIORITY, this);

			if (fAnimationWorker < B_NO_ERROR)
				return;

			atomic_set(&fAnimationActive, true);
			if (resume_thread(fAnimationWorker) != B_OK)
				atomic_set(&fAnimationActive, false);
		} else {
			atomic_set(&fAnimationActive, false);
			wait_for_thread(fAnimationWorker, NULL);

			fCurrentAnimationRow = -1;
			fAnimationLightenPhase = true;

			if (fCurrentIconBitmap != NULL && fNormalIconBitmap != NULL)
				fCurrentIconBitmap->ImportBits(fNormalIconBitmap);
		}
	}

private:
	status_t _AnimateWaitIcon()
	{
		int32 lastHeight = 1;
		while (atomic_get(&fAnimationActive)) {
			if (LockWithTimeout(kIconAnimateInterval / lastHeight) != B_OK)
				continue;

			lastHeight = fCurrentIconBitmap->Bounds().IntegerHeight();
			if (fCurrentAnimationRow < 0) {
				fCurrentAnimationRow = lastHeight;
				fAnimationLightenPhase = !fAnimationLightenPhase;
			}

			BBitmap* sourceBitmap = fAnimationLightenPhase ?
				fNormalIconBitmap : fTintedIconBitmap;

			fCurrentIconBitmap->ImportBits(sourceBitmap,
				BPoint(0, fCurrentAnimationRow),
				BPoint(0, fCurrentAnimationRow),
				BSize(sourceBitmap->Bounds().IntegerWidth() - 1, 0));

			fCurrentAnimationRow--;

			ChildAt(0)->Invalidate();

			Unlock();
			snooze(kIconAnimateInterval / lastHeight);
		}

		return B_OK;
	}

	static status_t _AnimateWaitIconWorker(void* cookie)
	{
		ShutdownWindow* ourView = (ShutdownWindow*)cookie;
		return ourView->_AnimateWaitIcon();
	}

private:
	BList				fAppInfos;
	BButton*			fKillAppButton;
	BButton*			fCancelShutdownButton;
	BButton*			fRebootSystemButton;
	BButton*			fAbortedOKButton;
	BMessage*			fKillAppMessage;
	team_id				fCurrentApp;

private:
	BBitmap*		fCurrentIconBitmap;
	BBitmap*		fNormalIconBitmap;
	BBitmap*		fTintedIconBitmap;
	int32			fAnimationActive;
	thread_id		fAnimationWorker;
	int32			fCurrentAnimationRow;
	bool			fAnimationLightenPhase;
};


// #pragma mark -


ShutdownProcess::ShutdownProcess(TRoster* roster, EventQueue* eventQueue)
	:
	BLooper("shutdown process"),
	EventMaskWatcher(BMessenger(this), B_REQUEST_QUIT | B_REQUEST_LAUNCHED),
	fWorkerLock("worker lock"),
	fRequest(NULL),
	fRoster(roster),
	fEventQueue(eventQueue),
	fTimeoutEvent(NULL),
	fInternalEvents(NULL),
	fInternalEventSemaphore(-1),
	fQuitRequestReplyHandler(NULL),
	fWorker(-1),
	fCurrentPhase(INVALID_PHASE),
	fShutdownError(B_ERROR),
	fHasGUI(false),
	fReboot(false),
	fRequestReplySent(false),
	fWindow(NULL)
{
}


ShutdownProcess::~ShutdownProcess()
{
	// terminate the GUI
	if (fHasGUI && fWindow && fWindow->Lock())
		fWindow->Quit();

	// remove and delete the quit request reply handler
	if (fQuitRequestReplyHandler) {
		BAutolock _(this);
		RemoveHandler(fQuitRequestReplyHandler);
		delete fQuitRequestReplyHandler;
	}

	// remove and delete the timeout event
	if (fTimeoutEvent) {
		fEventQueue->RemoveEvent(fTimeoutEvent);

		delete fTimeoutEvent;
	}

	// remove the application quit watcher
	fRoster->RemoveWatcher(this);

	// If an error occurred (e.g. the shutdown process was cancelled), the
	// roster should accept applications again.
	if (fShutdownError != B_OK)
		fRoster->SetShuttingDown(false);

	// delete the internal event semaphore
	if (fInternalEventSemaphore >= 0)
		delete_sem(fInternalEventSemaphore);

	// wait for the worker thread to terminate
	if (fWorker >= 0) {
		int32 result;
		wait_for_thread(fWorker, &result);
	}

	// delete all internal events and the queue
	if (fInternalEvents) {
		while (InternalEvent* event = fInternalEvents->First()) {
			fInternalEvents->Remove(event);
			delete event;
		}

		delete fInternalEvents;
	}

	// send a reply to the request and delete it
	_SendReply(fShutdownError);
	delete fRequest;
}


status_t
ShutdownProcess::Init(BMessage* request)
{
	PRINT("ShutdownProcess::Init()\n");

	// create and add the quit request reply handler
	fQuitRequestReplyHandler = new(nothrow) QuitRequestReplyHandler(this);
	if (!fQuitRequestReplyHandler)
		RETURN_ERROR(B_NO_MEMORY);
	AddHandler(fQuitRequestReplyHandler);

	// create the timeout event
	fTimeoutEvent = new(nothrow) TimeoutEvent(this);
	if (!fTimeoutEvent)
		RETURN_ERROR(B_NO_MEMORY);

	// create the event list
	fInternalEvents = new(nothrow) InternalEventList;
	if (!fInternalEvents)
		RETURN_ERROR(B_NO_MEMORY);

	// create the event sempahore
	fInternalEventSemaphore = create_sem(0, "shutdown events");
	if (fInternalEventSemaphore < 0)
		RETURN_ERROR(fInternalEventSemaphore);

	// init the app server connection
	fHasGUI = Registrar::App()->InitGUIContext() == B_OK;

	// start watching application quits
	status_t error = fRoster->AddWatcher(this);
	if (error != B_OK) {
		fRoster->SetShuttingDown(false);
		RETURN_ERROR(error);
	}

	// start the worker thread
	fWorker = spawn_thread(_WorkerEntry, "shutdown worker",
		B_NORMAL_PRIORITY + 1, this);
	if (fWorker < 0) {
		fRoster->RemoveWatcher(this);
		fRoster->SetShuttingDown(false);
		RETURN_ERROR(fWorker);
	}

	// everything went fine: now we own the request
	fRequest = request;

	if (fRequest->FindBool("reboot", &fReboot) != B_OK)
		fReboot = false;

	resume_thread(fWorker);

	PRINT("ShutdownProcess::Init() done\n");

	return B_OK;
}


void
ShutdownProcess::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_SOME_APP_QUIT:
		{
			// get the team
			team_id team;
			if (message->FindInt32("be:team", &team) != B_OK) {
				// should not happen
				return;
			}

			PRINT("ShutdownProcess::MessageReceived(): B_SOME_APP_QUIT: %"
				B_PRId32 "\n", team);

			// remove the app info from the respective list
			int32 phase;
			RosterAppInfo* info;
			{
				BAutolock _(fWorkerLock);

				info = fUserApps.InfoFor(team);
				if (info)
					fUserApps.RemoveInfo(info);
				else if ((info = fSystemApps.InfoFor(team)))
					fSystemApps.RemoveInfo(info);
				else if ((info = fBackgroundApps.InfoFor(team)))
					fBackgroundApps.RemoveInfo(info);
				else	// not found
					return;

				phase = fCurrentPhase;
			}

			// post the event
			_PushEvent(APP_QUIT_EVENT, team, phase);

			delete info;

			break;
		}

		case B_SOME_APP_LAUNCHED:
		{
			// get the team
			team_id team;
			if (message->FindInt32("be:team", &team) != B_OK) {
				// should not happen
				return;
			}

			PRINT("ShutdownProcess::MessageReceived(): B_SOME_APP_LAUNCHED: %"
				B_PRId32 "\n", team);

			// add the user app info to the respective list
			{
				BAutolock _(fWorkerLock);
				fRoster->AddAppInfo(fUserApps, team);
			}
			break;
		}

		case MSG_PHASE_TIMED_OUT:
		{
			// get the phase the event is intended for
			int32 phase = TimeoutEvent::GetMessagePhase(message);
			team_id team = TimeoutEvent::GetMessageTeam(message);;
			PRINT("MSG_PHASE_TIMED_OUT: phase: %" B_PRId32 ", team: %" B_PRId32
				"\n", phase, team);

			BAutolock _(fWorkerLock);

			if (phase == INVALID_PHASE || phase != fCurrentPhase)
				return;

			// post the event
			_PushEvent(TIMEOUT_EVENT, team, phase);

			break;
		}

		case MSG_KILL_APPLICATION:
		{
			team_id team;
			if (message->FindInt32("team", &team) != B_OK)
				break;

			// post the event
			_PushEvent(KILL_APP_EVENT, team, fCurrentPhase);
			break;
		}

		case MSG_CANCEL_SHUTDOWN:
		{
			// post the event
			_PushEvent(ABORT_EVENT, -1, fCurrentPhase);
			break;
		}

		case MSG_REBOOT_SYSTEM:
		{
			// post the event
			_PushEvent(REBOOT_SYSTEM_EVENT, -1, INVALID_PHASE);
			break;
		}

		case MSG_DONE:
		{
			// notify the registrar that we're done
			be_app->PostMessage(B_REG_SHUTDOWN_FINISHED, be_app);
			break;
		}

		case B_REG_TEAM_DEBUGGER_ALERT:
		{
			bool stopShutdown;
			if (message->FindBool("stop shutdown", &stopShutdown) == B_OK
				&& stopShutdown) {
				// post abort event to the worker
				_PushEvent(ABORT_EVENT, -1, fCurrentPhase);
				break;
			}

			bool open;
			team_id team;
			if (message->FindInt32("team", &team) != B_OK
				|| message->FindBool("open", &open) != B_OK)
				break;

			BAutolock _(fWorkerLock);
			if (open) {
				PRINT("B_REG_TEAM_DEBUGGER_ALERT: insert %" B_PRId32 "\n",
					team);
				fDebuggedTeams.Add(team);
			} else {
				PRINT("B_REG_TEAM_DEBUGGER_ALERT: remove %" B_PRId32 "\n",
					team);
				fDebuggedTeams.Remove(team);
				_PushEvent(DEBUG_EVENT, -1, fCurrentPhase);
			}
			break;
		}

		default:
			BLooper::MessageReceived(message);
			break;
	}
}


void
ShutdownProcess::SendReply(BMessage* request, status_t error)
{
	if (error == B_OK) {
		BMessage reply(B_REG_SUCCESS);
		request->SendReply(&reply);
	} else {
		BMessage reply(B_REG_ERROR);
		reply.AddInt32("error", error);
		request->SendReply(&reply);
	}
}


void
ShutdownProcess::_SendReply(status_t error)
{
	if (!fRequestReplySent) {
		SendReply(fRequest, error);
		fRequestReplySent = true;
	}
}


void
ShutdownProcess::_SetPhase(int32 phase)
{
	BAutolock _(fWorkerLock);

	if (phase == fCurrentPhase)
		return;

	fCurrentPhase = phase;

	// remove the timeout event scheduled for the previous phase
	fEventQueue->RemoveEvent(fTimeoutEvent);
}


void
ShutdownProcess::_ScheduleTimeoutEvent(bigtime_t timeout, team_id team)
{
	BAutolock _(fWorkerLock);

	// remove the timeout event
	fEventQueue->RemoveEvent(fTimeoutEvent);

	// set the event's phase, team and time
	fTimeoutEvent->SetPhase(fCurrentPhase);
	fTimeoutEvent->SetTeam(team);
	fTimeoutEvent->SetTime(system_time() + timeout);

	// add the event
	fEventQueue->AddEvent(fTimeoutEvent);
}


void
ShutdownProcess::_SetShowShutdownWindow(bool show)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		if (show == fWindow->IsHidden()) {
			if (show)
				fWindow->Go(NULL);
			else
				fWindow->Hide();
		}
	}
}


void
ShutdownProcess::_InitShutdownWindow()
{
	// prepare the window
	if (fHasGUI) {
		fWindow = new(nothrow) ShutdownWindow;
		if (fWindow != NULL) {
			status_t error = fWindow->Init(BMessenger(this));
			if (error != B_OK) {
				delete fWindow;
				fWindow = NULL;
			}
		}

		// add the applications
		if (fWindow) {
			BAutolock _(fWorkerLock);
			_AddShutdownWindowApps(fUserApps);
			_AddShutdownWindowApps(fSystemApps);
		} else {
			WARNING("ShutdownProcess::Init(): Failed to create or init "
				"shutdown window.");

			fHasGUI = false;
		}
	}
}


void
ShutdownProcess::_AddShutdownWindowApps(AppInfoList& infos)
{
	if (!fHasGUI)
		return;

	for (AppInfoList::Iterator it = infos.It(); it.IsValid(); ++it) {
		RosterAppInfo* info = *it;

		// init an app file info
		BFile file;
		status_t error = file.SetTo(&info->ref, B_READ_ONLY);
		if (error != B_OK) {
			WARNING("ShutdownProcess::_AddShutdownWindowApps(): Failed to "
				"open file for app %s: %s\n", info->signature,
				strerror(error));
			continue;
		}

		BAppFileInfo appFileInfo;
		error = appFileInfo.SetTo(&file);
		if (error != B_OK) {
			WARNING("ShutdownProcess::_AddShutdownWindowApps(): Failed to "
				"init app file info for app %s: %s\n", info->signature,
				strerror(error));
		}

		// get the application icon
		BBitmap* appIcon = new(nothrow) BBitmap(
			BRect(BPoint(0, 0), be_control_look->ComposeIconSize(B_LARGE_ICON)),
			B_BITMAP_NO_SERVER_LINK, B_RGBA32);
		if (appIcon != NULL) {
			error = appIcon->InitCheck();
			if (error == B_OK) {
				error = appFileInfo.GetTrackerIcon(appIcon,
					(icon_size)(appIcon->Bounds().IntegerWidth() + 1));
			}
			if (error != B_OK) {
				delete appIcon;
				appIcon = NULL;
			}
		}

		// add the app
		error = fWindow->AddApp(info->team, appIcon);
		if (error != B_OK) {
			WARNING("ShutdownProcess::_AddShutdownWindowApps(): Failed to "
				"add app to the shutdown window: %s\n", strerror(error));
		}
	}
}


void
ShutdownProcess::_RemoveShutdownWindowApp(team_id team)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->RemoveApp(team);
	}
}


void
ShutdownProcess::_SetShutdownWindowCurrentApp(team_id team)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetCurrentApp(team);
	}
}


void
ShutdownProcess::_SetShutdownWindowText(const char* text)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetText(text);
	}
}


void
ShutdownProcess::_SetShutdownWindowCancelButtonEnabled(bool enabled)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetCancelShutdownButtonEnabled(enabled);
	}
}


void
ShutdownProcess::_SetShutdownWindowKillButtonEnabled(bool enabled)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetKillAppButtonEnabled(enabled);
	}
}


void
ShutdownProcess::_SetShutdownWindowWaitAnimationEnabled(bool enabled)
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetWaitAnimationEnabled(enabled);
	}
}


void
ShutdownProcess::_SetShutdownWindowWaitForShutdown()
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetWaitForShutdown();
	}
}


void
ShutdownProcess::_SetShutdownWindowWaitForAbortedOK()
{
	if (fHasGUI) {
		BAutolock _(fWindow);

		fWindow->SetWaitForAbortedOK();
	}
}


void
ShutdownProcess::_NegativeQuitRequestReply(thread_id thread)
{
	BAutolock _(fWorkerLock);

	// Note: team ID == team main thread ID under Haiku. When testing under R5
	// using the team ID in case of an ABORT_EVENT won't work correctly. But
	// this is done only for system apps.
	_PushEvent(ABORT_EVENT, thread, fCurrentPhase);
}


void
ShutdownProcess::_PrepareShutdownMessage(BMessage& message) const
{
	message.what = B_QUIT_REQUESTED;
	message.AddBool("_shutdown_", true);

	BMessage::Private(message).SetReply(BMessenger(fQuitRequestReplyHandler));
}


status_t
ShutdownProcess::_ShutDown()
{
	PRINT("Invoking _kern_shutdown(%d)\n", fReboot);
	RETURN_ERROR(_kern_shutdown(fReboot));
}


status_t
ShutdownProcess::_PushEvent(uint32 eventType, team_id team, int32 phase)
{
	InternalEvent* event = new(nothrow) InternalEvent(eventType, team, phase);
	if (!event) {
		ERROR("ShutdownProcess::_PushEvent(): Failed to create event!\n");

		return B_NO_MEMORY;
	}

	BAutolock _(fWorkerLock);

	fInternalEvents->Add(event);
	release_sem(fInternalEventSemaphore);

	return B_OK;
}


status_t
ShutdownProcess::_GetNextEvent(uint32& eventType, thread_id& team, int32& phase,
	bool block)
{
	while (true) {
		// acquire the semaphore
		if (block) {
			status_t error;
			do {
				error = acquire_sem(fInternalEventSemaphore);
			} while (error == B_INTERRUPTED);

			if (error != B_OK)
				return error;
		} else {
			status_t error = acquire_sem_etc(fInternalEventSemaphore, 1,
				B_RELATIVE_TIMEOUT, 0);
			if (error != B_OK) {
				eventType = NO_EVENT;
				return B_OK;
			}
		}

		// get the event
		BAutolock _(fWorkerLock);

		InternalEvent* event = fInternalEvents->Head();
		fInternalEvents->Remove(event);

		eventType = event->Type();
		team = event->Team();
		phase = event->Phase();

		delete event;

		// if the event is an obsolete timeout event, we drop it right here
		if (eventType == TIMEOUT_EVENT && phase != fCurrentPhase)
			continue;

		break;
	}

	// notify the window, if an app has been removed
	if (eventType == APP_QUIT_EVENT)
		_RemoveShutdownWindowApp(team);

	return B_OK;
}


status_t
ShutdownProcess::_WorkerEntry(void* data)
{
	return ((ShutdownProcess*)data)->_Worker();
}


status_t
ShutdownProcess::_Worker()
{
	try {
		_WorkerDoShutdown();
		fShutdownError = B_OK;
	} catch (status_t error) {
		PRINT("ShutdownProcess::_Worker(): error while shutting down: %s\n",
			strerror(error));

		fShutdownError = error;
	}

	// this can happen only, if the shutdown process failed or was aborted:
	// notify the looper
	_SetPhase(DONE_PHASE);
	PostMessage(MSG_DONE);

	return B_OK;
}


void
ShutdownProcess::_WorkerDoShutdown()
{
	PRINT("ShutdownProcess::_WorkerDoShutdown()\n");

	// If we are here, the shutdown process has been initiated successfully,
	// that is, if an asynchronous BRoster::Shutdown() was requested, we
	// notify the caller at this point.
	bool synchronous;
	if (fRequest->FindBool("synchronous", &synchronous) == B_OK && !synchronous)
		_SendReply(B_OK);

	// ask the user to confirm the shutdown, if desired
	bool askUser;
	if (fHasGUI && fRequest->FindBool("confirm", &askUser) == B_OK && askUser) {
		const char* restart = B_TRANSLATE("Restart");
		const char* shutdown = B_TRANSLATE("Shut down");
		BString title = B_TRANSLATE("%action%?");
		title.ReplaceFirst("%action%", fReboot ? restart : shutdown);
		const char* text = fReboot
			? B_TRANSLATE("Do you really want to restart the system?")
			: B_TRANSLATE("Do you really want to shut down the system?");
		const char* defaultText = fReboot ? restart : shutdown;
		const char* otherText = fReboot ? shutdown : restart;
		BAlert* alert = new BAlert(title.String(), text,
			B_TRANSLATE("Cancel"), otherText, defaultText,
			B_WIDTH_AS_USUAL, B_WARNING_ALERT);
		// We want the alert to behave more like a regular window...
		alert->SetFeel(B_NORMAL_WINDOW_FEEL);
		// ...but not quit. Minimizing the alert would prevent the user from
		// finding it again, since registrar does not have an entry in the
		// Deskbar.
		alert->SetFlags(alert->Flags() | B_NOT_MINIMIZABLE | B_CLOSE_ON_ESCAPE);
		alert->SetWorkspaces(B_ALL_WORKSPACES);
		int32 result = alert->Go();

		if (result == 1) {
			// Toggle shutdown method
			fReboot = !fReboot;
		} else if (result < 1)
			throw_error(B_SHUTDOWN_CANCELLED);
	}

	fWorkerLock.Lock();
	// get a list of all applications to shut down and sort them
	status_t status = fRoster->GetShutdownApps(fUserApps, fSystemApps,
		fBackgroundApps, fVitalSystemApps);
	if (status  != B_OK) {
		fWorkerLock.Unlock();
		fRoster->RemoveWatcher(this);
		return;
	}

	fUserApps.Sort(&inverse_compare_by_registration_time);
	fSystemApps.Sort(&inverse_compare_by_registration_time);

	fWorkerLock.Unlock();

	// make the shutdown window ready and show it
	_InitShutdownWindow();
	_SetShutdownWindowCurrentApp(-1);
	_SetShutdownWindowText(B_TRANSLATE("Tidying things up a bit."));
	_SetShutdownWindowCancelButtonEnabled(true);
	_SetShutdownWindowKillButtonEnabled(false);
	_SetShowShutdownWindow(true);

	// sync
	sync();

	// phase 1: terminate the user apps
	_SetPhase(USER_APP_TERMINATION_PHASE);

	// since, new apps can still be launched, loop until all are gone
	if (!fUserApps.IsEmpty()) {
		_QuitApps(fUserApps, false);
		_WaitForDebuggedTeams();
	}

	// tell TRoster not to accept new applications anymore
	fRoster->SetShuttingDown(true);

	// phase 2: terminate the system apps
	_SetPhase(SYSTEM_APP_TERMINATION_PHASE);
	_QuitApps(fSystemApps, true);
	_WaitForDebuggedTeams();

	// phase 3: terminate the background apps
	_SetPhase(BACKGROUND_APP_TERMINATION_PHASE);
	_QuitBackgroundApps();
	_WaitForDebuggedTeams();

	// phase 4: terminate the other processes
	_SetPhase(OTHER_PROCESSES_TERMINATION_PHASE);
	_QuitNonApps();
	_ScheduleTimeoutEvent(kBackgroundAppQuitTimeout, -1);
	_WaitForBackgroundApps();
	_KillBackgroundApps();
	_WaitForDebuggedTeams();

	// we're through: do the shutdown
	_SetPhase(DONE_PHASE);
	if (fReboot)
		_SetShutdownWindowText(B_TRANSLATE("Restarting" B_UTF8_ELLIPSIS));
	else
		_SetShutdownWindowText(B_TRANSLATE("Shutting down" B_UTF8_ELLIPSIS));
	_ShutDown();
	_SetShutdownWindowWaitForShutdown();

	PRINT("  _kern_shutdown() failed\n");

	// shutdown failed: This can happen for power off mode -- reboot should
	// always work.
	if (fHasGUI) {
		// wait for the reboot event
		uint32 event;
		do {
			team_id team;
			int32 phase;
			status = _GetNextEvent(event, team, phase, true);
			if (status != B_OK)
				break;
		} while (event != REBOOT_SYSTEM_EVENT);

		_kern_shutdown(true);
	}

	// either there's no GUI or reboot failed: we enter the kernel debugger
	// instead
	while (true) {
		_kern_kernel_debugger("The system is shut down. It's now safe to turn "
			"off the computer.");
	}
}


bool
ShutdownProcess::_WaitForApp(team_id team, AppInfoList* list, bool systemApps)
{
	uint32 event;
	do {
		team_id eventTeam;
		int32 phase;
		status_t error = _GetNextEvent(event, eventTeam, phase, true);
		if (error != B_OK)
			throw_error(error);

		if (event == APP_QUIT_EVENT && eventTeam == team)
			return true;

		if (event == TIMEOUT_EVENT && eventTeam == team)
			return false;

		if (event == ABORT_EVENT) {
			if (eventTeam == -1) {
				// The user canceled the shutdown process by pressing the
				// Cancel button.
				throw_error(B_SHUTDOWN_CANCELLED);
			}
			if (systemApps) {
				// If the app requests aborting the shutdown, we don't need
				// to wait any longer. It has processed the request and
				// won't quit by itself. We ignore this for system apps.
				if (eventTeam == team)
					return false;
			} else {
				// The app returned false in QuitRequested().
				PRINT("ShutdownProcess::_WaitForApp(): shutdown cancelled "
					"by team %" B_PRId32 " (-1 => user)\n", eventTeam);

				_DisplayAbortingApp(team);
				throw_error(B_SHUTDOWN_CANCELLED);
			}
		}

		BAutolock _(fWorkerLock);
		if (list != NULL && !list->InfoFor(team))
			return true;
	} while (event != NO_EVENT);

	return false;
}


void
ShutdownProcess::_QuitApps(AppInfoList& list, bool systemApps)
{
	PRINT("ShutdownProcess::_QuitApps(%s)\n",
		(systemApps ? "system" : "user"));

	if (systemApps) {
		_SetShutdownWindowCancelButtonEnabled(false);

		// check one last time for abort events
		uint32 event;
		do {
			team_id team;
			int32 phase;
			status_t error = _GetNextEvent(event, team, phase, false);
			if (error != B_OK)
				throw_error(error);

			if (event == ABORT_EVENT) {
				PRINT("ShutdownProcess::_QuitApps(): shutdown cancelled by "
					"team %" B_PRId32 " (-1 => user)\n", team);

				_DisplayAbortingApp(team);
				throw_error(B_SHUTDOWN_CANCELLED);
			}

		} while (event != NO_EVENT);
	}

	// prepare the shutdown message
	BMessage message;
	_PrepareShutdownMessage(message);

	// now iterate through the list of apps
	while (true) {
		// eat events
		uint32 event;
		do {
			team_id team;
			int32 phase;
			status_t error = _GetNextEvent(event, team, phase, false);
			if (error != B_OK)
				throw_error(error);

			if (!systemApps && event == ABORT_EVENT) {
				PRINT("ShutdownProcess::_QuitApps(): shutdown cancelled by "
					"team %" B_PRId32 " (-1 => user)\n", team);

				_DisplayAbortingApp(team);
				throw_error(B_SHUTDOWN_CANCELLED);
			}

		} while (event != NO_EVENT);

		// get the first app to quit
		team_id team = -1;
		port_id port = -1;
		char appName[B_FILE_NAME_LENGTH];
		{
			BAutolock _(fWorkerLock);
			while (!list.IsEmpty()) {
				RosterAppInfo* info = *list.It();
				team = info->team;
				port = info->port;
				strcpy(appName, info->ref.name);

				if (info->IsRunning())
					break;
				list.RemoveInfo(info);
				delete info;
			}
		}

		if (team < 0) {
			PRINT("ShutdownProcess::_QuitApps() done\n");
			return;
		}

		// set window text
		BString buffer = B_TRANSLATE("Asking \"%appName%\" to quit.");
		buffer.ReplaceFirst("%appName%", appName);
		_SetShutdownWindowText(buffer.String());
		_SetShutdownWindowCurrentApp(team);

		// send the shutdown message to the app
		PRINT("  sending team %" B_PRId32 " (port: %" B_PRId32 ") a shutdown "
			"message\n", team, port);
		SingleMessagingTargetSet target(port, B_PREFERRED_TOKEN);
		MessageDeliverer::Default()->DeliverMessage(&message, target);

		// schedule a timeout event
		_ScheduleTimeoutEvent(kAppQuitTimeout, team);

		// wait for the app to die or for the timeout to occur
		bool appGone = _WaitForApp(team, &list, systemApps);
		if (appGone) {
			// fine: the app finished in an orderly manner
		} else {
			// the app is either blocking on a model alert or blocks for another
			// reason
			if (!systemApps)
				_QuitBlockingApp(list, team, appName, true);
			else {
				// This is a system app: remove it from the list
				BAutolock _(fWorkerLock);

				if (RosterAppInfo* info = list.InfoFor(team)) {
					list.RemoveInfo(info);
					delete info;
				}
			}
		}
	}
}


void
ShutdownProcess::_QuitBackgroundApps()
{
	PRINT("ShutdownProcess::_QuitBackgroundApps()\n");

	_SetShutdownWindowText(
		B_TRANSLATE("Asking background applications to quit."));

	// prepare the shutdown message
	BMessage message;
	_PrepareShutdownMessage(message);

	// send shutdown messages to user apps
	BAutolock _(fWorkerLock);

	AppInfoListMessagingTargetSet targetSet(fBackgroundApps);

	if (targetSet.HasNext()) {
		PRINT("  sending shutdown message to %" B_PRId32 " apps\n",
			fBackgroundApps.CountInfos());

		status_t error = MessageDeliverer::Default()->DeliverMessage(
			&message, targetSet);
		if (error != B_OK) {
			WARNING("_QuitBackgroundApps::_Worker(): Failed to deliver "
				"shutdown message to all applications: %s\n",
				strerror(error));
		}
	}

	PRINT("ShutdownProcess::_QuitBackgroundApps() done\n");
}


void
ShutdownProcess::_WaitForBackgroundApps()
{
	PRINT("ShutdownProcess::_WaitForBackgroundApps()\n");

	// wait for user apps
	bool moreApps = true;
	while (moreApps) {
		{
			BAutolock _(fWorkerLock);
			moreApps = !fBackgroundApps.IsEmpty();
		}

		if (moreApps) {
			uint32 event;
			team_id team;
			int32 phase;
			status_t error = _GetNextEvent(event, team, phase, true);
			if (error != B_OK)
				throw_error(error);

			if (event == ABORT_EVENT) {
				// ignore: it's too late to abort the shutdown
			}

			if (event == TIMEOUT_EVENT)
				return;
		}
	}

	PRINT("ShutdownProcess::_WaitForBackgroundApps() done\n");
}


void
ShutdownProcess::_KillBackgroundApps()
{
	PRINT("ShutdownProcess::_KillBackgroundApps()\n");

	while (true) {
		// eat events (we need to be responsive for an abort event)
		uint32 event;
		do {
			team_id team;
			int32 phase;
			status_t error = _GetNextEvent(event, team, phase, false);
			if (error != B_OK)
				throw_error(error);

		} while (event != NO_EVENT);

		// get the first team to kill
		team_id team = -1;
		char appName[B_FILE_NAME_LENGTH];
		AppInfoList& list = fBackgroundApps;
		{
			BAutolock _(fWorkerLock);

			if (!list.IsEmpty()) {
				RosterAppInfo* info = *list.It();
				team = info->team;
				strcpy(appName, info->ref.name);
			}
		}


		if (team < 0) {
			PRINT("ShutdownProcess::_KillBackgroundApps() done\n");
			return;
		}

		// the app is either blocking on a model alert or blocks for another
		// reason
		_QuitBlockingApp(list, team, appName, false);
	}
}


void
ShutdownProcess::_QuitNonApps()
{
	PRINT("ShutdownProcess::_QuitNonApps()\n");

	_SetShutdownWindowText(B_TRANSLATE("Asking other processes to quit."));

	// iterate through the remaining teams and send them the TERM signal
	int32 cookie = 0;
	team_info teamInfo;
	while (get_next_team_info(&cookie, &teamInfo) == B_OK) {
		if (!fVitalSystemApps.Contains(teamInfo.team)) {
			PRINT("  sending team %" B_PRId32 " TERM signal\n", teamInfo.team);

			// Note: team ID == team main thread ID under Haiku
			send_signal(teamInfo.team, SIGTERM);
		}
	}

	// give them a bit of time to terminate
	// TODO: Instead of just waiting we could periodically check whether the
	// processes are already gone to shorten the process.
	snooze(kNonAppQuitTimeout);

	// iterate through the remaining teams and kill them
	cookie = 0;
	while (get_next_team_info(&cookie, &teamInfo) == B_OK) {
		if (!fVitalSystemApps.Contains(teamInfo.team)) {
			PRINT("  killing team %" B_PRId32 "\n", teamInfo.team);

			kill_team(teamInfo.team);
		}
	}

	PRINT("ShutdownProcess::_QuitNonApps() done\n");
}


void
ShutdownProcess::_QuitBlockingApp(AppInfoList& list, team_id team,
	const char* appName, bool cancelAllowed)
{
	bool debugged = false;
	bool modal = false;
	{
		BAutolock _(fWorkerLock);
		if (fDebuggedTeams.Contains(team))
			debugged = true;
	}
	if (!debugged)
		modal = BPrivate::is_app_showing_modal_window(team);

	if (modal) {
		// app blocks on a modal window
		BString buffer = B_TRANSLATE("The application \"%appName%\" might be "
			"blocked on a modal panel.");
		buffer.ReplaceFirst("%appName%", appName);
		_SetShutdownWindowText(buffer.String());
		_SetShutdownWindowCurrentApp(team);
		_SetShutdownWindowKillButtonEnabled(true);
		_SetShutdownWindowWaitAnimationEnabled(true);
	}

	if (modal || debugged) {
		// wait for something to happen
		bool appGone = false;
		while (true) {
			uint32 event;
			team_id eventTeam;
			int32 phase;
			status_t error = _GetNextEvent(event, eventTeam, phase, true);
			if (error != B_OK)
				throw_error(error);

			if ((event == APP_QUIT_EVENT) && eventTeam == team) {
				appGone = true;
				break;
			}

			if (event == KILL_APP_EVENT && eventTeam == team)
				break;

			if (event == ABORT_EVENT) {
				if (cancelAllowed || debugged) {
					PRINT("ShutdownProcess::_QuitBlockingApp(): shutdown "
						"cancelled by team %" B_PRId32 " (-1 => user)\n",
						eventTeam);

					if (!debugged)
						_DisplayAbortingApp(eventTeam);
					throw_error(B_SHUTDOWN_CANCELLED);
				}

				// If the app requests aborting the shutdown, we don't need
				// to wait any longer. It has processed the request and
				// won't quit by itself. We'll have to kill it.
				if (eventTeam == team)
					break;
			}
		}

		_SetShutdownWindowKillButtonEnabled(false);
		_SetShutdownWindowWaitAnimationEnabled(false);

		if (appGone)
			return;
	}

	// kill the app
	PRINT("  killing team %" B_PRId32 "\n", team);

	kill_team(team);

	// remove the app (the roster will note eventually and send us
	// a notification, but we want to be sure)
	{
		BAutolock _(fWorkerLock);

		if (RosterAppInfo* info = list.InfoFor(team)) {
			list.RemoveInfo(info);
			delete info;
		}
	}
}


void
ShutdownProcess::_DisplayAbortingApp(team_id team)
{
	// find the app that cancelled the shutdown
	char appName[B_FILE_NAME_LENGTH];
	bool foundApp = false;
	{
		BAutolock _(fWorkerLock);

		RosterAppInfo* info = fUserApps.InfoFor(team);
		if (!info)
			info = fSystemApps.InfoFor(team);
		if (!info)
			fBackgroundApps.InfoFor(team);

		if (info) {
			foundApp = true;
			strcpy(appName, info->ref.name);
		}
	}

	if (!foundApp) {
		PRINT("ShutdownProcess::_DisplayAbortingApp(): Didn't find the app "
			"that has cancelled the shutdown.\n");
		return;
	}

	// compose the text to be displayed
	BString buffer = B_TRANSLATE("Application \"%appName%\" has aborted the "
		"shutdown process.");
	buffer.ReplaceFirst("%appName%", appName);

	// set up the window
	_SetShutdownWindowWaitAnimationEnabled(false);
	_SetShutdownWindowCurrentApp(team);
	_SetShutdownWindowText(buffer.String());
	_SetShutdownWindowWaitForAbortedOK();

	// schedule the timeout event
	_SetPhase(ABORTED_PHASE);
	_ScheduleTimeoutEvent(kDisplayAbortingAppTimeout);

	// wait for the timeout or the user to press the cancel button
	while (true) {
		uint32 event;
		team_id eventTeam;
		int32 phase;
		status_t error = _GetNextEvent(event, eventTeam, phase, true);
		if (error != B_OK)
			break;

		// stop waiting when the timeout occurs
		if (event == TIMEOUT_EVENT)
			break;

		// stop waiting when the user hit the cancel button
		if (event == ABORT_EVENT && phase == ABORTED_PHASE && eventTeam < 0)
			break;
	}
}


/*!	Waits until the debugged team list is empty, ie. when there is no one
	left to debug.
*/
void
ShutdownProcess::_WaitForDebuggedTeams()
{
	PRINT("ShutdownProcess::_WaitForDebuggedTeams()\n");
	{
		BAutolock _(fWorkerLock);
		if (fDebuggedTeams.Size() == 0)
			return;
	}

	PRINT("  not empty!\n");

	// wait for something to happen
	while (true) {
		uint32 event;
		team_id eventTeam;
		int32 phase;
		status_t error = _GetNextEvent(event, eventTeam, phase, true);
		if (error != B_OK)
			throw_error(error);

		if (event == ABORT_EVENT)
			throw_error(B_SHUTDOWN_CANCELLED);

		BAutolock _(fWorkerLock);
		if (fDebuggedTeams.Size() == 0) {
			PRINT("  out empty");
			return;
		}
	}
}