Merge commit '86cc97e55fe346502462284d2e636a2b3708163e' as 'Sources/OpenVPN3'

Sources/OpenVPN3/openvpn/ip/csum.hpp

@@ -0,0 +1,171 @@
+//    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/>.
+
+// IP checksum based on Linux kernel implementation
+
+#pragma once
+
+#include <cstdint>
+
+#include <openvpn/common/endian.hpp>
+#include <openvpn/common/socktypes.hpp>
+#include <openvpn/common/size.hpp>
+
+namespace openvpn {
+  namespace IPChecksum {
+
+    inline std::uint16_t fold(std::uint32_t sum)
+    {
+      sum = (sum >> 16) + (sum & 0xffff);
+      sum += (sum >> 16);
+      return sum;
+    }
+
+    inline std::uint16_t cfold(const std::uint32_t sum)
+    {
+      return ~fold(sum);
+    }
+
+    inline std::uint32_t unfold(const std::uint16_t sum)
+    {
+      return sum;
+    }
+
+    inline std::uint32_t cunfold(const std::uint16_t sum)
+    {
+      return ~unfold(sum);
+    }
+
+    inline std::uint32_t compute(const std::uint8_t *buf, size_t len)
+    {
+      std::uint32_t result = 0;
+
+      if (!len)
+	return 0;
+
+      const bool odd = size_t(buf) & 1;
+      if (odd)
+	{
+#ifdef OPENVPN_LITTLE_ENDIAN
+	  result += (*buf << 8);
+#else
+	  result = *buf;
+#endif
+	  len--;
+	  buf++;
+	}
+
+      if (len >= 2)
+	{
+	  if (size_t(buf) & 2)
+	    {
+	      result += *(std::uint16_t *)buf;
+	      len -= 2;
+	      buf += 2;
+	    }
+	  if (len >= 4)
+	    {
+	      const uint8_t *end = buf + (len & ~3);
+	      std::uint32_t carry = 0;
+	      do {
+		std::uint32_t w = *(std::uint32_t *)buf;
+		buf += 4;
+		result += carry;
+		result += w;
+		carry = (w > result);
+	      } while (buf < end);
+	      result += carry;
+	      result = (result & 0xffff) + (result >> 16);
+	    }
+	  if (len & 2)
+	    {
+	      result += *(std::uint16_t *)buf;
+	      buf += 2;
+	    }
+	}
+      if (len & 1)
+	{
+#ifdef OPENVPN_LITTLE_ENDIAN
+	  result += *buf;
+#else
+	  result += (*buf << 8);
+#endif
+	}
+      result = fold(result);
+      if (odd)
+	result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
+      return result;
+    }
+
+    inline std::uint32_t compute(const void *buf, const size_t len)
+    {
+      return compute((const std::uint8_t *)buf, len);
+    }
+
+    inline std::uint32_t partial(const void *buf, const size_t len, const std::uint32_t sum)
+    {
+      std::uint32_t result = compute(buf, len);
+
+      /* add in old sum, and carry.. */
+      result += sum;
+      if (sum > result)
+	result += 1;
+      return result;
+    }
+
+    inline std::uint32_t diff16(const std::uint32_t *old,
+				const std::uint32_t *new_,
+				const std::uint32_t oldsum)
+    {
+      std::uint32_t diff[8] = { ~old[0], ~old[1], ~old[2], ~old[3],
+				new_[0],  new_[1],  new_[2],  new_[3] };
+      return partial(diff, sizeof(diff), oldsum);
+    }
+
+    inline std::uint32_t diff16(const std::uint8_t *old,
+				const std::uint8_t *new_,
+				const std::uint32_t oldsum)
+    {
+      return diff16((const std::uint32_t *)old, (const std::uint32_t *)new_, oldsum);
+    }
+
+    inline std::uint32_t diff4(const std::uint32_t old,
+			       const std::uint32_t new_,
+			       const std::uint32_t oldsum)
+    {
+      std::uint32_t diff[2] = { ~old, new_ };
+      return partial(diff, sizeof(diff), oldsum);
+    }
+
+    inline std::uint32_t diff2(const std::uint16_t old,
+			       const std::uint16_t new_,
+			       const std::uint32_t oldsum)
+    {
+      std::uint16_t diff[2] = { std::uint16_t(~old), new_ };
+      return partial(diff, sizeof(diff), oldsum);
+    }
+
+    inline std::uint16_t checksum(const void *data, const size_t size)
+    {
+      return cfold(compute(data, size));
+    }
+  }
+}