VirtualBox

Changeset 42783 in vbox for trunk/src/VBox/Main/src-client


Ignore:
Timestamp:
Aug 12, 2012 8:25:38 PM (12 years ago)
Author:
vboxsync
Message:

Main: split out implementation of GuestSession:DirectoryMakeTemp and added (disabled) test.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-client/GuestSessionImpl.cpp

    r42765 r42783  
    15011501}
    15021502
     1503int GuestSession::objectCreateTempInternal(Utf8Str strTemplate,
     1504                                           Utf8Str strPath,
     1505                                           bool fDirectory,
     1506                                           Utf8Str &strName, int *prc)
     1507{
     1508    GuestProcessStartupInfo procInfo;
     1509    GuestProcessStream      streamOut;
     1510    ComObjPtr<GuestProcess> pProcess;
     1511    int rc = VINF_SUCCESS;
     1512
     1513    if (fDirectory)
     1514        procInfo.mName    = Utf8StrFmt(tr("Creating temporary directory from template \"%s\"",
     1515                                   strTemplate.c_str()));
     1516    else
     1517        procInfo.mName    = Utf8StrFmt(tr("Creating temporary file from template \"%s\"",
     1518                                   strTemplate.c_str()));
     1519    procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
     1520    procInfo.mFlags   =   ProcessCreateFlag_Hidden
     1521                        | ProcessCreateFlag_WaitForStdOut;
     1522    /* Construct arguments. */
     1523    procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
     1524    if (fDirectory)
     1525        procInfo.mArguments.push_back(Utf8Str("-d"));
     1526    if (strPath.length())  /* Otherwise use /tmp or equivalent. */
     1527    {
     1528        procInfo.mArguments.push_back(Utf8Str("-t"));
     1529        procInfo.mArguments.push_back(strPath);
     1530    }
     1531    procInfo.mArguments.push_back(strTemplate);
     1532
     1533    rc = processCreateExInteral(procInfo, pProcess);
     1534    if (RT_SUCCESS(rc))
     1535    {
     1536        GuestProcessWaitResult waitRes;
     1537        BYTE byBuf[_64K];
     1538        size_t cbRead;
     1539
     1540        for (;;)
     1541        {
     1542            rc = pProcess->waitFor(ProcessWaitForFlag_StdOut,
     1543                                   30 * 1000 /* Timeout */, waitRes);
     1544            if (   RT_FAILURE(rc)
     1545                || waitRes.mResult == ProcessWaitResult_Terminate
     1546                || waitRes.mResult == ProcessWaitResult_Error
     1547                || waitRes.mResult == ProcessWaitResult_Timeout)
     1548            {
     1549                break;
     1550            }
     1551
     1552            rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
     1553                                    30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
     1554                                    &cbRead);
     1555            if (RT_FAILURE(rc))
     1556                break;
     1557
     1558            if (cbRead)
     1559            {
     1560                rc = streamOut.AddData(byBuf, cbRead);
     1561                if (RT_FAILURE(rc))
     1562                    break;
     1563            }
     1564        }
     1565
     1566        LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32, cbStreamOut=%RU32\n",
     1567                         rc, cbRead, streamOut.GetSize()));
     1568    }
     1569    else
     1570        LogThisFunc(("Error while starting temporary object creation tool on guest: %Rrc\n", rc));
     1571    if (RT_FAILURE(rc))
     1572        LogThisFunc(("Error while running temporary object creation tool: %Rrc\n", rc));
     1573    else if (!streamOut.GetSize())
     1574    {
     1575        LogThisFunc(("No return code after creating temporary object\n"));
     1576        rc = VERR_NO_DATA;
     1577    }
     1578    if (RT_SUCCESS(rc))
     1579    {
     1580        const char *pcszName;
     1581        int64_t i64rc;
     1582        GuestProcessStreamBlock streamBlock;
     1583        rc = streamOut.ParseBlock(streamBlock);
     1584        if (RT_SUCCESS(rc))
     1585        {
     1586            pcszName = streamBlock.GetString("name");
     1587            if (pcszName)
     1588                strName = pcszName;
     1589            else
     1590            {
     1591                LogThisFunc(("No name returned after creating temporary object\n"));
     1592                rc = VERR_NO_DATA;
     1593            }
     1594            if (RT_FAILURE(rc = streamBlock.GetInt64Ex("rc", &i64rc)))
     1595                LogThisFunc(("No return code after creating temporary object\n"));
     1596        }
     1597        if (   RT_SUCCESS(rc)
     1598            && (   i64rc == VERR_INVALID_PARAMETER
     1599                || i64rc == VERR_NOT_SUPPORTED))
     1600            rc = (int)i64rc;
     1601        if (RT_SUCCESS(rc))
     1602            *prc = (int)i64rc;
     1603    }
     1604    else
     1605        LogThisFunc(("Error while getting return code from creating temporary object: %Rrc\n", rc));
     1606    return rc;
     1607}
     1608
    15031609int GuestSession::directoryOpenInternal(const Utf8Str &strPath, const Utf8Str &strFilter,
    15041610                                        uint32_t uFlags, ComObjPtr<GuestDirectory> &pDirectory)
     
    22162322    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    22172323
    2218     GuestProcessStartupInfo procInfo;
    2219     GuestProcessStream      streamOut;
    22202324    int rc = VINF_SUCCESS;
    22212325
    22222326    try  /* Can this be done without exceptions? */
    22232327    {
    2224         Utf8Str strTemplate(aTemplate);
    2225         Utf8Str strPath(aPath);
    2226         procInfo.mName    = Utf8StrFmt(tr("Creating temporary directory from template \"%s\"",
    2227                                        strTemplate.c_str()));
    2228         procInfo.mCommand = Utf8Str(VBOXSERVICE_TOOL_MKTEMP);
    2229         procInfo.mFlags   =   ProcessCreateFlag_Hidden
    2230                             | ProcessCreateFlag_WaitForStdOut;
    2231         /* Construct arguments. */
    2232         procInfo.mArguments.push_back(Utf8Str("--machinereadable"));
    2233         if (strPath.length())  /* Otherwise use /tmp or equivalent. */
    2234         {
    2235             procInfo.mArguments.push_back(Utf8Str("-d"));
    2236             procInfo.mArguments.push_back(strPath);
    2237         }
    2238         procInfo.mArguments.push_back(strTemplate);
     2328        Utf8Str strName;
     2329        if (RT_FAILURE(objectCreateTempInternal(Utf8Str(aTemplate),
     2330                                                Utf8Str(aPath),
     2331                                                true, strName, &rc)))
     2332            return E_FAIL;
     2333        HRESULT hrc =   rc == VERR_INVALID_PARAMETER ? E_INVALIDARG
     2334                      : rc == VERR_NOT_SUPPORTED ? VBOX_E_NOT_SUPPORTED
     2335                      : RT_FAILURE(rc) ? VBOX_E_IPRT_ERROR
     2336                      : S_OK;
     2337        if (FAILED(hrc))
     2338            return setError(hrc, tr("Temporary directory creation failed: %Rrc"),
     2339                            rc);
     2340        strName.cloneTo(aDirectory);
     2341        return S_OK;
    22392342    }
    22402343    catch (...)
     
    22422345        return E_OUTOFMEMORY;
    22432346    }
    2244 
    2245     ComObjPtr<GuestProcess> pProcess;
    2246     rc = processCreateExInteral(procInfo, pProcess);
    2247     if (RT_SUCCESS(rc))
    2248     {
    2249         GuestProcessWaitResult waitRes;
    2250         BYTE byBuf[_64K];
    2251         size_t cbRead;
    2252 
    2253         for (;;)
    2254         {
    2255             rc = pProcess->waitFor(ProcessWaitForFlag_StdOut,
    2256                                    30 * 1000 /* Timeout */, waitRes);
    2257             if (   RT_FAILURE(rc)
    2258                 || waitRes.mResult == ProcessWaitResult_Terminate
    2259                 || waitRes.mResult == ProcessWaitResult_Error
    2260                 || waitRes.mResult == ProcessWaitResult_Timeout)
    2261             {
    2262                 break;
    2263             }
    2264 
    2265             rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
    2266                                     30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
    2267                                     &cbRead);
    2268             if (RT_FAILURE(rc))
    2269                 break;
    2270 
    2271             if (cbRead)
    2272             {
    2273                 rc = streamOut.AddData(byBuf, cbRead);
    2274                 if (RT_FAILURE(rc))
    2275                     break;
    2276             }
    2277         }
    2278 
    2279         LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32, cbStreamOut=%RU32\n",
    2280                          rc, cbRead, streamOut.GetSize()));
    2281     }
    2282     else
    2283         return setError(E_FAIL, tr("Error while starting temporary directory creation tool on guest: %Rrc"), rc);
    2284     if (RT_FAILURE(rc))
    2285         return setError(E_FAIL, tr("Error while running temporary directory creation tool: %Rrc"), rc);
    2286     if (!streamOut.GetSize())
    2287         return setError(E_FAIL, tr("No return code after creating temporary directory"));
    2288     GuestProcessStreamBlock streamBlock;
    2289     rc = streamOut.ParseBlock(streamBlock);
    2290     if (RT_SUCCESS(rc))
    2291     {
    2292         const char *pcszName = streamBlock.GetString("name");
    2293         if (!pcszName)
    2294             return setError(E_FAIL, tr("No name returned after creating temporary directory"));
    2295         int64_t i64rc;
    2296         if (RT_FAILURE(streamBlock.GetInt64Ex("rc", &i64rc)))
    2297             return setError(E_FAIL, tr("No return code after creating temporary directory"));
    2298         if (RT_FAILURE((int)i64rc))
    2299         {
    2300             HRESULT hrc =   i64rc == VERR_INVALID_PARAMETER ? E_INVALIDARG
    2301                           : i64rc == VERR_NOT_SUPPORTED ? VBOX_E_NOT_SUPPORTED
    2302                           : VBOX_E_IPRT_ERROR;
    2303             return setError(hrc, tr("Temporary directory creation failed: %Rrc"),
    2304                             (int)i64rc);
    2305         }
    2306         try
    2307         {
    2308             Bstr(pcszName).cloneTo(aDirectory);
    2309         }
    2310         catch (...)
    2311         {
    2312             return E_OUTOFMEMORY;
    2313         }
    2314     }
    2315     else
    2316         return setError(E_FAIL, tr("Error while getting return code from creating temporary directory: %Rrc"), rc);
    2317     return S_OK;
    23182347#endif /* VBOX_WITH_GUEST_CONTROL */
    23192348}
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