git.sur5r.net Git - bacula/bacula/blob - bacula/src/filed/backup.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *  Bacula File Daemon  backup.c  send file attributes and data
  30  *   to the Storage daemon.
  31  *
  32  *    Kern Sibbald, March MM
  33  *
  34  *   Version $Id$
  35  *
  36  */
  37
  38 #include "bacula.h"
  39 #include "filed.h"
  40
  41 /* Forward referenced functions */
  42 static int save_file(FF_PKT *ff_pkt, void *pkt, bool top_level);
  43 static void strip_path(FF_PKT *ff_pkt);
  44 static void unstrip_path(FF_PKT *ff_pkt);
  45 static int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest, DIGEST *signature_digest);
  46 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream);
  47 static bool read_and_send_acl(JCR *jcr, int acltype, int stream);
  48
  49 /*
  50  * Find all the requested files and send them
  51  * to the Storage daemon.
  52  *
  53  * Note, we normally carry on a one-way
  54  * conversation from this point on with the SD, simply blasting
  55  * data to him.  To properly know what is going on, we
  56  * also run a "heartbeat" monitor which reads the socket and
  57  * reacts accordingly (at the moment it has nothing to do
  58  * except echo the heartbeat to the Director).
  59  *
  60  */
  61 bool blast_data_to_storage_daemon(JCR *jcr, char *addr)
  62 {
  63    BSOCK *sd;
  64    bool ok = true;
  65    // TODO landonf: Allow user to specify encryption algorithm
  66    crypto_cipher_t cipher = CRYPTO_CIPHER_AES_128_CBC;
  67
  68
  69    sd = jcr->store_bsock;
  70
  71    set_jcr_job_status(jcr, JS_Running);
  72
  73    Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->m_fd);
  74
  75    LockRes();
  76    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
  77    UnlockRes();
  78    uint32_t buf_size;
  79    if (client) {
  80       buf_size = client->max_network_buffer_size;
  81    } else {
  82       buf_size = 0;                   /* use default */
  83    }
  84    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
  85       set_jcr_job_status(jcr, JS_ErrorTerminated);
  86       Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
  87       return false;
  88    }
  89
  90    jcr->buf_size = sd->msglen;
  91    /* Adjust for compression so that output buffer is
  92     * 12 bytes + 0.1% larger than input buffer plus 18 bytes.
  93     * This gives a bit extra plus room for the sparse addr if any.
  94     * Note, we adjust the read size to be smaller so that the
  95     * same output buffer can be used without growing it.
  96     *
  97     * The zlib compression workset is initialized here to minimise
  98     * the "per file" load. The jcr member is only set, if the init was successful.
  99     */
 100    jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
 101    jcr->compress_buf = get_memory(jcr->compress_buf_size);
 102
 103 #ifdef HAVE_LIBZ
 104    z_stream *pZlibStream = (z_stream*)malloc(sizeof(z_stream));
 105    if (pZlibStream) {
 106       pZlibStream->zalloc = Z_NULL;
 107       pZlibStream->zfree = Z_NULL;
 108       pZlibStream->opaque = Z_NULL;
 109       pZlibStream->state = Z_NULL;
 110
 111       if (deflateInit(pZlibStream, Z_DEFAULT_COMPRESSION) == Z_OK)
 112          jcr->pZLIB_compress_workset = pZlibStream;
 113       else
 114          free (pZlibStream);
 115    }
 116 #endif
 117
 118    /* Create encryption session data and a cached, DER-encoded session data
 119     * structure. We use a single session key for each backup, so we'll encode
 120     * the session data only once. */
 121    if (jcr->pki_encrypt) {
 122       uint32_t size = 0;
 123
 124       /* Create per-job session encryption context */
 125       jcr->pki_session = crypto_session_new(cipher, jcr->pki_recipients);
 126
 127       /* Get the session data size */
 128       if (crypto_session_encode(jcr->pki_session, (uint8_t *)0, &size) == false) {
 129          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 130          return 0;
 131       }
 132
 133       /* Allocate buffer */
 134       jcr->pki_session_encoded = (uint8_t *)malloc(size);
 135
 136       /* Encode session data */
 137       if (crypto_session_encode(jcr->pki_session, jcr->pki_session_encoded, &size) == false) {
 138          Jmsg(jcr, M_FATAL, 0, _("An error occurred while encrypting the stream.\n"));
 139          return 0;
 140       }
 141
 142       /* ... and store the encoded size */
 143       jcr->pki_session_encoded_size = size;
 144
 145       /* Allocate the encryption/decryption buffer */
 146       jcr->crypto_buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 147    }
 148
 149    Dmsg1(300, "set_find_options ff=%p\n", jcr->ff);
 150    set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
 151    Dmsg0(300, "start find files\n");
 152
 153    start_heartbeat_monitor(jcr);
 154
 155    jcr->acl_text = get_pool_memory(PM_MESSAGE);
 156
 157    /* Subroutine save_file() is called for each file */
 158    if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, (void *)jcr)) {
 159       ok = false;                     /* error */
 160       set_jcr_job_status(jcr, JS_ErrorTerminated);
 161    }
 162
 163    free_pool_memory(jcr->acl_text);
 164
 165    stop_heartbeat_monitor(jcr);
 166
 167    sd->signal(BNET_EOD);            /* end of sending data */
 168
 169    if (jcr->big_buf) {
 170       free(jcr->big_buf);
 171       jcr->big_buf = NULL;
 172    }
 173    if (jcr->compress_buf) {
 174       free_pool_memory(jcr->compress_buf);
 175       jcr->compress_buf = NULL;
 176    }
 177    if (jcr->pZLIB_compress_workset) {
 178       /* Free the zlib stream */
 179 #ifdef HAVE_LIBZ
 180       deflateEnd((z_stream *)jcr->pZLIB_compress_workset);
 181 #endif
 182       free (jcr->pZLIB_compress_workset);
 183       jcr->pZLIB_compress_workset = NULL;
 184    }
 185    if (jcr->crypto_buf) {
 186       free_pool_memory(jcr->crypto_buf);
 187       jcr->crypto_buf = NULL;
 188    }
 189    if (jcr->pki_session) {
 190       crypto_session_free(jcr->pki_session);
 191    }
 192    if (jcr->pki_session_encoded) {
 193       free(jcr->pki_session_encoded);
 194       jcr->pki_session_encoded = NULL;
 195    }
 196
 197    Dmsg1(100, "end blast_data ok=%d\n", ok);
 198    return ok;
 199 }
 200
 201 /*
 202  * Called here by find() for each file included.
 203  *   This is a callback. The original is find_files() above.
 204  *
 205  *  Send the file and its data to the Storage daemon.
 206  *
 207  *  Returns: 1 if OK
 208  *           0 if error
 209  *          -1 to ignore file/directory (not used here)
 210  */
 211 static int save_file(FF_PKT *ff_pkt, void *vjcr, bool top_level)
 212 {
 213    bool do_read = false;
 214    int stat, data_stream;
 215    int rtnstat = 0;
 216    DIGEST *digest = NULL;
 217    DIGEST *signing_digest = NULL;
 218    int digest_stream = STREAM_NONE;
 219    SIGNATURE *sig = NULL;
 220    bool has_file_data = false;
 221    // TODO landonf: Allow the user to specify the digest algorithm
 222 #ifdef HAVE_SHA2
 223    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA256;
 224 #else
 225    crypto_digest_t signing_algorithm = CRYPTO_DIGEST_SHA1;
 226 #endif
 227    JCR *jcr = (JCR *)vjcr;
 228    BSOCK *sd = jcr->store_bsock;
 229
 230    if (job_canceled(jcr)) {
 231       return 0;
 232    }
 233
 234    jcr->num_files_examined++;         /* bump total file count */
 235
 236    switch (ff_pkt->type) {
 237    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 238       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 239       break;
 240    case FT_REGE:
 241       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 242       has_file_data = true;
 243       break;
 244    case FT_REG:
 245       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 246       has_file_data = true;
 247       break;
 248    case FT_LNK:
 249       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 250       break;
 251    case FT_DIRBEGIN:
 252       jcr->num_files_examined--;      /* correct file count */
 253       return 1;                       /* not used */
 254    case FT_NORECURSE:
 255       Jmsg(jcr, M_INFO, 1, _("     Recursion turned off. Will not descend from %s into %s\n"),
 256            ff_pkt->top_fname, ff_pkt->fname);
 257       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 258       break;
 259    case FT_NOFSCHG:
 260       /* Suppress message for /dev filesystems */
 261       if (strncmp(ff_pkt->fname, "/dev/", 5) != 0) {
 262          Jmsg(jcr, M_INFO, 1, _("     %s is a different filesystem. Will not descend from %s into %s\n"),
 263               ff_pkt->fname, ff_pkt->top_fname, ff_pkt->fname);
 264       }
 265       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 266       break;
 267    case FT_INVALIDFS:
 268       Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend from %s into %s\n"),
 269            ff_pkt->top_fname, ff_pkt->fname);
 270       ff_pkt->type = FT_DIREND;       /* Backup only the directory entry */
 271       break;
 272    case FT_INVALIDDT:
 273       Jmsg(jcr, M_INFO, 1, _("     Disallowed drive type. Will not descend into %s\n"),
 274            ff_pkt->fname);
 275       break;
 276    case FT_REPARSE:
 277    case FT_DIREND:
 278       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 279       break;
 280    case FT_SPEC:
 281       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 282       break;
 283    case FT_RAW:
 284       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 285       has_file_data = true;
 286       break;
 287    case FT_FIFO:
 288       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 289       break;
 290    case FT_NOACCESS: {
 291       berrno be;
 292       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access %s: ERR=%s\n"), ff_pkt->fname,
 293          be.bstrerror(ff_pkt->ff_errno));
 294       jcr->Errors++;
 295       return 1;
 296    }
 297    case FT_NOFOLLOW: {
 298       berrno be;
 299       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link %s: ERR=%s\n"),
 300            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 301       jcr->Errors++;
 302       return 1;
 303    }
 304    case FT_NOSTAT: {
 305       berrno be;
 306       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat %s: ERR=%s\n"), ff_pkt->fname,
 307          be.bstrerror(ff_pkt->ff_errno));
 308       jcr->Errors++;
 309       return 1;
 310    }
 311    case FT_DIRNOCHG:
 312    case FT_NOCHG:
 313       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 314       return 1;
 315    case FT_ISARCH:
 316       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 317       return 1;
 318    case FT_NOOPEN: {
 319       berrno be;
 320       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory %s: ERR=%s\n"),
 321            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 322       jcr->Errors++;
 323       return 1;
 324    }
 325    default:
 326       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"),
 327            ff_pkt->type, ff_pkt->fname);
 328       jcr->Errors++;
 329       return 1;
 330    }
 331
 332    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 333
 334    /* Digests and encryption are only useful if there's file data */
 335    if (has_file_data) {
 336       /*
 337        * Setup for digest handling. If this fails, the digest will be set to NULL
 338        * and not used. Note, the digest (file hash) can be any one of the four
 339        * algorithms below.
 340        *
 341        * The signing digest is a single algorithm depending on
 342        * whether or not we have SHA2.
 343        *   ****FIXME****  the signing algoritm should really be
 344        *   determined a different way!!!!!!  What happens if
 345        *   sha2 was available during backup but not restore?
 346        */
 347       if (ff_pkt->flags & FO_MD5) {
 348          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_MD5);
 349          digest_stream = STREAM_MD5_DIGEST;
 350
 351       } else if (ff_pkt->flags & FO_SHA1) {
 352          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA1);
 353          digest_stream = STREAM_SHA1_DIGEST;
 354
 355       } else if (ff_pkt->flags & FO_SHA256) {
 356          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA256);
 357          digest_stream = STREAM_SHA256_DIGEST;
 358
 359       } else if (ff_pkt->flags & FO_SHA512) {
 360          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA512);
 361          digest_stream = STREAM_SHA512_DIGEST;
 362       }
 363
 364       /* Did digest initialization fail? */
 365       if (digest_stream != STREAM_NONE && digest == NULL) {
 366          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 367             stream_to_ascii(digest_stream));
 368       }
 369
 370       /*
 371        * Set up signature digest handling. If this fails, the signature digest will be set to
 372        * NULL and not used.
 373        */
 374       // TODO landonf: We should really only calculate the digest once, for both verification and signing.
 375       if (jcr->pki_sign) {
 376          signing_digest = crypto_digest_new(jcr, signing_algorithm);
 377
 378          /* Full-stop if a failure occurred initializing the signature digest */
 379          if (signing_digest == NULL) {
 380             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 381                stream_to_ascii(signing_algorithm));
 382             jcr->Errors++;
 383             goto good_rtn;
 384          }
 385       }
 386
 387       /* Enable encryption */
 388       if (jcr->pki_encrypt) {
 389          ff_pkt->flags |= FO_ENCRYPT;
 390       }
 391    }
 392
 393    /* Initialise the file descriptor we use for data and other streams. */
 394    binit(&ff_pkt->bfd);
 395    if (ff_pkt->flags & FO_PORTABLE) {
 396       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 397    }
 398    if (ff_pkt->reader) {
 399       if (!set_prog(&ff_pkt->bfd, ff_pkt->reader, jcr)) {
 400          Jmsg(jcr, M_FATAL, 0, _("Python reader program \"%s\" not found.\n"),
 401             ff_pkt->reader);
 402          goto bail_out;
 403       }
 404    }
 405
 406    /* Send attributes -- must be done after binit() */
 407    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 408       goto bail_out;
 409    }
 410
 411    /* Set up the encryption context and send the session data to the SD */
 412    if (has_file_data && jcr->pki_encrypt) {
 413       /* Send our header */
 414       Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 415       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 416
 417       /* Grow the bsock buffer to fit our message if necessary */
 418       if (sizeof_pool_memory(sd->msg) < jcr->pki_session_encoded_size) {
 419          sd->msg = realloc_pool_memory(sd->msg, jcr->pki_session_encoded_size);
 420       }
 421
 422       /* Copy our message over and send it */
 423       memcpy(sd->msg, jcr->pki_session_encoded, jcr->pki_session_encoded_size);
 424       sd->msglen = jcr->pki_session_encoded_size;
 425       jcr->JobBytes += sd->msglen;
 426
 427       Dmsg1(100, "Send data len=%d\n", sd->msglen);
 428       sd->send();
 429       sd->signal(BNET_EOD);
 430    }
 431
 432    /*
 433     * Open any file with data that we intend to save, then save it.
 434     *
 435     * Note, if is_win32_backup, we must open the Directory so that
 436     * the BackupRead will save its permissions and ownership streams.
 437     */
 438    if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
 439 #ifdef HAVE_WIN32
 440       do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
 441 #else
 442       do_read = ff_pkt->statp.st_size > 0;
 443 #endif
 444    } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 445               ff_pkt->type == FT_REPARSE ||
 446          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 447       do_read = true;
 448    }
 449
 450    if (do_read) {
 451       btimer_t *tid;
 452       if (ff_pkt->type == FT_FIFO) {
 453          tid = start_thread_timer(jcr, pthread_self(), 60);
 454       } else {
 455          tid = NULL;
 456       }
 457       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 458       ff_pkt->bfd.reparse_point = ff_pkt->type == FT_REPARSE;
 459       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 460          ff_pkt->ff_errno = errno;
 461          berrno be;
 462          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
 463               be.bstrerror());
 464          jcr->Errors++;
 465          if (tid) {
 466             stop_thread_timer(tid);
 467             tid = NULL;
 468          }
 469          goto good_rtn;
 470       }
 471       if (tid) {
 472          stop_thread_timer(tid);
 473          tid = NULL;
 474       }
 475
 476       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 477
 478       if (ff_pkt->flags & FO_CHKCHANGES) {
 479          has_file_changed(jcr, ff_pkt);
 480       }
 481
 482       bclose(&ff_pkt->bfd);
 483
 484       if (!stat) {
 485          goto bail_out;
 486       }
 487    }
 488
 489 #ifdef HAVE_DARWIN_OS
 490    /* Regular files can have resource forks and Finder Info */
 491    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 492             ff_pkt->flags & FO_HFSPLUS)) {
 493       if (ff_pkt->hfsinfo.rsrclength > 0) {
 494          int flags;
 495          int rsrc_stream;
 496          if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 497             ff_pkt->ff_errno = errno;
 498             berrno be;
 499             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for %s: ERR=%s.\n"),
 500                  ff_pkt->fname, be.bstrerror());
 501             jcr->Errors++;
 502             if (is_bopen(&ff_pkt->bfd)) {
 503                bclose(&ff_pkt->bfd);
 504             }
 505             goto good_rtn;
 506          }
 507          flags = ff_pkt->flags;
 508          ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
 509          if (flags & FO_ENCRYPT) {
 510             rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 511          } else {
 512             rsrc_stream = STREAM_MACOS_FORK_DATA;
 513          }
 514          stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 515          ff_pkt->flags = flags;
 516          bclose(&ff_pkt->bfd);
 517          if (!stat) {
 518             goto bail_out;
 519          }
 520       }
 521
 522       Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 523       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 524       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 525       memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 526       sd->msglen = 32;
 527       if (digest) {
 528          crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 529       }
 530       if (signing_digest) {
 531          crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 532       }
 533       sd->send();
 534       sd->signal(BNET_EOD);
 535    }
 536 #endif
 537
 538    if (ff_pkt->flags & FO_ACL) {
 539       /* Read access ACLs for files, dirs and links */
 540       if (!read_and_send_acl(jcr, BACL_TYPE_ACCESS, STREAM_UNIX_ATTRIBUTES_ACCESS_ACL)) {
 541          goto bail_out;
 542       }
 543       /* Directories can have default ACLs too */
 544       if (ff_pkt->type == FT_DIREND && (BACL_CAP & BACL_CAP_DEFAULTS_DIR)) {
 545          if (!read_and_send_acl(jcr, BACL_TYPE_DEFAULT, STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL)) {
 546             goto bail_out;
 547          }
 548       }
 549    }
 550
 551    /* Terminate the signing digest and send it to the Storage daemon */
 552    if (signing_digest) {
 553       uint32_t size = 0;
 554
 555       if ((sig = crypto_sign_new(jcr)) == NULL) {
 556          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
 557          goto bail_out;
 558       }
 559
 560       if (!crypto_sign_add_signer(sig, signing_digest, jcr->pki_keypair)) {
 561          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 562          goto bail_out;
 563       }
 564
 565       /* Get signature size */
 566       if (!crypto_sign_encode(sig, NULL, &size)) {
 567          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 568          goto bail_out;
 569       }
 570
 571       /* Grow the bsock buffer to fit our message if necessary */
 572       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 573          sd->msg = realloc_pool_memory(sd->msg, size);
 574       }
 575
 576       /* Send our header */
 577       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 578       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 579
 580       /* Encode signature data */
 581       if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
 582          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 583          goto bail_out;
 584       }
 585
 586       sd->msglen = size;
 587       sd->send();
 588       sd->signal(BNET_EOD);              /* end of checksum */
 589    }
 590
 591    /* Terminate any digest and send it to Storage daemon and the Director */
 592    if (digest) {
 593       uint32_t size;
 594
 595       sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
 596       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 597
 598       size = CRYPTO_DIGEST_MAX_SIZE;
 599
 600       /* Grow the bsock buffer to fit our message if necessary */
 601       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 602          sd->msg = realloc_pool_memory(sd->msg, size);
 603       }
 604
 605       if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
 606          Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
 607          goto bail_out;
 608       }
 609
 610       sd->msglen = size;
 611       sd->send();
 612       sd->signal(BNET_EOD);              /* end of checksum */
 613    }
 614
 615 good_rtn:
 616    rtnstat = 1;                       /* good return */
 617
 618 bail_out:
 619    if (digest) {
 620       crypto_digest_free(digest);
 621    }
 622    if (signing_digest) {
 623       crypto_digest_free(signing_digest);
 624    }
 625    if (sig) {
 626       crypto_sign_free(sig);
 627    }
 628    return rtnstat;
 629 }
 630
 631 /*
 632  * Send data read from an already open file descriptor.
 633  *
 634  * We return 1 on sucess and 0 on errors.
 635  *
 636  * ***FIXME***
 637  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 638  *  reading.
 639  * Currently this is not a problem as the only other stream, resource forks,
 640  * are not handled as sparse files.
 641  */
 642 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 643               DIGEST *signing_digest)
 644 {
 645    BSOCK *sd = jcr->store_bsock;
 646    uint64_t fileAddr = 0;             /* file address */
 647    char *rbuf, *wbuf;
 648    int32_t rsize = jcr->buf_size;      /* read buffer size */
 649    POOLMEM *msgsave;
 650    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 651    const uint8_t *cipher_input;
 652    uint32_t cipher_input_len;
 653    uint32_t cipher_block_size;
 654    uint32_t encrypted_len;
 655 #ifdef FD_NO_SEND_TEST
 656    return 1;
 657 #endif
 658
 659    msgsave = sd->msg;
 660    rbuf = sd->msg;                    /* read buffer */
 661    wbuf = sd->msg;                    /* write buffer */
 662    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 663
 664    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 665
 666 #ifdef HAVE_LIBZ
 667    uLong compress_len = 0;
 668    uLong max_compress_len = 0;
 669    const Bytef *cbuf = NULL;
 670    int zstat;
 671
 672    if (ff_pkt->flags & FO_GZIP) {
 673       if (ff_pkt->flags & FO_SPARSE) {
 674          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 675          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 676       } else {
 677          cbuf = (Bytef *)jcr->compress_buf;
 678          max_compress_len = jcr->compress_buf_size; /* set max length */
 679       }
 680       wbuf = jcr->compress_buf;    /* compressed output here */
 681       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 682
 683       /*
 684        * Only change zlib parameters if there is no pending operation.
 685        * This should never happen as deflatereset is called after each
 686        * deflate.
 687        */
 688
 689       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 690          /* set gzip compression level - must be done per file */
 691          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 692               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 693             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 694             set_jcr_job_status(jcr, JS_ErrorTerminated);
 695             goto err;
 696          }
 697       }
 698    }
 699 #else
 700    const uint32_t max_compress_len = 0;
 701 #endif
 702
 703    if (ff_pkt->flags & FO_ENCRYPT) {
 704       if (ff_pkt->flags & FO_SPARSE) {
 705          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
 706          goto err;
 707       }
 708       /* Allocate the cipher context */
 709       if ((cipher_ctx = crypto_cipher_new(jcr->pki_session, true,
 710            &cipher_block_size)) == NULL) {
 711          /* Shouldn't happen! */
 712          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 713          goto err;
 714       }
 715
 716       /*
 717        * Grow the crypto buffer, if necessary.
 718        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 719        * We grow crypto_buf to the maximum number of blocks that
 720        * could be returned for the given read buffer size.
 721        * (Using the larger of either rsize or max_compress_len)
 722        */
 723       jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 724            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 725             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 726
 727       wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
 728    }
 729
 730    /*
 731     * Send Data header to Storage daemon
 732     *    <file-index> <stream> <info>
 733     */
 734    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 735       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 736             sd->bstrerror());
 737       goto err;
 738    }
 739    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 740
 741    /*
 742     * Make space at beginning of buffer for fileAddr because this
 743     *   same buffer will be used for writing if compression is off.
 744     */
 745    if (ff_pkt->flags & FO_SPARSE) {
 746       rbuf += SPARSE_FADDR_SIZE;
 747       rsize -= SPARSE_FADDR_SIZE;
 748 #ifdef HAVE_FREEBSD_OS
 749       /*
 750        * To read FreeBSD partitions, the read size must be
 751        *  a multiple of 512.
 752        */
 753       rsize = (rsize/512) * 512;
 754 #endif
 755    }
 756
 757    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 758 #ifdef HAVE_WIN32
 759    if (S_ISBLK(ff_pkt->statp.st_mode))
 760       rsize = (rsize/512) * 512;
 761 #endif
 762
 763    /*
 764     * Read the file data
 765     */
 766    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 767
 768       /* Check for sparse blocks */
 769       if (ff_pkt->flags & FO_SPARSE) {
 770          ser_declare;
 771          bool haveBlock = true;
 772          if (sd->msglen == rsize &&
 773              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 774              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 775                (uint64_t)ff_pkt->statp.st_size == 0)) {
 776             haveBlock = !is_buf_zero(rbuf, rsize);
 777          }
 778          if (haveBlock) {
 779             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 780             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 781          }
 782          fileAddr += sd->msglen;      /* update file address */
 783          if (!haveBlock) {
 784             continue;                 /* skip block of zeros */
 785          }
 786       }
 787
 788       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 789
 790       /* Uncompressed cipher input length */
 791       cipher_input_len = sd->msglen;
 792
 793       /* Update checksum if requested */
 794       if (digest) {
 795          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 796       }
 797
 798       /* Update signing digest if requested */
 799       if (signing_digest) {
 800          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 801       }
 802
 803 #ifdef HAVE_LIBZ
 804       /* Do compression if turned on */
 805       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 806          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 807
 808          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 809                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 810          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 811                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 812
 813          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 814             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 815             set_jcr_job_status(jcr, JS_ErrorTerminated);
 816             goto err;
 817          }
 818          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 819          /* reset zlib stream to be able to begin from scratch again */
 820          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 821             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 822             set_jcr_job_status(jcr, JS_ErrorTerminated);
 823             goto err;
 824          }
 825
 826          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 827                sd->msglen);
 828
 829          sd->msglen = compress_len;      /* set compressed length */
 830          cipher_input_len = compress_len;
 831       }
 832 #endif
 833       /*
 834        * Note, here we prepend the current record length to the beginning
 835        *  of the encrypted data. This is because both sparse and compression
 836        *  restore handling want records returned to them with exactly the
 837        *  same number of bytes that were processed in the backup handling.
 838        *  That is, both are block filters rather than a stream.  When doing
 839        *  compression, the compression routines may buffer data, so that for
 840        *  any one record compressed, when it is decompressed the same size
 841        *  will not be obtained. Of course, the buffered data eventually comes
 842        *  out in subsequent crypto_cipher_update() calls or at least
 843        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 844        *  "feature" of encryption enormously complicates the restore code.
 845        */
 846       if (ff_pkt->flags & FO_ENCRYPT) {
 847          uint32_t initial_len = 0;
 848          ser_declare;
 849
 850          if (ff_pkt->flags & FO_SPARSE) {
 851             cipher_input_len += SPARSE_FADDR_SIZE;
 852          }
 853
 854          /* Encrypt the length of the input block */
 855          uint8_t packet_len[sizeof(uint32_t)];
 856
 857          ser_begin(packet_len, sizeof(uint32_t));
 858          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 859          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 860
 861          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 862              (u_int8_t *)jcr->crypto_buf, &initial_len)) {
 863             /* Encryption failed. Shouldn't happen. */
 864             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 865             goto err;
 866          }
 867
 868          /* Encrypt the input block */
 869          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 870              (u_int8_t *)&jcr->crypto_buf[initial_len], &encrypted_len)) {
 871             if ((initial_len + encrypted_len) == 0) {
 872                /* No full block of data available, read more data */
 873                continue;
 874             }
 875             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 876                   sd->msglen);
 877             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 878          } else {
 879             /* Encryption failed. Shouldn't happen. */
 880             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 881             goto err;
 882          }
 883       }
 884
 885       /* Send the buffer to the Storage daemon */
 886       if (ff_pkt->flags & FO_SPARSE) {
 887          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 888       }
 889       sd->msg = wbuf;              /* set correct write buffer */
 890       if (!sd->send()) {
 891          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 892                sd->bstrerror());
 893          goto err;
 894       }
 895       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 896       /*          #endif */
 897       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 898       sd->msg = msgsave;                /* restore read buffer */
 899
 900    } /* end while read file data */
 901
 902    if (sd->msglen < 0) {                 /* error */
 903       berrno be;
 904       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 905          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
 906       if (jcr->Errors++ > 1000) {       /* insanity check */
 907          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 908       }
 909    } else if (ff_pkt->flags & FO_ENCRYPT) {
 910       /*
 911        * For encryption, we must call finalize to push out any
 912        *  buffered data.
 913        */
 914       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto_buf,
 915            &encrypted_len)) {
 916          /* Padding failed. Shouldn't happen. */
 917          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 918          goto err;
 919       }
 920
 921       /* Note, on SSL pre-0.9.7, there is always some output */
 922       if (encrypted_len > 0) {
 923          sd->msglen = encrypted_len;      /* set encrypted length */
 924          sd->msg = jcr->crypto_buf;       /* set correct write buffer */
 925          if (!sd->send()) {
 926             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 927                   sd->bstrerror());
 928             goto err;
 929          }
 930          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 931          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
 932          sd->msg = msgsave;               /* restore bnet buffer */
 933       }
 934    }
 935
 936    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
 937       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 938             sd->bstrerror());
 939       goto err;
 940    }
 941
 942    /* Free the cipher context */
 943    if (cipher_ctx) {
 944       crypto_cipher_free(cipher_ctx);
 945    }
 946    return 1;
 947
 948 err:
 949    /* Free the cipher context */
 950    if (cipher_ctx) {
 951       crypto_cipher_free(cipher_ctx);
 952    }
 953
 954    sd->msg = msgsave; /* restore bnet buffer */
 955    sd->msglen = 0;
 956    return 0;
 957 }
 958
 959 /*
 960  * Read and send an ACL for the last encountered file.
 961  */
 962 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 963 {
 964 #ifdef HAVE_ACL
 965    BSOCK *sd = jcr->store_bsock;
 966    POOLMEM *msgsave;
 967    int len;
 968 #ifdef FD_NO_SEND_TEST
 969    return true;
 970 #endif
 971
 972    len = bacl_get(jcr, acltype);
 973    if (len < 0) {
 974       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 975       return true;
 976    }
 977    if (len == 0) {
 978       return true;                    /* no ACL */
 979    }
 980
 981    /* Send header */
 982    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 983       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 984             sd->bstrerror());
 985       return false;
 986    }
 987
 988    /* Send the buffer to the storage deamon */
 989    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 990    msgsave = sd->msg;
 991    sd->msg = jcr->acl_text;
 992    sd->msglen = len + 1;
 993    if (!sd->send()) {
 994       sd->msg = msgsave;
 995       sd->msglen = 0;
 996       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 997             sd->bstrerror());
 998       return false;
 999    }
