/*
 * Copyright 2013-2014, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include "CommitTransactionHandler.h"

#include <errno.h>
#include <grp.h>
#include <pwd.h>

#include <File.h>
#include <Path.h>
#include <SymLink.h>

#include <AutoDeleter.h>
#include <CopyEngine.h>
#include <NotOwningEntryRef.h>
#include <package/CommitTransactionResult.h>
#include <package/DaemonDefs.h>
#include <RemoveEngine.h>

#include "Constants.h"
#include "DebugSupport.h"
#include "Exception.h"
#include "PackageFileManager.h"
#include "VolumeState.h"


using namespace BPackageKit::BPrivate;

using BPackageKit::BTransactionIssue;


// #pragma mark - TransactionIssueBuilder


struct CommitTransactionHandler::TransactionIssueBuilder {
        TransactionIssueBuilder(BTransactionIssue::BType type,
                Package* package = NULL)
                :
                fType(type),
                fPackageName(package != NULL ? package->FileName() : BString()),
                fPath1(),
                fPath2(),
                fSystemError(B_OK),
                fExitCode(0)
        {
        }

        TransactionIssueBuilder& SetPath1(const BString& path)
        {
                fPath1 = path;
                return *this;
        }

        TransactionIssueBuilder& SetPath1(const FSUtils::Entry& entry)
        {
                return SetPath1(entry.Path());
        }

        TransactionIssueBuilder& SetPath2(const BString& path)
        {
                fPath2 = path;
                return *this;
        }

        TransactionIssueBuilder& SetPath2(const FSUtils::Entry& entry)
        {
                return SetPath2(entry.Path());
        }

        TransactionIssueBuilder& SetSystemError(status_t error)
        {
                fSystemError = error;
                return *this;
        }

        TransactionIssueBuilder& SetExitCode(int exitCode)
        {
                fExitCode = exitCode;
                return *this;
        }

        BTransactionIssue BuildIssue(Package* package) const
        {
                BString packageName(fPackageName);
                if (packageName.IsEmpty() && package != NULL)
                        packageName = package->FileName();

                return BTransactionIssue(fType, packageName, fPath1, fPath2,
                        fSystemError, fExitCode);
        }

private:
        BTransactionIssue::BType        fType;
        BString                                         fPackageName;
        BString                                         fPath1;
        BString                                         fPath2;
        status_t                                        fSystemError;
        int                                                     fExitCode;
};


// #pragma mark - CommitTransactionHandler


CommitTransactionHandler::CommitTransactionHandler(Volume* volume,
        PackageFileManager* packageFileManager, BCommitTransactionResult& result)
        :
        fVolume(volume),
        fPackageFileManager(packageFileManager),
        fVolumeState(NULL),
        fVolumeStateIsActive(false),
        fPackagesToActivate(),
        fPackagesToDeactivate(),
        fAddedPackages(),
        fRemovedPackages(),
        fPackagesAlreadyAdded(),
        fPackagesAlreadyRemoved(),
        fOldStateDirectory(),
        fOldStateDirectoryRef(),
        fOldStateDirectoryName(),
        fTransactionDirectoryRef(),
        fFirstBootProcessing(false),
        fWritableFilesDirectory(),
        fAddedGroups(),
        fAddedUsers(),
        fFSTransaction(),
        fResult(result),
        fCurrentPackage(NULL)
{
}


CommitTransactionHandler::~CommitTransactionHandler()
{
        // Delete Package objects we created in case of error (on success
        // fPackagesToActivate will be empty).
        int32 count = fPackagesToActivate.CountItems();
        for (int32 i = 0; i < count; i++) {
                Package* package = fPackagesToActivate.ItemAt(i);
                if (fPackagesAlreadyAdded.find(package)
                                == fPackagesAlreadyAdded.end()) {
                        delete package;
                }
        }

        delete fVolumeState;
}


void
CommitTransactionHandler::Init(VolumeState* volumeState,
        bool isActiveVolumeState, const PackageSet& packagesAlreadyAdded,
        const PackageSet& packagesAlreadyRemoved)
{
        fVolumeState = volumeState->Clone();
        if (fVolumeState == NULL)
                throw std::bad_alloc();

        fVolumeStateIsActive = isActiveVolumeState;

        for (PackageSet::const_iterator it = packagesAlreadyAdded.begin();
                        it != packagesAlreadyAdded.end(); ++it) {
                Package* package = fVolumeState->FindPackage((*it)->FileName());
                fPackagesAlreadyAdded.insert(package);
        }

        for (PackageSet::const_iterator it = packagesAlreadyRemoved.begin();
                        it != packagesAlreadyRemoved.end(); ++it) {
                Package* package = fVolumeState->FindPackage((*it)->FileName());
                fPackagesAlreadyRemoved.insert(package);
        }
}


void
CommitTransactionHandler::HandleRequest(BMessage* request)
{
        status_t error;

        BActivationTransaction transaction(request, &error);
        if (error == B_OK)
                error = transaction.InitCheck();
        if (error != B_OK) {
                if (error == B_NO_MEMORY)
                        throw Exception(B_TRANSACTION_NO_MEMORY);
                throw Exception(B_TRANSACTION_BAD_REQUEST);
        }

        HandleRequest(transaction);
}


void
CommitTransactionHandler::HandleRequest(
        const BActivationTransaction& transaction)
{
        // check the change count
        if (transaction.ChangeCount() != fVolume->ChangeCount())
                throw Exception(B_TRANSACTION_CHANGE_COUNT_MISMATCH);

        fFirstBootProcessing = transaction.FirstBootProcessing();

        // collect the packages to deactivate
        _GetPackagesToDeactivate(transaction);

        // read the packages to activate
        _ReadPackagesToActivate(transaction);

        // anything to do at all?
        if (fPackagesToActivate.IsEmpty() && fPackagesToDeactivate.empty()) {
                WARN("Bad package activation request: no packages to activate or"
                        " deactivate\n");
                throw Exception(B_TRANSACTION_BAD_REQUEST);
        }

        _ApplyChanges();

        // Clean up the unused empty transaction directory for first boot
        // processing, since it's usually an internal to package_daemon
        // operation and there is no external client to clean it up.
        if (fFirstBootProcessing) {
                RelativePath directoryPath(kAdminDirectoryName,
                        transaction.TransactionDirectoryName().String());
                BDirectory transactionDir;
                status_t error = _OpenPackagesSubDirectory(directoryPath, false,
                        transactionDir);
                if (error == B_OK) {
                        BEntry transactionDirEntry;
                        error = transactionDir.GetEntry(&transactionDirEntry);
                        if (error == B_OK)
                                transactionDirEntry.Remove(); // Okay to fail when non-empty.
                }
        }
}


void
CommitTransactionHandler::HandleRequest()
{
        for (PackageSet::const_iterator it = fPackagesAlreadyAdded.begin();
                it != fPackagesAlreadyAdded.end(); ++it) {
                if (!fPackagesToActivate.AddItem(*it))
                        throw std::bad_alloc();
        }

        fPackagesToDeactivate = fPackagesAlreadyRemoved;

        _ApplyChanges();
}


void
CommitTransactionHandler::Revert()
{
        // move packages to activate back to transaction directory
        _RevertAddPackagesToActivate();

        // move packages to deactivate back to packages directory
        _RevertRemovePackagesToDeactivate();

        // revert user and group changes
        _RevertUserGroupChanges();

        // Revert all other FS operations, i.e. the writable files changes as
        // well as the creation of the old state directory.
        fFSTransaction.RollBack();
}


VolumeState*
CommitTransactionHandler::DetachVolumeState()
{
        VolumeState* result = fVolumeState;
        fVolumeState = NULL;
        return result;
}


void
CommitTransactionHandler::_GetPackagesToDeactivate(
        const BActivationTransaction& transaction)
{
        // get the number of packages to deactivate
        const BStringList& packagesToDeactivate
                = transaction.PackagesToDeactivate();
        int32 packagesToDeactivateCount = packagesToDeactivate.CountStrings();
        if (packagesToDeactivateCount == 0)
                return;

        for (int32 i = 0; i < packagesToDeactivateCount; i++) {
                BString packageName = packagesToDeactivate.StringAt(i);
                Package* package = fVolumeState->FindPackage(packageName);
                if (package == NULL) {
                        throw Exception(B_TRANSACTION_NO_SUCH_PACKAGE)
                                .SetPackageName(packageName);
                }

                fPackagesToDeactivate.insert(package);
        }
}


void
CommitTransactionHandler::_ReadPackagesToActivate(
        const BActivationTransaction& transaction)
{
        // get the number of packages to activate
        const BStringList& packagesToActivate
                = transaction.PackagesToActivate();
        int32 packagesToActivateCount = packagesToActivate.CountStrings();
        if (packagesToActivateCount == 0)
                return;

        // check the transaction directory name -- we only allow a simple
        // subdirectory of the admin directory
        const BString& transactionDirectoryName
                = transaction.TransactionDirectoryName();
        if (transactionDirectoryName.IsEmpty()
                || transactionDirectoryName.FindFirst('/') >= 0
                || transactionDirectoryName == "."
                || transactionDirectoryName == "..") {
                WARN("Bad package activation request: malformed transaction"
                        " directory name: \"%s\"\n", transactionDirectoryName.String());
                throw Exception(B_TRANSACTION_BAD_REQUEST);
        }

        // open the directory
        RelativePath directoryPath(kAdminDirectoryName,
                transactionDirectoryName);
        BDirectory directory;
        status_t error = _OpenPackagesSubDirectory(directoryPath, false, directory);
        if (error == B_OK) {
                error = directory.GetNodeRef(&fTransactionDirectoryRef);
                if (error != B_OK) {
                        ERROR("Failed to get transaction directory node ref: %s\n",
                                strerror(error));
                }
        } else
                ERROR("Failed to open transaction directory: %s\n", strerror(error));

        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(fVolume->PackagesDirectoryRef(),
                                        directoryPath.ToString()),
                                directoryPath.ToString()))
                        .SetSystemError(error);
        }

        // read the packages
        for (int32 i = 0; i < packagesToActivateCount; i++) {
                BString packageName = packagesToActivate.StringAt(i);
                // make sure it doesn't clash with an already existing package,
                // except in first boot mode where it should always clash.
                Package* package = fVolumeState->FindPackage(packageName);
                if (fFirstBootProcessing) {
                        if (package == NULL) {
                                throw Exception(B_TRANSACTION_NO_SUCH_PACKAGE)
                                        .SetPackageName(packageName);
                        }
                        if (!fPackagesToActivate.AddItem(package))
                                throw Exception(B_TRANSACTION_NO_MEMORY);
                        continue;
                } else {
                        if (package != NULL) {
                                if (fPackagesAlreadyAdded.find(package)
                                                != fPackagesAlreadyAdded.end()) {
                                        if (!fPackagesToActivate.AddItem(package))
                                                throw Exception(B_TRANSACTION_NO_MEMORY);
                                        continue;
                                }

                                if (fPackagesToDeactivate.find(package)
                                                == fPackagesToDeactivate.end()) {
                                        throw Exception(B_TRANSACTION_PACKAGE_ALREADY_EXISTS)
                                                .SetPackageName(packageName);
                                }
                        }
                }

                // read the package
                error = fPackageFileManager->CreatePackage(
                        NotOwningEntryRef(fTransactionDirectoryRef, packageName),
                        package);
                if (error != B_OK) {
                        if (error == B_NO_MEMORY)
                                throw Exception(B_TRANSACTION_NO_MEMORY);
                        throw Exception(B_TRANSACTION_FAILED_TO_READ_PACKAGE_FILE)
                                .SetPackageName(packageName)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(
                                                NotOwningEntryRef(fTransactionDirectoryRef,
                                                        packageName)),
                                        packageName))
                                .SetSystemError(error);
                }

                if (!fPackagesToActivate.AddItem(package)) {
                        delete package;
                        throw Exception(B_TRANSACTION_NO_MEMORY);
                }
        }
}


void
CommitTransactionHandler::_ApplyChanges()
{
        if (!fFirstBootProcessing)
        {
                // create an old state directory
                _CreateOldStateDirectory();

                // move packages to deactivate to old state directory
                _RemovePackagesToDeactivate();

                // move packages to activate to packages directory
                _AddPackagesToActivate();

                // run pre-uninstall scripts, before their packages vanish.
                _RunPreUninstallScripts();

                // activate/deactivate packages and create users, groups, settings files.
                _ChangePackageActivation(fAddedPackages, fRemovedPackages);
        } else // FirstBootProcessing, skip several steps and just do package setup.
                _PrepareFirstBootPackages();

        // run post-install scripts now that the new packages are visible in the
        // package file system.
        if (fVolumeStateIsActive || fFirstBootProcessing) {
                _RunPostInstallScripts();
        } else {
                // Do post-install scripts later after a reboot, for Haiku OS packages.
                _QueuePostInstallScripts();
        }

        // removed packages have been deleted, new packages shall not be deleted
        fAddedPackages.clear();
        fRemovedPackages.clear();
        fPackagesToActivate.MakeEmpty(false);
        fPackagesToDeactivate.clear();
}


void
CommitTransactionHandler::_CreateOldStateDirectory()
{
        time_t stateTime = 0;
        {
                // use the modification time of the old activations file, if possible
                BFile oldActivationFile;
                BEntry oldActivationEntry;
                if (_OpenPackagesFile(RelativePath(kAdminDirectoryName), kActivationFileName,
                                B_READ_ONLY, oldActivationFile, &oldActivationEntry) != B_OK
                                        || oldActivationEntry.GetModificationTime(&stateTime) != B_OK) {
                        stateTime = time(NULL);
                }
        }

        // construct a nice name from the date and time
        struct tm now;
        BString baseName;
        if (localtime_r(&stateTime, &now) != NULL) {
                baseName.SetToFormat("state_%d-%02d-%02d_%02d:%02d:%02d",
                        1900 + now.tm_year, now.tm_mon + 1, now.tm_mday, now.tm_hour,
                        now.tm_min, now.tm_sec);
        } else
                baseName = "state";

        if (baseName.IsEmpty())
                throw Exception(B_TRANSACTION_NO_MEMORY);

        // make sure the directory doesn't exist yet
        BDirectory adminDirectory;
        status_t error = _OpenPackagesSubDirectory(
                RelativePath(kAdminDirectoryName), true, adminDirectory);
        if (error != B_OK) {
                ERROR("Failed to open administrative directory: %s\n", strerror(error));
                throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(fVolume->PackagesDirectoryRef(),
                                        kAdminDirectoryName),
                                kAdminDirectoryName))
                        .SetSystemError(error);
        }

        int uniqueId = 1;
        BString directoryName = baseName;
        while (BEntry(&adminDirectory, directoryName).Exists()) {
                directoryName.SetToFormat("%s-%d", baseName.String(), uniqueId++);
                if (directoryName.IsEmpty())
                        throw Exception(B_TRANSACTION_NO_MEMORY);
        }

        // create the directory
        FSTransaction::CreateOperation createOldStateDirectoryOperation(
                &fFSTransaction, FSUtils::Entry(adminDirectory, directoryName));

        error = adminDirectory.CreateDirectory(directoryName,
                &fOldStateDirectory);
        if (error == B_OK) {
                createOldStateDirectoryOperation.Finished();

                fOldStateDirectoryName = directoryName;

                error = fOldStateDirectory.GetNodeRef(&fOldStateDirectoryRef);
                if (error != B_OK)
                        ERROR("Failed get old state directory ref: %s\n", strerror(error));
        } else
                ERROR("Failed to create old state directory: %s\n", strerror(error));

        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_CREATE_DIRECTORY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(adminDirectory, directoryName),
                                directoryName))
                        .SetSystemError(error);
        }

        // write the old activation file
        BEntry activationFile;
        _WriteActivationFile(RelativePath(kAdminDirectoryName, directoryName),
                kActivationFileName, PackageSet(), PackageSet(), activationFile);

        fResult.SetOldStateDirectory(fOldStateDirectoryName);
}


void
CommitTransactionHandler::_RemovePackagesToDeactivate()
{
        if (fPackagesToDeactivate.empty())
                return;

        for (PackageSet::const_iterator it = fPackagesToDeactivate.begin();
                it != fPackagesToDeactivate.end(); ++it) {
                Package* package = *it;

                // When deactivating (or updating) a system package, don't do that live.
                if (_IsSystemPackage(package))
                        fVolumeStateIsActive = false;

                if (fPackagesAlreadyRemoved.find(package)
                                != fPackagesAlreadyRemoved.end()) {
                        fRemovedPackages.insert(package);
                        continue;
                }

                // get a BEntry for the package
                NotOwningEntryRef entryRef(package->EntryRef());

                BEntry entry;
                status_t error = entry.SetTo(&entryRef);
                if (error != B_OK) {
                        ERROR("Failed to get package entry for %s: %s\n",
                                package->FileName().String(), strerror(error));
                        throw Exception(B_TRANSACTION_FAILED_TO_GET_ENTRY_PATH)
                                .SetPath1(package->FileName())
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }

                // move entry
                fRemovedPackages.insert(package);

                error = entry.MoveTo(&fOldStateDirectory);
                if (error != B_OK) {
                        fRemovedPackages.erase(package);
                        ERROR("Failed to move old package %s from packages directory: %s\n",
                                package->FileName().String(), strerror(error));
                        throw Exception(B_TRANSACTION_FAILED_TO_MOVE_FILE)
                                .SetPath1(
                                        _GetPath(FSUtils::Entry(entryRef), package->FileName()))
                                .SetPath2(_GetPath(
                                        FSUtils::Entry(fOldStateDirectory),
                                        fOldStateDirectoryName))
                                .SetSystemError(error);
                }

                fPackageFileManager->PackageFileMoved(package->File(),
                        fOldStateDirectoryRef);
                package->File()->IncrementEntryRemovedIgnoreLevel();
        }
}


void
CommitTransactionHandler::_AddPackagesToActivate()
{
        if (fPackagesToActivate.IsEmpty())
                return;

        // open packages directory
        BDirectory packagesDirectory;
        status_t error
                = packagesDirectory.SetTo(&fVolume->PackagesDirectoryRef());
        if (error != B_OK) {
                ERROR("Failed to open packages directory: %s\n", strerror(error));
                throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                        .SetPath1("<packages>")
                        .SetSystemError(error);
        }

        int32 count = fPackagesToActivate.CountItems();
        for (int32 i = 0; i < count; i++) {
                Package* package = fPackagesToActivate.ItemAt(i);
                if (fPackagesAlreadyAdded.find(package)
                                != fPackagesAlreadyAdded.end()) {
                        fAddedPackages.insert(package);
                        _PreparePackageToActivate(package);
                        continue;
                }

                // get a BEntry for the package
                NotOwningEntryRef entryRef(fTransactionDirectoryRef,
                        package->FileName());
                BEntry entry;
                error = entry.SetTo(&entryRef);
                if (error != B_OK) {
                        ERROR("Failed to get package entry for %s: %s\n",
                                package->FileName().String(), strerror(error));
                        throw Exception(B_TRANSACTION_FAILED_TO_GET_ENTRY_PATH)
                                .SetPath1(package->FileName())
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }

                // move entry
                fAddedPackages.insert(package);

                error = entry.MoveTo(&packagesDirectory);
                if (error == B_FILE_EXISTS) {
                        error = _AssertEntriesAreEqual(entry, &packagesDirectory);
                        if (error == B_OK) {
                                // Packages are identical, no need to move.
                                // If the entry is not removed however, it will prevent
                                // the transaction directory from being removed later.
                                // We ignore failure to Remove() here, though.
                                entry.Remove();
                        } else if (error != B_FILE_EXISTS) {
                                ERROR("Failed to compare new package %s to existing file in "
                                        "packages directory: %s\n", package->FileName().String(),
                                        strerror(error));
                                // Restore original error to avoid confusion
                                error = B_FILE_EXISTS;
                        }
                }
                if (error != B_OK) {
                        fAddedPackages.erase(package);
                        ERROR("Failed to move new package %s to packages directory: %s\n",
                                package->FileName().String(), strerror(error));
                        throw Exception(B_TRANSACTION_FAILED_TO_MOVE_FILE)
                                .SetPath1(
                                        _GetPath(FSUtils::Entry(entryRef), package->FileName()))
                                .SetPath2(_GetPath(
                                        FSUtils::Entry(packagesDirectory),
                                        "packages"))
                                .SetSystemError(error);
                }

                fPackageFileManager->PackageFileMoved(package->File(),
                        fVolume->PackagesDirectoryRef());
                package->File()->IncrementEntryCreatedIgnoreLevel();

                // also add the package to the volume
                fVolumeState->AddPackage(package);

                _PreparePackageToActivate(package);
        }
}


void
CommitTransactionHandler::_PrepareFirstBootPackages()
{
        int32 count = fPackagesToActivate.CountItems();

        BDirectory transactionDir(&fTransactionDirectoryRef);
        BEntry transactionEntry;
        BPath transactionPath;
        if (transactionDir.InitCheck() == B_OK &&
                        transactionDir.GetEntry(&transactionEntry) == B_OK &&
                        transactionEntry.GetPath(&transactionPath) == B_OK) {
                INFORM("Starting First Boot Processing for %d packages in %s.\n",
                        (int) count, transactionPath.Path());
        }

        for (int32 i = 0; i < count; i++) {
                Package* package = fPackagesToActivate.ItemAt(i);
                fAddedPackages.insert(package);
                INFORM("Doing first boot processing #%d for package %s.\n",
                        (int) i, package->FileName().String());
                _PreparePackageToActivate(package);
        }
}


void
CommitTransactionHandler::_PreparePackageToActivate(Package* package)
{
        fCurrentPackage = package;

        // add groups
        const BStringList& groups = package->Info().Groups();
        int32 count = groups.CountStrings();
        for (int32 i = 0; i < count; i++)
                _AddGroup(package, groups.StringAt(i));

        // add users
        const BObjectList<BUser, true>& users = package->Info().Users();
        for (int32 i = 0; const BUser* user = users.ItemAt(i); i++)
                _AddUser(package, *user);

        // handle global writable files
        _AddGlobalWritableFiles(package);

        fCurrentPackage = NULL;
}


void
CommitTransactionHandler::_AddGroup(Package* package, const BString& groupName)
{
        // Check whether the group already exists.
        char buffer[256];
        struct group groupBuffer;
        struct group* groupFound;
        int error = getgrnam_r(groupName, &groupBuffer, buffer, sizeof(buffer),
                &groupFound);
        if ((error == 0 && groupFound != NULL) || error == ERANGE)
                return;

        // add it
        fAddedGroups.insert(groupName.String());

        std::string commandLine("groupadd ");
        commandLine += FSUtils::ShellEscapeString(groupName).String();

        if (system(commandLine.c_str()) != 0) {
                fAddedGroups.erase(groupName.String());
                ERROR("Failed to add group \"%s\".\n", groupName.String());
                throw Exception(B_TRANSACTION_FAILED_TO_ADD_GROUP)
                        .SetPackageName(package->FileName())
                        .SetString1(groupName);
        }
}


void
CommitTransactionHandler::_AddUser(Package* package, const BUser& user)
{
        // Check whether the user already exists.
        char buffer[256];
        struct passwd passwdBuffer;
        struct passwd* passwdFound;
        int error = getpwnam_r(user.Name(), &passwdBuffer, buffer,
                sizeof(buffer), &passwdFound);
        if ((error == 0 && passwdFound != NULL) || error == ERANGE)
                return;

        // add it
        fAddedUsers.insert(user.Name().String());

        std::string commandLine("useradd ");

        if (!user.RealName().IsEmpty()) {
                commandLine += std::string("-n ")
                        + FSUtils::ShellEscapeString(user.RealName()).String() + " ";
        }

        if (!user.Home().IsEmpty()) {
                commandLine += std::string("-d ")
                        + FSUtils::ShellEscapeString(user.Home()).String() + " ";
        }

        if (!user.Shell().IsEmpty()) {
                commandLine += std::string("-s ")
                        + FSUtils::ShellEscapeString(user.Shell()).String() + " ";
        }

        if (!user.Groups().IsEmpty()) {
                commandLine += std::string("-g ")
                        + FSUtils::ShellEscapeString(user.Groups().First()).String()
                        + " ";
        }

        commandLine += FSUtils::ShellEscapeString(user.Name()).String();

        if (system(commandLine.c_str()) != 0) {
                fAddedUsers.erase(user.Name().String());
                ERROR("Failed to add user \"%s\".\n", user.Name().String());
                throw Exception(B_TRANSACTION_FAILED_TO_ADD_USER)
                        .SetPackageName(package->FileName())
                        .SetString1(user.Name());

        }

        // add the supplementary groups
        int32 groupCount = user.Groups().CountStrings();
        for (int32 i = 1; i < groupCount; i++) {
                commandLine = std::string("groupmod -A ")
                        + FSUtils::ShellEscapeString(user.Name()).String()
                        + " "
                        + FSUtils::ShellEscapeString(user.Groups().StringAt(i))
                                .String();
                if (system(commandLine.c_str()) != 0) {
                        fAddedUsers.erase(user.Name().String());
                        ERROR("Failed to add user \"%s\" to group \"%s\".\n",
                                user.Name().String(), user.Groups().StringAt(i).String());
                        throw Exception(B_TRANSACTION_FAILED_TO_ADD_USER_TO_GROUP)
                                .SetPackageName(package->FileName())
                                .SetString1(user.Name())
                                .SetString2(user.Groups().StringAt(i));
                }
        }
}


void
CommitTransactionHandler::_AddGlobalWritableFiles(Package* package)
{
        // get the list of included files
        const BObjectList<BGlobalWritableFileInfo, true>& files
                = package->Info().GlobalWritableFileInfos();
        BStringList contentPaths;
        for (int32 i = 0; const BGlobalWritableFileInfo* file = files.ItemAt(i);
                i++) {
                if (file->IsIncluded() && !contentPaths.Add(file->Path()))
                        throw std::bad_alloc();
        }

        if (contentPaths.IsEmpty())
                return;

        // Open the root directory of the installation location where we will
        // extract the files -- that's the volume's root directory.
        BDirectory rootDirectory;
        status_t error = rootDirectory.SetTo(&fVolume->RootDirectoryRef());
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(fVolume->RootDirectoryRef()),
                                "<packagefs root>"))
                        .SetSystemError(error);
        }

        // Open writable-files directory in the administrative directory.
        if (fWritableFilesDirectory.InitCheck() != B_OK) {
                RelativePath directoryPath(kAdminDirectoryName,
                        kWritableFilesDirectoryName);
                error = _OpenPackagesSubDirectory(directoryPath, true,
                        fWritableFilesDirectory);

                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(fVolume->PackagesDirectoryRef(),
                                                directoryPath.ToString()),
                                        directoryPath.ToString()))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }
        }

        // extract files into a subdir of the writable-files directory
        BDirectory extractedFilesDirectory;
        _ExtractPackageContent(package, contentPaths,
                fWritableFilesDirectory, extractedFilesDirectory);

        for (int32 i = 0; const BGlobalWritableFileInfo* file = files.ItemAt(i);
                i++) {
                if (file->IsIncluded()) {
                        _AddGlobalWritableFile(package, *file, rootDirectory,
                                extractedFilesDirectory);
                }
        }
}


void
CommitTransactionHandler::_AddGlobalWritableFile(Package* package,
        const BGlobalWritableFileInfo& file, const BDirectory& rootDirectory,
        const BDirectory& extractedFilesDirectory)
{
        // open parent directory of the source entry
        const char* lastSlash = strrchr(file.Path(), '/');
        const BDirectory* sourceDirectory;
        BDirectory stackSourceDirectory;
        if (lastSlash != NULL) {
                sourceDirectory = &stackSourceDirectory;
                BString sourceParentPath(file.Path(),
                        lastSlash - file.Path().String());
                if (sourceParentPath.Length() == 0)
                        throw std::bad_alloc();

                status_t error = stackSourceDirectory.SetTo(
                        &extractedFilesDirectory, sourceParentPath);
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(extractedFilesDirectory, sourceParentPath),
                                        sourceParentPath))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }
        } else {
                sourceDirectory = &extractedFilesDirectory;
        }

        // open parent directory of the target entry -- create, if necessary
        BString targetPath(file.Path());
        FSUtils::Path relativeSourcePath(file.Path());
        lastSlash = strrchr(targetPath, '/');
        if (lastSlash != NULL) {
                BString targetParentPath(targetPath,
                        lastSlash - targetPath.String());
                if (targetParentPath.Length() == 0)
                        throw std::bad_alloc();

                BDirectory targetDirectory;
                status_t error = FSUtils::OpenSubDirectory(rootDirectory,
                        RelativePath(targetParentPath), true, targetDirectory);
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(rootDirectory, targetParentPath),
                                        targetParentPath))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }
                _AddGlobalWritableFileRecurse(package, *sourceDirectory,
                        relativeSourcePath, targetDirectory, lastSlash + 1,
                        file.UpdateType());
        } else {
                _AddGlobalWritableFileRecurse(package, *sourceDirectory,
                        relativeSourcePath, rootDirectory, targetPath,
                        file.UpdateType());
        }
}


void
CommitTransactionHandler::_AddGlobalWritableFileRecurse(Package* package,
        const BDirectory& sourceDirectory, FSUtils::Path& relativeSourcePath,
        const BDirectory& targetDirectory, const char* targetName,
        BWritableFileUpdateType updateType)
{
        // * If the file doesn't exist, just copy the extracted one.
        // * If the file does exist, compare with the previous original version:
        //   * If unchanged, just overwrite it.
        //   * If changed, leave it to the user for now. When we support merging
        //     first back the file up, then try the merge.

        // Check whether the target location exists and what type the entry at
        // both locations are.
        struct stat targetStat;
        if (targetDirectory.GetStatFor(targetName, &targetStat) != B_OK) {
                // target doesn't exist -- just copy
                PRINT("Volume::CommitTransactionHandler::_AddGlobalWritableFile(): "
                        "couldn't get stat for writable file \"%s\", copying...\n",
                        targetName);
                FSTransaction::CreateOperation copyOperation(&fFSTransaction,
                        FSUtils::Entry(targetDirectory, targetName));
                status_t error = BCopyEngine(BCopyEngine::COPY_RECURSIVELY)
                        .CopyEntry(
                                FSUtils::Entry(sourceDirectory, relativeSourcePath.Leaf()),
                                FSUtils::Entry(targetDirectory, targetName));
                if (error != B_OK) {
                        if (targetDirectory.GetStatFor(targetName, &targetStat) == B_OK)
                                copyOperation.Finished();

                        throw Exception(B_TRANSACTION_FAILED_TO_COPY_FILE)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(sourceDirectory,
                                                relativeSourcePath.Leaf()),
                                        relativeSourcePath))
                                .SetPath2(_GetPath(
                                        FSUtils::Entry(targetDirectory, targetName),
                                        targetName))
                                .SetSystemError(error);
                }
                copyOperation.Finished();
                return;
        }

        struct stat sourceStat;
        status_t error = sourceDirectory.GetStatFor(relativeSourcePath.Leaf(),
                &sourceStat);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_ACCESS_ENTRY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(sourceDirectory,
                                        relativeSourcePath.Leaf()),
                                relativeSourcePath))
                        .SetSystemError(error);
        }

        if ((sourceStat.st_mode & S_IFMT) != (targetStat.st_mode & S_IFMT)
                || (!S_ISDIR(sourceStat.st_mode) && !S_ISREG(sourceStat.st_mode)
                        && !S_ISLNK(sourceStat.st_mode))) {
                // Source and target entry types don't match or this is an entry
                // we cannot handle. The user must handle this manually.
                PRINT("Volume::CommitTransactionHandler::_AddGlobalWritableFile(): "
                        "writable file \"%s\" exists, but type doesn't match previous "
                        "type\n", targetName);
                _AddIssue(TransactionIssueBuilder(
                                BTransactionIssue::B_WRITABLE_FILE_TYPE_MISMATCH)
                        .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                        .SetPath2(FSUtils::Entry(sourceDirectory,
                                relativeSourcePath.Leaf())));
                return;
        }

        if (S_ISDIR(sourceStat.st_mode)) {
                // entry is a directory -- recurse
                BDirectory sourceSubDirectory;
                error = sourceSubDirectory.SetTo(&sourceDirectory,
                        relativeSourcePath.Leaf());
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(sourceDirectory,
                                                relativeSourcePath.Leaf()),
                                        relativeSourcePath))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }

                BDirectory targetSubDirectory;
                error = targetSubDirectory.SetTo(&targetDirectory, targetName);
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(targetDirectory, targetName),
                                        targetName))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }

                entry_ref entry;
                while (sourceSubDirectory.GetNextRef(&entry) == B_OK) {
                        relativeSourcePath.AppendComponent(entry.name);
                        _AddGlobalWritableFileRecurse(package, sourceSubDirectory,
                                relativeSourcePath, targetSubDirectory, entry.name,
                                updateType);
                        relativeSourcePath.RemoveLastComponent();
                }

                PRINT("Volume::CommitTransactionHandler::_AddGlobalWritableFile(): "
                        "writable directory, recursion done\n");
                return;
        }

        // get the package the target file originated from
        BString originalPackage;
        if (BNode(&targetDirectory, targetName).ReadAttrString(
                        kPackageFileAttribute, &originalPackage) != B_OK) {
                // Can't determine the original package. The user must handle this
                // manually.
                PRINT("Volume::CommitTransactionHandler::_AddGlobalWritableFile(): "
                        "failed to get SYS:PACKAGE attribute for \"%s\", can't tell if "
                        "file needs to be updated\n",
                        targetName);
                if (updateType != B_WRITABLE_FILE_UPDATE_TYPE_KEEP_OLD) {
                        _AddIssue(TransactionIssueBuilder(
                                        BTransactionIssue::B_WRITABLE_FILE_NO_PACKAGE_ATTRIBUTE)
                                .SetPath1(FSUtils::Entry(targetDirectory, targetName)));
                }
                return;
        }

        // If that's our package, we're happy.
        if (originalPackage == package->RevisionedNameThrows()) {
                PRINT("Volume::CommitTransactionHandler::_AddGlobalWritableFile(): "
                        "file \"%s\" tagged with same package version we're activating\n",
                        targetName);
                return;
        }

        // Check, whether the writable-files directory for the original package
        // exists.
        BString originalRelativeSourcePath = BString().SetToFormat("%s/%s",
                originalPackage.String(), relativeSourcePath.ToCString());
        if (originalRelativeSourcePath.IsEmpty())
                throw std::bad_alloc();

        struct stat originalPackageStat;
        error = fWritableFilesDirectory.GetStatFor(originalRelativeSourcePath,
                &originalPackageStat);
        if (error != B_OK
                || (sourceStat.st_mode & S_IFMT)
                        != (originalPackageStat.st_mode & S_IFMT)) {
                // Original entry doesn't exist (either we don't have the data from
                // the original package or the entry really didn't exist) or its
                // type differs from the expected one. The user must handle this
                // manually.
                PRINT("Volume::CommitTransactionHandler::_AddGlobalWritableFile(): "
                        "original \"%s\" doesn't exist or has other type\n",
                        _GetPath(FSUtils::Entry(fWritableFilesDirectory,
                                        originalRelativeSourcePath),
                                originalRelativeSourcePath).String());
                if (error != B_OK) {
                        _AddIssue(TransactionIssueBuilder(
                                        BTransactionIssue
                                                ::B_WRITABLE_FILE_OLD_ORIGINAL_FILE_MISSING)
                                .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                                .SetPath2(FSUtils::Entry(fWritableFilesDirectory,
                                        originalRelativeSourcePath)));
                } else {
                        _AddIssue(TransactionIssueBuilder(
                                        BTransactionIssue
                                                ::B_WRITABLE_FILE_OLD_ORIGINAL_FILE_TYPE_MISMATCH)
                                .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                                .SetPath2(FSUtils::Entry(fWritableFilesDirectory,
                                        originalRelativeSourcePath)));
                }
                return;
        }

        if (S_ISREG(sourceStat.st_mode)) {
                // compare file content
                bool equal;
                error = FSUtils::CompareFileContent(
                        FSUtils::Entry(fWritableFilesDirectory,
                                originalRelativeSourcePath),
                        FSUtils::Entry(targetDirectory, targetName),
                        equal);
                // TODO: Merge support!
                if (error != B_OK || !equal) {
                        // The comparison failed or the files differ. The user must
                        // handle this manually.
                        PRINT("Volume::CommitTransactionHandler::"
                                "_AddGlobalWritableFile(): "
                                "file comparison \"%s\" failed (%s) or files aren't equal\n",
                                targetName, strerror(error));
                        if (updateType != B_WRITABLE_FILE_UPDATE_TYPE_KEEP_OLD) {
                                if (error != B_OK) {
                                        _AddIssue(TransactionIssueBuilder(
                                                        BTransactionIssue
                                                                ::B_WRITABLE_FILE_COMPARISON_FAILED)
                                                .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                                                .SetPath2(FSUtils::Entry(fWritableFilesDirectory,
                                                        originalRelativeSourcePath))
                                                .SetSystemError(error));
                                } else {
                                        _AddIssue(TransactionIssueBuilder(
                                                        BTransactionIssue
                                                                ::B_WRITABLE_FILE_NOT_EQUAL)
                                                .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                                                .SetPath2(FSUtils::Entry(fWritableFilesDirectory,
                                                        originalRelativeSourcePath)));
                                }
                        }
                        return;
                }
        } else {
                // compare symlinks
                bool equal;
                error = FSUtils::CompareSymLinks(
                        FSUtils::Entry(fWritableFilesDirectory,
                                originalRelativeSourcePath),
                        FSUtils::Entry(targetDirectory, targetName),
                        equal);
                if (error != B_OK || !equal) {
                        // The comparison failed or the symlinks differ. The user must
                        // handle this manually.
                        PRINT("Volume::CommitTransactionHandler::"
                                "_AddGlobalWritableFile(): "
                                "symlink comparison \"%s\" failed (%s) or symlinks aren't "
                                "equal\n", targetName, strerror(error));
                        if (updateType != B_WRITABLE_FILE_UPDATE_TYPE_KEEP_OLD) {
                                if (error != B_OK) {
                                        _AddIssue(TransactionIssueBuilder(
                                                        BTransactionIssue
                                                                ::B_WRITABLE_SYMLINK_COMPARISON_FAILED)
                                                .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                                                .SetPath2(FSUtils::Entry(fWritableFilesDirectory,
                                                        originalRelativeSourcePath))
                                                .SetSystemError(error));
                                } else {
                                        _AddIssue(TransactionIssueBuilder(
                                                        BTransactionIssue
                                                                ::B_WRITABLE_SYMLINK_NOT_EQUAL)
                                                .SetPath1(FSUtils::Entry(targetDirectory, targetName))
                                                .SetPath2(FSUtils::Entry(fWritableFilesDirectory,
                                                        originalRelativeSourcePath)));
                                }
                        }
                        return;
                }
        }

        // Replace the existing file/symlink. We do that in two steps: First
        // copy the new file to a neighoring location, then move-replace the
        // old file.
        BString tempTargetName;
        tempTargetName.SetToFormat("%s.%s", targetName,
                package->RevisionedNameThrows().String());
        if (tempTargetName.IsEmpty())
                throw std::bad_alloc();

        // copy
        FSTransaction::CreateOperation copyOperation(&fFSTransaction,
                FSUtils::Entry(targetDirectory, tempTargetName));

        error = BCopyEngine(BCopyEngine::UNLINK_DESTINATION).CopyEntry(
                FSUtils::Entry(sourceDirectory, relativeSourcePath.Leaf()),
                FSUtils::Entry(targetDirectory, tempTargetName));
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_COPY_FILE)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(sourceDirectory,
                                        relativeSourcePath.Leaf()),
                                relativeSourcePath))
                        .SetPath2(_GetPath(
                                FSUtils::Entry(targetDirectory, tempTargetName),
                                tempTargetName))
                        .SetSystemError(error);
        }

        copyOperation.Finished();

        // rename
        FSTransaction::RemoveOperation renameOperation(&fFSTransaction,
                FSUtils::Entry(targetDirectory, targetName),
                FSUtils::Entry(fWritableFilesDirectory,
                        originalRelativeSourcePath));

        BEntry targetEntry;
        error = targetEntry.SetTo(&targetDirectory, tempTargetName);
        if (error == B_OK)
                error = targetEntry.Rename(targetName, true);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_MOVE_FILE)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(targetDirectory, tempTargetName),
                                tempTargetName))
                        .SetPath2(targetName)
                        .SetSystemError(error);
        }

        renameOperation.Finished();
        copyOperation.Unregister();
}


void
CommitTransactionHandler::_RevertAddPackagesToActivate()
{
        if (fAddedPackages.empty() || fFirstBootProcessing)
                return;

        // open transaction directory
        BDirectory transactionDirectory;
        status_t error = transactionDirectory.SetTo(&fTransactionDirectoryRef);
        if (error != B_OK) {
                ERROR("failed to open transaction directory: %s\n",
                        strerror(error));
        }

        for (PackageSet::iterator it = fAddedPackages.begin();
                it != fAddedPackages.end(); ++it) {
                // remove package from the volume
                Package* package = *it;

                if (fPackagesAlreadyAdded.find(package)
                                != fPackagesAlreadyAdded.end()) {
                        continue;
                }

                fVolumeState->RemovePackage(package);

                if (transactionDirectory.InitCheck() != B_OK)
                        continue;

                // get BEntry for the package
                NotOwningEntryRef entryRef(package->EntryRef());
                BEntry entry;
                error = entry.SetTo(&entryRef);
                if (error != B_OK) {
                        ERROR("failed to get entry for package \"%s\": %s\n",
                                package->FileName().String(), strerror(error));
                        continue;
                }

                // move entry
                error = entry.MoveTo(&transactionDirectory);
                if (error != B_OK) {
                        ERROR("failed to move new package \"%s\" back to transaction "
                                "directory: %s\n", package->FileName().String(),
                                strerror(error));
                        continue;
                }

                fPackageFileManager->PackageFileMoved(package->File(),
                        fTransactionDirectoryRef);
                package->File()->IncrementEntryRemovedIgnoreLevel();
        }
}


void
CommitTransactionHandler::_RevertRemovePackagesToDeactivate()
{
        if (fRemovedPackages.empty() || fFirstBootProcessing)
                return;

        // open packages directory
        BDirectory packagesDirectory;
        status_t error
                = packagesDirectory.SetTo(&fVolume->PackagesDirectoryRef());
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                        .SetPath1("<packages>")
                        .SetSystemError(error);
        }

        for (PackageSet::iterator it = fRemovedPackages.begin();
                it != fRemovedPackages.end(); ++it) {
                Package* package = *it;
                if (fPackagesAlreadyRemoved.find(package)
                                != fPackagesAlreadyRemoved.end()) {
                        continue;
                }

                // get a BEntry for the package
                BEntry entry;
                status_t error = entry.SetTo(&fOldStateDirectory,
                        package->FileName());
                if (error != B_OK) {
                        ERROR("failed to get entry for package \"%s\": %s\n",
                                package->FileName().String(), strerror(error));
                        continue;
                }

                // move entry
                error = entry.MoveTo(&packagesDirectory);
                if (error != B_OK) {
                        ERROR("failed to move old package \"%s\" back to packages "
                                "directory: %s\n", package->FileName().String(),
                                strerror(error));
                        continue;
                }

                fPackageFileManager->PackageFileMoved(package->File(),
                        fVolume->PackagesDirectoryRef());
                package->File()->IncrementEntryCreatedIgnoreLevel();
        }
}


void
CommitTransactionHandler::_RevertUserGroupChanges()
{
        // delete users
        for (StringSet::const_iterator it = fAddedUsers.begin();
                it != fAddedUsers.end(); ++it) {
                std::string commandLine("userdel ");
                commandLine += FSUtils::ShellEscapeString(it->c_str()).String();
                if (system(commandLine.c_str()) != 0)
                        ERROR("failed to remove user \"%s\"\n", it->c_str());
        }

        // delete groups
        for (StringSet::const_iterator it = fAddedGroups.begin();
                it != fAddedGroups.end(); ++it) {
                std::string commandLine("groupdel ");
                commandLine += FSUtils::ShellEscapeString(it->c_str()).String();
                if (system(commandLine.c_str()) != 0)
                        ERROR("failed to remove group \"%s\"\n", it->c_str());
        }
}


void
CommitTransactionHandler::_RunPostInstallScripts()
{
        for (PackageSet::iterator it = fAddedPackages.begin();
                it != fAddedPackages.end(); ++it) {
                Package* package = *it;
                fCurrentPackage = package;
                const BStringList& scripts = package->Info().PostInstallScripts();
                int32 count = scripts.CountStrings();
                for (int32 i = 0; i < count; i++)
                        _RunPostOrPreScript(package, scripts.StringAt(i), true);
        }

        fCurrentPackage = NULL;
}


void
CommitTransactionHandler::_RunPreUninstallScripts()
{
        // Note this runs in the correct order, so dependents get uninstalled before
        // the packages they depend on.  No need for a reversed loop.
        for (PackageSet::iterator it = fPackagesToDeactivate.begin();
                it != fPackagesToDeactivate.end(); ++it) {
                Package* package = *it;
                fCurrentPackage = package;
                const BStringList& scripts = package->Info().PreUninstallScripts();
                int32 count = scripts.CountStrings();
                for (int32 i = 0; i < count; i++)
                        _RunPostOrPreScript(package, scripts.StringAt(i), false);
        }

        fCurrentPackage = NULL;
}


void
CommitTransactionHandler::_RunPostOrPreScript(Package* package,
        const BString& script, bool postNotPre)
{
        const char *postOrPreInstallWording = postNotPre
                ? "post-installation" : "pre-uninstall";
        BDirectory rootDir(&fVolume->RootDirectoryRef());
        BPath scriptPath(&rootDir, script);
        status_t error = scriptPath.InitCheck();
        if (error != B_OK) {
                ERROR("Volume::CommitTransactionHandler::_RunPostOrPreScript(): "
                        "failed get path of %s script \"%s\" of package "
                        "%s: %s\n",
                        postOrPreInstallWording, script.String(),
                        package->FileName().String(), strerror(error));
                _AddIssue(TransactionIssueBuilder(postNotPre
                                ? BTransactionIssue::B_POST_INSTALL_SCRIPT_NOT_FOUND
                                : BTransactionIssue::B_PRE_UNINSTALL_SCRIPT_NOT_FOUND)
                        .SetPath1(script)
                        .SetSystemError(error));
                return;
        }

        errno = 0;
        int result = system(scriptPath.Path());
        if (result != 0) {
                ERROR("Volume::CommitTransactionHandler::_RunPostOrPreScript(): "
                        "running %s script \"%s\" of package %s "
                        "failed: %d (errno: %s)\n",
                        postOrPreInstallWording, script.String(),
                        package->FileName().String(), result, strerror(errno));
                if (result < 0 || result == 127) { // bash shell returns 127 on failure.
                        _AddIssue(TransactionIssueBuilder(postNotPre
                                        ? BTransactionIssue::B_STARTING_POST_INSTALL_SCRIPT_FAILED
                                        : BTransactionIssue::B_STARTING_PRE_UNINSTALL_SCRIPT_FAILED)
                                .SetPath1(BString(scriptPath.Path()))
                                .SetSystemError(errno));
                } else { // positive is an exit code from the script itself.
                        _AddIssue(TransactionIssueBuilder(postNotPre
                                        ? BTransactionIssue::B_POST_INSTALL_SCRIPT_FAILED
                                        : BTransactionIssue::B_PRE_UNINSTALL_SCRIPT_FAILED)
                                .SetPath1(BString(scriptPath.Path()))
                                .SetExitCode(result));
                }
        }
}


void
CommitTransactionHandler::_QueuePostInstallScripts()
{
        BDirectory adminDirectory;
        status_t error = _OpenPackagesSubDirectory(
                RelativePath(kAdminDirectoryName), true, adminDirectory);
        if (error != B_OK) {
                ERROR("Failed to open administrative directory: %s\n", strerror(error));
                return;
        }

        BDirectory scriptsDirectory;
        error = scriptsDirectory.SetTo(&adminDirectory, kQueuedScriptsDirectoryName);
        if (error == B_ENTRY_NOT_FOUND)
                error = adminDirectory.CreateDirectory(kQueuedScriptsDirectoryName, &scriptsDirectory);
        if (error != B_OK) {
                ERROR("Failed to open queued scripts directory: %s\n", strerror(error));
                return;
        }

        BDirectory rootDir(&fVolume->RootDirectoryRef());
        for (PackageSet::iterator it = fAddedPackages.begin();
                it != fAddedPackages.end(); ++it) {
                Package* package = *it;
                const BStringList& scripts = package->Info().PostInstallScripts();
                for (int32 i = 0; i < scripts.CountStrings(); ++i) {
                        BPath scriptPath(&rootDir, scripts.StringAt(i));
                        status_t error = scriptPath.InitCheck();
                        if (error != B_OK) {
                                ERROR("Can't find script: %s\n", scripts.StringAt(i).String());
                                continue;
                        }

                        // symlink to the script
                        BSymLink scriptLink;
                        scriptsDirectory.CreateSymLink(scriptPath.Leaf(),
                                scriptPath.Path(), &scriptLink);
                        if (scriptLink.InitCheck() != B_OK) {
                                ERROR("Creating symlink failed: %s\n", strerror(scriptLink.InitCheck()));
                                continue;
                        }
                }
        }
}


void
CommitTransactionHandler::_ExtractPackageContent(Package* package,
        const BStringList& contentPaths, BDirectory& targetDirectory,
        BDirectory& _extractedFilesDirectory)
{
        // check whether the subdirectory already exists
        BString targetName(package->RevisionedNameThrows());

        BEntry targetEntry;
        status_t error = targetEntry.SetTo(&targetDirectory, targetName);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_ACCESS_ENTRY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(targetDirectory, targetName),
                                targetName))
                        .SetPackageName(package->FileName())
                        .SetSystemError(error);
        }
        if (targetEntry.Exists()) {
                // nothing to do -- the very same version of the package has already
                // been extracted
                error = _extractedFilesDirectory.SetTo(&targetDirectory,
                        targetName);
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(targetDirectory, targetName),
                                        targetName))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }
                return;
        }

        // create the subdirectory with a temporary name (remove, if it already
        // exists)
        BString temporaryTargetName = BString().SetToFormat("%s.tmp",
                targetName.String());
        if (temporaryTargetName.IsEmpty())
                throw std::bad_alloc();

        error = targetEntry.SetTo(&targetDirectory, temporaryTargetName);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_ACCESS_ENTRY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(targetDirectory, temporaryTargetName),
                                temporaryTargetName))
                        .SetPackageName(package->FileName())
                        .SetSystemError(error);
        }

        if (targetEntry.Exists()) {
                // remove pre-existing
                error = BRemoveEngine().RemoveEntry(FSUtils::Entry(targetEntry));
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_REMOVE_DIRECTORY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(targetDirectory, temporaryTargetName),
                                        temporaryTargetName))
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }
        }

        BDirectory& subDirectory = _extractedFilesDirectory;
        FSTransaction::CreateOperation createSubDirectoryOperation(
                &fFSTransaction,
                FSUtils::Entry(targetDirectory, temporaryTargetName));
        error = targetDirectory.CreateDirectory(temporaryTargetName,
                &subDirectory);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_CREATE_DIRECTORY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(targetDirectory, temporaryTargetName),
                                temporaryTargetName))
                        .SetPackageName(package->FileName())
                        .SetSystemError(error);
        }

        createSubDirectoryOperation.Finished();

        // extract
        NotOwningEntryRef packageRef(package->EntryRef());

        int32 contentPathCount = contentPaths.CountStrings();
        for (int32 i = 0; i < contentPathCount; i++) {
                const char* contentPath = contentPaths.StringAt(i);

                error = FSUtils::ExtractPackageContent(FSUtils::Entry(packageRef),
                        contentPath, FSUtils::Entry(subDirectory));
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_EXTRACT_PACKAGE_FILE)
                                .SetPath1(contentPath)
                                .SetPackageName(package->FileName())
                                .SetSystemError(error);
                }
        }

        // tag all entries with the package attribute
        _TagPackageEntriesRecursively(subDirectory, targetName, true);

        // rename the subdirectory
        error = targetEntry.Rename(targetName);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_MOVE_FILE)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(targetDirectory, temporaryTargetName),
                                temporaryTargetName))
                        .SetPath2(targetName)
                        .SetPackageName(package->FileName())
                        .SetSystemError(error);
        }

        // keep the directory, regardless of whether the transaction is rolled
        // back
        createSubDirectoryOperation.Unregister();
}


status_t
CommitTransactionHandler::_OpenPackagesSubDirectory(const RelativePath& path,
        bool create, BDirectory& _directory)
{
        // open the packages directory
        BDirectory directory;
        status_t error = directory.SetTo(&fVolume->PackagesDirectoryRef());
        if (error != B_OK) {
                ERROR("CommitTransactionHandler::_OpenPackagesSubDirectory(): failed "
                        "to open packages directory: %s\n", strerror(error));
                RETURN_ERROR(error);
        }

        return FSUtils::OpenSubDirectory(directory, path, create, _directory);
}


status_t
CommitTransactionHandler::_OpenPackagesFile(
        const RelativePath& subDirectoryPath, const char* fileName, uint32 openMode,
        BFile& _file, BEntry* _entry)
{
        BDirectory directory;
        if (!subDirectoryPath.IsEmpty()) {
                status_t error = _OpenPackagesSubDirectory(subDirectoryPath,
                        (openMode & B_CREATE_FILE) != 0, directory);
                if (error != B_OK) {
                        ERROR("CommitTransactionHandler::_OpenPackagesFile(): failed to "
                                "open packages subdirectory \"%s\": %s\n",
                                subDirectoryPath.ToString().String(), strerror(error));
                        RETURN_ERROR(error);
                }
        } else {
                status_t error = directory.SetTo(&fVolume->PackagesDirectoryRef());
                if (error != B_OK) {
                        ERROR("CommitTransactionHandler::_OpenPackagesFile(): failed to "
                                "open packages directory: %s\n", strerror(error));
                        RETURN_ERROR(error);
                }
        }

        BEntry stackEntry;
        BEntry& entry = _entry != NULL ? *_entry : stackEntry;
        status_t error = entry.SetTo(&directory, fileName);
        if (error != B_OK) {
                ERROR("CommitTransactionHandler::_OpenPackagesFile(): failed to get "
                        "entry for file: %s", strerror(error));
                RETURN_ERROR(error);
        }

        return _file.SetTo(&entry, openMode);
}


void
CommitTransactionHandler::_WriteActivationFile(
        const RelativePath& directoryPath, const char* fileName,
        const PackageSet& toActivate, const PackageSet& toDeactivate,
        BEntry& _entry)
{
        // create the content
        BString activationFileContent;
        _CreateActivationFileContent(toActivate, toDeactivate,
                activationFileContent);

        // write the file
        status_t error = _WriteTextFile(directoryPath, fileName,
                activationFileContent, _entry);
        if (error != B_OK) {
                BString filePath = directoryPath.ToString() << '/' << fileName;
                throw Exception(B_TRANSACTION_FAILED_TO_WRITE_ACTIVATION_FILE)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(fVolume->PackagesDirectoryRef(), filePath),
                                filePath))
                        .SetSystemError(error);
        }
}


void
CommitTransactionHandler::_CreateActivationFileContent(
        const PackageSet& toActivate, const PackageSet& toDeactivate,
        BString& _content)
{
        BString activationFileContent;
        for (PackageFileNameHashTable::Iterator it
                        = fVolumeState->ByFileNameIterator();
                Package* package = it.Next();) {
                if (package->IsActive()
                        && toDeactivate.find(package) == toDeactivate.end()) {
                        int32 length = activationFileContent.Length();
                        activationFileContent << package->FileName() << '\n';
                        if (activationFileContent.Length()
                                        < length + package->FileName().Length() + 1) {
                                throw Exception(B_TRANSACTION_NO_MEMORY);
                        }
                }
        }

        for (PackageSet::const_iterator it = toActivate.begin();
                it != toActivate.end(); ++it) {
                Package* package = *it;
                int32 length = activationFileContent.Length();
                activationFileContent << package->FileName() << '\n';
                if (activationFileContent.Length()
                                < length + package->FileName().Length() + 1) {
                        throw Exception(B_TRANSACTION_NO_MEMORY);
                }
        }

        _content = activationFileContent;
}


status_t
CommitTransactionHandler::_WriteTextFile(const RelativePath& directoryPath,
        const char* fileName, const BString& content, BEntry& _entry)
{
        BFile file;
        status_t error = _OpenPackagesFile(directoryPath,
                fileName, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE, file, &_entry);
        if (error != B_OK) {
                ERROR("CommitTransactionHandler::_WriteTextFile(): failed to create "
                        "file \"%s/%s\": %s\n", directoryPath.ToString().String(), fileName,
                        strerror(error));
                return error;
        }

        ssize_t bytesWritten = file.Write(content.String(),
                content.Length());
        if (bytesWritten < 0) {
                ERROR("CommitTransactionHandler::_WriteTextFile(): failed to write "
                        "file \"%s/%s\": %s\n", directoryPath.ToString().String(), fileName,
                        strerror(bytesWritten));
                return bytesWritten;
        }

        return B_OK;
}


void
CommitTransactionHandler::_ChangePackageActivation(
        const PackageSet& packagesToActivate,
        const PackageSet& packagesToDeactivate)
{
        INFORM("CommitTransactionHandler::_ChangePackageActivation(): activating "
                "%zu, deactivating %zu packages\n", packagesToActivate.size(),
                packagesToDeactivate.size());

        // write the temporary package activation file
        BEntry activationFileEntry;
        _WriteActivationFile(RelativePath(kAdminDirectoryName),
                kTemporaryActivationFileName, packagesToActivate, packagesToDeactivate,
                activationFileEntry);

        // notify packagefs
        if (fVolumeStateIsActive) {
                _ChangePackageActivationIOCtl(packagesToActivate, packagesToDeactivate);
        } else {
                // TODO: Notify packagefs that active packages have been moved or do
                // node monitoring in packagefs!
        }

        // rename the temporary activation file to the final file
        status_t error = activationFileEntry.Rename(kActivationFileName, true);
        if (error != B_OK) {
                throw Exception(B_TRANSACTION_FAILED_TO_MOVE_FILE)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(activationFileEntry),
                                activationFileEntry.Name()))
                        .SetPath2(kActivationFileName)
                        .SetSystemError(error);

// TODO: We should probably try to revert the activation changes, though that
// will fail, if this method has been called in response to node monitoring
// events. Alternatively moving the package activation file could be made part
// of the ioctl(), since packagefs should be able to undo package changes until
// the very end, unless running out of memory. In the end the situation would be
// bad anyway, though, since the activation file may refer to removed packages
// and things would be in an inconsistent state after rebooting.
        }

        // Update our state, i.e. remove deactivated packages and mark activated
        // packages accordingly.
        fVolumeState->ActivationChanged(packagesToActivate, packagesToDeactivate);
}


void
CommitTransactionHandler::_ChangePackageActivationIOCtl(
        const PackageSet& packagesToActivate,
        const PackageSet& packagesToDeactivate)
{
        // compute the size of the allocation we need for the activation change
        // request
        int32 itemCount = packagesToActivate.size() + packagesToDeactivate.size();
        size_t requestSize = sizeof(PackageFSActivationChangeRequest)
                + itemCount * sizeof(PackageFSActivationChangeItem);

        for (PackageSet::iterator it = packagesToActivate.begin();
                 it != packagesToActivate.end(); ++it) {
                requestSize += (*it)->FileName().Length() + 1;
        }

        for (PackageSet::iterator it = packagesToDeactivate.begin();
                 it != packagesToDeactivate.end(); ++it) {
                requestSize += (*it)->FileName().Length() + 1;
        }

        // allocate and prepare the request
        PackageFSActivationChangeRequest* request
                = (PackageFSActivationChangeRequest*)malloc(requestSize);
        if (request == NULL)
                throw Exception(B_TRANSACTION_NO_MEMORY);
        MemoryDeleter requestDeleter(request);

        request->itemCount = itemCount;

        PackageFSActivationChangeItem* item = &request->items[0];
        char* nameBuffer = (char*)(item + itemCount);

        for (PackageSet::iterator it = packagesToActivate.begin();
                it != packagesToActivate.end(); ++it, item++) {
                _FillInActivationChangeItem(item, PACKAGE_FS_ACTIVATE_PACKAGE, *it,
                        nameBuffer);
        }

        for (PackageSet::iterator it = packagesToDeactivate.begin();
                it != packagesToDeactivate.end(); ++it, item++) {
                _FillInActivationChangeItem(item, PACKAGE_FS_DEACTIVATE_PACKAGE, *it,
                        nameBuffer);
        }

        // issue the request
        FileDescriptorCloser fd(fVolume->OpenRootDirectory());
        if (!fd.IsSet()) {
                throw Exception(B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY)
                        .SetPath1(_GetPath(
                                FSUtils::Entry(fVolume->RootDirectoryRef()),
                                "<packagefs root>"))
                        .SetSystemError(fd.Get());
        }

        if (ioctl(fd.Get(), PACKAGE_FS_OPERATION_CHANGE_ACTIVATION, request,
                requestSize) != 0) {
// TODO: We need more error information and error handling!
                throw Exception(B_TRANSACTION_FAILED_TO_CHANGE_PACKAGE_ACTIVATION)
                        .SetSystemError(errno);
        }
}


void
CommitTransactionHandler::_FillInActivationChangeItem(
        PackageFSActivationChangeItem* item, PackageFSActivationChangeType type,
        Package* package, char*& nameBuffer)
{
        item->type = type;
        item->packageDeviceID = package->NodeRef().device;
        item->packageNodeID = package->NodeRef().node;
        item->nameLength = package->FileName().Length();
        item->parentDeviceID = fVolume->PackagesDeviceID();
        item->parentDirectoryID = fVolume->PackagesDirectoryID();
        item->name = nameBuffer;
        strcpy(nameBuffer, package->FileName());
        nameBuffer += package->FileName().Length() + 1;
}


bool
CommitTransactionHandler::_IsSystemPackage(Package* package)
{
        // package name should be "haiku[_<arch>]"
        const BString& name = package->Info().Name();
        if (!name.StartsWith("haiku"))
                return false;
        if (name.Length() == 5)
                return true;
        if (name[5] != '_')
                return false;

        BPackageArchitecture architecture;
        return BPackageInfo::GetArchitectureByName(name.String() + 6, architecture)
                == B_OK;
}


void
CommitTransactionHandler::_AddIssue(const TransactionIssueBuilder& builder)
{
        fResult.AddIssue(builder.BuildIssue(fCurrentPackage));
}


/*static*/ BString
CommitTransactionHandler::_GetPath(const FSUtils::Entry& entry,
        const BString& fallback)
{
        BString path = entry.Path();
        return path.IsEmpty() ? fallback : path;
}


