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, 2001, 2002 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
  63 /* Forward referenced functions */
  64 static int label_cmd(JCR *jcr);
  65 static int setdebug_cmd(JCR *jcr);
  66 static int cancel_cmd(JCR *cjcr);
  67 static int mount_cmd(JCR *jcr);
  68 static int unmount_cmd(JCR *jcr);
  69 static int status_cmd(JCR *sjcr);
  70 static void label_volume_if_ok(JCR *jcr, DEVICE *dev, char *vname, char *poolname,
  71                                int Slot);
  72 static void send_blocked_status(JCR *jcr, DEVICE *dev);
  73
  74 struct s_cmds {
  75    char *cmd;
  76    int (*func)(JCR *jcr);
  77 };
  78
  79 /*
  80  * The following are the recognized commands from the Director.
  81  */
  82 static struct s_cmds cmds[] = {
  83    {"JobId=",    job_cmd},            /* start Job */
  84    {"setdebug=", setdebug_cmd},       /* set debug level */
  85    {"cancel",    cancel_cmd},
  86    {"label",     label_cmd},          /* label a tape */
  87    {"mount",     mount_cmd},
  88    {"unmount",   unmount_cmd},
  89    {"status",    status_cmd},
  90    {NULL,        NULL}                /* list terminator */
  91 };
  92
  93
  94 /*
  95  * Connection request. We accept connections either from the
  96  *  Director or a Client.
  97  *
  98  * Note, we are running as a seperate thread of the Storage daemon.
  99  *  and it is because a Director has made a connection with
 100  *  us on the "Message" channel.
 101  *
 102  * Basic tasks done here:
 103  *  - Create a JCR record
 104  *  - Authenticate the Director
 105  *  - We wait for a command
 106  *  - We execute the command
 107  *  - We continue or exit depending on the return status
 108  */
 109 void connection_request(void *arg)
 110 {
 111    BSOCK *bs = (BSOCK *)arg;
 112    JCR *jcr;
 113    int i, found, quit;
 114    int bnet_stat = 0;
 115    char name[MAX_NAME_LENGTH];
 116
 117    if (bnet_recv(bs) <= 0) {
 118       Emsg0(M_ERROR, 0, "Connection request failed.\n");
 119       return;
 120    }
 121
 122    /*
 123     * See if this is a File daemon connection
 124     */
 125    if (sscanf(bs->msg, "Hello Start Job %127s calling\n", name) == 1) {
 126       handle_filed_connection(bs, name);
 127       return;
 128    }
 129
 130    jcr = new_jcr(sizeof(JCR), stored_free_jcr);     /* create Job Control Record */
 131    jcr->dir_bsock = bs;               /* save Director bsock */
 132
 133    Dmsg0(1000, "stored in start_job\n");
 134
 135    /*
 136     * Authenticate the Director
 137     */
 138    if (!authenticate_director(jcr)) {
 139       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate Director\n"));
 140       free_jcr(jcr);
 141       return;
 142    }
 143    Dmsg0(90, "Message channel init completed.\n");
 144
 145    for (quit=0; !quit;) {
 146
 147       /* Read command */
 148       if ((bnet_stat = bnet_recv(bs)) <= 0) {
 149          break;                       /* connection terminated */
 150       }
 151       Dmsg1(9, "<dird: %s\n", bs->msg);
 152       found = FALSE;
 153       for (i=0; cmds[i].cmd; i++) {
 154          if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 155             if (!cmds[i].func(jcr)) {    /* do command */
 156                quit = TRUE;              /* error, get out */
 157                Dmsg1(90, "Command %s requsts quit\n", cmds[i].cmd);
 158             }
 159             found = TRUE;            /* indicate command found */
 160             break;
 161          }
 162       }
 163       if (!found) {                   /* command not found */
 164          bnet_fsend(bs, derrmsg);
 165          quit = TRUE;
 166          break;
 167       }
 168    }
 169    if (bnet_stat != BNET_TERMINATE) {
 170       bnet_sig(bs, BNET_TERMINATE);
 171    }
 172    free_jcr(jcr);
 173    return;
 174 }
 175
 176 /*
 177  * Set debug level as requested by the Director
 178  *
 179  */
 180 static int setdebug_cmd(JCR *jcr)
 181 {
 182    BSOCK *dir = jcr->dir_bsock;
 183    int level;
 184
 185    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 186    if (sscanf(dir->msg, "setdebug=%d", &level) != 1 || level < 0) {
 187       bnet_fsend(dir, "3991 Bad setdebug command: %s\n", dir->msg);
 188       return 0;
 189    }
 190    debug_level = level;
 191    return bnet_fsend(dir, OKsetdebug, level);
 192 }
 193
 194
 195 /*
 196  * Cancel a Job
 197  */
 198 static int cancel_cmd(JCR *cjcr)
 199 {
 200    BSOCK *dir = cjcr->dir_bsock;
 201    int oldStatus;
 202    char Job[MAX_NAME_LENGTH];
 203    JCR *jcr;
 204
 205    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 206       if (!(jcr=get_jcr_by_full_name(Job))) {
 207          bnet_fsend(dir, _("3992 Job %s not found.\n"), Job);
 208       } else {
 209          P(jcr->mutex);
 210          oldStatus = jcr->JobStatus;
 211          jcr->JobStatus = JS_Cancelled;
 212          if (!jcr->authenticated && jcr->JobStatus == JS_WaitFD) {
 213             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 214          }
 215          V(jcr->mutex);
 216          if (jcr->file_bsock) {
 217             bnet_sig(jcr->file_bsock, BNET_TERMINATE);
 218          }
 219          bnet_fsend(dir, _("3000 Job %s Status=%c marked to be cancelled.\n"),
 220             jcr->Job, oldStatus);
 221          free_jcr(jcr);
 222       }
 223    } else {
 224       bnet_fsend(dir, _("3993 Error scanning cancel command.\n"));
 225    }
 226    bnet_sig(dir, BNET_EOD);
 227    return 1;
 228 }
 229
 230 /*
 231  * Label a tape
 232  *
 233  */
 234 static int label_cmd(JCR *jcr)
 235 {
 236    POOLMEM *dname, *volname, *poolname, *mtype;
 237    BSOCK *dir = jcr->dir_bsock;
 238    DEVRES *device;
 239    DEVICE *dev;
 240    int found = 0;
 241    int slot;
 242
 243    dname = get_memory(dir->msglen+1);
 244    volname = get_memory(dir->msglen+1);
 245    poolname = get_memory(dir->msglen+1);
 246    mtype = get_memory(dir->msglen+1);
 247    if (sscanf(dir->msg, "label %s VolumeName=%s PoolName=%s MediaType=%s Slot=%d",
 248        dname, volname, poolname, mtype, &slot) == 5) {
 249       unbash_spaces(dname);
 250       unbash_spaces(volname);
 251       unbash_spaces(poolname);
 252       unbash_spaces(mtype);
 253       device = NULL;
 254       LockRes();
 255       while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) {
 256          /* Find resource, and make sure we were able to open it */
 257          if (strcmp(device->hdr.name, dname) == 0 && device->dev) {
 258             Dmsg1(20, "Found device %s\n", device->hdr.name);
 259             found = 1;
 260             break;
 261          }
 262       }
 263       UnlockRes();
 264       if (found) {
 265          /******FIXME**** compare MediaTypes */
 266          jcr->device = device;
 267          dev = device->dev;
 268
 269          P(dev->mutex);               /* Use P to avoid indefinite block */
 270          if (!(dev->state & ST_OPENED)) {
 271             if (open_dev(dev, volname, READ_WRITE) < 0) {
 272                bnet_fsend(dir, _("3994 Connot open device: %s\n"), strerror_dev(dev));
 273             } else {
 274                label_volume_if_ok(jcr, dev, volname, poolname, slot);
 275                force_close_dev(dev);
 276             }
 277          /* Under certain "safe" conditions, we can steal the lock */
 278          } else if (dev->dev_blocked &&
 279                     (dev->dev_blocked == BST_UNMOUNTED ||
 280                      dev->dev_blocked == BST_WAITING_FOR_SYSOP ||
 281                      dev->dev_blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP)) {
 282             label_volume_if_ok(jcr, dev, volname, poolname, slot);
 283          } else if (dev->state & ST_READ || dev->num_writers) {
 284             if (dev->state & ST_READ) {
 285                 bnet_fsend(dir, _("3901 Device %s is busy with 1 reader.\n"),
 286                    dev_name(dev));
 287             } else {
 288                 bnet_fsend(dir, _("3902 Device %s is busy with %d writer(s).\n"),
 289                    dev_name(dev), dev->num_writers);
 290             }
 291          } else {                     /* device not being used */
 292             label_volume_if_ok(jcr, dev, volname, poolname, slot);
 293          }
 294          V(dev->mutex);
 295       } else {
 296          bnet_fsend(dir, _("3999 Device %s not found\n"), dname);
 297       }
 298    } else {
 299       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 300       strcpy(dname, dir->msg);
 301       bnet_fsend(dir, _("3903 Error scanning label command: %s\n"), dname);
 302    }
 303    free_memory(dname);
 304    free_memory(volname);
 305    free_memory(poolname);
 306    free_memory(mtype);
 307    bnet_sig(dir, BNET_EOD);
 308    return 1;
 309 }
 310
 311 /*
 312  * Read the tape label and determine if we can safely
 313  * label the tape (not a Bacula volume), then label it.
 314  *
 315  *  Enter with the mutex set
 316  */
 317 static void label_volume_if_ok(JCR *jcr, DEVICE *dev, char *vname, char *poolname,
 318                                int slot)
 319 {
 320    BSOCK *dir = jcr->dir_bsock;
 321    DEV_BLOCK *block;
 322    bsteal_lock_t hold;
 323
 324    steal_device_lock(dev, &hold, BST_WRITING_LABEL);
 325
 326    strcpy(jcr->VolumeName, vname);
 327    jcr->VolCatInfo.Slot = slot;
 328    autoload_device(jcr, dev, 0, dir);      /* autoload if possible */
 329    block = new_block(dev);
 330
 331    /* Ensure that the device is open -- not autoload_device() closes it */
 332    for ( ; !(dev->state & ST_OPENED); ) {
 333        if (open_dev(dev, jcr->VolumeName, READ_WRITE) < 0) {
 334           if (dev->dev_errno == EAGAIN || dev->dev_errno == EBUSY) {
 335              sleep(30);
 336           }
 337           bnet_fsend(dir, _("3903 Unable to open device %s. ERR=%s\n"),
 338              dev_name(dev), strerror_dev(dev));
 339           goto bail_out;
 340        }
 341    }
 342
 343    /* See what we have for a Volume */
 344    switch (read_dev_volume_label(jcr, dev, block)) {
 345       case VOL_NAME_ERROR:
 346       case VOL_VERSION_ERROR:
 347       case VOL_LABEL_ERROR:
 348       case VOL_OK:
 349          bnet_fsend(dir, _("3901 Cannot label Volume because it is \
 350 already labeled: %s\n"), dev->VolHdr.VolName);
 351          break;
 352       case VOL_IO_ERROR:
 353       case VOL_NO_LABEL:
 354          if (!write_volume_label_to_dev(jcr, jcr->device, vname, poolname)) {
 355             bnet_fsend(dir, _("3903 Failed to label Volume: ERR=%s\n"), strerror_dev(dev));
 356             break;
 357          }
 358          strcpy(jcr->VolumeName, vname);
 359          bnet_fsend(dir, _("3000 OK label. Volume=%s Device=%s\n"),
 360             vname, dev->dev_name);
 361          break;
 362       default:
 363          bnet_fsend(dir, _("3902 Cannot label Volume. \
 364 Unknown status %d from read_volume_label()\n"), jcr->label_status);
 365          break;
 366    }
 367 bail_out:
 368    free_block(block);
 369    return_device_lock(dev, &hold);
 370 }
 371
 372
 373 /*
 374  * Read the tape label
 375  *
 376  *  Enter with the mutex set
 377  */
 378 static int read_label(JCR *jcr, DEVICE *dev)
 379 {
 380    int stat;
 381    BSOCK *dir = jcr->dir_bsock;
 382    DEV_BLOCK *block;
 383 #ifndef NEW_LOCK
 384    bsteal_lock_t hold;
 385
 386    steal_device_lock(dev, &hold, BST_DOING_ACQUIRE);
 387 #endif
 388
 389    jcr->VolumeName[0] = 0;
 390    block = new_block(dev);
 391    dev->state &= ~ST_LABEL;           /* force read of label */
 392    switch (read_dev_volume_label(jcr, dev, block)) {
 393       case VOL_OK:
 394          bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolName);
 395          stat = 1;
 396          break;
 397       default:
 398          bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s\n"),
 399             dev->dev_name, jcr->errmsg);
 400          stat = 0;
 401          break;
 402    }
 403    free_block(block);
 404 #ifndef NEW_LOCK
 405    return_device_lock(dev, &hold);
 406 #endif
 407    return stat;
 408 }
 409
 410 /*
 411  * Mount command from Director
 412  */
 413 static int mount_cmd(JCR *jcr)
 414 {
 415    char *dev_name;
 416    BSOCK *dir = jcr->dir_bsock;
 417    DEVRES *device;
 418    DEVICE *dev;
 419    int found = 0;
 420
 421    dev_name = (char *) get_memory(dir->msglen);
 422    if (sscanf(dir->msg, "mount %s", dev_name) == 1) {
 423       unbash_spaces(dev_name);
 424       device = NULL;
 425       LockRes();
 426       while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) {
 427          /* Find resource, and make sure we were able to open it */
 428          if (strcmp(device->hdr.name, dev_name) == 0 && device->dev) {
 429             Dmsg1(20, "Found device %s\n", device->hdr.name);
 430             found = 1;
 431             break;
 432          }
 433       }
 434       UnlockRes();
 435       if (found) {
 436          jcr->device = device;
 437          dev = device->dev;
 438          P(dev->mutex);               /* Use P to avoid indefinite block */
 439          switch (dev->dev_blocked) {         /* device blocked? */
 440             DEV_BLOCK *block;
 441             case BST_WAITING_FOR_SYSOP:
 442                /* Someone is waiting, wake him */
 443                Dmsg0(90, "Waiting for mount attempt to wake thread\n");
 444                pthread_cond_signal(&dev->wait_next_vol);
 445                bnet_fsend(dir, "3001 OK mount. Device=%s\n", dev->dev_name);
 446                break;
 447
 448             case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 449             case BST_UNMOUNTED:
 450                /* We freed the device, so reopen it and wake any waiting threads */
 451                if (open_dev(dev, NULL, READ_WRITE) < 0) {
 452                   bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 453                      strerror_dev(dev));
 454                   break;
 455                }
 456                block = new_block(dev);
 457                read_dev_volume_label(jcr, dev, block);
 458                free_block(block);
 459                if (dev->dev_blocked == BST_UNMOUNTED) {
 460                   Dmsg0(90, "Unmounted unblocking device\n");
 461                   read_label(jcr, dev);
 462                   unblock_device(dev);
 463                } else {
 464                   Dmsg0(90, "Unmounted waiting for mount attempt to wake thread\n");
 465                   dev->dev_blocked = BST_WAITING_FOR_SYSOP;
 466                   pthread_cond_signal(&dev->wait_next_vol);
 467                }
 468                if (dev->state & ST_LABEL) {
 469                   bnet_fsend(dir, _("3001 Device %s is mounted with Volume %s\n"),
 470                      dev->dev_name, dev->VolHdr.VolName);
 471                } else {
 472                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"),
 473                              dev->dev_name);
 474                }
 475                break;
 476
 477             case BST_DOING_ACQUIRE:
 478                bnet_fsend(dir, _("3001 Device %s is mounted; doing acquire.\n"),
 479                           dev->dev_name);
 480                break;
 481
 482             case BST_WRITING_LABEL:
 483                bnet_fsend(dir, _("3903 Device %s is being labeled.\n"), dev->dev_name);
 484                break;
 485
 486             case BST_NOT_BLOCKED:
 487                if (dev->state & ST_OPENED) {
 488                   if (dev->state & ST_LABEL) {
 489                      bnet_fsend(dir, _("3001 Device %s is mounted with Volume %s\n"),
 490                         dev->dev_name, dev->VolHdr.VolName);
 491                   } else {
 492                      bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"),
 493                                 dev->dev_name);
 494                   }
 495                } else {
 496                   if (!dev_is_tape(dev)) {
 497                      bnet_fsend(dir, _("3906 cannot mount non-tape.\n"));
 498                      break;
 499                   }
 500                   if (open_dev(dev, NULL, READ_WRITE) < 0) {
 501                      bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 502                         strerror_dev(dev));
 503                      break;
 504                   }
 505                   read_label(jcr, dev);
 506                   if (dev->state & ST_LABEL) {
 507                      bnet_fsend(dir, _("3001 Device %s is mounted with Volume %s\n"),
 508                         dev->dev_name, dev->VolHdr.VolName);
 509                   } else {
 510                      bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"),
 511                                 dev->dev_name);
 512                   }
 513                }
 514                break;
 515
 516             default:
 517                bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
 518                break;
 519          }
 520          V(dev->mutex);
 521       } else {
 522          bnet_fsend(dir, _("3999 Device %s not found\n"), dev_name);
 523       }
 524    } else {
 525       strcpy(dev_name, dir->msg);
 526       bnet_fsend(dir, _("3906 Error scanning mount command: %s\n"), dev_name);
 527    }
 528    free_memory(dev_name);
 529    bnet_sig(dir, BNET_EOD);
 530    return 1;
 531 }
 532
 533 /*
 534  * unmount command from Director
 535  */
 536 static int unmount_cmd(JCR *jcr)
 537 {
 538    char *dname;
 539    BSOCK *dir = jcr->dir_bsock;
 540    DEVRES *device;
 541    DEVICE *dev;
 542    int found = 0;
 543
 544    dname = (char *) get_memory(dir->msglen+1);
 545    if (sscanf(dir->msg, "unmount %s", dname) == 1) {
 546       unbash_spaces(dname);
 547       device = NULL;
 548       LockRes();
 549       while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) {
 550          /* Find resource, and make sure we were able to open it */
 551          if (strcmp(device->hdr.name, dname) == 0 && device->dev) {
 552             Dmsg1(20, "Found device %s\n", device->hdr.name);
 553             found = 1;
 554             break;
 555          }
 556       }
 557       UnlockRes();
 558       if (found) {
 559          jcr->device = device;
 560          dev = device->dev;
 561          P(dev->mutex);               /* Use P to avoid indefinite block */
 562          if (!(dev->state & ST_OPENED)) {
 563             Dmsg0(90, "Device already unmounted\n");
 564             bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"), dev_name(dev));
 565
 566          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
 567             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 568                dev->dev_blocked);
 569             if (dev->capabilities & CAP_OFFLINEUNMOUNT) {
 570                offline_dev(dev);
 571             }
 572             force_close_dev(dev);
 573             dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
 574             bnet_fsend(dir, _("3001 Device %s unmounted.\n"), dev_name(dev));
 575
 576          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 577             bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"),
 578                dev_name(dev));
 579
 580          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 581             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 582                dev_name(dev));
 583
 584          } else if (dev->state & ST_READ || dev->num_writers) {
 585             if (dev->state & ST_READ) {
 586                 Dmsg0(90, "Device in read mode\n");
 587                 bnet_fsend(dir, _("3904 Device %s is busy with 1 reader.\n"),
 588                    dev_name(dev));
 589             } else {
 590                 Dmsg1(90, "Device busy with %d writers\n", dev->num_writers);
 591                 bnet_fsend(dir, _("3905 Device %s is busy with %d writer(s).\n"),
 592                    dev_name(dev), dev->num_writers);
 593             }
 594
 595          } else {                     /* device not being used */
 596             Dmsg0(90, "Device not in use, unmounting\n");
 597             block_device(dev, BST_UNMOUNTED);
 598             if (dev->capabilities & CAP_OFFLINEUNMOUNT) {
 599                offline_dev(dev);
 600             }
 601             force_close_dev(dev);
 602             bnet_fsend(dir, _("3002 Device %s unmounted.\n"), dev_name(dev));
 603          }
 604          V(dev->mutex);
 605       } else {
 606          bnet_fsend(dir, _("3999 Device %s not found\n"), dname);
 607       }
 608    } else {
 609       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 610       strcpy(dname, dir->msg);
 611       bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), dname);
 612    }
 613    free_memory(dname);
 614    bnet_sig(dir, BNET_EOD);
 615    return 1;
 616 }
 617
 618 /*
 619  * Status command from Director
 620  */
 621 static int status_cmd(JCR *jcr)
 622 {
 623    DEVRES *device;
 624    DEVICE *dev;
 625    int found, bps, sec, bpb;
 626    BSOCK *user = jcr->dir_bsock;
 627    char dt[MAX_TIME_LENGTH];
 628    char b1[30], b2[30], b3[30];
 629
 630    bnet_fsend(user, "\n%s Version: " VERSION " (" DATE ")\n", my_name);
 631    bstrftime(dt, sizeof(dt), daemon_start_time);
 632    bnet_fsend(user, _("Daemon started %s, %d Job%s run.\n"), dt, last_job.NumJobs,
 633         last_job.NumJobs == 1 ? "" : "s");
 634    if (last_job.NumJobs > 0) {
 635       char termstat[30];
 636
 637       bstrftime(dt, sizeof(dt), last_job.end_time);
 638       bnet_fsend(user, _("Last Job %s finished at %s\n"), last_job.Job, dt);
 639
 640       jobstatus_to_ascii(last_job.JobStatus, termstat, sizeof(termstat));
 641       bnet_fsend(user, _("  Files=%s Bytes=%s Termination Status=%s\n"),
 642            edit_uint64_with_commas(last_job.JobFiles, b1),
 643            edit_uint64_with_commas(last_job.JobBytes, b2),
 644            termstat);
 645    }
 646
 647    LockRes();
 648    for (device=NULL;  (device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device)); ) {
 649       dev = device->dev;
 650       if (dev) {
 651          if (dev->state & ST_OPENED) {
 652             if (dev->state & ST_LABEL) {
 653                bnet_fsend(user, _("Device %s is mounted with Volume %s\n"),
 654                   dev_name(dev), dev->VolHdr.VolName);
 655             } else {
 656                bnet_fsend(user, _("Device %s open but no Bacula volume is mounted.\n"), dev_name(dev));
 657             }
 658             send_blocked_status(jcr, dev);
 659             bpb = dev->VolCatInfo.VolCatBlocks;
 660             if (bpb <= 0) {
 661                bpb = 1;
 662             }
 663             bpb = dev->VolCatInfo.VolCatBytes / bpb;
 664             bnet_fsend(user, _("    Total Bytes=%s Blocks=%s Bytes/block=%s\n"),
 665                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
 666                edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
 667                edit_uint64_with_commas(bpb, b3));
 668             bnet_fsend(user, _("    Positioned at File=%s Block=%s\n"),
 669                edit_uint64_with_commas(dev->file, b1),
 670                edit_uint64_with_commas(dev->block_num, b2));
 671
 672          } else {
 673             bnet_fsend(user, _("Device %s is not open.\n"), dev_name(dev));
 674             send_blocked_status(jcr, dev);
 675          }
 676       }
 677    }
 678    UnlockRes();
 679
 680    found = 0;
 681    lock_jcr_chain();
 682    /* NOTE, we reuse a calling argument jcr. Be warned! */
 683    for (jcr=NULL; (jcr=get_next_jcr(jcr)); ) {
 684       if (jcr->JobStatus == JS_WaitFD) {
 685          bnet_fsend(user, _("%s Job %s waiting for Client connection.\n"),
 686             job_type_to_str(jcr->JobType), jcr->Job);
 687       }
 688       if (jcr->device) {
 689          bnet_fsend(user, _("%s %s job %s is using device %s\n"),
 690                    job_level_to_str(jcr->JobLevel),
 691                    job_type_to_str(jcr->JobType),
 692                    jcr->Job, jcr->device->device_name);
 693          sec = time(NULL) - jcr->run_time;
 694          if (sec <= 0) {
 695             sec = 1;
 696          }
 697          bps = jcr->JobBytes / sec;
 698          bnet_fsend(user, _("    Files=%s Bytes=%s Bytes/sec=%s\n"),
 699             edit_uint64_with_commas(jcr->JobFiles, b1),
 700             edit_uint64_with_commas(jcr->JobBytes, b2),
 701             edit_uint64_with_commas(bps, b3));
 702          found = 1;
 703 #ifdef DEBUG
 704          if (jcr->file_bsock) {
 705             bnet_fsend(user, "    FDReadSeqNo=%" lld " fd=%d\n",
 706                jcr->file_bsock->read_seqno, jcr->file_bsock->fd);
 707          } else {
 708             bnet_fsend(user, "    FDSocket closed\n");
 709          }
 710 #endif
 711       }
 712       free_locked_jcr(jcr);
 713    }
 714    unlock_jcr_chain();
 715    if (!found) {
 716       bnet_fsend(user, _("No jobs running.\n"));
 717    }
 718
 719 #ifdef full_status
 720    bnet_fsend(user, "\n\n");
 721    dump_resource(R_DEVICE, resources[R_DEVICE-r_first].res_head, sendit, user);
 722 #endif
 723    bnet_fsend(user, "====\n");
 724
 725    bnet_sig(user, BNET_EOD);
 726    return 1;
 727 }
 728
 729 static void send_blocked_status(JCR *jcr, DEVICE *dev)
 730 {
 731    BSOCK *user = jcr->dir_bsock;
 732
 733    switch (dev->dev_blocked) {
 734       case BST_UNMOUNTED:
 735          bnet_fsend(user, _("    Device is BLOCKED. User unmounted.\n"));
 736          break;
 737       case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 738          bnet_fsend(user, _("    Device is BLOCKED. User unmounted during wait for media/mount.\n"));
 739          break;
 740       case BST_WAITING_FOR_SYSOP:
 741          if (jcr->JobStatus == JS_WaitMount) {
 742             bnet_fsend(user, _("    Device is BLOCKED waiting for mount.\n"));
 743          } else {
 744             bnet_fsend(user, _("    Device is BLOCKED waiting for appendable media.\n"));
 745          }
 746          break;
 747       case BST_DOING_ACQUIRE:
 748          bnet_fsend(user, _("    Device is being initialized.\n"));
 749          break;
 750       case BST_WRITING_LABEL:
 751          bnet_fsend(user, _("    Device is blocked labeling a Volume.\n"));
 752          break;
 753       default:
 754          break;
 755    }
 756 }