X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/7fcbf9e43e05c7c8fad4771b7cf8ac9c6ddc655a..bd685982389b78a158921b7839bdeca501338d19:/token.c diff --git a/token.c b/token.c index 862af0f0..75d2b17b 100644 --- a/token.c +++ b/token.c @@ -1,73 +1,219 @@ /* - Copyright (C) Andrew Tridgell 1996 - Copyright (C) Paul Mackerras 1996 - - 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 - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -*/ + * Routines used by the file-transfer code. + * + * Copyright (C) 1996 Andrew Tridgell + * Copyright (C) 1996 Paul Mackerras + * Copyright (C) 2003-2009 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 + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, visit the http://fsf.org website. + */ #include "rsync.h" +#include "itypes.h" #include "zlib/zlib.h" extern int do_compression; extern int module_id; +extern int def_compress_level; +extern char *skip_compress; + +static int compression_level, per_file_default_level; + +struct suffix_tree { + struct suffix_tree *sibling; + struct suffix_tree *child; + char letter, word_end; +}; + +static char *match_list; +static struct suffix_tree *suftree; + +static void add_suffix(struct suffix_tree **prior, char ltr, const char *str) +{ + struct suffix_tree *node, *newnode; + + if (ltr == '[') { + const char *after = strchr(str, ']'); + /* Treat "[foo" and "[]" as having a literal '['. */ + if (after && after++ != str+1) { + while ((ltr = *str++) != ']') + add_suffix(prior, ltr, after); + return; + } + } + + for (node = *prior; node; prior = &node->sibling, node = node->sibling) { + if (node->letter == ltr) { + if (*str) + add_suffix(&node->child, *str, str+1); + else + node->word_end = 1; + return; + } + if (node->letter > ltr) + break; + } + if (!(newnode = new(struct suffix_tree))) + out_of_memory("add_suffix"); + newnode->sibling = node; + newnode->child = NULL; + newnode->letter = ltr; + *prior = newnode; + if (*str) { + add_suffix(&newnode->child, *str, str+1); + newnode->word_end = 0; + } else + newnode->word_end = 1; +} + +static void add_nocompress_suffixes(const char *str) +{ + char *buf, *t; + const char *f = str; + + if (!(buf = new_array(char, strlen(f) + 1))) + out_of_memory("add_nocompress_suffixes"); + + while (*f) { + if (*f == '/') { + f++; + continue; + } + + t = buf; + do { + if (isUpper(f)) + *t++ = toLower(f); + else + *t++ = *f; + } while (*++f != '/' && *f); + *t++ = '\0'; + + add_suffix(&suftree, *buf, buf+1); + } + + free(buf); +} + +static void init_set_compression(void) +{ + const char *f; + char *t, *start; + + if (skip_compress) + add_nocompress_suffixes(skip_compress); + + /* A non-daemon transfer skips the default suffix list if the + * user specified --skip-compress. */ + if (skip_compress && module_id < 0) + f = ""; + else + f = lp_dont_compress(module_id); -static int compression_level = Z_DEFAULT_COMPRESSION; + if (!(match_list = t = new_array(char, strlen(f) + 2))) + out_of_memory("set_compression"); + + per_file_default_level = def_compress_level; + + while (*f) { + if (*f == ' ') { + f++; + continue; + } + + start = t; + do { + if (isUpper(f)) + *t++ = toLower(f); + else + *t++ = *f; + } while (*++f != ' ' && *f); + *t++ = '\0'; + + if (t - start == 1+1 && *start == '*') { + /* Optimize a match-string of "*". */ + *match_list = '\0'; + suftree = NULL; + per_file_default_level = 0; + break; + } + + /* Move *.foo items into the stuffix tree. */ + if (*start == '*' && start[1] == '.' && start[2] + && !strpbrk(start+2, ".?*")) { + add_suffix(&suftree, start[2], start+3); + t = start; + } + } + *t++ = '\0'; +} /* determine the compression level based on a wildcard filename list */ -void set_compression(char *fname) +void set_compression(const char *fname) { - char *dont; - char *tok; + const struct suffix_tree *node; + const char *s; + char ltr; if (!do_compression) return; - compression_level = Z_DEFAULT_COMPRESSION; - dont = lp_dont_compress(module_id); + if (!match_list) + init_set_compression(); - if (!dont || !*dont) - return; + compression_level = per_file_default_level; - if (dont[0] == '*' && !dont[1]) { - /* an optimization to skip the rest of this routine */ - compression_level = 0; + if (!*match_list && !suftree) return; + + if ((s = strrchr(fname, '/')) != NULL) + fname = s + 1; + + for (s = match_list; *s; s += strlen(s) + 1) { + if (iwildmatch(s, fname)) { + compression_level = 0; + return; + } } - dont = strdup(dont); - fname = strdup(fname); - if (!dont || !fname) + if (!(node = suftree) || !(s = strrchr(fname, '.')) + || s == fname || !(ltr = *++s)) return; - strlower(dont); - strlower(fname); - - for (tok = strtok(dont, " "); tok; tok = strtok(NULL, " ")) { - if (wildmatch(tok, fname)) { - compression_level = 0; - break; + while (1) { + if (isUpper(<r)) + ltr = toLower(<r); + while (node->letter != ltr) { + if (node->letter > ltr) + return; + if (!(node = node->sibling)) + return; } + if ((ltr = *++s) == '\0') { + if (node->word_end) + compression_level = 0; + return; + } + if (!(node = node->child)) + return; } - free(dont); - free(fname); } /* non-compressing recv token */ static int32 simple_recv_token(int f, char **data) { - static int residue; + static int32 residue; static char *buf; int32 n; @@ -91,9 +237,8 @@ static int32 simple_recv_token(int f, char **data) return n; } - /* non-compressing send token */ -static void simple_send_token(int f, int token, struct map_struct *buf, +static void simple_send_token(int f, int32 token, struct map_struct *buf, OFF_T offset, int32 n) { if (n > 0) { @@ -110,7 +255,6 @@ static void simple_send_token(int f, int token, struct map_struct *buf, write_int(f, -(token+1)); } - /* Flag bytes in compressed stream are encoded as follows: */ #define END_FLAG 0 /* that's all folks */ #define TOKEN_LONG 0x20 /* followed by 32-bit token number */ @@ -128,9 +272,9 @@ static void simple_send_token(int f, int token, struct map_struct *buf, #define AVAIL_OUT_SIZE(avail_in_size) ((avail_in_size)*1001/1000+16) /* For coding runs of tokens */ -static int last_token = -1; -static int run_start; -static int last_run_end; +static int32 last_token = -1; +static int32 run_start; +static int32 last_run_end; /* Deflation state */ static z_stream tx_strm; @@ -148,7 +292,7 @@ static char *obuf; /* Send a deflated token */ static void -send_deflated_token(int f, int token, struct map_struct *buf, OFF_T offset, +send_deflated_token(int f, int32 token, struct map_struct *buf, OFF_T offset, int32 nb, int32 toklen) { int32 n, r; @@ -164,7 +308,7 @@ send_deflated_token(int f, int token, struct map_struct *buf, OFF_T offset, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) { rprintf(FERROR, "compression init failed\n"); - exit_cleanup(RERR_STREAMIO); + exit_cleanup(RERR_PROTOCOL); } if ((obuf = new_array(char, OBUF_SIZE)) == NULL) out_of_memory("send_deflated_token"); @@ -174,10 +318,8 @@ send_deflated_token(int f, int token, struct map_struct *buf, OFF_T offset, last_run_end = 0; run_start = token; flush_pending = 0; - } else if (last_token == -2) { run_start = token; - } else if (nb != 0 || token != last_token + 1 || token >= run_start + 65536) { /* output previous run */ @@ -260,25 +402,27 @@ send_deflated_token(int f, int token, struct map_struct *buf, OFF_T offset, /* end of file - clean up */ write_byte(f, END_FLAG); } else if (token != -2) { - /* add the data in the current block to the compressor's - history and hash table */ - tx_strm.next_in = (Bytef *) map_ptr(buf, offset, toklen); - tx_strm.avail_in = toklen; + /* Add the data in the current block to the compressor's + * history and hash table. */ do { - tx_strm.next_out = (Bytef *)obuf; + /* Break up long sections in the same way that + * see_deflate_token() does. */ + int32 n1 = toklen > 0xffff ? 0xffff : toklen; + toklen -= n1; + tx_strm.next_in = (Bytef *)map_ptr(buf, offset, n1); + tx_strm.avail_in = n1; + tx_strm.next_out = (Bytef *) obuf; tx_strm.avail_out = AVAIL_OUT_SIZE(CHUNK_SIZE); r = deflate(&tx_strm, Z_INSERT_ONLY); - if (r != Z_OK) { - rprintf(FERROR, - "deflate on token returned %d (%d bytes left)\n", + if (r != Z_OK || tx_strm.avail_in != 0) { + rprintf(FERROR, "deflate on token returned %d (%d bytes left)\n", r, tx_strm.avail_in); exit_cleanup(RERR_STREAMIO); } - } while (tx_strm.avail_in != 0); + } while (toklen > 0); } } - /* tells us what the receiver is in the middle of doing */ static enum { r_init, r_idle, r_running, r_inflating, r_inflated } recv_state; @@ -295,9 +439,9 @@ static int32 rx_run; static int32 recv_deflated_token(int f, char **data) { static int init_done; - static int saved_flag; - int r, flag; - int32 n; + static int32 saved_flag; + int32 n, flag; + int r; for (;;) { switch (recv_state) { @@ -308,7 +452,7 @@ static int32 recv_deflated_token(int f, char **data) rx_strm.zfree = NULL; if (inflateInit2(&rx_strm, -15) != Z_OK) { rprintf(FERROR, "inflate init failed\n"); - exit_cleanup(RERR_STREAMIO); + exit_cleanup(RERR_PROTOCOL); } if (!(cbuf = new_array(char, MAX_DATA_COUNT)) || !(dbuf = new_array(char, AVAIL_OUT_SIZE(CHUNK_SIZE)))) @@ -426,7 +570,8 @@ static int32 recv_deflated_token(int f, char **data) */ static void see_deflate_token(char *buf, int32 len) { - int r, blklen; + int r; + int32 blklen; unsigned char hdr[5]; rx_strm.avail_in = 0; @@ -455,7 +600,7 @@ static void see_deflate_token(char *buf, int32 len) rx_strm.next_out = (Bytef *)dbuf; rx_strm.avail_out = AVAIL_OUT_SIZE(CHUNK_SIZE); r = inflate(&rx_strm, Z_SYNC_FLUSH); - if (r != Z_OK) { + if (r != Z_OK && r != Z_BUF_ERROR) { rprintf(FERROR, "inflate (token) returned %d\n", r); exit_cleanup(RERR_STREAMIO); } @@ -467,7 +612,7 @@ static void see_deflate_token(char *buf, int32 len) * If token == -1 then we have reached EOF * If n == 0 then don't send a buffer */ -void send_token(int f, int token, struct map_struct *buf, OFF_T offset, +void send_token(int f, int32 token, struct map_struct *buf, OFF_T offset, int32 n, int32 toklen) { if (!do_compression) @@ -476,7 +621,6 @@ void send_token(int f, int token, struct map_struct *buf, OFF_T offset, send_deflated_token(f, token, buf, offset, n, toklen); } - /* * receive a token or buffer from the other end. If the reurn value is >0 then * it is a data buffer of that length, and *data will point at the data.