/*
* Read Data and send to File Daemon
*
* Returns: false on failure
* true on success
*/
bool do_read_data(JCR *jcr)
{
BSOCK *fd = jcr->file_bsock;
DCR *dcr = jcr->read_dcr;
bool ok = true;
Dmsg0(20, "Start read data.\n");
if (!bnet_set_buffer_size(fd, dcr->device->max_network_buffer_size, BNET_SETBUF_WRITE)) {
return false;
}
if (jcr->NumReadVolumes == 0) {
Jmsg(jcr, M_FATAL, 0, _("No Volume names found for restore.\n"));
fd->fsend(FD_error);
return false;
}
Dmsg2(200, "Found %d volumes names to restore. First=%s\n",
jcr->NumReadVolumes, jcr->VolList->VolumeName);
/*
* Ready device for reading
*/
if (!acquire_device_for_read(dcr)) {
fd->fsend(FD_error);
return false;
}
/*
* Let any SD plugin know now its time to setup the record translation infra.
*/
if (generate_plugin_event(jcr, bsdEventSetupRecordTranslation, dcr) != bRC_OK) {
jcr->setJobStatus(JS_ErrorTerminated);
return false;
}
/*
* Tell File daemon we will send data
*/
fd->fsend(OK_data);
jcr->sendJobStatus(JS_Running);
ok = read_records(dcr, record_cb, mount_next_read_volume);
/*
* Send end of data to FD
*/
fd->signal(BNET_EOD);
if (!release_device(jcr->read_dcr)) {
ok = false;
}
Dmsg0(30, "Done reading.\n");
return ok;
}
/*
* Read Data and send to File Daemon
* Returns: false on failure
* true on success
*/
bool do_read_data(JCR *jcr)
{
BSOCK *fd = jcr->file_bsock;
bool ok = true;
DCR *dcr = jcr->read_dcr;
Dmsg0(20, "Start read data.\n");
if (!bnet_set_buffer_size(fd, dcr->device->max_network_buffer_size, BNET_SETBUF_WRITE)) {
return false;
}
if (jcr->NumReadVolumes == 0) {
Jmsg(jcr, M_FATAL, 0, _("No Volume names found for restore.\n"));
fd->fsend(FD_error);
return false;
}
Dmsg2(200, "Found %d volumes names to restore. First=%s\n", jcr->NumReadVolumes,
jcr->VolList->VolumeName);
/* Ready device for reading */
if (!acquire_device_for_read(dcr)) {
fd->fsend(FD_error);
return false;
}
/* Tell File daemon we will send data */
fd->fsend(OK_data);
jcr->sendJobStatus(JS_Running);
ok = read_records(dcr, record_cb, mount_next_read_volume);
/* Send end of data to FD */
fd->signal(BNET_EOD);
if (!release_device(jcr->read_dcr)) {
ok = false;
}
Dmsg0(30, "Done reading.\n");
return ok;
}
/* Do an ls type listing of an archive */
static void do_ls(char *infname)
{
if (dump_label) {
dump_volume_label(dev);
return;
}
read_records(dcr, record_cb, mount_next_read_volume);
printf("%u files found.\n", num_files);
}
static void do_extract(char *devname)
{
struct stat statp;
enable_backup_privileges(NULL, 1);
jcr = setup_jcr("bextract", devname, bsr, director, VolumeName, 1); /* acquire for read */
if (!jcr) {
exit(1);
}
dev = jcr->read_dcr->dev;
if (!dev) {
exit(1);
}
dcr = jcr->read_dcr;
/* Make sure where directory exists and that it is a directory */
if (stat(where, &statp) < 0) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Cannot stat %s. It must exist. ERR=%s\n"),
where, be.bstrerror());
}
if (!S_ISDIR(statp.st_mode)) {
Emsg1(M_ERROR_TERM, 0, _("%s must be a directory.\n"), where);
}
free(jcr->where);
jcr->where = bstrdup(where);
attr = new_attr(jcr);
compress_buf = get_memory(compress_buf_size);
acl_data.last_fname = get_pool_memory(PM_FNAME);
xattr_data.last_fname = get_pool_memory(PM_FNAME);
read_records(dcr, record_cb, mount_next_read_volume);
/* If output file is still open, it was the last one in the
* archive since we just hit an end of file, so close the file.
*/
if (is_bopen(&bfd)) {
set_attributes(jcr, attr, &bfd);
}
free_attr(attr);
free_pool_memory(acl_data.last_fname);
free_pool_memory(xattr_data.last_fname);
clean_device(jcr->dcr);
dev->term();
free_dcr(dcr);
free_jcr(jcr);
printf(_("%u files restored.\n"), num_files);
return;
}
// Performs a single read iteration. Returns the number of records read.
static int perform_read_iteration(size_t record_size) {
const void* read_buffer = NULL;
size_t bytes_available;
int records_read = 0;
census_log_init_reader();
while ((read_buffer = census_log_read_next(&bytes_available))) {
int num_records = 0;
read_records(record_size, (const char*)read_buffer, bytes_available,
&num_records);
records_read += num_records;
}
return records_read;
}
/* Read records from a file:
-- currently assumes 'biblio.bib' is in current directory
-- TODO: make this user definable somehow
and sets up a new recdata instance.
Returns NULL if failed to load records.
*/
struct rec_data * recdata_create (void) {
FILE * fp;
struct rec_data * rd = malloc (sizeof(struct recdata));
fp = fopen("biblio.bib", "r");
if (fp == NULL) { /* file not found */
rd = NULL;
} else {
rd->all = read_records (fp);
fclose (fp);
rd->current = rd->all; /* current record is first of loaded records */
rd->found = NULL; /* initial list of found records to NULL */
recdata_initialise_stats (rd);
}
return rd;
}
/* Do list job records */
static void do_jobs(char *infname)
{
read_records(dcr, jobs_cb, mount_next_read_volume);
}
int process_args(int argc, char *argv[], char batch_mode)
{
int c;
char mode = 0;
char time_ok = 0;
char room = 0;
char *filename;
record *rec = calloc(1, sizeof(record));
record *first = NULL;
record *last = NULL;
EVP_CIPHER_CTX en_ctx, de_ctx;
optind = 0;
opterr = 0;
while ((c = getopt(argc, argv, ":T:K:E:G:ALR:B:")) != -1)
switch (c)
{
case 'T':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (strtoi(optarg, &(rec->timestamp)) || !rec->timestamp)
return print_error(ARG_ERROR);
time_ok = 1;
break;
case 'K':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (!is_token_valid(optarg))
return print_error(ARG_ERROR);
rec->token = optarg;
break;
case 'E':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (rec->ptype == GUEST)
return print_error(ARG_ERROR);
rec->ptype = EMPLOYEE;
if (!is_name_valid(optarg))
return print_error(ARG_ERROR);
rec->name = optarg;
break;
case 'G':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (rec->ptype == EMPLOYEE)
return print_error(ARG_ERROR);
rec->ptype = GUEST;
if (!is_name_valid(optarg))
return print_error(ARG_ERROR);
rec->name = optarg;
break;
case 'A':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (rec->etype == DEPARTURE)
return print_error(ARG_ERROR);
rec->etype = ARRIVAL;
break;
case 'L':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (rec->etype == ARRIVAL)
return print_error(ARG_ERROR);
rec->etype = DEPARTURE;
break;
case 'R':
if (mode == BATCH_MODE)
return print_error(ARG_ERROR);
mode = DEFAULT_MODE;
if (strtoi(optarg, &(rec->room_id)))
return print_error(ARG_ERROR);
room = 1;
break;
case 'B':
if (mode == DEFAULT_MODE || batch_mode)
return print_error(ARG_ERROR);
mode = BATCH_MODE;
filename = optarg;
break;
default:
return print_error(ARG_ERROR);
}
if (mode == BATCH_MODE)
{
free(rec);
if (batch(filename))
return print_error(ARG_ERROR);
return NO_ERROR;
}
//Checa opcoes mandatorias
if (mode != DEFAULT_MODE || !time_ok || rec->token == NULL || rec->name == NULL
|| rec->etype == UNDEF_E || optind >= argc)
return print_error(ARG_ERROR);
//Ajusta o evento de acordo com a presenca de sala
if (!room)
{
if (rec->etype == ARRIVAL)
rec->etype = G_ARRIVAL;
else
rec->etype = G_DEPARTURE;
}
//Inicia contextos de seguranca
if ((aes_init((unsigned char *) rec->token, strlen(rec->token), &en_ctx, &de_ctx)))
return print_error(ARG_ERROR);
//validacoes de consistencia
c = read_records(&first, argv[optind], &last, &de_ctx);
if (c)
{
EVP_CIPHER_CTX_cleanup(&en_ctx);
EVP_CIPHER_CTX_cleanup(&de_ctx);
return c;
}
if ((c = check_record(first, rec)))
{
del_records(&first);
free(rec);
EVP_CIPHER_CTX_cleanup(&en_ctx);
EVP_CIPHER_CTX_cleanup(&de_ctx);
return print_error(ARG_ERROR);
}
if (!first)
first = rec;
else
{
if (!last)
last = first;
last->next = rec;
}
write_record(first, argv[optind], &en_ctx);
//TODO em batch, esses registros poderiam ser mantidos para evitar reler o arquivo.
if (first != rec)
{
last->next = NULL;
del_records(&first);
}
free(rec);
EVP_CIPHER_CTX_cleanup(&en_ctx);
EVP_CIPHER_CTX_cleanup(&de_ctx);
return NO_ERROR;
}
int main (int argc, char *argv[])
{
int ch;
char *iVolumeName = NULL;
char *oVolumeName = NULL;
bool ignore_label_errors = false;
bool ok;
setlocale(LC_ALL, "");
bindtextdomain("bacula", LOCALEDIR);
textdomain("bacula");
init_stack_dump();
my_name_is(argc, argv, "bcopy");
init_msg(NULL, NULL);
while ((ch = getopt(argc, argv, "b:c:d:i:o:pvw:?")) != -1) {
switch (ch) {
case 'b':
bsr = parse_bsr(NULL, optarg);
break;
case 'c': /* specify config 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 'i': /* input Volume name */
iVolumeName = optarg;
break;
case 'o': /* output Volume name */
oVolumeName = optarg;
break;
case 'p':
ignore_label_errors = true;
forge_on = true;
break;
case 'v':
verbose++;
break;
case 'w':
wd = optarg;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 2) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
OSDependentInit();
working_directory = wd;
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
config = new_config_parser();
parse_sd_config(config, configfile, M_ERROR_TERM);
/* Setup and acquire input device for reading */
Dmsg0(100, "About to setup input jcr\n");
in_jcr = setup_jcr("bcopy", argv[0], bsr, iVolumeName, 1); /* read device */
if (!in_jcr) {
exit(1);
}
in_jcr->ignore_label_errors = ignore_label_errors;
in_dev = in_jcr->dcr->dev;
if (!in_dev) {
exit(1);
}
/* Setup output device for writing */
Dmsg0(100, "About to setup output jcr\n");
out_jcr = setup_jcr("bcopy", argv[1], bsr, oVolumeName, 0); /* no acquire */
if (!out_jcr) {
exit(1);
}
out_dev = out_jcr->dcr->dev;
if (!out_dev) {
exit(1);
}
Dmsg0(100, "About to acquire device for writing\n");
/* For we must now acquire the device for writing */
out_dev->r_dlock();
if (out_dev->open(out_jcr->dcr, OPEN_READ_WRITE) < 0) {
Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), out_dev->errmsg);
out_dev->dunlock();
exit(1);
}
out_dev->dunlock();
if (!acquire_device_for_append(out_jcr->dcr)) {
free_jcr(in_jcr);
exit(1);
}
out_block = out_jcr->dcr->block;
ok = read_records(in_jcr->dcr, record_cb, mount_next_read_volume);
if (ok || out_dev->can_write()) {
if (!write_block_to_device(out_jcr->dcr)) {
Pmsg0(000, _("Write of last block failed.\n"));
}
}
Pmsg2(000, _("%u Jobs copied. %u records copied.\n"), jobs, records);
free_jcr(in_jcr);
free_jcr(out_jcr);
in_dev->term();
out_dev->term();
return 0;
}
/*
* Read Data and commit to new job.
*/
bool do_mac_run(JCR *jcr)
{
DEVICE *dev;
char ec1[50];
const char *Type;
bool ok = true;
BSOCK *dir = jcr->dir_bsock;
switch(jcr->getJobType()) {
case JT_MIGRATE:
Type = "Migration";
break;
case JT_ARCHIVE:
Type = "Archive";
break;
case JT_COPY:
Type = "Copy";
break;
case JT_BACKUP:
Type = "Virtual Backup";
break;
default:
Type = "Unknown";
break;
}
Dmsg0(20, "Start read data.\n");
if (jcr->NumReadVolumes == 0) {
Jmsg(jcr, M_FATAL, 0, _("No Volume names found for %s.\n"), Type);
goto bail_out;
}
/*
* Check autoinflation/autodeflation settings.
*/
check_auto_xflation(jcr);
/*
* See if we perform both read and write or read only.
*/
if (jcr->remote_replicate) {
BSOCK *sd;
if (!jcr->read_dcr) {
Jmsg(jcr, M_FATAL, 0, _("Read device not properly initialized.\n"));
goto bail_out;
}
Dmsg1(100, "read_dcr=%p\n", jcr->read_dcr);
Dmsg3(200, "Found %d volumes names for %s. First=%s\n",
jcr->NumReadVolumes, Type, jcr->VolList->VolumeName);
/*
* Ready devices for reading.
*/
if (!acquire_device_for_read(jcr->read_dcr)) {
ok = false;
goto bail_out;
}
Dmsg2(200, "===== After acquire pos %u:%u\n", jcr->read_dcr->dev->file, jcr->read_dcr->dev->block_num);
jcr->sendJobStatus(JS_Running);
/*
* Set network buffering.
*/
sd = jcr->store_bsock;
if (!sd->set_buffer_size(me->max_network_buffer_size, BNET_SETBUF_WRITE)) {
Jmsg(jcr, M_FATAL, 0, _("Cannot set buffer size SD->SD.\n"));
ok = false;
goto bail_out;
}
/*
* Let the remote SD know we are about to start the replication.
*/
sd->fsend(start_replicate);
Dmsg1(110, ">stored: %s", sd->msg);
/*
* Expect to receive back the Ticket number.
*/
if (bget_msg(sd) >= 0) {
Dmsg1(110, "<stored: %s", sd->msg);
if (sscanf(sd->msg, OK_start_replicate, &jcr->Ticket) != 1) {
Jmsg(jcr, M_FATAL, 0, _("Bad response to start replicate: %s\n"), sd->msg);
goto bail_out;
}
Dmsg1(110, "Got Ticket=%d\n", jcr->Ticket);
} else {
Jmsg(jcr, M_FATAL, 0, _("Bad response from stored to start replicate command\n"));
goto bail_out;
}
/*
* Let the remote SD know we are now really going to send the data.
*/
sd->fsend(replicate_data, jcr->Ticket);
Dmsg1(110, ">stored: %s", sd->msg);
/*
* Expect to get response to the replicate data cmd from Storage daemon
*/
if (!response(jcr, sd, OK_data, "replicate data")) {
ok = false;
goto bail_out;
}
/*
* Read all data and send it to remote SD.
*/
ok = read_records(jcr->read_dcr, clone_record_to_remote_sd, mount_next_read_volume);
/*
* Send the last EOD to close the last data transfer and a next EOD to
* signal the remote we are done.
*/
if (!sd->signal(BNET_EOD) || !sd->signal(BNET_EOD)) {
if (!jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
}
goto bail_out;
}
/*
* Expect to get response that the replicate data succeeded.
*/
if (!response(jcr, sd, OK_replicate, "replicate data")) {
ok = false;
goto bail_out;
}
/*
* End replicate session.
*/
sd->fsend(end_replicate);
Dmsg1(110, ">stored: %s", sd->msg);
/*
* Expect to get response to the end replicate cmd from Storage daemon
*/
if (!response(jcr, sd, OK_end_replicate, "end replicate")) {
ok = false;
goto bail_out;
}
/* Inform Storage daemon that we are done */
sd->signal(BNET_TERMINATE);
} else {
if (!jcr->read_dcr || !jcr->dcr) {
Jmsg(jcr, M_FATAL, 0, _("Read and write devices not properly initialized.\n"));
goto bail_out;
}
Dmsg2(100, "read_dcr=%p write_dcr=%p\n", jcr->read_dcr, jcr->dcr);
Dmsg3(200, "Found %d volumes names for %s. First=%s\n",
jcr->NumReadVolumes, Type, jcr->VolList->VolumeName);
/*
* Ready devices for reading and writing.
*/
if (!acquire_device_for_read(jcr->read_dcr) ||
!acquire_device_for_append(jcr->dcr)) {
ok = false;
goto bail_out;
}
Dmsg2(200, "===== After acquire pos %u:%u\n", jcr->dcr->dev->file, jcr->dcr->dev->block_num);
jcr->sendJobStatus(JS_Running);
if (!begin_data_spool(jcr->dcr) ) {
ok = false;
goto bail_out;
}
if (!begin_attribute_spool(jcr)) {
ok = false;
goto bail_out;
}
jcr->dcr->VolFirstIndex = jcr->dcr->VolLastIndex = 0;
jcr->run_time = time(NULL);
set_start_vol_position(jcr->dcr);
jcr->JobFiles = 0;
/*
* Read all data and make a local clone of it.
*/
ok = read_records(jcr->read_dcr, clone_record_internally, mount_next_read_volume);
}
bail_out:
if (!ok) {
jcr->setJobStatus(JS_ErrorTerminated);
}
if (!jcr->remote_replicate && jcr->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;
dev = jcr->dcr->dev;
Dmsg1(100, "ok=%d\n", ok);
if (ok || dev->can_write()) {
/*
* Flush out final partial block of this session
*/
if (!jcr->dcr->write_block_to_device()) {
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"));
ok = false;
}
Dmsg2(200, "Flush block to device pos %u:%u\n", dev->file, dev->block_num);
}
if (!ok) {
discard_data_spool(jcr->dcr);
} else {
/*
* Note: if commit is OK, the device will remain blocked
*/
commit_data_spool(jcr->dcr);
}
job_elapsed = time(NULL) - jcr->run_time;
if (job_elapsed <= 0) {
job_elapsed = 1;
}
Jmsg(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, ec1));
/*
* Release the device -- and send final Vol info to DIR
*/
release_device(jcr->dcr);
if (!ok || job_canceled(jcr)) {
discard_attribute_spool(jcr);
} else {
commit_attribute_spool(jcr);
}
}
if (jcr->read_dcr) {
if (!release_device(jcr->read_dcr)) {
ok = false;
}
}
jcr->sendJobStatus(); /* update director */
Dmsg0(30, "Done reading.\n");
jcr->end_time = time(NULL);
dequeue_messages(jcr); /* send any queued messages */
if (ok) {
jcr->setJobStatus(JS_Terminated);
}
generate_plugin_event(jcr, bsdEventJobEnd);
dir->fsend(Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles,
edit_uint64(jcr->JobBytes, ec1), jcr->JobErrors);
Dmsg4(100, Job_end, jcr->Job, jcr->JobStatus, jcr->JobFiles, ec1);
dir->signal(BNET_EOD); /* send EOD to Director daemon */
free_plugins(jcr); /* release instantiated plugins */
return false; /* Continue DIR session ? */
}
int main(int argc, const char *argv[])
{
long nrecords = 0; /* # of records to read */
int poll_time = 1; /* # of seconds to sleep when waiting for writer */
int reopen_count = 1; /* # of reads between reopens */
unsigned verbose = 1; /* Whether to emit some informational messages */
unsigned u; /* Local index variables */
/* Parse command line options */
if(argc < 2)
usage();
if(argc > 1) {
u = 1;
while(u < (unsigned)argc) {
if(argv[u][0] == '-') {
switch(argv[u][1]) {
/* # of reads between reopens */
case 'n':
reopen_count = HDatoi(argv[u + 1]);
if(reopen_count < 0)
usage();
u += 2;
break;
/* Be quiet */
case 'q':
verbose = 0;
u++;
break;
/* # of seconds between polling */
case 's':
poll_time = HDatoi(argv[u + 1]);
if(poll_time < 0)
usage();
u += 2;
break;
default:
usage();
break;
} /* end switch */
} /* end if */
else {
/* Get the number of records to read */
nrecords = HDatol(argv[u]);
if(nrecords <= 0)
usage();
u++;
} /* end else */
} /* end while */
} /* end if */
/* Emit informational message */
if(verbose) {
HDfprintf(stderr, "Parameters:\n");
HDfprintf(stderr, "\t# of seconds between polling = %d\n", poll_time);
HDfprintf(stderr, "\t# of reads between reopens = %d\n", reopen_count);
HDfprintf(stderr, "\t# of records to read = %ld\n", nrecords);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Generating symbol names\n");
/* Generate dataset names */
if(generate_symbols() < 0) {
HDfprintf(stderr, "Error generating symbol names!\n");
HDexit(1);
} /* end if */
/* Create datatype for creating datasets */
if((symbol_tid = create_symbol_datatype()) < 0)
return -1;
/* Reading records from datasets */
if(read_records(FILENAME, verbose, (unsigned long) nrecords, (unsigned)poll_time, (unsigned)reopen_count) < 0) {
HDfprintf(stderr, "Error reading records from datasets!\n");
HDexit(1);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Releasing symbols\n");
/* Clean up the symbols */
if(shutdown_symbols() < 0) {
HDfprintf(stderr, "Error releasing symbols!\n");
HDexit(1);
} /* end if */
/* Emit informational message */
if(verbose)
HDfprintf(stderr, "Closing objects\n");
/* Close objects created */
if(H5Tclose(symbol_tid) < 0) {
HDfprintf(stderr, "Error closing symbol datatype!\n");
HDexit(1);
} /* end if */
return 0;
}
int main (int argc, char *argv[])
{
int ch;
bool ok;
char *iVolumeName = NULL;
char *oVolumeName = NULL;
char *DirectorName = NULL;
DIRRES *director = NULL;
bool ignore_label_errors = false;
DCR *in_dcr, *out_dcr;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
my_name_is(argc, argv, "bcopy");
lmgr_init_thread();
init_msg(NULL, NULL);
while ((ch = getopt(argc, argv, "b:c:D:d:i:o:pvw:?")) != -1) {
switch (ch) {
case 'b':
bsr = parse_bsr(NULL, optarg);
break;
case 'c': /* specify config file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'D': /* specify director name */
if (DirectorName != NULL) {
free(DirectorName);
}
DirectorName = 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 'i': /* input Volume name */
iVolumeName = optarg;
break;
case 'o': /* output Volume name */
oVolumeName = optarg;
break;
case 'p':
ignore_label_errors = true;
forge_on = true;
break;
case 'v':
verbose++;
break;
case 'w':
wd = optarg;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 2) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
OSDependentInit();
working_directory = wd;
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
if (DirectorName) {
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, DirectorName)) {
break;
}
}
if (!director) {
Emsg2(M_ERROR_TERM, 0, _("No Director resource named %s defined in %s. Cannot continue.\n"),
DirectorName, configfile);
}
}
load_sd_plugins(me->plugin_directory, me->plugin_names);
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
/*
* Setup and acquire input device for reading
*/
Dmsg0(100, "About to setup input jcr\n");
in_dcr = New(DCR);
in_jcr = setup_jcr("bcopy", argv[0], bsr, director, in_dcr, iVolumeName, true); /* read device */
if (!in_jcr) {
exit(1);
}
in_jcr->ignore_label_errors = ignore_label_errors;
in_dev = in_jcr->dcr->dev;
if (!in_dev) {
exit(1);
}
/*
* Setup output device for writing
*/
Dmsg0(100, "About to setup output jcr\n");
out_dcr = New(DCR);
out_jcr = setup_jcr("bcopy", argv[1], bsr, director, out_dcr, oVolumeName, false); /* write device */
if (!out_jcr) {
exit(1);
}
out_dev = out_jcr->dcr->dev;
if (!out_dev) {
exit(1);
}
Dmsg0(100, "About to acquire device for writing\n");
/*
* For we must now acquire the device for writing
*/
out_dev->rLock(false);
if (!out_dev->open(out_jcr->dcr, OPEN_READ_WRITE)) {
Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), out_dev->errmsg);
out_dev->Unlock();
exit(1);
}
out_dev->Unlock();
if (!acquire_device_for_append(out_jcr->dcr)) {
free_jcr(in_jcr);
exit(1);
}
out_block = out_jcr->dcr->block;
ok = read_records(in_jcr->dcr, record_cb, mount_next_read_volume);
if (ok || out_dev->can_write()) {
if (!out_jcr->dcr->write_block_to_device()) {
Pmsg0(000, _("Write of last block failed.\n"));
}
}
Pmsg2(000, _("%u Jobs copied. %u records copied.\n"), jobs, records);
in_dev->term();
out_dev->term();
free_jcr(in_jcr);
free_jcr(out_jcr);
return 0;
}
