bool dir_update_changer(JCR *jcr, AUTOCHANGER *changer)
{
BSOCK *dir = jcr->dir_bsock;
POOL_MEM dev_name, MediaType;
DEVRES *device;
bool ok;
pm_strcpy(dev_name, changer->hdr.name);
bash_spaces(dev_name);
device = (DEVRES *)changer->device->first();
pm_strcpy(MediaType, device->media_type);
bash_spaces(MediaType);
/* This is mostly to indicate that we are here */
ok = dir->fsend(Device_update,
jcr->Job,
dev_name.c_str(), /* Changer name */
0, 0, 0, /* append, read, num_writers */
0, 0, 0, /* is_open, is_labeled, offline */
0, 0, /* reserved, max_writers */
0, /* Autoselect */
changer->device->size(), /* Number of devices */
"0", /* PoolId */
"*", /* ChangerName */
MediaType.c_str(), /* MediaType */
"*"); /* VolName */
Dmsg1(dbglvl, ">dird: %s\n", dir->msg);
return ok;
}
/*
* Called here to send the appropriate commands to the SD
* to do truncate on purge.
*/
static void do_truncate_on_purge(UAContext *ua, MEDIA_DBR *mr,
char *pool, char *storage,
int drive, BSOCK *sd)
{
bool ok=false;
uint64_t VolBytes = 0;
/* TODO: Return if not mr->Recyle ? */
if (!mr->Recycle) {
return;
}
/* Do it only if action on purge = truncate is set */
if (!(mr->ActionOnPurge & ON_PURGE_TRUNCATE)) {
return;
}
/*
* Send the command to truncate the volume after purge. If this feature
* is disabled for the specific device, this will be a no-op.
*/
/* Protect us from spaces */
bash_spaces(mr->VolumeName);
bash_spaces(mr->MediaType);
bash_spaces(pool);
bash_spaces(storage);
/* Do it by relabeling the Volume, which truncates it */
sd->fsend("relabel %s OldName=%s NewName=%s PoolName=%s "
"MediaType=%s Slot=%d drive=%d\n",
storage,
mr->VolumeName, mr->VolumeName,
pool, mr->MediaType, mr->Slot, drive);
unbash_spaces(mr->VolumeName);
unbash_spaces(mr->MediaType);
unbash_spaces(pool);
unbash_spaces(storage);
/* Send relabel command, and check for valid response */
while (sd->recv() >= 0) {
ua->send_msg("%s", sd->msg);
if (sscanf(sd->msg, "3000 OK label. VolBytes=%llu ", &VolBytes) == 1) {
ok = true;
}
}
if (ok) {
mr->VolBytes = VolBytes;
mr->VolFiles = 0;
set_storageid_in_mr(NULL, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg(_("Can't update volume size in the catalog\n"));
}
ua->send_msg(_("The volume \"%s\" has been truncated\n"), mr->VolumeName);
} else {
ua->warning_msg(_("Unable to truncate volume \"%s\"\n"), mr->VolumeName);
}
}
/*
* We get the number of drives in the changer from the SD
*/
int get_num_drives_from_SD(UAContext *ua)
{
STORERES *store = ua->jcr->res.wstore;
char dev_name[MAX_NAME_LENGTH];
BSOCK *sd;
int drives = 0;
if (!(sd = open_sd_bsock(ua))) {
return 0;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/*
* Ask for autochanger number of drives
*/
sd->fsend(changerdrivescmd, dev_name);
while (sd->recv() >= 0) {
if (sscanf(sd->msg, changerdrivesresponse, &drives) == 1) {
break;
} else {
ua->send_msg("%s", sd->msg);
}
}
close_sd_bsock(ua);
// bsendmsg(ua, _("Device \"%s\" has %d drives.\n"), store->dev_name(), drives);
return drives;
}
/*
* We get the number of slots in the changer from the SD
*/
static int get_num_slots_from_SD(UAContext *ua)
{
STORE *store = ua->jcr->wstore;
char dev_name[MAX_NAME_LENGTH];
BSOCK *sd;
int slots = 0;
if (!(sd=open_sd_bsock(ua))) {
return 0;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/* Ask for autochanger number of slots */
sd->fsend(NT_("autochanger slots %s\n"), dev_name);
while (sd->recv() >= 0) {
if (sscanf(sd->msg, "slots=%d\n", &slots) == 1) {
break;
} else {
ua->send_msg("%s", sd->msg);
}
}
close_sd_bsock(ua);
ua->send_msg(_("Device \"%s\" has %d slots.\n"), store->dev_name(), slots);
return slots;
}
static char *get_volume_name_from_SD(UAContext *ua, int Slot, int drive)
{
STORE *store = ua->jcr->wstore;
BSOCK *sd;
char dev_name[MAX_NAME_LENGTH];
char *VolName = NULL;
int rtn_slot;
if (!(sd=open_sd_bsock(ua))) {
ua->error_msg(_("Could not open SD socket.\n"));
return NULL;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/* Ask for autochanger list of volumes */
sd->fsend(NT_("readlabel %s Slot=%d drive=%d\n"), dev_name, Slot, drive);
Dmsg1(100, "Sent: %s", sd->msg);
/* Get Volume name in this Slot */
while (sd->recv() >= 0) {
ua->send_msg("%s", sd->msg);
Dmsg1(100, "Got: %s", sd->msg);
if (strncmp(sd->msg, NT_("3001 Volume="), 12) == 0) {
VolName = (char *)malloc(sd->msglen);
if (sscanf(sd->msg, NT_("3001 Volume=%s Slot=%d"), VolName, &rtn_slot) == 2) {
break;
}
free(VolName);
VolName = NULL;
}
}
close_sd_bsock(ua);
Dmsg1(100, "get_vol_name=%s\n", NPRT(VolName));
return VolName;
}
static int send_volume_info_to_storage_daemon(JCR *jcr, BSOCK *sd, MEDIA_DBR *mr)
{
int status;
char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50];
jcr->MediaId = mr->MediaId;
pm_strcpy(jcr->VolumeName, mr->VolumeName);
bash_spaces(mr->VolumeName);
status = sd->fsend(OK_media, mr->VolumeName, mr->VolJobs,
mr->VolFiles, mr->VolBlocks, edit_uint64(mr->VolBytes, ed1),
mr->VolMounts, mr->VolErrors, mr->VolWrites,
edit_uint64(mr->MaxVolBytes, ed2),
edit_uint64(mr->VolCapacityBytes, ed3),
mr->VolStatus, mr->Slot, mr->MaxVolJobs, mr->MaxVolFiles,
mr->InChanger,
edit_int64(mr->VolReadTime, ed4),
edit_int64(mr->VolWriteTime, ed5),
mr->EndFile, mr->EndBlock,
mr->LabelType,
edit_uint64(mr->MediaId, ed6),
mr->EncrKey, mr->MinBlocksize, mr->MaxBlocksize);
unbash_spaces(mr->VolumeName);
Dmsg2(100, "Vol Info for %s: %s", jcr->Job, sd->msg);
return status;
}
/*
* Authenticate Director
*/
bool BSOCK::authenticate_with_director(JCR *jcr,
const char *name, s_password &password, tls_t &tls,
char *response, int response_len)
{
char bashed_name[MAX_NAME_LENGTH];
BSOCK *dir = this; /* for readability */
response[0] = 0;
/*
* Send my name to the Director then do authentication
*/
bstrncpy(bashed_name, name, sizeof(bashed_name));
bash_spaces(bashed_name);
/*
* Timeout Hello after 5 mins
*/
dir->start_timer(60 * 5);
dir->fsend(hello, bashed_name);
if (!authenticate_outbound_connection(jcr, "Director", name, password, tls)) {
goto bail_out;
}
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
dir->stop_timer();
bsnprintf(response, response_len, _("Bad response to Hello command: ERR=%s\n"
"The Director at \"%s:%d\" is probably not running.\n"),
dir->bstrerror(), dir->host(), dir->port());
return false;
}
dir->stop_timer();
Dmsg1(10, "<dird: %s", dir->msg);
if (!bstrncmp(dir->msg, OKhello, sizeof(OKhello) - 1)) {
bsnprintf(response, response_len, _("Director at \"%s:%d\" rejected Hello command\n"),
dir->host(), dir->port());
return false;
} else {
bsnprintf(response, response_len, "%s", dir->msg);
}
return true;
bail_out:
dir->stop_timer();
bsnprintf(response, response_len, _("Authorization problem with Director at \"%s:%d\"\n"
"Most likely the passwords do not agree.\n"
"If you are using TLS, there may have been a certificate "
"validation error during the TLS handshake.\n"
"Please see %s for help.\n"),
dir->host(), dir->port(), MANUAL_AUTH_URL);
return false;
}
/*
* Send update information about a device to Director
*/
bool SD_DCR::dir_update_device(JCR *jcr, DEVICE *dev)
{
BSOCK *dir = jcr->dir_bsock;
POOL_MEM dev_name, VolumeName, MediaType, ChangerName;
DEVRES *device = dev->device;
bool ok;
pm_strcpy(dev_name, device->hdr.name);
bash_spaces(dev_name);
if (dev->is_labeled()) {
pm_strcpy(VolumeName, dev->VolHdr.VolumeName);
} else {
pm_strcpy(VolumeName, "*");
}
bash_spaces(VolumeName);
pm_strcpy(MediaType, device->media_type);
bash_spaces(MediaType);
if (device->changer_res) {
pm_strcpy(ChangerName, device->changer_res->hdr.name);
bash_spaces(ChangerName);
} else {
pm_strcpy(ChangerName, "*");
}
ok = dir->fsend(Device_update,
jcr->Job,
dev_name.c_str(),
dev->can_append() != 0,
dev->can_read() != 0, dev->num_writers,
dev->is_open() != 0, dev->is_labeled() != 0,
dev->is_offline() != 0, dev->reserved_device,
dev->is_tape() ? 100000 : 1,
dev->autoselect, 0,
ChangerName.c_str(), MediaType.c_str(), VolumeName.c_str());
Dmsg1(dbglvl, ">dird: %s", dir->msg);
return ok;
}
/**
* Get Volume info for a specific volume from the Director's Database
*
* Returns: true on success (Director guarantees that Pool and MediaType
* are correct and VolStatus==Append or
* VolStatus==Recycle)
* false on failure
*
* Volume information returned in dcr->VolCatInfo
*/
bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw writing)
{
JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
P(vol_info_mutex);
dcr->setVolCatName(dcr->VolumeName);
bash_spaces(dcr->getVolCatName());
dir->fsend(Get_Vol_Info, jcr->Job, dcr->getVolCatName(),
writing==GET_VOL_INFO_FOR_WRITE?1:0);
Dmsg1(dbglvl, ">dird %s", dir->msg);
unbash_spaces(dcr->getVolCatName());
bool ok = do_get_volume_info(dcr);
V(vol_info_mutex);
return ok;
}
/**
* Get Volume info for a specific volume from the Director's Database
*
* Returns: true on success (Director guarantees that Pool and MediaType
* are correct and VolStatus==Append or
* VolStatus==Recycle)
* false on failure
*
* Volume information returned in dcr->VolCatInfo
*/
bool SD_DCR::dir_get_volume_info(enum get_vol_info_rw writing)
{
bool ok;
BSOCK *dir = jcr->dir_bsock;
P(vol_info_mutex);
setVolCatName(VolumeName);
bash_spaces(getVolCatName());
dir->fsend(Get_Vol_Info, jcr->Job, getVolCatName(),
(writing == GET_VOL_INFO_FOR_WRITE) ? 1 : 0);
Dmsg1(dbglvl, ">dird %s", dir->msg);
unbash_spaces(getVolCatName());
ok = do_get_volume_info(this);
V(vol_info_mutex);
return ok;
}
/*
* Authenticate Director
*/
static int authenticate_director(JCR *jcr)
{
const MONITORRES *monitor = MonitorItemThread::instance()->getMonitor();
BSOCK *dir = jcr->dir_bsock;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true;
char bashed_name[MAX_NAME_LENGTH];
char *password;
bstrncpy(bashed_name, monitor->hdr.name, sizeof(bashed_name));
bash_spaces(bashed_name);
password = monitor->password;
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(dir, 60 * 5);
dir->fsend(DIRhello, bashed_name);
if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(dir, password, tls_local_need, compatible)) {
stop_bsock_timer(tid);
Jmsg1(jcr, M_FATAL, 0, _("Director authorization problem.\n"
"Most likely the passwords do not agree.\n"
"Please see %s for help.\n"), MANUAL_AUTH_URL);
return 0;
}
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
stop_bsock_timer(tid);
Jmsg1(jcr, M_FATAL, 0, _("Bad response to Hello command: ERR=%s\n"),
dir->bstrerror());
return 0;
}
Dmsg1(10, "<dird: %s", dir->msg);
stop_bsock_timer(tid);
if (strncmp(dir->msg, DIROKhello, sizeof(DIROKhello)-1) != 0) {
Jmsg0(jcr, M_FATAL, 0, _("Director rejected Hello command\n"));
return 0;
} else {
Jmsg0(jcr, M_INFO, 0, dir->msg);
}
return 1;
}
/*
* Authenticate File daemon connection
*/
static int authenticate_file_daemon(JCR *jcr, CLIENTRES* client)
{
const MONITORRES *monitor = MonitorItemThread::instance()->getMonitor();
BSOCK *fd = jcr->file_bsock;
char dirname[MAX_NAME_LENGTH];
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool compatible = true;
/*
* Send my name to the File daemon then do authentication
*/
bstrncpy(dirname, monitor->hdr.name, sizeof(dirname));
bash_spaces(dirname);
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(fd, 60 * 5);
if (!fd->fsend(SDFDhello, dirname)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Error sending Hello to File daemon. ERR=%s\n"), bnet_strerror(fd));
return 0;
}
if (!cram_md5_respond(fd, client->password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(fd, client->password, tls_local_need, compatible)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Director and File daemon passwords or names not the same.\n"
"Please see " MANUAL_AUTH_URL " for help.\n"));
return 0;
}
Dmsg1(116, ">filed: %s", fd->msg);
if (fd->recv() <= 0) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Bad response from File daemon to Hello command: ERR=%s\n"),
fd->bstrerror());
return 0;
}
Dmsg1(110, "<stored: %s", fd->msg);
stop_bsock_timer(tid);
if (strncmp(fd->msg, FDOKhello, sizeof(FDOKhello)-1) != 0) {
Jmsg(jcr, M_FATAL, 0, _("File daemon rejected Hello command\n"));
return 0;
}
return 1;
}
/*
* Authenticate Storage daemon connection
*/
int authenticate_storage_daemon(JCR *jcr, MONITOR *monitor, STORE* store)
{
BSOCK *sd = jcr->store_bsock;
char dirname[MAX_NAME_LENGTH];
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
int compatible = true;
/*
* Send my name to the Storage daemon then do authentication
*/
bstrncpy(dirname, monitor->hdr.name, sizeof(dirname));
bash_spaces(dirname);
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(sd, 60 * 5);
if (!sd->fsend(SDFDhello, dirname)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Error sending Hello to Storage daemon. ERR=%s\n"), sd->bstrerror());
return 0;
}
if (!cram_md5_respond(sd, store->password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(sd, store->password, tls_local_need, compatible)) {
stop_bsock_timer(tid);
Jmsg0(jcr, M_FATAL, 0, _("Director and Storage daemon passwords or names not the same.\n"
"Please see " MANUAL_AUTH_URL " for help.\n"));
return 0;
}
Dmsg1(116, ">stored: %s", sd->msg);
if (sd->recv() <= 0) {
stop_bsock_timer(tid);
Jmsg1(jcr, M_FATAL, 0, _("bdird<stored: bad response to Hello command: ERR=%s\n"),
sd->bstrerror());
return 0;
}
Dmsg1(110, "<stored: %s", sd->msg);
stop_bsock_timer(tid);
if (strncmp(sd->msg, SDOKhello, sizeof(SDOKhello)) != 0) {
Jmsg0(jcr, M_FATAL, 0, _("Storage daemon rejected Hello command\n"));
return 0;
}
return 1;
}
/*
* Ask the autochanger to move a volume from one slot to an other.
* You have to update the database slots yourself afterwards.
*/
bool transfer_volume(UAContext *ua, STORERES *store, int src_slot, int dst_slot)
{
BSOCK *sd = NULL;
bool retval = true;
char dev_name[MAX_NAME_LENGTH];
if (!(sd = open_sd_bsock(ua))) {
return false;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/*
* Ask for autochanger transfer of volumes
*/
sd->fsend(changertransfercmd, dev_name, src_slot, dst_slot);
while (bnet_recv(sd) >= 0) {
strip_trailing_junk(sd->msg);
/*
* Check for returned SD messages
*/
if (sd->msg[0] == '3' && B_ISDIGIT(sd->msg[1]) &&
B_ISDIGIT(sd->msg[2]) && B_ISDIGIT(sd->msg[3]) &&
sd->msg[4] == ' ') {
/*
* See if this is a failure msg.
*/
if (sd->msg[0] == '3' && sd->msg[0] == '9')
retval = false;
ua->send_msg("%s\n", sd->msg); /* pass them on to user */
continue;
}
ua->send_msg("%s\n", sd->msg); /* pass them on to user */
}
close_sd_bsock(ua);
return retval;
}
/*
* We get the volume name from the SD
*/
char *get_volume_name_from_SD(UAContext *ua, int Slot, int drive)
{
BSOCK *sd;
STORERES *store = ua->jcr->res.wstore;
char dev_name[MAX_NAME_LENGTH];
char *VolName = NULL;
int rtn_slot;
if (!(sd = open_sd_bsock(ua))) {
ua->error_msg(_("Could not open SD socket.\n"));
return NULL;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
/*
* Ask storage daemon to read the label of the volume in a
* specific slot of the autochanger using the drive number given.
* This could change the loaded volume in the drive.
*/
sd->fsend(readlabelcmd, dev_name, Slot, drive);
Dmsg1(100, "Sent: %s", sd->msg);
/*
* Get Volume name in this Slot
*/
while (sd->recv() >= 0) {
ua->send_msg("%s", sd->msg);
Dmsg1(100, "Got: %s", sd->msg);
if (strncmp(sd->msg, NT_("3001 Volume="), 12) == 0) {
VolName = (char *)malloc(sd->msglen);
if (sscanf(sd->msg, readlabelresponse, VolName, &rtn_slot) == 2) {
break;
}
free(VolName);
VolName = NULL;
}
}
close_sd_bsock(ua);
Dmsg1(100, "get_vol_name=%s\n", NPRT(VolName));
return VolName;
}
/*
* Tell Director where to find the attributes spool file
* Note, if we are not on the same machine, the Director will
* return an error, and the higher level routine will transmit
* the data record by record -- using bsock->despool().
*/
static bool blast_attr_spool_file(JCR *jcr, boffset_t size)
{
/* send full spool file name */
POOLMEM *name = get_pool_memory(PM_MESSAGE);
make_unique_spool_filename(jcr, &name, jcr->dir_bsock->m_fd);
bash_spaces(name);
jcr->dir_bsock->fsend("BlastAttr Job=%s File=%s\n", jcr->Job, name);
free_pool_memory(name);
if (jcr->dir_bsock->recv() <= 0) {
Jmsg(jcr, M_FATAL, 0, _("Network error on BlastAttributes.\n"));
jcr->forceJobStatus(JS_FatalError); /* override any Incomplete */
return false;
}
if (!bstrcmp(jcr->dir_bsock->msg, "1000 OK BlastAttr\n")) {
return false;
}
return true;
}
static void build_restore_command(JCR *jcr, POOL_MEM &ret)
{
char replace, *where, *cmd;
char empty = '\0';
/*
* Build the restore command
*/
if (jcr->replace != 0) {
replace = jcr->replace;
} else if (jcr->res.job->replace != 0) {
replace = jcr->res.job->replace;
} else {
replace = REPLACE_ALWAYS; /* always replace */
}
if (jcr->RegexWhere) {
where = jcr->RegexWhere; /* override */
cmd = restorecmdR;
} else if (jcr->res.job->RegexWhere) {
where = jcr->res.job->RegexWhere; /* no override take from job */
cmd = restorecmdR;
} else if (jcr->where) {
where = jcr->where; /* override */
cmd = restorecmd;
} else if (jcr->res.job->RestoreWhere) {
where = jcr->res.job->RestoreWhere; /* no override take from job */
cmd = restorecmd;
} else { /* nothing was specified */
where = ∅ /* use default */
cmd = restorecmd;
}
jcr->prefix_links = jcr->res.job->PrefixLinks;
bash_spaces(where);
Mmsg(ret, cmd, replace, jcr->prefix_links, where);
unbash_spaces(where);
}
/*
* Ask the autochanger to perform a mount, umount or release operation.
*/
bool do_autochanger_volume_operation(UAContext *ua, STORERES *store,
const char *operation, int drive, int slot)
{
BSOCK *sd = NULL;
bool retval = true;
char dev_name[MAX_NAME_LENGTH];
if (!(sd = open_sd_bsock(ua))) {
return false;
}
bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
if (slot > 0) {
sd->fsend(changervolopslotcmd, operation, dev_name, drive, slot);
} else {
sd->fsend(changervolopcmd, operation, dev_name, drive);
}
/*
* We use bget_dirmsg here and not bnet_recv because as part of
* the mount request the stored can request catalog information for
* any plugin who listens to the bsdEventLabelVerified event.
* As we don't want to loose any non protocol data e.g. errors
* without a 3xxx prefix we set the allow_any_message of
* bget_dirmsg to true and as such is behaves like a normal
* bnet_recv for any non protocol messages.
*/
while (bget_dirmsg(sd, true) >= 0) {
ua->send_msg("%s", sd->msg);
}
close_sd_bsock(ua);
return retval;
}
/**
* Get info on the next appendable volume in the Director's database
*
* Returns: true on success dcr->VolumeName is volume
* reserve_volume() called on Volume name
* false on failure dcr->VolumeName[0] == 0
* also sets dcr->found_in_use if at least one
* in use volume was found.
*
* Volume information returned in dcr
*
*/
bool dir_find_next_appendable_volume(DCR *dcr)
{
JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
bool rtn;
char lastVolume[MAX_NAME_LENGTH];
Dmsg2(dbglvl, "dir_find_next_appendable_volume: reserved=%d Vol=%s\n",
dcr->is_reserved(), dcr->VolumeName);
/*
* Try the twenty oldest or most available volumes. Note,
* the most available could already be mounted on another
* drive, so we continue looking for a not in use Volume.
*/
lock_volumes();
P(vol_info_mutex);
dcr->clear_found_in_use();
lastVolume[0] = 0;
for (int vol_index=1; vol_index < 20; vol_index++) {
bash_spaces(dcr->media_type);
bash_spaces(dcr->pool_name);
dir->fsend(Find_media, jcr->Job, vol_index, dcr->pool_name, dcr->media_type);
unbash_spaces(dcr->media_type);
unbash_spaces(dcr->pool_name);
Dmsg1(dbglvl, ">dird %s", dir->msg);
if (do_get_volume_info(dcr)) {
/* Give up if we get the same volume name twice */
if (lastVolume[0] && bstrcmp(lastVolume, dcr->VolumeName)) {
Dmsg1(dbglvl, "Got same vol = %s\n", lastVolume);
break;
}
bstrncpy(lastVolume, dcr->VolumeName, sizeof(lastVolume));
if (dcr->can_i_write_volume()) {
Dmsg1(dbglvl, "Call reserve_volume for write. Vol=%s\n", dcr->VolumeName);
if (reserve_volume(dcr, dcr->VolumeName) == NULL) {
Dmsg2(dbglvl, "Could not reserve volume %s on %s\n", dcr->VolumeName,
dcr->dev->print_name());
continue;
}
Dmsg1(dbglvl, "dir_find_next_appendable_volume return true. vol=%s\n",
dcr->VolumeName);
rtn = true;
goto get_out;
} else {
Dmsg1(dbglvl, "Volume %s is in use.\n", dcr->VolumeName);
/* If volume is not usable, it is in use by someone else */
dcr->set_found_in_use();
continue;
}
}
Dmsg2(dbglvl, "No vol. index %d return false. dev=%s\n", vol_index,
dcr->dev->print_name());
break;
}
rtn = false;
dcr->VolumeName[0] = 0;
get_out:
V(vol_info_mutex);
unlock_volumes();
return rtn;
}
/*
* NOTE! This routine opens the SD socket but leaves it open
*/
static bool send_label_request(UAContext *ua, MEDIA_DBR *mr, MEDIA_DBR *omr,
POOL_DBR *pr, int relabel, bool media_record_exists,
int drive)
{
BSOCK *sd;
char dev_name[MAX_NAME_LENGTH];
bool ok = false;
bool is_dvd = false;
uint64_t VolBytes = 0;
if (!(sd=open_sd_bsock(ua))) {
return false;
}
bstrncpy(dev_name, ua->jcr->wstore->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
bash_spaces(mr->VolumeName);
bash_spaces(mr->MediaType);
bash_spaces(pr->Name);
if (relabel) {
bash_spaces(omr->VolumeName);
sd->fsend("relabel %s OldName=%s NewName=%s PoolName=%s "
"MediaType=%s Slot=%d drive=%d",
dev_name, omr->VolumeName, mr->VolumeName, pr->Name,
mr->MediaType, mr->Slot, drive);
ua->send_msg(_("Sending relabel command from \"%s\" to \"%s\" ...\n"),
omr->VolumeName, mr->VolumeName);
} else {
sd->fsend("label %s VolumeName=%s PoolName=%s MediaType=%s "
"Slot=%d drive=%d",
dev_name, mr->VolumeName, pr->Name, mr->MediaType,
mr->Slot, drive);
ua->send_msg(_("Sending label command for Volume \"%s\" Slot %d ...\n"),
mr->VolumeName, mr->Slot);
Dmsg6(100, "label %s VolumeName=%s PoolName=%s MediaType=%s Slot=%d drive=%d\n",
dev_name, mr->VolumeName, pr->Name, mr->MediaType, mr->Slot, drive);
}
while (sd->recv() >= 0) {
int dvd;
ua->send_msg("%s", sd->msg);
if (sscanf(sd->msg, "3000 OK label. VolBytes=%llu DVD=%d ", &VolBytes,
&dvd) == 2) {
is_dvd = dvd;
ok = true;
}
}
unbash_spaces(mr->VolumeName);
unbash_spaces(mr->MediaType);
unbash_spaces(pr->Name);
mr->LabelDate = time(NULL);
mr->set_label_date = true;
if (is_dvd) {
/* We know that a freshly labelled DVD has 1 VolParts */
/* This does not apply to auto-labelled DVDs. */
mr->VolParts = 1;
}
if (ok) {
if (media_record_exists) { /* we update it */
mr->VolBytes = VolBytes;
mr->InChanger = mr->Slot > 0; /* if slot give assume in changer */
mr->StorageId = ua->jcr->wstore->StorageId;
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg("%s", db_strerror(ua->db));
ok = false;
}
} else { /* create the media record */
set_pool_dbr_defaults_in_media_dbr(mr, pr);
mr->VolBytes = VolBytes;
mr->InChanger = mr->Slot > 0; /* if slot give assume in changer */
mr->StorageId = ua->jcr->wstore->StorageId;
mr->Enabled = 1;
if (db_create_media_record(ua->jcr, ua->db, mr)) {
ua->info_msg(_("Catalog record for Volume \"%s\", Slot %d successfully created.\n"),
mr->VolumeName, mr->Slot);
/* Update number of volumes in pool */
pr->NumVols++;
if (!db_update_pool_record(ua->jcr, ua->db, pr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
} else {
ua->error_msg("%s", db_strerror(ua->db));
ok = false;
}
}
} else {
ua->error_msg(_("Label command failed for Volume %s.\n"), mr->VolumeName);
}
return ok;
}
/*
* 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;
}
/*
* Authenticate Director
*/
bool DirComm::authenticate_director(JCR *jcr, DIRRES *director, CONRES *cons,
char *errmsg, int errmsg_len)
{
BSOCK *dir = jcr->dir_bsock;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool tls_authenticate;
int compatible = true;
char bashed_name[MAX_NAME_LENGTH];
char *password;
TLS_CONTEXT *tls_ctx = NULL;
errmsg[0] = 0;
/*
* Send my name to the Director then do authentication
*/
if (cons) {
bstrncpy(bashed_name, cons->hdr.name, sizeof(bashed_name));
bash_spaces(bashed_name);
password = cons->password;
/* TLS Requirement */
if (cons->tls_enable) {
if (cons->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
tls_authenticate = cons->tls_authenticate;
tls_ctx = cons->tls_ctx;
} else {
bstrncpy(bashed_name, "*UserAgent*", sizeof(bashed_name));
password = director->password;
/* TLS Requirement */
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
tls_authenticate = director->tls_authenticate;
tls_ctx = director->tls_ctx;
}
if (tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
/* Timeout Hello after 15 secs */
dir->start_timer(15);
dir->fsend(hello, bashed_name);
/* respond to Dir challenge */
if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
/* Now challenge dir */
!cram_md5_challenge(dir, password, tls_local_need, compatible)) {
bsnprintf(errmsg, errmsg_len, _("Director authorization problem at \"%s:%d\"\n"),
dir->host(), dir->port());
goto bail_out;
}
/* Verify that the remote host is willing to meet our TLS requirements */
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
bsnprintf(errmsg, errmsg_len, _("Authorization problem:"
" Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
dir->host(), dir->port());
goto bail_out;
}
/* Verify that we are willing to meet the remote host's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
bsnprintf(errmsg, errmsg_len, _("Authorization problem with Director at \"%s:%d\":"
" Remote server requires TLS.\n"),
dir->host(), dir->port());
goto bail_out;
}
/* Is TLS Enabled? */
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_client(tls_ctx, dir, NULL)) {
bsnprintf(errmsg, errmsg_len, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
dir->host(), dir->port());
goto bail_out;
}
if (tls_authenticate) { /* authenticate only? */
dir->free_tls(); /* Yes, shutdown tls */
}
}
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
dir->stop_timer();
bsnprintf(errmsg, errmsg_len, _("Bad response to Hello command: ERR=%s\n"
"The Director at \"%s:%d\" is probably not running.\n"),
dir->bstrerror(), dir->host(), dir->port());
return false;
}
dir->stop_timer();
Dmsg1(10, "<dird: %s", dir->msg);
if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
bsnprintf(errmsg, errmsg_len, _("Director at \"%s:%d\" rejected Hello command\n"),
dir->host(), dir->port());
return false;
} else {
if (m_conn == 0) {
bsnprintf(errmsg, errmsg_len, "%s", dir->msg);
}
}
return true;
bail_out:
dir->stop_timer();
bsnprintf(errmsg, errmsg_len, _("Authorization problem with Director at \"%s:%d\"\n"
"Most likely the passwords do not agree.\n"
"If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
"Please see " MANUAL_AUTH_URL " for help.\n"),
dir->host(), dir->port());
return false;
}
/*
* Authenticate Director
*/
int authenticate_director(JCR *jcr, DIRRES *director, CONRES *cons)
{
BSOCK *dir = jcr->dir_bsock;
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
bool tls_authenticate;
int compatible = true;
char bashed_name[MAX_NAME_LENGTH];
char *password;
TLS_CONTEXT *tls_ctx = NULL;
/*
* Send my name to the Director then do authentication
*/
if (cons) {
bstrncpy(bashed_name, cons->hdr.name, sizeof(bashed_name));
bash_spaces(bashed_name);
password = cons->password;
/* TLS Requirement */
if (cons->tls_enable) {
if (cons->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (cons->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
tls_authenticate = cons->tls_authenticate;
tls_ctx = cons->tls_ctx;
} else {
bstrncpy(bashed_name, "*UserAgent*", sizeof(bashed_name));
password = director->password;
/* TLS Requirement */
if (director->tls_enable) {
if (director->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (director->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
tls_authenticate = director->tls_authenticate;
tls_ctx = director->tls_ctx;
}
/* Timeout Hello after 5 mins */
btimer_t *tid = start_bsock_timer(dir, 60 * 5);
dir->fsend(hello, bashed_name);
if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
!cram_md5_challenge(dir, password, tls_local_need, compatible)) {
goto bail_out;
}
/* Verify that the remote host is willing to meet our TLS requirements */
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
sendit(_("Authorization problem:"
" Remote server did not advertise required TLS support.\n"));
goto bail_out;
}
/* Verify that we are willing to meet the remote host's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
sendit(_("Authorization problem:"
" Remote server requires TLS.\n"));
goto bail_out;
}
/* Is TLS Enabled? */
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_client(tls_ctx, dir, NULL)) {
sendit(_("TLS negotiation failed\n"));
goto bail_out;
}
if (tls_authenticate) { /* Authenticate only? */
dir->free_tls(); /* yes, shutdown tls */
}
}
/*
* It's possible that the TLS connection will
* be dropped here if an invalid client certificate was presented
*/
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
senditf(_("Bad response to Hello command: ERR=%s\n"),
dir->bstrerror());
goto bail_out;
}
Dmsg1(10, "<dird: %s", dir->msg);
if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
sendit(_("Director rejected Hello command\n"));
goto bail_out;
} else {
sendit(dir->msg);
}
stop_bsock_timer(tid);
return 1;
bail_out:
stop_bsock_timer(tid);
sendit( _("Director authorization problem.\n"
"Most likely the passwords do not agree.\n"
"If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
"Please see " MANUAL_AUTH_URL " for help.\n"));
return 0;
}
/*
* Common routine for both label and relabel
*/
static int do_label(UAContext *ua, const char *cmd, bool relabel)
{
USTORERES store;
BSOCK *sd;
char dev_name[MAX_NAME_LENGTH];
MEDIA_DBR mr, omr;
POOL_DBR pr;
bool print_reminder = true;
bool label_barcodes = false;
bool label_encrypt = false;
int ok = FALSE;
int i, j;
int drive;
bool media_record_exists = false;
static const char *barcode_keywords[] = {
"barcode",
"barcodes",
NULL
};
memset(&pr, 0, sizeof(pr));
if (!open_client_db(ua)) {
return 1;
}
/*
* Look for one of the barcode keywords
*/
if (!relabel && (i = find_arg_keyword(ua, barcode_keywords)) >= 0) {
/*
* Now find the keyword in the list
*/
if ((j = find_arg(ua, barcode_keywords[i])) > 0) {
*ua->argk[j] = 0; /* zap barcode keyword */
}
label_barcodes = true;
}
/*
* Look for the encrypt keyword
*/
if ((i = find_arg(ua, "encrypt")) > 0) {
*ua->argk[i] = 0; /* zap encrypt keyword */
label_encrypt = true;
}
store.store = get_storage_resource(ua, true, label_barcodes);
if (!store.store) {
return 1;
}
switch (store.store->Protocol) {
case APT_NDMPV2:
case APT_NDMPV3:
case APT_NDMPV4:
/*
* See if the user selected a NDMP storage device but its
* handled by a native Bareos storage daemon e.g. we have
* a paired_storage pointer.
*/
if (store.store->paired_storage) {
store.store = store.store->paired_storage;
} else {
ua->warning_msg(_("Storage has non-native protocol.\n"));
return 1;
}
break;
default:
break;
}
pm_strcpy(store.store_source, _("command line"));
set_wstorage(ua->jcr, &store);
drive = get_storage_drive(ua, store.store);
if (label_barcodes) {
label_from_barcodes(ua, drive, label_encrypt);
return 1;
}
/*
* If relabel get name of Volume to relabel
*/
if (relabel) {
/*
* Check for oldvolume=name
*/
i = find_arg_with_value(ua, "oldvolume");
if (i >= 0) {
bstrncpy(omr.VolumeName, ua->argv[i], sizeof(omr.VolumeName));
if (db_get_media_record(ua->jcr, ua->db, &omr)) {
goto checkVol;
}
ua->error_msg("%s", db_strerror(ua->db));
}
/*
* No keyword or Vol not found, ask user to select
*/
if (!select_media_dbr(ua, &omr)) {
return 1;
}
/*
* Require Volume to be Purged or Recycled
*/
checkVol:
if (!bstrcmp(omr.VolStatus, "Purged") && !bstrcmp(omr.VolStatus, "Recycle")) {
ua->error_msg(_("Volume \"%s\" has VolStatus %s. It must be Purged or Recycled before relabeling.\n"),
omr.VolumeName, omr.VolStatus);
return 1;
}
}
/*
* Check for volume=NewVolume
*/
i = find_arg_with_value(ua, "volume");
if (i >= 0) {
pm_strcpy(ua->cmd, ua->argv[i]);
goto checkName;
}
/*
* Get a new Volume name
*/
for ( ;; ) {
media_record_exists = false;
if (!get_cmd(ua, _("Enter new Volume name: "))) {
return 1;
}
checkName:
if (!is_volume_name_legal(ua, ua->cmd)) {
continue;
}
/*
* Search by Media name so set VolumeName and clear MediaId.
*/
mr.MediaId = 0;
bstrncpy(mr.VolumeName, ua->cmd, sizeof(mr.VolumeName));
/*
* If VolBytes are zero the Volume is not labeled
*/
if (db_get_media_record(ua->jcr, ua->db, &mr)) {
if (mr.VolBytes != 0) {
ua->error_msg(_("Media record for new Volume \"%s\" already exists.\n"),
mr.VolumeName);
continue;
}
media_record_exists = true;
}
break; /* Got it */
}
/*
* If autochanger, request slot
*/
i = find_arg_with_value(ua, "slot");
if (i >= 0) {
mr.Slot = atoi(ua->argv[i]);
if (mr.Slot < 0) {
mr.Slot = 0;
}
mr.InChanger = mr.Slot > 0; /* if slot give assume in changer */
} else if (store.store->autochanger) {
if (!get_pint(ua, _("Enter slot (0 or Enter for none): "))) {
return 1;
}
mr.Slot = ua->pint32_val;
if (mr.Slot < 0) {
mr.Slot = 0;
}
mr.InChanger = mr.Slot > 0; /* if slot give assume in changer */
}
set_storageid_in_mr(store.store, &mr);
bstrncpy(mr.MediaType, store.store->media_type, sizeof(mr.MediaType));
/*
* Must select Pool if not already done
*/
if (pr.PoolId == 0) {
memset(&pr, 0, sizeof(pr));
if (!select_pool_dbr(ua, &pr)) {
return 1;
}
}
/*
* See if we need to generate a new passphrase for hardware encryption.
*/
if (label_encrypt) {
ua->info_msg(_("Generating new hardware encryption key\n"));
if (!generate_new_encryption_key(ua, &mr)) {
return 1;
}
}
ok = send_label_request(ua, &mr, &omr, &pr, relabel, media_record_exists, drive);
if (ok) {
sd = ua->jcr->store_bsock;
if (relabel) {
/*
* Delete the old media record
*/
if (!db_delete_media_record(ua->jcr, ua->db, &omr)) {
ua->error_msg(_("Delete of Volume \"%s\" failed. ERR=%s"),
omr.VolumeName, db_strerror(ua->db));
} else {
ua->info_msg(_("Old volume \"%s\" deleted from catalog.\n"),
omr.VolumeName);
/*
* Update the number of Volumes in the pool
*/
pr.NumVols--;
if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
}
}
if (ua->automount) {
bstrncpy(dev_name, store.store->dev_name(), sizeof(dev_name));
ua->info_msg(_("Requesting to mount %s ...\n"), dev_name);
bash_spaces(dev_name);
sd->fsend("mount %s drive=%d", dev_name, drive);
unbash_spaces(dev_name);
/*
* We use bget_dirmsg here and not bnet_recv because as part of
* the mount request the stored can request catalog information for
* any plugin who listens to the bsdEventLabelVerified event.
* As we don't want to loose any non protocol data e.g. errors
* without a 3xxx prefix we set the allow_any_message of
* bget_dirmsg to true and as such is behaves like a normal
* bnet_recv for any non protocol messages.
*/
while (bget_dirmsg(sd, true) >= 0) {
ua->send_msg("%s", sd->msg);
/*
* Here we can get
* 3001 OK mount. Device=xxx or
* 3001 Mounted Volume vvvv
* 3002 Device "DVD-Writer" (/dev/hdc) is mounted.
* 3906 is cannot mount non-tape
* So for those, no need to print a reminder
*/
if (bstrncmp(sd->msg, "3001 ", 5) ||
bstrncmp(sd->msg, "3002 ", 5) ||
bstrncmp(sd->msg, "3906 ", 5)) {
print_reminder = false;
}
}
}
}
if (print_reminder) {
ua->info_msg(_("Do not forget to mount the drive!!!\n"));
}
close_sd_bsock(ua);
return 1;
}
/**
* Get info on the next appendable volume in the Director's database
*
* Returns: true on success dcr->VolumeName is volume
* reserve_volume() called on Volume name
* false on failure dcr->VolumeName[0] == 0
* also sets dcr->found_in_use if at least one
* in use volume was found.
*
* Volume information returned in dcr
*/
bool SD_DCR::dir_find_next_appendable_volume()
{
bool retval;
BSOCK *dir = jcr->dir_bsock;
POOL_MEM unwanted_volumes(PM_MESSAGE);
Dmsg2(dbglvl, "dir_find_next_appendable_volume: reserved=%d Vol=%s\n", is_reserved(), VolumeName);
/*
* Try the twenty oldest or most available volumes. Note,
* the most available could already be mounted on another
* drive, so we continue looking for a not in use Volume.
*/
lock_volumes();
P(vol_info_mutex);
clear_found_in_use();
pm_strcpy(unwanted_volumes, "");
for (int vol_index = 1; vol_index < 20; vol_index++) {
bash_spaces(media_type);
bash_spaces(pool_name);
bash_spaces(unwanted_volumes.c_str());
dir->fsend(Find_media, jcr->Job, vol_index, pool_name, media_type, unwanted_volumes.c_str());
unbash_spaces(media_type);
unbash_spaces(pool_name);
unbash_spaces(unwanted_volumes.c_str());
Dmsg1(dbglvl, ">dird %s", dir->msg);
if (do_get_volume_info(this)) {
if (vol_index == 1) {
pm_strcpy(unwanted_volumes, VolumeName);
} else {
pm_strcat(unwanted_volumes, ",");
pm_strcat(unwanted_volumes, VolumeName);
}
if (can_i_write_volume()) {
Dmsg1(dbglvl, "Call reserve_volume for write. Vol=%s\n", VolumeName);
if (reserve_volume(this, VolumeName) == NULL) {
Dmsg2(dbglvl, "Could not reserve volume %s on %s\n", VolumeName, dev->print_name());
continue;
}
Dmsg1(dbglvl, "dir_find_next_appendable_volume return true. vol=%s\n", VolumeName);
retval = true;
goto get_out;
} else {
Dmsg1(dbglvl, "Volume %s is in use.\n", VolumeName);
/*
* If volume is not usable, it is in use by someone else
*/
set_found_in_use();
continue;
}
}
Dmsg2(dbglvl, "No vol. index %d return false. dev=%s\n", vol_index, dev->print_name());
break;
}
retval = false;
VolumeName[0] = 0;
get_out:
V(vol_info_mutex);
unlock_volumes();
return retval;
}
/*
* 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;
}
/*
* Authenticate Storage daemon connection
*/
bool authenticate_storage_daemon(JCR *jcr, STORERES *store)
{
BSOCK *sd = jcr->store_bsock;
char dirname[MAX_NAME_LENGTH];
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
int compatible = true;
bool auth_success = false;
/*
* Send my name to the Storage daemon then do authentication
*/
bstrncpy(dirname, director->hdr.name, sizeof(dirname));
bash_spaces(dirname);
/* Timeout Hello after 1 min */
btimer_t *tid = start_bsock_timer(sd, AUTH_TIMEOUT);
if (!sd->fsend(hello, dirname)) {
stop_bsock_timer(tid);
Dmsg1(dbglvl, _("Error sending Hello to Storage daemon. ERR=%s\n"), bnet_strerror(sd));
Jmsg(jcr, M_FATAL, 0, _("Error sending Hello to Storage daemon. ERR=%s\n"), bnet_strerror(sd));
return 0;
}
/* TLS Requirement */
if (store->tls_enable) {
if (store->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (store->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
auth_success = cram_md5_respond(sd, store->password, &tls_remote_need, &compatible);
if (auth_success) {
auth_success = cram_md5_challenge(sd, store->password, tls_local_need, compatible);
if (!auth_success) {
Dmsg1(dbglvl, "cram_challenge failed for %s\n", sd->who());
}
} else {
Dmsg1(dbglvl, "cram_respond failed for %s\n", sd->who());
}
if (!auth_success) {
stop_bsock_timer(tid);
Dmsg0(dbglvl, _("Director and Storage daemon passwords or names not the same.\n"));
Jmsg2(jcr, M_FATAL, 0,
_("Director unable to authenticate with Storage daemon at \"%s:%d\". Possible causes:\n"
"Passwords or names not the same or\n"
"Maximum Concurrent Jobs exceeded on the SD or\n"
"SD networking messed up (restart daemon).\n"
"Please see " MANUAL_AUTH_URL " for help.\n"),
sd->host(), sd->port());
return 0;
}
/* Verify that the remote host is willing to meet our TLS requirements */
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Authorization problem: Remote server did not advertise required TLS support.\n"));
return 0;
}
/* Verify that we are willing to meet the remote host's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Authorization problem: Remote server requires TLS.\n"));
return 0;
}
/* Is TLS Enabled? */
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_client(store->tls_ctx, sd, NULL)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("TLS negotiation failed with SD at \"%s:%d\"\n"),
sd->host(), sd->port());
return 0;
}
if (store->tls_authenticate) { /* authentication only? */
sd->free_tls(); /* yes, stop tls */
}
}
Dmsg1(116, ">stored: %s", sd->msg);
if (sd->recv() <= 0) {
stop_bsock_timer(tid);
Jmsg3(jcr, M_FATAL, 0, _("bdird<stored: \"%s:%s\" bad response to Hello command: ERR=%s\n"),
sd->who(), sd->host(), sd->bstrerror());
return 0;
}
Dmsg1(110, "<stored: %s", sd->msg);
stop_bsock_timer(tid);
if (!bstrncmp(sd->msg, OKhello, sizeof(OKhello))) {
Dmsg0(dbglvl, _("Storage daemon rejected Hello command\n"));
Jmsg2(jcr, M_FATAL, 0, _("Storage daemon at \"%s:%d\" rejected Hello command\n"),
sd->host(), sd->port());
return 0;
}
return 1;
}
/**
* After writing a Volume, send the updated statistics
* back to the director. The information comes from the
* dev record.
*/
bool dir_update_volume_info(DCR *dcr, bool label, bool update_LastWritten)
{
JCR *jcr = dcr->jcr;
BSOCK *dir = jcr->dir_bsock;
DEVICE *dev = dcr->dev;
VOLUME_CAT_INFO *vol = &dev->VolCatInfo;
char ed1[50], ed2[50], ed3[50], ed4[50], ed5[50], ed6[50];
int InChanger;
bool ok = false;
POOL_MEM VolumeName;
/* If system job, do not update catalog */
if (jcr->is_JobType(JT_SYSTEM)) {
return true;
}
if (vol->VolCatName[0] == 0) {
Jmsg0(jcr, M_FATAL, 0, _("NULL Volume name. This shouldn't happen!!!\n"));
Pmsg0(000, _("NULL Volume name. This shouldn't happen!!!\n"));
return false;
}
/* Lock during Volume update */
P(vol_info_mutex);
Dmsg1(dbglvl, "Update cat VolBytes=%lld\n", vol->VolCatBytes);
/* Just labeled or relabeled the tape */
if (label) {
bstrncpy(vol->VolCatStatus, "Append", sizeof(vol->VolCatStatus));
}
// if (update_LastWritten) {
vol->VolLastWritten = time(NULL);
// }
pm_strcpy(VolumeName, vol->VolCatName);
bash_spaces(VolumeName);
InChanger = vol->InChanger;
dir->fsend(Update_media, jcr->Job,
VolumeName.c_str(), vol->VolCatJobs, vol->VolCatFiles,
vol->VolCatBlocks, edit_uint64(vol->VolCatBytes, ed1),
vol->VolCatMounts, vol->VolCatErrors,
vol->VolCatWrites, edit_uint64(vol->VolCatMaxBytes, ed2),
edit_uint64(vol->VolLastWritten, ed6),
vol->VolCatStatus, vol->Slot, label,
InChanger, /* bool in structure */
edit_int64(vol->VolReadTime, ed3),
edit_int64(vol->VolWriteTime, ed4),
edit_uint64(vol->VolFirstWritten, ed5));
Dmsg1(dbglvl, ">dird %s", dir->msg);
/* Do not lock device here because it may be locked from label */
if (!jcr->is_canceled()) {
if (!do_get_volume_info(dcr)) {
Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
Dmsg2(dbglvl, _("Didn't get vol info vol=%s: ERR=%s"),
vol->VolCatName, jcr->errmsg);
goto bail_out;
}
Dmsg1(420, "get_volume_info() %s", dir->msg);
/* Update dev Volume info in case something changed (e.g. expired) */
dev->VolCatInfo = dcr->VolCatInfo;
ok = true;
}
bail_out:
V(vol_info_mutex);
return ok;
}
/*
* Authenticate File daemon connection
*/
int authenticate_file_daemon(JCR *jcr)
{
BSOCK *fd = jcr->file_bsock;
CLIENTRES *client = jcr->res.client;
char dirname[MAX_NAME_LENGTH];
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
int compatible = true;
bool auth_success = false;
/*
* Send my name to the File daemon then do authentication
*/
bstrncpy(dirname, director->name(), sizeof(dirname));
bash_spaces(dirname);
/* Timeout Hello after 1 min */
btimer_t *tid = start_bsock_timer(fd, AUTH_TIMEOUT);
if (!fd->fsend(hello, dirname)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Error sending Hello to File daemon at \"%s:%d\". ERR=%s\n"),
fd->host(), fd->port(), fd->bstrerror());
return 0;
}
Dmsg1(dbglvl, "Sent: %s", fd->msg);
/* TLS Requirement */
if (client->tls_enable) {
if (client->tls_require) {
tls_local_need = BNET_TLS_REQUIRED;
} else {
tls_local_need = BNET_TLS_OK;
}
}
if (client->tls_authenticate) {
tls_local_need = BNET_TLS_REQUIRED;
}
auth_success = cram_md5_respond(fd, client->password, &tls_remote_need, &compatible);
if (auth_success) {
auth_success = cram_md5_challenge(fd, client->password, tls_local_need, compatible);
if (!auth_success) {
Dmsg1(dbglvl, "cram_auth failed for %s\n", fd->who());
}
} else {
Dmsg1(dbglvl, "cram_get_auth failed for %s\n", fd->who());
}
if (!auth_success) {
stop_bsock_timer(tid);
Dmsg0(dbglvl, _("Director and File daemon passwords or names not the same.\n"));
Jmsg(jcr, M_FATAL, 0,
_("Unable to authenticate with File daemon at \"%s:%d\". Possible causes:\n"
"Passwords or names not the same or\n"
"Maximum Concurrent Jobs exceeded on the FD or\n"
"FD networking messed up (restart daemon).\n"
"Please see " MANUAL_AUTH_URL " for help.\n"),
fd->host(), fd->port());
return 0;
}
/* Verify that the remote host is willing to meet our TLS requirements */
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Authorization problem: FD \"%s:%s\" did not advertise required TLS support.\n"),
fd->who(), fd->host());
return 0;
}
/* Verify that we are willing to meet the remote host's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("Authorization problem: FD at \"%s:%d\" requires TLS.\n"),
fd->host(), fd->port());
return 0;
}
/* Is TLS Enabled? */
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_client(client->tls_ctx, fd, client->tls_allowed_cns)) {
stop_bsock_timer(tid);
Jmsg(jcr, M_FATAL, 0, _("TLS negotiation failed with FD at \"%s:%d\".\n"),
fd->host(), fd->port());
return 0;
}
if (client->tls_authenticate) { /* tls authentication only? */
fd->free_tls(); /* yes, shutdown tls */
}
}
Dmsg1(116, ">filed: %s", fd->msg);
if (fd->recv() <= 0) {
stop_bsock_timer(tid);
Dmsg1(dbglvl, _("Bad response from File daemon to Hello command: ERR=%s\n"),
bnet_strerror(fd));
Jmsg(jcr, M_FATAL, 0, _("Bad response from File daemon at \"%s:%d\" to Hello command: ERR=%s\n"),
fd->host(), fd->port(), fd->bstrerror());
return 0;
}
Dmsg1(110, "<filed: %s", fd->msg);
stop_bsock_timer(tid);
jcr->FDVersion = 0;
if (!bstrncmp(fd->msg, FDOKhello, sizeof(FDOKhello)) &&
sscanf(fd->msg, FDOKnewHello, &jcr->FDVersion) != 1) {
Dmsg0(dbglvl, _("File daemon rejected Hello command\n"));
Jmsg(jcr, M_FATAL, 0, _("File daemon at \"%s:%d\" rejected Hello command\n"),
fd->host(), fd->port());
return 0;
}
return 1;
}
/*
* NOTE! This routine opens the SD socket but leaves it open
*/
static bool send_label_request(UAContext *ua, MEDIA_DBR *mr, MEDIA_DBR *omr,
POOL_DBR *pr, bool relabel, bool media_record_exists,
int drive)
{
BSOCK *sd;
char dev_name[MAX_NAME_LENGTH];
bool ok = false;
uint64_t VolBytes = 0;
if (!(sd=open_sd_bsock(ua))) {
return false;
}
bstrncpy(dev_name, ua->jcr->res.wstore->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
bash_spaces(mr->VolumeName);
bash_spaces(mr->MediaType);
bash_spaces(pr->Name);
if (relabel) {
bash_spaces(omr->VolumeName);
sd->fsend("relabel %s OldName=%s NewName=%s PoolName=%s "
"MediaType=%s Slot=%d drive=%d MinBlocksize=%d MaxBlocksize=%d",
dev_name, omr->VolumeName, mr->VolumeName, pr->Name,
mr->MediaType, mr->Slot, drive,
/*
* if relabeling, keep blocksize settings
*/
omr->MinBlocksize, omr->MaxBlocksize);
ua->send_msg(_("Sending relabel command from \"%s\" to \"%s\" ...\n"),
omr->VolumeName, mr->VolumeName);
} else {
sd->fsend("label %s VolumeName=%s PoolName=%s MediaType=%s "
"Slot=%d drive=%d MinBlocksize=%d MaxBlocksize=%d",
dev_name, mr->VolumeName, pr->Name, mr->MediaType,
mr->Slot, drive,
/*
* if labeling, use blocksize defined in pool
*/
pr->MinBlocksize, pr->MaxBlocksize);
ua->send_msg(_("Sending label command for Volume \"%s\" Slot %d ...\n"),
mr->VolumeName, mr->Slot);
Dmsg8(100, "label %s VolumeName=%s PoolName=%s MediaType=%s "
"Slot=%d drive=%d MinBlocksize=%d MaxBlocksize=%d\n",
dev_name, mr->VolumeName, pr->Name, mr->MediaType, mr->Slot, drive,
pr->MinBlocksize, pr->MaxBlocksize);
}
/*
* We use bget_dirmsg here and not bnet_recv because as part of
* the label request the stored can request catalog information for
* any plugin who listens to the bsdEventLabelVerified event.
* As we don't want to loose any non protocol data e.g. errors
* without a 3xxx prefix we set the allow_any_message of
* bget_dirmsg to true and as such is behaves like a normal
* bnet_recv for any non protocol messages.
*/
while (bget_dirmsg(sd, true) >= 0) {
ua->send_msg("%s", sd->msg);
if (sscanf(sd->msg, "3000 OK label. VolBytes=%llu ", &VolBytes) == 1) {
ok = true;
}
}
unbash_spaces(mr->VolumeName);
unbash_spaces(mr->MediaType);
unbash_spaces(pr->Name);
mr->LabelDate = time(NULL);
mr->set_label_date = true;
if (ok) {
if (media_record_exists) { /* we update it */
mr->VolBytes = VolBytes;
mr->InChanger = mr->Slot > 0; /* if slot give assume in changer */
set_storageid_in_mr(ua->jcr->res.wstore, mr);
if (!db_update_media_record(ua->jcr, ua->db, mr)) {
ua->error_msg("%s", db_strerror(ua->db));
ok = false;
}
} else { /* create the media record */
set_pool_dbr_defaults_in_media_dbr(mr, pr);
mr->VolBytes = VolBytes;
mr->InChanger = mr->Slot > 0; /* if slot give assume in changer */
mr->Enabled = 1;
set_storageid_in_mr(ua->jcr->res.wstore, mr);
if (db_create_media_record(ua->jcr, ua->db, mr)) {
ua->info_msg(_("Catalog record for Volume \"%s\", Slot %d successfully created.\n"),
mr->VolumeName, mr->Slot);
/*
* Update number of volumes in pool
*/
pr->NumVols++;
if (!db_update_pool_record(ua->jcr, ua->db, pr)) {
ua->error_msg("%s", db_strerror(ua->db));
}
} else {
ua->error_msg("%s", db_strerror(ua->db));
ok = false;
}
}
} else {
ua->error_msg(_("Label command failed for Volume %s.\n"), mr->VolumeName);
}
return ok;
}