2 Copyright (C) Andrew Tridgell 1996
3 Copyright (C) Paul Mackerras 1996
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 Utilities used in rsync
29 /* this is taken from CVS */
30 int piped_child(char **command,int *f_in,int *f_out)
34 int from_child_pipe[2];
36 if (pipe(to_child_pipe) < 0 ||
37 pipe(from_child_pipe) < 0) {
38 rprintf(FERROR,"pipe: %s\n",strerror(errno));
39 exit_cleanup(RERR_IPC);
45 rprintf(FERROR,"fork: %s\n",strerror(errno));
46 exit_cleanup(RERR_IPC);
51 extern int orig_umask;
52 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
53 close(to_child_pipe[1]) < 0 ||
54 close(from_child_pipe[0]) < 0 ||
55 dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
56 rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
57 exit_cleanup(RERR_IPC);
59 if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
60 if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
62 execvp(command[0], command);
63 rprintf(FERROR,"Failed to exec %s : %s\n",
64 command[0],strerror(errno));
65 exit_cleanup(RERR_IPC);
68 if (close(from_child_pipe[1]) < 0 ||
69 close(to_child_pipe[0]) < 0) {
70 rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
71 exit_cleanup(RERR_IPC);
74 *f_in = from_child_pipe[0];
75 *f_out = to_child_pipe[1];
80 int local_child(int argc, char **argv,int *f_in,int *f_out)
84 int from_child_pipe[2];
86 if (pipe(to_child_pipe) < 0 ||
87 pipe(from_child_pipe) < 0) {
88 rprintf(FERROR,"pipe: %s\n",strerror(errno));
89 exit_cleanup(RERR_IPC);
95 rprintf(FERROR,"fork: %s\n",strerror(errno));
96 exit_cleanup(RERR_IPC);
100 extern int am_sender;
101 extern int am_server;
103 am_sender = !am_sender;
106 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
107 close(to_child_pipe[1]) < 0 ||
108 close(from_child_pipe[0]) < 0 ||
109 dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
110 rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
111 exit_cleanup(RERR_IPC);
113 if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
114 if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
115 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
118 if (close(from_child_pipe[1]) < 0 ||
119 close(to_child_pipe[0]) < 0) {
120 rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
121 exit_cleanup(RERR_IPC);
124 *f_in = from_child_pipe[0];
125 *f_out = to_child_pipe[1];
132 void out_of_memory(char *str)
134 rprintf(FERROR,"ERROR: out of memory in %s\n",str);
135 exit_cleanup(RERR_MALLOC);
138 void overflow(char *str)
140 rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
141 exit_cleanup(RERR_MALLOC);
146 int set_modtime(char *fname,time_t modtime)
149 if (dry_run) return 0;
153 tbuf.actime = time(NULL);
154 tbuf.modtime = modtime;
155 return utime(fname,&tbuf);
156 #elif defined(HAVE_UTIME)
160 return utime(fname,t);
163 t[0].tv_sec = time(NULL);
165 t[1].tv_sec = modtime;
167 return utimes(fname,t);
173 /****************************************************************************
174 create any necessary directories in fname. Unfortunately we don't know
175 what perms to give the directory when this is called so we need to rely
177 ****************************************************************************/
178 int create_directory_path(char *fname)
180 extern int orig_umask;
183 while (*fname == '/') fname++;
184 while (strncmp(fname,"./",2)==0) fname += 2;
187 while ((p=strchr(p,'/'))) {
189 do_mkdir(fname,0777 & ~orig_umask);
197 /* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
198 Return LEN upon success, write's (negative) error code otherwise.
200 derived from GNU C's cccp.c.
202 static int full_write(int desc, char *ptr, int len)
208 int written = write (desc, ptr, len);
216 total_written += written;
220 return total_written;
223 /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
224 Return the actual number of bytes read, zero for EOF, or negative
227 derived from GNU C's cccp.c. */
228 static int safe_read(int desc, char *ptr, int len)
237 n_chars = read(desc, ptr, len);
238 } while (n_chars < 0 && errno == EINTR);
240 n_chars = read(desc, ptr, len);
247 /* copy a file - this is used in conjunction with the --temp-dir option */
248 int copy_file(char *source, char *dest, mode_t mode)
253 int len; /* Number of bytes read into `buf'. */
255 ifd = do_open(source, O_RDONLY, 0);
257 rprintf(FERROR,"open %s: %s\n",
258 source,strerror(errno));
262 if (robust_unlink(dest) && errno != ENOENT) {
263 rprintf(FERROR,"unlink %s: %s\n",
264 dest,strerror(errno));
268 ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
270 rprintf(FERROR,"open %s: %s\n",
271 dest,strerror(errno));
276 while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
277 if (full_write(ofd, buf, len) < 0) {
278 rprintf(FERROR,"write %s: %s\n",
279 dest,strerror(errno));
290 rprintf(FERROR,"read %s: %s\n",
291 source,strerror(errno));
299 Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
300 rename to <path>/.rsyncNNN instead. Note that successive rsync runs
301 will shuffle the filenames around a bit as long as the file is still
302 busy; this is because this function does not know if the unlink call
303 is due to a new file coming in, or --delete trying to remove old
304 .rsyncNNN files, hence it renames it each time.
306 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
307 #define MAX_RENAMES_DIGITS 3
308 #define MAX_RENAMES 1000
310 int robust_unlink(char *fname)
313 return do_unlink(fname);
315 static int counter = 1;
317 char path[MAXPATHLEN];
319 rc = do_unlink(fname);
320 if ((rc == 0) || (errno != ETXTBSY))
323 strlcpy(path, fname, MAXPATHLEN);
326 while((path[--pos] != '/') && (pos >= 0))
329 strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
330 pos += sizeof(".rsync")-1;
332 if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
337 /* start where the last one left off to reduce chance of clashes */
340 sprintf(&path[pos], "%03d", counter);
341 if (++counter >= MAX_RENAMES)
343 } while (((rc = access(path, 0)) == 0) && (counter != start));
346 rprintf(FINFO,"renaming %s to %s because of text busy\n",
349 /* maybe we should return rename()'s exit status? Nah. */
350 if (do_rename(fname, path) != 0) {
358 int robust_rename(char *from, char *to)
361 return do_rename(from, to);
363 int rc = do_rename(from, to);
364 if ((rc == 0) || (errno != ETXTBSY))
366 if (robust_unlink(to) != 0)
368 return do_rename(from, to);
373 static pid_t all_pids[10];
376 /* fork and record the pid of the child */
379 pid_t newpid = fork();
382 all_pids[num_pids++] = newpid;
387 /* kill all children */
388 void kill_all(int sig)
391 for (i=0;i<num_pids;i++) {
392 if (all_pids[i] != getpid())
393 kill(all_pids[i], sig);
397 /* turn a user name into a uid */
398 int name_to_uid(char *name, uid_t *uid)
401 if (!name || !*name) return 0;
402 pass = getpwnam(name);
410 /* turn a group name into a gid */
411 int name_to_gid(char *name, gid_t *gid)
414 if (!name || !*name) return 0;
415 grp = getgrnam(name);
424 /* lock a byte range in a open file */
425 int lock_range(int fd, int offset, int len)
429 lock.l_type = F_WRLCK;
430 lock.l_whence = SEEK_SET;
431 lock.l_start = offset;
435 return fcntl(fd,F_SETLK,&lock) == 0;
439 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
441 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
443 argv[*argc] = strdup(s);
447 extern int sanitize_paths;
453 argv[*argc] = strdup(s);
454 if (sanitize_paths) {
455 sanitize_path(argv[*argc], NULL);
458 memset(&globbuf, 0, sizeof(globbuf));
459 glob(argv[*argc], 0, NULL, &globbuf);
460 if (globbuf.gl_pathc == 0) {
465 for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
466 if (i == 0) free(argv[*argc]);
467 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
468 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
475 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
477 char *s = argv[*argc];
481 if (!s || !*s) return;
483 if (strncmp(s, base, strlen(base)) == 0) {
488 if (!s) out_of_memory("glob_expand");
490 base = (char *)malloc(strlen(base1)+3);
491 if (!base) out_of_memory("glob_expand");
493 sprintf(base," %s/", base1);
496 while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
497 /* split it at this point */
499 glob_expand_one(q, argv, argc, maxargs);
503 if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
509 /*******************************************************************
510 convert a string to lower case
511 ********************************************************************/
512 void strlower(char *s)
515 if (isupper(*s)) *s = tolower(*s);
520 /* this is like vsnprintf but it always null terminates, so you
521 can fit at most n-1 chars in */
522 int vslprintf(char *str, int n, const char *format, va_list ap)
524 int ret = vsnprintf(str, n, format, ap);
525 if (ret >= n || ret < 0) {
534 /* like snprintf but always null terminates */
535 int slprintf(char *str, int n, char *format, ...)
540 va_start(ap, format);
541 ret = vslprintf(str,n,format,ap);
547 void *Realloc(void *p, int size)
549 if (!p) return (void *)malloc(size);
550 return (void *)realloc(p, size);
554 void clean_fname(char *name)
565 if ((p=strstr(name,"/./"))) {
573 if ((p=strstr(name,"//"))) {
581 if (strncmp(p=name,"./",2) == 0) {
589 if (l > 1 && p[l-1] == '/') {
597 * Make path appear as if a chroot had occurred:
598 * 1. remove leading "/" (or replace with "." if at end)
599 * 2. remove leading ".." components (except those allowed by "reldir")
600 * 3. delete any other "<dir>/.." (recursively)
601 * Can only shrink paths, so sanitizes in place.
602 * While we're at it, remove double slashes and "." components like
603 * clean_fname does(), but DON'T remove a trailing slash because that
604 * is sometimes significant on command line arguments.
605 * If "reldir" is non-null, it is a sanitized directory that the path will be
606 * relative to, so allow as many ".." at the beginning of the path as
607 * there are components in reldir. This is used for symbolic link targets.
608 * If reldir is non-null and the path began with "/", to be completely like
609 * a chroot we should add in depth levels of ".." at the beginning of the
610 * path, but that would blow the assumption that the path doesn't grow and
611 * it is not likely to end up being a valid symlink anyway, so just do
612 * the normal removal of the leading "/" instead.
613 * Contributed by Dave Dykstra <dwd@bell-labs.com>
616 void sanitize_path(char *p, char *reldir)
625 if (*reldir++ == '/') {
633 /* remove leading slashes */
637 /* this loop iterates once per filename component in p.
638 * both p (and sanp if the original had a slash) should
639 * always be left pointing after a slash
641 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
642 /* skip "." component */
643 while (*++p == '/') {
644 /* skip following slashes */
650 if ((*p == '.') && (*(p+1) == '.') &&
651 ((*(p+2) == '/') || (*(p+2) == '\0'))) {
652 /* ".." component followed by slash or end */
653 if ((depth > 0) && (sanp == start)) {
654 /* allow depth levels of .. at the beginning */
662 /* back up sanp one level */
663 --sanp; /* now pointing at slash */
664 while ((sanp > start) && (*(sanp - 1) != '/')) {
665 /* skip back up to slash */
673 /* copy one component through next slash */
675 if ((*p == '\0') || (*(p-1) == '/')) {
677 /* skip multiple slashes */
684 /* move the virtual beginning to leave the .. alone */
688 if ((sanp == start) && !allowdotdot) {
689 /* ended up with nothing, so put in "." component */
691 * note that the !allowdotdot doesn't prevent this from
692 * happening in all allowed ".." situations, but I didn't
693 * think it was worth putting in an extra variable to ensure
694 * it since an extra "." won't hurt in those situations.
702 static char curr_dir[MAXPATHLEN];
704 /* like chdir() but can be reversed with pop_dir() if save is set. It
705 is also much faster as it remembers where we have been */
706 char *push_dir(char *dir, int save)
708 char *ret = curr_dir;
709 static int initialised;
713 getcwd(curr_dir, sizeof(curr_dir)-1);
716 if (!dir) return NULL; /* this call was probably just to initialize */
718 if (chdir(dir)) return NULL;
721 ret = strdup(curr_dir);
725 strlcpy(curr_dir, dir, sizeof(curr_dir));
727 strlcat(curr_dir,"/", sizeof(curr_dir));
728 strlcat(curr_dir,dir, sizeof(curr_dir));
731 clean_fname(curr_dir);
736 /* reverse a push_dir call */
737 int pop_dir(char *dir)
747 strlcpy(curr_dir, dir, sizeof(curr_dir));
754 /* we need to supply our own strcmp function for file list comparisons
755 to ensure that signed/unsigned usage is consistent between machines. */
756 int u_strcmp(const char *cs1, const char *cs2)
758 const uchar *s1 = (const uchar *)cs1;
759 const uchar *s2 = (const uchar *)cs2;
761 while (*s1 && *s2 && (*s1 == *s2)) {
765 return (int)*s1 - (int)*s2;
768 static OFF_T last_ofs;
770 void end_progress(void)
772 extern int do_progress, am_server;
774 if (do_progress && !am_server) {
780 void show_progress(OFF_T ofs, OFF_T size)
782 extern int do_progress, am_server;
784 if (do_progress && !am_server) {
785 if (ofs > last_ofs + 1000) {
786 int pct = (int)((100.0*ofs)/size);
787 rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
793 /* determine if a symlink points outside the current directory tree */
794 int unsafe_symlink(char *dest, char *src)
799 /* all absolute and null symlinks are unsafe */
800 if (!dest || !(*dest) || (*dest == '/')) return 1;
803 if (!src) out_of_memory("unsafe_symlink");
805 /* find out what our safety margin is */
806 for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
807 if (strcmp(tok,"..") == 0) {
809 } else if (strcmp(tok,".") == 0) {
817 /* drop by one to account for the filename portion */
821 if (!dest) out_of_memory("unsafe_symlink");
823 for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
824 if (strcmp(tok,"..") == 0) {
826 } else if (strcmp(tok,".") == 0) {
831 /* if at any point we go outside the current directory then
832 stop - it is unsafe */
833 if (depth < 0) break;
841 /****************************************************************************
842 return the date and time as a string
843 ****************************************************************************/
844 char *timestring(time_t t)
846 static char TimeBuf[200];
847 struct tm *tm = localtime(&t);
850 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
852 strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
855 if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
856 TimeBuf[strlen(TimeBuf)-1] = 0;
863 /****************************************************************************
864 like waitpid but does the WEXITSTATUS
865 ****************************************************************************/
867 #define WEXITSTATUS(stat) ((int)(((stat)>>8)&0xFF))
869 void wait_process(pid_t pid, int *status)
871 waitpid(pid, status, 0);
872 *status = WEXITSTATUS(*status);