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