~ubuntu-branches/ubuntu/wily/389-ds-base/wily-proposed

#define DNA_REMOTE_BUFSIZ      15 /* max size for bind method & protocol */

static struct dnaServer *dna_global_servers = NULL;

static Slapi_RWLock *g_dna_cache_server_lock;

 

    Slapi_DN *sdn;

    struct dnaServer *next; /* used for the global server list */

static void dna_delete_config(PRCList *list);

static int dna_get_shared_servers(struct configEntry *config_entry, PRCList **servers, int get_all);

static int dna_load_shared_servers();

static void dna_delete_global_servers();

static int dna_get_shared_config_attr_val(struct configEntry *config_entry, char *attr, char *value);

static PRCList *dna_config_copy();

/*

 * During the plugin startup we delay the creation of the shared config entries

 * so all the other betxn plugins have time to start.  During the "delayed"

 * update config event we will need a copy of the global config, as we can not

 * hold the read lock while starting a transaction(potential deadlock).

 */

static PRCList *

dna_config_copy()

{

    PRCList *copy = (PRCList *)slapi_ch_calloc(1, sizeof(struct configEntry));

    PRCList *config_list;

    PR_INIT_CLIST(copy);

    int first = 1;

 

 

    if (!PR_CLIST_IS_EMPTY(dna_global_config)) {

        config_list = PR_LIST_HEAD(dna_global_config);

        while (config_list != dna_global_config) {

            struct configEntry *new_entry = (struct configEntry *)slapi_ch_calloc(1, sizeof(struct configEntry));

            struct configEntry *config_entry = (struct configEntry *) config_list;

 

            new_entry->dn = slapi_ch_strdup(config_entry->dn);

            new_entry->types = slapi_ch_array_dup(config_entry->types);

            new_entry->prefix = slapi_ch_strdup(config_entry->prefix);

            new_entry->filter = slapi_ch_strdup(config_entry->filter);

            new_entry->slapi_filter = slapi_filter_dup(config_entry->slapi_filter);

            new_entry->generate = slapi_ch_strdup(config_entry->generate);

            new_entry->scope = slapi_ch_strdup(config_entry->scope);

            new_entry->shared_cfg_base = slapi_ch_strdup(config_entry->shared_cfg_base);

            new_entry->shared_cfg_dn   = slapi_ch_strdup(config_entry->shared_cfg_dn);

            new_entry->remote_binddn   = slapi_ch_strdup(config_entry->remote_binddn);

            new_entry->remote_bindpw   = slapi_ch_strdup(config_entry->remote_bindpw);

            new_entry->timeout = config_entry->timeout;

            new_entry->interval = config_entry->interval;

            new_entry->threshold = config_entry->threshold;

            new_entry->nextval = config_entry->nextval;

            new_entry->maxval = config_entry->maxval;

            new_entry->remaining = config_entry->remaining;

            new_entry->extend_in_progress = config_entry->extend_in_progress;

            new_entry->next_range_lower = config_entry->next_range_lower;

            new_entry->next_range_upper = config_entry->next_range_upper;

            new_entry->lock = NULL;

            new_entry->extend_lock = NULL;

 

            if(first){

                PR_INSERT_LINK(&(new_entry->list), copy);

                first = 0;

            } else {

                PR_INSERT_BEFORE(&(new_entry->list), copy);

            }

            config_list = PR_NEXT_LINK(config_list);

        }

    }

 

    return copy;

}

 

void dna_server_read_lock()

{

    slapi_rwlock_rdlock(g_dna_cache_server_lock);

}

 

void dna_server_write_lock()

{

    slapi_rwlock_wrlock(g_dna_cache_server_lock);

}

 

void dna_server_unlock()

