int get_pos_range(char *s,int *n1,int *n2)
{
int i;
char buf[80];
strcpy(buf,s);
if (buf[0]=='-')
return(0);
if (is_an_integer(buf))
{
(*n1)=(*n2)=atoi(buf);
return(1);
}
for (i=0;buf[i]!='-' && buf[i]!='\0';i++);
if (buf[i]=='\0')
return(0);
buf[i]='\0';
if (!is_an_integer(buf))
return(0);
(*n1)=atoi(buf);
if (!is_an_integer(&buf[i+1]))
return(0);
(*n2)=atoi(&buf[i+1]);
return(1);
}
/*
** Caution: buf cannot be constant char *. It gets temporarily modified
** by this routine.
*/
int string_read_integers(char *buf,int *a,int nmax)
{
int i,n;
for (i=n=0;buf[i]!='\0';)
{
int j,c;
for (;buf[i]=='\n' || buf[i]=='\r' || buf[i]==' ' || buf[i]=='\t' || buf[i]==',' || buf[i]==';';i++);
if (buf[i]=='\0')
break;
j=i;
for (;buf[i]!='\n' && buf[i]!='\r' && buf[i]!=' ' && buf[i]!='\t' && buf[i]!=','
&& buf[i]!=';' && buf[i]!='\0';i++);
c=buf[i];
if (buf[i]!='\0')
buf[i]='\0';
if (!is_an_integer(&buf[j]))
{
buf[i]=c;
break;
}
a[n++]=atoi(&buf[j]);
buf[i]=c;
if (n>=nmax)
break;
}
return(n);
}
/*
* If full_list is set, we list vertically, otherwise, we
* list on one line horizontally.
* Return number of rows
*/
int list_result(JCR *jcr, B_DB *mdb, OUTPUT_FORMATTER *send, e_list_type type)
{
SQL_FIELD *field;
SQL_ROW row;
int i, col_len, max_len = 0;
int num_fields;
char ewc[30];
POOL_MEM key;
POOL_MEM value;
Dmsg0(800, "list_result starts\n");
if (sql_num_rows(mdb) == 0) {
send->decoration(_("No results to list.\n"));
send->object_end("table");
return sql_num_rows(mdb);
}
num_fields = sql_num_fields(mdb);
switch (type) {
case NF_LIST:
case RAW_LIST:
/*
* No need to calculate things like column widths for
* unformated or raw output.
*/
break;
case HORZ_LIST:
case VERT_LIST:
Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
/*
* Determine column display widths
*/
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result processing field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
col_len = cstrlen(field->name);
if (type == VERT_LIST) {
if (col_len > max_len) {
max_len = col_len;
}
} else {
if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
field->max_length += (field->max_length - 1) / 3;
}
if (col_len < (int)field->max_length) {
col_len = field->max_length;
}
if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
col_len = 4; /* 4 = length of the word "NULL" */
}
field->max_length = col_len; /* reset column info */
}
}
break;
}
Dmsg0(800, "list_result finished first loop\n");
switch (type) {
case NF_LIST:
case RAW_LIST:
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
send->object_start(row[0]);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
value.bsprintf(" %s", "NULL");
} else {
value.bsprintf(" %s", row[i]);
}
send->object_key_value(field->name, value.c_str(), "%s");
}
if (type != RAW_LIST) {
send->decoration("\n");
}
send->object_end(row[0]);
}
break;
case HORZ_LIST:
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
list_dashes(mdb, send);
send->decoration("|");
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result looking at field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
send->decoration(" %-*s |", max_len, field->name);
}
send->decoration("\n");
list_dashes(mdb, send);
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
send->object_start(row[0]);
sql_field_seek(mdb, 0);
send->decoration("|");
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
if (row[i] == NULL) {
value.bsprintf(" %-*s |", max_len, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
value.bsprintf(" %*s |", max_len, add_commas(row[i], ewc));
} else {
value.bsprintf(" %-*s |", max_len, row[i]);
}
if (i == num_fields-1) {
value.strcat("\n");
}
/* use value format string to send preformated value */
send->object_key_value(field->name, row[i], value.c_str());
}
send->object_end(row[0]);
}
list_dashes(mdb, send);
break;
case VERT_LIST:
Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
send->object_start(row[0]);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", add_commas(row[i], ewc));
} else {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", row[i]);
}
/* use value format string to send preformated value */
send->object_key_value(field->name, key.c_str(), row[i], value.c_str());
}
send->decoration("\n");
send->object_end(row[0]);
}
break;
}
return sql_num_rows(mdb);
}
int list_result(void *vctx, int nb_col, char **row)
{
SQL_FIELD *field;
int i, col_len, max_len = 0;
int num_fields;
char ewc[30];
POOL_MEM key;
POOL_MEM value;
LIST_CTX *pctx = (LIST_CTX *)vctx;
OUTPUT_FORMATTER *send = pctx->send;
e_list_type type = pctx->type;
B_DB *mdb = pctx->mdb;
JCR *jcr = pctx->jcr;
send->object_start("row");
num_fields = sql_num_fields(mdb);
switch (type) {
case NF_LIST:
case RAW_LIST:
/*
* No need to calculate things like maximum field lenght for
* unformated or raw output.
*/
break;
case HORZ_LIST:
case VERT_LIST:
if (!pctx->once) {
pctx->once = true;
Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
/*
* Determine column display widths
*/
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result processing field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
col_len = cstrlen(field->name);
if (type == VERT_LIST) {
if (col_len > max_len) {
max_len = col_len;
}
} else {
if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
field->max_length += (field->max_length - 1) / 3;
}
if (col_len < (int)field->max_length) {
col_len = field->max_length;
}
if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
col_len = 4; /* 4 = length of the word "NULL" */
}
field->max_length = col_len; /* reset column info */
}
}
pctx->num_rows++;
Dmsg0(800, "list_result finished first loop\n");
if (type == VERT_LIST) {
break;
}
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
/*
* Keep the result to display the same line at the end of the table
*/
list_dashes(mdb, send);
send->decoration("|");
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result looking at field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
send->decoration(" %-*s |", max_len, field->name);
}
send->decoration("\n");
list_dashes(mdb, send);
}
break;
default:
break;
}
switch (type) {
case NF_LIST:
case RAW_LIST:
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
value.bsprintf(" %s", "NULL");
} else {
value.bsprintf(" %s", row[i]);
}
send->object_key_value(field->name, value.c_str(), "%s");
}
if (type != RAW_LIST) {
send->decoration("\n");
}
break;
case HORZ_LIST:
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
send->decoration("|");
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
if (row[i] == NULL) {
value.bsprintf(" %-*s |", max_len, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
value.bsprintf(" %*s |", max_len, add_commas(row[i], ewc));
} else {
value.bsprintf(" %-*s |", max_len, row[i]);
}
/*
* Use value format string to send preformated value.
*/
send->object_key_value(field->name, row[i], value.c_str());
}
send->decoration("\n");
break;
case VERT_LIST:
Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", add_commas(row[i], ewc));
} else {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", row[i]);
}
/*
* Use value format string to send preformated value.
*/
send->object_key_value(field->name, key.c_str(), row[i], value.c_str());
}
send->decoration("\n");
break;
default:
break;
}
send->object_end("row");
return 0;
}
/*
* Store Schedule Run information
*
* Parse Run statement:
*
* Run <keyword=value ...> [on] 2 january at 23:45
*
* Default Run time is daily at 0:0
*
* There can be multiple run statements, they are simply chained
* together.
*
*/
void store_run(LEX *lc, RES_ITEM *item, int index, int pass)
{
char *p;
int i, j;
int options = lc->options;
int token, state, state2 = 0, code = 0, code2 = 0;
bool found;
utime_t utime;
RES *res;
RUNRES **run = (RUNRES **)(item->value);
URES *res_all = (URES *)my_config->m_res_all;
lc->options |= LOPT_NO_IDENT; /* Want only "strings" */
/*
* Clear local copy of run record
*/
memset(&lrun, 0, sizeof(lrun));
/*
* Scan for Job level "full", "incremental", ...
*/
for (found = true; found; ) {
found = false;
token = lex_get_token(lc, T_NAME);
for (i = 0; !found && RunFields[i].name; i++) {
if (bstrcasecmp(lc->str, RunFields[i].name)) {
found = true;
if (lex_get_token(lc, T_ALL) != T_EQUALS) {
scan_err1(lc, _("Expected an equals, got: %s"), lc->str);
/* NOT REACHED */
}
switch (RunFields[i].token) {
case 's': /* Data spooling */
token = lex_get_token(lc, T_NAME);
if (bstrcasecmp(lc->str, "yes") || bstrcasecmp(lc->str, "true")) {
lrun.spool_data = true;
lrun.spool_data_set = true;
} else if (bstrcasecmp(lc->str, "no") || bstrcasecmp(lc->str, "false")) {
lrun.spool_data = false;
lrun.spool_data_set = true;
} else {
scan_err1(lc, _("Expect a YES or NO, got: %s"), lc->str);
}
break;
case 'L': /* Level */
token = lex_get_token(lc, T_NAME);
for (j = 0; joblevels[j].level_name; j++) {
if (bstrcasecmp(lc->str, joblevels[j].level_name)) {
lrun.level = joblevels[j].level;
lrun.job_type = joblevels[j].job_type;
j = 0;
break;
}
}
if (j != 0) {
scan_err1(lc, _("Job level field: %s not found in run record"), lc->str);
/* NOT REACHED */
}
break;
case 'p': /* Priority */
token = lex_get_token(lc, T_PINT32);
if (pass == 2) {
lrun.Priority = lc->pint32_val;
}
break;
case 'P': /* Pool */
case 'f': /* FullPool */
case 'v': /* VFullPool */
case 'i': /* IncPool */
case 'd': /* DiffPool */
case 'n': /* NextPool */
token = lex_get_token(lc, T_NAME);
if (pass == 2) {
res = GetResWithName(R_POOL, lc->str);
if (res == NULL) {
scan_err1(lc, _("Could not find specified Pool Resource: %s"),
lc->str);
/* NOT REACHED */
}
switch(RunFields[i].token) {
case 'P':
lrun.pool = (POOLRES *)res;
break;
case 'f':
lrun.full_pool = (POOLRES *)res;
break;
case 'v':
lrun.vfull_pool = (POOLRES *)res;
break;
case 'i':
lrun.inc_pool = (POOLRES *)res;
break;
case 'd':
lrun.diff_pool = (POOLRES *)res;
break;
case 'n':
lrun.next_pool = (POOLRES *)res;
break;
}
}
break;
case 'S': /* Storage */
token = lex_get_token(lc, T_NAME);
if (pass == 2) {
res = GetResWithName(R_STORAGE, lc->str);
if (res == NULL) {
scan_err1(lc, _("Could not find specified Storage Resource: %s"),
lc->str);
/* NOT REACHED */
}
lrun.storage = (STORERES *)res;
}
break;
case 'M': /* Messages */
token = lex_get_token(lc, T_NAME);
if (pass == 2) {
res = GetResWithName(R_MSGS, lc->str);
if (res == NULL) {
scan_err1(lc, _("Could not find specified Messages Resource: %s"),
lc->str);
/* NOT REACHED */
}
lrun.msgs = (MSGSRES *)res;
}
break;
case 'm': /* Max run sched time */
token = lex_get_token(lc, T_QUOTED_STRING);
if (!duration_to_utime(lc->str, &utime)) {
scan_err1(lc, _("expected a time period, got: %s"), lc->str);
return;
}
lrun.MaxRunSchedTime = utime;
lrun.MaxRunSchedTime_set = true;
break;
case 'a': /* Accurate */
token = lex_get_token(lc, T_NAME);
if (strcasecmp(lc->str, "yes") == 0 || strcasecmp(lc->str, "true") == 0) {
lrun.accurate = true;
lrun.accurate_set = true;
} else if (strcasecmp(lc->str, "no") == 0 || strcasecmp(lc->str, "false") == 0) {
lrun.accurate = false;
lrun.accurate_set = true;
} else {
scan_err1(lc, _("Expect a YES or NO, got: %s"), lc->str);
}
break;
default:
scan_err1(lc, _("Expected a keyword name, got: %s"), lc->str);
/* NOT REACHED */
break;
} /* end switch */
} /* end if bstrcasecmp */
} /* end for RunFields */
/*
* At this point, it is not a keyword. Check for old syle
* Job Levels without keyword. This form is depreciated!!!
*/
if (!found) {
for (j = 0; joblevels[j].level_name; j++) {
if (bstrcasecmp(lc->str, joblevels[j].level_name)) {
lrun.level = joblevels[j].level;
lrun.job_type = joblevels[j].job_type;
found = true;
break;
}
}
}
} /* end for found */
/*
* Scan schedule times.
* Default is: daily at 0:0
*/
state = s_none;
set_defaults();
for (; token != T_EOL; (token = lex_get_token(lc, T_ALL))) {
int len;
bool pm = false;
bool am = false;
switch (token) {
case T_NUMBER:
state = s_mday;
code = atoi(lc->str) - 1;
if (code < 0 || code > 30) {
scan_err0(lc, _("Day number out of range (1-31)"));
}
break;
case T_NAME: /* This handles drop through from keyword */
case T_UNQUOTED_STRING:
if (strchr(lc->str, (int)'-')) {
state = s_range;
break;
}
if (strchr(lc->str, (int)':')) {
state = s_time;
break;
}
if (strchr(lc->str, (int)'/')) {
state = s_modulo;
break;
}
if (lc->str_len == 3 && (lc->str[0] == 'w' || lc->str[0] == 'W') &&
is_an_integer(lc->str+1)) {
code = atoi(lc->str+1);
if (code < 0 || code > 53) {
scan_err0(lc, _("Week number out of range (0-53)"));
/* NOT REACHED */
}
state = s_woy; /* Week of year */
break;
}
/*
* Everything else must be a keyword
*/
for (i = 0; keyw[i].name; i++) {
if (bstrcasecmp(lc->str, keyw[i].name)) {
state = keyw[i].state;
code = keyw[i].code;
i = 0;
break;
}
}
if (i != 0) {
scan_err1(lc, _("Job type field: %s in run record not found"), lc->str);
/* NOT REACHED */
}
break;
case T_COMMA:
continue;
default:
scan_err2(lc, _("Unexpected token: %d:%s"), token, lc->str);
/* NOT REACHED */
break;
}
switch (state) {
case s_none:
continue;
case s_mday: /* Day of month */
if (!have_mday) {
clear_bits(0, 30, lrun.mday);
have_mday = true;
}
set_bit(code, lrun.mday);
break;
case s_month: /* Month of year */
if (!have_month) {
clear_bits(0, 11, lrun.month);
have_month = true;
}
set_bit(code, lrun.month);
break;
case s_wday: /* Week day */
if (!have_wday) {
clear_bits(0, 6, lrun.wday);
have_wday = true;
}
set_bit(code, lrun.wday);
break;
case s_wom: /* Week of month 1st, ... */
if (!have_wom) {
clear_bits(0, 4, lrun.wom);
have_wom = true;
}
set_bit(code, lrun.wom);
break;
case s_woy:
if (!have_woy) {
clear_bits(0, 53, lrun.woy);
have_woy = true;
}
set_bit(code, lrun.woy);
break;
case s_time: /* Time */
if (!have_at) {
scan_err0(lc, _("Time must be preceded by keyword AT."));
/* NOT REACHED */
}
if (!have_hour) {
clear_bits(0, 23, lrun.hour);
}
// Dmsg1(000, "s_time=%s\n", lc->str);
p = strchr(lc->str, ':');
if (!p) {
scan_err0(lc, _("Time logic error.\n"));
/* NOT REACHED */
}
*p++ = 0; /* Separate two halves */
code = atoi(lc->str); /* Pick up hour */
code2 = atoi(p); /* Pick up minutes */
len = strlen(p);
if (len >= 2) {
p += 2;
}
if (bstrcasecmp(p, "pm")) {
pm = true;
} else if (bstrcasecmp(p, "am")) {
am = true;
} else if (len != 2) {
scan_err0(lc, _("Bad time specification."));
/* NOT REACHED */
}
/*
* Note, according to NIST, 12am and 12pm are ambiguous and
* can be defined to anything. However, 12:01am is the same
* as 00:01 and 12:01pm is the same as 12:01, so we define
* 12am as 00:00 and 12pm as 12:00.
*/
if (pm) {
/*
* Convert to 24 hour time
*/
if (code != 12) {
code += 12;
}
} else if (am && code == 12) {
/*
* AM
*/
code -= 12;
}
if (code < 0 || code > 23 || code2 < 0 || code2 > 59) {
scan_err0(lc, _("Bad time specification."));
/* NOT REACHED */
}
set_bit(code, lrun.hour);
lrun.minute = code2;
have_hour = true;
break;
case s_at:
have_at = true;
break;
case s_last:
lrun.last_set = true;
if (!have_wom) {
clear_bits(0, 4, lrun.wom);
have_wom = true;
}
break;
case s_modulo:
p = strchr(lc->str, '/');
if (!p) {
scan_err0(lc, _("Modulo logic error.\n"));
}
*p++ = 0; /* Separate two halves */
if (is_an_integer(lc->str) && is_an_integer(p)) {
/*
* Check for day modulo specification.
*/
code = atoi(lc->str) - 1;
code2 = atoi(p);
if (code < 0 || code > 30 || code2 < 0 || code2 > 30) {
scan_err0(lc, _("Bad day specification in modulo."));
}
if (code > code2) {
scan_err0(lc, _("Bad day specification, offset must always be <= than modulo."));
}
if (!have_mday) {
clear_bits(0, 30, lrun.mday);
have_mday = true;
}
/*
* Set the bits according to the modulo specification.
*/
for (i = 0; i < 31; i++) {
if (i % code2 == 0) {
set_bit(i + code, lrun.mday);
}
}
} else if (strlen(lc->str) == 3 && strlen(p) == 3 &&
(lc->str[0] == 'w' || lc->str[0] == 'W') &&
(p[0] == 'w' || p[0] == 'W') &&
is_an_integer(lc->str + 1) &&
is_an_integer(p + 1)) {
/*
* Check for week modulo specification.
*/
code = atoi(lc->str + 1);
code2 = atoi(p + 1);
if (code < 0 || code > 53 || code2 < 0 || code2 > 53) {
scan_err0(lc, _("Week number out of range (0-53) in modulo"));
}
if (code > code2) {
scan_err0(lc, _("Bad week number specification in modulo, offset must always be <= than modulo."));
}
if (!have_woy) {
clear_bits(0, 53, lrun.woy);
have_woy = true;
}
/*
* Set the bits according to the modulo specification.
*/
for (i = 0; i < 54; i++) {
if (i % code2 == 0) {
set_bit(i + code - 1, lrun.woy);
}
}
} else {
scan_err0(lc, _("Bad modulo time specification. Format for weekdays is '01/02', for yearweeks is 'w01/w02'."));
}
break;
case s_range:
p = strchr(lc->str, '-');
if (!p) {
scan_err0(lc, _("Range logic error.\n"));
}
*p++ = 0; /* Separate two halves */
if (is_an_integer(lc->str) && is_an_integer(p)) {
/*
* Check for day range.
*/
code = atoi(lc->str) - 1;
code2 = atoi(p) - 1;
if (code < 0 || code > 30 || code2 < 0 || code2 > 30) {
scan_err0(lc, _("Bad day range specification."));
}
if (!have_mday) {
clear_bits(0, 30, lrun.mday);
have_mday = true;
}
if (code < code2) {
set_bits(code, code2, lrun.mday);
} else {
set_bits(code, 30, lrun.mday);
set_bits(0, code2, lrun.mday);
}
} else if (strlen(lc->str) == 3 && strlen(p) == 3 &&
(lc->str[0] == 'w' || lc->str[0] == 'W') &&
(p[0] == 'w' || p[0] == 'W') &&
is_an_integer(lc->str + 1) &&
is_an_integer(p + 1)) {
/*
* Check for week of year range.
*/
code = atoi(lc->str + 1);
code2 = atoi(p + 1);
if (code < 0 || code > 53 || code2 < 0 || code2 > 53) {
scan_err0(lc, _("Week number out of range (0-53)"));
}
if (!have_woy) {
clear_bits(0, 53, lrun.woy);
have_woy = true;
}
if (code < code2) {
set_bits(code, code2, lrun.woy);
} else {
set_bits(code, 53, lrun.woy);
set_bits(0, code2, lrun.woy);
}
} else {
/*
* lookup first half of keyword range (week days or months).
*/
lcase(lc->str);
for (i = 0; keyw[i].name; i++) {
if (bstrcmp(lc->str, keyw[i].name)) {
state = keyw[i].state;
code = keyw[i].code;
i = 0;
break;
}
}
if (i != 0 || (state != s_month && state != s_wday && state != s_wom)) {
scan_err0(lc, _("Invalid month, week or position day range"));
/* NOT REACHED */
}
/*
* Lookup end of range.
*/
lcase(p);
for (i = 0; keyw[i].name; i++) {
if (bstrcmp(p, keyw[i].name)) {
state2 = keyw[i].state;
code2 = keyw[i].code;
i = 0;
break;
}
}
if (i != 0 || state != state2 || code == code2) {
scan_err0(lc, _("Invalid month, weekday or position range"));
/* NOT REACHED */
}
if (state == s_wday) {
if (!have_wday) {
clear_bits(0, 6, lrun.wday);
have_wday = true;
}
if (code < code2) {
set_bits(code, code2, lrun.wday);
} else {
set_bits(code, 6, lrun.wday);
set_bits(0, code2, lrun.wday);
}
} else if (state == s_month) {
if (!have_month) {
clear_bits(0, 11, lrun.month);
have_month = true;
}
if (code < code2) {
set_bits(code, code2, lrun.month);
} else {
/*
* This is a bit odd, but we accept it anyway
*/
set_bits(code, 11, lrun.month);
set_bits(0, code2, lrun.month);
}
} else {
/*
* Must be position
*/
if (!have_wom) {
clear_bits(0, 4, lrun.wom);
have_wom = true;
}
if (code < code2) {
set_bits(code, code2, lrun.wom);
} else {
set_bits(code, 4, lrun.wom);
set_bits(0, code2, lrun.wom);
}
}
}
break;
case s_hourly:
have_hour = true;
set_bits(0, 23, lrun.hour);
break;
case s_weekly:
have_mday = have_wom = have_woy = true;
set_bits(0, 30, lrun.mday);
set_bits(0, 4, lrun.wom);
set_bits(0, 53, lrun.woy);
break;
case s_daily:
have_mday = true;
set_bits(0, 6, lrun.wday);
break;
case s_monthly:
have_month = true;
set_bits(0, 11, lrun.month);
break;
default:
scan_err0(lc, _("Unexpected run state\n"));
/* NOT REACHED */
break;
}
}
/* Allocate run record, copy new stuff into it,
* and append it to the list of run records
* in the schedule resource.
*/
if (pass == 2) {
RUNRES *tail;
/* Create new run record */
RUNRES *nrun = (RUNRES *)malloc(sizeof(RUNRES));
memcpy(nrun, &lrun, sizeof(RUNRES));
nrun ->next = NULL;
if (!*run) { /* If empty list */
*run = nrun; /* Add new record */
} else {
for (tail = *run; tail->next; tail=tail->next)
{ }
tail->next = nrun;
}
}
lc->options = options; /* Restore scanner options */
set_bit(index, res_all->res_sch.hdr.item_present);
clear_bit(index, res_all->hdr.inherit_content);
}
/*
* The first step in the restore process is for the user to
* select a list of JobIds from which he will subsequently
* select which files are to be restored.
*
* Returns: 2 if filename list made
* 1 if jobid list made
* 0 on error
*/
static int user_select_jobids_or_files(UAContext *ua, RESTORE_CTX *rx)
{
char *p;
char date[MAX_TIME_LENGTH];
bool have_date = false;
/* Include current second if using current time */
utime_t now = time(NULL) + 1;
JobId_t JobId;
JOB_DBR jr = { (JobId_t)-1 };
bool done = false;
int i, j;
const char *list[] = {
_("List last 20 Jobs run"),
_("List Jobs where a given File is saved"),
_("Enter list of comma separated JobIds to select"),
_("Enter SQL list command"),
_("Select the most recent backup for a client"),
_("Select backup for a client before a specified time"),
_("Enter a list of files to restore"),
_("Enter a list of files to restore before a specified time"),
_("Find the JobIds of the most recent backup for a client"),
_("Find the JobIds for a backup for a client before a specified time"),
_("Enter a list of directories to restore for found JobIds"),
_("Select full restore to a specified Job date"),
_("Cancel"),
NULL
};
const char *kw[] = {
/*
* These keywords are handled in a for loop
*/
"jobid", /* 0 */
"current", /* 1 */
"before", /* 2 */
"file", /* 3 */
"directory", /* 4 */
"select", /* 5 */
"pool", /* 6 */
"all", /* 7 */
/*
* The keyword below are handled by individual arg lookups
*/
"client", /* 8 */
"storage", /* 9 */
"fileset", /* 10 */
"where", /* 11 */
"yes", /* 12 */
"bootstrap", /* 13 */
"done", /* 14 */
"strip_prefix", /* 15 */
"add_prefix", /* 16 */
"add_suffix", /* 17 */
"regexwhere", /* 18 */
"restoreclient", /* 19 */
"copies", /* 20 */
"comment", /* 21 */
"restorejob", /* 22 */
"replace", /* 23 */
"pluginoptions", /* 24 */
NULL
};
rx->JobIds[0] = 0;
for (i = 1; i<ua->argc; i++) { /* loop through arguments */
bool found_kw = false;
for (j = 0; kw[j]; j++) { /* loop through keywords */
if (bstrcasecmp(kw[j], ua->argk[i])) {
found_kw = true;
break;
}
}
if (!found_kw) {
ua->error_msg(_("Unknown keyword: %s\n"), ua->argk[i]);
return 0;
}
/* Found keyword in kw[] list, process it */
switch (j) {
case 0: /* jobid */
if (!has_value(ua, i)) {
return 0;
}
if (*rx->JobIds != 0) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->argv[i]);
done = true;
break;
case 1: /* current */
/*
* Note, we add one second here just to include any job
* that may have finished within the current second,
* which happens a lot in scripting small jobs.
*/
bstrutime(date, sizeof(date), now);
have_date = true;
break;
case 2: /* before */
if (have_date || !has_value(ua, i)) {
return 0;
}
if (str_to_utime(ua->argv[i]) == 0) {
ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]);
return 0;
}
bstrncpy(date, ua->argv[i], sizeof(date));
have_date = true;
break;
case 3: /* file */
case 4: /* dir */
if (!has_value(ua, i)) {
return 0;
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
pm_strcpy(ua->cmd, ua->argv[i]);
insert_one_file_or_dir(ua, rx, date, j==4);
return 2;
case 5: /* select */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = true;
break;
case 6: /* pool specified */
if (!has_value(ua, i)) {
return 0;
}
rx->pool = (POOLRES *)GetResWithName(R_POOL, ua->argv[i]);
if (!rx->pool) {
ua->error_msg(_("Error: Pool resource \"%s\" does not exist.\n"), ua->argv[i]);
return 0;
}
if (!acl_access_ok(ua, Pool_ACL, ua->argv[i], true)) {
rx->pool = NULL;
ua->error_msg(_("Error: Pool resource \"%s\" access not allowed.\n"), ua->argv[i]);
return 0;
}
break;
case 7: /* all specified */
rx->all = true;
break;
default:
/*
* All keywords 7 or greater are ignored or handled by a select prompt
*/
break;
}
}
if (!done) {
ua->send_msg(_("\nFirst you select one or more JobIds that contain files\n"
"to be restored. You will be presented several methods\n"
"of specifying the JobIds. Then you will be allowed to\n"
"select which files from those JobIds are to be restored.\n\n"));
}
/* If choice not already made above, prompt */
for ( ; !done; ) {
char *fname;
int len;
bool gui_save;
db_list_ctx jobids;
start_prompt(ua, _("To select the JobIds, you have the following choices:\n"));
for (int i=0; list[i]; i++) {
add_prompt(ua, list[i]);
}
done = true;
switch (do_prompt(ua, "", _("Select item: "), NULL, 0)) {
case -1: /* error or cancel */
return 0;
case 0: /* list last 20 Jobs run */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, uar_list_jobs, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 1: /* list where a file is saved */
if (!get_client_name(ua, rx)) {
return 0;
}
if (!get_cmd(ua, _("Enter Filename (no path):"))) {
return 0;
}
len = strlen(ua->cmd);
fname = (char *)malloc(len * 2 + 1);
db_escape_string(ua->jcr, ua->db, fname, ua->cmd, len);
Mmsg(rx->query, uar_file[db_get_type_index(ua->db)], rx->ClientName, fname);
free(fname);
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, rx->query, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 2: /* enter a list of JobIds */
if (!get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
return 0;
}
pm_strcpy(rx->JobIds, ua->cmd);
break;
case 3: /* Enter an SQL list command */
if (!acl_access_ok(ua, Command_ACL, NT_("sqlquery"), true)) {
ua->error_msg(_("SQL query not authorized.\n"));
return 0;
}
if (!get_cmd(ua, _("Enter SQL list command: "))) {
return 0;
}
gui_save = ua->jcr->gui;
ua->jcr->gui = true;
db_list_sql_query(ua->jcr, ua->db, ua->cmd, ua->send, HORZ_LIST, true);
ua->jcr->gui = gui_save;
done = false;
break;
case 4: /* Select the most recent backups */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 5: /* select backup at specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
break;
case 6: /* Enter files */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 7: /* enter files backed up before specified time */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter file names with paths, or < to enter a filename\n"
"containing a list of file names with paths, and terminate\n"
"them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter full filename: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
insert_one_file_or_dir(ua, rx, date, false);
}
return 2;
case 8: /* Find JobIds for current backup */
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 9: /* Find JobIds for give date */
if (!have_date) {
if (!get_date(ua, date, sizeof(date))) {
return 0;
}
}
if (!select_backups_before_date(ua, rx, date)) {
return 0;
}
done = false;
break;
case 10: /* Enter directories */
if (*rx->JobIds != 0) {
ua->send_msg(_("You have already selected the following JobIds: %s\n"),
rx->JobIds);
} else if (get_cmd(ua, _("Enter JobId(s), comma separated, to restore: "))) {
if (*rx->JobIds != 0 && *ua->cmd) {
pm_strcat(rx->JobIds, ",");
}
pm_strcat(rx->JobIds, ua->cmd);
}
if (*rx->JobIds == 0 || *rx->JobIds == '.') {
*rx->JobIds = 0;
return 0; /* nothing entered, return */
}
if (!have_date) {
bstrutime(date, sizeof(date), now);
}
if (!get_client_name(ua, rx)) {
return 0;
}
ua->send_msg(_("Enter full directory names or start the name\n"
"with a < to indicate it is a filename containing a list\n"
"of directories and terminate them with a blank line.\n"));
for ( ;; ) {
if (!get_cmd(ua, _("Enter directory name: "))) {
return 0;
}
len = strlen(ua->cmd);
if (len == 0) {
break;
}
/* Add trailing slash to end of directory names */
if (ua->cmd[0] != '<' && !IsPathSeparator(ua->cmd[len-1])) {
strcat(ua->cmd, "/");
}
insert_one_file_or_dir(ua, rx, date, true);
}
return 2;
case 11: /* Choose a jobid and select jobs */
if (!get_cmd(ua, _("Enter JobId to get the state to restore: ")) ||
!is_an_integer(ua->cmd))
{
return 0;
}
memset(&jr, 0, sizeof(jr));
jr.JobId = str_to_int64(ua->cmd);
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
ua->cmd, db_strerror(ua->db));
return 0;
}
ua->send_msg(_("Selecting jobs to build the Full state at %s\n"),
jr.cStartTime);
jr.JobLevel = L_INCREMENTAL; /* Take Full+Diff+Incr */
if (!db_accurate_get_jobids(ua->jcr, ua->db, &jr, &jobids)) {
return 0;
}
pm_strcpy(rx->JobIds, jobids.list);
Dmsg1(30, "Item 12: jobids = %s\n", rx->JobIds);
break;
case 12: /* Cancel or quit */
return 0;
}
}
memset(&jr, 0, sizeof(jr));
POOLMEM *JobIds = get_pool_memory(PM_FNAME);
*JobIds = 0;
rx->TotalFiles = 0;
/*
* Find total number of files to be restored, and filter the JobId
* list to contain only ones permitted by the ACL conditions.
*/
for (p=rx->JobIds; ; ) {
char ed1[50];
int status = get_next_jobid_from_list(&p, &JobId);
if (status < 0) {
ua->error_msg(_("Invalid JobId in list.\n"));
free_pool_memory(JobIds);
return 0;
}
if (status == 0) {
break;
}
if (jr.JobId == JobId) {
continue; /* duplicate of last JobId */
}
memset(&jr, 0, sizeof(jr));
jr.JobId = JobId;
if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
ua->error_msg(_("Unable to get Job record for JobId=%s: ERR=%s\n"),
edit_int64(JobId, ed1), db_strerror(ua->db));
free_pool_memory(JobIds);
return 0;
}
if (!acl_access_ok(ua, Job_ACL, jr.Name, true)) {
ua->error_msg(_("Access to JobId=%s (Job \"%s\") not authorized. Not selected.\n"),
edit_int64(JobId, ed1), jr.Name);
continue;
}
if (*JobIds != 0) {
pm_strcat(JobIds, ",");
}
pm_strcat(JobIds, edit_int64(JobId, ed1));
rx->TotalFiles += jr.JobFiles;
}
free_pool_memory(rx->JobIds);
rx->JobIds = JobIds; /* Set ACL filtered list */
if (*rx->JobIds == 0) {
ua->warning_msg(_("No Jobs selected.\n"));
return 0;
}
if (strchr(rx->JobIds,',')) {
ua->info_msg(_("You have selected the following JobIds: %s\n"), rx->JobIds);
} else {
ua->info_msg(_("You have selected the following JobId: %s\n"), rx->JobIds);
}
return true;
}
/*
* Scan for right hand side of Include options (keyword=option) is
* converted into one or two characters. Verifyopts=xxxx is Vxxxx:
* Whatever is found is concatenated to the opts string.
* This code is also used inside an Options resource.
*/
static void scan_include_options(LEX *lc, int keyword, char *opts, int optlen)
{
int i;
char option[3];
int lcopts = lc->options;
struct s_sz_matching size_matching;
option[0] = 0; /* default option = none */
option[2] = 0; /* terminate options */
lc->options |= LOPT_STRING; /* force string */
lex_get_token(lc, T_STRING); /* expect at least one option */
if (keyword == INC_KW_VERIFY) { /* special case */
/* ***FIXME**** ensure these are in permitted set */
bstrncat(opts, "V", optlen); /* indicate Verify */
bstrncat(opts, lc->str, optlen);
bstrncat(opts, ":", optlen); /* terminate it */
Dmsg3(900, "Catopts=%s option=%s optlen=%d\n", opts, option,optlen);
} else if (keyword == INC_KW_ACCURATE) { /* special case */
/* ***FIXME**** ensure these are in permitted set */
bstrncat(opts, "C", optlen); /* indicate Accurate */
bstrncat(opts, lc->str, optlen);
bstrncat(opts, ":", optlen); /* terminate it */
Dmsg3(900, "Catopts=%s option=%s optlen=%d\n", opts, option,optlen);
} else if (keyword == INC_KW_BASEJOB) { /* special case */
/* ***FIXME**** ensure these are in permitted set */
bstrncat(opts, "J", optlen); /* indicate BaseJob */
bstrncat(opts, lc->str, optlen);
bstrncat(opts, ":", optlen); /* terminate it */
Dmsg3(900, "Catopts=%s option=%s optlen=%d\n", opts, option,optlen);
} else if (keyword == INC_KW_STRIPPATH) { /* special case */
if (!is_an_integer(lc->str)) {
scan_err1(lc, _("Expected a strip path positive integer, got:%s:"), lc->str);
}
bstrncat(opts, "P", optlen); /* indicate strip path */
bstrncat(opts, lc->str, optlen);
bstrncat(opts, ":", optlen); /* terminate it */
Dmsg3(900, "Catopts=%s option=%s optlen=%d\n", opts, option,optlen);
} else if (keyword == INC_KW_SIZE) { /* special case */
if (!parse_size_match(lc->str, &size_matching)) {
scan_err1(lc, _("Expected a parseable size, got:%s:"), lc->str);
}
bstrncat(opts, "z", optlen); /* indicate size */
bstrncat(opts, lc->str, optlen);
bstrncat(opts, ":", optlen); /* terminate it */
Dmsg3(900, "Catopts=%s option=%s optlen=%d\n", opts, option,optlen);
} else {
/*
* Standard keyword options for Include/Exclude
*/
for (i=0; FS_options[i].name; i++) {
if (FS_options[i].keyword == keyword && bstrcasecmp(lc->str, FS_options[i].name)) {
/* NOTE! maximum 2 letters here or increase option[3] */
option[0] = FS_options[i].option[0];
option[1] = FS_options[i].option[1];
i = 0;
break;
}
}
if (i != 0) {
scan_err1(lc, _("Expected a FileSet option keyword, got:%s:"), lc->str);
} else { /* add option */
bstrncat(opts, option, optlen);
Dmsg3(900, "Catopts=%s option=%s optlen=%d\n", opts, option,optlen);
}
}
lc->options = lcopts;
/* If option terminated by comma, eat it */
if (lc->ch == ',') {
lex_get_token(lc, T_ALL); /* yes, eat comma */
}
}
/*
** Return file count
** setvals==1 to set all values based on options
** ==2 to set only ansi, user interface, exit on complete
** ==0 to not set any values
** procfiles == 1 to process files
** == 0 to count files only
*/
int parse_cmd_args(K2PDFOPT_SETTINGS *k2settings,STRBUF *env,STRBUF *cmdline,
STRBUF *usermenu,int setvals,int procfiles)
{
CMDLINEINPUT _cl,*cl;
STRBUF *allopts,_allopts;
int filecount,readnext;
allopts=&_allopts;
strbuf_init(allopts);
strbuf_cpy(allopts,env->s);
strbuf_cat(allopts,cmdline->s);
strbuf_cat(allopts,usermenu->s);
cl=&_cl;
filecount=0;
cmdlineinput_init(cl,0,NULL,allopts->s);
readnext=1;
while (1)
{
if (readnext && cmdlineinput_next(cl)==NULL)
break;
readnext=1;
if (!stricmp(cl->cmdarg,"-?") || !stricmp(cl->cmdarg,"-?-"))
{
if (setvals==2)
k2settings->show_usage = cl->cmdarg[2]=='-' ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-a") || !stricmp(cl->cmdarg,"-a-"))
{
if (setvals>=1)
ansi_set(cl->cmdarg[2]=='-' ? 0 : 1);
continue;
}
if (!stricmp(cl->cmdarg,"-x") || !stricmp(cl->cmdarg,"-x-"))
{
if (setvals>=1)
k2settings->exit_on_complete=(cl->cmdarg[2]=='-' ? 0 : 1);
continue;
}
if (!strnicmp(cl->cmdarg,"-ui",3))
{
if (setvals>=1)
{
if (cl->cmdarg[3]!='-')
k2settings->query_user_explicit=1;
k2settings->query_user=(cl->cmdarg[3]!='-') ? 1 : 0;
}
continue;
}
if (!stricmp(cl->cmdarg,"-evl"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->erase_vertical_lines=atoi(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-vls"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->vertical_line_spacing=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-vm"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->vertical_multiplier=fabs(atof(cl->cmdarg));
if (k2settings->vertical_multiplier < 0.1)
k2settings->vertical_multiplier = 0.1;
}
continue;
}
if (!stricmp(cl->cmdarg,"-vs"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->max_vertical_gap_inches=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-de"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->defect_size_pts=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-dev"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==2 && !strcmp(cl->cmdarg,"?"))
{
devprofiles_echo(stdout);
k2sys_exit(k2settings,0);
}
if (setvals==1)
{
if (!k2pdfopt_settings_set_to_device(k2settings,devprofile_get(cl->cmdarg)))
aprintf(TTEXT_WARN "\aDevice profile '%s' not known." TTEXT_NORMAL "\n",cl->cmdarg);
}
continue;
}
if (!stricmp(cl->cmdarg,"-pi") || !stricmp(cl->cmdarg,"-pi-"))
{
if (setvals==1)
k2settings->preserve_indentation=(cl->cmdarg[3]=='-') ? 0 : 1;
continue;
}
if (!strnicmp(cl->cmdarg,"-wrap",5))
{
if (setvals==1)
{
k2settings->text_wrap=(cl->cmdarg[5]=='-') ? 0 : (cl->cmdarg[5]=='+' ? 2 : 1);
if (k2settings->text_wrap)
k2settings->use_crop_boxes=0;
}
continue;
}
#ifdef HAVE_MUPDF_LIB
if (!stricmp(cl->cmdarg,"-gs") || !stricmp(cl->cmdarg,"-gs-")
|| !stricmp(cl->cmdarg,"-gs--"))
{
if (setvals==1)
k2settings->user_usegs=(cl->cmdarg[3]=='-' ? (cl->cmdarg[4]=='-' ? -1 : 0) : 1);
continue;
}
if (!stricmp(cl->cmdarg,"-n") || !stricmp(cl->cmdarg,"-n-"))
{
if (setvals==1)
{
k2settings->use_crop_boxes=(cl->cmdarg[2]=='-') ? 0 : 1;
if (k2settings->use_crop_boxes)
{
k2settings->text_wrap=0;
#ifdef HAVE_OCR_LIB
k2settings->dst_ocr=0;
#endif
}
}
continue;
}
#endif
if (!stricmp(cl->cmdarg,"-neg") || !stricmp(cl->cmdarg,"-neg-"))
{
if (setvals==1)
k2settings->dst_negative=(cl->cmdarg[4]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-r") || !stricmp(cl->cmdarg,"-r-"))
{
if (setvals==1)
k2settings->src_left_to_right=(cl->cmdarg[2]=='-') ? 1 : 0;
continue;
}
if (!strnicmp(cl->cmdarg,"-hy",3))
{
if (setvals==1)
k2settings->hyphen_detect=(cl->cmdarg[3]=='-') ? 0 : 1;
continue;
}
if (!strnicmp(cl->cmdarg,"-ls",3))
{
if (setvals==1)
k2settings->dst_landscape=(cl->cmdarg[3]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-mode"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
if (!stricmp(cl->cmdarg,"pdfr")
|| !stricmp(cl->cmdarg,"copy"))
{
/* -n- -wrap- -col 1 -vb -2 -w -1 -h -1 -dpi 150 -rt 0 -c -t- -f2p -2 */
/* -m 0 -om 0 -pl 0 -pr 0 -pt 0 -pb 0 -mc- */
k2settings->use_crop_boxes=0;
k2settings->text_wrap=0;
k2settings->max_columns=1;
k2settings->vertical_break_threshold=-2;
k2settings->dst_userwidth=-1.0;
k2settings->dst_userwidth_units=UNITS_PIXELS;
k2settings->dst_userheight=-1.0;
k2settings->dst_userheight_units=UNITS_PIXELS;
k2settings->dst_dpi=150;
k2settings->src_rot=0.;
k2settings->dst_color=1;
k2settings->src_trim=0;
k2settings->dst_fit_to_page=-2;
k2settings->mar_left=k2settings->mar_top=k2settings->mar_right=k2settings->mar_bot=0.;
k2settings->dst_mar=k2settings->dst_marleft=k2settings->dst_martop=k2settings->dst_marright=k2settings->dst_marbot=0.;
k2settings->pad_left=k2settings->pad_top=k2settings->pad_bottom=k2settings->pad_right=0;
k2settings->mark_corners=0;
}
else if (!stricmp(cl->cmdarg,"fw")
|| !stricmp(cl->cmdarg,"sopdf")
|| !stricmp(cl->cmdarg,"fitwidth"))
{
/* -wrap- -col 1 -vb -2 -t -ls */
k2settings->use_crop_boxes=1;
k2settings->text_wrap=0;
k2settings->max_columns=1;
k2settings->vertical_break_threshold=-2;
k2settings->src_trim=1;
k2settings->dst_landscape=1;
}
else if (!stricmp(cl->cmdarg,"2col")
|| !stricmp(cl->cmdarg,"col2"))
{
k2settings->use_crop_boxes=1;
k2settings->text_wrap=0;
k2settings->max_columns=2;
k2settings->vertical_break_threshold=-2;
k2settings->src_trim=1;
}
else if (!stricmp(cl->cmdarg,"def")
|| !stricmp(cl->cmdarg,"default")
|| !stricmp(cl->cmdarg,"std")
|| !stricmp(cl->cmdarg,"standard"))
{
k2pdfopt_settings_set_to_device(k2settings,devprofile_get("k2"));
k2settings->use_crop_boxes=1;
k2settings->text_wrap=1;
k2settings->max_columns=2;
k2settings->vertical_break_threshold=1.75;
k2settings->src_rot=SRCROT_AUTO;
k2settings->src_trim=1;
k2settings->dst_fit_to_page=0;
k2settings->mar_left=k2settings->mar_top=k2settings->mar_right=k2settings->mar_bot=0.25;
k2settings->dst_mar=k2settings->dst_marleft=k2settings->dst_martop=k2settings->dst_marright=k2settings->dst_marbot=0.02;
}
else
aprintf(TTEXT_WARN "\a\n** Unknown mode: %s **\n\n" TTEXT_NORMAL,
cl->cmdarg);
}
continue;
}
if (!stricmp(cl->cmdarg,"-o"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
strncpy(k2settings->dst_opname_format,cl->cmdarg,127);
k2settings->dst_opname_format[127]='\0';
}
continue;
}
if (!stricmp(cl->cmdarg,"-ow") || !stricmp(cl->cmdarg,"-ow-"))
{
int always_prompt;
char *ptr;
always_prompt = (cl->cmdarg[3]=='-');
if (((ptr=cmdlineinput_next(cl))==NULL) || !is_a_number(cl->cmdarg))
{
readnext=0;
if (setvals==1)
k2settings->overwrite_minsize_mb= always_prompt ? 0 : -1;
if (ptr==NULL)
break;
continue;
}
if (setvals==1)
k2settings->overwrite_minsize_mb=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-grid"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
char buf[128];
double v[3];
int na,i;
strncpy(buf,cl->cmdarg,127);
buf[127]='\0';
k2settings->src_grid_order=0;
for (i=0; buf[i]!='\0'; i++)
{
if (tolower(buf[i])=='x')
buf[i]=' ';
if (buf[i]=='+' && buf[i+1]=='\0')
k2settings->src_grid_order=1;
}
na=string_read_doubles(buf,v,3);
if (na>=2)
{
k2settings->src_grid_cols=(int)(v[0]+.5);
k2settings->src_grid_rows=(int)(v[1]+.5);
if (na>2)
k2settings->src_grid_overlap_percentage=(int)(v[2]+.5);
}
else
k2settings->src_grid_cols = k2settings->src_grid_rows = -1;
if (k2settings->src_grid_cols>0 && k2settings->src_grid_rows>0)
{
k2settings->use_crop_boxes=1;
k2settings->dst_fit_to_page=-2;
k2settings->vertical_break_threshold=-2;
k2settings->text_wrap=1;
k2settings->max_columns=1;
}
}
continue;
}
if (!stricmp(cl->cmdarg,"-f2p"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->dst_fit_to_page=atoi(cl->cmdarg);
if (k2settings->dst_fit_to_page == -2)
k2settings->vertical_break_threshold=-2.;
}
continue;
}
if (!stricmp(cl->cmdarg,"-vb"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->vertical_break_threshold=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-sm") || !stricmp(cl->cmdarg,"-sm-"))
{
if (setvals==1)
k2settings->show_marked_source=(cl->cmdarg[3]=='-' ? 0 : 1);
continue;
}
if (!stricmp(cl->cmdarg,"-bp") || !stricmp(cl->cmdarg,"-bp-"))
{
if (cl->cmdarg[3]=='-')
{
if (setvals==1)
k2settings->dst_break_pages=0;
continue;
}
if (cmdlineinput_next(cl)==NULL)
break;
if (is_a_number(cl->cmdarg))
{
if (setvals==1)
k2settings->dst_break_pages= -1 - (int)(atof(cl->cmdarg)*1000.+.5);
}
else
{
if (setvals==1)
k2settings->dst_break_pages=1;
readnext=0;
}
continue;
}
if (!strnicmp(cl->cmdarg,"-fc",3))
{
if (setvals==1)
k2settings->fit_columns=(cl->cmdarg[3]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-d") || !stricmp(cl->cmdarg,"-d-"))
{
if (setvals==1)
k2settings->dst_dither=(cl->cmdarg[2]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-c") || !stricmp(cl->cmdarg,"-c-"))
{
if (setvals==1)
{
k2settings->dst_color=(cl->cmdarg[2]=='-') ? 0 : 1;
/* wrapbmp_set_color(k2settings->dst_color); */
}
continue;
}
if (!strnicmp(cl->cmdarg,"-v",2))
{
if (setvals==1)
k2settings->verbose=(cl->cmdarg[2]=='-') ? 0 : 1;
continue;
}
if (!strnicmp(cl->cmdarg,"-png",4))
{
if (setvals==1)
k2settings->jpeg_quality=(cl->cmdarg[4]=='-') ? 90 : -1;
continue;
}
if (!strnicmp(cl->cmdarg,"-mc",3))
{
if (setvals==1)
k2settings->mark_corners=(cl->cmdarg[3]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-ocrlang") || !stricmp(cl->cmdarg,"-l"))
{
if (cmdlineinput_next(cl)==NULL)
break;
#ifdef HAVE_TESSERACT_LIB
strncpy(k2settings->dst_ocr_lang,cl->cmdarg,15);
k2settings->dst_ocr_lang[15]='\0';
#endif
continue;
}
if (!stricmp(cl->cmdarg,"-ocrvis"))
{
if (cmdlineinput_next(cl)==NULL)
break;
#ifdef HAVE_OCR_LIB
if (setvals==1)
{
k2settings->dst_ocr_visibility_flags=0;
if (in_string(cl->cmdarg,"s")>=0)
k2settings->dst_ocr_visibility_flags |= 1;
if (in_string(cl->cmdarg,"t")>=0)
k2settings->dst_ocr_visibility_flags |= 2;
if (in_string(cl->cmdarg,"b")>=0)
k2settings->dst_ocr_visibility_flags |= 4;
}
#endif
continue;
}
if (!stricmp(cl->cmdarg,"-ocrhmax"))
{
if (cmdlineinput_next(cl)==NULL)
break;
#ifdef HAVE_OCR_LIB
if (setvals==1)
k2settings->ocr_max_height_inches=atof(cl->cmdarg);
#endif
continue;
}
if (!stricmp(cl->cmdarg,"-ocr") || !stricmp(cl->cmdarg,"-ocr-"))
{
#ifndef HAVE_OCR_LIB
if (setvals==1)
{
static int warned=0;
if (!warned)
aprintf(TTEXT_WARN "\a\n** No OCR capability in this compile of k2pdfopt! **\n\n"
TTEXT_NORMAL);
warned=1;
}
#endif
if (cl->cmdarg[4]=='-')
{
#ifdef HAVE_OCR_LIB
if (setvals==1)
k2settings->dst_ocr=0;
#endif
continue;
}
if (cmdlineinput_next(cl)==NULL || !stricmp(cl->cmdarg,"t"))
{
#ifdef HAVE_OCR_LIB
if (setvals==1)
{
k2settings->dst_ocr='t';
k2settings->use_crop_boxes=0;
}
#endif
continue;
}
if (!stricmp(cl->cmdarg,"g") || !stricmp(cl->cmdarg,"j"))
{
#ifdef HAVE_OCR_LIB
if (setvals==1)
{
k2settings->dst_ocr='g';
k2settings->use_crop_boxes=0;
}
#endif
continue;
}
#ifdef HAVE_OCR_LIB
if (setvals==1)
{
#ifdef HAVE_TESSERACT_LIB
k2settings->dst_ocr='t';
#else
k2settings->dst_ocr='g';
#endif
k2settings->use_crop_boxes=0;
}
#endif
readnext=0;
continue;
}
if (!stricmp(cl->cmdarg,"-t") || !stricmp(cl->cmdarg,"-t-"))
{
if (setvals==1)
k2settings->src_trim=(cl->cmdarg[2]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-s") || !stricmp(cl->cmdarg,"-s-"))
{
if (setvals==1)
k2settings->dst_sharpen=(cl->cmdarg[2]=='-') ? 0 : 1;
continue;
}
if (!stricmp(cl->cmdarg,"-as"))
{
if (setvals==1)
k2settings->src_autostraighten=4.;
if (cmdlineinput_next(cl)==NULL)
break;
if (is_a_number(cl->cmdarg))
{
if (setvals==1)
k2settings->src_autostraighten=atof(cl->cmdarg);
}
else
readnext=0;
if (k2settings->src_autostraighten > 45.)
k2settings->src_autostraighten = 45.;
continue;
}
if (!stricmp(cl->cmdarg,"-rt"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
if (!stricmp(cl->cmdarg,"auto"))
k2settings->src_rot=SRCROT_AUTO;
else if (!stricmp(cl->cmdarg,"aep"))
k2settings->src_rot=SRCROT_AUTOEP;
else
k2settings->src_rot=atoi(cl->cmdarg);
}
continue;
}
if (!stricmp(cl->cmdarg,"-crgh"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->column_row_gap_height_in=atof(cl->cmdarg);
if (k2settings->column_row_gap_height_in < 0.001)
k2settings->column_row_gap_height_in = 0.001;
}
continue;
}
if (!stricmp(cl->cmdarg,"-cgr"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->column_gap_range=atof(cl->cmdarg);
if (k2settings->column_gap_range < 0.)
k2settings->column_gap_range = 0.;
if (k2settings->column_gap_range > 1.0)
k2settings->column_gap_range = 1.0;
}
continue;
}
if (!stricmp(cl->cmdarg,"-comax"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->column_offset_max=atof(cl->cmdarg);
if (k2settings->column_offset_max > 1.0)
k2settings->column_offset_max = 1.0;
}
continue;
}
if (!stricmp(cl->cmdarg,"-col"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->max_columns=atoi(cl->cmdarg);
if (k2settings->max_columns<1)
k2settings->max_columns=1;
if (k2settings->max_columns>2)
k2settings->max_columns=4;
}
continue;
}
if (!strnicmp(cl->cmdarg,"-jpg",4) || !strnicmp(cl->cmdarg,"-jpeg",5))
{
int ic;
ic = (tolower(cl->cmdarg[3])=='g') ? 4 : 5;
if (cl->cmdarg[ic]=='-')
{
if (setvals==1)
k2settings->jpeg_quality=-1;
}
else
{
if (cmdlineinput_next(cl)==NULL)
{
if (setvals==1)
k2settings->jpeg_quality=90;
}
else if (is_an_integer(cl->cmdarg))
{
if (setvals==1)
k2settings->jpeg_quality=atoi(cl->cmdarg);
}
else
{
readnext=0;
if (setvals==1)
k2settings->jpeg_quality=90;
}
}
if (k2settings->jpeg_quality>100)
k2settings->jpeg_quality=100;
continue;
}
if (!stricmp(cl->cmdarg,"-col"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->max_columns=atoi(cl->cmdarg);
if (k2settings->max_columns<1)
k2settings->max_columns=1;
if (k2settings->max_columns>2)
k2settings->max_columns=4;
}
continue;
}
if (!stricmp(cl->cmdarg,"-p"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
strncpy(k2settings->pagelist,cl->cmdarg,1023);
k2settings->pagelist[1023]='\0';
}
continue;
}
if (!stricmp(cl->cmdarg,"-bpc"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->dst_bpc=atoi(cl->cmdarg);
if (k2settings->dst_bpc>=6)
k2settings->dst_bpc=8;
else if (k2settings->dst_bpc>=3)
k2settings->dst_bpc=4;
else if (k2settings->dst_bpc<1)
k2settings->dst_bpc=1;
}
continue;
}
if (!stricmp(cl->cmdarg,"-g"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->dst_gamma=atof(cl->cmdarg);
if (k2settings->dst_gamma<.01)
k2settings->dst_gamma=.01;
if (k2settings->dst_gamma>100.)
k2settings->dst_gamma=100.;
}
continue;
}
if (!stricmp(cl->cmdarg,"-cg"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->min_column_gap_inches=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-cgmax"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->max_column_gap_inches=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-gtr"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->gtr_in=atof(cl->cmdarg);
if (k2settings->gtr_in<0.)
k2settings->gtr_in=0.;
}
continue;
}
if (!stricmp(cl->cmdarg,"-gtc"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->gtc_in=atof(cl->cmdarg);
if (k2settings->gtc_in<0.)
k2settings->gtc_in=0.;
}
continue;
}
if (!stricmp(cl->cmdarg,"-gtw"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->gtw_in=atof(cl->cmdarg);
if (k2settings->gtw_in<0.)
k2settings->gtw_in=0.;
}
continue;
}
/*
if (i<argc-1 && !stricmp(cl->cmdarg,"-cd"))
{
if (setvals==1)
{
cdthresh=atof(argv[++i]);
if (cdthresh<0.)
cdthresh=0.;
else if (cdthresh>100.)
cdthresh=100.;
}
else
i++;
continue;
}
*/
if (!stricmp(cl->cmdarg,"-cmax"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->contrast_max=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-ch"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->min_column_height_inches=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-ds"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1 && atof(cl->cmdarg)>0.)
k2settings->document_scale_factor=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-idpi"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1 && atof(cl->cmdarg)!=0.)
k2settings->user_src_dpi=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-odpi") || !stricmp(cl->cmdarg,"-dpi"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_dpi=atoi(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-jf"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_figure_justify=atoi(cl->cmdarg);
if (cmdlineinput_next(cl)==NULL)
break;
if (!is_a_number(cl->cmdarg))
{
readnext=0;
continue;
}
if (setvals==1)
k2settings->dst_min_figure_height_in=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-j"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->dst_justify=atoi(cl->cmdarg);
if (in_string(cl->cmdarg,"+")>=0)
k2settings->dst_fulljustify=1;
else if (in_string(&cl->cmdarg[1],"-")>=0)
k2settings->dst_fulljustify=0;
else
k2settings->dst_fulljustify=-1;
}
continue;
}
if (!stricmp(cl->cmdarg,"-dr"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_display_resolution=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-h"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
set_value_with_units(cl->cmdarg,&k2settings->dst_userheight,&k2settings->dst_userheight_units);
continue;
}
if (!stricmp(cl->cmdarg,"-ws"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->word_spacing=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-wt"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
k2settings->src_whitethresh=atoi(cl->cmdarg);
if (k2settings->src_whitethresh>255)
k2settings->src_whitethresh=255;
}
continue;
}
if (!stricmp(cl->cmdarg,"-w"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
set_value_with_units(cl->cmdarg,&k2settings->dst_userwidth,&k2settings->dst_userwidth_units);
continue;
}
if (!stricmp(cl->cmdarg,"-omb"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_marbot=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-omt"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_martop=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-omr"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_marright=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-oml"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->dst_marleft=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-om"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
double v[4];
int na;
na=string_read_doubles(cl->cmdarg,v,4);
if (na>=1)
k2settings->dst_mar=k2settings->dst_marleft=k2settings->dst_martop=k2settings->dst_marright=k2settings->dst_marbot=v[0];
if (na>=2)
k2settings->dst_martop=k2settings->dst_marright=k2settings->dst_marbot=v[1];
if (na>=3)
k2settings->dst_marright=k2settings->dst_marbot=v[2];
if (na>=4)
k2settings->dst_marbot=v[3];
}
continue;
}
if (!stricmp(cl->cmdarg,"-mb"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->mar_bot=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-mt"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->mar_top=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-mr"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->mar_right=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-ml"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->mar_left=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-pb"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->pad_bottom=atoi(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-pt"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->pad_top=atoi(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-pr"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->pad_right=atoi(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-pl"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->pad_left=atoi(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-m"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
{
double v[4];
int na;
na=string_read_doubles(cl->cmdarg,v,4);
if (na>=1)
k2settings->mar_left=k2settings->mar_top=k2settings->mar_right=k2settings->mar_bot=v[0];
if (na>=2)
k2settings->mar_top=k2settings->mar_right=k2settings->mar_bot=v[1];
if (na>=3)
k2settings->mar_right=k2settings->mar_bot=v[2];
if (na>=4)
k2settings->mar_bot=v[3];
}
continue;
}
if (!strnicmp(cl->cmdarg,"-hq",3))
{
if (setvals==1)
continue;
if (cl->cmdarg[3]=='-')
{
k2settings->dst_dpi=167;
k2settings->user_src_dpi = -2.0;
k2settings->dst_userwidth=DEFAULT_WIDTH;
k2settings->dst_userwidth_units=UNITS_PIXELS;
k2settings->dst_userheight=DEFAULT_HEIGHT;
k2settings->dst_userheight_units=UNITS_PIXELS;
}
else
{
k2settings->dst_dpi=333;
k2settings->user_src_dpi = -2.0;
k2settings->dst_userwidth=DEFAULT_WIDTH*2;
k2settings->dst_userheight=DEFAULT_HEIGHT*2;
k2settings->dst_userwidth_units=UNITS_PIXELS;
k2settings->dst_userheight_units=UNITS_PIXELS;
}
continue;
}
if (!stricmp(cl->cmdarg,"-debug"))
{
if (setvals==1)
k2settings->debug=1;
if (cmdlineinput_next(cl)==NULL)
break;
if (is_an_integer(cl->cmdarg))
{
if (setvals==1)
k2settings->debug=atoi(cl->cmdarg);
}
else
readnext=0;
continue;
}
/*
** UNDOCUMENTED COMMAND-LINE ARGS
*/
if (!stricmp(cl->cmdarg,"-whmax"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->no_wrap_height_limit_inches=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-arlim"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->no_wrap_ar_limit=atof(cl->cmdarg);
continue;
}
if (!stricmp(cl->cmdarg,"-rwmin"))
{
if (cmdlineinput_next(cl)==NULL)
break;
if (setvals==1)
k2settings->little_piece_threshold_inches=atof(cl->cmdarg);
continue;
}
filecount++;
/*
if (filecount==1 && firstfile!=NULL)
{
strncpy(firstfile,cl->cmdarg,255);
firstfile[255]='\0';
}
*/
if (procfiles)
k2pdfopt_proc_wildarg(k2settings,cl->cmdarg);
}
strbuf_free(allopts);
return(filecount);
}
/*
* 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;
}
/*
* Returns next item
* error if returns -1 and errmsg set
* end of items if returns -1 and errmsg NULL
*/
int64_t sellist::next()
{
errmsg = NULL;
if (beg <= end) {
return beg++;
}
if (e == NULL) {
goto bail_out;
}
/*
* As we walk the list, we set EOF in
* the end of the next item to ease scanning,
* but save and then restore the character.
*/
for (p=e; p && *p; p=e) {
/* Check for list */
e = strchr(p, ',');
if (e) {
esave = *e;
*e++ = 0;
} else {
esave = 0;
}
/* Check for range */
h = strchr(p, '-'); /* range? */
if (h == p) {
errmsg = _("Negative numbers not permitted.\n");
goto bail_out;
}
if (h) {
hsave = *h;
*h++ = 0;
if (!is_an_integer(h)) {
errmsg = _("Range end is not integer.\n");
goto bail_out;
}
skip_spaces(&p);
if (!is_an_integer(p)) {
errmsg = _("Range start is not an integer.\n");
goto bail_out;
}
beg = str_to_int64(p);
end = str_to_int64(h);
if (end < beg) {
errmsg = _("Range end not bigger than start.\n");
goto bail_out;
}
} else {
hsave = 0;
skip_spaces(&p);
if (!is_an_integer(p)) {
errmsg = _("Input value is not an integer.\n");
goto bail_out;
}
beg = end = str_to_int64(p);
}
if (esave) {
*(e-1) = esave;
}
if (hsave) {
*(h-1) = hsave;
}
if (beg <= 0 || end <= 0) {
errmsg = _("Selection items must be be greater than zero.\n");
goto bail_out;
}
if (end > max) {
errmsg = _("Selection item too large.\n");
goto bail_out;
}
if (beg <= end) {
return beg++;
}
}
/* End of items */
errmsg = NULL; /* No error */
return -1;
bail_out:
return -1; /* Error, errmsg set */
}
/*
** Accepts most date string formats:
** JAN DD YYYY|YY
** DD JAN YYYY|YY
** YYYY JAN DD
** YYYY DD JAN
** DD YYYY JAN
** YYYY-MM-DD
** MM-DD-YYYY|YY [Default]
**
** CAUTION! This function zeros the time fields!
*/
int structtm_from_date(struct tm *date,char *datestr)
{
static char *months[]={"jan","feb","mar","apr","may","jun",
"jul","aug","sep","oct","nov","dec"};
char buf[32];
char tok[3][32];
int num[3];
int mon[3];
int i,j,n,yr;
strncpy(buf,datestr,31);
buf[31]='\0';
date->tm_year=0;
date->tm_mon=0;
date->tm_mday=1;
for (i=0;buf[i]!='\0';i++)
if (buf[i]=='/' || buf[i]=='-' || buf[i]=='\\'
|| buf[i]=='.' || buf[i]==':')
buf[i]=' ';
n=sscanf(buf,"%s %s %s",tok[0],tok[1],tok[2]);
yr = -1;
for (i=0;i<n;i++)
{
mon[i]=0;
if (is_an_integer(tok[i]))
{
num[i]=atoi(tok[i]);
continue;
}
for (j=0;j<12;j++)
if (!strnicmp(months[j],tok[i],3))
break;
if (j<12)
{
num[i]=j+1;
mon[i]=1;
}
else
num[i]=-1;
}
if (n>0 && mon[0]==1)
{
date->tm_mon=num[0]-1;
if (n>1)
date->tm_mday=num[1];
if (n>2)
yr=num[2];
}
else if (n>1 && mon[1]==1)
{
date->tm_mon=num[1]-1;
if (num[0]>31)
{
yr=num[0];
if (n>2)
date->tm_mday=num[2];
}
else
{
date->tm_mday=num[0];
if (n>2)
yr=num[2];
}
}
else if (n>2 && mon[2]==1)
{
date->tm_mon=num[2]-1;
if (num[1]>31)
{
yr=num[1];
date->tm_mday=num[0];
}
else
{
yr=num[0];
date->tm_mday=num[1];
}
}
else if (n>0 && num[0]>31)
{
yr=num[0];
if (n>1)
{
if (num[1]<=12)
date->tm_mon=num[1]-1;
else
date->tm_mday=num[1];
if (n>2)
{
if (num[1]<=12)
date->tm_mday=num[2];
else
date->tm_mon=num[2]-1;
}
}
}
else
{
if (n>0)
{
if (num[0]>12)
date->tm_mday=num[0];
else
date->tm_mon=num[0]-1;
if (n>1)
{
if (num[0]>12)
date->tm_mon=num[1]-1;
else
date->tm_mday=num[1];
if (n>2)
yr=num[2];
}
}
}
if (date->tm_mon<0 || date->tm_mon>12)
date->tm_mon=0;
if (date->tm_mday<1 || date->tm_mday>31)
date->tm_mday=1;
if (yr>=0)
{
year_adjust(&yr);
date->tm_year=yr-1900;
}
/* Get week day and year day right */
{
time_t lt;
date->tm_hour=0;
date->tm_min=0;
date->tm_sec=0;
date->tm_wday = -1;
date->tm_yday = -1;
date->tm_isdst = -1;
/*
printf("date = %d/%02d/%04d, %02d:%02d:%02d, wd=%d, yd=%d, isdst=%d\n",
date->tm_mon+1,date->tm_mday,date->tm_year+1900,date->tm_hour,date->tm_min,
date->tm_sec,date->tm_wday,date->tm_yday,date->tm_isdst);
*/
lt = mktime(date);
if (lt>=0)
(*date)=(*localtime(<));
else
{
date->tm_wday=0;
date->tm_yday=0;
date->tm_isdst=0;
}
/*
printf("date = %d/%02d/%04d, %02d:%02d:%02d, wd=%d, yd=%d, isdst=%d\n",
date->tm_mon+1,date->tm_mday,date->tm_year+1900,date->tm_hour,date->tm_min,
date->tm_sec,date->tm_wday,date->tm_yday,date->tm_isdst);
*/
}
return(0);
}
/*
* If full_list is set, we list vertically, otherwise, we
* list on one line horizontally.
* Return number of rows
*/
int list_result(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type type)
{
SQL_FIELD *field;
SQL_ROW row;
int i, col_len, max_len = 0;
int num_fields;
char buf[2000], ewc[30];
Dmsg0(800, "list_result starts\n");
if (sql_num_rows(mdb) == 0) {
send(ctx, _("No results to list.\n"));
return sql_num_rows(mdb);
}
num_fields = sql_num_fields(mdb);
switch (type) {
case NF_LIST:
case RAW_LIST:
/*
* No need to calculate things like column widths for
* unformated or raw output.
*/
break;
case HORZ_LIST:
case VERT_LIST:
Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
/*
* Determine column display widths
*/
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result processing field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
col_len = cstrlen(field->name);
if (type == VERT_LIST) {
if (col_len > max_len) {
max_len = col_len;
}
} else {
if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
field->max_length += (field->max_length - 1) / 3;
}
if (col_len < (int)field->max_length) {
col_len = field->max_length;
}
if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
col_len = 4; /* 4 = length of the word "NULL" */
}
field->max_length = col_len; /* reset column info */
}
}
break;
}
Dmsg0(800, "list_result finished first loop\n");
switch (type) {
case NF_LIST:
case RAW_LIST:
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
bsnprintf(buf, sizeof(buf), " %s", "NULL");
} else {
bsnprintf(buf, sizeof(buf), " %s", row[i]);
}
send(ctx, buf);
}
if (type != RAW_LIST) {
send(ctx, "\n");
}
}
break;
case HORZ_LIST:
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
list_dashes(mdb, send, ctx);
send(ctx, "|");
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result looking at field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
bsnprintf(buf, sizeof(buf), " %-*s |", max_len, field->name);
send(ctx, buf);
}
send(ctx, "\n");
list_dashes(mdb, send, ctx);
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
sql_field_seek(mdb, 0);
send(ctx, "|");
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
if (row[i] == NULL) {
bsnprintf(buf, sizeof(buf), " %-*s |", max_len, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
bsnprintf(buf, sizeof(buf), " %*s |", max_len,
add_commas(row[i], ewc));
} else {
bsnprintf(buf, sizeof(buf), " %-*s |", max_len, row[i]);
}
send(ctx, buf);
}
send(ctx, "\n");
}
list_dashes(mdb, send, ctx);
break;
case VERT_LIST:
Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name,
add_commas(row[i], ewc));
} else {
bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, row[i]);
}
send(ctx, buf);
}
send(ctx, "\n");
}
break;
}
return sql_num_rows(mdb);
}
int list_result(void *vctx, int nb_col, char **row)
{
SQL_FIELD *field;
int i, col_len, max_len = 0;
int num_fields;
char buf[2000], ewc[30];
LIST_CTX *pctx = (LIST_CTX *)vctx;
DB_LIST_HANDLER *send = pctx->send;
e_list_type type = pctx->type;
B_DB *mdb = pctx->mdb;
void *ctx = pctx->ctx;
JCR *jcr = pctx->jcr;
num_fields = sql_num_fields(mdb);
switch (type) {
case NF_LIST:
case RAW_LIST:
/*
* No need to calculate things like maximum field lenght for
* unformated or raw output.
*/
break;
case HORZ_LIST:
case VERT_LIST:
if (!pctx->once) {
pctx->once = true;
Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
/*
* Determine column display widths
*/
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result processing field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
col_len = cstrlen(field->name);
if (type == VERT_LIST) {
if (col_len > max_len) {
max_len = col_len;
}
} else {
if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
field->max_length += (field->max_length - 1) / 3;
}
if (col_len < (int)field->max_length) {
col_len = field->max_length;
}
if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
col_len = 4; /* 4 = length of the word "NULL" */
}
field->max_length = col_len; /* reset column info */
}
}
pctx->num_rows++;
Dmsg0(800, "list_result finished first loop\n");
if (type == VERT_LIST) {
break;
}
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
/*
* Keep the result to display the same line at the end of the table
*/
list_dashes(mdb, last_line_handler, pctx);
send(ctx, pctx->line);
send(ctx, "|");
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result looking at field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
bsnprintf(buf, sizeof(buf), " %-*s |", max_len, field->name);
send(ctx, buf);
}
send(ctx, "\n");
list_dashes(mdb, send, ctx);
}
break;
default:
break;
}
switch (type) {
case NF_LIST:
case RAW_LIST:
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
bsnprintf(buf, sizeof(buf), " %s", "NULL");
} else {
bsnprintf(buf, sizeof(buf), " %s", row[i]);
}
send(ctx, buf);
}
if (type != RAW_LIST) {
send(ctx, "\n");
}
break;
case HORZ_LIST:
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
send(ctx, "|");
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
if (row[i] == NULL) {
bsnprintf(buf, sizeof(buf), " %-*s |", max_len, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
bsnprintf(buf, sizeof(buf), " %*s |", max_len,
add_commas(row[i], ewc));
} else {
bsnprintf(buf, sizeof(buf), " %-*s |", max_len, row[i]);
}
send(ctx, buf);
}
send(ctx, "\n");
break;
case VERT_LIST:
Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name,
add_commas(row[i], ewc));
} else {
bsnprintf(buf, sizeof(buf), " %*s: %s\n", max_len, field->name, row[i]);
}
send(ctx, buf);
}
send(ctx, "\n");
break;
default:
break;
}
return 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;
}
