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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 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 = bs->jcr();
 133    char *msg;
 134
 135    for (;;) {
 136       n = bs->recv();
 137       Dmsg2(300, "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             Jmsg1(jcr, 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          Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 191          continue;
 192       }
 193
 194       /* Skip past "Jmsg Job=nnn" */
 195       if (!(msg=find_msg_start(bs->msg))) {
 196          Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 197          continue;
 198       }
 199
 200       /*
 201        * Here we are expecting a message of the following format:
 202        *   Jmsg Job=nnn type=nnn level=nnn Message-string
 203        */
 204       if (bs->msg[0] == 'J') {           /* Job message */
 205          if (sscanf(bs->msg, "Jmsg Job=%127s type=%d level=%d",
 206                     Job, &type, &level) != 3) {
 207             Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 208             continue;
 209          }
 210          Dmsg1(900, "Got msg: %s\n", bs->msg);
 211          skip_spaces(&msg);
 212          skip_nonspaces(&msg);        /* skip type=nnn */
 213          skip_spaces(&msg);
 214          skip_nonspaces(&msg);        /* skip level=nnn */
 215          if (*msg == ' ') {
 216             msg++;                    /* skip leading space */
 217          }
 218          Dmsg1(900, "Dispatch msg: %s", msg);
 219          dispatch_message(jcr, type, level, msg);
 220          continue;
 221       }
 222       /*
 223        * Here we expact a CatReq message
 224        *   CatReq Job=nn Catalog-Request-Message
 225        */
 226       if (bs->msg[0] == 'C') {        /* Catalog request */
 227          Dmsg2(900, "Catalog req jcr 0x%x: %s", jcr, bs->msg);
 228          catalog_request(jcr, bs);
 229          continue;
 230       }
 231       if (bs->msg[0] == 'U') {        /* SD sending attributes */
 232          Dmsg2(900, "Catalog upd jcr 0x%x: %s", jcr, bs->msg);
 233          catalog_update(jcr, bs);
 234          continue;
 235       }
 236       if (bs->msg[0] == 'M') {        /* Mount request */
 237          Dmsg1(900, "Mount req: %s", bs->msg);
 238          mount_request(jcr, bs, msg);
 239          continue;
 240       }
 241       if (bs->msg[0] == 'S') {       /* Status change */
 242          int JobStatus;
 243          char Job[MAX_NAME_LENGTH];
 244          if (sscanf(bs->msg, Job_status, &Job, &JobStatus) == 2) {
 245             set_jcr_sd_job_status(jcr, JobStatus); /* current status */
 246          } else {
 247             Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 248          }
 249          continue;
 250       }
 251 #ifdef needed
 252       /* No JCR for Device Updates! */
 253       if (bs->msg[0] = 'D') {         /* Device update */
 254          DEVICE *dev;
 255          POOL_MEM dev_name, changer_name, media_type, volume_name;
 256          int dev_open, dev_append, dev_read, dev_labeled;
 257          int dev_offline, dev_autochanger, dev_autoselect;
 258          int dev_num_writers, dev_max_writers, dev_reserved;
 259          uint64_t dev_read_time, dev_write_time, dev_write_bytes, dev_read_bytes;
 260          uint64_t dev_PoolId;
 261          Dmsg1(100, "<stored: %s", bs->msg);
 262          if (sscanf(bs->msg, Device_update,
 263              &Job, dev_name.c_str(),
 264              &dev_append, &dev_read,
 265              &dev_num_writers, &dev_open,
 266              &dev_labeled, &dev_offline, &dev_reserved,
 267              &dev_max_writers, &dev_autoselect,
 268              &dev_autochanger,
 269              changer_name.c_str(), media_type.c_str(),
 270              volume_name.c_str(),
 271              &dev_read_time, &dev_write_time, &dev_read_bytes,
 272              &dev_write_bytes) != 19) {
 273             Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
 274          } else {
 275             unbash_spaces(dev_name);
 276             dev = (DEVICE *)GetResWithName(R_DEVICE, dev_name.c_str());
 277             if (!dev) {
 278                continue;
 279             }
 280             unbash_spaces(changer_name);
 281             unbash_spaces(media_type);
 282             unbash_spaces(volume_name);
 283             bstrncpy(dev->ChangerName, changer_name.c_str(), sizeof(dev->ChangerName));
 284             bstrncpy(dev->MediaType, media_type.c_str(), sizeof(dev->MediaType));
 285             bstrncpy(dev->VolumeName, volume_name.c_str(), sizeof(dev->VolumeName));
 286             /* Note, these are copied because they are boolean rather than
 287              *  integer.
 288              */
 289             dev->open = dev_open;
 290             dev->append = dev_append;
 291             dev->read = dev_read;
 292             dev->labeled = dev_labeled;
 293             dev->offline = dev_offline;
 294             dev->autoselect = dev_autoselect;
 295             dev->autochanger = dev_autochanger > 0;
 296             dev->num_drives = dev_autochanger;    /* does double duty */
 297             dev->PoolId = dev_PoolId;
 298             dev->num_writers = dev_num_writers;
 299             dev->max_writers = dev_max_writers;
 300             dev->reserved = dev_reserved;
 301             dev->found = true;
 302             dev->DevReadTime = dev_read_time; /* TODO : have to update database */
 303             dev->DevWriteTime = dev_write_time;
 304             dev->DevReadBytes = dev_read_bytes;
 305             dev->DevWriteBytes = dev_write_bytes;
 306          }
 307          continue;
 308       }
 309 #endif
 310       return n;
 311    }
 312 }
 313
 314 static char *find_msg_start(char *msg)
 315 {
 316    char *p = msg;
 317
 318    skip_nonspaces(&p);                /* skip message type */
 319    skip_spaces(&p);
 320    skip_nonspaces(&p);                /* skip Job */
 321    skip_spaces(&p);                   /* after spaces come the message */
 322    return p;
 323 }
 324
 325 /*
 326  * Get response from FD or SD to a command we
 327  * sent. Check that the response agrees with what we expect.
 328  *
 329  *  Returns: false on failure
 330  *           true  on success
 331  */
 332 bool response(JCR *jcr, BSOCK *bs, char *resp, const char *cmd, e_prtmsg prtmsg)
 333 {
 334    int n;
 335
 336    if (is_bnet_error(bs)) {
 337       return false;
 338    }
 339    if ((n = bget_dirmsg(bs)) >= 0) {
 340       if (strcmp(bs->msg, resp) == 0) {
 341          return true;
 342       }
 343       if (prtmsg == DISPLAY_ERROR) {
 344          Jmsg(jcr, M_FATAL, 0, _("Bad response to %s command: wanted %s, got %s\n"),
 345             cmd, resp, bs->msg);
 346       }
 347       return false;
 348    }
 349    Jmsg(jcr, M_FATAL, 0, _("Socket error on %s command: ERR=%s\n"),
 350          cmd, bnet_strerror(bs));
 351    return false;
 352 }