VirtualBox

Changeset 98320 in vbox


Ignore:
Timestamp:
Jan 26, 2023 3:50:47 PM (2 years ago)
Author:
vboxsync
Message:

FE/VBoxBugReport: Move away from deprecated RTTar* API and use the VFS implementation instead, allows to skip creation of the temporary archive before compression

Location:
trunk/src/VBox/Frontends/VBoxBugReport
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxBugReport/VBoxBugReport.cpp

    r98103 r98320  
    270270BugReportStream::BugReportStream(const char *pszTitle) : BugReportItem(pszTitle)
    271271{
     272    m_hVfsIos = NIL_RTVFSIOSTREAM;
    272273    handleRtError(RTPathTemp(m_szFileName, RTPATH_MAX),
    273274                  "Failed to obtain path to temporary folder");
    … …  
    276277    handleRtError(RTFileCreateTemp(m_szFileName, 0600),
    277278                  "Failed to create temporary file '%s'", m_szFileName);
    278     handleRtError(RTStrmOpen(m_szFileName, "w", &m_Strm),
     279    handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN | RTFILE_O_WRITE | RTFILE_O_DENY_NONE, &m_hVfsIos),
    279280                  "Failed to open '%s'", m_szFileName);
    280281}
    … …  
    282283BugReportStream::~BugReportStream()
    283284{
    284     if (m_Strm)
    285         RTStrmClose(m_Strm);
     285    if (m_hVfsIos != NIL_RTVFSIOSTREAM)
     286        RTVfsIoStrmRelease(m_hVfsIos);
    286287    RTFileDelete(m_szFileName);
    287288}
    … …  
    291292    va_list va;
    292293    va_start(va, pszFmt);
    293     int cb = RTStrmPrintfV(m_Strm, pszFmt, va);
     294    int cb = RTVfsIoStrmPrintfV(m_hVfsIos, pszFmt, va);
    294295    va_end(va);
    295296    return cb;
    … …  
    298299int BugReportStream::putStr(const char *pszString)
    299300{
    300     return RTStrmPutStr(m_Strm, pszString);
    301 }
    302 
    303 PRTSTREAM BugReportStream::getStream(void)
    304 {
    305     RTStrmClose(m_Strm);
    306     handleRtError(RTStrmOpen(m_szFileName, "r", &m_Strm),
     301    return RTVfsIoStrmPrintf(m_hVfsIos, "%s", pszString);
     302}
     303
     304RTVFSIOSTREAM BugReportStream::getStream(void)
     305{
     306    RTVfsIoStrmRelease(m_hVfsIos);
     307    handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, &m_hVfsIos),
    307308                  "Failed to open '%s'", m_szFileName);
    308     return m_Strm;
     309    return m_hVfsIos;
    309310}
    310311
    … …  
    314315BugReportFile::BugReportFile(const char *pszPath, const char *pszShortName) : BugReportItem(pszShortName)
    315316{
    316     m_Strm = 0;
     317    m_hVfsIos = NIL_RTVFSIOSTREAM;
    317318    m_pszPath = RTStrDup(pszPath);
    318319}
    … …  
    320321BugReportFile::~BugReportFile()
    321322{
    322     if (m_Strm)
    323         RTStrmClose(m_Strm);
     323    if (m_hVfsIos != NIL_RTVFSIOSTREAM)
     324        RTVfsIoStrmRelease(m_hVfsIos);
    324325    if (m_pszPath)
    325326        RTStrFree(m_pszPath);
    326327}
    327328
    328 PRTSTREAM BugReportFile::getStream(void)
    329 {
    330     handleRtError(RTStrmOpen(m_pszPath, "rb", &m_Strm),
     329RTVFSIOSTREAM BugReportFile::getStream(void)
     330{
     331    handleRtError(RTVfsIoStrmOpenNormal(m_pszPath, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, &m_hVfsIos),
    331332                  "Failed to open '%s'", m_pszPath);
    332     return m_Strm;
     333    return m_hVfsIos;
    333334}
    334335
    335336
    336337BugReportCommand::BugReportCommand(const char *pszTitle, const char *pszExec, ...)
    337     : BugReportItem(pszTitle), m_Strm(NULL)
     338    : BugReportItem(pszTitle), m_hVfsIos(NIL_RTVFSIOSTREAM)
    338339{
    339340    unsigned cArgs = 0;
    … …  
    358359BugReportCommand::~BugReportCommand()
    359360{
    360     if (m_Strm)
    361         RTStrmClose(m_Strm);
     361    if (m_hVfsIos != NIL_RTVFSIOSTREAM)
     362        RTVfsIoStrmRelease(m_hVfsIos);
    362363    RTFileDelete(m_szFileName);
    363364    for (size_t i = 0; i < RT_ELEMENTS(m_papszArgs) && m_papszArgs[i]; ++i)
    … …  
    365366}
    366367
    367 PRTSTREAM BugReportCommand::getStream(void)
     368RTVFSIOSTREAM BugReportCommand::getStream(void)
    368369{
    369370    handleRtError(RTPathTemp(m_szFileName, RTPATH_MAX),
    … …  
    391392    RTFileClose(hStdOutErr.u.hFile);
    392393
    393     handleRtError(RTStrmOpen(m_szFileName, "r", &m_Strm),
     394    handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, &m_hVfsIos),
    394395                  "Failed to open '%s'", m_szFileName);
    395     return m_Strm;
     396    return m_hVfsIos;
    396397}
    397398
    398399
    399400BugReportCommandTemp::BugReportCommandTemp(const char *pszTitle, const char *pszExec, ...)
    400     : BugReportItem(pszTitle), m_Strm(NULL)
     401    : BugReportItem(pszTitle), m_hVfsIos(NIL_RTVFSIOSTREAM)
    401402{
    402403    handleRtError(RTPathTemp(m_szFileName, RTPATH_MAX),
    … …  
    430431BugReportCommandTemp::~BugReportCommandTemp()
    431432{
    432     if (m_Strm)
    433         RTStrmClose(m_Strm);
     433    if (m_hVfsIos != NIL_RTVFSIOSTREAM)
     434        RTVfsIoStrmRelease(m_hVfsIos);
    434435    RTFileDelete(m_szErrFileName);
    435436    RTFileDelete(m_szFileName);
    … …  
    438439}
    439440
    440 PRTSTREAM BugReportCommandTemp::getStream(void)
     441RTVFSIOSTREAM BugReportCommandTemp::getStream(void)
    441442{
    442443    handleRtError(RTPathTemp(m_szErrFileName, RTPATH_MAX),
    … …  
    468469
    469470    if (status.enmReason == RTPROCEXITREASON_NORMAL && status.iStatus == 0)
    470         handleRtError(RTStrmOpen(m_szFileName, "r", &m_Strm), "Failed to open '%s'", m_szFileName);
     471        handleRtError(RTVfsIoStrmOpenNormal(m_szFileName, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, &m_hVfsIos),
     472                      "Failed to open '%s'", m_szFileName);
    471473    else
    472         handleRtError(RTStrmOpen(m_szErrFileName, "r", &m_Strm), "Failed to open '%s'", m_szErrFileName);
    473     return m_Strm;
     474        handleRtError(RTVfsIoStrmOpenNormal(m_szErrFileName, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE, &m_hVfsIos),
     475                      "Failed to open '%s'", m_szErrFileName);
     476    return m_hVfsIos;
    474477}
    475478
    … …  
    493496        throw RTCError(com::Utf8StrFmt("Write failure (cb=%d)\n", cb));
    494497
    495     PRTSTREAM strmIn = NULL;
     498    RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
    496499    try
    497500    {
    498         strmIn = item->getStream();
     501        hVfsIos = item->getStream();
    499502    }
    500503    catch (RTCError &e)
    501504    {
    502         strmIn = NULL;
     505        hVfsIos = NIL_RTVFSIOSTREAM;
    503506        RTStrmPutStr(m_StrmTxt, e.what());
    504507    }
    … …  
    506509    int rc = VINF_SUCCESS;
    507510
    508     if (strmIn)
     511    if (hVfsIos != NIL_RTVFSIOSTREAM)
    509512    {
    510513        char buf[64*1024];
    511514        size_t cbRead, cbWritten;
    512515        cbRead = cbWritten = 0;
    513         while (RT_SUCCESS(rc = RTStrmReadEx(strmIn, buf, sizeof(buf), &cbRead)) && cbRead)
     516        while (RT_SUCCESS(rc = RTVfsIoStrmRead(hVfsIos, buf, sizeof(buf), true /*fBlocking*/, &cbRead)) && cbRead)
    514517        {
    515518            rc = RTStrmWriteEx(m_StrmTxt, applyFilters(item, buf, &cbRead), cbRead, &cbWritten);
    … …  
    525528
    526529BugReportTarGzip::BugReportTarGzip(const char *pszFileName)
    527     : BugReport(pszFileName), m_hTar(NIL_RTTAR), m_hTarFile(NIL_RTTARFILE)
     530    : BugReport(pszFileName), m_hTarFss(NIL_RTVFSFSSTREAM)
    528531{
    529532    VfsIoStreamHandle hVfsOut;
    … …  
    534537                  "Failed to create compressed stream for '%s'", pszFileName);
    535538
    536     handleRtError(RTPathTemp(m_szTarName, RTPATH_MAX),
    537                   "Failed to obtain path to temporary folder");
    538     handleRtError(RTPathAppend(m_szTarName, RTPATH_MAX, "BugRepXXXXX.tar"),
    539                   "Failed to append path");
    540     handleRtError(RTFileCreateTemp(m_szTarName, 0600),
    541                   "Failed to create temporary file '%s'", m_szTarName);
    542     handleRtError(RTFileDelete(m_szTarName),
    543                   "Failed to delete temporary file '%s'", m_szTarName);
    544     handleRtError(RTTarOpen(&m_hTar, m_szTarName,  RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_ALL),
    545                   "Failed to create TAR file '%s'", m_szTarName);
    546 
     539    int rc = RTZipTarFsStreamToIoStream(m_hVfsGzip.get(), RTZIPTARFORMAT_DEFAULT, RTZIPTAR_C_SPARSE, &m_hTarFss);
     540    handleRtError(rc, "Failed to create TAR file '%s'", m_szTarName);
    547541}
    548542
    549543BugReportTarGzip::~BugReportTarGzip()
    550544{
    551     if (m_hTarFile != NIL_RTTARFILE)
    552         RTTarFileClose(m_hTarFile);
    553     if (m_hTar != NIL_RTTAR)
    554         RTTarClose(m_hTar);
     545    if (m_hTarFss != NIL_RTVFSFSSTREAM)
     546        RTVfsFsStrmRelease(m_hTarFss);
     547}
     548
     549void BugReportTarGzip::dumpExceptionToArchive(RTCString &strTarFile, RTCError &e)
     550{
     551    RTVFSFILE hVfsFile;
     552    int rc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, _1K/*cbEstimate*/, &hVfsFile);
     553    if (RT_SUCCESS(rc))
     554    {
     555        rc = RTVfsFileWrite(hVfsFile, e.what(), RTStrNLen(e.what(), 1024), NULL /*pcbWritten*/);
     556        if (RT_SUCCESS(rc))
     557        {
     558            rc = RTVfsFileSeek(hVfsFile, 0 /*offSeek*/, RTFILE_SEEK_BEGIN, NULL /*poffActual*/);
     559            if (RT_SUCCESS(rc))
     560            {
     561                RTVFSOBJ hVfsObj = RTVfsObjFromFile(hVfsFile);
     562                rc = RTVfsFsStrmAdd(m_hTarFss, strTarFile.c_str(), hVfsObj, 0 /*fFlags*/);
     563                RTVfsObjRelease(hVfsObj);
     564            }
     565        }
     566        RTVfsFileRelease(hVfsFile);
     567    }
     568    handleRtError(rc, "Failed to add exception text to TAR archive '%s'", m_szTarName);
    555569}
    556570
    … …  
    562576     */
    563577    RTCString strTarFile = RTCString(item->getTitle()).substr(0, RTStrNLen(item->getTitle(), 99));
    564     handleRtError(RTTarFileOpen(m_hTar, &m_hTarFile, strTarFile.c_str(),
    565                                 RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE),
    566                   "Failed to open '%s' in TAR", strTarFile.c_str());
    567 
    568     PRTSTREAM strmIn = NULL;
     578    RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
    569579    try
    570580    {
    571         strmIn = item->getStream();
     581        hVfsIos = item->getStream();
    572582    }
    573583    catch (RTCError &e)
    574584    {
    575         strmIn = NULL;
    576         handleRtError(RTTarFileWriteAt(m_hTarFile, 0, e.what(), RTStrNLen(e.what(), 1024), NULL),
    577                       "Failed to write %u bytes to TAR", RTStrNLen(e.what(), 1024));
    578     }
    579 
    580     int rc = VINF_SUCCESS;
    581 
    582     if (strmIn)
    583     {
    584         char buf[64*1024];
    585         size_t cbRead = 0;
    586         for (uint64_t offset = 0;
    587              RT_SUCCESS(rc = RTStrmReadEx(strmIn, buf, sizeof(buf), &cbRead)) && cbRead;
    588              offset += cbRead)
    589         {
    590             handleRtError(RTTarFileWriteAt(m_hTarFile, offset, applyFilters(item, buf, &cbRead), cbRead, NULL),
    591                           "Failed to write %u bytes to TAR", cbRead);
    592         }
    593     }
    594 
    595     if (m_hTarFile)
    596     {
    597         handleRtError(RTTarFileClose(m_hTarFile), "Failed to close '%s' in TAR", strTarFile.c_str());
    598         m_hTarFile = NIL_RTTARFILE;
     585        hVfsIos = NIL_RTVFSIOSTREAM;
     586        dumpExceptionToArchive(strTarFile, e);
     587    }
     588
     589    if (hVfsIos != NIL_RTVFSIOSTREAM)
     590    {
     591        RTVFSOBJ hVfsObjIos = RTVfsObjFromIoStream(hVfsIos);
     592        int rc = RTVfsFsStrmAdd(m_hTarFss, strTarFile.c_str(), hVfsObjIos, 0 /*fFlags*/);
     593        RTVfsObjRelease(hVfsObjIos);
     594        handleRtError(rc, "Failed to add file to TAR archive '%s'", m_szTarName);
    599595    }
    600596}
    … …  
    602598void BugReportTarGzip::complete(void)
    603599{
    604     if (m_hTarFile != NIL_RTTARFILE)
    605     {
    606         RTTarFileClose(m_hTarFile);
    607         m_hTarFile = NIL_RTTARFILE;
    608     }
    609     if (m_hTar != NIL_RTTAR)
    610     {
    611         RTTarClose(m_hTar);
    612         m_hTar = NIL_RTTAR;
    613     }
    614 
    615     VfsIoStreamHandle hVfsIn;
    616     handleRtError(RTVfsIoStrmOpenNormal(m_szTarName, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
    617                                         hVfsIn.getPtr()),
    618                   "Failed to open TAR file '%s'", m_szTarName);
    619 
    620     int rc;
    621     char buf[_64K];
    622     size_t cbRead = 0;
    623     while (RT_SUCCESS(rc = RTVfsIoStrmRead(hVfsIn.get(), buf, sizeof(buf), true, &cbRead)) && cbRead)
    624         handleRtError(RTVfsIoStrmWrite(m_hVfsGzip.get(), buf, cbRead, true, NULL),
    625                       "Failed to write into compressed stream");
    626     handleRtError(rc, "Failed to read from TAR stream");
     600    if (m_hTarFss != NIL_RTVFSFSSTREAM)
     601    {
     602        RTVfsFsStrmRelease(m_hTarFss);
     603        m_hTarFss = NIL_RTVFSFSSTREAM;
     604    }
    627605    handleRtError(RTVfsIoStrmFlush(m_hVfsGzip.get()), "Failed to flush output stream");
    628606    m_hVfsGzip.release();

  • trunk/src/VBox/Frontends/VBoxBugReport/VBoxBugReport.h

    r98103 r98320  
    4646#include <iprt/path.h>
    4747#include <iprt/stream.h>
    48 #include <iprt/tar.h>
    4948#include <iprt/vfs.h>
     49#include <iprt/zip.h>
    5050#include <iprt/cpp/list.h>
    5151
    … …  
    130130    virtual ~BugReportItem();
    131131    virtual const char *getTitle(void);
    132     virtual PRTSTREAM getStream(void) = 0;
     132    virtual RTVFSIOSTREAM getStream(void) = 0;
    133133    void addFilter(BugReportFilter *filter);
    134134    void *applyFilter(void *pvSource, size_t *pcbInOut);
    … …  
    169169    BugReportStream(const char *pszTitle);
    170170    virtual ~BugReportStream();
    171     virtual PRTSTREAM getStream(void);
     171    virtual RTVFSIOSTREAM getStream(void);
    172172protected:
    173173    int printf(const char *pszFmt, ...);
    174174    int putStr(const char *pszString);
    175175private:
    176     PRTSTREAM m_Strm;
     176    RTVFSIOSTREAM m_hVfsIos;
    177177    char m_szFileName[RTPATH_MAX];
    178178};
    … …  
    206206    virtual void complete(void);
    207207private:
     208    void dumpExceptionToArchive(RTCString &strTarFile, RTCError &e);
     209
    208210    /*
    209211     * Helper class to release handles going out of scope.
    … …  
    228230    VfsIoStreamHandle m_hVfsGzip;
    229231
    230     RTTAR m_hTar;
    231     RTTARFILE m_hTarFile;
     232    RTVFSFSSTREAM m_hTarFss;
    232233    char m_szTarName[RTPATH_MAX];
    233234};
    … …  
    242243    BugReportFile(const char *pszPath, const char *pcszName);
    243244    virtual ~BugReportFile();
    244     virtual PRTSTREAM getStream(void);
     245    virtual RTVFSIOSTREAM getStream(void);
    245246
    246247private:
    247248    char *m_pszPath;
    248     PRTSTREAM m_Strm;
     249    RTVFSIOSTREAM m_hVfsIos;
    249250};
    250251
    … …  
    257258    BugReportCommand(const char *pszTitle, const char *pszExec, ...);
    258259    virtual ~BugReportCommand();
    259     virtual PRTSTREAM getStream(void);
    260 private:
    261     PRTSTREAM m_Strm;
     260    virtual RTVFSIOSTREAM getStream(void);
     261private:
     262    RTVFSIOSTREAM m_hVfsIos;
    262263    char m_szFileName[RTPATH_MAX];
    263264    char *m_papszArgs[32];
    … …  
    272273    BugReportCommandTemp(const char *pszTitle, const char *pszExec, ...);
    273274    virtual ~BugReportCommandTemp();
    274     virtual PRTSTREAM getStream(void);
    275 private:
    276     PRTSTREAM m_Strm;
     275    virtual RTVFSIOSTREAM getStream(void);
     276private:
     277    RTVFSIOSTREAM m_hVfsIos;
    277278    char m_szFileName[RTPATH_MAX];
    278279    char m_szErrFileName[RTPATH_MAX];

  • trunk/src/VBox/Frontends/VBoxBugReport/VBoxBugReportWin.cpp

    r98103 r98320  
    268268    BugReportUsbTreeWin();
    269269    virtual ~BugReportUsbTreeWin();
    270     virtual PRTSTREAM getStream(void) { enumerate(); return BugReportStream::getStream(); }
     270    virtual RTVFSIOSTREAM getStream(void) { enumerate(); return BugReportStream::getStream(); }
    271271private:
    272272    class AutoHandle {
    … …  
    582582    BugReportDriversWin();
    583583    virtual ~BugReportDriversWin();
    584     virtual PRTSTREAM getStream(void) { enumerateDrivers(); return BugReportStream::getStream(); }
     584    virtual RTVFSIOSTREAM getStream(void) { enumerateDrivers(); return BugReportStream::getStream(); }
    585585private:
    586586    void enumerateDrivers(void);
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