/*
* Stop btimer
*/
static void stop_btimer(btimer_t *wid)
{
if (wid == NULL) {
Emsg0(M_ABORT, 0, _("stop_btimer called with NULL btimer_id\n"));
}
unregister_watchdog(wid->wd);
free(wid->wd);
free(wid);
}
/*
* Remove a JCR from the chain
*
* NOTE! The chain must be locked prior to calling this routine.
*/
static void remove_jcr(JCR *jcr)
{
Dmsg0(dbglvl, "Enter remove_jcr\n");
if (!jcr) {
Emsg0(M_ABORT, 0, _("NULL jcr.\n"));
}
jcrs->remove(jcr);
Dmsg0(dbglvl, "Leave remove_jcr\n");
}
/* Return the size of a memory buffer */
int32_t sm_sizeof_pool_memory(const char *fname, int lineno, POOLMEM *obuf)
{
char *cp = (char *)obuf;
if (obuf == NULL) {
Emsg0(M_ABORT, 0, _("obuf is NULL\n"));
}
cp -= HEAD_SIZE;
return ((struct abufhead *)cp)->ablen;
}
/*
* Inititiate the communications with the Director.
* He has made a connection to our server.
*
* Basic tasks done here:
* We read Director's initial message and authorize him.
*
*/
int authenticate_director(JCR *jcr)
{
BSOCK *dir = jcr->dir_bsock;
if (!authenticate(R_DIRECTOR, dir, jcr)) {
bnet_fsend(dir, "%s", Dir_sorry);
Emsg0(M_FATAL, 0, _("Unable to authenticate Director\n"));
return 0;
}
return bnet_fsend(dir, "%s", OK_hello);
}
void *sm_calloc(const char *fname, int lineno,
unsigned int nelem, unsigned int elsize)
{
void *buf;
if ((buf = smalloc(fname, lineno, nelem * elsize)) != NULL) {
memset(buf, 0, (int) (nelem * elsize));
} else {
Emsg0(M_ABORT, 0, _("Out of memory\n"));
}
return buf;
}
/*
* Inititiate the communications with the Director.
* He has made a connection to our server.
*
* Basic tasks done here:
* We read Director's initial message and authorize him.
*/
bool authenticate_director(JCR *jcr)
{
BSOCK *dir = jcr->dir_bsock;
if (!two_way_authenticate(R_DIRECTOR, dir, jcr)) {
dir->fsend("%s", Dir_sorry);
Emsg0(M_FATAL, 0, _("Unable to authenticate Director\n"));
return false;
}
return dir->fsend("%s", (me->compatible) ? OK_hello_compat : OK_hello);
}
/*
* Write an end of file on the device
*
* Returns: true on success
* false on failure
*/
bool generic_tape_device::weof(int num)
{
struct mtop mt_com;
int status;
Dmsg1(129, "=== weof_dev=%s\n", prt_name);
if (!is_open()) {
dev_errno = EBADF;
Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
Emsg0(M_FATAL, 0, errmsg);
return false;
}
file_size = 0;
if (!can_append()) {
Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
Emsg0(M_FATAL, 0, errmsg);
return false;
}
clear_eof();
clear_eot();
mt_com.mt_op = MTWEOF;
mt_com.mt_count = num;
status = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
if (status == 0) {
block_num = 0;
file += num;
file_addr = 0;
} else {
berrno be;
clrerror(mt_com.mt_op);
if (status == -1) {
Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"), prt_name, be.bstrerror());
}
}
return status == 0;
}
/*
* Foward space num records
*
* Returns: false on failure
* true on success
*/
bool generic_tape_device::fsr(int num)
{
struct mtop mt_com;
int status;
if (!is_open()) {
dev_errno = EBADF;
Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
Emsg0(M_FATAL, 0, errmsg);
return false;
}
if (!has_cap(CAP_FSR)) {
Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), prt_name);
return false;
}
Dmsg1(100, "fsr %d\n", num);
mt_com.mt_op = MTFSR;
mt_com.mt_count = num;
status = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
if (status == 0) {
clear_eof();
block_num += num;
} else {
berrno be;
struct mtget mt_stat;
clrerror(mt_com.mt_op);
Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
if (dev_get_os_pos(this, &mt_stat)) {
Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
file = mt_stat.mt_fileno;
block_num = mt_stat.mt_blkno;
} else {
if (at_eof()) {
set_eot();
} else {
set_ateof();
}
}
Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"), num, prt_name, be.bstrerror());
}
return status == 0;
}
void *sm_malloc(const char *fname, int lineno, unsigned int nbytes)
{
void *buf;
if ((buf = smalloc(fname, lineno, nbytes)) != NULL) {
/* To catch sloppy code that assumes buffers obtained from
malloc() are zeroed, we preset the buffer contents to
"designer garbage" consisting of alternating bits. */
memset(buf, 0x55, (int) nbytes);
} else {
Emsg0(M_ABORT, 0, _("Out of memory\n"));
}
return buf;
}
void DEVICE::set_mode(int new_mode)
{
switch (new_mode) {
case CREATE_READ_WRITE:
mode = O_CREAT | O_RDWR | O_BINARY;
break;
case OPEN_READ_WRITE:
mode = O_RDWR | O_BINARY;
break;
case OPEN_READ_ONLY:
mode = O_RDONLY | O_BINARY;
break;
case OPEN_WRITE_ONLY:
mode = O_WRONLY | O_BINARY;
break;
default:
Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
}
}
/*
* Called here for each record from read_records()
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
if (rec->FileIndex < 0) {
get_session_record(dev, rec, &sessrec);
return true;
}
/* File Attributes stream */
if (rec->Stream == STREAM_UNIX_ATTRIBUTES ||
rec->Stream == STREAM_UNIX_ATTRIBUTES_EX) {
if (!unpack_attributes_record(jcr, rec->Stream, rec->data, attr)) {
if (!forge_on) {
Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
}
num_files++;
return true;
}
if (attr->file_index != rec->FileIndex) {
Emsg2(forge_on?M_WARNING:M_ERROR_TERM, 0, _("Record header file index %ld not equal record index %ld\n"),
rec->FileIndex, attr->file_index);
}
attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
build_attr_output_fnames(jcr, attr);
if (file_is_included(ff, attr->fname) && !file_is_excluded(ff, attr->fname)) {
if (verbose) {
Pmsg5(-1, _("FileIndex=%d VolSessionId=%d VolSessionTime=%d Stream=%d DataLen=%d\n"),
rec->FileIndex, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
}
print_ls_output(jcr, attr);
num_files++;
}
} else if (rec->Stream == STREAM_PLUGIN_NAME) {
if (strncmp("0 0", rec->data, 3) != 0) {
Pmsg1(000, "Plugin data: %s\n", rec->data);
}
}
return true;
}
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;
}
static void *do_batch(void *jcr)
{
JCR *bjcr = (JCR *)jcr;
char data[1024];
int lineno = 0;
struct ATTR_DBR ar;
memset(&ar, 0, sizeof(ar));
btime_t begin = get_current_btime();
char *datafile = bjcr->where;
FILE *fd = fopen(datafile, "r");
if (!fd) {
Emsg1(M_ERROR_TERM, 0, _("Error opening datafile %s\n"), datafile);
}
while (fgets(data, sizeof(data)-1, fd)) {
strip_trailing_newline(data);
lineno++;
if (verbose && ((lineno % 5000) == 1)) {
printf("\r%i", lineno);
}
fill_attr(&ar, data);
if (!db_create_attributes_record(bjcr, bjcr->db, &ar)) {
Emsg0(M_ERROR_TERM, 0, _("Error while inserting file\n"));
}
}
fclose(fd);
db_write_batch_file_records(bjcr);
btime_t end = get_current_btime();
P(mutex);
char ed1[200], ed2[200];
printf("\rbegin = %s, end = %s\n", edit_int64(begin, ed1),edit_int64(end, ed2));
printf("Insert time = %sms\n", edit_int64((end - begin) / 10000, ed1));
printf("Create %u files at %.2f/s\n", lineno,
(lineno / ((float)((end - begin) / 1000000))));
nb--;
V(mutex);
pthread_exit(NULL);
return NULL;
}
/*
* Reposition the device to file, block
* Returns: false on failure
* true on success
*/
bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
{
if (!is_open()) {
dev_errno = EBADF;
Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
Emsg0(M_FATAL, 0, errmsg);
return false;
}
boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
Dmsg1(100, "===== lseek to %d\n", (int)pos);
if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
berrno be;
dev_errno = errno;
Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
print_name(), be.bstrerror());
return false;
}
file = rfile;
block_num = rblock;
file_addr = pos;
return true;
}
/*
* Implement vsnprintf()
*/
int bvsnprintf(char *str, int32_t size, const char *format, va_list ap)
{
#ifdef HAVE_VSNPRINTF
int len;
len = vsnprintf(str, size, format, ap);
str[size-1] = 0;
return len;
#else
int len, buflen;
char *buf;
buflen = size > BIG_BUF ? size : BIG_BUF;
buf = get_memory(buflen);
len = vsprintf(buf, format, ap);
if (len >= buflen) {
Emsg0(M_ABORT, 0, _("Buffer overflow.\n"));
}
memcpy(str, buf, len);
str[len] = 0; /* len excludes the null */
free_memory(buf);
return len;
#endif
}
int authenticate_user_agent(UAContext *uac)
{
char name[MAX_NAME_LENGTH];
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool tls_authenticate;
int compatible = true;
CONRES *cons = NULL;
BSOCK *ua = uac->UA_sock;
bool auth_success = false;
TLS_CONTEXT *tls_ctx = NULL;
alist *verify_list = NULL;
if (ua->msglen < 16 || ua->msglen >= MAX_NAME_LENGTH + 15) {
Emsg4(M_ERROR, 0, _("UA Hello from %s:%s:%d is invalid. Len=%d\n"), ua->who(),
ua->host(), ua->port(), ua->msglen);
return 0;
}
if (sscanf(ua->msg, "Hello %127s calling\n", name) != 1) {
ua->msg[100] = 0; /* terminate string */
Emsg4(M_ERROR, 0, _("UA Hello from %s:%s:%d is invalid. Got: %s\n"), ua->who(),
ua->host(), ua->port(), ua->msg);
return 0;
}
name[sizeof(name)-1] = 0; /* terminate name */
if (bstrcmp(name, "*UserAgent*")) { /* default console */
/* TLS Requirement */
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
tls_authenticate = director->tls_authenticate;
if (tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
if (director->tls_verify_peer) {
verify_list = director->tls_allowed_cns;
}
auth_success = cram_md5_challenge(ua, director->password, tls_local_need,
compatible) &&
cram_md5_respond(ua, director->password, &tls_remote_need, &compatible);
} else {
unbash_spaces(name);
cons = (CONRES *)GetResWithName(R_CONSOLE, name);
if (cons) {
/* TLS Requirement */
if (cons->tls_enable) {
if (cons->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
tls_authenticate = cons->tls_authenticate;
if (tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
if (cons->tls_verify_peer) {
verify_list = cons->tls_allowed_cns;
}
auth_success = cram_md5_challenge(ua, cons->password, tls_local_need,
compatible) &&
cram_md5_respond(ua, cons->password, &tls_remote_need, &compatible);
if (auth_success) {
uac->cons = cons; /* save console resource pointer */
}
} else {
auth_success = false;
goto auth_done;
}
}
/* Verify that the remote peer 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) {
Emsg0(M_FATAL, 0, _("Authorization problem:"
" Remote client did not advertise required TLS support.\n"));
auth_success = false;
goto auth_done;
}
/* Verify that we are willing to meet the peer's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
Emsg0(M_FATAL, 0, _("Authorization problem:"
" Remote client requires TLS.\n"));
auth_success = false;
goto auth_done;
}
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
if (cons) {
tls_ctx = cons->tls_ctx;
} else {
tls_ctx = director->tls_ctx;
}
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_server(tls_ctx, ua, verify_list)) {
Emsg0(M_ERROR, 0, _("TLS negotiation failed.\n"));
auth_success = false;
goto auth_done;
}
if (tls_authenticate) { /* authentication only? */
ua->free_tls(); /* stop tls */
}
}
/* Authorization Completed */
auth_done:
if (!auth_success) {
ua->fsend("%s", _(Dir_sorry));
Emsg4(M_ERROR, 0, _("Unable to authenticate console \"%s\" at %s:%s:%d.\n"),
name, ua->who(), ua->host(), ua->port());
sleep(5);
return 0;
}
ua->fsend(_("1000 OK: %s Version: %s (%s)\n"), my_name, VERSION, BDATE);
return 1;
}
int main(int argc, char *argv[])
{
int ch;
bool no_signals = true;
bool test_config = false;
app = new QApplication(argc, argv);
app->setQuitOnLastWindowClosed(true);
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
QTranslator qtTranslator;
qtTranslator.load(QString("qt_") + QLocale::system().name());
app->installTranslator(&qtTranslator);
QTranslator batTranslator;
batTranslator.load(QString("bat_") + QLocale::system().name());
app->installTranslator(&batTranslator);
#ifdef xENABLE_NLS
setlocale(LC_ALL, "");
bindtextdomain("bacula", LOCALEDIR);
textdomain("bacula");
#endif
init_stack_dump();
my_name_is(argc, argv, "bat");
init_msg(NULL, NULL);
working_directory = "/tmp";
struct sigaction sigignore;
sigignore.sa_flags = 0;
sigignore.sa_handler = SIG_IGN;
sigfillset(&sigignore.sa_mask);
sigaction(SIGPIPE, &sigignore, NULL);
sigaction(SIGUSR2, &sigignore, NULL);
while ((ch = getopt(argc, argv, "bc:d:r:st?")) != -1) {
switch (ch) {
case 'c': /* configuration file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'd':
debug_level = atoi(optarg);
if (debug_level <= 0)
debug_level = 1;
break;
case 's': /* turn off signals */
no_signals = true;
break;
case 't':
test_config = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (!no_signals) {
init_signals(terminate_console);
}
if (argc) {
usage();
}
OSDependentInit();
#ifdef HAVE_WIN32
WSA_Init(); /* Initialize Windows sockets */
#endif
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
config = new_config_parser();
parse_bat_config(config, configfile, M_ERROR_TERM);
if (init_crypto() != 0) {
Emsg0(M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n"));
}
if (!check_resources()) {
Emsg1(M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
}
mainWin = new MainWin;
mainWin->show();
return app->exec();
}
int main (int argc, char *argv[])
{
int ch;
char *jobids = (char *)"1";
char *path=NULL, *client=NULL;
uint64_t limit=0;
bool clean=false;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
Dmsg0(0, "Starting ing_test tool\n");
my_name_is(argc, argv, "ing_test");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "h:c:l:d:n:P:Su:vf:w:?j:p:f:T")) != -1) {
switch (ch) {
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'l':
limit = str_to_int64(optarg);
break;
case 'c':
client = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'p':
path = optarg;
break;
case 'f':
file = optarg;
break;
case 'j':
jobids = optarg;
break;
case 'T':
clean = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
if ((db = db_init_database(NULL, "ingres", db_name, db_user, db_password, db_host, 0, NULL)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
Dmsg1(0, "db_type=%s\n", db_get_type(db));
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
/*
* simple CRUD test including create/drop table
*/
Pmsg0(0, "\nsimple CRUD test...\n\n");
const char *stmt1[8] = {
"CREATE TABLE t1 ( c1 integer, c2 varchar(29))",
"INSERT INTO t1 VALUES (1, 'foo')",
"SELECT c1,c2 FROM t1",
"UPDATE t1 SET c2='bar' WHERE c1=1",
"SELECT * FROM t1",
"DELETE FROM t1 WHERE c2 LIKE '\%r'",
"SELECT * FROM t1",
"DROP TABLE t1"
};
int (*hndl1[8])(void*,int,char**) = {
NULL,
NULL,
test_handler,
NULL,
test_handler,
NULL,
test_handler,
NULL
};
for (int i=0; i<8; ++i) {
Pmsg1(0, "DB-Statement: %s\n",stmt1[i]);
if (!db_sql_query(db, stmt1[i], hndl1[i], NULL)) {
Emsg0(M_ERROR_TERM, 0, _("Stmt went wrong\n"));
}
}
/*
* simple SELECT tests without tables
*/
Pmsg0(0, "\nsimple SELECT tests without tables...\n\n");
const char *stmt2[8] = {
"SELECT 'Test of simple SELECT!'",
"SELECT 'Test of simple SELECT!' as Text",
"SELECT VARCHAR(LENGTH('Test of simple SELECT!'))",
"SELECT DBMSINFO('_version')",
"SELECT 'This is a ''quoting'' test with single quotes'",
"SELECT 'This is a \"quoting\" test with double quotes'",
"SELECT null",
"SELECT ''"
};
int (*hndl2[8])(void*,int,char**) = {
string_handler,
string_handler,
string_handler,
string_handler,
string_handler,
string_handler,
string_handler,
string_handler
};
for (int i=0; i<8; ++i) {
Pmsg1(0, "DB-Statement: %s\n",stmt2[i]);
if (!db_sql_query(db, stmt2[i], hndl2[i], NULL)) {
Emsg0(M_ERROR_TERM, 0, _("Stmt went wrong\n"));
}
}
/*
* testing aggregates like avg, max, sum
*/
Pmsg0(0, "\ntesting aggregates...\n\n");
const char *stmt[11] = {
"CREATE TABLE t1 (c1 integer, c2 varchar(29))",
"INSERT INTO t1 VALUES (1,'foo')",
"INSERT INTO t1 VALUES (2,'bar')",
"INSERT INTO t1 VALUES (3,'fun')",
"INSERT INTO t1 VALUES (4,'egg')",
"SELECT max(c1) from t1",
"SELECT sum(c1) from t1",
"INSERT INTO t1 VALUES (5,NULL)",
"SELECT count(*) from t1",
"SELECT count(c2) from t1",
"DROP TABLE t1"
};
int (*hndl[11])(void*,int,char**) = {
NULL,
NULL,
NULL,
NULL,
NULL,
string_handler,
string_handler,
NULL,
string_handler,
string_handler,
NULL
};
for (int i=0; i<11; ++i) {
Pmsg1(0, "DB-Statement: %s\n",stmt[i]);
if (!db_sql_query(db, stmt[i], hndl[i], NULL)) {
Emsg0(M_ERROR_TERM, 0, _("Stmt went wrong\n"));
}
}
/*
* datatypes test
*/
Pmsg0(0, "\ndatatypes test... (TODO)\n\n");
Dmsg0(200, "DB-Statement: CREATE TABLE for datatypes\n");
if (!db_sql_query(db, "CREATE TABLE t2 ("
"c1 integer,"
"c2 varchar(255),"
"c3 char(255)"
/* some more datatypes... "c4 ," */
")" , NULL, NULL)) {
Emsg0(M_ERROR_TERM, 0, _("CREATE-Stmt went wrong\n"));
}
Dmsg0(200, "DB-Statement: DROP TABLE for datatypes\n");
if (!db_sql_query(db, "DROP TABLE t2", NULL, NULL)) {
Emsg0(M_ERROR_TERM, 0, _("DROP-Stmt went wrong\n"));
}
db_close_database(NULL, db);
db_flush_backends();
Dmsg0(200, "Database closed\n");
return 0;
}
/*
* Open a volume using libdroplet.
*/
int object_store_device::d_open(const char *pathname, int flags, int mode)
{
dpl_status_t status;
dpl_vfile_flag_t dpl_flags;
dpl_option_t dpl_options;
#if 1
Mmsg1(errmsg, _("Object Storage devices are not yet supported, please disable %s\n"), dev_name);
return -1;
#endif
/*
* Initialize the droplet library when its not done previously.
*/
P(mutex);
if (droplet_reference_count == 0) {
status = dpl_init();
if (status != DPL_SUCCESS) {
V(mutex);
return -1;
}
dpl_set_log_func(object_store_logfunc);
droplet_reference_count++;
}
V(mutex);
if (!m_object_configstring) {
int len;
char *bp, *next_option;
bool done;
if (!dev_options) {
Mmsg0(errmsg, _("No device options configured\n"));
Emsg0(M_FATAL, 0, errmsg);
return -1;
}
m_object_configstring = bstrdup(dev_options);
bp = m_object_configstring;
while (bp) {
next_option = strchr(bp, ',');
if (next_option) {
*next_option++ = '\0';
}
done = false;
for (int i = 0; !done && device_options[i].name; i++) {
/*
* Try to find a matching device option.
*/
if (bstrncasecmp(bp, device_options[i].name, device_options[i].compare_size)) {
switch (device_options[i].type) {
case argument_profile:
m_profile = bp + device_options[i].compare_size;
done = true;
break;
case argument_bucket:
m_object_bucketname = bp + device_options[i].compare_size;
done = true;
break;
default:
break;
}
}
}
if (!done) {
Mmsg1(errmsg, _("Unable to parse device option: %s\n"), bp);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
bp = next_option;
}
if (!m_profile) {
Mmsg0(errmsg, _("No droplet profile configured\n"));
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
/*
* Strip any .profile prefix from the libdroplet profile name.
*/
len = strlen(m_profile);
if (len > 8 && bstrcasecmp(m_profile + (len - 8), ".profile")) {
m_profile[len - 8] = '\0';
}
}
/*
* See if we need to setup a new context for this device.
*/
if (!m_ctx) {
char *bp;
/*
* See if this is a path.
*/
bp = strrchr(m_object_configstring, '/');
if (!bp) {
/*
* Only a profile name.
*/
m_ctx = dpl_ctx_new(NULL, m_object_configstring);
} else {
if (bp == m_object_configstring) {
/*
* Profile in root of filesystem
*/
m_ctx = dpl_ctx_new("/", bp + 1);
} else {
/*
* Profile somewhere else.
*/
*bp++ = '\0';
m_ctx = dpl_ctx_new(m_object_configstring, bp);
}
}
/*
* If we failed to allocate a new context fail the open.
*/
if (!m_ctx) {
Mmsg1(errmsg, _("Failed to create a new context using config %s\n"), dev_options);
return -1;
}
/*
* Login if that is needed for this backend.
*/
status = dpl_login(m_ctx);
switch (status) {
case DPL_SUCCESS:
break;
case DPL_ENOTSUPP:
/*
* Backend doesn't support login which is fine.
*/
break;
default:
Mmsg2(errmsg, _("Failed to login for voume %s using dpl_login(): ERR=%s.\n"),
getVolCatName(), dpl_status_str(status));
return -1;
}
/*
* If a bucketname was defined set it in the context.
*/
if (m_object_bucketname) {
m_ctx->cur_bucket = m_object_bucketname;
}
}
/*
* See if we don't have a file open already.
*/
if (m_vfd) {
dpl_close(m_vfd);
m_vfd = NULL;
}
/*
* Create some options for libdroplet.
*
* DPL_OPTION_NOALLOC - we provide the buffer to copy the data into
* no need to let the library allocate memory we
* need to free after copying the data.
*/
memset(&dpl_options, 0, sizeof(dpl_options));
dpl_options.mask |= DPL_OPTION_NOALLOC;
if (flags & O_CREAT) {
dpl_flags = DPL_VFILE_FLAG_CREAT | DPL_VFILE_FLAG_RDWR;
status = dpl_open(m_ctx, /* context */
getVolCatName(), /* locator */
dpl_flags, /* flags */
&dpl_options, /* options */
NULL, /* condition */
NULL, /* metadata */
NULL, /* sysmd */
NULL, /* query_params */
NULL, /* stream_status */
&m_vfd);
} else {
dpl_flags = DPL_VFILE_FLAG_RDWR;
status = dpl_open(m_ctx, /* context */
getVolCatName(), /* locator */
dpl_flags, /* flags */
&dpl_options, /* options */
NULL, /* condition */
NULL, /* metadata */
NULL, /* sysmd */
NULL, /* query_params */
NULL, /* stream_status */
&m_vfd);
}
switch (status) {
case DPL_SUCCESS:
m_offset = 0;
return 0;
default:
Mmsg2(errmsg, _("Failed to open %s using dpl_open(): ERR=%s.\n"),
getVolCatName(), dpl_status_str(status));
m_vfd = NULL;
return droplet_errno_to_system_errno(status);
}
bail_out:
return -1;
}
/*
* Foward space a file
*
* Returns: true on success
* false on failure
*/
bool generic_tape_device::fsf(int num)
{
int32_t os_file = 0;
struct mtop mt_com;
int status = 0;
if (!is_open()) {
dev_errno = EBADF;
Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
Emsg0(M_FATAL, 0, errmsg);
return false;
}
if (at_eot()) {
dev_errno = 0;
Mmsg1(errmsg, _("Device %s at End of Tape.\n"), prt_name);
return false;
}
if (at_eof()) {
Dmsg0(200, "ST_EOF set on entry to FSF\n");
}
Dmsg0(100, "fsf\n");
block_num = 0;
/*
* If Fast forward space file is set, then we
* use MTFSF to forward space and MTIOCGET
* to get the file position. We assume that
* the SCSI driver will ensure that we do not
* forward space past the end of the medium.
*/
if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
int my_errno = 0;
mt_com.mt_op = MTFSF;
mt_com.mt_count = num;
status = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
if (status < 0) {
my_errno = errno; /* save errno */
} else if ((os_file=get_os_tape_file()) < 0) {
my_errno = errno; /* save errno */
}
if (my_errno != 0) {
berrno be;
set_eot();
Dmsg0(200, "Set ST_EOT\n");
clrerror(mt_com.mt_op);
Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"), prt_name, be.bstrerror(my_errno));
Dmsg1(200, "%s", errmsg);
return false;
}
Dmsg1(200, "fsf file=%d\n", os_file);
set_ateof();
file = os_file;
return true;
/*
* Here if CAP_FSF is set, and virtually all drives
* these days support it, we read a record, then forward
* space one file. Using this procedure, which is slow,
* is the only way we can be sure that we don't read
* two consecutive EOF marks, which means End of Data.
*/
} else if (has_cap(CAP_FSF)) {
POOLMEM *rbuf;
int rbuf_len;
Dmsg0(200, "FSF has cap_fsf\n");
if (max_block_size == 0) {
rbuf_len = DEFAULT_BLOCK_SIZE;
} else {
rbuf_len = max_block_size;
}
rbuf = get_memory(rbuf_len);
mt_com.mt_op = MTFSF;
mt_com.mt_count = 1;
while (num-- && !at_eot()) {
Dmsg0(100, "Doing read before fsf\n");
if ((status = this->read((char *)rbuf, rbuf_len)) < 0) {
if (errno == ENOMEM) { /* tape record exceeds buf len */
status = rbuf_len; /* This is OK */
/*
* On IBM drives, they return ENOSPC at EOM instead of EOF status
*/
} else if (at_eof() && errno == ENOSPC) {
status = 0;
} else if (has_cap(CAP_IOERRATEOM) && at_eof() && errno == EIO) {
if (has_cap(CAP_IBMLINTAPE)) {
Dmsg0(100, "Got EIO on read, checking lin_tape sense data\n");
if (check_scsi_at_eod(m_fd)) {
Dmsg0(100, "Sense data confirms it's EOD\n");
status = 0;
} else {
Dmsg0(100, "Not at EOD, might be a real error. Check sense trace from lin_taped logs.\n");
set_eot();
clrerror(-1);
Mmsg1(errmsg, _("read error on %s. ERR=Input/Output error.\n"), prt_name);
break;
}
} else {
Dmsg0(100, "Got EIO on read, assuming that's due to EOD\n");
status = 0;
}
} else {
berrno be;
set_eot();
clrerror(-1);
Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno, be.bstrerror());
Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"), prt_name, be.bstrerror());
Dmsg1(100, "%s", errmsg);
break;
}
}
if (status == 0) { /* EOF */
Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
/*
* Two reads of zero means end of tape
*/
if (at_eof()) {
set_eot();
Dmsg0(100, "Set ST_EOT\n");
break;
} else {
set_ateof();
continue;
}
} else { /* Got data */
clear_eot();
clear_eof();
}
Dmsg0(100, "Doing MTFSF\n");
status = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
if (status < 0) { /* error => EOT */
berrno be;
set_eot();
Dmsg0(100, "Set ST_EOT\n");
clrerror(mt_com.mt_op);
Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"), prt_name, be.bstrerror());
Dmsg0(100, "Got < 0 for MTFSF\n");
Dmsg1(100, "%s", errmsg);
} else {
set_ateof();
}
}
free_memory(rbuf);
/*
* No FSF, so use FSR to simulate it
*/
} else {
Dmsg0(200, "Doing FSR for FSF\n");
while (num-- && !at_eot()) {
fsr(INT32_MAX); /* returns -1 on EOF or EOT */
}
if (at_eot()) {
dev_errno = 0;
Mmsg1(errmsg, _("Device %s at End of Tape.\n"), prt_name);
status = -1;
} else {
status = 0;
}
}
Dmsg1(200, "Return %d from FSF\n", status);
if (at_eof()) {
Dmsg0(200, "ST_EOF set on exit FSF\n");
}
if (at_eot()) {
Dmsg0(200, "ST_EOT set on exit FSF\n");
}
Dmsg1(200, "Return from FSF file=%d\n", file);
return status == 0;
}
/*
* If implemented in system, clear the tape error status.
*/
void generic_tape_device::clrerror(int func)
{
const char *msg = NULL;
char buf[100];
dev_errno = errno; /* save errno */
if (errno == EIO) {
VolCatInfo.VolCatErrors++;
}
if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
switch (func) {
case -1:
break; /* ignore message printed later */
case MTWEOF:
msg = "WTWEOF";
clear_cap(CAP_EOF); /* turn off feature */
break;
#ifdef MTEOM
case MTEOM:
msg = "WTEOM";
clear_cap(CAP_EOM); /* turn off feature */
break;
#endif
case MTFSF:
msg = "MTFSF";
clear_cap(CAP_FSF); /* turn off feature */
break;
case MTBSF:
msg = "MTBSF";
clear_cap(CAP_BSF); /* turn off feature */
break;
case MTFSR:
msg = "MTFSR";
clear_cap(CAP_FSR); /* turn off feature */
break;
case MTBSR:
msg = "MTBSR";
clear_cap(CAP_BSR); /* turn off feature */
break;
case MTREW:
msg = "MTREW";
break;
#ifdef MTSETBLK
case MTSETBLK:
msg = "MTSETBLK";
break;
#endif
#ifdef MTSETDRVBUFFER
case MTSETDRVBUFFER:
msg = "MTSETDRVBUFFER";
break;
#endif
#ifdef MTRESET
case MTRESET:
msg = "MTRESET";
break;
#endif
#ifdef MTSETBSIZ
case MTSETBSIZ:
msg = "MTSETBSIZ";
break;
#endif
#ifdef MTSRSZ
case MTSRSZ:
msg = "MTSRSZ";
break;
#endif
#ifdef MTLOAD
case MTLOAD:
msg = "MTLOAD";
break;
#endif
#ifdef MTLOCK
case MTLOCK:
msg = "MTLOCK";
break;
#endif
#ifdef MTUNLOCK
case MTUNLOCK:
msg = "MTUNLOCK";
break;
#endif
case MTOFFL:
msg = "MTOFFL";
break;
#ifdef MTIOCLRERR
case MTIOCLRERR:
msg = "MTIOCLRERR";
break;
#endif
#ifdef MTIOCERRSTAT
case MTIOCERRSTAT:
msg = "MTIOCERRSTAT";
break;
#endif
#ifdef MTCSE
case MTCSE:
msg = "MTCSE";
break;
#endif
default:
bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
msg = buf;
break;
}
if (msg != NULL) {
dev_errno = ENOSYS;
Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
Emsg0(M_ERROR, 0, errmsg);
}
}
/*
* Now we try different methods of clearing the error status on the drive
* so that it is not locked for further operations.
*/
/*
* On some systems such as NetBSD, this clears all errors
*/
get_os_tape_file();
/*
* OS specific clear function.
*/
os_clrerror(this);
}
/*
* Open a volume using gfapi.
*/
int gfapi_device::d_open(const char *pathname, int flags, int mode)
{
int status;
POOL_MEM virtual_filename(PM_FNAME);
/*
* Parse the gluster URI.
*/
if (!m_gfapi_volume) {
m_gfapi_volume = bstrdup(dev_name);
if (!parse_gfapi_devicename(m_gfapi_volume,
&m_transport,
&m_servername,
&m_volumename,
&m_basedir,
&m_serverport)) {
Mmsg1(errmsg, _("Unable to parse device URI %s.\n"), dev_name);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
}
/*
* See if we need to setup a Gluster context.
*/
if (!m_glfs) {
m_glfs = glfs_new(m_volumename);
if (!m_glfs) {
Mmsg1(errmsg, _("Unable to create new Gluster context for volumename %s.\n"), m_volumename);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
status = glfs_set_volfile_server(m_glfs, (m_transport) ? m_transport : "tcp", m_servername, m_serverport);
if (status < 0) {
Mmsg3(errmsg, _("Unable to initialize Gluster management server for transport %s, servername %s, serverport %d\n"),
(m_transport) ? m_transport : "tcp", m_servername, m_serverport);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
status = glfs_init(m_glfs);
if (status < 0) {
Mmsg1(errmsg, _("Unable to initialize Gluster for volumename %s.\n"), m_volumename);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
}
/*
* See if we don't have a file open already.
*/
if (m_gfd) {
glfs_close(m_gfd);
m_gfd = NULL;
}
/*
* See if we store in an explicit directory.
*/
if (m_basedir) {
struct stat st;
/*
* Make sure the dir exists if one is defined.
*/
Mmsg(virtual_filename, "/%s", m_basedir);
if (glfs_stat(m_glfs, virtual_filename.c_str(), &st) != 0) {
switch (errno) {
case ENOENT:
if (!gfapi_makedir(m_glfs, virtual_filename.c_str())) {
Mmsg1(errmsg, _("Specified glusterfs direcory %s cannot be created.\n"), virtual_filename.c_str());
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
break;
default:
goto bail_out;
}
} else {
if (!S_ISDIR(st.st_mode)) {
Mmsg1(errmsg, _("Specified glusterfs direcory %s is not a directory.\n"), virtual_filename.c_str());
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
}
Mmsg(virtual_filename, "/%s/%s", m_basedir, getVolCatName());
} else {
Mmsg(virtual_filename, "%s", getVolCatName());
}
/*
* See if the O_CREAT flag is set as glfs_open doesn't support that flag and you have to call glfs_creat then.
*/
if (flags & O_CREAT) {
m_gfd = glfs_creat(m_glfs, virtual_filename.c_str(), flags, mode);
} else {
m_gfd = glfs_open(m_glfs, virtual_filename.c_str(), flags);
}
if (!m_gfd) {
goto bail_out;
}
return 0;
bail_out:
/*
* Cleanup the Gluster context.
*/
if (m_glfs) {
glfs_fini(m_glfs);
m_glfs = NULL;
}
return -1;
}
int main (int argc, char *argv[])
{
int ch;
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
alist *backend_directories = NULL;
#endif
char *jobids = (char *)"1";
char *path=NULL, *client=NULL;
uint64_t limit=0;
bool clean=false;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
Dmsg0(0, "Starting bvfs_test tool\n");
my_name_is(argc, argv, "bvfs_test");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "h:c:l:d:D:n:P:Su:vf:w:?j:p:f:T")) != -1) {
switch (ch) {
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'D':
db_driver = optarg;
break;
case 'l':
limit = str_to_int64(optarg);
break;
case 'c':
client = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'p':
path = optarg;
break;
case 'f':
file = optarg;
break;
case 'j':
jobids = optarg;
break;
case 'T':
clean = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bvfs_test", sizeof(bjcr->Job));
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
backend_directories = New(alist(10, owned_by_alist));
backend_directories->append((char *)backend_directory);
db_set_backend_dirs(backend_directories);
#endif
if ((db = db_init_database(NULL, NULL, db_name, db_user, db_password, db_host, 0, NULL)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
Dmsg1(0, "db_type=%s\n", db_get_type(db));
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
if (clean) {
Pmsg0(0, "Clean old table\n");
db_sql_query(db, "DELETE FROM PathHierarchy", NULL, NULL);
db_sql_query(db, "UPDATE Job SET HasCache=0", NULL, NULL);
db_sql_query(db, "DELETE FROM PathVisibility", NULL, NULL);
bvfs_update_cache(bjcr, db);
}
Bvfs fs(bjcr, db);
fs.set_handler(result_handler, &fs);
fs.set_jobids(jobids);
fs.update_cache();
if (limit)
fs.set_limit(limit);
if (path) {
fs.ch_dir(path);
fs.ls_special_dirs();
fs.ls_dirs();
while (fs.ls_files()) {
fs.next_offset();
}
if (fnid && client) {
Pmsg0(0, "---------------------------------------------\n");
Pmsg1(0, "Getting file version for %s\n", file);
fs.get_all_file_versions(fs.get_pwd(), fnid, client);
}
exit (0);
}
Pmsg0(0, "list /\n");
fs.ch_dir("/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/\n");
fs.ch_dir("/tmp/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/regress/\n");
fs.ch_dir("/tmp/regress/");
fs.ls_special_dirs();
fs.ls_files();
fs.ls_dirs();
Pmsg0(0, "list /tmp/regress/build/\n");
fs.ch_dir("/tmp/regress/build/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
fs.get_all_file_versions(1, 347, "zog4-fd");
char p[200];
strcpy(p, "/tmp/toto/rep/");
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/toto/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
return 0;
}
int main (int argc, char *argv[])
{
int ch;
bool disable_batch = false;
char *restore_list=NULL;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
char **files = (char **) malloc (10 * sizeof(char *));
int i;
my_name_is(argc, argv, "bbatch");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "bBh:c:d:D:n:P:Su:vf:w:r:?")) != -1) {
switch (ch) {
case 'r':
restore_list=bstrdup(optarg);
break;
case 'B':
disable_batch = true;
break;
case 'b':
disable_batch = false;
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 'D':
db_driver = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'f':
if (nb < 10 ) {
files[nb++] = optarg;
}
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
if (restore_list) {
uint64_t nb_file=0;
btime_t start, end;
/* To use the -r option, the catalog should already contains records */
if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
db_host, 0, NULL, false, disable_batch)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
start = get_current_btime();
db_get_file_list(NULL, db, restore_list, false, false, list_handler, &nb_file);
end = get_current_btime();
Pmsg3(0, _("Computing file list for jobid=%s files=%lld secs=%d\n"),
restore_list, nb_file, (uint32_t)btime_to_unix(end-start));
free(restore_list);
return 0;
}
if (disable_batch) {
printf("Without new Batch mode\n");
} else {
printf("With new Batch mode\n");
}
i = nb;
while (--i >= 0) {
pthread_t thid;
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->bsr = NULL;
bjcr->VolSessionId = 1;
bjcr->VolSessionTime = (uint32_t)time(NULL);
bjcr->NumReadVolumes = 0;
bjcr->NumWriteVolumes = 0;
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->where = bstrdup(files[i]);
bjcr->job_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->job_name, "Dummy.Job.Name");
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bbatch", sizeof(bjcr->Job));
bjcr->fileset_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->fileset_name, "Dummy.fileset.name");
bjcr->fileset_md5 = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->fileset_md5, "Dummy.fileset.md5");
if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
db_host, 0, NULL, false, false)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
pthread_create(&thid, NULL, do_batch, bjcr);
}
while (nb > 0) {
bmicrosleep(1,0);
}
return 0;
}
/*
* If implemented in system, clear the tape
* error status.
*/
void DEVICE::clrerror(int func)
{
const char *msg = NULL;
char buf[100];
dev_errno = errno; /* save errno */
if (errno == EIO) {
VolCatInfo.VolCatErrors++;
}
if (!is_tape()) {
return;
}
if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
switch (func) {
case -1:
break; /* ignore message printed later */
case MTWEOF:
msg = "WTWEOF";
clear_cap(CAP_EOF); /* turn off feature */
break;
#ifdef MTEOM
case MTEOM:
msg = "WTEOM";
clear_cap(CAP_EOM); /* turn off feature */
break;
#endif
case MTFSF:
msg = "MTFSF";
clear_cap(CAP_FSF); /* turn off feature */
break;
case MTBSF:
msg = "MTBSF";
clear_cap(CAP_BSF); /* turn off feature */
break;
case MTFSR:
msg = "MTFSR";
clear_cap(CAP_FSR); /* turn off feature */
break;
case MTBSR:
msg = "MTBSR";
clear_cap(CAP_BSR); /* turn off feature */
break;
case MTREW:
msg = "MTREW";
break;
#ifdef MTSETBLK
case MTSETBLK:
msg = "MTSETBLK";
break;
#endif
#ifdef MTSETDRVBUFFER
case MTSETDRVBUFFER:
msg = "MTSETDRVBUFFER";
break;
#endif
#ifdef MTRESET
case MTRESET:
msg = "MTRESET";
break;
#endif
#ifdef MTSETBSIZ
case MTSETBSIZ:
msg = "MTSETBSIZ";
break;
#endif
#ifdef MTSRSZ
case MTSRSZ:
msg = "MTSRSZ";
break;
#endif
#ifdef MTLOAD
case MTLOAD:
msg = "MTLOAD";
break;
#endif
#ifdef MTUNLOCK
case MTUNLOCK:
msg = "MTUNLOCK";
break;
#endif
case MTOFFL:
msg = "MTOFFL";
break;
default:
bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
msg = buf;
break;
}
if (msg != NULL) {
dev_errno = ENOSYS;
Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
Emsg0(M_ERROR, 0, errmsg);
}
}
/*
* Now we try different methods of clearing the error
* status on the drive so that it is not locked for
* further operations.
*/
/* On some systems such as NetBSD, this clears all errors */
get_os_tape_file();
/* Found on Solaris */
#ifdef MTIOCLRERR
{
d_ioctl(m_fd, MTIOCLRERR);
Dmsg0(200, "Did MTIOCLRERR\n");
}
#endif
/* Typically on FreeBSD */
#ifdef MTIOCERRSTAT
{
berrno be;
/* Read and clear SCSI error status */
union mterrstat mt_errstat;
Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
be.bstrerror(dev_errno));
d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
}
#endif
/* Clear Subsystem Exception TRU64 */
#ifdef MTCSE
{
struct mtop mt_com;
mt_com.mt_op = MTCSE;
mt_com.mt_count = 1;
/* Clear any error condition on the tape */
d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
Dmsg0(200, "Did MTCSE\n");
}
#endif
}
/*
* Called here for each record from read_records()
*/
static bool record_cb(DCR *dcr, DEV_RECORD *rec)
{
int status;
JCR *jcr = dcr->jcr;
if (rec->FileIndex < 0) {
return true; /* we don't want labels */
}
/* File Attributes stream */
switch (rec->maskedStream) {
case STREAM_UNIX_ATTRIBUTES:
case STREAM_UNIX_ATTRIBUTES_EX:
/* If extracting, it was from previous stream, so
* close the output file.
*/
if (extract) {
if (!is_bopen(&bfd)) {
Emsg0(M_ERROR, 0, _("Logic error output file should be open but is not.\n"));
}
set_attributes(jcr, attr, &bfd);
extract = false;
}
if (!unpack_attributes_record(jcr, rec->Stream, rec->data, rec->data_len, attr)) {
Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
}
if (file_is_included(ff, attr->fname) && !file_is_excluded(ff, attr->fname)) {
attr->data_stream = decode_stat(attr->attr, &attr->statp, sizeof(attr->statp), &attr->LinkFI);
if (!is_restore_stream_supported(attr->data_stream)) {
if (!non_support_data++) {
Jmsg(jcr, M_ERROR, 0, _("%s stream not supported on this Client.\n"),
stream_to_ascii(attr->data_stream));
}
extract = false;
return true;
}
build_attr_output_fnames(jcr, attr);
if (attr->type == FT_DELETED) { /* TODO: choose the right fname/ofname */
Jmsg(jcr, M_INFO, 0, _("%s was deleted.\n"), attr->fname);
extract = false;
return true;
}
extract = false;
status = create_file(jcr, attr, &bfd, REPLACE_ALWAYS);
switch (status) {
case CF_ERROR:
case CF_SKIP:
break;
case CF_EXTRACT:
extract = true;
print_ls_output(jcr, attr);
num_files++;
fileAddr = 0;
break;
case CF_CREATED:
set_attributes(jcr, attr, &bfd);
print_ls_output(jcr, attr);
num_files++;
fileAddr = 0;
break;
}
}
break;
case STREAM_RESTORE_OBJECT:
/* nothing to do */
break;
/* Data stream and extracting */
case STREAM_FILE_DATA:
case STREAM_SPARSE_DATA:
case STREAM_WIN32_DATA:
if (extract) {
if (rec->maskedStream == STREAM_SPARSE_DATA) {
ser_declare;
uint64_t faddr;
wbuf = rec->data + OFFSET_FADDR_SIZE;
wsize = rec->data_len - OFFSET_FADDR_SIZE;
ser_begin(rec->data, OFFSET_FADDR_SIZE);
unser_uint64(faddr);
if (fileAddr != faddr) {
fileAddr = faddr;
if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Seek error on %s: %s\n"),
attr->ofname, be.bstrerror());
}
}
} else {
wbuf = rec->data;
wsize = rec->data_len;
}
total += wsize;
Dmsg2(8, "Write %u bytes, total=%u\n", wsize, total);
store_data(&bfd, wbuf, wsize);
fileAddr += wsize;
}
break;
/* GZIP data stream */
case STREAM_GZIP_DATA:
case STREAM_SPARSE_GZIP_DATA:
case STREAM_WIN32_GZIP_DATA:
#ifdef HAVE_LIBZ
if (extract) {
uLong compress_len = compress_buf_size;
int status = Z_BUF_ERROR;
if (rec->maskedStream == STREAM_SPARSE_GZIP_DATA) {
ser_declare;
uint64_t faddr;
char ec1[50];
wbuf = rec->data + OFFSET_FADDR_SIZE;
wsize = rec->data_len - OFFSET_FADDR_SIZE;
ser_begin(rec->data, OFFSET_FADDR_SIZE);
unser_uint64(faddr);
if (fileAddr != faddr) {
fileAddr = faddr;
if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {
berrno be;
Emsg3(M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
edit_uint64(fileAddr, ec1), attr->ofname, be.bstrerror());
extract = false;
return true;
}
}
} else {
wbuf = rec->data;
wsize = rec->data_len;
}
while (compress_len < 10000000 && (status = uncompress((Byte *)compress_buf, &compress_len,
(const Byte *)wbuf, (uLong)wsize)) == Z_BUF_ERROR) {
/* The buffer size is too small, try with a bigger one */
compress_len = 2 * compress_len;
compress_buf = check_pool_memory_size(compress_buf,
compress_len);
}
if (status != Z_OK) {
Emsg1(M_ERROR, 0, _("Uncompression error. ERR=%d\n"), status);
extract = false;
return true;
}
Dmsg2(100, "Write uncompressed %d bytes, total before write=%d\n", compress_len, total);
store_data(&bfd, compress_buf, compress_len);
total += compress_len;
fileAddr += compress_len;
Dmsg2(100, "Compress len=%d uncompressed=%d\n", rec->data_len,
compress_len);
}
#else
if (extract) {
Emsg0(M_ERROR, 0, _("GZIP data stream found, but GZIP not configured!\n"));
extract = false;
return true;
}
#endif
break;
/* Compressed data stream */
case STREAM_COMPRESSED_DATA:
case STREAM_SPARSE_COMPRESSED_DATA:
case STREAM_WIN32_COMPRESSED_DATA:
if (extract) {
uint32_t comp_magic, comp_len;
uint16_t comp_level, comp_version;
#ifdef HAVE_LZO
lzo_uint compress_len;
const unsigned char *cbuf;
int r, real_compress_len;
#endif
if (rec->maskedStream == STREAM_SPARSE_COMPRESSED_DATA) {
ser_declare;
uint64_t faddr;
char ec1[50];
wbuf = rec->data + OFFSET_FADDR_SIZE;
wsize = rec->data_len - OFFSET_FADDR_SIZE;
ser_begin(rec->data, OFFSET_FADDR_SIZE);
unser_uint64(faddr);
if (fileAddr != faddr) {
fileAddr = faddr;
if (blseek(&bfd, (boffset_t)fileAddr, SEEK_SET) < 0) {
berrno be;
Emsg3(M_ERROR, 0, _("Seek to %s error on %s: ERR=%s\n"),
edit_uint64(fileAddr, ec1), attr->ofname, be.bstrerror());
extract = false;
return true;
}
}
} else {
wbuf = rec->data;
wsize = rec->data_len;
}
/* read compress header */
unser_declare;
unser_begin(wbuf, sizeof(comp_stream_header));
unser_uint32(comp_magic);
unser_uint32(comp_len);
unser_uint16(comp_level);
unser_uint16(comp_version);
Dmsg4(200, "Compressed data stream found: magic=0x%x, len=%d, level=%d, ver=0x%x\n", comp_magic, comp_len,
comp_level, comp_version);
/* version check */
if (comp_version != COMP_HEAD_VERSION) {
Emsg1(M_ERROR, 0, _("Compressed header version error. version=0x%x\n"), comp_version);
return false;
}
/* size check */
if (comp_len + sizeof(comp_stream_header) != wsize) {
Emsg2(M_ERROR, 0, _("Compressed header size error. comp_len=%d, msglen=%d\n"),
comp_len, wsize);
return false;
}
switch(comp_magic) {
#ifdef HAVE_LZO
case COMPRESS_LZO1X:
compress_len = compress_buf_size;
cbuf = (const unsigned char*) wbuf + sizeof(comp_stream_header);
real_compress_len = wsize - sizeof(comp_stream_header);
Dmsg2(200, "Comp_len=%d msglen=%d\n", compress_len, wsize);
while ((r=lzo1x_decompress_safe(cbuf, real_compress_len,
(unsigned char *)compress_buf, &compress_len, NULL)) == LZO_E_OUTPUT_OVERRUN)
{
/* The buffer size is too small, try with a bigger one */
compress_len = 2 * compress_len;
compress_buf = check_pool_memory_size(compress_buf,
compress_len);
}
if (r != LZO_E_OK) {
Emsg1(M_ERROR, 0, _("LZO uncompression error. ERR=%d\n"), r);
extract = false;
return true;
}
Dmsg2(100, "Write uncompressed %d bytes, total before write=%d\n", compress_len, total);
store_data(&bfd, compress_buf, compress_len);
total += compress_len;
fileAddr += compress_len;
Dmsg2(100, "Compress len=%d uncompressed=%d\n", rec->data_len, compress_len);
break;
#endif
default:
Emsg1(M_ERROR, 0, _("Compression algorithm 0x%x found, but not supported!\n"), comp_magic);
extract = false;
return true;
}
}
break;
case STREAM_MD5_DIGEST:
case STREAM_SHA1_DIGEST:
case STREAM_SHA256_DIGEST:
case STREAM_SHA512_DIGEST:
break;
case STREAM_SIGNED_DIGEST:
case STREAM_ENCRYPTED_SESSION_DATA:
// TODO landonf: Investigate crypto support in the storage daemon
break;
case STREAM_PROGRAM_NAMES:
case STREAM_PROGRAM_DATA:
if (!prog_name_msg) {
Pmsg0(000, _("Got Program Name or Data Stream. Ignored.\n"));
prog_name_msg++;
}
break;
case STREAM_UNIX_ACCESS_ACL: /* Deprecated Standard ACL attributes on UNIX */
case STREAM_UNIX_DEFAULT_ACL: /* Deprecated Default ACL attributes on UNIX */
case STREAM_ACL_AIX_TEXT:
case STREAM_ACL_DARWIN_ACCESS_ACL:
case STREAM_ACL_FREEBSD_DEFAULT_ACL:
case STREAM_ACL_FREEBSD_ACCESS_ACL:
case STREAM_ACL_HPUX_ACL_ENTRY:
case STREAM_ACL_IRIX_DEFAULT_ACL:
case STREAM_ACL_IRIX_ACCESS_ACL:
case STREAM_ACL_LINUX_DEFAULT_ACL:
case STREAM_ACL_LINUX_ACCESS_ACL:
case STREAM_ACL_TRU64_DEFAULT_ACL:
case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
case STREAM_ACL_TRU64_ACCESS_ACL:
case STREAM_ACL_SOLARIS_ACLENT:
case STREAM_ACL_SOLARIS_ACE:
case STREAM_ACL_AFS_TEXT:
case STREAM_ACL_AIX_AIXC:
case STREAM_ACL_AIX_NFS4:
case STREAM_ACL_FREEBSD_NFS4_ACL:
case STREAM_ACL_HURD_DEFAULT_ACL:
case STREAM_ACL_HURD_ACCESS_ACL:
if (extract) {
wbuf = rec->data;
wsize = rec->data_len;
pm_strcpy(acl_data.last_fname, attr->fname);
parse_acl_streams(jcr, &acl_data, rec->maskedStream, wbuf, wsize);
}
break;
case STREAM_XATTR_HURD:
case STREAM_XATTR_IRIX:
case STREAM_XATTR_TRU64:
case STREAM_XATTR_AIX:
case STREAM_XATTR_OPENBSD:
case STREAM_XATTR_SOLARIS_SYS:
case STREAM_XATTR_SOLARIS:
case STREAM_XATTR_DARWIN:
case STREAM_XATTR_FREEBSD:
case STREAM_XATTR_LINUX:
case STREAM_XATTR_NETBSD:
if (extract) {
wbuf = rec->data;
wsize = rec->data_len;
pm_strcpy(xattr_data.last_fname, attr->fname);
parse_xattr_streams(jcr, &xattr_data, rec->maskedStream, wbuf, wsize);
}
break;
case STREAM_NDMP_SEPERATOR:
break;
default:
/* If extracting, weird stream (not 1 or 2), close output file anyway */
if (extract) {
if (!is_bopen(&bfd)) {
Emsg0(M_ERROR, 0, _("Logic error output file should be open but is not.\n"));
}
set_attributes(jcr, attr, &bfd);
extract = false;
}
Jmsg(jcr, M_ERROR, 0, _("Unknown stream=%d ignored. This shouldn't happen!\n"),
rec->Stream);
break;
} /* end switch */
return true;
}
/*
* Write a Record to the block
*
* Returns: false on failure (none or partially written)
* true on success (all bytes written)
*
* and remainder returned in packet.
*
* We require enough room for the header, and we deal with
* two special cases. 1. Only part of the record may have
* been transferred the last time (when remainder is
* non-zero), and 2. The remaining bytes to write may not
* all fit into the block.
*/
bool write_record_to_block(DCR *dcr, DEV_RECORD *rec)
{
ssize_t n;
bool retval = false;
char buf1[100], buf2[100];
DEV_BLOCK *block = dcr->block;
/*
* After this point the record is in nrec not rec e.g. its either converted
* or is just a pointer to the same as the rec pointer being passed in.
*/
while (1) {
ASSERT(block->binbuf == (uint32_t)(block->bufp - block->buf));
ASSERT(block->buf_len >= block->binbuf);
Dmsg9(890, "%s() state=%d (%s) FI=%s SessId=%d Strm=%s len=%d "
"block_navail=%d remainder=%d\n",
__func__, rec->state, record_state_to_ascii(rec->state),
FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
block_write_navail(block), rec->remainder);
switch (rec->state) {
case st_none:
/*
* Figure out what to do
*/
rec->state = st_header;
rec->remainder = rec->data_len; /* length of data remaining to write */
continue; /* goto st_header */
case st_header:
/*
* Write header
*/
n = write_header_to_block(block, rec, rec->Stream);
if (n < 0) {
/*
* the header did not fit into the block, so flush the current
* block and come back to st_header and try again on the next block.
*/
goto bail_out;
}
if (block_write_navail(block) == 0) {
/*
* The header fit, but no bytes of data will fit,
* so flush this block and start the next block with a
* continuation header.
*/
rec->state = st_header_cont;
goto bail_out;
}
/*
* The header fit, and at least one byte of data will fit,
* so move to the st_data state and start filling the block
* with data bytes
*/
rec->state = st_data;
continue;
case st_header_cont:
/*
* Write continuation header
*/
n = write_header_to_block(block, rec, -rec->Stream);
if (n < 0) {
/*
* The continuation header wouldn't fit, which is impossible
* unless something is broken
*/
Emsg0(M_ABORT, 0, _("couldn't write continuation header\n"));
}
/*
* After successfully writing a continuation header, we always start writing
* data, even if none will fit into this block.
*/
rec->state = st_data;
if (block_write_navail(block) == 0) {
/*
* The header fit, but no bytes of data will fit,
* so flush the block and start the next block with
* data bytes
*/
goto bail_out; /* Partial transfer */
}
continue;
case st_data:
/*
* Write normal data
*
* Part of it may have already been transferred, and we
* may not have enough room to transfer the whole this time.
*/
if (rec->remainder > 0) {
n = write_data_to_block(block, rec);
if (n < 0) {
/*
* error appending data to block should be impossible
* unless something is broken
*/
Emsg0(M_ABORT, 0, _("data write error\n"));
}
rec->remainder -= n;
if (rec->remainder > 0) {
/*
* Could not fit all of the data bytes into this block, so
* flush the current block, and start the next block with a
* continuation header
*/
rec->state = st_header_cont;
goto bail_out;
}
}
rec->remainder = 0; /* did whole transfer */
rec->state = st_none;
retval = true;
goto bail_out;
default:
Emsg1(M_ABORT, 0, _("Something went wrong. Unknown state %d.\n"), rec->state);
rec->state = st_none;
retval = true;
goto bail_out;
}
}
bail_out:
return retval;
}
/*
* Truncate a volume. If this is aligned disk, we
* truncate both volumes.
*/
bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
{
struct stat st;
DEVICE *dev = this;
Dmsg1(100, "truncate %s\n", print_name());
switch (dev_type) {
case B_VTL_DEV:
case B_VTAPE_DEV:
case B_TAPE_DEV:
/* maybe we should rewind and write and eof ???? */
return true; /* we don't really truncate tapes */
case B_FILE_DEV:
Dmsg1(100, "Truncate fd=%d\n", dev->m_fd);
if (ftruncate(dev->m_fd, 0) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
print_name(), be.bstrerror());
return false;
}
/*
* Check for a successful ftruncate() and issue a work-around for devices
* (mostly cheap NAS) that don't support truncation.
* Workaround supplied by Martin Schmid as a solution to bug #1011.
* 1. close file
* 2. delete file
* 3. open new file with same mode
* 4. change ownership to original
*/
if (fstat(dev->m_fd, &st) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
print_name(), be.bstrerror());
return false;
}
if (st.st_size != 0) { /* ftruncate() didn't work */
POOL_MEM archive_name(PM_FNAME);
pm_strcpy(archive_name, dev_name);
if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
pm_strcat(archive_name, "/");
}
pm_strcat(archive_name, dcr->VolumeName);
Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
print_name(), archive_name.c_str());
/* Close file and blow it away */
::close(dev->m_fd);
::unlink(archive_name.c_str());
/* Recreate the file -- of course, empty */
dev->set_mode(CREATE_READ_WRITE);
if ((dev->m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
berrno be;
dev_errno = errno;
Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
be.bstrerror());
Dmsg1(40, "reopen failed: %s", errmsg);
Emsg0(M_FATAL, 0, errmsg);
return false;
}
/* Reset proper owner */
chown(archive_name.c_str(), st.st_uid, st.st_gid);
}
return true;
}
return false;
}
bool win32_file_device::d_truncate(DCR *dcr)
{
struct stat st;
if (ftruncate(m_fd, 0) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"), print_name(), be.bstrerror());
return false;
}
/*
* Check for a successful ftruncate() and issue a work-around for devices
* (mostly cheap NAS) that don't support truncation.
* Workaround supplied by Martin Schmid as a solution to bug #1011.
* 1. close file
* 2. delete file
* 3. open new file with same mode
* 4. change ownership to original
*/
if (fstat(m_fd, &st) != 0) {
berrno be;
Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"), print_name(), be.bstrerror());
return false;
}
if (st.st_size != 0) { /* ftruncate() didn't work */
POOL_MEM archive_name(PM_FNAME);
pm_strcpy(archive_name, dev_name);
if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
pm_strcat(archive_name, "/");
}
pm_strcat(archive_name, dcr->VolumeName);
Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
print_name(), archive_name.c_str());
/*
* Close file and blow it away
*/
::close(m_fd);
::unlink(archive_name.c_str());
/*
* Recreate the file -- of course, empty
*/
oflags = O_CREAT | O_RDWR | O_BINARY;
if ((m_fd = ::open(archive_name.c_str(), oflags, st.st_mode)) < 0) {
berrno be;
dev_errno = errno;
Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(), be.bstrerror());
Dmsg1(100, "reopen failed: %s", errmsg);
Emsg0(M_FATAL, 0, errmsg);
return false;
}
/*
* Reset proper owner
*/
chown(archive_name.c_str(), st.st_uid, st.st_gid);
}
return true;
}
static bRC do_set_scsi_encryption_key(void *value)
{
DCR *dcr;
DEVICE *dev;
DEVRES *device;
DIRRES *director;
char StoredVolEncrKey[MAX_NAME_LENGTH];
char VolEncrKey[MAX_NAME_LENGTH];
/*
* Unpack the arguments passed in.
*/
dcr = (DCR *)value;
if (!dcr) {
return bRC_Error;
}
dev = dcr->dev;
if (!dev) {
return bRC_Error;
}
device = dev->device;
if (!device) {
return bRC_Error;
}
*StoredVolEncrKey = '\0';
if (!get_volume_encryption_key(dcr, StoredVolEncrKey)) {
return bRC_Error;
}
/*
* See if a volume encryption key is available.
*/
if (!*StoredVolEncrKey) {
Dmsg0(dbglvl, "scsicrypto-sd: No encryption key to load on device\n");
return bRC_OK;
}
/*
* See if device supports hardware encryption.
*/
if (!device->drive_crypto_enabled) {
Dmsg0(dbglvl, "scsicrypto-sd: Trying to load encryption key on drive without support\n");
Emsg0(M_ERROR, 0,
_("scsicrypto-sd: Trying to load encryption key on drive without support\n"));
return bRC_Error;
}
/*
* The key passed from the director to the storage daemon is always base64 encoded.
*/
base64_to_bin(VolEncrKey, sizeof(VolEncrKey), StoredVolEncrKey, strlen(StoredVolEncrKey));
/*
* See if we have an key encryption key in the config then the passed key
* has been wrapped using RFC3394 key wrapping. We first copy the current
* wrapped key into a temporary variable for unwrapping.
*/
if (dcr->jcr && dcr->jcr->director) {
director = dcr->jcr->director;
if (director->keyencrkey) {
char WrappedVolEncrKey[MAX_NAME_LENGTH];
memcpy(WrappedVolEncrKey, VolEncrKey, MAX_NAME_LENGTH);
memset(VolEncrKey, 0, MAX_NAME_LENGTH);
if (aes_unwrap((unsigned char *)director->keyencrkey,
DEFAULT_PASSPHRASE_LENGTH / 8,
(unsigned char *)WrappedVolEncrKey,
(unsigned char *)VolEncrKey) != 0) {
Dmsg1(dbglvl,
"scsicrypto-sd: Failed to unwrap encryption key using %s\n", director->keyencrkey);
Emsg0(M_ERROR, 0,
_("scsicrypto-sd: Failed to unwrap encryption key, probably wrong KeyEncryptionKey in config\n"));
return bRC_Error;
}
}
}
Dmsg1(dbglvl, "scsicrypto-sd: Loading new crypto key %s\n", VolEncrKey);
P(crypto_operation_mutex);
if (set_scsi_encryption_key(dev->fd(), dev->dev_name, VolEncrKey)) {
dev->set_crypto_enabled();
V(crypto_operation_mutex);
return bRC_OK;
} else {
V(crypto_operation_mutex);
return bRC_Error;
}
}