void OUTPUT_FORMATTER::object_key_value(const char *key, const char *key_fmt,
const char *value, const char *value_fmt,
int wrap)
{
POOL_MEM string;
POOL_MEM wvalue(value);
rewrap(wvalue, wrap);
switch (api) {
#if HAVE_JANSSON
case API_MODE_JSON:
json_key_value_add(key, wvalue.c_str());
break;
#endif
default:
if (key_fmt) {
string.bsprintf(key_fmt, key);
result_message_plain->strcat(string);
}
if (value_fmt) {
string.bsprintf(value_fmt, wvalue.c_str());
result_message_plain->strcat(string);
}
Dmsg2(800, "obj: %s:%s\n", key, wvalue.c_str());
}
}
void OUTPUT_FORMATTER::json_finalize_result(bool result)
{
POOL_MEM string;
json_t *msg_obj = json_object();
json_t *error_obj;
/*
* We mimic json-rpc result and error messages,
* To make it easier to implement real json-rpc later on.
*/
json_object_set(msg_obj, "jsonrpc", json_string("2.0"));
json_object_set(msg_obj, "id", json_null());
if (result) {
json_object_set(msg_obj, "result", result_array_json);
} else {
error_obj = json_object();
json_object_set_new(error_obj, "code", json_integer(1));
json_object_set_new(error_obj, "message", json_string("failed"));
json_object_set(error_obj, "data", result_array_json);
json_object_set_new(msg_obj, "error", error_obj);
}
string.bsprintf("%s\n", json_dumps(msg_obj, UA_JSON_FLAGS));
send_func(send_ctx, string.c_str());
json_array_clear(result_array_json);
json_object_clear(msg_obj);
}
static inline bool configure_create_fd_resource_string(UAContext *ua, POOL_MEM &resource, const char *clientname)
{
CLIENTRES *client;
s_password *password;
POOL_MEM temp(PM_MESSAGE);
client = ua->GetClientResWithName(clientname);
if (!client) {
return false;
}
password = &client->password;
resource.strcat("Director {\n");
config_add_directive(NULL, NULL, "Name", me->name(), resource);
switch (password->encoding) {
case p_encoding_clear:
Mmsg(temp, "\"%s\"", password->value);
break;
case p_encoding_md5:
Mmsg(temp, "\"[md5]%s\"", password->value);
break;
default:
break;
}
config_add_directive(NULL, NULL, "Password", temp.c_str(), resource);
resource.strcat("}\n");
return true;
}
/*
* Dump contents of resource
*/
void dump_resource(int type, RES *reshdr,
void sendit(void *sock, const char *fmt, ...),
void *sock, bool hide_sensitive_data)
{
POOL_MEM buf;
URES *res = (URES *)reshdr;
BRSRES *resclass;
bool recurse = true;
if (res == NULL) {
sendit(sock, _("Warning: no \"%s\" resource (%d) defined.\n"), res_to_str(type), type);
return;
}
if (type < 0) { /* no recursion */
type = - type;
recurse = false;
}
switch (type) {
default:
resclass = (BRSRES *)reshdr;
resclass->print_config(buf);
break;
}
sendit(sock, "%s", buf.c_str());
if (recurse && res->res_dir.hdr.next) {
dump_resource(type, res->res_dir.hdr.next, sendit, sock, hide_sensitive_data);
}
}
int pm_strcpy(POOLMEM *&pm, POOL_MEM &str)
{
int len = strlen(str.c_str()) + 1;
pm = check_pool_memory_size(pm, len);
memcpy(pm, str.c_str(), len);
return len - 1;
}
int pm_strcat(POOLMEM *&pm, POOL_MEM &str)
{
int pmlen = strlen(pm);
int len = strlen(str.c_str()) + 1;
pm = check_pool_memory_size(pm, pmlen + len);
memcpy(pm+pmlen, str.c_str(), len);
return pmlen + len - 1;
}
/*
* Edit codes into (Un)MountCommand, Write(First)PartCommand
* %% = %
* %a = archive device name
* %e = erase (set if cannot mount and first part)
* %n = part number
* %m = mount point
* %v = last part name
*
* omsg = edited output message
* imsg = input string containing edit codes (%x)
*
*/
void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
{
const char *p;
const char *str;
char add[20];
POOL_MEM archive_name(PM_FNAME);
omsg.c_str()[0] = 0;
Dmsg1(800, "edit_mount_codes: %s\n", imsg);
for (p=imsg; *p; p++) {
if (*p == '%') {
switch (*++p) {
case '%':
str = "%";
break;
case 'a':
str = dev_name;
break;
case 'e':
if (num_dvd_parts == 0) {
if (truncating || blank_dvd) {
str = "2";
} else {
str = "1";
}
} else {
str = "0";
}
break;
case 'n':
bsnprintf(add, sizeof(add), "%d", part);
str = add;
break;
case 'm':
str = device->mount_point;
break;
default:
add[0] = '%';
add[1] = *p;
add[2] = 0;
str = add;
break;
}
} else {
add[0] = *p;
add[1] = 0;
str = add;
}
Dmsg1(1900, "add_str %s\n", str);
pm_strcat(omsg, (char *)str);
Dmsg1(1800, "omsg=%s\n", omsg.c_str());
}
}
int pm_strcpy(POOL_MEM &pm, const char *str)
{
int len;
if (!str) str = "";
len = strlen(str) + 1;
pm.check_size(len);
memcpy(pm.c_str(), str, len);
return len - 1;
}
int pm_strcat(POOL_MEM &pm, const char *str)
{
int pmlen = strlen(pm.c_str());
int len;
if (!str) str = "";
len = strlen(str) + 1;
pm.check_size(pmlen + len);
memcpy(pm.c_str()+pmlen, str, len);
return pmlen + len - 1;
}
bool CONFIG::get_config_include_path(POOL_MEM &full_path, const char *config_dir)
{
bool found = false;
if (m_config_include_dir) {
/*
* Set full_path to the initial part of the include path,
* so it can be used as result, even on errors.
* On success, full_path will be overwritten with the full path.
*/
full_path.strcpy(config_dir);
path_append(full_path, m_config_include_dir);
if (path_is_directory(full_path)) {
m_config_dir = bstrdup(config_dir);
/*
* Set full_path to wildcard path.
*/
if (get_path_of_resource(full_path, NULL, NULL, NULL, true)) {
m_use_config_include_dir = true;
found = true;
}
}
}
return found;
}
/*
* Fill the rx->BaseJobIds and display the list
*/
static void get_and_display_basejobs(UAContext *ua, RESTORE_CTX *rx)
{
db_list_ctx jobids;
if (!db_get_used_base_jobids(ua->jcr, ua->db, rx->JobIds, &jobids)) {
ua->warning_msg("%s", db_strerror(ua->db));
}
if (jobids.count) {
POOL_MEM q;
Mmsg(q, uar_print_jobs, jobids.list);
ua->send_msg(_("The restore will use the following job(s) as Base\n"));
db_list_sql_query(ua->jcr, ua->db, q.c_str(), prtit, ua, 1, HORZ_LIST);
}
pm_strcpy(rx->BaseJobIds, jobids.list);
}
void OUTPUT_FORMATTER::decoration(const char *fmt, ...)
{
POOL_MEM string;
va_list arg_ptr;
switch (api) {
case API_MODE_ON:
case API_MODE_JSON:
break;
default:
va_start(arg_ptr, fmt);
string.bvsprintf(fmt, arg_ptr);
result_message_plain->strcat(string);
va_end(arg_ptr);
break;
}
}
static void add_file_and_part_name(DEVICE *dev, POOL_MEM &archive_name)
{
char partnumber[20];
if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
pm_strcat(archive_name, "/");
}
pm_strcat(archive_name, dev->getVolCatName());
/* if part > 1, append .# to the filename (where # is the part number) */
if (dev->part > 1) {
pm_strcat(archive_name, ".");
bsnprintf(partnumber, sizeof(partnumber), "%d", dev->part);
pm_strcat(archive_name, partnumber);
}
Dmsg2(400, "Exit add_file_part_name: arch=%s, part=%d\n",
archive_name.c_str(), dev->part);
}
static void configure_lex_error_handler(const char *file, int line, LEX *lc, POOL_MEM &msg)
{
UAContext *ua;
lc->error_counter++;
if (lc->caller_ctx) {
ua = (UAContext *)(lc->caller_ctx);
ua->error_msg("configure error: %s\n", msg.c_str());
};
}
/* Convert spaces to non-space character.
* This makes scanf of fields containing spaces easier.
*/
void
bash_spaces(POOL_MEM &pm)
{
char *str = pm.c_str();
while (*str) {
if (*str == ' ')
*str = 0x1;
str++;
}
}
/* Convert non-space characters (0x1) back into spaces */
void
unbash_spaces(POOL_MEM &pm)
{
char *str = pm.c_str();
while (*str) {
if (*str == 0x1)
*str = ' ';
str++;
}
}
/*
* Send current file list to FD
* DIR -> FD : accurate files=xxxx
* DIR -> FD : /path/to/file\0Lstat
* DIR -> FD : /path/to/dir/\0Lstat
* ...
* DIR -> FD : EOD
*/
bool send_accurate_current_files(JCR *jcr)
{
POOL_MEM buf;
if (!jcr->accurate || job_canceled(jcr) || jcr->get_JobLevel()==L_FULL) {
return true;
}
POOLMEM *jobids = get_pool_memory(PM_FNAME);
db_accurate_get_jobids(jcr, jcr->db, &jcr->jr, jobids);
if (*jobids == 0) {
free_pool_memory(jobids);
Jmsg(jcr, M_FATAL, 0, _("Cannot find previous jobids.\n"));
return false;
}
Jmsg(jcr, M_INFO, 0, _("Sending Accurate information.\n"));
/* to be able to allocate the right size for htable */
POOLMEM *nb = get_pool_memory(PM_FNAME);
*nb = 0; /* clear buffer */
Mmsg(buf, "SELECT sum(JobFiles) FROM Job WHERE JobId IN (%s)",jobids);
db_sql_query(jcr->db, buf.c_str(), db_get_int_handler, nb);
Dmsg2(200, "jobids=%s nb=%s\n", jobids, nb);
jcr->file_bsock->fsend("accurate files=%s\n", nb);
if (!db_open_batch_connexion(jcr, jcr->db)) {
Jmsg0(jcr, M_FATAL, 0, "Can't get dedicate sql connexion");
return false;
}
db_get_file_list(jcr, jcr->db_batch, jobids, accurate_list_handler, (void *)jcr);
/* TODO: close the batch connexion ? (can be used very soon) */
free_pool_memory(jobids);
free_pool_memory(nb);
jcr->file_bsock->signal(BNET_EOD);
return true;
}
void OUTPUT_FORMATTER::object_key_value(const char *key, const char *key_fmt,
uint64_t value, const char *value_fmt)
{
POOL_MEM string;
switch (api) {
#if HAVE_JANSSON
case API_MODE_JSON:
json_key_value_add(key, value);
break;
#endif
default:
if (key_fmt) {
string.bsprintf(key_fmt, key);
result_message_plain->strcat(string);
}
if (value_fmt) {
string.bsprintf(value_fmt, value);
result_message_plain->strcat(string);
}
}
}
/*
* Edit codes into (Un)MountCommand
* %% = %
* %a = archive device name
* %m = mount point
*
* omsg = edited output message
* imsg = input string containing edit codes (%x)
*
*/
void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
{
const char *p;
const char *str;
char add[20];
POOL_MEM archive_name(PM_FNAME);
omsg.c_str()[0] = 0;
Dmsg1(800, "edit_mount_codes: %s\n", imsg);
for (p=imsg; *p; p++) {
if (*p == '%') {
switch (*++p) {
case '%':
str = "%";
break;
case 'a':
str = dev_name;
break;
case 'm':
str = device->mount_point;
break;
default:
add[0] = '%';
add[1] = *p;
add[2] = 0;
str = add;
break;
}
} else {
add[0] = *p;
add[1] = 0;
str = add;
}
Dmsg1(1900, "add_str %s\n", str);
pm_strcat(omsg, (char *)str);
Dmsg1(1800, "omsg=%s\n", omsg.c_str());
}
}
static void make_unique_restore_filename(UAContext *ua, POOL_MEM &fname)
{
JCR *jcr = ua->jcr;
int i = find_arg_with_value(ua, "bootstrap");
if (i >= 0) {
Mmsg(fname, "%s", ua->argv[i]);
jcr->unlink_bsr = false;
} else {
P(mutex);
uniq++;
V(mutex);
Mmsg(fname, "%s/%s.restore.%u.bsr", working_directory, my_name, uniq);
jcr->unlink_bsr = true;
}
if (jcr->RestoreBootstrap) {
free(jcr->RestoreBootstrap);
}
jcr->RestoreBootstrap = bstrdup(fname.c_str());
}
bool CONFIG::get_path_of_new_resource(POOL_MEM &path, POOL_MEM &extramsg, const char *component,
const char *resourcetype, const char *name,
bool error_if_exists, bool create_directories)
{
POOL_MEM rel_path(PM_FNAME);
POOL_MEM directory(PM_FNAME);
POOL_MEM resourcetype_lowercase(resourcetype);
resourcetype_lowercase.toLower();
if (!get_path_of_resource(path, component, resourcetype, name, false)) {
return false;
}
path_get_directory(directory, path);
if (create_directories) {
path_create(directory);
}
if (!path_exists(directory)) {
extramsg.bsprintf("Resource config directory \"%s\" does not exist.\n", directory.c_str());
return false;
}
/*
* Store name for temporary file in extramsg.
* Can be used, if result is true.
* Otherwise it contains an error message.
*/
extramsg.bsprintf("%s.tmp", path.c_str());
if (!error_if_exists) {
return true;
}
/*
* File should not exists, as it is going to be created.
*/
if (path_exists(path)) {
extramsg.bsprintf("Resource config file \"%s\" already exists.\n", path.c_str());
return false;
}
if (path_exists(extramsg)) {
extramsg.bsprintf("Temporary resource config file \"%s.tmp\" already exists.\n", path.c_str());
return false;
}
return true;
}
bool CONFIG::get_config_file(POOL_MEM &full_path, const char *config_dir, const char *config_filename)
{
bool found = false;
if (!path_is_directory(config_dir)) {
return false;
}
if (config_filename) {
full_path.strcpy(config_dir);
if (path_append(full_path, config_filename)) {
if (path_exists(full_path)) {
m_config_dir = bstrdup(config_dir);
found = true;
}
}
}
return found;
}
bool CONFIG::get_path_of_resource(POOL_MEM &path, const char *component,
const char *resourcetype, const char *name, bool set_wildcards)
{
POOL_MEM rel_path(PM_FNAME);
POOL_MEM directory(PM_FNAME);
POOL_MEM resourcetype_lowercase(resourcetype);
resourcetype_lowercase.toLower();
if (!component) {
if (m_config_include_dir) {
component = m_config_include_dir;
} else {
return false;
}
}
if (resourcetype_lowercase.strlen() <= 0) {
if (set_wildcards) {
resourcetype_lowercase.strcpy("*");
} else {
return false;
}
}
if (!name) {
if (set_wildcards) {
name = "*";
} else {
return false;
}
}
path.strcpy(m_config_dir);
rel_path.bsprintf(m_config_include_naming_format, component, resourcetype_lowercase.c_str(), name);
path_append(path, rel_path);
return true;
}
static inline bool configure_create_resource_string(UAContext *ua, int first_parameter, RES_TABLE *res_table,
POOL_MEM &resourcename, POOL_MEM &resource)
{
resource.strcat(res_table->name);
resource.strcat(" {\n");
/*
* Is the name of the resource already given as value of the resource type?
* E.g. configure add client=newclient address=127.0.0.1 ...
* instead of configure add client name=newclient address=127.0.0.1 ...
*/
if (ua->argv[first_parameter - 1]) {
resourcename.strcat(ua->argv[first_parameter - 1]);
if (!config_add_directive(ua, res_table, "name", resourcename.c_str(), resource)) {
return false;
}
}
for (int i = first_parameter; i < ua->argc; i++) {
if (!ua->argv[i]) {
ua->error_msg("Missing value for directive \"%s\"\n", ua->argk[i]);
return false;
}
if (bstrcasecmp(ua->argk[i], "name")) {
resourcename.strcat(ua->argv[i]);
}
if (!config_add_directive(ua, res_table, ua->argk[i], ua->argv[i], resource)) {
return false;
}
}
resource.strcat("}\n");
if (strlen(resourcename.c_str()) <= 0) {
ua->error_msg("Resource \"%s\": missing name parameter.\n", res_table->name);
return false;
}
return true;
}
static inline bool config_add_directive(UAContext *ua, RES_TABLE *res_table, const char *key,
const char *value, POOL_MEM &resource, int indent = 2)
{
POOL_MEM temp(PM_MESSAGE);
RES_ITEM *item = NULL;
item = config_get_res_item(ua, res_table, key, value);
if (res_table && (!item)) {
return false;
}
/*
* Use item->name instead of key for uniform formatting.
*/
if (item) {
key = item->name;
}
/* TODO: check type, to see if quotes should be used */
temp.bsprintf("%-*s%s = %s\n", indent, "", key, value);
resource.strcat(temp);
return true;
}
/*
* If full_list is set, we list vertically, otherwise, we
* list on one line horizontally.
* Return number of rows
*/
int list_result(JCR *jcr, B_DB *mdb, OUTPUT_FORMATTER *send, e_list_type type)
{
SQL_FIELD *field;
SQL_ROW row;
int i, col_len, max_len = 0;
int num_fields;
char ewc[30];
POOL_MEM key;
POOL_MEM value;
Dmsg0(800, "list_result starts\n");
if (sql_num_rows(mdb) == 0) {
send->decoration(_("No results to list.\n"));
send->object_end("table");
return sql_num_rows(mdb);
}
num_fields = sql_num_fields(mdb);
switch (type) {
case NF_LIST:
case RAW_LIST:
/*
* No need to calculate things like column widths for
* unformated or raw output.
*/
break;
case HORZ_LIST:
case VERT_LIST:
Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
/*
* Determine column display widths
*/
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result processing field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
col_len = cstrlen(field->name);
if (type == VERT_LIST) {
if (col_len > max_len) {
max_len = col_len;
}
} else {
if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
field->max_length += (field->max_length - 1) / 3;
}
if (col_len < (int)field->max_length) {
col_len = field->max_length;
}
if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
col_len = 4; /* 4 = length of the word "NULL" */
}
field->max_length = col_len; /* reset column info */
}
}
break;
}
Dmsg0(800, "list_result finished first loop\n");
switch (type) {
case NF_LIST:
case RAW_LIST:
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
send->object_start(row[0]);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
value.bsprintf(" %s", "NULL");
} else {
value.bsprintf(" %s", row[i]);
}
send->object_key_value(field->name, value.c_str(), "%s");
}
if (type != RAW_LIST) {
send->decoration("\n");
}
send->object_end(row[0]);
}
break;
case HORZ_LIST:
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
list_dashes(mdb, send);
send->decoration("|");
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result looking at field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
send->decoration(" %-*s |", max_len, field->name);
}
send->decoration("\n");
list_dashes(mdb, send);
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
send->object_start(row[0]);
sql_field_seek(mdb, 0);
send->decoration("|");
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
if (row[i] == NULL) {
value.bsprintf(" %-*s |", max_len, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
value.bsprintf(" %*s |", max_len, add_commas(row[i], ewc));
} else {
value.bsprintf(" %-*s |", max_len, row[i]);
}
if (i == num_fields-1) {
value.strcat("\n");
}
/* use value format string to send preformated value */
send->object_key_value(field->name, row[i], value.c_str());
}
send->object_end(row[0]);
}
list_dashes(mdb, send);
break;
case VERT_LIST:
Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
while ((row = sql_fetch_row(mdb)) != NULL) {
send->object_start(row[0]);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", add_commas(row[i], ewc));
} else {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", row[i]);
}
/* use value format string to send preformated value */
send->object_key_value(field->name, key.c_str(), row[i], value.c_str());
}
send->decoration("\n");
send->object_end(row[0]);
}
break;
}
return sql_num_rows(mdb);
}
int list_result(void *vctx, int nb_col, char **row)
{
SQL_FIELD *field;
int i, col_len, max_len = 0;
int num_fields;
char ewc[30];
POOL_MEM key;
POOL_MEM value;
LIST_CTX *pctx = (LIST_CTX *)vctx;
OUTPUT_FORMATTER *send = pctx->send;
e_list_type type = pctx->type;
B_DB *mdb = pctx->mdb;
JCR *jcr = pctx->jcr;
send->object_start("row");
num_fields = sql_num_fields(mdb);
switch (type) {
case NF_LIST:
case RAW_LIST:
/*
* No need to calculate things like maximum field lenght for
* unformated or raw output.
*/
break;
case HORZ_LIST:
case VERT_LIST:
if (!pctx->once) {
pctx->once = true;
Dmsg1(800, "list_result starts looking at %d fields\n", num_fields);
/*
* Determine column display widths
*/
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result processing field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
col_len = cstrlen(field->name);
if (type == VERT_LIST) {
if (col_len > max_len) {
max_len = col_len;
}
} else {
if (sql_field_is_numeric(mdb, field->type) && (int)field->max_length > 0) { /* fixup for commas */
field->max_length += (field->max_length - 1) / 3;
}
if (col_len < (int)field->max_length) {
col_len = field->max_length;
}
if (col_len < 4 && !sql_field_is_not_null(mdb, field->flags)) {
col_len = 4; /* 4 = length of the word "NULL" */
}
field->max_length = col_len; /* reset column info */
}
}
pctx->num_rows++;
Dmsg0(800, "list_result finished first loop\n");
if (type == VERT_LIST) {
break;
}
Dmsg1(800, "list_result starts second loop looking at %d fields\n", num_fields);
/*
* Keep the result to display the same line at the end of the table
*/
list_dashes(mdb, send);
send->decoration("|");
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
Dmsg1(800, "list_result looking at field %d\n", i);
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
send->decoration(" %-*s |", max_len, field->name);
}
send->decoration("\n");
list_dashes(mdb, send);
}
break;
default:
break;
}
switch (type) {
case NF_LIST:
case RAW_LIST:
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
value.bsprintf(" %s", "NULL");
} else {
value.bsprintf(" %s", row[i]);
}
send->object_key_value(field->name, value.c_str(), "%s");
}
if (type != RAW_LIST) {
send->decoration("\n");
}
break;
case HORZ_LIST:
Dmsg1(800, "list_result starts third loop looking at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
send->decoration("|");
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
max_len = max_length(field->max_length);
if (row[i] == NULL) {
value.bsprintf(" %-*s |", max_len, "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
value.bsprintf(" %*s |", max_len, add_commas(row[i], ewc));
} else {
value.bsprintf(" %-*s |", max_len, row[i]);
}
/*
* Use value format string to send preformated value.
*/
send->object_key_value(field->name, row[i], value.c_str());
}
send->decoration("\n");
break;
case VERT_LIST:
Dmsg1(800, "list_result starts vertical list at %d fields\n", num_fields);
sql_field_seek(mdb, 0);
for (i = 0; i < num_fields; i++) {
field = sql_fetch_field(mdb);
if (!field) {
break;
}
if (row[i] == NULL) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", "NULL");
} else if (sql_field_is_numeric(mdb, field->type) && !jcr->gui && is_an_integer(row[i])) {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", add_commas(row[i], ewc));
} else {
key.bsprintf(" %*s: ", max_len, field->name);
value.bsprintf("%s\n", row[i]);
}
/*
* Use value format string to send preformated value.
*/
send->object_key_value(field->name, key.c_str(), row[i], value.c_str());
}
send->decoration("\n");
break;
default:
break;
}
send->object_end("row");
return 0;
}
int pm_memcpy(POOLMEM *&pm, POOL_MEM &data, int32_t n)
{
pm = check_pool_memory_size(pm, n);
memcpy(pm, data.c_str(), n);
return n;
}
/**
* 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;
}
int pm_memcpy(POOL_MEM &pm, const char *data, int32_t n)
{
pm.check_size(n);
memcpy(pm.c_str(), data, n);
return n;
}
