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

   1 /*
   2  *  This file handles accepting Director Commands
   3  *
   4  *    Most Director commands are handled here, with the
   5  *    exception of the Job command command and subsequent
   6  *    subcommands that are handled
   7  *    in job.c.
   8  *
   9  *    N.B. in this file, in general we must use P(dev->mutex) rather
  10  *      than lock_device(dev) so that we can examine the blocked
  11  *      state rather than blocking ourselves because a Job
  12  *      thread has the device blocked. In some "safe" cases,
  13  *      we can do things to a blocked device. CAREFUL!!!!
  14  *
  15  *    File daemon commands are handled in fdcmd.c
  16  *
  17  *     Kern Sibbald, May MMI
  18  *
  19  *   Version $Id$
  20  *
  21  */
  22 /*
  23    Copyright (C) 2001-2006 Kern Sibbald
  24
  25    This program is free software; you can redistribute it and/or
  26    modify it under the terms of the GNU General Public License
  27    version 2 as amended with additional clauses defined in the
  28    file LICENSE in the main source directory.
  29
  30    This program is distributed in the hope that it will be useful,
  31    but WITHOUT ANY WARRANTY; without even the implied warranty of
  32    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  33    the file LICENSE for additional details.
  34
  35  */
  36
  37 #include "bacula.h"
  38 #include "stored.h"
  39
  40 /* Exported variables */
  41
  42 /* Imported variables */
  43 extern BSOCK *filed_chan;
  44 extern int r_first, r_last;
  45 extern struct s_res resources[];
  46 extern struct s_last_job last_job;
  47 extern bool init_done;
  48
  49 /* Static variables */
  50 static char derrmsg[]     = "3900 Invalid command\n";
  51 static char OKsetdebug[]  = "3000 OK setdebug=%d\n";
  52 static char illegal_cmd[] = "3997 Illegal command for a Director with Monitor directive enabled\n";
  53
  54 /* Imported functions */
  55 extern void terminate_child();
  56 extern bool job_cmd(JCR *jcr);
  57 extern bool use_cmd(JCR *jcr);
  58 extern bool run_cmd(JCR *jcr);
  59 extern bool status_cmd(JCR *sjcr);
  60 extern bool qstatus_cmd(JCR *jcr);
  61 //extern bool query_cmd(JCR *jcr);
  62
  63 /* Forward referenced functions */
  64 static bool label_cmd(JCR *jcr);
  65 static bool relabel_cmd(JCR *jcr);
  66 static bool readlabel_cmd(JCR *jcr);
  67 static bool release_cmd(JCR *jcr);
  68 static bool setdebug_cmd(JCR *jcr);
  69 static bool cancel_cmd(JCR *cjcr);
  70 static bool mount_cmd(JCR *jcr);
  71 static bool unmount_cmd(JCR *jcr);
  72 static bool bootstrap_cmd(JCR *jcr);
  73 static bool changer_cmd(JCR *sjcr);
  74 static bool do_label(JCR *jcr, int relabel);
  75 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
  76 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot);
  77 static void label_volume_if_ok(DCR *dcr, char *oldname,
  78                                char *newname, char *poolname,
  79                                int Slot, int relabel);
  80 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName);
  81 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
  82
  83 struct s_cmds {
  84    const char *cmd;
  85    bool (*func)(JCR *jcr);
  86    int monitoraccess; /* specify if monitors have access to this function */
  87 };
  88
  89 /*
  90  * The following are the recognized commands from the Director.
  91  */
  92 static struct s_cmds cmds[] = {
  93    {"JobId=",      job_cmd,         0},     /* start Job */
  94    {"autochanger", changer_cmd,     0},
  95    {"bootstrap",   bootstrap_cmd,   0},
  96    {"cancel",      cancel_cmd,      0},
  97    {"label",       label_cmd,       0},     /* label a tape */
  98    {"mount",       mount_cmd,       0},
  99    {"readlabel",   readlabel_cmd,   0},
 100    {"release",     release_cmd,     0},
 101    {"relabel",     relabel_cmd,     0},     /* relabel a tape */
 102    {"setdebug=",   setdebug_cmd,    0},     /* set debug level */
 103    {"status",      status_cmd,      1},
 104    {".status",     qstatus_cmd,     1},
 105    {"unmount",     unmount_cmd,     0},
 106    {"use storage=", use_cmd,        0},
 107    {"run",         run_cmd,         0},
 108 // {"query",       query_cmd,       0},
 109    {NULL,        NULL}                      /* list terminator */
 110 };
 111
 112
 113 /*
 114  * Connection request. We accept connections either from the
 115  *  Director or a Client (File daemon).
 116  *
 117  * Note, we are running as a seperate thread of the Storage daemon.
 118  *  and it is because a Director has made a connection with
 119  *  us on the "Message" channel.
 120  *
 121  * Basic tasks done here:
 122  *  - Create a JCR record
 123  *  - If it was from the FD, call handle_filed_connection()
 124  *  - Authenticate the Director
 125  *  - We wait for a command
 126  *  - We execute the command
 127  *  - We continue or exit depending on the return status
 128  */
 129 void *handle_connection_request(void *arg)
 130 {
 131    BSOCK *bs = (BSOCK *)arg;
 132    JCR *jcr;
 133    int i;
 134    bool found, quit;
 135    int bnet_stat = 0;
 136    char name[MAX_NAME_LENGTH];
 137
 138    if (bnet_recv(bs) <= 0) {
 139       Emsg0(M_ERROR, 0, _("Connection request failed.\n"));
 140       bnet_close(bs);
 141       return NULL;
 142    }
 143
 144    /*
 145     * Do a sanity check on the message received
 146     */
 147    if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)-25) {
 148       Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen);
 149       bnet_close(bs);
 150       return NULL;
 151    }
 152    /*
 153     * See if this is a File daemon connection. If so
 154     *   call FD handler.
 155     */
 156    Dmsg1(110, "Conn: %s", bs->msg);
 157    if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
 158       handle_filed_connection(bs, name);
 159       return NULL;
 160    }
 161
 162    /*
 163     * This is a connection from the Director, so setup a JCR
 164     */
 165    Dmsg0(110, "Start Dir Job\n");
 166    jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
 167    jcr->dir_bsock = bs;               /* save Director bsock */
 168    jcr->dir_bsock->jcr = jcr;
 169    jcr->dcrs = New(alist(10, not_owned_by_alist));
 170    /* Initialize FD start condition variable */
 171    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 172    if (errstat != 0) {
 173       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat));
 174       goto bail_out;
 175    }
 176
 177    Dmsg0(1000, "stored in start_job\n");
 178
 179    /*
 180     * Authenticate the Director
 181     */
 182    if (!authenticate_director(jcr)) {
 183       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
 184       goto bail_out;
 185    }
 186    Dmsg0(90, "Message channel init completed.\n");
 187
 188    for (quit=false; !quit;) {
 189       /* Read command */
 190       if ((bnet_stat = bnet_recv(bs)) <= 0) {
 191          break;               /* connection terminated */
 192       }
 193       Dmsg1(199, "<dird: %s\n", bs->msg);
 194       /* Ensure that device initialization is complete */
 195       while (!init_done) {
 196          bmicrosleep(1, 0);
 197       }
 198       found = false;
 199       for (i=0; cmds[i].cmd; i++) {
 200         if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 201            if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
 202               Dmsg1(100, "Command %s illegal.\n", cmds[i].cmd);
 203               bnet_fsend(bs, illegal_cmd);
 204               bnet_sig(bs, BNET_EOD);
 205               break;
 206            }
 207            Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
 208            if (!cmds[i].func(jcr)) { /* do command */
 209               quit = true; /* error, get out */
 210               Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
 211            }
 212            found = true;             /* indicate command found */
 213            break;
 214         }
 215       }
 216       if (!found) {                   /* command not found */
 217         bnet_fsend(bs, derrmsg);
 218         break;
 219       }
 220    }
 221 bail_out:
 222    generate_daemon_event(jcr, "JobEnd");
 223    dequeue_messages(jcr);             /* send any queued messages */
 224    bnet_sig(bs, BNET_TERMINATE);
 225    free_jcr(jcr);
 226    return NULL;
 227 }
 228
 229 /*
 230  * Set debug level as requested by the Director
 231  *
 232  */
 233 static bool setdebug_cmd(JCR *jcr)
 234 {
 235    BSOCK *dir = jcr->dir_bsock;
 236    int level, trace_flag;
 237
 238    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 239    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
 240       bnet_fsend(dir, _("3991 Bad setdebug command: %s\n"), dir->msg);
 241       return 0;
 242    }
 243    debug_level = level;
 244    set_trace(trace_flag);
 245    return bnet_fsend(dir, OKsetdebug, level);
 246 }
 247
 248
 249 /*
 250  * Cancel a Job
 251  */
 252 static bool cancel_cmd(JCR *cjcr)
 253 {
 254    BSOCK *dir = cjcr->dir_bsock;
 255    int oldStatus;
 256    char Job[MAX_NAME_LENGTH];
 257    JCR *jcr;
 258
 259    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 260       if (!(jcr=get_jcr_by_full_name(Job))) {
 261          bnet_fsend(dir, _("3904 Job %s not found.\n"), Job);
 262       } else {
 263          jcr->lock();
 264          oldStatus = jcr->JobStatus;
 265          set_jcr_job_status(jcr, JS_Canceled);
 266          if (!jcr->authenticated && oldStatus == JS_WaitFD) {
 267             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 268          }
 269          jcr->unlock();
 270          if (jcr->file_bsock) {
 271             bnet_sig(jcr->file_bsock, BNET_TERMINATE);
 272          }
 273          /* If thread waiting on mount, wake him */
 274          if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
 275             pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 276             pthread_cond_broadcast(&wait_device_release);
 277          }
 278          if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
 279             pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 280             pthread_cond_broadcast(&wait_device_release);
 281          }
 282          bnet_fsend(dir, _("3000 Job %s marked to be canceled.\n"), jcr->Job);
 283          free_jcr(jcr);
 284       }
 285    } else {
 286       bnet_fsend(dir, _("3903 Error scanning cancel command.\n"));
 287    }
 288    bnet_sig(dir, BNET_EOD);
 289    return 1;
 290 }
 291
 292 /*
 293  * Label a Volume
 294  *
 295  */
 296 static bool label_cmd(JCR *jcr)
 297 {
 298    return do_label(jcr, 0);
 299 }
 300
 301 static bool relabel_cmd(JCR *jcr)
 302 {
 303    return do_label(jcr, 1);
 304 }
 305
 306 static bool do_label(JCR *jcr, int relabel)
 307 {
 308    POOLMEM *newname, *oldname, *poolname, *mtype;
 309    POOL_MEM dev_name;
 310    BSOCK *dir = jcr->dir_bsock;
 311    DCR *dcr;
 312    DEVICE *dev;
 313    bool ok = false;
 314    int slot;
 315    int drive;
 316
 317    newname = get_memory(dir->msglen+1);
 318    oldname = get_memory(dir->msglen+1);
 319    poolname = get_memory(dir->msglen+1);
 320    mtype = get_memory(dir->msglen+1);
 321    if (relabel) {
 322       if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
 323                  "MediaType=%127s Slot=%d drive=%d",
 324                   dev_name.c_str(), oldname, newname, poolname, mtype,
 325                   &slot, &drive) == 7) {
 326          ok = true;
 327       }
 328    } else {
 329       *oldname = 0;
 330       if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
 331                  "MediaType=%127s Slot=%d drive=%d",
 332           dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
 333          ok = true;
 334       }
 335    }
 336    if (ok) {
 337       unbash_spaces(newname);
 338       unbash_spaces(oldname);
 339       unbash_spaces(poolname);
 340       unbash_spaces(mtype);
 341       dcr = find_device(jcr, dev_name, drive);
 342       if (dcr) {
 343          dev = dcr->dev;
 344          P(dev->mutex);               /* Use P to avoid indefinite block */
 345          if (!dev->is_open()) {
 346             Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
 347             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 348             dev->close();
 349          /* Under certain "safe" conditions, we can steal the lock */
 350          } else if (dev->can_steal_lock()) {
 351             Dmsg0(400, "Can relabel. can_steal_lock\n");
 352             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 353          } else if (dev->is_busy() || dev->is_blocked()) {
 354             send_dir_busy_message(dir, dev);
 355          } else {                     /* device not being used */
 356             Dmsg0(400, "Can relabel. device not used\n");
 357             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 358          }
 359          V(dev->mutex);
 360          free_dcr(dcr);
 361          jcr->dcr = NULL;
 362       } else {
 363          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 364       }
 365    } else {
 366       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 367       pm_strcpy(jcr->errmsg, dir->msg);
 368       bnet_fsend(dir, _("3903 Error scanning label command: %s\n"), jcr->errmsg);
 369    }
 370    free_memory(oldname);
 371    free_memory(newname);
 372    free_memory(poolname);
 373    free_memory(mtype);
 374    bnet_sig(dir, BNET_EOD);
 375    return true;
 376 }
 377
 378 /*
 379  * Read the tape label and determine if we can safely
 380  * label the tape (not a Bacula volume), then label it.
 381  *
 382  *  Enter with the mutex set
 383  */
 384 static void label_volume_if_ok(DCR *dcr, char *oldname,
 385                                char *newname, char *poolname,
 386                                int slot, int relabel)
 387 {
 388    BSOCK *dir = dcr->jcr->dir_bsock;
 389    bsteal_lock_t hold;
 390    DEVICE *dev = dcr->dev;
 391    int label_status;
 392    int mode;
 393    const char *volname = (relabel == 0) ? newname : oldname;
 394
 395    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 396    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
 397
 398    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 399    if (relabel && dev->is_dvd()) {
 400       dcr->VolCatInfo.VolCatParts=1;
 401    }
 402
 403    if (!try_autoload_device(dcr->jcr, slot, volname)) {
 404       goto bail_out;                  /* error */
 405    }
 406
 407    /* Ensure that the device is open -- autoload_device() closes it */
 408    if (dev->is_tape()) {
 409       mode = OPEN_READ_WRITE;
 410    } else {
 411       mode = CREATE_READ_WRITE;
 412    }
 413    if (dev->is_dvd()) {
 414       bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
 415    }
 416
 417    if (dev->open(dcr, mode) < 0) {
 418       bnet_fsend(dir, _("3910 Unable to open device %s: ERR=%s\n"),
 419          dev->print_name(), dev->strerror());
 420       goto bail_out;
 421    }
 422
 423    /* See what we have for a Volume */
 424    label_status = read_dev_volume_label(dcr);
 425
 426    switch(label_status) {
 427    case VOL_NAME_ERROR:
 428    case VOL_VERSION_ERROR:
 429    case VOL_LABEL_ERROR:
 430    case VOL_OK:
 431       if (!relabel) {
 432          bnet_fsend(dir, _(
 433             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
 434              dev->VolHdr.VolumeName);
 435          break;
 436       }
 437
 438       /* Relabel request. If oldname matches, continue */
 439       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
 440          bnet_fsend(dir, _("3921 Wrong volume mounted.\n"));
 441          break;
 442       }
 443       if (dev->label_type != B_BACULA_LABEL) {
 444          bnet_fsend(dir, _("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
 445          break;
 446       }
 447       if (relabel && dev->is_dvd()) {
 448          /* Change the partition file name */
 449          bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 450          if (!dev->truncate(dcr)) {
 451             bnet_fsend(dir, _("3912 Failed to truncate previous DVD volume.\n"));
 452             break;
 453          }
 454       }
 455       free_volume(dev);               /* release old volume name */
 456       /* Fall through wanted! */
 457    case VOL_IO_ERROR:
 458    case VOL_NO_LABEL:
 459       if (!write_new_volume_label_to_dev(dcr, newname, poolname, true /* write dvd now */)) {
 460          bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 461          break;
 462       }
 463       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 464       /* The following 3000 OK label. string is scanned in ua_label.c */
 465       bnet_fsend(dir, "3000 OK label. DVD=%d Volume=\"%s\" Device=\"%s\"\n",
 466          dev->is_dvd()?1:0, newname, dev->print_name());
 467       break;
 468    case VOL_NO_MEDIA:
 469       bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 470       break;
 471    default:
 472       bnet_fsend(dir, _("3913 Cannot label Volume. "
 473 "Unknown status %d from read_volume_label()\n"), label_status);
 474       break;
 475    }
 476
 477 bail_out:
 478    if (!dev->is_open()) {
 479       free_volume(dev);
 480    }
 481    give_back_device_lock(dev, &hold);
 482    return;
 483 }
 484
 485
 486 /*
 487  * Read the tape label
 488  *
 489  *  Enter with the mutex set
 490  */
 491 static bool read_label(DCR *dcr)
 492 {
 493    int ok;
 494    JCR *jcr = dcr->jcr;
 495    BSOCK *dir = jcr->dir_bsock;
 496    bsteal_lock_t hold;
 497    DEVICE *dev = dcr->dev;
 498
 499    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 500
 501    dcr->VolumeName[0] = 0;
 502    dev->clear_labeled();              /* force read of label */
 503    switch (read_dev_volume_label(dcr)) {
 504    case VOL_OK:
 505       bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
 506       ok = true;
 507       break;
 508    default:
 509       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
 510          dev->print_name(), jcr->errmsg);
 511       ok = false;
 512       break;
 513    }
 514    give_back_device_lock(dev, &hold);
 515    return ok;
 516 }
 517
 518 /*
 519  * Searches for device by name, and if found, creates a dcr and
 520  *  returns it.
 521  */
 522 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
 523 {
 524    DEVRES *device;
 525    AUTOCHANGER *changer;
 526    bool found = false;
 527    DCR *dcr = NULL;
 528
 529    unbash_spaces(devname);
 530    foreach_res(device, R_DEVICE) {
 531       /* Find resource, and make sure we were able to open it */
 532       if (fnmatch(device->hdr.name, devname.c_str(), 0) == 0) {
 533          if (!device->dev) {
 534             device->dev = init_dev(jcr, device);
 535          }
 536          if (!device->dev) {
 537             Jmsg(jcr, M_WARNING, 0, _("\n"
 538                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 539                  devname.c_str());
 540             continue;
 541          }
 542          Dmsg1(20, "Found device %s\n", device->hdr.name);
 543          found = true;
 544          break;
 545       }
 546    }
 547    if (!found) {
 548       foreach_res(changer, R_AUTOCHANGER) {
 549          /* Find resource, and make sure we were able to open it */
 550          if (fnmatch(devname.c_str(), changer->hdr.name, 0) == 0) {
 551             /* Try each device in this AutoChanger */
 552             foreach_alist(device, changer->device) {
 553                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
 554                if (!device->dev) {
 555                   device->dev = init_dev(jcr, device);
 556                }
 557                if (!device->dev) {
 558                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
 559                   Jmsg(jcr, M_WARNING, 0, _("\n"
 560                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 561                        device->hdr.name, devname.c_str());
 562                   continue;
 563                }
 564                if (!device->dev->autoselect) {
 565                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
 566                   continue;              /* device is not available */
 567                }
 568                if (drive < 0 || drive == (int)device->dev->drive_index) {
 569                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
 570                   found = true;
 571                   break;
 572                }
 573                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
 574                   devname.c_str(), drive, (int)device->dev->drive_index);
 575             }
 576             break;                    /* we found it but could not open a device */
 577          }
 578       }
 579    }
 580
 581    if (found) {
 582       Dmsg1(100, "Found device %s\n", device->hdr.name);
 583       dcr = new_dcr(jcr, device->dev);
 584       dcr->device = device;
 585       jcr->dcr = dcr;
 586    }
 587    return dcr;
 588 }
 589
 590
 591 /*
 592  * Mount command from Director
 593  */
 594 static bool mount_cmd(JCR *jcr)
 595 {
 596    POOL_MEM devname;
 597    BSOCK *dir = jcr->dir_bsock;
 598    DEVICE *dev;
 599    DCR *dcr;
 600    int drive;
 601    int slot = 0;
 602    bool ok;
 603
 604    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
 605                &drive, &slot) == 3;
 606    if (!ok) {
 607       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
 608    }
 609    if (ok) {
 610       dcr = find_device(jcr, devname, drive);
 611       if (dcr) {
 612          dev = dcr->dev;
 613          P(dev->mutex);               /* Use P to avoid indefinite block */
 614          Dmsg1(100, "mount cmd blocked=%d\n", dev->dev_blocked);
 615          switch (dev->dev_blocked) {         /* device blocked? */
 616          case BST_WAITING_FOR_SYSOP:
 617             /* Someone is waiting, wake him */
 618             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
 619             dev->dev_blocked = BST_MOUNT;
 620             bnet_fsend(dir, "3001 OK mount. Device=%s\n",
 621                dev->print_name());
 622             pthread_cond_broadcast(&dev->wait_next_vol);
 623             pthread_cond_broadcast(&wait_device_release);
 624             break;
 625
 626          /* In both of these two cases, we (the user) unmounted the Volume */
 627          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 628          case BST_UNMOUNTED:
 629             if (dev->is_autochanger() && slot > 0) {
 630                try_autoload_device(jcr, slot, "");
 631             }
 632             /* We freed the device, so reopen it and wake any waiting threads */
 633             if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 634                bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 635                   dev->bstrerror());
 636                if (dev->dev_blocked == BST_UNMOUNTED) {
 637                   /* We blocked the device, so unblock it */
 638                   Dmsg0(100, "Unmounted. Unblocking device\n");
 639                   unblock_device(dev);
 640                }
 641                break;
 642             }
 643             read_dev_volume_label(dcr);
 644             if (dev->dev_blocked == BST_UNMOUNTED) {
 645                /* We blocked the device, so unblock it */
 646                Dmsg0(100, "Unmounted. Unblocking device\n");
 647                read_label(dcr);       /* this should not be necessary */
 648                unblock_device(dev);
 649             } else {
 650                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
 651                dev->dev_blocked = BST_MOUNT;
 652             }
 653             if (dev->is_labeled()) {
 654                bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
 655                   dev->print_name(), dev->VolHdr.VolumeName);
 656             } else {
 657                bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 658                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 659                           dev->print_name());
 660             }
 661             pthread_cond_broadcast(&dev->wait_next_vol);
 662             pthread_cond_broadcast(&wait_device_release);
 663             break;
 664
 665          case BST_DOING_ACQUIRE:
 666             bnet_fsend(dir, _("3001 Device %s is doing acquire.\n"),
 667                        dev->print_name());
 668             break;
 669
 670          case BST_WRITING_LABEL:
 671             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 672                dev->print_name());
 673             break;
 674
 675          case BST_NOT_BLOCKED:
 676             if (dev->is_autochanger() && slot > 0) {
 677                try_autoload_device(jcr, slot, "");
 678             }
 679             if (dev->is_open()) {
 680                if (dev->is_labeled()) {
 681                   bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
 682                      dev->print_name(), dev->VolHdr.VolumeName);
 683                } else {
 684                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 685                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 686                              dev->print_name());
 687                }
 688             } else if (dev->is_tape()) {
 689                if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 690                   bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 691                      dev->bstrerror());
 692                   break;
 693                }
 694                read_label(dcr);
 695                if (dev->is_labeled()) {
 696                   bnet_fsend(dir, _("3001 Device %s is already mounted with Volume \"%s\"\n"),
 697                      dev->print_name(), dev->VolHdr.VolumeName);
 698                } else {
 699                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 700                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 701                              dev->print_name());
 702                }
 703             } else if (dev->is_dvd()) {
 704                if (mount_dvd(dev, 1)) {
 705                   bnet_fsend(dir, _("3002 Device %s is mounted.\n"),
 706                      dev->print_name());
 707                } else {
 708                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 709                }
 710             } else { /* must be file */
 711                bnet_fsend(dir, _("3906 File device %s is always mounted.\n"),
 712                   dev->print_name());
 713             }
 714             break;
 715
 716          default:
 717             bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
 718             break;
 719          }
 720          V(dev->mutex);
 721          free_dcr(dcr);
 722          jcr->dcr = NULL;
 723       } else {
 724          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 725       }
 726    } else {
 727       pm_strcpy(jcr->errmsg, dir->msg);
 728       bnet_fsend(dir, _("3909 Error scanning mount command: %s\n"), jcr->errmsg);
 729    }
 730    bnet_sig(dir, BNET_EOD);
 731    return true;
 732 }
 733
 734 /*
 735  * unmount command from Director
 736  */
 737 static bool unmount_cmd(JCR *jcr)
 738 {
 739    POOL_MEM devname;
 740    BSOCK *dir = jcr->dir_bsock;
 741    DEVICE *dev;
 742    DCR *dcr;
 743    int drive;
 744
 745    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
 746       dcr = find_device(jcr, devname, drive);
 747       if (dcr) {
 748          dev = dcr->dev;
 749          P(dev->mutex);               /* Use P to avoid indefinite block */
 750          if (!dev->is_open()) {
 751             if (!dev->is_busy()) {
 752                unload_autochanger(jcr->dcr, -1);
 753             }
 754             if (dev->is_dvd()) {
 755                if (unmount_dvd(dev, 0)) {
 756                   bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
 757                      dev->print_name());
 758                } else {
 759                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 760                }
 761             } else {
 762                Dmsg0(90, "Device already unmounted\n");
 763                bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"),
 764                   dev->print_name());
 765             }
 766          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
 767             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 768                dev->dev_blocked);
 769             if (!unload_autochanger(jcr->dcr, -1)) {
 770                dev->close();
 771             }
 772             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
 773                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 774             } else {
 775                dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
 776                bnet_fsend(dir, _("3001 Device %s unmounted.\n"),
 777                   dev->print_name());
 778             }
 779
 780          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 781             bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"),
 782                dev->print_name());
 783
 784          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 785             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 786                dev->print_name());
 787
 788          } else if (dev->is_busy()) {
 789             send_dir_busy_message(dir, dev);
 790          } else {                     /* device not being used */
 791             Dmsg0(90, "Device not in use, unmounting\n");
 792             /* On FreeBSD, I am having ASSERT() failures in block_device()
 793              * and I can only imagine that the thread id that we are
 794              * leaving in no_wait_id is being re-used. So here,
 795              * we simply do it by hand.  Gross, but a solution.
 796              */
 797             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
 798             dev->dev_blocked = BST_UNMOUNTED;
 799             dev->no_wait_id = 0;
 800             if (!unload_autochanger(jcr->dcr, -1)) {
 801                dev->close();
 802             }
 803             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
 804                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 805             } else {
 806                bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
 807                   dev->print_name());
 808             }
 809          }
 810          V(dev->mutex);
 811          free_dcr(dcr);
 812          jcr->dcr = NULL;
 813       } else {
 814          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 815       }
 816    } else {
 817       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 818       pm_strcpy(jcr->errmsg, dir->msg);
 819       bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
 820    }
 821    bnet_sig(dir, BNET_EOD);
 822    return true;
 823 }
 824
 825 /*
 826  * Release command from Director. This rewinds the device and if
 827  *   configured does a offline and ensures that Bacula will
 828  *   re-read the label of the tape before continuing. This gives
 829  *   the operator the chance to change the tape anytime before the
 830  *   next job starts.
 831  */
 832 static bool release_cmd(JCR *jcr)
 833 {
 834    POOL_MEM devname;
 835    BSOCK *dir = jcr->dir_bsock;
 836    DEVICE *dev;
 837    DCR *dcr;
 838    int drive;
 839
 840    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
 841       dcr = find_device(jcr, devname, drive);
 842       if (dcr) {
 843          dev = dcr->dev;
 844          P(dev->mutex);               /* Use P to avoid indefinite block */
 845          if (!dev->is_open()) {
 846             Dmsg0(90, "Device already released\n");
 847             bnet_fsend(dir, _("3921 Device %s already released.\n"),
 848                dev->print_name());
 849
 850          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP ||
 851                     dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
 852             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 853                dev->dev_blocked);
 854             bnet_fsend(dir, _("3922 Device %s waiting for mount.\n"),
 855                dev->print_name());
 856
 857          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 858             bnet_fsend(dir, _("3923 Device %s is busy in acquire.\n"),
 859                dev->print_name());
 860
 861          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 862             bnet_fsend(dir, _("3914 Device %s is being labeled.\n"),
 863                dev->print_name());
 864
 865          } else if (dev->is_busy()) {
 866             send_dir_busy_message(dir, dev);
 867          } else {                     /* device not being used */
 868             Dmsg0(90, "Device not in use, unmounting\n");
 869             release_volume(jcr->dcr);
 870             bnet_fsend(dir, _("3022 Device %s released.\n"),
 871                dev->print_name());
 872          }
 873          V(dev->mutex);
 874          free_dcr(dcr);
 875          jcr->dcr = NULL;
 876       } else {
 877          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 878       }
 879    } else {
 880       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 881       pm_strcpy(jcr->errmsg, dir->msg);
 882       bnet_fsend(dir, _("3927 Error scanning release command: %s\n"), jcr->errmsg);
 883    }
 884    bnet_sig(dir, BNET_EOD);
 885    return true;
 886 }
 887
 888
 889 static bool bootstrap_cmd(JCR *jcr)
 890 {
 891    return get_bootstrap_file(jcr, jcr->dir_bsock);
 892 }
 893
 894 /*
 895  * Autochanger command from Director
 896  */
 897 static bool changer_cmd(JCR *jcr)
 898 {
 899    POOL_MEM devname;
 900    BSOCK *dir = jcr->dir_bsock;
 901    DEVICE *dev;
 902    DCR *dcr;
 903    const char *cmd = NULL;
 904    bool ok = false;
 905    bool dolist = false;
 906
 907    if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
 908       cmd = "list";
 909       dolist = ok = true;
 910    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
 911       cmd = "slots";
 912       ok = true;
 913    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
 914       cmd = "drives";
 915       ok = true;
 916    }
 917    if (ok) {
 918       dcr = find_device(jcr, devname, -1);
 919       if (dcr) {
 920          dev = dcr->dev;
 921          P(dev->mutex);               /* Use P to avoid indefinite block */
 922          if (!dev->device->changer_res) {
 923             bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"),
 924                dev->print_name());
 925          /* Under certain "safe" conditions, we can steal the lock */
 926          } else if (dolist || !dev->is_open() || dev->can_steal_lock()) {
 927             autochanger_cmd(dcr, dir, cmd);
 928          } else if (dev->is_busy() || dev->is_blocked()) {
 929             send_dir_busy_message(dir, dev);
 930          } else {                     /* device not being used */
 931             autochanger_cmd(dcr, dir, cmd);
 932          }
 933          V(dev->mutex);
 934          free_dcr(dcr);
 935          jcr->dcr = NULL;
 936       } else {
 937          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 938       }
 939    } else {  /* error on scanf */
 940       pm_strcpy(jcr->errmsg, dir->msg);
 941       bnet_fsend(dir, _("3908 Error scanning autocharger drives/list/slots command: %s\n"),
 942          jcr->errmsg);
 943    }
 944    bnet_sig(dir, BNET_EOD);
 945    return true;
 946 }
 947
 948 /*
 949  * Read and return the Volume label
 950  */
 951 static bool readlabel_cmd(JCR *jcr)
 952 {
 953    POOL_MEM devname;
 954    BSOCK *dir = jcr->dir_bsock;
 955    DEVICE *dev;
 956    DCR *dcr;
 957    int Slot;
 958    int drive;
 959
 960    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
 961        &Slot, &drive) == 3) {
 962       dcr = find_device(jcr, devname, drive);
 963       if (dcr) {
 964          dev = dcr->dev;
 965          P(dev->mutex);               /* Use P to avoid indefinite block */
 966          if (!dev->is_open()) {
 967             read_volume_label(jcr, dev, Slot);
 968             dev->close();
 969          /* Under certain "safe" conditions, we can steal the lock */
 970          } else if (dev->can_steal_lock()) {
 971             read_volume_label(jcr, dev, Slot);
 972          } else if (dev->is_busy() || dev->is_blocked()) {
 973             send_dir_busy_message(dir, dev);
 974          } else {                     /* device not being used */
 975             read_volume_label(jcr, dev, Slot);
 976          }
 977          V(dev->mutex);
 978          free_dcr(dcr);
 979          jcr->dcr = NULL;
 980       } else {
 981          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 982       }
 983    } else {
 984       pm_strcpy(jcr->errmsg, dir->msg);
 985       bnet_fsend(dir, _("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
 986    }
 987    bnet_sig(dir, BNET_EOD);
 988    return true;
 989 }
 990
 991
 992 /*
 993  * Read the tape label
 994  *
 995  *  Enter with the mutex set
 996  */
 997 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot)
 998 {
 999    BSOCK *dir = jcr->dir_bsock;
1000    bsteal_lock_t hold;
1001    DCR *dcr = jcr->dcr;
1002
1003    dcr->dev = dev;
1004    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1005
1006    if (!try_autoload_device(jcr, Slot, "")) {
1007       goto bail_out;                  /* error */
1008    }
1009
1010    dev->clear_labeled();              /* force read of label */
1011    switch (read_dev_volume_label(dcr)) {
1012    case VOL_OK:
1013       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1014       bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1015       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1016       break;
1017    default:
1018       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1019                  dev->print_name(), jcr->errmsg);
1020       break;
1021    }
1022
1023 bail_out:
1024    give_back_device_lock(dev, &hold);
1025    return;
1026 }
1027
1028 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName)
1029 {
1030    DCR *dcr = jcr->dcr;
1031    BSOCK *dir = jcr->dir_bsock;
1032
1033    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1034    dcr->VolCatInfo.Slot = slot;
1035    dcr->VolCatInfo.InChanger = slot > 0;
1036    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1037       return false;
1038    }
1039    return true;
1040 }
1041
1042 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1043 {
1044    if (dev->is_blocked()) {
1045       switch (dev->dev_blocked) {
1046       case BST_UNMOUNTED:
1047          bnet_fsend(dir, _("3931 Device %s is BLOCKED. user unmounted.\n"),
1048             dev->print_name());
1049          break;
1050       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1051          bnet_fsend(dir, _("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1052              dev->print_name());
1053          break;
1054       case BST_WAITING_FOR_SYSOP:
1055          bnet_fsend(dir, _("3933 Device %s is BLOCKED waiting for media.\n"),
1056             dev->print_name());
1057          break;
1058       case BST_DOING_ACQUIRE:
1059          bnet_fsend(dir, _("3934 Device %s is being initialized.\n"),
1060             dev->print_name());
1061          break;
1062       case BST_WRITING_LABEL:
1063          bnet_fsend(dir, _("3935 Device %s is blocked labeling a Volume.\n"),
1064             dev->print_name());
1065          break;
1066       default:
1067          bnet_fsend(dir, _("3935 Device %s is blocked for unknown reason.\n"),
1068             dev->print_name());
1069          break;
1070       }
1071    } else if (dev->can_read()) {
1072        bnet_fsend(dir, _("3936 Device %s is busy reading.\n"),
1073                    dev->print_name());;
1074    } else {
1075        bnet_fsend(dir, _("3937 Device %s is busy with %d writer(s).\n"),
1076           dev->print_name(), dev->num_writers);
1077    }
1078 }