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

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2017 Kern Sibbald
   5
   6    The original author of Bacula is Kern Sibbald, with contributions
   7    from many others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    This notice must be preserved when any source code is
  15    conveyed and/or propagated.
  16
  17    Bacula(R) is a registered trademark of Kern Sibbald.
  18 */
  19 /*
  20  *  This file handles accepting Director Commands
  21  *
  22  *    Most Director commands are handled here, with the
  23  *    exception of the Job command command and subsequent
  24  *    subcommands that are handled
  25  *    in job.c.
  26  *
  27  *    N.B. in this file, in general we must use P(dev->mutex) rather
  28  *      than dev->rLock() so that we can examine the blocked
  29  *      state rather than blocking ourselves because a Job
  30  *      thread has the device blocked. In some "safe" cases,
  31  *      we can do things to a blocked device. CAREFUL!!!!
  32  *
  33  *    File daemon commands are handled in fdcmd.c
  34  *
  35  *     Written by Kern Sibbald, May MMI
  36  *
  37  */
  38
  39 #include "bacula.h"
  40 #include "stored.h"
  41
  42 /* Exported variables */
  43
  44 /* Imported variables */
  45 extern BSOCK *filed_chan;
  46 extern struct s_last_job last_job;
  47 extern bool init_done;
  48
  49 /* Static variables */
  50 static char derrmsg[]     = "3900 Invalid command:";
  51 static char OKsetdebug[]  = "3000 OK setdebug=%ld trace=%ld options=%s tags=%s\n";
  52 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n";
  53 static char OK_bootstrap[]    = "3000 OK bootstrap\n";
  54 static char ERROR_bootstrap[] = "3904 Error bootstrap\n";
  55 static char OKclient[] = "3000 OK client command\n";
  56
  57 /* Imported functions */
  58 extern void terminate_child();
  59 extern bool job_cmd(JCR *jcr);
  60 extern bool use_cmd(JCR *jcr);
  61 extern bool run_cmd(JCR *jcr);
  62 extern bool status_cmd(JCR *sjcr);
  63 extern bool qstatus_cmd(JCR *jcr);
  64 //extern bool query_cmd(JCR *jcr);
  65
  66 /* Forward referenced functions */
  67 static bool client_cmd(JCR *jcr);
  68 static bool storage_cmd(JCR *jcr);
  69 static bool label_cmd(JCR *jcr);
  70 static bool die_cmd(JCR *jcr);
  71 static bool relabel_cmd(JCR *jcr);
  72 static bool truncate_cache_cmd(JCR *jcr);
  73 static bool upload_cmd(JCR *jcr);
  74 static bool readlabel_cmd(JCR *jcr);
  75 static bool release_cmd(JCR *jcr);
  76 static bool setdebug_cmd(JCR *jcr);
  77 static bool cancel_cmd(JCR *cjcr);
  78 static bool mount_cmd(JCR *jcr);
  79 static bool unmount_cmd(JCR *jcr);
  80 static bool enable_cmd(JCR *jcr);
  81 static bool disable_cmd(JCR *jcr);
  82 //static bool action_on_purge_cmd(JCR *jcr);
  83 static bool bootstrap_cmd(JCR *jcr);
  84 static bool cloud_list_cmd(JCR *jcr);
  85 static bool cloud_prunecache_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,
  89                         POOLMEM *media_type, int drive);
  90 static DCR *find_any_device(JCR *jcr, POOL_MEM &dev_name,
  91                         POOLMEM *media_type, int drive);
  92 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
  93 static void label_volume_if_ok(DCR *dcr, char *oldname,
  94                                char *newname, char *poolname,
  95                                int Slot, int relabel);
  96 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
  97 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
  98
  99 /* Responses send to Director for storage command */
 100 static char BADcmd[]  = "2902 Bad %s\n";
 101 static char OKstore[] = "2000 OK storage\n";
 102
 103 /* Commands received from director that need scanning */
 104 static char storaddr[] = "storage address=%s port=%d ssl=%d Job=%127s Authentication=%127s";
 105
 106 struct s_cmds {
 107    const char *cmd;
 108    bool (*func)(JCR *jcr);
 109    bool monitoraccess;                      /* set if monitors can access this cmd */
 110 };
 111
 112 /*
 113  * The following are the recognized commands from the Director.
 114  */
 115 static struct s_cmds cmds[] = {
 116    {"JobId=",      job_cmd,         0},     /* start Job */
 117    {"autochanger", changer_cmd,     0},
 118    {"bootstrap",   bootstrap_cmd,   0},
 119    {"cancel",      cancel_cmd,      0},
 120    {"client",      client_cmd,      0},     /* client address */
 121    {".die",        die_cmd,         0},
 122    {"label",       label_cmd,       0},     /* label a tape */
 123    {"mount",       mount_cmd,       0},
 124    {"enable",      enable_cmd,      0},
 125    {"disable",     disable_cmd,     0},
 126    {"readlabel",   readlabel_cmd,   0},
 127    {"release",     release_cmd,     0},
 128    {"relabel",     relabel_cmd,     0},     /* relabel a tape */
 129    {"setdebug=",   setdebug_cmd,    0},     /* set debug level */
 130    {"status",      status_cmd,      1},
 131    {".status",     qstatus_cmd,     1},
 132    {"stop",        cancel_cmd,      0},
 133    {"storage",     storage_cmd,     0},     /* get SD addr from Dir */
 134    {"truncate",    truncate_cache_cmd, 0},
 135    {"upload",      upload_cmd,      0},
 136    {"prunecache",  cloud_prunecache_cmd, 0},
 137    {"cloudlist",   cloud_list_cmd,  0},     /* List volumes/parts in the cloud */
 138    {"unmount",     unmount_cmd,     0},
 139    {"use storage=", use_cmd,        0},
 140    {"run",         run_cmd,         0},
 141 // {"query",       query_cmd,       0},
 142    {NULL,        NULL}                      /* list terminator */
 143 };
 144
 145
 146 /*
 147  * Connection request. We accept connections either from the
 148  *  Director or a Client (File daemon).
 149  *
 150  * Note, we are running as a separate thread of the Storage daemon.
 151  *  and it is because a Director has made a connection with
 152  *  us on the "Message" channel.
 153  *
 154  * Basic tasks done here:
 155  *  - Create a JCR record
 156  *  - If it was from the FD, call handle_filed_connection()
 157  *  - Authenticate the Director
 158  *  - We wait for a command
 159  *  - We execute the command
 160  *  - We continue or exit depending on the return status
 161  */
 162 void *handle_connection_request(void *arg)
 163 {
 164    BSOCK *bs = (BSOCK *)arg;
 165    JCR *jcr;
 166    int i;
 167    bool found, quit;
 168    int bnet_stat = 0;
 169    char tbuf[100];
 170
 171    if (bs->recv() <= 0) {
 172       Jmsg1(NULL, M_ERROR, 0, _("Connection request from %s failed.\n"), bs->who());
 173       bmicrosleep(5, 0);   /* make user wait 5 seconds */
 174       bs->destroy();
 175       return NULL;
 176    }
 177
 178    /* Check for client connection */
 179    if (is_client_connection(bs)) {
 180       handle_client_connection(bs);
 181       return NULL;
 182    }
 183
 184    /*
 185     * This is a connection from the Director, so setup a JCR
 186     */
 187    Dmsg1(050, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 188          (utime_t)time(NULL)));
 189    jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
 190    jcr->dir_bsock = bs;               /* save Director bsock */
 191    jcr->dir_bsock->set_jcr(jcr);
 192    jcr->dcrs = New(alist(10, not_owned_by_alist));
 193    create_jobmedia_queue(jcr);
 194    /* Initialize FD start condition variable */
 195    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 196    if (errstat != 0) {
 197       berrno be;
 198       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 199       goto bail_out;
 200    }
 201
 202    Dmsg0(1000, "stored in start_job\n");
 203
 204    /*
 205     * Validate then authenticate the Director
 206     */
 207    if (!validate_dir_hello(jcr)) {
 208       goto bail_out;
 209    }
 210    if (!authenticate_director(jcr)) {
 211       Jmsg(jcr, M_FATAL, 0, _("[SF0100] Unable to authenticate Director\n"));
 212       goto bail_out;
 213    }
 214    Dmsg0(90, "Message channel init completed.\n");
 215
 216    dequeue_messages(jcr);     /* dequeue any daemon messages */
 217
 218    for (quit=false; !quit;) {
 219       /* Read command */
 220       if ((bnet_stat = bs->recv()) <= 0) {
 221          break;               /* connection terminated */
 222       }
 223       Dmsg1(199, "<dird: %s", bs->msg);
 224       /* Ensure that device initialization is complete */
 225       while (!init_done) {
 226          bmicrosleep(1, 0);
 227       }
 228       found = false;
 229       for (i=0; cmds[i].cmd; i++) {
 230         if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 231            if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
 232               Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
 233               bs->fsend(invalid_cmd);
 234               bs->signal(BNET_EOD);
 235               break;
 236            }
 237            Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
 238            if (!cmds[i].func(jcr)) { /* do command */
 239               quit = true; /* error, get out */
 240               Dmsg1(190, "Command %s requests quit\n", cmds[i].cmd);
 241            }
 242            found = true;             /* indicate command found */
 243            break;
 244         }
 245       }
 246       if (!found) {                   /* command not found */
 247         POOL_MEM err_msg;
 248         Mmsg(err_msg, "%s %s\n", derrmsg, bs->msg);
 249         bs->fsend(err_msg.c_str());
 250         break;
 251       }
 252    }
 253 bail_out:
 254    generate_daemon_event(jcr, "JobEnd");
 255    generate_plugin_event(jcr, bsdEventJobEnd);
 256    flush_jobmedia_queue(jcr);
 257    dequeue_messages(jcr);             /* send any queued messages */
 258    bs->signal(BNET_TERMINATE);
 259    free_plugins(jcr);                 /* release instantiated plugins */
 260    free_jcr(jcr);
 261    return NULL;
 262 }
 263
 264
 265 /*
 266  * Force SD to die, and hopefully dump itself.  Turned on only
 267  *  in development version.
 268  */
 269 static bool die_cmd(JCR *jcr)
 270 {
 271 #ifdef DEVELOPER
 272    JCR *djcr = NULL;
 273    int a;
 274    BSOCK *dir = jcr->dir_bsock;
 275    pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
 276
 277    if (strstr(dir->msg, "deadlock")) {
 278       Pmsg0(000, "I have been requested to deadlock ...\n");
 279       P(m);
 280       P(m);
 281    }
 282
 283    Pmsg1(000, "I have been requested to die ... (%s)\n", dir->msg);
 284    a = djcr->JobId;   /* ref NULL pointer */
 285    djcr->JobId = a;
 286 #endif
 287    return 0;
 288 }
 289
 290 /*
 291  * Get address of client from Director
 292  *   This initiates SD Calls Client.
 293  *   We attempt to connect to the client (an FD or SD) and
 294  *   authenticate it.
 295  */
 296 static bool client_cmd(JCR *jcr)
 297 {
 298    int client_port;                 /* client port */
 299    int enable_ssl;                 /* enable ssl */
 300    BSOCK *dir = jcr->dir_bsock;
 301    BSOCK *cl = new_bsock();        /* client bsock */
 302
 303    Dmsg1(100, "ClientCmd: %s", dir->msg);
 304    jcr->sd_calls_client = true;
 305    if (sscanf(dir->msg, "client address=%s port=%d ssl=%d", &jcr->client_addr, &client_port,
 306               &enable_ssl) != 3) {
 307       pm_strcpy(jcr->errmsg, dir->msg);
 308       Jmsg(jcr, M_FATAL, 0, _("[SF0101] Bad client command: %s"), jcr->errmsg);
 309       Dmsg1(050, "Bad client command: %s", jcr->errmsg);
 310       goto bail_out;
 311    }
 312
 313    Dmsg3(110, "Connect to client: %s:%d ssl=%d\n", jcr->client_addr, client_port,
 314          enable_ssl);
 315    /* Open command communications with Client */
 316    /* Try to connect for 1 hour at 10 second intervals */
 317    if (!cl->connect(jcr, 10, (int)me->ClientConnectTimeout, me->heartbeat_interval,
 318                 _("Client daemon"), jcr->client_addr, NULL, client_port, 1)) {
 319       /* destroy() OK because cl is local */
 320       cl->destroy();
 321       Jmsg(jcr, M_FATAL, 0, _("[SF0102] Failed to connect to Client daemon: %s:%d\n"),
 322           jcr->client_addr, client_port);
 323       Dmsg2(100, "Failed to connect to Client daemon: %s:%d\n",
 324           jcr->client_addr, client_port);
 325       goto bail_out;
 326    }
 327    Dmsg0(110, "SD connection OK to Client.\n");
 328
 329    jcr->file_bsock = cl;
 330    jcr->file_bsock->set_jcr(jcr);
 331    if (!send_hello_client(jcr, jcr->Job)) {
 332       goto bail_out;
 333    }
 334
 335    /* Send OK to Director */
 336    return dir->fsend(OKclient);
 337
 338 bail_out:
 339    jcr->setJobStatus(JS_ErrorTerminated);
 340    dir->fsend("3902 Bad %s cmd\n", "client");
 341    return 0;
 342 }
 343
 344 /*
 345  * Get address of storage daemon from Director
 346  */
 347 static bool storage_cmd(JCR *jcr)
 348 {
 349    int stored_port;                /* storage daemon port */
 350    int enable_ssl;                 /* enable ssl to sd */
 351    char sd_auth_key[200];
 352    BSOCK *dir = jcr->dir_bsock;
 353    BSOCK *sd = new_bsock();        /* storage daemon bsock */
 354    char Job[MAX_NAME_LENGTH];
 355
 356    Dmsg1(050, "StorageCmd: %s", dir->msg);
 357    if (sscanf(dir->msg, storaddr, &jcr->stored_addr, &stored_port,
 358               &enable_ssl, Job, sd_auth_key) != 5) {
 359       pm_strcpy(jcr->errmsg, dir->msg);
 360       Jmsg(jcr, M_FATAL, 0, _("[SF0103] Bad storage command: %s"), jcr->errmsg);
 361       Pmsg1(010, "Bad storage command: %s", jcr->errmsg);
 362       goto bail_out;
 363    }
 364
 365    unbash_spaces(Job);
 366    if (jcr->sd_auth_key) {
 367       bfree_and_null(jcr->sd_auth_key);
 368       jcr->sd_auth_key = bstrdup(sd_auth_key);
 369    }
 370    if (stored_port != 0) {
 371       Dmsg2(050, "sd_calls=%d sd_client=%d\n", jcr->sd_calls_client,
 372          jcr->sd_client);
 373       jcr->sd_calls_client = false;   /* We are doing the connecting */
 374       Dmsg3(050, "Connect to storage and wait: %s:%d ssl=%d\n", jcr->stored_addr, stored_port,
 375             enable_ssl);
 376       /* Open command communications with Storage daemon */
 377       /* Try to connect for 1 hour at 10 second intervals */
 378       if (!sd->connect(jcr, 10, (int)me->ClientConnectTimeout, me->heartbeat_interval,
 379                 _("Storage daemon"), jcr->stored_addr, NULL, stored_port, 1)) {
 380          /* destroy() OK because sd is local */
 381          sd->destroy();
 382          Jmsg(jcr, M_FATAL, 0, _("[SF0104] Failed to connect to Storage daemon: %s:%d\n"),
 383              jcr->stored_addr, stored_port);
 384          Dmsg2(010, "Failed to connect to Storage daemon: %s:%d\n",
 385              jcr->stored_addr, stored_port);
 386          goto bail_out;
 387       }
 388
 389       Dmsg0(050, "Connection OK to SD.\n");
 390
 391       jcr->store_bsock = sd;
 392    } else {                      /* The storage daemon called us */
 393       jcr->sd_calls_client = true;
 394       /* We should already have a storage connection! */
 395       if (jcr->file_bsock && jcr->store_bsock == NULL) {
 396          jcr->store_bsock = jcr->file_bsock;
 397       }
 398       if (jcr->store_bsock == NULL) {
 399          Jmsg0(jcr, M_FATAL, 0, _("[SF0105] In storage_cmd port==0, no prior Storage connection.\n"));
 400          Pmsg0(010, "In storage_cmd port==0, no prior Storage connection.\n");
 401          goto bail_out;
 402       }
 403    }
 404
 405    if (!send_hello_sd(jcr, Job)) {
 406       goto bail_out;
 407    }
 408
 409    if (!authenticate_storagedaemon(jcr)) {
 410       goto bail_out;
 411    }
 412    /*
 413     * We are a client so we read from the socket we just
 414     *   opened as if we were a FD, so set file_bsock and
 415     *   clear the store_bsock.
 416     */
 417    jcr->file_bsock = jcr->store_bsock;
 418    jcr->store_bsock = NULL;
 419    jcr->authenticated = true;    /* Dir authentication is sufficient */
 420    Dmsg1(050, "=== Storage_cmd authenticated Job=%s with SD.\n", Job);
 421
 422    /* Send OK to Director */
 423    return dir->fsend(OKstore);
 424
 425 bail_out:
 426    Dmsg0(100, "Send storage command failed.\n");
 427    dir->fsend(BADcmd, "storage");
 428    return false;
 429 }
 430
 431
 432 /*
 433  * Set debug level as requested by the Director
 434  *
 435  */
 436 static bool setdebug_cmd(JCR *jcr)
 437 {
 438    BSOCK *dir = jcr->dir_bsock;
 439    int32_t trace_flag, lvl, hangup, blowup;
 440    int64_t level, level_tags = 0;
 441    char options[60];
 442    char tags[512];
 443    *tags = *options = 0;
 444
 445    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 446
 447    if (sscanf(dir->msg, "setdebug=%ld trace=%ld hangup=%ld blowup=%ld options=%55s tags=%511s",
 448               &lvl, &trace_flag, &hangup, &blowup, options, tags) != 6)
 449    {
 450       if (sscanf(dir->msg, "setdebug=%ld trace=%ld", &lvl, &trace_flag) != 2 || lvl < 0) {
 451          dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
 452          return 0;
 453       }
 454    }
 455    level = lvl;
 456    set_trace(trace_flag);
 457    set_hangup(hangup);
 458    set_blowup(blowup);
 459    set_debug_flags(options);
 460    if (!debug_parse_tags(tags, &level_tags)) {
 461       *tags = 0;
 462    }
 463    if (level >= 0) {
 464       debug_level = level;
 465    }
 466    debug_level_tags = level_tags;
 467
 468    /* TODO: Temp code to activate the new BSR optimisation code */
 469    for (char *p = options; *p ; p++) {
 470       switch(*p) {
 471       case 'i':                 /* Use new match_bsr() code */
 472          use_new_match_all = 1;
 473          break;
 474       case '0':
 475          use_new_match_all = 0;
 476          break;
 477       }
 478    }
 479    /* **** */
 480
 481    return dir->fsend(OKsetdebug, lvl, trace_flag, options, tags);
 482 }
 483
 484
 485 /*
 486  * Cancel a Job
 487  *   Be careful, we switch to using the job's JCR! So, using
 488  *   BSOCKs on that jcr can have two threads in the same code.
 489  */
 490 static bool cancel_cmd(JCR *cjcr)
 491 {
 492    BSOCK *dir = cjcr->dir_bsock;
 493    int oldStatus;
 494    char Job[MAX_NAME_LENGTH];
 495    JCR *jcr;
 496    int status;
 497    const char *reason;
 498
 499    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 500       status = JS_Canceled;
 501       reason = "canceled";
 502    } else if (sscanf(dir->msg, "stop Job=%127s", Job) == 1) {
 503       status = JS_Incomplete;
 504       reason = "stopped";
 505    } else {
 506       dir->fsend(_("3903 Error scanning cancel command.\n"));
 507       goto bail_out;
 508    }
 509    if (!(jcr=get_jcr_by_full_name(Job))) {
 510       dir->fsend(_("3904 Job %s not found.\n"), Job);
 511    } else {
 512       oldStatus = jcr->JobStatus;
 513       jcr->setJobStatus(status);
 514       Dmsg2(800, "Cancel JobId=%d %p\n", jcr->JobId, jcr);
 515       if (!jcr->authenticated && oldStatus == JS_WaitFD) {
 516          pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 517       }
 518       if (jcr->file_bsock) {
 519          jcr->file_bsock->set_terminated();
 520          jcr->file_bsock->set_timed_out();
 521          Dmsg2(800, "Term bsock jid=%d %p\n", jcr->JobId, jcr);
 522       } else {
 523          /* Still waiting for FD to connect, release it */
 524          pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
 525          Dmsg2(800, "Signal FD connect jid=%d %p\n", jcr->JobId, jcr);
 526       }
 527       /* If thread waiting on mount, wake him */
 528       if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
 529          pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 530          Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 531          pthread_cond_broadcast(&wait_device_release);
 532       }
 533       if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
 534          pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 535          Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 536          pthread_cond_broadcast(&wait_device_release);
 537       }
 538       jcr->my_thread_send_signal(TIMEOUT_SIGNAL);
 539       dir->fsend(_("3000 JobId=%ld Job=\"%s\" marked to be %s.\n"),
 540          jcr->JobId, jcr->Job, reason);
 541       free_jcr(jcr);
 542    }
 543
 544 bail_out:
 545    dir->signal(BNET_EOD);
 546    return 1;
 547 }
 548
 549 /*
 550  * Label a Volume
 551  *
 552  */
 553 static bool label_cmd(JCR *jcr)
 554 {
 555    return do_label(jcr, 0);
 556 }
 557
 558 static bool relabel_cmd(JCR *jcr)
 559 {
 560    return do_label(jcr, 1);
 561 }
 562
 563 static bool do_label(JCR *jcr, int relabel)
 564 {
 565    POOLMEM *newname, *oldname, *poolname, *mtype;
 566    POOL_MEM dev_name;
 567    BSOCK *dir = jcr->dir_bsock;
 568    DCR *dcr = NULL;;
 569    DEVICE *dev;
 570    bool ok = false;
 571    int32_t slot, drive;
 572
 573    newname = get_memory(dir->msglen+1);
 574    oldname = get_memory(dir->msglen+1);
 575    poolname = get_memory(dir->msglen+1);
 576    mtype = get_memory(dir->msglen+1);
 577    if (relabel) {
 578       if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
 579                  "MediaType=%127s Slot=%d drive=%d",
 580                   dev_name.c_str(), oldname, newname, poolname, mtype,
 581                   &slot, &drive) == 7) {
 582          ok = true;
 583       }
 584    } else {
 585       *oldname = 0;
 586       if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
 587                  "MediaType=%127s Slot=%d drive=%d",
 588           dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
 589          ok = true;
 590       }
 591    }
 592    if (ok) {
 593       unbash_spaces(newname);
 594       unbash_spaces(oldname);
 595       unbash_spaces(poolname);
 596       unbash_spaces(mtype);
 597       dcr = find_device(jcr, dev_name, mtype, drive);
 598       if (dcr) {
 599          uint32_t max_jobs;
 600          dev = dcr->dev;
 601          ok = true;
 602          dev->Lock();                 /* Use P to avoid indefinite block */
 603          max_jobs = dev->max_concurrent_jobs;
 604          dev->max_concurrent_jobs = 1;
 605          bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 606          if (dcr->can_i_write_volume()) {
 607             if (reserve_volume(dcr, newname) == NULL) {
 608                ok = false;
 609             }
 610             Dmsg1(400, "Reserved volume \"%s\"\n", newname);
 611          } else {
 612             ok = false;
 613          }
 614          if (!ok) {
 615             dir->fsend(_("3908 Error reserving volume: %s\n"), jcr->errmsg);
 616             dev->max_concurrent_jobs = max_jobs;
 617             dev->Unlock();
 618             goto bail_out;
 619          }
 620
 621          /* some command use recv and don't accept catalog update.
 622           * it's not the case here, so we force dir_update_volume_info catalog update */
 623          dcr->force_update_volume_info = true;
 624
 625          if (!dev->is_open() && !dev->is_busy()) {
 626             Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
 627             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 628             dev->close(dcr);
 629          /* Under certain "safe" conditions, we can steal the lock */
 630          } else if (dev->can_steal_lock()) {
 631             Dmsg0(400, "Can relabel. can_steal_lock\n");
 632             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 633          } else if (dev->is_busy() || dev->is_blocked()) {
 634             send_dir_busy_message(dir, dev);
 635          } else {                     /* device not being used */
 636             Dmsg0(400, "Can relabel. device not used\n");
 637             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 638          }
 639          dev->max_concurrent_jobs = max_jobs;
 640          volume_unused(dcr);
 641          dev->Unlock();
 642 #ifdef DEVELOPER
 643          if (chk_dbglvl(DT_VOLUME)) {
 644             Dmsg0(0, "Waiting few seconds to force a bug...\n");
 645             bmicrosleep(30, 0);
 646             Dmsg0(0, "Doing free_volume()\n");
 647          }
 648 #endif
 649       } else {
 650          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 651       }
 652    } else {
 653       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 654       pm_strcpy(jcr->errmsg, dir->msg);
 655       dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
 656    }
 657 bail_out:
 658    if (dcr) {
 659       free_dcr(dcr);
 660    }
 661    free_memory(oldname);
 662    free_memory(newname);
 663    free_memory(poolname);
 664    free_memory(mtype);
 665    dir->signal(BNET_EOD);
 666    return true;
 667 }
 668
 669 /*
 670  * Handles truncate cache commands
 671  */
 672 static bool truncate_cache_cmd(JCR *jcr)
 673 {
 674    POOLMEM *volname, *poolname, *mtype;
 675    POOL_MEM dev_name;
 676    BSOCK *dir = jcr->dir_bsock;
 677    DCR *dcr = NULL;;
 678    DEVICE *dev;
 679    bool ok = false;
 680    int32_t slot, drive;
 681    int nbpart = 0;
 682    int64_t size = 0;
 683    char ed1[50];
 684
 685    volname = get_memory(dir->msglen+1);
 686    poolname = get_memory(dir->msglen+1);
 687    mtype = get_memory(dir->msglen+1);
 688    if (sscanf(dir->msg, "truncate cache Storage=%127s Volume=%127s PoolName=%127s "
 689               "MediaType=%127s Slot=%d drive=%d",
 690                dev_name.c_str(), volname, poolname, mtype,
 691                &slot, &drive) == 6) {
 692       ok = true;
 693    }
 694    if (ok) {
 695       unbash_spaces(volname);
 696       unbash_spaces(poolname);
 697       unbash_spaces(mtype);
 698       dcr = find_device(jcr, dev_name, mtype, drive);
 699       if (dcr) {
 700          uint32_t max_jobs;
 701          dev = dcr->dev;
 702          ok = true;
 703          dev->Lock();                 /* Use P to avoid indefinite block */
 704          max_jobs = dev->max_concurrent_jobs;
 705          dev->max_concurrent_jobs = 1;
 706          bstrncpy(dcr->VolumeName, volname, sizeof(dcr->VolumeName));
 707          if (dcr->can_i_write_volume()) {
 708             if (reserve_volume(dcr, volname) == NULL) {
 709                ok = false;
 710             }
 711             Dmsg1(400, "Reserved volume \"%s\"\n", volname);
 712          } else {
 713             ok = false;
 714          }
 715          if (!ok) {
 716             dir->fsend(_("3908 Error reserving volume \"%s\": %s\n"), volname, jcr->errmsg);
 717             dev->max_concurrent_jobs = max_jobs;
 718             dev->Unlock();
 719             goto bail_out;
 720          }
 721          if ((!dev->is_open() && !dev->is_busy()) || dev->can_steal_lock()) {
 722             Dmsg0(400, "Call truncate_cache\n");
 723             nbpart = dev->truncate_cache(dcr, volname, &size);
 724             if (nbpart >= 0) {
 725                dir->fsend(_("3000 OK truncate cache for volume \"%s\" %d part(s) %sB\n"),
 726                           volname, nbpart, edit_uint64_with_suffix(size, ed1));
 727             } else {
 728                dir->fsend(_("3900 Truncate cache for volume \"%s\" failed. ERR=%s\n"), volname, dev->errmsg);
 729             }
 730          } else if (dev->is_busy() || dev->is_blocked()) {
 731             send_dir_busy_message(dir, dev);
 732          } else {                     /* device not being used */
 733             Dmsg0(400, "Call truncate_cache\n");
 734             nbpart = dev->truncate_cache(dcr, volname, &size);
 735             if (nbpart >= 0) {
 736                dir->fsend(_("3000 OK truncate cache for volume \"%s\" %d part(s) %sB\n"), volname,
 737                           nbpart, edit_uint64_with_suffix(size, ed1));
 738             } else {
 739                dir->fsend(_("3900 Truncate cache for volume \"%s\" failed. ERR=%s\n"), volname, dev->errmsg);
 740             }
 741          }
 742          dev->max_concurrent_jobs = max_jobs;
 743          volume_unused(dcr);
 744          dev->Unlock();
 745 #ifdef DEVELOPER
 746          if (chk_dbglvl(DT_VOLUME)) {
 747             Dmsg0(0, "Waiting few seconds to force a bug...\n");
 748             bmicrosleep(30, 0);
 749             Dmsg0(0, "Doing free_volume()\n");
 750          }
 751 #endif
 752       } else {
 753          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 754       }
 755    } else {
 756       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 757       pm_strcpy(jcr->errmsg, dir->msg);
 758       dir->fsend(_("3911 Error scanning truncate command: %s\n"), jcr->errmsg);
 759    }
 760 bail_out:
 761    if (dcr) {
 762       free_dcr(dcr);
 763    }
 764    free_memory(volname);
 765    free_memory(poolname);
 766    free_memory(mtype);
 767    dir->signal(BNET_EOD);
 768    return true;
 769 }
 770
 771 static bool cloud_prunecache_cmd(JCR *jcr)
 772 {
 773    /* TODO: Implement a function to prune the cache of a cloud device */
 774    jcr->dir_bsock->fsend(_("3900 Not yet implemented\n"));
 775    return true;
 776 }
 777
 778 /* List volumes in the cloud */
 779 static bool cloud_list_cmd(JCR *jcr)
 780 {
 781    jcr->dir_bsock->fsend(_("3900 Not yet implemented\n"));
 782    return true;
 783 }
 784
 785 /*
 786  * Handles upload cache to Cloud command
 787  */
 788 static bool upload_cmd(JCR *jcr)
 789 {
 790    POOLMEM *volname, *poolname, *mtype, *err;
 791    POOL_MEM dev_name;
 792    BSOCK *dir = jcr->dir_bsock;
 793    DCR *dcr = NULL;
 794    DEVICE *dev;
 795    bool ok = false;
 796    int32_t slot, drive;
 797
 798    volname = get_memory(dir->msglen+1);
 799    poolname = get_memory(dir->msglen+1);
 800    mtype = get_memory(dir->msglen+1);
 801    err = get_pool_memory(PM_MESSAGE);
 802    *volname = *poolname = *mtype = *err = 0;
 803
 804    if (sscanf(dir->msg, "upload Storage=%127s Volume=%127s PoolName=%127s "
 805               "MediaType=%127s Slot=%d drive=%d",
 806                dev_name.c_str(), volname, poolname, mtype,
 807                &slot, &drive) == 6) {
 808       ok = true;
 809    }
 810    if (ok) {
 811       unbash_spaces(volname);
 812       unbash_spaces(poolname);
 813       unbash_spaces(mtype);
 814       dcr = find_device(jcr, dev_name, mtype, drive);
 815       if (dcr) {
 816          uint32_t max_jobs;
 817          dev = dcr->dev;
 818          ok = true;
 819          dev->Lock();                 /* Use P to avoid indefinite block */
 820          max_jobs = dev->max_concurrent_jobs;
 821          dev->max_concurrent_jobs = 1;
 822          bstrncpy(dcr->VolumeName, volname, sizeof(dcr->VolumeName));
 823          if (dcr->can_i_write_volume()) {
 824             if (reserve_volume(dcr, volname) == NULL) {
 825                ok = false;
 826             }
 827             Dmsg1(400, "Reserved volume \"%s\"\n", volname);
 828          } else {
 829             ok = false;
 830          }
 831          if (!ok) {
 832             dir->fsend(_("3908 Error reserving volume \"%s\": %s\n"), volname, jcr->errmsg);
 833             dev->max_concurrent_jobs = max_jobs;
 834             dev->Unlock();
 835             goto bail_out;
 836          }
 837          if ((!dev->is_open() && !dev->is_busy()) || dev->can_steal_lock()) {
 838             Dmsg0(400, "Can upload, because device is not open.\n");
 839             dev->setVolCatName(volname);
 840             dev->part = 0;
 841             if (dev->open_device(dcr, OPEN_READ_WRITE)) {
 842                ok = dev->upload_cache(dcr, volname, err);
 843                dev->part = 0;
 844                dev->close(dcr);
 845                dev->end_of_job(dcr);
 846             }
 847          } else if (dev->is_busy() || dev->is_blocked()) {
 848             send_dir_busy_message(dir, dev);
 849          } else {                     /* device not being used */
 850             Dmsg0(400, "Can upload, because device not used\n");
 851             dev->setVolCatName(volname);
 852             dev->part = 0;
 853             if (dev->open_device(dcr, OPEN_READ_WRITE)) {
 854                ok = dev->upload_cache(dcr, volname, err);
 855                dev->part = 0;
 856                dev->close(dcr);
 857                dev->end_of_job(dcr);
 858             }
 859          }
 860          dev->max_concurrent_jobs = max_jobs;
 861          volume_unused(dcr);
 862          dev->Unlock();
 863 #ifdef DEVELOPER
 864          if (chk_dbglvl(DT_VOLUME)) {
 865             Dmsg0(0, "Waiting few seconds to force a bug...\n");
 866             bmicrosleep(30, 0);
 867             Dmsg0(0, "Doing free_volume()\n");
 868          }
 869 #endif
 870       } else {
 871          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 872       }
 873    } else {
 874       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 875       pm_strcpy(jcr->errmsg, dir->msg);
 876       dir->fsend(_("3912 Error scanning upload command: ERR=%s\n"), jcr->errmsg);
 877    }
 878 bail_out:
 879    if (ok) {
 880       dir->fsend(_("3000 OK upload.\n"));
 881    } else {
 882       dir->fsend(_("3999 Error with the upload: ERR=%s\n"), err);
 883    }
 884    if (dcr) {
 885       free_dcr(dcr);
 886    }
 887    free_pool_memory(err);
 888    free_memory(volname);
 889    free_memory(poolname);
 890    free_memory(mtype);
 891    dir->signal(BNET_EOD);
 892    return true;
 893 }
 894
 895
 896 /*
 897  * Read the tape label and determine if we can safely
 898  * label the tape (not a Bacula volume), then label it.
 899  *
 900  *  Enter with the mutex set
 901  */
 902 static void label_volume_if_ok(DCR *dcr, char *oldname,
 903                                char *newname, char *poolname,
 904                                int slot, int relabel)
 905 {
 906    BSOCK *dir = dcr->jcr->dir_bsock;
 907    bsteal_lock_t hold;
 908    DEVICE *dev = dcr->dev;
 909    int label_status;
 910    int mode;
 911    const char *volname = (relabel == 1) ? oldname : newname;
 912    uint64_t volCatBytes;
 913
 914    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 915    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
 916
 917    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 918    if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
 919       goto bail_out;                  /* error */
 920    }
 921
 922
 923    if (relabel) {
 924       dev->truncating = true;         /* let open_device() know we will truncate it */
 925    }
 926    /* Set old volume name for open if relabeling */
 927    dcr->setVolCatName(volname);
 928
 929    /* Ensure that the device is open -- autoload_device() closes it */
 930    if (dev->is_tape()) {
 931       mode = OPEN_READ_WRITE;
 932    } else {
 933       mode = CREATE_READ_WRITE;
 934    }
 935    if (!dev->open_device(dcr, mode)) {
 936       dir->fsend(_("3929 Unable to open device \"%s\": ERR=%s\n"),
 937          dev->print_name(), dev->bstrerror());
 938       goto bail_out;
 939    }
 940
 941    /* See what we have for a Volume */
 942    label_status = dev->read_dev_volume_label(dcr);
 943
 944    /* Set new volume name */
 945    dcr->setVolCatName(newname);
 946    switch(label_status) {
 947    case VOL_NAME_ERROR:
 948    case VOL_VERSION_ERROR:
 949    case VOL_LABEL_ERROR:
 950    case VOL_OK:
 951       if (!relabel) {
 952          dir->fsend(_(
 953             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
 954              dev->VolHdr.VolumeName);
 955          break;
 956       }
 957
 958       /* Relabel request. If oldname matches, continue */
 959       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
 960          dir->fsend(_("3921 Wrong volume mounted.\n"));
 961          break;
 962       }
 963       if (dev->label_type != B_BACULA_LABEL) {
 964          dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
 965          break;
 966       }
 967       /* Fall through wanted! */
 968    case VOL_IO_ERROR:
 969    case VOL_NO_LABEL:
 970       if (!dev->write_volume_label(dcr, newname, poolname,
 971               relabel, true /* write label now */)) {
 972          dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dcr->jcr->errmsg);
 973          break;
 974       }
 975       volCatBytes = dev->VolCatInfo.VolCatBytes;
 976       /*
 977       * After writing label, create a new part
 978       */
 979       if (dev->is_cloud()) {
 980          dev->set_append();
 981          if (!dev->open_next_part(dcr)) {
 982             dir->fsend(_("3913 Failed to open next part: ERR=%s\n"), dcr->jcr->errmsg);
 983             break;
 984          }
 985       }
 986       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 987       /* The following 3000 OK label. string is scanned in ua_label.c */
 988       int type;
 989       if (dev->dev_type == B_FILE_DEV || dev->dev_type == B_ALIGNED_DEV ||
 990           dev->dev_type == B_CLOUD_DEV)
 991       {
 992          type = dev->dev_type;
 993       } else {
 994          type = 0;
 995       }
 996       dir->fsend("3000 OK label. VolBytes=%lld VolABytes=%lld VolType=%d Volume=\"%s\" Device=%s\n",
 997                  volCatBytes, dev->VolCatInfo.VolCatAdataBytes,
 998                  type, newname, dev->print_name());
 999       break;
