/* effective comparison */
int nid_cmp_effective(xptr node1, xptr node2) {
if (node1 == node2) return 0;
CHECKP(node1);
t_prefix p1 = nid_get_prefix(node1);
unsigned char* ptr1 = p1.prefix;
shft size1 = p1.size;
CHECKP(node2);
t_nid* nd = &((internal::node_base_t*)XADDR(node2))->nid;
shft size2 = nd->size;
unsigned char* ptr2=nd->prefix;
if (size2 == 0)
{
xptr ps = *(xptr*)ptr2;
size2=*(shft*)(nd->prefix+sizeof(xptr));
CHECKP(ps);
ptr2=(unsigned char*)XADDR(BLOCKXPTR(ps)) + *(shft*)XADDR(ps);
}
int result = sign(memcmp(ptr1,ptr2,min(size1,size2))); /// There is no guarantee that memcmp returns 1, -1, 0!
if (!result)
{
if (size1 > size2) {
result = (ptr1[size2] == ALPHABET_SIZE) ? 1 : 2;
} else {
result = (ptr2[size1] == ALPHABET_SIZE) ? -1 : -2;
}
}
nid_free(p1.prefix);
return result;
}
void update_insert_sequence(xptr node,schema_node_cptr icell)
{
cat_list<ft_index_cell_xptr>::item* obj=icell->ft_index_list->first;
if (obj == NULL) return;
CHECKP(node);
xptr ind=nodeGetIndirection(node);
while (obj!=NULL)
{
update_insert_sequence(ind,ft_index_cell_cptr(obj->object));
obj=obj->next;
}
CHECKP(node);
}
/*t_prefix tp;*/
void nid_delete(xptr node) {
CHECKP(node);
bool vroot = getNodeType(node) == virtual_root;
t_nid the_nid = nid_get_nid(node);
/* free the pstr contents */
if (the_nid.size==0 /*CHANGED BY LEON*/)
{
//statistics
shft nids=(*(shft*)(the_nid.prefix+sizeof(xptr)));
schema_node_cptr scm=getSchemaNode(node);
scm.modify();
scm->extnids-=nids;
if (IS_DATA_BLOCK(node))
scm->root.modify()->total_ext_nids-=nids;
xptr blk = BLOCKXPTR((*(xptr*)the_nid.prefix));
if (
pstr_do_deallocate(blk, *(xptr*)(the_nid.prefix), *(shft*)(the_nid.prefix+sizeof(xptr)), true)
&& scm->root->ext_nids_block==blk
)
scm->root.modify()->ext_nids_block=XNULL;
/*--------------------------------------------------------
>>> this is debug case when prefix is allocated just in memory
delete[] (char*)XADDR(*(xptr*)the_nid.prefix);
--------------------------------------------------------*/
}
}
void apply_after_replace_triggers(xptr new_node, xptr old_node, xptr where_var, schema_node_cptr scm_node)
{
if (tr_globals::internal_auth_switch == BLOCK_AUTH_CHECK) return;
// care about after-statement triggers
find_triggers_for_node(scm_node, TRIGGER_REPLACE_EVENT, TRIGGER_AFTER, TRIGGER_FOR_EACH_STATEMENT, &after_statement_triggers);
if (old_node==XNULL) return; //old_var==XNULL if there are no for-each-node-after-triggers
CHECKP(old_node);
//if the node is not element or attribute - return
t_item node_type = scm_node->type;
if((node_type!=element)&&(node_type!=attribute))
return;
t_triggers_set treated_triggers;
trigger_cell_cptr trc = XNULL;
while(true)
{
trc = find_trigger_for_node(scm_node, TRIGGER_REPLACE_EVENT, TRIGGER_AFTER, TRIGGER_FOR_EACH_NODE, &treated_triggers);
if(!trc.found())
return;
trc->execute_trigger_action(new_node, old_node, where_var);
treated_triggers.insert(trc.ptr());
}
}
void apply_before_replace_for_each_statement_triggers(xptr_sequence* target_seq, bool target_seq_direct)
{
t_scmnodes_set scmnodes;
t_scmnodes_set::iterator scmnodes_iter;
t_triggers_set triggers;
t_triggers_set::iterator triggers_iter;
xptr_sequence::iterator it1;
std::set<trigger_cell_xptr>::iterator set_triggers_iter;
if (tr_globals::internal_auth_switch == BLOCK_AUTH_CHECK) return;
//if there are no statement level triggers at all - return
if(!has_statement_triggers(TRIGGER_REPLACE_EVENT, TRIGGER_BEFORE)) return;
//1. create a set of schema nodes
it1=target_seq->begin();
while(it1!=target_seq->end())
{
xptr p=indirectionDereferenceCP(*it1);
CHECKP(p);
schema_node_cptr scn=getSchemaNode(p);
scmnodes.insert(scn.ptr());
it1++;
}
//2. find statement triggers on the nodes from the node set
for(scmnodes_iter=scmnodes.begin(); scmnodes_iter!=scmnodes.end(); scmnodes_iter++)
{
find_triggers_for_node(*scmnodes_iter, TRIGGER_REPLACE_EVENT, TRIGGER_BEFORE, TRIGGER_FOR_EACH_STATEMENT, &triggers);
for(triggers_iter=triggers.begin(); triggers_iter!=triggers.end(); triggers_iter++)
(*triggers_iter)->execute_trigger_action(XNULL, XNULL, XNULL);
}
}
void apply_after_insert_triggers(xptr new_var, xptr where_var, schema_node_cptr scm_node)
{
if (tr_globals::internal_auth_switch == BLOCK_AUTH_CHECK) return;
//if insert while constructor
if (IS_TMP_BLOCK(where_var)) return;
if ((new_var==XNULL)||(where_var==XNULL)) throw SYSTEM_EXCEPTION("Bad parameters");
CHECKP(new_var);
scm_node = getSchemaNode(new_var);
//if the node is not element or attribute - return
t_item node_type = getNodeType(new_var);
if((node_type!=element)&&(node_type!=attribute))
return;
// care about after-statement triggers
find_triggers_for_node(scm_node, TRIGGER_INSERT_EVENT, TRIGGER_AFTER, TRIGGER_FOR_EACH_STATEMENT, &after_statement_triggers);
t_triggers_set treated_triggers;
trigger_cell_cptr trc = XNULL;
while(true)
{
trc = find_trigger_for_node(scm_node, TRIGGER_INSERT_EVENT, TRIGGER_AFTER, TRIGGER_FOR_EACH_NODE, &treated_triggers);
if(!trc.found())
return;
trc->execute_trigger_action(new_var, XNULL, where_var);
treated_triggers.insert(trc.ptr());
}
}
void catalog_update_metadata()
{
CHECKP(catalog_masterblock);
memcpy(
&(local_catalog->masterdata),
&(((catalog_master_record *) XADDR(catalog_masterblock))->masterdata),
sizeof(catalog_name_trees));
}
void nid_assign(xptr node, t_prefix p) {
internal::node_base_t* dsc;
xptr tmp;
xptr blk;
dsc = (internal::node_base_t*)XADDR(node);
CHECKP(node);
if (p.size <= MAXINTERNALPREFIX)
{
VMM_SIGNAL_MODIFICATION(node);
memcpy(dsc->nid.prefix, p.prefix, p.size);
dsc->nid.size=(unsigned char)p.size;
}
else
{
if (p.size > PSTRMAXSIZE)
{
dsc->nid.prefix[0]=1;
dsc->nid.size=1;
moSetUserException(SE2023);
}
if (IS_DATA_BLOCK(node)) {
nid_holder=getSchemaNode(node)->root;
U_ASSERT(nid_holder != XNULL);
}
blk = nid_get_blk(p.size, IS_DATA_BLOCK(node));
tmp = pstr_do_allocate(blk, (char*) p.prefix, p.size);
/*--------------------------------------------------------
>>> this is the debug case of keeping prefix just in memory
tmp.addr = se_new char[prefix_size];
strcpy((char*)tmp.addr, prefix);
--------------------------------------------------------*/
CHECKP(node);
VMM_SIGNAL_MODIFICATION(node);
memcpy(dsc->nid.prefix, (char*)&tmp, sizeof(xptr));
*(shft*)(dsc->nid.prefix + sizeof(xptr)) = p.size;
dsc->nid.size = 0;
//statistics
getSchemaNode(node).modify()->extnids+=p.size;
if (IS_DATA_BLOCK(node))
nid_holder.modify()->total_ext_nids+=p.size;
}
}
xptr apply_before_insert_triggers(xptr new_var, xptr where_var)
{
if (tr_globals::internal_auth_switch == BLOCK_AUTH_CHECK) return new_var;
//if insert while constructor
if (IS_TMP_BLOCK(where_var)) return new_var;
if ((new_var==XNULL)||(where_var==XNULL)) throw SYSTEM_EXCEPTION("Bad parameters");
CHECKP(new_var);
const char* name=getSchemaNode(new_var)->get_name();
t_item node_type = getNodeType(new_var);
//if the node is not element or attribute - return
if((node_type!=element)&&(node_type!=attribute))
return new_var;
t_triggers_set treated_triggers;
schema_node_cptr scm_parent_node = XNULL;
CHECKP(where_var);
scm_parent_node=getSchemaNode(where_var);
trigger_cell_cptr trc = XNULL;
while(true)
{
if(scm_parent_node->find_first_child(NULL_XMLNS, name, node_type)<0)
trc = find_trigger_for_newly_inserted_node(scm_parent_node, name, node_type, &treated_triggers);
else
trc = find_trigger_for_node(scm_parent_node->get_first_child(NULL_XMLNS, name, node_type), TRIGGER_INSERT_EVENT, TRIGGER_BEFORE, TRIGGER_FOR_EACH_NODE, &treated_triggers);
if(!trc.found())
return new_var;
new_var=trc->execute_trigger_action(new_var, XNULL, where_var);
if(new_var == XNULL)
return new_var;
node_type = getNodeType(new_var);
if((node_type!=element)&&(node_type!=attribute))
return new_var;
name=getSchemaNode(new_var)->get_name();
treated_triggers.insert(trc.ptr());
}
}
int main(int argc, char** argv) {
if (getenv("RACKMOND_FOREGROUND") == NULL) {
daemon(0, 0);
}
signal(SIGPIPE, SIG_IGN);
int error = 0;
world.paused = 0;
world.modbus_timeout = 300000;
if (getenv("RACKMOND_TIMEOUT") != NULL) {
world.modbus_timeout = atoll(getenv("RACKMOND_TIMEOUT"));
fprintf(stderr, "Timeout from env: %dms\n",
(world.modbus_timeout / 1000));
}
world.config = NULL;
pthread_mutex_init(&world.lock, NULL);
verbose = getenv("RACKMOND_VERBOSE") != NULL ? 1 : 0;
openlog("rackmond", 0, LOG_USER);
syslog(LOG_INFO, "rackmon/modbus service starting");
CHECK(open_rs485_dev(DEFAULT_TTY, DEFAULT_GPIO, &world.rs485));
pthread_t monitoring_thread;
pthread_create(&monitoring_thread, NULL, monitoring_loop, NULL);
struct sockaddr_un local, client;
int sock = socket(AF_UNIX, SOCK_STREAM, 0);
strcpy(local.sun_path, "/var/run/rackmond.sock");
local.sun_family = AF_UNIX;
int socknamelen = sizeof(local.sun_family) + strlen(local.sun_path);
unlink(local.sun_path);
CHECKP(bind, bind(sock, (struct sockaddr *)&local, socknamelen));
CHECKP(listen, listen(sock, 5));
syslog(LOG_INFO, "rackmon/modbus service listening");
while(1) {
socklen_t clisocklen = sizeof(struct sockaddr_un);
int clisock = accept(sock, (struct sockaddr*) &client, &clisocklen);
CHECKP(accept, clisock);
CHECK(handle_connection(clisock));
}
cleanup:
if (error != 0) {
error = 1;
}
return error;
}
void PPFnNamespaceUriForPrefix::do_next(xqp_tuple &t)
{
if (first_time)
{
tuple_cell prefix_tc;
const char *prefix = "";
child_prefix.op->next(t);
if (!t.is_eos())
{
if (!(child_prefix.get(t).is_atomic()) || child_prefix.get(t).get_atomic_type() != xs_string)
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:namespace-uri-for-prefix function");
prefix_tc = tuple_cell::make_sure_light_atomic(child_prefix.get(t));
prefix = prefix_tc.get_str_mem();
child_prefix.op->next(t);
if (!(t.is_eos())) throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:namespace-uri-for-prefix function");
}
child_element.op->next(t);
if (t.is_eos())
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:namespace-uri-for-prefix function");
if (!child_element.get(t).is_node())
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:namespace-uri-for-prefix function");
child_element.op->next(t);
if (!(t.is_eos()))
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:namespace-uri-for-prefix function");
xptr node = child_element.get(t).get_node();
CHECKP(node);
if (getNodeType(node) != element)
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:namespace-uri-for-prefix function");
scoped_ptr<InscopeNamespaceMap> inscopeNamespaces = new InscopeNamespaceMap(node, cxt->get_static_context()->getStaticallyKnownNamespaces());
xmlns_ptr x = inscopeNamespaces->resolvePrefix(prefix);
if (x != NULL_XMLNS) {
t.copy(tuple_cell::atomic_deep(xs_anyURI, x->get_uri()));
first_time = false;
return;
} else if (*prefix == '\0') {
// For default prefix we should always return some value.
t.copy(EMPTY_STRING_TC);
first_time = false;
return;
}
}
first_time = true;
t.set_eos();
}
xptr triggers_test(xptr new_var, xptr where_var, const char* name, t_item node_type)
{
if(name==NULL)
{
name=getSchemaNode(new_var)->get_name();
CHECKP(where_var);
name=getSchemaNode(new_var)->get_name();
node_type = getNodeType(new_var);
}
return new_var;
}
/*
* Get nid of node descriptor "dsc" uploading native block of this descriptor
*/
t_nid
nid_get_nid(xptr node) {
t_nid result;
internal::node_base_t* dsc;
CHECKP(node);
/* dsc now points to descriptor inside in-memory block */
dsc = (internal::node_base_t*)XADDR(node);
result = dsc->nid;
return result;
}
/*
initialize the node descriptor with given nid (prefix, dc)
blk is the block where to store prefix string
*/
void nid_assign_pers_data(xptr node,char* data,int size)
{
xptr blk = nid_get_blk(size, true);
xptr tmp = pstr_do_allocate(blk, data, size);
CHECKP(node);
internal::node_base_t* dsc=(internal::node_base_t*)XADDR(node);
VMM_SIGNAL_MODIFICATION(node);
memcpy(dsc->nid.prefix, (char*)&tmp, sizeof(xptr));
*(shft*)(dsc->nid.prefix + sizeof(xptr)) = size;
dsc->nid.size = 0;
}
xptr xptr_sequence::get(int pos)
{
if (pos < SEQ_NUMBER_OF_XPTRS_IN_MEMORY) return mem_xptrs[pos];
int b_ind = (pos - SEQ_NUMBER_OF_XPTRS_IN_MEMORY) / XPTRS_IN_BLOCK;
int o_ind = (pos - SEQ_NUMBER_OF_XPTRS_IN_MEMORY) % XPTRS_IN_BLOCK;
xptr p = blk_arr[b_ind] + sizeof(seq_blk_hdr) + o_ind * sizeof(xptr);
CHECKP(p);
return *(xptr*)(XADDR(p));
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
const char *format_data = "data BIT in1 3 4\n";
int fd, n, error, r = 0;
DIRFILE *D;
gd_entry_t E;
rmdirfile();
mkdir(filedir, 0777);
fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);
write(fd, format_data, strlen(format_data));
close(fd);
D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);
n = gd_entry(D, "data", &E);
error = gd_error(D);
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_OK);
CHECKI(n, 0);
CHECKS(E.field, "data");
CHECKI(E.field_type, GD_BIT_ENTRY);
CHECKS(E.in_fields[0], "in1");
CHECKI(E.EN(bit,bitnum), 3);
CHECKI(E.EN(bit,numbits), 4);
CHECKP(E.scalar[0]);
CHECKP(E.scalar[1]);
gd_free_entry_strings(&E);
return r;
}
static
xptr get_root (xptr node)
{
CHECKP(node);
xptr tmp=node;
while (true)
{
xptr parent = nodeGetParent(tmp);
if (parent == XNULL) {
return tmp;
}
tmp = parent;
}
}
int main(void)
{
const char *filedir = "dirfile";
const char *format = "dirfile/format";
int error, r = 0;
DIRFILE *D;
gd_entry_t E, e;
E.field = "data";
E.field_type = GD_LINCOM_ENTRY;
E.fragment_index = 0;
E.EN(lincom,n_fields) = 1;
E.comp_scal = 0;
E.in_fields[0] = "INDEX";
E.EN(lincom,m)[0] = 1.;
E.scalar[0] = NULL;
E.scalar[0 + GD_MAX_LINCOM] = "c";
E.scalar_ind[0 + GD_MAX_LINCOM] = 3;
rmdirfile();
D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);
gd_add_spec(D, "c CARRAY INT64 1 2 3 4", 0);
gd_add(D, &E);
error = gd_error(D);
/* check */
gd_entry(D, "data", &e);
if (gd_error(D))
r = 1;
else {
CHECKI(e.field_type, GD_LINCOM_ENTRY);
CHECKI(e.fragment_index, 0);
CHECKI(e.EN(lincom,n_fields), 1);
CHECKF(e.EN(lincom,m)[0], 1);
CHECKF(e.EN(lincom,b)[0], 4);
CHECKP(e.scalar[0]);
CHECKS(e.scalar[0 + GD_MAX_LINCOM], "c");
CHECKI(e.scalar_ind[0 + GD_MAX_LINCOM], 3);
gd_free_entry_strings(&e);
}
gd_close(D);
unlink(format);
rmdir(filedir);
CHECKI(error, GD_E_OK);
return r;
}
void init_ft_sequences (const xptr& left, const xptr& right, const xptr& parent)
{
if (IS_TMP_BLOCK(left)||IS_TMP_BLOCK(right)||IS_TMP_BLOCK(parent)) return;
xptr tmp;
schema_node_cptr scn = XNULL;
if (parent!=XNULL)
{
tmp=parent;
CHECKP(parent);
scn = getSchemaNode(parent);
}
else
{
tmp=(left==XNULL)?right:left;
CHECKP(tmp);
scn = getSchemaNode(tmp)->parent;
}
if (scn->root == scn.ptr() || scn->root->full_ft_index_list->empty()) return;
while (scn.found())
{
cat_list<ft_index_cell_xptr>::item* obj=scn->ft_index_list->first;
if (obj!=NULL)
{
tmp=getNodeAncestorIndirectionByScheme(tmp,scn);
while (obj!=NULL)
{
update_update_sequence(tmp,ft_index_cell_cptr(obj->object));
obj=obj->next;
}
tmp=indirectionDereferenceCP(tmp);
}
scn=scn->parent;
}
}
void xptr_sequence::add(const xptr &p)
{
if (seq_size++ < SEQ_NUMBER_OF_XPTRS_IN_MEMORY)
{
mem_xptrs.push_back(p);
return;
}
if (eblk == XNULL) init_blks();
CHECKP(eblk);
// Allocate new block?
if (SEQ_BLK_FREE_SPACE(XADDR(eblk)) < sizeof(xptr))
{
xptr new_blk;
vmm_alloc_tmp_block(&new_blk);
seq_blk_hdr::init(XADDR(new_blk));
blks_num++;
blk_arr.push_back(new_blk);
CHECKP(eblk);
VMM_SIGNAL_MODIFICATION(eblk);
SEQ_BLK_HDR(eblk)->nblk = new_blk;
eblk = new_blk;
CHECKP(eblk);
}
xptr* dest_xptr = (xptr*)(SEQ_BLK_CURSOR(XADDR(eblk)));
VMM_SIGNAL_MODIFICATION(eblk);
*dest_xptr = p;
SEQ_BLK_HDR(eblk)->cursor += sizeof(xptr);
}
bool nid_parse(const xptr nid, xptr * prefix, shft * size) {
CHECKP(nid);
const t_nid * tnid = (t_nid *) XADDR(nid);
const unsigned char sz = tnid->size;
if (sz == 0) {
*size = *(shft*) ((tnid->prefix) + sizeof(xptr));
*prefix = pstrderef(checkp(*(xptr*) (tnid->prefix)));
return true;
} else {
*prefix = nid;
*size = sz;
return false;
}
}
void xptr_sequence::set(const xptr& p, int pos)
{
if (pos < SEQ_NUMBER_OF_XPTRS_IN_MEMORY)
{
mem_xptrs[pos] = p;
return;
}
int b_ind = (pos - SEQ_NUMBER_OF_XPTRS_IN_MEMORY) / XPTRS_IN_BLOCK;
int o_ind = (pos - SEQ_NUMBER_OF_XPTRS_IN_MEMORY) % XPTRS_IN_BLOCK;
xptr pp = blk_arr[b_ind] + sizeof(seq_blk_hdr) + o_ind * sizeof(xptr);
CHECKP(pp);
VMM_SIGNAL_MODIFICATION(pp);
*(xptr*)(XADDR(pp)) = p;
}
void PPFnResolveQName::do_next(xqp_tuple &t)
{
if (first_time)
{
child_qname.op->next(t);
if (t.is_eos())
return;
first_time = false;
tuple_cell qname_tc = atomize(child_qname.get(t));
if (!is_string_type(qname_tc.get_atomic_type())) {
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong first argument of fn:resolve-QName function");
}
child_qname.op->next(t);
if (!(t.is_eos())) {
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong first argument of fn:resolve-QName function");
}
qname_tc = tuple_cell::make_sure_light_atomic(qname_tc);
child_elem.op->next(t);
if (t.is_eos() || !child_elem.get(t).is_node()) {
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong second argument of fn:resolve-QName function");
}
xptr node = child_elem.get(t).get_node();
child_elem.op->next(t);
if (!(t.is_eos())) {
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong second argument of fn:resolve-QName function");
}
CHECKP(node);
if (getNodeType(node) != element)
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong second argument of fn:resolve-QName function");
scoped_ptr<InscopeNamespaceMap> inscopeNamespaces = new InscopeNamespaceMap(node, cxt->get_static_context()->getStaticallyKnownNamespaces());
t.copy(tuple_cell::atomic(xsd::QName::createResolve(qname_tc.get_str_mem(), inscopeNamespaces.get())));
}
else
{
first_time = true;
t.set_eos();
}
}
int main(void)
{
const char *filedir = "dirfile";
int error, r = 0;
DIRFILE *D;
const char **fl;
rmdirfile();
D = gd_open(filedir, GD_RDONLY);
fl = gd_strings(D);
error = gd_error(D);
gd_close(D);
CHECKP(fl);
CHECKI(error,GD_E_BAD_DIRFILE);
return r;
}
void PPFnInScopePrefixes::do_next (xqp_tuple &t)
{
if (pos < 0)
{
child.op->next(t);
if (t.is_eos())
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function");
if (!child.get(t).is_node())
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function");
xptr node = child.get(t).get_node();
child.op->next(t);
if (!(t.is_eos()))
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function");
CHECKP(node);
if (getNodeType(node) != element)
throw XQUERY_EXCEPTION2(XPTY0004, "Wrong argument of fn:in-scope-prefixes function");
namespaces = new InscopeNamespaceIterator(node, cxt->get_static_context()->getStaticallyKnownNamespaces());
pos = 0;
}
if (namespaces->next())
{
xmlns_ptr ns = namespaces->get();
if (ns->has_prefix())
t.copy(tuple_cell::atomic_deep(xs_NCName, ns->prefix));
else
t.copy(EMPTY_STRING_TC);
}
else
{
t.set_eos();
pos = -1;
delete namespaces;
namespaces = NULL;
}
}
int main(void)
{
const char *filedir = "dirfile";
int error, r = 0;
DIRFILE *D;
const void *fl;
rmdirfile();
D = gd_open(filedir, GD_RDONLY);
fl = gd_mconstants(D, "parent", GD_UINT8);
error = gd_error(D);
gd_close(D);
CHECKP(fl);
CHECKI(error, GD_E_BAD_DIRFILE);
return r;
}
int main(void)
{
const char *filedir = "dirfile";
int error, r = 0;
DIRFILE *D;
const char **fl;
rmdirfile();
D = gd_open(filedir, GD_RDONLY);
fl = gd_field_list_by_type(D, GD_STRING_ENTRY);
error = gd_error(D);
gd_close(D);
CHECKP(fl);
CHECKI(error, GD_E_BAD_DIRFILE);
return r;
}
void test_db_after_rcv()
{
std::string rcv_fname = std::string(SEDNA_DATA) + std::string("/data/") + std::string(tr_globals::db_name) + std::string("_files/rcv_test_result.log");
metadata_cell_cptr mdc = XNULL;
logfile = fopen(rcv_fname.c_str(), "at");
fprintf(logfile, "---------------------------------------------------------------------\n");
bt_cursor cursor = bt_lm(catalog_get_names(catobj_metadata));
if (!cursor.is_null()) do
{
mdc = cursor.bt_next_obj();
if (!mdc->is_document())
test_collection(mdc->get_name(), mdc->get_schema_node());
else
{
xptr blk = mdc->get_schema_node()->bblk;
CHECKP(blk);
xptr doc_dsc = getFirstBlockNode(blk);
test_document(mdc->get_name(), doc_dsc, false);
test_indexes(doc_schema_node_cptr(mdc->get_schema_node())->full_index_list->first);
}
}
while(cursor.bt_next_key());
fclose(logfile);
#ifdef RCV_TEST_CRASH
rcv_fname = std::string(SEDNA_DATA) + std::string("/data/") + std::string(tr_globals::db_name) + std::string("_files");
if (isRcvOK)
rcv_fname += std::string("/rcv_ok");
else
rcv_fname += std::string("/rcv_failed");
r_fh = uCreateFile(rcv_fname.c_str(), U_SHARE_READ | U_SHARE_WRITE, U_READ_WRITE, U_NO_BUFFERING, NULL, NULL);
if (r_fh == U_INVALID_FD)
fprintf(stderr, "Cannot create rcv result file\n");
uCloseFile(r_fh, NULL);
#endif
}
// receive the command as a length prefixed block
// (uint16_t, followed by data)
// this is all over a local socket, won't be doing
// endian flipping, clients should only be local procs
// compiled for the same arch
int handle_connection(int sock) {
int error = 0;
rackmond_connection_state state = CONN_WAITING_LENGTH;
char bodybuf[1024];
uint16_t expected_len = 0;
struct pollfd pfd;
int recvret = 0;
pfd.fd = sock;
pfd.events = POLLIN | POLLERR | POLLHUP;
// if you don't do anything for a whole second we bail
next:
CHECKP(poll, poll(&pfd, 1, 1000));
if (pfd.revents & (POLLERR | POLLHUP)) {
goto cleanup;
}
switch(state) {
case CONN_WAITING_LENGTH:
recvret = recv(sock, &expected_len, 2, MSG_DONTWAIT);
if (recvret == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
goto next;
}
if (expected_len == 0 || expected_len > sizeof(bodybuf)) {
// bad length; bail
goto cleanup;
}
state = CONN_WAITING_BODY;
goto next;
break;
case CONN_WAITING_BODY:
recvret = recv(sock, &bodybuf, expected_len, MSG_DONTWAIT);
if (recvret == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
goto next;
}
CHECK(do_command(sock, (rackmond_command*) bodybuf));
}
cleanup:
close(sock);
if (error != 0) {
fprintf(stderr, "Warning: possible error handling user connection (%d)\n", error);
}
return 0;
}
xptr apply_before_replace_triggers(xptr new_node, xptr old_node, schema_node_cptr scm_node)
{
if (tr_globals::internal_auth_switch == BLOCK_AUTH_CHECK) return old_node;
CHECKP(old_node);
xptr parent= nodeGetParent(old_node);
t_triggers_set treated_triggers;
trigger_cell_cptr trc = XNULL;
while(true)
{
trc = find_trigger_for_node(scm_node, TRIGGER_REPLACE_EVENT, TRIGGER_BEFORE, TRIGGER_FOR_EACH_NODE, &treated_triggers);
if(!trc.found())
return new_node;
new_node = trc->execute_trigger_action(new_node, old_node, parent);
if(new_node==XNULL) return XNULL;
treated_triggers.insert(trc.ptr());
}
return new_node;
}
