/ - Diff - OpenNebula - OpenNebula Development pages

Revision f8615d6e

+    {
     public:
         AddressRange(unsigned int _id):id(_id),next(0),used_addr(0){};
         virtual ~AddressRange(){};
         // *************************************************************************
-...
          *            SIZE = 1024,
          *            ULA_PREFIX    = "fd00:0:0:1::",
          *            GLOBAL_PREFIX = "2001::"]
+         *
          * NOTE: This function is part of the AddressRange interface. The AR
          * implementation may contact an external IPAM to complete or validate
          * the AR allocation request.
          */
         int from_vattr(VectorAttribute * attr, string& error_msg);
         virtual int from_vattr(VectorAttribute * attr, string& error_msg) = 0;
         /**
          *  Builds an Address Range from a vector attribute stored in the DB
-...
          */
         unsigned int get_used_addr() const
+        {
             return used_addr;
             return allocated.size();
+        }
         /**
-...
          */
         unsigned int get_free_addr() const
+        {
             return size - used_addr;
             return size - allocated.size();
+        }
         /**
-...
                 string&             error_msg);
         /**
          *  Helper function to initialize restricte attributes of an AddressRange
          */
         static void set_restricted_attributes(vector<const SingleAttribute *>& ras);
         /**
          *  Get the security groups for this AR.
          *    @return a reference to the security group set
          */
-...
          */
         friend int AddressRangePool::add_ar(AddressRange * ar);
         static void set_restricted_attributes(vector<const SingleAttribute *>& rattrs);
     protected:
         /**
          *  Base constructor it cannot be called directly but from the
          *  AddressRange factory constructor.
          */
         AddressRange(unsigned int _id):id(_id){};
         /**
          * Builds the AddressRange from its vector attribute representation
          */
         int from_attr(VectorAttribute * attr, string& error_msg);
         /* ---------------------------------------------------------------------- */
         /* Implementation specific address management interface                   */
         /* ---------------------------------------------------------------------- */
         /**
          *  Sets the given range of addresses (by index) as used
          *    @param index the first address to set as used
          *    @param sz number of addresses to set
          *    @param msg describing the error if any
+         *
          *    @return 0 if success
          */
         virtual int allocate_addr(unsigned int index, unsigned int sz, string& msg) = 0;
         /**
          *  Gets a range of free addresses
          *    @param index the first address in the range
          *    @param size number of addresses requested in the range
          *    @param msg describing the error if any
+         *
          *    @return 0 if success
          */
         virtual int get_addr(unsigned int& index, unsigned int sz, string& msg) = 0;
         /**
          *  Sets the given address (by index) as free
          *    @param index of the address
          *    @param msg describing the error if any
+         *
          *    @return 0 if success
          */
         virtual int free_addr(unsigned int index, string& msg) = 0;
         /* ---------------------------------------------------------------------- */
         /* Allocated addresses                                                    */
         /* ---------------------------------------------------------------------- */
         /**
          *  Map to store the allocated address indexed by the address index relative
          *  to the mac/ip values. It contains also the type and id of the object
          *  owning the address.
+         *
          *              +--------------------+--------------------+
          *  index ----> | ObjectType(32bits) | Object ID (32bits) |
          *              +--------------------+--------------------+
+         *
          *  Address = First Address + index
          */
         map<unsigned int, long long> allocated;
     private:
         /* ---------------------------------------------------------------------- */
