VirtualBox

Changeset 48107 in vbox for trunk/src/VBox/Main/src-server


Ignore:
Timestamp:
Aug 27, 2013 10:15:13 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
88483
Message:

NATNetwork windows build fix. Fixed memory leak in recalculateIpv4AddressAssignments due to confusing string handling and simplified the code there a little (~20 lines shorter). Fixed indentation and some other nits.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r48103 r48107  
    11/* $Id$ */
    2 
    32/** @file
    4  *
    5  * VirtualBox COM class implementation
     3 * INATNetwork implementation.
    64 */
    75
    … …  
    4038
    4139#ifndef RT_OS_WINDOWS
    42 #include <netinet/in.h>
     40# include <netinet/in.h>
    4341#else
    44 # include <ws2def.h>
    4542# define IN_LOOPBACKNET 127
    4643#endif
    … …  
    5249struct NATNetwork::Data
    5350{
    54     Data() :
    55 
    56       fEnabled(FALSE),
    57       fIPv6Enabled(FALSE),
    58       fAdvertiseDefaultIPv6Route(FALSE),
    59       fNeedDhcpServer(FALSE)
     51    Data()
     52      : fEnabled(FALSE)
     53      , fIPv6Enabled(FALSE)
     54      , fAdvertiseDefaultIPv6Route(FALSE)
     55      , fNeedDhcpServer(FALSE)
    6056    {
    6157        IPv4Gateway.setNull();
    … …  
    8884    settings::NATLoopbackOffsetList llNATLoopbackOffsetList;
    8985    uint32_t u32LoopbackIp6;
    90     uint32_t u32GatewayOffset;
    91     uint32_t u32DhcpOffset;
     86    uint32_t offGateway;
     87    uint32_t offDhcp;
    9288};
    9389
    … …  
    135131    unconst(mName) = aName;
    136132    m = new Data();
    137     m->u32GatewayOffset = 1;
     133    m->offGateway = 1;
    138134    m->IPv4NetworkCidr = "10.0.2.0/24";
    139135    m->IPv6Prefix = "fe80::/64";
    … …  
    145141    m->llNATLoopbackOffsetList.push_back(off);
    146142
    147     RecalculateIpv4AddressAssignments();
     143    recalculateIpv4AddressAssignments();
    148144
    149145    HRESULT hrc = unconst(m->pEventSource).createObject();
    … …  
    183179                               data.llHostLoopbackOffsetList.end());
    184180
    185     RecalculateIpv4AddressAssignments();
     181    recalculateIpv4AddressAssignments();
    186182
    187183    /* IPv4 port-forward rules */
    … …  
    232228    for (NATRuleMap::iterator it = m->mapName2PortForwardRule4.begin();
    233229         it != m->mapName2PortForwardRule4.end(); ++it)
    234       data.llPortForwardRules4.push_back(it->second);
     230        data.llPortForwardRules4.push_back(it->second);
    235231
    236232    /* saving ipv6 port-forward Rules*/
    … …  
    238234    for (NATRuleMap::iterator it = m->mapName2PortForwardRule6.begin();
    239235         it != m->mapName2PortForwardRule6.end(); ++it)
    240       data.llPortForwardRules4.push_back(it->second);
     236        data.llPortForwardRules4.push_back(it->second);
    241237
    242238    data.u32HostLoopback6Offset = m->u32LoopbackIp6;
    … …  
    255251    return S_OK;
    256252}
    257 #endif
     253#endif /* NAT_XML_SERIALIZATION */
    258254
    259255STDMETHODIMP NATNetwork::COMGETTER(EventSource)(IEventSource ** aEventSource)
    … …  
    270266}
    271267
    272 STDMETHODIMP NATNetwork::COMGETTER(NetworkName) (BSTR *aName)
     268STDMETHODIMP NATNetwork::COMGETTER(NetworkName)(BSTR *aName)
    273269{
    274270    CheckComArgOutPointerValid(aName);
    … …  
    282278}
    283279
    284 STDMETHODIMP NATNetwork::COMSETTER(NetworkName) (IN_BSTR aName)
     280STDMETHODIMP NATNetwork::COMSETTER(NetworkName)(IN_BSTR aName)
    285281{
    286282    CheckComArgOutPointerValid(aName);
    … …  
    302298
    303299
    304 STDMETHODIMP NATNetwork::COMGETTER(Enabled) (BOOL *aEnabled)
     300STDMETHODIMP NATNetwork::COMGETTER(Enabled)(BOOL *aEnabled)
    305301{
    306302    CheckComArgOutPointerValid(aEnabled);
    … …  
    310306
    311307    *aEnabled = m->fEnabled;
    312     RecalculateIpv4AddressAssignments();
    313 
    314     return S_OK;
    315 }
    316 
    317 STDMETHODIMP NATNetwork::COMSETTER(Enabled) (BOOL aEnabled)
     308    recalculateIpv4AddressAssignments();
     309
     310    return S_OK;
     311}
     312
     313STDMETHODIMP NATNetwork::COMSETTER(Enabled)(BOOL aEnabled)
    318314{
    319315    AutoCaller autoCaller(this);
    … …  
    332328}
    333329
    334 STDMETHODIMP NATNetwork::COMGETTER(Gateway) (BSTR *aIPv4Gateway)
     330STDMETHODIMP NATNetwork::COMGETTER(Gateway)(BSTR *aIPv4Gateway)
    335331{
    336332    CheckComArgOutPointerValid(aIPv4Gateway);
    … …  
    344340}
    345341
    346 STDMETHODIMP NATNetwork::COMGETTER(Network) (BSTR *aIPv4NetworkCidr)
     342STDMETHODIMP NATNetwork::COMGETTER(Network)(BSTR *aIPv4NetworkCidr)
    347343{
    348344    CheckComArgOutPointerValid(aIPv4NetworkCidr);
    … …  
    354350}
    355351
    356 STDMETHODIMP NATNetwork::COMSETTER(Network) (IN_BSTR aIPv4NetworkCidr)
     352STDMETHODIMP NATNetwork::COMSETTER(Network)(IN_BSTR aIPv4NetworkCidr)
    357353{
    358354    CheckComArgOutPointerValid(aIPv4NetworkCidr);
    … …  
    367363
    368364        unconst(m->IPv4NetworkCidr) = Bstr(aIPv4NetworkCidr);
    369         RecalculateIpv4AddressAssignments();
     365        recalculateIpv4AddressAssignments();
    370366        alock.release();
    371367
    … …  
    394390    AutoCaller autoCaller(this);
    395391    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    396     HRESULT rc = S_OK;
    397392    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    398393    m->fAdvertiseDefaultIPv6Route = aAdvertiseDefaultIPv6Route;
    … …  
    401396    alock.release();
    402397
     398    HRESULT rc = S_OK;
    403399#ifdef NAT_XML_SERIALIZATION
    404400    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    462458    AutoCaller autoCaller(this);
    463459    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    464     HRESULT rc = S_OK;
    465460    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    466461    m->fAdvertiseDefaultIPv6Route = aAdvertiseDefaultIPv6Route;
    … …  
    469464    alock.release();
    470465
     466    HRESULT rc = S_OK;
    471467#ifdef NAT_XML_SERIALIZATION
    472468    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    492488    AutoCaller autoCaller(this);
    493489    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    494     HRESULT rc = S_OK;
    495490    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    496491    m->fNeedDhcpServer = aNeedDhcpServer;
    497492
    498     RecalculateIpv4AddressAssignments();
     493    recalculateIpv4AddressAssignments();
    499494
    500495    // save the global settings; for that we should hold only the VirtualBox lock
    501496    alock.release();
    502497
     498    HRESULT rc = S_OK;
    503499#ifdef NAT_XML_SERIALIZATION
    504500    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    684680    }
    685681    if (name.isEmpty())
    686       name = Utf8StrFmt("%s_[%s]%%%d_[%s]%%%d", proto.c_str(),
    687                         Utf8Str(aHostIp).c_str(), aHostPort,
    688                         Utf8Str(aGuestIp).c_str(), aGuestPort);
     682        name = Utf8StrFmt("%s_[%s]%%%d_[%s]%%%d", proto.c_str(),
     683                          Utf8Str(aHostIp).c_str(), aHostPort,
     684                          Utf8Str(aGuestIp).c_str(), aGuestPort);
    689685
    690686    NATRuleMap::iterator it;
    … …  
    732728STDMETHODIMP NATNetwork::RemovePortForwardRule(BOOL aIsIpv6, IN_BSTR aPortForwardRuleName)
    733729{
    734     int rc = S_OK;
    735     Utf8Str strHostIP, strGuestIP;
    736     uint16_t u16HostPort, u16GuestPort;
    737     NATProtocol_T proto = NATProtocol_TCP;
    738 
    739730    AutoCaller autoCaller(this);
    740731    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    … …  
    747738        return E_INVALIDARG;
    748739
    749     strHostIP = it->second.strHostIP;
    750     strGuestIP = it->second.strGuestIP;
    751     u16HostPort = it->second.u16HostPort;
    752     u16GuestPort = it->second.u16GuestPort;
    753     proto = it->second.proto;
     740    Utf8Str strHostIP = it->second.strHostIP;
     741    Utf8Str strGuestIP = it->second.strGuestIP;
     742    uint16_t u16HostPort = it->second.u16HostPort;
     743    uint16_t u16GuestPort = it->second.u16GuestPort;
     744    NATProtocol_T proto = it->second.proto;
    754745
    755746    mapRules.erase(it);
    … …  
    767758                                   Bstr(strHostIP).raw(), u16HostPort,
    768759                                   Bstr(strGuestIP).raw(), u16GuestPort);
     760    HRESULT rc = S_OK;
    769761#ifdef NAT_XML_SERIALIZATION
    770762    AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    … …  
    793785    if (m->fNeedDhcpServer)
    794786    {
    795         /**
     787        /*
    796788         * Just to as idea... via API (on creation user pass the cidr of network and)
    797789         * and we calculate it's addreses (mutable?).
    … …  
    864856        return S_OK;
    865857    }
    866     else return E_FAIL;
     858    /** @todo missing setError()! */
     859    return E_FAIL;
    867860#else
    868861    NOREF(aTrunkType);
    … …  
    882875        return S_OK;
    883876    }
    884     else return E_FAIL;
     877    /** @todo missing setError()! */
     878    return E_FAIL;
    885879#else
    886880    ReturnComNotImplemented();
    … …  
    910904
    911905
    912 int NATNetwork::findFirstAvailableOffset(uint32_t *pu32Offset)
    913 {
    914     uint32_t offset;
     906int NATNetwork::findFirstAvailableOffset(uint32_t *poff)
     907{
    915908    RTNETADDRIPV4 network, netmask;
    916909
    … …  
    920913    AssertRCReturn(rc, rc);
    921914
     915    uint32_t off;
    922916    settings::NATLoopbackOffsetList::iterator it;
    923     for (offset = 1; offset < (network.u & (~netmask.u)); ++offset)
    924     {
    925         bool skip = false;
    926 
    927         if (offset == m->u32GatewayOffset)
     917    for (off = 1; off < (network.u & ~netmask.u); ++off)
     918    {
     919
     920        if (off == m->offGateway)
    928921            continue;
    929922
    930         if (offset == m->u32DhcpOffset)
     923        if (off == m->offDhcp)
    931924            continue;
    932925       
     926        bool skip = false;
    933927        for (it = m->llNATLoopbackOffsetList.begin();
    934928             it != m->llNATLoopbackOffsetList.end();
    935929             ++it)
    936930        {
    937             if ((*it).u32Offset == offset)
     931            if ((*it).u32Offset == off)
    938932            {
    939933                skip = true;
    … …  
    943937        }
    944938       
    945         if(!skip)
     939        if (!skip)
    946940            break;
    947941    }
    948942   
    949     if (pu32Offset)
    950         *pu32Offset = offset;
     943    if (poff)
     944        *poff = off;
    951945   
    952946    return VINF_SUCCESS;
    953947}
    954948
    955 int NATNetwork::RecalculateIpv4AddressAssignments()
    956 {
    957     RTNETADDRIPV4 network, netmask, gateway;
    958     char aszGatewayIp[16], aszNetmask[16];
    959     RT_ZERO(aszNetmask);
     949int NATNetwork::recalculateIpv4AddressAssignments()
     950{
     951    RTNETADDRIPV4 network, netmask;
    960952    int rc = RTCidrStrToIPv4(Utf8Str(m->IPv4NetworkCidr.raw()).c_str(),
    961953                             &network,
    … …  
    963955    AssertRCReturn(rc, rc);
    964956
    965     findFirstAvailableOffset(&m->u32GatewayOffset);
     957    findFirstAvailableOffset(&m->offGateway);
    966958    if (m->fNeedDhcpServer)
    967         findFirstAvailableOffset(&m->u32DhcpOffset);
    968 
    969     /* I don't remember the reason CIDR calcualted in host */
    970     gateway.u = network.u;
    971 
    972     gateway.u += m->u32GatewayOffset;
     959        findFirstAvailableOffset(&m->offDhcp);
     960
     961    /* I don't remember the reason CIDR calculated on the host. */
     962    RTNETADDRIPV4 gateway = network;
     963    gateway.u += m->offGateway;
    973964    gateway.u = RT_H2N_U32(gateway.u);
    974     RTStrPrintf(aszGatewayIp, 16, "%RTnaipv4", gateway);
    975 
    976     m->IPv4Gateway = RTStrDup(aszGatewayIp);
     965    char szTmpIp[16];
     966    RTStrPrintf(szTmpIp, sizeof(szTmpIp), "%RTnaipv4", gateway);
     967    m->IPv4Gateway = szTmpIp;
    977968
    978969    if (m->fNeedDhcpServer)
    979970    {
    980         RTNETADDRIPV4 dhcpserver,
    981           dhcplowerip,
    982           dhcpupperip;
    983         char aszNetwork[16],
    984           aszDhcpIp[16],
    985           aszDhcpLowerIp[16],
    986           aszDhcpUpperIp[16];
    987         RT_ZERO(aszNetwork);
    988 
    989         RT_ZERO(aszDhcpIp);
    990         RT_ZERO(aszDhcpLowerIp);
    991         RT_ZERO(aszDhcpUpperIp);
    992 
    993         dhcpserver.u = network.u;
    994         dhcpserver.u += m->u32DhcpOffset;
    995 
     971        RTNETADDRIPV4 dhcpserver = network;
     972        dhcpserver.u += m->offDhcp;
    996973
    997974        /* XXX: adding more services should change the math here */
     975        RTNETADDRIPV4 dhcplowerip;
    998976        dhcplowerip.u = RT_H2N_U32(dhcpserver.u + 1);
    999         dhcpupperip.u = RT_H2N_U32((network.u | (~netmask.u)) -1);
     977        RTNETADDRIPV4 dhcpupperip;
     978        dhcpupperip.u = RT_H2N_U32((network.u | ~netmask.u) - 1);
     979
    1000980        dhcpserver.u = RT_H2N_U32(dhcpserver.u);
    1001981        network.u = RT_H2N_U32(network.u);
    1002982
    1003         RTStrPrintf(aszNetwork, 16, "%RTnaipv4", network);
    1004         RTStrPrintf(aszDhcpLowerIp, 16, "%RTnaipv4", dhcplowerip);
    1005         RTStrPrintf(aszDhcpUpperIp, 16, "%RTnaipv4", dhcpupperip);
    1006         RTStrPrintf(aszDhcpIp, 16, "%RTnaipv4", dhcpserver);
    1007 
    1008         m->IPv4DhcpServer = aszDhcpIp;
    1009         m->IPv4DhcpServerLowerIp = aszDhcpLowerIp;
    1010         m->IPv4DhcpServerUpperIp = aszDhcpUpperIp;
    1011 
    1012         LogFunc(("network: %RTnaipv4, dhcpserver:%RTnaipv4, dhcplowerip:%RTnaipv4, dhcpupperip:%RTnaipv4\n",
    1013                  network,
    1014                  dhcpserver,
    1015                  dhcplowerip,
    1016                  dhcpupperip));
    1017     }
     983        RTStrPrintf(szTmpIp, sizeof(szTmpIp), "%RTnaipv4", dhcpserver);
     984        m->IPv4DhcpServer = szTmpIp;
     985        RTStrPrintf(szTmpIp, sizeof(szTmpIp), "%RTnaipv4", dhcplowerip);
     986        m->IPv4DhcpServerLowerIp = szTmpIp;
     987        RTStrPrintf(szTmpIp, sizeof(szTmpIp), "%RTnaipv4", dhcpupperip);
     988        m->IPv4DhcpServerUpperIp = szTmpIp;
     989
     990        LogFunc(("network:%RTnaipv4, dhcpserver:%RTnaipv4, dhcplowerip:%RTnaipv4, dhcpupperip:%RTnaipv4\n",
     991                 network, dhcpserver, dhcplowerip, dhcpupperip));
     992    }
     993
    1018994    /* we need IPv4NetworkMask for NAT's gw service start */
    1019995    netmask.u = RT_H2N_U32(netmask.u);
    1020     RTStrPrintf(aszNetmask, 16, "%RTnaipv4", netmask);
    1021     m->IPv4NetworkMask = aszNetmask;
     996    RTStrPrintf(szTmpIp, 16, "%RTnaipv4", netmask);
     997    m->IPv4NetworkMask = szTmpIp;
     998
    1022999    LogFlowFunc(("getaway:%RTnaipv4, netmask:%RTnaipv4\n", gateway, netmask));
    10231000    return VINF_SUCCESS;
    10241001}
     1002
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