// Constructor
VSSClient::VSSClient()
{
memset(this, 0, sizeof(VSSClient));
m_pAlistWriterState = New(alist(10, not_owned_by_alist));
m_pAlistWriterInfoText = New(alist(10, owned_by_alist));
m_uidCurrentSnapshotSet = GUID_NULL;
}
/*
* Store a resource pointer in an alist. default_value indicates how many
* times this routine can be called -- i.e. how many alists
* there are.
*
* If we are in pass 2, do a lookup of the resource.
*/
static void store_alist_res(LEX *lc, RES_ITEM *item, int index, int pass)
{
RES *res;
int i = 0;
alist *list;
URES *res_all = (URES *)my_config->m_res_all;
int count = str_to_int32(item->default_value);
if (pass == 2) {
if (count == 0) { /* always store in item->value */
i = 0;
if ((item->value)[i] == NULL) {
list = New(alist(10, not_owned_by_alist));
} else {
list = (alist *)(item->value)[i];
}
} else {
/*
* Find empty place to store this directive
*/
while ((item->value)[i] != NULL && i++ < count) { }
if (i >= count) {
scan_err4(lc, _("Too many %s directives. Max. is %d. line %d: %s\n"),
lc->str, count, lc->line_no, lc->line);
return;
}
list = New(alist(10, not_owned_by_alist));
}
for (;;) {
lex_get_token(lc, T_NAME); /* scan next item */
res = GetResWithName(item->code, lc->str);
if (res == NULL) {
scan_err3(lc, _("Could not find config Resource \"%s\" referenced on line %d : %s\n"),
item->name, lc->line_no, lc->line);
return;
}
Dmsg5(900, "Append %p to alist %p size=%d i=%d %s\n",
res, list, list->size(), i, item->name);
list->append(res);
(item->value)[i] = (char *)list;
if (lc->ch != ',') { /* if no other item follows */
break; /* get out */
}
lex_get_token(lc, T_ALL); /* eat comma */
}
}
scan_to_eol(lc);
set_bit(index, res_all->hdr.item_present);
}
// Constructor
VSSClient::VSSClient()
{
m_bCoInitializeCalled = false;
m_bCoInitializeSecurityCalled = false;
m_dwContext = 0; // VSS_CTX_BACKUP;
m_bDuringRestore = false;
m_bBackupIsInitialized = false;
m_pVssObject = NULL;
m_pAlistWriterState = New(alist(10, not_owned_by_alist));
m_pAlistWriterInfoText = New(alist(10, owned_by_alist));
m_uidCurrentSnapshotSet = GUID_NULL;
memset(m_wszUniqueVolumeName, 0, sizeof(m_wszUniqueVolumeName));
memset(m_szShadowCopyName, 0, sizeof(m_szShadowCopyName));
}
void justine::robocar::Traffic::toGPS ( osmium::unsigned_object_id_type from,
osmium::unsigned_object_id_type to,
osmium::unsigned_object_id_type step, double *lo, double *la ) const
{
shm_map_Type::iterator iter1=shm_map->find ( from );
double lon1 {iter1->second.lon/10000000.0}, lat1 {iter1->second.lat/10000000.0};
shm_map_Type::iterator iter2=shm_map->find ( alist ( from, to ) );
double lon2 {iter2->second.lon/10000000.0}, lat2 {iter2->second.lat/10000000.0};
osmium::unsigned_object_id_type maxstep = palist ( from, to );
if ( maxstep == 0 )
{
maxstep = 1;
}
lat1 += step * ( ( lat2 - lat1 ) / maxstep );
lon1 += step * ( ( lon2 - lon1 ) / maxstep );
*lo = lon1;
*la = lat1;
}
bool
ControlSet::find_next_event (FrameTime now, FrameTime end, ControlEvent& next_event) const
{
Controls::const_iterator li;
next_event.when = std::numeric_limits<FrameTime>::max();
for (li = _controls.begin(); li != _controls.end(); ++li) {
ControlList::const_iterator i;
boost::shared_ptr<const ControlList> alist (li->second->list());
ControlEvent cp (now, 0.0f);
for (i = lower_bound (alist->begin(), alist->end(), &cp, ControlList::time_comparator);
i != alist->end() && (*i)->when < end; ++i) {
if ((*i)->when > now) {
break;
}
}
if (i != alist->end() && (*i)->when < end) {
if ((*i)->when < next_event.when) {
next_event.when = (*i)->when;
}
}
}
return next_event.when != std::numeric_limits<FrameTime>::max();
}
void cp_compute_consumption(ClassAd& job, ClassAd& resource, consumption_map_t& consumption) {
consumption.clear();
string mrv;
if (!resource.LookupString(ATTR_MACHINE_RESOURCES, mrv)) {
EXCEPT("Resource ad missing %s attribute", ATTR_MACHINE_RESOURCES);
}
StringList alist(mrv.c_str());
alist.rewind();
while (char* asset = alist.next()) {
if (MATCH == strcasecmp(asset, "swap")) continue;
string ra;
string coa;
formatstr(ra, "%s%s", ATTR_REQUEST_PREFIX, asset);
formatstr(coa, "_condor_%s", ra.c_str());
bool override = false;
double ov=0;
if (job.EvalFloat(coa.c_str(), NULL, ov)) {
// Allow _condor_RequestedXXX to override RequestedXXX
// this case is intended to be operative when a scheduler has set
// such values and sent them on to the startd that owns this resource
// (e.g. I'd not expect this case to arise elsewhere, like the negotiator)
string ta;
formatstr(ta, "_cp_temp_%s", ra.c_str());
job.CopyAttribute(ta.c_str(), ra.c_str());
job.Assign(ra.c_str(), ov);
override = true;
}
bool cp_supports_policy(ClassAd& resource, bool strict) {
// currently, only p-slots can support a functional consumption policy
if (strict) {
bool part = false;
if (!resource.LookupBool(ATTR_SLOT_PARTITIONABLE, part)) part = false;
if (!part) return false;
}
// must support MachineResources attribute
string mrv;
if (!resource.LookupString(ATTR_MACHINE_RESOURCES, mrv)) return false;
// must define ConsumptionXxx for all resources Xxx (including extensible resources)
StringList alist(mrv.c_str());
alist.rewind();
while (char* asset = alist.next()) {
if (MATCH == strcasecmp(asset, "swap")) continue;
string ca;
formatstr(ca, "%s%s", ATTR_CONSUMPTION_PREFIX, asset);
ClassAd::iterator f(resource.find(ca));
if (f == resource.end()) return false;
}
return true;
}
TEST_F(SHAPE, Moves)
{
std::vector<ade::DimT> junk = {8, 51, 73};
std::vector<ade::DimT> slist = {24, 11, 12, 16};
ade::Shape mvassign;
ade::Shape mvassign2(junk);
ade::Shape orig(slist);
ade::Shape mv(std::move(orig));
std::vector<ade::DimT> mlist(mv.begin(), mv.end());
EXPECT_ARREQ(slist, mlist);
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
EXPECT_EQ(1, orig.at(i));
}
mvassign = std::move(mv);
std::vector<ade::DimT> alist(mvassign.begin(), mvassign.end());
EXPECT_ARREQ(slist, alist);
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
EXPECT_EQ(1, mv.at(i));
}
mvassign2 = std::move(mvassign);
std::vector<ade::DimT> alist2(mvassign2.begin(), mvassign2.end());
EXPECT_ARREQ(slist, alist2);
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
EXPECT_EQ(1, mvassign.at(i));
}
}
static bool ini_store_alist_str(LEX *lc, ConfigFile *inifile, ini_items *item)
{
alist *list;
if (!lc) {
/*
* TODO, write back the alist to edit buffer
*/
return true;
}
if (lex_get_token(lc, T_STRING) == T_ERROR) {
return false;
}
if (item->val.alistval == NULL) {
list = New(alist(10, owned_by_alist));
} else {
list = item->val.alistval;
}
Dmsg4(900, "Append %s to alist %p size=%d %s\n",
lc->str, list, list->size(), item->name);
list->append(bstrdup(lc->str));
item->val.alistval = list;
scan_to_eol(lc);
return true;
}
PendingUpdateList UInsertAsLast::createUpdateList(DynamicContext *context) const
{
Node::Ptr node = (Node*)target_->createResult(context)->next(context).get();
if(node->dmNodeKind() != Node::element_string &&
node->dmNodeKind() != Node::document_string)
XQThrow(XPath2TypeMatchException,X("UInsertAsLast::createUpdateList"),
X("It is a type error for the target expression of an insert as last expression not to be a single element "
"or document [err:XUTY0005]"));
Sequence alist(context->getMemoryManager());
Sequence clist(context->getMemoryManager());
Result value = source_->createResult(context);
Item::Ptr item;
while((item = value->next(context)).notNull()) {
if(((Node*)item.get())->dmNodeKind() == Node::attribute_string) {
if(!clist.isEmpty())
XQThrow(ASTException,X("UInsertAsLast::createUpdateList"),
X("Attribute nodes must occur before other nodes in the source expression for an insert as last expression [err:XUTY0004]"));
// b. No attribute node in $alist may have a QName whose implied namespace binding conflicts with a namespace
// binding in the "namespaces" property of $target [err:XUDY0023].
ATQNameOrDerived::Ptr qname = ((Node*)item.get())->dmNodeName(context);
if(qname->getURI() != 0 && *(qname->getURI()) != 0) {
ATAnyURIOrDerived::Ptr uri = FunctionNamespaceURIForPrefix::uriForPrefix(qname->getPrefix(), node, context, this);
if(uri.notNull() && !XPath2Utils::equals(uri->asString(context), qname->getURI())) {
XMLBuffer buf;
buf.append(X("Implied namespace binding for the insert as last expression (\""));
buf.append(qname->getPrefix());
buf.append(X("\" -> \""));
buf.append(qname->getURI());
buf.append(X("\") conflicts with those already existing on the parent element of the target attribute [err:XUDY0023]"));
XQThrow3(DynamicErrorException, X("UInsertInto::createUpdateList"), buf.getRawBuffer(), this);
}
}
alist.addItem(item);
}
else
clist.addItem(item);
}
PendingUpdateList result;
if(!alist.isEmpty()) {
// 3. If $alist is not empty and into is specified, the following checks are performed:
// a. $target must be an element node [err:XUTY0022].
if(node->dmNodeKind() == Node::document_string)
XQThrow(XPath2TypeMatchException,X("UInsertInto::createUpdateList"),
X("It is a type error if an insert expression specifies the insertion of an attribute node into a document node [err:XUTY0022]"));
result.addUpdate(PendingUpdate(PendingUpdate::INSERT_ATTRIBUTES, node, alist, this));
}
if(!clist.isEmpty()) {
result.addUpdate(PendingUpdate(PendingUpdate::INSERT_INTO_AS_LAST, node, clist, this));
}
return result;
}
void factor_vm::primitive_modify_code_heap()
{
bool reset_inline_caches = to_boolean(ctx->pop());
bool update_existing_words = to_boolean(ctx->pop());
data_root<array> alist(ctx->pop(),this);
cell count = array_capacity(alist.untagged());
if(count == 0)
return;
for(cell i = 0; i < count; i++)
{
data_root<array> pair(array_nth(alist.untagged(),i),this);
data_root<word> word(array_nth(pair.untagged(),0),this);
data_root<object> data(array_nth(pair.untagged(),1),this);
switch(data.type())
{
case QUOTATION_TYPE:
jit_compile_word(word.value(),data.value(),false);
break;
case ARRAY_TYPE:
{
array *compiled_data = data.as<array>().untagged();
cell parameters = array_nth(compiled_data,0);
cell literals = array_nth(compiled_data,1);
cell relocation = array_nth(compiled_data,2);
cell labels = array_nth(compiled_data,3);
cell code = array_nth(compiled_data,4);
code_block *compiled = add_code_block(
code_block_optimized,
code,
labels,
word.value(),
relocation,
parameters,
literals);
word->code = compiled;
}
break;
default:
critical_error("Expected a quotation or an array",data.value());
break;
}
update_word_entry_point(word.untagged());
}
if(update_existing_words)
update_code_heap_words(reset_inline_caches);
else
initialize_code_blocks();
}
int main(int argc, char **argv)
{
static char *callback = NULL, *user;
int i;
extern int headers_initialized;
if (argc < 2) { /* normal operation as a CGI application */
cgi_init();
atexit(cgi_end);
cgi_process_form();
printf("Content-type: application/javascript; charset=utf-8\r\n\r\n");
}
else
interactive = 1; /* interactive mode for debugging */
wfdbquiet(); /* suppress WFDB library error messages */
atexit(cleanup); /* release allocated memory before exiting */
/* Define data sources to be accessed via this server. */
setrepos(); /* function defined in "setrepos.c" */
if (!(action = get_param("action"))) {
print_file(LWDIR "/doc/about.txt");
exit(0);
}
if (!interactive && (callback = get_param("callback"))) {
printf("%s(", callback); /* JSONP: "wrap" output in callback */
atexit(jsonp_end); /* close the output with ")" before exiting */
}
if (strcmp(action, "dblist") == 0)
dblist();
else if ((db = get_param("db")) == NULL)
lwfail("Your request did not specify a database");
else if (strcmp(action, "rlist") == 0)
rlist();
else if (strcmp(action, "alist") == 0)
alist();
else if ((record = get_param("record")) == NULL)
lwfail("Your request did not specify a record");
else if (strcmp(action, "info") == 0)
info();
else if (strcmp(action, "fetch") == 0)
fetch();
else
lwfail("Your request did not specify a valid action");
exit(0);
}
void factor_vm::primitive_modify_code_heap()
{
gc_root<array> alist(dpop(),this);
cell count = array_capacity(alist.untagged());
if(count == 0)
return;
cell i;
for(i = 0; i < count; i++)
{
gc_root<array> pair(array_nth(alist.untagged(),i),this);
gc_root<word> word(array_nth(pair.untagged(),0),this);
gc_root<object> data(array_nth(pair.untagged(),1),this);
switch(data.type())
{
case QUOTATION_TYPE:
jit_compile_word(word.value(),data.value(),false);
break;
case ARRAY_TYPE:
{
array *compiled_data = data.as<array>().untagged();
cell owner = array_nth(compiled_data,0);
cell literals = array_nth(compiled_data,1);
cell relocation = array_nth(compiled_data,2);
cell labels = array_nth(compiled_data,3);
cell code = array_nth(compiled_data,4);
code_block *compiled = add_code_block(
WORD_TYPE,
code,
labels,
owner,
relocation,
literals);
word->code = compiled;
}
break;
default:
critical_error("Expected a quotation or an array",data.value());
break;
}
update_word_xt(word.value());
}
update_code_heap_words();
}
OUTPUT_FORMATTER::OUTPUT_FORMATTER(SEND_HANDLER *send_func_arg, void *send_ctx_arg,
int api_mode)
{
initialize_json();
send_func = send_func_arg;
send_ctx = send_ctx_arg;
api = api_mode;
result_message_plain = new POOL_MEM(PM_MESSAGE);
#if HAVE_JANSSON
result_array_json = json_array();
result_stack_json = New(alist(10, false));
#endif
}
void *connect_thread(void *arg)
{
pthread_detach(pthread_self());
set_jcr_in_tsd(INVALID_JCR);
/* Permit MaxConsoleConnect console connections */
sock_fds = New(alist(10, not_owned_by_alist));
bnet_thread_server_tcp((dlist*)arg,
me->MaxConsoleConnect,
sock_fds,
&ua_workq,
me->nokeepalive,
handle_UA_client_request);
return NULL;
}
/*
* Copy the storage definitions from an alist to the JCR
*/
void copy_rstorage(JCR *jcr, alist *storage, const char *where)
{
if (storage) {
STORERES *store;
if (jcr->res.rstorage) {
delete jcr->res.rstorage;
}
jcr->res.rstorage = New(alist(10, not_owned_by_alist));
foreach_alist(store, storage) {
jcr->res.rstorage->append(store);
}
if (!jcr->res.rstore_source) {
jcr->res.rstore_source = get_pool_memory(PM_MESSAGE);
}
pm_strcpy(jcr->res.rstore_source, where);
if (jcr->res.rstorage) {
jcr->res.rstore = (STORERES *)jcr->res.rstorage->first();
}
}
/*
* Store a string in an alist.
*/
void store_alist_str(LEX *lc, RES_ITEM *item, int index, int pass)
{
alist *list;
if (pass == 2) {
if (*(item->value) == NULL) {
list = New(alist(10, owned_by_alist));
} else {
list = (alist *)(*(item->value));
}
lex_get_token(lc, T_STRING); /* scan next item */
Dmsg4(900, "Append %s to alist %p size=%d %s\n",
lc->str, list, list->size(), item->name);
list->append(bstrdup(lc->str));
*(item->value) = (char *)list;
}
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
}
/*
* Create a stack of all filters that should be applied to a SQL query
* before submitting it to the database backend.
*/
static inline alist *db_initialize_query_filters(JCR *jcr)
{
alist *query_filters;
query_filters = New(alist(10, not_owned_by_alist));
if (!query_filters) {
Jmsg(jcr, M_FATAL, 0, _("Failed to allocate space for query filters.\n"));
return NULL;
}
db_allocate_query_filter(jcr, query_filters, 6, "OFFSET",
"/LIMIT ([0-9]+) OFFSET ([0-9]+)/OFFSET $2 FETCH NEXT $1 ROWS ONLY/ig");
db_allocate_query_filter(jcr, query_filters, 5, "LIMIT",
"/LIMIT ([0-9]+)/FETCH FIRST $1 ROWS ONLY/ig");
db_allocate_query_filter(jcr, query_filters, 9, "TEMPORARY",
"/CREATE TEMPORARY TABLE (.+)/DECLARE GLOBAL TEMPORARY TABLE $1 ON COMMIT PRESERVE ROWS WITH NORECOVERY/i");
return query_filters;
}
int main(int argc, char *argv[])
{
char plugin_dir[1000];
bpContext ctx;
bEvent event;
Plugin *plugin;
b_plugin_list = New(alist(10, not_owned_by_alist));
ctx.bContext = NULL;
ctx.pContext = NULL;
getcwd(plugin_dir, sizeof(plugin_dir)-1);
load_plugins((void *)&bfuncs, plugin_dir, plugin_type);
foreach_alist(plugin, b_plugin_list) {
printf("bacula: plugin_size=%d plugin_version=%d\n",
pref(plugin)->size, pref(plugin)->interface);
printf("License: %s\nAuthor: %s\nDate: %s\nVersion: %s\nDescription: %s\n",
pref(plugin)->plugin_license, pref(plugin)->plugin_author,
pref(plugin)->plugin_date, pref(plugin)->plugin_version,
pref(plugin)->plugin_description);
/* Start a new instance of the plugin */
pref(plugin)->newPlugin(&ctx);
event.eventType = bEventNewVolume;
pref(plugin)->handlePluginEvent(&ctx, &event);
/* Free the plugin instance */
pref(plugin)->freePlugin(&ctx);
/* Start a new instance of the plugin */
pref(plugin)->newPlugin(&ctx);
event.eventType = bEventNewVolume;
pref(plugin)->handlePluginEvent(&ctx, &event);
/* Free the plugin instance */
pref(plugin)->freePlugin(&ctx);
}
void arr_list_test(){
arr_list<int> alist(100);
for(int i = 0 ; i < 100 ; i ++){
alist.append(i);
}
alist.print();
for(int i = 10 ; i < 100 ; i ++){
alist.remove(10) ;
}
alist.print();
for(int i = 5 ; i < 15 ; i ++){
int t(alist.get_position(i));
std::cout << i << " in " << t << std::endl;
}
for(int i = 0 ; i < 10 ; i ++){
alist.insert(5,7);
}
alist.print();
alist.~arr_list();
}
/*
* Store a directory name at specified address in an alist.
* Note, we do shell expansion except if the string begins
* with a vertical bar (i.e. it will likely be passed to the
* shell later).
*/
static void store_alist_dir(LEX *lc, RES_ITEM *item, int index, int pass)
{
alist *list;
URES *res_all = (URES *)my_config->m_res_all;
if (pass == 2) {
if (*(item->value) == NULL) {
list = New(alist(10, owned_by_alist));
} else {
list = (alist *)(*(item->value));
}
lex_get_token(lc, T_STRING); /* scan next item */
Dmsg4(900, "Append %s to alist %p size=%d %s\n",
lc->str, list, list->size(), item->name);
if (lc->str[0] != '|') {
do_shell_expansion(lc->str, sizeof_pool_memory(lc->str));
}
list->append(bstrdup(lc->str));
*(item->value) = (char *)list;
}
scan_to_eol(lc);
set_bit(index, res_all->hdr.item_present);
}
/*
* Pruning Jobs is a bit more complicated than purging Files
* because we delete Job records only if there is a more current
* backup of the FileSet. Otherwise, we keep the Job record.
* In other words, we never delete the only Job record that
* contains a current backup of a FileSet. This prevents the
* Volume from being recycled and destroying a current backup.
*
* For Verify Jobs, we do not delete the last InitCatalog.
*
* For Restore Jobs there are no restrictions.
*/
int prune_jobs(UAContext *ua, CLIENTRES *client, POOLRES *pool, int JobType)
{
POOL_MEM query(PM_MESSAGE);
POOL_MEM sql_where(PM_MESSAGE);
POOL_MEM sql_from(PM_MESSAGE);
utime_t period;
char ed1[50];
alist *jobids_check=NULL;
struct accurate_check_ctx *elt;
db_list_ctx jobids, tempids;
JOB_DBR jr;
struct del_ctx del;
memset(&del, 0, sizeof(del));
if (pool && pool->JobRetention > 0) {
period = pool->JobRetention;
} else if (client) {
period = client->JobRetention;
} else { /* should specify at least pool or client */
return false;
}
db_lock(ua->db);
if (!prune_set_filter(ua, client, pool, period, &sql_from, &sql_where)) {
goto bail_out;
}
/* Drop any previous temporary tables still there */
drop_temp_tables(ua);
/* Create temp tables and indicies */
if (!create_temp_tables(ua)) {
goto bail_out;
}
edit_utime(period, ed1, sizeof(ed1));
Jmsg(ua->jcr, M_INFO, 0, _("Begin pruning Jobs older than %s.\n"), ed1);
del.max_ids = 100;
del.JobId = (JobId_t *)malloc(sizeof(JobId_t) * del.max_ids);
del.PurgedFiles = (char *)malloc(del.max_ids);
/*
* Select all files that are older than the JobRetention period
* and add them into the "DeletionCandidates" table.
*/
Mmsg(query,
"INSERT INTO DelCandidates "
"SELECT JobId,PurgedFiles,FileSetId,JobFiles,JobStatus "
"FROM Job %s " /* JOIN Pool/Client */
"WHERE Type IN ('B', 'C', 'M', 'V', 'D', 'R', 'c', 'm', 'g') "
" %s ", /* Pool/Client + JobTDate */
sql_from.c_str(), sql_where.c_str());
Dmsg1(050, "select sql=%s\n", query.c_str());
if (!db_sql_query(ua->db, query.c_str())) {
if (ua->verbose) {
ua->error_msg("%s", db_strerror(ua->db));
}
goto bail_out;
}
/* Now, for the selection, we discard some of them in order to be always
* able to restore files. (ie, last full, last diff, last incrs)
* Note: The DISTINCT could be more useful if we don't get FileSetId
*/
jobids_check = New(alist(10, owned_by_alist));
Mmsg(query,
"SELECT DISTINCT Job.Name, FileSet, Client.Name, Job.FileSetId, "
"Job.ClientId, Job.Type "
"FROM DelCandidates "
"JOIN Job USING (JobId) "
"JOIN Client USING (ClientId) "
"JOIN FileSet ON (Job.FileSetId = FileSet.FileSetId) "
"WHERE Job.Type IN ('B') " /* Look only Backup jobs */
"AND Job.JobStatus IN ('T', 'W') " /* Look only useful jobs */
);
/* The job_select_handler will skip jobs or filesets that are no longer
* in the configuration file. Interesting ClientId/FileSetId will be
* added to jobids_check (currently disabled in 6.0.7b)
*/
if (!db_sql_query(ua->db, query.c_str(), job_select_handler, jobids_check)) {
ua->error_msg("%s", db_strerror(ua->db));
}
/* For this selection, we exclude current jobs used for restore or
* accurate. This will prevent to prune the last full backup used for
* current backup & restore
*/
memset(&jr, 0, sizeof(jr));
/* To find useful jobs, we do like an incremental */
jr.JobLevel = L_INCREMENTAL;
foreach_alist(elt, jobids_check) {
jr.ClientId = elt->ClientId; /* should be always the same */
jr.FileSetId = elt->FileSetId;
db_accurate_get_jobids(ua->jcr, ua->db, &jr, &tempids);
jobids.add(tempids);
}
int main (int argc, char *argv[])
{
int ch;
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
alist *backend_directories = NULL;
#endif
char *jobids = (char *)"1";
char *path=NULL, *client=NULL;
uint64_t limit=0;
bool clean=false;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
Dmsg0(0, "Starting bvfs_test tool\n");
my_name_is(argc, argv, "bvfs_test");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "h:c:l:d:D:n:P:Su:vf:w:?j:p:f:T")) != -1) {
switch (ch) {
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'D':
db_driver = optarg;
break;
case 'l':
limit = str_to_int64(optarg);
break;
case 'c':
client = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'p':
path = optarg;
break;
case 'f':
file = optarg;
break;
case 'j':
jobids = optarg;
break;
case 'T':
clean = true;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bvfs_test", sizeof(bjcr->Job));
#if defined(HAVE_DYNAMIC_CATS_BACKENDS)
backend_directories = New(alist(10, owned_by_alist));
backend_directories->append((char *)backend_directory);
db_set_backend_dirs(backend_directories);
#endif
if ((db = db_init_database(NULL, NULL, db_name, db_user, db_password, db_host, 0, NULL)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
Dmsg1(0, "db_type=%s\n", db_get_type(db));
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
if (clean) {
Pmsg0(0, "Clean old table\n");
db_sql_query(db, "DELETE FROM PathHierarchy", NULL, NULL);
db_sql_query(db, "UPDATE Job SET HasCache=0", NULL, NULL);
db_sql_query(db, "DELETE FROM PathVisibility", NULL, NULL);
bvfs_update_cache(bjcr, db);
}
Bvfs fs(bjcr, db);
fs.set_handler(result_handler, &fs);
fs.set_jobids(jobids);
fs.update_cache();
if (limit)
fs.set_limit(limit);
if (path) {
fs.ch_dir(path);
fs.ls_special_dirs();
fs.ls_dirs();
while (fs.ls_files()) {
fs.next_offset();
}
if (fnid && client) {
Pmsg0(0, "---------------------------------------------\n");
Pmsg1(0, "Getting file version for %s\n", file);
fs.get_all_file_versions(fs.get_pwd(), fnid, client);
}
exit (0);
}
Pmsg0(0, "list /\n");
fs.ch_dir("/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/\n");
fs.ch_dir("/tmp/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
Pmsg0(0, "list /tmp/regress/\n");
fs.ch_dir("/tmp/regress/");
fs.ls_special_dirs();
fs.ls_files();
fs.ls_dirs();
Pmsg0(0, "list /tmp/regress/build/\n");
fs.ch_dir("/tmp/regress/build/");
fs.ls_special_dirs();
fs.ls_dirs();
fs.ls_files();
fs.get_all_file_versions(1, 347, "zog4-fd");
char p[200];
strcpy(p, "/tmp/toto/rep/");
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/toto/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/tmp/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "/")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
bvfs_parent_dir(p);
if(!bstrcmp(p, "")) {
Pmsg0(000, "Error in bvfs_parent_dir\n");
}
return 0;
}
/*
* Initialize the static structure to zeros, then apply all the default values.
*/
void CONFIG::init_resource(int type, RES_ITEM *items, int pass)
{
URES *res_all;
memset(m_res_all, 0, m_res_all_size);
res_all = ((URES *)m_res_all);
res_all->hdr.rcode = type;
res_all->hdr.refcnt = 1;
/*
* See what pass of the config parsing this is.
*/
switch (pass) {
case 1: {
/*
* Set all defaults for types that are filled in pass 1 of the config parser.
*/
int i;
for (i = 0; items[i].name; i++) {
Dmsg3(900, "Item=%s def=%s defval=%s\n", items[i].name,
(items[i].flags & CFG_ITEM_DEFAULT) ? "yes" : "no",
(items[i].default_value) ? items[i].default_value : "None");
/*
* Sanity check.
*
* Items with a default value but without the CFG_ITEM_DEFAULT flag set
* are most of the time an indication of a programmers error.
*/
if (items[i].default_value != NULL && !(items[i].flags & CFG_ITEM_DEFAULT)) {
Pmsg1(000, _("Found config item %s which has default value but no CFG_ITEM_DEFAULT flag set\n"),
items[i].name);
items[i].flags |= CFG_ITEM_DEFAULT;
}
/*
* See if the CFG_ITEM_DEFAULT flag is set and a default value is available.
*/
if (items[i].flags & CFG_ITEM_DEFAULT && items[i].default_value != NULL) {
/*
* First try to handle the generic types.
*/
switch (items[i].type) {
case CFG_TYPE_BIT:
if (bstrcasecmp(items[i].default_value, "on")) {
set_bit(items[i].code, items[i].bitvalue);
} else if (bstrcasecmp(items[i].default_value, "off")) {
clear_bit(items[i].code, items[i].bitvalue);
}
break;
case CFG_TYPE_BOOL:
if (bstrcasecmp(items[i].default_value, "yes") ||
bstrcasecmp(items[i].default_value, "true")) {
*(items[i].boolvalue) = true;
} else if (bstrcasecmp(items[i].default_value, "no") ||
bstrcasecmp(items[i].default_value, "false")) {
*(items[i].boolvalue) = false;
}
break;
case CFG_TYPE_PINT32:
case CFG_TYPE_INT32:
case CFG_TYPE_SIZE32:
*(items[i].ui32value) = str_to_int32(items[i].default_value);
break;
case CFG_TYPE_INT64:
*(items[i].i64value) = str_to_int64(items[i].default_value);
break;
case CFG_TYPE_SIZE64:
*(items[i].ui64value) = str_to_uint64(items[i].default_value);
break;
case CFG_TYPE_SPEED:
*(items[i].ui64value) = str_to_uint64(items[i].default_value);
break;
case CFG_TYPE_TIME:
*(items[i].utimevalue) = str_to_int64(items[i].default_value);
break;
case CFG_TYPE_STRNAME:
case CFG_TYPE_STR:
*(items[i].value) = bstrdup(items[i].default_value);
break;
case CFG_TYPE_DIR: {
POOL_MEM pathname(PM_FNAME);
pm_strcpy(pathname, items[i].default_value);
if (*pathname.c_str() != '|') {
int size;
/*
* Make sure we have enough room
*/
size = pathname.size() + 1024;
pathname.check_size(size);
do_shell_expansion(pathname.c_str(), pathname.size());
}
*items[i].value = bstrdup(pathname.c_str());
break;
}
case CFG_TYPE_ADDRESSES:
init_default_addresses(items[i].dlistvalue, items[i].default_value);
break;
default:
/*
* None of the generic types fired if there is a registered callback call that now.
*/
if (m_init_res) {
m_init_res(&items[i], pass);
}
break;
}
if (!m_omit_defaults) {
set_bit(i, res_all->hdr.inherit_content);
}
}
/*
* If this triggers, take a look at lib/parse_conf.h
*/
if (i >= MAX_RES_ITEMS) {
Emsg1(M_ERROR_TERM, 0, _("Too many items in %s resource\n"), m_resources[type - m_r_first]);
}
}
break;
}
case 2: {
/*
* Set all defaults for types that are filled in pass 2 of the config parser.
*/
int i;
for (i = 0; items[i].name; i++) {
Dmsg3(900, "Item=%s def=%s defval=%s\n", items[i].name,
(items[i].flags & CFG_ITEM_DEFAULT) ? "yes" : "no",
(items[i].default_value) ? items[i].default_value : "None");
/*
* See if the CFG_ITEM_DEFAULT flag is set and a default value is available.
*/
if (items[i].flags & CFG_ITEM_DEFAULT && items[i].default_value != NULL) {
/*
* First try to handle the generic types.
*/
switch (items[i].type) {
case CFG_TYPE_ALIST_STR:
if (!*items[i].alistvalue) {
*(items[i].alistvalue) = New(alist(10, owned_by_alist));
}
(*(items[i].alistvalue))->append(bstrdup(items[i].default_value));
break;
case CFG_TYPE_ALIST_DIR: {
POOL_MEM pathname(PM_FNAME);
if (!*items[i].alistvalue) {
*(items[i].alistvalue) = New(alist(10, owned_by_alist));
}
pm_strcpy(pathname, items[i].default_value);
if (*items[i].default_value != '|') {
int size;
/*
* Make sure we have enough room
*/
size = pathname.size() + 1024;
pathname.check_size(size);
do_shell_expansion(pathname.c_str(), pathname.size());
}
(*(items[i].alistvalue))->append(bstrdup(pathname.c_str()));
break;
}
default:
/*
* None of the generic types fired if there is a registered callback call that now.
*/
if (m_init_res) {
m_init_res(&items[i], pass);
}
break;
}
if (!m_omit_defaults) {
set_bit(i, res_all->hdr.inherit_content);
}
}
/*
* If this triggers, take a look at lib/parse_conf.h
*/
if (i >= MAX_RES_ITEMS) {
Emsg1(M_ERROR_TERM, 0, _("Too many items in %s resource\n"), m_resources[type - m_r_first]);
}
}
break;
}
default:
break;
}
}
int Model::
init(tao_tree_info_s * kgm_tree,
tao_tree_info_s * cc_tree,
std::ostream * msg)
{
int const status(tao_consistency_check(kgm_tree->root, msg));
if (0 != status) {
return status;
}
if (kgm_tree_) {
if (msg) {
*msg << "jspace::Model::init(): already initialized\n";
}
return -1;
}
if ( ! kgm_tree->sort()) {
if (msg) {
*msg << "jspace::Model::init(): could not sort KGM nodes according to IDs\n";
}
return -2;
}
if ((0 != cc_tree) && ( ! cc_tree->sort())) {
if (msg) {
*msg << "jspace::Model::init(): could not sort CC nodes according to IDs\n";
}
return -3;
}
// Create ancestry table of all nodes in the KGM tree, for correct
// (and slightly more efficient) computation of the Jacobian.
ancestry_table_.clear(); // just paranoid...
typedef tao_tree_info_s::node_info_t::const_iterator cit_t;
cit_t in(kgm_tree->info.begin());
cit_t iend(kgm_tree->info.end());
for (/**/; in != iend; ++in) {
// ...paranoid checks...
if ( ! in->node) {
if (msg) {
*msg << "jspace::Model::init(): NULL node at entry #" << in->id << "\n";
}
return -4;
}
if (in->id != in->node->getID()) {
if (msg) {
*msg << "jspace::Model::init(): node ID of entry #" << in->id << " is " << in->node->getID() << "\n";
}
return -5;
}
ancestry_list_t & alist(ancestry_table_[in->node]); // first reference creates the instance
// walk up the ancestry, append each parent to the list of
// ancestors of this node
for (taoDNode * node(in->node); 0 != node; node = node->getDParent()) {
ancestry_entry_s entry;
entry.id = node->getID();
entry.joint = node->getJointList();
if (0 != entry.joint) {
alist.push_back(entry);
}
}
}
kgm_tree_ = kgm_tree;
cc_tree_ = cc_tree;
ndof_ = kgm_tree->info.size();
return 0;
}
B_DB *db_init_database(JCR *jcr,
const char *db_driver,
const char *db_name,
const char *db_user,
const char *db_password,
const char *db_address,
int db_port,
const char *db_socket,
bool mult_db_connections,
bool disable_batch_insert,
bool need_private)
{
void *dl_handle;
char shared_library_name[1024];
backend_interface_mapping_t *backend_interface_mapping;
backend_shared_library_t *backend_shared_library;
t_backend_instantiate backend_instantiate;
t_flush_backend flush_backend;
/*
* A db_driver is mandatory for dynamic loading of backends to work.
*/
if (!db_driver) {
Jmsg(jcr, M_ABORT, 0, _("Driver type not specified in Catalog resource.\n"));
}
/*
* If we didn't find a mapping its fatal because we don't know what database backend to use.
*/
backend_interface_mapping = lookup_backend_interface_mapping(db_driver);
if (backend_interface_mapping == NULL) {
Jmsg(jcr, M_ABORT, 0, _("Unknown database type: %s\n"), db_driver);
return (B_DB *)NULL;
}
/*
* See if the backend is already loaded.
*/
if (loaded_backends) {
foreach_alist(backend_shared_library, loaded_backends) {
if (backend_shared_library->interface_type_id ==
backend_interface_mapping->interface_type_id) {
return backend_shared_library->backend_instantiate(jcr,
db_driver,
db_name,
db_user,
db_password,
db_address,
db_port,
db_socket,
mult_db_connections,
disable_batch_insert,
need_private);
}
}
}
/*
* This is a new backend try to use dynamic loading to load the backend library.
*/
#if defined(HAVE_WIN32)
bsnprintf(shared_library_name, sizeof(shared_library_name), "libbareoscats-%s%s",
backend_interface_mapping->interface_name, DYN_LIB_EXTENSION);
#else
bsnprintf(shared_library_name, sizeof(shared_library_name), "%s/libbareoscats-%s%s",
LIBDIR, backend_interface_mapping->interface_name, DYN_LIB_EXTENSION);
#endif
dl_handle = dlopen(shared_library_name, RTLD_NOW);
if (!dl_handle) {
Jmsg(jcr, M_ABORT, 0, _("Unable to load shared library: %s ERR=%s\n"),
shared_library_name, NPRT(dlerror()));
return (B_DB *)NULL;
}
/*
* Lookup the backend_instantiate function.
*/
backend_instantiate = (t_backend_instantiate)dlsym(dl_handle, "backend_instantiate");
if (backend_instantiate == NULL) {
Jmsg(jcr, M_ABORT, 0, _("Lookup of backend_instantiate in shared library %s failed: ERR=%s\n"),
shared_library_name, NPRT(dlerror()));
dlclose(dl_handle);
return (B_DB *)NULL;
}
/*
* Lookup the flush_backend function.
*/
flush_backend = (t_flush_backend)dlsym(dl_handle, "flush_backend");
if (flush_backend == NULL) {
Jmsg(jcr, M_ABORT, 0, _("Lookup of flush_backend in shared library %s failed: ERR=%s\n"),
shared_library_name, NPRT(dlerror()));
dlclose(dl_handle);
return (B_DB *)NULL;
}
/*
* Create a new loaded shared library entry and tack it onto the list of loaded backend shared libs.
*/
backend_shared_library = (backend_shared_library_t *)malloc(sizeof(backend_shared_library_t));
backend_shared_library->interface_type_id = backend_interface_mapping->interface_type_id;
backend_shared_library->handle = dl_handle;
backend_shared_library->backend_instantiate = backend_instantiate;
backend_shared_library->flush_backend = flush_backend;
if (loaded_backends == NULL) {
loaded_backends = New(alist(10, not_owned_by_alist));
}
loaded_backends->append(backend_shared_library);
return backend_shared_library->backend_instantiate(jcr,
db_driver,
db_name,
db_user,
db_password,
db_address,
db_port,
db_socket,
mult_db_connections,
disable_batch_insert,
need_private);
}
/*
* This is the engine called by jobq.c:jobq_add() when we were pulled
* from the work queue.
* At this point, we are running in our own thread and all
* necessary resources are allocated -- see jobq.c
*/
static void *job_thread(void *arg)
{
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
Dsm_check(100);
Dmsg0(200, "=====Start Job=========\n");
jcr->setJobStatus(JS_Running); /* this will be set only if no error */
jcr->start_time = time(NULL); /* set the real start time */
jcr->jr.StartTime = jcr->start_time;
if (jcr->res.job->MaxStartDelay != 0 && jcr->res.job->MaxStartDelay <
(utime_t)(jcr->start_time - jcr->sched_time)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
}
if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max run sched time exceeded.\n"));
}
/* TODO : check if it is used somewhere */
if (jcr->res.job->RunScripts == NULL) {
Dmsg0(200, "Warning, job->RunScripts is empty\n");
jcr->res.job->RunScripts = New(alist(10, not_owned_by_alist));
}
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
/* Run any script BeforeJob on dird */
run_scripts(jcr, jcr->res.job->RunScripts, "BeforeJob");
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
generate_plugin_event(jcr, bDirEventJobRun);
switch (jcr->getJobType()) {
case JT_BACKUP:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_backup(jcr)) {
do_autoprune(jcr);
} else {
ndmp_backup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_backup_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
if (do_native_vbackup(jcr)) {
do_autoprune(jcr);
} else {
native_vbackup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
if (do_native_backup(jcr)) {
do_autoprune(jcr);
} else {
native_backup_cleanup(jcr, JS_ErrorTerminated);
}
}
} else {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
native_vbackup_cleanup(jcr, JS_Canceled);
} else {
native_backup_cleanup(jcr, JS_Canceled);
}
}
break;
}
break;
case JT_VERIFY:
if (!job_canceled(jcr)) {
if (do_verify(jcr)) {
do_autoprune(jcr);
} else {
verify_cleanup(jcr, JS_ErrorTerminated);
}
} else {
verify_cleanup(jcr, JS_Canceled);
}
break;
case JT_RESTORE:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_restore(jcr)) {
do_autoprune(jcr);
} else {
ndmp_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_restore_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (do_native_restore(jcr)) {
do_autoprune(jcr);
} else {
native_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
native_restore_cleanup(jcr, JS_Canceled);
}
break;
}
break;
case JT_ADMIN:
if (!job_canceled(jcr)) {
if (do_admin(jcr)) {
do_autoprune(jcr);
} else {
admin_cleanup(jcr, JS_ErrorTerminated);
}
} else {
admin_cleanup(jcr, JS_Canceled);
}
break;
case JT_COPY:
case JT_MIGRATE:
if (!job_canceled(jcr)) {
if (do_migration(jcr)) {
do_autoprune(jcr);
} else {
migration_cleanup(jcr, JS_ErrorTerminated);
}
} else {
migration_cleanup(jcr, JS_Canceled);
}
break;
default:
Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
break;
}
run_scripts(jcr, jcr->res.job->RunScripts, "AfterJob");
/* Send off any queued messages */
if (jcr->msg_queue && jcr->msg_queue->size() > 0) {
dequeue_messages(jcr);
}
generate_plugin_event(jcr, bDirEventJobEnd);
Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
Dsm_check(100);
return NULL;
}
int main (int argc, char *argv[])
{
int ch;
bool no_signals = false;
bool test_config = false;
pthread_t thid;
char *uid = NULL;
char *gid = NULL;
start_heap = sbrk(0);
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
my_name_is(argc, argv, "bareos-sd");
init_msg(NULL, NULL);
daemon_start_time = time(NULL);
/* Sanity checks */
if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
TAPE_BSIZE, B_DEV_BSIZE);
}
if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
}
while ((ch = getopt(argc, argv, "c:d:fg:mpstu:v?")) != -1) {
switch (ch) {
case 'c': /* configuration file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'f': /* run in foreground */
foreground = true;
break;
case 'g': /* set group id */
gid = optarg;
break;
case 'm': /* print kaboom output */
prt_kaboom = true;
break;
case 'p': /* proceed in spite of I/O errors */
forge_on = true;
break;
case 's': /* no signals */
no_signals = true;
break;
case 't':
test_config = true;
break;
case 'u': /* set uid */
uid = optarg;
break;
case 'v': /* verbose */
verbose++;
break;
case '?':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc) {
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(*argv);
argc--;
argv++;
}
if (argc)
usage();
/*
* See if we want to drop privs.
*/
if (geteuid() == 0) {
drop(uid, gid, false);
}
if (!no_signals) {
init_signals(terminate_stored);
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
if (init_crypto() != 0) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n"));
}
if (!check_resources()) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
}
init_reservations_lock();
if (test_config) {
terminate_stored(0);
}
my_name_is(0, (char **)NULL, me->hdr.name); /* Set our real name */
if (!foreground) {
daemon_start(); /* become daemon */
init_stack_dump(); /* pick up new pid */
}
create_pid_file(me->pid_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
read_state_file(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
set_jcr_in_tsd(INVALID_JCR);
/*
* Make sure on Solaris we can run concurrent, watch dog + servers + misc
*/
set_thread_concurrency(me->max_concurrent_jobs * 2 + 4);
lmgr_init_thread(); /* initialize the lockmanager stack */
load_sd_plugins(me->plugin_directory, me->plugin_names);
cleanup_old_files();
/* Ensure that Volume Session Time and Id are both
* set and are both non-zero.
*/
VolSessionTime = (uint32_t)daemon_start_time;
if (VolSessionTime == 0) { /* paranoid */
Jmsg0(NULL, M_ABORT, 0, _("Volume Session Time is ZERO!\n"));
}
/*
* Start the device allocation thread
*/
create_volume_lists(); /* do before device_init */
if (pthread_create(&thid, NULL, device_initialization, NULL) != 0) {
berrno be;
Emsg1(M_ABORT, 0, _("Unable to create thread. ERR=%s\n"), be.bstrerror());
}
start_watchdog(); /* start watchdog thread */
if (me->jcr_watchdog_time) {
init_jcr_subsystem(me->jcr_watchdog_time); /* start JCR watchdogs etc. */
}
#if HAVE_NDMP
/* Seperate thread that handles NDMP connections */
if (me->ndmp_enable) {
start_ndmp_thread_server(me->NDMPaddrs,
me->max_concurrent_jobs * 2 + 1,
&ndmp_workq);
}
#endif
/* Single server used for Director/Storage and File daemon */
sock_fds = New(alist(10, not_owned_by_alist));
bnet_thread_server_tcp(me->SDaddrs,
me->max_concurrent_jobs * 2 + 1,
sock_fds,
&dird_workq,
me->nokeepalive,
handle_connection_request);
exit(1); /* to keep compiler quiet */
}
}
void start_socket_server(dlist *addrs)
{
IPADDR *p;
tcp_server_tid = pthread_self();
/*
* Become server, and handle requests
*/
foreach_dlist(p, addrs) {
Dmsg1(10, "stored: listening on port %d\n", p->get_port_host_order());
}
sock_fds = New(alist(10, not_owned_by_alist));
bnet_thread_server_tcp(addrs,
me->MaxConnections,
sock_fds,
&socket_workq,
me->nokeepalive,
handle_connection_request);
}
void stop_socket_server()
{
if (sock_fds) {
bnet_stop_thread_server_tcp(tcp_server_tid);
cleanup_bnet_thread_server_tcp(sock_fds, &socket_workq);
delete sock_fds;
sock_fds = NULL;
/*********************************************************************
* Acquire device for reading.
* The drive should have previously been reserved by calling
* reserve_device_for_read(). We read the Volume label from the block and
* leave the block pointers just after the label.
*
* Returns: NULL if failed for any reason
* dcr if successful
*/
bool acquire_device_for_read(DCR *dcr)
{
DEVICE *dev;
JCR *jcr = dcr->jcr;
bool ok = false;
bool tape_previously_mounted;
VOL_LIST *vol;
bool try_autochanger = true;
int i;
int vol_label_status;
int retry = 0;
Enter(rdbglvl);
dev = dcr->dev;
dev->Lock_read_acquire();
Dmsg2(rdbglvl, "dcr=%p dev=%p\n", dcr, dcr->dev);
Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type);
dev->dblock(BST_DOING_ACQUIRE);
if (dev->num_writers > 0) {
Jmsg2(jcr, M_FATAL, 0, _("Acquire read: num_writers=%d not zero. Job %d canceled.\n"),
dev->num_writers, jcr->JobId);
goto get_out;
}
/* Find next Volume, if any */
vol = jcr->VolList;
if (!vol) {
char ed1[50];
Jmsg(jcr, M_FATAL, 0, _("No volumes specified for reading. Job %s canceled.\n"),
edit_int64(jcr->JobId, ed1));
goto get_out;
}
jcr->CurReadVolume++;
for (i=1; i<jcr->CurReadVolume; i++) {
vol = vol->next;
}
if (!vol) {
Jmsg(jcr, M_FATAL, 0, _("Logic error: no next volume to read. Numvol=%d Curvol=%d\n"),
jcr->NumReadVolumes, jcr->CurReadVolume);
goto get_out; /* should not happen */
}
set_dcr_from_vol(dcr, vol);
Dmsg2(rdbglvl, "Want Vol=%s Slot=%d\n", vol->VolumeName, vol->Slot);
/*
* If the MediaType requested for this volume is not the
* same as the current drive, we attempt to find the same
* device that was used to write the orginal volume. If
* found, we switch to using that device.
*
* N.B. A lot of routines rely on the dcr pointer not changing
* read_records.c even has multiple dcrs cached, so we take care
* here to release all important parts of the dcr and re-acquire
* them such as the block pointer (size may change), but we do
* not release the dcr.
*/
Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type);
if (dcr->media_type[0] && !bstrcmp(dcr->media_type, dev->device->media_type)) {
RCTX rctx;
DIRSTORE *store;
int status;
Jmsg3(jcr, M_INFO, 0, _("Changing read device. Want Media Type=\"%s\" have=\"%s\"\n"
" device=%s\n"),
dcr->media_type, dev->device->media_type, dev->print_name());
Dmsg3(rdbglvl, "Changing read device. Want Media Type=\"%s\" have=\"%s\"\n"
" device=%s\n",
dcr->media_type, dev->device->media_type, dev->print_name());
dev->dunblock(DEV_UNLOCKED);
lock_reservations();
memset(&rctx, 0, sizeof(RCTX));
rctx.jcr = jcr;
jcr->read_dcr = dcr;
jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
rctx.any_drive = true;
rctx.device_name = vol->device;
store = new DIRSTORE;
memset(store, 0, sizeof(DIRSTORE));
store->name[0] = 0; /* No dir name */
bstrncpy(store->media_type, vol->MediaType, sizeof(store->media_type));
bstrncpy(store->pool_name, dcr->pool_name, sizeof(store->pool_name));
bstrncpy(store->pool_type, dcr->pool_type, sizeof(store->pool_type));
store->append = false;
rctx.store = store;
clean_device(dcr); /* clean up the dcr */
/*
* Search for a new device
*/
status = search_res_for_device(rctx);
release_reserve_messages(jcr); /* release queued messages */
unlock_reservations();
if (status == 1) { /* found new device to use */
/*
* Switching devices, so acquire lock on new device,
* then release the old one.
*/
dcr->dev->Lock_read_acquire(); /* lock new one */
dev->Unlock_read_acquire(); /* release old one */
dev = dcr->dev; /* get new device pointer */
dev->dblock(BST_DOING_ACQUIRE);
dcr->VolumeName[0] = 0;
Jmsg(jcr, M_INFO, 0, _("Media Type change. New read device %s chosen.\n"),
dev->print_name());
Dmsg1(50, "Media Type change. New read device %s chosen.\n", dev->print_name());
bstrncpy(dcr->VolumeName, vol->VolumeName, sizeof(dcr->VolumeName));
dcr->setVolCatName(vol->VolumeName);
bstrncpy(dcr->media_type, vol->MediaType, sizeof(dcr->media_type));
dcr->VolCatInfo.Slot = vol->Slot;
dcr->VolCatInfo.InChanger = vol->Slot > 0;
bstrncpy(dcr->pool_name, store->pool_name, sizeof(dcr->pool_name));
bstrncpy(dcr->pool_type, store->pool_type, sizeof(dcr->pool_type));
} else {
/* error */
Jmsg1(jcr, M_FATAL, 0, _("No suitable device found to read Volume \"%s\"\n"),
vol->VolumeName);
Dmsg1(rdbglvl, "No suitable device found to read Volume \"%s\"\n", vol->VolumeName);
goto get_out;
}
}
Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type);
dev->clear_unload();
if (dev->vol && dev->vol->is_swapping()) {
dev->vol->set_slot(vol->Slot);
Dmsg3(rdbglvl, "swapping: slot=%d Vol=%s dev=%s\n", dev->vol->get_slot(),
dev->vol->vol_name, dev->print_name());
}
init_device_wait_timers(dcr);
tape_previously_mounted = dev->can_read() || dev->can_append() ||
dev->is_labeled();
// tape_initially_mounted = tape_previously_mounted;
/* Volume info is always needed because of VolParts */
Dmsg1(rdbglvl, "dir_get_volume_info vol=%s\n", dcr->VolumeName);
if (!dcr->dir_get_volume_info(GET_VOL_INFO_FOR_READ)) {
Dmsg2(rdbglvl, "dir_get_vol_info failed for vol=%s: %s\n",
dcr->VolumeName, jcr->errmsg);
Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
}
dev->set_load(); /* set to load volume */
for ( ;; ) {
/* If not polling limit retries */
if (!dev->poll && retry++ > 10) {
break;
}
dev->clear_labeled(); /* force reread of label */
if (job_canceled(jcr)) {
char ed1[50];
Mmsg1(dev->errmsg, _("Job %s canceled.\n"), edit_int64(jcr->JobId, ed1));
Jmsg(jcr, M_INFO, 0, dev->errmsg);
goto get_out; /* error return */
}
dcr->do_unload();
dcr->do_swapping(false/*!is_writing*/);
dcr->do_load(false /*!is_writing*/);
set_dcr_from_vol(dcr, vol); /* refresh dcr with desired volume info */
/*
* This code ensures that the device is ready for
* reading. If it is a file, it opens it.
* If it is a tape, it checks the volume name
*/
Dmsg1(rdbglvl, "stored: open vol=%s\n", dcr->VolumeName);
if (!dev->open(dcr, OPEN_READ_ONLY)) {
if (!dev->poll) {
Jmsg3(jcr, M_WARNING, 0, _("Read open device %s Volume \"%s\" failed: ERR=%s\n"),
dev->print_name(), dcr->VolumeName, dev->bstrerror());
}
goto default_path;
}
Dmsg1(rdbglvl, "opened dev %s OK\n", dev->print_name());
/* Read Volume Label */
Dmsg0(rdbglvl, "calling read-vol-label\n");
vol_label_status = read_dev_volume_label(dcr);
switch (vol_label_status) {
case VOL_OK:
Dmsg0(rdbglvl, "Got correct volume.\n");
ok = true;
dev->VolCatInfo = dcr->VolCatInfo; /* structure assignment */
break; /* got it */
case VOL_IO_ERROR:
Dmsg0(rdbglvl, "IO Error\n");
/*
* Send error message generated by read_dev_volume_label()
* only we really had a tape mounted. This supresses superfluous
* error messages when nothing is mounted.
*/
if (tape_previously_mounted) {
Jmsg(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
}
goto default_path;
case VOL_NAME_ERROR:
Dmsg3(rdbglvl, "Vol name=%s want=%s drv=%s.\n", dev->VolHdr.VolumeName,
dcr->VolumeName, dev->print_name());
if (dev->is_volume_to_unload()) {
goto default_path;
}
dev->set_unload(); /* force unload of unwanted tape */
if (!unload_autochanger(dcr, -1)) {
/* at least free the device so we can re-open with correct volume */
dev->close(dcr);
free_volume(dev);
}
dev->set_load();
/* Fall through */
default:
Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
default_path:
Dmsg0(rdbglvl, "default path\n");
tape_previously_mounted = true;
/*
* If the device requires mount, close it, so the device can be ejected.
*/
if (dev->requires_mount()) {
dev->close(dcr);
free_volume(dev);
}
/* Call autochanger only once unless ask_sysop called */
if (try_autochanger) {
int status;
Dmsg2(rdbglvl, "calling autoload Vol=%s Slot=%d\n",
dcr->VolumeName, dcr->VolCatInfo.Slot);
status = autoload_device(dcr, 0, NULL);
if (status > 0) {
try_autochanger = false;
continue; /* try reading volume mounted */
}
}
/* Mount a specific volume and no other */
Dmsg0(rdbglvl, "calling dir_ask_sysop\n");
if (!dcr->dir_ask_sysop_to_mount_volume(ST_READREADY)) {
goto get_out; /* error return */
}
/* Volume info is always needed because of VolParts */
Dmsg1(150, "dir_get_volume_info vol=%s\n", dcr->VolumeName);
if (!dcr->dir_get_volume_info(GET_VOL_INFO_FOR_READ)) {
Dmsg2(150, "dir_get_vol_info failed for vol=%s: %s\n",
dcr->VolumeName, jcr->errmsg);
Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg);
}
dev->set_load(); /* set to load volume */
try_autochanger = true; /* permit trying the autochanger again */
continue; /* try reading again */
} /* end switch */
break;
} /* end for loop */
if (!ok) {
Jmsg1(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s for reading.\n"),
dev->print_name());
goto get_out;
}
dev->clear_append();
dev->set_read();
jcr->sendJobStatus(JS_Running);
Jmsg(jcr, M_INFO, 0, _("Ready to read from volume \"%s\" on device %s.\n"),
dcr->VolumeName, dev->print_name());
get_out:
dev->Lock();
dcr->clear_reserved();
/*
* Normally we are blocked, but in at least one error case above
* we are not blocked because we unsuccessfully tried changing
* devices.
*/
if (dev->is_blocked()) {
dev->dunblock(DEV_LOCKED);
} else {
dev->Unlock(); /* dunblock() unlock the device too */
}
Dmsg2(rdbglvl, "dcr=%p dev=%p\n", dcr, dcr->dev);
Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type);
dev->Unlock_read_acquire();
Leave(rdbglvl);
return ok;
}