/**
Szuka słowo w poddrzewie node'a
@param[in] node Węzeł
@param[in] word Słowo
@return Nowy węzeł
*/
static bool node_find(trie_node *node, const wchar_t *word)
{
assert(node != NULL);
if(word[0] == L'\0')
return node->end_of_word;
if(word[0] == IGNORE_CHAR)
return node_find(node, word + 1);
trie_node *son = node_son(node, word[0]);
if(son == NULL)
return false;
return node_find(son, word + 1);
}
void
fen_remove (const gchar *filename, gpointer sub, gboolean is_mondir)
{
node_t* f;
g_assert (filename);
g_assert (sub);
G_LOCK (fen_lock);
f = node_find(NULL, filename, FALSE);
FH_W ("%s 0x%p sub[0x%p] %s\n", __func__, f, sub, filename);
if (f) {
if (is_mondir) {
f->dir_subs = g_list_remove(f->dir_subs, sub);
} else {
f->subs = g_list_remove(f->subs, sub);
}
if (!NODE_IS_ACTIVE(f)) {
node_try_delete (f);
}
}
G_UNLOCK (fen_lock);
}
int lf_add_dependency_cpp(lua_State *L)
{
struct CONTEXT *context;
struct DEFERRED *deferred;
struct NODE * node;
int n = lua_gettop(L);
if(n != 1)
luaL_error(L, "add_dependency_cpp: incorrect number of arguments");
luaL_checkstring(L,1);
context = context_get_pointer(L);
node = node_find(context->graph, lua_tostring(L,1));
if(!node)
luaL_error(L, "add_dependency_cpp: couldn't find node with name '%s'", lua_tostring(L,1));
deferred = (struct DEFERRED *)mem_allocate(context->deferredheap, sizeof(struct DEFERRED));
deferred->node = node;
deferred->user = current_includepaths;
deferred->run = dependency_cpp_do_run;
deferred->next = context->firstdeferred_cpp;
context->firstdeferred_cpp = deferred;
return 0;
}
/* add_output(string output, string other_output) */
int lf_add_output(lua_State *L)
{
struct NODE *output;
struct NODE *other_output;
struct CONTEXT *context;
int i;
const char *filename;
if(lua_gettop(L) != 2)
luaL_error(L, "add_output: incorrect number of arguments");
luaL_checktype(L, 1, LUA_TSTRING);
luaL_checktype(L, 2, LUA_TSTRING);
context = context_get_pointer(L);
output = node_find(context->graph, lua_tostring(L,1));
if(!output)
luaL_error(L, "add_output: couldn't find node with name '%s'", lua_tostring(L,1));
if(!output->job->real)
luaL_error(L, "add_output: '%s' does not have a job", lua_tostring(L,1));
filename = lua_tostring(L, -1);
i = node_create(&other_output, context->graph, filename, output->job);
if(i == NODECREATE_NOTNICE)
luaL_error(L, "add_output: node '%s' is not nice", filename);
else if(i == NODECREATE_EXISTS)
luaL_error(L, "add_output: node '%s' already exists", filename);
else if(i != NODECREATE_OK)
luaL_error(L, "add_output: unknown error creating node '%s'", filename);
return 0;
}
bool trie_find(trie_tree *tree, const wchar_t *word)
{
assert(tree != NULL);
if(tree->root == NULL)
return false;
return node_find(tree->root, word);
}
void node_add(node_t **n, int value)
{
node_t **found = node_find(n, value);
if (*found == NULL)
{
*found = node_new(value);
}
}
int rtloginl ()
{
LINK *link;
CIRCUIT *circuit;
SADDR sp;
char *buf, call[ln_axaddr+1];
if (MemLow) return cmd_exit;
getpeername(CurProc->input, &sp);
if (sp.type isnt TYPE_NETROM) return cmd_exit;
ax2str(call, sp.a.nr.node);
if (node_find(call)) return cmd_exit; // Already linked.
for (link = link_hd; link; link = link->next)
if (matchi(call, link->call)) break;
if (!link) return cmd_exit; // We don't link with this system.
if (link->flags & (p_linked | p_linkini)) return cmd_exit; // Already linked.
// Accept the link request.
puser(link->alias);
buf = mallocw(LINE128);
strcpy(buf, call);
strlop(buf, '-');
puser(buf);
free(buf);
// Create a circuit for this link.
circuit = circuit_new(p_linked, CurProc->output);
if (!circuit) return cmd_exit;
tputs("OK\n");
circuit->u.link = link;
link->flags = p_linked;
state_tell(circuit);
makelinks();
// Run in circles, scream and shout.
for (;;) if (getinp(circuit))
chkctl(circuit);
else
{
link_drop(circuit);
link->flags = p_nil;
return cmd_exit;
}
}
static int node_findfile(struct GRAPH *graph, const char *filename, struct NODE **node, time_t *timestamp)
{
/* first check the graph */
*node = node_find(graph, filename);
if(*node)
return 1;
/* then check the file system */
*timestamp = file_timestamp(filename);
if(*timestamp && file_isregular(filename))
return 1;
return 0;
}
/**
* fen_add
*
* Won't hold a ref, we have a timout callback to clean unused node_t.
* If there is no value for a key, add it and return it; else return the old
* one.
*/
void
fen_add (const gchar *filename, gpointer sub, gboolean is_mondir)
{
node_t* f;
g_assert (filename);
g_assert (sub);
G_LOCK (fen_lock);
f = node_find(NULL, filename, TRUE);
FH_W ("%s 0x%p sub[0x%p] %s\n", __func__, f, sub, filename);
g_assert (f);
/* Update timestamp, the events in global queue will compare itself to this
* timestamp to decide if be emitted. TODO, timestamp should be per sub.
*/
if (!NODE_IS_ACTIVE(f)) {
g_get_current_time(&f->atv);
}
if (is_mondir) {
f->dir_subs = g_list_prepend(f->dir_subs, sub);
} else {
f->subs = g_list_prepend(f->subs, sub);
}
if (NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED) ||
(node_lstat(f) == 0 && port_add(f) == 0)) {
#ifndef GIO_COMPILATION
gam_server_emit_one_event (NODE_NAME(f),
gam_subscription_is_dir (sub), GAMIN_EVENT_EXISTS, sub, 1);
#endif
if (is_mondir) {
scan_children_init (f, sub);
}
} else {
#ifndef GIO_COMPILATION
gam_server_emit_one_event (NODE_NAME(f),
gam_subscription_is_dir (sub), GAMIN_EVENT_DELETED, sub, 1);
#endif
node_adjust_deleted (f);
}
#ifndef GIO_COMPILATION
gam_server_emit_one_event (NODE_NAME(f),
gam_subscription_is_dir (sub), GAMIN_EVENT_ENDEXISTS, sub, 1);
#endif
G_UNLOCK (fen_lock);
}
/* nodeexist(string nodename) */
int lf_nodeexist(struct lua_State *L)
{
struct NODE *node;
if(lua_gettop(L) != 1)
luaL_error(L, "nodeexists: takes exactly one argument");
luaL_checktype(L, 1, LUA_TSTRING);
node = node_find(context_get_pointer(L)->graph, lua_tostring(L,1));
if(!node)
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
static void xmlrpc_config_ready(void *vptr)
{
/* Note: handle_xmlrpc.path may point to freed memory between
* reading the config and here.
*/
handle_xmlrpc.path = xmlrpc_config.path;
if (handle_xmlrpc.handler != NULL)
{
if (node_find(&handle_xmlrpc, httpd_path_handlers))
return;
node_add(&handle_xmlrpc, node_create(), httpd_path_handlers);
}
else
slog(LG_ERROR, "xmlrpc_config_ready(): xmlrpc {} block missing or invalid");
}
static NODE *node_inc(char *call, char *alias)
{
NODE *node;
node = node_find(call);
if (!node)
{
node = zallocw(sizeof(NODE));
sl_ins_hd(node, node_hd);
node->call = strdup(call);
node->alias = strdup(alias);
}
node->refcnt++;
return node;
}
static void makelinks(void)
{
LINK *link;
rtrun = true;
// Make the links.
for (link = link_hd; link; link = link->next)
{
// Is this link already established?
if (link->flags & (p_linked | p_linkini)) continue;
// Already linked through some other node?
// If so, making this link would create a loop.
if (node_find(link->call)) continue;
// Fire up the process to handle this link.
link->flags = p_linkini;
pcreate("RT", RT_STACK, link_out, PR_LINK, link);
}
}
void _moddeinit(void)
{
node_t *n;
xmlrpc_unregister_method("atheme.login");
xmlrpc_unregister_method("atheme.logout");
xmlrpc_unregister_method("atheme.command");
if ((n = node_find(&handle_xmlrpc, httpd_path_handlers)) != NULL)
{
node_del(n, httpd_path_handlers);
node_free(n);
}
del_conf_item("PATH", &conf_xmlrpc_table);
del_top_conf("XMLRPC");
free(xmlrpc_config.path);
hook_del_config_ready(xmlrpc_config_ready);
}
/* default_target(string filename) */
int lf_default_target(lua_State *L)
{
struct NODE *node;
struct CONTEXT *context;
int n = lua_gettop(L);
if(n != 1)
luaL_error(L, "default_target: incorrect number of arguments");
luaL_checktype(L, 1, LUA_TSTRING);
/* fetch context from lua */
context = context_get_pointer(L);
/* search for the node */
node = node_find(context->graph, lua_tostring(L,1));
if(!node)
luaL_error(L, "default_target: node '%s' not found", lua_tostring(L,1));
/* set target */
context_default_target(context, node);
return 0;
}
static
int node_find_impl( mxml_node *n, const mxml_char_t * path, LIST_TYPE lst )
{
#define TMP_LIST_INIT_SIZE 32
size_t length = 0;
list_type tmp_list;
list_init( &tmp_list, TMP_LIST_INIT_SIZE );
#undef TMP_LIST_INIT_SIZE
if ( match_nodes( path, &length, n, &tmp_list ) == 0 )
{
size_t ii = 0;
if ( length != 0 )
{
for ( ii = 0; ii < tmp_list.count; ++ii )
{
node_find( tmp_list.items[ ii ], path + length + 1, lst );
}
list_free( &tmp_list );
return 0;
}
else
{
for ( ii = 0; ii < tmp_list.count; ++ii )
lst->items[ lst->count + ii ] = tmp_list.items[ ii ];
lst->count += tmp_list.count;
list_free( &tmp_list );
return 0;
}
}
list_free( &tmp_list );
return -1;
}
int lf_set_filter(struct lua_State *L)
{
struct NODE *node;
const char *str;
size_t len;
/* check the arguments */
if(lua_gettop(L) < 2)
luaL_error(L, "set_filter: too few arguments");
luaL_checktype(L, 1, LUA_TSTRING);
luaL_checktype(L, 2, LUA_TSTRING);
/* find the node */
node = node_find(context_get_pointer(L)->graph, lua_tostring(L,1));
if(!node)
luaL_error(L, "set_filter: couldn't find node with name '%s'", lua_tostring(L,1));
/* setup the string */
str = lua_tolstring(L, 2, &len);
node->job->filter = (char *)mem_allocate(node->graph->heap, len+1);
memcpy(node->job->filter, str, len+1);
return 0;
}
int trie_check(TRIE **head,char *str) {
TRIE *t = *head;
int index = 0;
while(*str) {
TRIE *l = node_find(t,str,&index);
if(l && index == strlen(l->str)) {
str += index;
if(*str) {
t = l->son;
} else {
t = l;
break;
}
} else {
t = NULL;
break;
}
}
if(t) {
return t->isEmail;
} else {
return false;
}
}
/* add_dependency(string node, string dependency) */
static int add_node_attribute(lua_State *L, const char *funcname, struct NODE *(*callback)(struct NODE*, const char *))
{
struct NODE *node;
struct CONTEXT *context;
int n = lua_gettop(L);
struct NODEATTRIB_CBINFO cbinfo;
if(n < 2)
luaL_error(L, "%s: to few arguments", funcname);
luaL_checktype(L, 1, LUA_TSTRING);
context = context_get_pointer(L);
node = node_find(context->graph, lua_tostring(L,1));
if(!node)
luaL_error(L, "%s: couldn't find node with name '%s'", funcname, lua_tostring(L,1));
/* seek deps */
cbinfo.node = node;
cbinfo.callback = callback;
deep_walk(L, 2, n, callback_node_attrib, &cbinfo);
return 0;
}
static void chkctl(CIRCUIT *ckt_from)
{
NODE *node, *ln;
CIRCUIT *ckt_to;
USER *user, *su;
char *ncall, *ucall, *f1, *f2, *buf;
if (ckt_from->buf[FORMAT_O] != FORMAT) return; // Not a control message.
buf = strdup(ckt_from->buf + DATA_O);
// FORMAT and TYPE bytes are followed by node and user callsigns.
ncall = buf;
ucall = strlop(buf, ' ');
if (!ucall) { free(buf); return; } // Not a control message.
// There may be at least one field after the node and user callsigns.
// Node leave (id_unlink) has no F1.
f1 = strlop(ucall, ' ');
// If the frame came from an unknown node ignore it.
// If the frame came from us ignore it (loop breaking).
node = node_find(ncall);
if (!node || matchi(ncall, Node->calls)) { free(buf); return; }
switch(ckt_from->buf[TYPE_O])
{
// Data from user ucall at node ncall.
case id_data :
user = user_find(ucall);
if (!user) break;
text_tellu(user, f1, NULL, o_topic);
for (ckt_to = circuit_hd; ckt_to; ckt_to = ckt_to->next)
if ((ckt_to->flags & p_linked) &&
ckt_to->refcnt &&
!cn_find(ckt_to, node) &&
ct_find(ckt_to, user->topic)) nprintf(ckt_to->s, "%s\n", ckt_from->buf);
break;
// User ucall at node ncall changed their Name/QTH info.
case id_user :
echo(ckt_from, node); // Relay to other nodes.
user = user_find(ucall);
if (!user) break;
f2 = strlop(f1, ' ');
if (!f2) break;
strnew(&user->name, f1);
strnew(&user->qth, f2);
upduser(user);
break;
// User ucall logged into node ncall.
case id_join :
echo(ckt_from, node); // Relay to other nodes.
f2 = strlop(f1, ' ');
if (!f2) break;
user = user_join(ckt_from, ucall, ncall, NULL);
if (!user) break;
ckt_from->refcnt++;
text_tellu(user, rtjoin, NULL, o_all);
strnew(&user->name, f1);
strnew(&user->qth, f2);
upduser(user);
break;
// User ucall logged out of node ncall.
case id_leave :
echo(ckt_from, node); // Relay to other nodes.
user = user_find(ucall);
if (!user) break;
f2 = strlop(f1, ' ');
if (!f2) break;
text_tellu(user, rtleave, NULL, o_all);
ckt_from->refcnt--;
cn_dec(ckt_from, node);
strnew(&user->name, f1);
strnew(&user->qth, f2);
upduser(user);
user_leave(user);
break;
// Node ncall lost its link to node ucall, alias f1.
case id_unlink :
echo(ckt_from, node); // Relay to other nodes.
ln = node_find(ucall);
if (ln) cn_dec(ckt_from, ln);
break;
// Node ncall acquired a link to node ucall, alias f1.
// If we are not linked, is no problem, don't link.
// If we are linked, is a loop, do what?
case id_link :
echo(ckt_from, node); // Relay to other nodes.
ln = node_find(ucall);
if (!ln && !matchi(ncall, Node->calls)) cn_inc(ckt_from, ucall, f1);
break;
// User ucall at node ncall sent f2 to user f1.
case id_send :
user = user_find(ucall);
if (!user) break;
f2 = strlop(f1, ' ');
if (!f2) break;
su = user_find(f1);
if (!su) break;
if (su->circuit->flags & p_user)
text_tellu(user, f2, f1, o_one);
else
echo(ckt_from, node); // Relay to other nodes.
break;
// User ucall at node ncall changed topic.
case id_topic :
echo(ckt_from, node); // Relay to other nodes.
user = user_find(ucall);
if (user) topic_chg(user, f1);
break;
default : break;
}
free(buf);
}
void buckets_finalize_migration(client_t *client, hash_t hashmask, int level, conninfo_t *conninfo)
{
bucket_t *bucket;
assert(_mask > 0 && (hashmask >= 0 && hashmask <= _mask));
assert(client);
assert(level == 0 || level == 1);
assert(conninfo);
// ** some of these valumes should be checked at runtime
bucket = _buckets[hashmask];
assert(bucket);
assert(bucket->hashmask == hashmask);
assert(bucket->level < 0);
assert(bucket->source_node == NULL);
assert(bucket->backup_node == NULL);
assert(data_in_transit() == 0);
assert(bucket->transfer_event == NULL);
assert(_bucket_transfer);
assert(bucket->transfer_client == client);
assert(client);
assert(client->node);
logger(LOG_DEBUG, "Removing transfer client ('%s') from bucket %#llx.", node_name(client->node), bucket->hashmask);
bucket->transfer_client = NULL;
// mark the bucket as ready for action.
bucket->level = level;
if (level == 0) {
// we are receiving a primary bucket.
if (conninfo) {
assert(bucket->backup_node == NULL);
bucket->backup_node = node_find(conninfo);
assert(bucket->backup_node);
assert(bucket->backup_node->client);
}
else {
assert(bucket->backup_node == NULL);
}
assert(bucket->source_node == NULL);
// if level is -1 then indicates bucket is not here. bucket is here.
assert(bucket->level >= 0);
// indicates buckets is hosted here if level is not -1.
bucket->primary_node = NULL;
_primary_buckets ++;
assert(_primary_buckets > 0);
}
else {
// we are receiving a backup bucket.
assert(conninfo);
logger(LOG_DEBUG, "Setting source_node [%d]", __LINE__);
bucket->source_node = node_find(conninfo);
assert(bucket->source_node);
assert(bucket->source_node->client);
// if level is -1 then indicates bucket is not here. bucket is here.
assert(bucket->level >= 0);
// setting this to NULL while level is not -1 indicates that the bucket is here.
bucket->secondary_node = NULL;
// we should be connected to this other node.
assert(bucket->backup_node == NULL);
_secondary_buckets ++;
assert(_secondary_buckets > 0);
}
}
/* ---------------------------------
* brief : check if pdata is in set
* return : find 1, not find 0
* --------------------------------- */
int set_in(Set *st, void *pdata) {
if (node_find(st->rb, pdata) != NULL) return 1;
return 0;
}
int trie_add(TRIE **head,char *str) {
TRIE *t = *head;
int index=0,len1;
char *pstr;
while(*str) {
TRIE *l =node_find(t,str,&index);
if(l) { /*exist the same header string.OK divided it.*/
len1 = strlen(l->str);
if(index < len1) { /*divied it*/
/*find the end of list*/
TRIE *tp = l->son,*temp,*q;
/*new a sub node*/
temp =(TRIE *)malloc(sizeof(TRIE));
temp->isEmail = l->isEmail;
q = temp;
pstr = l->str;
pstr += index;
q->str = (char *)malloc(strlen(pstr)+1);
strcpy(q->str,pstr);
q->bro= q->son = NULL;
if(tp) {
q->son = tp;
}
/*redirect the node*/
l->son = temp;
/*change l->cNode*/
l->str[index] = '\0';
l->isEmail = false;
/*move t*/
t = l->son;
str += index;
} else if(index == len1) { /*l->cNode is short*/
str += index;
if(!l->son) {
l->son = (TRIE *)malloc(sizeof(TRIE));
l->son->isEmail = false;
l->son->son = l->son->bro = NULL;
l->son->str = (char *)malloc(strlen(str)+1);
strcpy(l->son->str,str);
t = l->son;
break;
}
if(*str) {
t = l->son;
} else {
t = l;
}
}
} else { /*new*/
TRIE *p,*q=NULL;
if(t) {
if(!t->bro) {
t->bro = (TRIE *)malloc(sizeof(TRIE));
t->bro->son = t->bro->bro = NULL;
t->bro->str = NULL;
q = t->bro ;
} else {
q = p = t;
while(p) {
q = p;
p = p->bro;
}
q->bro = (TRIE *)malloc(sizeof(TRIE));
q = q->bro;
q->str = NULL;
}
} else {
*head = (TRIE *)malloc(sizeof(TRIE));
(*head)->str = NULL;
(*head)->son = (*head)->bro = NULL;
q = (*head);
}
if(q->str) {
free(q->str);
q->str = NULL;
}
q->str = (char *)malloc(strlen(str)+1);
strcpy(q->str,str);
t = q;
break;
}
}
t->isEmail = true;
return 0;
}
static int bam_setup(struct CONTEXT *context, const char *scriptfile, const char **targets, int num_targets)
{
/* */
if(session.verbose)
printf("%s: setup started\n", session.name);
/* set filename */
context->filename = scriptfile;
/* set global timestamp to the script file */
context->globaltimestamp = file_timestamp(scriptfile);
/* */
context->forced = option_force;
/* fetch script directory */
{
char cwd[MAX_PATH_LENGTH];
char path[MAX_PATH_LENGTH];
if(!getcwd(cwd, sizeof(cwd)))
{
printf("%s: error: couldn't get current working directory\n", session.name);
return -1;
}
if(path_directory(context->filename, path, sizeof(path)))
{
printf("%s: error: path too long '%s'\n", session.name, path);
return -1;
}
if(path_join(cwd, -1, path, -1, context->script_directory, sizeof(context->script_directory)))
{
printf("%s: error: path too long when joining '%s' and '%s'\n", session.name, cwd, path);
return -1;
}
}
/* register all functions */
event_begin(0, "lua setup", NULL);
if(register_lua_globals(context->lua, context->script_directory, context->filename) != 0)
{
printf("%s: error: registering of lua functions failed\n", session.name);
return -1;
}
event_end(0, "lua setup", NULL);
/* load script */
if(session.verbose)
printf("%s: reading script from '%s'\n", session.name, scriptfile);
event_begin(0, "script load", NULL);
/* push error function to stack and load the script */
lua_getglobal(context->lua, "errorfunc");
switch(luaL_loadfile(context->lua, scriptfile))
{
case 0: break;
case LUA_ERRSYNTAX:
lf_errorfunc(context->lua);
return -1;
case LUA_ERRMEM:
printf("%s: memory allocation error\n", session.name);
return -1;
case LUA_ERRFILE:
printf("%s: error opening '%s'\n", session.name, scriptfile);
return -1;
default:
printf("%s: unknown error\n", session.name);
return -1;
}
event_end(0, "script load", NULL);
/* start the background stat thread */
node_graph_start_statthread(context->graph);
/* call the code chunk */
event_begin(0, "script run", NULL);
if(lua_pcall(context->lua, 0, LUA_MULTRET, -2) != 0)
{
node_graph_end_statthread(context->graph);
printf("%s: script error (-t for more detail)\n", session.name);
return -1;
}
event_end(0, "script run", NULL);
/* stop the background stat thread */
event_begin(0, "stat", NULL);
node_graph_end_statthread(context->graph);
event_end(0, "stat", NULL);
/* run deferred functions */
event_begin(0, "deferred cpp dependencies", NULL);
if(run_deferred_functions(context, context->firstdeferred_cpp) != 0)
return -1;
event_end(0, "deferred cpp dependencies", NULL);
event_begin(0, "deferred search dependencies", NULL);
if(run_deferred_functions(context, context->firstdeferred_search) != 0)
return -1;
event_end(0, "deferred search dependencies", NULL);
/* */
if(session.verbose)
printf("%s: making build target\n", session.name);
/* make build target */
{
struct NODE *node;
int all_target = 0;
int i;
if(node_create(&context->target, context->graph, "_bam_buildtarget", NULL, TIMESTAMP_PSEUDO))
return -1;
if(num_targets)
{
/* search for all target */
for(i = 0; i < num_targets; i++)
{
if(strcmp(targets[i], "all") == 0)
{
all_target = 1;
break;
}
}
}
/* default too all if we have no targets or default target */
if(num_targets == 0 && !context->defaulttarget)
all_target = 1;
if(all_target)
{
/* build the all target */
for(node = context->graph->first; node; node = node->next)
{
if(node->firstparent == NULL && node != context->target)
{
if(!node_add_dependency (context->target, node))
return -1;
}
}
}
else
{
if(num_targets)
{
for(i = 0; i < num_targets; i++)
{
struct NODE *node = node_find(context->graph, targets[i]);
if(!node)
{
printf("%s: target '%s' not found\n", session.name, targets[i]);
return -1;
}
if(option_dependent)
{
/* TODO: this should perhaps do a reverse walk up in the tree to
find all dependent node with commandline */
struct NODELINK *parent;
for(parent = node->firstparent; parent; parent = parent->next)
{
if(!node_add_dependency (context->target, parent->node))
return -1;
}
}
else
{
if(!node_add_dependency (context->target, node))
return -1;
}
}
}
else
{
if(!node_add_dependency (context->target, context->defaulttarget))
return -1;
}
}
}
/* zero out the global timestamp if we don't want to use it */
if(option_no_scripttimestamp)
context->globaltimestamp = 0;
/* */
if(session.verbose)
printf("%s: setup done\n", session.name);
/* return success */
return 0;
}
bool node_contains(node_t **n, int value)
{
return *node_find(n, value) != NULL;
}
