+/*
+ Bacula® - The Network Backup Solution
+
+ Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
+
+ The main author of Bacula is Kern Sibbald, with contributions from
+ many others, a complete list can be found in the file AUTHORS.
+ This program is Free Software; you can redistribute it and/or
+ modify it under the terms of version two of the GNU General Public
+ License as published by the Free Software Foundation plus additions
+ that are listed in the file LICENSE.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+ Bacula® is a registered trademark of John Walker.
+ The licensor of Bacula is the Free Software Foundation Europe
+ (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
+ Switzerland, email:ftf@fsfeurope.org.
+*/
/*
*
* Bacula Director -- User Agent Commands
*
* Version $Id$
*/
-/*
- Copyright (C) 2000-2006 Kern Sibbald
-
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License
- version 2 as amended with additional clauses defined in the
- file LICENSE in the main source directory.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- the file LICENSE for additional details.
-
- */
-
+
#include "bacula.h"
#include "dird.h"
{
unsigned int i;
int len, stat;
+ bool ok = false;
bool found = false;
+ BSOCK *user = ua->UA_sock;
stat = 1;
return 1;
}
- while (ua->jcr->storage->size()) {
- ua->jcr->storage->remove(0);
+ while (ua->jcr->wstorage->size()) {
+ ua->jcr->wstorage->remove(0);
}
len = strlen(ua->argk[0]);
!acl_access_ok(ua, Command_ACL, ua->argk[0], len)) {
break;
}
- stat = (*commands[i].func)(ua, cmd); /* go execute command */
+ if (ua->api) user->signal(BNET_CMD_BEGIN);
+ ok = (*commands[i].func)(ua, cmd); /* go execute command */
found = true;
break;
}
}
if (!found) {
- bnet_fsend(ua->UA_sock, _("%s: is an illegal command.\n"), ua->argk[0]);
+ user->fsend(_("%s: is an invalid command.\n"), ua->argk[0]);
}
- return stat;
+ if (ua->api) user->signal(ok?BNET_CMD_OK:BNET_CMD_FAILED);
+ return ok;
}
/*
mr->Recycle = pr->Recycle;
mr->VolRetention = pr->VolRetention;
mr->VolUseDuration = pr->VolUseDuration;
+ mr->RecyclePoolId = pr->RecyclePoolId;
mr->MaxVolJobs = pr->MaxVolJobs;
mr->MaxVolFiles = pr->MaxVolFiles;
mr->MaxVolBytes = pr->MaxVolBytes;
"creates database records without labeling the Volumes.\n"
"You probably want to use the \"label\" command.\n\n"));
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
return 1;
}
JCR *jcr = NULL;
char JobName[MAX_NAME_LENGTH];
- if (!open_db(ua)) {
- return 1;
- }
-
for (i=1; i<ua->argc; i++) {
if (strcasecmp(ua->argk[i], NT_("jobid")) == 0) {
uint32_t JobId;
}
}
- /* If we still do not have a jcr,
- * throw up a list and ask the user to select one.
- */
- if (!jcr) {
+ if (jcr) {
+ if (jcr->job && !acl_access_ok(ua, Job_ACL, jcr->job->name())) {
+ bsendmsg(ua, _("Unauthorized command from this console.\n"));
+ return 1;
+ }
+ } else {
+ /*
+ * If we still do not have a jcr,
+ * throw up a list and ask the user to select one.
+ */
char buf[1000];
+ int tjobs = 0; /* total # number jobs */
/* Count Jobs running */
foreach_jcr(jcr) {
if (jcr->JobId == 0) { /* this is us */
continue;
}
- njobs++;
+ tjobs++; /* count of all jobs */
+ if (!acl_access_ok(ua, Job_ACL, jcr->job->name())) {
+ continue; /* skip not authorized */
+ }
+ njobs++; /* count of authorized jobs */
}
endeach_jcr(jcr);
- if (njobs == 0) {
- bsendmsg(ua, _("No Jobs running.\n"));
+ if (njobs == 0) { /* no authorized */
+ if (tjobs == 0) {
+ bsendmsg(ua, _("No Jobs running.\n"));
+ } else {
+ bsendmsg(ua, _("None of your jobs are running.\n"));
+ }
return 1;
}
+
start_prompt(ua, _("Select Job:\n"));
foreach_jcr(jcr) {
char ed1[50];
if (jcr->JobId == 0) { /* this is us */
continue;
}
+ if (!acl_access_ok(ua, Job_ACL, jcr->job->name())) {
+ continue; /* skip not authorized */
+ }
bsnprintf(buf, sizeof(buf), _("JobId=%s Job=%s"), edit_int64(jcr->JobId, ed1), jcr->Job);
add_prompt(ua, buf);
}
sscanf(buf, "JobId=%d Job=%127s", &njobs, JobName);
jcr = get_jcr_by_full_name(JobName);
if (!jcr) {
- bsendmsg(ua, _("Job %s not found.\n"), JobName);
+ bsendmsg(ua, _("Job \"%s\" not found.\n"), JobName);
return 1;
}
}
* the setting of MaxVols and NumVols slightly differently
* depending on if we are creating the Pool or we are
* simply bringing it into agreement with the resource (updage).
+ *
+ * Caution : RecyclePoolId isn't setup in this function.
+ * You can use set_pooldbr_recyclepoolid();
+ *
*/
void set_pooldbr_from_poolres(POOL_DBR *pr, POOL *pool, e_pool_op op)
{
}
}
+/* set/update Pool.RecyclePoolId in Catalog */
+int update_pool_recyclepool(JCR *jcr, B_DB *db, POOL *pool)
+{
+ POOL_DBR pr;
+
+ if (!pool->RecyclePool) {
+ return 1;
+ }
+
+ memset(&pr, 0, sizeof(POOL_DBR));
+ bstrncpy(pr.Name, pool->name(), sizeof(pr.Name));
+
+ if (!db_get_pool_record(jcr, db, &pr)) {
+ return -1; /* not exists in database */
+ }
+
+ set_pooldbr_from_poolres(&pr, pool, POOL_OP_UPDATE);
+
+ if (!set_pooldbr_recyclepoolid(jcr, db, &pr, pool)) {
+ return -1; /* error */
+ }
+
+ if (!db_update_pool_record(jcr, db, &pr)) {
+ return -1; /* error */
+ }
+ return 1;
+}
+
+/* set POOL_DBR.RecyclePoolId from Pool resource
+ * works with set_pooldbr_from_poolres
+ */
+bool set_pooldbr_recyclepoolid(JCR *jcr, B_DB *db, POOL_DBR *pr, POOL *pool)
+{
+ POOL_DBR rpool;
+ bool ret = true;
+
+ if (pool->RecyclePool) {
+ memset(&rpool, 0, sizeof(POOL_DBR));
+
+ bstrncpy(rpool.Name, pool->RecyclePool->name(), sizeof(rpool.Name));
+ if (db_get_pool_record(jcr, db, &rpool)) {
+ pr->RecyclePoolId = rpool.PoolId;
+ } else {
+ Jmsg(jcr, M_WARNING, 0,
+ _("Can't set %s RecyclePool to %s, %s is not in database.\n" \
+ "Try to update it with 'update pool=%s'\n"),
+ pool->name(), rpool.Name, rpool.Name,pool->name());
+
+ ret = false;
+ }
+ } else { /* no RecyclePool used, set it to 0 */
+ pr->RecyclePoolId = 0;
+ }
+ return ret;
+}
+
/*
* Create a pool record from a given Pool resource
memset(&pr, 0, sizeof(POOL_DBR));
- bstrncpy(pr.Name, pool->hdr.name, sizeof(pr.Name));
+ bstrncpy(pr.Name, pool->name(), sizeof(pr.Name));
if (db_get_pool_record(jcr, db, &pr)) {
/* Pool Exists */
{
POOL *pool;
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
return 1;
}
switch (create_pool(ua->jcr, ua->db, pool, POOL_OP_CREATE)) {
case 0:
bsendmsg(ua, _("Error: Pool %s already exists.\n"
- "Use update to change it.\n"), pool->hdr.name);
+ "Use update to change it.\n"), pool->name());
break;
case -1:
default:
break;
}
- bsendmsg(ua, _("Pool %s created.\n"), pool->hdr.name);
+ bsendmsg(ua, _("Pool %s created.\n"), pool->name());
return 1;
}
*/
static int python_cmd(UAContext *ua, const char *cmd)
{
- if (ua->argc >= 1 && strcasecmp(ua->argk[1], NT_("restart")) == 0) {
+ if (ua->argc >= 2 && strcasecmp(ua->argk[1], NT_("restart")) == 0) {
term_python_interpreter();
- init_python_interpreter(director->hdr.name,
+ init_python_interpreter(director->name(),
director->scripts_directory, "DirStartUp");
bsendmsg(ua, _("Python interpreter restarted.\n"));
} else {
{
CLIENT *client;
char buf[1024];
- if (!ua->cons || !acl_access_ok(ua, Client_ACL, ua->cons->hdr.name)) {
- bsendmsg(ua, _("Illegal command from this console.\n"));
+ if (!ua->cons || !acl_access_ok(ua, Client_ACL, ua->cons->name())) {
+ bsendmsg(ua, _("Unauthorized command from this console.\n"));
return 1;
}
LockRes();
- client = (CLIENT *)GetResWithName(R_CLIENT, ua->cons->hdr.name);
+ client = (CLIENT *)GetResWithName(R_CLIENT, ua->cons->name());
if (!client) {
- bsendmsg(ua, _("Client \"%s\" not found.\n"), ua->cons->hdr.name);
+ bsendmsg(ua, _("Client \"%s\" not found.\n"), ua->cons->name());
goto get_out;
}
if (client->address) {
sockaddr_to_ascii(&(ua->UA_sock->client_addr), buf, sizeof(buf));
client->address = bstrdup(buf);
bsendmsg(ua, _("Client \"%s\" address set to %s\n"),
- client->hdr.name, client->address);
+ client->name(), client->address);
get_out:
UnlockRes();
return 1;
return;
}
- if (!acl_access_ok(ua, Job_ACL, job->hdr.name)) {
- bsendmsg(ua, _("Illegal command from this console.\n"));
+ if (!acl_access_ok(ua, Job_ACL, job->name())) {
+ bsendmsg(ua, _("Unauthorized command from this console.\n"));
return;
}
job->enabled = setting;
- bsendmsg(ua, _("Job \"%s\" %sabled\n"), job->hdr.name, setting?"en":"dis");
+ bsendmsg(ua, _("Job \"%s\" %sabled\n"), job->name(), setting?"en":"dis");
return;
}
{
BSOCK *sd;
JCR *jcr = ua->jcr;
-
- set_storage(jcr, store);
+ USTORE lstore;
+
+ lstore.store = store;
+ pm_strcpy(lstore.store_source, _("unknown source"));
+ set_wstorage(jcr, &lstore);
/* Try connecting for up to 15 seconds */
bsendmsg(ua, _("Connecting to Storage daemon %s at %s:%d\n"),
- store->hdr.name, store->address, store->SDport);
+ store->name(), store->address, store->SDport);
if (!connect_to_storage_daemon(jcr, 1, 15, 0)) {
bsendmsg(ua, _("Failed to connect to Storage daemon.\n"));
return;
ua->jcr->client = client;
/* Try to connect for 15 seconds */
bsendmsg(ua, _("Connecting to Client %s at %s:%d\n"),
- client->hdr.name, client->address, client->FDport);
+ client->name(), client->address, client->FDport);
if (!connect_to_file_daemon(ua->jcr, 1, 15, 0)) {
bsendmsg(ua, _("Failed to connect to Client.\n"));
return;
int trace_flag = -1;
int i;
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
return 1;
}
Dmsg1(120, "setdebug:%s:\n", cmd);
POOLMEM *val = get_pool_memory(PM_FNAME);
char *var;
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
return 1;
}
for (var=ua->cmd; *var != ' '; ) { /* skip command */
if (strcasecmp(ua->argk[i], NT_("job")) == 0) {
if (ua->argv[i]) {
job = (JOB *)GetResWithName(R_JOB, ua->argv[i]);
+ if (job && !acl_access_ok(ua, Job_ACL, job->name())) {
+ bsendmsg(ua, _("No authorization for Job \"%s\"\n"), job->name());
+ return 1;
+ }
continue;
}
}
if (strcasecmp(ua->argk[i], NT_("fileset")) == 0) {
if (ua->argv[i]) {
fileset = (FILESET *)GetResWithName(R_FILESET, ua->argv[i]);
+ if (fileset && !acl_access_ok(ua, FileSet_ACL, fileset->name())) {
+ bsendmsg(ua, _("No authorization for FileSet \"%s\"\n"), fileset->name());
+ return 1;
+ }
continue;
}
}
bsendmsg(ua, _("No job specified.\n"));
return 1;
}
+ if (!acl_access_ok(ua, Job_ACL, job->name())) {
+ bsendmsg(ua, _("No authorization for Job \"%s\"\n"), job->name());
+ return 1;
+ }
}
if (!client) {
client = job->client;
get_level_since_time(ua->jcr, since, sizeof(since));
bsendmsg(ua, _("Connecting to Client %s at %s:%d\n"),
- job->client->hdr.name, job->client->address, job->client->FDport);
+ job->client->name(), job->client->address, job->client->FDport);
if (!connect_to_file_daemon(jcr, 1, 15, 0)) {
bsendmsg(ua, _("Failed to connect to Client.\n"));
return 1;
NT_("jobid"),
NULL};
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
return 1;
}
/*
* do_job_delete now performs the actual delete operation atomically
- * we always return 1 because C++ is pissy about void functions
*/
static void do_job_delete(UAContext *ua, JobId_t JobId)
{
- POOLMEM *query = get_pool_memory(PM_MESSAGE);
+ POOL_MEM query(PM_MESSAGE);
char ed1[50];
- Mmsg(query, "DELETE FROM Job WHERE JobId=%s", edit_int64(JobId, ed1));
- db_sql_query(ua->db, query, NULL, (void *)NULL);
- Mmsg(query, "DELETE FROM MAC WHERE JobId=%s", ed1);
- db_sql_query(ua->db, query, NULL, (void *)NULL);
- Mmsg(query, "DELETE FROM File WHERE JobId=%s", ed1);
- db_sql_query(ua->db, query, NULL, (void *)NULL);
- Mmsg(query, "DELETE FROM JobMedia WHERE JobId=%s", ed1);
- db_sql_query(ua->db, query, NULL, (void *)NULL);
- free_pool_memory(query);
+ purge_files_from_job(ua, JobId);
+ purge_job_from_catalog(ua, JobId);
bsendmsg(ua, _("Job %s and associated records deleted from the catalog.\n"), edit_int64(JobId, ed1));
}
static void do_mount_cmd(UAContext *ua, const char *command)
{
- STORE *store;
+ USTORE store;
BSOCK *sd;
JCR *jcr = ua->jcr;
char dev_name[MAX_NAME_LENGTH];
int drive;
+ int slot = -1;
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
return;
}
Dmsg2(120, "%s: %s\n", command, ua->UA_sock->msg);
- store = get_storage_resource(ua, true/*arg is storage*/);
- if (!store) {
+ store.store = get_storage_resource(ua, true/*arg is storage*/);
+ pm_strcpy(store.store_source, _("unknown source"));
+ if (!store.store) {
return;
}
- set_storage(jcr, store);
- drive = get_storage_drive(ua, store);
+ set_wstorage(jcr, &store);
+ drive = get_storage_drive(ua, store.store);
+ if (strcmp(command, "mount") == 0) {
+ slot = get_storage_slot(ua, store.store);
+ }
Dmsg3(120, "Found storage, MediaType=%s DevName=%s drive=%d\n",
- store->media_type, store->dev_name(), drive);
+ store.store->media_type, store.store->dev_name(), drive);
if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
bsendmsg(ua, _("Failed to connect to Storage daemon.\n"));
return;
}
sd = jcr->store_bsock;
- bstrncpy(dev_name, store->dev_name(), sizeof(dev_name));
+ bstrncpy(dev_name, store.store->dev_name(), sizeof(dev_name));
bash_spaces(dev_name);
- bnet_fsend(sd, "%s %s drive=%d", command, dev_name, drive);
+ if (slot > 0) {
+ bnet_fsend(sd, "%s %s drive=%d slot=%d", command, dev_name, drive, slot);
+ } else {
+ bnet_fsend(sd, "%s %s drive=%d", command, dev_name, drive);
+ }
while (bnet_recv(sd) >= 0) {
bsendmsg(ua, "%s", sd->msg);
}
}
/*
- * mount [storage=<name>] [drive=nn]
+ * mount [storage=<name>] [drive=nn] [slot=mm]
*/
static int mount_cmd(UAContext *ua, const char *cmd)
{
}
if (open_db(ua)) {
bsendmsg(ua, _("Using Catalog name=%s DB=%s\n"),
- ua->catalog->hdr.name, ua->catalog->db_name);
+ ua->catalog->name(), ua->catalog->db_name);
}
return 1;
}
int quit_cmd(UAContext *ua, const char *cmd)
{
- ua->quit = TRUE;
+ ua->quit = true;
return 1;
}
uint32_t jobid = 0 ;
- if (!open_db(ua)) {
+ if (!open_client_db(ua)) {
bsendmsg(ua, _("ERR: Can't open db\n")) ;
return 1;
}
return 1;
}
+/*
+ * This call explicitly checks for a catalog=xxx and
+ * if given, opens that catalog. It also checks for
+ * client=xxx and if found, opens the catalog
+ * corresponding to that client. If we still don't
+ * have a catalog, look for a Job keyword and get the
+ * catalog from its client record.
+ */
+bool open_client_db(UAContext *ua)
+{
+ int i;
+ CAT *catalog;
+ CLIENT *client;
+ JOB *job;
+
+ /* Try for catalog keyword */
+ i = find_arg_with_value(ua, NT_("catalog"));
+ if (i >= 0) {
+ if (!acl_access_ok(ua, Catalog_ACL, ua->argv[i])) {
+ bsendmsg(ua, _("No authorization for Catalog \"%s\"\n"), ua->argv[i]);
+ return false;
+ }
+ catalog = (CAT *)GetResWithName(R_CATALOG, ua->argv[i]);
+ if (catalog) {
+ if (ua->catalog && ua->catalog != catalog) {
+ close_db(ua);
+ }
+ ua->catalog = catalog;
+ return open_db(ua);
+ }
+ }
-/* A bit brain damaged in that if the user has not done
- * a "use catalog xxx" command, we simply find the first
- * catalog resource and open it.
+ /* Try for client keyword */
+ i = find_arg_with_value(ua, NT_("client"));
+ if (i >= 0) {
+ if (!acl_access_ok(ua, Client_ACL, ua->argv[i])) {
+ bsendmsg(ua, _("No authorization for Client \"%s\"\n"), ua->argv[i]);
+ return false;
+ }
+ client = (CLIENT *)GetResWithName(R_CLIENT, ua->argv[i]);
+ if (client) {
+ catalog = client->catalog;
+ if (ua->catalog && ua->catalog != catalog) {
+ close_db(ua);
+ }
+ if (!acl_access_ok(ua, Catalog_ACL, catalog->name())) {
+ bsendmsg(ua, _("No authorization for Catalog \"%s\"\n"), catalog->name());
+ return false;
+ }
+ ua->catalog = catalog;
+ return open_db(ua);
+ }
+ }
+
+ /* Try for Job keyword */
+ i = find_arg_with_value(ua, NT_("job"));
+ if (i >= 0) {
+ if (!acl_access_ok(ua, Job_ACL, ua->argv[i])) {
+ bsendmsg(ua, _("No authorization for Job \"%s\"\n"), ua->argv[i]);
+ return false;
+ }
+ job = (JOB *)GetResWithName(R_JOB, ua->argv[i]);
+ if (job) {
+ catalog = job->client->catalog;
+ if (ua->catalog && ua->catalog != catalog) {
+ close_db(ua);
+ }
+ if (!acl_access_ok(ua, Catalog_ACL, catalog->name())) {
+ bsendmsg(ua, _("No authorization for Catalog \"%s\"\n"), catalog->name());
+ return false;
+ }
+ ua->catalog = catalog;
+ return open_db(ua);
+ }
+ }
+
+ return open_db(ua);
+}
+
+
+/*
+ * Open the catalog database.
*/
bool open_db(UAContext *ua)
{
return true;
}
if (!ua->catalog) {
- LockRes();
- ua->catalog = (CAT *)GetNextRes(R_CATALOG, NULL);
- UnlockRes();
+ ua->catalog = get_catalog_resource(ua);
if (!ua->catalog) {
bsendmsg(ua, _("Could not find a Catalog resource\n"));
return false;
- } else if (!acl_access_ok(ua, Catalog_ACL, ua->catalog->hdr.name)) {
- bsendmsg(ua, _("You must specify a \"use <catalog-name>\" command before continuing.\n"));
- ua->catalog = NULL;
- return false;
- } else {
- bsendmsg(ua, _("Using default Catalog name=%s DB=%s\n"),
- ua->catalog->hdr.name, ua->catalog->db_name);
}
}
ua->catalog->db_port, ua->catalog->db_socket,
ua->catalog->mult_db_connections);
if (!ua->db || !db_open_database(ua->jcr, ua->db)) {
- bsendmsg(ua, _("Could not open database \"%s\".\n"),
+ bsendmsg(ua, _("Could not open catalog database \"%s\".\n"),
ua->catalog->db_name);
if (ua->db) {
bsendmsg(ua, "%s", db_strerror(ua->db));
return false;
}
ua->jcr->db = ua->db;
+ bsendmsg(ua, _("Using Catalog \"%s\"\n"), ua->catalog->name());
Dmsg1(150, "DB %s opened\n", ua->catalog->db_name);
return true;
}