file_struct_len = offsetof(struct file_struct, flags) + sizeof f.flags;
}
-
static int show_filelist_p(void)
{
return verbose && xfer_dirs && !am_server;
rflush(FINFO);
}
-
static void emit_filelist_progress(int count)
{
rprintf(FINFO, " %d files...\r", count);
}
-
static void maybe_emit_filelist_progress(int count)
{
if (do_progress && show_filelist_p() && (count % 100) == 0)
emit_filelist_progress(count);
}
-
static void finish_filelist_progress(const struct file_list *flist)
{
if (do_progress) {
/* Nothing yet */
}
-
static void list_file_entry(struct file_struct *f)
{
char perms[11];
}
}
-
/**
* Stat either a symlink or its referent, depending on the settings of
* copy_links, copy_unsafe_links, etc.
return (mode_t)mode;
}
-
static void send_directory(int f, struct file_list *flist,
char *fbuf, int len);
} else
write_byte(f, flags);
} else {
- if (!(flags & 0xFF) && !S_ISDIR(mode))
- flags |= XMIT_TOP_DIR;
if (!(flags & 0xFF))
- flags |= XMIT_LONG_NAME;
+ flags |= S_ISDIR(mode) ? XMIT_LONG_NAME : XMIT_TOP_DIR;
write_byte(f, flags);
}
if (flags & XMIT_SAME_NAME)
}
#endif
- if (always_checksum) {
+ if (always_checksum && (S_ISREG(mode) || protocol_version < 28)) {
char *sum;
+ int slen = protocol_version < 21 ? 2 : MD4_SUM_LENGTH;
if (S_ISREG(mode))
sum = file->u.sum;
- else if (protocol_version < 28) {
+ else {
/* Prior to 28, we sent a useless set of nulls. */
sum = empty_sum;
- } else
- sum = NULL;
- if (sum) {
- write_buf(f, sum,
- protocol_version < 21 ? 2 : MD4_SUM_LENGTH);
}
+ write_buf(f, sum, slen);
}
strlcpy(lastname, fname, MAXPATHLEN);
io_write_phase = "unknown";
}
-
-
static struct file_struct *receive_file_entry(struct file_list *flist,
unsigned short flags, int f)
{
rprintf(FERROR,
"overflow: flags=0x%x l1=%d l2=%d lastname=%s\n",
flags, l1, l2, safe_fname(lastname));
- overflow("receive_file_entry");
+ overflow_exit("receive_file_entry");
}
strlcpy(thisname, lastname, l1 + 1);
if (linkname_len <= 0 || linkname_len > MAXPATHLEN) {
rprintf(FERROR, "overflow: linkname_len=%d\n",
linkname_len - 1);
- overflow("receive_file_entry");
+ overflow_exit("receive_file_entry");
}
}
else
if (basename_len == 1+1 && *basename == '.') /* +1 for '\0' */
file->dir.depth--;
if (flags & XMIT_TOP_DIR) {
- in_del_hier = 1;
+ in_del_hier = recurse;
del_hier_name_len = file->dir.depth == 0 ? 0 : l1 + l2;
if (relative_paths && del_hier_name_len > 2
&& basename_len == 1+1 && *basename == '.')
}
#endif
- if (always_checksum) {
+ if (always_checksum && (sum_len || protocol_version < 28)) {
char *sum;
+ int slen = protocol_version < 21 ? 2 : MD4_SUM_LENGTH;
if (sum_len) {
file->u.sum = sum = bp;
/*bp += sum_len;*/
- } else if (protocol_version < 28) {
+ } else {
/* Prior to 28, we get a useless set of nulls. */
sum = empty_sum;
- } else
- sum = NULL;
- if (sum) {
- read_buf(f, sum,
- protocol_version < 21 ? 2 : MD4_SUM_LENGTH);
}
+ read_buf(f, sum, slen);
}
if (!preserve_perms) {
return file;
}
-
/**
* Create a file_struct for a named file by reading its stat()
* information and performing extensive checks against global
return file;
}
-
static struct file_struct *send_file_name(int f, struct file_list *flist,
char *fname, unsigned short base_flags)
{
}
}
-
/* 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()
}
}
-
struct file_list *send_file_list(int f, int argc, char *argv[])
{
int l;
}
while (1) {
- struct file_struct *file;
char fname2[MAXPATHLEN];
char *fname = fname2;
int is_dot_dir;
fname[1] = '\0';
} else {
if (l + 1 >= MAXPATHLEN)
- overflow("send_file_list");
+ overflow_exit("send_file_list");
fname[l++] = '.';
fname[l] = '\0';
}
} else if (l > 1 && fname[l-1] == '.' && fname[l-2] == '.'
&& (l == 2 || fname[l-3] == '/')) {
if (l + 2 >= MAXPATHLEN)
- overflow("send_file_list");
+ overflow_exit("send_file_list");
fname[l++] = '/';
fname[l++] = '.';
fname[l] = '\0';
if (!relative_paths) {
p = strrchr(fname, '/');
if (p) {
- *p = 0;
+ *p = '\0';
if (p == fname)
dir = "/";
else
dir = fname;
fname = p + 1;
}
- } else if (implied_dirs && (p=strrchr(fname,'/')) && p != fname) {
- /* this ensures we send the intermediate directories,
- thus getting their permissions right */
- char *lp = lastpath, *fn = fname, *slash = fname;
- *p = 0;
- /* Skip any initial directories in our path that we
- * have in common with lastpath. */
- while (*fn && *lp == *fn) {
- if (*fn == '/')
- slash = fn;
- lp++, fn++;
- }
- *p = '/';
- if (fn != p || (*lp && *lp != '/')) {
- int save_copy_links = copy_links;
- int save_xfer_dirs = xfer_dirs;
- copy_links = copy_unsafe_links;
- xfer_dirs = 1;
- while ((slash = strchr(slash+1, '/')) != 0) {
- *slash = 0;
- send_file_name(f, flist, fname, 0);
- *slash = '/';
- }
- copy_links = save_copy_links;
- xfer_dirs = save_xfer_dirs;
- *p = 0;
- strlcpy(lastpath, fname, sizeof lastpath);
- *p = '/';
- }
+ } else if ((p = strstr(fname, "/./")) != NULL) {
+ *p = '\0';
+ if (p == fname)
+ dir = "/";
+ else
+ dir = fname;
+ fname = p + 3;
}
if (!*fname)
static char *lastdir;
static int lastdir_len;
- strcpy(olddir, curr_dir); /* can't overflow */
+ strlcpy(olddir, curr_dir, sizeof olddir);
if (!push_dir(dir)) {
io_error |= IOERR_GENERAL;
}
}
+ if (implied_dirs && (p=strrchr(fname,'/')) && p != fname) {
+ /* Send the implied directories at the start of the
+ * source spec, so we get their permissions right. */
+ char *lp = lastpath, *fn = fname, *slash = fname;
+ *p = '\0';
+ /* Skip any initial directories in our path that we
+ * have in common with lastpath. */
+ while (*fn && *lp == *fn) {
+ if (*fn == '/')
+ slash = fn;
+ lp++, fn++;
+ }
+ *p = '/';
+ if (fn != p || (*lp && *lp != '/')) {
+ int save_copy_links = copy_links;
+ int save_xfer_dirs = xfer_dirs;
+ copy_links = copy_unsafe_links;
+ xfer_dirs = 1;
+ while ((slash = strchr(slash+1, '/')) != 0) {
+ *slash = '\0';
+ send_file_name(f, flist, fname, 0);
+ *slash = '/';
+ }
+ copy_links = save_copy_links;
+ xfer_dirs = save_xfer_dirs;
+ *p = '\0';
+ strlcpy(lastpath, fname, sizeof lastpath);
+ *p = '/';
+ }
+ }
+
if (one_file_system)
filesystem_dev = st.st_dev;
- if ((file = send_file_name(f, flist, fname, XMIT_TOP_DIR))) {
- if (recurse || (xfer_dirs && is_dot_dir))
+ if (recurse || (xfer_dirs && is_dot_dir)) {
+ struct file_struct *file;
+ if ((file = send_file_name(f, flist, fname, XMIT_TOP_DIR)))
send_if_directory(f, flist, file);
- }
+ } else
+ send_file_name(f, flist, fname, 0);
if (olddir[0]) {
flist_dir = NULL;
flist_dir_len = 0;
if (!pop_dir(olddir)) {
rsyserr(FERROR, errno, "pop_dir %s failed",
- full_fname(dir));
+ full_fname(olddir));
exit_cleanup(RERR_FILESELECT);
}
}
return flist;
}
-
struct file_list *recv_file_list(int f)
{
struct file_list *flist;
return NULL; /* not reached */
}
-
static int file_compare(struct file_struct **file1, struct file_struct **file2)
{
return f_name_cmp(*file1, *file2);
}
-
/* Search for an identically-named item in the file list. Note that the
* items must agree in their directory-ness, or no match is returned. */
int flist_find(struct file_list *flist, struct file_struct *f)
return -1;
}
-
/*
* Free up any resources a file_struct has allocated
* and clear the file.
memset(flist->files[i], 0, file_struct_len);
}
-
/*
* allocate a new file list
*/
free(flist);
}
-
/*
* This routine ensures we don't have any duplicate names in our file list.
* duplicate names can cause corruption because of the pipelining
{
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,
}
}
-
static void output_flist(struct file_list *flist)
{
char uidbuf[16], gidbuf[16], depthbuf[16];
}
}
-
enum fnc_state { s_DIR, s_SLASH, s_BASE, s_TRAILING };
enum fnc_type { t_PATH, t_ITEM };
return dif;
}
-
/* Return a copy of the full filename of a flist entry, using the indicated
* buffer. No size-checking is done because we checked the size when creating
* the file_struct entry.
return fbuf;
}
-
/* Like f_name_to(), but we rotate through 5 static buffers of our own. */
char *f_name(struct file_struct *f)
{
return f_name_to(f, names[n]);
}
-
/* 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