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

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