void symbol_exit(void)
{
Symbol* q;
Symbol* p;
int i;
for(p = anchor; p != NULL; p = q)
{
assert(symbol_is_valid(p));
SID_del(p);
q = p->next;
for(i = 0; i < p->used; i++)
entry_free(p->entry[i]);
free(p->entry);
set_free(p->set);
hash_free(p->hash);
if (p->deflt != NULL)
entry_free(p->deflt);
free(p);
}
anchor = NULL;
}
static void entry_free(GoomHashEntry *entry) {
if (entry!=NULL) {
entry_free(entry->lower);
entry_free(entry->upper);
free(entry->key);
free(entry);
}
}
static ret_t
table_add_new_entry (cherokee_resolv_cache_t *resolv,
cherokee_buffer_t *domain,
cherokee_resolv_cache_entry_t **entry)
{
ret_t ret;
cherokee_resolv_cache_entry_t *n = NULL;
/* Instance the entry
*/
ret = entry_new (&n);
if (unlikely (ret != ret_ok)) {
return ret;
}
/* Fill it up
*/
ret = entry_fill_up (n, domain);
if (unlikely (ret != ret_ok)) {
entry_free (n);
return ret;
}
/* Add it to the table
*/
CHEROKEE_RWLOCK_WRITER (&resolv->lock);
ret = cherokee_avl_add (&resolv->table, domain, (void **)n);
CHEROKEE_RWLOCK_UNLOCK (&resolv->lock);
*entry = n;
return ret_ok;
}
int
run_delete_event (const char *cmd, size_t argc, char *argv[])
{
if (argc != 1) {
fprintf (stderr,
_("use 'delete-event <name>' to delete an event handler\n"));
return -1;
}
const struct entry key = { .name = argv[0] };
struct entry *entry, *p;
entry = hash_delete (event_handlers, &key);
if (!entry) {
fprintf (stderr, _("delete-event: %s: no such event handler\n"), argv[0]);
return -1;
}
/* Delete them from the handle. */
p = entry;
while (p) {
guestfs_delete_event_callback (g, p->eh);
p = p->next;
}
/* Free the structures. */
entry_free (entry);
return 0;
}
int wt_entry_return(
Entry *e
)
{
if ( !e ) {
return 0;
}
/* Our entries are allocated in two blocks; the data comes from
* the db itself and the Entry structure and associated pointers
* are allocated in entry_decode. The db data pointer is saved
* in e_bv.
*/
if ( e->e_bv.bv_val ) {
#if 0
/* See if the DNs were changed by modrdn */
if( e->e_nname.bv_val < e->e_bv.bv_val || e->e_nname.bv_val >
e->e_bv.bv_val + e->e_bv.bv_len ) {
ch_free(e->e_name.bv_val);
ch_free(e->e_nname.bv_val);
}
#endif
e->e_name.bv_val = NULL;
e->e_nname.bv_val = NULL;
/* In tool mode the e_bv buffer is realloc'd, leave it alone */
if( !(slapMode & SLAP_TOOL_MODE) ) {
free( e->e_bv.bv_val );
}
BER_BVZERO( &e->e_bv );
}
entry_free( e );
}
/*
* Lies ein attrval-record nach position `offset' in `s'.
* Setze *pos (falls pos != 0).
* Liefere 0 bei Erfolg, -1 sonst.
* Bei Erfolg:
* - pos ist die exakte Anfangsposition.
* - Setze *entry auf den gelesenen Eintrag (falls entry != 0).
* - Setze *key auf den Schluessel (falls key != 0).
* EOF ist kein Fehler und liefert *key = 0 (falls key != 0);
*/
int
ldif_read_entry(FILE *s, long offset, char **key, tentry **entry, long *pos)
{
GString *tmp1 = g_string_new("");
GString *tmp2 = g_string_new("");
char *dn;
char *k = 0;
tentry *e = 0;
int rc = ldif_read_header(tmp1, tmp2, s, offset, &k, &dn, pos);
if (rc || !k) goto cleanup;
e = entry_new(dn);
rc = ldif_read_attrval_body(tmp1, tmp2, s, e);
if (!rc) {
if (entry) {
*entry = e;
e = 0;
}
if (key) {
*key = k;
k = 0;
}
}
cleanup:
if (k) free(k);
if (e) entry_free(e);
g_string_free(tmp1, 1);
g_string_free(tmp2, 1);
return rc;
}
/*..........................................................................*/
void lsa_entry_exit(raid5_entry_t *rentry)
{
while (!list_empty(&rentry->free)) {
Entry *me = list_entry(rentry->free.next, Entry, entry);
list_del(&me->entry);
entry_free(me);
}
}
void avahi_hashmap_free(AvahiHashmap *m) {
assert(m);
while (m->entries_list)
entry_free(m, m->entries_list, 0);
avahi_free(m);
}
void entry_destroy(entry_t *e)
{
if (e != NULL) {
sdsdel(e->key);
sdsdel(e->value);
entry_free(e);
}
}
static void entry_remove_and_free(pa_autoload_entry *e) {
pa_assert(e);
pa_assert(e->core);
pa_idxset_remove_by_data(e->core->autoload_idxset, e, NULL);
pa_hashmap_remove(e->core->autoload_hashmap, e->name);
entry_free(e);
}
void avahi_hashmap_remove(AvahiHashmap *m, const void *key) {
Entry *e;
assert(m);
if (!(e = entry_get(m, key)))
return;
entry_free(m, e, 0);
}
static void
entry_free (void *x)
{
if (x) {
struct entry *p = x;
entry_free (p->next);
free (p->name);
free (p->command);
free (p);
}
}
/*********************************************************************************
* The contents of this file are subject to the Common Public Attribution
* License Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.openemm.org/cpal1.html. The License is based on the Mozilla
* Public License Version 1.1 but Sections 14 and 15 have been added to cover
* use of software over a computer network and provide for limited attribution
* for the Original Developer. In addition, Exhibit A has been modified to be
* consistent with Exhibit B.
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* The Original Code is OpenEMM.
* The Original Developer is the Initial Developer.
* The Initial Developer of the Original Code is AGNITAS AG. All portions of
* the code written by AGNITAS AG are Copyright (c) 2007 AGNITAS AG. All Rights
* Reserved.
*
* Contributor(s): AGNITAS AG.
********************************************************************************/
# include <stdlib.h>
# include <unistd.h>
# include <fcntl.h>
# include <string.h>
# include <dirent.h>
# include <errno.h>
# include <sys/types.h>
# include <sys/stat.h>
# include "qctrl.h"
entry_t *
entry_alloc (const char *fname, int match) /*{{{*/
{
entry_t *e;
if (e = (entry_t *) malloc (sizeof (entry_t))) {
e -> fname = NULL;
e -> match = match;
e -> next = NULL;
if (fname && (! (e -> fname = strdup (fname))))
e = entry_free (e);
}
return e;
}/*}}}*/
entry_t *
entry_free (entry_t *e) /*{{{*/
{
if (e) {
if (e -> fname)
free (e -> fname);
free (e);
}
return NULL;
}/*}}}*/
entry_t *
entry_free_all (entry_t *e) /*{{{*/
{
entry_t *tmp;
while (tmp = e) {
e = e -> next;
entry_free (tmp);
}
return NULL;
}/*}}}*/
/*----------------------------------------------------------------------------*/
static void
purge_flowtable(void)
{
entry_t *e;
entry_t *next;
for(e = list_head(flowtable); e != NULL;) {
next = e->next;
entry_free(e);
e = next;
}
}
/* Entry is eaten.
* No check is done if entry->tuple is a member of sym->set !
* This has to be done before.
*/
void symbol_add_entry(Symbol* sym, Entry* entry)
{
const Tuple* tuple;
assert(symbol_is_valid(sym));
assert(entry_is_valid(entry));
assert(sym->used <= sym->size);
if (sym->used == sym->size)
{
sym->size += sym->extend;
sym->extend += sym->extend;
sym->entry = realloc(
sym->entry, (size_t)sym->size * sizeof(*sym->entry));
assert(sym->entry != NULL);
}
assert(sym->used < sym->size);
tuple = entry_get_tuple(entry);
/* There is no index set for the internal symbol.
*/
assert(!strcmp(sym->name, SYMBOL_NAME_INTERNAL) || set_lookup(sym->set, tuple));
if (hash_has_entry(sym->hash, tuple))
{
if (stmt_trigger_warning(166))
{
fprintf(stderr, "--- Warning 166: Duplicate element ");
tuple_print(stderr, tuple);
fprintf(stderr, " for symbol %s rejected\n", sym->name);
}
entry_free(entry);
}
else
{
/* Falls noch nicht geschehen, legen wir hier den Typ des
* Symbols fest.
*/
if ((sym->type == SYM_ERR) && (sym->used == 0))
sym->type = entry_get_type(entry);
assert(sym->type != SYM_ERR);
hash_add_entry(sym->hash, entry);
sym->entry[sym->used] = entry;
sym->used++;
}
}
entry_t *
entry_alloc (const char *fname, int match) /*{{{*/
{
entry_t *e;
if (e = (entry_t *) malloc (sizeof (entry_t))) {
e -> fname = NULL;
e -> match = match;
e -> next = NULL;
if (fname && (! (e -> fname = strdup (fname))))
e = entry_free (e);
}
return e;
}/*}}}*/
void table_destroy (table_t *table)
{
entry_t *entry, *tmp;
assert(table != NULL);
entry = table->entries;
while (entry != NULL)
{
tmp = entry;
entry = entry->next;
entry_free(tmp);
}
if (table->hash != NULL)
hash_free(table->hash);
}
/* Obey and clear rs->sr_flags & REP_ENTRY_MASK. Clear sr_entry if freed. */
void
rs_flush_entry( Operation *op, SlapReply *rs, slap_overinst *on )
{
rs_assert_ok( rs );
if ( (rs->sr_flags & REP_ENTRY_MUSTFLUSH) && rs->sr_entry != NULL ) {
if ( !(rs->sr_flags & REP_ENTRY_MUSTRELEASE) ) {
entry_free( rs->sr_entry );
} else if ( on != NULL ) {
overlay_entry_release_ov( op, rs->sr_entry, 0, on );
} else {
be_entry_release_rw( op, rs->sr_entry, 0 );
}
rs->sr_entry = NULL;
}
rs->sr_flags &= ~REP_ENTRY_MASK;
}
/* Set rs->sr_entry after obyeing and clearing sr_flags & REP_ENTRY_MASK. */
void
rs_replace_entry( Operation *op, SlapReply *rs, slap_overinst *on, Entry *e )
{
slap_mask_t e_flags = rs->sr_flags & REP_ENTRY_MUSTFLUSH;
if ( e_flags && rs->sr_entry != NULL ) {
RS_ASSERT( e_flags != REP_ENTRY_MUSTFLUSH );
if ( !(e_flags & REP_ENTRY_MUSTRELEASE) ) {
entry_free( rs->sr_entry );
} else if ( on != NULL ) {
overlay_entry_release_ov( op, rs->sr_entry, 0, on );
} else {
be_entry_release_rw( op, rs->sr_entry, 0 );
}
}
rs->sr_flags &= ~REP_ENTRY_MASK;
rs->sr_entry = e;
}
Entry* ndb_tool_entry_get( BackendDB *be, ID id )
{
NdbArgs NA;
int rc;
char text[1024];
Operation op = {0};
Opheader ohdr = {0};
assert( be != NULL );
assert( slapMode & SLAP_TOOL_MODE );
NA.txn = myNdb->startTransaction();
if ( !NA.txn ) {
snprintf( text, sizeof(text),
"start_transaction failed: %s (%d)",
myNdb->getNdbError().message, myNdb->getNdbError().code );
Debug( LDAP_DEBUG_ANY,
"=> " LDAP_XSTRING(ndb_tool_entry_get) ": %s\n",
text, 0, 0 );
return NULL;
}
NA.e = entry_alloc();
NA.e->e_id = id;
ber_dupbv( &NA.e->e_name, &myDn );
dnNormalize( 0, NULL, NULL, &NA.e->e_name, &NA.e->e_nname, NULL );
op.o_hdr = &ohdr;
op.o_bd = be;
op.o_tmpmemctx = NULL;
op.o_tmpmfuncs = &ch_mfuncs;
NA.ndb = myNdb;
NA.ocs = myOcList;
rc = ndb_entry_get_data( &op, &NA, 0 );
if ( rc ) {
entry_free( NA.e );
NA.e = NULL;
}
NA.txn->close();
return NA.e;
}
int bdb_entry_return(
Entry *e )
{
/* Our entries are allocated in two blocks; the data comes from
* the db itself and the Entry structure and associated pointers
* are allocated in entry_decode. The db data pointer is saved
* in e_bv. Since the Entry structure is allocated as a single
* block, e_attrs is always a fixed offset from e. The exception
* is when an entry has been modified, in which case we also need
* to free e_attrs.
*/
if( !e->e_bv.bv_val ) { /* A regular entry, from do_add */
entry_free( e );
return 0;
}
if( (void *) e->e_attrs != (void *) (e+1)) {
attrs_free( e->e_attrs );
}
#ifndef BDB_HIER
/* See if the DNs were changed by modrdn */
if( e->e_nname.bv_val < e->e_bv.bv_val || e->e_nname.bv_val >
e->e_bv.bv_val + e->e_bv.bv_len ) {
ch_free(e->e_name.bv_val);
ch_free(e->e_nname.bv_val);
e->e_name.bv_val = NULL;
e->e_nname.bv_val = NULL;
}
#else
/* We had to construct the dn and ndn as well, in a single block */
if( e->e_name.bv_val ) {
free( e->e_name.bv_val );
}
#endif
/* In tool mode the e_bv buffer is realloc'd, leave it alone */
if( !(slapMode & SLAP_TOOL_MODE) ) {
free( e->e_bv.bv_val );
}
free( e );
return 0;
}
/* Create the remaining hardlinks in the target directory */
gboolean mk_hlink(GSList * h)
{
struct rdup *e;
GSList *p;
struct stat *st;
gchar *parent;
if (opt_dry)
return TRUE;
for (p = g_slist_nth(h, 0); p; p = p->next) {
e = (struct rdup *)p->data;
if (link(e->f_target, e->f_name) == -1) {
if (errno == EACCES) {
parent = dir_parent(e->f_name);
st = dir_write(parent);
if (link(e->f_target, e->f_name) == -1) {
msgd(__func__, __LINE__,
_
("Failed to create hardlink `%s -> %s\': %s"),
e->f_name, e->f_target,
strerror(errno));
dir_restore(parent, st);
g_free(parent);
return FALSE;
}
dir_restore(parent, st);
g_free(parent);
return TRUE;
} else {
msgd(__func__, __LINE__,
_
("Failed to create hardlink `%s -> %s\': %s"),
e->f_name, e->f_target, strerror(errno));
return FALSE;
}
}
entry_free(e);
}
return TRUE;
}
void list_free(List* list)
{
ListElem* p;
ListElem* q;
assert(list_is_valid(list));
list->refc--;
if (list->refc == 0)
{
SID_del(list);
for(p = list->anchor.next; p != &list->anchor; p = q)
{
q = p->next;
switch(list->type)
{
case LIST_ELEM :
elem_free(p->data.elem);
break;
case LIST_TUPLE :
tuple_free(p->data.tuple);
break;
case LIST_ENTRY :
entry_free(p->data.entry);
break;
case LIST_IDXELEM :
break;
case LIST_LIST :
list_free(p->data.list);
break;
default :
abort();
}
blk_free(p, sizeof(*p));
}
free(list);
}
}
/*
* releases the lock of the entry; if it is marked as volatile, it is
* destroyed.
*/
int
monitor_cache_release(
monitor_info_t *mi,
Entry *e )
{
monitor_entry_t *mp;
assert( mi != NULL );
assert( e != NULL );
assert( e->e_private != NULL );
mp = ( monitor_entry_t * )e->e_private;
if ( mp->mp_flags & MONITOR_F_VOLATILE ) {
monitor_cache_t *mc, tmp_mc;
/* volatile entries do not return to cache */
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
tmp_mc.mc_ndn = e->e_nname;
mc = avl_delete( &mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp );
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
if ( mc != NULL ) {
ch_free( mc );
}
ldap_pvt_thread_mutex_unlock( &mp->mp_mutex );
ldap_pvt_thread_mutex_destroy( &mp->mp_mutex );
ch_free( mp );
e->e_private = NULL;
entry_free( e );
return( 0 );
}
ldap_pvt_thread_mutex_unlock( &mp->mp_mutex );
return( 0 );
}
int hash_map_remove(struct hash_map_t *self_p,
long key)
{
ASSERTN(self_p != NULL, EINVAL);
int hash;
struct hash_map_bucket_t *bucket_p;
struct hash_map_entry_t *entry_p, *prev_p;
/* Hash key. */
hash = self_p->hash(key);
hash %= self_p->buckets_max;
bucket_p = &self_p->buckets_p[hash];
/* Is the key already in map? */
if (bucket_p->list_p != NULL) {
entry_p = bucket_p->list_p;
prev_p = NULL;
while (entry_p != NULL) {
if (entry_p->key == key) {
if (prev_p != NULL) {
prev_p->next_p = entry_p->next_p;
} else {
bucket_p->list_p = entry_p->next_p;
}
entry_free(self_p, entry_p);
return (0);
}
prev_p = entry_p;
entry_p = entry_p->next_p;
}
}
return (-1);
}
/*----------------------------------------------------------------------------*/
void
test_flowtable(void)
{
uint8_t array[25] = {
20, 18, 0, 6, 0, 2, 82, 0, 15, 0, 1, 114,
0, 16, 0, 2, 50, 0, 17, 0, 5, 1, 4, 254,
0};
if (!list_length(flowtable)){
entry_t* e = get_entry_from_array(array,25);
if (e != NULL){
add_entry(e);
}
}else{
entry_free(list_pop(flowtable));
}
uint8_t array1[116] = {
1, 116, 0, 0, 0, 2, 2, 100, 0, 0,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 90, 10, 10, 10, 11, 22, 10, 12, 10,
35, 11, 14, 18, 16, 12, 10, 10, 10, 40,
40, 10, 18, 15, 11, 10, 10, 10, 10, 10,
50, 11, 13, 13, 12, 25, 25, 31, 11, 01,
61, 11, 17, 18, 16, 13, 10, 11, 10, 12,
71, 11, 17, 18, 16, 13, 10, 11, 10, 12,
81, 11, 17, 18, 16, 13, 10, 11, 10, 12,
91, 11, 17, 18, 16, 13, 10, 11, 10, 12,
11, 11, 17, 18, 16, 13, 10, 11, 10, 12,
10, 13, 254,11, 12, 13
};
packet_t* p = get_packet_from_array(array1);
match_packet(p);
packet_deallocate(p);
}
static void
monitor_entry_destroy( void *v_mc )
{
monitor_cache_t *mc = (monitor_cache_t *)v_mc;
if ( mc->mc_e != NULL ) {
monitor_entry_t *mp;
assert( mc->mc_e->e_private != NULL );
mp = ( monitor_entry_t * )mc->mc_e->e_private;
if ( mp->mp_cb ) {
monitor_callback_t *cb;
for ( cb = mp->mp_cb; cb != NULL; ) {
monitor_callback_t *next = cb->mc_next;
if ( cb->mc_free ) {
(void)cb->mc_free( mc->mc_e, &cb->mc_private );
}
ch_free( mp->mp_cb );
cb = next;
}
}
ldap_pvt_thread_mutex_destroy( &mp->mp_mutex );
ch_free( mp );
mc->mc_e->e_private = NULL;
entry_free( mc->mc_e );
}
ch_free( mc );
}
/*
* Read the entries specified in fname and merge the attributes
* to the user defined baseObject entry. Note that if we find any errors
* what so ever, we will discard the entire entries, print an
* error message and return.
*/
static int
read_baseObject(
BackendDB *be,
const char *fname )
{
backsql_info *bi = (backsql_info *)be->be_private;
LDIFFP *fp;
int rc = 0, lmax = 0, ldifrc;
unsigned long lineno = 0;
char *buf = NULL;
assert( fname != NULL );
fp = ldif_open( fname, "r" );
if ( fp == NULL ) {
Debug( LDAP_DEBUG_ANY,
"could not open back-sql baseObject "
"attr file \"%s\" - absolute path?\n",
fname, 0, 0 );
perror( fname );
return LDAP_OTHER;
}
bi->sql_baseObject = entry_alloc();
if ( bi->sql_baseObject == NULL ) {
Debug( LDAP_DEBUG_ANY,
"read_baseObject_file: entry_alloc failed", 0, 0, 0 );
ldif_close( fp );
return LDAP_NO_MEMORY;
}
bi->sql_baseObject->e_name = be->be_suffix[0];
bi->sql_baseObject->e_nname = be->be_nsuffix[0];
bi->sql_baseObject->e_attrs = NULL;
while (( ldifrc = ldif_read_record( fp, &lineno, &buf, &lmax )) > 0 ) {
Entry *e = str2entry( buf );
Attribute *a;
if( e == NULL ) {
fprintf( stderr, "back-sql baseObject: "
"could not parse entry (line=%lu)\n",
lineno );
rc = LDAP_OTHER;
break;
}
/* make sure the DN is the database's suffix */
if ( !be_issuffix( be, &e->e_nname ) ) {
fprintf( stderr,
"back-sql: invalid baseObject - "
"dn=\"%s\" (line=%lu)\n",
e->e_name.bv_val, lineno );
entry_free( e );
rc = LDAP_OTHER;
break;
}
/*
* we found a valid entry, so walk thru all the attributes in the
* entry, and add each attribute type and description to baseObject
*/
for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
if ( attr_merge( bi->sql_baseObject, a->a_desc,
a->a_vals,
( a->a_nvals == a->a_vals ) ?
NULL : a->a_nvals ) )
{
rc = LDAP_OTHER;
break;
}
}
entry_free( e );
if ( rc ) {
break;
}
}
if ( ldifrc < 0 )
rc = LDAP_OTHER;
if ( rc ) {
entry_free( bi->sql_baseObject );
bi->sql_baseObject = NULL;
}
ch_free( buf );
ldif_close( fp );
Debug( LDAP_DEBUG_CONFIG, "back-sql baseObject file \"%s\" read.\n",
fname, 0, 0 );
return rc;
}
static int
sql_cf_gen( ConfigArgs *c )
{
backsql_info *bi = (backsql_info *)c->be->be_private;
int rc = 0;
if ( c->op == SLAP_CONFIG_EMIT ) {
switch( c->type ) {
case BSQL_CONCAT_PATT:
if ( bi->sql_concat_patt ) {
c->value_string = ch_strdup( bi->sql_concat_patt );
} else {
rc = 1;
}
break;
case BSQL_CREATE_NEEDS_SEL:
if ( bi->sql_flags & BSQLF_CREATE_NEEDS_SELECT )
c->value_int = 1;
break;
case BSQL_UPPER_NEEDS_CAST:
if ( bi->sql_flags & BSQLF_UPPER_NEEDS_CAST )
c->value_int = 1;
break;
case BSQL_HAS_LDAPINFO_DN_RU:
if ( !(bi->sql_flags & BSQLF_DONTCHECK_LDAPINFO_DN_RU) )
return 1;
if ( bi->sql_flags & BSQLF_HAS_LDAPINFO_DN_RU )
c->value_int = 1;
break;
case BSQL_FAIL_IF_NO_MAPPING:
if ( bi->sql_flags & BSQLF_FAIL_IF_NO_MAPPING )
c->value_int = 1;
break;
case BSQL_ALLOW_ORPHANS:
if ( bi->sql_flags & BSQLF_ALLOW_ORPHANS )
c->value_int = 1;
break;
case BSQL_SUBTREE_SHORTCUT:
if ( bi->sql_flags & BSQLF_USE_SUBTREE_SHORTCUT )
c->value_int = 1;
break;
case BSQL_FETCH_ALL_ATTRS:
if ( bi->sql_flags & BSQLF_FETCH_ALL_ATTRS )
c->value_int = 1;
break;
case BSQL_CHECK_SCHEMA:
if ( bi->sql_flags & BSQLF_CHECK_SCHEMA )
c->value_int = 1;
break;
case BSQL_AUTOCOMMIT:
if ( bi->sql_flags & BSQLF_AUTOCOMMIT_ON )
c->value_int = 1;
break;
case BSQL_BASE_OBJECT:
if ( bi->sql_base_ob_file ) {
c->value_string = ch_strdup( bi->sql_base_ob_file );
} else if ( bi->sql_baseObject ) {
c->value_string = ch_strdup( "TRUE" );
} else {
rc = 1;
}
break;
case BSQL_LAYER:
if ( bi->sql_api ) {
backsql_api *ba;
struct berval bv;
char *ptr;
int i;
for ( ba = bi->sql_api; ba; ba = ba->ba_next ) {
bv.bv_len = strlen( ba->ba_name );
if ( ba->ba_argc ) {
for ( i = 0; i<ba->ba_argc; i++ )
bv.bv_len += strlen( ba->ba_argv[i] ) + 3;
}
bv.bv_val = ch_malloc( bv.bv_len + 1 );
ptr = lutil_strcopy( bv.bv_val, ba->ba_name );
if ( ba->ba_argc ) {
for ( i = 0; i<ba->ba_argc; i++ ) {
*ptr++ = ' ';
*ptr++ = '"';
ptr = lutil_strcopy( ptr, ba->ba_argv[i] );
*ptr++ = '"';
}
}
ber_bvarray_add( &c->rvalue_vals, &bv );
}
} else {
rc = 1;
}
break;
case BSQL_ALIASING_KEYWORD:
if ( !BER_BVISNULL( &bi->sql_aliasing )) {
struct berval bv;
bv = bi->sql_aliasing;
bv.bv_len--;
value_add_one( &c->rvalue_vals, &bv );
} else {
rc = 1;
}
break;
case BSQL_FETCH_ATTRS:
if ( bi->sql_anlist ||
( bi->sql_flags & (BSQLF_FETCH_ALL_USERATTRS|
BSQLF_FETCH_ALL_OPATTRS)))
{
char buf[BUFSIZ*2], *ptr;
struct berval bv;
# define WHATSLEFT ((ber_len_t) (&buf[sizeof( buf )] - ptr))
ptr = buf;
if ( bi->sql_anlist ) {
ptr = anlist_unparse( bi->sql_anlist, ptr, WHATSLEFT );
if ( ptr == NULL )
return 1;
}
if ( bi->sql_flags & BSQLF_FETCH_ALL_USERATTRS ) {
if ( WHATSLEFT <= STRLENOF( ",*" )) return 1;
if ( ptr != buf ) *ptr++ = ',';
*ptr++ = '*';
}
if ( bi->sql_flags & BSQLF_FETCH_ALL_OPATTRS ) {
if ( WHATSLEFT <= STRLENOF( ",+" )) return 1;
if ( ptr != buf ) *ptr++ = ',';
*ptr++ = '+';
}
bv.bv_val = buf;
bv.bv_len = ptr - buf;
value_add_one( &c->rvalue_vals, &bv );
}
break;
}
return rc;
} else if ( c->op == LDAP_MOD_DELETE ) { /* FIXME */
return -1;
}
switch( c->type ) {
case BSQL_CONCAT_PATT:
if ( backsql_split_pattern( c->argv[ 1 ], &bi->sql_concat_func, 2 ) ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"%s: unable to parse pattern \"%s\"",
c->log, c->argv[ 1 ] );
Debug( LDAP_DEBUG_ANY, "%s\n", c->cr_msg, 0, 0 );
return -1;
}
bi->sql_concat_patt = c->value_string;
break;
case BSQL_CREATE_NEEDS_SEL:
if ( c->value_int )
bi->sql_flags |= BSQLF_CREATE_NEEDS_SELECT;
else
bi->sql_flags &= ~BSQLF_CREATE_NEEDS_SELECT;
break;
case BSQL_UPPER_NEEDS_CAST:
if ( c->value_int )
bi->sql_flags |= BSQLF_UPPER_NEEDS_CAST;
else
bi->sql_flags &= ~BSQLF_UPPER_NEEDS_CAST;
break;
case BSQL_HAS_LDAPINFO_DN_RU:
bi->sql_flags |= BSQLF_DONTCHECK_LDAPINFO_DN_RU;
if ( c->value_int )
bi->sql_flags |= BSQLF_HAS_LDAPINFO_DN_RU;
else
bi->sql_flags &= ~BSQLF_HAS_LDAPINFO_DN_RU;
break;
case BSQL_FAIL_IF_NO_MAPPING:
if ( c->value_int )
bi->sql_flags |= BSQLF_FAIL_IF_NO_MAPPING;
else
bi->sql_flags &= ~BSQLF_FAIL_IF_NO_MAPPING;
break;
case BSQL_ALLOW_ORPHANS:
if ( c->value_int )
bi->sql_flags |= BSQLF_ALLOW_ORPHANS;
else
bi->sql_flags &= ~BSQLF_ALLOW_ORPHANS;
break;
case BSQL_SUBTREE_SHORTCUT:
if ( c->value_int )
bi->sql_flags |= BSQLF_USE_SUBTREE_SHORTCUT;
else
bi->sql_flags &= ~BSQLF_USE_SUBTREE_SHORTCUT;
break;
case BSQL_FETCH_ALL_ATTRS:
if ( c->value_int )
bi->sql_flags |= BSQLF_FETCH_ALL_ATTRS;
else
bi->sql_flags &= ~BSQLF_FETCH_ALL_ATTRS;
break;
case BSQL_CHECK_SCHEMA:
if ( c->value_int )
bi->sql_flags |= BSQLF_CHECK_SCHEMA;
else
bi->sql_flags &= ~BSQLF_CHECK_SCHEMA;
break;
case BSQL_AUTOCOMMIT:
if ( c->value_int )
bi->sql_flags |= BSQLF_AUTOCOMMIT_ON;
else
bi->sql_flags &= ~BSQLF_AUTOCOMMIT_ON;
break;
case BSQL_BASE_OBJECT:
if ( c->be->be_nsuffix == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"%s: suffix must be set", c->log );
Debug( LDAP_DEBUG_ANY, "%s\n", c->cr_msg, 0, 0 );
rc = ARG_BAD_CONF;
break;
}
if ( bi->sql_baseObject ) {
Debug( LDAP_DEBUG_CONFIG,
"%s: "
"\"baseObject\" already provided (will be overwritten)\n",
c->log, 0, 0 );
entry_free( bi->sql_baseObject );
}
if ( c->argc == 2 && !strcmp( c->argv[1], "TRUE" ))
c->argc = 1;
switch( c->argc ) {
case 1:
return create_baseObject( c->be, c->fname, c->lineno );
case 2:
rc = read_baseObject( c->be, c->argv[ 1 ] );
if ( rc == 0 ) {
ch_free( bi->sql_base_ob_file );
bi->sql_base_ob_file = c->value_string;
}
return rc;
default:
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"%s: trailing values in directive", c->log );
Debug( LDAP_DEBUG_ANY, "%s\n", c->cr_msg, 0, 0 );
return 1;
}
break;
case BSQL_LAYER:
if ( backsql_api_config( bi, c->argv[ 1 ], c->argc - 2, &c->argv[ 2 ] ) )
{
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"%s: unable to load sql layer", c->log );
Debug( LDAP_DEBUG_ANY, "%s \"%s\"\n",
c->cr_msg, c->argv[1], 0 );
return 1;
}
break;
case BSQL_ALIASING_KEYWORD:
if ( ! BER_BVISNULL( &bi->sql_aliasing ) ) {
ch_free( bi->sql_aliasing.bv_val );
}
ber_str2bv( c->argv[ 1 ], strlen( c->argv[ 1 ] ) + 1, 1,
&bi->sql_aliasing );
/* add a trailing space... */
bi->sql_aliasing.bv_val[ bi->sql_aliasing.bv_len - 1] = ' ';
break;
case BSQL_FETCH_ATTRS: {
char *str, *s, *next;
const char *delimstr = ",";
str = ch_strdup( c->argv[ 1 ] );
for ( s = ldap_pvt_strtok( str, delimstr, &next );
s != NULL;
s = ldap_pvt_strtok( NULL, delimstr, &next ) )
{
if ( strlen( s ) == 1 ) {
if ( *s == '*' ) {
bi->sql_flags |= BSQLF_FETCH_ALL_USERATTRS;
c->argv[ 1 ][ s - str ] = ',';
} else if ( *s == '+' ) {
bi->sql_flags |= BSQLF_FETCH_ALL_OPATTRS;
c->argv[ 1 ][ s - str ] = ',';
}
}
}
ch_free( str );
bi->sql_anlist = str2anlist( bi->sql_anlist, c->argv[ 1 ], delimstr );
if ( bi->sql_anlist == NULL ) {
return -1;
}
}
break;
}
return rc;
}
int
fe_op_search( Operation *op, SlapReply *rs )
{
BackendDB *bd = op->o_bd;
if ( op->ors_scope == LDAP_SCOPE_BASE ) {
Entry *entry = NULL;
if ( BER_BVISEMPTY( &op->o_req_ndn ) ) {
#ifdef LDAP_CONNECTIONLESS
/* Ignore LDAPv2 CLDAP Root DSE queries */
if (op->o_protocol == LDAP_VERSION2 && op->o_conn->c_is_udp) {
goto return_results;
}
#endif
/* check restrictions */
if( backend_check_restrictions( op, rs, NULL ) != LDAP_SUCCESS ) {
send_ldap_result( op, rs );
goto return_results;
}
rs->sr_err = root_dse_info( op->o_conn, &entry, &rs->sr_text );
} else if ( bvmatch( &op->o_req_ndn, &frontendDB->be_schemandn ) ) {
/* check restrictions */
if( backend_check_restrictions( op, rs, NULL ) != LDAP_SUCCESS ) {
send_ldap_result( op, rs );
goto return_results;
}
rs->sr_err = schema_info( &entry, &rs->sr_text );
}
if( rs->sr_err != LDAP_SUCCESS ) {
send_ldap_result( op, rs );
goto return_results;
} else if ( entry != NULL ) {
if ( get_assert( op ) &&
( test_filter( op, entry, get_assertion( op )) != LDAP_COMPARE_TRUE )) {
rs->sr_err = LDAP_ASSERTION_FAILED;
goto fail1;
}
rs->sr_err = test_filter( op, entry, op->ors_filter );
if( rs->sr_err == LDAP_COMPARE_TRUE ) {
/* note: we set no limits because either
* no limit is specified, or at least 1
* is specified, and we're going to return
* at most one entry */
op->ors_slimit = SLAP_NO_LIMIT;
op->ors_tlimit = SLAP_NO_LIMIT;
rs->sr_entry = entry;
rs->sr_attrs = op->ors_attrs;
rs->sr_operational_attrs = NULL;
rs->sr_flags = 0;
send_search_entry( op, rs );
rs->sr_entry = NULL;
rs->sr_operational_attrs = NULL;
}
rs->sr_err = LDAP_SUCCESS;
fail1:
entry_free( entry );
send_ldap_result( op, rs );
goto return_results;
}
}
if( BER_BVISEMPTY( &op->o_req_ndn ) && !BER_BVISEMPTY( &default_search_nbase ) ) {
slap_sl_free( op->o_req_dn.bv_val, op->o_tmpmemctx );
slap_sl_free( op->o_req_ndn.bv_val, op->o_tmpmemctx );
ber_dupbv_x( &op->o_req_dn, &default_search_base, op->o_tmpmemctx );
ber_dupbv_x( &op->o_req_ndn, &default_search_nbase, op->o_tmpmemctx );
}
/*
* We could be serving multiple database backends. Select the
* appropriate one, or send a referral to our "referral server"
* if we don't hold it.
*/
op->o_bd = select_backend( &op->o_req_ndn, 1 );
if ( op->o_bd == NULL ) {
rs->sr_ref = referral_rewrite( default_referral,
NULL, &op->o_req_dn, op->ors_scope );
if (!rs->sr_ref) rs->sr_ref = default_referral;
rs->sr_err = LDAP_REFERRAL;
op->o_bd = bd;
send_ldap_result( op, rs );
if (rs->sr_ref != default_referral)
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
goto return_results;
}
/* check restrictions */
if( backend_check_restrictions( op, rs, NULL ) != LDAP_SUCCESS ) {
send_ldap_result( op, rs );
goto return_results;
}
/* check for referrals */
if( backend_check_referrals( op, rs ) != LDAP_SUCCESS ) {
goto return_results;
}
if ( SLAP_SHADOW(op->o_bd) && get_dontUseCopy(op) ) {
/* don't use shadow copy */
BerVarray defref = op->o_bd->be_update_refs
? op->o_bd->be_update_refs : default_referral;
if( defref != NULL ) {
rs->sr_ref = referral_rewrite( defref,
NULL, &op->o_req_dn, op->ors_scope );
if( !rs->sr_ref) rs->sr_ref = defref;
rs->sr_err = LDAP_REFERRAL;
send_ldap_result( op, rs );
if (rs->sr_ref != defref) ber_bvarray_free( rs->sr_ref );
} else {
send_ldap_error( op, rs, LDAP_UNWILLING_TO_PERFORM,
"copy not used; no referral information available" );
}
} else if ( op->o_bd->be_search ) {
if ( limits_check( op, rs ) == 0 ) {
/* actually do the search and send the result(s) */
(op->o_bd->be_search)( op, rs );
}
/* else limits_check() sends error */
} else {
send_ldap_error( op, rs, LDAP_UNWILLING_TO_PERFORM,
"operation not supported within namingContext" );
}
return_results:;
op->o_bd = bd;
return rs->sr_err;
}