VirtualBox

Changeset 33524 in vbox for trunk


Ignore:
Timestamp:
Oct 27, 2010 4:44:37 PM (14 years ago)
Author:
vboxsync
Message:

Storage: Implement offical support for other disk types like DVD and floppy images. DMG images can be used now without hacks

Location:
trunk
Files:
34 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxHDD-Plugin.h

    r32536 r33524  
    6161
    6262    /**
    63      * Pointer to a NULL-terminated array of strings, containing the supported
     63     * Pointer to a NULL-terminated array, containing the supported
    6464     * file extensions. Note that some backends do not work on files, so this
    6565     * pointer may just contain NULL.
    6666     */
    67     const char * const *papszFileExtensions;
     67    PCVDFILEEXTENSION paFileExtensions;
    6868
    6969    /**
    … …  
    8787     * @param   pVDIfsDisk      Pointer to the per-disk VD interface list.
    8888     * @param   pVDIfsImage     Pointer to the per-image VD interface list.
    89      */
    90     DECLR3CALLBACKMEMBER(int, pfnCheckIfValid, (const char *pszFilename, PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage));
     89     * @param   penmType        Returns the supported device type on success.
     90     */
     91    DECLR3CALLBACKMEMBER(int, pfnCheckIfValid, (const char *pszFilename, PVDINTERFACE pVDIfsDisk,
     92                                                PVDINTERFACE pVDIfsImage, VDTYPE *penmType));
    9193
    9294    /**
    … …  
    99101     * @param   pVDIfsDisk      Pointer to the per-disk VD interface list.
    100102     * @param   pVDIfsImage     Pointer to the per-image VD interface list.
     103     * @param   enmType         Requested type of the image.
    101104     * @param   ppBackendData   Opaque state data for this image.
    102105     */
    103106    DECLR3CALLBACKMEMBER(int, pfnOpen, (const char *pszFilename, unsigned uOpenFlags,
    104107                                        PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    105                                         void **ppBackendData));
     108                                        VDTYPE enmType, void **ppBackendData));
    106109
    107110    /**

  • trunk/include/VBox/VBoxHDD.h

    r33205 r33524  
    247247/** @}*/
    248248
     249/** @name VBox HDD container type.
     250 * @{
     251 */
     252typedef enum VDTYPE
     253{
     254    /** Invalid. */
     255    VDTYPE_INVALID = 0,
     256    /** HardDisk */
     257    VDTYPE_HDD,
     258    /** CD/DVD */
     259    VDTYPE_DVD,
     260    /** Floppy. */
     261    VDTYPE_FLOPPY
     262} VDTYPE;
     263/** @}*/
     264
    249265/**
    250266 * Supported interface types.
    … …  
    15291545
    15301546/**
     1547 * Structure describing a file extension.
     1548 */
     1549typedef struct VDFILEEXTENSION
     1550{
     1551    /** Pointer to the NULL-terminated string containing the extension. */
     1552    const char *pszExtension;
     1553    /** The device type the extension supports. */
     1554    VDTYPE      enmType;
     1555} VDFILEEXTENSION;
     1556
     1557/** Pointer to a structure describing a file extension. */
     1558typedef VDFILEEXTENSION *PVDFILEEXTENSION;
     1559
     1560/** Pointer to a const structure describing a file extension. */
     1561typedef const VDFILEEXTENSION *PCVDFILEEXTENSION;
     1562
     1563/**
    15311564 * Data structure for returning a list of backend capabilities.
    15321565 */
    … …  
    15401573     * file extensions. Note that some backends do not work on files, so this
    15411574     * pointer may just contain NULL. */
    1542     const char * const *papszFileExtensions;
     1575    PCVDFILEEXTENSION paFileExtensions;
    15431576    /** Pointer to an array of structs describing each supported config key.
    15441577     * Terminated by a NULL config key. Note that some backends do not support
    … …  
    20002033 * @return  VBox status code.
    20012034 * @param   pVDIfsDisk      Pointer to the per-disk VD interface list.
     2035 * @param   enmType         Type of the image container.
    20022036 * @param   ppDisk          Where to store the reference to HDD container.
    20032037 */
    2004 VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, PVBOXHDD *ppDisk);
     2038VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, VDTYPE enmType, PVBOXHDD *ppDisk);
    20052039
    20062040/**
    … …  
    20242058 * @param   ppszFormat      Receives pointer of the UTF-8 string which contains the format name.
    20252059 *                          The returned pointer must be freed using RTStrFree().
     2060 * @param   penmType        Where to store the type of the image.
    20262061 */
    20272062VBOXDDU_DECL(int) VDGetFormat(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    2028                               const char *pszFilename, char **ppszFormat);
     2063                              const char *pszFilename, char **ppszFormat, VDTYPE *penmType);
    20292064
    20302065/**

  • trunk/include/VBox/settings.h

    r33386 r33524  
    185185                               const USBDeviceFiltersList &ll,
    186186                               bool fHostMode);
    187     void buildHardDisk(xml::ElementNode &elmMedium,
    188                        const Medium &m,
    189                        uint32_t level);
     187    void buildMedium(xml::ElementNode &elmMedium,
     188                     DeviceType_T devType,
     189                     const Medium &m,
     190                     uint32_t level);
    190191    void buildMediaRegistry(xml::ElementNode &elmParent,
    191192                            const MediaRegistry &mr);

  • trunk/src/VBox/Devices/Storage/DMGHDDCore.cpp

    r33479 r33524  
    407407
    408408/** NULL-terminated array of supported file extensions. */
    409 static const char *const s_apszDmgFileExtensions[] =
    410 {
    411     "dmg",
    412     NULL
     409static const VDFILEEXTENSION s_aDmgFileExtensions[] =
     410{
     411    {"dmg", VDTYPE_DVD},
     412    {NULL, VDTYPE_INVALID}
    413413};
    414414
    … …  
    15921592/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    15931593static int dmgCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    1594                            PVDINTERFACE pVDIfsImage)
    1595 {
    1596     LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
     1594                           PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
     1595{
     1596    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p penmType=%#p\n",
     1597                 pszFilename, pVDIfsDisk, pVDIfsImage, penmType));
    15971598    int rc;
    15981599    PVDIOSTORAGE pStorage;
    … …  
    16391640        {
    16401641            if (dmgUdifFtrIsValid(&Ftr, offFtr))
     1642            {
    16411643                rc = VINF_SUCCESS;
     1644                *penmType = VDTYPE_DVD;
     1645            }
    16421646            else
    16431647            {
    … …  
    16591663static int dmgOpen(const char *pszFilename, unsigned uOpenFlags,
    16601664                   PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    1661                    void **ppBackendData)
     1665                   VDTYPE enmType, void **ppBackendData)
    16621666{
    16631667    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    … …  
    21362140{
    21372141    LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
    2138     PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
     2142    PDMGIMAGE pImage = (PDMGIMAGE)pBackendData;
    21392143    int rc;
    21402144
    2141     AssertPtr(pThis);
    2142 
    2143     if (pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    2144     {
    2145         rc = VERR_VD_IMAGE_READ_ONLY;
    2146         goto out;
    2147     }
    2148 
    2149     if (pThis)
    2150         rc = VERR_NOT_SUPPORTED;
     2145    AssertPtr(pImage);
     2146
     2147    if (pImage)
     2148    {
     2149        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
     2150            rc = VERR_VD_IMAGE_READ_ONLY;
     2151        else
     2152            rc = VERR_NOT_SUPPORTED;
     2153    }
    21512154    else
    21522155        rc = VERR_VD_NOT_OPENED;
    … …  
    23462349    /* uBackendCaps */
    23472350    VD_CAP_FILE | VD_CAP_VFS,
    2348     /* papszFileExtensions */
    2349     s_apszDmgFileExtensions,
     2351    /* paFileExtensions */
     2352    s_aDmgFileExtensions,
    23502353    /* paConfigInfo */
    23512354    NULL,

  • trunk/src/VBox/Devices/Storage/DrvVD.cpp

    r33218 r33524  
    20042004    unsigned    iLevel = 0;
    20052005    PCFGMNODE   pCurNode = pCfg;
     2006    VDTYPE      enmType = VDTYPE_HDD;
    20062007
    20072008    for (;;)
    … …  
    20172018                                          "ReadOnly\0MaybeReadOnly\0TempReadOnly\0Shareable\0HonorZeroWrites\0"
    20182019                                          "HostIPStack\0UseNewIo\0BootAcceleration\0BootAccelerationBuffer\0"
    2019                                           "SetupMerge\0MergeSource\0MergeTarget\0BwGroup\0");
     2020                                          "SetupMerge\0MergeSource\0MergeTarget\0BwGroup\0Type\0");
    20202021        }
    20212022        else
    … …  
    21322133            else
    21332134                rc = VINF_SUCCESS;
     2135
     2136            char *psz;
     2137            rc = CFGMR3QueryStringAlloc(pCfg, "Type", &psz);
     2138            if (RT_FAILURE(rc))
     2139            {
     2140                rc = PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_BLOCK_NO_TYPE, N_("Failed to obtain the type"));
     2141                break;
     2142            }
     2143            else if (!strcmp(psz, "HardDisk"))
     2144                enmType = VDTYPE_HDD;
     2145            else if (!strcmp(psz, "DVD"))
     2146                enmType = VDTYPE_DVD;
     2147            else if (!strcmp(psz, "Floppy"))
     2148                enmType = VDTYPE_FLOPPY;
     2149            else
     2150            {
     2151                rc = PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_BLOCK_UNKNOWN_TYPE, RT_SRC_POS,
     2152                                         N_("Unknown type \"%s\""), psz);
     2153                MMR3HeapFree(psz);
     2154                break;
     2155            }
     2156            MMR3HeapFree(psz); psz = NULL;
    21342157        }
    21352158
    … …  
    22702293        if (RT_SUCCESS(rc))
    22712294        {
    2272             rc = VDCreate(pThis->pVDIfsDisk, &pThis->pDisk);
     2295            rc = VDCreate(pThis->pVDIfsDisk, enmType, &pThis->pDisk);
    22732296            /* Error message is already set correctly. */
    22742297        }

  • trunk/src/VBox/Devices/Storage/ISCSIHDDCore.cpp

    r33182 r33524  
    43694369/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    43704370static int iscsiCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    4371                              PVDINTERFACE pVDIfsImage)
     4371                             PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
    43724372{
    43734373    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
    … …  
    43844384static int iscsiOpen(const char *pszFilename, unsigned uOpenFlags,
    43854385                     PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    4386                      void **ppBackendData)
     4386                     VDTYPE enmType, void **ppBackendData)
    43874387{
    43884388    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));

  • trunk/src/VBox/Devices/Storage/ParallelsHDDCore.cpp

    r33258 r33524  
    105105
    106106/** NULL-terminated array of supported file extensions. */
    107 static const char *const s_apszParallelsFileExtensions[] =
    108 {
    109     "hdd",
    110     NULL
     107static const VDFILEEXTENSION s_aParallelsFileExtensions[] =
     108{
     109    {"hdd", VDTYPE_HDD},
     110    {NULL, VDTYPE_INVALID}
    111111};
    112112
    … …  
    415415/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    416416static int parallelsCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    417                                  PVDINTERFACE pVDIfsImage)
     417                                 PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
    418418{
    419419    int rc;
    … …  
    471471    }
    472472
     473    if (RT_SUCCESS(rc))
     474        *penmType = VDTYPE_HDD;
     475
    473476    pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
    474477    return rc;
    … …  
    478481static int parallelsOpen(const char *pszFilename, unsigned uOpenFlags,
    479482                         PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    480                          void **ppBackendData)
     483                         VDTYPE enmType, void **ppBackendData)
    481484{
    482485    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    … …  
    10011004    AssertPtr(pImage);
    10021005
    1003     if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    1004     {
    1005         rc = VERR_VD_IMAGE_READ_ONLY;
    1006         goto out;
    1007     }
    1008 
    1009     if (pImage)
    1010         rc = VERR_NOT_SUPPORTED;
     1006    if (pImage)
     1007    {
     1008        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
     1009            rc = VERR_VD_IMAGE_READ_ONLY;
     1010        else
     1011            rc = VERR_NOT_SUPPORTED;
     1012    }
    10111013    else
    10121014        rc = VERR_VD_NOT_OPENED;
    … …  
    13571359    /* uBackendCaps */
    13581360    VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS,
    1359     /* papszFileExtensions */
    1360     s_apszParallelsFileExtensions,
     1361    /* paFileExtensions */
     1362    s_aParallelsFileExtensions,
    13611363    /* paConfigInfo */
    13621364    NULL,

  • trunk/src/VBox/Devices/Storage/RawHDDCore.cpp

    r33234 r33524  
    2626#include <iprt/assert.h>
    2727#include <iprt/alloc.h>
    28 
     28#include <iprt/path.h>
    2929
    3030/*******************************************************************************
    3131*   Constants And Macros, Structures and Typedefs                              *
    3232*******************************************************************************/
     33/**
     34 * ISO volume descriptor.
     35 */
     36#pragma pack(1)
     37typedef struct ISOVOLDESC
     38{
     39    union
     40    {
     41        /** Byte view. */
     42        uint8_t au8[2048];
     43        /** Field view. */
     44        struct
     45        {
     46            /** Descriptor type. */
     47            uint8_t u8Type;
     48            /** Standard identifier */
     49            uint8_t au8Id[5];
     50            /** Descriptor version. */
     51            uint8_t u8Version;
     52            /** Rest depends on the descriptor type. */
     53        } fields;
     54    };
     55} ISOVOLDESC, *PISOVOLDESC;
     56#pragma pack()
     57AssertCompileSize(ISOVOLDESC, 2048);
    3358
    3459/**
    … …  
    82107
    83108/** NULL-terminated array of supported file extensions. */
    84 static const char *const s_apszRawFileExtensions[] =
    85 {
    86     /** @todo At the moment this backend doesn't claim any extensions, but it might
    87      * be useful to add a few later. However this needs careful testing, as the
    88      * CheckIfValid function never returns success. */
    89     NULL
     109static const VDFILEEXTENSION s_aRawFileExtensions[] =
     110{
     111    {"iso", VDTYPE_DVD},
     112    {"img", VDTYPE_FLOPPY},
     113    {"ima", VDTYPE_FLOPPY},
     114    {NULL, VDTYPE_INVALID}
    90115};
    91116
    … …  
    484509/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    485510static int rawCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    486                            PVDINTERFACE pVDIfsImage)
    487 {
    488     LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
     511                           PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
     512{
     513    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
     514    PVDIOSTORAGE pStorage = NULL;
     515    uint64_t cbFile;
    489516    int rc = VINF_SUCCESS;
     517    ISOVOLDESC IsoVolDesc;
     518    char *pszExtension = NULL;
     519
     520    /* Get I/O interface. */
     521    PVDINTERFACE pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT);
     522    AssertPtrReturn(pInterfaceIO, VERR_INVALID_PARAMETER);
     523    PVDINTERFACEIOINT pInterfaceIOCallbacks = VDGetInterfaceIOInt(pInterfaceIO);
     524    AssertPtrReturn(pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
    490525
    491526    if (   !VALID_PTR(pszFilename)
    … …  
    496531    }
    497532
    498     /* Always return failure, to avoid opening everything as a raw image. */
    499     rc = VERR_VD_RAW_INVALID_HEADER;
     533    pszExtension = RTPathExt(pszFilename);
     534
     535    /*
     536     * Open the file and read the footer.
     537     */
     538    rc = pInterfaceIOCallbacks->pfnOpen(pInterfaceIO->pvUser, pszFilename,
     539                                        VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
     540                                                                   false /* fCreate */),
     541                                        &pStorage);
     542    if (RT_SUCCESS(rc))
     543        rc = pInterfaceIOCallbacks->pfnGetSize(pInterfaceIO->pvUser, pStorage,
     544                                               &cbFile);
     545
     546    /* Try to guess the image type based on the extension. */
     547    if (   RT_SUCCESS(rc)
     548        && pszExtension)
     549    {
     550        if (!strcmp(pszExtension, ".iso")) /* DVD images. */
     551        {
     552            if (cbFile >= (32768 + sizeof(ISOVOLDESC)))
     553            {
     554                rc = pInterfaceIOCallbacks->pfnReadSync(pInterfaceIO->pvUser, pStorage,
     555                                                        32768, &IsoVolDesc, sizeof(IsoVolDesc), NULL);
     556            }
     557            else
     558                rc = VERR_VD_RAW_INVALID_HEADER;
     559
     560            if (RT_SUCCESS(rc))
     561            {
     562                /*
     563                 * Do we recognize this stuff?
     564                 */
     565                if (   !memcmp(IsoVolDesc.fields.au8Id, "BEA01", 5)
     566                    || !memcmp(IsoVolDesc.fields.au8Id, "BOOT2", 5)
     567                    || !memcmp(IsoVolDesc.fields.au8Id, "CD001", 5)
     568                    || !memcmp(IsoVolDesc.fields.au8Id, "CDW02", 5)
     569                    || !memcmp(IsoVolDesc.fields.au8Id, "NSR02", 5)
     570                    || !memcmp(IsoVolDesc.fields.au8Id, "NSR03", 5)
     571                    || !memcmp(IsoVolDesc.fields.au8Id, "TEA01", 5))
     572                {
     573                    *penmType = VDTYPE_DVD;
     574                    rc = VINF_SUCCESS;
     575                }
     576                else
     577                    rc = VERR_VD_RAW_INVALID_HEADER;
     578            }
     579        }
     580        else if (!strcmp(pszExtension, ".img") || !strcmp(pszExtension, ".ima")) /* Floppy images */
     581        {
     582            if (!(cbFile % 512))
     583            {
     584                *penmType = VDTYPE_FLOPPY;
     585                rc = VINF_SUCCESS;
     586            }
     587            else
     588                rc = VERR_VD_RAW_INVALID_HEADER;
     589        }
     590    }
     591    else
     592        rc = VERR_VD_RAW_INVALID_HEADER;
     593
     594    if (pStorage)
     595        pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
    500596
    501597out:
    … …  
    507603static int rawOpen(const char *pszFilename, unsigned uOpenFlags,
    508604                   PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    509                    void **ppBackendData)
     605                   VDTYPE enmType, void **ppBackendData)
    510606{
    511607    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    … …  
    10401136    AssertPtr(pImage);
    10411137
    1042     if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    1043     {
    1044         rc = VERR_VD_IMAGE_READ_ONLY;
    1045         goto out;
    1046     }
    1047 
    1048     if (pImage)
    1049         rc = VERR_NOT_SUPPORTED;
     1138    if (pImage)
     1139    {
     1140        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
     1141            rc = VERR_VD_IMAGE_READ_ONLY;
     1142        else
     1143            rc = VERR_NOT_SUPPORTED;
     1144    }
    10501145    else
    10511146        rc = VERR_VD_NOT_OPENED;
    … …  
    12921387{
    12931388    /* pszBackendName */
    1294     "raw",
     1389    "RAW",
    12951390    /* cbSize */
    12961391    sizeof(VBOXHDDBACKEND),
    12971392    /* uBackendCaps */
    12981393    VD_CAP_CREATE_FIXED | VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS,
    1299     /* papszFileExtensions */
    1300     s_apszRawFileExtensions,
     1394    /* paFileExtensions */
     1395    s_aRawFileExtensions,
    13011396    /* paConfigInfo */
    13021397    NULL,

  • trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

    r33495 r33524  
    156156    /** Structure signature (VBOXHDDDISK_SIGNATURE). */
    157157    uint32_t            u32Signature;
     158
     159    /** Image type. */
     160    VDTYPE              enmType;
    158161
    159162    /** Number of opened images. */
    … …  
    440443extern VBOXHDDBACKEND g_VhdBackend;
    441444extern VBOXHDDBACKEND g_ParallelsBackend;
    442 #ifdef VBOX_WITH_DMG
    443445extern VBOXHDDBACKEND g_DmgBackend;
    444 #endif
    445446#ifdef VBOX_WITH_ISCSI
    446447extern VBOXHDDBACKEND g_ISCSIBackend;
    … …  
    451452static PVBOXHDDBACKEND aStaticBackends[] =
    452453{
    453     &g_RawBackend,
    454454    &g_VmdkBackend,
    455455    &g_VDIBackend,
    456456    &g_VhdBackend,
    457     &g_ParallelsBackend
    458 #ifdef VBOX_WITH_DMG
    459     ,&g_DmgBackend
    460 #endif
     457    &g_ParallelsBackend,
     458    &g_DmgBackend,
     459    &g_RawBackend
    461460#ifdef VBOX_WITH_ISCSI
    462461    ,&g_ISCSIBackend
    … …  
    35843583        pEntries[i].pszBackend = g_apBackends[i]->pszBackendName;
    35853584        pEntries[i].uBackendCaps = g_apBackends[i]->uBackendCaps;
    3586         pEntries[i].papszFileExtensions = g_apBackends[i]->papszFileExtensions;
     3585        pEntries[i].paFileExtensions = g_apBackends[i]->paFileExtensions;
    35873586        pEntries[i].paConfigInfo = g_apBackends[i]->paConfigInfo;
    35883587        pEntries[i].pfnComposeLocation = g_apBackends[i]->pfnComposeLocation;
    … …  
    36223621            pEntry->pszBackend = g_apBackends[i]->pszBackendName;
    36233622            pEntry->uBackendCaps = g_apBackends[i]->uBackendCaps;
    3624             pEntry->papszFileExtensions = g_apBackends[i]->papszFileExtensions;
     3623            pEntry->paFileExtensions = g_apBackends[i]->paFileExtensions;
    36253624            pEntry->paConfigInfo = g_apBackends[i]->paConfigInfo;
    36263625            return VINF_SUCCESS;
    … …  
    36373636 * @returns VBox status code.
    36383637 * @param   pVDIfsDisk      Pointer to the per-disk VD interface list.
     3638 * @param   enmType         Type of the image container.
    36393639 * @param   ppDisk          Where to store the reference to HDD container.
    36403640 */
    3641 VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, PVBOXHDD *ppDisk)
     3641VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, VDTYPE enmType, PVBOXHDD *ppDisk)
    36423642{
    36433643    int rc = VINF_SUCCESS;
    … …  
    36563656        {
    36573657            pDisk->u32Signature = VBOXHDDDISK_SIGNATURE;
     3658            pDisk->enmType      = enmType;
    36583659            pDisk->cImages      = 0;
    36593660            pDisk->pBase        = NULL;
    … …  
    38093810 */
    38103811VBOXDDU_DECL(int) VDGetFormat(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    3811                               const char *pszFilename, char **ppszFormat)
     3812                              const char *pszFilename, char **ppszFormat, VDTYPE *penmType)
    38123813{
    38133814    int rc = VERR_NOT_SUPPORTED;
    … …  
    38253826    AssertMsgReturn(VALID_PTR(ppszFormat),
    38263827                    ("ppszFormat=%#p\n", ppszFormat),
     3828                    VERR_INVALID_PARAMETER);
     3829    AssertMsgReturn(VALID_PTR(ppszFormat),
     3830                    ("penmType=%#p\n", penmType),
    38273831                    VERR_INVALID_PARAMETER);
    38283832
    … …  
    38863890        {
    38873891            rc = g_apBackends[i]->pfnCheckIfValid(pszFilename, pVDIfsDisk,
    3888                                                   pVDIfsImage);
     3892                                                  pVDIfsImage, penmType);
    38893893            if (    RT_SUCCESS(rc)
    38903894                /* The correct backend has been found, but there is a small
    … …  
    40484052                                      pDisk->pVDIfsDisk,
    40494053                                      pImage->pVDIfsImage,
     4054                                      pDisk->enmType,
    40504055                                      &pImage->pBackendData);
    40514056        /* If the open in read-write mode failed, retry in read-only mode. */
    … …  
    40634068                                               pDisk->pVDIfsDisk,
    40644069                                               pImage->pVDIfsImage,
     4070                                               pDisk->enmType,
    40654071                                               &pImage->pBackendData);
    40664072            if (RT_FAILURE(rc))
    … …  
    71867192        pBackendInfo->pszBackend = pImage->Backend->pszBackendName;
    71877193        pBackendInfo->uBackendCaps = pImage->Backend->uBackendCaps;
    7188         pBackendInfo->papszFileExtensions = pImage->Backend->papszFileExtensions;
     7194        pBackendInfo->paFileExtensions = pImage->Backend->paFileExtensions;
    71897195        pBackendInfo->paConfigInfo = pImage->Backend->paConfigInfo;
    71907196    } while (0);

  • trunk/src/VBox/Devices/Storage/VCICacheCore.cpp

    r33522 r33524  
    19011901    AssertPtr(pCache);
    19021902
    1903     if (pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    1904     {
    1905         rc = VERR_VD_IMAGE_READ_ONLY;
    1906         goto out;
    1907     }
    1908 
    19091903    if (pCache)
    1910         rc = VERR_NOT_SUPPORTED;
     1904    {
     1905        if (pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY)
     1906            rc = VERR_VD_IMAGE_READ_ONLY;
     1907        else
     1908            rc = VERR_NOT_SUPPORTED;
     1909    }
    19111910    else
    19121911        rc = VERR_VD_NOT_OPENED;

  • trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp

    r33478 r33524  
    3838
    3939/** NULL-terminated array of supported file extensions. */
    40 static const char *const s_apszVdiFileExtensions[] =
    41 {
    42     "vdi",
    43     NULL
     40static const VDFILEEXTENSION s_aVdiFileExtensions[] =
     41{
     42    {"vdi", VDTYPE_HDD},
     43    {NULL, VDTYPE_INVALID}
    4444};
    4545
    … …  
    999999/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    10001000static int vdiCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    1001                            PVDINTERFACE pVDIfsImage)
     1001                           PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
    10021002{
    10031003    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
    … …  
    10281028    RTMemFree(pImage);
    10291029
     1030    if (RT_SUCCESS(rc))
     1031        *penmType = VDTYPE_HDD;
     1032
    10301033out:
    10311034    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    10361039static int vdiOpen(const char *pszFilename, unsigned uOpenFlags,
    10371040                   PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    1038                    void **ppBackendData)
     1041                   VDTYPE enmType, void **ppBackendData)
    10391042{
    10401043    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    … …  
    17011704    AssertPtr(pImage);
    17021705
    1703     if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    1704     {
    1705         rc = VERR_VD_IMAGE_READ_ONLY;
    1706         goto out;
    1707     }
    1708 
    17091706    if (pImage)
    17101707    {
    1711         size_t cchComment = pszComment ? strlen(pszComment) : 0;
    1712         if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
    1713         {
    1714             LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
    1715             rc = VERR_VD_VDI_COMMENT_TOO_LONG;
    1716             goto out;
    1717         }
    1718 
    1719         /* we don't support old style images */
    1720         if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
    1721         {
    1722             /*
    1723              * Update the comment field, making sure to zero out all of the previous comment.
    1724              */
    1725             memset(pImage->Header.u.v1.szComment, '\0', VDI_IMAGE_COMMENT_SIZE);
    1726             memcpy(pImage->Header.u.v1.szComment, pszComment, cchComment);
    1727 
    1728             /* write out new the header */
    1729             rc = vdiUpdateHeader(pImage);
    1730         }
     1708        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
     1709            rc = VERR_VD_IMAGE_READ_ONLY;
    17311710        else
    1732             rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
     1711        {
     1712            size_t cchComment = pszComment ? strlen(pszComment) : 0;
     1713            if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
     1714            {
     1715                LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
     1716                rc = VERR_VD_VDI_COMMENT_TOO_LONG;
     1717                goto out;
     1718            }
     1719
     1720            /* we don't support old style images */
     1721            if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
     1722            {
     1723                /*
     1724                 * Update the comment field, making sure to zero out all of the previous comment.
     1725                 */
     1726                memset(pImage->Header.u.v1.szComment, '\0', VDI_IMAGE_COMMENT_SIZE);
     1727                memcpy(pImage->Header.u.v1.szComment, pszComment, cchComment);
     1728
     1729                /* write out new the header */
     1730                rc = vdiUpdateHeader(pImage);
     1731            }
     1732            else
     1733                rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
     1734        }
    17331735    }
    17341736    else
    … …  
    26572659      VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
    26582660    | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS,
    2659     /* papszFileExtensions */
    2660     s_apszVdiFileExtensions,
     2661    /* paFileExtensions */
     2662    s_aVdiFileExtensions,
    26612663    /* paConfigInfo */
    26622664    NULL,

  • trunk/src/VBox/Devices/Storage/VHDHDDCore.cpp

    r33495 r33524  
    241241
    242242/** NULL-terminated array of supported file extensions. */
    243 static const char *const s_apszVhdFileExtensions[] =
    244 {
    245     "vhd",
    246     NULL
     243static const VDFILEEXTENSION s_aVhdFileExtensions[] =
     244{
     245    {"vhd", VDTYPE_HDD},
     246    {NULL, VDTYPE_INVALID}
    247247};
    248248
    … …  
    13801380/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    13811381static int vhdCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    1382                            PVDINTERFACE pVDIfsImage)
     1382                           PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
    13831383{
    13841384    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
    … …  
    14161416        rc = VERR_VD_VHD_INVALID_HEADER;
    14171417    else
     1418    {
     1419        *penmType = VDTYPE_HDD;
    14181420        rc = VINF_SUCCESS;
     1421    }
    14191422
    14201423    pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
    … …  
    14281431static int vhdOpen(const char *pszFilename, unsigned uOpenFlags,
    14291432                   PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    1430                    void **ppBackendData)
     1433                   VDTYPE enmType, void **ppBackendData)
    14311434{
    14321435    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    … …  
    21372140    AssertPtr(pImage);
    21382141
    2139     if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
    2140     {
    2141         rc = VERR_VD_IMAGE_READ_ONLY;
    2142         goto out;
    2143     }
    2144 
    21452142    if (pImage)
    2146         rc = VERR_NOT_SUPPORTED;
     2143    {
     2144        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
     2145            rc = VERR_VD_IMAGE_READ_ONLY;
     2146        else
     2147            rc = VERR_NOT_SUPPORTED;
     2148    }
    21472149    else
    21482150        rc = VERR_VD_NOT_OPENED;
    … …  
    30203022    VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC |
    30213023    VD_CAP_ASYNC | VD_CAP_VFS,
    3022     /* papszFileExtensions */
    3023     s_apszVhdFileExtensions,
     3024    /* paFileExtensions */
     3025    s_aVhdFileExtensions,
    30243026    /* paConfigInfo */
    30253027    NULL,

  • trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp

    r33493 r33524  
    514514
    515515/** NULL-terminated array of supported file extensions. */
    516 static const char *const s_apszVmdkFileExtensions[] =
    517 {
    518     "vmdk",
    519     NULL
     516static const VDFILEEXTENSION s_aVmdkFileExtensions[] =
     517{
     518    {"vmdk", VDTYPE_HDD},
     519    {NULL, VDTYPE_INVALID}
    520520};
    521521
    … …  
    57045704/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
    57055705static int vmdkCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
    5706                             PVDINTERFACE pVDIfsImage)
    5707 {
    5708     LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
     5706                            PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
     5707{
     5708    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p penmType=%#p\n",
     5709                 pszFilename, pVDIfsDisk, pVDIfsImage, penmType));
    57095710    int rc = VINF_SUCCESS;
    57105711    PVMDKIMAGE pImage;
    … …  
    57385739    RTMemFree(pImage);
    57395740
     5741    if (RT_SUCCESS(rc))
     5742        *penmType = VDTYPE_HDD;
     5743
    57405744out:
    57415745    LogFlowFunc(("returns %Rrc\n", rc));
    … …  
    57465750static int vmdkOpen(const char *pszFilename, unsigned uOpenFlags,
    57475751                    PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
    5748                     void **ppBackendData)
     5752                    VDTYPE enmType, void **ppBackendData)
    57495753{
    57505754    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    … …  
    73227326    | VD_CAP_CREATE_SPLIT_2G | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC
    73237327    | VD_CAP_VFS,
    7324     /* papszFileExtensions */
    7325     s_apszVmdkFileExtensions,
     7328    /* paFileExtensions */
     7329    s_aVmdkFileExtensions,
    73267330    /* paConfigInfo */
    73277331    NULL,

  • trunk/src/VBox/Devices/Storage/testcase/tstVD-2.cpp

    r28800 r33524  
    8686};
    8787
     88static const char *tstVDDeviceType(VDTYPE enmType)
     89{
     90    switch (enmType)
     91    {
     92        case VDTYPE_HDD:
     93            return "HardDisk";
     94        case VDTYPE_DVD:
     95            return "DVD";
     96        case VDTYPE_FLOPPY:
     97            return "Floppy";
     98        default:
     99            return "Unknown";
     100    }
     101}
     102
    88103static int tstVDBackendInfo(void)
    89104{
    … …  
    108123        RTPrintf("Backend %u: name=%s capabilities=%#06x extensions=",
    109124                 i, aVDInfo[i].pszBackend, aVDInfo[i].uBackendCaps);
    110         if (aVDInfo[i].papszFileExtensions)
    111         {
    112             const char *const *papsz = aVDInfo[i].papszFileExtensions;
    113             while (*papsz != NULL)
    114             {
    115                 if (papsz != aVDInfo[i].papszFileExtensions)
     125        if (aVDInfo[i].paFileExtensions)
     126        {
     127            PCVDFILEEXTENSION pa = aVDInfo[i].paFileExtensions;
     128            while (pa->pszExtension != NULL)
     129            {
     130                if (pa != aVDInfo[i].paFileExtensions)
    116131                    RTPrintf(",");
    117                 RTPrintf("%s", *papsz);
    118                 papsz++;
    119             }
    120             if (papsz == aVDInfo[i].papszFileExtensions)
     132                RTPrintf("%s (%s)", pa->pszExtension, tstVDDeviceType(pa->enmType));
     133                pa++;
     134            }
     135            if (pa == aVDInfo[i].paFileExtensions)
    121136                RTPrintf("<EMPTY>");
    122137        }

  • trunk/src/VBox/Devices/Storage/testcase/tstVD.cpp

    r33083 r33524  
    9292    AssertRC(rc);
    9393
    94     rc = VDCreate(&VDIError, &pVD);
     94    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    9595    CHECK("VDCreate()");
    9696
    … …  
    150150    AssertRC(rc);
    151151
    152     rc = VDCreate(&VDIError, &pVD);
     152    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    153153    CHECK("VDCreate()");
    154154
    … …  
    505505    PVBOXHDD pVD = NULL;
    506506    char *pszFormat;
     507    VDTYPE enmType = VDTYPE_INVALID;
    507508    VDGEOMETRY PCHS = { 0, 0, 0 };
    508509    VDGEOMETRY LCHS = { 0, 0, 0 };
    … …  
    539540
    540541
    541     rc = VDCreate(&VDIError, &pVD);
     542    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    542543    CHECK("VDCreate()");
    543544
    … …  
    548549        RTFileClose(File);
    549550        rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    550                          pszBaseFilename, &pszFormat);
     551                         pszBaseFilename, &pszFormat, &enmType);
    551552        RTPrintf("VDGetFormat() pszFormat=%s rc=%Rrc\n", pszFormat, rc);
    552553        if (RT_SUCCESS(rc) && strcmp(pszFormat, pszBackend))
    … …  
    664665
    665666
    666     rc = VDCreate(&VDIError, &pVD);
     667    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    667668    CHECK("VDCreate()");
    668669
    … …  
    738739    AssertRC(rc);
    739740
    740     rc = VDCreate(&VDIError, &pVD);
     741    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    741742    CHECK("VDCreate()");
    742743
    … …  
    789790    AssertRC(rc);
    790791
    791     rc = VDCreate(&VDIError, &pVD);
     792    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    792793    CHECK("VDCreate()");
    793794

  • trunk/src/VBox/Devices/Storage/testcase/tstVDCopy.cpp

    r32536 r33524  
    7070    char *pbBuf1 = NULL;
    7171    char *pbBuf2 = NULL;
     72    VDTYPE enmTypeVD1 = VDTYPE_INVALID;
     73    VDTYPE enmTypeVD2 = VDTYPE_INVALID;
    7274
    7375#define CHECK(str) \
    … …  
    98100
    99101    rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    100                      argv[1], &pszVD1);
     102                     argv[1], &pszVD1, &enmTypeVD1);
    101103    CHECK("VDGetFormat() hdd1");
    102104
    103105    rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    104                      argv[2], &pszVD2);
     106                     argv[2], &pszVD2, &enmTypeVD2);
    105107    CHECK("VDGetFormat() hdd2");
    106108
    107     rc = VDCreate(&VDIError, &pVD1);
     109    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD1);
    108110    CHECK("VDCreate() hdd1");
    109111
    110     rc = VDCreate(&VDIError, &pVD2);
     112    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD2);
    111113    CHECK("VDCreate() hdd1");
    112114

  • trunk/src/VBox/Devices/Storage/testcase/tstVDShareable.cpp

    r32536 r33524  
    9292    AssertRC(rc);
    9393
    94     rc = VDCreate(&VDIError, &pVD);
     94    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD);
    9595    CHECK("VDCreate()");
    96     rc = VDCreate(&VDIError, &pVD2);
     96    rc = VDCreate(&VDIError, VDTYPE_HDD, &pVD2);
    9797    CHECK("VDCreate() #2");
    9898

  • trunk/src/VBox/Devices/Storage/testcase/tstVDSnap.cpp

    r32536 r33524  
    276276
    277277
    278     rc = VDCreate(pVDIfs, &pVD);
     278    rc = VDCreate(pVDIfs, VDTYPE_HDD, &pVD);
    279279    CHECK("VDCreate()");
    280280

  • trunk/src/VBox/Devices/Storage/testcase/vbox-img.cpp

    r33288 r33524  
    124124    const char *pszFilename = NULL;
    125125    char *pszFormat = NULL;
     126    VDTYPE enmType = VDTYPE_INVALID;
    126127    RTUUID imageUuid;
    127128    RTUUID parentUuid;
    … …  
    188189        /* Don't pass error interface, as that would triggers error messages
    189190         * because some backends fail to open the image. */
    190         rc = VDGetFormat(NULL, NULL, pszFilename, &pszFormat);
     191        rc = VDGetFormat(NULL, NULL, pszFilename, &pszFormat, &enmType);
    191192        if (RT_FAILURE(rc))
    192193            return errorRuntime("Format autodetect failed: %Rrc\n", rc);
    … …  
    194195
    195196    PVBOXHDD pVD = NULL;
    196     rc = VDCreate(pVDIfs, &pVD);
     197    rc = VDCreate(pVDIfs, enmType, &pVD);
    197198    if (RT_FAILURE(rc))
    198199        return errorRuntime("Cannot create the virtual disk container: %Rrc\n", rc);
    … …  
    625626    bool fStdOut = false;
    626627    const char *pszSrcFormat = NULL;
     628    VDTYPE enmSrcType = VDTYPE_HDD;
    627629    const char *pszDstFormat = NULL;
    628630    const char *pszVariant = NULL;
    … …  
    788790        if (!pszSrcFormat)
    789791        {
    790             char *pszFormat;
    791             rc = VDGetFormat(NULL, NULL, pszSrcFilename, &pszFormat);
     792            char *pszFormat = NULL;
     793            VDTYPE enmType = VDTYPE_INVALID;
     794            rc = VDGetFormat(NULL, NULL, pszSrcFilename, &pszFormat, &enmType);
    792795            if (RT_FAILURE(rc))
    793796            {
    … …  
    796799            }
    797800            pszSrcFormat = pszFormat;
    798         }
    799 
    800         rc = VDCreate(pVDIfs, &pSrcDisk);
     801            enmSrcType = enmType;
     802        }
     803
     804        rc = VDCreate(pVDIfs, enmSrcType, &pSrcDisk);
    801805        if (RT_FAILURE(rc))
    802806        {
    … …  
    814818        }
    815819
    816         rc = VDCreate(pVDIfs, &pDstDisk);
     820        rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDstDisk);
    817821        if (RT_FAILURE(rc))
    818822        {
    … …  
    883887    /* just try it */
    884888    char *pszFormat = NULL;
    885     rc = VDGetFormat(NULL, NULL, pszFilename, &pszFormat);
     889    VDTYPE enmType = VDTYPE_INVALID;
     890    rc = VDGetFormat(NULL, NULL, pszFilename, &pszFormat, &enmType);
    886891    if (RT_FAILURE(rc))
    887892        return errorSyntax("Format autodetect failed: %Rrc\n", rc);
    888893
    889     rc = VDCreate(pVDIfs, &pDisk);
     894    rc = VDCreate(pVDIfs, enmType, &pDisk);
    890895    if (RT_FAILURE(rc))
    891896        return errorRuntime("Error while creating the virtual disk container: %Rrc\n", rc);
    … …  
    940945    /* just try it */
    941946    char *pszFormat = NULL;
    942     rc = VDGetFormat(NULL, NULL, pszFilename, &pszFormat);
     947    VDTYPE enmType = VDTYPE_INVALID;
     948    rc = VDGetFormat(NULL, NULL, pszFilename, &pszFormat, &enmType);
    943949    if (RT_FAILURE(rc))
    944950        return errorSyntax("Format autodetect failed: %Rrc\n", rc);
    945951
    946     rc = VDCreate(pVDIfs, &pDisk);
     952    rc = VDCreate(pVDIfs, enmType, &pDisk);
    947953    if (RT_FAILURE(rc))
    948954        return errorRuntime("Error while creating the virtual disk container: %Rrc\n", rc);

  • trunk/src/VBox/Devices/Storage/testcase/vditool.cpp

    r32536 r33524  
    104104
    105105    PVBOXHDD hdd;
    106     rc = VDCreate(NULL, &hdd);
     106    rc = VDCreate(NULL, VDTYPE_HDD, &hdd);
    107107    if (RT_FAILURE(rc))
    108108        return PrintDone(rc);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r33464 r33524  
    555555    /* just try it */
    556556    char *pszFormat = NULL;
     557    VDTYPE enmType = VDTYPE_INVALID;
    557558    int rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    558                          argv[1], &pszFormat);
     559                         argv[1], &pszFormat, &enmType);
    559560    if (RT_FAILURE(rc))
    560561    {
    … …  
    577578    AssertRC(rc);
    578579
    579     rc = VDCreate(pVDIfs, &pDisk);
     580    rc = VDCreate(pVDIfs, enmType, &pDisk);
    580581    if (RT_FAILURE(rc))
    581582    {
    … …  
    617618    /* just try it */
    618619    char *pszFormat = NULL;
     620    VDTYPE enmType = VDTYPE_INVALID;
    619621    int rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    620                          argv[0], &pszFormat);
     622                         argv[0], &pszFormat, &enmType);
    621623    if (RT_FAILURE(rc))
    622624    {
    … …  
    639641    AssertRC(rc);
    640642
    641     rc = VDCreate(pVDIfs, &pDisk);
     643    rc = VDCreate(pVDIfs, enmType, &pDisk);
    642644    if (RT_FAILURE(rc))
    643645    {
    … …  
    14331435    AssertRC(vrc);
    14341436
    1435     vrc = VDCreate(pVDIfs, &pDisk);
     1437    vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk); /* Raw VMDK's are harddisk only. */
    14361438    if (RT_FAILURE(vrc))
    14371439    {
    … …  
    15431545    AssertRC(vrc);
    15441546
    1545     vrc = VDCreate(pVDIfs, &pDisk);
     1547    vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    15461548    if (RT_FAILURE(vrc))
    15471549    {
    … …  
    16271629    AssertRC(vrc);
    16281630
    1629     vrc = VDCreate(pVDIfs, &pDisk);
     1631    /** @todo: Support convert to raw for floppy and DVD images too. */
     1632    vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    16301633    if (RT_FAILURE(vrc))
    16311634    {
    … …  
    16511654    {
    16521655        char *pszFormat = NULL;
     1656        VDTYPE enmType = VDTYPE_INVALID;
    16531657        vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    1654                           src.c_str(), &pszFormat);
    1655         if (RT_FAILURE(vrc))
     1658                          src.c_str(), &pszFormat, &enmType);
     1659        if (RT_FAILURE(vrc) || enmType != VDTYPE_HDD)
    16561660        {
    16571661            VDCloseAll(pDisk);
    … …  
    16611665                RTFileDelete(dst.c_str());
    16621666            }
    1663             RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
     1667            if (RT_FAILURE(vrc))
     1668                RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
     1669            else
     1670                RTMsgError("Only converting harddisk images is supported");
    16641671            return 1;
    16651672        }
    … …  
    17391746    PVBOXHDD pSrcDisk = NULL;
    17401747    PVBOXHDD pDstDisk = NULL;
     1748    VDTYPE enmSrcType = VDTYPE_INVALID;
    17411749
    17421750    /* Parse the arguments. */
    … …  
    18001808            char *pszFormat = NULL;
    18011809            vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    1802                               src.c_str(), &pszFormat);
     1810                              src.c_str(), &pszFormat, &enmSrcType);
    18031811            if (RT_FAILURE(vrc))
    18041812            {
    … …  
    18101818        }
    18111819
    1812         vrc = VDCreate(pVDIfs, &pSrcDisk);
     1820        vrc = VDCreate(pVDIfs, enmSrcType, &pSrcDisk);
    18131821        if (RT_FAILURE(vrc))
    18141822        {
    … …  
    18291837            dstformat = "VDI";
    18301838
    1831         vrc = VDCreate(pVDIfs, &pDstDisk);
     1839        vrc = VDCreate(pVDIfs, enmSrcType, &pDstDisk);
    18321840        if (RT_FAILURE(vrc))
    18331841        {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r33456 r33524  
    888888    char pszComment[256];
    889889    RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
    890     rc = VDCreate(pVDIfs, &pDisk);
     890    rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
    891891    if (RT_FAILURE(rc))
    892892    {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

    r33386 r33524  
    6262}
    6363#endif
     64
     65static const char*getDeviceTypeText(DeviceType_T enmType)
     66{
     67    switch (enmType)
     68    {
     69        case DeviceType_HardDisk: return "HardDisk";
     70        case DeviceType_DVD: return "DVD";
     71        case DeviceType_Floppy: return "Floppy";
     72    }
     73    return "Unknown";
     74}
    6475
    6576static void listMedia(const ComPtr<IVirtualBox> aVirtualBox,
    … …  
    604615                /* File extensions */
    605616                com::SafeArray <BSTR> fileExtensions;
     617                com::SafeArray <DeviceType_T> deviceTypes;
    606618                CHECK_ERROR(mediumFormats[i],
    607                             COMGETTER(FileExtensions)(ComSafeArrayAsOutParam(fileExtensions)));
     619                            DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes)));
    608620                for (size_t j = 0; j < fileExtensions.size(); ++j)
    609621                {
    610                     RTPrintf("%ls", Bstr(fileExtensions[j]).raw());
     622                    RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j]));
    611623                    if (j != fileExtensions.size()-1)
    612624                        RTPrintf(",");

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxMediaManagerDlg.cpp

    r33294 r33524  
    981981        dir = mVBox.GetHomeFolder();
    982982
     983    QList < QPair <QString, QString> > filterList;
     984    QStringList backends;
     985    QStringList allPrefix;
     986    QString     allType;
     987
    983988    switch (type)
    984989    {
     990        case VBoxDefs::MediumType_DVD:
     991        {
     992            filterList = vboxGlobal().DVDBackends();
     993            title = tr ("Select a CD/DVD-ROM disk image file");
     994            allType = tr ("CD/DVD-ROM disk");
     995            break;
     996        }
    985997        case VBoxDefs::MediumType_HardDisk:
    986998        {
    987             QList < QPair <QString, QString> > filterList = vboxGlobal().HDDBackends();
    988             QStringList backends;
    989             QStringList allPrefix;
    990             for (int i = 0; i < filterList.count(); ++i)
    991             {
    992                 QPair <QString, QString> item = filterList.at (i);
    993                 /* Create one backend filter string */
    994                 backends << QString ("%1 (%2)").arg (item.first). arg (item.second);
    995                 /* Save the suffix's for the "All" entry */
    996                 allPrefix << item.second;
    997             }
    998             if (!allPrefix.isEmpty())
    999                 backends.insert (0, tr ("All hard disk images (%1)").arg (allPrefix.join (" ").trimmed()));
    1000             backends << tr ("All files (*)");
    1001             filter = backends.join (";;").trimmed();
    1002 
     999            filterList = vboxGlobal().HDDBackends();
    10031000            title = tr ("Select a hard disk image file");
    1004             break;
    1005         }
    1006         case VBoxDefs::MediumType_DVD:
    1007         {
    1008             filter = tr ("CD/DVD-ROM images (*.iso);;All files (*)");
    1009             title = tr ("Select a CD/DVD-ROM disk image file");
     1001            allType = tr ("hard disk");
    10101002            break;
    10111003        }
    10121004        case VBoxDefs::MediumType_Floppy:
    10131005        {
    1014             filter = tr ("Floppy images (*.img);;All files (*)");
     1006            filterList = vboxGlobal().FloppyBackends();
    10151007            title = tr ("Select a floppy disk image file");
     1008            allType = tr ("floppy disk");
    10161009            break;
    10171010        }
    … …  
    10201013            break;
    10211014    }
     1015
     1016    for (int i = 0; i < filterList.count(); ++i)
     1017    {
     1018        QPair <QString, QString> item = filterList.at (i);
     1019        /* Create one backend filter string */
     1020        backends << QString ("%1 (%2)").arg (item.first). arg (item.second);
     1021        /* Save the suffix's for the "All" entry */
     1022        allPrefix << item.second;
     1023    }
     1024    if (!allPrefix.isEmpty())
     1025        backends.insert (0, tr ("All %1 images (%2)").arg (allType). arg (allPrefix.join (" ").trimmed()));
     1026    backends << tr ("All files (*)");
     1027    filter = backends.join (";;").trimmed();
    10221028
    10231029    QStringList files = QIFileDialog::getOpenFileNames (dir, filter, this, title);

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

    r33386 r33524  
    40604060
    40614061/**
    4062  * Figures out which hard disk formats are currently supported by VirtualBox.
     4062 * Figures out which medium formats are currently supported by VirtualBox for
     4063 * the given device type.
    40634064 * Returned is a list of pairs with the form
    40644065 *   <tt>{"Backend Name", "*.suffix1 .suffix2 ..."}</tt>.
    40654066 */
    40664067/* static */
    4067 QList <QPair <QString, QString> > VBoxGlobal::HDDBackends()
     4068QList <QPair <QString, QString> > VBoxGlobal::MediumBackends(KDeviceType enmType)
    40684069{
    40694070    CSystemProperties systemProperties = vboxGlobal().virtualBox().GetSystemProperties();
    … …  
    40734074    {
    40744075        /* File extensions */
    4075         QVector <QString> fileExtensions = mediumFormats [i].GetFileExtensions();
     4076        QVector <QString> fileExtensions;
     4077        QVector <KDeviceType> deviceTypes;
     4078
     4079        mediumFormats [i].DescribeFileExtensions(fileExtensions, deviceTypes);
     4080
    40764081        QStringList f;
    40774082        for (int a = 0; a < fileExtensions.size(); ++ a)
    4078             f << QString ("*.%1").arg (fileExtensions [a]);
     4083            if (deviceTypes [a] == enmType)
     4084                f << QString ("*.%1").arg (fileExtensions [a]);
    40794085        /* Create a pair out of the backend description and all suffix's. */
    40804086        if (!f.isEmpty())
    … …  
    40824088    }
    40834089    return backendPropList;
     4090}
     4091
     4092/**
     4093 * Figures out which hard disk formats are currently supported by VirtualBox.
     4094 * Returned is a list of pairs with the form
     4095 *   <tt>{"Backend Name", "*.suffix1 .suffix2 ..."}</tt>.
     4096 */
     4097/* static */
     4098QList <QPair <QString, QString> > VBoxGlobal::HDDBackends()
     4099{
     4100    return MediumBackends(KDeviceType_HardDisk);
     4101}
     4102
     4103/**
     4104 * Figures out which CD/DVD disk formats are currently supported by VirtualBox.
     4105 * Returned is a list of pairs with the form
     4106 *   <tt>{"Backend Name", "*.suffix1 .suffix2 ..."}</tt>.
     4107 */
     4108/* static */
     4109QList <QPair <QString, QString> > VBoxGlobal::DVDBackends()
     4110{
     4111    return MediumBackends(KDeviceType_DVD);
     4112}
     4113
     4114/**
     4115 * Figures out which floppy disk formats are currently supported by VirtualBox.
     4116 * Returned is a list of pairs with the form
     4117 *   <tt>{"Backend Name", "*.suffix1 .suffix2 ..."}</tt>.
     4118 */
     4119/* static */
     4120QList <QPair <QString, QString> > VBoxGlobal::FloppyBackends()
     4121{
     4122    return MediumBackends(KDeviceType_Floppy);
    40844123}
    40854124

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.h

    r33386 r33524  
    630630                                bool aRecursive = false);
    631631
     632    static QList <QPair <QString, QString> > MediumBackends(KDeviceType enmDeviceType);
    632633    static QList <QPair <QString, QString> > HDDBackends();
     634    static QList <QPair <QString, QString> > DVDBackends();
     635    static QList <QPair <QString, QString> > FloppyBackends();
    633636
    634637    /* Qt 4.2.0 support function */

  • trunk/src/VBox/Main/ConsoleImpl2.cpp

    r33307 r33524  
    30373037                }
    30383038
     3039                switch (enmType)
     3040                {
     3041                    case DeviceType_DVD:
     3042                        InsertConfigString(pCfg, "Type", "DVD");
     3043                        break;
     3044                    case DeviceType_Floppy:
     3045                        InsertConfigString(pCfg, "Type", "Floppy");
     3046                        break;
     3047                    case DeviceType_HardDisk:
     3048                    default:
     3049                        InsertConfigString(pCfg, "Type", "HardDisk");
     3050                }
     3051
    30393052                /* Pass all custom parameters. */
    30403053                bool fHostIP = true;

  • trunk/src/VBox/Main/MediumFormatImpl.cpp

    r32682 r33524  
    11/* $Id$ */
    2 
    32/** @file
    43 *
    … …  
    6867    unconst(m.capabilities) = aVDInfo->uBackendCaps;
    6968    /* Save the supported file extensions in a list */
    70     if (aVDInfo->papszFileExtensions)
     69    if (aVDInfo->paFileExtensions)
    7170    {
    72         const char *const *papsz = aVDInfo->papszFileExtensions;
    73         while (*papsz != NULL)
     71        PCVDFILEEXTENSION papExtension = aVDInfo->paFileExtensions;
     72        while (papExtension->pszExtension != NULL)
    7473        {
    75             unconst(m.llFileExtensions).push_back(*papsz);
    76             ++papsz;
     74            DeviceType_T devType;
     75
     76            unconst(m.llFileExtensions).push_back(papExtension->pszExtension);
     77
     78            switch(papExtension->enmType)
     79            {
     80                case VDTYPE_HDD:
     81                    devType = DeviceType_HardDisk;
     82                    break;
     83                case VDTYPE_DVD:
     84                    devType = DeviceType_DVD;
     85                    break;
     86                case VDTYPE_FLOPPY:
     87                    devType = DeviceType_Floppy;
     88                    break;
     89                default:
     90                    AssertMsgFailed(("Invalid enm type %d!\n", papExtension->enmType));
     91                    return E_INVALIDARG;
     92            }
     93
     94            unconst(m.llDeviceTypes).push_back(devType);
     95            ++papExtension;
    7796        }
    7897    }
    … …  
    162181    unconst(m.llProperties).clear();
    163182    unconst(m.llFileExtensions).clear();
     183    unconst(m.llDeviceTypes).clear();
    164184    unconst(m.capabilities) = 0;
    165185    unconst(m.strName).setNull();
    … …  
    196216}
    197217
    198 STDMETHODIMP MediumFormat::COMGETTER(FileExtensions)(ComSafeArrayOut(BSTR, aFileExtensions))
     218STDMETHODIMP MediumFormat::COMGETTER(Capabilities)(ULONG *aCaps)
     219{
     220    CheckComArgOutPointerValid(aCaps);
     221
     222    AutoCaller autoCaller(this);
     223    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     224
     225    /* m.capabilities is const, no need to lock */
     226
     227    /// @todo add COMGETTER(ExtendedCapabilities) when we reach the 32 bit
     228    /// limit (or make the argument ULONG64 after checking that COM is capable
     229    /// of defining enums (used to represent bit flags) that contain 64-bit
     230    /// values)
     231    ComAssertRet(m.capabilities == ((ULONG)m.capabilities), E_FAIL);
     232
     233    *aCaps = (ULONG) m.capabilities;
     234
     235    return S_OK;
     236}
     237
     238STDMETHODIMP MediumFormat::DescribeFileExtensions(ComSafeArrayOut(BSTR, aFileExtensions),
     239                                                  ComSafeArrayOut(DeviceType_T, aDeviceTypes))
    199240{
    200241    CheckComArgOutSafeArrayPointerValid(aFileExtensions);
    … …  
    212253    fileExtentions.detachTo(ComSafeArrayOutArg(aFileExtensions));
    213254
    214     return S_OK;
    215 }
    216 
    217 STDMETHODIMP MediumFormat::COMGETTER(Capabilities)(ULONG *aCaps)
    218 {
    219     CheckComArgOutPointerValid(aCaps);
    220 
    221     AutoCaller autoCaller(this);
    222     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    223 
    224     /* m.capabilities is const, no need to lock */
    225 
    226     /// @todo add COMGETTER(ExtendedCapabilities) when we reach the 32 bit
    227     /// limit (or make the argument ULONG64 after checking that COM is capable
    228     /// of defining enums (used to represent bit flags) that contain 64-bit
    229     /// values)
    230     ComAssertRet(m.capabilities == ((ULONG)m.capabilities), E_FAIL);
    231 
    232     *aCaps = (ULONG) m.capabilities;
     255    com::SafeArray<DeviceType_T> deviceTypes(m.llDeviceTypes.size());
     256    i = 0;
     257    for (DeviceTypeList::const_iterator it = m.llDeviceTypes.begin();
     258         it != m.llDeviceTypes.end();
     259         ++it, ++i)
     260        deviceTypes[i] = (*it);
     261    deviceTypes.detachTo(ComSafeArrayOutArg(aDeviceTypes));
    233262
    234263    return S_OK;

  • trunk/src/VBox/Main/MediumImpl.cpp

    r33433 r33524  
    10241024    m->hddOpenMode = enOpenMode;
    10251025
    1026     if (aDeviceType == DeviceType_HardDisk)
    1027         rc = setLocation(aLocation);
    1028     else
    1029     {
    1030         if (aDeviceType == DeviceType_DVD)
    1031             m->type = MediumType_Readonly;
    1032         else
    1033             m->type = MediumType_Writethrough;
    1034         rc = setLocation(aLocation, "RAW");
    1035     }
     1026    if (aDeviceType == DeviceType_DVD)
     1027        m->type = MediumType_Readonly;
     1028    else if (aDeviceType == DeviceType_Floppy)
     1029        m->type = MediumType_Writethrough;
     1030
     1031    rc = setLocation(aLocation);
    10361032    if (FAILED(rc)) return rc;
    1037 
    1038     if (    aDeviceType == DeviceType_DVD
    1039          || aDeviceType == DeviceType_Floppy)
    1040         // create new UUID
    1041         unconst(m->id).create();
    10421033
    10431034    /* get all the information about the medium from the storage unit */
    … …  
    36603651        if (isImport)
    36613652        {
     3653            VDTYPE enmType = VDTYPE_INVALID;
    36623654            char *backendName = NULL;
    36633655
    … …  
    36743666            {
    36753667                vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    3676                                   locationFull.c_str(), &backendName);
     3668                                  locationFull.c_str(), &backendName, &enmType);
    36773669            }
    36783670            else if (vrc != VERR_FILE_NOT_FOUND && vrc != VERR_PATH_NOT_FOUND)
    … …  
    36813673                locationFull = aLocation;
    36823674                vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
    3683                                   locationFull.c_str(), &backendName);
     3675                                  locationFull.c_str(), &backendName, &enmType);
    36843676            }
    36853677
    … …  
    37023694                }
    37033695            }
     3696            else if (m->devType != convertToDeviceType(enmType))
     3697            {
     3698                /*
     3699                 * The user tried to use a image as a device which is not supported
     3700                 * by the backend.
     3701                 */
     3702                return setError(E_FAIL,
     3703                                tr("The medium '%s' can't be used as the requested device type"),
     3704                                locationFull.c_str());
     3705            }
    37043706            else
    37053707            {
    … …  
    38433845
    38443846        PVBOXHDD hdd;
    3845         vrc = VDCreate(m->vdDiskIfaces, &hdd);
     3847        vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    38463848        ComAssertRCThrow(vrc, E_FAIL);
    38473849
    … …  
    40924094        {
    40934095            PVBOXHDD hdd;
    4094             vrc = VDCreate(m->vdDiskIfaces, &hdd);
     4096            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    40954097            ComAssertRCThrow(vrc, E_FAIL);
    40964098
    … …  
    42074209
    42084210    return rc;
     4211}
     4212
     4213/**
     4214 * Converts the Medium device type to the VD type.
     4215 */
     4216VDTYPE Medium::convertDeviceType()
     4217{
     4218    VDTYPE enmType;
     4219
     4220    switch (m->devType)
     4221    {
     4222        case DeviceType_HardDisk:
     4223            enmType = VDTYPE_HDD;
     4224            break;
     4225        case DeviceType_DVD:
     4226            enmType = VDTYPE_DVD;
     4227            break;
     4228        case DeviceType_Floppy:
     4229            enmType = VDTYPE_FLOPPY;
     4230            break;
     4231        default:
     4232            ComAssertFailedThrow(E_FAIL);
     4233    }
     4234
     4235    return enmType;
     4236}
     4237
     4238/**
     4239 * Converts from the VD type to the medium type.
     4240 */
     4241DeviceType_T Medium::convertToDeviceType(VDTYPE enmType)
     4242{
     4243    DeviceType_T devType;
     4244
     4245    switch (enmType)
     4246    {
     4247        case VDTYPE_HDD:
     4248            devType = DeviceType_HardDisk;
     4249            break;
     4250        case VDTYPE_DVD:
     4251            devType = DeviceType_DVD;
     4252            break;
     4253        case VDTYPE_FLOPPY:
     4254            devType = DeviceType_Floppy;
     4255            break;
     4256        default:
     4257            ComAssertFailedThrow(E_FAIL);
     4258    }
     4259
     4260    return devType;
    42094261}
    42104262
    … …  
    57405792    {
    57415793        PVBOXHDD hdd;
    5742         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     5794        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    57435795        ComAssertRCThrow(vrc, E_FAIL);
    57445796
    … …  
    58815933
    58825934        PVBOXHDD hdd;
    5883         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     5935        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    58845936        ComAssertRCThrow(vrc, E_FAIL);
    58855937
    … …  
    60186070
    60196071        PVBOXHDD hdd;
    6020         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     6072        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    60216073        ComAssertRCThrow(vrc, E_FAIL);
    60226074
    … …  
    61876239    {
    61886240        PVBOXHDD hdd;
    6189         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     6241        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    61906242        ComAssertRCThrow(vrc, E_FAIL);
    61916243
    … …  
    65126564
    65136565        PVBOXHDD hdd;
    6514         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     6566        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    65156567        ComAssertRCThrow(vrc, E_FAIL);
    65166568
    … …  
    65646616
    65656617            PVBOXHDD targetHdd;
    6566             vrc = VDCreate(m->vdDiskIfaces, &targetHdd);
     6618            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &targetHdd);
    65676619            ComAssertRCThrow(vrc, E_FAIL);
    65686620
    … …  
    67406792
    67416793        PVBOXHDD hdd;
    6742         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     6794        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    67436795        ComAssertRCThrow(vrc, E_FAIL);
    67446796
    … …  
    68126864
    68136865        PVBOXHDD hdd;
    6814         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     6866        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    68156867        ComAssertRCThrow(vrc, E_FAIL);
    68166868
    … …  
    69507002    {
    69517003        PVBOXHDD hdd;
    6952         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     7004        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    69537005        ComAssertRCThrow(vrc, E_FAIL);
    69547006
    … …  
    70477099    {
    70487100        PVBOXHDD hdd;
    7049         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     7101        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    70507102        ComAssertRCThrow(vrc, E_FAIL);
    70517103
    … …  
    71497201
    71507202        PVBOXHDD hdd;
    7151         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     7203        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    71527204        ComAssertRCThrow(vrc, E_FAIL);
    71537205
    … …  
    71977249
    71987250            PVBOXHDD targetHdd;
    7199             vrc = VDCreate(m->vdDiskIfaces, &targetHdd);
     7251            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &targetHdd);
    72007252            ComAssertRCThrow(vrc, E_FAIL);
    72017253
    … …  
    72847336
    72857337        PVBOXHDD hdd;
    7286         int vrc = VDCreate(m->vdDiskIfaces, &hdd);
     7338        int vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &hdd);
    72877339        ComAssertRCThrow(vrc, E_FAIL);
    72887340
    … …  
    73187370
    73197371            PVBOXHDD targetHdd;
    7320             vrc = VDCreate(m->vdDiskIfaces, &targetHdd);
     7372            vrc = VDCreate(m->vdDiskIfaces, convertDeviceType(), &targetHdd);
    73217373            ComAssertRCThrow(vrc, E_FAIL);
    73227374

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r33492 r33524  
    468468    <const name="v1_11"     value="13">
    469469      <desc>Settings version "1.11", written by VirtualBox 4.0.x.</desc>
    470       <!-- Machine changes: HD Audio controller, per-machine disk registries
     470      <!-- Machine changes: HD Audio controller, per-machine disk registries,
     471           /@format attribute for DVD and floppy images.
    471472           -->
    472473    </const>
    … …  
    1014710148  <interface
    1014810149     name="IMediumFormat" extends="$unknown"
    10149      uuid="89f52554-d469-4799-9fad-1705e86a08b1"
     10150     uuid="4e9a873f-0599-434a-8345-619ef3fb3111"
    1015010151     wsmap="managed"
    1015110152     >
    … …  
    1019510196    </attribute>
    1019610197
    10197     <attribute name="fileExtensions" type="wstring" safearray="yes" readonly="yes">
    10198       <desc>
    10199         Array of strings containing the supported file extensions.
    10200 
    10201         The first extension in the array is the extension preferred by the
    10202         backend. It is recommended to use this extension when specifying a
    10203         location of the storage unit for a new medium.
     10198    <attribute name="capabilities" type="unsigned long" readonly="yes">
     10199      <desc>
     10200        Capabilities of the format as a set of bit flags.
     10201
     10202        For the meaning of individual capability flags see
     10203        <link to="MediumFormatCapabilities"/>.
     10204      </desc>
     10205    </attribute>
     10206
     10207    <method name="describeFileExtensions">
     10208      <desc>
     10209        Returns two arrays describing the supported file extensions.
     10210
     10211        The first array contains the supported extensions and the seconds one
     10212        the type each extension supports. Both have the same size.
    1020410213
    1020510214        Note that some backends do not work on files, so this array may be
    … …  
    1020810217        <see>IMediumFormat::capabilities</see>
    1020910218      </desc>
    10210     </attribute>
    10211 
    10212     <attribute name="capabilities" type="unsigned long" readonly="yes">
    10213       <desc>
    10214         Capabilities of the format as a set of bit flags.
    10215 
    10216         For the meaning of individual capability flags see
    10217         <link to="MediumFormatCapabilities"/>.
    10218       </desc>
    10219     </attribute>
     10219      <param  name="extensions" type="wstring" safearray="yes" dir="out">
     10220        <desc>The array of supported extensions.</desc>
     10221      </param>
     10222      <param  name="type" type="DeviceType" safearray="yes" dir="out">
     10223        <desc>The array which indicates the device type for every given extension.</desc>
     10224      </param>
     10225    </method>
    1022010226
    1022110227    <method name="describeProperties">

  • trunk/src/VBox/Main/include/MediumFormatImpl.h

    r32531 r33524  
    5353    };
    5454
    55     typedef std::list<Utf8Str>  StrList;
    56     typedef std::list<Property> PropertyList;
     55    typedef std::list<Utf8Str>      StrList;
     56    typedef std::list<DeviceType_T> DeviceTypeList;
     57    typedef std::list<Property>     PropertyList;
    5758
    5859    struct Data
    … …  
    6061        Data() : capabilities(0) {}
    6162
    62         const Utf8Str       strId;
    63         const Utf8Str       strName;
    64         const StrList       llFileExtensions;
    65         const uint64_t      capabilities;
    66         const PropertyList  llProperties;
     63        const Utf8Str        strId;
     64        const Utf8Str        strName;
     65        const StrList        llFileExtensions;
     66        const DeviceTypeList llDeviceTypes;
     67        const uint64_t       capabilities;
     68        const PropertyList   llProperties;
    6769    };
    6870
    … …  
    9193    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    9294    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    93     STDMETHOD(COMGETTER(FileExtensions))(ComSafeArrayOut(BSTR, aFileExtensions));
    9495    STDMETHOD(COMGETTER(Capabilities))(ULONG *aCaps);
    9596
    9697    // IMediumFormat methods
     98    STDMETHOD(DescribeFileExtensions)(ComSafeArrayOut(BSTR, aFileExtensions),
     99                                      ComSafeArrayOut(DeviceType_T, aDeviceTypes));
    97100    STDMETHOD(DescribeProperties)(ComSafeArrayOut(BSTR, aNames),
    98101                                  ComSafeArrayOut(BSTR, aDescriptions),

  • trunk/src/VBox/Main/include/MediumImpl.h

    r33339 r33524  
    300300    Utf8Str vdError(int aVRC);
    301301
     302    VDTYPE convertDeviceType();
     303    DeviceType_T convertToDeviceType(VDTYPE enmType);
     304
    302305    static DECLCALLBACK(void) vdErrorCall(void *pvUser, int rc, RT_SRC_POS_DECL,
    303306                                          const char *pszFormat, va_list va);

  • trunk/src/VBox/Main/include/VirtualBoxBase.h

    r31539 r33524  
    164164
    165165/**
     166 *  Special version of the AssertFailed macro to be used within VirtualBoxBase
     167 *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
     168 *
     169 *  In the debug build, this macro is equivalent to AssertFailed.
     170 *  In the release build, this macro uses |setError(E_FAIL, ...)| to set the
     171 *  error info from the asserted expression.
     172 *
     173 *  @see VirtualBoxSupportErrorInfoImpl::setError
     174 *
     175 */
     176#if defined (DEBUG)
     177#define ComAssertFailed()    AssertFailed()
     178#else
     179#define ComAssertFailed()    \
     180    do { \
     181        setError(E_FAIL, \
     182                 "Assertion failed: at '%s' (%d) in %s.\nPlease contact the product vendor!", \
     183                 __FILE__, __LINE__, __PRETTY_FUNCTION__); \
     184    } while (0)
     185#endif
     186
     187/**
    166188 *  Special version of the AssertMsg macro to be used within VirtualBoxBase
    167189 *  subclasses that also inherit the VirtualBoxSupportErrorInfoImpl template.
    … …  
    280302#define ComAssertComRCThrowRC(rc)                 \
    281303    if (1)  { ComAssertComRC(rc); if (!SUCCEEDED(rc)) { throw rc; } } else do {} while (0)
     304/** Special version of ComAssert that throws eval */
     305#define ComAssertFailedThrow(eval)                \
     306    if (1) { ComAssertFailed(); { throw (eval); } } else do {} while (0)
    282307
    283308////////////////////////////////////////////////////////////////////////////////

  • trunk/src/VBox/Main/xml/Settings.cpp

    r33504 r33524  
    671671            else if (strType == "SHAREABLE")
    672672                med.hdType = MediumType_Shareable;
     673            else if (strType == "READONLY")
     674                med.hdType = MediumType_Readonly;
    673675            else
    674676                throw ConfigFileError(this, &elmMedium, N_("HardDisk/@type attribute must be one of Normal, Immutable or Writethrough"));
    675677        }
    676678    }
    677     else if (m->sv < SettingsVersion_v1_4)
    678     {
    679         // DVD and floppy images before 1.4 had "src" attribute instead of "location"
    680         if (!(elmMedium.getAttributeValue("src", med.strLocation)))
    681             throw ConfigFileError(this, &elmMedium, N_("Required %s/@src attribute is missing"), elmMedium.getName());
    682 
    683         fNeedsLocation = false;
     679    else
     680    {
     681        if (m->sv < SettingsVersion_v1_4)
     682        {
     683            // DVD and floppy images before 1.4 had "src" attribute instead of "location"
     684            if (!(elmMedium.getAttributeValue("src", med.strLocation)))
     685                throw ConfigFileError(this, &elmMedium, N_("Required %s/@src attribute is missing"), elmMedium.getName());
     686
     687            fNeedsLocation = false;
     688        }
     689
     690        if (!(elmMedium.getAttributeValue("format", med.strFormat)))
     691        {
     692            // DVD and floppy images before 1.11 had no format attribute. assign the default.
     693            med.strFormat = "RAW";
     694        }
    684695    }
    685696
    … …  
    979990 * @param level
    980991 */
    981 void ConfigFileBase::buildHardDisk(xml::ElementNode &elmMedium,
    982                                    const Medium &mdm,
    983                                    uint32_t level)          // 0 for "root" call, incremented with each recursion
    984 {
    985     xml::ElementNode *pelmHardDisk = elmMedium.createChild("HardDisk");
    986     pelmHardDisk->setAttribute("uuid", mdm.uuid.toStringCurly());
    987     pelmHardDisk->setAttribute("location", mdm.strLocation);
    988     pelmHardDisk->setAttribute("format", mdm.strFormat);
     992void ConfigFileBase::buildMedium(xml::ElementNode &elmMedium,
     993                                 DeviceType_T devType,
     994                                 const Medium &mdm,
     995                                 uint32_t level)          // 0 for "root" call, incremented with each recursion
     996{
     997    xml::ElementNode *pelmMedium;
     998
     999    if (devType == DeviceType_HardDisk)
     1000        pelmMedium = elmMedium.createChild("HardDisk");
     1001    else
     1002        pelmMedium = elmMedium.createChild("Image");
     1003
     1004    pelmMedium->setAttribute("uuid", mdm.uuid.toStringCurly());
     1005    pelmMedium->setAttribute("location", mdm.strLocation);
     1006    pelmMedium->setAttribute("format", mdm.strFormat);
    9891007    if (mdm.fAutoReset)
    990         pelmHardDisk->setAttribute("autoReset", mdm.fAutoReset);
     1008        pelmMedium->setAttribute("autoReset", mdm.fAutoReset);
    9911009    if (mdm.strDescription.length())
    992         pelmHardDisk->setAttribute("Description", mdm.strDescription);
     1010        pelmMedium->setAttribute("Description", mdm.strDescription);
    9931011
    9941012    for (StringsMap::const_iterator it = mdm.properties.begin();
    … …  
    9961014         ++it)
    9971015    {
    998         xml::ElementNode *pelmProp = pelmHardDisk->createChild("Property");
     1016        xml::ElementNode *pelmProp = pelmMedium->createChild("Property");
    9991017        pelmProp->setAttribute("name", it->first);
    10001018        pelmProp->setAttribute("value", it->second);
    … …  
    10081026            mdm.hdType == MediumType_Immutable ? "Immutable" :
    10091027            mdm.hdType == MediumType_Writethrough ? "Writethrough" :
    1010             mdm.hdType == MediumType_Shareable ? "Shareable" : "INVALID";
    1011         pelmHardDisk->setAttribute("type", pcszType);
     1028            mdm.hdType == MediumType_Shareable ? "Shareable" :
     1029            mdm.hdType == MediumType_Readonly ? "Readonly" : "INVALID";
     1030        pelmMedium->setAttribute("type", pcszType);
    10121031    }
    10131032
    … …  
    10171036    {
    10181037        // recurse for children
    1019         buildHardDisk(*pelmHardDisk, // parent
    1020                       *it,           // settings::Medium
    1021                       ++level);      // recursion level
     1038        buildMedium(*pelmMedium, // parent
     1039                    devType,     // device type
     1040                    *it,         // settings::Medium
     1041                    ++level);    // recursion level
    10221042    }
    10231043}
    … …  
    10441064         ++it)
    10451065    {
    1046         buildHardDisk(*pelmHardDisks, *it, 0);
     1066        buildMedium(*pelmHardDisks, DeviceType_HardDisk, *it, 0);
    10471067    }
    10481068
    … …  
    10521072         ++it)
    10531073    {
    1054         const Medium &mdm = *it;
    1055         xml::ElementNode *pelmMedium = pelmDVDImages->createChild("Image");
    1056         pelmMedium->setAttribute("uuid", mdm.uuid.toStringCurly());
    1057         pelmMedium->setAttribute("location", mdm.strLocation);
    1058         if (mdm.strDescription.length())
    1059             pelmMedium->setAttribute("Description", mdm.strDescription);
     1074        buildMedium(*pelmDVDImages, DeviceType_DVD, *it, 0);
    10601075    }
    10611076
    … …  
    10651080         ++it)
    10661081    {
    1067         const Medium &mdm = *it;
    1068         xml::ElementNode *pelmMedium = pelmFloppyImages->createChild("Image");
    1069         pelmMedium->setAttribute("uuid", mdm.uuid.toStringCurly());
    1070         pelmMedium->setAttribute("location", mdm.strLocation);
    1071         if (mdm.strDescription.length())
    1072             pelmMedium->setAttribute("Description", mdm.strDescription);
     1082        buildMedium(*pelmFloppyImages, DeviceType_Floppy, *it, 0);
    10731083    }
    10741084}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette