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/common/bigmutex.hpp

@@ -36,7 +36,7 @@
 
 namespace openvpn {
   namespace bigmutex {
-    std::recursive_mutex the_recursive_mutex;
+    OPENVPN_EXTERN std::recursive_mutex the_recursive_mutex;
   }
   
   #ifdef OPENVPN_ENABLE_BIGMUTEX

openvpn/common/core.hpp

@@ -40,8 +40,13 @@ namespace openvpn {
 
   inline int n_cores()
   {
+    int count = std::thread::hardware_concurrency();
+    // C++11 allows thread::hardware_concurrency() to return 0, fall back
+    // to specific solution if we detect this
+    if (count > 0)
+      return count;
+
 #if defined(OPENVPN_PLATFORM_TYPE_APPLE)
-    int count;
     size_t count_len = sizeof(count);
     if (::sysctlbyname("hw.logicalcpu", &count, &count_len, NULL, 0) != 0)
       count = 1;

openvpn/common/exception.hpp

@@ -89,14 +89,14 @@ namespace openvpn {
   class C : public openvpn::Exception { \
   public: \
     C() : openvpn::Exception(#C OPENVPN_FILE_LINE) {} \
-    C(std::string err) : openvpn::Exception(#C OPENVPN_FILE_LINE ": " + err) {} \
+    C(const std::string err) : openvpn::Exception(#C OPENVPN_FILE_LINE ": " + err) {} \
   }
 
   // define a custom exception class that allows extra info, but does not emit a tag
 # define OPENVPN_UNTAGGED_EXCEPTION(C) \
   class C : public openvpn::Exception { \
   public: \
-    C(std::string err) : openvpn::Exception(err) {} \
+    C(const std::string err) : openvpn::Exception(err) {} \
   }
 
   // define a custom exception class that allows extra info, and inherits from a custom base
@@ -104,7 +104,7 @@ namespace openvpn {
   class C : public B { \
   public: \
     C() : B(#C OPENVPN_FILE_LINE) {} \
-    C(std::string err) : B(#C OPENVPN_FILE_LINE ": " + err) {} \
+    C(const std::string err) : B(#C OPENVPN_FILE_LINE ": " + err) {} \
   }
 
   // define a custom exception class that allows extra info, and inherits from a custom base,
@@ -112,7 +112,7 @@ namespace openvpn {
 # define OPENVPN_UNTAGGED_EXCEPTION_INHERIT(B, C) \
   class C : public B { \
   public: \
-    C(std::string err) : B(err) {} \
+    C(const std::string err) : B(err) {} \
   }
 
   // throw an Exception with stringstream concatenation allowed

openvpn/common/fileatomic.hpp

@@ -47,6 +47,7 @@ namespace openvpn {
   inline void write_binary_atomic(const std::string& fn,
 				  const std::string& tmpdir,
 				  const mode_t mode,
+				  const std::uint64_t mtime_ns,  // set explicit modification-time in nanoseconds since epoch, or 0 to defer to system
 				  const ConstBuffer& buf,
 				  RandomAPI& rng)
   {
@@ -56,7 +57,7 @@ namespace openvpn {
     const std::string tfn = path::join(tmpdir, '.' + path::basename(fn) + '.' + render_hex(data, sizeof(data)));
 
     // write to temporary file
-    write_binary_unix(tfn, mode, buf);
+    write_binary_unix(tfn, mode, mtime_ns, buf);
 
     // then move into position
     if (::rename(tfn.c_str(), fn.c_str()) == -1)
@@ -69,10 +70,11 @@ namespace openvpn {
   inline void write_binary_atomic(const std::string& fn,
 				  const std::string& tmpdir,
 				  const mode_t mode,
+				  const std::uint64_t mtime_ns,
 				  const Buffer& buf,
 				  RandomAPI& rng)
   {
-    return write_binary_atomic(fn, tmpdir, mode, const_buffer_ref(buf), rng);
+    return write_binary_atomic(fn, tmpdir, mode, mtime_ns, const_buffer_ref(buf), rng);
   }
 }
 

openvpn/common/fileunix.hpp

@@ -35,12 +35,14 @@
 #include <sys/types.h> // for lseek, open
 #include <sys/stat.h>  // for open
 #include <fcntl.h>     // for open
+#include <cstdint>
 
 #include <openvpn/common/exception.hpp>
 #include <openvpn/common/size.hpp>
 #include <openvpn/common/scoped_fd.hpp>
 #include <openvpn/common/write.hpp>
 #include <openvpn/common/strerror.hpp>
+#include <openvpn/common/modstat.hpp>
 #include <openvpn/buffer/bufread.hpp>
 
 namespace openvpn {
@@ -49,6 +51,7 @@ namespace openvpn {
   // write binary buffer to file
   inline void write_binary_unix(const std::string& fn,
 				const mode_t mode,
+				const std::uint64_t mtime_ns,  // set explicit modification-time in nanoseconds since epoch, or 0 to defer to system
 				const void *buf,
 				const size_t size)
   {
@@ -61,11 +64,16 @@ namespace openvpn {
       }
 
     // write
-    {
-      const ssize_t len = write_retry(fd(), buf, size);
-      if (len != size)
-	throw file_unix_error(fn + " : incomplete write");
-    }
+    if (size)
+      {
+	const ssize_t len = write_retry(fd(), buf, size);
+	if (len != size)
+	  throw file_unix_error(fn + " : incomplete write");
+      }
+
+    // explicit modification time
+    if (mtime_ns)
+      update_file_mod_time_nanoseconds(fd(), mtime_ns);
 
     // close
     {
@@ -77,23 +85,26 @@ namespace openvpn {
 
   inline void write_binary_unix(const std::string& fn,
 				const mode_t mode,
+				const std::uint64_t mtime_ns,
 				const Buffer& buf)
   {
-    write_binary_unix(fn, mode, buf.c_data(), buf.size());
+    write_binary_unix(fn, mode, mtime_ns, buf.c_data(), buf.size());
   }
 
   inline void write_binary_unix(const std::string& fn,
 				const mode_t mode,
+				const std::uint64_t mtime_ns,
 				const ConstBuffer& buf)
   {
-    write_binary_unix(fn, mode, buf.c_data(), buf.size());
+    write_binary_unix(fn, mode, mtime_ns, buf.c_data(), buf.size());
   }
 
   inline void write_text_unix(const std::string& fn,
 			      const mode_t mode,
+			      const std::uint64_t mtime_ns,
 			      const std::string& content)
   {
-    write_binary_unix(fn, mode, content.c_str(), content.length());
+    write_binary_unix(fn, mode, mtime_ns, content.c_str(), content.length());
   }
 
   enum { // MUST be distinct from BufferAllocated flags

openvpn/common/function.hpp

@@ -26,6 +26,7 @@
 
 #include <cstddef>  // for std::size_t
 #include <utility>  // for std::move
+#include <type_traits>
 #include <new>
 
 namespace openvpn {
@@ -35,7 +36,7 @@ namespace openvpn {
   template <typename F, std::size_t N=3, bool INTERN_ONLY=false>
   class Function;
 
-  template <typename R, typename ... A, std::size_t N, bool INTERN_ONLY>
+  template <typename R, typename... A, std::size_t N, bool INTERN_ONLY>
   class Function<R(A...), N, INTERN_ONLY>
   {
   public:
@@ -92,7 +93,7 @@ namespace openvpn {
 	}
     }
 
-    R operator()(A... args)
+    R operator()(A... args) const
     {
       return methods->invoke(data, std::forward<A>(args)...);
     }
@@ -103,6 +104,7 @@ namespace openvpn {
     }
 
   private:
+#ifdef _MSC_VER
     template <typename T>
     void construct(T&& functor) noexcept
     {
@@ -123,10 +125,38 @@ namespace openvpn {
 	  new (data) Extern<T>(std::move(functor));
 	}
     }
+#else
+    template <typename T>
+    static constexpr bool is_intern()
+    {
+      return sizeof(Intern<T>) <= sizeof(data);
+    }
+
+    template <typename T,
+	      typename std::enable_if<is_intern<T>(), int>::type = 0>
+    void construct(T&& functor) noexcept
+    {
+      // store functor internally (in data)
+      setup_methods_intern<T>();
+      new (data) Intern<T>(std::move(functor));
+    }
+
+    template <typename T,
+	      typename std::enable_if<!is_intern<T>(), int>::type = 0>
+    void construct(T&& functor) noexcept
+    {
+      static_assert(!INTERN_ONLY, "Function: Intern<T> doesn't fit in data[] and INTERN_ONLY=true");
+      static_assert(sizeof(Extern<T>) <= sizeof(data), "Function: Extern<T> doesn't fit in data[]");
+
+      // store functor externally (using new)
+      setup_methods_extern<T>();
+      new (data) Extern<T>(std::move(functor));
+    }
+#endif
 
     struct Methods
     {
-      R (*invoke)(void *, A...);
+      R (*invoke)(void *, A&&...);
       void (*move)(void *, void *);
       void (*destruct)(void *);
     };
@@ -163,21 +193,21 @@ namespace openvpn {
       {
       }
 
-      static R invoke(void *ptr, A... args)
+      static R invoke(void* ptr, A&&... args)
       {
-	Intern* self = reinterpret_cast<Intern<T>*>(ptr);
+	Intern* self = reinterpret_cast<Intern*>(ptr);
 	return self->functor_(std::forward<A>(args)...);
       }
 
       static void move(void *dest, void *src)
       {
-	Intern* s = reinterpret_cast<Intern<T>*>(src);
+	Intern* s = reinterpret_cast<Intern*>(src);
 	new (dest) Intern(std::move(*s));
       }
 
       static void destruct(void *ptr)
       {
-	Intern* self = reinterpret_cast<Intern<T>*>(ptr);
+	Intern* self = reinterpret_cast<Intern*>(ptr);
 	self->~Intern();
       }
 
@@ -195,23 +225,23 @@ namespace openvpn {
       {
       }
 
-      static R invoke(void *ptr, A... args)
+      static R invoke(void* ptr, A&&... args)
       {
-	Extern* self = reinterpret_cast<Extern<T>*>(ptr);
+	Extern* self = reinterpret_cast<Extern *>(ptr);
 	return (*self->functor_)(std::forward<A>(args)...);
       }
 
       static void move(void *dest, void *src)
       {
-	Extern* d = reinterpret_cast<Extern<T>*>(dest);
-	Extern* s = reinterpret_cast<Extern<T>*>(src);
+	Extern* d = reinterpret_cast<Extern*>(dest);
+	Extern* s = reinterpret_cast<Extern*>(src);
 	d->functor_ = s->functor_;
 	// no need to set s->functor_=nullptr because parent will not destruct src after move
       }
 
       static void destruct(void *ptr)
       {
-	Extern* self = reinterpret_cast<Extern<T>*>(ptr);
+	Extern* self = reinterpret_cast<Extern*>(ptr);
 	delete self->functor_;
       }
 
@@ -220,7 +250,7 @@ namespace openvpn {
     };
 
     const Methods* methods;
-    void* data[N];
+    mutable void* data[N];
   };
 }
 

openvpn/common/hexstr.hpp

@@ -461,7 +461,7 @@ namespace openvpn {
    *          of the input value.  The result will always contain only
    *          two characters.
    */
-  std::string render_hex_number(unsigned char uc, const bool caps=false)
+  inline std::string render_hex_number(unsigned char uc, const bool caps=false)
   {
     RenderHexByte b(uc, caps);
     return std::string(b.str2(), 2);

openvpn/common/modstat.hpp

@@ -0,0 +1,57 @@
+//    OpenVPN -- An application to securely tunnel IP networks
+//               over a single port, with support for SSL/TLS-based
+//               session authentication and key exchange,
+//               packet encryption, packet authentication, and
+//               packet compression.
+//
+//    Copyright (C) 2012-2017 OpenVPN Inc.
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU Affero General Public License Version 3
+//    as published by the Free Software Foundation.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU Affero General Public License for more details.
+//
+//    You should have received a copy of the GNU Affero General Public License
+//    along with this program in the COPYING file.
+//    If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <fcntl.h>         // Definition of AT_* constants */
+#include <sys/stat.h>
+#include <cstdint>         // for std::uint64_t
+#include <cerrno>
+
+#include <string>
+
+namespace openvpn {
+
+  inline int update_file_mod_time_nanoseconds(const std::string& filename,
+					      const std::uint64_t nanoseconds_since_epooch)
+  {
+    struct timespec times[2];
+    times[0].tv_sec = nanoseconds_since_epooch / std::uint64_t(1000000000);
+    times[0].tv_nsec = nanoseconds_since_epooch % std::uint64_t(1000000000);
+    times[1] = times[0];
+    if (::utimensat(AT_FDCWD, filename.c_str(), times, 0) == -1)
+      return errno;
+    return 0;
+  }
+
+  inline int update_file_mod_time_nanoseconds(const int fd,
+					      const std::uint64_t nanoseconds_since_epooch)
+  {
+    struct timespec times[2];
+    times[0].tv_sec = nanoseconds_since_epooch / std::uint64_t(1000000000);
+    times[0].tv_nsec = nanoseconds_since_epooch % std::uint64_t(1000000000);
+    times[1] = times[0];
+    if (::futimens(fd, times) == -1)
+      return errno;
+    return 0;
+  }
+
+}

openvpn/common/option_error.hpp

@@ -0,0 +1,30 @@
+//    OpenVPN -- An application to securely tunnel IP networks
+//               over a single port, with support for SSL/TLS-based
+//               session authentication and key exchange,
+//               packet encryption, packet authentication, and
+//               packet compression.
+//
+//    Copyright (C) 2012-2018 OpenVPN Inc.
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU Affero General Public License Version 3
+//    as published by the Free Software Foundation.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU Affero General Public License for more details.
+//
+//    You should have received a copy of the GNU Affero General Public License
+//    along with this program in the COPYING file.
+//    If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <openvpn/common/exception.hpp>
+
+namespace openvpn {
+
+  OPENVPN_EXCEPTION(option_error);
+
+}

openvpn/common/options.hpp

@@ -57,7 +57,6 @@
 #include <cstdint>     // for std::uint64_t
 
 #include <openvpn/common/rc.hpp>
-#include <openvpn/common/exception.hpp>
 #include <openvpn/common/size.hpp>
 #include <openvpn/common/number.hpp>
 #include <openvpn/common/hexstr.hpp>
@@ -65,11 +64,10 @@
 #include <openvpn/common/split.hpp>
 #include <openvpn/common/splitlines.hpp>
 #include <openvpn/common/unicode.hpp>
+#include <openvpn/common/option_error.hpp>
 
 namespace openvpn {
 
-  OPENVPN_EXCEPTION(option_error);
-
   class Option
   {
   public:
@@ -1173,6 +1171,16 @@ namespace openvpn {
 	}
     }
 
+    // Return raw C string to option data or nullptr if option doesn't exist.
+    const char *get_c_str(const std::string& name, size_t index, const size_t max_len) const
+    {
+      const Option* o = get_ptr(name);
+      if (o)
+	return o->get(index, max_len).c_str();
+      else
+	return nullptr;
+    }
+
     // Convenience method that gets a particular argument index within an option,
     // while returning a default string if option doesn't exist, and raising an
     // exception if argument index is out-of-bounds.

openvpn/common/strerror.hpp

@@ -25,6 +25,8 @@
 #include <string.h>
 #include <string>
 
+#include <errno.h>
+
 namespace openvpn {
   inline std::string strerror_str(const int errnum)
   {

openvpn/common/string.hpp

@@ -223,7 +223,7 @@ namespace openvpn {
     }
 
     // return the first line (without newline) of a multi-line string
-    std::string first_line(const std::string& str)
+    inline std::string first_line(const std::string& str)
     {
       const size_t pos = str.find_first_of('\n');
       if (pos != std::string::npos)
@@ -310,6 +310,19 @@ namespace openvpn {
       return false;
     }
 
+    // remove all spaces in string
+    inline std::string remove_spaces(const std::string& str)
+    {
+      std::string ret;
+      for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
+	{
+	  char c = *i;
+	  if (!is_space(c))
+	    ret += c;
+	}
+      return ret;
+    }
+
     // replace all spaces in string with rep
     inline std::string replace_spaces(const std::string& str, const char rep)
     {