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