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