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         else
 792                 rlen = 0;
 793         if (!(buf = new_array(char, rlen + plen + 1)))
 794                 out_of_memory("alloc_sanitize_path");
 795         if (rlen)
 796                 memcpy(buf, rootdir, rlen);
 797         memcpy(buf + rlen, path, plen + 1);
 798
 799         if (rlen)
 800                 rlen++;
 801         sanitize_path(buf + rlen, NULL);
 802         if (rlen && buf[rlen] == '.' && buf[rlen+1] == '\0')
 803                 buf[rlen-1] = '\0';
 804
 805         return buf;
 806 }
 807
 808 char curr_dir[MAXPATHLEN];
 809 unsigned int curr_dir_len;
 810
 811 /**
 812  * Like chdir(), but it keeps track of the current directory (in the
 813  * global "curr_dir"), and ensures that the path size doesn't overflow.
 814  * Also cleans the path using the clean_fname() function.
 815  **/
 816 int push_dir(char *dir)
 817 {
 818         static int initialised;
 819         unsigned int len;
 820
 821         if (!initialised) {
 822                 initialised = 1;
 823                 getcwd(curr_dir, sizeof curr_dir - 1);
 824                 curr_dir_len = strlen(curr_dir);
 825         }
 826
 827         if (!dir)       /* this call was probably just to initialize */
 828                 return 0;
 829
 830         len = strlen(dir);
 831         if (len == 1 && *dir == '.')
 832                 return 1;
 833
 834         if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
 835                 return 0;
 836
 837         if (chdir(dir))
 838                 return 0;
 839
 840         if (*dir == '/') {
 841                 memcpy(curr_dir, dir, len + 1);
 842                 curr_dir_len = len;
 843         } else {
 844                 curr_dir[curr_dir_len++] = '/';
 845                 memcpy(curr_dir + curr_dir_len, dir, len + 1);
 846                 curr_dir_len += len;
 847         }
 848
 849         clean_fname(curr_dir);
 850
 851         return 1;
 852 }
 853
 854 /**
 855  * Reverse a push_dir() call.  You must pass in an absolute path
 856  * that was copied from a prior value of "curr_dir".
 857  **/
 858 int pop_dir(char *dir)
 859 {
 860         if (chdir(dir))
 861                 return 0;
 862
 863         curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
 864         if (curr_dir_len >= sizeof curr_dir)
 865                 curr_dir_len = sizeof curr_dir - 1;
 866
 867         return 1;
 868 }
 869
 870 /**
 871  * Return a quoted string with the full pathname of the indicated filename.
 872  * The string " (in MODNAME)" may also be appended.  The returned pointer
 873  * remains valid until the next time full_fname() is called.
 874  **/
 875 char *full_fname(char *fn)
 876 {
 877         extern int module_id;
 878         static char *result = NULL;
 879         char *m1, *m2, *m3;
 880         char *p1, *p2;
 881
 882         if (result)
 883                 free(result);
 884
 885         if (*fn == '/')
 886                 p1 = p2 = "";
 887         else {
 888                 p1 = curr_dir;
 889                 p2 = "/";
 890         }
 891         if (module_id >= 0) {
 892                 m1 = " (in ";
 893                 m2 = lp_name(module_id);
 894                 m3 = ")";
 895                 if (*p1) {
 896                         if (!lp_use_chroot(module_id)) {
 897                                 char *p = lp_path(module_id);
 898                                 if (*p != '/' || p[1])
 899                                         p1 += strlen(p);
 900                         }
 901                         if (!*p1)
 902                                 p2++;
 903                         else
 904                                 p1++;
 905                 }
 906                 else
 907                         fn++;
 908         } else
 909                 m1 = m2 = m3 = "";
 910
 911         asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
 912
 913         return result;
 914 }
 915
 916 /** We need to supply our own strcmp function for file list comparisons
 917    to ensure that signed/unsigned usage is consistent between machines. */
 918 int u_strcmp(const char *cs1, const char *cs2)
 919 {
 920         const uchar *s1 = (const uchar *)cs1;
 921         const uchar *s2 = (const uchar *)cs2;
 922
 923         while (*s1 && *s2 && (*s1 == *s2)) {
 924                 s1++; s2++;
 925         }
 926
 927         return (int)*s1 - (int)*s2;
 928 }
 929
 930
 931
 932 /**
 933  * Determine if a symlink points outside the current directory tree.
 934  * This is considered "unsafe" because e.g. when mirroring somebody
 935  * else's machine it might allow them to establish a symlink to
 936  * /etc/passwd, and then read it through a web server.
 937  *
 938  * Null symlinks and absolute symlinks are always unsafe.
 939  *
 940  * Basically here we are concerned with symlinks whose target contains
 941  * "..", because this might cause us to walk back up out of the
 942  * transferred directory.  We are not allowed to go back up and
 943  * reenter.
 944  *
 945  * @param dest Target of the symlink in question.
 946  *
 947  * @param src Top source directory currently applicable.  Basically this
 948  * is the first parameter to rsync in a simple invocation, but it's
 949  * modified by flist.c in slightly complex ways.
 950  *
 951  * @retval True if unsafe
 952  * @retval False is unsafe
 953  *
 954  * @sa t_unsafe.c
 955  **/
 956 int unsafe_symlink(const char *dest, const char *src)
 957 {
 958         const char *name, *slash;
 959         int depth = 0;
 960
 961         /* all absolute and null symlinks are unsafe */
 962         if (!dest || !*dest || *dest == '/') return 1;
 963
 964         /* find out what our safety margin is */
 965         for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
 966                 if (strncmp(name, "../", 3) == 0) {
 967                         depth = 0;
 968                 } else if (strncmp(name, "./", 2) == 0) {
 969                         /* nothing */
 970                 } else {
 971                         depth++;
 972                 }
 973         }
 974         if (strcmp(name, "..") == 0)
 975                 depth = 0;
 976
 977         for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
 978                 if (strncmp(name, "../", 3) == 0) {
 979                         /* if at any point we go outside the current directory
 980                            then stop - it is unsafe */
 981                         if (--depth < 0)
 982                                 return 1;
 983                 } else if (strncmp(name, "./", 2) == 0) {
 984                         /* nothing */
 985                 } else {
 986                         depth++;
 987                 }
 988         }
 989         if (strcmp(name, "..") == 0)
 990                 depth--;
 991
 992         return (depth < 0);
 993 }
 994
 995
 996 /**
 997  * Return the date and time as a string
 998  **/
 999 char *timestring(time_t t)
