VirtualBox

Changeset 34101 in vbox for trunk


Ignore:
Timestamp:
Nov 16, 2010 10:56:43 AM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
67800
Message:

Main-OVF: address r67784

Location:
trunk/src/VBox/Main
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r33835 r34101  
    15901590    HRESULT rc = S_OK;
    15911591
    1592     PVDINTERFACEIO pRTSha1Callbacks = 0;
    1593     PVDINTERFACEIO pRTFileCallbacks = 0;
     1592    PVDINTERFACEIO pSha1Callbacks = 0;
     1593    PVDINTERFACEIO pFileCallbacks = 0;
    15941594    do
    15951595    {
    1596         pRTSha1Callbacks = RTSha1CreateInterface();
    1597         if (!pRTSha1Callbacks)
     1596        pSha1Callbacks = Sha1CreateInterface();
     1597        if (!pSha1Callbacks)
    15981598        {
    15991599            rc = E_OUTOFMEMORY;
    16001600            break;
    16011601        }
    1602         pRTFileCallbacks = RTFileCreateInterface();
    1603         if (!pRTFileCallbacks)
     1602        pFileCallbacks = FileCreateInterface();
     1603        if (!pFileCallbacks)
    16041604        {
    16051605            rc = E_OUTOFMEMORY;
    … …  
    16071607        }
    16081608
    1609         RTSHA1STORAGE storage;
     1609        SHA1STORAGE storage;
    16101610        RT_ZERO(storage);
    16111611        storage.fCreateDigest = m->fManifest;
    16121612        VDINTERFACE VDInterfaceIO;
    1613         int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IORTFile",
    1614                                  VDINTERFACETYPE_IO, pRTFileCallbacks,
     1613        int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOFile",
     1614                                 VDINTERFACETYPE_IO, pFileCallbacks,
    16151615                                 0, &storage.pVDImageIfaces);
    16161616        if (RT_FAILURE(vrc))
    … …  
    16191619            break;
    16201620        }
    1621         rc = writeFSImpl(pTask, writeLock, pRTSha1Callbacks, &storage);
     1621        rc = writeFSImpl(pTask, writeLock, pSha1Callbacks, &storage);
    16221622    }while(0);
    16231623
    16241624    /* Cleanup */
    1625     if (pRTSha1Callbacks)
    1626         RTMemFree(pRTSha1Callbacks);
    1627     if (pRTFileCallbacks)
    1628         RTMemFree(pRTFileCallbacks);
     1625    if (pSha1Callbacks)
     1626        RTMemFree(pSha1Callbacks);
     1627    if (pFileCallbacks)
     1628        RTMemFree(pFileCallbacks);
    16291629
    16301630    LogFlowFuncLeave();
    … …  
    16451645    HRESULT rc = S_OK;
    16461646
    1647     PVDINTERFACEIO pRTSha1Callbacks = 0;
    1648     PVDINTERFACEIO pRTTarCallbacks = 0;
     1647    PVDINTERFACEIO pSha1Callbacks = 0;
     1648    PVDINTERFACEIO pTarCallbacks = 0;
    16491649    do
    16501650    {
    1651         pRTSha1Callbacks = RTSha1CreateInterface();
    1652         if (!pRTSha1Callbacks)
     1651        pSha1Callbacks = Sha1CreateInterface();
     1652        if (!pSha1Callbacks)
    16531653        {
    16541654            rc = E_OUTOFMEMORY;
    16551655            break;
    16561656        }
    1657         pRTTarCallbacks = RTTarCreateInterface();
    1658         if (!pRTTarCallbacks)
     1657        pTarCallbacks = TarCreateInterface();
     1658        if (!pTarCallbacks)
    16591659        {
    16601660            rc = E_OUTOFMEMORY;
    … …  
    16621662        }
    16631663        VDINTERFACE VDInterfaceIO;
    1664         RTSHA1STORAGE storage;
     1664        SHA1STORAGE storage;
    16651665        RT_ZERO(storage);
    16661666        storage.fCreateDigest = m->fManifest;
    1667         vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IORTTar",
    1668                              VDINTERFACETYPE_IO, pRTTarCallbacks,
     1667        vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
     1668                             VDINTERFACETYPE_IO, pTarCallbacks,
    16691669                             tar, &storage.pVDImageIfaces);
    16701670        if (RT_FAILURE(vrc))
    … …  
    16731673            break;
    16741674        }
    1675         rc = writeFSImpl(pTask, writeLock, pRTSha1Callbacks, &storage);
     1675        rc = writeFSImpl(pTask, writeLock, pSha1Callbacks, &storage);
    16761676    }while(0);
    16771677
    … …  
    16791679
    16801680    /* Cleanup */
    1681     if (pRTSha1Callbacks)
    1682         RTMemFree(pRTSha1Callbacks);
    1683     if (pRTTarCallbacks)
    1684         RTMemFree(pRTTarCallbacks);
     1681    if (pSha1Callbacks)
     1682        RTMemFree(pSha1Callbacks);
     1683    if (pTarCallbacks)
     1684        RTMemFree(pTarCallbacks);
    16851685
    16861686    /* Delete ova file on error */
    … …  
    16921692}
    16931693
    1694 HRESULT Appliance::writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage)
     1694HRESULT Appliance::writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
    16951695{
    16961696    LogFlowFuncEnter();
    … …  
    17241724                               strOvfFile.c_str());
    17251725            /* Write the ovf file to disk. */
    1726             vrc = RTSha1WriteBuf(strOvfFile.c_str(), pvBuf, cbSize, pCallbacks, pStorage);
     1726            vrc = Sha1WriteBuf(strOvfFile.c_str(), pvBuf, cbSize, pCallbacks, pStorage);
    17271727            if (RT_FAILURE(vrc))
    17281728                throw setError(VBOX_E_FILE_ERROR,
    … …  
    18411841            pStorage->fCreateDigest = false;
    18421842            /* Write the manifest file to disk. */
    1843             vrc = RTSha1WriteBuf(strMfFilePath.c_str(), pvBuf, cbSize, pCallbacks, pStorage);
     1843            vrc = Sha1WriteBuf(strMfFilePath.c_str(), pvBuf, cbSize, pCallbacks, pStorage);
    18441844            RTMemFree(pvBuf);
    18451845            if (RT_FAILURE(vrc))

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

    r33706 r34101  
    3737 ******************************************************************************/
    3838
    39 typedef struct RTFILESTORAGEINTERNAL
     39typedef struct FILESTORAGEINTERNAL
    4040{
    4141    /** File handle. */
    … …  
    4343    /** Completion callback. */
    4444    PFNVDCOMPLETED pfnCompleted;
    45 } RTFILESTORAGEINTERNAL, *PRTFILESTORAGEINTERNAL;
    46 
    47 typedef struct RTTARSTORAGEINTERNAL
     45} FILESTORAGEINTERNAL, *PFILESTORAGEINTERNAL;
     46
     47typedef struct TARSTORAGEINTERNAL
    4848{
    4949    /** Tar handle. */
    … …  
    5151    /** Completion callback. */
    5252    PFNVDCOMPLETED pfnCompleted;
    53 } RTTARSTORAGEINTERNAL, *PRTTARSTORAGEINTERNAL;
    54 
    55 typedef struct RTSHA1STORAGEINTERNAL
     53} TARSTORAGEINTERNAL, *PTARSTORAGEINTERNAL;
     54
     55typedef struct SHA1STORAGEINTERNAL
    5656{
    5757    /** Completion callback. */
    … …  
    6262    uint32_t fOpenMode;
    6363    /** Our own storage handle. */
    64     PRTSHA1STORAGE pSha1Storage;
     64    PSHA1STORAGE pSha1Storage;
    6565    /** Circular buffer used for transferring data from/to the worker thread. */
    6666    PRTCIRCBUF pCircBuf;
    … …  
    8787//    uint64_t calls;
    8888//    uint64_t waits;
    89 } RTSHA1STORAGEINTERNAL, *PRTSHA1STORAGEINTERNAL;
     89} SHA1STORAGEINTERNAL, *PSHA1STORAGEINTERNAL;
    9090
    9191/******************************************************************************
    … …  
    113113 ******************************************************************************/
    114114
    115 static int rtFileOpenCallback(void * /* pvUser */, const char *pszLocation, uint32_t fOpen,
     115static int fileOpenCallback(void * /* pvUser */, const char *pszLocation, uint32_t fOpen,
    116116                              PFNVDCOMPLETED pfnCompleted, void **ppInt)
    117117{
    … …  
    122122    DEBUG_PRINT_FLOW();
    123123
    124     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)RTMemAllocZ(sizeof(RTFILESTORAGEINTERNAL));
     124    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)RTMemAllocZ(sizeof(FILESTORAGEINTERNAL));
    125125    if (!pInt)
    126126        return VERR_NO_MEMORY;
    … …  
    138138}
    139139
    140 static int rtFileCloseCallback(void * /* pvUser */, void *pvStorage)
    141 {
    142     /* Validate input. */
    143     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    144 
    145     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)pvStorage;
     140static int fileCloseCallback(void * /* pvUser */, void *pvStorage)
     141{
     142    /* Validate input. */
     143    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     144
     145    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
    146146
    147147    DEBUG_PRINT_FLOW();
    … …  
    155155}
    156156
    157 static int rtFileDeleteCallback(void * /* pvUser */, const char *pcszFilename)
     157static int fileDeleteCallback(void * /* pvUser */, const char *pcszFilename)
    158158{
    159159    DEBUG_PRINT_FLOW();
    … …  
    162162}
    163163
    164 static int rtFileMoveCallback(void * /* pvUser */, const char *pcszSrc, const char *pcszDst, unsigned fMove)
     164static int fileMoveCallback(void * /* pvUser */, const char *pcszSrc, const char *pcszDst, unsigned fMove)
    165165{
    166166    DEBUG_PRINT_FLOW();
    … …  
    169169}
    170170
    171 static int rtFileGetFreeSpaceCallback(void * /* pvUser */, const char *pcszFilename, int64_t *pcbFreeSpace)
     171static int fileGetFreeSpaceCallback(void * /* pvUser */, const char *pcszFilename, int64_t *pcbFreeSpace)
    172172{
    173173    /* Validate input. */
    … …  
    180180}
    181181
    182 static int rtFileGetModificationTimeCallback(void * /* pvUser */, const char *pcszFilename, PRTTIMESPEC pModificationTime)
     182static int fileGetModificationTimeCallback(void * /* pvUser */, const char *pcszFilename, PRTTIMESPEC pModificationTime)
    183183{
    184184    /* Validate input. */
    … …  
    191191}
    192192
    193 static int rtFileGetSizeCallback(void * /* pvUser */, void *pvStorage, uint64_t *pcbSize)
    194 {
    195     /* Validate input. */
    196     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    197 
    198     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)pvStorage;
     193static int fileGetSizeCallback(void * /* pvUser */, void *pvStorage, uint64_t *pcbSize)
     194{
     195    /* Validate input. */
     196    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     197
     198    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
    199199
    200200    DEBUG_PRINT_FLOW();
    … …  
    203203}
    204204
    205 static int rtFileSetSizeCallback(void * /* pvUser */, void *pvStorage, uint64_t cbSize)
    206 {
    207     /* Validate input. */
    208     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    209 
    210     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)pvStorage;
     205static int fileSetSizeCallback(void * /* pvUser */, void *pvStorage, uint64_t cbSize)
     206{
     207    /* Validate input. */
     208    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     209
     210    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
    211211
    212212    DEBUG_PRINT_FLOW();
    … …  
    215215}
    216216
    217 static int rtFileWriteSyncCallback(void * /* pvUser */, void *pvStorage, uint64_t uOffset,
     217static int fileWriteSyncCallback(void * /* pvUser */, void *pvStorage, uint64_t uOffset,
    218218                                   const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
    219219{
    … …  
    221221    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    222222
    223     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)pvStorage;
     223    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
    224224
    225225    return RTFileWriteAt(pInt->file, uOffset, pvBuf, cbWrite, pcbWritten);
    226226}
    227227
    228 static int rtFileReadSyncCallback(void * /* pvUser */, void *pvStorage, uint64_t uOffset,
     228static int fileReadSyncCallback(void * /* pvUser */, void *pvStorage, uint64_t uOffset,
    229229                                  void *pvBuf, size_t cbRead, size_t *pcbRead)
    230230{
    … …  
    234234//    DEBUG_PRINT_FLOW();
    235235
    236     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)pvStorage;
     236    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
    237237
    238238    return RTFileReadAt(pInt->file, uOffset, pvBuf, cbRead, pcbRead);
    239239}
    240240
    241 static int rtFileFlushSyncCallback(void * /* pvUser */, void *pvStorage)
    242 {
    243     /* Validate input. */
    244     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    245 
    246     DEBUG_PRINT_FLOW();
    247 
    248     PRTFILESTORAGEINTERNAL pInt = (PRTFILESTORAGEINTERNAL)pvStorage;
     241static int fileFlushSyncCallback(void * /* pvUser */, void *pvStorage)
     242{
     243    /* Validate input. */
     244    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     245
     246    DEBUG_PRINT_FLOW();
     247
     248    PFILESTORAGEINTERNAL pInt = (PFILESTORAGEINTERNAL)pvStorage;
    249249
    250250    return RTFileFlush(pInt->file);
    … …  
    255255 ******************************************************************************/
    256256
    257 static int rtTarOpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
     257static int tarOpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
    258258                             PFNVDCOMPLETED pfnCompleted, void **ppInt)
    259259{
    … …  
    268268    DEBUG_PRINT_FLOW();
    269269
    270     PRTTARSTORAGEINTERNAL pInt = (PRTTARSTORAGEINTERNAL)RTMemAllocZ(sizeof(RTTARSTORAGEINTERNAL));
     270    PTARSTORAGEINTERNAL pInt = (PTARSTORAGEINTERNAL)RTMemAllocZ(sizeof(TARSTORAGEINTERNAL));
    271271    if (!pInt)
    272272        return VERR_NO_MEMORY;
    … …  
    325325}
    326326
    327 static int rtTarCloseCallback(void *pvUser, void *pvStorage)
    328 {
    329     /* Validate input. */
    330     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    331     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    332 
    333     PRTTARSTORAGEINTERNAL pInt = (PRTTARSTORAGEINTERNAL)pvStorage;
     327static int tarCloseCallback(void *pvUser, void *pvStorage)
     328{
     329    /* Validate input. */
     330    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     331    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     332
     333    PTARSTORAGEINTERNAL pInt = (PTARSTORAGEINTERNAL)pvStorage;
    334334
    335335    DEBUG_PRINT_FLOW();
    … …  
    343343}
    344344
    345 static int rtTarDeleteCallback(void *pvUser, const char *pcszFilename)
     345static int tarDeleteCallback(void *pvUser, const char *pcszFilename)
    346346{
    347347    /* Validate input. */
    … …  
    354354}
    355355
    356 static int rtTarMoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned /* fMove */)
     356static int tarMoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned /* fMove */)
    357357{
    358358    /* Validate input. */
    … …  
    366366}
    367367
    368 static int rtTarGetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
     368static int tarGetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
    369369{
    370370    /* Validate input. */
    … …  
    378378}
    379379
    380 static int rtTarGetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
     380static int tarGetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
    381381{
    382382    /* Validate input. */
    … …  
    390390}
    391391
    392 static int rtTarGetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
    393 {
    394     /* Validate input. */
    395     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    396     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    397 
    398     PRTTARSTORAGEINTERNAL pInt = (PRTTARSTORAGEINTERNAL)pvStorage;
     392static int tarGetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
     393{
     394    /* Validate input. */
     395    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     396    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     397
     398    PTARSTORAGEINTERNAL pInt = (PTARSTORAGEINTERNAL)pvStorage;
    399399
    400400    DEBUG_PRINT_FLOW();
    … …  
    403403}
    404404
    405 static int rtTarSetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
    406 {
    407     /* Validate input. */
    408     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    409     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    410 
    411     PRTTARSTORAGEINTERNAL pInt = (PRTTARSTORAGEINTERNAL)pvStorage;
     405static int tarSetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
     406{
     407    /* Validate input. */
     408    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     409    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     410
     411    PTARSTORAGEINTERNAL pInt = (PTARSTORAGEINTERNAL)pvStorage;
    412412
    413413    DEBUG_PRINT_FLOW();
    … …  
    416416}
    417417
    418 static int rtTarWriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
     418static int tarWriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
    419419                                  const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
    420420{
    … …  
    423423    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    424424
    425     PRTTARSTORAGEINTERNAL pInt = (PRTTARSTORAGEINTERNAL)pvStorage;
     425    PTARSTORAGEINTERNAL pInt = (PTARSTORAGEINTERNAL)pvStorage;
    426426
    427427    DEBUG_PRINT_FLOW();
    … …  
    430430}
    431431
    432 static int rtTarReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
     432static int tarReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
    433433                                 void *pvBuf, size_t cbRead, size_t *pcbRead)
    434434{
    … …  
    437437    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    438438
    439     PRTTARSTORAGEINTERNAL pInt = (PRTTARSTORAGEINTERNAL)pvStorage;
     439    PTARSTORAGEINTERNAL pInt = (PTARSTORAGEINTERNAL)pvStorage;
    440440
    441441//    DEBUG_PRINT_FLOW();
    … …  
    444444}
    445445
    446 static int rtTarFlushSyncCallback(void *pvUser, void *pvStorage)
     446static int tarFlushSyncCallback(void *pvUser, void *pvStorage)
    447447{
    448448    /* Validate input. */
    … …  
    459459 ******************************************************************************/
    460460
    461 DECLCALLBACK(int) rtSha1CalcWorkerThread(RTTHREAD /* aThread */, void *pvUser)
    462 {
    463     /* Validate input. */
    464     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    465 
    466     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvUser;
     461DECLCALLBACK(int) sha1CalcWorkerThread(RTTHREAD /* aThread */, void *pvUser)
     462{
     463    /* Validate input. */
     464    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     465
     466    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvUser;
    467467
    468468    PVDINTERFACE pIO = VDInterfaceGet(pInt->pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    … …  
    609609}
    610610
    611 DECLINLINE(int) rtSha1SignalManifestThread(PRTSHA1STORAGEINTERNAL pInt, uint32_t uStatus)
     611DECLINLINE(int) sha1SignalManifestThread(PSHA1STORAGEINTERNAL pInt, uint32_t uStatus)
    612612{
    613613    ASMAtomicWriteU32(&pInt->u32Status, uStatus);
    … …  
    615615}
    616616
    617 DECLINLINE(int) rtSha1WaitForManifestThreadFinished(PRTSHA1STORAGEINTERNAL pInt)
     617DECLINLINE(int) sha1WaitForManifestThreadFinished(PSHA1STORAGEINTERNAL pInt)
    618618{
    619619//    RTPrintf("start\n");
    … …  
    632632}
    633633
    634 DECLINLINE(int) rtSha1FlushCurBuf(PRTSHA1STORAGEINTERNAL pInt)
     634DECLINLINE(int) sha1FlushCurBuf(PSHA1STORAGEINTERNAL pInt)
    635635{
    636636    int rc = VINF_SUCCESS;
    … …  
    638638    {
    639639        /* Let the write worker thread start immediately. */
    640         rc = rtSha1SignalManifestThread(pInt, STATUS_WRITE);
     640        rc = sha1SignalManifestThread(pInt, STATUS_WRITE);
    641641        if (RT_FAILURE(rc))
    642642            return rc;
    643643
    644644        /* Wait until the write worker thread has finished. */
    645         rc = rtSha1WaitForManifestThreadFinished(pInt);
     645        rc = sha1WaitForManifestThreadFinished(pInt);
    646646    }
    647647
    … …  
    649649}
    650650
    651 static int rtSha1OpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
     651static int sha1OpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
    652652                              PFNVDCOMPLETED pfnCompleted, void **ppInt)
    653653{
    … …  
    659659    AssertReturn((fOpen & RTFILE_O_READWRITE) != RTFILE_O_READWRITE, VERR_INVALID_PARAMETER); /* No read/write allowed */
    660660
    661     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     661    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    662662    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    663663    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    667667    DEBUG_PRINT_FLOW();
    668668
    669     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)RTMemAllocZ(sizeof(RTSHA1STORAGEINTERNAL));
     669    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)RTMemAllocZ(sizeof(SHA1STORAGEINTERNAL));
    670670    if (!pInt)
    671671        return VERR_NO_MEMORY;
    … …  
    709709            break;
    710710        /* Create the worker thread. */
    711         rc = RTThreadCreate(&pInt->pWorkerThread, rtSha1CalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, RTTHREADFLAGS_WAITABLE, "SHA1-Worker");
     711        rc = RTThreadCreate(&pInt->pWorkerThread, sha1CalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, RTTHREADFLAGS_WAITABLE, "SHA1-Worker");
    712712        if (RT_FAILURE(rc))
    713713            break;
    … …  
    727727        {
    728728            /* Immediately let the worker thread start the reading. */
    729             rc = rtSha1SignalManifestThread(pInt, STATUS_READ);
     729            rc = sha1SignalManifestThread(pInt, STATUS_READ);
    730730        }
    731731    }
    … …  
    736736        if (pInt->pWorkerThread)
    737737        {
    738             rtSha1SignalManifestThread(pInt, STATUS_END);
     738            sha1SignalManifestThread(pInt, STATUS_END);
    739739            RTThreadWait(pInt->pWorkerThread, RT_INDEFINITE_WAIT, 0);
    740740        }
    … …  
    755755}
    756756
    757 static int rtSha1CloseCallback(void *pvUser, void *pvStorage)
    758 {
    759     /* Validate input. */
    760     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    761     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    762 
    763     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     757static int sha1CloseCallback(void *pvUser, void *pvStorage)
     758{
     759    /* Validate input. */
     760    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     761    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     762
     763    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    764764    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    765765    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    767767    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
    768768
    769     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvStorage;
     769    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
    770770
    771771    DEBUG_PRINT_FLOW();
    … …  
    774774
    775775    /* Make sure all pending writes are flushed */
    776     rc = rtSha1FlushCurBuf(pInt);
     776    rc = sha1FlushCurBuf(pInt);
    777777
    778778    if (pInt->pWorkerThread)
    779779    {
    780780        /* Signal the worker thread to end himself */
    781         rc = rtSha1SignalManifestThread(pInt, STATUS_END);
     781        rc = sha1SignalManifestThread(pInt, STATUS_END);
    782782        /* Worker thread stopped? */
    783783        rc = RTThreadWait(pInt->pWorkerThread, RT_INDEFINITE_WAIT, 0);
    … …  
    820820}
    821821
    822 static int rtSha1DeleteCallback(void *pvUser, const char *pcszFilename)
    823 {
    824     /* Validate input. */
    825     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    826 
    827     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     822static int sha1DeleteCallback(void *pvUser, const char *pcszFilename)
     823{
     824    /* Validate input. */
     825    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     826
     827    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    828828    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    829829    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    836836}
    837837
    838 static int rtSha1MoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
    839 {
    840     /* Validate input. */
    841     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    842 
    843     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     838static int sha1MoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
     839{
     840    /* Validate input. */
     841    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     842
     843    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    844844    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    845845    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    852852}
    853853
    854 static int rtSha1GetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
    855 {
    856     /* Validate input. */
    857     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    858 
    859     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     854static int sha1GetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
     855{
     856    /* Validate input. */
     857    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     858
     859    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    860860    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    861861    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    868868}
    869869
    870 static int rtSha1GetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
    871 {
    872     /* Validate input. */
    873     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    874 
    875     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     870static int sha1GetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
     871{
     872    /* Validate input. */
     873    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     874
     875    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    876876    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    877877    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    885885
    886886
    887 static int rtSha1GetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
    888 {
    889     /* Validate input. */
    890     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    891     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    892 
    893     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     887static int sha1GetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
     888{
     889    /* Validate input. */
     890    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     891    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     892
     893    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    894894    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    895895    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    897897    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
    898898
    899     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvStorage;
     899    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
    900900
    901901    DEBUG_PRINT_FLOW();
    … …  
    911911}
    912912
    913 static int rtSha1SetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
    914 {
    915     /* Validate input. */
    916     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    917     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    918 
    919     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     913static int sha1SetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
     914{
     915    /* Validate input. */
     916    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     917    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     918
     919    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    920920    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    921921    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    923923    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
    924924
    925     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvStorage;
     925    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
    926926
    927927    DEBUG_PRINT_FLOW();
    … …  
    930930}
    931931
    932 static int rtSha1WriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
     932static int sha1WriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
    933933                                 const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
    934934{
    … …  
    937937    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    938938
    939     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     939    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    940940    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    941941    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    943943    AssertPtrReturn(pCallbacks, VERR_INVALID_PARAMETER);
    944944
    945     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvStorage;
     945    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
    946946
    947947    DEBUG_PRINT_FLOW();
    … …  
    965965            size_t cbToWrite = RT_MIN(pInt->cbZeroBuf, cbSize - cbAllWritten);
    966966            size_t cbWritten = 0;
    967             rc = rtSha1WriteSyncCallback(pvUser, pvStorage, pInt->cbCurAll,
     967            rc = sha1WriteSyncCallback(pvUser, pvStorage, pInt->cbCurAll,
    968968                                         pInt->pvZeroBuf, cbToWrite, &cbWritten);
    969969            if (RT_FAILURE(rc))
    … …  
    990990        if ((cbWrite - cbAllWritten) > cbAvail)
    991991        {
    992             rc = rtSha1SignalManifestThread(pInt, STATUS_WRITE);
     992            rc = sha1SignalManifestThread(pInt, STATUS_WRITE);
    993993            if(RT_FAILURE(rc))
    994994                break;
    … …  
    996996            if (cbAvail == 0)
    997997            {
    998                 rc = rtSha1WaitForManifestThreadFinished(pInt);
     998                rc = sha1WaitForManifestThreadFinished(pInt);
    999999                if (RT_FAILURE(rc))
    10001000                    break;
    … …  
    10221022    if (   RT_SUCCESS(rc)
    10231023           && RTCircBufUsed(pInt->pCircBuf) >= (RTCircBufSize(pInt->pCircBuf) / 2))
    1024         rc = rtSha1SignalManifestThread(pInt, STATUS_WRITE);
     1024        rc = sha1SignalManifestThread(pInt, STATUS_WRITE);
    10251025
    10261026    return rc;
    10271027}
    10281028
    1029 static int rtSha1ReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
     1029static int sha1ReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
    10301030                                  void *pvBuf, size_t cbRead, size_t *pcbRead)
    10311031{
    … …  
    10341034    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    10351035
    1036     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     1036    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    10371037    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    10381038    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    10421042//    DEBUG_PRINT_FLOW();
    10431043
    1044     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvStorage;
     1044    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
    10451045
    10461046    int rc = VINF_SUCCESS;
    … …  
    10531053    if (pInt->cbCurAll < uOffset)
    10541054    {
    1055         rc = rtSha1ReadSyncCallback(pvUser, pvStorage, pInt->cbCurAll, 0,
     1055        rc = sha1ReadSyncCallback(pvUser, pvStorage, pInt->cbCurAll, 0,
    10561056                                    (size_t)(uOffset - pInt->cbCurAll), 0);
    10571057        if (RT_FAILURE(rc))
    … …  
    10751075        if ((cbRead - cbAllRead) > cbAvail)
    10761076        {
    1077             rc = rtSha1SignalManifestThread(pInt, STATUS_READ);
     1077            rc = sha1SignalManifestThread(pInt, STATUS_READ);
    10781078            if(RT_FAILURE(rc))
    10791079                break;
    … …  
    10811081            if (cbAvail == 0)
    10821082            {
    1083                 rc = rtSha1WaitForManifestThreadFinished(pInt);
     1083                rc = sha1WaitForManifestThreadFinished(pInt);
    10841084                if (RT_FAILURE(rc))
    10851085                    break;
    … …  
    11121112    if (   RT_SUCCESS(rc)
    11131113        && RTCircBufFree(pInt->pCircBuf) >= (RTCircBufSize(pInt->pCircBuf) / 2))
    1114         rc = rtSha1SignalManifestThread(pInt, STATUS_READ);
     1114        rc = sha1SignalManifestThread(pInt, STATUS_READ);
    11151115
    11161116    return rc;
    11171117}
    11181118
    1119 static int rtSha1FlushSyncCallback(void *pvUser, void *pvStorage)
    1120 {
    1121     /* Validate input. */
    1122     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
    1123     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
    1124 
    1125     PRTSHA1STORAGE pSha1Storage = (PRTSHA1STORAGE)pvUser;
     1119static int sha1FlushSyncCallback(void *pvUser, void *pvStorage)
     1120{
     1121    /* Validate input. */
     1122    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
     1123    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
     1124
     1125    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
    11261126    PVDINTERFACE pIO = VDInterfaceGet(pSha1Storage->pVDImageIfaces, VDINTERFACETYPE_IO);
    11271127    AssertPtrReturn(pIO, VERR_INVALID_PARAMETER);
    … …  
    11311131    DEBUG_PRINT_FLOW();
    11321132
    1133     PRTSHA1STORAGEINTERNAL pInt = (PRTSHA1STORAGEINTERNAL)pvStorage;
     1133    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
    11341134
    11351135    /* Check if there is still something in the buffer. If yes, flush it. */
    1136     int rc = rtSha1FlushCurBuf(pInt);
     1136    int rc = sha1FlushCurBuf(pInt);
    11371137    if (RT_FAILURE(rc))
    11381138        return rc;
    … …  
    11451145 ******************************************************************************/
    11461146
    1147 PVDINTERFACEIO RTSha1CreateInterface()
     1147PVDINTERFACEIO Sha1CreateInterface()
    11481148{
    11491149    PVDINTERFACEIO pCallbacks = (PVDINTERFACEIO)RTMemAllocZ(sizeof(VDINTERFACEIO));
    … …  
    11531153    pCallbacks->cbSize                 = sizeof(VDINTERFACEIO);
    11541154    pCallbacks->enmInterface           = VDINTERFACETYPE_IO;
    1155     pCallbacks->pfnOpen                = rtSha1OpenCallback;
    1156     pCallbacks->pfnClose               = rtSha1CloseCallback;
    1157     pCallbacks->pfnDelete              = rtSha1DeleteCallback;
    1158     pCallbacks->pfnMove                = rtSha1MoveCallback;
    1159     pCallbacks->pfnGetFreeSpace        = rtSha1GetFreeSpaceCallback;
    1160     pCallbacks->pfnGetModificationTime = rtSha1GetModificationTimeCallback;
    1161     pCallbacks->pfnGetSize             = rtSha1GetSizeCallback;
    1162     pCallbacks->pfnSetSize             = rtSha1SetSizeCallback;
    1163     pCallbacks->pfnReadSync            = rtSha1ReadSyncCallback;
    1164     pCallbacks->pfnWriteSync           = rtSha1WriteSyncCallback;
    1165     pCallbacks->pfnFlushSync           = rtSha1FlushSyncCallback;
     1155    pCallbacks->pfnOpen                = sha1OpenCallback;
     1156    pCallbacks->pfnClose               = sha1CloseCallback;
     1157    pCallbacks->pfnDelete              = sha1DeleteCallback;
     1158    pCallbacks->pfnMove                = sha1MoveCallback;
     1159    pCallbacks->pfnGetFreeSpace        = sha1GetFreeSpaceCallback;
     1160    pCallbacks->pfnGetModificationTime = sha1GetModificationTimeCallback;
     1161    pCallbacks->pfnGetSize             = sha1GetSizeCallback;
     1162    pCallbacks->pfnSetSize             = sha1SetSizeCallback;
     1163    pCallbacks->pfnReadSync            = sha1ReadSyncCallback;
     1164    pCallbacks->pfnWriteSync           = sha1WriteSyncCallback;
     1165    pCallbacks->pfnFlushSync           = sha1FlushSyncCallback;
    11661166
    11671167    return pCallbacks;
    11681168}
    11691169
    1170 PVDINTERFACEIO RTFileCreateInterface()
     1170PVDINTERFACEIO FileCreateInterface()
    11711171{
    11721172    PVDINTERFACEIO pCallbacks = (PVDINTERFACEIO)RTMemAllocZ(sizeof(VDINTERFACEIO));
    … …  
    11761176    pCallbacks->cbSize                 = sizeof(VDINTERFACEIO);
    11771177    pCallbacks->enmInterface           = VDINTERFACETYPE_IO;
    1178     pCallbacks->pfnOpen                = rtFileOpenCallback;
    1179     pCallbacks->pfnClose               = rtFileCloseCallback;
    1180     pCallbacks->pfnDelete              = rtFileDeleteCallback;
    1181     pCallbacks->pfnMove                = rtFileMoveCallback;
    1182     pCallbacks->pfnGetFreeSpace        = rtFileGetFreeSpaceCallback;
    1183     pCallbacks->pfnGetModificationTime = rtFileGetModificationTimeCallback;
    1184     pCallbacks->pfnGetSize             = rtFileGetSizeCallback;
    1185     pCallbacks->pfnSetSize             = rtFileSetSizeCallback;
    1186     pCallbacks->pfnReadSync            = rtFileReadSyncCallback;
    1187     pCallbacks->pfnWriteSync           = rtFileWriteSyncCallback;
    1188     pCallbacks->pfnFlushSync           = rtFileFlushSyncCallback;
     1178    pCallbacks->pfnOpen                = fileOpenCallback;
     1179    pCallbacks->pfnClose               = fileCloseCallback;
     1180    pCallbacks->pfnDelete              = fileDeleteCallback;
     1181    pCallbacks->pfnMove                = fileMoveCallback;
     1182    pCallbacks->pfnGetFreeSpace        = fileGetFreeSpaceCallback;
     1183    pCallbacks->pfnGetModificationTime = fileGetModificationTimeCallback;
     1184    pCallbacks->pfnGetSize             = fileGetSizeCallback;
     1185    pCallbacks->pfnSetSize             = fileSetSizeCallback;
     1186    pCallbacks->pfnReadSync            = fileReadSyncCallback;
     1187    pCallbacks->pfnWriteSync           = fileWriteSyncCallback;
     1188    pCallbacks->pfnFlushSync           = fileFlushSyncCallback;
    11891189
    11901190    return pCallbacks;
    11911191}
    11921192
    1193 PVDINTERFACEIO RTTarCreateInterface()
     1193PVDINTERFACEIO TarCreateInterface()
    11941194{
    11951195    PVDINTERFACEIO pCallbacks = (PVDINTERFACEIO)RTMemAllocZ(sizeof(VDINTERFACEIO));
    … …  
    11991199    pCallbacks->cbSize                 = sizeof(VDINTERFACEIO);
    12001200    pCallbacks->enmInterface           = VDINTERFACETYPE_IO;
    1201     pCallbacks->pfnOpen                = rtTarOpenCallback;
    1202     pCallbacks->pfnClose               = rtTarCloseCallback;
    1203     pCallbacks->pfnDelete              = rtTarDeleteCallback;
    1204     pCallbacks->pfnMove                = rtTarMoveCallback;
    1205     pCallbacks->pfnGetFreeSpace        = rtTarGetFreeSpaceCallback;
    1206     pCallbacks->pfnGetModificationTime = rtTarGetModificationTimeCallback;
    1207     pCallbacks->pfnGetSize             = rtTarGetSizeCallback;
    1208     pCallbacks->pfnSetSize             = rtTarSetSizeCallback;
    1209     pCallbacks->pfnReadSync            = rtTarReadSyncCallback;
    1210     pCallbacks->pfnWriteSync           = rtTarWriteSyncCallback;
    1211     pCallbacks->pfnFlushSync           = rtTarFlushSyncCallback;
     1201    pCallbacks->pfnOpen                = tarOpenCallback;
     1202    pCallbacks->pfnClose               = tarCloseCallback;
     1203    pCallbacks->pfnDelete              = tarDeleteCallback;
     1204    pCallbacks->pfnMove                = tarMoveCallback;
     1205    pCallbacks->pfnGetFreeSpace        = tarGetFreeSpaceCallback;
     1206    pCallbacks->pfnGetModificationTime = tarGetModificationTimeCallback;
     1207    pCallbacks->pfnGetSize             = tarGetSizeCallback;
     1208    pCallbacks->pfnSetSize             = tarSetSizeCallback;
     1209    pCallbacks->pfnReadSync            = tarReadSyncCallback;
     1210    pCallbacks->pfnWriteSync           = tarWriteSyncCallback;
     1211    pCallbacks->pfnFlushSync           = tarFlushSyncCallback;
    12121212
    12131213    return pCallbacks;
    12141214}
    12151215
    1216 int RTSha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, void *pvUser)
     1216int Sha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, void *pvUser)
    12171217{
    12181218    /* Validate input. */
    … …  
    12801280}
    12811281
    1282 int RTSha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pCallbacks, void *pvUser)
     1282int Sha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pCallbacks, void *pvUser)
    12831283{
    12841284    /* Validate input. */

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

    r33921 r34101  
    803803    HRESULT rc = S_OK;
    804804
    805     PVDINTERFACEIO pRTSha1Callbacks = 0;
    806     PVDINTERFACEIO pRTFileCallbacks = 0;
     805    PVDINTERFACEIO pSha1Callbacks = 0;
     806    PVDINTERFACEIO pFileCallbacks = 0;
    807807    do
    808808    {
    809         pRTSha1Callbacks = RTSha1CreateInterface();
    810         if (!pRTSha1Callbacks)
     809        pSha1Callbacks = Sha1CreateInterface();
     810        if (!pSha1Callbacks)
    811811        {
    812812            rc = E_OUTOFMEMORY;
    813813            break;
    814814        }
    815         pRTFileCallbacks = RTFileCreateInterface();
    816         if (!pRTFileCallbacks)
     815        pFileCallbacks = FileCreateInterface();
     816        if (!pFileCallbacks)
    817817        {
    818818            rc = E_OUTOFMEMORY;
    … …  
    820820        }
    821821        VDINTERFACE VDInterfaceIO;
    822         RTSHA1STORAGE storage;
     822        SHA1STORAGE storage;
    823823        RT_ZERO(storage);
    824         int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IORTFile",
    825                                  VDINTERFACETYPE_IO, pRTFileCallbacks,
     824        int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOFile",
     825                                 VDINTERFACETYPE_IO, pFileCallbacks,
    826826                                 0, &storage.pVDImageIfaces);
    827827        if (RT_FAILURE(vrc))
    … …  
    830830            break;
    831831        }
    832         rc = readFSImpl(pTask, pRTSha1Callbacks, &storage);
     832        rc = readFSImpl(pTask, pSha1Callbacks, &storage);
    833833    }while(0);
    834834
    835835    /* Cleanup */
    836     if (pRTSha1Callbacks)
    837         RTMemFree(pRTSha1Callbacks);
    838     if (pRTFileCallbacks)
    839         RTMemFree(pRTFileCallbacks);
     836    if (pSha1Callbacks)
     837        RTMemFree(pSha1Callbacks);
     838    if (pFileCallbacks)
     839        RTMemFree(pFileCallbacks);
    840840
    841841    LogFlowFunc(("rc=%Rhrc\n", rc));
    … …  
    858858    HRESULT rc = S_OK;
    859859
    860     PVDINTERFACEIO pRTSha1Callbacks = 0;
    861     PVDINTERFACEIO pRTTarCallbacks = 0;
     860    PVDINTERFACEIO pSha1Callbacks = 0;
     861    PVDINTERFACEIO pTarCallbacks = 0;
    862862    do
    863863    {
    864         pRTSha1Callbacks = RTSha1CreateInterface();
    865         if (!pRTSha1Callbacks)
     864        pSha1Callbacks = Sha1CreateInterface();
     865        if (!pSha1Callbacks)
    866866        {
    867867            rc = E_OUTOFMEMORY;
    868868            break;
    869869        }
    870         pRTTarCallbacks = RTTarCreateInterface();
    871         if (!pRTTarCallbacks)
     870        pTarCallbacks = TarCreateInterface();
     871        if (!pTarCallbacks)
    872872        {
    873873            rc = E_OUTOFMEMORY;
    … …  
    875875        }
    876876        VDINTERFACE VDInterfaceIO;
    877         RTSHA1STORAGE storage;
     877        SHA1STORAGE storage;
    878878        RT_ZERO(storage);
    879         vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IORTTar",
    880                              VDINTERFACETYPE_IO, pRTTarCallbacks,
     879        vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
     880                             VDINTERFACETYPE_IO, pTarCallbacks,
    881881                             tar, &storage.pVDImageIfaces);
    882882        if (RT_FAILURE(vrc))
    … …  
    885885            break;
    886886        }
    887         rc = readFSImpl(pTask, pRTSha1Callbacks, &storage);
     887        rc = readFSImpl(pTask, pSha1Callbacks, &storage);
    888888    }while(0);
    889889
    … …  
    891891
    892892    /* Cleanup */
    893     if (pRTSha1Callbacks)
    894         RTMemFree(pRTSha1Callbacks);
    895     if (pRTTarCallbacks)
    896         RTMemFree(pRTTarCallbacks);
     893    if (pSha1Callbacks)
     894        RTMemFree(pSha1Callbacks);
     895    if (pTarCallbacks)
     896        RTMemFree(pTarCallbacks);
    897897
    898898    LogFlowFunc(("rc=%Rhrc\n", rc));
    … …  
    902902}
    903903
    904 HRESULT Appliance::readFSImpl(TaskOVF *pTask, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage)
     904HRESULT Appliance::readFSImpl(TaskOVF *pTask, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
    905905{
    906906    LogFlowFuncEnter();
    … …  
    916916        /* Read the OVF into a memory buffer */
    917917        size_t cbSize = 0;
    918         int vrc = RTSha1ReadBuf(strOvfFile.c_str(), &pvTmpBuf, &cbSize, pCallbacks, pStorage);
     918        int vrc = Sha1ReadBuf(strOvfFile.c_str(), &pvTmpBuf, &cbSize, pCallbacks, pStorage);
    919919        if (   RT_FAILURE(vrc)
    920920            || !pvTmpBuf)
    … …  
    12091209    HRESULT rc = S_OK;
    12101210
    1211     PVDINTERFACEIO pRTSha1Callbacks = 0;
    1212     PVDINTERFACEIO pRTFileCallbacks = 0;
     1211    PVDINTERFACEIO pSha1Callbacks = 0;
     1212    PVDINTERFACEIO pFileCallbacks = 0;
    12131213    void *pvMfBuf = 0;
    12141214    writeLock.release();
    … …  
    12161216    {
    12171217        /* Create the necessary file access interfaces. */
    1218         pRTSha1Callbacks = RTSha1CreateInterface();
    1219         if (!pRTSha1Callbacks)
     1218        pSha1Callbacks = Sha1CreateInterface();
     1219        if (!pSha1Callbacks)
    12201220            throw E_OUTOFMEMORY;
    1221         pRTFileCallbacks = RTFileCreateInterface();
    1222         if (!pRTFileCallbacks)
     1221        pFileCallbacks = FileCreateInterface();
     1222        if (!pFileCallbacks)
    12231223            throw E_OUTOFMEMORY;
    12241224
    12251225        VDINTERFACE VDInterfaceIO;
    1226         RTSHA1STORAGE storage;
     1226        SHA1STORAGE storage;
    12271227        RT_ZERO(storage);
    12281228        storage.fCreateDigest = true;
    1229         int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IORTFile",
    1230                                  VDINTERFACETYPE_IO, pRTFileCallbacks,
     1229        int vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOFile",
     1230                                 VDINTERFACETYPE_IO, pFileCallbacks,
    12311231                                 0, &storage.pVDImageIfaces);
    12321232        if (RT_FAILURE(vrc))
    … …  
    12401240        storage.fCreateDigest = RTFileExists(strMfFile.c_str());
    12411241        /* Now import the appliance. */
    1242         importMachines(stack, pRTSha1Callbacks, &storage);
     1242        importMachines(stack, pSha1Callbacks, &storage);
    12431243        /* Read & verify the manifest file, if there is one. */
    12441244        if (storage.fCreateDigest)
    … …  
    12461246            /* Add the ovf file to the digest list. */
    12471247            stack.llSrcDisksDigest.push_front(STRPAIR(pTask->locInfo.strPath, m->strOVFSHA1Digest));
    1248             rc = readManifestFile(strMfFile, &pvMfBuf, &cbMfSize, pRTSha1Callbacks, &storage);
     1248            rc = readManifestFile(strMfFile, &pvMfBuf, &cbMfSize, pSha1Callbacks, &storage);
    12491249            if (FAILED(rc)) throw rc;
    12501250            rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
    … …  
    12611261    if (pvMfBuf)
    12621262        RTMemFree(pvMfBuf);
    1263     if (pRTSha1Callbacks)
    1264         RTMemFree(pRTSha1Callbacks);
    1265     if (pRTFileCallbacks)
    1266         RTMemFree(pRTFileCallbacks);
     1263    if (pSha1Callbacks)
     1264        RTMemFree(pSha1Callbacks);
     1265    if (pFileCallbacks)
     1266        RTMemFree(pFileCallbacks);
    12671267
    12681268    LogFlowFunc(("rc=%Rhrc\n", rc));
    … …  
    12851285    HRESULT rc = S_OK;
    12861286
    1287     PVDINTERFACEIO pRTSha1Callbacks = 0;
    1288     PVDINTERFACEIO pRTTarCallbacks = 0;
     1287    PVDINTERFACEIO pSha1Callbacks = 0;
     1288    PVDINTERFACEIO pTarCallbacks = 0;
    12891289    void *pvMfBuf = 0;
    12901290    writeLock.release();
    … …  
    12921292    {
    12931293        /* Create the necessary file access interfaces. */
    1294         pRTSha1Callbacks = RTSha1CreateInterface();
    1295         if (!pRTSha1Callbacks)
     1294        pSha1Callbacks = Sha1CreateInterface();
     1295        if (!pSha1Callbacks)
    12961296            throw E_OUTOFMEMORY;
    1297         pRTTarCallbacks = RTTarCreateInterface();
    1298         if (!pRTTarCallbacks)
     1297        pTarCallbacks = TarCreateInterface();
     1298        if (!pTarCallbacks)
    12991299            throw E_OUTOFMEMORY;
    13001300
    13011301        VDINTERFACE VDInterfaceIO;
    1302         RTSHA1STORAGE storage;
     1302        SHA1STORAGE storage;
    13031303        RT_ZERO(storage);
    1304         vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IORTTar",
    1305                              VDINTERFACETYPE_IO, pRTTarCallbacks,
     1304        vrc = VDInterfaceAdd(&VDInterfaceIO, "Appliance::IOTar",
     1305                             VDINTERFACETYPE_IO, pTarCallbacks,
    13061306                             tar, &storage.pVDImageIfaces);
    13071307        if (RT_FAILURE(vrc))
    … …  
    13161316                           tr("Internal error (%Rrc)"), vrc);
    13171317
    1318         PVDINTERFACEIO pCallbacks = pRTSha1Callbacks;
    1319         PRTSHA1STORAGE pStorage = &storage;
     1318        PVDINTERFACEIO pCallbacks = pSha1Callbacks;
     1319        PSHA1STORAGE pStorage = &storage;
    13201320
    13211321        /* We always need to create the digest, cause we didn't know if there
    … …  
    13691369    if (pvMfBuf)
    13701370        RTMemFree(pvMfBuf);
    1371     if (pRTSha1Callbacks)
    1372         RTMemFree(pRTSha1Callbacks);
    1373     if (pRTTarCallbacks)
    1374         RTMemFree(pRTTarCallbacks);
     1371    if (pSha1Callbacks)
     1372        RTMemFree(pSha1Callbacks);
     1373    if (pTarCallbacks)
     1374        RTMemFree(pTarCallbacks);
    13751375
    13761376    LogFlowFunc(("rc=%Rhrc\n", rc));
    … …  
    15711571}
    15721572
    1573 HRESULT Appliance::readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage)
     1573HRESULT Appliance::readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
    15741574{
    15751575    HRESULT rc = S_OK;
    … …  
    15771577    bool fOldDigest = pStorage->fCreateDigest;
    15781578    pStorage->fCreateDigest = false; /* No digest for the manifest file */
    1579     int vrc = RTSha1ReadBuf(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
     1579    int vrc = Sha1ReadBuf(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
    15801580    if (   RT_FAILURE(vrc)
    15811581        && vrc != VERR_FILE_NOT_FOUND)
    … …  
    15881588}
    15891589
    1590 HRESULT Appliance::readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage)
     1590HRESULT Appliance::readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
    15911591{
    15921592    HRESULT rc = S_OK;
    … …  
    17621762                                   ImportStack &stack,
    17631763                                   PVDINTERFACEIO pCallbacks,
    1764                                    PRTSHA1STORAGE pStorage)
     1764                                   PSHA1STORAGE pStorage)
    17651765{
    17661766    ComObjPtr<Progress> pProgress;
    … …  
    19011901                                     ImportStack &stack,
    19021902                                     PVDINTERFACEIO pCallbacks,
    1903                                      PRTSHA1STORAGE pStorage)
     1903                                     PSHA1STORAGE pStorage)
    19041904{
    19051905    HRESULT rc;
    … …  
    24672467                                  ImportStack &stack,
    24682468                                  PVDINTERFACEIO pCallbacks,
    2469                                   PRTSHA1STORAGE pStorage)
     2469                                  PSHA1STORAGE pStorage)
    24702470{
    24712471    Assert(vsdescThis->m->pConfig);
    … …  
    27242724void Appliance::importMachines(ImportStack &stack,
    27252725                               PVDINTERFACEIO pCallbacks,
    2726                                PRTSHA1STORAGE pStorage)
     2726                               PSHA1STORAGE pStorage)
    27272727{
    27282728    HRESULT rc = S_OK;

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

    r33651 r34101  
    3535typedef struct VDINTERFACE   *PVDINTERFACE;
    3636typedef struct VDINTERFACEIO *PVDINTERFACEIO;
    37 typedef struct RTSHA1STORAGE *PRTSHA1STORAGE;
     37typedef struct SHA1STORAGE *PSHA1STORAGE;
    3838
    3939namespace ovf
    … …  
    152152    HRESULT readFSOVF(TaskOVF *pTask);
    153153    HRESULT readFSOVA(TaskOVF *pTask);
    154     HRESULT readFSImpl(TaskOVF *pTask, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage);
     154    HRESULT readFSImpl(TaskOVF *pTask, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage);
    155155    HRESULT readS3(TaskOVF *pTask);
    156156
    … …  
    166166    HRESULT importS3(TaskOVF *pTask);
    167167
    168     HRESULT readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage);
    169     HRESULT readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage);
     168    HRESULT readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage);
     169    HRESULT readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage);
    170170    HRESULT verifyManifestFile(const Utf8Str &strFile, ImportStack &stack, void *pvBuf, size_t cbSize);
    171171
    … …  
    181181                            ImportStack &stack,
    182182                            PVDINTERFACEIO pCallbacks,
    183                             PRTSHA1STORAGE pStorage);
     183                            PSHA1STORAGE pStorage);
    184184    void importMachineGeneric(const ovf::VirtualSystem &vsysThis,
    185185                              ComObjPtr<VirtualSystemDescription> &vsdescThis,
    … …  
    187187                              ImportStack &stack,
    188188                              PVDINTERFACEIO pCallbacks,
    189                               PRTSHA1STORAGE pStorage);
     189                              PSHA1STORAGE pStorage);
    190190    void importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
    191191                           ComPtr<IMachine> &pNewMachine,
    192192                           ImportStack &stack,
    193193                           PVDINTERFACEIO pCallbacks,
    194                            PRTSHA1STORAGE pStorage);
     194                           PSHA1STORAGE pStorage);
    195195    void importMachines(ImportStack &stack,
    196196                        PVDINTERFACEIO pCallbacks,
    197                         PRTSHA1STORAGE pStorage);
     197                        PSHA1STORAGE pStorage);
    198198
    199199    /*******************************************************************************
    … …  
    206206    HRESULT writeFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
    207207    HRESULT writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
    208     HRESULT writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PRTSHA1STORAGE pStorage);
     208    HRESULT writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage);
    209209    HRESULT writeS3(TaskOVF *pTask);
    210210

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

    r34093 r34101  
    223223Utf8Str convertNetworkAttachmentTypeToString(NetworkAttachmentType_T type);
    224224
    225 typedef struct RTSHA1STORAGE
     225typedef struct SHA1STORAGE
    226226{
    227227    PVDINTERFACE pVDImageIfaces;
    228228    bool         fCreateDigest;
    229229    Utf8Str      strDigest;
    230 } RTSHA1STORAGE, *PRTSHA1STORAGE;
    231 
    232 /** @todo r=bird: RT is a prefix reserved for IPRT, using it outside will only
    233  * cause confusion. Please find a different prefix unless the plan is to move
    234  * this code into IPRT. (I can find no @todo in the code hinting at this.) */
    235 PVDINTERFACEIO RTSha1CreateInterface();
    236 PVDINTERFACEIO RTFileCreateInterface();
    237 PVDINTERFACEIO RTTarCreateInterface();
    238 int RTSha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, void *pvUser);
    239 int RTSha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pCallbacks, void *pvUser);
     230} SHA1STORAGE, *PSHA1STORAGE;
     231
     232PVDINTERFACEIO Sha1CreateInterface();
     233PVDINTERFACEIO FileCreateInterface();
     234PVDINTERFACEIO TarCreateInterface();
     235int Sha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, void *pvUser);
     236int Sha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pCallbacks, void *pvUser);
    240237
    241238#endif // ____H_APPLIANCEIMPLPRIVATE
Note: See TracChangeset for help on using the changeset viewer.

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