extern int am_server;
extern int am_daemon;
extern int am_sender;
+extern int am_generator;
extern int inc_recurse;
extern int do_progress;
extern int always_checksum;
extern struct filter_list_struct filter_list;
extern struct filter_list_struct server_filter_list;
+#ifdef ICONV_OPTION
+extern int ic_ndx;
+extern int need_unsorted_flist;
+extern iconv_t ic_send, ic_recv;
+#endif
+
int io_error;
int checksum_len;
dev_t filesystem_dev; /* used to implement -x */
rprintf(FINFO,"copying unsafe symlink \"%s\" -> \"%s\"\n",
path, linkbuf);
}
- return do_stat(path, stp);
+ return x_stat(path, stp, NULL);
}
}
return 0;
#else
- return do_stat(path, stp);
+ return x_stat(path, stp, NULL);
#endif
}
{
#ifdef SUPPORT_LINKS
if (copy_links)
- return do_stat(path, stp);
- if (do_lstat(path, stp) < 0)
+ return x_stat(path, stp, NULL);
+ if (x_lstat(path, stp, NULL) < 0)
return -1;
if (follow_dirlinks && S_ISLNK(stp->st_mode)) {
STRUCT_STAT st;
- if (do_stat(path, &st) == 0 && S_ISDIR(st.st_mode))
+ if (x_stat(path, &st, NULL) == 0 && S_ISDIR(st.st_mode))
*stp = st;
}
return 0;
#else
- return do_stat(path, stp);
+ return x_stat(path, stp, NULL);
#endif
}
return 0;
}
-static int to_wire_mode(mode_t mode)
-{
-#ifdef SUPPORT_LINKS
-#if _S_IFLNK != 0120000
- if (S_ISLNK(mode))
- return (mode & ~(_S_IFMT)) | 0120000;
-#endif
-#endif
- return mode;
-}
-
-static mode_t from_wire_mode(int mode)
-{
-#if _S_IFLNK != 0120000
- if ((mode & (_S_IFMT)) == 0120000)
- return (mode & ~(_S_IFMT)) | _S_IFLNK;
-#endif
- return mode;
-}
-
static void send_directory(int f, struct file_list *flist, int ndx,
char *fbuf, int len, int flags);
-static const char *flist_dir, *orig_dir;
-static int flist_dir_len;
+static const char *pathname, *orig_dir;
+static int pathname_len;
/**
out_of_memory("flist_expand");
}
-int push_flist_dir(const char *dir, int len)
+int push_pathname(const char *dir, int len)
{
- if (dir == flist_dir)
+ if (dir == pathname)
return 1;
if (!orig_dir)
orig_dir = strdup(curr_dir);
- if (flist_dir && !pop_dir(orig_dir)) {
+ if (pathname && !pop_dir(orig_dir)) {
rsyserr(FERROR, errno, "pop_dir %s failed",
full_fname(orig_dir));
exit_cleanup(RERR_FILESELECT);
return 0;
}
- flist_dir = dir;
- flist_dir_len = len >= 0 ? len : dir ? (int)strlen(dir) : 0;
+ pathname = dir;
+ pathname_len = len >= 0 ? len : dir ? (int)strlen(dir) : 0;
return 1;
}
int l1, l2;
int flags;
- f_name(file, fname);
+#ifdef ICONV_OPTION
+ if (ic_send != (iconv_t)-1) {
+ ICONV_CONST char *ibuf;
+ char *obuf = fname;
+ size_t ocnt = MAXPATHLEN, icnt;
+
+ iconv(ic_send, NULL,0, NULL,0);
+ if ((ibuf = (ICONV_CONST char *)file->dirname) != NULL) {
+ icnt = strlen(ibuf);
+ ocnt--; /* pre-subtract the space for the '/' */
+ if (iconv(ic_send, &ibuf,&icnt, &obuf,&ocnt) == (size_t)-1)
+ goto convert_error;
+ *obuf++ = '/';
+ }
+
+ ibuf = (ICONV_CONST char *)file->basename;
+ icnt = strlen(ibuf);
+ if (iconv(ic_send, &ibuf,&icnt, &obuf,&ocnt) == (size_t)-1) {
+ convert_error:
+ io_error |= IOERR_GENERAL;
+ rprintf(FINFO,
+ "[%s] cannot convert filename: %s (%s)\n",
+ who_am_i(), f_name(file, fname), strerror(errno));
+ return;
+ }
+ *obuf = '\0';
+ } else
+#endif
+ f_name(file, fname);
flags = file->flags & FLAG_TOP_DIR; /* FLAG_TOP_DIR == XMIT_TOP_DIR */
static struct file_struct *recv_file_entry(struct file_list *flist,
int flags, int f)
{
- static time_t modtime;
+ static int64 modtime;
static mode_t mode;
static int64 dev;
static dev_t rdev;
int first_hlink_ndx = -1;
OFF_T file_length;
const char *basename;
- char *bp;
struct file_struct *file;
+ alloc_pool_t *pool;
+ char *bp;
if (flags & XMIT_SAME_NAME)
l1 = read_byte(f);
read_sbuf(f, &thisname[l1], l2);
thisname[l1 + l2] = 0;
- strlcpy(lastname, thisname, MAXPATHLEN);
+ /* Abuse basename_len for a moment... */
+ basename_len = strlcpy(lastname, thisname, MAXPATHLEN);
+
+#ifdef ICONV_OPTION
+ if (ic_recv != (iconv_t)-1) {
+ char *obuf = thisname, *ibuf = lastname;
+ size_t ocnt = MAXPATHLEN, icnt = basename_len;
+
+ if (icnt >= MAXPATHLEN) {
+ errno = E2BIG;
+ goto convert_error;
+ }
+
+ iconv(ic_recv, NULL,0, NULL,0);
+ if (iconv(ic_recv, &ibuf,&icnt, &obuf,&ocnt) == (size_t)-1) {
+ convert_error:
+ io_error |= IOERR_GENERAL;
+ rprintf(FINFO,
+ "[%s] cannot convert filename: %s (%s)\n",
+ who_am_i(), lastname, strerror(errno));
+ obuf = thisname;
+ }
+ *obuf = '\0';
+ }
+#endif
clean_fname(thisname, 0);
file_length = read_varlong30(f, 3);
if (!(flags & XMIT_SAME_TIME)) {
- if (protocol_version >= 30)
- modtime = (time_t)read_varlong(f, 4);
- else
- modtime = (time_t)read_int(f);
+ if (protocol_version >= 30) {
+ modtime = read_varlong(f, 4);
+#if SIZEOF_TIME_T < SIZEOF_INT64
+ if ((modtime > INT_MAX || modtime < INT_MIN) && !am_generator) {
+ rprintf(FERROR,
+ "Time value of %s truncated on receiver.\n",
+ lastname);
+ }
+#endif
+ } else
+ modtime = read_int(f);
}
if (!(flags & XMIT_SAME_MODE))
mode = from_wire_mode(read_int(f));
/* Room to save the dir's device for -x */
extra_len += 2 * EXTRA_LEN;
}
- flist = dir_flist;
- }
+ pool = dir_flist->file_pool;
+ } else
+ pool = flist->file_pool;
alloc_len = FILE_STRUCT_LEN + extra_len + basename_len
+ linkname_len;
- bp = pool_alloc(flist->file_pool, alloc_len, "recv_file_entry");
+ bp = pool_alloc(pool, alloc_len, "recv_file_entry");
memset(bp, 0, extra_len + FILE_STRUCT_LEN);
bp += extra_len;
if (flags & XMIT_HLINKED)
file->flags |= FLAG_HLINKED;
#endif
- file->modtime = modtime;
+ file->modtime = (time_t)modtime;
file->len32 = (uint32)file_length;
if (file_length > 0xFFFFFFFFu && S_ISREG(mode)) {
file->flags |= FLAG_LENGTH64;
F_OWNER(file) = uid;
if (preserve_gid)
F_GROUP(file) = gid;
+#ifdef ICONV_OPTION
+ if (ic_ndx)
+ F_NDX(file) = flist->count + flist->ndx_start;
+#endif
if (basename != thisname) {
file->dirname = lastdir;
char *bp;
if (strlcpy(thisname, fname, sizeof thisname)
- >= sizeof thisname - flist_dir_len) {
+ >= sizeof thisname - pathname_len) {
rprintf(FINFO, "skipping overly long name: %s\n", fname);
return NULL;
}
if (save_errno == ENOENT) {
#ifdef SUPPORT_LINKS
/* Avoid "vanished" error if symlink points nowhere. */
- if (copy_links && do_lstat(thisname, &st) == 0
+ if (copy_links && x_lstat(thisname, &st, NULL) == 0
&& S_ISLNK(st.st_mode)) {
io_error |= IOERR_GENERAL;
rprintf(FERROR, "symlink has no referent: %s\n",
if (always_checksum && am_sender && S_ISREG(st.st_mode))
file_checksum(thisname, tmp_sum, st.st_size);
- F_ROOTDIR(file) = flist_dir;
+ F_PATHNAME(file) = pathname;
/* This code is only used by the receiver when it is building
* a list of files for a delete pass. */
int save_mode = file->mode;
file->mode = S_IFDIR; /* Find a directory with our name. */
if (flist_find(dir_flist, file) >= 0
- && do_stat(thisname, &st2) == 0 && S_ISDIR(st2.st_mode)) {
+ && x_stat(thisname, &st2, NULL) == 0 && S_ISDIR(st2.st_mode)) {
file->modtime = st2.st_mtime;
file->len32 = 0;
file->mode = st2.st_mode;
* files in the upcoming file-lists. */
if (cur_flist->next) {
flist = first_flist->prev; /* the newest flist */
- future_cnt = flist->count
- + flist->ndx_start - cur_flist->next->ndx_start;
+ future_cnt = flist->count + flist->ndx_start
+ - cur_flist->next->ndx_start;
} else
future_cnt = 0;
while (future_cnt < at_least) {
f_name(file, fbuf);
dlen = strlen(fbuf);
- if (F_ROOTDIR(file) != flist_dir) {
- if (!push_flist_dir(F_ROOTDIR(file), -1))
+ if (F_PATHNAME(file) != pathname) {
+ if (!push_pathname(F_PATHNAME(file), -1))
exit_cleanup(RERR_FILESELECT);
}
write_ndx(f, NDX_FLIST_OFFSET - send_dir_ndx);
change_local_filter_dir(fbuf, dlen, send_dir_depth);
- send_directory(f, flist, send_dir_ndx, fbuf, dlen, FLAG_DIVERT_DIRS | FLAG_XFER_DIR);
+ send_directory(f, flist, send_dir_ndx, fbuf, dlen,
+ FLAG_DIVERT_DIRS | FLAG_XFER_DIR);
write_byte(f, 0);
- clean_flist(flist, 0, 0);
+#ifdef ICONV_OPTION
+ if (!need_unsorted_flist)
+#endif
+ {
+ flist->sorted = flist->files;
+ clean_flist(flist, 0, 0);
+ }
file_total += flist->count;
future_cnt += flist->count;
stats.flist_size += stats.total_written - start_write;
struct file_list *send_file_list(int f, int argc, char *argv[])
{
- int len;
+ static const char *lastdir;
+ static int lastdir_len = -1;
+ int len, dirlen;
STRUCT_STAT st;
char *p, *dir;
char lastpath[MAXPATHLEN] = "";
fn = ".";
}
- if (dir && *dir) {
- static const char *lastdir;
- static int lastdir_len = -1;
- int len = strlen(dir);
-
- if (len != lastdir_len || memcmp(lastdir, dir, len) != 0) {
- if (!push_flist_dir(strdup(dir), len))
- goto push_error;
- lastdir = flist_dir;
- lastdir_len = flist_dir_len;
- } else if (!push_flist_dir(lastdir, lastdir_len)) {
- push_error:
- io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno, "push_dir %s failed in %s",
- full_fname(dir), curr_dir);
- continue;
- }
+ dirlen = dir ? strlen(dir) : 0;
+ if (dirlen != lastdir_len || memcmp(lastdir, dir, dirlen) != 0) {
+ if (!push_pathname(dir ? strdup(dir) : NULL, dirlen))
+ goto push_error;
+ lastdir = pathname;
+ lastdir_len = pathname_len;
+ } else if (!push_pathname(lastdir, lastdir_len)) {
+ push_error:
+ io_error |= IOERR_GENERAL;
+ rsyserr(FERROR, errno, "push_dir %s failed in %s",
+ full_fname(dir), curr_dir);
+ continue;
}
if (fn != fbuf)
if (recurse || (xfer_dirs && is_dot_dir)) {
struct file_struct *file;
- int top_flags = FLAG_TOP_DIR | FLAG_XFER_DIR
- | (is_dot_dir ? 0 : flags)
- | (inc_recurse ? FLAG_DIVERT_DIRS : 0);
+ int top_flags = FLAG_TOP_DIR | FLAG_XFER_DIR | flags;
file = send_file_name(f, flist, fbuf, &st,
top_flags, ALL_FILTERS);
if (file && !inc_recurse)
stats.flist_xfertime = (int64)(end_tv.tv_sec - start_tv.tv_sec) * 1000
+ (end_tv.tv_usec - start_tv.tv_usec) / 1000;
+ /* When converting names, both sides keep an unsorted file-list array
+ * because the names will differ on the sending and receiving sides
+ * (both sides will use the unsorted index number for each item). */
+
/* Sort the list without removing any duplicates in non-incremental
* mode. This allows the receiving side to ask for whatever name it
* kept. For incremental mode, the sender also removes duplicates
* in this initial file-list so that it avoids re-sending duplicated
* directories. */
- clean_flist(flist, 0, inc_recurse);
+#ifdef ICONV_OPTION
+ if (need_unsorted_flist) {
+ if (inc_recurse) {
+ if (!(flist->sorted = new_array(struct file_struct *, flist->count)))
+ out_of_memory("recv_file_list");
+ memcpy(flist->sorted, flist->files,
+ flist->count * sizeof (struct file_struct*));
+ clean_flist(flist, 0, 1);
+ }
+ } else
+#endif
+ {
+ flist->sorted = flist->files;
+ clean_flist(flist, 0, inc_recurse);
+ }
file_total += flist->count;
if (!numeric_ids && !inc_recurse)
if (show_filelist_p())
finish_filelist_progress(flist);
+#ifdef ICONV_OPTION
+ if (need_unsorted_flist) {
+ /* Create an extra array of index pointers that we can sort for
+ * the generator's use (for wading through the files in sorted
+ * order and for calling flist_find()). We keep the "files"
+ * list unsorted for our exchange of index numbers with the
+ * other side (since their names may not sort the same). */
+ if (!(flist->sorted = new_array(struct file_struct *, flist->count)))
+ out_of_memory("recv_file_list");
+ memcpy(flist->sorted, flist->files,
+ flist->count * sizeof (struct file_struct*));
+ } else
+#endif
+ flist->sorted = flist->files;
+
clean_flist(flist, relative_paths, 1);
if (inc_recurse) {
- qsort(dir_flist->files + dstart, dir_flist->count - dstart,
- sizeof dir_flist->files[0], (int (*)())file_compare);
+ dir_flist->sorted = dir_flist->files;
+ qsort(dir_flist->sorted + dstart, dir_flist->count - dstart,
+ sizeof dir_flist->sorted[0], (int (*)())file_compare);
} else if (f >= 0)
recv_uid_list(f, flist);
while (low <= high) {
mid = (low + high) / 2;
- if (F_IS_ACTIVE(flist->files[mid]))
+ if (F_IS_ACTIVE(flist->sorted[mid]))
mid_up = mid;
else {
/* Scan for the next non-empty entry using the cached
* distance values. If the value isn't fully up-to-
* date, update it. */
- mid_up = mid + F_DEPTH(flist->files[mid]);
- if (!F_IS_ACTIVE(flist->files[mid_up])) {
+ mid_up = mid + F_DEPTH(flist->sorted[mid]);
+ if (!F_IS_ACTIVE(flist->sorted[mid_up])) {
do {
- mid_up += F_DEPTH(flist->files[mid_up]);
- } while (!F_IS_ACTIVE(flist->files[mid_up]));
- F_DEPTH(flist->files[mid]) = mid_up - mid;
+ mid_up += F_DEPTH(flist->sorted[mid_up]);
+ } while (!F_IS_ACTIVE(flist->sorted[mid_up]));
+ F_DEPTH(flist->sorted[mid]) = mid_up - mid;
}
if (mid_up > high) {
/* If there's nothing left above us, set high to
* a non-empty entry below us and continue. */
- high = mid - (int)flist->files[mid]->len32;
- if (!F_IS_ACTIVE(flist->files[high])) {
+ high = mid - (int)flist->sorted[mid]->len32;
+ if (!F_IS_ACTIVE(flist->sorted[high])) {
do {
- high -= (int)flist->files[high]->len32;
- } while (!F_IS_ACTIVE(flist->files[high]));
- flist->files[mid]->len32 = mid - high;
+ high -= (int)flist->sorted[high]->len32;
+ } while (!F_IS_ACTIVE(flist->sorted[high]));
+ flist->sorted[mid]->len32 = mid - high;
}
continue;
}
}
- diff = f_name_cmp(flist->files[mid_up], f);
+ diff = f_name_cmp(flist->sorted[mid_up], f);
if (diff == 0) {
if (protocol_version < 29
- && S_ISDIR(flist->files[mid_up]->mode)
+ && S_ISDIR(flist->sorted[mid_up]->mode)
!= S_ISDIR(f->mode))
return -1;
return mid_up;
}
pool_destroy(flist->file_pool);
+ if (flist->sorted && flist->sorted != flist->files)
+ free(flist->sorted);
free(flist->files);
free(flist);
}
return;
}
- qsort(flist->files, flist->count,
- sizeof flist->files[0], (int (*)())file_compare);
+ qsort(flist->sorted, flist->count,
+ sizeof flist->sorted[0], (int (*)())file_compare);
for (i = no_dups? 0 : flist->count; i < flist->count; i++) {
- if (F_IS_ACTIVE(flist->files[i])) {
+ if (F_IS_ACTIVE(flist->sorted[i])) {
prev_i = i;
break;
}
flist->low = prev_i;
while (++i < flist->count) {
int j;
- struct file_struct *file = flist->files[i];
+ struct file_struct *file = flist->sorted[i];
if (!F_IS_ACTIVE(file))
continue;
- if (f_name_cmp(file, flist->files[prev_i]) == 0)
+ if (f_name_cmp(file, flist->sorted[prev_i]) == 0)
j = prev_i;
else if (protocol_version >= 29 && S_ISDIR(file->mode)) {
int save_mode = file->mode;
} else
j = -1;
if (j >= 0) {
- struct file_struct *fp = flist->files[j];
+ struct file_struct *fp = flist->sorted[j];
int keep, drop;
/* If one is a dir and the other is not, we want to
* keep the dir because it might have contents in the
}
/* Make sure we don't lose track of a user-specified
* top directory. */
- flist->files[keep]->flags |= flist->files[drop]->flags
+ flist->sorted[keep]->flags |= flist->sorted[drop]->flags
& (FLAG_TOP_DIR|FLAG_XFER_DIR);
- clear_file(flist->files[drop]);
+ clear_file(flist->sorted[drop]);
if (keep == i) {
if (flist->low == drop) {
for (j = drop + 1;
- j < i && !F_IS_ACTIVE(flist->files[j]);
+ j < i && !F_IS_ACTIVE(flist->sorted[j]);
j++) {}
flist->low = j;
}
/* We need to strip off the leading slashes for relative
* paths, but this must be done _after_ the sorting phase. */
for (i = flist->low; i <= flist->high; i++) {
- struct file_struct *file = flist->files[i];
+ struct file_struct *file = flist->sorted[i];
if (!file->dirname)
continue;
prev_i = 0; /* It's OK that this isn't really true. */
for (i = flist->low; i <= flist->high; i++) {
- struct file_struct *fp, *file = flist->files[i];
+ struct file_struct *fp, *file = flist->sorted[i];
/* This temporarily abuses the F_DEPTH() value for a
* directory that is in a chain that might get pruned.
if (S_ISDIR(file->mode) && F_DEPTH(file)) {
/* Dump empty dirs when coming back down. */
for (j = prev_depth; j >= F_DEPTH(file); j--) {
- fp = flist->files[prev_i];
+ fp = flist->sorted[prev_i];
if (F_DEPTH(fp) >= 0)
break;
prev_i = -F_DEPTH(fp)-1;
ALL_FILTERS)) {
/* Keep dirs through this dir. */
for (j = prev_depth-1; ; j--) {
- fp = flist->files[prev_i];
+ fp = flist->sorted[prev_i];
if (F_DEPTH(fp) >= 0)
break;
prev_i = -F_DEPTH(fp)-1;
} else {
/* Keep dirs through this non-dir. */
for (j = prev_depth; ; j--) {
- fp = flist->files[prev_i];
+ fp = flist->sorted[prev_i];
if (F_DEPTH(fp) >= 0)
break;
prev_i = -F_DEPTH(fp)-1;
}
/* Dump all remaining empty dirs. */
while (1) {
- struct file_struct *fp = flist->files[prev_i];
+ struct file_struct *fp = flist->sorted[prev_i];
if (F_DEPTH(fp) >= 0)
break;
prev_i = -F_DEPTH(fp)-1;
}
for (i = flist->low; i <= flist->high; i++) {
- if (F_IS_ACTIVE(flist->files[i]))
+ if (F_IS_ACTIVE(flist->sorted[i]))
break;
}
flist->low = i;
for (i = flist->high; i >= flist->low; i--) {
- if (F_IS_ACTIVE(flist->files[i]))
+ if (F_IS_ACTIVE(flist->sorted[i]))
break;
}
flist->high = i;
if (!am_sender)
snprintf(depthbuf, sizeof depthbuf, "%d", F_DEPTH(file));
if (F_IS_ACTIVE(file)) {
- root = am_sender ? NS(F_ROOTDIR(file)) : depthbuf;
+ root = am_sender ? NS(F_PATHNAME(file)) : depthbuf;
if ((dir = file->dirname) == NULL)
dir = slash = "";
else
if (do_progress)
flist_count_offset += dirlist->count;
+ dirlist->sorted = dirlist->files;
clean_flist(dirlist, 0, 0);
if (verbose > 3)