vbox_mscom_impl.cpp

// This file is part of BOINC.
// http://boinc.berkeley.edu
// Copyright (C) 2010-2012 University of California
//
// BOINC is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// BOINC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with BOINC.  If not, see <http://www.gnu.org/licenses/>.

#ifdef _VIRTUALBOX_IMPORT_FUNCTIONS_

const char *MachineStateToName(MachineState State) 
{ 
    switch (State) 
    { 
        case MachineState_PoweredOff: 
            return "poweroff"; 
        case MachineState_Saved: 
            return "saved"; 
        case MachineState_Aborted: 
            return "aborted"; 
        case MachineState_Teleported: 
            return "teleported"; 
        case MachineState_Running: 
            return "running"; 
        case MachineState_Paused: 
            return "paused"; 
        case MachineState_Stuck: 
            return "gurumeditation"; 
        case MachineState_LiveSnapshotting: 
            return "livesnapshotting"; 
        case MachineState_Teleporting: 
            return "teleporting"; 
        case MachineState_Starting: 
            return "starting"; 
        case MachineState_Stopping: 
            return "stopping"; 
        case MachineState_Saving: 
            return "saving"; 
        case MachineState_Restoring: 
            return "restoring"; 
        case MachineState_TeleportingPausedVM: 
            return "teleportingpausedvm"; 
        case MachineState_TeleportingIn: 
            return "teleportingin"; 
        case MachineState_RestoringSnapshot: 
            return "restoringsnapshot"; 
        case MachineState_DeletingSnapshot: 
            return "deletingsnapshot"; 
        case MachineState_DeletingSnapshotOnline: 
            return "deletingsnapshotlive"; 
        case MachineState_DeletingSnapshotPaused: 
            return "deletingsnapshotlivepaused"; 
        case MachineState_SettingUp: 
            return "settingup"; 
        default: 
            break; 
    } 
    return "unknown"; 
} 


// Helper function to print MSCOM exception information set on the current
// thread after a failed MSCOM method call. This function will also print
// extended VirtualBox error info if it is available.
//
#define CHECK_ERROR(rc) \
    retval = virtualbox_check_error(rc, __FUNCTION__, __FILE__, __LINE__)

int virtualbox_check_error(HRESULT rc, char* szFunction, char* szFile, int iLine) {
    HRESULT local_rc;
    CComPtr<IErrorInfo> pErrorInfo;
    CComBSTR strDescription;

    if (FAILED(rc)) {
        local_rc = GetErrorInfo(0, &pErrorInfo);
        if (SUCCEEDED(local_rc)) {
            vboxlog_msg("Error in %s (%s:%d)", szFunction, szFile, iLine);
            rc = pErrorInfo->GetDescription(&strDescription);
            if (SUCCEEDED(rc) && strDescription) {
                vboxlog_msg("Error description: %S", strDescription);
            }
        } else {
            vboxlog_msg("Error: getting error info! rc = 0x%x", rc);
        }
    }
    return rc;
}


// We want to recurisively walk the snapshot tree so that we can get the most recent children first.
// We also want to skip whatever the most current snapshot is.
//
void TraverseSnapshots(std::string& current_snapshot_id, std::vector<std::string>& snapshots, ISnapshot* pSnapshot) {
    HRESULT rc;
    SAFEARRAY* pSnapshots = NULL;
    CComSafeArray<LPDISPATCH> aSnapshots;
    CComBSTR tmp;
    ULONG lCount;
    std::string snapshot_id;

    // Check to see if we have any children
    //
    rc = pSnapshot->GetChildrenCount(&lCount);
    if (SUCCEEDED(rc) && lCount) {
        rc = pSnapshot->get_Children(&pSnapshots);
        if (SUCCEEDED(rc)) {
            aSnapshots.Attach(pSnapshots);
            if (aSnapshots.GetCount() > 0) {
                for (int i = 0; i < (int)aSnapshots.GetCount(); i++) {
                    TraverseSnapshots(current_snapshot_id, snapshots, (ISnapshot*)(LPDISPATCH)aSnapshots[i]);
                }
            }
        }
    }

    // Check to see if we are the most recent snapshot.
    // if not, add the snapshot id to the list of snapshots to be deleted.
    //
    pSnapshot->get_Id(&tmp);
    if (SUCCEEDED(rc)) {
        snapshot_id = CW2A(tmp);
        if (current_snapshot_id == snapshot_id) {
            return;
        } else {
            snapshots.push_back(snapshot_id);
        }
    }
}


