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