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