1000 {
1001         static char TimeBuf[200];
1002         struct tm *tm = localtime(&t);
1003
1004 #ifdef HAVE_STRFTIME
1005         strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1006 #else
1007         strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1008 #endif
1009
1010         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1011                 TimeBuf[strlen(TimeBuf)-1] = 0;
1012         }
1013
1014         return(TimeBuf);
1015 }
1016
1017
1018 /**
1019  * Sleep for a specified number of milliseconds.
1020  *
1021  * Always returns TRUE.  (In the future it might return FALSE if
1022  * interrupted.)
1023  **/
1024 int msleep(int t)
1025 {
1026         int tdiff = 0;
1027         struct timeval tval, t1, t2;
1028
1029         gettimeofday(&t1, NULL);
1030         gettimeofday(&t2, NULL);
1031
1032         while (tdiff < t) {
1033                 tval.tv_sec = (t-tdiff)/1000;
1034                 tval.tv_usec = 1000*((t-tdiff)%1000);
1035
1036                 errno = 0;
1037                 select(0,NULL,NULL, NULL, &tval);
1038
1039                 gettimeofday(&t2, NULL);
1040                 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1041                         (t2.tv_usec - t1.tv_usec)/1000;
1042         }
1043
1044         return True;
1045 }
1046
1047
1048 /**
1049  * Determine if two file modification times are equivalent (either
1050  * exact or in the modification timestamp window established by
1051  * --modify-window).
1052  *
1053  * @retval 0 if the times should be treated as the same
1054  *
1055  * @retval +1 if the first is later
1056  *
1057  * @retval -1 if the 2nd is later
1058  **/
1059 int cmp_modtime(time_t file1, time_t file2)
1060 {
1061         extern int modify_window;
1062
1063         if (file2 > file1) {
1064                 if (file2 - file1 <= modify_window) return 0;
1065                 return -1;
1066         }
1067         if (file1 - file2 <= modify_window) return 0;
1068         return 1;
1069 }
1070
1071
1072 #ifdef __INSURE__XX
1073 #include <dlfcn.h>
1074
1075 /**
1076    This routine is a trick to immediately catch errors when debugging
1077    with insure. A xterm with a gdb is popped up when insure catches
1078    a error. It is Linux specific.
1079 **/
1080 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1081 {
1082         static int (*fn)();
1083         int ret;
1084         char *cmd;
1085
1086         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'",
1087                 getpid(), getpid(), getpid());
1088
1089         if (!fn) {
1090                 static void *h;
1091                 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1092                 fn = dlsym(h, "_Insure_trap_error");
1093         }
1094
1095         ret = fn(a1, a2, a3, a4, a5, a6);
1096
1097         system(cmd);
1098
1099         free(cmd);
1100
1101         return ret;
1102 }
1103 #endif
1104
1105
1106 #define MALLOC_MAX 0x40000000
1107
1108 void *_new_array(unsigned int size, unsigned long num)
1109 {
1110         if (num >= MALLOC_MAX/size)
1111                 return NULL;
1112         return malloc(size * num);
1113 }
1114
1115 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1116 {
1117         if (num >= MALLOC_MAX/size)
1118                 return NULL;
1119         /* No realloc should need this, but just in case... */
1120         if (!ptr)
1121                 return malloc(size * num);
1122         return realloc(ptr, size * num);
1123 }