From: Howard Chu Date: Sat, 6 Dec 2003 23:53:46 +0000 (+0000) Subject: Remove trailing whitespace X-Git-Tag: OPENLDAP_REL_ENG_2_1_MP~247 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=44fc00b4c0370d59e29e814b307446238c01ffbc;p=openldap Remove trailing whitespace --- diff --git a/servers/slapd/overlays/pcache.c b/servers/slapd/overlays/pcache.c index bda597b379..2055816b91 100644 --- a/servers/slapd/overlays/pcache.c +++ b/servers/slapd/overlays/pcache.c @@ -47,52 +47,52 @@ typedef struct Query_s { /* struct representing a cached query */ typedef struct cached_query_s { - Query query; /* LDAP query */ - struct berval q_uuid; /* query identifier */ - int template_id; /* template of the query */ - time_t expiry_time; /* time till the query is considered valid */ + Query query; /* LDAP query */ + struct berval q_uuid; /* query identifier */ + int template_id; /* template of the query */ + time_t expiry_time; /* time till the query is considered valid */ struct cached_query_s *next; /* next query in the template */ struct cached_query_s *prev; /* previous query in the template */ - struct cached_query_s *lru_up; /* previous query in the LRU list */ - struct cached_query_s *lru_down; /* next query in the LRU list */ -} CachedQuery; + struct cached_query_s *lru_up; /* previous query in the LRU list */ + struct cached_query_s *lru_down; /* next query in the LRU list */ +} CachedQuery; /* struct representing a query template - * e.g. template string = &(cn=)(mail=) + * e.g. template string = &(cn=)(mail=) */ typedef struct query_template_s { struct berval querystr; /* Filter string corresponding to the QT */ - int attr_set_index; /* determines the projected attributes */ + int attr_set_index; /* determines the projected attributes */ - CachedQuery* query; /* most recent query cached for the template */ - CachedQuery* query_last; /* oldest query cached for the template */ + CachedQuery* query; /* most recent query cached for the template */ + CachedQuery* query_last; /* oldest query cached for the template */ int no_of_queries; /* Total number of queries in the template */ - long ttl; /* TTL for the queries of this template */ - ldap_pvt_thread_rdwr_t t_rwlock; /* Rd/wr lock for accessing queries in the template */ + long ttl; /* TTL for the queries of this template */ + ldap_pvt_thread_rdwr_t t_rwlock; /* Rd/wr lock for accessing queries in the template */ } QueryTemplate; -/* +/* * Represents a set of projected attributes and any - * supersets among all specified sets of attributes. + * supersets among all specified sets of attributes. */ struct attr_set { AttributeName* attrs; /* specifies the set */ - int count; /* number of attributes */ - int* ID_array; /* array of indices of supersets of 'attrs' */ + int count; /* number of attributes */ + int* ID_array; /* array of indices of supersets of 'attrs' */ }; -struct query_manager_s; +struct query_manager_s; -/* prototypes for functions for 1) query containment - * 2) query addition, 3) cache replacement +/* prototypes for functions for 1) query containment + * 2) query addition, 3) cache replacement */ typedef int (QCfunc)(struct query_manager_s*, Query*, int ); typedef void (AddQueryfunc)(struct query_manager_s*, Query*, int, struct berval*); typedef void (CRfunc)(struct query_manager_s*, struct berval * ); -/* LDAP query cache */ +/* LDAP query cache */ typedef struct query_manager_s { struct attr_set* attr_sets; /* possible sets of projected attributes */ QueryTemplate* templates; /* cacheable templates */ @@ -103,32 +103,32 @@ typedef struct query_manager_s { ldap_pvt_thread_mutex_t lru_mutex; /* mutex for accessing LRU list */ /* Query cache methods */ - QCfunc *qcfunc; /* Query containment*/ + QCfunc *qcfunc; /* Query containment*/ CRfunc *crfunc; /* cache replacement */ - AddQueryfunc *addfunc; /* add query */ -} query_manager; + AddQueryfunc *addfunc; /* add query */ +} query_manager; -/* LDAP query cache manager */ +/* LDAP query cache manager */ typedef struct cache_manager_s { BackendInfo *bi; /* underlying database info */ void *be_private; /* for the underlying database */ unsigned long num_cached_queries; /* total number of cached queries */ - unsigned long max_queries; /* upper bound on # of cached queries */ + unsigned long max_queries; /* upper bound on # of cached queries */ int numattrsets; /* number of attribute sets */ int numtemplates; /* number of cacheable templates */ - int cur_entries; /* current number of entries cached */ - int max_entries; /* max number of entries cached */ - int num_entries_limit; /* max # of entries in a cacheable query */ + int cur_entries; /* current number of entries cached */ + int max_entries; /* max number of entries cached */ + int num_entries_limit; /* max # of entries in a cacheable query */ - int cc_period; /* interval between successive consistency checks (sec) */ + int cc_period; /* interval between successive consistency checks (sec) */ int cc_paused; void *cc_arg; - ldap_pvt_thread_mutex_t cache_mutex; + ldap_pvt_thread_mutex_t cache_mutex; ldap_pvt_thread_mutex_t remove_mutex; - query_manager* qm; /* query cache managed by the cache manager */ -} cache_manager; + query_manager* qm; /* query cache managed by the cache manager */ +} cache_manager; static AttributeDescription *ad_queryid; static char *queryid_schema = "( 1.3.6.1.4.1.4203.666.1.12 NAME 'queryid' " @@ -158,7 +158,7 @@ merge_entry( attr = e->e_attrs; e->e_attrs = NULL; - /* add queryid attribute */ + /* add queryid attribute */ attr_merge_one( e, ad_queryid, query_uuid, NULL ); /* append the attribute list from the fetched entry */ @@ -203,9 +203,9 @@ merge_entry( /* compare base and scope of incoming and cached queries */ static int base_scope_compare( - struct berval* ndn_stored, - struct berval* ndn_incoming, - int scope_stored, + struct berval* ndn_stored, + struct berval* ndn_incoming, + int scope_stored, int scope_incoming ) { struct berval pdn_incoming = { 0, NULL }; @@ -215,7 +215,7 @@ static int base_scope_compare( if ( !dnIsSuffix(ndn_incoming, ndn_stored)) return 0; - + switch(scope_stored) { case LDAP_SCOPE_BASE: return (ndn_incoming->bv_len == ndn_stored->bv_len); @@ -223,7 +223,7 @@ static int base_scope_compare( case LDAP_SCOPE_ONELEVEL: switch(scope_incoming){ case LDAP_SCOPE_BASE: - dnParent(ndn_incoming, &pdn_incoming); + dnParent(ndn_incoming, &pdn_incoming); return (pdn_incoming.bv_len == ndn_stored->bv_len); case LDAP_SCOPE_ONELEVEL: @@ -237,26 +237,26 @@ static int base_scope_compare( break; default: return 0; - break; + break; } } /* add query on top of LRU list */ -static void -add_query_on_top (query_manager* qm, CachedQuery* qc) +static void +add_query_on_top (query_manager* qm, CachedQuery* qc) { - CachedQuery* top = qm->lru_top; - Query* q = (Query*)qc; - - qm->lru_top = qc; + CachedQuery* top = qm->lru_top; + Query* q = (Query*)qc; + + qm->lru_top = qc; - if (top) - top->lru_up = qc; + if (top) + top->lru_up = qc; else - qm->lru_bottom = qc; - - qc->lru_down = top; - qc->lru_up = NULL; + qm->lru_bottom = qc; + + qc->lru_down = top; + qc->lru_up = NULL; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Base of added query = %s\n", q->base.bv_val, 0, 0 ); @@ -268,37 +268,37 @@ add_query_on_top (query_manager* qm, CachedQuery* qc) /* remove_query from LRU list */ -static void -remove_query (query_manager* qm, CachedQuery* qc) +static void +remove_query (query_manager* qm, CachedQuery* qc) { - CachedQuery* up; - CachedQuery* down; + CachedQuery* up; + CachedQuery* down; - if (!qc) - return; + if (!qc) + return; - up = qc->lru_up; - down = qc->lru_down; + up = qc->lru_up; + down = qc->lru_down; - if (!up) - qm->lru_top = down; + if (!up) + qm->lru_top = down; - if (!down) - qm->lru_bottom = up; + if (!down) + qm->lru_bottom = up; - if (down) - down->lru_up = up; + if (down) + down->lru_up = up; - if (up) - up->lru_down = down; + if (up) + up->lru_down = down; - qc->lru_up = qc->lru_down = NULL; + qc->lru_up = qc->lru_down = NULL; } static void invert_string( struct berval *bv ) { - int i; + int i; char c; for (i=0; ibv_len/2; i++) { @@ -306,39 +306,39 @@ invert_string( struct berval *bv ) bv->bv_val[i] = bv->bv_val[bv->bv_len-i-1]; bv->bv_val[bv->bv_len-i-1] = c; } -} +} -/* find and remove string2 from string1 - * from start if position = 1, +/* find and remove string2 from string1 + * from start if position = 1, * from end if position = 3, * from anywhere if position = 2 */ -static int +static int find_and_remove(struct berval* ber1, struct berval* ber2, int position) { - char* temp; - int len; + char* temp; + int len; int ret=0; - char* arg1, *arg2; + char* arg1, *arg2; char* string1=ber1->bv_val; char* string2=ber2->bv_val; - if (string2 == NULL) - return 1; - if (string1 == NULL) - return 0; + if (string2 == NULL) + return 1; + if (string1 == NULL) + return 0; if (position == 3) { - invert_string(ber1); - invert_string(ber2); + invert_string(ber1); + invert_string(ber2); } - arg1 = string1; - arg2 = string2; + arg1 = string1; + arg2 = string2; - temp = strstr(arg1, arg2); + temp = strstr(arg1, arg2); len = ber2->bv_len; @@ -349,31 +349,31 @@ find_and_remove(struct berval* ber1, struct berval* ber2, int position) ret = 1; } if ( position == 3 ) { - invert_string(ber1); - invert_string(ber2); + invert_string(ber1); + invert_string(ber2); } return ret; } -static struct berval* +static struct berval* merge_init_final(struct berval* init, struct berval* any, struct berval* final) { - struct berval* merged, *temp; - int i, any_count, count; + struct berval* merged, *temp; + int i, any_count, count; for (any_count=0; any && any[any_count].bv_val; any_count++) ; - count = any_count; + count = any_count; - if (init->bv_val) - count++; + if (init->bv_val) + count++; if (final->bv_val) - count++; + count++; - merged = (struct berval*)(ch_malloc((count+1)*sizeof(struct berval))); - temp = merged; + merged = (struct berval*)(ch_malloc((count+1)*sizeof(struct berval))); + temp = merged; if (init->bv_val) { *temp++ = *init; @@ -381,14 +381,14 @@ merge_init_final(struct berval* init, struct berval* any, struct berval* final) for (i=0; ibv_val){ + if (final->bv_val){ *temp++ = *final; - } - temp->bv_val = NULL; - temp->bv_len = 0; - return merged; + } + temp->bv_val = NULL; + temp->bv_len = 0; + return merged; } static int @@ -396,99 +396,99 @@ strings_containment(struct berval* stored, struct berval* incoming) { struct berval* element; int k=0; - int j, rc = 0; - + int j, rc = 0; + for ( element=stored; element->bv_val != NULL; element++ ) { for (j = k; incoming[j].bv_val != NULL; j++) { if (find_and_remove(&(incoming[j]), element, 2)) { - k = j; - rc = 1; - break; + k = j; + rc = 1; + break; } - rc = 0; + rc = 0; } if ( rc ) { - continue; + continue; } else { return 0; } - } + } return 1; } static int -substr_containment_substr(Filter* stored, Filter* incoming) +substr_containment_substr(Filter* stored, Filter* incoming) { - int i; + int i; int rc = 0; - int any_count = 0; + int any_count = 0; struct berval init_incoming; struct berval final_incoming; - struct berval *any_incoming = NULL; - struct berval *remaining_incoming = NULL; - - if ((!(incoming->f_sub_initial.bv_val) && (stored->f_sub_initial.bv_val)) - || (!(incoming->f_sub_final.bv_val) && (stored->f_sub_final.bv_val))) - return 0; - - - ber_dupbv(&init_incoming, &(incoming->f_sub_initial)); - ber_dupbv(&final_incoming, &(incoming->f_sub_final)); - - if (incoming->f_sub_any) { + struct berval *any_incoming = NULL; + struct berval *remaining_incoming = NULL; + + if ((!(incoming->f_sub_initial.bv_val) && (stored->f_sub_initial.bv_val)) + || (!(incoming->f_sub_final.bv_val) && (stored->f_sub_final.bv_val))) + return 0; + + + ber_dupbv(&init_incoming, &(incoming->f_sub_initial)); + ber_dupbv(&final_incoming, &(incoming->f_sub_final)); + + if (incoming->f_sub_any) { for ( any_count=0; incoming->f_sub_any[any_count].bv_val != NULL; any_count++ ) ; - + any_incoming = (struct berval*)ch_malloc((any_count+1) * - sizeof(struct berval)); - + sizeof(struct berval)); + for (i=0; if_sub_any[i])); + ber_dupbv(&(any_incoming[i]), &(incoming->f_sub_any[i])); } - any_incoming[any_count].bv_val = NULL; - any_incoming[any_count].bv_len = 0; + any_incoming[any_count].bv_val = NULL; + any_incoming[any_count].bv_len = 0; } - - if (find_and_remove(&init_incoming, - &(stored->f_sub_initial), 1) && find_and_remove(&final_incoming, - &(stored->f_sub_final), 3)) + + if (find_and_remove(&init_incoming, + &(stored->f_sub_initial), 1) && find_and_remove(&final_incoming, + &(stored->f_sub_final), 3)) { if (stored->f_sub_any == NULL) { - rc = 1; - goto final; + rc = 1; + goto final; } remaining_incoming = merge_init_final(&init_incoming, - any_incoming, &final_incoming); + any_incoming, &final_incoming); rc = strings_containment(stored->f_sub_any, remaining_incoming); - } + } final: free(init_incoming.bv_val); - free(final_incoming.bv_val); + free(final_incoming.bv_val); if (any_incoming) ber_bvarray_free( any_incoming ); free(remaining_incoming); - - return rc; + + return rc; } static int -substr_containment_equality(Filter* stored, Filter* incoming) +substr_containment_equality(Filter* stored, Filter* incoming) { struct berval incoming_val[2]; int rc = 0; - + ber_dupbv(incoming_val, &(incoming->f_av_value)); incoming_val[1].bv_val = NULL; incoming_val[1].bv_len = 0; - + if (find_and_remove(incoming_val, - &(stored->f_sub_initial), 1) && find_and_remove(incoming_val, + &(stored->f_sub_initial), 1) && find_and_remove(incoming_val, &(stored->f_sub_final), 3)) { - if (stored->f_sub_any == NULL){ + if (stored->f_sub_any == NULL){ rc = 1; goto final; - } + } rc = strings_containment(stored->f_sub_any, incoming_val); } final: @@ -496,25 +496,25 @@ final: return rc; } -/* check whether query is contained in any of - * the cached queries in template template_index +/* check whether query is contained in any of + * the cached queries in template template_index */ -static int -query_containment(query_manager *qm, - Query *query, +static int +query_containment(query_manager *qm, + Query *query, int template_index) { QueryTemplate* templa= qm->templates; CachedQuery* qc; Query* q; - Filter* inputf = query->filter; - struct berval* base = &(query->base); - int scope = query->scope; + Filter* inputf = query->filter; + struct berval* base = &(query->base); + int scope = query->scope; int res=0; Filter* fs; Filter* fi; - int ret, rc; - const char* text; + int ret, rc; + const char* text; MatchingRule* mrule = NULL; if (inputf != NULL) { @@ -525,35 +525,35 @@ query_containment(query_manager *qm, Debug( LDAP_DEBUG_ANY, "Lock QC index = %d\n", template_index, 0, 0 ); #endif - ldap_pvt_thread_rdwr_rlock(&(templa[template_index].t_rwlock)); + ldap_pvt_thread_rdwr_rlock(&(templa[template_index].t_rwlock)); for(qc=templa[template_index].query; qc != NULL; qc= qc->next) { - q = (Query*)qc; + q = (Query*)qc; if(base_scope_compare(&(q->base), base, q->scope, scope)) { fi = inputf; - fs = q->filter; - do { + fs = q->filter; + do { res=0; switch (fs->f_choice) { case LDAP_FILTER_EQUALITY: - if (fi->f_choice == LDAP_FILTER_EQUALITY) - mrule = fs->f_ava->aa_desc->ad_type->sat_equality; - else - ret = 1; - break; + if (fi->f_choice == LDAP_FILTER_EQUALITY) + mrule = fs->f_ava->aa_desc->ad_type->sat_equality; + else + ret = 1; + break; case LDAP_FILTER_GE: case LDAP_FILTER_LE: - mrule = fs->f_ava->aa_desc->ad_type->sat_ordering; - break; - default: - mrule = NULL; + mrule = fs->f_ava->aa_desc->ad_type->sat_ordering; + break; + default: + mrule = NULL; } - if (mrule) { - rc = value_match(&ret, fs->f_ava->aa_desc, mrule, - SLAP_MR_VALUE_OF_ASSERTION_SYNTAX, - &(fi->f_ava->aa_value), - &(fs->f_ava->aa_value), &text); + if (mrule) { + rc = value_match(&ret, fs->f_ava->aa_desc, mrule, + SLAP_MR_VALUE_OF_ASSERTION_SYNTAX, + &(fi->f_ava->aa_value), + &(fs->f_ava->aa_value), &text); if (rc != LDAP_SUCCESS) { - ldap_pvt_thread_rdwr_runlock(&(templa[template_index].t_rwlock)); + ldap_pvt_thread_rdwr_runlock(&(templa[template_index].t_rwlock)); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Unlock: Exiting QC index=%d\n", @@ -563,72 +563,72 @@ query_containment(query_manager *qm, "Unlock: Exiting QC index=%d\n", template_index, 0, 0 ); #endif - return 0; + return 0; } } switch (fs->f_choice) { - case LDAP_FILTER_OR: + case LDAP_FILTER_OR: case LDAP_FILTER_AND: fs = fs->f_and; fi = fi->f_and; res=1; - break; - case LDAP_FILTER_SUBSTRINGS: - /* check if the equality query can be + break; + case LDAP_FILTER_SUBSTRINGS: + /* check if the equality query can be * answered with cached substring query */ if ((fi->f_choice == LDAP_FILTER_EQUALITY) && substr_containment_equality( fs, fi)) - res=1; - /* check if the substring query can be + res=1; + /* check if the substring query can be * answered with cached substring query */ if ((fi->f_choice ==LDAP_FILTER_SUBSTRINGS ) && substr_containment_substr( fs, fi)) res= 1; fs=fs->f_next; - fi=fi->f_next; - break; - case LDAP_FILTER_PRESENT: + fi=fi->f_next; + break; + case LDAP_FILTER_PRESENT: res=1; fs=fs->f_next; - fi=fi->f_next; - break; - case LDAP_FILTER_EQUALITY: - if (ret == 0) + fi=fi->f_next; + break; + case LDAP_FILTER_EQUALITY: + if (ret == 0) res = 1; fs=fs->f_next; - fi=fi->f_next; - break; - case LDAP_FILTER_GE: + fi=fi->f_next; + break; + case LDAP_FILTER_GE: if (ret >= 0) - res = 1; + res = 1; fs=fs->f_next; - fi=fi->f_next; + fi=fi->f_next; break; - case LDAP_FILTER_LE: + case LDAP_FILTER_LE: if (ret <= 0) - res = 1; + res = 1; fs=fs->f_next; - fi=fi->f_next; + fi=fi->f_next; break; case LDAP_FILTER_NOT: res=0; break; default: break; - } + } } while((res) && (fi != NULL) && (fs != NULL)); if(res) { - ldap_pvt_thread_mutex_lock(&qm->lru_mutex); + ldap_pvt_thread_mutex_lock(&qm->lru_mutex); if (qm->lru_top != qc) { - remove_query(qm, qc); - add_query_on_top(qm, qc); + remove_query(qm, qc); + add_query_on_top(qm, qc); } - ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); + ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); return 1; - } + } } } #ifdef NEW_LOGGING @@ -640,43 +640,43 @@ query_containment(query_manager *qm, "Not answerable: Unlock QC index=%d\n", template_index, 0, 0 ); #endif - ldap_pvt_thread_rdwr_runlock(&(templa[template_index].t_rwlock)); + ldap_pvt_thread_rdwr_runlock(&(templa[template_index].t_rwlock)); } - return 0; + return 0; } -static void -free_query (CachedQuery* qc) +static void +free_query (CachedQuery* qc) { - Query* q = (Query*)qc; + Query* q = (Query*)qc; int i; - free(qc->q_uuid.bv_val); - filter_free(q->filter); - free (q->base.bv_val); + free(qc->q_uuid.bv_val); + filter_free(q->filter); + free (q->base.bv_val); for (i=0; q->attrs[i].an_name.bv_val; i++) { free(q->attrs[i].an_name.bv_val); } - free(q->attrs); - free(qc); + free(q->attrs); + free(qc); } /* Add query to query cache */ static void add_query( - query_manager* qm, - Query* query, - int template_index, + query_manager* qm, + Query* query, + int template_index, struct berval* uuid) { CachedQuery* new_cached_query = (CachedQuery*) ch_malloc(sizeof(CachedQuery)); - QueryTemplate* templ = (qm->templates)+template_index; + QueryTemplate* templ = (qm->templates)+template_index; Query* new_query; - new_cached_query->template_id = template_index; - new_cached_query->q_uuid = *uuid; - new_cached_query->lru_up = NULL; - new_cached_query->lru_down = NULL; - new_cached_query->expiry_time = slap_get_time() + templ->ttl; + new_cached_query->template_id = template_index; + new_cached_query->q_uuid = *uuid; + new_cached_query->lru_up = NULL; + new_cached_query->lru_down = NULL; + new_cached_query->expiry_time = slap_get_time() + templ->ttl; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Added query expires at %ld\n", (long) new_cached_query->expiry_time, 0, 0 ); @@ -684,12 +684,12 @@ static void add_query( Debug( LDAP_DEBUG_ANY, "Added query expires at %ld\n", (long) new_cached_query->expiry_time, 0, 0 ); #endif - new_query = (Query*)new_cached_query; + new_query = (Query*)new_cached_query; ber_dupbv(&new_query->base, &query->base); - new_query->scope = query->scope; + new_query->scope = query->scope; new_query->filter = query->filter; - new_query->attrs = query->attrs; + new_query->attrs = query->attrs; /* Adding a query */ #ifdef NEW_LOGGING @@ -699,15 +699,15 @@ static void add_query( Debug( LDAP_DEBUG_ANY, "Lock AQ index = %d\n", template_index, 0, 0 ); #endif - ldap_pvt_thread_rdwr_wlock(&templ->t_rwlock); - if (templ->query == NULL) - templ->query_last = new_cached_query; - else - templ->query->prev = new_cached_query; - new_cached_query->next = templ->query; - new_cached_query->prev = NULL; - templ->query = new_cached_query; - templ->no_of_queries++; + ldap_pvt_thread_rdwr_wlock(&templ->t_rwlock); + if (templ->query == NULL) + templ->query_last = new_cached_query; + else + templ->query->prev = new_cached_query; + new_cached_query->next = templ->query; + new_cached_query->prev = NULL; + templ->query = new_cached_query; + templ->no_of_queries++; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "TEMPLATE %d QUERIES++ %d\n", template_index, templ->no_of_queries, 0 ); @@ -723,41 +723,41 @@ static void add_query( Debug( LDAP_DEBUG_ANY, "Unlock AQ index = %d \n", template_index, 0, 0 ); #endif - ldap_pvt_thread_rdwr_wunlock(&templ->t_rwlock); + ldap_pvt_thread_rdwr_wunlock(&templ->t_rwlock); /* Adding on top of LRU list */ - ldap_pvt_thread_mutex_lock(&qm->lru_mutex); - add_query_on_top(qm, new_cached_query); - ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); + ldap_pvt_thread_mutex_lock(&qm->lru_mutex); + add_query_on_top(qm, new_cached_query); + ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); } static void remove_from_template (CachedQuery* qc, QueryTemplate* template) { if (!qc->prev && !qc->next) { - template->query_last = template->query = NULL; + template->query_last = template->query = NULL; } else if (qc->prev == NULL) { - qc->next->prev = NULL; - template->query = qc->next; + qc->next->prev = NULL; + template->query = qc->next; } else if (qc->next == NULL) { - qc->prev->next = NULL; - template->query_last = qc->prev; + qc->prev->next = NULL; + template->query_last = qc->prev; } else { - qc->next->prev = qc->prev; - qc->prev->next = qc->next; + qc->next->prev = qc->prev; + qc->prev->next = qc->next; } - template->no_of_queries--; + template->no_of_queries--; } -/* remove bottom query of LRU list from the query cache */ +/* remove bottom query of LRU list from the query cache */ static void cache_replacement(query_manager* qm, struct berval *result) { - CachedQuery* bottom; + CachedQuery* bottom; int temp_id; - ldap_pvt_thread_mutex_lock(&qm->lru_mutex); - bottom = qm->lru_bottom; + ldap_pvt_thread_mutex_lock(&qm->lru_mutex); + bottom = qm->lru_bottom; result->bv_val = NULL; result->bv_len = 0; @@ -776,10 +776,10 @@ static void cache_replacement(query_manager* qm, struct berval *result) } temp_id = bottom->template_id; - remove_query(qm, bottom); - ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); + remove_query(qm, bottom); + ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); - *result = bottom->q_uuid; + *result = bottom->q_uuid; bottom->q_uuid.bv_val = NULL; #ifdef NEW_LOGGING @@ -787,8 +787,8 @@ static void cache_replacement(query_manager* qm, struct berval *result) #else Debug( LDAP_DEBUG_ANY, "Lock CR index = %d\n", temp_id, 0, 0 ); #endif - ldap_pvt_thread_rdwr_wlock(&(qm->templates[temp_id].t_rwlock)); - remove_from_template(bottom, (qm->templates+temp_id)); + ldap_pvt_thread_rdwr_wlock(&(qm->templates[temp_id].t_rwlock)); + remove_from_template(bottom, (qm->templates+temp_id)); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "TEMPLATE %d QUERIES-- %d\n", temp_id, qm->templates[temp_id].no_of_queries, 0 ); @@ -801,15 +801,15 @@ static void cache_replacement(query_manager* qm, struct berval *result) #else Debug( LDAP_DEBUG_ANY, "Unlock CR index = %d\n", temp_id, 0, 0 ); #endif - ldap_pvt_thread_rdwr_wunlock(&(qm->templates[temp_id].t_rwlock)); - free_query(bottom); + ldap_pvt_thread_rdwr_wunlock(&(qm->templates[temp_id].t_rwlock)); + free_query(bottom); } struct query_info { - struct berval* uuid; - int deleted; -}; - + struct berval* uuid; + int deleted; +}; + static int remove_func ( Operation *op, @@ -824,21 +824,21 @@ remove_func ( Attribute *attr; Operation op_tmp = *op; - SlapReply sreply = {REP_RESULT}; + SlapReply sreply = {REP_RESULT}; - if (rs->sr_type == REP_RESULT) - return 0; + if (rs->sr_type == REP_RESULT) + return 0; for (attr = rs->sr_entry->e_attrs; attr!= NULL; attr = attr->a_next) { if (attr->a_desc == ad_queryid) { - for (count=0; attr->a_vals[count].bv_val; count++) + for (count=0; attr->a_vals[count].bv_val; count++) ; - break; + break; } - } + } if (count == 0) { - return 0; + return 0; } if (count == 1) { #ifdef NEW_LOGGING @@ -854,19 +854,19 @@ remove_func ( op_tmp.o_req_ndn = rs->sr_entry->e_nname; if (op->o_bd->be_delete(&op_tmp, rs) == LDAP_SUCCESS) { - info->deleted++; + info->deleted++; } - return 0; + return 0; } vals[0] = *info->uuid; vals[1].bv_val = NULL; vals[1].bv_len = 0; - mod.sml_op = LDAP_MOD_DELETE; + mod.sml_op = LDAP_MOD_DELETE; mod.sml_desc = ad_queryid; mod.sml_type = ad_queryid->ad_cname; mod.sml_bvalues = vals; - mod.sml_next = NULL; + mod.sml_next = NULL; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "REMOVING TEMP ATTR : TEMPLATE=%s\n", @@ -879,34 +879,34 @@ remove_func ( op_tmp.o_req_dn = rs->sr_entry->e_name; op_tmp.o_req_ndn = rs->sr_entry->e_nname; op_tmp.orm_modlist = &mod; - + op->o_bd->be_modify( &op_tmp, &sreply ); return 0; } - -static int + +static int remove_query_data ( Operation *op, SlapReply *rs, struct berval* query_uuid) { - struct query_info info; - char filter_str[64]; + struct query_info info; + char filter_str[64]; Filter filter = {LDAP_FILTER_EQUALITY}; - SlapReply sreply = {REP_RESULT}; - slap_callback cb = { remove_func, NULL }; + SlapReply sreply = {REP_RESULT}; + slap_callback cb = { remove_func, NULL }; - sreply.sr_entry = NULL; - sreply.sr_nentries = 0; + sreply.sr_entry = NULL; + sreply.sr_nentries = 0; op->ors_filterstr.bv_len = snprintf(filter_str, sizeof(filter_str), "(%s=%s)", ad_queryid->ad_cname.bv_val, query_uuid->bv_val); filter.f_av_desc = ad_queryid; filter.f_av_value = *query_uuid; - info.uuid = query_uuid; - info.deleted = 0; - cb.sc_private = &info; - + info.uuid = query_uuid; + info.deleted = 0; + cb.sc_private = &info; + op->o_tag = LDAP_REQ_SEARCH; op->o_protocol = LDAP_VERSION3; op->o_callback = &cb; @@ -930,48 +930,48 @@ remove_query_data ( return info.deleted; } -static int +static int get_attr_set( - AttributeName* attrs, - query_manager* qm, + AttributeName* attrs, + query_manager* qm, int num ); -static int +static int attrscmp( - AttributeName* attrs_in, + AttributeName* attrs_in, AttributeName* attrs ); -static int +static int is_temp_answerable( - int attr_set, - struct berval* tempstr, - query_manager* qm, + int attr_set, + struct berval* tempstr, + query_manager* qm, int template_id ) { QueryTemplate *qt = qm->templates + template_id; if (attr_set != qt->attr_set_index) { - int* id_array = qm->attr_sets[attr_set].ID_array; + int* id_array = qm->attr_sets[attr_set].ID_array; while (*id_array != -1) { if (*id_array == qt->attr_set_index) break; - id_array++; + id_array++; } if (*id_array == -1) - return 0; + return 0; } return (qt->querystr.bv_len == tempstr->bv_len && strcasecmp(qt->querystr.bv_val, tempstr->bv_val) == 0); } -static int +static int filter2template( Filter *f, struct berval *fstr, - AttributeName** filter_attrs, + AttributeName** filter_attrs, int* filter_cnt ) { AttributeDescription *ad; @@ -1023,7 +1023,7 @@ filter2template( fstr->bv_len += sizeof("(%") - 1; for ( f = f->f_list; f != NULL; f = f->f_next ) { - rc = filter2template( f, fstr, filter_attrs, filter_cnt ); + rc = filter2template( f, fstr, filter_attrs, filter_cnt ); if ( rc ) break; } sprintf( fstr->bv_val+fstr->bv_len, ")" ); @@ -1039,13 +1039,13 @@ filter2template( } *filter_attrs = (AttributeName *)ch_realloc(*filter_attrs, - (*filter_cnt + 2)*sizeof(AttributeName)); - + (*filter_cnt + 2)*sizeof(AttributeName)); + (*filter_attrs)[*filter_cnt].an_desc = ad; - (*filter_attrs)[*filter_cnt].an_name = ad->ad_cname; - (*filter_attrs)[*filter_cnt+1].an_name.bv_val = NULL; - (*filter_attrs)[*filter_cnt+1].an_name.bv_len = 0; - (*filter_cnt)++; + (*filter_attrs)[*filter_cnt].an_name = ad->ad_cname; + (*filter_attrs)[*filter_cnt+1].an_name.bv_val = NULL; + (*filter_attrs)[*filter_cnt+1].an_name.bv_len = 0; + (*filter_cnt)++; return 0; } @@ -1069,16 +1069,16 @@ cache_entries( struct search_info *si = op->o_callback->sc_private; slap_overinst *on = si->on; cache_manager *cm = on->on_bi.bi_private; - query_manager* qm = cm->qm; - int i; - int return_val; - Entry *e; - struct berval crp_uuid; + query_manager* qm = cm->qm; + int i; + int return_val; + Entry *e; + struct berval crp_uuid; char uuidbuf[ LDAP_LUTIL_UUIDSTR_BUFSIZE ]; Operation op_tmp = *op; BackendDB db = *op->o_bd; - - query_uuid->bv_len = lutil_uuidstr(uuidbuf, sizeof(uuidbuf)); + + query_uuid->bv_len = lutil_uuidstr(uuidbuf, sizeof(uuidbuf)); ber_str2bv(uuidbuf, query_uuid->bv_len, 1, query_uuid); op_tmp.o_bd = &db; @@ -1095,7 +1095,7 @@ cache_entries( Debug( LDAP_DEBUG_ANY, "UUID for query being added = %s\n", uuidbuf, 0, 0 ); #endif /* !NEW_LOGGING */ - + for ( e=si->head; e; e=si->head ) { si->head = e->e_private; e->e_private = NULL; @@ -1105,7 +1105,7 @@ cache_entries( #else /* !NEW_LOGGING */ Debug( LDAP_DEBUG_NONE, "LOCKING REMOVE MUTEX\n", 0, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_mutex_lock(&cm->remove_mutex); + ldap_pvt_thread_mutex_lock(&cm->remove_mutex); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL2, "LOCKED REMOVE MUTEX\n", 0, 0, 0); #else /* !NEW_LOGGING */ @@ -1134,9 +1134,9 @@ cache_entries( return_val, 0, 0); #endif /* !NEW_LOGGING */ ldap_pvt_thread_mutex_lock( - &cm->cache_mutex ); + &cm->cache_mutex ); cm->cur_entries -= return_val; - cm->num_cached_queries--; + cm->num_cached_queries--; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "STORED QUERIES = %lu\n", @@ -1163,8 +1163,8 @@ cache_entries( } return_val = merge_entry(&op_tmp, e, query_uuid); - ldap_pvt_thread_mutex_unlock(&cm->remove_mutex); - ldap_pvt_thread_mutex_lock(&cm->cache_mutex); + ldap_pvt_thread_mutex_unlock(&cm->remove_mutex); + ldap_pvt_thread_mutex_lock(&cm->cache_mutex); cm->cur_entries += return_val; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, @@ -1176,10 +1176,10 @@ cache_entries( cm->cur_entries, 0, 0 ); #endif /* !NEW_LOGGING */ return_val = 0; - ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); + ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); } - ldap_pvt_thread_mutex_lock(&cm->cache_mutex); - cm->num_cached_queries++; + ldap_pvt_thread_mutex_lock(&cm->cache_mutex); + cm->num_cached_queries++; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "STORED QUERIES = %lu\n", cm->num_cached_queries, 0, 0 ); @@ -1187,7 +1187,7 @@ cache_entries( Debug( LDAP_DEBUG_ANY, "STORED QUERIES = %lu\n", cm->num_cached_queries, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); + ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); return return_val; } @@ -1200,7 +1200,7 @@ proxy_cache_response( struct search_info *si = op->o_callback->sc_private; slap_overinst *on = si->on; cache_manager *cm = on->on_bi.bi_private; - query_manager* qm = cm->qm; + query_manager* qm = cm->qm; struct berval uuid; if ( rs->sr_type == REP_SEARCH ) { @@ -1249,57 +1249,57 @@ proxy_cache_response( static void add_filter_attrs( Operation *op, - AttributeName** new_attrs, - AttributeName* attrs, + AttributeName** new_attrs, + AttributeName* attrs, AttributeName* filter_attrs ) { - int alluser = 0; - int allop = 0; - int i; - int count; + int alluser = 0; + int allop = 0; + int i; + int count; /* duplicate attrs */ if (attrs == NULL) { - count = 1; - } else { - for (count=0; attrs[count].an_name.bv_val; count++) + count = 1; + } else { + for (count=0; attrs[count].an_name.bv_val; count++) ; } *new_attrs = (AttributeName*)(op->o_tmpalloc((count+1)* - sizeof(AttributeName), op->o_tmpmemctx)); - if (attrs == NULL) { - (*new_attrs)[0].an_name.bv_val = "*"; - (*new_attrs)[0].an_name.bv_len = 1; + sizeof(AttributeName), op->o_tmpmemctx)); + if (attrs == NULL) { + (*new_attrs)[0].an_name.bv_val = "*"; + (*new_attrs)[0].an_name.bv_len = 1; (*new_attrs)[1].an_name.bv_val = NULL; - (*new_attrs)[1].an_name.bv_len = 0; - alluser = 1; - allop = 0; - } else { + (*new_attrs)[1].an_name.bv_len = 0; + alluser = 1; + allop = 0; + } else { for (i=0; iad_type) ) { - if (allop) - continue; - } else if (alluser) - continue; + if (allop) + continue; + } else if (alluser) + continue; *new_attrs = (AttributeName*)(op->o_tmprealloc(*new_attrs, - (count+2)*sizeof(AttributeName), op->o_tmpmemctx)); + (count+2)*sizeof(AttributeName), op->o_tmpmemctx)); (*new_attrs)[count].an_name = filter_attrs[i].an_name; - (*new_attrs)[count].an_desc = filter_attrs[i].an_desc; - count++; - (*new_attrs)[count].an_name.bv_val = NULL; - (*new_attrs)[count].an_name.bv_len = 0; + (*new_attrs)[count].an_desc = filter_attrs[i].an_desc; + count++; + (*new_attrs)[count].an_name.bv_val = NULL; + (*new_attrs)[count].an_name.bv_len = 0; } } @@ -1310,22 +1310,22 @@ proxy_cache_search( { slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; cache_manager *cm = on->on_bi.bi_private; - query_manager* qm = cm->qm; + query_manager* qm = cm->qm; int count; - + int i = -1; - AttributeName *filter_attrs = NULL; - AttributeName *new_attrs = NULL; + AttributeName *filter_attrs = NULL; + AttributeName *new_attrs = NULL; - Query query; + Query query; - int attr_set = -1; - int template_id = -1; - int answerable = 0; - int cacheable = 0; - int fattr_cnt=0; + int attr_set = -1; + int template_id = -1; + int answerable = 0; + int cacheable = 0; + int fattr_cnt=0; int oc_attr_absent = 1; struct berval tempstr; @@ -1345,23 +1345,23 @@ proxy_cache_search( tempstr.bv_val, 0, 0 ); #endif /* !NEW_LOGGING */ - /* find attr set */ - attr_set = get_attr_set(op->ors_attrs, qm, cm->numattrsets); - - query.filter = op->ors_filter; - query.attrs = op->ors_attrs; - query.base = op->o_req_ndn; - query.scope = op->ors_scope; + /* find attr set */ + attr_set = get_attr_set(op->ors_attrs, qm, cm->numattrsets); + + query.filter = op->ors_filter; + query.attrs = op->ors_attrs; + query.base = op->o_req_ndn; + query.scope = op->ors_scope; /* check for query containment */ if (attr_set > -1) { for (i=0; inumtemplates; i++) { /* find if template i can potentially answer tempstr */ - if (!is_temp_answerable(attr_set, &tempstr, qm, i)) - continue; + if (!is_temp_answerable(attr_set, &tempstr, qm, i)) + continue; if (attr_set == qm->templates[i].attr_set_index) { - cacheable = 1; - template_id = i; + cacheable = 1; + template_id = i; } #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL2, @@ -1386,8 +1386,8 @@ proxy_cache_search( #else /* !NEW_LOGGING */ Debug( LDAP_DEBUG_ANY, "QUERY ANSWERABLE\n", 0, 0, 0 ); #endif /* !NEW_LOGGING */ - free(filter_attrs); - ldap_pvt_thread_rdwr_runlock(&qm->templates[i].t_rwlock); + free(filter_attrs); + ldap_pvt_thread_rdwr_runlock(&qm->templates[i].t_rwlock); db = *op->o_bd; db.bd_info = cm->bi; db.be_private = cm->be_private; @@ -1405,12 +1405,12 @@ proxy_cache_search( Debug( LDAP_DEBUG_ANY, "QUERY NOT ANSWERABLE\n", 0, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_mutex_lock(&cm->cache_mutex); + ldap_pvt_thread_mutex_lock(&cm->cache_mutex); if (cm->num_cached_queries >= cm->max_queries) { - cacheable = 0; + cacheable = 0; } - ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); - + ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); + if (cacheable) { slap_callback *cb; struct search_info *si; @@ -1420,7 +1420,7 @@ proxy_cache_search( #else /* !NEW_LOGGING */ Debug( LDAP_DEBUG_ANY, "QUERY CACHEABLE\n", 0, 0, 0 ); #endif /* !NEW_LOGGING */ - query.filter = str2filter(op->ors_filterstr.bv_val); + query.filter = str2filter(op->ors_filterstr.bv_val); if (op->ors_attrs) { for ( count=0; op->ors_attrs[ count ].an_name.bv_val; count++ ) { if ( op->ors_attrs[count].an_desc == slap_schema.si_ad_objectClass ) @@ -1467,56 +1467,56 @@ proxy_cache_search( #endif /* !NEW_LOGGING */ } - free(filter_attrs); - + free(filter_attrs); + return SLAP_CB_CONTINUE; } -static int +static int attrscmp( - AttributeName* attrs_in, + AttributeName* attrs_in, AttributeName* attrs) { - int i, count1, count2; + int i, count1, count2; if ( attrs_in == NULL ) { - return (attrs ? 0 : 1); - } - if ( attrs == NULL ) - return 0; - + return (attrs ? 0 : 1); + } + if ( attrs == NULL ) + return 0; + for ( count1=0; attrs_in && attrs_in[count1].an_name.bv_val != NULL; count1++ ) ; for ( count2=0; attrs && attrs[count2].an_name.bv_val != NULL; - count2++) + count2++) ; if ( count1 != count2 ) - return 0; + return 0; for ( i=0; iattr_sets[i].attrs)) + if (attrscmp(attrs, qm->attr_sets[i].attrs)) return i; } - return -1; + return -1; } -static void* +static void* consistency_check( void *ctx, void *arg ) @@ -1524,13 +1524,13 @@ consistency_check( struct re_s *rtask = arg; slap_overinst *on = rtask->arg; cache_manager *cm = on->on_bi.bi_private; - query_manager *qm = cm->qm; + query_manager *qm = cm->qm; Operation op = {0}; BackendDB be = on->on_info->oi_bd; - SlapReply rs = {REP_RESULT}; - CachedQuery* query, *query_prev; - int i, return_val, pause = 1; + SlapReply rs = {REP_RESULT}; + CachedQuery* query, *query_prev; + int i, return_val, pause = 1; QueryTemplate* templ; op.o_bd = &be; @@ -1543,19 +1543,19 @@ consistency_check( be.bd_info = cm->bi; be.be_private = cm->be_private; - + cm->cc_arg = arg; for (i=0; qm->templates[i].querystr.bv_val; i++) { - templ = qm->templates + i; - query = templ->query_last; + templ = qm->templates + i; + query = templ->query_last; if ( query ) pause = 0; - op.o_time = slap_get_time(); - ldap_pvt_thread_mutex_lock(&cm->remove_mutex); + op.o_time = slap_get_time(); + ldap_pvt_thread_mutex_lock(&cm->remove_mutex); while (query && (query->expiry_time < op.o_time)) { - ldap_pvt_thread_mutex_lock(&qm->lru_mutex); - remove_query(qm, query); - ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); + ldap_pvt_thread_mutex_lock(&qm->lru_mutex); + remove_query(qm, query); + ldap_pvt_thread_mutex_unlock(&qm->lru_mutex); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Lock CR index = %d\n", i, 0, 0 ); @@ -1563,8 +1563,8 @@ consistency_check( Debug( LDAP_DEBUG_ANY, "Lock CR index = %d\n", i, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_rdwr_wlock(&templ->t_rwlock); - remove_from_template(query, templ); + ldap_pvt_thread_rdwr_wlock(&templ->t_rwlock); + remove_from_template(query, templ); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "TEMPLATE %d QUERIES-- %d\n", @@ -1580,7 +1580,7 @@ consistency_check( Debug( LDAP_DEBUG_ANY, "Unlock CR index = %d\n", i, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_rdwr_wunlock(&templ->t_rwlock); + ldap_pvt_thread_rdwr_wunlock(&templ->t_rwlock); return_val = remove_query_data(&op, &rs, &query->q_uuid); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, @@ -1590,9 +1590,9 @@ consistency_check( Debug( LDAP_DEBUG_ANY, "STALE QUERY REMOVED, SIZE=%d\n", return_val, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_mutex_lock(&cm->cache_mutex); + ldap_pvt_thread_mutex_lock(&cm->cache_mutex); cm->cur_entries -= return_val; - cm->num_cached_queries--; + cm->num_cached_queries--; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "STORED QUERIES = %lu\n", cm->num_cached_queries, 0, 0 ); @@ -1600,23 +1600,23 @@ consistency_check( Debug( LDAP_DEBUG_ANY, "STORED QUERIES = %lu\n", cm->num_cached_queries, 0, 0 ); #endif /* !NEW_LOGGING */ - ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); + ldap_pvt_thread_mutex_unlock(&cm->cache_mutex); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "STALE QUERY REMOVED, CACHE =" - "%d entries\n", + "%d entries\n", cm->cur_entries, 0, 0 ); #else /* !NEW_LOGGING */ Debug( LDAP_DEBUG_ANY, "STALE QUERY REMOVED, CACHE =" - "%d entries\n", + "%d entries\n", cm->cur_entries, 0, 0 ); #endif /* !NEW_LOGGING */ - query_prev = query; - query = query->prev; - free_query(query_prev); + query_prev = query; + query = query->prev; + free_query(query_prev); } - ldap_pvt_thread_mutex_unlock(&cm->remove_mutex); + ldap_pvt_thread_mutex_unlock(&cm->remove_mutex); } /* If there were no queries, defer processing for a while */ if ( pause ) { @@ -1632,8 +1632,8 @@ consistency_check( } -#define MAX_ATTR_SETS 500 -static void find_supersets( struct attr_set* attr_sets, int numsets ); +#define MAX_ATTR_SETS 500 +static void find_supersets( struct attr_set* attr_sets, int numsets ); static int compare_sets( struct attr_set* setA, int, int ); static int @@ -1649,13 +1649,13 @@ proxy_cache_config( cache_manager* cm = on->on_bi.bi_private; query_manager* qm = cm->qm; QueryTemplate* temp; - AttributeName* attr_name; + AttributeName* attr_name; AttributeName* attrarray; - const char* text=NULL; + const char* text=NULL; void *private = be->be_private; - int index, i; - int num; + int index, i; + int num; if ( strcasecmp( argv[0], "proxycache" ) == 0 ) { if ( argc < 6 ) { @@ -1686,21 +1686,21 @@ proxy_cache_config( return( 1 ); } - cm->num_entries_limit = atoi( argv[4] ); - cm->cc_period = atoi( argv[5] ); + cm->num_entries_limit = atoi( argv[4] ); + cm->cc_period = atoi( argv[5] ); #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Total # of attribute sets to be cached = %d\n", - cm->numattrsets, 0, 0 ); + cm->numattrsets, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "Total # of attribute sets to be cached = %d\n", - cm->numattrsets, 0, 0 ); + cm->numattrsets, 0, 0 ); #endif qm->attr_sets = ( struct attr_set * )ch_malloc( cm->numattrsets * sizeof( struct attr_set )); for ( i = 0; i < cm->numattrsets; i++ ) { - qm->attr_sets[i].attrs = NULL; + qm->attr_sets[i].attrs = NULL; } } else if ( strcasecmp( argv[0], "proxyattrset" ) == 0 ) { @@ -1711,19 +1711,19 @@ proxy_cache_config( } #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Attribute Set # %d\n", - atoi( argv[1] ), 0, 0 ); + atoi( argv[1] ), 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "Attribute Set # %d\n", - atoi( argv[1] ), 0, 0 ); + atoi( argv[1] ), 0, 0 ); #endif if (atoi(argv[1]) >= cm->numattrsets) { fprintf( stderr, "%s; line %d index out of bounds \n", fname, lineno ); - return 1; - } + return 1; + } index = atoi( argv[1] ); if ( argv[2] && strcmp( argv[2], "*" ) ) { - qm->attr_sets[index].count = argc - 2; + qm->attr_sets[index].count = argc - 2; qm->attr_sets[index].attrs = (AttributeName*)ch_malloc( (argc-1) * sizeof( AttributeName )); attr_name = qm->attr_sets[index].attrs; @@ -1736,13 +1736,13 @@ proxy_cache_config( argv[i], 0, 0 ); #endif ber_str2bv( argv[i], 0, 1, - &attr_name->an_name); - attr_name->an_desc = NULL; + &attr_name->an_name); + attr_name->an_desc = NULL; slap_bv2ad( &attr_name->an_name, &attr_name->an_desc, &text ); - attr_name++; - attr_name->an_name.bv_val = NULL; - attr_name->an_name.bv_len = 0; + attr_name++; + attr_name->an_name.bv_val = NULL; + attr_name->an_name.bv_len = 0; } } } else if ( strcasecmp( argv[0], "proxytemplate" ) == 0 ) { @@ -1756,35 +1756,35 @@ proxy_cache_config( #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "%s: line %d, template index invalid\n", - fname, lineno, 0 ); + fname, lineno, 0 ); #else Debug( LDAP_DEBUG_ANY, "%s: line %d, template index invalid\n", - fname, lineno, 0 ); + fname, lineno, 0 ); #endif - return 1; + return 1; } - num = cm->numtemplates; + num = cm->numtemplates; if ( num == 0 ) find_supersets( qm->attr_sets, cm->numattrsets ); qm->templates = ( QueryTemplate* )ch_realloc( qm->templates, ( num + 2 ) * sizeof( QueryTemplate )); - temp = qm->templates + num; - ldap_pvt_thread_rdwr_init( &temp->t_rwlock ); + temp = qm->templates + num; + ldap_pvt_thread_rdwr_init( &temp->t_rwlock ); temp->query = temp->query_last = NULL; temp->ttl = atoi( argv[3] ); - temp->no_of_queries = 0; + temp->no_of_queries = 0; if ( argv[1] == NULL ) { #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "Templates string not specified " - "for template %d\n", num, 0, 0 ); + "for template %d\n", num, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "Templates string not specified " - "for template %d\n", num, 0, 0 ); + "for template %d\n", num, 0, 0 ); #endif - return 1; + return 1; } ber_str2bv( argv[1], 0, 1, &temp->querystr ); #ifdef NEW_LOGGING @@ -1799,14 +1799,14 @@ proxy_cache_config( Debug( LDAP_DEBUG_ANY, " query template: %s\n", temp->querystr.bv_val, 0, 0 ); #endif - temp->attr_set_index = i; + temp->attr_set_index = i; #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, " attributes: \n", 0, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, " attributes: \n", 0, 0, 0 ); #endif if ( ( attrarray = qm->attr_sets[i].attrs ) != NULL ) { - for ( i=0; attrarray[i].an_name.bv_val; i++ ) + for ( i=0; attrarray[i].an_name.bv_val; i++ ) #ifdef NEW_LOGGING LDAP_LOG( BACK_META, DETAIL1, "\t%s\n", attrarray[i].an_name.bv_val, 0, 0 ); @@ -1815,10 +1815,10 @@ proxy_cache_config( attrarray[i].an_name.bv_val, 0, 0 ); #endif } - temp++; - temp->querystr.bv_val = NULL; + temp++; + temp->querystr.bv_val = NULL; cm->numtemplates++; - } + } /* anything else */ else { be->be_private = cm->be_private; @@ -1838,34 +1838,34 @@ proxy_cache_init( cache_manager *cm; query_manager *qm; - cm = (cache_manager *)ch_malloc(sizeof(cache_manager)); + cm = (cache_manager *)ch_malloc(sizeof(cache_manager)); on->on_bi.bi_private = cm; - qm = (query_manager*)ch_malloc(sizeof(query_manager)); + qm = (query_manager*)ch_malloc(sizeof(query_manager)); - cm->qm = qm; - cm->numattrsets = 0; - cm->numtemplates = 0; + cm->qm = qm; + cm->numattrsets = 0; + cm->numtemplates = 0; cm->num_entries_limit = 5; - cm->num_cached_queries = 0; - cm->max_entries = 0; - cm->cur_entries = 0; - cm->max_queries = 10000; - cm->cc_period = 1000; - cm->cc_paused = 0; - - qm->attr_sets = NULL; - qm->templates = NULL; + cm->num_cached_queries = 0; + cm->max_entries = 0; + cm->cur_entries = 0; + cm->max_queries = 10000; + cm->cc_period = 1000; + cm->cc_paused = 0; + + qm->attr_sets = NULL; + qm->templates = NULL; qm->lru_top = NULL; qm->lru_bottom = NULL; - qm->qcfunc = query_containment; - qm->crfunc = cache_replacement; - qm->addfunc = add_query; - ldap_pvt_thread_mutex_init(&qm->lru_mutex); - - ldap_pvt_thread_mutex_init(&cm->cache_mutex); - ldap_pvt_thread_mutex_init(&cm->remove_mutex); + qm->qcfunc = query_containment; + qm->crfunc = cache_replacement; + qm->addfunc = add_query; + ldap_pvt_thread_mutex_init(&qm->lru_mutex); + + ldap_pvt_thread_mutex_init(&cm->cache_mutex); + ldap_pvt_thread_mutex_init(&cm->remove_mutex); return 0; } @@ -1916,7 +1916,7 @@ proxy_cache_close( free_query( qc ); } free( qm->templates[i].querystr.bv_val ); - ldap_pvt_thread_rdwr_destroy( &qm->templates[i].t_rwlock ); + ldap_pvt_thread_rdwr_destroy( &qm->templates[i].t_rwlock ); } free( qm->templates ); qm->templates = NULL; @@ -1950,9 +1950,9 @@ proxy_cache_destroy( rc = cm->bi->bi_db_destroy( be ); be->be_private = private; } - ldap_pvt_thread_mutex_destroy(&qm->lru_mutex); - ldap_pvt_thread_mutex_destroy(&cm->cache_mutex); - ldap_pvt_thread_mutex_destroy(&cm->remove_mutex); + ldap_pvt_thread_mutex_destroy(&qm->lru_mutex); + ldap_pvt_thread_mutex_destroy(&cm->cache_mutex); + ldap_pvt_thread_mutex_destroy(&cm->remove_mutex); free( qm ); free( cm ); return rc; @@ -1969,31 +1969,31 @@ find_supersets ( struct attr_set* attr_sets, int numsets ) for ( i = 0; i < numsets; i++ ) { attr_sets[i].ID_array = (int*) ch_malloc( sizeof( int ) ); - attr_sets[i].ID_array[0] = -1; - } + attr_sets[i].ID_array[0] = -1; + } for ( i = 0; i < numsets; i++ ) { for ( j=i+1; j < numsets; j++ ) { - res = compare_sets( attr_sets, i, j ); + res = compare_sets( attr_sets, i, j ); switch ( res ) { case 0: break; - case 3: - case 1: - id_array = attr_sets[i].ID_array; + case 3: + case 1: + id_array = attr_sets[i].ID_array; attr_sets[i].ID_array = (int *) ch_realloc( id_array, - ( num[i] + 2 ) * sizeof( int )); - attr_sets[i].ID_array[num[i]] = j; - attr_sets[i].ID_array[num[i]+1] = -1; + ( num[i] + 2 ) * sizeof( int )); + attr_sets[i].ID_array[num[i]] = j; + attr_sets[i].ID_array[num[i]+1] = -1; num[i]++; - if (res == 1) + if (res == 1) break; - case 2: - id_array = attr_sets[j].ID_array; + case 2: + id_array = attr_sets[j].ID_array; attr_sets[j].ID_array = (int *) ch_realloc( id_array, - ( num[j] + 2 ) * sizeof( int )); - attr_sets[j].ID_array[num[j]] = i; - attr_sets[j].ID_array[num[j]+1] = -1; + ( num[j] + 2 ) * sizeof( int )); + attr_sets[j].ID_array[num[j]] = i; + attr_sets[j].ID_array[num[j]+1] = -1; num[j]++; break; } @@ -2001,15 +2001,15 @@ find_supersets ( struct attr_set* attr_sets, int numsets ) } } -/* - * compares two sets of attributes (indices i and j) - * returns 0: if neither set is contained in the other set +/* + * compares two sets of attributes (indices i and j) + * returns 0: if neither set is contained in the other set * 1: if set i is contained in set j * 2: if set j is contained in set i - * 3: the sets are equivalent + * 3: the sets are equivalent */ -static int +static int compare_sets(struct attr_set* set, int i, int j) { int k,l,numI,numJ; @@ -2017,32 +2017,32 @@ compare_sets(struct attr_set* set, int i, int j) int result=0; if (( set[i].attrs == NULL ) && ( set[j].attrs == NULL )) - return 3; + return 3; if ( set[i].attrs == NULL ) - return 2; + return 2; if ( set[j].attrs == NULL ) - return 1; - - numI = set[i].count; - numJ = set[j].count; + return 1; + + numI = set[i].count; + numJ = set[j].count; for ( l=0; l < numI; l++ ) { for ( k = 0; k < numJ; k++ ) { if ( strcmp( set[i].attrs[l].an_name.bv_val, set[j].attrs[k].an_name.bv_val ) == 0 ) - common++; + common++; } } if ( common == numI ) - result = 1; + result = 1; if ( common == numJ ) result += 2; - return result; + return result; } static slap_overinst proxy_cache;