[BACK]Return to cleanup.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/cleanup.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2012/02/17 15:09:30 version 1.1.1.4, 2021/03/17 00:32:36
Line 4 Line 4
  * Copyright (C) 1996-2000 Andrew Tridgell   * Copyright (C) 1996-2000 Andrew Tridgell
  * Copyright (C) 1996 Paul Mackerras   * Copyright (C) 1996 Paul Mackerras
  * Copyright (C) 2002 Martin Pool   * Copyright (C) 2002 Martin Pool
 * Copyright (C) 2003-2009 Wayne Davison * Copyright (C) 2003-2020 Wayne Davison
  *   *
  * This program is free software; you can redistribute it and/or modify   * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
Line 22 Line 22
   
 #include "rsync.h"  #include "rsync.h"
   
   extern int dry_run;
 extern int am_server;  extern int am_server;
 extern int am_daemon;  extern int am_daemon;
 extern int am_receiver;  extern int am_receiver;
   extern int am_sender;
 extern int io_error;  extern int io_error;
   extern int use_db;
 extern int keep_partial;  extern int keep_partial;
 extern int got_xfer_error;  extern int got_xfer_error;
   extern int protocol_version;
   extern int output_needs_newline;
 extern char *partial_dir;  extern char *partial_dir;
 extern char *logfile_name;  extern char *logfile_name;
   
   int called_from_signal_handler = 0;
   BOOL shutting_down = False;
   BOOL flush_ok_after_signal = False;
   
 #ifdef HAVE_SIGACTION  #ifdef HAVE_SIGACTION
 static struct sigaction sigact;  static struct sigaction sigact;
 #endif  #endif
Line 82  int cleanup_got_literal = 0; Line 91  int cleanup_got_literal = 0;
 static const char *cleanup_fname;  static const char *cleanup_fname;
 static const char *cleanup_new_fname;  static const char *cleanup_new_fname;
 static struct file_struct *cleanup_file;  static struct file_struct *cleanup_file;
static int cleanup_fd_r, cleanup_fd_w;static int cleanup_fd_r = -1, cleanup_fd_w = -1;
 static pid_t cleanup_pid = 0;  static pid_t cleanup_pid = 0;
   
 pid_t cleanup_child_pid = -1;  pid_t cleanup_child_pid = -1;
