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 = do_open(source, O_RDONLY, 0);
 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)
 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         extern int sanitize_paths;
 489         glob_t globbuf;
 490         int i;
 491
 492         if (!*s) s = ".";
 493
 494         argv[*argc] = strdup(s);
 495         if (sanitize_paths) {
 496                 sanitize_path(argv[*argc], NULL);
 497         }
 498
 499         memset(&globbuf, 0, sizeof(globbuf));
 500         glob(argv[*argc], 0, NULL, &globbuf);
 501         if (globbuf.gl_pathc == 0) {
 502                 (*argc)++;
 503                 globfree(&globbuf);
 504                 return;
 505         }
 506         for (i=0; i<(maxargs - (*argc)) && i<globbuf.gl_pathc;i++) {
 507                 if (i == 0) free(argv[*argc]);
 508                 argv[(*argc) + i] = strdup(globbuf.gl_pathv[i]);
 509                 if (!argv[(*argc) + i]) out_of_memory("glob_expand");
 510         }
 511         globfree(&globbuf);
 512         (*argc) += i;
 513 #endif
 514 }
 515
 516 void glob_expand(char *base1, char **argv, int *argc, int maxargs)
 517 {
 518         char *s = argv[*argc];
 519         char *p, *q;
 520         char *base = base1;
 521
 522         if (!s || !*s) return;
 523
 524         if (strncmp(s, base, strlen(base)) == 0) {
 525                 s += strlen(base);
 526         }
 527
 528         s = strdup(s);
 529         if (!s) out_of_memory("glob_expand");
 530
 531         base = (char *)malloc(strlen(base1)+3);
 532         if (!base) out_of_memory("glob_expand");
 533
 534         sprintf(base," %s/", base1);
 535
 536         q = s;
 537         while ((p = strstr(q,base)) && ((*argc) < maxargs)) {
 538                 /* split it at this point */
 539                 *p = 0;
 540                 glob_expand_one(q, argv, argc, maxargs);
 541                 q = p+strlen(base);
 542         }
 543
 544         if (*q && (*argc < maxargs)) glob_expand_one(q, argv, argc, maxargs);
 545
 546         free(s);
 547         free(base);
 548 }
 549
 550 /*******************************************************************
 551   convert a string to lower case
 552 ********************************************************************/
 553 void strlower(char *s)
 554 {
 555         while (*s) {
 556                 if (isupper(*s)) *s = tolower(*s);
 557                 s++;
 558         }
 559 }
 560
 561 /* this is like vsnprintf but it always null terminates, so you
 562    can fit at most n-1 chars in */
 563 int vslprintf(char *str, int n, const char *format, va_list ap)
 564 {
 565         int ret = vsnprintf(str, n, format, ap);
 566         if (ret >= n || ret < 0) {
 567                 str[n-1] = 0;
 568                 return -1;
 569         }
 570         str[ret] = 0;
 571         return ret;
 572 }
 573
 574
 575 /* like snprintf but always null terminates */
 576 int slprintf(char *str, int n, char *format, ...)
 577 {
 578         va_list ap;
 579         int ret;
 580
 581         va_start(ap, format);
 582         ret = vslprintf(str,n,format,ap);
 583         va_end(ap);
 584         return ret;
 585 }
 586
 587
 588 void *Realloc(void *p, int size)
 589 {
 590         if (!p) return (void *)malloc(size);
 591         return (void *)realloc(p, size);
 592 }
 593
 594
 595 void clean_fname(char *name)
 596 {
 597         char *p;
 598         int l;
 599         int modified = 1;
 600
 601         if (!name) return;
 602
 603         while (modified) {
 604                 modified = 0;
 605
 606                 if ((p=strstr(name,"/./"))) {
 607                         modified = 1;
 608                         while (*p) {
 609                                 p[0] = p[2];
 610                                 p++;
 611                         }
 612                 }
 613
 614                 if ((p=strstr(name,"//"))) {
 615                         modified = 1;
 616                         while (*p) {
 617                                 p[0] = p[1];
 618                                 p++;
 619                         }
 620                 }
 621
 622                 if (strncmp(p=name,"./",2) == 0) {
 623                         modified = 1;
 624                         do {
 625                                 p[0] = p[2];
 626                         } while (*p++);
 627                 }
 628
 629                 l = strlen(p=name);
 630                 if (l > 1 && p[l-1] == '/') {
 631                         modified = 1;
 632                         p[l-1] = 0;
 633                 }
 634         }
 635 }
 636
 637 /*
 638  * Make path appear as if a chroot had occurred:
 639  *    1. remove leading "/" (or replace with "." if at end)
 640  *    2. remove leading ".." components (except those allowed by "reldir")
 641  *    3. delete any other "<dir>/.." (recursively)
 642  * Can only shrink paths, so sanitizes in place.
 643  * While we're at it, remove double slashes and "." components like
 644  *   clean_fname does(), but DON'T remove a trailing slash because that
 645  *   is sometimes significant on command line arguments.
 646  * If "reldir" is non-null, it is a sanitized directory that the path will be
 647  *    relative to, so allow as many ".." at the beginning of the path as
 648  *    there are components in reldir.  This is used for symbolic link targets.
 649  *    If reldir is non-null and the path began with "/", to be completely like
 650  *    a chroot we should add in depth levels of ".." at the beginning of the
 651  *    path, but that would blow the assumption that the path doesn't grow and
 652  *    it is not likely to end up being a valid symlink anyway, so just do
 653  *    the normal removal of the leading "/" instead.
 654  * Contributed by Dave Dykstra <dwd@bell-labs.com>
 655  */
 656
 657 void sanitize_path(char *p, char *reldir)
 658 {
 659         char *start, *sanp;
 660         int depth = 0;
 661         int allowdotdot = 0;
 662
 663         if (reldir) {
 664                 depth++;
 665                 while (*reldir) {
 666                         if (*reldir++ == '/') {
 667                                 depth++;
 668                         }
 669                 }
 670         }
 671         start = p;
 672         sanp = p;
 673         while (*p == '/') {
 674                 /* remove leading slashes */
 675                 p++;
 676         }
 677         while (*p != '\0') {
 678                 /* this loop iterates once per filename component in p.
 679                  * both p (and sanp if the original had a slash) should
 680                  * always be left pointing after a slash
 681                  */
 682                 if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
 683                         /* skip "." component */
 684                         while (*++p == '/') {
 685                                 /* skip following slashes */
 686                                 ;
 687                         }
 688                         continue;
 689                 }
 690                 allowdotdot = 0;
 691                 if ((*p == '.') && (*(p+1) == '.') &&
 692                             ((*(p+2) == '/') || (*(p+2) == '\0'))) {
 693                         /* ".." component followed by slash or end */
 694                         if ((depth > 0) && (sanp == start)) {
 695                                 /* allow depth levels of .. at the beginning */
 696                                 --depth;
 697                                 allowdotdot = 1;
 698                         } else {
 699                                 p += 2;
 700                                 if (*p == '/')
 701                                         p++;
 702                                 if (sanp != start) {
 703                                         /* back up sanp one level */
 704                                         --sanp; /* now pointing at slash */
 705                                         while ((sanp > start) && (*(sanp - 1) != '/')) {
 706                                                 /* skip back up to slash */
 707                                                 sanp--;
 708                                         }
 709                                 }
 710                                 continue;
 711                         }
 712                 }
 713                 while (1) {
 714                         /* copy one component through next slash */
 715                         *sanp++ = *p++;
 716                         if ((*p == '\0') || (*(p-1) == '/')) {
 717                                 while (*p == '/') {
 718                                         /* skip multiple slashes */
 719                                         p++;
 720                                 }
 721                                 break;
 722                         }
 723                 }
 724                 if (allowdotdot) {
 725                         /* move the virtual beginning to leave the .. alone */
 726                         start = sanp;
 727                 }
 728         }
 729         if ((sanp == start) && !allowdotdot) {
 730                 /* ended up with nothing, so put in "." component */
 731                 /*
 732                  * note that the !allowdotdot doesn't prevent this from
 733                  *  happening in all allowed ".." situations, but I didn't
 734                  *  think it was worth putting in an extra variable to ensure
 735                  *  it since an extra "." won't hurt in those situations.
 736                  */
 737                 *sanp++ = '.';
 738         }
 739         *sanp = '\0';
 740 }
 741
 742
 743 static char curr_dir[MAXPATHLEN];
 744
 745 /* like chdir() but can be reversed with pop_dir() if save is set. It
 746    is also much faster as it remembers where we have been */
 747 char *push_dir(char *dir, int save)
 748 {
 749         char *ret = curr_dir;
 750         static int initialised;
 751
 752         if (!initialised) {
 753                 initialised = 1;
 754                 getcwd(curr_dir, sizeof(curr_dir)-1);
 755         }
 756
 757         if (!dir) return NULL; /* this call was probably just to initialize */
 758
 759         if (chdir(dir)) return NULL;
 760
 761         if (save) {
 762                 ret = strdup(curr_dir);
 763         }
 764
 765         if (*dir == '/') {
 766                 strlcpy(curr_dir, dir, sizeof(curr_dir));
 767         } else {
 768                 strlcat(curr_dir,"/", sizeof(curr_dir));
 769                 strlcat(curr_dir,dir, sizeof(curr_dir));
 770         }
 771
 772         clean_fname(curr_dir);
 773
 774         return ret;
 775 }
 776
 777 /* reverse a push_dir call */
 778 int pop_dir(char *dir)
 779 {
 780         int ret;
 781
 782         ret = chdir(dir);
 783         if (ret) {
 784                 free(dir);
 785                 return ret;
 786         }
 787
 788         strlcpy(curr_dir, dir, sizeof(curr_dir));
 789
 790         free(dir);
 791
 792         return 0;
 793 }
 794
 795 /* we need to supply our own strcmp function for file list comparisons
 796    to ensure that signed/unsigned usage is consistent between machines. */
 797 int u_strcmp(const char *cs1, const char *cs2)
 798 {
 799         const uchar *s1 = (const uchar *)cs1;
 800         const uchar *s2 = (const uchar *)cs2;
 801
 802         while (*s1 && *s2 && (*s1 == *s2)) {
 803                 s1++; s2++;
 804         }
 805
 806         return (int)*s1 - (int)*s2;
 807 }
 808
 809 static OFF_T last_ofs;
 810
 811 void end_progress(void)
 812 {
 813         extern int do_progress, am_server;
 814
 815         if (do_progress && !am_server) {
 816                 rprintf(FINFO,"\n");
 817         }
 818         last_ofs = 0;
 819 }
 820
 821 void show_progress(OFF_T ofs, OFF_T size)
 822 {
 823         extern int do_progress, am_server;
 824
 825         if (do_progress && !am_server) {
 826                 if (ofs > last_ofs + 1000) {
 827                         int pct = (int)((100.0*ofs)/size);
 828                         rprintf(FINFO,"%.0f (%d%%)\r", (double)ofs, pct);
 829                         last_ofs = ofs;
 830                 }
 831         }
 832 }
 833
 834 /* determine if a symlink points outside the current directory tree */
 835 int unsafe_symlink(char *dest, char *src)
 836 {
 837         char *tok;
 838         int depth = 0;
 839
 840         /* all absolute and null symlinks are unsafe */
 841         if (!dest || !(*dest) || (*dest == '/')) return 1;
 842
 843         src = strdup(src);
 844         if (!src) out_of_memory("unsafe_symlink");
 845
 846         /* find out what our safety margin is */
 847         for (tok=strtok(src,"/"); tok; tok=strtok(NULL,"/")) {
 848                 if (strcmp(tok,"..") == 0) {
 849                         depth=0;
 850                 } else if (strcmp(tok,".") == 0) {
 851                         /* nothing */
 852                 } else {
 853                         depth++;
 854                 }
 855         }
 856         free(src);
 857
 858         /* drop by one to account for the filename portion */
 859         depth--;
 860
 861         dest = strdup(dest);
 862         if (!dest) out_of_memory("unsafe_symlink");
 863
 864         for (tok=strtok(dest,"/"); tok; tok=strtok(NULL,"/")) {
 865                 if (strcmp(tok,"..") == 0) {
 866                         depth--;
 867                 } else if (strcmp(tok,".") == 0) {
 868                         /* nothing */
 869                 } else {
 870                         depth++;
 871                 }
 872                 /* if at any point we go outside the current directory then
 873                    stop - it is unsafe */
 874                 if (depth < 0) break;
 875         }
 876
 877         free(dest);
 878         return (depth < 0);
 879 }
 880
 881
 882 /****************************************************************************
 883   return the date and time as a string
 884 ****************************************************************************/
 885 char *timestring(time_t t)
 886 {
 887         static char TimeBuf[200];
 888         struct tm *tm = localtime(&t);
 889
 890 #ifdef HAVE_STRFTIME
 891         strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %T",tm);
 892 #else
 893         strlcpy(TimeBuf, asctime(tm), sizeof(TimeBuf));
 894 #endif
 895
 896         if (TimeBuf[strlen(TimeBuf)-1] == '\n') {
 897                 TimeBuf[strlen(TimeBuf)-1] = 0;
 898         }
 899
 900         return(TimeBuf);
 901 }
 902