util.c

   1 /*
   2    Copyright (C) Andrew Tridgell 1996
   3    Copyright (C) Paul Mackerras 1996
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 /*
  21   Utilities used in rsync
  22
  23   tridge, June 1996
  24   */
  25 #include "rsync.h"
  26
  27 extern int verbose;
  28
  29 /****************************************************************************
  30 Set a fd into nonblocking mode. Uses POSIX O_NONBLOCK if available,
  31 else
  32 if SYSV use O_NDELAY
  33 if BSD use FNDELAY
  34 ****************************************************************************/
  35 int set_nonblocking(int fd)
  36 {
  37         int val;
  38 #ifdef O_NONBLOCK
  39 #define FLAG_TO_SET O_NONBLOCK
  40 #else
  41 #ifdef SYSV
  42 #define FLAG_TO_SET O_NDELAY
  43 #else /* BSD */
  44 #define FLAG_TO_SET FNDELAY
  45 #endif
  46 #endif
  47
  48         if((val = fcntl(fd, F_GETFL, 0)) == -1)
  49                 return -1;
  50         val |= FLAG_TO_SET;
  51         return fcntl( fd, F_SETFL, val);
  52 #undef FLAG_TO_SET
  53 }
  54
  55
  56 /* this is taken from CVS */
  57 int piped_child(char **command,int *f_in,int *f_out)
  58 {
  59   int pid;
  60   int to_child_pipe[2];
  61   int from_child_pipe[2];
  62
  63   if (pipe(to_child_pipe) < 0 ||
  64       pipe(from_child_pipe) < 0) {
  65     rprintf(FERROR,"pipe: %s\n",strerror(errno));
  66     exit_cleanup(RERR_IPC);
  67   }
  68
  69
  70   pid = do_fork();
  71   if (pid < 0) {
  72     rprintf(FERROR,"fork: %s\n",strerror(errno));
  73     exit_cleanup(RERR_IPC);
  74   }
  75
  76   if (pid == 0)
  77     {
  78       extern int orig_umask;
  79       if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
  80           close(to_child_pipe[1]) < 0 ||
  81           close(from_child_pipe[0]) < 0 ||
  82           dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
  83         rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
  84         exit_cleanup(RERR_IPC);
  85       }
  86       if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
  87       if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
  88       umask(orig_umask);
  89       execvp(command[0], command);
  90       rprintf(FERROR,"Failed to exec %s : %s\n",
  91               command[0],strerror(errno));
  92       exit_cleanup(RERR_IPC);
  93     }
  94
  95   if (close(from_child_pipe[1]) < 0 ||
  96       close(to_child_pipe[0]) < 0) {
  97     rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
  98     exit_cleanup(RERR_IPC);
  99   }
 100
 101   *f_in = from_child_pipe[0];
 102   *f_out = to_child_pipe[1];
 103
 104   set_nonblocking(*f_in);
 105   set_nonblocking(*f_out);
 106
 107   return pid;
 108 }
 109
 110 int local_child(int argc, char **argv,int *f_in,int *f_out)
 111 {
 112         int pid;
 113         int to_child_pipe[2];
 114         int from_child_pipe[2];
 115
 116         if (pipe(to_child_pipe) < 0 ||
 117             pipe(from_child_pipe) < 0) {
 118                 rprintf(FERROR,"pipe: %s\n",strerror(errno));
 119                 exit_cleanup(RERR_IPC);
 120         }
 121
 122
 123         pid = do_fork();
 124         if (pid < 0) {
 125                 rprintf(FERROR,"fork: %s\n",strerror(errno));
 126                 exit_cleanup(RERR_IPC);
 127         }
 128
 129         if (pid == 0) {
 130                 extern int am_sender;
 131                 extern int am_server;
 132
 133                 am_sender = !am_sender;
 134                 am_server = 1;
 135
 136                 if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
 137                     close(to_child_pipe[1]) < 0 ||
 138                     close(from_child_pipe[0]) < 0 ||
 139                     dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
 140                         rprintf(FERROR,"Failed to dup/close : %s\n",strerror(errno));
 141                         exit_cleanup(RERR_IPC);
 142                 }
 143                 if (to_child_pipe[0] != STDIN_FILENO) close(to_child_pipe[0]);
 144                 if (from_child_pipe[1] != STDOUT_FILENO) close(from_child_pipe[1]);
 145                 start_server(STDIN_FILENO, STDOUT_FILENO, argc, argv);
 146         }
 147
 148         if (close(from_child_pipe[1]) < 0 ||
 149             close(to_child_pipe[0]) < 0) {
 150                 rprintf(FERROR,"Failed to close : %s\n",strerror(errno));
 151                 exit_cleanup(RERR_IPC);
 152         }
 153
 154         *f_in = from_child_pipe[0];
 155         *f_out = to_child_pipe[1];
 156
 157         return pid;
 158 }
 159
 160
 161
 162 void out_of_memory(char *str)
 163 {
 164   rprintf(FERROR,"ERROR: out of memory in %s\n",str);
 165   exit_cleanup(RERR_MALLOC);
 166 }
 167
 168 void overflow(char *str)
 169 {
 170   rprintf(FERROR,"ERROR: buffer overflow in %s\n",str);
 171   exit_cleanup(RERR_MALLOC);
 172 }
 173
 174
 175
 176 int set_modtime(char *fname,time_t modtime)
 177 {
 178         extern int dry_run;
 179         if (dry_run) return 0;
 180         {
 181 #ifdef HAVE_UTIMBUF
 182                 struct utimbuf tbuf;
 183                 tbuf.actime = time(NULL);
 184                 tbuf.modtime = modtime;
 185                 return utime(fname,&tbuf);
 186 #elif defined(HAVE_UTIME)
 187                 time_t t[2];
 188                 t[0] = time(NULL);
 189                 t[1] = modtime;
 190                 return utime(fname,t);
 191 #else
 192                 struct timeval t[2];
 193                 t[0].tv_sec = time(NULL);
 194                 t[0].tv_usec = 0;
 195                 t[1].tv_sec = modtime;
 196                 t[1].tv_usec = 0;
 197                 return utimes(fname,t);
 198 #endif
 199         }
 200 }
 201
 202
 203 /****************************************************************************
 204 create any necessary directories in fname. Unfortunately we don't know
 205 what perms to give the directory when this is called so we need to rely
 206 on the umask
 207 ****************************************************************************/
 208 int create_directory_path(char *fname)
 209 {
 210         extern int orig_umask;
 211         char *p;
 212
 213         while (*fname == '/') fname++;
 214         while (strncmp(fname,"./",2)==0) fname += 2;
 215
 216         p = fname;
 217         while ((p=strchr(p,'/'))) {
 218                 *p = 0;
 219                 do_mkdir(fname,0777 & ~orig_umask);
 220                 *p = '/';
 221                 p++;
 222         }
 223         return 0;
 224 }
 225
 226
 227 /* Write LEN bytes at PTR to descriptor DESC, retrying if interrupted.
 228    Return LEN upon success, write's (negative) error code otherwise.
 229
 230    derived from GNU C's cccp.c.
 231 */
 232 static int full_write(int desc, char *ptr, int len)
 233 {
 234         int total_written;
 235
 236         total_written = 0;
 237         while (len > 0) {
 238                 int written = write (desc, ptr, len);
 239                 if (written < 0)  {
 240 #ifdef EINTR
 241                         if (errno == EINTR)
 242                                 continue;
 243 #endif
 244                         return written;
 245                 }
 246                 total_written += written;
 247                 ptr += written;
 248                 len -= written;
 249         }
 250         return total_written;
 251 }
 252
 253 /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
 254    Return the actual number of bytes read, zero for EOF, or negative
 255    for an error.
 256
 257    derived from GNU C's cccp.c. */
 258 static int safe_read(int desc, char *ptr, int len)
 259 {
 260         int n_chars;
 261
 262         if (len <= 0)
 263                 return len;
 264
 265 #ifdef EINTR
 266         do {
 267                 n_chars = read(desc, ptr, len);
 268         } while (n_chars < 0 && errno == EINTR);
 269 #else
 270         n_chars = read(desc, ptr, len);
 271 #endif
 272
 273         return n_chars;
 274 }
 275
 276
 277 /* copy a file - this is used in conjunction with the --temp-dir option */
 278 int copy_file(char *source, char *dest, mode_t mode)
 279 {
 280         int ifd;
 281         int ofd;
 282         char buf[1024 * 8];
 283         int len;   /* Number of bytes read into `buf'. */
 284
 285         ifd = open(source, O_RDONLY);
 286         if (ifd == -1) {
 287                 rprintf(FERROR,"open %s: %s\n",
 288                         source,strerror(errno));
 289                 return -1;
 290         }
 291
 292         if (robust_unlink(dest) && errno != ENOENT) {
 293                 rprintf(FERROR,"unlink %s: %s\n",
 294                         dest,strerror(errno));
 295                 return -1;
 296         }
 297
 298         ofd = do_open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, mode);
 299         if (ofd == -1) {
 300                 rprintf(FERROR,"open %s: %s\n",
 301                         dest,strerror(errno));
 302                 close(ifd);
 303                 return -1;
 304         }
 305
 306         while ((len = safe_read(ifd, buf, sizeof(buf))) > 0) {
 307                 if (full_write(ofd, buf, len) < 0) {
 308                         rprintf(FERROR,"write %s: %s\n",
 309                                 dest,strerror(errno));
 310                         close(ifd);
 311                         close(ofd);
 312                         return -1;
 313                 }
 314         }
 315
 316         close(ifd);
 317         close(ofd);
 318
 319         if (len < 0) {
 320                 rprintf(FERROR,"read %s: %s\n",
 321                         source,strerror(errno));
 322                 return -1;
 323         }
 324
 325         return 0;
 326 }
 327
 328 /*
 329   Robust unlink: some OS'es (HPUX) refuse to unlink busy files, so
 330   rename to <path>/.rsyncNNN instead. Note that successive rsync runs
 331   will shuffle the filenames around a bit as long as the file is still
 332   busy; this is because this function does not know if the unlink call
 333   is due to a new file coming in, or --delete trying to remove old
 334   .rsyncNNN files, hence it renames it each time.
 335 */
 336 /* MAX_RENAMES should be 10**MAX_RENAMES_DIGITS */
 337 #define MAX_RENAMES_DIGITS 3
 338 #define MAX_RENAMES 1000
 339
 340 int robust_unlink(char *fname)
 341 {
 342 #ifndef ETXTBSY
 343         return do_unlink(fname);
 344 #else
 345         static int counter = 1;
 346         int rc, pos, start;
 347         char path[MAXPATHLEN];
 348
 349         rc = do_unlink(fname);
 350         if ((rc == 0) || (errno != ETXTBSY))
 351                 return rc;
 352
 353         strlcpy(path, fname, MAXPATHLEN);
 354
 355         pos = strlen(path);
 356         while((path[--pos] != '/') && (pos >= 0))
 357                 ;
 358         ++pos;
 359         strlcpy(&path[pos], ".rsync", MAXPATHLEN-pos);
 360         pos += sizeof(".rsync")-1;
 361
 362         if (pos > (MAXPATHLEN-MAX_RENAMES_DIGITS-1)) {
 363                 errno = ETXTBSY;
 364                 return -1;
 365         }
 366
 367         /* start where the last one left off to reduce chance of clashes */
 368         start = counter;
 369         do {
 370                 sprintf(&path[pos], "%03d", counter);
 371                 if (++counter >= MAX_RENAMES)
 372                         counter = 1;
 373         } while (((rc = access(path, 0)) == 0) && (counter != start));
 374
 375         if (verbose > 0)
 376                 rprintf(FINFO,"renaming %s to %s because of text busy\n",
 377                                             fname, path);
 378
 379         /* maybe we should return rename()'s exit status? Nah. */
 380         if (do_rename(fname, path) != 0) {
 381                 errno = ETXTBSY;
 382                 return -1;
 383         }
 384         return 0;
 385 #endif
 386 }
 387
 388 int robust_rename(char *from, char *to)
 389 {
 390 #ifndef ETXTBSY
 391         return do_rename(from, to);
 392 #else
 393         int rc = do_rename(from, to);
 394         if ((rc == 0) || (errno != ETXTBSY))
 395                 return rc;
 396         if (robust_unlink(to) != 0)
 397                 return -1;
 398         return do_rename(from, to);
 399 #endif
 400     }
 401
 402
 403 /* sleep for a while via select */
 404 void u_sleep(int usec)
 405 {
 406         struct timeval tv;
 407
 408         tv.tv_sec = 0;
 409         tv.tv_usec = usec;
 410         select(0, NULL, NULL, NULL, &tv);
 411 }
 412
 413
 414 static pid_t all_pids[10];
 415 static int num_pids;
 416
 417 /* fork and record the pid of the child */
 418 pid_t do_fork(void)
 419 {
 420         pid_t newpid = fork();
 421
 422         if (newpid) {
 423                 all_pids[num_pids++] = newpid;
 424         }
 425         return newpid;
 426 }
 427
 428 /* kill all children */
 429 void kill_all(int sig)
 430 {
 431         int i;
 432         for (i=0;i<num_pids;i++) {
 433                 if (all_pids[i] != getpid())
 434                         kill(all_pids[i], sig);
 435         }
 436 }
 437
 438 /* turn a user name into a uid */
 439 int name_to_uid(char *name, uid_t *uid)
 440 {
 441         struct passwd *pass;
 442         if (!name || !*name) return 0;
 443         pass = getpwnam(name);
 444         if (pass) {
 445                 *uid = pass->pw_uid;
 446                 return 1;
 447         }
 448         return 0;
 449 }
 450
 451 /* turn a group name into a gid */
 452 int name_to_gid(char *name, gid_t *gid)
 453 {
 454         struct group *grp;
 455         if (!name || !*name) return 0;
 456         grp = getgrnam(name);
 457         if (grp) {
 458                 *gid = grp->gr_gid;
 459                 return 1;
 460         }
 461         return 0;
 462 }
 463
 464
 465 /* lock a byte range in a open file */
 466 int lock_range(int fd, int offset, int len)
 467 {
 468         struct flock lock;
 469
 470         lock.l_type = F_WRLCK;
 471         lock.l_whence = SEEK_SET;
 472         lock.l_start = offset;
 473         lock.l_len = len;
 474         lock.l_pid = 0;
 475
 476         return fcntl(fd,F_SETLK,&lock) == 0;
 477 }
 478
 479
 480 static void glob_expand_one(char *s, char **argv, int *argc, int maxargs, int sanitize_paths)
 481 {
 482 #if !(defined(HAVE_GLOB) && defined(HAVE_GLOB_H))
 483         if (!*s) s = ".";
 484         argv[*argc] = strdup(s);
 485         (*argc)++;
 486         return;
 487 #else
 488         glob_t globbuf;
 489         int i;
 490
 491         if (!*s) s = ".";
 492
 493         s = strdup(s);
 494         sanitize_path(s);
 495         argv[*argc] = s;
 496
 497         memset(&globbuf, 0, sizeof(globbuf));
 498         glob(argv[*argc], 0, NULL, &globbuf);
 499         if (globbuf.gl_pathc == 0) {
 500                 (*argc)++;
 501                 globfree(&globbuf);
 502                 return;
 503         }
 504         for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
 505                 if (i == 0) free(argv[*argc]);
 506                 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
 507                 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
 508         }
 509         globfree(&globbuf);
 510         (*argc) += i;
 511 #endif
 512 }
 513
 514 void glob_expand(char *base1, char **argv, int *argc, int maxargs, int sanitize_paths)
 515 {
 516         char *s = argv[*argc];
 517         char *p, *q;
 518         char *base = base1;
 519
 520         if (!s || !*s) return;
 521
 522         if (strncmp(s, base, strlen(base)) == 0) {
 523                 s += strlen(base);
 524         }
 525
 526         s = strdup(s);
 527         if (!s) out_of_memory("glob_expand");
 528
 529         base = (char *)malloc(strlen(base1)+3);
 530         if (!base) out_of_memory("glob_expand");
 531
 532         sprintf(base," %s/", base1);
 533
 534         q = s;
 535         while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
 536                 /* split it at this point */
 537                 *p = 0;
 538                 glob_expand_one(q, argv, argc, maxargs, sanitize_paths);
 539                 q = p+strlen(base);
 540         }
 541
 542         if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs, sanitize_paths);
 543
 544         free(s);
 545         free(base);
 546 }
 547
 548 /*******************************************************************
 549   convert a string to lower case
 550 ********************************************************************/
 551 void strlower(char *s)
 552 {
 553         while (*s) {
 554                 if (isupper(*s)) *s = tolower(*s);
 555                 s++;
 556         }
 557 }
 558
 559 /* this is like vsnprintf but it always null terminates, so you
 560    can fit at most n-1 chars in */
 561 int vslprintf(char *str, int n, const char *format, va_list ap)
 562 {
 563         int ret = vsnprintf(str, n, format, ap);
 564         if (ret >= n || ret < 0) {
 565                 str[n-1] = 0;
 566                 return -1;
 567         }
 568         str[ret] = 0;
 569         return ret;
 570 }
 571
 572
 573 /* like snprintf but always null terminates */
 574 int slprintf(char *str, int n, char *format, ...)
 575 {
 576         va_list ap;
 577         int ret;
 578
 579         va_start(ap, format);
 580         ret = vslprintf(str,n,format,ap);
 581         va_end(ap);
 582         return ret;
 583 }
 584
 585
 586 void *Realloc(void *p, int size)
 587 {
 588         if (!p) return (void *)malloc(size);
 589         return (void *)realloc(p, size);
 590 }
 591
 592
 593 void clean_fname(char *name)
 594 {
 595         char *p;
 596         int l;
 597         int modified = 1;
 598
 599         if (!name) return;
 600
 601         while (modified) {
 602                 modified = 0;
 603
 604                 if ((p=strstr(name,"/./"))) {
 605                         modified = 1;
 606                         while (*p) {
 607                                 p[0] = p[2];
 608                                 p++;
 609                         }
 610                 }
 611
 612                 if ((p=strstr(name,"//"))) {
 613                         modified = 1;
 614                         while (*p) {
 615                                 p[0] = p[1];
 616                                 p++;
 617                         }
 618                 }
 619
 620                 if (strncmp(p=name,"./",2) == 0) {
 621                         modified = 1;
 622                         do {
 623                                 p[0] = p[2];
 624                         } while (*p++);
 625                 }
 626
 627                 l = strlen(p=name);
 628                 if (l > 1 && p[l-1] == '/') {
 629                         modified = 1;
 630                         p[l-1] = 0;
 631                 }
 632         }
 633 }
 634
 635 /*
 636  * Make path appear as if a chroot had occurred:
 637  *    1. remove leading "/" (or replace with "." if at end)
 638  *    2. remove leading ".." components
 639  *    3. delete any other "<dir>/.." (recursively)
 640  * While we're at it, remove double slashes and "." components like
 641  *   clean_fname does(), but DON'T remove a trailing slash because that
 642  *   is sometimes significant on command line arguments.
 643  * Can only shrink paths, so sanitizes in place.
 644  * Contributed by Dave Dykstra <dwd@bell-labs.com>
 645  */
 646
 647 void sanitize_path(char *p)
 648 {
 649         char *start, *sanp;
 650
 651         start = p;
 652         sanp = p;
 653         while (*p == '/') {
 654                 /* remove leading slashes */
 655                 p++;
 656         }
 657         while (*p != '\0') {
 658                 /* this loop iterates once per filename component in p.
 659                  * both p (and sanp if the original had a slash) should
 660                  * always be left pointing after a slash
 661                  */
 662                 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
 663                         /* skip "." component */
 664                         while (*++p == '/') {
 665                                 /* skip following slashes */
 666                                 ;
 667                         }
 668                 } else if ((*p == '.') && (*(p+1) == '.') &&
 669                             ((*(p+2) == '/') || (*(p+2) == '\0'))) {
 670                         /* skip ".." component followed by slash or end */
 671                         p += 2;
 672                         if (*p == '/')
 673                                 p++;
 674                         if (sanp != start) {
 675                                 /* back up sanp one level */
 676                                 --sanp; /* now pointing at slash */
 677                                 while ((sanp > start) && (*(sanp - 1) != '/')) {
 678                                         /* skip back up to slash */
 679                                         sanp--;
 680                                 }
 681                         }
 682                 } else {
 683                         while (1) {
 684                                 /* copy one component through next slash */
 685                                 *sanp++ = *p++;
 686                                 if ((*p == '\0') || (*(p-1) == '/')) {
 687                                         while (*p == '/') {
 688                                                 /* skip multiple slashes */
 689                                                 p++;
 690                                         }
 691                                         break;
 692                                 }
 693                         }
 694                 }
 695         }
 696         if (sanp == start) {
 697                 /* ended up with nothing, so put in "." component */
 698                 *sanp++ = '.';
 699         }
 700         *sanp = '\0';
 701 }
 702
 703
 704 static char curr_dir[MAXPATHLEN];
 705
 706 /* like chdir() but can be reversed with pop_dir() if save is set. It
 707    is also much faster as it remembers where we have been */
 708 char *push_dir(char *dir, int save)
 709 {
 710         char *ret = curr_dir;
 711         static int initialised;
 712
 713         if (!initialised) {
 714                 initialised = 1;
 715                 getcwd(curr_dir, sizeof(curr_dir)-1);
 716         }
 717
 718         if (!dir) return NULL; /* this call was probably just to initialize */
 719
 720         if (chdir(dir)) return NULL;
 721
 722         if (save) {
 723                 ret = strdup(curr_dir);
 724         }
 725
 726         if (*dir == '/') {
 727                 strlcpy(curr_dir, dir, sizeof(curr_dir));
 728         } else {
 729                 strlcat(curr_dir,"/", sizeof(curr_dir));
 730                 strlcat(curr_dir,dir, sizeof(curr_dir));
 731         }
 732
 733         clean_fname(curr_dir);
 734
 735         return ret;
 736 }
 737
 738 /* reverse a push_dir call */
 739 int pop_dir(char *dir)
 740 {
 741         int ret;
 742
 743         ret = chdir(dir);
 744         if (ret) {
 745                 free(dir);
 746                 return ret;
 747         }
 748
 749         strlcpy(curr_dir, dir, sizeof(curr_dir));
 750
 751         free(dir);
 752
 753         return 0;
 754 }
 755
 756 /* we need to supply our own strcmp function for file list comparisons
 757    to ensure that signed/unsigned usage is consistent between machines. */
 758 int u_strcmp(const char *cs1, const char *cs2)
 759 {
 760         const uchar *s1 = (const uchar *)cs1;
 761         const uchar *s2 = (const uchar *)cs2;
 762
 763         while (*s1 && *s2 && (*s1 == *s2)) {
 764                 s1++; s2++;
 765         }
 766
 767         return (int)*s1 - (int)*s2;
 768 }
 769
 770 static OFF_T last_ofs;
 771
 772 void end_progress(void)
 773 {
 774         extern int do_progress, am_server;
 775
 776         if (do_progress && !am_server) {
 777                 rprintf(FINFO,"\n");
 778         }
 779         last_ofs = 0;
 780 }
 781
 782 void show_progress(OFF_T ofs, OFF_T size)
 783 {
 784         extern int do_progress, am_server;
 785
 786         if (do_progress && !am_server) {
 787                 if (ofs > last_ofs + 1000) {
 788                         int pct = (int)((100.0*ofs)/size);
 789                         rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
 790                         last_ofs = ofs;
 791                 }
 792         }
 793 }
 794
 795 /* determine if a symlink points outside the current directory tree */
 796 int unsafe_symlink(char *dest, char *src)
 797 {
 798         char *tok;
 799         int depth = 0;
 800
 801         /* all absolute and null symlinks are unsafe */
 802         if (!dest || !(*dest) || (*dest == '/')) return 1;
 803
 804         src = strdup(src);
 805         if (!src) out_of_memory("unsafe_symlink");
 806
 807         /* find out what our safety margin is */
 808         for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
 809                 if (strcmp(tok,"..") == 0) {
 810                         depth=0;
 811                 } else if (strcmp(tok,".") == 0) {
 812                         /* nothing */
 813                 } else {
 814                         depth++;
 815                 }
 816         }
 817         free(src);
 818
 819         /* drop by one to account for the filename portion */
 820         depth--;
 821
 822         dest = strdup(dest);
 823         if (!dest) out_of_memory("unsafe_symlink");
 824
 825         for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
 826                 if (strcmp(tok,"..") == 0) {
 827                         depth--;
 828                 } else if (strcmp(tok,".") == 0) {
 829                         /* nothing */
 830                 } else {
 831                         depth++;
 832                 }
 833                 /* if at any point we go outside the current directory then
 834                    stop - it is unsafe */
 835                 if (depth < 0) break;
 836         }
 837
 838         free(dest);
 839         return (depth < 0);
 840 }
 841
 842
 843 /****************************************************************************
 844   return the date and time as a string
 845 ****************************************************************************/
 846 char *timestring(time_t t)
 847 {
 848         static char TimeBuf[200];
 849         struct tm *tm = localtime(&t);
 850
 851 #ifdef HAVE_STRFTIME
 852         strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
 853 #else
 854         strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
 855 #endif
 856
 857         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
 858                 TimeBuf[strlen(TimeBuf)-1] = 0;
 859         }
 860
 861         return(TimeBuf);
 862 }
 863