1 /* -*- c-file-style: "linux" -*-
3 Copyright (C) 1996-2000 by Andrew Tridgell
4 Copyright (C) Paul Mackerras 1996
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 Utilities used in rsync
31 /****************************************************************************
32 Set a fd into nonblocking mode
33 ****************************************************************************/
34 void set_nonblocking(int fd)
38 if((val = fcntl(fd, F_GETFL, 0)) == -1)
40 if (!(val & NONBLOCK_FLAG)) {
42 fcntl(fd, F_SETFL, val);
46 /****************************************************************************
47 Set a fd into blocking mode
48 ****************************************************************************/
49 void set_blocking(int fd)
53 if((val = fcntl(fd, F_GETFL, 0)) == -1)
55 if (val & NONBLOCK_FLAG) {
56 val &= ~NONBLOCK_FLAG;
57 fcntl(fd, F_SETFL, val);
62 /* create a file descriptor pair - like pipe() but use socketpair if
63 possible (because of blocking issues on pipes)
65 always set non-blocking
67 int fd_pair(int fd[2])
72 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
78 set_nonblocking(fd[0]);
79 set_nonblocking(fd[1]);
86 /* this is derived from CVS code
88 note that in the child STDIN is set to blocking and STDOUT
89 is set to non-blocking. This is necessary as rsh relies on stdin being blocking
90 and ssh relies on stdout being non-blocking
92 if blocking_io is set then use blocking io on both fds. That can be
93 used to cope with badly broken rsh implementations like the one on
96 pid_t piped_child(char **command,int *f_in,int *f_out)
100 int from_child_pipe[2];
101 extern int blocking_io;
103 if (fd_pair(to_child_pipe) < 0 ||
104 fd_pair(from_child_pipe) < 0) {
105 rprintf(FERROR,"pipe: %s\n",strerror(errno));
106 exit_cleanup(RERR_IPC);
112 rprintf(FERROR,"fork: %s\n",strerror(errno));
113 exit_cleanup(RERR_IPC);
118 extern int orig_umask;
119 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
120 close(to_child_pipe[1]) < 0 ||
121 close(from_child_pipe[0]) < 0 ||
122 dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
123 rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
124 exit_cleanup(RERR_IPC);
126 if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
127 if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
129 set_blocking(STDIN_FILENO);
131 set_blocking(STDOUT_FILENO);
133 execvp(command[0], command);
134 rprintf(FERROR,"Failed to exec %s : %s\n",
135 command[0],strerror(errno));
136 exit_cleanup(RERR_IPC);
139 if (close(from_child_pipe[1]) < 0 ||
140 close(to_child_pipe[0]) < 0) {
141 rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
142 exit_cleanup(RERR_IPC);
145 *f_in = from_child_pipe[0];
146 *f_out = to_child_pipe[1];
151 pid_t local_child(int argc, char **argv,int *f_in,int *f_out)
154 int to_child_pipe[2];
155 int from_child_pipe[2];
157 if (fd_pair(to_child_pipe) < 0 ||
158 fd_pair(from_child_pipe) < 0) {
159 rprintf(FERROR,"pipe: %s\n",strerror(errno));
160 exit_cleanup(RERR_IPC);
166 rprintf(FERROR,"fork: %s\n",strerror(errno));
167 exit_cleanup(RERR_IPC);
171 extern int am_sender;
172 extern int am_server;
174 am_sender = !am_sender;
177 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
178 close(to_child_pipe[1]) < 0 ||
179 close(from_child_pipe[0]) < 0 ||
180 dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
181 rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
182 exit_cleanup(RERR_IPC);
184 if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
185 if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
186 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
189 if (close(from_child_pipe[1]) < 0 ||
190 close(to_child_pipe[0]) < 0) {
191 rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
192 exit_cleanup(RERR_IPC);
195 *f_in = from_child_pipe[0];
196 *f_out = to_child_pipe[1];
203 void out_of_memory(char *str)
205 rprintf(FERROR,"ERROR: out of memory in %s\n",str);
206 exit_cleanup(RERR_MALLOC);
209 void overflow(char *str)
211 rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
212 exit_cleanup(RERR_MALLOC);
217 int set_modtime(char *fname,time_t modtime)
220 if (dry_run) return 0;
224 tbuf.actime = time(NULL);
225 tbuf.modtime = modtime;
226 return utime(fname,&tbuf);
227 #elif defined(HAVE_UTIME)
231 return utime(fname,t);
234 t[0].tv_sec = time(NULL);
236 t[1].tv_sec = modtime;
238 return utimes(fname,t);
244 /****************************************************************************
245 create any necessary directories in fname. Unfortunately we don't know
246 what perms to give the directory when this is called so we need to rely
248 ****************************************************************************/
249 int create_directory_path(char *fname)
251 extern int orig_umask;
254 while (*fname == '/') fname++;
255 while (strncmp(fname,"./",2)==0) fname += 2;
258 while ((p=strchr(p,'/'))) {
260 do_mkdir(fname,0777 & ~orig_umask);
268 /* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
269 Return LEN upon success, write's (negative) error code otherwise.
271 derived from GNU C's cccp.c.
273 static int full_write(int desc, char *ptr, int len)
279 int written = write (desc, ptr, len);
287 total_written += written;
291 return total_written;
294 /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
295 Return the actual number of bytes read, zero for EOF, or negative
298 derived from GNU C's cccp.c. */
299 static int safe_read(int desc, char *ptr, int len)
308 n_chars = read(desc, ptr, len);
309 } while (n_chars < 0 && errno == EINTR);
311 n_chars = read(desc, ptr, len);
318 /* copy a file - this is used in conjunction with the --temp-dir option */
319 int copy_file(char *source, char *dest, mode_t mode)
324 int len; /* Number of bytes read into `buf'. */
326 ifd = do_open(source, O_RDONLY, 0);
328 rprintf(FERROR,"open %s: %s\n",
329 source,strerror(errno));
333 if (robust_unlink(dest) && errno != ENOENT) {
334 rprintf(FERROR,"unlink %s: %s\n",
335 dest,strerror(errno));
339 ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
341 rprintf(FERROR,"open %s: %s\n",
342 dest,strerror(errno));
347 while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
348 if (full_write(ofd, buf, len) < 0) {
349 rprintf(FERROR,"write %s: %s\n",
350 dest,strerror(errno));
361 rprintf(FERROR,"read %s: %s\n",
362 source,strerror(errno));
370 Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
371 rename to <path>/.rsyncNNN instead. Note that successive rsync runs
372 will shuffle the filenames around a bit as long as the file is still
373 busy; this is because this function does not know if the unlink call
374 is due to a new file coming in, or --delete trying to remove old
375 .rsyncNNN files, hence it renames it each time.
377 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
378 #define MAX_RENAMES_DIGITS 3
379 #define MAX_RENAMES 1000
381 int robust_unlink(char *fname)
384 return do_unlink(fname);
386 static int counter = 1;
388 char path[MAXPATHLEN];
390 rc = do_unlink(fname);
391 if ((rc == 0) || (errno != ETXTBSY))
394 strlcpy(path, fname, MAXPATHLEN);
397 while((path[--pos] != '/') && (pos >= 0))
400 strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
401 pos += sizeof(".rsync")-1;
403 if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
408 /* start where the last one left off to reduce chance of clashes */
411 sprintf(&path[pos], "%03d", counter);
412 if (++counter >= MAX_RENAMES)
414 } while (((rc = access(path, 0)) == 0) && (counter != start));
417 rprintf(FINFO,"renaming %s to %s because of text busy\n",
420 /* maybe we should return rename()'s exit status? Nah. */
421 if (do_rename(fname, path) != 0) {
429 int robust_rename(char *from, char *to)
432 return do_rename(from, to);
434 int rc = do_rename(from, to);
435 if ((rc == 0) || (errno != ETXTBSY))
437 if (robust_unlink(to) != 0)
439 return do_rename(from, to);
444 static pid_t all_pids[10];
447 /* fork and record the pid of the child */
450 pid_t newpid = fork();
453 all_pids[num_pids++] = newpid;
458 /* kill all children */
459 void kill_all(int sig)
462 for (i=0;i<num_pids;i++) {
463 if (all_pids[i] != getpid())
464 kill(all_pids[i], sig);
468 /* turn a user name into a uid */
469 int name_to_uid(char *name, uid_t *uid)
472 if (!name || !*name) return 0;
473 pass = getpwnam(name);
481 /* turn a group name into a gid */
482 int name_to_gid(char *name, gid_t *gid)
485 if (!name || !*name) return 0;
486 grp = getgrnam(name);
495 /* lock a byte range in a open file */
496 int lock_range(int fd, int offset, int len)
500 lock.l_type = F_WRLCK;
501 lock.l_whence = SEEK_SET;
502 lock.l_start = offset;
506 return fcntl(fd,F_SETLK,&lock) == 0;
510 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
512 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
514 argv[*argc] = strdup(s);
518 extern int sanitize_paths;
524 argv[*argc] = strdup(s);
525 if (sanitize_paths) {
526 sanitize_path(argv[*argc], NULL);
529 memset(&globbuf, 0, sizeof(globbuf));
530 glob(argv[*argc], 0, NULL, &globbuf);
531 if (globbuf.gl_pathc == 0) {
536 for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
537 if (i == 0) free(argv[*argc]);
538 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
539 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
546 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
548 char *s = argv[*argc];
552 if (!s || !*s) return;
554 if (strncmp(s, base, strlen(base)) == 0) {
559 if (!s) out_of_memory("glob_expand");
561 if (asprintf(&base," %s/", base1) <= 0) out_of_memory("glob_expand");
564 while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
565 /* split it at this point */
567 glob_expand_one(q, argv, argc, maxargs);
571 if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
577 /*******************************************************************
578 convert a string to lower case
579 ********************************************************************/
580 void strlower(char *s)
583 if (isupper(*s)) *s = tolower(*s);
588 void *Realloc(void *p, int size)
590 if (!p) return (void *)malloc(size);
591 return (void *)realloc(p, size);
595 void clean_fname(char *name)
606 if ((p=strstr(name,"/./"))) {
614 if ((p=strstr(name,"//"))) {
622 if (strncmp(p=name,"./",2) == 0) {
630 if (l > 1 && p[l-1] == '/') {
638 * Make path appear as if a chroot had occurred:
639 * 1. remove leading "/" (or replace with "." if at end)
640 * 2. remove leading ".." components (except those allowed by "reldir")
641 * 3. delete any other "<dir>/.." (recursively)
642 * Can only shrink paths, so sanitizes in place.
643 * While we're at it, remove double slashes and "." components like
644 * clean_fname does(), but DON'T remove a trailing slash because that
645 * is sometimes significant on command line arguments.
646 * If "reldir" is non-null, it is a sanitized directory that the path will be
647 * relative to, so allow as many ".." at the beginning of the path as
648 * there are components in reldir. This is used for symbolic link targets.
649 * If reldir is non-null and the path began with "/", to be completely like
650 * a chroot we should add in depth levels of ".." at the beginning of the
651 * path, but that would blow the assumption that the path doesn't grow and
652 * it is not likely to end up being a valid symlink anyway, so just do
653 * the normal removal of the leading "/" instead.
654 * Contributed by Dave Dykstra <dwd@bell-labs.com>
657 void sanitize_path(char *p, char *reldir)
666 if (*reldir++ == '/') {
674 /* remove leading slashes */
678 /* this loop iterates once per filename component in p.
679 * both p (and sanp if the original had a slash) should
680 * always be left pointing after a slash
682 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
683 /* skip "." component */
684 while (*++p == '/') {
685 /* skip following slashes */
691 if ((*p == '.') && (*(p+1) == '.') &&
692 ((*(p+2) == '/') || (*(p+2) == '\0'))) {
693 /* ".." component followed by slash or end */
694 if ((depth > 0) && (sanp == start)) {
695 /* allow depth levels of .. at the beginning */
703 /* back up sanp one level */
704 --sanp; /* now pointing at slash */
705 while ((sanp > start) && (*(sanp - 1) != '/')) {
706 /* skip back up to slash */
714 /* copy one component through next slash */
716 if ((*p == '\0') || (*(p-1) == '/')) {
718 /* skip multiple slashes */
725 /* move the virtual beginning to leave the .. alone */
729 if ((sanp == start) && !allowdotdot) {
730 /* ended up with nothing, so put in "." component */
732 * note that the !allowdotdot doesn't prevent this from
733 * happening in all allowed ".." situations, but I didn't
734 * think it was worth putting in an extra variable to ensure
735 * it since an extra "." won't hurt in those situations.
743 static char curr_dir[MAXPATHLEN];
745 /* like chdir() but can be reversed with pop_dir() if save is set. It
746 is also much faster as it remembers where we have been */
747 char *push_dir(char *dir, int save)
749 char *ret = curr_dir;
750 static int initialised;
754 getcwd(curr_dir, sizeof(curr_dir)-1);
757 if (!dir) return NULL; /* this call was probably just to initialize */
759 if (chdir(dir)) return NULL;
762 ret = strdup(curr_dir);
766 strlcpy(curr_dir, dir, sizeof(curr_dir));
768 strlcat(curr_dir,"/", sizeof(curr_dir));
769 strlcat(curr_dir,dir, sizeof(curr_dir));
772 clean_fname(curr_dir);
777 /* reverse a push_dir call */
778 int pop_dir(char *dir)
788 strlcpy(curr_dir, dir, sizeof(curr_dir));
795 /* we need to supply our own strcmp function for file list comparisons
796 to ensure that signed/unsigned usage is consistent between machines. */
797 int u_strcmp(const char *cs1, const char *cs2)
799 const uchar *s1 = (const uchar *)cs1;
800 const uchar *s2 = (const uchar *)cs2;
802 while (*s1 && *s2 && (*s1 == *s2)) {
806 return (int)*s1 - (int)*s2;
809 static OFF_T last_ofs;
811 void end_progress(OFF_T size)
813 extern int do_progress, am_server;
815 if (do_progress && !am_server) {
816 rprintf(FINFO,"%.0f (100%%)\n", (double)size);
821 void show_progress(OFF_T ofs, OFF_T size)
823 extern int do_progress, am_server;
825 if (do_progress && !am_server) {
826 if (ofs > last_ofs + 1000) {
827 int pct = (int)((100.0*ofs)/size);
828 rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
834 /* determine if a symlink points outside the current directory tree */
835 int unsafe_symlink(char *dest, char *src)
840 /* all absolute and null symlinks are unsafe */
841 if (!dest || !(*dest) || (*dest == '/')) return 1;
844 if (!src) out_of_memory("unsafe_symlink");
846 /* find out what our safety margin is */
847 for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
848 if (strcmp(tok,"..") == 0) {
850 } else if (strcmp(tok,".") == 0) {
858 /* drop by one to account for the filename portion */
862 if (!dest) out_of_memory("unsafe_symlink");
864 for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
865 if (strcmp(tok,"..") == 0) {
867 } else if (strcmp(tok,".") == 0) {
872 /* if at any point we go outside the current directory then
873 stop - it is unsafe */
874 if (depth < 0) break;
882 /****************************************************************************
883 return the date and time as a string
884 ****************************************************************************/
885 char *timestring(time_t t)
887 static char TimeBuf[200];
888 struct tm *tm = localtime(&t);
891 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
893 strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
896 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
897 TimeBuf[strlen(TimeBuf)-1] = 0;
904 /*******************************************************************
905 sleep for a specified number of milliseconds
906 ********************************************************************/
910 struct timeval tval,t1,t2;
912 gettimeofday(&t1, NULL);
913 gettimeofday(&t2, NULL);
916 tval.tv_sec = (t-tdiff)/1000;
917 tval.tv_usec = 1000*((t-tdiff)%1000);
920 select(0,NULL,NULL, NULL, &tval);
922 gettimeofday(&t2, NULL);
923 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
924 (t2.tv_usec - t1.tv_usec)/1000;
929 /*******************************************************************
930 Determine if two file modification times are equivalent (either exact
931 or in the modification timestamp window established by --modify-window)
932 Returns 0 if the times should be treated as the same, 1 if the
933 first is later and -1 if the 2nd is later
934 *******************************************************************/
935 int cmp_modtime(time_t file1, time_t file2)
937 extern int modify_window;
940 if (file2 - file1 <= modify_window) return 0;
943 if (file1 - file2 <= modify_window) return 0;
951 /*******************************************************************
952 This routine is a trick to immediately catch errors when debugging
953 with insure. A xterm with a gdb is popped up when insure catches
954 a error. It is Linux specific.
955 ********************************************************************/
956 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
962 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'",
963 getpid(), getpid(), getpid());
967 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
968 fn = dlsym(h, "_Insure_trap_error");
971 ret = fn(a1, a2, a3, a4, a5, a6);