Add more link targets to html man pages.

[rsync.git] / match.c

diff --git a/match.c b/match.c
index a8bd1f304f44983925c1c8b5b1664b0c7fbf8192..9d5c9259468e6ada1c36c7ffc9f5273f2983763e 100644 (file)
--- a/match.c
+++ b/match.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 1996 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras
- * Copyright (C) 2003-2013 Wayne Davison
+ * Copyright (C) 2003-2020 Wayne Davison
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,7 +24,7 @@
 
 extern int checksum_seed;
 extern int append_mode;
-extern int checksum_len;
+extern int xfersum_type;
 
 int updating_basis_file;
 char sender_file_sum[MAX_DIGEST_LEN];
@@ -65,8 +65,6 @@ static void build_hash_table(struct sum_struct *s)
                if (hash_table)
                        free(hash_table);
                hash_table = new_array(int32, tablesize);
-               if (!hash_table)
-                       out_of_memory("build_hash_table");
                alloc_size = tablesize;
        }
 
@@ -102,8 +100,7 @@ static OFF_T last_match;
  * If i >= 0, the number of a matched token.  If < 0, indicates we have
  * only literal data.  A -1 will send a 0-token-int too, and a -2 sends
  * only literal data, w/o any token-int. */
-static void matched(int f, struct sum_struct *s, struct map_struct *buf,
-                   OFF_T offset, int32 i)
+static void matched(int f, struct sum_struct *s, struct map_struct *buf, OFF_T offset, int32 i)
 {
        int32 n = (int32)(offset - last_match); /* max value: block_size (int32) */
        int32 j;
@@ -207,7 +204,7 @@ static void hash_search(int f,struct sum_struct *s,
                         * either >= our offset or identical data at that offset.
                         * Remove any bypassed entries that we can never use. */
                        if (updating_basis_file && s->sums[i].offset < offset
-                           && !(s->sums[i].flags & SUMFLG_SAME_OFFSET)) {
+                        && !(s->sums[i].flags & SUMFLG_SAME_OFFSET)) {
                                *prev = s->sums[i].chain;
                                continue;
                        }
@@ -288,10 +285,10 @@ static void hash_search(int f,struct sum_struct *s,
                        /* we've found a match, but now check to see
                         * if want_i can hint at a better match. */
                        if (i != want_i && want_i < s->count
-                           && (!updating_basis_file || s->sums[want_i].offset >= offset
-                            || s->sums[want_i].flags & SUMFLG_SAME_OFFSET)
-                           && sum == s->sums[want_i].sum1
-                           && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) {
+                        && (!updating_basis_file || s->sums[want_i].offset >= offset
+                         || s->sums[want_i].flags & SUMFLG_SAME_OFFSET)
+                        && sum == s->sums[want_i].sum1
+                        && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) {
                                /* we've found an adjacent match - the RLL coder
                                 * will be happy */
                                i = want_i;
@@ -317,8 +314,7 @@ static void hash_search(int f,struct sum_struct *s,
 
                /* Trim off the first byte from the checksum */
                more = offset + k < len;
-               map = (schar *)map_ptr(buf, offset - backup, k + more + backup)
-                   + backup;
+               map = (schar *)map_ptr(buf, offset - backup, k + more + backup) + backup;
                s1 -= map[0] + CHAR_OFFSET;
                s2 -= k * (map[0]+CHAR_OFFSET);
 
@@ -360,13 +356,15 @@ static void hash_search(int f,struct sum_struct *s,
  **/
 void match_sums(int f, struct sum_struct *s, struct map_struct *buf, OFF_T len)
 {
+       int sum_len;
+
        last_match = 0;
        false_alarms = 0;
        hash_hits = 0;
        matches = 0;
        data_transfer = 0;
 
-       sum_init(checksum_seed);
+       sum_init(xfersum_type, checksum_seed);
 
        if (append_mode > 0) {
                if (append_mode == 2) {
@@ -407,23 +405,22 @@ void match_sums(int f, struct sum_struct *s, struct map_struct *buf, OFF_T len)
                matched(f, s, buf, len, -1);
        }
 
-       if (sum_end(sender_file_sum) != checksum_len)
-               overflow_exit("checksum_len"); /* Impossible... */
+       sum_len = sum_end(sender_file_sum);
 
        /* If we had a read error, send a bad checksum.  We use all bits
         * off as long as the checksum doesn't happen to be that, in
         * which case we turn the last 0 bit into a 1. */
        if (buf && buf->status != 0) {
                int i;
-               for (i = 0; i < checksum_len && sender_file_sum[i] == 0; i++) {}
-               memset(sender_file_sum, 0, checksum_len);
-               if (i == checksum_len)
+               for (i = 0; i < sum_len && sender_file_sum[i] == 0; i++) {}
+               memset(sender_file_sum, 0, sum_len);
+               if (i == sum_len)
                        sender_file_sum[i-1]++;
        }
 
        if (DEBUG_GTE(DELTASUM, 2))
                rprintf(FINFO,"sending file_sum\n");
-       write_buf(f, sender_file_sum, checksum_len);
+       write_buf(f, sender_file_sum, sum_len);
 
        if (DEBUG_GTE(DELTASUM, 2)) {
                rprintf(FINFO, "false_alarms=%d hash_hits=%d matches=%d\n",