X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fparse_bsr.c;h=83b0ff41422a67f3d68b153cd9ec432388fc3724;hb=562570f93a8dc0f9a2ebed286e8eed9ffd23a058;hp=4ff019b30c51ef272ebfef784fd06f822c736c10;hpb=1c31d780ff8befc9ef13c681d991bf235cb5f735;p=bacula%2Fbacula

diff --git a/bacula/src/stored/parse_bsr.c b/bacula/src/stored/parse_bsr.c
old mode 100755
new mode 100644
index 4ff019b30c..83b0ff4142
--- a/bacula/src/stored/parse_bsr.c
+++ b/bacula/src/stored/parse_bsr.c
@@ -1,29 +1,37 @@
-/*     
- *   Parse a Bootstrap Records (used for restores) 
- *  
+/*
+ *   Parse a Bootstrap Records (used for restores)
+ *
  *     Kern Sibbald, June MMII
  *
  *   Version $Id$
  */
-
 /*
-   Copyright (C) 2002 Kern Sibbald and John Walker
+   Bacula® - The Network Backup Solution
+
+   Copyright (C) 2002-2006 Free Software Foundation Europe e.V.
 
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of
-   the License, or (at your option) any later version.
+   The main author of Bacula is Kern Sibbald, with contributions from
+   many others, a complete list can be found in the file AUTHORS.
+   This program is Free Software; you can redistribute it and/or
+   modify it under the terms of version two of the GNU General Public
+   License as published by the Free Software Foundation and included
+   in the file LICENSE.
 
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    General Public License for more details.
 
-   You should have received a copy of the GNU General Public
-   License along with this program; if not, write to the Free
-   MA 02111-1307, USA.
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
 
- */
+   Bacula® is a registered trademark of Kern Sibbald.
+   The licensor of Bacula is the Free Software Foundation Europe
+   (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
+   Switzerland, email:ftf@fsfeurope.org.
+*/
 
 
 #include "bacula.h"
@@ -32,6 +40,8 @@
 typedef BSR * (ITEM_HANDLER)(LEX *lc, BSR *bsr);
 
 static BSR *store_vol(LEX *lc, BSR *bsr);
+static BSR *store_mediatype(LEX *lc, BSR *bsr);
+static BSR *store_device(LEX *lc, BSR *bsr);
 static BSR *store_client(LEX *lc, BSR *bsr);
 static BSR *store_job(LEX *lc, BSR *bsr);
 static BSR *store_jobid(LEX *lc, BSR *bsr);
@@ -60,6 +70,7 @@ struct kw_items {
  */
 struct kw_items items[] = {
    {"volume", store_vol},
+   {"mediatype", store_mediatype},
    {"client", store_client},
    {"job", store_job},
    {"jobid", store_jobid},
@@ -73,13 +84,14 @@ struct kw_items items[] = {
    {"exclude", store_exclude},
    {"volfile", store_volfile},
    {"volblock", store_volblock},
-   {"stream",  store_stream},
-   {"slot",    store_slot},
+   {"stream",   store_stream},
+   {"slot",     store_slot},
+   {"device",   store_device},
    {NULL, NULL}
 
 };
 
-/* 
+/*
  * Create a BSR record
  */
 static BSR *new_bsr()
@@ -90,7 +102,7 @@ static BSR *new_bsr()
 }
 
 /*
- * Format a scanner error message 
+ * Format a scanner error message
  */
 static void s_err(const char *file, int line, LEX *lc, const char *msg, ...)
 {
@@ -101,22 +113,22 @@ static void s_err(const char *file, int line, LEX *lc, const char *msg, ...)
    va_start(arg_ptr, msg);
    bvsnprintf(buf, sizeof(buf), msg, arg_ptr);
    va_end(arg_ptr);
-     
+
    if (jcr) {
-      Jmsg(jcr, M_FATAL, 0, _("Bootstrap file error: %s\n\
-            : Line %d, col %d of file %s\n%s\n"),
-	 buf, lc->line_no, lc->col_no, lc->fname, lc->line);
+      Jmsg(jcr, M_FATAL, 0, _("Bootstrap file error: %s\n"
+"            : Line %d, col %d of file %s\n%s\n"),
+         buf, lc->line_no, lc->col_no, lc->fname, lc->line);
    } else {
-      e_msg(file, line, M_FATAL, 0, _("Bootstrap file error: %s\n\
-            : Line %d, col %d of file %s\n%s\n"),
-	 buf, lc->line_no, lc->col_no, lc->fname, lc->line);
+      e_msg(file, line, M_FATAL, 0, _("Bootstrap file error: %s\n"
+"            : Line %d, col %d of file %s\n%s\n"),
+         buf, lc->line_no, lc->col_no, lc->fname, lc->line);
    }
 }
 
 
 /*********************************************************************
  *
- *	Parse Bootstrap file
+ *      Parse Bootstrap file
  *
  */
 BSR *parse_bsr(JCR *jcr, char *fname)
@@ -125,43 +137,47 @@ BSR *parse_bsr(JCR *jcr, char *fname)
    int token, i;
    BSR *root_bsr = new_bsr();
    BSR *bsr = root_bsr;
-     
-   Dmsg1(200, "Enter parse_bsf %s\n", fname);
-   lc = lex_open_file(lc, fname, s_err);
+
+   Dmsg1(300, "Enter parse_bsf %s\n", fname);
+   if ((lc = lex_open_file(lc, fname, s_err)) == NULL) {
+      berrno be;
+      Emsg2(M_ERROR_TERM, 0, _("Cannot open bootstrap file %s: %s\n"),
+            fname, be.bstrerror());
+   }
    lc->caller_ctx = (void *)jcr;
    while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
-      Dmsg1(200, "parse got token=%s\n", lex_tok_to_str(token));
+      Dmsg1(300, "parse got token=%s\n", lex_tok_to_str(token));
       if (token == T_EOL) {
-	 continue;
+         continue;
       }
       for (i=0; items[i].name; i++) {
-	 if (strcasecmp(items[i].name, lc->str) == 0) {
-	    token = lex_get_token(lc, T_ALL);
-            Dmsg1 (200, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
-	    if (token != T_EQUALS) {
+         if (strcasecmp(items[i].name, lc->str) == 0) {
+            token = lex_get_token(lc, T_ALL);
+            Dmsg1 (300, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
+            if (token != T_EQUALS) {
                scan_err1(lc, "expected an equals, got: %s", lc->str);
-	       bsr = NULL;
-	       break;
-	    }
-            Dmsg1(200, "calling handler for %s\n", items[i].name);
-	    /* Call item handler */
-	    bsr = items[i].handler(lc, bsr);
-	    i = -1;
-	    break;
-	 }
+               bsr = NULL;
+               break;
+            }
+            Dmsg1(300, "calling handler for %s\n", items[i].name);
+            /* Call item handler */
+            bsr = items[i].handler(lc, bsr);
+            i = -1;
+            break;
+         }
       }
       if (i >= 0) {
-         Dmsg1(200, "Keyword = %s\n", lc->str);
+         Dmsg1(300, "Keyword = %s\n", lc->str);
          scan_err1(lc, "Keyword %s not found", lc->str);
-	 bsr = NULL;
-	 break;
+         bsr = NULL;
+         break;
       }
       if (!bsr) {
-	 break;
+         break;
       }
    }
    lc = lex_close_file(lc);
-   Dmsg0(200, "Leave parse_bsf()\n");
+   Dmsg0(300, "Leave parse_bsf()\n");
    if (!bsr) {
       free_bsr(root_bsr);
       root_bsr = NULL;
@@ -183,11 +199,10 @@ static bool is_fast_rejection_ok(BSR *bsr)
     *  all bsrs to have both sesstime and sessid set before
     *  we do fast rejection.
     */
-   if (!(bsr->sesstime && bsr->sessid)) {
-      return false;
-   }
-   if (bsr->next) {
-      return is_fast_rejection_ok(bsr->next);
+   for ( ; bsr; bsr=bsr->next) {
+      if (!(bsr->sesstime && bsr->sessid)) {
+         return false;
+      }
    }
    return true;
 }
@@ -196,13 +211,12 @@ static bool is_positioning_ok(BSR *bsr)
 {
    /*
     * Every bsr should have a volfile entry and a volblock entry
-    *	if we are going to use positioning
+    *   if we are going to use positioning
     */
-   if (!bsr->volfile || !bsr->volblock) {
-      return false;
-   }
-   if (bsr->next) {
-      return is_positioning_ok(bsr->next);
+   for ( ; bsr; bsr=bsr->next) {
+      if (!bsr->volfile || !bsr->volblock) {
+         return false;
+      }
    }
    return true;
 }
@@ -213,7 +227,7 @@ static BSR *store_vol(LEX *lc, BSR *bsr)
    int token;
    BSR_VOLUME *volume;
    char *p, *n;
-    
+
    token = lex_get_token(lc, T_STRING);
    if (token == T_ERROR) {
       return NULL;
@@ -222,56 +236,100 @@ static BSR *store_vol(LEX *lc, BSR *bsr)
       bsr->next = new_bsr();
       bsr = bsr->next;
    }
-   /* This may actually be more than one volume separated by a |  
+   /* This may actually be more than one volume separated by a |
     * If so, separate them.
     */
    for (p=lc->str; p && *p; ) {
       n = strchr(p, '|');
       if (n) {
-	 *n++ = 0;
+         *n++ = 0;
       }
       volume = (BSR_VOLUME *)malloc(sizeof(BSR_VOLUME));
       memset(volume, 0, sizeof(BSR_VOLUME));
       bstrncpy(volume->VolumeName, p, sizeof(volume->VolumeName));
       /* Add it to the end of the volume chain */
       if (!bsr->volume) {
-	 bsr->volume = volume;
+         bsr->volume = volume;
       } else {
-	 BSR_VOLUME *bc = bsr->volume;
-	 for ( ;bc->next; bc=bc->next)	
-	    { }
-	 bc->next = volume;
+         BSR_VOLUME *bc = bsr->volume;
+         for ( ;bc->next; bc=bc->next)
+            { }
+         bc->next = volume;
       }
       p = n;
    }
    return bsr;
 }
 
+/* Shove the MediaType in each Volume in the current bsr */
+static BSR *store_mediatype(LEX *lc, BSR *bsr)
+{
+   int token;
+
+   token = lex_get_token(lc, T_STRING);
+   if (token == T_ERROR) {
+      return NULL;
+   }
+   if (!bsr->volume) {
+      Emsg1(M_ERROR,0, _("MediaType %s in bsr at inappropriate place.\n"),
+         lc->str);
+      return bsr;
+   }
+   BSR_VOLUME *bv;
+   for (bv=bsr->volume; bv; bv=bv->next) {
+      bstrncpy(bv->MediaType, lc->str, sizeof(bv->MediaType));
+   }
+   return bsr;
+}
+
+/* Shove the Device name in each Volume in the current bsr */
+static BSR *store_device(LEX *lc, BSR *bsr)
+{
+   int token;
+
+   token = lex_get_token(lc, T_STRING);
+   if (token == T_ERROR) {
+      return NULL;
+   }
+   if (!bsr->volume) {
+      Emsg1(M_ERROR,0, _("Device \"%s\" in bsr at inappropriate place.\n"),
+         lc->str);
+      return bsr;
+   }
+   BSR_VOLUME *bv;
+   for (bv=bsr->volume; bv; bv=bv->next) {
+      bstrncpy(bv->device, lc->str, sizeof(bv->device));
+   }
+   return bsr;
+}
+
+
+
 static BSR *store_client(LEX *lc, BSR *bsr)
 {
    int token;
    BSR_CLIENT *client;
-    
+
    for (;;) {
       token = lex_get_token(lc, T_NAME);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       client = (BSR_CLIENT *)malloc(sizeof(BSR_CLIENT));
       memset(client, 0, sizeof(BSR_CLIENT));
       bstrncpy(client->ClientName, lc->str, sizeof(client->ClientName));
       /* Add it to the end of the client chain */
       if (!bsr->client) {
-	 bsr->client = client;
+         bsr->client = client;
       } else {
-	 BSR_CLIENT *bc = bsr->client;
-	 for ( ;bc->next; bc=bc->next)	
-	    { }
-	 bc->next = client;
+         BSR_CLIENT *bc = bsr->client;
+         for ( ;bc->next; bc=bc->next)
+            { }
+         bc->next = client;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -281,28 +339,28 @@ static BSR *store_job(LEX *lc, BSR *bsr)
 {
    int token;
    BSR_JOB *job;
-    
+
    for (;;) {
       token = lex_get_token(lc, T_NAME);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       job = (BSR_JOB *)malloc(sizeof(BSR_JOB));
       memset(job, 0, sizeof(BSR_JOB));
       bstrncpy(job->Job, lc->str, sizeof(job->Job));
       /* Add it to the end of the client chain */
       if (!bsr->job) {
-	 bsr->job = job;
+         bsr->job = job;
       } else {
-	 /* Add to end of chain */
-	 BSR_JOB *bc = bsr->job;
-	 for ( ;bc->next; bc=bc->next)
-	    { }
-	 bc->next = job;
+         /* Add to end of chain */
+         BSR_JOB *bc = bsr->job;
+         for ( ;bc->next; bc=bc->next)
+            { }
+         bc->next = job;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -316,7 +374,7 @@ static BSR *store_findex(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_PINT32_RANGE);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       findex = (BSR_FINDEX *)malloc(sizeof(BSR_FINDEX));
       memset(findex, 0, sizeof(BSR_FINDEX));
@@ -324,17 +382,17 @@ static BSR *store_findex(LEX *lc, BSR *bsr)
       findex->findex2 = lc->pint32_val2;
       /* Add it to the end of the chain */
       if (!bsr->FileIndex) {
-	 bsr->FileIndex = findex;
+         bsr->FileIndex = findex;
       } else {
-	 /* Add to end of chain */
-	 BSR_FINDEX *bs = bsr->FileIndex;
-	 for ( ;bs->next; bs=bs->next)
-	    {  }
-	 bs->next = findex;
+         /* Add to end of chain */
+         BSR_FINDEX *bs = bsr->FileIndex;
+         for ( ;bs->next; bs=bs->next)
+            {  }
+         bs->next = findex;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -349,7 +407,7 @@ static BSR *store_jobid(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_PINT32_RANGE);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       jobid = (BSR_JOBID *)malloc(sizeof(BSR_JOBID));
       memset(jobid, 0, sizeof(BSR_JOBID));
@@ -357,17 +415,17 @@ static BSR *store_jobid(LEX *lc, BSR *bsr)
       jobid->JobId2 = lc->pint32_val2;
       /* Add it to the end of the chain */
       if (!bsr->JobId) {
-	 bsr->JobId = jobid;
+         bsr->JobId = jobid;
       } else {
-	 /* Add to end of chain */
-	 BSR_JOBID *bs = bsr->JobId;
-	 for ( ;bs->next; bs=bs->next)
-	    {  }
-	 bs->next = jobid;
+         /* Add to end of chain */
+         BSR_JOBID *bs = bsr->JobId;
+         for ( ;bs->next; bs=bs->next)
+            {  }
+         bs->next = jobid;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -391,7 +449,7 @@ static BSR *store_count(LEX *lc, BSR *bsr)
 static BSR *store_jobtype(LEX *lc, BSR *bsr)
 {
    /* *****FIXME****** */
-   Dmsg0(-1, "JobType not yet implemented\n");
+   Pmsg0(-1, _("JobType not yet implemented\n"));
    return bsr;
 }
 
@@ -399,7 +457,7 @@ static BSR *store_jobtype(LEX *lc, BSR *bsr)
 static BSR *store_joblevel(LEX *lc, BSR *bsr)
 {
    /* *****FIXME****** */
-   Dmsg0(-1, "JobLevel not yet implemented\n");
+   Pmsg0(-1, _("JobLevel not yet implemented\n"));
    return bsr;
 }
 
@@ -407,7 +465,7 @@ static BSR *store_joblevel(LEX *lc, BSR *bsr)
 
 
 /*
- * Routine to handle Volume start/end file   
+ * Routine to handle Volume start/end file
  */
 static BSR *store_volfile(LEX *lc, BSR *bsr)
 {
@@ -417,7 +475,7 @@ static BSR *store_volfile(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_PINT32_RANGE);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       volfile = (BSR_VOLFILE *)malloc(sizeof(BSR_VOLFILE));
       memset(volfile, 0, sizeof(BSR_VOLFILE));
@@ -425,17 +483,17 @@ static BSR *store_volfile(LEX *lc, BSR *bsr)
       volfile->efile = lc->pint32_val2;
       /* Add it to the end of the chain */
       if (!bsr->volfile) {
-	 bsr->volfile = volfile;
+         bsr->volfile = volfile;
       } else {
-	 /* Add to end of chain */
-	 BSR_VOLFILE *bs = bsr->volfile;
-	 for ( ;bs->next; bs=bs->next)
-	    {  }
-	 bs->next = volfile;
+         /* Add to end of chain */
+         BSR_VOLFILE *bs = bsr->volfile;
+         for ( ;bs->next; bs=bs->next)
+            {  }
+         bs->next = volfile;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -443,7 +501,7 @@ static BSR *store_volfile(LEX *lc, BSR *bsr)
 
 
 /*
- * Routine to handle Volume start/end Block  
+ * Routine to handle Volume start/end Block
  */
 static BSR *store_volblock(LEX *lc, BSR *bsr)
 {
@@ -453,7 +511,7 @@ static BSR *store_volblock(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_PINT32_RANGE);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       volblock = (BSR_VOLBLOCK *)malloc(sizeof(BSR_VOLBLOCK));
       memset(volblock, 0, sizeof(BSR_VOLBLOCK));
@@ -461,17 +519,17 @@ static BSR *store_volblock(LEX *lc, BSR *bsr)
       volblock->eblock = lc->pint32_val2;
       /* Add it to the end of the chain */
       if (!bsr->volblock) {
-	 bsr->volblock = volblock;
+         bsr->volblock = volblock;
       } else {
-	 /* Add to end of chain */
-	 BSR_VOLBLOCK *bs = bsr->volblock;
-	 for ( ;bs->next; bs=bs->next)
-	    {  }
-	 bs->next = volblock;
+         /* Add to end of chain */
+         BSR_VOLBLOCK *bs = bsr->volblock;
+         for ( ;bs->next; bs=bs->next)
+            {  }
+         bs->next = volblock;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -486,7 +544,7 @@ static BSR *store_sessid(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_PINT32_RANGE);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       sid = (BSR_SESSID *)malloc(sizeof(BSR_SESSID));
       memset(sid, 0, sizeof(BSR_SESSID));
@@ -494,17 +552,17 @@ static BSR *store_sessid(LEX *lc, BSR *bsr)
       sid->sessid2 = lc->pint32_val2;
       /* Add it to the end of the chain */
       if (!bsr->sessid) {
-	 bsr->sessid = sid;
+         bsr->sessid = sid;
       } else {
-	 /* Add to end of chain */
-	 BSR_SESSID *bs = bsr->sessid;
-	 for ( ;bs->next; bs=bs->next)
-	    {  }
-	 bs->next = sid;
+         /* Add to end of chain */
+         BSR_SESSID *bs = bsr->sessid;
+         for ( ;bs->next; bs=bs->next)
+            {  }
+         bs->next = sid;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -518,24 +576,24 @@ static BSR *store_sesstime(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_PINT32);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       stime = (BSR_SESSTIME *)malloc(sizeof(BSR_SESSTIME));
       memset(stime, 0, sizeof(BSR_SESSTIME));
       stime->sesstime = lc->pint32_val;
       /* Add it to the end of the chain */
       if (!bsr->sesstime) {
-	 bsr->sesstime = stime;
+         bsr->sesstime = stime;
       } else {
-	 /* Add to end of chain */
-	 BSR_SESSTIME *bs = bsr->sesstime;
-	 for ( ;bs->next; bs=bs->next)
-	    { }
-	 bs->next = stime;
+         /* Add to end of chain */
+         BSR_SESSTIME *bs = bsr->sesstime;
+         for ( ;bs->next; bs=bs->next)
+            { }
+         bs->next = stime;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -550,24 +608,24 @@ static BSR *store_stream(LEX *lc, BSR *bsr)
    for (;;) {
       token = lex_get_token(lc, T_INT32);
       if (token == T_ERROR) {
-	 return NULL;
+         return NULL;
       }
       stream = (BSR_STREAM *)malloc(sizeof(BSR_STREAM));
       memset(stream, 0, sizeof(BSR_STREAM));
       stream->stream = lc->int32_val;
       /* Add it to the end of the chain */
       if (!bsr->stream) {
-	 bsr->stream = stream;
+         bsr->stream = stream;
       } else {
-	 /* Add to end of chain */
-	 BSR_STREAM *bs = bsr->stream;
-	 for ( ;bs->next; bs=bs->next)
-	    { }
-	 bs->next = stream;
+         /* Add to end of chain */
+         BSR_STREAM *bs = bsr->stream;
+         for ( ;bs->next; bs=bs->next)
+            { }
+         bs->next = stream;
       }
       token = lex_get_token(lc, T_ALL);
       if (token != T_COMMA) {
-	 break;
+         break;
       }
    }
    return bsr;
@@ -581,7 +639,12 @@ static BSR *store_slot(LEX *lc, BSR *bsr)
    if (token == T_ERROR) {
       return NULL;
    }
-   bsr->Slot = lc->pint32_val;
+   if (!bsr->volume) {
+      Emsg1(M_ERROR,0, _("Slot %d in bsr at inappropriate place.\n"),
+         lc->pint32_val);
+      return bsr;
+   }
+   bsr->volume->Slot = lc->pint32_val;
    scan_to_eol(lc);
    return bsr;
 }
@@ -601,7 +664,7 @@ static BSR *store_exclude(LEX *lc, BSR *bsr)
 void dump_volfile(BSR_VOLFILE *volfile)
 {
    if (volfile) {
-      Dmsg2(-1, "VolFile     : %u-%u\n", volfile->sfile, volfile->efile);
+      Pmsg2(-1, _("VolFile     : %u-%u\n"), volfile->sfile, volfile->efile);
       dump_volfile(volfile->next);
    }
 }
@@ -609,7 +672,7 @@ void dump_volfile(BSR_VOLFILE *volfile)
 void dump_volblock(BSR_VOLBLOCK *volblock)
 {
    if (volblock) {
-      Dmsg2(-1, "VolBlock    : %u-%u\n", volblock->sblock, volblock->eblock);
+      Pmsg2(-1, _("VolBlock    : %u-%u\n"), volblock->sblock, volblock->eblock);
       dump_volblock(volblock->next);
    }
 }
@@ -619,9 +682,9 @@ void dump_findex(BSR_FINDEX *FileIndex)
 {
    if (FileIndex) {
       if (FileIndex->findex == FileIndex->findex2) {
-         Dmsg1(-1, "FileIndex   : %u\n", FileIndex->findex);
+         Pmsg1(-1, _("FileIndex   : %u\n"), FileIndex->findex);
       } else {
-         Dmsg2(-1, "FileIndex   : %u-%u\n", FileIndex->findex, FileIndex->findex2);
+         Pmsg2(-1, _("FileIndex   : %u-%u\n"), FileIndex->findex, FileIndex->findex2);
       }
       dump_findex(FileIndex->next);
    }
@@ -631,9 +694,9 @@ void dump_jobid(BSR_JOBID *jobid)
 {
    if (jobid) {
       if (jobid->JobId == jobid->JobId2) {
-         Dmsg1(-1, "JobId       : %u\n", jobid->JobId);
+         Pmsg1(-1, _("JobId       : %u\n"), jobid->JobId);
       } else {
-         Dmsg2(-1, "JobId       : %u-%u\n", jobid->JobId, jobid->JobId2);
+         Pmsg2(-1, _("JobId       : %u-%u\n"), jobid->JobId, jobid->JobId2);
       }
       dump_jobid(jobid->next);
    }
@@ -643,9 +706,9 @@ void dump_sessid(BSR_SESSID *sessid)
 {
    if (sessid) {
       if (sessid->sessid == sessid->sessid2) {
-         Dmsg1(-1, "SessId      : %u\n", sessid->sessid);
+         Pmsg1(-1, _("SessId      : %u\n"), sessid->sessid);
       } else {
-         Dmsg2(-1, "SessId      : %u-%u\n", sessid->sessid, sessid->sessid2);
+         Pmsg2(-1, _("SessId      : %u-%u\n"), sessid->sessid, sessid->sessid2);
       }
       dump_sessid(sessid->next);
    }
@@ -654,7 +717,10 @@ void dump_sessid(BSR_SESSID *sessid)
 void dump_volume(BSR_VOLUME *volume)
 {
    if (volume) {
-      Dmsg1(-1, "VolumeName  : %s\n", volume->VolumeName);
+      Pmsg1(-1, _("VolumeName  : %s\n"), volume->VolumeName);
+      Pmsg1(-1, _("  MediaType : %s\n"), volume->MediaType);
+      Pmsg1(-1, _("  Device    : %s\n"), volume->device);
+      Pmsg1(-1, _("  Slot      : %d\n"), volume->Slot);
       dump_volume(volume->next);
    }
 }
@@ -663,7 +729,7 @@ void dump_volume(BSR_VOLUME *volume)
 void dump_client(BSR_CLIENT *client)
 {
    if (client) {
-      Dmsg1(-1, "Client      : %s\n", client->ClientName);
+      Pmsg1(-1, _("Client      : %s\n"), client->ClientName);
       dump_client(client->next);
    }
 }
@@ -671,7 +737,7 @@ void dump_client(BSR_CLIENT *client)
 void dump_job(BSR_JOB *job)
 {
    if (job) {
-      Dmsg1(-1, "Job          : %s\n", job->Job);
+      Pmsg1(-1, _("Job          : %s\n"), job->Job);
       dump_job(job->next);
    }
 }
@@ -679,26 +745,23 @@ void dump_job(BSR_JOB *job)
 void dump_sesstime(BSR_SESSTIME *sesstime)
 {
    if (sesstime) {
-      Dmsg1(-1, "SessTime    : %u\n", sesstime->sesstime);
+      Pmsg1(-1, _("SessTime    : %u\n"), sesstime->sesstime);
       dump_sesstime(sesstime->next);
    }
 }
 
 
-
-
-
 void dump_bsr(BSR *bsr, bool recurse)
 {
    int save_debug = debug_level;
    debug_level = 1;
    if (!bsr) {
-      Dmsg0(-1, "BSR is NULL\n");
+      Pmsg0(-1, _("BSR is NULL\n"));
       debug_level = save_debug;
       return;
    }
-   Dmsg1(-1,    "Next        : 0x%x\n", bsr->next);
-   Dmsg1(-1,    "Root bsr    : 0x%x\n", bsr->root);
+   Pmsg1(-1,    _("Next        : 0x%x\n"), bsr->next);
+   Pmsg1(-1,    _("Root bsr    : 0x%x\n"), bsr->root);
    dump_volume(bsr->volume);
    dump_sessid(bsr->sessid);
    dump_sesstime(bsr->sesstime);
@@ -708,19 +771,16 @@ void dump_bsr(BSR *bsr, bool recurse)
    dump_jobid(bsr->JobId);
    dump_job(bsr->job);
    dump_findex(bsr->FileIndex);
-   if (bsr->Slot) {
-      Dmsg1(-1, "Slot        : %u\n", bsr->Slot);
-   }
    if (bsr->count) {
-      Dmsg1(-1, "count       : %u\n", bsr->count);
-      Dmsg1(-1, "found       : %u\n", bsr->found);
+      Pmsg1(-1, _("count       : %u\n"), bsr->count);
+      Pmsg1(-1, _("found       : %u\n"), bsr->found);
    }
 
-   Dmsg1(-1,    "done        : %s\n", bsr->done?"yes":"no");
-   Dmsg1(-1,    "positioning : %d\n", bsr->use_positioning);
-   Dmsg1(-1,    "fast_reject : %d\n", bsr->use_fast_rejection);
+   Pmsg1(-1,    _("done        : %s\n"), bsr->done?_("yes"):_("no"));
+   Pmsg1(-1,    _("positioning : %d\n"), bsr->use_positioning);
+   Pmsg1(-1,    _("fast_reject : %d\n"), bsr->use_fast_rejection);
    if (recurse && bsr->next) {
-      Dmsg0(-1, "\n");
+      Pmsg0(-1, "\n");
       dump_bsr(bsr->next, true);
    }
    debug_level = save_debug;
@@ -730,7 +790,7 @@ void dump_bsr(BSR *bsr, bool recurse)
 
 /*********************************************************************
  *
- *	Free bsr resources
+ *      Free bsr resources
  */
 
 static void free_bsr_item(BSR *bsr)
@@ -762,9 +822,9 @@ void free_bsr(BSR *bsr)
 }
 
 /*****************************************************************
- * Routines for handling volumes     
+ * Routines for handling volumes
  */
-VOL_LIST *new_vol()
+VOL_LIST *new_restore_volume()
 {
    VOL_LIST *vol;
    vol = (VOL_LIST *)malloc(sizeof(VOL_LIST));
@@ -772,40 +832,40 @@ VOL_LIST *new_vol()
    return vol;
 }
 
-/* 
+/*
  * Add current volume to end of list, only if the Volume
  * is not already in the list.
  *
  *   returns: 1 if volume added
- *	      0 if volume already in list
+ *            0 if volume already in list
  */
-int add_vol(JCR *jcr, VOL_LIST *vol)
+int add_restore_volume(JCR *jcr, VOL_LIST *vol)
 {
    VOL_LIST *next = jcr->VolList;
 
-   if (!next) { 		      /* list empty ? */
-      jcr->VolList = vol;	      /* yes, add volume */
+   if (!next) {                       /* list empty ? */
+      jcr->VolList = vol;             /* yes, add volume */
    } else {
       for ( ; next->next; next=next->next) {
-	 if (strcmp(vol->VolumeName, next->VolumeName) == 0) {
-	    if (vol->start_file < next->start_file) {
-	       next->start_file = vol->start_file;
-	    }
-	    return 0;		      /* already in list */
-	 }
+         if (strcmp(vol->VolumeName, next->VolumeName) == 0) {
+            if (vol->start_file < next->start_file) {
+               next->start_file = vol->start_file;
+            }
+            return 0;                 /* already in list */
+         }
       }
       if (strcmp(vol->VolumeName, next->VolumeName) == 0) {
-	 if (vol->start_file < next->start_file) {
-	    next->start_file = vol->start_file;
-	 }
-	 return 0;		      /* already in list */
+         if (vol->start_file < next->start_file) {
+            next->start_file = vol->start_file;
+         }
+         return 0;                    /* already in list */
       }
-      next->next = vol; 	      /* add volume */
+      next->next = vol;               /* add volume */
    }
    return 1;
 }
 
-void free_vol_list(JCR *jcr)
+void free_restore_volume_list(JCR *jcr)
 {
    VOL_LIST *next = jcr->VolList;
    VOL_LIST *tmp;
@@ -822,62 +882,67 @@ void free_vol_list(JCR *jcr)
  * Create a list of Volumes (and Slots and Start positions) to be
  *  used in the current restore job.
  */
-void create_vol_list(JCR *jcr)
+void create_restore_volume_list(JCR *jcr)
 {
    char *p, *n;
    VOL_LIST *vol;
 
-   /* 
+   /*
     * Build a list of volumes to be processed
     */
-   jcr->NumVolumes = 0;
-   jcr->CurVolume = 0;
+   jcr->NumReadVolumes = 0;
+   jcr->CurReadVolume = 0;
    if (jcr->bsr) {
       BSR *bsr = jcr->bsr;
       if (!bsr->volume || !bsr->volume->VolumeName) {
-	 return;
+         return;
       }
       for ( ; bsr; bsr=bsr->next) {
-	 BSR_VOLUME *bsrvol;
-	 BSR_VOLFILE *volfile;
-	 uint32_t sfile = UINT32_MAX;
-
-	 /* Find minimum start file so that we can forward space to it */
-	 for (volfile = bsr->volfile; volfile; volfile=volfile->next) {
-	    if (volfile->sfile < sfile) {
-	       sfile = volfile->sfile;
-	    }
-	 }
-	 /* Now add volumes for this bsr */
-	 for (bsrvol = bsr->volume; bsrvol; bsrvol=bsrvol->next) {
-	    vol = new_vol();
-	    bstrncpy(vol->VolumeName, bsrvol->VolumeName, sizeof(vol->VolumeName));
-	    vol->start_file = sfile;
-	    if (add_vol(jcr, vol)) {
-	       jcr->NumVolumes++;
-               Dmsg1(400, "Added volume %s\n", vol->VolumeName);
-	    } else {
+         BSR_VOLUME *bsrvol;
+         BSR_VOLFILE *volfile;
+         uint32_t sfile = UINT32_MAX;
+
+         /* Find minimum start file so that we can forward space to it */
+         for (volfile = bsr->volfile; volfile; volfile=volfile->next) {
+            if (volfile->sfile < sfile) {
+               sfile = volfile->sfile;
+            }
+         }
+         /* Now add volumes for this bsr */
+         for (bsrvol = bsr->volume; bsrvol; bsrvol=bsrvol->next) {
+            vol = new_restore_volume();
+            bstrncpy(vol->VolumeName, bsrvol->VolumeName, sizeof(vol->VolumeName));
+            bstrncpy(vol->MediaType,  bsrvol->MediaType,  sizeof(vol->MediaType));
+            bstrncpy(vol->device, bsrvol->device, sizeof(vol->device));
+            vol->Slot = bsrvol->Slot;
+            vol->start_file = sfile;
+            if (add_restore_volume(jcr, vol)) {
+               jcr->NumReadVolumes++;
+               Dmsg2(400, "Added volume=%s mediatype=%s\n", vol->VolumeName,
+                  vol->MediaType);
+            } else {
                Dmsg1(400, "Duplicate volume %s\n", vol->VolumeName);
-	       free((char *)vol);
-	    }
-	    sfile = 0;		      /* start at beginning of second volume */
-	 }
+               free((char *)vol);
+            }
+            sfile = 0;                /* start at beginning of second volume */
+         }
       }
    } else {
-      /* This is the old way -- deprecated */ 
+      /* This is the old way -- deprecated */
       for (p = jcr->dcr->VolumeName; p && *p; ) {
          n = strchr(p, '|');             /* volume name separator */
-	 if (n) {
-	    *n++ = 0;			 /* Terminate name */
-	 }
-	 vol = new_vol();
-	 bstrncpy(vol->VolumeName, p, sizeof(vol->VolumeName));
-	 if (add_vol(jcr, vol)) {
-	    jcr->NumVolumes++;
-	 } else {
-	    free((char *)vol);
-	 }
-	 p = n;
+         if (n) {
+            *n++ = 0;                    /* Terminate name */
+         }
+         vol = new_restore_volume();
+         bstrncpy(vol->VolumeName, p, sizeof(vol->VolumeName));
+         bstrncpy(vol->MediaType, jcr->dcr->media_type, sizeof(vol->MediaType));
+         if (add_restore_volume(jcr, vol)) {
+            jcr->NumReadVolumes++;
+         } else {
+            free((char *)vol);
+         }
+         p = n;
       }
    }
 }