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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-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 John Walker.
  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  *   Version $Id$
  41  */
  42
  43 #include "bacula.h"
  44 #include "dird.h"
  45 #include "findlib/find.h"
  46
  47 /*
  48  * Handle catalog request
  49  *  For now, we simply return next Volume to be used
  50  */
  51
  52 /* Requests from the Storage daemon */
  53 static char Find_media[] = "CatReq Job=%127s FindMedia=%d pool_name=%127s media_type=%127s\n";
  54 static char Get_Vol_Info[] = "CatReq Job=%127s GetVolInfo VolName=%127s write=%d\n";
  55
  56 static char Update_media[] = "CatReq Job=%127s UpdateMedia VolName=%s"
  57    " VolJobs=%u VolFiles=%u VolBlocks=%u VolBytes=%lld VolMounts=%u"
  58    " VolErrors=%u VolWrites=%u MaxVolBytes=%lld EndTime=%lld VolStatus=%10s"
  59    " Slot=%d relabel=%d InChanger=%d VolReadTime=%lld VolWriteTime=%lld"
  60    " VolFirstWritten=%lld VolParts=%u\n";
  61
  62 static char Create_job_media[] = "CatReq Job=%127s CreateJobMedia "
  63    " FirstIndex=%u LastIndex=%u StartFile=%u EndFile=%u "
  64    " StartBlock=%u EndBlock=%u Copy=%d Strip=%d MediaId=%" lld "\n";
  65
  66
  67 /* Responses  sent to Storage daemon */
  68 static char OK_media[] = "1000 OK VolName=%s VolJobs=%u VolFiles=%u"
  69    " VolBlocks=%u VolBytes=%s VolMounts=%u VolErrors=%u VolWrites=%u"
  70    " MaxVolBytes=%s VolCapacityBytes=%s VolStatus=%s Slot=%d"
  71    " MaxVolJobs=%u MaxVolFiles=%u InChanger=%d VolReadTime=%s"
  72    " VolWriteTime=%s EndFile=%u EndBlock=%u VolParts=%u LabelType=%d"
  73    " MediaId=%s\n";
  74
  75 static char OK_create[] = "1000 OK CreateJobMedia\n";
  76
  77
  78 static int send_volume_info_to_storage_daemon(JCR *jcr, BSOCK *sd, MEDIA_DBR *mr)
  79 {
  80    int stat;
  81    char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50];
  82
  83    jcr->MediaId = mr->MediaId;
  84    pm_strcpy(jcr->VolumeName, mr->VolumeName);
  85    bash_spaces(mr->VolumeName);
  86    stat = bnet_fsend(sd, OK_media, mr->VolumeName, mr->VolJobs,
  87       mr->VolFiles, mr->VolBlocks, edit_uint64(mr->VolBytes, ed1),
  88       mr->VolMounts, mr->VolErrors, mr->VolWrites,
  89       edit_uint64(mr->MaxVolBytes, ed2),
  90       edit_uint64(mr->VolCapacityBytes, ed3),
  91       mr->VolStatus, mr->Slot, mr->MaxVolJobs, mr->MaxVolFiles,
  92       mr->InChanger,
  93       edit_int64(mr->VolReadTime, ed4),
  94       edit_int64(mr->VolWriteTime, ed5),
  95       mr->EndFile, mr->EndBlock,
  96       mr->VolParts,
  97       mr->LabelType,
  98       edit_uint64(mr->MediaId, ed6));
  99    unbash_spaces(mr->VolumeName);
 100    Dmsg2(100, "Vol Info for %s: %s", jcr->Job, sd->msg);
 101    return stat;
 102 }
 103
 104 void catalog_request(JCR *jcr, BSOCK *bs)
 105 {
 106    MEDIA_DBR mr, sdmr;
 107    JOBMEDIA_DBR jm;
 108    char Job[MAX_NAME_LENGTH];
 109    char pool_name[MAX_NAME_LENGTH];
 110    int index, ok, label, writing;
 111    POOLMEM *omsg;
 112    POOL_DBR pr;
 113    uint32_t Stripe;
 114    uint64_t MediaId;
 115    utime_t VolFirstWritten;
 116    utime_t VolLastWritten;
 117
 118    memset(&mr, 0, sizeof(mr));
 119    memset(&sdmr, 0, sizeof(sdmr));
 120    memset(&jm, 0, sizeof(jm));
 121    Dsm_check(1);
 122
 123    /*
 124     * Request to find next appendable Volume for this Job
 125     */
 126    Dmsg1(100, "catreq %s", bs->msg);
 127    if (!jcr->db) {
 128       omsg = get_memory(bs->msglen+1);
 129       pm_strcpy(omsg, bs->msg);
 130       bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
 131       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request; DB not open: %s"), omsg);
 132       free_memory(omsg);
 133       return;
 134    }
 135    /*
 136     * Find next appendable medium for SD
 137     */
 138    if (sscanf(bs->msg, Find_media, &Job, &index, &pool_name, &mr.MediaType) == 4) {
 139       memset(&pr, 0, sizeof(pr));
 140       bstrncpy(pr.Name, pool_name, sizeof(pr.Name));
 141       unbash_spaces(pr.Name);
 142       ok = db_get_pool_record(jcr, jcr->db, &pr);
 143       if (ok) {
 144          mr.PoolId = pr.PoolId;
 145          mr.StorageId = jcr->wstore->StorageId;
 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       /* Check if the volume has been written by the job,
 271        * and update the LastWritten field if needed */
 272       if (mr.VolBlocks != sdmr.VolBlocks && VolLastWritten != 0) {
 273          mr.LastWritten = VolLastWritten;
 274       }
 275       /* Copy updated values to original media record */
 276       mr.VolJobs      = sdmr.VolJobs;
 277       mr.VolFiles     = sdmr.VolFiles;
 278       mr.VolBlocks    = sdmr.VolBlocks;
 279       mr.VolBytes     = sdmr.VolBytes;
 280       mr.VolMounts    = sdmr.VolMounts;
 281       mr.VolErrors    = sdmr.VolErrors;
 282       mr.VolWrites    = sdmr.VolWrites;
 283       mr.Slot         = sdmr.Slot;
 284       mr.InChanger    = sdmr.InChanger;
 285       mr.VolReadTime  = sdmr.VolReadTime;
 286       mr.VolWriteTime = sdmr.VolWriteTime;
 287       mr.VolParts     = sdmr.VolParts;
 288       bstrncpy(mr.VolStatus, sdmr.VolStatus, sizeof(mr.VolStatus));
 289       if (jcr->wstore && jcr->wstore->StorageId) {
 290          mr.StorageId = jcr->wstore->StorageId;
 291       }
 292
 293       Dmsg2(400, "db_update_media_record. Stat=%s Vol=%s\n", mr.VolStatus, mr.VolumeName);
 294       /*
 295        * Update the database, then before sending the response to the
 296        *  SD, check if the Volume has expired.
 297        */
 298       if (!db_update_media_record(jcr, jcr->db, &mr)) {
 299          Jmsg(jcr, M_FATAL, 0, _("Catalog error updating Media record. %s"),
 300             db_strerror(jcr->db));
 301          bs->fsend(_("1993 Update Media error\n"));
 302          Dmsg0(400, "send error\n");
 303       } else {
 304          (void)has_volume_expired(jcr, &mr);
 305          send_volume_info_to_storage_daemon(jcr, bs, &mr);
 306       }
 307       db_unlock(jcr->db);
 308
 309    /*
 310     * Request to create a JobMedia record
 311     */
 312    } else if (sscanf(bs->msg, Create_job_media, &Job,
 313       &jm.FirstIndex, &jm.LastIndex, &jm.StartFile, &jm.EndFile,
 314       &jm.StartBlock, &jm.EndBlock, &jm.Copy, &Stripe, &MediaId) == 10) {
 315
 316       if (jcr->mig_jcr) {
 317          jm.JobId = jcr->mig_jcr->JobId;
 318       } else {
 319          jm.JobId = jcr->JobId;
 320       }
 321       jm.MediaId = MediaId;
 322       Dmsg6(400, "create_jobmedia JobId=%d MediaId=%d SF=%d EF=%d FI=%d LI=%d\n",
 323          jm.JobId, jm.MediaId, jm.StartFile, jm.EndFile, jm.FirstIndex, jm.LastIndex);
 324       if (!db_create_jobmedia_record(jcr, jcr->db, &jm)) {
 325          Jmsg(jcr, M_FATAL, 0, _("Catalog error creating JobMedia record. %s"),
 326             db_strerror(jcr->db));
 327          bs->fsend(_("1991 Update JobMedia error\n"));
 328       } else {
 329          Dmsg0(400, "JobMedia record created\n");
 330          bs->fsend(OK_create);
 331       }
 332
 333    } else {
 334       omsg = get_memory(bs->msglen+1);
 335       pm_strcpy(omsg, bs->msg);
 336       bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
 337       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request: %s"), omsg);
 338       free_memory(omsg);
 339    }
 340    Dmsg1(400, ">CatReq response: %s", bs->msg);
 341    Dmsg1(400, "Leave catreq jcr 0x%x\n", jcr);
 342    return;
 343 }
 344
 345 /*
 346  * Update File Attributes in the catalog with data
 347  *  sent by the Storage daemon.  Note, we receive the whole
 348  *  attribute record, but we select out only the stat packet,
 349  *  VolSessionId, VolSessionTime, FileIndex, file type, and
 350  *  file name to store in the catalog.
 351  */
 352 void catalog_update(JCR *jcr, BSOCK *bs)
 353 {
 354    unser_declare;
 355    uint32_t VolSessionId, VolSessionTime;
 356    int32_t Stream;
 357    uint32_t FileIndex;
 358    uint32_t data_len;
 359    char *p;
 360    int filetype;
 361    int len;
 362    char *fname, *attr;
 363    ATTR_DBR *ar = NULL;
 364    POOLMEM *omsg;
 365
 366    Dsm_check(1);
 367    if (job_canceled(jcr) || !jcr->pool->catalog_files) {
 368       goto bail_out;                  /* user disabled cataloging */
 369    }
 370    if (!jcr->db) {
 371       omsg = get_memory(bs->msglen+1);
 372       pm_strcpy(omsg, bs->msg);
 373       bs->fsend(_("1991 Invalid Catalog Update: %s"), omsg);
 374       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog Update; DB not open: %s"), omsg);
 375       free_memory(omsg);
 376       goto bail_out;
 377    }
 378
 379    /* Start transaction allocates jcr->attr and jcr->ar if needed */
 380    db_start_transaction(jcr, jcr->db);     /* start transaction if not already open */
 381    ar = jcr->ar;
 382
 383    /* Start by scanning directly in the message buffer to get Stream
 384     *  there may be a cached attr so we cannot yet write into
 385     *  jcr->attr or jcr->ar
 386     */
 387    p = bs->msg;
 388    skip_nonspaces(&p);                /* UpdCat */
 389    skip_spaces(&p);
 390    skip_nonspaces(&p);                /* Job=nnn */
 391    skip_spaces(&p);
 392    skip_nonspaces(&p);                /* FileAttributes */
 393    p += 1;
 394    unser_begin(p, 0);
 395    unser_uint32(VolSessionId);
 396    unser_uint32(VolSessionTime);
 397    unser_int32(FileIndex);
 398    unser_int32(Stream);
 399    unser_uint32(data_len);
 400    p += unser_length(p);
 401
 402    Dmsg1(400, "UpdCat msg=%s\n", bs->msg);
 403    Dmsg5(400, "UpdCat VolSessId=%d VolSessT=%d FI=%d Strm=%d data_len=%d\n",
 404       VolSessionId, VolSessionTime, FileIndex, Stream, data_len);
 405
 406    if (Stream == STREAM_UNIX_ATTRIBUTES || Stream == STREAM_UNIX_ATTRIBUTES_EX) {
 407       if (jcr->cached_attribute) {
 408          Dmsg2(400, "Cached attr. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 409          if (!db_create_file_attributes_record(jcr, jcr->db, ar)) {
 410             Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 411          }
 412       }
 413       /* Any cached attr is flushed so we can reuse jcr->attr and jcr->ar */
 414       jcr->attr = check_pool_memory_size(jcr->attr, bs->msglen);
 415       memcpy(jcr->attr, bs->msg, bs->msglen);
 416       p = jcr->attr - bs->msg + p;    /* point p into jcr->attr */
 417       skip_nonspaces(&p);             /* skip FileIndex */
 418       skip_spaces(&p);
 419       filetype = str_to_int32(p);     /* TODO: choose between unserialize and str_to_int32 */
 420       skip_nonspaces(&p);             /* skip FileType */
 421       skip_spaces(&p);
 422       fname = p;
 423       len = strlen(fname);        /* length before attributes */
 424       attr = &fname[len+1];
 425
 426       Dmsg2(400, "dird<stored: stream=%d %s\n", Stream, fname);
 427       Dmsg1(400, "dird<stored: attr=%s\n", attr);
 428       ar->attr = attr;
 429       ar->fname = fname;
 430       if (filetype == FT_DELETED) {
 431          ar->FileIndex = 0;     /* special value */
 432       } else {
 433          ar->FileIndex = FileIndex;
 434       }
 435       ar->Stream = Stream;
 436       ar->link = NULL;
 437       if (jcr->mig_jcr) {
 438          ar->JobId = jcr->mig_jcr->JobId;
 439       } else {
 440          ar->JobId = jcr->JobId;
 441       }
 442       ar->Digest = NULL;
 443       ar->DigestType = CRYPTO_DIGEST_NONE;
 444       jcr->cached_attribute = true;
 445
 446       Dmsg2(400, "dird<filed: stream=%d %s\n", Stream, fname);
 447       Dmsg1(400, "dird<filed: attr=%s\n", attr);
 448
 449    } else if (crypto_digest_stream_type(Stream) != CRYPTO_DIGEST_NONE) {
 450       fname = p;
 451       if (ar->FileIndex != FileIndex) {
 452          Jmsg(jcr, M_WARNING, 0, _("Got %s but not same File as attributes\n"), stream_to_ascii(Stream));
 453       } else {
 454          /* Update digest in catalog */
 455          char digestbuf[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
 456          int len = 0;
 457          int type = CRYPTO_DIGEST_NONE;
 458
 459          switch(Stream) {
 460          case STREAM_MD5_DIGEST:
 461             len = CRYPTO_DIGEST_MD5_SIZE;
 462             type = CRYPTO_DIGEST_MD5;
 463             break;
 464          case STREAM_SHA1_DIGEST:
 465             len = CRYPTO_DIGEST_SHA1_SIZE;
 466             type = CRYPTO_DIGEST_SHA1;
 467             break;
 468          case STREAM_SHA256_DIGEST:
 469             len = CRYPTO_DIGEST_SHA256_SIZE;
 470             type = CRYPTO_DIGEST_SHA256;
 471             break;
 472          case STREAM_SHA512_DIGEST:
 473             len = CRYPTO_DIGEST_SHA512_SIZE;
 474             type = CRYPTO_DIGEST_SHA512;
 475             break;
 476          default:
 477             /* Never reached ... */
 478             Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. Unsupported digest stream type: %d"),
 479                  Stream);
 480          }
 481
 482          bin_to_base64(digestbuf, sizeof(digestbuf), fname, len, true);
 483          Dmsg3(400, "DigestLen=%d Digest=%s type=%d\n", strlen(digestbuf), digestbuf, Stream);
 484          if (jcr->cached_attribute) {
 485             ar->Digest = digestbuf;
 486             ar->DigestType = type;
 487             Dmsg2(400, "Cached attr with digest. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 488             if (!db_create_file_attributes_record(jcr, jcr->db, ar)) {
 489                Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 490             }
 491             jcr->cached_attribute = false;
 492          } else {
 493             if (!db_add_digest_to_file_record(jcr, jcr->db, ar->FileId, digestbuf, type)) {
 494                Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. %s"),
 495                   db_strerror(jcr->db));
 496             }
 497          }
 498       }
 499    }
 500 bail_out:
 501    if (job_canceled(jcr)) {
 502       cancel_storage_daemon_job(jcr);
 503    }
 504 }