extern char *tmpdir;
extern char *compare_dest;
extern int make_backups;
+extern int do_progress;
+extern char *backup_dir;
extern char *backup_suffix;
+extern int backup_suffix_len;
static struct delete_list {
DEV64_T dev;
rprintf(FINFO,"added %s to delete list\n", f_name(file));
}
-static void delete_one(struct file_struct *f)
+static void delete_one(char *fn, int is_dir)
{
- if (!S_ISDIR(f->mode)) {
- if (robust_unlink(f_name(f)) != 0) {
- rprintf(FERROR,"delete_one: unlink %s: %s\n",f_name(f),strerror(errno));
+ if (!is_dir) {
+ if (robust_unlink(fn) != 0) {
+ rprintf(FERROR, "delete_one: unlink %s: %s\n",
+ fn, strerror(errno));
} else if (verbose) {
- rprintf(FINFO,"deleting %s\n",f_name(f));
+ rprintf(FINFO, "deleting %s\n", fn);
}
} else {
- if (do_rmdir(f_name(f)) != 0) {
- if (errno != ENOTEMPTY && errno != EEXIST)
- rprintf(FERROR,"delete_one: rmdir %s: %s\n",
- f_name(f), strerror(errno));
+ if (do_rmdir(fn) != 0) {
+ if (errno != ENOTEMPTY && errno != EEXIST) {
+ rprintf(FERROR, "delete_one: rmdir %s: %s\n",
+ fn, strerror(errno));
+ }
} else if (verbose) {
- rprintf(FINFO,"deleting directory %s\n",f_name(f));
+ rprintf(FINFO, "deleting directory %s\n", fn);
}
}
}
+static int is_backup_file(char *fn)
+{
+ int k = strlen(fn) - backup_suffix_len;
+ return k > 0 && strcmp(fn+k, backup_suffix) == 0;
+}
/* this deletes any files on the receiving side that are not present
add_delete_entry(local_file_list->files[i]);
if (-1 == flist_find(flist,local_file_list->files[i])) {
char *f = f_name(local_file_list->files[i]);
- int k = strlen(f) - strlen(backup_suffix);
-/* Hi Andrew, do we really need to play with backup_suffix here? */
- if (make_backups && ((k <= 0) ||
- (strcmp(f+k,backup_suffix) != 0))) {
+ if (make_backups && (backup_dir || !is_backup_file(f))) {
(void) make_backup(f);
+ if (verbose)
+ rprintf(FINFO, "deleting %s\n", f);
} else {
+ int mode = local_file_list->files[i]->mode;
+ delete_one(f, S_ISDIR(mode) != 0);
deletion_count++;
- delete_one(local_file_list->files[i]);
}
}
}
}
+/*
+ * get_tmpname() - create a tmp filename for a given filename
+ *
+ * If a tmpdir is defined, use that as the directory to
+ * put it in. Otherwise, the tmp filename is in the same
+ * directory as the given name. Note that there may be no
+ * directory at all in the given name!
+ *
+ * The tmp filename is basically the given filename with a
+ * dot prepended, and .XXXXXX appended (for mkstemp() to
+ * put its unique gunk in). Take care to not exceed
+ * either the MAXPATHLEN or NAME_MAX, esp. the last, as
+ * the basename basically becomes 8 chars longer. In that
+ * case, the original name is shortened sufficiently to
+ * make it all fit.
+ *
+ * Of course, there's no real reason for the tmp name to
+ * look like the original, except to satisfy us humans.
+ * As long as it's unique, rsync will work.
+ */
+
static int get_tmpname(char *fnametmp, char *fname)
{
char *f;
+ int length = 0;
+ int maxname;
- /* open tmp file */
if (tmpdir) {
- f = strrchr(fname,'/');
- if (f == NULL)
- f = fname;
- else
- f++;
- if (strlen(tmpdir)+strlen(f)+10 > MAXPATHLEN) {
- rprintf(FERROR,"filename too long\n");
- return 0;
+ strlcpy(fnametmp, tmpdir, MAXPATHLEN - 2);
+ length = strlen(fnametmp);
+ fnametmp[length++] = '/';
+ fnametmp[length] = '\0'; /* always NULL terminated */
}
- snprintf(fnametmp,MAXPATHLEN, "%s/.%s.XXXXXX",tmpdir,f);
- return 1;
+
+ if ((f = strrchr(fname, '/'))) { /* extra () for gcc */
+ ++f;
+ if (!tmpdir) {
+ length = f - fname;
+ strlcpy(fnametmp, fname, length + 1);
+ } /* copy up to and including the slash */
+ } else {
+ f = fname;
}
+ fnametmp[length++] = '.';
+ fnametmp[length] = '\0'; /* always NULL terminated */
- f = strrchr(fname,'/');
+ maxname = MIN(MAXPATHLEN - 7 - length, NAME_MAX - 8);
- if (strlen(fname)+9 > MAXPATHLEN) {
- rprintf(FERROR,"filename too long\n");
+ if (maxname < 1)
+ {
+ rprintf(FERROR, "temporary filename too long: %s\n", fname);
+ fnametmp[0] = '\0';
return 0;
}
- if (f) {
- *f = 0;
- snprintf(fnametmp,MAXPATHLEN,"%s/.%s.XXXXXX",
- fname,f+1);
- *f = '/';
- } else {
- snprintf(fnametmp,MAXPATHLEN,".%s.XXXXXX",fname);
- }
+ strlcpy(fnametmp + length, f, maxname);
+ strcat(fnametmp + length, ".XXXXXX");
return 1;
}
OFF_T total_size)
{
int i;
- unsigned int n,remainder,len,count;
+ struct sum_struct sum;
+ unsigned int len;
OFF_T offset = 0;
OFF_T offset2;
char *data;
static char file_sum2[MD4_SUM_LENGTH];
char *map=NULL;
- count = read_int(f_in);
- n = read_int(f_in);
- remainder = read_int(f_in);
+ read_sum_head(f_in, &sum);
sum_init();
for (i=recv_token(f_in,&data); i != 0; i=recv_token(f_in,&data)) {
-
- show_progress(offset, total_size);
+ if (do_progress)
+ show_progress(offset, total_size);
if (i > 0) {
extern int cleanup_got_literal;
}
i = -(i+1);
- offset2 = i*(OFF_T)n;
- len = n;
- if (i == (int) count-1 && remainder != 0)
- len = remainder;
+ offset2 = i*(OFF_T)sum.blength;
+ len = sum.blength;
+ if (i == (int) sum.count-1 && sum.remainder != 0)
+ len = sum.remainder;
stats.matched_data += len;
offset += len;
}
- end_progress(total_size);
+ if (do_progress)
+ end_progress(total_size);
if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
rprintf(FERROR,"write failed on %s : %s\n",
sum_end(file_sum1);
- if (remote_version >= 14) {
- read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
- if (verbose > 2) {
- rprintf(FINFO,"got file_sum\n");
- }
- if (fd != -1 &&
- memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0) {
- return 0;
- }
+ read_buf(f_in,file_sum2,MD4_SUM_LENGTH);
+ if (verbose > 2) {
+ rprintf(FINFO,"got file_sum\n");
+ }
+ if (fd != -1
+ && memcmp(file_sum1,file_sum2,MD4_SUM_LENGTH) != 0) {
+ return 0;
}
return 1;
}
i = read_int(f_in);
if (i == -1) {
- if (phase==0 && remote_version >= 13) {
+ if (phase==0) {
phase++;
csum_length = SUM_LENGTH;
if (verbose > 2)
fname = local_name;
if (dry_run) {
- if (!am_server) {
- log_transfer(file, fname);
+ if (!am_server && verbose) { /* log transfer */
+ rprintf(FINFO, "%s\n", fname);
}
continue;
}
}
if (fd1 != -1 && !preserve_perms) {
- /* if the file exists already and we aren't perserving
- presmissions then act as though the remote end sent
+ /* if the file exists already and we aren't preserving
+ permissions then act as though the remote end sent
us the file permissions we already have */
file->mode = st.st_mode;
}
this out. We also set it initially without group
access because of a similar race condition. */
fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
- if (fd2 == -1) {
- rprintf(FERROR,"mkstemp %s failed: %s\n",fnametmp,strerror(errno));
- receive_data(f_in,buf,-1,NULL,file->length);
- if (buf) unmap_file(buf);
- continue;
- }
/* in most cases parent directories will already exist
because their information should have been previously
fd2 = do_mkstemp(fnametmp, file->mode & INITACCESSPERMS);
}
if (fd2 == -1) {
- rprintf(FERROR,"cannot create %s : %s\n",fnametmp,strerror(errno));
+ rprintf(FERROR,"mkstemp %s failed: %s\n",fnametmp,strerror(errno));
receive_data(f_in,buf,-1,NULL,file->length);
if (buf) unmap_file(buf);
if (fd1 != -1) close(fd1);
cleanup_set(fnametmp, fname, file, buf, fd1, fd2);
- if (!am_server) {
- log_transfer(file, fname);
+ if (!am_server && verbose) { /* log transfer */
+ rprintf(FINFO, "%s\n", fname);
}
/* recv file data */
Matt McCutchen's Web Site / rsync / rsync.git / blobdiff