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
  32 int sanitize_paths = 0;
  33
  34
  35
  36 /**
  37  * Set a fd into nonblocking mode
  38  **/
  39 void set_nonblocking(int fd)
  40 {
  41         int val;
  42
  43         if ((val = fcntl(fd, F_GETFL, 0)) == -1)
  44                 return;
  45         if (!(val & NONBLOCK_FLAG)) {
  46                 val |= NONBLOCK_FLAG;
  47                 fcntl(fd, F_SETFL, val);
  48         }
  49 }
  50
  51 /**
  52  * Set a fd into blocking mode
  53  **/
  54 void set_blocking(int fd)
  55 {
  56         int val;
  57
  58         if ((val = fcntl(fd, F_GETFL, 0)) == -1)
  59                 return;
  60         if (val & NONBLOCK_FLAG) {
  61                 val &= ~NONBLOCK_FLAG;
  62                 fcntl(fd, F_SETFL, val);
  63         }
  64 }
  65
  66
  67 /**
  68  * Create a file descriptor pair - like pipe() but use socketpair if
  69  * possible (because of blocking issues on pipes).
  70  *
  71  * Always set non-blocking.
  72  */
  73 int fd_pair(int fd[2])
  74 {
  75         int ret;
  76
  77 #if HAVE_SOCKETPAIR
  78         ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
  79 #else
  80         ret = pipe(fd);
  81 #endif
  82
  83         if (ret == 0) {
  84                 set_nonblocking(fd[0]);
  85                 set_nonblocking(fd[1]);
  86         }
  87
  88         return ret;
  89 }
  90
  91
  92 void print_child_argv(char **cmd)
  93 {
  94         rprintf(FINFO, "opening connection using ");
  95         for (; *cmd; cmd++) {
  96                 /* Look for characters that ought to be quoted.  This
  97                 * is not a great quoting algorithm, but it's
  98                 * sufficient for a log message. */
  99                 if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
 100                            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 101                            "0123456789"
 102                            ",.-_=+@/") != strlen(*cmd)) {
 103                         rprintf(FINFO, "\"%s\" ", *cmd);
 104                 } else {
 105                         rprintf(FINFO, "%s ", *cmd);
 106                 }
 107         }
 108         rprintf(FINFO, "\n");
 109 }
 110
 111
 112 void out_of_memory(char *str)
 113 {
 114         rprintf(FERROR, "ERROR: out of memory in %s\n", str);
 115         exit_cleanup(RERR_MALLOC);
 116 }
 117
 118 void overflow(char *str)
 119 {
 120         rprintf(FERROR, "ERROR: buffer overflow in %s\n", str);
 121         exit_cleanup(RERR_MALLOC);
 122 }
 123
 124
 125
 126 int set_modtime(char *fname, time_t modtime)
 127 {
 128         extern int dry_run;
 129         if (dry_run)
 130                 return 0;
 131
 132         if (verbose > 2) {
 133                 rprintf(FINFO, "set modtime of %s to (%ld) %s",
 134                         fname, (long) modtime,
 135                         asctime(localtime(&modtime)));
 136         }
 137
 138         {
 139 #ifdef HAVE_UTIMBUF
 140                 struct utimbuf tbuf;
 141                 tbuf.actime = time(NULL);
 142                 tbuf.modtime = modtime;
 143                 return utime(fname,&tbuf);
 144 #elif defined(HAVE_UTIME)
 145                 time_t t[2];
 146                 t[0] = time(NULL);
 147                 t[1] = modtime;
 148                 return utime(fname,t);
 149 #else
 150                 struct timeval t[2];
 151                 t[0].tv_sec = time(NULL);
 152                 t[0].tv_usec = 0;
 153                 t[1].tv_sec = modtime;
 154                 t[1].tv_usec = 0;
 155                 return utimes(fname,t);
 156 #endif
 157         }
 158 }
 159
 160
 161 /**
 162    Create any necessary directories in fname. Unfortunately we don't know
 163    what perms to give the directory when this is called so we need to rely
 164    on the umask
 165 **/
 166 int create_directory_path(char *fname, int base_umask)
 167 {
 168         char *p;
 169
 170         while (*fname == '/')
 171                 fname++;
 172         while (strncmp(fname, "./", 2) == 0)
 173                 fname += 2;
 174
 175         p = fname;
 176         while ((p = strchr(p,'/')) != NULL) {
 177                 *p = 0;
 178                 do_mkdir(fname, 0777 & ~base_umask);
 179                 *p = '/';
 180                 p++;
 181         }
 182         return 0;
 183 }
 184
 185
 186 /**
 187  * Write @p len bytes at @p ptr to descriptor @p desc, retrying if
 188  * interrupted.
 189  *
 190  * @retval len upon success
 191  *
 192  * @retval <0 write's (negative) error code
 193  *
 194  * Derived from GNU C's cccp.c.
 195  */
 196 static int full_write(int desc, char *ptr, size_t len)
 197 {
 198         int total_written;
 199
 200         total_written = 0;
 201         while (len > 0) {
 202                 int written = write(desc, ptr, len);
 203                 if (written < 0)  {
 204                         if (errno == EINTR)
 205                                 continue;
 206                         return written;
 207                 }
 208                 total_written += written;
 209                 ptr += written;
 210                 len -= written;
 211         }
 212         return total_written;
 213 }
 214
 215
 216 /**
 217  * Read @p len bytes at @p ptr from descriptor @p desc, retrying if
 218  * interrupted.
 219  *
 220  * @retval >0 the actual number of bytes read
 221  *
 222  * @retval 0 for EOF
 223  *
 224  * @retval <0 for an error.
 225  *
 226  * Derived from GNU C's cccp.c. */
 227 static int safe_read(int desc, char *ptr, size_t len)
 228 {
 229         int n_chars;
 230
 231         if (len == 0)
 232                 return len;
 233
 234         do {
 235                 n_chars = read(desc, ptr, len);
 236         } while (n_chars < 0 && errno == EINTR);
 237
 238         return n_chars;
 239 }
 240
 241
 242 /** Copy a file.
 243  *
 244  * This is used in conjunction with the --temp-dir option */
 245 int copy_file(char *source, char *dest, mode_t mode)
 246 {
 247         int ifd;
 248         int ofd;
 249         char buf[1024 * 8];
 250         int len;   /* Number of bytes read into `buf'. */
 251
 252         ifd = do_open(source, O_RDONLY, 0);
 253         if (ifd == -1) {
 254                 rprintf(FERROR,"open %s: %s\n",
 255                         source,strerror(errno));
 256                 return -1;
 257         }
 258
 259         if (robust_unlink(dest) && errno != ENOENT) {
 260                 rprintf(FERROR,"unlink %s: %s\n",
 261                         dest,strerror(errno));
 262                 return -1;
 263         }
 264
 265         ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
 266         if (ofd == -1) {
 267                 rprintf(FERROR,"open %s: %s\n",
 268                         dest,strerror(errno));
 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                         rprintf(FERROR,"write %s: %s\n",
 276                                 dest,strerror(errno));
 277                         close(ifd);
 278                         close(ofd);
 279                         return -1;
 280                 }
 281         }
 282
 283         close(ifd);
 284         close(ofd);
 285
 286         if (len < 0) {
 287                 rprintf(FERROR,"read %s: %s\n",
 288                         source,strerror(errno));
 289                 return -1;
 290         }
 291
 292         return 0;
 293 }
 294
 295 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
 296 #define MAX_RENAMES_DIGITS 3
 297 #define MAX_RENAMES 1000
 298
 299 /**
 300  * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
 301  * rename to <path>/.rsyncNNN instead.
 302  *
 303  * Note that successive rsync runs will shuffle the filenames around a
 304  * bit as long as the file is still busy; this is because this function
 305  * does not know if the unlink call is due to a new file coming in, or
 306  * --delete trying to remove old .rsyncNNN files, hence it renames it
 307  * each time.
 308  **/
 309 int robust_unlink(char *fname)
 310 {
 311 #ifndef ETXTBSY
 312         return do_unlink(fname);
 313 #else
 314         static int counter = 1;
 315         int rc, pos, start;
 316         char path[MAXPATHLEN];
 317
 318         rc = do_unlink(fname);
 319         if (rc == 0 || errno != ETXTBSY)
 320                 return rc;
 321
 322         if ((pos = strlcpy(path, fname, MAXPATHLEN)) >= MAXPATHLEN)
 323                 pos = MAXPATHLEN - 1;
 324
 325         while (pos > 0 && path[pos-1] != '/')
 326                 pos--;
 327         pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);
 328
 329         if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
 330                 errno = ETXTBSY;
 331                 return -1;
 332         }
 333
 334         /* start where the last one left off to reduce chance of clashes */
 335         start = counter;
 336         do {
 337                 sprintf(&path[pos], "%03d", counter);
 338                 if (++counter >= MAX_RENAMES)
 339                         counter = 1;
 340         } while ((rc = access(path, 0)) == 0 && counter != start);
 341
 342         if (verbose > 0) {
 343                 rprintf(FINFO,"renaming %s to %s because of text busy\n",
 344                         fname, path);
 345         }
 346
 347         /* maybe we should return rename()'s exit status? Nah. */
 348         if (do_rename(fname, path) != 0) {
 349                 errno = ETXTBSY;
 350                 return -1;
 351         }
 352         return 0;
 353 #endif
 354 }
 355
 356 /* Returns 0 on success, -1 on most errors, and -2 if we got an error
 357  * trying to copy the file across file systems. */
 358 int robust_rename(char *from, char *to, int mode)
 359 {
 360         int tries = 4;
 361
 362         while (tries--) {
 363                 if (do_rename(from, to) == 0)
 364                         return 0;
 365
 366                 switch (errno) {
 367 #ifdef ETXTBSY
 368                 case ETXTBSY:
 369                         if (robust_unlink(to) != 0)
 370                                 return -1;
 371                         break;
 372 #endif
 373                 case EXDEV:
 374                         if (copy_file(from, to, mode) != 0)
 375                                 return -2;
 376                         do_unlink(from);
 377                         return 0;
 378                 default:
 379                         return -1;
 380                 }
 381         }
 382         return -1;
 383 }
 384
 385
 386 static pid_t all_pids[10];
 387 static int num_pids;
 388
 389 /** Fork and record the pid of the child. **/
 390 pid_t do_fork(void)
 391 {
 392         pid_t newpid = fork();
 393
 394         if (newpid != 0  &&  newpid != -1) {
 395                 all_pids[num_pids++] = newpid;
 396         }
 397         return newpid;
 398 }
 399
 400 /**
 401  * Kill all children.
 402  *
 403  * @todo It would be kind of nice to make sure that they are actually
 404  * all our children before we kill them, because their pids may have
 405  * been recycled by some other process.  Perhaps when we wait for a
 406  * child, we should remove it from this array.  Alternatively we could
 407  * perhaps use process groups, but I think that would not work on
 408  * ancient Unix versions that don't support them.
 409  **/
 410 void kill_all(int sig)
 411 {
 412         int i;
 413
 414         for (i = 0; i < num_pids; i++) {
 415                 /* Let's just be a little careful where we
 416                  * point that gun, hey?  See kill(2) for the
 417                  * magic caused by negative values. */
 418                 pid_t p = all_pids[i];
 419
 420                 if (p == getpid())
 421                         continue;
 422                 if (p <= 0)
 423                         continue;
 424
 425                 kill(p, sig);
 426         }
 427 }
 428
 429
 430 /** Turn a user name into a uid */
 431 int name_to_uid(char *name, uid_t *uid)
 432 {
 433         struct passwd *pass;
 434         if (!name || !*name) return 0;
 435         pass = getpwnam(name);
 436         if (pass) {
 437                 *uid = pass->pw_uid;
 438                 return 1;
 439         }
 440         return 0;
 441 }
 442
 443 /** Turn a group name into a gid */
 444 int name_to_gid(char *name, gid_t *gid)
 445 {
 446         struct group *grp;
 447         if (!name || !*name) return 0;
 448         grp = getgrnam(name);
 449         if (grp) {
 450                 *gid = grp->gr_gid;
 451                 return 1;
 452         }
 453         return 0;
 454 }
 455
 456
 457 /** Lock a byte range in a open file */
 458 int lock_range(int fd, int offset, int len)
 459 {
 460         struct flock lock;
 461
 462         lock.l_type = F_WRLCK;
 463         lock.l_whence = SEEK_SET;
 464         lock.l_start = offset;
 465         lock.l_len = len;
 466         lock.l_pid = 0;
 467
 468         return fcntl(fd,F_SETLK,&lock) == 0;
 469 }
 470
 471 static int exclude_server_path(char *arg)
 472 {
 473         char *s;
 474         extern struct exclude_struct **server_exclude_list;
 475
 476         if (server_exclude_list) {
 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 }