time_t starttime = 0;
-struct stats stats;
-
+extern struct stats stats;
extern int verbose;
static void show_malloc_stats(void);
if (local_server) {
if (read_batch)
create_flist_from_batch(); /* sets batch_flist */
- ret = local_child(argc, args, f_in, f_out);
+ ret = local_child(argc, args, f_in, f_out, child_main);
} else {
ret = piped_child(args,f_in,f_out);
}
return name;
if (do_mkdir(name,0777 & ~orig_umask) != 0) {
- rprintf(FERROR,"mkdir %s : %s (1)\n",name,strerror(errno));
+ rprintf(FERROR, RSYNC_NAME ": mkdir %s: %s\n",
+ name, strerror(errno));
exit_cleanup(RERR_FILEIO);
} else {
if (verbose > 0)
}
if (!push_dir(name, 0)) {
- rprintf(FERROR,"push_dir %s : %s (2)\n",
- name,strerror(errno));
+ rprintf(FERROR, RSYNC_NAME ": push_dir %s: %s\n",
+ name, strerror(errno));
exit_cleanup(RERR_FILESELECT);
}
}
+int child_main(int argc, char *argv[])
+{
+ start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
+ return 0;
+}
+
+
void start_server(int f_in, int f_out, int argc, char *argv[])
{
extern int cvs_exclude;
}
-/*
+/**
* Start a client for either type of remote connection. Work out
* whether the arguments request a remote shell or rsyncd connection,
* and call the appropriate connection function, then run_client.
- */
+ *
+ * Calls either start_socket_client (for sockets) or do_cmd and
+ * client_run (for ssh).
+ **/
static int start_client(int argc, char *argv[])
{
char *p;
extern int am_sender;
extern char *shell_cmd;
extern int rsync_port;
- extern int whole_file;
- extern int write_batch;
extern int read_batch;
int rc;
p = find_colon(argv[0]);
if (p) {
- if (p[1] == ':') {
+ if (p[1] == ':') { /* double colon */
*p = 0;
return start_socket_client(argv[0], p+2, argc-1, argv+1);
}
p = find_colon(argv[argc-1]);
if (!p) {
local_server = 1;
- /*
- * disable "rsync algorithm" when both sides local,
- * except when creating a batch update
- */
- if (!write_batch && whole_file == -1)
- whole_file = 1;
} else if (p[1] == ':') {
*p = 0;
return start_socket_client(argv[argc-1], p+2, argc-1, argv);
}
-static RETSIGTYPE sigusr1_handler(int val) {
+static RETSIGTYPE sigusr1_handler(int UNUSED(val)) {
exit_cleanup(RERR_SIGNAL);
}
-static RETSIGTYPE sigusr2_handler(int val) {
+static RETSIGTYPE sigusr2_handler(int UNUSED(val)) {
extern int log_got_error;
if (log_got_error) _exit(RERR_PARTIAL);
_exit(0);
}
-static RETSIGTYPE sigchld_handler(int val) {
+static RETSIGTYPE sigchld_handler(int UNUSED(val)) {
#ifdef WNOHANG
while (waitpid(-1, NULL, WNOHANG) > 0) ;
#endif
}
+
+/**
+ * This routine catches signals and tries to send them to gdb.
+ *
+ * Because it's called from inside a signal handler it ought not to
+ * use too many library routines.
+ *
+ * @todo Perhaps use "screen -X" instead/as well, to help people
+ * debugging without easy access to X. Perhaps use an environment
+ * variable, or just call a script?
+ *
+ * @todo The /proc/ magic probably only works on Linux (and
+ * Solaris?) Can we be more portable?
+ **/
+#ifdef MAINTAINER_MODE
+const char *get_panic_action(void)
+{
+ const char *cmd_fmt = getenv("RSYNC_PANIC_ACTION");
+
+ if (cmd_fmt)
+ return cmd_fmt;
+ else
+ return "xterm -display :0 -T Panic -n Panic "
+ "-e gdb /proc/%d/exe %d";
+}
+
+
+/**
+ * Handle a fatal signal by launching a debugger, controlled by $RSYNC_PANIC_ACTION.
+ *
+ * This signal handler is only installed if we were configured with
+ * --enable-maintainer-mode. Perhaps it should always be on and we
+ * should just look at the environment variable, but I'm a bit leery
+ * of a signal sending us into a busy loop.
+ **/
+static RETSIGTYPE rsync_panic_handler(int UNUSED(whatsig))
+{
+ char cmd_buf[300];
+ int ret;
+
+ sprintf(cmd_buf, get_panic_action(),
+ getpid(), getpid());
+
+ /* Unless we failed to execute gdb, we allow the process to
+ * continue. I'm not sure if that's right. */
+ ret = system(cmd_buf);
+ if (ret)
+ _exit(ret);
+}
+#endif
+
+
int main(int argc,char *argv[])
{
extern int am_root;
signal(SIGUSR1, sigusr1_handler);
signal(SIGUSR2, sigusr2_handler);
signal(SIGCHLD, sigchld_handler);
+#ifdef MAINTAINER_MODE
+ signal(SIGSEGV, rsync_panic_handler);
+ signal(SIGFPE, rsync_panic_handler);
+ signal(SIGABRT, rsync_panic_handler);
+ signal(SIGBUS, rsync_panic_handler);
+#endif /* def MAINTAINER_MODE */
starttime = time(NULL);
am_root = (getuid() == 0);
ret = start_client(argc, argv);
if (ret == -1)
- exit_cleanup(RERR_STARTCLIENT);
+ exit_cleanup(RERR_STARTCLIENT);
else
- exit_cleanup(ret);
- return ret;
+ exit_cleanup(ret);
+
+ exit(ret);
+ /* NOTREACHED */
}