Mention the EEXIST fix.
[rsync.git] / flist.c
diff --git a/flist.c b/flist.c
index 113592900b8bd820777355b54f584bc78d02cdd8..64ff00771249678b6b7e4daf875ee2da4d597fd0 100644 (file)
--- a/flist.c
+++ b/flist.c
 
 #include "rsync.h"
 
-extern struct stats stats;
-
 extern int verbose;
-extern int do_progress;
+extern int dry_run;
+extern int list_only;
 extern int am_root;
 extern int am_server;
 extern int am_daemon;
 extern int am_sender;
+extern int do_progress;
 extern int always_checksum;
 extern int module_id;
 extern int ignore_errors;
 extern int numeric_ids;
-
 extern int recurse;
 extern int xfer_dirs;
-extern char curr_dir[MAXPATHLEN];
-extern unsigned int curr_dir_len;
-extern char *backup_dir;
-extern char *backup_suffix;
 extern int filesfrom_fd;
-
 extern int one_file_system;
 extern int keep_dirlinks;
 extern int preserve_links;
@@ -58,29 +52,29 @@ extern int preserve_uid;
 extern int preserve_gid;
 extern int relative_paths;
 extern int implied_dirs;
-extern int make_backups;
-extern int backup_suffix_len;
 extern int copy_links;
 extern int copy_unsafe_links;
 extern int protocol_version;
 extern int sanitize_paths;
-extern int max_delete;
 extern int orig_umask;
-extern int list_only;
+extern struct stats stats;
+extern struct file_list *the_file_list;
+
+extern char curr_dir[MAXPATHLEN];
 
 extern struct filter_list_struct filter_list;
 extern struct filter_list_struct server_filter_list;
 
 int io_error;
+dev_t filesystem_dev; /* used to implement -x */
 
 static char empty_sum[MD4_SUM_LENGTH];
+static int flist_count_offset;
 static unsigned int file_struct_len;
-static struct file_list *received_flist, *sorting_flist;
-static dev_t filesystem_dev; /* used to implement -x */
-static int deletion_count = 0; /* used to implement --max-delete */
+static struct file_list *sorting_flist;
 
 static void clean_flist(struct file_list *flist, int strip_root, int no_dups);
-static void output_flist(struct file_list *flist, const char *whose_list);
+static void output_flist(struct file_list *flist);
 
 void init_flist(void)
 {
@@ -105,16 +99,16 @@ static void start_filelist_progress(char *kind)
 }
 
 
-static void emit_filelist_progress(const struct file_list *flist)
+static void emit_filelist_progress(int count)
 {
-       rprintf(FINFO, " %d files...\r", flist->count);
+       rprintf(FINFO, " %d files...\r", count);
 }
 
 
-static void maybe_emit_filelist_progress(const struct file_list *flist)
+static void maybe_emit_filelist_progress(int count)
 {
-       if (do_progress && show_filelist_p() && (flist->count % 100) == 0)
-               emit_filelist_progress(flist);
+       if (do_progress && show_filelist_p() && (count % 100) == 0)
+               emit_filelist_progress(count);
 }
 
 
@@ -269,7 +263,7 @@ static mode_t from_wire_mode(int mode)
 
 
 static void send_directory(int f, struct file_list *flist,
-                          char *fbuf, unsigned int offset);
+                          char *fbuf, int len);
 
 static char *flist_dir;
 static int flist_dir_len;
@@ -330,7 +324,7 @@ void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
        char fname[MAXPATHLEN];
        int l1, l2;
 
