/*
 * Copyright 2007-2018, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus, superstippi@gmx.de
 *              Axel Dörfler, axeld@pinc-software.de
 */


#include "AutoMounter.h"

#include <new>

#include <string.h>
#include <unistd.h>

#include <Alert.h>
#include <AutoLocker.h>
#include <Catalog.h>
#include <Debug.h>
#include <Directory.h>
#include <DiskDevice.h>
#include <DiskDeviceRoster.h>
#include <DiskDeviceList.h>
#include <DiskDeviceTypes.h>
#include <DiskSystem.h>
#include <FindDirectory.h>
#include <fs_info.h>
#include <fs_volume.h>
#include <LaunchRoster.h>
#include <Locale.h>
#include <Message.h>
#include <Node.h>
#include <NodeMonitor.h>
#include <Path.h>
#include <PropertyInfo.h>
#include <String.h>
#include <VolumeRoster.h>

#include "MountServer.h"

#include "Utilities.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "AutoMounter"


static const char* kMountServerSettings = "mount_server";
static const char* kMountFlagsKeyExtension = " mount flags";

static const char* kInitialMountEvent = "initial_volumes_mounted";


class MountVisitor : public BDiskDeviceVisitor {
public:
                                                                MountVisitor(mount_mode normalMode,
                                                                        mount_mode removableMode,
                                                                        bool initialRescan, BMessage& previous,
                                                                        partition_id deviceID);
        virtual                                         ~MountVisitor()
                                                                        {}

        virtual bool                            Visit(BDiskDevice* device);
        virtual bool                            Visit(BPartition* partition, int32 level);

private:
                        bool                            _WasPreviouslyMounted(const BPath& path,
                                                                        const BPartition* partition);

private:
                        mount_mode                      fNormalMode;
                        mount_mode                      fRemovableMode;
                        bool                            fInitialRescan;
                        BMessage&                       fPrevious;
                        partition_id            fOnlyOnDeviceID;
};


class MountArchivedVisitor : public BDiskDeviceVisitor {
public:
                                                                MountArchivedVisitor(
                                                                        const BDiskDeviceList& devices,
                                                                        const BMessage& archived);
        virtual                                         ~MountArchivedVisitor();

        virtual bool                            Visit(BDiskDevice* device);
        virtual bool                            Visit(BPartition* partition, int32 level);

private:
                enum {
                        MATCHES_VOLUME_NAME     = (1 << 0),
                        MATCHES_DEVICE_NAME     = (1 << 1),
                        MATCHES_FS_NAME         = (1 << 2),
                        MATCHES_BLOCK_SIZE      = (1 << 3),
                        MATCHES_CAPACITY        = (1 << 4),
                };

                        int                                     _Score(BPartition* partition);

private:
                        const BDiskDeviceList& fDevices;
                        const BMessage&         fArchived;
                        int                                     fBestScore;
                        partition_id            fBestID;
};


static bool
BootedInSafeMode()
{
        const char* safeMode = getenv("SAFEMODE");
        return safeMode != NULL && strcmp(safeMode, "yes") == 0;
}


class ArchiveVisitor : public BDiskDeviceVisitor {
public:
                                                                ArchiveVisitor(BMessage& message);
        virtual                                         ~ArchiveVisitor();

        virtual bool                            Visit(BDiskDevice* device);
        virtual bool                            Visit(BPartition* partition, int32 level);

private:
                        BMessage&                       fMessage;
};


// #pragma mark - MountVisitor


MountVisitor::MountVisitor(mount_mode normalMode, mount_mode removableMode,
                bool initialRescan, BMessage& previous, partition_id deviceID)
        :
        fNormalMode(normalMode),
        fRemovableMode(removableMode),
        fInitialRescan(initialRescan),
        fPrevious(previous),
        fOnlyOnDeviceID(deviceID)
{
}


bool
MountVisitor::Visit(BDiskDevice* device)
{
        return Visit(device, 0);
}


