Changeset 49327 in vbox for trunk

Timestamp:

Oct 30, 2013 4:45:35 AM (11 years ago)

Author:

vboxsync

Message:

NetworkService/DHCP: refactoring:

1. Client and Lease are use shared data.
2. data moved to closer to implementations and accessible via accessors.

Location:

trunk/src/VBox/NetworkServices/DHCP

Files:

• Config.cpp (modified) (46 diffs)
• Config.h (modified) (19 diffs)
• VBoxNetDHCP.cpp (modified) (5 diffs)

trunk/src/VBox/NetworkServices/DHCP/Config.cpp

@@ -15 +15 @@
 #include <VBox/version.h>
 
+#include <VBox/com/string.h>
+
+#include <iprt/cpp/xml.h>
+
 #include "../NetLib/VBoxNetLib.h"
+#include "../NetLib/shared_ptr.h"
 
 #include <list>
@@ -25 +30 @@
 
 /* types */
-class Lease::Data
+class ClientData
 {
 public:
-    Data()
+    ClientData()
     {
         m_address.u = 0;
-        m_client = NULL;
+        m_network.u = 0;
+        fHasLease = false;
+        fHasClient = false;
         fBinding = true;
         u64TimestampBindingStarted = 0;
@@ -40 +47 @@
 
     }
-    ~Data(){}
+    ~ClientData(){}
     
+    /* client information */
     RTNETADDRIPV4 m_address;
-
+    RTNETADDRIPV4 m_network;
+    RTMAC m_mac;
+    
+    bool fHasClient;
+
+    /* Lease part */
+    bool fHasLease; 
     /** lease isn't commited */
     bool fBinding;
@@ -57 +71 @@
     uint32_t u32BindExpirationPeriod;
 
+    MapOptionId2RawOption options;
+
     NetworkConfigEntity *pCfg;
-    Client *m_client;
 };
 
 
+bool operator== (const Lease& lhs, const Lease& rhs)
+{
+    return (lhs.m.get() == rhs.m.get());
+}
+
+
+bool operator!= (const Lease& lhs, const Lease& rhs)
+{
+    return !(lhs == rhs);
+}
+
+
+bool operator< (const Lease& lhs, const Lease& rhs)
+{
+    return (   (lhs.getAddress() < rhs.getAddress())
+            || (lhs.issued() < rhs.issued()));
+}
 /* consts */
 
@@ -74 +106 @@
 int BaseConfigEntity::match(Client& client, BaseConfigEntity **cfg)
 {
-        int iMatch = (m_criteria && m_criteria->check(client)? m_MatchLevel: 0);
-        if (m_children.empty())
+    int iMatch = (m_criteria && m_criteria->check(client)? m_MatchLevel: 0);
+    if (m_children.empty())
+    {
+        if (iMatch > 0)
         {
-            if (iMatch > 0)
+            *cfg = this;
+            return iMatch;
+        }
+    }
+    else
+    {
+        *cfg = this;
+        /* XXX: hack */
+        BaseConfigEntity *matching = this;
+        int matchingLevel = m_MatchLevel;
+
+        for (std::vector<BaseConfigEntity *>::iterator it = m_children.begin();
+             it != m_children.end();
+             ++it)
+        {
+            iMatch = (*it)->match(client, &matching);
+            if (iMatch > matchingLevel)
             {
-                *cfg = this;
-                return iMatch;
+                *cfg = matching;
+                matchingLevel = iMatch;
             }
         }
-        else
-        {
-            *cfg = this;
-            /* XXX: hack */
-            BaseConfigEntity *matching = this;
-            int matchingLevel = m_MatchLevel;
-
-            for (std::vector<BaseConfigEntity *>::iterator it = m_children.begin();
-                 it != m_children.end();
-                 ++it)
-            {
-                iMatch = (*it)->match(client, &matching);
-                if (iMatch > matchingLevel)
-                {
-                    *cfg = matching;
-                    matchingLevel = iMatch;
-                }
-            }
-            return matchingLevel;
-        }
-        return iMatch;
+        return matchingLevel;
+    }
+    return iMatch;
 }
 
 /* Client */
-
-Client::Client(const RTMAC& mac)
-{
-    m_mac = mac;
-    m_lease = NULL;
-}
-
 /* Configs
     NetworkConfigEntity(std::string name,
@@ -130 +155 @@
 }
 
-
 /* Configuration Manager */
