git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/dircmd.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2012 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version three of the GNU Affero General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *  This file handles accepting Director Commands
  30  *
  31  *    Most Director commands are handled here, with the
  32  *    exception of the Job command command and subsequent
  33  *    subcommands that are handled
  34  *    in job.c.
  35  *
  36  *    N.B. in this file, in general we must use P(dev->mutex) rather
  37  *      than dev->r_lock() so that we can examine the blocked
  38  *      state rather than blocking ourselves because a Job
  39  *      thread has the device blocked. In some "safe" cases,
  40  *      we can do things to a blocked device. CAREFUL!!!!
  41  *
  42  *    File daemon commands are handled in fdcmd.c
  43  *
  44  *     Kern Sibbald, May MMI
  45  *
  46  */
  47
  48 #include "bacula.h"
  49 #include "stored.h"
  50
  51 /* Exported variables */
  52
  53 /* Imported variables */
  54 extern BSOCK *filed_chan;
  55 extern struct s_last_job last_job;
  56 extern bool init_done;
  57
  58 /* Static variables */
  59 static char derrmsg[]     = "3900 Invalid command:";
  60 static char OKsetdebug[]  = "3000 OK setdebug=%d\n";
  61 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n";
  62 static char OK_bootstrap[]    = "3000 OK bootstrap\n";
  63 static char ERROR_bootstrap[] = "3904 Error bootstrap\n";
  64
  65 /* Imported functions */
  66 extern void terminate_child();
  67 extern bool job_cmd(JCR *jcr);
  68 extern bool use_cmd(JCR *jcr);
  69 extern bool run_cmd(JCR *jcr);
  70 extern bool status_cmd(JCR *sjcr);
  71 extern bool qstatus_cmd(JCR *jcr);
  72 //extern bool query_cmd(JCR *jcr);
  73
  74 /* Forward referenced functions */
  75 static bool label_cmd(JCR *jcr);
  76 static bool die_cmd(JCR *jcr);
  77 static bool relabel_cmd(JCR *jcr);
  78 static bool readlabel_cmd(JCR *jcr);
  79 static bool release_cmd(JCR *jcr);
  80 static bool setdebug_cmd(JCR *jcr);
  81 static bool cancel_cmd(JCR *cjcr);
  82 static bool mount_cmd(JCR *jcr);
  83 static bool unmount_cmd(JCR *jcr);
  84 //static bool action_on_purge_cmd(JCR *jcr);
  85 static bool bootstrap_cmd(JCR *jcr);
  86 static bool changer_cmd(JCR *sjcr);
  87 static bool do_label(JCR *jcr, int relabel);
  88 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
  89 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
  90 static void label_volume_if_ok(DCR *dcr, char *oldname,
  91                                char *newname, char *poolname,
  92                                int Slot, int relabel);
  93 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
  94 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
  95
  96 struct s_cmds {
  97    const char *cmd;
  98    bool (*func)(JCR *jcr);
  99    bool monitoraccess;                      /* set if monitors can access this cmd */
 100 };
 101
 102 /*
 103  * The following are the recognized commands from the Director.
 104  */
 105 static struct s_cmds cmds[] = {
 106    {"JobId=",      job_cmd,         0},     /* start Job */
 107    {"autochanger", changer_cmd,     0},
 108    {"bootstrap",   bootstrap_cmd,   0},
 109    {"cancel",      cancel_cmd,      0},
 110    {".die",        die_cmd,         0},
 111    {"label",       label_cmd,       0},     /* label a tape */
 112    {"mount",       mount_cmd,       0},
 113    {"readlabel",   readlabel_cmd,   0},
 114    {"release",     release_cmd,     0},
 115    {"relabel",     relabel_cmd,     0},     /* relabel a tape */
 116    {"setdebug=",   setdebug_cmd,    0},     /* set debug level */
 117    {"status",      status_cmd,      1},
 118    {".status",     qstatus_cmd,     1},
 119    {"unmount",     unmount_cmd,     0},
 120 //   {"action_on_purge",  action_on_purge_cmd,    0},
 121    {"use storage=", use_cmd,        0},
 122    {"run",         run_cmd,         0},
 123 // {"query",       query_cmd,       0},
 124    {NULL,        NULL}                      /* list terminator */
 125 };
 126
 127
 128 /*
 129  * Connection request. We accept connections either from the
 130  *  Director or a Client (File daemon).
 131  *
 132  * Note, we are running as a seperate thread of the Storage daemon.
 133  *  and it is because a Director has made a connection with
 134  *  us on the "Message" channel.
 135  *
 136  * Basic tasks done here:
 137  *  - Create a JCR record
 138  *  - If it was from the FD, call handle_filed_connection()
 139  *  - Authenticate the Director
 140  *  - We wait for a command
 141  *  - We execute the command
 142  *  - We continue or exit depending on the return status
 143  */
 144 void *handle_connection_request(void *arg)
 145 {
 146    BSOCK *bs = (BSOCK *)arg;
 147    JCR *jcr;
 148    int i;
 149    bool found, quit;
 150    int bnet_stat = 0;
 151    char name[500];
 152    char tbuf[100];
 153
 154    if (bs->recv() <= 0) {
 155       Emsg1(M_ERROR, 0, _("Connection request from %s failed.\n"), bs->who());
 156       bmicrosleep(5, 0);   /* make user wait 5 seconds */
 157       bs->close();
 158       return NULL;
 159    }
 160
 161    /*
 162     * Do a sanity check on the message received
 163     */
 164    if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
 165       Dmsg1(000, "<filed: %s", bs->msg);
 166       Emsg2(M_ERROR, 0, _("Invalid connection from %s. Len=%d\n"), bs->who(), bs->msglen);
 167       bmicrosleep(5, 0);   /* make user wait 5 seconds */
 168       bs->close();
 169       return NULL;
 170    }
 171    /*
 172     * See if this is a File daemon connection. If so
 173     *   call FD handler.
 174     */
 175    Dmsg1(110, "Conn: %s", bs->msg);
 176    if (debug_level == 3) {
 177       Dmsg1(000, "<filed: %s", bs->msg);
 178    }
 179    if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
 180       Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 181             (utime_t)time(NULL)));
 182       Dmsg1(50, "%s", bs->msg);
 183       handle_filed_connection(bs, name);
 184       return NULL;
 185    }
 186
 187    /*
 188     * This is a connection from the Director, so setup a JCR
 189     */
 190    Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 191          (utime_t)time(NULL)));
 192    jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
 193    jcr->dir_bsock = bs;               /* save Director bsock */
 194    jcr->dir_bsock->set_jcr(jcr);
 195    jcr->dcrs = New(alist(10, not_owned_by_alist));
 196    /* Initialize FD start condition variable */
 197    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 198    if (errstat != 0) {
 199       berrno be;
 200       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 201       goto bail_out;
 202    }
 203
 204    Dmsg0(1000, "stored in start_job\n");
 205
 206    /*
 207     * Authenticate the Director
 208     */
 209    if (!authenticate_director(jcr)) {
 210       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
 211       goto bail_out;
 212    }
 213    Dmsg0(90, "Message channel init completed.\n");
 214
 215    for (quit=false; !quit;) {
 216       /* Read command */
 217       if ((bnet_stat = bs->recv()) <= 0) {
 218          break;               /* connection terminated */
 219       }
 220       Dmsg1(199, "<dird: %s\n", bs->msg);
 221       /* Ensure that device initialization is complete */
 222       while (!init_done) {
 223          bmicrosleep(1, 0);
 224       }
 225       found = false;
 226       for (i=0; cmds[i].cmd; i++) {
 227         if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 228            if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
 229               Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
 230               bs->fsend(invalid_cmd);
 231               bs->signal(BNET_EOD);
 232               break;
 233            }
 234            Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
 235            if (!cmds[i].func(jcr)) { /* do command */
 236               quit = true; /* error, get out */
 237               Dmsg1(190, "Command %s requests quit\n", cmds[i].cmd);
 238            }
 239            found = true;             /* indicate command found */
 240            break;
 241         }
 242       }
 243       if (!found) {                   /* command not found */
 244         POOL_MEM err_msg;
 245         Mmsg(err_msg, "%s %s\n", derrmsg, bs->msg);
 246         bs->fsend(err_msg.c_str());
 247         break;
 248       }
 249    }
 250 bail_out:
 251    generate_daemon_event(jcr, "JobEnd");
 252    generate_plugin_event(jcr, bsdEventJobEnd);
 253    dequeue_messages(jcr);             /* send any queued messages */
 254    bs->signal(BNET_TERMINATE);
 255    free_plugins(jcr);                 /* release instantiated plugins */
 256    free_jcr(jcr);
 257    return NULL;
 258 }
 259
 260
 261 /*
 262  * Force SD to die, and hopefully dump itself.  Turned on only
 263  *  in development version.
 264  */
 265 static bool die_cmd(JCR *jcr)
 266 {
 267 #ifdef DEVELOPER
 268    JCR *djcr = NULL;
 269    int a;
 270    BSOCK *dir = jcr->dir_bsock;
 271    pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
 272
 273    if (strstr(dir->msg, "deadlock")) {
 274       Pmsg0(000, "I have been requested to deadlock ...\n");
 275       P(m);
 276       P(m);
 277    }
 278
 279    Pmsg1(000, "I have been requested to die ... (%s)\n", dir->msg);
 280    a = djcr->JobId;   /* ref NULL pointer */
 281    djcr->JobId = a;
 282 #endif
 283    return 0;
 284 }
 285
 286
 287
 288 /*
 289  * Set debug level as requested by the Director
 290  *
 291  */
 292 static bool setdebug_cmd(JCR *jcr)
 293 {
 294    BSOCK *dir = jcr->dir_bsock;
 295    int32_t level, trace_flag;
 296
 297    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 298    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
 299       dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
 300       return 0;
 301    }
 302    debug_level = level;
 303    set_trace(trace_flag);
 304    return dir->fsend(OKsetdebug, level);
 305 }
 306
 307
 308 /*
 309  * Cancel a Job
 310  *   Be careful, we switch to using the job's JCR! So, using
 311  *   BSOCKs on that jcr can have two threads in the same code.
 312  */
 313 static bool cancel_cmd(JCR *cjcr)
 314 {
 315    BSOCK *dir = cjcr->dir_bsock;
 316    int oldStatus;
 317    char Job[MAX_NAME_LENGTH];
 318    JCR *jcr;
 319    int status;
 320    const char *reason;
 321
 322    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 323       status = JS_Canceled;
 324       reason = "canceled";
 325    } else {
 326       dir->fsend(_("3903 Error scanning cancel command.\n"));
 327       goto bail_out;
 328    }
 329    if (!(jcr=get_jcr_by_full_name(Job))) {
 330       dir->fsend(_("3904 Job %s not found.\n"), Job);
 331    } else {
 332       oldStatus = jcr->JobStatus;
 333       jcr->setJobStatus(status);
 334       Dmsg2(800, "Cancel JobId=%d %p\n", jcr->JobId, jcr);
 335       if (!jcr->authenticated && oldStatus == JS_WaitFD) {
 336          pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 337       }
 338       if (jcr->file_bsock) {
 339          jcr->file_bsock->set_terminated();
 340          jcr->file_bsock->set_timed_out();
 341          Dmsg2(800, "Term bsock jid=%d %p\n", jcr->JobId, jcr);
 342       } else {
 343          /* Still waiting for FD to connect, release it */
 344          pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
 345          Dmsg2(800, "Signal FD connect jid=%d %p\n", jcr->JobId, jcr);
 346       }
 347       /* If thread waiting on mount, wake him */
 348       if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
 349          pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 350          Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 351          pthread_cond_broadcast(&wait_device_release);
 352       }
 353       if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
 354          pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 355          Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 356          pthread_cond_broadcast(&wait_device_release);
 357       }
 358       dir->fsend(_("3000 JobId=%ld Job=\"%s\" marked to be %s.\n"),
 359          jcr->JobId, jcr->Job, reason);
 360       free_jcr(jcr);
 361    }
 362
 363 bail_out:
 364    dir->signal(BNET_EOD);
 365    return 1;
 366 }
 367
 368 /*
 369  * Label a Volume
 370  *
 371  */
 372 static bool label_cmd(JCR *jcr)
 373 {
 374    return do_label(jcr, 0);
 375 }
 376
 377 static bool relabel_cmd(JCR *jcr)
 378 {
 379    return do_label(jcr, 1);
 380 }
 381
 382 static bool do_label(JCR *jcr, int relabel)
 383 {
 384    POOLMEM *newname, *oldname, *poolname, *mtype;
 385    POOL_MEM dev_name;
 386    BSOCK *dir = jcr->dir_bsock;
 387    DCR *dcr;
 388    DEVICE *dev;
 389    bool ok = false;
 390    int32_t slot, drive;
 391
 392    newname = get_memory(dir->msglen+1);
 393    oldname = get_memory(dir->msglen+1);
 394    poolname = get_memory(dir->msglen+1);
 395    mtype = get_memory(dir->msglen+1);
 396    if (relabel) {
 397       if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
 398                  "MediaType=%127s Slot=%d drive=%d",
 399                   dev_name.c_str(), oldname, newname, poolname, mtype,
 400                   &slot, &drive) == 7) {
 401          ok = true;
 402       }
 403    } else {
 404       *oldname = 0;
 405       if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
 406                  "MediaType=%127s Slot=%d drive=%d",
 407           dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
 408          ok = true;
 409       }
 410    }
 411    if (ok) {
 412       unbash_spaces(newname);
 413       unbash_spaces(oldname);
 414       unbash_spaces(poolname);
 415       unbash_spaces(mtype);
 416       dcr = find_device(jcr, dev_name, drive);
 417       if (dcr) {
 418          dev = dcr->dev;
 419          dev->dlock();                 /* Use P to avoid indefinite block */
 420          if (!dev->is_open() && !dev->is_busy()) {
 421             Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
 422             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 423             dev->close();
 424          /* Under certain "safe" conditions, we can steal the lock */
 425          } else if (dev->can_steal_lock()) {
 426             Dmsg0(400, "Can relabel. can_steal_lock\n");
 427             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 428          } else if (dev->is_busy() || dev->is_blocked()) {
 429             send_dir_busy_message(dir, dev);
 430          } else {                     /* device not being used */
 431             Dmsg0(400, "Can relabel. device not used\n");
 432             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 433          }
 434          dev->dunlock();
 435          free_dcr(dcr);
 436       } else {
 437          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 438       }
 439    } else {
 440       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 441       pm_strcpy(jcr->errmsg, dir->msg);
 442       dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
 443    }
 444    free_memory(oldname);
 445    free_memory(newname);
 446    free_memory(poolname);
 447    free_memory(mtype);
 448    dir->signal(BNET_EOD);
 449    return true;
 450 }
 451
 452 /*
 453  * Read the tape label and determine if we can safely
 454  * label the tape (not a Bacula volume), then label it.
 455  *
 456  *  Enter with the mutex set
 457  */
 458 static void label_volume_if_ok(DCR *dcr, char *oldname,
 459                                char *newname, char *poolname,
 460                                int slot, int relabel)
 461 {
 462    BSOCK *dir = dcr->jcr->dir_bsock;
 463    bsteal_lock_t hold;
 464    DEVICE *dev = dcr->dev;
 465    int label_status;
 466    int mode;
 467    const char *volname = (relabel == 1) ? oldname : newname;
 468    char ed1[50];
 469
 470    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 471    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
 472
 473
 474    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 475    if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
 476       goto bail_out;                  /* error */
 477    }
 478
 479    /* Ensure that the device is open -- autoload_device() closes it */
 480    if (dev->is_tape()) {
 481       mode = OPEN_READ_WRITE;
 482    } else {
 483       mode = CREATE_READ_WRITE;
 484    }
 485
 486    if (relabel) {
 487       dev->truncating = true;         /* let open() know we will truncate it */
 488    }
 489    /* Set old volume name for open if relabeling */
 490    dcr->setVolCatName(volname);
 491    if (!dev->open(dcr, mode)) {
 492       dir->fsend(_("3910 Unable to open device \"%s\": ERR=%s\n"),
 493          dev->print_name(), dev->bstrerror());
 494       goto bail_out;
 495    }
 496
 497    /* See what we have for a Volume */
 498    label_status = read_dev_volume_label(dcr);
 499
 500    /* Set new volume name */
 501    dcr->setVolCatName(newname);
 502    switch(label_status) {
 503    case VOL_NAME_ERROR:
 504    case VOL_VERSION_ERROR:
 505    case VOL_LABEL_ERROR:
 506    case VOL_OK:
 507       if (!relabel) {
 508          dir->fsend(_(
 509             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
 510              dev->VolHdr.VolumeName);
 511          break;
 512       }
 513
 514       /* Relabel request. If oldname matches, continue */
 515       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
 516          dir->fsend(_("3921 Wrong volume mounted.\n"));
 517          break;
 518       }
 519       if (dev->label_type != B_BACULA_LABEL) {
 520          dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
 521          break;
 522       }
 523       /* Fall through wanted! */
 524    case VOL_IO_ERROR:
 525    case VOL_NO_LABEL:
 526       if (!write_new_volume_label_to_dev(dcr, newname, poolname,
 527               relabel, true /* write dvd now */)) {
 528          dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 529          break;
 530       }
 531       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 532       /* The following 3000 OK label. string is scanned in ua_label.c */
 533       dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
 534                  edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
 535                  dev->is_dvd()?1:0, newname, dev->print_name());
 536       break;
 537    case VOL_NO_MEDIA:
 538       dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
 539       break;
 540    default:
 541       dir->fsend(_("3913 Cannot label Volume. "
 542 "Unknown status %d from read_volume_label()\n"), label_status);
 543       break;
 544    }
 545
 546 bail_out:
 547    if (dev->is_open() && !dev->has_cap(CAP_ALWAYSOPEN)) {
 548       dev->close();
 549    }
 550    if (!dev->is_open()) {
 551       dev->clear_volhdr();
 552    }
 553    volume_unused(dcr);                   /* no longer using volume */
 554    give_back_device_lock(dev, &hold);
 555    return;
 556 }
 557
 558
 559 /*
 560  * Read the tape label
 561  *
 562  *  Enter with the mutex set
 563  */
 564 static bool read_label(DCR *dcr)
 565 {
 566    int ok;
 567    JCR *jcr = dcr->jcr;
 568    BSOCK *dir = jcr->dir_bsock;
 569    bsteal_lock_t hold;
 570    DEVICE *dev = dcr->dev;
 571
 572    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 573
 574    dcr->VolumeName[0] = 0;
 575    dev->clear_labeled();              /* force read of label */
 576    switch (read_dev_volume_label(dcr)) {
 577    case VOL_OK:
 578       dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
 579       ok = true;
 580       break;
 581    default:
 582       dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"),
 583          dev->print_name(), jcr->errmsg);
 584       ok = false;
 585       break;
 586    }
 587    volume_unused(dcr);
 588    give_back_device_lock(dev, &hold);
 589    return ok;
 590 }
 591
 592 /*
 593  * Searches for device by name, and if found, creates a dcr and
 594  *  returns it.
 595  */
 596 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
 597 {
 598    DEVRES *device;
 599    AUTOCHANGER *changer;
 600    bool found = false;
 601    DCR *dcr = NULL;
 602
 603    unbash_spaces(devname);
 604    foreach_res(device, R_DEVICE) {
 605       /* Find resource, and make sure we were able to open it */
 606       if (strcmp(device->hdr.name, devname.c_str()) == 0) {
 607          if (!device->dev) {
 608             device->dev = init_dev(jcr, device);
 609          }
 610          if (!device->dev) {
 611             Jmsg(jcr, M_WARNING, 0, _("\n"
 612                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 613                  devname.c_str());
 614             continue;
 615          }
 616          Dmsg1(20, "Found device %s\n", device->hdr.name);
 617          found = true;
 618          break;
 619       }
 620    }
 621    if (!found) {
 622       foreach_res(changer, R_AUTOCHANGER) {
 623          /* Find resource, and make sure we were able to open it */
 624          if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
 625             /* Try each device in this AutoChanger */
 626             foreach_alist(device, changer->device) {
 627                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
 628                if (!device->dev) {
 629                   device->dev = init_dev(jcr, device);
 630                }
 631                if (!device->dev) {
 632                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
 633                   Jmsg(jcr, M_WARNING, 0, _("\n"
 634                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 635                        device->hdr.name, devname.c_str());
 636                   continue;
 637                }
 638                if (!device->dev->autoselect) {
 639                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
 640                   continue;              /* device is not available */
 641                }
 642                if (drive < 0 || drive == (int)device->dev->drive_index) {
 643                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
 644                   found = true;
 645                   break;
 646                }
 647                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
 648                   devname.c_str(), drive, (int)device->dev->drive_index);
 649             }
 650             break;                    /* we found it but could not open a device */
 651          }
 652       }
 653    }
 654
 655    if (found) {
 656       Dmsg1(100, "Found device %s\n", device->hdr.name);
 657       dcr = new_dcr(jcr, NULL, device->dev);
 658       dcr->device = device;
 659    }
 660    return dcr;
 661 }
 662
 663
 664 /*
 665  * Mount command from Director
 666  */
 667 static bool mount_cmd(JCR *jcr)
 668 {
 669    POOL_MEM devname;
 670    BSOCK *dir = jcr->dir_bsock;
 671    DEVICE *dev;
 672    DCR *dcr;
 673    int32_t drive;
 674    int32_t slot = 0;
 675    bool ok;
 676
 677    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
 678                &drive, &slot) == 3;
 679    if (!ok) {
 680       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
 681    }
 682    Dmsg3(100, "ok=%d drive=%d slot=%d\n", ok, drive, slot);
 683    if (ok) {
 684       dcr = find_device(jcr, devname, drive);
 685       if (dcr) {
 686          dev = dcr->dev;
 687          dev->dlock();                 /* Use P to avoid indefinite block */
 688          Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
 689             dev->must_unload());
 690          switch (dev->blocked()) {         /* device blocked? */
 691          case BST_WAITING_FOR_SYSOP:
 692             /* Someone is waiting, wake him */
 693             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
 694             dev->set_blocked(BST_MOUNT);
 695             dir->fsend("3001 OK mount requested. %sDevice=%s\n",
 696                        slot>0?_("Specified slot ignored. "):"",
 697                        dev->print_name());
 698             pthread_cond_broadcast(&dev->wait_next_vol);
 699             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
 700             pthread_cond_broadcast(&wait_device_release);
 701             break;
 702
 703          /* In both of these two cases, we (the user) unmounted the Volume */
 704          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 705          case BST_UNMOUNTED:
 706             Dmsg2(100, "Unmounted changer=%d slot=%d\n", dev->is_autochanger(), slot);
 707             if (dev->is_autochanger() && slot > 0) {
 708                try_autoload_device(jcr, dcr, slot, "");
 709             }
 710             /* We freed the device, so reopen it and wake any waiting threads */
 711             if (!dev->open(dcr, OPEN_READ_ONLY)) {
 712                dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"),
 713                   dev->print_name(), dev->bstrerror());
 714                if (dev->blocked() == BST_UNMOUNTED) {
 715                   /* We blocked the device, so unblock it */
 716                   Dmsg0(100, "Unmounted. Unblocking device\n");
 717                   unblock_device(dev);
 718                }
 719                break;
 720             }
 721             read_dev_volume_label(dcr);
 722             if (dev->blocked() == BST_UNMOUNTED) {
 723                /* We blocked the device, so unblock it */
 724                Dmsg0(100, "Unmounted. Unblocking device\n");
 725                read_label(dcr);       /* this should not be necessary */
 726                unblock_device(dev);
 727             } else {
 728                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
 729                dev->set_blocked(BST_MOUNT);
 730             }
 731             if (dev->is_labeled()) {
 732                dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"),
 733                   dev->print_name(), dev->VolHdr.VolumeName);
 734             } else {
 735                dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
 736                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 737                           dev->print_name());
 738             }
 739             pthread_cond_broadcast(&dev->wait_next_vol);
 740             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
 741             pthread_cond_broadcast(&wait_device_release);
 742             break;
 743
 744          case BST_DOING_ACQUIRE:
 745             dir->fsend(_("3001 Device \"%s\" is doing acquire.\n"),
 746                        dev->print_name());
 747             break;
 748
 749          case BST_WRITING_LABEL:
 750             dir->fsend(_("3903 Device \"%s\" is being labeled.\n"),
 751                dev->print_name());
 752             break;
 753
 754          case BST_NOT_BLOCKED:
 755             Dmsg2(100, "Not blocked changer=%d slot=%d\n", dev->is_autochanger(), slot);
 756             if (dev->is_autochanger() && slot > 0) {
 757                try_autoload_device(jcr, dcr, slot, "");
 758             }
 759             if (dev->is_open()) {
 760                if (dev->is_labeled()) {
 761                   dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"),
 762                      dev->print_name(), dev->VolHdr.VolumeName);
 763                } else {
 764                   dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
 765                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 766                              dev->print_name());
 767                }
 768             } else if (dev->is_tape()) {
 769                if (!dev->open(dcr, OPEN_READ_ONLY)) {
 770                   dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"),
 771                      dev->print_name(), dev->bstrerror());
 772                   break;
 773                }
 774                read_label(dcr);
 775                if (dev->is_labeled()) {
 776                   dir->fsend(_("3001 Device \"%s\" is already mounted with Volume \"%s\"\n"),
 777                      dev->print_name(), dev->VolHdr.VolumeName);
 778                } else {
 779                   dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
 780                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 781                              dev->print_name());
 782                }
 783                if (dev->is_open() && !dev->has_cap(CAP_ALWAYSOPEN)) {
 784                   dev->close();
 785                }
 786             } else if (dev->is_unmountable()) {
 787                if (dev->mount(1)) {
 788                   dir->fsend(_("3002 Device \"%s\" is mounted.\n"), dev->print_name());
 789                } else {
 790                   dir->fsend(_("3907 %s"), dev->bstrerror());
 791                }
 792             } else { /* must be file */
 793                dir->fsend(_("3906 File device \"%s\" is always mounted.\n"),
 794                   dev->print_name());
 795                pthread_cond_broadcast(&dev->wait_next_vol);
 796                Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
 797                pthread_cond_broadcast(&wait_device_release);
 798             }
 799             break;
 800
 801          case BST_RELEASING:
 802             dir->fsend(_("3930 Device \"%s\" is being released.\n"), dev->print_name());
 803             break;
 804
 805          default:
 806             dir->fsend(_("3905 Unknown wait state %d\n"), dev->blocked());
 807             break;
 808          }
 809          dev->dunlock();
 810          free_dcr(dcr);
 811       } else {
 812          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 813       }
 814    } else {
 815       pm_strcpy(jcr->errmsg, dir->msg);
 816       dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
 817    }
 818    dir->signal(BNET_EOD);
 819    return true;
 820 }
 821
 822 /*
 823  * unmount command from Director
 824  */
 825 static bool unmount_cmd(JCR *jcr)
 826 {
 827    POOL_MEM devname;
 828    BSOCK *dir = jcr->dir_bsock;
 829    DEVICE *dev;
 830    DCR *dcr;
 831    int32_t drive;
 832
 833    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
 834       dcr = find_device(jcr, devname, drive);
 835       if (dcr) {
 836          dev = dcr->dev;
 837          dev->dlock();                 /* Use P to avoid indefinite block */
 838          if (!dev->is_open()) {
 839             if (!dev->is_busy()) {
 840                unload_autochanger(dcr, -1);
 841             }
 842             if (dev->is_unmountable()) {
 843                if (dev->unmount(0)) {
 844                   dir->fsend(_("3002 Device \"%s\" unmounted.\n"),
 845                      dev->print_name());
 846                } else {
 847                   dir->fsend(_("3907 %s"), dev->bstrerror());
 848                }
 849             } else {
 850                Dmsg0(90, "Device already unmounted\n");
 851                dir->fsend(_("3901 Device \"%s\" is already unmounted.\n"),
 852                   dev->print_name());
 853             }
 854          } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
 855             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 856                dev->blocked());
 857             if (!unload_autochanger(dcr, -1)) {
 858                /* ***FIXME**** what is this ????  */
 859                dev->close();
 860                free_volume(dev);
 861             }
 862             if (dev->is_unmountable() && !dev->unmount(0)) {
 863                dir->fsend(_("3907 %s"), dev->bstrerror());
 864             } else {
 865                dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
 866                dir->fsend(_("3001 Device \"%s\" unmounted.\n"),
 867                   dev->print_name());
 868             }
 869
 870          } else if (dev->blocked() == BST_DOING_ACQUIRE) {
 871             dir->fsend(_("3902 Device \"%s\" is busy in acquire.\n"),
 872                dev->print_name());
 873
 874          } else if (dev->blocked() == BST_WRITING_LABEL) {
 875             dir->fsend(_("3903 Device \"%s\" is being labeled.\n"),
 876                dev->print_name());
 877
 878          } else if (dev->is_busy()) {
 879             send_dir_busy_message(dir, dev);
 880          } else {                     /* device not being used */
 881             Dmsg0(90, "Device not in use, unmounting\n");
 882             /* On FreeBSD, I am having ASSERT() failures in block_device()
 883              * and I can only imagine that the thread id that we are
 884              * leaving in no_wait_id is being re-used. So here,
 885              * we simply do it by hand.  Gross, but a solution.
 886              */
 887             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
 888             dev->set_blocked(BST_UNMOUNTED);
 889             clear_thread_id(dev->no_wait_id);
 890             if (!unload_autochanger(dcr, -1)) {
 891                dev->close();
 892                free_volume(dev);
 893             }
 894             if (dev->is_unmountable() && !dev->unmount(0)) {
 895                dir->fsend(_("3907 %s"), dev->bstrerror());
 896             } else {
 897                dir->fsend(_("3002 Device \"%s\" unmounted.\n"),
 898                   dev->print_name());
 899             }
 900          }
 901          dev->dunlock();
 902          free_dcr(dcr);
 903       } else {
 904          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 905       }
 906    } else {
 907       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 908       pm_strcpy(jcr->errmsg, dir->msg);
 909       dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
 910    }
 911    dir->signal(BNET_EOD);
 912    return true;
 913 }
 914
 915 #if 0
 916 /*
 917  * The truncate command will recycle a volume. The director can call this
 918  * after purging a volume so that disk space will not be wasted. Only useful
 919  * for File Storage, of course.
 920  *
 921  *
 922  * It is currently disabled
 923  */
 924 static bool action_on_purge_cmd(JCR *jcr)
 925 {
 926    BSOCK *dir = jcr->dir_bsock;
 927
 928    char devname[MAX_NAME_LENGTH];
 929    char volumename[MAX_NAME_LENGTH];
 930    int32_t action;
 931
 932    /* TODO: Need to find a free device and ask for slot to the director */
 933    if (sscanf(dir->msg,
 934               "action_on_purge %127s vol=%127s action=%d",
 935               devname, volumename, &action)!= 5)
 936    {
 937       dir->fsend(_("3916 Error scanning action_on_purge command\n"));
 938       goto done;
 939    }
 940    unbash_spaces(volumename);
 941    unbash_spaces(devname);
 942
 943    /* Check if action is correct */
 944    if (action & AOP_TRUNCTATE) {
 945
 946    }
 947    /* ... */
 948
 949 done:
 950    dir->signal(BNET_EOD);
 951    return true;
 952 }
 953 #endif
 954
 955 /*
 956  * Release command from Director. This rewinds the device and if
 957  *   configured does a offline and ensures that Bacula will
 958  *   re-read the label of the tape before continuing. This gives
 959  *   the operator the chance to change the tape anytime before the
 960  *   next job starts.
 961  */
 962 static bool release_cmd(JCR *jcr)
 963 {
 964    POOL_MEM devname;
 965    BSOCK *dir = jcr->dir_bsock;
 966    DEVICE *dev;
 967    DCR *dcr;
 968    int32_t drive;
 969
 970    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
 971       dcr = find_device(jcr, devname, drive);
 972       if (dcr) {
 973          dev = dcr->dev;
 974          dev->dlock();                 /* Use P to avoid indefinite block */
 975          if (!dev->is_open()) {
 976             if (!dev->is_busy()) {
 977                unload_autochanger(dcr, -1);
 978             }
 979             Dmsg0(90, "Device already released\n");
 980             dir->fsend(_("3921 Device \"%s\" already released.\n"),
 981                dev->print_name());
 982
 983          } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
 984             Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
 985                dev->blocked());
 986             unload_autochanger(dcr, -1);
 987             dir->fsend(_("3922 Device \"%s\" waiting for sysop.\n"),
 988                dev->print_name());
 989
 990          } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
 991             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 992                dev->blocked());
 993             dir->fsend(_("3922 Device \"%s\" waiting for mount.\n"),
 994                dev->print_name());
 995
 996          } else if (dev->blocked() == BST_DOING_ACQUIRE) {
 997             dir->fsend(_("3923 Device \"%s\" is busy in acquire.\n"),
 998                dev->print_name());
 999
1000          } else if (dev->blocked() == BST_WRITING_LABEL) {
1001             dir->fsend(_("3914 Device \"%s\" is being labeled.\n"),
1002                dev->print_name());
1003
1004          } else if (dev->is_busy()) {
1005             send_dir_busy_message(dir, dev);
1006          } else {                     /* device not being used */
1007             Dmsg0(90, "Device not in use, releasing\n");
1008             dcr->release_volume();
1009             dir->fsend(_("3022 Device \"%s\" released.\n"),
1010                dev->print_name());
1011          }
1012          dev->dunlock();
1013          free_dcr(dcr);
1014       } else {
1015          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1016       }
1017    } else {
1018       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
1019       pm_strcpy(jcr->errmsg, dir->msg);
1020       dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
1021    }
1022    dir->signal(BNET_EOD);
1023    return true;
1024 }
1025
1026 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
1027 static uint32_t bsr_uniq = 0;
1028
1029 static bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
1030 {
1031    POOLMEM *fname = get_pool_memory(PM_FNAME);
1032    FILE *bs;
1033    bool ok = false;
1034
1035    if (jcr->RestoreBootstrap) {
1036       unlink(jcr->RestoreBootstrap);
1037       free_pool_memory(jcr->RestoreBootstrap);
1038    }
1039    P(bsr_mutex);
1040    bsr_uniq++;
1041    Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
1042       jcr->Job, bsr_uniq);
1043    V(bsr_mutex);
1044    Dmsg1(400, "bootstrap=%s\n", fname);
1045    jcr->RestoreBootstrap = fname;
1046    bs = fopen(fname, "a+b");           /* create file */
1047    if (!bs) {
1048       berrno be;
1049       Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
1050          jcr->RestoreBootstrap, be.bstrerror());
1051       goto bail_out;
1052    }
1053    Dmsg0(10, "=== Bootstrap file ===\n");
1054    while (sock->recv() >= 0) {
1055        Dmsg1(10, "%s", sock->msg);
1056        fputs(sock->msg, bs);
1057    }
1058    fclose(bs);
1059    Dmsg0(10, "=== end bootstrap file ===\n");
1060    jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
1061    if (!jcr->bsr) {
1062       Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
1063       goto bail_out;
1064    }
1065    if (debug_level >= 10) {
1066       dump_bsr(jcr->bsr, true);
1067    }
1068    /* If we got a bootstrap, we are reading, so create read volume list */
1069    create_restore_volume_list(jcr);
1070    ok = true;
1071
1072 bail_out:
1073    unlink(jcr->RestoreBootstrap);
1074    free_pool_memory(jcr->RestoreBootstrap);
1075    jcr->RestoreBootstrap = NULL;
1076    if (!ok) {
1077       sock->fsend(ERROR_bootstrap);
1078       return false;
1079    }
1080    return sock->fsend(OK_bootstrap);
1081 }
1082
1083 static bool bootstrap_cmd(JCR *jcr)
1084 {
1085    return get_bootstrap_file(jcr, jcr->dir_bsock);
1086 }
1087
1088 /*
1089  * Autochanger command from Director
1090  */
1091 static bool changer_cmd(JCR *jcr)
1092 {
1093    POOL_MEM devname;
1094    BSOCK *dir = jcr->dir_bsock;
1095    DEVICE *dev;
1096    DCR *dcr;
1097    const char *cmd = NULL;
1098    bool ok = false;
1099    /*
1100     * A safe_cmd may call autochanger script but does not load/unload
1101     *    slots so it can be done at the same time that the drive is open.
1102     */
1103    bool safe_cmd = false;
1104
1105    if (sscanf(dir->msg, "autochanger listall %127s", devname.c_str()) == 1) {
1106       cmd = "listall";
1107       safe_cmd = ok = true;
1108    } else if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
1109       cmd = "list";
1110       safe_cmd = ok = true;
1111    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
1112       cmd = "slots";
1113       safe_cmd = ok = true;
1114    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
1115       cmd = "drives";
1116       safe_cmd = ok = true;
1117    }
1118    if (ok) {
1119       dcr = find_device(jcr, devname, -1);
1120       if (dcr) {
1121          dev = dcr->dev;
1122          dev->dlock();                 /* Use P to avoid indefinite block */
1123          if (!dev->device->changer_res) {
1124             dir->fsend(_("3998 Device \"%s\" is not an autochanger.\n"),
1125                dev->print_name());
1126          /* Under certain "safe" conditions, we can steal the lock */
1127          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
1128             autochanger_cmd(dcr, dir, cmd);
1129          } else if (dev->is_busy() || dev->is_blocked()) {
1130             send_dir_busy_message(dir, dev);
1131          } else {                     /* device not being used */
1132             autochanger_cmd(dcr, dir, cmd);
1133          }
1134          dev->dunlock();
1135          free_dcr(dcr);
1136       } else {
1137          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1138       }
1139    } else {  /* error on scanf */
1140       pm_strcpy(jcr->errmsg, dir->msg);
1141       dir->fsend(_("3908 Error scanning autochanger drives/list/slots command: %s\n"),
1142          jcr->errmsg);
1143    }
1144    dir->signal(BNET_EOD);
1145    return true;
1146 }
1147
1148 /*
1149  * Read and return the Volume label
1150  */
1151 static bool readlabel_cmd(JCR *jcr)
1152 {
1153    POOL_MEM devname;
1154    BSOCK *dir = jcr->dir_bsock;
1155    DEVICE *dev;
1156    DCR *dcr;
1157    int32_t Slot, drive;
1158
1159    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1160        &Slot, &drive) == 3) {
1161       dcr = find_device(jcr, devname, drive);
1162       if (dcr) {
1163          dev = dcr->dev;
1164          dev->dlock();                 /* Use P to avoid indefinite block */
1165          if (!dev->is_open()) {
1166             read_volume_label(jcr, dcr, dev, Slot);
1167             dev->close();
1168          /* Under certain "safe" conditions, we can steal the lock */
1169          } else if (dev->can_steal_lock()) {
1170             read_volume_label(jcr, dcr, dev, Slot);
1171          } else if (dev->is_busy() || dev->is_blocked()) {
1172             send_dir_busy_message(dir, dev);
1173          } else {                     /* device not being used */
1174             read_volume_label(jcr, dcr, dev, Slot);
1175          }
1176          dev->dunlock();
1177          free_dcr(dcr);
1178       } else {
1179          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1180       }
1181    } else {
1182       pm_strcpy(jcr->errmsg, dir->msg);
1183       dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1184    }
1185    dir->signal(BNET_EOD);
1186    return true;
1187 }
1188
1189
1190 /*
1191  * Read the tape label
1192  *
1193  *  Enter with the mutex set
1194  */
1195 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1196 {
1197    BSOCK *dir = jcr->dir_bsock;
1198    bsteal_lock_t hold;
1199
1200    dcr->set_dev(dev);
1201    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1202
1203    if (!try_autoload_device(jcr, dcr, Slot, "")) {
1204       goto bail_out;                  /* error */
1205    }
1206
1207    dev->clear_labeled();              /* force read of label */
1208    switch (read_dev_volume_label(dcr)) {
1209    case VOL_OK:
1210       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1211       dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1212       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1213       break;
1214    default:
1215       dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"),
1216                  dev->print_name(), jcr->errmsg);
1217       break;
1218    }
1219
1220 bail_out:
1221    give_back_device_lock(dev, &hold);
1222    return;
1223 }
1224
1225 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1226 {
1227    BSOCK *dir = jcr->dir_bsock;
1228
1229    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1230    dcr->VolCatInfo.Slot = slot;
1231    dcr->VolCatInfo.InChanger = slot > 0;
1232    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1233       return false;
1234    }
1235    return true;
1236 }
1237
1238 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1239 {
1240    if (dev->is_blocked()) {
1241       switch (dev->blocked()) {
1242       case BST_UNMOUNTED:
1243          dir->fsend(_("3931 Device \"%s\" is BLOCKED. user unmounted.\n"),
1244             dev->print_name());
1245          break;
1246       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1247          dir->fsend(_("3932 Device \"%s\" is BLOCKED. user unmounted during wait for media/mount.\n"),
1248              dev->print_name());
1249          break;
1250       case BST_WAITING_FOR_SYSOP:
1251          dir->fsend(_("3933 Device \"%s\" is BLOCKED waiting for media.\n"),
1252             dev->print_name());
1253          break;
1254       case BST_DOING_ACQUIRE:
1255          dir->fsend(_("3934 Device \"%s\" is being initialized.\n"),
1256             dev->print_name());
1257          break;
1258       case BST_WRITING_LABEL:
1259          dir->fsend(_("3935 Device \"%s\" is blocked labeling a Volume.\n"),
1260             dev->print_name());
1261          break;
1262       default:
1263          dir->fsend(_("3935 Device \"%s\" is blocked for unknown reason.\n"),
1264             dev->print_name());
1265          break;
1266       }
1267    } else if (dev->can_read()) {
1268        dir->fsend(_("3936 Device \"%s\" is busy reading.\n"),
1269                    dev->print_name());;
1270    } else {
1271        dir->fsend(_("3937 Device \"%s\" is busy with writers=%d reserved=%d.\n"),
1272           dev->print_name(), dev->num_writers, dev->num_reserved());
1273    }
1274 }