void delete_hashlist(struct session *ses, struct hashtable *h, const char *pat, const char *msg_ok, const char *msg_none)
{
struct listnode *templist;
if (is_literal(pat))
{
if (delete_hash(h, pat))
{
if (msg_ok)
tintin_printf(ses, msg_ok, pat);
}
else
{
if (msg_none)
tintin_printf(ses, msg_none, pat);
}
return;
}
templist=hash2list(h, pat);
for (struct listnode *ln=templist->next; ln; ln=ln->next)
{
if (msg_ok)
tintin_printf(ses, msg_ok, ln->left);
delete_hash(h, ln->left);
}
if (msg_none && !templist->next)
tintin_printf(ses, msg_none, pat);
zap_list(templist);
}
static void
delete_transaction_db() {
debug( "Deleting transaction database ( db = %p, xid = %p, barrier_xid = %p ).", transaction_db, transaction_db->xid, transaction_db->barrier_xid );
assert( transaction_db != NULL );
assert( transaction_db->xid != NULL );
assert( transaction_db->barrier_xid != NULL );
hash_entry *e;
hash_iterator iter;
init_hash_iterator( transaction_db->xid, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
if ( e->value != NULL ) {
free_transaction_entry( e->value );
}
}
delete_hash( transaction_db->xid );
transaction_db->xid = NULL;
delete_hash( transaction_db->barrier_xid );
transaction_db->barrier_xid = NULL;
xfree( transaction_db );
debug( "Transaction database is deleted ( %p ).", transaction_db );
transaction_db = NULL;
}
bool
finalize_redirector() {
hash_iterator iter;
hash_entry *entry;
host_entry *host_entry;
if ( host_db != NULL ) {
delete_timer_event( age_host_db, NULL );
init_hash_iterator( host_db, &iter );
while ( ( entry = iterate_hash_next( &iter ) ) != NULL ) {
host_entry = entry->value;
if ( host_entry != NULL ) {
delete_host_route( host_entry->ip );
xfree( host_entry );
}
}
delete_hash( host_db );
}
host_db = NULL;
if ( fd >= 0 ) {
set_readable( fd, false );
delete_fd_handler( fd );
}
return finalize_tun();
}
int
destroy_vxlan_instance (struct vxlan_instance * vins)
{
/* error handling */
if (vxlan.vins_num < 1) {
return -1;
}
if (vins == NULL) {
error_warn ("%s: vxlan_instance is NULL!!", __func__);
return -1;
}
/* Stop And Delete */
if (pthread_cancel (vins->tid) != 0)
error_warn ("%s: can not stop vxlan instance %s", vins->vxlan_tap_name);
if (close (vins->tap_sock) < 0)
error_warn ("%s: can not close tap socket %s : %s",
vins->vxlan_tap_name,
strerror (errno));
destroy_fdb (vins->fdb);
/* cleaning struct vxlan values */
vxlan.vins_num--;
delete_hash (&vxlan.vins_tuple, vins->vni);
return 0;
}
static void
finalize_exact_match_table( hash_table *exact_table ) {
assert( exact_table != NULL );
foreach_hash( exact_table, free_exact_match_entry, NULL );
delete_hash( exact_table );
}
static bool
delete_user_from_multicast_group( struct in_addr maddr, unsigned int *n_users ) {
assert( multicast_groups != NULL );
assert( n_users != NULL );
if ( !IN_MULTICAST( ntohl( maddr.s_addr ) ) ) {
return false;
}
lock_multicast_group_table();
unsigned int *in_use = search_hash( &multicast_groups->groups, &maddr );
if ( in_use == NULL ) {
*n_users = 0;
unlock_multicast_group_table();
return false;
}
( *in_use )--;
*n_users = *in_use;
if ( *in_use == 0 ) {
in_use = delete_hash( &multicast_groups->groups, &maddr );
if ( in_use != NULL ) {
free( in_use );
in_use = NULL;
}
}
unlock_multicast_group_table();
return true;
}
void
finalize_dpid_table( void ) {
assert( dpid_table != NULL );
foreach_hash( dpid_table, free_dpid_table_walker, NULL );
delete_hash( dpid_table );
dpid_table = NULL;
}
static void
test_lookup_empty_table_returns_NULL() {
table = create_hash( compare_string, hash_string );
assert_true( lookup_hash_entry( table, alpha ) == NULL );
delete_hash( table );
}
static void delete_bucket(bucket b) {
if(!b)
return;
delete_hash(b -> subnodes);
delete_bucket(b -> next);
free(b -> key);
free(b);
}
static void
test_nonexistent_entry_returns_NULL() {
table = create_hash( compare_string, hash_string );
assert_true( delete_hash_entry( table, "NO SUCH KEY" ) == NULL );
delete_hash( table );
}
static void
test_insert_and_lookup() {
table = create_hash( compare_string, hash_string );
insert_hash_entry( table, alpha, alpha );
assert_string_equal( lookup_hash_entry( table, alpha ), "alpha" );
delete_hash( table );
}
void
delete_datapath_db( hash_table *db ) {
hash_iterator iter;
init_hash_iterator( db, &iter );
hash_entry *hash;
while ( ( hash = iterate_hash_next( &iter ) ) != NULL ) {
free_datapath_entry( hash->value );
}
delete_hash( db );
}
static void
test_insert_and_lookup_by_atom_hash() {
key mykey = { "alpha" };
table = create_hash( compare_atom, hash_atom );
insert_hash_entry( table, &mykey, alpha );
assert_string_equal( lookup_hash_entry( table, &mykey ), "alpha" );
delete_hash( table );
}
static void
test_iterate_empty_hash() {
hash_iterator iter;
table = create_hash( compare_atom, hash_atom );
init_hash_iterator( table, &iter );
while ( iterate_hash_next( &iter ) != NULL ) { UNREACHABLE(); }
delete_hash( table );
}
static void
xfree_all_sw_tx( all_sw_tx *tx ) {
struct event_forward_operation_to_all_request_param *param = tx->request_param;
xfree_event_forward_operation_to_all_request_param( param );
tx->request_param = NULL;
foreach_hash( tx->waiting_dpid, xfree_dpid, NULL );
delete_hash( tx->waiting_dpid );
tx->waiting_dpid = NULL;
xfree( tx );
}
int
fdb_del_entry (struct hash * fdb, u_int8_t * mac)
{
struct fdb_entry * entry;
if ((entry = delete_hash (fdb, mac)) != NULL) {
free (entry);
return 1;
}
return -1;
}
void
delete_fdb( hash_table *fdb ) {
if ( fdb != NULL ) {
hash_iterator iter;
hash_entry *e;
init_hash_iterator( fdb, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
xfree( e->value );
}
delete_hash( fdb );
}
}
void
finalize_xid_table( void ) {
for( int i = 0; i < XID_MAX_ENTRIES; i++ ) {
if ( xid_table.entries[ i ] != NULL ) {
free_xid_entry( xid_table.entries[ i ] );
xid_table.entries[ i ] = NULL;
}
}
delete_hash( xid_table.hash );
xid_table.hash = NULL;
xid_table.next_index = 0;
}
int
uninstall_acl_entry (struct vxlan_instance * vins, struct acl_entry ae)
{
struct acl_entry * e;
if (vins == NULL)
return -1;
if (CHECK_VNI (vins->vni, ae.vni) < 0)
return -1;
e = (struct acl_entry *) malloc (sizeof (struct acl_entry));
memset (e, 0, sizeof (struct acl_entry));
memcpy (e, &ae, sizeof (ae));
switch (e->type) {
case ACL_TYPE_MAC :
delete_hash (&vins->acl_mac, &e->term_mac);
break;
case ACL_TYPE_IP4 :
delete_hash (&vins->acl_ip4, &e->term_ip4);
break;
case ACL_TYPE_IP6 :
delete_hash (&vins->acl_ip6, &e->term_ip6);
break;
case ACL_TYPE_RA :
vins->acl_mask ^= ACL_MASK_RA;
break;
case ACL_TYPE_RS :
vins->acl_mask ^= ACL_MASK_RS;
break;
default :
return -1;
}
return 1;
}
/**
* Delete the global hash_table which stored the stats of parameters.
* @param None
* @return None
*/
static void
delete_stats_table() {
hash_iterator iter;
hash_entry *e;
assert( stats != NULL );
init_hash_iterator( stats, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
void *value = delete_hash_entry( stats, e->key );
xfree( value );
}
delete_hash( stats );
stats = NULL;
}
static void
test_delete_entry() {
table = create_hash( compare_string, hash_string );
insert_hash_entry( table, alpha, alpha );
insert_hash_entry( table, bravo, bravo );
insert_hash_entry( table, charlie, charlie );
delete_hash_entry( table, bravo );
assert_string_equal( lookup_hash_entry( table, alpha ), "alpha" );
assert_true( lookup_hash_entry( table, bravo ) == NULL );
assert_string_equal( lookup_hash_entry( table, charlie ), "charlie" );
delete_hash( table );
}
static void
test_map() {
table = create_hash( compare_string, hash_string );
char key[] = "key";
insert_hash_entry( table, key, alpha );
insert_hash_entry( table, key, bravo );
insert_hash_entry( table, key, charlie );
map_hash( table, key, append_back, NULL );
assert_string_equal( abc0[ 0 ], "charlie" );
assert_string_equal( abc0[ 1 ], "bravo" );
assert_string_equal( abc0[ 2 ], "alpha" );
delete_hash( table );
}
static void
test_insert_twice_overwrites_old_value() {
char *prev;
char key[] = "key";
table = create_hash( compare_string, hash_string );
char old_value[] = "old value";
char new_value[] = "new value";
insert_hash_entry( table, key, old_value );
prev = insert_hash_entry( table, key, new_value );
assert_string_equal( lookup_hash_entry( table, key ), "new value" );
assert_string_equal( prev, "old value" );
delete_hash( table );
}
bool
finalize_event_forward_interface( void ) {
if ( efi_queue_name == NULL ) {
warn( "already finalized." );
return false;
}
delete_message_replied_callback( efi_queue_name, handle_efi_reply );
xfree( efi_queue_name );
efi_queue_name = NULL;
_cleanup_tx_table();
delete_hash( efi_tx_table );
efi_tx_table = NULL;
return true;
}
static void
test_iterator() {
table = create_hash( compare_string, hash_string );
char one[] = "one";
insert_hash_entry( table, one, ( void * ) 1 );
char two[] = "two";
insert_hash_entry( table, two, ( void * ) 2 );
char three[] = "three";
insert_hash_entry( table, three, ( void * ) 3 );
char four[] = "four";
insert_hash_entry( table, four, ( void * ) 4 );
char five[] = "five";
insert_hash_entry( table, five, ( void * ) 5 );
char six[] = "six";
insert_hash_entry( table, six, ( void * ) 6 );
char seven[] = "seven";
insert_hash_entry( table, seven, ( void * ) 7 );
char eight[] = "eight";
insert_hash_entry( table, eight, ( void * ) 8 );
char nine[] = "nine";
insert_hash_entry( table, nine, ( void * ) 9 );
char ten[] = "ten";
insert_hash_entry( table, ten, ( void * ) 10 );
int sum = 0;
hash_iterator iter;
hash_entry *e;
init_hash_iterator( table, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
sum += ( int ) ( uintptr_t ) e->value;
delete_hash_entry( table, e->key );
}
assert_true( sum == 55 );
delete_hash( table );
}
static void
test_foreach() {
table = create_hash( compare_string, hash_string );
insert_hash_entry( table, alpha, alpha );
insert_hash_entry( table, bravo, bravo );
insert_hash_entry( table, charlie, charlie );
delete_hash_entry( table, bravo );
delete_hash_entry( table, charlie );
foreach_hash( table, append_back_foreach, NULL );
assert_string_equal( abc[ 0 ], "alpha" );
assert_true( abc[ 1 ] == NULL );
assert_true( abc[ 2 ] == NULL );
delete_hash( table );
}
bool
finalize_redirector() {
hash_iterator iter;
hash_entry *entry;
init_hash_iterator( host_db, &iter );
while ( ( entry = iterate_hash_next( &iter ) ) != NULL ) {
xfree( entry->value );
}
delete_hash( host_db );
if ( fd >= 0 ) {
set_readable( fd, false );
delete_fd_handler( fd );
}
return finalize_tun();
}
void
print_with_graph_easy_format( void *param, size_t entries, const topology_link_status *s ) {
size_t i;
UNUSED( param );
debug( "topology: entries %d", entries );
hash_table *link_hash = create_hash( compare_link, hash_link );
// show_topology graph-easy | graph-easy
// Graph-Easy:
// http://search.cpan.org/~shlomif/Graph-Easy/bin/graph-easy
printf("#! /usr/bin/env graph-easy\n" );
for ( i = 0; i < entries; i++ ) {
if ( s[ i ].status != TD_LINK_UP ) {
continue;
}
topology_link_status r;
r.from_dpid = s[ i ].to_dpid;
r.from_portno = s[ i ].to_portno;
r.to_dpid = s[ i ].from_dpid;
r.to_portno = s[ i ].from_portno;
topology_link_status *e = lookup_hash_entry( link_hash, &r );
if ( e != NULL ) {
delete_hash_entry( link_hash, e );
print_link_status( e, true );
} else {
insert_hash_entry( link_hash, ( void * ) ( intptr_t ) &s[ i ], ( void *) ( intptr_t ) &s[ i ] );
}
}
hash_iterator iter;
init_hash_iterator( link_hash, &iter );
hash_entry *e;
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
topology_link_status *le = e->value;
print_link_status( le, false );
}
delete_hash( link_hash );
stop_trema();
}
void
finalize_switch_port() {
assert( switch_ports != NULL );
hash_iterator iter;
hash_entry *e;
init_hash_iterator( switch_ports, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
switch_port *port = delete_hash_entry( switch_ports, e->key );
if ( port == NULL ) {
continue;
}
if ( port->device != NULL ) {
delete_ether_device( port->device );
}
xfree( port );
}
delete_hash( switch_ports );
switch_ports = NULL;
}
void
finalize_match_table( void ) {
list_element *list;
pthread_mutex_lock( match_table_head.mutex );
foreach_hash( match_table_head.exact_table, free_match_table_walker, NULL );
delete_hash( match_table_head.exact_table );
match_table_head.exact_table = NULL;
for ( list = match_table_head.wildcard_table; list != NULL; list = list->next ) {
free_match_entry( list->data );
}
delete_list( match_table_head.wildcard_table );
match_table_head.wildcard_table = NULL;
pthread_mutex_unlock( match_table_head.mutex );
pthread_mutex_destroy( match_table_head.mutex );
xfree( match_table_head.mutex );
match_table_head.mutex = NULL;
}