bool
MountVisitor::Visit(BPartition* partition, int32 level)
{
        if (fOnlyOnDeviceID >= 0) {
                // only mount partitions on the given device id
                // or if the partition ID is already matched
                BPartition* device = partition;
                while (device->Parent() != NULL) {
                        if (device->ID() == fOnlyOnDeviceID) {
                                // we are happy
                                break;
                        }
                        device = device->Parent();
                }
                if (device->ID() != fOnlyOnDeviceID)
                        return false;
        }

        mount_mode mode = !fInitialRescan && partition->Device()->IsRemovableMedia()
                ? fRemovableMode : fNormalMode;
        if (mode == kNoVolumes || partition->IsMounted()
                || !partition->ContainsFileSystem()) {
                return false;
        }

        BPath path;
        if (partition->GetPath(&path) != B_OK)
                return false;

        if (mode == kRestorePreviousVolumes) {
                // mount all volumes that were stored in the settings file
                if (!_WasPreviouslyMounted(path, partition))
                        return false;
        } else if (mode == kOnlyBFSVolumes) {
                if (partition->ContentType() == NULL
                        || strcmp(partition->ContentType(), kPartitionTypeBFS))
                        return false;
        }

        uint32 mountFlags;
        if (!fInitialRescan) {
                // Ask the user about mount flags if this is not the
                // initial scan.
                if (!AutoMounter::_SuggestMountFlags(partition, &mountFlags))
                        return false;
        } else {
                BString mountFlagsKey(path.Path());
                mountFlagsKey << kMountFlagsKeyExtension;
                if (fPrevious.FindInt32(mountFlagsKey.String(),
                                (int32*)&mountFlags) < B_OK) {
                        mountFlags = 0;
                }
        }

        if (partition->Mount(NULL, mountFlags) != B_OK) {
                // TODO: Error to syslog
        }
        return false;
}


bool
MountVisitor::_WasPreviouslyMounted(const BPath& path,
        const BPartition* partition)
{
        // We only check the legacy config data here; the current method
        // is implemented in ArchivedVolumeVisitor -- this can be removed
        // some day.
        BString volumeName;
        if (fPrevious.FindString(path.Path(), &volumeName) != B_OK
                || volumeName != partition->ContentName())
                return false;

        return true;
}


// #pragma mark - MountArchivedVisitor


MountArchivedVisitor::MountArchivedVisitor(const BDiskDeviceList& devices,
                const BMessage& archived)
        :
        fDevices(devices),
        fArchived(archived),
        fBestScore(-1),
        fBestID(-1)
{
}


MountArchivedVisitor::~MountArchivedVisitor()
{
        // At least these fields, plus one other besides, must match for us to auto-mount.
        const int requiredMatches = MATCHES_FS_NAME | MATCHES_CAPACITY | MATCHES_BLOCK_SIZE;
        if ((fBestScore & requiredMatches) != requiredMatches)
                return;
        if ((fBestScore & ~requiredMatches) == 0)
                return;

        uint32 mountFlags = fArchived.GetUInt32("mountFlags", 0);
        BPartition* partition = fDevices.PartitionWithID(fBestID);
        if (partition != NULL)
                partition->Mount(NULL, mountFlags);
}


bool
MountArchivedVisitor::Visit(BDiskDevice* device)
{
        return Visit(device, 0);
}


bool
MountArchivedVisitor::Visit(BPartition* partition, int32 level)
{
        if (partition->IsMounted() || !partition->ContainsFileSystem())
                return false;

        int score = _Score(partition);
        if (score > fBestScore) {
                fBestScore = score;
                fBestID = partition->ID();
        }

        return false;
}


int
MountArchivedVisitor::_Score(BPartition* partition)
{
        BPath path;
        if (partition->GetPath(&path) != B_OK)
                return 0;

        int score = 0;

        BString volumeName = fArchived.GetString("volumeName");
        if (volumeName == partition->ContentName())
                score |= MATCHES_VOLUME_NAME;

        BString deviceName = fArchived.GetString("deviceName");
        if (deviceName == path.Path())
                score |= MATCHES_DEVICE_NAME;

        BString fsName = fArchived.FindString("fsName");
        if (fsName == partition->ContentType())
                score |= MATCHES_FS_NAME;

        int64 capacity = fArchived.GetInt64("capacity", 0);
        if (capacity == partition->ContentSize())
                score |= MATCHES_CAPACITY;

        uint32 blockSize = fArchived.GetUInt32("blockSize", 0);
        if (blockSize == partition->BlockSize())
                score |= MATCHES_BLOCK_SIZE;

        return score;
}


