/*
* Put a volume label into the block
*
* Returns: false on failure
* true on success
*/
static bool write_volume_label_to_block(DCR *dcr)
{
DEVICE *dev = dcr->dev;
DEV_BLOCK *block = dcr->block;
DEV_RECORD rec;
JCR *jcr = dcr->jcr;
Dmsg0(130, "write Label in write_volume_label_to_block()\n");
memset(&rec, 0, sizeof(rec));
rec.data = get_memory(SER_LENGTH_Volume_Label);
empty_block(block); /* Volume label always at beginning */
create_volume_label_record(dcr, dev, &rec);
block->BlockNumber = 0;
if (!write_record_to_block(dcr, &rec)) {
free_pool_memory(rec.data);
Jmsg1(jcr, M_FATAL, 0, _("Cannot write Volume label to block for device %s\n"),
dev->print_name());
return false;
} else {
Dmsg2(130, "Wrote label of %d bytes to block. Vol=%s\n", rec.data_len,
dcr->VolumeName);
}
free_pool_memory(rec.data);
return true;
}
void free_ua_context(UAContext *ua)
{
if (ua->guid) {
free_guid_list(ua->guid);
}
if (ua->cmd) {
free_pool_memory(ua->cmd);
}
if (ua->args) {
free_pool_memory(ua->args);
}
if (ua->errmsg) {
free_pool_memory(ua->errmsg);
}
if (ua->prompt) {
free(ua->prompt);
}
if (ua->send) {
delete ua->send;
}
if (ua->UA_sock) {
ua->UA_sock->close();
ua->UA_sock = NULL;
}
free(ua);
}
void free_attr(ATTR *attr)
{
free_pool_memory(attr->olname);
free_pool_memory(attr->ofname);
free_pool_memory(attr->attrEx);
free(attr);
}
/*
* Free the record entity
*/
void free_record(DEV_RECORD *rec)
{
Dmsg0(950, "Enter free_record.\n");
if (rec->data && rec->own_mempool) {
free_pool_memory(rec->data);
}
Dmsg0(950, "Data buf is freed.\n");
free_pool_memory((POOLMEM *)rec);
Dmsg0(950, "Leave free_record.\n");
}
static void do_extract(char *devname)
{
struct stat statp;
enable_backup_privileges(NULL, 1);
jcr = setup_jcr("bextract", devname, bsr, director, VolumeName, 1); /* acquire for read */
if (!jcr) {
exit(1);
}
dev = jcr->read_dcr->dev;
if (!dev) {
exit(1);
}
dcr = jcr->read_dcr;
/* Make sure where directory exists and that it is a directory */
if (stat(where, &statp) < 0) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Cannot stat %s. It must exist. ERR=%s\n"),
where, be.bstrerror());
}
if (!S_ISDIR(statp.st_mode)) {
Emsg1(M_ERROR_TERM, 0, _("%s must be a directory.\n"), where);
}
free(jcr->where);
jcr->where = bstrdup(where);
attr = new_attr(jcr);
compress_buf = get_memory(compress_buf_size);
acl_data.last_fname = get_pool_memory(PM_FNAME);
xattr_data.last_fname = get_pool_memory(PM_FNAME);
read_records(dcr, record_cb, mount_next_read_volume);
/* If output file is still open, it was the last one in the
* archive since we just hit an end of file, so close the file.
*/
if (is_bopen(&bfd)) {
set_attributes(jcr, attr, &bfd);
}
free_attr(attr);
free_pool_memory(acl_data.last_fname);
free_pool_memory(xattr_data.last_fname);
clean_device(jcr->dcr);
dev->term();
free_dcr(dcr);
free_jcr(jcr);
printf(_("%u files restored.\n"), num_files);
return;
}
bool get_bootstrap_file(JCR *jcr, BSOCK *sock)
{
POOLMEM *fname = get_pool_memory(PM_FNAME);
FILE *bs;
bool ok = false;
if (jcr->RestoreBootstrap) {
unlink(jcr->RestoreBootstrap);
free_pool_memory(jcr->RestoreBootstrap);
}
P(bsr_mutex);
bsr_uniq++;
Mmsg(fname, "%s/%s.%s.%d.bootstrap", me->working_directory, me->hdr.name,
jcr->Job, bsr_uniq);
V(bsr_mutex);
Dmsg1(400, "bootstrap=%s\n", fname);
jcr->RestoreBootstrap = fname;
bs = fopen(fname, "a+b"); /* create file */
if (!bs) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Could not create bootstrap file %s: ERR=%s\n"),
jcr->RestoreBootstrap, be.bstrerror());
goto bail_out;
}
Dmsg0(10, "=== Bootstrap file ===\n");
while (sock->recv() >= 0) {
Dmsg1(10, "%s", sock->msg);
fputs(sock->msg, bs);
}
fclose(bs);
Dmsg0(10, "=== end bootstrap file ===\n");
jcr->bsr = parse_bsr(jcr, jcr->RestoreBootstrap);
if (!jcr->bsr) {
Jmsg(jcr, M_FATAL, 0, _("Error parsing bootstrap file.\n"));
goto bail_out;
}
if (debug_level >= 10) {
dump_bsr(jcr->bsr, true);
}
/* If we got a bootstrap, we are reading, so create read volume list */
create_restore_volume_list(jcr);
ok = true;
bail_out:
unlink(jcr->RestoreBootstrap);
free_pool_memory(jcr->RestoreBootstrap);
jcr->RestoreBootstrap = NULL;
if (!ok) {
sock->fsend(ERROR_bootstrap);
return false;
}
return sock->fsend(OK_bootstrap);
}
void free_runscript(RUNSCRIPT *script)
{
Dmsg0(500, "runscript: freeing RUNSCRIPT object\n");
if (script->command) {
free_pool_memory(script->command);
}
if (script->target) {
free_pool_memory(script->target);
}
free(script);
}
static void crypto_session_end(JCR *jcr)
{
if (jcr->crypto.crypto_buf) {
free_pool_memory(jcr->crypto.crypto_buf);
jcr->crypto.crypto_buf = NULL;
}
if (jcr->crypto.pki_session) {
crypto_session_free(jcr->crypto.pki_session);
}
if (jcr->crypto.pki_session_encoded) {
free_pool_memory(jcr->crypto.pki_session_encoded);
jcr->crypto.pki_session_encoded = NULL;
}
}
/*
* (Un)mount the device (for tape devices)
*/
static bool do_mount(DCR *dcr, int mount, int dotimeout)
{
DEVRES *device = dcr->dev->device;
POOL_MEM ocmd(PM_FNAME);
POOLMEM *results;
char *icmd;
int status, tries;
berrno be;
Dsm_check(200);
if (mount) {
icmd = device->mount_command;
} else {
icmd = device->unmount_command;
}
dcr->dev->edit_mount_codes(ocmd, icmd);
Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), dcr->dev->is_mounted());
if (dotimeout) {
/* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
tries = 10;
} else {
tries = 1;
}
results = get_memory(4000);
/* If busy retry each second */
Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
while ((status = run_program_full_output(ocmd.c_str(), dcr->dev->max_open_wait / 2, results)) != 0) {
if (tries-- > 0) {
continue;
}
Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", dcr->dev->print_name(),
(mount ? "" : "un"), status, results, be.bstrerror(status));
Mmsg(dcr->dev->errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
dcr->dev->print_name(), (mount ? "" : "un"), be.bstrerror(status));
free_pool_memory(results);
Dmsg0(200, "============ mount=0\n");
Dsm_check(200);
return false;
}
free_pool_memory(results);
Dmsg1(200, "============ mount=%d\n", mount);
return true;
}
void bmsg(UAContext *ua, const char *fmt, va_list arg_ptr)
{
BSOCK *bs = ua->UA_sock;
int maxlen, len;
POOLMEM *msg = NULL;
va_list ap;
if (bs) {
msg = bs->msg;
}
if (!msg) {
msg = get_pool_memory(PM_EMSG);
}
again:
maxlen = sizeof_pool_memory(msg) - 1;
va_copy(ap, arg_ptr);
len = bvsnprintf(msg, maxlen, fmt, ap);
va_end(ap);
if (len < 0 || len >= maxlen) {
msg = realloc_pool_memory(msg, maxlen + maxlen/2);
goto again;
}
if (bs) {
bs->msg = msg;
bs->msglen = len;
bs->send();
} else { /* No UA, send to Job */
Jmsg(ua->jcr, M_INFO, 0, "%s", msg);
free_pool_memory(msg);
}
}
/*
* This routine will purge (delete) all records
* associated with a particular Volume. It will
* not delete the media record itself.
* TODO: This function is broken and it doesn't purge
* File, BaseFiles, Log, ...
* We call it from relabel and delete volume=, both ensure
* that the volume is properly purged.
*/
static int do_media_purge(B_DB *mdb, MEDIA_DBR *mr)
{
POOLMEM *query = get_pool_memory(PM_MESSAGE);
struct s_del_ctx del;
char ed1[50];
int i;
del.num_ids = 0;
del.tot_ids = 0;
del.num_del = 0;
del.max_ids = 0;
Mmsg(mdb->cmd, "SELECT JobId from JobMedia WHERE MediaId=%d", mr->MediaId);
del.max_ids = mr->VolJobs;
if (del.max_ids < 100) {
del.max_ids = 100;
} else if (del.max_ids > MAX_DEL_LIST_LEN) {
del.max_ids = MAX_DEL_LIST_LEN;
}
del.JobId = (JobId_t *)malloc(sizeof(JobId_t) * del.max_ids);
db_sql_query(mdb, mdb->cmd, delete_handler, (void *)&del);
for (i=0; i < del.num_ids; i++) {
Dmsg1(400, "Delete JobId=%d\n", del.JobId[i]);
Mmsg(query, "DELETE FROM Job WHERE JobId=%s", edit_int64(del.JobId[i], ed1));
db_sql_query(mdb, query);
Mmsg(query, "DELETE FROM File WHERE JobId=%s", edit_int64(del.JobId[i], ed1));
db_sql_query(mdb, query);
Mmsg(query, "DELETE FROM JobMedia WHERE JobId=%s", edit_int64(del.JobId[i], ed1));
db_sql_query(mdb, query);
}
free(del.JobId);
free_pool_memory(query);
return 1;
}
/*
* Free memory allocated for the device
*/
void DEVICE::term(void)
{
DEVICE *dev = NULL;
Dmsg1(900, "term dev: %s\n", print_name());
close();
if (dev_name) {
free_memory(dev_name);
dev_name = NULL;
}
if (prt_name) {
free_memory(prt_name);
prt_name = NULL;
}
if (errmsg) {
free_pool_memory(errmsg);
errmsg = NULL;
}
pthread_mutex_destroy(&m_mutex);
pthread_cond_destroy(&wait);
pthread_cond_destroy(&wait_next_vol);
pthread_mutex_destroy(&spool_mutex);
pthread_mutex_destroy(&freespace_mutex);
if (attached_dcrs) {
delete attached_dcrs;
attached_dcrs = NULL;
}
/* We let the DEVRES pointer if not our device */
if (device && device->dev == this) {
device->dev = NULL;
}
delete this;
if (dev) {
dev->term();
}
}
/* Dump the item table content to a text file (used by director) */
int ConfigFile::dump_results(POOLMEM **buf)
{
int len;
POOLMEM *tmp;
if (!items) {
**buf = 0;
return 0;
}
len = Mmsg(buf, "# Plugin configuration file\n# Version %d\n", version);
tmp = get_pool_memory(PM_MESSAGE);
for (int i = 0; items[i].name; i++) {
if (items[i].found) {
items[i].handler(NULL, this, &items[i]);
if (items[i].comment && *items[i].comment) {
Mmsg(tmp, "# %s\n", items[i].comment);
pm_strcat(buf, tmp);
}
Mmsg(tmp, "%s=%s\n\n", items[i].name, this->edit);
len = pm_strcat(buf, tmp);
}
}
free_pool_memory(tmp);
return len ;
}
/* Dump the item table format to a text file (used by plugin) */
bool ConfigFile::serialize(const char *fname)
{
FILE *fp;
POOLMEM *tmp;
int32_t len;
bool ret = false;
if (!items) {
return ret;
}
fp = fopen(fname, "w");
if (!fp) {
return ret;
}
tmp = get_pool_memory(PM_MESSAGE);
len = serialize(&tmp);
if (fwrite(tmp, len, 1, fp) == 1) {
ret = true;
}
free_pool_memory(tmp);
fclose(fp);
return ret;
}
/*
* Save current working directory.
* Returns: true if OK
* false if failed
*/
bool saveCWD::save(JCR *jcr)
{
release(); /* clean up */
if (!fchdir_failed) {
m_fd = open(".", O_RDONLY);
if (m_fd < 0) {
berrno be;
Jmsg1(jcr, M_ERROR, 0, _("Cannot open current directory: ERR=%s\n"), be.bstrerror());
m_saved = false;
return false;
}
}
if (fchdir_failed) {
POOLMEM *buf = get_memory(5000);
m_cwd = (POOLMEM *)getcwd(buf, sizeof_pool_memory(buf));
if (m_cwd == NULL) {
berrno be;
Jmsg1(jcr, M_ERROR, 0, _("Cannot get current directory: ERR=%s\n"), be.bstrerror());
free_pool_memory(buf);
m_saved = false;
return false;
}
}
m_saved = true;
return true;
}
void bmsg(UAContext *ua, const char *fmt, va_list arg_ptr)
{
BSOCK *bs = ua->UA_sock;
int maxlen, len;
POOLMEM *msg = NULL;
if (bs) {
msg = bs->msg;
}
if (!msg) {
msg = get_memory(5000);
}
maxlen = sizeof_pool_memory(msg) - 1;
if (maxlen < 4999) {
msg = realloc_pool_memory(msg, 5000);
maxlen = 4999;
}
len = bvsnprintf(msg, maxlen, fmt, arg_ptr);
if (len < 0 || len >= maxlen) {
pm_strcpy(msg, _("Message too long to display.\n"));
len = strlen(msg);
}
if (bs) {
bs->msg = msg;
bs->msglen = len;
bs->send();
} else { /* No UA, send to Job */
Jmsg(ua->jcr, M_INFO, 0, "%s", msg);
free_pool_memory(msg);
}
}
/*
* Restore previous working directory.
* Returns: true if OK
* false if failed
*/
bool saveCWD::restore(JCR *jcr)
{
if (!m_saved) {
return true;
}
m_saved = false;
if (m_fd >= 0) {
if (fchdir(m_fd) != 0) {
berrno be;
Jmsg1(jcr, M_ERROR, 0, _("Cannot reset current directory: ERR=%s\n"), be.bstrerror());
close(m_fd);
m_fd = -1;
fchdir_failed = true;
chdir("/"); /* punt */
return false;
}
return true;
}
if (chdir(m_cwd) < 0) {
berrno be;
Jmsg1(jcr, M_ERROR, 0, _("Cannot reset current directory: ERR=%s\n"), be.bstrerror());
chdir("/");
free_pool_memory(m_cwd);
m_cwd = NULL;
return false;
}
return true;
}
/*
* Delete the pid file if we created it
*/
int delete_pid_file(char *dir, const char *progname, int port)
{
#if !defined(HAVE_WIN32)
POOLMEM *fname = get_pool_memory(PM_FNAME);
if (!del_pid_file_ok) {
free_pool_memory(fname);
return 0;
}
del_pid_file_ok = FALSE;
Mmsg(&fname, "%s/%s.%d.pid", dir, progname, port);
unlink(fname);
free_pool_memory(fname);
#endif
return 1;
}
/*
* Update pool record -- pull info from current POOL resource
*/
static bool update_pool(UAContext *ua)
{
POOL_DBR pr;
int id;
POOL *pool;
POOLMEM *query;
char ed1[50];
pool = get_pool_resource(ua);
if (!pool) {
return false;
}
memset(&pr, 0, sizeof(pr));
bstrncpy(pr.Name, pool->name(), sizeof(pr.Name));
if (!get_pool_dbr(ua, &pr)) {
return false;
}
set_pooldbr_from_poolres(&pr, pool, POOL_OP_UPDATE); /* update */
set_pooldbr_references(ua->jcr, ua->db, &pr, pool);
id = db_update_pool_record(ua->jcr, ua->db, &pr);
if (id <= 0) {
ua->error_msg(_("db_update_pool_record returned %d. ERR=%s\n"),
id, db_strerror(ua->db));
}
query = get_pool_memory(PM_MESSAGE);
Mmsg(query, list_pool, edit_int64(pr.PoolId, ed1));
db_list_sql_query(ua->jcr, ua->db, query, prtit, ua, 1, HORZ_LIST);
free_pool_memory(query);
ua->info_msg(_("Pool DB record updated from resource.\n"));
return true;
}
static bool close_attr_spool_file(JCR *jcr, BSOCK *bs)
{
POOLMEM *name;
char tbuf[MAX_TIME_LENGTH];
Dmsg1(100, "Close attr spool file at %s\n", bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL)));
if (bs->m_spool_fd == -1) {
return true;
}
name = get_pool_memory(PM_MESSAGE);
P(mutex);
spool_stats.attr_jobs--;
spool_stats.total_attr_jobs++;
V(mutex);
make_unique_spool_filename(jcr, &name, bs->m_fd);
close(bs->m_spool_fd);
unlink(name);
free_pool_memory(name);
bs->m_spool_fd = -1;
bs->clear_spooling();
return true;
}
static bool close_data_spool_file(DCR *dcr)
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
P(mutex);
spool_stats.data_jobs--;
spool_stats.total_data_jobs++;
if (spool_stats.data_size < dcr->job_spool_size) {
spool_stats.data_size = 0;
} else {
spool_stats.data_size -= dcr->job_spool_size;
}
V(mutex);
P(dcr->dev->spool_mutex);
dcr->job_spool_size = 0;
V(dcr->dev->spool_mutex);
make_unique_data_spool_filename(dcr, &name);
close(dcr->spool_fd);
dcr->spool_fd = -1;
dcr->spooling = false;
unlink(name);
Dmsg1(100, "Deleted spool file: %s\n", name);
free_pool_memory(name);
return true;
}
int encode_attribsEx(JCR *jcr, char *attribsEx, FF_PKT *ff_pkt)
{
char *p = attribsEx;
WIN32_FILE_ATTRIBUTE_DATA atts;
ULARGE_INTEGER li;
attribsEx[0] = 0; /* no extended attributes */
if (jcr->cmd_plugin || ff_pkt->type == FT_DELETED) {
return STREAM_UNIX_ATTRIBUTES;
}
unix_name_to_win32(&ff_pkt->sys_fname, ff_pkt->fname);
/** try unicode version */
if (p_GetFileAttributesExW) {
POOLMEM* pwszBuf = get_pool_memory(PM_FNAME);
make_win32_path_UTF8_2_wchar(&pwszBuf, ff_pkt->fname);
BOOL b=p_GetFileAttributesExW((LPCWSTR)pwszBuf, GetFileExInfoStandard,
(LPVOID)&atts);
free_pool_memory(pwszBuf);
if (!b) {
win_error(jcr, "GetFileAttributesExW:", ff_pkt->sys_fname);
return STREAM_UNIX_ATTRIBUTES;
}
}
else {
if (!p_GetFileAttributesExA)
return STREAM_UNIX_ATTRIBUTES;
if (!p_GetFileAttributesExA(ff_pkt->sys_fname, GetFileExInfoStandard,
(LPVOID)&atts)) {
win_error(jcr, "GetFileAttributesExA:", ff_pkt->sys_fname);
return STREAM_UNIX_ATTRIBUTES;
}
}
p += to_base64((uint64_t)atts.dwFileAttributes, p);
*p++ = ' '; /* separate fields with a space */
li.LowPart = atts.ftCreationTime.dwLowDateTime;
li.HighPart = atts.ftCreationTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
li.LowPart = atts.ftLastAccessTime.dwLowDateTime;
li.HighPart = atts.ftLastAccessTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
li.LowPart = atts.ftLastWriteTime.dwLowDateTime;
li.HighPart = atts.ftLastWriteTime.dwHighDateTime;
p += to_base64((uint64_t)li.QuadPart, p);
*p++ = ' ';
p += to_base64((uint64_t)atts.nFileSizeHigh, p);
*p++ = ' ';
p += to_base64((uint64_t)atts.nFileSizeLow, p);
*p = 0;
return STREAM_UNIX_ATTRIBUTES_EX;
}
bool RUNSCRIPT::run(JCR *jcr, const char *name)
{
Dmsg1(100, "runscript: running a RUNSCRIPT object type=%d\n", cmd_type);
POOLMEM *ecmd = get_pool_memory(PM_FNAME);
int status;
BPIPE *bpipe;
POOL_MEM line(PM_NAME);
ecmd = edit_job_codes(jcr, ecmd, this->command, "", this->job_code_callback);
Dmsg1(100, "runscript: running '%s'...\n", ecmd);
Jmsg(jcr, M_INFO, 0, _("%s: run %s \"%s\"\n"),
cmd_type==SHELL_CMD?"shell command":"console command", name, ecmd);
switch (cmd_type) {
case SHELL_CMD:
bpipe = open_bpipe(ecmd, 0, "r");
free_pool_memory(ecmd);
if (bpipe == NULL) {
berrno be;
Jmsg(jcr, M_ERROR, 0, _("Runscript: %s could not execute. ERR=%s\n"), name,
be.bstrerror());
goto bail_out;
}
while (fgets(line.c_str(), line.size(), bpipe->rfd)) {
strip_trailing_junk(line.c_str());
Jmsg(jcr, M_INFO, 0, _("%s: %s\n"), name, line.c_str());
}
status = close_bpipe(bpipe);
if (status != 0) {
berrno be;
Jmsg(jcr, M_ERROR, 0, _("Runscript: %s returned non-zero status=%d. ERR=%s\n"), name,
be.code(status), be.bstrerror(status));
goto bail_out;
}
Dmsg0(100, "runscript OK\n");
break;
case CONSOLE_CMD:
if (console_command) { /* can we run console command? */
if (!console_command(jcr, ecmd)) { /* yes, do so */
goto bail_out;
}
}
break;
}
return true;
bail_out:
/* cancel running job properly */
if (fail_on_error) {
jcr->setJobStatus(JS_ErrorTerminated);
}
Dmsg1(100, "runscript failed. fail_on_error=%d\n", fail_on_error);
return false;
}
void RUNSCRIPT::reset_default(bool free_strings)
{
if (free_strings && command) {
free_pool_memory(command);
}
if (free_strings && target) {
free_pool_memory(target);
}
target = NULL;
command = NULL;
on_success = true;
on_failure = false;
fail_on_error = true;
when = SCRIPT_Never;
job_code_callback = NULL;
}
void write_crypto_cache(const char *dir, const char *progname, int port)
{
POOLMEM *fname = get_pool_memory(PM_FNAME);
Mmsg(&fname, "%s/%s.%d.cryptoc", dir, progname, port);
write_crypto_cache(fname);
free_pool_memory(fname);
}
void RUNSCRIPT::reset_default(bool free_strings)
{
if (free_strings && command) {
free_pool_memory(command);
}
if (free_strings && target) {
free_pool_memory(target);
}
target = NULL;
command = NULL;
on_success = true;
on_failure = false;
fail_on_error = true;
when = SCRIPT_Never;
old_proto = false; /* TODO: drop this with bacula 1.42 */
job_code_callback = NULL;
}
/*
* Free a plugin instance, i.e. release our private storage
*/
static bRC freePlugin(bpContext *ctx)
{
plugin_ctx *p_ctx = (plugin_ctx *)ctx->pContext;
if (!p_ctx) {
return bRC_Error;
}
Dmsg(ctx, dbglvl, "cephfs-fd: entering freePlugin\n");
if (p_ctx->path_list) {
free_path_list(p_ctx->path_list);
p_ctx->path_list = NULL;
}
if (p_ctx->dir_stack) {
p_ctx->dir_stack->destroy();
delete p_ctx->dir_stack;
}
if (p_ctx->cmount) {
ceph_shutdown(p_ctx->cmount);
p_ctx->cmount = NULL;
}
free_pool_memory(p_ctx->xattr_list);
free_pool_memory(p_ctx->link_target);
free_pool_memory(p_ctx->next_filename);
free_pool_memory(p_ctx->cwd);
if (p_ctx->conffile) {
free(p_ctx->conffile);
}
if (p_ctx->plugin_options) {
free(p_ctx->plugin_options);
}
free(p_ctx);
p_ctx = NULL;
Dmsg(ctx, dbglvl, "cephfs-fd: leaving freePlugin\n");
return bRC_OK;
}
bool open_attr_spool_file(JCR *jcr, BSOCK *bs)
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
make_unique_spool_filename(jcr, &name, bs->m_fd);
bs->m_spool_fd = fopen(name, "w+b");
if (!bs->m_spool_fd) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("fopen attr spool file %s failed: ERR=%s\n"), name,
be.bstrerror());
free_pool_memory(name);
return false;
}
P(mutex);
spool_stats.attr_jobs++;
V(mutex);
free_pool_memory(name);
return true;
}
/*
* 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;
}
static bool open_data_spool_file(DCR *dcr)
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
int spool_fd;
make_unique_data_spool_filename(dcr, &name);
if ((spool_fd = open(name, O_CREAT | O_TRUNC | O_RDWR | O_BINARY, 0640)) >= 0) {
dcr->spool_fd = spool_fd;
dcr->jcr->spool_attributes = true;
} else {
berrno be;
Jmsg(dcr->jcr, M_FATAL, 0, _("Open data spool file %s failed: ERR=%s\n"), name, be.bstrerror());
free_pool_memory(name);
return false;
}
Dmsg1(100, "Created spool file: %s\n", name);
free_pool_memory(name);
return true;
}