/*static*/ void
CommitTransactionHandler::_TagPackageEntriesRecursively(BDirectory& directory,
        const BString& value, bool nonDirectoriesOnly)
{
        char buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH];
        dirent *entry = (dirent*)buffer;
        while (directory.GetNextDirents(entry, sizeof(buffer), 1) == 1) {
                if (strcmp(entry->d_name, ".") == 0
                        || strcmp(entry->d_name, "..") == 0) {
                        continue;
                }

                // determine type
                struct stat st;
                status_t error = directory.GetStatFor(entry->d_name, &st);
                if (error != B_OK) {
                        throw Exception(B_TRANSACTION_FAILED_TO_ACCESS_ENTRY)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(directory, entry->d_name),
                                        entry->d_name))
                                .SetSystemError(error);
                }
                bool isDirectory = S_ISDIR(st.st_mode);

                // open the node and set the attribute
                BNode stackNode;
                BDirectory stackDirectory;
                BNode* node;
                if (isDirectory) {
                        node = &stackDirectory;
                        error = stackDirectory.SetTo(&directory, entry->d_name);
                } else {
                        node = &stackNode;
                        error = stackNode.SetTo(&directory, entry->d_name);
                }

                if (error != B_OK) {
                        throw Exception(isDirectory
                                        ? B_TRANSACTION_FAILED_TO_OPEN_DIRECTORY
                                        : B_TRANSACTION_FAILED_TO_OPEN_FILE)
                                .SetPath1(_GetPath(
                                        FSUtils::Entry(directory, entry->d_name),
                                        entry->d_name))
                                .SetSystemError(error);
                }

                if (!isDirectory || !nonDirectoriesOnly) {
                        error = node->WriteAttrString(kPackageFileAttribute, &value);
                        if (error != B_OK) {
                                throw Exception(B_TRANSACTION_FAILED_TO_WRITE_FILE_ATTRIBUTE)
                                        .SetPath1(_GetPath(
                                                FSUtils::Entry(directory, entry->d_name),
                                                entry->d_name))
                                        .SetSystemError(error);
                        }
                }

                // recurse
                if (isDirectory) {
                        _TagPackageEntriesRecursively(stackDirectory, value,
                                nonDirectoriesOnly);
                }
        }
}