-       if (f == -1)
+       if (f < 0)
                return;
 
        if (!file) {
@@ -661,6 +655,9 @@ static struct file_struct *receive_file_entry(struct file_list *flist,
                if (flags & XMIT_TOP_DIR) {
                        in_del_hier = 1;
                        del_hier_name_len = file->dir.depth == 0 ? 0 : l1 + l2;
+                       if (relative_paths && del_hier_name_len > 2
+                           && basename_len == 1+1 && *basename == '.')
+                               del_hier_name_len -= 2;
                        file->flags |= FLAG_TOP_DIR | FLAG_DEL_HERE;
                } else if (in_del_hier) {
                        if (!relative_paths || !del_hier_name_len
@@ -950,7 +947,7 @@ skip_filters:
                STRUCT_STAT st2;
                int save_mode = file->mode;
                file->mode = S_IFDIR; /* find a directory w/our name */
-               if (flist_find(received_flist, file) >= 0
+               if (flist_find(the_file_list, file) >= 0
                    && do_stat(thisname, &st2) == 0 && S_ISDIR(st2.st_mode)) {
                        file->modtime = st2.st_mtime;
                        file->length = st2.st_size;
@@ -962,23 +959,23 @@ skip_filters:
                        file->mode = save_mode;
        }
 
-       if (!S_ISDIR(st.st_mode))
+       if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
                stats.total_size += st.st_size;
 
        return file;
 }
 
 
-void send_file_name(int f, struct file_list *flist, char *fname,
-                   int recursive, unsigned short base_flags)
+static struct file_struct *send_file_name(int f, struct file_list *flist,
+                                         char *fname, unsigned short base_flags)
 {
        struct file_struct *file;
-       char fbuf[MAXPATHLEN];
 
-       if (!(file = make_file(fname, flist, ALL_FILTERS)))
-               return;
+       file = make_file(fname, flist, f == -2 ? SERVER_FILTERS : ALL_FILTERS);
+       if (!file)
+               return NULL;
 
-       maybe_emit_filelist_progress(flist);
+       maybe_emit_filelist_progress(flist->count + flist_count_offset);
 
        flist_expand(flist);
 
@@ -986,8 +983,15 @@ void send_file_name(int f, struct file_list *flist, char *fname,
                flist->files[flist->count++] = file;
                send_file_entry(file, f, base_flags);
        }
+       return file;
+}
 
-       if (recursive && S_ISDIR(file->mode)
+static void send_if_directory(int f, struct file_list *flist,
+                             struct file_struct *file)
+{
+       char fbuf[MAXPATHLEN];
+
+       if (S_ISDIR(file->mode)
            && !(file->flags & FLAG_MOUNT_POINT) && f_name_to(file, fbuf)) {
                void *save_filters;
                unsigned int len = strlen(fbuf);
@@ -1006,17 +1010,19 @@ void send_file_name(int f, struct file_list *flist, char *fname,
 }
 
 
-/* Note that the "recurse" value either contains -1, for infinite recursion,
- * or a number >= 0 indicating how many levels of recursion we will allow.
- * This function is normally called by the sender, but the receiving side
- * also calls it from delete_in_dir() with f set to -1 so that we just
- * construct the file list in memory without sending it over the wire. */
+/* This function is normally called by the sender, but the receiving side also
+ * calls it from get_dirlist() with f set to -1 so that we just construct the
+ * file list in memory without sending it over the wire.  Also, get_dirlist()
+ * might call this with f set to -2, which also indicates that local filter
+ * rules should be ignored. */
 static void send_directory(int f, struct file_list *flist,
-                          char *fbuf, unsigned int len)
+                          char *fbuf, int len)
 {
        struct dirent *di;
+       unsigned remainder;
        char *p;
        DIR *d;
+       int start = flist->count;
 
        if (!(d = opendir(fbuf))) {
                io_error |= IOERR_GENERAL;
@@ -1028,29 +1034,37 @@ static void send_directory(int f, struct file_list *flist,
        if (len != 1 || *fbuf != '/')
                *p++ = '/';
        *p = '\0';
+       remainder = MAXPATHLEN - (p - fbuf);
 
        for (errno = 0, di = readdir(d); di; errno = 0, di = readdir(d)) {
                char *dname = d_name(di);
                if (dname[0] == '.' && (dname[1] == '\0'
                    || (dname[1] == '.' && dname[2] == '\0')))
                        continue;
-               if (strlcpy(p, dname, MAXPATHLEN - len) < MAXPATHLEN - len) {
-                       int do_subdirs = recurse >= 1 ? recurse-- : recurse;
-                       send_file_name(f, flist, fbuf, do_subdirs, 0);
-               } else {
+               if (strlcpy(p, dname, remainder) < remainder)
+                       send_file_name(f, flist, fbuf, 0);
+               else {
                        io_error |= IOERR_GENERAL;
                        rprintf(FINFO,
                                "cannot send long-named file %s\n",
                                full_fname(fbuf));
                }
        }
+
+       fbuf[len] = '\0';
+
        if (errno) {
                io_error |= IOERR_GENERAL;
-               *p = '\0';
                rsyserr(FERROR, errno, "readdir(%s)", full_fname(fbuf));
        }
 
        closedir(d);
+
+       if (recurse) {
+               int i, end = flist->count - 1;
+               for (i = start; i <= end; i++)
+                       send_if_directory(f, flist, flist->files[i]);
+       }
 }
 
 
@@ -1084,9 +1098,10 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
        }
 
        while (1) {
+               struct file_struct *file;
                char fname2[MAXPATHLEN];
                char *fname = fname2;
-               int do_subdirs;
+               int is_dot_dir;
 
                if (use_ff_fd) {
                        if (read_filesfrom_line(filesfrom_fd, fname) == 0)
@@ -1105,16 +1120,25 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
                        if (l == 2 && fname[0] == '.') {
                                /* Turn "./" into just "." rather than "./." */
                                fname[1] = '\0';
-                       } else if (l < MAXPATHLEN) {
+                       } else {
+                               if (l + 1 >= MAXPATHLEN)
+                                       overflow("send_file_list");
                                fname[l++] = '.';
                                fname[l] = '\0';
                        }
+                       is_dot_dir = 1;
+               } else if (l > 1 && fname[l-1] == '.' && fname[l-2] == '.'
+                   && (l == 2 || fname[l-3] == '/')) {
+                       if (l + 2 >= MAXPATHLEN)
+                               overflow("send_file_list");
+                       fname[l++] = '/';
+                       fname[l++] = '.';
+                       fname[l] = '\0';
+                       is_dot_dir = 1;
+               } else {
+                       is_dot_dir = fname[l-1] == '.'
+                                  && (l == 1 || fname[l-2] == '/');
                }
-               if (fname[l-1] == '.' && (l == 1 || fname[l-2] == '/')) {
-                       if (!recurse && xfer_dirs)
-                               recurse = 1; /* allow one level */
-               } else if (recurse > 0)
-                       recurse = 0;
 
                if (link_stat(fname, &st, keep_dirlinks) != 0) {
                        io_error |= IOERR_GENERAL;
@@ -1162,7 +1186,7 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
                                xfer_dirs = 1;
                                while ((slash = strchr(slash+1, '/')) != 0) {
                                        *slash = 0;
-                                       send_file_name(f, flist, fname, 0, 0);
+                                       send_file_name(f, flist, fname, 0);
                                        *slash = '/';
                                }
                                copy_links = save_copy_links;
@@ -1201,8 +1225,10 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
                if (one_file_system)
                        filesystem_dev = st.st_dev;
 
-               do_subdirs = recurse >= 1 ? recurse-- : recurse;
-               send_file_name(f, flist, fname, do_subdirs, XMIT_TOP_DIR);
+               if ((file = send_file_name(f, flist, fname, XMIT_TOP_DIR))) {
+                       if (recurse || (xfer_dirs && is_dot_dir))
+                               send_if_directory(f, flist, file);
+               }
 
                if (olddir[0]) {
                        flist_dir = NULL;
@@ -1254,7 +1280,7 @@ struct file_list *send_file_list(int f, int argc, char *argv[])
        stats.num_files = flist->count;
 
        if (verbose > 3)
-               output_flist(flist, who_am_i());
+               output_flist(flist);
 
        if (verbose > 2)
                rprintf(FINFO, "send_file_list done\n");
@@ -1275,7 +1301,6 @@ struct file_list *recv_file_list(int f)
        start_read = stats.total_read;
 
        flist = flist_new(WITH_HLINK, "recv_file_list");
-       received_flist = flist;
 
        flist->count = 0;
        flist->malloced = 1000;
@@ -1298,7 +1323,7 @@ struct file_list *recv_file_list(int f)
 
                flist->files[flist->count++] = file;
 
-               maybe_emit_filelist_progress(flist);
+               maybe_emit_filelist_progress(flist->count);
 
                if (verbose > 2) {
                        rprintf(FINFO, "recv_file_name(%s)\n",
@@ -1315,7 +1340,7 @@ struct file_list *recv_file_list(int f)
 
        clean_flist(flist, relative_paths, 1);
 
-       if (f != -1) {
+       if (f >= 0) {
                /* Now send the uid/gid list. This was introduced in
                 * protocol version 15 */
                recv_uid_list(f, flist);
@@ -1328,7 +1353,7 @@ struct file_list *recv_file_list(int f)
        }
 
        if (verbose > 3)
-               output_flist(flist, who_am_i());
+               output_flist(flist);
 
        if (list_only) {
                int i;
@@ -1446,8 +1471,12 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
 {
        int i, prev_i = 0;
 
-       if (!flist || flist->count == 0)
+       if (!flist)
                return;
+       if (flist->count == 0) {
+               flist->high = -1;
+               return;
+       }
 
        sorting_flist = flist;
        qsort(flist->files, flist->count,
@@ -1499,8 +1528,8 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
                        }
                        /* Make sure that if we unduplicate '.', that we don't
                         * lose track of a user-specified top directory. */
-                       if (flist->files[drop]->flags & FLAG_TOP_DIR)
-                               flist->files[keep]->flags |= FLAG_TOP_DIR;
+                       flist->files[keep]->flags |= flist->files[drop]->flags
+                                                  & (FLAG_TOP_DIR|FLAG_DEL_HERE);
 
                        clear_file(drop, flist);
 
@@ -1538,10 +1567,12 @@ static void clean_flist(struct file_list *flist, int strip_root, int no_dups)
        }
 }
 
-static void output_flist(struct file_list *flist, const char *whose_list)
+
+static void output_flist(struct file_list *flist)
 {
        char uidbuf[16], gidbuf[16], depthbuf[16];
        struct file_struct *file;
+       const char *who = who_am_i();
        int i;
 
        for (i = 0; i < flist->count; i++) {
@@ -1557,7 +1588,7 @@ static void output_flist(struct file_list *flist, const char *whose_list)
                if (!am_sender)
                        sprintf(depthbuf, "%d", file->dir.depth);
                rprintf(FINFO, "[%s] i=%d %s %s%s%s%s mode=0%o len=%.0f%s%s flags=%x\n",
-                       whose_list, i, am_sender ? NS(file->dir.root) : depthbuf,
+                       who, i, am_sender ? NS(file->dir.root) : depthbuf,
                        file->dirname ? safe_fname(file->dirname) : "",
                        file->dirname ? "/" : "", NS(file->basename),
                        S_ISDIR(file->mode) ? "/" : "", (int)file->mode,
@@ -1653,8 +1684,13 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
                                break;
                        case s_SLASH:
                                type1 = S_ISDIR(f1->mode) ? t_path : t_ITEM;
-                               state1 = s_BASE;
                                c1 = (uchar*)f1->basename;
+                               if (type1 == t_PATH && *c1 == '.' && !c1[1]) {
+                                       type1 = t_ITEM;
+                                       state1 = s_TRAILING;
+                                       c1 = (uchar*)"";
+                               } else
+                                       state1 = s_BASE;
                                break;
                        case s_BASE:
                                state1 = s_TRAILING;
@@ -1673,25 +1709,18 @@ int f_name_cmp(struct file_struct *f1, struct file_struct *f2)
                if (!*c2) {
                        switch (state2) {
                        case s_DIR:
-                               if (state1 == s_SLASH && sorting_flist) {
-                                       int j;
-                                       /* Optimize for future comparisons. */
-                                       for (j = 0;
-                                            j < sorting_flist->count;
-                                            j++) {
-                                               struct file_struct *fp
-                                                   = sorting_flist->files[j];
-                                               if (fp->dirname == f2->dirname)
-                                                       fp->dirname = f1->dirname;
-                                       }
-                               }
                                state2 = s_SLASH;
                                c2 = (uchar*)"/";
                                break;
                        case s_SLASH:
                                type2 = S_ISDIR(f2->mode) ? t_path : t_ITEM;
-                               state2 = s_BASE;
                                c2 = (uchar*)f2->basename;
+                               if (type2 == t_PATH && *c2 == '.' && !c2[1]) {
+                                       type2 = t_ITEM;
+                                       state2 = s_TRAILING;
+                                       c2 = (uchar*)"";
+                               } else
+                                       state2 = s_BASE;
                                break;
                        case s_BASE:
                                state2 = s_TRAILING;
@@ -1747,110 +1776,37 @@ char *f_name(struct file_struct *f)
 }
 
 
-static int is_backup_file(char *fn)
+/* Do a non-recursive scan of the named directory, possibly ignoring all
+ * exclude rules except for the daemon's.  If "dlen" is >=0, it is the length
+ * of the dirname string, and also indicates that "dirname" is a MAXPATHLEN
+ * buffer (the functions we call will append names onto the end, but the old
+ * dir value will be restored on exit). */
+struct file_list *get_dirlist(char *dirname, int dlen,
+                             int ignore_filter_rules)
 {
-       int k = strlen(fn) - backup_suffix_len;
-       return k > 0 && strcmp(fn+k, backup_suffix) == 0;
-}
-
-
-/* This function is used to implement per-directory deletion, and
- * is used by all the --delete-WHEN options.  Note that the fbuf
- * pointer must point to a MAXPATHLEN buffer with the name of the
- * directory in it (the functions we call will append names onto
- * the end, but the old dir value will be restored on exit). */
-void delete_in_dir(struct file_list *flist, char *fbuf,
-                  struct file_struct *file)
-{
-       static int min_depth = MAXPATHLEN, cur_depth = -1;
-       static void *filt_array[MAXPATHLEN/2+1];
-       struct file_list *dir_list;
-       STRUCT_STAT st;
-       int dlen;
-
-       if (!flist) {
-               while (cur_depth >= min_depth)
-                       pop_local_filters(filt_array[cur_depth--]);
-               min_depth = MAXPATHLEN;
-               cur_depth = -1;
-               return;
-       }
-       if (file->dir.depth >= MAXPATHLEN/2+1)
-               return; /* Impossible... */
+       struct file_list *dirlist;
+       char dirbuf[MAXPATHLEN];
+       int save_recurse = recurse;
 
-       if (max_delete && deletion_count >= max_delete)
-               return;
-
-       if (io_error && !(lp_ignore_errors(module_id) || ignore_errors)) {
-               rprintf(FINFO,
-                       "IO error encountered -- skipping file deletion\n");
-               max_delete = -1; /* avoid duplicating the above warning */
-               return;
+       if (dlen < 0) {
+               dlen = strlcpy(dirbuf, dirname, MAXPATHLEN);
+               if (dlen >= MAXPATHLEN)
+                       return NULL;
+               dirname = dirbuf;
        }
 
-       while (cur_depth >= file->dir.depth && cur_depth >= min_depth)
-               pop_local_filters(filt_array[cur_depth--]);
-       cur_depth = file->dir.depth;
-       if (min_depth > cur_depth)
-               min_depth = cur_depth;
-       dlen = strlen(fbuf);
-       filt_array[cur_depth] = push_local_filters(fbuf, dlen);
-
-       if (link_stat(fbuf, &st, keep_dirlinks) < 0)
-               return;
-
-       if (one_file_system && file->flags & FLAG_TOP_DIR)
-               filesystem_dev = st.st_dev;
-
-       dir_list = flist_new(WITHOUT_HLINK, "delete_in_dir");
+       dirlist = flist_new(WITHOUT_HLINK, "get_dirlist");
 
        recurse = 0;
-       send_directory(-1, dir_list, fbuf, dlen);
-       recurse = -1;
-       fbuf[dlen] = '\0';
+       send_directory(ignore_filter_rules ? -2 : -1, dirlist, dirname, dlen);
+       recurse = save_recurse;
+       if (do_progress)
+               flist_count_offset += dirlist->count;
 
-       if (verbose > 3)
-               output_flist(dir_list, "delete");
-
-       delete_missing(flist, dir_list, fbuf);
-
-       flist_free(dir_list);
-}
-
-
-/* If an item in dir_list is not found in full_list, delete it from the
- * filesystem. */
-void delete_missing(struct file_list *full_list, struct file_list *dir_list,
-                   const char *dirname)
-{
-       int i, mode;
-
-       if (max_delete && deletion_count >= max_delete)
-               return;
+       clean_flist(dirlist, 0, 0);
 
-       if (verbose > 2)
-               rprintf(FINFO, "delete_missing(%s)\n", safe_fname(dirname));
+       if (verbose > 3)
+               output_flist(dirlist);
 
-       for (i = dir_list->count; i--; ) {
-               if (!dir_list->files[i]->basename)
-                       continue;
-               mode = dir_list->files[i]->mode;
-               if (flist_find(full_list, dir_list->files[i]) < 0) {
-                       char *f = f_name(dir_list->files[i]);
-                       if (make_backups && (backup_dir || !is_backup_file(f))
-                         && !S_ISDIR(mode)) {
-                               make_backup(f);
-                               if (verbose) {
-                                       rprintf(FINFO, "deleting %s\n",
-                                               safe_fname(f));
-                               }
-                       } else if (S_ISDIR(mode))
-                               delete_file(f, DEL_DIR | DEL_FORCE_RECURSE);
-                       else
-                               delete_file(f, 0);
-                       deletion_count++;
-                       if (max_delete && deletion_count >= max_delete)
-                               break;
-               }
-       }
+       return dirlist;
 }