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