Add address and socket for MySQL

git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@355 91ce42f0-d328-0410-95d8-f526ca767f89

diff --git a/bacula/src/cats/bdb.c b/bacula/src/cats/bdb.c
index d35bc53dac495c30992b49aa380480dc7aca6ccd..4a68ac03aec7e1c38a7c29f2b49f335e467c5e38 100644 (file)
--- a/bacula/src/cats/bdb.c
+++ b/bacula/src/cats/bdb.c
@@ -100,7 +100,8 @@ int bdb_write_control_file(B_DB *mdb)
  * never have errors, or it is really fatal.
  */
 B_DB *
-db_init_database(void *jcr, char *db_name, char *db_user, char *db_password)
+db_init_database(void *jcr, char *db_name, char *db_user, char *db_password,
+                char *db_address, int db_port, char *db_socket)
 {
    B_DB *mdb;
    P(mutex);                         /* lock DB queue */

diff --git a/bacula/src/cats/cats.h b/bacula/src/cats/cats.h
index abd39a24040e6306c4764aeb65972d3465278aeb..a9b7d7bb2280fddc42a344e3da16777f123ee3db 100644 (file)
--- a/bacula/src/cats/cats.h
+++ b/bacula/src/cats/cats.h
@@ -90,7 +90,10 @@ typedef struct s_db {
    int ref_count;
    char *db_name;
    char *db_user;
+   char *db_address;                  /* host name address */
+   char *db_socket;                   /* socket for local access */
    char *db_password;
+   int  db_port;                      /* port for host name address */
    int connected;
    char *sqlite_errmsg;               /* error message returned by sqlite */
    POOLMEM *errmsg;                   /* nicely edited error message */
@@ -161,6 +164,9 @@ typedef struct s_db {
    char *db_name;
    char *db_user;
    char *db_password;
+   char *db_address;                  /* host address */
+   char *db_socket;                   /* socket for local access */
+   int db_port;                       /* port of host address */
    int have_insert_id;                /* do have insert_id() */
    int connected;
    POOLMEM *errmsg;                   /* nicely edited error message */

diff --git a/bacula/src/cats/mysql.c b/bacula/src/cats/mysql.c
index e89fa92ebec021fedbf2bc0232532babab93f34c..47f965a0b2abdbc68d7efd9762e4c9f7275789bc 100644 (file)
--- a/bacula/src/cats/mysql.c
+++ b/bacula/src/cats/mysql.c
@@ -56,7 +56,8 @@ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  * never have errors, or it is really fatal.
  */
 B_DB *
-db_init_database(void *jcr, char *db_name, char *db_user, char *db_password)
+db_init_database(void *jcr, char *db_name, char *db_user, char *db_password, 
+                char *db_address, int db_port, char *db_socket) 
 {
    B_DB *mdb;
 
@@ -76,6 +77,13 @@ db_init_database(void *jcr, char *db_name, char *db_user, char *db_password)
    mdb->db_name = bstrdup(db_name);
    mdb->db_user = bstrdup(db_user);
    mdb->db_password = bstrdup(db_password);
+   if (db_address) {
+      mdb->db_address = bstrdup(db_address);
+   }
+   if (db_socket) {
+      mdb->db_socket = bstrdup(db_socket);
+   }
+   mdb->db_port = db_port;
    mdb->have_insert_id = TRUE;
    mdb->errmsg = get_pool_memory(PM_EMSG); /* get error message buffer */
    *mdb->errmsg = 0;
@@ -122,24 +130,24 @@ db_open_database(void *jcr, B_DB *mdb)
    Dmsg0(50, "mysql_init done\n");
    mdb->db = mysql_real_connect(
        &(mdb->mysql),                /* db */
-       NULL,                         /* default = localhost */
+       mdb->db_address,              /* default = localhost */
        mdb->db_user,                 /*  login name */
        mdb->db_password,             /*  password */
        mdb->db_name,                 /* database name */
-       0,                            /* default port */
-       NULL,                         /* default = socket */
+       mdb->db_port,                 /* default port */
+       mdb->db_socket,               /* default = socket */
        0);                           /* flags = none */
 
    /* If no connect, try once more incase it is a timing problem */
    if (mdb->db == NULL) {
       mdb->db = mysql_real_connect(
           &(mdb->mysql),                /* db */
-          NULL,                         /* default = localhost */
+          mdb->db_address,              /* default = localhost */
           mdb->db_user,                 /*  login name */
           mdb->db_password,             /*  password */
           mdb->db_name,                 /* database name */
-          0,                            /* default port */
-          NULL,                         /* default = socket */
+          mdb->db_port,                 /* default port */
+          mdb->db_socket,               /* default = socket */
           0);                           /* flags = none */
    }
     
@@ -196,6 +204,12 @@ db_close_database(void *jcr, B_DB *mdb)
       if (mdb->db_password) {
         free(mdb->db_password);
       }
+      if (mdb->db_address) {
+        free(mdb->db_address);
+      }
+      if (mdb->db_socket) {
+        free(mdb->db_socket);
+      }
       free(mdb);
    }
    V(mutex);

diff --git a/bacula/src/cats/protos.h b/bacula/src/cats/protos.h
index a212423604307806b3b25ffd619cc73459365e4a..4a5080a78bc86e047698b53e4436d797e2344c81 100644 (file)
--- a/bacula/src/cats/protos.h
+++ b/bacula/src/cats/protos.h
@@ -30,7 +30,8 @@
 /* Database prototypes */
 
 /* sql.c */
-B_DB *db_init_database(void *jcr, char *db_name, char *db_user, char *db_password);
+B_DB *db_init_database(void *jcr, char *db_name, char *db_user, char *db_password, 
+                       char *db_address, int db_port, char *db_socket);
 int db_open_database(void *jcr, B_DB *db);
 void db_close_database(void *jcr, B_DB *db);
 void db_escape_string(char *snew, char *old, int len);

diff --git a/bacula/src/cats/sqlite.c b/bacula/src/cats/sqlite.c
index 18cf9128a36c1766e1474c3d04589348ab92ca9c..9049e7bf60412a62daaab8244dd94ac2134c4ecb 100644 (file)
--- a/bacula/src/cats/sqlite.c
+++ b/bacula/src/cats/sqlite.c
@@ -59,7 +59,8 @@ int QueryDB(char *file, int line, void *jcr, B_DB *db, char *select_cmd);
  * never have errors, or it is really fatal.
  */
 B_DB *
-db_init_database(void *jcr, char *db_name, char *db_user, char *db_password)
+db_init_database(void *jcr, char *db_name, char *db_user, char *db_password,
+                char *db_address, int db_port, char *db_socket) 
 {
    B_DB *mdb;
 

diff --git a/bacula/src/dird/dird.c b/bacula/src/dird/dird.c
index c8ad804153902e7c9676180e86caa5b2639d3cda..23a4d83778e31c64e4aa31002956e9d21d071e9e 100644 (file)
--- a/bacula/src/dird/dird.c
+++ b/bacula/src/dird/dird.c
@@ -365,7 +365,8 @@ Without that I don't know who I am :-(\n"), configfile);
          * message because the server is probably not running.
          */
         db = db_init_database(NULL, catalog->db_name, catalog->db_user,
-                           catalog->db_password);
+                           catalog->db_password, catalog->db_address,
+                           catalog->db_port, catalog->db_socket);
         if (!db_open_database(NULL, db)) {
             Jmsg(NULL, M_FATAL,  0, "%s", db_strerror(db));
         } else {

diff --git a/bacula/src/dird/dird_conf.c b/bacula/src/dird/dird_conf.c
index 7fb3765166ccfb49348cdea6b64448207bfad636..c13a348ae607010792b4102f964d025ac850c41f 100644 (file)
--- a/bacula/src/dird/dird_conf.c
+++ b/bacula/src/dird/dird_conf.c
@@ -146,12 +146,14 @@ static struct res_items store_items[] = {
 static struct res_items cat_items[] = {
    {"name",     store_name,     ITEM(res_cat.hdr.name),    0, ITEM_REQUIRED, 0},
    {"description", store_str,   ITEM(res_cat.hdr.desc),    0, 0, 0},
-   {"address",  store_str,      ITEM(res_cat.address),     0, 0, 0},
-   {"dbport",   store_pint,     ITEM(res_cat.DBport),      0, 0, 0},
+   {"address",  store_str,      ITEM(res_cat.db_address),  0, 0, 0},
+   {"dbaddress", store_str,     ITEM(res_cat.db_address),  0, 0, 0},
+   {"dbport",   store_pint,     ITEM(res_cat.db_port),      0, 0, 0},
    /* keep this password as store_str for the moment */
    {"password", store_str,      ITEM(res_cat.db_password), 0, 0, 0},
    {"user",     store_str,      ITEM(res_cat.db_user),     0, 0, 0},
    {"dbname",   store_str,      ITEM(res_cat.db_name),     0, ITEM_REQUIRED, 0},
+   {"dbsocket", store_str,      ITEM(res_cat.db_socket),   0, 0, 0}, 
    {NULL, NULL, NULL, 0, 0, 0} 
 };
 
@@ -494,8 +496,8 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, char *fmt, ...
       case R_CATALOG:
          sendit(sock, "Catalog: name=%s address=%s DBport=%d db_name=%s\n\
          db_user=%s\n",
-           res->res_cat.hdr.name, NPRT(res->res_cat.address),
-           res->res_cat.DBport, res->res_cat.db_name, NPRT(res->res_cat.db_user));
+           res->res_cat.hdr.name, NPRT(res->res_cat.db_address),
+           res->res_cat.db_port, res->res_cat.db_name, NPRT(res->res_cat.db_user));
         break;
       case R_JOB:
          sendit(sock, "Job: name=%s JobType=%d level=%s\n", res->res_job.hdr.name, 
@@ -716,24 +718,35 @@ void free_resource(int type)
         }
         break;
       case R_STORAGE:
-        if (res->res_store.address)
+        if (res->res_store.address) {
            free(res->res_store.address);
-        if (res->res_store.password)
+        }
+        if (res->res_store.password) {
            free(res->res_store.password);
-        if (res->res_store.media_type)
+        }
+        if (res->res_store.media_type) {
            free(res->res_store.media_type);
-        if (res->res_store.dev_name)
+        }
+        if (res->res_store.dev_name) {
            free(res->res_store.dev_name);
+        }
         break;
       case R_CATALOG:
-        if (res->res_cat.address)
-           free(res->res_cat.address);
-        if (res->res_cat.db_user)
+        if (res->res_cat.db_address) {
+           free(res->res_cat.db_address);
+        }
+        if (res->res_cat.db_socket) {
+           free(res->res_cat.db_socket);
+        }
+        if (res->res_cat.db_user) {
            free(res->res_cat.db_user);
-        if (res->res_cat.db_name)
+        }
+        if (res->res_cat.db_name) {
            free(res->res_cat.db_name);
-        if (res->res_cat.db_password)
+        }
+        if (res->res_cat.db_password) {
            free(res->res_cat.db_password);
+        }
         break;
       case R_FILESET:
         if ((num=res->res_fs.num_includes)) {

diff --git a/bacula/src/dird/dird_conf.h b/bacula/src/dird/dird_conf.h
index b6bd05a1ceb3ee1ace5fcdd3c9df8c050ea36990..aef4215df906f83778fcba7dc51420cffe852a25 100644 (file)
--- a/bacula/src/dird/dird_conf.h
+++ b/bacula/src/dird/dird_conf.h
@@ -139,8 +139,9 @@ typedef struct s_res_store STORE;
 struct s_res_cat {
    RES  hdr;
 
-   int  DBport;                      /* Port -- not yet implemented */
-   char *address;
+   int  db_port;                     /* Port -- not yet implemented */
+   char *db_address;                 /* host name for remote access */
+   char *db_socket;                  /* Socket for local access */
    char *db_password;
    char *db_user;
    char *db_name;

diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c
index fd0f0804bf311b8ce27f31c2146ffb49d2e69a0b..fc95c6b1a9bd2cb1f7a7481917bd58f1d59e493d 100644 (file)
--- a/bacula/src/dird/job.c
+++ b/bacula/src/dird/job.c
@@ -93,7 +93,8 @@ void run_job(JCR *jcr)
     */
    Dmsg0(50, "Open database\n");
    jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user,
-                           jcr->catalog->db_password);
+                           jcr->catalog->db_password, jcr->catalog->db_address,
+                           jcr->catalog->db_port, jcr->catalog->db_socket);
    if (!db_open_database(jcr, jcr->db)) {
       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
       db_close_database(jcr, jcr->db);

diff --git a/bacula/src/dird/ua_cmds.c b/bacula/src/dird/ua_cmds.c
index e4bb83dddfb68d9a5306fc3d6127b5ce2523b9bb..908f3a47164393dac6052821f52c93d5dc5d9118 100644 (file)
--- a/bacula/src/dird/ua_cmds.c
+++ b/bacula/src/dird/ua_cmds.c
@@ -1512,7 +1512,8 @@ int open_db(UAContext *ua)
 
    Dmsg0(150, "Open database\n");
    ua->db = db_init_database(ua->jcr, ua->catalog->db_name, ua->catalog->db_user,
-                            ua->catalog->db_password);
+                            ua->catalog->db_password, ua->catalog->db_address,
+                            ua->catalog->db_port, ua->catalog->db_socket);
    if (!db_open_database(ua->jcr, ua->db)) {
       bsendmsg(ua, _("Could not open DB %s: ERR=%s"), 
         ua->catalog->db_name, db_strerror(ua->db));

diff --git a/bacula/src/stored/bcopy.c b/bacula/src/stored/bcopy.c
index a8057eea54a89c61166d9b1a1a4d788bf77a2b29..69dc4ee1f500f9c0f8bfffb8b578658e8609f74c 100644 (file)
--- a/bacula/src/stored/bcopy.c
+++ b/bacula/src/stored/bcopy.c
@@ -60,6 +60,8 @@ static void usage()
 "       -c <file>         specify configuration file\n"
 "       -dnn              set debug level to nn\n"
 "       -v                verbose\n"
+"       -i                specify input Volume names (separated by |)\n"
+"       -o                specify output Volume names (separated by |)\n"
 "       -w dir            specify working directory (default /tmp)\n"
 "       -?                print this message\n\n"));
    exit(1);
@@ -68,11 +70,13 @@ static void usage()
 int main (int argc, char *argv[])
 {
    int ch;
+   char *iVolumeName = NULL;
+   char *oVolumeName = NULL;
 
    my_name_is(argc, argv, "bscan");
    init_msg(NULL, NULL);
 
-   while ((ch = getopt(argc, argv, "b:c:d:mn:p:rsu:vw:?")) != -1) {
+   while ((ch = getopt(argc, argv, "b:c:d:mn:p:rsu:vV:w:?")) != -1) {
       switch (ch) {
          case 'b':
            bsr = parse_bsr(NULL, optarg);
@@ -95,6 +99,15 @@ int main (int argc, char *argv[])
            verbose++;
            break;
 
+         case 'i':                    /* input Volume name */
+           iVolumeName = optarg;
+           break;
+
+         case 'o':                    /* output Volume name */
+           oVolumeName = optarg;
+           break;
+
+
          case 'w':
            wd = optarg;
            break;
@@ -122,14 +135,14 @@ int main (int argc, char *argv[])
    parse_config(configfile);
 
    /* Setup and acquire input device for reading */
-   in_jcr = setup_jcr("bcopy", argv[0], bsr);
+   in_jcr = setup_jcr("bcopy", argv[0], bsr, iVolumeName);
    in_dev = setup_to_access_device(in_jcr, 1);  /* read device */
    if (!in_dev) { 
       exit(1);
    }
 
    /* Setup output device for writing */
-   out_jcr = setup_jcr("bcopy", argv[1], bsr);
+   out_jcr = setup_jcr("bcopy", argv[1], bsr, oVolumeName);
    out_dev = setup_to_access_device(out_jcr, 0);   /* no acquire */  
    if (!out_dev) { 
       exit(1);     

diff --git a/bacula/src/stored/bextract.c b/bacula/src/stored/bextract.c
index 645c11bdabc4c629a2bcea3fbffaee77bae6c3a4..69df799ba7415522ac3f977ea944d175cd3c45d7 100644 (file)
--- a/bacula/src/stored/bextract.c
+++ b/bacula/src/stored/bextract.c
@@ -63,6 +63,7 @@ static POOLMEM *compress_buf;
 static int type;
 static int stream;
 static int prog_name_msg = 0;
+static char *VolumeName = NULL;
 
 static char *wbuf;                   /* write buffer address */
 static uint32_t wsize;               /* write size */
@@ -82,6 +83,7 @@ static void usage()
 "       -dnn            set debug level to nn\n"
 "       -e <file>       exclude list\n"
 "       -i <file>       include list\n"
+"       -V              specify Volume names (separated by |)\n"
 "       -?              print this message\n\n");
    exit(1);
 }
@@ -150,6 +152,10 @@ int main (int argc, char *argv[])
            got_inc = TRUE;
            break;
 
+         case 'V':                    /* Volume name */
+           VolumeName = optarg;
+           break;
+
          case '?':
         default:
            usage();
@@ -186,7 +192,7 @@ int main (int argc, char *argv[])
 static void do_extract(char *devname)
 {
 
-   jcr = setup_jcr("bextract", devname, bsr);
+   jcr = setup_jcr("bextract", devname, bsr, VolumeName);
    dev = setup_to_access_device(jcr, 1);    /* acquire for read */
    if (!dev) {
       exit(1);

diff --git a/bacula/src/stored/bls.c b/bacula/src/stored/bls.c
index 6c2ec78ca92c95cfac68762a5648fc94856efb45..774417c087e7de6e062a6d14aee5d6b04356622b 100644 (file)
--- a/bacula/src/stored/bls.c
+++ b/bacula/src/stored/bls.c
@@ -67,9 +67,9 @@ static void usage()
 "       -i <file>       include list\n"
 "       -j              list jobs\n"
 "       -k              list blocks\n"
-"       -L              list tape label\n"
 "    (none of above)    list saved files\n"
 "       -v              be verbose\n"
+"       -V              specify Volume names (separated by |)\n"
 "       -?              print this message\n\n");
    exit(1);
 }
@@ -80,6 +80,8 @@ int main (int argc, char *argv[])
    int i, ch;
    FILE *fd;
    char line[1000];
+   char *VolumeName= NULL;
+   char *bsrName = NULL;
 
    working_directory = "/tmp";
    my_name_is(argc, argv, "bls");
@@ -88,11 +90,10 @@ int main (int argc, char *argv[])
    memset(&ff, 0, sizeof(ff));
    init_include_exclude_files(&ff);
 
-   while ((ch = getopt(argc, argv, "b:c:d:e:i:jkLtv?")) != -1) {
+   while ((ch = getopt(argc, argv, "b:c:d:e:i:jkLtvV:?")) != -1) {
       switch (ch) {
          case 'b':
-           bsr = parse_bsr(NULL, optarg);
-//         dump_bsr(bsr);
+           bsrName = optarg;
            break;
 
          case 'c':                    /* specify config file */
@@ -152,6 +153,10 @@ int main (int argc, char *argv[])
            verbose++;
            break;
 
+         case 'V':                    /* Volume name */
+           VolumeName = optarg;
+           break;
+
          case '?':
         default:
            usage();
@@ -172,13 +177,15 @@ int main (int argc, char *argv[])
 
    parse_config(configfile);
 
-
    if (ff.included_files_list == NULL) {
       add_fname_to_include_list(&ff, 0, "/");
    }
 
    for (i=0; i < argc; i++) {
-      jcr = setup_jcr("bls", argv[i], bsr);
+      if (bsrName) {
+        bsr = parse_bsr(NULL, bsrName);
+      }
+      jcr = setup_jcr("bls", argv[i], bsr, VolumeName);
       dev = setup_to_access_device(jcr, 1);   /* acquire for read */
       if (!dev) {
         exit(1);
@@ -301,7 +308,6 @@ static void do_ls(char *infname)
       dump_volume_label(dev);
       return;
    }
-
    read_records(jcr, dev, record_cb, mount_next_read_volume);
    printf("%u files found.\n", num_files);
 }

diff --git a/bacula/src/stored/bscan.c b/bacula/src/stored/bscan.c
index 05f8a7ce2d0b7951b3880267478ad7ef14fe1647..c185e03cca5b7d7f7e50b98a017216f710b53142 100644 (file)
--- a/bacula/src/stored/bscan.c
+++ b/bacula/src/stored/bscan.c
@@ -107,6 +107,7 @@ static void usage()
 "       -r                list records\n"
 "       -s                synchronize or store in database\n"
 "       -v                verbose\n"
+"       -V              specify Volume names (separated by |)\n"
 "       -w dir            specify working directory (default from conf file)\n"
 "       -?                print this message\n\n"));
    exit(1);
@@ -116,6 +117,7 @@ int main (int argc, char *argv[])
 {
    int ch;
    struct stat stat_buf;
+   char *VolumeName = NULL;
 
    my_name_is(argc, argv, "bscan");
    init_msg(NULL, NULL);
@@ -168,6 +170,10 @@ int main (int argc, char *argv[])
            verbose++;
            break;
 
+         case 'V':                    /* Volume name */
+           VolumeName = optarg;
+           break;
+
          case 'w':
            wd = optarg;
            break;
@@ -219,13 +225,13 @@ int main (int argc, char *argv[])
         working_directory);
    }
 
-   bjcr = setup_jcr("bscan", argv[0], bsr);
+   bjcr = setup_jcr("bscan", argv[0], bsr, VolumeName);
    dev = setup_to_access_device(bjcr, 1);   /* read device */
    if (!dev) { 
       exit(1);
    }
 
-   if ((db=db_init_database(NULL, db_name, db_user, db_password)) == NULL) {
+   if ((db=db_init_database(NULL, db_name, db_user, db_password, NULL, 0, NULL)) == NULL) {
       Emsg0(M_ERROR_TERM, 0, _("Could not init Bacula database\n"));
    }
    if (!db_open_database(NULL, db)) {

diff --git a/bacula/src/stored/btape.c b/bacula/src/stored/btape.c
index 8bac101d7ccb1925ce718e5afd8c8ee06f001be9..e60ad718acf0870e5e3fa6d74342caf5b74d99dd 100644 (file)
--- a/bacula/src/stored/btape.c
+++ b/bacula/src/stored/btape.c
@@ -206,7 +206,7 @@ int main(int argc, char *argv[])
       exit(1);
    }
 
-   jcr = setup_jcr("btape", argv[0], bsr);
+   jcr = setup_jcr("btape", argv[0], bsr, NULL);
    dev = setup_to_access_device(jcr, 0);     /* acquire for write */
    if (!dev) {
       exit(1);

diff --git a/bacula/src/stored/butil.c b/bacula/src/stored/butil.c
index 40389710b58c485b4d9c97c5cadc6529cc8b115b..dd9343c5a114cc2b50951e55dfb6aa0262feed53 100644 (file)
--- a/bacula/src/stored/butil.c
+++ b/bacula/src/stored/butil.c
@@ -75,15 +75,20 @@ DEVICE *setup_to_access_device(JCR *jcr, int read_access)
    char *p;
    DEVRES *device;
 
-   jcr->VolumeName[0] = 0;
-   if (strncmp(jcr->dev_name, "/dev/", 5) != 0) {
-      /* Try stripping file part */
-      p = jcr->dev_name + strlen(jcr->dev_name);
-      while (p >= jcr->dev_name && *p != '/')
-        p--;
-      if (*p == '/') {
-        strcpy(jcr->VolumeName, p+1);
-        *p = 0;
+   /*
+    * If no volume name already given and no bsr, and it is a file,
+    * try getting name from Filename  
+    */
+   if (!jcr->bsr && jcr->VolumeName[0] == 0) {
+      if (strncmp(jcr->dev_name, "/dev/", 5) != 0) {
+        /* Try stripping file part */
+        p = jcr->dev_name + strlen(jcr->dev_name);
+         while (p >= jcr->dev_name && *p != '/')
+           p--;
+         if (*p == '/') {
+           strcpy(jcr->VolumeName, p+1);
+           *p = 0;
+        }
       }
    }
 
@@ -192,13 +197,13 @@ static void my_free_jcr(JCR *jcr)
  * Setup a "daemon" JCR for the various standalone
  *  tools (e.g. bls, bextract, bscan, ...)
  */
-JCR *setup_jcr(char *name, char *device, BSR *bsr) 
+JCR *setup_jcr(char *name, char *device, BSR *bsr, char *VolumeName)
 {
    JCR *jcr = new_jcr(sizeof(JCR), my_free_jcr);
    jcr->VolSessionId = 1;
    jcr->VolSessionTime = (uint32_t)time(NULL);
    jcr->bsr = bsr;
-   jcr->NumVolumes = 1;
+   jcr->NumVolumes = 0;
    jcr->pool_name = get_pool_memory(PM_FNAME);
    strcpy(jcr->pool_name, "Default");
    jcr->pool_type = get_pool_memory(PM_FNAME);
@@ -218,6 +223,9 @@ JCR *setup_jcr(char *name, char *device, BSR *bsr)
    jcr->JobStatus = JS_Terminated;
    jcr->dev_name = get_pool_memory(PM_FNAME);
    pm_strcpy(&jcr->dev_name, device);
+   if (!bsr && VolumeName) {
+      pm_strcpy(&jcr->VolumeName, VolumeName);
+   }
    return jcr;
 }
 

diff --git a/bacula/src/stored/label.c b/bacula/src/stored/label.c
index e23c5062a6b4b182e13a0e57a24d217b7d922f4b..d1ee526a1b5350d479160c96b5be4bcf41bdeaf4 100644 (file)
--- a/bacula/src/stored/label.c
+++ b/bacula/src/stored/label.c
@@ -65,8 +65,8 @@ int read_dev_volume_label(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
       dev_name(dev), VolName);
 
    if (dev->state & ST_LABEL) {       /* did we already read label? */
-      /* Compare Volume Names */
-      if (VolName && *VolName && strcmp(dev->VolHdr.VolName, VolName) != 0) {
+      /* Compare Volume Names allow special wild card */
+      if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolName, VolName) != 0) {
          Mmsg(&jcr->errmsg, _("Volume name mismatch on device %s: Wanted %s got %s\n"),
            dev_name(dev), VolName, dev->VolHdr.VolName);
         /*
@@ -133,7 +133,7 @@ because:\n   %s"), dev_name(dev), strerror_dev(dev));
 
    /* Compare Volume Names */
    Dmsg2(30, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolName);
-   if (VolName && *VolName && strcmp(dev->VolHdr.VolName, VolName) != 0) {
+   if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolName, VolName) != 0) {
       Mmsg(&jcr->errmsg, _("Volume name mismatch. Wanted %s got %s\n"),
         VolName, dev->VolHdr.VolName);
       /*

diff --git a/bacula/src/stored/protos.h b/bacula/src/stored/protos.h
index 6f0b4db6ff706138c63f6e916c017c5540f4e106..c74f40e7f5fbed18597b2f7ff5fc4a524e59ed73 100644 (file)
--- a/bacula/src/stored/protos.h
+++ b/bacula/src/stored/protos.h
@@ -28,82 +28,82 @@
 uint32_t new_VolSessionId();
 
 /* From acquire.c */
-DEVICE  *acquire_device_for_append(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-int      acquire_device_for_read(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-int      release_device(JCR *jcr, DEVICE *dev);
+DEVICE *acquire_device_for_append(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+int     acquire_device_for_read(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+int     release_device(JCR *jcr, DEVICE *dev);
 
 /* From askdir.c */
-int     dir_get_volume_info(JCR *jcr, int writing);
-int     dir_find_next_appendable_volume(JCR *jcr);
-int     dir_update_volume_info(JCR *jcr, VOLUME_CAT_INFO *vol, int relabel);
-int     dir_ask_sysop_to_mount_next_volume(JCR *jcr, DEVICE *dev);
-int     dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev);
-int     dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec);
-int     dir_send_job_status(JCR *jcr);
-int     dir_create_jobmedia_record(JCR *jcr);
+int    dir_get_volume_info(JCR *jcr, int writing);
+int    dir_find_next_appendable_volume(JCR *jcr);
+int    dir_update_volume_info(JCR *jcr, VOLUME_CAT_INFO *vol, int relabel);
+int    dir_ask_sysop_to_mount_next_volume(JCR *jcr, DEVICE *dev);
+int    dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev);
+int    dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec);
+int    dir_send_job_status(JCR *jcr);
+int    dir_create_jobmedia_record(JCR *jcr);
 
 /* authenticate.c */
-int     authenticate_director(JCR *jcr);
-int     authenticate_filed(JCR *jcr);
+int    authenticate_director(JCR *jcr);
+int    authenticate_filed(JCR *jcr);
 
 /* From block.c */
-void    dump_block(DEV_BLOCK *b, char *msg);
+void   dump_block(DEV_BLOCK *b, char *msg);
 DEV_BLOCK *new_block(DEVICE *dev);
-void    init_block_write(DEV_BLOCK *block);
-void    empty_block(DEV_BLOCK *block);
-void    free_block(DEV_BLOCK *block);
-int     write_block_to_device(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-int     write_block_to_dev(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-int     read_block_from_device(DEVICE *dev, DEV_BLOCK *block);
-int     read_block_from_dev(DEVICE *dev, DEV_BLOCK *block);
+void   init_block_write(DEV_BLOCK *block);
+void   empty_block(DEV_BLOCK *block);
+void   free_block(DEV_BLOCK *block);
+int    write_block_to_device(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+int    write_block_to_dev(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+int    read_block_from_device(DEVICE *dev, DEV_BLOCK *block);
+int    read_block_from_dev(DEVICE *dev, DEV_BLOCK *block);
 
 /* From butil.c -- utilities for SD tool programs */
-void    print_ls_output(char *fname, char *link, int type, struct stat *statp);
-JCR    *setup_jcr(char *name, char *device, BSR *bsr); 
+void   print_ls_output(char *fname, char *link, int type, struct stat *statp);
+JCR    *setup_jcr(char *name, char *device, BSR *bsr, char *VolumeName);
 DEVICE *setup_to_access_device(JCR *jcr, int read_access);
-void    display_error_status(DEVICE *dev);
+void   display_error_status(DEVICE *dev);
 DEVRES *find_device_res(char *device_name, int read_access);
 
 
 /* From dev.c */
-DEVICE  *init_dev(DEVICE *dev, DEVRES *device);
-int      open_dev(DEVICE *dev, char *VolName, int mode);
-void     close_dev(DEVICE *dev);
-void     force_close_dev(DEVICE *dev);
-int      truncate_dev(DEVICE *dev);
-void     term_dev(DEVICE *dev);
-char *   strerror_dev(DEVICE *dev);
-void     clrerror_dev(DEVICE *dev, int func);
-int      update_pos_dev(DEVICE *dev);
-int      rewind_dev(DEVICE *dev);
-int      load_dev(DEVICE *dev);
-int      offline_dev(DEVICE *dev);
-int      flush_dev(DEVICE *dev);
-int      weof_dev(DEVICE *dev, int num);
-int      write_block(DEVICE *dev);
-int      write_dev(DEVICE *dev, char *buf, size_t len);
-int      read_dev(DEVICE *dev, char *buf, size_t len);
-int      status_dev(DEVICE *dev, uint32_t *status);
-int      eod_dev(DEVICE *dev);
-int      fsf_dev(DEVICE *dev, int num);
-int      fsr_dev(DEVICE *dev, int num);
-int      bsf_dev(DEVICE *dev, int num);
-int      bsr_dev(DEVICE *dev, int num);
-void     attach_jcr_to_device(DEVICE *dev, JCR *jcr);
-void     detach_jcr_from_device(DEVICE *dev, JCR *jcr);
-JCR     *next_attached_jcr(DEVICE *dev, JCR *jcr);
+DEVICE *init_dev(DEVICE *dev, DEVRES *device);
+int     open_dev(DEVICE *dev, char *VolName, int mode);
+void    close_dev(DEVICE *dev);
+void    force_close_dev(DEVICE *dev);
+int     truncate_dev(DEVICE *dev);
+void    term_dev(DEVICE *dev);
+char *  strerror_dev(DEVICE *dev);
+void    clrerror_dev(DEVICE *dev, int func);
+int     update_pos_dev(DEVICE *dev);
+int     rewind_dev(DEVICE *dev);
+int     load_dev(DEVICE *dev);
+int     offline_dev(DEVICE *dev);
+int     flush_dev(DEVICE *dev);
+int     weof_dev(DEVICE *dev, int num);
+int     write_block(DEVICE *dev);
+int     write_dev(DEVICE *dev, char *buf, size_t len);
+int     read_dev(DEVICE *dev, char *buf, size_t len);
+int     status_dev(DEVICE *dev, uint32_t *status);
+int     eod_dev(DEVICE *dev);
+int     fsf_dev(DEVICE *dev, int num);
+int     fsr_dev(DEVICE *dev, int num);
+int     bsf_dev(DEVICE *dev, int num);
+int     bsr_dev(DEVICE *dev, int num);
+void    attach_jcr_to_device(DEVICE *dev, JCR *jcr);
+void    detach_jcr_from_device(DEVICE *dev, JCR *jcr);
+JCR    *next_attached_jcr(DEVICE *dev, JCR *jcr);
 
 
 /* Get info about device */
-char *   dev_name(DEVICE *dev);
-char *   dev_vol_name(DEVICE *dev);
+char *  dev_name(DEVICE *dev);
+char *  dev_vol_name(DEVICE *dev);
 uint32_t dev_block(DEVICE *dev);
 uint32_t dev_file(DEVICE *dev);
-int      dev_is_tape(DEVICE *dev);
+int     dev_is_tape(DEVICE *dev);
 
 /* From device.c */
-int      open_device(DEVICE *dev);
-int      fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+int     open_device(DEVICE *dev);
+int     fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
 void _lock_device(char *file, int line, DEVICE *dev);
 void _unlock_device(char *file, int line, DEVICE *dev);
 void _block_device(char *file, int line, DEVICE *dev, int state);
@@ -119,40 +119,40 @@ void  new_steal_device_lock(DEVICE *dev, brwsteal_t *hold, int state);
 void  new_return_device_lock(DEVICE *dev, brwsteal_t *hold);
 
 /* From dircmd.c */
-void     connection_request(void *arg); 
+void    connection_request(void *arg); 
 
 
 /* From fd_cmds.c */
-void     run_job(JCR *jcr);
+void    run_job(JCR *jcr);
 
 /* From fdmsg.c */
-int      bget_msg(BSOCK *sock);
+int     bget_msg(BSOCK *sock);
 
 /* From job.c */
-void     stored_free_jcr(JCR *jcr);
-void     connection_from_filed(void *arg);     
-void     handle_filed_connection(BSOCK *fd, char *job_name);
+void    stored_free_jcr(JCR *jcr);
+void    connection_from_filed(void *arg);     
+void    handle_filed_connection(BSOCK *fd, char *job_name);
 
 /* From label.c */
-int      read_dev_volume_label(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-void     create_session_label(JCR *jcr, DEV_RECORD *rec, int label);
-void     create_volume_label(DEVICE *dev, char *VolName);
-int      write_volume_label_to_dev(JCR *jcr, DEVRES *device, char *VolName, char *PoolName);
-int      write_session_label(JCR *jcr, DEV_BLOCK *block, int label);
-int      write_volume_label_to_block(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-void     dump_volume_label(DEVICE *dev);
-void     dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose);
-int      unser_volume_label(DEVICE *dev, DEV_RECORD *rec);
-int      unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec);
+int     read_dev_volume_label(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+void    create_session_label(JCR *jcr, DEV_RECORD *rec, int label);
+void    create_volume_label(DEVICE *dev, char *VolName);
+int     write_volume_label_to_dev(JCR *jcr, DEVRES *device, char *VolName, char *PoolName);
+int     write_session_label(JCR *jcr, DEV_BLOCK *block, int label);
+int     write_volume_label_to_block(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+void    dump_volume_label(DEVICE *dev);
+void    dump_label_record(DEVICE *dev, DEV_RECORD *rec, int verbose);
+int     unser_volume_label(DEVICE *dev, DEV_RECORD *rec);
+int     unser_session_label(SESSION_LABEL *label, DEV_RECORD *rec);
 
 /* From match_bsr.c */
 int match_bsr(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec, 
-              SESSION_LABEL *sesrec);
+             SESSION_LABEL *sesrec);
 
 /* From mount.c */
-int      mount_next_write_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, int release);
-int      mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
-int      autoload_device(JCR *jcr, DEVICE *dev, int writing, BSOCK *dir);
+int     mount_next_write_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, int release);
+int     mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+int     autoload_device(JCR *jcr, DEVICE *dev, int writing, BSOCK *dir);
 
 
 /* From parse_bsr.c */
@@ -167,11 +167,11 @@ extern void create_vol_list(JCR *jcr);
 /* From record.c */
 char   *FI_to_ascii(int fi);
 char   *stream_to_ascii(int stream, int fi);
-int     write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
-int     can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
-int     read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec); 
+int    write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int    can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec);
+int    read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec); 
 DEV_RECORD *new_record();
-void    free_record(DEV_RECORD *rec);
+void   free_record(DEV_RECORD *rec);
 
 /* From read_record.c */
 int read_records(JCR *jcr,  DEVICE *dev, 

diff --git a/bacula/src/tools/dbcheck.c b/bacula/src/tools/dbcheck.c
index e598ce19ae2045c1e72eaf15d5c30046d2437eea..923bc5a0ccb11f781284a9bbb8835dc53e404f35 100644 (file)
--- a/bacula/src/tools/dbcheck.c
+++ b/bacula/src/tools/dbcheck.c
@@ -160,7 +160,7 @@ int main (int argc, char *argv[])
    }
 
    /* Open database */
-   db = db_init_database(NULL, db_name, user, password);
+   db = db_init_database(NULL, db_name, user, password, NULL, 0, NULL);
    if (!db_open_database(NULL, db)) {
       Emsg1(M_FATAL, 0, "%s", db_strerror(db));
    }