{

    slapi_rwlock_unlock(g_dna_cache_server_lock);

}

 

                        "dna_start: global config lock creation failed\n");

        return DNA_FAILURE;

    }

    g_dna_cache_server_lock = slapi_new_rwlock();

    if (!g_dna_cache_server_lock) {

        slapi_log_error(SLAPI_LOG_FATAL, DNA_PLUGIN_SUBSYSTEM,

                        "dna_start: global server lock creation failed\n");

 

    /*

     * Load all shared server configs

     */

    if (dna_load_shared_servers() ) {

        slapi_log_error(SLAPI_LOG_FATAL, DNA_PLUGIN_SUBSYSTEM,

                        "dna_start: shared config server initialization failed.\n");

        return DNA_FAILURE;

    }

 

    dna_delete_config(NULL);

    dna_unlock();

 

    dna_delete_global_servers();

    slapi_destroy_rwlock(g_dna_cache_server_lock);

    g_dna_cache_server_lock = NULL;

 * Free the global linkedl ist of shared servers

 */

static void

dna_delete_global_servers()

{

    struct dnaServer *server, *next;

 

    if(dna_global_servers){

        server = dna_global_servers;

        while(server){

            next = server->next;

            dna_free_shared_server(&server);

            server = next;

        }

        dna_global_servers = NULL;

    }

}

 

/*

 * Look through the global config entries, and build a global

 * shared server config list.

 */

static int

dna_load_shared_servers()

{

    struct configEntry *config_entry = NULL;

    struct dnaServer *server = NULL, *global_servers = NULL;

    PRCList *server_list = NULL;

    PRCList *config_list = NULL;

    int freed_servers = 0;

    int ret = 0;

 

    /* Now build the new list. */

    dna_write_lock();

    if (!PR_CLIST_IS_EMPTY(dna_global_config)) {

        config_list = PR_LIST_HEAD(dna_global_config);

        while (config_list != dna_global_config) {

            PRCList *shared_list = NULL;

            config_entry = (struct configEntry *) config_list;

 

            if(dna_get_shared_servers(config_entry,

                                      &shared_list,

                                      1 /* get all the servers */))

            {

                dna_unlock();

                return -1;

            }

 

            dna_server_write_lock();

            if(!freed_servers){

                dna_delete_global_servers();

                freed_servers = 1;

            }

            if (shared_list) {

                server_list = PR_LIST_HEAD(shared_list);

                while (server_list != shared_list) {

                    server = (struct dnaServer *)server_list;

                    if(global_servers == NULL){

                        dna_global_servers = global_servers = server;

                    } else {

                        global_servers->next = server;

                        global_servers = server;

                    }

                    server_list = PR_NEXT_LINK(server_list);

                }

                slapi_ch_free((void **)&shared_list);

            }

            dna_server_unlock();

 

            config_list = PR_NEXT_LINK(config_list);

        }

    }

    dna_unlock();

 

    return ret;

}

 

/*

    dna_delete_config(NULL);

dna_delete_config(PRCList *list)

    PRCList *list_entry, *delete_list;

    if(list){

        delete_list = list;

    } else {

        delete_list = dna_global_config;

    }

    while (!PR_CLIST_IS_EMPTY(delete_list)) {

        list_entry = PR_LIST_HEAD(delete_list);

        dna_delete_configEntry(list_entry);

    slapi_sdn_free(&s->sdn);

 *

 * Since we need to start a backend transaction, a copy/snapshot of the global

 * config is used, and then freed.

    PRCList *copy = NULL, *list = NULL;

    /* Get the read lock so we can copy the config */

    /* Loop through all config entries and update the shared config entries. */

        /*

         * We need to use a copy of the config because we can not hold

         * the read lock and start a backend transaction.

         */

        copy = dna_config_copy();

        dna_unlock();

        /* Create the pblock.  We'll reuse it for all shared config updates. */

        list = PR_LIST_HEAD(copy);

        while (list != copy) {

 

        dna_delete_config(copy);

        slapi_ch_free((void **)&copy);

    } else {

        dna_unlock();

        dna_get_shared_servers(config_entry, &servers, 0 );

dna_get_shared_servers(struct configEntry *config_entry, PRCList **servers, int get_all)

            /* skip our own shared config entry, unless we want all the servers */

            if (get_all || slapi_sdn_compare(cfg_sdn, slapi_entry_get_sdn(entries[i]))) {

                server->sdn = slapi_sdn_new_dn_byval(slapi_entry_get_ndn(entries[i]));

                     * the remaining number of values, highest

static int

dna_dn_is_shared_config(Slapi_PBlock *pb, char *dn)

{

    struct configEntry *config_entry = NULL;

    Slapi_Entry *entry = NULL;

    Slapi_Attr *attr = NULL;

    PRCList *list = NULL;

    int ret = 0;

 

    dna_read_lock();

    if (!PR_CLIST_IS_EMPTY(dna_global_config)) {

        list = PR_LIST_HEAD(dna_global_config);

        while (list != dna_global_config) {

            config_entry = (struct configEntry *) list;

            if (slapi_dn_issuffix(dn, config_entry->shared_cfg_base)) {

                slapi_pblock_get(pb, SLAPI_ENTRY_POST_OP, &entry);

                /* If the entry has the dnaHost attribute, it is a shared entry */

                if (slapi_entry_attr_find(entry, DNA_HOSTNAME, &attr) == 0) {

                    ret = 1;

                    break;

                }

            }

            list = PR_NEXT_LINK(list);

        }

    }

    dna_unlock();

 

    return ret;

}

 

 * Get a value from the global server list.  The dna_server_read_lock()

 * should be held prior to calling this function.

 */

static int

dna_get_shared_config_attr_val(struct configEntry *config_entry, char *attr, char *value)

{

    struct dnaServer *server = NULL;

    Slapi_DN *server_sdn = NULL;

    int found = 0;

 

    server_sdn = slapi_sdn_new_dn_byref(config_entry->shared_cfg_dn);

    if (dna_global_servers) {

        server = dna_global_servers;

        while (server) {

            if(slapi_sdn_compare(server->sdn, server_sdn) == 0){

                if(strcmp(attr, DNA_REMOTE_BIND_METHOD) == 0){

                    PR_snprintf(value, DNA_REMOTE_BUFSIZ, "%s", server->remote_bind_method);

                    found = 1;

                    break;

                } else if(strcmp(attr, DNA_REMOTE_CONN_PROT) == 0){

                    PR_snprintf(value, DNA_REMOTE_BUFSIZ, "%s", server->remote_conn_prot);

                    found = 1;

                    break;

                }

            }

            server = server->next;

        }

    }

    slapi_sdn_free(&server_sdn);

 

    return found;

}

/*

dna_update_shared_config(struct configEntry *config_entry)

                Slapi_DN *sdn = slapi_sdn_new_normdn_byref(config_entry->shared_cfg_dn);

                char bind_meth[DNA_REMOTE_BUFSIZ];

                char conn_prot[DNA_REMOTE_BUFSIZ];

                /* Grab the remote server settings */

                dna_server_read_lock();

                if(dna_get_shared_config_attr_val(config_entry, DNA_REMOTE_BIND_METHOD, bind_meth)) {

                    slapi_entry_add_string(e, DNA_REMOTE_BIND_METHOD, bind_meth);

                }

                if(dna_get_shared_config_attr_val(config_entry, DNA_REMOTE_CONN_PROT, conn_prot)){

                    slapi_entry_add_string(e, DNA_REMOTE_CONN_PROT,conn_prot);

                }

                dna_server_unlock();

 

            if(dna_dn_is_shared_config(pb, dn) == 0){

                dna_load_shared_servers();

            }