When rsync encountered an empty file list, it behaved differently
[rsync.git] / util.c
1 /*  -*- c-file-style: "linux" -*-
2  *
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>
6  *
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.
11  *
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.
16  *
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.
20  */
21
22 /**
23  * @file
24  *
25  * Utilities used in rsync
26  **/
27
28 #include "rsync.h"
29
30 extern int verbose;
31 extern int dry_run;
32 extern int module_id;
33 extern int modify_window;
34 extern char *partial_dir;
35 extern struct filter_list_struct server_filter_list;
36
37 int sanitize_paths = 0;
38
39
40
41 /**
42  * Set a fd into nonblocking mode
43  **/
44 void set_nonblocking(int fd)
45 {
46         int val;
47
48         if ((val = fcntl(fd, F_GETFL, 0)) == -1)
49                 return;
50         if (!(val & NONBLOCK_FLAG)) {
51                 val |= NONBLOCK_FLAG;
52                 fcntl(fd, F_SETFL, val);
53         }
54 }
55
56 /**
57  * Set a fd into blocking mode
58  **/
59 void set_blocking(int fd)
60 {
61         int val;
62
63         if ((val = fcntl(fd, F_GETFL, 0)) == -1)
64                 return;
65         if (val & NONBLOCK_FLAG) {
66                 val &= ~NONBLOCK_FLAG;
67                 fcntl(fd, F_SETFL, val);
68         }
69 }
70
71
72 /**
73  * Create a file descriptor pair - like pipe() but use socketpair if
74  * possible (because of blocking issues on pipes).
75  *
76  * Always set non-blocking.
77  */
78 int fd_pair(int fd[2])
79 {
80         int ret;
81
82 #ifdef HAVE_SOCKETPAIR
83         ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
84 #else
85         ret = pipe(fd);
86 #endif
87
88         if (ret == 0) {
89                 set_nonblocking(fd[0]);
90                 set_nonblocking(fd[1]);
91         }
92
93         return ret;
94 }
95
96
97 void print_child_argv(char **cmd)
98 {
99         rprintf(FINFO, "opening connection using ");
100         for (; *cmd; cmd++) {
101                 /* Look for characters that ought to be quoted.  This
102                 * is not a great quoting algorithm, but it's
103                 * sufficient for a log message. */
104                 if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
105                            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
106                            "0123456789"
107                            ",.-_=+@/") != strlen(*cmd)) {
108                         rprintf(FINFO, "\"%s\" ", safe_fname(*cmd));
109                 } else {
110                         rprintf(FINFO, "%s ", safe_fname(*cmd));
111                 }
112         }
113         rprintf(FINFO, "\n");
114 }
115
116
117 void out_of_memory(char *str)
118 {
119         rprintf(FERROR, "ERROR: out of memory in %s\n", str);
120         exit_cleanup(RERR_MALLOC);
121 }
122
123 void overflow(char *str)
124 {
125         rprintf(FERROR, "ERROR: buffer overflow in %s\n", str);
126         exit_cleanup(RERR_MALLOC);
127 }
128
129
130
131 int set_modtime(char *fname, time_t modtime)
132 {
133         if (verbose > 2) {
134                 rprintf(FINFO, "set modtime of %s to (%ld) %s",
135                         safe_fname(fname), (long)modtime,
136                         asctime(localtime(&modtime)));
137         }
138
139         if (dry_run)
140                 return 0;
141
142         {
143 #ifdef HAVE_UTIMBUF
144                 struct utimbuf tbuf;
145                 tbuf.actime = time(NULL);
146                 tbuf.modtime = modtime;
147                 return utime(fname,&tbuf);
148 #elif defined HAVE_UTIME
149                 time_t t[2];
150                 t[0] = time(NULL);
151                 t[1] = modtime;
152                 return utime(fname,t);
153 #else
154                 struct timeval t[2];
155                 t[0].tv_sec = time(NULL);
156                 t[0].tv_usec = 0;
157                 t[1].tv_sec = modtime;
158                 t[1].tv_usec = 0;
159                 return utimes(fname,t);
160 #endif
161         }
162 }
163
164
165 /**
166    Create any necessary directories in fname. Unfortunately we don't know
167    what perms to give the directory when this is called so we need to rely
168    on the umask
169 **/
170 int create_directory_path(char *fname, int base_umask)
171 {
172         char *p;
173
174         while (*fname == '/')
175                 fname++;
176         while (strncmp(fname, "./", 2) == 0)
177                 fname += 2;
178
179         p = fname;
180         while ((p = strchr(p,'/')) != NULL) {
181                 *p = 0;
182                 do_mkdir(fname, 0777 & ~base_umask);
183                 *p = '/';
184                 p++;
185         }
186         return 0;
187 }
188
189
190 /**
191  * Write @p len bytes at @p ptr to descriptor @p desc, retrying if
192  * interrupted.
193  *
194  * @retval len upon success
195  *
196  * @retval <0 write's (negative) error code
197  *
198  * Derived from GNU C's cccp.c.
199  */
200 int full_write(int desc, char *ptr, size_t len)
201 {
202         int total_written;
203
204         total_written = 0;
205         while (len > 0) {
206                 int written = write(desc, ptr, len);
207                 if (written < 0)  {
208                         if (errno == EINTR)
209                                 continue;
210                         return written;
211                 }
212                 total_written += written;
213                 ptr += written;
214                 len -= written;
215         }
216         return total_written;
217 }
218
219
220 /**
221  * Read @p len bytes at @p ptr from descriptor @p desc, retrying if
222  * interrupted.
223  *
224  * @retval >0 the actual number of bytes read
225  *
226  * @retval 0 for EOF
227  *
228  * @retval <0 for an error.
229  *
230  * Derived from GNU C's cccp.c. */
231 static int safe_read(int desc, char *ptr, size_t len)
232 {
233         int n_chars;
234
235         if (len == 0)
236                 return len;
237
238         do {
239                 n_chars = read(desc, ptr, len);
240         } while (n_chars < 0 && errno == EINTR);
241
242         return n_chars;
243 }
244
245
246 /** Copy a file.
247  *
248  * This is used in conjunction with the --temp-dir, --backup, and
249  * --copy-dest options. */
250 int copy_file(char *source, char *dest, mode_t mode)
251 {
252         int ifd;
253         int ofd;
254         char buf[1024 * 8];
255         int len;   /* Number of bytes read into `buf'. */
256
257         ifd = do_open(source, O_RDONLY, 0);
258         if (ifd == -1) {
259                 rsyserr(FERROR, errno, "open %s", full_fname(source));
260                 return -1;
261         }
262
263         if (robust_unlink(dest) && errno != ENOENT) {
264                 rsyserr(FERROR, errno, "unlink %s", full_fname(dest));
265                 return -1;
266         }
267
268         ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
269         if (ofd == -1) {
270                 rsyserr(FERROR, errno, "open %s", full_fname(dest));
271                 close(ifd);
272                 return -1;
273         }
274
275         while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
276                 if (full_write(ofd, buf, len) < 0) {
277                         rsyserr(FERROR, errno, "write %s", full_fname(dest));
278                         close(ifd);
279                         close(ofd);
280                         return -1;
281                 }
282         }
283
284         if (len < 0) {
285                 rsyserr(FERROR, errno, "read %s", full_fname(source));
286                 close(ifd);
287                 close(ofd);
288                 return -1;
289         }
290
291         if (close(ifd) < 0) {
292                 rsyserr(FINFO, errno, "close failed on %s",
293                         full_fname(source));
294         }
295
296         if (close(ofd) < 0) {
297                 rsyserr(FERROR, errno, "close failed on %s",
298                         full_fname(dest));
299                 return -1;
300         }
301
302         return 0;
303 }
304
305 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
306 #define MAX_RENAMES_DIGITS 3
307 #define MAX_RENAMES 1000
308
309 /**
310  * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
311  * rename to <path>/.rsyncNNN instead.
312  *
313  * Note that successive rsync runs will shuffle the filenames around a
314  * bit as long as the file is still busy; this is because this function
315  * does not know if the unlink call is due to a new file coming in, or
316  * --delete trying to remove old .rsyncNNN files, hence it renames it
317  * each time.
318  **/
319 int robust_unlink(char *fname)
320 {
321 #ifndef ETXTBSY
322         return do_unlink(fname);
323 #else
324         static int counter = 1;
325         int rc, pos, start;
326         char path[MAXPATHLEN];
327
328         rc = do_unlink(fname);
329         if (rc == 0 || errno != ETXTBSY)
330                 return rc;
331
332         if ((pos = strlcpy(path, fname, MAXPATHLEN)) >= MAXPATHLEN)
333                 pos = MAXPATHLEN - 1;
334
335         while (pos > 0 && path[pos-1] != '/')
336                 pos--;
337         pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);
338
339         if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
340                 errno = ETXTBSY;
341                 return -1;
342         }
343
344         /* start where the last one left off to reduce chance of clashes */
345         start = counter;
346         do {
347                 sprintf(&path[pos], "%03d", counter);
348                 if (++counter >= MAX_RENAMES)
349                         counter = 1;
350         } while ((rc = access(path, 0)) == 0 && counter != start);
351
352         if (verbose > 0) {
353                 rprintf(FINFO,"renaming %s to %s because of text busy\n",
354                         safe_fname(fname), safe_fname(path));
355         }
356
357         /* maybe we should return rename()'s exit status? Nah. */
358         if (do_rename(fname, path) != 0) {
359                 errno = ETXTBSY;
360                 return -1;
361         }
362         return 0;
363 #endif
364 }
365
366 /* Returns 0 on successful rename, 1 if we successfully copied the file
367  * across filesystems, -2 if copy_file() failed, and -1 on other errors. */
368 int robust_rename(char *from, char *to, int mode)
369 {
370         int tries = 4;
371
372         while (tries--) {
373                 if (do_rename(from, to) == 0)
374                         return 0;
375
376                 switch (errno) {
377 #ifdef ETXTBSY
378                 case ETXTBSY:
379                         if (robust_unlink(to) != 0)
380                                 return -1;
381                         break;
382 #endif
383                 case EXDEV:
384                         if (copy_file(from, to, mode) != 0)
385                                 return -2;
386                         do_unlink(from);
387                         return 1;
388                 default:
389                         return -1;
390                 }
391         }
392         return -1;
393 }
394
395
396 static pid_t all_pids[10];
397 static int num_pids;
398
399 /** Fork and record the pid of the child. **/
400 pid_t do_fork(void)
401 {
402         pid_t newpid = fork();
403
404         if (newpid != 0  &&  newpid != -1) {
405                 all_pids[num_pids++] = newpid;
406         }
407         return newpid;
408 }
409
410 /**
411  * Kill all children.
412  *
413  * @todo It would be kind of nice to make sure that they are actually
414  * all our children before we kill them, because their pids may have
415  * been recycled by some other process.  Perhaps when we wait for a
416  * child, we should remove it from this array.  Alternatively we could
417  * perhaps use process groups, but I think that would not work on
418  * ancient Unix versions that don't support them.
419  **/
420 void kill_all(int sig)
421 {
422         int i;
423
424         for (i = 0; i < num_pids; i++) {
425                 /* Let's just be a little careful where we
426                  * point that gun, hey?  See kill(2) for the
427                  * magic caused by negative values. */
428                 pid_t p = all_pids[i];
429
430                 if (p == getpid())
431                         continue;
432                 if (p <= 0)
433                         continue;
434
435                 kill(p, sig);
436         }
437 }
438
439
440 /** Turn a user name into a uid */
441 int name_to_uid(char *name, uid_t *uid)
442 {
443         struct passwd *pass;
444         if (!name || !*name)
445                 return 0;
446         pass = getpwnam(name);
447         if (pass) {
448                 *uid = pass->pw_uid;
449                 return 1;
450         }
451         return 0;
452 }
453
454 /** Turn a group name into a gid */
455 int name_to_gid(char *name, gid_t *gid)
456 {
457         struct group *grp;
458         if (!name || !*name)
459                 return 0;
460         grp = getgrnam(name);
461         if (grp) {
462                 *gid = grp->gr_gid;
463                 return 1;
464         }
465         return 0;
466 }
467
468
469 /** Lock a byte range in a open file */
470 int lock_range(int fd, int offset, int len)
471 {
472         struct flock lock;
473
474         lock.l_type = F_WRLCK;
475         lock.l_whence = SEEK_SET;
476         lock.l_start = offset;
477         lock.l_len = len;
478         lock.l_pid = 0;
479
480         return fcntl(fd,F_SETLK,&lock) == 0;
481 }
482
483 static int filter_server_path(char *arg)
484 {
485         char *s;
486
487         if (server_filter_list.head) {
488                 for (s = arg; (s = strchr(s, '/')) != NULL; ) {
489                         *s = '\0';
490                         if (check_filter(&server_filter_list, arg, 1) < 0) {
491                                 /* We must leave arg truncated! */
492                                 return 1;
493                         }
494                         *s++ = '/';
495                 }
496         }
497         return 0;
498 }
499
500 static void glob_expand_one(char *s, char ***argv_ptr, int *argc_ptr,
501                             int *maxargs_ptr)
502 {
503         char **argv = *argv_ptr;
504         int argc = *argc_ptr;
505         int maxargs = *maxargs_ptr;
506 #if !defined HAVE_GLOB || !defined HAVE_GLOB_H
507         if (argc == maxargs) {
508                 maxargs += MAX_ARGS;
509                 if (!(argv = realloc_array(argv, char *, maxargs)))
510                         out_of_memory("glob_expand_one");
511                 *argv_ptr = argv;
512                 *maxargs_ptr = maxargs;
513         }
514         if (!*s)
515                 s = ".";
516         s = argv[argc++] = strdup(s);
517         filter_server_path(s);
518 #else
519         glob_t globbuf;
520         int i;
521
522         if (maxargs <= argc)
523                 return;
524         if (!*s)
525                 s = ".";
526
527         if (sanitize_paths)
528                 s = sanitize_path(NULL, s, "", 0);
529         else
530                 s = strdup(s);
531
532         memset(&globbuf, 0, sizeof globbuf);
533         if (!filter_server_path(s))
534                 glob(s, 0, NULL, &globbuf);
535         if (MAX((int)globbuf.gl_pathc, 1) > maxargs - argc) {
536                 maxargs += globbuf.gl_pathc + MAX_ARGS;
537                 if (!(argv = realloc_array(argv, char *, maxargs)))
538                         out_of_memory("glob_expand_one");
539                 *argv_ptr = argv;
540                 *maxargs_ptr = maxargs;
541         }
542         if (globbuf.gl_pathc == 0)
543                 argv[argc++] = s;
544         else {
545                 int j = globbuf.gl_pathc;
546                 free(s);
547                 for (i = 0; i < j; i++) {
548                         if (!(argv[argc++] = strdup(globbuf.gl_pathv[i])))
549                                 out_of_memory("glob_expand_one");
550                 }
551         }
552         globfree(&globbuf);
553 #endif
554         *argc_ptr = argc;
555 }
556
557 /* This routine is only used in daemon mode. */
558 void glob_expand(char *base1, char ***argv_ptr, int *argc_ptr, int *maxargs_ptr)
559 {
560         char *s = (*argv_ptr)[*argc_ptr];
561         char *p, *q;
562         char *base = base1;
563         int base_len = strlen(base);
564
565         if (!s || !*s)
566                 return;
567
568         if (strncmp(s, base, base_len) == 0)
569                 s += base_len;
570
571         if (!(s = strdup(s)))
572                 out_of_memory("glob_expand");
573
574         if (asprintf(&base," %s/", base1) <= 0)
575                 out_of_memory("glob_expand");
576         base_len++;
577
578         for (q = s; *q; q = p + base_len) {
579                 if ((p = strstr(q, base)) != NULL)
580                         *p = '\0'; /* split it at this point */
581                 glob_expand_one(q, argv_ptr, argc_ptr, maxargs_ptr);
582                 if (!p)
583                         break;
584         }
585
586         free(s);
587         free(base);
588 }
589
590 /**
591  * Convert a string to lower case
592  **/
593 void strlower(char *s)
594 {
595         while (*s) {
596                 if (isupper(*(unsigned char *)s))
597                         *s = tolower(*(unsigned char *)s);
598                 s++;
599         }
600 }
601
602 /* Join strings p1 & p2 into "dest" with a guaranteed '/' between them.  (If
603  * p1 ends with a '/', no extra '/' is inserted.)  Returns the length of both
604  * strings + 1 (if '/' was inserted), regardless of whether the null-terminated
605  * string fits into destsize. */
606 size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)
607 {
608         size_t len = strlcpy(dest, p1, destsize);
609         if (len < destsize - 1) {
610                 if (!len || dest[len-1] != '/')
611                         dest[len++] = '/';
612                 if (len < destsize - 1)
613                         len += strlcpy(dest + len, p2, destsize - len);
614                 else {
615                         dest[len] = '\0';
616                         len += strlen(p2);
617                 }
618         }
619         else
620                 len += strlen(p2) + 1; /* Assume we'd insert a '/'. */
621         return len;
622 }
623
624 /* Join any number of strings together, putting them in "dest".  The return
625  * value is the length of all the strings, regardless of whether the null-
626  * terminated whole fits in destsize.  Your list of string pointers must end
627  * with a NULL to indicate the end of the list. */
628 size_t stringjoin(char *dest, size_t destsize, ...)
629 {
630         va_list ap;
631         size_t len, ret = 0;
632         const char *src;
633
634         va_start(ap, destsize);
635         while (1) {
636                 if (!(src = va_arg(ap, const char *)))
637                         break;
638                 len = strlen(src);
639                 ret += len;
640                 if (destsize > 1) {
641                         if (len >= destsize)
642                                 len = destsize - 1;
643                         memcpy(dest, src, len);
644                         destsize -= len;
645                         dest += len;
646                 }
647         }
648         *dest = '\0';
649         va_end(ap);
650
651         return ret;
652 }
653
654 int count_dir_elements(const char *p)
655 {
656         int cnt = 0, new_component = 1;
657         while (*p) {
658                 if (*p++ == '/')
659                         new_component = 1;
660                 else if (new_component) {
661                         new_component = 0;
662                         cnt++;
663                 }
664         }
665         return cnt;
666 }
667
668 /* Turns multiple adjacent slashes into a single slash, gets rid of "./"
669  * elements (but not a trailing dot dir), removes a trailing slash, and
670  * optionally collapses ".." elements (except for those at the start of the
671  * string).  If the resulting name would be empty, change it into a ".". */
672 unsigned int clean_fname(char *name, BOOL collapse_dot_dot)
673 {
674         char *limit = name - 1, *t = name, *f = name;
675         int anchored;
676
677         if (!name)
678                 return 0;
679
680         if ((anchored = *f == '/') != 0)
681                 *t++ = *f++;
682         while (*f) {
683                 /* discard extra slashes */
684                 if (*f == '/') {
685                         f++;
686                         continue;
687                 }
688                 if (*f == '.') {
689                         /* discard "." dirs (but NOT a trailing '.'!) */
690                         if (f[1] == '/') {
691                                 f += 2;
692                                 continue;
693                         }
694                         /* collapse ".." dirs */
695                         if (collapse_dot_dot
696                             && f[1] == '.' && (f[2] == '/' || !f[2])) {
697                                 char *s = t - 1;
698                                 if (s == name && anchored) {
699                                         f += 2;
700                                         continue;
701                                 }
702                                 while (s > limit && *--s != '/') {}
703                                 if (s != t - 1 && (s < name || *s == '/')) {
704                                         t = s + 1;
705                                         f += 2;
706                                         continue;
707                                 }
708                                 limit = t + 2;
709                         }
710                 }
711                 while (*f && (*t++ = *f++) != '/') {}
712         }
713
714         if (t > name+anchored && t[-1] == '/')
715                 t--;
716         if (t == name)
717                 *t++ = '.';
718         *t = '\0';
719
720         return t - name;
721 }
722
723 /* Make path appear as if a chroot had occurred.  This handles a leading
724  * "/" (either removing it or expanding it) and any leading or embedded
725  * ".." components that attempt to escape past the module's top dir.
726  *
727  * If dest is NULL, a buffer is allocated to hold the result.  It is legal
728  * to call with the dest and the path (p) pointing to the same buffer, but
729  * rootdir will be ignored to avoid expansion of the string.
730  *
731  * The rootdir string contains a value to use in place of a leading slash.
732  * Specify NULL to get the default of lp_path(module_id).
733  *
734  * If depth is >= 0, it is a count of how many '..'s to allow at the start
735  * of the path.  Use -1 to allow unlimited depth.
736  *
737  * We also clean the path in a manner similar to clean_fname() but with a
738  * few differences: 
739  *
740  * Turns multiple adjacent slashes into a single slash, gets rid of "." dir
741  * elements (INCLUDING a trailing dot dir), PRESERVES a trailing slash, and
742  * ALWAYS collapses ".." elements (except for those at the start of the
743  * string up to "depth" deep).  If the resulting name would be empty,
744  * change it into a ".". */
745 char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth)
746 {
747         char *start, *sanp;
748         int rlen = 0;
749
750         if (dest != p) {
751                 int plen = strlen(p);
752                 if (*p == '/') {
753                         if (!rootdir)
754                                 rootdir = lp_path(module_id);
755                         rlen = strlen(rootdir);
756                         depth = 0;
757                         p++;
758                 }
759                 if (dest) {
760                         if (rlen + plen + 1 >= MAXPATHLEN)
761                                 return NULL;
762                 } else if (!(dest = new_array(char, rlen + plen + 1)))
763                         out_of_memory("sanitize_path");
764                 if (rlen) {
765                         memcpy(dest, rootdir, rlen);
766                         if (rlen > 1)
767                                 dest[rlen++] = '/';
768                 }
769         }
770
771         start = sanp = dest + rlen;
772         while (*p != '\0') {
773                 /* discard leading or extra slashes */
774                 if (*p == '/') {
775                         p++;
776                         continue;
777                 }
778                 /* this loop iterates once per filename component in p.
779                  * both p (and sanp if the original had a slash) should
780                  * always be left pointing after a slash
781                  */
782                 if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {
783                         /* skip "." component */
784                         p++;
785                         continue;
786                 }
787                 if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
788                         /* ".." component followed by slash or end */
789                         if (depth <= 0 || sanp != start) {
790                                 p += 2;
791                                 if (sanp != start) {
792                                         /* back up sanp one level */
793                                         --sanp; /* now pointing at slash */
794                                         while (sanp > start && sanp[-1] != '/') {
795                                                 /* skip back up to slash */
796                                                 sanp--;
797                                         }
798                                 }
799                                 continue;
800                         }
801                         /* allow depth levels of .. at the beginning */
802                         depth--;
803                         /* move the virtual beginning to leave the .. alone */
804                         start = sanp + 3;
805                 }
806                 /* copy one component through next slash */
807                 while (*p && (*sanp++ = *p++) != '/') {}
808         }
809         if (sanp == dest) {
810                 /* ended up with nothing, so put in "." component */
811                 *sanp++ = '.';
812         }
813         *sanp = '\0';
814
815         return dest;
816 }
817
818 char curr_dir[MAXPATHLEN];
819 unsigned int curr_dir_len;
820
821 /**
822  * Like chdir(), but it keeps track of the current directory (in the
823  * global "curr_dir"), and ensures that the path size doesn't overflow.
824  * Also cleans the path using the clean_fname() function.
825  **/
826 int push_dir(char *dir)
827 {
828         static int initialised;
829         unsigned int len;
830
831         if (!initialised) {
832                 initialised = 1;
833                 getcwd(curr_dir, sizeof curr_dir - 1);
834                 curr_dir_len = strlen(curr_dir);
835         }
836
837         if (!dir)       /* this call was probably just to initialize */
838                 return 0;
839
840         len = strlen(dir);
841         if (len == 1 && *dir == '.')
842                 return 1;
843
844         if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
845                 return 0;
846
847         if (chdir(dir))
848                 return 0;
849
850         if (*dir == '/') {
851                 memcpy(curr_dir, dir, len + 1);
852                 curr_dir_len = len;
853         } else {
854                 curr_dir[curr_dir_len++] = '/';
855                 memcpy(curr_dir + curr_dir_len, dir, len + 1);
856                 curr_dir_len += len;
857         }
858
859         curr_dir_len = clean_fname(curr_dir, 1);
860
861         return 1;
862 }
863
864 /**
865  * Reverse a push_dir() call.  You must pass in an absolute path
866  * that was copied from a prior value of "curr_dir".
867  **/
868 int pop_dir(char *dir)
869 {
870         if (chdir(dir))
871                 return 0;
872
873         curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
874         if (curr_dir_len >= sizeof curr_dir)
875                 curr_dir_len = sizeof curr_dir - 1;
876
877         return 1;
878 }
879
880 /* Return the filename, turning any non-printable characters into escaped
881  * characters (e.g. \n -> \012, \ -> \\).  This ensures that outputting it
882  * cannot generate an empty line nor corrupt the screen.  This function can
883  * return only MAX_SAFE_NAMES values at a time!  The returned value can be
884  * longer than MAXPATHLEN (because we may be trying to output an error about
885  * a too-long filename)! */
886 char *safe_fname(const char *fname)
887 {
888 #define MAX_SAFE_NAMES 4
889         static char fbuf[MAX_SAFE_NAMES][MAXPATHLEN*2];
890         static int ndx = 0;
891         int limit = sizeof fbuf / MAX_SAFE_NAMES - 1;
892         char *t;
893
894         ndx = (ndx + 1) % MAX_SAFE_NAMES;
895         for (t = fbuf[ndx]; *fname && limit; fname++) {
896                 if (*fname == '\\') {
897                         if ((limit -= 2) < 0)
898                                 break;
899                         *t++ = '\\';
900                         *t++ = '\\';
901                 } else if (!isprint(*(uchar*)fname)) {
902                         if ((limit -= 4) < 0)
903                                 break;
904                         sprintf(t, "\\%03o", *(uchar*)fname);
905                         t += 4;
906                 } else {
907                         limit--;
908                         *t++ = *fname;
909                 }
910         }
911         *t = '\0';
912
913         return fbuf[ndx];
914 }
915
916 /**
917  * Return a quoted string with the full pathname of the indicated filename.
918  * The string " (in MODNAME)" may also be appended.  The returned pointer
919  * remains valid until the next time full_fname() is called.
920  **/
921 char *full_fname(const char *fn)
922 {
923         static char *result = NULL;
924         char *m1, *m2, *m3;
925         char *p1, *p2;
926
927         if (result)
928                 free(result);
929
930         fn = safe_fname(fn);
931         if (*fn == '/')
932                 p1 = p2 = "";
933         else {
934                 p1 = curr_dir;
935                 for (p2 = p1; *p2 == '/'; p2++) {}
936                 if (*p2)
937                         p2 = "/";
938         }
939         if (module_id >= 0) {
940                 m1 = " (in ";
941                 m2 = lp_name(module_id);
942                 m3 = ")";
943                 if (p1 == curr_dir) {
944                         if (!lp_use_chroot(module_id)) {
945                                 char *p = lp_path(module_id);
946                                 if (*p != '/' || p[1])
947                                         p1 += strlen(p);
948                         }
949                 }
950         } else
951                 m1 = m2 = m3 = "";
952
953         asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
954
955         return result;
956 }
957
958 static char partial_fname[MAXPATHLEN];
959
960 char *partial_dir_fname(const char *fname)
961 {
962         char *t = partial_fname;
963         int sz = sizeof partial_fname;
964         const char *fn;
965
966         if ((fn = strrchr(fname, '/')) != NULL) {
967                 fn++;
968                 if (*partial_dir != '/') {
969                         int len = fn - fname;
970                         strncpy(t, fname, len); /* safe */
971                         t += len;
972                         sz -= len;
973                 }
974         } else
975                 fn = fname;
976         if ((int)pathjoin(t, sz, partial_dir, fn) >= sz)
977                 return NULL;
978         if (server_filter_list.head) {
979                 static int len;
980                 if (!len)
981                         len = strlen(partial_dir);
982                 t[len] = '\0';
983                 if (check_filter(&server_filter_list, partial_fname, 1) < 0)
984                         return NULL;
985                 t[len] = '/';
986                 if (check_filter(&server_filter_list, partial_fname, 0) < 0)
987                         return NULL;
988         }
989
990         return partial_fname;
991 }
992
993 /* If no --partial-dir option was specified, we don't need to do anything
994  * (the partial-dir is essentially '.'), so just return success. */
995 int handle_partial_dir(const char *fname, int create)
996 {
997         char *fn, *dir;
998
999         if (fname != partial_fname)
1000                 return 1;
1001         if (!create && *partial_dir == '/')
1002                 return 1;
1003         if (!(fn = strrchr(partial_fname, '/')))
1004                 return 1;
1005
1006         *fn = '\0';
1007         dir = partial_fname;
1008         if (create) {
1009                 STRUCT_STAT st;
1010                 int statret = do_lstat(dir, &st);
1011                 if (statret == 0 && !S_ISDIR(st.st_mode)) {
1012                         if (do_unlink(dir) < 0)
1013                                 return 0;
1014                         statret = -1;
1015                 }
1016                 if (statret < 0 && do_mkdir(dir, 0700) < 0)
1017                         return 0;
1018         } else
1019                 do_rmdir(dir);
1020         *fn = '/';
1021
1022         return 1;
1023 }
1024
1025 /** We need to supply our own strcmp function for file list comparisons
1026    to ensure that signed/unsigned usage is consistent between machines. */
1027 int u_strcmp(const char *cs1, const char *cs2)
1028 {
1029         const uchar *s1 = (const uchar *)cs1;
1030         const uchar *s2 = (const uchar *)cs2;
1031
1032         while (*s1 && *s2 && (*s1 == *s2)) {
1033                 s1++; s2++;
1034         }
1035
1036         return (int)*s1 - (int)*s2;
1037 }
1038
1039
1040
1041 /**
1042  * Determine if a symlink points outside the current directory tree.
1043  * This is considered "unsafe" because e.g. when mirroring somebody
1044  * else's machine it might allow them to establish a symlink to
1045  * /etc/passwd, and then read it through a web server.
1046  *
1047  * Null symlinks and absolute symlinks are always unsafe.
1048  *
1049  * Basically here we are concerned with symlinks whose target contains
1050  * "..", because this might cause us to walk back up out of the
1051  * transferred directory.  We are not allowed to go back up and
1052  * reenter.
1053  *
1054  * @param dest Target of the symlink in question.
1055  *
1056  * @param src Top source directory currently applicable.  Basically this
1057  * is the first parameter to rsync in a simple invocation, but it's
1058  * modified by flist.c in slightly complex ways.
1059  *
1060  * @retval True if unsafe
1061  * @retval False is unsafe
1062  *
1063  * @sa t_unsafe.c
1064  **/
1065 int unsafe_symlink(const char *dest, const char *src)
1066 {
1067         const char *name, *slash;
1068         int depth = 0;
1069
1070         /* all absolute and null symlinks are unsafe */
1071         if (!dest || !*dest || *dest == '/')
1072                 return 1;
1073
1074         /* find out what our safety margin is */
1075         for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
1076                 if (strncmp(name, "../", 3) == 0) {
1077                         depth = 0;
1078                 } else if (strncmp(name, "./", 2) == 0) {
1079                         /* nothing */
1080                 } else {
1081                         depth++;
1082                 }
1083         }
1084         if (strcmp(name, "..") == 0)
1085                 depth = 0;
1086
1087         for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
1088                 if (strncmp(name, "../", 3) == 0) {
1089                         /* if at any point we go outside the current directory
1090                            then stop - it is unsafe */
1091                         if (--depth < 0)
1092                                 return 1;
1093                 } else if (strncmp(name, "./", 2) == 0) {
1094                         /* nothing */
1095                 } else {
1096                         depth++;
1097                 }
1098         }
1099         if (strcmp(name, "..") == 0)
1100                 depth--;
1101
1102         return (depth < 0);
1103 }
1104
1105
1106 /**
1107  * Return the date and time as a string
1108  **/
1109 char *timestring(time_t t)
1110 {
1111         static char TimeBuf[200];
1112         struct tm *tm = localtime(&t);
1113
1114 #ifdef HAVE_STRFTIME
1115         strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1116 #else
1117         strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1118 #endif
1119
1120         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1121                 TimeBuf[strlen(TimeBuf)-1] = 0;
1122         }
1123
1124         return(TimeBuf);
1125 }
1126
1127
1128 /**
1129  * Sleep for a specified number of milliseconds.
1130  *
1131  * Always returns TRUE.  (In the future it might return FALSE if
1132  * interrupted.)
1133  **/
1134 int msleep(int t)
1135 {
1136         int tdiff = 0;
1137         struct timeval tval, t1, t2;
1138
1139         gettimeofday(&t1, NULL);
1140
1141         while (tdiff < t) {
1142                 tval.tv_sec = (t-tdiff)/1000;
1143                 tval.tv_usec = 1000*((t-tdiff)%1000);
1144
1145                 errno = 0;
1146                 select(0,NULL,NULL, NULL, &tval);
1147
1148                 gettimeofday(&t2, NULL);
1149                 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1150                         (t2.tv_usec - t1.tv_usec)/1000;
1151         }
1152
1153         return True;
1154 }
1155
1156
1157 /**
1158  * Determine if two file modification times are equivalent (either
1159  * exact or in the modification timestamp window established by
1160  * --modify-window).
1161  *
1162  * @retval 0 if the times should be treated as the same
1163  *
1164  * @retval +1 if the first is later
1165  *
1166  * @retval -1 if the 2nd is later
1167  **/
1168 int cmp_modtime(time_t file1, time_t file2)
1169 {
1170         if (file2 > file1) {
1171                 if (file2 - file1 <= modify_window)
1172                         return 0;
1173                 return -1;
1174         }
1175         if (file1 - file2 <= modify_window)
1176                 return 0;
1177         return 1;
1178 }
1179
1180
1181 #ifdef __INSURE__XX
1182 #include <dlfcn.h>
1183
1184 /**
1185    This routine is a trick to immediately catch errors when debugging
1186    with insure. A xterm with a gdb is popped up when insure catches
1187    a error. It is Linux specific.
1188 **/
1189 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1190 {
1191         static int (*fn)();
1192         int ret;
1193         char *cmd;
1194
1195         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'",
1196                 getpid(), getpid(), getpid());
1197
1198         if (!fn) {
1199                 static void *h;
1200                 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1201                 fn = dlsym(h, "_Insure_trap_error");
1202         }
1203
1204         ret = fn(a1, a2, a3, a4, a5, a6);
1205
1206         system(cmd);
1207
1208         free(cmd);
1209
1210         return ret;
1211 }
1212 #endif
1213
1214
1215 #define MALLOC_MAX 0x40000000
1216
1217 void *_new_array(unsigned int size, unsigned long num)
1218 {
1219         if (num >= MALLOC_MAX/size)
1220                 return NULL;
1221         return malloc(size * num);
1222 }
1223
1224 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1225 {
1226         if (num >= MALLOC_MAX/size)
1227                 return NULL;
1228         /* No realloc should need this, but just in case... */
1229         if (!ptr)
1230                 return malloc(size * num);
1231         return realloc(ptr, size * num);
1232 }
1233
1234 /* Take a filename and filename length and return the most significant
1235  * filename suffix we can find.  This ignores suffixes such as "~",
1236  * ".bak", ".orig", ".~1~", etc. */
1237 const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr)
1238 {
1239         const char *suf, *s;
1240         BOOL had_tilde;
1241         int s_len;
1242
1243         /* One or more dots at the start aren't a suffix. */
1244         while (fn_len && *fn == '.') fn++, fn_len--;
1245
1246         /* Ignore the ~ in a "foo~" filename. */
1247         if (fn_len > 1 && fn[fn_len-1] == '~')
1248                 fn_len--, had_tilde = True;
1249         else
1250                 had_tilde = False;
1251
1252         /* Assume we don't find an suffix. */
1253         suf = "";
1254         *len_ptr = 0;
1255
1256         /* Find the last significant suffix. */
1257         for (s = fn + fn_len; fn_len > 1; ) {
1258                 while (*--s != '.' && s != fn) {}
1259                 if (s == fn)
1260                         break;
1261                 s_len = fn_len - (s - fn);
1262                 fn_len = s - fn;
1263                 if (s_len == 4) {
1264                         if (strcmp(s+1, "bak") == 0
1265                          || strcmp(s+1, "old") == 0)
1266                                 continue;
1267                 } else if (s_len == 5) {
1268                         if (strcmp(s+1, "orig") == 0)
1269                                 continue;
1270                 } else if (s_len > 2 && had_tilde
1271                     && s[1] == '~' && isdigit(*(uchar*)(s+2)))
1272                         continue;
1273                 *len_ptr = s_len;
1274                 suf = s;
1275                 if (s_len == 1)
1276                         break;
1277                 /* Determine if the suffix is all digits. */
1278                 for (s++, s_len--; s_len > 0; s++, s_len--) {
1279                         if (!isdigit(*(uchar*)s))
1280                                 return suf;
1281                 }
1282                 /* An all-digit suffix may not be that signficant. */
1283                 s = suf;
1284         }
1285
1286         return suf;
1287 }
1288
1289 /* This is an implementation of the Levenshtein distance algorithm.  It
1290  * was implemented to avoid needing a two-dimensional matrix (to save
1291  * memory).  It was also tweaked to try to factor in the ASCII distance
1292  * between changed characters as a minor distance quantity.  The normal
1293  * Levenshtein units of distance (each signifying a single change between
1294  * the two strings) are defined as a "UNIT". */
1295
1296 #define UNIT (1 << 16)
1297
1298 uint32 fuzzy_distance(const char *s1, int len1, const char *s2, int len2)
1299 {
1300         uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
1301         int32 cost;
1302         int i1, i2;
1303
1304         if (!len1 || !len2) {
1305                 if (!len1) {
1306                         s1 = s2;
1307                         len1 = len2;
1308                 }
1309                 for (i1 = 0, cost = 0; i1 < len1; i1++)
1310                         cost += s1[i1];
1311                 return (int32)len1 * UNIT + cost;
1312         }
1313
1314         for (i2 = 0; i2 < len2; i2++)
1315                 a[i2] = (i2+1) * UNIT;
1316
1317         for (i1 = 0; i1 < len1; i1++) {
1318                 diag = i1 * UNIT;
1319                 above = (i1+1) * UNIT;
1320                 for (i2 = 0; i2 < len2; i2++) {
1321                         left = a[i2];
1322                         if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
1323                                 if (cost < 0)
1324                                         cost = UNIT - cost;
1325                                 else
1326                                         cost = UNIT + cost;
1327                         }
1328                         diag_inc = diag + cost;
1329                         left_inc = left + UNIT + *((uchar*)s1+i1);
1330                         above_inc = above + UNIT + *((uchar*)s2+i2);
1331                         a[i2] = above = left < above
1332                               ? (left_inc < diag_inc ? left_inc : diag_inc)
1333                               : (above_inc < diag_inc ? above_inc : diag_inc);
1334                         diag = left;
1335                 }
1336         }
1337
1338         return a[len2-1];
1339 }