// We want to recurisively walk the medium tree so that we can get the most recent children first.
//
void TraverseMediums(std::vector<CComPtr<IMedium>>& mediums, IMedium* pMedium) {
    HRESULT rc;
    SAFEARRAY* pMediums = NULL;
    CComSafeArray<LPDISPATCH> aMediums;

    // Check to see if we have any children
    //
    rc = pMedium->get_Children(&pMediums);
    if (SUCCEEDED(rc)) {
        aMediums.Attach(pMediums);
        if (aMediums.GetCount() > 0) {
            for (int i = 0; i < (int)aMediums.GetCount(); i++) {
                TraverseMediums(mediums, (IMedium*)(LPDISPATCH)aMediums[i]);
            }
        }
    }

    mediums.push_back(CComPtr<IMedium>(pMedium));
}


VBOX_VM::VBOX_VM() {
    VBOX_BASE::VBOX_BASE();

    m_pPrivate = new VBOX_PRIV();
}

VBOX_VM::~VBOX_VM() {
    VBOX_BASE::~VBOX_BASE();

    if (m_pPrivate) {
        delete m_pPrivate;
        m_pPrivate = NULL;
    }
}

int VBOX_VM::initialize() {
    int rc = BOINC_SUCCESS;
    string old_path;
    string new_path;
    string version;
    APP_INIT_DATA aid;
    bool force_sandbox = false;

    boinc_get_init_data_p(&aid);
    get_install_directory(virtualbox_install_directory);

    // Prep the environment so we can execute the vboxmanage application
    //
    // TODO: Fix for non-Windows environments if we ever find another platform
    // where vboxmanage is not already in the search path
    if (!virtualbox_install_directory.empty())
    {
        old_path = getenv("PATH");
        new_path = virtualbox_install_directory + ";" + old_path;

        if (!SetEnvironmentVariable("PATH", const_cast<char*>(new_path.c_str()))) {
            vboxlog_msg("Failed to modify the search path");
        }
    }

    // Determine the VirtualBox home directory.  Overwrite as needed.
    //
    if (getenv("VBOX_USER_HOME")) {
        virtualbox_home_directory = getenv("VBOX_USER_HOME");
    } else {
        // If the override environment variable isn't specified then
        // it is based of the current users HOME directory.
        virtualbox_home_directory = getenv("USERPROFILE");
        virtualbox_home_directory += "/.VirtualBox";
    }

    // Set the location in which the VirtualBox Configuration files can be
    // stored for this instance.
    if (aid.using_sandbox || force_sandbox) {
        virtualbox_home_directory = aid.project_dir;
        virtualbox_home_directory += "/../virtualbox";

        if (!boinc_file_exists(virtualbox_home_directory.c_str())) {
            boinc_mkdir(virtualbox_home_directory.c_str());
        }

        if (!SetEnvironmentVariable("VBOX_USER_HOME", const_cast<char*>(virtualbox_home_directory.c_str()))) {
            vboxlog_msg("Failed to modify the search path");
        }
    }

    // Launch vboxsvc manually so that the DCOM subsystem won't be able too.  Our version
    // will have permission and direction to write its state information to the BOINC
    // data directory.
    //
    launch_vboxsvc();

    // Instantiate the VirtualBox root object.
    rc = m_pPrivate->m_pVirtualBox.CreateInstance(CLSID_VirtualBox);
    if (FAILED(rc)) {
        vboxlog_msg("Error creating VirtualBox instance! rc = 0x%x", rc);
        return rc;
    }

    // Create the session object.
    rc = m_pPrivate->m_pSession.CreateInstance(CLSID_Session);
    if (FAILED(rc)) {
        vboxlog_msg("Error creating Session instance! rc = 0x%x", rc);
        return rc;
    }

    rc = get_version_information(version);
    if (rc) return rc;

    // Fix-up version string
    virtualbox_version = "VirtualBox COM Interface (Version: " + version + ")";

    // Get the guest addition information
    get_guest_additions(virtualbox_guest_additions);

    return rc;
}

