bool RUNSCRIPT::run(JCR *jcr, const char *name)
{
Dmsg1(100, "runscript: running a RUNSCRIPT object type=%d\n", cmd_type);
POOLMEM *ecmd = get_pool_memory(PM_FNAME);
int status;
BPIPE *bpipe;
POOL_MEM line(PM_NAME);
ecmd = edit_job_codes(jcr, ecmd, this->command, "", this->job_code_callback);
Dmsg1(100, "runscript: running '%s'...\n", ecmd);
Jmsg(jcr, M_INFO, 0, _("%s: run %s \"%s\"\n"),
cmd_type==SHELL_CMD?"shell command":"console command", name, ecmd);
switch (cmd_type) {
case SHELL_CMD:
bpipe = open_bpipe(ecmd, 0, "r");
free_pool_memory(ecmd);
if (bpipe == NULL) {
berrno be;
Jmsg(jcr, M_ERROR, 0, _("Runscript: %s could not execute. ERR=%s\n"), name,
be.bstrerror());
goto bail_out;
}
while (fgets(line.c_str(), line.size(), bpipe->rfd)) {
strip_trailing_junk(line.c_str());
Jmsg(jcr, M_INFO, 0, _("%s: %s\n"), name, line.c_str());
}
status = close_bpipe(bpipe);
if (status != 0) {
berrno be;
Jmsg(jcr, M_ERROR, 0, _("Runscript: %s returned non-zero status=%d. ERR=%s\n"), name,
be.code(status), be.bstrerror(status));
goto bail_out;
}
Dmsg0(100, "runscript OK\n");
break;
case CONSOLE_CMD:
if (console_command) { /* can we run console command? */
if (!console_command(jcr, ecmd)) { /* yes, do so */
goto bail_out;
}
}
break;
}
return true;
bail_out:
/* cancel running job properly */
if (fail_on_error) {
jcr->setJobStatus(JS_ErrorTerminated);
}
Dmsg1(100, "runscript failed. fail_on_error=%d\n", fail_on_error);
return false;
}
/*
* Return 1 if OK
* 0 if no input
* -1 error (must stop)
*/
int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec)
{
static char *line = NULL;
static char *next = NULL;
static int do_history = 0;
char *command;
if (line == NULL) {
do_history = 0;
rl_catch_signals = 0; /* do it ourselves */
/* Here, readline does ***real*** malloc
* so, be we have to use the real free
*/
line = readline((char *)prompt); /* cast needed for old readlines */
if (!line) {
return -1; /* error return and exit */
}
strip_trailing_junk(line);
command = line;
} else if (next) {
command = next + 1;
} else {
sendit(_("Command logic problem\n"));
sock->msglen = 0;
sock->msg[0] = 0;
return 0; /* No input */
}
/*
* Split "line" into multiple commands separated by the eol character.
* Each part is pointed to by "next" until finally it becomes null.
*/
if (eol == '\0') {
next = NULL;
} else {
next = strchr(command, eol);
if (next) {
*next = '\0';
}
}
if (command != line && isatty(fileno(input))) {
senditf("%s%s\n", prompt, command);
}
sock->msglen = pm_strcpy(&sock->msg, command);
if (sock->msglen) {
do_history++;
}
if (!next) {
if (do_history) {
add_history(line);
}
actuallyfree(line); /* allocated by readline() malloc */
line = NULL;
}
return 1; /* OK */
}
/* retreive a simple list (.pool, .client) and store it into items */
void get_items(const char *what)
{
init_items();
UA_sock->fsend("%s", what);
while (UA_sock->recv() > 0) {
strip_trailing_junk(UA_sock->msg);
items->list.append(bstrdup(UA_sock->msg));
}
}
/*
* 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;
}
void get_list(monitoritem *item, const char *cmd, QStringList &lst)
{
int stat;
doconnect(item);
item->writecmd(cmd);
while((stat = item->D_sock->recv()) >= 0) {
strip_trailing_junk(item->D_sock->msg);
if (*(item->D_sock->msg)) {
lst << QString(item->D_sock->msg);
}
}
}
void win_error(JCR *jcr, const char *prefix, POOLMEM *win32_ofile)
{
DWORD lerror = GetLastError();
LPTSTR msg;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
lerror,
0,
(LPTSTR)&msg,
0,
NULL);
Dmsg3(100, "Error in %s on file %s: ERR=%s\n", prefix, win32_ofile, msg);
strip_trailing_junk(msg);
Jmsg3(jcr, M_ERROR, 0, _("Error in %s file %s: ERR=%s\n"), prefix, win32_ofile, msg);
LocalFree(msg);
}
/*
* Get the JobId and FileIndexes of all files in the specified table
*/
static bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table)
{
strip_trailing_junk(table);
Mmsg(rx->query, uar_jobid_fileindex_from_table, table);
rx->found = false;
/* Find and insert jobid and File Index */
if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
ua->error_msg(_("Query failed: %s. ERR=%s\n"),
rx->query, db_strerror(ua->db));
}
if (!rx->found) {
ua->error_msg(_("No table found: %s\n"), table);
return true;
}
return true;
}
int do_shell_expansion(char *name, int name_len)
{
static char meta[] = "~\\$[]*?`'<>\"";
bool found = false;
int len, i, status;
POOLMEM *cmd;
BPIPE *bpipe;
char line[MAXSTRING];
const char *shellcmd;
/* Check if any meta characters are present */
len = strlen(meta);
for (i = 0; i < len; i++) {
if (strchr(name, meta[i])) {
found = true;
break;
}
}
if (found) {
cmd = get_pool_memory(PM_FNAME);
/* look for shell */
if ((shellcmd = getenv("SHELL")) == NULL) {
shellcmd = "/bin/sh";
}
pm_strcpy(&cmd, shellcmd);
pm_strcat(&cmd, " -c \"echo ");
pm_strcat(&cmd, name);
pm_strcat(&cmd, "\"");
Dmsg1(400, "Send: %s\n", cmd);
if ((bpipe = open_bpipe(cmd, 0, "r"))) {
*line = 0;
fgets(line, sizeof(line), bpipe->rfd);
strip_trailing_junk(line);
status = close_bpipe(bpipe);
Dmsg2(400, "status=%d got: %s\n", status, line);
} else {
status = 1; /* error */
}
free_pool_memory(cmd);
if (status == 0) {
bstrncpy(name, line, name_len);
}
}
return 1;
}
void win_error(JCR *jcr, const char *prefix, DWORD lerror)
{
LPTSTR msg;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
lerror,
0,
(LPTSTR)&msg,
0,
NULL);
strip_trailing_junk(msg);
if (jcr) {
Jmsg2(jcr, M_ERROR, 0, _("Error in %s: ERR=%s\n"), prefix, msg);
} else {
MessageBox(NULL, msg, prefix, MB_OK);
}
LocalFree(msg);
}
/*
* Get next input command from terminal.
*
* Returns: 1 if got input
* -1 if EOF or error
*/
int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec)
{
int len;
if (!stop) {
if (output == stdout || teeout) {
sendit(prompt);
}
}
again:
len = sizeof_pool_memory(sock->msg) - 1;
if (stop) {
sleep(1);
goto again;
}
#ifdef HAVE_CONIO
if (bisatty(fileno(input))) {
input_line(sock->msg, len);
goto ok_out;
}
#endif
if (input == stdin) {
if (win32_cgets(sock->msg, len) == NULL) {
return -1;
}
} else {
if (fgets(sock->msg, len, input) == NULL) {
return -1;
}
}
if (usrbrk()) {
clrbrk();
}
strip_trailing_junk(sock->msg);
sock->msglen = strlen(sock->msg);
return 1;
}
/*
* Get next input command from terminal.
*
* Returns: 1 if got input
* 0 if timeout
* -1 if EOF or error
*/
int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec)
{
int len;
if (!stop) {
if (output == stdout || teeout) {
sendit(prompt);
}
}
again:
switch (wait_for_readable_fd(fileno(input), sec, true)) {
case 0:
return 0; /* timeout */
case -1:
return -1; /* error */
default:
len = sizeof_pool_memory(sock->msg) - 1;
if (stop) {
sleep(1);
goto again;
}
#ifdef HAVE_CONIO
if (bisatty(fileno(input))) {
input_line(sock->msg, len);
break;
}
#endif
if (fgets(sock->msg, len, input) == NULL) {
return -1;
}
break;
}
if (usrbrk()) {
clrbrk();
}
strip_trailing_junk(sock->msg);
sock->msglen = strlen(sock->msg);
return 1;
}
/*
* Ask the autochanger to move a volume from one slot to an other.
* You have to update the database slots yourself afterwards.
*/
bool transfer_volume(UAContext *ua, STORERES *store, int src_slot, int dst_slot)
{
BSOCK *sd = NULL;
bool retval = true;
char dev_name[MAX_NAME_LENGTH];
if (!(sd = open_sd_bsock(ua))) {
return false;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/*
* Ask for autochanger transfer of volumes
*/
sd->fsend(changertransfercmd, dev_name, src_slot, dst_slot);
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] == ' ') {
/*
* See if this is a failure msg.
*/
if (sd->msg[0] == '3' && sd->msg[0] == '9')
retval = false;
ua->send_msg("%s\n", sd->msg); /* pass them on to user */
continue;
}
ua->send_msg("%s\n", sd->msg); /* pass them on to user */
}
close_sd_bsock(ua);
return retval;
}
/* fill the items list with the output of the help command */
void get_arguments(const char *what)
{
regex_t preg;
POOLMEM *buf;
int rc;
init_items();
rc = regcomp(&preg, "(([a-z_]+=)|([a-z]+)( |$))", REG_EXTENDED);
if (rc != 0) {
return;
}
buf = get_pool_memory(PM_MESSAGE);
UA_sock->fsend(".help item=%s", what);
while (UA_sock->recv() > 0) {
strip_trailing_junk(UA_sock->msg);
match_kw(&preg, UA_sock->msg, UA_sock->msglen, &buf);
}
free_pool_memory(buf);
regfree(&preg);
}
/*
* For a given path lookup the most recent backup in the catalog
* to get the JobId and FileIndexes of all files in that directory.
*/
static bool insert_dir_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *dir,
char *date)
{
strip_trailing_junk(dir);
if (*rx->JobIds == 0) {
ua->error_msg(_("No JobId specified cannot continue.\n"));
return false;
} else {
Mmsg(rx->query, uar_jobid_fileindex_from_dir[db_get_type_index(ua->db)], rx->JobIds, dir, rx->ClientName);
}
rx->found = false;
/* Find and insert jobid and File Index */
if (!db_sql_query(ua->db, rx->query, jobid_fileindex_handler, (void *)rx)) {
ua->error_msg(_("Query failed: %s. ERR=%s\n"),
rx->query, db_strerror(ua->db));
}
if (!rx->found) {
ua->error_msg(_("No database record found for: %s\n"), dir);
return true;
}
return true;
}
static void read_and_process_input(FILE *input, BSOCK *UA_sock)
{
const char *prompt = "*";
bool at_prompt = false;
int tty_input = isatty(fileno(input));
int status;
btimer_t *tid = NULL;
while (1) {
if (at_prompt) { /* don't prompt multiple times */
prompt = "";
} else {
prompt = "*";
at_prompt = true;
}
if (tty_input) {
status = get_cmd(input, prompt, UA_sock, 30);
if (usrbrk() == 1) {
clrbrk();
}
if (usrbrk()) {
break;
}
} else {
/*
* Reading input from a file
*/
int len = sizeof_pool_memory(UA_sock->msg) - 1;
if (usrbrk()) {
break;
}
if (fgets(UA_sock->msg, len, input) == NULL) {
status = -1;
} else {
sendit(UA_sock->msg); /* echo to terminal */
strip_trailing_junk(UA_sock->msg);
UA_sock->msglen = strlen(UA_sock->msg);
status = 1;
}
}
if (status < 0) {
break; /* error or interrupt */
} else if (status == 0) { /* timeout */
if (bstrcmp(prompt, "*")) {
tid = start_bsock_timer(UA_sock, timeout);
UA_sock->fsend(".messages");
stop_bsock_timer(tid);
} else {
continue;
}
} else {
at_prompt = false;
/*
* @ => internal command for us
*/
if (UA_sock->msg[0] == '@') {
parse_args(UA_sock->msg, &args, &argc, argk, argv, MAX_CMD_ARGS);
if (!do_a_command(input, UA_sock)) {
break;
}
continue;
}
tid = start_bsock_timer(UA_sock, timeout);
if (!UA_sock->send()) { /* send command */
stop_bsock_timer(tid);
break; /* error */
}
stop_bsock_timer(tid);
}
if (bstrcmp(UA_sock->msg, ".quit") || bstrcmp(UA_sock->msg, ".exit")) {
break;
}
tid = start_bsock_timer(UA_sock, timeout);
while ((status = UA_sock->recv()) >= 0 ||
((status == BNET_SIGNAL) && (
(UA_sock->msglen != BNET_EOD) &&
(UA_sock->msglen != BNET_MAIN_PROMPT) &&
(UA_sock->msglen != BNET_SUB_PROMPT)))) {
if (status == BNET_SIGNAL) {
if (UA_sock->msglen == BNET_START_RTREE) {
file_selection = true;
} else if (UA_sock->msglen == BNET_END_RTREE) {
file_selection = false;
}
continue;
}
if (at_prompt) {
if (!stop) {
sendit("\n");
}
at_prompt = false;
}
/*
* Suppress output if running in background or user hit ctl-c
*/
if (!stop && !usrbrk()) {
if (UA_sock->msg) {
sendit(UA_sock->msg);
}
}
}
stop_bsock_timer(tid);
if (usrbrk() > 1) {
break;
} else {
clrbrk();
}
if (!stop) {
fflush(stdout);
}
if (is_bnet_stop(UA_sock)) {
break; /* error or term */
} else if (status == BNET_SIGNAL) {
if (UA_sock->msglen == BNET_SUB_PROMPT) {
at_prompt = true;
}
Dmsg1(100, "Got poll %s\n", bnet_sig_to_ascii(UA_sock));
}
}
}
int main (int argc, char *argv[])
{
int i, ch;
FILE *fd;
char line[1000];
char *VolumeName = NULL;
char *bsrName = NULL;
char *DirectorName = NULL;
bool ignore_label_errors = false;
DIRRES *director = NULL;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
working_directory = "/tmp";
my_name_is(argc, argv, "bls");
init_msg(NULL, NULL); /* initialize message handler */
OSDependentInit();
ff = init_find_files();
while ((ch = getopt(argc, argv, "b:c:D:d:e:i:jkLpvV:?")) != -1) {
switch (ch) {
case 'b':
bsrName = optarg;
break;
case 'c': /* specify config file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'D': /* specify director name */
if (DirectorName != NULL) {
free(DirectorName);
}
DirectorName = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'e': /* exclude list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open exclude file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(100, "add_exclude %s\n", line);
add_fname_to_exclude_list(ff, line);
}
fclose(fd);
break;
case 'i': /* include list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open include file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(100, "add_include %s\n", line);
add_fname_to_include_list(ff, 0, line);
}
fclose(fd);
break;
case 'j':
list_jobs = true;
break;
case 'k':
list_blocks = true;
break;
case 'L':
dump_label = true;
break;
case 'p':
ignore_label_errors = true;
forge_on = true;
break;
case 'v':
verbose++;
break;
case 'V': /* Volume name */
VolumeName = optarg;
break;
case '?':
default:
usage();
} /* end switch */
} /* end while */
argc -= optind;
argv += optind;
if (!argc) {
Pmsg0(0, _("No archive name specified\n"));
usage();
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
LockRes();
me = (STORES *)GetNextRes(R_STORAGE, NULL);
if (!me) {
UnlockRes();
Emsg1(M_ERROR_TERM, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
configfile);
}
UnlockRes();
if (DirectorName) {
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, DirectorName)) {
break;
}
}
if (!director) {
Emsg2(M_ERROR_TERM, 0, _("No Director resource named %s defined in %s. Cannot continue.\n"),
DirectorName, configfile);
}
}
load_sd_plugins(me->plugin_directory, me->plugin_names);
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
if (ff->included_files_list == NULL) {
add_fname_to_include_list(ff, 0, "/");
}
for (i=0; i < argc; i++) {
if (bsrName) {
bsr = parse_bsr(NULL, bsrName);
}
jcr = setup_jcr("bls", argv[i], bsr, director, VolumeName, 1); /* acquire for read */
if (!jcr) {
exit(1);
}
jcr->ignore_label_errors = ignore_label_errors;
dev = jcr->dcr->dev;
if (!dev) {
exit(1);
}
dcr = jcr->dcr;
rec = new_record();
attr = new_attr(jcr);
/*
* Assume that we have already read the volume label.
* If on second or subsequent volume, adjust buffer pointer
*/
if (dev->VolHdr.PrevVolumeName[0] != 0) { /* second volume */
Pmsg1(0, _("\n"
"Warning, this Volume is a continuation of Volume %s\n"),
dev->VolHdr.PrevVolumeName);
}
if (list_blocks) {
do_blocks(argv[i]);
} else if (list_jobs) {
do_jobs(argv[i]);
} else {
do_ls(argv[i]);
}
do_close(jcr);
}
if (bsr) {
free_bsr(bsr);
}
term_include_exclude_files(ff);
term_find_files(ff);
return 0;
}
/*
* 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;
}
int main (int argc, char *argv[])
{
int ch;
FILE *fd;
char line[1000];
bool got_inc = false;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
working_directory = "/tmp";
my_name_is(argc, argv, "bextract");
init_msg(NULL, NULL); /* setup message handler */
OSDependentInit();
ff = init_find_files();
binit(&bfd);
while ((ch = getopt(argc, argv, "b:c:D:d:e:i:pvV:?")) != -1) {
switch (ch) {
case 'b': /* bootstrap file */
bsr = parse_bsr(NULL, optarg);
// dump_bsr(bsr, true);
break;
case 'c': /* specify config file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'D': /* specify director name */
if (DirectorName != NULL) {
free(DirectorName);
}
DirectorName = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'e': /* exclude list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open exclude file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(900, "add_exclude %s\n", line);
add_fname_to_exclude_list(ff, line);
}
fclose(fd);
break;
case 'i': /* include list */
if ((fd = fopen(optarg, "rb")) == NULL) {
berrno be;
Pmsg2(0, _("Could not open include file: %s, ERR=%s\n"),
optarg, be.bstrerror());
exit(1);
}
while (fgets(line, sizeof(line), fd) != NULL) {
strip_trailing_junk(line);
Dmsg1(900, "add_include %s\n", line);
add_fname_to_include_list(ff, 0, line);
}
fclose(fd);
got_inc = true;
break;
case 'p':
forge_on = true;
break;
case 'v':
verbose++;
break;
case 'V': /* Volume name */
VolumeName = optarg;
break;
case '?':
default:
usage();
} /* end switch */
} /* end while */
argc -= optind;
argv += optind;
if (argc != 2) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
config = new_config_parser();
parse_sd_config(config, configfile, M_ERROR_TERM);
LockRes();
me = (STORES *)GetNextRes(R_STORAGE, NULL);
if (!me) {
UnlockRes();
Emsg1(M_ERROR_TERM, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
configfile);
}
UnlockRes();
if (DirectorName) {
foreach_res(director, R_DIRECTOR) {
if (bstrcmp(director->hdr.name, DirectorName)) {
break;
}
}
if (!director) {
Emsg2(M_ERROR_TERM, 0, _("No Director resource named %s defined in %s. Cannot continue.\n"),
DirectorName, configfile);
}
}
load_sd_plugins(me->plugin_directory);
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->sdaddrs));
if (!got_inc) { /* If no include file, */
add_fname_to_include_list(ff, 0, "/"); /* include everything */
}
where = argv[1];
do_extract(argv[0]);
if (bsr) {
free_bsr(bsr);
}
if (prog_name_msg) {
Pmsg1(000, _("%d Program Name and/or Program Data Stream records ignored.\n"),
prog_name_msg);
}
if (win32_data_msg) {
Pmsg1(000, _("%d Win32 data or Win32 gzip data stream records. Ignored.\n"),
win32_data_msg);
}
term_include_exclude_files(ff);
term_find_files(ff);
return 0;
}
/*
* Fill the CList box with files at path
*/
void FillDirectory(const char *path, Window *restore)
{
char pathbuf[MAXSTRING];
char modes[20], user[20], group[20], size[20], date[30];
char file[1000];
char marked[10];
gchar *text[NUM_COLUMNS] = {marked, file, modes, user, group, size, date};
GtkCList *list = restore->list;
int row = 0;
stop_director_reader(NULL);
pm_strcpy(&restore->fname, path);
gtk_entry_set_text(GTK_ENTRY(restore_dir), restore->fname);
gtk_clist_freeze(list);
gtk_clist_clear(list);
bsnprintf(pathbuf, sizeof(pathbuf), "cd %s", path);
Dmsg1(100, "%s\n", pathbuf);
write_director(pathbuf);
discard_to_prompt();
write_director("dir");
while (bnet_recv(UA_sock) > 0) {
char *p = UA_sock->msg;
char *l;
strip_trailing_junk(UA_sock->msg);
if (*p == '$') {
break;
}
Dmsg1(200, "Got: %s\n", p);
if (!*p) {
continue;
}
l = p;
skip_nonspaces(&p); /* permissions */
*p++ = 0;
bstrncpy(modes, l, sizeof(modes));
skip_spaces(&p);
skip_nonspaces(&p); /* link count */
*p++ = 0;
skip_spaces(&p);
l = p;
skip_nonspaces(&p); /* user */
*p++ = 0;
skip_spaces(&p);
bstrncpy(user, l, sizeof(user));
l = p;
skip_nonspaces(&p); /* group */
*p++ = 0;
bstrncpy(group, l, sizeof(group));
skip_spaces(&p);
l = p;
skip_nonspaces(&p); /* size */
*p++ = 0;
bstrncpy(size, l, sizeof(size));
skip_spaces(&p);
l = p;
skip_nonspaces(&p); /* date/time */
skip_spaces(&p);
skip_nonspaces(&p);
*p++ = 0;
bstrncpy(date, l, sizeof(date));
skip_spaces(&p);
if (*p == '*') {
bstrncpy(marked, "x", sizeof(marked));
p++;
} else {
bstrncpy(marked, " ", sizeof(marked));
}
split_path_and_filename(p, &restore->path, &restore->pnl,
&restore->file, &restore->fnl);
// Dmsg1(000, "restore->fname=%s\n", restore->fname);
bstrncpy(file, restore->file, sizeof(file));
// printf("modes=%s user=%s group=%s size=%s date=%s file=%s\n",
// modes, user, group, size, date, file);
gtk_clist_append(list, text);
row++;
}
/* Fix up length of file column */
gtk_clist_set_column_width(list, FILE_COLUMN, gtk_clist_optimal_column_width(list, FILE_COLUMN));
gtk_clist_set_column_width(list, MODES_COLUMN, gtk_clist_optimal_column_width(list, MODES_COLUMN));
gtk_clist_thaw(list);
start_director_reader(NULL);
}
int main(int argc, char *const *argv)
{
int retval = 0;
int ch, kfd, length;
bool base64_transform = false,
clear_encryption = false,
drive_encryption_status = false,
generate_passphrase = false,
populate_cache = false,
set_encryption = false,
show_keydata = false,
volume_encryption_status = false,
wrapped_keys = false;
char *keyfile = NULL;
char *cache_file = NULL;
char *wrap_keyfile = NULL;
char keydata[64];
char wrapdata[64];
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
while ((ch = getopt(argc, argv, "bcd:eg:k:p:s:vw:?")) != -1) {
switch (ch) {
case 'b':
base64_transform = true;
break;
case 'c':
clear_encryption = true;
break;
case 'd':
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
break;
case 'e':
drive_encryption_status = true;
break;
case 'g':
generate_passphrase = true;
if (keyfile) {
usage();
goto bail_out;
}
keyfile = bstrdup(optarg);
break;
case 'k':
show_keydata = true;
if (keyfile) {
usage();
goto bail_out;
}
keyfile = bstrdup(optarg);
break;
case 'p':
populate_cache = true;
cache_file = bstrdup(optarg);
break;
case 's':
set_encryption = true;
if (keyfile) {
usage();
goto bail_out;
}
keyfile = bstrdup(optarg);
break;
case 'v':
volume_encryption_status = true;
break;
case 'w':
wrapped_keys = true;
wrap_keyfile = bstrdup(optarg);
break;
case '?':
default:
usage();
goto bail_out;
}
}
argc -= optind;
argv += optind;
if (!generate_passphrase && !show_keydata && !populate_cache && argc < 1) {
fprintf(stderr, _("Missing device_name argument for this option\n"));
usage();
retval = 1;
goto bail_out;
}
if (generate_passphrase && show_keydata) {
fprintf(stderr, _("Either use -g or -k not both\n"));
retval = 1;
goto bail_out;
}
if (clear_encryption && set_encryption) {
fprintf(stderr, _("Either use -c or -s not both\n"));
retval = 1;
goto bail_out;
}
if ((clear_encryption ||
set_encryption) &&
(drive_encryption_status ||
volume_encryption_status)) {
fprintf(stderr, _("Either set or clear the crypto key or ask for status not both\n"));
retval = 1;
goto bail_out;
}
if ((clear_encryption ||
set_encryption ||
drive_encryption_status ||
volume_encryption_status) &&
(generate_passphrase ||
show_keydata ||
populate_cache)) {
fprintf(stderr, _("Don't mix operations which are incompatible "
"e.g. generate/show vs set/clear etc.\n"));
retval = 1;
goto bail_out;
}
OSDependentInit();
init_msg(NULL, NULL);
if (populate_cache) {
char *VolumeName, *EncrKey;
char new_cache_entry[256];
/*
* Load any keys currently in the cache.
*/
read_crypto_cache(cache_file);
/*
* Read new entries from stdin and parse them to update
* the cache.
*/
fprintf(stdout, _("Enter cache entrie(s) (close with ^D): "));
fflush(stdout);
while (read(1, new_cache_entry, sizeof(new_cache_entry)) > 0) {
strip_trailing_junk(new_cache_entry);
/*
* Try to parse the entry.
*/
VolumeName = new_cache_entry;
EncrKey = strchr(new_cache_entry, '\t');
if (!EncrKey) {
break;
}
*EncrKey++ = '\0';
update_crypto_cache(VolumeName, EncrKey);
}
/*
* Write out the new cache entries.
*/
write_crypto_cache(cache_file);
goto bail_out;
}
memset(keydata, 0, sizeof(keydata));
memset(wrapdata, 0, sizeof(wrapdata));
if (wrapped_keys) {
/*
* Read the key bits from the keyfile.
* - == stdin
*/
if (bstrcmp(wrap_keyfile, "-")) {
kfd = 0;
fprintf(stdout, _("Enter Key Encryption Key: "));
fflush(stdout);
} else {
kfd = open(wrap_keyfile, O_RDONLY);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), wrap_keyfile);
retval = 1;
goto bail_out;
}
}
read(kfd, wrapdata, sizeof(wrapdata));
if (kfd > 0) {
close(kfd);
}
strip_trailing_junk(wrapdata);
Dmsg1(10, "Wrapped keydata = %s\n", wrapdata);
}
/*
* Generate a new passphrase allow it to be wrapped using the given wrapkey
* and base64 if specified or when wrapped.
*/
if (generate_passphrase) {
int cnt;
char *passphrase;
passphrase = generate_crypto_passphrase(DEFAULT_PASSPHRASE_LENGTH);
if (!passphrase) {
retval = 1;
goto bail_out;
}
Dmsg1(10, "Generated passphrase = %s\n", passphrase);
/*
* See if we need to wrap the passphrase.
*/
if (wrapped_keys) {
char *wrapped_passphrase;
length = DEFAULT_PASSPHRASE_LENGTH + 8;
wrapped_passphrase = (char *)malloc(length);
memset(wrapped_passphrase, 0, length);
aes_wrap((unsigned char *)wrapdata,
DEFAULT_PASSPHRASE_LENGTH / 8,
(unsigned char *)passphrase,
(unsigned char *)wrapped_passphrase);
free(passphrase);
passphrase = wrapped_passphrase;
} else {
length = DEFAULT_PASSPHRASE_LENGTH;
}
/*
* See where to write the key.
* - == stdout
*/
if (bstrcmp(keyfile, "-")) {
kfd = 1;
} else {
kfd = open(keyfile, O_WRONLY | O_CREAT, 0644);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), keyfile);
free(passphrase);
retval = 1;
goto bail_out;
}
}
if (base64_transform || wrapped_keys) {
cnt = bin_to_base64(keydata, sizeof(keydata), passphrase, length, true);
if (write(kfd, keydata, cnt) != cnt) {
fprintf(stderr, _("Failed to write %d bytes to keyfile %s\n"), cnt, keyfile);
}
} else {
cnt = DEFAULT_PASSPHRASE_LENGTH;
if (write(kfd, passphrase, cnt) != cnt) {
fprintf(stderr, _("Failed to write %d bytes to keyfile %s\n"), cnt, keyfile);
}
}
Dmsg1(10, "Keydata = %s\n", keydata);
if (kfd > 1) {
close(kfd);
} else {
write(kfd, "\n", 1);
}
free(passphrase);
goto bail_out;
}
if (show_keydata) {
char *passphrase;
/*
* Read the key bits from the keyfile.
* - == stdin
*/
if (bstrcmp(keyfile, "-")) {
kfd = 0;
fprintf(stdout, _("Enter Encryption Key: "));
fflush(stdout);
} else {
kfd = open(keyfile, O_RDONLY);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), keyfile);
retval = 1;
goto bail_out;
}
}
read(kfd, keydata, sizeof(keydata));
if (kfd > 0) {
close(kfd);
}
strip_trailing_junk(keydata);
Dmsg1(10, "Keydata = %s\n", keydata);
/*
* See if we need to unwrap the passphrase.
*/
if (wrapped_keys) {
char *wrapped_passphrase;
/*
* A wrapped key is base64 encoded after it was wrapped so first
* convert it from base64 to bin. As we first go from base64 to bin
* and the base64_to_bin has a check if the decoded string will fit
* we need to alocate some more bytes for the decoded buffer to be
* sure it will fit.
*/
length = DEFAULT_PASSPHRASE_LENGTH + 12;
wrapped_passphrase = (char *)malloc(length);
memset(wrapped_passphrase, 0, length);
if (base64_to_bin(wrapped_passphrase, length,
keydata, strlen(keydata)) == 0) {
fprintf(stderr,
_("Failed to base64 decode the keydata read from %s, aborting...\n"),
keyfile);
free(wrapped_passphrase);
goto bail_out;
}
length = DEFAULT_PASSPHRASE_LENGTH;
passphrase = (char *)malloc(length);
memset(passphrase, 0, length);
if (aes_unwrap((unsigned char *)wrapdata,
length / 8,
(unsigned char *)wrapped_passphrase,
(unsigned char *)passphrase) == -1) {
fprintf(stderr,
_("Failed to aes unwrap the keydata read from %s using the wrap data from %s, aborting...\n"),
keyfile, wrap_keyfile);
free(wrapped_passphrase);
goto bail_out;
}
free(wrapped_passphrase);
} else {
if (base64_transform) {
/*
* As we first go from base64 to bin and the base64_to_bin has a check
* if the decoded string will fit we need to alocate some more bytes
* for the decoded buffer to be sure it will fit.
*/
length = DEFAULT_PASSPHRASE_LENGTH + 4;
passphrase = (char *)malloc(length);
memset(passphrase, 0, length);
base64_to_bin(passphrase, length, keydata, strlen(keydata));
} else {
length = DEFAULT_PASSPHRASE_LENGTH;
passphrase = (char *)malloc(length);
memset(passphrase, 0, length);
bstrncpy(passphrase, keydata, length);
}
}
Dmsg1(10, "Unwrapped passphrase = %s\n", passphrase);
fprintf(stdout, "%s\n", passphrase);
free(passphrase);
goto bail_out;
}
/*
* Clear the loaded encryption key of the given drive.
*/
if (clear_encryption) {
if (clear_scsi_encryption_key(-1, argv[0])) {
goto bail_out;
} else {
retval = 1;
goto bail_out;
}
}
/*
* Get the drive encryption status of the given drive.
*/
if (drive_encryption_status) {
POOLMEM *encryption_status = get_pool_memory(PM_MESSAGE);
if (get_scsi_drive_encryption_status(-1, argv[0], encryption_status, 0)) {
fprintf(stdout, "%s", encryption_status);
free_pool_memory(encryption_status);
} else {
retval = 1;
free_pool_memory(encryption_status);
goto bail_out;
}
}
/*
* Load a new encryption key onto the given drive.
*/
if (set_encryption) {
/*
* Read the key bits from the keyfile.
* - == stdin
*/
if (bstrcmp(keyfile, "-")) {
kfd = 0;
fprintf(stdout, _("Enter Encryption Key (close with ^D): "));
fflush(stdout);
} else {
kfd = open(keyfile, O_RDONLY);
if (kfd < 0) {
fprintf(stderr, _("Cannot open keyfile %s\n"), keyfile);
retval = 1;
goto bail_out;
}
}
read(kfd, keydata, sizeof(keydata));
if (kfd > 0) {
close(kfd);
}
strip_trailing_junk(keydata);
if (set_scsi_encryption_key(-1, argv[0], keydata)) {
goto bail_out;
} else {
retval = 1;
goto bail_out;
}
}
/*
* Get the volume encryption status of volume currently loaded in the given drive.
*/
if (volume_encryption_status) {
POOLMEM *encryption_status = get_pool_memory(PM_MESSAGE);
if (get_scsi_volume_encryption_status(-1, argv[0], encryption_status, 0)) {
fprintf(stdout, "%s", encryption_status);
free_pool_memory(encryption_status);
} else {
retval = 1;
free_pool_memory(encryption_status);
goto bail_out;
}
}
bail_out:
if (cache_file) {
free(cache_file);
}
if (keyfile) {
free(keyfile);
}
if (wrap_keyfile) {
free(wrap_keyfile);
}
exit(retval);
}
/*
* Read a file containing SQL queries and prompt
* the user to select which one.
*
* File format:
* # => comment
* :prompt for query
* *prompt for subst %1
* *prompt for subst %2
* ...
* SQL statement possibly terminated by ;
* :next query prompt
*/
bool query_cmd(UAContext *ua, const char *cmd)
{
FILE *fd = NULL;
POOLMEM *query = get_pool_memory(PM_MESSAGE);
char line[1000];
int i, item, len;
char *prompt[9];
int nprompt = 0;
char *query_file = me->query_file;
if (!open_client_db(ua, true)) {
goto bail_out;
}
if ((fd=fopen(query_file, "rb")) == NULL) {
berrno be;
ua->error_msg(_("Could not open %s: ERR=%s\n"), query_file,
be.bstrerror());
goto bail_out;
}
start_prompt(ua, _("Available queries:\n"));
while (fgets(line, sizeof(line), fd) != NULL) {
if (line[0] == ':') {
strip_trailing_junk(line);
add_prompt(ua, line+1);
}
}
if ((item=do_prompt(ua, "", _("Choose a query"), NULL, 0)) < 0) {
goto bail_out;
}
rewind(fd);
i = -1;
while (fgets(line, sizeof(line), fd) != NULL) {
if (line[0] == ':') {
i++;
}
if (i == item) {
break;
}
}
if (i != item) {
ua->error_msg(_("Could not find query.\n"));
goto bail_out;
}
query[0] = 0;
for (i=0; i<9; i++) {
prompt[i] = NULL;
}
while (fgets(line, sizeof(line), fd) != NULL) {
if (line[0] == '#') {
continue;
}
if (line[0] == ':') {
break;
}
strip_trailing_junk(line);
len = strlen(line);
if (line[0] == '*') { /* prompt */
if (nprompt >= 9) {
ua->error_msg(_("Too many prompts in query, max is 9.\n"));
} else {
line[len++] = ' ';
line[len] = 0;
prompt[nprompt++] = bstrdup(line+1);
continue;
}
}
if (*query != 0) {
pm_strcat(query, " ");
}
pm_strcat(query, line);
if (line[len-1] != ';') {
continue;
}
line[len-1] = 0; /* zap ; */
if (query[0] != 0) {
query = substitute_prompts(ua, query, prompt, nprompt);
Dmsg1(100, "Query2=%s\n", query);
if (query[0] == '!') {
db_list_sql_query(ua->jcr, ua->db, query+1, ua->send, VERT_LIST, false);
} else if (!db_list_sql_query(ua->jcr, ua->db, query, ua->send, HORZ_LIST, true)) {
ua->send_msg("%s\n", query);
}
query[0] = 0;
}
} /* end while */
if (query[0] != 0) {
query = substitute_prompts(ua, query, prompt, nprompt);
Dmsg1(100, "Query2=%s\n", query);
if (query[0] == '!') {
db_list_sql_query(ua->jcr, ua->db, query+1, ua->send, VERT_LIST, false);
} else if (!db_list_sql_query(ua->jcr, ua->db, query, ua->send, HORZ_LIST, true)) {
ua->error_msg("%s\n", query);
}
}
bail_out:
if (fd) {
fclose(fd);
}
free_pool_memory(query);
for (i=0; i<nprompt; i++) {
free(prompt[i]);
}
return true;
}
int main(int argc, char *const *argv)
{
FF_PKT *ff;
char name[1000];
bool quiet = false;
int i, ch;
char *inc = NULL;
char *exc = NULL;
FILE *fd;
setlocale(LC_ALL, "");
bindtextdomain("bacula", LOCALEDIR);
textdomain("bacula");
lmgr_init_thread();
while ((ch = getopt(argc, argv, "ad:e:i:q?")) != -1) {
switch (ch) {
case 'a': /* print extended attributes *debug* */
attrs = 1;
break;
case 'd': /* set debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'e': /* exclude patterns */
exc = optarg;
break;
case 'i': /* include patterns */
inc = optarg;
break;
case 'q':
quiet = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
jcr = new_jcr(sizeof(JCR), NULL);
ff = init_find_files();
if (argc == 0 && !inc) {
add_fname_to_include_list(ff, 0, "/"); /* default to / */
} else {
for (i=0; i < argc; i++) {
if (strcmp(argv[i], "-") == 0) {
while (fgets(name, sizeof(name)-1, stdin)) {
strip_trailing_junk(name);
add_fname_to_include_list(ff, 0, name);
}
continue;
}
add_fname_to_include_list(ff, 0, argv[i]);
}
}
if (inc) {
fd = fopen(inc, "rb");
if (!fd) {
printf(_("Could not open include file: %s\n"), inc);
exit(1);
}
while (fgets(name, sizeof(name)-1, fd)) {
strip_trailing_junk(name);
add_fname_to_include_list(ff, 0, name);
}
fclose(fd);
}
if (exc) {
fd = fopen(exc, "rb");
if (!fd) {
printf(_("Could not open exclude file: %s\n"), exc);
exit(1);
}
while (fgets(name, sizeof(name)-1, fd)) {
strip_trailing_junk(name);
add_fname_to_exclude_list(ff, name);
}
fclose(fd);
}
if (quiet) {
match_files(jcr, ff, count_files);
} else {
match_files(jcr, ff, print_file);
}
printf(_("Files seen = %d\n"), num_files);
term_include_exclude_files(ff);
term_find_files(ff);
free_jcr(jcr);
term_last_jobs_list(); /* free jcr chain */
close_memory_pool();
lmgr_cleanup_main();
sm_dump(false);
exit(0);
}
/*
* We get the slot list from the Storage daemon.
* If scan is set, we return all slots found,
* otherwise, we return only slots with valid barcodes (Volume names)
*/
static vol_list_t *get_vol_list_from_SD(UAContext *ua, bool scan)
{
STORE *store = ua->jcr->wstore;
char dev_name[MAX_NAME_LENGTH];
BSOCK *sd;
vol_list_t *vl;
vol_list_t *vol_list = 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 */
bnet_fsend(sd, NT_("autochanger list %s \n"), dev_name);
/* Read and organize list of Volumes */
while (bnet_recv(sd) >= 0) {
char *p;
int Slot;
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;
}
/* Validate Slot: if scanning, otherwise Slot:Barcode */
p = strchr(sd->msg, ':');
if (scan && p) {
/* Scanning -- require only valid slot */
Slot = atoi(sd->msg);
if (Slot <= 0) {
p--;
*p = ':';
ua->error_msg(_("Invalid Slot number: %s\n"), sd->msg);
continue;
}
} else {
/* Not scanning */
if (p && strlen(p) > 1) {
*p++ = 0;
if (!is_an_integer(sd->msg) || (Slot=atoi(sd->msg)) <= 0) {
p--;
*p = ':';
ua->error_msg(_("Invalid Slot number: %s\n"), sd->msg);
continue;
}
} else {
continue;
}
if (!is_volume_name_legal(ua, p)) {
p--;
*p = ':';
ua->error_msg(_("Invalid Volume name: %s\n"), sd->msg);
continue;
}
}
/* Add Slot and VolumeName to list */
vl = (vol_list_t *)malloc(sizeof(vol_list_t));
vl->Slot = Slot;
if (p) {
if (*p == ':') {
p++; /* skip separator */
}
vl->VolName = bstrdup(p);
} else {
vl->VolName = NULL;
}
Dmsg2(100, "Add slot=%d Vol=%s to SD list.\n", vl->Slot, NPRT(vl->VolName));
if (!vol_list) {
vl->next = vol_list;
vol_list = vl;
} else {
/* Add new entry to end of list */
for (vol_list_t *tvl=vol_list; tvl; tvl=tvl->next) {
if (!tvl->next) {
tvl->next = vl;
vl->next = NULL;
break;
}
}
}
}
close_sd_bsock(ua);
return vol_list;
}
static bool get_user_slot_list(UAContext *ua, char *slot_list, int num_slots)
{
int i;
const char *msg;
/* slots are numbered 1 to num_slots */
for (int i=0; i <= num_slots; i++) {
slot_list[i] = 0;
}
i = find_arg_with_value(ua, "slots");
if (i > 0) {
/* scan slot list in ua->argv[i] */
char *p, *e, *h;
int beg, end;
strip_trailing_junk(ua->argv[i]);
for (p=ua->argv[i]; p && *p; p=e) {
/* Check for list */
e = strchr(p, ',');
if (e) {
*e++ = 0;
}
/* Check for range */
h = strchr(p, '-'); /* range? */
if (h == p) {
msg = _("Negative numbers not permitted\n");
goto bail_out;
}
if (h) {
*h++ = 0;
if (!is_an_integer(h)) {
msg = _("Range end is not integer.\n");
goto bail_out;
}
skip_spaces(&p);
if (!is_an_integer(p)) {
msg = _("Range start is not an integer.\n");
goto bail_out;
}
beg = atoi(p);
end = atoi(h);
if (end < beg) {
msg = _("Range end not bigger than start.\n");
goto bail_out;
}
} else {
skip_spaces(&p);
if (!is_an_integer(p)) {
msg = _("Input value is not an integer.\n");
goto bail_out;
}
beg = end = atoi(p);
}
if (beg <= 0 || end <= 0) {
msg = _("Values must be be greater than zero.\n");
goto bail_out;
}
if (end > num_slots) {
msg = _("Slot too large.\n");
goto bail_out;
}
for (i=beg; i<=end; i++) {
slot_list[i] = 1; /* Turn on specified range */
}
}
} else {
/* Turn everything on */
for (i=1; i <= num_slots; i++) {
slot_list[i] = 1;
}
}
Dmsg0(100, "Slots turned on:\n");
for (i=1; i <= num_slots; i++) {
if (slot_list[i]) {
Dmsg1(100, "%d\n", i);
}
}
return true;
bail_out:
return false;
}