abrt.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Denys Vlasenko <vda.linux@googlemail.com>	2009-09-15 19:14:50 +0200
committer	Denys Vlasenko <vda.linux@googlemail.com>	2009-09-15 19:14:50 +0200
commit	b60ce4965bee80f44db8a7e76382ecbd2947e4d4 (patch)
tree	4e9d265577aa34e8f5595b3d4c91627f0b261bc2 /lib/Utils/Observer.h
parent	fbe358995978f60ad23ed86e71cfa8ba425b70eb (diff)
parent	670a6e1741242096ee0fdd4ae98953493c1b743b (diff)

Merge branch 'master' of ssh://vda@git.fedorahosted.org/git/abrt

Diffstat (limited to 'lib/Utils/Observer.h')

0 files changed, 0 insertions, 0 deletions

/** BEGIN COPYRIGHT BLOCK * Copyright (C) 2001 Sun Microsystems, Inc. Used by permission. * Copyright (C) 2005 Red Hat, Inc. * All rights reserved. * END COPYRIGHT BLOCK **/ /* Virtual Attributes This file implements the "virtual attribute API", which is the interface by which any joe servercode gets the values of attributes associated with an entry which are _not_ stored with the entry. Attributes which _are_ stored with the entry will also be returned by this interface, unless the caller specifies the SLAPI_REALATTRS_ONLY flag. This means that the casual caller looking for attribute values should probably call the virtual attribute interface rather than the regular Slapi_Entry_Attr_Find... and so on calls. This interface is different from that one in that the data returned is a copy, to be freed by the caller. Details on how to free the returned data is given individually for each function. The thing is implemented with a service provider model. The code in here does NOT know how to generate computed attr values etc, it just calls the registered providers of such information. It also takes care of any crusty special cases. Everything above the line here is crispy clean. Implicit in this interface is the assumption that the value of an attribute can only depend on the entry and some independent stored state. For example, the value can't depend upon who is asking, since we don't pass that information over the interface. More design: we'd like to have the regular result returning code in result.c call this interface. However, as it stands, his would incur a malloc, a copy and a free for every value. Too expensive. So, it would be good to modify the interface such that when we retrieve values from inside the entry, we just fetch a pointer like before. When we retrieve values which are generated, we get copies of the data (or can we get pointers there too ?? --- no). One way to achieve this: allow the caller to say that they perfer to receive pointers and not copies. They are then informed by the function whether they did receive pointers or copies. They then call the free function only when needed. The implicit lifetime of the returned pointers is the lifetime of the entry object passed into the function. Nasty, but one has to do these things in the name of the god performance. DBDB: remember to rename the structures mark complained weren't compliant with the slapi naming scheme. */ #include "slap.h" #include "vattr_spi.h" #include "statechange.h" #ifdef SOURCEFILE #undef SOURCEFILE #endif #define SOURCEFILE "vattr.c" static char *sourcefile = SOURCEFILE; /* Define only for module test code */ /* #define VATTR_TEST_CODE */ /* Loop context structure */ struct _vattr_context { Slapi_PBlock *pb; unsigned int vattr_context_loop_count; unsigned int error_displayed; }; #define VATTR_LOOP_COUNT_MAX 50 typedef vattr_sp_handle vattr_sp_handle_list; /* Local prototypes */ static int vattr_map_create(); static void vattr_map_destroy(); int vattr_map_sp_insert(char *type_to_add, vattr_sp_handle *sp, void *hint); vattr_sp_handle_list *vattr_map_sp_getlist(char *type_to_find); vattr_sp_handle_list *vattr_map_namespace_sp_getlist(Slapi_DN *dn, const char *type_to_find); vattr_sp_handle_list *vattr_map_sp_get_complete_list(); vattr_sp_handle *vattr_map_sp_first(vattr_sp_handle_list *list,void **hint); vattr_sp_handle *vattr_map_sp_next(vattr_sp_handle_list *list,void **hint); vattr_sp_handle *vattr_list_sp_first(vattr_sp_handle_list *list); vattr_sp_handle *vattr_list_sp_next(vattr_sp_handle_list *list); int vattr_call_sp_get_value(vattr_sp_handle *handle, vattr_context *c, Slapi_Entry *e, vattr_get_thang *my_get, char *type, Slapi_ValueSet** results,int *type_name_disposition, char** actual_type_name, int flags, int *buffer_flags, void *hint); int vattr_call_sp_get_batch_values(vattr_sp_handle *handle, vattr_context *c, Slapi_Entry *e, vattr_get_thang *my_get, char **type, Slapi_ValueSet*** results,int **type_name_disposition, char*** actual_type_name, int flags, int *buffer_flags, void** hint); int vattr_call_sp_compare_value(vattr_sp_handle *handle, vattr_context *c, Slapi_Entry *e, vattr_get_thang *my_get, const char *type, Slapi_Value* test_this,int *result, int flags, void* hint); int vattr_call_sp_get_types(vattr_sp_handle *handle,Slapi_Entry *e,vattr_type_list_context *type_context,int flags); void schema_changed_callback(Slapi_Entry *e, char *dn, int modtype, Slapi_PBlock *pb, void *caller_data); int slapi_vattrspi_register_internal(vattr_sp_handle **h, vattr_get_fn_type get_fn, vattr_get_ex_fn_type get_ex_fn, vattr_compare_fn_type compare_fn, vattr_types_fn_type types_fn, void *options); #ifdef VATTR_TEST_CODE int vattr_basic_sp_init(); #endif void **statechange_api; /* Housekeeping Functions, called by server startup/shutdown code */ /* Called on server startup, init all structures etc */ void vattr_init() { statechange_api = 0; vattr_map_create(); #ifdef VATTR_TEST_CODE vattr_basic_sp_init(); #endif } /* Called on server shutdown, free all structures, inform service providers that we're going down etc */ void vattr_cleanup() { vattr_map_destroy(); } /* The public interface functions start here */ /* Function which returns the value(s) of an attribute, given an entry and the attribute type name */ /* Return 0 if OK, ?? if attr doesn't exist, ?? if some error condition ?? if result doesn't need to be free'ed */ int slapi_vattr_values_get(/* Entry we're interested in */ Slapi_Entry *e, /* attr type name */ char *type, /* pointer to result set */ Slapi_ValueSet** results,int *type_name_disposition, char** actual_type_name, int flags, int *buffer_flags) { vattr_context *c = NULL; return slapi_vattr_values_get_sp(c,e,type,results,type_name_disposition,actual_type_name,flags, buffer_flags); } int slapi_vattr_values_get_ex(/* Entry we're interested in */ Slapi_Entry *e,/* attr type name */ char *type, /* pointer to result set */ Slapi_ValueSet*** results,int **type_name_disposition, char*** actual_type_name, int flags, int *buffer_flags, int *subtype_count) { vattr_context *c = NULL; return slapi_vattr_values_get_sp_ex(c,e,type,results,type_name_disposition,actual_type_name,flags, buffer_flags, subtype_count); } int slapi_vattr_namespace_values_get(/* Entry we're interested in */ Slapi_Entry *e, /* backend namespace dn*/ Slapi_DN *namespace_dn, /* attr type name */ char *type, /* pointer to result set */ Slapi_ValueSet*** results,int **type_name_disposition, char*** actual_type_name, int flags, int *buffer_flags, int *subtype_count) { vattr_context *c = NULL; return slapi_vattr_namespace_values_get_sp(c,e,namespace_dn,type,results,type_name_disposition,actual_type_name,flags, buffer_flags, subtype_count); } /* * If pointers into the entry were requested then we might have * a stashed pointer to the entry values, otherwise will be null. */ Slapi_ValueSet *vattr_typethang_get_values(vattr_type_thang *t) { return t->type_values; } /* * This can be much faster than using slapi_vattr_values_get() * when you have a vattr_type_thang list returned from slapi_vattr_list_types(). * * We call the vattr SPs to get values for an attribute type in the list only * if the results field for that attribute type is null. * If the type list comes from slapi_vattr_list_types() then the value is null * only for attributes for which an SP wishes to provide a value, so fo the other * ones don't bother calling the SPs again--just use the real value we picked up * from the entry. * */ int slapi_vattr_values_type_thang_get( Slapi_Entry *e, vattr_type_thang *type_thang, Slapi_ValueSet **results, int *type_name_disposition, char **actual_type_name, int flags, int *buffer_flags ) { int rc = 0; char *type = NULL; type = vattr_typethang_get_name(type_thang); *results = vattr_typethang_get_values(type_thang); if (*results != NULL) { /* we already have a pointer directly into the entry */ *actual_type_name = type; *type_name_disposition = SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_EXACTLY_OR_ALIAS; *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_POINTERS; } else { /* fall back to usual implementation */ rc = slapi_vattr_values_get(e,type,results, type_name_disposition, actual_type_name, flags,buffer_flags); } return rc; } static void vattr_helper_get_entry_conts(Slapi_Entry *e,char *type, vattr_get_thang *my_get) { Slapi_Attr *a = NULL; void *dummy = 0; a = attrlist_find_ex(e->e_attrs,type,&(my_get->get_name_disposition), &(my_get->get_type_name), &dummy); if (a) { my_get->get_present = 1; my_get->get_present_values = &(a->a_present_values); my_get->get_attr = a; } } static int vattr_helper_get_entry_conts_with_subtypes(Slapi_Entry *e,const char *type, vattr_get_thang **my_get) { Slapi_Attr *a = NULL; void *hint = 0; int counter = 0; int attr_count = attrlist_count_subtypes(e->e_attrs,type); if(attr_count > 0) { *my_get = (vattr_get_thang *)slapi_ch_calloc(attr_count, sizeof(vattr_get_thang)); /* pick up attributes with sub-types and slip into the get_thang list */ for(counter = 0; counter < attr_count; counter++) { a = attrlist_find_ex(e->e_attrs,type,&((*my_get)[counter].get_name_disposition), &((*my_get)[counter].get_type_name), &hint); if (a) { (*my_get)[counter].get_present = 1; (*my_get)[counter].get_present_values = &(a->a_present_values); (*my_get)[counter].get_attr = a; } } } return attr_count; } static int vattr_helper_get_entry_conts_no_subtypes(Slapi_Entry *e,const char *type, vattr_get_thang **my_get) { int attr_count = 0; Slapi_Attr *a = attrlist_find(e->e_attrs,type); if (a) { attr_count = 1; *my_get = (vattr_get_thang *)slapi_ch_calloc(1, sizeof(vattr_get_thang)); (*my_get)[0].get_present = 1; (*my_get)[0].get_name_disposition = SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_EXACTLY_OR_ALIAS; (*my_get)[0].get_type_name = a->a_type; (*my_get)[0].get_present_values = &(a->a_present_values); (*my_get)[0].get_attr = a; } return attr_count; } static int vattr_helper_get_entry_conts_ex(Slapi_Entry *e,const char *type, vattr_get_thang **my_get, int suppress_subtypes) { int rc; if ( suppress_subtypes ) { rc = vattr_helper_get_entry_conts_no_subtypes(e, type, my_get); } else { rc = vattr_helper_get_entry_conts_with_subtypes(e, type, my_get); } return rc; } vattr_context *vattr_context_new( Slapi_PBlock *pb ) { vattr_context *c = (vattr_context *)slapi_ch_calloc(1, sizeof(vattr_context)); /* The payload is zero, which is what we want */ if ( c ) { c->pb = pb; } return c; } static int vattr_context_check(vattr_context *c) { /* Observe the loop count and see if it's higher than is allowed */ if (c->vattr_context_loop_count > VATTR_LOOP_COUNT_MAX) { return SLAPI_VIRTUALATTRS_LOOP_DETECTED; } else return 0; } static void vattr_context_mark(vattr_context *c) { c->vattr_context_loop_count += 1; } static int vattr_context_unmark(vattr_context *c) { return (c->vattr_context_loop_count -= 1); } /* modify the context structure on exit from a vattr sp function */ static void vattr_context_ungrok(vattr_context **c) { /* Decrement the loop count */ if (0 == vattr_context_unmark(*c)) { /* If necessary, delete the structure */ slapi_ch_free((void **)c); } } /* Check and mess with the context structure on entry to a vattr sp function */ static int vattr_context_grok(vattr_context **c) { int rc = 0; /* First check that we've not got into an infinite loop. We do so by means of the vattr_context structure. */ /* Do we have a context at all ?? */ if (NULL == *c) { /* No, so let's make one */ *c = vattr_context_new( NULL ); if (NULL == *c) { return ENOMEM; } } else { /* Yes, so let's check its contents */ rc = vattr_context_check(*c); } /* mark the context as having been used once */ vattr_context_mark(*c); return rc; } /* keep track of error messages so we don't spam the error log */ static void vattr_context_set_loop_msg_displayed(vattr_context **c) { (*c)->error_displayed = 1; } static int vattr_context_is_loop_msg_displayed(vattr_context **c) { return (*c)->error_displayed; } /* * vattr_test_filter: * * . tests an ava, presence or substring filter against e. * . group these filter types together to avoid having to duplicate the * . vattr specific code in three seperate routines. * . handles virtual attrs in the filter. * . does update the vattrcache if a call to this calculates vattrs * * returns: 0 filter matched * -1 filter did not match * >0 an ldap error code * */ int vattr_test_filter( /* Entry we're interested in */ Slapi_Entry *e, Slapi_Filter *f, filter_type_t filter_type, char * type) { int rc = -1; int sp_bit = 0; /* Set if an SP supplied an answer */ vattr_sp_handle_list *list = NULL; Slapi_DN *sdn; Slapi_Backend *be; Slapi_DN *namespace_dn; /* get the namespace this entry belongs to */ sdn = slapi_entry_get_sdn( e ); be = slapi_be_select( sdn ); namespace_dn = (Slapi_DN*)slapi_be_getsuffix(be, 0); /* Look for attribute in the map */ if(namespace_dn) { list = vattr_map_namespace_sp_getlist(namespace_dn, type); } else { list = vattr_map_namespace_sp_getlist(NULL, type); } if (list) { vattr_sp_handle *current_handle = NULL; /* first lets consult the cache to save work */ int cache_status; cache_status = slapi_entry_vattrcache_findAndTest(e, type, f, filter_type, &rc); switch(cache_status) { case SLAPI_ENTRY_VATTR_RESOLVED_EXISTS: /* cached vattr */ { sp_bit = 1; break; } case SLAPI_ENTRY_VATTR_RESOLVED_ABSENT: /* does not exist */ break; /* look in entry */ case SLAPI_ENTRY_VATTR_NOT_RESOLVED: /* not resolved */ default: /* any other result, resolve */ { int flags = SLAPI_VIRTUALATTRS_REQUEST_POINTERS; void *hint = NULL; Slapi_ValueSet **results = NULL; /* pointer to result set */ int *type_name_disposition; char **actual_type_name; int buffer_flags; vattr_get_thang my_get = {0}; vattr_context ctx; /* bit cacky, but need to make a null terminated lists for now * for the (unimplemented and so fake) batch attribute request */ char *types[2]; void *hint_list[2]; types[0] = type; types[1] = 0; hint_list[1] = 0; /* set up some local context */ ctx.vattr_context_loop_count=1; ctx.error_displayed = 0; for (current_handle = vattr_map_sp_first(list,&hint); current_handle; current_handle = vattr_map_sp_next(current_handle,&hint)) { hint_list[0] = hint; rc = vattr_call_sp_get_batch_values(current_handle,&ctx,e, &my_get,types,&results,&type_name_disposition, &actual_type_name,flags,&buffer_flags, hint_list); if (0 == rc) { sp_bit = 1; break; } } if(!sp_bit) { /* * No vattr sp supplied an answer so will look in the * entry itself. * but first lets cache the no result */ slapi_entry_vattrcache_merge_sv(e, type, NULL ); } else { /* * A vattr sp supplied an answer. * so turn the value into a Slapi_Attr, pass * to the syntax plugin for comparison. */ if ( filter_type == FILTER_TYPE_AVA || filter_type == FILTER_TYPE_SUBSTRING ) { Slapi_Attr *a = NULL; int i=0; /* may need this when we have a passin interface for set_valueset */ /*Slapi_ValueSet null_valueset = {0};*/ rc=-1; if(results && actual_type_name && type_name_disposition) { while(results[i] && rc) { a = slapi_attr_new(); slapi_attr_init(a, type); /* a now contains a *copy* of results */ slapi_attr_set_valueset( a, results[i]); if ( filter_type == FILTER_TYPE_AVA ) { rc = plugin_call_syntax_filter_ava( a, f->f_choice, &f->f_ava ); } else if ( filter_type == FILTER_TYPE_SUBSTRING) { rc = plugin_call_syntax_filter_sub( a, &f->f_sub); } /* * Cache stuff: dups results */ slapi_entry_vattrcache_merge_sv(e, actual_type_name[i], results[i] ); /* * Free stuff, just in case we did not * get pointers. */ slapi_vattr_values_free( &(results[i]), &(actual_type_name[i]), buffer_flags); /* may need this when we support a passin set_valueset */ /*slapi_attr_set_valueset( a, &null_valueset);*/ /* since a contains a copy of results, we must free it */ slapi_attr_free(&a); i++; } } slapi_ch_free((void**)&results); slapi_ch_free((void**)&actual_type_name); slapi_ch_free((void**)&type_name_disposition); } else if ( filter_type == FILTER_TYPE_PRES ) { /* * Cache stuff: dups results */ int i=0; while(results[i]) { slapi_entry_vattrcache_merge_sv(e, actual_type_name[i], results[i] ); /* * Free stuff, just in case we did not * get pointers. */ slapi_vattr_values_free( &results[i], &actual_type_name[i], buffer_flags); } slapi_ch_free((void**)&results); slapi_ch_free((void**)&actual_type_name); slapi_ch_free((void**)&type_name_disposition); } } break; } }/* switch */ } /* If no SP supplied the answer, take it from the entry */ if (!sp_bit) { int acl_test_done; if ( filter_type == FILTER_TYPE_AVA ) { rc = test_ava_filter( NULL /* pb not needed */, e, e->e_attrs, &f->f_ava, f->f_choice, 0 /* no access check */, 0 /* do test filter */, &acl_test_done); } else if ( filter_type == FILTER_TYPE_SUBSTRING ) { rc = test_substring_filter( NULL, e, f, 0 /* no access check */, 0 /* do test filter */, &acl_test_done); } else if ( filter_type == FILTER_TYPE_PRES ) { rc = test_presence_filter( NULL, e, f->f_type, 0 /* no access check */, 0 /* do test filter */, &acl_test_done); } } return rc; } /* * deprecated in favour of slapi_vattr_values_get_sp_ex() which * returns subtypes too. */ SLAPI_DEPRECATED int slapi_vattr_values_get_sp(vattr_context *c, /* Entry we're interested in */ Slapi_Entry *e, /* attr type name */ char *type, /* pointer to result set */ Slapi_ValueSet** results, int *type_name_disposition, char** actual_type_name, int flags, int *buffer_flags) { PRBool use_local_ctx=PR_FALSE; vattr_context ctx; int rc = 0; int sp_bit = 0; /* Set if an SP supplied an answer */ vattr_sp_handle_list *list = NULL; vattr_get_thang my_get = {0}; if (c != NULL) { rc = vattr_context_grok(&c); if (0 != rc) { if(!vattr_context_is_loop_msg_displayed(&c)) { /* Print a handy error log message */ LDAPDebug(LDAP_DEBUG_ANY,"Detected virtual attribute loop in get on entry %s, attribute %s\n", slapi_entry_get_dn_const(e), type, 0); vattr_context_set_loop_msg_displayed(&c); } return rc; } } else { use_local_ctx=PR_TRUE; ctx.vattr_context_loop_count=1; ctx.error_displayed = 0; } /* For attributes which are in the entry, we just need to get to the Slapi_Attr structure and yank out the slapi_value_set structure. We either return a pointer directly to it, or we copy it, depending upon whether the caller asked us to try to avoid copying. */ /* First grok the entry, and remember what we saw. This call does no more than walk down the entry attribute list, do some string compares and copy pointers. */ vattr_helper_get_entry_conts(e,type, &my_get); /* Having done that, we now consult the attribute map to find service providers who are interested */ /* Look for attribute in the map */ if(!(flags & SLAPI_REALATTRS_ONLY)) { list = vattr_map_sp_getlist(type); if (list) { vattr_sp_handle *current_handle = NULL; void *hint = NULL; /* first lets consult the cache to save work */ int cache_status; cache_status = slapi_entry_vattrcache_find_values_and_type(e, type, results, actual_type_name); switch(cache_status) { case SLAPI_ENTRY_VATTR_RESOLVED_EXISTS: /* cached vattr */ { sp_bit = 1; /* Complete analysis of type matching */ if ( 0 == slapi_attr_type_cmp( type , *actual_type_name, SLAPI_TYPE_CMP_EXACT) ) { *type_name_disposition = SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_EXACTLY_OR_ALIAS; } else { *type_name_disposition = SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_SUBTYPE; } break; } case SLAPI_ENTRY_VATTR_RESOLVED_ABSENT: /* does not exist */ break; /* look in entry */ case SLAPI_ENTRY_VATTR_NOT_RESOLVED: /* not resolved */ default: /* any other result, resolve */ { for (current_handle = vattr_map_sp_first(list,&hint); current_handle; current_handle = vattr_map_sp_next(current_handle,&hint)) { if (use_local_ctx) { rc = vattr_call_sp_get_value(current_handle,&ctx,e,&my_get,type,results,type_name_disposition,actual_type_name,flags,buffer_flags, hint); } else { /* call this SP */ rc = vattr_call_sp_get_value(current_handle,c,e,&my_get,type,results,type_name_disposition,actual_type_name,flags,buffer_flags, hint); } if (0 == rc) { sp_bit = 1; break; } } if(!sp_bit) { /* clean up, we have failed and must now examine the * entry itself * But first lets cache the no result * Creates the type (if necessary). */ slapi_entry_vattrcache_merge_sv(e, type, NULL ); } else { /* * we need to cache the virtual attribute * creates the type (if necessary) and dups * results. */ slapi_entry_vattrcache_merge_sv(e, *actual_type_name, *results ); } break; } } } } /* If no SP supplied the answer, take it from the entry */ if (!sp_bit && !(flags & SLAPI_VIRTUALATTRS_ONLY)) { rc = 0; /* reset return code (cause an sp must have failed) */ *type_name_disposition = my_get.get_name_disposition; if (my_get.get_present) { if (flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS) { *results = my_get.get_present_values; *actual_type_name = my_get.get_type_name; } else { *results = valueset_dup(my_get.get_present_values); if (NULL == *results) { rc = ENOMEM; } else { *actual_type_name = slapi_ch_strdup(my_get.get_type_name); if (NULL == *actual_type_name) { rc = ENOMEM; } } } if (flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS) { *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_POINTERS; } else { *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_COPIES; } } else { rc = SLAPI_VIRTUALATTRS_NOT_FOUND; } } if (!use_local_ctx) { vattr_context_ungrok(&c); } return rc; } /* * * returns 0: (no_error && type found ) in which case: * results: contains the current values for type and * all it's subtypes in e * type_name_disposition: how each type was matched * SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_EXACTLY_OR_ALIAS * SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_SUBTYPE * actual_type_name: type name as found * flags: bit mask of options: * SLAPI_REALATTRS_ONLY * SLAPI_VIRTUALATTRS_ONLY * SLAPI_VIRTUALATTRS_REQUEST_POINTERS * SLAPI_VIRTUALATTRS_LIST_OPERATIONAL_ATTRS * buffer_flags: bit mask to be used as input flags for * slapi_values_free() * SLAPI_VIRTUALATTRS_RETURNED_POINTERS * SLAPI_VIRTUALATTRS_RETURNED_COPIES * SLAPI_VIRTUALATTRS_REALATTRS_ONLY * item_count: number of subtypes matched * otherwise: * SLAPI_VIRTUALATTRS_LOOP_DETECTED (failed to eval a vattr) * SLAPI_VIRTUALATTRS_NOT_FOUND (type not recognised by any vattr * sp && not a real attr in entry ) * ENOMEM (memory error) * * Note: * . modifes the virtual cache in the entry. * . for cached vattrs you always get a copy, so it will need to be * freed via slapi_values_free(). * */ int slapi_vattr_values_get_sp_ex(vattr_context *c, /* Entry we're interested in */ Slapi_Entry *e, /* attr type name */ char *type, /* pointer to result set */ Slapi_ValueSet*** results, int **type_name_disposition, char*** actual_type_name, int flags, int *buffer_flags, int *item_count) { return slapi_vattr_namespace_values_get_sp( c, e, NULL, type, results, type_name_disposition, actual_type_name, flags, buffer_flags, item_count ); } int slapi_vattr_namespace_values_get_sp(vattr_context *c, /* Entry we're interested in */ Slapi_Entry *e, /* DN denoting backend namespace */ Slapi_DN *namespace_dn, /* attr type name */ char *type, /* pointer to result set */ Slapi_ValueSet*** results, int **type_name_disposition, char*** actual_type_name, int flags, int *buffer_flags, int *item_count) { int rc = 0; int sp_bit = 0; /* Set if an SP supplied an answer */ vattr_sp_handle_list *list = NULL; vattr_get_thang *my_get = NULL; int attr_count = 0; rc = vattr_context_grok(&c); if (0 != rc) { /* Print a handy error log message */ if(!vattr_context_is_loop_msg_displayed(&c)) { LDAPDebug(LDAP_DEBUG_ANY,"Detected virtual attribute loop in get on entry %s, attribute %s\n", slapi_entry_get_dn_const(e), type, 0); vattr_context_set_loop_msg_displayed(&c); } return rc; } /* Having done that, we now consult the attribute map to find service providers who are interested */ /* Look for attribute in the map */ if(!(flags & SLAPI_REALATTRS_ONLY)) { /* we use the vattr namespace aware version of this */ list = vattr_map_namespace_sp_getlist(namespace_dn, type); if (list) { vattr_sp_handle *current_handle = NULL; void *hint = NULL; /* first lets consult the cache to save work */ int cache_status; cache_status = slapi_entry_vattrcache_find_values_and_type_ex(e, type, results, actual_type_name); switch(cache_status) { case SLAPI_ENTRY_VATTR_RESOLVED_EXISTS: /* cached vattr */ { sp_bit = 1; /* Complete analysis of type matching */ *type_name_disposition = (int *)slapi_ch_malloc(sizeof(*type_name_disposition)); if ( 0 == slapi_attr_type_cmp( type , **actual_type_name, SLAPI_TYPE_CMP_EXACT) ) { **type_name_disposition = SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_EXACTLY_OR_ALIAS; } else { **type_name_disposition = SLAPI_VIRTUALATTRS_TYPE_NAME_MATCHED_SUBTYPE; } *item_count = 1; break; } case SLAPI_ENTRY_VATTR_RESOLVED_ABSENT: /* does not exist */ break; /* look in entry */ case SLAPI_ENTRY_VATTR_NOT_RESOLVED: /* not resolved */ default: /* any other result, resolve */ { /* bit cacky, but need to make a null terminated lists for now * for the (unimplemented and so fake) batch attribute request */ char **type_list = (char**)slapi_ch_calloc(2,sizeof(char*)); void **hint_list = (void**)slapi_ch_calloc(2,sizeof(void*)); type_list[0] = type; for (current_handle = vattr_map_sp_first(list,&hint); current_handle; current_handle = vattr_map_sp_next(current_handle,&hint)) { /* call this SP */ hint_list[0] = hint; rc = vattr_call_sp_get_batch_values(current_handle,c,e,my_get, type_list,results,type_name_disposition, actual_type_name, flags,buffer_flags, hint_list); if (0 == rc) { sp_bit = 1; /* this sp provided an answer, we are done */ /* count the items in the (null terminated) result list */ *item_count = 0; while((*results)[*item_count]) { (*item_count)++; } break; } } slapi_ch_free((void**)&type_list); slapi_ch_free((void**)&hint_list); if(!sp_bit) { /* we have failed and must now examine the entry itself * * But first lets cache the no result * dups the type (if necessary). */ slapi_entry_vattrcache_merge_sv(e, type, NULL ); } else { /* * we need to cache the virtual attribute * dups the type (if necessary) and results. */ /* * this (and above) will of course need to get updated * when we do real batched attributes */ slapi_entry_vattrcache_merge_sv(e, **actual_type_name, **results ); } } } } } /* If no SP supplied the answer, take it from the entry */ if (!sp_bit && !(flags & SLAPI_VIRTUALATTRS_ONLY)) { int counter; /* First grok the entry - allocates memory for list */ attr_count = vattr_helper_get_entry_conts_ex(e,type, &my_get, (0 != (flags & SLAPI_VIRTUALATTRS_SUPPRESS_SUBTYPES))); *item_count = attr_count; rc = 0; /* reset return code (cause an sp must have failed) */ if(attr_count > 0) { *results = (Slapi_ValueSet**)slapi_ch_calloc(1, sizeof(*results) * attr_count); *type_name_disposition = (int *)slapi_ch_malloc(sizeof(*type_name_disposition) * attr_count); *actual_type_name = (char**)slapi_ch_malloc(sizeof(*actual_type_name) * attr_count); /* For attributes which are in the entry, we just need to get to the Slapi_Attr structure and yank out the slapi_value_set structure. We either return a pointer directly to it, or we copy it, depending upon whether the caller asked us to try to avoid copying. */ for(counter = 0; counter < attr_count; counter++) { (*type_name_disposition)[counter] = my_get[counter].get_name_disposition; if (my_get[counter].get_present) { if (flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS) { /* pointers will do, good */ (*results)[counter] = my_get[counter].get_present_values; (*actual_type_name)[counter] = my_get[counter].get_type_name; } else { /* need to copy the values */ (*results)[counter] = valueset_dup(my_get[counter].get_present_values); if (NULL == (*results)[counter]) { rc = ENOMEM; } else { (*actual_type_name)[counter] = slapi_ch_strdup(my_get[counter].get_type_name); if (NULL == (*actual_type_name)[counter]) { rc = ENOMEM; } } } if (flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS) { *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_POINTERS; } else { *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_COPIES; } } else { rc = SLAPI_VIRTUALATTRS_NOT_FOUND; } } slapi_ch_free((void **)&my_get); } } vattr_context_ungrok(&c); return rc; } /* Do we need a call to free the results from the above ? */ void slapi_vattr_values_free(Slapi_ValueSet **value, char** actual_type_name, int flags) { /* Check whether we need to free the strings */ if (flags & SLAPI_VIRTUALATTRS_RETURNED_POINTERS) { /* We don't need to free the values */ } else { /* Free the valueset */ if (*value) { slapi_valueset_free(*value); } if (*actual_type_name) { slapi_ch_free((void **)actual_type_name); } } *actual_type_name = NULL; *value = NULL; } /* Function like the one above but doing a compare operation */ /* Same return codes as above. Compare result value returned in "result": 0 if compare true, 1 if compare false */ int slapi_vattr_value_compare(Slapi_Entry *e, char *type, Slapi_Value *test_this, int *result, int flags) { return slapi_vattr_namespace_value_compare_sp(NULL,e,NULL,type,test_this,result,flags); } /* namespace version of above */ int slapi_vattr_namespace_value_compare(Slapi_Entry *e, Slapi_DN *namespace_dn, const char *type, Slapi_Value *test_this, int *result, int flags) { return slapi_vattr_namespace_value_compare_sp(NULL,e,namespace_dn,type,test_this,result,flags); } int slapi_vattr_value_compare_sp(vattr_context *c,/* Entry we're interested in */ Slapi_Entry *e,/* attr type name */ char *type, Slapi_Value *test_this,/* pointer to result */ int *result, int flags) { return slapi_vattr_namespace_value_compare_sp(c,e,NULL,type,test_this,result,flags); } int slapi_vattr_namespace_value_compare_sp(vattr_context *c,/* Entry we're interested in */ Slapi_Entry *e, /* backend namespace dn*/Slapi_DN *namespace_dn, /* attr type name */ const char *type, Slapi_Value *test_this,/* pointer to result */ int *result, int flags) { int rc = 0; int sp_bit = 0; /* Set if an SP supplied an answer */ vattr_sp_handle_list *list = NULL; vattr_get_thang *my_get = 0; *result = 0; /* return "compare false" by default */ rc = vattr_context_grok(&c); if (0 != rc) { /* Print a handy error log message */ LDAPDebug(LDAP_DEBUG_ANY,"Detected virtual attribute loop in compare on entry %s, attribute %s\n", slapi_entry_get_dn_const(e), type, 0); return rc; } /* Having done that, we now consult the attribute map to find service providers who are interested */ /* Look for attribute in the map */ list = vattr_map_namespace_sp_getlist(namespace_dn, type); if (list) { vattr_sp_handle *current_handle = NULL; void *hint = NULL; for (current_handle = vattr_map_sp_first(list,&hint); current_handle; current_handle = vattr_map_sp_next(list,&hint)) { /* call this SP */ rc = vattr_call_sp_compare_value(current_handle,c,e,my_get,type,test_this,result,flags, hint); if (0 == rc) { sp_bit = 1; break; } } } /* If no SP supplied the answer, take it from the entry */ if (!sp_bit) { /* Grok the entry, and remember what we saw. This call does no more than walk down the entry attribute list, do some string compares and copy pointers. */ int attr_count = vattr_helper_get_entry_conts_ex(e,type, &my_get, (0 != (flags & SLAPI_VIRTUALATTRS_SUPPRESS_SUBTYPES))); if (my_get && my_get->get_present) { int i; Slapi_Value *Dummy_value = NULL; /* Put the required stuff in the fake attr */ for(i=0;i<attr_count;i++) { Dummy_value = slapi_valueset_find( my_get[i].get_attr, my_get[i].get_present_values, test_this ); if (Dummy_value) { *result = 1; /* return "compare true" */ break; } } } else { rc = SLAPI_VIRTUALATTRS_NOT_FOUND; } } vattr_context_ungrok(&c); slapi_ch_free((void **)&my_get); return rc; } /* Function to obtain the list of attribute types which are available on this entry */ /* Need to call service providers here: We know only the entry's DN and so we could restrict our choice of SPs based on that. However, we don't yet implement such fancyness. For now, we just crawl through all the SPs, asking them in turn to contribute. This is pretty inefficient because we will trawl the list for each wildcard attribute type search operation. Service providers should therefore handle the call as fast as they can. */ struct _vattr_type_list_context { unsigned int vattr_context_loop_count; vattr_type_thang *types; int realattrs_only; /* TRUE implies list contains only real attrs */ int list_is_copies; int flags; size_t list_length; size_t block_length; }; /* Helper function which converts a type list from pointers to copies */ static int vattr_convert_type_list(vattr_type_list_context *thang) { vattr_type_thang *old_list = NULL; vattr_type_thang *new_list = NULL; size_t index = 0; old_list = thang->types; /* Make a new list */ new_list = (vattr_type_thang*)slapi_ch_calloc(thang->block_length, sizeof(vattr_type_thang)); if (NULL == new_list) { return ENOMEM; } /* Walk the list strdup'ing the type name and copying the rest of the structure contents */ for (index = 0; index < thang->list_length; index++) { new_list[index].type_flags = old_list[index].type_flags; new_list[index].type_name = slapi_ch_strdup(old_list[index].type_name); /* * list_is_copies does not affect type_values as it * is always a pointer never a copy. */ new_list[index].type_values = old_list[index].type_values; } /* Mark it a copy list */ thang->list_is_copies = 1; /* Free the original list */ slapi_ch_free((void **)&(thang->types)); /* swap lists */ thang->types = new_list; return 0; } /* * Returns all the attribute types from e, both real and virtual. * * Any of the attributes found in the entry to start with, for * whom no vattr SP volunteered, will also have a pointer to the * original valueset in the entry--this fact can be used by * calling slapi_vattr_values_type_thang_get(), which will * take the values present in the vattr_type_thang list * rather than calling slapi_vattr_values_get() to retrieve the value. */ #define TYPE_LIST_EXTRA_SPACE 5 /* Number of extra slots we allow for SP's to insert types */ int slapi_vattr_list_attrs(/* Entry we're interested in */ Slapi_Entry *e, /* pointer to receive the list */ vattr_type_thang **types, int flags, int *buffer_flags) { int rc = 0; size_t attr_count = 0; vattr_type_thang *result_array = NULL ; Slapi_Attr *current_attr = NULL; size_t i = 0; int list_is_copies = 0; vattr_sp_handle_list *list = NULL; size_t list_length = 0; size_t block_length = 0; vattr_type_list_context type_context = {0}; block_length = 1 + TYPE_LIST_EXTRA_SPACE; if(!(flags & SLAPI_VIRTUALATTRS_ONLY)) { /* First find what's in the entry itself*/ /* Count the attributes */ for (current_attr = e->e_attrs; current_attr != NULL; current_attr = current_attr->a_next, attr_count++) ; block_length += attr_count; /* Allocate the pointer array */ result_array = (vattr_type_thang*)slapi_ch_calloc(block_length,sizeof(vattr_type_thang)); if (NULL == result_array) { return ENOMEM; } list_length = attr_count; /* Now copy the pointers into the array */ i = 0; for (current_attr = e->e_attrs; current_attr != NULL; current_attr = current_attr->a_next) { char *mypointer = NULL; if (flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS) { mypointer = current_attr->a_type; result_array[i].type_values = &(current_attr->a_present_values); } else { mypointer = slapi_ch_strdup(current_attr->a_type); list_is_copies = 1; } result_array[i].type_flags = current_attr->a_flags; result_array[i++].type_name = mypointer; } PR_ASSERT(i == attr_count); } /* if we didnt send real attrs we need to allocate result array */ if(NULL == result_array) { result_array = (vattr_type_thang*)slapi_ch_calloc(block_length,sizeof(vattr_type_thang)); if (NULL == result_array) { return ENOMEM; } } /* Then ask the service providers for their input */ type_context.flags = flags; type_context.realattrs_only = 1; /* until we know otherwise */ type_context.list_is_copies = list_is_copies; type_context.types = result_array; type_context.list_length = list_length; type_context.block_length = block_length; /* * At this point type_context.types is a list of all * the attributetypes (copies or pointers) and values (copies, if present) * found in the entry. */ if(!(flags & SLAPI_REALATTRS_ONLY)) { list = vattr_map_sp_get_complete_list(); if (list) { vattr_sp_handle *current_handle = NULL; for (current_handle = vattr_list_sp_first(list); current_handle; current_handle = vattr_list_sp_next((vattr_sp_handle_list *)current_handle)) { /* call this SP */ rc = vattr_call_sp_get_types(current_handle,e,&type_context, flags); if (0 != rc) { /* DBDB do what on error condition ? */ } } /* assert enough space for the null terminator */ PR_ASSERT( type_context.list_length < type_context.block_length); i = type_context.list_length; } } /* * Now type_context.types is a list of all the types in this entry-- * real and virtual. For real ones, the values field is filled in. * For virtual ones (including virtual ones which will overwrite a real * value) the values field is null--this fact may used * subsequently by callers of slapi_vattr_list_attrs() * by calling slapi_vattr_values_type_thang_get() which * will only calculate the values for attributetypes with * non-null values. */ flags = type_context.flags; list_is_copies = type_context.list_is_copies; result_array = type_context.types; list_length = type_context.list_length; block_length = type_context.block_length; if (list_is_copies) { *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_COPIES; } else { *buffer_flags = SLAPI_VIRTUALATTRS_RETURNED_POINTERS; } /* Let the caller know if the list contains only real attrs */ if (type_context.realattrs_only) { *buffer_flags |= SLAPI_VIRTUALATTRS_REALATTRS_ONLY; } result_array[i].type_name = NULL; if (types && list_length) { *types = result_array; } else *types = 0; return rc; } static int vattr_add_thang_to_list(vattr_type_list_context *c, vattr_type_thang *thang) { vattr_type_thang *new_list = NULL; /* Will it fit in the current block ? */ if (c->list_length == c->block_length - 1) { c->block_length *= 2; new_list = (vattr_type_thang*)slapi_ch_realloc((char *)c->types, c->block_length * (int)sizeof(vattr_type_thang)); if (NULL == new_list) { return ENOMEM; } c->types = new_list; } /* Add to the end of the list */ c->types[c->list_length ] = *thang; c->list_length += 1; return 0; } /* Called by SP's during their get_types call, to have the server add a * type to the type list. * * c: the vattr_type_list_context passed from the original caller of * slapi_vattr_list_attrs() * thang: the new type to be added to the type list. * flags: tells the routine whether to copy the thang or not. * SLAPI_VIRTUALATTRS_REQUEST_POINTERS--no need to copy it. * !(SLAPI_VIRTUALATTRS_REQUEST_POINTERS)--need to copy it. * * Checks to see if the requested type is already in the list, * and if it is, if the value of the attribute is * non-null, it resets the value to null. This means that when used * subsequently, the type list indicates whether, for a given attribute type, * the SP's need to be called to retrieve the value. * */ int slapi_vattrspi_add_type(vattr_type_list_context *c, vattr_type_thang *thang, int flags) { int rc = 0; unsigned int index = 0; vattr_type_thang thang_to_add = {0}; int found_it = 0; PR_ASSERT(c); /* We are no longer sure that the list contains only real attrs */ c->realattrs_only = 0; /* Check to see if the type is in the list already */ for (index = 0; index < c->list_length; index++) { if (0 == slapi_UTF8CASECMP(c->types[index].type_name,thang->type_name)) { found_it = 1; break; } } /* * If found and there are values specified in the vattr_type_thang, then * that means it's a real attribute--because SP's do not add values * when called via slapi_vattr_list_attrs()/vattr_call_sp_get_types(). * However, an SP is willing to claim responsibility for this attribute * type, so to ensure that that virtual value will get calculated, set the * original real value to NULL here. * The guiding rule here is "if an SP is prepared * to provide a value for an attribute type, then that is the one * that must be returned to the user". Note, this does not prevent * the SP implementing a "merge real with virtual policy", if they * wish. */ if (found_it) { if ( c->types[index].type_values != NULL ) { /* * Any values in this list are always pointers. * See slapi_vattr_list_types() and vattr_convert_type_list() */ c->types[index].type_values = NULL; } return 0; } /* * If it's not in the list then we need to add it. * If the list is already copies, then we need to make a copy of what the * SP passed us. * If the SP indicated that the type name it passed us is volatile, * !(flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS) * then we need to copy it anyway. */ /* rbyrneXXX optimisation for COS: if each type_thang could have a * free_flag * then we would not have to convert all the real attrs to copies * just because an SP returned a copy (note: only COS rrequires copies; * roles returns a pointer to a static string "nsRole"). */ if (!c->list_is_copies && (0 == (flags & SLAPI_VIRTUALATTRS_REQUEST_POINTERS))) { /* Means we need to turn the existing list into a list of copies */ vattr_convert_type_list(c); } if (c->list_is_copies) { thang_to_add.type_flags = thang->type_flags; thang_to_add.type_name = slapi_ch_strdup(thang->type_name); } else { thang_to_add = *thang; } /* Lastly, we add to the list, using a function which hides the complexity of extending the list if it fills up */ vattr_add_thang_to_list(c, &thang_to_add); return rc; } /* Function to free the list returned in the function above */ /* Written, reviewed, debug stepped */ void slapi_vattr_attrs_free(vattr_type_thang **types, int flags) { if (NULL == *types) { return; } /* Check whether we need to free the strings */ if (flags & SLAPI_VIRTUALATTRS_RETURNED_POINTERS) { /* We don't need to free the values */ } else { char *attr_name_to_free = NULL; size_t i = 0; /* Walk down the set of values, fr eeing each one in turn */ for (; (attr_name_to_free = (*types)[i].type_name) != NULL; i++) { slapi_ch_free((void **)&attr_name_to_free); } } /* We always need to free the pointer block */ slapi_ch_free((void **)types); } char *vattr_typethang_get_name(vattr_type_thang *t) { return t->type_name; } unsigned long vattr_typethang_get_flags(vattr_type_thang *t) { return t->type_flags; } vattr_type_thang *vattr_typethang_next(vattr_type_thang *t) { t++; if (t->type_name) { return t; } else { return NULL; } } vattr_type_thang *vattr_typethang_first(vattr_type_thang *t) { return t; } vattr_get_thang *slapi_vattr_getthang_first(vattr_get_thang *t) { return t; } vattr_get_thang *slapi_vattr_getthang_next(vattr_get_thang *t) { t++; if (t->get_present) { return t; } else { return NULL; } } /* End of the public interface functions */ /* Everything below here is the SPI interface, only callable by vattr service providers. Currently this interface is not public. Interface definitions are in vattr_spi.h */ /* Structures used in the SPI interface */ /* Service provider object */ struct _vattr_sp { /* vtbl */ vattr_get_fn_type sp_get_fn; vattr_get_ex_fn_type sp_get_ex_fn; vattr_compare_fn_type sp_compare_fn; vattr_types_fn_type sp_types_fn; void *sp_data; /* Pointer for use by the Service Provider */ }; typedef struct _vattr_sp vattr_sp; /* Service provider handle */ struct _vattr_sp_handle { vattr_sp *sp; struct _vattr_sp_handle *next; /* So we can link them together in the map */ void *hint; /* Hint to the SP */ }; /* Calls made by Service Providers */ /* Call to register as a service provider */ /* This function needs to do the following: o Let the provider say "hey, I'm here". It should probably get some handle back which it can use in future calls. o Say whether it wants to be called to resolve every single query, or whether it will say in advance what attrs it services. */ static vattr_sp_handle *vattr_sp_list = NULL; int slapi_vattrspi_register(vattr_sp_handle **h, vattr_get_fn_type get_fn, vattr_compare_fn_type compare_fn, vattr_types_fn_type types_fn) { return slapi_vattrspi_register_internal(h, get_fn, 0, compare_fn, types_fn, 0); } int slapi_vattrspi_register_ex(vattr_sp_handle **h, vattr_get_ex_fn_type get_fn, vattr_compare_fn_type compare_fn, vattr_types_fn_type types_fn, void *options) { return slapi_vattrspi_register_internal(h, 0, get_fn, compare_fn, types_fn, options); } /* options not used yet - for future expansion */ int slapi_vattrspi_register_internal(vattr_sp_handle **h, vattr_get_fn_type get_fn, vattr_get_ex_fn_type get_ex_fn, vattr_compare_fn_type compare_fn, vattr_types_fn_type types_fn, void *options) { vattr_sp_handle *return_to_caller = NULL; vattr_sp_handle *list_handle = NULL; vattr_sp *new_sp = NULL; /* Make a service provider handle */ new_sp = (vattr_sp*)slapi_ch_calloc(1,sizeof(vattr_sp)); if (NULL == new_sp) { slapd_nasty(sourcefile,7,0); return ENOMEM; } return_to_caller = (vattr_sp_handle*)slapi_ch_calloc(1,sizeof(vattr_sp_handle)); if (NULL == return_to_caller) { slapd_nasty(sourcefile,8,0); return ENOMEM; } new_sp->sp_get_fn = get_fn; new_sp->sp_get_ex_fn = get_ex_fn; new_sp->sp_compare_fn = compare_fn; new_sp->sp_types_fn = types_fn; return_to_caller->sp = new_sp; /* Add to the service provider list */ /* Make a handle for the list */ list_handle = (vattr_sp_handle*)slapi_ch_calloc(1, sizeof (vattr_sp_handle)); if (NULL == list_handle) { return ENOMEM; } *list_handle = *return_to_caller; list_handle->next = vattr_sp_list; vattr_sp_list = list_handle; /* Return the handle to the caller */ *h = return_to_caller; return 0; } vattr_sp_handle_list *vattr_map_sp_get_complete_list() { return vattr_sp_list; } int slapi_vattrspi_regattr(vattr_sp_handle *h,char *type_name_to_register, char* DN , void *hint) { int ret = 0; char *type_to_add; int free_type_to_add = 0; /* Supplying a DN means that the plugin requires to be called * only when the considering attributes in relevant entries - almost * * Actually the smallest namespace is the backend. * * atttributes that are tied to backends have the format DN::attr * this essentially makes the attribute have split namespaces * that are treated as separate attributes in the vattr code */ if(DN) { /* as a coutesy we accept any old DN and will convert * to a namespace DN, this helps to hide details * (that we might decide to change) anyway */ Slapi_DN original_dn; Slapi_Backend *be; Slapi_DN *namespace_dn; slapi_sdn_init(&original_dn); slapi_sdn_set_dn_byref(&original_dn,DN); be = slapi_be_select( &original_dn ); namespace_dn = (Slapi_DN*)slapi_be_getsuffix(be, 0); if(namespace_dn && be != defbackend_get_backend()) /* just in case someone thinks "" is a good namespace */ { type_to_add = (char*)PR_smprintf("%s::%s", (char*)slapi_sdn_get_dn(namespace_dn), type_name_to_register); if(!type_to_add) { ret = -1; } free_type_to_add = 1; } else { type_to_add = type_name_to_register; } slapi_sdn_done(&original_dn); } else { type_to_add = type_name_to_register; } ret = vattr_map_sp_insert(type_to_add,h,hint); if(free_type_to_add) { PR_smprintf_free(type_to_add); } return ret; } /* Call to advertise or refute that you generate the value for some attribute, and to signal that the definition for this attribute has changed */ /* This call needs to do the following: o Let the SP say "you know, I will generate the value of attribute "foo", within subtree "bar". (we might ignore the subtree for now to keep things simple o Same as above, but say "you know, I'm not doing that any more". (we'll do that with a addordel flag). o Say, "you know that definition I said I did, well it's changed". */ /* Functions to handle the context stucture */ int slapi_vattr_context_create(vattr_context **c) { return 0; } void slapi_vattr_context_destroy(vattr_context *c) { } int vattr_call_sp_get_value(vattr_sp_handle *handle, vattr_context *c, Slapi_Entry *e, vattr_get_thang *my_get, char *type, Slapi_ValueSet** results,int *type_name_disposition, char** actual_type_name, int flags, int *buffer_flags, void* hint) { int ret = -1; if(handle->sp->sp_get_fn) { ret = ((handle->sp->sp_get_fn)(handle,c,e,type,results,type_name_disposition,actual_type_name,flags,buffer_flags, hint)); } return ret; } int vattr_call_sp_get_batch_values(vattr_sp_handle *handle, vattr_context *c, Slapi_Entry *e, vattr_get_thang *my_get, char **type, Slapi_ValueSet*** results,int **type_name_disposition, char*** actual_type_name, int flags, int *buffer_flags, void** hint) { int ret = 0; if(handle->sp->sp_get_ex_fn) { ret = ((handle->sp->sp_get_ex_fn)(handle,c,e,type,results,type_name_disposition,actual_type_name,flags,buffer_flags, hint)); } else { /* make our args look like the simple non-batched case */ *results = (Slapi_ValueSet**)slapi_ch_calloc(2, sizeof(*results)); /* 2 for null terminated list */ *type_name_disposition = (int *)slapi_ch_calloc(2, sizeof(*type_name_disposition)); *actual_type_name = (char**)slapi_ch_calloc(2, sizeof(*actual_type_name)); ret =((handle->sp->sp_get_fn)(handle,c,e,*type,*results,*type_name_disposition,*actual_type_name,flags,buffer_flags, hint)); if(ret) { slapi_ch_free((void**)results ); slapi_ch_free((void**)type_name_disposition ); slapi_ch_free((void**)actual_type_name ); } } return ret; } int vattr_call_sp_compare_value(vattr_sp_handle *handle, vattr_context *c, Slapi_Entry *e, vattr_get_thang *my_get, const char *type, Slapi_Value* test_this,int *result, int flags, void* hint) { return ((handle->sp->sp_compare_fn)(handle,c,e,(char*)type,test_this,result,flags, hint)); } int vattr_call_sp_get_types(vattr_sp_handle *handle,Slapi_Entry *e,vattr_type_list_context *type_context,int flags) { return ((handle->sp->sp_types_fn)(handle,e,type_context,flags)); } /* Service provider entry point prototypes */ /* Call which allows a SP to say what attributes can be used to define a given attribute, used for loop detection */ /* Not implementing this yet */ /* typedef int (*vattrspi_explain_definition) (); */ /* Function called to indicate to the SP that the game is over, we free the handle, not the SP */ typedef int (*vattrspi_deregister) (vattr_sp_handle *h); /* End of the SPI functions */ /* Implementation functions only after here */ /* The attribute map */ /* We need a structure which can map attribute type names to SP's which might tell us something useful. We need a function which, given an attr type name, can return a set of SP's to ask about said attr. SP's which don't tell us which attrs they are handling always get asked. The first SP which tells us the answer wins, we don't attempt to arbitrate between them. One might imaging doing this stuff in a unified way with other stuff pertaining to types (schema, syntax). Someday. For now this is a separate thing in the insterests of stability. */ /* Virtual Attribute map implementation */ /* The virtual attribute type map is implemented as a hash table. The single key is the attribute type base name (not an alias) (what about subtypes??). The hash table takes care of translating this key to a list of probable service providers for the type. Other than the obvious lookup function, we need functions to allow entries to be added and removed from the map. Because the map is likely to be consulted at least once for every search operation performed by the server, it's important that it is free from performance deficiencies such as lock contention (is the NSPR hash table implementation even thread safe ? */ #define VARRT_MAP_HASHTABLE_SIZE 10 /* Attribute map oject */ /* Needs to contain: a linked list of pointers to provider handles handles, The type name, other stuff ? Access to the entire map will be controlled via a single RW lock. */ struct _objAttrValue { struct _objAttrValue *pNext; Slapi_Value *val; }; typedef struct _objAttrValue objAttrValue; struct _vattr_map_entry { char * /* currect ? */ type_name; vattr_sp_handle *sp_list; objAttrValue *objectclasses; /* objectclasses for this type to check schema with*/ }; typedef struct _vattr_map_entry vattr_map_entry; vattr_map_entry test_entry = {NULL}; struct _vattr_map { PRRWLock *lock; PLHashTable *hashtable; /* Hash table */ }; typedef struct _vattr_map vattr_map; static vattr_map *the_map = NULL; static PRIntn vattr_hash_compare_keys(const void *v1, const void *v2) { /* Should this be subtype aware, etc ? */ return ( (0 == strcasecmp(v1,v2)) ? 1 : 0) ; } static PRIntn vattr_hash_compare_values(const void *v1, const void *v2) { return( ((char *)v1 == (char *)v2 ) ? 1 : 0); } static PLHashNumber vattr_hash_fn(const void *type_name) { /* need a hash function here */ /* Sum the bytes for now */ PLHashNumber result = 0; char * current_position = NULL; char current_char = 0; for (current_position = (char*) type_name; *current_position; current_position++) { current_char = tolower(*current_position); result += current_char; } return result; } static int vattr_map_create() { the_map = (vattr_map*)slapi_ch_calloc(1, sizeof(vattr_map)); if (NULL == the_map) { slapd_nasty(sourcefile,1,0); return ENOMEM; } the_map->hashtable = PL_NewHashTable(VARRT_MAP_HASHTABLE_SIZE, vattr_hash_fn, vattr_hash_compare_keys, vattr_hash_compare_values, NULL, NULL); if (NULL == the_map->hashtable) { slapd_nasty(sourcefile,2,0); return ENOMEM; } the_map->lock = PR_NewRWLock(0,SOURCEFILE "1"); if (NULL == the_map) { slapd_nasty(sourcefile,3,0); return ENOMEM; } return 0; } static void vattr_map_destroy() { if (the_map) { if (the_map->hashtable) { PL_HashTableDestroy(the_map->hashtable); } if (the_map->lock) { PR_DestroyRWLock(the_map->lock); } } slapi_ch_free ((void**)&the_map); } /* Returns 0 if present, entry returned in result. Returns SLAPI_VIRTUALATTRS_NOT_FOUND if not found */ static int vattr_map_lookup(const char *type_to_find, vattr_map_entry **result) { char *basetype = 0; char *tmp = 0; char buf[SLAPD_TYPICAL_ATTRIBUTE_NAME_MAX_LENGTH]; *result = NULL; PR_ASSERT(the_map); /* vattrs need to support subtypes * we insist that one service provider * will support all subtypes for a * given superior, hence we look for * superiors only here */ tmp = slapi_attr_basetype( type_to_find, buf, sizeof(buf)); if(tmp) { basetype = tmp; } else { basetype = buf; } /* Get the reader lock */ PR_RWLock_Rlock(the_map->lock); *result = (vattr_map_entry*)PL_HashTableLookupConst(the_map->hashtable, (void*)basetype); /* Release ze lock */ PR_RWLock_Unlock(the_map->lock); if(tmp) { slapi_ch_free_string(&tmp); } if (*result) { return 0; } else { return SLAPI_VIRTUALATTRS_NOT_FOUND; } } /* Insert an entry into the attribute map */ int vattr_map_insert(vattr_map_entry *vae) { char *copy_of_type_name = NULL; PR_ASSERT(the_map); copy_of_type_name = slapi_ch_strdup(vae->type_name); if (NULL == copy_of_type_name) { slapd_nasty(sourcefile,6,0); return ENOMEM; } /* Get the writer lock */ PR_RWLock_Wlock(the_map->lock); /* Insert the thing */ /* It's illegal to call this function if the entry is already there */ PR_ASSERT(NULL == PL_HashTableLookupConst(the_map->hashtable,(void*)copy_of_type_name)); PL_HashTableAdd(the_map->hashtable,(void*)copy_of_type_name,(void*)vae); /* Unlock and we're done */ PR_RWLock_Unlock(the_map->lock); return 0; } /* vattr_delete_attrvals --------------------- deletes a value list */ void vattr_delete_attrvals(objAttrValue **attrval) { objAttrValue *val = *attrval; while(val) { objAttrValue *next = val->pNext; slapi_value_free(&val->val); slapi_ch_free((void**)&val); val = next; } } /* vattr_add_attrval ----------------- adds a value to an attribute value list */ int vattr_add_attrval(objAttrValue **attrval, char *val) { int ret = 0; objAttrValue *theVal; LDAPDebug( LDAP_DEBUG_TRACE, "--> vattr_add_attrval\n",0,0,0); /* create the attrvalue */ theVal = (objAttrValue*) slapi_ch_malloc(sizeof(objAttrValue)); if(theVal) { theVal->val = slapi_value_new_string(val); if(theVal->val) { theVal->pNext = *attrval; *attrval = theVal; } else { slapi_ch_free((void**)&theVal); LDAPDebug( LDAP_DEBUG_ANY, "vattr_add_attrval: failed to allocate memory\n",0,0,0); ret = -1; } } else { LDAPDebug( LDAP_DEBUG_ANY, "vattr_add_attrval: failed to allocate memory\n",0,0,0); ret = -1; } LDAPDebug( LDAP_DEBUG_TRACE, "<-- vattr_add_attrval\n",0,0,0); return ret; } objAttrValue *vattr_map_entry_build_schema(char *type_name) { objAttrValue *ret = 0; struct objclass *oc; LDAPDebug( LDAP_DEBUG_TRACE, "--> vattr_map_entry_build_schema\n",0,0,0); /* this is the first opportunity to register * with the statechange api, our init function * gets called prior to loading plugins, so it * was not available then */ if(!statechange_api) { /* grab statechange api - we never release this */ if(!slapi_apib_get_interface(StateChange_v1_0_GUID, &statechange_api)) { /* register for schema changes via dn */ statechange_register(statechange_api, "vattr", "cn=schema", NULL, NULL, (notify_callback) schema_changed_callback); } } if(!config_get_schemacheck()) { LDAPDebug( LDAP_DEBUG_TRACE, "<-- vattr_map_entry_build_schema - schema off\n",0,0,0); return 0; } oc_lock_read(); for ( oc = g_get_global_oc_nolock(); oc != NULL; oc = oc->oc_next ) { char **pppAttrs[2]; int index; int attrType = 0; int oc_added = 0; pppAttrs[0] = oc->oc_required; pppAttrs[1] = oc->oc_allowed; /* we need to check both required and allowed attributes */ while(!oc_added && attrType < 2) { if(pppAttrs[attrType]) { index = 0; while(pppAttrs[attrType][index]) { if(!PL_strcasecmp(pppAttrs[attrType][index], type_name)) { vattr_add_attrval(&ret, oc->oc_name); oc_added = 1; break; } index++; } } attrType++; } } oc_unlock(); LDAPDebug( LDAP_DEBUG_TRACE, "<-- vattr_map_entry_build_schema\n",0,0,0); return ret; } static PRIntn vattr_map_entry_rebuild_schema(PLHashEntry *he, PRIntn i, void *arg) { vattr_map_entry *entry = (vattr_map_entry *)(he->value); if(entry->objectclasses) vattr_delete_attrvals(&(entry->objectclasses)); entry->objectclasses = vattr_map_entry_build_schema(entry->type_name); return HT_ENUMERATE_NEXT; } void schema_changed_callback(Slapi_Entry *e, char *dn, int modtype, Slapi_PBlock *pb, void *caller_data) { /* Get the writer lock */ PR_RWLock_Wlock(the_map->lock); /* go through the list */ PL_HashTableEnumerateEntries(the_map->hashtable, vattr_map_entry_rebuild_schema, 0); /* Unlock and we're done */ PR_RWLock_Unlock(the_map->lock); } int slapi_vattr_schema_check_type(Slapi_Entry *e, char *type) { int ret = 0; vattr_map_entry *map_entry; if(config_get_schemacheck()) { Slapi_Attr *attr; if(0 == slapi_entry_attr_find(e, "objectclass", &attr)) { Slapi_ValueSet *vs; if(0 == slapi_attr_get_valueset(attr, &vs)) { objAttrValue *obj; if(0 == vattr_map_lookup(type, &map_entry)) { PR_RWLock_Rlock(the_map->lock); obj = map_entry->objectclasses; while(obj) { if(slapi_valueset_find(attr, vs, obj->val)) { /* this entry has an objectclass * that allows or requires the * attribute type */ ret = -1;


context:
space:
mode: