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    char ed1[50];
 395
 396    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 397    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
 398
 399    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 400    if (relabel && dev->is_dvd()) {
 401       dcr->VolCatInfo.VolCatParts=0;
 402    }
 403
 404    if (!try_autoload_device(dcr->jcr, slot, volname)) {
 405       goto bail_out;                  /* error */
 406    }
 407
 408    /* Ensure that the device is open -- autoload_device() closes it */
 409    if (dev->is_tape()) {
 410       mode = OPEN_READ_WRITE;
 411    } else {
 412       mode = CREATE_READ_WRITE;
 413    }
 414    if (dev->is_dvd()) {
 415       bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
 416    }
 417
 418    if (dev->open(dcr, mode) < 0) {
 419       bnet_fsend(dir, _("3910 Unable to open device %s: ERR=%s\n"),
 420          dev->print_name(), dev->strerror());
 421       goto bail_out;
 422    }
 423
 424    /* See what we have for a Volume */
 425    label_status = read_dev_volume_label(dcr);
 426
 427    switch(label_status) {
 428    case VOL_NAME_ERROR:
 429    case VOL_VERSION_ERROR:
 430    case VOL_LABEL_ERROR:
 431    case VOL_OK:
 432       if (!relabel) {
 433          bnet_fsend(dir, _(
 434             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
 435              dev->VolHdr.VolumeName);
 436          break;
 437       }
 438
 439       /* Relabel request. If oldname matches, continue */
 440       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
 441          bnet_fsend(dir, _("3921 Wrong volume mounted.\n"));
 442          break;
 443       }
 444       if (dev->label_type != B_BACULA_LABEL) {
 445          bnet_fsend(dir, _("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
 446          break;
 447       }
 448       if (relabel && dev->is_dvd()) {
 449          /* Change the partition file name */
 450          bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 451          if (!dev->truncate(dcr)) {
 452             bnet_fsend(dir, _("3912 Failed to truncate previous DVD volume.\n"));
 453             break;
 454          }
 455       }
 456       free_volume(dev);               /* release old volume name */
 457       /* Fall through wanted! */
 458    case VOL_IO_ERROR:
 459    case VOL_NO_LABEL:
 460       if (!write_new_volume_label_to_dev(dcr, newname, poolname, true /* write dvd now */)) {
 461          bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 462          break;
 463       }
 464       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 465       /* The following 3000 OK label. string is scanned in ua_label.c */
 466       bnet_fsend(dir, "3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
 467                  edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
 468                  dev->is_dvd()?1:0, newname, dev->print_name());
 469       break;
 470    case VOL_NO_MEDIA:
 471       bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 472       break;
 473    default:
 474       bnet_fsend(dir, _("3913 Cannot label Volume. "
 475 "Unknown status %d from read_volume_label()\n"), label_status);
 476       break;
 477    }
 478
 479 bail_out:
 480    if (!dev->is_open()) {
 481       free_volume(dev);
 482    }
 483    give_back_device_lock(dev, &hold);
 484    return;
 485 }
 486
 487
 488 /*
 489  * Read the tape label
 490  *
 491  *  Enter with the mutex set
 492  */
 493 static bool read_label(DCR *dcr)
 494 {
 495    int ok;
 496    JCR *jcr = dcr->jcr;
 497    BSOCK *dir = jcr->dir_bsock;
 498    bsteal_lock_t hold;
 499    DEVICE *dev = dcr->dev;
 500
 501    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 502
 503    dcr->VolumeName[0] = 0;
 504    dev->clear_labeled();              /* force read of label */
 505    switch (read_dev_volume_label(dcr)) {
 506    case VOL_OK:
 507       bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
 508       ok = true;
 509       break;
 510    default:
 511       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
 512          dev->print_name(), jcr->errmsg);
 513       ok = false;
 514       break;
 515    }
 516    give_back_device_lock(dev, &hold);
 517    return ok;
 518 }
 519
 520 /*
 521  * Searches for device by name, and if found, creates a dcr and
 522  *  returns it.
 523  */
 524 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
 525 {
 526    DEVRES *device;
 527    AUTOCHANGER *changer;
 528    bool found = false;
 529    DCR *dcr = NULL;
 530
 531    unbash_spaces(devname);
 532    foreach_res(device, R_DEVICE) {
 533       /* Find resource, and make sure we were able to open it */
 534       if (fnmatch(device->hdr.name, devname.c_str(), 0) == 0) {
 535          if (!device->dev) {
 536             device->dev = init_dev(jcr, device);
 537          }
 538          if (!device->dev) {
 539             Jmsg(jcr, M_WARNING, 0, _("\n"
 540                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 541                  devname.c_str());
 542             continue;
 543          }
 544          Dmsg1(20, "Found device %s\n", device->hdr.name);
 545          found = true;
 546          break;
 547       }
 548    }
 549    if (!found) {
 550       foreach_res(changer, R_AUTOCHANGER) {
 551          /* Find resource, and make sure we were able to open it */
 552          if (fnmatch(devname.c_str(), changer->hdr.name, 0) == 0) {
 553             /* Try each device in this AutoChanger */
 554             foreach_alist(device, changer->device) {
 555                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
 556                if (!device->dev) {
 557                   device->dev = init_dev(jcr, device);
 558                }
 559                if (!device->dev) {
 560                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
 561                   Jmsg(jcr, M_WARNING, 0, _("\n"
 562                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 563                        device->hdr.name, devname.c_str());
 564                   continue;
 565                }
 566                if (!device->dev->autoselect) {
 567                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
 568                   continue;              /* device is not available */
 569                }
 570                if (drive < 0 || drive == (int)device->dev->drive_index) {
 571                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
 572                   found = true;
 573                   break;
 574                }
 575                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
 576                   devname.c_str(), drive, (int)device->dev->drive_index);
 577             }
 578             break;                    /* we found it but could not open a device */
 579          }
 580       }
 581    }
 582
 583    if (found) {
 584       Dmsg1(100, "Found device %s\n", device->hdr.name);
 585       dcr = new_dcr(jcr, device->dev);
 586       dcr->device = device;
 587       jcr->dcr = dcr;
 588    }
 589    return dcr;
 590 }
 591
 592
 593 /*
 594  * Mount command from Director
 595  */
 596 static bool mount_cmd(JCR *jcr)
 597 {
 598    POOL_MEM devname;
 599    BSOCK *dir = jcr->dir_bsock;
 600    DEVICE *dev;
 601    DCR *dcr;
 602    int drive;
 603    int slot = 0;
 604    bool ok;
 605
 606    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
 607                &drive, &slot) == 3;
 608    if (!ok) {
 609       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
 610    }
 611    if (ok) {
 612       dcr = find_device(jcr, devname, drive);
 613       if (dcr) {
 614          dev = dcr->dev;
 615          P(dev->mutex);               /* Use P to avoid indefinite block */
 616          Dmsg1(100, "mount cmd blocked=%d\n", dev->dev_blocked);
 617          switch (dev->dev_blocked) {         /* device blocked? */
 618          case BST_WAITING_FOR_SYSOP:
 619             /* Someone is waiting, wake him */
 620             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
 621             dev->dev_blocked = BST_MOUNT;
 622             bnet_fsend(dir, "3001 OK mount. Device=%s\n",
 623                dev->print_name());
 624             pthread_cond_broadcast(&dev->wait_next_vol);
 625             pthread_cond_broadcast(&wait_device_release);
 626             break;
 627
 628          /* In both of these two cases, we (the user) unmounted the Volume */
 629          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 630          case BST_UNMOUNTED:
 631             if (dev->is_autochanger() && slot > 0) {
 632                try_autoload_device(jcr, slot, "");
 633             }
 634             /* We freed the device, so reopen it and wake any waiting threads */
 635             if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 636                bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 637                   dev->bstrerror());
 638                if (dev->dev_blocked == BST_UNMOUNTED) {
 639                   /* We blocked the device, so unblock it */
 640                   Dmsg0(100, "Unmounted. Unblocking device\n");
 641                   unblock_device(dev);
 642                }
 643                break;
 644             }
 645             read_dev_volume_label(dcr);
 646             if (dev->dev_blocked == BST_UNMOUNTED) {
 647                /* We blocked the device, so unblock it */
 648                Dmsg0(100, "Unmounted. Unblocking device\n");
 649                read_label(dcr);       /* this should not be necessary */
 650                unblock_device(dev);
 651             } else {
 652                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
 653                dev->dev_blocked = BST_MOUNT;
 654             }
 655             if (dev->is_labeled()) {
 656                bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
 657                   dev->print_name(), dev->VolHdr.VolumeName);
 658             } else {
 659                bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 660                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 661                           dev->print_name());
 662             }
 663             pthread_cond_broadcast(&dev->wait_next_vol);
 664             pthread_cond_broadcast(&wait_device_release);
 665             break;
 666
 667          case BST_DOING_ACQUIRE:
 668             bnet_fsend(dir, _("3001 Device %s is doing acquire.\n"),
 669                        dev->print_name());
 670             break;
 671
 672          case BST_WRITING_LABEL:
 673             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 674                dev->print_name());
 675             break;
 676
 677          case BST_NOT_BLOCKED:
 678             if (dev->is_autochanger() && slot > 0) {
 679                try_autoload_device(jcr, slot, "");
 680             }
 681             if (dev->is_open()) {
 682                if (dev->is_labeled()) {
 683                   bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
 684                      dev->print_name(), dev->VolHdr.VolumeName);
 685                } else {
 686                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 687                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 688                              dev->print_name());
 689                }
 690             } else if (dev->is_tape()) {
 691                if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 692                   bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 693                      dev->bstrerror());
 694                   break;
 695                }
 696                read_label(dcr);
 697                if (dev->is_labeled()) {
 698                   bnet_fsend(dir, _("3001 Device %s is already mounted with Volume \"%s\"\n"),
 699                      dev->print_name(), dev->VolHdr.VolumeName);
 700                } else {
 701                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 702                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 703                              dev->print_name());
 704                }
 705             } else if (dev->is_dvd()) {
 706                if (mount_dvd(dev, 1)) {
 707                   bnet_fsend(dir, _("3002 Device %s is mounted.\n"),
 708                      dev->print_name());
 709                } else {
 710                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 711                }
 712             } else { /* must be file */
 713                bnet_fsend(dir, _("3906 File device %s is always mounted.\n"),
 714                   dev->print_name());
 715             }
 716             break;
 717
 718          default:
 719             bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
 720             break;
 721          }
 722          V(dev->mutex);
 723          free_dcr(dcr);
 724          jcr->dcr = NULL;
 725       } else {
 726          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 727       }
 728    } else {
 729       pm_strcpy(jcr->errmsg, dir->msg);
 730       bnet_fsend(dir, _("3909 Error scanning mount command: %s\n"), jcr->errmsg);
 731    }
 732    bnet_sig(dir, BNET_EOD);
 733    return true;
 734 }
 735
 736 /*
 737  * unmount command from Director
 738  */
 739 static bool unmount_cmd(JCR *jcr)
 740 {
 741    POOL_MEM devname;
 742    BSOCK *dir = jcr->dir_bsock;
 743    DEVICE *dev;
 744    DCR *dcr;
 745    int drive;
 746
 747    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
 748       dcr = find_device(jcr, devname, drive);
 749       if (dcr) {
 750          dev = dcr->dev;
 751          P(dev->mutex);               /* Use P to avoid indefinite block */
 752          if (!dev->is_open()) {
 753             if (!dev->is_busy()) {
 754                unload_autochanger(jcr->dcr, -1);
 755             }
 756             if (dev->is_dvd()) {
 757                if (unmount_dvd(dev, 0)) {
 758                   bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
 759                      dev->print_name());
 760                } else {
 761                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 762                }
 763             } else {
 764                Dmsg0(90, "Device already unmounted\n");
 765                bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"),
 766                   dev->print_name());
 767             }
 768          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
 769             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 770                dev->dev_blocked);
 771             if (!unload_autochanger(jcr->dcr, -1)) {
 772                dev->close();
 773             }
 774             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
 775                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 776             } else {
 777                dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
 778                bnet_fsend(dir, _("3001 Device %s unmounted.\n"),
 779                   dev->print_name());
 780             }
 781
 782          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 783             bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"),
 784                dev->print_name());
 785
 786          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 787             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 788                dev->print_name());
 789
 790          } else if (dev->is_busy()) {
 791             send_dir_busy_message(dir, dev);
 792          } else {                     /* device not being used */
 793             Dmsg0(90, "Device not in use, unmounting\n");
 794             /* On FreeBSD, I am having ASSERT() failures in block_device()
 795              * and I can only imagine that the thread id that we are
 796              * leaving in no_wait_id is being re-used. So here,
 797              * we simply do it by hand.  Gross, but a solution.
 798              */
 799             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
 800             dev->dev_blocked = BST_UNMOUNTED;
 801             dev->no_wait_id = 0;
 802             if (!unload_autochanger(jcr->dcr, -1)) {
 803                dev->close();
 804             }
 805             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
 806                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 807             } else {
 808                bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
 809                   dev->print_name());
 810             }
 811          }
 812          V(dev->mutex);
 813          free_dcr(dcr);
 814          jcr->dcr = NULL;
 815       } else {
 816          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 817       }
 818    } else {
 819       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 820       pm_strcpy(jcr->errmsg, dir->msg);
 821       bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
 822    }
 823    bnet_sig(dir, BNET_EOD);
 824    return true;
 825 }
 826
 827 /*
 828  * Release command from Director. This rewinds the device and if
 829  *   configured does a offline and ensures that Bacula will
 830  *   re-read the label of the tape before continuing. This gives
 831  *   the operator the chance to change the tape anytime before the
 832  *   next job starts.
 833  */
 834 static bool release_cmd(JCR *jcr)
 835 {
 836    POOL_MEM devname;
 837    BSOCK *dir = jcr->dir_bsock;
 838    DEVICE *dev;
 839    DCR *dcr;
 840    int drive;
 841
 842    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
 843       dcr = find_device(jcr, devname, drive);
 844       if (dcr) {
 845          dev = dcr->dev;
 846          P(dev->mutex);               /* Use P to avoid indefinite block */
 847          if (!dev->is_open()) {
 848             Dmsg0(90, "Device already released\n");
 849             bnet_fsend(dir, _("3921 Device %s already released.\n"),
 850                dev->print_name());
 851
 852          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP ||
 853                     dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
 854             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 855                dev->dev_blocked);
 856             bnet_fsend(dir, _("3922 Device %s waiting for mount.\n"),
 857                dev->print_name());
 858
 859          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 860             bnet_fsend(dir, _("3923 Device %s is busy in acquire.\n"),
 861                dev->print_name());
 862
 863          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 864             bnet_fsend(dir, _("3914 Device %s is being labeled.\n"),
 865                dev->print_name());
 866
 867          } else if (dev->is_busy()) {
 868             send_dir_busy_message(dir, dev);
 869          } else {                     /* device not being used */
 870             Dmsg0(90, "Device not in use, unmounting\n");
 871             release_volume(jcr->dcr);
 872             bnet_fsend(dir, _("3022 Device %s released.\n"),
 873                dev->print_name());
 874          }
 875          V(dev->mutex);
 876          free_dcr(dcr);
 877          jcr->dcr = NULL;
 878       } else {
 879          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 880       }
 881    } else {
 882       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 883       pm_strcpy(jcr->errmsg, dir->msg);
 884       bnet_fsend(dir, _("3927 Error scanning release command: %s\n"), jcr->errmsg);
 885    }
 886    bnet_sig(dir, BNET_EOD);
 887    return true;
 888 }
 889
 890
 891 static bool bootstrap_cmd(JCR *jcr)
 892 {
 893    return get_bootstrap_file(jcr, jcr->dir_bsock);
 894 }
 895
 896 /*
 897  * Autochanger command from Director
 898  */
 899 static bool changer_cmd(JCR *jcr)
 900 {
 901    POOL_MEM devname;
 902    BSOCK *dir = jcr->dir_bsock;
 903    DEVICE *dev;
 904    DCR *dcr;
 905    const char *cmd = NULL;
 906    bool ok = false;
 907    /*
 908     * A safe_cmd may call autochanger script but does not load/unload
 909     *    slots so it can be done at the same time that the drive is open.
 910     */
 911    bool safe_cmd = false;
 912
 913    if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
 914       cmd = "list";
 915       safe_cmd = ok = true;
 916    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
 917       cmd = "slots";
 918       safe_cmd = ok = true;
 919    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
 920       cmd = "drives";
 921       safe_cmd = ok = true;
 922    }
 923    if (ok) {
 924       dcr = find_device(jcr, devname, -1);
 925       if (dcr) {
 926          dev = dcr->dev;
 927          P(dev->mutex);               /* Use P to avoid indefinite block */
 928          if (!dev->device->changer_res) {
 929             bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"),
 930                dev->print_name());
 931          /* Under certain "safe" conditions, we can steal the lock */
 932          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
 933             autochanger_cmd(dcr, dir, cmd);
 934          } else if (dev->is_busy() || dev->is_blocked()) {
 935             send_dir_busy_message(dir, dev);
 936          } else {                     /* device not being used */
 937             autochanger_cmd(dcr, dir, cmd);
 938          }
 939          V(dev->mutex);
 940          free_dcr(dcr);
 941          jcr->dcr = NULL;
 942       } else {
 943          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 944       }
 945    } else {  /* error on scanf */
 946       pm_strcpy(jcr->errmsg, dir->msg);
 947       bnet_fsend(dir, _("3908 Error scanning autocharger drives/list/slots command: %s\n"),
 948          jcr->errmsg);
 949    }
 950    bnet_sig(dir, BNET_EOD);
 951    return true;
 952 }
 953
 954 /*
 955  * Read and return the Volume label
 956  */
 957 static bool readlabel_cmd(JCR *jcr)
 958 {
 959    POOL_MEM devname;
 960    BSOCK *dir = jcr->dir_bsock;
 961    DEVICE *dev;
 962    DCR *dcr;
 963    int Slot;
 964    int drive;
 965
 966    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
 967        &Slot, &drive) == 3) {
 968       dcr = find_device(jcr, devname, drive);
 969       if (dcr) {
 970          dev = dcr->dev;
 971          P(dev->mutex);               /* Use P to avoid indefinite block */
 972          if (!dev->is_open()) {
 973             read_volume_label(jcr, dev, Slot);
 974             dev->close();
 975          /* Under certain "safe" conditions, we can steal the lock */
 976          } else if (dev->can_steal_lock()) {
 977             read_volume_label(jcr, dev, Slot);
 978          } else if (dev->is_busy() || dev->is_blocked()) {
 979             send_dir_busy_message(dir, dev);
 980          } else {                     /* device not being used */
 981             read_volume_label(jcr, dev, Slot);
 982          }
 983          V(dev->mutex);
 984          free_dcr(dcr);
 985          jcr->dcr = NULL;
 986       } else {
 987          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 988       }
 989    } else {
 990       pm_strcpy(jcr->errmsg, dir->msg);
 991       bnet_fsend(dir, _("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
 992    }
 993    bnet_sig(dir, BNET_EOD);
 994    return true;
 995 }
 996
 997
 998 /*
 999  * Read the tape label
1000  *
1001  *  Enter with the mutex set
1002  */
1003 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot)
1004 {
1005    BSOCK *dir = jcr->dir_bsock;
1006    bsteal_lock_t hold;
1007    DCR *dcr = jcr->dcr;
1008
1009    dcr->dev = dev;
1010    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1011
1012    if (!try_autoload_device(jcr, Slot, "")) {
1013       goto bail_out;                  /* error */
1014    }
1015
1016    dev->clear_labeled();              /* force read of label */
1017    switch (read_dev_volume_label(dcr)) {
1018    case VOL_OK:
1019       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1020       bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1021       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1022       break;
1023    default:
1024       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1025                  dev->print_name(), jcr->errmsg);
1026       break;
1027    }
1028
1029 bail_out:
1030    give_back_device_lock(dev, &hold);
1031    return;
1032 }
1033
1034 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName)
1035 {
1036    DCR *dcr = jcr->dcr;
1037    BSOCK *dir = jcr->dir_bsock;
1038
1039    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1040    dcr->VolCatInfo.Slot = slot;
1041    dcr->VolCatInfo.InChanger = slot > 0;
1042    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1043       return false;
1044    }
1045    return true;
1046 }
1047
1048 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1049 {
1050    if (dev->is_blocked()) {
1051       switch (dev->dev_blocked) {
1052       case BST_UNMOUNTED:
1053          bnet_fsend(dir, _("3931 Device %s is BLOCKED. user unmounted.\n"),
1054             dev->print_name());
1055          break;
1056       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1057          bnet_fsend(dir, _("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1058              dev->print_name());
1059          break;
1060       case BST_WAITING_FOR_SYSOP:
1061          bnet_fsend(dir, _("3933 Device %s is BLOCKED waiting for media.\n"),
1062             dev->print_name());
1063          break;
1064       case BST_DOING_ACQUIRE:
1065          bnet_fsend(dir, _("3934 Device %s is being initialized.\n"),
1066             dev->print_name());
1067          break;
1068       case BST_WRITING_LABEL:
1069          bnet_fsend(dir, _("3935 Device %s is blocked labeling a Volume.\n"),
1070             dev->print_name());
1071          break;
1072       default:
1073          bnet_fsend(dir, _("3935 Device %s is blocked for unknown reason.\n"),
1074             dev->print_name());
1075          break;
1076       }
1077    } else if (dev->can_read()) {
1078        bnet_fsend(dir, _("3936 Device %s is busy reading.\n"),
1079                    dev->print_name());;
1080    } else {
1081        bnet_fsend(dir, _("3937 Device %s is busy with %d writer(s).\n"),
1082           dev->print_name(), dev->num_writers);
1083    }
1084 }