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

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