VirtualBox

Changeset 60786 in vbox


Ignore:
Timestamp:
May 2, 2016 1:00:02 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
106985
Message:

Main/NATNetwork+NATEngine: simplify settings handling greatly by directly using the structs without tedious translation

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r60410 r60786  
    1818
    1919/*
    20  * Copyright (C) 2007-2015 Oracle Corporation
     20 * Copyright (C) 2007-2016 Oracle Corporation
    2121 *
    2222 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    202202    com::Utf8Str            strGuestIP;
    203203};
    204 typedef std::list<NATRule> NATRuleList;
     204typedef std::map<com::Utf8Str, NATRule> NATRulesMap;
    205205
    206206
    … …  
    210210    com::Utf8Str strLoopbackHostAddress;
    211211    uint32_t u32Offset;
    212     bool operator == (const com::Utf8Str& strAddr)
    213     {
    214         return (strLoopbackHostAddress == strAddr);
    215     }
    216 
    217     bool operator == (uint32_t off)
    218     {
    219         return (this->u32Offset == off);
     212    bool operator==(const com::Utf8Str& strAddr)
     213    {
     214        return strLoopbackHostAddress == strAddr;
     215    }
     216
     217    bool operator==(uint32_t off)
     218    {
     219        return u32Offset == off;
     220    }
     221
     222    bool operator==(const NATHostLoopbackOffset &o) const
     223    {
     224        return strLoopbackHostAddress == o.strLoopbackHostAddress
     225            && u32Offset == o.u32Offset;
    220226    }
    221227};
    … …  
    257263    void readMedium(MediaType t, uint32_t depth, const xml::ElementNode &elmMedium, Medium &med);
    258264    void readMediaRegistry(const xml::ElementNode &elmMediaRegistry, MediaRegistry &mr);
    259     void readNATForwardRuleList(const xml::ElementNode  &elmParent, NATRuleList &llRules);
     265    void readNATForwardRulesMap(const xml::ElementNode  &elmParent, NATRulesMap &mapRules);
    260266    void readNATLoopbacks(const xml::ElementNode &elmParent, NATLoopbackOffsetList &llLoopBacks);
    261267
    … …  
    273279    void buildMediaRegistry(xml::ElementNode &elmParent,
    274280                            const MediaRegistry &mr);
    275     void buildNATForwardRuleList(xml::ElementNode &elmParent, const NATRuleList &natRuleList);
     281    void buildNATForwardRulesMap(xml::ElementNode &elmParent, const NATRulesMap &mapRules);
    276282    void buildNATLoopbacks(xml::ElementNode &elmParent, const NATLoopbackOffsetList &natLoopbackList);
    277283    void clearDocument();
    … …  
    388394                    strIPUpper;
    389395    bool            fEnabled;
    390     DhcpOptionMap     GlobalDhcpOptions;
     396    DhcpOptionMap   GlobalDhcpOptions;
    391397    VmSlot2OptionsMap VmSlot2OptionsM;
    392398};
    … …  
    400406{
    401407    com::Utf8Str strNetworkName;
     408    com::Utf8Str strIPv4NetworkCidr;
     409    com::Utf8Str strIPv6Prefix;
    402410    bool         fEnabled;
    403     com::Utf8Str strNetwork;
    404     bool         fIPv6;
    405     com::Utf8Str strIPv6Prefix;
     411    bool         fIPv6Enabled;
     412    bool         fAdvertiseDefaultIPv6Route;
     413    bool         fNeedDhcpServer;
    406414    uint32_t     u32HostLoopback6Offset;
    407415    NATLoopbackOffsetList llHostLoopbackOffsetList;
    408     bool         fAdvertiseDefaultIPv6Route;
    409     bool         fNeedDhcpServer;
    410     NATRuleList  llPortForwardRules4;
    411     NATRuleList  llPortForwardRules6;
    412     NATNetwork():fEnabled(true),
     416    NATRulesMap  mapPortForwardRules4;
     417    NATRulesMap  mapPortForwardRules6;
     418    NATNetwork() :
     419      fEnabled(true),
     420      fIPv6Enabled(false),
    413421      fAdvertiseDefaultIPv6Route(false),
    414       fNeedDhcpServer(true)
     422      fNeedDhcpServer(true),
     423      u32HostLoopback6Offset(0)
    415424      {}
    416425    bool operator==(const NATNetwork &n) const
    417426    {
    418         return    strNetworkName == n.strNetworkName
    419                && strNetwork == n.strNetwork;
     427        return strNetworkName               == n.strNetworkName
     428            && strIPv4NetworkCidr           == n.strIPv4NetworkCidr
     429            && strIPv6Prefix                == n.strIPv6Prefix
     430            && fEnabled                     == n.fEnabled
     431            && fIPv6Enabled                 == n.fIPv6Enabled
     432            && fAdvertiseDefaultIPv6Route   == n.fAdvertiseDefaultIPv6Route
     433            && fNeedDhcpServer              == n.fNeedDhcpServer
     434            && u32HostLoopback6Offset       == n.u32HostLoopback6Offset
     435            && llHostLoopbackOffsetList     == n.llHostLoopbackOffsetList
     436            && mapPortForwardRules4         == n.mapPortForwardRules4
     437            && mapPortForwardRules6         == n.mapPortForwardRules6;
    420438    }
    421439
    … …  
    544562};
    545563
    546  struct NAT
    547  {
    548      NAT()
    549          : u32Mtu(0),
    550            u32SockRcv(0),
    551            u32SockSnd(0),
    552            u32TcpRcv(0),
    553            u32TcpSnd(0),
    554            fDNSPassDomain(true), /* historically this value is true */
    555            fDNSProxy(false),
    556            fDNSUseHostResolver(false),
    557            fAliasLog(false),
    558            fAliasProxyOnly(false),
    559            fAliasUseSamePorts(false)
    560      {}
    561 
    562      bool operator==(const NAT &n) const
    563      {
    564         return strNetwork           == n.strNetwork
    565              && strBindIP           == n.strBindIP
    566              && u32Mtu              == n.u32Mtu
    567              && u32SockRcv          == n.u32SockRcv
    568              && u32SockSnd          == n.u32SockSnd
    569              && u32TcpSnd           == n.u32TcpSnd
    570              && u32TcpRcv           == n.u32TcpRcv
    571              && strTFTPPrefix       == n.strTFTPPrefix
    572              && strTFTPBootFile     == n.strTFTPBootFile
    573              && strTFTPNextServer   == n.strTFTPNextServer
    574              && fDNSPassDomain      == n.fDNSPassDomain
    575              && fDNSProxy           == n.fDNSProxy
    576              && fDNSUseHostResolver == n.fDNSUseHostResolver
    577              && fAliasLog           == n.fAliasLog
    578              && fAliasProxyOnly     == n.fAliasProxyOnly
    579              && fAliasUseSamePorts  == n.fAliasUseSamePorts
    580              && llRules             == n.llRules;
    581      }
    582 
    583      com::Utf8Str            strNetwork;
    584      com::Utf8Str            strBindIP;
    585      uint32_t                u32Mtu;
    586      uint32_t                u32SockRcv;
    587      uint32_t                u32SockSnd;
    588      uint32_t                u32TcpRcv;
    589      uint32_t                u32TcpSnd;
    590      com::Utf8Str            strTFTPPrefix;
    591      com::Utf8Str            strTFTPBootFile;
    592      com::Utf8Str            strTFTPNextServer;
    593      bool                    fDNSPassDomain;
    594      bool                    fDNSProxy;
    595      bool                    fDNSUseHostResolver;
    596      bool                    fAliasLog;
    597      bool                    fAliasProxyOnly;
    598      bool                    fAliasUseSamePorts;
    599      NATRuleList             llRules;
    600  };
     564struct NAT
     565{
     566    NAT()
     567        : u32Mtu(0),
     568          u32SockRcv(0),
     569          u32SockSnd(0),
     570          u32TcpRcv(0),
     571          u32TcpSnd(0),
     572          fDNSPassDomain(true), /* historically this value is true */
     573          fDNSProxy(false),
     574          fDNSUseHostResolver(false),
     575          fAliasLog(false),
     576          fAliasProxyOnly(false),
     577          fAliasUseSamePorts(false)
     578    {}
     579
     580    bool operator==(const NAT &n) const
     581    {
     582       return strNetwork           == n.strNetwork
     583            && strBindIP           == n.strBindIP
     584            && u32Mtu              == n.u32Mtu
     585            && u32SockRcv          == n.u32SockRcv
     586            && u32SockSnd          == n.u32SockSnd
     587            && u32TcpSnd           == n.u32TcpSnd
     588            && u32TcpRcv           == n.u32TcpRcv
     589            && strTFTPPrefix       == n.strTFTPPrefix
     590            && strTFTPBootFile     == n.strTFTPBootFile
     591            && strTFTPNextServer   == n.strTFTPNextServer
     592            && fDNSPassDomain      == n.fDNSPassDomain
     593            && fDNSProxy           == n.fDNSProxy
     594            && fDNSUseHostResolver == n.fDNSUseHostResolver
     595            && fAliasLog           == n.fAliasLog
     596            && fAliasProxyOnly     == n.fAliasProxyOnly
     597            && fAliasUseSamePorts  == n.fAliasUseSamePorts
     598            && mapRules            == n.mapRules;
     599    }
     600
     601    com::Utf8Str            strNetwork;
     602    com::Utf8Str            strBindIP;
     603    uint32_t                u32Mtu;
     604    uint32_t                u32SockRcv;
     605    uint32_t                u32SockSnd;
     606    uint32_t                u32TcpRcv;
     607    uint32_t                u32TcpSnd;
     608    com::Utf8Str            strTFTPPrefix;
     609    com::Utf8Str            strTFTPBootFile;
     610    com::Utf8Str            strTFTPNextServer;
     611    bool                    fDNSPassDomain;
     612    bool                    fDNSProxy;
     613    bool                    fDNSUseHostResolver;
     614    bool                    fAliasLog;
     615    bool                    fAliasProxyOnly;
     616    bool                    fAliasUseSamePorts;
     617    NATRulesMap             mapRules;
     618};
    601619
    602620/**

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

    r58827 r60786  
    55
    66/*
    7  * Copyright (C) 2006-2013 Oracle Corporation
     7 * Copyright (C) 2006-2016 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    6262    void FinalRelease();
    6363
    64     HRESULT init(VirtualBox *aVirtualBox,
    65                  com::Utf8Str aName);
    66 
    67 
    68     HRESULT init(VirtualBox *aVirtualBox,
    69                  const settings::NATNetwork &data);
     64    HRESULT init(VirtualBox *aVirtualBox, com::Utf8Str aName);
     65    HRESULT i_loadSettings(const settings::NATNetwork &data);
    7066    void uninit();
    7167    HRESULT i_saveSettings(settings::NATNetwork &data);
    … …  
    9894    // wrapped INATNetwork methods
    9995    HRESULT addLocalMapping(const com::Utf8Str &aHostid,
    100                                   LONG aOffset);
     96                            LONG aOffset);
    10197    HRESULT addPortForwardRule(BOOL aIsIpv6,
    10298                               const com::Utf8Str &aRuleName,
    … …  
    116112    int i_recalculateIPv6Prefix();
    117113
    118     typedef std::map<Utf8Str, settings::NATRule> NATRuleMap;
    119     typedef NATRuleMap::const_iterator constNATRuleMapIterator;
    120 
    121     void i_getPortForwardRulesFromMap(std::vector<Utf8Str> &aPortForwardRules, NATRuleMap& aRules);
    122 
    123     /** weak VirtualBox parent */
    124     VirtualBox * const mVirtualBox;
    125 
    126     const  com::Utf8Str mName;
     114    void i_getPortForwardRulesFromMap(std::vector<Utf8Str> &aPortForwardRules, settings::NATRulesMap &aRules);
    127115
    128116    struct Data;
    129     struct Data *m;
    130 
     117    Data *m;
    131118};
    132119

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

    r57751 r60786  
    55
    66/*
    7  * Copyright (C) 2010-2015 Oracle Corporation
     7 * Copyright (C) 2010-2016 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2929#include <VBox/com/array.h>
    3030
    31 typedef std::map<Utf8Str, settings::NATRule> NATRuleMap;
    32 
    3331struct NATEngineData
    3432{
    35     NATEngineData() : mMtu(0),
    36              mSockRcv(0),
    37              mSockSnd(0),
    38              mTcpRcv(0),
    39              mTcpSnd(0),
    40              mDNSPassDomain(TRUE),
    41              mDNSProxy(FALSE),
    42              mDNSUseHostResolver(FALSE),
    43              mAliasMode(0)
     33    NATEngineData()
    4434    {}
    4535
    46     com::Utf8Str mNetwork;
    47     com::Utf8Str mBindIP;
    48     uint32_t mMtu;
    49     uint32_t mSockRcv;
    50     uint32_t mSockSnd;
    51     uint32_t mTcpRcv;
    52     uint32_t mTcpSnd;
    53     /* TFTP service */
    54     Utf8Str mTFTPPrefix;
    55     Utf8Str mTFTPBootFile;
    56     Utf8Str mTFTPNextServer;
    57     /* DNS service */
    58     BOOL mDNSPassDomain;
    59     BOOL mDNSProxy;
    60     BOOL mDNSUseHostResolver;
    61     /* Alias service */
    62     ULONG mAliasMode;
    63     /* Port forwarding rules */
    64     NATRuleMap mNATRules;
     36    settings::NAT s;
    6537};
    6638
    … …  
    9668    mData = new Data();
    9769    mData->m.allocate();
    98     mData->m->mNetwork.setNull();
    99     mData->m->mBindIP.setNull();
     70    mData->m->s.strNetwork.setNull();
     71    mData->m->s.strBindIP.setNull();
    10072    unconst(mParent) = aParent;
    10173    unconst(mAdapter) = aAdapter;
    … …  
    219191    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    220192    if (aMtu)
    221         *aMtu = mData->m->mMtu;
     193        *aMtu = mData->m->s.u32Mtu;
    222194    if (aSockSnd)
    223         *aSockSnd = mData->m->mSockSnd;
     195        *aSockSnd = mData->m->s.u32SockSnd;
    224196    if (aSockRcv)
    225         *aSockRcv = mData->m->mSockRcv;
     197        *aSockRcv = mData->m->s.u32SockRcv;
    226198    if (aTcpWndSnd)
    227         *aTcpWndSnd = mData->m->mTcpSnd;
     199        *aTcpWndSnd = mData->m->s.u32TcpSnd;
    228200    if (aTcpWndRcv)
    229         *aTcpWndRcv = mData->m->mTcpRcv;
     201        *aTcpWndRcv = mData->m->s.u32TcpRcv;
    230202
    231203    return S_OK;
    … …  
    242214    }
    243215    if (aMtu)
    244         mData->m->mMtu = aMtu;
     216        mData->m->s.u32Mtu = aMtu;
    245217    if (aSockSnd)
    246         mData->m->mSockSnd = aSockSnd;
     218        mData->m->s.u32SockSnd = aSockSnd;
    247219    if (aSockRcv)
    248         mData->m->mSockRcv = aSockSnd;
     220        mData->m->s.u32SockRcv = aSockSnd;
    249221    if (aTcpWndSnd)
    250         mData->m->mTcpSnd = aTcpWndSnd;
     222        mData->m->s.u32TcpSnd = aTcpWndSnd;
    251223    if (aTcpWndRcv)
    252         mData->m->mTcpRcv = aTcpWndRcv;
     224        mData->m->s.u32TcpRcv = aTcpWndRcv;
    253225
    254226    return S_OK;
    … …  
    260232    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    261233
    262     aRedirects.resize(mData->m->mNATRules.size());
     234    aRedirects.resize(mData->m->s.mapRules.size());
    263235    size_t i = 0;
    264     NATRuleMap::const_iterator it;
    265     for (it = mData->m->mNATRules.begin(); it != mData->m->mNATRules.end(); ++it, ++i)
     236    settings::NATRulesMap::const_iterator it;
     237    for (it = mData->m->s.mapRules.begin(); it != mData->m->s.mapRules.end(); ++it, ++i)
    266238    {
    267239        settings::NATRule r = it->second;
    … …  
    298270        name = Utf8StrFmt("%s_%d_%d", proto, aHostPort, aGuestPort);
    299271
    300     NATRuleMap::iterator it;
    301     for (it = mData->m->mNATRules.begin(); it != mData->m->mNATRules.end(); ++it)
     272    settings::NATRulesMap::iterator it;
     273    for (it = mData->m->s.mapRules.begin(); it != mData->m->s.mapRules.end(); ++it)
    302274    {
    303275        r = it->second;
    … …  
    319291    r.strGuestIP = aGuestIP;
    320292    r.u16GuestPort = aGuestPort;
    321     mData->m->mNATRules.insert(std::make_pair(name, r));
     293    mData->m->s.mapRules.insert(std::make_pair(name, r));
    322294    mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    323295
    … …  
    334306{
    335307    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    336     NATRuleMap::iterator it = mData->m->mNATRules.find(aName);
    337     if (it == mData->m->mNATRules.end())
     308    settings::NATRulesMap::iterator it = mData->m->s.mapRules.find(aName);
     309    if (it == mData->m->s.mapRules.end())
    338310        return E_INVALIDARG;
    339311    mData->m.backup();
    340312    /*
    341313     * NB: "it" may now point to the backup!  In that case it's ok to
    342      * get data from the backup copy of mNATRules via it, but we can't
    343      * erase(it) from potentially new mNATRules.
     314     * get data from the backup copy of s.mapRules via it, but we can't
     315     * erase(it) from potentially new s.mapRules.
    344316     */
    345317    settings::NATRule r = it->second;
    … …  
    352324    mAdapter->COMGETTER(Slot)(&ulSlot);
    353325
    354     mData->m->mNATRules.erase(aName); /* NB: erase by key, "it" may not be valid */
     326    mData->m->s.mapRules.erase(aName); /* NB: erase by key, "it" may not be valid */
    355327    mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    356328    alock.release();
    … …  
    366338
    367339    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    368     HRESULT rc = S_OK;
    369     mData->m->mNetwork = data.strNetwork;
    370     mData->m->mBindIP = data.strBindIP;
    371     mData->m->mMtu = data.u32Mtu;
    372     mData->m->mSockSnd = data.u32SockSnd;
    373     mData->m->mTcpRcv = data.u32TcpRcv;
    374     mData->m->mTcpSnd = data.u32TcpSnd;
    375     /* TFTP */
    376     mData->m->mTFTPPrefix = data.strTFTPPrefix;
    377     mData->m->mTFTPBootFile = data.strTFTPBootFile;
    378     mData->m->mTFTPNextServer = data.strTFTPNextServer;
    379     /* DNS */
    380     mData->m->mDNSPassDomain = data.fDNSPassDomain;
    381     mData->m->mDNSProxy = data.fDNSProxy;
    382     mData->m->mDNSUseHostResolver = data.fDNSUseHostResolver;
    383     /* Alias */
    384     mData->m->mAliasMode  = (data.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
    385     mData->m->mAliasMode |= (data.fAliasLog          ? NATAliasMode_AliasLog          : 0);
    386     mData->m->mAliasMode |= (data.fAliasProxyOnly    ? NATAliasMode_AliasProxyOnly    : 0);
    387     /* port forwarding */
    388     mData->m->mNATRules.clear();
    389     for (settings::NATRuleList::const_iterator it = data.llRules.begin();
    390         it != data.llRules.end(); ++it)
    391     {
    392         mData->m->mNATRules.insert(std::make_pair(it->strName, *it));
    393     }
    394     return rc;
     340    mData->m->s = data;
     341    return S_OK;
    395342}
    396343
    … …  
    403350    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    404351    HRESULT rc = S_OK;
    405     data.strNetwork = mData->m->mNetwork;
    406     data.strBindIP = mData->m->mBindIP;
    407     data.u32Mtu = mData->m->mMtu;
    408     data.u32SockRcv = mData->m->mSockRcv;
    409     data.u32SockSnd = mData->m->mSockSnd;
    410     data.u32TcpRcv = mData->m->mTcpRcv;
    411     data.u32TcpSnd = mData->m->mTcpSnd;
    412     /* TFTP */
    413     data.strTFTPPrefix = mData->m->mTFTPPrefix;
    414     data.strTFTPBootFile = mData->m->mTFTPBootFile;
    415     data.strTFTPNextServer = mData->m->mTFTPNextServer;
    416     /* DNS */
    417     data.fDNSPassDomain = !!mData->m->mDNSPassDomain;
    418     data.fDNSProxy = !!mData->m->mDNSProxy;
    419     data.fDNSUseHostResolver = !!mData->m->mDNSUseHostResolver;
    420     /* Alias */
    421     data.fAliasLog = !!(mData->m->mAliasMode & NATAliasMode_AliasLog);
    422     data.fAliasProxyOnly = !!(mData->m->mAliasMode & NATAliasMode_AliasProxyOnly);
    423     data.fAliasUseSamePorts = !!(mData->m->mAliasMode & NATAliasMode_AliasUseSamePorts);
    424 
    425     for (NATRuleMap::iterator it = mData->m->mNATRules.begin();
    426         it != mData->m->mNATRules.end(); ++it)
    427         data.llRules.push_back(it->second);
     352    data = mData->m->s;
    428353    return rc;
    429354}
    … …  
    432357{
    433358    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    434     if (Bstr(mData->m->mNetwork) != aNetwork)
    435     {
    436         mData->m.backup();
    437         mData->m->mNetwork = aNetwork;
     359    if (mData->m->s.strNetwork != aNetwork)
     360    {
     361        mData->m.backup();
     362        mData->m->s.strNetwork = aNetwork;
    438363        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    439364    }
    … …  
    445370{
    446371    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    447     if (!mData->m->mNetwork.isEmpty())
    448     {
    449         aNetwork = mData->m->mNetwork;
    450         Log(("Getter (this:%p) Network: %s\n", this, mData->m->mNetwork.c_str()));
     372    if (!mData->m->s.strNetwork.isEmpty())
     373    {
     374        aNetwork = mData->m->s.strNetwork;
     375        Log(("Getter (this:%p) Network: %s\n", this, mData->m->s.strNetwork.c_str()));
    451376    }
    452377    return S_OK;
    … …  
    456381{
    457382    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    458     if (Bstr(mData->m->mBindIP) != aHostIP)
    459     {
    460         mData->m.backup();
    461         mData->m->mBindIP = aHostIP;
     383    if (mData->m->s.strBindIP != aHostIP)
     384    {
     385        mData->m.backup();
     386        mData->m->s.strBindIP = aHostIP;
    462387        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    463388    }
    … …  
    469394    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    470395
    471     if (!mData->m->mBindIP.isEmpty())
    472         aBindIP = mData->m->mBindIP;
     396    if (!mData->m->s.strBindIP.isEmpty())
     397        aBindIP = mData->m->s.strBindIP;
    473398    return S_OK;
    474399}
    … …  
    477402{
    478403    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    479     if (Bstr(mData->m->mTFTPPrefix) != aTFTPPrefix)
    480     {
    481         mData->m.backup();
    482         mData->m->mTFTPPrefix = aTFTPPrefix;
     404    if (mData->m->s.strTFTPPrefix != aTFTPPrefix)
     405    {
     406        mData->m.backup();
     407        mData->m->s.strTFTPPrefix = aTFTPPrefix;
    483408        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    484409    }
    … …  
    491416    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    492417
    493     if (!mData->m->mTFTPPrefix.isEmpty())
    494     {
    495         aTFTPPrefix = mData->m->mTFTPPrefix;
    496         Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->m->mTFTPPrefix.c_str()));
     418    if (!mData->m->s.strTFTPPrefix.isEmpty())
     419    {
     420        aTFTPPrefix = mData->m->s.strTFTPPrefix;
     421        Log(("Getter (this:%p) TFTPPrefix: %s\n", this, mData->m->s.strTFTPPrefix.c_str()));
    497422    }
    498423    return S_OK;
    … …  
    502427{
    503428    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    504     if (Bstr(mData->m->mTFTPBootFile) != aTFTPBootFile)
    505     {
    506         mData->m.backup();
    507         mData->m->mTFTPBootFile = aTFTPBootFile;
     429    if (mData->m->s.strTFTPBootFile != aTFTPBootFile)
     430    {
     431        mData->m.backup();
     432        mData->m->s.strTFTPBootFile = aTFTPBootFile;
    508433        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    509434    }
    … …  
    515440{
    516441    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    517     if (!mData->m->mTFTPBootFile.isEmpty())
    518     {
    519         aTFTPBootFile = mData->m->mTFTPBootFile;
    520         Log(("Getter (this:%p) BootFile: %s\n", this, mData->m->mTFTPBootFile.c_str()));
     442    if (!mData->m->s.strTFTPBootFile.isEmpty())
     443    {
     444        aTFTPBootFile = mData->m->s.strTFTPBootFile;
     445        Log(("Getter (this:%p) BootFile: %s\n", this, mData->m->s.strTFTPBootFile.c_str()));
    521446    }
    522447    return S_OK;
    … …  
    527452{
    528453    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    529     if (Bstr(mData->m->mTFTPNextServer) != aTFTPNextServer)
    530     {
    531         mData->m.backup();
    532         mData->m->mTFTPNextServer = aTFTPNextServer;
     454    if (mData->m->s.strTFTPNextServer != aTFTPNextServer)
     455    {
     456        mData->m.backup();
     457        mData->m->s.strTFTPNextServer = aTFTPNextServer;
    533458        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    534459    }
    … …  
    539464{
    540465    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    541     if (!mData->m->mTFTPNextServer.isEmpty())
    542     {
    543         aTFTPNextServer =  mData->m->mTFTPNextServer;
    544         Log(("Getter (this:%p) NextServer: %s\n", this, mData->m->mTFTPNextServer.c_str()));
     466    if (!mData->m->s.strTFTPNextServer.isEmpty())
     467    {
     468        aTFTPNextServer =  mData->m->s.strTFTPNextServer;
     469        Log(("Getter (this:%p) NextServer: %s\n", this, mData->m->s.strTFTPNextServer.c_str()));
    545470    }
    546471    return S_OK;
    … …  
    552477    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    553478
    554     if (mData->m->mDNSPassDomain != aDNSPassDomain)
    555     {
    556         mData->m.backup();
    557         mData->m->mDNSPassDomain = aDNSPassDomain;
     479    if (mData->m->s.fDNSPassDomain != RT_BOOL(aDNSPassDomain))
     480    {
     481        mData->m.backup();
     482        mData->m->s.fDNSPassDomain = RT_BOOL(aDNSPassDomain);
    558483        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    559484    }
    … …  
    564489{
    565490    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    566     *aDNSPassDomain = mData->m->mDNSPassDomain;
     491    *aDNSPassDomain = mData->m->s.fDNSPassDomain;
    567492    return S_OK;
    568493}
    … …  
    573498    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    574499
    575     if (mData->m->mDNSProxy != aDNSProxy)
    576     {
    577         mData->m.backup();
    578         mData->m->mDNSProxy = aDNSProxy;
     500    if (mData->m->s.fDNSProxy != RT_BOOL(aDNSProxy))
     501    {
     502        mData->m.backup();
     503        mData->m->s.fDNSProxy = RT_BOOL(aDNSProxy);
    579504        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    580505    }
    … …  
    585510{
    586511    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    587     *aDNSProxy = mData->m->mDNSProxy;
     512    *aDNSProxy = mData->m->s.fDNSProxy;
    588513    return S_OK;
    589514}
    … …  
    593518{
    594519    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    595     *aDNSUseHostResolver = mData->m->mDNSUseHostResolver;
     520    *aDNSUseHostResolver = mData->m->s.fDNSUseHostResolver;
    596521    return S_OK;
    597522}
    … …  
    600525HRESULT NATEngine::setDNSUseHostResolver(BOOL aDNSUseHostResolver)
    601526{
    602     if (mData->m->mDNSUseHostResolver != aDNSUseHostResolver)
    603     {
    604         mData->m.backup();
    605         mData->m->mDNSUseHostResolver = aDNSUseHostResolver;
     527    if (mData->m->s.fDNSUseHostResolver != RT_BOOL(aDNSUseHostResolver))
     528    {
     529        mData->m.backup();
     530        mData->m->s.fDNSUseHostResolver = RT_BOOL(aDNSUseHostResolver);
    606531        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    607532    }
    … …  
    612537{
    613538    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    614 
    615     if (mData->m->mAliasMode != aAliasMode)
    616     {
    617         mData->m.backup();
    618         mData->m->mAliasMode = aAliasMode;
     539    ULONG uAliasMode = (mData->m->s.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
     540    uAliasMode |= (mData->m->s.fAliasLog ? NATAliasMode_AliasLog : 0);
     541    uAliasMode |= (mData->m->s.fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
     542    if (uAliasMode != aAliasMode)
     543    {
     544        mData->m.backup();
     545        mData->m->s.fAliasUseSamePorts = RT_BOOL(aAliasMode & NATAliasMode_AliasUseSamePorts);
     546        mData->m->s.fAliasLog = RT_BOOL(aAliasMode & NATAliasMode_AliasLog);
     547        mData->m->s.fAliasProxyOnly = RT_BOOL(aAliasMode & NATAliasMode_AliasProxyOnly);
    619548        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
    620549    }
    … …  
    625554{
    626555    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    627     *aAliasMode = mData->m->mAliasMode;
    628     return S_OK;
    629 }
    630 
     556    ULONG uAliasMode = (mData->m->s.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
     557    uAliasMode |= (mData->m->s.fAliasLog ? NATAliasMode_AliasLog : 0);
     558    uAliasMode |= (mData->m->s.fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
     559    *aAliasMode = uAliasMode;
     560    return S_OK;
     561}
     562

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

    r58827 r60786  
    55
    66/*
    7  * Copyright (C) 2013 Oracle Corporation
     7 * Copyright (C) 2013-2016 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4949{
    5050    Data()
    51       : fEnabled(TRUE)
    52       , fIPv6Enabled(FALSE)
    53       , fAdvertiseDefaultIPv6Route(FALSE)
    54       , fNeedDhcpServer(TRUE)
    55       , u32LoopbackIp6(0)
     51      : pVirtualBox(NULL)
    5652      , offGateway(0)
    5753      , offDhcp(0)
    5854    {
    59         IPv4Gateway.setNull();
    60         IPv4NetworkCidr.setNull();
    61         IPv6Prefix.setNull();
    62         IPv4DhcpServer.setNull();
    63         IPv4NetworkMask.setNull();
    64         IPv4DhcpServerLowerIp.setNull();
    65         IPv4DhcpServerUpperIp.setNull();
    6655    }
    6756    virtual ~Data(){}
    … …  
    7160    ComObjPtr<IDHCPServer> dhcpServer;
    7261#endif
     62    /** weak VirtualBox parent */
     63    VirtualBox * const pVirtualBox;
     64
     65    /** NATNetwork settings */
     66    settings::NATNetwork s;
     67
    7368    com::Utf8Str IPv4Gateway;
    74     com::Utf8Str IPv4NetworkCidr;
    7569    com::Utf8Str IPv4NetworkMask;
    7670    com::Utf8Str IPv4DhcpServer;
    7771    com::Utf8Str IPv4DhcpServerLowerIp;
    7872    com::Utf8Str IPv4DhcpServerUpperIp;
    79     BOOL fEnabled;
    80     BOOL fIPv6Enabled;
    81     com::Utf8Str IPv6Prefix;
    82     BOOL fAdvertiseDefaultIPv6Route;
    83     BOOL fNeedDhcpServer;
    84     NATRuleMap mapName2PortForwardRule4;
    85     NATRuleMap mapName2PortForwardRule6;
    86     settings::NATLoopbackOffsetList maNATLoopbackOffsetList;
    87     uint32_t u32LoopbackIp6;
     73
    8874    uint32_t offGateway;
    8975    uint32_t offDhcp;
    … …  
    9278
    9379NATNetwork::NATNetwork()
    94     : mVirtualBox(NULL)
     80    : m(NULL)
    9581{
    9682}
    … …  
    122108    if (autoUninitSpan.uninitDone())
    123109        return;
     110    unconst(m->pVirtualBox) = NULL;
    124111    delete m;
    125112    m = NULL;
    126     unconst(mVirtualBox) = NULL;
    127113}
    128114
    … …  
    134120    AssertReturn(autoInitSpan.isOk(), E_FAIL);
    135121
    136     /* share VirtualBox weakly (parent remains NULL so far) */
    137     unconst(mVirtualBox) = aVirtualBox;
    138     unconst(mName) = aName;
    139122    m = new Data();
     123    /* share VirtualBox weakly */
     124    unconst(m->pVirtualBox) = aVirtualBox;
     125    m->s.strNetworkName = aName;
     126    m->s.strIPv4NetworkCidr = "10.0.2.0/24";
    140127    m->offGateway = 1;
    141     m->IPv4NetworkCidr = "10.0.2.0/24";
    142     i_recalculateIPv6Prefix();  /* set m->IPv6Prefix based on IPv4 */
     128    i_recalculateIPv6Prefix();  /* set m->strIPv6Prefix based on IPv4 */
    143129
    144130    settings::NATHostLoopbackOffset off;
    145131    off.strLoopbackHostAddress = "127.0.0.1";
    146132    off.u32Offset = (uint32_t)2;
    147     m->maNATLoopbackOffsetList.push_back(off);
     133    m->s.llHostLoopbackOffsetList.push_back(off);
    148134
    149135    i_recalculateIpv4AddressAssignments();
    … …  
    162148
    163149
    164 HRESULT NATNetwork::init(VirtualBox *aVirtualBox,
    165                          const settings::NATNetwork &data)
    166 {
    167     /* Enclose the state transition NotReady->InInit->Ready */
    168     AutoInitSpan autoInitSpan(this);
    169     AssertReturn(autoInitSpan.isOk(), E_FAIL);
    170 
    171     /* share VirtualBox weakly (parent remains NULL so far) */
    172     unconst(mVirtualBox) = aVirtualBox;
    173 
    174     unconst(mName) = data.strNetworkName;
    175     m = new Data();
    176     m->IPv4NetworkCidr = data.strNetwork;
    177     m->fEnabled = data.fEnabled;
    178     m->fAdvertiseDefaultIPv6Route = data.fAdvertiseDefaultIPv6Route;
    179     m->fNeedDhcpServer = data.fNeedDhcpServer;
    180     m->fIPv6Enabled = data.fIPv6;
    181 
    182     if (   data.strIPv6Prefix.isEmpty()
     150HRESULT NATNetwork::i_loadSettings(const settings::NATNetwork &data)
     151{
     152    AutoCaller autoCaller(this);
     153    AssertComRCReturnRC(autoCaller.rc());
     154
     155    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     156    m->s = data;
     157    if (   m->s.strIPv6Prefix.isEmpty()
    183158           /* also clean up bogus old default */
    184         || data.strIPv6Prefix == "fe80::/64")
    185         i_recalculateIPv6Prefix(); /* set m->IPv6Prefix based on IPv4 */
    186     else
    187         m->IPv6Prefix = data.strIPv6Prefix;
    188 
    189     m->u32LoopbackIp6 = data.u32HostLoopback6Offset;
    190 
    191     m->maNATLoopbackOffsetList.clear();
    192     m->maNATLoopbackOffsetList.assign(data.llHostLoopbackOffsetList.begin(),
    193                                data.llHostLoopbackOffsetList.end());
    194 
     159        || m->s.strIPv6Prefix == "fe80::/64")
     160        i_recalculateIPv6Prefix(); /* set m->strIPv6Prefix based on IPv4 */
    195161    i_recalculateIpv4AddressAssignments();
    196 
    197     /* IPv4 port-forward rules */
    198     m->mapName2PortForwardRule4.clear();
    199     for (settings::NATRuleList::const_iterator it = data.llPortForwardRules4.begin();
    200         it != data.llPortForwardRules4.end(); ++it)
    201     {
    202         m->mapName2PortForwardRule4.insert(std::make_pair(it->strName.c_str(), *it));
    203     }
    204 
    205     /* IPv6 port-forward rules */
    206     m->mapName2PortForwardRule6.clear();
    207     for (settings::NATRuleList::const_iterator it = data.llPortForwardRules6.begin();
    208         it != data.llPortForwardRules6.end(); ++it)
    209     {
    210         m->mapName2PortForwardRule6.insert(std::make_pair(it->strName, *it));
    211     }
    212 
    213     HRESULT hrc = unconst(m->pEventSource).createObject();
    214     if (FAILED(hrc)) throw hrc;
    215 
    216     hrc = m->pEventSource->init();
    217     if (FAILED(hrc)) throw hrc;
    218 
    219     autoInitSpan.setSucceeded();
    220162
    221163    return S_OK;
    … …  
    228170
    229171    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    230 
    231     data.strNetworkName = mName;
    232     data.strNetwork = m->IPv4NetworkCidr;
    233     data.fEnabled = RT_BOOL(m->fEnabled);
    234     data.fAdvertiseDefaultIPv6Route = RT_BOOL(m->fAdvertiseDefaultIPv6Route);
    235     data.fNeedDhcpServer = RT_BOOL(m->fNeedDhcpServer);
    236     data.fIPv6 = RT_BOOL(m->fIPv6Enabled);
    237     data.strIPv6Prefix = m->IPv6Prefix;
    238 
    239     /* saving ipv4 port-forward Rules*/
    240     data.llPortForwardRules4.clear();
    241     for (NATRuleMap::iterator it = m->mapName2PortForwardRule4.begin();
    242          it != m->mapName2PortForwardRule4.end(); ++it)
    243         data.llPortForwardRules4.push_back(it->second);
    244 
    245     /* saving ipv6 port-forward Rules*/
    246     data.llPortForwardRules6.clear();
    247     for (NATRuleMap::iterator it = m->mapName2PortForwardRule6.begin();
    248          it != m->mapName2PortForwardRule6.end(); ++it)
    249         data.llPortForwardRules6.push_back(it->second);
    250 
    251     data.u32HostLoopback6Offset = m->u32LoopbackIp6;
    252 
    253     data.llHostLoopbackOffsetList.clear();
    254     data.llHostLoopbackOffsetList.assign(m->maNATLoopbackOffsetList.begin(),
    255                                          m->maNATLoopbackOffsetList.end());
    256 
    257     mVirtualBox->i_onNATNetworkSetting(Bstr(mName).raw(),
    258                                        data.fEnabled ? TRUE : FALSE,
    259                                        Bstr(m->IPv4NetworkCidr).raw(),
    260                                        Bstr(m->IPv4Gateway).raw(),
    261                                        data.fAdvertiseDefaultIPv6Route ? TRUE : FALSE,
    262                                        data.fNeedDhcpServer ? TRUE : FALSE);
     172    data = m->s;
     173    alock.release();
     174
     175    m->pVirtualBox->i_onNATNetworkSetting(Bstr(m->s.strNetworkName).raw(),
     176                                          m->s.fEnabled,
     177                                          Bstr(m->s.strIPv4NetworkCidr).raw(),
     178                                          Bstr(m->IPv4Gateway).raw(),
     179                                          m->s.fAdvertiseDefaultIPv6Route,
     180                                          m->s.fNeedDhcpServer);
    263181
    264182    /* Notify listerners listening on this network only */
    265183    fireNATNetworkSettingEvent(m->pEventSource,
    266                                Bstr(mName).raw(),
    267                                data.fEnabled ? TRUE : FALSE,
    268                                Bstr(m->IPv4NetworkCidr).raw(),
     184                               Bstr(m->s.strNetworkName).raw(),
     185                               m->s.fEnabled,
     186                               Bstr(m->s.strIPv4NetworkCidr).raw(),
    269187                               Bstr(m->IPv4Gateway).raw(),
    270                                data.fAdvertiseDefaultIPv6Route ? TRUE : FALSE,
    271                                data.fNeedDhcpServer ? TRUE : FALSE);
     188                               m->s.fAdvertiseDefaultIPv6Route,
     189                               m->s.fNeedDhcpServer);
    272190
    273191    return S_OK;
    … …  
    283201HRESULT NATNetwork::getNetworkName(com::Utf8Str &aNetworkName)
    284202{
    285     aNetworkName = mName;
     203    aNetworkName = m->s.strNetworkName;
    286204    return S_OK;
    287205}
    … …  
    291209    {
    292210        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    293         if (aNetworkName == mName)
     211        if (aNetworkName == m->s.strNetworkName)
    294212            return S_OK;
    295213
    296         unconst(mName) = aNetworkName;
    297     }
    298     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    299     HRESULT rc = mVirtualBox->i_saveSettings();
     214        m->s.strNetworkName = aNetworkName;
     215    }
     216    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     217    HRESULT rc = m->pVirtualBox->i_saveSettings();
    300218    ComAssertComRCRetRC(rc);
    301219
    … …  
    305223HRESULT NATNetwork::getEnabled(BOOL *aEnabled)
    306224{
    307     *aEnabled = m->fEnabled;
     225    *aEnabled = m->s.fEnabled;
    308226
    309227    i_recalculateIpv4AddressAssignments();
    … …  
    315233    {
    316234        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    317         if (aEnabled == m->fEnabled)
     235        if (RT_BOOL(aEnabled) == m->s.fEnabled)
    318236            return S_OK;
    319         m->fEnabled = aEnabled;
    320     }
    321 
    322     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    323     HRESULT rc = mVirtualBox->i_saveSettings();
     237        m->s.fEnabled = RT_BOOL(aEnabled);
     238    }
     239
     240    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     241    HRESULT rc = m->pVirtualBox->i_saveSettings();
    324242    ComAssertComRCRetRC(rc);
    325243    return S_OK;
    … …  
    334252HRESULT NATNetwork::getNetwork(com::Utf8Str &aNetwork)
    335253{
    336     aNetwork = m->IPv4NetworkCidr;
     254    aNetwork = m->s.strIPv4NetworkCidr;
    337255    return S_OK;
    338256}
    … …  
    345263        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    346264
    347         if (aIPv4NetworkCidr == m->IPv4NetworkCidr)
     265        if (aIPv4NetworkCidr == m->s.strIPv4NetworkCidr)
    348266            return S_OK;
    349267
    … …  
    352270         * as offset from network id.
    353271         */
    354         if (!m->mapName2PortForwardRule4.empty())
     272        if (!m->s.mapPortForwardRules4.empty())
    355273            return S_OK;
    356274
    357275
    358         unconst(m->IPv4NetworkCidr) = aIPv4NetworkCidr;
     276        m->s.strIPv4NetworkCidr = aIPv4NetworkCidr;
    359277        i_recalculateIpv4AddressAssignments();
    360278    }
    361279
    362     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    363     HRESULT rc = mVirtualBox->i_saveSettings();
     280    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     281    HRESULT rc = m->pVirtualBox->i_saveSettings();
    364282    ComAssertComRCRetRC(rc);
    365283    return S_OK;
    … …  
    369287HRESULT NATNetwork::getIPv6Enabled(BOOL *aIPv6Enabled)
    370288{
    371     *aIPv6Enabled = m->fIPv6Enabled;
     289    *aIPv6Enabled = m->s.fIPv6Enabled;
    372290
    373291    return S_OK;
    … …  
    380298        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    381299
    382         if (aIPv6Enabled == m->fIPv6Enabled)
     300        if (RT_BOOL(aIPv6Enabled) == m->s.fIPv6Enabled)
    383301            return S_OK;
    384302
    385         m->fIPv6Enabled = aIPv6Enabled;
    386     }
    387 
    388     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    389     HRESULT rc = mVirtualBox->i_saveSettings();
     303        m->s.fIPv6Enabled = RT_BOOL(aIPv6Enabled);
     304    }
     305
     306    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     307    HRESULT rc = m->pVirtualBox->i_saveSettings();
    390308    ComAssertComRCRetRC(rc);
    391309
    … …  
    398316    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    399317
    400     aIPv6Prefix = m->IPv6Prefix;
     318    aIPv6Prefix = m->s.strIPv6Prefix;
    401319    return S_OK;
    402320}
    … …  
    407325        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    408326
    409         if (aIPv6Prefix == m->IPv6Prefix)
     327        if (aIPv6Prefix == m->s.strIPv6Prefix)
    410328            return S_OK;
    411329
    … …  
    413331         * todo: see similar todo in NATNetwork::COMSETTER(Network)(IN_BSTR)
    414332         */
    415         if (!m->mapName2PortForwardRule6.empty())
     333        if (!m->s.mapPortForwardRules6.empty())
    416334            return S_OK;
    417335
    418         unconst(m->IPv6Prefix) = Bstr(aIPv6Prefix);
    419     }
    420 
    421     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    422     HRESULT rc = mVirtualBox->i_saveSettings();
     336        m->s.strIPv6Prefix = aIPv6Prefix;
     337    }
     338
     339    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     340    HRESULT rc = m->pVirtualBox->i_saveSettings();
    423341    ComAssertComRCRetRC(rc);
    424342
    … …  
    429347HRESULT NATNetwork::getAdvertiseDefaultIPv6RouteEnabled(BOOL *aAdvertiseDefaultIPv6Route)
    430348{
    431     *aAdvertiseDefaultIPv6Route = m->fAdvertiseDefaultIPv6Route;
     349    *aAdvertiseDefaultIPv6Route = m->s.fAdvertiseDefaultIPv6Route;
    432350
    433351    return S_OK;
    … …  
    440358        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    441359
    442         if (aAdvertiseDefaultIPv6Route == m->fAdvertiseDefaultIPv6Route)
     360        if (RT_BOOL(aAdvertiseDefaultIPv6Route) == m->s.fAdvertiseDefaultIPv6Route)
    443361            return S_OK;
    444362
    445         m->fAdvertiseDefaultIPv6Route = aAdvertiseDefaultIPv6Route;
    446 
    447     }
    448 
    449     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    450     HRESULT rc = mVirtualBox->i_saveSettings();
     363        m->s.fAdvertiseDefaultIPv6Route = RT_BOOL(aAdvertiseDefaultIPv6Route);
     364
     365    }
     366
     367    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     368    HRESULT rc = m->pVirtualBox->i_saveSettings();
    451369    ComAssertComRCRetRC(rc);
    452370
    … …  
    457375HRESULT NATNetwork::getNeedDhcpServer(BOOL *aNeedDhcpServer)
    458376{
    459     *aNeedDhcpServer = m->fNeedDhcpServer;
     377    *aNeedDhcpServer = m->s.fNeedDhcpServer;
    460378
    461379    return S_OK;
    … …  
    467385        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    468386
    469         if (aNeedDhcpServer == m->fNeedDhcpServer)
     387        if (RT_BOOL(aNeedDhcpServer) == m->s.fNeedDhcpServer)
    470388            return S_OK;
    471389
    472         m->fNeedDhcpServer = aNeedDhcpServer;
     390        m->s.fNeedDhcpServer = RT_BOOL(aNeedDhcpServer);
    473391
    474392        i_recalculateIpv4AddressAssignments();
    … …  
    476394    }
    477395
    478     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    479     HRESULT rc = mVirtualBox->i_saveSettings();
     396    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     397    HRESULT rc = m->pVirtualBox->i_saveSettings();
    480398    ComAssertComRCRetRC(rc);
    481399
    … …  
    487405    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    488406
    489     aLocalMappings.resize(m->maNATLoopbackOffsetList.size());
     407    aLocalMappings.resize(m->s.llHostLoopbackOffsetList.size());
    490408    size_t i = 0;
    491     for (settings::NATLoopbackOffsetList::const_iterator it = m->maNATLoopbackOffsetList.begin();
    492          it != m->maNATLoopbackOffsetList.end(); ++it, ++i)
     409    for (settings::NATLoopbackOffsetList::const_iterator it = m->s.llHostLoopbackOffsetList.begin();
     410         it != m->s.llHostLoopbackOffsetList.end(); ++it, ++i)
    493411    {
    494412        aLocalMappings[i] = Utf8StrFmt("%s=%d",
    … …  
    513431
    514432    /* check against networkid vs network mask */
    515     rc = RTCidrStrToIPv4(Utf8Str(m->IPv4NetworkCidr).c_str(), &net, &mask);
     433    rc = RTCidrStrToIPv4(Utf8Str(m->s.strIPv4NetworkCidr).c_str(), &net, &mask);
    516434    if (RT_FAILURE(rc))
    517435        return E_INVALIDARG;
    … …  
    522440    settings::NATLoopbackOffsetList::iterator it;
    523441
    524     it = std::find(m->maNATLoopbackOffsetList.begin(),
    525                    m->maNATLoopbackOffsetList.end(),
     442    it = std::find(m->s.llHostLoopbackOffsetList.begin(),
     443                   m->s.llHostLoopbackOffsetList.end(),
    526444                   aHostId);
    527     if (it != m->maNATLoopbackOffsetList.end())
     445    if (it != m->s.llHostLoopbackOffsetList.end())
    528446    {
    529447        if (aOffset == 0) /* erase */
    530             m->maNATLoopbackOffsetList.erase(it, it);
     448            m->s.llHostLoopbackOffsetList.erase(it, it);
    531449        else /* modify */
    532450        {
    533451            settings::NATLoopbackOffsetList::iterator it1;
    534             it1 = std::find(m->maNATLoopbackOffsetList.begin(),
    535                            m->maNATLoopbackOffsetList.end(),
    536                            (uint32_t)aOffset);
    537             if (it1 != m->maNATLoopbackOffsetList.end())
     452            it1 = std::find(m->s.llHostLoopbackOffsetList.begin(),
     453                            m->s.llHostLoopbackOffsetList.end(),
     454                            (uint32_t)aOffset);
     455            if (it1 != m->s.llHostLoopbackOffsetList.end())
    538456                return E_INVALIDARG; /* this offset is already registered. */
    539457
    … …  
    541459        }
    542460
    543         AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    544         return mVirtualBox->i_saveSettings();
     461        AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     462        return m->pVirtualBox->i_saveSettings();
    545463    }
    546464
    547465    /* injection */
    548     it = std::find(m->maNATLoopbackOffsetList.begin(),
    549                    m->maNATLoopbackOffsetList.end(),
     466    it = std::find(m->s.llHostLoopbackOffsetList.begin(),
     467                   m->s.llHostLoopbackOffsetList.end(),
    550468                   (uint32_t)aOffset);
    551469
    552     if (it != m->maNATLoopbackOffsetList.end())
     470    if (it != m->s.llHostLoopbackOffsetList.end())
    553471        return E_INVALIDARG; /* offset is already registered. */
    554472
    … …  
    556474    off.strLoopbackHostAddress = aHostId;
    557475    off.u32Offset = (uint32_t)aOffset;
    558     m->maNATLoopbackOffsetList.push_back(off);
    559 
    560     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    561     return mVirtualBox->i_saveSettings();
     476    m->s.llHostLoopbackOffsetList.push_back(off);
     477
     478    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     479    return m->pVirtualBox->i_saveSettings();
    562480}
    563481
    … …  
    567485    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    568486
    569     *aLoopbackIp6 = m->u32LoopbackIp6;
     487    *aLoopbackIp6 = m->s.u32HostLoopback6Offset;
    570488    return S_OK;
    571489}
    … …  
    580498            return E_INVALIDARG;
    581499
    582         if (static_cast<uint32_t>(aLoopbackIp6) == m->u32LoopbackIp6)
     500        if (static_cast<uint32_t>(aLoopbackIp6) == m->s.u32HostLoopback6Offset)
    583501            return S_OK;
    584502
    585         m->u32LoopbackIp6 = aLoopbackIp6;
    586     }
    587 
    588     AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    589     return mVirtualBox->i_saveSettings();
     503        m->s.u32HostLoopback6Offset = aLoopbackIp6;
     504    }
     505
     506    AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     507    return m->pVirtualBox->i_saveSettings();
    590508}
    591509
    … …  
    595513    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    596514    i_getPortForwardRulesFromMap(aPortForwardRules4,
    597                                  m->mapName2PortForwardRule4);
     515                                 m->s.mapPortForwardRules4);
    598516    return S_OK;
    599517}
    … …  
    603521    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    604522    i_getPortForwardRulesFromMap(aPortForwardRules6,
    605                                  m->mapName2PortForwardRule6);
     523                                 m->s.mapPortForwardRules6);
    606524    return S_OK;
    607525}
    … …  
    620538        Utf8Str proto;
    621539        settings::NATRule r;
    622         NATRuleMap& mapRules = aIsIpv6 ? m->mapName2PortForwardRule6 : m->mapName2PortForwardRule4;
     540        settings::NATRulesMap &mapRules = aIsIpv6 ? m->s.mapPortForwardRules6 : m->s.mapPortForwardRules4;
    623541        switch (aProto)
    624542        {
    … …  
    637555                              aGuestIp.c_str(), aGuestPort);
    638556
    639         for (NATRuleMap::iterator it = mapRules.begin(); it != mapRules.end(); ++it)
     557        for (settings::NATRulesMap::iterator it = mapRules.begin(); it != mapRules.end(); ++it)
    640558        {
    641559            r = it->second;
    … …  
    659577    }
    660578    {
    661         AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    662         HRESULT rc = mVirtualBox->i_saveSettings();
     579        AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     580        HRESULT rc = m->pVirtualBox->i_saveSettings();
    663581        ComAssertComRCRetRC(rc);
    664582    }
    665583
    666     mVirtualBox->i_onNATNetworkPortForward(Bstr(mName).raw(), TRUE, aIsIpv6,
    667                                            Bstr(aPortForwardRuleName).raw(), aProto,
    668                                            Bstr(aHostIp).raw(), aHostPort,
    669                                            Bstr(aGuestIp).raw(), aGuestPort);
     584    m->pVirtualBox->i_onNATNetworkPortForward(Bstr(m->s.strNetworkName).raw(), TRUE, aIsIpv6,
     585                                              Bstr(aPortForwardRuleName).raw(), aProto,
     586                                              Bstr(aHostIp).raw(), aHostPort,
     587                                              Bstr(aGuestIp).raw(), aGuestPort);
    670588
    671589    /* Notify listerners listening on this network only */
    672     fireNATNetworkPortForwardEvent(m->pEventSource, Bstr(mName).raw(), TRUE,
     590    fireNATNetworkPortForwardEvent(m->pEventSource, Bstr(m->s.strNetworkName).raw(), TRUE,
    673591                                   aIsIpv6, Bstr(aPortForwardRuleName).raw(), aProto,
    674592                                   Bstr(aHostIp).raw(), aHostPort,
    … …  
    688606    {
    689607        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    690         NATRuleMap& mapRules = aIsIpv6 ? m->mapName2PortForwardRule6 : m->mapName2PortForwardRule4;
    691         NATRuleMap::iterator it = mapRules.find(aPortForwardRuleName);
     608        settings::NATRulesMap &mapRules = aIsIpv6 ? m->s.mapPortForwardRules6 : m->s.mapPortForwardRules4;
     609        settings::NATRulesMap::iterator it = mapRules.find(aPortForwardRuleName);
    692610
    693611        if (it == mapRules.end())
    … …  
    704622
    705623    {
    706         AutoWriteLock vboxLock(mVirtualBox COMMA_LOCKVAL_SRC_POS);
    707         HRESULT rc = mVirtualBox->i_saveSettings();
     624        AutoWriteLock vboxLock(m->pVirtualBox COMMA_LOCKVAL_SRC_POS);
     625        HRESULT rc = m->pVirtualBox->i_saveSettings();
    708626        ComAssertComRCRetRC(rc);
    709627    }
    710628
    711     mVirtualBox->i_onNATNetworkPortForward(Bstr(mName).raw(), FALSE, aIsIpv6,
    712                                            Bstr(aPortForwardRuleName).raw(), proto,
    713                                            Bstr(strHostIP).raw(), u16HostPort,
    714                                            Bstr(strGuestIP).raw(), u16GuestPort);
     629    m->pVirtualBox->i_onNATNetworkPortForward(Bstr(m->s.strNetworkName).raw(), FALSE, aIsIpv6,
     630                                              Bstr(aPortForwardRuleName).raw(), proto,
     631                                              Bstr(strHostIP).raw(), u16HostPort,
     632                                              Bstr(strGuestIP).raw(), u16GuestPort);
    715633
    716634    /* Notify listerners listening on this network only */
    717     fireNATNetworkPortForwardEvent(m->pEventSource, Bstr(mName).raw(), FALSE,
     635    fireNATNetworkPortForwardEvent(m->pEventSource, Bstr(m->s.strNetworkName).raw(), FALSE,
    718636                                   aIsIpv6, Bstr(aPortForwardRuleName).raw(), proto,
    719637                                   Bstr(strHostIP).raw(), u16HostPort,
    … …  
    726644{
    727645#ifdef VBOX_WITH_NAT_SERVICE
    728     if (!m->fEnabled) return S_OK;
    729 
    730     m->NATRunner.setOption(NetworkServiceRunner::kNsrKeyNetwork, Utf8Str(mName).c_str());
     646    if (!m->s.fEnabled) return S_OK;
     647
     648    m->NATRunner.setOption(NetworkServiceRunner::kNsrKeyNetwork, Utf8Str(m->s.strNetworkName).c_str());
    731649    m->NATRunner.setOption(NetworkServiceRunner::kNsrKeyTrunkType, Utf8Str(aTrunkType).c_str());
    732650    m->NATRunner.setOption(NetworkServiceRunner::kNsrIpAddress, Utf8Str(m->IPv4Gateway).c_str());
    … …  
    735653    /* No portforwarding rules from command-line, all will be fetched via API */
    736654
    737     if (m->fNeedDhcpServer)
     655    if (m->s.fNeedDhcpServer)
    738656    {
    739657        /*
    … …  
    751669         * 6. start dhcp server.
    752670         */
    753         HRESULT hrc = mVirtualBox->FindDHCPServerByNetworkName(Bstr(mName).raw(),
    754                                                                m->dhcpServer.asOutParam());
     671        HRESULT hrc = m->pVirtualBox->FindDHCPServerByNetworkName(Bstr(m->s.strNetworkName).raw(),
     672                                                                  m->dhcpServer.asOutParam());
    755673        switch (hrc)
    756674        {
    757675            case E_INVALIDARG:
    758676                /* server haven't beeen found let create it then */
    759                 hrc = mVirtualBox->CreateDHCPServer(Bstr(mName).raw(),
    760                                                    m->dhcpServer.asOutParam());
     677                hrc = m->pVirtualBox->CreateDHCPServer(Bstr(m->s.strNetworkName).raw(),
     678                                                       m->dhcpServer.asOutParam());
    761679                if (FAILED(hrc))
    762680                  return E_FAIL;
    … …  
    796714        m->dhcpServer->AddGlobalOption(DhcpOpt_Router, Bstr(m->IPv4Gateway).raw());
    797715
    798         hrc = m->dhcpServer->Start(Bstr(mName).raw(), Bstr("").raw(), Bstr(aTrunkType).raw());
     716        hrc = m->dhcpServer->Start(Bstr(m->s.strNetworkName).raw(), Bstr("").raw(), Bstr(aTrunkType).raw());
    799717        if (FAILED(hrc))
    800718        {
    … …  
    806724    if (RT_SUCCESS(m->NATRunner.start(false /* KillProcOnStop */)))
    807725    {
    808         mVirtualBox->i_onNATNetworkStartStop(Bstr(mName).raw(), TRUE);
     726        m->pVirtualBox->i_onNATNetworkStartStop(Bstr(m->s.strNetworkName).raw(), TRUE);
    809727        return S_OK;
    810728    }
    … …  
    820738{
    821739#ifdef VBOX_WITH_NAT_SERVICE
    822     mVirtualBox->i_onNATNetworkStartStop(Bstr(mName).raw(), FALSE);
     740    m->pVirtualBox->i_onNATNetworkStartStop(Bstr(m->s.strNetworkName).raw(), FALSE);
    823741
    824742    if (!m->dhcpServer.isNull())
    … …  
    836754
    837755
    838 void NATNetwork::i_getPortForwardRulesFromMap(std::vector<com::Utf8Str> &aPortForwardRules, NATRuleMap& aRules)
     756void NATNetwork::i_getPortForwardRulesFromMap(std::vector<com::Utf8Str> &aPortForwardRules, settings::NATRulesMap &aRules)
    839757{
    840758    aPortForwardRules.resize(aRules.size());
    841759    size_t i = 0;
    842     for (NATRuleMap::const_iterator it = aRules.begin();
     760    for (settings::NATRulesMap::const_iterator it = aRules.begin();
    843761         it != aRules.end(); ++it, ++i)
    844       {
     762    {
    845763        settings::NATRule r = it->second;
    846764        aPortForwardRules[i] =  Utf8StrFmt("%s:%s:[%s]:%d:[%s]:%d",
    847765                                           r.strName.c_str(),
    848                                            (r.proto == NATProtocol_TCP? "tcp" : "udp"),
     766                                           (r.proto == NATProtocol_TCP ? "tcp" : "udp"),
    849767                                           r.strHostIP.c_str(),
    850768                                           r.u16HostPort,
    … …  
    859777    RTNETADDRIPV4 network, netmask;
    860778
    861     int rc = RTCidrStrToIPv4(m->IPv4NetworkCidr.c_str(),
     779    int rc = RTCidrStrToIPv4(m->s.strIPv4NetworkCidr.c_str(),
    862780                             &network,
    863781                             &netmask);
    … …  
    868786    {
    869787        bool skip = false;
    870         for (settings::NATLoopbackOffsetList::iterator it = m->maNATLoopbackOffsetList.begin();
    871              it != m->maNATLoopbackOffsetList.end();
     788        for (settings::NATLoopbackOffsetList::iterator it = m->s.llHostLoopbackOffsetList.begin();
     789             it != m->s.llHostLoopbackOffsetList.end();
    872790             ++it)
    873791        {
    … …  
    912830{
    913831    RTNETADDRIPV4 network, netmask;
    914     int rc = RTCidrStrToIPv4(m->IPv4NetworkCidr.c_str(),
     832    int rc = RTCidrStrToIPv4(m->s.strIPv4NetworkCidr.c_str(),
    915833                             &network,
    916834                             &netmask);
    … …  
    918836
    919837    i_findFirstAvailableOffset(ADDR_GATEWAY, &m->offGateway);
    920     if (m->fNeedDhcpServer)
     838    if (m->s.fNeedDhcpServer)
    921839        i_findFirstAvailableOffset(ADDR_DHCP, &m->offDhcp);
    922840
    … …  
    929847    m->IPv4Gateway = szTmpIp;
    930848
    931     if (m->fNeedDhcpServer)
     849    if (m->s.fNeedDhcpServer)
    932850    {
    933851        RTNETADDRIPV4 dhcpserver = network;
    … …  
    972890
    973891    RTNETADDRIPV4 net, mask;
    974     rc = RTCidrStrToIPv4(Utf8Str(m->IPv4NetworkCidr).c_str(), &net, &mask);
     892    rc = RTCidrStrToIPv4(Utf8Str(m->s.strIPv4NetworkCidr).c_str(), &net, &mask);
    975893    if (RT_FAILURE(rc))
    976894        return rc;
    … …  
    1001919    RTStrPrintf(szBuf, sizeof(szBuf), "%RTnaipv6/64", &prefix);
    1002920
    1003     m->IPv6Prefix = szBuf;
     921    m->s.strIPv6Prefix = szBuf;
    1004922    return VINF_SUCCESS;
    1005923}

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

    r60763 r60786  
    522522            rc = pNATNetwork.createObject();
    523523            AssertComRCThrowRC(rc);
    524             rc = pNATNetwork->init(this, net);
     524            rc = pNATNetwork->init(this, "");
     525            AssertComRCThrowRC(rc);
     526            rc = pNATNetwork->i_loadSettings(net);
    525527            AssertComRCThrowRC(rc);
    526528            rc = i_registerNATNetwork(pNATNetwork, false /* aSaveRegistry */);

  • trunk/src/VBox/Main/xml/Settings.cpp

    r60410 r60786  
    5555
    5656/*
    57  * Copyright (C) 2007-2015 Oracle Corporation
     57 * Copyright (C) 2007-2016 Oracle Corporation
    5858 *
    5959 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    868868 * declaration in ovmfreader.h.
    869869 */
    870 void ConfigFileBase::readNATForwardRuleList(const xml::ElementNode &elmParent, NATRuleList &llRules)
     870void ConfigFileBase::readNATForwardRulesMap(const xml::ElementNode &elmParent, NATRulesMap &mapRules)
    871871{
    872872    xml::ElementNodesList plstRules;
    … …  
    884884        (*pf)->getAttributeValue("guestport", port);
    885885        rule.u16GuestPort = port;
    886         llRules.push_back(rule);
     886        mapRules.insert(std::make_pair(rule.strName, rule));
    887887    }
    888888}
    … …  
    12631263 * because this method used for serializing per-_mahine's_adapter_ and per-network approaches.
    12641264 */
    1265 void ConfigFileBase::buildNATForwardRuleList(xml::ElementNode &elmParent, const NATRuleList &natRuleList)
    1266 {
    1267     for (NATRuleList::const_iterator r = natRuleList.begin();
    1268          r != natRuleList.end(); ++r)
     1265void ConfigFileBase::buildNATForwardRulesMap(xml::ElementNode &elmParent, const NATRulesMap &mapRules)
     1266{
     1267    for (NATRulesMap::const_iterator r = mapRules.begin();
     1268         r != mapRules.end(); ++r)
    12691269    {
    12701270        xml::ElementNode *pelmPF;
    12711271        pelmPF = elmParent.createChild("Forwarding");
    1272         if ((*r).strName.length())
    1273             pelmPF->setAttribute("name", (*r).strName);
    1274         pelmPF->setAttribute("proto", (*r).proto);
    1275         if ((*r).strHostIP.length())
    1276             pelmPF->setAttribute("hostip", (*r).strHostIP);
    1277         if ((*r).u16HostPort)
    1278             pelmPF->setAttribute("hostport", (*r).u16HostPort);
    1279         if ((*r).strGuestIP.length())
    1280             pelmPF->setAttribute("guestip", (*r).strGuestIP);
    1281         if ((*r).u16GuestPort)
    1282             pelmPF->setAttribute("guestport", (*r).u16GuestPort);
     1272        const NATRule &nr = r->second;
     1273        if (nr.strName.length())
     1274            pelmPF->setAttribute("name", nr.strName);
     1275        pelmPF->setAttribute("proto", nr.proto);
     1276        if (nr.strHostIP.length())
     1277            pelmPF->setAttribute("hostip", nr.strHostIP);
     1278        if (nr.u16HostPort)
     1279            pelmPF->setAttribute("hostport", nr.u16HostPort);
     1280        if (nr.strGuestIP.length())
     1281            pelmPF->setAttribute("guestip", nr.strGuestIP);
     1282        if (nr.u16GuestPort)
     1283            pelmPF->setAttribute("guestport", nr.u16GuestPort);
    12831284    }
    12841285}
    … …  
    14761477            if (   pelmNet->getAttributeValue("networkName", net.strNetworkName)
    14771478                && pelmNet->getAttributeValue("enabled", net.fEnabled)
    1478                 && pelmNet->getAttributeValue("network", net.strNetwork)
    1479                 && pelmNet->getAttributeValue("ipv6", net.fIPv6)
     1479                && pelmNet->getAttributeValue("network", net.strIPv4NetworkCidr)
     1480                && pelmNet->getAttributeValue("ipv6", net.fIPv6Enabled)
    14801481                && pelmNet->getAttributeValue("ipv6prefix", net.strIPv6Prefix)
    14811482                && pelmNet->getAttributeValue("advertiseDefaultIPv6Route", net.fAdvertiseDefaultIPv6Route)
    … …  
    14891490                const xml::ElementNode *pelmPortForwardRules4;
    14901491                if ((pelmPortForwardRules4 = pelmNet->findChildElement("PortForwarding4")))
    1491                     readNATForwardRuleList(*pelmPortForwardRules4,
    1492                                            net.llPortForwardRules4);
     1492                    readNATForwardRulesMap(*pelmPortForwardRules4,
     1493                                           net.mapPortForwardRules4);
    14931494
    14941495                const xml::ElementNode *pelmPortForwardRules6;
    14951496                if ((pelmPortForwardRules6 = pelmNet->findChildElement("PortForwarding6")))
    1496                     readNATForwardRuleList(*pelmPortForwardRules6,
    1497                                            net.llPortForwardRules6);
     1497                    readNATForwardRulesMap(*pelmPortForwardRules6,
     1498                                           net.mapPortForwardRules6);
    14981499
    14991500                llNATNetworks.push_back(net);
    … …  
    18101811            xml::ElementNode *pelmThis = pelmNATNetworks->createChild("NATNetwork");
    18111812            pelmThis->setAttribute("networkName", n.strNetworkName);
    1812             pelmThis->setAttribute("network", n.strNetwork);
    1813             pelmThis->setAttribute("ipv6", n.fIPv6 ? 1 : 0);
     1813            pelmThis->setAttribute("network", n.strIPv4NetworkCidr);
     1814            pelmThis->setAttribute("ipv6", n.fIPv6Enabled ? 1 : 0);
    18141815            pelmThis->setAttribute("ipv6prefix", n.strIPv6Prefix);
    18151816            pelmThis->setAttribute("advertiseDefaultIPv6Route", (n.fAdvertiseDefaultIPv6Route)? 1 : 0);
    18161817            pelmThis->setAttribute("needDhcp", (n.fNeedDhcpServer) ? 1 : 0);
    18171818            pelmThis->setAttribute("enabled", (n.fEnabled) ? 1 : 0);        // too bad we chose 1 vs. 0 here
    1818             if (n.llPortForwardRules4.size())
     1819            if (n.mapPortForwardRules4.size())
    18191820            {
    18201821                xml::ElementNode *pelmPf4 = pelmThis->createChild("PortForwarding4");
    1821                 buildNATForwardRuleList(*pelmPf4, n.llPortForwardRules4);
    1822             }
    1823             if (n.llPortForwardRules6.size())
     1822                buildNATForwardRulesMap(*pelmPf4, n.mapPortForwardRules4);
     1823            }
     1824            if (n.mapPortForwardRules6.size())
    18241825            {
    18251826                xml::ElementNode *pelmPf6 = pelmThis->createChild("PortForwarding6");
    1826                 buildNATForwardRuleList(*pelmPf6, n.llPortForwardRules6);
     1827                buildNATForwardRulesMap(*pelmPf6, n.mapPortForwardRules6);
    18271828            }
    18281829
    … …  
    25472548        }
    25482549
    2549         readNATForwardRuleList(elmMode, nic.nat.llRules);
     2550        readNATForwardRulesMap(elmMode, nic.nat.mapRules);
    25502551    }
    25512552    else if (   elmMode.nameEquals("HostInterface")
    … …  
    51035104                    pelmTFTP->setAttribute("next-server", nic.nat.strTFTPNextServer);
    51045105            }
    5105             buildNATForwardRuleList(*pelmNAT, nic.nat.llRules);
     5106            buildNATForwardRulesMap(*pelmNAT, nic.nat.mapRules);
    51065107            break;
    51075108
    … …  
    61636164                          || netit->nat.strTFTPBootFile.length()
    61646165                          || netit->nat.strTFTPNextServer.length()
    6165                           || netit->nat.llRules.size()
     6166                          || netit->nat.mapRules.size()
    61666167                         )
    61676168                     )
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