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) < 0) {
 480                                 /* We must leave arg truncated! */
 481                                 return 1;
 482                         }
 483                         *s++ = '/';
 484                 }
 485         }
 486         return 0;
 487 }
 488
 489 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs)
 490 {
 491 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
 492         if (!*s) s = ".";
 493         s = argv[*argc] = strdup(s);
 494         exclude_server_path(s);
 495         (*argc)++;
 496 #else
 497         extern int sanitize_paths;
 498         glob_t globbuf;
 499         int i;
 500
 501         if (!*s) s = ".";
 502
 503         s = argv[*argc] = strdup(s);
 504         if (sanitize_paths) {
 505                 sanitize_path(s, NULL);
 506         }
 507
 508         memset(&globbuf, 0, sizeof globbuf);
 509         if (!exclude_server_path(s))
 510                 glob(s, 0, NULL, &globbuf);
 511         if (globbuf.gl_pathc == 0) {
 512                 (*argc)++;
 513                 globfree(&globbuf);
 514                 return;
 515         }
 516         for (i = 0; i < maxargs - *argc && i < (int)globbuf.gl_pathc; i++) {
 517                 if (i == 0)
 518                         free(s);
 519                 argv[*argc + i] = strdup(globbuf.gl_pathv[i]);
 520                 if (!argv[*argc + i])
 521                         out_of_memory("glob_expand");
 522         }
 523         globfree(&globbuf);
 524         *argc += i;
 525 #endif
 526 }
 527
 528 /* This routine is only used in daemon mode. */
 529 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
 530 {
 531         char *s = argv[*argc];
 532         char *p, *q;
 533         char *base = base1;
 534         int base_len = strlen(base);
 535
 536         if (!s || !*s) return;
 537
 538         if (strncmp(s, base, base_len) == 0)
 539                 s += base_len;
 540
 541         s = strdup(s);
 542         if (!s) out_of_memory("glob_expand");
 543
 544         if (asprintf(&base," %s/", base1) <= 0) out_of_memory("glob_expand");
 545         base_len++;
 546
 547         q = s;
 548         while ((p = strstr(q,base)) != NULL && *argc < maxargs) {
 549                 /* split it at this point */
 550                 *p = 0;
 551                 glob_expand_one(q, argv, argc, maxargs);
 552                 q = p + base_len;
 553         }
 554
 555         if (*q && *argc < maxargs)
 556                 glob_expand_one(q, argv, argc, maxargs);
 557
 558         free(s);
 559         free(base);
 560 }
 561
 562 /**
 563  * Convert a string to lower case
 564  **/
 565 void strlower(char *s)
 566 {
 567         while (*s) {
 568                 if (isupper(* (unsigned char *) s))
 569                         *s = tolower(* (unsigned char *) s);
 570                 s++;
 571         }
 572 }
 573
 574 /* Join strings p1 & p2 into "dest" with a guaranteed '/' between them.  (If
 575  * p1 ends with a '/', no extra '/' is inserted.)  Returns the length of both
 576  * strings + 1 (if '/' was inserted), regardless of whether the null-terminated
 577  * string fits into destsize. */
 578 size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)
 579 {
 580         size_t len = strlcpy(dest, p1, destsize);
 581         if (len < destsize - 1) {
 582                 if (!len || dest[len-1] != '/')
 583                         dest[len++] = '/';
 584                 if (len < destsize - 1)
 585                         len += strlcpy(dest + len, p2, destsize - len);
 586                 else {
 587                         dest[len] = '\0';
 588                         len += strlen(p2);
 589                 }
 590         }
 591         else
 592                 len += strlen(p2) + 1; /* Assume we'd insert a '/'. */
 593         return len;
 594 }
 595
 596 /* Join any number of strings together, putting them in "dest".  The return
 597  * value is the length of all the strings, regardless of whether the null-
 598  * terminated whole fits in destsize.  Your list of string pointers must end
 599  * with a NULL to indicate the end of the list. */
 600 size_t stringjoin(char *dest, size_t destsize, ...)
 601 {
 602         va_list ap;
 603         size_t len, ret = 0;
 604         const char *src;
 605
 606         va_start(ap, destsize);
 607         while (1) {
 608                 if (!(src = va_arg(ap, const char *)))
 609                         break;
 610                 len = strlen(src);
 611                 ret += len;
 612                 if (destsize > 1) {
 613                         if (len >= destsize)
 614                                 len = destsize - 1;
 615                         memcpy(dest, src, len);
 616                         destsize -= len;
 617                         dest += len;
 618                 }
 619         }
 620         *dest = '\0';
 621         va_end(ap);
 622
 623         return ret;
 624 }
 625
 626 void clean_fname(char *name)
 627 {
 628         char *p;
 629         int l;
 630         int modified = 1;
 631
 632         if (!name) return;
 633
 634         while (modified) {
 635                 modified = 0;
 636
 637                 if ((p = strstr(name,"/./")) != NULL) {
 638                         modified = 1;
 639                         while (*p) {
 640                                 p[0] = p[2];
 641                                 p++;
 642                         }
 643                 }
 644
 645                 if ((p = strstr(name,"//")) != NULL) {
 646                         modified = 1;
 647                         while (*p) {
 648                                 p[0] = p[1];
 649                                 p++;
 650                         }
 651                 }
 652
 653                 if (strncmp(p = name, "./", 2) == 0) {
 654                         modified = 1;
 655                         do {
 656                                 p[0] = p[2];
 657                         } while (*p++);
 658                 }
 659
 660                 l = strlen(p = name);
 661                 if (l > 1 && p[l-1] == '/') {
 662                         modified = 1;
 663                         p[l-1] = 0;
 664                 }
 665         }
 666 }
 667
 668 /**
 669  * Make path appear as if a chroot had occurred:
 670  *
 671  * @li 1. remove leading "/" (or replace with "." if at end)
 672  *
 673  * @li 2. remove leading ".." components (except those allowed by @p reldir)
 674  *
 675  * @li 3. delete any other "<dir>/.." (recursively)
 676  *
 677  * Can only shrink paths, so sanitizes in place.
 678  *
 679  * While we're at it, remove double slashes and "." components like
 680  *   clean_fname() does, but DON'T remove a trailing slash because that
 681  *   is sometimes significant on command line arguments.
 682  *
 683  * If @p reldir is non-null, it is a sanitized directory that the path will be
 684  *    relative to, so allow as many ".." at the beginning of the path as
 685  *    there are components in reldir.  This is used for symbolic link targets.
 686  *    If reldir is non-null and the path began with "/", to be completely like
 687  *    a chroot we should add in depth levels of ".." at the beginning of the
 688  *    path, but that would blow the assumption that the path doesn't grow and
 689  *    it is not likely to end up being a valid symlink anyway, so just do
 690  *    the normal removal of the leading "/" instead.
 691  *
 692  * Contributed by Dave Dykstra <dwd@bell-labs.com>
 693  */
 694 void sanitize_path(char *p, char *reldir)
 695 {
 696         char *start, *sanp;
 697         int depth = 0;
 698         int allowdotdot = 0;
 699
 700         if (reldir) {
 701                 depth++;
 702                 while (*reldir) {
 703                         if (*reldir++ == '/') {
 704                                 depth++;
 705                         }
 706                 }
 707         }
 708         start = p;
 709         sanp = p;
 710         while (*p == '/') {
 711                 /* remove leading slashes */
 712                 p++;
 713         }
 714         while (*p != '\0') {
 715                 /* this loop iterates once per filename component in p.
 716                  * both p (and sanp if the original had a slash) should
 717                  * always be left pointing after a slash
 718                  */
 719                 if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {
 720                         /* skip "." component */
 721                         while (*++p == '/') {
 722                                 /* skip following slashes */
 723                                 ;
 724                         }
 725                         continue;
 726                 }
 727                 allowdotdot = 0;
 728                 if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
 729                         /* ".." component followed by slash or end */
 730                         if (depth > 0 && sanp == start) {
 731                                 /* allow depth levels of .. at the beginning */
 732                                 --depth;
 733                                 allowdotdot = 1;
 734                         } else {
 735                                 p += 2;
 736                                 if (*p == '/')
 737                                         p++;
 738                                 if (sanp != start) {
 739                                         /* back up sanp one level */
 740                                         --sanp; /* now pointing at slash */
 741                                         while (sanp > start && sanp[-1] != '/') {
 742                                                 /* skip back up to slash */
 743                                                 sanp--;
 744                                         }
 745                                 }
 746                                 continue;
 747                         }
 748                 }
 749                 while (1) {
 750                         /* copy one component through next slash */
 751                         *sanp++ = *p++;
 752                         if (*p == '\0' || p[-1] == '/') {
 753                                 while (*p == '/') {
 754                                         /* skip multiple slashes */
 755                                         p++;
 756                                 }
 757                                 break;
 758                         }
 759                 }
 760                 if (allowdotdot) {
 761                         /* move the virtual beginning to leave the .. alone */
 762                         start = sanp;
 763                 }
 764         }
 765         if (sanp == start && !allowdotdot) {
 766                 /* ended up with nothing, so put in "." component */
 767                 /*
 768                  * note that the !allowdotdot doesn't prevent this from
 769                  *  happening in all allowed ".." situations, but I didn't
 770                  *  think it was worth putting in an extra variable to ensure
 771                  *  it since an extra "." won't hurt in those situations.
 772                  */
 773                 *sanp++ = '.';
 774         }
 775         *sanp = '\0';
 776 }
 777
 778 /* Works much like sanitize_path(), with these differences:  (1) a new buffer
 779  * is allocated for the sanitized path rather than modifying it in-place; (2)
 780  * a leading slash gets transformed into the rootdir value (which can be empty
 781  * or NULL if you just want the slash to get dropped); (3) no "reldir" can be
 782  * specified. */
 783 char *alloc_sanitize_path(const char *path, const char *rootdir)
 784 {
 785         char *buf;
 786         int rlen, plen = strlen(path);
 787
 788         if (*path == '/' && rootdir) {
 789                 rlen = strlen(rootdir);
 790                 if (rlen == 1)
 791                         path++;
 792         } else
 793                 rlen = 0;
 794         if (!(buf = new_array(char, rlen + plen + 1)))
 795                 out_of_memory("alloc_sanitize_path");
 796         if (rlen)
 797                 memcpy(buf, rootdir, rlen);
 798         memcpy(buf + rlen, path, plen + 1);
 799
 800         if (rlen > 1)
 801                 rlen++;
 802         sanitize_path(buf + rlen, NULL);
 803         if (rlen && buf[rlen] == '.' && buf[rlen+1] == '\0') {
 804                 if (rlen > 1)
 805                         rlen--;
 806                 buf[rlen] = '\0';
 807         }
 808         fprintf(stderr, "p:`%s'\n", buf);
 809
 810         return buf;
 811 }
 812
 813 char curr_dir[MAXPATHLEN];
 814 unsigned int curr_dir_len;
 815
 816 /**
 817  * Like chdir(), but it keeps track of the current directory (in the
 818  * global "curr_dir"), and ensures that the path size doesn't overflow.
 819  * Also cleans the path using the clean_fname() function.
 820  **/
 821 int push_dir(char *dir)
 822 {
 823         static int initialised;
 824         unsigned int len;
 825
 826         if (!initialised) {
 827                 initialised = 1;
 828                 getcwd(curr_dir, sizeof curr_dir - 1);
 829                 curr_dir_len = strlen(curr_dir);
 830         }
 831
 832         if (!dir)       /* this call was probably just to initialize */
 833                 return 0;
 834
 835         len = strlen(dir);
 836         if (len == 1 && *dir == '.')
 837                 return 1;
 838
 839         if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
 840                 return 0;
 841
 842         if (chdir(dir))
 843                 return 0;
 844
 845         if (*dir == '/') {
 846                 memcpy(curr_dir, dir, len + 1);
 847                 curr_dir_len = len;
 848         } else {
 849                 curr_dir[curr_dir_len++] = '/';
 850                 memcpy(curr_dir + curr_dir_len, dir, len + 1);
 851                 curr_dir_len += len;
 852         }
 853
 854         clean_fname(curr_dir);
 855
 856         return 1;
 857 }
 858
 859 /**
 860  * Reverse a push_dir() call.  You must pass in an absolute path
 861  * that was copied from a prior value of "curr_dir".
 862  **/
 863 int pop_dir(char *dir)
 864 {
 865         if (chdir(dir))
 866                 return 0;
 867
 868         curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
 869         if (curr_dir_len >= sizeof curr_dir)
 870                 curr_dir_len = sizeof curr_dir - 1;
 871
 872         return 1;
 873 }
 874
 875 /**
 876  * Return a quoted string with the full pathname of the indicated filename.
 877  * The string " (in MODNAME)" may also be appended.  The returned pointer
 878  * remains valid until the next time full_fname() is called.
 879  **/
 880 char *full_fname(char *fn)
 881 {
 882         extern int module_id;
 883         static char *result = NULL;
 884         char *m1, *m2, *m3;
 885         char *p1, *p2;
 886
 887         if (result)
 888                 free(result);
 889
 890         if (*fn == '/')
 891                 p1 = p2 = "";
 892         else {
 893                 p1 = curr_dir;
 894                 p2 = "/";
 895         }
 896         if (module_id >= 0) {
 897                 m1 = " (in ";
 898                 m2 = lp_name(module_id);
 899                 m3 = ")";
 900                 if (*p1) {
 901                         if (!lp_use_chroot(module_id)) {
 902                                 char *p = lp_path(module_id);
 903                                 if (*p != '/' || p[1])
 904                                         p1 += strlen(p);
 905                         }
 906                         if (!*p1)
 907                                 p2++;
 908                         else
 909                                 p1++;
 910                 }
 911                 else
 912                         fn++;
 913         } else
 914                 m1 = m2 = m3 = "";
 915
 916         asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
 917
 918         return result;
 919 }
 920
 921 /** We need to supply our own strcmp function for file list comparisons
 922    to ensure that signed/unsigned usage is consistent between machines. */
 923 int u_strcmp(const char *cs1, const char *cs2)
 924 {
 925         const uchar *s1 = (const uchar *)cs1;
 926         const uchar *s2 = (const uchar *)cs2;
 927
 928         while (*s1 && *s2 && (*s1 == *s2)) {
 929                 s1++; s2++;
 930         }
 931
 932         return (int)*s1 - (int)*s2;
 933 }
 934
 935
 936
 937 /**
 938  * Determine if a symlink points outside the current directory tree.
 939  * This is considered "unsafe" because e.g. when mirroring somebody
 940  * else's machine it might allow them to establish a symlink to
 941  * /etc/passwd, and then read it through a web server.
 942  *
 943  * Null symlinks and absolute symlinks are always unsafe.
 944  *
 945  * Basically here we are concerned with symlinks whose target contains
 946  * "..", because this might cause us to walk back up out of the
 947  * transferred directory.  We are not allowed to go back up and
 948  * reenter.
 949  *
 950  * @param dest Target of the symlink in question.
 951  *
 952  * @param src Top source directory currently applicable.  Basically this
 953  * is the first parameter to rsync in a simple invocation, but it's
 954  * modified by flist.c in slightly complex ways.
 955  *
 956  * @retval True if unsafe
 957  * @retval False is unsafe
 958  *
 959  * @sa t_unsafe.c
 960  **/
 961 int unsafe_symlink(const char *dest, const char *src)
 962 {
 963         const char *name, *slash;
 964         int depth = 0;
 965
 966         /* all absolute and null symlinks are unsafe */
 967         if (!dest || !*dest || *dest == '/') return 1;
 968
 969         /* find out what our safety margin is */
 970         for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
 971                 if (strncmp(name, "../", 3) == 0) {
 972                         depth = 0;
 973                 } else if (strncmp(name, "./", 2) == 0) {
 974                         /* nothing */
 975                 } else {
 976                         depth++;
 977                 }
 978         }
 979         if (strcmp(name, "..") == 0)
 980                 depth = 0;
 981
 982         for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
 983                 if (strncmp(name, "../", 3) == 0) {
 984                         /* if at any point we go outside the current directory
 985                            then stop - it is unsafe */
 986                         if (--depth < 0)
 987                                 return 1;
 988                 } else if (strncmp(name, "./", 2) == 0) {
 989                         /* nothing */
 990                 } else {
 991                         depth++;
 992                 }
 993         }
 994         if (strcmp(name, "..") == 0)
 995                 depth--;
 996
 997         return (depth < 0);
 998 }
 999
