git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/catreq.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2010 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  *
  30  *   Bacula Director -- catreq.c -- handles the message channel
  31  *    catalog request from the Storage daemon.
  32  *
  33  *     Kern Sibbald, March MMI
  34  *
  35  *    This routine runs as a thread and must be thread reentrant.
  36  *
  37  *  Basic tasks done here:
  38  *      Handle Catalog services.
  39  *
  40  */
  41
  42 #include "bacula.h"
  43 #include "dird.h"
  44 #include "findlib/find.h"
  45
  46 /*
  47  * Handle catalog request
  48  *  For now, we simply return next Volume to be used
  49  */
  50
  51 /* Requests from the Storage daemon */
  52 static char Find_media[] = "CatReq Job=%127s FindMedia=%d pool_name=%127s media_type=%127s\n";
  53 static char Get_Vol_Info[] = "CatReq Job=%127s GetVolInfo VolName=%127s write=%d\n";
  54
  55 static char Update_media[] = "CatReq Job=%127s UpdateMedia VolName=%s"
  56    " VolJobs=%u VolFiles=%u VolBlocks=%u VolBytes=%lld VolMounts=%u"
  57    " VolErrors=%u VolWrites=%u MaxVolBytes=%lld EndTime=%lld VolStatus=%10s"
  58    " Slot=%d relabel=%d InChanger=%d VolReadTime=%lld VolWriteTime=%lld"
  59    " VolFirstWritten=%lld VolParts=%u\n";
  60
  61 static char Create_job_media[] = "CatReq Job=%127s CreateJobMedia "
  62    " FirstIndex=%u LastIndex=%u StartFile=%u EndFile=%u "
  63    " StartBlock=%u EndBlock=%u Copy=%d Strip=%d MediaId=%" lld "\n";
  64
  65
  66 /* Responses  sent to Storage daemon */
  67 static char OK_media[] = "1000 OK VolName=%s VolJobs=%u VolFiles=%u"
  68    " VolBlocks=%u VolBytes=%s VolMounts=%u VolErrors=%u VolWrites=%u"
  69    " MaxVolBytes=%s VolCapacityBytes=%s VolStatus=%s Slot=%d"
  70    " MaxVolJobs=%u MaxVolFiles=%u InChanger=%d VolReadTime=%s"
  71    " VolWriteTime=%s EndFile=%u EndBlock=%u VolParts=%u LabelType=%d"
  72    " MediaId=%s\n";
  73
  74 static char OK_create[] = "1000 OK CreateJobMedia\n";
  75
  76
  77 static int send_volume_info_to_storage_daemon(JCR *jcr, BSOCK *sd, MEDIA_DBR *mr)
  78 {
  79    int stat;
  80    char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50];
  81
  82    jcr->MediaId = mr->MediaId;
  83    pm_strcpy(jcr->VolumeName, mr->VolumeName);
  84    bash_spaces(mr->VolumeName);
  85    stat = sd->fsend(OK_media, mr->VolumeName, mr->VolJobs,
  86       mr->VolFiles, mr->VolBlocks, edit_uint64(mr->VolBytes, ed1),
  87       mr->VolMounts, mr->VolErrors, mr->VolWrites,
  88       edit_uint64(mr->MaxVolBytes, ed2),
  89       edit_uint64(mr->VolCapacityBytes, ed3),
  90       mr->VolStatus, mr->Slot, mr->MaxVolJobs, mr->MaxVolFiles,
  91       mr->InChanger,
  92       edit_int64(mr->VolReadTime, ed4),
  93       edit_int64(mr->VolWriteTime, ed5),
  94       mr->EndFile, mr->EndBlock,
  95       mr->VolParts,
  96       mr->LabelType,
  97       edit_uint64(mr->MediaId, ed6));
  98    unbash_spaces(mr->VolumeName);
  99    Dmsg2(100, "Vol Info for %s: %s", jcr->Job, sd->msg);
 100    return stat;
 101 }
 102
 103 void catalog_request(JCR *jcr, BSOCK *bs)
 104 {
 105    MEDIA_DBR mr, sdmr;
 106    JOBMEDIA_DBR jm;
 107    char Job[MAX_NAME_LENGTH];
 108    char pool_name[MAX_NAME_LENGTH];
 109    int index, ok, label, writing;
 110    POOLMEM *omsg;
 111    POOL_DBR pr;
 112    uint32_t Stripe, Copy;
 113    uint64_t MediaId;
 114    utime_t VolFirstWritten;
 115    utime_t VolLastWritten;
 116
 117    memset(&mr, 0, sizeof(mr));
 118    memset(&sdmr, 0, sizeof(sdmr));
 119    memset(&jm, 0, sizeof(jm));
 120    Dsm_check(100);
 121
 122    /*
 123     * Request to find next appendable Volume for this Job
 124     */
 125    Dmsg1(100, "catreq %s", bs->msg);
 126    if (!jcr->db) {
 127       omsg = get_memory(bs->msglen+1);
 128       pm_strcpy(omsg, bs->msg);
 129       bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
 130       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request; DB not open: %s"), omsg);
 131       free_memory(omsg);
 132       return;
 133    }
 134    /*
 135     * Find next appendable medium for SD
 136     */
 137    if (sscanf(bs->msg, Find_media, &Job, &index, &pool_name, &mr.MediaType) == 4) {
 138       memset(&pr, 0, sizeof(pr));
 139       bstrncpy(pr.Name, pool_name, sizeof(pr.Name));
 140       unbash_spaces(pr.Name);
 141       ok = db_get_pool_record(jcr, jcr->db, &pr);
 142       if (ok) {
 143          mr.PoolId = pr.PoolId;
 144          mr.StorageId = jcr->wstore->StorageId;
 145          mr.ScratchPoolId = pr.ScratchPoolId;
 146          ok = find_next_volume_for_append(jcr, &mr, index, fnv_create_vol, fnv_prune);
 147          Dmsg3(050, "find_media ok=%d idx=%d vol=%s\n", ok, index, mr.VolumeName);
 148       }
 149       /*
 150        * Send Find Media response to Storage daemon
 151        */
 152       if (ok) {
 153          send_volume_info_to_storage_daemon(jcr, bs, &mr);
 154       } else {
 155          bs->fsend(_("1901 No Media.\n"));
 156          Dmsg0(500, "1901 No Media.\n");
 157       }
 158
 159    /*
 160     * Request to find specific Volume information
 161     */
 162    } else if (sscanf(bs->msg, Get_Vol_Info, &Job, &mr.VolumeName, &writing) == 3) {
 163       Dmsg1(100, "CatReq GetVolInfo Vol=%s\n", mr.VolumeName);
 164       /*
 165        * Find the Volume
 166        */
 167       unbash_spaces(mr.VolumeName);
 168       if (db_get_media_record(jcr, jcr->db, &mr)) {
 169          const char *reason = NULL;           /* detailed reason for rejection */
 170          /*
 171           * If we are reading, accept any volume (reason == NULL)
 172           * If we are writing, check if the Volume is valid
 173           *   for this job, and do a recycle if necessary
 174           */
 175          if (writing) {
 176             /*
 177              * SD wants to write this Volume, so make
 178              *   sure it is suitable for this job, i.e.
 179              *   Pool matches, and it is either Append or Recycle
 180              *   and Media Type matches and Pool allows any volume.
 181              */
 182             if (mr.PoolId != jcr->jr.PoolId) {
 183                reason = _("not in Pool");
 184             } else if (strcmp(mr.MediaType, jcr->wstore->media_type) != 0) {
 185                reason = _("not correct MediaType");
 186             } else {
 187                /*
 188                 * Now try recycling if necessary
 189                 *   reason set non-NULL if we cannot use it
 190                 */
 191                check_if_volume_valid_or_recyclable(jcr, &mr, &reason);
 192             }
 193          }
 194          if (!reason && mr.Enabled != 1) {
 195             reason = _("is not Enabled");
 196          }
 197          if (reason == NULL) {
 198             /*
 199              * Send Find Media response to Storage daemon
 200              */
 201             send_volume_info_to_storage_daemon(jcr, bs, &mr);
 202          } else {
 203             /* Not suitable volume */
 204             bs->fsend(_("1998 Volume \"%s\" status is %s, %s.\n"), mr.VolumeName,
 205                mr.VolStatus, reason);
 206          }
 207
 208       } else {
 209          bs->fsend(_("1997 Volume \"%s\" not in catalog.\n"), mr.VolumeName);
 210          Dmsg1(100, "1997 Volume \"%s\" not in catalog.\n", mr.VolumeName);
 211       }
 212
 213    /*
 214     * Request to update Media record. Comes typically at the end
 215     *  of a Storage daemon Job Session, when labeling/relabeling a
 216     *  Volume, or when an EOF mark is written.
 217     */
 218    } else if (sscanf(bs->msg, Update_media, &Job, &sdmr.VolumeName,
 219       &sdmr.VolJobs, &sdmr.VolFiles, &sdmr.VolBlocks, &sdmr.VolBytes,
 220       &sdmr.VolMounts, &sdmr.VolErrors, &sdmr.VolWrites, &sdmr.MaxVolBytes,
 221       &VolLastWritten, &sdmr.VolStatus, &sdmr.Slot, &label, &sdmr.InChanger,
 222       &sdmr.VolReadTime, &sdmr.VolWriteTime, &VolFirstWritten,
 223       &sdmr.VolParts) == 19) {
 224
 225       db_lock(jcr->db);
 226       Dmsg3(400, "Update media %s oldStat=%s newStat=%s\n", sdmr.VolumeName,
 227          mr.VolStatus, sdmr.VolStatus);
 228       bstrncpy(mr.VolumeName, sdmr.VolumeName, sizeof(mr.VolumeName)); /* copy Volume name */
 229       unbash_spaces(mr.VolumeName);
 230       if (!db_get_media_record(jcr, jcr->db, &mr)) {
 231          Jmsg(jcr, M_ERROR, 0, _("Unable to get Media record for Volume %s: ERR=%s\n"),
 232               mr.VolumeName, db_strerror(jcr->db));
 233          bs->fsend(_("1991 Catalog Request for vol=%s failed: %s"),
 234             mr.VolumeName, db_strerror(jcr->db));
 235          db_unlock(jcr->db);
 236          return;
 237       }
 238       /* Set first written time if this is first job */
 239       if (mr.FirstWritten == 0) {
 240          if (VolFirstWritten == 0) {
 241             mr.FirstWritten = jcr->start_time;   /* use Job start time as first write */
 242          } else {
 243             mr.FirstWritten = VolFirstWritten;
 244          }
 245          mr.set_first_written = true;
 246       }
 247       /* If we just labeled the tape set time */
 248       if (label || mr.LabelDate == 0) {
 249          mr.LabelDate = jcr->start_time;
 250          mr.set_label_date = true;
 251          if (mr.InitialWrite == 0) {
 252             mr.InitialWrite = jcr->start_time;
 253          }
 254          Dmsg2(400, "label=%d labeldate=%d\n", label, mr.LabelDate);
 255       } else {
 256          /*
 257           * Insanity check for VolFiles get set to a smaller value
 258           */
 259          if (sdmr.VolFiles < mr.VolFiles) {
 260             Jmsg(jcr, M_FATAL, 0, _("Volume Files at %u being set to %u"
 261                  " for Volume \"%s\". This is incorrect.\n"),
 262                mr.VolFiles, sdmr.VolFiles, mr.VolumeName);
 263             bs->fsend(_("1992 Update Media error. VolFiles=%u, CatFiles=%u\n"),
 264                sdmr.VolFiles, mr.VolFiles);
 265             db_unlock(jcr->db);
 266             return;
 267          }
 268       }
 269       Dmsg2(400, "Update media: BefVolJobs=%u After=%u\n", mr.VolJobs, sdmr.VolJobs);
 270
 271       /*
 272        * Check if the volume has been written by the job,
 273        * and update the LastWritten field if needed.
 274        */
 275       if (mr.VolBlocks != sdmr.VolBlocks && VolLastWritten != 0) {
 276          mr.LastWritten = VolLastWritten;
 277       }
 278
 279       /*
 280        * Update to point to the last device used to write the Volume.
 281        *   However, do so only if we are writing the tape, i.e.
 282        *   the number of VolWrites has increased.
 283        */
 284       if (jcr->wstore && jcr->wstore->StorageId && sdmr.VolWrites > mr.VolWrites) {
 285          mr.StorageId = jcr->wstore->StorageId;
 286       }
 287
 288       /* Copy updated values to original media record */
 289       mr.VolJobs      = sdmr.VolJobs;
 290       mr.VolFiles     = sdmr.VolFiles;
 291       mr.VolBlocks    = sdmr.VolBlocks;
 292       mr.VolBytes     = sdmr.VolBytes;
 293       mr.VolMounts    = sdmr.VolMounts;
 294       mr.VolErrors    = sdmr.VolErrors;
 295       mr.VolWrites    = sdmr.VolWrites;
 296       mr.Slot         = sdmr.Slot;
 297       mr.InChanger    = sdmr.InChanger;
 298       mr.VolParts     = sdmr.VolParts;
 299       bstrncpy(mr.VolStatus, sdmr.VolStatus, sizeof(mr.VolStatus));
 300       if (sdmr.VolReadTime >= 0) {
 301          mr.VolReadTime  = sdmr.VolReadTime;
 302       }
 303       if (sdmr.VolWriteTime >= 0) {
 304          mr.VolWriteTime = sdmr.VolWriteTime;
 305       }
 306
 307       Dmsg2(400, "db_update_media_record. Stat=%s Vol=%s\n", mr.VolStatus, mr.VolumeName);
 308       /*
 309        * Update the database, then before sending the response to the
 310        *  SD, check if the Volume has expired.
 311        */
 312       if (!db_update_media_record(jcr, jcr->db, &mr)) {
 313          Jmsg(jcr, M_FATAL, 0, _("Catalog error updating Media record. %s"),
 314             db_strerror(jcr->db));
 315          bs->fsend(_("1993 Update Media error\n"));
 316          Dmsg0(400, "send error\n");
 317       } else {
 318          (void)has_volume_expired(jcr, &mr);
 319          send_volume_info_to_storage_daemon(jcr, bs, &mr);
 320       }
 321       db_unlock(jcr->db);
 322
 323    /*
 324     * Request to create a JobMedia record
 325     */
 326    } else if (sscanf(bs->msg, Create_job_media, &Job,
 327       &jm.FirstIndex, &jm.LastIndex, &jm.StartFile, &jm.EndFile,
 328       &jm.StartBlock, &jm.EndBlock, &Copy, &Stripe, &MediaId) == 10) {
 329
 330       if (jcr->mig_jcr) {
 331          jm.JobId = jcr->mig_jcr->JobId;
 332       } else {
 333          jm.JobId = jcr->JobId;
 334       }
 335       jm.MediaId = MediaId;
 336       Dmsg6(400, "create_jobmedia JobId=%d MediaId=%d SF=%d EF=%d FI=%d LI=%d\n",
 337          jm.JobId, jm.MediaId, jm.StartFile, jm.EndFile, jm.FirstIndex, jm.LastIndex);
 338       if (!db_create_jobmedia_record(jcr, jcr->db, &jm)) {
 339          Jmsg(jcr, M_FATAL, 0, _("Catalog error creating JobMedia record. %s"),
 340             db_strerror(jcr->db));
 341          bs->fsend(_("1992 Create JobMedia error\n"));
 342       } else {
 343          Dmsg0(400, "JobMedia record created\n");
 344          bs->fsend(OK_create);
 345       }
 346
 347    } else {
 348       omsg = get_memory(bs->msglen+1);
 349       pm_strcpy(omsg, bs->msg);
 350       bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
 351       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request: %s"), omsg);
 352       free_memory(omsg);
 353    }
 354    Dmsg1(400, ">CatReq response: %s", bs->msg);
 355    Dmsg1(400, "Leave catreq jcr 0x%x\n", jcr);
 356    return;
 357 }
 358
 359 /*
 360  * Note, we receive the whole attribute record, but we select out only the stat
 361  * packet, VolSessionId, VolSessionTime, FileIndex, file type, and file name to
 362  * store in the catalog.
 363  */
 364 static void update_attribute(JCR *jcr, char *msg, int32_t msglen)
 365 {
 366    unser_declare;
 367    uint32_t VolSessionId, VolSessionTime;
 368    int32_t Stream;
 369    uint32_t FileIndex;
 370    uint32_t data_len;
 371    char *p;
 372    int len;
 373    char *fname, *attr;
 374    ATTR_DBR *ar = NULL;
 375
 376    /* Start transaction allocates jcr->attr and jcr->ar if needed */
 377    db_start_transaction(jcr, jcr->db);     /* start transaction if not already open */
 378    ar = jcr->ar;
 379
 380    /* Start by scanning directly in the message buffer to get Stream
 381     *  there may be a cached attr so we cannot yet write into
 382     *  jcr->attr or jcr->ar
 383     */
 384    p = msg;
 385    skip_nonspaces(&p);                /* UpdCat */
 386    skip_spaces(&p);
 387    skip_nonspaces(&p);                /* Job=nnn */
 388    skip_spaces(&p);
 389    skip_nonspaces(&p);                /* FileAttributes */
 390    p += 1;
 391    unser_begin(p, 0);
 392    unser_uint32(VolSessionId);
 393    unser_uint32(VolSessionTime);
 394    unser_int32(FileIndex);
 395    unser_int32(Stream);
 396    unser_uint32(data_len);
 397    p += unser_length(p);
 398
 399    Dmsg1(400, "UpdCat msg=%s\n", msg);
 400    Dmsg5(400, "UpdCat VolSessId=%d VolSessT=%d FI=%d Strm=%d data_len=%d\n",
 401       VolSessionId, VolSessionTime, FileIndex, Stream, data_len);
 402
 403    if (Stream == STREAM_UNIX_ATTRIBUTES || Stream == STREAM_UNIX_ATTRIBUTES_EX) {
 404       if (jcr->cached_attribute) {
 405          Dmsg2(400, "Cached attr. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 406          if (!db_create_attributes_record(jcr, jcr->db, ar)) {
 407             Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 408          }
 409       }
 410       /* Any cached attr is flushed so we can reuse jcr->attr and jcr->ar */
 411       jcr->attr = check_pool_memory_size(jcr->attr, msglen);
 412       memcpy(jcr->attr, msg, msglen);
 413       p = jcr->attr - msg + p;    /* point p into jcr->attr */
 414       skip_nonspaces(&p);             /* skip FileIndex */
 415       skip_spaces(&p);
 416       ar->FileType = str_to_int32(p);     /* TODO: choose between unserialize and str_to_int32 */
 417       skip_nonspaces(&p);             /* skip FileType */
 418       skip_spaces(&p);
 419       fname = p;
 420       len = strlen(fname);        /* length before attributes */
 421       attr = &fname[len+1];
 422
 423       Dmsg2(400, "dird<stored: stream=%d %s\n", Stream, fname);
 424       Dmsg1(400, "dird<stored: attr=%s\n", attr);
 425       ar->attr = attr;
 426       ar->fname = fname;
 427       if (ar->FileType == FT_DELETED) {
 428          ar->FileIndex = 0;     /* special value */
 429       } else {
 430          ar->FileIndex = FileIndex;
 431       }
 432       ar->Stream = Stream;
 433       ar->link = NULL;
 434       if (jcr->mig_jcr) {
 435          ar->JobId = jcr->mig_jcr->JobId;
 436       } else {
 437          ar->JobId = jcr->JobId;
 438       }
 439       ar->Digest = NULL;
 440       ar->DigestType = CRYPTO_DIGEST_NONE;
 441       jcr->cached_attribute = true;
 442
 443       Dmsg2(400, "dird<filed: stream=%d %s\n", Stream, fname);
 444       Dmsg1(400, "dird<filed: attr=%s\n", attr);
 445
 446    } else if (crypto_digest_stream_type(Stream) != CRYPTO_DIGEST_NONE) {
 447       fname = p;
 448       if (ar->FileIndex != FileIndex) {
 449          Jmsg(jcr, M_WARNING, 0, _("Got %s but not same File as attributes\n"), stream_to_ascii(Stream));
 450       } else {
 451          /* Update digest in catalog */
 452          char digestbuf[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
 453          int len = 0;
 454          int type = CRYPTO_DIGEST_NONE;
 455
 456          switch(Stream) {
 457          case STREAM_MD5_DIGEST:
 458             len = CRYPTO_DIGEST_MD5_SIZE;
 459             type = CRYPTO_DIGEST_MD5;
 460             break;
 461          case STREAM_SHA1_DIGEST:
 462             len = CRYPTO_DIGEST_SHA1_SIZE;
 463             type = CRYPTO_DIGEST_SHA1;
 464             break;
 465          case STREAM_SHA256_DIGEST:
 466             len = CRYPTO_DIGEST_SHA256_SIZE;
 467             type = CRYPTO_DIGEST_SHA256;
 468             break;
 469          case STREAM_SHA512_DIGEST:
 470             len = CRYPTO_DIGEST_SHA512_SIZE;
 471             type = CRYPTO_DIGEST_SHA512;
 472             break;
 473          default:
 474             /* Never reached ... */
 475             Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. Unsupported digest stream type: %d"),
 476                  Stream);
 477          }
 478
 479          bin_to_base64(digestbuf, sizeof(digestbuf), fname, len, true);
 480          Dmsg3(400, "DigestLen=%d Digest=%s type=%d\n", strlen(digestbuf),
 481                digestbuf, Stream);
 482          if (jcr->cached_attribute) {
 483             ar->Digest = digestbuf;
 484             ar->DigestType = type;
 485             Dmsg2(400, "Cached attr with digest. Stream=%d fname=%s\n",
 486                   ar->Stream, ar->fname);
 487
 488             /* Update BaseFile table */
 489             if (!db_create_attributes_record(jcr, jcr->db, ar)) {
 490                Jmsg1(jcr, M_FATAL, 0, _("attribute create error. %s"),
 491                         db_strerror(jcr->db));
 492             }
 493             jcr->cached_attribute = false;
 494          } else {
 495             if (!db_add_digest_to_file_record(jcr, jcr->db, ar->FileId, digestbuf, type)) {
 496                Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. %s"),
 497                   db_strerror(jcr->db));
 498             }
 499          }
 500       }
 501    }
 502 }
 503
 504 /*
 505  * Update File Attributes in the catalog with data
 506  *  sent by the Storage daemon.
 507  */
 508 void catalog_update(JCR *jcr, BSOCK *bs)
 509 {
 510    if (!jcr->pool->catalog_files) {
 511       return;                         /* user disabled cataloging */
 512    }
 513    if (job_canceled(jcr)) {
 514       goto bail_out;
 515    }
 516    if (!jcr->db) {
 517       POOLMEM *omsg = get_memory(bs->msglen+1);
 518       pm_strcpy(omsg, bs->msg);
 519       bs->fsend(_("1994 Invalid Catalog Update: %s"), omsg);
 520       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog Update; DB not open: %s"), omsg);
 521       free_memory(omsg);
 522       goto bail_out;
 523    }
 524    update_attribute(jcr, bs->msg, bs->msglen);
 525
 526 bail_out:
 527    if (job_canceled(jcr)) {
 528       cancel_storage_daemon_job(jcr);
 529    }
 530 }
 531
 532 /*
 533  * Update File Attributes in the catalog with data read from
 534  * the storage daemon spool file. We receive the filename and
 535  * we try to read it.
 536  */
 537 bool despool_attributes_from_file(JCR *jcr, const char *file)
 538 {
 539    bool ret=false;
 540    int32_t pktsiz;
 541    size_t nbytes;
 542    ssize_t last = 0, size = 0;
 543    int count = 0;
 544    int32_t msglen;                    /* message length */
 545    POOLMEM *msg = get_pool_memory(PM_MESSAGE);
 546    FILE *spool_fd=NULL;
 547
 548    Dmsg0(100, "Begin despool_attributes_from_file\n");
 549
 550    if (job_canceled(jcr) || !jcr->pool->catalog_files || !jcr->db) {
 551       goto bail_out;                  /* user disabled cataloging */
 552    }
 553
 554    spool_fd = fopen(file, "rb");
 555    if (!spool_fd) {
 556       Dmsg0(100, "cancel despool_attributes_from_file\n");
 557       /* send an error message */
 558       goto bail_out;
 559    }
 560 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
 561    posix_fadvise(fileno(spool_fd), 0, 0, POSIX_FADV_WILLNEED);
 562 #endif
 563
 564    while (fread((char *)&pktsiz, 1, sizeof(int32_t), spool_fd) ==
 565           sizeof(int32_t)) {
 566       size += sizeof(int32_t);
 567       msglen = ntohl(pktsiz);
 568       if (msglen > 0) {
 569          if (msglen > (int32_t) sizeof_pool_memory(msg)) {
 570             msg = realloc_pool_memory(msg, msglen + 1);
 571          }
 572          nbytes = fread(msg, 1, msglen, spool_fd);
 573          if (nbytes != (size_t) msglen) {
 574             berrno be;
 575             Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
 576             Qmsg1(jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 577                   be.bstrerror());
 578             goto bail_out;
 579          }
 580          size += nbytes;
 581          if ((++count & 0x3F) == 0) {
 582             last = size;
 583          }
 584       }
 585       if (!job_canceled(jcr)) {
 586          update_attribute(jcr, msg, msglen);
 587          if (job_canceled(jcr)) {
 588             goto bail_out;
 589          }
 590       }
 591    }
 592    if (ferror(spool_fd)) {
 593       berrno be;
 594       Qmsg1(jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 595             be.bstrerror());
 596       goto bail_out;
 597    }
 598    ret = true;
 599
 600 bail_out:
 601    if (spool_fd) {
 602       fclose(spool_fd);
 603    }
 604
 605    if (job_canceled(jcr)) {
 606       cancel_storage_daemon_job(jcr);
 607    }
 608
 609    free_pool_memory(msg);
 610    Dmsg1(100, "End despool_attributes_from_file ret=%i\n", ret);
 611    return ret;
 612 }