Split code to generate "rwx-----" strings into lib/permstring.c so it

[rsync/rsync.git] / token.c

diff --git a/token.c b/token.c
index 1244b2d..174f121 100644 (file)
--- a/token.c
+++ b/token.c
@@ -21,7 +21,44 @@
 #include "zlib/zlib.h"
 
 extern int do_compression;
+static int compression_level = Z_DEFAULT_COMPRESSION;
 
+/* determine the compression level based on a wildcard filename list */
+void set_compression(char *fname)
+{
+       extern int module_id;
+       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 (fnmatch(tok, fname, 0) == 0) {
+                       compression_level = 0;
+                       break;
+               }
+       }
+       free(dont);
+       free(fname);
+}
 
 /* non-compressing recv token */
 static int simple_recv_token(int f,char **data)
@@ -53,18 +90,29 @@ static int simple_recv_token(int f,char **data)
 static void simple_send_token(int f,int token,
                              struct map_struct *buf,OFF_T offset,int 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;
                }
        }
        /* 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) );
+               }
        }
 }
 
@@ -97,6 +145,8 @@ send_deflated_token(int f, int token,
 {
        int n, r;
        static int init_done, flush_pending;
+       extern int write_batch;  /* dw */
+       char temp_byte;   /* dw */
 
        if (last_token == -1) {
                /* initialization */
@@ -104,11 +154,11 @@ 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)
                                out_of_memory("send_deflated_token");
@@ -129,13 +179,27 @@ 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;
@@ -178,7 +242,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;
@@ -194,6 +258,8 @@ 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);
@@ -203,6 +269,10 @@ 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
@@ -215,7 +285,7 @@ send_deflated_token(int f, int token,
                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,7 +320,7 @@ 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)
@@ -293,7 +363,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 +378,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;
@@ -343,7 +413,7 @@ recv_deflated_token(int f, char **data)
                        n = 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;
@@ -399,7 +469,7 @@ static void see_deflate_token(char *buf, int len)
                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);
 }