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

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