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