X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/6e4fb64e6141727b8144bb77265bf0a4a8450a39..efd5ee57867a5de86692dff3ec0067c4113980fa:/token.c diff --git a/token.c b/token.c index 1244b2d6..c7e898ce 100644 --- a/token.c +++ b/token.c @@ -1,17 +1,17 @@ -/* +/* 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. @@ -21,7 +21,48 @@ #include "zlib/zlib.h" extern int do_compression; +extern int module_id; + +static int compression_level = Z_DEFAULT_COMPRESSION; + +/* determine the compression level based on a wildcard filename list */ +void set_compression(char *fname) +{ + char *dont; + char *tok; + + if (!do_compression) + return; + + compression_level = Z_DEFAULT_COMPRESSION; + dont = lp_dont_compress(module_id); + + if (!dont || !*dont) + return; + + if (dont[0] == '*' && !dont[1]) { + /* an optimization to skip the rest of this routine */ + compression_level = 0; + return; + } + + dont = strdup(dont); + fname = strdup(fname); + if (!dont || !fname) + return; + strlower(dont); + strlower(fname); + + for (tok = strtok(dont, " "); tok; tok = strtok(NULL, " ")) { + if (wildmatch(tok, fname)) { + compression_level = 0; + break; + } + } + free(dont); + free(fname); +} /* non-compressing recv token */ static int simple_recv_token(int f,char **data) @@ -31,13 +72,15 @@ static int simple_recv_token(int f,char **data) int n; if (!buf) { - buf = (char *)malloc(CHUNK_SIZE); - if (!buf) out_of_memory("simple_recv_token"); + buf = new_array(char, CHUNK_SIZE); + if (!buf) + out_of_memory("simple_recv_token"); } if (residue == 0) { int i = read_int(f); - if (i <= 0) return i; + if (i <= 0) + return i; residue = i; } @@ -79,6 +122,12 @@ static void simple_send_token(int f,int token, #define MAX_DATA_COUNT 16383 /* fit 14 bit count into 2 bytes with flags */ +/* zlib.h says that if we want to be able to compress something in a single + * call, avail_out must be at least 0.1% larger than avail_in plus 12 bytes. + * We'll add in 0.1%+16, just to be safe (and we'll avoid floating point, + * to ensure that this is a compile-time value). */ +#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; @@ -90,6 +139,14 @@ static z_stream tx_strm; /* Output buffer */ static char *obuf; +/* We want obuf to be able to hold both MAX_DATA_COUNT+2 bytes as well as + * AVAIL_OUT_SIZE(CHUNK_SIZE) bytes, so make sure that it's large enough. */ +#if MAX_DATA_COUNT+2 > AVAIL_OUT_SIZE(CHUNK_SIZE) +#define OBUF_SIZE (MAX_DATA_COUNT+2) +#else +#define OBUF_SIZE AVAIL_OUT_SIZE(CHUNK_SIZE) +#endif + /* Send a deflated token */ static void send_deflated_token(int f, int token, @@ -104,13 +161,13 @@ send_deflated_token(int f, int token, tx_strm.next_in = NULL; tx_strm.zalloc = NULL; tx_strm.zfree = NULL; - if (deflateInit2(&tx_strm, Z_DEFAULT_COMPRESSION, + if (deflateInit2(&tx_strm, compression_level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) { rprintf(FERROR, "compression init failed\n"); - exit_cleanup(1); + exit_cleanup(RERR_STREAMIO); } - if ((obuf = malloc(MAX_DATA_COUNT+2)) == NULL) + if ((obuf = new_array(char, OBUF_SIZE)) == NULL) out_of_memory("send_deflated_token"); init_done = 1; } else @@ -178,7 +235,7 @@ send_deflated_token(int f, int token, r = deflate(&tx_strm, flush); if (r != Z_OK) { rprintf(FERROR, "deflate returned %d\n", r); - exit_cleanup(1); + exit_cleanup(RERR_STREAMIO); } if (nb == 0 || tx_strm.avail_out == 0) { n = MAX_DATA_COUNT - tx_strm.avail_out; @@ -203,19 +260,18 @@ send_deflated_token(int f, int token, if (token == -1) { /* 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; tx_strm.next_out = (Bytef *) obuf; - tx_strm.avail_out = MAX_DATA_COUNT; + tx_strm.avail_out = AVAIL_OUT_SIZE(CHUNK_SIZE); r = deflate(&tx_strm, Z_INSERT_ONLY); 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(1); + exit_cleanup(RERR_STREAMIO); } } } @@ -250,10 +306,10 @@ 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(1); + exit_cleanup(RERR_STREAMIO); } - if ((cbuf = malloc(MAX_DATA_COUNT)) == NULL - || (dbuf = malloc(CHUNK_SIZE)) == NULL) + if (!(cbuf = new_array(char, MAX_DATA_COUNT)) + || !(dbuf = new_array(char, AVAIL_OUT_SIZE(CHUNK_SIZE)))) out_of_memory("recv_deflated_token"); init_done = 1; } else { @@ -282,9 +338,9 @@ recv_deflated_token(int f, char **data) /* check previous inflated stuff ended correctly */ rx_strm.avail_in = 0; rx_strm.next_out = (Bytef *)dbuf; - rx_strm.avail_out = CHUNK_SIZE; + rx_strm.avail_out = AVAIL_OUT_SIZE(CHUNK_SIZE); r = inflate(&rx_strm, Z_SYNC_FLUSH); - n = CHUNK_SIZE - rx_strm.avail_out; + n = AVAIL_OUT_SIZE(CHUNK_SIZE) - rx_strm.avail_out; /* * Z_BUF_ERROR just means no progress was * made, i.e. the decompressor didn't have @@ -293,7 +349,7 @@ recv_deflated_token(int f, char **data) if (r != Z_OK && r != Z_BUF_ERROR) { rprintf(FERROR, "inflate flush returned %d (%d bytes)\n", r, n); - exit_cleanup(1); + exit_cleanup(RERR_STREAMIO); } if (n != 0 && r != Z_BUF_ERROR) { /* have to return some more data and @@ -308,7 +364,7 @@ recv_deflated_token(int f, char **data) */ if (!inflateSyncPoint(&rx_strm)) { rprintf(FERROR, "decompressor lost sync!\n"); - exit_cleanup(1); + exit_cleanup(RERR_STREAMIO); } rx_strm.avail_in = 4; rx_strm.next_in = (Bytef *)cbuf; @@ -338,12 +394,12 @@ recv_deflated_token(int f, char **data) case r_inflating: rx_strm.next_out = (Bytef *)dbuf; - rx_strm.avail_out = CHUNK_SIZE; + rx_strm.avail_out = AVAIL_OUT_SIZE(CHUNK_SIZE); r = inflate(&rx_strm, Z_NO_FLUSH); - n = CHUNK_SIZE - rx_strm.avail_out; + n = AVAIL_OUT_SIZE(CHUNK_SIZE) - rx_strm.avail_out; if (r != Z_OK) { rprintf(FERROR, "inflate returned %d (%d bytes)\n", r, n); - exit_cleanup(1); + exit_cleanup(RERR_STREAMIO); } if (rx_strm.avail_in == 0) recv_state = r_inflated; @@ -395,18 +451,18 @@ static void see_deflate_token(char *buf, int len) } } rx_strm.next_out = (Bytef *)dbuf; - rx_strm.avail_out = CHUNK_SIZE; + rx_strm.avail_out = AVAIL_OUT_SIZE(CHUNK_SIZE); r = inflate(&rx_strm, Z_SYNC_FLUSH); if (r != Z_OK) { rprintf(FERROR, "inflate (token) returned %d\n", r); - exit_cleanup(1); + exit_cleanup(RERR_STREAMIO); } } while (len || rx_strm.avail_out == 0); } -/* - * transmit a verbatim buffer of length n followed by a token - * If token == -1 then we have reached EOF +/** + * Transmit a verbatim buffer of length @p n followed by a token. + * 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,