util.c

   1 /*  -*- c-file-style: "linux" -*-
   2  *
   3  * Copyright (C) 1996-2000 by Andrew Tridgell
   4  * Copyright (C) Paul Mackerras 1996
   5  * Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 /**
  23  * @file
  24  *
  25  * Utilities used in rsync
  26  **/
  27
  28 #include "rsync.h"
  29
  30 extern int verbose;
  31 extern int dry_run;
  32 extern int module_id;
  33 extern int modify_window;
  34 extern int relative_paths;
  35 extern int human_readable;
  36 extern char *partial_dir;
  37 extern struct filter_list_struct server_filter_list;
  38
  39 int sanitize_paths = 0;
  40
  41
  42
  43 /**
  44  * Set a fd into nonblocking mode
  45  **/
  46 void set_nonblocking(int fd)
  47 {
  48         int val;
  49
  50         if ((val = fcntl(fd, F_GETFL, 0)) == -1)
  51                 return;
  52         if (!(val & NONBLOCK_FLAG)) {
  53                 val |= NONBLOCK_FLAG;
  54                 fcntl(fd, F_SETFL, val);
  55         }
  56 }
  57
  58 /**
  59  * Set a fd into blocking mode
  60  **/
  61 void set_blocking(int fd)
  62 {
  63         int val;
  64
  65         if ((val = fcntl(fd, F_GETFL, 0)) == -1)
  66                 return;
  67         if (val & NONBLOCK_FLAG) {
  68                 val &= ~NONBLOCK_FLAG;
  69                 fcntl(fd, F_SETFL, val);
  70         }
  71 }
  72
  73
  74 /**
  75  * Create a file descriptor pair - like pipe() but use socketpair if
  76  * possible (because of blocking issues on pipes).
  77  *
  78  * Always set non-blocking.
  79  */
  80 int fd_pair(int fd[2])
  81 {
  82         int ret;
  83
  84 #ifdef HAVE_SOCKETPAIR
  85         ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
  86 #else
  87         ret = pipe(fd);
  88 #endif
  89
  90         if (ret == 0) {
  91                 set_nonblocking(fd[0]);
  92                 set_nonblocking(fd[1]);
  93         }
  94
  95         return ret;
  96 }
  97
  98
  99 void print_child_argv(char **cmd)
 100 {
 101         rprintf(FINFO, "opening connection using ");
 102         for (; *cmd; cmd++) {
 103                 /* Look for characters that ought to be quoted.  This
 104                 * is not a great quoting algorithm, but it's
 105                 * sufficient for a log message. */
 106                 if (strspn(*cmd, "abcdefghijklmnopqrstuvwxyz"
 107                            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 108                            "0123456789"
 109                            ",.-_=+@/") != strlen(*cmd)) {
 110                         rprintf(FINFO, "\"%s\" ", *cmd);
 111                 } else {
 112                         rprintf(FINFO, "%s ", *cmd);
 113                 }
 114         }
 115         rprintf(FINFO, "\n");
 116 }
 117
 118
 119 void out_of_memory(char *str)
 120 {
 121         rprintf(FERROR, "ERROR: out of memory in %s\n", str);
 122         exit_cleanup(RERR_MALLOC);
 123 }
 124
 125 void overflow_exit(char *str)
 126 {
 127         rprintf(FERROR, "ERROR: buffer overflow in %s\n", str);
 128         exit_cleanup(RERR_MALLOC);
 129 }
 130
 131
 132
 133 int set_modtime(char *fname, time_t modtime, mode_t mode)
 134 {
 135 #if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
 136         if (S_ISLNK(mode))
 137                 return 1;
 138 #endif
 139
 140         if (verbose > 2) {
 141                 rprintf(FINFO, "set modtime of %s to (%ld) %s",
 142                         fname, (long)modtime,
 143                         asctime(localtime(&modtime)));
 144         }
 145
 146         if (dry_run)
 147                 return 0;
 148
 149         {
 150 #ifdef HAVE_UTIMES
 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 # ifdef HAVE_LUTIMES
 157                 if (S_ISLNK(mode))
 158                         return lutimes(fname, t);
 159 # endif
 160                 return utimes(fname, t);
 161 #elif defined HAVE_UTIMBUF
 162                 struct utimbuf tbuf;
 163                 tbuf.actime = time(NULL);
 164                 tbuf.modtime = modtime;
 165                 return utime(fname,&tbuf);
 166 #elif defined HAVE_UTIME
 167                 time_t t[2];
 168                 t[0] = time(NULL);
 169                 t[1] = modtime;
 170                 return utime(fname,t);
 171 #else
 172 #error No file-time-modification routine found!
 173 #endif
 174         }
 175 }
 176
 177
 178 /**
 179    Create any necessary directories in fname. Unfortunately we don't know
 180    what perms to give the directory when this is called so we need to rely
 181    on the umask
 182 **/
 183 int create_directory_path(char *fname, int base_umask)
 184 {
 185         char *p;
 186
 187         while (*fname == '/')
 188                 fname++;
 189         while (strncmp(fname, "./", 2) == 0)
 190                 fname += 2;
 191
 192         p = fname;
 193         while ((p = strchr(p,'/')) != NULL) {
 194                 *p = 0;
 195                 do_mkdir(fname, 0777 & ~base_umask);
 196                 *p = '/';
 197                 p++;
 198         }
 199         return 0;
 200 }
 201
 202
 203 /**
 204  * Write @p len bytes at @p ptr to descriptor @p desc, retrying if
 205  * interrupted.
 206  *
 207  * @retval len upon success
 208  *
 209  * @retval <0 write's (negative) error code
 210  *
 211  * Derived from GNU C's cccp.c.
 212  */
 213 int full_write(int desc, char *ptr, size_t len)
 214 {
 215         int total_written;
 216
 217         total_written = 0;
 218         while (len > 0) {
 219                 int written = write(desc, ptr, len);
 220                 if (written < 0)  {
 221                         if (errno == EINTR)
 222                                 continue;
 223                         return written;
 224                 }
 225                 total_written += written;
 226                 ptr += written;
 227                 len -= written;
 228         }
 229         return total_written;
 230 }
 231
 232
 233 /**
 234  * Read @p len bytes at @p ptr from descriptor @p desc, retrying if
 235  * interrupted.
 236  *
 237  * @retval >0 the actual number of bytes read
 238  *
 239  * @retval 0 for EOF
 240  *
 241  * @retval <0 for an error.
 242  *
 243  * Derived from GNU C's cccp.c. */
 244 static int safe_read(int desc, char *ptr, size_t len)
 245 {
 246         int n_chars;
 247
 248         if (len == 0)
 249                 return len;
 250
 251         do {
 252                 n_chars = read(desc, ptr, len);
 253         } while (n_chars < 0 && errno == EINTR);
 254
 255         return n_chars;
 256 }
 257
 258
 259 /** Copy a file.
 260  *
 261  * This is used in conjunction with the --temp-dir, --backup, and
 262  * --copy-dest options. */
 263 int copy_file(char *source, char *dest, mode_t mode)
 264 {
 265         int ifd;
 266         int ofd;
 267         char buf[1024 * 8];
 268         int len;   /* Number of bytes read into `buf'. */
 269
 270         ifd = do_open(source, O_RDONLY, 0);
 271         if (ifd == -1) {
 272                 rsyserr(FERROR, errno, "open %s", full_fname(source));
 273                 return -1;
 274         }
 275
 276         if (robust_unlink(dest) && errno != ENOENT) {
 277                 rsyserr(FERROR, errno, "unlink %s", full_fname(dest));
 278                 return -1;
 279         }
 280
 281         ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
 282         if (ofd == -1) {
 283                 rsyserr(FERROR, errno, "open %s", full_fname(dest));
 284                 close(ifd);
 285                 return -1;
 286         }
 287
 288         while ((len = safe_read(ifd, buf, sizeof buf)) > 0) {
 289                 if (full_write(ofd, buf, len) < 0) {
 290                         rsyserr(FERROR, errno, "write %s", full_fname(dest));
 291                         close(ifd);
 292                         close(ofd);
 293                         return -1;
 294                 }
 295         }
 296
 297         if (len < 0) {
 298                 rsyserr(FERROR, errno, "read %s", full_fname(source));
 299                 close(ifd);
 300                 close(ofd);
 301                 return -1;
 302         }
 303
 304         if (close(ifd) < 0) {
 305                 rsyserr(FINFO, errno, "close failed on %s",
 306                         full_fname(source));
 307         }
 308
 309         if (close(ofd) < 0) {
 310                 rsyserr(FERROR, errno, "close failed on %s",
 311                         full_fname(dest));
 312                 return -1;
 313         }
 314
 315         return 0;
 316 }
 317
 318 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
 319 #define MAX_RENAMES_DIGITS 3
 320 #define MAX_RENAMES 1000
 321
 322 /**
 323  * Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
 324  * rename to <path>/.rsyncNNN instead.
 325  *
 326  * Note that successive rsync runs will shuffle the filenames around a
 327  * bit as long as the file is still busy; this is because this function
 328  * does not know if the unlink call is due to a new file coming in, or
 329  * --delete trying to remove old .rsyncNNN files, hence it renames it
 330  * each time.
 331  **/
 332 int robust_unlink(char *fname)
 333 {
 334 #ifndef ETXTBSY
 335         return do_unlink(fname);
 336 #else
 337         static int counter = 1;
 338         int rc, pos, start;
 339         char path[MAXPATHLEN];
 340
 341         rc = do_unlink(fname);
 342         if (rc == 0 || errno != ETXTBSY)
 343                 return rc;
 344
 345         if ((pos = strlcpy(path, fname, MAXPATHLEN)) >= MAXPATHLEN)
 346                 pos = MAXPATHLEN - 1;
 347
 348         while (pos > 0 && path[pos-1] != '/')
 349                 pos--;
 350         pos += strlcpy(path+pos, ".rsync", MAXPATHLEN-pos);
 351
 352         if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
 353                 errno = ETXTBSY;
 354                 return -1;
 355         }
 356
 357         /* start where the last one left off to reduce chance of clashes */
 358         start = counter;
 359         do {
 360                 sprintf(&path[pos], "%03d", counter);
 361                 if (++counter >= MAX_RENAMES)
 362                         counter = 1;
 363         } while ((rc = access(path, 0)) == 0 && counter != start);
 364
 365         if (verbose > 0) {
 366                 rprintf(FINFO,"renaming %s to %s because of text busy\n",
 367                         fname, path);
 368         }
 369
 370         /* maybe we should return rename()'s exit status? Nah. */
 371         if (do_rename(fname, path) != 0) {
 372                 errno = ETXTBSY;
 373                 return -1;
 374         }
 375         return 0;
 376 #endif
 377 }
 378
 379 /* Returns 0 on successful rename, 1 if we successfully copied the file
 380  * across filesystems, -2 if copy_file() failed, and -1 on other errors. */
 381 int robust_rename(char *from, char *to, int mode)
 382 {
 383         int tries = 4;
 384
 385         while (tries--) {
 386                 if (do_rename(from, to) == 0)
 387                         return 0;
 388
 389                 switch (errno) {
 390 #ifdef ETXTBSY
 391                 case ETXTBSY:
 392                         if (robust_unlink(to) != 0)
 393                                 return -1;
 394                         break;
 395 #endif
 396                 case EXDEV:
 397                         if (copy_file(from, to, mode) != 0)
 398                                 return -2;
 399                         do_unlink(from);
 400                         return 1;
 401                 default:
 402                         return -1;
 403                 }
 404         }
 405         return -1;
 406 }
 407
 408
 409 static pid_t all_pids[10];
 410 static int num_pids;
 411
 412 /** Fork and record the pid of the child. **/
 413 pid_t do_fork(void)
 414 {
 415         pid_t newpid = fork();
 416
 417         if (newpid != 0  &&  newpid != -1) {
 418                 all_pids[num_pids++] = newpid;
 419         }
 420         return newpid;
 421 }
 422
 423 /**
 424  * Kill all children.
 425  *
 426  * @todo It would be kind of nice to make sure that they are actually
 427  * all our children before we kill them, because their pids may have
 428  * been recycled by some other process.  Perhaps when we wait for a
 429  * child, we should remove it from this array.  Alternatively we could
 430  * perhaps use process groups, but I think that would not work on
 431  * ancient Unix versions that don't support them.
 432  **/
 433 void kill_all(int sig)
 434 {
 435         int i;
 436
 437         for (i = 0; i < num_pids; i++) {
 438                 /* Let's just be a little careful where we
 439                  * point that gun, hey?  See kill(2) for the
 440                  * magic caused by negative values. */
 441                 pid_t p = all_pids[i];
 442
 443                 if (p == getpid())
 444                         continue;
 445                 if (p <= 0)
 446                         continue;
 447
 448                 kill(p, sig);
 449         }
 450 }
 451
 452
 453 /** Turn a user name into a uid */
 454 int name_to_uid(char *name, uid_t *uid)
 455 {
 456         struct passwd *pass;
 457         if (!name || !*name)
 458                 return 0;
 459         pass = getpwnam(name);
 460         if (pass) {
 461                 *uid = pass->pw_uid;
 462                 return 1;
 463         }
 464         return 0;
 465 }
 466
 467 /** Turn a group name into a gid */
 468 int name_to_gid(char *name, gid_t *gid)
 469 {
 470         struct group *grp;
 471         if (!name || !*name)
 472                 return 0;
 473         grp = getgrnam(name);
 474         if (grp) {
 475                 *gid = grp->gr_gid;
 476                 return 1;
 477         }
 478         return 0;
 479 }
 480
 481
 482 /** Lock a byte range in a open file */
 483 int lock_range(int fd, int offset, int len)
 484 {
 485         struct flock lock;
 486
 487         lock.l_type = F_WRLCK;
 488         lock.l_whence = SEEK_SET;
 489         lock.l_start = offset;
 490         lock.l_len = len;
 491         lock.l_pid = 0;
 492
 493         return fcntl(fd,F_SETLK,&lock) == 0;
 494 }
 495
 496 static int filter_server_path(char *arg)
 497 {
 498         char *s;
 499
 500         if (server_filter_list.head) {
 501                 for (s = arg; (s = strchr(s, '/')) != NULL; ) {
 502                         *s = '\0';
 503                         if (check_filter(&server_filter_list, arg, 1) < 0) {
 504                                 /* We must leave arg truncated! */
 505                                 return 1;
 506                         }
 507                         *s++ = '/';
 508                 }
 509         }
 510         return 0;
 511 }
 512
 513 static void glob_expand_one(char *s, char ***argv_ptr, int *argc_ptr,
 514                             int *maxargs_ptr)
 515 {
 516         char **argv = *argv_ptr;
 517         int argc = *argc_ptr;
 518         int maxargs = *maxargs_ptr;
 519 #if !defined HAVE_GLOB || !defined HAVE_GLOB_H
 520         if (argc == maxargs) {
 521                 maxargs += MAX_ARGS;
 522                 if (!(argv = realloc_array(argv, char *, maxargs)))
 523                         out_of_memory("glob_expand_one");
 524                 *argv_ptr = argv;
 525                 *maxargs_ptr = maxargs;
 526         }
 527         if (!*s)
 528                 s = ".";
 529         s = argv[argc++] = strdup(s);
 530         filter_server_path(s);
 531 #else
 532         glob_t globbuf;
 533
 534         if (maxargs <= argc)
 535                 return;
 536         if (!*s)
 537                 s = ".";
 538
 539         if (sanitize_paths)
 540                 s = sanitize_path(NULL, s, "", 0);
 541         else
 542                 s = strdup(s);
 543
 544         memset(&globbuf, 0, sizeof globbuf);
 545         if (!filter_server_path(s))
 546                 glob(s, 0, NULL, &globbuf);
 547         if (MAX((int)globbuf.gl_pathc, 1) > maxargs - argc) {
 548                 maxargs += globbuf.gl_pathc + MAX_ARGS;
 549                 if (!(argv = realloc_array(argv, char *, maxargs)))
 550                         out_of_memory("glob_expand_one");
 551                 *argv_ptr = argv;
 552                 *maxargs_ptr = maxargs;
 553         }
 554         if (globbuf.gl_pathc == 0)
 555                 argv[argc++] = s;
 556         else {
 557                 int i;
 558                 free(s);
 559                 for (i = 0; i < (int)globbuf.gl_pathc; i++) {
 560                         if (!(argv[argc++] = strdup(globbuf.gl_pathv[i])))
 561                                 out_of_memory("glob_expand_one");
 562                 }
 563         }
 564         globfree(&globbuf);
 565 #endif
 566         *argc_ptr = argc;
 567 }
 568
 569 /* This routine is only used in daemon mode. */
 570 void glob_expand(char *base1, char ***argv_ptr, int *argc_ptr, int *maxargs_ptr)
 571 {
 572         char *s = (*argv_ptr)[*argc_ptr];
 573         char *p, *q;
 574         char *base = base1;
 575         int base_len = strlen(base);
 576
 577         if (!s || !*s)
 578                 return;
 579
 580         if (strncmp(s, base, base_len) == 0)
 581                 s += base_len;
 582
 583         if (!(s = strdup(s)))
 584                 out_of_memory("glob_expand");
 585
 586         if (asprintf(&base," %s/", base1) <= 0)
 587                 out_of_memory("glob_expand");
 588         base_len++;
 589
 590         for (q = s; *q; q = p + base_len) {
 591                 if ((p = strstr(q, base)) != NULL)
 592                         *p = '\0'; /* split it at this point */
 593                 glob_expand_one(q, argv_ptr, argc_ptr, maxargs_ptr);
 594                 if (!p)
 595                         break;
 596         }
 597
 598         free(s);
 599         free(base);
 600 }
 601
 602 /**
 603  * Convert a string to lower case
 604  **/
 605 void strlower(char *s)
 606 {
 607         while (*s) {
 608                 if (isupper(*(unsigned char *)s))
 609                         *s = tolower(*(unsigned char *)s);
 610                 s++;
 611         }
 612 }
 613
 614 /* Join strings p1 & p2 into "dest" with a guaranteed '/' between them.  (If
 615  * p1 ends with a '/', no extra '/' is inserted.)  Returns the length of both
 616  * strings + 1 (if '/' was inserted), regardless of whether the null-terminated
 617  * string fits into destsize. */
 618 size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2)
 619 {
 620         size_t len = strlcpy(dest, p1, destsize);
 621         if (len < destsize - 1) {
 622                 if (!len || dest[len-1] != '/')
 623                         dest[len++] = '/';
 624                 if (len < destsize - 1)
 625                         len += strlcpy(dest + len, p2, destsize - len);
 626                 else {
 627                         dest[len] = '\0';
 628                         len += strlen(p2);
 629                 }
 630         }
 631         else
 632                 len += strlen(p2) + 1; /* Assume we'd insert a '/'. */
 633         return len;
 634 }
 635
 636 /* Join any number of strings together, putting them in "dest".  The return
 637  * value is the length of all the strings, regardless of whether the null-
 638  * terminated whole fits in destsize.  Your list of string pointers must end
 639  * with a NULL to indicate the end of the list. */
 640 size_t stringjoin(char *dest, size_t destsize, ...)
 641 {
 642         va_list ap;
 643         size_t len, ret = 0;
 644         const char *src;
 645
 646         va_start(ap, destsize);
 647         while (1) {
 648                 if (!(src = va_arg(ap, const char *)))
 649                         break;
 650                 len = strlen(src);
 651                 ret += len;
 652                 if (destsize > 1) {
 653                         if (len >= destsize)
 654                                 len = destsize - 1;
 655                         memcpy(dest, src, len);
 656                         destsize -= len;
 657                         dest += len;
 658                 }
 659         }
 660         *dest = '\0';
 661         va_end(ap);
 662
 663         return ret;
 664 }
 665
 666 int count_dir_elements(const char *p)
 667 {
 668         int cnt = 0, new_component = 1;
 669         while (*p) {
 670                 if (*p++ == '/')
 671                         new_component = 1;
 672                 else if (new_component) {
 673                         new_component = 0;
 674                         cnt++;
 675                 }
 676         }
 677         return cnt;
 678 }
 679
 680 /* Turns multiple adjacent slashes into a single slash, gets rid of "./"
 681  * elements (but not a trailing dot dir), removes a trailing slash, and
 682  * optionally collapses ".." elements (except for those at the start of the
 683  * string).  If the resulting name would be empty, change it into a ".". */
 684 unsigned int clean_fname(char *name, BOOL collapse_dot_dot)
 685 {
 686         char *limit = name - 1, *t = name, *f = name;
 687         int anchored;
 688
 689         if (!name)
 690                 return 0;
 691
 692         if ((anchored = *f == '/') != 0)
 693                 *t++ = *f++;
 694         while (*f) {
 695                 /* discard extra slashes */
 696                 if (*f == '/') {
 697                         f++;
 698                         continue;
 699                 }
 700                 if (*f == '.') {
 701                         /* discard "." dirs (but NOT a trailing '.'!) */
 702                         if (f[1] == '/') {
 703                                 f += 2;
 704                                 continue;
 705                         }
 706                         /* collapse ".." dirs */
 707                         if (collapse_dot_dot
 708                             && f[1] == '.' && (f[2] == '/' || !f[2])) {
 709                                 char *s = t - 1;
 710                                 if (s == name && anchored) {
 711                                         f += 2;
 712                                         continue;
 713                                 }
 714                                 while (s > limit && *--s != '/') {}
 715                                 if (s != t - 1 && (s < name || *s == '/')) {
 716                                         t = s + 1;
 717                                         f += 2;
 718                                         continue;
 719                                 }
 720                                 limit = t + 2;
 721                         }
 722                 }
 723                 while (*f && (*t++ = *f++) != '/') {}
 724         }
 725
 726         if (t > name+anchored && t[-1] == '/')
 727                 t--;
 728         if (t == name)
 729                 *t++ = '.';
 730         *t = '\0';
 731
 732         return t - name;
 733 }
 734
 735 /* Make path appear as if a chroot had occurred.  This handles a leading
 736  * "/" (either removing it or expanding it) and any leading or embedded
 737  * ".." components that attempt to escape past the module's top dir.
 738  *
 739  * If dest is NULL, a buffer is allocated to hold the result.  It is legal
 740  * to call with the dest and the path (p) pointing to the same buffer, but
 741  * rootdir will be ignored to avoid expansion of the string.
 742  *
 743  * The rootdir string contains a value to use in place of a leading slash.
 744  * Specify NULL to get the default of lp_path(module_id).
 745  *
 746  * If depth is >= 0, it is a count of how many '..'s to allow at the start
 747  * of the path.  Use -1 to allow unlimited depth.
 748  *
 749  * We also clean the path in a manner similar to clean_fname() but with a
 750  * few differences:
 751  *
 752  * Turns multiple adjacent slashes into a single slash, gets rid of "." dir
 753  * elements (INCLUDING a trailing dot dir), PRESERVES a trailing slash, and
 754  * ALWAYS collapses ".." elements (except for those at the start of the
 755  * string up to "depth" deep).  If the resulting name would be empty,
 756  * change it into a ".". */
 757 char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth)
 758 {
 759         char *start, *sanp;
 760         int rlen = 0, leave_one_dotdir = relative_paths;
 761
 762         if (dest != p) {
 763                 int plen = strlen(p);
 764                 if (*p == '/') {
 765                         if (!rootdir)
 766                                 rootdir = lp_path(module_id);
 767                         rlen = strlen(rootdir);
 768                         depth = 0;
 769                         p++;
 770                 }
 771                 if (dest) {
 772                         if (rlen + plen + 1 >= MAXPATHLEN)
 773                                 return NULL;
 774                 } else if (!(dest = new_array(char, rlen + plen + 1)))
 775                         out_of_memory("sanitize_path");
 776                 if (rlen) {
 777                         memcpy(dest, rootdir, rlen);
 778                         if (rlen > 1)
 779                                 dest[rlen++] = '/';
 780                 }
 781         }
 782
 783         start = sanp = dest + rlen;
 784         while (*p != '\0') {
 785                 /* discard leading or extra slashes */
 786                 if (*p == '/') {
 787                         p++;
 788                         continue;
 789                 }
 790                 /* this loop iterates once per filename component in p.
 791                  * both p (and sanp if the original had a slash) should
 792                  * always be left pointing after a slash
 793                  */
 794                 if (*p == '.' && (p[1] == '/' || p[1] == '\0')) {
 795                         if (leave_one_dotdir && p[1])
 796                                 leave_one_dotdir = 0;
 797                         else {
 798                                 /* skip "." component */
 799                                 p++;
 800                                 continue;
 801                         }
 802                 }
 803                 if (*p == '.' && p[1] == '.' && (p[2] == '/' || p[2] == '\0')) {
 804                         /* ".." component followed by slash or end */
 805                         if (depth <= 0 || sanp != start) {
 806                                 p += 2;
 807                                 if (sanp != start) {
 808                                         /* back up sanp one level */
 809                                         --sanp; /* now pointing at slash */
 810                                         while (sanp > start && sanp[-1] != '/') {
 811                                                 /* skip back up to slash */
 812                                                 sanp--;
 813                                         }
 814                                 }
 815                                 continue;
 816                         }
 817                         /* allow depth levels of .. at the beginning */
 818                         depth--;
 819                         /* move the virtual beginning to leave the .. alone */
 820                         start = sanp + 3;
 821                 }
 822                 /* copy one component through next slash */
 823                 while (*p && (*sanp++ = *p++) != '/') {}
 824         }
 825         if (sanp == dest) {
 826                 /* ended up with nothing, so put in "." component */
 827                 *sanp++ = '.';
 828         }
 829         *sanp = '\0';
 830
 831         return dest;
 832 }
 833
 834 char curr_dir[MAXPATHLEN];
 835 unsigned int curr_dir_len;
 836
 837 /**
 838  * Like chdir(), but it keeps track of the current directory (in the
 839  * global "curr_dir"), and ensures that the path size doesn't overflow.
 840  * Also cleans the path using the clean_fname() function.
 841  **/
 842 int push_dir(char *dir)
 843 {
 844         static int initialised;
 845         unsigned int len;
 846
 847         if (!initialised) {
 848                 initialised = 1;
 849                 getcwd(curr_dir, sizeof curr_dir - 1);
 850                 curr_dir_len = strlen(curr_dir);
 851         }
 852
 853         if (!dir)       /* this call was probably just to initialize */
 854                 return 0;
 855
 856         len = strlen(dir);
 857         if (len == 1 && *dir == '.')
 858                 return 1;
 859
 860         if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
 861                 return 0;
 862
 863         if (chdir(dir))
 864                 return 0;
 865
 866         if (*dir == '/') {
 867                 memcpy(curr_dir, dir, len + 1);
 868                 curr_dir_len = len;
 869         } else {
 870                 curr_dir[curr_dir_len++] = '/';
 871                 memcpy(curr_dir + curr_dir_len, dir, len + 1);
 872                 curr_dir_len += len;
 873         }
 874
 875         curr_dir_len = clean_fname(curr_dir, 1);
 876
 877         return 1;
 878 }
 879
 880 /**
 881  * Reverse a push_dir() call.  You must pass in an absolute path
 882  * that was copied from a prior value of "curr_dir".
 883  **/
 884 int pop_dir(char *dir)
 885 {
 886         if (chdir(dir))
 887                 return 0;
 888
 889         curr_dir_len = strlcpy(curr_dir, dir, sizeof curr_dir);
 890         if (curr_dir_len >= sizeof curr_dir)
 891                 curr_dir_len = sizeof curr_dir - 1;
 892
 893         return 1;
 894 }
 895
 896 /**
 897  * Return a quoted string with the full pathname of the indicated filename.
 898  * The string " (in MODNAME)" may also be appended.  The returned pointer
 899  * remains valid until the next time full_fname() is called.
 900  **/
 901 char *full_fname(const char *fn)
 902 {
 903         static char *result = NULL;
 904         char *m1, *m2, *m3;
 905         char *p1, *p2;
 906
 907         if (result)
 908                 free(result);
 909
 910         if (*fn == '/')
 911                 p1 = p2 = "";
 912         else {
 913                 p1 = curr_dir;
 914                 for (p2 = p1; *p2 == '/'; p2++) {}
 915                 if (*p2)
 916                         p2 = "/";
 917         }
 918         if (module_id >= 0) {
 919                 m1 = " (in ";
 920                 m2 = lp_name(module_id);
 921                 m3 = ")";
 922                 if (p1 == curr_dir) {
 923                         if (!lp_use_chroot(module_id)) {
 924                                 char *p = lp_path(module_id);
 925                                 if (*p != '/' || p[1])
 926                                         p1 += strlen(p);
 927                         }
 928                 }
 929         } else
 930                 m1 = m2 = m3 = "";
 931
 932         asprintf(&result, "\"%s%s%s\"%s%s%s", p1, p2, fn, m1, m2, m3);
 933
 934         return result;
 935 }
 936
 937 static char partial_fname[MAXPATHLEN];
 938
 939 char *partial_dir_fname(const char *fname)
 940 {
 941         char *t = partial_fname;
 942         int sz = sizeof partial_fname;
 943         const char *fn;
 944
 945         if ((fn = strrchr(fname, '/')) != NULL) {
 946                 fn++;
 947                 if (*partial_dir != '/') {
 948                         int len = fn - fname;
 949                         strncpy(t, fname, len); /* safe */
 950                         t += len;
 951                         sz -= len;
 952                 }
 953         } else
 954                 fn = fname;
 955         if ((int)pathjoin(t, sz, partial_dir, fn) >= sz)
 956                 return NULL;
 957         if (server_filter_list.head) {
 958                 static int len;
 959                 if (!len)
 960                         len = strlen(partial_dir);
 961                 t[len] = '\0';
 962                 if (check_filter(&server_filter_list, partial_fname, 1) < 0)
 963                         return NULL;
 964                 t[len] = '/';
 965                 if (check_filter(&server_filter_list, partial_fname, 0) < 0)
 966                         return NULL;
 967         }
 968
 969         return partial_fname;
 970 }
 971
 972 /* If no --partial-dir option was specified, we don't need to do anything
 973  * (the partial-dir is essentially '.'), so just return success. */
 974 int handle_partial_dir(const char *fname, int create)
 975 {
 976         char *fn, *dir;
 977
 978         if (fname != partial_fname)
 979                 return 1;
 980         if (!create && *partial_dir == '/')
 981                 return 1;
 982         if (!(fn = strrchr(partial_fname, '/')))
 983                 return 1;
 984
 985         *fn = '\0';
 986         dir = partial_fname;
 987         if (create) {
 988                 STRUCT_STAT st;
 989                 int statret = do_lstat(dir, &st);
 990                 if (statret == 0 && !S_ISDIR(st.st_mode)) {
 991                         if (do_unlink(dir) < 0)
 992                                 return 0;
 993                         statret = -1;
 994                 }
 995                 if (statret < 0 && do_mkdir(dir, 0700) < 0)
 996                         return 0;
 997         } else
 998                 do_rmdir(dir);
 999         *fn = '/';
1000
1001         return 1;
1002 }
1003
1004 /**
1005  * Determine if a symlink points outside the current directory tree.
1006  * This is considered "unsafe" because e.g. when mirroring somebody
1007  * else's machine it might allow them to establish a symlink to
1008  * /etc/passwd, and then read it through a web server.
1009  *
1010  * Null symlinks and absolute symlinks are always unsafe.
1011  *
1012  * Basically here we are concerned with symlinks whose target contains
1013  * "..", because this might cause us to walk back up out of the
1014  * transferred directory.  We are not allowed to go back up and
1015  * reenter.
1016  *
1017  * @param dest Target of the symlink in question.
1018  *
1019  * @param src Top source directory currently applicable.  Basically this
1020  * is the first parameter to rsync in a simple invocation, but it's
1021  * modified by flist.c in slightly complex ways.
1022  *
1023  * @retval True if unsafe
1024  * @retval False is unsafe
1025  *
1026  * @sa t_unsafe.c
1027  **/
1028 int unsafe_symlink(const char *dest, const char *src)
1029 {
1030         const char *name, *slash;
1031         int depth = 0;
1032
1033         /* all absolute and null symlinks are unsafe */
1034         if (!dest || !*dest || *dest == '/')
1035                 return 1;
1036
1037         /* find out what our safety margin is */
1038         for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
1039                 if (strncmp(name, "../", 3) == 0) {
1040                         depth = 0;
1041                 } else if (strncmp(name, "./", 2) == 0) {
1042                         /* nothing */
1043                 } else {
1044                         depth++;
1045                 }
1046         }
1047         if (strcmp(name, "..") == 0)
1048                 depth = 0;
1049
1050         for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
1051                 if (strncmp(name, "../", 3) == 0) {
1052                         /* if at any point we go outside the current directory
1053                            then stop - it is unsafe */
1054                         if (--depth < 0)
1055                                 return 1;
1056                 } else if (strncmp(name, "./", 2) == 0) {
1057                         /* nothing */
1058                 } else {
1059                         depth++;
1060                 }
1061         }
1062         if (strcmp(name, "..") == 0)
1063                 depth--;
1064
1065         return (depth < 0);
1066 }
1067
1068 /* Return the int64 number as a string.  If the --human-readable option was
1069  * specified, we may output the number in K, M, or G units.  We can return
1070  * up to 4 buffers at a time. */
1071 char *human_num(int64 num)
1072 {
1073         static char bufs[4][128]; /* more than enough room */
1074         static unsigned int n;
1075         char *s;
1076
1077         n = (n + 1) % (sizeof bufs / sizeof bufs[0]);
1078
1079         if (human_readable) {
1080                 char units = '\0';
1081                 int mult = human_readable == 1 ? 1024 : 1000;
1082                 double dnum = 0;
1083                 if (num > mult*mult*mult) {
1084                         dnum = (double)num / (mult*mult*mult);
1085                         units = 'G';
1086                 } else if (num > mult*mult) {
1087                         dnum = (double)num / (mult*mult);
1088                         units = 'M';
1089                 } else if (num > mult) {
1090                         dnum = (double)num / mult;
1091                         units = 'K';
1092                 }
1093                 if (units) {
1094                         sprintf(bufs[n], "%.2f%c", dnum, units);
1095                         return bufs[n];
1096                 }
1097         }
1098
1099         s = bufs[n] + sizeof bufs[0] - 1;
1100         *s = '\0';
1101
1102         if (!num)
1103                 *--s = '0';
1104         while (num) {
1105                 *--s = (num % 10) + '0';
1106                 num /= 10;
1107         }
1108         return s;
1109 }
1110
1111 /* Return the double number as a string.  If the --human-readable option was
1112  * specified, we may output the number in K, M, or G units.  We use a buffer
1113  * from human_num() to return our result. */
1114 char *human_dnum(double dnum, int decimal_digits)
1115 {
1116         char *buf = human_num(dnum);
1117         int len = strlen(buf);
1118         if (isdigit(*(uchar*)(buf+len-1))) {
1119                 /* There's extra room in buf prior to the start of the num. */
1120                 buf -= decimal_digits + 1;
1121                 snprintf(buf, len + decimal_digits + 2, "%.*f", decimal_digits, dnum);
1122         }
1123         return buf;
1124 }
1125
1126 /**
1127  * Return the date and time as a string
1128  **/
1129 char *timestring(time_t t)
1130 {
1131         static char TimeBuf[200];
1132         struct tm *tm = localtime(&t);
1133
1134 #ifdef HAVE_STRFTIME
1135         strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1136 #else
1137         strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1138 #endif
1139
1140         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1141                 TimeBuf[strlen(TimeBuf)-1] = 0;
1142         }
1143
1144         return(TimeBuf);
1145 }
1146
1147
1148 /**
1149  * Sleep for a specified number of milliseconds.
1150  *
1151  * Always returns TRUE.  (In the future it might return FALSE if
1152  * interrupted.)
1153  **/
1154 int msleep(int t)
1155 {
1156         int tdiff = 0;
1157         struct timeval tval, t1, t2;
1158
1159         gettimeofday(&t1, NULL);
1160
1161         while (tdiff < t) {
1162                 tval.tv_sec = (t-tdiff)/1000;
1163                 tval.tv_usec = 1000*((t-tdiff)%1000);
1164
1165                 errno = 0;
1166                 select(0,NULL,NULL, NULL, &tval);
1167
1168                 gettimeofday(&t2, NULL);
1169                 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1170                         (t2.tv_usec - t1.tv_usec)/1000;
1171         }
1172
1173         return True;
1174 }
1175
1176
1177 /**
1178  * Determine if two file modification times are equivalent (either
1179  * exact or in the modification timestamp window established by
1180  * --modify-window).
1181  *
1182  * @retval 0 if the times should be treated as the same
1183  *
1184  * @retval +1 if the first is later
1185  *
1186  * @retval -1 if the 2nd is later
1187  **/
1188 int cmp_modtime(time_t file1, time_t file2)
1189 {
1190         if (file2 > file1) {
1191                 if (file2 - file1 <= modify_window)
1192                         return 0;
1193                 return -1;
1194         }
1195         if (file1 - file2 <= modify_window)
1196                 return 0;
1197         return 1;
1198 }
1199
1200
1201 #ifdef __INSURE__XX
1202 #include <dlfcn.h>
1203
1204 /**
1205    This routine is a trick to immediately catch errors when debugging
1206    with insure. A xterm with a gdb is popped up when insure catches
1207    a error. It is Linux specific.
1208 **/
1209 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1210 {
1211         static int (*fn)();
1212         int ret;
1213         char *cmd;
1214
1215         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'",
1216                 getpid(), getpid(), getpid());
1217
1218         if (!fn) {
1219                 static void *h;
1220                 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1221                 fn = dlsym(h, "_Insure_trap_error");
1222         }
1223
1224         ret = fn(a1, a2, a3, a4, a5, a6);
1225
1226         system(cmd);
1227
1228         free(cmd);
1229
1230         return ret;
1231 }
1232 #endif
1233
1234
1235 #define MALLOC_MAX 0x40000000
1236
1237 void *_new_array(unsigned int size, unsigned long num)
1238 {
1239         if (num >= MALLOC_MAX/size)
1240                 return NULL;
1241         return malloc(size * num);
1242 }
1243
1244 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1245 {
1246         if (num >= MALLOC_MAX/size)
1247                 return NULL;
1248         /* No realloc should need this, but just in case... */
1249         if (!ptr)
1250                 return malloc(size * num);
1251         return realloc(ptr, size * num);
1252 }
1253
1254 /* Take a filename and filename length and return the most significant
1255  * filename suffix we can find.  This ignores suffixes such as "~",
1256  * ".bak", ".orig", ".~1~", etc. */
1257 const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr)
1258 {
1259         const char *suf, *s;
1260         BOOL had_tilde;
1261         int s_len;
1262
1263         /* One or more dots at the start aren't a suffix. */
1264         while (fn_len && *fn == '.') fn++, fn_len--;
1265
1266         /* Ignore the ~ in a "foo~" filename. */
1267         if (fn_len > 1 && fn[fn_len-1] == '~')
1268                 fn_len--, had_tilde = True;
1269         else
1270                 had_tilde = False;
1271
1272         /* Assume we don't find an suffix. */
1273         suf = "";
1274         *len_ptr = 0;
1275
1276         /* Find the last significant suffix. */
1277         for (s = fn + fn_len; fn_len > 1; ) {
1278                 while (*--s != '.' && s != fn) {}
1279                 if (s == fn)
1280                         break;
1281                 s_len = fn_len - (s - fn);
1282                 fn_len = s - fn;
1283                 if (s_len == 4) {
1284                         if (strcmp(s+1, "bak") == 0
1285                          || strcmp(s+1, "old") == 0)
1286                                 continue;
1287                 } else if (s_len == 5) {
1288                         if (strcmp(s+1, "orig") == 0)
1289                                 continue;
1290                 } else if (s_len > 2 && had_tilde
1291                     && s[1] == '~' && isdigit(*(uchar*)(s+2)))
1292                         continue;
1293                 *len_ptr = s_len;
1294                 suf = s;
1295                 if (s_len == 1)
1296                         break;
1297                 /* Determine if the suffix is all digits. */
1298                 for (s++, s_len--; s_len > 0; s++, s_len--) {
1299                         if (!isdigit(*(uchar*)s))
1300                                 return suf;
1301                 }
1302                 /* An all-digit suffix may not be that signficant. */
1303                 s = suf;
1304         }
1305
1306         return suf;
1307 }
1308
1309 /* This is an implementation of the Levenshtein distance algorithm.  It
1310  * was implemented to avoid needing a two-dimensional matrix (to save
1311  * memory).  It was also tweaked to try to factor in the ASCII distance
1312  * between changed characters as a minor distance quantity.  The normal
1313  * Levenshtein units of distance (each signifying a single change between
1314  * the two strings) are defined as a "UNIT". */
1315
1316 #define UNIT (1 << 16)
1317
1318 uint32 fuzzy_distance(const char *s1, int len1, const char *s2, int len2)
1319 {
1320         uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
1321         int32 cost;
1322         int i1, i2;
1323
1324         if (!len1 || !len2) {
1325                 if (!len1) {
1326                         s1 = s2;
1327                         len1 = len2;
1328                 }
1329                 for (i1 = 0, cost = 0; i1 < len1; i1++)
1330                         cost += s1[i1];
1331                 return (int32)len1 * UNIT + cost;
1332         }
1333
1334         for (i2 = 0; i2 < len2; i2++)
1335                 a[i2] = (i2+1) * UNIT;
1336
1337         for (i1 = 0; i1 < len1; i1++) {
1338                 diag = i1 * UNIT;
1339                 above = (i1+1) * UNIT;
1340                 for (i2 = 0; i2 < len2; i2++) {
1341                         left = a[i2];
1342                         if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
1343                                 if (cost < 0)
1344                                         cost = UNIT - cost;
1345                                 else
1346                                         cost = UNIT + cost;
1347                         }
1348                         diag_inc = diag + cost;
1349                         left_inc = left + UNIT + *((uchar*)s1+i1);
1350                         above_inc = above + UNIT + *((uchar*)s2+i2);
1351                         a[i2] = above = left < above
1352                               ? (left_inc < diag_inc ? left_inc : diag_inc)
1353                               : (above_inc < diag_inc ? above_inc : diag_inc);
1354                         diag = left;
1355                 }
1356         }
1357
1358         return a[len2-1];
1359 }