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