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