VirtualBox

Changeset 49133 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Oct 16, 2013 12:22:14 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
89986
Message:

Main/NATNetworkImpl.cpp: replace explicit autolock releasing with scopping.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r49131 r49133  
    290290    CheckComArgOutPointerValid(aName);
    291291    AutoCaller autoCaller(this);
    292     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    293     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    294    
    295     if (aName == mName)
    296         return S_OK;
    297 
    298     unconst(mName) = aName;
    299 
    300     alock.release();
     292   
     293    if (FAILED(autoCaller.rc()))
     294        return autoCaller.rc();
     295   
     296    {
     297        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     298   
     299        if (aName == mName)
     300            return S_OK;
     301
     302        unconst(mName) = aName;
     303    }
     304
    301305    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    302306    HRESULT rc = mVirtualBox->saveSettings();
    … …  
    323327{
    324328    AutoCaller autoCaller(this);
    325     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    326     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    327    
    328     if (aEnabled == m->fEnabled)
    329         return S_OK;
    330 
    331     m->fEnabled = aEnabled;
    332 
    333     // save the global settings; for that we should hold only the VirtualBox lock
    334     alock.release();
     329    if (FAILED(autoCaller.rc()))
     330        return autoCaller.rc();
     331   
     332    {
     333        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     334   
     335        if (aEnabled == m->fEnabled)
     336            return S_OK;
     337
     338        m->fEnabled = aEnabled;
     339    }
     340
    335341    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    336342    HRESULT rc = mVirtualBox->saveSettings();
    … …  
    367373
    368374    AutoCaller autoCaller(this);
    369     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    370     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    371    
    372     if (aIPv4NetworkCidr == m->IPv4NetworkCidr)
    373         return S_OK;
     375    if (FAILED(autoCaller.rc()))
     376        return autoCaller.rc();
     377   
     378    {
     379        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     380   
     381        if (aIPv4NetworkCidr == m->IPv4NetworkCidr)
     382            return S_OK;
    374383       
    375     /* silently ignore network cidr update for now.
    376      * todo: keep internally guest address of port forward rule
    377      * as offset from network id.
    378      */
    379     if (m->mapName2PortForwardRule4.empty())
    380     {
     384        /* silently ignore network cidr update for now.
     385         * todo: keep internally guest address of port forward rule
     386         * as offset from network id.
     387         */
     388        if (!m->mapName2PortForwardRule4.empty())
     389            return S_OK;
    381390
    382391        unconst(m->IPv4NetworkCidr) = Bstr(aIPv4NetworkCidr);
    383392        recalculateIpv4AddressAssignments();
    384         alock.release();
    385 
    386         AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    387         HRESULT rc = mVirtualBox->saveSettings();
    388         ComAssertComRCRetRC(rc);
    389     }
    390     return S_OK;
    391 }
    392 
    393 STDMETHODIMP NATNetwork::COMGETTER(IPv6Enabled)(BOOL *aIPv6Enabled)
    394 {
    395     CheckComArgOutPointerValid(aIPv6Enabled);
    396 
    397     AutoCaller autoCaller(this);
    398     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    399 
    400     *aIPv6Enabled = m->fIPv6Enabled;
    401 
    402     return S_OK;
    403 }
    404 
    405 STDMETHODIMP NATNetwork::COMSETTER(IPv6Enabled)(BOOL aIPv6Enabled)
    406 {
    407     AutoCaller autoCaller(this);
    408     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    409     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    410 
    411     if (aIPv6Enabled == m->fIPv6Enabled)
    412         return S_OK;
    413 
    414     m->fIPv6Enabled = aIPv6Enabled;
    415 
    416     // save the global settings; for that we should hold only the VirtualBox lock
    417     alock.release();
     393    }
    418394
    419395    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    424400}
    425401
    426 STDMETHODIMP NATNetwork::COMGETTER(IPv6Prefix) (BSTR *aIPv6Prefix)
    427 {
    428     CheckComArgOutPointerValid(aIPv6Prefix);
    429 
    430     AutoCaller autoCaller(this);
    431     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    432     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    433 
    434     m->IPv6Prefix.cloneTo(aIPv6Prefix);
    435 
    436     return S_OK;
    437 }
    438 
    439 STDMETHODIMP NATNetwork::COMSETTER(IPv6Prefix) (IN_BSTR aIPv6Prefix)
    440 {
    441     CheckComArgOutPointerValid(aIPv6Prefix);
    442 
    443     AutoCaller autoCaller(this);
    444     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    445     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    446 
    447     if (aIPv6Prefix == m->IPv6Prefix)
    448         return S_OK;
    449 
    450     /* silently ignore network IPv6 prefix update.
    451      * todo: see similar todo in NATNetwork::COMSETTER(Network)(IN_BSTR)
    452      */
    453     if (m->mapName2PortForwardRule6.empty())
    454     {
    455 
    456         unconst(m->IPv6Prefix) = Bstr(aIPv6Prefix);
    457         /* @todo: do we need recalculation ? */
    458         alock.release();
    459 
    460         AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    461         HRESULT rc = mVirtualBox->saveSettings();
    462         ComAssertComRCRetRC(rc);
    463     }
    464 
    465     return S_OK;
    466 }
    467 
    468 STDMETHODIMP NATNetwork::COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(BOOL *aAdvertiseDefaultIPv6Route)
    469 {
    470     CheckComArgOutPointerValid(aAdvertiseDefaultIPv6Route);
    471 
    472     AutoCaller autoCaller(this);
    473     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    474 
    475     *aAdvertiseDefaultIPv6Route = m->fAdvertiseDefaultIPv6Route;
    476 
    477     return S_OK;
    478 }
    479 
    480 STDMETHODIMP NATNetwork::COMSETTER(AdvertiseDefaultIPv6RouteEnabled)(BOOL aAdvertiseDefaultIPv6Route)
    481 {
    482     AutoCaller autoCaller(this);
    483     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    484     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    485    
    486     if (aAdvertiseDefaultIPv6Route == m->fAdvertiseDefaultIPv6Route)
    487         return S_OK;
    488 
    489     m->fAdvertiseDefaultIPv6Route = aAdvertiseDefaultIPv6Route;
    490 
    491     // save the global settings; for that we should hold only the VirtualBox lock
    492     alock.release();
     402STDMETHODIMP NATNetwork::COMGETTER(IPv6Enabled)(BOOL *aIPv6Enabled)
     403{
     404    CheckComArgOutPointerValid(aIPv6Enabled);
     405
     406    AutoCaller autoCaller(this);
     407    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     408
     409    *aIPv6Enabled = m->fIPv6Enabled;
     410
     411    return S_OK;
     412}
     413
     414STDMETHODIMP NATNetwork::COMSETTER(IPv6Enabled)(BOOL aIPv6Enabled)
     415{
     416    AutoCaller autoCaller(this);
     417    if (FAILED(autoCaller.rc()))
     418        return autoCaller.rc();
     419   
     420    {
     421        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     422
     423        if (aIPv6Enabled == m->fIPv6Enabled)
     424            return S_OK;
     425
     426        m->fIPv6Enabled = aIPv6Enabled;
     427    }
     428
    493429
    494430    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    499435}
    500436
     437STDMETHODIMP NATNetwork::COMGETTER(IPv6Prefix) (BSTR *aIPv6Prefix)
     438{
     439    CheckComArgOutPointerValid(aIPv6Prefix);
     440
     441    AutoCaller autoCaller(this);
     442    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     443    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     444
     445    m->IPv6Prefix.cloneTo(aIPv6Prefix);
     446
     447    return S_OK;
     448}
     449
     450STDMETHODIMP NATNetwork::COMSETTER(IPv6Prefix) (IN_BSTR aIPv6Prefix)
     451{
     452    CheckComArgOutPointerValid(aIPv6Prefix);
     453
     454    AutoCaller autoCaller(this);
     455    if (FAILED(autoCaller.rc()))
     456        return autoCaller.rc();
     457
     458    {
     459        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     460
     461        if (aIPv6Prefix == m->IPv6Prefix)
     462            return S_OK;
     463
     464        /* silently ignore network IPv6 prefix update.
     465         * todo: see similar todo in NATNetwork::COMSETTER(Network)(IN_BSTR)
     466         */
     467        if (!m->mapName2PortForwardRule6.empty())
     468            return S_OK;
     469
     470        unconst(m->IPv6Prefix) = Bstr(aIPv6Prefix);
     471    }
     472
     473    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
     474    HRESULT rc = mVirtualBox->saveSettings();
     475    ComAssertComRCRetRC(rc);
     476
     477    return S_OK;
     478}
     479
     480STDMETHODIMP NATNetwork::COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(BOOL *aAdvertiseDefaultIPv6Route)
     481{
     482    CheckComArgOutPointerValid(aAdvertiseDefaultIPv6Route);
     483
     484    AutoCaller autoCaller(this);
     485    if (FAILED(autoCaller.rc())) return autoCaller.rc();
     486
     487    *aAdvertiseDefaultIPv6Route = m->fAdvertiseDefaultIPv6Route;
     488
     489    return S_OK;
     490}
     491
     492STDMETHODIMP NATNetwork::COMSETTER(AdvertiseDefaultIPv6RouteEnabled)(BOOL aAdvertiseDefaultIPv6Route)
     493{
     494    AutoCaller autoCaller(this);
     495    if (FAILED(autoCaller.rc()))
     496        return autoCaller.rc();
     497   
     498    {
     499        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     500   
     501        if (aAdvertiseDefaultIPv6Route == m->fAdvertiseDefaultIPv6Route)
     502            return S_OK;
     503
     504        m->fAdvertiseDefaultIPv6Route = aAdvertiseDefaultIPv6Route;
     505
     506    }
     507
     508    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
     509    HRESULT rc = mVirtualBox->saveSettings();
     510    ComAssertComRCRetRC(rc);
     511
     512    return S_OK;
     513}
     514
    501515STDMETHODIMP NATNetwork::COMGETTER(NeedDhcpServer)(BOOL *aNeedDhcpServer)
    502516{
    … …  
    514528{
    515529    AutoCaller autoCaller(this);
    516     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    517     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    518    
    519     if (aNeedDhcpServer == m->fNeedDhcpServer)
    520         return S_OK;
    521 
    522     m->fNeedDhcpServer = aNeedDhcpServer;
    523 
    524     recalculateIpv4AddressAssignments();
    525 
    526     // save the global settings; for that we should hold only the VirtualBox lock
    527     alock.release();
     530    if (FAILED(autoCaller.rc()))
     531        return autoCaller.rc();
     532   
     533    {
     534        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     535   
     536        if (aNeedDhcpServer == m->fNeedDhcpServer)
     537            return S_OK;
     538
     539        m->fNeedDhcpServer = aNeedDhcpServer;
     540
     541        recalculateIpv4AddressAssignments();
     542
     543    }
    528544
    529545    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    645661{
    646662    AutoCaller autoCaller(this);
    647     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    648     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    649 
    650     if (aLoopbackIp6 < 0)
    651         return E_INVALIDARG;
    652 
    653     if (static_cast<uint32_t>(aLoopbackIp6) == m->u32LoopbackIp6)
    654         return S_OK;
    655    
    656     m->u32LoopbackIp6 = aLoopbackIp6;
     663    if (FAILED(autoCaller.rc()))
     664        return autoCaller.rc();
     665   
     666    {
     667        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     668
     669        if (aLoopbackIp6 < 0)
     670            return E_INVALIDARG;
     671
     672        if (static_cast<uint32_t>(aLoopbackIp6) == m->u32LoopbackIp6)
     673            return S_OK;
     674   
     675        m->u32LoopbackIp6 = aLoopbackIp6;
     676    }
    657677
    658678    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    670690    GetPortForwardRulesFromMap(ComSafeArrayInArg(aPortForwardRules4),
    671691                               m->mapName2PortForwardRule4);
    672     alock.release();
    673692    return S_OK;
    674693}
    … …  
    696715{
    697716    AutoCaller autoCaller(this);
    698     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    699 
    700     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    701     Utf8Str name = aPortForwardRuleName;
    702     Utf8Str proto;
    703     settings::NATRule r;
    704     NATRuleMap& mapRules = aIsIpv6 ? m->mapName2PortForwardRule6 : m->mapName2PortForwardRule4;
     717    if (FAILED(autoCaller.rc()))
     718        return autoCaller.rc();
     719
     720    {
     721        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     722        Utf8Str name = aPortForwardRuleName;
     723        Utf8Str proto;
     724        settings::NATRule r;
     725        NATRuleMap& mapRules = aIsIpv6 ? m->mapName2PortForwardRule6 : m->mapName2PortForwardRule4;
    705726        switch (aProto)
    706     {
    707         case NATProtocol_TCP:
    708             proto = "tcp";
    709             break;
    710         case NATProtocol_UDP:
    711             proto = "udp";
    712             break;
    713         default:
    714             return E_INVALIDARG;
    715     }
    716     if (name.isEmpty())
    717         name = Utf8StrFmt("%s_[%s]%%%d_[%s]%%%d", proto.c_str(),
    718                           Utf8Str(aHostIp).c_str(), aHostPort,
    719                           Utf8Str(aGuestIp).c_str(), aGuestPort);
    720 
    721     NATRuleMap::iterator it;
    722 
    723     for (it = mapRules.begin(); it != mapRules.end(); ++it)
    724     {
    725         r = it->second;
    726         if (it->first == name)
    727             return setError(E_INVALIDARG,
    728                             tr("A NAT rule of this name already exists"));
    729         if (   r.strHostIP == Utf8Str(aHostIp)
    730             && r.u16HostPort == aHostPort
    731             && r.proto == aProto)
    732             return setError(E_INVALIDARG,
    733                             tr("A NAT rule for this host port and this host IP already exists"));
    734     }
    735 
    736     r.strName = name.c_str();
    737     r.proto = aProto;
    738     r.strHostIP = aHostIp;
    739     r.u16HostPort = aHostPort;
    740     r.strGuestIP = aGuestIp;
    741     r.u16GuestPort = aGuestPort;
    742     mapRules.insert(std::make_pair(name, r));
    743 
    744     alock.release();
     727        {
     728            case NATProtocol_TCP:
     729                proto = "tcp";
     730                break;
     731            case NATProtocol_UDP:
     732                proto = "udp";
     733                break;
     734            default:
     735                return E_INVALIDARG;
     736        }
     737        if (name.isEmpty())
     738            name = Utf8StrFmt("%s_[%s]%%%d_[%s]%%%d", proto.c_str(),
     739                              Utf8Str(aHostIp).c_str(), aHostPort,
     740                              Utf8Str(aGuestIp).c_str(), aGuestPort);
     741
     742        NATRuleMap::iterator it;
     743
     744        for (it = mapRules.begin(); it != mapRules.end(); ++it)
     745        {
     746            r = it->second;
     747            if (it->first == name)
     748                return setError(E_INVALIDARG,
     749                                tr("A NAT rule of this name already exists"));
     750            if (   r.strHostIP == Utf8Str(aHostIp)
     751                   && r.u16HostPort == aHostPort
     752                   && r.proto == aProto)
     753                return setError(E_INVALIDARG,
     754                                tr("A NAT rule for this host port and this host IP already exists"));
     755        }
     756
     757        r.strName = name.c_str();
     758        r.proto = aProto;
     759        r.strHostIP = aHostIp;
     760        r.u16HostPort = aHostPort;
     761        r.strGuestIP = aGuestIp;
     762        r.u16GuestPort = aGuestPort;
     763        mapRules.insert(std::make_pair(name, r));
     764    }
    745765
    746766    {
    … …  
    766786{
    767787    AutoCaller autoCaller(this);
    768     if (FAILED(autoCaller.rc())) return autoCaller.rc();
    769 
    770     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    771     NATRuleMap& mapRules = aIsIpv6 ? m->mapName2PortForwardRule6 : m->mapName2PortForwardRule4;
    772     NATRuleMap::iterator it = mapRules.find(aPortForwardRuleName);
    773 
    774     if (it == mapRules.end())
    775         return E_INVALIDARG;
    776 
    777     Utf8Str strHostIP = it->second.strHostIP;
    778     Utf8Str strGuestIP = it->second.strGuestIP;
    779     uint16_t u16HostPort = it->second.u16HostPort;
    780     uint16_t u16GuestPort = it->second.u16GuestPort;
    781     NATProtocol_T proto = it->second.proto;
    782 
    783     mapRules.erase(it);
    784 
    785     alock.release();
    786 
     788    if (FAILED(autoCaller.rc()))
     789        return autoCaller.rc();
     790
     791    Utf8Str strHostIP;
     792    Utf8Str strGuestIP;
     793    uint16_t u16HostPort;
     794    uint16_t u16GuestPort;
     795    NATProtocol_T proto;
     796
     797
     798    {
     799        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     800        NATRuleMap& mapRules = aIsIpv6 ? m->mapName2PortForwardRule6
     801          : m->mapName2PortForwardRule4;
     802       
     803        NATRuleMap::iterator it = mapRules.find(aPortForwardRuleName);
     804
     805        if (it == mapRules.end())
     806            return E_INVALIDARG;
     807
     808        strHostIP = it->second.strHostIP;
     809        strGuestIP = it->second.strGuestIP;
     810        u16HostPort = it->second.u16HostPort;
     811        u16GuestPort = it->second.u16GuestPort;
     812        proto = it->second.proto;
     813
     814        mapRules.erase(it);
     815    }
     816   
    787817    {
    788818        AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
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