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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2007 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=%d VolStatus=%10s"
  59    " Slot=%d relabel=%d InChanger=%d VolReadTime=%s VolWriteTime=%s"
  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    char ed_vrt[50], ed_vwt[50];
 107    MEDIA_DBR mr, sdmr;
 108    JOBMEDIA_DBR jm;
 109    char Job[MAX_NAME_LENGTH];
 110    char pool_name[MAX_NAME_LENGTH];
 111    int index, ok, label, writing;
 112    POOLMEM *omsg;
 113    POOL_DBR pr;
 114    uint32_t Stripe;
 115    uint64_t MediaId;
 116    utime_t VolFirstWritten;
 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       &sdmr.LastWritten, &sdmr.VolStatus, &sdmr.Slot, &label, &sdmr.InChanger,
 222       ed_vrt, ed_vwt, &VolFirstWritten,
 223       &sdmr.VolParts) == 19) {
 224
 225       sdmr.VolReadTime = str_to_int64(ed_vrt);
 226       sdmr.VolWriteTime = str_to_int64(ed_vwt);
 227
 228       db_lock(jcr->db);
 229       Dmsg3(400, "Update media %s oldStat=%s newStat=%s\n", sdmr.VolumeName,
 230          mr.VolStatus, sdmr.VolStatus);
 231       bstrncpy(mr.VolumeName, sdmr.VolumeName, sizeof(mr.VolumeName)); /* copy Volume name */
 232       unbash_spaces(mr.VolumeName);
 233       if (!db_get_media_record(jcr, jcr->db, &mr)) {
 234          Jmsg(jcr, M_ERROR, 0, _("Unable to get Media record for Volume %s: ERR=%s\n"),
 235               mr.VolumeName, db_strerror(jcr->db));
 236          bs->fsend(_("1991 Catalog Request for vol=%s failed: %s"),
 237             mr.VolumeName, db_strerror(jcr->db));
 238          db_unlock(jcr->db);
 239          return;
 240       }
 241       /* Set first written time if this is first job */
 242       if (mr.FirstWritten == 0) {
 243          if (VolFirstWritten == 0) {
 244             mr.FirstWritten = jcr->start_time;   /* use Job start time as first write */
 245          } else {
 246             mr.FirstWritten = VolFirstWritten;
 247          }
 248          mr.set_first_written = true;
 249       }
 250       /* If we just labeled the tape set time */
 251       if (label || mr.LabelDate == 0) {
 252          mr.LabelDate = jcr->start_time;
 253          mr.set_label_date = true;
 254          if (mr.InitialWrite == 0) {
 255             mr.InitialWrite = jcr->start_time;
 256          }
 257          Dmsg2(400, "label=%d labeldate=%d\n", label, mr.LabelDate);
 258       } else {
 259          /*
 260           * Insanity check for VolFiles get set to a smaller value
 261           */
 262          if (sdmr.VolFiles < mr.VolFiles) {
 263             Jmsg(jcr, M_FATAL, 0, _("Volume Files at %u being set to %u"
 264                  " for Volume \"%s\". This is incorrect.\n"),
 265                mr.VolFiles, sdmr.VolFiles, mr.VolumeName);
 266             bs->fsend(_("1992 Update Media error. VolFiles=%u, CatFiles=%u\n"),
 267                sdmr.VolFiles, mr.VolFiles);
 268             db_unlock(jcr->db);
 269             return;
 270          }
 271       }
 272       Dmsg2(400, "Update media: BefVolJobs=%u After=%u\n", mr.VolJobs, sdmr.VolJobs);
 273       /* Check if the volume has been written by the job,
 274        * and update the LastWritten field if needed */
 275       if (mr.VolBlocks != sdmr.VolBlocks) {
 276          mr.LastWritten = sdmr.LastWritten;
 277       }
 278       /* Copy updated values to original media record */
 279       mr.VolJobs      = sdmr.VolJobs;
 280       mr.VolFiles     = sdmr.VolFiles;
 281       mr.VolBlocks    = sdmr.VolBlocks;
 282       mr.VolBytes     = sdmr.VolBytes;
 283       mr.VolMounts    = sdmr.VolMounts;
 284       mr.VolErrors    = sdmr.VolErrors;
 285       mr.VolWrites    = sdmr.VolWrites;
 286       mr.Slot         = sdmr.Slot;
 287       mr.InChanger    = sdmr.InChanger;
 288       mr.VolReadTime  = sdmr.VolReadTime;
 289       mr.VolWriteTime = sdmr.VolWriteTime;
 290       mr.VolParts     = sdmr.VolParts;
 291       bstrncpy(mr.VolStatus, sdmr.VolStatus, sizeof(mr.VolStatus));
 292       /*
 293        * Update to point to the last device used to write the Volume.
 294        *   However, do so only if we are writing the tape, i.e.
 295        *   the number of VolBlocks has increased.
 296        */
 297       if (jcr->wstore && jcr->wstore->StorageId && mr.VolBlocks != sdmr.VolBlocks) {
 298          mr.StorageId = jcr->wstore->StorageId;
 299       }
 300
 301       Dmsg2(400, "db_update_media_record. Stat=%s Vol=%s\n", mr.VolStatus, mr.VolumeName);
 302       /*
 303        * Update the database, then before sending the response to the
 304        *  SD, check if the Volume has expired.
 305        */
 306       if (!db_update_media_record(jcr, jcr->db, &mr)) {
 307          Jmsg(jcr, M_FATAL, 0, _("Catalog error updating Media record. %s"),
 308             db_strerror(jcr->db));
 309          bs->fsend(_("1993 Update Media error\n"));
 310          Dmsg0(400, "send error\n");
 311       } else {
 312          (void)has_volume_expired(jcr, &mr);
 313          send_volume_info_to_storage_daemon(jcr, bs, &mr);
 314       }
 315       db_unlock(jcr->db);
 316
 317    /*
 318     * Request to create a JobMedia record
 319     */
 320    } else if (sscanf(bs->msg, Create_job_media, &Job,
 321       &jm.FirstIndex, &jm.LastIndex, &jm.StartFile, &jm.EndFile,
 322       &jm.StartBlock, &jm.EndBlock, &jm.Copy, &Stripe, &MediaId) == 10) {
 323
 324       if (jcr->mig_jcr) {
 325          jm.JobId = jcr->mig_jcr->JobId;
 326       } else {
 327          jm.JobId = jcr->JobId;
 328       }
 329       jm.MediaId = MediaId;
 330       Dmsg6(400, "create_jobmedia JobId=%d MediaId=%d SF=%d EF=%d FI=%d LI=%d\n",
 331          jm.JobId, jm.MediaId, jm.StartFile, jm.EndFile, jm.FirstIndex, jm.LastIndex);
 332       if (!db_create_jobmedia_record(jcr, jcr->db, &jm)) {
 333          Jmsg(jcr, M_FATAL, 0, _("Catalog error creating JobMedia record. %s"),
 334             db_strerror(jcr->db));
 335          bs->fsend(_("1991 Update JobMedia error\n"));
 336       } else {
 337          Dmsg0(400, "JobMedia record created\n");
 338          bs->fsend(OK_create);
 339       }
 340
 341    } else {
 342       omsg = get_memory(bs->msglen+1);
 343       pm_strcpy(omsg, bs->msg);
 344       bs->fsend(_("1990 Invalid Catalog Request: %s"), omsg);
 345       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request: %s"), omsg);
 346       free_memory(omsg);
 347    }
 348    Dmsg1(400, ">CatReq response: %s", bs->msg);
 349    Dmsg1(400, "Leave catreq jcr 0x%x\n", jcr);
 350    return;
 351 }
 352
 353 /*
 354  * Update File Attributes in the catalog with data
 355  *  sent by the Storage daemon.  Note, we receive the whole
 356  *  attribute record, but we select out only the stat packet,
 357  *  VolSessionId, VolSessionTime, FileIndex, and file name
 358  *  to store in the catalog.
 359  */
 360 void catalog_update(JCR *jcr, BSOCK *bs)
 361 {
 362    unser_declare;
 363    uint32_t VolSessionId, VolSessionTime;
 364    int32_t Stream;
 365    uint32_t FileIndex;
 366    uint32_t data_len;
 367    char *p;
 368    int len;
 369    char *fname, *attr;
 370    ATTR_DBR *ar = NULL;
 371    POOLMEM *omsg;
 372
 373    Dsm_check(1);
 374    if (job_canceled(jcr) || !jcr->pool->catalog_files) {
 375       goto bail_out;                  /* user disabled cataloging */
 376    }
 377    if (!jcr->db) {
 378       omsg = get_memory(bs->msglen+1);
 379       pm_strcpy(omsg, bs->msg);
 380       bs->fsend(_("1991 Invalid Catalog Update: %s"), omsg);
 381       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog Update; DB not open: %s"), omsg);
 382       free_memory(omsg);
 383       goto bail_out;
 384    }
 385
 386    /* Start transaction allocates jcr->attr and jcr->ar if needed */
 387    db_start_transaction(jcr, jcr->db);     /* start transaction if not already open */
 388    ar = jcr->ar;
 389
 390    /* Start by scanning directly in the message buffer to get Stream
 391     *  there may be a cached attr so we cannot yet write into
 392     *  jcr->attr or jcr->ar
 393     */
 394    p = bs->msg;
 395    skip_nonspaces(&p);                /* UpdCat */
 396    skip_spaces(&p);
 397    skip_nonspaces(&p);                /* Job=nnn */
 398    skip_spaces(&p);
 399    skip_nonspaces(&p);                /* FileAttributes */
 400    p += 1;
 401    unser_begin(p, 0);
 402    unser_uint32(VolSessionId);
 403    unser_uint32(VolSessionTime);
 404    unser_int32(FileIndex);
 405    unser_int32(Stream);
 406    unser_uint32(data_len);
 407    p += unser_length(p);
 408
 409    Dmsg1(400, "UpdCat msg=%s\n", bs->msg);
 410    Dmsg5(400, "UpdCat VolSessId=%d VolSessT=%d FI=%d Strm=%d data_len=%d\n",
 411       VolSessionId, VolSessionTime, FileIndex, Stream, data_len);
 412
 413    if (Stream == STREAM_UNIX_ATTRIBUTES || Stream == STREAM_UNIX_ATTRIBUTES_EX) {
 414       if (jcr->cached_attribute) {
 415          Dmsg2(400, "Cached attr. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 416          if (!db_create_file_attributes_record(jcr, jcr->db, ar)) {
 417             Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 418          }
 419       }
 420       /* Any cached attr is flushed so we can reuse jcr->attr and jcr->ar */
 421       jcr->attr = check_pool_memory_size(jcr->attr, bs->msglen);
 422       memcpy(jcr->attr, bs->msg, bs->msglen);
 423       p = jcr->attr - bs->msg + p;    /* point p into jcr->attr */
 424       skip_nonspaces(&p);             /* skip FileIndex */
 425       skip_spaces(&p);
 426       skip_nonspaces(&p);             /* skip FileType */
 427       skip_spaces(&p);
 428       fname = p;
 429       len = strlen(fname);        /* length before attributes */
 430       attr = &fname[len+1];
 431
 432       Dmsg2(400, "dird<stored: stream=%d %s\n", Stream, fname);
 433       Dmsg1(400, "dird<stored: attr=%s\n", attr);
 434       ar->attr = attr;
 435       ar->fname = fname;
 436       ar->FileIndex = FileIndex;
 437       ar->Stream = Stream;
 438       ar->link = NULL;
 439       if (jcr->mig_jcr) {
 440          ar->JobId = jcr->mig_jcr->JobId;
 441       } else {
 442          ar->JobId = jcr->JobId;
 443       }
 444       ar->Digest = NULL;
 445       ar->DigestType = CRYPTO_DIGEST_NONE;
 446       jcr->cached_attribute = true;
 447
 448       Dmsg2(400, "dird<filed: stream=%d %s\n", Stream, fname);
 449       Dmsg1(400, "dird<filed: attr=%s\n", attr);
 450
 451    } else if (crypto_digest_stream_type(Stream) != CRYPTO_DIGEST_NONE) {
 452       fname = p;
 453       if (ar->FileIndex != FileIndex) {
 454          Jmsg(jcr, M_WARNING, 0, _("Got %s but not same File as attributes\n"), stream_to_ascii(Stream));
 455       } else {
 456          /* Update digest in catalog */
 457          char digestbuf[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
 458          int len = 0;
 459          int type = CRYPTO_DIGEST_NONE;
 460
 461          switch(Stream) {
 462          case STREAM_MD5_DIGEST:
 463             len = CRYPTO_DIGEST_MD5_SIZE;
 464             type = CRYPTO_DIGEST_MD5;
 465             break;
 466          case STREAM_SHA1_DIGEST:
 467             len = CRYPTO_DIGEST_SHA1_SIZE;
 468             type = CRYPTO_DIGEST_SHA1;
 469             break;
 470          case STREAM_SHA256_DIGEST:
 471             len = CRYPTO_DIGEST_SHA256_SIZE;
 472             type = CRYPTO_DIGEST_SHA256;
 473             break;
 474          case STREAM_SHA512_DIGEST:
 475             len = CRYPTO_DIGEST_SHA512_SIZE;
 476             type = CRYPTO_DIGEST_SHA512;
 477             break;
 478          default:
 479             /* Never reached ... */
 480             Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. Unsupported digest stream type: %d"),
 481                  Stream);
 482          }
 483
 484          bin_to_base64(digestbuf, sizeof(digestbuf), fname, len, true);
 485          Dmsg3(400, "DigestLen=%d Digest=%s type=%d\n", strlen(digestbuf), digestbuf, Stream);
 486          if (jcr->cached_attribute) {
 487             ar->Digest = digestbuf;
 488             ar->DigestType = type;
 489             Dmsg2(400, "Cached attr with digest. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 490             if (!db_create_file_attributes_record(jcr, jcr->db, ar)) {
 491                Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), 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 bail_out:
 503    if (job_canceled(jcr)) {
 504       cancel_storage_daemon_job(jcr);
 505    }
 506 }