X-Git-Url: https://mattmccutchen.net/rsync/rsync.git/blobdiff_plain/2473391971b10ab9fdec66714d25d2ba357a3ac8..d3d07a5e860f1cde0e234ec7a1aff7111a2c514f:/token.c

diff --git a/token.c b/token.c
index 0b3aa999..5e761485 100644
--- a/token.c
+++ b/token.c
@@ -1,80 +1,231 @@
-/* 
-   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-2008 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 "ifuncs.h"
 #include "zlib/zlib.h"
 
 extern int do_compression;
-static int compression_level = Z_DEFAULT_COMPRESSION;
+extern int module_id;
+extern int def_compress_level;
+extern char *skip_compress;
 
-/* determine the compression level based on a wildcard filename list */
-void set_compression(char *fname)
+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)
 {
-	extern int module_id;
-	char *dont;
-	char *tok;
+	struct suffix_tree *node, *newnode;
+
+	if (ltr == '[') {
+		const char *after = strchr(str, ']');
+		/* Just skip bogus character classes. */
+		if (!after++)
+			return;
+		while ((ltr = *str++) != ']')
+			add_suffix(prior, ltr, after);
+		return;
+	}
 
-	if (!do_compression) 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;
+}
 
-	compression_level = Z_DEFAULT_COMPRESSION;
-	dont = lp_dont_compress(module_id);
+static void add_nocompress_suffixes(const char *str)
+{
+	char *buf, *t;
+	const char *f = str;
 
-	if (!dont || !*dont) return;
+	if (!(buf = new_array(char, strlen(f) + 1)))
+		out_of_memory("add_nocompress_suffixes");
 
-	if ((dont[0] == '*') && (!dont[1])) {
-		/* an optimization to skip the rest of this routine */
-		compression_level = 0;
-		return;
+	while (*f) {
+		if (*f == '/') {
+			f++;
+			continue;
+		}
+
+		t = buf;
+		do {
+			if (isUpper(f))
+				*t++ = toLower(f);
+			else
+				*t++ = *f;
+		} while (*++f != '/' && *f);
+		*t++ = '\0';
+
+		fprintf(stderr, "adding `%s'\n", buf);
+		add_suffix(&suftree, *buf, buf+1);
 	}
 
-	dont = strdup(dont);
-	fname = strdup(fname);
-	if (!dont || !fname) return;
+	free(buf);
+}
 
-	strlower(dont);
-	strlower(fname);
+static void init_set_compression(void)
+{
+	const char *f;
+	char *t, *start;
 
-	for (tok=strtok(dont," ");tok;tok=strtok(NULL," ")) {
-		if (fnmatch(tok, fname, 0) == 0) {
-			compression_level = 0;
+	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);
+
+	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(const char *fname)
+{
+	const struct suffix_tree *node;
+	const char *s;
+	char ltr;
+
+	if (!do_compression)
+		return;
+
+	if (!match_list)
+		init_set_compression();
+
+	compression_level = per_file_default_level;
+
+	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;
+		}
+	}
+
+	if (!(node = suftree) || !(s = strrchr(fname, '.'))
+	 || s == fname || !(ltr = *++s))
+		return;
+
+	while (1) {
+		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 int simple_recv_token(int f,char **data)
+static int32 simple_recv_token(int f, char **data)
 {
-	static int residue;
+	static int32 residue;
 	static char *buf;
-	int n;
+	int32 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;
+		int32 i = read_int(f);
+		if (i <= 0)
+			return i;
 		residue = i;
 	}
 
@@ -85,38 +236,24 @@ static int 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,OFF_T offset,int n)
+static void simple_send_token(int f, int32 token, struct map_struct *buf,
+			      OFF_T offset, int32 n)
 {
-	extern int write_batch; /* dw */
-	int hold_int; /* dw */
-
 	if (n > 0) {
-		int l = 0;
-		while (l < n) {
-			int n1 = MIN(CHUNK_SIZE,n-l);
-			write_int(f,n1);
-			write_buf(f,map_ptr(buf,offset+l,n1),n1);
-			if (write_batch) {
-			    write_batch_delta_file( (char *) &n1, sizeof(int) );
-			    write_batch_delta_file(map_ptr(buf,offset+l,n1),n1);
-			}
-			l += n1;
+		int32 len = 0;
+		while (len < n) {
+			int32 n1 = MIN(CHUNK_SIZE, n-len);
+			write_int(f, n1);
+			write_buf(f, map_ptr(buf, offset+len, n1), n1);
+			len += n1;
 		}
 	}
 	/* a -2 token means to send data only and no token */
-	if (token != -2) {
-		write_int(f,-(token+1));
-		if (write_batch) {
-		    hold_int = -(token+1);
-		    write_batch_delta_file( (char *) &hold_int, sizeof(int) );
-		}
-	}
+	if (token != -2)
+		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 */
@@ -134,9 +271,9 @@ static void simple_send_token(int f,int token,
 #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;
@@ -154,13 +291,11 @@ static char *obuf;
 
 /* Send a deflated token */
 static void
-send_deflated_token(int f, int token,
-		    struct map_struct *buf, OFF_T offset, int nb, int toklen)
+send_deflated_token(int f, int32 token, struct map_struct *buf, OFF_T offset,
+		    int32 nb, int32 toklen)
 {
-	int n, r;
+	int32 n, r;
 	static int init_done, flush_pending;
-	extern int write_batch;  /* dw */
-	char temp_byte;   /* dw */
 
 	if (last_token == -1) {
 		/* initialization */
@@ -174,7 +309,7 @@ send_deflated_token(int f, int token,
 				rprintf(FERROR, "compression init failed\n");
 				exit_cleanup(RERR_STREAMIO);
 			}
-			if ((obuf = malloc(OBUF_SIZE)) == NULL)
+			if ((obuf = new_array(char, OBUF_SIZE)) == NULL)
 				out_of_memory("send_deflated_token");
 			init_done = 1;
 		} else
@@ -182,10 +317,8 @@ send_deflated_token(int f, int token,
 		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 */
@@ -193,27 +326,13 @@ send_deflated_token(int f, int token,
 		n = last_token - run_start;
 		if (r >= 0 && r <= 63) {
 			write_byte(f, (n==0? TOKEN_REL: TOKENRUN_REL) + r);
-			if (write_batch) { /* dw */
-			    temp_byte = (char)( (n==0? TOKEN_REL: TOKENRUN_REL) + r);
-			    write_batch_delta_file(&temp_byte,sizeof(char));
-			}
 		} else {
 			write_byte(f, (n==0? TOKEN_LONG: TOKENRUN_LONG));
 			write_int(f, run_start);
-			if (write_batch) { /* dw */
-			    temp_byte = (char)(n==0? TOKEN_LONG: TOKENRUN_LONG);
-			    write_batch_delta_file(&temp_byte,sizeof(temp_byte));
-			    write_batch_delta_file((char *)&run_start,sizeof(run_start));
-			}
 		}
 		if (n != 0) {
 			write_byte(f, n);
 			write_byte(f, n >> 8);
-			if (write_batch) { /* dw */
-			    write_batch_delta_file((char *)&n,sizeof(char));
-			    temp_byte = (char) n >> 8;
-			    write_batch_delta_file(&temp_byte,sizeof(temp_byte));
-			}
 		}
 		last_run_end = last_token;
 		run_start = token;
@@ -272,8 +391,6 @@ send_deflated_token(int f, int token,
 					obuf[0] = DEFLATED_DATA + (n >> 8);
 					obuf[1] = n;
 					write_buf(f, obuf, n+2);
-					if (write_batch) /* dw */
-					    write_batch_delta_file(obuf,n+2);
 				}
 			}
 		} while (nb != 0 || tx_strm.avail_out == 0);
@@ -283,28 +400,28 @@ send_deflated_token(int f, int token,
 	if (token == -1) {
 		/* end of file - clean up */
 		write_byte(f, END_FLAG);
-		if (write_batch) { /* dw */
-		    temp_byte = END_FLAG;
-		    write_batch_delta_file((char *)&temp_byte,sizeof(temp_byte));
-		}
-
 	} 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 = 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(RERR_STREAMIO);
-		}
+		/* Add the data in the current block to the compressor's
+		 * history and hash table. */
+		do {
+			/* 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 || 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 (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;
 
@@ -314,16 +431,16 @@ static char *cbuf;
 static char *dbuf;
 
 /* for decoding runs of tokens */
-static int rx_token;
-static int rx_run;
+static int32 rx_token;
+static int32 rx_run;
 
 /* Receive a deflated token and inflate it */
-static int
-recv_deflated_token(int f, char **data)
+static int32 recv_deflated_token(int f, char **data)
 {
-	int n, r, flag;
 	static int init_done;
-	static int saved_flag;
+	static int32 saved_flag;
+	int32 n, flag;
+	int r;
 
 	for (;;) {
 		switch (recv_state) {
@@ -336,8 +453,8 @@ recv_deflated_token(int f, char **data)
 					rprintf(FERROR, "inflate init failed\n");
 					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 {
@@ -366,9 +483,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
@@ -422,9 +539,9 @@ 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(RERR_STREAMIO);
@@ -450,9 +567,10 @@ recv_deflated_token(int f, char **data)
  * put the data corresponding to a token that we've just returned
  * from recv_deflated_token into the decompressor's history buffer.
  */
-static void see_deflate_token(char *buf, int len)
+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;
@@ -479,7 +597,7 @@ 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);
@@ -490,27 +608,25 @@ static void see_deflate_token(char *buf, int len)
 
 /**
  * Transmit a verbatim buffer of length @p n followed by a token.
- * If token == -1 then we have reached EOF 
+ * 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,
-		int n,int toklen)
+void send_token(int f, int32 token, struct map_struct *buf, OFF_T offset,
+		int32 n, int32 toklen)
 {
-	if (!do_compression) {
-		simple_send_token(f,token,buf,offset,n);
-	} else {
+	if (!do_compression)
+		simple_send_token(f, token, buf, offset, n);
+	else
 		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.
  * if the return value is -i then it represents token i-1
  * if the return value is 0 then the end has been reached
  */
-int recv_token(int f,char **data)
+int32 recv_token(int f, char **data)
 {
 	int tok;
 
@@ -525,7 +641,7 @@ int recv_token(int f,char **data)
 /*
  * look at the data corresponding to a token, if necessary
  */
-void see_token(char *data, int toklen)
+void see_token(char *data, int32 toklen)
 {
 	if (do_compression)
 		see_deflate_token(data, toklen);