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