static void
becon_free(becon_t * bc, int close)
{
if (bc) {
if (close) {
pthread_mutex_lock(bc->c_lock);
if (bc->con != 0)
bc->close(bc->con);
bc->con = 0;
pthread_mutex_unlock(bc->c_lock);
/*
* can't be locked when destroyed
*/
pthread_mutex_destroy(bc->c_lock);
Free(bc->c_lock);
}
if (bc->arg)
oct_free(bc->arg);
Free(bc);
}
}
int join_cell( int icell ) {
int i;
cart_assert( icell >= 0 && icell < num_cells );
if ( cell_is_leaf(icell) ) {
cart_debug("ERROR: called join_cell(%u) on a leaf", icell );
return -1;
}
cart_assert( cell_child_oct[icell] != NULL_OCT );
cart_assert( oct_level[cell_child_oct[icell]] != FREE_OCT_LEVEL );
#ifdef PARTICLES
join_particle_list(icell);
#endif /* PARTICLES */
#ifdef HYDRO_TRACERS
join_tracer_list(icell);
#endif /* HYDRO_TRACERS */
for ( i = 0; i < num_children; i++ ) {
cell_free( cell_child( icell, i ) );
}
oct_free( cell_child_oct[icell] );
cell_child_oct[icell] = UNREFINED_CELL;
return 0;
}
spocp_result_t
strmatch_test(cmd_param_t * cpp, octet_t * blob)
{
octarr_t *argv = 0;
int r = SPOCP_DENIED;
octet_t *oct = 0;
if (cpp->arg == 0 || cpp->arg->len == 0)
return SPOCP_MISSING_ARG;
oct = element_atom_sub(cpp->arg, cpp->x);
if (oct) { /* simple substitutions was OK */
argv = oct_split(oct, ':', 0, 0, 0);
if (argv->n >= 2) {
if (octcmp(argv->arr[0], argv->arr[1]) == 0)
r = SPOCP_SUCCESS;
} else
r = SPOCP_MISSING_ARG;
octarr_free(argv);
if (oct != cpp->arg)
oct_free(oct);
} /*
else {
element_t *ce[2], *cen[2];
int i, n;
octet_t *var0 = 0, *var1 = 0;
ce[0] = element_nth(cpp->x, 0);
ce[1] = element_nth(cpp->x, 1);
if ((n = element_size(ce[0])) == element_size(ce[1])) {
for (i = 0; i < n; i++) {
cen[0] = element_nth(ce[0], i);
cen[1] = element_nth(ce[1], i);
if (element_type(cen[0]) == SPOC_ATOM
&& element_type(cen[1]) == SPOC_ATOM) {
var0 = element_data(cen[0]);
var1 = element_data(cen[1]);
if (octcmp(var0, var1) != 0)
break;
} else
break;
}
if (i == n)
r = SPOCP_SUCCESS;
}
}
*/
return r;
}
char *
element2str( element_t *e )
{
octet_t *o;
char *tmp;
o = oct_new( 512, NULL);
element_print( o, e );
tmp = oct2strdup(o, 0);
oct_free(o);
return tmp;
}
static void
bcspec_free(bcspec_t * bcs)
{
if (bcs) {
if (bcs->name)
Free(bcs->name);
if (bcs->args)
octarr_free(bcs->args);
if (bcs->spec)
oct_free(bcs->spec);
Free(bcs);
}
}
static void
element_set_reduce( element_t *ep )
{
varr_t *va;
size_t i;
element_t *te;
#ifdef XYDEBUG
octet_t *op;
char *tmp;
op = oct_new( 512, NULL);
element_print( op, ep );
tmp = oct2strdup( op, 0 );
traceLog(LOG_DEBUG,"Reducing: [%s]", tmp );
Free( tmp );
#endif
varr_rm_dup( ep->e.set, P_element_cmp, P_element_free );
#ifdef XYDEBUG
op->len = 0;
element_print( op, ep );
tmp = oct2strdup( op, 0 );
traceLog(LOG_DEBUG, "1:st Reduction to [%s]", tmp);
Free(tmp);
#endif
va = ep->e.set;
if( va->n > 1 ) {
for( i = 0; i < va->n; i++) {
if( va->arr[i] == 0 ) continue;
te = (element_t *) va->arr[i];
va->arr[i] = element_reduce(te);
}
}
#ifdef XYDEBUG
op->len = 0;
element_print( op, ep );
tmp = oct2strdup( op, 0 );
traceLog(LOG_DEBUG, "2:nd Reduction to [%s]", tmp);
Free(tmp);
oct_free( op );
#endif
}
/*******************************************************
* cell_free
******************************************************/
void cell_free( int c )
/* purpose: frees a previously allocated cell and ensures
* no octs have neighbors pointing to it.
*/
{
int i;
cart_assert( c >= 0 && c < num_cells );
if ( cell_level(c) > min_level ) {
if ( cell_is_local(c) ) {
num_cells_per_level[ cell_level(c) ]--;
} else {
num_buffer_cells[ cell_level(c) ]--;
}
}
if ( cell_is_refined(c) ) {
for ( i = 0; i < num_children; i++ ) {
cart_assert( cell_parent_cell( cell_child(c,i) ) == c );
cart_assert( cell_is_local(c) == cell_is_local(cell_child(c,i) ) );
cell_free( cell_child( c, i ) );
}
oct_free( cell_child_oct[c] );
cell_child_oct[c] = UNREFINED_CELL;
}
#ifdef PARTICLES
cell_particle_list[c] = NULL_PARTICLE;
#endif /* PARTICLES */
#ifdef HYDRO_TRACERS
cell_tracer_list[c] = NULL_TRACER;
#endif /* HYDRO_TRACERS */
}
JNIEXPORT void JNICALL Java_org_sosy_1lab_cpachecker_util_octagon_OctWrapper_J_1free
(JNIEnv *env, jobject obj, jlong oct1){
oct_free((oct_t *)oct1);
}
int
read_rules(srv_t * srv, char *file, dbcmd_t * dbc)
{
FILE *fp;
char *sp, *tmp;
int n = 0, f = 0, r;
octet_t *op;
octarr_t *oa = 0;
ruleset_t *rs = 0, *trs, *prs;
spocp_result_t rc = SPOCP_SUCCESS;
spocp_charbuf_t *buf;
spocp_chunk_t *chunk = 0, *ck;
spocp_chunkwrap_t *cw;
spocp_ruledef_t rdef;
struct stat statbuf;
if ((fp = fopen(file, "r")) == 0) {
LOG(SPOCP_EMERG) traceLog(LOG_ERR,"couldn't open rule file \"%s\"",
file);
op = oct_new( 256, NULL);
sp = getcwd(op->val, op->size);
traceLog(LOG_ERR,"I'm in \"%s\"", sp);
oct_free(op);
return -1;
}
stat( file, &statbuf);
srv->mtime = statbuf.st_mtime;
/*
* The default ruleset should already be set
*/
if (srv->root == 0) {
srv->root = rs = ruleset_new(0);
} else
rs = srv->root;
if (rs->db == 0)
rs->db = db_new();
buf = charbuf_new( fp, BUFSIZ );
if (get_more(buf) == 0) return 0;
/*
* have to escape CR since fgets stops reading when it hits a newline
* NUL also has to be escaped since I have problem otherwise finding
* the length of the 'string'. '\' hex hex is probably going to be the
* choice
*/
while (rc == SPOCP_SUCCESS ) {
cw = get_object( buf, 0 );
if (cw->status == 0) {
Free(cw);
break;
}
else if (cw->status == -1) {
rc = SPOCP_LOCAL_ERROR;
Free(cw);
break;
}
else {
chunk = cw->chunk;
Free(cw);
}
if (oct2strcmp(chunk->val, ";include ") == 0) { /* include
* file */
ck = chunk->next;
tmp = oct2strdup( ck->val, 0 ) ;
LOG(SPOCP_DEBUG) traceLog(LOG_DEBUG,"include directive \"%s\"",
tmp);
if ((rc = read_rules(srv, tmp, dbc)) < 0) {
traceLog(LOG_ERR,"Include problem");
}
}
else if (*chunk->val->val == '/' || *chunk->val->val == '(') {
trs = rs;
if (*chunk->val->val == '/') {
#ifdef AVLUS
oct_print(LOG_INFO,"ruleset", chunk->val);
#endif
if ((trs = ruleset_find( chunk->val, rs)) == NULL) {
octet_t oct;
octln( &oct, chunk->val);
rs = ruleset_create(chunk->val, rs);
trs = ruleset_find(&oct, rs);
trs->db = db_new();
}
ck = chunk->next;
}
else {
ck = chunk;
}
ruledef_return( &rdef, ck ) ;
if( rdef.rule ) {
op = chunk2sexp( rdef.rule ) ;
oa = octarr_add(oa, op) ;
LOG(SPOCP_DEBUG) {
traceLog(LOG_DEBUG,"We've got a rule");
}
}
if( rdef.bcond) {
op = chunk2sexp( rdef.bcond ) ;
oa = octarr_add(oa, op) ;
LOG(SPOCP_DEBUG) {
traceLog(LOG_DEBUG,"We've got a boundary condition");
}
}
spocp_result_t
ldapproxy_test(cmd_param_t * cpp, octet_t * blob)
{
spocp_result_t r = SPOCP_DENIED;
LDAP *ld = 0;
becon_t *bc = 0;
octarr_t *argv;
octet_t *oct, *domain;
pdyn_t *dyn = cpp->pd;
char ***ava = 0, *tmp, *filter, *fqdn;
char *attr = 0, *val, *dn, **attrs = 0;
char *xml;
srvrec_t *sr, *nsr;
int i, j;
if (cpp->arg == 0 || cpp->arg->len == 0)
return SPOCP_MISSING_ARG;
if ((oct = element_atom_sub(cpp->arg, cpp->x)) == 0)
return SPOCP_SYNTAXERROR;
argv = oct_split( oct, ':', '\\', 0,0 );
traceLog( LOG_DEBUG,"argc: %d", argv->n);
domain = argv->arr[0];
tmp = oct2strdup( domain, 0);
fqdn = normalize(tmp);
free(tmp);
traceLog( LOG_DEBUG,"domain: %s", fqdn);
if (dyn == 0 || (bc = becon_get(domain, dyn->bcp)) == 0) {
/* find the server/-s */
if(( sr = dnssrv_lookup( fqdn, "ldap")) == 0 ) {
traceLog(LOG_DEBUG,"SRV record lookup failed");
sr = ( srvrec_t * ) calloc( 1, sizeof( srvrec_t ));
sr->srv = ( char * ) calloc( domain->len+7, sizeof( char ));
tmp = oct2strdup( domain, 0 );
snprintf(sr->srv, domain->len+6,"ldap.%s", tmp );
free( tmp );
}
for( nsr = sr ; nsr ; nsr = nsr->next ) {
/* should pick the one with the lowest priority first */
LOG(SPOCP_DEBUG)
traceLog(LOG_DEBUG, "Trying %s:%d", nsr->srv, nsr->port);
ld = open_conn(nsr->srv, nsr->port, &r);
if (ld)
break ;
}
srvrec_free( sr );
if (ld == 0)
r = SPOCP_UNAVAILABLE;
else if (dyn && dyn->size) {
if (!dyn->bcp)
dyn->bcp = becpool_new(dyn->size);
bc = becon_push(domain, &P_ldapclose, (void *) ld, dyn->bcp);
}
} else
ld = (LDAP *) bc->con;
if (r != SPOCP_UNAVAILABLE) {
/* get the baseDN */
dn = fqdn2dn( fqdn );
free( fqdn );
/* create the filter */
val = oct2strdup( argv->arr[1], 0 );
if( argv->n == 3 )
attr = oct2strdup( argv->arr[2], 0 );
else
attr = "uid";
filter = (char *)malloc( strlen(attr) + strlen(val) +4);
sprintf( filter, "(%s=%s)", attr, val );
traceLog(LOG_DEBUG, "Filter: %s, DN: %s", filter, dn);
if( cpp->conf )
attrs = match_base( (ainfo_t *) cpp->conf, dn );
if (attrs == 0)
attrs = defattrs;
/* do the stuff */
ava = do_ldap_query( ld, dn, filter, attrs, &r);
if (bc)
becon_return(bc);
else
ldap_unbind_s(ld);
free(val);
free(filter);
free(dn);
if( argv->n == 3)
free(attr);
}
/* create the blob */
if (ava) {
xml = do_xml( ava );
oct_assign( blob, xml );
blob->size = blob->len;
traceLog(LOG_DEBUG, "%s", xml);
for( i = 0; ava[i] ; i++) {
for( j = 0; ava[i][j] ; j++) free( ava[i][j] );
free( ava[i] );
}
free(ava);
}
if (oct != cpp->arg)
oct_free(oct);
return r;
}
