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 Kern Sibbald.
  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 struct s_last_job last_job;
  58 extern bool init_done;
  59
  60 /* Static variables */
  61 static char derrmsg[]     = "3900 Invalid command\n";
  62 static char OKsetdebug[]  = "3000 OK setdebug=%d\n";
  63 static char invalid_cmd[] = "3997 Invalid command for a Director with Monitor directive enabled.\n";
  64
  65 /* Imported functions */
  66 extern void terminate_child();
  67 extern bool job_cmd(JCR *jcr);
  68 extern bool use_cmd(JCR *jcr);
  69 extern bool run_cmd(JCR *jcr);
  70 extern bool status_cmd(JCR *sjcr);
  71 extern bool qstatus_cmd(JCR *jcr);
  72 //extern bool query_cmd(JCR *jcr);
  73
  74 /* Forward referenced functions */
  75 static bool label_cmd(JCR *jcr);
  76 static bool die_cmd(JCR *jcr);
  77 static bool relabel_cmd(JCR *jcr);
  78 static bool readlabel_cmd(JCR *jcr);
  79 static bool release_cmd(JCR *jcr);
  80 static bool setdebug_cmd(JCR *jcr);
  81 static bool cancel_cmd(JCR *cjcr);
  82 static bool mount_cmd(JCR *jcr);
  83 static bool unmount_cmd(JCR *jcr);
  84 static bool bootstrap_cmd(JCR *jcr);
  85 static bool changer_cmd(JCR *sjcr);
  86 static bool do_label(JCR *jcr, int relabel);
  87 static DCR *find_device(JCR *jcr, POOL_MEM &dev_name, int drive);
  88 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot);
  89 static void label_volume_if_ok(DCR *dcr, char *oldname,
  90                                char *newname, char *poolname,
  91                                int Slot, int relabel);
  92 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName);
  93 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev);
  94
  95 struct s_cmds {
  96    const char *cmd;
  97    bool (*func)(JCR *jcr);
  98    bool monitoraccess;                      /* set if monitors can access this cmd */
  99 };
 100
 101 /*
 102  * The following are the recognized commands from the Director.
 103  */
 104 static struct s_cmds cmds[] = {
 105    {"JobId=",      job_cmd,         0},     /* start Job */
 106    {"autochanger", changer_cmd,     0},
 107    {"bootstrap",   bootstrap_cmd,   0},
 108    {"cancel",      cancel_cmd,      0},
 109    {".die",        die_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[500];
 150    char tbuf[100];
 151
 152    if (bs->recv() <= 0) {
 153       Emsg0(M_ERROR, 0, _("Connection request failed.\n"));
 154       bs->close();
 155       return NULL;
 156    }
 157
 158    /*
 159     * Do a sanity check on the message received
 160     */
 161    if (bs->msglen < 25 || bs->msglen > (int)sizeof(name)) {
 162       Dmsg1(000, "<filed: %s", bs->msg);
 163       Emsg1(M_ERROR, 0, _("Invalid connection. Len=%d\n"), bs->msglen);
 164       bs->close();
 165       return NULL;
 166    }
 167    /*
 168     * See if this is a File daemon connection. If so
 169     *   call FD handler.
 170     */
 171    Dmsg1(110, "Conn: %s", bs->msg);
 172    if (debug_level == 3) {
 173       Dmsg1(000, "<filed: %s", bs->msg);
 174    }
 175    if (sscanf(bs->msg, "Hello Start Job %127s", name) == 1) {
 176       Dmsg1(110, "Got a FD connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 177             (utime_t)time(NULL)));
 178       Dmsg1(50, "%s", bs->msg);
 179       handle_filed_connection(bs, name);
 180       return NULL;
 181    }
 182
 183    /*
 184     * This is a connection from the Director, so setup a JCR
 185     */
 186    Dmsg1(110, "Got a DIR connection at %s\n", bstrftimes(tbuf, sizeof(tbuf),
 187          (utime_t)time(NULL)));
 188    jcr = new_jcr(sizeof(JCR), stored_free_jcr); /* create Job Control Record */
 189    jcr->dir_bsock = bs;               /* save Director bsock */
 190    jcr->dir_bsock->set_jcr(jcr);
 191    jcr->dcrs = New(alist(10, not_owned_by_alist));
 192    /* Initialize FD start condition variable */
 193    int errstat = pthread_cond_init(&jcr->job_start_wait, NULL);
 194    if (errstat != 0) {
 195       berrno be;
 196       Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.bstrerror(errstat));
 197       goto bail_out;
 198    }
 199
 200    Dmsg0(1000, "stored in start_job\n");
 201
 202    /*
 203     * Authenticate the Director
 204     */
 205    if (!authenticate_director(jcr)) {
 206       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
 207       goto bail_out;
 208    }
 209    Dmsg0(90, "Message channel init completed.\n");
 210
 211    for (quit=false; !quit;) {
 212       /* Read command */
 213       if ((bnet_stat = bs->recv()) <= 0) {
 214          break;               /* connection terminated */
 215       }
 216       Dmsg1(199, "<dird: %s\n", bs->msg);
 217       /* Ensure that device initialization is complete */
 218       while (!init_done) {
 219          bmicrosleep(1, 0);
 220       }
 221       found = false;
 222       for (i=0; cmds[i].cmd; i++) {
 223         if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 224            if ((!cmds[i].monitoraccess) && (jcr->director->monitor)) {
 225               Dmsg1(100, "Command \"%s\" is invalid.\n", cmds[i].cmd);
 226               bs->fsend(invalid_cmd);
 227               bs->signal(BNET_EOD);
 228               break;
 229            }
 230            Dmsg1(200, "Do command: %s\n", cmds[i].cmd);
 231            if (!cmds[i].func(jcr)) { /* do command */
 232               quit = true; /* error, get out */
 233               Dmsg1(190, "Command %s reqeusts quit\n", cmds[i].cmd);
 234            }
 235            found = true;             /* indicate command found */
 236            break;
 237         }
 238       }
 239       if (!found) {                   /* command not found */
 240         bs->fsend(derrmsg);
 241         break;
 242       }
 243    }
 244 bail_out:
 245    generate_daemon_event(jcr, "JobEnd");
 246    dequeue_messages(jcr);             /* send any queued messages */
 247    bs->signal(BNET_TERMINATE);
 248    free_jcr(jcr);
 249    return NULL;
 250 }
 251
 252
 253 /*
 254  * Force SD to die, and hopefully dump itself.  Turned on only
 255  *  in development version.
 256  */
 257 static bool die_cmd(JCR *jcr)
 258 {
 259 #ifdef DEVELOPER
 260    JCR *djcr = NULL;
 261    int a;
 262    Pmsg0(000, "I have been requested to die ...");
 263    a = djcr->JobId;   /* ref NULL pointer */
 264 #endif
 265    return 0;
 266 }
 267
 268
 269
 270 /*
 271  * Set debug level as requested by the Director
 272  *
 273  */
 274 static bool setdebug_cmd(JCR *jcr)
 275 {
 276    BSOCK *dir = jcr->dir_bsock;
 277    int level, trace_flag;
 278
 279    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 280    if (sscanf(dir->msg, "setdebug=%d trace=%d", &level, &trace_flag) != 2 || level < 0) {
 281       dir->fsend(_("3991 Bad setdebug command: %s\n"), dir->msg);
 282       return 0;
 283    }
 284    debug_level = level;
 285    set_trace(trace_flag);
 286    return dir->fsend(OKsetdebug, level);
 287 }
 288
 289
 290 /*
 291  * Cancel a Job
 292  */
 293 static bool cancel_cmd(JCR *cjcr)
 294 {
 295    BSOCK *dir = cjcr->dir_bsock;
 296    int oldStatus;
 297    char Job[MAX_NAME_LENGTH];
 298    JCR *jcr;
 299
 300    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 301       if (!(jcr=get_jcr_by_full_name(Job))) {
 302          dir->fsend(_("3904 Job %s not found.\n"), Job);
 303       } else {
 304          oldStatus = jcr->JobStatus;
 305          set_jcr_job_status(jcr, JS_Canceled);
 306          if (!jcr->authenticated && oldStatus == JS_WaitFD) {
 307             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 308          }
 309          if (jcr->file_bsock) {
 310             bnet_sig(jcr->file_bsock, BNET_TERMINATE);
 311          } else {
 312             /* Still waiting for FD to connect, release it */
 313             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
 314          }
 315          /* If thread waiting on mount, wake him */
 316          if (jcr->dcr && jcr->dcr->dev && jcr->dcr->dev->waiting_for_mount()) {
 317             pthread_cond_broadcast(&jcr->dcr->dev->wait_next_vol);
 318             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 319             pthread_cond_broadcast(&wait_device_release);
 320          }
 321          if (jcr->read_dcr && jcr->read_dcr->dev && jcr->read_dcr->dev->waiting_for_mount()) {
 322             pthread_cond_broadcast(&jcr->read_dcr->dev->wait_next_vol);
 323             Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId);
 324             pthread_cond_broadcast(&wait_device_release);
 325          }
 326          Jmsg(jcr, M_INFO, 0, _("Job %s marked to be canceled.\n"), jcr->Job);
 327          dir->fsend(_("3000 Job %s marked to be canceled.\n"), jcr->Job);
 328          free_jcr(jcr);
 329       }
 330    } else {
 331       dir->fsend(_("3903 Error scanning cancel command.\n"));
 332    }
 333    dir->signal(BNET_EOD);
 334    return 1;
 335 }
 336
 337 /*
 338  * Label a Volume
 339  *
 340  */
 341 static bool label_cmd(JCR *jcr)
 342 {
 343    return do_label(jcr, 0);
 344 }
 345
 346 static bool relabel_cmd(JCR *jcr)
 347 {
 348    return do_label(jcr, 1);
 349 }
 350
 351 static bool do_label(JCR *jcr, int relabel)
 352 {
 353    POOLMEM *newname, *oldname, *poolname, *mtype;
 354    POOL_MEM dev_name;
 355    BSOCK *dir = jcr->dir_bsock;
 356    DCR *dcr;
 357    DEVICE *dev;
 358    bool ok = false;
 359    int slot;
 360    int drive;
 361
 362    newname = get_memory(dir->msglen+1);
 363    oldname = get_memory(dir->msglen+1);
 364    poolname = get_memory(dir->msglen+1);
 365    mtype = get_memory(dir->msglen+1);
 366    if (relabel) {
 367       if (sscanf(dir->msg, "relabel %127s OldName=%127s NewName=%127s PoolName=%127s "
 368                  "MediaType=%127s Slot=%d drive=%d",
 369                   dev_name.c_str(), oldname, newname, poolname, mtype,
 370                   &slot, &drive) == 7) {
 371          ok = true;
 372       }
 373    } else {
 374       *oldname = 0;
 375       if (sscanf(dir->msg, "label %127s VolumeName=%127s PoolName=%127s "
 376                  "MediaType=%127s Slot=%d drive=%d",
 377           dev_name.c_str(), newname, poolname, mtype, &slot, &drive) == 6) {
 378          ok = true;
 379       }
 380    }
 381    if (ok) {
 382       unbash_spaces(newname);
 383       unbash_spaces(oldname);
 384       unbash_spaces(poolname);
 385       unbash_spaces(mtype);
 386       dcr = find_device(jcr, dev_name, drive);
 387       if (dcr) {
 388          dev = dcr->dev;
 389          dev->dlock();                 /* Use P to avoid indefinite block */
 390          if (!dev->is_open() && !dev->is_busy()) {
 391             Dmsg1(400, "Can %slabel. Device is not open\n", relabel?"re":"");
 392             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 393             dev->close();
 394          /* Under certain "safe" conditions, we can steal the lock */
 395          } else if (dev->can_steal_lock()) {
 396             Dmsg0(400, "Can relabel. can_steal_lock\n");
 397             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 398          } else if (dev->is_busy() || dev->is_blocked()) {
 399             send_dir_busy_message(dir, dev);
 400          } else {                     /* device not being used */
 401             Dmsg0(400, "Can relabel. device not used\n");
 402             label_volume_if_ok(dcr, oldname, newname, poolname, slot, relabel);
 403          }
 404          dev->dunlock();
 405          free_dcr(dcr);
 406       } else {
 407          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), dev_name.c_str());
 408       }
 409    } else {
 410       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 411       pm_strcpy(jcr->errmsg, dir->msg);
 412       dir->fsend(_("3903 Error scanning label command: %s\n"), jcr->errmsg);
 413    }
 414    free_memory(oldname);
 415    free_memory(newname);
 416    free_memory(poolname);
 417    free_memory(mtype);
 418    dir->signal(BNET_EOD);
 419    return true;
 420 }
 421
 422 /*
 423  * Read the tape label and determine if we can safely
 424  * label the tape (not a Bacula volume), then label it.
 425  *
 426  *  Enter with the mutex set
 427  */
 428 static void label_volume_if_ok(DCR *dcr, char *oldname,
 429                                char *newname, char *poolname,
 430                                int slot, int relabel)
 431 {
 432    BSOCK *dir = dcr->jcr->dir_bsock;
 433    bsteal_lock_t hold;
 434    DEVICE *dev = dcr->dev;
 435    int label_status;
 436    int mode;
 437    const char *volname = (relabel == 1) ? oldname : newname;
 438    char ed1[50];
 439
 440    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 441    Dmsg1(100, "Stole device %s lock, writing label.\n", dev->print_name());
 442
 443
 444    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 445    if (!try_autoload_device(dcr->jcr, dcr, slot, volname)) {
 446       goto bail_out;                  /* error */
 447    }
 448
 449    /* Ensure that the device is open -- autoload_device() closes it */
 450    if (dev->is_tape()) {
 451       mode = OPEN_READ_WRITE;
 452    } else {
 453       mode = CREATE_READ_WRITE;
 454    }
 455
 456    if (relabel) {
 457       dev->truncating = true;         /* let open() know we will truncate it */
 458    }
 459    /* Set old volume name for open if relabeling */
 460    bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
 461    if (dev->open(dcr, mode) < 0) {
 462       dir->fsend(_("3910 Unable to open device %s: ERR=%s\n"),
 463          dev->print_name(), dev->bstrerror());
 464       goto bail_out;
 465    }
 466
 467    /* See what we have for a Volume */
 468    label_status = read_dev_volume_label(dcr);
 469
 470    /* Set new volume name */
 471    bstrncpy(dcr->VolCatInfo.VolCatName, newname, sizeof(dcr->VolCatInfo.VolCatName));
 472    switch(label_status) {
 473    case VOL_NAME_ERROR:
 474    case VOL_VERSION_ERROR:
 475    case VOL_LABEL_ERROR:
 476    case VOL_OK:
 477       if (!relabel) {
 478          dir->fsend(_(
 479             "3920 Cannot label Volume because it is already labeled: \"%s\"\n"),
 480              dev->VolHdr.VolumeName);
 481          break;
 482       }
 483
 484       /* Relabel request. If oldname matches, continue */
 485       if (strcmp(oldname, dev->VolHdr.VolumeName) != 0) {
 486          dir->fsend(_("3921 Wrong volume mounted.\n"));
 487          break;
 488       }
 489       if (dev->label_type != B_BACULA_LABEL) {
 490          dir->fsend(_("3922 Cannot relabel an ANSI/IBM labeled Volume.\n"));
 491          break;
 492       }
 493       /* Fall through wanted! */
 494    case VOL_IO_ERROR:
 495    case VOL_NO_LABEL:
 496       if (!write_new_volume_label_to_dev(dcr, newname, poolname,
 497            relabel, true /* write dvd now */)) {
 498          dir->fsend(_("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 499          break;
 500       }
 501       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 502       /* The following 3000 OK label. string is scanned in ua_label.c */
 503       dir->fsend("3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
 504                  edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
 505                  dev->is_dvd()?1:0, newname, dev->print_name());
 506       break;
 507    case VOL_NO_MEDIA:
 508       dir->fsend(_("3914 Failed to label Volume (no media): ERR=%s\n"), dev->bstrerror());
 509       break;
 510    default:
 511       dir->fsend(_("3913 Cannot label Volume. "
 512 "Unknown status %d from read_volume_label()\n"), label_status);
 513       break;
 514    }
 515
 516 bail_out:
 517    if (!dev->is_open()) {
 518       dev->clear_volhdr();
 519    }
 520    volume_unused(dcr);                   /* no longer using volume */
 521    give_back_device_lock(dev, &hold);
 522    return;
 523 }
 524
 525
 526 /*
 527  * Read the tape label
 528  *
 529  *  Enter with the mutex set
 530  */
 531 static bool read_label(DCR *dcr)
 532 {
 533    int ok;
 534    JCR *jcr = dcr->jcr;
 535    BSOCK *dir = jcr->dir_bsock;
 536    bsteal_lock_t hold;
 537    DEVICE *dev = dcr->dev;
 538
 539    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 540
 541    dcr->VolumeName[0] = 0;
 542    dev->clear_labeled();              /* force read of label */
 543    switch (read_dev_volume_label(dcr)) {
 544    case VOL_OK:
 545       dir->fsend(_("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
 546       ok = true;
 547       break;
 548    default:
 549       dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
 550          dev->print_name(), jcr->errmsg);
 551       ok = false;
 552       break;
 553    }
 554    volume_unused(dcr);
 555    give_back_device_lock(dev, &hold);
 556    return ok;
 557 }
 558
 559 /*
 560  * Searches for device by name, and if found, creates a dcr and
 561  *  returns it.
 562  */
 563 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
 564 {
 565    DEVRES *device;
 566    AUTOCHANGER *changer;
 567    bool found = false;
 568    DCR *dcr = NULL;
 569
 570    unbash_spaces(devname);
 571    foreach_res(device, R_DEVICE) {
 572       /* Find resource, and make sure we were able to open it */
 573       if (strcmp(device->hdr.name, devname.c_str()) == 0) {
 574          if (!device->dev) {
 575             device->dev = init_dev(jcr, device);
 576          }
 577          if (!device->dev) {
 578             Jmsg(jcr, M_WARNING, 0, _("\n"
 579                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 580                  devname.c_str());
 581             continue;
 582          }
 583          Dmsg1(20, "Found device %s\n", device->hdr.name);
 584          found = true;
 585          break;
 586       }
 587    }
 588    if (!found) {
 589       foreach_res(changer, R_AUTOCHANGER) {
 590          /* Find resource, and make sure we were able to open it */
 591          if (strcmp(devname.c_str(), changer->hdr.name) == 0) {
 592             /* Try each device in this AutoChanger */
 593             foreach_alist(device, changer->device) {
 594                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
 595                if (!device->dev) {
 596                   device->dev = init_dev(jcr, device);
 597                }
 598                if (!device->dev) {
 599                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
 600                   Jmsg(jcr, M_WARNING, 0, _("\n"
 601                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 602                        device->hdr.name, devname.c_str());
 603                   continue;
 604                }
 605                if (!device->dev->autoselect) {
 606                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
 607                   continue;              /* device is not available */
 608                }
 609                if (drive < 0 || drive == (int)device->dev->drive_index) {
 610                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
 611                   found = true;
 612                   break;
 613                }
 614                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
 615                   devname.c_str(), drive, (int)device->dev->drive_index);
 616             }
 617             break;                    /* we found it but could not open a device */
 618          }
 619       }
 620    }
 621
 622    if (found) {
 623       Dmsg1(100, "Found device %s\n", device->hdr.name);
 624       dcr = new_dcr(jcr, NULL, device->dev);
 625       dcr->device = device;
 626    }
 627    return dcr;
 628 }
 629
 630
 631 /*
 632  * Mount command from Director
 633  */
 634 static bool mount_cmd(JCR *jcr)
 635 {
 636    POOL_MEM devname;
 637    BSOCK *dir = jcr->dir_bsock;
 638    DEVICE *dev;
 639    DCR *dcr;
 640    int drive;
 641    int slot = 0;
 642    bool ok;
 643
 644    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
 645                &drive, &slot) == 3;
 646    if (!ok) {
 647       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
 648    }
 649    if (ok) {
 650       dcr = find_device(jcr, devname, drive);
 651       if (dcr) {
 652          dev = dcr->dev;
 653          dev->dlock();                 /* Use P to avoid indefinite block */
 654          Dmsg2(100, "mount cmd blocked=%d must_unload=%d\n", dev->blocked(),
 655             dev->must_unload());
 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             clear_thread_id(dev->no_wait_id);
 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             dcr->release_volume();
 921             dir->fsend(_("3022 Device %s released.\n"),
 922                dev->print_name());
 923          }
 924          dev->dunlock();
 925          free_dcr(dcr);
 926       } else {
 927          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 928       }
 929    } else {
 930       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 931       pm_strcpy(jcr->errmsg, dir->msg);
 932       dir->fsend(_("3927 Error scanning release command: %s\n"), jcr->errmsg);
 933    }
 934    dir->signal(BNET_EOD);
 935    return true;
 936 }
 937
 938
 939 static bool bootstrap_cmd(JCR *jcr)
 940 {
 941    return get_bootstrap_file(jcr, jcr->dir_bsock);
 942 }
 943
 944 /*
 945  * Autochanger command from Director
 946  */
 947 static bool changer_cmd(JCR *jcr)
 948 {
 949    POOL_MEM devname;
 950    BSOCK *dir = jcr->dir_bsock;
 951    DEVICE *dev;
 952    DCR *dcr;
 953    const char *cmd = NULL;
 954    bool ok = false;
 955    /*
 956     * A safe_cmd may call autochanger script but does not load/unload
 957     *    slots so it can be done at the same time that the drive is open.
 958     */
 959    bool safe_cmd = false;
 960
 961    if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
 962       cmd = "list";
 963       safe_cmd = ok = true;
 964    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
 965       cmd = "slots";
 966       safe_cmd = ok = true;
 967    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
 968       cmd = "drives";
 969       safe_cmd = ok = true;
 970    }
 971    if (ok) {
 972       dcr = find_device(jcr, devname, -1);
 973       if (dcr) {
 974          dev = dcr->dev;
 975          dev->dlock();                 /* Use P to avoid indefinite block */
 976          if (!dev->device->changer_res) {
 977             dir->fsend(_("3995 Device %s is not an autochanger.\n"),
 978                dev->print_name());
 979          /* Under certain "safe" conditions, we can steal the lock */
 980          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
 981             autochanger_cmd(dcr, dir, cmd);
 982          } else if (dev->is_busy() || dev->is_blocked()) {
 983             send_dir_busy_message(dir, dev);
 984          } else {                     /* device not being used */
 985             autochanger_cmd(dcr, dir, cmd);
 986          }
 987          dev->dunlock();
 988          free_dcr(dcr);
 989       } else {
 990          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 991       }
 992    } else {  /* error on scanf */
 993       pm_strcpy(jcr->errmsg, dir->msg);
 994       dir->fsend(_("3908 Error scanning autocharger drives/list/slots command: %s\n"),
 995          jcr->errmsg);
 996    }
 997    dir->signal(BNET_EOD);
 998    return true;
 999 }
1000
1001 /*
1002  * Read and return the Volume label
1003  */
1004 static bool readlabel_cmd(JCR *jcr)
1005 {
1006    POOL_MEM devname;
1007    BSOCK *dir = jcr->dir_bsock;
1008    DEVICE *dev;
1009    DCR *dcr;
1010    int Slot;
1011    int drive;
1012
1013    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
1014        &Slot, &drive) == 3) {
1015       dcr = find_device(jcr, devname, drive);
1016       if (dcr) {
1017          dev = dcr->dev;
1018          dev->dlock();                 /* Use P to avoid indefinite block */
1019          if (!dev->is_open()) {
1020             read_volume_label(jcr, dcr, dev, Slot);
1021             dev->close();
1022          /* Under certain "safe" conditions, we can steal the lock */
1023          } else if (dev->can_steal_lock()) {
1024             read_volume_label(jcr, dcr, dev, Slot);
1025          } else if (dev->is_busy() || dev->is_blocked()) {
1026             send_dir_busy_message(dir, dev);
1027          } else {                     /* device not being used */
1028             read_volume_label(jcr, dcr, dev, Slot);
1029          }
1030          dev->dunlock();
1031          free_dcr(dcr);
1032       } else {
1033          dir->fsend(_("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
1034       }
1035    } else {
1036       pm_strcpy(jcr->errmsg, dir->msg);
1037       dir->fsend(_("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
1038    }
1039    dir->signal(BNET_EOD);
1040    return true;
1041 }
1042
1043
1044 /*
1045  * Read the tape label
1046  *
1047  *  Enter with the mutex set
1048  */
1049 static void read_volume_label(JCR *jcr, DCR *dcr, DEVICE *dev, int Slot)
1050 {
1051    BSOCK *dir = jcr->dir_bsock;
1052    bsteal_lock_t hold;
1053
1054    dcr->dev = dev;
1055    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1056
1057    if (!try_autoload_device(jcr, dcr, Slot, "")) {
1058       goto bail_out;                  /* error */
1059    }
1060
1061    dev->clear_labeled();              /* force read of label */
1062    switch (read_dev_volume_label(dcr)) {
1063    case VOL_OK:
1064       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1065       dir->fsend(_("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1066       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1067       break;
1068    default:
1069       dir->fsend(_("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1070                  dev->print_name(), jcr->errmsg);
1071       break;
1072    }
1073
1074 bail_out:
1075    give_back_device_lock(dev, &hold);
1076    return;
1077 }
1078
1079 static bool try_autoload_device(JCR *jcr, DCR *dcr, int slot, const char *VolName)
1080 {
1081    BSOCK *dir = jcr->dir_bsock;
1082
1083    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1084    dcr->VolCatInfo.Slot = slot;
1085    dcr->VolCatInfo.InChanger = slot > 0;
1086    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1087       return false;
1088    }
1089    return true;
1090 }
1091
1092 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1093 {
1094    if (dev->is_blocked()) {
1095       switch (dev->blocked()) {
1096       case BST_UNMOUNTED:
1097          dir->fsend(_("3931 Device %s is BLOCKED. user unmounted.\n"),
1098             dev->print_name());
1099          break;
1100       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1101          dir->fsend(_("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1102              dev->print_name());
1103          break;
1104       case BST_WAITING_FOR_SYSOP:
1105          dir->fsend(_("3933 Device %s is BLOCKED waiting for media.\n"),
1106             dev->print_name());
1107          break;
1108       case BST_DOING_ACQUIRE:
1109          dir->fsend(_("3934 Device %s is being initialized.\n"),
1110             dev->print_name());
1111          break;
1112       case BST_WRITING_LABEL:
1113          dir->fsend(_("3935 Device %s is blocked labeling a Volume.\n"),
1114             dev->print_name());
1115          break;
1116       default:
1117          dir->fsend(_("3935 Device %s is blocked for unknown reason.\n"),
1118             dev->print_name());
1119          break;
1120       }
1121    } else if (dev->can_read()) {
1122        dir->fsend(_("3936 Device %s is busy reading.\n"),
1123                    dev->print_name());;
1124    } else {
1125        dir->fsend(_("3937 Device %s is busy with %d writer(s).\n"),
1126           dev->print_name(), dev->num_writers);
1127    }
1128 }