1000    case VOL_TYPE_ERROR:
1001       dir->fsend(_("3917 Failed to label Volume: ERR=%s\n"), dcr->jcr->errmsg);
1002       break;
1003    case VOL_NO_MEDIA:
1004       dir->fsend(_("3918 Failed to label Volume (no media): ERR=%s\n"), dcr->jcr->errmsg);
1005       break;
1006    default:
1007       dir->fsend(_("3919 Cannot label Volume. "
1008                    "Unknown status %d from read_volume_label()\n"), label_status);
1009       break;
1010    }
1011
1012 bail_out:
1013    if (dev->is_open() && !dev->has_cap(CAP_ALWAYSOPEN)) {
1014       dev->close(dcr);
1015    }
1016
1017    dev->end_of_job(dcr);
1018
1019    if (!dev->is_open()) {
1020       dev->clear_volhdr();
1021    }
1022    volume_unused(dcr);                   /* no longer using volume */
1023    give_back_device_lock(dev, &hold);
1024    return;
1025 }
1026
1027
1028 /*
1029  * Read the tape label
1030  *
1031  *  Enter with the mutex set
1032  */
1033 static bool read_label(DCR *dcr)
1034 {
1035    int ok;
1036    JCR *jcr = dcr->jcr;
1037    BSOCK *dir = jcr->dir_bsock;
1038    bsteal_lock_t hold;
1039    DEVICE *dev = dcr->dev;
1040
1041    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
1042
1043    dcr->VolumeName[0] = 0;
1044    dev->clear_labeled();              /* force read of label */
1045    switch (dev->read_dev_volume_label(dcr)) {
1046    case VOL_OK:
1047       dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
1048       ok = true;
1049       break;
1050    default:
1051       dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"),
1052          dev->print_name(), jcr->errmsg);
1053       ok = false;
1054       break;
1055    }
1056    volume_unused(dcr);
1057    give_back_device_lock(dev, &hold);
1058    return ok;
1059 }
1060
1061 /*
1062  * Searches for device by name, and if found, creates a dcr and
1063  *  returns it.
1064  */
1065 static DCR *find_device(JCR *jcr, POOL_MEM &devname,
1066                         POOLMEM *media_type, int drive)
1067 {
1068    DEVRES *device;
1069    AUTOCHANGER *changer;
1070    bool found = false;
1071    DCR *dcr = NULL;
1072
1073    unbash_spaces(devname);
1074    foreach_res(device, R_DEVICE) {
1075       /* Find resource, and make sure we were able to open it */
1076       if (strcmp(device->hdr.name, devname.c_str()) == 0 &&
1077           (!media_type || strcmp(device->media_type, media_type) ==0)) {
1078          if (!device->dev) {
1079             device->dev = init_dev(jcr, device);
1080          }
1081          if (!device->dev) {
1082             Jmsg(jcr, M_WARNING, 0, _("\n"
1083                "[SW0106] Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1084                  devname.c_str());
1085             continue;
1086          }
1087          Dmsg1(20, "Found device %s\n", device->hdr.name);
1088          found = true;
1089          break;
1090       }
1091    }
1092    if (!found) {
1093       foreach_res(changer, R_AUTOCHANGER) {
1094          /* Find resource, and make sure we were able to open it */
1095          if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
1096             /* Try each device in this AutoChanger */
1097             foreach_alist(device, changer->device) {
1098                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
1099                if (!device->dev) {
1100                   device->dev = init_dev(jcr, device);
1101                }
1102                if (!device->dev) {
1103                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
1104                   Jmsg(jcr, M_WARNING, 0, _("\n"
1105                      "[SW0107] Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1106                        device->hdr.name, devname.c_str());
1107                   continue;
1108                }
1109                if (!device->dev->autoselect) {
1110                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
1111                   continue;              /* device is not available */
1112                } else if (!device->dev->enabled) {
1113                   Dmsg1(100, "Device %s disabled skipped.\n", devname.c_str());
1114                   continue;              /* device disabled */
1115                }
1116                if ((drive < 0 || drive == (int)device->dev->drive_index) &&
1117                    (!media_type || strcmp(device->media_type, media_type) ==0)) {
1118                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
1119                   found = true;
1120                   break;
1121                }
1122                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
1123                   devname.c_str(), drive, (int)device->dev->drive_index);
1124             }
1125             break;                    /* we found it but could not open a device */
1126          }
1127       }
1128    }
1129
1130    if (found) {
1131       Dmsg1(100, "Found device %s\n", device->hdr.name);
1132       dcr = new_dcr(jcr, NULL, device->dev);
1133       dcr->device = device;
1134    }
1135    return dcr;
1136 }
1137
1138 /*
1139  * Find even disabled devices so that we can enable them
1140  *   ***FIXME*** This could probably be merged with find_device with another
1141  *   argument, but this is easier for the moment.
1142  */
1143 static DCR *find_any_device(JCR *jcr, POOL_MEM &devname,
1144                         POOLMEM *media_type, int drive)
1145 {
1146    DEVRES *device;
1147    AUTOCHANGER *changer;
1148    bool found = false;
1149    DCR *dcr = NULL;
1150
1151    unbash_spaces(devname);
1152    foreach_res(device, R_DEVICE) {
1153       /* Find resource, and make sure we were able to open it */
1154       if (strcmp(device->hdr.name, devname.c_str()) == 0 &&
1155           (!media_type || strcmp(device->media_type, media_type) ==0)) {
1156          if (!device->dev) {
1157             device->dev = init_dev(jcr, device);
1158          }
1159          if (!device->dev) {
1160             Jmsg(jcr, M_WARNING, 0, _("\n"
1161                "[SW0108] Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1162                  devname.c_str());
1163             continue;
1164          }
1165          Dmsg1(20, "Found device %s\n", device->hdr.name);
1166          found = true;
1167          break;
1168       }
1169    }
1170    if (!found) {
1171       foreach_res(changer, R_AUTOCHANGER) {
1172          /* Find resource, and make sure we were able to open it */
1173          if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
1174             /* Try each device in this AutoChanger */
1175             foreach_alist(device, changer->device) {
1176                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
1177                if (!device->dev) {
1178                   device->dev = init_dev(jcr, device);
1179                }
1180                if (!device->dev) {
1181                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
1182                   Jmsg(jcr, M_WARNING, 0, _("\n"
1183                      "[SW0109] Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1184                        device->hdr.name, devname.c_str());
1185                   continue;
1186                }
1187                if ((drive < 0 || drive == (int)device->dev->drive_index) &&
1188                    (!media_type || strcmp(device->media_type, media_type) ==0)) {
1189                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
1190                   found = true;
1191                   break;
1192                }
1193                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
1194                   devname.c_str(), drive, (int)device->dev->drive_index);
1195             }
1196             break;                    /* we found it but could not open a device */
1197          }
1198       }
1199    }
1200
1201    if (found) {
1202       Dmsg1(100, "Found device %s\n", device->hdr.name);
1203       dcr = new_dcr(jcr, NULL, device->dev);
1204       dcr->device = device;
1205    }
1206    return dcr;
1207 }
1208
1209
1210 /*
1211  * Mount command from Director
1212  */
1213 static bool mount_cmd(JCR *jcr)
1214 {
1215    POOL_MEM devname;
1216    BSOCK *dir = jcr->dir_bsock;
1217    DEVICE *dev;
1218    DCR *dcr;
1219    int32_t drive;      /* device index */
1220    int32_t slot;
1221    bool ok;
1222
1223    Dmsg1(100, "%s\n", dir->msg);
1224    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
1225                &drive, &slot) == 3;
1226    Dmsg3(100, "ok=%d device_index=%d slot=%d\n", ok, drive, slot);
1227    if (ok) {
1228       dcr = find_device(jcr, devname, NULL, drive);
1229       if (dcr) {
1230          dev = dcr->dev;
1231          dev->Lock();                 /* Use P to avoid indefinite block */
1232          Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
1233             dev->must_unload());
1234          switch (dev->blocked()) {         /* device blocked? */
1235          case BST_WAITING_FOR_SYSOP:
1236             /* Someone is waiting, wake him */
1237             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
1238             dev->set_blocked(BST_MOUNT);
1239             dir->fsend("3001 OK mount requested. %sDevice=%s\n",
1240                        slot>0?_("Specified slot ignored. "):"",
1241                        dev->print_name());
1242             Dmsg1(100, "JobId=%u broadcast wait_next_vol\n", (uint32_t)dcr->jcr->JobId);
1243             pthread_cond_broadcast(&dev->wait_next_vol);
1244             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
1245             pthread_cond_broadcast(&wait_device_release);
1246             break;
1247
1248          /* In both of these two cases, we (the user) unmounted the Volume */
1249          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1250          case BST_UNMOUNTED:
1251             Dmsg2(100, "Unmounted changer=%d slot=%d\n", dev->is_autochanger(), slot);
1252             if (dev->is_autochanger() && slot > 0) {
1253                try_autoload_device(jcr, dcr, slot, "");
1254             }
1255             /* We freed the device, so reopen it and wake any waiting threads */
1256             if (!dev->open_device(dcr, OPEN_READ_ONLY)) {
1257                dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"),
1258                   dev->print_name(), dev->bstrerror());
1259                if (dev->blocked() == BST_UNMOUNTED) {
1260                   /* We blocked the device, so unblock it */
1261                   Dmsg0(100, "Unmounted. Unblocking device\n");
1262                   unblock_device(dev);
1263                }
1264                break;
1265             }
1266             dev->read_dev_volume_label(dcr);
1267             if (dev->blocked() == BST_UNMOUNTED) {
1268                /* We blocked the device, so unblock it */
1269                Dmsg0(100, "Unmounted. Unblocking device\n");
1270                read_label(dcr);       /* this should not be necessary */
1271                unblock_device(dev);
1272             } else {
1273                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
1274                dev->set_blocked(BST_MOUNT);
1275             }
1276             if (dev->is_labeled()) {
1277                dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"),
1278                   dev->print_name(), dev->VolHdr.VolumeName);
1279             } else {
1280                dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
1281                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
1282                           dev->print_name());
1283             }
1284             pthread_cond_broadcast(&dev->wait_next_vol);
1285             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
1286             pthread_cond_broadcast(&wait_device_release);
1287             break;
1288
1289          case BST_DOING_ACQUIRE:
1290             dir->fsend(_("3001 Device \"%s\" is doing acquire.\n"),
1291                        dev->print_name());
1292             break;
1293
1294          case BST_WRITING_LABEL:
1295             dir->fsend(_("3903 Device \"%s\" is being labeled.\n"),
1296                dev->print_name());
1297             break;
1298
1299          case BST_NOT_BLOCKED:
1300             Dmsg2(100, "Not blocked changer=%d slot=%d\n", dev->is_autochanger(), slot);
1301             if (dev->is_autochanger() && slot > 0) {
1302                try_autoload_device(jcr, dcr, slot, "");
1303             }
1304             if (dev->is_open()) {
1305                if (dev->is_labeled()) {
1306                   dir->fsend(_("3001 Device \"%s\" is mounted with Volume \"%s\"\n"),
1307                      dev->print_name(), dev->VolHdr.VolumeName);
1308                } else {
1309                   dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
1310                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
1311                              dev->print_name());
1312                }
1313             } else if (dev->is_tape()) {
1314                if (!dev->open_device(dcr, OPEN_READ_ONLY)) {
1315                   dir->fsend(_("3901 Unable to open device \"%s\": ERR=%s\n"),
1316                      dev->print_name(), dev->bstrerror());
1317                   break;
1318                }
1319                read_label(dcr);
1320                if (dev->is_labeled()) {
1321                   dir->fsend(_("3001 Device \"%s\" is already mounted with Volume \"%s\"\n"),
1322                      dev->print_name(), dev->VolHdr.VolumeName);
1323                } else {
1324                   dir->fsend(_("3905 Device \"%s\" open but no Bacula volume is mounted.\n"
1325                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
1326                              dev->print_name());
1327                }
1328                if (dev->is_open() && !dev->has_cap(CAP_ALWAYSOPEN)) {
1329                   dev->close(dcr);
1330                }
1331             } else if (dev->is_unmountable()) {
1332                if (dev->mount(1)) {
1333                   dir->fsend(_("3002 Device \"%s\" is mounted.\n"), dev->print_name());
1334                } else {
1335                   dir->fsend(_("3907 %s"), dev->bstrerror());
1336                }
1337             } else { /* must be file */
1338                dir->fsend(_("3906 File device \"%s\" is always mounted.\n"),
1339                   dev->print_name());
1340                pthread_cond_broadcast(&dev->wait_next_vol);
1341                Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)dcr->jcr->JobId);
1342                pthread_cond_broadcast(&wait_device_release);
1343             }
1344             break;
1345
1346          case BST_RELEASING:
1347             dir->fsend(_("3930 Device \"%s\" is being released.\n"), dev->print_name());
1348             break;
1349
1350          default:
1351             dir->fsend(_("3905 Unknown wait state %d\n"), dev->blocked());
1352             break;
1353          }
1354          dev->Unlock();
1355          free_dcr(dcr);
1356       } else {
1357          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1358       }
1359    } else {
1360       pm_strcpy(jcr->errmsg, dir->msg);
1361       dir->fsend(_("3909 Error scanning mount command: %s\n"), jcr->errmsg);
1362    }
1363    dir->signal(BNET_EOD);
1364    return true;
1365 }
1366
1367 /* enable command from Director */
1368 static bool enable_cmd(JCR *jcr)
1369 {
1370    POOL_MEM devname;
1371    BSOCK *dir = jcr->dir_bsock;
1372    DEVICE *dev;
1373    DCR *dcr;
1374    int32_t drive;
1375    bool ok;
1376    int deleted;
1377
1378    ok = sscanf(dir->msg, "enable %127s drive=%d", devname.c_str(),
1379                &drive) == 2;
1380    Dmsg3(100, "ok=%d device=%s device_index=%d\n", ok, devname.c_str(), drive);
1381    if (ok) {
1382       dcr = find_any_device(jcr, devname, NULL, drive);
1383       if (dcr) {
1384          dev = dcr->dev;
1385          dev->Lock();                 /* Use P to avoid indefinite block */
1386          if (dev->enabled) {
1387             dir->fsend(_("3003 Device \"%s\" already enabled.\n"), dev->print_name());
1388          } else {
1389             dev->enabled = true;
1390             dir->fsend(_("3002 Device \"%s\" enabled.\n"), dev->print_name());
1391          }
1392          deleted = dev->delete_alerts();
1393          if (deleted > 0) {
1394             dir->fsend(_("3004 Device \"%s\" deleted %d alert%s.\n"),
1395                 dev->print_name(), deleted, deleted>1?"s":"");
1396          }
1397          dev->Unlock();
1398          free_dcr(dcr);
1399       }
1400    } else {
1401       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
1402       pm_strcpy(jcr->errmsg, dir->msg);
1403       dir->fsend(_("3907 Error scanning \"enable\" command: %s\n"), jcr->errmsg);
1404    }
1405    dir->signal(BNET_EOD);
1406    return true;
1407 }
1408
1409 /* enable command from Director */
1410 static bool disable_cmd(JCR *jcr)
1411 {
1412    POOL_MEM devname;
1413    BSOCK *dir = jcr->dir_bsock;
1414    DEVICE *dev;
1415    DCR *dcr;
1416    int32_t drive;
1417    bool ok;
1418
1419    ok = sscanf(dir->msg, "disable %127s drive=%d", devname.c_str(),
1420                &drive) == 2;
1421    Dmsg3(100, "ok=%d device=%s device_index=%d\n", ok, devname.c_str(), drive);
1422    if (ok) {
1423       dcr = find_device(jcr, devname, NULL, drive);
1424       if (dcr) {
1425          dev = dcr->dev;
1426          dev->Lock();
1427          dev->enabled = false;
1428          dir->fsend(_("3002 Device \"%s\" disabled.\n"), dev->print_name());
1429          dev->Unlock();
1430          free_dcr(dcr);
1431       }
1432    } else {
1433       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
1434       pm_strcpy(jcr->errmsg, dir->msg);
1435       dir->fsend(_("3907 Error scanning \"disable\" command: %s\n"), jcr->errmsg);
1436    }
1437    dir->signal(BNET_EOD);
1438    return true;
1439 }
1440
1441
1442 /*
1443  * unmount command from Director
1444  */
1445 static bool unmount_cmd(JCR *jcr)
1446 {
1447    POOL_MEM devname;
1448    BSOCK *dir = jcr->dir_bsock;
1449    DEVICE *dev;
1450    DCR *dcr;
1451    int32_t drive;
1452
1453    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
1454       dcr = find_device(jcr, devname, NULL, drive);
1455       if (dcr) {
1456          dev = dcr->dev;
1457          dev->Lock();                 /* Use P to avoid indefinite block */
1458          if (!dev->is_open()) {
1459             if (!dev->is_busy()) {
1460                unload_autochanger(dcr, -1);
1461             }
1462             if (dev->is_unmountable()) {
1463                if (dev->unmount(0)) {
1464                   dir->fsend(_("3002 Device \"%s\" unmounted.\n"),
1465                      dev->print_name());
1466                } else {
1467                   dir->fsend(_("3907 %s"), dev->bstrerror());
1468                }
1469             } else {
1470                Dmsg0(90, "Device already unmounted\n");
1471                dir->fsend(_("3901 Device \"%s\" is already unmounted.\n"),
1472                   dev->print_name());
1473             }
1474          } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
1475             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
1476                dev->blocked());
1477             if (!unload_autochanger(dcr, -1)) {
1478                /*
1479                 * ***FIXME**** what is this ???? -- probably we had
1480                 *   the wrong volume so we must free it and try again. KES
1481                 */
1482                dev->close(dcr);
1483                free_volume(dev);
1484             }
1485             if (dev->is_unmountable() && !dev->unmount(0)) {
1486                dir->fsend(_("3907 %s"), dev->bstrerror());
1487             } else {
1488                dev->set_blocked(BST_UNMOUNTED_WAITING_FOR_SYSOP);
1489                dir->fsend(_("3001 Device \"%s\" unmounted.\n"),
1490                   dev->print_name());
1491             }
1492
1493          } else if (dev->blocked() == BST_DOING_ACQUIRE) {
1494             dir->fsend(_("3902 Device \"%s\" is busy in acquire.\n"),
1495                dev->print_name());
1496
1497          } else if (dev->blocked() == BST_WRITING_LABEL) {
1498             dir->fsend(_("3903 Device \"%s\" is being labeled.\n"),
1499                dev->print_name());
1500
1501          } else if (dev->is_busy()) {
1502             send_dir_busy_message(dir, dev);
1503          } else {                     /* device not being used */
1504             Dmsg0(90, "Device not in use, unmounting\n");
1505             /* On FreeBSD, I am having ASSERT() failures in block_device()
1506              * and I can only imagine that the thread id that we are
1507              * leaving in no_wait_id is being re-used. So here,
1508              * we simply do it by hand.  Gross, but a solution.
1509              */
1510             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
1511             dev->set_blocked(BST_UNMOUNTED);
1512             clear_thread_id(dev->no_wait_id);
1513             if (!unload_autochanger(dcr, -1)) {
1514                dev->close(dcr);
1515                free_volume(dev);
1516             }
1517             if (dev->is_unmountable() && !dev->unmount(0)) {
1518                dir->fsend(_("3907 %s"), dev->bstrerror());
1519             } else {
1520                dir->fsend(_("3002 Device \"%s\" unmounted.\n"),
1521                   dev->print_name());
1522             }
1523          }
1524          dev->Unlock();
1525          free_dcr(dcr);
1526       } else {
1527          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1528       }
1529    } else {
1530       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
1531       pm_strcpy(jcr->errmsg, dir->msg);
1532       dir->fsend(_("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
1533    }
1534    dir->signal(BNET_EOD);
1535    return true;
1536 }
1537
1538 #if 0
1539 /*
1540  * The truncate command will recycle a volume. The director can call this
1541  * after purging a volume so that disk space will not be wasted. Only useful
1542  * for File Storage, of course.
1543  *
1544  *
1545  * It is currently disabled
1546  */
1547 static bool action_on_purge_cmd(JCR *jcr)
1548 {
1549    BSOCK *dir = jcr->dir_bsock;
1550
1551    char devname[MAX_NAME_LENGTH];
1552    char volumename[MAX_NAME_LENGTH];
1553    int32_t action;
1554
1555    /* TODO: Need to find a free device and ask for slot to the director */
1556    if (sscanf(dir->msg,
1557               "action_on_purge %127s vol=%127s action=%d",
1558               devname, volumename, &action)!= 5)
1559    {
1560       dir->fsend(_("3916 Error scanning action_on_purge command\n"));
1561       goto done;
1562    }
1563    unbash_spaces(volumename);
1564    unbash_spaces(devname);
1565
1566    /* Check if action is correct */
1567    if (action & AOP_TRUNCTATE) {
1568
1569    }
1570    /* ... */
1571
1572 done:
1573    dir->signal(BNET_EOD);
1574    return true;
1575 }
1576 #endif
1577
1578 /*
1579  * Release command from Director. This rewinds the device and if
1580  *   configured does a offline and ensures that Bacula will
1581  *   re-read the label of the tape before continuing. This gives
1582  *   the operator the chance to change the tape anytime before the
1583  *   next job starts.
1584  */
1585 static bool release_cmd(JCR *jcr)
1586 {
1587    POOL_MEM devname;
1588    BSOCK *dir = jcr->dir_bsock;
1589    DEVICE *dev;
1590    DCR *dcr;
1591    int32_t drive;
1592
1593    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
1594       dcr = find_device(jcr, devname, NULL, drive);
1595       if (dcr) {
1596          dev = dcr->dev;
1597          dev->Lock();                 /* Use P to avoid indefinite block */
1598          if (!dev->is_open()) {
1599             if (!dev->is_busy()) {
1600                unload_autochanger(dcr, -1);
1601             }
1602             Dmsg0(90, "Device already released\n");
1603             dir->fsend(_("3921 Device \"%s\" already released.\n"),
1604                dev->print_name());
1605
1606          } else if (dev->blocked() == BST_WAITING_FOR_SYSOP) {
1607             Dmsg2(90, "%d waiter dev_block=%d.\n", dev->num_waiting,
1608                dev->blocked());
1609             unload_autochanger(dcr, -1);
1610             dir->fsend(_("3922 Device \"%s\" waiting for sysop.\n"),
1611                dev->print_name());
1612
1613          } else if (dev->blocked() == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
1614             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
1615                dev->blocked());
1616             dir->fsend(_("3922 Device \"%s\" waiting for mount.\n"),
1617                dev->print_name());
1618
1619          } else if (dev->blocked() == BST_DOING_ACQUIRE) {
1620             dir->fsend(_("3923 Device \"%s\" is busy in acquire.\n"),
1621                dev->print_name());
1622
1623          } else if (dev->blocked() == BST_WRITING_LABEL) {
1624             dir->fsend(_("3914 Device \"%s\" is being labeled.\n"),
1625                dev->print_name());
1626
1627          } else if (dev->is_busy()) {
1628             send_dir_busy_message(dir, dev);
1629          } else {                     /* device not being used */
1630             Dmsg0(90, "Device not in use, releasing\n");
1631             dcr->release_volume();
1632             dir->fsend(_("3022 Device \"%s\" released.\n"),
1633                dev->print_name());
1634          }
1635          dev->Unlock();
1636          free_dcr(dcr);
1637       } else {
1638          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1639       }
1640    } else {
1641       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
1642       pm_strcpy(jcr->errmsg, dir->msg);
1643       dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
1644    }
1645    dir->signal(BNET_EOD);
1646    return true;
1647 }
1648
1649 static pthread_mutex_t bsr_mutex = PTHREAD_MUTEX_INITIALIZER;
1650 static uint32_t bsr_uniq = 0;
1651
1652 static bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
1653 {
1654    POOLMEM *fname = get_pool_memory(PM_FNAME);
1655    FILE *bs;
1656    bool ok = false;
1657
1658    if (jcr->RestoreBootstrap) {
1659       unlink(jcr->RestoreBootstrap);
1660       free_pool_memory(jcr->RestoreBootstrap);
1661    }
1662    P(bsr_mutex);
1663    bsr_uniq++;
1664    Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
1665       jcr->Job, bsr_uniq);
1666    V(bsr_mutex);
1667    Dmsg1(400, "bootstrap=%s\n", fname);
1668    jcr->RestoreBootstrap = fname;
1669    bs = bfopen(fname, "a+b");           /* create file */
1670    if (!bs) {
1671       berrno be;
1672       Jmsg(jcr, M_FATAL, 0, _("[SF0110] Could not create bootstrap file %s: ERR=%s\n"),
1673          jcr->RestoreBootstrap, be.bstrerror());
1674       goto bail_out;
1675    }
1676    Dmsg0(150, "=== Bootstrap file ===\n");
1677    while (sock->recv() >= 0) {
1678        Dmsg1(150, "%s", sock->msg);
1679        fputs(sock->msg, bs);
1680    }
1681    fclose(bs);
1682    Dmsg0(150, "=== end bootstrap file ===\n");
1683    jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
1684    if (!jcr->bsr) {
1685       Jmsg(jcr, M_FATAL, 0, _("[SF0111] Error parsing bootstrap file.\n"));
1686       goto bail_out;
1687    }
1688    if (chk_dbglvl(150)) {
1689       dump_bsr(NULL, jcr->bsr, true);
1690    }
1691
1692    /* If we got a bootstrap, we are reading, so create read volume list */
1693    create_restore_volume_list(jcr, true /* store the volumes in the global vol_read list */);
1694    ok = true;
1695
1696 bail_out:
1697    unlink(jcr->RestoreBootstrap);
1698    free_pool_memory(jcr->RestoreBootstrap);
1699    jcr->RestoreBootstrap = NULL;
1700    if (!ok) {
1701       sock->fsend(ERROR_bootstrap);
1702       return false;
1703    }
1704    return sock->fsend(OK_bootstrap);
1705 }
1706
1707 static bool bootstrap_cmd(JCR *jcr)
1708 {
1709    return get_bootstrap_file(jcr, jcr->dir_bsock);
1710 }
1711
1712 /*
1713  * Autochanger command from Director
1714  */
1715 static bool changer_cmd(JCR *jcr)
1716 {
1717    POOL_MEM devname;
1718    BSOCK *dir = jcr->dir_bsock;
1719    DEVICE *dev;
1720    DCR *dcr;
1721    const char *cmd = NULL;
1722    bool ok = false;
1723    /*
1724     * A safe_cmd may call autochanger script but does not load/unload
1725     *    slots so it can be done at the same time that the drive is open.
1726     */
1727    bool safe_cmd = false;
1728
1729    if (sscanf(dir->msg, "autochanger listall %127s", devname.c_str()) == 1) {
1730       cmd = "listall";
1731       safe_cmd = ok = true;
1732    } else if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
1733       cmd = "list";
1734       safe_cmd = ok = true;
1735    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
1736       cmd = "slots";
1737       safe_cmd = ok = true;
1738    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
1739       cmd = "drives";
1740       safe_cmd = ok = true;
1741    }
1742    if (ok) {
1743       dcr = find_device(jcr, devname, NULL, -1);
1744       if (dcr) {
1745          dev = dcr->dev;
1746          dev->Lock();                 /* Use P to avoid indefinite block */
1747          if (!dev->device->changer_res) {
1748             dir->fsend(_("3998 Device \"%s\" is not an autochanger.\n"),
1749                dev->print_name());
1750          /* Under certain "safe" conditions, we can steal the lock */
1751          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
1752             autochanger_cmd(dcr, dir, cmd);
1753          } else if (dev->is_busy() || dev->is_blocked()) {
1754             send_dir_busy_message(dir, dev);
1755          } else {                     /* device not being used */
1756             autochanger_cmd(dcr, dir, cmd);
1757          }
1758          dev->Unlock();
1759          free_dcr(dcr);
1760       } else {
1761          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1762       }
1763    } else {  /* error on scanf */
1764       pm_strcpy(jcr->errmsg, dir->msg);
1765       dir->fsend(_("3909 Error scanning autochanger drives/list/slots command: %s\n"),
1766          jcr->errmsg);
1767    }
1768    dir->signal(BNET_EOD);
1769    return true;
1770 }
1771
1772 /*
1773  * Read and return the Volume label
1774  */
1775 static bool readlabel_cmd(JCR *jcr)
1776 {
1777    POOL_MEM devname;
1778    BSOCK *dir = jcr->dir_bsock;
1779    DEVICE *dev;
1780    DCR *dcr;
1781    int32_t Slot, drive;
1782
1783    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1784        &Slot, &drive) == 3) {
1785       dcr = find_device(jcr, devname, NULL, drive);
1786       if (dcr) {
1787          dev = dcr->dev;
1788          dev->Lock();                 /* Use P to avoid indefinite block */
1789          if (!dev->is_open()) {
1790             read_volume_label(jcr, dcr, dev, Slot);
1791             dev->close(dcr);
1792          /* Under certain "safe" conditions, we can steal the lock */
1793          } else if (dev->can_steal_lock()) {
1794             read_volume_label(jcr, dcr, dev, Slot);
1795          } else if (dev->is_busy() || dev->is_blocked()) {
1796             send_dir_busy_message(dir, dev);
1797          } else {                     /* device not being used */
1798             read_volume_label(jcr, dcr, dev, Slot);
1799          }
1800          dev->Unlock();
1801          free_dcr(dcr);
1802       } else {
1803          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1804       }
1805    } else {
1806       pm_strcpy(jcr->errmsg, dir->msg);
1807       dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1808    }
1809    dir->signal(BNET_EOD);
1810    return true;
1811 }
1812
1813
1814 /*
1815  * Read the tape label
1816  *
1817  *  Enter with the mutex set
1818  */
1819 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1820 {
1821    BSOCK *dir = jcr->dir_bsock;
1822    bsteal_lock_t hold;
1823
1824    dcr->set_dev(dev);
1825    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1826
1827    if (!try_autoload_device(jcr, dcr, Slot, "")) {
1828       goto bail_out;                  /* error */
1829    }
1830
1831    dev->clear_labeled();              /* force read of label */
1832    switch (dev->read_dev_volume_label(dcr)) {
1833    case VOL_OK:
1834       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1835       dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1836       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1837       break;
1838    default:
1839       dir->fsend(_("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s"),
1840                  dev->print_name(), jcr->errmsg);
1841       break;
1842    }
1843
1844 bail_out:
1845    give_back_device_lock(dev, &hold);
1846    return;
1847 }
1848
1849 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1850 {
1851    BSOCK *dir = jcr->dir_bsock;
1852
1853    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1854    dcr->VolCatInfo.Slot = slot;
1855    dcr->VolCatInfo.InChanger = slot > 0;
1856    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1857       return false;
1858    }
1859    return true;
1860 }
1861
1862 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1863 {
1864    if (dev->is_blocked()) {
1865       switch (dev->blocked()) {
1866       case BST_UNMOUNTED:
1867          dir->fsend(_("3931 Device \"%s\" is BLOCKED. user unmounted.\n"),
1868             dev->print_name());
1869          break;
1870       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1871          dir->fsend(_("3932 Device \"%s\" is BLOCKED. user unmounted during wait for media/mount.\n"),
1872              dev->print_name());
1873          break;
1874       case BST_WAITING_FOR_SYSOP:
1875          dir->fsend(_("3933 Device \"%s\" is BLOCKED waiting for media.\n"),
1876             dev->print_name());
1877          break;
1878       case BST_DOING_ACQUIRE:
1879          dir->fsend(_("3934 Device \"%s\" is being initialized.\n"),
1880             dev->print_name());
1881          break;
1882       case BST_WRITING_LABEL:
1883          dir->fsend(_("3935 Device \"%s\" is blocked labeling a Volume.\n"),
1884             dev->print_name());
1885          break;
1886       default:
1887          dir->fsend(_("3935 Device \"%s\" is blocked for unknown reason.\n"),
1888             dev->print_name());
1889          break;
1890       }
1891    } else if (dev->can_read()) {
1892        dir->fsend(_("3936 Device \"%s\" is busy reading.\n"),
1893                    dev->print_name());;
1894    } else {
1895        dir->fsend(_("3937 Device \"%s\" is busy with writers=%d reserved=%d.\n"),
1896           dev->print_name(), dev->num_writers, dev->num_reserved());
1897    }
1898 }