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();
486 if (newpid != 0 && newpid != -1) {
487 all_pids[num_pids++] = newpid;
495 * @todo It would be kind of nice to make sure that they are actually
496 * all our children before we kill them, because their pids may have
497 * been recycled by some other process. Perhaps when we wait for a
498 * child, we should remove it from this array. Alternatively we could
499 * perhaps use process groups, but I think that would not work on
500 * ancient Unix versions that don't support them.
502 void kill_all(int sig)
506 for (i = 0; i < num_pids; i++) {
507 /* Let's just be a little careful where we
508 * point that gun, hey? See kill(2) for the
509 * magic caused by negative values. */
510 pid_t p = all_pids[i];
522 /* turn a user name into a uid */
523 int name_to_uid(char *name, uid_t *uid)
526 if (!name || !*name) return 0;
527 pass = getpwnam(name);
535 /* turn a group name into a gid */
536 int name_to_gid(char *name, gid_t *gid)
539 if (!name || !*name) return 0;
540 grp = getgrnam(name);
549 /* lock a byte range in a open file */
550 int lock_range(int fd, int offset, int len)
554 lock.l_type = F_WRLCK;
555 lock.l_whence = SEEK_SET;
556 lock.l_start = offset;
560 return fcntl(fd,F_SETLK,&lock) == 0;
564 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
566 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
568 argv[*argc] = strdup(s);
572 extern int sanitize_paths;
578 argv[*argc] = strdup(s);
579 if (sanitize_paths) {
580 sanitize_path(argv[*argc], NULL);
583 memset(&globbuf, 0, sizeof(globbuf));
584 glob(argv[*argc], 0, NULL, &globbuf);
585 if (globbuf.gl_pathc == 0) {
590 for (i=0; i<(maxargs - (*argc)) && i < (int) globbuf.gl_pathc;i++) {
591 if (i == 0) free(argv[*argc]);
592 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
593 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
600 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
602 char *s = argv[*argc];
606 if (!s || !*s) return;
608 if (strncmp(s, base, strlen(base)) == 0) {
613 if (!s) out_of_memory("glob_expand");
615 if (asprintf(&base," %s/", base1) <= 0) out_of_memory("glob_expand");
618 while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
619 /* split it at this point */
621 glob_expand_one(q, argv, argc, maxargs);
625 if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
631 /*******************************************************************
632 convert a string to lower case
633 ********************************************************************/
634 void strlower(char *s)
637 if (isupper(*s)) *s = tolower(*s);
642 void *Realloc(void *p, int size)
644 if (!p) return (void *)malloc(size);
645 return (void *)realloc(p, size);
649 void clean_fname(char *name)
660 if ((p=strstr(name,"/./"))) {
668 if ((p=strstr(name,"//"))) {
676 if (strncmp(p=name,"./",2) == 0) {
684 if (l > 1 && p[l-1] == '/') {
692 * Make path appear as if a chroot had occurred:
693 * 1. remove leading "/" (or replace with "." if at end)
694 * 2. remove leading ".." components (except those allowed by "reldir")
695 * 3. delete any other "<dir>/.." (recursively)
696 * Can only shrink paths, so sanitizes in place.
697 * While we're at it, remove double slashes and "." components like
698 * clean_fname does(), but DON'T remove a trailing slash because that
699 * is sometimes significant on command line arguments.
700 * If "reldir" is non-null, it is a sanitized directory that the path will be
701 * relative to, so allow as many ".." at the beginning of the path as
702 * there are components in reldir. This is used for symbolic link targets.
703 * If reldir is non-null and the path began with "/", to be completely like
704 * a chroot we should add in depth levels of ".." at the beginning of the
705 * path, but that would blow the assumption that the path doesn't grow and
706 * it is not likely to end up being a valid symlink anyway, so just do
707 * the normal removal of the leading "/" instead.
708 * Contributed by Dave Dykstra <dwd@bell-labs.com>
711 void sanitize_path(char *p, char *reldir)
720 if (*reldir++ == '/') {
728 /* remove leading slashes */
732 /* this loop iterates once per filename component in p.
733 * both p (and sanp if the original had a slash) should
734 * always be left pointing after a slash
736 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
737 /* skip "." component */
738 while (*++p == '/') {
739 /* skip following slashes */
745 if ((*p == '.') && (*(p+1) == '.') &&
746 ((*(p+2) == '/') || (*(p+2) == '\0'))) {
747 /* ".." component followed by slash or end */
748 if ((depth > 0) && (sanp == start)) {
749 /* allow depth levels of .. at the beginning */
757 /* back up sanp one level */
758 --sanp; /* now pointing at slash */
759 while ((sanp > start) && (*(sanp - 1) != '/')) {
760 /* skip back up to slash */
768 /* copy one component through next slash */
770 if ((*p == '\0') || (*(p-1) == '/')) {
772 /* skip multiple slashes */
779 /* move the virtual beginning to leave the .. alone */
783 if ((sanp == start) && !allowdotdot) {
784 /* ended up with nothing, so put in "." component */
786 * note that the !allowdotdot doesn't prevent this from
787 * happening in all allowed ".." situations, but I didn't
788 * think it was worth putting in an extra variable to ensure
789 * it since an extra "." won't hurt in those situations.
797 static char curr_dir[MAXPATHLEN];
799 /* like chdir() but can be reversed with pop_dir() if save is set. It
800 is also much faster as it remembers where we have been */
801 char *push_dir(char *dir, int save)
803 char *ret = curr_dir;
804 static int initialised;
808 getcwd(curr_dir, sizeof(curr_dir)-1);
811 if (!dir) return NULL; /* this call was probably just to initialize */
813 if (chdir(dir)) return NULL;
816 ret = strdup(curr_dir);
820 strlcpy(curr_dir, dir, sizeof(curr_dir));
822 strlcat(curr_dir,"/", sizeof(curr_dir));
823 strlcat(curr_dir,dir, sizeof(curr_dir));
826 clean_fname(curr_dir);
831 /* reverse a push_dir call */
832 int pop_dir(char *dir)
842 strlcpy(curr_dir, dir, sizeof(curr_dir));
849 /* we need to supply our own strcmp function for file list comparisons
850 to ensure that signed/unsigned usage is consistent between machines. */
851 int u_strcmp(const char *cs1, const char *cs2)
853 const uchar *s1 = (const uchar *)cs1;
854 const uchar *s2 = (const uchar *)cs2;
856 while (*s1 && *s2 && (*s1 == *s2)) {
860 return (int)*s1 - (int)*s2;
863 static OFF_T last_ofs;
864 static struct timeval print_time;
865 static struct timeval start_time;
866 static OFF_T start_ofs;
868 static unsigned long msdiff(struct timeval *t1, struct timeval *t2)
870 return (t2->tv_sec - t1->tv_sec) * 1000
871 + (t2->tv_usec - t1->tv_usec) / 1000;
876 * @param ofs Current position in file
877 * @param size Total size of file
878 * @param is_last True if this is the last time progress will be
879 * printed for this file, so we should output a newline. (Not
880 * necessarily the same as all bytes being received.)
882 static void rprint_progress(OFF_T ofs, OFF_T size, struct timeval *now,
885 int pct = (ofs == size) ? 100 : (int)((100.0*ofs)/size);
886 unsigned long diff = msdiff(&start_time, now);
887 double rate = diff ? (double) (ofs-start_ofs) * 1000.0 / diff / 1024.0 : 0;
889 /* If we've finished transferring this file, show the time taken;
890 * otherwise show expected time to complete. That's kind of
891 * inconsistent, but people can probably cope. Hopefully we'll
892 * get more consistent and complete progress reporting soon. --
894 double remain = is_last
895 ? (double) diff / 1000.0
896 : rate ? (double) (size-ofs) / rate / 1000.0 : 0.0;
897 int remain_h, remain_m, remain_s;
899 if (rate > 1024*1024) {
900 rate /= 1024.0 * 1024.0;
902 } else if (rate > 1024) {
909 remain_s = (int) remain % 60;
910 remain_m = (int) (remain / 60.0) % 60;
911 remain_h = (int) (remain / 3600.0);
913 rprintf(FINFO, "%12.0f %3d%% %7.2f%s %4d:%02d:%02d%s",
914 (double) ofs, pct, rate, units,
915 remain_h, remain_m, remain_s,
916 is_last ? "\n" : "\r");
919 void end_progress(OFF_T size)
921 extern int do_progress, am_server;
923 if (do_progress && !am_server) {
925 gettimeofday(&now, NULL);
926 rprint_progress(size, size, &now, True);
930 print_time.tv_sec = print_time.tv_usec = 0;
931 start_time.tv_sec = start_time.tv_usec = 0;
934 void show_progress(OFF_T ofs, OFF_T size)
936 extern int do_progress, am_server;
939 gettimeofday(&now, NULL);
941 if (!start_time.tv_sec && !start_time.tv_usec) {
942 start_time.tv_sec = now.tv_sec;
943 start_time.tv_usec = now.tv_usec;
949 && ofs > last_ofs + 1000
950 && msdiff(&print_time, &now) > 250) {
951 rprint_progress(ofs, size, &now, False);
953 print_time.tv_sec = now.tv_sec;
954 print_time.tv_usec = now.tv_usec;
958 /* determine if a symlink points outside the current directory tree */
959 int unsafe_symlink(char *dest, char *src)
964 /* all absolute and null symlinks are unsafe */
965 if (!dest || !(*dest) || (*dest == '/')) return 1;
968 if (!src) out_of_memory("unsafe_symlink");
970 /* find out what our safety margin is */
971 for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
972 if (strcmp(tok,"..") == 0) {
974 } else if (strcmp(tok,".") == 0) {
982 /* drop by one to account for the filename portion */
986 if (!dest) out_of_memory("unsafe_symlink");
988 for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
989 if (strcmp(tok,"..") == 0) {
991 } else if (strcmp(tok,".") == 0) {
996 /* if at any point we go outside the current directory then
997 stop - it is unsafe */
998 if (depth < 0) break;
1006 /****************************************************************************
1007 return the date and time as a string
1008 ****************************************************************************/
1009 char *timestring(time_t t)
1011 static char TimeBuf[200];
1012 struct tm *tm = localtime(&t);
1014 #ifdef HAVE_STRFTIME
1015 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
1017 strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
1020 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1021 TimeBuf[strlen(TimeBuf)-1] = 0;
1029 * Sleep for a specified number of milliseconds.
1031 * Always returns TRUE. (In the future it might return FALSE if
1037 struct timeval tval,t1,t2;
1039 gettimeofday(&t1, NULL);
1040 gettimeofday(&t2, NULL);
1043 tval.tv_sec = (t-tdiff)/1000;
1044 tval.tv_usec = 1000*((t-tdiff)%1000);
1047 select(0,NULL,NULL, NULL, &tval);
1049 gettimeofday(&t2, NULL);
1050 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1051 (t2.tv_usec - t1.tv_usec)/1000;
1058 /*******************************************************************
1059 Determine if two file modification times are equivalent (either exact
1060 or in the modification timestamp window established by --modify-window)
1061 Returns 0 if the times should be treated as the same, 1 if the
1062 first is later and -1 if the 2nd is later
1063 *******************************************************************/
1064 int cmp_modtime(time_t file1, time_t file2)
1066 extern int modify_window;
1068 if (file2 > file1) {
1069 if (file2 - file1 <= modify_window) return 0;
1072 if (file1 - file2 <= modify_window) return 0;
1080 /*******************************************************************
1081 This routine is a trick to immediately catch errors when debugging
1082 with insure. A xterm with a gdb is popped up when insure catches
1083 a error. It is Linux specific.
1084 ********************************************************************/
1085 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1091 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'",
1092 getpid(), getpid(), getpid());
1096 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1097 fn = dlsym(h, "_Insure_trap_error");
1100 ret = fn(a1, a2, a3, a4, a5, a6);