+struct ConfigurationManager::Data
+{
+    Data():fFileExists(false){}
+
+    MapLease2Ip4Address  m_allocations;
+    Ipv4AddressContainer m_nameservers;
+    Ipv4AddressContainer m_routers;
+
+    std::string          m_domainName;
+    VecClient            m_clients;
+    
+    bool                 fFileExists;
+};
+    
 ConfigurationManager *ConfigurationManager::getConfigurationManager()
 {
     if (!g_ConfigurationManager)
+    {
         g_ConfigurationManager = new ConfigurationManager();
+        g_ConfigurationManager->init();
+    }
 
     return g_ConfigurationManager;
@@ -147 +188 @@
 
 
-Client *ConfigurationManager::getClientByDhcpPacket(const RTNETBOOTP *pDhcpMsg, size_t cbDhcpMsg)
+Client ConfigurationManager::getClientByDhcpPacket(const RTNETBOOTP *pDhcpMsg, size_t cbDhcpMsg)
 {
 
@@ -155 +196 @@
 
     fDhcpValid = RTNetIPv4IsDHCPValid(NULL, pDhcpMsg, cbDhcpMsg, &uMsgType);
-    AssertReturn(fDhcpValid, NULL);
+    AssertReturn(fDhcpValid, Client::NullClient);
 
     LogFlowFunc(("dhcp:mac:%RTmac\n", &pDhcpMsg->bp_chaddr.Mac));
     /* 1st. client IDs */
-    for ( it = m_clients.begin();
-         it != m_clients.end();
+    for ( it = m->m_clients.begin();
+         it != m->m_clients.end();
          ++it)
     {
-        if (*(*it) == pDhcpMsg->bp_chaddr.Mac)
+        if ((*it) == pDhcpMsg->bp_chaddr.Mac)
         {
-            LogFlowFunc(("client:mac:%RTmac\n",  &(*it)->m_mac));
+            LogFlowFunc(("client:mac:%RTmac\n",  it->getMacAddress()));
             /* check timestamp that request wasn't expired. */
             return (*it);
@@ -171 +212 @@
     }
 
-    if (it == m_clients.end())
+    if (it == m->m_clients.end())
     {
         /* We hasn't got any session for this client */
-        m_clients.push_back(new Client(pDhcpMsg->bp_chaddr.Mac));
-        return m_clients.back();
-    }
-
-    return NULL;
+        Client c;
+        c.initWithMac(pDhcpMsg->bp_chaddr.Mac);
+        m->m_clients.push_back(c);
+        return m->m_clients.back();
+    }
+
+    return Client::NullClient;
 }
 
@@ -253 +296 @@
  * We bind lease for client till it continue with it on DHCPREQUEST.
  */
-Lease *ConfigurationManager::allocateLease4Client(Client *client, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg)
-{
-    /**
-     * Well, session hasn't get the config.
-     */
-    AssertPtrReturn(client, NULL);
-
-    /**
-     * This mean that client has already bound or commited lease.
-     * If we've it happens it means that we received DHCPDISCOVER twice.
-     */
-    if (client->m_lease)
-    {
-        if (client->m_lease->isExpired())
-            expireLease4Client(client);
-        else
+Lease ConfigurationManager::allocateLease4Client(const Client& client, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg)
+{
+    {
+        /**
+         * This mean that client has already bound or commited lease.
+         * If we've it happens it means that we received DHCPDISCOVER twice.
+         */
+        const Lease l = client.lease();
+        if (l != Lease::NullLease)
         {
-            AssertReturn(client->m_lease->getAddress().u != 0,NULL);
-            return client->m_lease;
+            /* Here we should take lease from the m_allocation which was feed with leases 
+             *  on start
+             */
+            if (l.isExpired())
+            {
+                expireLease4Client(const_cast<Client&>(client));
+                if (!l.isExpired())
+                    return l;
+            }
+            else
+            {
+                AssertReturn(l.getAddress().u != 0, Lease::NullLease);
+                return l;
+            }
         }
     }
@@ -277 +325 @@
     RTNETADDRIPV4 hintAddress;
     RawOption opt;
-    Lease *please = NULL;
-
     NetworkConfigEntity *pNetCfg;
 
-    AssertReturn(g_RootConfig->match(*client, (BaseConfigEntity **)&pNetCfg) > 0, NULL);
+    Client cl(client);
+    AssertReturn(g_RootConfig->match(cl, (BaseConfigEntity **)&pNetCfg) > 0, Lease::NullLease);
 
     /* DHCPDISCOVER MAY contain request address */
@@ -295 +342 @@
 
     if (   hintAddress.u
-        && !isAddressTaken(hintAddress, NULL))
-    {
-        please = new Lease();
-        please->init();
-        please->setConfig(pNetCfg);
-        please->setClient(client);
-        client->m_lease = please;
-        client->m_lease->setAddress(hintAddress);
-        m_allocations[please] = hintAddress;
-        return please;
+        && !isAddressTaken(hintAddress))
+    {
+        Lease l(cl);
+        l.setConfig(pNetCfg);
+        l.setAddress(hintAddress);
+        m->m_allocations.insert(MapLease2Ip4AddressPair(l, hintAddress));
+        return l;
     }
 
@@ -314 +358 @@
         RTNETADDRIPV4 address;
         address.u = RT_H2N_U32(u32);
-        if (!isAddressTaken(address, NULL))
+        if (!isAddressTaken(address))
         {
-            please = new Lease();
-            please->init();
-            please->setConfig(pNetCfg);
-            please->setClient(client);
-            please->setAddress(address);
-
-            client->m_lease = please;
-
-            m_allocations[please] = address;
-            return please;
+            Lease l(cl);
+            l.setConfig(pNetCfg);
+            l.setAddress(address);
+            m->m_allocations.insert(MapLease2Ip4AddressPair(l, address));
+            return l;
         }
     }
 
-    return NULL;
-}
-
-
-int ConfigurationManager::commitLease4Client(Client *client)
-{
-    client->m_lease->bindingPhase(false);
-
-    client->m_lease->setExpiration(client->m_lease->getConfig()->expirationPeriod());
-    client->m_lease->phaseStart(RTTimeMilliTS());
+    return Lease::NullLease;
+}
+
+
+int ConfigurationManager::commitLease4Client(Client& client)
+{
+    Lease l = client.lease();
+    AssertReturn(l != Lease::NullLease, VERR_INTERNAL_ERROR);
+
+    l.bindingPhase(false);
+    const NetworkConfigEntity *pCfg = l.getConfig();
+
+    AssertPtr(pCfg);
+    l.setExpiration(pCfg->expirationPeriod());
+    l.phaseStart(RTTimeMilliTS());
 
     return VINF_SUCCESS;
 }
 
-int ConfigurationManager::expireLease4Client(Client *client)
-{
-    MapLease2Ip4AddressIterator it = m_allocations.find(client->m_lease);
-    AssertReturn(it != m_allocations.end(), VERR_NOT_FOUND);
-
-    m_allocations.erase(it);
-
-    delete client->m_lease;
-    client->m_lease = NULL;
-
+int ConfigurationManager::expireLease4Client(Client& client)
+{
+    Lease l = client.lease();
+    AssertReturn(l != Lease::NullLease, VERR_INTERNAL_ERROR);
+    
+    if (l.isInBindingPhase())
+    {
+
+        MapLease2Ip4AddressIterator it = m->m_allocations.find(l);
+        AssertReturn(it != m->m_allocations.end(), VERR_NOT_FOUND);
+
+        /*
+         * XXX: perhaps it better to keep this allocation ????
+         */
+        m->m_allocations.erase(it);
+
+        l.expire();
+        return VINF_SUCCESS;
+    }
+    
+    l = Lease(client); /* re-new */
     return VINF_SUCCESS;
 }
 
-bool ConfigurationManager::isAddressTaken(const RTNETADDRIPV4& addr, Lease** ppLease)
+bool ConfigurationManager::isAddressTaken(const RTNETADDRIPV4& addr, Lease& lease)
 {
     MapLease2Ip4AddressIterator it;
 
-    for (it = m_allocations.begin();
-         it != m_allocations.end();
+    for (it = m->m_allocations.begin();
+         it != m->m_allocations.end();
          ++it)
     {
         if (it->second.u == addr.u)
         {
-            if (ppLease)
-                *ppLease = it->first;
+            if (lease != Lease::NullLease)
+                lease = it->first;
 
             return true;
         }
     }
+    lease = Lease::NullLease;
     return false;
 }
+
 
 NetworkConfigEntity *ConfigurationManager::addNetwork(NetworkConfigEntity *,
@@ -424 +481 @@
     {
         case RTNET_DHCP_OPT_DNS:
-            m_nameservers.push_back(address);
+            m->m_nameservers.push_back(address);
             break;
         case RTNET_DHCP_OPT_ROUTERS:
-            m_routers.push_back(address);
+            m->m_routers.push_back(address);
             break;
         default:
@@ -435 +492 @@
 }
 
+
 int ConfigurationManager::flushAddressList(uint8_t u8OptId)
 {
@@ -440 +498 @@
     {
         case RTNET_DHCP_OPT_DNS:
-            m_nameservers.clear();
+            m->m_nameservers.clear();
             break;
         case RTNET_DHCP_OPT_ROUTERS:
-            m_routers.clear();
+            m->m_routers.clear();
             break;
         default:
@@ -451 +509 @@
 }
 
+
 const Ipv4AddressContainer& ConfigurationManager::getAddressList(uint8_t u8OptId)
 {
@@ -456 +515 @@
     {
         case RTNET_DHCP_OPT_DNS:
-            return m_nameservers;
+            return m->m_nameservers;
 
         case RTNET_DHCP_OPT_ROUTERS:
-            return m_routers;
+            return m->m_routers;
 
     }
@@ -466 +525 @@
 }
 
+
 int ConfigurationManager::setString(uint8_t u8OptId, const std::string& str)
 {
@@ -471 +531 @@
     {
         case RTNET_DHCP_OPT_DOMAIN_NAME:
-            m_domainName = str;
+            m->m_domainName = str;
             break;
         default:
@@ -480 +540 @@
 }
 
+
 const std::string& ConfigurationManager::getString(uint8_t u8OptId)
 {
@@ -485 +546 @@
     {
         case RTNET_DHCP_OPT_DOMAIN_NAME:
-            if (m_domainName.length())
-                return m_domainName;
+            if (m->m_domainName.length())
+                return m->m_domainName;
             else
                 return m_noString;
@@ -496 +557 @@
 }
 
+
+void ConfigurationManager::init()
+{
+    m = new ConfigurationManager::Data();
+}
+
+
+ConfigurationManager::~ConfigurationManager() { if (m) delete m; }
+
 /**
  * Network manager
@@ -511 +581 @@
  * Network manager creates DHCPOFFER datagramm
  */
-int NetworkManager::offer4Client(Client *client, uint32_t u32Xid,
+int NetworkManager::offer4Client(const Client& client, uint32_t u32Xid,
                                  uint8_t *pu8ReqList, int cReqList)
 {
-    AssertPtrReturn(client, VERR_INTERNAL_ERROR);
-    AssertPtrReturn(client->m_lease, VERR_INTERNAL_ERROR);
-
+    Lease l(client); /* XXX: oh, it looks badly, but now we have lease */
     prepareReplyPacket4Client(client, u32Xid);
 
-
-    RTNETADDRIPV4 address = client->m_lease->getAddress();
+    RTNETADDRIPV4 address = l.getAddress();
     BootPReplyMsg.BootPHeader.bp_yiaddr =  address;
 
@@ -534 +601 @@
     RT_ZERO(opt);
 
-    /* XXX: can't store options per session */
-    AssertPtr(client);
-
+    std::vector<RawOption> extra(2);
     opt.u8OptId = RTNET_DHCP_OPT_MSG_TYPE;
     opt.au8RawOpt[0] = RTNET_DHCP_MT_OFFER;
     opt.cbRawOpt = 1;
-    client->rawOptions.push_back(opt);
+    extra.push_back(opt);
 
     opt.u8OptId = RTNET_DHCP_OPT_LEASE_TIME;
-    *(uint32_t *)opt.au8RawOpt = RT_H2N_U32(client->m_lease->getConfig()->expirationPeriod());
+
+    const NetworkConfigEntity *pCfg = l.getConfig();
+    AssertPtr(pCfg);
+
+    *(uint32_t *)opt.au8RawOpt = RT_H2N_U32(pCfg->expirationPeriod());
     opt.cbRawOpt = sizeof(RTNETADDRIPV4);
-    client->rawOptions.push_back(opt);
+
+    extra.push_back(opt);
 
     processParameterReqList(client, pu8ReqList, cReqList);
 
-    return doReply(client);
+    return doReply(client, extra);
 }
 
@@ -556 +626 @@
  * Network manager creates DHCPACK
  */
-int NetworkManager::ack(Client *client, uint32_t u32Xid,
+int NetworkManager::ack(const Client& client, uint32_t u32Xid,
                         uint8_t *pu8ReqList, int cReqList)
 {
-    AssertPtrReturn(client, VERR_INTERNAL_ERROR);
-    AssertPtrReturn(client->m_lease, VERR_INTERNAL_ERROR);
-
     RTNETADDRIPV4 address;
 
     prepareReplyPacket4Client(client, u32Xid);
-
-    address = client->m_lease->getAddress();
+    
+    Lease l = client.lease();
+    address = l.getAddress();
     BootPReplyMsg.BootPHeader.bp_ciaddr =  address;
 
@@ -587 +655 @@
     RT_ZERO(opt);
 
+    std::vector<RawOption> extra(2);
     opt.u8OptId = RTNET_DHCP_OPT_MSG_TYPE;
     opt.au8RawOpt[0] = RTNET_DHCP_MT_ACK;
     opt.cbRawOpt = 1;
-    client->rawOptions.push_back(opt);
+    extra.push_back(opt);
 
     /*
@@ -597 +666 @@
      */
     opt.u8OptId = RTNET_DHCP_OPT_LEASE_TIME;
-    *(uint32_t *)opt.au8RawOpt = RT_H2N_U32(client->m_lease->getExpiration());
+    *(uint32_t *)opt.au8RawOpt = RT_H2N_U32(l.getExpiration());
     opt.cbRawOpt = sizeof(RTNETADDRIPV4);
-    client->rawOptions.push_back(opt);
+    extra.push_back(opt);
 
     processParameterReqList(client, pu8ReqList, cReqList);
 
-    return doReply(client);
+    return doReply(client, extra);
 }
 
@@ -610 +679 @@
  * Network manager creates DHCPNAK
  */
-int NetworkManager::nak(Client* client, uint32_t u32Xid)
-{
-    AssertPtrReturn(client, VERR_INTERNAL_ERROR);
-
-    if (!client->m_lease)
+int NetworkManager::nak(const Client& client, uint32_t u32Xid)
+{
+
+    Lease l = client.lease();
+    if (l == Lease::NullLease)
         return VERR_INTERNAL_ERROR;
 
@@ -629 +698 @@
      */
     RawOption opt;
-    RT_ZERO(opt);
+    std::vector<RawOption> extra;
 
     opt.u8OptId = RTNET_DHCP_OPT_MSG_TYPE;
     opt.au8RawOpt[0] = RTNET_DHCP_MT_NAC;
     opt.cbRawOpt = 1;
-    client->rawOptions.push_back(opt);
-
-    return doReply(client);
+    extra.push_back(opt);
+
+    return doReply(client, extra);
 }
 
@@ -643 +712 @@
  *
  */
-int NetworkManager::prepareReplyPacket4Client(Client *client, uint32_t u32Xid)
-{
-    AssertPtrReturn(client, VERR_INTERNAL_ERROR);
-    AssertPtrReturn(client->m_lease, VERR_INTERNAL_ERROR);
-
+int NetworkManager::prepareReplyPacket4Client(const Client& client, uint32_t u32Xid)
+{
     memset(&BootPReplyMsg, 0, sizeof(BootPReplyMsg));
 
@@ -661 +727 @@
     BootPReplyMsg.BootPHeader.bp_giaddr.u = 0;
 
-    BootPReplyMsg.BootPHeader.bp_chaddr.Mac = client->m_mac;
-
-    BootPReplyMsg.BootPHeader.bp_yiaddr = client->m_lease->getAddress();
+    BootPReplyMsg.BootPHeader.bp_chaddr.Mac = client.getMacAddress();
+
+    const Lease l = client.lease();
+    BootPReplyMsg.BootPHeader.bp_yiaddr = l.getAddress();
     BootPReplyMsg.BootPHeader.bp_siaddr.u = 0;
 
@@ -677 +744 @@
 
 
-int NetworkManager::doReply(Client *client)
+int NetworkManager::doReply(const Client& client, const std::vector<RawOption>& extra)
 {
     int rc;
-
-    AssertPtrReturn(client, VERR_INTERNAL_ERROR);
-    AssertPtrReturn(client->m_lease, VERR_INTERNAL_ERROR);
 
     /*
@@ -693 +757 @@
     Cursor.optIPv4Addr(RTNET_DHCP_OPT_SERVER_ID, m_OurAddress);
 
-    while(!client->rawOptions.empty())
-    {
-        RawOption opt = client->rawOptions.back();
-        if (!Cursor.begin(opt.u8OptId, opt.cbRawOpt))
+    const Lease l = client.lease(); 
+    const std::map<uint8_t, RawOption>& options = l.options();
+
+    for(std::vector<RawOption>::const_iterator it = extra.begin(); 
+        it != extra.end(); ++it)
+    {
+        if (!Cursor.begin(it->u8OptId, it->cbRawOpt))
             break;
-        Cursor.put(opt.au8RawOpt, opt.cbRawOpt);
-
-        client->rawOptions.pop_back();
-    }
-
-
-    if (!client->rawOptions.empty())
-    {
-        Log(("Wasn't able to put all options\n"));
-        /* force clean up */
-        client->rawOptions.clear();
+        Cursor.put(it->au8RawOpt, it->cbRawOpt);
+
+    }
+
+    for(std::map<uint8_t, RawOption>::const_iterator it = options.begin(); 
+        it != options.end(); ++it)
+    {
+        if (!Cursor.begin(it->second.u8OptId, it->second.cbRawOpt))
+            break;
+        Cursor.put(it->second.au8RawOpt, it->second.cbRawOpt);
+
     }
 
@@ -716 +783 @@
      */
 #if 0
-    if (!(pDhcpMsg->bp_flags & RTNET_DHCP_FLAGS_NO_BROADCAST)) /** @todo need to see someone set this flag to check that it's correct. */
+    /** @todo need to see someone set this flag to check that it's correct. */
+    if (!(pDhcpMsg->bp_flags & RTNET_DHCP_FLAGS_NO_BROADCAST))  
     {
         rc = VBoxNetUDPUnicast(m_pSession,
@@ -746 +814 @@
 
 
-int NetworkManager::processParameterReqList(Client* client, uint8_t *pu8ReqList, int cReqList)
+int NetworkManager::processParameterReqList(const Client& client, uint8_t *pu8ReqList, int cReqList)
 {
     /* request parameter list */
@@ -752 +820 @@
     int idxParam = 0;
 
-    AssertPtrReturn(client, VERR_INTERNAL_ERROR);
-
     uint8_t *pReqList = pu8ReqList;
-
-    const NetworkConfigEntity *pNetCfg = client->m_lease->getConfig();
+    
+    const Lease const_l = client.lease();
+    Lease l = Lease(const_l);
+    
+    const NetworkConfigEntity *pNetCfg = l.getConfig();
 
     for (idxParam = 0; idxParam < cReqList; ++idxParam)
     {
 
+        bool fIgnore = false;
         RT_ZERO(opt);
         opt.u8OptId = pReqList[idxParam];
+
         switch(pReqList[idxParam])
         {
@@ -768 +839 @@
                 ((PRTNETADDRIPV4)opt.au8RawOpt)->u = pNetCfg->netmask().u;
                 opt.cbRawOpt = sizeof(RTNETADDRIPV4);
-                client->rawOptions.push_back(opt);
+
                 break;
 
@@ -787 +858 @@
                     }
 
-                    if (!lst.empty())
-                        client->rawOptions.push_back(opt);
+                    if (lst.empty())
+                        fIgnore = true;
                 }
                 break;
@@ -795 +866 @@
                     std::string domainName = g_ConfigurationManager->getString(pReqList[idxParam]);
                     if (domainName == g_ConfigurationManager->m_noString)
+                    {
+                        fIgnore = true;
                         break;
+                    }
 
                     char *pszDomainName = (char *)&opt.au8RawOpt[0];
@@ -801 +875 @@
                     strcpy(pszDomainName, domainName.c_str());
                     opt.cbRawOpt = domainName.length();
-                    client->rawOptions.push_back(opt);
                 }
                 break;
             default:
                 Log(("opt: %d is ignored\n", pReqList[idxParam]));
+                fIgnore = true;
                 break;
         }
+
+        if (!fIgnore)
+            l.options().insert(std::map<uint8_t, RawOption>::value_type(opt.u8OptId, opt));
+
     }
 
@@ -813 +891 @@
 }
 
-
-Lease::~Lease()
-{
-    if (m)
-        delete m;
-}
-
-
-void Lease::init()
-{
-    if (!m)
-        m = new Lease::Data();
+/* Utility */
+bool operator== (const RTMAC& lhs, const RTMAC& rhs)
+{
+    return (   lhs.au16[0] == rhs.au16[0]
+            && lhs.au16[1] == rhs.au16[1]
+            && lhs.au16[2] == rhs.au16[2]);
+}
+
+
+/* Client */
+Client::Client()
+{
+    m = SharedPtr<ClientData>();
+}
+
+
+void Client::initWithMac(const RTMAC& mac)
+{
+    m = SharedPtr<ClientData>(new ClientData());
+    m->m_mac = mac;
+}
+
+
+bool Client::operator== (const RTMAC& mac) const
+{
+    return (m.get() && m->m_mac == mac);
+}
+
+
+const RTMAC& Client::getMacAddress() const
+{
+    return m->m_mac;
+}
+
+
+Lease Client::lease()
+{
+    if (!m.get()) return Lease::NullLease;
+
+    if (m->fHasLease)
+        return Lease(*this);
+    else
+        return Lease::NullLease;
+}
+
+
+const Lease Client::lease() const
+{
+    return const_cast<Client *>(this)->lease();
+}
+
+
+Client::Client(ClientData *data):m(SharedPtr<ClientData>(data)){}
+
+/* Lease */
+Lease::Lease()
+{
+    m = SharedPtr<ClientData>();
+}
+
+
+Lease::Lease (const Client& c)
+{
+    m = SharedPtr<ClientData>(c.m);
+    if (   !m->fHasLease
+        || (   isExpired()
+            && !isInBindingPhase()))
+    {
+        m->fHasLease = true;
+        m->fBinding = true;
+        phaseStart(RTTimeMilliTS());
+    }
 }
 
@@ -830 +968 @@
 bool Lease::isExpired() const
 {
-    AssertPtrReturn(m, false);
+    AssertPtrReturn(m.get(), false);
 
     if (!m->fBinding)
@@ -841 +979 @@
 
 
+void Lease::expire()
+{
+    /* XXX: TODO */
+}
+
+
 void Lease::phaseStart(uint64_t u64Start)
 {
@@ -862 +1006 @@
 
 
+uint64_t Lease::issued() const
+{
+    return m->u64TimestampLeasingStarted;
+}
+
+
 void Lease::setExpiration(uint32_t exp)
 {
@@ -904 +1054 @@
 
 
-Client *Lease::getClient() const
-{
-    return m->m_client;
-}
-
-void Lease::setClient(Client *client)
-{
-    m->m_client = client;
-}
+const MapOptionId2RawOption& Lease::options() const
+{
+    return m->options;
+}
+
+
+MapOptionId2RawOption& Lease::options()
+{
+    return m->options;
+}
+
+
+Lease::Lease(ClientData *pd):m(SharedPtr<ClientData>(pd)){}
+
+
+const Lease Lease::NullLease;
+
+
+const Client Client::NullClient;

trunk/src/VBox/NetworkServices/DHCP/Config.h

@@ -10 +10 @@
 #include <iprt/cpp/utils.h>
 
-typedef std::vector<RTMAC> MacAddressContainer;
-typedef MacAddressContainer::iterator MacAddressIterator;
-
-typedef std::vector<RTNETADDRIPV4> Ipv4AddressContainer;
-typedef Ipv4AddressContainer::iterator Ipv4AddressIterator;
-typedef Ipv4AddressContainer::const_iterator Ipv4AddressConstIterator;
 
 static bool operator <(const RTNETADDRIPV4& a, const RTNETADDRIPV4& b)
@@ -31 +25 @@
 {
 public:
+    RawOption()
+    {
+        RT_ZERO(*this);
+    }
     uint8_t u8OptId;
     uint8_t cbRawOpt;
@@ -36 +34 @@
 };
 
-
+class ClientData;
 class Client;
 class Lease;
 class BaseConfigEntity;
 
-
 class NetworkConfigEntity;
 class HostConfigEntity;
 class ClientMatchCriteria;
-
-typedef std::map<Lease *, RTNETADDRIPV4> MapLease2Ip4Address;
-typedef MapLease2Ip4Address::iterator MapLease2Ip4AddressIterator;
-typedef MapLease2Ip4Address::value_type MapLease2Ip4AddressPair;
+class ConfigurationManager;
 
 /*
@@ -61 +55 @@
 class Client
 {
+    friend class Lease;
+    friend class ConfigurationManager;
+
     public:
-
-    /* XXX: Option 60 and 61 */
-    Client(const RTMAC& mac);
-
-    bool operator== (const RTMAC& mac) const
-    {
-        return (  m_mac.au16[0] == mac.au16[0]
-                && m_mac.au16[1] == mac.au16[1]
-                && m_mac.au16[2] == mac.au16[2]);
-    }
+    Client();
+    void initWithMac(const RTMAC& mac);
+    bool operator== (const RTMAC& mac) const;
+    const RTMAC& getMacAddress() const;
+
     /** Dumps client query */
     void dump();
 
-    /* XXX! private: */
-
-    RTMAC m_mac;
-    Lease *m_lease;
-
-    /* XXX: should be in lease */
-    std::vector<RawOption> rawOptions;
-};
-
-
-typedef std::vector<Client*> VecClient;
+    Lease lease();
+    const Lease lease() const; 
+
+    public:
+    static const Client NullClient;
+
+    private:
+    Client(ClientData *);
+    SharedPtr<ClientData> m;
+};
+
+
+bool operator== (const Lease&, const Lease&);
+bool operator!= (const Lease&, const Lease&);
+bool operator< (const Lease&, const Lease&);
+
+
+typedef std::map<uint8_t, RawOption> MapOptionId2RawOption;
+typedef MapOptionId2RawOption::iterator MapOptionId2RawOptionIterator;
+typedef MapOptionId2RawOption::const_iterator MapOptionId2RawOptionConstIterator;
+typedef MapOptionId2RawOption::value_type MapOptionId2RawOptionValue;
+
+namespace xml {
+    class ElementNode;
+}
+
+class Lease
+{
+    friend class Client;
+    friend bool operator== (const Lease&, const Lease&);
+    //friend int ConfigurationManager::loadFromFile(const std::string&);
+    friend class ConfigurationManager;
+
+    public:
+    Lease();
+    Lease(const Client&);
+
+    bool isExpired() const;
+    void expire();
+
+    /* Depending on phase *Expiration and phaseStart initialize different values. */
+    void bindingPhase(bool);
+    void phaseStart(uint64_t u64Start);
+    bool isInBindingPhase() const;
+    /* returns 0 if in binding state */
+    uint64_t issued() const; 
+
+    void setExpiration(uint32_t);
+    uint32_t getExpiration() const;
+
+    RTNETADDRIPV4 getAddress() const;
+    void setAddress(RTNETADDRIPV4);
+
+    const NetworkConfigEntity *getConfig() const;
+    void setConfig(NetworkConfigEntity *);
+
+    const MapOptionId2RawOption& options() const;
+    MapOptionId2RawOption& options();
+
+
+    public:
+    static const Lease NullLease;
+
+    private:
+    Lease(ClientData *);
+    SharedPtr<ClientData> m;
+};
+
+
+typedef std::vector<Client> VecClient;
 typedef VecClient::iterator VecClientIterator;
 typedef VecClient::const_iterator VecClientConstIterator;
+
+typedef std::vector<RTMAC> MacAddressContainer;
+typedef MacAddressContainer::iterator MacAddressIterator;
+
+typedef std::vector<RTNETADDRIPV4> Ipv4AddressContainer;
+typedef Ipv4AddressContainer::iterator Ipv4AddressIterator;
+typedef Ipv4AddressContainer::const_iterator Ipv4AddressConstIterator;
+
+typedef std::map<Lease, RTNETADDRIPV4> MapLease2Ip4Address;
+typedef MapLease2Ip4Address::iterator MapLease2Ip4AddressIterator;
+typedef MapLease2Ip4Address::const_iterator MapLease2Ip4AddressConstIterator;
+typedef MapLease2Ip4Address::value_type MapLease2Ip4AddressPair;
 
 
@@ -130 +193 @@
         return (m_left->check(client) && m_right->check(client));
     }
+
 private:
     ClientMatchCriteria* m_left;
@@ -156 +220 @@
         return (client == m_mac);
     }
+
 private:
     RTMAC m_mac;
@@ -185 +250 @@
 class BaseConfigEntity
 {
-public:
+    public:
     BaseConfigEntity(const ClientMatchCriteria *criteria = NULL,
       int matchingLevel = 0)
@@ -202 +267 @@
     virtual uint32_t expirationPeriod() const = 0;
 
-protected:
+    protected:
     const ClientMatchCriteria *m_criteria;
     int m_MatchLevel;
@@ -211 +276 @@
 class NullConfigEntity: public BaseConfigEntity
 {
-public:
+    public:
     NullConfigEntity(){}
     virtual ~NullConfigEntity(){}
-    int add(BaseConfigEntity *) const
-    {
-        return 0;
-    }
+    int add(BaseConfigEntity *) const { return 0;}
     virtual uint32_t expirationPeriod() const {return 0;}
 };
@@ -224 +286 @@
 class ConfigEntity: public BaseConfigEntity
 {
-public:
+    public:
     /* range */
     /* match conditions */
@@ -320 +382 @@
         /* upper addr == lower addr */
     }
-
-    virtual int match(const Client& client) const
-    {
-        return (m_criteria->check(client) ? 10 : 0);
-    }
-
 };
 
@@ -368 +424 @@
      *
      */
-    Client* getClientByDhcpPacket(const RTNETBOOTP *pDhcpMsg, size_t cbDhcpMsg);
+    Client getClientByDhcpPacket(const RTNETBOOTP *pDhcpMsg, size_t cbDhcpMsg);
 
     /**
@@ -375 +431 @@
      * allocation)...
      */
-    Lease* allocateLease4Client(Client *client, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg);
+    Lease allocateLease4Client(const Client& client, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg);
 
     /**
@@ -381 +437 @@
      * when requested configuration is acceptable.
      */
-    int commitLease4Client(Client *client);
+    int commitLease4Client(Client& client);
 
     /**
      * Expires client lease.
      */
-    int expireLease4Client(Client *client);
+    int expireLease4Client(Client& client);
 
     static int findOption(uint8_t uOption, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg, RawOption& opt);
@@ -404 +460 @@
 
 private:
-    ConfigurationManager(){}
-    virtual ~ConfigurationManager(){}
-    bool isAddressTaken(const RTNETADDRIPV4& addr, Lease** ppLease = NULL);
+    ConfigurationManager():m(NULL){}
+    void init();
+
+    ~ConfigurationManager();
+    bool isAddressTaken(const RTNETADDRIPV4& addr, Lease& lease);
+    bool isAddressTaken(const RTNETADDRIPV4& addr)
+    {
+        Lease ignore;
+        return isAddressTaken(addr, ignore);
+    }
 
 public:
@@ -414 +477 @@
 
 private:
-    MapLease2Ip4Address m_allocations;
-    /**
-     * Here we can store expired Leases to do not re-allocate them latter.
-     */
-
-    /* XXX: MapLease2Ip4Address m_freed; */
-    /* XXX: more universal storages are required. */
-    Ipv4AddressContainer m_nameservers;
-    Ipv4AddressContainer m_routers;
-
-    std::string          m_domainName;
-    VecClient m_clients;
+    struct Data;
+    Data *m;
 };
 
@@ -434 +487 @@
     static NetworkManager *getNetworkManager();
 
-    int offer4Client(Client* lease, uint32_t u32Xid, uint8_t *pu8ReqList, int cReqList);
-    int ack(Client *lease, uint32_t u32Xid, uint8_t *pu8ReqList, int cReqList);
-    int nak(Client *lease, uint32_t u32Xid);
+    int offer4Client(const Client& lease, uint32_t u32Xid, uint8_t *pu8ReqList, int cReqList);
+    int ack(const Client& lease, uint32_t u32Xid, uint8_t *pu8ReqList, int cReqList);
+    int nak(const Client& lease, uint32_t u32Xid);
 
     const RTNETADDRIPV4& getOurAddress(){ return m_OurAddress;}
@@ -455 +508 @@
     virtual ~NetworkManager(){}
 
-    int prepareReplyPacket4Client(Client *client, uint32_t u32Xid);
-    int doReply(Client *client);
-    int processParameterReqList(Client *client, uint8_t *pu8ReqList, int cReqList);
+    int prepareReplyPacket4Client(const Client& client, uint32_t u32Xid);
+    int doReply(const Client& client, const std::vector<RawOption>& extra);
+    int processParameterReqList(const Client& client, uint8_t *pu8ReqList, int cReqList);
 
     union {
@@ -469 +522 @@
     RTMAC m_OurMac;
 };
-
-
-
-class Lease
-{
-public:
-    Lease():m(NULL){};
-    ~Lease();
-    void init();
-
-    bool isExpired() const;
-
-    /* Depending on phase *Expiration and phaseStart initialize different values. */
-    void bindingPhase(bool);
-    void phaseStart(uint64_t u64Start);
-    bool isInBindingPhase() const;
-
-    void setExpiration(uint32_t);
-    uint32_t getExpiration() const;
-
-    RTNETADDRIPV4 getAddress() const;
-    void setAddress(RTNETADDRIPV4);
-
-    const NetworkConfigEntity *getConfig() const;
-    void setConfig(NetworkConfigEntity *);
-   
-    Client *getClient() const;
-    void setClient(Client *);
-
-    private:
-    class Data;
-    
-    Data *m;
-};
-
 
 

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

@@ -56 +56 @@
 
 #include "../NetLib/VBoxNetLib.h"
+#include "../NetLib/shared_ptr.h"
 
 #include <vector>
@@ -470 +471 @@
 
         }
+        
     }
 
@@ -725 +727 @@
         /* 1. Find client */
         ConfigurationManager *confManager = ConfigurationManager::getConfigurationManager();
-        Client *client = confManager->getClientByDhcpPacket(pDhcpMsg, cb);
+        Client client = confManager->getClientByDhcpPacket(pDhcpMsg, cb);
 
         /* 2. Find/Bind lease for client */
-        Lease *lease = confManager->allocateLease4Client(client, pDhcpMsg, cb);
-        AssertPtrReturn(lease, VINF_SUCCESS);
+        Lease lease = confManager->allocateLease4Client(client, pDhcpMsg, cb);
+        AssertReturn(lease != Lease::NullLease, VINF_SUCCESS);
 
         int rc = ConfigurationManager::extractRequestList(pDhcpMsg, cb, opt);
@@ -736 +738 @@
         NetworkManager *networkManager = NetworkManager::getNetworkManager();
 
-        lease->bindingPhase(true);
-        lease->phaseStart(RTTimeMilliTS());
-        lease->setExpiration(300); /* 3 min. */
+        lease.bindingPhase(true);
+        lease.phaseStart(RTTimeMilliTS());
+        lease.setExpiration(300); /* 3 min. */
         networkManager->offer4Client(client, pDhcpMsg->bp_xid, opt.au8RawOpt, opt.cbRawOpt);
     } /* end of if(!m_DhcpServer.isNull()) */
@@ -760 +762 @@
 
     /* 1. find client */
-    Client *client = confManager->getClientByDhcpPacket(pDhcpMsg, cb);
+    Client client = confManager->getClientByDhcpPacket(pDhcpMsg, cb);
 
     /* 2. find bound lease */
-    if (client->m_lease)
-    {
-
-        if (client->m_lease->isExpired())
+    Lease l = client.lease();
+    if (l != Lease::NullLease)
+    {
+
+        if (l.isExpired())
         {
             /* send client to INIT state */
+            Client c(client);
             networkManager->nak(client, pDhcpMsg->bp_xid);
-            confManager->expireLease4Client(client);
+            confManager->expireLease4Client(c);
             return true;
         }
-        /* XXX: Validate request */
-        RawOption opt;
-        memset((void *)&opt, 0, sizeof(RawOption));
-
-        int rc = confManager->commitLease4Client(client);
-        AssertRCReturn(rc, false);
-
-        rc = ConfigurationManager::extractRequestList(pDhcpMsg, cb, opt);
-        AssertRCReturn(rc, false);
-
-        networkManager->ack(client, pDhcpMsg->bp_xid, opt.au8RawOpt, opt.cbRawOpt);
+        else {
+            /* XXX: Validate request */
+            RawOption opt;
+            RT_ZERO(opt);
+
+            Client c(client);
+            int rc = confManager->commitLease4Client(c);
+            AssertRCReturn(rc, false);
+
+            rc = ConfigurationManager::extractRequestList(pDhcpMsg, cb, opt);
+            AssertRCReturn(rc, false);
+
+            networkManager->ack(client, pDhcpMsg->bp_xid, opt.au8RawOpt, opt.cbRawOpt);
+        }
     }
     else