[SCM] The rsync repository. - branch master updated
Rsync CVS commit messages
rsync-cvs at lists.samba.org
Mon Apr 8 19:54:17 UTC 2024
The branch, master has been updated
via 7bc3be2b CI: fixed rules for when to trigger
via 411c4789 support: added install_deps_ubuntu.sh
via 231b239f check for stpcpy
via 4c8683c8 update to popt 1.19
via 85c906f9 Silence unused var warning
via 35f5a21a hint that a proxy can handle plain and ssl stream at the same time
via 99673f93 CI: added FreeBSD build
via 9505ac59 removed old cirrus CI
via 0dd25d47 configure.ac: fix failing IPv6 check due to missing return type
from ae3e13ba Update github links.
https://git.samba.org/?p=rsync.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit 7bc3be2b9e32cf95ce9d67c6227a8e5367d0b8ad
Author: Andrew Tridgell <andrew at tridgell.net>
Date: Mon Apr 8 15:35:42 2024 +1000
CI: fixed rules for when to trigger
commit 411c4789dfb2561d3400a5f8282f5f1bab76eeae
Author: Andrew Tridgell <andrew at tridgell.net>
Date: Mon Apr 8 10:16:31 2024 +1000
support: added install_deps_ubuntu.sh
convenient way to bootstrap quickly
commit 231b239f304fb2daa1240eec567880d225b7f730
Author: Andrew Tridgell <andrew at tridgell.net>
Date: Mon Apr 8 13:40:58 2024 +1000
check for stpcpy
needed for popt on macos
commit 4c8683c8753f2493ef13c3425fb5847960a6e305
Author: Andrew Tridgell <andrew at tridgell.net>
Date: Mon Apr 8 12:45:59 2024 +1000
update to popt 1.19
commit 85c906f96425195f8ba8646fbb37142206399ba0
Author: Rose <83477269+AtariDreams at users.noreply.github.com>
Date: Wed May 3 09:50:31 2023 -0400
Silence unused var warning
recv_ida_entries still needs to be called regardless, so we cannot take that out. Let's just quiet the compiler instead.
commit 35f5a21a16ca2689710e0503464bb736d136edd6
Author: Christian Hesse <mail at eworm.de>
Date: Wed Apr 5 13:08:02 2023 +0200
hint that a proxy can handle plain and ssl stream at the same time
commit 99673f937f36ab90a160a1b8c1e37645893d7b77
Author: Andrew Tridgell <andrew at tridgell.net>
Date: Sun Apr 7 07:11:31 2024 +1000
CI: added FreeBSD build
commit 9505ac59455278b54708b7c2790d93eb3d0b960b
Author: Andrew Tridgell <andrew at tridgell.net>
Date: Sun Apr 7 07:11:47 2024 +1000
removed old cirrus CI
commit 0dd25d4752520ed405315f1d2a8454fd507631bb
Author: Ivan Babrou <github at ivan.computer>
Date: Mon Jan 1 19:31:01 2024 -0800
configure.ac: fix failing IPv6 check due to missing return type
Fixing this warning escalated to an error, resuting in no IPv6 support:
```
configure.sh:7679: checking whether to enable ipv6
configure.sh:7718: clang -o conftest -g -O2 -DHAVE_CONFIG_H -Wall -W conftest.c >&5
conftest.c:73:1: error: type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int [-Wimplicit-int]
main()
^
int
1 error generated.
configure.sh:7718: $? = 1
configure.sh: program exited with status 1
```
-----------------------------------------------------------------------
Summary of changes:
.cirrus.yml | 23 -
.github/workflows/build.yml | 2 -
.github/workflows/freebsd-build.yml | 27 +
INSTALL.md | 2 +
Makefile.in | 2 +-
acls.c | 1 +
configure.ac | 6 +-
popt/lookup3.c | 959 +++++++++++++++++++++++
popt/popt.c | 1447 +++++++++++++++++++++++------------
popt/popt.h | 475 ++++++------
popt/poptconfig.c | 526 ++++++++++---
popt/popthelp.c | 786 ++++++++++---------
popt/poptint.c | 194 +++++
popt/poptint.h | 118 ++-
popt/poptparse.c | 100 +--
popt/system.h | 148 +---
rsyncd.conf.5.md | 3 +
support/install_deps_ubuntu.sh | 11 +
18 files changed, 3411 insertions(+), 1419 deletions(-)
delete mode 100644 .cirrus.yml
create mode 100644 .github/workflows/freebsd-build.yml
create mode 100644 popt/lookup3.c
create mode 100644 popt/poptint.c
create mode 100755 support/install_deps_ubuntu.sh
Changeset truncated at 500 lines:
diff --git a/.cirrus.yml b/.cirrus.yml
deleted file mode 100644
index 33e2685e..00000000
--- a/.cirrus.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-freebsd_task:
- name: FreeBSD
- freebsd_instance:
- image_family: freebsd-13-1
- env:
- PATH: /usr/local/bin:$PATH
- prep_script:
- - dd if=/dev/zero of=/tmp/zpool bs=1M count=1024
- - zpool create -m `pwd`/testtmp zpool /tmp/zpool
- - pkg install -y bash autotools m4 xxhash zstd liblz4 wget
- - wget -O git-version.h https://gist.githubusercontent.com/WayneD/c11243fa374fc64d4e42f2855c8e3827/raw/rsync-git-version.h
- configure_script:
- - CPPFLAGS=-I/usr/local/include/ LDFLAGS=-L/usr/local/lib/ ./configure --disable-md2man
- make_script:
- - make
- install_script:
- - make install
- info_script:
- - rsync --version
- test_script:
- - RSYNC_EXPECT_SKIPPED=acls-default,acls,crtimes,protected-regular make check
- ssl_file_list_script:
- - rsync-ssl --no-motd download.samba.org::rsyncftp/ || true
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3439e181..9273e11a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -3,10 +3,8 @@ name: build
on:
push:
branches: [ master ]
- paths-ignore: [ .cirrus.yml ]
pull_request:
branches: [ master ]
- paths-ignore: [ .cirrus.yml ]
schedule:
- cron: '42 8 * * *'
diff --git a/.github/workflows/freebsd-build.yml b/.github/workflows/freebsd-build.yml
new file mode 100644
index 00000000..747bc35b
--- /dev/null
+++ b/.github/workflows/freebsd-build.yml
@@ -0,0 +1,27 @@
+name: Test rsync on FreeBSD
+
+on:
+ push:
+ branches: [ master ]
+ pull_request:
+ branches: [ master ]
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+ name: Test rsync on FreeBSD
+ steps:
+ - uses: actions/checkout at v4
+ - name: Test in FreeBSD
+ id: test
+ uses: vmactions/freebsd-vm at v1
+ with:
+ usesh: true
+ prepare: |
+ pkg install -y bash autotools m4 devel/xxhash zstd liblz4 wget python3 archivers/liblz4
+ run: |
+ freebsd-version
+ ./configure --with-rrsync -disable-zstd --disable-md2man --disable-xxhash --disable-lz4
+ make
+ ./rsync --version
+ ./rsync-ssl --no-motd download.samba.org::rsyncftp/ || true
diff --git a/INSTALL.md b/INSTALL.md
index 1605ab43..8ef574a5 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -104,6 +104,8 @@ like.
> sudo apt install -y liblz4-dev
> sudo apt install -y libssl-dev
+Or run support/install_deps_ubuntu.sh
+
- For CentOS (use EPEL for python3-pip):
> sudo yum -y install epel-release
diff --git a/Makefile.in b/Makefile.in
index a1253e5d..6bf304d1 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -50,7 +50,7 @@ OBJS2=options.o io.o compat.o hlink.o token.o uidlist.o socket.o hashtable.o \
OBJS3=progress.o pipe.o @MD5_ASM@ @ROLL_SIMD@ @ROLL_ASM@
DAEMON_OBJ = params.o loadparm.o clientserver.o access.o connection.o authenticate.o
popt_OBJS=popt/findme.o popt/popt.o popt/poptconfig.o \
- popt/popthelp.o popt/poptparse.o
+ popt/popthelp.o popt/poptparse.o popt/poptint.o
OBJS=$(OBJS1) $(OBJS2) $(OBJS3) $(DAEMON_OBJ) $(LIBOBJ) @BUILD_ZLIB@ @BUILD_POPT@
TLS_OBJ = tls.o syscall.o util2.o t_stub.o lib/compat.o lib/snprintf.o lib/permstring.o lib/sysxattrs.o @BUILD_POPT@
diff --git a/acls.c b/acls.c
index 3cf12eeb..a2b0ff3e 100644
--- a/acls.c
+++ b/acls.c
@@ -765,6 +765,7 @@ static int recv_rsync_acl(int f, item_list *racl_list, SMB_ACL_TYPE_T type, mode
/* If we received a superfluous mask, throw it away. */
duo_item->racl.mask_obj = NO_ENTRY;
(void)mode;
+ (void)computed_mask_bits;
#else
if (duo_item->racl.names.count && duo_item->racl.mask_obj == NO_ENTRY) {
/* Mask must be non-empty with lists. */
diff --git a/configure.ac b/configure.ac
index 0d868571..390c5961 100644
--- a/configure.ac
+++ b/configure.ac
@@ -392,7 +392,7 @@ AS_HELP_STRING([--disable-ipv6],[disable to omit ipv6 support]),
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
-main()
+int main()
{
if (socket(AF_INET6, SOCK_STREAM, 0) < 0)
exit(1);
@@ -870,7 +870,7 @@ AC_CHECK_FUNCS(waitpid wait4 getcwd chown chmod lchmod mknod mkfifo \
fchmod fstat ftruncate strchr readlink link utime utimes lutimes strftime \
chflags getattrlist mktime innetgr linkat \
memmove lchown vsnprintf snprintf vasprintf asprintf setsid strpbrk \
- strlcat strlcpy strtol mallinfo mallinfo2 getgroups setgroups geteuid getegid \
+ strlcat strlcpy stpcpy strtol mallinfo mallinfo2 getgroups setgroups geteuid getegid \
setlocale setmode open64 lseek64 mkstemp64 mtrace va_copy __va_copy \
seteuid strerror putenv iconv_open locale_charset nl_langinfo getxattr \
extattr_get_link sigaction sigprocmask setattrlist getgrouplist \
@@ -1084,6 +1084,8 @@ if test x"$with_included_popt" = x"yes"; then
AC_MSG_RESULT($srcdir/popt)
BUILD_POPT='$(popt_OBJS)'
CFLAGS="-I$srcdir/popt $CFLAGS"
+ AC_DEFINE(POPT_SYSCONFDIR, "/etc", [sysconfig dir for popt])
+ AC_DEFINE(PACKAGE, "rsync", [package name for rsync])
if test x"$ALLOCA" != x
then
# this can be removed when/if we add an included alloca.c;
diff --git a/popt/lookup3.c b/popt/lookup3.c
new file mode 100644
index 00000000..e974cad8
--- /dev/null
+++ b/popt/lookup3.c
@@ -0,0 +1,959 @@
+/* -------------------------------------------------------------------- */
+/*
+ * lookup3.c, by Bob Jenkins, May 2006, Public Domain.
+ *
+ * These are functions for producing 32-bit hashes for hash table lookup.
+ * jlu32w(), jlu32l(), jlu32lpair(), jlu32b(), _JLU3_MIX(), and _JLU3_FINAL()
+ * are externally useful functions. Routines to test the hash are included
+ * if SELF_TEST is defined. You can use this free for any purpose. It's in
+ * the public domain. It has no warranty.
+ *
+ * You probably want to use jlu32l(). jlu32l() and jlu32b()
+ * hash byte arrays. jlu32l() is is faster than jlu32b() on
+ * little-endian machines. Intel and AMD are little-endian machines.
+ * On second thought, you probably want jlu32lpair(), which is identical to
+ * jlu32l() except it returns two 32-bit hashes for the price of one.
+ * You could implement jlu32bpair() if you wanted but I haven't bothered here.
+ *
+ * If you want to find a hash of, say, exactly 7 integers, do
+ * a = i1; b = i2; c = i3;
+ * _JLU3_MIX(a,b,c);
+ * a += i4; b += i5; c += i6;
+ * _JLU3_MIX(a,b,c);
+ * a += i7;
+ * _JLU3_FINAL(a,b,c);
+ * then use c as the hash value. If you have a variable size array of
+ * 4-byte integers to hash, use jlu32w(). If you have a byte array (like
+ * a character string), use jlu32l(). If you have several byte arrays, or
+ * a mix of things, see the comments above jlu32l().
+ *
+ * Why is this so big? I read 12 bytes at a time into 3 4-byte integers,
+ * then mix those integers. This is fast (you can do a lot more thorough
+ * mixing with 12*3 instructions on 3 integers than you can with 3 instructions
+ * on 1 byte), but shoehorning those bytes into integers efficiently is messy.
+*/
+/* -------------------------------------------------------------------- */
+
+#include <stdint.h>
+
+#if defined(_JLU3_SELFTEST)
+# define _JLU3_jlu32w 1
+# define _JLU3_jlu32l 1
+# define _JLU3_jlu32lpair 1
+# define _JLU3_jlu32b 1
+#endif
+
+static const union _dbswap {
+ const uint32_t ui;
+ const unsigned char uc[4];
+} endian = { .ui = 0x11223344 };
+# define HASH_LITTLE_ENDIAN (endian.uc[0] == (unsigned char) 0x44)
+# define HASH_BIG_ENDIAN (endian.uc[0] == (unsigned char) 0x11)
+
+#ifndef ROTL32
+# define ROTL32(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
+#endif
+
+/* NOTE: The _size parameter should be in bytes. */
+#define _JLU3_INIT(_h, _size) (0xdeadbeef + ((uint32_t)(_size)) + (_h))
+
+/* -------------------------------------------------------------------- */
+/*
+ * _JLU3_MIX -- mix 3 32-bit values reversibly.
+ *
+ * This is reversible, so any information in (a,b,c) before _JLU3_MIX() is
+ * still in (a,b,c) after _JLU3_MIX().
+ *
+ * If four pairs of (a,b,c) inputs are run through _JLU3_MIX(), or through
+ * _JLU3_MIX() in reverse, there are at least 32 bits of the output that
+ * are sometimes the same for one pair and different for another pair.
+ * This was tested for:
+ * * pairs that differed by one bit, by two bits, in any combination
+ * of top bits of (a,b,c), or in any combination of bottom bits of
+ * (a,b,c).
+ * * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
+ * the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+ * is commonly produced by subtraction) look like a single 1-bit
+ * difference.
+ * * the base values were pseudorandom, all zero but one bit set, or
+ * all zero plus a counter that starts at zero.
+ *
+ * Some k values for my "a-=c; a^=ROTL32(c,k); c+=b;" arrangement that
+ * satisfy this are
+ * 4 6 8 16 19 4
+ * 9 15 3 18 27 15
+ * 14 9 3 7 17 3
+ * Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
+ * for "differ" defined as + with a one-bit base and a two-bit delta. I
+ * used http://burtleburtle.net/bob/hash/avalanche.html to choose
+ * the operations, constants, and arrangements of the variables.
+ *
+ * This does not achieve avalanche. There are input bits of (a,b,c)
+ * that fail to affect some output bits of (a,b,c), especially of a. The
+ * most thoroughly mixed value is c, but it doesn't really even achieve
+ * avalanche in c.
+ *
+ * This allows some parallelism. Read-after-writes are good at doubling
+ * the number of bits affected, so the goal of mixing pulls in the opposite
+ * direction as the goal of parallelism. I did what I could. Rotates
+ * seem to cost as much as shifts on every machine I could lay my hands
+ * on, and rotates are much kinder to the top and bottom bits, so I used
+ * rotates.
+ */
+/* -------------------------------------------------------------------- */
+#define _JLU3_MIX(a,b,c) \
+{ \
+ a -= c; a ^= ROTL32(c, 4); c += b; \
+ b -= a; b ^= ROTL32(a, 6); a += c; \
+ c -= b; c ^= ROTL32(b, 8); b += a; \
+ a -= c; a ^= ROTL32(c,16); c += b; \
+ b -= a; b ^= ROTL32(a,19); a += c; \
+ c -= b; c ^= ROTL32(b, 4); b += a; \
+}
+
+/* -------------------------------------------------------------------- */
+/**
+ * _JLU3_FINAL -- final mixing of 3 32-bit values (a,b,c) into c
+ *
+ * Pairs of (a,b,c) values differing in only a few bits will usually
+ * produce values of c that look totally different. This was tested for
+ * * pairs that differed by one bit, by two bits, in any combination
+ * of top bits of (a,b,c), or in any combination of bottom bits of
+ * (a,b,c).
+ * * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
+ * the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+ * is commonly produced by subtraction) look like a single 1-bit
+ * difference.
+ * * the base values were pseudorandom, all zero but one bit set, or
+ * all zero plus a counter that starts at zero.
+ *
+ * These constants passed:
+ * 14 11 25 16 4 14 24
+ * 12 14 25 16 4 14 24
+ * and these came close:
+ * 4 8 15 26 3 22 24
+ * 10 8 15 26 3 22 24
+ * 11 8 15 26 3 22 24
+ */
+/* -------------------------------------------------------------------- */
+#define _JLU3_FINAL(a,b,c) \
+{ \
+ c ^= b; c -= ROTL32(b,14); \
+ a ^= c; a -= ROTL32(c,11); \
+ b ^= a; b -= ROTL32(a,25); \
+ c ^= b; c -= ROTL32(b,16); \
+ a ^= c; a -= ROTL32(c,4); \
+ b ^= a; b -= ROTL32(a,14); \
+ c ^= b; c -= ROTL32(b,24); \
+}
+
+#if defined(_JLU3_jlu32w)
+uint32_t jlu32w(uint32_t h, const uint32_t *k, size_t size);
+/* -------------------------------------------------------------------- */
+/**
+ * This works on all machines. To be useful, it requires
+ * -- that the key be an array of uint32_t's, and
+ * -- that the size be the number of uint32_t's in the key
+ *
+ * The function jlu32w() is identical to jlu32l() on little-endian
+ * machines, and identical to jlu32b() on big-endian machines,
+ * except that the size has to be measured in uint32_ts rather than in
+ * bytes. jlu32l() is more complicated than jlu32w() only because
+ * jlu32l() has to dance around fitting the key bytes into registers.
+ *
+ * @param h the previous hash, or an arbitrary value
+ * @param *k the key, an array of uint32_t values
+ * @param size the size of the key, in uint32_ts
+ * @return the lookup3 hash
+ */
+/* -------------------------------------------------------------------- */
+uint32_t jlu32w(uint32_t h, const uint32_t *k, size_t size)
+{
+ uint32_t a = _JLU3_INIT(h, (size * sizeof(*k)));
+ uint32_t b = a;
+ uint32_t c = a;
+
+ if (k == NULL)
+ goto exit;
+
+ /*----------------------------------------------- handle most of the key */
+ while (size > 3) {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ _JLU3_MIX(a,b,c);
+ size -= 3;
+ k += 3;
+ }
+
+ /*----------------------------------------- handle the last 3 uint32_t's */
+ switch (size) {
+ case 3 : c+=k[2];
+ case 2 : b+=k[1];
+ case 1 : a+=k[0];
+ _JLU3_FINAL(a,b,c);
+ /* fallthrough */
+ case 0:
+ break;
+ }
+ /*---------------------------------------------------- report the result */
+exit:
+ return c;
+}
+#endif /* defined(_JLU3_jlu32w) */
+
+#if defined(_JLU3_jlu32l)
+uint32_t jlu32l(uint32_t h, const void *key, size_t size);
+/* -------------------------------------------------------------------- */
+/*
+ * jlu32l() -- hash a variable-length key into a 32-bit value
+ * h : can be any 4-byte value
+ * k : the key (the unaligned variable-length array of bytes)
+ * size : the size of the key, counting by bytes
+ * Returns a 32-bit value. Every bit of the key affects every bit of
+ * the return value. Two keys differing by one or two bits will have
+ * totally different hash values.
+ *
+ * The best hash table sizes are powers of 2. There is no need to do
+ * mod a prime (mod is sooo slow!). If you need less than 32 bits,
+ * use a bitmask. For example, if you need only 10 bits, do
+ * h = (h & hashmask(10));
+ * In which case, the hash table should have hashsize(10) elements.
+ *
+ * If you are hashing n strings (uint8_t **)k, do it like this:
+ * for (i=0, h=0; i<n; ++i) h = jlu32l(h, k[i], len[i]);
+ *
+ * By Bob Jenkins, 2006. bob_jenkins at burtleburtle.net. You may use this
+ * code any way you wish, private, educational, or commercial. It's free.
+ *
+ * Use for hash table lookup, or anything where one collision in 2^^32 is
+ * acceptable. Do NOT use for cryptographic purposes.
+ *
+ * @param h the previous hash, or an arbitrary value
+ * @param *k the key, an array of uint8_t values
+ * @param size the size of the key
+ * @return the lookup3 hash
+ */
+/* -------------------------------------------------------------------- */
+uint32_t jlu32l(uint32_t h, const void *key, size_t size)
+{
+ union { const void *ptr; size_t i; } u;
+ uint32_t a = _JLU3_INIT(h, size);
+ uint32_t b = a;
+ uint32_t c = a;
+
+ if (key == NULL)
+ goto exit;
+
+ u.ptr = key;
+ if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+ const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
+#ifdef VALGRIND
+ const uint8_t *k8;
+#endif
+
+ /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+ while (size > 12) {
+ a += k[0];
+ b += k[1];
+ c += k[2];
+ _JLU3_MIX(a,b,c);
+ size -= 12;
+ k += 3;
+ }
+
+ /*------------------------- handle the last (probably partial) block */
+ /*
+ * "k[2]&0xffffff" actually reads beyond the end of the string, but
+ * then masks off the part it's not allowed to read. Because the
+ * string is aligned, the masked-off tail is in the same word as the
+ * rest of the string. Every machine with memory protection I've seen
+ * does it on word boundaries, so is OK with this. But VALGRIND will
+ * still catch it and complain. The masking trick does make the hash
+ * noticeably faster for short strings (like English words).
+ */
+#ifndef VALGRIND
+
+ switch (size) {
+ case 12: c += k[2]; b+=k[1]; a+=k[0]; break;
+ case 11: c += k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+ case 10: c += k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+ case 9: c += k[2]&0xff; b+=k[1]; a+=k[0]; break;
+ case 8: b += k[1]; a+=k[0]; break;
+ case 7: b += k[1]&0xffffff; a+=k[0]; break;
+ case 6: b += k[1]&0xffff; a+=k[0]; break;
+ case 5: b += k[1]&0xff; a+=k[0]; break;
+ case 4: a += k[0]; break;
+ case 3: a += k[0]&0xffffff; break;
+ case 2: a += k[0]&0xffff; break;
+ case 1: a += k[0]&0xff; break;
+ case 0: goto exit;
+ }
+
+#else /* make valgrind happy */
+
+ k8 = (const uint8_t *)k;
+ switch (size) {
+ case 12: c += k[2]; b+=k[1]; a+=k[0] break;
+ case 11: c += ((uint32_t)k8[10])<<16; /* fallthrough */
+ case 10: c += ((uint32_t)k8[9])<<8; /* fallthrough */
+ case 9: c += k8[8]; /* fallthrough */
+ case 8: b += k[1]; a+=k[0]; break;
+ case 7: b += ((uint32_t)k8[6])<<16; /* fallthrough */
+ case 6: b += ((uint32_t)k8[5])<<8; /* fallthrough */
+ case 5: b += k8[4]; /* fallthrough */
+ case 4: a += k[0]; break;
+ case 3: a += ((uint32_t)k8[2])<<16; /* fallthrough */
+ case 2: a += ((uint32_t)k8[1])<<8; /* fallthrough */
+ case 1: a += k8[0]; break;
+ case 0: goto exit;
+ }
+
+#endif /* !valgrind */
+
+ } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+ const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
+ const uint8_t *k8;
+
+ /*----------- all but last block: aligned reads and different mixing */
+ while (size > 12) {
+ a += k[0] + (((uint32_t)k[1])<<16);
+ b += k[2] + (((uint32_t)k[3])<<16);
+ c += k[4] + (((uint32_t)k[5])<<16);
+ _JLU3_MIX(a,b,c);
+ size -= 12;
+ k += 6;
+ }
+
+ /*------------------------- handle the last (probably partial) block */
+ k8 = (const uint8_t *)k;
+ switch (size) {
+ case 12:
+ c += k[4]+(((uint32_t)k[5])<<16);
+ b += k[2]+(((uint32_t)k[3])<<16);
+ a += k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 11:
+ c += ((uint32_t)k8[10])<<16;
+ /* fallthrough */
+ case 10:
+ c += (uint32_t)k[4];
+ b += k[2]+(((uint32_t)k[3])<<16);
+ a += k[0]+(((uint32_t)k[1])<<16);
+ break;
+ case 9:
+ c += (uint32_t)k8[8];
+ /* fallthrough */
+ case 8:
+ b += k[2]+(((uint32_t)k[3])<<16);
--
The rsync repository.
More information about the rsync-cvs
mailing list