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

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