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 /** We need to supply our own strcmp function for file list comparisons
1005    to ensure that signed/unsigned usage is consistent between machines. */
1006 int u_strcmp(const char *cs1, const char *cs2)
1007 {
1008         const uchar *s1 = (const uchar *)cs1;
1009         const uchar *s2 = (const uchar *)cs2;
1010
1011         while (*s1 && *s2 && (*s1 == *s2)) {
1012                 s1++; s2++;
1013         }
1014
1015         return (int)*s1 - (int)*s2;
1016 }
1017
1018
1019
1020 /**
1021  * Determine if a symlink points outside the current directory tree.
1022  * This is considered "unsafe" because e.g. when mirroring somebody
1023  * else's machine it might allow them to establish a symlink to
1024  * /etc/passwd, and then read it through a web server.
1025  *
1026  * Null symlinks and absolute symlinks are always unsafe.
1027  *
1028  * Basically here we are concerned with symlinks whose target contains
1029  * "..", because this might cause us to walk back up out of the
1030  * transferred directory.  We are not allowed to go back up and
1031  * reenter.
1032  *
1033  * @param dest Target of the symlink in question.
1034  *
1035  * @param src Top source directory currently applicable.  Basically this
1036  * is the first parameter to rsync in a simple invocation, but it's
1037  * modified by flist.c in slightly complex ways.
1038  *
1039  * @retval True if unsafe
1040  * @retval False is unsafe
1041  *
1042  * @sa t_unsafe.c
1043  **/
1044 int unsafe_symlink(const char *dest, const char *src)
1045 {
1046         const char *name, *slash;
1047         int depth = 0;
1048
1049         /* all absolute and null symlinks are unsafe */
1050         if (!dest || !*dest || *dest == '/')
1051                 return 1;
1052
1053         /* find out what our safety margin is */
1054         for (name = src; (slash = strchr(name, '/')) != 0; name = slash+1) {
1055                 if (strncmp(name, "../", 3) == 0) {
1056                         depth = 0;
1057                 } else if (strncmp(name, "./", 2) == 0) {
1058                         /* nothing */
1059                 } else {
1060                         depth++;
1061                 }
1062         }
1063         if (strcmp(name, "..") == 0)
1064                 depth = 0;
1065
1066         for (name = dest; (slash = strchr(name, '/')) != 0; name = slash+1) {
1067                 if (strncmp(name, "../", 3) == 0) {
1068                         /* if at any point we go outside the current directory
1069                            then stop - it is unsafe */
1070                         if (--depth < 0)
1071                                 return 1;
1072                 } else if (strncmp(name, "./", 2) == 0) {
1073                         /* nothing */
1074                 } else {
1075                         depth++;
1076                 }
1077         }
1078         if (strcmp(name, "..") == 0)
1079                 depth--;
1080
1081         return (depth < 0);
1082 }
1083
1084 /* Return the int64 number as a string.  If the --human-readable option was
1085  * specified, we may output the number in K, M, or G units.  We can return
1086  * up to 4 buffers at a time. */
1087 char *human_num(int64 num)
1088 {
1089         static char bufs[4][128]; /* more than enough room */
1090         static unsigned int n;
1091         char *s;
1092
1093         n = (n + 1) % (sizeof bufs / sizeof bufs[0]);
1094
1095         if (human_readable) {
1096                 char units = '\0';
1097                 int mult = human_readable == 1 ? 1024 : 1000;
1098                 double dnum = 0;
1099                 if (num > mult*mult*mult) {
1100                         dnum = (double)num / (mult*mult*mult);
1101                         units = 'G';
1102                 } else if (num > mult*mult) {
1103                         dnum = (double)num / (mult*mult);
1104                         units = 'M';
1105                 } else if (num > mult) {
1106                         dnum = (double)num / mult;
1107                         units = 'K';
1108                 }
1109                 if (units) {
1110                         sprintf(bufs[n], "%.2f%c", dnum, units);
1111                         return bufs[n];
1112                 }
1113         }
1114
1115         s = bufs[n] + sizeof bufs[0] - 1;
1116         *s = '\0';
1117
1118         if (!num)
1119                 *--s = '0';
1120         while (num) {
1121                 *--s = (num % 10) + '0';
1122                 num /= 10;
1123         }
1124         return s;
1125 }
1126
1127 /* Return the double number as a string.  If the --human-readable option was
1128  * specified, we may output the number in K, M, or G units.  We use a buffer
1129  * from human_num() to return our result. */
1130 char *human_dnum(double dnum, int decimal_digits)
1131 {
1132         char *buf = human_num(dnum);
1133         int len = strlen(buf);
1134         if (isdigit(*(uchar*)(buf+len-1))) {
1135                 /* There's extra room in buf prior to the start of the num. */
1136                 buf -= decimal_digits + 1;
1137                 snprintf(buf, len + decimal_digits + 2, "%.*f", decimal_digits, dnum);
1138         }
1139         return buf;
1140 }
1141
1142 /**
1143  * Return the date and time as a string
1144  **/
1145 char *timestring(time_t t)
1146 {
1147         static char TimeBuf[200];
1148         struct tm *tm = localtime(&t);
1149
1150 #ifdef HAVE_STRFTIME
1151         strftime(TimeBuf, sizeof TimeBuf - 1, "%Y/%m/%d %H:%M:%S", tm);
1152 #else
1153         strlcpy(TimeBuf, asctime(tm), sizeof TimeBuf);
1154 #endif
1155
1156         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
1157                 TimeBuf[strlen(TimeBuf)-1] = 0;
1158         }
1159
1160         return(TimeBuf);
1161 }
1162
1163
1164 /**
1165  * Sleep for a specified number of milliseconds.
1166  *
1167  * Always returns TRUE.  (In the future it might return FALSE if
1168  * interrupted.)
1169  **/
1170 int msleep(int t)
1171 {
1172         int tdiff = 0;
1173         struct timeval tval, t1, t2;
1174
1175         gettimeofday(&t1, NULL);
1176
1177         while (tdiff < t) {
1178                 tval.tv_sec = (t-tdiff)/1000;
1179                 tval.tv_usec = 1000*((t-tdiff)%1000);
1180
1181                 errno = 0;
1182                 select(0,NULL,NULL, NULL, &tval);
1183
1184                 gettimeofday(&t2, NULL);
1185                 tdiff = (t2.tv_sec - t1.tv_sec)*1000 +
1186                         (t2.tv_usec - t1.tv_usec)/1000;
1187         }
1188
1189         return True;
1190 }
1191
1192
1193 /**
1194  * Determine if two file modification times are equivalent (either
1195  * exact or in the modification timestamp window established by
1196  * --modify-window).
1197  *
1198  * @retval 0 if the times should be treated as the same
1199  *
1200  * @retval +1 if the first is later
1201  *
1202  * @retval -1 if the 2nd is later
1203  **/
1204 int cmp_modtime(time_t file1, time_t file2)
1205 {
1206         if (file2 > file1) {
1207                 if (file2 - file1 <= modify_window)
1208                         return 0;
1209                 return -1;
1210         }
1211         if (file1 - file2 <= modify_window)
1212                 return 0;
1213         return 1;
1214 }
1215
1216
1217 #ifdef __INSURE__XX
1218 #include <dlfcn.h>
1219
1220 /**
1221    This routine is a trick to immediately catch errors when debugging
1222    with insure. A xterm with a gdb is popped up when insure catches
1223    a error. It is Linux specific.
1224 **/
1225 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
1226 {
1227         static int (*fn)();
1228         int ret;
1229         char *cmd;
1230
1231         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'",
1232                 getpid(), getpid(), getpid());
1233
1234         if (!fn) {
1235                 static void *h;
1236                 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
1237                 fn = dlsym(h, "_Insure_trap_error");
1238         }
1239
1240         ret = fn(a1, a2, a3, a4, a5, a6);
1241
1242         system(cmd);
1243
1244         free(cmd);
1245
1246         return ret;
1247 }
1248 #endif
1249
1250
1251 #define MALLOC_MAX 0x40000000
1252
1253 void *_new_array(unsigned int size, unsigned long num)
1254 {
1255         if (num >= MALLOC_MAX/size)
1256                 return NULL;
1257         return malloc(size * num);
1258 }
1259
1260 void *_realloc_array(void *ptr, unsigned int size, unsigned long num)
1261 {
1262         if (num >= MALLOC_MAX/size)
1263                 return NULL;
1264         /* No realloc should need this, but just in case... */
1265         if (!ptr)
1266                 return malloc(size * num);
1267         return realloc(ptr, size * num);
1268 }
1269
1270 /* Take a filename and filename length and return the most significant
1271  * filename suffix we can find.  This ignores suffixes such as "~",
1272  * ".bak", ".orig", ".~1~", etc. */
1273 const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr)
1274 {
1275         const char *suf, *s;
1276         BOOL had_tilde;
1277         int s_len;
1278
1279         /* One or more dots at the start aren't a suffix. */
1280         while (fn_len && *fn == '.') fn++, fn_len--;
1281
1282         /* Ignore the ~ in a "foo~" filename. */
1283         if (fn_len > 1 && fn[fn_len-1] == '~')
1284                 fn_len--, had_tilde = True;
1285         else
1286                 had_tilde = False;
1287
1288         /* Assume we don't find an suffix. */
1289         suf = "";
1290         *len_ptr = 0;
1291
1292         /* Find the last significant suffix. */
1293         for (s = fn + fn_len; fn_len > 1; ) {
1294                 while (*--s != '.' && s != fn) {}
1295                 if (s == fn)
1296                         break;
1297                 s_len = fn_len - (s - fn);
1298                 fn_len = s - fn;
1299                 if (s_len == 4) {
1300                         if (strcmp(s+1, "bak") == 0
1301                          || strcmp(s+1, "old") == 0)
1302                                 continue;
1303                 } else if (s_len == 5) {
1304                         if (strcmp(s+1, "orig") == 0)
1305                                 continue;
1306                 } else if (s_len > 2 && had_tilde
1307                     && s[1] == '~' && isdigit(*(uchar*)(s+2)))
1308                         continue;
1309                 *len_ptr = s_len;
1310                 suf = s;
1311                 if (s_len == 1)
1312                         break;
1313                 /* Determine if the suffix is all digits. */
1314                 for (s++, s_len--; s_len > 0; s++, s_len--) {
1315                         if (!isdigit(*(uchar*)s))
1316                                 return suf;
1317                 }
1318                 /* An all-digit suffix may not be that signficant. */
1319                 s = suf;
1320         }
1321
1322         return suf;
1323 }
1324
1325 /* This is an implementation of the Levenshtein distance algorithm.  It
1326  * was implemented to avoid needing a two-dimensional matrix (to save
1327  * memory).  It was also tweaked to try to factor in the ASCII distance
1328  * between changed characters as a minor distance quantity.  The normal
1329  * Levenshtein units of distance (each signifying a single change between
1330  * the two strings) are defined as a "UNIT". */
1331
1332 #define UNIT (1 << 16)
1333
1334 uint32 fuzzy_distance(const char *s1, int len1, const char *s2, int len2)
1335 {
1336         uint32 a[MAXPATHLEN], diag, above, left, diag_inc, above_inc, left_inc;
1337         int32 cost;
1338         int i1, i2;
1339
1340         if (!len1 || !len2) {
1341                 if (!len1) {
1342                         s1 = s2;
1343                         len1 = len2;
1344                 }
1345                 for (i1 = 0, cost = 0; i1 < len1; i1++)
1346                         cost += s1[i1];
1347                 return (int32)len1 * UNIT + cost;
1348         }
1349
1350         for (i2 = 0; i2 < len2; i2++)
1351                 a[i2] = (i2+1) * UNIT;
1352
1353         for (i1 = 0; i1 < len1; i1++) {
1354                 diag = i1 * UNIT;
1355                 above = (i1+1) * UNIT;
1356                 for (i2 = 0; i2 < len2; i2++) {
1357                         left = a[i2];
1358                         if ((cost = *((uchar*)s1+i1) - *((uchar*)s2+i2)) != 0) {
1359                                 if (cost < 0)
1360                                         cost = UNIT - cost;
1361                                 else
1362                                         cost = UNIT + cost;
1363                         }
1364                         diag_inc = diag + cost;
1365                         left_inc = left + UNIT + *((uchar*)s1+i1);
1366                         above_inc = above + UNIT + *((uchar*)s2+i2);
1367                         a[i2] = above = left < above
1368                               ? (left_inc < diag_inc ? left_inc : diag_inc)
1369                               : (above_inc < diag_inc ? above_inc : diag_inc);
1370                         diag = left;
1371                 }
1372         }
1373
1374         return a[len2-1];
1375 }