-...
         /* ---------------------------------------------------------------------- */
         /* NIC setup functions                                                    */
         /* ---------------------------------------------------------------------- */
         /**
          *  Check if the given MAC is valid for this address range by verifying:
          *    - Correct : notation
          *    - Part of the AR
+         *
          *    @param index of the MAC in the AR
          *    @param mac_s string representation of the MAC in : notation
          *    @param check_free apart from previous checks
+         *
          *    @return true if the MAC is valid
          */
         bool is_valid_mac(unsigned int& index, const string& mac_s, bool check_free);
         /**
          *  Check if the given IP is valid for this address range by verifying:
          *    - AR is of type IP4 or IP4_6
          *    - Correct . notation
          *    - Part of the AR
+         *
          *    @param index of the IP in the AR
          *    @param ip_s string representation of the IP in . notation
          *    @param check_free apart from previous checks
+         *
          *    @return true if the IP is valid
          */
         bool is_valid_ip(unsigned int& index, const string& ip_s, bool check_free);
         /**
          *  Writes MAC address to the given NIC attribute
          *    @param addr_index internal index for the lease
-...
         /**
          *  Adds a new allocated address to the map. Updates the ALLOCATED attribute
          */
         void allocate_addr(PoolObjectSQL::ObjectType ot, int obid,
         void set_allocated_addr(PoolObjectSQL::ObjectType ot, int obid,
             unsigned int addr_index);
         /**
          *  Sets the address lease as used and fills a NIC attribute with the
          *  configuration parameters from the address range.
          *    @param index of the lease in the address range
          *    @param ot the type of the object allocating the address
          *    @param obid the id of the object
          *    @param nic the VM NIC attribute
          *    @param inherit attributes to be added to the NIC attribute
          *    @return 0 if success
          */
         void allocate_by_index(unsigned int index,
             PoolObjectSQL::ObjectType ot,
             int                       obid,
             VectorAttribute*          nic,
             const vector<string>&     inherit);
         /**
          *  Frees an address from the map. Updates the ALLOCATED attribute
          */
         int free_addr(PoolObjectSQL::ObjectType ot, int obid,
         int free_allocated_addr(PoolObjectSQL::ObjectType ot, int obid,
             unsigned int addr_index);
         /**
-...
         set<int> security_groups;
         /**
          *  The Address Range attributes as a Template VectorAttribute. This is
          *  used to generate XML or a template representation of the AR.
          *  The name of the IPAM driver (internal for OpenNebula built-in)
          */
         VectorAttribute * attr;
         string ipam_mad;
         /* ---------------------------------------------------------------------- */
         /* Allocated address & control                                            */
         /* ---------------------------------------------------------------------- */
         /**
          *  Map to store the allocated address indexed by the address index relative
          *  to the mac/ip values. It contains also the type and id of the object
          *  owning the address ObjectType(32bits) | Object ID (32)
          *  The Address Range attributes as a Template VectorAttribute. This is
          *  used to generate XML or a template representation of the AR.
          */
         map<unsigned int, long long> allocated;
         unsigned int next;
         unsigned int used_addr;
         VectorAttribute * attr;
         /* ---------------------------------------------------------------------- */
         /* Restricted Attributes                                                  */

     /* -------------------------------------------------------------------------- */
     /* Copyright 2002-2016, OpenNebula Project, OpenNebula Systems                */
     /*                                                                            */
     /* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
     /* not use this file except in compliance with the License. You may obtain    */
     /* a copy of the License at                                                   */
     /*                                                                            */
     /* http://www.apache.org/licenses/LICENSE-2.0                                 */
     /*                                                                            */
     /* Unless required by applicable law or agreed to in writing, software        */
     /* distributed under the License is distributed on an "AS IS" BASIS,          */
     /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
     /* See the License for the specific language governing permissions and        */
     /* limitations under the License.                                             */
     /* -------------------------------------------------------------------------- */
     #ifndef ADDRESS_RANGE_IPAM_H_
     #define ADDRESS_RANGE_IPAM_H_
     #include <string>
     #include "AddressRange.h"
     #include "AddressRangePool.h"
     class VectorAttribute;
     class AddressRangeIPAM : public AddressRange
+    {
     public:
         AddressRangeIPAM(unsigned int _id):AddressRange(_id){};
         virtual ~AddressRangeIPAM(){};
         /* ---------------------------------------------------------------------- */
         /* AddressRange Interface **TODO contact IPAM**                           */
         /* ---------------------------------------------------------------------- */
         int from_vattr(VectorAttribute * attr, std::string& error_msg)
+        {
             error_msg = "Not Implemented";
             return -1;
         };
         int allocate_addr(unsigned int index, unsigned int size, string& error_msg)
+        {
             error_msg = "Not Implemented";
             return -1;
         };
         int get_addr(unsigned int& index, unsigned int rsize, string& error_msg)
+        {
             error_msg = "Not Implemented";
             return -1;
         };
         int free_addr(unsigned int index, string& error_msg)
+        {
             error_msg = "Not Implemented";
             return -1;
         };
     };
     #endif

     /* -------------------------------------------------------------------------- */
     /* Copyright 2002-2016, OpenNebula Project, OpenNebula Systems                */
     /*                                                                            */
     /* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
     /* not use this file except in compliance with the License. You may obtain    */
     /* a copy of the License at                                                   */
     /*                                                                            */
     /* http://www.apache.org/licenses/LICENSE-2.0                                 */
     /*                                                                            */
     /* Unless required by applicable law or agreed to in writing, software        */
     /* distributed under the License is distributed on an "AS IS" BASIS,          */
     /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
     /* See the License for the specific language governing permissions and        */
     /* limitations under the License.                                             */
     /* -------------------------------------------------------------------------- */
     #ifndef ADDRESS_RANGE_INTERNAL_H_
     #define ADDRESS_RANGE_INTERNAL_H_
     #include <string>
     #include "AddressRange.h"
     #include "AddressRangePool.h"
     class VectorAttribute;
     class AddressRangeInternal : public AddressRange
+    {
     public:
         AddressRangeInternal(unsigned int _id):AddressRange(_id), next(0){};
         virtual ~AddressRangeInternal(){};
         /* ---------------------------------------------------------------------- */
         /* AddressRange Interface                                                 */
         /* ---------------------------------------------------------------------- */
         /**
          *  Init an Address Range based on a vector attribute.
          *    @param attr the description of the AddressRange
          *    @param error_msg description if error
          *    @return 0 on success
          */
         int from_vattr(VectorAttribute * attr, std::string& error_msg)
+        {
             return AddressRange::from_attr(attr, error_msg);
+        }
         /**
          *  Sets the given range of addresses (by index) as used
          *    @param index the first address to set as used
          *    @param sz number of addresses to set
          *    @param msg describing the error if any
+         *
          *    @return 0 if success
          */
         int allocate_addr(unsigned int index, unsigned int size, string& error_msg)
+        {
             return 0;
+        }
         /**
          *  Gets a range of free addresses
          *    @param index the first address in the range
          *    @param size number of addresses requested in the range
          *    @param msg describing the error if any
+         *
          *    @return 0 if success
          */
         int get_addr(unsigned int& index, unsigned int rsize, string& error_msg)
+        {
             if ( rsize == 1 )
+            {
                 return get_single_addr(index, error_msg);
+            }
             return get_range_addr(index, rsize, error_msg);
+        }
         /**
          *  Sets the given address (by index) as free
          *    @param index of the address
          *    @param msg describing the error if any
+         *
          *    @return 0 if success
          */
         int free_addr(unsigned int index, string& msg)
+        {
             return 0;
         };
     private:
         /**
          *  Lookup index for the next free address lease
          */
         unsigned int next;
         /**
          *  Get a free lease
          *    @param index of the free lease, undefined if error
          *    @param msg with error description if any
          *    @return 0 on success -1 otherwise
          */
         int get_single_addr(unsigned int& index, std::string& msg);
         /**
          *  Get a free and continuous range of leases
          *    @param index of the first free lease in range, undefined if error
          *    @param sz of the range
          *    @param msg with error description if any
          *    @return 0 on success -1 otherwise
          */
         int get_range_addr(unsigned int& index, unsigned int sz, std::string& msg);
     };
     #endif

          *    the reason.
          *    @return 0 on success
          */
         int update_ar(vector<VectorAttribute *> ars, bool keep_restricted, string& error_msg);
         int update_ar(vector<VectorAttribute *> ars, bool keep_restricted,
                 string& error_msg);
         /**
          *  Allocates a new *empty* address range. It is not added to the pool as it
          *  needs to be initialized. Only the AR_ID is set.
          *    @param ipam_mad sets the type of AddressRange to be created: internal,
          *    IPAM...
          *    @return the new address range.
          */
         AddressRange * allocate_ar();
         AddressRange * allocate_ar(const string& ipam_mad);
         /**
          *  Adds a new address range to the pool. It should be allocated by the
-...
          *  Used addresses
          */
         unsigned int used_addr;
         /**
          *  Allocates a new *empty* address range. It is not added to the pool as it
          *  needs to be initialized.
          *    @param ipam_mad sets the type of AddressRange to be created: internal,
          *    IPAM...
          *    @param ar_id for the AddressRange
          *    @return the new address range.
          */
         AddressRange * allocate_ar(const string& ipam_mad, unsigned int ar_id);
     };
     #endif

          *  ar_pool
          *    @return pointer to the new address range
          */
         AddressRange * allocate_ar()
         AddressRange * allocate_ar(const string& ipam_mad)
+        {
             return ar_pool.allocate_ar();
             return ar_pool.allocate_ar(ipam_mad);
+        }
         /**

     /* ************************************************************************** */
     /* ************************************************************************** */
     int AddressRange::from_vattr(VectorAttribute *vattr, string& error_msg)
     int AddressRange::from_attr(VectorAttribute *vattr, string& error_msg)
+    {
         string value;
-...
                 return -1;
+            }
             next = 0;
+        }
         else