int VBOX_VM::create_vm() {
    int retval = ERR_EXEC;
    HRESULT rc;
    char buf[256];
    APP_INIT_DATA aid;
    CComBSTR vm_machine_uuid;
    CComPtr<IMachine> pMachineRO;
    CComPtr<IMachine> pMachine;
    CComPtr<ISession> pSession;
    CComPtr<IBIOSSettings> pBIOSSettings;
    CComPtr<INetworkAdapter> pNetworkAdapter;
    CComPtr<INATEngine> pNATEngine;
    CComPtr<IUSBController> pUSBContoller;
    CComPtr<ISerialPort> pSerialPort1;
    CComPtr<ISerialPort> pSerialPort2;
    CComPtr<IParallelPort> pParallelPort1;
    CComPtr<IParallelPort> pParallelPort2;
    CComPtr<IAudioAdapter> pAudioAdapter;
    CComPtr<IStorageController> pDiskController;
    CComPtr<IStorageController> pFloppyController;
    CComPtr<IBandwidthControl> pBandwidthControl;
    CComPtr<IVRDEServer> pVRDEServer;
    ULONG lOHCICtrls = 0;
    bool disable_acceleration = false;
    string virtual_machine_slot_directory;
    string default_interface;

    boinc_get_init_data_p(&aid);
    get_slot_directory(virtual_machine_slot_directory);


    rc = pSession.CoCreateInstance(CLSID_Session);
    if (CHECK_ERROR(rc)) goto CLEANUP;


    vboxlog_msg("Create VM. (%s, slot#%d)", vm_master_name.c_str(), aid.slot);


    // Reset VM name in case it was changed while deregistering a stale VM
    //
    vm_name = vm_master_name;

    // Fixup chipset and drive controller information for known configurations
    //
    if (enable_isocontextualization) {
        if ("PIIX4" == vm_disk_controller_model) {
            vboxlog_msg("Updating drive controller type and model for desired configuration.");
            vm_disk_controller_type = "sata";
            vm_disk_controller_model = "IntelAHCI";
        }
    }

    // Start the VM creation process
    //
    rc = m_pPrivate->m_pVirtualBox->CreateMachine(
        CComBSTR(string(virtual_machine_slot_directory + "\\" + vm_name + "\\" + vm_name + ".vbox").c_str()),
        CComBSTR(vm_name.c_str()),
        NULL,
        CComBSTR(os_name.c_str()),
        CComBSTR(""),
        &pMachineRO
    );
    if (CHECK_ERROR(rc)) goto CLEANUP;

    // Register the VM. Note that this call also saves the VM config
    // to disk. It is also possible to save the VM settings but not
    // register the VM.
    //
    // Also note that due to current VirtualBox limitations, the machine
    // must be registered *before* we can attach hard disks to it.
    //
    rc = m_pPrivate->m_pVirtualBox->RegisterMachine(pMachineRO);
    if (CHECK_ERROR(rc)) goto CLEANUP;
    
    rc = pMachineRO->LockMachine(pSession, LockType_Write);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pSession->get_Machine(&pMachine);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pMachine->get_BIOSSettings(&pBIOSSettings);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pMachine->get_BandwidthControl(&pBandwidthControl);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pMachine->get_VRDEServer(&pVRDEServer);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pMachine->GetNetworkAdapter(0, &pNetworkAdapter);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pNetworkAdapter->get_NATEngine(&pNATEngine);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pMachine->get_AudioAdapter(&pAudioAdapter);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    // Set some properties
    //
    pMachine->put_Description(CComBSTR(vm_master_description.c_str()));

    // Tweak the VM's Memory Size
    //
    vboxlog_msg("Setting Memory Size for VM. (%dMB)", (int)memory_size_mb);
    rc = pMachine->put_MemorySize((int)(memory_size_mb));
    if (CHECK_ERROR(rc)) goto CLEANUP;

    // Tweak the VM's CPU Count
    //
    vboxlog_msg("Setting CPU Count for VM. (%s)", vm_cpu_count.c_str());
    rc = pMachine->put_CPUCount((int)atoi(vm_cpu_count.c_str()));
    if (CHECK_ERROR(rc)) goto CLEANUP;

    // Tweak the VM's Chipset Options
    //
    vboxlog_msg("Setting Chipset Options for VM.");
    rc = pBIOSSettings->put_ACPIEnabled(TRUE);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = pBIOSSettings->put_IOAPICEnabled(TRUE);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    // Tweak the VM's Boot Options
    //
    vboxlog_msg("Setting Boot Options for VM.");
    rc = pMachine->SetBootOrder(1, DeviceType_HardDisk);
    if (CHECK_ERROR(rc)) goto CLEANUP;
    
    rc = pMachine->SetBootOrder(2, DeviceType_DVD);
    if (CHECK_ERROR(rc)) goto CLEANUP;

    pMachine->SetBootOrder(3, DeviceType_Null);
    pMachine->SetBootOrder(4, DeviceType_Null);

    // Tweak the VM's Network Configuration
    //
    if (enable_network) {
        vboxlog_msg("Enabling VM Network Access.");
        rc = pNetworkAdapter->put_Enabled(TRUE);
        if (CHECK_ERROR(rc)) goto CLEANUP;
    } else {
        vboxlog_msg("Disabling VM Network Access.");
        rc = pNetworkAdapter->put_Enabled(FALSE);
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }

    if (network_bridged_mode) {
        vboxlog_msg("Setting Network Configuration for Bridged Mode.");
        rc = pNetworkAdapter->put_AttachmentType(NetworkAttachmentType_Bridged);
        if (CHECK_ERROR(rc)) goto CLEANUP;

        get_default_network_interface(default_interface);

        vboxlog_msg("Setting Bridged Interface. (%s)", default_interface.c_str());
        rc = pNetworkAdapter->put_BridgedInterface(CComBSTR(CA2W(default_interface.c_str())));
        if (CHECK_ERROR(rc)) goto CLEANUP;
    } else {
        vboxlog_msg("Setting Network Configuration for NAT.");
        rc = pNetworkAdapter->put_AttachmentType(NetworkAttachmentType_NAT);
        if (CHECK_ERROR(rc)) goto CLEANUP;

        rc = pNATEngine->put_DNSProxy(TRUE);
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }

    // Tweak the VM's USB Configuration
    //
    vboxlog_msg("Disabling USB Support for VM.");
#ifdef _VIRTUALBOX43_
    rc = pMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &lOHCICtrls);
    if (SUCCEEDED(rc) && lOHCICtrls) {
        pMachine->RemoveUSBController(CComBSTR("OHCI"));
    }
