Squashed 'Sources/OpenVPNAdapter/Libraries/Vendors/openvpn/' changes from 554d8b888..cc90cde57

cc90cde57 win: use 'MSVC 2017 Professional' as default compiler
4b072bce1 [OVPN3-311] function.hpp: fix Windows build
48b9b78de [OVPN3-310] logging: fix 'OPENVPN_LOG_NTNL': identifier not found
5a4a87552 cosmetics: helper function to check registry errors
fc52fd8a5 [OC-78] proxy: support PROXY_AUTO_CONFIG_URL on Windows
f5178cff9 [OC-77] proxy: refactor proxy settings code
18e50ec3f ReplyParser: added undefined status
8178ae06f unix file utils: added update_file_mod_time_nanoseconds()
8f20f7693 build: use LZ4_SYS=1 default when target is Linux
4bd996e61 timestr: added date_time_utc() and nanosec_time_to_string()
0eaa2586f string: added remove_spaces() method
d47ae03cc OptionList: added get_c_str() method
1eb9cd657 unix file utils: added mtime_ns parameter to write_binary_unix() and write_binary_atomic()
bf00c6e3e Time::delta_str(): use "INF" to denote infinite time
0e598a87b kovpn.hpp: asio must be included before sys/ and linux/ headers to avoid redefinition conflicts
1d2ce460d BufferType: added read_alloc_buf() method
148ae6085 BufferType: added reset_offset() method
6218ed618 Factor out IP::random_addr_v4() and IP::random_addr_v6() from IP::random_addr().
5468670b9 pool: minor changes
36a885a82 route: allow for specialized IPv4/v6 RouteType
5e29e6628 BufferType: added typedef T value_type
d92021c99 strerror.hpp: added #include <errno.h> for benefit of users
363cbece3 Function: misc cleanup
d88435ecd IP::Route: added defined() method
3371cb745 kovpn.hpp: fix centos build with DCO enabled
dc9e48d98 Fix bug in macos tunnel interface setup. Second ip address should be gateway address
bcdb27993 Merged in schwabe/fix_clang_warnings (pull request #25)
ede5e90ff Merged in schabe/fix_swig_ipadr (pull request #27)
c0d580d24 Merged in schwabe/fix_openvpn_extern (pull request #26)
0965882e5 Merged in schwabe/stats_morecpus (pull request #23)
5f1f8470b Revert bugfix for not compiling IA32 ASM of 2.7.5
bde2c41be dep: switch from mbeTLS 2.7.0 to 2.7.5
9d06b5c97 [OC-77] proxy: support PROXY_AUTO_CONFIG_URL on macOS
3f2ad8e8c Hide const std::string IP methods from SWIG
ba264862a Send also kovpn statistics of CPU Cores >= 16 via status message
2991d38b3 Fix warnings reported by LLVM/Clang
02d2a7975 Fix multiple inclusion of OpenVPN3 header with OPENPVN_EXTERN

git-subtree-dir: Sources/OpenVPNAdapter/Libraries/Vendors/openvpn
git-subtree-split: cc90cde5769dcf9e13fdd9e85d6d0857963dabce

openvpn/addr/ip.hpp

@@ -78,10 +78,16 @@ namespace openvpn {
       {
       }
 
+#ifndef SWIGPYTHON
+      // When calling IP:Addr with None as the second parameter, Swig will
+      // always pick this function and complain about not being able to convert
+      // a null pointer to a const std::string reference. Hide this function, so
+      // swig is forced to take the const char* variant of this function instead
       Addr(const std::string& ipstr, const std::string& title, Version required_version = UNSPEC)
 	: Addr(from_string(ipstr, title.c_str(), required_version))
       {
       }
+#endif
 
       void validate_version(const char *title, Version required_version) const
       {
@@ -89,10 +95,12 @@ namespace openvpn {
 	  throw ip_exception(internal::format_error(to_string(), title, version_string_static(required_version), "wrong IP version"));
       }
 
+#ifndef SWIGPYTHON
       void validate_version(const std::string& title, Version required_version) const
       {
 	validate_version(title.c_str(), required_version);
       }
+#endif
 
       static std::string validate(const std::string& ipstr, const char *title = nullptr, Version required_version = UNSPEC)
       {
@@ -100,10 +108,12 @@ namespace openvpn {
 	return a.to_string();
       }
 
+#ifndef SWIGPYTHON
       static std::string validate(const std::string& ipstr, const std::string& title, Version required_version = UNSPEC)
       {
 	return validate(ipstr, title.c_str(), required_version);
       }
+#endif
 
       static bool is_valid(const std::string& ipstr)
       {

openvpn/addr/ipv4.hpp

@@ -58,6 +58,11 @@ namespace openvpn {
       typedef std::uint32_t base_type;
       typedef std::int32_t signed_base_type;
 
+      bool defined() const
+      {
+	return true;
+      }
+
       static Addr from_addr(const Addr& addr)
       {
 	return addr;
@@ -498,6 +503,15 @@ namespace openvpn {
 	h(u.addr);
       }
 
+#ifdef HAVE_CITYHASH
+      std::size_t hashval() const
+      {
+	HashSizeT h;
+	hash(h);
+	return h.value();
+      }
+#endif
+
 #ifdef OPENVPN_IP_IMMUTABLE
     private:
 #endif
@@ -566,4 +580,8 @@ namespace openvpn {
   }
 }
 
+#ifdef HAVE_CITYHASH
+OPENVPN_HASH_METHOD(openvpn::IPv4::Addr, hashval);
+#endif
+
 #endif // OPENVPN_ADDR_IPV4_H

openvpn/addr/ipv6.hpp

@@ -55,6 +55,11 @@ namespace openvpn {
     public:
       enum { SIZE=128 };
 
+      bool defined() const
+      {
+	return true;
+      }
+
       static Addr from_addr(const Addr& addr)
       {
 	return addr;
@@ -540,6 +545,15 @@ namespace openvpn {
 	h(u.bytes, sizeof(u.bytes));
       }
 
+#ifdef HAVE_CITYHASH
+      std::size_t hashval() const
+      {
+	HashSizeT h;
+	hash(h);
+	return h.value();
+      }
+#endif
+
 #ifdef OPENVPN_IP_IMMUTABLE
     private:
 #endif
@@ -825,4 +839,8 @@ namespace openvpn {
   }
 }
 
+#ifdef HAVE_CITYHASH
+OPENVPN_HASH_METHOD(openvpn::IPv6::Addr, hashval);
+#endif
+
 #endif // OPENVPN_ADDR_IPV6_H

openvpn/addr/pool.hpp

@@ -47,7 +47,7 @@ namespace openvpn {
       // Add range of addresses to pool (pool will own the addresses).
       void add_range(const RangeType<ADDR>& range)
       {
-	typename RangeType<ADDR>::Iterator iter = range.iterator();
+	auto iter = range.iterator();
 	while (iter.more())
 	  {
 	    const ADDR& a = iter.addr();
@@ -59,7 +59,7 @@ namespace openvpn {
       // Add single address to pool (pool will own the address).
       void add_addr(const ADDR& addr)
       {
-	typename std::unordered_map<ADDR, bool>::const_iterator e = map.find(addr);
+	auto e = map.find(addr);
 	if (e == map.end())
 	  {
 	    freelist.push_back(addr);
@@ -73,16 +73,23 @@ namespace openvpn {
 	return map.size() - freelist.size();
       }
 
+      // Return number of pool addresses currently in use.
+      size_t n_free() const
+      {
+	return freelist.size();
+      }
+
       // Acquire an address from pool.  Returns true if successful,
       // with address placed in dest, or false if pool depleted.
       bool acquire_addr(ADDR& dest)
       {
 	while (true)
 	  {
+	    freelist_fill();
 	    if (freelist.empty())
 	      return false;
 	    const ADDR& a = freelist.front();
-	    typename std::unordered_map<ADDR, bool>::iterator e = map.find(a);
+	    auto e = map.find(a);
 	    if (e == map.end()) // any address in freelist must exist in map
 	      throw Exception("PoolType: address in freelist doesn't exist in map");
 	    if (!e->second)
@@ -100,7 +107,7 @@ namespace openvpn {
       // successful, or false if the address is not available.
       bool acquire_specific_addr(const ADDR& addr)
       {
-	typename std::unordered_map<ADDR, bool>::iterator e = map.find(addr);
+	auto e = map.find(addr);
 	if (e != map.end() && !e->second)
 	  {
 	    e->second = true;
@@ -115,7 +122,7 @@ namespace openvpn {
       // (b) the address is not owned by the pool.
       void release_addr(const ADDR& addr)
       {
-	typename std::unordered_map<ADDR, bool>::iterator e = map.find(addr);
+	auto e = map.find(addr);
 	if (e != map.end() && e->second)
 	  {
 	    freelist.push_back(addr);
@@ -126,6 +133,25 @@ namespace openvpn {
       // DEBUGGING -- get the map load factor
       float load_factor() const { return map.load_factor(); }
 
+      // Override to refill freelist on demand
+      virtual void freelist_fill()
+      {
+      }
+
+      std::string to_string() const
+      {
+	std::string ret;
+	for (const auto& e : map)
+	  {
+	    if (e.second)
+	      {
+		ret += e.first.to_string();
+		ret += '\n';
+	      }
+	  }
+	return ret;
+      }
+
     private:
       std::deque<ADDR> freelist;
       std::unordered_map<ADDR, bool> map;

openvpn/addr/randaddr.hpp

@@ -28,18 +28,26 @@
 namespace openvpn {
   namespace IP {
 
+    inline IPv4::Addr random_addr_v4(RandomAPI& prng)
+    {
+      return IPv4::Addr::from_uint32(prng.rand_get<std::uint32_t>());
+    }
+
+    inline IPv6::Addr random_addr_v6(RandomAPI& prng)
+    {
+      unsigned char bytes[16];
+      prng.rand_fill(bytes);
+      return IPv6::Addr::from_byte_string(bytes);
+    }
+
     inline Addr random_addr(const Addr::Version v, RandomAPI& prng)
     {
       switch (v)
 	{
 	case Addr::V4:
-	  return Addr::from_ipv4(IPv4::Addr::from_uint32(prng.rand_get<std::uint32_t>()));
+	  return Addr::from_ipv4(random_addr_v4(prng));
 	case Addr::V6:
-	  {
-	    unsigned char bytes[16];
-	    prng.rand_fill(bytes);
-	    return Addr::from_ipv6(IPv6::Addr::from_byte_string(bytes));
-	  }
+	  return Addr::from_ipv6(random_addr_v6(prng));
 	default:
 	  throw ip_exception("address unspecified");
 	}

openvpn/addr/route.hpp

@@ -40,8 +40,9 @@ namespace openvpn {
   namespace IP {
     // Basic route object
     template <typename ADDR>
-    struct RouteType
+    class RouteType
     {
+    public:
       typedef ADDR Addr;
 
       ADDR addr;
@@ -89,6 +90,11 @@ namespace openvpn {
 	return r;
       }
 
+      bool defined() const
+      {
+	return addr.defined();
+      }
+
       IP::Addr::Version version() const
       {
 	return addr.version();
@@ -99,9 +105,19 @@ namespace openvpn {
 	return addr.version_mask();
       }
 
+      RouteType<IPv4::Addr> to_ipv4() const
+      {
+	return RouteType<IPv4::Addr>(addr.to_ipv4(), prefix_len);
+      }
+
+      RouteType<IPv6::Addr> to_ipv6() const
+      {
+	return RouteType<IPv6::Addr>(addr.to_ipv6(), prefix_len);
+      }
+
       ADDR netmask() const
       {
-	return ADDR::netmask_from_prefix_len(version(), prefix_len);
+	return netmask_(addr, prefix_len);
       }
 
       size_t extent() const
@@ -119,6 +135,12 @@ namespace openvpn {
 	addr = addr & netmask();
       }
 
+      void verify_canonical() const
+      {
+	  if (!is_canonical())
+	    throw route_error("route not canonical: " + to_string());
+      }
+
       bool is_host() const
       {
 	return addr.defined() && prefix_len == addr.size();
@@ -134,7 +156,7 @@ namespace openvpn {
 
       bool contains(const ADDR& a) const // assumes canonical address/routes
       {
-	if (addr.defined() && addr.version() == a.version())
+	if (addr.defined() && version_eq(addr, a))
 	  return (a & netmask()) == addr;
 	else
 	  return false;
@@ -153,7 +175,7 @@ namespace openvpn {
 	    r1.addr = addr;
 	    r1.prefix_len = newpl;
 
-	    r2.addr = addr + ADDR::netmask_from_prefix_len(addr.version(), newpl).extent_from_netmask();
+	    r2.addr = addr + netmask_(addr, newpl).extent_from_netmask();
 	    r2.prefix_len = newpl;
 
 	    return true;
@@ -201,6 +223,37 @@ namespace openvpn {
 	return h.value();
       }
 #endif
+
+    private:
+      static IPv4::Addr netmask_(const IPv4::Addr&, unsigned int prefix_len)
+      {
+	return IPv4::Addr::netmask_from_prefix_len(prefix_len);
+      }
+
+      static IPv6::Addr netmask_(const IPv6::Addr&, unsigned int prefix_len)
+      {
+	return IPv6::Addr::netmask_from_prefix_len(prefix_len);
+      }
+
+      static IP::Addr netmask_(const IP::Addr& addr, unsigned int prefix_len)
+      {
+	return IP::Addr::netmask_from_prefix_len(addr.version(), prefix_len);
+      }
+
+      static bool version_eq(const IPv4::Addr&, const IPv4::Addr&)
+      {
+	return true;
+      }
+
+      static bool version_eq(const IPv6::Addr&, const IPv6::Addr&)
+      {
+	return true;
+      }
+
+      static bool version_eq(const IP::Addr& a1, const IP::Addr& a2)
+      {
+	return a1.version() == a2.version();
+      }
     };
 
     template <typename ADDR>
@@ -229,8 +282,7 @@ namespace openvpn {
       void verify_canonical() const
       {
 	for (auto &r : *this)
-	  if (!r.is_canonical())
-	    throw route_list_error("route not canonical: " + r.to_string());
+	  r.verify_canonical();
       }
 
       template <typename R>