// #pragma mark - ArchiveVisitor


ArchiveVisitor::ArchiveVisitor(BMessage& message)
        :
        fMessage(message)
{
}


ArchiveVisitor::~ArchiveVisitor()
{
}


bool
ArchiveVisitor::Visit(BDiskDevice* device)
{
        return Visit(device, 0);
}


bool
ArchiveVisitor::Visit(BPartition* partition, int32 level)
{
        if (!partition->ContainsFileSystem())
                return false;

        BPath path;
        if (partition->GetPath(&path) != B_OK)
                return false;

        BMessage info;
        info.AddUInt32("blockSize", partition->BlockSize());
        info.AddInt64("capacity", partition->ContentSize());
        info.AddString("deviceName", path.Path());
        info.AddString("volumeName", partition->ContentName());
        info.AddString("fsName", partition->ContentType());
        BVolume volume;
        partition->GetVolume(&volume);
        fs_info fsInfo;
        if (fs_stat_dev(volume.Device(), &fsInfo) == 0) {
                if ((fsInfo.flags & B_FS_IS_READONLY) != 0)
                        info.AddUInt32("mountFlags", B_MOUNT_READ_ONLY);
                else
                        info.AddUInt32("mountFlags", 0);
        }

        fMessage.AddMessage("info", &info);
        return false;
}


// #pragma mark -


AutoMounter::AutoMounter()
        :
        BServer(kMountServerSignature, false, NULL),
        fNormalMode(kRestorePreviousVolumes),
        fRemovableMode(kAllVolumes),
        fEjectWhenUnmounting(true)
{
        set_thread_priority(Thread(), B_LOW_PRIORITY);

        if (!BootedInSafeMode()) {
                _ReadSettings();
        } else {
                // defeat automounter in safe mode, don't even care about the settings
                fNormalMode = kNoVolumes;
                fRemovableMode = kNoVolumes;
        }

        BDiskDeviceRoster().StartWatching(this,
                B_DEVICE_REQUEST_DEVICE | B_DEVICE_REQUEST_DEVICE_LIST);
        BLaunchRoster().RegisterEvent(this, kInitialMountEvent, B_STICKY_EVENT);
}


AutoMounter::~AutoMounter()
{
        BLaunchRoster().UnregisterEvent(this, kInitialMountEvent);
        BDiskDeviceRoster().StopWatching(this);
}


void
AutoMounter::ReadyToRun()
{
        // Do initial scan
        _MountVolumes(fNormalMode, fRemovableMode, true);
        BLaunchRoster().NotifyEvent(this, kInitialMountEvent);
}


void
AutoMounter::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case kMountVolume:
                        _MountVolume(message);
                        break;

                case kUnmountVolume:
                        _UnmountAndEjectVolume(message);
                        break;

                case kSetAutomounterParams:
                {
                        bool rescanNow = false;
                        message->FindBool("rescanNow", &rescanNow);

                        _UpdateSettingsFromMessage(message);
                        _GetSettings(&fSettings);
                        _WriteSettings();

                        if (rescanNow)
                                _MountVolumes(fNormalMode, fRemovableMode);
                        break;
                }

                case kGetAutomounterParams:
                {
                        BMessage reply;
                        _GetSettings(&reply);
                        message->SendReply(&reply);
                        break;
                }

                case kMountAllNow:
                        _MountVolumes(kAllVolumes, kAllVolumes);
                        break;

                case B_DEVICE_UPDATE:
                        int32 event;
                        if (message->FindInt32("event", &event) != B_OK
                                || (event != B_DEVICE_MEDIA_CHANGED
                                        && event != B_DEVICE_ADDED))
                                break;

                        partition_id deviceID;
                        if (message->FindInt32("id", &deviceID) != B_OK)
                                break;

                        _MountVolumes(kNoVolumes, fRemovableMode, false, deviceID);
                        break;

