extern int do_progress;
extern int am_server;
extern int always_checksum;
+extern int module_id;
+extern int ignore_errors;
extern int cvs_exclude;
int io_error;
static struct file_struct null_file;
+static char empty_sum[MD4_SUM_LENGTH];
static void clean_flist(struct file_list *flist, int strip_root, int no_dups);
rprintf(FINFO, "%s %11.0f %s %s -> %s\n",
perms,
(double) f->length, timestring(f->modtime),
- f_name(f), f->link);
+ f_name(f), f->u.link);
} else {
rprintf(FINFO, "%s %11.0f %s %s\n",
perms,
}
}
-
-static void send_file_entry(struct file_struct *file, int f,
- unsigned short base_flags)
+void send_file_entry(struct file_struct *file, int f, unsigned short base_flags)
{
unsigned short flags;
- static time_t last_time;
- static mode_t last_mode;
- static DEV64_T last_rdev;
- static uid_t last_uid;
- static gid_t last_gid;
+ static time_t modtime;
+ static mode_t mode;
+ static DEV64_T rdev; /* just high bytes in p28 onward */
+ static DEV64_T dev;
+ static uid_t uid;
+ static gid_t gid;
static char lastname[MAXPATHLEN];
char *fname, fbuf[MAXPATHLEN];
int l1, l2;
if (!file) {
write_byte(f, 0);
+ modtime = 0, mode = 0;
+ rdev = 0, dev = 0;
+ uid = 0, gid = 0;
+ *lastname = '\0';
return;
}
flags = base_flags;
- if (file->mode == last_mode)
+ if (file->mode == mode)
flags |= SAME_MODE;
else
- last_mode = file->mode;
+ mode = file->mode;
if (preserve_devices) {
if (protocol_version < 28) {
- if (IS_DEVICE(last_mode) && file->rdev == last_rdev)
- flags |= OLD_SAME_RDEV|SAME_HIGH_RDEV;
- else
- last_rdev = file->rdev;
- }
- else if (IS_DEVICE(last_mode)) {
- if ((file->rdev & ~0xFF) == (last_rdev & ~0xFF))
+ if (IS_DEVICE(mode)) {
+ if (file->u.rdev == rdev) {
+ /* Set both flags so that the test when
+ * writing the data is simpler. */
+ flags |= SAME_RDEV_pre28|SAME_HIGH_RDEV;
+ } else
+ rdev = file->u.rdev;
+ } else
+ rdev = 0;
+ } else if (IS_DEVICE(mode)) {
+ if ((file->u.rdev & ~0xFF) == rdev)
flags |= SAME_HIGH_RDEV;
- last_rdev = file->rdev;
+ else
+ rdev = file->u.rdev & ~0xFF;
}
}
- if (file->uid == last_uid)
+ if (file->uid == uid)
flags |= SAME_UID;
else
- last_uid = file->uid;
- if (file->gid == last_gid)
+ uid = file->uid;
+ if (file->gid == gid)
flags |= SAME_GID;
else
- last_gid = file->gid;
- if (file->modtime == last_time)
+ gid = file->gid;
+ if (file->modtime == modtime)
flags |= SAME_TIME;
else
- last_time = file->modtime;
+ modtime = file->modtime;
+ if (file->link_u.idev) {
+ if (file->F_DEV == dev) {
+ if (protocol_version >= 28)
+ flags |= SAME_DEV;
+ } else
+ dev = file->F_DEV;
+ flags |= HAS_INODE_DATA;
+ }
for (l1 = 0;
lastname[l1] && (fname[l1] == lastname[l1]) && (l1 < 255);
l1++) {}
- l2 = strlen(fname) - l1;
+ l2 = strlen(fname+l1);
if (l1 > 0)
flags |= SAME_NAME;
/* We must make sure we don't send a zero flags byte or
* the other end will terminate the flist transfer. */
- if (flags == 0 && !S_ISDIR(last_mode))
+ if (flags == 0 && !S_ISDIR(mode))
flags |= FLAG_DELETE; /* NOTE: no meaning for non-dir */
if (protocol_version >= 28) {
if ((flags & 0xFF00) || flags == 0) {
write_longint(f, file->length);
if (!(flags & SAME_TIME))
- write_int(f, last_time);
+ write_int(f, modtime);
if (!(flags & SAME_MODE))
- write_int(f, to_wire_mode(last_mode));
+ write_int(f, to_wire_mode(mode));
if (preserve_uid && !(flags & SAME_UID)) {
- add_uid(last_uid);
- write_int(f, last_uid);
+ add_uid(uid);
+ write_int(f, uid);
}
if (preserve_gid && !(flags & SAME_GID)) {
- add_gid(last_gid);
- write_int(f, last_gid);
+ add_gid(gid);
+ write_int(f, gid);
}
- if (preserve_devices && IS_DEVICE(last_mode)) {
- /* If SAME_HIGH_RDEV is off, OLD_SAME_RDEV is also off. */
+ if (preserve_devices && IS_DEVICE(mode)) {
+ /* If SAME_HIGH_RDEV is off, SAME_RDEV_pre28 is also off.
+ * Also, avoid using "rdev" because it may be incomplete. */
if (!(flags & SAME_HIGH_RDEV))
- write_int(f, last_rdev);
+ write_int(f, file->u.rdev);
else if (protocol_version >= 28)
- write_byte(f, last_rdev);
+ write_byte(f, file->u.rdev);
}
#if SUPPORT_LINKS
- if (preserve_links && S_ISLNK(last_mode)) {
- write_int(f, strlen(file->link));
- write_buf(f, file->link, strlen(file->link));
+ if (preserve_links && S_ISLNK(mode)) {
+ write_int(f, strlen(file->u.link));
+ write_buf(f, file->u.link, strlen(file->u.link));
}
#endif
#if SUPPORT_HARD_LINKS
- if (preserve_hard_links && S_ISREG(file->mode)) {
+ if (flags & HAS_INODE_DATA) {
if (protocol_version < 26) {
/* 32-bit dev_t and ino_t */
- write_int(f, (int) file->dev);
- write_int(f, (int) file->inode);
+ write_int(f, dev);
+ write_int(f, file->F_INODE);
} else {
/* 64-bit dev_t and ino_t */
- write_longint(f, file->dev);
- write_longint(f, file->inode);
+ if (!(flags & SAME_DEV))
+ write_longint(f, dev);
+ write_longint(f, file->F_INODE);
}
}
#endif
if (always_checksum) {
- if (protocol_version < 21)
- write_buf(f, file->sum, 2);
- else
- write_buf(f, file->sum, MD4_SUM_LENGTH);
+ char *sum;
+ if (S_ISREG(mode))
+ sum = file->u.sum;
+ else if (protocol_version < 28) {
+ /* 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);
+ }
}
strlcpy(lastname, fname, MAXPATHLEN);
-static void receive_file_entry(struct file_struct **fptr,
- unsigned short flags, int f)
+void receive_file_entry(struct file_struct **fptr, unsigned short flags, int f)
{
- static time_t last_time;
- static mode_t last_mode;
- static DEV64_T last_rdev;
- static uid_t last_uid;
- static gid_t last_gid;
+ static time_t modtime;
+ static mode_t mode;
+ static DEV64_T rdev; /* just high bytes in p28 onward */
+ static DEV64_T dev;
+ static uid_t uid;
+ static gid_t gid;
static char lastname[MAXPATHLEN];
char thisname[MAXPATHLEN];
unsigned int l1 = 0, l2 = 0;
char *p;
struct file_struct *file;
+ if (!fptr) {
+ modtime = 0, mode = 0;
+ rdev = 0, dev = 0;
+ uid = 0, gid = 0;
+ *lastname = '\0';
+ return;
+ }
+
if (flags & SAME_NAME)
l1 = read_byte(f);
file->flags = flags;
file->length = read_longint(f);
if (!(flags & SAME_TIME))
- last_time = (time_t)read_int(f);
- file->modtime = last_time;
+ modtime = (time_t)read_int(f);
+ file->modtime = modtime;
if (!(flags & SAME_MODE))
- last_mode = from_wire_mode(read_int(f));
- file->mode = last_mode;
+ mode = from_wire_mode(read_int(f));
+ file->mode = mode;
if (preserve_uid) {
if (!(flags & SAME_UID))
- last_uid = (uid_t)read_int(f);
- file->uid = last_uid;
+ uid = (uid_t)read_int(f);
+ file->uid = uid;
}
if (preserve_gid) {
if (!(flags & SAME_GID))
- last_gid = (gid_t)read_int(f);
- file->gid = last_gid;
+ gid = (gid_t)read_int(f);
+ file->gid = gid;
}
if (preserve_devices) {
if (protocol_version < 28) {
- if (IS_DEVICE(last_mode)) {
- if (!(flags & OLD_SAME_RDEV))
- last_rdev = (DEV64_T)read_int(f);
- file->rdev = last_rdev;
+ if (IS_DEVICE(mode)) {
+ if (!(flags & SAME_RDEV_pre28))
+ rdev = (DEV64_T)read_int(f);
+ file->u.rdev = rdev;
} else
- last_rdev = 0;
- } else if (IS_DEVICE(last_mode)) {
- if (!(flags & SAME_HIGH_RDEV))
- last_rdev = (DEV64_T)read_int(f);
- else {
- last_rdev = (DEV64_T)((last_rdev & ~0xFF)
- | read_byte(f));
- }
- file->rdev = last_rdev;
+ rdev = 0;
+ } else if (IS_DEVICE(mode)) {
+ if (!(flags & SAME_HIGH_RDEV)) {
+ file->u.rdev = (DEV64_T)read_int(f);
+ rdev = file->u.rdev & ~0xFF;
+ } else
+ file->u.rdev = rdev | (DEV64_T)read_byte(f);
}
}
- if (preserve_links && S_ISLNK(last_mode)) {
+ if (preserve_links && S_ISLNK(mode)) {
int l = read_int(f);
if (l < 0) {
rprintf(FERROR, "overflow: l=%d\n", l);
overflow("receive_file_entry");
}
- file->link = new_array(char, l + 1);
- if (!file->link)
+ if (!(file->u.link = new_array(char, l + 1)))
out_of_memory("receive_file_entry 2");
- read_sbuf(f, file->link, l);
+ read_sbuf(f, file->u.link, l);
if (sanitize_paths)
- sanitize_path(file->link, file->dirname);
+ sanitize_path(file->u.link, file->dirname);
}
#if SUPPORT_HARD_LINKS
- if (preserve_hard_links && S_ISREG(file->mode)) {
+ if (preserve_hard_links && protocol_version < 28 && S_ISREG(mode))
+ flags |= HAS_INODE_DATA;
+ if (flags & HAS_INODE_DATA) {
+ if (!(file->link_u.idev = new(struct idev)))
+ out_of_memory("file inode data");
if (protocol_version < 26) {
- file->dev = read_int(f);
- file->inode = read_int(f);
+ dev = read_int(f);
+ file->F_INODE = read_int(f);
} else {
- file->dev = read_longint(f);
- file->inode = read_longint(f);
+ if (!(flags & SAME_DEV))
+ dev = read_longint(f);
+ file->F_INODE = read_longint(f);
}
+ file->F_DEV = dev;
}
#endif
if (always_checksum) {
- file->sum = new_array(char, MD4_SUM_LENGTH);
- if (!file->sum)
- out_of_memory("md4 sum");
- if (protocol_version < 21)
- read_buf(f, file->sum, 2);
- else
- read_buf(f, file->sum, MD4_SUM_LENGTH);
+ char *sum;
+ if (S_ISREG(mode)) {
+ sum = file->u.sum = new_array(char, MD4_SUM_LENGTH);
+ if (!sum)
+ out_of_memory("md4 sum");
+ } else if (protocol_version < 28) {
+ /* 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);
+ }
}
if (!preserve_perms) {
extern int orig_umask;
/* set an appropriate set of permissions based on original
- permissions and umask. This emulates what GNU cp does */
+ * permissions and umask. This emulates what GNU cp does */
file->mode &= ~orig_umask;
}
}
char *p;
char cleaned_name[MAXPATHLEN];
char linkbuf[MAXPATHLEN];
- extern int module_id;
strlcpy(cleaned_name, fname, MAXPATHLEN);
cleaned_name[MAXPATHLEN - 1] = 0;
file->mode = st.st_mode;
file->uid = st.st_uid;
file->gid = st.st_gid;
- file->dev = st.st_dev;
- file->inode = st.st_ino;
+ if (preserve_hard_links) {
+ if (protocol_version < 28 ? S_ISREG(st.st_mode)
+ : !S_ISDIR(st.st_mode) && st.st_nlink > 1) {
+ if (!(file->link_u.idev = new(struct idev)))
+ out_of_memory("file inode data");
+ file->F_DEV = st.st_dev;
+ file->F_INODE = st.st_ino;
+ }
+ }
#ifdef HAVE_STRUCT_STAT_ST_RDEV
- file->rdev = st.st_rdev;
+ if (IS_DEVICE(st.st_mode))
+ file->u.rdev = st.st_rdev;
#endif
#if SUPPORT_LINKS
if (S_ISLNK(st.st_mode))
- file->link = STRDUP(ap, linkbuf);
+ file->u.link = STRDUP(ap, linkbuf);
#endif
- if (always_checksum) {
- file->sum = (char *) MALLOC(ap, MD4_SUM_LENGTH);
- if (!file->sum)
+ if (always_checksum && S_ISREG(st.st_mode)) {
+ if (!(file->u.sum = (char*)MALLOC(ap, MD4_SUM_LENGTH)))
out_of_memory("md4 sum");
- /* drat. we have to provide a null checksum for non-regular
- files in order to be compatible with earlier versions
- of rsync */
- if (S_ISREG(st.st_mode)) {
- file_checksum(fname, file->sum, st.st_size);
- } else {
- memset(file->sum, 0, MD4_SUM_LENGTH);
- }
+ file_checksum(fname, file->u.sum, st.st_size);
}
if (flist_dir) {
DIR *d;
struct dirent *di;
char fname[MAXPATHLEN];
- int l;
+ unsigned int offset;
char *p;
d = opendir(dir);
return;
}
- strlcpy(fname, dir, MAXPATHLEN);
- l = strlen(fname);
- if (fname[l - 1] != '/') {
- if (l == MAXPATHLEN - 1) {
+ offset = strlcpy(fname, dir, MAXPATHLEN);
+ p = fname + offset;
+ if (offset >= MAXPATHLEN || p[-1] != '/') {
+ if (offset >= MAXPATHLEN - 1) {
io_error |= IOERR_GENERAL;
rprintf(FERROR, "skipping long-named directory: %s\n",
full_fname(fname));
closedir(d);
return;
}
- strlcat(fname, "/", MAXPATHLEN);
- l++;
+ *p++ = '/';
+ offset++;
}
- p = fname + strlen(fname);
local_exclude_list = NULL;
if (cvs_exclude) {
- if (strlen(fname) + strlen(".cvsignore") <= MAXPATHLEN - 1) {
- strcpy(p, ".cvsignore");
- add_exclude_file(&exclude_list,fname,MISSING_OK,ADD_EXCLUDE);
- } else {
+ if (strlcpy(p, ".cvsignore", MAXPATHLEN - offset)
+ < MAXPATHLEN - offset)
+ add_exclude_file(&local_exclude_list,fname,MISSING_OK,ADD_EXCLUDE);
+ else {
io_error |= IOERR_GENERAL;
rprintf(FINFO,
"cannot cvs-exclude in long-named directory %s\n",
if (dname[0] == '.' && (dname[1] == '\0'
|| (dname[1] == '.' && dname[2] == '\0')))
continue;
- strlcpy(p, dname, MAXPATHLEN - l);
- send_file_name(f, flist, fname, recurse, 0);
+ if (strlcpy(p, dname, MAXPATHLEN - offset) < MAXPATHLEN - offset)
+ send_file_name(f, flist, fname, recurse, 0);
+ else {
+ io_error |= IOERR_GENERAL;
+ rprintf(FINFO,
+ "cannot send long-named file %s\n",
+ full_fname(fname));
+ }
}
if (errno) {
io_error |= IOERR_GENERAL;
rprintf(FERROR, "readdir(%s): (%d) %s\n",
- dir, errno, strerror(errno));
+ dir, errno, strerror(errno));
}
if (local_exclude_list)
if (l == 2 && fname[0] == '.') {
/* Turn "./" into just "." rather than "./." */
fname[1] = '\0';
- } else {
- strlcat(fname, ".", MAXPATHLEN);
+ } else if (l < MAXPATHLEN) {
+ fname[l++] = '.';
+ fname[l] = '\0';
}
}
}
}
- if (f != -1)
+ if (f != -1) {
send_file_entry(NULL, f, 0);
- if (show_filelist_p() && f != -1)
- finish_filelist_progress(flist);
+ if (show_filelist_p())
+ finish_filelist_progress(flist);
+ }
clean_flist(flist, 0, 0);
- /* now send the uid/gid list. This was introduced in protocol
- version 15 */
- if (f != -1)
+ if (f != -1) {
+ /* Now send the uid/gid list. This was introduced in
+ * protocol version 15 */
send_uid_list(f);
- /* send the io_error flag */
- if (f != -1) {
- extern int module_id;
+ /* send the io_error flag */
write_int(f, lp_ignore_errors(module_id) ? 0 : io_error);
- }
- if (f != -1) {
io_end_buffering();
stats.flist_size = stats.total_written - start_write;
stats.num_files = flist->count;
f_name(flist->files[i]));
}
}
-
+ receive_file_entry(NULL, 0, 0); /* Signal that we're done. */
if (verbose > 2)
rprintf(FINFO, "received %d names\n", flist->count);
- clean_flist(flist, relative_paths, 1);
-
if (show_filelist_p())
finish_filelist_progress(flist);
- /* now recv the uid/gid list. This was introduced in protocol version 15 */
- if (f != -1)
+ clean_flist(flist, relative_paths, 1);
+
+ if (f != -1) {
+ /* Now send the uid/gid list. This was introduced in
+ * protocol version 15 */
recv_uid_list(f, flist);
- /* recv the io_error flag */
- if (f != -1 && !read_batch) { /* dw-added readbatch */
- extern int module_id;
- extern int ignore_errors;
- if (lp_ignore_errors(module_id) || ignore_errors)
- read_int(f);
- else
- io_error |= read_int(f);
+ if (!read_batch) {
+ /* Recv the io_error flag */
+ if (lp_ignore_errors(module_id) || ignore_errors)
+ read_int(f);
+ else
+ io_error |= read_int(f);
+ }
}
if (list_only) {
list_file_entry(flist->files[i]);
}
-
if (verbose > 2)
rprintf(FINFO, "recv_file_list done\n");
return;
if (file->basename)
free(file->basename);
- if (file->link)
- free(file->link);
- if (file->sum)
- free(file->sum);
+ if (!IS_DEVICE(file->mode) && file->u.link)
+ free(file->u.link); /* Handles u.sum too. */
+ if (file->link_u.idev)
+ free((char*)file->link_u.idev); /* Handles link_u.links too. */
*file = null_file;
}
flist->files[i][0] = null_file;
else
free_file(flist->files[i]);
- }
- else
+ } else
prev_i = i;
}
if (!(c1 = (uchar*)f1->dirname)) {
state1 = fnc_BASE;
c1 = (uchar*)f1->basename;
- }
- else
+ } else
state1 = fnc_DIR;
if (!(c2 = (uchar*)f2->dirname)) {
state2 = fnc_BASE;
c2 = (uchar*)f2->basename;
- }
- else
+ } else
state2 = fnc_DIR;
while (1) {