自学教程：C++ Dmsg2函数代码示例

bool commit_attribute_spool(JCR *jcr){    boffset_t size, data_end;    char ec1[30];    char tbuf[MAX_TIME_LENGTH];    BSOCK *dir;    Dmsg1(100, "Commit attributes at %s/n", bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));    if (are_attributes_spooled(jcr)) {        dir = jcr->dir_bsock;        if ((size = lseek(dir->m_spool_fd, 0, SEEK_END)) == -1) {            berrno be;            Jmsg(jcr, M_FATAL, 0, _("lseek on attributes file failed: ERR=%s/n"), be.bstrerror());            jcr->forceJobStatus(JS_FatalError);  /* override any Incomplete */            goto bail_out;        }        if (jcr->is_JobStatus(JS_Incomplete)) {            data_end = dir->get_data_end();            /*             * Check and truncate to last valid data_end if necssary             */            if (size > data_end) {                if (ftruncate(dir->m_spool_fd, data_end) != 0) {                    berrno be;                    Jmsg(jcr, M_FATAL, 0, _("Truncate on attributes file failed: ERR=%s/n"), be.bstrerror());                    jcr->forceJobStatus(JS_FatalError);  /* override any Incomplete */                    goto bail_out;                }                Dmsg2(100, "=== Attrib spool truncated from %lld to %lld/n", size, data_end);                size = data_end;            }        }        if (size < 0) {            berrno be;            Jmsg(jcr, M_FATAL, 0, _("Fseek on attributes file failed: ERR=%s/n"),                 be.bstrerror());            jcr->forceJobStatus(JS_FatalError);  /* override any Incomplete */            goto bail_out;        }        P(mutex);        if (spool_stats.attr_size + size > spool_stats.max_attr_size) {            spool_stats.max_attr_size = spool_stats.attr_size + size;        }        spool_stats.attr_size += size;        V(mutex);        jcr->sendJobStatus(JS_AttrDespooling);        Jmsg(jcr, M_INFO, 0, _("Sending spooled attrs to the Director. Despooling %s bytes .../n"),             edit_uint64_with_commas(size, ec1));        if (!blast_attr_spool_file(jcr, size)) {            /* Can't read spool file from director side,             * send content over network.             */            dir->despool(update_attr_spool_size, size);        }        return close_attr_spool_file(jcr, dir);    }    return true;bail_out:    close_attr_spool_file(jcr, dir);    return false;}

//.........这里部分代码省略.........   URES *res;   int rindex = type - r_first;   int i, size = 0;   int error = 0;   /*    * Ensure that all required items are present    */   for (i=0; items[i].name; i++) {      if (items[i].flags & ITEM_REQUIRED) {            if (!bit_is_set(i, res_all.dir_res.hdr.item_present)) {               Emsg2(M_ABORT, 0, _("%s item is required in %s resource, but not found./n"),                 items[i].name, resources[rindex]);             }      }   }   /*    * During pass 2, we looked up pointers to all the resources    * referrenced in the current resource, , now we    * must copy their address from the static record to the allocated    * record.    */   if (pass == 2) {      switch (type) {      /*       * Resources not containing a resource       */      case R_DIRECTOR:         break;      case R_CONSOLE:      case R_CONSOLE_FONT:         break;      default:         Emsg1(M_ERROR, 0, _("Unknown resource type %d/n"), type);         error = 1;         break;      }      /*       * Note, the resoure name was already saved during pass 1,       * so here, we can just release it.       */      if (res_all.dir_res.hdr.name) {         free(res_all.dir_res.hdr.name);         res_all.dir_res.hdr.name = NULL;      }      if (res_all.dir_res.hdr.desc) {         free(res_all.dir_res.hdr.desc);         res_all.dir_res.hdr.desc = NULL;      }      return;   }   /*    * The following code is only executed during pass 1    */   switch (type) {   case R_DIRECTOR:      size = sizeof(DIRRES);      break;   case R_CONSOLE_FONT:      size = sizeof(CONFONTRES);      break;   case R_CONSOLE:      size = sizeof(CONRES);      break;   default:      printf(_("Unknown resource type %d/n"), type);      error = 1;      break;   }   /*    * Common    */   if (!error) {      res = (URES *)malloc(size);      memcpy(res, &res_all, size);      if (!res_head[rindex]) {         res_head[rindex] = (RES *)res; /* store first entry */      } else {         RES *next, *last;         /*          * Add new res to end of chain          */         for (last=next=res_head[rindex]; next; next=next->next) {            last = next;            if (strcmp(next->name, res->dir_res.hdr.name) == 0) {               Emsg2(M_ERROR_TERM, 0,                  _("Attempt to define second %s resource named /"%s/" is not permitted./n"),                  resources[rindex].name, res->dir_res.hdr.name);            }         }         last->next = (RES *)res;         Dmsg2(90, "Inserting %s res: %s/n", res_to_str(type),               res->dir_res.hdr.name);      }   }}

/* * Convert a string duration to utime_t (64 bit seconds) * Returns false: if error           true:  if OK, and value stored in value */bool duration_to_utime(char *str, utime_t *value){   int i, mod_len;   double val, total = 0.0;   char mod_str[20];   char num_str[50];   /*    * The "n" = mins and months appears before minutes so that m maps to months.    */   static const char *mod[] = {      "n",      "seconds",      "months",      "minutes",      "mins",      "hours",      "days",      "weeks",      "quarters",      "years",      (char *)NULL   };   static const int32_t mult[] = {      60,      1,      60 * 60 * 24 * 30,      60,      60,      3600,      3600 * 24,      3600 * 24 * 7,      3600 * 24 * 91,      3600 * 24 * 365,      0   };   while (*str) {      if (!get_modifier(str, num_str, sizeof(num_str), mod_str, sizeof(mod_str))) {         return false;      }      /* Now find the multiplier corresponding to the modifier */      mod_len = strlen(mod_str);      if (mod_len == 0) {         i = 1;                          /* default to seconds */      } else {         for (i=0; mod[i]; i++) {            if (bstrncasecmp(mod_str, mod[i], mod_len)) {               break;            }         }         if (mod[i] == NULL) {            return false;         }      }      Dmsg2(900, "str=%s: mult=%d/n", num_str, mult[i]);      errno = 0;      val = strtod(num_str, NULL);      if (errno != 0 || val < 0) {         return false;      }      total += val * mult[i];   }   *value = (utime_t)total;   return true;}

/** * Get info on the next appendable volume in the Director's database * * Returns: true  on success dcr->VolumeName is volume *                reserve_volume() called on Volume name *          false on failure dcr->VolumeName[0] == 0 *                also sets dcr->found_in_use if at least one *                in use volume was found. * *          Volume information returned in dcr * */bool dir_find_next_appendable_volume(DCR *dcr){    JCR *jcr = dcr->jcr;    BSOCK *dir = jcr->dir_bsock;    bool rtn;    char lastVolume[MAX_NAME_LENGTH];    Dmsg2(dbglvl, "dir_find_next_appendable_volume: reserved=%d Vol=%s/n",       dcr->is_reserved(), dcr->VolumeName);    /*     * Try the twenty oldest or most available volumes.  Note,     *   the most available could already be mounted on another     *   drive, so we continue looking for a not in use Volume.     */    lock_volumes();    P(vol_info_mutex);    dcr->clear_found_in_use();    lastVolume[0] = 0;    for (int vol_index=1;  vol_index < 20; vol_index++) {       bash_spaces(dcr->media_type);       bash_spaces(dcr->pool_name);       dir->fsend(Find_media, jcr->Job, vol_index, dcr->pool_name, dcr->media_type);       unbash_spaces(dcr->media_type);       unbash_spaces(dcr->pool_name);       Dmsg1(dbglvl, ">dird %s", dir->msg);       if (do_get_volume_info(dcr)) {          /* Give up if we get the same volume name twice */          if (lastVolume[0] && bstrcmp(lastVolume, dcr->VolumeName)) {             Dmsg1(dbglvl, "Got same vol = %s/n", lastVolume);             break;          }          bstrncpy(lastVolume, dcr->VolumeName, sizeof(lastVolume));          if (dcr->can_i_write_volume()) {             Dmsg1(dbglvl, "Call reserve_volume for write. Vol=%s/n", dcr->VolumeName);             if (reserve_volume(dcr, dcr->VolumeName) == NULL) {                Dmsg2(dbglvl, "Could not reserve volume %s on %s/n", dcr->VolumeName,                    dcr->dev->print_name());                continue;             }             Dmsg1(dbglvl, "dir_find_next_appendable_volume return true. vol=%s/n",                dcr->VolumeName);             rtn = true;             goto get_out;          } else {             Dmsg1(dbglvl, "Volume %s is in use./n", dcr->VolumeName);             /* If volume is not usable, it is in use by someone else */             dcr->set_found_in_use();             continue;          }       }       Dmsg2(dbglvl, "No vol. index %d return false. dev=%s/n", vol_index,          dcr->dev->print_name());       break;    }    rtn = false;    dcr->VolumeName[0] = 0;get_out:    V(vol_info_mutex);    unlock_volumes();    return rtn;}

