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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 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 Kern Sibbald.
  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  restore.c Restorefiles.
  30  *
  31  *    Kern Sibbald, November MM
  32  *
  33  *   Version $Id$
  34  *
  35  */
  36
  37 #include "bacula.h"
  38 #include "filed.h"
  39
  40 #ifdef HAVE_DARWIN_OS
  41 #include <sys/attr.h>
  42 const bool have_darwin_os = true;
  43 #else
  44 const bool have_darwin_os = false;
  45 #endif
  46
  47 #if defined(HAVE_CRYPTO)
  48 const bool have_crypto = true;
  49 #else
  50 const bool have_crypto = false;
  51 #endif
  52
  53 #if defined(HAVE_ACL)
  54 const bool have_acl = true;
  55 #else
  56 const bool have_acl = false;
  57 #endif
  58
  59 #ifdef HAVE_SHA2
  60 const bool have_sha2 = true;
  61 #else
  62 const bool have_sha2 = false;
  63 #endif
  64
  65 #if defined(HAVE_XATTR)
  66 const bool have_xattr = true;
  67 #else
  68 const bool have_xattr = false;
  69 #endif
  70
  71 /* Data received from Storage Daemon */
  72 static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
  73
  74 typedef struct restore_cipher_ctx {
  75    CIPHER_CONTEXT *cipher;
  76    uint32_t block_size;
  77
  78    POOLMEM *buf;       /* Pointer to descryption buffer */
  79    int32_t buf_len;    /* Count of bytes currently in buf */
  80    int32_t packet_len; /* Total bytes in packet */
  81 } RESTORE_CIPHER_CTX;
  82
  83 struct r_ctx {
  84    JCR *jcr;
  85    int32_t stream;
  86    int32_t prev_stream;
  87    BFILE bfd;                          /* File content */
  88    uint64_t fileAddr;                  /* file write address */
  89    uint32_t size;                      /* Size of file */
  90    int flags;                          /* Options for extract_data() */
  91    BFILE forkbfd;                      /* Alternative data stream */
  92    uint64_t fork_addr;                 /* Write address for alternative stream */
  93    intmax_t fork_size;                 /* Size of alternate stream */
  94    int fork_flags;                     /* Options for extract_data() */
  95    int32_t type;                       /* file type FT_ */
  96    ATTR *attr;                         /* Pointer to attributes */
  97    bool extract;                       /* set when extracting */
  98
  99    SIGNATURE *sig;                     /* Cryptographic signature (if any) for file */
 100    CRYPTO_SESSION *cs;                 /* Cryptographic session data (if any) for file */
 101    RESTORE_CIPHER_CTX cipher_ctx;      /* Cryptographic restore context (if any) for file */
 102    RESTORE_CIPHER_CTX fork_cipher_ctx; /* Cryptographic restore context (if any) for alternative stream */
 103 };
 104
 105
 106 /* Forward referenced functions */
 107 #if   defined(HAVE_LIBZ)
 108 static const char *zlib_strerror(int stat);
 109 const bool have_libz = true;
 110 #else
 111 const bool have_libz = false;
 112 #endif
 113
 114 static void deallocate_cipher(r_ctx &rctx);
 115 static void deallocate_fork_cipher(r_ctx &rctx);
 116 static void free_signature(r_ctx &rctx);
 117 static void free_session(r_ctx &rctx);
 118 static void close_previous_stream(r_ctx &rctx);
 119
 120
 121
 122 static bool verify_signature(JCR *jcr, r_ctx &rctx);
 123 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
 124                      uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx);
 125 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
 126                   RESTORE_CIPHER_CTX *cipher_ctx);
 127
 128
 129 /*
 130  * Close a bfd check that we are at the expected file offset.
 131  * Makes use of some code from set_attributes().
 132  */
 133 static int bclose_chksize(JCR *jcr, BFILE *bfd, boffset_t osize)
 134 {
 135    char ec1[50], ec2[50];
 136    boffset_t fsize;
 137
 138    fsize = blseek(bfd, 0, SEEK_CUR);
 139    bclose(bfd);                              /* first close file */
 140    if (fsize > 0 && fsize != osize) {
 141       Qmsg3(jcr, M_ERROR, 0, _("Size of data or stream of %s not correct. Original %s, restored %s.\n"),
 142             jcr->last_fname, edit_uint64(osize, ec1),
 143             edit_uint64(fsize, ec2));
 144       return -1;
 145    }
 146    return 0;
 147 }
 148
 149
 150 /*
 151  * Restore the requested files.
 152  *
 153  */
 154 void do_restore(JCR *jcr)
 155 {
 156    BSOCK *sd;
 157    uint32_t VolSessionId, VolSessionTime;
 158    int32_t file_index;
 159    char ec1[50];                       /* Buffer printing huge values */
 160    uint32_t buf_size;                  /* client buffer size */
 161    int stat;
 162    intmax_t rsrc_len = 0;             /* Original length of resource fork */
 163    r_ctx rctx;
 164    ATTR *attr;
 165    /* ***FIXME*** make configurable */
 166    crypto_digest_t signing_algorithm = have_sha2 ?
 167                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 168    memset(&rctx, 0, sizeof(rctx));
 169    rctx.jcr = jcr;
 170
 171    /* The following variables keep track of "known unknowns" */
 172    int non_support_data = 0;
 173    int non_support_attr = 0;
 174    int non_support_rsrc = 0;
 175    int non_support_finfo = 0;
 176    int non_support_acl = 0;
 177    int non_support_progname = 0;
 178    int non_support_crypto = 0;
 179    int non_support_xattr = 0;
 180
 181 #ifdef HAVE_DARWIN_OS
 182    struct attrlist attrList;
 183    memset(&attrList, 0, sizeof(attrList));
 184    attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
 185    attrList.commonattr = ATTR_CMN_FNDRINFO;
 186 #endif
 187
 188
 189    sd = jcr->store_bsock;
 190    set_jcr_job_status(jcr, JS_Running);
 191
 192    LockRes();
 193    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
 194    UnlockRes();
 195    if (client) {
 196       buf_size = client->max_network_buffer_size;
 197    } else {
 198       buf_size = 0;                   /* use default */
 199    }
 200    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
 201       set_jcr_job_status(jcr, JS_ErrorTerminated);
 202       return;
 203    }
 204    jcr->buf_size = sd->msglen;
 205
 206    /* St Bernard code goes here if implemented -- see end of file */
 207
 208    if (have_libz) {
 209       uint32_t compress_buf_size = jcr->buf_size + 12 + ((jcr->buf_size+999) / 1000) + 100;
 210       jcr->compress_buf = (char *)bmalloc(compress_buf_size);
 211       jcr->compress_buf_size = compress_buf_size;
 212    }
 213
 214    if (have_crypto) {
 215       rctx.cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 216       if (have_darwin_os) {
 217          rctx.fork_cipher_ctx.buf = get_memory(CRYPTO_CIPHER_MAX_BLOCK_SIZE);
 218       }
 219    }
 220
 221    /*
 222     * Get a record from the Storage daemon. We are guaranteed to
 223     *   receive records in the following order:
 224     *   1. Stream record header
 225     *   2. Stream data (one or more of the following in the order given)
 226     *        a. Attributes (Unix or Win32)
 227     *        b. Possibly stream encryption session data (e.g., symmetric session key)
 228     *        c. File data for the file
 229     *        d. Alternate data stream (e.g. Resource Fork)
 230     *        e. Finder info
 231     *        f. ACLs
 232     *        g. XATTRs
 233     *        h. Possibly a cryptographic signature
 234     *        i. Possibly MD5 or SHA1 record
 235     *   3. Repeat step 1
 236     *
 237     * NOTE: We keep track of two bacula file descriptors:
 238     *   1. bfd for file data.
 239     *      This fd is opened for non empty files when an attribute stream is
 240     *      encountered and closed when we find the next attribute stream.
 241     *   2. fork_bfd for alternate data streams
 242     *      This fd is opened every time we encounter a new alternate data
 243     *      stream for the current file. When we find any other stream, we
 244     *      close it again.
 245     *      The expected size of the stream, fork_len, should be set when
 246     *      opening the fd.
 247     *   3. Not all the stream data records are required -- e.g. if there
 248     *      is no fork, there is no alternate data stream, no ACL, ...
 249     */
 250    binit(&rctx.bfd);
 251    binit(&rctx.forkbfd);
 252    attr = rctx.attr = new_attr(jcr);
 253    if (have_acl) {
 254       jcr->acl_data = (acl_data_t *)malloc(sizeof(acl_data_t));
 255       memset((caddr_t)jcr->acl_data, 0, sizeof(acl_data_t));
 256       jcr->acl_data->content = get_pool_memory(PM_MESSAGE);
 257    }
 258    if (have_xattr) {
 259       jcr->xattr_data = (xattr_data_t *)malloc(sizeof(xattr_data_t));
 260       memset((caddr_t)jcr->xattr_data, 0, sizeof(xattr_data_t));
 261       jcr->xattr_data->content = get_pool_memory(PM_MESSAGE);
 262    }
 263
 264    while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {
 265       /* Remember previous stream type */
 266       rctx.prev_stream = rctx.stream;
 267
 268       /* First we expect a Stream Record Header */
 269       if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,
 270           &rctx.stream, &rctx.size) != 5) {
 271          Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s\n"), sd->msg);
 272          goto bail_out;
 273       }
 274       Dmsg5(50, "Got hdr: Files=%d FilInx=%d size=%d Stream=%d, %s.\n",
 275             jcr->JobFiles, file_index, rctx.size, rctx.stream, stream_to_ascii(rctx.stream));
 276
 277       /* * Now we expect the Stream Data */
 278       if (bget_msg(sd) < 0) {
 279          Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s\n"), sd->bstrerror());
 280          goto bail_out;
 281       }
 282       if (rctx.size != (uint32_t)sd->msglen) {
 283          Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d\n"),
 284                sd->msglen, rctx.size);
 285          Dmsg2(50, "Actual data size %d not same as header %d\n",
 286                sd->msglen, rctx.size);
 287          goto bail_out;
 288       }
 289       Dmsg3(130, "Got stream: %s len=%d extract=%d\n", stream_to_ascii(rctx.stream),
 290             sd->msglen, rctx.extract);
 291
 292       /* If we change streams, close and reset alternate data streams */
 293       if (rctx.prev_stream != rctx.stream) {
 294          if (is_bopen(&rctx.forkbfd)) {
 295             deallocate_fork_cipher(rctx);
 296             bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 297          }
 298          rctx.fork_size = -1; /* Use an impossible value and set a proper one below */
 299          rctx.fork_addr = 0;
 300       }
 301
 302       /* File Attributes stream */
 303       switch (rctx.stream) {
 304       case STREAM_UNIX_ATTRIBUTES:
 305       case STREAM_UNIX_ATTRIBUTES_EX:
 306          close_previous_stream(rctx);     /* if any previous stream open, close it */
 307
 308
 309          /* TODO: manage deleted files */
 310          if (rctx.type == FT_DELETED) { /* deleted file */
 311             continue;
 312          }
 313
 314          /*
 315           * Unpack attributes and do sanity check them
 316           */
 317          if (!unpack_attributes_record(jcr, rctx.stream, sd->msg, attr)) {
 318             goto bail_out;
 319          }
 320 #ifdef xxx
 321          if (file_index != attr->file_index) {
 322             Jmsg(jcr, M_FATAL, 0, _("Record header file index %ld not equal record index %ld\n"),
 323                  file_index, attr->file_index);
 324             Dmsg0(200, "File index error\n");
 325             goto bail_out;
 326          }
 327 #endif
 328
 329          Dmsg3(200, "File %s\nattrib=%s\nattribsEx=%s\n", attr->fname,
 330                attr->attr, attr->attrEx);
 331
 332          attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
 333
 334          if (!is_restore_stream_supported(attr->data_stream)) {
 335             if (!non_support_data++) {
 336                Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
 337                   stream_to_ascii(attr->data_stream));
 338             }
 339             continue;
 340          }
 341
 342          build_attr_output_fnames(jcr, attr);
 343
 344          /*
 345           * Try to actually create the file, which returns a status telling
 346           *  us if we need to extract or not.
 347           */
 348          jcr->num_files_examined++;
 349          rctx.extract = false;
 350          if (jcr->plugin) {
 351             stat = plugin_create_file(jcr, attr, &rctx.bfd, jcr->replace);
 352          } else {
 353             stat = create_file(jcr, attr, &rctx.bfd, jcr->replace);
 354          }
 355          jcr->lock();
 356          pm_strcpy(jcr->last_fname, attr->ofname);
 357          jcr->last_type = attr->type;
 358          jcr->unlock();
 359          Dmsg2(130, "Outfile=%s create_file stat=%d\n", attr->ofname, stat);
 360          switch (stat) {
 361          case CF_ERROR:
 362          case CF_SKIP:
 363             pm_strcpy(jcr->last_fname, attr->ofname);
 364             jcr->last_type = attr->type;
 365             break;
 366          case CF_EXTRACT:        /* File created and we expect file data */
 367             rctx.extract = true;
 368             /* FALLTHROUGH */
 369          case CF_CREATED:        /* File created, but there is no content */
 370             jcr->JobFiles++;
 371             rctx.fileAddr = 0;
 372             print_ls_output(jcr, attr);
 373
 374             if (have_darwin_os) {
 375                /* Only restore the resource fork for regular files */
 376                from_base64(&rsrc_len, attr->attrEx);
 377                if (attr->type == FT_REG && rsrc_len > 0) {
 378                   rctx.extract = true;
 379                }
 380             }
 381             if (!rctx.extract) {
 382                /* set attributes now because file will not be extracted */
 383                if (jcr->plugin) {
 384                   plugin_set_attributes(jcr, attr, &rctx.bfd);
 385                } else {
 386                   set_attributes(jcr, attr, &rctx.bfd);
 387                }
 388             }
 389             break;
 390          }
 391          break;
 392
 393       /* Data stream */
 394       case STREAM_ENCRYPTED_SESSION_DATA:
 395          crypto_error_t cryptoerr;
 396
 397          /* Is this an unexpected session data entry? */
 398          if (rctx.cs) {
 399             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic session data stream.\n"));
 400             rctx.extract = false;
 401             bclose(&rctx.bfd);
 402             continue;
 403          }
 404
 405          /* Do we have any keys at all? */
 406          if (!jcr->crypto.pki_recipients) {
 407             Jmsg(jcr, M_ERROR, 0, _("No private decryption keys have been defined to decrypt encrypted backup data.\n"));
 408             rctx.extract = false;
 409             bclose(&rctx.bfd);
 410             break;
 411          }
 412
 413          if (jcr->crypto.digest) {
 414             crypto_digest_free(jcr->crypto.digest);
 415          }
 416          jcr->crypto.digest = crypto_digest_new(jcr, signing_algorithm);
 417          if (!jcr->crypto.digest) {
 418             Jmsg0(jcr, M_FATAL, 0, _("Could not create digest.\n"));
 419             rctx.extract = false;
 420             bclose(&rctx.bfd);
 421             break;
 422          }
 423
 424          /* Decode and save session keys. */
 425          cryptoerr = crypto_session_decode((uint8_t *)sd->msg, (uint32_t)sd->msglen,
 426                         jcr->crypto.pki_recipients, &rctx.cs);
 427          switch(cryptoerr) {
 428          case CRYPTO_ERROR_NONE:
 429             /* Success */
 430             break;
 431          case CRYPTO_ERROR_NORECIPIENT:
 432             Jmsg(jcr, M_ERROR, 0, _("Missing private key required to decrypt encrypted backup data.\n"));
 433             break;
 434          case CRYPTO_ERROR_DECRYPTION:
 435             Jmsg(jcr, M_ERROR, 0, _("Decrypt of the session key failed.\n"));
 436             break;
 437          default:
 438             /* Shouldn't happen */
 439             Jmsg1(jcr, M_ERROR, 0, _("An error occurred while decoding encrypted session data stream: %s\n"), crypto_strerror(cryptoerr));
 440             break;
 441          }
 442
 443          if (cryptoerr != CRYPTO_ERROR_NONE) {
 444             rctx.extract = false;
 445             bclose(&rctx.bfd);
 446             continue;
 447          }
 448
 449          break;
 450
 451       case STREAM_FILE_DATA:
 452       case STREAM_SPARSE_DATA:
 453       case STREAM_WIN32_DATA:
 454       case STREAM_GZIP_DATA:
 455       case STREAM_SPARSE_GZIP_DATA:
 456       case STREAM_WIN32_GZIP_DATA:
 457       case STREAM_ENCRYPTED_FILE_DATA:
 458       case STREAM_ENCRYPTED_WIN32_DATA:
 459       case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 460       case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 461          /* Force an expected, consistent stream type here */
 462          if (rctx.extract && (rctx.prev_stream == rctx.stream
 463                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES
 464                          || rctx.prev_stream == STREAM_UNIX_ATTRIBUTES_EX
 465                          || rctx.prev_stream == STREAM_ENCRYPTED_SESSION_DATA)) {
 466             rctx.flags = 0;
 467
 468             if (rctx.stream == STREAM_SPARSE_DATA ||
 469                 rctx.stream == STREAM_SPARSE_GZIP_DATA) {
 470                rctx.flags |= FO_SPARSE;
 471             }
 472
 473             if (rctx.stream == STREAM_GZIP_DATA
 474                   || rctx.stream == STREAM_SPARSE_GZIP_DATA
 475                   || rctx.stream == STREAM_WIN32_GZIP_DATA
 476                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 477                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 478                rctx.flags |= FO_GZIP;
 479             }
 480
 481             if (rctx.stream == STREAM_ENCRYPTED_FILE_DATA
 482                   || rctx.stream == STREAM_ENCRYPTED_FILE_GZIP_DATA
 483                   || rctx.stream == STREAM_ENCRYPTED_WIN32_DATA
 484                   || rctx.stream == STREAM_ENCRYPTED_WIN32_GZIP_DATA) {
 485                /* Set up a decryption context */
 486                if (!rctx.cipher_ctx.cipher) {
 487                   if (!rctx.cs) {
 488                      Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 489                      rctx.extract = false;
 490                      bclose(&rctx.bfd);
 491                      continue;
 492                   }
 493
 494                   if ((rctx.cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false,
 495                            &rctx.cipher_ctx.block_size)) == NULL) {
 496                      Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 497                      free_session(rctx);
 498                      rctx.extract = false;
 499                      bclose(&rctx.bfd);
 500                      continue;
 501                   }
 502                }
 503                rctx.flags |= FO_ENCRYPT;
 504             }
 505
 506             if (is_win32_stream(rctx.stream) && !have_win32_api()) {
 507                set_portable_backup(&rctx.bfd);
 508                rctx.flags |= FO_WIN32DECOMP;    /* "decompose" BackupWrite data */
 509             }
 510
 511             if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fileAddr,
 512                              rctx.flags, &rctx.cipher_ctx) < 0) {
 513                bclose(&rctx.bfd);
 514                continue;
 515             }
 516          }
 517          break;
 518
 519       /* Resource fork stream - only recorded after a file to be restored */
 520       /* Silently ignore if we cannot write - we already reported that */
 521       case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 522       case STREAM_MACOS_FORK_DATA:
 523 #ifdef HAVE_DARWIN_OS
 524          rctx.fork_flags = 0;
 525          jcr->ff->flags |= FO_HFSPLUS;
 526
 527          if (rctx.stream == STREAM_ENCRYPTED_MACOS_FORK_DATA) {
 528             rctx.fork_flags |= FO_ENCRYPT;
 529
 530             /* Set up a decryption context */
 531             if (rctx.extract && !rctx.fork_cipher_ctx.cipher) {
 532                if (!rctx.cs) {
 533                   Jmsg1(jcr, M_ERROR, 0, _("Missing encryption session data stream for %s\n"), jcr->last_fname);
 534                   rctx.extract = false;
 535                   bclose(&rctx.bfd);
 536                   continue;
 537                }
 538
 539                if ((rctx.fork_cipher_ctx.cipher = crypto_cipher_new(rctx.cs, false, &rctx.fork_cipher_ctx.block_size)) == NULL) {
 540                   Jmsg1(jcr, M_ERROR, 0, _("Failed to initialize decryption context for %s\n"), jcr->last_fname);
 541                   free_session(rctx);
 542                   rctx.extract = false;
 543                   bclose(&rctx.bfd);
 544                   continue;
 545                }
 546             }
 547          }
 548
 549          if (rctx.extract) {
 550             if (rctx.prev_stream != rctx.stream) {
 551                if (bopen_rsrc(&rctx.forkbfd, jcr->last_fname, O_WRONLY | O_TRUNC | O_BINARY, 0) < 0) {
 552                   Jmsg(jcr, M_ERROR, 0, _("     Cannot open resource fork for %s.\n"), jcr->last_fname);
 553                   rctx.extract = false;
 554                   continue;
 555                }
 556
 557                rctx.fork_size = rsrc_len;
 558                Dmsg0(130, "Restoring resource fork\n");
 559             }
 560
 561             if (extract_data(jcr, rctx, sd->msg, sd->msglen, &rctx.fork_addr, rctx.fork_flags,
 562                              &rctx.fork_cipher_ctx) < 0) {
 563                bclose(&rctx.forkbfd);
 564                continue;
 565             }
 566          }
 567 #else
 568          non_support_rsrc++;
 569 #endif
 570          break;
 571
 572       case STREAM_HFSPLUS_ATTRIBUTES:
 573 #ifdef HAVE_DARWIN_OS
 574          Dmsg0(130, "Restoring Finder Info\n");
 575          jcr->ff->flags |= FO_HFSPLUS;
 576          if (sd->msglen != 32) {
 577             Jmsg(jcr, M_ERROR, 0, _("     Invalid length of Finder Info (got %d, not 32)\n"), sd->msglen);
 578             continue;
 579          }
 580          if (setattrlist(jcr->last_fname, &attrList, sd->msg, sd->msglen, 0) != 0) {
 581             Jmsg(jcr, M_ERROR, 0, _("     Could not set Finder Info on %s\n"), jcr->last_fname);
 582             continue;
 583          }
 584 #else
 585          non_support_finfo++;
 586 #endif
 587          break;
 588
 589       case STREAM_UNIX_ACCESS_ACL:
 590       case STREAM_UNIX_DEFAULT_ACL:
 591       case STREAM_ACL_AIX_TEXT:
 592       case STREAM_ACL_DARWIN_ACCESS_ACL:
 593       case STREAM_ACL_FREEBSD_DEFAULT_ACL:
 594       case STREAM_ACL_FREEBSD_ACCESS_ACL:
 595       case STREAM_ACL_HPUX_ACL_ENTRY:
 596       case STREAM_ACL_IRIX_DEFAULT_ACL:
 597       case STREAM_ACL_IRIX_ACCESS_ACL:
 598       case STREAM_ACL_LINUX_DEFAULT_ACL:
 599       case STREAM_ACL_LINUX_ACCESS_ACL:
 600       case STREAM_ACL_TRU64_DEFAULT_ACL:
 601       case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
 602       case STREAM_ACL_TRU64_ACCESS_ACL:
 603       case STREAM_ACL_SOLARIS_ACLENT:
 604       case STREAM_ACL_SOLARIS_ACE:
 605          /*
 606           * Do not restore ACLs when
 607           * a) The current file is not extracted
 608           * b)     and it is not a directory (they are never "extracted")
 609           * c) or the file name is empty
 610           */
 611          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 612             break;
 613          }
 614          if (have_acl) {
 615             pm_memcpy(jcr->acl_data->content, sd->msg, sd->msglen);
 616             jcr->acl_data->content_length = sd->msglen;
 617             switch (parse_acl_streams(jcr, rctx.stream)) {
 618             case bacl_exit_fatal:
 619                goto bail_out;
 620             case bacl_exit_error:
 621                /*
 622                 * Non-fatal errors, count them and when the number is under ACL_REPORT_ERR_MAX_PER_JOB
 623                 * print the error message set by the lower level routine in jcr->errmsg.
 624                 */
 625                if (jcr->acl_data->nr_errors < ACL_REPORT_ERR_MAX_PER_JOB) {
 626                   Qmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 627                }
 628                jcr->acl_data->nr_errors++;
 629                break;
 630             case bacl_exit_ok:
 631                break;
 632             }
 633          } else {
 634             non_support_acl++;
 635          }
 636          break;
 637
 638       case STREAM_XATTR_SOLARIS_SYS:
 639       case STREAM_XATTR_SOLARIS:
 640       case STREAM_XATTR_DARWIN:
 641       case STREAM_XATTR_FREEBSD:
 642       case STREAM_XATTR_LINUX:
 643       case STREAM_XATTR_NETBSD:
 644          /*
 645           * Do not restore Extended Attributes when
 646           * a) The current file is not extracted
 647           * b)     and it is not a directory (they are never "extracted")
 648           * c) or the file name is empty
 649           */
 650          if ((!rctx.extract && jcr->last_type != FT_DIREND) || (*jcr->last_fname == 0)) {
 651             break;
 652          }
 653          if (have_xattr) {
 654             pm_memcpy(jcr->xattr_data->content, sd->msg, sd->msglen);
 655             jcr->xattr_data->content_length = sd->msglen;
 656             switch (parse_xattr_streams(jcr, rctx.stream)) {
 657             case bxattr_exit_fatal:
 658                goto bail_out;
 659             case bxattr_exit_error:
 660                /*
 661                 * Non-fatal errors, count them and when the number is under XATTR_REPORT_ERR_MAX_PER_JOB
 662                 * print the error message set by the lower level routine in jcr->errmsg.
 663                 */
 664                if (jcr->xattr_data->nr_errors < XATTR_REPORT_ERR_MAX_PER_JOB) {
 665                   Qmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg);
 666                }
 667                jcr->xattr_data->nr_errors++;
 668                break;
 669             case bxattr_exit_ok:
 670                break;
 671             }
 672          } else {
 673             non_support_xattr++;
 674          }
 675          break;
 676
 677       case STREAM_SIGNED_DIGEST:
 678          /* Is this an unexpected signature? */
 679          if (rctx.sig) {
 680             Jmsg0(jcr, M_ERROR, 0, _("Unexpected cryptographic signature data stream.\n"));
 681             free_signature(rctx);
 682             continue;
 683          }
 684          /* Save signature. */
 685          if (rctx.extract && (rctx.sig = crypto_sign_decode(jcr, (uint8_t *)sd->msg, (uint32_t)sd->msglen)) == NULL) {
 686             Jmsg1(jcr, M_ERROR, 0, _("Failed to decode message signature for %s\n"), jcr->last_fname);
 687          }
 688          break;
 689
 690       case STREAM_MD5_DIGEST:
 691       case STREAM_SHA1_DIGEST:
 692       case STREAM_SHA256_DIGEST:
 693       case STREAM_SHA512_DIGEST:
 694          break;
 695
 696       case STREAM_PROGRAM_NAMES:
 697       case STREAM_PROGRAM_DATA:
 698          if (!non_support_progname) {
 699             Pmsg0(000, "Got Program Name or Data Stream. Ignored.\n");
 700             non_support_progname++;
 701          }
 702          break;
 703
 704       case STREAM_PLUGIN_NAME:
 705          close_previous_stream(rctx);
 706          Dmsg1(50, "restore stream_plugin_name=%s\n", sd->msg);
 707          plugin_name_stream(jcr, sd->msg);
 708          break;
 709
 710       default:
 711          close_previous_stream(rctx);
 712          Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
 713               rctx.stream);
 714          Dmsg2(0, "Unknown stream=%d data=%s\n", rctx.stream, sd->msg);
 715          break;
 716       } /* end switch(stream) */
 717
 718    } /* end while get_msg() */
 719
 720    /*
 721     * If output file is still open, it was the last one in the
 722     * archive since we just hit an end of file, so close the file.
 723     */
 724    if (is_bopen(&rctx.forkbfd)) {
 725       bclose_chksize(jcr, &rctx.forkbfd, rctx.fork_size);
 726    }
 727
 728    close_previous_stream(rctx);
 729    set_jcr_job_status(jcr, JS_Terminated);
 730    goto ok_out;
 731
 732 bail_out:
 733    set_jcr_job_status(jcr, JS_ErrorTerminated);
 734
 735 ok_out:
 736    /* Free Signature & Crypto Data */
 737    free_signature(rctx);
 738    free_session(rctx);
 739    if (jcr->crypto.digest) {
 740       crypto_digest_free(jcr->crypto.digest);
 741       jcr->crypto.digest = NULL;
 742    }
 743
 744    /* Free file cipher restore context */
 745    if (rctx.cipher_ctx.cipher) {
 746       crypto_cipher_free(rctx.cipher_ctx.cipher);
 747       rctx.cipher_ctx.cipher = NULL;
 748    }
 749    if (rctx.cipher_ctx.buf) {
 750       free_pool_memory(rctx.cipher_ctx.buf);
 751       rctx.cipher_ctx.buf = NULL;
 752    }
 753
 754    /* Free alternate stream cipher restore context */
 755    if (rctx.fork_cipher_ctx.cipher) {
 756       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
 757       rctx.fork_cipher_ctx.cipher = NULL;
 758    }
 759    if (rctx.fork_cipher_ctx.buf) {
 760       free_pool_memory(rctx.fork_cipher_ctx.buf);
 761       rctx.fork_cipher_ctx.buf = NULL;
 762    }
 763
 764    if (jcr->compress_buf) {
 765       free(jcr->compress_buf);
 766       jcr->compress_buf = NULL;
 767       jcr->compress_buf_size = 0;
 768    }
 769
 770    if (have_xattr && jcr->xattr_data) {
 771       free_pool_memory(jcr->xattr_data->content);
 772       free(jcr->xattr_data);
 773       jcr->xattr_data = NULL;
 774    }
 775    if (have_acl && jcr->acl_data) {
 776       free_pool_memory(jcr->acl_data->content);
 777       free(jcr->acl_data);
 778       jcr->acl_data = NULL;
 779    }
 780
 781    bclose(&rctx.forkbfd);
 782    bclose(&rctx.bfd);
 783    free_attr(rctx.attr);
 784    Dmsg2(10, "End Do Restore. Files=%d Bytes=%s\n", jcr->JobFiles,
 785       edit_uint64(jcr->JobBytes, ec1));
 786    if (jcr->acl_data->nr_errors > 0) {
 787       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld acl errors while doing restore\n"),
 788            jcr->acl_data->nr_errors);
 789    }
 790    if (jcr->xattr_data->nr_errors > 0) {
 791       Jmsg(jcr, M_ERROR, 0, _("Encountered %ld xattr errors while doing restore\n"),
 792            jcr->xattr_data->nr_errors);
 793    }
 794    if (non_support_data > 1 || non_support_attr > 1) {
 795       Jmsg(jcr, M_ERROR, 0, _("%d non-supported data streams and %d non-supported attrib streams ignored.\n"),
 796          non_support_data, non_support_attr);
 797    }
 798    if (non_support_rsrc) {
 799       Jmsg(jcr, M_INFO, 0, _("%d non-supported resource fork streams ignored.\n"), non_support_rsrc);
 800    }
 801    if (non_support_finfo) {
 802       Jmsg(jcr, M_INFO, 0, _("%d non-supported Finder Info streams ignored.\n"), non_support_rsrc);
 803    }
 804    if (non_support_acl) {
 805       Jmsg(jcr, M_INFO, 0, _("%d non-supported acl streams ignored.\n"), non_support_acl);
 806    }
 807    if (non_support_crypto) {
 808       Jmsg(jcr, M_INFO, 0, _("%d non-supported crypto streams ignored.\n"), non_support_acl);
 809    }
 810    if (non_support_xattr) {
 811       Jmsg(jcr, M_INFO, 0, _("%d non-supported xattr streams ignored.\n"), non_support_xattr);
 812    }
 813
 814 }
 815
 816 #ifdef HAVE_LIBZ
 817 /*
 818  * Convert ZLIB error code into an ASCII message
 819  */
 820 static const char *zlib_strerror(int stat)
 821 {
 822    if (stat >= 0) {
 823       return _("None");
 824    }
 825    switch (stat) {
 826    case Z_ERRNO:
 827       return _("Zlib errno");
 828    case Z_STREAM_ERROR:
 829       return _("Zlib stream error");
 830    case Z_DATA_ERROR:
 831       return _("Zlib data error");
 832    case Z_MEM_ERROR:
 833       return _("Zlib memory error");
 834    case Z_BUF_ERROR:
 835       return _("Zlib buffer error");
 836    case Z_VERSION_ERROR:
 837       return _("Zlib version error");
 838    default:
 839       return _("*none*");
 840    }
 841 }
 842 #endif
 843
 844 static int do_file_digest(JCR *jcr, FF_PKT *ff_pkt, bool top_level)
 845 {
 846    Dmsg1(50, "do_file_digest jcr=%p\n", jcr);
 847    return (digest_file(jcr, ff_pkt, jcr->crypto.digest));
 848 }
 849
 850 /*
 851  * Verify the signature for the last restored file
 852  * Return value is either true (signature correct)
 853  * or false (signature could not be verified).
 854  * TODO landonf: Implement without using find_one_file and
 855  * without re-reading the file.
 856  */
 857 static bool verify_signature(JCR *jcr, r_ctx &rctx)
 858 {
 859    X509_KEYPAIR *keypair;
 860    DIGEST *digest = NULL;
 861    crypto_error_t err;
 862    uint64_t saved_bytes;
 863    crypto_digest_t signing_algorithm = have_sha2 ?
 864                                        CRYPTO_DIGEST_SHA256 : CRYPTO_DIGEST_SHA1;
 865    crypto_digest_t algorithm;
 866    SIGNATURE *sig = rctx.sig;
 867
 868
 869    if (!jcr->crypto.pki_sign) {
 870       return true;                    /* no signature OK */
 871    }
 872    if (!sig) {
 873       if (rctx.type == FT_REGE || rctx.type == FT_REG || rctx.type == FT_RAW) {
 874          Jmsg1(jcr, M_ERROR, 0, _("Missing cryptographic signature for %s\n"),
 875                jcr->last_fname);
 876          goto bail_out;
 877       }
 878       return true;
 879    }
 880
 881    /* Iterate through the trusted signers */
 882    foreach_alist(keypair, jcr->crypto.pki_signers) {
 883       err = crypto_sign_get_digest(sig, jcr->crypto.pki_keypair, algorithm, &digest);
 884       switch (err) {
 885       case CRYPTO_ERROR_NONE:
 886          Dmsg0(50, "== Got digest\n");
 887          /*
 888           * We computed jcr->crypto.digest using signing_algorithm while writing
 889           * the file. If it is not the same as the algorithm used for
 890           * this file, punt by releasing the computed algorithm and
 891           * computing by re-reading the file.
 892           */
 893          if (algorithm != signing_algorithm) {
 894             if (jcr->crypto.digest) {
 895                crypto_digest_free(jcr->crypto.digest);
 896                jcr->crypto.digest = NULL;
 897             }
 898          }
 899          if (jcr->crypto.digest) {
 900              /* Use digest computed while writing the file to verify the signature */
 901             if ((err = crypto_sign_verify(sig, keypair, jcr->crypto.digest)) != CRYPTO_ERROR_NONE) {
 902                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 903                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 904                      jcr->last_fname, crypto_strerror(err));
 905                goto bail_out;
 906             }
 907          } else {
 908             /* Signature found, digest allocated.  Old method,
 909              * re-read the file and compute the digest
 910              */
 911             jcr->crypto.digest = digest;
 912
 913             /* Checksum the entire file */
 914             /* Make sure we don't modify JobBytes by saving and restoring it */
 915             saved_bytes = jcr->JobBytes;
 916             if (find_one_file(jcr, jcr->ff, do_file_digest, jcr->last_fname, (dev_t)-1, 1) != 0) {
 917                Jmsg(jcr, M_ERROR, 0, _("Digest one file failed for file: %s\n"),
 918                     jcr->last_fname);
 919                jcr->JobBytes = saved_bytes;
 920                goto bail_out;
 921             }
 922             jcr->JobBytes = saved_bytes;
 923
 924             /* Verify the signature */
 925             if ((err = crypto_sign_verify(sig, keypair, digest)) != CRYPTO_ERROR_NONE) {
 926                Dmsg1(50, "Bad signature on %s\n", jcr->last_fname);
 927                Jmsg2(jcr, M_ERROR, 0, _("Signature validation failed for file %s: ERR=%s\n"),
 928                      jcr->last_fname, crypto_strerror(err));
 929                goto bail_out;
 930             }
 931             jcr->crypto.digest = NULL;
 932          }
 933
 934          /* Valid signature */
 935          Dmsg1(50, "Signature good on %s\n", jcr->last_fname);
 936          crypto_digest_free(digest);
 937          return true;
 938
 939       case CRYPTO_ERROR_NOSIGNER:
 940          /* Signature not found, try again */
 941          if (digest) {
 942             crypto_digest_free(digest);
 943             digest = NULL;
 944          }
 945          continue;
 946       default:
 947          /* Something strange happened (that shouldn't happen!)... */
 948          Qmsg2(jcr, M_ERROR, 0, _("Signature validation failed for %s: %s\n"), jcr->last_fname, crypto_strerror(err));
 949          goto bail_out;
 950       }
 951    }
 952
 953    /* No signer */
 954    Dmsg1(50, "Could not find a valid public key for signature on %s\n", jcr->last_fname);
 955
 956 bail_out:
 957    if (digest) {
 958       crypto_digest_free(digest);
 959    }
 960    return false;
 961 }
 962
 963 bool sparse_data(JCR *jcr, BFILE *bfd, uint64_t *addr, char **data, uint32_t *length)
 964 {
 965       unser_declare;
 966       uint64_t faddr;
 967       char ec1[50];
 968       unser_begin(*data, SPARSE_FADDR_SIZE);
 969       unser_uint64(faddr);
 970       if (*addr != faddr) {
 971          *addr = faddr;
 972          if (blseek(bfd, (boffset_t)*addr, SEEK_SET) < 0) {
 973             berrno be;
 974             Jmsg3(jcr, M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
 975                   edit_uint64(*addr, ec1), jcr->last_fname,
 976                   be.bstrerror(bfd->berrno));
 977             return false;
 978          }
 979       }
 980       *data += SPARSE_FADDR_SIZE;
 981       *length -= SPARSE_FADDR_SIZE;
 982       return true;
 983 }
 984
 985 bool decompress_data(JCR *jcr, char **data, uint32_t *length)
 986 {
 987 #ifdef HAVE_LIBZ
 988    uLong compress_len;
 989    int stat;
 990    char ec1[50];                      /* Buffer printing huge values */
 991
 992    /*
 993     * NOTE! We only use uLong and Byte because they are
 994     *  needed by the zlib routines, they should not otherwise
 995     *  be used in Bacula.
 996     */
 997    compress_len = jcr->compress_buf_size;
 998    Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, *length);
 999    if ((stat=uncompress((Byte *)jcr->compress_buf, &compress_len,
1000                (const Byte *)*data, (uLong)*length)) != Z_OK) {
1001       Qmsg(jcr, M_ERROR, 0, _("Uncompression error on file %s. ERR=%s\n"),
1002             jcr->last_fname, zlib_strerror(stat));
1003       return false;
1004    }
1005    *data = jcr->compress_buf;
1006    *length = compress_len;
1007    Dmsg2(200, "Write uncompressed %d bytes, total before write=%s\n", compress_len, edit_uint64(jcr->JobBytes, ec1));
1008    return true;
1009 #else
1010    Qmsg(jcr, M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
1011    return false;
1012 #endif
1013 }
1014
1015 static void unser_crypto_packet_len(RESTORE_CIPHER_CTX *ctx)
1016 {
1017    unser_declare;
1018    if (ctx->packet_len == 0 && ctx->buf_len >= CRYPTO_LEN_SIZE) {
1019       unser_begin(&ctx->buf[0], CRYPTO_LEN_SIZE);
1020       unser_uint32(ctx->packet_len);
1021       ctx->packet_len += CRYPTO_LEN_SIZE;
1022    }
1023 }
1024
1025 bool store_data(JCR *jcr, BFILE *bfd, char *data, const int32_t length, bool win32_decomp)
1026 {
1027    if (jcr->crypto.digest) {
1028       crypto_digest_update(jcr->crypto.digest, (uint8_t *)data, length);
1029    }
1030    if (win32_decomp) {
1031       if (!processWin32BackupAPIBlock(bfd, data, length)) {
1032          berrno be;
1033          Jmsg2(jcr, M_ERROR, 0, _("Write error in Win32 Block Decomposition on %s: %s\n"),
1034                jcr->last_fname, be.bstrerror(bfd->berrno));
1035          return false;
1036       }
1037    } else if (bwrite(bfd, data, length) != (ssize_t)length) {
1038       berrno be;
1039       Jmsg2(jcr, M_ERROR, 0, _("Write error on %s: %s\n"),
1040             jcr->last_fname, be.bstrerror(bfd->berrno));
1041       return false;
1042    }
1043
1044    return true;
1045 }
1046
1047 /*
1048  * In the context of jcr, write data to bfd.
1049  * We write buflen bytes in buf at addr. addr is updated in place.
1050  * The flags specify whether to use sparse files or compression.
1051  * Return value is the number of bytes written, or -1 on errors.
1052  */
1053 int32_t extract_data(JCR *jcr, r_ctx &rctx, POOLMEM *buf, int32_t buflen,
1054       uint64_t *addr, int flags, RESTORE_CIPHER_CTX *cipher_ctx)
1055 {
1056    BFILE *bfd = &rctx.bfd;
1057    char *wbuf;                        /* write buffer */
1058    uint32_t wsize;                    /* write size */
1059    uint32_t rsize;                    /* read size */
1060    uint32_t decrypted_len = 0;        /* Decryption output length */
1061    char ec1[50];                      /* Buffer printing huge values */
1062
1063    rsize = buflen;
1064    jcr->ReadBytes += rsize;
1065    wsize = rsize;
1066    wbuf = buf;
1067
1068    if (flags & FO_ENCRYPT) {
1069       ASSERT(cipher_ctx->cipher);
1070
1071       /* NOTE: We must implement block preserving semantics for the
1072        * non-streaming compression and sparse code. */
1073
1074       /*
1075        * Grow the crypto buffer, if necessary.
1076        * crypto_cipher_update() will process only whole blocks,
1077        * buffering the remaining input.
1078        */
1079       cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf,
1080                         cipher_ctx->buf_len + wsize + cipher_ctx->block_size);
1081
1082       /* Decrypt the input block */
1083       if (!crypto_cipher_update(cipher_ctx->cipher,
1084                                 (const u_int8_t *)wbuf,
1085                                 wsize,
1086                                 (u_int8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1087                                 &decrypted_len)) {
1088          /* Decryption failed. Shouldn't happen. */
1089          Jmsg(jcr, M_FATAL, 0, _("Decryption error\n"));
1090          goto bail_out;
1091       }
1092
1093       if (decrypted_len == 0) {
1094          /* No full block of encrypted data available, write more data */
1095          return 0;
1096       }
1097
1098       Dmsg2(200, "decrypted len=%d encrypted len=%d\n", decrypted_len, wsize);
1099
1100       cipher_ctx->buf_len += decrypted_len;
1101       wbuf = cipher_ctx->buf;
1102
1103       /* If one full preserved block is available, write it to disk,
1104        * and then buffer any remaining data. This should be effecient
1105        * as long as Bacula's block size is not significantly smaller than the
1106        * encryption block size (extremely unlikely!) */
1107       unser_crypto_packet_len(cipher_ctx);
1108       Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1109
1110       if (cipher_ctx->packet_len == 0 || cipher_ctx->buf_len < cipher_ctx->packet_len) {
1111          /* No full preserved block is available. */
1112          return 0;
1113       }
1114
1115       /* We have one full block, set up the filter input buffers */
1116       wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1117       wbuf = &wbuf[CRYPTO_LEN_SIZE]; /* Skip the block length header */
1118       cipher_ctx->buf_len -= cipher_ctx->packet_len;
1119       Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1120    }
1121
1122    if (flags & FO_SPARSE) {
1123       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1124          goto bail_out;
1125       }
1126    }
1127
1128    if (flags & FO_GZIP) {
1129       if (!decompress_data(jcr, &wbuf, &wsize)) {
1130          goto bail_out;
1131       }
1132    }
1133
1134    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1135       goto bail_out;
1136    }
1137    jcr->JobBytes += wsize;
1138    *addr += wsize;
1139    Dmsg2(130, "Write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1140
1141    /* Clean up crypto buffers */
1142    if (flags & FO_ENCRYPT) {
1143       /* Move any remaining data to start of buffer */
1144       if (cipher_ctx->buf_len > 0) {
1145          Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1146          memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1147             cipher_ctx->buf_len);
1148       }
1149       /* The packet was successfully written, reset the length so that the next
1150        * packet length may be re-read by unser_crypto_packet_len() */
1151       cipher_ctx->packet_len = 0;
1152    }
1153    return wsize;
1154
1155 bail_out:
1156    rctx.extract = false;
1157    return -1;
1158
1159 }
1160
1161
1162 /*
1163  * If extracting, close any previous stream
1164  */
1165 static void close_previous_stream(r_ctx &rctx)
1166 {
1167    /*
1168     * If extracting, it was from previous stream, so
1169     * close the output file and validate the signature.
1170     */
1171    if (rctx.extract) {
1172       if (rctx.size > 0 && !is_bopen(&rctx.bfd)) {
1173          Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should be open\n"));
1174          Dmsg2(000, "=== logic error size=%d bopen=%d\n", rctx.size,
1175             is_bopen(&rctx.bfd));
1176       }
1177
1178       if (rctx.prev_stream != STREAM_ENCRYPTED_SESSION_DATA) {
1179          deallocate_cipher(rctx);
1180          deallocate_fork_cipher(rctx);
1181       }
1182
1183       if (rctx.jcr->plugin) {
1184          plugin_set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1185       } else {
1186          set_attributes(rctx.jcr, rctx.attr, &rctx.bfd);
1187       }
1188       rctx.extract = false;
1189
1190       /* Verify the cryptographic signature, if any */
1191       rctx.type = rctx.attr->type;
1192       verify_signature(rctx.jcr, rctx);
1193
1194       /* Free Signature */
1195       free_signature(rctx);
1196       free_session(rctx);
1197       rctx.jcr->ff->flags = 0;
1198       Dmsg0(130, "Stop extracting.\n");
1199    } else if (is_bopen(&rctx.bfd)) {
1200       Jmsg0(rctx.jcr, M_ERROR, 0, _("Logic error: output file should not be open\n"));
1201       Dmsg0(000, "=== logic error !open\n");
1202       bclose(&rctx.bfd);
1203    }
1204 }
1205
1206
1207 /*
1208  * In the context of jcr, flush any remaining data from the cipher context,
1209  * writing it to bfd.
1210  * Return value is true on success, false on failure.
1211  */
1212 bool flush_cipher(JCR *jcr, BFILE *bfd, uint64_t *addr, int flags,
1213                   RESTORE_CIPHER_CTX *cipher_ctx)
1214 {
1215    uint32_t decrypted_len = 0;
1216    char *wbuf;                        /* write buffer */
1217    uint32_t wsize;                    /* write size */
1218    char ec1[50];                      /* Buffer printing huge values */
1219    bool second_pass = false;
1220
1221 again:
1222    /* Write out the remaining block and free the cipher context */
1223    cipher_ctx->buf = check_pool_memory_size(cipher_ctx->buf, cipher_ctx->buf_len +
1224                      cipher_ctx->block_size);
1225
1226    if (!crypto_cipher_finalize(cipher_ctx->cipher, (uint8_t *)&cipher_ctx->buf[cipher_ctx->buf_len],
1227         &decrypted_len)) {
1228       /* Writing out the final, buffered block failed. Shouldn't happen. */
1229       Jmsg3(jcr, M_ERROR, 0, _("Decryption error. buf_len=%d decrypt_len=%d on file %s\n"),
1230             cipher_ctx->buf_len, decrypted_len, jcr->last_fname);
1231    }
1232
1233    Dmsg2(130, "Flush decrypt len=%d buf_len=%d\n", decrypted_len, cipher_ctx->buf_len);
1234    /* If nothing new was decrypted, and our output buffer is empty, return */
1235    if (decrypted_len == 0 && cipher_ctx->buf_len == 0) {
1236       return true;
1237    }
1238
1239    cipher_ctx->buf_len += decrypted_len;
1240
1241    unser_crypto_packet_len(cipher_ctx);
1242    Dmsg1(500, "Crypto unser block size=%d\n", cipher_ctx->packet_len - CRYPTO_LEN_SIZE);
1243    wsize = cipher_ctx->packet_len - CRYPTO_LEN_SIZE;
1244    wbuf = &cipher_ctx->buf[CRYPTO_LEN_SIZE]; /* Decrypted, possibly decompressed output here. */
1245    cipher_ctx->buf_len -= cipher_ctx->packet_len;
1246    Dmsg2(130, "Encryption writing full block, %u bytes, remaining %u bytes in buffer\n", wsize, cipher_ctx->buf_len);
1247
1248    if (flags & FO_SPARSE) {
1249       if (!sparse_data(jcr, bfd, addr, &wbuf, &wsize)) {
1250          return false;
1251       }
1252    }
1253
1254    if (flags & FO_GZIP) {
1255       if (!decompress_data(jcr, &wbuf, &wsize)) {
1256          return false;
1257       }
1258    }
1259
1260    Dmsg0(130, "Call store_data\n");
1261    if (!store_data(jcr, bfd, wbuf, wsize, (flags & FO_WIN32DECOMP) != 0)) {
1262       return false;
1263    }
1264    jcr->JobBytes += wsize;
1265    Dmsg2(130, "Flush write %u bytes, JobBytes=%s\n", wsize, edit_uint64(jcr->JobBytes, ec1));
1266
1267    /* Move any remaining data to start of buffer */
1268    if (cipher_ctx->buf_len > 0) {
1269       Dmsg1(130, "Moving %u buffered bytes to start of buffer\n", cipher_ctx->buf_len);
1270       memmove(cipher_ctx->buf, &cipher_ctx->buf[cipher_ctx->packet_len],
1271          cipher_ctx->buf_len);
1272    }
1273    /* The packet was successfully written, reset the length so that the next
1274     * packet length may be re-read by unser_crypto_packet_len() */
1275    cipher_ctx->packet_len = 0;
1276
1277    if (cipher_ctx->buf_len >0 && !second_pass) {
1278       second_pass = true;
1279       goto again;
1280    }
1281
1282    /* Stop decryption */
1283    cipher_ctx->buf_len = 0;
1284    cipher_ctx->packet_len = 0;
1285
1286    return true;
1287 }
1288
1289 static void deallocate_cipher(r_ctx &rctx)
1290 {
1291    /* Flush and deallocate previous stream's cipher context */
1292    if (rctx.cipher_ctx.cipher) {
1293       flush_cipher(rctx.jcr, &rctx.bfd, &rctx.fileAddr, rctx.flags, &rctx.cipher_ctx);
1294       crypto_cipher_free(rctx.cipher_ctx.cipher);
1295       rctx.cipher_ctx.cipher = NULL;
1296    }
1297 }
1298
1299 static void deallocate_fork_cipher(r_ctx &rctx)
1300 {
1301
1302    /* Flush and deallocate previous stream's fork cipher context */
1303    if (rctx.fork_cipher_ctx.cipher) {
1304       flush_cipher(rctx.jcr, &rctx.forkbfd, &rctx.fork_addr, rctx.fork_flags, &rctx.fork_cipher_ctx);
1305       crypto_cipher_free(rctx.fork_cipher_ctx.cipher);
1306       rctx.fork_cipher_ctx.cipher = NULL;
1307    }
1308 }
1309
1310 static void free_signature(r_ctx &rctx)
1311 {
1312    if (rctx.sig) {
1313       crypto_sign_free(rctx.sig);
1314       rctx.sig = NULL;
1315    }
1316 }
1317
1318 static void free_session(r_ctx &rctx)
1319 {
1320    if (rctx.cs) {
1321       crypto_session_free(rctx.cs);
1322       rctx.cs = NULL;
1323    }
1324 }
1325
1326
1327 /* This code if implemented goes above */
1328 #ifdef stbernard_implemented
1329 /  #if defined(HAVE_WIN32)
1330    bool        bResumeOfmOnExit = FALSE;
1331    if (isOpenFileManagerRunning()) {
1332        if ( pauseOpenFileManager() ) {
1333           Jmsg(jcr, M_INFO, 0, _("Open File Manager paused\n") );
1334           bResumeOfmOnExit = TRUE;
1335        }
1336        else {
1337           Jmsg(jcr, M_ERROR, 0, _("FAILED to pause Open File Manager\n") );
1338        }
1339    }
1340    {
1341        char username[UNLEN+1];
1342        DWORD usize = sizeof(username);
1343        int privs = enable_backup_privileges(NULL, 1);
1344        if (GetUserName(username, &usize)) {
1345           Jmsg2(jcr, M_INFO, 0, _("Running as '%s'. Privmask=%#08x\n"), username,
1346        } else {
1347           Jmsg(jcr, M_WARNING, 0, _("Failed to retrieve current UserName\n"));
1348        }
1349    }
1350 #endif