rgw_cksum: add 64bit and 32bit crc constructions from crcany

These constructions provide conforming implemenations of Amazon
S3 CRC32 (ISO hdlc), CRC32C (iscsi), and CRC64/NVME checksums,
in particular, linear combining of adjacent checksums, by
Mark Adler.

Source: https://github.com/madler/crcany
License: approximate BSD with "optional" advertising clause

Signed-off-by: Matt Benjamin <[email protected]>

Author: mattbenjamin

src/rgw/madler/LICENSE

@@ -0,0 +1,20 @@
+  Copyright (C) 2014-2025 Mark Adler
+
+  This software is provided 'as-is', without any express or implied warranty.
+  In no event will the authors be held liable for any damages arising from the
+  use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not claim
+     that you wrote the original software. If you use this software in a
+     product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler
+  [email protected]

src/rgw/madler/crc32iscsi.c

@@ -0,0 +1,27 @@
+// The _bit, _byte, and _word routines return the CRC of the len
+// bytes at mem, applied to the previous CRC value, crc. If mem is
+// NULL, then the other arguments are ignored, and the initial CRC,
+// i.e. the CRC of zero bytes, is returned. Those routines will all
+// return the same result, differing only in speed and code
+// complexity. The _rem routine returns the CRC of the remaining
+// bits in the last byte, for when the number of bits in the
+// message is not a multiple of eight. The low bits bits of the low
+// byte of val are applied to crc. bits must be in 0..8.
+
+#include <stddef.h>
+#include <stdint.h>
+
+// Compute the CRC a bit at a time.
+uint32_t crc32iscsi_bit(uint32_t crc, void const *mem, size_t len);
+
+// Compute the CRC of the low bits bits in val.
+uint32_t crc32iscsi_rem(uint32_t crc, unsigned val, unsigned bits);
+
+// Compute the CRC a byte at a time.
+uint32_t crc32iscsi_byte(uint32_t crc, void const *mem, size_t len);
+
+// Compute the CRC a word at a time.
+uint32_t crc32iscsi_word(uint32_t crc, void const *mem, size_t len);
+
+// Compute the combination of two CRCs.
+uint32_t crc32iscsi_comb(uint32_t crc1, uint32_t crc2, uintmax_t len2);

src/rgw/madler/crc32iscsi.h

@@ -0,0 +1,27 @@
+// The _bit, _byte, and _word routines return the CRC of the len
+// bytes at mem, applied to the previous CRC value, crc. If mem is
+// NULL, then the other arguments are ignored, and the initial CRC,
+// i.e. the CRC of zero bytes, is returned. Those routines will all
+// return the same result, differing only in speed and code
+// complexity. The _rem routine returns the CRC of the remaining
+// bits in the last byte, for when the number of bits in the
+// message is not a multiple of eight. The low bits bits of the low
+// byte of val are applied to crc. bits must be in 0..8.
+
+#include <stddef.h>
+#include <stdint.h>
+
+// Compute the CRC a bit at a time.
+uint32_t crc32iso_hdlc_bit(uint32_t crc, void const *mem, size_t len);
+
+// Compute the CRC of the low bits bits in val.
+uint32_t crc32iso_hdlc_rem(uint32_t crc, unsigned val, unsigned bits);
+
+// Compute the CRC a byte at a time.
+uint32_t crc32iso_hdlc_byte(uint32_t crc, void const *mem, size_t len);
+
+// Compute the CRC a word at a time.
+uint32_t crc32iso_hdlc_word(uint32_t crc, void const *mem, size_t len);
+
+// Compute the combination of two CRCs.
+uint32_t crc32iso_hdlc_comb(uint32_t crc1, uint32_t crc2, uintmax_t len2);

src/rgw/madler/crc32iso_hdlc.c

@@ -0,0 +1,27 @@
+// The _bit, _byte, and _word routines return the CRC of the len
+// bytes at mem, applied to the previous CRC value, crc. If mem is
+// NULL, then the other arguments are ignored, and the initial CRC,
+// i.e. the CRC of zero bytes, is returned. Those routines will all
+// return the same result, differing only in speed and code
+// complexity. The _rem routine returns the CRC of the remaining
+// bits in the last byte, for when the number of bits in the
+// message is not a multiple of eight. The low bits bits of the low
+// byte of val are applied to crc. bits must be in 0..8.
+
+#include <stddef.h>
+#include <stdint.h>
+
+// Compute the CRC a bit at a time.
+uint64_t crc64nvme_bit(uint64_t crc, void const *mem, size_t len);
+
+// Compute the CRC of the low bits bits in val.
+uint64_t crc64nvme_rem(uint64_t crc, unsigned val, unsigned bits);
+
+// Compute the CRC a byte at a time.
+uint64_t crc64nvme_byte(uint64_t crc, void const *mem, size_t len);
+
+// Compute the CRC a word at a time.
+uint64_t crc64nvme_word(uint64_t crc, void const *mem, size_t len);
+
+// Compute the combination of two CRCs.
+uint64_t crc64nvme_comb(uint64_t crc1, uint64_t crc2, uintmax_t len2);