[BACK]Return to match.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/match.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2016/11/01 09:54:32 version 1.1.1.4, 2021/03/17 00:32:36
Line 3 Line 3
  *   *
  * Copyright (C) 1996 Andrew Tridgell   * Copyright (C) 1996 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras   * Copyright (C) 1996 Paul Mackerras
 * Copyright (C) 2003-2015 Wayne Davison * Copyright (C) 2003-2020 Wayne Davison
  *   *
  * This program is free software; you can redistribute it and/or modify   * 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   * it under the terms of the GNU General Public License as published by
Line 24 Line 24
   
 extern int checksum_seed;  extern int checksum_seed;
 extern int append_mode;  extern int append_mode;
extern int checksum_len;extern int xfersum_type;
   
 int updating_basis_file;  int updating_basis_file;
 char sender_file_sum[MAX_DIGEST_LEN];  char sender_file_sum[MAX_DIGEST_LEN];
Line 65  static void build_hash_table(struct sum_struct *s) Line 65  static void build_hash_table(struct sum_struct *s)
                 if (hash_table)                  if (hash_table)
                         free(hash_table);                          free(hash_table);
                 hash_table = new_array(int32, tablesize);                  hash_table = new_array(int32, tablesize);
                 if (!hash_table)  
                         out_of_memory("build_hash_table");  
                 alloc_size = tablesize;                  alloc_size = tablesize;
         }          }
   
Line 102  static OFF_T last_match; Line 100  static OFF_T last_match;
  * If i >= 0, the number of a matched token.  If < 0, indicates we have   * 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.  A -1 will send a 0-token-int too, and a -2 sends
  * only literal data, w/o any token-int. */   * only literal data, w/o any token-int. */
