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