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

   1 /*
   2  *   Parse a Bootstrap Records (used for restores)
   3  *
   4  *     Kern Sibbald, June MMII
   5  *
   6  *   Version $Id$
   7  */
   8
   9 /*
  10    Copyright (C) 2002 Kern Sibbald and John Walker
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    MA 02111-1307, USA.
  25
  26  */
  27
  28
  29 #include "bacula.h"
  30 #include "stored.h"
  31
  32 typedef BSR * (ITEM_HANDLER)(LEX *lc, BSR *bsr);
  33
  34 static BSR *store_vol(LEX *lc, BSR *bsr);
  35 static BSR *store_client(LEX *lc, BSR *bsr);
  36 static BSR *store_job(LEX *lc, BSR *bsr);
  37 static BSR *store_jobid(LEX *lc, BSR *bsr);
  38 static BSR *store_jobtype(LEX *lc, BSR *bsr);
  39 static BSR *store_joblevel(LEX *lc, BSR *bsr);
  40 static BSR *store_findex(LEX *lc, BSR *bsr);
  41 static BSR *store_sessid(LEX *lc, BSR *bsr);
  42 static BSR *store_volfile(LEX *lc, BSR *bsr);
  43 static BSR *store_sesstime(LEX *lc, BSR *bsr);
  44 static BSR *store_include(LEX *lc, BSR *bsr);
  45 static BSR *store_exclude(LEX *lc, BSR *bsr);
  46 static BSR *store_stream(LEX *lc, BSR *bsr);
  47 static BSR *store_slot(LEX *lc, BSR *bsr);
  48
  49 struct kw_items {
  50    char *name;
  51    ITEM_HANDLER *handler;
  52 };
  53
  54 /*
  55  * List of all keywords permitted in bsr files and their handlers
  56  */
  57 struct kw_items items[] = {
  58    {"volume", store_vol},
  59    {"client", store_client},
  60    {"job", store_job},
  61    {"jobid", store_jobid},
  62    {"fileindex", store_findex},
  63    {"jobtype", store_jobtype},
  64    {"joblevel", store_joblevel},
  65    {"volsessionid", store_sessid},
  66    {"volsessiontime", store_sesstime},
  67    {"include", store_include},
  68    {"exclude", store_exclude},
  69    {"volfile", store_volfile},
  70    {"stream",  store_stream},
  71    {"slot",    store_slot},
  72    {NULL, NULL}
  73
  74 };
  75
  76 /*
  77  * Create a BSR record
  78  */
  79 static BSR *new_bsr()
  80 {
  81    BSR *bsr = (BSR *)malloc(sizeof(BSR));
  82    memset(bsr, 0, sizeof(BSR));
  83    return bsr;
  84 }
  85
  86 /*
  87  * Format a scanner error message
  88  */
  89 static void s_err(char *file, int line, LEX *lc, char *msg, ...)
  90 {
  91    JCR *jcr = (JCR *)(lc->caller_ctx);
  92    va_list arg_ptr;
  93    char buf[MAXSTRING];
  94
  95    va_start(arg_ptr, msg);
  96    bvsnprintf(buf, sizeof(buf), msg, arg_ptr);
  97    va_end(arg_ptr);
  98
  99    if (jcr) {
 100       Jmsg(jcr, M_FATAL, 0, _("Bootstrap file error: %s\n\
 101             : Line %d, col %d of file %s\n%s\n"),
 102          buf, lc->line_no, lc->col_no, lc->fname, lc->line);
 103    } else {
 104       e_msg(file, line, M_FATAL, 0, _("Bootstrap file error: %s\n\
 105             : Line %d, col %d of file %s\n%s\n"),
 106          buf, lc->line_no, lc->col_no, lc->fname, lc->line);
 107    }
 108 }
 109
 110
 111 /*********************************************************************
 112  *
 113  *      Parse Bootstrap file
 114  *
 115  */
 116 BSR *parse_bsr(JCR *jcr, char *cf)
 117 {
 118    LEX *lc = NULL;
 119    int token, i;
 120    BSR *root_bsr = new_bsr();
 121    BSR *bsr = root_bsr;
 122
 123    Dmsg1(200, "Enter parse_bsf %s\n", cf);
 124    lc = lex_open_file(lc, cf, s_err);
 125    lc->caller_ctx = (void *)jcr;
 126    while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
 127       Dmsg1(200, "parse got token=%s\n", lex_tok_to_str(token));
 128       if (token == T_EOL) {
 129          continue;
 130       }
 131       for (i=0; items[i].name; i++) {
 132          if (strcasecmp(items[i].name, lc->str) == 0) {
 133             token = lex_get_token(lc, T_ALL);
 134             Dmsg1 (200, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
 135             if (token != T_EQUALS) {
 136                scan_err1(lc, "expected an equals, got: %s", lc->str);
 137                bsr = NULL;
 138                break;
 139             }
 140             Dmsg1(200, "calling handler for %s\n", items[i].name);
 141             /* Call item handler */
 142             bsr = items[i].handler(lc, bsr);
 143             i = -1;
 144             break;
 145          }
 146       }
 147       if (i >= 0) {
 148          Dmsg1(200, "Keyword = %s\n", lc->str);
 149          scan_err1(lc, "Keyword %s not found", lc->str);
 150          bsr = NULL;
 151          break;
 152       }
 153       if (!bsr) {
 154          break;
 155       }
 156    }
 157    lc = lex_close_file(lc);
 158    Dmsg0(200, "Leave parse_bsf()\n");
 159    if (!bsr) {
 160       free_bsr(root_bsr);
 161       root_bsr = NULL;
 162    }
 163    return root_bsr;
 164 }
 165
 166 static BSR *store_vol(LEX *lc, BSR *bsr)
 167 {
 168    int token;
 169    BSR_VOLUME *volume;
 170    char *p, *n;
 171
 172    token = lex_get_token(lc, T_STRING);
 173    if (token == T_ERROR) {
 174       return NULL;
 175    }
 176    /* This may actually be more than one volume separated by a |
 177     * If so, separate them.
 178     */
 179    for (p=lc->str; p && *p; ) {
 180       n = strchr(p, '|');
 181       if (n) {
 182          *n++ = 0;
 183       }
 184       volume = (BSR_VOLUME *)malloc(sizeof(BSR_VOLUME));
 185       memset(volume, 0, sizeof(BSR_VOLUME));
 186       strcpy(volume->VolumeName, p);
 187       /* Add it to the end of the volume chain */
 188       if (!bsr->volume) {
 189          bsr->volume = volume;
 190       } else {
 191          BSR_VOLUME *bc = bsr->volume;
 192          for ( ;bc->next; bc=bc->next)
 193             { }
 194          bc->next = volume;
 195       }
 196       p = n;
 197    }
 198    return bsr;
 199 }
 200
 201 static BSR *store_client(LEX *lc, BSR *bsr)
 202 {
 203    int token;
 204    BSR_CLIENT *client;
 205
 206    for (;;) {
 207       token = lex_get_token(lc, T_NAME);
 208       if (token == T_ERROR) {
 209          return NULL;
 210       }
 211       client = (BSR_CLIENT *)malloc(sizeof(BSR_CLIENT));
 212       memset(client, 0, sizeof(BSR_CLIENT));
 213       strcpy(client->ClientName, lc->str);
 214       /* Add it to the end of the client chain */
 215       if (!bsr->client) {
 216          bsr->client = client;
 217       } else {
 218          BSR_CLIENT *bc = bsr->client;
 219          for ( ;bc->next; bc=bc->next)
 220             { }
 221          bc->next = client;
 222       }
 223       token = lex_get_token(lc, T_ALL);
 224       if (token != T_COMMA) {
 225          break;
 226       }
 227    }
 228    return bsr;
 229 }
 230
 231 static BSR *store_job(LEX *lc, BSR *bsr)
 232 {
 233    int token;
 234    BSR_JOB *job;
 235
 236    for (;;) {
 237       token = lex_get_token(lc, T_NAME);
 238       if (token == T_ERROR) {
 239          return NULL;
 240       }
 241       job = (BSR_JOB *)malloc(sizeof(BSR_JOB));
 242       memset(job, 0, sizeof(BSR_JOB));
 243       strcpy(job->Job, lc->str);
 244       /* Add it to the end of the client chain */
 245       if (!bsr->job) {
 246          bsr->job = job;
 247       } else {
 248          /* Add to end of chain */
 249          BSR_JOB *bc = bsr->job;
 250          for ( ;bc->next; bc=bc->next)
 251             { }
 252          bc->next = job;
 253       }
 254       token = lex_get_token(lc, T_ALL);
 255       if (token != T_COMMA) {
 256          break;
 257       }
 258    }
 259    return bsr;
 260 }
 261
 262 static BSR *store_findex(LEX *lc, BSR *bsr)
 263 {
 264    int token;
 265    BSR_FINDEX *findex;
 266
 267    for (;;) {
 268       token = lex_get_token(lc, T_PINT32_RANGE);
 269       if (token == T_ERROR) {
 270          return NULL;
 271       }
 272       findex = (BSR_FINDEX *)malloc(sizeof(BSR_FINDEX));
 273       memset(findex, 0, sizeof(BSR_FINDEX));
 274       findex->findex = lc->pint32_val;
 275       findex->findex2 = lc->pint32_val2;
 276       /* Add it to the end of the chain */
 277       if (!bsr->FileIndex) {
 278          bsr->FileIndex = findex;
 279       } else {
 280          /* Add to end of chain */
 281          BSR_FINDEX *bs = bsr->FileIndex;
 282          for ( ;bs->next; bs=bs->next)
 283             {  }
 284          bs->next = findex;
 285       }
 286       token = lex_get_token(lc, T_ALL);
 287       if (token != T_COMMA) {
 288          break;
 289       }
 290    }
 291    return bsr;
 292 }
 293
 294
 295 static BSR *store_jobid(LEX *lc, BSR *bsr)
 296 {
 297    int token;
 298    BSR_JOBID *jobid;
 299
 300    for (;;) {
 301       token = lex_get_token(lc, T_PINT32_RANGE);
 302       if (token == T_ERROR) {
 303          return NULL;
 304       }
 305       jobid = (BSR_JOBID *)malloc(sizeof(BSR_JOBID));
 306       memset(jobid, 0, sizeof(BSR_JOBID));
 307       jobid->JobId = lc->pint32_val;
 308       jobid->JobId2 = lc->pint32_val2;
 309       /* Add it to the end of the chain */
 310       if (!bsr->JobId) {
 311          bsr->JobId = jobid;
 312       } else {
 313          /* Add to end of chain */
 314          BSR_JOBID *bs = bsr->JobId;
 315          for ( ;bs->next; bs=bs->next)
 316             {  }
 317          bs->next = jobid;
 318       }
 319       token = lex_get_token(lc, T_ALL);
 320       if (token != T_COMMA) {
 321          break;
 322       }
 323    }
 324    return bsr;
 325 }
 326
 327 static BSR *store_jobtype(LEX *lc, BSR *bsr)
 328 {
 329    /* *****FIXME****** */
 330    Dmsg0(-1, "JobType not yet implemented\n");
 331    return bsr;
 332 }
 333
 334
 335 static BSR *store_joblevel(LEX *lc, BSR *bsr)
 336 {
 337    /* *****FIXME****** */
 338    Dmsg0(-1, "JobLevel not yet implemented\n");
 339    return bsr;
 340 }
 341
 342
 343
 344
 345 /*
 346  * Routine to handle Volume start/end file
 347  */
 348 static BSR *store_volfile(LEX *lc, BSR *bsr)
 349 {
 350    int token;
 351    BSR_VOLFILE *volfile;
 352
 353    for (;;) {
 354       token = lex_get_token(lc, T_PINT32_RANGE);
 355       if (token == T_ERROR) {
 356          return NULL;
 357       }
 358       volfile = (BSR_VOLFILE *)malloc(sizeof(BSR_VOLFILE));
 359       memset(volfile, 0, sizeof(BSR_VOLFILE));
 360       volfile->sfile = lc->pint32_val;
 361       volfile->efile = lc->pint32_val2;
 362       /* Add it to the end of the chain */
 363       if (!bsr->volfile) {
 364          bsr->volfile = volfile;
 365       } else {
 366          /* Add to end of chain */
 367          BSR_VOLFILE *bs = bsr->volfile;
 368          for ( ;bs->next; bs=bs->next)
 369             {  }
 370          bs->next = volfile;
 371       }
 372       token = lex_get_token(lc, T_ALL);
 373       if (token != T_COMMA) {
 374          break;
 375       }
 376    }
 377    return bsr;
 378 }
 379
 380
 381
 382 static BSR *store_sessid(LEX *lc, BSR *bsr)
 383 {
 384    int token;
 385    BSR_SESSID *sid;
 386
 387    for (;;) {
 388       token = lex_get_token(lc, T_PINT32_RANGE);
 389       if (token == T_ERROR) {
 390          return NULL;
 391       }
 392       sid = (BSR_SESSID *)malloc(sizeof(BSR_SESSID));
 393       memset(sid, 0, sizeof(BSR_SESSID));
 394       sid->sessid = lc->pint32_val;
 395       sid->sessid2 = lc->pint32_val2;
 396       /* Add it to the end of the chain */
 397       if (!bsr->sessid) {
 398          bsr->sessid = sid;
 399       } else {
 400          /* Add to end of chain */
 401          BSR_SESSID *bs = bsr->sessid;
 402          for ( ;bs->next; bs=bs->next)
 403             {  }
 404          bs->next = sid;
 405       }
 406       token = lex_get_token(lc, T_ALL);
 407       if (token != T_COMMA) {
 408          break;
 409       }
 410    }
 411    return bsr;
 412 }
 413
 414 static BSR *store_sesstime(LEX *lc, BSR *bsr)
 415 {
 416    int token;
 417    BSR_SESSTIME *stime;
 418
 419    for (;;) {
 420       token = lex_get_token(lc, T_PINT32);
 421       if (token == T_ERROR) {
 422          return NULL;
 423       }
 424       stime = (BSR_SESSTIME *)malloc(sizeof(BSR_SESSTIME));
 425       memset(stime, 0, sizeof(BSR_SESSTIME));
 426       stime->sesstime = lc->pint32_val;
 427       /* Add it to the end of the chain */
 428       if (!bsr->sesstime) {
 429          bsr->sesstime = stime;
 430       } else {
 431          /* Add to end of chain */
 432          BSR_SESSTIME *bs = bsr->sesstime;
 433          for ( ;bs->next; bs=bs->next)
 434             { }
 435          bs->next = stime;
 436       }
 437       token = lex_get_token(lc, T_ALL);
 438       if (token != T_COMMA) {
 439          break;
 440       }
 441    }
 442    return bsr;
 443 }
 444
 445
 446 static BSR *store_stream(LEX *lc, BSR *bsr)
 447 {
 448    int token;
 449    BSR_STREAM *stream;
 450
 451    for (;;) {
 452       token = lex_get_token(lc, T_INT32);
 453       if (token == T_ERROR) {
 454          return NULL;
 455       }
 456       stream = (BSR_STREAM *)malloc(sizeof(BSR_STREAM));
 457       memset(stream, 0, sizeof(BSR_STREAM));
 458       stream->stream = lc->int32_val;
 459       /* Add it to the end of the chain */
 460       if (!bsr->stream) {
 461          bsr->stream = stream;
 462       } else {
 463          /* Add to end of chain */
 464          BSR_STREAM *bs = bsr->stream;
 465          for ( ;bs->next; bs=bs->next)
 466             { }
 467          bs->next = stream;
 468       }
 469       token = lex_get_token(lc, T_ALL);
 470       if (token != T_COMMA) {
 471          break;
 472       }
 473    }
 474    return bsr;
 475 }
 476
 477 static BSR *store_slot(LEX *lc, BSR *bsr)
 478 {
 479    int token;
 480
 481    token = lex_get_token(lc, T_PINT32);
 482    if (token == T_ERROR) {
 483       return NULL;
 484    }
 485    bsr->Slot = lc->pint32_val;
 486    scan_to_eol(lc);
 487    return bsr;
 488 }
 489
 490 static BSR *store_include(LEX *lc, BSR *bsr)
 491 {
 492    scan_to_eol(lc);
 493    return bsr;
 494 }
 495
 496 static BSR *store_exclude(LEX *lc, BSR *bsr)
 497 {
 498    scan_to_eol(lc);
 499    return bsr;
 500 }
 501
 502 void dump_volfile(BSR_VOLFILE *volfile)
 503 {
 504    if (volfile) {
 505       Dmsg2(-1, "VolFile     : %u-%u\n", volfile->sfile, volfile->efile);
 506       dump_volfile(volfile->next);
 507    }
 508 }
 509
 510 void dump_findex(BSR_FINDEX *FileIndex)
 511 {
 512    if (FileIndex) {
 513       if (FileIndex->findex == FileIndex->findex2) {
 514          Dmsg1(-1, "FileIndex   : %u\n", FileIndex->findex);
 515       } else {
 516          Dmsg2(-1, "FileIndex   : %u-%u\n", FileIndex->findex, FileIndex->findex2);
 517       }
 518       dump_findex(FileIndex->next);
 519    }
 520 }
 521
 522 void dump_jobid(BSR_JOBID *jobid)
 523 {
 524    if (jobid) {
 525       if (jobid->JobId == jobid->JobId2) {
 526          Dmsg1(-1, "JobId       : %u\n", jobid->JobId);
 527       } else {
 528          Dmsg2(-1, "JobId       : %u-%u\n", jobid->JobId, jobid->JobId2);
 529       }
 530       dump_jobid(jobid->next);
 531    }
 532 }
 533
 534 void dump_sessid(BSR_SESSID *sessid)
 535 {
 536    if (sessid) {
 537       if (sessid->sessid == sessid->sessid2) {
 538          Dmsg1(-1, "SessId      : %u\n", sessid->sessid);
 539       } else {
 540          Dmsg2(-1, "SessId      : %u-%u\n", sessid->sessid, sessid->sessid2);
 541       }
 542       dump_sessid(sessid->next);
 543    }
 544 }
 545
 546 void dump_volume(BSR_VOLUME *volume)
 547 {
 548    if (volume) {
 549       Dmsg1(-1, "VolumeName  : %s\n", volume->VolumeName);
 550       dump_volume(volume->next);
 551    }
 552 }
 553
 554
 555 void dump_client(BSR_CLIENT *client)
 556 {
 557    if (client) {
 558       Dmsg1(-1, "Client      : %s\n", client->ClientName);
 559       dump_client(client->next);
 560    }
 561 }
 562
 563 void dump_job(BSR_JOB *job)
 564 {
 565    if (job) {
 566       Dmsg1(-1, "Job          : %s\n", job->Job);
 567       dump_job(job->next);
 568    }
 569 }
 570
 571 void dump_sesstime(BSR_SESSTIME *sesstime)
 572 {
 573    if (sesstime) {
 574       Dmsg1(-1, "SessTime    : %u\n", sesstime->sesstime);
 575       dump_sesstime(sesstime->next);
 576    }
 577 }
 578
 579
 580
 581
 582
 583 void dump_bsr(BSR *bsr)
 584 {
 585    if (!bsr) {
 586       Dmsg0(-1, "BSR is NULL\n");
 587       return;
 588    }
 589    Dmsg1(-1,
 590 "Next        : 0x%x\n", bsr->next);
 591    dump_volume(bsr->volume);
 592    dump_sessid(bsr->sessid);
 593    dump_sesstime(bsr->sesstime);
 594    dump_volfile(bsr->volfile);
 595    dump_client(bsr->client);
 596    dump_jobid(bsr->JobId);
 597    dump_job(bsr->job);
 598    dump_findex(bsr->FileIndex);
 599    if (bsr->next) {
 600       Dmsg0(-1, "\n");
 601       dump_bsr(bsr->next);
 602    }
 603 }
 604
 605
 606
 607 /*********************************************************************
 608  *
 609  *      Free bsr resources
 610  */
 611
 612 static void free_bsr_item(BSR *bsr)
 613 {
 614    if (bsr) {
 615       free_bsr_item(bsr->next);
 616       free(bsr);
 617    }
 618 }
 619
 620 void free_bsr(BSR *bsr)
 621 {
 622    if (!bsr) {
 623       return;
 624    }
 625    free_bsr_item((BSR *)bsr->volume);
 626    free_bsr_item((BSR *)bsr->client);
 627    free_bsr_item((BSR *)bsr->sessid);
 628    free_bsr_item((BSR *)bsr->sesstime);
 629    free_bsr_item((BSR *)bsr->volfile);
 630    free_bsr_item((BSR *)bsr->JobId);
 631    free_bsr_item((BSR *)bsr->job);
 632    free_bsr_item((BSR *)bsr->FileIndex);
 633    free_bsr_item((BSR *)bsr->JobType);
 634    free_bsr_item((BSR *)bsr->JobLevel);
 635    free_bsr(bsr->next);
 636    free(bsr);
 637 }
 638
 639 /*****************************************************************
 640  * Routines for handling volumes
 641  */
 642 VOL_LIST *new_vol()
 643 {
 644    VOL_LIST *vol;
 645    vol = (VOL_LIST *)malloc(sizeof(VOL_LIST));
 646    memset(vol, 0, sizeof(VOL_LIST));
 647    return vol;
 648 }
 649
 650 /*
 651  * Add current volume to end of list, only if the Volume
 652  * is not already in the list.
 653  *
 654  *   returns: 1 if volume added
 655  *            0 if volume already in list
 656  */
 657 int add_vol(JCR *jcr, VOL_LIST *vol)
 658 {
 659    VOL_LIST *next = jcr->VolList;
 660
 661    if (!next) {                       /* list empty ? */
 662       jcr->VolList = vol;             /* yes, add volume */
 663    } else {
 664       for ( ; next->next; next=next->next) {
 665          if (strcmp(vol->VolumeName, next->VolumeName) == 0) {
 666             return 0;                 /* already in list */
 667          }
 668       }
 669       if (strcmp(vol->VolumeName, next->VolumeName) == 0) {
 670          return 0;                    /* already in list */
 671       }
 672       next->next = vol;               /* add volume */
 673    }
 674    return 1;
 675 }
 676
 677 void free_vol_list(JCR *jcr)
 678 {
 679    VOL_LIST *next = jcr->VolList;
 680    VOL_LIST *tmp;
 681
 682    for ( ; next; ) {
 683       tmp = next->next;
 684       free(next);
 685       next = tmp;
 686    }
 687 }
 688
 689 void create_vol_list(JCR *jcr)
 690 {
 691    char *p, *n;
 692    VOL_LIST *vol;
 693
 694    /*
 695     * Build a list of volume to be processed
 696     */
 697    jcr->NumVolumes = 0;
 698    jcr->CurVolume = 1;
 699    if (jcr->bsr) {
 700       BSR *bsr = jcr->bsr;
 701       strcpy(jcr->VolumeName, bsr->volume->VolumeName); /* setup first volume */
 702       for ( ; bsr; bsr=bsr->next) {
 703          BSR_VOLUME *bsrvol = bsr->volume;
 704          for ( ; bsrvol; bsrvol=bsrvol->next) {
 705             vol = new_vol();
 706             strcpy(vol->VolumeName, bsrvol->VolumeName);
 707             if (add_vol(jcr, vol)) {
 708                jcr->NumVolumes++;
 709                Dmsg1(400, "Added volume %s\n", vol->VolumeName);
 710             } else {
 711                Dmsg1(400, "Duplicate volume %s\n", vol->VolumeName);
 712                free((char *)vol);
 713             }
 714          }
 715       }
 716    } else {
 717       /* This is the old way -- deprecated */
 718       for (p = jcr->VolumeName; p && *p; ) {
 719          n = strchr(p, '|');             /* volume name separator */
 720          if (n) {
 721             *n++ = 0;                    /* Terminate name */
 722          }
 723          vol = new_vol();
 724          strcpy(vol->VolumeName, p);
 725          if (add_vol(jcr, vol)) {
 726             jcr->NumVolumes++;
 727          } else {
 728             free((char *)vol);
 729          }
 730          p = n;
 731       }
 732    }
 733 }