git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/match_bsr.c

   1 /*
   2  *   Match Bootstrap Records (used for restores) against
   3  *     Volume Records
   4  *
   5  *     Kern Sibbald, June MMII
   6  *
   7  *   Version $Id$
   8  */
   9
  10 /*
  11    Copyright (C) 2000-2003 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 "stored.h"
  32 #include <fnmatch.h>
  33
  34 /* Forward references */
  35 static int match_volume(BSR *bsr, BSR_VOLUME *volume, VOLUME_LABEL *volrec, bool done);
  36 static int match_sesstime(BSR *bsr, BSR_SESSTIME *sesstime, DEV_RECORD *rec, bool done);
  37 static int match_sessid(BSR *bsr, BSR_SESSID *sessid, DEV_RECORD *rec);
  38 static int match_client(BSR *bsr, BSR_CLIENT *client, SESSION_LABEL *sessrec, bool done);
  39 static int match_job(BSR *bsr, BSR_JOB *job, SESSION_LABEL *sessrec, bool done);
  40 static int match_job_type(BSR *bsr, BSR_JOBTYPE *job_type, SESSION_LABEL *sessrec, bool done);
  41 static int match_job_level(BSR *bsr, BSR_JOBLEVEL *job_level, SESSION_LABEL *sessrec, bool done);
  42 static int match_jobid(BSR *bsr, BSR_JOBID *jobid, SESSION_LABEL *sessrec, bool done);
  43 static int match_findex(BSR *bsr, BSR_FINDEX *findex, DEV_RECORD *rec, bool done);
  44 static int match_volfile(BSR *bsr, BSR_VOLFILE *volfile, DEV_RECORD *rec, bool done);
  45 static int match_stream(BSR *bsr, BSR_STREAM *stream, DEV_RECORD *rec, bool done);
  46 static int match_all(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, SESSION_LABEL *sessrec, bool done);
  47 static int match_block_sesstime(BSR *bsr, BSR_SESSTIME *sesstime, DEV_BLOCK *block);
  48 static int match_block_sessid(BSR *bsr, BSR_SESSID *sessid, DEV_BLOCK *block);
  49 static BSR *find_smallest_volfile(BSR *fbsr, BSR *bsr);
  50
  51
  52 /*********************************************************************
  53  *
  54  *  If possible, position the archive device (tape) to read the
  55  *  next block.
  56  */
  57 void position_bsr_block(BSR *bsr, DEV_BLOCK *block)
  58 {
  59    /* To be implemented */
  60 }
  61
  62 /*********************************************************************
  63  *
  64  *  Do fast block rejection based on bootstrap records.
  65  *    use_fast_rejection will be set if we have VolSessionId and VolSessTime
  66  *    in each record. When BlockVer is >= 2, we have those in the block header
  67  *    so can do fast rejection.
  68  *
  69  *   returns:  1 if block may contain valid records
  70  *             0 if block may be skipped (i.e. it contains no records of
  71  *                  that can match the bsr).
  72  *
  73  */
  74 int match_bsr_block(BSR *bsr, DEV_BLOCK *block)
  75 {
  76    if (!bsr || !bsr->use_fast_rejection || (block->BlockVer < 2)) {
  77       return 1;                       /* cannot fast reject */
  78    }
  79
  80    for ( ; bsr; bsr=bsr->next) {
  81    if (!match_block_sesstime(bsr, bsr->sesstime, block)) {
  82          continue;
  83       }
  84       if (!match_block_sessid(bsr, bsr->sessid, block)) {
  85          continue;
  86    }
  87       return 1;
  88    }
  89    return 0;
  90 }
  91
  92 static int match_block_sesstime(BSR *bsr, BSR_SESSTIME *sesstime, DEV_BLOCK *block)
  93 {
  94    if (!sesstime) {
  95       return 1;                       /* no specification matches all */
  96    }
  97    if (sesstime->sesstime == block->VolSessionTime) {
  98       return 1;
  99    }
 100    if (sesstime->next) {
 101       return match_block_sesstime(bsr, sesstime->next, block);
 102    }
 103    return 0;
 104 }
 105
 106 static int match_block_sessid(BSR *bsr, BSR_SESSID *sessid, DEV_BLOCK *block)
 107 {
 108    if (!sessid) {
 109       return 1;                       /* no specification matches all */
 110    }
 111    if (sessid->sessid <= block->VolSessionId && sessid->sessid2 >= block->VolSessionId) {
 112       return 1;
 113    }
 114    if (sessid->next) {
 115       return match_block_sessid(bsr, sessid->next, block);
 116    }
 117    return 0;
 118 }
 119
 120
 121 /*********************************************************************
 122  *
 123  *      Match Bootstrap records
 124  *        returns  1 on match
 125  *        returns  0 no match and reposition is set if we should
 126  *                      reposition the tape
 127  *       returns -1 no additional matches possible
 128  */
 129 int match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, SESSION_LABEL *sessrec)
 130 {
 131    int stat;
 132
 133    /*
 134     * The bsr->reposition flag is set any time a bsr is done.
 135     *   In this case, we can probably reposition the
 136     *   tape to the next available bsr position.
 137     */
 138    if (bsr) {
 139       bsr->reposition = false;
 140       stat = match_all(bsr, rec, volrec, sessrec, true);
 141       /*
 142        * Note, bsr->reposition is set by match_all when
 143        *  a bsr is done. We turn it off if a match was
 144        *  found or if we cannot use positioning
 145        */
 146       if (stat != 0 || !bsr->use_positioning) {
 147          bsr->reposition = false;
 148       }
 149    } else {
 150       stat = 1;                       /* no bsr => match all */
 151    }
 152    return stat;
 153 }
 154
 155 /*
 156  * Find the next bsr that applies to the current tape.
 157  *   It is the one with the smallest VolFile position.
 158  */
 159 BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev)
 160 {
 161    BSR *bsr;
 162    BSR *found_bsr = NULL;
 163
 164    if (!root_bsr || !root_bsr->use_positioning ||
 165        !root_bsr->reposition || !dev_is_tape(dev)) {
 166       Dmsg2(100, "No nxt_bsr use_pos=%d repos=%d\n", root_bsr->use_positioning, root_bsr->reposition);
 167       return NULL;
 168    }
 169    Dmsg2(100, "use_pos=%d repos=%d\n", root_bsr->use_positioning, root_bsr->reposition);
 170    root_bsr->mount_next_volume = false;
 171    for (bsr=root_bsr; bsr; bsr=bsr->next) {
 172       if (bsr->done || !match_volume(bsr, bsr->volume, &dev->VolHdr, 1)) {
 173          continue;
 174       }
 175       if (found_bsr == NULL) {
 176          found_bsr = bsr;
 177       } else {
 178          found_bsr = find_smallest_volfile(found_bsr, bsr);
 179       }
 180    }
 181    /*
 182     * If we get to this point and found no bsr, it means
 183     *  that any additional bsr's must apply to the next
 184     *  tape, so set a flag.
 185     */
 186    if (found_bsr == NULL) {
 187       root_bsr->mount_next_volume = true;
 188    }
 189    return found_bsr;
 190 }
 191
 192 static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
 193 {
 194    BSR *return_bsr = found_bsr;
 195    BSR_VOLFILE *vf;
 196    BSR_VOLBLOCK *vb;
 197    uint32_t found_bsr_sfile, bsr_sfile;
 198    uint32_t found_bsr_sblock, bsr_sblock;
 199
 200    vf = found_bsr->volfile;
 201    found_bsr_sfile = vf->sfile;
 202    while ( (vf=vf->next) ) {
 203       if (vf->sfile < found_bsr_sfile) {
 204          found_bsr_sfile = vf->sfile;
 205       }
 206    }
 207    vf = bsr->volfile;
 208    bsr_sfile = vf->sfile;
 209    while ( (vf=vf->next) ) {
 210       if (vf->sfile < bsr_sfile) {
 211          bsr_sfile = vf->sfile;
 212       }
 213    }
 214    if (found_bsr_sfile > bsr_sfile) {
 215       return_bsr = bsr;
 216    } else if (found_bsr_sfile == bsr_sfile) {
 217       /* Must check block */
 218       vb = found_bsr->volblock;
 219       found_bsr_sblock = vb->sblock;
 220       while ( (vb=vb->next) ) {
 221          if (vb->sblock < found_bsr_sblock) {
 222             found_bsr_sblock = vb->sblock;
 223          }
 224       }
 225       vb = bsr->volblock;
 226       bsr_sblock = vb->sblock;
 227       while ( (vb=vb->next) ) {
 228          if (vb->sblock < bsr_sblock) {
 229             bsr_sblock = vb->sblock;
 230          }
 231       }
 232       if (found_bsr_sblock > bsr_sblock) {
 233          return_bsr = bsr;
 234       }
 235    }
 236
 237    return return_bsr;
 238 }
 239
 240 /*
 241  * Called to tell the matcher that the end of
 242  *   the current file has been reached.
 243  *  The bsr argument is not used, but is included
 244  *    for consistency with the other match calls.
 245  *
 246  * Returns: true if we should reposition
 247  *        : false otherwise.
 248  */
 249 bool match_set_eof(BSR *bsr, DEV_RECORD *rec)
 250 {
 251    BSR *rbsr = rec->bsr;
 252    Dmsg1(100, "match_set %d\n", rbsr != NULL);
 253    if (!rbsr) {
 254       return false;
 255    }
 256    rec->bsr = NULL;
 257    rbsr->found++;
 258    if (rbsr->count && rbsr->found >= rbsr->count) {
 259       rbsr->done = true;
 260       rbsr->root->reposition = true;
 261       Dmsg2(100, "match_set_eof reposition count=%d found=%d\n",
 262          rbsr->count, rbsr->found);
 263       return true;
 264    }
 265    return false;
 266 }
 267
 268 /*
 269  * Match all the components of current record
 270  *   returns  1 on match
 271  *   returns  0 no match
 272  *   returns -1 no additional matches possible
 273  */
 274 static int match_all(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec,
 275                      SESSION_LABEL *sessrec, bool done)
 276 {
 277    if (bsr->done) {
 278       goto no_match;
 279    }
 280    if (!match_volume(bsr, bsr->volume, volrec, 1)) {
 281       goto no_match;
 282    }
 283    if (!match_volfile(bsr, bsr->volfile, rec, 1)) {
 284       Dmsg2(100, "Fail on file. bsr=%d rec=%d\n", bsr->volfile->efile,
 285          rec->File);
 286       goto no_match;
 287    }
 288    if (!match_sesstime(bsr, bsr->sesstime, rec, 1)) {
 289       Dmsg2(100, "Fail on sesstime. bsr=%d rec=%d\n",
 290          bsr->sesstime->sesstime, rec->VolSessionTime);
 291       goto no_match;
 292    }
 293
 294    /* NOTE!! This test MUST come after the sesstime test */
 295    if (!match_sessid(bsr, bsr->sessid, rec)) {
 296       Dmsg2(100, "Fail on sessid. bsr=%d rec=%d\n",
 297          bsr->sessid->sessid, rec->VolSessionId);
 298       goto no_match;
 299    }
 300
 301    /* NOTE!! This test MUST come after sesstime and sessid tests */
 302    if (!match_findex(bsr, bsr->FileIndex, rec, 1)) {
 303       Dmsg2(100, "Fail on findex. bsr=%d rec=%d\n",
 304          bsr->FileIndex->findex2, rec->FileIndex);
 305       goto no_match;
 306    }
 307    /*
 308     * If a count was specified and we have a FileIndex, assume
 309     *   it is a Bacula created bsr (or the equivalent). We
 310     *   then save the bsr where the match occurred so that
 311     *   after processing the record or records, we can update
 312     *   the found count. I.e. rec->bsr points to the bsr that
 313     *   satisfied the match.
 314     */
 315    if (bsr->count && bsr->FileIndex) {
 316       rec->bsr = bsr;
 317       return 1;                       /* this is a complete match */
 318    }
 319
 320    /*
 321     * The selections below are not used by Bacula's
 322     *   restore command, and don't work because of
 323     *   the rec->bsr = bsr optimization above.
 324     */
 325    if (!match_jobid(bsr, bsr->JobId, sessrec, 1)) {
 326       goto no_match;
 327
 328    }
 329    if (!match_job(bsr, bsr->job, sessrec, 1)) {
 330       goto no_match;
 331    }
 332    if (!match_client(bsr, bsr->client, sessrec, 1)) {
 333       goto no_match;
 334    }
 335    if (!match_job_type(bsr, bsr->JobType, sessrec, 1)) {
 336       goto no_match;
 337    }
 338    if (!match_job_level(bsr, bsr->JobLevel, sessrec, 1)) {
 339       goto no_match;
 340    }
 341    if (!match_stream(bsr, bsr->stream, rec, 1)) {
 342       goto no_match;
 343    }
 344    return 1;
 345
 346 no_match:
 347    if (bsr->next) {
 348       return match_all(bsr->next, rec, volrec, sessrec, bsr->done && done);
 349    }
 350    if (bsr->done && done) {
 351       return -1;
 352    }
 353    return 0;
 354 }
 355
 356 static int match_volume(BSR *bsr, BSR_VOLUME *volume, VOLUME_LABEL *volrec, bool done)
 357 {
 358    if (!volume) {
 359       return 0;                       /* Volume must match */
 360    }
 361    if (strcmp(volume->VolumeName, volrec->VolName) == 0) {
 362       return 1;
 363    }
 364    if (volume->next) {
 365       return match_volume(bsr, volume->next, volrec, 1);
 366    }
 367    return 0;
 368 }
 369
 370 static int match_client(BSR *bsr, BSR_CLIENT *client, SESSION_LABEL *sessrec, bool done)
 371 {
 372    if (!client) {
 373       return 1;                       /* no specification matches all */
 374    }
 375    if (fnmatch(client->ClientName, sessrec->ClientName, 0) == 0) {
 376       return 1;
 377    }
 378    if (client->next) {
 379       return match_client(bsr, client->next, sessrec, 1);
 380    }
 381    return 0;
 382 }
 383
 384 static int match_job(BSR *bsr, BSR_JOB *job, SESSION_LABEL *sessrec, bool done)
 385 {
 386    if (!job) {
 387       return 1;                       /* no specification matches all */
 388    }
 389    if (fnmatch(job->Job, sessrec->Job, 0) == 0) {
 390       return 1;
 391    }
 392    if (job->next) {
 393       return match_job(bsr, job->next, sessrec, 1);
 394    }
 395    return 0;
 396 }
 397
 398 static int match_job_type(BSR *bsr, BSR_JOBTYPE *job_type, SESSION_LABEL *sessrec, bool done)
 399 {
 400    if (!job_type) {
 401       return 1;                       /* no specification matches all */
 402    }
 403    if (job_type->JobType == sessrec->JobType) {
 404       return 1;
 405    }
 406    if (job_type->next) {
 407       return match_job_type(bsr, job_type->next, sessrec, 1);
 408    }
 409    return 0;
 410 }
 411
 412 static int match_job_level(BSR *bsr, BSR_JOBLEVEL *job_level, SESSION_LABEL *sessrec, bool done)
 413 {
 414    if (!job_level) {
 415       return 1;                       /* no specification matches all */
 416    }
 417    if (job_level->JobLevel == sessrec->JobLevel) {
 418       return 1;
 419    }
 420    if (job_level->next) {
 421       return match_job_level(bsr, job_level->next, sessrec, 1);
 422    }
 423    return 0;
 424 }
 425
 426 static int match_jobid(BSR *bsr, BSR_JOBID *jobid, SESSION_LABEL *sessrec, bool done)
 427 {
 428    if (!jobid) {
 429       return 1;                       /* no specification matches all */
 430    }
 431    if (jobid->JobId <= sessrec->JobId && jobid->JobId2 >= sessrec->JobId) {
 432       return 1;
 433    }
 434    if (jobid->next) {
 435       return match_jobid(bsr, jobid->next, sessrec, 1);
 436    }
 437    return 0;
 438 }
 439
 440 static int match_volfile(BSR *bsr, BSR_VOLFILE *volfile, DEV_RECORD *rec, bool done)
 441 {
 442    if (!volfile) {
 443       return 1;                       /* no specification matches all */
 444    }
 445    /* For the moment, these tests work only with tapes. */
 446    if (!(rec->state & REC_ISTAPE)) {
 447       return 1;                       /* All File records OK for this match */
 448    }
 449 // Dmsg3(000, "match_volfile: sfile=%d efile=%d recfile=%d\n",
 450 //             volfile->sfile, volfile->efile, rec->File);
 451    if (volfile->sfile <= rec->File && volfile->efile >= rec->File) {
 452       return 1;
 453    }
 454    /* Once we get past last efile, we are done */
 455    if (rec->File > volfile->efile) {
 456       volfile->done = true;              /* set local done */
 457    }
 458    if (volfile->next) {
 459       return match_volfile(bsr, volfile->next, rec, volfile->done && done);
 460    }
 461
 462    /* If we are done and all prior matches are done, this bsr is finished */
 463    if (volfile->done && done) {
 464       bsr->done = true;
 465       bsr->root->reposition = true;
 466       Dmsg2(100, "bsr done from volfile rec=%d volefile=%d\n",
 467          rec->File, volfile->efile);
 468    }
 469    return 0;
 470 }
 471
 472 static int match_stream(BSR *bsr, BSR_STREAM *stream, DEV_RECORD *rec, bool done)
 473 {
 474    if (!stream) {
 475       return 1;                       /* no specification matches all */
 476    }
 477    if (stream->stream == rec->Stream) {
 478       return 1;
 479    }
 480    if (stream->next) {
 481       return match_stream(bsr, stream->next, rec, 1);
 482    }
 483    return 0;
 484 }
 485
 486 static int match_sesstime(BSR *bsr, BSR_SESSTIME *sesstime, DEV_RECORD *rec, bool done)
 487 {
 488    if (!sesstime) {
 489       return 1;                       /* no specification matches all */
 490    }
 491    if (sesstime->sesstime == rec->VolSessionTime) {
 492       return 1;
 493    }
 494    if (rec->VolSessionTime > sesstime->sesstime) {
 495       sesstime->done = true;
 496    }
 497    if (sesstime->next) {
 498       return match_sesstime(bsr, sesstime->next, rec, sesstime->done && done);
 499    }
 500    if (sesstime->done && done) {
 501       bsr->done = true;
 502       bsr->root->reposition = true;
 503       Dmsg0(100, "bsr done from sesstime\n");
 504    }
 505    return 0;
 506 }
 507
 508 static int match_sessid(BSR *bsr, BSR_SESSID *sessid, DEV_RECORD *rec)
 509 {
 510    if (!sessid) {
 511       return 1;                       /* no specification matches all */
 512    }
 513    if (sessid->sessid <= rec->VolSessionId && sessid->sessid2 >= rec->VolSessionId) {
 514       return 1;
 515    }
 516    if (sessid->next) {
 517       return match_sessid(bsr, sessid->next, rec);
 518    }
 519    return 0;
 520 }
 521
 522 /*
 523  * When reading the Volume, the Volume Findex (rec->FileIndex) always
 524  *   are found in sequential order. Thus we can make optimizations.
 525  */
 526 static int match_findex(BSR *bsr, BSR_FINDEX *findex, DEV_RECORD *rec, bool done)
 527 {
 528    if (!findex) {
 529       return 1;                       /* no specification matches all */
 530    }
 531    if (findex->findex <= rec->FileIndex && findex->findex2 >= rec->FileIndex) {
 532       return 1;
 533    }
 534    if (rec->FileIndex > findex->findex2) {
 535       findex->done = true;
 536    }
 537    if (findex->next) {
 538       return match_findex(bsr, findex->next, rec, findex->done && done);
 539    }
 540    if (findex->done && done) {
 541       bsr->done = true;
 542       bsr->root->reposition = true;
 543       Dmsg1(100, "bsr done from findex %d\n", rec->FileIndex);
 544    }
 545    return 0;
 546 }