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 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)
246 if (dry_run) return 0;
250 tbuf.actime = time(NULL);
251 tbuf.modtime = modtime;
252 return utime(fname,&tbuf);
253 #elif defined(HAVE_UTIME)
257 return utime(fname,t);
260 t[0].tv_sec = time(NULL);
262 t[1].tv_sec = modtime;
264 return utimes(fname,t);
270 /****************************************************************************
271 create any necessary directories in fname. Unfortunately we don't know
272 what perms to give the directory when this is called so we need to rely
274 ****************************************************************************/
275 int create_directory_path(char *fname)
277 extern int orig_umask;
280 while (*fname == '/') fname++;
281 while (strncmp(fname,"./",2)==0) fname += 2;
284 while ((p=strchr(p,'/'))) {
286 do_mkdir(fname,0777 & ~orig_umask);
294 /* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
295 Return LEN upon success, write's (negative) error code otherwise.
297 derived from GNU C's cccp.c.
299 static int full_write(int desc, char *ptr, size_t len)
305 int written = write (desc, ptr, len);
313 total_written += written;
317 return total_written;
320 /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
321 Return the actual number of bytes read, zero for EOF, or negative
324 derived from GNU C's cccp.c. */
325 static int safe_read(int desc, char *ptr, size_t len)
334 n_chars = read(desc, ptr, len);
335 } while (n_chars < 0 && errno == EINTR);
337 n_chars = read(desc, ptr, len);
344 /* copy a file - this is used in conjunction with the --temp-dir option */
345 int copy_file(char *source, char *dest, mode_t mode)
350 int len; /* Number of bytes read into `buf'. */
352 ifd = do_open(source, O_RDONLY, 0);
354 rprintf(FERROR,"open %s: %s\n",
355 source,strerror(errno));
359 if (robust_unlink(dest) && errno != ENOENT) {
360 rprintf(FERROR,"unlink %s: %s\n",
361 dest,strerror(errno));
365 ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
367 rprintf(FERROR,"open %s: %s\n",
368 dest,strerror(errno));
373 while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
374 if (full_write(ofd, buf, len) < 0) {
375 rprintf(FERROR,"write %s: %s\n",
376 dest,strerror(errno));
387 rprintf(FERROR,"read %s: %s\n",
388 source,strerror(errno));
396 Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
397 rename to <path>/.rsyncNNN instead. Note that successive rsync runs
398 will shuffle the filenames around a bit as long as the file is still
399 busy; this is because this function does not know if the unlink call
400 is due to a new file coming in, or --delete trying to remove old
401 .rsyncNNN files, hence it renames it each time.
403 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
404 #define MAX_RENAMES_DIGITS 3
405 #define MAX_RENAMES 1000
407 int robust_unlink(char *fname)
410 return do_unlink(fname);
412 static int counter = 1;
414 char path[MAXPATHLEN];
416 rc = do_unlink(fname);
417 if ((rc == 0) || (errno != ETXTBSY))
420 strlcpy(path, fname, MAXPATHLEN);
423 while((path[--pos] != '/') && (pos >= 0))
426 strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
427 pos += sizeof(".rsync")-1;
429 if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
434 /* start where the last one left off to reduce chance of clashes */
437 sprintf(&path[pos], "%03d", counter);
438 if (++counter >= MAX_RENAMES)
440 } while (((rc = access(path, 0)) == 0) && (counter != start));
443 rprintf(FINFO,"renaming %s to %s because of text busy\n",
446 /* maybe we should return rename()'s exit status? Nah. */
447 if (do_rename(fname, path) != 0) {
455 int robust_rename(char *from, char *to)
458 return do_rename(from, to);
460 int rc = do_rename(from, to);
461 if ((rc == 0) || (errno != ETXTBSY))
463 if (robust_unlink(to) != 0)
465 return do_rename(from, to);
470 static pid_t all_pids[10];
473 /* fork and record the pid of the child */
476 pid_t newpid = fork();
479 all_pids[num_pids++] = newpid;
484 /* kill all children */
485 void kill_all(int sig)
488 for (i=0;i<num_pids;i++) {
489 if (all_pids[i] != getpid())
490 kill(all_pids[i], sig);
494 /* turn a user name into a uid */
495 int name_to_uid(char *name, uid_t *uid)
498 if (!name || !*name) return 0;
499 pass = getpwnam(name);
507 /* turn a group name into a gid */
508 int name_to_gid(char *name, gid_t *gid)
511 if (!name || !*name) return 0;
512 grp = getgrnam(name);
521 /* lock a byte range in a open file */
522 int lock_range(int fd, int offset, int len)
526 lock.l_type = F_WRLCK;
527 lock.l_whence = SEEK_SET;
528 lock.l_start = offset;
532 return fcntl(fd,F_SETLK,&lock) == 0;
536 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
538 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
540 argv[*argc] = strdup(s);
544 extern int sanitize_paths;
550 argv[*argc] = strdup(s);
551 if (sanitize_paths) {
552 sanitize_path(argv[*argc], NULL);
555 memset(&globbuf, 0, sizeof(globbuf));
556 glob(argv[*argc], 0, NULL, &globbuf);
557 if (globbuf.gl_pathc == 0) {
562 for (i=0; i<(maxargs - (*argc)) && i < (int) globbuf.gl_pathc;i++) {
563 if (i == 0) free(argv[*argc]);
564 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
565 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
572 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
574 char *s = argv[*argc];
578 if (!s || !*s) return;
580 if (strncmp(s, base, strlen(base)) == 0) {
585 if (!s) out_of_memory("glob_expand");
587 if (asprintf(&base," %s/", base1) <= 0) out_of_memory("glob_expand");
590 while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
591 /* split it at this point */
593 glob_expand_one(q, argv, argc, maxargs);
597 if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
603 /*******************************************************************
604 convert a string to lower case
605 ********************************************************************/
606 void strlower(char *s)
609 if (isupper(*s)) *s = tolower(*s);
614 void *Realloc(void *p, int size)
616 if (!p) return (void *)malloc(size);
617 return (void *)realloc(p, size);
621 void clean_fname(char *name)
632 if ((p=strstr(name,"/./"))) {
640 if ((p=strstr(name,"//"))) {
648 if (strncmp(p=name,"./",2) == 0) {
656 if (l > 1 && p[l-1] == '/') {
664 * Make path appear as if a chroot had occurred:
665 * 1. remove leading "/" (or replace with "." if at end)
666 * 2. remove leading ".." components (except those allowed by "reldir")
667 * 3. delete any other "<dir>/.." (recursively)
668 * Can only shrink paths, so sanitizes in place.
669 * While we're at it, remove double slashes and "." components like
670 * clean_fname does(), but DON'T remove a trailing slash because that
671 * is sometimes significant on command line arguments.
672 * If "reldir" is non-null, it is a sanitized directory that the path will be
673 * relative to, so allow as many ".." at the beginning of the path as
674 * there are components in reldir. This is used for symbolic link targets.
675 * If reldir is non-null and the path began with "/", to be completely like
676 * a chroot we should add in depth levels of ".." at the beginning of the
677 * path, but that would blow the assumption that the path doesn't grow and
678 * it is not likely to end up being a valid symlink anyway, so just do
679 * the normal removal of the leading "/" instead.
680 * Contributed by Dave Dykstra <dwd@bell-labs.com>
683 void sanitize_path(char *p, char *reldir)
692 if (*reldir++ == '/') {
700 /* remove leading slashes */
704 /* this loop iterates once per filename component in p.
705 * both p (and sanp if the original had a slash) should
706 * always be left pointing after a slash
708 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
709 /* skip "." component */
710 while (*++p == '/') {
711 /* skip following slashes */
717 if ((*p == '.') && (*(p+1) == '.') &&
718 ((*(p+2) == '/') || (*(p+2) == '\0'))) {
719 /* ".." component followed by slash or end */
720 if ((depth > 0) && (sanp == start)) {
721 /* allow depth levels of .. at the beginning */
729 /* back up sanp one level */
730 --sanp; /* now pointing at slash */
731 while ((sanp > start) && (*(sanp - 1) != '/')) {
732 /* skip back up to slash */
740 /* copy one component through next slash */
742 if ((*p == '\0') || (*(p-1) == '/')) {
744 /* skip multiple slashes */
751 /* move the virtual beginning to leave the .. alone */
755 if ((sanp == start) && !allowdotdot) {
756 /* ended up with nothing, so put in "." component */
758 * note that the !allowdotdot doesn't prevent this from
759 * happening in all allowed ".." situations, but I didn't
760 * think it was worth putting in an extra variable to ensure
761 * it since an extra "." won't hurt in those situations.
769 static char curr_dir[MAXPATHLEN];
771 /* like chdir() but can be reversed with pop_dir() if save is set. It
772 is also much faster as it remembers where we have been */
773 char *push_dir(char *dir, int save)
775 char *ret = curr_dir;
776 static int initialised;
780 getcwd(curr_dir, sizeof(curr_dir)-1);
783 if (!dir) return NULL; /* this call was probably just to initialize */
785 if (chdir(dir)) return NULL;
788 ret = strdup(curr_dir);
792 strlcpy(curr_dir, dir, sizeof(curr_dir));
794 strlcat(curr_dir,"/", sizeof(curr_dir));
795 strlcat(curr_dir,dir, sizeof(curr_dir));
798 clean_fname(curr_dir);
803 /* reverse a push_dir call */
804 int pop_dir(char *dir)
814 strlcpy(curr_dir, dir, sizeof(curr_dir));
821 /* we need to supply our own strcmp function for file list comparisons
822 to ensure that signed/unsigned usage is consistent between machines. */
823 int u_strcmp(const char *cs1, const char *cs2)
825 const uchar *s1 = (const uchar *)cs1;
826 const uchar *s2 = (const uchar *)cs2;
828 while (*s1 && *s2 && (*s1 == *s2)) {
832 return (int)*s1 - (int)*s2;
835 static OFF_T last_ofs;
836 static struct timeval print_time;
837 static struct timeval start_time;
838 static OFF_T start_ofs;
840 static unsigned long msdiff(struct timeval *t1, struct timeval *t2)
842 return (t2->tv_sec - t1->tv_sec) * 1000
843 + (t2->tv_usec - t1->tv_usec) / 1000;
848 * @param ofs Current position in file
849 * @param size Total size of file
850 * @param is_last True if this is the last time progress will be
851 * printed for this file, so we should output a newline. (Not
852 * necessarily the same as all bytes being received.)
854 static void rprint_progress(OFF_T ofs, OFF_T size, struct timeval *now,
857 int pct = (ofs == size) ? 100 : (int)((100.0*ofs)/size);
858 unsigned long diff = msdiff(&start_time, now);
859 double rate = diff ? (double) (ofs-start_ofs) * 1000.0 / diff / 1024.0 : 0;
861 double remain = rate ? (double) (size-ofs) / rate / 1000.0: 0.0;
862 int remain_h, remain_m, remain_s;
864 if (rate > 1024*1024) {
865 rate /= 1024.0 * 1024.0;
867 } else if (rate > 1024) {
874 remain_s = (int) remain % 60;
875 remain_m = (int) (remain / 60.0) % 60;
876 remain_h = (int) (remain / 3600.0);
878 rprintf(FINFO, "%12.0f %3d%% %7.2f%s %4d:%02d:%02d%s",
879 (double) ofs, pct, rate, units,
880 remain_h, remain_m, remain_s,
881 is_last ? "\n" : "\r");
884 void end_progress(OFF_T size)
886 extern int do_progress, am_server;
888 if (do_progress && !am_server) {
890 gettimeofday(&now, NULL);
891 rprint_progress(size, size, &now, True);
895 print_time.tv_sec = print_time.tv_usec = 0;
896 start_time.tv_sec = start_time.tv_usec = 0;
899 void show_progress(OFF_T ofs, OFF_T size)
901 extern int do_progress, am_server;
904 gettimeofday(&now, NULL);
906 if (!start_time.tv_sec && !start_time.tv_usec) {
907 start_time.tv_sec = now.tv_sec;
908 start_time.tv_usec = now.tv_usec;
914 && ofs > last_ofs + 1000
915 && msdiff(&print_time, &now) > 250) {
916 rprint_progress(ofs, size, &now, False);
918 print_time.tv_sec = now.tv_sec;
919 print_time.tv_usec = now.tv_usec;
923 /* determine if a symlink points outside the current directory tree */
924 int unsafe_symlink(char *dest, char *src)
929 /* all absolute and null symlinks are unsafe */
930 if (!dest || !(*dest) || (*dest == '/')) return 1;
933 if (!src) out_of_memory("unsafe_symlink");
935 /* find out what our safety margin is */
936 for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
937 if (strcmp(tok,"..") == 0) {
939 } else if (strcmp(tok,".") == 0) {
947 /* drop by one to account for the filename portion */
951 if (!dest) out_of_memory("unsafe_symlink");
953 for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
954 if (strcmp(tok,"..") == 0) {
956 } else if (strcmp(tok,".") == 0) {
961 /* if at any point we go outside the current directory then
962 stop - it is unsafe */
963 if (depth < 0) break;
971 /****************************************************************************
972 return the date and time as a string
973 ****************************************************************************/
974 char *timestring(time_t t)
976 static char TimeBuf[200];
977 struct tm *tm = localtime(&t);
980 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
982 strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
985 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
986 TimeBuf[strlen(TimeBuf)-1] = 0;
994 * Sleep for a specified number of milliseconds.
996 * Always returns TRUE. (In the future it might return FALSE if
1002 struct timeval tval,t1,t2;
1004 gettimeofday(&t1, NULL);
1005 gettimeofday(&t2, NULL);
1008 tval.tv_sec = (t-tdiff)/1000;
1009 tval.tv_usec = 1000*((t-tdiff)%1000);
1012 select(0,NULL,NULL, NULL, &tval);
1014 gettimeofday(&t2, NULL);
1015 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1016 (t2.tv_usec - t1.tv_usec)/1000;
1023 /*******************************************************************
1024 Determine if two file modification times are equivalent (either exact
1025 or in the modification timestamp window established by --modify-window)
1026 Returns 0 if the times should be treated as the same, 1 if the
1027 first is later and -1 if the 2nd is later
1028 *******************************************************************/
1029 int cmp_modtime(time_t file1, time_t file2)
1031 extern int modify_window;
1033 if (file2 > file1) {
1034 if (file2 - file1 <= modify_window) return 0;
1037 if (file1 - file2 <= modify_window) return 0;
1045 /*******************************************************************
1046 This routine is a trick to immediately catch errors when debugging
1047 with insure. A xterm with a gdb is popped up when insure catches
1048 a error. It is Linux specific.
1049 ********************************************************************/
1050 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1056 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'",
1057 getpid(), getpid(), getpid());
1061 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1062 fn = dlsym(h, "_Insure_trap_error");
1065 ret = fn(a1, a2, a3, a4, a5, a6);