/*static*/ status_t
CommitTransactionHandler::_AssertEntriesAreEqual(const BEntry& entry,
        const BDirectory* directory)
{
        BFile a;
        status_t status = a.SetTo(&entry, B_READ_ONLY);
        if (status != B_OK)
                return status;

        BFile b;
        status = b.SetTo(directory, entry.Name(), B_READ_ONLY);
        if (status != B_OK)
                return status;

        off_t aSize;
        status = a.GetSize(&aSize);
        if (status != B_OK)
                return status;

        off_t bSize;
        status = b.GetSize(&bSize);
        if (status != B_OK)
                return status;

        if (aSize != bSize)
                return B_FILE_EXISTS;

        const size_t bufferSize = 4096;
        uint8 aBuffer[bufferSize];
        uint8 bBuffer[bufferSize];

        while (aSize > 0) {
                ssize_t aRead = a.Read(aBuffer, bufferSize);
                ssize_t bRead = b.Read(bBuffer, bufferSize);
                if (aRead < 0 || aRead != bRead)
                        return B_FILE_EXISTS;
                if (memcmp(aBuffer, bBuffer, aRead) != 0)
                        return B_FILE_EXISTS;
                aSize -= aRead;
        }

        INFORM("CommitTransactionHandler::_AssertEntriesAreEqual(): "
                "Package file '%s' already exists in target folder "
                "with equal contents\n", entry.Name());
        return B_OK;
}