git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/job.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 John Walker.
  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  *   Job control and execution for Storage Daemon
  30  *
  31  *   Kern Sibbald, MM
  32  *
  33  *   Version $Id$
  34  *
  35  */
  36
  37 #include "bacula.h"
  38 #include "stored.h"
  39
  40 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  41
  42 /* Imported variables */
  43 extern uint32_t VolSessionTime;
  44
  45 /* Imported functions */
  46 extern uint32_t newVolSessionId();
  47 extern bool do_mac(JCR *jcr);
  48
  49 /* Requests from the Director daemon */
  50 static char jobcmd[] = "JobId=%d job=%127s job_name=%127s client_name=%127s "
  51       "type=%d level=%d FileSet=%127s NoAttr=%d SpoolAttr=%d FileSetMD5=%127s "
  52       "SpoolData=%d WritePartAfterJob=%d PreferMountedVols=%d\n";
  53
  54
  55 /* Responses sent to Director daemon */
  56 static char OKjob[]     = "3000 OK Job SDid=%u SDtime=%u Authorization=%s\n";
  57 static char BAD_job[]   = "3915 Bad Job command. stat=%d CMD: %s\n";
  58 //static char OK_query[]  = "3001 OK query\n";
  59 //static char NO_query[]  = "3918 Query failed\n";
  60 //static char BAD_query[] = "3917 Bad query command: %s\n";
  61
  62 /*
  63  * Director requests us to start a job
  64  * Basic tasks done here:
  65  *  - We pickup the JobId to be run from the Director.
  66  *  - We pickup the device, media, and pool from the Director
  67  *  - Wait for a connection from the File Daemon (FD)
  68  *  - Accept commands from the FD (i.e. run the job)
  69  *  - Return when the connection is terminated or
  70  *    there is an error.
  71  */
  72 bool job_cmd(JCR *jcr)
  73 {
  74    int JobId;
  75    char auth_key[100];
  76    char seed[100];
  77    BSOCK *dir = jcr->dir_bsock;
  78    POOL_MEM job_name, client_name, job, fileset_name, fileset_md5;
  79    int JobType, level, spool_attributes, no_attributes, spool_data;
  80    int write_part_after_job, PreferMountedVols;
  81    int stat;
  82    JCR *ojcr;
  83
  84    /*
  85     * Get JobId and permissions from Director
  86     */
  87    Dmsg1(100, "<dird: %s", dir->msg);
  88    stat = sscanf(dir->msg, jobcmd, &JobId, job.c_str(), job_name.c_str(),
  89               client_name.c_str(),
  90               &JobType, &level, fileset_name.c_str(), &no_attributes,
  91               &spool_attributes, fileset_md5.c_str(), &spool_data,
  92               &write_part_after_job, &PreferMountedVols);
  93    if (stat != 13) {
  94       pm_strcpy(jcr->errmsg, dir->msg);
  95       dir->fsend(BAD_job, stat, jcr->errmsg);
  96       Dmsg1(100, ">dird: %s", dir->msg);
  97       set_jcr_job_status(jcr, JS_ErrorTerminated);
  98       return false;
  99    }
 100    /*
 101     * Since this job could be rescheduled, we
 102     *  check to see if we have it already. If so
 103     *  free the old jcr and use the new one.
 104     */
 105    ojcr = get_jcr_by_full_name(job.c_str());
 106    if (ojcr && !ojcr->authenticated) {
 107       Dmsg2(100, "Found ojcr=0x%x Job %s\n", (unsigned)(long)ojcr, job.c_str());
 108       free_jcr(ojcr);
 109    }
 110    jcr->JobId = JobId;
 111    jcr->VolSessionId = newVolSessionId();
 112    jcr->VolSessionTime = VolSessionTime;
 113    bstrncpy(jcr->Job, job, sizeof(jcr->Job));
 114    unbash_spaces(job_name);
 115    jcr->job_name = get_pool_memory(PM_NAME);
 116    pm_strcpy(jcr->job_name, job_name);
 117    unbash_spaces(client_name);
 118    jcr->client_name = get_pool_memory(PM_NAME);
 119    pm_strcpy(jcr->client_name, client_name);
 120    unbash_spaces(fileset_name);
 121    jcr->fileset_name = get_pool_memory(PM_NAME);
 122    pm_strcpy(jcr->fileset_name, fileset_name);
 123    jcr->JobType = JobType;
 124    jcr->JobLevel = level;
 125    jcr->no_attributes = no_attributes;
 126    jcr->spool_attributes = spool_attributes;
 127    jcr->spool_data = spool_data;
 128    jcr->write_part_after_job = write_part_after_job;
 129    jcr->fileset_md5 = get_pool_memory(PM_NAME);
 130    pm_strcpy(jcr->fileset_md5, fileset_md5);
 131    jcr->PreferMountedVols = PreferMountedVols;
 132
 133    jcr->authenticated = false;
 134
 135    /*
 136     * Pass back an authorization key for the File daemon
 137     */
 138    bsnprintf(seed, sizeof(seed), "%p", jcr);
 139    make_session_key(auth_key, seed, 1);
 140    dir->fsend(OKjob, jcr->VolSessionId, jcr->VolSessionTime, auth_key);
 141    if (debug_level == 3) {
 142       Dmsg2(000, ">dird jid=%u: %s", (uint32_t)jcr->JobId, dir->msg);
 143    }
 144    Dmsg2(100, ">dird jid=%u: %s", (uint32_t)jcr->JobId, dir->msg);
 145    jcr->sd_auth_key = bstrdup(auth_key);
 146    memset(auth_key, 0, sizeof(auth_key));
 147    generate_daemon_event(jcr, "JobStart");
 148    return true;
 149 }
 150
 151 bool run_cmd(JCR *jcr)
 152 {
 153    struct timeval tv;
 154    struct timezone tz;
 155    struct timespec timeout;
 156    int errstat;
 157
 158    Dsm_check(1);
 159    Dmsg1(200, "Run_cmd: %s\n", jcr->dir_bsock->msg);
 160    /* The following jobs don't need the FD */
 161    switch (jcr->JobType) {
 162    case JT_MIGRATE:
 163    case JT_COPY:
 164    case JT_ARCHIVE:
 165       jcr->authenticated = true;
 166       do_mac(jcr);
 167       return false;
 168    }
 169
 170    set_jcr_job_status(jcr, JS_WaitFD);          /* wait for FD to connect */
 171    dir_send_job_status(jcr);
 172
 173    gettimeofday(&tv, &tz);
 174    timeout.tv_nsec = tv.tv_usec * 1000;
 175    timeout.tv_sec = tv.tv_sec + me->client_wait;
 176
 177    Dmsg2(100, "%s waiting %d sec for FD to contact SD\n",
 178         jcr->Job, (int)me->client_wait);
 179    /*
 180     * Wait for the File daemon to contact us to start the Job,
 181     *  when he does, we will be released, unless the 30 minutes
 182     *  expires.
 183     */
 184    P(mutex);
 185    for ( ; !job_canceled(jcr); ) {
 186       errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout);
 187       if (errstat == 0 || errstat == ETIMEDOUT) {
 188          break;
 189       }
 190    }
 191    V(mutex);
 192
 193    if (debug_level == 3) {
 194       Dmsg1(000, "jid=%u Zap sd_auth_key\n", (uint32_t)jcr->JobId);
 195    }
 196    memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
 197
 198    if (jcr->authenticated && !job_canceled(jcr)) {
 199       Dmsg1(100, "Running job %s\n", jcr->Job);
 200       run_job(jcr);                   /* Run the job */
 201    }
 202    return false;
 203 }
 204
 205 /*
 206  * After receiving a connection (in dircmd.c) if it is
 207  *   from the File daemon, this routine is called.
 208  */
 209 void handle_filed_connection(BSOCK *fd, char *job_name)
 210 {
 211    JCR *jcr;
 212
 213    bmicrosleep(0, 50000);             /* wait 50 millisecs */
 214    if (!(jcr=get_jcr_by_full_name(job_name))) {
 215       Jmsg1(NULL, M_FATAL, 0, _("FD connect failed: Job name not found: %s\n"), job_name);
 216       Dmsg1(100, "Job name not found: %s\n", job_name);
 217       return;
 218    }
 219
 220    jcr->file_bsock = fd;
 221    jcr->file_bsock->set_jcr(jcr);
 222
 223    Dmsg1(110, "Found Job %s\n", job_name);
 224
 225    if (jcr->authenticated) {
 226       Jmsg2(jcr, M_FATAL, 0, _("Hey!!!! JobId %u Job %s already authenticated.\n"),
 227          (uint32_t)jcr->JobId, jcr->Job);
 228       free_jcr(jcr);
 229       return;
 230    }
 231
 232    /*
 233     * Authenticate the File daemon
 234     */
 235    if (debug_level == 3) {
 236       Dmsg2(000, "jid=%u sd_auth_key=%s\n", (uint32_t)jcr->JobId, jcr->sd_auth_key);
 237    }
 238    if (jcr->authenticated || !authenticate_filed(jcr)) {
 239       Dmsg1(100, "Authentication failed Job %s\n", jcr->Job);
 240       Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate File daemon\n"));
 241       if (debug_level == 3) {
 242          Dmsg1(000, "Authentication failed Job %s\n", jcr->Job);
 243       }
 244    } else {
 245       jcr->authenticated = true;
 246       Dmsg2(110, "OK Authentication jid=%u Job %s\n", (uint32_t)jcr->JobId, jcr->Job);
 247    }
 248
 249    if (!jcr->authenticated) {
 250       set_jcr_job_status(jcr, JS_ErrorTerminated);
 251    }
 252    pthread_cond_signal(&jcr->job_start_wait); /* wake waiting job */
 253    free_jcr(jcr);
 254    return;
 255 }
 256
 257
 258 #ifdef needed
 259 /*
 260  *   Query Device command from Director
 261  *   Sends Storage Daemon's information on the device to the
 262  *    caller (presumably the Director).
 263  *   This command always returns "true" so that the line is
 264  *    not closed on an error.
 265  *
 266  */
 267 bool query_cmd(JCR *jcr)
 268 {
 269    POOL_MEM dev_name, VolumeName, MediaType, ChangerName;
 270    BSOCK *dir = jcr->dir_bsock;
 271    DEVRES *device;
 272    AUTOCHANGER *changer;
 273    bool ok;
 274
 275    Dmsg1(100, "Query_cmd: %s", dir->msg);
 276    ok = sscanf(dir->msg, query_device, dev_name.c_str()) == 1;
 277    Dmsg1(100, "<dird: %s\n", dir->msg);
 278    if (ok) {
 279       unbash_spaces(dev_name);
 280       foreach_res(device, R_DEVICE) {
 281          /* Find resource, and make sure we were able to open it */
 282          if (strcmp(dev_name.c_str(), device->hdr.name) == 0) {
 283             if (!device->dev) {
 284                device->dev = init_dev(jcr, device);
 285             }
 286             if (!device->dev) {
 287                break;
 288             }
 289             ok = dir_update_device(jcr, device->dev);
 290             if (ok) {
 291                ok = dir->fsend(OK_query);
 292             } else {
 293                dir->fsend(NO_query);
 294             }
 295             return ok;
 296          }
 297       }
 298       foreach_res(changer, R_AUTOCHANGER) {
 299          /* Find resource, and make sure we were able to open it */
 300          if (strcmp(dev_name.c_str(), changer->hdr.name) == 0) {
 301             if (!changer->device || changer->device->size() == 0) {
 302                continue;              /* no devices */
 303             }
 304             ok = dir_update_changer(jcr, changer);
 305             if (ok) {
 306                ok = dir->fsend(OK_query);
 307             } else {
 308                dir->fsend(NO_query);
 309             }
 310             return ok;
 311          }
 312       }
 313       /* If we get here, the device/autochanger was not found */
 314       unbash_spaces(dir->msg);
 315       pm_strcpy(jcr->errmsg, dir->msg);
 316       dir->fsend(NO_device, dev_name.c_str());
 317       Dmsg1(100, ">dird: %s\n", dir->msg);
 318    } else {
 319       unbash_spaces(dir->msg);
 320       pm_strcpy(jcr->errmsg, dir->msg);
 321       dir->fsend(BAD_query, jcr->errmsg);
 322       Dmsg1(100, ">dird: %s\n", dir->msg);
 323    }
 324
 325    return true;
 326 }
 327
 328 #endif
 329
 330
 331 /*
 332  * Destroy the Job Control Record and associated
 333  * resources (sockets).
 334  */
 335 void stored_free_jcr(JCR *jcr)
 336 {
 337    Dmsg1(900, "stored_free_jcr JobId=%u\n", jcr->JobId);
 338    if (jcr->file_bsock) {
 339       jcr->file_bsock->close();
 340       jcr->file_bsock = NULL;
 341    }
 342    if (jcr->job_name) {
 343       free_pool_memory(jcr->job_name);
 344    }
 345    if (jcr->client_name) {
 346       free_memory(jcr->client_name);
 347       jcr->client_name = NULL;
 348    }
 349    if (jcr->fileset_name) {
 350       free_memory(jcr->fileset_name);
 351    }
 352    if (jcr->fileset_md5) {
 353       free_memory(jcr->fileset_md5);
 354    }
 355    if (jcr->bsr) {
 356       free_bsr(jcr->bsr);
 357       jcr->bsr = NULL;
 358    }
 359    if (jcr->RestoreBootstrap) {
 360       unlink(jcr->RestoreBootstrap);
 361       free_pool_memory(jcr->RestoreBootstrap);
 362       jcr->RestoreBootstrap = NULL;
 363    }
 364    if (jcr->next_dev || jcr->prev_dev) {
 365       Emsg0(M_FATAL, 0, _("In free_jcr(), but still attached to device!!!!\n"));
 366    }
 367    pthread_cond_destroy(&jcr->job_start_wait);
 368    if (jcr->dcrs) {
 369       delete jcr->dcrs;
 370    }
 371    jcr->dcrs = NULL;
 372
 373    /* Avoid a double free */
 374    if (jcr->dcr == jcr->read_dcr) {
 375       jcr->read_dcr = NULL;
 376    }
 377    if (jcr->dcr) {
 378       free_dcr(jcr->dcr);
 379       jcr->dcr = NULL;
 380    }
 381    if (jcr->read_dcr) {
 382       free_dcr(jcr->read_dcr);
 383       jcr->read_dcr = NULL;
 384    }
 385
 386    if (jcr->read_store) {
 387       DIRSTORE *store;
 388       foreach_alist(store, jcr->read_store) {
 389          delete store->device;
 390          delete store;
 391       }
 392       delete jcr->read_store;
 393       jcr->read_store = NULL;
 394    }
 395    if (jcr->write_store) {
 396       DIRSTORE *store;
 397       foreach_alist(store, jcr->write_store) {
 398          delete store->device;
 399          delete store;
 400       }
 401       delete jcr->write_store;
 402       jcr->write_store = NULL;
 403    }
 404    Dsm_check(1);
 405    return;
 406 }