1 /* -*- c-file-style: "linux" -*-
3 Copyright (C) 1996-2000 by Andrew Tridgell
4 Copyright (C) Paul Mackerras 1996
5 Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 Utilities used in rsync
32 /****************************************************************************
33 Set a fd into nonblocking mode
34 ****************************************************************************/
35 void set_nonblocking(int fd)
39 if((val = fcntl(fd, F_GETFL, 0)) == -1)
41 if (!(val & NONBLOCK_FLAG)) {
43 fcntl(fd, F_SETFL, val);
47 /****************************************************************************
48 Set a fd into blocking mode
49 ****************************************************************************/
50 void set_blocking(int fd)
54 if((val = fcntl(fd, F_GETFL, 0)) == -1)
56 if (val & NONBLOCK_FLAG) {
57 val &= ~NONBLOCK_FLAG;
58 fcntl(fd, F_SETFL, val);
63 /* create a file descriptor pair - like pipe() but use socketpair if
64 possible (because of blocking issues on pipes)
66 always set non-blocking
68 int fd_pair(int fd[2])
73 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
79 set_nonblocking(fd[0]);
80 set_nonblocking(fd[1]);
87 static void print_child_argv(char **cmd)
89 rprintf(FINFO, "opening connection using ");
91 /* Look for characters that ought to be quoted. This
92 * is not a great quoting algorithm, but it's
93 * sufficient for a log message. */
94 if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
95 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
97 ",.-_=+@/") != strlen(*cmd)) {
98 rprintf(FINFO, "\"%s\" ", *cmd);
100 rprintf(FINFO, "%s ", *cmd);
103 rprintf(FINFO, "\n");
107 /* this is derived from CVS code
109 note that in the child STDIN is set to blocking and STDOUT
110 is set to non-blocking. This is necessary as rsh relies on stdin being blocking
111 and ssh relies on stdout being non-blocking
113 if blocking_io is set then use blocking io on both fds. That can be
114 used to cope with badly broken rsh implementations like the one on
117 pid_t piped_child(char **command, int *f_in, int *f_out)
120 int to_child_pipe[2];
121 int from_child_pipe[2];
122 extern int blocking_io;
125 print_child_argv(command);
128 if (fd_pair(to_child_pipe) < 0 || fd_pair(from_child_pipe) < 0) {
129 rprintf(FERROR, "pipe: %s\n", strerror(errno));
130 exit_cleanup(RERR_IPC);
136 rprintf(FERROR, "fork: %s\n", strerror(errno));
137 exit_cleanup(RERR_IPC);
141 extern int orig_umask;
142 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
143 close(to_child_pipe[1]) < 0 ||
144 close(from_child_pipe[0]) < 0 ||
145 dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
146 rprintf(FERROR, "Failed to dup/close : %s\n",
148 exit_cleanup(RERR_IPC);
150 if (to_child_pipe[0] != STDIN_FILENO)
151 close(to_child_pipe[0]);
152 if (from_child_pipe[1] != STDOUT_FILENO)
153 close(from_child_pipe[1]);
155 set_blocking(STDIN_FILENO);
157 set_blocking(STDOUT_FILENO);
159 execvp(command[0], command);
160 rprintf(FERROR, "Failed to exec %s : %s\n",
161 command[0], strerror(errno));
162 exit_cleanup(RERR_IPC);
165 if (close(from_child_pipe[1]) < 0 || close(to_child_pipe[0]) < 0) {
166 rprintf(FERROR, "Failed to close : %s\n", strerror(errno));
167 exit_cleanup(RERR_IPC);
170 *f_in = from_child_pipe[0];
171 *f_out = to_child_pipe[1];
176 pid_t local_child(int argc, char **argv,int *f_in,int *f_out)
179 int to_child_pipe[2];
180 int from_child_pipe[2];
181 extern int read_batch; /* dw */
183 if (fd_pair(to_child_pipe) < 0 ||
184 fd_pair(from_child_pipe) < 0) {
185 rprintf(FERROR,"pipe: %s\n",strerror(errno));
186 exit_cleanup(RERR_IPC);
192 rprintf(FERROR,"fork: %s\n",strerror(errno));
193 exit_cleanup(RERR_IPC);
197 extern int am_sender;
198 extern int am_server;
200 am_sender = read_batch ? 0 : !am_sender;
203 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
204 close(to_child_pipe[1]) < 0 ||
205 close(from_child_pipe[0]) < 0 ||
206 dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
207 rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
208 exit_cleanup(RERR_IPC);
210 if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
211 if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
212 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
215 if (close(from_child_pipe[1]) < 0 ||
216 close(to_child_pipe[0]) < 0) {
217 rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
218 exit_cleanup(RERR_IPC);
221 *f_in = from_child_pipe[0];
222 *f_out = to_child_pipe[1];
229 void out_of_memory(char *str)
231 rprintf(FERROR,"ERROR: out of memory in %s\n",str);
232 exit_cleanup(RERR_MALLOC);
235 void overflow(char *str)
237 rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
238 exit_cleanup(RERR_MALLOC);
243 int set_modtime(char *fname, time_t modtime)
250 rprintf(FINFO, "set modtime of %s to (%ld) %s",
251 fname, (long) modtime,
252 asctime(localtime(&modtime)));
258 tbuf.actime = time(NULL);
259 tbuf.modtime = modtime;
260 return utime(fname,&tbuf);
261 #elif defined(HAVE_UTIME)
265 return utime(fname,t);
268 t[0].tv_sec = time(NULL);
270 t[1].tv_sec = modtime;
272 return utimes(fname,t);
278 /****************************************************************************
279 create any necessary directories in fname. Unfortunately we don't know
280 what perms to give the directory when this is called so we need to rely
282 ****************************************************************************/
283 int create_directory_path(char *fname)
285 extern int orig_umask;
288 while (*fname == '/') fname++;
289 while (strncmp(fname,"./",2)==0) fname += 2;
292 while ((p=strchr(p,'/'))) {
294 do_mkdir(fname,0777 & ~orig_umask);
302 /* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
303 Return LEN upon success, write's (negative) error code otherwise.
305 derived from GNU C's cccp.c.
307 static int full_write(int desc, char *ptr, size_t len)
313 int written = write (desc, ptr, len);
321 total_written += written;
325 return total_written;
328 /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
329 Return the actual number of bytes read, zero for EOF, or negative
332 derived from GNU C's cccp.c. */
333 static int safe_read(int desc, char *ptr, size_t len)
342 n_chars = read(desc, ptr, len);
343 } while (n_chars < 0 && errno == EINTR);
345 n_chars = read(desc, ptr, len);
352 /* copy a file - this is used in conjunction with the --temp-dir option */
353 int copy_file(char *source, char *dest, mode_t mode)
358 int len; /* Number of bytes read into `buf'. */
360 ifd = do_open(source, O_RDONLY, 0);
362 rprintf(FERROR,"open %s: %s\n",
363 source,strerror(errno));
367 if (robust_unlink(dest) && errno != ENOENT) {
368 rprintf(FERROR,"unlink %s: %s\n",
369 dest,strerror(errno));
373 ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
375 rprintf(FERROR,"open %s: %s\n",
376 dest,strerror(errno));
381 while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
382 if (full_write(ofd, buf, len) < 0) {
383 rprintf(FERROR,"write %s: %s\n",
384 dest,strerror(errno));
395 rprintf(FERROR,"read %s: %s\n",
396 source,strerror(errno));
404 Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
405 rename to <path>/.rsyncNNN instead. Note that successive rsync runs
406 will shuffle the filenames around a bit as long as the file is still
407 busy; this is because this function does not know if the unlink call
408 is due to a new file coming in, or --delete trying to remove old
409 .rsyncNNN files, hence it renames it each time.
411 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
412 #define MAX_RENAMES_DIGITS 3
413 #define MAX_RENAMES 1000
415 int robust_unlink(char *fname)
418 return do_unlink(fname);
420 static int counter = 1;
422 char path[MAXPATHLEN];
424 rc = do_unlink(fname);
425 if ((rc == 0) || (errno != ETXTBSY))
428 strlcpy(path, fname, MAXPATHLEN);
431 while((path[--pos] != '/') && (pos >= 0))
434 strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
435 pos += sizeof(".rsync")-1;
437 if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
442 /* start where the last one left off to reduce chance of clashes */
445 sprintf(&path[pos], "%03d", counter);
446 if (++counter >= MAX_RENAMES)
448 } while (((rc = access(path, 0)) == 0) && (counter != start));
451 rprintf(FINFO,"renaming %s to %s because of text busy\n",
454 /* maybe we should return rename()'s exit status? Nah. */
455 if (do_rename(fname, path) != 0) {
463 int robust_rename(char *from, char *to)
466 return do_rename(from, to);
468 int rc = do_rename(from, to);
469 if ((rc == 0) || (errno != ETXTBSY))
471 if (robust_unlink(to) != 0)
473 return do_rename(from, to);
478 static pid_t all_pids[10];
481 /* fork and record the pid of the child */
484 pid_t newpid = fork();
487 all_pids[num_pids++] = newpid;
492 /* kill all children */
493 void kill_all(int sig)
496 for (i=0;i<num_pids;i++) {
497 if (all_pids[i] != getpid())
498 kill(all_pids[i], sig);
502 /* turn a user name into a uid */
503 int name_to_uid(char *name, uid_t *uid)
506 if (!name || !*name) return 0;
507 pass = getpwnam(name);
515 /* turn a group name into a gid */
516 int name_to_gid(char *name, gid_t *gid)
519 if (!name || !*name) return 0;
520 grp = getgrnam(name);
529 /* lock a byte range in a open file */
530 int lock_range(int fd, int offset, int len)
534 lock.l_type = F_WRLCK;
535 lock.l_whence = SEEK_SET;
536 lock.l_start = offset;
540 return fcntl(fd,F_SETLK,&lock) == 0;
544 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
546 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
548 argv[*argc] = strdup(s);
552 extern int sanitize_paths;
558 argv[*argc] = strdup(s);
559 if (sanitize_paths) {
560 sanitize_path(argv[*argc], NULL);
563 memset(&globbuf, 0, sizeof(globbuf));
564 glob(argv[*argc], 0, NULL, &globbuf);
565 if (globbuf.gl_pathc == 0) {
570 for (i=0; i<(maxargs - (*argc)) && i < (int) globbuf.gl_pathc;i++) {
571 if (i == 0) free(argv[*argc]);
572 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
573 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
580 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
582 char *s = argv[*argc];
586 if (!s || !*s) return;
588 if (strncmp(s, base, strlen(base)) == 0) {
593 if (!s) out_of_memory("glob_expand");
595 if (asprintf(&base," %s/", base1) <= 0) out_of_memory("glob_expand");
598 while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
599 /* split it at this point */
601 glob_expand_one(q, argv, argc, maxargs);
605 if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
611 /*******************************************************************
612 convert a string to lower case
613 ********************************************************************/
614 void strlower(char *s)
617 if (isupper(*s)) *s = tolower(*s);
622 void *Realloc(void *p, int size)
624 if (!p) return (void *)malloc(size);
625 return (void *)realloc(p, size);
629 void clean_fname(char *name)
640 if ((p=strstr(name,"/./"))) {
648 if ((p=strstr(name,"//"))) {
656 if (strncmp(p=name,"./",2) == 0) {
664 if (l > 1 && p[l-1] == '/') {
672 * Make path appear as if a chroot had occurred:
673 * 1. remove leading "/" (or replace with "." if at end)
674 * 2. remove leading ".." components (except those allowed by "reldir")
675 * 3. delete any other "<dir>/.." (recursively)
676 * Can only shrink paths, so sanitizes in place.
677 * While we're at it, remove double slashes and "." components like
678 * clean_fname does(), but DON'T remove a trailing slash because that
679 * is sometimes significant on command line arguments.
680 * If "reldir" is non-null, it is a sanitized directory that the path will be
681 * relative to, so allow as many ".." at the beginning of the path as
682 * there are components in reldir. This is used for symbolic link targets.
683 * If reldir is non-null and the path began with "/", to be completely like
684 * a chroot we should add in depth levels of ".." at the beginning of the
685 * path, but that would blow the assumption that the path doesn't grow and
686 * it is not likely to end up being a valid symlink anyway, so just do
687 * the normal removal of the leading "/" instead.
688 * Contributed by Dave Dykstra <dwd@bell-labs.com>
691 void sanitize_path(char *p, char *reldir)
700 if (*reldir++ == '/') {
708 /* remove leading slashes */
712 /* this loop iterates once per filename component in p.
713 * both p (and sanp if the original had a slash) should
714 * always be left pointing after a slash
716 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
717 /* skip "." component */
718 while (*++p == '/') {
719 /* skip following slashes */
725 if ((*p == '.') && (*(p+1) == '.') &&
726 ((*(p+2) == '/') || (*(p+2) == '\0'))) {
727 /* ".." component followed by slash or end */
728 if ((depth > 0) && (sanp == start)) {
729 /* allow depth levels of .. at the beginning */
737 /* back up sanp one level */
738 --sanp; /* now pointing at slash */
739 while ((sanp > start) && (*(sanp - 1) != '/')) {
740 /* skip back up to slash */
748 /* copy one component through next slash */
750 if ((*p == '\0') || (*(p-1) == '/')) {
752 /* skip multiple slashes */
759 /* move the virtual beginning to leave the .. alone */
763 if ((sanp == start) && !allowdotdot) {
764 /* ended up with nothing, so put in "." component */
766 * note that the !allowdotdot doesn't prevent this from
767 * happening in all allowed ".." situations, but I didn't
768 * think it was worth putting in an extra variable to ensure
769 * it since an extra "." won't hurt in those situations.
777 static char curr_dir[MAXPATHLEN];
779 /* like chdir() but can be reversed with pop_dir() if save is set. It
780 is also much faster as it remembers where we have been */
781 char *push_dir(char *dir, int save)
783 char *ret = curr_dir;
784 static int initialised;
788 getcwd(curr_dir, sizeof(curr_dir)-1);
791 if (!dir) return NULL; /* this call was probably just to initialize */
793 if (chdir(dir)) return NULL;
796 ret = strdup(curr_dir);
800 strlcpy(curr_dir, dir, sizeof(curr_dir));
802 strlcat(curr_dir,"/", sizeof(curr_dir));
803 strlcat(curr_dir,dir, sizeof(curr_dir));
806 clean_fname(curr_dir);
811 /* reverse a push_dir call */
812 int pop_dir(char *dir)
822 strlcpy(curr_dir, dir, sizeof(curr_dir));
829 /* we need to supply our own strcmp function for file list comparisons
830 to ensure that signed/unsigned usage is consistent between machines. */
831 int u_strcmp(const char *cs1, const char *cs2)
833 const uchar *s1 = (const uchar *)cs1;
834 const uchar *s2 = (const uchar *)cs2;
836 while (*s1 && *s2 && (*s1 == *s2)) {
840 return (int)*s1 - (int)*s2;
843 static OFF_T last_ofs;
844 static struct timeval print_time;
845 static struct timeval start_time;
846 static OFF_T start_ofs;
848 static unsigned long msdiff(struct timeval *t1, struct timeval *t2)
850 return (t2->tv_sec - t1->tv_sec) * 1000
851 + (t2->tv_usec - t1->tv_usec) / 1000;
856 * @param ofs Current position in file
857 * @param size Total size of file
858 * @param is_last True if this is the last time progress will be
859 * printed for this file, so we should output a newline. (Not
860 * necessarily the same as all bytes being received.)
862 static void rprint_progress(OFF_T ofs, OFF_T size, struct timeval *now,
865 int pct = (ofs == size) ? 100 : (int)((100.0*ofs)/size);
866 unsigned long diff = msdiff(&start_time, now);
867 double rate = diff ? (double) (ofs-start_ofs) * 1000.0 / diff / 1024.0 : 0;
869 /* If we've finished transferring this file, show the time taken;
870 * otherwise show expected time to complete. That's kind of
871 * inconsistent, but people can probably cope. Hopefully we'll
872 * get more consistent and complete progress reporting soon. --
874 double remain = is_last
875 ? (double) diff / 1000.0
876 : rate ? (double) (size-ofs) / rate / 1000.0 : 0.0;
877 int remain_h, remain_m, remain_s;
879 if (rate > 1024*1024) {
880 rate /= 1024.0 * 1024.0;
882 } else if (rate > 1024) {
889 remain_s = (int) remain % 60;
890 remain_m = (int) (remain / 60.0) % 60;
891 remain_h = (int) (remain / 3600.0);
893 rprintf(FINFO, "%12.0f %3d%% %7.2f%s %4d:%02d:%02d%s",
894 (double) ofs, pct, rate, units,
895 remain_h, remain_m, remain_s,
896 is_last ? "\n" : "\r");
899 void end_progress(OFF_T size)
901 extern int do_progress, am_server;
903 if (do_progress && !am_server) {
905 gettimeofday(&now, NULL);
906 rprint_progress(size, size, &now, True);
910 print_time.tv_sec = print_time.tv_usec = 0;
911 start_time.tv_sec = start_time.tv_usec = 0;
914 void show_progress(OFF_T ofs, OFF_T size)
916 extern int do_progress, am_server;
919 gettimeofday(&now, NULL);
921 if (!start_time.tv_sec && !start_time.tv_usec) {
922 start_time.tv_sec = now.tv_sec;
923 start_time.tv_usec = now.tv_usec;
929 && ofs > last_ofs + 1000
930 && msdiff(&print_time, &now) > 250) {
931 rprint_progress(ofs, size, &now, False);
933 print_time.tv_sec = now.tv_sec;
934 print_time.tv_usec = now.tv_usec;
938 /* determine if a symlink points outside the current directory tree */
939 int unsafe_symlink(char *dest, char *src)
944 /* all absolute and null symlinks are unsafe */
945 if (!dest || !(*dest) || (*dest == '/')) return 1;
948 if (!src) out_of_memory("unsafe_symlink");
950 /* find out what our safety margin is */
951 for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
952 if (strcmp(tok,"..") == 0) {
954 } else if (strcmp(tok,".") == 0) {
962 /* drop by one to account for the filename portion */
966 if (!dest) out_of_memory("unsafe_symlink");
968 for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
969 if (strcmp(tok,"..") == 0) {
971 } else if (strcmp(tok,".") == 0) {
976 /* if at any point we go outside the current directory then
977 stop - it is unsafe */
978 if (depth < 0) break;
986 /****************************************************************************
987 return the date and time as a string
988 ****************************************************************************/
989 char *timestring(time_t t)
991 static char TimeBuf[200];
992 struct tm *tm = localtime(&t);
995 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
997 strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
1000 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1001 TimeBuf[strlen(TimeBuf)-1] = 0;
1009 * Sleep for a specified number of milliseconds.
1011 * Always returns TRUE. (In the future it might return FALSE if
1017 struct timeval tval,t1,t2;
1019 gettimeofday(&t1, NULL);
1020 gettimeofday(&t2, NULL);
1023 tval.tv_sec = (t-tdiff)/1000;
1024 tval.tv_usec = 1000*((t-tdiff)%1000);
1027 select(0,NULL,NULL, NULL, &tval);
1029 gettimeofday(&t2, NULL);
1030 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1031 (t2.tv_usec - t1.tv_usec)/1000;
1038 /*******************************************************************
1039 Determine if two file modification times are equivalent (either exact
1040 or in the modification timestamp window established by --modify-window)
1041 Returns 0 if the times should be treated as the same, 1 if the
1042 first is later and -1 if the 2nd is later
1043 *******************************************************************/
1044 int cmp_modtime(time_t file1, time_t file2)
1046 extern int modify_window;
1048 if (file2 > file1) {
1049 if (file2 - file1 <= modify_window) return 0;
1052 if (file1 - file2 <= modify_window) return 0;
1060 /*******************************************************************
1061 This routine is a trick to immediately catch errors when debugging
1062 with insure. A xterm with a gdb is popped up when insure catches
1063 a error. It is Linux specific.
1064 ********************************************************************/
1065 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1071 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'",
1072 getpid(), getpid(), getpid());
1076 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1077 fn = dlsym(h, "_Insure_trap_error");
1080 ret = fn(a1, a2, a3, a4, a5, a6);