static void matched(int f, struct sum_struct *s, struct map_struct *buf,static void matched(int f, struct sum_struct *s, struct map_struct *buf, OFF_T offset, int32 i)
                    OFF_T offset, int32 i) 
 {  {
         int32 n = (int32)(offset - last_match); /* max value: block_size (int32) */          int32 n = (int32)(offset - last_match); /* max value: block_size (int32) */
         int32 j;          int32 j;
Line 167  static void hash_search(int f,struct sum_struct *s, Line 164  static void hash_search(int f,struct sum_struct *s,
         if (DEBUG_GTE(DELTASUM, 3))          if (DEBUG_GTE(DELTASUM, 3))
                 rprintf(FINFO, "sum=%.8x k=%ld\n", sum, (long)k);                  rprintf(FINFO, "sum=%.8x k=%ld\n", sum, (long)k);
   
           checksum2_enable_prefetch(buf, len, s->blength);
   
         offset = aligned_offset = aligned_i = 0;          offset = aligned_offset = aligned_i = 0;
   
         end = len + 1 - s->sums[s->count-1].len;          end = len + 1 - s->sums[s->count-1].len;
Line 207  static void hash_search(int f,struct sum_struct *s, Line 206  static void hash_search(int f,struct sum_struct *s,
                          * either >= our offset or identical data at that offset.                           * either >= our offset or identical data at that offset.
                          * Remove any bypassed entries that we can never use. */                           * Remove any bypassed entries that we can never use. */
                         if (updating_basis_file && s->sums[i].offset < offset                          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;                                  *prev = s->sums[i].chain;
                                 continue;                                  continue;
                         }                          }
Line 229  static void hash_search(int f,struct sum_struct *s, Line 228  static void hash_search(int f,struct sum_struct *s,
   
                         if (!done_csum2) {                          if (!done_csum2) {
                                 map = (schar *)map_ptr(buf,offset,l);                                  map = (schar *)map_ptr(buf,offset,l);
                                get_checksum2((char *)map,l,sum2);                                get_checksum2((char *)map, l, sum2, offset);
                                 done_csum2 = 1;                                  done_csum2 = 1;
                         }                          }
   
Line 271  static void hash_search(int f,struct sum_struct *s, Line 270  static void hash_search(int f,struct sum_struct *s,
                                                 sum = get_checksum1((char *)map, l);                                                  sum = get_checksum1((char *)map, l);
                                                 if (sum != s->sums[i].sum1)                                                  if (sum != s->sums[i].sum1)
                                                         goto check_want_i;                                                          goto check_want_i;
                                                get_checksum2((char *)map, l, sum2);                                                get_checksum2((char *)map, l, sum2, aligned_offset);
                                                 if (memcmp(sum2, s->sums[i].sum2, s->s2length) != 0)                                                  if (memcmp(sum2, s->sums[i].sum2, s->s2length) != 0)
                                                         goto check_want_i;                                                          goto check_want_i;
                                                 /* OK, we have a re-alignment match.  Bump the offset                                                  /* OK, we have a re-alignment match.  Bump the offset
Line 288  static void hash_search(int f,struct sum_struct *s, Line 287  static void hash_search(int f,struct sum_struct *s,
                         /* we've found a match, but now check to see                          /* we've found a match, but now check to see
                          * if want_i can hint at a better match. */                           * if want_i can hint at a better match. */
                         if (i != want_i && want_i < s->count                          if (i != want_i && want_i < s->count
                            && (!updating_basis_file || s->sums[want_i].offset >= offset                         && (!updating_basis_file || s->sums[want_i].offset >= offset
                             || s->sums[want_i].flags & SUMFLG_SAME_OFFSET)                          || s->sums[want_i].flags & SUMFLG_SAME_OFFSET)
                            && sum == s->sums[want_i].sum1                         && sum == s->sums[want_i].sum1
                            && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) {                         && memcmp(sum2, s->sums[want_i].sum2, s->s2length) == 0) {
                                 /* we've found an adjacent match - the RLL coder                                  /* we've found an adjacent match - the RLL coder
                                  * will be happy */                                   * will be happy */
                                 i = want_i;                                  i = want_i;
Line 317  static void hash_search(int f,struct sum_struct *s, Line 316  static void hash_search(int f,struct sum_struct *s,
   
                 /* Trim off the first byte from the checksum */                  /* Trim off the first byte from the checksum */
                 more = offset + k < len;                  more = offset + k < len;
                map = (schar *)map_ptr(buf, offset - backup, k + more + backup)                map = (schar *)map_ptr(buf, offset - backup, k + more + backup) + backup;
                    + backup; 
                 s1 -= map[0] + CHAR_OFFSET;                  s1 -= map[0] + CHAR_OFFSET;
                 s2 -= k * (map[0]+CHAR_OFFSET);                  s2 -= k * (map[0]+CHAR_OFFSET);
   
Line 339  static void hash_search(int f,struct sum_struct *s, Line 337  static void hash_search(int f,struct sum_struct *s,
                         matched(f, s, buf, offset - s->blength, -2);                          matched(f, s, buf, offset - s->blength, -2);
         } while (++offset < end);          } while (++offset < end);
   
           checksum2_disable_prefetch();
   
         matched(f, s, buf, len, -1);          matched(f, s, buf, len, -1);
         map_ptr(buf, len-1, 1);          map_ptr(buf, len-1, 1);
 }  }
Line 360  static void hash_search(int f,struct sum_struct *s, Line 360  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)  void match_sums(int f, struct sum_struct *s, struct map_struct *buf, OFF_T len)
 {  {
           int sum_len;
   
         last_match = 0;          last_match = 0;
         false_alarms = 0;          false_alarms = 0;
         hash_hits = 0;          hash_hits = 0;
         matches = 0;          matches = 0;
         data_transfer = 0;          data_transfer = 0;
   
        sum_init(checksum_seed);        sum_init(xfersum_type, checksum_seed);
   
         if (append_mode > 0) {          if (append_mode > 0) {
                 if (append_mode == 2) {                  if (append_mode == 2) {
Line 407  void match_sums(int f, struct sum_struct *s, struct ma Line 409  void match_sums(int f, struct sum_struct *s, struct ma
                 matched(f, s, buf, len, -1);                  matched(f, s, buf, len, -1);
         }          }
   
        if (sum_end(sender_file_sum) != checksum_len)        sum_len = sum_end(sender_file_sum);
                overflow_exit("checksum_len"); /* Impossible... */ 
   
         /* If we had a read error, send a bad checksum.  We use all bits          /* 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           * off as long as the checksum doesn't happen to be that, in
          * which case we turn the last 0 bit into a 1. */           * which case we turn the last 0 bit into a 1. */
         if (buf && buf->status != 0) {          if (buf && buf->status != 0) {
                 int i;                  int i;
                for (i = 0; i < checksum_len && sender_file_sum[i] == 0; i++) {}                for (i = 0; i < sum_len && sender_file_sum[i] == 0; i++) {}
                memset(sender_file_sum, 0, checksum_len);                memset(sender_file_sum, 0, sum_len);
                if (i == checksum_len)                if (i == sum_len)
                         sender_file_sum[i-1]++;                          sender_file_sum[i-1]++;
         }          }
   
         if (DEBUG_GTE(DELTASUM, 2))          if (DEBUG_GTE(DELTASUM, 2))
                 rprintf(FINFO,"sending file_sum\n");                  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)) {          if (DEBUG_GTE(DELTASUM, 2)) {
                 rprintf(FINFO, "false_alarms=%d hash_hits=%d matches=%d\n",                  rprintf(FINFO, "false_alarms=%d hash_hits=%d matches=%d\n",
Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>