#if 0
                case B_NODE_MONITOR:
                {
                        int32 opcode;
                        if (message->FindInt32("opcode", &opcode) != B_OK)
                                break;

                        switch (opcode) {
                                //      The name of a mount point has changed
                                case B_ENTRY_MOVED: {
                                        WRITELOG(("*** Received Mount Point Renamed Notification"));

                                        const char *newName;
                                        if (message->FindString("name", &newName) != B_OK) {
                                                WRITELOG(("ERROR: Couldn't find name field in update "
                                                        "message"));
                                                PRINT_OBJECT(*message);
                                                break ;
                                        }

                                        //
                                        // When the node monitor reports a move, it gives the
                                        // parent device and inode that moved.  The problem is
                                        // that  the inode is the inode of root *in* the filesystem,
                                        // which is generally always the same number for every
                                        // filesystem of a type.
                                        //
                                        // What we'd really like is the device that the moved
                                        // volume is mounted on.  Find this by using the
                                        // *new* name and directory, and then stat()ing that to
                                        // find the device.
                                        //
                                        dev_t parentDevice;
                                        if (message->FindInt32("device", &parentDevice) != B_OK) {
                                                WRITELOG(("ERROR: Couldn't find 'device' field in "
                                                        "update message"));
                                                PRINT_OBJECT(*message);
                                                break;
                                        }

                                        ino_t toDirectory;
                                        if (message->FindInt64("to directory", &toDirectory)
                                                != B_OK) {
                                                WRITELOG(("ERROR: Couldn't find 'to directory' field "
                                                        "in update message"));
                                                PRINT_OBJECT(*message);
                                                break;
                                        }

                                        entry_ref root_entry(parentDevice, toDirectory, newName);

                                        BNode entryNode(&root_entry);
                                        if (entryNode.InitCheck() != B_OK) {
                                                WRITELOG(("ERROR: Couldn't create mount point entry "
                                                        "node: %s/n", strerror(entryNode.InitCheck())));
                                                break;
                                        }

                                        node_ref mountPointNode;
                                        if (entryNode.GetNodeRef(&mountPointNode) != B_OK) {
                                                WRITELOG(("ERROR: Couldn't get node ref for new mount "
                                                        "point"));
                                                break;
                                        }

                                        WRITELOG(("Attempt to rename device %li to %s",
                                                mountPointNode.device, newName));

                                        Partition *partition = FindPartition(mountPointNode.device);
                                        if (partition != NULL) {
                                                WRITELOG(("Found device, changing name."));

                                                BVolume mountVolume(partition->VolumeDeviceID());
                                                BDirectory mountDir;
                                                mountVolume.GetRootDirectory(&mountDir);
                                                BPath dirPath(&mountDir, 0);

                                                partition->SetMountedAt(dirPath.Path());
                                                partition->SetVolumeName(newName);
                                                break;
                                        } else {
                                                WRITELOG(("ERROR: Device %li does not appear to be "
                                                        "present", mountPointNode.device));
                                        }
                                }
                        }
                        break;
                }
#endif

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


bool
AutoMounter::QuitRequested()
{
        if (!BootedInSafeMode()) {
                // Don't write out settings in safe mode - this would overwrite the
                // normal, non-safe mode settings.
                _WriteSettings();
        }

        return true;
}


// #pragma mark - private methods


void
AutoMounter::_MountVolumes(mount_mode normal, mount_mode removable,
        bool initialRescan, partition_id deviceID)
{
        if (normal == kNoVolumes && removable == kNoVolumes)
                return;

        BDiskDeviceList devices;
        status_t status = devices.Fetch();
        if (status != B_OK)
                return;

        if (normal == kRestorePreviousVolumes) {
                BMessage archived;
                for (int32 index = 0;
                                fSettings.FindMessage("info", index, &archived) == B_OK;
                                index++) {
                        MountArchivedVisitor visitor(devices, archived);
                        devices.VisitEachPartition(&visitor);
                }
        }

        MountVisitor visitor(normal, removable, initialRescan, fSettings, deviceID);
        devices.VisitEachPartition(&visitor);
}


