ida->access = access;
}
if (rc) {
- rsyserr(FERROR, errno, "unpack_smb_acl: %s()", errfun);
+ rsyserr(FERROR_XFER, errno, "unpack_smb_acl: %s()", errfun);
rsync_acl_free(racl);
return False;
}
static int store_access_in_entry(uint32 access, SMB_ACL_ENTRY_T entry)
{
if (sys_acl_set_access_bits(entry, access)) {
- rsyserr(FERROR, errno, "store_access_in_entry sys_acl_set_access_bits()");
+ rsyserr(FERROR_XFER, errno, "store_access_in_entry sys_acl_set_access_bits()");
return -1;
}
return 0;
SMB_ACL_ENTRY_T entry;
if (!(*smb_acl = sys_acl_init(calc_sacl_entries(racl)))) {
- rsyserr(FERROR, errno, "pack_smb_acl: sys_acl_init()");
+ rsyserr(FERROR_XFER, errno, "pack_smb_acl: sys_acl_init()");
return False;
}
#ifdef DEBUG
if (sys_acl_valid(*smb_acl) < 0)
- rprintf(FERROR, "pack_smb_acl: warning: system says the ACL I packed is invalid\n");
+ rprintf(FERROR_XFER, "pack_smb_acl: warning: system says the ACL I packed is invalid\n");
#endif
return True;
error_exit:
if (errfun) {
- rsyserr(FERROR, errno, "pack_smb_acl %s()", errfun);
+ rsyserr(FERROR_XFER, errno, "pack_smb_acl %s()", errfun);
}
sys_acl_free_acl(*smb_acl);
return False;
if (type == SMB_ACL_TYPE_ACCESS)
rsync_acl_fake_perms(racl, mode);
} else {
- rsyserr(FERROR, errno, "get_acl: sys_acl_get_file(%s, %s)",
+ rsyserr(FERROR_XFER, errno, "get_acl: sys_acl_get_file(%s, %s)",
fname, str_acl_type(type));
return -1;
}
access |= NAME_IS_USER;
} else if (am_root >= 0 && access & ~SMB_ACL_VALID_OBJ_BITS) {
value_error:
- rprintf(FERROR, "recv_acl_access: value out of range: %x\n",
+ rprintf(FERROR_XFER, "recv_acl_access: value out of range: %x\n",
access);
exit_cleanup(RERR_STREAMIO);
}
int ndx = read_varint(f);
if (ndx < 0 || (size_t)ndx > racl_list->count) {
- rprintf(FERROR, "recv_acl_index: %s ACL index %d > %d\n",
+ rprintf(FERROR_XFER, "recv_acl_index: %s ACL index %d > %d\n",
str_acl_type(type), ndx, (int)racl_list->count);
exit_cleanup(RERR_STREAMIO);
}
if (rc) {
error_exit:
if (errfun) {
- rsyserr(FERROR, errno, "change_sacl_perms: %s()",
+ rsyserr(FERROR_XFER, errno, "change_sacl_perms: %s()",
errfun);
}
return (mode_t)~0;
#endif
rc = sys_acl_delete_def_file(fname);
if (rc < 0) {
- rsyserr(FERROR, errno, "set_acl: sys_acl_delete_def_file(%s)",
+ rsyserr(FERROR_XFER, errno, "set_acl: sys_acl_delete_def_file(%s)",
fname);
return -1;
}
}
#endif
if (sys_acl_set_file(fname, type, duo_item->sacl) < 0) {
- rsyserr(FERROR, errno, "set_acl: sys_acl_set_file(%s, %s)",
+ rsyserr(FERROR_XFER, errno, "set_acl: sys_acl_set_file(%s, %s)",
fname, str_acl_type(type));
return -1;
}
}
/* Otherwise fall through. */
default:
- rprintf(FERROR, "default_perms_for_dir: sys_acl_get_file(%s, %s): %s, falling back on umask\n",
+ rprintf(FWARNING,
+ "default_perms_for_dir: sys_acl_get_file(%s, %s): %s, falling back on umask\n",
dir, str_acl_type(SMB_ACL_TYPE_DEFAULT), strerror(errno));
}
return perms;
ok = unpack_smb_acl(sacl, &racl);
sys_acl_free_acl(sacl);
if (!ok) {
- rprintf(FERROR, "default_perms_for_dir: unpack_smb_acl failed, falling back on umask\n");
+ rprintf(FWARNING, "default_perms_for_dir: unpack_smb_acl failed, falling back on umask\n");
return perms;
}
#include "rsync.h"
extern char *password_file;
-extern int log_got_error;
/***************************************************************************
encode a buffer using base64 - simple and slow algorithm. null terminates
return NULL;
if ((fd = open(filename,O_RDONLY)) < 0) {
- rsyserr(FERROR, errno, "could not open password file \"%s\"",
+ rsyserr(FWARNING, errno, "could not open password file \"%s\"",
filename);
if (envpw)
rprintf(FINFO, "falling back to RSYNC_PASSWORD environment variable.\n");
}
if (do_stat(filename, &st) == -1) {
- rsyserr(FERROR, errno, "stat(%s)", filename);
+ rsyserr(FWARNING, errno, "stat(%s)", filename);
ok = 0;
} else if ((st.st_mode & 06) != 0) {
- rprintf(FERROR, "password file must not be other-accessible\n");
+ rprintf(FWARNING, "password file must not be other-accessible\n");
ok = 0;
} else if (MY_UID() == 0 && st.st_uid != 0) {
- rprintf(FERROR, "password file must be owned by root when running as root\n");
+ rprintf(FWARNING, "password file must be owned by root when running as root\n");
ok = 0;
}
if (!ok) {
close(fd);
- rprintf(FERROR, "continuing without password file\n");
+ rprintf(FWARNING, "continuing without password file\n");
if (envpw)
rprintf(FINFO, "falling back to RSYNC_PASSWORD environment variable.\n");
return NULL;
pass = getpass("Password: ");
}
- /* Any errors output during password handling aren't transfer errors. */
- log_got_error = 0;
-
if (!pass)
pass = "";
extern int am_daemon;
extern int io_error;
extern int keep_partial;
-extern int log_got_error;
+extern int got_xfer_error;
extern char *partial_dir;
extern char *logfile_name;
code = exit_code = RERR_DEL_LIMIT;
if (io_error & IOERR_VANISHED)
code = exit_code = RERR_VANISHED;
- if (io_error & IOERR_GENERAL || log_got_error)
+ if (io_error & IOERR_GENERAL || got_xfer_error)
code = exit_code = RERR_PARTIAL;
}
modtime = read_varlong(f, 4);
#if SIZEOF_TIME_T < SIZEOF_INT64
if ((modtime > INT_MAX || modtime < INT_MIN) && !am_generator) {
- rprintf(FERROR,
+ rprintf(FERROR_XFER,
"Time value of %s truncated on receiver.\n",
lastname);
}
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",
+ rprintf(FERROR_XFER, "symlink has no referent: %s\n",
full_fname(thisname));
} else
#endif
{
enum logcode c = am_daemon && protocol_version < 28
- ? FERROR : FINFO;
+ ? FERROR : FWARNING;
io_error |= IOERR_VANISHED;
rprintf(c, "file has vanished: %s\n",
full_fname(thisname));
}
} else {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, save_errno, "readlink %s failed",
+ rsyserr(FERROR_XFER, save_errno, "readlink %s failed",
full_fname(thisname));
}
return NULL;
fbuf[--len] = '\0';
if (len >= MAXPATHLEN - 1) {
io_error |= IOERR_GENERAL;
- rprintf(FERROR, "skipping long-named directory: %s\n",
+ rprintf(FERROR_XFER, "skipping long-named directory: %s\n",
full_fname(fbuf));
return;
}
if (!(d = opendir(fbuf))) {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno, "opendir %s failed", full_fname(fbuf));
+ rsyserr(FERROR_XFER, errno, "opendir %s failed", full_fname(fbuf));
return;
}
if (errno) {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno, "readdir(%s)", full_fname(fbuf));
+ rsyserr(FERROR_XFER, errno, "readdir(%s)", full_fname(fbuf));
}
closedir(d);
STRUCT_STAT st;
if (link_stat(fbuf, &st, copy_dirlinks) != 0) {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno, "link_stat %s failed",
+ rsyserr(FERROR_XFER, errno, "link_stat %s failed",
full_fname(fbuf));
return;
}
STRUCT_STAT st;
if (link_stat(fbuf, &st, 1) != 0) {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno, "link_stat %s failed",
+ rsyserr(FERROR_XFER, errno, "link_stat %s failed",
full_fname(fbuf));
continue;
}
disable_buffering = io_start_buffering_out(f);
if (filesfrom_fd >= 0) {
if (argv[0] && !push_dir(argv[0], 0)) {
- rsyserr(FERROR, errno, "push_dir %s failed in %s",
+ rsyserr(FERROR_XFER, errno, "push_dir %s failed in %s",
full_fname(argv[0]), curr_dir);
exit_cleanup(RERR_FILESELECT);
}
if (link_stat(fbuf, &st, copy_dirlinks || name_type != NORMAL_NAME) != 0) {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno, "link_stat %s failed",
+ rsyserr(FERROR_XFER, errno, "link_stat %s failed",
full_fname(fbuf));
continue;
}
check_ret:
if (replace && ret != DR_SUCCESS) {
- rprintf(FERROR, "could not make way for new %s: %s\n",
+ rprintf(FERROR_XFER, "could not make way for new %s: %s\n",
replace, fbuf);
}
return ret;
#endif
&& !S_ISDIR(file->mode)) {
if (do_link(cmpbuf, fname) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"failed to hard-link %s with %s",
cmpbuf, fname);
return j;
if (relative_paths && !implied_dirs
&& do_stat(dn, &sx.st) < 0
&& create_directory_path(fname) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"recv_generator: mkdir %s failed",
full_fname(dn));
}
if (!relative_paths || errno != ENOENT
|| create_directory_path(fname) < 0
|| (do_mkdir(fname, file->mode) < 0 && errno != EEXIST)) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"recv_generator: mkdir %s failed",
full_fname(fname));
skipping_dir_contents:
if (!am_root && !(file->mode & S_IWUSR) && dir_tweaking) {
mode_t mode = file->mode | S_IWUSR;
if (do_chmod(fname, mode) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"failed to modify permissions on %s",
full_fname(fname));
}
}
#endif
if (do_symlink(sl, fname) != 0) {
- rsyserr(FERROR, errno, "symlink %s -> \"%s\" failed",
+ rsyserr(FERROR_XFER, errno, "symlink %s -> \"%s\" failed",
full_fname(fname), sl);
} else {
set_file_attrs(fname, file, NULL, NULL, 0);
(long)major(rdev), (long)minor(rdev));
}
if (do_mknod(fname, file->mode, rdev) < 0) {
- rsyserr(FERROR, errno, "mknod %s failed",
+ rsyserr(FERROR_XFER, errno, "mknod %s failed",
full_fname(fname));
} else {
set_file_attrs(fname, file, NULL, NULL, 0);
#endif
if (stat_errno == ENOENT)
goto notify_others;
- rsyserr(FERROR, stat_errno, "recv_generator: failed to stat %s",
+ rsyserr(FERROR_XFER, stat_errno, "recv_generator: failed to stat %s",
full_fname(fname));
goto cleanup;
}
goto pretend_missing;
}
if (robust_unlink(backupptr) && errno != ENOENT) {
- rsyserr(FERROR, errno, "unlink %s",
+ rsyserr(FERROR_XFER, errno, "unlink %s",
full_fname(backupptr));
unmake_file(back_file);
back_file = NULL;
if ((f_copy = do_open(backupptr, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600)) < 0
&& (errno != ENOENT || make_bak_dir(backupptr) < 0
|| (f_copy = do_open(backupptr, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600)) < 0)) {
- rsyserr(FERROR, errno, "open %s",
+ rsyserr(FERROR_XFER, errno, "open %s",
full_fname(backupptr));
unmake_file(back_file);
back_file = NULL;
if (!make_backup(fname))
return -1;
} else if (robust_unlink(fname)) {
- rsyserr(FERROR, errno, "unlink %s failed",
+ rsyserr(FERROR_XFER, errno, "unlink %s failed",
full_fname(fname));
return -1;
}
}
if (link_stat(prev_name, &prev_st, 0) < 0) {
- rsyserr(FERROR, errno, "stat %s failed",
+ rsyserr(FERROR_XFER, errno, "stat %s failed",
full_fname(prev_name));
return -1;
}
return -1;
code = FINFO;
} else
- code = FERROR;
+ code = FERROR_XFER;
rsyserr(code, errno, "link %s => %s failed",
full_fname(fname), oldname);
return 0;
if (stp == NULL && prev_ndx >= 0) {
if (link_stat(fname, &st, 0) < 0) {
- rsyserr(FERROR, errno, "stat %s failed",
+ rsyserr(FERROR_XFER, errno, "stat %s failed",
full_fname(fname));
return;
}
readfd(fd, buf, 4);
got_flist_entry_status(FES_NO_SEND, buf);
break;
- case MSG_SOCKERR:
+ case MSG_ERROR_SOCKET:
case MSG_CLIENT:
if (!am_generator)
goto invalid_msg;
- if (tag == MSG_SOCKERR)
+ if (tag == MSG_ERROR_SOCKET)
io_end_multiplex_out();
/* FALL THROUGH */
case MSG_INFO:
case MSG_ERROR:
+ case MSG_ERROR_XFER:
+ case MSG_WARNING:
case MSG_LOG:
while (len) {
n = len;
/* Don't write errors on a dead socket. */
if (fd == sock_f_in) {
io_end_multiplex_out();
- rsyserr(FSOCKERR, errno, "read error");
+ rsyserr(FERROR_SOCKET, errno, "read error");
} else
rsyserr(FERROR, errno, "read error");
exit_cleanup(RERR_STREAMIO);
break;
case MSG_INFO:
case MSG_ERROR:
+ case MSG_ERROR_XFER:
+ case MSG_WARNING:
if (msg_bytes >= sizeof line) {
overflow:
rprintf(FERROR,
static FILE *logfile_fp;
struct stats stats;
-int log_got_error = 0;
+int got_xfer_error = 0;
struct {
int code;
}
/* this is the underlying (unformatted) rsync debugging function. Call
- * it with FINFO, FERROR or FLOG. Note: recursion can happen with
- * certain fatal conditions. */
+ * it with FINFO, FERROR_*, FWARNING, FLOG, or FCLIENT. Note: recursion
+ * can happen with certain fatal conditions. */
void rwrite(enum logcode code, const char *buf, int len, int is_utf8)
{
int trailing_CR_or_NL;
return;
}
- if (code == FSOCKERR) /* This gets simplified for a non-sibling. */
+ if (code == FERROR_SOCKET) /* This gets simplified for a non-sibling. */
code = FERROR;
if (code == FCLIENT)
else if (am_daemon || logfile_name) {
static int in_block;
char msg[2048];
- int priority = code == FERROR ? LOG_WARNING : LOG_INFO;
+ int priority = code == FINFO || code == FLOG ? LOG_INFO : LOG_WARNING;
if (in_block)
return;
} else if (code == FLOG)
return;
- if (quiet && code != FERROR)
+ if (quiet && code == FINFO)
return;
if (am_server) {
+ enum msgcode msg = (enum msgcode)code;
+ if (protocol_version < 30) {
+ if (msg == MSG_ERROR)
+ msg = MSG_ERROR_XFER;
+ else if (msg == MSG_WARNING)
+ msg = MSG_INFO;
+ }
/* Pass the message to the non-server side. */
- if (send_msg((enum msgcode)code, buf, len, !is_utf8))
+ if (send_msg(msg, buf, len, !is_utf8))
return;
if (am_daemon) {
/* TODO: can we send the error to the user somehow? */
}
switch (code) {
+ case FERROR_XFER:
+ got_xfer_error = 1;
+ /* CONTINUE */
case FERROR:
- log_got_error = 1;
+ case FWARNING:
f = stderr;
break;
case FINFO:
}
}
-/* This is the rsync debugging function. Call it with FINFO, FERROR or
- * FLOG. */
+/* This is the rsync debugging function. Call it with FINFO, FERROR_*,
+ * FWARNING, FLOG, or FCLIENT. */
void rprintf(enum logcode code, const char *format, ...)
{
va_list ap;
if (am_daemon || code == FLOG)
return;
- if (code == FERROR || am_server)
- f = stderr;
- else
+ if (code == FINFO && !am_server)
f = stdout;
+ else
+ f = stderr;
fflush(f);
}
/* VANISHED is not an error, only a warning */
if (code == RERR_VANISHED) {
- rprintf(FINFO, "rsync warning: %s (code %d) at %s(%d) [%s=%s]\n",
+ rprintf(FWARNING, "rsync warning: %s (code %d) at %s(%d) [%s=%s]\n",
name, code, file, line, who_am_i(), RSYNC_VERSION);
} else {
rprintf(FERROR, "rsync error: %s (code %d) at %s(%d) [%s=%s]\n",
extern int need_messages_from_generator;
extern int kluge_around_eof;
extern int do_stats;
-extern int log_got_error;
+extern int got_xfer_error;
extern int module_id;
extern int copy_links;
extern int copy_dirlinks;
if (!am_server)
output_summary();
close_all();
- if (log_got_error)
+ if (got_xfer_error)
_exit(RERR_PARTIAL);
_exit(0);
}
maxname = MIN(MAXPATHLEN - 7 - length, NAME_MAX - 8);
if (maxname < 1) {
- rprintf(FERROR, "temporary filename too long: %s\n", fname);
+ rprintf(FERROR_XFER, "temporary filename too long: %s\n", fname);
fnametmp[0] = '\0';
return 0;
}
#endif
if (fd == -1) {
- rsyserr(FERROR, errno, "mkstemp %s failed",
+ rsyserr(FERROR_XFER, errno, "mkstemp %s failed",
full_fname(fnametmp));
return -1;
}
}
offset = sum.flength;
if (fd != -1 && (j = do_lseek(fd, offset, SEEK_SET)) != offset) {
- rsyserr(FERROR, errno, "lseek of %s returned %.0f, not %.0f",
+ rsyserr(FERROR_XFER, errno, "lseek of %s returned %.0f, not %.0f",
full_fname(fname), (double)j, (double)offset);
exit_cleanup(RERR_FILEIO);
}
goto report_write_error;
offset += len;
if ((pos = do_lseek(fd, len, SEEK_CUR)) != offset) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"lseek of %s returned %.0f, not %.0f",
full_fname(fname),
(double)pos, (double)offset);
if (fd != -1 && offset > 0 && sparse_end(fd) != 0) {
report_write_error:
- rsyserr(FERROR, errno, "write failed on %s",
+ rsyserr(FERROR_XFER, errno, "write failed on %s",
full_fname(fname));
exit_cleanup(RERR_FILEIO);
}
/* We don't use robust_rename() here because the
* partial-dir must be on the same drive. */
if (do_rename(partialptr, fname) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rename failed for %s (from %s)",
full_fname(fname), partialptr);
} else {
st.st_mode = 0;
st.st_size = 0;
} else if (do_fstat(fd1,&st) != 0) {
- rsyserr(FERROR, errno, "fstat %s failed",
+ rsyserr(FERROR_XFER, errno, "fstat %s failed",
full_fname(fnamecmp));
discard_receive_data(f_in, F_LENGTH(file));
close(fd1);
* and the underlying robust_unlink could cope
* with directories
*/
- rprintf(FERROR,"recv_files: %s is a directory\n",
+ rprintf(FERROR_XFER, "recv_files: %s is a directory\n",
full_fname(fnamecmp));
discard_receive_data(f_in, F_LENGTH(file));
close(fd1);
if (inplace) {
fd2 = do_open(fname, O_WRONLY|O_CREAT, 0600);
if (fd2 == -1) {
- rsyserr(FERROR, errno, "open %s failed",
+ rsyserr(FERROR_XFER, errno, "open %s failed",
full_fname(fname));
}
} else {
|| (preserve_hard_links && F_IS_HLINKED(file)))
send_msg_int(MSG_SUCCESS, ndx);
} else if (!recv_ok) {
- enum logcode msgtype = redoing || read_batch ? FERROR : FINFO;
+ enum logcode msgtype = redoing || read_batch ? FERROR : FWARNING;
if (msgtype == FERROR || verbose) {
char *errstr, *redostr, *keptstr;
if (!(keep_partial && partialptr) && !inplace)
if (dry_run)
return 1;
if (link_stat(fname, &sx2.st, 0) < 0) {
- rsyserr(FERROR, errno, "stat %s failed",
+ rsyserr(FERROR_XFER, errno, "stat %s failed",
full_fname(fname));
return 0;
}
&& cmp_time(sxp->st.st_mtime, file->modtime) != 0) {
int ret = set_modtime(fname, file->modtime, sxp->st.st_mode);
if (ret < 0) {
- rsyserr(FERROR, errno, "failed to set times on %s",
+ rsyserr(FERROR_XFER, errno, "failed to set times on %s",
full_fname(fname));
goto cleanup;
}
change_gid ? (gid_t)F_GROUP(file) : sxp->st.st_gid) != 0) {
/* shouldn't have attempted to change uid or gid
* unless have the privilege */
- rsyserr(FERROR, errno, "%s %s failed",
+ rsyserr(FERROR_XFER, errno, "%s %s failed",
change_uid ? "chown" : "chgrp",
full_fname(fname));
goto cleanup;
if (!BITS_EQUAL(sxp->st.st_mode, new_mode, CHMOD_BITS)) {
int ret = am_root < 0 ? 0 : do_chmod(fname, new_mode);
if (ret < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"failed to set permissions on %s",
full_fname(fname));
goto cleanup;
ret = robust_rename(fnametmp, fname, partialptr,
file->mode & INITACCESSPERMS);
if (ret < 0) {
- rsyserr(FERROR, errno, "%s %s -> \"%s\"",
+ rsyserr(FERROR_XFER, errno, "%s %s -> \"%s\"",
ret == -2 ? "copy" : "rename",
full_fname(fnametmp), fname);
do_unlink(fnametmp);
if (partialptr) {
if (do_rename(fnametmp, fname) < 0) {
- rsyserr(FERROR, errno, "rename %s -> \"%s\"",
+ rsyserr(FERROR_XFER, errno, "rename %s -> \"%s\"",
full_fname(fnametmp), fname);
} else
handle_partial_dir(partialptr, PDIR_DELETE);
/* This is used when working on a new protocol version in CVS, and should
* be a new non-zero value for each CVS change that affects the protocol.
* It must ALWAYS be 0 when the protocol goes final! */
-#define SUBPROTOCOL_VERSION 14
+#define SUBPROTOCOL_VERSION 15
/* We refuse to interoperate with versions that are not in this range.
* Note that we assume we'll work with later versions: the onus is on
#define CFN_DROP_TRAILING_DOT_DIR (1<<2)
#define CFN_COLLAPSE_DOT_DOT_DIRS (1<<3)
-/* Log-message categories. Only FERROR and FINFO get sent over the socket,
- * but FLOG and FSOCKERR can be sent over the receiver -> generator pipe.
- * FLOG only goes to the log file, not the client; FCLIENT is the opposite. */
-enum logcode { FNONE=0, FERROR=1, FINFO=2, FLOG=3, FCLIENT=4, FSOCKERR=5 };
+/* Log-message categories. FLOG only goes to the log file, not the client;
+ * FCLIENT is the opposite. */
+enum logcode {
+ FNONE=0, /* never sent */
+ FERROR_XFER=1, FINFO=2, /* sent over socket for any protocol */
+ FERROR=3, FWARNING=4, /* sent over socket for protocols >= 30 */
+ FERROR_SOCKET=5, FLOG=6, /* only sent via receiver -> generator pipe */
+ FCLIENT=7 /* never transmitted (e.g. server converts to FINFO) */
+};
/* Messages types that are sent over the message channel. The logcode
* values must all be present here with identical numbers. */
enum msgcode {
MSG_DATA=0, /* raw data on the multiplexed stream */
- MSG_ERROR=FERROR, MSG_INFO=FINFO, /* remote logging */
- MSG_LOG=FLOG, MSG_CLIENT=FCLIENT, MSG_SOCKERR=FSOCKERR, /* sibling logging */
+ MSG_ERROR_XFER=FERROR_XFER, MSG_INFO=FINFO, /* remote logging */
+ MSG_ERROR=FERROR, MSG_WARNING=FWARNING, /* protocol-30 remote logging */
+ MSG_ERROR_SOCKET=FERROR_SOCKET, /* sibling logging */
+ MSG_LOG=FLOG, MSG_CLIENT=FCLIENT, /* sibling logging */
MSG_REDO=9, /* reprocess indicated flist index */
MSG_FLIST=20, /* extra file list over sibling socket */
MSG_FLIST_EOF=21,/* we've transmitted all the file lists */
if (errno == ENOENT) {
enum logcode c = am_daemon
&& protocol_version < 28 ? FERROR
- : FINFO;
+ : FWARNING;
io_error |= IOERR_VANISHED;
rprintf(c, "file has vanished: %s\n",
full_fname(fname));
} else {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"send_files failed to open %s",
full_fname(fname));
}
j = unmap_file(mbuf);
if (j) {
io_error |= IOERR_GENERAL;
- rsyserr(FERROR, j,
+ rsyserr(FERROR_XFER, j,
"read errors mapping %s",
full_fname(fname));
}
int len; /* Number of bytes read into `buf'. */
if ((ifd = do_open(source, O_RDONLY, 0)) < 0) {
- rsyserr(FERROR, errno, "open %s", full_fname(source));
+ rsyserr(FERROR_XFER, errno, "open %s", full_fname(source));
return -1;
}
if (ofd < 0) {
if (robust_unlink(dest) && errno != ENOENT) {
- rsyserr(FERROR, errno, "unlink %s", full_fname(dest));
+ rsyserr(FERROR_XFER, errno, "unlink %s", full_fname(dest));
return -1;
}
if ((ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0
&& (!create_bak_dir || errno != ENOENT || make_bak_dir(dest) < 0
|| (ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode)) < 0)) {
- rsyserr(FERROR, errno, "open %s", full_fname(dest));
+ rsyserr(FERROR_XFER, errno, "open %s", full_fname(dest));
close(ifd);
return -1;
}
while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
if (full_write(ofd, buf, len) < 0) {
- rsyserr(FERROR, errno, "write %s", full_fname(dest));
+ rsyserr(FERROR_XFER, errno, "write %s", full_fname(dest));
close(ifd);
close(ofd);
return -1;
}
if (len < 0) {
- rsyserr(FERROR, errno, "read %s", full_fname(source));
+ rsyserr(FERROR_XFER, errno, "read %s", full_fname(source));
close(ifd);
close(ofd);
return -1;
}
if (close(ifd) < 0) {
- rsyserr(FINFO, errno, "close failed on %s",
+ rsyserr(FWARNING, errno, "close failed on %s",
full_fname(source));
}
if (close(ofd) < 0) {
- rsyserr(FERROR, errno, "close failed on %s",
+ rsyserr(FERROR_XFER, errno, "close failed on %s",
full_fname(dest));
return -1;
}
} while ((rc = access(path, 0)) == 0 && counter != start);
if (verbose > 0) {
- rprintf(FINFO,"renaming %s to %s because of text busy\n",
+ rprintf(FWARNING, "renaming %s to %s because of text busy\n",
fname, path);
}
if (errno == ERANGE) {
list_len = sys_llistxattr(fname, NULL, 0);
if (list_len < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"get_xattr_names: llistxattr(\"%s\",0) failed",
fname);
return -1;
return list_len;
}
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"get_xattr_names: llistxattr(\"%s\",%ld) failed",
fname, (long)namebuf_len);
return -1;
if (datum_len == (size_t)-1) {
if (errno == ENOTSUP || no_missing_error)
return NULL;
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"get_xattr_data: lgetxattr(\"%s\",\"%s\",0) failed",
fname, name);
return NULL;
size_t len = sys_lgetxattr(fname, name, ptr, datum_len);
if (len != datum_len) {
if (len == (size_t)-1) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
" failed", fname, name, (long)datum_len);
} else {
- rprintf(FERROR,
+ rprintf(FERROR_XFER,
"get_xattr_data: lgetxattr(\"%s\",\"%s\",%ld)"
" returned %ld\n", fname, name,
(long)datum_len, (long)len);
if (fname == fnamecmp)
; /* Value is already set when identical */
else if (sys_lsetxattr(fname, name, ptr, len) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
fname, name);
ret = -1;
}
if (sys_lsetxattr(fname, name, rxas[i].datum, rxas[i].datum_len) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rsync_xal_set: lsetxattr(\"%s\",\"%s\") failed",
fname, name);
ret = -1;
}
if (i == xalp->count) {
if (sys_lremovexattr(fname, name) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"rsync_xal_clear: lremovexattr(\"%s\",\"%s\") failed",
fname, name);
ret = -1;
{
const char *name = is_access_acl ? XACC_ACL_ATTR : XDEF_ACL_ATTR;
if (sys_lsetxattr(fname, name, buf, buf_len) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"set_xattr_acl: lsetxattr(\"%s\",\"%s\") failed",
fname, name);
return -1;
xst->st_gid = 0;
return 0;
}
- rsyserr(FERROR, errno, "failed to read xattr %s for %s",
+ rsyserr(FERROR_XFER, errno, "failed to read xattr %s for %s",
XSTAT_ATTR, full_fname(fname));
return -1;
}
return 0;
if (read_only || list_only) {
- rsyserr(FERROR, EROFS, "failed to write xattr %s for %s",
+ rsyserr(FERROR_XFER, EROFS, "failed to write xattr %s for %s",
XSTAT_ATTR, full_fname(fname));
return -1;
}
if (x_lstat(fname, &fst, &xst) < 0) {
- rsyserr(FERROR, errno, "failed to re-stat %s",
+ rsyserr(FERROR_XFER, errno, "failed to re-stat %s",
full_fname(fname));
return -1;
}
&& fst.st_uid == F_OWNER(file) && fst.st_gid == F_GROUP(file)) {
/* xst.st_mode will be 0 if there's no current stat xattr */
if (xst.st_mode && sys_lremovexattr(fname, XSTAT_ATTR) < 0) {
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"delete of stat xattr failed for %s",
full_fname(fname));
return -1;
if (sys_lsetxattr(fname, XSTAT_ATTR, buf, len) < 0) {
if (errno == EPERM && S_ISLNK(fst.st_mode))
return 0;
- rsyserr(FERROR, errno,
+ rsyserr(FERROR_XFER, errno,
"failed to write xattr %s for %s",
XSTAT_ATTR, full_fname(fname));
return -1;