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

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