void
AutoMounter::_MountVolume(const BMessage* message)
{
        int32 id;
        if (message->FindInt32("id", &id) != B_OK)
                return;

        BDiskDeviceRoster roster;
        BPartition *partition;
        BDiskDevice device;
        if (roster.GetPartitionWithID(id, &device, &partition) != B_OK)
                return;

        uint32 mountFlags;
        if (!_SuggestMountFlags(partition, &mountFlags))
                return;

        status_t status = partition->Mount(NULL, mountFlags);
        if (status < B_OK && InitGUIContext() == B_OK) {
                char text[512];
                snprintf(text, sizeof(text),
                        B_TRANSLATE("Error mounting volume:\n\n%s"), strerror(status));
                BAlert* alert = new BAlert(B_TRANSLATE("Mount error"), text,
                        B_TRANSLATE("OK"));
                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                alert->Go(NULL);
        }
}


bool
AutoMounter::_SuggestForceUnmount(const char* name, status_t error)
{
        if (InitGUIContext() != B_OK)
                return false;

        char text[1024];
        snprintf(text, sizeof(text),
                B_TRANSLATE("Could not unmount disk \"%s\":\n\t%s\n\n"
                        "Should unmounting be forced?\n\n"
                        "Note: If an application is currently writing to the volume, "
                        "unmounting it now might result in loss of data.\n"),
                name, strerror(error));

        BAlert* alert = new BAlert(B_TRANSLATE("Force unmount"), text,
                B_TRANSLATE("Cancel"), B_TRANSLATE("Force unmount"), NULL,
                B_WIDTH_AS_USUAL, B_WARNING_ALERT);
        alert->SetShortcut(0, B_ESCAPE);
        int32 choice = alert->Go();

        return choice == 1;
}


