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

   1 /*
   2  *
   3  *   Bacula Director -- catreq.c -- handles the message channel
   4  *    catalog request from the Storage daemon.
   5  *
   6  *     Kern Sibbald, March MMI
   7  *
   8  *    This routine runs as a thread and must be thread reentrant.
   9  *
  10  *  Basic tasks done here:
  11  *      Handle Catalog services.
  12  *
  13  *   Version $Id$
  14  */
  15 /*
  16    Bacula® - The Network Backup Solution
  17
  18    Copyright (C) 2001-2006 Free Software Foundation Europe e.V.
  19
  20    The main author of Bacula is Kern Sibbald, with contributions from
  21    many others, a complete list can be found in the file AUTHORS.
  22    This program is Free Software; you can redistribute it and/or
  23    modify it under the terms of version two of the GNU General Public
  24    License as published by the Free Software Foundation plus additions
  25    that are listed in the file LICENSE.
  26
  27    This program is distributed in the hope that it will be useful, but
  28    WITHOUT ANY WARRANTY; without even the implied warranty of
  29    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  30    General Public License for more details.
  31
  32    You should have received a copy of the GNU General Public License
  33    along with this program; if not, write to the Free Software
  34    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  35    02110-1301, USA.
  36
  37    Bacula® is a registered trademark of John Walker.
  38    The licensor of Bacula is the Free Software Foundation Europe
  39    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  40    Switzerland, email:ftf@fsfeurope.org.
  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=%" 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
 117    memset(&mr, 0, sizeof(mr));
 118    memset(&sdmr, 0, sizeof(sdmr));
 119    memset(&jm, 0, sizeof(jm));
 120
 121    /*
 122     * Request to find next appendable Volume for this Job
 123     */
 124    Dmsg1(100, "catreq %s", bs->msg);
 125    if (!jcr->db) {
 126       omsg = get_memory(bs->msglen+1);
 127       pm_strcpy(omsg, bs->msg);
 128       bnet_fsend(bs, _("1990 Invalid Catalog Request: %s"), omsg);
 129       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request; DB not open: %s"), omsg);
 130       free_memory(omsg);
 131       return;
 132    }
 133    /*
 134     * Find next appendable medium for SD
 135     */
 136    if (sscanf(bs->msg, Find_media, &Job, &index, &pool_name, &mr.MediaType) == 4) {
 137       memset(&pr, 0, sizeof(pr));
 138       bstrncpy(pr.Name, pool_name, sizeof(pr.Name));
 139       unbash_spaces(pr.Name);
 140       ok = db_get_pool_record(jcr, jcr->db, &pr);
 141       if (ok) {
 142          mr.PoolId = pr.PoolId;
 143          mr.StorageId = jcr->wstore->StorageId;
 144          ok = find_next_volume_for_append(jcr, &mr, index, fnv_create_vol, fnv_prune);
 145          Dmsg3(050, "find_media ok=%d idx=%d vol=%s\n", ok, index, mr.VolumeName);
 146       }
 147       /*
 148        * Send Find Media response to Storage daemon
 149        */
 150       if (ok) {
 151          send_volume_info_to_storage_daemon(jcr, bs, &mr);
 152       } else {
 153          bnet_fsend(bs, _("1901 No Media.\n"));
 154          Dmsg0(500, "1901 No Media.\n");
 155       }
 156
 157    /*
 158     * Request to find specific Volume information
 159     */
 160    } else if (sscanf(bs->msg, Get_Vol_Info, &Job, &mr.VolumeName, &writing) == 3) {
 161       Dmsg1(100, "CatReq GetVolInfo Vol=%s\n", mr.VolumeName);
 162       /*
 163        * Find the Volume
 164        */
 165       unbash_spaces(mr.VolumeName);
 166       if (db_get_media_record(jcr, jcr->db, &mr)) {
 167          const char *reason = NULL;           /* detailed reason for rejection */
 168          /*
 169           * If we are reading, accept any volume (reason == NULL)
 170           * If we are writing, check if the Volume is valid
 171           *   for this job, and do a recycle if necessary
 172           */
 173          if (writing) {
 174             /*
 175              * SD wants to write this Volume, so make
 176              *   sure it is suitable for this job, i.e.
 177              *   Pool matches, and it is either Append or Recycle
 178              *   and Media Type matches and Pool allows any volume.
 179              */
 180             if (mr.PoolId != jcr->jr.PoolId) {
 181                reason = _("not in Pool");
 182             } else if (strcmp(mr.MediaType, jcr->wstore->media_type) != 0) {
 183                reason = _("not correct MediaType");
 184             } else {
 185                /*
 186                 * Now try recycling if necessary
 187                 *   reason set non-NULL if we cannot use it
 188                 */
 189                check_if_volume_valid_or_recyclable(jcr, &mr, &reason);
 190             }
 191          }
 192          if (!reason && mr.Enabled != 1) {
 193             reason = _("is not Enabled");
 194          }
 195          if (reason == NULL) {
 196             /*
 197              * Send Find Media response to Storage daemon
 198              */
 199             send_volume_info_to_storage_daemon(jcr, bs, &mr);
 200          } else {
 201             /* Not suitable volume */
 202             bnet_fsend(bs, _("1998 Volume \"%s\" status is %s, %s.\n"), mr.VolumeName,
 203                mr.VolStatus, reason);
 204          }
 205
 206       } else {
 207          bnet_fsend(bs, _("1997 Volume \"%s\" not in catalog.\n"), mr.VolumeName);
 208          Dmsg1(100, "1997 Volume \"%s\" not in catalog.\n", mr.VolumeName);
 209       }
 210
 211    /*
 212     * Request to update Media record. Comes typically at the end
 213     *  of a Storage daemon Job Session, when labeling/relabeling a
 214     *  Volume, or when an EOF mark is written.
 215     */
 216    } else if (sscanf(bs->msg, Update_media, &Job, &sdmr.VolumeName,
 217       &sdmr.VolJobs, &sdmr.VolFiles, &sdmr.VolBlocks, &sdmr.VolBytes,
 218       &sdmr.VolMounts, &sdmr.VolErrors, &sdmr.VolWrites, &sdmr.MaxVolBytes,
 219       &sdmr.LastWritten, &sdmr.VolStatus, &sdmr.Slot, &label, &sdmr.InChanger,
 220       &sdmr.VolReadTime, &sdmr.VolWriteTime, &VolFirstWritten,
 221       &sdmr.VolParts) == 19) {
 222
 223       db_lock(jcr->db);
 224       Dmsg3(400, "Update media %s oldStat=%s newStat=%s\n", sdmr.VolumeName,
 225          mr.VolStatus, sdmr.VolStatus);
 226       bstrncpy(mr.VolumeName, sdmr.VolumeName, sizeof(mr.VolumeName)); /* copy Volume name */
 227       unbash_spaces(mr.VolumeName);
 228       if (!db_get_media_record(jcr, jcr->db, &mr)) {
 229          Jmsg(jcr, M_ERROR, 0, _("Unable to get Media record for Volume %s: ERR=%s\n"),
 230               mr.VolumeName, db_strerror(jcr->db));
 231          bnet_fsend(bs, _("1991 Catalog Request for vol=%s failed: %s"),
 232             mr.VolumeName, db_strerror(jcr->db));
 233          db_unlock(jcr->db);
 234          return;
 235       }
 236       /* Set first written time if this is first job */
 237       if (mr.FirstWritten == 0) {
 238          if (VolFirstWritten == 0) {
 239             mr.FirstWritten = jcr->start_time;   /* use Job start time as first write */
 240          } else {
 241             mr.FirstWritten = VolFirstWritten;
 242          }
 243          mr.set_first_written = true;
 244       }
 245       /* If we just labeled the tape set time */
 246       if (label || mr.LabelDate == 0) {
 247          mr.LabelDate = jcr->start_time;
 248          mr.set_label_date = true;
 249          if (mr.InitialWrite == 0) {
 250             mr.InitialWrite = jcr->start_time;
 251          }
 252          Dmsg2(400, "label=%d labeldate=%d\n", label, mr.LabelDate);
 253       } else {
 254          /*
 255           * Insanity check for VolFiles get set to a smaller value
 256           */
 257          if (sdmr.VolFiles < mr.VolFiles) {
 258             Jmsg(jcr, M_FATAL, 0, _("Volume Files at %u being set to %u"
 259                  " for Volume \"%s\". This is incorrect.\n"),
 260                mr.VolFiles, sdmr.VolFiles, mr.VolumeName);
 261             bnet_fsend(bs, _("1992 Update Media error. VolFiles=%u, CatFiles=%u\n"),
 262                sdmr.VolFiles, mr.VolFiles);
 263             db_unlock(jcr->db);
 264             return;
 265          }
 266       }
 267       Dmsg2(400, "Update media: BefVolJobs=%u After=%u\n", mr.VolJobs, sdmr.VolJobs);
 268       /* Copy updated values to original media record */
 269       mr.VolJobs      = sdmr.VolJobs;
 270       mr.VolFiles     = sdmr.VolFiles;
 271       mr.VolBlocks    = sdmr.VolBlocks;
 272       mr.VolBytes     = sdmr.VolBytes;
 273       mr.VolMounts    = sdmr.VolMounts;
 274       mr.VolErrors    = sdmr.VolErrors;
 275       mr.VolWrites    = sdmr.VolWrites;
 276       mr.LastWritten  = sdmr.LastWritten;
 277       mr.Slot         = sdmr.Slot;
 278       mr.InChanger    = sdmr.InChanger;
 279       mr.VolReadTime  = sdmr.VolReadTime;
 280       mr.VolWriteTime = sdmr.VolWriteTime;
 281       mr.VolParts     = sdmr.VolParts;
 282       bstrncpy(mr.VolStatus, sdmr.VolStatus, sizeof(mr.VolStatus));
 283       if (jcr->wstore && jcr->wstore->StorageId) {
 284          mr.StorageId = jcr->wstore->StorageId;
 285       }
 286
 287       Dmsg2(400, "db_update_media_record. Stat=%s Vol=%s\n", mr.VolStatus, mr.VolumeName);
 288       /*
 289        * Update the database, then before sending the response to the
 290        *  SD, check if the Volume has expired.
 291        */
 292       if (!db_update_media_record(jcr, jcr->db, &mr)) {
 293          Jmsg(jcr, M_FATAL, 0, _("Catalog error updating Media record. %s"),
 294             db_strerror(jcr->db));
 295          bnet_fsend(bs, _("1993 Update Media error\n"));
 296          Dmsg0(400, "send error\n");
 297       } else {
 298          (void)has_volume_expired(jcr, &mr);
 299          send_volume_info_to_storage_daemon(jcr, bs, &mr);
 300       }
 301       db_unlock(jcr->db);
 302
 303    /*
 304     * Request to create a JobMedia record
 305     */
 306    } else if (sscanf(bs->msg, Create_job_media, &Job,
 307       &jm.FirstIndex, &jm.LastIndex, &jm.StartFile, &jm.EndFile,
 308       &jm.StartBlock, &jm.EndBlock, &jm.Copy, &Stripe, &MediaId) == 10) {
 309
 310       if (jcr->mig_jcr) {
 311          jm.JobId = jcr->mig_jcr->JobId;
 312       } else {
 313          jm.JobId = jcr->JobId;
 314       }
 315       jm.MediaId = MediaId;
 316       Dmsg6(400, "create_jobmedia JobId=%d MediaId=%d SF=%d EF=%d FI=%d LI=%d\n",
 317          jm.JobId, jm.MediaId, jm.StartFile, jm.EndFile, jm.FirstIndex, jm.LastIndex);
 318       if (!db_create_jobmedia_record(jcr, jcr->db, &jm)) {
 319          Jmsg(jcr, M_FATAL, 0, _("Catalog error creating JobMedia record. %s"),
 320             db_strerror(jcr->db));
 321          bnet_fsend(bs, _("1991 Update JobMedia error\n"));
 322       } else {
 323          Dmsg0(400, "JobMedia record created\n");
 324          bnet_fsend(bs, OK_create);
 325       }
 326
 327    } else {
 328       omsg = get_memory(bs->msglen+1);
 329       pm_strcpy(omsg, bs->msg);
 330       bnet_fsend(bs, _("1990 Invalid Catalog Request: %s"), omsg);
 331       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog request: %s"), omsg);
 332       free_memory(omsg);
 333    }
 334    Dmsg1(400, ">CatReq response: %s", bs->msg);
 335    Dmsg1(400, "Leave catreq jcr 0x%x\n", jcr);
 336    return;
 337 }
 338
 339 /*
 340  * Update File Attributes in the catalog with data
 341  *  sent by the Storage daemon.  Note, we receive the whole
 342  *  attribute record, but we select out only the stat packet,
 343  *  VolSessionId, VolSessionTime, FileIndex, and file name
 344  *  to store in the catalog.
 345  */
 346 void catalog_update(JCR *jcr, BSOCK *bs)
 347 {
 348    unser_declare;
 349    uint32_t VolSessionId, VolSessionTime;
 350    int32_t Stream;
 351    uint32_t FileIndex;
 352    uint32_t data_len;
 353    char *p;
 354    int len;
 355    char *fname, *attr;
 356    ATTR_DBR *ar = NULL;
 357    POOLMEM *omsg;
 358
 359    if (!jcr->pool->catalog_files) {
 360       return;                         /* user disabled cataloging */
 361    }
 362    if (!jcr->db) {
 363       omsg = get_memory(bs->msglen+1);
 364       pm_strcpy(omsg, bs->msg);
 365       bnet_fsend(bs, _("1991 Invalid Catalog Update: %s"), omsg);
 366       Jmsg1(jcr, M_FATAL, 0, _("Invalid Catalog Update; DB not open: %s"), omsg);
 367       free_memory(omsg);
 368       return;
 369    }
 370
 371    /* Start transaction allocates jcr->attr and jcr->ar if needed */
 372    db_start_transaction(jcr, jcr->db);     /* start transaction if not already open */
 373    ar = jcr->ar;
 374
 375    /* Start by scanning directly in the message buffer to get Stream
 376     *  there may be a cached attr so we cannot yet write into
 377     *  jcr->attr or jcr->ar
 378     */
 379    p = bs->msg;
 380    skip_nonspaces(&p);                /* UpdCat */
 381    skip_spaces(&p);
 382    skip_nonspaces(&p);                /* Job=nnn */
 383    skip_spaces(&p);
 384    skip_nonspaces(&p);                /* FileAttributes */
 385    p += 1;
 386    unser_begin(p, 0);
 387    unser_uint32(VolSessionId);
 388    unser_uint32(VolSessionTime);
 389    unser_int32(FileIndex);
 390    unser_int32(Stream);
 391    unser_uint32(data_len);
 392    p += unser_length(p);
 393
 394    Dmsg1(400, "UpdCat msg=%s\n", bs->msg);
 395    Dmsg5(400, "UpdCat VolSessId=%d VolSessT=%d FI=%d Strm=%d data_len=%d\n",
 396       VolSessionId, VolSessionTime, FileIndex, Stream, data_len);
 397
 398    if (Stream == STREAM_UNIX_ATTRIBUTES || Stream == STREAM_UNIX_ATTRIBUTES_EX) {
 399       if (jcr->cached_attribute) {
 400          Dmsg2(400, "Cached attr. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 401          if (!db_create_file_attributes_record(jcr, jcr->db, ar)) {
 402             Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 403          }
 404       }
 405       /* Any cached attr is flushed so we can reuse jcr->attr and jcr->ar */
 406       jcr->attr = check_pool_memory_size(jcr->attr, bs->msglen);
 407       memcpy(jcr->attr, bs->msg, bs->msglen);
 408       p = jcr->attr - bs->msg + p;    /* point p into jcr->attr */
 409       skip_nonspaces(&p);             /* skip FileIndex */
 410       skip_spaces(&p);
 411       skip_nonspaces(&p);             /* skip FileType */
 412       skip_spaces(&p);
 413       fname = p;
 414       len = strlen(fname);        /* length before attributes */
 415       attr = &fname[len+1];
 416
 417       Dmsg2(400, "dird<stored: stream=%d %s\n", Stream, fname);
 418       Dmsg1(400, "dird<stored: attr=%s\n", attr);
 419       ar->attr = attr;
 420       ar->fname = fname;
 421       ar->FileIndex = FileIndex;
 422       ar->Stream = Stream;
 423       ar->link = NULL;
 424       if (jcr->mig_jcr) {
 425          ar->JobId = jcr->mig_jcr->JobId;
 426       } else {
 427          ar->JobId = jcr->JobId;
 428       }
 429       ar->Digest = NULL;
 430       ar->DigestType = CRYPTO_DIGEST_NONE;
 431       jcr->cached_attribute = true;
 432
 433       Dmsg2(400, "dird<filed: stream=%d %s\n", Stream, fname);
 434       Dmsg1(400, "dird<filed: attr=%s\n", attr);
 435
 436    } else if (crypto_digest_stream_type(Stream) != CRYPTO_DIGEST_NONE) {
 437       fname = p;
 438       if (ar->FileIndex != FileIndex) {
 439          Jmsg(jcr, M_WARNING, 0, _("Got %s but not same File as attributes\n"), stream_to_ascii(Stream));
 440       } else {
 441          /* Update digest in catalog */
 442          char digestbuf[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
 443          int len = 0;
 444          int type = CRYPTO_DIGEST_NONE;
 445
 446          switch(Stream) {
 447          case STREAM_MD5_DIGEST:
 448             len = CRYPTO_DIGEST_MD5_SIZE;
 449             type = CRYPTO_DIGEST_MD5;
 450             break;
 451          case STREAM_SHA1_DIGEST:
 452             len = CRYPTO_DIGEST_SHA1_SIZE;
 453             type = CRYPTO_DIGEST_SHA1;
 454             break;
 455          case STREAM_SHA256_DIGEST:
 456             len = CRYPTO_DIGEST_SHA256_SIZE;
 457             type = CRYPTO_DIGEST_SHA256;
 458             break;
 459          case STREAM_SHA512_DIGEST:
 460             len = CRYPTO_DIGEST_SHA512_SIZE;
 461             type = CRYPTO_DIGEST_SHA512;
 462             break;
 463          default:
 464             /* Never reached ... */
 465             Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. Unsupported digest stream type: %d"),
 466                  Stream);
 467          }
 468
 469          bin_to_base64(digestbuf, sizeof(digestbuf), fname, len, true);
 470          Dmsg3(400, "DigestLen=%d Digest=%s type=%d\n", strlen(digestbuf), digestbuf, Stream);
 471          if (jcr->cached_attribute) {
 472             ar->Digest = digestbuf;
 473             ar->DigestType = type;
 474             Dmsg2(400, "Cached attr with digest. Stream=%d fname=%s\n", ar->Stream, ar->fname);
 475             if (!db_create_file_attributes_record(jcr, jcr->db, ar)) {
 476                Jmsg1(jcr, M_FATAL, 0, _("Attribute create error. %s"), db_strerror(jcr->db));
 477             }
 478             jcr->cached_attribute = false;
 479          } else {
 480             if (!db_add_digest_to_file_record(jcr, jcr->db, ar->FileId, digestbuf, type)) {
 481                Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. %s"),
 482                   db_strerror(jcr->db));
 483             }
 484          }
 485       }
 486    }
 487 }