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 == 0) ? newname : oldname;
 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    Dmsg0(90, "try_autoload_device - looking for volume_info\n");
 400    if (relabel && dev->is_dvd()) {
 401       /* Fake at least one partition to ensure that we look for the old volume */
 402       dcr->VolCatInfo.VolCatParts = 1;
 403    }
 404
 405    if (!try_autoload_device(dcr->jcr, slot, volname)) {
 406       goto bail_out;                  /* error */
 407    }
 408
 409    /* Ensure that the device is open -- autoload_device() closes it */
 410    if (dev->is_tape()) {
 411       mode = OPEN_READ_WRITE;
 412    } else {
 413       mode = CREATE_READ_WRITE;
 414    }
 415    if (dev->is_dvd()) {
 416       bstrncpy(dcr->VolCatInfo.VolCatName, volname, sizeof(dcr->VolCatInfo.VolCatName));
 417    }
 418
 419    if (dev->open(dcr, mode) < 0) {
 420       bnet_fsend(dir, _("3910 Unable to open device %s: ERR=%s\n"),
 421          dev->print_name(), dev->strerror());
 422       goto bail_out;
 423    }
 424
 425    /* See what we have for a Volume */
 426    label_status = read_dev_volume_label(dcr);
 427
 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       if (relabel && dev->is_dvd()) {
 450          /* Save dev VolumeName */
 451          bstrncpy(dcr->VolumeName, dev->VolCatInfo.VolCatName, sizeof(dcr->VolumeName));
 452          /* Use new name for DVD truncation */
 453          bstrncpy(dev->VolCatInfo.VolCatName, newname, sizeof(dev->VolCatInfo.VolCatName));
 454          if (!dev->truncate(dcr)) {
 455             bnet_fsend(dir, _("3912 Failed to truncate previous DVD volume.\n"));
 456             /* Restore device VolName */
 457             bstrncpy(dev->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dev->VolCatInfo.VolCatName));
 458             break;
 459          }
 460          /* Restore device VolName */
 461          bstrncpy(dev->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dev->VolCatInfo.VolCatName));
 462       }
 463       free_volume(dev);               /* release old volume name */
 464       /* Fall through wanted! */
 465    case VOL_IO_ERROR:
 466    case VOL_NO_LABEL:
 467       if (!write_new_volume_label_to_dev(dcr, newname, poolname, true /* write dvd now */)) {
 468          bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 469          break;
 470       }
 471       bstrncpy(dcr->VolumeName, newname, sizeof(dcr->VolumeName));
 472       /* The following 3000 OK label. string is scanned in ua_label.c */
 473       bnet_fsend(dir, "3000 OK label. VolBytes=%s DVD=%d Volume=\"%s\" Device=%s\n",
 474                  edit_uint64(dev->VolCatInfo.VolCatBytes, ed1),
 475                  dev->is_dvd()?1:0, newname, dev->print_name());
 476       break;
 477    case VOL_NO_MEDIA:
 478       bnet_fsend(dir, _("3912 Failed to label Volume: ERR=%s\n"), dev->bstrerror());
 479       break;
 480    default:
 481       bnet_fsend(dir, _("3913 Cannot label Volume. "
 482 "Unknown status %d from read_volume_label()\n"), label_status);
 483       break;
 484    }
 485
 486 bail_out:
 487    if (!dev->is_open()) {
 488       free_volume(dev);
 489    }
 490    give_back_device_lock(dev, &hold);
 491    return;
 492 }
 493
 494
 495 /*
 496  * Read the tape label
 497  *
 498  *  Enter with the mutex set
 499  */
 500 static bool read_label(DCR *dcr)
 501 {
 502    int ok;
 503    JCR *jcr = dcr->jcr;
 504    BSOCK *dir = jcr->dir_bsock;
 505    bsteal_lock_t hold;
 506    DEVICE *dev = dcr->dev;
 507
 508    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 509
 510    dcr->VolumeName[0] = 0;
 511    dev->clear_labeled();              /* force read of label */
 512    switch (read_dev_volume_label(dcr)) {
 513    case VOL_OK:
 514       bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolumeName);
 515       ok = true;
 516       break;
 517    default:
 518       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
 519          dev->print_name(), jcr->errmsg);
 520       ok = false;
 521       break;
 522    }
 523    give_back_device_lock(dev, &hold);
 524    return ok;
 525 }
 526
 527 /*
 528  * Searches for device by name, and if found, creates a dcr and
 529  *  returns it.
 530  */
 531 static DCR *find_device(JCR *jcr, POOL_MEM &devname, int drive)
 532 {
 533    DEVRES *device;
 534    AUTOCHANGER *changer;
 535    bool found = false;
 536    DCR *dcr = NULL;
 537
 538    unbash_spaces(devname);
 539    foreach_res(device, R_DEVICE) {
 540       /* Find resource, and make sure we were able to open it */
 541       if (fnmatch(device->hdr.name, devname.c_str(), 0) == 0) {
 542          if (!device->dev) {
 543             device->dev = init_dev(jcr, device);
 544          }
 545          if (!device->dev) {
 546             Jmsg(jcr, M_WARNING, 0, _("\n"
 547                "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 548                  devname.c_str());
 549             continue;
 550          }
 551          Dmsg1(20, "Found device %s\n", device->hdr.name);
 552          found = true;
 553          break;
 554       }
 555    }
 556    if (!found) {
 557       foreach_res(changer, R_AUTOCHANGER) {
 558          /* Find resource, and make sure we were able to open it */
 559          if (fnmatch(devname.c_str(), changer->hdr.name, 0) == 0) {
 560             /* Try each device in this AutoChanger */
 561             foreach_alist(device, changer->device) {
 562                Dmsg1(100, "Try changer device %s\n", device->hdr.name);
 563                if (!device->dev) {
 564                   device->dev = init_dev(jcr, device);
 565                }
 566                if (!device->dev) {
 567                   Dmsg1(100, "Device %s could not be opened. Skipped\n", devname.c_str());
 568                   Jmsg(jcr, M_WARNING, 0, _("\n"
 569                      "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 570                        device->hdr.name, devname.c_str());
 571                   continue;
 572                }
 573                if (!device->dev->autoselect) {
 574                   Dmsg1(100, "Device %s not autoselect skipped.\n", devname.c_str());
 575                   continue;              /* device is not available */
 576                }
 577                if (drive < 0 || drive == (int)device->dev->drive_index) {
 578                   Dmsg1(20, "Found changer device %s\n", device->hdr.name);
 579                   found = true;
 580                   break;
 581                }
 582                Dmsg3(100, "Device %s drive wrong: want=%d got=%d skipping\n",
 583                   devname.c_str(), drive, (int)device->dev->drive_index);
 584             }
 585             break;                    /* we found it but could not open a device */
 586          }
 587       }
 588    }
 589
 590    if (found) {
 591       Dmsg1(100, "Found device %s\n", device->hdr.name);
 592       dcr = new_dcr(jcr, device->dev);
 593       dcr->device = device;
 594       jcr->dcr = dcr;
 595    }
 596    return dcr;
 597 }
 598
 599
 600 /*
 601  * Mount command from Director
 602  */
 603 static bool mount_cmd(JCR *jcr)
 604 {
 605    POOL_MEM devname;
 606    BSOCK *dir = jcr->dir_bsock;
 607    DEVICE *dev;
 608    DCR *dcr;
 609    int drive;
 610    int slot = 0;
 611    bool ok;
 612
 613    ok = sscanf(dir->msg, "mount %127s drive=%d slot=%d", devname.c_str(),
 614                &drive, &slot) == 3;
 615    if (!ok) {
 616       ok = sscanf(dir->msg, "mount %127s drive=%d", devname.c_str(), &drive) == 2;
 617    }
 618    if (ok) {
 619       dcr = find_device(jcr, devname, drive);
 620       if (dcr) {
 621          dev = dcr->dev;
 622          P(dev->mutex);               /* Use P to avoid indefinite block */
 623          Dmsg1(100, "mount cmd blocked=%d\n", dev->dev_blocked);
 624          switch (dev->dev_blocked) {         /* device blocked? */
 625          case BST_WAITING_FOR_SYSOP:
 626             /* Someone is waiting, wake him */
 627             Dmsg0(100, "Waiting for mount. Attempting to wake thread\n");
 628             dev->dev_blocked = BST_MOUNT;
 629             bnet_fsend(dir, "3001 OK mount. Device=%s\n",
 630                dev->print_name());
 631             pthread_cond_broadcast(&dev->wait_next_vol);
 632             pthread_cond_broadcast(&wait_device_release);
 633             break;
 634
 635          /* In both of these two cases, we (the user) unmounted the Volume */
 636          case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 637          case BST_UNMOUNTED:
 638             if (dev->is_autochanger() && slot > 0) {
 639                try_autoload_device(jcr, slot, "");
 640             }
 641             /* We freed the device, so reopen it and wake any waiting threads */
 642             if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 643                bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 644                   dev->bstrerror());
 645                if (dev->dev_blocked == BST_UNMOUNTED) {
 646                   /* We blocked the device, so unblock it */
 647                   Dmsg0(100, "Unmounted. Unblocking device\n");
 648                   unblock_device(dev);
 649                }
 650                break;
 651             }
 652             read_dev_volume_label(dcr);
 653             if (dev->dev_blocked == BST_UNMOUNTED) {
 654                /* We blocked the device, so unblock it */
 655                Dmsg0(100, "Unmounted. Unblocking device\n");
 656                read_label(dcr);       /* this should not be necessary */
 657                unblock_device(dev);
 658             } else {
 659                Dmsg0(100, "Unmounted waiting for mount. Attempting to wake thread\n");
 660                dev->dev_blocked = BST_MOUNT;
 661             }
 662             if (dev->is_labeled()) {
 663                bnet_fsend(dir, _("3001 Device %s is mounted with Volume \"%s\"\n"),
 664                   dev->print_name(), dev->VolHdr.VolumeName);
 665             } else {
 666                bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 667                                  "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 668                           dev->print_name());
 669             }
 670             pthread_cond_broadcast(&dev->wait_next_vol);
 671             pthread_cond_broadcast(&wait_device_release);
 672             break;
 673
 674          case BST_DOING_ACQUIRE:
 675             bnet_fsend(dir, _("3001 Device %s is doing acquire.\n"),
 676                        dev->print_name());
 677             break;
 678
 679          case BST_WRITING_LABEL:
 680             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 681                dev->print_name());
 682             break;
 683
 684          case BST_NOT_BLOCKED:
 685             if (dev->is_autochanger() && slot > 0) {
 686                try_autoload_device(jcr, slot, "");
 687             }
 688             if (dev->is_open()) {
 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             } else if (dev->is_tape()) {
 698                if (dev->open(dcr, OPEN_READ_ONLY) < 0) {
 699                   bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 700                      dev->bstrerror());
 701                   break;
 702                }
 703                read_label(dcr);
 704                if (dev->is_labeled()) {
 705                   bnet_fsend(dir, _("3001 Device %s is already mounted with Volume \"%s\"\n"),
 706                      dev->print_name(), dev->VolHdr.VolumeName);
 707                } else {
 708                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"
 709                                     "If this is not a blank tape, try unmounting and remounting the Volume.\n"),
 710                              dev->print_name());
 711                }
 712             } else if (dev->is_dvd()) {
 713                if (mount_dvd(dev, 1)) {
 714                   bnet_fsend(dir, _("3002 Device %s is mounted.\n"),
 715                      dev->print_name());
 716                } else {
 717                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 718                }
 719             } else { /* must be file */
 720                bnet_fsend(dir, _("3906 File device %s is always mounted.\n"),
 721                   dev->print_name());
 722             }
 723             break;
 724
 725          default:
 726             bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
 727             break;
 728          }
 729          V(dev->mutex);
 730          free_dcr(dcr);
 731          jcr->dcr = NULL;
 732       } else {
 733          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 734       }
 735    } else {
 736       pm_strcpy(jcr->errmsg, dir->msg);
 737       bnet_fsend(dir, _("3909 Error scanning mount command: %s\n"), jcr->errmsg);
 738    }
 739    bnet_sig(dir, BNET_EOD);
 740    return true;
 741 }
 742
 743 /*
 744  * unmount command from Director
 745  */
 746 static bool unmount_cmd(JCR *jcr)
 747 {
 748    POOL_MEM devname;
 749    BSOCK *dir = jcr->dir_bsock;
 750    DEVICE *dev;
 751    DCR *dcr;
 752    int drive;
 753
 754    if (sscanf(dir->msg, "unmount %127s drive=%d", devname.c_str(), &drive) == 2) {
 755       dcr = find_device(jcr, devname, drive);
 756       if (dcr) {
 757          dev = dcr->dev;
 758          P(dev->mutex);               /* Use P to avoid indefinite block */
 759          if (!dev->is_open()) {
 760             if (!dev->is_busy()) {
 761                unload_autochanger(jcr->dcr, -1);
 762             }
 763             if (dev->is_dvd()) {
 764                if (unmount_dvd(dev, 0)) {
 765                   bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
 766                      dev->print_name());
 767                } else {
 768                   bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 769                }
 770             } else {
 771                Dmsg0(90, "Device already unmounted\n");
 772                bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"),
 773                   dev->print_name());
 774             }
 775          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
 776             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 777                dev->dev_blocked);
 778             if (!unload_autochanger(jcr->dcr, -1)) {
 779                dev->close();
 780             }
 781             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
 782                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 783             } else {
 784                dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
 785                bnet_fsend(dir, _("3001 Device %s unmounted.\n"),
 786                   dev->print_name());
 787             }
 788
 789          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 790             bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"),
 791                dev->print_name());
 792
 793          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 794             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 795                dev->print_name());
 796
 797          } else if (dev->is_busy()) {
 798             send_dir_busy_message(dir, dev);
 799          } else {                     /* device not being used */
 800             Dmsg0(90, "Device not in use, unmounting\n");
 801             /* On FreeBSD, I am having ASSERT() failures in block_device()
 802              * and I can only imagine that the thread id that we are
 803              * leaving in no_wait_id is being re-used. So here,
 804              * we simply do it by hand.  Gross, but a solution.
 805              */
 806             /*  block_device(dev, BST_UNMOUNTED); replace with 2 lines below */
 807             dev->dev_blocked = BST_UNMOUNTED;
 808             dev->no_wait_id = 0;
 809             if (!unload_autochanger(jcr->dcr, -1)) {
 810                dev->close();
 811             }
 812             if (dev->is_dvd() && !unmount_dvd(dev, 0)) {
 813                bnet_fsend(dir, _("3907 %s"), dev->bstrerror());
 814             } else {
 815                bnet_fsend(dir, _("3002 Device %s unmounted.\n"),
 816                   dev->print_name());
 817             }
 818          }
 819          V(dev->mutex);
 820          free_dcr(dcr);
 821          jcr->dcr = NULL;
 822       } else {
 823          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 824       }
 825    } else {
 826       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 827       pm_strcpy(jcr->errmsg, dir->msg);
 828       bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), jcr->errmsg);
 829    }
 830    bnet_sig(dir, BNET_EOD);
 831    return true;
 832 }
 833
 834 /*
 835  * Release command from Director. This rewinds the device and if
 836  *   configured does a offline and ensures that Bacula will
 837  *   re-read the label of the tape before continuing. This gives
 838  *   the operator the chance to change the tape anytime before the
 839  *   next job starts.
 840  */
 841 static bool release_cmd(JCR *jcr)
 842 {
 843    POOL_MEM devname;
 844    BSOCK *dir = jcr->dir_bsock;
 845    DEVICE *dev;
 846    DCR *dcr;
 847    int drive;
 848
 849    if (sscanf(dir->msg, "release %127s drive=%d", devname.c_str(), &drive) == 2) {
 850       dcr = find_device(jcr, devname, drive);
 851       if (dcr) {
 852          dev = dcr->dev;
 853          P(dev->mutex);               /* Use P to avoid indefinite block */
 854          if (!dev->is_open()) {
 855             Dmsg0(90, "Device already released\n");
 856             bnet_fsend(dir, _("3921 Device %s already released.\n"),
 857                dev->print_name());
 858
 859          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP ||
 860                     dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP) {
 861             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 862                dev->dev_blocked);
 863             bnet_fsend(dir, _("3922 Device %s waiting for mount.\n"),
 864                dev->print_name());
 865
 866          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 867             bnet_fsend(dir, _("3923 Device %s is busy in acquire.\n"),
 868                dev->print_name());
 869
 870          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 871             bnet_fsend(dir, _("3914 Device %s is being labeled.\n"),
 872                dev->print_name());
 873
 874          } else if (dev->is_busy()) {
 875             send_dir_busy_message(dir, dev);
 876          } else {                     /* device not being used */
 877             Dmsg0(90, "Device not in use, unmounting\n");
 878             release_volume(jcr->dcr);
 879             bnet_fsend(dir, _("3022 Device %s released.\n"),
 880                dev->print_name());
 881          }
 882          V(dev->mutex);
 883          free_dcr(dcr);
 884          jcr->dcr = NULL;
 885       } else {
 886          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 887       }
 888    } else {
 889       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 890       pm_strcpy(jcr->errmsg, dir->msg);
 891       bnet_fsend(dir, _("3927 Error scanning release command: %s\n"), jcr->errmsg);
 892    }
 893    bnet_sig(dir, BNET_EOD);
 894    return true;
 895 }
 896
 897
 898 static bool bootstrap_cmd(JCR *jcr)
 899 {
 900    return get_bootstrap_file(jcr, jcr->dir_bsock);
 901 }
 902
 903 /*
 904  * Autochanger command from Director
 905  */
 906 static bool changer_cmd(JCR *jcr)
 907 {
 908    POOL_MEM devname;
 909    BSOCK *dir = jcr->dir_bsock;
 910    DEVICE *dev;
 911    DCR *dcr;
 912    const char *cmd = NULL;
 913    bool ok = false;
 914    /*
 915     * A safe_cmd may call autochanger script but does not load/unload
 916     *    slots so it can be done at the same time that the drive is open.
 917     */
 918    bool safe_cmd = false;
 919
 920    if (sscanf(dir->msg, "autochanger list %127s", devname.c_str()) == 1) {
 921       cmd = "list";
 922       safe_cmd = ok = true;
 923    } else if (sscanf(dir->msg, "autochanger slots %127s", devname.c_str()) == 1) {
 924       cmd = "slots";
 925       safe_cmd = ok = true;
 926    } else if (sscanf(dir->msg, "autochanger drives %127s", devname.c_str()) == 1) {
 927       cmd = "drives";
 928       safe_cmd = ok = true;
 929    }
 930    if (ok) {
 931       dcr = find_device(jcr, devname, -1);
 932       if (dcr) {
 933          dev = dcr->dev;
 934          P(dev->mutex);               /* Use P to avoid indefinite block */
 935          if (!dev->device->changer_res) {
 936             bnet_fsend(dir, _("3995 Device %s is not an autochanger.\n"),
 937                dev->print_name());
 938          /* Under certain "safe" conditions, we can steal the lock */
 939          } else if (safe_cmd || !dev->is_open() || dev->can_steal_lock()) {
 940             autochanger_cmd(dcr, dir, cmd);
 941          } else if (dev->is_busy() || dev->is_blocked()) {
 942             send_dir_busy_message(dir, dev);
 943          } else {                     /* device not being used */
 944             autochanger_cmd(dcr, dir, cmd);
 945          }
 946          V(dev->mutex);
 947          free_dcr(dcr);
 948          jcr->dcr = NULL;
 949       } else {
 950          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 951       }
 952    } else {  /* error on scanf */
 953       pm_strcpy(jcr->errmsg, dir->msg);
 954       bnet_fsend(dir, _("3908 Error scanning autocharger drives/list/slots command: %s\n"),
 955          jcr->errmsg);
 956    }
 957    bnet_sig(dir, BNET_EOD);
 958    return true;
 959 }
 960
 961 /*
 962  * Read and return the Volume label
 963  */
 964 static bool readlabel_cmd(JCR *jcr)
 965 {
 966    POOL_MEM devname;
 967    BSOCK *dir = jcr->dir_bsock;
 968    DEVICE *dev;
 969    DCR *dcr;
 970    int Slot;
 971    int drive;
 972
 973    if (sscanf(dir->msg, "readlabel %127s Slot=%d drive=%d", devname.c_str(),
 974        &Slot, &drive) == 3) {
 975       dcr = find_device(jcr, devname, drive);
 976       if (dcr) {
 977          dev = dcr->dev;
 978          P(dev->mutex);               /* Use P to avoid indefinite block */
 979          if (!dev->is_open()) {
 980             read_volume_label(jcr, dev, Slot);
 981             dev->close();
 982          /* Under certain "safe" conditions, we can steal the lock */
 983          } else if (dev->can_steal_lock()) {
 984             read_volume_label(jcr, dev, Slot);
 985          } else if (dev->is_busy() || dev->is_blocked()) {
 986             send_dir_busy_message(dir, dev);
 987          } else {                     /* device not being used */
 988             read_volume_label(jcr, dev, Slot);
 989          }
 990          V(dev->mutex);
 991          free_dcr(dcr);
 992          jcr->dcr = NULL;
 993       } else {
 994          bnet_fsend(dir, _("3999 Device \"%s\" not found or could not be opened.\n"), devname.c_str());
 995       }
 996    } else {
 997       pm_strcpy(jcr->errmsg, dir->msg);
 998       bnet_fsend(dir, _("3909 Error scanning readlabel command: %s\n"), jcr->errmsg);
 999    }
1000    bnet_sig(dir, BNET_EOD);
1001    return true;
1002 }
1003
1004
1005 /*
1006  * Read the tape label
1007  *
1008  *  Enter with the mutex set
1009  */
1010 static void read_volume_label(JCR *jcr, DEVICE *dev, int Slot)
1011 {
1012    BSOCK *dir = jcr->dir_bsock;
1013    bsteal_lock_t hold;
1014    DCR *dcr = jcr->dcr;
1015
1016    dcr->dev = dev;
1017    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
1018
1019    if (!try_autoload_device(jcr, Slot, "")) {
1020       goto bail_out;                  /* error */
1021    }
1022
1023    dev->clear_labeled();              /* force read of label */
1024    switch (read_dev_volume_label(dcr)) {
1025    case VOL_OK:
1026       /* DO NOT add quotes around the Volume name. It is scanned in the DIR */
1027       bnet_fsend(dir, _("3001 Volume=%s Slot=%d\n"), dev->VolHdr.VolumeName, Slot);
1028       Dmsg1(100, "Volume: %s\n", dev->VolHdr.VolumeName);
1029       break;
1030    default:
1031       bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device %s because:\n%s"),
1032                  dev->print_name(), jcr->errmsg);
1033       break;
1034    }
1035
1036 bail_out:
1037    give_back_device_lock(dev, &hold);
1038    return;
1039 }
1040
1041 static bool try_autoload_device(JCR *jcr, int slot, const char *VolName)
1042 {
1043    DCR *dcr = jcr->dcr;
1044    BSOCK *dir = jcr->dir_bsock;
1045
1046    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
1047    dcr->VolCatInfo.Slot = slot;
1048    dcr->VolCatInfo.InChanger = slot > 0;
1049    if (autoload_device(dcr, 0, dir) < 0) {    /* autoload if possible */
1050       return false;
1051    }
1052    return true;
1053 }
1054
1055 static void send_dir_busy_message(BSOCK *dir, DEVICE *dev)
1056 {
1057    if (dev->is_blocked()) {
1058       switch (dev->dev_blocked) {
1059       case BST_UNMOUNTED:
1060          bnet_fsend(dir, _("3931 Device %s is BLOCKED. user unmounted.\n"),
1061             dev->print_name());
1062          break;
1063       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
1064          bnet_fsend(dir, _("3932 Device %s is BLOCKED. user unmounted during wait for media/mount.\n"),
1065              dev->print_name());
1066          break;
1067       case BST_WAITING_FOR_SYSOP:
1068          bnet_fsend(dir, _("3933 Device %s is BLOCKED waiting for media.\n"),
1069             dev->print_name());
1070          break;
1071       case BST_DOING_ACQUIRE:
1072          bnet_fsend(dir, _("3934 Device %s is being initialized.\n"),
1073             dev->print_name());
1074          break;
1075       case BST_WRITING_LABEL:
1076          bnet_fsend(dir, _("3935 Device %s is blocked labeling a Volume.\n"),
1077             dev->print_name());
1078          break;
1079       default:
1080          bnet_fsend(dir, _("3935 Device %s is blocked for unknown reason.\n"),
1081             dev->print_name());
1082          break;
1083       }
1084    } else if (dev->can_read()) {
1085        bnet_fsend(dir, _("3936 Device %s is busy reading.\n"),
1086                    dev->print_name());;
1087    } else {
1088        bnet_fsend(dir, _("3937 Device %s is busy with %d writer(s).\n"),
1089           dev->print_name(), dev->num_writers);
1090    }
1091 }