1000
1001    jcr->JobBytes += sd->msglen;
1002    sd->msg = msgsave;
1003    if (!sd->signal(BNET_EOD)) {
1004       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1005             sd->bstrerror());
1006       return false;
1007    }
1008
1009    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
1010 #endif
1011    return true;
1012 }
1013
1014 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1015 {
1016    BSOCK *sd = jcr->store_bsock;
1017    char attribs[MAXSTRING];
1018    char attribsEx[MAXSTRING];
1019    int attr_stream;
1020    int stat;
1021 #ifdef FD_NO_SEND_TEST
1022    return true;
1023 #endif
1024
1025    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1026    /* Find what data stream we will use, then encode the attributes */
1027    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1028       /* This should not happen */
1029       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1030       return false;
1031    }
1032    encode_stat(attribs, ff_pkt, data_stream);
1033
1034    /* Now possibly extend the attributes */
1035    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1036
1037    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1038
1039    jcr->lock();
1040    jcr->JobFiles++;                    /* increment number of files sent */
1041    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1042    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1043    jcr->unlock();
1044
1045    /*
1046     * Send Attributes header to Storage daemon
1047     *    <file-index> <stream> <info>
1048     */
1049    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1050       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1051             sd->bstrerror());
1052       return false;
1053    }
1054    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1055
1056    /*
1057     * Send file attributes to Storage daemon
1058     *   File_index
1059     *   File type
1060     *   Filename (full path)
1061     *   Encoded attributes
1062     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1063     *   Encoded extended-attributes (for Win32)
1064     *
1065     * For a directory, link is the same as fname, but with trailing
1066     * slash. For a linked file, link is the link.
1067     */
1068    strip_path(ff_pkt);
1069    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1070       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1071       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1072                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1073                attribsEx, 0);
1074    } else if (ff_pkt->type == FT_DIREND || ff_pkt->type == FT_REPARSE) {
1075       /* Here link is the canonical filename (i.e. with trailing slash) */
1076       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1077                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1078    } else {
1079       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1080                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1081    }
1082    unstrip_path(ff_pkt);
1083
1084    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1085    if (!stat) {
1086       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1087             sd->bstrerror());
1088       return false;
1089    }
1090    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1091    return true;
1092 }
1093
1094 /*
1095  * Do in place strip of path
1096  */
1097 static bool do_strip(int count, char *in)
1098 {
1099    char *out = in;
1100    int stripped;
1101    int numsep = 0;
1102
1103    /* Copy to first path separator -- Win32 might have c: ... */
1104    while (*in && !IsPathSeparator(*in)) {
1105       *out++ = *in++;
1106    }
1107    *out++ = *in++;
1108    numsep++;                     /* one separator seen */
1109    for (stripped=0; stripped<count && *in; stripped++) {
1110       while (*in && !IsPathSeparator(*in)) {
1111          in++;                   /* skip chars */
1112       }
1113       if (*in) {
1114          numsep++;               /* count separators seen */
1115          in++;                   /* skip separator */
1116       }
1117    }
1118    /* Copy to end */
1119    while (*in) {                /* copy to end */
1120       if (IsPathSeparator(*in)) {
1121          numsep++;
1122       }
1123       *out++ = *in++;
1124    }
1125    *out = 0;
1126    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1127          stripped, count, numsep, numsep>count);
1128    return stripped==count && numsep>count;
1129 }
1130
1131 /*
1132  * If requested strip leading components of the path
1133  */
1134 static void strip_path(FF_PKT *ff_pkt)
1135 {
1136    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1137       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1138       return;
1139    }
1140    if (!ff_pkt->fname_save) {
1141      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1142      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1143    }
1144    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1145
1146    /*
1147     * Strip path.  If it doesn't succeed put it back.  If
1148     *  it does, and there is a different link string,
1149     *  attempt to strip the link. If it fails, but them
1150     *  both back.
1151     * I.e. if either stripping fails don't strip anything.
1152     */
1153    if (do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1154       if (ff_pkt->fname != ff_pkt->link) {
1155          pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1156          if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1157             strcpy(ff_pkt->link, ff_pkt->link_save);
1158             strcpy(ff_pkt->fname, ff_pkt->fname_save);
1159          }
1160       }
1161    } else {
1162       strcpy(ff_pkt->fname, ff_pkt->fname_save);
1163    }
1164    Dmsg2(200, "fname=%s stripped=%s\n", ff_pkt->fname_save, ff_pkt->fname);
1165 }
1166
1167 static void unstrip_path(FF_PKT *ff_pkt)
1168 {
1169    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1170       return;
1171    }
1172    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1173    if (ff_pkt->fname != ff_pkt->link) {
1174       strcpy(ff_pkt->link, ff_pkt->link_save);
1175    }
1176 }