/*
* Append Data sent from File daemon
*
*/
bool do_append_data(JCR *jcr)
{
int32_t n;
int32_t file_index, stream, last_file_index;
BSOCK *fd = jcr->file_bsock;
bool ok = true;
DEV_RECORD rec;
char buf1[100], buf2[100];
DCR *dcr = jcr->dcr;
DEVICE *dev;
char ec[50];
if (!dcr) {
Jmsg0(jcr, M_FATAL, 0, _("DCR is NULL!!!\n"));
return false;
}
dev = dcr->dev;
if (!dev) {
Jmsg0(jcr, M_FATAL, 0, _("DEVICE is NULL!!!\n"));
return false;
}
Dmsg1(100, "Start append data. res=%d\n", dev->num_reserved());
memset(&rec, 0, sizeof(rec));
if (!fd->set_buffer_size(dcr->device->max_network_buffer_size, BNET_SETBUF_WRITE)) {
jcr->setJobStatus(JS_ErrorTerminated);
Jmsg0(jcr, M_FATAL, 0, _("Unable to set network buffer size.\n"));
return false;
}
if (!acquire_device_for_append(dcr)) {
jcr->setJobStatus(JS_ErrorTerminated);
return false;
}
jcr->setJobStatus(JS_Running);
dir_send_job_status(jcr);
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
Dmsg1(50, "Begin append device=%s\n", dev->print_name());
begin_data_spool(dcr);
begin_attribute_spool(jcr);
Dmsg0(100, "Just after acquire_device_for_append\n");
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
/*
* Write Begin Session Record
*/
if (!write_session_label(dcr, SOS_LABEL)) {
Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
dev->bstrerror());
jcr->setJobStatus(JS_ErrorTerminated);
ok = false;
}
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
/* Tell File daemon to send data */
if (!fd->fsend(OK_data)) {
berrno be;
Jmsg1(jcr, M_FATAL, 0, _("Network send error to FD. ERR=%s\n"),
be.bstrerror(fd->b_errno));
ok = false;
}
/*
* Get Data from File daemon, write to device. To clarify what is
* going on here. We expect:
* - A stream header
* - Multiple records of data
* - EOD record
*
* The Stream header is just used to sychronize things, and
* none of the stream header is written to tape.
* The Multiple records of data, contain first the Attributes,
* then after another stream header, the file data, then
* after another stream header, the MD5 data if any.
*
* 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;
rec.Stream = stream;
rec.maskedStream = stream & STREAMMASK_TYPE; /* strip high bits */
rec.data_len = fd->msglen;
rec.data = fd->msg; /* use message buffer */
Dmsg4(850, "before writ_rec FI=%d SessId=%d Strm=%s len=%d\n",
rec.FileIndex, rec.VolSessionId,
stream_to_ascii(buf1, rec.Stream,rec.FileIndex),
rec.data_len);
while (!write_record_to_block(dcr->block, &rec)) {
Dmsg2(850, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
rec.remainder);
if (!write_block_to_device(dcr)) {
Dmsg2(90, "Got write_block_to_dev error on device %s. %s\n",
dev->print_name(), dev->bstrerror());
ok = false;
break;
}
}
if (!ok) {
Dmsg0(400, "Not OK\n");
break;
}
jcr->JobBytes += rec.data_len; /* increment bytes this job */
Dmsg4(850, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
send_attrs_to_dir(jcr, &rec);
Dmsg0(650, "Enter bnet_get\n");
}
Dmsg1(650, "End read loop with FD. Stat=%d\n", n);
if (fd->is_error()) {
if (!jcr->is_job_canceled()) {
Dmsg1(350, "Network read error from FD. ERR=%s\n", fd->bstrerror());
Jmsg1(jcr, M_FATAL, 0, _("Network error reading from FD. ERR=%s\n"),
fd->bstrerror());
possible_incomplete_job(jcr, last_file_index);
}
ok = false;
break;
}
}
/* Create Job status for end of session label */
jcr->setJobStatus(ok?JS_Terminated:JS_ErrorTerminated);
if (ok) {
/* Terminate connection with FD */
fd->fsend(OK_append);
do_fd_commands(jcr); /* finish dialog with FD */
} else {
fd->fsend("3999 Failed append\n");
}
/*
* Don't use time_t for job_elapsed as time_t can be 32 or 64 bits,
* and the subsequent Jmsg() editing will break
*/
int32_t job_elapsed = time(NULL) - jcr->run_time;
if (job_elapsed <= 0) {
job_elapsed = 1;
}
Jmsg(dcr->jcr, M_INFO, 0, _("Job write elapsed time = %02d:%02d:%02d, Transfer rate = %s Bytes/second\n"),
job_elapsed / 3600, job_elapsed % 3600 / 60, job_elapsed % 60,
edit_uint64_with_suffix(jcr->JobBytes / job_elapsed, ec));
Dmsg1(200, "Write EOS label JobStatus=%c\n", jcr->JobStatus);
/*
* Check if we can still write. This may not be the case
* if we are at the end of the tape or we got a fatal I/O error.
*/
if (ok || dev->can_write()) {
if (!write_session_label(dcr, EOS_LABEL)) {
/* Print only if ok and not cancelled to avoid spurious messages */
if (ok && !jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Error writing end session label. ERR=%s\n"),
dev->bstrerror());
possible_incomplete_job(jcr, last_file_index);
}
jcr->setJobStatus(JS_ErrorTerminated);
ok = false;
}
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
Dmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
Dmsg0(90, "back from write_end_session_label()\n");
/* Flush out final partial block of this session */
if (!write_block_to_device(dcr)) {
/* Print only if ok and not cancelled to avoid spurious messages */
if (ok && !jcr->is_job_canceled()) {
Jmsg2(jcr, M_FATAL, 0, _("Fatal append error on device %s: ERR=%s\n"),
dev->print_name(), dev->bstrerror());
Dmsg0(100, _("Set ok=FALSE after write_block_to_device.\n"));
possible_incomplete_job(jcr, last_file_index);
}
jcr->setJobStatus(JS_ErrorTerminated);
ok = false;
}
}
if (!ok && !jcr->is_JobStatus(JS_Incomplete)) {
discard_data_spool(dcr);
} else {
/* Note: if commit is OK, the device will remain blocked */
commit_data_spool(dcr);
}
if (ok) {
ok = dvd_close_job(dcr); /* do DVD cleanup if any */
}
/*
* Release the device -- and send final Vol info to DIR
* and unlock it.
*/
release_device(dcr);
if ((!ok || jcr->is_job_canceled()) && !jcr->is_JobStatus(JS_Incomplete)) {
discard_attribute_spool(jcr);
} else {
commit_attribute_spool(jcr);
}
dir_send_job_status(jcr); /* update director */
Dmsg1(100, "return from do_append_data() ok=%d\n", ok);
return ok;
}
/*
* Unlock write lock
* Start any waiting writers in preference to waiting readers
*/
int devlock::writeunlock()
{
devlock *rwl = this;
int status, status2;
if (rwl->valid != DEVLOCK_VALID) {
return EINVAL;
}
if ((status = pthread_mutex_lock(&rwl->mutex)) != 0) {
return status;
}
if (rwl->w_active <= 0) {
pthread_mutex_unlock(&rwl->mutex);
Jmsg0(NULL, M_ABORT, 0, _("writeunlock called too many times.\n"));
}
rwl->w_active--;
if (!pthread_equal(pthread_self(), rwl->writer_id)) {
pthread_mutex_unlock(&rwl->mutex);
Jmsg0(NULL, M_ABORT, 0, _("writeunlock by non-owner.\n"));
}
if (rwl->w_active > 0) {
status = 0; /* writers still active */
} else {
lmgr_do_unlock(rwl);
/* No more writers, awaken someone */
if (rwl->r_wait > 0) { /* if readers waiting */
status = pthread_cond_broadcast(&rwl->read);
} else if (rwl->w_wait > 0) {
status = pthread_cond_broadcast(&rwl->write);
}
}
status2 = pthread_mutex_unlock(&rwl->mutex);
return (status == 0 ? status2 : status);
}
/*
* Either because we are going to hang a new volume, or because
* of explicit user request, we release the current volume.
*/
void DCR::release_volume()
{
unload_autochanger(this, -1);
if (WroteVol) {
Jmsg0(jcr, M_ERROR, 0, _("Hey!!!!! WroteVol non-zero !!!!!\n"));
Pmsg0(190, "Hey!!!!! WroteVol non-zero !!!!!\n");
}
/*
* First erase all memory of the current volume
*/
free_volume(dev);
dev->block_num = dev->file = 0;
dev->EndBlock = dev->EndFile = 0;
memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
dev->clear_volhdr();
/* Force re-read of label */
dev->clear_labeled();
dev->clear_read();
dev->clear_append();
dev->label_type = B_BACULA_LABEL;
VolumeName[0] = 0;
if (dev->is_open() && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
dev->close();
}
/* If we have not closed the device, then at least rewind the tape */
if (dev->is_open()) {
dev->offline_or_rewind();
}
// Dmsg0(50, "set_unload\n");
// dev->set_unload();
Dmsg0(190, "release_volume\n");
}
static bool create_bootstrap_file(JCR *jcr, char *jobids)
{
RESTORE_CTX rx;
UAContext *ua;
memset(&rx, 0, sizeof(rx));
rx.bsr = new_bsr();
ua = new_ua_context(jcr);
rx.JobIds = jobids;
if (!db_open_batch_connection(jcr, jcr->db)) {
Jmsg0(jcr, M_FATAL, 0, "Can't get batch sql connexion");
return false;
}
if (!db_get_file_list(jcr, jcr->db_batch, jobids, false /* don't use md5 */,
true /* use delta */,
insert_bootstrap_handler, (void *)rx.bsr)) {
Jmsg(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db_batch));
}
complete_bsr(ua, rx.bsr);
jcr->ExpectedFiles = write_bsr_file(ua, rx);
if (debug_level >= 10) {
Dmsg1(000, "Found %d files to consolidate.\n", jcr->ExpectedFiles);
}
if (jcr->ExpectedFiles == 0) {
free_ua_context(ua);
free_bsr(rx.bsr);
return false;
}
free_ua_context(ua);
free_bsr(rx.bsr);
return true;
}
bool unregister_watchdog(watchdog_t *wd)
{
watchdog_t *p;
bool ok = false;
if (!wd_is_init) {
Jmsg0(NULL, M_ABORT, 0, _("BUG! unregister_watchdog_unlocked called before start_watchdog\n"));
}
wd_lock();
foreach_dlist(p, wd_queue) {
if (wd == p) {
wd_queue->remove(wd);
Dmsg1(800, "Unregistered watchdog %p\n", wd);
ok = true;
goto get_out;
}
}
foreach_dlist(p, wd_inactive) {
if (wd == p) {
wd_inactive->remove(wd);
Dmsg1(800, "Unregistered inactive watchdog %p\n", wd);
ok = true;
goto get_out;
}
}
Dmsg1(800, "Failed to unregister watchdog %p\n", wd);
get_out:
wd_unlock();
ping_watchdog();
return ok;
}
/*
* Authenticate Director
*/
static int authenticate_director(JCR *jcr)
{
const MONITORRES *monitor = MonitorItemThread::instance()->getMonitor();
BSOCK *dir = jcr->dir_bsock;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true;
char bashed_name[MAX_NAME_LENGTH];
char *password;
bstrncpy(bashed_name, monitor->hdr.name, sizeof(bashed_name));
bash_spaces(bashed_name);
password = monitor->password;
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(dir, 60 * 5);
dir->fsend(DIRhello, bashed_name);
if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(dir, password, tls_local_need, compatible)) {
stop_bsock_timer(tid);
Jmsg1(jcr, M_FATAL, 0, _("Director authorization problem.\n"
"Most likely the passwords do not agree.\n"
"Please see %s for help.\n"), MANUAL_AUTH_URL);
return 0;
}
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
stop_bsock_timer(tid);
Jmsg1(jcr, M_FATAL, 0, _("Bad response to Hello command: ERR=%s\n"),
dir->bstrerror());
return 0;
}
Dmsg1(10, "<dird: %s", dir->msg);
stop_bsock_timer(tid);
if (strncmp(dir->msg, DIROKhello, sizeof(DIROKhello)-1) != 0) {
Jmsg0(jcr, M_FATAL, 0, _("Director rejected Hello command\n"));
return 0;
} else {
Jmsg0(jcr, M_INFO, 0, dir->msg);
}
return 1;
}
/*
* Write a Record to the block
*
* Returns: false means the block could not be written to tape/disk.
* true on success (all bytes written to the block).
*/
bool DCR::write_record()
{
bool retval = false;
bool translated_record = false;
char buf1[100], buf2[100];
/*
* Perform record translations.
*/
before_rec = rec;
after_rec = NULL;
if (generate_plugin_event(jcr, bsdEventWriteRecordTranslation, this) != bRC_OK) {
goto bail_out;
}
/*
* The record got translated when we got an after_rec pointer after calling the
* bsdEventWriteRecordTranslation plugin event. If no translation has taken place
* we just point the after_rec pointer to same DEV_RECORD as in the before_rec pointer.
*/
if (!after_rec) {
after_rec = before_rec;
} else {
translated_record = true;
}
while (!write_record_to_block(this, after_rec)) {
Dmsg2(850, "!write_record_to_block data_len=%d rem=%d\n",
after_rec->data_len, after_rec->remainder);
if (!write_block_to_device()) {
Dmsg2(90, "Got write_block_to_dev error on device %s. %s\n",
dev->print_name(), dev->bstrerror());
goto bail_out;
}
}
jcr->JobBytes += after_rec->data_len; /* increment bytes this job */
if (jcr->RemainingQuota && jcr->JobBytes > jcr->RemainingQuota) {
Jmsg0(jcr, M_FATAL, 0, _("Quota Exceeded. Job Terminated.\n"));
goto bail_out;
}
Dmsg4(850, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
FI_to_ascii(buf1, after_rec->FileIndex), after_rec->VolSessionId,
stream_to_ascii(buf2, after_rec->Stream, after_rec->FileIndex), after_rec->data_len);
retval = true;
bail_out:
if (translated_record) {
copy_record_state(before_rec, after_rec);
free_record(after_rec);
after_rec = NULL;
}
return retval;
}
/*
* Authenticate Storage daemon connection
*/
static int authenticate_storage_daemon(JCR *jcr, STORERES* store)
{
const MONITORRES *monitor = MonitorItemThread::instance()->getMonitor();
BSOCK *sd = jcr->store_bsock;
char dirname[MAX_NAME_LENGTH];
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true;
/*
* Send my name to the Storage daemon then do authentication
*/
bstrncpy(dirname, monitor->hdr.name, sizeof(dirname));
bash_spaces(dirname);
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(sd, 60 * 5);
if (!sd->fsend(SDFDhello, dirname)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Error sending Hello to Storage daemon. ERR=%s\n"), bnet_strerror(sd));
return 0;
}
if (!cram_md5_respond(sd, store->password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(sd, store->password, tls_local_need, compatible)) {
stop_bsock_timer(tid);
Jmsg0(jcr, M_FATAL, 0, _("Director and Storage daemon passwords or names not the same.\n"
"Please see " MANUAL_AUTH_URL " for help.\n"));
return 0;
}
Dmsg1(116, ">stored: %s", sd->msg);
if (sd->recv() <= 0) {
stop_bsock_timer(tid);
Jmsg1(jcr, M_FATAL, 0, _("bdird<stored: bad response to Hello command: ERR=%s\n"),
sd->bstrerror());
return 0;
}
Dmsg1(110, "<stored: %s", sd->msg);
stop_bsock_timer(tid);
if (strncmp(sd->msg, SDOKhello, sizeof(SDOKhello)) != 0) {
Jmsg0(jcr, M_FATAL, 0, _("Storage daemon rejected Hello command\n"));
return 0;
}
return 1;
}
/*
* Now talk to the SD and do what he says
*/
static void do_sd_commands(JCR *jcr)
{
int i, status;
bool found, quit;
BSOCK *sd = jcr->store_bsock;
sd->set_jcr(jcr);
quit = false;
while (!quit) {
/*
* Read command coming from the Storage daemon
*/
status = sd->recv();
if (is_bnet_stop(sd)) { /* hardeof or error */
break; /* connection terminated */
}
if (status <= 0) {
continue; /* ignore signals and zero length msgs */
}
Dmsg1(110, "<stored: %s", sd->msg);
found = false;
for (i = 0; sd_cmds[i].cmd; i++) {
if (bstrncmp(sd_cmds[i].cmd, sd->msg, strlen(sd_cmds[i].cmd))) {
found = true; /* indicate command found */
jcr->errmsg[0] = 0;
if (!sd_cmds[i].func(jcr)) { /* do command */
/*
* Note sd->msg command may be destroyed by comm activity
*/
if (!job_canceled(jcr)) {
if (jcr->errmsg[0]) {
Jmsg1(jcr, M_FATAL, 0, _("Command error with SD, hanging up. %s\n"),
jcr->errmsg);
} else {
Jmsg0(jcr, M_FATAL, 0, _("Command error with SD, hanging up.\n"));
}
jcr->setJobStatus(JS_ErrorTerminated);
}
quit = true;
}
break;
}
}
if (!found) { /* command not found */
if (!job_canceled(jcr)) {
Jmsg1(jcr, M_FATAL, 0, _("SD command not found: %s\n"), sd->msg);
Dmsg1(110, "<stored: Command not found: %s\n", sd->msg);
}
sd->fsend(serrmsg);
break;
}
}
sd->signal(BNET_TERMINATE); /* signal to SD job is done */
}
/*
* DCR Constructor.
*/
DCR::DCR()
{
POOL_MEM errmsg(PM_MESSAGE);
int errstat;
tid = pthread_self();
spool_fd = -1;
if ((errstat = pthread_mutex_init(&m_mutex, NULL)) != 0) {
berrno be;
Mmsg(errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, errmsg.c_str());
}
if ((errstat = pthread_mutex_init(&r_mutex, NULL)) != 0) {
berrno be;
Mmsg(errmsg, _("Unable to init r_mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, errmsg.c_str());
}
}
/*
* Now talk to the FD and do what he says
*/
void do_fd_commands(JCR *jcr)
{
int i;
bool found, quit;
BSOCK *fd = jcr->file_bsock;
fd->set_jcr(jcr);
for (quit=false; !quit;) {
int status;
/* Read command coming from the File daemon */
status = fd->recv();
if (is_bnet_stop(fd)) { /* hardeof or error */
break; /* connection terminated */
}
if (status <= 0) {
continue; /* ignore signals and zero length msgs */
}
Dmsg1(110, "<filed: %s", fd->msg);
found = false;
for (i=0; fd_cmds[i].cmd; i++) {
if (bstrncmp(fd_cmds[i].cmd, fd->msg, strlen(fd_cmds[i].cmd))) {
found = true; /* indicate command found */
jcr->errmsg[0] = 0;
if (!fd_cmds[i].func(jcr)) { /* do command */
/* Note fd->msg command may be destroyed by comm activity */
if (!job_canceled(jcr)) {
if (jcr->errmsg[0]) {
Jmsg1(jcr, M_FATAL, 0, _("Command error with FD, hanging up. %s\n"),
jcr->errmsg);
} else {
Jmsg0(jcr, M_FATAL, 0, _("Command error with FD, hanging up.\n"));
}
jcr->setJobStatus(JS_ErrorTerminated);
}
quit = true;
}
break;
}
}
if (!found) { /* command not found */
if (!job_canceled(jcr)) {
Jmsg1(jcr, M_FATAL, 0, _("FD command not found: %s\n"), fd->msg);
Dmsg1(110, "<filed: Command not found: %s\n", fd->msg);
}
fd->fsend(ferrmsg);
break;
}
}
fd->signal(BNET_TERMINATE); /* signal to FD job is done */
}
/*
* Send current file list to FD
* DIR -> FD : accurate files=xxxx
* DIR -> FD : /path/to/file\0Lstat
* DIR -> FD : /path/to/dir/\0Lstat
* ...
* DIR -> FD : EOD
*/
bool send_accurate_current_files(JCR *jcr)
{
POOL_MEM buf;
if (!jcr->accurate || job_canceled(jcr) || jcr->get_JobLevel()==L_FULL) {
return true;
}
POOLMEM *jobids = get_pool_memory(PM_FNAME);
db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, jobids);
if (*jobids == 0) {
free_pool_memory(jobids);
Jmsg(jcr, M_FATAL, 0, _("Cannot find previous jobids.\n"));
return false;
}
Jmsg(jcr, M_INFO, 0, _("Sending Accurate information.\n"));
/* to be able to allocate the right size for htable */
POOLMEM *nb = get_pool_memory(PM_FNAME);
*nb = 0; /* clear buffer */
Mmsg(buf, "SELECT sum(JobFiles) FROM Job WHERE JobId IN (%s)",jobids);
db_sql_query(jcr->db, buf.c_str(), db_get_int_handler, nb);
Dmsg2(200, "jobids=%s nb=%s\n", jobids, nb);
jcr->file_bsock->fsend("accurate files=%s\n", nb);
if (!db_open_batch_connexion(jcr, jcr->db)) {
Jmsg0(jcr, M_FATAL, 0, "Can't get dedicate sql connexion");
return false;
}
db_get_file_list(jcr, jcr->db_batch, jobids, accurate_list_handler, (void *)jcr);
/* TODO: close the batch connexion ? (can be used very soon) */
free_pool_memory(jobids);
free_pool_memory(nb);
jcr->file_bsock->signal(BNET_EOD);
return true;
}
bool CONFIG::parse_config()
{
static bool first = true;
int errstat;
POOL_MEM config_path;
if (first && (errstat = rwl_init(&m_res_lock)) != 0) {
berrno be;
Jmsg1(NULL, M_ABORT, 0, _("Unable to initialize resource lock. ERR=%s\n"),
be.bstrerror(errstat));
}
first = false;
if (!find_config_path(config_path)) {
Jmsg0(NULL, M_ERROR_TERM, 0, _("Failed to find config filename.\n"));
}
m_used_config_path = bstrdup(config_path.c_str());
Dmsg1(100, "config file = %s\n", m_used_config_path);
return parse_config_file(config_path.c_str(), NULL, m_scan_error, m_scan_warning, m_err_type);
}
bool register_watchdog(watchdog_t *wd)
{
if (!wd_is_init) {
Jmsg0(NULL, M_ABORT, 0, _("BUG! register_watchdog called before start_watchdog\n"));
}
if (wd->callback == NULL) {
Jmsg1(NULL, M_ABORT, 0, _("BUG! Watchdog %p has NULL callback\n"), wd);
}
if (wd->interval == 0) {
Jmsg1(NULL, M_ABORT, 0, _("BUG! Watchdog %p has zero interval\n"), wd);
}
wd_lock();
wd->next_fire = watchdog_time + wd->interval;
wd_queue->append(wd);
Dmsg3(800, "Registered watchdog %p, interval %d%s\n",
wd, wd->interval, wd->one_shot ? " one shot" : "");
wd_unlock();
ping_watchdog();
return false;
}
/*
* Send the content of an Encrypted file on an EFS filesystem.
*/
static inline bool send_encrypted_data(b_ctx &bctx)
{
bool retval = false;
if (!p_ReadEncryptedFileRaw) {
Jmsg0(bctx.jcr, M_FATAL, 0, _("Encrypted file but no EFS support functions\n"));
}
/*
* The EFS read function, ReadEncryptedFileRaw(), works in a specific way.
* You have to give it a function that it calls repeatedly every time the
* read buffer is filled.
*
* So ReadEncryptedFileRaw() will not return until it has read the whole file.
*/
if (p_ReadEncryptedFileRaw((PFE_EXPORT_FUNC)send_efs_data, &bctx, bctx.ff_pkt->bfd.pvContext)) {
goto bail_out;
}
retval = true;
bail_out:
return retval;
}
bool encode_and_send_attributes(JCR *jcr, FF_PKT *ff_pkt, int &data_stream)
{
BSOCK *sd = jcr->store_bsock;
POOL_MEM attribs(PM_NAME),
attribsExBuf(PM_NAME);
char *attribsEx = NULL;
int attr_stream;
int comp_len;
bool status;
int hangup = get_hangup();
#ifdef FD_NO_SEND_TEST
return true;
#endif
Dmsg1(300, "encode_and_send_attrs fname=%s\n", ff_pkt->fname);
/** Find what data stream we will use, then encode the attributes */
if ((data_stream = select_data_stream(ff_pkt, me->compatible)) == STREAM_NONE) {
/* This should not happen */
Jmsg0(jcr, M_FATAL, 0, _("Invalid file flags, no supported data stream type.\n"));
return false;
}
encode_stat(attribs.c_str(), &ff_pkt->statp, sizeof(ff_pkt->statp), ff_pkt->LinkFI, data_stream);
/** Now possibly extend the attributes */
if (IS_FT_OBJECT(ff_pkt->type)) {
attr_stream = STREAM_RESTORE_OBJECT;
} else {
attribsEx = attribsExBuf.c_str();
attr_stream = encode_attribsEx(jcr, attribsEx, ff_pkt);
}
Dmsg3(300, "File %s\nattribs=%s\nattribsEx=%s\n", ff_pkt->fname, attribs.c_str(), attribsEx);
jcr->lock();
jcr->JobFiles++; /* increment number of files sent */
ff_pkt->FileIndex = jcr->JobFiles; /* return FileIndex */
pm_strcpy(jcr->last_fname, ff_pkt->fname);
jcr->unlock();
/*
* Debug code: check if we must hangup
*/
if (hangup && (jcr->JobFiles > (uint32_t)hangup)) {
jcr->setJobStatus(JS_Incomplete);
Jmsg1(jcr, M_FATAL, 0, "Debug hangup requested after %d files.\n", hangup);
set_hangup(0);
return false;
}
/**
* Send Attributes header to Storage daemon
* <file-index> <stream> <info>
*/
if (!sd->fsend("%ld %d 0", jcr->JobFiles, attr_stream)) {
if (!jcr->is_canceled() && !jcr->is_incomplete()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror());
}
return false;
}
Dmsg1(300, ">stored: attrhdr %s", sd->msg);
/**
* Send file attributes to Storage daemon
* File_index
* File type
* Filename (full path)
* Encoded attributes
* Link name (if type==FT_LNK or FT_LNKSAVED)
* Encoded extended-attributes (for Win32)
* Delta Sequence Number
*
* or send Restore Object to Storage daemon
* File_index
* File_type
* Object_index
* Object_len (possibly compressed)
* Object_full_len (not compressed)
* Object_compression
* Plugin_name
* Object_name
* Binary Object data
*
* For a directory, link is the same as fname, but with trailing
* slash. For a linked file, link is the link.
*/
if (!IS_FT_OBJECT(ff_pkt->type) && ff_pkt->type != FT_DELETED) { /* already stripped */
strip_path(ff_pkt);
}
switch (ff_pkt->type) {
case FT_JUNCTION:
case FT_LNK:
case FT_LNKSAVED:
Dmsg3(300, "Link %d %s to %s\n", jcr->JobFiles, ff_pkt->fname, ff_pkt->link);
status = sd->fsend("%ld %d %s%c%s%c%s%c%s%c%u%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->fname, 0, attribs.c_str(), 0,
ff_pkt->link, 0, attribsEx, 0, ff_pkt->delta_seq, 0);
break;
case FT_DIREND:
case FT_REPARSE:
/* Here link is the canonical filename (i.e. with trailing slash) */
status = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->link, 0, attribs.c_str(), 0, 0,
attribsEx, 0, ff_pkt->delta_seq, 0);
break;
case FT_PLUGIN_CONFIG:
case FT_RESTORE_FIRST:
comp_len = ff_pkt->object_len;
ff_pkt->object_compression = 0;
if (ff_pkt->object_len > 1000) {
/*
* Big object, compress it
*/
comp_len = compressBound(ff_pkt->object_len);
POOLMEM *comp_obj = get_memory(comp_len);
/*
* FIXME: check Zdeflate error
*/
Zdeflate(ff_pkt->object, ff_pkt->object_len, comp_obj, comp_len);
if (comp_len < ff_pkt->object_len) {
ff_pkt->object = comp_obj;
ff_pkt->object_compression = 1; /* zlib level 9 compression */
} else {
/*
* Uncompressed object smaller, use it
*/
comp_len = ff_pkt->object_len;
}
Dmsg2(100, "Object compressed from %d to %d bytes\n", ff_pkt->object_len, comp_len);
}
sd->msglen = Mmsg(sd->msg, "%d %d %d %d %d %d %s%c%s%c",
jcr->JobFiles, ff_pkt->type, ff_pkt->object_index,
comp_len, ff_pkt->object_len, ff_pkt->object_compression,
ff_pkt->fname, 0, ff_pkt->object_name, 0);
sd->msg = check_pool_memory_size(sd->msg, sd->msglen + comp_len + 2);
memcpy(sd->msg + sd->msglen, ff_pkt->object, comp_len);
/*
* Note we send one extra byte so Dir can store zero after object
*/
sd->msglen += comp_len + 1;
status = sd->send();
if (ff_pkt->object_compression) {
free_and_null_pool_memory(ff_pkt->object);
}
break;
case FT_REG:
status = sd->fsend("%ld %d %s%c%s%c%c%s%c%d%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->fname, 0, attribs.c_str(), 0, 0,
attribsEx, 0, ff_pkt->delta_seq, 0);
break;
default:
status = sd->fsend("%ld %d %s%c%s%c%c%s%c%u%c", jcr->JobFiles,
ff_pkt->type, ff_pkt->fname, 0, attribs.c_str(), 0, 0,
attribsEx, 0, ff_pkt->delta_seq, 0);
break;
}
if (!IS_FT_OBJECT(ff_pkt->type) && ff_pkt->type != FT_DELETED) {
unstrip_path(ff_pkt);
}
Dmsg2(300, ">stored: attr len=%d: %s\n", sd->msglen, sd->msg);
if (!status && !jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"), sd->bstrerror());
}
sd->signal(BNET_EOD); /* indicate end of attributes data */
return status;
}
int main (int argc, char *argv[])
{
int ch;
bool no_signals = false;
bool test_config = false;
pthread_t thid;
char *uid = NULL;
char *gid = NULL;
start_heap = sbrk(0);
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
my_name_is(argc, argv, "bareos-sd");
init_msg(NULL, NULL);
daemon_start_time = time(NULL);
/* Sanity checks */
if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
TAPE_BSIZE, B_DEV_BSIZE);
}
if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
}
while ((ch = getopt(argc, argv, "c:d:fg:mpstu:v?")) != -1) {
switch (ch) {
case 'c': /* configuration file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'f': /* run in foreground */
foreground = true;
break;
case 'g': /* set group id */
gid = optarg;
break;
case 'm': /* print kaboom output */
prt_kaboom = true;
break;
case 'p': /* proceed in spite of I/O errors */
forge_on = true;
break;
case 's': /* no signals */
no_signals = true;
break;
case 't':
test_config = true;
break;
case 'u': /* set uid */
uid = optarg;
break;
case 'v': /* verbose */
verbose++;
break;
case '?':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc) {
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(*argv);
argc--;
argv++;
}
if (argc)
usage();
/*
* See if we want to drop privs.
*/
if (geteuid() == 0) {
drop(uid, gid, false);
}
if (!no_signals) {
init_signals(terminate_stored);
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
if (init_crypto() != 0) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n"));
}
if (!check_resources()) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
}
init_reservations_lock();
if (test_config) {
terminate_stored(0);
}
my_name_is(0, (char **)NULL, me->hdr.name); /* Set our real name */
if (!foreground) {
daemon_start(); /* become daemon */
init_stack_dump(); /* pick up new pid */
}
create_pid_file(me->pid_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
read_state_file(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
set_jcr_in_tsd(INVALID_JCR);
/*
* Make sure on Solaris we can run concurrent, watch dog + servers + misc
*/
set_thread_concurrency(me->max_concurrent_jobs * 2 + 4);
lmgr_init_thread(); /* initialize the lockmanager stack */
load_sd_plugins(me->plugin_directory, me->plugin_names);
cleanup_old_files();
/* Ensure that Volume Session Time and Id are both
* set and are both non-zero.
*/
VolSessionTime = (uint32_t)daemon_start_time;
if (VolSessionTime == 0) { /* paranoid */
Jmsg0(NULL, M_ABORT, 0, _("Volume Session Time is ZERO!\n"));
}
/*
* Start the device allocation thread
*/
create_volume_lists(); /* do before device_init */
if (pthread_create(&thid, NULL, device_initialization, NULL) != 0) {
berrno be;
Emsg1(M_ABORT, 0, _("Unable to create thread. ERR=%s\n"), be.bstrerror());
}
start_watchdog(); /* start watchdog thread */
if (me->jcr_watchdog_time) {
init_jcr_subsystem(me->jcr_watchdog_time); /* start JCR watchdogs etc. */
}
#if HAVE_NDMP
/* Seperate thread that handles NDMP connections */
if (me->ndmp_enable) {
start_ndmp_thread_server(me->NDMPaddrs,
me->max_concurrent_jobs * 2 + 1,
&ndmp_workq);
}
#endif
/* Single server used for Director/Storage and File daemon */
sock_fds = New(alist(10, not_owned_by_alist));
bnet_thread_server_tcp(me->SDaddrs,
me->max_concurrent_jobs * 2 + 1,
sock_fds,
&dird_workq,
me->nokeepalive,
handle_connection_request);
exit(1); /* to keep compiler quiet */
}
static inline DEVICE *m_init_dev(JCR *jcr, DEVRES *device, bool new_init)
{
struct stat statp;
int errstat;
DCR *dcr = NULL;
DEVICE *dev = NULL;
uint32_t max_bs;
Dmsg1(400, "max_block_size in device res is %u\n", device->max_block_size);
/*
* If no device type specified, try to guess
*/
if (!device->dev_type) {
/*
* Check that device is available
*/
if (stat(device->device_name, &statp) < 0) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
device->device_name, be.bstrerror());
return NULL;
}
if (S_ISDIR(statp.st_mode)) {
device->dev_type = B_FILE_DEV;
} else if (S_ISCHR(statp.st_mode)) {
device->dev_type = B_TAPE_DEV;
} else if (S_ISFIFO(statp.st_mode)) {
device->dev_type = B_FIFO_DEV;
} else if (!bit_is_set(CAP_REQMOUNT, device->cap_bits)) {
Jmsg2(jcr, M_ERROR, 0,
_("%s is an unknown device type. Must be tape or directory, st_mode=%x\n"),
device->device_name, statp.st_mode);
return NULL;
}
}
/*
* See what type of device is wanted.
*/
switch (device->dev_type) {
/*
* When using dynamic loading use the init_backend_dev() function
* for any type of device not being of the type file.
*/
#ifndef HAVE_DYNAMIC_SD_BACKENDS
#ifdef HAVE_GFAPI
case B_GFAPI_DEV:
dev = New(gfapi_device);
break;
#endif
#ifdef HAVE_OBJECTSTORE
case B_OBJECT_STORE_DEV:
dev = New(object_store_device);
break;
#endif
#ifdef HAVE_RADOS
case B_RADOS_DEV:
dev = New(rados_device);
break;
#endif
#ifdef HAVE_CEPHFS
case B_CEPHFS_DEV:
dev = New(cephfs_device);
break;
#endif
#ifdef HAVE_ELASTO
case B_ELASTO_DEV:
dev = New(elasto_device);
break;
#endif
#ifdef HAVE_WIN32
case B_TAPE_DEV:
dev = New(win32_tape_device);
break;
case B_FIFO_DEV:
dev = New(win32_fifo_device);
break;
#else
case B_TAPE_DEV:
dev = New(unix_tape_device);
break;
case B_FIFO_DEV:
dev = New(unix_fifo_device);
break;
#endif
#endif /* HAVE_DYNAMIC_SD_BACKENDS */
#ifdef HAVE_WIN32
case B_FILE_DEV:
dev = New(win32_file_device);
break;
#else
case B_FILE_DEV:
dev = New(unix_file_device);
break;
#endif
default:
#ifdef HAVE_DYNAMIC_SD_BACKENDS
dev = init_backend_dev(jcr, device->dev_type);
#endif
break;
}
if (!dev) {
Jmsg2(jcr, M_ERROR, 0, _("%s has an unknown device type %d\n"),
device->device_name, device->dev_type);
return NULL;
}
dev->clear_slot(); /* unknown */
/*
* Copy user supplied device parameters from Resource
*/
dev->dev_name = get_memory(strlen(device->device_name) + 1);
pm_strcpy(dev->dev_name, device->device_name);
if (device->device_options) {
dev->dev_options = get_memory(strlen(device->device_options) + 1);
pm_strcpy(dev->dev_options, device->device_options);
}
dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->name()) + 20);
/*
* We edit "Resource-name" (physical-name)
*/
Mmsg(dev->prt_name, "\"%s\" (%s)", device->name(), device->device_name);
Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
copy_bits(CAP_MAX, device->cap_bits, dev->capabilities);
/*
* current block sizes
*/
dev->min_block_size = device->min_block_size;
dev->max_block_size = device->max_block_size;
dev->max_volume_size = device->max_volume_size;
dev->max_file_size = device->max_file_size;
dev->max_concurrent_jobs = device->max_concurrent_jobs;
dev->volume_capacity = device->volume_capacity;
dev->max_rewind_wait = device->max_rewind_wait;
dev->max_open_wait = device->max_open_wait;
dev->max_open_vols = device->max_open_vols;
dev->vol_poll_interval = device->vol_poll_interval;
dev->max_spool_size = device->max_spool_size;
dev->drive = device->drive;
dev->drive_index = device->drive_index;
dev->autoselect = device->autoselect;
dev->norewindonclose = device->norewindonclose;
dev->dev_type = device->dev_type;
dev->device = device;
/*
* Sanity check
*/
if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
dev->vol_poll_interval = 60;
}
device->dev = dev;
if (dev->is_fifo()) {
dev->set_cap(CAP_STREAM); /* set stream device */
}
/*
* If the device requires mount :
* - Check that the mount point is available
* - Check that (un)mount commands are defined
*/
if (dev->is_file() && dev->requires_mount()) {
if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
berrno be;
dev->dev_errno = errno;
Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
device->mount_point, be.bstrerror());
}
if (!device->mount_command || !device->unmount_command) {
Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
}
}
/*
* Sanity check
*/
if (dev->max_block_size == 0) {
max_bs = DEFAULT_BLOCK_SIZE;
} else {
max_bs = dev->max_block_size;
}
if (dev->min_block_size > max_bs) {
Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"), dev->print_name());
}
if (dev->max_block_size > MAX_BLOCK_LENGTH) {
Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
dev->max_block_size = 0;
}
if (dev->max_block_size % TAPE_BSIZE != 0) {
Jmsg3(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size=%d.\n"),
dev->max_block_size, dev->print_name(), TAPE_BSIZE);
}
if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size for device %s\n"), dev->print_name());
}
dev->errmsg = get_pool_memory(PM_EMSG);
*dev->errmsg = 0;
if ((errstat = dev->init_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init spool mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = dev->init_acquire_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init acquire mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = dev->init_read_acquire_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init read acquire mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
dev->set_mutex_priorities();
#ifdef xxx
if ((errstat = rwl_init(&dev->lock)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
#endif
dev->clear_opened();
dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
dev->initiated = true;
Dmsg3(100, "dev=%s dev_max_bs=%u max_bs=%u\n", dev->dev_name, dev->device->max_block_size, dev->max_block_size);
return dev;
}
/**
* 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;
}
DEVICE *m_init_dev(JCR *jcr, DEVRES *device)
{
struct stat statp;
int errstat;
DCR *dcr = NULL;
DEVICE *dev = NULL;
uint32_t max_bs;
/* If no device type specified, try to guess */
if (!device->dev_type) {
/* Check that device is available */
if (stat(device->device_name, &statp) < 0) {
berrno be;
Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
device->device_name, be.bstrerror());
return NULL;
}
if (S_ISDIR(statp.st_mode)) {
device->dev_type = B_FILE_DEV;
} else if (S_ISCHR(statp.st_mode)) {
device->dev_type = B_TAPE_DEV;
} else if (S_ISFIFO(statp.st_mode)) {
device->dev_type = B_FIFO_DEV;
#ifdef USE_VTAPE
/* must set DeviceType = Vtape
* in normal mode, autodetection is disabled
*/
} else if (S_ISREG(statp.st_mode)) {
device->dev_type = B_VTAPE_DEV;
#endif
} else if (!(device->cap_bits & CAP_REQMOUNT)) {
Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
" or have RequiresMount=yes for DVD. st_mode=%x\n"),
device->device_name, statp.st_mode);
return NULL;
} else {
device->dev_type = B_DVD_DEV;
}
if (strcmp(device->device_name, "/dev/null") == 0) {
device->dev_type = B_NULL_DEV;
}
}
switch (device->dev_type) {
case B_DVD_DEV:
Jmsg0(jcr, M_FATAL, 0, _("DVD support is now deprecated.\n"));
return NULL;
case B_VTAPE_DEV:
dev = New(vtape);
break;
#ifdef USE_FTP
case B_FTP_DEV:
dev = New(ftp_device);
break;
#endif
case B_TAPE_DEV:
dev = New(tape_dev);
break;
case B_FILE_DEV:
case B_FIFO_DEV:
case B_NULL_DEV:
dev = New(file_dev);
break;
default:
return NULL;
}
dev->clear_slot(); /* unknown */
/* Copy user supplied device parameters from Resource */
dev->dev_name = get_memory(strlen(device->device_name)+1);
pm_strcpy(dev->dev_name, device->device_name);
dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
/* We edit "Resource-name" (physical-name) */
Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
dev->capabilities = device->cap_bits;
dev->min_free_space = device->min_free_space;
dev->min_block_size = device->min_block_size;
dev->max_block_size = device->max_block_size;
dev->max_volume_size = device->max_volume_size;
dev->max_file_size = device->max_file_size;
dev->max_concurrent_jobs = device->max_concurrent_jobs;
dev->volume_capacity = device->volume_capacity;
dev->max_rewind_wait = device->max_rewind_wait;
dev->max_open_wait = device->max_open_wait;
dev->vol_poll_interval = device->vol_poll_interval;
dev->max_spool_size = device->max_spool_size;
dev->drive_index = device->drive_index;
dev->enabled = device->enabled;
dev->autoselect = device->autoselect;
dev->read_only = device->read_only;
dev->dev_type = device->dev_type;
dev->device = device;
if (dev->is_tape()) { /* No parts on tapes */
dev->max_part_size = 0;
} else {
dev->max_part_size = device->max_part_size;
}
/* Sanity check */
if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
dev->vol_poll_interval = 60;
}
if (!device->dev) {
/* The first time we create a DEVICE from the DEVRES, we keep a pointer
* to the DEVICE accessible from the DEVRES.
*/
device->dev = dev;
}
if (dev->is_fifo()) {
dev->capabilities |= CAP_STREAM; /* set stream device */
}
/* If the device requires mount :
* - Check that the mount point is available
* - Check that (un)mount commands are defined
*/
if (dev->is_file() && dev->requires_mount()) {
if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
berrno be;
dev->dev_errno = errno;
Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
device->mount_point, be.bstrerror());
}
if (!device->mount_command || !device->unmount_command) {
Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
}
}
/* Keep the device ID in the DEVICE struct to identify the hardware */
if (dev->is_file() && stat(dev->archive_name(), &statp) == 0) {
dev->devno = statp.st_dev;
}
/* Sanity check */
if (dev->max_block_size == 0) {
max_bs = DEFAULT_BLOCK_SIZE;
} else {
max_bs = dev->max_block_size;
}
if (dev->min_block_size > max_bs) {
Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
dev->print_name());
}
if (dev->max_block_size > 4096000) {
Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
dev->max_block_size = 0;
}
if (dev->max_block_size % TAPE_BSIZE != 0) {
Jmsg3(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size=%d.\n"),
dev->max_block_size, dev->print_name(), TAPE_BSIZE);
}
if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size for device %s\n"),
dev->print_name());
}
dev->errmsg = get_pool_memory(PM_EMSG);
*dev->errmsg = 0;
if ((errstat = dev->init_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init spool mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = dev->init_acquire_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init acquire mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = dev->init_read_acquire_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init read acquire mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = dev->init_volcat_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init volcat mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
if ((errstat = dev->init_dcrs_mutex()) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init dcrs mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
dev->set_mutex_priorities();
#ifdef xxx
if ((errstat = rwl_init(&dev->lock)) != 0) {
berrno be;
dev->dev_errno = errstat;
Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
}
#endif
dev->clear_opened();
dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
dev->initiated = true;
return dev;
}
/*
* Setup device, jcr, and prepare to access device.
* If the caller wants read access, acquire the device, otherwise,
* the caller will do it.
*/
static DCR *setup_to_access_device(JCR *jcr, char *dev_name,
const char *VolumeName, int mode)
{
DEVICE *dev;
char *p;
DEVRES *device;
DCR *dcr;
char VolName[MAX_NAME_LENGTH];
init_reservations_lock();
/*
* If no volume name already given and no bsr, and it is a file,
* try getting name from Filename
*/
if (VolumeName) {
bstrncpy(VolName, VolumeName, sizeof(VolName));
if (strlen(VolumeName) >= MAX_NAME_LENGTH) {
Jmsg0(jcr, M_ERROR, 0, _("Volume name or names is too long. Please use a .bsr file.\n"));
}
} else {
VolName[0] = 0;
}
if (!jcr->bsr && VolName[0] == 0) {
if (!bstrncmp(dev_name, "/dev/", 5)) {
/* Try stripping file part */
p = dev_name + strlen(dev_name);
while (p >= dev_name && !IsPathSeparator(*p))
p--;
if (IsPathSeparator(*p)) {
bstrncpy(VolName, p+1, sizeof(VolName));
*p = 0;
}
}
}
if ((device=find_device_res(dev_name, mode)) == NULL) {
Jmsg2(jcr, M_FATAL, 0, _("Cannot find device \"%s\" in config file %s.\n"),
dev_name, configfile);
return NULL;
}
dev = init_dev(jcr, device);
if (!dev) {
Jmsg1(jcr, M_FATAL, 0, _("Cannot init device %s\n"), dev_name);
return NULL;
}
device->dev = dev;
jcr->dcr = dcr = new_dcr(jcr, NULL, dev);
if (VolName[0]) {
bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
}
bstrncpy(dcr->dev_name, device->device_name, sizeof(dcr->dev_name));
create_restore_volume_list(jcr);
if (mode) { /* read only access? */
Dmsg0(100, "Acquire device for read\n");
if (!acquire_device_for_read(dcr)) {
return NULL;
}
jcr->read_dcr = dcr;
} else {
if (!first_open_device(dcr)) {
Jmsg1(jcr, M_FATAL, 0, _("Cannot open %s\n"), dev->print_name());
return NULL;
}
jcr->dcr = dcr; /* write dcr */
}
return dcr;
}
/*
* Write an ANSI or IBM 80 character tape label
* Type determines whether we are writing HDR, EOF, or EOV labels
* Assume we are positioned to write the labels
* Returns: true of OK
* false if error
*/
bool write_ansi_ibm_labels(DCR *dcr, int type, const char *VolName)
{
DEVICE *dev = dcr->dev;
JCR *jcr = dcr->jcr;
char ansi_volname[7]; /* 6 char + \0 */
char label[80]; /* tape label */
char date[20]; /* ansi date buffer */
time_t now;
int len, stat, label_type;
/*
* If the Device requires a specific label type use it,
* otherwise, use the type requested by the Director
*/
if (dcr->device->label_type != B_BACULA_LABEL) {
label_type = dcr->device->label_type; /* force label type */
} else {
label_type = dcr->VolCatInfo.LabelType; /* accept Dir type */
}
switch (label_type) {
case B_BACULA_LABEL:
return true;
case B_ANSI_LABEL:
case B_IBM_LABEL:
ser_declare;
Dmsg1(100, "Write ANSI label type=%d\n", label_type);
len = strlen(VolName);
if (len > 6) {
Jmsg1(jcr, M_FATAL, 0, _("ANSI Volume label name \"%s\" longer than 6 chars.\n"),
VolName);
return false;
}
/* ANSI labels have 6 characters, and are padded with spaces
* 'vol1\0' => 'vol1 \0'
*/
strcpy(ansi_volname, VolName);
for(int i=len; i < 6; i++) {
ansi_volname[i]=' ';
}
ansi_volname[6]='\0'; /* only for debug */
if (type == ANSI_VOL_LABEL) {
ser_begin(label, sizeof(label));
ser_bytes("VOL1", 4);
ser_bytes(ansi_volname, 6);
/* Write VOL1 label */
if (label_type == B_IBM_LABEL) {
ascii_to_ebcdic(label, label, sizeof(label));
} else {
label[79] = '3'; /* ANSI label flag */
}
stat = dev->write(label, sizeof(label));
if (stat != sizeof(label)) {
berrno be;
Jmsg1(jcr, M_FATAL, 0, _("Could not write ANSI VOL1 label. ERR=%s\n"),
be.bstrerror());
return false;
}
}
/* Now construct HDR1 label */
memset(label, ' ', sizeof(label));
ser_begin(label, sizeof(label));
ser_bytes(labels[type], 3);
ser_bytes("1", 1);
ser_bytes("BACULA.DATA", 11); /* Filename field */
ser_begin(&label[21], sizeof(label)-21); /* fileset field */
ser_bytes(ansi_volname, 6); /* write Vol Ser No. */
ser_begin(&label[27], sizeof(label)-27);
ser_bytes("00010001000100", 14); /* File section, File seq no, Generation no */
now = time(NULL);
ser_bytes(ansi_date(now, date), 6); /* current date */
ser_bytes(ansi_date(now - 24 * 3600, date), 6); /* created yesterday */
ser_bytes(" 000000Bacula ", 27);
/* Write HDR1 label */
if (label_type == B_IBM_LABEL) {
ascii_to_ebcdic(label, label, sizeof(label));
}
/*
* This could come at the end of a tape, ignore
* EOT errors.
*/
stat = dev->write(label, sizeof(label));
if (stat != sizeof(label)) {
berrno be;
if (stat == -1) {
dev->clrerror(-1);
if (dev->dev_errno == 0) {
dev->dev_errno = ENOSPC; /* out of space */
}
if (dev->dev_errno != ENOSPC) {
Jmsg1(jcr, M_FATAL, 0, _("Could not write ANSI HDR1 label. ERR=%s\n"),
be.bstrerror());
return false;
}
} else {
Jmsg(jcr, M_FATAL, 0, _("Could not write ANSI HDR1 label.\n"));
return false;
}
}
/* Now construct HDR2 label */
memset(label, ' ', sizeof(label));
ser_begin(label, sizeof(label));
ser_bytes(labels[type], 3);
ser_bytes("2D3200032000", 12);
/* Write HDR2 label */
if (label_type == B_IBM_LABEL) {
label[4] = 'V';
ascii_to_ebcdic(label, label, sizeof(label));
}
stat = dev->write(label, sizeof(label));
if (stat != sizeof(label)) {
berrno be;
if (stat == -1) {
dev->clrerror(-1);
if (dev->dev_errno == 0) {
dev->dev_errno = ENOSPC; /* out of space */
}
if (dev->dev_errno != ENOSPC) {
Jmsg1(jcr, M_FATAL, 0, _("Could not write ANSI HDR1 label. ERR=%s\n"),
be.bstrerror());
return false;
}
dev->weof(1);
return true;
} else {
Jmsg(jcr, M_FATAL, 0, _("Could not write ANSI HDR1 label.\n"));
return false;
}
}
if (!dev->weof(1)) {
Jmsg(jcr, M_FATAL, 0, _("Error writing EOF to tape. ERR=%s"), dev->errmsg);
return false;
}
return true;
default:
Jmsg0(jcr, M_ABORT, 0, _("write_ansi_ibm_label called for non-ANSI/IBM type\n"));
return false; /* should not get here */
}
}
/*
* Create a new TLS_CONTEXT instance.
*
* Returns: Pointer to TLS_CONTEXT instance on success
* NULL on failure;
*/
TLS_CONTEXT *new_tls_context(const char *ca_certfile,
const char *ca_certdir,
const char *crlfile,
const char *certfile,
const char *keyfile,
CRYPTO_PEM_PASSWD_CB *pem_callback,
const void *pem_userdata,
const char *dhfile,
bool verify_peer)
{
TLS_CONTEXT *ctx;
BIO *bio;
DH *dh;
ctx = (TLS_CONTEXT *)malloc(sizeof(TLS_CONTEXT));
/*
* Allocate our OpenSSL TLSv1 Context
*/
ctx->openssl = SSL_CTX_new(TLSv1_method());
if (!ctx->openssl) {
openssl_post_errors(M_FATAL, _("Error initializing SSL context"));
goto err;
}
/*
* Set up pem encryption callback
*/
if (pem_callback) {
ctx->pem_callback = pem_callback;
ctx->pem_userdata = pem_userdata;
} else {
ctx->pem_callback = crypto_default_pem_callback;
ctx->pem_userdata = NULL;
}
ctx->verify_peer = verify_peer;
SSL_CTX_set_default_passwd_cb(ctx->openssl, tls_pem_callback_dispatch);
SSL_CTX_set_default_passwd_cb_userdata(ctx->openssl, (void *) ctx);
/*
* Set certificate verification paths. This requires that at least one value be non-NULL
*/
if (ca_certfile || ca_certdir) {
if (!SSL_CTX_load_verify_locations(ctx->openssl, ca_certfile, ca_certdir)) {
openssl_post_errors(M_FATAL, _("Error loading certificate verification stores"));
goto err;
}
} else if (verify_peer) {
/* At least one CA is required for peer verification */
Jmsg0(NULL, M_ERROR, 0, _("Either a certificate file or a directory must be"
" specified as a verification store\n"));
goto err;
}
#if (OPENSSL_VERSION_NUMBER >= 0x00907000L)
/*
* Set certificate revocation list.
*/
if (crlfile) {
X509_STORE *store;
X509_LOOKUP *lookup;
store = SSL_CTX_get_cert_store(ctx->openssl);
if (!store) {
openssl_post_errors(M_FATAL, _("Error loading revocation list file"));
goto err;
}
lookup = X509_STORE_add_lookup(store, X509_LOOKUP_crl_reloader());
if (!lookup) {
openssl_post_errors(M_FATAL, _("Error loading revocation list file"));
goto err;
}
if (!load_new_crl_file(lookup, (char *)crlfile)) {
openssl_post_errors(M_FATAL, _("Error loading revocation list file"));
goto err;
}
X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
}
#endif
/*
* Load our certificate file, if available. This file may also contain a
* private key, though this usage is somewhat unusual.
*/
if (certfile) {
if (!SSL_CTX_use_certificate_chain_file(ctx->openssl, certfile)) {
openssl_post_errors(M_FATAL, _("Error loading certificate file"));
goto err;
}
}
/*
* Load our private key.
*/
if (keyfile) {
if (!SSL_CTX_use_PrivateKey_file(ctx->openssl, keyfile, SSL_FILETYPE_PEM)) {
openssl_post_errors(M_FATAL, _("Error loading private key"));
goto err;
}
}
/*
* Load Diffie-Hellman Parameters.
*/
if (dhfile) {
if (!(bio = BIO_new_file(dhfile, "r"))) {
openssl_post_errors(M_FATAL, _("Unable to open DH parameters file"));
goto err;
}
dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
BIO_free(bio);
if (!dh) {
openssl_post_errors(M_FATAL, _("Unable to load DH parameters from specified file"));
goto err;
}
if (!SSL_CTX_set_tmp_dh(ctx->openssl, dh)) {
openssl_post_errors(M_FATAL, _("Failed to set TLS Diffie-Hellman parameters"));
DH_free(dh);
goto err;
}
/*
* Enable Single-Use DH for Ephemeral Keying
*/
SSL_CTX_set_options(ctx->openssl, SSL_OP_SINGLE_DH_USE);
}
if (SSL_CTX_set_cipher_list(ctx->openssl, TLS_DEFAULT_CIPHERS) != 1) {
Jmsg0(NULL, M_ERROR, 0,
_("Error setting cipher list, no valid ciphers available\n"));
goto err;
}
/*
* Verify Peer Certificate
*/
if (verify_peer) {
/*
* SSL_VERIFY_FAIL_IF_NO_PEER_CERT has no effect in client mode
*/
SSL_CTX_set_verify(ctx->openssl,
SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
openssl_verify_peer);
} else {
SSL_CTX_set_verify(ctx->openssl,
SSL_VERIFY_NONE,
NULL);
}
return ctx;
err:
/*
* Clean up after ourselves
*/
if (ctx->openssl) {
SSL_CTX_free(ctx->openssl);
}
free(ctx);
return NULL;
}
bool CONFIG::parse_config()
{
LEX *lc = NULL;
int token, i, pass;
int res_type = 0;
enum parse_state state = p_none;
RES_ITEM *items = NULL;
int level = 0;
static bool first = true;
int errstat;
const char *cf = m_cf;
LEX_ERROR_HANDLER *scan_error = m_scan_error;
int err_type = m_err_type;
if (first && (errstat=rwl_init(&res_lock)) != 0) {
berrno be;
Jmsg1(NULL, M_ABORT, 0, _("Unable to initialize resource lock. ERR=%s\n"),
be.bstrerror(errstat));
}
first = false;
char *full_path = (char *)alloca(MAX_PATH + 1);
if (!find_config_file(cf, full_path, MAX_PATH +1)) {
Jmsg0(NULL, M_ABORT, 0, _("Config filename too long.\n"));
}
cf = full_path;
/* Make two passes. The first builds the name symbol table,
* and the second picks up the items.
*/
Dmsg0(900, "Enter parse_config()\n");
for (pass=1; pass <= 2; pass++) {
Dmsg1(900, "parse_config pass %d\n", pass);
if ((lc = lex_open_file(lc, cf, scan_error)) == NULL) {
berrno be;
/* We must create a lex packet to print the error */
lc = (LEX *)malloc(sizeof(LEX));
memset(lc, 0, sizeof(LEX));
if (scan_error) {
lc->scan_error = scan_error;
} else {
lex_set_default_error_handler(lc);
}
lex_set_error_handler_error_type(lc, err_type) ;
bstrncpy(lc->str, cf, sizeof(lc->str));
lc->fname = lc->str;
scan_err2(lc, _("Cannot open config file \"%s\": %s\n"),
lc->str, be.bstrerror());
free(lc);
return 0;
}
lex_set_error_handler_error_type(lc, err_type) ;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg3(900, "parse state=%d pass=%d got token=%s\n", state, pass,
lex_tok_to_str(token));
switch (state) {
case p_none:
if (token == T_EOL) {
break;
} else if (token == T_UTF8_BOM) {
/* We can assume the file is UTF-8 as we have seen a UTF-8 BOM */
break;
} else if (token == T_UTF16_BOM) {
scan_err0(lc, _("Currently we cannot handle UTF-16 source files. "
"Please convert the conf file to UTF-8\n"));
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;
}
/*
* See who is connecting and lookup the authentication information.
* First make him prove his identity and then prove our identity to the Remote daemon.
*/
static inline bool two_way_authenticate(int rcode, BSOCK *bs, JCR* jcr)
{
POOLMEM *dirname;
DIRRES *director = NULL;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true; /* require md5 compatible DIR */
bool auth_success = false;
alist *verify_list = NULL;
if (rcode != R_DIRECTOR) {
Dmsg1(dbglvl, "I only authenticate Directors, not %d\n", rcode);
Jmsg1(jcr, M_FATAL, 0, _("I only authenticate Directors, not %d\n"), rcode);
return 0;
}
/*
* Sanity check.
*/
if (bs->msglen < 25 || bs->msglen > 500) {
Dmsg2(dbglvl, "Bad Hello command from Director at %s. Len=%d.\n",
bs->who(), bs->msglen);
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s. Len=%d.\n"),
bs->who(), bs->msglen);
return 0;
}
dirname = get_pool_memory(PM_MESSAGE);
dirname = check_pool_memory_size(dirname, bs->msglen);
if (sscanf(bs->msg, "Hello Director %127s calling", dirname) != 1) {
bs->msg[100] = 0;
Dmsg2(dbglvl, "Bad Hello command from Director at %s: %s\n",
bs->who(), bs->msg);
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s: %s\n"),
bs->who(), bs->msg);
return 0;
}
director = NULL;
unbash_spaces(dirname);
foreach_res(director, rcode) {
if (bstrcmp(director->hdr.name, dirname)) {
break;
}
}
if (!director) {
Dmsg2(dbglvl, "Connection from unknown Director %s at %s rejected.\n",
dirname, bs->who());
Jmsg(jcr, M_FATAL, 0, _("Connection from unknown Director %s at %s rejected.\n"
"Please see %s for help.\n"),
dirname, bs->who(), MANUAL_AUTH_URL);
free_pool_memory(dirname);
return 0;
}
/*
* TLS Requirement
*/
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (director->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
if (director->tls_verify_peer) {
verify_list = director->tls_allowed_cns;
}
ASSERT(director->password.encoding == p_encoding_md5);
/*
* Timeout Hello after 10 mins
*/
btimer_t *tid = start_bsock_timer(bs, AUTH_TIMEOUT);
auth_success = cram_md5_challenge(bs, director->password.value, tls_local_need, compatible);
if (auth_success) {
auth_success = cram_md5_respond(bs, director->password.value, &tls_remote_need, &compatible);
if (!auth_success) {
Dmsg1(dbglvl, "cram_get_auth failed with %s\n", bs->who());
}
} else {
Dmsg1(dbglvl, "cram_auth failed with %s\n", bs->who());
}
if (!auth_success) {
Jmsg(jcr, M_FATAL, 0, _("Incorrect password given by Director.\n"
"Please see %s for help.\n"), MANUAL_AUTH_URL);
auth_success = false;
goto auth_fatal;
}
/*
* Verify that the remote host is willing to meet our TLS requirements
*/
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server did not"
" advertize required TLS support.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
/*
* Verify that we are willing to meet the remote host's requirements
*/
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/*
* Engage TLS! Full Speed Ahead!
*/
if (!bnet_tls_server(director->tls_ctx, bs, verify_list)) {
Jmsg(jcr, M_FATAL, 0, _("TLS negotiation failed with DIR at \"%s:%d\"\n"),
bs->host(), bs->port());
auth_success = false;
goto auth_fatal;
}
if (director->tls_authenticate) { /* authenticate with tls only? */
bs->free_tls(); /* yes, shut it down */
}
}
auth_fatal:
stop_bsock_timer(tid);
free_pool_memory(dirname);
jcr->director = director;
return auth_success;
}
/*
* Do a verification of the specified files against the Catlaog
*
* Returns: false on failure
* true on success
*/
bool do_verify(JCR *jcr)
{
int JobLevel;
const char *level;
BSOCK *fd = NULL;
BSOCK *sd = NULL;
int status;
char ed1[100];
JOB_DBR jr;
JobId_t verify_jobid = 0;
const char *Name;
free_wstorage(jcr); /* we don't write */
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
/*
* Find JobId of last job that ran. Note, we do this when
* the job actually starts running, not at schedule time,
* so that we find the last job that terminated before
* this job runs rather than before it is scheduled. This
* permits scheduling a Backup and Verify at the same time,
* but with the Verify at a lower priority.
*
* For VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
* last backup Job.
*/
JobLevel = jcr->getJobLevel();
switch (JobLevel) {
case L_VERIFY_CATALOG:
case L_VERIFY_VOLUME_TO_CATALOG:
case L_VERIFY_DISK_TO_CATALOG:
memcpy(&jr, &jcr->jr, sizeof(jr));
if (jcr->res.verify_job &&
(JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||
JobLevel == L_VERIFY_DISK_TO_CATALOG)) {
Name = jcr->res.verify_job->name();
} else {
Name = NULL;
}
Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
/*
* See if user supplied a jobid= as run argument or from menu
*/
if (jcr->VerifyJobId) {
verify_jobid = jcr->VerifyJobId;
Dmsg1(100, "Supplied jobid=%d\n", verify_jobid);
} else {
if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
if (JobLevel == L_VERIFY_CATALOG) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
"running the current Job.\n"));
} else {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous Job for this client.\n"));
}
return false;
}
verify_jobid = jr.JobId;
}
Dmsg1(100, "Last full jobid=%d\n", verify_jobid);
/*
* Now get the job record for the previous backup that interests
* us. We use the verify_jobid that we found above.
*/
jcr->previous_jr.JobId = verify_jobid;
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!(jcr->previous_jr.JobStatus == JS_Terminated ||
jcr->previous_jr.JobStatus == JS_Warnings)) {
Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
verify_jobid, jcr->previous_jr.JobStatus);
return false;
}
Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
jcr->previous_jr.JobId, jcr->previous_jr.Job);
}
/*
* If we are verifying a Volume, we need the Storage
* daemon, so open a connection, otherwise, just
* create a dummy authorization key (passed to
* File daemon but not used).
*/
switch (JobLevel) {
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* Note: negative status is an error, zero status, means
* no files were backed up, so skip calling SD and
* client.
*/
status = create_restore_bootstrap_file(jcr);
if (status < 0) { /* error */
return false;
} else if (status == 0) { /* No files, nothing to do */
verify_cleanup(jcr, JS_Terminated); /* clean up */
return true; /* get out */
}
if (jcr->res.verify_job) {
jcr->res.fileset = jcr->res.verify_job->fileset;
}
break;
default:
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
break;
}
Dmsg2(100, "ClientId=%u JobLevel=%c\n", jcr->previous_jr.ClientId, JobLevel);
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/*
* Print Job Start message
*/
Jmsg(jcr, M_INFO, 0, _("Start Verify JobId=%s Level=%s Job=%s\n"),
edit_uint64(jcr->JobId, ed1), level_to_str(JobLevel), jcr->Job);
switch (JobLevel) {
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* Start conversation with Storage daemon
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_storage_daemon(jcr, 10, me->SDConnectTimeout, true)) {
return false;
}
sd = jcr->store_bsock;
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->res.rstorage, NULL, /* send_bsr */ true)) {
return false;
}
jcr->passive_client = jcr->res.client->passive;
if (!jcr->passive_client) {
/*
* Start the Job in the SD.
*/
if (!sd->fsend("run")) {
return false;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
return false;
}
Dmsg0(50, "Storage daemon connection OK\n");
}
/*
* OK, now connect to the File daemon and ask him for the files.
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, me->FDConnectTimeout, true)) {
goto bail_out;
}
send_job_info(jcr);
fd = jcr->file_bsock;
/*
* Check if the file daemon supports passive client mode.
*/
if (jcr->passive_client && jcr->FDVersion < FD_VERSION_51) {
Jmsg(jcr, M_FATAL, 0,
_("Client \"%s\" doesn't support passive client mode. "
"Please upgrade your client or disable compat mode.\n"),
jcr->res.client->name());
goto bail_out;
}
break;
default:
/*
* OK, now connect to the File daemon and ask him for the files.
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, me->FDConnectTimeout, true)) {
goto bail_out;
}
send_job_info(jcr);
fd = jcr->file_bsock;
break;
}
jcr->setJobStatus(JS_Running);
Dmsg0(30, ">filed: Send include list\n");
if (!send_include_list(jcr)) {
goto bail_out;
}
Dmsg0(30, ">filed: Send exclude list\n");
if (!send_exclude_list(jcr)) {
goto bail_out;
}
/*
* Send Level command to File daemon, as well as the Storage address if appropriate.
*/
switch (JobLevel) {
case L_VERIFY_INIT:
level = "init";
break;
case L_VERIFY_CATALOG:
level = "catalog";
break;
case L_VERIFY_VOLUME_TO_CATALOG:
if (!jcr->RestoreBootstrap) {
Jmsg0(jcr, M_FATAL, 0, _("Deprecated feature ... use bootstrap.\n"));
goto bail_out;
}
if (!jcr->passive_client) {
int tls_need = BNET_TLS_NONE;
STORERES *store = jcr->res.rstore;
/*
* Send Storage daemon address to the File daemon
*/
if (store->SDDport == 0) {
store->SDDport = store->SDport;
}
/*
* TLS Requirement
*/
if (store->tls.enable) {
if (store->tls.require) {
tls_need = BNET_TLS_REQUIRED;
} else {
tls_need = BNET_TLS_OK;
}
}
fd->fsend(storaddrcmd, store->address, store->SDDport, tls_need, jcr->sd_auth_key);
if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
goto bail_out;
}
} else {
int tls_need = BNET_TLS_NONE;
CLIENTRES *client = jcr->res.client;
/*
* TLS Requirement
*/
if (client->tls.enable) {
if (client->tls.require) {
tls_need = BNET_TLS_REQUIRED;
} else {
tls_need = BNET_TLS_OK;
}
}
/*
* Tell the SD to connect to the FD.
*/
sd->fsend(passiveclientcmd, client->address, client->FDport, tls_need);
if (!response(jcr, sd, OKpassiveclient, "Passive client", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Start the Job in the SD.
*/
if (!sd->fsend("run")) {
goto bail_out;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
goto bail_out;
}
Dmsg0(50, "Storage daemon connection OK\n");
}
level = "volume";
break;
case L_VERIFY_DATA:
level = "data";
break;
case L_VERIFY_DISK_TO_CATALOG:
level="disk_to_catalog";
break;
default:
Jmsg2(jcr, M_FATAL, 0, _("Unimplemented Verify level %d(%c)\n"), JobLevel, JobLevel);
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* Send verify command/level to File daemon
*/
fd->fsend(verifycmd, level);
if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Now get data back from File daemon and
* compare it to the catalog or store it in the
* catalog depending on the run type.
*/
switch (JobLevel) {
case L_VERIFY_CATALOG:
/*
* Verify from catalog
*/
Dmsg0(10, "Verify level=catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* Verify Volume to catalog entries
*/
Dmsg0(10, "Verify level=volume\n");
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_DISK_TO_CATALOG:
/*
* Verify Disk attributes to catalog
*/
Dmsg0(10, "Verify level=disk_to_catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_INIT:
/*
* Build catalog
*/
Dmsg0(10, "Verify level=init\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_put_in_catalog(jcr);
db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
db_write_batch_file_records(jcr);
break;
default:
Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), JobLevel);
goto bail_out;
}
status = wait_for_job_termination(jcr);
verify_cleanup(jcr, status);
return true;
bail_out:
if (jcr->file_bsock) {
jcr->file_bsock->signal(BNET_TERMINATE);
jcr->file_bsock->close();
delete jcr->file_bsock;
jcr->file_bsock = NULL;
}
return false;
}
/*
* See who is connecting and lookup the authentication information.
* First make him prove his identity and then prove our identity to the Remote daemon.
*/
static inline bool two_way_authenticate(int rcode, BSOCK *bs, JCR* jcr)
{
POOLMEM *dirname = get_pool_memory(PM_MESSAGE);
DIRRES *director = NULL;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true; /* Want md5 compatible DIR */
bool auth_success = false;
alist *verify_list = NULL;
btimer_t *tid = NULL;
if (rcode != R_DIRECTOR) {
Dmsg1(dbglvl, "I only authenticate directors, not %d\n", rcode);
Jmsg1(jcr, M_FATAL, 0, _("I only authenticate directors, not %d\n"), rcode);
goto auth_fatal;
}
if (bs->msglen < 25 || bs->msglen > 500) {
Dmsg2(dbglvl, "Bad Hello command from Director at %s. Len=%d.\n",
bs->who(), bs->msglen);
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s. Len=%d.\n"),
who, bs->msglen);
goto auth_fatal;
}
dirname = check_pool_memory_size(dirname, bs->msglen);
if (sscanf(bs->msg, "Hello Director %s calling", dirname) != 1) {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
bs->msg[100] = 0;
Dmsg2(dbglvl, "Bad Hello command from Director at %s: %s\n",
bs->who(), bs->msg);
Jmsg2(jcr, M_FATAL, 0, _("Bad Hello command from Director at %s: %s\n"),
who, bs->msg);
goto auth_fatal;
}
unbash_spaces(dirname);
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, dirname))
break;
}
if (!director) {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Jmsg2(jcr, M_FATAL, 0, _("Connection from unknown Director %s at %s rejected.\n"),
dirname, who);
goto auth_fatal;
}
if (have_tls) {
/*
* TLS Requirement
*/
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (director->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
if (director->tls_verify_peer) {
verify_list = director->tls_allowed_cns;
}
}
/*
* Timeout Hello after 10 min
*/
tid = start_bsock_timer(bs, AUTH_TIMEOUT);
/*
* Sanity check.
*/
ASSERT(director->password.encoding == p_encoding_md5);
/*
* Challenge the director
*/
auth_success = cram_md5_challenge(bs, director->password.value, tls_local_need, compatible);
if (job_canceled(jcr)) {
auth_success = false;
goto auth_fatal; /* quick exit */
}
if (auth_success) {
auth_success = cram_md5_respond(bs, director->password.value, &tls_remote_need, &compatible);
if (!auth_success) {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Dmsg1(dbglvl, "cram_get_auth failed for %s\n", who);
}
} else {
char addr[64];
char *who = bnet_get_peer(bs, addr, sizeof(addr)) ? bs->who() : addr;
Dmsg1(dbglvl, "cram_auth failed for %s\n", who);
}
if (!auth_success) {
Emsg1(M_FATAL, 0, _("Incorrect password given by Director at %s.\n"),
bs->who());
goto auth_fatal;
}
/*
* Verify that the remote host is willing to meet our TLS requirements
*/
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server did not"
" advertize required TLS support.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
/*
* Verify that we are willing to meet the remote host's requirements
*/
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Jmsg0(jcr, M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
Dmsg2(dbglvl, "remote_need=%d local_need=%d\n", tls_remote_need, tls_local_need);
auth_success = false;
goto auth_fatal;
}
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/*
* Engage TLS! Full Speed Ahead!
*/
if (!bnet_tls_server(director->tls_ctx, bs, verify_list)) {
Jmsg0(jcr, M_FATAL, 0, _("TLS negotiation failed.\n"));
auth_success = false;
goto auth_fatal;
}
if (director->tls_authenticate) { /* authentication only? */
bs->free_tls(); /* shutodown tls */
}
}
auth_fatal:
if (tid) {
stop_bsock_timer(tid);
tid = NULL;
}
free_pool_memory(dirname);
jcr->director = director;
/*
* Single thread all failures to avoid DOS
*/
if (!auth_success) {
P(mutex);
bmicrosleep(6, 0);
V(mutex);
}
return auth_success;
}
/*
* Do a verification of the specified files against the Catlaog
*
* Returns: false on failure
* true on success
*/
bool do_verify(JCR *jcr)
{
const char *level;
BSOCK *fd, *sd;
int stat;
char ed1[100];
JOB_DBR jr;
JobId_t verify_jobid = 0;
char *store_address;
uint32_t store_port;
const char *Name;
free_wstorage(jcr); /* we don't write */
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
/*
* Find JobId of last job that ran. Note, we do this when
* the job actually starts running, not at schedule time,
* so that we find the last job that terminated before
* this job runs rather than before it is scheduled. This
* permits scheduling a Backup and Verify at the same time,
* but with the Verify at a lower priority.
*
* For VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
* last backup Job.
*/
if (jcr->getJobLevel() == L_VERIFY_CATALOG ||
jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA) {
memcpy(&jr, &jcr->jr, sizeof(jr));
if (jcr->verify_job &&
(jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA)) {
Name = jcr->verify_job->name();
} else {
Name = NULL;
}
Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
/* see if user supplied a jobid= as run argument or from menu */
if (jcr->RestoreJobId) {
verify_jobid = jcr->RestoreJobId;
Dmsg1(100, "Supplied jobid=%d\n", verify_jobid);
} else {
if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
if (jcr->getJobLevel() == L_VERIFY_CATALOG) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
"running the current Job.\n"));
} else {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous Job for this client.\n"));
}
return false;
}
verify_jobid = jr.JobId;
}
Dmsg1(100, "Last full jobid=%d\n", verify_jobid);
}
/*
* Now get the job record for the previous backup that interests
* us. We use the verify_jobid that we found above.
*/
if (jcr->getJobLevel() == L_VERIFY_CATALOG ||
jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA) {
jcr->previous_jr.JobId = verify_jobid;
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!(jcr->previous_jr.JobStatus == JS_Terminated ||
jcr->previous_jr.JobStatus == JS_Warnings)) {
Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
verify_jobid, jcr->previous_jr.JobStatus);
return false;
}
Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
jcr->previous_jr.JobId, jcr->previous_jr.Job);
}
/*
* If we are verifying a Volume, we need the Storage
* daemon, so open a connection, otherwise, just
* create a dummy authorization key (passed to
* File daemon but not used).
*/
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG || jcr->getJobLevel() == L_VERIFY_DATA) {
int stat;
/*
* Note: negative status is an error, zero status, means
* no files were backed up, so skip calling SD and
* client.
*/
stat = create_restore_bootstrap_file(jcr);
if (stat < 0) { /* error */
return false;
} else if (stat == 0) { /* No files, nothing to do */
verify_cleanup(jcr, JS_Terminated); /* clean up */
return true; /* get out */
}
} else {
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
}
/* Pass the original fileset to the client */
if (jcr->getJobLevel() == L_VERIFY_DATA) {
FILESET_DBR fdbr;
memset(&fdbr, 0, sizeof(fdbr));
fdbr.FileSetId = jcr->previous_jr.FileSetId;
if (!db_get_fileset_record(jcr, jcr->db, &fdbr)) {
Jmsg(jcr, M_FATAL, 0,
_("Could not get fileset record from previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
jcr->fileset = (FILESET *)GetResWithName(R_FILESET, fdbr.FileSet);
if (!jcr->fileset) {
if (jcr->verify_job) {
jcr->fileset = jcr->verify_job->fileset;
Jmsg(jcr, M_WARNING, 0,
_("Could not find FileSet resource \"%s\" from previous Job\n"),
fdbr.FileSet);
Jmsg(jcr, M_INFO, 0,
_("Using FileSet \"%\"\n"), jcr->fileset->name());
} else {
Jmsg(jcr, M_FATAL, 0,
_("Could not get FileSet resource for verify Job."));
return false;
}
}
Dmsg1(50, "FileSet = %s\n", jcr->fileset->name());
}
/* Pass the current fileset to the client */
if (jcr->getJobLevel() == L_VERIFY_DISK_TO_CATALOG && jcr->verify_job) {
jcr->fileset = jcr->verify_job->fileset;
}
Dmsg2(100, "ClientId=%u JobLevel=%c\n",
jcr->previous_jr.ClientId, jcr->getJobLevel());
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/* Print Job Start message */
Jmsg(jcr, M_INFO, 0, _("Start Verify JobId=%s Level=%s Job=%s\n"),
edit_uint64(jcr->JobId, ed1), level_to_str(jcr->getJobLevel()), jcr->Job);
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->getJobLevel() == L_VERIFY_DATA)
{
/*
* Start conversation with Storage daemon
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
return false;
}
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->rstorage, NULL)) {
return false;
}
sd = jcr->store_bsock;
jcr->sd_calls_client = jcr->client->sd_calls_client;
/*
* Send the bootstrap file -- what Volumes/files to restore
*/
if (!send_bootstrap_file(jcr, sd) ||
!response(jcr, sd, OKbootstrap, "Bootstrap", DISPLAY_ERROR)) {
goto bail_out;
}
if (!jcr->sd_calls_client) {
if (!run_storage_and_start_message_thread(jcr, sd)) {
return false;
}
}
}
/*
* OK, now connect to the File daemon
* and ask him for the files.
*/
jcr->setJobStatus(JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
goto bail_out;
}
jcr->setJobStatus(JS_Running);
fd = jcr->file_bsock;
Dmsg0(30, ">filed: Send include list\n");
if (!send_include_list(jcr)) {
goto bail_out;
}
Dmsg0(30, ">filed: Send exclude list\n");
if (!send_exclude_list(jcr)) {
goto bail_out;
}
/*
* Send Level command to File daemon, as well
* as the Storage address if appropriate.
*/
switch (jcr->getJobLevel()) {
case L_VERIFY_INIT:
level = "init";
break;
case L_VERIFY_CATALOG:
level = "catalog";
break;
case L_VERIFY_DATA:
case L_VERIFY_VOLUME_TO_CATALOG:
if (jcr->sd_calls_client) {
if (jcr->FDVersion < 10) {
Jmsg(jcr, M_FATAL, 0, _("The File daemon does not support SDCallsClient.\n"));
goto bail_out;
}
if (!send_client_addr_to_sd(jcr)) {
goto bail_out;
}
if (!run_storage_and_start_message_thread(jcr, jcr->store_bsock)) {
return false;
}
store_address = jcr->rstore->address; /* dummy */
store_port = 0; /* flag that SD calls FD */
} else {
/*
* send Storage daemon address to the File daemon
*/
if (jcr->rstore->SDDport == 0) {
jcr->rstore->SDDport = jcr->rstore->SDport;
}
store_address = get_storage_address(jcr->client, jcr->rstore);
store_port = jcr->rstore->SDDport;
}
if (!send_store_addr_to_fd(jcr, jcr->rstore, store_address, store_port)) {
goto bail_out;
}
if (!jcr->RestoreBootstrap) {
Jmsg0(jcr, M_FATAL, 0, _("Deprecated feature ... use bootstrap.\n"));
goto bail_out;
}
if (jcr->getJobLevel() == L_VERIFY_VOLUME_TO_CATALOG) {
level = "volume";
} else {
level = "data";
}
break;
case L_VERIFY_DISK_TO_CATALOG:
level="disk_to_catalog";
break;
default:
Jmsg2(jcr, M_FATAL, 0, _("Unimplemented Verify level %d(%c)\n"),
jcr->getJobLevel(),
jcr->getJobLevel());
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* Send verify command/level to File daemon
*/
fd->fsend(verifycmd, level);
if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Now get data back from File daemon and
* compare it to the catalog or store it in the
* catalog depending on the run type.
*/
/* Compare to catalog */
switch (jcr->getJobLevel()) {
case L_VERIFY_CATALOG:
Dmsg0(10, "Verify level=catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_VOLUME_TO_CATALOG:
Dmsg0(10, "Verify level=volume\n");
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_DISK_TO_CATALOG:
Dmsg0(10, "Verify level=disk_to_catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_INIT:
/* Build catalog */
Dmsg0(10, "Verify level=init\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_put_in_catalog(jcr);
db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
db_write_batch_file_records(jcr);
break;
case L_VERIFY_DATA:
/* Nothing special to do */
bget_dirmsg(fd); /* eat EOD */
break;
default:
Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), jcr->getJobLevel());
goto bail_out;
}
stat = wait_for_job_termination(jcr);
verify_cleanup(jcr, stat);
return true;
bail_out:
return false;
}
/*
* Do a verification of the specified files against the Catlaog
*
* Returns: false on failure
* true on success
*/
bool do_verify(JCR *jcr)
{
const char *level;
BSOCK *fd;
int stat;
char ed1[100];
JOB_DBR jr;
JobId_t verify_jobid = 0;
const char *Name;
free_wstorage(jcr); /* we don't write */
memset(&jcr->previous_jr, 0, sizeof(jcr->previous_jr));
/*
* Find JobId of last job that ran. Note, we do this when
* the job actually starts running, not at schedule time,
* so that we find the last job that terminated before
* this job runs rather than before it is scheduled. This
* permits scheduling a Backup and Verify at the same time,
* but with the Verify at a lower priority.
*
* For VERIFY_CATALOG we want the JobId of the last INIT.
* For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
* last backup Job.
*/
if (jcr->get_JobLevel() == L_VERIFY_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG) {
memcpy(&jr, &jcr->jr, sizeof(jr));
if (jcr->verify_job &&
(jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG)) {
Name = jcr->verify_job->name();
} else {
Name = NULL;
}
Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
if (jcr->get_JobLevel() == L_VERIFY_CATALOG) {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous InitCatalog Job.\n"
"Please run a Verify with Level=InitCatalog before\n"
"running the current Job.\n"));
} else {
Jmsg(jcr, M_FATAL, 0, _(
"Unable to find JobId of previous Job for this client.\n"));
}
return false;
}
verify_jobid = jr.JobId;
Dmsg1(100, "Last full jobid=%d\n", verify_jobid);
}
/*
* Now get the job record for the previous backup that interests
* us. We use the verify_jobid that we found above.
*/
if (jcr->get_JobLevel() == L_VERIFY_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG ||
jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG) {
jcr->previous_jr.JobId = verify_jobid;
if (!db_get_job_record(jcr, jcr->db, &jcr->previous_jr)) {
Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
db_strerror(jcr->db));
return false;
}
if (!(jcr->previous_jr.JobStatus == JS_Terminated ||
jcr->previous_jr.JobStatus == JS_Warnings)) {
Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
verify_jobid, jcr->previous_jr.JobStatus);
return false;
}
Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
jcr->previous_jr.JobId, jcr->previous_jr.Job);
}
/*
* If we are verifying a Volume, we need the Storage
* daemon, so open a connection, otherwise, just
* create a dummy authorization key (passed to
* File daemon but not used).
*/
if (jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG) {
if (!create_restore_bootstrap_file(jcr)) {
return false;
}
} else {
jcr->sd_auth_key = bstrdup("dummy"); /* dummy Storage daemon key */
}
if (jcr->get_JobLevel() == L_VERIFY_DISK_TO_CATALOG && jcr->verify_job) {
jcr->fileset = jcr->verify_job->fileset;
}
Dmsg2(100, "ClientId=%u JobLevel=%c\n", jcr->previous_jr.ClientId, jcr->get_JobLevel());
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
return false;
}
/* Print Job Start message */
Jmsg(jcr, M_INFO, 0, _("Start Verify JobId=%s Level=%s Job=%s\n"),
edit_uint64(jcr->JobId, ed1), level_to_str(jcr->get_JobLevel()), jcr->Job);
if (jcr->get_JobLevel() == L_VERIFY_VOLUME_TO_CATALOG) {
/*
* Start conversation with Storage daemon
*/
set_jcr_job_status(jcr, JS_Blocked);
if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
return false;
}
/*
* Now start a job with the Storage daemon
*/
if (!start_storage_daemon_job(jcr, jcr->rstorage, NULL)) {
return false;
}
if (!jcr->store_bsock->fsend("run")) {
return false;
}
/*
* Now start a Storage daemon message thread
*/
if (!start_storage_daemon_message_thread(jcr)) {
return false;
}
Dmsg0(50, "Storage daemon connection OK\n");
}
/*
* OK, now connect to the File daemon
* and ask him for the files.
*/
set_jcr_job_status(jcr, JS_Blocked);
if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
goto bail_out;
}
set_jcr_job_status(jcr, JS_Running);
fd = jcr->file_bsock;
Dmsg0(30, ">filed: Send include list\n");
if (!send_include_list(jcr)) {
goto bail_out;
}
Dmsg0(30, ">filed: Send exclude list\n");
if (!send_exclude_list(jcr)) {
goto bail_out;
}
/*
* Send Level command to File daemon, as well
* as the Storage address if appropriate.
*/
switch (jcr->get_JobLevel()) {
case L_VERIFY_INIT:
level = "init";
break;
case L_VERIFY_CATALOG:
level = "catalog";
break;
case L_VERIFY_VOLUME_TO_CATALOG:
/*
* send Storage daemon address to the File daemon
*/
if (jcr->rstore->SDDport == 0) {
jcr->rstore->SDDport = jcr->rstore->SDport;
}
bnet_fsend(fd, storaddr, jcr->rstore->address, jcr->rstore->SDDport);
if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Send the bootstrap file -- what Volumes/files to restore
*/
if (!send_bootstrap_file(jcr, fd) ||
!response(jcr, fd, OKbootstrap, "Bootstrap", DISPLAY_ERROR)) {
goto bail_out;
}
if (!jcr->RestoreBootstrap) {
Jmsg0(jcr, M_FATAL, 0, _("Deprecated feature ... use bootstrap.\n"));
goto bail_out;
}
level = "volume";
break;
case L_VERIFY_DATA:
level = "data";
break;
case L_VERIFY_DISK_TO_CATALOG:
level="disk_to_catalog";
break;
default:
Jmsg2(jcr, M_FATAL, 0, _("Unimplemented Verify level %d(%c)\n"), jcr->get_JobLevel(),
jcr->get_JobLevel());
goto bail_out;
}
if (!send_runscripts_commands(jcr)) {
goto bail_out;
}
/*
* Send verify command/level to File daemon
*/
fd->fsend(verifycmd, level);
if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
goto bail_out;
}
/*
* Now get data back from File daemon and
* compare it to the catalog or store it in the
* catalog depending on the run type.
*/
/* Compare to catalog */
switch (jcr->get_JobLevel()) {
case L_VERIFY_CATALOG:
Dmsg0(10, "Verify level=catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_VOLUME_TO_CATALOG:
Dmsg0(10, "Verify level=volume\n");
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_DISK_TO_CATALOG:
Dmsg0(10, "Verify level=disk_to_catalog\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_compare_to_catalog(jcr, jcr->previous_jr.JobId);
break;
case L_VERIFY_INIT:
/* Build catalog */
Dmsg0(10, "Verify level=init\n");
jcr->sd_msg_thread_done = true; /* no SD msg thread, so it is done */
jcr->SDJobStatus = JS_Terminated;
get_attributes_and_put_in_catalog(jcr);
db_end_transaction(jcr, jcr->db); /* terminate any open transaction */
db_write_batch_file_records(jcr);
break;
default:
Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), jcr->get_JobLevel());
goto bail_out;
}
stat = wait_for_job_termination(jcr);
verify_cleanup(jcr, stat);
return true;
bail_out:
return false;
}
/*
* Append Data sent from Client (FD/SD)
*
*/
bool do_append_data(JCR *jcr)
{
int32_t n;
int32_t file_index, stream, last_file_index;
uint64_t stream_len;
BSOCK *fd = jcr->file_bsock;
bool ok = true;
DEV_RECORD rec;
char buf1[100], buf2[100];
DCR *dcr = jcr->dcr;
DEVICE *dev;
char ec[50];
POOLMEM *eblock = NULL;
POOL_MEM errmsg(PM_EMSG);
if (!dcr) {
pm_strcpy(jcr->errmsg, _("DCR is NULL!!!\n"));
Jmsg0(jcr, M_FATAL, 0, jcr->errmsg);
return false;
}
dev = dcr->dev;
if (!dev) {
pm_strcpy(jcr->errmsg, _("DEVICE is NULL!!!\n"));
Jmsg0(jcr, M_FATAL, 0, jcr->errmsg);
return false;
}
Dmsg1(100, "Start append data. res=%d\n", dev->num_reserved());
memset(&rec, 0, sizeof(rec));
if (!fd->set_buffer_size(dcr->device->max_network_buffer_size, BNET_SETBUF_WRITE)) {
jcr->setJobStatus(JS_ErrorTerminated);
pm_strcpy(jcr->errmsg, _("Unable to set network buffer size.\n"));
Jmsg0(jcr, M_FATAL, 0, jcr->errmsg);
return false;
}
if (!acquire_device_for_append(dcr)) {
jcr->setJobStatus(JS_ErrorTerminated);
return false;
}
jcr->sendJobStatus(JS_Running);
//ASSERT(dev->VolCatInfo.VolCatName[0]);
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
Dmsg1(50, "Begin append device=%s\n", dev->print_name());
begin_data_spool(dcr);
begin_attribute_spool(jcr);
Dmsg0(100, "Just after acquire_device_for_append\n");
//ASSERT(dev->VolCatInfo.VolCatName[0]);
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
/*
* Write Begin Session Record
*/
if (!write_session_label(dcr, SOS_LABEL)) {
Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
dev->bstrerror());
jcr->setJobStatus(JS_ErrorTerminated);
ok = false;
}
//ASSERT(dev->VolCatInfo.VolCatName[0]);
if (dev->VolCatInfo.VolCatName[0] == 0) {
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
}
/* Tell File daemon to send data */
if (!fd->fsend(OK_data)) {
berrno be;
Jmsg1(jcr, M_FATAL, 0, _("Network send error to FD. ERR=%s\n"),
be.bstrerror(fd->b_errno));
ok = false;
}
/*
* Get Data from File daemon, write to device. To clarify what is
* going on here. We expect:
* - A stream header
* - Multiple records of data
* - EOD record
*
* The Stream header is just used to synchronize things, and
* none of the stream header is written to tape.
* The Multiple records of data, contain first the Attributes,
* then after another stream header, the file data, then
* after another stream header, the MD5 data if any.
*
* 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 */
GetMsg *qfd;
qfd = New(GetMsg(jcr, fd, NULL, GETMSG_MAX_MSG_SIZE));
qfd->start_read_sock();
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)
* stream_len (Expected length of this stream. This
* will be the size backed up if the file does not
* grow during the backup.
*/
n = qfd->bget_msg(NULL);
if (n <= 0) {
if (n == BNET_SIGNAL && qfd->msglen == BNET_EOD) {
Dmsg0(200, "Got EOD on reading header.\n");
break; /* end of data */
}
Jmsg3(jcr, M_FATAL, 0, _("Error reading data header from FD. n=%d msglen=%d ERR=%s\n"),
n, qfd->msglen, fd->bstrerror());
// ASX TODO the fd->bstrerror() can be related to the wrong error, I should Queue the error too
possible_incomplete_job(jcr, last_file_index);
ok = false;
break;
}
if (sscanf(qfd->msg, "%ld %ld %lld", &file_index, &stream, &stream_len) != 3) {
// TODO ASX already done in bufmsg, should reuse the values
char buf[256];
Jmsg1(jcr, M_FATAL, 0, _("Malformed data header from FD: %s\n"), asciidump(qfd->msg, qfd->msglen, buf, sizeof(buf)));
ok = false;
possible_incomplete_job(jcr, last_file_index);
break;
}
Dmsg3(890, "<filed: Header FilInx=%d stream=%d stream_len=%lld\n",
file_index, stream, stream_len);
/*
* 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;
}
Dmsg2(400, "file_index=%d last_file_index=%d\n", file_index, last_file_index);
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 last_FI=%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=qfd->bget_msg(NULL)) > 0 && !jcr->is_job_canceled()) {
rec.VolSessionId = jcr->VolSessionId;
rec.VolSessionTime = jcr->VolSessionTime;
rec.FileIndex = file_index;
rec.Stream = stream;
rec.StreamLen = stream_len;
rec.maskedStream = stream & STREAMMASK_TYPE; /* strip high bits */
rec.data_len = qfd->msglen;
rec.data = qfd->msg; /* use message buffer */
Dmsg4(850, "before writ_rec FI=%d SessId=%d Strm=%s len=%d\n",
rec.FileIndex, rec.VolSessionId,
stream_to_ascii(buf1, rec.Stream,rec.FileIndex),
rec.data_len);
ok = dcr->write_record(&rec);
if (!ok) {
Dmsg2(90, "Got write_block_to_dev error on device %s. %s\n",
dcr->dev->print_name(), dcr->dev->bstrerror());
break;
}
jcr->JobBytes += rec.data_len; /* increment bytes this job */
jcr->JobBytes += qfd->bmsg->jobbytes; // if the block as been downloaded, count it
Dmsg4(850, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
send_attrs_to_dir(jcr, &rec);
Dmsg0(650, "Enter bnet_get\n");
}
Dmsg2(650, "End read loop with FD. JobFiles=%d Stat=%d\n", jcr->JobFiles, n);
if (fd->is_error()) {
if (!jcr->is_job_canceled()) {
Dmsg1(350, "Network read error from FD. ERR=%s\n", fd->bstrerror());
Jmsg1(jcr, M_FATAL, 0, _("Network error reading from FD. ERR=%s\n"),
fd->bstrerror());
possible_incomplete_job(jcr, last_file_index);
}
ok = false;
break;
}
}
qfd->wait_read_sock();
free_GetMsg(qfd);
if (eblock != NULL) {
free_pool_memory(eblock);
}
/* Create Job status for end of session label */
jcr->setJobStatus(ok?JS_Terminated:JS_ErrorTerminated);
if (ok) {
/* Terminate connection with Client */
fd->fsend(OK_append);
do_client_commands(jcr); /* finish dialog with Client */
} else {
fd->fsend("3999 Failed append\n");
}
Dmsg1(200, "Write EOS label JobStatus=%c\n", jcr->JobStatus);
/*
* Check if we can still write. This may not be the case
* if we are at the end of the tape or we got a fatal I/O error.
*/
if (ok || dev->can_write()) {
if (!write_session_label(dcr, EOS_LABEL)) {
/* Print only if ok and not cancelled to avoid spurious messages */
if (ok && !jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Error writing end session label. ERR=%s\n"),
dev->bstrerror());
possible_incomplete_job(jcr, last_file_index);
}
jcr->setJobStatus(JS_ErrorTerminated);
ok = false;
}
/* Flush out final partial block of this session */
if (!dcr->write_final_block_to_device()) {
/* Print only if ok and not cancelled to avoid spurious messages */
if (ok && !jcr->is_job_canceled()) {
Jmsg2(jcr, M_FATAL, 0, _("Fatal append error on device %s: ERR=%s\n"),
dev->print_name(), dev->bstrerror());
Dmsg0(100, _("Set ok=FALSE after write_final_block_to_device.\n"));
possible_incomplete_job(jcr, last_file_index);
}
jcr->setJobStatus(JS_ErrorTerminated);
ok = false;
}
}
flush_jobmedia_queue(jcr);
if (!ok && !jcr->is_JobStatus(JS_Incomplete)) {
discard_data_spool(dcr);
} else {
/* Note: if commit is OK, the device will remain blocked */
commit_data_spool(dcr);
}
/*
* Don't use time_t for job_elapsed as time_t can be 32 or 64 bits,
* and the subsequent Jmsg() editing will break
*/
int32_t job_elapsed = time(NULL) - jcr->run_time;
if (job_elapsed <= 0) {
job_elapsed = 1;
}
Jmsg(dcr->jcr, M_INFO, 0, _("Elapsed time=%02d:%02d:%02d, Transfer rate=%s Bytes/second\n"),
job_elapsed / 3600, job_elapsed % 3600 / 60, job_elapsed % 60,
edit_uint64_with_suffix(jcr->JobBytes / job_elapsed, ec));
/*
* Release the device -- and send final Vol info to DIR
* and unlock it.
*/
release_device(dcr);
if ((!ok || jcr->is_job_canceled()) && !jcr->is_JobStatus(JS_Incomplete)) {
discard_attribute_spool(jcr);
} else {
commit_attribute_spool(jcr);
}
jcr->sendJobStatus(); /* update director */
Dmsg1(100, "return from do_append_data() ok=%d\n", ok);
return ok;
}