#endif
#ifdef _VIRTUALBOX42_
    rc = pMachine->get_USBController(&pUSBContoller);
    if (SUCCEEDED(rc)) {
        pUSBContoller->put_Enabled(FALSE);
    }
#endif

    // Tweak the VM's COM Port Support
    //
    vboxlog_msg("Disabling COM Port Support for VM.");
    rc = pMachine->GetSerialPort(0, &pSerialPort1);
    if (SUCCEEDED(rc)) {
        pSerialPort1->put_Enabled(FALSE);
    }
    rc = pMachine->GetSerialPort(1, &pSerialPort2);
    if (SUCCEEDED(rc)) {
        pSerialPort2->put_Enabled(FALSE);
    }

    // Tweak the VM's LPT Port Support
    //
    vboxlog_msg("Disabling LPT Port Support for VM.");
    rc = pMachine->GetParallelPort(0, &pParallelPort1);
    if (SUCCEEDED(rc)) {
        pParallelPort1->put_Enabled(FALSE);
    }
    rc = pMachine->GetParallelPort(1, &pParallelPort2);
    if (SUCCEEDED(rc)) {
        pParallelPort2->put_Enabled(FALSE);
    }

    // Tweak the VM's Audio Support
    //
    vboxlog_msg("Disabling Audio Support for VM.");
    pAudioAdapter->put_Enabled(FALSE);

    // Tweak the VM's Clipboard Support
    //
    vboxlog_msg("Disabling Clipboard Support for VM.");
    pMachine->put_ClipboardMode(ClipboardMode_Disabled);

    // Tweak the VM's Drag & Drop Support
    //
    vboxlog_msg("Disabling Drag and Drop Support for VM.");
    pMachine->put_DragAndDropMode(DragAndDropMode_Disabled);

    // Check to see if the processor supports hardware acceleration for virtualization
    // If it doesn't, disable the use of it in VirtualBox. Multi-core jobs require hardware
    // acceleration and actually override this setting.
    //
    if (!strstr(aid.host_info.p_features, "vmx") && !strstr(aid.host_info.p_features, "svm")) {
        vboxlog_msg("Hardware acceleration CPU extensions not detected. Disabling VirtualBox hardware acceleration support.");
        disable_acceleration = true;
    }
    if (strstr(aid.host_info.p_features, "hypervisor")) {
        vboxlog_msg("Running under Hypervisor. Disabling VirtualBox hardware acceleration support.");
        disable_acceleration = true;
    }
    if (is_boinc_client_version_newer(aid, 7, 2, 16)) {
        if (aid.vm_extensions_disabled) {
            vboxlog_msg("Hardware acceleration failed with previous execution. Disabling VirtualBox hardware acceleration support.");
            disable_acceleration = true;
        }
    } else {
        if (vm_cpu_count == "1") {
            // Keep this around for older clients.  Removing this for older clients might
            // lead to a machine that will only return crashed VM reports.
            vboxlog_msg("Legacy fallback configuration detected. Disabling VirtualBox hardware acceleration support.");
            vboxlog_msg("NOTE: Upgrading to BOINC 7.2.16 or better may re-enable hardware acceleration.");
            disable_acceleration = true;
        }
    }

    // Only allow disabling of hardware acceleration on 32-bit VM types, 64-bit VM types require it.
    //
    if (os_name.find("_64") == std::string::npos) {
        if (disable_acceleration) {
            vboxlog_msg("Disabling hardware acceleration support for virtualization.");
            rc = pMachine->SetHWVirtExProperty(HWVirtExPropertyType_Enabled, FALSE);
            if (CHECK_ERROR(rc)) goto CLEANUP;
        }
    } else if (os_name.find("_64") != std::string::npos) {
        if (disable_acceleration) {
            vboxlog_msg("ERROR: Invalid configuration.  VM type requires acceleration but the current configuration cannot support it.");
            retval = ERR_INVALID_PARAM;
            goto CLEANUP;
        }
    }

    // Add storage controller to VM
    // See: http://www.virtualbox.org/manual/ch08.html#vboxmanage-storagectl
    // See: http://www.virtualbox.org/manual/ch05.html#iocaching
    //
    vboxlog_msg("Adding storage controller(s) to VM.");
    if (0 == stricmp(vm_disk_controller_type.c_str(), "ide")) {
        rc = pMachine->AddStorageController(CComBSTR("Hard Disk Controller"), StorageBus_IDE, &pDiskController);
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }
    if (0 == stricmp(vm_disk_controller_type.c_str(), "sata")) {
        rc = pMachine->AddStorageController(CComBSTR("Hard Disk Controller"), StorageBus_SATA, &pDiskController);
        if (CHECK_ERROR(rc)) goto CLEANUP;

        pDiskController->put_UseHostIOCache(FALSE);
        pDiskController->put_PortCount(3);
    }
    if (0 == stricmp(vm_disk_controller_type.c_str(), "sas")) {
        rc = pMachine->AddStorageController(CComBSTR("Hard Disk Controller"), StorageBus_SAS, &pDiskController);
        if (CHECK_ERROR(rc)) goto CLEANUP;

        pDiskController->put_UseHostIOCache(FALSE);
    }
    if (0 == stricmp(vm_disk_controller_type.c_str(), "scsi")) {
        rc = pMachine->AddStorageController(CComBSTR("Hard Disk Controller"), StorageBus_SCSI, &pDiskController);
        if (CHECK_ERROR(rc)) goto CLEANUP;

        pDiskController->put_UseHostIOCache(FALSE);
    }

    if (0 == stricmp(vm_disk_controller_model.c_str(), "lsilogic")) {
        pDiskController->put_ControllerType(StorageControllerType_LsiLogic);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "buslogic")) {
        pDiskController->put_ControllerType(StorageControllerType_BusLogic);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "intelahci")) {
        pDiskController->put_ControllerType(StorageControllerType_IntelAhci);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "piix3")) {
        pDiskController->put_ControllerType(StorageControllerType_PIIX3);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "piix4")) {
        pDiskController->put_ControllerType(StorageControllerType_PIIX4);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "ich6")) {
        pDiskController->put_ControllerType(StorageControllerType_ICH6);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "i82078")) {
        pDiskController->put_ControllerType(StorageControllerType_I82078);
    } else if (0 == stricmp(vm_disk_controller_model.c_str(), "lsilogicsas")) {
        pDiskController->put_ControllerType(StorageControllerType_LsiLogicSas);
    }

    // Add storage controller for a floppy device if desired
    //
    if (enable_floppyio) {
        rc = pMachine->AddStorageController(CComBSTR("Floppy Controller"), StorageBus_Floppy, &pFloppyController);
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }

    if (enable_isocontextualization) {
        // Add virtual ISO 9660 disk drive to VM
        //
        vboxlog_msg("Adding virtual ISO 9660 disk drive to VM. (%s)", iso_image_filename.c_str());
        CComPtr<IMedium> pISOImage;
        rc = m_pPrivate->m_pVirtualBox->OpenMedium(
            CComBSTR(string(virtual_machine_slot_directory + "\\" + iso_image_filename).c_str()),
            DeviceType_DVD,
            AccessMode_ReadOnly,
            TRUE,
            &pISOImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        rc = pMachine->AttachDevice(
            CComBSTR("Hard Disk Controller"),
            0,
            0,
            DeviceType_DVD,
            pISOImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        // Add guest additions to the VM
        //
        vboxlog_msg("Adding VirtualBox Guest Additions to VM.");
        CComPtr<IMedium> pGuestAdditionsImage;
        rc = m_pPrivate->m_pVirtualBox->OpenMedium(
            CComBSTR(virtualbox_guest_additions.c_str()),
            DeviceType_DVD,
            AccessMode_ReadOnly,
            FALSE,
            &pGuestAdditionsImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        rc = pMachine->AttachDevice(
            CComBSTR("Hard Disk Controller"),
            2,
            0,
            DeviceType_DVD,
            pGuestAdditionsImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        // Add a virtual cache disk drive to VM
        //
        if (enable_cache_disk){
            vboxlog_msg("Adding virtual cache disk drive to VM. (%s)", cache_disk_filename.c_str());
            CComPtr<IMedium> pCacheImage;
            rc = m_pPrivate->m_pVirtualBox->OpenMedium(
                CComBSTR(string(virtual_machine_slot_directory + "\\" + cache_disk_filename).c_str()),
                DeviceType_HardDisk,
                AccessMode_ReadWrite,
                TRUE,
                &pCacheImage
            );
            if (CHECK_ERROR(rc)) goto CLEANUP;

            rc = pMachine->AttachDevice(
                CComBSTR("Hard Disk Controller"),
                1,
                0,
                DeviceType_HardDisk,
                pCacheImage
            );
            if (CHECK_ERROR(rc)) goto CLEANUP;
        }
    } else {
        // Adding virtual hard drive to VM
        //
        vboxlog_msg("Adding virtual disk drive to VM. (%s)", image_filename.c_str());
        CComPtr<IMedium> pDiskImage;
        rc = m_pPrivate->m_pVirtualBox->OpenMedium(
            CComBSTR(string(virtual_machine_slot_directory + "\\" + image_filename).c_str()),
            DeviceType_HardDisk,
            AccessMode_ReadWrite,
            TRUE,
            &pDiskImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        rc = pMachine->AttachDevice(
            CComBSTR("Hard Disk Controller"),
            0,
            0,
            DeviceType_HardDisk,
            pDiskImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        // Add guest additions to the VM
        //
        vboxlog_msg("Adding VirtualBox Guest Additions to VM.");
        CComPtr<IMedium> pGuestAdditionsImage;
        rc = m_pPrivate->m_pVirtualBox->OpenMedium(
            CComBSTR(virtualbox_guest_additions.c_str()),
            DeviceType_DVD,
            AccessMode_ReadOnly,
            FALSE,
            &pGuestAdditionsImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        rc = pMachine->AttachDevice(
            CComBSTR("Hard Disk Controller"),
            1,
            0,
            DeviceType_DVD,
            pGuestAdditionsImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }

    // Adding virtual floppy disk drive to VM
    //
    if (enable_floppyio) {
        // Put in place the FloppyIO abstraction
        //
        // NOTE: This creates the floppy.img file at runtime for use by the VM.
        //
        pFloppy = new FloppyIONS::FloppyIO(floppy_image_filename.c_str());
        if (!pFloppy->ready()) {
            vboxlog_msg("Creating virtual floppy image failed.");
            vboxlog_msg("Error Code '%d' Error Message '%s'", pFloppy->error, pFloppy->errorStr.c_str());
            retval = ERR_FWRITE;
            goto CLEANUP;
        }

        vboxlog_msg("Adding virtual floppy disk drive to VM.");
        CComPtr<IMedium> pFloppyImage;
        rc = m_pPrivate->m_pVirtualBox->OpenMedium(
            CComBSTR(string(virtual_machine_slot_directory + "\\" + floppy_image_filename).c_str()),
            DeviceType_Floppy,
            AccessMode_ReadWrite,
            TRUE,
            &pFloppyImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;

        rc = pMachine->AttachDevice(
            CComBSTR("Floppy Controller"),
            0,
            0,
            DeviceType_Floppy,
            pFloppyImage
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }

    // Add network bandwidth throttle group
    //
    vboxlog_msg("Adding network bandwidth throttle group to VM. (Defaulting to 1024GB)");
    rc = pBandwidthControl->CreateBandwidthGroup(
        CComBSTR(string(vm_name + "_net").c_str()),
        BandwidthGroupType_Network,
        (LONG64)1024*1024*1024*1024
    );
    if (CHECK_ERROR(rc)) goto CLEANUP;

    // Configure port forwarding
    //
    if (enable_network) {
        if (pf_guest_port) {
            VBOX_PORT_FORWARD pf;
            pf.guest_port = pf_guest_port;
            pf.host_port = pf_host_port;
            if (!pf_host_port) {
                retval = boinc_get_port(false, pf.host_port);
                if (retval) return retval;
                pf_host_port = pf.host_port;
            }
            port_forwards.push_back(pf);
        }
        for (unsigned int i=0; i<port_forwards.size(); i++) {
            VBOX_PORT_FORWARD& pf = port_forwards[i];

            vboxlog_msg("forwarding host port %d to guest port %d", pf.host_port, pf.guest_port);

            // Add new firewall rule
            //
            rc = pNATEngine->AddRedirect(
                CComBSTR(""),
                NATProtocol_TCP,
                pf.is_remote?CComBSTR(""):CComBSTR("127.0.0.1"),
                pf.host_port,
                CComBSTR(""),
                pf.guest_port
            );
            if (CHECK_ERROR(rc)) goto CLEANUP;
        }
    }

    // If the VM wants to enable remote desktop for the VM do it here
    //
    if (enable_remotedesktop) {
        vboxlog_msg("Enabling remote desktop for VM.");
        if (!is_extpack_installed()) {
            vboxlog_msg("Required extension pack not installed, remote desktop not enabled.");
        } else {
            retval = boinc_get_port(false, rd_host_port);
            if (retval) goto CLEANUP;

            sprintf(buf, "%d", rd_host_port);

            pVRDEServer->put_Enabled(TRUE);
            pVRDEServer->put_VRDEExtPack(CComBSTR(""));
            pVRDEServer->put_AuthLibrary(CComBSTR(""));
            pVRDEServer->put_AuthType(AuthType_Null);
            pVRDEServer->SetVRDEProperty(CComBSTR("TCP/Ports"), CComBSTR(buf));
        }
    }

    // Enable the shared folder if a shared folder is specified.
    //
    if (enable_shared_directory) {
        vboxlog_msg("Enabling shared directory for VM.");
        rc = pMachine->CreateSharedFolder(
            CComBSTR("shared"),
            CComBSTR(string(virtual_machine_slot_directory + "\\shared").c_str()),
            TRUE,
            TRUE
        );
        if (CHECK_ERROR(rc)) goto CLEANUP;
    }

CLEANUP:
    if (pMachine) {
        pMachine->SaveSettings();
    }
    if (pSession) {
        pSession->UnlockMachine();
    }

    return retval;
}

int VBOX_VM::register_vm() {
    int retval = ERR_EXEC;
    HRESULT rc;
    string virtual_machine_slot_directory;
    APP_INIT_DATA aid;
    CComPtr<IMachine> pMachine;

    boinc_get_init_data_p(&aid);
    get_slot_directory(virtual_machine_slot_directory);


    vboxlog_msg("Register VM. (%s, slot#%d)", vm_master_name.c_str(), aid.slot);


    // Reset VM name in case it was changed while deregistering a stale VM
    //
    vm_name = vm_master_name;

    rc = m_pPrivate->m_pVirtualBox->OpenMachine(
        CComBSTR(string(virtual_machine_slot_directory + "\\" + vm_name + "\\" + vm_name + ".vbox").c_str()),
        &pMachine
    );
    if (CHECK_ERROR(rc)) goto CLEANUP;

    rc = m_pPrivate->m_pVirtualBox->RegisterMachine(pMachine);
    if (CHECK_ERROR(rc)) goto CLEANUP;

CLEANUP:
    return retval;
}

int VBOX_VM::deregister_vm(bool delete_media) {
    int retval = ERR_EXEC;
    HRESULT rc;
    SAFEARRAY* pHardDisks = NULL;
    SAFEARRAY* pEmptyHardDisks = NULL;
    SAFEARRAY* pMediumAttachments = NULL;
    CComSafeArray<LPDISPATCH> aMediumAttachments;
    CComSafeArray<LPDISPATCH> aHardDisks;
    CComPtr<ISession> pSession;
    CComPtr<IConsole> pConsole;
    CComPtr<IMachine> pMachineRO;
    CComPtr<IMachine> pMachine;
    CComPtr<IProgress> pProgress;
    CComPtr<IBandwidthControl> pBandwidthControl;
    CComPtr<ISnapshot> pRootSnapshot;
    std::vector<CComPtr<IMedium>> clean_mediums;
    std::vector<CComPtr<IMedium>> mediums;
    std::vector<std::string> snapshots;
    DeviceType device_type; 
    LONG lDevice;
    LONG lPort;
    string virtual_machine_slot_directory;
    APP_INIT_DATA aid;


    boinc_get_init_data_p(&aid);
    get_slot_directory(virtual_machine_slot_directory);


    vboxlog_msg("Deregistering VM. (%s, slot#%d)", vm_name.c_str(), aid.slot);


    rc = m_pPrivate->m_pVirtualBox->FindMachine(CComBSTR(vm_name.c_str()), &pMachineRO);
    if (SUCCEEDED(rc)) {
        if (delete_media) {
            rc = pSession.CoCreateInstance(CLSID_Session);
            CHECK_ERROR(rc);

            rc = pMachineRO->LockMachine(pSession, LockType_Write);
            CHECK_ERROR(rc);

            rc = pSession->get_Console(&pConsole);
            CHECK_ERROR(rc);

            rc = pSession->get_Machine(&pMachine);
            CHECK_ERROR(rc);


            // Delete snapshots
            //
            rc = pMachine->FindSnapshot(CComBSTR(""), &pRootSnapshot);
            if (SUCCEEDED(rc) && pRootSnapshot) {
                TraverseSnapshots(string(""), snapshots, pRootSnapshot);
            }
            if (snapshots.size()) {
                for (size_t i = 0; i < snapshots.size(); i++) {
                    CComPtr<IProgress> pProgress;
                    rc = pConsole->DeleteSnapshot(CComBSTR(snapshots[i].c_str()), &pProgress);
                    if (SUCCEEDED(rc)) {
                        pProgress->WaitForCompletion(-1);
                    } else {
                        CHECK_ERROR(rc);
                    }
                }
            }

            // Close Hard Disk, DVD, and floppy mediums
            //
           vboxlog_msg("Removing virtual disk drive(s) from VM.");
            rc = pMachine->get_MediumAttachments(&pMediumAttachments);
            if (SUCCEEDED(rc)) {
                aMediumAttachments.Attach(pMediumAttachments);
                for (int i = 0; i < (int)aMediumAttachments.GetCount(); i++) {
                    CComPtr<IMediumAttachment> pMediumAttachment((IMediumAttachment*)(LPDISPATCH)aMediumAttachments[i]);
                    rc = pMediumAttachment->get_Type(&device_type);
                    if (SUCCEEDED(rc) && 
                       ((DeviceType_HardDisk == device_type) ||
                        (DeviceType_DVD == device_type) ||
                        (DeviceType_Floppy == device_type))
                    ) {
                        CComPtr<IMedium> pMedium;
                        CComBSTR strController;

                        if ((DeviceType_HardDisk == device_type) || (DeviceType_DVD == device_type)) {
                            strController = "Hard Disk Controller";
                        } else {
                            strController = "Floppy Controller";
                        }

                        pMediumAttachment->get_Device(&lDevice);
                        pMediumAttachment->get_Port(&lPort);
                        pMediumAttachment->get_Medium(&pMedium);
                        
                        // If the device in question is a DVD/CD-ROM drive, the medium may have been ejected.
                        // If so, pMedium will be NULL.
                        if (pMedium) {
                            mediums.push_back(CComPtr<IMedium>(pMedium));
                        }
                        
                        rc = pMachine->DetachDevice(strController, lPort, lDevice);
                        CHECK_ERROR(rc);
                    }
                }
            }

            // Delete network bandwidth throttle group
            //
            vboxlog_msg("Removing network bandwidth throttle group from VM.");
            rc = pMachine->get_BandwidthControl(&pBandwidthControl);
            if (SUCCEEDED(rc)) {
                pBandwidthControl->DeleteBandwidthGroup(CComBSTR(string(vm_name + "_net").c_str()));
            }

            // Delete its storage controller(s)
            //
            vboxlog_msg("Removing storage controller(s) from VM.");
            pMachine->RemoveStorageController(CComBSTR("Hard Disk Controller"));
            if (enable_floppyio) {
                pMachine->RemoveStorageController(CComBSTR("Floppy Controller"));
            }

            // Save the VM Settings so the state is stored
            //
            rc = pMachine->SaveSettings();
            CHECK_ERROR(rc);

            // Now it should be safe to close down the mediums we detached.
            //
            for (int i = 0; i < (int)mediums.size(); i++) {
                mediums[i]->Close();
            }

            // Now free the session lock
            //
            rc = pSession->UnlockMachine();
            CHECK_ERROR(rc);
        }

        // Next, delete VM
        //
        vboxlog_msg("Removing VM from VirtualBox.");
        rc = pMachineRO->Unregister(CleanupMode_Full, &pHardDisks);
        if (SUCCEEDED(rc)) {

            // We only want to close(remove from media registry) the hard disks
            // instead of deleting them, order them by most recent image first
            // and then walk back to the root.
            //
            aHardDisks.Attach(pHardDisks);
            for (int i = 0; i < (int)aHardDisks.GetCount(); i++) {
                CComPtr<IMedium> pMedium((IMedium*)(LPDISPATCH)aHardDisks[i]);
                TraverseMediums(mediums, pMedium);
            }
            for (int i = 0; i < (int)mediums.size(); i++) {