git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/getmsg.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *   Bacula Director -- routines to receive network data and
  31  *    handle network signals. These routines handle the connections
  32  *    to the Storage daemon and the File daemon.
  33  *
  34  *     Kern Sibbald, August MM
  35  *
  36  *    This routine runs as a thread and must be thread reentrant.
  37  *
  38  *  Basic tasks done here:
  39  *    Handle  network signals (signals).
  40  *       Signals always have return status 0 from bnet_recv() and
  41  *       a zero or negative message length.
  42  *    Pass appropriate messages back to the caller (responses).
  43  *       Responses always have a digit as the first character.
  44  *    Handle requests for message and catalog services (requests).
  45  *       Requests are any message that does not begin with a digit.
  46  *       In affect, they are commands.
  47  *
  48  *   Version $Id$
  49  */
  50
  51 #include "bacula.h"
  52 #include "dird.h"
  53
  54 /* Forward referenced functions */
  55 static char *find_msg_start(char *msg);
  56
  57 static char Job_status[] = "Status Job=%127s JobStatus=%d\n";
  58 #ifdef needed
  59 static char Device_update[]   = "DevUpd Job=%127s "
  60    "device=%127s "
  61    "append=%d read=%d num_writers=%d "
  62    "open=%d labeled=%d offline=%d "
  63    "reserved=%d max_writers=%d "
  64    "autoselect=%d autochanger=%d "
  65    "changer_name=%127s media_type=%127s volume_name=%127s "
  66    "DevReadTime=%d DevWriteTime=%d DevReadBytes=%d "
  67    "DevWriteBytes=%d\n";
  68 #endif
  69
  70
  71 static char OK_msg[] = "1000 OK\n";
  72
  73
  74 void set_jcr_sd_job_status(JCR *jcr, int SDJobStatus)
  75 {
  76    bool set_waittime=false;
  77    Dmsg2(800, "set_jcr_sd_job_status(%s, %c)\n", jcr->Job, SDJobStatus);
  78    /* if wait state is new, we keep current time for watchdog MaxWaitTime */
  79    switch (SDJobStatus) {
  80       case JS_WaitMedia:
  81       case JS_WaitMount:
  82       case JS_WaitMaxJobs:
  83          set_waittime = true;
  84       default:
  85          break;
  86    }
  87
  88    if (job_waiting(jcr)) {
  89       set_waittime = false;
  90    }
  91
  92    if (set_waittime) {
  93       /* set it before JobStatus */
  94       Dmsg0(800, "Setting wait_time\n");
  95       jcr->wait_time = time(NULL);
  96    }
  97    jcr->SDJobStatus = SDJobStatus;
  98 }
  99
 100 /*
 101  * Get a message
 102  *  Call appropriate processing routine
 103  *  If it is not a Jmsg or a ReqCat message,
 104  *   return it to the caller.
 105  *
 106  *  This routine is called to get the next message from
 107  *  another daemon. If the message is in canonical message
 108  *  format and the type is known, it will be dispatched
 109  *  to the appropriate handler.  If the message is
 110  *  in any other format, it will be returned.
 111  *
 112  *  E.g. any message beginning with a digit will be passed
 113  *       through to the caller.
 114  *  All other messages are expected begin with some identifier
 115  *    -- for the moment only the first character is checked, but
 116  *    at a later time, the whole identifier (e.g. Jmsg, CatReq, ...)
 117  *    could be checked. This is followed by Job=Jobname <user-defined>
 118  *    info. The identifier is used to dispatch the message to the right
 119  *    place (Job message, catalog request, ...). The Job is used to lookup
 120  *    the JCR so that the action is performed on the correct jcr, and
 121  *    the rest of the message is up to the user.  Note, DevUpd uses
 122  *    *System* for the Job name, and hence no JCR is obtained. This
 123  *    is a *rare* case where a jcr is not really needed.
 124  *
 125  */
 126 int bget_dirmsg(BSOCK *bs)
 127 {
 128    int32_t n;
 129    char Job[MAX_NAME_LENGTH];
 130    char MsgType[20];
 131    int type, level;
 132    JCR *jcr;
 133    char *msg;
 134
 135    for (;;) {
 136       n = bs->recv();
 137       Dmsg2(100, "bget_dirmsg %d: %s\n", n, bs->msg);
 138
 139       if (is_bnet_stop(bs)) {
 140          return n;                    /* error or terminate */
 141       }
 142       if (n == BNET_SIGNAL) {          /* handle signal */
 143          /* BNET_SIGNAL (-1) return from bnet_recv() => network signal */
 144          switch (bs->msglen) {
 145          case BNET_EOD:            /* end of data */
 146             return n;
 147          case BNET_EOD_POLL:
 148             bs->fsend(OK_msg);/* send response */
 149             return n;              /* end of data */
 150          case BNET_TERMINATE:
 151             bs->set_terminated();
 152             return n;
 153          case BNET_POLL:
 154             bs->fsend(OK_msg); /* send response */
 155             break;
 156          case BNET_HEARTBEAT:
 157 //          encode_time(time(NULL), Job);
 158 //          Dmsg1(100, "%s got heartbeat.\n", Job);
 159             break;
 160          case BNET_HB_RESPONSE:
 161             break;
 162          case BNET_STATUS:
 163             /* *****FIXME***** Implement more completely */
 164             bs->fsend("Status OK\n");
 165             bs->signal(BNET_EOD);
 166             break;
 167          case BNET_BTIME:             /* send Bacula time */
 168             char ed1[50];
 169             bs->fsend("btime %s\n", edit_uint64(get_current_btime(),ed1));
 170             break;
 171          default:
 172             Emsg1(M_WARNING, 0, _("bget_dirmsg: unknown bnet signal %d\n"), bs->msglen);
 173             return n;
 174          }
 175          continue;
 176       }
 177
 178       /* Handle normal data */
 179
 180       if (n > 0 && B_ISDIGIT(bs->msg[0])) {      /* response? */
 181          return n;                    /* yes, return it */
 182       }
 183
 184       /*
 185        * If we get here, it must be a request.  Either
 186        *  a message to dispatch, or a catalog request.
 187        *  Try to fulfill it.
 188        */
 189       if (sscanf(bs->msg, "%020s Job=%127s ", MsgType, Job) != 2) {
 190          Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 191          continue;
 192       }
 193       if (strcmp(Job, "*System*") == 0) {
 194          jcr = NULL;                  /* No jcr */
 195       } else if (!(jcr=get_jcr_by_full_name(Job))) {
 196          Emsg1(M_ERROR, 0, _("Job not found: %s\n"), bs->msg);
 197          continue;
 198       }
 199       Dmsg1(900, "Getmsg got jcr 0x%x\n", jcr);
 200
 201       /* Skip past "Jmsg Job=nnn" */
 202       if (!(msg=find_msg_start(bs->msg))) {
 203          Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 204          free_jcr(jcr);
 205          continue;
 206       }
 207
 208       /*
 209        * Here we are expecting a message of the following format:
 210        *   Jmsg Job=nnn type=nnn level=nnn Message-string
 211        */
 212       if (bs->msg[0] == 'J') {           /* Job message */
 213          if (sscanf(bs->msg, "Jmsg Job=%127s type=%d level=%d",
 214                     Job, &type, &level) != 3) {
 215             Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 216             free_jcr(jcr);
 217             continue;
 218          }
 219          Dmsg1(900, "Got msg: %s\n", bs->msg);
 220          skip_spaces(&msg);
 221          skip_nonspaces(&msg);        /* skip type=nnn */
 222          skip_spaces(&msg);
 223          skip_nonspaces(&msg);        /* skip level=nnn */
 224          if (*msg == ' ') {
 225             msg++;                    /* skip leading space */
 226          }
 227          Dmsg1(900, "Dispatch msg: %s", msg);
 228          dispatch_message(jcr, type, level, msg);
 229          free_jcr(jcr);
 230          continue;
 231       }
 232       /*
 233        * Here we expact a CatReq message
 234        *   CatReq Job=nn Catalog-Request-Message
 235        */
 236       if (bs->msg[0] == 'C') {        /* Catalog request */
 237          Dmsg2(900, "Catalog req jcr 0x%x: %s", jcr, bs->msg);
 238          catalog_request(jcr, bs);
 239          Dmsg1(900, "Calling freejcr 0x%x\n", jcr);
 240          free_jcr(jcr);
 241          continue;
 242       }
 243       if (bs->msg[0] == 'U') {        /* SD sending attributes */
 244          Dmsg2(900, "Catalog upd jcr 0x%x: %s", jcr, bs->msg);
 245          catalog_update(jcr, bs);
 246          Dmsg1(900, "Calling freejcr 0x%x\n", jcr);
 247          free_jcr(jcr);
 248          continue;
 249       }
 250       if (bs->msg[0] == 'M') {        /* Mount request */
 251          Dmsg1(900, "Mount req: %s", bs->msg);
 252          mount_request(jcr, bs, msg);
 253          free_jcr(jcr);
 254          continue;
 255       }
 256       if (bs->msg[0] == 'S') {       /* Status change */
 257          int JobStatus;
 258          char Job[MAX_NAME_LENGTH];
 259          if (sscanf(bs->msg, Job_status, &Job, &JobStatus) == 2) {
 260             set_jcr_sd_job_status(jcr,JobStatus); /* current status */
 261          } else {
 262             Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 263          }
 264          free_jcr(jcr);
 265          continue;
 266       }
 267 #ifdef needed
 268       /* No JCR for Device Updates! */
 269       if (bs->msg[0] = 'D') {         /* Device update */
 270          DEVICE *dev;
 271          POOL_MEM dev_name, changer_name, media_type, volume_name;
 272          int dev_open, dev_append, dev_read, dev_labeled;
 273          int dev_offline, dev_autochanger, dev_autoselect;
 274          int dev_num_writers, dev_max_writers, dev_reserved;
 275          uint64_t dev_read_time, dev_write_time, dev_write_bytes, dev_read_bytes;
 276          uint64_t dev_PoolId;
 277          Dmsg1(100, "<stored: %s", bs->msg);
 278          if (sscanf(bs->msg, Device_update,
 279              &Job, dev_name.c_str(),
 280              &dev_append, &dev_read,
 281              &dev_num_writers, &dev_open,
 282              &dev_labeled, &dev_offline, &dev_reserved,
 283              &dev_max_writers, &dev_autoselect,
 284              &dev_autochanger,
 285              changer_name.c_str(), media_type.c_str(),
 286              volume_name.c_str(),
 287              &dev_read_time, &dev_write_time, &dev_read_bytes,
 288              &dev_write_bytes) != 19) {
 289             Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 290          } else {
 291             unbash_spaces(dev_name);
 292             dev = (DEVICE *)GetResWithName(R_DEVICE, dev_name.c_str());
 293             if (!dev) {
 294                continue;
 295             }
 296             unbash_spaces(changer_name);
 297             unbash_spaces(media_type);
 298             unbash_spaces(volume_name);
 299             bstrncpy(dev->ChangerName, changer_name.c_str(), sizeof(dev->ChangerName));
 300             bstrncpy(dev->MediaType, media_type.c_str(), sizeof(dev->MediaType));
 301             bstrncpy(dev->VolumeName, volume_name.c_str(), sizeof(dev->VolumeName));
 302             /* Note, these are copied because they are boolean rather than
 303              *  integer.
 304              */
 305             dev->open = dev_open;
 306             dev->append = dev_append;
 307             dev->read = dev_read;
 308             dev->labeled = dev_labeled;
 309             dev->offline = dev_offline;
 310             dev->autoselect = dev_autoselect;
 311             dev->autochanger = dev_autochanger > 0;
 312             dev->num_drives = dev_autochanger;    /* does double duty */
 313             dev->PoolId = dev_PoolId;
 314             dev->num_writers = dev_num_writers;
 315             dev->max_writers = dev_max_writers;
 316             dev->reserved = dev_reserved;
 317             dev->found = true;
 318             dev->DevReadTime = dev_read_time; /* TODO : have to update database */
 319             dev->DevWriteTime = dev_write_time;
 320             dev->DevReadBytes = dev_read_bytes;
 321             dev->DevWriteBytes = dev_write_bytes;
 322          }
 323          continue;
 324       }
 325 #endif
 326       return n;
 327    }
 328 }
 329
 330 static char *find_msg_start(char *msg)
 331 {
 332    char *p = msg;
 333
 334    skip_nonspaces(&p);                /* skip message type */
 335    skip_spaces(&p);
 336    skip_nonspaces(&p);                /* skip Job */
 337    skip_spaces(&p);                   /* after spaces come the message */
 338    return p;
 339 }
 340
 341 /*
 342  * Get response from FD or SD to a command we
 343  * sent. Check that the response agrees with what we expect.
 344  *
 345  *  Returns: false on failure
 346  *           true  on success
 347  */
 348 bool response(JCR *jcr, BSOCK *bs, char *resp, const char *cmd, e_prtmsg prtmsg)
 349 {
 350    int n;
 351
 352    if (is_bnet_error(bs)) {
 353       return false;
 354    }
 355    if ((n = bget_dirmsg(bs)) >= 0) {
 356       if (strcmp(bs->msg, resp) == 0) {
 357          return true;
 358       }
 359       if (prtmsg == DISPLAY_ERROR) {
 360          Jmsg(jcr, M_FATAL, 0, _("Bad response to %s command: wanted %s, got %s\n"),
 361             cmd, resp, bs->msg);
 362       }
 363       return false;
 364    }
 365    Jmsg(jcr, M_FATAL, 0, _("Socket error on %s command: ERR=%s\n"),
 366          cmd, bnet_strerror(bs));
 367    return false;
 368 }