void
AutoMounter::_ReportUnmountError(const char* name, status_t error)
{
        if (InitGUIContext() != B_OK)
                return;

        char text[512];
        snprintf(text, sizeof(text), B_TRANSLATE("Could not unmount disk "
                "\"%s\":\n\t%s"), name, strerror(error));

        BAlert* alert = new BAlert(B_TRANSLATE("Unmount error"), text,
                B_TRANSLATE("OK"), NULL, NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
        alert->Go(NULL);
}


void
AutoMounter::_UnmountAndEjectVolume(BPartition* partition, BPath& mountPoint,
        const char* name)
{
        BDiskDevice deviceStorage;
        BDiskDevice* device;
        if (partition == NULL) {
                // Try to retrieve partition
                BDiskDeviceRoster().FindPartitionByMountPoint(mountPoint.Path(),
                        &deviceStorage, &partition);
                        device = &deviceStorage;
        } else {
                device = partition->Device();
        }

        status_t status;
        if (partition != NULL)
                status = partition->Unmount();
        else
                status = fs_unmount_volume(mountPoint.Path(), 0);

        if (status != B_OK) {
                if (!_SuggestForceUnmount(name, status))
                        return;

                if (partition != NULL)
                        status = partition->Unmount(B_FORCE_UNMOUNT);
                else
                        status = fs_unmount_volume(mountPoint.Path(), B_FORCE_UNMOUNT);
        }

        if (status != B_OK) {
                _ReportUnmountError(name, status);
                return;
        }

        if (fEjectWhenUnmounting && partition != NULL) {
                // eject device if it doesn't have any mounted partitions left
                class IsMountedVisitor : public BDiskDeviceVisitor {
                public:
                        IsMountedVisitor()
                                :
                                fHasMounted(false)
                        {
                        }

                        virtual bool Visit(BDiskDevice* device)
                        {
                                return Visit(device, 0);
                        }

                        virtual bool Visit(BPartition* partition, int32 level)
                        {
                                if (partition->IsMounted()) {
                                        fHasMounted = true;
                                        return true;
                                }

                                return false;
                        }

                        bool HasMountedPartitions() const
                        {
                                return fHasMounted;
                        }

                private:
                        bool    fHasMounted;
                } visitor;

                device->VisitEachDescendant(&visitor);

                if (!visitor.HasMountedPartitions())
                        device->Eject();
        }

        // remove the directory if it's a directory in rootfs
        if (dev_for_path(mountPoint.Path()) == dev_for_path("/"))
                rmdir(mountPoint.Path());
}


void
AutoMounter::_UnmountAndEjectVolume(BMessage* message)
{
        int32 id;
        if (message->FindInt32("id", &id) == B_OK) {
                BDiskDeviceRoster roster;
                BPartition *partition;
                BDiskDevice device;
                if (roster.GetPartitionWithID(id, &device, &partition) != B_OK)
                        return;

                BPath path;
                if (partition->GetMountPoint(&path) == B_OK)
                        _UnmountAndEjectVolume(partition, path, partition->ContentName());
        } else {
                // see if we got a dev_t

                dev_t device;
                if (message->FindInt32("device_id", &device) != B_OK)
                        return;

                BVolume volume(device);
                status_t status = volume.InitCheck();

                char name[B_FILE_NAME_LENGTH];
                if (status == B_OK)
                        status = volume.GetName(name);
                if (status < B_OK)
                        snprintf(name, sizeof(name), "device:%" B_PRIdDEV, device);

                BPath path;
                if (status == B_OK) {
                        BDirectory mountPoint;
                        status = volume.GetRootDirectory(&mountPoint);
                        if (status == B_OK)
                                status = path.SetTo(&mountPoint, ".");
                }

                if (status == B_OK)
                        _UnmountAndEjectVolume(NULL, path, name);
        }
}


void
AutoMounter::_FromMode(mount_mode mode, bool& all, bool& bfs, bool& restore)
{
        all = bfs = restore = false;

        switch (mode) {
                case kAllVolumes:
                        all = true;
                        break;
                case kOnlyBFSVolumes:
                        bfs = true;
                        break;
                case kRestorePreviousVolumes:
                        restore = true;
                        break;

                default:
                        break;
        }
}


mount_mode
AutoMounter::_ToMode(bool all, bool bfs, bool restore)
{
        if (all)
                return kAllVolumes;
        if (bfs)
                return kOnlyBFSVolumes;
        if (restore)
                return kRestorePreviousVolumes;

        return kNoVolumes;
}


void
AutoMounter::_ReadSettings()
{
        BPath directoryPath;
        if (find_directory(B_USER_SETTINGS_DIRECTORY, &directoryPath, true)
                != B_OK) {
                return;
        }

        BPath path(directoryPath);
        path.Append(kMountServerSettings);
        fPrefsFile.SetTo(path.Path(), O_RDWR);

        if (fPrefsFile.InitCheck() != B_OK) {
                // no prefs file yet, create a new one

                BDirectory dir(directoryPath.Path());
                dir.CreateFile(kMountServerSettings, &fPrefsFile);
                return;
        }

        ssize_t settingsSize = (ssize_t)fPrefsFile.Seek(0, SEEK_END);
        if (settingsSize == 0)
                return;

        ASSERT(settingsSize != 0);
        char *buffer = new(std::nothrow) char[settingsSize];
        if (buffer == NULL) {
                PRINT(("error writing automounter settings, out of memory\n"));
                return;
        }

        fPrefsFile.Seek(0, 0);
        if (fPrefsFile.Read(buffer, (size_t)settingsSize) != settingsSize) {
                PRINT(("error reading automounter settings\n"));
                delete [] buffer;
                return;
        }

        BMessage message('stng');
        status_t result = message.Unflatten(buffer);
        if (result != B_OK) {
                PRINT(("error %s unflattening automounter settings, size %" B_PRIdSSIZE "\n",
                        strerror(result), settingsSize));
                delete [] buffer;
                return;
        }

        delete [] buffer;

        // update flags and modes from the message
        _UpdateSettingsFromMessage(&message);
        // copy the previously mounted partitions
        fSettings = message;
}


void
AutoMounter::_WriteSettings()
{
        if (fPrefsFile.InitCheck() != B_OK)
                return;

        BMessage message('stng');
        _GetSettings(&message);

        ssize_t settingsSize = message.FlattenedSize();

        char* buffer = new(std::nothrow) char[settingsSize];
        if (buffer == NULL) {
                PRINT(("error writing automounter settings, out of memory\n"));
                return;
        }

        status_t result = message.Flatten(buffer, settingsSize);

        fPrefsFile.Seek(0, SEEK_SET);
        fPrefsFile.SetSize(0);

        result = fPrefsFile.Write(buffer, (size_t)settingsSize);
        if (result != settingsSize)
                PRINT(("error writing automounter settings, %s\n", strerror(result)));

        delete [] buffer;
}


void
AutoMounter::_UpdateSettingsFromMessage(BMessage* message)
{
        // auto mounter settings

        bool all, bfs, restore;
        if (message->FindBool("autoMountAll", &all) != B_OK)
                all = true;
        if (message->FindBool("autoMountAllBFS", &bfs) != B_OK)
                bfs = false;

        fRemovableMode = _ToMode(all, bfs, false);

        // initial mount settings

        if (message->FindBool("initialMountAll", &all) != B_OK)
                all = false;
        if (message->FindBool("initialMountAllBFS", &bfs) != B_OK)
                bfs = false;
        if (message->FindBool("initialMountRestore", &restore) != B_OK)
                restore = true;

        fNormalMode = _ToMode(all, bfs, restore);

        // eject settings
        bool eject;
        if (message->FindBool("ejectWhenUnmounting", &eject) == B_OK)
                fEjectWhenUnmounting = eject;
}


void
AutoMounter::_GetSettings(BMessage *message)
{
        message->MakeEmpty();

        bool all, bfs, restore;

        _FromMode(fNormalMode, all, bfs, restore);
        message->AddBool("initialMountAll", all);
        message->AddBool("initialMountAllBFS", bfs);
        message->AddBool("initialMountRestore", restore);

        _FromMode(fRemovableMode, all, bfs, restore);
        message->AddBool("autoMountAll", all);
        message->AddBool("autoMountAllBFS", bfs);

        message->AddBool("ejectWhenUnmounting", fEjectWhenUnmounting);

        // Save mounted volumes so we can optionally mount them on next
        // startup
        ArchiveVisitor visitor(*message);
        BDiskDeviceRoster().VisitEachMountedPartition(&visitor);
}


/*static*/ bool
AutoMounter::_SuggestMountFlags(const BPartition* partition, uint32* _flags)
{
        uint32 mountFlags = 0;

        bool askReadOnly = true;

        if (partition->ContentType() != NULL
                && strcmp(partition->ContentType(), kPartitionTypeBFS) == 0) {
                askReadOnly = false;
        }

        BDiskSystem diskSystem;
        status_t status = partition->GetDiskSystem(&diskSystem);
        if (status == B_OK && !diskSystem.SupportsWriting())
                askReadOnly = false;

        if (partition->IsReadOnly())
                askReadOnly = false;

        if (askReadOnly && ((BServer*)be_app)->InitGUIContext() != B_OK) {
                // Mount read-only, just to be safe.
                mountFlags |= B_MOUNT_READ_ONLY;
                askReadOnly = false;
        }

        if (askReadOnly) {
                // Suggest to the user to mount read-only until Haiku is more mature.
                BString string;
                string.SetToFormat(B_TRANSLATE("Mounting volume '%s'\n\n"),
                        partition->ContentName().String());

                // TODO: Use distro name instead of "Haiku"...
                string << B_TRANSLATE("The file system on this volume is not the "
                        "Be file system. It is recommended to mount it in read-only "
                        "mode, to prevent unintentional data loss because of bugs "
                        "in Haiku.");

                BAlert* alert = new BAlert(B_TRANSLATE("Mount warning"),
                        string.String(), B_TRANSLATE("Mount read/write"),
                        B_TRANSLATE("Cancel"), B_TRANSLATE("Mount read-only"),
                        B_WIDTH_FROM_WIDEST, B_WARNING_ALERT);
                alert->SetShortcut(1, B_ESCAPE);
                int32 choice = alert->Go();
                switch (choice) {
                        case 0:
                                break;
                        case 1:
                                return false;
                        case 2:
                                mountFlags |= B_MOUNT_READ_ONLY;
                                break;
                }
        }

        *_flags = mountFlags;
        return true;
}


// #pragma mark -


int
main(int argc, char* argv[])
{
        AutoMounter app;

        app.Run();
        return 0;
}