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