static inline ssize_t write_data_to_block(DEV_BLOCK *block, const DEV_RECORD *rec)
{
uint32_t len;
len = MIN(rec->remainder, block_write_navail(block));
memcpy(block->bufp,
((unsigned char *)rec->data) + (rec->data_len - rec->remainder),
len);
block->bufp += len;
block->binbuf += len;
#ifdef xxxxxSMCHECK
if (!sm_check_rtn(__FILE__, __LINE__, False)) {
/*
* We damaged a buffer
*/
Dmsg7(0, "Damaged block FI=%s SessId=%d Strm=%s datalen=%d\n"
"len=%d rem=%d remainder=%d\n",
FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex),
rec->data_len, len, block_write_navail(block),
rec->remainder);
Dmsg5(0, "Damaged block: bufp=%x binbuf=%d buf_len=%d rem=%d moved=%d\n",
block->bufp, block->binbuf, block->buf_len,
block_write_navail(block), len);
Dmsg2(0, "Damaged block: buf=%x binbuffrombuf=%d \n",
block->buf, block->bufp-block->buf);
Emsg0(M_ABORT, 0, _("Damaged buffer\n"));
}
#endif
return len;
}
static void get_session_record(DEVICE *dev, DEV_RECORD *rec, SESSION_LABEL *sessrec)
{
const char *rtype;
memset(sessrec, 0, sizeof(sessrec));
switch (rec->FileIndex) {
case PRE_LABEL:
rtype = _("Fresh Volume Label");
break;
case VOL_LABEL:
rtype = _("Volume Label");
unser_volume_label(dev, rec);
break;
case SOS_LABEL:
rtype = _("Begin Job Session");
unser_session_label(sessrec, rec);
break;
case EOS_LABEL:
rtype = _("End Job Session");
break;
case 0:
case EOM_LABEL:
rtype = _("End of Medium");
break;
default:
rtype = _("Unknown");
break;
}
Dmsg5(10, "%s Record: VolSessionId=%d VolSessionTime=%d JobId=%d DataLen=%d\n",
rtype, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
if (verbose) {
Pmsg5(-1, _("%s Record: VolSessionId=%d VolSessionTime=%d JobId=%d DataLen=%d\n"),
rtype, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
}
}
/*
* Given a string "str", separate the numeric part into
* str, and the modifier into mod.
*/
static bool get_modifier(char *str, char *num, int num_len, char *mod, int mod_len)
{
int i, len, num_begin, num_end, mod_begin, mod_end;
strip_trailing_junk(str);
len = strlen(str);
for (i=0; i<len; i++) {
if (!B_ISSPACE(str[i])) {
break;
}
}
num_begin = i;
/* Walk through integer part */
for ( ; i<len; i++) {
if (!B_ISDIGIT(str[i]) && str[i] != '.') {
break;
}
}
num_end = i;
if (num_len > (num_end - num_begin + 1)) {
num_len = num_end - num_begin + 1;
}
if (num_len == 0) {
return false;
}
/* Eat any spaces in front of modifier */
for ( ; i<len; i++) {
if (!B_ISSPACE(str[i])) {
break;
}
}
mod_begin = i;
for ( ; i<len; i++) {
if (!B_ISALPHA(str[i])) {
break;
}
}
mod_end = i;
if (mod_len > (mod_end - mod_begin + 1)) {
mod_len = mod_end - mod_begin + 1;
}
Dmsg5(900, "str=%s: num_beg=%d num_end=%d mod_beg=%d mod_end=%d\n",
str, num_begin, num_end, mod_begin, mod_end);
bstrncpy(num, &str[num_begin], num_len);
bstrncpy(mod, &str[mod_begin], mod_len);
if (!is_a_number(num)) {
return false;
}
bstrncpy(str, &str[mod_end], len);
Dmsg2(900, "num=%s mod=%s\n", num, mod);
return true;
}
/*
* Store a resource pointer in an alist. default_value indicates how many
* times this routine can be called -- i.e. how many alists
* there are.
*
* If we are in pass 2, do a lookup of the resource.
*/
static void store_alist_res(LEX *lc, RES_ITEM *item, int index, int pass)
{
RES *res;
int i = 0;
alist *list;
URES *res_all = (URES *)my_config->m_res_all;
int count = str_to_int32(item->default_value);
if (pass == 2) {
if (count == 0) { /* always store in item->value */
i = 0;
if ((item->value)[i] == NULL) {
list = New(alist(10, not_owned_by_alist));
} else {
list = (alist *)(item->value)[i];
}
} else {
/*
* Find empty place to store this directive
*/
while ((item->value)[i] != NULL && i++ < count) { }
if (i >= count) {
scan_err4(lc, _("Too many %s directives. Max. is %d. line %d: %s\n"),
lc->str, count, lc->line_no, lc->line);
return;
}
list = New(alist(10, not_owned_by_alist));
}
for (;;) {
lex_get_token(lc, T_NAME); /* scan next item */
res = GetResWithName(item->code, lc->str);
if (res == NULL) {
scan_err3(lc, _("Could not find config Resource \"%s\" referenced on line %d : %s\n"),
item->name, lc->line_no, lc->line);
return;
}
Dmsg5(900, "Append %p to alist %p size=%d i=%d %s\n",
res, list, list->size(), i, item->name);
list->append(res);
(item->value)[i] = (char *)list;
if (lc->ch != ',') { /* if no other item follows */
break; /* get out */
}
lex_get_token(lc, T_ALL); /* eat comma */
}
}
scan_to_eol(lc);
set_bit(index, res_all->hdr.item_present);
}
/*
* Called here for each record from read_records()
*
* Returns: true if OK
* false if error
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
JCR *jcr = dcr->jcr;
BSOCK *fd = jcr->file_bsock;
bool ok = true;
POOLMEM *save_msg;
char ec1[50], ec2[50];
if (rec->FileIndex < 0) {
return true;
}
Dmsg5(400, "Send to FD: SessId=%u SessTim=%u FI=%s Strm=%s, len=%d\n",
rec->VolSessionId, rec->VolSessionTime,
FI_to_ascii(ec1, rec->FileIndex),
stream_to_ascii(ec2, rec->Stream, rec->FileIndex),
rec->data_len);
/*
* Send record header to File daemon
*/
if (!fd->fsend(rec_header, rec->VolSessionId, rec->VolSessionTime,
rec->FileIndex, rec->Stream, rec->data_len)) {
Pmsg1(000, _(">filed: Error Hdr=%s"), fd->msg);
Jmsg1(jcr, M_FATAL, 0, _("Error sending to File daemon. ERR=%s\n"),
fd->bstrerror());
return false;
} else {
Dmsg1(400, ">filed: Hdr=%s", fd->msg);
}
/*
* Send data record to File daemon
*/
save_msg = fd->msg; /* save fd message pointer */
fd->msg = rec->data; /* pass data directly to the FD */
fd->msglen = rec->data_len;
Dmsg1(400, ">filed: send %d bytes data.\n", fd->msglen);
if (!fd->send()) {
Pmsg1(000, _("Error sending to FD. ERR=%s\n"), fd->bstrerror());
Jmsg1(jcr, M_FATAL, 0, _("Error sending to File daemon. ERR=%s\n"),
fd->bstrerror());
ok = false;
}
fd->msg = save_msg; /* restore fd message pointer */
return ok;
}
/*
* (Un)mount the device (for tape devices)
*/
static bool do_mount(DCR *dcr, int mount, int dotimeout)
{
DEVRES *device = dcr->dev->device;
POOL_MEM ocmd(PM_FNAME);
POOLMEM *results;
char *icmd;
int status, tries;
berrno be;
Dsm_check(200);
if (mount) {
icmd = device->mount_command;
} else {
icmd = device->unmount_command;
}
dcr->dev->edit_mount_codes(ocmd, icmd);
Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), dcr->dev->is_mounted());
if (dotimeout) {
/* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
tries = 10;
} else {
tries = 1;
}
results = get_memory(4000);
/* If busy retry each second */
Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
while ((status = run_program_full_output(ocmd.c_str(), dcr->dev->max_open_wait / 2, results)) != 0) {
if (tries-- > 0) {
continue;
}
Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", dcr->dev->print_name(),
(mount ? "" : "un"), status, results, be.bstrerror(status));
Mmsg(dcr->dev->errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
dcr->dev->print_name(), (mount ? "" : "un"), be.bstrerror(status));
free_pool_memory(results);
Dmsg0(200, "============ mount=0\n");
Dsm_check(200);
return false;
}
free_pool_memory(results);
Dmsg1(200, "============ mount=%d\n", mount);
return true;
}
/*
* Read a Record from the block
* Returns: false if nothing read or if the continuation record does not match.
* In both of these cases, a block read must be done.
* true if at least the record header was read, this
* routine may have to be called again with a new
* block if the entire record was not read.
*/
bool read_record_from_block(DCR *dcr, DEV_RECORD *rec)
{
bool rtn;
Dmsg0(dbgep, "=== rpath 1 Enter read_record_from block\n");
for ( ;; ) {
switch (rec->rstate) {
case st_none:
dump_block(dcr->block, "st_none");
case st_header:
Dmsg0(dbgep, "=== rpath 33 st_header\n");
rec->remlen = dcr->block->binbuf;
/* Note read_header sets rec->rstate on return true */
if (!read_header(dcr, dcr->block, rec)) { /* sets state */
Dmsg0(dbgep, "=== rpath 34 failed read header\n");
Dmsg0(read_dbglvl, "read_header returned EOF.\n");
goto fail_out;
}
continue;
case st_data:
Dmsg0(dbgep, "=== rpath 37 st_data\n");
read_data(dcr->block, rec);
rec->rstate = st_header; /* next pass look for a header */
goto get_out;
default:
Dmsg0(dbgep, "=== rpath 50 default\n");
Dmsg0(0, "======= In default !!!!!\n");
Pmsg1(190, "Read: unknown state=%d\n", rec->rstate);
goto fail_out;
}
}
get_out:
char buf1[100], buf2[100];
Dmsg5(read_dbglvl, "read_rec return: FI=%s Strm=%s len=%d rem=%d remainder=%d\n",
FI_to_ascii(buf1, rec->FileIndex),
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
rec->remlen, rec->remainder);
rtn = true;
goto out;
fail_out:
rec->rstate = st_none;
rtn = false;
out:
return rtn;
}
static inline bool write_data_to_block(DEV_BLOCK *block, DEV_RECORD *rec)
{
rec->remlen = block->buf_len - block->binbuf;
/*
* Write as much of data as possible
*/
if (rec->remlen >= rec->remainder) {
memcpy(block->bufp, rec->data + (rec->data_len - rec->remainder), rec->remainder);
block->bufp += rec->remainder;
block->binbuf += rec->remainder;
} else {
memcpy(block->bufp, rec->data + (rec->data_len - rec->remainder), rec->remlen);
#ifdef xxxxxSMCHECK
if (!sm_check_rtn(__FILE__, __LINE__, False)) {
/*
* We damaged a buffer
*/
Dmsg6(0, "Damaged block FI=%s SessId=%d Strm=%s len=%d\n"
"rem=%d remainder=%d\n",
FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
rec->remlen, rec->remainder);
Dmsg5(0, "Damaged block: bufp=%x binbuf=%d buf_len=%d rem=%d moved=%d\n",
block->bufp, block->binbuf, block->buf_len, block->buf_len-block->binbuf,
rec->remlen);
Dmsg2(0, "Damaged block: buf=%x binbuffrombuf=%d \n",
block->buf, block->bufp-block->buf);
Emsg0(M_ABORT, 0, _("Damaged buffer\n"));
}
#endif
block->bufp += rec->remlen;
block->binbuf += rec->remlen;
rec->remainder -= rec->remlen;
return false; /* did partial transfer */
}
return true;
}
/*
* We have just read a header, now read the data into the record.
* Note, if we do not read the full record, we will return to
* read the next header, which will then come back here later
* to finish reading the full record.
*/
static void read_data(DEV_BLOCK *block, DEV_RECORD *rec)
{
char buf1[100], buf2[100];
Dmsg0(dbgep, "=== rpath 22 read_data\n");
/*
* At this point, we have read the header, now we
* must transfer as much of the data record as
* possible taking into account: 1. A partial
* data record may have previously been transferred,
* 2. The current block may not contain the whole data
* record.
*/
if (rec->remlen >= rec->data_bytes) {
Dmsg0(dbgep, "=== rpath 23 full record\n");
/* Got whole record */
memcpy(rec->data+rec->data_len, block->bufp, rec->data_bytes);
block->bufp += rec->data_bytes;
block->binbuf -= rec->data_bytes;
rec->data_len += rec->data_bytes;
rec->remainder = 0;
Dmsg5(190, "Rdata full FI=%s SessId=%d Strm=%s len=%d block=%p\n",
FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
block);
} else {
Dmsg0(dbgep, "=== rpath 24 partial record\n");
/* Partial record */
memcpy(rec->data+rec->data_len, block->bufp, rec->remlen);
block->bufp += rec->remlen;
block->binbuf -= rec->remlen;
rec->data_len += rec->remlen;
rec->remainder = 1; /* partial record transferred */
Dmsg1(read_dbglvl, "read_data: partial xfered=%d\n", rec->data_len);
rec->state_bits |= (REC_PARTIAL_RECORD | REC_BLOCK_EMPTY);
}
}
/*
* Open the first part file.
* - Close the fd
* - Reopen the device
*/
static bool dvd_open_first_part(DCR *dcr, int mode)
{
DEVICE *dev = dcr->dev;
Dmsg5(29, "Enter: ==== open_first_part dev=%s Vol=%s mode=%d num_dvd_parts=%d append=%d\n", dev->print_name(),
dev->getVolCatName(), dev->openmode, dev->num_dvd_parts, dev->can_append());
dev->close_part(dcr);
Dmsg2(400, "Call dev->open(vol=%s, mode=%d)\n", dcr->getVolCatName(),
mode);
Dmsg0(100, "Set part=1\n");
dev->part = 1;
dev->part_start = 0;
if (dev->open(dcr, mode) < 0) {
Dmsg0(400, "open dev() failed\n");
return false;
}
Dmsg2(400, "Leave open_first_part state=%s append=%d\n", dev->is_open()?"open":"not open", dev->can_append());
return true;
}
/*
* Note, we receive the whole attribute record, but we select out only the stat
* packet, VolSessionId, VolSessionTime, FileIndex, file type, and file name to
* store in the catalog.
*/
static void update_attribute(JCR *jcr, char *msg, int32_t msglen)
{
unser_declare;
uint32_t VolSessionId, VolSessionTime;
int32_t Stream;
uint32_t FileIndex;
char *p;
int len;
char *fname, *attr;
ATTR_DBR *ar = NULL;
uint32_t reclen;
/*
* Start transaction allocates jcr->attr and jcr->ar if needed
*/
db_start_transaction(jcr, jcr->db); /* start transaction if not already open */
ar = jcr->ar;
/*
* Start by scanning directly in the message buffer to get Stream
* there may be a cached attr so we cannot yet write into
* jcr->attr or jcr->ar
*/
p = msg;
skip_nonspaces(&p); /* UpdCat */
skip_spaces(&p);
skip_nonspaces(&p); /* Job=nnn */
skip_spaces(&p);
skip_nonspaces(&p); /* "FileAttributes" */
p += 1;
/*
* The following "SD header" fields are serialized
*/
unser_begin(p, 0);
unser_uint32(VolSessionId); /* VolSessionId */
unser_uint32(VolSessionTime); /* VolSessionTime */
unser_int32(FileIndex); /* FileIndex */
unser_int32(Stream); /* Stream */
unser_uint32(reclen); /* Record length */
p += unser_length(p); /* Raw record follows */
/**
* At this point p points to the raw record, which varies according
* to what kind of a record (Stream) was sent. Note, the integer
* fields at the beginning of these "raw" records are in ASCII with
* spaces between them so one can use scanf or manual scanning to
* extract the fields.
*
* File Attributes
* 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 (32 bit int)
*
* Restore Object
* File_index
* File_type
* Object_index
* Object_len (possibly compressed)
* Object_full_len (not compressed)
* Object_compression
* Plugin_name
* Object_name
* Binary Object data
*/
Dmsg1(400, "UpdCat msg=%s\n", msg);
Dmsg5(400, "UpdCat VolSessId=%d VolSessT=%d FI=%d Strm=%d reclen=%d\n",
VolSessionId, VolSessionTime, FileIndex, Stream, reclen);
jcr->SDJobBytes += reclen; /* update number of bytes transferred for quotas */
/*
* Depending on the stream we are handling dispatch.
*/
switch (Stream) {
case STREAM_UNIX_ATTRIBUTES:
case STREAM_UNIX_ATTRIBUTES_EX:
if (jcr->cached_attribute) {
Dmsg2(400, "Cached attr. Stream=%d fname=%s\n", ar->Stream, ar->fname);
if (!db_create_attributes_record(jcr, jcr->db, ar)) {
Jmsg1(jcr, M_FATAL, 0, _("Attribute create error: ERR=%s"), db_strerror(jcr->db));
}
jcr->cached_attribute = false;
}
/*
* Any cached attr is flushed so we can reuse jcr->attr and jcr->ar
*/
jcr->attr = check_pool_memory_size(jcr->attr, msglen);
memcpy(jcr->attr, msg, msglen);
p = jcr->attr - msg + p; /* point p into jcr->attr */
skip_nonspaces(&p); /* skip FileIndex */
skip_spaces(&p);
ar->FileType = str_to_int32(p);
skip_nonspaces(&p); /* skip FileType */
skip_spaces(&p);
fname = p;
len = strlen(fname); /* length before attributes */
attr = &fname[len+1];
ar->DeltaSeq = 0;
if (ar->FileType == FT_REG) {
p = attr + strlen(attr) + 1; /* point to link */
p = p + strlen(p) + 1; /* point to extended attributes */
p = p + strlen(p) + 1; /* point to delta sequence */
/*
* Older FDs don't have a delta sequence, so check if it is there
*/
if (p - jcr->attr < msglen) {
ar->DeltaSeq = str_to_int32(p); /* delta_seq */
}
}
Dmsg2(400, "dird<stored: stream=%d %s\n", Stream, fname);
Dmsg1(400, "dird<stored: attr=%s\n", attr);
ar->attr = attr;
ar->fname = fname;
if (ar->FileType == FT_DELETED) {
ar->FileIndex = 0; /* special value */
} else {
ar->FileIndex = FileIndex;
}
ar->Stream = Stream;
ar->link = NULL;
if (jcr->mig_jcr) {
ar->JobId = jcr->mig_jcr->JobId;
} else {
ar->JobId = jcr->JobId;
}
ar->Digest = NULL;
ar->DigestType = CRYPTO_DIGEST_NONE;
jcr->cached_attribute = true;
Dmsg2(400, "dird<filed: stream=%d %s\n", Stream, fname);
Dmsg1(400, "dird<filed: attr=%s\n", attr);
break;
case STREAM_RESTORE_OBJECT: {
ROBJECT_DBR ro;
memset(&ro, 0, sizeof(ro));
ro.Stream = Stream;
ro.FileIndex = FileIndex;
if (jcr->mig_jcr) {
ro.JobId = jcr->mig_jcr->JobId;
} else {
ro.JobId = jcr->JobId;
}
Dmsg1(100, "Robj=%s\n", p);
skip_nonspaces(&p); /* skip FileIndex */
skip_spaces(&p);
ro.FileType = str_to_int32(p); /* FileType */
skip_nonspaces(&p);
skip_spaces(&p);
ro.object_index = str_to_int32(p); /* Object Index */
skip_nonspaces(&p);
skip_spaces(&p);
ro.object_len = str_to_int32(p); /* object length possibly compressed */
skip_nonspaces(&p);
skip_spaces(&p);
ro.object_full_len = str_to_int32(p); /* uncompressed object length */
skip_nonspaces(&p);
skip_spaces(&p);
ro.object_compression = str_to_int32(p); /* compression */
skip_nonspaces(&p);
skip_spaces(&p);
ro.plugin_name = p; /* point to plugin name */
len = strlen(ro.plugin_name);
ro.object_name = &ro.plugin_name[len+1]; /* point to object name */
len = strlen(ro.object_name);
ro.object = &ro.object_name[len+1]; /* point to object */
ro.object[ro.object_len] = 0; /* add zero for those who attempt printing */
Dmsg7(100, "oname=%s stream=%d FT=%d FI=%d JobId=%d, obj_len=%d\nobj=\"%s\"\n",
ro.object_name, ro.Stream, ro.FileType, ro.FileIndex, ro.JobId,
ro.object_len, ro.object);
/*
* Store it.
*/
if (!db_create_restore_object_record(jcr, jcr->db, &ro)) {
Jmsg1(jcr, M_FATAL, 0, _("Restore object create error. %s"), db_strerror(jcr->db));
}
break;
}
default:
if (crypto_digest_stream_type(Stream) != CRYPTO_DIGEST_NONE) {
fname = p;
if (ar->FileIndex != FileIndex) {
Jmsg3(jcr, M_WARNING, 0, _("%s not same File=%d as attributes=%d\n"),
stream_to_ascii(Stream), FileIndex, ar->FileIndex);
} else {
/*
* Update digest in catalog
*/
char digestbuf[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
int len = 0;
int type = CRYPTO_DIGEST_NONE;
switch(Stream) {
case STREAM_MD5_DIGEST:
len = CRYPTO_DIGEST_MD5_SIZE;
type = CRYPTO_DIGEST_MD5;
break;
case STREAM_SHA1_DIGEST:
len = CRYPTO_DIGEST_SHA1_SIZE;
type = CRYPTO_DIGEST_SHA1;
break;
case STREAM_SHA256_DIGEST:
len = CRYPTO_DIGEST_SHA256_SIZE;
type = CRYPTO_DIGEST_SHA256;
break;
case STREAM_SHA512_DIGEST:
len = CRYPTO_DIGEST_SHA512_SIZE;
type = CRYPTO_DIGEST_SHA512;
break;
default:
/*
* Never reached ...
*/
Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. Unsupported digest stream type: %d"), Stream);
}
bin_to_base64(digestbuf, sizeof(digestbuf), fname, len, true);
Dmsg3(400, "DigestLen=%d Digest=%s type=%d\n", strlen(digestbuf),
digestbuf, Stream);
if (jcr->cached_attribute) {
ar->Digest = digestbuf;
ar->DigestType = type;
Dmsg2(400, "Cached attr with digest. Stream=%d fname=%s\n", ar->Stream, ar->fname);
/*
* Update BaseFile table
*/
if (!db_create_attributes_record(jcr, jcr->db, ar)) {
Jmsg1(jcr, M_FATAL, 0, _("attribute create error. %s"), db_strerror(jcr->db));
}
jcr->cached_attribute = false;
} else {
if (!db_add_digest_to_file_record(jcr, jcr->db, ar->FileId, digestbuf, type)) {
Jmsg(jcr, M_ERROR, 0, _("Catalog error updating file digest. %s"), db_strerror(jcr->db));
}
}
}
}
break;
}
}
/* List just block information */
static void do_blocks(char *infname)
{
DEV_BLOCK *block = dcr->block;
char buf1[100], buf2[100];
for ( ;; ) {
if (!dcr->read_block_from_device(NO_BLOCK_NUMBER_CHECK)) {
Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
if (dev->at_eot()) {
if (!mount_next_read_volume(dcr)) {
Jmsg(jcr, M_INFO, 0, _("Got EOM at file %u on device %s, Volume \"%s\"\n"),
dev->file, dev->print_name(), dcr->VolumeName);
break;
}
/* Read and discard Volume label */
DEV_RECORD *record;
record = new_record();
dcr->read_block_from_device(NO_BLOCK_NUMBER_CHECK);
read_record_from_block(dcr, record);
get_session_record(dev, record, &sessrec);
free_record(record);
Jmsg(jcr, M_INFO, 0, _("Mounted Volume \"%s\".\n"), dcr->VolumeName);
} else if (dev->at_eof()) {
Jmsg(jcr, M_INFO, 0, _("End of file %u on device %s, Volume \"%s\"\n"),
dev->file, dev->print_name(), dcr->VolumeName);
Dmsg0(20, "read_record got eof. try again\n");
continue;
} else if (dev->is_short_block()) {
Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg);
continue;
} else {
/* I/O error */
display_tape_error_status(jcr, dev);
break;
}
}
if (!match_bsr_block(bsr, block)) {
Dmsg5(100, "reject Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
block->BlockNumber, block->block_len, block->BlockVer,
block->VolSessionId, block->VolSessionTime);
continue;
}
Dmsg5(100, "Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
block->BlockNumber, block->block_len, block->BlockVer,
block->VolSessionId, block->VolSessionTime);
if (verbose == 1) {
read_record_from_block(dcr, rec);
Pmsg9(-1, _("File:blk=%u:%u blk_num=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
dev->file, dev->block_num,
block->BlockNumber, block->block_len,
FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
rec->remainder = 0;
} else if (verbose > 1) {
dump_block(block, "");
} else {
printf(_("Block: %d size=%d\n"), block->BlockNumber, block->block_len);
}
}
return;
}
/*
* Read the volume label
*
* If dcr->VolumeName == NULL, we accept any Bareos Volume
* If dcr->VolumeName[0] == 0, we accept any Bareos Volume
* otherwise dcr->VolumeName must match the Volume.
*
* If VolName given, ensure that it matches
*
* Returns VOL_ code as defined in record.h
* VOL_NOT_READ
* VOL_OK good label found
* VOL_NO_LABEL volume not labeled
* VOL_IO_ERROR I/O error reading tape
* VOL_NAME_ERROR label has wrong name
* VOL_CREATE_ERROR Error creating label
* VOL_VERSION_ERROR label has wrong version
* VOL_LABEL_ERROR bad label type
* VOL_NO_MEDIA no media in drive
*
* The dcr block is emptied on return, and the Volume is
* rewound.
*/
int read_dev_volume_label(DCR *dcr)
{
JCR *jcr = dcr->jcr;
DEVICE * volatile dev = dcr->dev;
char *VolName = dcr->VolumeName;
DEV_RECORD *record;
bool ok = false;
DEV_BLOCK *block = dcr->block;
int status;
bool want_ansi_label;
bool have_ansi_label = false;
/*
* We always write the label in an 64512 byte / 63k block.
* so we never have problems reading the volume label.
*/
/*
* Set the default blocksize to read the label
*/
dev->set_label_blocksize(dcr);
Dmsg5(100, "Enter read_volume_label res=%d device=%s vol=%s dev_Vol=%s max_blocksize=%u\n",
dev->num_reserved(), dev->print_name(), VolName,
dev->VolHdr.VolumeName[0]?dev->VolHdr.VolumeName:"*NULL*", dev->max_block_size);
if (!dev->is_open()) {
if (!dev->open(dcr, OPEN_READ_ONLY)) {
return VOL_IO_ERROR;
}
}
dev->clear_labeled();
dev->clear_append();
dev->clear_read();
dev->label_type = B_BAREOS_LABEL;
if (!dev->rewind(dcr)) {
Mmsg(jcr->errmsg, _("Couldn't rewind device %s: ERR=%s\n"),
dev->print_name(), dev->print_errmsg());
Dmsg1(130, "return VOL_NO_MEDIA: %s", jcr->errmsg);
return VOL_NO_MEDIA;
}
bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id));
/*
* The stored plugin handling the bsdEventLabelRead event can abort
* the reading of the label by returning a non bRC_OK.
*/
if (generate_plugin_event(jcr, bsdEventLabelRead, dcr) != bRC_OK) {
Dmsg0(200, "Error from bsdEventLabelRead plugin event.\n");
return VOL_NO_MEDIA;
}
/*
* Read ANSI/IBM label if so requested
*/
want_ansi_label = dcr->VolCatInfo.LabelType != B_BAREOS_LABEL ||
dcr->device->label_type != B_BAREOS_LABEL;
if (want_ansi_label || dev->has_cap(CAP_CHECKLABELS)) {
status = read_ansi_ibm_label(dcr);
/*
* If we want a label and didn't find it, return error
*/
if (want_ansi_label && status != VOL_OK) {
goto bail_out;
}
if (status == VOL_NAME_ERROR || status == VOL_LABEL_ERROR) {
Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
dev->print_name(), VolName, dev->VolHdr.VolumeName);
if (!dev->poll && jcr->label_errors++ > 100) {
Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
}
goto bail_out;
}
if (status != VOL_OK) { /* Not an ANSI/IBM label, so re-read */
dev->rewind(dcr);
} else {
have_ansi_label = true;
}
}
/*
* Read the Bareos Volume label block
*/
record = new_record();
empty_block(block);
Dmsg0(130, "Big if statement in read_volume_label\n");
if (!dcr->read_block_from_dev(NO_BLOCK_NUMBER_CHECK)) {
Mmsg(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bareos "
"labeled Volume, because: ERR=%s"), NPRT(VolName),
dev->print_name(), dev->print_errmsg());
Dmsg1(130, "%s", jcr->errmsg);
} else if (!read_record_from_block(dcr, record)) {
Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n"));
Dmsg1(130, "%s", jcr->errmsg);
} else if (!unser_volume_label(dev, record)) {
Mmsg(jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"),
dev->print_errmsg());
Dmsg1(130, "%s", jcr->errmsg);
} else if (!bstrcmp(dev->VolHdr.Id, BareosId) &&
!bstrcmp(dev->VolHdr.Id, OldBaculaId) &&
!bstrcmp(dev->VolHdr.Id, OlderBaculaId)) {
Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id);
Dmsg1(130, "%s", jcr->errmsg);
} else {
ok = true;
}
free_record(record); /* finished reading Volume record */
if (!dev->is_volume_to_unload()) {
dev->clear_unload();
}
if (!ok) {
if (forge_on || jcr->ignore_label_errors) {
dev->set_labeled(); /* set has Bareos label */
Jmsg(jcr, M_ERROR, 0, "%s", jcr->errmsg);
goto ok_out;
}
Dmsg0(100, "No volume label - bailing out\n");
status = VOL_NO_LABEL;
goto bail_out;
}
/*
* At this point, we have read the first Bareos block, and
* then read the Bareos Volume label. Now we need to
* make sure we have the right Volume.
*/
if (dev->VolHdr.VerNum != BareosTapeVersion &&
dev->VolHdr.VerNum != OldCompatibleBareosTapeVersion1 &&
dev->VolHdr.VerNum != OldCompatibleBareosTapeVersion2 &&
dev->VolHdr.VerNum != OldCompatibleBareosTapeVersion3) {
Mmsg(jcr->errmsg, _("Volume on %s has wrong Bareos version. Wanted %d got %d\n"),
dev->print_name(), BareosTapeVersion, dev->VolHdr.VerNum);
Dmsg1(130, "VOL_VERSION_ERROR: %s", jcr->errmsg);
status = VOL_VERSION_ERROR;
goto bail_out;
}
/*
* We are looking for either an unused Bareos tape (PRE_LABEL) or
* a Bareos volume label (VOL_LABEL)
*/
if (dev->VolHdr.LabelType != PRE_LABEL && dev->VolHdr.LabelType != VOL_LABEL) {
Mmsg(jcr->errmsg, _("Volume on %s has bad Bareos label type: %x\n"),
dev->print_name(), dev->VolHdr.LabelType);
Dmsg1(130, "%s", jcr->errmsg);
if (!dev->poll && jcr->label_errors++ > 100) {
Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
}
Dmsg0(150, "return VOL_LABEL_ERROR\n");
status = VOL_LABEL_ERROR;
goto bail_out;
}
dev->set_labeled(); /* set has Bareos label */
/* Compare Volume Names */
Dmsg2(130, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolumeName);
if (VolName && *VolName && *VolName != '*' && !bstrcmp(dev->VolHdr.VolumeName, VolName)) {
Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
dev->print_name(), VolName, dev->VolHdr.VolumeName);
Dmsg1(130, "%s", jcr->errmsg);
/*
* Cancel Job if too many label errors
* => we are in a loop
*/
if (!dev->poll && jcr->label_errors++ > 100) {
Jmsg(jcr, M_FATAL, 0, "Too many tries: %s", jcr->errmsg);
}
Dmsg0(150, "return VOL_NAME_ERROR\n");
status = VOL_NAME_ERROR;
goto bail_out;
}
if (debug_level >= 200) {
dump_volume_label(dev);
}
Dmsg0(130, "Leave read_volume_label() VOL_OK\n");
/*
* If we are a streaming device, we only get one chance to read
*/
if (!dev->has_cap(CAP_STREAM)) {
dev->rewind(dcr);
if (have_ansi_label) {
status = read_ansi_ibm_label(dcr);
/*
* If we want a label and didn't find it, return error
*/
if (status != VOL_OK) {
goto bail_out;
}
}
}
Dmsg1(100, "Call reserve_volume=%s\n", dev->VolHdr.VolumeName);
if (reserve_volume(dcr, dev->VolHdr.VolumeName) == NULL) {
Mmsg2(jcr->errmsg, _("Could not reserve volume %s on %s\n"),
dev->VolHdr.VolumeName, dev->print_name());
Dmsg2(150, "Could not reserve volume %s on %s\n", dev->VolHdr.VolumeName, dev->print_name());
status = VOL_NAME_ERROR;
goto bail_out;
}
ok_out:
/*
* The stored plugin handling the bsdEventLabelVerified event can override
* the return value e.g. although we think the volume label is ok the plugin
* has reasons to override that. So when the plugin returns something else
* then bRC_OK it want to tell us the volume is not OK to use and as
* such we return VOL_NAME_ERROR as error although it might not be the
* best error it should be sufficient.
*/
if (generate_plugin_event(jcr, bsdEventLabelVerified, dcr) != bRC_OK) {
Dmsg0(200, "Error from bsdEventLabelVerified plugin event.\n");
status = VOL_NAME_ERROR;
goto bail_out;
}
empty_block(block);
/*
* reset blocksizes from volinfo to device as we set blocksize to
* DEFAULT_BLOCK_SIZE to read the label
*/
dev->set_blocksizes(dcr);
return VOL_OK;
bail_out:
empty_block(block);
dev->rewind(dcr);
Dmsg1(150, "return %d\n", status);
return status;
}
/*
* Called here for each record from read_records()
* This function is used when we do a external clone of a Job e.g.
* this SD is the reading SD. And a remote SD is the writing SD.
*
* Returns: true if OK
* false if error
*/
static bool clone_record_to_remote_sd(DCR *dcr, DEV_RECORD *rec)
{
POOLMEM *msgsave;
JCR *jcr = dcr->jcr;
char buf1[100], buf2[100];
BSOCK *sd = jcr->store_bsock;
bool send_eod, send_header;
#ifdef xxx
Dmsg5(000, "on entry JobId=%d FI=%s SessId=%d Strm=%s len=%d\n",
jcr->JobId, FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
#endif
/*
* If label discard it
*/
if (rec->FileIndex < 0) {
return true;
}
/*
* See if this is the first record being processed.
*/
if (rec->last_FileIndex == 0) {
/*
* Initialize the last counters so we can compare
* things in the next run through here.
*/
rec->last_VolSessionId = rec->VolSessionId;
rec->last_VolSessionTime = rec->VolSessionTime;
rec->last_FileIndex = rec->FileIndex;
rec->last_Stream = rec->Stream;
jcr->JobFiles = 1;
/*
* Need to send both a new header only.
*/
send_eod = false;
send_header = true;
} else {
/*
* See if we are changing file or stream type.
*/
if (rec->VolSessionId != rec->last_VolSessionId ||
rec->VolSessionTime != rec->last_VolSessionTime ||
rec->FileIndex != rec->last_FileIndex ||
rec->Stream != rec->last_Stream) {
/*
* See if we are changing the FileIndex e.g.
* start processing the next file in the backup stream.
*/
if (rec->FileIndex != rec->last_FileIndex) {
jcr->JobFiles++;
}
/*
* Keep track of the new state.
*/
rec->last_VolSessionId = rec->VolSessionId;
rec->last_VolSessionTime = rec->VolSessionTime;
rec->last_FileIndex = rec->FileIndex;
rec->last_Stream = rec->Stream;
/*
* Need to send both a EOD and a new header.
*/
send_eod = true;
send_header = true;
} else {
send_eod = false;
send_header = false;
}
}
/*
* Send a EOD when needed.
*/
if (send_eod) {
if (!sd->signal(BNET_EOD)) { /* indicate end of file data */
if (!jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
}
return false;
}
}
/*
* Send a header when needed.
*/
if (send_header) {
if (!sd->fsend("%ld %d 0", rec->FileIndex, rec->Stream)) {
if (!jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
}
return false;
}
}
/*
* Send the record data.
* We don't want to copy the data from the record to the socket structure
* so we save the original msg pointer and use the record data pointer for
* sending and restore the original msg pointer when done.
*/
msgsave = sd->msg;
sd->msg = rec->data;
sd->msglen = rec->data_len;
if (!sd->send()) {
sd->msg = msgsave;
sd->msglen = 0;
if (!jcr->is_job_canceled()) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
}
return false;
}
jcr->JobBytes += sd->msglen;
sd->msg = msgsave;
Dmsg5(500, "wrote_record JobId=%d FI=%s SessId=%d Strm=%s len=%d\n",
jcr->JobId, FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
return true;
}
/*
* Called here for each record from read_records()
* This function is used when we do a internal clone of a Job e.g.
* this SD is both the reading and writing SD.
*
* Returns: true if OK
* false if error
*/
static bool clone_record_internally(DCR *dcr, DEV_RECORD *rec)
{
JCR *jcr = dcr->jcr;
DEVICE *dev = jcr->dcr->dev;
char buf1[100], buf2[100];
#ifdef xxx
Dmsg5(000, "on entry JobId=%d FI=%s SessId=%d Strm=%s len=%d\n",
jcr->JobId, FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
#endif
/*
* If label and not for us, discard it
*/
if (rec->FileIndex < 0 && rec->match_stat <= 0) {
return true;
}
/*
* We want to write SOS_LABEL and EOS_LABEL discard all others
*/
switch (rec->FileIndex) {
case PRE_LABEL:
case VOL_LABEL:
case EOT_LABEL:
case EOM_LABEL:
return true; /* don't write vol labels */
}
// if (jcr->is_JobType(JT_BACKUP)) {
/*
* For normal migration jobs, FileIndex values are sequential because
* we are dealing with one job. However, for Vbackup (consolidation),
* we will be getting records from multiple jobs and writing them back
* out, so we need to ensure that the output FileIndex is sequential.
* We do so by detecting a FileIndex change and incrementing the
* JobFiles, which we then use as the output FileIndex.
*/
if (rec->FileIndex >= 0) {
/*
* If something changed, increment FileIndex
*/
if (rec->VolSessionId != rec->last_VolSessionId ||
rec->VolSessionTime != rec->last_VolSessionTime ||
rec->FileIndex != rec->last_FileIndex) {
jcr->JobFiles++;
rec->last_VolSessionId = rec->VolSessionId;
rec->last_VolSessionTime = rec->VolSessionTime;
rec->last_FileIndex = rec->FileIndex;
}
rec->FileIndex = jcr->JobFiles; /* set sequential output FileIndex */
}
// }
/*
* Modify record SessionId and SessionTime to correspond to output.
*/
rec->VolSessionId = jcr->VolSessionId;
rec->VolSessionTime = jcr->VolSessionTime;
Dmsg5(200, "before write JobId=%d FI=%s SessId=%d Strm=%s len=%d\n",
jcr->JobId, FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
while (!write_record_to_block(jcr->dcr, rec)) {
Dmsg4(200, "!write_record_to_block blkpos=%u:%u len=%d rem=%d\n",
dev->file, dev->block_num, rec->data_len, rec->remainder);
if (!jcr->dcr->write_block_to_device()) {
Dmsg2(90, "Got write_block_to_dev error on device %s. %s\n",
dev->print_name(), dev->bstrerror());
Jmsg2(jcr, M_FATAL, 0, _("Fatal append error on device %s: ERR=%s\n"),
dev->print_name(), dev->bstrerror());
return false;
}
Dmsg2(200, "===== Wrote block new pos %u:%u\n", dev->file, dev->block_num);
}
/*
* Restore packet
*/
rec->VolSessionId = rec->last_VolSessionId;
rec->VolSessionTime = rec->last_VolSessionTime;
if (rec->FileIndex < 0) {
return true; /* don't send LABELs to Dir */
}
jcr->JobBytes += rec->data_len; /* increment bytes of this job */
Dmsg5(500, "wrote_record JobId=%d FI=%s SessId=%d Strm=%s len=%d\n",
jcr->JobId, 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);
return true;
}
/*
* Open a fifo device
*/
void win32_fifo_device::open_device(DCR *dcr, int omode)
{
file_size = 0;
int timeout = max_open_wait;
utime_t start_time = time(NULL);
mount(dcr, 1); /* do mount if required */
Dmsg0(100, "Open dev: device is fifo\n");
get_autochanger_loaded_slot(dcr);
open_mode = omode;
set_mode(omode);
if (timeout < 1) {
timeout = 1;
}
errno = 0;
if (timeout) {
/*
* Set open timer
*/
tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
}
Dmsg2(100, "Try open %s mode=%s\n", prt_name, mode_to_str(omode));
/*
* If busy retry each second for max_open_wait seconds
*/
for ( ;; ) {
/*
* Try non-blocking open
*/
m_fd = d_open(dev_name, oflags | O_NONBLOCK, 0);
if (m_fd < 0) {
berrno be;
dev_errno = errno;
Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n",
prt_name, omode, oflags, errno, be.bstrerror());
} else {
d_close(m_fd);
m_fd = d_open(dev_name, oflags, 0); /* open normally */
if (m_fd < 0) {
berrno be;
dev_errno = errno;
Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n",
prt_name, omode, oflags, errno, be.bstrerror());
break;
}
dev_errno = 0;
lock_door();
break; /* Successfully opened and rewound */
}
bmicrosleep(5, 0);
/*
* Exceed wait time ?
*/
if (time(NULL) - start_time >= max_open_wait) {
break; /* yes, get out */
}
}
if (!is_open()) {
berrno be;
Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
prt_name, be.bstrerror(dev_errno));
Dmsg1(100, "%s", errmsg);
}
/*
* Stop any open() timer we started
*/
if (tid) {
stop_thread_timer(tid);
tid = 0;
}
Dmsg1(100, "open dev: fifo %d opened\n", m_fd);
}
/*
* We get the slot list from the Storage daemon.
* If listall is set we run an 'autochanger listall' cmd
* otherwise an 'autochanger list' cmd
* If scan is set and listall is not, we return all slots found,
* otherwise, we return only slots with valid barcodes (Volume names)
*
* Input (output of mxt-changer list):
*
* 0:vol2 Slot num:Volume Name
*
* Input (output of mxt-changer listall):
*
* Drive content: D:Drive num:F:Slot loaded:Volume Name
* D:0:F:2:vol2 or D:Drive num:E
* D:1:F:42:vol42
* D:3:E
*
* Slot content:
* S:1:F:vol1 S:Slot num:F:Volume Name
* S:2:E or S:Slot num:E
* S:3:F:vol4
*
* Import/Export tray slots:
* I:10:F:vol10 I:Slot num:F:Volume Name
* I:11:E or I:Slot num:E
* I:12:F:vol40
*
* If a drive is loaded, the slot *should* be empty
*/
dlist *get_vol_list_from_SD(UAContext *ua, STORERES *store, bool listall, bool scan)
{
int nr_fields;
char *bp;
char dev_name[MAX_NAME_LENGTH];
char *field1, *field2, *field3, *field4, *field5;
vol_list_t *vl = NULL;
dlist *vol_list;
BSOCK *sd = NULL;
if (!(sd = open_sd_bsock(ua))) {
return NULL;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/*
* Ask for autochanger list of volumes
*/
if (listall) {
sd->fsend(changerlistallcmd , dev_name);
} else {
sd->fsend(changerlistcmd, dev_name);
}
vol_list = New(dlist(vl, &vl->link));
/*
* Read and organize list of Volumes
*/
while (bnet_recv(sd) >= 0) {
strip_trailing_junk(sd->msg);
/*
* Check for returned SD messages
*/
if (sd->msg[0] == '3' && B_ISDIGIT(sd->msg[1]) &&
B_ISDIGIT(sd->msg[2]) && B_ISDIGIT(sd->msg[3]) &&
sd->msg[4] == ' ') {
ua->send_msg("%s\n", sd->msg); /* pass them on to user */
continue;
}
/*
* Parse the message. list gives max 2 fields listall max 5.
* We always make sure all fields are initialized to either
* a value or NULL.
*
* For autochanger list the following mapping is used:
* - field1 == slotnr
* - field2 == volumename
*
* For autochanger listall the following mapping is used:
* - field1 == type
* - field2 == slotnr
* - field3 == content (E for Empty, F for Full)
* - field4 == loaded (loaded slot if type == D)
* - field4 == volumename (if type == S or I)
* - field5 == volumename (if type == D)
*/
field1 = sd->msg;
field2 = strchr(sd->msg, ':');
if (field2) {
*field2++ = '\0';
if (listall) {
field3 = strchr(field2, ':');
if (field3) {
*field3++ = '\0';
field4 = strchr(field3, ':');
if (field4) {
*field4++ = '\0';
field5 = strchr(field4, ':');
if (field5) {
*field5++ = '\0';
nr_fields = 5;
} else {
nr_fields = 4;
}
} else {
nr_fields = 3;
field5 = NULL;
}
} else {
nr_fields = 2;
field4 = NULL;
field5 = NULL;
}
} else {
nr_fields = 2;
field3 = NULL;
field4 = NULL;
field5 = NULL;
}
} else {
nr_fields = 1;
field3 = NULL;
field4 = NULL;
field5 = NULL;
}
/*
* See if this is a parsable string from either list or listall
* e.g. at least f1:f2
*/
if (!field1 && !field2) {
goto parse_error;
}
vl = (vol_list_t *)malloc(sizeof(vol_list_t));
memset(vl, 0, sizeof(vol_list_t));
if (scan && !listall) {
/*
* Scanning -- require only valid slot
*/
vl->Slot = atoi(field1);
if (vl->Slot <= 0) {
ua->error_msg(_("Invalid Slot number: %s\n"), sd->msg);
free(vl);
continue;
}
vl->Type = slot_type_normal;
if (strlen(field2) > 0) {
vl->Content = slot_content_full;
vl->VolName = bstrdup(field2);
} else {
vl->Content = slot_content_empty;
}
vl->Index = INDEX_SLOT_OFFSET + vl->Slot;
} else if (!listall) {
/*
* Not scanning and not listall.
*/
if (strlen(field2) == 0) {
free(vl);
continue;
}
if (!is_an_integer(field1) || (vl->Slot = atoi(field1)) <= 0) {
ua->error_msg(_("Invalid Slot number: %s\n"), field1);
free(vl);
continue;
}
if (!is_volume_name_legal(ua, field2)) {
ua->error_msg(_("Invalid Volume name: %s\n"), field2);
free(vl);
continue;
}
vl->Type = slot_type_normal;
vl->Content = slot_content_full;
vl->VolName = bstrdup(field2);
vl->Index = INDEX_SLOT_OFFSET + vl->Slot;
} else {
/*
* Listall.
*/
if (!field3) {
goto parse_error;
}
switch (*field1) {
case 'D':
vl->Type = slot_type_drive;
break;
case 'S':
vl->Type = slot_type_normal;
break;
case 'I':
vl->Type = slot_type_import;
break;
default:
vl->Type = slot_type_unknown;
break;
}
/*
* For drives the Slot is the actual drive number.
* For any other type its the actual slot number.
*/
switch (vl->Type) {
case slot_type_drive:
if (!is_an_integer(field2) || (vl->Slot = atoi(field2)) < 0) {
ua->error_msg(_("Invalid Drive number: %s\n"), field2);
free(vl);
continue;
}
vl->Index = INDEX_DRIVE_OFFSET + vl->Slot;
if (vl->Index >= INDEX_MAX_DRIVES) {
ua->error_msg(_("Drive number %d greater then INDEX_MAX_DRIVES(%d) please increase define\n"),
vl->Slot, INDEX_MAX_DRIVES);
free(vl);
continue;
}
break;
default:
if (!is_an_integer(field2) || (vl->Slot = atoi(field2)) <= 0) {
ua->error_msg(_("Invalid Slot number: %s\n"), field2);
free(vl);
continue;
}
vl->Index = INDEX_SLOT_OFFSET + vl->Slot;
break;
}
switch (*field3) {
case 'E':
vl->Content = slot_content_empty;
break;
case 'F':
vl->Content = slot_content_full;
switch (vl->Type) {
case slot_type_normal:
case slot_type_import:
if (field4) {
vl->VolName = bstrdup(field4);
}
break;
case slot_type_drive:
if (field4) {
vl->Loaded = atoi(field4);
}
if (field5) {
vl->VolName = bstrdup(field5);
}
break;
default:
break;
}
break;
default:
vl->Content = slot_content_unknown;
break;
}
}
if (vl->VolName) {
Dmsg6(100, "Add index = %d slot=%d loaded=%d type=%d content=%d Vol=%s to SD list.\n",
vl->Index, vl->Slot, vl->Loaded, vl->Type, vl->Content, NPRT(vl->VolName));
} else {
Dmsg5(100, "Add index = %d slot=%d loaded=%d type=%d content=%d Vol=NULL to SD list.\n",
vl->Index, vl->Slot, vl->Loaded, vl->Type, vl->Content);
}
vol_list->binary_insert(vl, compare_vol_list_entry);
continue;
parse_error:
/*
* We encountered a parse error, see how many replacements
* we done of ':' with '\0' by looking at the nr_fields
* variable and undo those. Number of undo's are nr_fields - 1
*/
while (nr_fields > 1 && (bp = strchr(sd->msg, '\0')) != NULL) {
*bp = ':';
nr_fields--;
}
ua->error_msg(_("Illegal output from autochanger %s: %s\n"),
(listall) ? _("listall") : _("list"), sd->msg);
free(vl);
continue;
}
close_sd_bsock(ua);
if (vol_list->size() == 0) {
delete vol_list;
vol_list = NULL;
}
return vol_list;
}
/*
* (Un)mount the device (For a FILE device)
*/
static bool do_mount(DCR *dcr, bool mount, int dotimeout)
{
DEVRES *device = dcr->dev->device;
POOL_MEM ocmd(PM_FNAME);
POOLMEM *results;
DIR* dp;
char *icmd;
struct dirent *entry, *result;
int status, tries, name_max, count;
berrno be;
Dsm_check(200);
if (mount) {
icmd = device->mount_command;
} else {
icmd = device->unmount_command;
}
dcr->dev->edit_mount_codes(ocmd, icmd);
Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), dcr->dev->is_mounted());
if (dotimeout) {
/* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
tries = 10;
} else {
tries = 1;
}
results = get_memory(4000);
/* If busy retry each second */
Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
while ((status = run_program_full_output(ocmd.c_str(), dcr->dev->max_open_wait / 2, results)) != 0) {
/* Doesn't work with internationalization (This is not a problem) */
if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
break;
}
if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
break;
}
if (tries-- > 0) {
/* Sometimes the device cannot be mounted because it is already mounted.
* Try to unmount it, then remount it */
if (mount) {
Dmsg1(400, "Trying to unmount the device %s...\n", dcr->dev->print_name());
do_mount(dcr, 0, 0);
}
bmicrosleep(1, 0);
continue;
}
Dmsg5(100, "Device %s cannot be %smounted. status=%d result=%s ERR=%s\n", dcr->dev->print_name(),
(mount ? "" : "un"), status, results, be.bstrerror(status));
Mmsg(dcr->dev->errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
dcr->dev->print_name(), (mount ? "" : "un"), be.bstrerror(status));
/*
* Now, just to be sure it is not mounted, try to read the filesystem.
*/
name_max = pathconf(".", _PC_NAME_MAX);
if (name_max < 1024) {
name_max = 1024;
}
if (!(dp = opendir(device->mount_point))) {
berrno be;
dcr->dev->dev_errno = errno;
Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
device->mount_point, dcr->dev->print_name(), be.bstrerror());
goto get_out;
}
entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
count = 0;
while (1) {
if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
dcr->dev->dev_errno = EIO;
Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
device->mount_point, dcr->dev->print_name());
break;
}
if (!bstrcmp(result->d_name, ".") && !bstrcmp(result->d_name, "..") && !bstrcmp(result->d_name, ".keep")) {
count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
break;
} else {
Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
}
}
free(entry);
closedir(dp);
Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
if (count > 0) {
/* If we got more than ., .. and .keep */
/* there must be something mounted */
if (mount) {
Dmsg1(100, "Did Mount by count=%d\n", count);
break;
} else {
/* An unmount request. We failed to unmount - report an error */
free_pool_memory(results);
Dmsg0(200, "== error mount=1 wanted unmount\n");
return false;
}
}
get_out:
free_pool_memory(results);
Dmsg0(200, "============ mount=0\n");
Dsm_check(200);
return false;
}
free_pool_memory(results);
Dmsg1(200, "============ mount=%d\n", mount);
return true;
}
/*
* Do an lseek on a DVD handling all the different parts
*/
boffset_t lseek_dvd(DCR *dcr, boffset_t offset, int whence)
{
DEVICE *dev;
boffset_t pos;
char ed1[50], ed2[50];
if (!dcr) { /* can be NULL when called from rewind(NULL) */
return -1;
}
dev = dcr->dev;
Dmsg5(400, "Enter lseek_dvd fd=%d off=%s w=%d part=%d nparts=%d\n", dev->fd(),
edit_int64(offset, ed1), whence, dev->part, dev->num_dvd_parts);
switch(whence) {
case SEEK_SET:
Dmsg2(400, "lseek_dvd SEEK_SET to %s (part_start=%s)\n",
edit_int64(offset, ed1), edit_uint64(dev->part_start, ed2));
if ((uint64_t)offset >= dev->part_start) {
if ((uint64_t)offset == dev->part_start ||
(uint64_t)offset < dev->part_start+dev->part_size) {
/* We are staying in the current part, just seek */
#if defined(HAVE_WIN32)
pos = _lseeki64(dev->fd(), offset-dev->part_start, SEEK_SET);
#else
pos = lseek(dev->fd(), offset-dev->part_start, SEEK_SET);
#endif
if (pos < 0) {
return pos;
} else {
return pos + dev->part_start;
}
} else {
/* Load next part, and start again */
Dmsg0(100, "lseek open next part\n");
if (dvd_open_next_part(dcr) < 0) {
Dmsg0(400, "lseek_dvd failed while trying to open the next part\n");
return -1;
}
Dmsg2(100, "Recurse lseek after open next part=%d num_part=%d\n",
dev->part, dev->num_dvd_parts);
return lseek_dvd(dcr, offset, SEEK_SET);
}
} else {
/*
* pos < dev->part_start :
* We need to access a previous part,
* so just load the first one, and seek again
* until the right one is loaded
*/
Dmsg0(100, "lseek open first part\n");
if (!dvd_open_first_part(dcr, dev->openmode)) {
Dmsg0(400, "lseek_dvd failed while trying to open the first part\n");
return -1;
}
Dmsg2(100, "Recurse lseek after open first part=%d num_part=%d\n",
dev->part, dev->num_dvd_parts);
return lseek_dvd(dcr, offset, SEEK_SET); /* system lseek */
}
break;
case SEEK_CUR:
Dmsg1(400, "lseek_dvd SEEK_CUR to %s\n", edit_int64(offset, ed1));
if ((pos = lseek(dev->fd(), 0, SEEK_CUR)) < 0) {
Dmsg0(400, "Seek error.\n");
return pos;
}
pos += dev->part_start;
if (offset == 0) {
Dmsg1(400, "lseek_dvd SEEK_CUR returns %s\n", edit_uint64(pos, ed1));
return pos;
} else {
Dmsg1(400, "do lseek_dvd SEEK_SET %s\n", edit_uint64(pos, ed1));
return lseek_dvd(dcr, pos, SEEK_SET);
}
break;
case SEEK_END:
Dmsg1(400, "lseek_dvd SEEK_END to %s\n", edit_int64(offset, ed1));
/*
* Bacula does not use offsets for SEEK_END
* Also, Bacula uses seek_end only when it wants to
* append to the volume, so for a dvd that means
* that the volume must be spooled since the DVD
* itself is read-only (as currently implemented).
*/
if (offset > 0) { /* Not used by bacula */
Dmsg1(400, "lseek_dvd SEEK_END called with an invalid offset %s\n",
edit_uint64(offset, ed1));
errno = EINVAL;
return -1;
}
/* If we are already on a spooled part and have the
* right part number, simply seek
*/
if (dev->is_part_spooled() && dev->part > dev->num_dvd_parts) {
if ((pos = lseek(dev->fd(), 0, SEEK_END)) < 0) {
return pos;
} else {
Dmsg1(400, "lseek_dvd SEEK_END returns %s\n",
edit_uint64(pos + dev->part_start, ed1));
return pos + dev->part_start;
}
} else {
/*
* Load the first part, then load the next until we reach the last one.
* This is the only way to be sure we compute the right file address.
*
* Save previous openmode, and open all but last part read-only
* (useful for DVDs)
*/
int modesave = dev->openmode;
if (!dvd_open_first_part(dcr, OPEN_READ_ONLY)) {
Dmsg0(400, "lseek_dvd failed while trying to open the first part\n");
return -1;
}
if (dev->num_dvd_parts > 0) {
while (dev->part < dev->num_dvd_parts) {
if (dvd_open_next_part(dcr) < 0) {
Dmsg0(400, "lseek_dvd failed while trying to open the next part\n");
return -1;
}
}
dev->openmode = modesave;
if (dvd_open_next_part(dcr) < 0) {
Dmsg0(400, "lseek_dvd failed while trying to open the next part\n");
return -1;
}
}
return lseek_dvd(dcr, 0, SEEK_END);
}
break;
default:
Dmsg0(400, "Seek call error.\n");
errno = EINVAL;
return -1;
}
}
/*
* Open a tape device
*/
void generic_tape_device::open_device(DCR *dcr, int omode)
{
file_size = 0;
int timeout = max_open_wait;
#if !defined(HAVE_WIN32)
struct mtop mt_com;
utime_t start_time = time(NULL);
#endif
mount(dcr, 1); /* do mount if required */
Dmsg0(100, "Open dev: device is tape\n");
get_autochanger_loaded_slot(dcr);
open_mode = omode;
set_mode(omode);
if (timeout < 1) {
timeout = 1;
}
errno = 0;
Dmsg2(100, "Try open %s mode=%s\n", prt_name, mode_to_str(omode));
#if defined(HAVE_WIN32)
/*
* Windows Code
*/
if ((m_fd = d_open(dev_name, oflags, 0)) < 0) {
dev_errno = errno;
}
#else
/*
* UNIX Code
*
* If busy retry each second for max_open_wait seconds
*/
for ( ;; ) {
/*
* Try non-blocking open
*/
m_fd = d_open(dev_name, oflags | O_NONBLOCK, 0);
if (m_fd < 0) {
berrno be;
dev_errno = errno;
Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n",
prt_name, omode, oflags, errno, be.bstrerror());
} else {
/*
* Tape open, now rewind it
*/
Dmsg0(100, "Rewind after open\n");
mt_com.mt_op = MTREW;
mt_com.mt_count = 1;
/*
* Rewind only if dev is a tape
*/
if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
berrno be;
dev_errno = errno; /* set error status from rewind */
d_close(m_fd);
clear_opened();
Dmsg2(100, "Rewind error on %s close: ERR=%s\n", prt_name, be.bstrerror(dev_errno));
/*
* If we get busy, device is probably rewinding, try again
*/
if (dev_errno != EBUSY) {
break; /* error -- no medium */
}
} else {
/*
* Got fd and rewind worked, so we must have medium in drive
*/
d_close(m_fd);
m_fd = d_open(dev_name, oflags, 0); /* open normally */
if (m_fd < 0) {
berrno be;
dev_errno = errno;
Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n",
prt_name, omode, oflags, errno, be.bstrerror());
break;
}
dev_errno = 0;
lock_door();
set_os_device_parameters(dcr); /* do system dependent stuff */
break; /* Successfully opened and rewound */
}
}
bmicrosleep(5, 0);
/*
* Exceed wait time ?
*/
if (time(NULL) - start_time >= max_open_wait) {
break; /* yes, get out */
}
}
#endif
if (!is_open()) {
berrno be;
Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
prt_name, be.bstrerror(dev_errno));
Dmsg1(100, "%s", errmsg);
}
Dmsg1(100, "open dev: tape %d opened\n", m_fd);
}
