static indigo_error_t
router_ip_delete(void *table_priv, void *entry_priv, of_list_bsn_tlv_t *key)
{
    struct router_ip_entry *entry = entry_priv;
    bighash_remove(router_ip_entries, &entry->hash_entry);
    entry->ip = INVALID_IP;
    return INDIGO_ERROR_NONE;
}
Пример #2
0
int
bighash_entries_move(bighash_table_t *dst, bighash_table_t *src)
{
    bighash_iter_t iter;
    bighash_entry_t *e;
    for(e = bighash_iter_start(src, &iter); e; e = bighash_iter_next(&iter)) {
        bighash_remove(src, e);
        bighash_insert(dst, e, e->hash);
    }
    return 0;
}
static indigo_error_t
router_ip_modify(void *table_priv, void *entry_priv, of_list_bsn_tlv_t *key, of_list_bsn_tlv_t *value)
{
    indigo_error_t rv;
    uint32_t ip;
    struct router_ip_entry *entry = entry_priv;
    of_mac_addr_t mac;

    rv = router_ip_parse_value(value, &ip, &mac);
    if (rv < 0) {
        return rv;
    }
   
    bighash_remove(router_ip_entries, &entry->hash_entry); 
     
    entry->ip = ip;
    entry->mac = mac;

    router_ip_entries_hashtable_insert(router_ip_entries, entry); 
    return INDIGO_ERROR_NONE;
}
Пример #4
0
int main(int argc, char *argv[])
{
    biglist_t *entries = NULL;

    /** Basic Hashing -- statically allocated table */
    bighash_table_init_static(&static_table);
    insert__(&static_table, 10000, &entries);
    test_table_data__(&static_table, &entries);
    bighash_table_destroy(&static_table, NULL);

    /** Basic hashing -- dynamically allocated table */
    {
        bighash_table_t *dtable;
        dtable = bighash_table_create(64);
        insert__(dtable, 10000, &entries);
        test_table_data__(dtable, &entries);
        bighash_table_destroy(dtable, NULL);
    }

    /** Count and removal while iterating */
    {
        bighash_table_t *table;
        bighash_iter_t iter;
        bighash_entry_t *e;
        test_entry_t *te;
        int ecount=100;
        int count = 0;
        table = bighash_table_create(64);
        insert__(table, ecount, NULL);
        if(bighash_entry_count(table) != ecount) {
            AIM_DIE("Entry count mismatch: expected %d, got %d",
                    ecount, bighash_entry_count(table));
        }
        /* Iterate once, just counting */
        for(te = (test_entry_t*)bighash_iter_start(table, &iter);
            te; te = (test_entry_t*)bighash_iter_next(&iter)) {
            count++;
        }
        if(count != ecount) {
            AIM_DIE("Iteration count incorrect (%d)", count);
        }
        /* Iterate again, removing elements. Tests both iteration restart
         * and remove-while-iterating.
         */
        for(e = bighash_iter_start(table, &iter); e; e = bighash_iter_next(&iter)) {
            test_entry_t *te = container_of(e, hash_entry, test_entry_t);
            bighash_remove(table, &te->hash_entry);
            /* Clear the list links on this element to make sure the
             * removal was done properly. */
            memset(te, 0, sizeof(*te));
            aim_free(te);
        }
        if(bighash_entry_count(table) != 0) {
            AIM_DIE("Count is not zero after iterated removal (count=%d)",
                    bighash_entry_count(table));
        }
        bighash_table_destroy(table, NULL);
    }

    /** Migrating between tables */
    {
        bighash_table_t *src;
        bighash_table_t *dst;
        src = bighash_table_create(64);
        dst = bighash_table_create(128);
        insert__(src, 1000, &entries);
        bighash_entries_move(dst, src);
        if(bighash_entry_count(src) != 0) {
            AIM_DIE("Source table is not empty.");
        }
        bighash_table_destroy(src, NULL);
        test_table_data__(dst, &entries);
        bighash_table_destroy(dst, NULL);
    }

    /** Check utilization and automatic element destruction */
    bighash_table_init_static(&static_table);
    insert__(&static_table, 100000, 0);
    bighash_table_utilization_show(&static_table, &aim_pvs_stdout);
    bighash_table_destroy(&static_table, free_test_entry);

    test_template();

    return 0;
}
Пример #5
0
int test_table_data__(bighash_table_t *table, biglist_t** entry_list)
{
    /* Make sure we can find all entries in the entry list */
    {
        biglist_t *ble;
        test_entry_t *te;
        BIGLIST_FOREACH_DATA(ble, *entry_list, test_entry_t*, te) {
            test_entry_t *fe = find_by_id(table, te->id);
            if(fe == NULL) {
                AIM_DIE("inserted entry (id=%d) was not found after filling table",
                        te->id);
            }
            else if(fe != te) {
                AIM_DIE("Retreived pointer does not match. (te=%p (%d), fe=%p (%d)",
                        te, te->id, fe, fe->id);
            }
        }
    }

    /* Make sure all elements in the list are enumerated */
    {
        bighash_iter_t iter;
        bighash_entry_t *e;
        int count = 0;
        for(e = bighash_iter_start(table, &iter); e; e = bighash_iter_next(&iter)) {
            test_entry_t *te = container_of(e, hash_entry, test_entry_t);

            if(te->found) {
                AIM_DIE("Entry %p:%d was already enumerated.", te, te->id);
            }
            te->found++;
            if(biglist_find(*entry_list, te) == NULL) {
                AIM_DIE("Entry %p:%d is not in the entry list.", te, te->id);
            }
            count++;
        }
        if(count != biglist_length(*entry_list)) {
            AIM_DIE("Enumeration error: count=%d, length=%d",
                    count, biglist_length(*entry_list));
        }
    }

    /* Remove from table */
    {
        biglist_t *ble;
        test_entry_t *te;
        int count = 1;
        BIGLIST_FOREACH_DATA(ble, *entry_list, test_entry_t*, te) {
            bighash_remove(table, &te->hash_entry);
            if(find_by_id(table, te->id) != NULL) {
                AIM_DIE("Removed entry was not removed.");
            }
            if(bighash_entry_count(table) != biglist_length(*entry_list)-count) {
                AIM_DIE("Entry count mismatch: hashcount=%d, listcount=%d",
                        bighash_entry_count(table), biglist_length(*entry_list)-count);
            }
            count++;
        }
    }

    /* Free entry list */
    biglist_free_all(*entry_list, aim_free);
    *entry_list = NULL;
    return 0;
}