+        {
-...
+            }
+        }
         oss << "<USED_LEASES>" << used_addr << "</USED_LEASES>";
         oss << "<USED_LEASES>" << get_used_addr() << "</USED_LEASES>";
         if (allocated.empty())
+        {
-...
     /* ************************************************************************** */
     /* ************************************************************************** */
     bool AddressRange::is_valid_mac(unsigned int& index, const string& mac_s,
         bool check_free)
+    {
         unsigned int mac_i[2];
         if (mac_to_i(mac_s, mac_i) == -1)
+        {
             return false;
+        }
         if ((mac_i[1] != mac[1]) || (mac_i[0] < mac[0]))
+        {
             return false;
+        }
         index = mac_i[0] - mac[0];
         if ((check_free && allocated.count(index) != 0) || (index >= size))
+        {
             return false;
+        }
         return true;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     bool AddressRange::is_valid_ip(unsigned int& index, const string& ip_s,
         bool check_free)
+    {
         if (!(type & 0x00000002))//Not of type IP4 or IP4_6
+        {
             return false;
+        }
         unsigned int ip_i;
         if (ip_to_i(ip_s, ip_i) == -1)
+        {
             return false;
+        }
         if (ip_i < ip)
+        {
             return false;
+        }
         index = ip_i - ip;
         if ((check_free && allocated.count(index) != 0) || (index >= size))
+        {
             return false;
+        }
         return true;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void AddressRange::set_mac(unsigned int addr_index, VectorAttribute * nic) const
+    {
         unsigned int new_mac[2];
-...
+            }
             allocated.insert(make_pair(addr_index,object_pack));
             used_addr++;
+        }
         if ( used_addr > size )
         if ( get_used_addr() > size )
+        {
             return -1;
+        }
-...
     /* -------------------------------------------------------------------------- */
     void AddressRange::allocate_addr(PoolObjectSQL::ObjectType ot, int obid,
     void AddressRange::set_allocated_addr(PoolObjectSQL::ObjectType ot, int obid,
         unsigned int addr_index)
+    {
         long long lobid = obid & 0x00000000FFFFFFFFLL;
         allocated.insert(make_pair(addr_index,ot|lobid));
         used_addr++;
         allocated_to_attr();
+    }
     /* -------------------------------------------------------------------------- */
     int AddressRange::free_addr(PoolObjectSQL::ObjectType ot, int obid,
     int AddressRange::free_allocated_addr(PoolObjectSQL::ObjectType ot, int obid,
         unsigned int addr_index)
+    {
         long long lobid = obid & 0x00000000FFFFFFFFLL;
-...
             allocated.erase(it);
             allocated_to_attr();
             used_addr--;
             return 0;
+        }
-...
     /* ************************************************************************** */
     /* ************************************************************************** */
     int AddressRange::allocate_addr(
     void AddressRange::allocate_by_index(unsigned int index,
         PoolObjectSQL::ObjectType ot,
         int                       obid,
         VectorAttribute*          nic,
         const vector<string>&     inherit)
+    {
         if ( used_addr >= size )
         set_mac(index, nic);
         if (type & 0x00000002 )
+        {
             return -1;
             set_ip(index, nic);
+        }
         for ( unsigned int i=0; i<size; i++, next = (next+1)%size )
         if (type & 0x00000004)
+        {
             if ( allocated.count(next) == 0 )
+            {
                 set_mac(next, nic);
                 if (type & 0x00000002 )
+                {
                     set_ip(next, nic);
+                }
                 if (type & 0x00000004)
+                {
                     set_ip6(next, nic);
+                }
                 set_vnet(nic, inherit);
                 allocate_addr(ot, obid, next);
                 return 0;
+            }
             set_ip6(index, nic);
+        }
         return -1;
         set_vnet(nic, inherit);
         set_allocated_addr(ot, obid, index);
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int AddressRange::allocate_by_mac(
         const string&             mac_s,
     int AddressRange::allocate_addr(
         PoolObjectSQL::ObjectType ot,
         int                       obid,
         VectorAttribute*          nic,
         const vector<string>&     inherit)
+    {
         unsigned int mac_i[2];
         unsigned int index;
         string       error_msg;
         if (mac_to_i(mac_s, mac_i) == -1)
         if ( get_used_addr() >= size )
+        {
             return -1;
+        }
         if ((mac_i[1] != mac[1]) || (mac_i[0] < mac[0]))
         if ( get_addr(index, 1, error_msg) != 0 )
+        {
             return -1;
+        }
         unsigned int index = mac_i[0] - mac[0];
         allocate_by_index(index, ot, obid, nic, inherit);
         if ((allocated.count(index) != 0) || (index >= size))
+        {
             return -1;
+        }
         return 0;
+    }
         set_mac(index, nic);
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
         if (type & 0x00000002 )
     int AddressRange::allocate_by_mac(
         const string&             mac_s,
         PoolObjectSQL::ObjectType ot,
         int                       obid,
         VectorAttribute*          nic,
         const vector<string>&     inherit)
+    {
         string error_msg;
         unsigned int index;
         if (!is_valid_mac(index, mac_s, true))
+        {
             set_ip(index, nic);
             return -1;
+        }
         if (type & 0x00000004)
         if (allocate_addr(index, 1, error_msg) != 0)
+        {
             set_ip6(index, nic);
             return -1;
+        }
         set_vnet(nic, inherit);
         allocate_addr(ot, obid, index);
         allocate_by_index(index, ot, obid, nic, inherit);
         return 0;
+    }
-...
         VectorAttribute*          nic,
         const vector<string>&     inherit)
+    {
         if (!(type & 0x00000002))//Not of type IP4 or IP4_6
+        {
             return -1;
+        }
         unsigned int ip_i;
         string error_msg;
         unsigned int index;
         if (ip_to_i(ip_s, ip_i) == -1)
         if (!is_valid_ip(index, ip_s, true))
+        {
             return -1;
+        }
         if (ip_i < ip)
         if (allocate_addr(index, 1, error_msg) != 0)
+        {
             return -1;
+        }
         unsigned int index = ip_i - ip;
         if (allocated.count(index) != 0 || index >= size )
+        {
             return -1;
+        }
         set_mac(index, nic);
         if (type & 0x00000002 )
+        {
             set_ip(index, nic);
+        }
         if (type & 0x00000004)
+        {
             set_ip6(index, nic);
+        }
         set_vnet(nic, inherit);
         allocate_addr(ot, obid, index);
         allocate_by_index(index, ot, obid, nic, inherit);
         return 0;
+    }
-...
     int AddressRange::free_addr(PoolObjectSQL::ObjectType ot, int obid,
         const string& mac_s)
+    {
         string error_msg;
         unsigned int mac_i[2];
         mac_to_i(mac_s, mac_i);
         unsigned int index = mac_i[0] - mac[0];
         if ( index < 0)
         if (index < 0 || index >= size)
+        {
             return -1;
+        }
         return free_addr(ot, obid, index);
         if (free_addr(index, error_msg) != 0)
+        {
             return -1;
+        }
         return free_allocated_addr(ot, obid, index);
+    }
     /* -------------------------------------------------------------------------- */
-...
     int AddressRange::free_addr_by_ip(PoolObjectSQL::ObjectType ot, int obid,
         const string& ip_s)
+    {
         string error_msg;
         if (!(type & 0x00000002))//Not of type IP4 or IP4_6
+        {
             return -1;
-...
         unsigned int index = ip_i - ip;
         if ((0 <= index ) && (index < size))
         if (index < 0 || index >= size)
+        {
             return -1;
+        }
         if (free_addr(index, error_msg) != 0)
+        {
             return free_addr(ot, obid, index);
             return -1;
+        }
         return -1;
         return free_allocated_addr(ot, obid, index);
+    }
     /* -------------------------------------------------------------------------- */
-...
         int freed = 0;
         string error_msg;
         while (it != allocated.end())
+        {
             if (it->second == obj_pack)
             if (it->second == obj_pack && free_addr(it->first, error_msg) == 0)
+            {
                 map<unsigned int, long long>::iterator prev_it = it++;
                 allocated.erase(prev_it);
                 used_addr--;
                 freed++;
+            }
             else
-...
         unsigned int index = mac_i[0] - mac[0];
         string error_msg;
         if ((0 <= index) && (index < size))
+        {
             map<unsigned int, long long>::iterator it = allocated.find(index);
-...
             for (unsigned int i=0; i<rsize; i++)
+            {
                 if (it != allocated.end() && it->second == obj_pack)
                 if (it != allocated.end() && it->second == obj_pack &&
                          free_addr(it->first, error_msg) == 0)
+                {
                     map<unsigned int, long long>::iterator prev_it = it++;
                     allocated.erase(prev_it);
                     used_addr--;
                     freed++;
+                }
                 else
-...
     int AddressRange::hold_by_ip(const string& ip_s)
+    {
         if (!(type & 0x00000002))//Not of type IP4 or IP4_6
+        {
             return -1;
+        }
         unsigned int ip_i;
         string error_msg;
         unsigned int index;
         if (ip_to_i(ip_s, ip_i) == -1)
         if (!is_valid_ip(index, ip_s, true))
+        {
             return -1;
+        }
         if (ip_i < ip)
+        {
             return -1;
+        }
         unsigned int index = ip_i - ip;
         if (allocated.count(index) != 0 || index >= size )
         if (allocate_addr(index, 1, error_msg) != 0)
+        {
             return -1;
+        }
         allocate_addr(PoolObjectSQL::VM, -1, index);
         set_allocated_addr(PoolObjectSQL::VM, -1, index);
         return 0;
+    }
-...
     int AddressRange::hold_by_mac(const string& mac_s)
+    {
         unsigned int mac_i[2];
         if (mac_to_i(mac_s, mac_i) == -1)
+        {
             return -1;
+        }
         unsigned int index;
         string error_msg;
         if ((mac_i[1] != mac[1]) || (mac_i[0] < mac[0]))
         if (!is_valid_mac(index, mac_s, true))
+        {
             return -1;
+        }
         unsigned int index = mac_i[0] - mac[0];
         if ((allocated.count(index) != 0) || (index >= size))
         if (allocate_addr(index, 1, error_msg) != 0)
+        {
             return -1;
+        }
         allocate_addr(PoolObjectSQL::VM, -1, index);
         set_allocated_addr(PoolObjectSQL::VM, -1, index);
         return 0;
+    }
-...
     int AddressRange::reserve_addr(int vid, unsigned int rsize, AddressRange *rar)
+    {
         unsigned int first_index;
         string error_msg;
         if (rsize > (size - used_addr))
         if (rsize > get_free_addr())
+        {
             return -1; //reservation dosen't fit
             return -1;
+        }
         // --------------- Look for a continuos range of addresses -----------------
         bool valid = true;
         for (unsigned int i=0; i<size; i++)
         if ( get_addr(first_index, rsize, error_msg) != 0 )
+        {
             if ( allocated.count(i) != 0 )
+            {
                 continue;
+            }
             valid = true;
             for (unsigned int j=0; j<rsize; j++, i++)
+            {
                 if ( allocated.count(i) != 0  || i >= size )
+                {
                     valid = false;
                     break;
+                }
+            }
             if (valid == true)
+            {
                 i -= rsize;
                 first_index = i;
                 for (unsigned int j=0; j<rsize; j++, i++)
+                {
                     allocate_addr(PoolObjectSQL::NET, vid, i);
+                }
                 break;
+            }
             return -1;
+        }
         if (valid == false)
         for (unsigned int j=0, i=first_index; j<rsize; j++, i++)
+        {
             return -1; //This address range has not a continuos range big enough
             set_allocated_addr(PoolObjectSQL::NET, vid, i);
+        }
         VectorAttribute * new_ar = attr->clone();
-...
     int AddressRange::reserve_addr_by_index(int vid, unsigned int rsize,
         unsigned int sindex, AddressRange *rar)
+    {
         string error_msg;
         /* ----------------- Allocate the new AR from sindex -------------------- */
         for (unsigned int j=sindex; j< (sindex+rsize) ; j++)
-...
+            }
+        }
         if (allocate_addr(sindex, rsize, error_msg) != 0)
+        {
             return -1;
+        }
         for (unsigned int j=sindex; j< (sindex+rsize); j++)
+        {
             allocate_addr(PoolObjectSQL::NET, vid, j);
             set_allocated_addr(PoolObjectSQL::NET, vid, j);
+        }
         /* ------------------------- Initialize the new AR ---------------------- */
-...
     int AddressRange::reserve_addr_by_ip(int vid, unsigned int rsize,
         const string& ip_s, AddressRange *rar)
+    {
         if (!(type & 0x00000002))//Not of type IP4 or IP4_6
+        {
             return -1;
+        }
         unsigned int sindex;
         unsigned int ip_i;
         if (ip_to_i(ip_s, ip_i) == -1)
+        {
             return -1;
+        }
         if (ip_i < ip)
+        {
             return -1;
+        }
         unsigned int sindex = ip_i - ip;
         if (sindex >= size )
         if (!is_valid_ip(sindex, ip_s, false))
+        {
             return -1;
+        }
-...
     int AddressRange::reserve_addr_by_mac(int vid, unsigned int rsize,
         const string& mac_s, AddressRange *rar)
+    {
         unsigned int mac_i[2];
         if (mac_to_i(mac_s, mac_i) == -1)
+        {
             return -1;
+        }
         if ((mac_i[1] != mac[1]) || (mac_i[0] < mac[0]))
+        {
             return -1;
+        }
         unsigned int sindex = mac_i[0] - mac[0];
         unsigned int sindex;
         if (sindex >= size)
         if (!is_valid_mac(sindex, mac_s, false))
+        {
             return -1;
+        }

     /* -------------------------------------------------------------------------- */
     /* Copyright 2002-2016, OpenNebula Project, OpenNebula Systems                */
     /*                                                                            */
     /* Licensed under the Apache License, Version 2.0 (the "License"); you may    */
     /* not use this file except in compliance with the License. You may obtain    */
     /* a copy of the License at                                                   */
     /*                                                                            */
     /* http://www.apache.org/licenses/LICENSE-2.0                                 */
     /*                                                                            */
     /* Unless required by applicable law or agreed to in writing, software        */
     /* distributed under the License is distributed on an "AS IS" BASIS,          */
     /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   */
     /* See the License for the specific language governing permissions and        */
     /* limitations under the License.                                             */
     /* -------------------------------------------------------------------------- */
     #include "AddressRangeInternal.h"
     int AddressRangeInternal::get_single_addr(unsigned int& index, std::string& msg)
+    {
         unsigned int ar_size = get_size();
         for ( unsigned int i=0; i<ar_size; i++, next = (next+1)%ar_size )
+        {
             if ( allocated.count(next) == 0 )
+            {
                 index = next;
                 return 0;
+            }
+        }
         msg = "Not free addresses available";
         return -1;
+    }
     int AddressRangeInternal::get_range_addr(unsigned int& index,
             unsigned int rsize, std::string& msg)
+    {
         unsigned int ar_size = get_size();
         bool valid;
         for (unsigned int i=0; i< ar_size; i++)
+        {
             if ( allocated.count(i) != 0 )
+            {
                 continue;
+            }
             valid = true;
             for (unsigned int j=0; j<rsize; j++, i++)
+            {
                 if ( allocated.count(i) != 0 || i >= ar_size )
+                {
                     valid = false;
                     break;
+                }
+            }
             if (valid == true)
+            {
                 index = i - rsize;
                 return 0;
+            }
+        }
         msg = "There isn't a continuous range big enough";
         return -1;
+    }

     #include "AddressRangePool.h"
     #include "AddressRange.h"
     #include "AddressRangeInternal.h"
     #include "AddressRangeIPAM.h"
     using namespace std;
-...
     int AddressRangePool::from_vattr(VectorAttribute* va, string& error_msg)
+    {
         AddressRange * ar = new AddressRange(next_ar);
         AddressRange * ar = allocate_ar(va->vector_value("IPAM_MAD"));
         if (ar->from_vattr(va, error_msg) != 0)
+        {
             next_ar = next_ar - 1;
             delete ar;
             return -1;
+        }
         ar_pool.insert(make_pair(next_ar++, ar));
         ar_pool.insert(make_pair(ar->ar_id(), ar));
         ar_template.set(va);
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     AddressRange * AddressRangePool::allocate_ar()
     AddressRange * AddressRangePool::allocate_ar(const string& ipam_mad)
+    {
         return allocate_ar(ipam_mad, next_ar++);
+    }
     /* -------------------------------------------------------------------------- */
     AddressRange * AddressRangePool::allocate_ar(const string& ipam_mad,
             unsigned int na)
+    {
         return new AddressRange(next_ar++);
         if ( ipam_mad.empty() || ipam_mad == "internal" )
+        {
             return new AddressRangeInternal(na);
+        }
         else
+        {
             return new AddressRangeIPAM(na);
+        }
+    }
     /* -------------------------------------------------------------------------- */
-...
         for (int i = 0; i < num_ar; i++)
+        {
             AddressRange * ar = new AddressRange(0);
             AddressRange * ar = allocate_ar((var[i])->vector_value("IPAM_MAD"), 0);
             if (ar->from_vattr_db(var[i])!= 0)
             if (ar->from_vattr_db(var[i]) != 0)
+            {
                 return -1;
+            }

src/vnm/SConstruct
25	25	'VirtualNetwork.cc',
26	26	'VirtualNetworkPool.cc',
27	27	'AddressRange.cc',
	28	'AddressRangeInternal.cc',
28	29	'AddressRangePool.cc',
29	30	'VirtualNetworkTemplate.cc'
30	31	]

             return 0;
+        }
         AddressRange *ar = rvn->allocate_ar();
         AddressRange *ar = rvn->allocate_ar("internal");
         update(rvn);

Also available in: Unified diff