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  *    File daemon commands are handled in fdcmd.c
  10  *
  11  *     Kern Sibbald, May MMI
  12  *
  13  */
  14 /*
  15    Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
  16
  17    This program is free software; you can redistribute it and/or
  18    modify it under the terms of the GNU General Public License as
  19    published by the Free Software Foundation; either version 2 of
  20    the License, or (at your option) any later version.
  21
  22    This program is distributed in the hope that it will be useful,
  23    but WITHOUT ANY WARRANTY; without even the implied warranty of
  24    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  25    General Public License for more details.
  26
  27    You should have received a copy of the GNU General Public
  28    License along with this program; if not, write to the Free
  29    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  30    MA 02111-1307, USA.
  31
  32  */
  33
  34 #include "bacula.h"
  35 #include "stored.h"
  36
  37 /* Exported variables */
  38
  39 /* Imported variables */
  40 extern BSOCK *filed_chan;
  41 extern int r_first, r_last;
  42 extern struct s_res resources[];
  43 extern char my_name[];
  44 extern time_t daemon_start_time;
  45 extern struct s_last_job last_job;
  46
  47 /* Static variables */
  48 static char derrmsg[]       = "3900 Invalid command\n";
  49 static char OKsetdebug[]   = "3000 OK setdebug=%d\n";
  50
  51
  52 /* Imported functions */
  53 extern void terminate_child();
  54 extern int job_cmd(JCR *jcr);
  55
  56 /* Forward referenced functions */
  57 static int label_cmd(JCR *jcr);
  58 static int setdebug_cmd(JCR *jcr);
  59 static int cancel_cmd(JCR *cjcr);
  60 static int mount_cmd(JCR *jcr);
  61 static int unmount_cmd(JCR *jcr);
  62 static int status_cmd(JCR *sjcr);
  63 static void label_volume_if_ok(JCR *jcr, DEVICE *dev, char *vname, char *poolname);
  64
  65 struct s_cmds {
  66    char *cmd;
  67    int (*func)(JCR *jcr);
  68 };
  69
  70 /*
  71  * The following are the recognized commands from the Director.
  72  */
  73 static struct s_cmds cmds[] = {
  74    {"JobId=",    job_cmd},            /* start Job */
  75    {"setdebug=", setdebug_cmd},       /* set debug level */
  76    {"cancel",    cancel_cmd},
  77    {"label",     label_cmd},          /* label a tape */
  78    {"mount",     mount_cmd},
  79    {"unmount",   unmount_cmd},
  80    {"status",    status_cmd},
  81    {NULL,        NULL}                /* list terminator */
  82 };
  83
  84
  85 /*
  86  * Connection request. We accept connections either from the
  87  *  Director or a Client.
  88  *
  89  * Note, we are running as a seperate thread of the Storage daemon.
  90  *  and it is because a Director has made a connection with
  91  *  us on the "Message" channel.
  92  *
  93  * Basic tasks done here:
  94  *  - Create a JCR record
  95  *  - Authenticate the Director
  96  *  - We wait for a command
  97  *  - We execute the command
  98  *  - We continue or exit depending on the return status
  99  */
 100 void connection_request(void *arg)
 101 {
 102    BSOCK *bs = (BSOCK *)arg;
 103    JCR *jcr;
 104    int i, found, quit;
 105    int bnet_stat;
 106    char name[MAX_NAME_LENGTH];
 107
 108    if (bnet_recv(bs) <= 0) {
 109       Emsg0(M_ERROR, 0, "Connection request failed.\n");
 110       return;
 111    }
 112
 113    /*
 114     * See if this is a File daemon connection
 115     */
 116    if (sscanf(bs->msg, "Hello Start Job %127s calling\n", name) == 1) {
 117       handle_filed_connection(bs, name);
 118       return;
 119    }
 120
 121    jcr = new_jcr(sizeof(JCR), stored_free_jcr);     /* create Job Control Record */
 122    jcr->dir_bsock = bs;               /* save Director bsock */
 123
 124    Dmsg0(1000, "stored in start_job\n");
 125
 126    /*
 127     * Authenticate the Director
 128     */
 129    if (!authenticate_director(jcr)) {
 130       Emsg0(M_FATAL, 0, _("Unable to authenticate Director\n"));
 131       free_jcr(jcr);
 132       return;
 133    }
 134    Dmsg0(90, "Message channel init completed.\n");
 135
 136    for (quit=0; !quit;) {
 137
 138       /* Read command */
 139       if ((bnet_stat = bnet_recv(bs)) <= 0) {
 140          break;                       /* connection terminated */
 141       }
 142       Dmsg1(9, "<dird: %s\n", bs->msg);
 143       found = FALSE;
 144       for (i=0; cmds[i].cmd; i++) {
 145          if (strncmp(cmds[i].cmd, bs->msg, strlen(cmds[i].cmd)) == 0) {
 146             if (!cmds[i].func(jcr)) {    /* do command */
 147                quit = TRUE;              /* error, get out */
 148                Dmsg1(90, "Command %s requsts quit\n", cmds[i].cmd);
 149             }
 150             found = TRUE;            /* indicate command found */
 151             break;
 152          }
 153       }
 154       if (!found) {                   /* command not found */
 155          bnet_fsend(bs, derrmsg);
 156          quit = TRUE;
 157          break;
 158       }
 159    }
 160    if (bnet_stat != BNET_TERMINATE) {
 161       bnet_sig(bs, BNET_TERMINATE);
 162    }
 163    free_jcr(jcr);
 164    return;
 165 }
 166
 167 /*
 168  * Set debug level as requested by the Director
 169  *
 170  */
 171 static int setdebug_cmd(JCR *jcr)
 172 {
 173    BSOCK *dir = jcr->dir_bsock;
 174    int level;
 175
 176    Dmsg1(10, "setdebug_cmd: %s", dir->msg);
 177    if (sscanf(dir->msg, "setdebug=%d", &level) != 1 || level < 0) {
 178       bnet_fsend(dir, "3991 Bad setdebug command: %s\n", dir->msg);
 179       return 0;
 180    }
 181    debug_level = level;
 182    return bnet_fsend(dir, OKsetdebug, level);
 183 }
 184
 185
 186 /*
 187  * Cancel a Job
 188  */
 189 static int cancel_cmd(JCR *cjcr)
 190 {
 191    BSOCK *dir = cjcr->dir_bsock;
 192    int oldStatus;
 193    char Job[MAX_NAME_LENGTH];
 194    JCR *jcr;
 195
 196    if (sscanf(dir->msg, "cancel Job=%127s", Job) == 1) {
 197       if (!(jcr=get_jcr_by_full_name(Job))) {
 198          bnet_fsend(dir, _("3992 Job %s not found.\n"), Job);
 199       } else {
 200          P(jcr->mutex);
 201          oldStatus = jcr->JobStatus;
 202          jcr->JobStatus = JS_Cancelled;
 203          if (!jcr->authenticated && jcr->JobStatus == JS_WaitFD) {
 204             pthread_cond_signal(&jcr->job_start_wait); /* wake waiting thread */
 205          }
 206          V(jcr->mutex);
 207          if (jcr->file_bsock) {
 208             bnet_sig(jcr->file_bsock, BNET_TERMINATE);
 209          }
 210          bnet_fsend(dir, _("3000 Job %s Status=%c marked to be cancelled.\n"),
 211             jcr->Job, oldStatus);
 212          free_jcr(jcr);
 213       }
 214    } else {
 215       bnet_fsend(dir, _("3993 Error scanning cancel command.\n"));
 216    }
 217    bnet_sig(dir, BNET_EOF);
 218    return 1;
 219 }
 220
 221 /*
 222  * Label a tape
 223  *
 224  */
 225 static int label_cmd(JCR *jcr)
 226 {
 227    char *dname, *volname, *poolname, *mtype;
 228    BSOCK *dir = jcr->dir_bsock;
 229    DEVRES *device;
 230    DEVICE *dev;
 231    int found = 0;
 232
 233    dname = (char *) get_memory(dir->msglen+1);
 234    volname = (char *) get_memory(dir->msglen+1);
 235    poolname = (char *) get_memory(dir->msglen+1);
 236    mtype = (char *) get_memory(dir->msglen+1);
 237    if (sscanf(dir->msg, "label %s VolumeName=%s PoolName=%s MediaType=%s",
 238        dname, volname, poolname, mtype) == 4) {
 239       unbash_spaces(dname);
 240       unbash_spaces(volname);
 241       unbash_spaces(poolname);
 242       unbash_spaces(mtype);
 243       device = NULL;
 244       LockRes();
 245       while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) {
 246          /* Find resource, and make sure we were able to open it */
 247          if (strcmp(device->hdr.name, dname) == 0 && device->dev) {
 248             Dmsg1(20, "Found device %s\n", device->hdr.name);
 249             found = 1;
 250             break;
 251          }
 252       }
 253       UnlockRes();
 254       if (found) {
 255          /******FIXME**** compare MediaTypes */
 256          jcr->device = device;
 257          dev = device->dev;
 258          P(dev->mutex);
 259          if (!(dev->state & ST_OPENED)) {
 260             if (open_dev(dev, volname, READ_WRITE) < 0) {
 261                bnet_fsend(dir, _("3994 Connot open device: %s\n"), strerror_dev(dev));
 262             } else {
 263                label_volume_if_ok(jcr, dev, volname, poolname);
 264                force_close_dev(dev);
 265             }
 266          } else if (dev->dev_blocked &&
 267                     dev->dev_blocked != BST_DOING_ACQUIRE) {  /* device blocked? */
 268             label_volume_if_ok(jcr, dev, volname, poolname);
 269          } else if (dev->state & ST_READ || dev->num_writers) {
 270             if (dev->state & ST_READ) {
 271                 bnet_fsend(dir, _("3901 Device %s is busy with 1 reader.\n"),
 272                    dev_name(dev));
 273             } else {
 274                 bnet_fsend(dir, _("3902 Device %s is busy with %d writer(s).\n"),
 275                    dev_name(dev), dev->num_writers);
 276             }
 277          } else {                     /* device not being used */
 278             label_volume_if_ok(jcr, dev, volname, poolname);
 279          }
 280          V(dev->mutex);
 281       } else {
 282          bnet_fsend(dir, _("3999 Device %s not found\n"), dname);
 283       }
 284    } else {
 285       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 286       strcpy(dname, dir->msg);
 287       bnet_fsend(dir, _("3903 Error scanning label command: %s\n"), dname);
 288    }
 289    free_memory(dname);
 290    free_memory(volname);
 291    free_memory(poolname);
 292    free_memory(mtype);
 293    bnet_sig(dir, BNET_EOF);
 294    return 1;
 295 }
 296
 297 /*
 298  * Read the tape label and determine if we can safely
 299  * label the tape (not a Bacula volume), then label it.
 300  *
 301  *  Enter with the mutex set
 302  */
 303 static void label_volume_if_ok(JCR *jcr, DEVICE *dev, char *vname, char *poolname)
 304 {
 305    BSOCK *dir = jcr->dir_bsock;
 306    DEV_BLOCK *block;
 307    int blocked;
 308    pthread_t no_wait_id;
 309
 310    blocked = dev->dev_blocked;        /* save any prev blocked state */
 311    no_wait_id = dev->no_wait_id;
 312    dev->dev_blocked = BST_WRITING_LABEL;
 313    dev->no_wait_id = pthread_self();  /* let us use the tape */
 314    V(dev->mutex);                     /* release lock */
 315
 316    strcpy(jcr->VolumeName, vname);
 317    block = new_block(dev);
 318    switch (read_dev_volume_label(jcr, dev, block)) {
 319       case VOL_NAME_ERROR:
 320       case VOL_VERSION_ERROR:
 321       case VOL_LABEL_ERROR:
 322       case VOL_OK:
 323          bnet_fsend(dir, _("3901 Cannot label Volume because it is \
 324 already labeled: %s\n"), dev->VolHdr.VolName);
 325          break;
 326       case VOL_IO_ERROR:
 327       case VOL_NO_LABEL:
 328          write_volume_label_to_dev(jcr, jcr->device, vname, poolname);
 329          strcpy(jcr->VolumeName, vname);
 330          bnet_fsend(dir, _("3000 OK label. Volume=%s Device=%s\n"),
 331             vname, dev->dev_name);
 332          break;
 333       default:
 334          bnet_fsend(dir, _("3902 Cannot label Volume. \
 335 Unknown status %d from read_volume_label()\n"), jcr->label_status);
 336          break;
 337    }
 338    free_block(block);
 339    P(dev->mutex);
 340    dev->dev_blocked = blocked;        /* reset blocked state */
 341    dev->no_wait_id = no_wait_id;      /* reset blocking thread id */
 342 }
 343
 344
 345 /*
 346  * Read the tape label
 347  *
 348  *  Enter with the mutex set
 349  */
 350 static int read_label(JCR *jcr, DEVICE *dev)
 351 {
 352    BSOCK *dir = jcr->dir_bsock;
 353    DEV_BLOCK *block;
 354    int blocked;
 355    pthread_t no_wait_id;
 356    int stat;
 357
 358    blocked = dev->dev_blocked;        /* save any prev blocked state */
 359    no_wait_id = dev->no_wait_id;
 360    dev->dev_blocked = BST_DOING_ACQUIRE;
 361    dev->no_wait_id = pthread_self();  /* let us use the tape */
 362    V(dev->mutex);                     /* release lock */
 363
 364    jcr->VolumeName[0] = 0;
 365    block = new_block(dev);
 366    dev->state &= ~ST_LABEL;           /* force read of label */
 367    switch (read_dev_volume_label(jcr, dev, block)) {
 368       case VOL_OK:
 369          bnet_fsend(dir, _("3001 Mounted Volume: %s\n"), dev->VolHdr.VolName);
 370          stat = 1;
 371          break;
 372       default:
 373          bnet_fsend(dir, _("3902 Cannot mount Volume on Storage Device \"%s\" because:\n%s\n"),
 374             dev->dev_name, jcr->errmsg);
 375          stat = 0;
 376          break;
 377    }
 378    free_block(block);
 379    P(dev->mutex);
 380    dev->dev_blocked = blocked;        /* reset blocked state */
 381    dev->no_wait_id = no_wait_id;      /* reset blocking thread id */
 382    return stat;
 383 }
 384
 385 /*
 386  * Mount command from Director
 387  */
 388 static int mount_cmd(JCR *jcr)
 389 {
 390    char *dev_name;
 391    BSOCK *dir = jcr->dir_bsock;
 392    DEVRES *device;
 393    DEVICE *dev;
 394    int found = 0;
 395
 396    dev_name = (char *) get_memory(dir->msglen);
 397    if (sscanf(dir->msg, "mount %s", dev_name) == 1) {
 398       unbash_spaces(dev_name);
 399       device = NULL;
 400       LockRes();
 401       while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) {
 402          /* Find resource, and make sure we were able to open it */
 403          if (strcmp(device->hdr.name, dev_name) == 0 && device->dev) {
 404             Dmsg1(20, "Found device %s\n", device->hdr.name);
 405             found = 1;
 406             break;
 407          }
 408       }
 409       UnlockRes();
 410       if (found) {
 411          jcr->device = device;
 412          dev = device->dev;
 413          P(dev->mutex);
 414          switch (dev->dev_blocked) {         /* device blocked? */
 415             DEV_BLOCK *block;
 416             case BST_WAITING_FOR_SYSOP:
 417                /* Someone is waiting, wake him */
 418                Dmsg0(90, "Waiting for mount attempt to wake thread\n");
 419                pthread_cond_signal(&dev->wait_next_vol);
 420                bnet_fsend(dir, "3001 OK mount. Device=%s\n", dev->dev_name);
 421                break;
 422
 423             case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 424             case BST_UNMOUNTED:
 425                /* We freed the device, so reopen it and wake any waiting threads */
 426                if (open_dev(dev, NULL, READ_WRITE) < 0) {
 427                   bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 428                      strerror_dev(dev));
 429                   break;
 430                }
 431                block = new_block(dev);
 432                read_dev_volume_label(jcr, dev, block);
 433                free_block(block);
 434                if (dev->dev_blocked == BST_UNMOUNTED) {
 435                   Dmsg0(90, "Unmounted unblocking device\n");
 436                   read_label(jcr, dev);
 437                   unblock_device(dev);
 438                } else {
 439                   Dmsg0(90, "Unmounted waiting for mount attempt to wake thread\n");
 440                   dev->dev_blocked = BST_WAITING_FOR_SYSOP;
 441                   pthread_cond_signal(&dev->wait_next_vol);
 442                }
 443                if (dev->state & ST_LABEL) {
 444                   bnet_fsend(dir, _("3001 Device %s is mounted with Volume %s\n"),
 445                      dev->dev_name, dev->VolHdr.VolName);
 446                } else {
 447                   bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"),
 448                              dev->dev_name);
 449                }
 450                break;
 451
 452             case BST_DOING_ACQUIRE:
 453                bnet_fsend(dir, _("3001 Device %s is mounted; doing acquire.\n"),
 454                           dev->dev_name);
 455                break;
 456
 457             case BST_WRITING_LABEL:
 458                bnet_fsend(dir, _("3903 Device %s is being labeled.\n"), dev->dev_name);
 459                break;
 460
 461             case BST_NOT_BLOCKED:
 462                if (dev->state & ST_OPENED) {
 463                   if (dev->state & ST_LABEL) {
 464                      bnet_fsend(dir, _("3001 Device %s is mounted with Volume %s\n"),
 465                         dev->dev_name, dev->VolHdr.VolName);
 466                   } else {
 467                      bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"),
 468                                 dev->dev_name);
 469                   }
 470                } else {
 471                   if (!dev_is_tape(dev)) {
 472                      bnet_fsend(dir, _("3906 cannot mount non-tape.\n"));
 473                      break;
 474                   }
 475                   if (open_dev(dev, NULL, READ_WRITE) < 0) {
 476                      bnet_fsend(dir, _("3901 open device failed: ERR=%s\n"),
 477                         strerror_dev(dev));
 478                      break;
 479                   }
 480                   read_label(jcr, dev);
 481                   if (dev->state & ST_LABEL) {
 482                      bnet_fsend(dir, _("3001 Device %s is mounted with Volume %s\n"),
 483                         dev->dev_name, dev->VolHdr.VolName);
 484                   } else {
 485                      bnet_fsend(dir, _("3905 Device %s open but no Bacula volume is mounted.\n"),
 486                                 dev->dev_name);
 487                   }
 488                }
 489                break;
 490
 491             default:
 492                bnet_fsend(dir, _("3905 Bizarre wait state %d\n"), dev->dev_blocked);
 493                break;
 494          }
 495          V(dev->mutex);
 496       } else {
 497          bnet_fsend(dir, _("3999 Device %s not found\n"), dev_name);
 498       }
 499    } else {
 500       strcpy(dev_name, dir->msg);
 501       bnet_fsend(dir, _("3906 Error scanning mount command: %s\n"), dev_name);
 502    }
 503    free_memory(dev_name);
 504    bnet_sig(dir, BNET_EOF);
 505    return 1;
 506 }
 507
 508 /*
 509  * unmount command from Director
 510  */
 511 static int unmount_cmd(JCR *jcr)
 512 {
 513    char *dname;
 514    BSOCK *dir = jcr->dir_bsock;
 515    DEVRES *device;
 516    DEVICE *dev;
 517    int found = 0;
 518
 519    dname = (char *) get_memory(dir->msglen+1);
 520    if (sscanf(dir->msg, "unmount %s", dname) == 1) {
 521       unbash_spaces(dname);
 522       device = NULL;
 523       LockRes();
 524       while ((device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device))) {
 525          /* Find resource, and make sure we were able to open it */
 526          if (strcmp(device->hdr.name, dname) == 0 && device->dev) {
 527             Dmsg1(20, "Found device %s\n", device->hdr.name);
 528             found = 1;
 529             break;
 530          }
 531       }
 532       UnlockRes();
 533       if (found) {
 534          jcr->device = device;
 535          dev = device->dev;
 536          P(dev->mutex);
 537          if (!(dev->state & ST_OPENED)) {
 538             Dmsg0(90, "Device already unmounted\n");
 539             bnet_fsend(dir, _("3901 Device %s is already unmounted.\n"), dev_name(dev));
 540
 541          } else if (dev->dev_blocked == BST_WAITING_FOR_SYSOP) {
 542             Dmsg2(90, "%d waiter dev_block=%d. doing unmount\n", dev->num_waiting,
 543                dev->dev_blocked);
 544             force_close_dev(dev);
 545             dev->dev_blocked = BST_UNMOUNTED_WAITING_FOR_SYSOP;
 546             bnet_fsend(dir, _("3001 Device %s unmounted.\n"), dev_name(dev));
 547
 548          } else if (dev->dev_blocked == BST_DOING_ACQUIRE) {
 549             bnet_fsend(dir, _("3902 Device %s is busy in acquire.\n"),
 550                dev_name(dev));
 551
 552          } else if (dev->dev_blocked == BST_WRITING_LABEL) {
 553             bnet_fsend(dir, _("3903 Device %s is being labeled.\n"),
 554                dev_name(dev));
 555
 556          } else if (dev->state & ST_READ || dev->num_writers) {
 557             if (dev->state & ST_READ) {
 558                 Dmsg0(90, "Device in read mode\n");
 559                 bnet_fsend(dir, _("3904 Device %s is busy with 1 reader.\n"),
 560                    dev_name(dev));
 561             } else {
 562                 Dmsg1(90, "Device busy with %d writers\n", dev->num_writers);
 563                 bnet_fsend(dir, _("3905 Device %s is busy with %d writer(s).\n"),
 564                    dev_name(dev), dev->num_writers);
 565             }
 566
 567          } else {                     /* device not being used */
 568             Dmsg0(90, "Device not in use, unmounting\n");
 569             block_device(dev, BST_UNMOUNTED);
 570             force_close_dev(dev);
 571             bnet_fsend(dir, _("3002 Device %s unmounted.\n"), dev_name(dev));
 572          }
 573          V(dev->mutex);
 574       } else {
 575          bnet_fsend(dir, _("3999 Device %s not found\n"), dname);
 576       }
 577    } else {
 578       /* NB dir->msg gets clobbered in bnet_fsend, so save command */
 579       strcpy(dname, dir->msg);
 580       bnet_fsend(dir, _("3907 Error scanning unmount command: %s\n"), dname);
 581    }
 582    free_memory(dname);
 583    bnet_sig(dir, BNET_EOF);
 584    return 1;
 585 }
 586
 587 /*
 588  * Status command from Director
 589  */
 590 static int status_cmd(JCR *jcr)
 591 {
 592    DEVRES *device;
 593    DEVICE *dev;
 594    int found, bps, sec, bpb;
 595    BSOCK *user = jcr->dir_bsock;
 596    char dt[MAX_TIME_LENGTH];
 597    char b1[30], b2[30], b3[30];
 598
 599    bnet_fsend(user, "\n%s Version: " VERSION " (" DATE ")\n", my_name);
 600    bstrftime(dt, sizeof(dt), daemon_start_time);
 601    bnet_fsend(user, _("Daemon started %s, %d Job%s run.\n"), dt, last_job.NumJobs,
 602         last_job.NumJobs == 1 ? "" : "s");
 603    if (last_job.NumJobs > 0) {
 604       char *termstat, jstat[2];
 605
 606       bstrftime(dt, sizeof(dt), last_job.end_time);
 607       bnet_fsend(user, _("Last Job %s finished at %s\n"), last_job.Job, dt);
 608       switch (last_job.JobStatus) {
 609          case JS_Terminated:
 610             termstat = _("OK");
 611             break;
 612         case JS_ErrorTerminated:
 613             termstat = _("Error");
 614             break;
 615         default:
 616             jstat[0] = last_job.JobStatus;
 617             jstat[1] = 0;
 618             termstat = jstat;
 619             break;
 620       }
 621
 622       bnet_fsend(user, _("  Files=%s Bytes=%s Termination Status=%s\n"),
 623            edit_uint64_with_commas(last_job.JobFiles, b1),
 624            edit_uint64_with_commas(last_job.JobBytes, b2),
 625            termstat);
 626    }
 627
 628    LockRes();
 629    for (device=NULL;  (device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device)); ) {
 630       dev = device->dev;
 631       if (dev) {
 632          if (dev->state & ST_OPENED) {
 633             if (dev->state & ST_LABEL) {
 634                bnet_fsend(user, _("Device %s is mounted with Volume %s\n"),
 635                   dev_name(dev), dev->VolHdr.VolName);
 636             } else {
 637                bnet_fsend(user, _("Device %s open but no Bacula volume is mounted.\n"), dev_name(dev));
 638             }
 639             switch (dev->dev_blocked) {
 640                case BST_UNMOUNTED:
 641                   bnet_fsend(user, _("    Deviced is blocked. User unmounted.\n"));
 642                   break;
 643                case BST_UNMOUNTED_WAITING_FOR_SYSOP:
 644                   bnet_fsend(user, _("    Deviced is blocked. User unmounted during wait for media/mount.\n"));
 645                   break;
 646                case BST_WAITING_FOR_SYSOP:
 647                   if (jcr->JobStatus == JS_WaitMount) {
 648                      bnet_fsend(user, _("    Device is blocked waiting for mount.\n"));
 649                   } else {
 650                      bnet_fsend(user, _("    Device is blocked waiting for appendable media.\n"));
 651                   }
 652                   break;
 653                case BST_DOING_ACQUIRE:
 654                   bnet_fsend(user, _("    Device is being initialized.\n"));
 655                   break;
 656                case BST_WRITING_LABEL:
 657                   bnet_fsend(user, _("    Device is blocked labeling a Volume.\n"));
 658                   break;
 659                default:
 660                   break;
 661             }
 662             bpb = dev->VolCatInfo.VolCatBlocks;
 663             if (bpb <= 0) {
 664                bpb = 1;
 665             }
 666             bpb = dev->VolCatInfo.VolCatBytes / bpb;
 667             bnet_fsend(user, _("    Total Bytes=%s Blocks=%s Bytes/block=%s\n"),
 668                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
 669                edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
 670                edit_uint64_with_commas(bpb, b3));
 671             bnet_fsend(user, _("    Positioned at File=%s Block=%s\n"),
 672                edit_uint64_with_commas(dev->file, b1),
 673                edit_uint64_with_commas(dev->block_num, b2));
 674
 675          } else {
 676             bnet_fsend(user, _("Device %s is not open.\n"), dev_name(dev));
 677          }
 678       }
 679    }
 680    UnlockRes();
 681
 682    found = 0;
 683    lock_jcr_chain();
 684    /* NOTE, we reuse a calling argument jcr. Be warned! */
 685    for (jcr=NULL; (jcr=get_next_jcr(jcr)); ) {
 686       if (jcr->JobStatus == JS_WaitFD) {
 687          bnet_fsend(user, _("Job %s is waiting for the Client connection.\n"),
 688             jcr->Job);
 689       }
 690       if (jcr->device) {
 691          bnet_fsend(user, _("Job %s is using device %s\n"),
 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_EOF);
 726    return 1;
 727 }