int
meta_back_bind( Operation *op, SlapReply *rs )
{
metainfo_t *mi = ( metainfo_t * )op->o_bd->be_private;
metaconn_t *mc = NULL;
int rc = LDAP_OTHER,
i,
gotit = 0,
isroot = 0;
SlapReply *candidates;
rs->sr_err = LDAP_SUCCESS;
Debug( LDAP_DEBUG_ARGS, "%s meta_back_bind: dn=\"%s\".\n",
op->o_log_prefix, op->o_req_dn.bv_val );
/* the test on the bind method should be superfluous */
switch ( be_rootdn_bind( op, rs ) ) {
case LDAP_SUCCESS:
if ( META_BACK_DEFER_ROOTDN_BIND( mi ) ) {
/* frontend will return success */
return rs->sr_err;
}
isroot = 1;
/* fallthru */
case SLAP_CB_CONTINUE:
break;
default:
/* be_rootdn_bind() sent result */
return rs->sr_err;
}
/* we need meta_back_getconn() not send result even on error,
* because we want to intercept the error and make it
* invalidCredentials */
mc = meta_back_getconn( op, rs, NULL, LDAP_BACK_BIND_DONTSEND );
if ( !mc ) {
if ( LogTest( LDAP_DEBUG_ANY ) ) {
char buf[ SLAP_TEXT_BUFLEN ];
snprintf( buf, sizeof( buf ),
"meta_back_bind: no target "
"for dn \"%s\" (%d%s%s).",
op->o_req_dn.bv_val, rs->sr_err,
rs->sr_text ? ". " : "",
rs->sr_text ? rs->sr_text : "" );
Debug( LDAP_DEBUG_ANY,
"%s %s\n",
op->o_log_prefix, buf );
}
/* FIXME: there might be cases where we don't want
* to map the error onto invalidCredentials */
switch ( rs->sr_err ) {
case LDAP_NO_SUCH_OBJECT:
case LDAP_UNWILLING_TO_PERFORM:
rs->sr_err = LDAP_INVALID_CREDENTIALS;
rs->sr_text = NULL;
break;
}
send_ldap_result( op, rs );
return rs->sr_err;
}
candidates = meta_back_candidates_get( op );
/*
* Each target is scanned ...
*/
mc->mc_authz_target = META_BOUND_NONE;
for ( i = 0; i < mi->mi_ntargets; i++ ) {
metatarget_t *mt = mi->mi_targets[ i ];
int lerr;
/*
* Skip non-candidates
*/
if ( !META_IS_CANDIDATE( &candidates[ i ] ) ) {
continue;
}
if ( gotit == 0 ) {
/* set rc to LDAP_SUCCESS only if at least
* one candidate has been tried */
rc = LDAP_SUCCESS;
gotit = 1;
} else if ( !isroot ) {
/*
* A bind operation is expected to have
* ONE CANDIDATE ONLY!
*/
Debug( LDAP_DEBUG_ANY,
"### %s meta_back_bind: more than one"
" candidate selected...\n",
op->o_log_prefix );
}
if ( isroot ) {
if ( mt->mt_idassert_authmethod == LDAP_AUTH_NONE
|| BER_BVISNULL( &mt->mt_idassert_authcDN ) )
{
metasingleconn_t *msc = &mc->mc_conns[ i ];
/* skip the target if no pseudorootdn is provided */
if ( !BER_BVISNULL( &msc->msc_bound_ndn ) ) {
ch_free( msc->msc_bound_ndn.bv_val );
BER_BVZERO( &msc->msc_bound_ndn );
}
if ( !BER_BVISNULL( &msc->msc_cred ) ) {
/* destroy sensitive data */
memset( msc->msc_cred.bv_val, 0,
msc->msc_cred.bv_len );
ch_free( msc->msc_cred.bv_val );
BER_BVZERO( &msc->msc_cred );
}
continue;
}
(void)meta_back_proxy_authz_bind( mc, i, op, rs, LDAP_BACK_DONTSEND, 1 );
lerr = rs->sr_err;
} else {
lerr = meta_back_single_bind( op, rs, mc, i );
}
if ( lerr != LDAP_SUCCESS ) {
rc = rs->sr_err = lerr;
/* FIXME: in some cases (e.g. unavailable)
* do not assume it's not candidate; rather
* mark this as an error to be eventually
* reported to client */
META_CANDIDATE_CLEAR( &candidates[ i ] );
break;
}
}
/* must re-insert if local DN changed as result of bind */
if ( rc == LDAP_SUCCESS ) {
if ( isroot ) {
mc->mc_authz_target = META_BOUND_ALL;
}
if ( !LDAP_BACK_PCONN_ISPRIV( mc )
&& !dn_match( &op->o_req_ndn, &mc->mc_local_ndn ) )
{
int lerr;
/* wait for all other ops to release the connection */
ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
assert( mc->mc_refcnt == 1 );
#if META_BACK_PRINT_CONNTREE > 0
meta_back_print_conntree( mi, ">>> meta_back_bind" );
#endif /* META_BACK_PRINT_CONNTREE */
/* delete all cached connections with the current connection */
if ( LDAP_BACK_SINGLECONN( mi ) ) {
metaconn_t *tmpmc;
while ( ( tmpmc = avl_delete( &mi->mi_conninfo.lai_tree, (caddr_t)mc, meta_back_conn_cmp ) ) != NULL )
{
assert( !LDAP_BACK_PCONN_ISPRIV( mc ) );
Debug( LDAP_DEBUG_TRACE,
"=>meta_back_bind: destroying conn %lu (refcnt=%u)\n",
mc->mc_conn->c_connid, mc->mc_refcnt );
if ( tmpmc->mc_refcnt != 0 ) {
/* taint it */
LDAP_BACK_CONN_TAINTED_SET( tmpmc );
} else {
/*
* Needs a test because the handler may be corrupted,
* and calling ldap_unbind on a corrupted header results
* in a segmentation fault
*/
meta_back_conn_free( tmpmc );
}
}
}
ber_bvreplace( &mc->mc_local_ndn, &op->o_req_ndn );
lerr = avl_insert( &mi->mi_conninfo.lai_tree, (caddr_t)mc,
meta_back_conndn_cmp, meta_back_conndn_dup );
#if META_BACK_PRINT_CONNTREE > 0
meta_back_print_conntree( mi, "<<< meta_back_bind" );
#endif /* META_BACK_PRINT_CONNTREE */
if ( lerr == 0 ) {
#if 0
/* NOTE: a connection cannot be privileged
* and be in the avl tree at the same time
*/
if ( isroot ) {
LDAP_BACK_CONN_ISPRIV_SET( mc );
LDAP_BACK_PCONN_SET( mc, op );
}
#endif
LDAP_BACK_CONN_CACHED_SET( mc );
} else {
LDAP_BACK_CONN_CACHED_CLEAR( mc );
}
ldap_pvt_thread_mutex_unlock( &mi->mi_conninfo.lai_mutex );
}
}
if ( mc != NULL ) {
meta_back_release_conn( mi, mc );
}
/*
* rc is LDAP_SUCCESS if at least one bind succeeded,
* err is the last error that occurred during a bind;
* if at least (and at most?) one bind succeeds, fine.
*/
if ( rc != LDAP_SUCCESS ) {
/*
* deal with bind failure ...
*/
/*
* no target was found within the naming context,
* so bind must fail with invalid credentials
*/
if ( rs->sr_err == LDAP_SUCCESS && gotit == 0 ) {
rs->sr_err = LDAP_INVALID_CREDENTIALS;
} else {
rs->sr_err = slap_map_api2result( rs );
}
send_ldap_result( op, rs );
return rs->sr_err;
}
return LDAP_SUCCESS;
}
static void process_source_stat (stats_source_t *src_stats, stats_event_t *event)
{
if (event->name)
{
stats_node_t *node = _find_node (src_stats->stats_tree, event->name);
if (node == NULL)
{
/* adding node */
if (event->action != STATS_EVENT_REMOVE && event->value)
{
DEBUG3 ("new node on %s \"%s\" (%s)", src_stats->source, event->name, event->value);
node = (stats_node_t *)calloc (1,sizeof(stats_node_t));
node->name = (char *)strdup (event->name);
node->value = (char *)strdup (event->value);
node->flags = event->flags;
if (src_stats->flags & STATS_HIDDEN)
node->flags |= STATS_HIDDEN;
stats_listener_send (node->flags, "EVENT %s %s %s\n", src_stats->source, event->name, event->value);
avl_insert (src_stats->stats_tree, (void *)node);
}
return;
}
if (event->action == STATS_EVENT_REMOVE)
{
DEBUG2 ("delete node %s from %s", event->name, src_stats->source);
stats_listener_send (node->flags, "DELETE %s %s\n", src_stats->source, event->name);
avl_delete (src_stats->stats_tree, (void *)node, _free_stats);
return;
}
modify_node_event (node, event);
stats_listener_send (node->flags, "EVENT %s %s %s\n", src_stats->source, node->name, node->value);
return;
}
if (event->action == STATS_EVENT_REMOVE && event->name == NULL)
{
avl_tree_unlock (src_stats->stats_tree);
avl_tree_wlock (_stats.source_tree);
avl_tree_wlock (src_stats->stats_tree);
avl_delete (_stats.source_tree, (void *)src_stats, _free_source_stats);
avl_tree_unlock (_stats.source_tree);
return;
}
/* change source flags status */
if (event->action & STATS_EVENT_HIDDEN)
{
avl_node *node = avl_get_first (src_stats->stats_tree);
int visible = 0;
if ((event->flags&STATS_HIDDEN) == (src_stats->flags&STATS_HIDDEN))
return;
if (src_stats->flags & STATS_HIDDEN)
{
stats_node_t *ct = _find_node (src_stats->stats_tree, "server_type");
const char *type = "audio/mpeg";
if (ct)
type = ct->value;
src_stats->flags &= ~STATS_HIDDEN;
stats_listener_send (src_stats->flags, "NEW %s %s\n", type, src_stats->source);
visible = 1;
}
else
{
stats_listener_send (src_stats->flags, "DELETE %s\n", src_stats->source);
src_stats->flags |= STATS_HIDDEN;
}
while (node)
{
stats_node_t *stats = (stats_node_t*)node->key;
if (visible)
{
stats->flags &= ~STATS_HIDDEN;
stats_listener_send (stats->flags, "EVENT %s %s %s\n", src_stats->source, stats->name, stats->value);
}
else
stats->flags |= STATS_HIDDEN;
node = avl_get_next (node);
}
}
}
int
bdb_idl_fetch_key(
BackendDB *be,
DB *db,
DB_TXN *tid,
DBT *key,
ID *ids )
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
int rc;
DBT data;
DBC *cursor;
ID *i;
void *ptr;
size_t len;
int rc2;
int flags = bdb->bi_db_opflags | DB_MULTIPLE;
#ifdef SLAP_IDL_CACHE
bdb_idl_cache_entry_t idl_tmp;
#endif
/* If using BerkeleyDB 4.0, the buf must be large enough to
* grab the entire IDL in one get(), otherwise BDB will leak
* resources on subsequent get's. We can safely call get()
* twice - once for the data, and once to get the DB_NOTFOUND
* result meaning there's no more data. See ITS#2040 for details.
* This bug is fixed in BDB 4.1 so a smaller buffer will work if
* stack space is too limited.
*
* configure now requires Berkeley DB 4.1.
*/
#if (DB_VERSION_MAJOR == 4) && (DB_VERSION_MINOR == 0)
# define BDB_ENOUGH 5
#else
# define BDB_ENOUGH 1
#endif
ID buf[BDB_IDL_DB_SIZE*BDB_ENOUGH];
char keybuf[16];
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ARGS,
"bdb_idl_fetch_key: %s\n",
bdb_show_key( key, keybuf ), 0, 0 );
#else
Debug( LDAP_DEBUG_ARGS,
"bdb_idl_fetch_key: %s\n",
bdb_show_key( key, keybuf ), 0, 0 );
#endif
assert( ids != NULL );
#ifdef SLAP_IDL_CACHE
if ( bdb->bi_idl_cache_max_size ) {
bdb_idl_cache_entry_t *matched_idl_entry;
DBT2bv( key, &idl_tmp.kstr );
idl_tmp.db = db;
ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_mutex );
matched_idl_entry = avl_find( bdb->bi_idl_tree, &idl_tmp,
bdb_idl_entry_cmp );
if ( matched_idl_entry != NULL ) {
BDB_IDL_CPY( ids, matched_idl_entry->idl );
IDL_LRU_DELETE( bdb, matched_idl_entry );
IDL_LRU_ADD( bdb, matched_idl_entry );
ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_mutex );
return LDAP_SUCCESS;
}
ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_mutex );
}
#endif
DBTzero( &data );
data.data = buf;
data.ulen = sizeof(buf);
data.flags = DB_DBT_USERMEM;
if ( tid ) flags |= DB_RMW;
rc = db->cursor( db, tid, &cursor, bdb->bi_db_opflags );
if( rc != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"bdb_idl_fetch_key: cursor failed: %s (%d)\n",
db_strerror(rc), rc, 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"cursor failed: %s (%d)\n", db_strerror(rc), rc, 0 );
#endif
return rc;
}
rc = cursor->c_get( cursor, key, &data, flags | DB_SET );
if (rc == 0) {
i = ids;
while (rc == 0) {
u_int8_t *j;
DB_MULTIPLE_INIT( ptr, &data );
while (ptr) {
DB_MULTIPLE_NEXT(ptr, &data, j, len);
if (j) {
++i;
AC_MEMCPY( i, j, sizeof(ID) );
}
}
rc = cursor->c_get( cursor, key, &data, flags | DB_NEXT_DUP );
}
if ( rc == DB_NOTFOUND ) rc = 0;
ids[0] = i - ids;
/* On disk, a range is denoted by 0 in the first element */
if (ids[1] == 0) {
if (ids[0] != BDB_IDL_RANGE_SIZE) {
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"=> bdb_idl_fetch_key: range size mismatch: "
"expected %ld, got %ld\n",
BDB_IDL_RANGE_SIZE, ids[0], 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"range size mismatch: expected %d, got %ld\n",
BDB_IDL_RANGE_SIZE, ids[0], 0 );
#endif
cursor->c_close( cursor );
return -1;
}
BDB_IDL_RANGE( ids, ids[2], ids[3] );
}
data.size = BDB_IDL_SIZEOF(ids);
}
rc2 = cursor->c_close( cursor );
if (rc2) {
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"bdb_idl_fetch_key: close failed: %s (%d)\n",
db_strerror(rc2), rc2, 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"close failed: %s (%d)\n", db_strerror(rc2), rc2, 0 );
#endif
return rc2;
}
if( rc == DB_NOTFOUND ) {
return rc;
} else if( rc != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"bdb_idl_fetch_key: get failed: %s (%d)\n",
db_strerror(rc), rc, 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"get failed: %s (%d)\n",
db_strerror(rc), rc, 0 );
#endif
return rc;
} else if ( data.size == 0 || data.size % sizeof( ID ) ) {
/* size not multiple of ID size */
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"bdb_idl_fetch_key: odd size: expected %ld multiple, got %ld\n",
(long) sizeof( ID ), (long) data.size, 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"odd size: expected %ld multiple, got %ld\n",
(long) sizeof( ID ), (long) data.size, 0 );
#endif
return -1;
} else if ( data.size != BDB_IDL_SIZEOF(ids) ) {
/* size mismatch */
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"bdb_idl_fetch_key: get size mismatch: expected %ld, got %ld\n",
(long) ((1 + ids[0]) * sizeof( ID )), (long) data.size, 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"get size mismatch: expected %ld, got %ld\n",
(long) ((1 + ids[0]) * sizeof( ID )), (long) data.size, 0 );
#endif
return -1;
}
#ifdef SLAP_IDL_CACHE
if ( bdb->bi_idl_cache_max_size ) {
bdb_idl_cache_entry_t *ee;
ee = (bdb_idl_cache_entry_t *) ch_malloc(
sizeof( bdb_idl_cache_entry_t ) );
ee->db = db;
ee->idl = (ID*) ch_malloc( BDB_IDL_SIZEOF ( ids ) );
ee->idl_lru_prev = NULL;
ee->idl_lru_next = NULL;
BDB_IDL_CPY( ee->idl, ids );
ber_dupbv( &ee->kstr, &idl_tmp.kstr );
ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_mutex );
if ( avl_insert( &bdb->bi_idl_tree, (caddr_t) ee,
bdb_idl_entry_cmp, avl_dup_error ))
{
ch_free( ee->kstr.bv_val );
ch_free( ee->idl );
ch_free( ee );
} else {
IDL_LRU_ADD( bdb, ee );
if ( ++bdb->bi_idl_cache_size > bdb->bi_idl_cache_max_size ) {
int i = 0;
while ( bdb->bi_idl_lru_tail != NULL && i < 10 ) {
ee = bdb->bi_idl_lru_tail;
if ( avl_delete( &bdb->bi_idl_tree, (caddr_t) ee,
bdb_idl_entry_cmp ) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG( INDEX, ERR,
"bdb_idl_fetch_key: AVL delete failed\n",
0, 0, 0 );
#else
Debug( LDAP_DEBUG_ANY, "=> bdb_idl_fetch_key: "
"AVL delete failed\n",
0, 0, 0 );
#endif
}
IDL_LRU_DELETE( bdb, ee );
i++;
--bdb->bi_idl_cache_size;
ch_free( ee->kstr.bv_val );
ch_free( ee->idl );
ch_free( ee );
}
}
}
ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_mutex );
}
#endif
return rc;
}
Gestao inserir_compra_gestao(Gestao g, char*cl, char*pr, int mes, int tipo, int filial, int quant, double preco){
int i, j, k, v;
char *cod;
Cliente procura = NULL;
Produto procura2 = NULL;
ProdutoGestao procura3 = NULL;
Produto p = NULL;
Cliente c = NULL;
ProdutoGestao pg = NULL;
/*Atualizar ProdutoGestao************************************************/
procura3 = (ProdutoGestao) malloc(sizeof(struct produtogestao));
procura3->prod = pr; /*Não tem mal apenas igualar o apontador, pois esta variável será usada somente para efetuar uma procura e nunca para inserir a string para que se aponta, deste modo, seria redundante e menos eficiente alocar memória aqui.*/
pg = (ProdutoGestao) avl_find (g->produtos[*pr-'A'], procura3);
pg->quantidade_anual += quant;
pg->faturacao_anual += quant*preco;
pg->faturacao[filial-1] += quant*preco;
pg->vendas [filial-1]++;
if (((char*)avl_find (pg->clientes[*cl-'A'], cl))==NULL) {
pg->num_clientes++;
cod = (char*) malloc ((sizeof(char))*(strlen(cl)+1));
strcpy(cod,cl);
avl_insert(pg->clientes[cod[0]-'A'], cod);
}
free(procura3);
/**********************************************************************/
/*Inserir Cliente*/
procura = (Cliente) malloc(sizeof(struct cliente));
procura->cli = cl; /*Não tem mal apenas igualar o apontador, pois esta variável será usada somente para efetuar uma procura e nunca para inserir a string para que se aponta, deste modo, seria redundante e menos eficiente alocar memória aqui.*/
c = avl_find (g->clientes[(*cl)-'A'], procura);
free(procura);
/*Contador de Clientes que compraram em todas as filiais*/
if ((c->comprador_todas_filiais)==0){
for(i=0; i<N_FILIAIS; i++){
if (i==filial-1) continue;
for (v=0, j=0; j<N_MESES; j++){
for (k=0; k<N_REGIMES; k++){
v += c->compras_mes[i][j][k];
}
}
if (v==0) break;
}
if (i==N_FILIAIS) {
g->num_compradores_todas_filiais++;
c->comprador_todas_filiais = 1;
}
}
/****************************************************/
/*Contador de clientes compradores*/
if (c->produtos_diferentes_comprados==0)
g->num_clientes_compradores++;
/*********************************/
c->quantidade_mes[filial-1][mes-1][tipo]+=quant;
c->compras_mes [filial-1][mes-1][tipo]++;
/*Inserir Produto*/
procura2 = (Produto) malloc(sizeof(struct produto));
procura2->prod = pr; /*Não tem mal apenas igualar o apontador, pois esta variável será usada somente para efetuar uma procura e nunca para inserir a string para que se aponta, deste modo, seria redundante e menos eficiente alocar memória aqui.*/
p = avl_find (c->produtos[*pr-'A'], procura2);
free(procura2);
if (p==NULL) {
p = init_produto_gestao(pr);
p->faturacao += quant*preco;
p->quantidade_anual += quant;
p->quantidade_mes[filial-1][mes-1][tipo]+=quant;
p->compras_mes [filial-1][mes-1][tipo]++;
c->produtos_diferentes_comprados++;
c->produtos_diferentes_comprados_mes[mes-1]++;
avl_insert(c->produtos[*pr-'A'], p);
return g;
}
p->faturacao += quant*preco;
p->quantidade_anual += quant;
p->quantidade_mes[filial-1][mes-1][tipo]+=quant;
p->compras_mes [filial-1][mes-1][tipo]++;
/*************/
return g;
}
int
gsl_spmatrix_set(gsl_spmatrix *m, const size_t i, const size_t j,
const double x)
{
if (!GSL_SPMATRIX_ISTRIPLET(m))
{
GSL_ERROR("matrix not in triplet representation", GSL_EINVAL);
}
else if (x == 0.0)
{
/* traverse binary tree to search for (i,j) element */
void *ptr = tree_find(m, i, j);
/*
* just set the data element to 0; it would be easy to
* delete the node from the tree with avl_delete(), but
* we'd also have to delete it from the data arrays which
* is less simple
*/
if (ptr != NULL)
*(double *) ptr = 0.0;
return GSL_SUCCESS;
}
else
{
int s = GSL_SUCCESS;
void *ptr;
/* check if matrix needs to be realloced */
if (m->nz >= m->nzmax)
{
s = gsl_spmatrix_realloc(2 * m->nzmax, m);
if (s)
return s;
}
/* store the triplet (i, j, x) */
m->i[m->nz] = i;
m->p[m->nz] = j;
m->data[m->nz] = x;
ptr = avl_insert(m->tree_data->tree, &m->data[m->nz]);
if (ptr != NULL)
{
/* found duplicate entry (i,j), replace with new x */
*((double *) ptr) = x;
}
else
{
/* no duplicate (i,j) found, update indices as needed */
/* increase matrix dimensions if needed */
m->size1 = GSL_MAX(m->size1, i + 1);
m->size2 = GSL_MAX(m->size2, j + 1);
++(m->nz);
}
return s;
}
} /* gsl_spmatrix_set() */
int
main( int argc, char **argv )
{
Avlnode *tree = NULL;
char command[ 10 ];
char name[ 80 ];
char *p;
printf( "> " );
while ( fgets( command, sizeof( command ), stdin ) != NULL ) {
switch( *command ) {
case 'n': /* new tree */
( void ) avl_free( tree, free );
tree = NULL;
break;
case 'p': /* print */
( void ) myprint( tree );
break;
case 't': /* traverse with first, next */
#ifdef AVL_NONREENTRANT
printf( "***\n" );
for ( p = (char * ) avl_getfirst( tree );
p != NULL;
p = (char *) avl_getnext())
printf( "%s\n", p );
printf( "***\n" );
#else
printf( "*** reentrant interface not implemented ***" );
#endif
break;
case 'f': /* find */
printf( "data? " );
if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0';
if ( (p = (char *) avl_find( tree, name, avl_strcmp ))
== NULL )
printf( "Not found.\n\n" );
else
printf( "%s\n\n", p );
break;
case 'i': /* insert */
printf( "data? " );
if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0';
if ( avl_insert( &tree, strdup( name ), avl_strcmp,
avl_dup_error ) != 0 )
printf( "\nNot inserted!\n" );
break;
case 'd': /* delete */
printf( "data? " );
if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0';
if ( avl_delete( &tree, name, avl_strcmp ) == NULL )
printf( "\nNot found!\n" );
break;
case 'q': /* quit */
exit( EXIT_SUCCESS );
break;
case '\n':
break;
default:
printf("Commands: insert, delete, print, new, quit\n");
}
printf( "> " );
}
return( 0 );
}
/* Create an entryinfo in the cache. Caller must release the locks later.
*/
static int
bdb_entryinfo_add_internal(
struct bdb_info *bdb,
EntryInfo *ei,
EntryInfo **res )
{
EntryInfo *ei2 = NULL;
*res = NULL;
ei2 = bdb_cache_entryinfo_new( &bdb->bi_cache );
bdb_cache_entryinfo_lock( ei->bei_parent );
ldap_pvt_thread_rdwr_wlock( &bdb->bi_cache.c_rwlock );
ei2->bei_id = ei->bei_id;
ei2->bei_parent = ei->bei_parent;
#ifdef BDB_HIER
ei2->bei_rdn = ei->bei_rdn;
#endif
#ifdef SLAP_ZONE_ALLOC
ei2->bei_bdb = bdb;
#endif
/* Add to cache ID tree */
if (avl_insert( &bdb->bi_cache.c_idtree, ei2, bdb_id_cmp,
bdb_id_dup_err )) {
EntryInfo *eix = ei2->bei_lrunext;
bdb_cache_entryinfo_free( &bdb->bi_cache, ei2 );
ei2 = eix;
#ifdef BDB_HIER
/* It got freed above because its value was
* assigned to ei2.
*/
ei->bei_rdn.bv_val = NULL;
#endif
} else {
int rc;
bdb->bi_cache.c_eiused++;
ber_dupbv( &ei2->bei_nrdn, &ei->bei_nrdn );
/* This is a new leaf node. But if parent had no kids, then it was
* a leaf and we would be decrementing that. So, only increment if
* the parent already has kids.
*/
if ( ei->bei_parent->bei_kids || !ei->bei_parent->bei_id )
bdb->bi_cache.c_leaves++;
rc = avl_insert( &ei->bei_parent->bei_kids, ei2, bdb_rdn_cmp,
avl_dup_error );
#ifdef BDB_HIER
/* it's possible for hdb_cache_find_parent to beat us to it */
if ( !rc ) {
ei->bei_parent->bei_ckids++;
}
#endif
}
*res = ei2;
return 0;
}
void
range_tree_add(void *arg, uint64_t start, uint64_t size)
{
range_tree_t *rt = arg;
avl_index_t where;
range_seg_t rsearch, *rs_before, *rs_after, *rs;
uint64_t end = start + size;
boolean_t merge_before, merge_after;
VERIFY(size != 0);
rsearch.rs_start = start;
rsearch.rs_end = end;
rs = avl_find(&rt->rt_root, &rsearch, &where);
if (rs != NULL && rs->rs_start <= start && rs->rs_end >= end) {
zfs_panic_recover("zfs: allocating allocated segment"
"(offset=%llu size=%llu)\n",
(longlong_t)start, (longlong_t)size);
return;
}
/* Make sure we don't overlap with either of our neighbors */
VERIFY3P(rs, ==, NULL);
rs_before = avl_nearest(&rt->rt_root, where, AVL_BEFORE);
rs_after = avl_nearest(&rt->rt_root, where, AVL_AFTER);
merge_before = (rs_before != NULL && rs_before->rs_end == start);
merge_after = (rs_after != NULL && rs_after->rs_start == end);
if (merge_before && merge_after) {
avl_remove(&rt->rt_root, rs_before);
if (rt->rt_ops != NULL) {
rt->rt_ops->rtop_remove(rt, rs_before, rt->rt_arg);
rt->rt_ops->rtop_remove(rt, rs_after, rt->rt_arg);
}
range_tree_stat_decr(rt, rs_before);
range_tree_stat_decr(rt, rs_after);
rs_after->rs_start = rs_before->rs_start;
kmem_cache_free(range_seg_cache, rs_before);
rs = rs_after;
} else if (merge_before) {
if (rt->rt_ops != NULL)
rt->rt_ops->rtop_remove(rt, rs_before, rt->rt_arg);
range_tree_stat_decr(rt, rs_before);
rs_before->rs_end = end;
rs = rs_before;
} else if (merge_after) {
if (rt->rt_ops != NULL)
rt->rt_ops->rtop_remove(rt, rs_after, rt->rt_arg);
range_tree_stat_decr(rt, rs_after);
rs_after->rs_start = start;
rs = rs_after;
} else {
rs = kmem_cache_alloc(range_seg_cache, KM_SLEEP);
rs->rs_start = start;
rs->rs_end = end;
avl_insert(&rt->rt_root, rs, where);
}
if (rt->rt_ops != NULL)
rt->rt_ops->rtop_add(rt, rs, rt->rt_arg);
range_tree_stat_incr(rt, rs);
rt->rt_space += size;
}
/*
* Inits a session
*/
struct rewrite_session *
rewrite_session_init(
struct rewrite_info *info,
const void *cookie
)
{
struct rewrite_session *session, tmp;
int rc;
assert( info != NULL );
assert( cookie != NULL );
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
tmp.ls_cookie = ( void * )cookie;
session = ( struct rewrite_session * )avl_find( info->li_cookies,
( caddr_t )&tmp, rewrite_cookie_cmp );
if ( session ) {
session->ls_count++;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
return session;
}
session = calloc( sizeof( struct rewrite_session ), 1 );
if ( session == NULL ) {
return NULL;
}
session->ls_cookie = ( void * )cookie;
session->ls_count = 1;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( ldap_pvt_thread_mutex_init( &session->ls_mutex ) ) {
free( session );
return NULL;
}
if ( ldap_pvt_thread_rdwr_init( &session->ls_vars_mutex ) ) {
ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
free( session );
return NULL;
}
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
rc = avl_insert( &info->li_cookies, ( caddr_t )session,
rewrite_cookie_cmp, rewrite_cookie_dup );
info->li_num_cookies++;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
if ( rc != 0 ) {
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_destroy( &session->ls_vars_mutex );
ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
free( session );
return NULL;
}
return session;
}
static int ndb_tool_next_id(
Operation *op,
NdbArgs *NA,
struct berval *text,
int hole )
{
struct berval ndn = NA->e->e_nname;
int rc;
if (ndn.bv_len == 0) {
NA->e->e_id = 0;
return 0;
}
rc = ndb_entry_get_info( op, NA, 0, NULL );
if ( rc ) {
Attribute *a, tmp = {0};
if ( !be_issuffix( op->o_bd, &ndn ) ) {
struct dn_id *dptr;
struct berval npdn;
dnParent( &ndn, &npdn );
NA->e->e_nname = npdn;
NA->rdns->nr_num--;
rc = ndb_tool_next_id( op, NA, text, 1 );
NA->e->e_nname = ndn;
NA->rdns->nr_num++;
if ( rc ) {
return rc;
}
/* If parent didn't exist, it was created just now
* and its ID is now in e->e_id.
*/
dptr = (struct dn_id *)ch_malloc( sizeof( struct dn_id ) + npdn.bv_len + 1);
dptr->id = NA->e->e_id;
dptr->dn.bv_val = (char *)(dptr+1);
strcpy(dptr->dn.bv_val, npdn.bv_val );
dptr->dn.bv_len = npdn.bv_len;
if ( avl_insert( &myParents, dptr, ndb_dnid_cmp, avl_dup_error )) {
ch_free( dptr );
}
}
rc = ndb_next_id( op->o_bd, myNdb, &NA->e->e_id );
if ( rc ) {
snprintf( text->bv_val, text->bv_len,
"next_id failed: %s (%d)",
myNdb->getNdbError().message, myNdb->getNdbError().code );
Debug( LDAP_DEBUG_ANY,
"=> ndb_tool_next_id: %s\n", text->bv_val );
return rc;
}
if ( hole ) {
a = NA->e->e_attrs;
NA->e->e_attrs = &tmp;
tmp.a_desc = slap_schema.si_ad_objectClass;
tmp.a_vals = glueval;
tmp.a_nvals = tmp.a_vals;
tmp.a_numvals = 1;
}
rc = ndb_entry_put_info( op->o_bd, NA, 0 );
if ( hole ) {
NA->e->e_attrs = a;
}
if ( rc ) {
snprintf( text->bv_val, text->bv_len,
"ndb_entry_put_info failed: %s (%d)",
myNdb->getNdbError().message, myNdb->getNdbError().code );
Debug( LDAP_DEBUG_ANY,
"=> ndb_tool_next_id: %s\n", text->bv_val );
} else if ( hole ) {
if ( nholes == nhmax - 1 ) {
if ( holes == hbuf ) {
holes = (dn_id *)ch_malloc( nhmax * sizeof(dn_id) * 2 );
AC_MEMCPY( holes, hbuf, sizeof(hbuf) );
} else {
holes = (dn_id *)ch_realloc( holes, nhmax * sizeof(dn_id) * 2 );
}
nhmax *= 2;
}
ber_dupbv( &holes[nholes].dn, &ndn );
holes[nholes++].id = NA->e->e_id;
}
} else if ( !hole ) {
unsigned i;
for ( i=0; i<nholes; i++) {
if ( holes[i].id == NA->e->e_id ) {
unsigned j;
free(holes[i].dn.bv_val);
for (j=i;j<nholes;j++) holes[j] = holes[j+1];
holes[j].id = 0;
nholes--;
rc = ndb_entry_put_info( op->o_bd, NA, 1 );
break;
} else if ( holes[i].id > NA->e->e_id ) {
break;
}
}
}
return rc;
}
static int
rrdns_next_query(struct rrdns_context *rctx)
{
const char *addr = NULL, *hex = "0123456789abcdef";
struct rrdns_request *req;
int i, alen, family;
char *p, dname[73];
union {
unsigned char uchar[4];
struct in6_addr in6;
struct in_addr in;
} a = { };
union {
unsigned char buf[512];
HEADER hdr;
} msg;
if (rctx->addr_rem > 0 &&
blob_pad_len(rctx->addr_cur) <= rctx->addr_rem &&
blob_pad_len(rctx->addr_cur) >= sizeof(struct blob_attr)) {
addr = blobmsg_get_string(rctx->addr_cur);
rctx->addr_rem -= blob_pad_len(rctx->addr_cur);
rctx->addr_cur = blob_next(rctx->addr_cur);
}
if (!addr)
return 0;
if (inet_pton(AF_INET6, addr, &a.in6)) {
memset(dname, 0, sizeof(dname));
for (i = 0, p = dname; i < 16; i++) {
*p++ = hex[a.in6.s6_addr[15-i] % 16];
*p++ = '.';
*p++ = hex[a.in6.s6_addr[15-i] / 16];
*p++ = '.';
}
p += snprintf(p, p - dname - 1, "ip6.arpa");
family = AF_INET6;
alen = p - dname;
}
else if (inet_pton(AF_INET, addr, &a.in)) {
family = AF_INET;
alen = snprintf(dname, sizeof(dname), "%u.%u.%u.%u.in-addr.arpa",
a.uchar[3], a.uchar[2], a.uchar[1], a.uchar[0]);
}
else {
return -EINVAL;
}
alen = res_mkquery(QUERY, dname, C_IN, T_PTR, NULL, 0, NULL,
msg.buf, sizeof(msg.buf));
if (alen < 0)
return alen;
if (avl_find(&rctx->request_addrs, &a.in6))
return -ENOTUNIQ;
if (send(rctx->socket.fd, msg.buf, alen, 0) != alen)
return -errno;
req = calloc(1, sizeof(*req));
if (!req)
return -ENOMEM;
req->id = msg.hdr.id;
req->by_id.key = &req->id;
avl_insert(&rctx->request_ids, &req->by_id);
req->family = family;
req->addr.in6 = a.in6;
req->by_addr.key = &req->addr.in6;
avl_insert(&rctx->request_addrs, &req->by_addr);
return 0;
}
/* find/create handle and return it with the structure in a locked state */
static fh_node *open_fh (fbinfo *finfo)
{
fh_node *fh, *result;
if (finfo->mount == NULL)
finfo->mount = "";
fh = calloc (1, sizeof (fh_node));
memcpy (&fh->finfo, finfo, sizeof (fbinfo));
if (avl_get_by_key (fh_cache, fh, (void**)&result) == 0)
{
free (fh);
thread_mutex_lock (&result->lock);
avl_tree_unlock (fh_cache);
if (finfo->flags & FS_FALLBACK)
{
if (result->finfo.type != finfo->type && finfo->type != FORMAT_TYPE_UNDEFINED)
{
WARN1 ("format mismatched for %s", finfo->mount);
thread_mutex_unlock (&result->lock);
return NULL;
}
result->expire = (time_t)-1;
}
return result;
}
// insert new one
if (fh->finfo.mount[0])
{
char *fullpath= util_get_path_from_normalised_uri (fh->finfo.mount, fh->finfo.flags&FS_USE_ADMIN);
char *contenttype = fserve_content_type (fullpath);
format_type_t type = format_get_type (contenttype);
if (fh->finfo.type == FORMAT_TYPE_UNDEFINED)
fh->finfo.type = type;
if (finfo->flags & FS_FALLBACK)
{
if (fh->finfo.type != type && type != FORMAT_TYPE_UNDEFINED && fh->finfo.type != FORMAT_TYPE_UNDEFINED)
{
avl_tree_unlock (fh_cache);
free (contenttype);
free (fullpath);
free (fh);
WARN1 ("format mismatched for %s", finfo->mount);
return NULL;
}
fh->expire = (time_t)-1;
INFO2 ("lookup of fallback file \"%s\" (%d)", finfo->mount, finfo->limit);
}
else
INFO1 ("lookup of \"%s\"", finfo->mount);
if (file_open (&fh->f, fullpath) < 0)
{
INFO1 ("Failed to open \"%s\"", fullpath);
avl_tree_unlock (fh_cache);
free (contenttype);
free (fullpath);
free (fh);
return NULL;
}
free (fullpath);
fh->format = calloc (1, sizeof (format_plugin_t));
fh->format->type = fh->finfo.type;
fh->format->contenttype = strdup (contenttype);
free (contenttype);
if (fh->finfo.type != FORMAT_TYPE_UNDEFINED)
{
fh->format->mount = strdup (fh->finfo.mount);
if (format_get_plugin (fh->format) < 0)
{
avl_tree_unlock (fh_cache);
file_close (&fh->f);
free (fh->format);
free (fh);
return NULL;
}
}
if (fh->finfo.limit)
fh->out_bitrate = rate_setup (10000, 1000);
}
fh->clients = avl_tree_new (client_compare, NULL);
thread_mutex_create (&fh->lock);
thread_mutex_lock (&fh->lock);
avl_insert (fh_cache, fh);
avl_tree_unlock (fh_cache);
fh->refcount = 0;
fh->peak = 0;
fh->finfo.mount = strdup (finfo->mount);
fh->finfo.fallback = NULL;
return fh;
}
void fserve_recheck_mime_types (ice_config_t *config)
{
mime_type *mapping;
int i;
avl_tree *old_mimetypes = NULL, *new_mimetypes = avl_tree_new(_compare_mappings, NULL);
mime_type defaults[] = {
{ "m3u", "audio/x-mpegurl" },
{ "pls", "audio/x-scpls" },
{ "xspf", "application/xspf+xml" },
{ "ogg", "application/ogg" },
{ "xml", "text/xml" },
{ "mp3", "audio/mpeg" },
{ "aac", "audio/aac" },
{ "aacp", "audio/aacp" },
{ "css", "text/css" },
{ "txt", "text/plain" },
{ "html", "text/html" },
{ "jpg", "image/jpg" },
{ "png", "image/png" },
{ "gif", "image/gif" },
{ NULL, NULL }
};
for (i=0; defaults[i].ext; i++)
{
mapping = malloc (sizeof(mime_type));
mapping->ext = strdup (defaults [i].ext);
mapping->type = strdup (defaults [i].type);
if (avl_insert (new_mimetypes, mapping) != 0)
_delete_mapping (mapping);
}
do
{
char *type, *ext, *cur;
FILE *mimefile = NULL;
char line[4096];
if (config->mimetypes_fn == NULL)
{
INFO0 ("no mime types file defined, using defaults");
break;
}
mimefile = fopen (config->mimetypes_fn, "r");
if (mimefile == NULL)
{
WARN1 ("Cannot open mime types file %s, using defaults", config->mimetypes_fn);
break;
}
while (fgets(line, sizeof line, mimefile))
{
line[4095] = 0;
if(*line == 0 || *line == '#')
continue;
type = line;
cur = line;
while(*cur != ' ' && *cur != '\t' && *cur)
cur++;
if(*cur == 0)
continue;
*cur++ = 0;
while(1)
{
while(*cur == ' ' || *cur == '\t')
cur++;
if(*cur == 0)
break;
ext = cur;
while(*cur != ' ' && *cur != '\t' && *cur != '\n' && *cur)
cur++;
*cur++ = 0;
if(*ext)
{
void *tmp;
/* Add a new extension->type mapping */
mapping = malloc(sizeof(mime_type));
mapping->ext = strdup(ext);
mapping->type = strdup(type);
if (!avl_get_by_key (new_mimetypes, mapping, &tmp))
avl_delete (new_mimetypes, mapping, _delete_mapping);
if (avl_insert (new_mimetypes, mapping) != 0)
_delete_mapping (mapping);
}
}
}
fclose(mimefile);
} while (0);
thread_spin_lock (&pending_lock);
old_mimetypes = mimetypes;
mimetypes = new_mimetypes;
thread_spin_unlock (&pending_lock);
if (old_mimetypes)
avl_tree_free (old_mimetypes, _delete_mapping);
}
int
gsl_spmatrix_realloc(const size_t nzmax, gsl_spmatrix *m)
{
int s = GSL_SUCCESS;
void *ptr;
if (nzmax < m->nz)
{
GSL_ERROR("new nzmax is less than current nz", GSL_EINVAL);
}
ptr = realloc(m->i, nzmax * sizeof(size_t));
if (!ptr)
{
GSL_ERROR("failed to allocate space for row indices", GSL_ENOMEM);
}
m->i = (size_t *) ptr;
if (GSL_SPMATRIX_ISTRIPLET(m))
{
ptr = realloc(m->p, nzmax * sizeof(size_t));
if (!ptr)
{
GSL_ERROR("failed to allocate space for column indices", GSL_ENOMEM);
}
m->p = (size_t *) ptr;
}
ptr = realloc(m->data, nzmax * sizeof(double));
if (!ptr)
{
GSL_ERROR("failed to allocate space for data", GSL_ENOMEM);
}
m->data = (double *) ptr;
/* rebuild binary tree */
if (GSL_SPMATRIX_ISTRIPLET(m))
{
size_t n;
/* reset tree to empty state, but don't free root tree ptr */
avl_empty(m->tree_data->tree, NULL);
m->tree_data->n = 0;
ptr = realloc(m->tree_data->node_array, nzmax * sizeof(struct avl_node));
if (!ptr)
{
GSL_ERROR("failed to allocate space for AVL tree nodes", GSL_ENOMEM);
}
m->tree_data->node_array = ptr;
/*
* need to reinsert all tree elements since the m->data addresses
* have changed
*/
for (n = 0; n < m->nz; ++n)
{
ptr = avl_insert(m->tree_data->tree, &m->data[n]);
if (ptr != NULL)
{
GSL_ERROR("detected duplicate entry", GSL_EINVAL);
}
}
}
/* update to new nzmax */
m->nzmax = nzmax;
return s;
} /* gsl_spmatrix_realloc() */
void config_add(avl_tree_t *config_tree, config_t *cfg) {
avl_insert(config_tree, cfg);
}
int
rwm_map_config(
struct ldapmap *oc_map,
struct ldapmap *at_map,
const char *fname,
int lineno,
int argc,
char **argv )
{
struct ldapmap *map;
struct ldapmapping *mapping;
char *src, *dst;
int is_oc = 0;
int rc = 0;
if ( argc < 3 || argc > 4 ) {
Debug( LDAP_DEBUG_ANY,
"%s: line %d: syntax is \"map {objectclass | attribute} [<local> | *] {<foreign> | *}\"\n",
fname, lineno, 0 );
return 1;
}
if ( strcasecmp( argv[1], "objectclass" ) == 0 ) {
map = oc_map;
is_oc = 1;
} else if ( strcasecmp( argv[1], "attribute" ) == 0 ) {
map = at_map;
} else {
Debug( LDAP_DEBUG_ANY, "%s: line %d: syntax is "
"\"map {objectclass | attribute} [<local> | *] "
"{<foreign> | *}\"\n",
fname, lineno, 0 );
return 1;
}
if ( !is_oc && map->map == NULL ) {
/* only init if required */
if ( rwm_map_init( map, &mapping ) != LDAP_SUCCESS ) {
return 1;
}
}
if ( strcmp( argv[2], "*" ) == 0 ) {
if ( argc < 4 || strcmp( argv[3], "*" ) == 0 ) {
map->drop_missing = ( argc < 4 );
goto success_return;
}
src = dst = argv[3];
} else if ( argc < 4 ) {
src = "";
dst = argv[2];
} else {
src = argv[2];
dst = ( strcmp( argv[3], "*" ) == 0 ? src : argv[3] );
}
if ( ( map == at_map )
&& ( strcasecmp( src, "objectclass" ) == 0
|| strcasecmp( dst, "objectclass" ) == 0 ) )
{
Debug( LDAP_DEBUG_ANY,
"%s: line %d: objectclass attribute cannot be mapped\n",
fname, lineno, 0 );
return 1;
}
mapping = (struct ldapmapping *)ch_calloc( 2,
sizeof(struct ldapmapping) );
if ( mapping == NULL ) {
Debug( LDAP_DEBUG_ANY,
"%s: line %d: out of memory\n",
fname, lineno, 0 );
return 1;
}
ber_str2bv( src, 0, 1, &mapping[0].m_src );
ber_str2bv( dst, 0, 1, &mapping[0].m_dst );
mapping[1].m_src = mapping[0].m_dst;
mapping[1].m_dst = mapping[0].m_src;
mapping[0].m_flags = RWMMAP_F_NONE;
mapping[1].m_flags = RWMMAP_F_NONE;
/*
* schema check
*/
if ( is_oc ) {
if ( src[0] != '\0' ) {
mapping[0].m_src_oc = oc_bvfind( &mapping[0].m_src );
if ( mapping[0].m_src_oc == NULL ) {
Debug( LDAP_DEBUG_ANY,
"%s: line %d: warning, source objectClass '%s' "
"should be defined in schema\n",
fname, lineno, src );
/*
* FIXME: this should become an err
*/
mapping[0].m_src_oc = ch_malloc( sizeof( ObjectClass ) );
memset( mapping[0].m_src_oc, 0, sizeof( ObjectClass ) );
mapping[0].m_src_oc->soc_cname = mapping[0].m_src;
mapping[0].m_flags |= RWMMAP_F_FREE_SRC;
}
mapping[1].m_dst_oc = mapping[0].m_src_oc;
}
mapping[0].m_dst_oc = oc_bvfind( &mapping[0].m_dst );
if ( mapping[0].m_dst_oc == NULL ) {
Debug( LDAP_DEBUG_ANY,
"%s: line %d: warning, destination objectClass '%s' "
"is not defined in schema\n",
fname, lineno, dst );
mapping[0].m_dst_oc = oc_bvfind_undef( &mapping[0].m_dst );
if ( mapping[0].m_dst_oc == NULL ) {
Debug( LDAP_DEBUG_ANY, "%s: line %d: unable to mimic destination objectClass '%s'\n",
fname, lineno, dst );
goto error_return;
}
}
mapping[1].m_src_oc = mapping[0].m_dst_oc;
mapping[0].m_flags |= RWMMAP_F_IS_OC;
mapping[1].m_flags |= RWMMAP_F_IS_OC;
} else {
int rc;
const char *text = NULL;
if ( src[0] != '\0' ) {
rc = slap_bv2ad( &mapping[0].m_src,
&mapping[0].m_src_ad, &text );
if ( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"%s: line %d: warning, source attributeType '%s' "
"should be defined in schema\n",
fname, lineno, src );
/*
* we create a fake "proxied" ad
* and add it here.
*/
rc = slap_bv2undef_ad( &mapping[0].m_src,
&mapping[0].m_src_ad, &text,
SLAP_AD_PROXIED );
if ( rc != LDAP_SUCCESS ) {
char prefix[1024];
snprintf( prefix, sizeof(prefix),
"%s: line %d: source attributeType '%s': %d",
fname, lineno, src, rc );
Debug( LDAP_DEBUG_ANY, "%s (%s)\n",
prefix, text ? text : "null", 0 );
goto error_return;
}
}
mapping[1].m_dst_ad = mapping[0].m_src_ad;
}
rc = slap_bv2ad( &mapping[0].m_dst, &mapping[0].m_dst_ad, &text );
if ( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"%s: line %d: warning, destination attributeType '%s' "
"is not defined in schema\n",
fname, lineno, dst );
rc = slap_bv2undef_ad( &mapping[0].m_dst,
&mapping[0].m_dst_ad, &text,
SLAP_AD_PROXIED );
if ( rc != LDAP_SUCCESS ) {
char prefix[1024];
snprintf( prefix, sizeof(prefix),
"%s: line %d: destination attributeType '%s': %d",
fname, lineno, dst, rc );
Debug( LDAP_DEBUG_ANY, "%s (%s)\n",
prefix, text ? text : "null", 0 );
goto error_return;
}
}
mapping[1].m_src_ad = mapping[0].m_dst_ad;
}
if ( ( src[0] != '\0' && avl_find( map->map, (caddr_t)mapping, rwm_mapping_cmp ) != NULL)
|| avl_find( map->remap, (caddr_t)&mapping[1], rwm_mapping_cmp ) != NULL)
{
Debug( LDAP_DEBUG_ANY,
"%s: line %d: duplicate mapping found.\n",
fname, lineno, 0 );
/* FIXME: free stuff */
goto error_return;
}
if ( src[0] != '\0' ) {
avl_insert( &map->map, (caddr_t)&mapping[0],
rwm_mapping_cmp, rwm_mapping_dup );
}
avl_insert( &map->remap, (caddr_t)&mapping[1],
rwm_mapping_cmp, rwm_mapping_dup );
success_return:;
return rc;
error_return:;
if ( mapping ) {
rwm_mapping_free( mapping );
}
return 1;
}
static void
trim_map_segment_add(trim_map_t *tm, uint64_t start, uint64_t end, uint64_t txg)
{
avl_index_t where;
trim_seg_t tsearch, *ts_before, *ts_after, *ts;
boolean_t merge_before, merge_after;
hrtime_t time;
ASSERT(MUTEX_HELD(&tm->tm_lock));
VERIFY(start < end);
time = gethrtime();
tsearch.ts_start = start;
tsearch.ts_end = end;
ts = avl_find(&tm->tm_queued_frees, &tsearch, &where);
if (ts != NULL) {
if (start < ts->ts_start)
trim_map_segment_add(tm, start, ts->ts_start, txg);
if (end > ts->ts_end)
trim_map_segment_add(tm, ts->ts_end, end, txg);
return;
}
ts_before = avl_nearest(&tm->tm_queued_frees, where, AVL_BEFORE);
ts_after = avl_nearest(&tm->tm_queued_frees, where, AVL_AFTER);
merge_before = (ts_before != NULL && ts_before->ts_end == start);
merge_after = (ts_after != NULL && ts_after->ts_start == end);
if (merge_before && merge_after) {
TRIM_MAP_SINC(tm, ts_after->ts_start - ts_before->ts_end);
TRIM_MAP_QDEC(tm);
avl_remove(&tm->tm_queued_frees, ts_before);
list_remove(&tm->tm_head, ts_before);
ts_after->ts_start = ts_before->ts_start;
ts_after->ts_txg = txg;
ts_after->ts_time = time;
kmem_free(ts_before, sizeof (*ts_before));
} else if (merge_before) {
TRIM_MAP_SINC(tm, end - ts_before->ts_end);
ts_before->ts_end = end;
ts_before->ts_txg = txg;
ts_before->ts_time = time;
} else if (merge_after) {
TRIM_MAP_SINC(tm, ts_after->ts_start - start);
ts_after->ts_start = start;
ts_after->ts_txg = txg;
ts_after->ts_time = time;
} else {
TRIM_MAP_SINC(tm, end - start);
TRIM_MAP_QINC(tm);
ts = kmem_alloc(sizeof (*ts), KM_SLEEP);
ts->ts_start = start;
ts->ts_end = end;
ts->ts_txg = txg;
ts->ts_time = time;
avl_insert(&tm->tm_queued_frees, ts, where);
list_insert_tail(&tm->tm_head, ts);
}
}
/*
* Finish the initialization of a new segment descriptor allocated by
* ld_map_seg_alloc(), and enter it into the segment list.
*
* entry:
* mf - Mapfile descriptor
* seg_type - One of DBG_SEG_NEW or DBG_SEG_NEW_IMPLICIT
* ins_head - If true, the new segment goes at the front of
* others of its type. If false, it goes at the end.
* sgp - Segment descriptor to enter.
* where - Insertion point, initialized by a previous (failed) call to
* ld_seg_lookup(). Ignored if the segment has a NULL sg_name.
*
* exit:
* On success, returns SEG_INS_OK. A non-fatal error is indicated with
* a return value of SEG_INS_SKIP, in which case the descriptor is
* not entered, but the user is expected to discard it and continue
* running. On failure, returns SEG_INS_FAIL.
*
* note:
* This routine will modify the contents of the descriptor referenced
* by sgp_tmpl before allocating the new descriptor. The caller must
* not expect it to be unmodified.
*/
ld_map_seg_ins_t
ld_map_seg_insert(Mapfile *mf, dbg_state_t dbg_state, Sg_desc *sgp,
avl_index_t where)
{
Ofl_desc *ofl = mf->mf_ofl;
size_t idx;
Sg_desc *sgp2; /* temp segment descriptor pointer */
int ins_head;
Elf64_Xword sg_ndx;
/*
* If specific fields have not been supplied via
* map_equal(), make sure defaults are supplied.
*/
if (((sgp->sg_flags & FLG_SG_P_TYPE) == 0) &&
(sgp->sg_phdr.p_type == PT_NULL)) {
/*
* Default to a loadable segment.
*/
sgp->sg_phdr.p_type = PT_LOAD;
sgp->sg_flags |= FLG_SG_P_TYPE;
}
if (sgp->sg_phdr.p_type == PT_LOAD) {
if ((sgp->sg_flags & FLG_SG_P_FLAGS) == 0) {
/*
* Default to read/write and execute.
*/
sgp->sg_phdr.p_flags = PF_R + PF_W + PF_X;
sgp->sg_flags |= FLG_SG_P_FLAGS;
}
if ((sgp->sg_flags & FLG_SG_P_ALIGN) == 0) {
/*
* Default to segment alignment
*/
sgp->sg_phdr.p_align = ld_targ.t_m.m_segm_align;
sgp->sg_flags |= FLG_SG_P_ALIGN;
}
}
/*
* Determine where the new item should be inserted in
* the segment descriptor list.
*/
switch (sgp->sg_phdr.p_type) {
case PT_LOAD:
if (sgp->sg_flags & FLG_SG_EMPTY)
sgp->sg_id = SGID_TEXT_EMPTY;
else
sgp->sg_id = SGID_TEXT;
break;
case PT_NULL:
if (sgp->sg_flags & FLG_SG_EMPTY)
sgp->sg_id = SGID_NULL_EMPTY;
else
sgp->sg_id = SGID_NULL;
break;
case PT_NOTE:
sgp->sg_id = SGID_NOTE;
break;
default:
mf_fatal(mf, (MSG_MAP_UNKSEGTYP),
EC_WORD(sgp->sg_phdr.p_type));
return (SEG_INS_FAIL);
}
/*
* Add the descriptor to the segment list. In the v1 syntax,
* new sections are added at the head of their type, while in
* the newer syntax, they go at the end of their type.
*/
sg_ndx = 0;
ins_head = (mf->mf_version == MFV_SYSV);
for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp2)) {
if (ins_head) { /* Insert before the others of its type */
if (sgp->sg_id > sgp2->sg_id) {
sg_ndx++;
continue;
}
} else { /* Insert after the others of its type */
if (sgp->sg_id >= sgp2->sg_id) {
sg_ndx++;
continue;
}
}
break;
}
if (aplist_insert(&ofl->ofl_segs, sgp, AL_CNT_SEGMENTS, idx) == NULL)
return (SEG_INS_FAIL);
if (sgp->sg_name != NULL)
avl_insert(&ofl->ofl_segs_avl, sgp, where);
//DBG_CALL(Dbg_map_seg(ofl, dbg_state, sg_ndx, sgp, mf->mf_lineno));
return (SEG_INS_OK);
}
int bdb_tool_idl_add(
BackendDB *be,
DB *db,
DB_TXN *txn,
DBT *key,
ID id )
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
bdb_tool_idl_cache *ic, itmp;
bdb_tool_idl_cache_entry *ice;
int rc;
if ( !bdb->bi_idl_cache_max_size )
return bdb_idl_insert_key( be, db, txn, key, id );
DBT2bv( key, &itmp.kstr );
ic = avl_find( (Avlnode *)db->app_private, &itmp, bdb_tool_idl_cmp );
/* No entry yet, create one */
if ( !ic ) {
DBC *curs;
DBT data;
ID nid;
int rc;
ic = ch_malloc( sizeof( bdb_tool_idl_cache ) + itmp.kstr.bv_len );
ic->kstr.bv_len = itmp.kstr.bv_len;
ic->kstr.bv_val = (char *)(ic+1);
AC_MEMCPY( ic->kstr.bv_val, itmp.kstr.bv_val, ic->kstr.bv_len );
ic->head = ic->tail = NULL;
ic->last = 0;
ic->count = 0;
avl_insert( (Avlnode **)&db->app_private, ic, bdb_tool_idl_cmp,
avl_dup_error );
/* load existing key count here */
rc = db->cursor( db, NULL, &curs, 0 );
if ( rc ) return rc;
data.ulen = sizeof( ID );
data.flags = DB_DBT_USERMEM;
data.data = &nid;
rc = curs->c_get( curs, key, &data, DB_SET );
if ( rc == 0 ) {
if ( nid == 0 ) {
ic->count = BDB_IDL_DB_SIZE+1;
} else {
db_recno_t count;
curs->c_count( curs, &count, 0 );
ic->count = count;
BDB_DISK2ID( &nid, &ic->first );
}
}
curs->c_close( curs );
}
/* are we a range already? */
if ( ic->count > BDB_IDL_DB_SIZE ) {
ic->last = id;
return 0;
/* Are we at the limit, and converting to a range? */
} else if ( ic->count == BDB_IDL_DB_SIZE ) {
int n;
for ( ice = ic->head, n=0; ice; ice = ice->next, n++ )
/* counting */ ;
if ( n ) {
ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
ic->tail->next = bdb_tool_idl_free_list;
bdb_tool_idl_free_list = ic->head;
bdb->bi_idl_cache_size -= n;
ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
}
ic->head = ic->tail = NULL;
ic->last = id;
ic->count++;
return 0;
}
/* No free block, create that too */
if ( !ic->tail || ( ic->count & (IDBLOCK-1)) == 0) {
ice = NULL;
ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
if ( bdb->bi_idl_cache_size >= bdb->bi_idl_cache_max_size ) {
ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
rc = bdb_tool_idl_flush_db( db, ic );
if ( rc )
return rc;
avl_insert( (Avlnode **)&db->app_private, ic, bdb_tool_idl_cmp,
avl_dup_error );
ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
}
bdb->bi_idl_cache_size++;
if ( bdb_tool_idl_free_list ) {
ice = bdb_tool_idl_free_list;
bdb_tool_idl_free_list = ice->next;
}
ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
if ( !ice ) {
ice = ch_malloc( sizeof( bdb_tool_idl_cache_entry ));
}
memset( ice, 0, sizeof( *ice ));
if ( !ic->head ) {
ic->head = ice;
} else {
ic->tail->next = ice;
}
ic->tail = ice;
if ( !ic->count )
ic->first = id;
}
ice = ic->tail;
ice->ids[ ic->count & (IDBLOCK-1) ] = id;
ic->count++;
return 0;
}
/* Insert element a into the AVL tree t
* returns 1 if the depth of the tree has grown
* Warning: do not insert elements already present
*/
int avl_insert(avl_tree* t,avl* a)
{
/* initialize */
a->left=0;
a->right=0;
a->balance=0;
/* insert into an empty tree */
if(!t->root){
t->root=a;
return 1;
}
if(t->compar(t->root,a)>0){
/* insert into the left subtree */
if(t->root->left){
avl_tree left_subtree;
left_subtree.root=t->root->left;
left_subtree.compar=t->compar;
if(avl_insert(&left_subtree,a)){
switch(t->root->balance--){
case 1: return 0;
case 0: return 1;
}
if(t->root->left->balance<0){
avl_swr(&(t->root));
t->root->balance=0;
t->root->right->balance=0;
}else{
avl_swl(&(t->root->left));
avl_swr(&(t->root));
avl_nasty(t->root);
}
}else t->root->left=left_subtree.root;
return 0;
}else{
t->root->left=a;
if(t->root->balance--) return 0;
return 1;
}
}else{
/* insert into the right subtree */
if(t->root->right){
avl_tree right_subtree;
right_subtree.root=t->root->right;
right_subtree.compar=t->compar;
if(avl_insert(&right_subtree,a)){
switch(t->root->balance++){
case -1: return 0;
case 0: return 1;
}
if(t->root->right->balance>0){
avl_swl(&(t->root));
t->root->balance=0;
t->root->left->balance=0;
}else{
avl_swr(&(t->root->right));
avl_swl(&(t->root));
avl_nasty(t->root);
}
}else t->root->right=right_subtree.root;
return 0;
}else{
t->root->right=a;
if(t->root->balance++) return 0;
return 1;
}
}
}
/* Walk up the tree from a child node, looking for an ID that's already
* been linked into the cache.
*/
int
hdb_cache_find_parent(
Operation *op,
DB_TXN *txn,
ID id,
EntryInfo **res )
{
struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
EntryInfo ei, eip, *ei2 = NULL, *ein = NULL, *eir = NULL;
int rc, add;
ei.bei_id = id;
ei.bei_kids = NULL;
ei.bei_ckids = 0;
for (;;) {
rc = hdb_dn2id_parent( op, txn, &ei, &eip.bei_id );
if ( rc ) break;
/* Save the previous node, if any */
ei2 = ein;
/* Create a new node for the current ID */
ein = bdb_cache_entryinfo_new( &bdb->bi_cache );
ein->bei_id = ei.bei_id;
ein->bei_kids = ei.bei_kids;
ein->bei_nrdn = ei.bei_nrdn;
ein->bei_rdn = ei.bei_rdn;
ein->bei_ckids = ei.bei_ckids;
#ifdef SLAP_ZONE_ALLOC
ein->bei_bdb = bdb;
#endif
ei.bei_ckids = 0;
add = 1;
/* This node is not fully connected yet */
ein->bei_state |= CACHE_ENTRY_NOT_LINKED;
/* If this is the first time, save this node
* to be returned later.
*/
if ( eir == NULL ) {
eir = ein;
ein->bei_finders++;
}
again:
/* Insert this node into the ID tree */
ldap_pvt_thread_rdwr_wlock( &bdb->bi_cache.c_rwlock );
if ( avl_insert( &bdb->bi_cache.c_idtree, (caddr_t)ein,
bdb_id_cmp, bdb_id_dup_err ) ) {
EntryInfo *eix = ein->bei_lrunext;
if ( bdb_cache_entryinfo_trylock( eix )) {
ldap_pvt_thread_rdwr_wunlock( &bdb->bi_cache.c_rwlock );
ldap_pvt_thread_yield();
goto again;
}
ldap_pvt_thread_rdwr_wunlock( &bdb->bi_cache.c_rwlock );
/* Someone else created this node just before us.
* Free our new copy and use the existing one.
*/
bdb_cache_entryinfo_free( &bdb->bi_cache, ein );
/* if it was the node we were looking for, just return it */
if ( eir == ein ) {
*res = eix;
rc = 0;
break;
}
ein = ei2;
ei2 = eix;
add = 0;
/* otherwise, link up what we have and return */
goto gotparent;
}
/* If there was a previous node, link it to this one */
if ( ei2 ) ei2->bei_parent = ein;
/* Look for this node's parent */
par2:
if ( eip.bei_id ) {
ei2 = (EntryInfo *) avl_find( bdb->bi_cache.c_idtree,
(caddr_t) &eip, bdb_id_cmp );
} else {
ei2 = &bdb->bi_cache.c_dntree;
}
if ( ei2 && bdb_cache_entryinfo_trylock( ei2 )) {
ldap_pvt_thread_rdwr_wunlock( &bdb->bi_cache.c_rwlock );
ldap_pvt_thread_yield();
ldap_pvt_thread_rdwr_wlock( &bdb->bi_cache.c_rwlock );
goto par2;
}
if ( add )
bdb->bi_cache.c_eiused++;
if ( ei2 && ( ei2->bei_kids || !ei2->bei_id ))
bdb->bi_cache.c_leaves++;
ldap_pvt_thread_rdwr_wunlock( &bdb->bi_cache.c_rwlock );
gotparent:
/* Got the parent, link in and we're done. */
if ( ei2 ) {
bdb_cache_entryinfo_lock( eir );
ein->bei_parent = ei2;
if ( avl_insert( &ei2->bei_kids, (caddr_t)ein, bdb_rdn_cmp,
avl_dup_error) == 0 )
ei2->bei_ckids++;
/* Reset all the state info */
for (ein = eir; ein != ei2; ein=ein->bei_parent)
ein->bei_state &= ~CACHE_ENTRY_NOT_LINKED;
bdb_cache_entryinfo_unlock( ei2 );
eir->bei_finders--;
*res = eir;
break;
}
ei.bei_kids = NULL;
ei.bei_id = eip.bei_id;
ei.bei_ckids = 1;
avl_insert( &ei.bei_kids, (caddr_t)ein, bdb_rdn_cmp,
avl_dup_error );
}
return rc;
}
/*
* XL-COM Connection Listener
*/
void* thr_listener(void* arg) {
int listen_fd, client_fd;
struct sockaddr_in client_addr, server_addr;
socklen_t client_sz = sizeof(client_addr);
struct epoll_event epoll_ev;
int result;
int* key_tmp;
client_info_t* info_tmp;
// Open socket to listen for new clients
if ((listen_fd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
printf("[xlcom_server] [L] cannot open socket.\n");
return NULL;
}
// Initialize server address structure
memset((char *)&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(LISTEN_PORT);
// Bind socket to listen port
while(bind(listen_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {
printf("[xlcom_server] [L] cannot bind port %d. trying again in %d seconds.\n", LISTEN_PORT, BIND_RETRY_DELAY);
sleep(BIND_RETRY_DELAY);
}
// Listen on that port
listen(listen_fd, LISTEN_QUEUE);
printf("[xlcom_server] [L] Listening on port %d. Max pending connections %d.\n", LISTEN_PORT, LISTEN_QUEUE);
while(1) {
// Wait for new connection
if ((client_fd = accept(listen_fd, (struct sockaddr *) &client_addr, &client_sz)) < 0) {
perror("[xlcom_server] [L] could not accept connection.\n");
close(listen_fd);
return NULL;
}
printf("[xlcom_server] [L] Received new connection from %s on fd %d.\n", inet_ntoa(client_addr.sin_addr), client_fd);
// Add new connection to epoll
epoll_ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
epoll_ev.data.fd = client_fd;
if ((result = epoll_ctl(Epoll_fd, EPOLL_CTL_ADD, client_fd, &epoll_ev)) != 0) {
printf("[xlcom_server] [L] Error adding new connection to epoll queue.\n");
close(listen_fd);
return NULL;
}
// Insert new connection into Active_connections
// Key = Client socket FD
key_tmp = malloc(sizeof(int));
*key_tmp = client_fd;
// Info = client_info_t structure
info_tmp = client_info_create();
client_info_set_fd(info_tmp, client_fd);
client_info_set_address(info_tmp, inet_ntoa(client_addr.sin_addr));
client_info_set_username(info_tmp, "Anonymous");
// Insert it on active connections database
avl_insert(Active_connections, key_tmp, info_tmp);
}
}
static void *_stats_thread(void *arg)
{
stats_event_t *event;
stats_event_t *copy;
stats_node_t *node;
stats_node_t *anode;
stats_source_t *snode;
stats_source_t *asnode;
event_listener_t *listener;
avl_node *avlnode;
while (_stats_running) {
thread_mutex_lock(&_global_event_mutex);
if (_global_event_queue != NULL) {
/* grab the next event from the queue */
event = _global_event_queue;
_global_event_queue = event->next;
event->next = NULL;
thread_mutex_unlock(&_global_event_mutex);
thread_mutex_lock(&_stats_mutex);
if (event->source == NULL) {
/* we have a global event */
if (event->value != NULL) {
/* adding/updating */
node = _find_node(_stats.global_tree, event->name);
if (node == NULL) {
/* add node */
anode = (stats_node_t *)malloc(sizeof(stats_node_t));
anode->name = (char *)strdup(event->name);
anode->value = (char *)strdup(event->value);
avl_insert(_stats.global_tree, (void *)anode);
} else {
/* update node */
free(node->value);
node->value = (char *)strdup(event->value);
}
} else {
/* we're deleting */
node = _find_node(_stats.global_tree, event->name);
if (node != NULL)
avl_delete(_stats.global_tree, (void *)node, _free_stats);
}
} else {
/* we have a source event */
snode = _find_source(_stats.source_tree, event->source);
if (snode != NULL) {
/* this is a source we already have a tree for */
if (event->value != NULL) {
/* we're add/updating */
node = _find_node(snode->stats_tree, event->name);
if (node == NULL) {
/* adding node */
anode = (stats_node_t *)malloc(sizeof(stats_node_t));
anode->name = (char *)strdup(event->name);
anode->value = (char *)strdup(event->value);
avl_insert(snode->stats_tree, (void *)anode);
} else {
/* updating node */
free(node->value);
node->value = (char *)strdup(event->value);
}
} else {
/* we're deleting */
node = _find_node(snode->stats_tree, event->name);
if (node != NULL) {
avl_delete(snode->stats_tree, (void *)node, _free_stats);
avlnode = avl_get_first(snode->stats_tree);
if (avlnode == NULL) {
avl_delete(_stats.source_tree, (void *)snode, _free_source_stats);
}
}
}
} else {
/* this is a new source */
asnode = (stats_source_t *)malloc(sizeof(stats_source_t));
asnode->source = (char *)strdup(event->source);
asnode->stats_tree = avl_tree_new(_compare_stats, NULL);
anode = (stats_node_t *)malloc(sizeof(stats_node_t));
anode->name = (char *)strdup(event->name);
anode->value = (char *)strdup(event->value);
avl_insert(asnode->stats_tree, (void *)anode);
avl_insert(_stats.source_tree, (void *)asnode);
}
}
/* now we have an event that's been processed into the running stats */
/* this event should get copied to event listeners' queues */
listener = _event_listeners;
while (listener) {
copy = _copy_event(event);
thread_mutex_lock(listener->mutex);
_add_event_to_queue(copy, listener->queue);
thread_mutex_unlock(listener->mutex);
listener = listener->next;
}
thread_cond_broadcast(&_event_signal_cond);
/* now we need to destroy the event */
_free_event(event);
thread_mutex_unlock(&_stats_mutex);
continue;
} else {
thread_mutex_unlock(&_global_event_mutex);
}
thread_sleep(300000);
}
/* wake the other threads so they can shut down cleanly */
thread_cond_broadcast(&_event_signal_cond);
thread_exit(0);
return NULL;
}
/* ARGSUSED */
static int
zfsctl_snapdir_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
int *direntflags, pathname_t *realpnp)
{
zfsctl_snapdir_t *sdp = dvp->v_data;
objset_t *snap;
char snapname[MAXNAMELEN];
char real[MAXNAMELEN];
char *mountpoint;
zfs_snapentry_t *sep, search;
struct mounta margs;
vfs_t *vfsp;
size_t mountpoint_len;
avl_index_t where;
zfsvfs_t *zfsvfs = dvp->v_vfsp->vfs_data;
int err;
/*
* No extended attributes allowed under .zfs
*/
if (flags & LOOKUP_XATTR)
return (EINVAL);
ASSERT(dvp->v_type == VDIR);
/*
* If we get a recursive call, that means we got called
* from the domount() code while it was trying to look up the
* spec (which looks like a local path for zfs). We need to
* add some flag to domount() to tell it not to do this lookup.
*/
if (MUTEX_HELD(&sdp->sd_lock))
return (ENOENT);
ZFS_ENTER(zfsvfs);
if (gfs_lookup_dot(vpp, dvp, zfsvfs->z_ctldir, nm) == 0) {
ZFS_EXIT(zfsvfs);
return (0);
}
if (flags & FIGNORECASE) {
boolean_t conflict = B_FALSE;
err = dmu_snapshot_realname(zfsvfs->z_os, nm, real,
MAXNAMELEN, &conflict);
if (err == 0) {
nm = real;
} else if (err != ENOTSUP) {
ZFS_EXIT(zfsvfs);
return (err);
}
if (realpnp)
(void) strlcpy(realpnp->pn_buf, nm,
realpnp->pn_bufsize);
if (conflict && direntflags)
*direntflags = ED_CASE_CONFLICT;
}
mutex_enter(&sdp->sd_lock);
search.se_name = (char *)nm;
if ((sep = avl_find(&sdp->sd_snaps, &search, &where)) != NULL) {
*vpp = sep->se_root;
if (VN_HOLD(*vpp) == NULL) {
*vpp = NULL;
err = EAGAIN;
} else {
err = traverse(vpp);
if (err) {
VN_RELE(*vpp);
*vpp = NULL;
} else if (*vpp == sep->se_root) {
/*
* The snapshot was unmounted behind our backs,
* try to remount it.
*/
goto domount;
} else {
/*
* VROOT was set during the traverse call. We need
* to clear it since we're pretending to be part
* of our parent's vfs.
*/
(*vpp)->v_flag &= ~VROOT;
}
}
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
return (err);
}
/*
* The requested snapshot is not currently mounted, look it up.
*/
err = zfsctl_snapshot_zname(dvp, nm, MAXNAMELEN, snapname);
if (err) {
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
/*
* handle "ls *" or "?" in a graceful manner,
* forcing EILSEQ to ENOENT.
* Since shell ultimately passes "*" or "?" as name to lookup
*/
return (err == EILSEQ ? ENOENT : err);
}
if (dmu_objset_hold(snapname, FTAG, &snap) != 0) {
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
return (ENOENT);
}
sep = kmem_alloc(sizeof (zfs_snapentry_t), KM_SLEEP);
sep->se_name = kmem_alloc(strlen(nm) + 1, KM_SLEEP);
(void) strcpy(sep->se_name, nm);
*vpp = sep->se_root = zfsctl_snapshot_mknode(dvp, dmu_objset_id(snap));
avl_insert(&sdp->sd_snaps, sep, where);
dmu_objset_rele(snap, FTAG);
domount:
mountpoint_len = strlen(refstr_value(dvp->v_vfsp->vfs_mntpt)) +
strlen("/.zfs/snapshot/") + strlen(nm) + 1;
mountpoint = kmem_alloc(mountpoint_len, KM_SLEEP);
(void) snprintf(mountpoint, mountpoint_len, "%s/.zfs/snapshot/%s",
refstr_value(dvp->v_vfsp->vfs_mntpt), nm);
margs.spec = snapname;
margs.dir = mountpoint;
margs.flags = MS_SYSSPACE | MS_NOMNTTAB;
margs.fstype = "zfs";
margs.dataptr = NULL;
margs.datalen = 0;
margs.optptr = NULL;
margs.optlen = 0;
err = domount("zfs", &margs, *vpp, kcred, &vfsp);
kmem_free(mountpoint, mountpoint_len);
if (err == 0) {
/*
* Return the mounted root rather than the covered mount point.
* Takes the GFS vnode at .zfs/snapshot/<snapname> and returns
* the ZFS vnode mounted on top of the GFS node. This ZFS
* vnode is the root of the newly created vfsp.
*/
VFS_RELE(vfsp);
err = traverse(vpp);
}
if (err == 0) {
/*
* Fix up the root vnode mounted on .zfs/snapshot/<snapname>.
*
* This is where we lie about our v_vfsp in order to
* make .zfs/snapshot/<snapname> accessible over NFS
* without requiring manual mounts of <snapname>.
*/
ASSERT(VTOZ(*vpp)->z_zfsvfs != zfsvfs);
VTOZ(*vpp)->z_zfsvfs->z_parent = zfsvfs;
(*vpp)->v_vfsp = zfsvfs->z_vfs;
(*vpp)->v_flag &= ~VROOT;
}
mutex_exit(&sdp->sd_lock);
ZFS_EXIT(zfsvfs);
/*
* If we had an error, drop our hold on the vnode and
* zfsctl_snapshot_inactive() will clean up.
*/
if (err) {
VN_RELE(*vpp);
*vpp = NULL;
}
return (err);
}
void fserve_recheck_mime_types(ice_config_t *config)
{
FILE *mimefile;
char line[4096];
char *type, *ext, *cur;
mime_type *mapping;
avl_tree *new_mimetypes;
if (config->mimetypes_fn == NULL)
return;
mimefile = fopen (config->mimetypes_fn, "r");
if (mimefile == NULL)
{
ICECAST_LOG_WARN("Cannot open mime types file %s", config->mimetypes_fn);
return;
}
new_mimetypes = avl_tree_new(_compare_mappings, NULL);
while(fgets(line, 4096, mimefile))
{
line[4095] = 0;
if(*line == 0 || *line == '#')
continue;
type = line;
cur = line;
while(*cur != ' ' && *cur != '\t' && *cur)
cur++;
if(*cur == 0)
continue;
*cur++ = 0;
while(1) {
while(*cur == ' ' || *cur == '\t')
cur++;
if(*cur == 0)
break;
ext = cur;
while(*cur != ' ' && *cur != '\t' && *cur != '\n' && *cur)
cur++;
*cur++ = 0;
if(*ext)
{
void *tmp;
/* Add a new extension->type mapping */
mapping = malloc(sizeof(mime_type));
mapping->ext = strdup(ext);
mapping->type = strdup(type);
if (!avl_get_by_key (new_mimetypes, mapping, &tmp))
avl_delete (new_mimetypes, mapping, _delete_mapping);
avl_insert (new_mimetypes, mapping);
}
}
}
fclose(mimefile);
thread_spin_lock (&pending_lock);
if (mimetypes)
avl_tree_free (mimetypes, _delete_mapping);
mimetypes = new_mimetypes;
thread_spin_unlock (&pending_lock);
}
/* Read table definitions from the DB and populate ObjectClassInfo */
extern "C" int
ndb_oc_read( struct ndb_info *ni, const NdbDictionary::Dictionary *myDict )
{
const NdbDictionary::Table *myTable;
const NdbDictionary::Column *myCol;
NdbOcInfo *oci, octmp;
NdbAttrInfo *ai;
ObjectClass *oc;
NdbDictionary::Dictionary::List myList;
struct berval bv;
int i, j, rc, col;
rc = myDict->listObjects( myList, NdbDictionary::Object::UserTable );
/* Populate our objectClass structures */
for ( i=0; i<myList.count; i++ ) {
/* Ignore other DBs */
if ( strcmp( myList.elements[i].database, ni->ni_dbname ))
continue;
/* Ignore internal tables */
if ( !strncmp( myList.elements[i].name, "OL_", 3 ))
continue;
ber_str2bv( myList.elements[i].name, 0, 0, &octmp.no_name );
oci = (NdbOcInfo *)avl_find( ni->ni_oc_tree, &octmp, ndb_name_cmp );
if ( oci )
continue;
oc = oc_bvfind( &octmp.no_name );
if ( !oc ) {
/* undefined - shouldn't happen */
continue;
}
myTable = myDict->getTable( myList.elements[i].name );
oci = (NdbOcInfo *)ch_malloc( sizeof( NdbOcInfo )+oc->soc_cname.bv_len+1 );
oci->no_table.bv_val = (char *)(oci+1);
strcpy( oci->no_table.bv_val, oc->soc_cname.bv_val );
oci->no_table.bv_len = oc->soc_cname.bv_len;
oci->no_name = oci->no_table;
oci->no_oc = oc;
oci->no_flag = 0;
oci->no_nsets = 0;
oci->no_nattrs = 0;
col = 0;
/* Make space for all attrs, even tho sups will be dropped */
if ( oci->no_oc->soc_required ) {
for ( j=0; oci->no_oc->soc_required[j]; j++ );
col = j;
}
if ( oci->no_oc->soc_allowed ) {
for ( j=0; oci->no_oc->soc_allowed[j]; j++ );
col += j;
}
oci->no_attrs = (struct ndb_attrinfo **)ch_malloc( col * sizeof(struct ndb_attrinfo *));
avl_insert( &ni->ni_oc_tree, oci, ndb_name_cmp, avl_dup_error );
col = myTable->getNoOfColumns();
/* Skip 0 and 1, eid and vid */
for ( j = 2; j<col; j++ ) {
myCol = myTable->getColumn( j );
ber_str2bv( myCol->getName(), 0, 0, &bv );
ai = ndb_ai_get( ni, &bv );
/* shouldn't happen */
if ( !ai )
continue;
ai->na_oi = oci;
ai->na_column = j;
ai->na_len = myCol->getLength();
if ( myCol->getType() == NdbDictionary::Column::Blob )
ai->na_flag |= NDB_INFO_ATBLOB;
}
}
/* Link to any attrsets */
for ( i=0; i<myList.count; i++ ) {
/* Ignore other DBs */
if ( strcmp( myList.elements[i].database, ni->ni_dbname ))
continue;
/* Ignore internal tables */
if ( !strncmp( myList.elements[i].name, "OL_", 3 ))
continue;
ber_str2bv( myList.elements[i].name, 0, 0, &octmp.no_name );
oci = (NdbOcInfo *)avl_find( ni->ni_oc_tree, &octmp, ndb_name_cmp );
/* shouldn't happen */
if ( !oci )
continue;
col = 2;
if ( oci->no_oc->soc_required ) {
rc = ndb_ai_check( ni, oci, oci->no_oc->soc_required, NULL, &col, 0 );
}
if ( oci->no_oc->soc_allowed ) {
rc = ndb_ai_check( ni, oci, oci->no_oc->soc_allowed, NULL, &col, 0 );
}
/* shrink down to just the needed size */
oci->no_attrs = (struct ndb_attrinfo **)ch_realloc( oci->no_attrs,
oci->no_nattrs * sizeof(struct ndb_attrinfo *));
}
return 0;
}
int
imap_driver_init(struct module *module, struct event_base *base)
{
struct imap_driver *driver = module->priv;
struct imap_config *config;
struct imap_handler *handler = handlers;
struct module *ldap;
struct sockaddr_in6 sin;
int socklen = sizeof(sin);
assert(driver && driver->config && base);
config = driver->config;
driver->base = base;
driver->dnsbase = get_dnsbase();
if (config->cert) {
driver->ssl_ctx = new_ssl_ctx(config->cert, config->pkey);
if (driver->ssl_ctx == NULL) {
return 1;
}
} else {
/* skip the STARTTLS handler */
handler += 1;
}
for (; handler->command; handler++) {
/* handle the private handler storage */
if (avl_insert(&driver->commands, handler, imap_handler_cmp, avl_dup_error)) {
return 1;
}
}
if (evutil_parse_sockaddr_port(config->listen, (struct sockaddr *)&sin, &socklen)) {
return 1;
}
/* we start in disabled state until the LDAP interface is ready */
driver->listener = evconnlistener_new_bind(base, listen_cb, (void*)driver,
LEV_OPT_REUSEABLE|LEV_OPT_DISABLED|LEV_OPT_CLOSE_ON_FREE,
-1, (struct sockaddr *)&sin, socklen);
/* could also be wise to set an error callback, but what errors do we face
* on accept()? */
if (!driver->listener) {
skeeter_log(LOG_CRIT, "Could not create a listener!");
return 1;
}
ldap = get_module("ldap");
if (!ldap || !ldap->register_event) {
skeeter_log(LOG_CRIT, "LDAP module not available!");
return 1;
}
if (ldap->register_event(ldap, MODULE_ANY | MODULE_PERSIST, trigger_listener, driver->listener)) {
skeeter_log(LOG_CRIT, "Regitration with LDAP module failed!");
return 1;
}
driver->ldap = ldap;
return 0;
}
static int
ndb_oc_list( struct ndb_info *ni, const NdbDictionary::Dictionary *myDict,
struct berval *oname, int implied, NdbOcs *out )
{
const NdbDictionary::Table *myTable;
NdbOcInfo *oci, octmp;
ObjectClass *oc;
int i, rc;
/* shortcut top */
if ( ber_bvstrcasecmp( oname, &slap_schema.si_oc_top->soc_cname )) {
octmp.no_name = *oname;
oci = (NdbOcInfo *)avl_find( ni->ni_oc_tree, &octmp, ndb_name_cmp );
if ( oci ) {
oc = oci->no_oc;
} else {
oc = oc_bvfind( oname );
if ( !oc ) {
/* undefined - shouldn't happen */
return LDAP_INVALID_SYNTAX;
}
}
if ( oc->soc_sups ) {
int i;
for ( i=0; oc->soc_sups[i]; i++ ) {
rc = ndb_oc_list( ni, myDict, &oc->soc_sups[i]->soc_cname, 1, out );
if ( rc ) return rc;
}
}
} else {
oc = slap_schema.si_oc_top;
}
/* Only insert once */
for ( i=0; i<out->no_ntext; i++ )
if ( out->no_text[i].bv_val == oc->soc_cname.bv_val )
break;
if ( i == out->no_ntext ) {
for ( i=0; i<out->no_nitext; i++ )
if ( out->no_itext[i].bv_val == oc->soc_cname.bv_val )
break;
if ( i == out->no_nitext ) {
if ( implied )
out->no_itext[out->no_nitext++] = oc->soc_cname;
else
out->no_text[out->no_ntext++] = oc->soc_cname;
}
}
/* ignore top, etc... */
if ( oc->soc_kind == LDAP_SCHEMA_ABSTRACT )
return 0;
if ( !oci ) {
ldap_pvt_thread_rdwr_runlock( &ni->ni_oc_rwlock );
oci = (NdbOcInfo *)ch_malloc( sizeof( NdbOcInfo )+oc->soc_cname.bv_len+1 );
oci->no_table.bv_val = (char *)(oci+1);
strcpy( oci->no_table.bv_val, oc->soc_cname.bv_val );
oci->no_table.bv_len = oc->soc_cname.bv_len;
oci->no_name = oci->no_table;
oci->no_oc = oc;
oci->no_flag = 0;
oci->no_nsets = 0;
oci->no_nattrs = 0;
ldap_pvt_thread_rdwr_wlock( &ni->ni_oc_rwlock );
if ( avl_insert( &ni->ni_oc_tree, oci, ndb_name_cmp, ndb_oc_dup_err )) {
octmp.no_oc = oci->no_oc;
ch_free( oci );
oci = (NdbOcInfo *)octmp.no_oc;
}
/* see if the oc table already exists in the DB */
myTable = myDict->getTable( oci->no_table.bv_val );
rc = ndb_oc_create( ni, oci, myTable == NULL );
ldap_pvt_thread_rdwr_wunlock( &ni->ni_oc_rwlock );
ldap_pvt_thread_rdwr_rlock( &ni->ni_oc_rwlock );
if ( rc ) return rc;
}
/* Only insert once */
for ( i=0; i<out->no_ninfo; i++ )
if ( out->no_info[i] == oci )
break;
if ( i == out->no_ninfo )
out->no_info[out->no_ninfo++] = oci;
return 0;
}
void * load_rules(void * raw)
{
unsigned int * tid = raw;
int rulefd;
char rulestr[LINELEN];
uint64_t curval;
uint64_t nbpwds;
uint64_t i;
struct s_rule_link * link;
unsigned int nbloaded;
unsigned int jobid;
uint64_t pwtested;
while(1)
{
/* select jobid */
pthread_mutex_lock( &rj_mutex );
for(jobid=0;jobid<nbfiles;jobid++)
if( rulejob[jobid].done_by == -1 )
break;
if(jobid>=nbfiles)
{
pthread_mutex_unlock( &rj_mutex );
break;
}
rulejob[jobid].done_by = *tid;
pthread_mutex_unlock( &rj_mutex );
rulefd = open(rulejob[jobid].filename, O_RDONLY);
if(rulefd <0)
{
perror(rulejob[jobid].filename);
continue;
}
nbloaded = 0;
while(1)
{
curval = 0;
pwtested = 0;
nbpwds = 0;
if(read(rulefd, &curval, sizeof(unsigned int)) != sizeof(unsigned int))
break;
if(curval>=(LINELEN-1))
{
fprintf(stderr, "rule length too large : %ld>=%d\n", curval, LINELEN-1);
break;
}
if(read(rulefd, rulestr, curval) != curval)
{
fprintf(stderr, "could not read rule string of len %ld", curval);
break;
}
rulestr[curval]=0;
if(read(rulefd, &pwtested, sizeof(unsigned long)) != sizeof(unsigned long))
{
fprintf(stderr, "could not read nb pwd tested\n");
break;
}
if(read(rulefd, &nbpwds, sizeof(unsigned int)) != sizeof(unsigned int))
{
fprintf(stderr, "could not read nbpwd\n");
break;
}
if(nbpwds >= matchlimit)
{
nbloaded++;
link = newlink(rulestr, pwtested);
for(i=0;i<nbpwds;i++)
{
curval = 0;
if( read(rulefd, &curval, sizeof(unsigned int)) != sizeof(unsigned int) )
{
fprintf(stderr, "could not read password %ld/%ld\n", i, nbpwds);
break;
}
if(avl_insert(link->coverage, (void *) curval) == NULL)
{
if(errno == EEXIST)
continue;
perror("avl_insert");
exit(1);
}
}
link->next = rulejob[jobid].root;
if(rulejob[jobid].tail == NULL)
rulejob[jobid].tail = link;
rulejob[jobid].root = link;
}
else
{
lseek(rulefd, sizeof(unsigned int)*nbpwds, SEEK_CUR);
}
}
close(rulefd);
fprintf(stderr, "%s loaded [%d]\n", rulejob[jobid].filename, nbloaded);
}
fprintf(stderr, "[%d] EXITS\n", *tid);
return NULL;
}
void process_event_message(char* method, struct htsp_message_t* msg)
{
struct event_t* event;
uint32_t eventId;
int do_insert = 0;
htsp_get_uint(msg,"eventId",&eventId);
pthread_mutex_lock(&events_mutex);
event = event_get_nolock(eventId, msg->server);
#ifdef DEBUG_EVENTS
if (strcmp(method,"eventUpdate")==0) {
fprintf(stderr,"eventUpdate - %d\n",eventId);
} else {
fprintf(stderr,"eventAdd - %d\n",eventId);
}
#endif
if (event == NULL) {
do_insert = 1;
event = calloc(sizeof(struct event_t),1);
event->eventId = eventId;
if (strcmp(method,"eventUpdate")==0) {
fprintf(stderr,"WARNING: eventUpdate received for non-existent event %d, adding instead.\n",eventId);
}
} else {
event_free_items(event);
memset(event,0,sizeof(event));
if (strcmp(method,"eventAdd")==0) {
fprintf(stderr,"WARNING: eventAdd received for existing event %d, updating instead.\n",eventId);
}
}
htsp_get_uint(msg,"eventId",&event->eventId);
htsp_get_uint(msg,"channelId",&event->channelId);
htsp_get_int64(msg,"start",&event->start);
htsp_get_int64(msg,"stop",&event->stop);
event->title = htsp_get_string(msg,"title");
event->description = htsp_get_string(msg,"description");
htsp_get_uint(msg,"serieslinkId",&event->serieslinkId);
event->serieslinkUri = htsp_get_string(msg,"serieslinkUri");
htsp_get_uint(msg,"episodeId",&event->episodeId);
htsp_get_uint(msg,"episodeNumber",&event->episodeNumber);
htsp_get_uint(msg,"seasonNumber",&event->seasonNumber);
event->episodeUri = htsp_get_string(msg,"episodeUri");
htsp_get_uint(msg,"nextEventId",&event->nextEventId);
//htsp_dump_message(msg);
eventId = eventId * MAX_HTSP_SERVERS + msg->server;
if (do_insert) {
#ifdef USE_AVL
avl_insert(&events,(struct avl*)event);
#else
if (eventId < MAX_EVENT_ID)
events[eventId] = event;
#endif
#ifdef DEBUG_EVENTS
struct event_t* event2 = event_get_nolock(eventId);
if (event2 == NULL) {
fprintf(stderr,"ERROR: Inserted event %d but could not retrieve it.\n",eventId);
}
#endif
}
pthread_mutex_unlock(&events_mutex);
}