Line 97  NORETURN void _exit_cleanup(int code, const char *file Line 106  NORETURN void _exit_cleanup(int code, const char *file
         static int switch_step = 0;          static int switch_step = 0;
         static int exit_code = 0, exit_line = 0;          static int exit_code = 0, exit_line = 0;
         static const char *exit_file = NULL;          static const char *exit_file = NULL;
        static int unmodified_code = 0;        static int first_code = 0;
   
         SIGACTION(SIGUSR1, SIG_IGN);          SIGACTION(SIGUSR1, SIG_IGN);
         SIGACTION(SIGUSR2, SIG_IGN);          SIGACTION(SIGUSR2, SIG_IGN);
   
        if (exit_code) { /* Preserve first exit info when recursing. */        if (!exit_code) { /* Preserve first error exit info when recursing. */
                code = exit_code;                exit_code = code;
                file = exit_file;                exit_file = file;
                line = exit_line;                exit_line = line < 0 ? -line : line;
         }          }
   
         /* If this is the exit at the end of the run, the server side          /* If this is the exit at the end of the run, the server side
Line 119  NORETURN void _exit_cleanup(int code, const char *file Line 128  NORETURN void _exit_cleanup(int code, const char *file
 #include "case_N.h" /* case 0: */  #include "case_N.h" /* case 0: */
                 switch_step++;                  switch_step++;
   
                exit_code = unmodified_code = code;                first_code = code;
                exit_file = file; 
                exit_line = line; 
   
                if (verbose > 3) {                if (output_needs_newline) {
                         fputc('\n', stdout);
                         output_needs_newline = 0;
                 }
 
                 if (DEBUG_GTE(EXIT, 2)) {
                         rprintf(FINFO,                          rprintf(FINFO,
                                 "[%s] _exit_cleanup(code=%d, file=%s, line=%d): entered\n",                                  "[%s] _exit_cleanup(code=%d, file=%s, line=%d): entered\n",
                                who_am_i(), code, file, line);                                who_am_i(), code, src_file(file), line);
                 }                  }
   
                 /* FALLTHROUGH */  
 #include "case_N.h"  #include "case_N.h"
                 switch_step++;                  switch_step++;
   
                   if (use_db)
                           db_disconnect(False);
   
                   /* FALLTHROUGH */
   #include "case_N.h"
   
                 if (cleanup_child_pid != -1) {                  if (cleanup_child_pid != -1) {
                         int status;                          int status;
                         int pid = wait_process(cleanup_child_pid, &status, WNOHANG);                          int pid = wait_process(cleanup_child_pid, &status, WNOHANG);
                         if (pid == cleanup_child_pid) {                          if (pid == cleanup_child_pid) {
                                 status = WEXITSTATUS(status);                                  status = WEXITSTATUS(status);
                                if (status > code)                                if (status > exit_code)
                                        code = exit_code = status;                                        exit_code = status;
                         }                          }
                 }                  }
   
                 /* FALLTHROUGH */  
 #include "case_N.h"  #include "case_N.h"
                 switch_step++;                  switch_step++;
   
                if (cleanup_got_literal && cleanup_fname && cleanup_new_fname                if (cleanup_got_literal && (cleanup_fname || cleanup_fd_w != -1)) {
                 && keep_partial && handle_partial_dir(cleanup_new_fname, PDIR_CREATE)) {                        if (cleanup_fd_r != -1) {
                        const char *fname = cleanup_fname; 
                        cleanup_fname = NULL; 
                        if (cleanup_fd_r != -1) 
                                 close(cleanup_fd_r);                                  close(cleanup_fd_r);
                                   cleanup_fd_r = -1;
                           }
                         if (cleanup_fd_w != -1) {                          if (cleanup_fd_w != -1) {
                                 flush_write_file(cleanup_fd_w);                                  flush_write_file(cleanup_fd_w);
                                 close(cleanup_fd_w);                                  close(cleanup_fd_w);
                                   cleanup_fd_w = -1;
                         }                          }
                        finish_transfer(cleanup_new_fname, fname, NULL, NULL,                        if (cleanup_fname && cleanup_new_fname && keep_partial
                                        cleanup_file, 0, !partial_dir);                         && handle_partial_dir(cleanup_new_fname, PDIR_CREATE)) {
                                 int tweak_modtime = 0;
                                 const char *fname = cleanup_fname;
                                 cleanup_fname = NULL;
                                 if (!partial_dir) {
                                         /* We don't want to leave a partial file with a modern time or it
                                          * could be skipped via --update.  Setting the time to something
                                          * really old also helps it to stand out as unfinished in an ls. */
                                         tweak_modtime = 1;
                                         cleanup_file->modtime = 0;
                                 }
                                 finish_transfer(cleanup_new_fname, fname, NULL, NULL,
                                                 cleanup_file, tweak_modtime, !partial_dir);
                         }
                 }                  }
   
                 /* FALLTHROUGH */  
 #include "case_N.h"  #include "case_N.h"
                 switch_step++;                  switch_step++;
   
                if (!code || am_server || am_receiver)                if (flush_ok_after_signal) {
                         flush_ok_after_signal = False;
                         if (code == RERR_SIGNAL)
                                 io_flush(FULL_FLUSH);
                 }
                 if (!exit_code && !code)
                         io_flush(FULL_FLUSH);                          io_flush(FULL_FLUSH);
   
                 /* FALLTHROUGH */  
 #include "case_N.h"  #include "case_N.h"
                 switch_step++;                  switch_step++;
   
                 if (cleanup_fname)                  if (cleanup_fname)
                         do_unlink(cleanup_fname);                          do_unlink(cleanup_fname);
                if (code)                if (exit_code)
                         kill_all(SIGUSR1);                          kill_all(SIGUSR1);
                 if (cleanup_pid && cleanup_pid == getpid()) {                  if (cleanup_pid && cleanup_pid == getpid()) {
                         char *pidf = lp_pid_file();                          char *pidf = lp_pid_file();
Line 182  NORETURN void _exit_cleanup(int code, const char *file Line 214  NORETURN void _exit_cleanup(int code, const char *file
                                 unlink(lp_pid_file());                                  unlink(lp_pid_file());
                 }                  }
   
                if (code == 0) {                if (exit_code == 0) {
                         if (code)
                                 exit_code = code;
                         if (io_error & IOERR_DEL_LIMIT)                          if (io_error & IOERR_DEL_LIMIT)
                                code = exit_code = RERR_DEL_LIMIT;                                exit_code = RERR_DEL_LIMIT;
                         if (io_error & IOERR_VANISHED)                          if (io_error & IOERR_VANISHED)
                                code = exit_code = RERR_VANISHED;                                exit_code = RERR_VANISHED;
                         if (io_error & IOERR_GENERAL || got_xfer_error)                          if (io_error & IOERR_GENERAL || got_xfer_error)
                                code = exit_code = RERR_PARTIAL;                                exit_code = RERR_PARTIAL;
                 }                  }
   
                if (code || am_daemon || (logfile_name && (am_server || !verbose)))                /* If line < 0, this exit is after a MSG_ERROR_EXIT event, so
                        log_exit(code, file, line);                 * we don't want to output a duplicate error. */
                 if ((exit_code && line > 0)
                  || am_daemon || (logfile_name && (am_server || !INFO_GTE(STATS, 1)))) {
                         log_exit(exit_code, exit_file, exit_line);
                 }
   
                 /* FALLTHROUGH */  
 #include "case_N.h"  #include "case_N.h"
                 switch_step++;                  switch_step++;
   
                if (verbose > 2) {                if (DEBUG_GTE(EXIT, 1)) {
                         rprintf(FINFO,                          rprintf(FINFO,
                                 "[%s] _exit_cleanup(code=%d, file=%s, line=%d): "                                  "[%s] _exit_cleanup(code=%d, file=%s, line=%d): "
                                "about to call exit(%d)\n",                                "about to call exit(%d)%s\n",
                                who_am_i(), unmodified_code, file, line, code);                                who_am_i(), first_code, exit_file, exit_line, exit_code,
                                 dry_run ? " (DRY RUN)" : "");
                 }                  }
   
                 /* FALLTHROUGH */  
 #include "case_N.h"  #include "case_N.h"
                 switch_step++;                  switch_step++;
   
                if (am_server && code)                if (exit_code && exit_code != RERR_SOCKETIO && exit_code != RERR_STREAMIO && exit_code != RERR_SIGNAL1
                  && exit_code != RERR_TIMEOUT && !shutting_down) {
                         if (protocol_version >= 31 || am_receiver) {
                                 if (line > 0) {
                                         if (DEBUG_GTE(EXIT, 3)) {
                                                 rprintf(FINFO, "[%s] sending MSG_ERROR_EXIT with exit_code %d\n",
                                                         who_am_i(), exit_code);
                                         }
                                         send_msg_int(MSG_ERROR_EXIT, exit_code);
                                 }
                                 if (!am_sender)
                                         io_flush(MSG_FLUSH); /* Be sure to send all messages */
                                 noop_io_until_death();
                         }
                         else if (!am_sender)
                                 io_flush(MSG_FLUSH); /* Be sure to send all messages */
                 }
 
 #include "case_N.h"
                 switch_step++;
 
                 if (am_server && exit_code)
                         msleep(100);                          msleep(100);
                 close_all();                  close_all();
   
Line 218  NORETURN void _exit_cleanup(int code, const char *file Line 276  NORETURN void _exit_cleanup(int code, const char *file
                 break;                  break;
         }          }
   
        exit(code);        if (called_from_signal_handler)
                 _exit(exit_code);
         exit(exit_code);
 }  }
   
 void cleanup_disable(void)  void cleanup_disable(void)
 {  {
         cleanup_fname = cleanup_new_fname = NULL;          cleanup_fname = cleanup_new_fname = NULL;
           cleanup_fd_r = cleanup_fd_w = -1;
         cleanup_got_literal = 0;          cleanup_got_literal = 0;
 }  }
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>