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
  47 struct kw_items {
  48    char *name;
  49    ITEM_HANDLER *handler;
  50 };
  51
  52 struct kw_items items[] = {
  53    {"volume", store_vol},
  54    {"client", store_client},
  55    {"job", store_job},
  56    {"jobid", store_jobid},
  57    {"fileindex", store_findex},
  58    {"jobtype", store_jobtype},
  59    {"joblevel", store_joblevel},
  60    {"volsessionid", store_sessid},
  61    {"volsessiontime", store_sesstime},
  62    {"include", store_include},
  63    {"exclude", store_exclude},
  64    {"volfile", store_volfile},
  65    {NULL, NULL}
  66
  67 };
  68
  69 static BSR *new_bsr()
  70 {
  71    BSR *bsr = (BSR *)malloc(sizeof(BSR));
  72    memset(bsr, 0, sizeof(BSR));
  73    return bsr;
  74 }
  75
  76 /*********************************************************************
  77  *
  78  *      Parse Bootstrap file
  79  *
  80  */
  81 BSR *parse_bsr(char *cf)
  82 {
  83    LEX *lc = NULL;
  84    int token, i;
  85    BSR *root_bsr = new_bsr();
  86    BSR *bsr = root_bsr;
  87
  88    Dmsg0(200, "Enter parse_bsf()\n");
  89    lc = lex_open_file(lc, cf);
  90    while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
  91       Dmsg1(150, "parse got token=%s\n", lex_tok_to_str(token));
  92       if (token == T_EOL) {
  93          continue;
  94       }
  95       for (i=0; items[i].name; i++) {
  96          if (strcasecmp(items[i].name, lc->str) == 0) {
  97             token = lex_get_token(lc, T_ALL);
  98             Dmsg1 (150, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
  99             if (token != T_EQUALS) {
 100                scan_err1(lc, "expected an equals, got: %s", lc->str);
 101             }
 102             Dmsg1(100, "calling handler for %s\n", items[i].name);
 103             /* Call item handler */
 104             bsr = items[i].handler(lc, bsr);
 105             i = -1;
 106             break;
 107          }
 108       }
 109       if (i >= 0) {
 110          Dmsg1(150, "Keyword = %s\n", lc->str);
 111          scan_err1(lc, "Keyword %s not found", lc->str);
 112       }
 113
 114    }
 115    lc = lex_close_file(lc);
 116    Dmsg0(200, "Leave parse_bsf()\n");
 117    return root_bsr;
 118 }
 119
 120 static BSR *store_vol(LEX *lc, BSR *bsr)
 121 {
 122    int token;
 123
 124    token = lex_get_token(lc, T_NAME);
 125    if (bsr->VolumeName) {
 126       bsr->next = new_bsr();
 127       bsr = bsr->next;
 128    }
 129    bsr->VolumeName = bstrdup(lc->str);
 130    scan_to_eol(lc);
 131    return bsr;
 132 }
 133
 134 static BSR *store_client(LEX *lc, BSR *bsr)
 135 {
 136    int token;
 137    BSR_CLIENT *client;
 138
 139    for (;;) {
 140       token = lex_get_token(lc, T_NAME);
 141       client = (BSR_CLIENT *)malloc(sizeof(BSR_CLIENT));
 142       memset(client, 0, sizeof(BSR_CLIENT));
 143       client->ClientName = bstrdup(lc->str);
 144       /* Add it to the end of the client chain */
 145       if (!bsr->client) {
 146          bsr->client = client;
 147       } else {
 148          BSR_CLIENT *bc = bsr->client;
 149          for ( ;bc->next; bc=bc->next)
 150             { }
 151          bc->next = client;
 152       }
 153       token = lex_get_token(lc, T_ALL);
 154       if (token != T_COMMA) {
 155          break;
 156       }
 157    }
 158    return bsr;
 159 }
 160
 161 static BSR *store_job(LEX *lc, BSR *bsr)
 162 {
 163    int token;
 164    BSR_JOB *job;
 165
 166    for (;;) {
 167       token = lex_get_token(lc, T_NAME);
 168       job = (BSR_JOB *)malloc(sizeof(BSR_JOB));
 169       memset(job, 0, sizeof(BSR_JOB));
 170       job->Job = bstrdup(lc->str);
 171       /* Add it to the end of the client chain */
 172       if (!bsr->job) {
 173          bsr->job = job;
 174       } else {
 175          /* Add to end of chain */
 176          BSR_JOB *bc = bsr->job;
 177          for ( ;bc->next; bc=bc->next)
 178             { }
 179          bc->next = job;
 180       }
 181       token = lex_get_token(lc, T_ALL);
 182       if (token != T_COMMA) {
 183          break;
 184       }
 185    }
 186    return bsr;
 187 }
 188
 189 static BSR *store_findex(LEX *lc, BSR *bsr)
 190 {
 191    int token;
 192    BSR_FINDEX *findex;
 193
 194    for (;;) {
 195       token = lex_get_token(lc, T_PINT32_RANGE);
 196       findex = (BSR_FINDEX *)malloc(sizeof(BSR_FINDEX));
 197       memset(findex, 0, sizeof(BSR_FINDEX));
 198       findex->findex = lc->pint32_val;
 199       findex->findex2 = lc->pint32_val2;
 200       /* Add it to the end of the chain */
 201       if (!bsr->FileIndex) {
 202          bsr->FileIndex = findex;
 203       } else {
 204          /* Add to end of chain */
 205          BSR_FINDEX *bs = bsr->FileIndex;
 206          for ( ;bs->next; bs=bs->next)
 207             {  }
 208          bs->next = findex;
 209       }
 210       token = lex_get_token(lc, T_ALL);
 211       if (token != T_COMMA) {
 212          break;
 213       }
 214    }
 215    return bsr;
 216 }
 217
 218
 219 static BSR *store_jobid(LEX *lc, BSR *bsr)
 220 {
 221    int token;
 222    BSR_JOBID *jobid;
 223
 224    for (;;) {
 225       token = lex_get_token(lc, T_PINT32_RANGE);
 226       jobid = (BSR_JOBID *)malloc(sizeof(BSR_JOBID));
 227       memset(jobid, 0, sizeof(BSR_JOBID));
 228       jobid->JobId = lc->pint32_val;
 229       jobid->JobId2 = lc->pint32_val2;
 230       /* Add it to the end of the chain */
 231       if (!bsr->JobId) {
 232          bsr->JobId = jobid;
 233       } else {
 234          /* Add to end of chain */
 235          BSR_JOBID *bs = bsr->JobId;
 236          for ( ;bs->next; bs=bs->next)
 237             {  }
 238          bs->next = jobid;
 239       }
 240       token = lex_get_token(lc, T_ALL);
 241       if (token != T_COMMA) {
 242          break;
 243       }
 244    }
 245    return bsr;
 246 }
 247
 248 static BSR *store_jobtype(LEX *lc, BSR *bsr)
 249 {
 250    /* *****FIXME****** */
 251    Dmsg0(-1, "JobType not yet implemented\n");
 252    return bsr;
 253 }
 254
 255
 256 static BSR *store_joblevel(LEX *lc, BSR *bsr)
 257 {
 258    /* *****FIXME****** */
 259    Dmsg0(-1, "JobLevel not yet implemented\n");
 260    return bsr;
 261 }
 262
 263
 264
 265
 266 /*
 267  * Routine to handle Volume start/end file
 268  */
 269 static BSR *store_volfile(LEX *lc, BSR *bsr)
 270 {
 271    int token;
 272    BSR_VOLFILE *volfile;
 273
 274    for (;;) {
 275       token = lex_get_token(lc, T_PINT32_RANGE);
 276       volfile = (BSR_VOLFILE *)malloc(sizeof(BSR_VOLFILE));
 277       memset(volfile, 0, sizeof(BSR_VOLFILE));
 278       volfile->sfile = lc->pint32_val;
 279       volfile->efile = lc->pint32_val2;
 280       /* Add it to the end of the chain */
 281       if (!bsr->volfile) {
 282          bsr->volfile = volfile;
 283       } else {
 284          /* Add to end of chain */
 285          BSR_VOLFILE *bs = bsr->volfile;
 286          for ( ;bs->next; bs=bs->next)
 287             {  }
 288          bs->next = volfile;
 289       }
 290       token = lex_get_token(lc, T_ALL);
 291       if (token != T_COMMA) {
 292          break;
 293       }
 294    }
 295    return bsr;
 296 }
 297
 298
 299
 300 static BSR *store_sessid(LEX *lc, BSR *bsr)
 301 {
 302    int token;
 303    BSR_SESSID *sid;
 304
 305    for (;;) {
 306       token = lex_get_token(lc, T_PINT32_RANGE);
 307       sid = (BSR_SESSID *)malloc(sizeof(BSR_SESSID));
 308       memset(sid, 0, sizeof(BSR_SESSID));
 309       sid->sessid = lc->pint32_val;
 310       sid->sessid2 = lc->pint32_val2;
 311       /* Add it to the end of the chain */
 312       if (!bsr->sessid) {
 313          bsr->sessid = sid;
 314       } else {
 315          /* Add to end of chain */
 316          BSR_SESSID *bs = bsr->sessid;
 317          for ( ;bs->next; bs=bs->next)
 318             {  }
 319          bs->next = sid;
 320       }
 321       token = lex_get_token(lc, T_ALL);
 322       if (token != T_COMMA) {
 323          break;
 324       }
 325    }
 326    return bsr;
 327 }
 328
 329 static BSR *store_sesstime(LEX *lc, BSR *bsr)
 330 {
 331    int token;
 332    BSR_SESSTIME *stime;
 333
 334    for (;;) {
 335       token = lex_get_token(lc, T_PINT32);
 336       stime = (BSR_SESSTIME *)malloc(sizeof(BSR_SESSTIME));
 337       memset(stime, 0, sizeof(BSR_SESSTIME));
 338       stime->sesstime = lc->pint32_val;
 339       /* Add it to the end of the chain */
 340       if (!bsr->sesstime) {
 341          bsr->sesstime = stime;
 342       } else {
 343          /* Add to end of chain */
 344          BSR_SESSTIME *bs = bsr->sesstime;
 345          for ( ;bs->next; bs=bs->next)
 346             { }
 347          bs->next = stime;
 348       }
 349       token = lex_get_token(lc, T_ALL);
 350       if (token != T_COMMA) {
 351          break;
 352       }
 353    }
 354    return bsr;
 355 }
 356
 357 static BSR *store_include(LEX *lc, BSR *bsr)
 358 {
 359    scan_to_eol(lc);
 360    return bsr;
 361 }
 362
 363 static BSR *store_exclude(LEX *lc, BSR *bsr)
 364 {
 365    scan_to_eol(lc);
 366    return bsr;
 367 }
 368
 369 void dump_volfile(BSR_VOLFILE *volfile)
 370 {
 371    if (volfile) {
 372       Dmsg2(-1, "VolFile     : %u-%u\n", volfile->sfile, volfile->efile);
 373       dump_volfile(volfile->next);
 374    }
 375 }
 376
 377 void dump_findex(BSR_FINDEX *FileIndex)
 378 {
 379    if (FileIndex) {
 380       if (FileIndex->findex == FileIndex->findex2) {
 381          Dmsg1(-1, "FileIndex   : %u\n", FileIndex->findex);
 382       } else {
 383          Dmsg2(-1, "FileIndex   : %u-%u\n", FileIndex->findex, FileIndex->findex2);
 384       }
 385       dump_findex(FileIndex->next);
 386    }
 387 }
 388
 389 void dump_jobid(BSR_JOBID *jobid)
 390 {
 391    if (jobid) {
 392       if (jobid->JobId == jobid->JobId2) {
 393          Dmsg1(-1, "JobId       : %u\n", jobid->JobId);
 394       } else {
 395          Dmsg2(-1, "JobId       : %u-%u\n", jobid->JobId, jobid->JobId2);
 396       }
 397       dump_jobid(jobid->next);
 398    }
 399 }
 400
 401 void dump_sessid(BSR_SESSID *sessid)
 402 {
 403    if (sessid) {
 404       if (sessid->sessid == sessid->sessid2) {
 405          Dmsg1(-1, "SessId      : %u\n", sessid->sessid);
 406       } else {
 407          Dmsg2(-1, "SessId      : %u-%u\n", sessid->sessid, sessid->sessid2);
 408       }
 409       dump_sessid(sessid->next);
 410    }
 411 }
 412
 413
 414 void dump_client(BSR_CLIENT *client)
 415 {
 416    if (client) {
 417       Dmsg1(-1, "Client      : %s\n", client->ClientName);
 418       dump_client(client->next);
 419    }
 420 }
 421
 422 void dump_job(BSR_JOB *job)
 423 {
 424    if (job) {
 425       Dmsg1(-1, "Job          : %s\n", job->Job);
 426       dump_job(job->next);
 427    }
 428 }
 429
 430 void dump_sesstime(BSR_SESSTIME *sesstime)
 431 {
 432    if (sesstime) {
 433       Dmsg1(-1, "SessTime    : %u\n", sesstime->sesstime);
 434       dump_sesstime(sesstime->next);
 435    }
 436 }
 437
 438
 439
 440
 441
 442 void dump_bsr(BSR *bsr)
 443 {
 444    if (!bsr) {
 445       Dmsg0(-1, "BSR is NULL\n");
 446       return;
 447    }
 448    Dmsg2(-1,
 449 "Next        : 0x%x\n"
 450 "VolumeName  : %s\n",
 451                  bsr->next,
 452                  bsr->VolumeName ? bsr->VolumeName : "*None*");
 453    dump_sessid(bsr->sessid);
 454    dump_sesstime(bsr->sesstime);
 455    dump_volfile(bsr->volfile);
 456    dump_client(bsr->client);
 457    dump_jobid(bsr->JobId);
 458    dump_job(bsr->job);
 459    dump_findex(bsr->FileIndex);
 460    if (bsr->next) {
 461       Dmsg0(-1, "\n");
 462       dump_bsr(bsr->next);
 463    }
 464 }
 465
 466
 467
 468 /*********************************************************************
 469  *
 470  *      Free bsr resources
 471  */
 472
 473 static void free_bsr_item(BSR *bsr)
 474 {
 475    if (bsr) {
 476       free_bsr_item(bsr->next);
 477       free(bsr);
 478    }
 479 }
 480
 481 void free_bsr(BSR *bsr)
 482 {
 483    if (!bsr) {
 484       return;
 485    }
 486    free_bsr_item((BSR *)bsr->client);
 487    free_bsr_item((BSR *)bsr->sessid);
 488    free_bsr_item((BSR *)bsr->sesstime);
 489    free_bsr_item((BSR *)bsr->volfile);
 490    free_bsr_item((BSR *)bsr->JobId);
 491    free_bsr_item((BSR *)bsr->job);
 492    free_bsr_item((BSR *)bsr->FileIndex);
 493    free_bsr_item((BSR *)bsr->JobType);
 494    free_bsr_item((BSR *)bsr->JobLevel);
 495    if (bsr->VolumeName) {
 496       free(bsr->VolumeName);
 497    }
 498    free_bsr(bsr->next);
 499    free(bsr);
 500 }