2 * Logging and utility functions.
4 * Copyright (C) 1998-2001 Andrew Tridgell <tridge@samba.org>
5 * Copyright (C) 2000-2001 Martin Pool <mbp@samba.org>
6 * Copyright (C) 2003-2008 Wayne Davison
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, visit the http://fsf.org website.
29 extern int am_generator
;
30 extern int local_server
;
33 extern int msg_fd_out
;
34 extern int checksum_len
;
35 extern int allow_8bit_chars
;
36 extern int protocol_version
;
37 extern int always_checksum
;
38 extern int preserve_times
;
39 extern int msgs2stderr
;
42 extern int stdout_format_has_i
;
43 extern int stdout_format_has_o_or_i
;
44 extern int logfile_format_has_i
;
45 extern int logfile_format_has_o_or_i
;
46 extern int receiver_symlink_times
;
47 extern mode_t orig_umask
;
48 extern char *auth_user
;
49 extern char *stdout_format
;
50 extern char *logfile_format
;
51 extern char *logfile_name
;
53 extern iconv_t ic_chck
;
56 extern iconv_t ic_recv
;
58 extern char curr_dir
[MAXPATHLEN
];
59 extern char *module_dir
;
60 extern unsigned int module_dirlen
;
61 extern char sender_file_sum
[MAX_DIGEST_LEN
];
63 static int log_initialised
;
64 static int logfile_was_closed
;
65 static FILE *logfile_fp
;
68 int got_xfer_error
= 0;
69 int output_needs_newline
= 0;
74 } const rerr_names
[] = {
75 { RERR_SYNTAX
, "syntax or usage error" },
76 { RERR_PROTOCOL
, "protocol incompatibility" },
77 { RERR_FILESELECT
, "errors selecting input/output files, dirs" },
78 { RERR_UNSUPPORTED
, "requested action not supported" },
79 { RERR_STARTCLIENT
, "error starting client-server protocol" },
80 { RERR_SOCKETIO
, "error in socket IO" },
81 { RERR_FILEIO
, "error in file IO" },
82 { RERR_STREAMIO
, "error in rsync protocol data stream" },
83 { RERR_MESSAGEIO
, "errors with program diagnostics" },
84 { RERR_IPC
, "error in IPC code" },
85 { RERR_CRASHED
, "sibling process crashed" },
86 { RERR_TERMINATED
, "sibling process terminated abnormally" },
87 { RERR_SIGNAL1
, "received SIGUSR1" },
88 { RERR_SIGNAL
, "received SIGINT, SIGTERM, or SIGHUP" },
89 { RERR_WAITCHILD
, "waitpid() failed" },
90 { RERR_MALLOC
, "error allocating core memory buffers" },
91 { RERR_PARTIAL
, "some files could not be transferred" },
92 { RERR_VANISHED
, "some files vanished before they could be transferred" },
93 { RERR_TIMEOUT
, "timeout in data send/receive" },
94 { RERR_CONTIMEOUT
, "timeout waiting for daemon connection" },
95 { RERR_CMD_FAILED
, "remote shell failed" },
96 { RERR_CMD_KILLED
, "remote shell killed" },
97 { RERR_CMD_RUN
, "remote command could not be run" },
98 { RERR_CMD_NOTFOUND
,"remote command not found" },
99 { RERR_DEL_LIMIT
, "the --max-delete limit stopped deletions" },
104 * Map from rsync error code to name, or return NULL.
106 static char const *rerr_name(int code
)
109 for (i
= 0; rerr_names
[i
].name
; i
++) {
110 if (rerr_names
[i
].code
== code
)
111 return rerr_names
[i
].name
;
116 static void logit(int priority
, const char *buf
)
118 if (logfile_was_closed
)
121 fprintf(logfile_fp
, "%s [%d] %s",
122 timestring(time(NULL
)), (int)getpid(), buf
);
125 syslog(priority
, "%s", buf
);
129 static void syslog_init()
131 static int been_here
= 0;
132 int options
= LOG_PID
;
139 options
|= LOG_NDELAY
;
143 openlog("rsyncd", options
, lp_syslog_facility(module_id
));
145 openlog("rsyncd", options
);
149 logit(LOG_INFO
, "rsyncd started\n");
153 static void logfile_open(void)
155 mode_t old_umask
= umask(022 | orig_umask
);
156 logfile_fp
= fopen(logfile_name
, "a");
159 int fopen_errno
= errno
;
160 /* Rsync falls back to using syslog on failure. */
162 rsyserr(FERROR
, fopen_errno
,
163 "failed to open log-file %s", logfile_name
);
164 rprintf(FINFO
, "Ignoring \"log file\" setting.\n");
168 void log_init(int restart
)
170 if (log_initialised
) {
173 if (strcmp(logfile_name
, lp_log_file(module_id
)) != 0) {
180 } else if (*logfile_name
)
181 return; /* unchanged, non-empty "log file" names */
182 else if (lp_syslog_facility(-1) != lp_syslog_facility(module_id
))
185 return; /* unchanged syslog settings */
189 /* This looks pointless, but it is needed in order for the
190 * C library on some systems to fetch the timezone info
191 * before the chroot. */
192 timestring(time(NULL
));
194 /* Optionally use a log file instead of syslog. (Non-daemon
195 * rsyncs will have already set logfile_name, as needed.) */
196 if (am_daemon
&& !logfile_name
)
197 logfile_name
= lp_log_file(module_id
);
198 if (logfile_name
&& *logfile_name
)
204 void logfile_close(void)
207 logfile_was_closed
= 1;
213 void logfile_reopen(void)
215 if (logfile_was_closed
) {
216 logfile_was_closed
= 0;
221 static void filtered_fwrite(FILE *f
, const char *buf
, int len
, int use_isprint
)
223 const char *s
, *end
= buf
+ len
;
224 for (s
= buf
; s
< end
; s
++) {
226 && *s
== '\\' && s
[1] == '#'
231 && ((use_isprint
&& !isPrint(s
))
232 || *(uchar
*)s
< ' '))) {
233 if (s
!= buf
&& fwrite(buf
, s
- buf
, 1, f
) != 1)
234 exit_cleanup(RERR_MESSAGEIO
);
235 fprintf(f
, "\\#%03o", *(uchar
*)s
);
239 if (buf
!= end
&& fwrite(buf
, end
- buf
, 1, f
) != 1)
240 exit_cleanup(RERR_MESSAGEIO
);
243 /* this is the underlying (unformatted) rsync debugging function. Call
244 * it with FINFO, FERROR_*, FWARNING, FLOG, or FCLIENT. Note: recursion
245 * can happen with certain fatal conditions. */
246 void rwrite(enum logcode code
, const char *buf
, int len
, int is_utf8
)
248 int trailing_CR_or_NL
;
251 iconv_t ic
= is_utf8
&& ic_recv
!= (iconv_t
)-1 ? ic_recv
: ic_chck
;
254 iconv_t ic
= ic_chck
;
259 exit_cleanup(RERR_MESSAGEIO
);
261 if (msgs2stderr
> 0 && code
!= FLOG
)
264 if (am_server
&& msg_fd_out
>= 0) {
266 /* Pass the message to our sibling. */
267 send_msg((enum msgcode
)code
, buf
, len
, 0);
271 if (code
== FERROR_SOCKET
) /* This gets simplified for a non-sibling. */
276 else if (am_daemon
|| logfile_name
) {
279 int priority
= code
== FINFO
|| code
== FLOG
? LOG_INFO
: LOG_WARNING
;
284 if (!log_initialised
)
286 strlcpy(msg
, buf
, MIN((int)sizeof msg
, len
+ 1));
287 logit(priority
, msg
);
290 if (code
== FLOG
|| (am_daemon
&& !am_server
))
292 } else if (code
== FLOG
)
295 if (quiet
&& code
== FINFO
)
299 enum msgcode msg
= (enum msgcode
)code
;
300 if (protocol_version
< 30) {
301 if (msg
== MSG_ERROR
)
302 msg
= MSG_ERROR_XFER
;
303 else if (msg
== MSG_WARNING
)
306 /* Pass the message to the non-server side. */
307 if (send_msg(msg
, buf
, len
, !is_utf8
))
310 /* TODO: can we send the error to the user somehow? */
327 f
= msgs2stderr
? stderr
: stdout
;
330 exit_cleanup(RERR_MESSAGEIO
);
333 if (output_needs_newline
) {
335 output_needs_newline
= 0;
338 trailing_CR_or_NL
= len
&& (buf
[len
-1] == '\n' || buf
[len
-1] == '\r')
341 if (len
&& buf
[0] == '\r') {
348 if (ic
!= (iconv_t
)-1) {
353 INIT_CONST_XBUF(outbuf
, convbuf
);
354 INIT_XBUF(inbuf
, (char*)buf
, len
, (size_t)-1);
357 iconvbufs(ic
, &inbuf
, &outbuf
, 0);
360 filtered_fwrite(f
, convbuf
, outbuf
.len
, 0);
363 if (!ierrno
|| ierrno
== E2BIG
)
365 fprintf(f
, "\\#%03o", CVAL(inbuf
.buf
, inbuf
.pos
++));
370 filtered_fwrite(f
, buf
, len
, !allow_8bit_chars
);
372 if (trailing_CR_or_NL
) {
373 fputc(trailing_CR_or_NL
, f
);
378 /* This is the rsync debugging function. Call it with FINFO, FERROR_*,
379 * FWARNING, FLOG, or FCLIENT. */
380 void rprintf(enum logcode code
, const char *format
, ...)
383 char buf
[BIGPATHBUFLEN
];
386 va_start(ap
, format
);
387 len
= vsnprintf(buf
, sizeof buf
, format
, ap
);
390 /* Deal with buffer overruns. Instead of panicking, just
391 * truncate the resulting string. (Note that configure ensures
392 * that we have a vsnprintf() that doesn't ever return -1.) */
393 if (len
> sizeof buf
- 1) {
394 static const char ellipsis
[] = "[...]";
396 /* Reset length, and zero-terminate the end of our buffer */
397 len
= sizeof buf
- 1;
400 /* Copy the ellipsis to the end of the string, but give
401 * us one extra character:
403 * v--- null byte at buf[sizeof buf - 1]
405 * -> abcd[...]00 <-- now two null bytes at end
407 * If the input format string has a trailing newline,
408 * we copy it into that extra null; if it doesn't, well,
409 * all we lose is one byte. */
410 memcpy(buf
+len
-sizeof ellipsis
, ellipsis
, sizeof ellipsis
);
411 if (format
[strlen(format
)-1] == '\n') {
416 rwrite(code
, buf
, len
, 0);
419 /* This is like rprintf, but it also tries to print some
420 * representation of the error code. Normally errcode = errno.
422 * Unlike rprintf, this always adds a newline and there should not be
423 * one in the format string.
425 * Note that since strerror might involve dynamically loading a
426 * message catalog we need to call it once before chroot-ing. */
427 void rsyserr(enum logcode code
, int errcode
, const char *format
, ...)
430 char buf
[BIGPATHBUFLEN
];
433 strlcpy(buf
, RSYNC_NAME
": ", sizeof buf
);
434 len
= (sizeof RSYNC_NAME
": ") - 1;
436 va_start(ap
, format
);
437 len
+= vsnprintf(buf
+ len
, sizeof buf
- len
, format
, ap
);
440 if (len
< sizeof buf
) {
441 len
+= snprintf(buf
+ len
, sizeof buf
- len
,
442 ": %s (%d)\n", strerror(errcode
), errcode
);
444 if (len
>= sizeof buf
)
445 exit_cleanup(RERR_MESSAGEIO
);
447 rwrite(code
, buf
, len
, 0);
450 void rflush(enum logcode code
)
454 if (am_daemon
|| code
== FLOG
)
457 if (!am_server
&& (code
== FINFO
|| code
== FCLIENT
))
465 /* A generic logging routine for send/recv, with parameter substitiution. */
466 static void log_formatted(enum logcode code
, const char *format
, const char *op
,
467 struct file_struct
*file
, const char *fname
,
468 struct stats
*initial_stats
, int iflags
,
471 char buf
[MAXPATHLEN
+1024], buf2
[MAXPATHLEN
], fmt
[32];
479 /* We expand % codes one by one in place in buf. We don't
480 * copy in the terminating null of the inserted strings, but
481 * rather keep going until we reach the null of the format. */
482 total
= strlcpy(buf
, format
, sizeof buf
);
483 if (total
> MAXPATHLEN
) {
484 rprintf(FERROR
, "log-format string is WAY too long!\n");
485 exit_cleanup(RERR_MESSAGEIO
);
490 for (p
= buf
; (p
= strchr(p
, '%')) != NULL
; ) {
495 while (isDigit(p
) && c
- fmt
< (int)(sizeof fmt
) - 8)
512 strlcat(fmt
, "s", sizeof fmt
);
513 snprintf(buf2
, sizeof buf2
, fmt
,
514 big_num(F_LENGTH(file
), 0));
518 strlcat(fmt
, "u", sizeof fmt
);
519 snprintf(buf2
, sizeof buf2
, fmt
,
520 uid_ndx
? F_OWNER(file
) : 0);
524 if (!gid_ndx
|| file
->flags
& FLAG_SKIP_GROUP
)
527 strlcat(fmt
, "u", sizeof fmt
);
528 snprintf(buf2
, sizeof buf2
, fmt
,
534 strlcat(fmt
, "ld", sizeof fmt
);
535 snprintf(buf2
, sizeof buf2
, fmt
,
540 n
= c
= timestring(file
->modtime
);
541 while ((c
= strchr(c
, ' ')) != NULL
)
545 c
= buf2
+ MAXPATHLEN
- PERMSTRING_SIZE
- 1;
546 permstring(c
, file
->mode
);
547 n
= c
+ 1; /* skip the type char */
555 strlcpy(c
, fname
, MAXPATHLEN
);
557 c
= f_name(file
, NULL
);
558 if (am_sender
&& F_PATHNAME(file
)) {
559 pathjoin(buf2
, sizeof buf2
,
560 F_PATHNAME(file
), c
);
561 clean_fname(buf2
, 0);
563 strlcpy(c
, buf2
, MAXPATHLEN
);
567 } else if (am_daemon
&& *c
!= '/') {
568 pathjoin(buf2
, sizeof buf2
,
569 curr_dir
+ module_dirlen
, c
);
570 clean_fname(buf2
, 0);
572 strlcpy(c
, buf2
, MAXPATHLEN
);
586 strlcpy(c
, fname
, MAXPATHLEN
);
588 c
= f_name(file
, NULL
);
589 if (S_ISDIR(file
->mode
))
590 strlcat(c
, "/", MAXPATHLEN
);
594 if (hlink
&& *hlink
) {
596 strlcpy(buf2
, " => ", sizeof buf2
);
597 } else if (S_ISLNK(file
->mode
) && !fname
) {
599 strlcpy(buf2
, " -> ", sizeof buf2
);
604 strlcpy(buf2
, " ", sizeof buf2
);
606 strlcat(fmt
, "s", sizeof fmt
);
607 snprintf(buf2
+ 4, sizeof buf2
- 4, fmt
, n
);
611 n
= lp_name(module_id
);
614 n
= timestring(time(NULL
));
624 b
= stats
.total_written
-
625 initial_stats
->total_written
;
627 b
= stats
.total_read
-
628 initial_stats
->total_read
;
630 strlcat(fmt
, "s", sizeof fmt
);
631 snprintf(buf2
, sizeof buf2
, fmt
, big_num(b
, 0));
636 b
= stats
.total_written
-
637 initial_stats
->total_written
;
639 b
= stats
.total_read
-
640 initial_stats
->total_read
;
642 strlcat(fmt
, "s", sizeof fmt
);
643 snprintf(buf2
, sizeof buf2
, fmt
, big_num(b
, 0));
647 if (protocol_version
>= 30
648 && (iflags
& ITEM_TRANSFER
649 || (always_checksum
&& S_ISREG(file
->mode
)))) {
651 const char *sum
= iflags
& ITEM_TRANSFER
652 ? sender_file_sum
: F_SUM(file
);
653 c
= buf2
+ checksum_len
*2;
655 for (i
= checksum_len
; --i
>= 0; ) {
659 *--c
= x1
<= 9 ? x1
+ '0' : x1
+ 'a' - 10;
660 *--c
= x2
<= 9 ? x2
+ '0' : x2
+ 'a' - 10;
663 memset(buf2
, ' ', checksum_len
*2);
664 buf2
[checksum_len
*2] = '\0';
669 if (iflags
& ITEM_DELETED
) {
673 n
= c
= buf2
+ MAXPATHLEN
- 32;
674 c
[0] = iflags
& ITEM_LOCAL_CHANGE
675 ? iflags
& ITEM_XNAME_FOLLOWS
? 'h' : 'c'
676 : !(iflags
& ITEM_TRANSFER
) ? '.'
677 : !local_server
&& *op
== 's' ? '<' : '>';
678 if (S_ISLNK(file
->mode
)) {
681 c
[4] = !(iflags
& ITEM_REPORT_TIME
) ? '.'
682 : !preserve_times
|| !receiver_symlink_times
683 || (iflags
& ITEM_REPORT_TIMEFAIL
) ? 'T' : 't';
685 c
[1] = S_ISDIR(file
->mode
) ? 'd'
686 : IS_SPECIAL(file
->mode
) ? 'S'
687 : IS_DEVICE(file
->mode
) ? 'D' : 'f';
688 c
[3] = !(iflags
& ITEM_REPORT_SIZE
) ? '.' : 's';
689 c
[4] = !(iflags
& ITEM_REPORT_TIME
) ? '.'
690 : !preserve_times
? 'T' : 't';
692 c
[2] = !(iflags
& ITEM_REPORT_CHANGE
) ? '.' : 'c';
693 c
[5] = !(iflags
& ITEM_REPORT_PERMS
) ? '.' : 'p';
694 c
[6] = !(iflags
& ITEM_REPORT_OWNER
) ? '.' : 'o';
695 c
[7] = !(iflags
& ITEM_REPORT_GROUP
) ? '.' : 'g';
696 c
[8] = !(iflags
& ITEM_REPORT_ATIME
) ? '.' : 'u';
697 c
[9] = !(iflags
& ITEM_REPORT_ACL
) ? '.' : 'a';
698 c
[10] = !(iflags
& ITEM_REPORT_XATTR
) ? '.' : 'x';
701 if (iflags
& (ITEM_IS_NEW
|ITEM_MISSING_DATA
)) {
702 char ch
= iflags
& ITEM_IS_NEW
? '+' : '?';
704 for (i
= 2; c
[i
]; i
++)
706 } else if (c
[0] == '.' || c
[0] == 'h' || c
[0] == 'c') {
708 for (i
= 2; c
[i
]; i
++) {
713 for (i
= 2; c
[i
]; i
++)
720 /* "n" is the string to be inserted in place of this % code. */
723 if (n
!= buf2
&& fmt
[1]) {
724 strlcat(fmt
, "s", sizeof fmt
);
725 snprintf(buf2
, sizeof buf2
, fmt
, n
);
730 /* Subtract the length of the escape from the string's size. */
733 if (len
+ total
>= (size_t)sizeof buf
) {
735 "buffer overflow expanding %%%c -- exiting\n",
737 exit_cleanup(RERR_MESSAGEIO
);
740 /* Shuffle the rest of the string along to make space for n */
741 if (len
!= (size_t)(p
- s
+ 1))
742 memmove(s
+ len
, p
+ 1, total
- (s
- buf
) + 1);
745 /* Insert the contents of string "n", but NOT its null. */
749 /* Skip over inserted string; continue looking */
753 rwrite(code
, buf
, total
, 0);
756 /* Return 1 if the format escape is in the log-format string (e.g. look for
757 * the 'b' in the "%9b" format escape). */
758 int log_format_has(const char *format
, char esc
)
765 for (p
= format
; (p
= strchr(p
, '%')) != NULL
; ) {
778 /* Log the transfer of a file. If the code is FCLIENT, the output just goes
779 * to stdout. If it is FLOG, it just goes to the log file. Otherwise we
781 void log_item(enum logcode code
, struct file_struct
*file
,
782 struct stats
*initial_stats
, int iflags
, const char *hlink
)
784 const char *s_or_r
= am_sender
? "send" : "recv";
786 if (code
!= FLOG
&& stdout_format
&& !am_server
) {
787 log_formatted(FCLIENT
, stdout_format
, s_or_r
,
788 file
, NULL
, initial_stats
, iflags
, hlink
);
790 if (code
!= FCLIENT
&& logfile_format
&& *logfile_format
) {
791 log_formatted(FLOG
, logfile_format
, s_or_r
,
792 file
, NULL
, initial_stats
, iflags
, hlink
);
796 void maybe_log_item(struct file_struct
*file
, int iflags
, int itemizing
,
799 int significant_flags
= iflags
& SIGNIFICANT_ITEM_FLAGS
;
800 int see_item
= itemizing
&& (significant_flags
|| *buf
801 || stdout_format_has_i
> 1 || (INFO_GTE(NAME
, 2) && stdout_format_has_i
));
802 int local_change
= iflags
& ITEM_LOCAL_CHANGE
&& significant_flags
;
804 if (logfile_name
&& !dry_run
&& see_item
805 && (significant_flags
|| logfile_format_has_i
))
806 log_item(FLOG
, file
, &stats
, iflags
, buf
);
807 } else if (see_item
|| local_change
|| *buf
808 || (S_ISDIR(file
->mode
) && significant_flags
)) {
809 enum logcode code
= significant_flags
|| logfile_format_has_i
? FINFO
: FCLIENT
;
810 log_item(code
, file
, &stats
, iflags
, buf
);
814 void log_delete(const char *fname
, int mode
)
817 union file_extras ex
[4]; /* just in case... */
818 struct file_struct file
;
820 int len
= strlen(fname
);
825 if (!INFO_GTE(DEL
, 1) && !stdout_format
)
827 else if (am_server
&& protocol_version
>= 29 && len
< MAXPATHLEN
) {
829 len
++; /* directories include trailing null */
830 send_msg(MSG_DELETED
, fname
, len
, am_generator
);
832 fmt
= stdout_format_has_o_or_i
? stdout_format
: "deleting %n";
833 log_formatted(FCLIENT
, fmt
, "del.", &x
.file
, fname
, &stats
,
837 if (!logfile_name
|| dry_run
|| !logfile_format
)
840 fmt
= logfile_format_has_o_or_i
? logfile_format
: "deleting %n";
841 log_formatted(FLOG
, fmt
, "del.", &x
.file
, fname
, &stats
, ITEM_DELETED
, NULL
);
845 * Called when the transfer is interrupted for some reason.
847 * Code is one of the RERR_* codes from errcode.h, or terminating
850 void log_exit(int code
, const char *file
, int line
)
853 rprintf(FLOG
,"sent %s bytes received %s bytes total size %s\n",
854 big_num(stats
.total_written
, 0),
855 big_num(stats
.total_read
, 0),
856 big_num(stats
.total_size
, 0));
857 } else if (am_server
!= 2) {
860 name
= rerr_name(code
);
862 name
= "unexplained error";
864 /* VANISHED is not an error, only a warning */
865 if (code
== RERR_VANISHED
) {
866 rprintf(FWARNING
, "rsync warning: %s (code %d) at %s(%d) [%s=%s]\n",
867 name
, code
, file
, line
, who_am_i(), RSYNC_VERSION
);
869 rprintf(FERROR
, "rsync error: %s (code %d) at %s(%d) [%s=%s]\n",
870 name
, code
, file
, line
, who_am_i(), RSYNC_VERSION
);