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

   1 /*
   2  *  Bacula File Daemon  backup.c  send file attributes and data
   3  *   to the Storage daemon.
   4  *
   5  *    Kern Sibbald, March MM
   6  *
   7  *   Version $Id$
   8  *
   9  */
  10 /*
  11    Copyright (C) 2000-2004 Kern Sibbald and John Walker
  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 as
  15    published by the Free Software Foundation; either version 2 of
  16    the License, or (at your option) any later version.
  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 GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public
  24    License along with this program; if not, write to the Free
  25    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  26    MA 02111-1307, USA.
  27
  28  */
  29
  30 #include "bacula.h"
  31 #include "filed.h"
  32
  33 #ifdef HAVE_ACL
  34 #include <sys/acl.h>
  35 #include <acl/libacl.h>
  36 #endif
  37
  38 #ifdef HAVE_DARWIN_OS
  39 #include <sys/paths.h>
  40 #endif
  41
  42 static int save_file(FF_PKT *ff_pkt, void *pkt);
  43
  44 /*
  45  * Find all the requested files and send them
  46  * to the Storage daemon.
  47  *
  48  * Note, we normally carry on a one-way
  49  * conversation from this point on with the SD, simply blasting
  50  * data to him.  To properly know what is going on, we
  51  * also run a "heartbeat" monitor which reads the socket and
  52  * reacts accordingly (at the moment it has nothing to do
  53  * except echo the heartbeat to the Director).
  54  *
  55  */
  56 bool blast_data_to_storage_daemon(JCR *jcr, char *addr)
  57 {
  58    BSOCK *sd;
  59    bool ok = true;
  60
  61    sd = jcr->store_bsock;
  62
  63    set_jcr_job_status(jcr, JS_Running);
  64
  65    Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->fd);
  66
  67    LockRes();
  68    CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
  69    UnlockRes();
  70    uint32_t buf_size;
  71    if (client) {
  72       buf_size = client->max_network_buffer_size;
  73    } else {
  74       buf_size = 0;                   /* use default */
  75    }
  76    if (!bnet_set_buffer_size(sd, buf_size, BNET_SETBUF_WRITE)) {
  77       set_jcr_job_status(jcr, JS_ErrorTerminated);
  78       Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size FD->SD.\n"));
  79       return false;
  80    }
  81
  82    jcr->buf_size = sd->msglen;
  83    /* Adjust for compression so that output buffer is
  84     * 12 bytes + 0.1% larger than input buffer plus 18 bytes.
  85     * This gives a bit extra plus room for the sparse addr if any.
  86     * Note, we adjust the read size to be smaller so that the
  87     * same output buffer can be used without growing it.
  88     */
  89    jcr->compress_buf_size = jcr->buf_size + ((jcr->buf_size+999) / 1000) + 30;
  90    jcr->compress_buf = get_memory(jcr->compress_buf_size);
  91
  92    Dmsg1(300, "set_find_options ff=%p\n", jcr->ff);
  93    set_find_options((FF_PKT *)jcr->ff, jcr->incremental, jcr->mtime);
  94    Dmsg0(300, "start find files\n");
  95
  96    start_heartbeat_monitor(jcr);
  97
  98    /* Subroutine save_file() is called for each file */
  99    if (!find_files(jcr, (FF_PKT *)jcr->ff, save_file, (void *)jcr)) {
 100       ok = false;                     /* error */
 101       set_jcr_job_status(jcr, JS_ErrorTerminated);
 102 //    Jmsg(jcr, M_FATAL, 0, _("Find files error.\n"));
 103    }
 104
 105    stop_heartbeat_monitor(jcr);
 106
 107    bnet_sig(sd, BNET_EOD);            /* end data connection */
 108
 109    if (jcr->big_buf) {
 110       free(jcr->big_buf);
 111       jcr->big_buf = NULL;
 112    }
 113    if (jcr->compress_buf) {
 114       free_pool_memory(jcr->compress_buf);
 115       jcr->compress_buf = NULL;
 116    }
 117    Dmsg1(300, "end blast_data stat=%d\n", ok);
 118    return ok;
 119 }
 120
 121 /*
 122  * Called here by find() for each file included.
 123  *
 124  *  *****FIXME*****   add FSMs File System Modules
 125  *
 126  *  Send the file and its data to the Storage daemon.
 127  *
 128  *  Returns: 1 if OK
 129  *           0 if error
 130  *          -1 to ignore file/directory (not used here)
 131  */
 132 static int save_file(FF_PKT *ff_pkt, void *vjcr)
 133 {
 134    char attribs[MAXSTRING];
 135    char attribsEx[MAXSTRING];
 136    int stat, attr_stream, data_stream;
 137    bool hfsplus = false;
 138    struct MD5Context md5c;
 139    struct SHA1Context sha1c;
 140    int gotMD5 = 0;
 141    int gotSHA1 = 0;
 142    unsigned char signature[30];       /* large enough for either signature */
 143    BSOCK *sd;
 144    JCR *jcr = (JCR *)vjcr;
 145    POOLMEM *msgsave;
 146
 147    if (job_canceled(jcr)) {
 148       return 0;
 149    }
 150
 151    sd = jcr->store_bsock;
 152    jcr->num_files_examined++;         /* bump total file count */
 153
 154    switch (ff_pkt->type) {
 155    case FT_LNKSAVED:                  /* Hard linked, file already saved */
 156       Dmsg2(130, "FT_LNKSAVED hard link: %s => %s\n", ff_pkt->fname, ff_pkt->link);
 157       break;
 158    case FT_REGE:
 159       Dmsg1(130, "FT_REGE saving: %s\n", ff_pkt->fname);
 160       break;
 161    case FT_REG:
 162       Dmsg1(130, "FT_REG saving: %s\n", ff_pkt->fname);
 163       break;
 164    case FT_LNK:
 165       Dmsg2(130, "FT_LNK saving: %s -> %s\n", ff_pkt->fname, ff_pkt->link);
 166       break;
 167    case FT_DIRBEGIN:
 168       return 1;                       /* not used */
 169    case FT_NORECURSE:
 170    case FT_NOFSCHG:
 171    case FT_INVALIDFS:
 172    case FT_DIREND:
 173       if (ff_pkt->type == FT_NORECURSE) {
 174          Jmsg(jcr, M_INFO, 1, _("     Recursion turned off. Will not descend into %s\n"),
 175             ff_pkt->fname);
 176       } else if (ff_pkt->type == FT_NOFSCHG) {
 177          Jmsg(jcr, M_INFO, 1, _("     File system change prohibited. Will not descend into %s\n"),
 178             ff_pkt->fname);
 179       } else if (ff_pkt->type == FT_INVALIDFS) {
 180          Jmsg(jcr, M_INFO, 1, _("     Disallowed filesystem. Will not descend into %s\n"),
 181             ff_pkt->fname);
 182       }
 183       ff_pkt->type = FT_DIREND;       /* value is used below */
 184       Dmsg1(130, "FT_DIR saving: %s\n", ff_pkt->link);
 185       break;
 186    case FT_SPEC:
 187       Dmsg1(130, "FT_SPEC saving: %s\n", ff_pkt->fname);
 188       break;
 189    case FT_RAW:
 190       Dmsg1(130, "FT_RAW saving: %s\n", ff_pkt->fname);
 191       break;
 192    case FT_FIFO:
 193       Dmsg1(130, "FT_FIFO saving: %s\n", ff_pkt->fname);
 194       break;
 195    case FT_NOACCESS: {
 196       berrno be;
 197       be.set_errno(ff_pkt->ff_errno);
 198       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not access %s: ERR=%s\n"), ff_pkt->fname,
 199          be.strerror());
 200       jcr->Errors++;
 201       return 1;
 202    }
 203    case FT_NOFOLLOW: {
 204       berrno be;
 205       be.set_errno(ff_pkt->ff_errno);
 206       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not follow link %s: ERR=%s\n"), ff_pkt->fname,
 207          be.strerror());
 208       jcr->Errors++;
 209       return 1;
 210    }
 211    case FT_NOSTAT: {
 212       berrno be;
 213       be.set_errno(ff_pkt->ff_errno);
 214       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not stat %s: ERR=%s\n"), ff_pkt->fname,
 215          be.strerror());
 216       jcr->Errors++;
 217       return 1;
 218    }
 219    case FT_DIRNOCHG:
 220    case FT_NOCHG:
 221       Jmsg(jcr, M_SKIPPED, 1, _("     Unchanged file skipped: %s\n"), ff_pkt->fname);
 222       return 1;
 223    case FT_ISARCH:
 224       Jmsg(jcr, M_NOTSAVED, 0, _("     Archive file not saved: %s\n"), ff_pkt->fname);
 225       return 1;
 226    case FT_NOOPEN: {
 227       berrno be;
 228       be.set_errno(ff_pkt->ff_errno);
 229       Jmsg(jcr, M_NOTSAVED, 0, _("     Could not open directory %s: ERR=%s\n"), ff_pkt->fname,
 230          be.strerror());
 231       jcr->Errors++;
 232       return 1;
 233    }
 234    default:
 235       Jmsg(jcr, M_NOTSAVED, 0,  _("     Unknown file type %d; not saved: %s\n"), ff_pkt->type, ff_pkt->fname);
 236       jcr->Errors++;
 237       return 1;
 238    }
 239
 240    binit(&ff_pkt->bfd);
 241    if (ff_pkt->flags & FO_PORTABLE) {
 242       set_portable_backup(&ff_pkt->bfd); /* disable Win32 BackupRead() */
 243    }
 244    if (ff_pkt->reader) {
 245       set_prog(&ff_pkt->bfd, ff_pkt->reader, jcr);
 246    }
 247
 248    /*
 249     * Open any file with data that we intend to save.
 250     * Note, if is_win32_backup, we must open the Directory so that
 251     * the BackupRead will save its permissions and ownership streams.
 252     */
 253    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 254          ff_pkt->statp.st_size > 0) ||
 255          ff_pkt->type == FT_RAW || ff_pkt->type == FT_FIFO ||
 256          (!is_portable_backup(&ff_pkt->bfd) && ff_pkt->type == FT_DIREND)) {
 257       btimer_t *tid;
 258       if (ff_pkt->type == FT_FIFO) {
 259          tid = start_thread_timer(pthread_self(), 60);
 260       } else {
 261          tid = NULL;
 262       }
 263       if (bopen(&ff_pkt->bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 264          ff_pkt->ff_errno = errno;
 265          berrno be;
 266          Jmsg(jcr, M_NOTSAVED, 0, _("     Cannot open %s: ERR=%s.\n"), ff_pkt->fname,
 267               be.strerror());
 268          jcr->Errors++;
 269          if (tid) {
 270             stop_thread_timer(tid);
 271             tid = NULL;
 272          }
 273          return 1;
 274       }
 275       if (tid) {
 276          stop_thread_timer(tid);
 277          tid = NULL;
 278       }
 279    }
 280
 281    binit(&ff_pkt->rsrc_bfd);
 282 #ifdef HAVE_DARWIN_OS
 283    /* Open resource fork if necessary */
 284    if (ff_pkt->type != FT_LNKSAVED && (S_ISREG(ff_pkt->statp.st_mode) &&
 285             ff_pkt->flags & FO_HFSPLUS)) {
 286       /* Remember Finder Info, whether we have data or fork, or not */
 287       hfsplus = true;
 288       if (ff_pkt->hfsinfo.rsrclength > 0) {
 289          if (!bopen_rsrc(&ff_pkt->rsrc_bfd, ff_pkt->fname, O_RDONLY | O_BINARY, 0) < 0) {
 290             ff_pkt->ff_errno = errno;
 291             berrno be;
 292             Jmsg(jcr, M_NOTSAVED, -1, _("     Cannot open resource fork for %s: ERR=%s.\n"), ff_pkt->fname,
 293                   be.strerror());
 294             jcr->Errors++;
 295             if (is_bopen(&ff_pkt->bfd)) {
 296                bclose(&ff_pkt->bfd);
 297             }
 298             return 1;
 299          }
 300       }
 301    }
 302 #endif
 303
 304    Dmsg1(130, "bfiled: sending %s to stored\n", ff_pkt->fname);
 305
 306    /* Find what data stream we will use, then encode the attributes */
 307    data_stream = select_data_stream(ff_pkt);
 308    encode_stat(attribs, ff_pkt, data_stream);
 309
 310    /* Now possibly extend the attributes */
 311    attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
 312
 313    Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs, attribsEx);
 314
 315    P(jcr->mutex);
 316    jcr->JobFiles++;                    /* increment number of files sent */
 317    ff_pkt->FileIndex = jcr->JobFiles;  /* return FileIndex */
 318    pm_strcpy(jcr->last_fname, ff_pkt->fname);
 319    V(jcr->mutex);
 320
 321    /*
 322     * Send Attributes header to Storage daemon
 323     *    <file-index> <stream> <info>
 324     */
 325    if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, attr_stream)) {
 326       berrno be;
 327       if (is_bopen(&ff_pkt->bfd)) {
 328          bclose(&ff_pkt->bfd);
 329       }
 330       if (is_bopen(&ff_pkt->rsrc_bfd)) {
 331          bclose(&ff_pkt->rsrc_bfd);
 332       }
 333       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 334             bnet_strerror(sd));
 335       return 0;
 336    }
 337    Dmsg1(300, ">stored: attrhdr %s\n", sd->msg);
 338
 339    /*
 340     * Send file attributes to Storage daemon
 341     *   File_index
 342     *   File type
 343     *   Filename (full path)
 344     *   Encoded attributes
 345     *   Link name (if type==FT_LNK or FT_LNKSAVED)
 346     *   Encoded extended-attributes (for Win32)
 347     *
 348     * For a directory, link is the same as fname, but with trailing
 349     * slash. For a linked file, link is the link.
 350     */
 351    if (ff_pkt->type == FT_LNK || ff_pkt->type == FT_LNKSAVED) {
 352       Dmsg2(300, "Link %s to %s\n", ff_pkt->fname, ff_pkt->link);
 353       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%s%c%s%c", jcr->JobFiles,
 354                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, ff_pkt->link, 0,
 355                attribsEx, 0);
 356    } else if (ff_pkt->type == FT_DIREND) {
 357       /* Here link is the canonical filename (i.e. with trailing slash) */
 358       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
 359                ff_pkt->type, ff_pkt->link, 0, attribs, 0, 0, attribsEx, 0);
 360    } else {
 361       stat = bnet_fsend(sd, "%ld %d %s%c%s%c%c%s%c", jcr->JobFiles,
 362                ff_pkt->type, ff_pkt->fname, 0, attribs, 0, 0, attribsEx, 0);
 363    }
 364
 365    Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
 366    if (!stat) {
 367       berrno be;
 368       if (is_bopen(&ff_pkt->bfd)) {
 369          bclose(&ff_pkt->bfd);
 370       }
 371       if (is_bopen(&ff_pkt->rsrc_bfd)) {
 372          bclose(&ff_pkt->rsrc_bfd);
 373       }
 374       Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 375             bnet_strerror(sd));
 376       return 0;
 377    }
 378    bnet_sig(sd, BNET_EOD);            /* indicate end of attributes data */
 379
 380    if (is_bopen(&ff_pkt->bfd) || hfsplus) {
 381       if (ff_pkt->flags & FO_MD5) {
 382          MD5Init(&md5c);
 383       } else if (ff_pkt->flags & FO_SHA1) {
 384          SHA1Init(&sha1c);
 385       }
 386    }
 387
 388    /*
 389     * If the file has data, read it and send to the Storage daemon
 390     *
 391     */
 392    if (is_bopen(&ff_pkt->bfd)) {
 393       uint64_t fileAddr = 0;          /* file address */
 394       char *rbuf, *wbuf;
 395       int rsize = jcr->buf_size;      /* read buffer size */
 396
 397       msgsave = sd->msg;
 398       rbuf = sd->msg;                 /* read buffer */
 399       wbuf = sd->msg;                 /* write buffer */
 400
 401
 402       Dmsg1(300, "Saving data, type=%d\n", ff_pkt->type);
 403
 404
 405 #ifdef HAVE_LIBZ
 406       uLong compress_len, max_compress_len = 0;
 407       const Bytef *cbuf = NULL;
 408
 409       if (ff_pkt->flags & FO_GZIP) {
 410          if (ff_pkt->flags & FO_SPARSE) {
 411             cbuf = (Bytef *)jcr->compress_buf + SPARSE_FADDR_SIZE;
 412             max_compress_len = jcr->compress_buf_size - SPARSE_FADDR_SIZE;
 413          } else {
 414             cbuf = (Bytef *)jcr->compress_buf;
 415             max_compress_len = jcr->compress_buf_size; /* set max length */
 416          }
 417          wbuf = jcr->compress_buf;    /* compressed output here */
 418       }
 419 #endif
 420
 421       /*
 422        * Send Data header to Storage daemon
 423        *    <file-index> <stream> <info>
 424        */
 425       if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, data_stream)) {
 426          berrno be;
 427          bclose(&ff_pkt->bfd);
 428          if (is_bopen(&ff_pkt->rsrc_bfd)) {
 429             bclose(&ff_pkt->rsrc_bfd);
 430          }
 431          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 432                bnet_strerror(sd));
 433          return 0;
 434       }
 435       Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 436
 437       /*
 438        * Make space at beginning of buffer for fileAddr because this
 439        *   same buffer will be used for writing if compression if off.
 440        */
 441       if (ff_pkt->flags & FO_SPARSE) {
 442          rbuf += SPARSE_FADDR_SIZE;
 443          rsize -= SPARSE_FADDR_SIZE;
 444 #ifdef HAVE_FREEBSD_OS
 445          /*
 446           * To read FreeBSD partitions, the read size must be
 447           *  a multiple of 512.
 448           */
 449          rsize = (rsize/512) * 512;
 450 #endif
 451       }
 452
 453       /*
 454        * Read the file data
 455        */
 456       while ((sd->msglen=(uint32_t)bread(&ff_pkt->bfd, rbuf, rsize)) > 0) {
 457          int sparseBlock = 0;
 458
 459          /* Check for sparse blocks */
 460          if (ff_pkt->flags & FO_SPARSE) {
 461             ser_declare;
 462             if (sd->msglen == rsize &&
 463                 (fileAddr+sd->msglen < (uint64_t)ff_pkt->statp.st_size)) {
 464                sparseBlock = is_buf_zero(rbuf, rsize);
 465             }
 466
 467             ser_begin(wbuf, SPARSE_FADDR_SIZE);
 468             ser_uint64(fileAddr);     /* store fileAddr in begin of buffer */
 469          }
 470
 471          jcr->ReadBytes += sd->msglen;      /* count bytes read */
 472          fileAddr += sd->msglen;
 473
 474          /* Update MD5 if requested */
 475          if (ff_pkt->flags & FO_MD5) {
 476             MD5Update(&md5c, (unsigned char *)rbuf, sd->msglen);
 477             gotMD5 = 1;
 478          } else if (ff_pkt->flags & FO_SHA1) {
 479             SHA1Update(&sha1c, (unsigned char *)rbuf, sd->msglen);
 480             gotSHA1 = 1;
 481          }
 482
 483 #ifdef HAVE_LIBZ
 484          /* Do compression if turned on */
 485          if (!sparseBlock && ff_pkt->flags & FO_GZIP) {
 486             int zstat;
 487             compress_len = max_compress_len;
 488             Dmsg4(400, "cbuf=0x%x len=%u rbuf=0x%x len=%u\n", cbuf, compress_len,
 489                rbuf, sd->msglen);
 490             /* NOTE! This call modifies compress_len !!! */
 491             if ((zstat=compress2((Bytef *)cbuf, &compress_len,
 492                   (const Bytef *)rbuf, (uLong)sd->msglen,
 493                   ff_pkt->GZIP_level)) != Z_OK) {
 494                Jmsg(jcr, M_FATAL, 0, _("Compression error: %d\n"), zstat);
 495                sd->msg = msgsave;
 496                sd->msglen = 0;
 497                bclose(&ff_pkt->bfd);
 498                if (is_bopen(&ff_pkt->rsrc_bfd)) {
 499                   bclose(&ff_pkt->rsrc_bfd);
 500                }
 501                set_jcr_job_status(jcr, JS_ErrorTerminated);
 502                return 0;
 503             }
 504             Dmsg2(400, "compressed len=%d uncompressed len=%d\n",
 505                compress_len, sd->msglen);
 506
 507             sd->msglen = compress_len;   /* set compressed length */
 508          }
 509 #endif
 510
 511          /* Send the buffer to the Storage daemon */
 512          if (!sparseBlock) {
 513             if (ff_pkt->flags & FO_SPARSE) {
 514                sd->msglen += SPARSE_FADDR_SIZE; /* include fileAddr in size */
 515             }
 516             sd->msg = wbuf;           /* set correct write buffer */
 517             if (!bnet_send(sd)) {
 518                berrno be;
 519                Jmsg2(jcr, M_FATAL, 0, _("Network send error %d to SD. ERR=%s\n"),
 520                      sd->msglen, bnet_strerror(sd));
 521                sd->msg = msgsave;     /* restore bnet buffer */
 522                sd->msglen = 0;
 523                bclose(&ff_pkt->bfd);
 524                if (is_bopen(&ff_pkt->rsrc_bfd)) {
 525                   bclose(&ff_pkt->rsrc_bfd);
 526                }
 527                return 0;
 528             }
 529          }
 530          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 531          /*       #endif */
 532          jcr->JobBytes += sd->msglen;   /* count bytes saved possibly compressed */
 533          sd->msg = msgsave;             /* restore read buffer */
 534
 535       } /* end while read file data */
 536
 537
 538       if (sd->msglen < 0) {
 539          berrno be;
 540          be.set_errno(ff_pkt->bfd.berrno);
 541          Jmsg(jcr, M_ERROR, 0, _("Read error on file %s. ERR=%s\n"),
 542             ff_pkt->fname, be.strerror());
 543       }
 544
 545       bclose(&ff_pkt->bfd);              /* close file */
 546       if (!bnet_sig(sd, BNET_EOD)) {     /* indicate end of file data */
 547          berrno be;
 548          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 549                bnet_strerror(sd));
 550          if (is_bopen(&ff_pkt->rsrc_bfd)) {
 551             bclose(&ff_pkt->rsrc_bfd);
 552          }
 553          return 0;
 554       }
 555    }
 556
 557 #ifdef HAVE_DARWIN_OS
 558    /*
 559     * If resource fork has data, read it and send to the Storage daemon
 560     *
 561     */
 562    if (is_bopen(&ff_pkt->rsrc_bfd)) {
 563       uint64_t fileAddr = 0;          /* file address */
 564       int rsize = jcr->buf_size;      /* read buffer size */
 565
 566       Dmsg1(300, "Saving resource fork for \"%s\"", ff_pkt->fname);
 567
 568       /*
 569        * Send Data header to Storage daemon
 570        *    <file-index> <stream> <info>
 571        */
 572       if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_MACOS_FORK_DATA)) {
 573          berrno be;
 574          bclose(&ff_pkt->rsrc_bfd);
 575          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 576                bnet_strerror(sd));
 577          return 0;
 578       }
 579       Dmsg1(300, ">stored: datahdr %s\n", sd->msg);
 580
 581       /*
 582        * Read the resource fork
 583        */
 584       while ((sd->msglen=(uint32_t)bread(&ff_pkt->rsrc_bfd, sd->msg, rsize)) > 0) {
 585          jcr->ReadBytes += sd->msglen;      /* count bytes read */
 586          fileAddr += sd->msglen;
 587
 588          /* Update MD5 if requested */
 589          if (ff_pkt->flags & FO_MD5) {
 590             MD5Update(&md5c, (unsigned char *)sd->msg, sd->msglen);
 591             gotMD5 = 1;
 592          } else if (ff_pkt->flags & FO_SHA1) {
 593             SHA1Update(&sha1c, (unsigned char *)sd->msg, sd->msglen);
 594             gotSHA1 = 1;
 595          }
 596
 597          /* Send the buffer to the Storage daemon */
 598          if (!bnet_send(sd)) {
 599             berrno be;
 600             Jmsg2(jcr, M_FATAL, 0, _("Network send error %d to SD. ERR=%s\n"),
 601                   sd->msglen, bnet_strerror(sd));
 602             sd->msglen = 0;
 603             bclose(&ff_pkt->rsrc_bfd);
 604             return 0;
 605          }
 606          Dmsg1(130, "Send data to SD len=%d\n", sd->msglen);
 607          /*       #endif */
 608          jcr->JobBytes += sd->msglen;   /* count bytes saved possibly compressed */
 609       } /* end while read file data */
 610
 611       if (sd->msglen < 0) {
 612          berrno be;
 613          be.set_errno(ff_pkt->rsrc_bfd.berrno);
 614          Jmsg(jcr, M_ERROR, 0, _("Read error on resource fork of %s. ERR=%s\n"),
 615             ff_pkt->fname, be.strerror());
 616       }
 617
 618       bclose(&ff_pkt->rsrc_bfd);                 /* close resource fork */
 619       if (!bnet_sig(sd, BNET_EOD)) {     /* indicate end of resource fork */
 620          berrno be;
 621          Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 622                bnet_strerror(sd));
 623          return 0;
 624       }
 625    }
 626 #endif
 627
 628 #ifdef HAVE_DARWIN_OS
 629    /* Handle Finder Info */
 630    if (S_ISREG(ff_pkt->statp.st_mode) && ff_pkt->flags & FO_HFSPLUS) {
 631       Dmsg1(300, "Saving Finder Info for \"%s\"", ff_pkt->fname);
 632       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_HFSPLUS_ATTRIBUTES);
 633       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 634       memcpy(sd->msg, ff_pkt->hfsinfo.fndrinfo, 32);
 635       sd->msglen = 32;
 636       /* Update MD5 if requested */
 637       if (ff_pkt->flags & FO_MD5) {
 638          MD5Update(&md5c, (unsigned char *)sd->msg, sd->msglen);
 639          gotMD5 = 1;
 640       } else if (ff_pkt->flags & FO_SHA1) {
 641          SHA1Update(&sha1c, (unsigned char *)sd->msg, sd->msglen);
 642          gotSHA1 = 1;
 643       }
 644       bnet_send(sd);
 645       bnet_sig(sd, BNET_EOD);
 646    }
 647 #endif
 648
 649
 650 #ifdef HAVE_ACL
 651    /* ACL stream */
 652    if (ff_pkt->flags & FO_ACL) {
 653       char *acl_text;
 654       /* Read ACLs for files, dirs and links */
 655       if (ff_pkt->type == FT_DIREND) {
 656          /* Directory: Try for default ACL*/
 657          acl_t myAcl = acl_get_file(ff_pkt->fname, ACL_TYPE_DEFAULT);
 658          if (!myAcl) {
 659             Dmsg1(200, "No default ACL defined for directory: %s!\n", ff_pkt->fname);
 660             /* If there is no default ACL get standard ACL */
 661             myAcl = acl_get_file(ff_pkt->fname, ACL_TYPE_ACCESS);
 662             if (!myAcl) {
 663                Jmsg1(jcr, M_WARNING, 0, "Error while trying to get ACL of directory: %s!\n", ff_pkt->fname);
 664             }
 665          }
 666          acl_text = acl_to_any_text(myAcl, NULL, ',', TEXT_ABBREVIATE);
 667          /* Free memory */
 668          acl_free(myAcl);
 669       } else {
 670          /* Files or links */
 671          acl_t myAcl = acl_get_file(ff_pkt->fname, ACL_TYPE_ACCESS);
 672          if (!myAcl) {
 673             Jmsg1(jcr, M_WARNING, 0, "Error while trying to get ACL of file: %s!\n", ff_pkt->fname);
 674             acl_free(myAcl);
 675          }
 676          acl_text = acl_to_any_text(myAcl, NULL, ',', TEXT_ABBREVIATE);
 677          acl_free(myAcl);
 678       }
 679
 680       /* If there is an ACL, send it to the Storage daemon */
 681       if (acl_text) {
 682          sd = jcr->store_bsock;
 683          pm_strcpy(&jcr->last_fname, ff_pkt->fname);
 684
 685          /*
 686          * Send ACL header
 687          *
 688          */
 689          if (!bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_UNIX_ATTRIBUTES_ACL)) {
 690             berrno be;
 691             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 692                   bnet_strerror(sd));
 693             return 0;
 694          }
 695
 696          /* Send the buffer to the storage deamon */
 697          msgsave = sd->msg;
 698          sd->msg = acl_text;
 699          sd->msglen = strlen(acl_text) + 1;
 700          if (!bnet_send(sd)) {
 701             berrno be;
 702             sd->msg = msgsave;
 703             sd->msglen = 0;
 704             Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 705                   bnet_strerror(sd));
 706          } else {
 707             jcr->JobBytes += sd->msglen;
 708             sd->msg = msgsave;
 709             if (!bnet_sig(sd, BNET_EOD)) {
 710                berrno be;
 711                Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
 712                      bnet_strerror(sd));
 713             } else {
 714                Dmsg1(200, "ACL of file: %s successfully backed up!\n", ff_pkt->fname);
 715             }
 716          }
 717       }
 718    }
 719 #endif
 720
 721    /* Terminate any MD5 signature and send it to Storage daemon and the Director */
 722    if (gotMD5 && ff_pkt->flags & FO_MD5) {
 723       MD5Final(signature, &md5c);
 724       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_MD5_SIGNATURE);
 725       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 726       memcpy(sd->msg, signature, 16);
 727       sd->msglen = 16;
 728       bnet_send(sd);
 729       bnet_sig(sd, BNET_EOD);         /* end of MD5 */
 730       gotMD5 = 0;
 731
 732    } else if (gotSHA1 && ff_pkt->flags & FO_SHA1) {
 733    /* Terminate any SHA1 signature and send it to Storage daemon and the Director */
 734       SHA1Final(&sha1c, signature);
 735       bnet_fsend(sd, "%ld %d 0", jcr->JobFiles, STREAM_SHA1_SIGNATURE);
 736       Dmsg1(300, "bfiled>stored:header %s\n", sd->msg);
 737       memcpy(sd->msg, signature, 20);
 738       sd->msglen = 20;
 739       bnet_send(sd);
 740       bnet_sig(sd, BNET_EOD);         /* end of SHA1 */
 741       gotMD5 = 0;
 742    }
 743    return 1;
 744 }