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_DIREND:
 277       Dmsg1(130, "FT_DIREND: %s\n", ff_pkt->link);
 278       break;
 279    case FT_SPEC:
 280       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 281       break;
 282    case FT_RAW:
 283       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 284       has_file_data = true;
 285       break;
 286    case FT_FIFO:
 287       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 288       break;
 289    case FT_NOACCESS: {
 290       berrno be;
 291       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access %s: ERR=%s\n"), ff_pkt->fname,
 292          be.bstrerror(ff_pkt->ff_errno));
 293       jcr->Errors++;
 294       return 1;
 295    }
 296    case FT_NOFOLLOW: {
 297       berrno be;
 298       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link %s: ERR=%s\n"),
 299            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 300       jcr->Errors++;
 301       return 1;
 302    }
 303    case FT_NOSTAT: {
 304       berrno be;
 305       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat %s: ERR=%s\n"), ff_pkt->fname,
 306          be.bstrerror(ff_pkt->ff_errno));
 307       jcr->Errors++;
 308       return 1;
 309    }
 310    case FT_DIRNOCHG:
 311    case FT_NOCHG:
 312       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 313       return 1;
 314    case FT_ISARCH:
 315       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 316       return 1;
 317    case FT_NOOPEN: {
 318       berrno be;
 319       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory %s: ERR=%s\n"),
 320            ff_pkt->fname, be.bstrerror(ff_pkt->ff_errno));
 321       jcr->Errors++;
 322       return 1;
 323    }
 324    default:
 325       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"),
 326            ff_pkt->type, ff_pkt->fname);
 327       jcr->Errors++;
 328       return 1;
 329    }
 330
 331    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 332
 333    /* Digests and encryption are only useful if there's file data */
 334    if (has_file_data) {
 335       /*
 336        * Setup for digest handling. If this fails, the digest will be set to NULL
 337        * and not used. Note, the digest (file hash) can be any one of the four
 338        * algorithms below.
 339        *
 340        * The signing digest is a single algorithm depending on
 341        * whether or not we have SHA2.
 342        *   ****FIXME****  the signing algoritm should really be
 343        *   determined a different way!!!!!!  What happens if
 344        *   sha2 was available during backup but not restore?
 345        */
 346       if (ff_pkt->flags & FO_MD5) {
 347          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_MD5);
 348          digest_stream = STREAM_MD5_DIGEST;
 349
 350       } else if (ff_pkt->flags & FO_SHA1) {
 351          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA1);
 352          digest_stream = STREAM_SHA1_DIGEST;
 353
 354       } else if (ff_pkt->flags & FO_SHA256) {
 355          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA256);
 356          digest_stream = STREAM_SHA256_DIGEST;
 357
 358       } else if (ff_pkt->flags & FO_SHA512) {
 359          digest = crypto_digest_new(jcr, CRYPTO_DIGEST_SHA512);
 360          digest_stream = STREAM_SHA512_DIGEST;
 361       }
 362
 363       /* Did digest initialization fail? */
 364       if (digest_stream != STREAM_NONE && digest == NULL) {
 365          Jmsg(jcr, M_WARNING, 0, _("%s digest initialization failed\n"),
 366             stream_to_ascii(digest_stream));
 367       }
 368
 369       /*
 370        * Set up signature digest handling. If this fails, the signature digest will be set to
 371        * NULL and not used.
 372        */
 373       // TODO landonf: We should really only calculate the digest once, for both verification and signing.
 374       if (jcr->pki_sign) {
 375          signing_digest = crypto_digest_new(jcr, signing_algorithm);
 376
 377          /* Full-stop if a failure occurred initializing the signature digest */
 378          if (signing_digest == NULL) {
 379             Jmsg(jcr, M_NOTSAVED, 0, _("%s signature digest initialization failed\n"),
 380                stream_to_ascii(signing_algorithm));
 381             jcr->Errors++;
 382             goto good_rtn;
 383          }
 384       }
 385
 386       /* Enable encryption */
 387       if (jcr->pki_encrypt) {
 388          ff_pkt->flags |= FO_ENCRYPT;
 389       }
 390    }
 391
 392    /* Initialise the file descriptor we use for data and other streams. */
 393    binit(&ff_pkt->bfd);
 394    if (ff_pkt->flags & FO_PORTABLE) {
 395       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 396    }
 397    if (ff_pkt->reader) {
 398       if (!set_prog(&ff_pkt->bfd, ff_pkt->reader, jcr)) {
 399          Jmsg(jcr, M_FATAL, 0, _("Python reader program \"%s\" not found.\n"),
 400             ff_pkt->reader);
 401          goto bail_out;
 402       }
 403    }
 404
 405    /* Send attributes -- must be done after binit() */
 406    if (!encode_and_send_attributes(jcr, ff_pkt, data_stream)) {
 407       goto bail_out;
 408    }
 409
 410    /* Set up the encryption context and send the session data to the SD */
 411    if (has_file_data && jcr->pki_encrypt) {
 412       /* Send our header */
 413       Dmsg2(100, "Send hdr fi=%ld stream=%d\n", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 414       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_ENCRYPTED_SESSION_DATA);
 415
 416       /* Grow the bsock buffer to fit our message if necessary */
 417       if (sizeof_pool_memory(sd->msg) < jcr->pki_session_encoded_size) {
 418          sd->msg = realloc_pool_memory(sd->msg, jcr->pki_session_encoded_size);
 419       }
 420
 421       /* Copy our message over and send it */
 422       memcpy(sd->msg, jcr->pki_session_encoded, jcr->pki_session_encoded_size);
 423       sd->msglen = jcr->pki_session_encoded_size;
 424       jcr->JobBytes += sd->msglen;
 425
 426       Dmsg1(100, "Send data len=%d\n", sd->msglen);
 427       sd->send();
 428       sd->signal(BNET_EOD);
 429    }
 430
 431    /*
 432     * Open any file with data that we intend to save, then save it.
 433     *
 434     * Note, if is_win32_backup, we must open the Directory so that
 435     * the BackupRead will save its permissions and ownership streams.
 436     */
 437    if (ff_pkt->type != FT_LNKSAVED && S_ISREG(ff_pkt->statp.st_mode)) {
 438 #ifdef HAVE_WIN32
 439       do_read = !is_portable_backup(&ff_pkt->bfd) || ff_pkt->statp.st_size > 0;
 440 #else
 441       do_read = ff_pkt->statp.st_size > 0;
 442 #endif
 443    } else if (ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 444          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 445       do_read = true;
 446    }
 447
 448    if (do_read) {
 449       btimer_t *tid;
 450       if (ff_pkt->type == FT_FIFO) {
 451          tid = start_thread_timer(pthread_self(), 60);
 452       } else {
 453          tid = NULL;
 454       }
 455       int noatime = ff_pkt->flags & FO_NOATIME ? O_NOATIME : 0;
 456       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY | noatime, 0) < 0) {
 457          ff_pkt->ff_errno = errno;
 458          berrno be;
 459          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
 460               be.bstrerror());
 461          jcr->Errors++;
 462          if (tid) {
 463             stop_thread_timer(tid);
 464             tid = NULL;
 465          }
 466          goto good_rtn;
 467       }
 468       if (tid) {
 469          stop_thread_timer(tid);
 470          tid = NULL;
 471       }
 472
 473       stat = send_data(jcr, data_stream, ff_pkt, digest, signing_digest);
 474
 475       if (ff_pkt->flags & FO_CHKCHANGES) {
 476          has_file_changed(jcr, ff_pkt);
 477       }
 478
 479       bclose(&ff_pkt->bfd);
 480
 481       if (!stat) {
 482          goto bail_out;
 483       }
 484    }
 485
 486 #ifdef HAVE_DARWIN_OS
 487    /* Regular files can have resource forks and Finder Info */
 488    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 489             ff_pkt->flags & FO_HFSPLUS)) {
 490       if (ff_pkt->hfsinfo.rsrclength > 0) {
 491          int flags;
 492          int rsrc_stream;
 493          if (!bopen_rsrc(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 494             ff_pkt->ff_errno = errno;
 495             berrno be;
 496             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for %s: ERR=%s.\n"),
 497                  ff_pkt->fname, be.bstrerror());
 498             jcr->Errors++;
 499             if (is_bopen(&ff_pkt->bfd)) {
 500                bclose(&ff_pkt->bfd);
 501             }
 502             goto good_rtn;
 503          }
 504          flags = ff_pkt->flags;
 505          ff_pkt->flags &= ~(FO_GZIP|FO_SPARSE);
 506          if (flags & FO_ENCRYPT) {
 507             rsrc_stream = STREAM_ENCRYPTED_MACOS_FORK_DATA;
 508          } else {
 509             rsrc_stream = STREAM_MACOS_FORK_DATA;
 510          }
 511          stat = send_data(jcr, rsrc_stream, ff_pkt, digest, signing_digest);
 512          ff_pkt->flags = flags;
 513          bclose(&ff_pkt->bfd);
 514          if (!stat) {
 515             goto bail_out;
 516          }
 517       }
 518
 519       Dmsg1(300, "Saving Finder Info for \"%s\"\n", ff_pkt->fname);
 520       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 521       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 522       memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 523       sd->msglen = 32;
 524       if (digest) {
 525          crypto_digest_update(digest, (uint8_t *)sd->msg, sd->msglen);
 526       }
 527       if (signing_digest) {
 528          crypto_digest_update(signing_digest, (uint8_t *)sd->msg, sd->msglen);
 529       }
 530       sd->send();
 531       sd->signal(BNET_EOD);
 532    }
 533 #endif
 534
 535    if (ff_pkt->flags & FO_ACL) {
 536       /* Read access ACLs for files, dirs and links */
 537       if (!read_and_send_acl(jcr, BACL_TYPE_ACCESS, STREAM_UNIX_ATTRIBUTES_ACCESS_ACL)) {
 538          goto bail_out;
 539       }
 540       /* Directories can have default ACLs too */
 541       if (ff_pkt->type == FT_DIREND && (BACL_CAP & BACL_CAP_DEFAULTS_DIR)) {
 542          if (!read_and_send_acl(jcr, BACL_TYPE_DEFAULT, STREAM_UNIX_ATTRIBUTES_DEFAULT_ACL)) {
 543             goto bail_out;
 544          }
 545       }
 546    }
 547
 548    /* Terminate the signing digest and send it to the Storage daemon */
 549    if (signing_digest) {
 550       uint32_t size = 0;
 551
 552       if ((sig = crypto_sign_new(jcr)) == NULL) {
 553          Jmsg(jcr, M_FATAL, 0, _("Failed to allocate memory for crypto signature.\n"));
 554          goto bail_out;
 555       }
 556
 557       if (!crypto_sign_add_signer(sig, signing_digest, jcr->pki_keypair)) {
 558          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 559          goto bail_out;
 560       }
 561
 562       /* Get signature size */
 563       if (!crypto_sign_encode(sig, NULL, &size)) {
 564          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 565          goto bail_out;
 566       }
 567
 568       /* Grow the bsock buffer to fit our message if necessary */
 569       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 570          sd->msg = realloc_pool_memory(sd->msg, size);
 571       }
 572
 573       /* Send our header */
 574       sd->fsend("%ld %d 0", jcr->JobFiles, STREAM_SIGNED_DIGEST);
 575       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 576
 577       /* Encode signature data */
 578       if (!crypto_sign_encode(sig, (uint8_t *)sd->msg, &size)) {
 579          Jmsg(jcr, M_FATAL, 0, _("An error occurred while signing the stream.\n"));
 580          goto bail_out;
 581       }
 582
 583       sd->msglen = size;
 584       sd->send();
 585       sd->signal(BNET_EOD);              /* end of checksum */
 586    }
 587
 588    /* Terminate any digest and send it to Storage daemon and the Director */
 589    if (digest) {
 590       uint32_t size;
 591
 592       sd->fsend("%ld %d 0", jcr->JobFiles, digest_stream);
 593       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 594
 595       size = sizeof(CRYPTO_DIGEST_MAX_SIZE);
 596       /* Grow the bsock buffer to fit our message if necessary */
 597       if (sizeof_pool_memory(sd->msg) < (int32_t)size) {
 598          sd->msg = realloc_pool_memory(sd->msg, size);
 599       }
 600
 601       if (!crypto_digest_finalize(digest, (uint8_t *)sd->msg, &size)) {
 602          Jmsg(jcr, M_FATAL, 0, _("An error occurred finalizing signing the stream.\n"));
 603          goto bail_out;
 604       }
 605
 606       sd->msglen = size;
 607       sd->send();
 608       sd->signal(BNET_EOD);              /* end of checksum */
 609    }
 610
 611 good_rtn:
 612    rtnstat = 1;                       /* good return */
 613
 614 bail_out:
 615    if (digest) {
 616       crypto_digest_free(digest);
 617    }
 618    if (signing_digest) {
 619       crypto_digest_free(signing_digest);
 620    }
 621    if (sig) {
 622       crypto_sign_free(sig);
 623    }
 624    return rtnstat;
 625 }
 626
 627 /*
 628  * Send data read from an already open file descriptor.
 629  *
 630  * We return 1 on sucess and 0 on errors.
 631  *
 632  * ***FIXME***
 633  * We use ff_pkt->statp.st_size when FO_SPARSE to know when to stop
 634  *  reading.
 635  * Currently this is not a problem as the only other stream, resource forks,
 636  * are not handled as sparse files.
 637  */
 638 int send_data(JCR *jcr, int stream, FF_PKT *ff_pkt, DIGEST *digest,
 639               DIGEST *signing_digest)
 640 {
 641    BSOCK *sd = jcr->store_bsock;
 642    uint64_t fileAddr = 0;             /* file address */
 643    char *rbuf, *wbuf;
 644    int32_t rsize = jcr->buf_size;      /* read buffer size */
 645    POOLMEM *msgsave;
 646    CIPHER_CONTEXT *cipher_ctx = NULL; /* Quell bogus uninitialized warnings */
 647    const uint8_t *cipher_input;
 648    uint32_t cipher_input_len;
 649    uint32_t cipher_block_size;
 650    uint32_t encrypted_len;
 651 #ifdef FD_NO_SEND_TEST
 652    return 1;
 653 #endif
 654
 655    msgsave = sd->msg;
 656    rbuf = sd->msg;                    /* read buffer */
 657    wbuf = sd->msg;                    /* write buffer */
 658    cipher_input = (uint8_t *)rbuf;    /* encrypt uncompressed data */
 659
 660    Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 661
 662 #ifdef HAVE_LIBZ
 663    uLong compress_len = 0;
 664    uLong max_compress_len = 0;
 665    const Bytef *cbuf = NULL;
 666    int zstat;
 667
 668    if (ff_pkt->flags & FO_GZIP) {
 669       if (ff_pkt->flags & FO_SPARSE) {
 670          cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 671          max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 672       } else {
 673          cbuf = (Bytef *)jcr->compress_buf;
 674          max_compress_len = jcr->compress_buf_size; /* set max length */
 675       }
 676       wbuf = jcr->compress_buf;    /* compressed output here */
 677       cipher_input = (uint8_t *)jcr->compress_buf; /* encrypt compressed data */
 678
 679       /*
 680        * Only change zlib parameters if there is no pending operation.
 681        * This should never happen as deflatereset is called after each
 682        * deflate.
 683        */
 684
 685       if (((z_stream*)jcr->pZLIB_compress_workset)->total_in == 0) {
 686          /* set gzip compression level - must be done per file */
 687          if ((zstat=deflateParams((z_stream*)jcr->pZLIB_compress_workset,
 688               ff_pkt->GZIP_level, Z_DEFAULT_STRATEGY)) != Z_OK) {
 689             Jmsg(jcr, M_FATAL, 0, _("Compression deflateParams error: %d\n"), zstat);
 690             set_jcr_job_status(jcr, JS_ErrorTerminated);
 691             goto err;
 692          }
 693       }
 694    }
 695 #else
 696    const uint32_t max_compress_len = 0;
 697 #endif
 698
 699    if (ff_pkt->flags & FO_ENCRYPT) {
 700       if (ff_pkt->flags & FO_SPARSE) {
 701          Jmsg0(jcr, M_FATAL, 0, _("Encrypting sparse data not supported.\n"));
 702          goto err;
 703       }
 704       /* Allocate the cipher context */
 705       if ((cipher_ctx = crypto_cipher_new(jcr->pki_session, true,
 706            &cipher_block_size)) == NULL) {
 707          /* Shouldn't happen! */
 708          Jmsg0(jcr, M_FATAL, 0, _("Failed to initialize encryption context.\n"));
 709          goto err;
 710       }
 711
 712       /*
 713        * Grow the crypto buffer, if necessary.
 714        * crypto_cipher_update() will buffer up to (cipher_block_size - 1).
 715        * We grow crypto_buf to the maximum number of blocks that
 716        * could be returned for the given read buffer size.
 717        * (Using the larger of either rsize or max_compress_len)
 718        */
 719       jcr->crypto_buf = check_pool_memory_size(jcr->crypto_buf,
 720            (MAX(rsize + (int)sizeof(uint32_t), (int32_t)max_compress_len) +
 721             cipher_block_size - 1) / cipher_block_size * cipher_block_size);
 722
 723       wbuf = jcr->crypto_buf; /* Encrypted, possibly compressed output here. */
 724    }
 725
 726    /*
 727     * Send Data header to Storage daemon
 728     *    <file-index> <stream> <info>
 729     */
 730    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 731       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 732             sd->bstrerror());
 733       goto err;
 734    }
 735    Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 736
 737    /*
 738     * Make space at beginning of buffer for fileAddr because this
 739     *   same buffer will be used for writing if compression is off.
 740     */
 741    if (ff_pkt->flags & FO_SPARSE) {
 742       rbuf += SPARSE_FADDR_SIZE;
 743       rsize -= SPARSE_FADDR_SIZE;
 744 #ifdef HAVE_FREEBSD_OS
 745       /*
 746        * To read FreeBSD partitions, the read size must be
 747        *  a multiple of 512.
 748        */
 749       rsize = (rsize/512) * 512;
 750 #endif
 751    }
 752
 753    /* a RAW device read on win32 only works if the buffer is a multiple of 512 */
 754 #ifdef HAVE_WIN32
 755    if (S_ISBLK(ff_pkt->statp.st_mode))
 756       rsize = (rsize/512) * 512;
 757 #endif
 758
 759    /*
 760     * Read the file data
 761     */
 762    while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 763
 764       /* Check for sparse blocks */
 765       if (ff_pkt->flags & FO_SPARSE) {
 766          ser_declare;
 767          bool haveBlock = true;
 768          if (sd->msglen == rsize &&
 769              fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size ||
 770              ((ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO) &&
 771                (uint64_t)ff_pkt->statp.st_size == 0)) {
 772             haveBlock = !is_buf_zero(rbuf, rsize);
 773          }
 774          if (haveBlock) {
 775             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 776             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 777          }
 778          fileAddr += sd->msglen;      /* update file address */
 779          if (!haveBlock) {
 780             continue;                 /* skip block of zeros */
 781          }
 782       }
 783
 784       jcr->ReadBytes += sd->msglen;         /* count bytes read */
 785
 786       /* Uncompressed cipher input length */
 787       cipher_input_len = sd->msglen;
 788
 789       /* Update checksum if requested */
 790       if (digest) {
 791          crypto_digest_update(digest, (uint8_t *)rbuf, sd->msglen);
 792       }
 793
 794       /* Update signing digest if requested */
 795       if (signing_digest) {
 796          crypto_digest_update(signing_digest, (uint8_t *)rbuf, sd->msglen);
 797       }
 798
 799 #ifdef HAVE_LIBZ
 800       /* Do compression if turned on */
 801       if (ff_pkt->flags & FO_GZIP && jcr->pZLIB_compress_workset) {
 802          Dmsg3(400, "cbuf=0x%x rbuf=0x%x len=%u\n", cbuf, rbuf, sd->msglen);
 803
 804          ((z_stream*)jcr->pZLIB_compress_workset)->next_in   = (Bytef *)rbuf;
 805                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_in  = sd->msglen;
 806          ((z_stream*)jcr->pZLIB_compress_workset)->next_out  = (Bytef *)cbuf;
 807                 ((z_stream*)jcr->pZLIB_compress_workset)->avail_out = max_compress_len;
 808
 809          if ((zstat=deflate((z_stream*)jcr->pZLIB_compress_workset, Z_FINISH)) != Z_STREAM_END) {
 810             Jmsg(jcr, M_FATAL, 0, _("Compression deflate error: %d\n"), zstat);
 811             set_jcr_job_status(jcr, JS_ErrorTerminated);
 812             goto err;
 813          }
 814          compress_len = ((z_stream*)jcr->pZLIB_compress_workset)->total_out;
 815          /* reset zlib stream to be able to begin from scratch again */
 816          if ((zstat=deflateReset((z_stream*)jcr->pZLIB_compress_workset)) != Z_OK) {
 817             Jmsg(jcr, M_FATAL, 0, _("Compression deflateReset error: %d\n"), zstat);
 818             set_jcr_job_status(jcr, JS_ErrorTerminated);
 819             goto err;
 820          }
 821
 822          Dmsg2(400, "compressed len=%d uncompressed len=%d\n", compress_len,
 823                sd->msglen);
 824
 825          sd->msglen = compress_len;      /* set compressed length */
 826          cipher_input_len = compress_len;
 827       }
 828 #endif
 829       /*
 830        * Note, here we prepend the current record length to the beginning
 831        *  of the encrypted data. This is because both sparse and compression
 832        *  restore handling want records returned to them with exactly the
 833        *  same number of bytes that were processed in the backup handling.
 834        *  That is, both are block filters rather than a stream.  When doing
 835        *  compression, the compression routines may buffer data, so that for
 836        *  any one record compressed, when it is decompressed the same size
 837        *  will not be obtained. Of course, the buffered data eventually comes
 838        *  out in subsequent crypto_cipher_update() calls or at least
 839        *  when crypto_cipher_finalize() is called.  Unfortunately, this
 840        *  "feature" of encryption enormously complicates the restore code.
 841        */
 842       if (ff_pkt->flags & FO_ENCRYPT) {
 843          uint32_t initial_len = 0;
 844          ser_declare;
 845
 846          if (ff_pkt->flags & FO_SPARSE) {
 847             cipher_input_len += SPARSE_FADDR_SIZE;
 848          }
 849
 850          /* Encrypt the length of the input block */
 851          uint8_t packet_len[sizeof(uint32_t)];
 852
 853          ser_begin(packet_len, sizeof(uint32_t));
 854          ser_uint32(cipher_input_len);    /* store data len in begin of buffer */
 855          Dmsg1(20, "Encrypt len=%d\n", cipher_input_len);
 856
 857          if (!crypto_cipher_update(cipher_ctx, packet_len, sizeof(packet_len),
 858              (u_int8_t *)jcr->crypto_buf, &initial_len)) {
 859             /* Encryption failed. Shouldn't happen. */
 860             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 861             goto err;
 862          }
 863
 864          /* Encrypt the input block */
 865          if (crypto_cipher_update(cipher_ctx, cipher_input, cipher_input_len,
 866              (u_int8_t *)&jcr->crypto_buf[initial_len], &encrypted_len)) {
 867             if ((initial_len + encrypted_len) == 0) {
 868                /* No full block of data available, read more data */
 869                continue;
 870             }
 871             Dmsg2(400, "encrypted len=%d unencrypted len=%d\n", encrypted_len,
 872                   sd->msglen);
 873             sd->msglen = initial_len + encrypted_len; /* set encrypted length */
 874          } else {
 875             /* Encryption failed. Shouldn't happen. */
 876             Jmsg(jcr, M_FATAL, 0, _("Encryption error\n"));
 877             goto err;
 878          }
 879       }
 880
 881       /* Send the buffer to the Storage daemon */
 882       if (ff_pkt->flags & FO_SPARSE) {
 883          sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 884       }
 885       sd->msg = wbuf;              /* set correct write buffer */
 886       if (!sd->send()) {
 887          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 888                sd->bstrerror());
 889          goto err;
 890       }
 891       Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 892       /*          #endif */
 893       jcr->JobBytes += sd->msglen;      /* count bytes saved possibly compressed/encrypted */
 894       sd->msg = msgsave;                /* restore read buffer */
 895
 896    } /* end while read file data */
 897
 898    if (sd->msglen < 0) {                 /* error */
 899       berrno be;
 900       Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 901          ff_pkt->fname, be.bstrerror(ff_pkt->bfd.berrno));
 902       if (jcr->Errors++ > 1000) {       /* insanity check */
 903          Jmsg(jcr, M_FATAL, 0, _("Too many errors.\n"));
 904       }
 905    } else if (ff_pkt->flags & FO_ENCRYPT) {
 906       /*
 907        * For encryption, we must call finalize to push out any
 908        *  buffered data.
 909        */
 910       if (!crypto_cipher_finalize(cipher_ctx, (uint8_t *)jcr->crypto_buf,
 911            &encrypted_len)) {
 912          /* Padding failed. Shouldn't happen. */
 913          Jmsg(jcr, M_FATAL, 0, _("Encryption padding error\n"));
 914          goto err;
 915       }
 916
 917       /* Note, on SSL pre-0.9.7, there is always some output */
 918       if (encrypted_len > 0) {
 919          sd->msglen = encrypted_len;      /* set encrypted length */
 920          sd->msg = jcr->crypto_buf;       /* set correct write buffer */
 921          if (!sd->send()) {
 922             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 923                   sd->bstrerror());
 924             goto err;
 925          }
 926          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 927          jcr->JobBytes += sd->msglen;     /* count bytes saved possibly compressed/encrypted */
 928          sd->msg = msgsave;               /* restore bnet buffer */
 929       }
 930    }
 931
 932    if (!sd->signal(BNET_EOD)) {        /* indicate end of file data */
 933       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 934             sd->bstrerror());
 935       goto err;
 936    }
 937
 938    /* Free the cipher context */
 939    if (cipher_ctx) {
 940       crypto_cipher_free(cipher_ctx);
 941    }
 942    return 1;
 943
 944 err:
 945    /* Free the cipher context */
 946    if (cipher_ctx) {
 947       crypto_cipher_free(cipher_ctx);
 948    }
 949
 950    sd->msg = msgsave; /* restore bnet buffer */
 951    sd->msglen = 0;
 952    return 0;
 953 }
 954
 955 /*
 956  * Read and send an ACL for the last encountered file.
 957  */
 958 static bool read_and_send_acl(JCR *jcr, int acltype, int stream)
 959 {
 960 #ifdef HAVE_ACL
 961    BSOCK *sd = jcr->store_bsock;
 962    POOLMEM *msgsave;
 963    int len;
 964 #ifdef FD_NO_SEND_TEST
 965    return true;
 966 #endif
 967
 968    len = bacl_get(jcr, acltype);
 969    if (len < 0) {
 970       Jmsg1(jcr, M_WARNING, 0, _("Error reading ACL of %s\n"), jcr->last_fname);
 971       return true;
 972    }
 973    if (len == 0) {
 974       return true;                    /* no ACL */
 975    }
 976
 977    /* Send header */
 978    if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
 979       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 980             sd->bstrerror());
 981       return false;
 982    }
 983
 984    /* Send the buffer to the storage deamon */
 985    Dmsg2(400, "Backing up ACL type 0x%2x <%s>\n", acltype, jcr->acl_text);
 986    msgsave = sd->msg;
 987    sd->msg = jcr->acl_text;
 988    sd->msglen = len + 1;
 989    if (!sd->send()) {
 990       sd->msg = msgsave;
 991       sd->msglen = 0;
 992       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 993             sd->bstrerror());
 994       return false;
 995    }
 996
 997    jcr->JobBytes += sd->msglen;
 998    sd->msg = msgsave;
 999    if (!sd->signal(BNET_EOD)) {
1000       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1001             sd->bstrerror());
1002       return false;
1003    }
1004
1005    Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
1006 #endif
1007    return true;
1008 }
1009
1010 static bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
1011 {
1012    BSOCK *sd = jcr->store_bsock;
1013    char attribs[MAXSTRING];
1014    char attribsEx[MAXSTRING];
1015    int attr_stream;
1016    int stat;
1017 #ifdef FD_NO_SEND_TEST
1018    return true;
1019 #endif
1020
1021    Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
1022    /* Find what data stream we will use, then encode the attributes */
1023    if ((data_stream = select_data_stream(ff_pkt)) == STREAM_NONE) {
1024       /* This should not happen */
1025       Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
1026       return false;
1027    }
1028    encode_stat(attribs, ff_pkt, data_stream);
1029
1030    /* Now possibly extend the attributes */
1031    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
1032
1033    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
1034
1035    jcr->lock();
1036    jcr->JobFiles++;                    /* increment number of files sent */
1037    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
1038    pm_strcpy(jcr->last_fname, ff_pkt->fname);
1039    jcr->unlock();
1040
1041    /*
1042     * Send Attributes header to Storage daemon
1043     *    <file-index> <stream> <info>
1044     */
1045    if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
1046       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1047             sd->bstrerror());
1048       return false;
1049    }
1050    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
1051
1052    /*
1053     * Send file attributes to Storage daemon
1054     *   File_index
1055     *   File type
1056     *   Filename (full path)
1057     *   Encoded attributes
1058     *   Link name (if type==FT_LNK or FT_LNKSAVED)
1059     *   Encoded extended-attributes (for Win32)
1060     *
1061     * For a directory, link is the same as fname, but with trailing
1062     * slash. For a linked file, link is the link.
1063     */
1064    strip_path(ff_pkt);
1065    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
1066       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
1067       stat = sd->fsend("%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
1068                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
1069                attribsEx, 0);
1070    } else if (ff_pkt->type == FT_DIREND) {
1071       /* Here link is the canonical filename (i.e. with trailing slash) */
1072       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1073                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
1074    } else {
1075       stat = sd->fsend("%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
1076                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
1077    }
1078    unstrip_path(ff_pkt);
1079
1080    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
1081    if (!stat) {
1082       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
1083             sd->bstrerror());
1084       return false;
1085    }
1086    sd->signal(BNET_EOD);            /* indicate end of attributes data */
1087    return true;
1088 }
1089
1090 /*
1091  * Do in place strip of path
1092  */
1093 static bool do_strip(int count, char *in)
1094 {
1095    char *out = in;
1096    int stripped;
1097    int numsep = 0;
1098
1099    /* Copy to first path separator -- Win32 might have c: ... */
1100    while (*in && !IsPathSeparator(*in)) {
1101       *out++ = *in++;
1102    }
1103    *out++ = *in++;
1104    numsep++;                     /* one separator seen */
1105    for (stripped=0; stripped<count && *in; stripped++) {
1106       while (*in && !IsPathSeparator(*in)) {
1107          in++;                   /* skip chars */
1108       }
1109       if (*in) {
1110          numsep++;               /* count separators seen */
1111          in++;                   /* skip separator */
1112       }
1113    }
1114    /* Copy to end */
1115    while (*in) {                /* copy to end */
1116       if (IsPathSeparator(*in)) {
1117          numsep++;
1118       }
1119       *out++ = *in++;
1120    }
1121    *out = 0;
1122    Dmsg4(500, "stripped=%d count=%d numsep=%d sep>count=%d\n",
1123          stripped, count, numsep, numsep>count);
1124    return stripped==count && numsep>count;
1125 }
1126
1127 /*
1128  * If requested strip leading components of the path
1129  */
1130 static void strip_path(FF_PKT *ff_pkt)
1131 {
1132    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1133       Dmsg1(200, "No strip for %s\n", ff_pkt->fname);
1134       return;
1135    }
1136    if (!ff_pkt->fname_save) {
1137      ff_pkt->fname_save = get_pool_memory(PM_FNAME);
1138      ff_pkt->link_save = get_pool_memory(PM_FNAME);
1139    }
1140    pm_strcpy(ff_pkt->fname_save, ff_pkt->fname);
1141
1142    /*
1143     * Strip path.  If it doesn't succeed put it back.  If
1144     *  it does, and there is a different link string,
1145     *  attempt to strip the link. If it fails, but them
1146     *  both back.
1147     * I.e. if either stripping fails don't strip anything.
1148     */
1149    if (do_strip(ff_pkt->strip_path, ff_pkt->fname)) {
1150       if (ff_pkt->fname != ff_pkt->link) {
1151          pm_strcpy(ff_pkt->link_save, ff_pkt->link);
1152          if (!do_strip(ff_pkt->strip_path, ff_pkt->link)) {
1153             strcpy(ff_pkt->link, ff_pkt->link_save);
1154             strcpy(ff_pkt->fname, ff_pkt->fname_save);
1155          }
1156       }
1157    } else {
1158       strcpy(ff_pkt->fname, ff_pkt->fname_save);
1159    }
1160    Dmsg2(200, "fname=%s stripped=%s\n", ff_pkt->fname_save, ff_pkt->fname);
1161 }
1162
1163 static void unstrip_path(FF_PKT *ff_pkt)
1164 {
1165    if (!(ff_pkt->flags & FO_STRIPPATH) || ff_pkt->strip_path <= 0) {
1166       return;
1167    }
1168    strcpy(ff_pkt->fname, ff_pkt->fname_save);
1169    if (ff_pkt->fname != ff_pkt->link) {
1170       strcpy(ff_pkt->link, ff_pkt->link_save);
1171    }
1172 }