VirtualBox

Changeset 59087 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Dec 11, 2015 11:04:51 AM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
104649
Message:

bugref:7179. auto_ptr was removed from the files VirtualBoxImpl.cpp and NetIf-win.cpp. The operations with network interface on Windows OS were affected.

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

Legend:

Unmodified
Added
Removed

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

    r58552 r59087  
    2222struct ThreadVoidData
    2323{
     24/*
     25 * The class ThreadVoidData is used as a base class for any data which we want to pass into a thread
     26 */
    2427public:
    2528    ThreadVoidData(){};

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

    r56398 r59087  
    381381
    382382#ifdef RT_OS_WINDOWS
     383    friend class StartSVCHelperClientData;
    383384    static DECLCALLBACK(int) SVCHelperClientThread(RTTHREAD aThread, void *aUser);
    384385#endif
     386
    385387};
    386388

  • trunk/src/VBox/Main/src-all/ThreadTask.cpp

    r58519 r59087  
    4343        delete this;
    4444    }
    45     catch(std::exception& e)
     45    catch(std::exception& )
    4646    {
    4747        rc = E_FAIL;
    … …  
    7474    catch(HRESULT eRC)
    7575    {
    76         rc = E_FAIL;
     76        rc = eRC;
    7777    }
    78     catch(std::exception& e)
     78    catch(std::exception& )
    7979    {
    8080        rc = E_FAIL;

  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r58132 r59087  
    8282# include "win/svchlp.h"
    8383# include "win/VBoxComEvents.h"
     84#include "ThreadTask.h"
    8485#endif
    8586
    … …  
    23912392#ifdef RT_OS_WINDOWS
    23922393
    2393 struct StartSVCHelperClientData
    2394 {
     2394class StartSVCHelperClientData : public ThreadTask
     2395{
     2396public:
     2397    StartSVCHelperClientData()
     2398    {
     2399        LogFlowFuncEnter();
     2400        m_strTaskName = "SVCHelper";
     2401        threadVoidData = NULL;
     2402        initialized = false;
     2403    }
     2404
     2405    virtual ~StartSVCHelperClientData()
     2406    {
     2407        LogFlowFuncEnter();
     2408        if (threadVoidData!=NULL)
     2409        {
     2410            delete threadVoidData;
     2411            threadVoidData=NULL;
     2412        }
     2413    };
     2414
     2415    void handler()
     2416    {
     2417        int vrc = VirtualBox::SVCHelperClientThread(NULL, this);
     2418    }
     2419
     2420    const ComPtr<Progress>& GetProgressObject() const {return progress;}
     2421
     2422    bool init(VirtualBox* aVbox,
     2423              Progress* aProgress,
     2424              bool aPrivileged,
     2425              VirtualBox::SVCHelperClientFunc aFunc,
     2426              void *aUser)
     2427    {
     2428        LogFlowFuncEnter();
     2429        that = aVbox;
     2430        progress = aProgress;
     2431        privileged = aPrivileged;
     2432        func = aFunc;
     2433        user = aUser;
     2434
     2435        initThreadVoidData();
     2436
     2437        initialized = true;
     2438
     2439        return initialized;
     2440    }
     2441
     2442    bool isOk() const{ return initialized;}
     2443
     2444    bool initialized;
    23952445    ComObjPtr<VirtualBox> that;
    23962446    ComObjPtr<Progress> progress;
    … …  
    23982448    VirtualBox::SVCHelperClientFunc func;
    23992449    void *user;
     2450    ThreadVoidData *threadVoidData;
     2451
     2452private:
     2453    bool initThreadVoidData()
     2454    {
     2455        LogFlowFuncEnter();
     2456        threadVoidData = static_cast<ThreadVoidData*>(user);
     2457        return true;
     2458    }
    24002459};
    24012460
    … …  
    24522511                                           void *aUser, Progress *aProgress)
    24532512{
     2513    LogFlowFuncEnter();
    24542514    AssertReturn(aFunc, E_POINTER);
    24552515    AssertReturn(aProgress, E_POINTER);
    … …  
    24592519
    24602520    /* create the SVCHelperClientThread() argument */
    2461     std::auto_ptr <StartSVCHelperClientData>
    2462         d(new StartSVCHelperClientData());
    2463     AssertReturn(d.get(), E_OUTOFMEMORY);
    2464 
    2465     d->that = this;
    2466     d->progress = aProgress;
    2467     d->privileged = aPrivileged;
    2468     d->func = aFunc;
    2469     d->user = aUser;
    2470 
     2521
     2522    HRESULT hr = S_OK;
     2523    StartSVCHelperClientData *pTask = NULL;
    24712524    RTTHREAD tid = NIL_RTTHREAD;
    2472     int vrc = RTThreadCreate(&tid, SVCHelperClientThread,
    2473                              static_cast <void *>(d.get()),
    2474                              0, RTTHREADTYPE_MAIN_WORKER,
    2475                              RTTHREADFLAGS_WAITABLE, "SVCHelper");
    2476     if (RT_FAILURE(vrc))
    2477         return setError(E_FAIL, "Could not create SVCHelper thread (%Rrc)", vrc);
    2478 
    2479     /* d is now owned by SVCHelperClientThread(), so release it */
    2480     d.release();
    2481 
    2482     return S_OK;
     2525    try
     2526    {
     2527        pTask = new StartSVCHelperClientData();
     2528
     2529        pTask->init(this, aProgress, aPrivileged, aFunc, aUser);
     2530
     2531        if (!pTask->isOk())
     2532        {
     2533            delete pTask;
     2534            LogRel(("Could not init StartSVCHelperClientData object \n"));
     2535            throw E_FAIL;
     2536        }
     2537
     2538        //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
     2539        hr = pTask->createThread(&tid, RTTHREADTYPE_MAIN_WORKER);
     2540
     2541    }
     2542    catch(std::bad_alloc &)
     2543    {
     2544        hr = setError(E_OUTOFMEMORY);
     2545    }
     2546    catch(...)
     2547    {
     2548        LogRel(("Could not create thread for StartSVCHelperClientData \n"));
     2549        hr = E_FAIL;
     2550    }
     2551
     2552    return hr;
    24832553}
    24842554
    … …  
    24922562    LogFlowFuncEnter();
    24932563
    2494     std::auto_ptr<StartSVCHelperClientData>
    2495         d(static_cast<StartSVCHelperClientData*>(aUser));
    2496 
     2564    StartSVCHelperClientData* d = static_cast<StartSVCHelperClientData*>(aUser);
    24972565    HRESULT rc = S_OK;
    24982566    bool userFuncCalled = false;
    … …  
    25002568    do
    25012569    {
    2502         AssertBreakStmt(d.get(), rc = E_POINTER);
     2570        AssertBreakStmt(d, rc = E_POINTER);
    25032571        AssertReturn(!d->progress.isNull(), E_POINTER);
    25042572

  • trunk/src/VBox/Main/src-server/win/NetIf-win.cpp

    r59082 r59087  
    4646#include "VirtualBoxImpl.h"
    4747#include "netif.h"
     48#include "ThreadTask.h"
    4849
    4950#ifdef VBOX_WITH_NETFLT
    … …  
    237238};
    238239
    239 struct NetworkInterfaceHelperClientData
    240 {
     240class NetworkInterfaceHelperClientData : public ThreadVoidData
     241{
     242public:
     243    NetworkInterfaceHelperClientData(){};
     244    ~NetworkInterfaceHelperClientData(){};
     245
    241246    SVCHlpMsg::Code msgCode;
    242247    /* for SVCHlpMsg::CreateHostOnlyNetworkInterface */
    … …  
    253258    } u;
    254259
    255 
    256260};
    257261
    … …  
    269273    AssertReturn(aUser, E_POINTER);
    270274
    271     std::auto_ptr<NetworkInterfaceHelperClientData>
    272         d(static_cast<NetworkInterfaceHelperClientData *>(aUser));
     275    NetworkInterfaceHelperClientData* d = static_cast<NetworkInterfaceHelperClientData *>(aUser);
    273276
    274277    if (aClient == NULL)
    … …  
    11611164
    11621165            /* create the networkInterfaceHelperClient() argument */
    1163             std::auto_ptr<NetworkInterfaceHelperClientData>
    1164                 d(new NetworkInterfaceHelperClientData());
    1165             AssertReturn(d.get(), E_OUTOFMEMORY);
     1166            NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
    11661167
    11671168            d->msgCode = SVCHlpMsg::CreateHostOnlyNetworkInterface;
    … …  
    11721173            rc = pVirtualBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
    11731174                                                     netIfNetworkInterfaceHelperClient,
    1174                                                      static_cast<void *>(d.get()),
     1175                                                     static_cast<void *>(d),
    11751176                                                     progress);
    1176             if (SUCCEEDED(rc))
    1177             {
    1178                 /* d is now owned by netIfNetworkInterfaceHelperClient(), so release it */
    1179                 d.release();
    1180             }
     1177            /* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
     1178
    11811179        }
    11821180    }
    … …  
    12081206
    12091207            /* create the networkInterfaceHelperClient() argument */
    1210             std::auto_ptr<NetworkInterfaceHelperClientData>
    1211                 d(new NetworkInterfaceHelperClientData());
    1212             AssertReturn(d.get(), E_OUTOFMEMORY);
     1208            NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
    12131209
    12141210            d->msgCode = SVCHlpMsg::RemoveHostOnlyNetworkInterface;
    … …  
    12171213            rc = pVirtualBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
    12181214                                                     netIfNetworkInterfaceHelperClient,
    1219                                                      static_cast<void *>(d.get()),
     1215                                                     static_cast<void *>(d),
    12201216                                                     progress);
    1221 
    1222             if (SUCCEEDED(rc))
    1223             {
    1224                 /* d is now owned by netIfNetworkInterfaceHelperClient(), so release it */
    1225                 d.release();
    1226             }
     1217            /* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
     1218
    12271219        }
    12281220    }
    … …  
    12621254
    12631255                    /* create the networkInterfaceHelperClient() argument */
    1264                     std::auto_ptr<NetworkInterfaceHelperClientData>
    1265                         d(new NetworkInterfaceHelperClientData());
    1266                     AssertReturn(d.get(), E_OUTOFMEMORY);
     1256                    NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
    12671257
    12681258                    d->msgCode = SVCHlpMsg::EnableStaticIpConfig;
    … …  
    12741264                    rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
    12751265                                                      netIfNetworkInterfaceHelperClient,
    1276                                                       static_cast<void *>(d.get()),
     1266                                                      static_cast<void *>(d),
    12771267                                                      progress);
     1268                    /* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
    12781269
    12791270                    if (SUCCEEDED(rc))
    12801271                    {
    1281                         /* d is now owned by netIfNetworkInterfaceHelperClient(), so release it */
    1282                         d.release();
    1283 
    12841272                        progress->WaitForCompletion(-1);
    12851273                    }
    … …  
    13241312
    13251313                    /* create the networkInterfaceHelperClient() argument */
    1326                     std::auto_ptr<NetworkInterfaceHelperClientData>
    1327                         d(new NetworkInterfaceHelperClientData());
    1328                     AssertReturn(d.get(), E_OUTOFMEMORY);
     1314                    NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
    13291315
    13301316                    d->msgCode = SVCHlpMsg::EnableStaticIpConfigV6;
    … …  
    13361322                    rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
    13371323                                                      netIfNetworkInterfaceHelperClient,
    1338                                                       static_cast<void *>(d.get()),
     1324                                                      static_cast<void *>(d),
    13391325                                                      progress);
     1326                    /* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
    13401327
    13411328                    if (SUCCEEDED(rc))
    13421329                    {
    1343                         /* d is now owned by netIfNetworkInterfaceHelperClient(), so release it */
    1344                         d.release();
    1345 
    13461330                        progress->WaitForCompletion(-1);
    13471331                    }
    … …  
    13851369
    13861370                    /* create the networkInterfaceHelperClient() argument */
    1387                     std::auto_ptr<NetworkInterfaceHelperClientData>
    1388                         d(new NetworkInterfaceHelperClientData());
    1389                     AssertReturn(d.get(), E_OUTOFMEMORY);
     1371                    NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
    13901372
    13911373                    d->msgCode = SVCHlpMsg::EnableDynamicIpConfig;
    … …  
    13951377                    rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
    13961378                                                      netIfNetworkInterfaceHelperClient,
    1397                                                       static_cast<void *>(d.get()),
     1379                                                      static_cast<void *>(d),
    13981380                                                      progress);
     1381                    /* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
    13991382
    14001383                    if (SUCCEEDED(rc))
    14011384                    {
    1402                         /* d is now owned by netIfNetworkInterfaceHelperClient(), so release it */
    1403                         d.release();
    1404 
    14051385                        progress->WaitForCompletion(-1);
    14061386                    }
    … …  
    14441424
    14451425                    /* create the networkInterfaceHelperClient() argument */
    1446                     std::auto_ptr<NetworkInterfaceHelperClientData>
    1447                         d(new NetworkInterfaceHelperClientData());
    1448                     AssertReturn(d.get(), E_OUTOFMEMORY);
     1426                    NetworkInterfaceHelperClientData* d = new NetworkInterfaceHelperClientData();
    14491427
    14501428                    d->msgCode = SVCHlpMsg::DhcpRediscover;
    … …  
    14541432                    rc = vBox->i_startSVCHelperClient(IsUACEnabled() == TRUE /* aPrivileged */,
    14551433                                                      netIfNetworkInterfaceHelperClient,
    1456                                                       static_cast<void *>(d.get()),
     1434                                                      static_cast<void *>(d),
    14571435                                                      progress);
     1436                    /* d is now owned by netIfNetworkInterfaceHelperClient(), no need to delete one here */
    14581437
    14591438                    if (SUCCEEDED(rc))
    14601439                    {
    1461                         /* d is now owned by netIfNetworkInterfaceHelperClient(), so release it */
    1462                         d.release();
    1463 
    14641440                        progress->WaitForCompletion(-1);
    14651441                    }
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