/* * Match all the components of current record *   returns  1 on match *   returns  0 no match *   returns -1 no additional matches possible */static int match_all(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec,                     SESSION_LABEL *sessrec, bool done, JCR *jcr){   Dmsg0(dbglevel, "Enter match_all/n");   if (bsr->done) {//    Dmsg0(dbglevel, "bsr->done set/n");      goto no_match;   }   if (!match_volume(bsr, bsr->volume, volrec, 1)) {      Dmsg2(dbglevel, "bsr fail bsr_vol=%s != rec read_vol=%s/n", bsr->volume->VolumeName,            volrec->VolumeName);      goto no_match;   }   Dmsg2(dbglevel, "OK bsr match bsr_vol=%s read_vol=%s/n", bsr->volume->VolumeName,            volrec->VolumeName);   if (!match_volfile(bsr, bsr->volfile, rec, 1)) {      if (bsr->volfile) {         Dmsg3(dbglevel, "Fail on file=%u. bsr=%u,%u/n",               rec->File, bsr->volfile->sfile, bsr->volfile->efile);      }      goto no_match;   }   if (!match_voladdr(bsr, bsr->voladdr, rec, 1)) {      if (bsr->voladdr) {         Dmsg3(dbglevel, "Fail on Addr=%llu. bsr=%llu,%llu/n",               get_record_address(rec), bsr->voladdr->saddr, bsr->voladdr->eaddr);      }      goto no_match;   }   if (!match_sesstime(bsr, bsr->sesstime, rec, 1)) {      Dmsg2(dbglevel, "Fail on sesstime. bsr=%u rec=%u/n",         bsr->sesstime->sesstime, rec->VolSessionTime);      goto no_match;   }   /* NOTE!! This test MUST come after the sesstime test */   if (!match_sessid(bsr, bsr->sessid, rec)) {      Dmsg2(dbglevel, "Fail on sessid. bsr=%u rec=%u/n",         bsr->sessid->sessid, rec->VolSessionId);      goto no_match;   }   /* NOTE!! This test MUST come after sesstime and sessid tests */   if (!match_findex(bsr, bsr->FileIndex, rec, 1)) {      Dmsg3(dbglevel, "Fail on findex=%d. bsr=%d,%d/n",         rec->FileIndex, bsr->FileIndex->findex, bsr->FileIndex->findex2);      goto no_match;   }   Dmsg3(dbglevel, "match on findex=%d. bsr=%d,%d/n",         rec->FileIndex, bsr->FileIndex->findex, bsr->FileIndex->findex2);   if (!match_fileregex(bsr, rec, jcr)) {     Dmsg1(dbglevel, "Fail on fileregex='%s'/n", bsr->fileregex);     goto no_match;   }   /* This flag is set by match_fileregex (and perhaps other tests) */   if (bsr->skip_file) {      Dmsg1(dbglevel, "Skipping findex=%d/n", rec->FileIndex);      goto no_match;   }   /*    * If a count was specified and we have a FileIndex, assume    *   it is a Bareos created bsr (or the equivalent). We    *   then save the bsr where the match occurred so that    *   after processing the record or records, we can update    *   the found count. I.e. rec->bsr points to the bsr that    *   satisfied the match.    */   if (bsr->count && bsr->FileIndex) {      rec->bsr = bsr;      Dmsg0(dbglevel, "Leave match_all 1/n");      return 1;                       /* this is a complete match */   }   /*    * The selections below are not used by Bareos's    *   restore command, and don't work because of    *   the rec->bsr = bsr optimization above.    */   if (!match_jobid(bsr, bsr->JobId, sessrec, 1)) {      Dmsg0(dbglevel, "fail on JobId/n");      goto no_match;   }   if (!match_job(bsr, bsr->job, sessrec, 1)) {      Dmsg0(dbglevel, "fail on Job/n");      goto no_match;   }   if (!match_client(bsr, bsr->client, sessrec, 1)) {//.........这里部分代码省略.........

/* * Find Available Media (Volume) for Pool * * Find a Volume for a given PoolId, MediaType, and Status. * The unwanted_volumes variable lists the VolumeNames which we should skip if any. * * Returns: 0 on failure *          numrows on success */int db_find_next_volume(JCR *jcr, B_DB *mdb, int item, bool InChanger, MEDIA_DBR *mr, const char *unwanted_volumes){   char ed1[50];   int num_rows = 0;   SQL_ROW row = NULL;   bool find_oldest = false;   bool found_candidate = false;   char esc_type[MAX_ESCAPE_NAME_LENGTH];   char esc_status[MAX_ESCAPE_NAME_LENGTH];   db_lock(mdb);   mdb->db_escape_string(jcr, esc_type, mr->MediaType, strlen(mr->MediaType));   mdb->db_escape_string(jcr, esc_status, mr->VolStatus, strlen(mr->VolStatus));   if (item == -1) {      find_oldest = true;      item = 1;   }retry_fetch:   if (find_oldest) {      /*       * Find oldest volume(s)       */      Mmsg(mdb->cmd, "SELECT MediaId,VolumeName,VolJobs,VolFiles,VolBlocks,"                     "VolBytes,VolMounts,VolErrors,VolWrites,MaxVolBytes,VolCapacityBytes,"                     "MediaType,VolStatus,PoolId,VolRetention,VolUseDuration,MaxVolJobs,"                     "MaxVolFiles,Recycle,Slot,FirstWritten,LastWritten,InChanger,"                     "EndFile,EndBlock,LabelType,LabelDate,StorageId,"                     "Enabled,LocationId,RecycleCount,InitialWrite,"                     "ScratchPoolId,RecyclePoolId,VolReadTime,VolWriteTime,"                     "ActionOnPurge,EncryptionKey,MinBlocksize,MaxBlocksize "                     "FROM Media WHERE PoolId=%s AND MediaType='%s' AND VolStatus IN ('Full',"                     "'Recycle','Purged','Used','Append') AND Enabled=1 "                     "ORDER BY LastWritten LIMIT %d",           edit_int64(mr->PoolId, ed1), esc_type, item);   } else {      POOL_MEM changer(PM_FNAME);      const char *order;      /*       * Find next available volume       */      if (InChanger) {         Mmsg(changer, "AND InChanger=1 AND StorageId=%s", edit_int64(mr->StorageId, ed1));      }      if (bstrcmp(mr->VolStatus, "Recycle") ||          bstrcmp(mr->VolStatus, "Purged")) {         order = "AND Recycle=1 ORDER BY LastWritten ASC,MediaId";  /* take oldest that can be recycled */      } else {         order = sql_media_order_most_recently_written[db_get_type_index(mdb)];    /* take most recently written */      }      Mmsg(mdb->cmd, "SELECT MediaId,VolumeName,VolJobs,VolFiles,VolBlocks,"                     "VolBytes,VolMounts,VolErrors,VolWrites,MaxVolBytes,VolCapacityBytes,"                     "MediaType,VolStatus,PoolId,VolRetention,VolUseDuration,MaxVolJobs,"                     "MaxVolFiles,Recycle,Slot,FirstWritten,LastWritten,InChanger,"                     "EndFile,EndBlock,LabelType,LabelDate,StorageId,"                     "Enabled,LocationId,RecycleCount,InitialWrite,"                     "ScratchPoolId,RecyclePoolId,VolReadTime,VolWriteTime,"                     "ActionOnPurge,EncryptionKey,MinBlocksize,MaxBlocksize "                     "FROM Media WHERE PoolId=%s AND MediaType='%s' AND Enabled=1 "                     "AND VolStatus='%s' "                     "%s "                     "%s LIMIT %d",           edit_int64(mr->PoolId, ed1), esc_type,           esc_status, changer.c_str(), order, item);   }   Dmsg1(100, "fnextvol=%s/n", mdb->cmd);   if (!QUERY_DB(jcr, mdb, mdb->cmd)) {      goto bail_out;   }   num_rows = sql_num_rows(mdb);   if (item > num_rows || item < 1) {      Dmsg2(050, "item=%d got=%d/n", item, num_rows);      Mmsg2(&mdb->errmsg, _("Request for Volume item %d greater than max %d or less than 1/n"), item, num_rows);      num_rows = 0;      goto bail_out;   }   for (int i = 0 ; i < item; i++) {      if ((row = sql_fetch_row(mdb)) == NULL) {         Dmsg1(050, "Fail fetch item=%d/n", i);         Mmsg1(&mdb->errmsg, _("No Volume record found for item %d./n"), i);         sql_free_result(mdb);         num_rows = 0;         goto bail_out;//.........这里部分代码省略.........

int run_scripts(JCR *jcr, alist *runscripts, const char *label, alist *allowed_script_dirs){   RUNSCRIPT *script;   bool runit;   int when;   Dmsg2(200, "runscript: running all RUNSCRIPT object (%s) JobStatus=%c/n", label, jcr->JobStatus);   if (strstr(label, NT_("Before"))) {      when = SCRIPT_Before;   } else if (bstrcmp(label, NT_("ClientAfterVSS"))) {      when = SCRIPT_AfterVSS;   } else {      when = SCRIPT_After;   }   if (runscripts == NULL) {      Dmsg0(100, "runscript: WARNING RUNSCRIPTS list is NULL/n");      return 0;   }   foreach_alist(script, runscripts) {      Dmsg2(200, "runscript: try to run %s:%s/n", NPRT(script->target), NPRT(script->command));      runit = false;      if ((script->when & SCRIPT_Before) && (when & SCRIPT_Before)) {         if ((script->on_success && (jcr->JobStatus == JS_Running || jcr->JobStatus == JS_Created)) ||             (script->on_failure && (job_canceled(jcr) || jcr->JobStatus == JS_Differences))) {            Dmsg4(200, "runscript: Run it because SCRIPT_Before (%s,%i,%i,%c)/n",                  script->command, script->on_success, script->on_failure, jcr->JobStatus );            runit = true;         }      }      if ((script->when & SCRIPT_AfterVSS) && (when & SCRIPT_AfterVSS)) {         if ((script->on_success && (jcr->JobStatus == JS_Blocked)) ||             (script->on_failure && job_canceled(jcr))) {            Dmsg4(200, "runscript: Run it because SCRIPT_AfterVSS (%s,%i,%i,%c)/n",                  script->command, script->on_success, script->on_failure, jcr->JobStatus );            runit = true;         }      }      if ((script->when & SCRIPT_After) && (when & SCRIPT_After)) {         if ((script->on_success && (jcr->JobStatus == JS_Terminated || jcr->JobStatus == JS_Warnings)) ||             (script->on_failure && (job_canceled(jcr) || jcr->JobStatus == JS_Differences))) {            Dmsg4(200, "runscript: Run it because SCRIPT_After (%s,%i,%i,%c)/n",                  script->command, script->on_success, script->on_failure, jcr->JobStatus );            runit = true;         }      }      if (!script->is_local()) {         runit = false;      }      /*       * We execute it       */      if (runit) {         if (!script_dir_allowed(jcr, script, allowed_script_dirs)) {            Dmsg1(200, "runscript: Not running script %s because its not in one of the allowed scripts dirs/n",                  script->command);            Jmsg(jcr, M_ERROR, 0, _("Runscript: run %s /"%s/" could not execute, "                                    "not in one of the allowed scripts dirs/n"), label, script->command);            jcr->setJobStatus(JS_ErrorTerminated);            goto bail_out;         }         script->run(jcr, label);      }   }

/* * Acquire device for writing. We permit multiple writers. *  If this is the first one, we read the label. * *  Returns: NULL if failed for any reason *           dcr if successful. *   Note, normally reserve_device_for_append() is called *   before this routine. */DCR *acquire_device_for_append(DCR *dcr){   DEVICE *dev = dcr->dev;   JCR *jcr = dcr->jcr;   bool ok = false;   bool have_vol = false;   Enter(200);   init_device_wait_timers(dcr);   dev->Lock_acquire();             /* only one job at a time */   dev->Lock();   Dmsg1(100, "acquire_append device is %s/n", dev->is_tape() ? "tape" : "disk");   /*    * With the reservation system, this should not happen    */   if (dev->can_read()) {      Jmsg1(jcr, M_FATAL, 0, _("Want to append, but device %s is busy reading./n"), dev->print_name());      Dmsg1(200, "Want to append but device %s is busy reading./n", dev->print_name());      goto get_out;   }   dev->clear_unload();   /*    * have_vol defines whether or not mount_next_write_volume should    *   ask the Director again about what Volume to use.    */   if (dev->can_append() && dcr->is_suitable_volume_mounted() &&       !bstrcmp(dcr->VolCatInfo.VolCatStatus, "Recycle")) {      Dmsg0(190, "device already in append./n");      /*       * At this point, the correct tape is already mounted, so       *   we do not need to do mount_next_write_volume(), unless       *   we need to recycle the tape.       */       if (dev->num_writers == 0) {          dev->VolCatInfo = dcr->VolCatInfo;   /* structure assignment */       }       have_vol = dcr->is_tape_position_ok();   }   if (!have_vol) {      dev->rLock(true);      block_device(dev, BST_DOING_ACQUIRE);      dev->Unlock();      Dmsg1(190, "jid=%u Do mount_next_write_vol/n", (uint32_t)jcr->JobId);      if (!dcr->mount_next_write_volume()) {         if (!job_canceled(jcr)) {            /* Reduce "noise" -- don't print if job canceled */            Jmsg(jcr, M_FATAL, 0, _("Could not ready device %s for append./n"),               dev->print_name());            Dmsg1(200, "Could not ready device %s for append./n",               dev->print_name());         }         dev->Lock();         unblock_device(dev);         goto get_out;      }      Dmsg2(190, "Output pos=%u:%u/n", dcr->dev->file, dcr->dev->block_num);      dev->Lock();      unblock_device(dev);   }   dev->num_writers++;                /* we are now a writer */   if (jcr->NumWriteVolumes == 0) {      jcr->NumWriteVolumes = 1;   }   dev->VolCatInfo.VolCatJobs++;              /* increment number of jobs on vol */   Dmsg4(100, "=== nwriters=%d nres=%d vcatjob=%d dev=%s/n",         dev->num_writers, dev->num_reserved(), dev->VolCatInfo.VolCatJobs, dev->print_name());   dcr->dir_update_volume_info(false, false); /* send Volume info to Director */   ok = true;get_out:   /* Don't plugin close here, we might have multiple writers */   dcr->clear_reserved();   dev->Unlock();   dev->Unlock_acquire();   Leave(200);   return ok ? dcr : NULL;}

/* * This job is done, so release the device. From a Unix standpoint, *  the device remains open. * * Note, if we were spooling, we may enter with the device blocked. *   We unblock at the end, only if it was us who blocked the *   device. * */bool release_device(DCR *dcr){   utime_t now;   JCR *jcr = dcr->jcr;   DEVICE *dev = dcr->dev;   bool ok = true;   char tbuf[100];   int was_blocked = BST_NOT_BLOCKED;   /*    * Capture job statistics now that we are done using this device.    */   now = (utime_t)time(NULL);   update_job_statistics(jcr, now);   dev->Lock();   if (!dev->is_blocked()) {      block_device(dev, BST_RELEASING);   } else {      was_blocked = dev->blocked();      dev->set_blocked(BST_RELEASING);   }   lock_volumes();   Dmsg2(100, "release_device device %s is %s/n", dev->print_name(), dev->is_tape() ? "tape" : "disk");   /*    * If device is reserved, job never started, so release the reserve here    */   dcr->clear_reserved();   if (dev->can_read()) {      VOLUME_CAT_INFO *vol = &dev->VolCatInfo;      dev->clear_read();              /* clear read bit */      Dmsg2(150, "dir_update_vol_info. label=%d Vol=%s/n",         dev->is_labeled(), vol->VolCatName);      if (dev->is_labeled() && vol->VolCatName[0] != 0) {         dcr->dir_update_volume_info(false, false); /* send Volume info to Director */         remove_read_volume(jcr, dcr->VolumeName);         volume_unused(dcr);      }   } else if (dev->num_writers > 0) {      /*       * Note if WEOT is set, we are at the end of the tape and may not be positioned correctly,       * so the job_media_record and update_vol_info have already been done,       * which means we skip them here.       */      dev->num_writers--;      Dmsg1(100, "There are %d writers in release_device/n", dev->num_writers);      if (dev->is_labeled()) {         Dmsg2(200, "dir_create_jobmedia. Release vol=%s dev=%s/n",               dev->getVolCatName(), dev->print_name());         if (!dev->at_weot() && !dcr->dir_create_jobmedia_record(false)) {            Jmsg2(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=/"%s/" Job=%s/n"),               dcr->getVolCatName(), jcr->Job);         }         /*          * If no more writers, and no errors, and wrote something, write an EOF          */         if (!dev->num_writers && dev->can_write() && dev->block_num > 0) {            dev->weof(1);            write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName);         }         if (!dev->at_weot()) {            dev->VolCatInfo.VolCatFiles = dev->file;   /* set number of files */            /*             * Note! do volume update before close, which zaps VolCatInfo             */            dcr->dir_update_volume_info(false, false); /* send Volume info to Director */            Dmsg2(200, "dir_update_vol_info. Release vol=%s dev=%s/n",                  dev->getVolCatName(), dev->print_name());         }         if (dev->num_writers == 0) {         /* if not being used */            volume_unused(dcr);               /*  we obviously are not using the volume */         }      }   } else {      /*       * If we reach here, it is most likely because the job has failed,       * since the device is not in read mode and there are no writers.       * It was probably reserved.       */      volume_unused(dcr);   }   Dmsg3(100, "%d writers, %d reserve, dev=%s/n", dev->num_writers, dev->num_reserved(), dev->print_name());   /*    * If no writers, close if file or !CAP_ALWAYS_OPEN//.........这里部分代码省略.........

/* * If release is set, we rewind the current volume, * which we no longer want, and ask the user (console) * to mount the next volume. * *  Continue trying until we get it, and then ensure *  that we can write on it. * * This routine returns a 0 only if it is REALLY *  impossible to get the requested Volume. * */bool DCR::mount_next_write_volume(){   int retry = 0;   bool ask = false, recycle, autochanger;   bool do_find = true;   int mode;   DCR *dcr = this;   Dmsg2(150, "Enter mount_next_volume(release=%d) dev=%s/n", dev->must_unload(),      dev->print_name());   init_device_wait_timers(dcr);   lock_volumes();      /*    * Attempt to mount the next volume. If something non-fatal goes    *  wrong, we come back here to re-try (new op messages, re-read    *  Volume, ...)    */mount_next_vol:   Dmsg1(150, "mount_next_vol retry=%d/n", retry);   /* Ignore retry if this is poll request */   if (!dev->poll && retry++ > 4) {      /* Last ditch effort before giving up, force operator to respond */      VolCatInfo.Slot = 0;      unlock_volumes();      if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {         Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s./n"),              dev->print_name());         goto no_lock_bail_out;      }      lock_volumes();      Dmsg1(150, "Continue after dir_ask_sysop_to_mount. must_load=%d/n", dev->must_load());   }   if (job_canceled(jcr)) {      Jmsg(jcr, M_FATAL, 0, _("Job %d canceled./n"), jcr->JobId);      goto bail_out;   }   recycle = false;   if (retry >= 2) {      do_find = false;    }   if (dev->must_unload()) {      ask = true;                     /* ask operator to mount tape */      do_find = true;                 /* re-find a volume after unload */   }   do_unload();   do_swapping(true /*is_writing*/);   do_load(true /*is_writing*/);   if (do_find && !find_a_volume()) {      goto no_lock_bail_out;   }   if (job_canceled(jcr)) {      goto bail_out;   }   Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d/n",         VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);      /*    * Get next volume and ready it for append    * This code ensures that the device is ready for    * writing. We start from the assumption that there    * may not be a tape mounted.    *    * If the device is a file, we create the output    * file. If it is a tape, we check the volume name    * and move the tape to the end of data.    *    */   if (autoload_device(dcr, true/*writing*/, NULL) > 0) {      autochanger = true;      ask = false;   } else {      autochanger = false;      VolCatInfo.Slot = 0;      ask = retry >= 2;   }   Dmsg1(150, "autoload_dev returns %d/n", autochanger);   /*    * If we autochanged to correct Volume or (we have not just    *   released the Volume AND we can automount) we go ahead    *   and read the label. If there is no tape in the drive,    *   we will fail, recurse and ask the operator the next time.    *///.........这里部分代码省略.........

//.........这里部分代码省略.........      }      break;   case STREAM_RESTORE_OBJECT:      /* nothing to do */      break;   /* Data stream and extracting */   case STREAM_FILE_DATA:   case STREAM_SPARSE_DATA:   case STREAM_WIN32_DATA:      if (extract) {         if (rec->maskedStream == STREAM_SPARSE_DATA) {            ser_declare;            uint64_t faddr;            wbuf = rec->data + OFFSET_FADDR_SIZE;            wsize = rec->data_len - OFFSET_FADDR_SIZE;            ser_begin(rec->data, OFFSET_FADDR_SIZE);            unser_uint64(faddr);            if (fileAddr != faddr) {               fileAddr = faddr;               if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {                  berrno be;                  Emsg2(M_ERROR_TERM, 0, _("Seek error on %s: %s/n"),                     attr->ofname, be.bstrerror());               }            }         } else {            wbuf = rec->data;            wsize = rec->data_len;         }         total += wsize;         Dmsg2(8, "Write %u bytes, total=%u/n", wsize, total);         store_data(&bfd, wbuf, wsize);         fileAddr += wsize;      }      break;   /* GZIP data stream */   case STREAM_GZIP_DATA:   case STREAM_SPARSE_GZIP_DATA:   case STREAM_WIN32_GZIP_DATA:#ifdef HAVE_LIBZ      if (extract) {         uLong compress_len = compress_buf_size;         int status = Z_BUF_ERROR;         if (rec->maskedStream == STREAM_SPARSE_GZIP_DATA) {            ser_declare;            uint64_t faddr;            char ec1[50];            wbuf = rec->data + OFFSET_FADDR_SIZE;            wsize = rec->data_len - OFFSET_FADDR_SIZE;            ser_begin(rec->data, OFFSET_FADDR_SIZE);            unser_uint64(faddr);            if (fileAddr != faddr) {               fileAddr = faddr;               if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {                  berrno be;                  Emsg3(M_ERROR, 0, _("Seek to %s error on %s: ERR=%s/n"),                     edit_uint64(fileAddr, ec1), attr->ofname, be.bstrerror());                  extract = false;                  return true;               }            }

int DCR::check_volume_label(bool &ask, bool &autochanger){   int vol_label_status;   /*    * If we are writing to a stream device, ASSUME the volume label    *  is correct.    */   if (dev->has_cap(CAP_STREAM)) {      vol_label_status = VOL_OK;      create_volume_label(dev, VolumeName, "Default", false /* not DVD */);      dev->VolHdr.LabelType = PRE_LABEL;   } else {      vol_label_status = read_dev_volume_label(this);   }   if (job_canceled(jcr)) {      goto check_bail_out;   }   Dmsg2(150, "Want dirVol=%s dirStat=%s/n", VolumeName,      VolCatInfo.VolCatStatus);   /*    * At this point, dev->VolCatInfo has what is in the drive, if anything,    *          and   dcr->VolCatInfo has what the Director wants.    */   switch (vol_label_status) {   case VOL_OK:      Dmsg1(150, "Vol OK name=%s/n", dev->VolHdr.VolumeName);      dev->VolCatInfo = VolCatInfo;       /* structure assignment */      break;                    /* got a Volume */   case VOL_NAME_ERROR:      VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;      char saveVolumeName[MAX_NAME_LENGTH];      Dmsg2(150, "Vol NAME Error Have=%s, want=%s/n", dev->VolHdr.VolumeName, VolumeName);      if (dev->is_volume_to_unload()) {         ask = true;         goto check_next_volume;      }      /* If not removable, Volume is broken */      if (!dev->is_removable()) {         Jmsg(jcr, M_WARNING, 0, _("Volume /"%s/" not on device %s./n"),            VolumeName, dev->print_name());         mark_volume_in_error();         goto check_next_volume;      }      /*       * OK, we got a different volume mounted. First save the       *  requested Volume info (dcr) structure, then query if       *  this volume is really OK. If not, put back the desired       *  volume name, mark it not in changer and continue.       */      dcrVolCatInfo = VolCatInfo;      /* structure assignment */      devVolCatInfo = dev->VolCatInfo;      /* structure assignment */      /* Check if this is a valid Volume in the pool */      bstrncpy(saveVolumeName, VolumeName, sizeof(saveVolumeName));      bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));      if (!dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE)) {         POOL_MEM vol_info_msg;         pm_strcpy(vol_info_msg, jcr->dir_bsock->msg);  /* save error message */         /* Restore desired volume name, note device info out of sync */         /* This gets the info regardless of the Pool */         bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));         if (autochanger && !dir_get_volume_info(this, GET_VOL_INFO_FOR_READ)) {            /*             * If we get here, we know we cannot write on the Volume,             *  and we know that we cannot read it either, so it              *  is not in the autochanger.             */            mark_volume_not_inchanger();         }         dev->VolCatInfo = devVolCatInfo;    /* structure assignment */         dev->set_unload();                  /* unload this volume */         Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume /"%s/"./n"              "    Current Volume /"%s/" not acceptable because:/n"              "    %s"),             dcrVolCatInfo.VolCatName, dev->VolHdr.VolumeName,             vol_info_msg.c_str());         ask = true;         /* Restore saved DCR before continuing */         bstrncpy(VolumeName, saveVolumeName, sizeof(VolumeName));         VolCatInfo = dcrVolCatInfo;  /* structure assignment */         goto check_next_volume;      }      /*       * This was not the volume we expected, but it is OK with       * the Director, so use it.       */      Dmsg1(150, "Got new Volume name=%s/n", VolumeName);      dev->VolCatInfo = VolCatInfo;   /* structure assignment */      Dmsg1(100, "Call reserve_volume=%s/n", dev->VolHdr.VolumeName);      if (reserve_volume(this, dev->VolHdr.VolumeName) == NULL) {         Jmsg2(jcr, M_WARNING, 0, _("Could not reserve volume %s on %s/n"),            dev->VolHdr.VolumeName, dev->print_name());         ask = true;         goto check_next_volume;      }      break;                /* got a Volume */   /*//.........这里部分代码省略.........

/* * Save the new resource by chaining it into the head list for * the resource. If this is pass 2, we update any resource * pointers (currently only in the Job resource). */bool save_resource(int type, RES_ITEM *items, int pass){   URES *res;   int rindex = type - R_FIRST;   int i;   int error = 0;   /*    * Ensure that all required items are present    */   for (i = 0; items[i].name; i++) {      if (items[i].flags & CFG_ITEM_REQUIRED) {            if (!bit_is_set(i, res_all.res_dir.hdr.item_present)) {               Emsg2(M_ABORT, 0, _("%s item is required in %s resource, but not found./n"),                 items[i].name, resources[rindex]);             }      }   }   /*    * During pass 2, we looked up pointers to all the resources    * referrenced in the current resource, , now we    * must copy their address from the static record to the allocated    * record.    */   if (pass == 2) {      switch (type) {         case R_CONSOLE:            if ((res = (URES *)GetResWithName(R_CONSOLE, res_all.res_cons.name())) == NULL) {               Emsg1(M_ABORT, 0, _("Cannot find Console resource %s/n"), res_all.res_cons.name());            } else {               res->res_cons.tls.allowed_cns = res_all.res_cons.tls.allowed_cns;            }            break;         case R_DIRECTOR:            if ((res = (URES *)GetResWithName(R_DIRECTOR, res_all.res_dir.name())) == NULL) {               Emsg1(M_ABORT, 0, _("Cannot find Director resource %s/n"), res_all.res_dir.name());            } else {               res->res_dir.tls.allowed_cns = res_all.res_dir.tls.allowed_cns;            }            break;         default:            Emsg1(M_ERROR, 0, _("Unknown resource type %d/n"), type);            error = 1;            break;      }      /*       * Note, the resoure name was already saved during pass 1,       * so here, we can just release it.       */      if (res_all.res_dir.hdr.name) {         free(res_all.res_dir.hdr.name);         res_all.res_dir.hdr.name = NULL;      }      if (res_all.res_dir.hdr.desc) {         free(res_all.res_dir.hdr.desc);         res_all.res_dir.hdr.desc = NULL;      }      return (error == 0);   }   /*    * Common    */   if (!error) {      res = (URES *)malloc(resources[rindex].size);      memcpy(res, &res_all, resources[rindex].size);      if (!res_head[rindex]) {         res_head[rindex] = (RES *)res; /* store first entry */      } else {         RES *next, *last;         for (last=next=res_head[rindex]; next; next=next->next) {            last = next;            if (bstrcmp(next->name, res->res_dir.name())) {               Emsg2(M_ERROR_TERM, 0,                     _("Attempt to define second %s resource named /"%s/" is not permitted./n"),                     resources[rindex].name, res->res_dir.name());            }         }         last->next = (RES *)res;         Dmsg2(90, "Inserting %s res: %s/n", res_to_str(type), res->res_dir.name());      }   }   return (error == 0);}

int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes){   int32_t nleft, nwritten;   if (bsock->is_spooling()) {      nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);      if (nwritten != nbytes) {         berrno be;         bsock->b_errno = errno;         Qmsg3(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. wrote=%d wanted=%d bytes. ERR=%s/n"),               nbytes, nwritten, be.bstrerror());         Dmsg2(400, "nwritten=%d nbytes=%d./n", nwritten, nbytes);         errno = bsock->b_errno;         return -1;      }      return nbytes;   }#ifdef HAVE_TLS   if (bsock->tls) {      /* TLS enabled */      return (tls_bsock_writen(bsock, ptr, nbytes));   }#endif /* HAVE_TLS */   nleft = nbytes;   while (nleft > 0) {      do {         errno = 0;         nwritten = socketWrite(bsock->m_fd, ptr, nleft);         if (bsock->is_timed_out() || bsock->is_terminated()) {            return -1;         }#ifdef HAVE_WIN32         /*          * For Windows, we must simulate Unix errno on a socket          *  error in order to handle errors correctly.          */         if (nwritten == SOCKET_ERROR) {            DWORD err = WSAGetLastError();            nwritten = -1;            if (err == WSAEINTR) {               errno = EINTR;            } else if (err == WSAEWOULDBLOCK) {               errno = EAGAIN;            } else {               errno = EIO;        /* some other error */            }         }#endif      } while (nwritten == -1 && errno == EINTR);      /*       * If connection is non-blocking, we will get EAGAIN, so       * use select() to keep from consuming all the CPU       * and try again.       */      if (nwritten == -1 && errno == EAGAIN) {         fd_set fdset;         struct timeval tv;         FD_ZERO(&fdset);         FD_SET((unsigned)bsock->m_fd, &fdset);         tv.tv_sec = 1;         tv.tv_usec = 0;         select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);         continue;      }      if (nwritten <= 0) {         return -1;                /* error */      }      nleft -= nwritten;      ptr += nwritten;      if (bsock->use_bwlimit()) {         bsock->control_bwlimit(nwritten);      }   }   return nbytes - nleft;}

//.........这里部分代码省略.........         }      }      switch (i) {      case 0:                         /* Want VOL1 label */         if (stat == 80) {            if (strncmp("VOL1", label, 4) == 0) {               ok = true;               dev->label_type = B_ANSI_LABEL;               Dmsg0(100, "Got ANSI VOL1 label/n");            } else {               /* Try EBCDIC */               ebcdic_to_ascii(label, label, sizeof(label));               if (strncmp("VOL1", label, 4) == 0) {                  ok = true;;                  dev->label_type = B_IBM_LABEL;                  Dmsg0(100, "Found IBM label./n");                  Dmsg0(100, "Got IBM VOL1 label/n");               }            }                }         if (!ok) {            Dmsg0(100, "No VOL1 label/n");            Mmsg0(jcr->errmsg, _("No VOL1 label while reading ANSI/IBM label./n"));            return VOL_NO_LABEL;   /* No ANSI label */         }         /* Compare Volume Names allow special wild card */         if (VolName && *VolName && *VolName != '*') {             if (!same_label_names(VolName, &label[4])) {               char *p = &label[4];               char *q;                 free_volume(dev);               /* Store new Volume name */               q = dev->VolHdr.VolumeName;               for (int i=0; *p != ' ' && i < 6; i++) {                  *q++ = *p++;               }               *q = 0;               Dmsg0(100, "Call reserve_volume/n");               /* ***FIXME***  why is this reserve_volume() needed???? KES */               reserve_volume(dcr, dev->VolHdr.VolumeName);               dev = dcr->dev;            /* may have changed in reserve_volume */               Dmsg2(100, "Wanted ANSI Vol %s got %6s/n", VolName, dev->VolHdr.VolumeName);               Mmsg2(jcr->errmsg, _("Wanted ANSI Volume /"%s/" got /"%s/"/n"), VolName, dev->VolHdr.VolumeName);               return VOL_NAME_ERROR;            }         }         break;      case 1:         if (dev->label_type == B_IBM_LABEL) {            ebcdic_to_ascii(label, label, sizeof(label));         }         if (stat != 80 || strncmp("HDR1", label, 4) != 0) {            Dmsg0(100, "No HDR1 label/n");            Mmsg0(jcr->errmsg, _("No HDR1 label while reading ANSI label./n"));            return VOL_LABEL_ERROR;         }         if (strncmp("BACULA.DATA", &label[4], 11) != 0) {            Dmsg1(100, "HD1 not Bacula label. Wanted  BACULA.DATA got %11s/n",               &label[4]);            Mmsg1(jcr->errmsg, _("ANSI/IBM Volume /"%s/" does not belong to Bacula./n"),               dev->VolHdr.VolumeName);            return VOL_NAME_ERROR;     /* Not a Bacula label */         }         Dmsg0(100, "Got HDR1 label/n");         break;      case 2:         if (dev->label_type == B_IBM_LABEL) {            ebcdic_to_ascii(label, label, sizeof(label));         }         if (stat != 80 || strncmp("HDR2", label, 4) != 0) {            Dmsg0(100, "No HDR2 label/n");            Mmsg0(jcr->errmsg, _("No HDR2 label while reading ANSI/IBM label./n"));            return VOL_LABEL_ERROR;         }         Dmsg0(100, "Got ANSI HDR2 label/n");         break;      default:         if (stat == 0) {            Dmsg0(100, "ANSI label OK/n");            return VOL_OK;         }         if (dev->label_type == B_IBM_LABEL) {            ebcdic_to_ascii(label, label, sizeof(label));         }         if (stat != 80 || strncmp("HDR", label, 3) != 0) {            Dmsg0(100, "Unknown or bad ANSI/IBM label record./n");            Mmsg0(jcr->errmsg, _("Unknown or bad ANSI/IBM label record./n"));            return VOL_LABEL_ERROR;         }         Dmsg0(100, "Got HDR label/n");         break;      }   }   Dmsg0(100, "Too many records in ANSI/IBM label./n");   Mmsg0(jcr->errmsg, _("Too many records in while reading ANSI/IBM label./n"));   return VOL_LABEL_ERROR;}  

/********************************************************************* * Acquire device for reading. *  The drive should have previously been reserved by calling *  reserve_device_for_read(). We read the Volume label from the block and *  leave the block pointers just after the label. * *  Returns: NULL if failed for any reason *           dcr  if successful */bool acquire_device_for_read(DCR *dcr){   DEVICE *dev;   JCR *jcr = dcr->jcr;   bool ok = false;   bool tape_previously_mounted;   VOL_LIST *vol;   bool try_autochanger = true;   int i;   int vol_label_status;   int retry = 0;   Enter(rdbglvl);   dev = dcr->dev;   dev->Lock_read_acquire();   Dmsg2(rdbglvl, "dcr=%p dev=%p/n", dcr, dcr->dev);   Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s/n", dcr->media_type, dev->device->media_type);   dev->dblock(BST_DOING_ACQUIRE);   if (dev->num_writers > 0) {      Jmsg2(jcr, M_FATAL, 0, _("Acquire read: num_writers=%d not zero. Job %d canceled./n"),         dev->num_writers, jcr->JobId);      goto get_out;   }   /* Find next Volume, if any */   vol = jcr->VolList;   if (!vol) {      char ed1[50];      Jmsg(jcr, M_FATAL, 0, _("No volumes specified for reading. Job %s canceled./n"),         edit_int64(jcr->JobId, ed1));      goto get_out;   }   jcr->CurReadVolume++;   for (i=1; i<jcr->CurReadVolume; i++) {      vol = vol->next;   }   if (!vol) {      Jmsg(jcr, M_FATAL, 0, _("Logic error: no next volume to read. Numvol=%d Curvol=%d/n"),         jcr->NumReadVolumes, jcr->CurReadVolume);      goto get_out;                   /* should not happen */   }   set_dcr_from_vol(dcr, vol);   Dmsg2(rdbglvl, "Want Vol=%s Slot=%d/n", vol->VolumeName, vol->Slot);   /*    * If the MediaType requested for this volume is not the    *  same as the current drive, we attempt to find the same    *  device that was used to write the orginal volume.  If    *  found, we switch to using that device.    *    *  N.B. A lot of routines rely on the dcr pointer not changing    *    read_records.c even has multiple dcrs cached, so we take care    *    here to release all important parts of the dcr and re-acquire    *    them such as the block pointer (size may change), but we do    *    not release the dcr.    */   Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s/n", dcr->media_type, dev->device->media_type);   if (dcr->media_type[0] && !bstrcmp(dcr->media_type, dev->device->media_type)) {      RCTX rctx;      DIRSTORE *store;      int status;      Jmsg3(jcr, M_INFO, 0, _("Changing read device. Want Media Type=/"%s/" have=/"%s/"/n"                              "  device=%s/n"),            dcr->media_type, dev->device->media_type, dev->print_name());      Dmsg3(rdbglvl, "Changing read device. Want Media Type=/"%s/" have=/"%s/"/n"                     "  device=%s/n",            dcr->media_type, dev->device->media_type, dev->print_name());      dev->dunblock(DEV_UNLOCKED);      lock_reservations();      memset(&rctx, 0, sizeof(RCTX));      rctx.jcr = jcr;      jcr->read_dcr = dcr;      jcr->reserve_msgs = New(alist(10, not_owned_by_alist));      rctx.any_drive = true;      rctx.device_name = vol->device;      store = new DIRSTORE;      memset(store, 0, sizeof(DIRSTORE));      store->name[0] = 0; /* No dir name */      bstrncpy(store->media_type, vol->MediaType, sizeof(store->media_type));      bstrncpy(store->pool_name, dcr->pool_name, sizeof(store->pool_name));      bstrncpy(store->pool_type, dcr->pool_type, sizeof(store->pool_type));      store->append = false;      rctx.store = store;      clean_device(dcr);                     /* clean up the dcr */      /*//.........这里部分代码省略.........

/* * Find JobId of last job that ran.  E.g. for *   VERIFY_CATALOG we want the JobId of the last INIT. *   For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the last Job. * * Returns: true  on success *          false on failure */bool db_find_last_jobid(JCR *jcr, B_DB *mdb, const char *Name, JOB_DBR *jr){   bool retval = false;   SQL_ROW row;   char ed1[50];   char esc_name[MAX_ESCAPE_NAME_LENGTH];   db_lock(mdb);   /* Find last full */   Dmsg2(100, "JobLevel=%d JobType=%d/n", jr->JobLevel, jr->JobType);   if (jr->JobLevel == L_VERIFY_CATALOG) {      mdb->db_escape_string(jcr, esc_name, jr->Name, strlen(jr->Name));      Mmsg(mdb->cmd,"SELECT JobId FROM Job WHERE Type='V' AND Level='%c' AND "" JobStatus IN ('T','W') AND Name='%s' AND ""ClientId=%s ORDER BY StartTime DESC LIMIT 1",           L_VERIFY_INIT, esc_name,           edit_int64(jr->ClientId, ed1));   } else if (jr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||              jr->JobLevel == L_VERIFY_DISK_TO_CATALOG ||              jr->JobType == JT_BACKUP) {      if (Name) {         mdb->db_escape_string(jcr, esc_name, (char*)Name,                               MIN(strlen(Name), sizeof(esc_name)));         Mmsg(mdb->cmd,"SELECT JobId FROM Job WHERE Type='B' AND JobStatus IN ('T','W') AND ""Name='%s' ORDER BY StartTime DESC LIMIT 1", esc_name);      } else {         Mmsg(mdb->cmd,"SELECT JobId FROM Job WHERE Type='B' AND JobStatus IN ('T','W') AND ""ClientId=%s ORDER BY StartTime DESC LIMIT 1",           edit_int64(jr->ClientId, ed1));      }   } else {      Mmsg1(&mdb->errmsg, _("Unknown Job level=%d/n"), jr->JobLevel);      goto bail_out;   }   Dmsg1(100, "Query: %s/n", mdb->cmd);   if (!QUERY_DB(jcr, mdb, mdb->cmd)) {      goto bail_out;   }   if ((row = sql_fetch_row(mdb)) == NULL) {      Mmsg1(&mdb->errmsg, _("No Job found for: %s./n"), mdb->cmd);      sql_free_result(mdb);      goto bail_out;   }   jr->JobId = str_to_int64(row[0]);   sql_free_result(mdb);   Dmsg1(100, "db_get_last_jobid: got JobId=%d/n", jr->JobId);   if (jr->JobId <= 0) {      Mmsg1(&mdb->errmsg, _("No Job found for: %s/n"), mdb->cmd);      goto bail_out;   }   retval = true;bail_out:   db_unlock(mdb);   return retval;}

void dump_record(const char *tag, const DEV_RECORD *rec){   char stream[128];   char findex[128];   Dmsg2(100, "%s: rec %p/n", tag, rec);   Dmsg3(100, "%-14s next %p prev %p/n", "link", rec->link.next, rec->link.prev);   Dmsg2(100, "%-14s %u/n", "File", rec->File);   Dmsg2(100, "%-14s %u/n", "Block", rec->Block);   Dmsg2(100, "%-14s %u/n", "VolSessionId", rec->VolSessionId);   Dmsg2(100, "%-14s %u/n", "VolSessionTime", rec->VolSessionTime);   Dmsg2(100, "%-14s %s/n", "FileIndex", findex_to_str(rec->FileIndex, findex, sizeof(findex)));   Dmsg2(100, "%-14s %s/n", "Stream", stream_to_ascii(stream, rec->Stream, rec->FileIndex));   Dmsg2(100, "%-14s %d/n", "maskedStream", rec->maskedStream);   Dmsg2(100, "%-14s %u/n", "data_len", rec->data_len);   Dmsg2(100, "%-14s %u/n", "remainder", rec->remainder);   for (unsigned int i = 0; i < (sizeof(rec->state_bits) / sizeof(rec->state_bits[0])); i++) {      Dmsg3(100, "%-11s[%d]        %2.2x/n", "state_bits", i, (uint8_t)rec->state_bits[i]);   }   Dmsg3(100, "%-14s %u (%s)/n", "state", rec->state, record_state_to_ascii(rec->state));   Dmsg2(100, "%-14s %p/n", "bsr", rec->bsr);   for (unsigned int i = 0; i < (sizeof(rec->ser_buf) / sizeof(rec->ser_buf[0])); i++) {      Dmsg3(100, "%-11s[%d] %2.2x/n", "ser_buf", i, (uint8_t)rec->ser_buf[i]);   }   Dmsg2(100, "%-14s %p/n", "data", rec->data);   Dmsg2(100, "%-14s %d/n", "match_stat", rec->match_stat);   Dmsg2(100, "%-14s %u/n", "last_VolSessionId", rec->last_VolSessionId);   Dmsg2(100, "%-14s %u/n", "last_VolSessionTime", rec->last_VolSessionTime);   Dmsg2(100, "%-14s %d/n", "last_FileIndex", rec->last_FileIndex);   Dmsg2(100, "%-14s %d/n", "last_Stream", rec->last_Stream);   Dmsg2(100, "%-14s %s/n", "own_mempool", rec->own_mempool ? "true" : "false");}

/* * Find job start time if JobId specified, otherwise * find last Job start time Incremental and Differential saves. * *  StartTime is returned in stime *  Job name is returned in job (MAX_NAME_LENGTH) * * Returns: 0 on failure *          1 on success, jr is unchanged, but stime and job are set */bool db_find_job_start_time(JCR *jcr, B_DB *mdb, JOB_DBR *jr, POOLMEM **stime, char *job){   bool retval = false;   SQL_ROW row;   char ed1[50], ed2[50];   char esc_name[MAX_ESCAPE_NAME_LENGTH];   db_lock(mdb);   mdb->db_escape_string(jcr, esc_name, jr->Name, strlen(jr->Name));   pm_strcpy(stime, "0000-00-00 00:00:00");   /* default */   job[0] = 0;   /* If no Id given, we must find corresponding job */   if (jr->JobId == 0) {      /* Differential is since last Full backup */      Mmsg(mdb->cmd,"SELECT StartTime, Job FROM Job WHERE JobStatus IN ('T','W') AND Type='%c' AND ""Level='%c' AND Name='%s' AND ClientId=%s AND FileSetId=%s ""ORDER BY StartTime DESC LIMIT 1",           jr->JobType, L_FULL, esc_name,           edit_int64(jr->ClientId, ed1), edit_int64(jr->FileSetId, ed2));      if (jr->JobLevel == L_DIFFERENTIAL) {         /* SQL cmd for Differential backup already edited above */      /* Incremental is since last Full, Incremental, or Differential */      } else if (jr->JobLevel == L_INCREMENTAL) {         /*          * For an Incremental job, we must first ensure          *  that a Full backup was done (cmd edited above)          *  then we do a second look to find the most recent          *  backup          */         if (!QUERY_DB(jcr, mdb, mdb->cmd)) {            Mmsg2(&mdb->errmsg, _("Query error for start time request: ERR=%s/nCMD=%s/n"),               sql_strerror(mdb), mdb->cmd);            goto bail_out;         }         if ((row = sql_fetch_row(mdb)) == NULL) {            sql_free_result(mdb);            Mmsg(mdb->errmsg, _("No prior Full backup Job record found./n"));            goto bail_out;         }         sql_free_result(mdb);         /* Now edit SQL command for Incremental Job */         Mmsg(mdb->cmd,"SELECT StartTime, Job FROM Job WHERE JobStatus IN ('T','W') AND Type='%c' AND ""Level IN ('%c','%c','%c') AND Name='%s' AND ClientId=%s ""AND FileSetId=%s ORDER BY StartTime DESC LIMIT 1",            jr->JobType, L_INCREMENTAL, L_DIFFERENTIAL, L_FULL, esc_name,            edit_int64(jr->ClientId, ed1), edit_int64(jr->FileSetId, ed2));      } else {         Mmsg1(mdb->errmsg, _("Unknown level=%d/n"), jr->JobLevel);         goto bail_out;      }   } else {      Dmsg1(100, "Submitting: %s/n", mdb->cmd);      Mmsg(mdb->cmd, "SELECT StartTime, Job FROM Job WHERE Job.JobId=%s",           edit_int64(jr->JobId, ed1));   }   if (!QUERY_DB(jcr, mdb, mdb->cmd)) {      pm_strcpy(stime, "");                   /* set EOS */      Mmsg2(&mdb->errmsg, _("Query error for start time request: ERR=%s/nCMD=%s/n"),         sql_strerror(mdb),  mdb->cmd);      goto bail_out;   }   if ((row = sql_fetch_row(mdb)) == NULL) {      Mmsg2(&mdb->errmsg, _("No Job record found: ERR=%s/nCMD=%s/n"),         sql_strerror(mdb),  mdb->cmd);      sql_free_result(mdb);      goto bail_out;   }   Dmsg2(100, "Got start time: %s, job: %s/n", row[0], row[1]);   pm_strcpy(stime, row[0]);   bstrncpy(job, row[1], MAX_NAME_LENGTH);   sql_free_result(mdb);   retval = true;bail_out:   db_unlock(mdb);   return retval;}

/* Store Messages Destination information */void store_msgs(LEX *lc, RES_ITEM *item, int index, int pass){   int token;   char *cmd;   POOLMEM *dest;   int dest_len;   Dmsg2(900, "store_msgs pass=%d code=%d/n", pass, item->code);   if (pass == 1) {      switch (item->code) {      case MD_STDOUT:      case MD_STDERR:      case MD_SYSLOG:              /* syslog */      case MD_CONSOLE:      case MD_CATALOG:         scan_types(lc, (MSGS *)(item->value), item->code, NULL, NULL);         break;      case MD_OPERATOR:            /* send to operator */      case MD_DIRECTOR:            /* send to Director */      case MD_MAIL:                /* mail */      case MD_MAIL_ON_ERROR:       /* mail if Job errors */      case MD_MAIL_ON_SUCCESS:     /* mail if Job succeeds */         if (item->code == MD_OPERATOR) {            cmd = res_all.res_msgs.operator_cmd;         } else {            cmd = res_all.res_msgs.mail_cmd;         }         dest = get_pool_memory(PM_MESSAGE);         dest[0] = 0;         dest_len = 0;         /* Pick up comma separated list of destinations */         for ( ;; ) {            token = lex_get_token(lc, T_NAME);   /* scan destination */            dest = check_pool_memory_size(dest, dest_len + lc->str_len + 2);            if (dest[0] != 0) {               pm_strcat(dest, " ");  /* separate multiple destinations with space */               dest_len++;            }            pm_strcat(dest, lc->str);            dest_len += lc->str_len;            Dmsg2(900, "store_msgs newdest=%s: dest=%s:/n", lc->str, NPRT(dest));            token = lex_get_token(lc, T_SKIP_EOL);            if (token == T_COMMA) {               continue;           /* get another destination */            }            if (token != T_EQUALS) {               scan_err1(lc, _("expected an =, got: %s"), lc->str);               return;            }            break;         }         Dmsg1(900, "mail_cmd=%s/n", NPRT(cmd));         scan_types(lc, (MSGS *)(item->value), item->code, dest, cmd);         free_pool_memory(dest);         Dmsg0(900, "done with dest codes/n");         break;      case MD_FILE:                /* file */      case MD_APPEND:              /* append */         dest = get_pool_memory(PM_MESSAGE);         /* Pick up a single destination */         token = lex_get_token(lc, T_NAME);   /* scan destination */         pm_strcpy(dest, lc->str);         dest_len = lc->str_len;         token = lex_get_token(lc, T_SKIP_EOL);         Dmsg1(900, "store_msgs dest=%s:/n", NPRT(dest));         if (token != T_EQUALS) {            scan_err1(lc, _("expected an =, got: %s"), lc->str);            return;         }         scan_types(lc, (MSGS *)(item->value), item->code, dest, NULL);         free_pool_memory(dest);         Dmsg0(900, "done with dest codes/n");         break;      default:         scan_err1(lc, _("Unknown item code: %d/n"), item->code);         return;      }   }   scan_to_eol(lc);   set_bit(index, res_all.hdr.item_present);   Dmsg0(900, "Done store_msgs/n");}

/** * Common routine for: *   dir_get_volume_info() * and *   dir_find_next_appendable_volume() * *  NOTE!!! All calls to this routine must be protected by *          locking vol_info_mutex before calling it so that *          we don't have one thread modifying the parameters *          and another reading them. * *  Returns: true  on success and vol info in dcr->VolCatInfo *           false on failure */static bool do_get_volume_info(DCR *dcr){    JCR *jcr = dcr->jcr;    BSOCK *dir = jcr->dir_bsock;    VOLUME_CAT_INFO vol;    int n;    int32_t InChanger;    dcr->setVolCatInfo(false);    if (dir->recv() <= 0) {       Dmsg0(dbglvl, "getvolname error bnet_recv/n");       Mmsg(jcr->errmsg, _("Network error on bnet_recv in req_vol_info./n"));       return false;    }    memset(&vol, 0, sizeof(vol));    Dmsg1(dbglvl, "<dird %s", dir->msg);    n = sscanf(dir->msg, OK_media, vol.VolCatName,               &vol.VolCatJobs, &vol.VolCatFiles,               &vol.VolCatBlocks, &vol.VolCatBytes,               &vol.VolCatMounts, &vol.VolCatErrors,               &vol.VolCatWrites, &vol.VolCatMaxBytes,               &vol.VolCatCapacityBytes, vol.VolCatStatus,               &vol.Slot, &vol.VolCatMaxJobs, &vol.VolCatMaxFiles,               &InChanger, &vol.VolReadTime, &vol.VolWriteTime,               &vol.EndFile, &vol.EndBlock, &vol.LabelType,               &vol.VolMediaId, vol.VolEncrKey,               &vol.VolMinBlocksize, &vol.VolMaxBlocksize);    if (n != 24) {       Dmsg3(dbglvl, "Bad response from Dir fields=%d, len=%d: %s",             n, dir->msglen, dir->msg);       Mmsg(jcr->errmsg, _("Error getting Volume info: %s"), dir->msg);       return false;    }    vol.InChanger = InChanger;        /* bool in structure */    vol.is_valid = true;    unbash_spaces(vol.VolCatName);    bstrncpy(dcr->VolumeName, vol.VolCatName, sizeof(dcr->VolumeName));    dcr->VolCatInfo = vol;            /* structure assignment */    /*     * If we received a new crypto key update the cache and write out the new cache on a change.     */    if (*vol.VolEncrKey) {       if (update_crypto_cache(vol.VolCatName, vol.VolEncrKey)) {          write_crypto_cache(me->working_directory, "bareos-sd",                             get_first_port_host_order(me->SDaddrs));       }    }    Dmsg4(dbglvl, "do_get_volume_info return true slot=%d Volume=%s, "                  "VolminBlocksize=%u VolMaxBlocksize=%u/n",          vol.Slot, vol.VolCatName, vol.VolMinBlocksize, vol.VolMaxBlocksize);    Dmsg2(dbglvl, "setting dcr->VolMinBlocksize(%u) to vol.VolMinBlocksize(%u)/n",          dcr->VolMinBlocksize, vol.VolMinBlocksize);    Dmsg2(dbglvl, "setting dcr->VolMaxBlocksize(%u) to vol.VolMaxBlocksize(%u)/n",          dcr->VolMaxBlocksize, vol.VolMaxBlocksize);    /*     * Assign the volcatinfo to the dcr.     */    dcr->VolMinBlocksize = vol.VolMinBlocksize;    dcr->VolMaxBlocksize = vol.VolMaxBlocksize;    return true;}

//.........这里部分代码省略.........               return 0;            } else if (token != T_IDENTIFIER) {               scan_err1(lc, _("Expected a Resource name identifier, got: %s"), lc->str);               return 0;            }            for (i=0; resources[i].name; i++) {               if (strcasecmp(resources[i].name, lc->str) == 0) {                  items = resources[i].items;                  if (!items) {                     break;                  }                  state = p_resource;                  res_type = resources[i].rcode;                  init_resource(this, res_type, items, pass);                  break;               }            }            if (state == p_none) {               scan_err1(lc, _("expected resource name, got: %s"), lc->str);               return 0;            }            break;         case p_resource:            switch (token) {            case T_BOB:               level++;               break;            case T_IDENTIFIER:               if (level != 1) {                  scan_err1(lc, _("not in resource definition: %s"), lc->str);                  return 0;               }               for (i=0; items[i].name; i++) {                  if (strcasecmp(items[i].name, lc->str) == 0) {                     /* If the ITEM_NO_EQUALS flag is set we do NOT                      *   scan for = after the keyword  */                     if (!(items[i].flags & ITEM_NO_EQUALS)) {                        token = lex_get_token(lc, T_SKIP_EOL);                        Dmsg1 (900, "in T_IDENT got token=%s/n", lex_tok_to_str(token));                        if (token != T_EQUALS) {                           scan_err1(lc, _("expected an equals, got: %s"), lc->str);                           return 0;                        }                     }                     Dmsg1(800, "calling handler for %s/n", items[i].name);                     /* Call item handler */                     items[i].handler(lc, &items[i], i, pass);                     i = -1;                     break;                  }               }               if (i >= 0) {                  Dmsg2(900, "level=%d id=%s/n", level, lc->str);                  Dmsg1(900, "Keyword = %s/n", lc->str);                  scan_err1(lc, _("Keyword /"%s/" not permitted in this resource./n"                     "Perhaps you left the trailing brace off of the previous resource."), lc->str);                  return 0;               }               break;            case T_EOB:               level--;               state = p_none;               Dmsg0(900, "T_EOB => define new resource/n");               if (res_all.hdr.name == NULL) {                  scan_err0(lc, _("Name not specified for resource"));                  return 0;               }               save_resource(res_type, items, pass);  /* save resource */               break;            case T_EOL:               break;            default:               scan_err2(lc, _("unexpected token %d %s in resource definition"),                  token, lex_tok_to_str(token));               return 0;            }            break;         default:            scan_err1(lc, _("Unknown parser state %d/n"), state);            return 0;         }      }      if (state != p_none) {         scan_err0(lc, _("End of conf file reached with unclosed resource."));         return 0;      }      if (debug_level >= 900 && pass == 2) {         int i;         for (i=m_r_first; i<=m_r_last; i++) {            dump_resource(i, m_res_head[i-m_r_first], prtmsg, NULL);         }      }      lc = lex_close_file(lc);   }   Dmsg0(900, "Leave parse_config()/n");   return 1;}

/** * After writing a Volume, send the updated statistics * back to the director. The information comes from the * dev record. */bool dir_update_volume_info(DCR *dcr, bool label, bool update_LastWritten){   JCR *jcr = dcr->jcr;   BSOCK *dir = jcr->dir_bsock;   DEVICE *dev = dcr->dev;   VOLUME_CAT_INFO *vol = &dev->VolCatInfo;   char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50];   int InChanger;   bool ok = false;   POOL_MEM VolumeName;   /* If system job, do not update catalog */   if (jcr->is_JobType(JT_SYSTEM)) {      return true;   }   if (vol->VolCatName[0] == 0) {      Jmsg0(jcr, M_FATAL, 0, _("NULL Volume name. This shouldn't happen!!!/n"));      Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!/n"));      return false;   }   /* Lock during Volume update */   P(vol_info_mutex);   Dmsg1(dbglvl, "Update cat VolBytes=%lld/n", vol->VolCatBytes);   /* Just labeled or relabeled the tape */   if (label) {      bstrncpy(vol->VolCatStatus, "Append", sizeof(vol->VolCatStatus));   }// if (update_LastWritten) {      vol->VolLastWritten = time(NULL);// }   pm_strcpy(VolumeName, vol->VolCatName);   bash_spaces(VolumeName);   InChanger = vol->InChanger;   dir->fsend(Update_media, jcr->Job,      VolumeName.c_str(), vol->VolCatJobs, vol->VolCatFiles,      vol->VolCatBlocks, edit_uint64(vol->VolCatBytes, ed1),      vol->VolCatMounts, vol->VolCatErrors,      vol->VolCatWrites, edit_uint64(vol->VolCatMaxBytes, ed2),      edit_uint64(vol->VolLastWritten, ed6),      vol->VolCatStatus, vol->Slot, label,      InChanger,                      /* bool in structure */      edit_int64(vol->VolReadTime, ed3),      edit_int64(vol->VolWriteTime, ed4),      edit_uint64(vol->VolFirstWritten, ed5));   Dmsg1(dbglvl, ">dird %s", dir->msg);   /* Do not lock device here because it may be locked from label */   if (!jcr->is_canceled()) {      if (!do_get_volume_info(dcr)) {         Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);         Dmsg2(dbglvl, _("Didn't get vol info vol=%s: ERR=%s"),            vol->VolCatName, jcr->errmsg);         goto bail_out;      }      Dmsg1(420, "get_volume_info() %s", dir->msg);      /* Update dev Volume info in case something changed (e.g. expired) */      dev->VolCatInfo = dcr->VolCatInfo;      ok = true;   }bail_out:   V(vol_info_mutex);   return ok;}

bool DEVICE::scan_dir_for_volume(DCR *dcr){   DIR* dp;   struct dirent *entry, *result;   int name_max;   char *mount_point;   VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;   char VolumeName[MAX_NAME_LENGTH];   struct stat statp;   bool found = false;   POOL_MEM fname(PM_FNAME);   bool need_slash = false;   int len;   dcrVolCatInfo = dcr->VolCatInfo;     /* structure assignment */   devVolCatInfo = VolCatInfo;          /* structure assignment */   bstrncpy(VolumeName, dcr->VolumeName, sizeof(VolumeName));   name_max = pathconf(".", _PC_NAME_MAX);   if (name_max < 1024) {      name_max = 1024;   }   if (device->mount_point) {      mount_point = device->mount_point;   } else {      mount_point = device->device_name;   }   if (!(dp = opendir(mount_point))) {      berrno be;      dev_errno = errno;      Dmsg3(29, "scan_dir_for_vol: failed to open dir %s (dev=%s), ERR=%s/n",            mount_point, print_name(), be.bstrerror());      goto get_out;   }   len = strlen(mount_point);   if (len > 0) {      need_slash = !IsPathSeparator(mount_point[len - 1]);   }   entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);   for ( ;; ) {      if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {         dev_errno = EIO;         Dmsg2(129, "scan_dir_for_vol: failed to find suitable file in dir %s (dev=%s)/n",               mount_point, print_name());         break;      }      if (strcmp(result->d_name, ".") == 0 ||          strcmp(result->d_name, "..") == 0) {         continue;      }      if (!is_volume_name_legal(result->d_name)) {         continue;      }      pm_strcpy(fname, mount_point);      if (need_slash) {         pm_strcat(fname, "/");      }      pm_strcat(fname, result->d_name);      if (lstat(fname.c_str(), &statp) != 0 ||          !S_ISREG(statp.st_mode)) {         continue;                 /* ignore directories & special files */      }      /*       * OK, we got a different volume mounted. First save the       *  requested Volume info (dcr) structure, then query if       *  this volume is really OK. If not, put back the desired       *  volume name, mark it not in changer and continue.       */      /* Check if this is a valid Volume in the pool */      bstrncpy(dcr->VolumeName, result->d_name, sizeof(dcr->VolumeName));      if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {         continue;      }      /* This was not the volume we expected, but it is OK with       * the Director, so use it.       */      VolCatInfo = dcr->VolCatInfo;       /* structure assignment */      found = true;      break;                /* got a Volume */   }   free(entry);   closedir(dp);get_out:   if (!found) {      /* Restore VolumeName we really wanted */      bstrncpy(dcr->VolumeName, VolumeName, sizeof(dcr->VolumeName));      dcr->VolCatInfo = dcrVolCatInfo;     /* structure assignment */      VolCatInfo = devVolCatInfo;          /* structure assignment */   }   Dsm_check(100);   return found;}

/* * Verify attributes of the requested files on the Volume * */void do_verify_volume(JCR *jcr){   BSOCK *sd, *dir;   POOLMEM *fname;                    /* original file name */   POOLMEM *lname;                    /* link name */   int32_t stream;   uint32_t size;   uint32_t VolSessionId, VolSessionTime, file_index;   uint32_t record_file_index;   char digest[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];   int type, stat;   sd = jcr->store_bsock;   if (!sd) {      Jmsg(jcr, M_FATAL, 0, _("Storage command not issued before Verify./n"));      jcr->setJobStatus(JS_FatalError);      return;   }   dir = jcr->dir_bsock;   jcr->setJobStatus(JS_Running);   LockRes();   CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);   UnlockRes();   uint32_t buf_size;   if (client) {      buf_size = client->max_network_buffer_size;   } else {      buf_size = 0;                   /* use default */   }   if (!sd->set_buffer_size(buf_size, BNET_SETBUF_WRITE)) {      jcr->setJobStatus(JS_FatalError);      return;   }   jcr->buf_size = sd->msglen;   fname = get_pool_memory(PM_FNAME);   lname = get_pool_memory(PM_FNAME);   /*    * Get a record from the Storage daemon    */   while (bget_msg(sd) >= 0 && !job_canceled(jcr)) {      /*       * First we expect a Stream Record Header       */      if (sscanf(sd->msg, rec_header, &VolSessionId, &VolSessionTime, &file_index,          &stream, &size) != 5) {         Jmsg1(jcr, M_FATAL, 0, _("Record header scan error: %s/n"), sd->msg);         goto bail_out;      }      Dmsg3(30, "Got hdr: FilInx=%d Stream=%d size=%d./n", file_index, stream, size);      /*       * Now we expect the Stream Data       */      if (bget_msg(sd) < 0) {         Jmsg1(jcr, M_FATAL, 0, _("Data record error. ERR=%s/n"), sd->bstrerror());         goto bail_out;      }      if (size != ((uint32_t)sd->msglen)) {         Jmsg2(jcr, M_FATAL, 0, _("Actual data size %d not same as header %d/n"), sd->msglen, size);         goto bail_out;      }      Dmsg2(30, "Got stream data %s, len=%d/n", stream_to_ascii(stream), sd->msglen);      /* File Attributes stream */      switch (stream) {      case STREAM_UNIX_ATTRIBUTES:      case STREAM_UNIX_ATTRIBUTES_EX:         char *ap, *lp, *fp;         Dmsg0(400, "Stream=Unix Attributes./n");         if ((int)sizeof_pool_memory(fname) < sd->msglen) {            fname = realloc_pool_memory(fname, sd->msglen + 1);         }         if ((int)sizeof_pool_memory(lname) < sd->msglen) {            lname = realloc_pool_memory(lname, sd->msglen + 1);         }         *fname = 0;         *lname = 0;         /*          * An Attributes record consists of:          *    File_index          *    Type   (FT_types)          *    Filename          *    Attributes          *    Link name (if file linked i.e. FT_LNK)          *    Extended Attributes (if Win32)          */         if (sscanf(sd->msg, "%d %d", &record_file_index, &type) != 2) {            Jmsg(jcr, M_FATAL, 0, _("Error scanning record header: %s/n"), sd->msg);            Dmsg0(0, "/nError scanning header/n");//.........这里部分代码省略.........

/* * BSR + EOF => begin of EOF + EIO * BSR + BSR + EOF => last block * current_block = -1 */int vtape::bsr(int count){   ASSERT(online);   ASSERT(current_file >= 0);   ASSERT(count == 1);   ASSERT(fd >= 0);   check_eof();   if (!count) {      return 0;   }   int ret=0;   int last_f=0;   int last_b=0;   boffset_t last=-1, last2=-1;   boffset_t orig = lseek(fd, 0, SEEK_CUR);   int orig_f = current_file;   int orig_b = current_block;   Dmsg4(dbglevel, "bsr(%i) cur_blk=%i orig=%lli cur_FM=%lli/n",         count, current_block, orig, cur_FM);   /* begin of tape, do nothing */   if (atBOT) {      errno = EIO;      return -1;   }   /* at EOF 0:-1 BOT=0 EOD=0 EOF=0 ERR: Input/output error  */   if (atEOF) {      lseek(fd, cur_FM, SEEK_SET);      atEOF = false;      if (current_file > 0) {         current_file--;      }      current_block=-1;      errno = EIO;      return -1;   }   /*    * First, go to cur/last_FM and read all blocks to find the good one    */   if (cur_FM == orig) {        /* already just before  EOF */      lseek(fd, last_FM, SEEK_SET);   } else {      lseek(fd, cur_FM, SEEK_SET);   }   ret = read_fm(VT_READ_EOF);   do {      if (!atEOF) {         last2 = last;          /* keep track of the 2 last blocs position */         last = lseek(fd, 0, SEEK_CUR);         last_f = current_file;         last_b = current_block;         Dmsg6(dbglevel, "EOF=%i last2=%lli last=%lli < orig=%lli %i:%i/n",               atEOF, last2, last, orig, current_file, current_block);      }      ret = fsr(1);   } while ((lseek(fd, 0, SEEK_CUR) < orig) && (ret == 0));   if (last2 > 0 && atEOF) {    /* we take the previous position */      lseek(fd, last2, SEEK_SET);      current_file = last_f;      current_block = last_b - 1;      Dmsg3(dbglevel, "1 set offset2=%lli %i:%i/n",            last, current_file, current_block);   } else if (last > 0) {      lseek(fd, last, SEEK_SET);      current_file = last_f;      current_block = last_b;      Dmsg3(dbglevel, "2 set offset=%lli %i:%i/n",            last, current_file, current_block);   } else {      lseek(fd, orig, SEEK_SET);      current_file = orig_f;      current_block = orig_b;      return -1;   }   Dmsg2(dbglevel, "bsr %i:%i/n", current_file, current_block);   errno=0;   atEOT = atEOF = atEOD = false;   atBOT = (lseek(fd, 0, SEEK_CUR) - (sizeof(uint32_t)+2*sizeof(boffset_t))) == 0;   if (orig_b == -1) {      current_block = orig_b;   }//.........这里部分代码省略.........

//.........这里部分代码省略.........    *   So we get the (stream header, data, EOD) three time for each    *   file. 1. for the Attributes, 2. for the file data if any,    *   and 3. for the MD5 if any.    */   dcr->VolFirstIndex = dcr->VolLastIndex = 0;   jcr->run_time = time(NULL);              /* start counting time for rates */   for (last_file_index = 0; ok && !jcr->is_job_canceled(); ) {      /* Read Stream header from the File daemon.       *  The stream header consists of the following:       *    file_index (sequential Bacula file index, base 1)       *    stream     (Bacula number to distinguish parts of data)       *    info       (Info for Storage daemon -- compressed, encrypted, ...)       *       info is not currently used, so is read, but ignored!       */     if ((n=bget_msg(fd)) <= 0) {         if (n == BNET_SIGNAL && fd->msglen == BNET_EOD) {            break;                    /* end of data */         }         Jmsg1(jcr, M_FATAL, 0, _("Error reading data header from FD. ERR=%s/n"),               fd->bstrerror());         possible_incomplete_job(jcr, last_file_index);         ok = false;         break;      }      if (sscanf(fd->msg, "%ld %ld", &file_index, &stream) != 2) {         Jmsg1(jcr, M_FATAL, 0, _("Malformed data header from FD: %s/n"), fd->msg);         ok = false;         possible_incomplete_job(jcr, last_file_index);         break;      }      Dmsg2(890, "<filed: Header FilInx=%d stream=%d/n", file_index, stream);      /*       * We make sure the file_index is advancing sequentially.       * An incomplete job can start the file_index at any number.       * otherwise, it must start at 1.       */      if (jcr->rerunning && file_index > 0 && last_file_index == 0) {         goto fi_checked;      }      if (file_index > 0 && (file_index == last_file_index ||          file_index == last_file_index + 1)) {         goto fi_checked;      }      Jmsg2(jcr, M_FATAL, 0, _("FI=%d from FD not positive or sequential=%d/n"),            file_index, last_file_index);      possible_incomplete_job(jcr, last_file_index);      ok = false;      break;fi_checked:      if (file_index != last_file_index) {         jcr->JobFiles = file_index;         last_file_index = file_index;      }      /* Read data stream from the File daemon.       *  The data stream is just raw bytes       */      while ((n=bget_msg(fd)) > 0 && !jcr->is_job_canceled()) {         rec.VolSessionId = jcr->VolSessionId;         rec.VolSessionTime = jcr->VolSessionTime;         rec.FileIndex = file_index;

/** * Set Extended File Attributes for Win32 * *  fname is the original filename *  ofile is the output filename (may be in a different directory) * * Returns:  true  on success *           false on failure */static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd){   char *p = attr->attrEx;   int64_t val;   WIN32_FILE_ATTRIBUTE_DATA atts;   ULARGE_INTEGER li;   POOLMEM *win32_ofile;   /** if we have neither Win ansi nor wchar API, get out */   if (!(p_SetFileAttributesW || p_SetFileAttributesA)) {      return false;   }   if (!p || !*p) {                   /* we should have attributes */      Dmsg2(100, "Attributes missing. of=%s ofd=%d/n", attr->ofname, ofd->fid);      if (is_bopen(ofd)) {         bclose(ofd);      }      return false;   } else {      Dmsg2(100, "Attribs %s = %s/n", attr->ofname, attr->attrEx);   }   p += from_base64(&val, p);   plug(atts.dwFileAttributes, val);   p++;                               /* skip space */   p += from_base64(&val, p);   li.QuadPart = val;   atts.ftCreationTime.dwLowDateTime = li.LowPart;   atts.ftCreationTime.dwHighDateTime = li.HighPart;   p++;                               /* skip space */   p += from_base64(&val, p);   li.QuadPart = val;   atts.ftLastAccessTime.dwLowDateTime = li.LowPart;   atts.ftLastAccessTime.dwHighDateTime = li.HighPart;   p++;                               /* skip space */   p += from_base64(&val, p);   li.QuadPart = val;   atts.ftLastWriteTime.dwLowDateTime = li.LowPart;   atts.ftLastWriteTime.dwHighDateTime = li.HighPart;   p++;   p += from_base64(&val, p);   plug(atts.nFileSizeHigh, val);   p++;   p += from_base64(&val, p);   plug(atts.nFileSizeLow, val);   /** Convert to Windows path format */   win32_ofile = get_pool_memory(PM_FNAME);   unix_name_to_win32(&win32_ofile, attr->ofname);   /** At this point, we have reconstructed the WIN32_FILE_ATTRIBUTE_DATA pkt */   if (!is_bopen(ofd)) {      Dmsg1(100, "File not open: %s/n", attr->ofname);      bopen(ofd, attr->ofname, O_WRONLY|O_BINARY, 0);   /* attempt to open the file */   }   if (is_bopen(ofd)) {      Dmsg1(100, "SetFileTime %s/n", attr->ofname);      if (!SetFileTime(bget_handle(ofd),                         &atts.ftCreationTime,                         &atts.ftLastAccessTime,                         &atts.ftLastWriteTime)) {         win_error(jcr, "SetFileTime:", win32_ofile);      }      bclose(ofd);   }   Dmsg1(100, "SetFileAtts %s/n", attr->ofname);   if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {      if (p_SetFileAttributesW) {         POOLMEM* pwszBuf = get_pool_memory(PM_FNAME);            make_win32_path_UTF8_2_wchar(&pwszBuf, attr->ofname);         BOOL b=p_SetFileAttributesW((LPCWSTR)pwszBuf, atts.dwFileAttributes & SET_ATTRS);         free_pool_memory(pwszBuf);               if (!b)             win_error(jcr, "SetFileAttributesW:", win32_ofile);       }      else {         if (!p_SetFileAttributesA(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) {            win_error(jcr, "SetFileAttributesA:", win32_ofile);         }      }   }   free_pool_memory(win32_ofile);   return true;}

/* * Write a block to the spool file * *  Returns: true on success or EOT *           false on hard error */bool write_block_to_spool_file(DCR *dcr){    uint32_t wlen, hlen;               /* length to write */    bool despool = false;    DEV_BLOCK *block = dcr->block;    if (job_canceled(dcr->jcr)) {        return false;    }    ASSERT(block->binbuf == ((uint32_t) (block->bufp - block->buf)));    if (block->binbuf <= WRITE_BLKHDR_LENGTH) {  /* Does block have data in it? */        return true;    }    hlen = sizeof(spool_hdr);    wlen = block->binbuf;    P(dcr->dev->spool_mutex);    dcr->job_spool_size += hlen + wlen;    dcr->dev->spool_size += hlen + wlen;    if ((dcr->max_job_spool_size > 0 && dcr->job_spool_size >= dcr->max_job_spool_size) ||            (dcr->dev->max_spool_size > 0 && dcr->dev->spool_size >= dcr->dev->max_spool_size)) {        despool = true;    }    V(dcr->dev->spool_mutex);    P(mutex);    spool_stats.data_size += hlen + wlen;    if (spool_stats.data_size > spool_stats.max_data_size) {        spool_stats.max_data_size = spool_stats.data_size;    }    V(mutex);    if (despool) {        char ec1[30], ec2[30];        if (dcr->max_job_spool_size > 0) {            Jmsg(dcr->jcr, M_INFO, 0, _("User specified Job spool size reached: "                                        "JobSpoolSize=%s MaxJobSpoolSize=%s/n"),                 edit_uint64_with_commas(dcr->job_spool_size, ec1),                 edit_uint64_with_commas(dcr->max_job_spool_size, ec2));        } else {            Jmsg(dcr->jcr, M_INFO, 0, _("User specified Device spool size reached: "                                        "DevSpoolSize=%s MaxDevSpoolSize=%s/n"),                 edit_uint64_with_commas(dcr->dev->spool_size, ec1),                 edit_uint64_with_commas(dcr->dev->max_spool_size, ec2));        }        if (!despool_data(dcr, false)) {            Pmsg0(000, _("Bad return from despool in write_block./n"));            return false;        }        /* Despooling cleared these variables so reset them */        P(dcr->dev->spool_mutex);        dcr->job_spool_size += hlen + wlen;        dcr->dev->spool_size += hlen + wlen;        V(dcr->dev->spool_mutex);        Jmsg(dcr->jcr, M_INFO, 0, _("Spooling data again .../n"));    }    if (!write_spool_header(dcr)) {        return false;    }    if (!write_spool_data(dcr)) {        return false;    }    Dmsg2(800, "Wrote block FI=%d LI=%d/n", block->FirstIndex, block->LastIndex);    empty_block(block);    return true;}