/*
* Check if the Volume name has legal characters
* If ua is non-NULL send the message
*/
static bool is_volume_name_legal(char *name)
{
int len;
const char *p;
const char *accept = ":.-_";
/* Restrict the characters permitted in the Volume name */
for (p=name; *p; p++) {
if (B_ISALPHA(*p) || B_ISDIGIT(*p) || strchr(accept, (int)(*p))) {
continue;
}
return false;
}
len = strlen(name);
if (len >= MAX_NAME_LENGTH) {
return false;
}
if (len == 0) {
return false;
}
return true;
}
/*
* Check if the Volume name has legal characters
* If ua is non-NULL send the message
*/
bool is_name_valid(const char *name, POOLMEM **msg)
{
int len;
const char *p;
/* Special characters to accept */
const char *accept = ":.-_ ";
/* No name is invalid */
if (!name) {
if (msg) {
Mmsg(msg, _("Empty name not allowed.\n"));
}
return false;
}
/* Restrict the characters permitted in the Volume name */
for (p=name; *p; p++) {
if (B_ISALPHA(*p) || B_ISDIGIT(*p) || strchr(accept, (int)(*p))) {
continue;
}
if (msg) {
Mmsg(msg, _("Illegal character \"%c\" in name.\n"), *p);
}
return false;
}
len = p - name;
if (len >= MAX_NAME_LENGTH) {
if (msg) {
Mmsg(msg, _("Name too long.\n"));
}
return false;
}
if (len == 0) {
if (msg) {
Mmsg(msg, _("Volume name must be at least one character long.\n"));
}
return false;
}
return true;
}
/*
* 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;
}
/*
* Get a message
* Call appropriate processing routine
* If it is not a Jmsg or a ReqCat message,
* return it to the caller.
*
* This routine is called to get the next message from
* another daemon. If the message is in canonical message
* format and the type is known, it will be dispatched
* to the appropriate handler. If the message is
* in any other format, it will be returned.
*
* E.g. any message beginning with a digit will be passed
* through to the caller.
* All other messages are expected begin with some identifier
* -- for the moment only the first character is checked, but
* at a later time, the whole identifier (e.g. Jmsg, CatReq, ...)
* could be checked. This is followed by Job=Jobname <user-defined>
* info. The identifier is used to dispatch the message to the right
* place (Job message, catalog request, ...). The Job is used to lookup
* the JCR so that the action is performed on the correct jcr, and
* the rest of the message is up to the user. Note, DevUpd uses
* *System* for the Job name, and hence no JCR is obtained. This
* is a *rare* case where a jcr is not really needed.
*
*/
int bget_dirmsg(BSOCK *bs, bool allow_any_message)
{
int32_t n = BNET_TERMINATE;
char Job[MAX_NAME_LENGTH];
char MsgType[20];
int type;
utime_t mtime; /* message time */
JCR *jcr = bs->jcr();
char *msg;
for ( ; !bs->is_stop() && !bs->is_timed_out(); ) {
n = bs->recv();
Dmsg2(200, "bget_dirmsg %d: %s\n", n, bs->msg);
if (bs->is_stop() || bs->is_timed_out()) {
return n; /* error or terminate */
}
if (n == BNET_SIGNAL) { /* handle signal */
/* BNET_SIGNAL (-1) return from bnet_recv() => network signal */
switch (bs->msglen) {
case BNET_EOD: /* end of data */
return n;
case BNET_EOD_POLL:
bs->fsend(OK_msg);/* send response */
return n; /* end of data */
case BNET_TERMINATE:
bs->set_terminated();
return n;
case BNET_POLL:
bs->fsend(OK_msg); /* send response */
break;
case BNET_HEARTBEAT:
// encode_time(time(NULL), Job);
// Dmsg1(100, "%s got heartbeat.\n", Job);
break;
case BNET_HB_RESPONSE:
break;
case BNET_STATUS:
/* *****FIXME***** Implement more completely */
bs->fsend("Status OK\n");
bs->signal(BNET_EOD);
break;
case BNET_BTIME: /* send BAREOS time */
char ed1[50];
bs->fsend("btime %s\n", edit_uint64(get_current_btime(),ed1));
break;
default:
Jmsg1(jcr, M_WARNING, 0, _("bget_dirmsg: unknown bnet signal %d\n"), bs->msglen);
return n;
}
continue;
}
/*
* Handle normal data
*/
if (n > 0 && B_ISDIGIT(bs->msg[0])) { /* response? */
return n; /* yes, return it */
}
/*
* If we get here, it must be a request. Either
* a message to dispatch, or a catalog request.
* Try to fulfill it.
*/
if (sscanf(bs->msg, "%020s Job=%127s ", MsgType, Job) != 2) {
/*
* If the special flag allow_any_message is given ignore
* the error and just return it as normal data.
*/
if (allow_any_message) {
return n;
} else {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
}
/*
* Skip past "Jmsg Job=nnn"
*/
if (!(msg=find_msg_start(bs->msg))) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
/*
* Here we are expecting a message of the following format:
* Jmsg Job=nnn type=nnn level=nnn Message-string
* Note, level should really be mtime, but that changes
* the protocol.
*/
if (bs->msg[0] == 'J') { /* Job message */
if (sscanf(bs->msg, "Jmsg Job=%127s type=%d level=%lld",
Job, &type, &mtime) != 3) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
Dmsg1(900, "Got msg: %s\n", bs->msg);
skip_spaces(&msg);
skip_nonspaces(&msg); /* skip type=nnn */
skip_spaces(&msg);
skip_nonspaces(&msg); /* skip level=nnn */
if (*msg == ' ') {
msg++; /* skip leading space */
}
Dmsg1(900, "Dispatch msg: %s", msg);
dispatch_message(jcr, type, mtime, msg);
continue;
}
/*
* Here we expact a CatReq message
* CatReq Job=nn Catalog-Request-Message
*/
if (bs->msg[0] == 'C') { /* Catalog request */
Dmsg2(900, "Catalog req jcr 0x%x: %s", jcr, bs->msg);
catalog_request(jcr, bs);
continue;
}
if (bs->msg[0] == 'U') { /* SD sending attributes */
Dmsg2(900, "Catalog upd jcr 0x%x: %s", jcr, bs->msg);
catalog_update(jcr, bs);
continue;
}
if (bs->msg[0] == 'B') { /* SD sending file spool attributes */
Dmsg2(100, "Blast attributes jcr 0x%x: %s", jcr, bs->msg);
char filename[256];
if (sscanf(bs->msg, "BlastAttr Job=%127s File=%255s",
Job, filename) != 2) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
unbash_spaces(filename);
if (despool_attributes_from_file(jcr, filename)) {
bs->fsend("1000 OK BlastAttr\n");
} else {
bs->fsend("1990 ERROR BlastAttr\n");
}
continue;
}
if (bs->msg[0] == 'M') { /* Mount request */
Dmsg1(900, "Mount req: %s", bs->msg);
mount_request(jcr, bs, msg);
continue;
}
if (bs->msg[0] == 'S') { /* Status change */
int JobStatus;
char Job[MAX_NAME_LENGTH];
if (sscanf(bs->msg, Job_status, &Job, &JobStatus) == 2) {
set_jcr_sd_job_status(jcr, JobStatus); /* current status */
} else {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
}
continue;
}
#ifdef needed
/* No JCR for Device Updates! */
if (bs->msg[0] = 'D') { /* Device update */
DEVICE *dev;
POOL_MEM dev_name, changer_name, media_type, volume_name;
int dev_open, dev_append, dev_read, dev_labeled;
int dev_offline, dev_autochanger, dev_autoselect;
int dev_num_writers, dev_max_writers, dev_reserved;
uint64_t dev_read_time, dev_write_time, dev_write_bytes, dev_read_bytes;
uint64_t dev_PoolId;
Dmsg1(100, "<stored: %s", bs->msg);
if (sscanf(bs->msg, Device_update,
&Job, dev_name.c_str(),
&dev_append, &dev_read,
&dev_num_writers, &dev_open,
&dev_labeled, &dev_offline, &dev_reserved,
&dev_max_writers, &dev_autoselect,
&dev_autochanger,
changer_name.c_str(), media_type.c_str(),
volume_name.c_str(),
&dev_read_time, &dev_write_time, &dev_read_bytes,
&dev_write_bytes) != 19) {
Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
} else {
unbash_spaces(dev_name);
dev = (DEVICE *)GetResWithName(R_DEVICE, dev_name.c_str());
if (!dev) {
continue;
}
unbash_spaces(changer_name);
unbash_spaces(media_type);
unbash_spaces(volume_name);
bstrncpy(dev->ChangerName, changer_name.c_str(), sizeof(dev->ChangerName));
bstrncpy(dev->MediaType, media_type.c_str(), sizeof(dev->MediaType));
bstrncpy(dev->VolumeName, volume_name.c_str(), sizeof(dev->VolumeName));
/* Note, these are copied because they are boolean rather than
* integer.
*/
dev->open = dev_open;
dev->append = dev_append;
dev->read = dev_read;
dev->labeled = dev_labeled;
dev->offline = dev_offline;
dev->autoselect = dev_autoselect;
dev->autochanger = dev_autochanger > 0;
dev->num_drives = dev_autochanger; /* does double duty */
dev->PoolId = dev_PoolId;
dev->num_writers = dev_num_writers;
dev->max_writers = dev_max_writers;
dev->reserved = dev_reserved;
dev->found = true;
dev->DevReadTime = dev_read_time; /* TODO : have to update database */
dev->DevWriteTime = dev_write_time;
dev->DevReadBytes = dev_read_bytes;
dev->DevWriteBytes = dev_write_bytes;
}
continue;
}
#endif
return n;
}
return n;
}
/*
*
* Get the next token from the input
*
*/
int lex_get_token(LEX *lf, int expect)
{
int ch;
int token = T_NONE;
bool esc_next = false;
/* Unicode files, especially on Win32, may begin with a "Byte Order Mark"
to indicate which transmission format the file is in. The codepoint for
this mark is U+FEFF and is represented as the octets EF-BB-BF in UTF-8
and as FF-FE in UTF-16le(little endian) and FE-FF in UTF-16(big endian).
We use a distinct state for UTF-8 and UTF-16le, and use bom_bytes_seen
to tell which byte we are expecting. */
int bom_bytes_seen = 0;
Dmsg0(dbglvl, "enter lex_get_token\n");
while (token == T_NONE) {
ch = lex_get_char(lf);
switch (lf->state) {
case lex_none:
Dmsg2(dbglvl, "Lex state lex_none ch=%d,%x\n", ch, ch);
if (B_ISSPACE(ch))
break;
if (B_ISALPHA(ch)) {
if (lf->options & LOPT_NO_IDENT || lf->options & LOPT_STRING) {
lf->state = lex_string;
} else {
lf->state = lex_identifier;
}
begin_str(lf, ch);
break;
}
if (B_ISDIGIT(ch)) {
if (lf->options & LOPT_STRING) {
lf->state = lex_string;
} else {
lf->state = lex_number;
}
begin_str(lf, ch);
break;
}
Dmsg0(dbglvl, "Enter lex_none switch\n");
switch (ch) {
case L_EOF:
token = T_EOF;
Dmsg0(dbglvl, "got L_EOF set token=T_EOF\n");
break;
case '#':
lf->state = lex_comment;
break;
case '{':
token = T_BOB;
begin_str(lf, ch);
break;
case '}':
token = T_EOB;
begin_str(lf, ch);
break;
case '"':
lf->state = lex_quoted_string;
begin_str(lf, 0);
break;
case '=':
token = T_EQUALS;
begin_str(lf, ch);
break;
case ',':
token = T_COMMA;
begin_str(lf, ch);
break;
case ';':
if (expect != T_SKIP_EOL) {
token = T_EOL; /* treat ; like EOL */
}
break;
case L_EOL:
Dmsg0(dbglvl, "got L_EOL set token=T_EOL\n");
if (expect != T_SKIP_EOL) {
token = T_EOL;
}
break;
case '@':
/* In NO_EXTERN mode, @ is part of a string */
if (lf->options & LOPT_NO_EXTERN) {
lf->state = lex_string;
begin_str(lf, ch);
} else {
lf->state = lex_include;
begin_str(lf, 0);
}
break;
case 0xEF: /* probably a UTF-8 BOM */
case 0xFF: /* probably a UTF-16le BOM */
case 0xFE: /* probably a UTF-16be BOM (error)*/
if (lf->line_no != 1 || lf->col_no != 1)
{
lf->state = lex_string;
begin_str(lf, ch);
} else {
bom_bytes_seen = 1;
if (ch == 0xEF) {
lf->state = lex_utf8_bom;
} else if (ch == 0xFF) {
lf->state = lex_utf16_le_bom;
} else {
scan_err0(lf, _("This config file appears to be in an "
"unsupported Unicode format (UTF-16be). Please resave as UTF-8\n"));
return T_ERROR;
}
}
break;
default:
lf->state = lex_string;
begin_str(lf, ch);
break;
}
break;
case lex_comment:
Dmsg1(dbglvl, "Lex state lex_comment ch=%x\n", ch);
if (ch == L_EOL) {
lf->state = lex_none;
if (expect != T_SKIP_EOL) {
token = T_EOL;
}
} else if (ch == L_EOF) {
token = T_ERROR;
}
break;
case lex_number:
Dmsg2(dbglvl, "Lex state lex_number ch=%x %c\n", ch, ch);
if (ch == L_EOF) {
token = T_ERROR;
break;
}
/* Might want to allow trailing specifications here */
if (B_ISDIGIT(ch)) {
add_str(lf, ch);
break;
}
/* A valid number can be terminated by the following */
if (B_ISSPACE(ch) || ch == L_EOL || ch == ',' || ch == ';') {
token = T_NUMBER;
lf->state = lex_none;
} else {
lf->state = lex_string;
}
lex_unget_char(lf);
break;
case lex_ip_addr:
if (ch == L_EOF) {
token = T_ERROR;
break;
}
Dmsg1(dbglvl, "Lex state lex_ip_addr ch=%x\n", ch);
break;
case lex_string:
Dmsg1(dbglvl, "Lex state lex_string ch=%x\n", ch);
if (ch == L_EOF) {
token = T_ERROR;
break;
}
if (ch == '\n' || ch == L_EOL || ch == '=' || ch == '}' || ch == '{' ||
ch == '\r' || ch == ';' || ch == ',' || ch == '#' || (B_ISSPACE(ch)) ) {
lex_unget_char(lf);
token = T_UNQUOTED_STRING;
lf->state = lex_none;
break;
}
add_str(lf, ch);
break;
case lex_identifier:
Dmsg2(dbglvl, "Lex state lex_identifier ch=%x %c\n", ch, ch);
if (B_ISALPHA(ch)) {
add_str(lf, ch);
break;
} else if (B_ISSPACE(ch)) {
break;
} else if (ch == '\n' || ch == L_EOL || ch == '=' || ch == '}' || ch == '{' ||
ch == '\r' || ch == ';' || ch == ',' || ch == '"' || ch == '#') {
lex_unget_char(lf);
token = T_IDENTIFIER;
lf->state = lex_none;
break;
} else if (ch == L_EOF) {
token = T_ERROR;
lf->state = lex_none;
begin_str(lf, ch);
break;
}
/* Some non-alpha character => string */
lf->state = lex_string;
add_str(lf, ch);
break;
case lex_quoted_string:
Dmsg2(dbglvl, "Lex state lex_quoted_string ch=%x %c\n", ch, ch);
if (ch == L_EOF) {
token = T_ERROR;
break;
}
if (ch == L_EOL) {
esc_next = false;
break;
}
if (esc_next) {
add_str(lf, ch);
esc_next = false;
break;
}
if (ch == '\\') {
esc_next = true;
break;
}
if (ch == '"') {
token = T_QUOTED_STRING;
/*
* Since we may be scanning a quoted list of names,
* we get the next character (a comma indicates another
* one), then we put it back for rescanning.
*/
lex_get_char(lf);
lex_unget_char(lf);
lf->state = lex_none;
break;
}
add_str(lf, ch);
break;
case lex_include_quoted_string:
if (ch == L_EOF) {
token = T_ERROR;
break;
}
if (esc_next) {
add_str(lf, ch);
esc_next = false;
break;
}
if (ch == '\\') {
esc_next = true;
break;
}
if (ch == '"') {
/* Keep the original LEX so we can print an error if the included file can't be opened. */
LEX* lfori = lf;
/* Skip the double quote when restarting parsing */
lex_get_char(lf);
lf->state = lex_none;
lf = lex_open_file(lf, lf->str, lf->scan_error, lf->scan_warning);
if (lf == NULL) {
berrno be;
scan_err2(lfori, _("Cannot open included config file %s: %s\n"),
lfori->str, be.bstrerror());
return T_ERROR;
}
break;
}
add_str(lf, ch);
break;
case lex_include: /* scanning a filename */
if (ch == L_EOF) {
token = T_ERROR;
break;
}
if (ch == '"') {
lf->state = lex_include_quoted_string;
break;
}
if (B_ISSPACE(ch) || ch == '\n' || ch == L_EOL || ch == '}' || ch == '{' ||
ch == ';' || ch == ',' || ch == '"' || ch == '#') {
/* Keep the original LEX so we can print an error if the included file can't be opened. */
LEX* lfori = lf;
lf->state = lex_none;
lf = lex_open_file(lf, lf->str, lf->scan_error, lf->scan_warning);
if (lf == NULL) {
berrno be;
scan_err2(lfori, _("Cannot open included config file %s: %s\n"),
lfori->str, be.bstrerror());
return T_ERROR;
}
break;
}
add_str(lf, ch);
break;
case lex_utf8_bom:
/* we only end up in this state if we have read an 0xEF
as the first byte of the file, indicating we are probably
reading a UTF-8 file */
if (ch == 0xBB && bom_bytes_seen == 1) {
bom_bytes_seen++;
} else if (ch == 0xBF && bom_bytes_seen == 2) {
token = T_UTF8_BOM;
lf->state = lex_none;
} else {
token = T_ERROR;
}
break;
case lex_utf16_le_bom:
/* we only end up in this state if we have read an 0xFF
as the first byte of the file -- indicating that we are
probably dealing with an Intel based (little endian) UTF-16 file*/
if (ch == 0xFE) {
token = T_UTF16_BOM;
lf->state = lex_none;
} else {
token = T_ERROR;
}
break;
}
Dmsg4(dbglvl, "ch=%d state=%s token=%s %c\n", ch, lex_state_to_str(lf->state),
lex_tok_to_str(token), ch);
}
Dmsg2(dbglvl, "lex returning: line %d token: %s\n", lf->line_no, lex_tok_to_str(token));
lf->token = token;
/*
* Here is where we check to see if the user has set certain
* expectations (e.g. 32 bit integer). If so, we do type checking
* and possible additional scanning (e.g. for range).
*/
switch (expect) {
case T_PINT16:
lf->u.pint16_val = (scan_pint(lf, lf->str) & 0xffff);
lf->u2.pint16_val = lf->u.pint16_val;
token = T_PINT16;
break;
case T_PINT32:
lf->u.pint32_val = scan_pint(lf, lf->str);
lf->u2.pint32_val = lf->u.pint32_val;
token = T_PINT32;
break;
case T_PINT32_RANGE:
if (token == T_NUMBER) {
lf->u.pint32_val = scan_pint(lf, lf->str);
lf->u2.pint32_val = lf->u.pint32_val;
token = T_PINT32;
} else {
char *p = strchr(lf->str, '-');
if (!p) {
scan_err2(lf, _("expected an integer or a range, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
}
*p++ = 0; /* terminate first half of range */
lf->u.pint32_val = scan_pint(lf, lf->str);
lf->u2.pint32_val = scan_pint(lf, p);
token = T_PINT32_RANGE;
}
break;
case T_INT16:
if (token != T_NUMBER || !is_a_number(lf->str)) {
scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
}
errno = 0;
lf->u.int16_val = (int16_t)str_to_int64(lf->str);
if (errno != 0) {
scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
token = T_INT16;
}
break;
case T_INT32:
if (token != T_NUMBER || !is_a_number(lf->str)) {
scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
}
errno = 0;
lf->u.int32_val = (int32_t)str_to_int64(lf->str);
if (errno != 0) {
scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
token = T_INT32;
}
break;
case T_INT64:
Dmsg2(dbglvl, "int64=:%s: %f\n", lf->str, strtod(lf->str, NULL));
if (token != T_NUMBER || !is_a_number(lf->str)) {
scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
}
errno = 0;
lf->u.int64_val = str_to_int64(lf->str);
if (errno != 0) {
scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
token = T_INT64;
}
break;
case T_PINT64_RANGE:
if (token == T_NUMBER) {
lf->u.pint64_val = scan_pint64(lf, lf->str);
lf->u2.pint64_val = lf->u.pint64_val;
token = T_PINT64;
} else {
char *p = strchr(lf->str, '-');
if (!p) {
scan_err2(lf, _("expected an integer or a range, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
}
*p++ = 0; /* terminate first half of range */
lf->u.pint64_val = scan_pint64(lf, lf->str);
lf->u2.pint64_val = scan_pint64(lf, p);
token = T_PINT64_RANGE;
}
break;
case T_NAME:
if (token != T_IDENTIFIER && token != T_UNQUOTED_STRING && token != T_QUOTED_STRING) {
scan_err2(lf, _("expected a name, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else if (lf->str_len > MAX_RES_NAME_LENGTH) {
scan_err3(lf, _("name %s length %d too long, max is %d\n"), lf->str,
lf->str_len, MAX_RES_NAME_LENGTH);
token = T_ERROR;
}
break;
case T_STRING:
if (token != T_IDENTIFIER && token != T_UNQUOTED_STRING && token != T_QUOTED_STRING) {
scan_err2(lf, _("expected a string, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
token = T_STRING;
}
break;
default:
break; /* no expectation given */
}
lf->token = token; /* set possible new token */
return token;
}
/*
* 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;
}
