2 * Utility routines used in rsync.
4 * Copyright (C) 1996-2000 Andrew Tridgell
5 * Copyright (C) 1996 Paul Mackerras
6 * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
7 * Copyright (C) 2003-2008 Wayne Davison
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 3 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, visit the http://fsf.org website.
29 extern int modify_window
;
30 extern int relative_paths
;
31 extern int human_readable
;
32 extern char *module_dir
;
33 extern unsigned int module_dirlen
;
34 extern mode_t orig_umask
;
35 extern char *partial_dir
;
36 extern struct filter_list_struct daemon_filter_list
;
38 int sanitize_paths
= 0;
40 char curr_dir
[MAXPATHLEN
];
41 unsigned int curr_dir_len
;
42 int curr_dir_depth
; /* This is only set for a sanitizing daemon. */
44 /* Set a fd into nonblocking mode. */
45 void set_nonblocking(int fd
)
49 if ((val
= fcntl(fd
, F_GETFL
)) == -1)
51 if (!(val
& NONBLOCK_FLAG
)) {
53 fcntl(fd
, F_SETFL
, val
);
57 /* Set a fd into blocking mode. */
58 void set_blocking(int fd
)
62 if ((val
= fcntl(fd
, F_GETFL
)) == -1)
64 if (val
& NONBLOCK_FLAG
) {
65 val
&= ~NONBLOCK_FLAG
;
66 fcntl(fd
, F_SETFL
, val
);
71 * Create a file descriptor pair - like pipe() but use socketpair if
72 * possible (because of blocking issues on pipes).
74 * Always set non-blocking.
76 int fd_pair(int fd
[2])
80 #ifdef HAVE_SOCKETPAIR
81 ret
= socketpair(AF_UNIX
, SOCK_STREAM
, 0, fd
);
87 set_nonblocking(fd
[0]);
88 set_nonblocking(fd
[1]);
94 void print_child_argv(const char *prefix
, char **cmd
)
96 rprintf(FCLIENT
, "%s ", prefix
);
98 /* Look for characters that ought to be quoted. This
99 * is not a great quoting algorithm, but it's
100 * sufficient for a log message. */
101 if (strspn(*cmd
, "abcdefghijklmnopqrstuvwxyz"
102 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
104 ",.-_=+@/") != strlen(*cmd
)) {
105 rprintf(FCLIENT
, "\"%s\" ", *cmd
);
107 rprintf(FCLIENT
, "%s ", *cmd
);
110 rprintf(FCLIENT
, "\n");
113 NORETURN
void out_of_memory(const char *str
)
115 rprintf(FERROR
, "ERROR: out of memory in %s [%s]\n", str
, who_am_i());
116 exit_cleanup(RERR_MALLOC
);
119 NORETURN
void overflow_exit(const char *str
)
121 rprintf(FERROR
, "ERROR: buffer overflow in %s [%s]\n", str
, who_am_i());
122 exit_cleanup(RERR_MALLOC
);
125 int set_modtime(const char *fname
, time_t modtime
, mode_t mode
)
127 #if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
133 rprintf(FINFO
, "set modtime of %s to (%ld) %s",
134 fname
, (long)modtime
,
135 asctime(localtime(&modtime
)));
144 t
[0].tv_sec
= time(NULL
);
146 t
[1].tv_sec
= modtime
;
150 if (lutimes(fname
, t
) < 0)
151 return errno
== ENOSYS
? 1 : -1;
155 return utimes(fname
, t
);
156 #elif defined HAVE_STRUCT_UTIMBUF
158 tbuf
.actime
= time(NULL
);
159 tbuf
.modtime
= modtime
;
160 return utime(fname
,&tbuf
);
161 #elif defined HAVE_UTIME
165 return utime(fname
,t
);
167 #error No file-time-modification routine found!
172 /* This creates a new directory with default permissions. Since there
173 * might be some directory-default permissions affecting this, we can't
174 * force the permissions directly using the original umask and mkdir(). */
175 int mkdir_defmode(char *fname
)
180 ret
= do_mkdir(fname
, ACCESSPERMS
);
186 /* Create any necessary directories in fname. Any missing directories are
187 * created with default permissions. */
188 int create_directory_path(char *fname
)
193 while (*fname
== '/')
195 while (strncmp(fname
, "./", 2) == 0)
200 while ((p
= strchr(p
,'/')) != NULL
) {
202 if (do_mkdir(fname
, ACCESSPERMS
) < 0 && errno
!= EEXIST
)
212 * Write @p len bytes at @p ptr to descriptor @p desc, retrying if
215 * @retval len upon success
217 * @retval <0 write's (negative) error code
219 * Derived from GNU C's cccp.c.
221 int full_write(int desc
, const char *ptr
, size_t len
)
227 int written
= write(desc
, ptr
, len
);
233 total_written
+= written
;
237 return total_written
;
241 * Read @p len bytes at @p ptr from descriptor @p desc, retrying if
244 * @retval >0 the actual number of bytes read
248 * @retval <0 for an error.
250 * Derived from GNU C's cccp.c. */
251 static int safe_read(int desc
, char *ptr
, size_t len
)
259 n_chars
= read(desc
, ptr
, len
);
260 } while (n_chars
< 0 && errno
== EINTR
);
265 /* Copy a file. If ofd < 0, copy_file unlinks and opens the "dest" file.
266 * Otherwise, it just writes to and closes the provided file descriptor.
268 * This is used in conjunction with the --temp-dir, --backup, and
269 * --copy-dest options. */
270 int copy_file(const char *source
, const char *dest
, int ofd
,
271 mode_t mode
, int create_bak_dir
)
275 int len
; /* Number of bytes read into `buf'. */
277 if ((ifd
= do_open(source
, O_RDONLY
, 0)) < 0) {
278 rsyserr(FERROR_XFER
, errno
, "open %s", full_fname(source
));
283 if (robust_unlink(dest
) && errno
!= ENOENT
) {
284 rsyserr(FERROR_XFER
, errno
, "unlink %s", full_fname(dest
));
288 if ((ofd
= do_open(dest
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_EXCL
, mode
)) < 0
289 && (!create_bak_dir
|| errno
!= ENOENT
|| make_bak_dir(dest
) < 0
290 || (ofd
= do_open(dest
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_EXCL
, mode
)) < 0)) {
291 rsyserr(FERROR_XFER
, errno
, "open %s", full_fname(dest
));
297 while ((len
= safe_read(ifd
, buf
, sizeof buf
)) > 0) {
298 if (full_write(ofd
, buf
, len
) < 0) {
299 rsyserr(FERROR_XFER
, errno
, "write %s", full_fname(dest
));
307 rsyserr(FERROR_XFER
, errno
, "read %s", full_fname(source
));
313 if (close(ifd
) < 0) {
314 rsyserr(FWARNING
, errno
, "close failed on %s",
318 if (close(ofd
) < 0) {
319 rsyserr(FERROR_XFER
, errno
, "close failed on %s",
327 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
328 #define MAX_RENAMES_DIGITS 3
329 #define MAX_RENAMES 1000
332 * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
333 * rename to <path>/.rsyncNNN instead.
335 * Note that successive rsync runs will shuffle the filenames around a
336 * bit as long as the file is still busy; this is because this function
337 * does not know if the unlink call is due to a new file coming in, or
338 * --delete trying to remove old .rsyncNNN files, hence it renames it
341 int robust_unlink(const char *fname
)
344 return do_unlink(fname
);
346 static int counter
= 1;
348 char path
[MAXPATHLEN
];
350 rc
= do_unlink(fname
);
351 if (rc
== 0 || errno
!= ETXTBSY
)
354 if ((pos
= strlcpy(path
, fname
, MAXPATHLEN
)) >= MAXPATHLEN
)
355 pos
= MAXPATHLEN
- 1;
357 while (pos
> 0 && path
[pos
-1] != '/')
359 pos
+= strlcpy(path
+pos
, ".rsync", MAXPATHLEN
-pos
);
361 if (pos
> (MAXPATHLEN
-MAX_RENAMES_DIGITS
-1)) {
366 /* start where the last one left off to reduce chance of clashes */
369 snprintf(&path
[pos
], MAX_RENAMES_DIGITS
+1, "%03d", counter
);
370 if (++counter
>= MAX_RENAMES
)
372 } while ((rc
= access(path
, 0)) == 0 && counter
!= start
);
375 rprintf(FWARNING
, "renaming %s to %s because of text busy\n",
379 /* maybe we should return rename()'s exit status? Nah. */
380 if (do_rename(fname
, path
) != 0) {
388 /* Returns 0 on successful rename, 1 if we successfully copied the file
389 * across filesystems, -2 if copy_file() failed, and -1 on other errors.
390 * If partialptr is not NULL and we need to do a copy, copy the file into
391 * the active partial-dir instead of over the destination file. */
392 int robust_rename(const char *from
, const char *to
, const char *partialptr
,
398 if (do_rename(from
, to
) == 0)
404 if (robust_unlink(to
) != 0)
410 if (!handle_partial_dir(partialptr
,PDIR_CREATE
))
414 if (copy_file(from
, to
, -1, mode
, 0) != 0)
425 static pid_t all_pids
[10];
428 /** Fork and record the pid of the child. **/
431 pid_t newpid
= fork();
433 if (newpid
!= 0 && newpid
!= -1) {
434 all_pids
[num_pids
++] = newpid
;
442 * @todo It would be kind of nice to make sure that they are actually
443 * all our children before we kill them, because their pids may have
444 * been recycled by some other process. Perhaps when we wait for a
445 * child, we should remove it from this array. Alternatively we could
446 * perhaps use process groups, but I think that would not work on
447 * ancient Unix versions that don't support them.
449 void kill_all(int sig
)
453 for (i
= 0; i
< num_pids
; i
++) {
454 /* Let's just be a little careful where we
455 * point that gun, hey? See kill(2) for the
456 * magic caused by negative values. */
457 pid_t p
= all_pids
[i
];
468 /** Turn a user name into a uid */
469 int name_to_uid(const char *name
, uid_t
*uid_p
)
474 if (!(pass
= getpwnam(name
)))
476 *uid_p
= pass
->pw_uid
;
480 /** Turn a group name into a gid */
481 int name_to_gid(const char *name
, gid_t
*gid_p
)
486 if (!(grp
= getgrnam(name
)))
488 *gid_p
= grp
->gr_gid
;
492 /** Lock a byte range in a open file */
493 int lock_range(int fd
, int offset
, int len
)
497 lock
.l_type
= F_WRLCK
;
498 lock
.l_whence
= SEEK_SET
;
499 lock
.l_start
= offset
;
503 return fcntl(fd
,F_SETLK
,&lock
) == 0;
506 #define ENSURE_MEMSPACE(buf, type, sz, req) \
507 if ((req) >= sz && !(buf = realloc_array(buf, type, sz *= 2))) \
508 out_of_memory("ENSURE_MEMSPACE")
510 static inline void call_glob_match(const char *name
, int len
, int from_glob
,
511 char *arg
, int abpos
, int fbpos
);
513 static struct glob_data
{
514 char *arg_buf
, *filt_buf
, **argv
;
515 int absize
, fbsize
, maxargs
, argc
;
518 static void glob_match(char *arg
, int abpos
, int fbpos
)
523 while (*arg
== '.' && arg
[1] == '/') {
525 if (glob
.fbsize
< glob
.absize
) {
526 glob
.filt_buf
= realloc_array(glob
.filt_buf
,
527 char, glob
.fbsize
= glob
.absize
);
529 memcpy(glob
.filt_buf
, glob
.arg_buf
, abpos
+ 1);
532 ENSURE_MEMSPACE(glob
.arg_buf
, char, glob
.absize
, abpos
+ 2);
533 glob
.arg_buf
[abpos
++] = *arg
++;
534 glob
.arg_buf
[abpos
++] = *arg
++;
535 glob
.arg_buf
[abpos
] = '\0';
537 if ((slash
= strchr(arg
, '/')) != NULL
) {
542 if (strpbrk(arg
, "*?[")) {
546 if (!(d
= opendir(abpos
? glob
.arg_buf
: ".")))
548 while ((di
= readdir(d
)) != NULL
) {
549 char *dname
= d_name(di
);
550 if (dname
[0] == '.' && (dname
[1] == '\0'
551 || (dname
[1] == '.' && dname
[2] == '\0')))
553 if (!wildmatch(arg
, dname
))
555 call_glob_match(dname
, strlen(dname
), 1,
556 slash
? arg
+ len
+ 1 : NULL
,
561 call_glob_match(arg
, len
, 0,
562 slash
? arg
+ len
+ 1 : NULL
,
569 static inline void call_glob_match(const char *name
, int len
, int from_glob
,
570 char *arg
, int abpos
, int fbpos
)
574 ENSURE_MEMSPACE(glob
.arg_buf
, char, glob
.absize
, abpos
+ len
+ 2);
575 memcpy(glob
.arg_buf
+ abpos
, name
, len
);
577 glob
.arg_buf
[abpos
] = '\0';
580 ENSURE_MEMSPACE(glob
.filt_buf
, char, glob
.fbsize
, fbpos
+ len
+ 2);
581 memcpy(glob
.filt_buf
+ fbpos
, name
, len
);
583 glob
.filt_buf
[fbpos
] = '\0';
584 use_buf
= glob
.filt_buf
;
586 use_buf
= glob
.arg_buf
;
588 if (from_glob
|| arg
) {
592 if (do_stat(glob
.arg_buf
, &st
) != 0) {
597 is_dir
= S_ISDIR(st
.st_mode
) != 0;
602 if (daemon_filter_list
.head
603 && check_filter(&daemon_filter_list
, use_buf
, is_dir
) < 0) {
611 glob
.arg_buf
[abpos
++] = '/';
612 glob
.arg_buf
[abpos
] = '\0';
614 glob
.filt_buf
[fbpos
++] = '/';
615 glob
.filt_buf
[fbpos
] = '\0';
617 glob_match(arg
, abpos
, fbpos
);
619 ENSURE_MEMSPACE(glob
.argv
, char *, glob
.maxargs
, glob
.argc
+ 1);
620 if (!(glob
.argv
[glob
.argc
++] = strdup(glob
.arg_buf
)))
621 out_of_memory("glob_match");
625 /* This routine performs wild-card expansion of the pathname in "arg". Any
626 * daemon-excluded files/dirs will not be matched by the wildcards. Returns 0
627 * if a wild-card string is the only returned item (due to matching nothing). */
628 int glob_expand(const char *arg
, char ***argv_p
, int *argc_p
, int *maxargs_p
)
637 memset(&glob
, 0, sizeof glob
);
642 s
= sanitize_path(NULL
, arg
, "", 0, SP_KEEP_DOT_DIRS
);
646 out_of_memory("glob_expand");
647 clean_fname(s
, CFN_KEEP_DOT_DIRS
648 | CFN_KEEP_TRAILING_SLASH
649 | CFN_COLLAPSE_DOT_DOT_DIRS
);
652 if (glob
.absize
< MAXPATHLEN
653 && !(glob
.arg_buf
= realloc_array(glob
.arg_buf
, char, glob
.absize
= MAXPATHLEN
)))
654 out_of_memory("glob_expand");
655 *glob
.arg_buf
= '\0';
657 glob
.argc
= save_argc
= *argc_p
;
659 glob
.maxargs
= *maxargs_p
;
661 if (glob
.maxargs
< 100
662 && !(glob
.argv
= realloc_array(glob
.argv
, char *, glob
.maxargs
= 100)))
663 out_of_memory("glob_expand");
665 glob_match(s
, 0, -1);
667 /* The arg didn't match anything, so add the failed arg to the list. */
668 if (glob
.argc
== save_argc
) {
669 ENSURE_MEMSPACE(glob
.argv
, char *, glob
.maxargs
, glob
.argc
+ 1);
670 glob
.argv
[glob
.argc
++] = s
;
677 *maxargs_p
= glob
.maxargs
;
684 /* This routine is only used in daemon mode. */
685 void glob_expand_module(char *base1
, char *arg
, char ***argv_p
, int *argc_p
, int *maxargs_p
)
689 int base_len
= strlen(base
);
694 if (strncmp(arg
, base
, base_len
) == 0)
697 if (!(arg
= strdup(arg
)))
698 out_of_memory("glob_expand_module");
700 if (asprintf(&base
," %s/", base1
) <= 0)
701 out_of_memory("glob_expand_module");
704 for (s
= arg
; *s
; s
= p
+ base_len
) {
705 if ((p
= strstr(s
, base
)) != NULL
)
706 *p
= '\0'; /* split it at this point */
707 glob_expand(s
, argv_p
, argc_p
, maxargs_p
);
717 * Convert a string to lower case
719 void strlower(char *s
)
728 /* Join strings p1 & p2 into "dest" with a guaranteed '/' between them. (If
729 * p1 ends with a '/', no extra '/' is inserted.) Returns the length of both
730 * strings + 1 (if '/' was inserted), regardless of whether the null-terminated
731 * string fits into destsize. */
732 size_t pathjoin(char *dest
, size_t destsize
, const char *p1
, const char *p2
)
734 size_t len
= strlcpy(dest
, p1
, destsize
);
735 if (len
< destsize
- 1) {
736 if (!len
|| dest
[len
-1] != '/')
738 if (len
< destsize
- 1)
739 len
+= strlcpy(dest
+ len
, p2
, destsize
- len
);
746 len
+= strlen(p2
) + 1; /* Assume we'd insert a '/'. */
750 /* Join any number of strings together, putting them in "dest". The return
751 * value is the length of all the strings, regardless of whether the null-
752 * terminated whole fits in destsize. Your list of string pointers must end
753 * with a NULL to indicate the end of the list. */
754 size_t stringjoin(char *dest
, size_t destsize
, ...)
760 va_start(ap
, destsize
);
762 if (!(src
= va_arg(ap
, const char *)))
769 memcpy(dest
, src
, len
);
780 int count_dir_elements(const char *p
)
782 int cnt
= 0, new_component
= 1;
785 new_component
= (*p
!= '.' || (p
[1] != '/' && p
[1] != '\0'));
786 else if (new_component
) {
794 /* Turns multiple adjacent slashes into a single slash, drops all leading or
795 * interior "." elements unless CFN_KEEP_DOT_DIRS is flagged. Will also drop
796 * a trailing '.' after a '/' if CFN_DROP_TRAILING_DOT_DIR is flagged, removes
797 * a trailing slash (perhaps after removing the aforementioned dot) unless
798 * CFN_KEEP_TRAILING_SLASH is flagged, and will also collapse ".." elements
799 * (except at the start) if CFN_COLLAPSE_DOT_DOT_DIRS is flagged. If the
800 * resulting name would be empty, returns ".". */
801 unsigned int clean_fname(char *name
, int flags
)
803 char *limit
= name
- 1, *t
= name
, *f
= name
;
809 if ((anchored
= *f
== '/') != 0)
811 else if (flags
& CFN_KEEP_DOT_DIRS
&& *f
== '.' && f
[1] == '/') {
816 /* discard extra slashes */
822 /* discard interior "." dirs */
823 if (f
[1] == '/' && !(flags
& CFN_KEEP_DOT_DIRS
)) {
827 if (f
[1] == '\0' && flags
& CFN_DROP_TRAILING_DOT_DIR
)
829 /* collapse ".." dirs */
830 if (flags
& CFN_COLLAPSE_DOT_DOT_DIRS
831 && f
[1] == '.' && (f
[2] == '/' || !f
[2])) {
833 if (s
== name
&& anchored
) {
837 while (s
> limit
&& *--s
!= '/') {}
838 if (s
!= t
- 1 && (s
< name
|| *s
== '/')) {
846 while (*f
&& (*t
++ = *f
++) != '/') {}
849 if (t
> name
+anchored
&& t
[-1] == '/' && !(flags
& CFN_KEEP_TRAILING_SLASH
))
858 /* Make path appear as if a chroot had occurred. This handles a leading
859 * "/" (either removing it or expanding it) and any leading or embedded
860 * ".." components that attempt to escape past the module's top dir.
862 * If dest is NULL, a buffer is allocated to hold the result. It is legal
863 * to call with the dest and the path (p) pointing to the same buffer, but
864 * rootdir will be ignored to avoid expansion of the string.
866 * The rootdir string contains a value to use in place of a leading slash.
867 * Specify NULL to get the default of "module_dir".
869 * The depth var is a count of how many '..'s to allow at the start of the
872 * We also clean the path in a manner similar to clean_fname() but with a
875 * Turns multiple adjacent slashes into a single slash, gets rid of "." dir
876 * elements (INCLUDING a trailing dot dir), PRESERVES a trailing slash, and
877 * ALWAYS collapses ".." elements (except for those at the start of the
878 * string up to "depth" deep). If the resulting name would be empty,
879 * change it into a ".". */
880 char *sanitize_path(char *dest
, const char *p
, const char *rootdir
, int depth
,
884 int rlen
= 0, drop_dot_dirs
= !relative_paths
|| !(flags
& SP_KEEP_DOT_DIRS
);
887 int plen
= strlen(p
);
890 rootdir
= module_dir
;
891 rlen
= strlen(rootdir
);
896 if (rlen
+ plen
+ 1 >= MAXPATHLEN
)
898 } else if (!(dest
= new_array(char, rlen
+ plen
+ 1)))
899 out_of_memory("sanitize_path");
901 memcpy(dest
, rootdir
, rlen
);
908 while (*p
== '.' && p
[1] == '/')
912 start
= sanp
= dest
+ rlen
;
913 /* This loop iterates once per filename component in p, pointing at
914 * the start of the name (past any prior slash) for each iteration. */
916 /* discard leading or extra slashes */
922 if (*p
== '.' && (p
[1] == '/' || p
[1] == '\0')) {
923 /* skip "." component */
928 if (*p
== '.' && p
[1] == '.' && (p
[2] == '/' || p
[2] == '\0')) {
929 /* ".." component followed by slash or end */
930 if (depth
<= 0 || sanp
!= start
) {
933 /* back up sanp one level */
934 --sanp
; /* now pointing at slash */
935 while (sanp
> start
&& sanp
[-1] != '/')
940 /* allow depth levels of .. at the beginning */
942 /* move the virtual beginning to leave the .. alone */
945 /* copy one component through next slash */
946 while (*p
&& (*sanp
++ = *p
++) != '/') {}
949 /* ended up with nothing, so put in "." component */
957 /* Like chdir(), but it keeps track of the current directory (in the
958 * global "curr_dir"), and ensures that the path size doesn't overflow.
959 * Also cleans the path using the clean_fname() function. */
960 int push_dir(const char *dir
, int set_path_only
)
962 static int initialised
;
967 getcwd(curr_dir
, sizeof curr_dir
- 1);
968 curr_dir_len
= strlen(curr_dir
);
971 if (!dir
) /* this call was probably just to initialize */
975 if (len
== 1 && *dir
== '.')
978 if ((*dir
== '/' ? len
: curr_dir_len
+ 1 + len
) >= sizeof curr_dir
) {
979 errno
= ENAMETOOLONG
;
983 if (!set_path_only
&& chdir(dir
))
987 memcpy(curr_dir
, dir
, len
+ 1);
990 curr_dir
[curr_dir_len
++] = '/';
991 memcpy(curr_dir
+ curr_dir_len
, dir
, len
+ 1);
995 curr_dir_len
= clean_fname(curr_dir
, CFN_COLLAPSE_DOT_DOT_DIRS
);
996 if (sanitize_paths
) {
997 if (module_dirlen
> curr_dir_len
)
998 module_dirlen
= curr_dir_len
;
999 curr_dir_depth
= count_dir_elements(curr_dir
+ module_dirlen
);
1002 if (verbose
>= 5 && !set_path_only
)
1003 rprintf(FINFO
, "[%s] push_dir(%s)\n", who_am_i(), curr_dir
);
1009 * Reverse a push_dir() call. You must pass in an absolute path
1010 * that was copied from a prior value of "curr_dir".
1012 int pop_dir(const char *dir
)
1017 curr_dir_len
= strlcpy(curr_dir
, dir
, sizeof curr_dir
);
1018 if (curr_dir_len
>= sizeof curr_dir
)
1019 curr_dir_len
= sizeof curr_dir
- 1;
1021 curr_dir_depth
= count_dir_elements(curr_dir
+ module_dirlen
);
1024 rprintf(FINFO
, "[%s] pop_dir(%s)\n", who_am_i(), curr_dir
);
1030 * Return a quoted string with the full pathname of the indicated filename.
1031 * The string " (in MODNAME)" may also be appended. The returned pointer
1032 * remains valid until the next time full_fname() is called.
1034 char *full_fname(const char *fn
)
1036 static char *result
= NULL
;
1046 p1
= curr_dir
+ module_dirlen
;
1047 for (p2
= p1
; *p2
== '/'; p2
++) {}
1051 if (module_id
>= 0) {
1053 m2
= lp_name(module_id
);
1058 if (asprintf(&result
, "\"%s%s%s\"%s%s%s", p1
, p2
, fn
, m1
, m2
, m3
) <= 0)
1059 out_of_memory("full_fname");
1064 static char partial_fname
[MAXPATHLEN
];
1066 char *partial_dir_fname(const char *fname
)
1068 char *t
= partial_fname
;
1069 int sz
= sizeof partial_fname
;
1072 if ((fn
= strrchr(fname
, '/')) != NULL
) {
1074 if (*partial_dir
!= '/') {
1075 int len
= fn
- fname
;
1076 strncpy(t
, fname
, len
); /* safe */
1082 if ((int)pathjoin(t
, sz
, partial_dir
, fn
) >= sz
)
1084 if (daemon_filter_list
.head
) {
1085 t
= strrchr(partial_fname
, '/');
1087 if (check_filter(&daemon_filter_list
, partial_fname
, 1) < 0)
1090 if (check_filter(&daemon_filter_list
, partial_fname
, 0) < 0)
1094 return partial_fname
;
1097 /* If no --partial-dir option was specified, we don't need to do anything
1098 * (the partial-dir is essentially '.'), so just return success. */
1099 int handle_partial_dir(const char *fname
, int create
)
1103 if (fname
!= partial_fname
)
1105 if (!create
&& *partial_dir
== '/')
1107 if (!(fn
= strrchr(partial_fname
, '/')))
1111 dir
= partial_fname
;
1114 int statret
= do_lstat(dir
, &st
);
1115 if (statret
== 0 && !S_ISDIR(st
.st_mode
)) {
1116 if (do_unlink(dir
) < 0)
1120 if (statret
< 0 && do_mkdir(dir
, 0700) < 0)
1130 * Determine if a symlink points outside the current directory tree.
1131 * This is considered "unsafe" because e.g. when mirroring somebody
1132 * else's machine it might allow them to establish a symlink to
1133 * /etc/passwd, and then read it through a web server.
1135 * Null symlinks and absolute symlinks are always unsafe.
1137 * Basically here we are concerned with symlinks whose target contains
1138 * "..", because this might cause us to walk back up out of the
1139 * transferred directory. We are not allowed to go back up and
1142 * @param dest Target of the symlink in question.
1144 * @param src Top source directory currently applicable. Basically this
1145 * is the first parameter to rsync in a simple invocation, but it's
1146 * modified by flist.c in slightly complex ways.
1148 * @retval True if unsafe
1149 * @retval False is unsafe
1153 int unsafe_symlink(const char *dest
, const char *src
)
1155 const char *name
, *slash
;
1158 /* all absolute and null symlinks are unsafe */
1159 if (!dest
|| !*dest
|| *dest
== '/')
1162 /* find out what our safety margin is */
1163 for (name
= src
; (slash
= strchr(name
, '/')) != 0; name
= slash
+1) {
1164 if (strncmp(name
, "../", 3) == 0) {
1166 } else if (strncmp(name
, "./", 2) == 0) {
1172 if (strcmp(name
, "..") == 0)
1175 for (name
= dest
; (slash
= strchr(name
, '/')) != 0; name
= slash
+1) {
1176 if (strncmp(name
, "../", 3) == 0) {
1177 /* if at any point we go outside the current directory
1178 then stop - it is unsafe */
1181 } else if (strncmp(name
, "./", 2) == 0) {
1187 if (strcmp(name
, "..") == 0)
1193 /* Return the int64 number as a string. If the --human-readable option was
1194 * specified, we may output the number in K, M, or G units. We can return
1195 * up to 4 buffers at a time. */
1196 char *human_num(int64 num
)
1198 static char bufs
[4][128]; /* more than enough room */
1199 static unsigned int n
;
1202 n
= (n
+ 1) % (sizeof bufs
/ sizeof bufs
[0]);
1204 if (human_readable
) {
1206 int mult
= human_readable
== 1 ? 1000 : 1024;
1208 if (num
> mult
*mult
*mult
) {
1209 dnum
= (double)num
/ (mult
*mult
*mult
);
1211 } else if (num
> mult
*mult
) {
1212 dnum
= (double)num
/ (mult
*mult
);
1214 } else if (num
> mult
) {
1215 dnum
= (double)num
/ mult
;
1219 snprintf(bufs
[n
], sizeof bufs
[0], "%.2f%c", dnum
, units
);
1224 s
= bufs
[n
] + sizeof bufs
[0] - 1;
1230 *--s
= (char)(num
% 10) + '0';
1236 /* Return the double number as a string. If the --human-readable option was
1237 * specified, we may output the number in K, M, or G units. We use a buffer
1238 * from human_num() to return our result. */
1239 char *human_dnum(double dnum
, int decimal_digits
)
1241 char *buf
= human_num(dnum
);
1242 int len
= strlen(buf
);
1243 if (isDigit(buf
+ len
- 1)) {
1244 /* There's extra room in buf prior to the start of the num. */
1245 buf
-= decimal_digits
+ 1;
1246 snprintf(buf
, len
+ decimal_digits
+ 2, "%.*f", decimal_digits
, dnum
);
1251 /* Return the date and time as a string. Some callers tweak returned buf. */
1252 char *timestring(time_t t
)
1254 static char TimeBuf
[200];
1255 struct tm
*tm
= localtime(&t
);
1258 #ifdef HAVE_STRFTIME
1259 strftime(TimeBuf
, sizeof TimeBuf
- 1, "%Y/%m/%d %H:%M:%S", tm
);
1261 strlcpy(TimeBuf
, asctime(tm
), sizeof TimeBuf
);
1264 if ((p
= strchr(TimeBuf
, '\n')) != NULL
)
1271 * Sleep for a specified number of milliseconds.
1273 * Always returns TRUE. (In the future it might return FALSE if
1279 struct timeval tval
, t1
, t2
;
1281 gettimeofday(&t1
, NULL
);
1284 tval
.tv_sec
= (t
-tdiff
)/1000;
1285 tval
.tv_usec
= 1000*((t
-tdiff
)%1000);
1288 select(0,NULL
,NULL
, NULL
, &tval
);
1290 gettimeofday(&t2
, NULL
);
1291 tdiff
= (t2
.tv_sec
- t1
.tv_sec
)*1000 +
1292 (t2
.tv_usec
- t1
.tv_usec
)/1000;
1298 /* Determine if two time_t values are equivalent (either exact, or in
1299 * the modification timestamp window established by --modify-window).
1301 * @retval 0 if the times should be treated as the same
1303 * @retval +1 if the first is later
1305 * @retval -1 if the 2nd is later
1307 int cmp_time(time_t file1
, time_t file2
)
1309 if (file2
> file1
) {
1310 if (file2
- file1
<= modify_window
)
1314 if (file1
- file2
<= modify_window
)
1324 This routine is a trick to immediately catch errors when debugging
1325 with insure. A xterm with a gdb is popped up when insure catches
1326 a error. It is Linux specific.
1328 int _Insure_trap_error(int a1
, int a2
, int a3
, int a4
, int a5
, int a6
)
1334 asprintf(&cmd
, "/usr/X11R6/bin/xterm -display :0 -T Panic -n Panic -e /bin/sh -c 'cat /tmp/ierrs.*.%d ; gdb /proc/%d/exe %d'",
1335 getpid(), getpid(), getpid());
1339 h
= dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY
);
1340 fn
= dlsym(h
, "_Insure_trap_error");
1343 ret
= fn(a1
, a2
, a3
, a4
, a5
, a6
);
1353 #define MALLOC_MAX 0x40000000
1355 void *_new_array(unsigned long num
, unsigned int size
, int use_calloc
)
1357 if (num
>= MALLOC_MAX
/size
)
1359 return use_calloc
? calloc(num
, size
) : malloc(num
* size
);
1362 void *_realloc_array(void *ptr
, unsigned int size
, unsigned long num
)
1364 if (num
>= MALLOC_MAX
/size
)
1367 return malloc(size
* num
);
1368 return realloc(ptr
, size
* num
);
1371 /* Take a filename and filename length and return the most significant
1372 * filename suffix we can find. This ignores suffixes such as "~",
1373 * ".bak", ".orig", ".~1~", etc. */
1374 const char *find_filename_suffix(const char *fn
, int fn_len
, int *len_ptr
)
1376 const char *suf
, *s
;
1380 /* One or more dots at the start aren't a suffix. */
1381 while (fn_len
&& *fn
== '.') fn
++, fn_len
--;
1383 /* Ignore the ~ in a "foo~" filename. */
1384 if (fn_len
> 1 && fn
[fn_len
-1] == '~')
1385 fn_len
--, had_tilde
= True
;
1389 /* Assume we don't find an suffix. */
1393 /* Find the last significant suffix. */
1394 for (s
= fn
+ fn_len
; fn_len
> 1; ) {
1395 while (*--s
!= '.' && s
!= fn
) {}
1398 s_len
= fn_len
- (s
- fn
);
1401 if (strcmp(s
+1, "bak") == 0
1402 || strcmp(s
+1, "old") == 0)
1404 } else if (s_len
== 5) {
1405 if (strcmp(s
+1, "orig") == 0)
1407 } else if (s_len
> 2 && had_tilde
1408 && s
[1] == '~' && isDigit(s
+ 2))
1414 /* Determine if the suffix is all digits. */
1415 for (s
++, s_len
--; s_len
> 0; s
++, s_len
--) {
1419 /* An all-digit suffix may not be that signficant. */
1426 /* This is an implementation of the Levenshtein distance algorithm. It
1427 * was implemented to avoid needing a two-dimensional matrix (to save
1428 * memory). It was also tweaked to try to factor in the ASCII distance
1429 * between changed characters as a minor distance quantity. The normal
1430 * Levenshtein units of distance (each signifying a single change between
1431 * the two strings) are defined as a "UNIT". */
1433 #define UNIT (1 << 16)
1435 uint32
fuzzy_distance(const char *s1
, int len1
, const char *s2
, int len2
)
1437 uint32 a
[MAXPATHLEN
], diag
, above
, left
, diag_inc
, above_inc
, left_inc
;
1441 if (!len1
|| !len2
) {
1446 for (i1
= 0, cost
= 0; i1
< len1
; i1
++)
1448 return (int32
)len1
* UNIT
+ cost
;
1451 for (i2
= 0; i2
< len2
; i2
++)
1452 a
[i2
] = (i2
+1) * UNIT
;
1454 for (i1
= 0; i1
< len1
; i1
++) {
1456 above
= (i1
+1) * UNIT
;
1457 for (i2
= 0; i2
< len2
; i2
++) {
1459 if ((cost
= *((uchar
*)s1
+i1
) - *((uchar
*)s2
+i2
)) != 0) {
1465 diag_inc
= diag
+ cost
;
1466 left_inc
= left
+ UNIT
+ *((uchar
*)s1
+i1
);
1467 above_inc
= above
+ UNIT
+ *((uchar
*)s2
+i2
);
1468 a
[i2
] = above
= left
< above
1469 ? (left_inc
< diag_inc
? left_inc
: diag_inc
)
1470 : (above_inc
< diag_inc
? above_inc
: diag_inc
);
1478 #define BB_SLOT_SIZE (16*1024) /* Desired size in bytes */
1479 #define BB_PER_SLOT_BITS (BB_SLOT_SIZE * 8) /* Number of bits per slot */
1480 #define BB_PER_SLOT_INTS (BB_SLOT_SIZE / 4) /* Number of int32s per slot */
1487 struct bitbag
*bitbag_create(int max_ndx
)
1489 struct bitbag
*bb
= new(struct bitbag
);
1490 bb
->slot_cnt
= (max_ndx
+ BB_PER_SLOT_BITS
- 1) / BB_PER_SLOT_BITS
;
1492 if (!(bb
->bits
= (uint32
**)calloc(bb
->slot_cnt
, sizeof (uint32
*))))
1493 out_of_memory("bitbag_create");
1498 void bitbag_set_bit(struct bitbag
*bb
, int ndx
)
1500 int slot
= ndx
/ BB_PER_SLOT_BITS
;
1501 ndx
%= BB_PER_SLOT_BITS
;
1503 if (!bb
->bits
[slot
]) {
1504 if (!(bb
->bits
[slot
] = (uint32
*)calloc(BB_PER_SLOT_INTS
, 4)))
1505 out_of_memory("bitbag_set_bit");
1508 bb
->bits
[slot
][ndx
/32] |= 1u << (ndx
% 32);
1511 #if 0 /* not needed yet */
1512 void bitbag_clear_bit(struct bitbag
*bb
, int ndx
)
1514 int slot
= ndx
/ BB_PER_SLOT_BITS
;
1515 ndx
%= BB_PER_SLOT_BITS
;
1517 if (!bb
->bits
[slot
])
1520 bb
->bits
[slot
][ndx
/32] &= ~(1u << (ndx
% 32));
1523 int bitbag_check_bit(struct bitbag
*bb
, int ndx
)
1525 int slot
= ndx
/ BB_PER_SLOT_BITS
;
1526 ndx
%= BB_PER_SLOT_BITS
;
1528 if (!bb
->bits
[slot
])
1531 return bb
->bits
[slot
][ndx
/32] & (1u << (ndx
% 32)) ? 1 : 0;
1535 /* Call this with -1 to start checking from 0. Returns -1 at the end. */
1536 int bitbag_next_bit(struct bitbag
*bb
, int after
)
1539 int i
, ndx
= after
+ 1;
1540 int slot
= ndx
/ BB_PER_SLOT_BITS
;
1541 ndx
%= BB_PER_SLOT_BITS
;
1543 mask
= (1u << (ndx
% 32)) - 1;
1544 for (i
= ndx
/ 32; slot
< bb
->slot_cnt
; slot
++, i
= mask
= 0) {
1545 if (!bb
->bits
[slot
])
1547 for ( ; i
< BB_PER_SLOT_INTS
; i
++, mask
= 0) {
1548 if (!(bits
= bb
->bits
[slot
][i
] & ~mask
))
1550 /* The xor magic figures out the lowest enabled bit in
1551 * bits, and the switch quickly computes log2(bit). */
1552 switch (bits
^ (bits
& (bits
-1))) {
1553 #define LOG2(n) case 1u << n: return slot*BB_PER_SLOT_BITS + i*32 + n
1554 LOG2(0); LOG2(1); LOG2(2); LOG2(3);
1555 LOG2(4); LOG2(5); LOG2(6); LOG2(7);
1556 LOG2(8); LOG2(9); LOG2(10); LOG2(11);
1557 LOG2(12); LOG2(13); LOG2(14); LOG2(15);
1558 LOG2(16); LOG2(17); LOG2(18); LOG2(19);
1559 LOG2(20); LOG2(21); LOG2(22); LOG2(23);
1560 LOG2(24); LOG2(25); LOG2(26); LOG2(27);
1561 LOG2(28); LOG2(29); LOG2(30); LOG2(31);
1563 return -1; /* impossible... */
1570 void *expand_item_list(item_list
*lp
, size_t item_size
,
1571 const char *desc
, int incr
)
1573 /* First time through, 0 <= 0, so list is expanded. */
1574 if (lp
->malloced
<= lp
->count
) {
1576 size_t new_size
= lp
->malloced
;
1578 new_size
+= -incr
; /* increase slowly */
1579 else if (new_size
< (size_t)incr
)
1583 new_ptr
= realloc_array(lp
->items
, char, new_size
* item_size
);
1585 rprintf(FINFO
, "[%s] expand %s to %.0f bytes, did%s move\n",
1586 who_am_i(), desc
, (double)new_size
* item_size
,
1587 new_ptr
== lp
->items
? " not" : "");
1590 out_of_memory("expand_item_list");
1592 lp
->items
= new_ptr
;
1593 lp
->malloced
= new_size
;
1595 return (char*)lp
->items
+ (lp
->count
++ * item_size
);