1000
1001 /**
1002  * Return the date and time as a string
1003  **/
1004 char *timestring(time_t t)
1005 {
1006         static char TimeBuf[200];
1007         struct tm *tm = localtime(&t);
1008
1009 #ifdef HAVE_STRFTIME
1010         strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1011 #else
1012         strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1013 #endif
1014
1015         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1016                 TimeBuf[strlen(TimeBuf)-1] = 0;
1017         }
1018
1019         return(TimeBuf);
1020 }
1021
1022
1023 /**
1024  * Sleep for a specified number of milliseconds.
1025  *
1026  * Always returns TRUE.  (In the future it might return FALSE if
1027  * interrupted.)
1028  **/
1029 int msleep(int t)
1030 {
1031         int tdiff = 0;
1032         struct timeval tval, t1, t2;
1033
1034         gettimeofday(&t1, NULL);
1035         gettimeofday(&t2, NULL);
1036
1037         while (tdiff < t) {
1038                 tval.tv_sec = (t-tdiff)/1000;
1039                 tval.tv_usec = 1000*((t-tdiff)%1000);
1040
1041                 errno = 0;
1042                 select(0,NULL,NULL, NULL, &tval);
1043
1044                 gettimeofday(&t2, NULL);
1045                 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1046                         (t2.tv_usec - t1.tv_usec)/1000;
1047         }
1048
1049         return True;
1050 }
1051
1052
1053 /**
1054  * Determine if two file modification times are equivalent (either
1055  * exact or in the modification timestamp window established by
1056  * --modify-window).
1057  *
1058  * @retval 0 if the times should be treated as the same
1059  *
1060  * @retval +1 if the first is later
1061  *
1062  * @retval -1 if the 2nd is later
1063  **/
1064 int cmp_modtime(time_t file1, time_t file2)
1065 {
1066         extern int modify_window;
1067
1068         if (file2 > file1) {
1069                 if (file2 - file1 <= modify_window) return 0;
1070                 return -1;
1071         }
1072         if (file1 - file2 <= modify_window) return 0;
1073         return 1;
1074 }
1075
1076
1077 #ifdef __INSURE__XX
1078 #include <dlfcn.h>
1079
1080 /**
1081    This routine is a trick to immediately catch errors when debugging
1082    with insure. A xterm with a gdb is popped up when insure catches
1083    a error. It is Linux specific.
1084 **/
1085 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1086 {
1087         static int (*fn)();
1088         int ret;
1089         char *cmd;
1090
1091         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'",
1092                 getpid(), getpid(), getpid());
1093
1094         if (!fn) {
1095                 static void *h;
1096                 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1097                 fn = dlsym(h, "_Insure_trap_error");
1098         }
1099
1100         ret = fn(a1, a2, a3, a4, a5, a6);
1101
1102         system(cmd);
1103
1104         free(cmd);
1105
1106         return ret;
1107 }
1108 #endif
1109
1110
1111 #define MALLOC_MAX 0x40000000
1112
1113 void *_new_array(unsigned int size, unsigned long num)
1114 {
1115         if (num >= MALLOC_MAX/size)
1116                 return NULL;
1117         return malloc(size * num);
1118 }
1119
1120 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1121 {
1122         if (num >= MALLOC_MAX/size)
1123                 return NULL;
1124         /* No realloc should need this, but just in case... */
1125         if (!ptr)
1126                 return malloc(size * num);
1127         return realloc(ptr, size * num);
1128 }