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