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

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