VirtualBox

vbox的更動 55365 路徑 trunk/src/VBox/NetworkServices


忽略:
時間撮記:
2015-4-22 上午09:34:46 (10 年 以前)
作者:
vboxsync
訊息:

NetworkServices: When handling COM/XPCOM events, always check if the event is for our network, otherwise ignore the event. Renamed {get/set}Network to {get/set}NetworkName(). Renamed {get/set}Name to {get/set}ServiceName(). Use RT_ZERO instead of memset if possible. Coding style.

位置:
trunk/src/VBox/NetworkServices
檔案:
修改 7 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/VBox/NetworkServices/DHCP/NetworkManagerDhcp.cpp

    r49735 r55365  
    5555{
    5656    RawOption opt;
    57     memset(&opt, 0, sizeof(RawOption));
     57    RT_ZERO(opt);
     58
    5859    /* 1. Find client */
    5960    ConfigurationManager *confManager = ConfigurationManager::getConfigurationManager();

  • trunk/src/VBox/NetworkServices/DHCP/VBoxNetDHCP.cpp

    r54700 r55365  
    221221    m_cbCurMsg              = 0;
    222222    m_pCurMsg               = NULL;
    223     memset(&m_CurHdrs, '\0', sizeof(m_CurHdrs));
     223    RT_ZERO(m_CurHdrs);
    224224
    225225    m_fIgnoreCmdLineParameters = true;
    … …  
    499499     */
    500500    AssertRCReturn(virtualbox.isNull(), VERR_INTERNAL_ERROR);
    501     std::string networkName = getNetwork();
     501    std::string networkName = getNetworkName();
    502502
    503503    int rc = findDhcpServer(virtualbox, networkName, m_DhcpServer);
    … …  
    616616        {
    617617            ComPtr <INATNetworkStartStopEvent> pStartStopEvent = pEvent;
     618
     619            com::Bstr networkName;
     620            HRESULT hrc = pStartStopEvent->COMGETTER(NetworkName)(networkName.asOutParam());
     621            AssertComRCReturn(hrc, hrc);
     622            if (networkName.compare(getNetworkName().c_str()))
     623                break; /* change not for our network */
     624
    618625            BOOL fStart = TRUE;
    619             HRESULT hrc = pStartStopEvent->COMGETTER(StartEvent)(&fStart);
     626            hrc = pStartStopEvent->COMGETTER(StartEvent)(&fStart);
     627            AssertComRCReturn(hrc, hrc);
    620628            if (!fStart)
    621629                shutdown();

  • trunk/src/VBox/NetworkServices/NAT/VBoxNetLwipNAT.cpp

    r54700 r55365  
    203203 * @note: this work on Event thread.
    204204 */
    205 HRESULT VBoxNetLwipNAT::HandleEvent(VBoxEventType_T aEventType,
    206                                                   IEvent *pEvent)
     205HRESULT VBoxNetLwipNAT::HandleEvent(VBoxEventType_T aEventType, IEvent *pEvent)
    207206{
    208207    HRESULT hrc = S_OK;
    … …  
    211210        case VBoxEventType_OnNATNetworkSetting:
    212211        {
    213             ComPtr<INATNetworkSettingEvent> evSettings(pEvent);
     212            ComPtr<INATNetworkSettingEvent> pSettingsEvent(pEvent);
     213
     214            com::Bstr networkName;
     215            hrc = pSettingsEvent->COMGETTER(NetworkName)(networkName.asOutParam());
     216            AssertComRCReturn(hrc, hrc);
     217            if (networkName.compare(getNetworkName().c_str()))
     218                break; /* change not for our network */
     219
    214220            // XXX: only handle IPv6 default route for now
    215 
    216221            if (!m_ProxyOptions.ipv6_enabled)
    217             {
    218222                break;
    219             }
    220223
    221224            BOOL fIPv6DefaultRoute = FALSE;
    222             hrc = evSettings->COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(&fIPv6DefaultRoute);
    223             AssertReturn(SUCCEEDED(hrc), hrc);
     225            hrc = pSettingsEvent->COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(&fIPv6DefaultRoute);
     226            AssertComRCReturn(hrc, hrc);
    224227
    225228            if (m_ProxyOptions.ipv6_defroute == fIPv6DefaultRoute)
    226             {
    227229                break;
    228             }
    229230
    230231            m_ProxyOptions.ipv6_defroute = fIPv6DefaultRoute;
    231232            tcpip_callback_with_block(proxy_rtadvd_do_quick, &m_LwipNetIf, 0);
    232 
    233233            break;
    234234        }
    … …  
    236236        case VBoxEventType_OnNATNetworkPortForward:
    237237        {
    238             com::Bstr name, strHostAddr, strGuestAddr;
    239             LONG lHostPort, lGuestPort;
    240             BOOL fCreateFW, fIPv6FW;
     238            ComPtr<INATNetworkPortForwardEvent> pForwardEvent = pEvent;
     239
     240            com::Bstr networkName;
     241            hrc = pForwardEvent->COMGETTER(NetworkName)(networkName.asOutParam());
     242            AssertComRCReturn(hrc, hrc);
     243            if (networkName.compare(getNetworkName().c_str()))
     244                break; /* change not for our network */
     245
     246            BOOL fCreateFW;
     247            hrc = pForwardEvent->COMGETTER(Create)(&fCreateFW);
     248            AssertComRCReturn(hrc, hrc);
     249
     250            BOOL  fIPv6FW;
     251            hrc = pForwardEvent->COMGETTER(Ipv6)(&fIPv6FW);
     252            AssertComRCReturn(hrc, hrc);
     253
     254            com::Bstr name;
     255            hrc = pForwardEvent->COMGETTER(Name)(name.asOutParam());
     256            AssertComRCReturn(hrc, hrc);
     257
    241258            NATProtocol_T proto = NATProtocol_TCP;
    242 
    243 
    244             ComPtr<INATNetworkPortForwardEvent> pfEvt = pEvent;
    245 
    246             hrc = pfEvt->COMGETTER(Create)(&fCreateFW);
    247             AssertReturn(SUCCEEDED(hrc), hrc);
    248 
    249             hrc = pfEvt->COMGETTER(Ipv6)(&fIPv6FW);
    250             AssertReturn(SUCCEEDED(hrc), hrc);
    251 
    252             hrc = pfEvt->COMGETTER(Name)(name.asOutParam());
    253             AssertReturn(SUCCEEDED(hrc), hrc);
    254 
    255             hrc = pfEvt->COMGETTER(Proto)(&proto);
    256             AssertReturn(SUCCEEDED(hrc), hrc);
    257 
    258             hrc = pfEvt->COMGETTER(HostIp)(strHostAddr.asOutParam());
    259             AssertReturn(SUCCEEDED(hrc), hrc);
    260 
    261             hrc = pfEvt->COMGETTER(HostPort)(&lHostPort);
    262             AssertReturn(SUCCEEDED(hrc), hrc);
    263 
    264             hrc = pfEvt->COMGETTER(GuestIp)(strGuestAddr.asOutParam());
    265             AssertReturn(SUCCEEDED(hrc), hrc);
    266 
    267             hrc = pfEvt->COMGETTER(GuestPort)(&lGuestPort);
    268             AssertReturn(SUCCEEDED(hrc), hrc);
    269 
    270             VECNATSERVICEPF& rules = (fIPv6FW ?
    271                                       m_vecPortForwardRule6 :
    272                                       m_vecPortForwardRule4);
     259            hrc = pForwardEvent->COMGETTER(Proto)(&proto);
     260            AssertComRCReturn(hrc, hrc);
     261
     262            com::Bstr strHostAddr;
     263            hrc = pForwardEvent->COMGETTER(HostIp)(strHostAddr.asOutParam());
     264            AssertComRCReturn(hrc, hrc);
     265
     266            LONG lHostPort;
     267            hrc = pForwardEvent->COMGETTER(HostPort)(&lHostPort);
     268            AssertComRCReturn(hrc, hrc);
     269
     270            com::Bstr strGuestAddr;
     271            hrc = pForwardEvent->COMGETTER(GuestIp)(strGuestAddr.asOutParam());
     272            AssertComRCReturn(hrc, hrc);
     273
     274            LONG lGuestPort;
     275            hrc = pForwardEvent->COMGETTER(GuestPort)(&lGuestPort);
     276            AssertComRCReturn(hrc, hrc);
     277
     278            VECNATSERVICEPF& rules = fIPv6FW ? m_vecPortForwardRule6
     279                                             : m_vecPortForwardRule4;
    273280
    274281            NATSEVICEPORTFORWARDRULE r;
    … …  
    320327
    321328            RTStrPrintf(r.Pfr.szPfrName, sizeof(r.Pfr.szPfrName),
    322                       "%s", com::Utf8Str(name).c_str());
     329                        "%s", com::Utf8Str(name).c_str());
    323330
    324331            RTStrPrintf(r.Pfr.szPfrHostAddr, sizeof(r.Pfr.szPfrHostAddr),
    325                       "%s", com::Utf8Str(strHostAddr).c_str());
     332                        "%s", com::Utf8Str(strHostAddr).c_str());
    326333
    327334            /* XXX: limits should be checked */
    … …  
    329336
    330337            RTStrPrintf(r.Pfr.szPfrGuestAddr, sizeof(r.Pfr.szPfrGuestAddr),
    331                       "%s", com::Utf8Str(strGuestAddr).c_str());
     338                        "%s", com::Utf8Str(strGuestAddr).c_str());
    332339
    333340            /* XXX: limits should be checked */
    … …  
    386393                                              /* :block */ 0);
    387394            if (error != ERR_OK && ppcszNameServers != NULL)
    388             {
    389395                RTMemFree(ppcszNameServers);
    390             }
    391396            break;
    392397        }
    … …  
    395400        {
    396401            ComPtr <INATNetworkStartStopEvent> pStartStopEvent = pEvent;
     402
     403            com::Bstr networkName;
     404            hrc = pStartStopEvent->COMGETTER(NetworkName)(networkName.asOutParam());
     405            AssertComRCReturn(hrc, hrc);
     406            if (networkName.compare(getNetworkName().c_str()))
     407                break; /* change not for our network */
     408
    397409            BOOL fStart = TRUE;
    398410            hrc = pStartStopEvent->COMGETTER(StartEvent)(&fStart);
     411            AssertComRCReturn(hrc, hrc);
     412
    399413            if (!fStart)
    400414                shutdown();
    … …  
    641655    m_ProxyOptions.src4 = NULL;
    642656    m_ProxyOptions.src6 = NULL;
    643     memset(&m_src4, 0, sizeof(m_src4));
    644     memset(&m_src6, 0, sizeof(m_src6));
     657    RT_ZERO(m_src4);
     658    RT_ZERO(m_src6);
    645659    m_src4.sin_family = AF_INET;
    646660    m_src6.sin6_family = AF_INET6;
    … …  
    774788
    775789
    776 /** This method executed on main thread, only at the end threr're one threads started explcitly (LWIP and later in ::run()
    777  * RECV)
     790/**
     791 * Main thread. Starts also the LWIP thread.
    778792 */
    779793int VBoxNetLwipNAT::init()
    … …  
    785799    AssertRCReturn(rc, rc);
    786800
    787     std::string networkName = getNetwork();
     801    std::string networkName = getNetworkName();
    788802    rc = findNatNetwork(virtualbox, networkName, m_net);
    789803    AssertRCReturn(rc, rc);
    … …  
    894908    rc = g_pLwipNat->tryGoOnline();
    895909    if (RT_FAILURE(rc))
    896     {
    897910        return rc;
    898     }
    899911
    900912    /* this starts LWIP thread */
    … …  
    908920const char **VBoxNetLwipNAT::getHostNameservers()
    909921{
    910     HRESULT hrc;
    911 
    912922    if (m_host.isNull())
    913     {
    914923        return NULL;
    915     }
    916924
    917925    com::SafeArray<BSTR> aNameServers;
    918     hrc = m_host->COMGETTER(NameServers)(ComSafeArrayAsOutParam(aNameServers));
     926    HRESULT hrc = m_host->COMGETTER(NameServers)(ComSafeArrayAsOutParam(aNameServers));
    919927    if (FAILED(hrc))
    920     {
    921928        return NULL;
    922     }
    923929
    924930    const size_t cNameServers = aNameServers.size();
    925931    if (cNameServers == 0)
    926     {
    927932        return NULL;
    928     }
    929933
    930934    const char **ppcszNameServers =
    931935        (const char **)RTMemAllocZ(sizeof(char *) * (cNameServers + 1));
    932936    if (ppcszNameServers == NULL)
    933     {
    934937        return NULL;
    935     }
    936938
    937939    size_t idxLast = 0;
    … …  
    941943        ppcszNameServers[idxLast] = RTStrDup(strNameServer.c_str());
    942944        if (ppcszNameServers[idxLast] != NULL)
    943         {
    944945            ++idxLast;
    945         }
    946946    }
    947947
    … …  
    989989    struct pbuf *p = pbuf_alloc(PBUF_RAW, cbFrame + ETH_PAD_SIZE, PBUF_POOL);
    990990    if (RT_UNLIKELY(p == NULL))
    991     {
    992991        return VERR_NO_MEMORY;
    993     }
    994992
    995993    /*
    … …  
    12001198
    12011199    if (RT_SUCCESS(rc))
    1202     {
    12031200        rc = g_pLwipNat->init();
    1204     }
    12051201
    12061202    if (RT_SUCCESS(rc))
    1207     {
    12081203        g_pLwipNat->run();
    1209     }
    12101204
    12111205    delete g_pLwipNat;
    … …  
    12491243
    12501244    if (pcszNetwork == NULL)
    1251     {
    12521245        return VERR_MISSING;
    1253     }
    12541246
    12551247    char szNetwork[RTPATH_MAX];
    12561248    rc = RTStrCopy(szNetwork, sizeof(szNetwork), pcszNetwork);
    12571249    if (RT_FAILURE(rc))
    1258     {
    12591250        return rc;
    1260     }
    12611251
    12621252    // sanitize network name to be usable as a path component
    … …  
    12641254    {
    12651255        if (RTPATH_IS_SEP(*p))
    1266         {
    12671256            *p = '_';
    1268         }
    12691257    }
    12701258
    … …  
    12931281                      "VBOXNET_%s_RELEASE_LOG", szNetwork);
    12941282    if (cch >= sizeof(szEnvVarBase))
    1295     {
    12961283        return VERR_BUFFER_OVERFLOW;
    1297     }
    12981284
    12991285    char szError[RTPATH_MAX + 128];
    … …  
    13211307    else
    13221308        hrc = nat->COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(rules));
    1323     AssertReturn(SUCCEEDED(hrc), VERR_INTERNAL_ERROR);
     1309    AssertComRCReturn(hrc, VERR_INTERNAL_ERROR);
    13241310
    13251311    NATSEVICEPORTFORWARDRULE Rule;

  • trunk/src/VBox/NetworkServices/NetLib/VBoxNetARP.cpp

    r46904 r55365  
    136136
    137137    uint8_t abTrailer[60 - sizeof(Reply) - sizeof(EthHdr)];
    138     memset(abTrailer, '\0', sizeof(abTrailer));
     138    RT_ZERO(abTrailer);
    139139
    140140    INTNETSEG aSegs[3];

  • trunk/src/VBox/NetworkServices/NetLib/VBoxNetBaseService.cpp

    r54741 r55365  
    7373struct VBoxNetBaseService::Data
    7474{
    75     Data(const std::string& aName, const std::string& aNetworkName):
    76       m_Name(aName),
    77       m_Network(aNetworkName),
     75    Data(const std::string& aServiceName, const std::string& aNetworkName):
     76      m_ServiceName(aServiceName),
     77      m_NetworkName(aNetworkName),
    7878      m_enmTrunkType(kIntNetTrunkType_WhateverNone),
    7979      m_pSession(NIL_RTR0PTR),
    … …  
    9292    };
    9393
    94     std::string         m_Name;
    95     std::string         m_Network;
     94    std::string         m_ServiceName;
     95    std::string         m_NetworkName;
    9696    std::string         m_TrunkName;
    9797    INTNETTRUNKTYPE     m_enmTrunkType;
    … …  
    268268        {
    269269            case 'N': // --name
    270                 m->m_Name = Val.psz;
     270                m->m_ServiceName = Val.psz;
    271271                break;
    272272
    273273            case 'n': // --network
    274                 m->m_Network = Val.psz;
     274                m->m_NetworkName = Val.psz;
    275275                break;
    276276
    … …  
    393393    OpenReq.Hdr.cbReq = sizeof(OpenReq);
    394394    OpenReq.pSession = m->m_pSession;
    395     strncpy(OpenReq.szNetwork, m->m_Network.c_str(), sizeof(OpenReq.szNetwork));
     395    RTStrCopy(OpenReq.szNetwork, sizeof(OpenReq.szNetwork), m->m_NetworkName.c_str());
    396396    OpenReq.szNetwork[sizeof(OpenReq.szNetwork) - 1] = '\0';
    397     strncpy(OpenReq.szTrunk, m->m_TrunkName.c_str(), sizeof(OpenReq.szTrunk));
     397    RTStrCopy(OpenReq.szTrunk, sizeof(OpenReq.szTrunk), m->m_TrunkName.c_str());
    398398    OpenReq.szTrunk[sizeof(OpenReq.szTrunk) - 1] = '\0';
    399399    OpenReq.enmTrunkType = m->m_enmTrunkType;
    … …  
    581581
    582582
    583 const std::string VBoxNetBaseService::getName() const
    584 {
    585     return m->m_Name;
    586 }
    587 
    588 
    589 void VBoxNetBaseService::setName(const std::string& aName)
    590 {
    591     m->m_Name = aName;
    592 }
    593 
    594 
    595 const std::string VBoxNetBaseService::getNetwork() const
    596 {
    597     return m->m_Network;
    598 }
    599 
    600 
    601 void VBoxNetBaseService::setNetwork(const std::string& aNetwork)
    602 {
    603     m->m_Network = aNetwork;
     583const std::string VBoxNetBaseService::getServiceName() const
     584{
     585    return m->m_ServiceName;
     586}
     587
     588
     589void VBoxNetBaseService::setServiceName(const std::string& aName)
     590{
     591    m->m_ServiceName = aName;
     592}
     593
     594
     595const std::string VBoxNetBaseService::getNetworkName() const
     596{
     597    return m->m_NetworkName;
     598}
     599
     600
     601void VBoxNetBaseService::setNetworkName(const std::string& aName)
     602{
     603    m->m_NetworkName = aName;
    604604}
    605605

  • trunk/src/VBox/NetworkServices/NetLib/VBoxNetBaseService.h

    r54723 r55365  
    8787
    8888protected:
    89     const std::string getName() const;
    90     void setName(const std::string&);
     89    const std::string getServiceName() const;
     90    void setServiceName(const std::string&);
    9191
    92     const std::string getNetwork() const;
    93     void setNetwork(const std::string&);
     92    const std::string getNetworkName() const;
     93    void setNetworkName(const std::string&);
    9494
    9595    const RTMAC getMacAddress() const;

  • trunk/src/VBox/NetworkServices/NetLib/VBoxNetPortForwardString.cpp

    r54944 r55365  
    234234    AssertPtrReturn(pPfr, VERR_INVALID_PARAMETER);
    235235
    236     memset(pPfr, 0, sizeof(PORTFORWARDRULE));
     236    RT_ZERO(*pPfr);
    237237
    238238    pszHostAddr = &pPfr->szPfrHostAddr[0];
    … …  
    271271                  pszRaw);
    272272        pszRaw += cbToken; /* move to separator */
     273        cbRaw -= cbToken;
    273274    }
    274275
    … …  
    277278
    278279    pszRaw++; /* skip separator */
     280    cbRaw--;
    279281    idxRaw = 0;
    280 
    281     cbRaw--;
    282282
    283283    if (  (  (fTcpProto = (RTStrNICmp(pszRaw, "tcp", 3) == 0))
    … …  
    293293    pszRaw += idxRaw;
    294294    cbRaw -= idxRaw;
    295     idxRaw = 0;
    296295
    297296    idxRaw = netPfStrAddressPortPairParse(pszRaw, cbRaw,
    … …  
    306305    Assert(pszRaw[0] == PF_FIELD_SEPARATOR);
    307306
    308     idxRaw = 0;
    309 
    310307    idxRaw = netPfStrAddressPortPairParse(pszRaw, cbRaw,
    311                                           pszGuestAddr,
    312                                           INET6_ADDRSTRLEN,
    313                                           false,
    314                                           &u16GuestPort);
     308                                          pszGuestAddr, INET6_ADDRSTRLEN,
     309                                          false, &u16GuestPort);
    315310
    316311    if (idxRaw < 0)
    … …  
    344339    RTStrFree(pszRawBegin);
    345340    if (pPfr)
    346         memset(pPfr, 0, sizeof(PORTFORWARDRULE));
     341        RT_ZERO(*pPfr);
    347342    return VERR_INVALID_PARAMETER;
    348343}
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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