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();
}
/**
* Dump the statistics onto screen (or stream specified by info function).
* @param None
* @return None
*/
void
dump_stats() {
assert( stats != NULL );
int n_stats = 0;
hash_iterator iter;
hash_entry *e;
pthread_mutex_lock( &stats_table_mutex );
info( "Statistics:" );
init_hash_iterator( stats, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
stat_entry *st = e->value;
info( "%s: %" PRIu64, st->key, st->value );
n_stats++;
}
if ( n_stats == 0 ) {
info( "No statistics found." );
}
pthread_mutex_unlock( &stats_table_mutex );
}
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 );
}
void
foreach_datapath_db( hash_table *db, void function( void *user_data ) ) {
hash_iterator iter;
init_hash_iterator( db, &iter );
hash_entry *hash;
while ( ( hash = iterate_hash_next( &iter ) ) != NULL ) {
datapath_entry *entry = hash->value;
function( entry->user_data );
}
}
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 );
}
void
dump_xid_table( void ) {
hash_iterator iter;
hash_entry *e;
info( "#### XID TABLE ####" );
init_hash_iterator( xid_table.hash, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
dump_xid_entry( e->value );
}
info( "#### END ####" );
}
void
foreach_switch_port( switch_port_walker callback, void *user_data ) {
hash_iterator iter;
hash_entry *e;
init_hash_iterator( switch_ports, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
if ( e->value != NULL ) {
callback( e->value, user_data );
}
}
}
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
_cleanup_tx_table() {
hash_iterator it;
init_hash_iterator( efi_tx_table, &it );
hash_entry *e = NULL;
while ( ( e = iterate_hash_next( &it ) ) != NULL ) {
all_sw_tx *tx = e->value;
warn( "txid:%#x was left behind.", tx->txid );
delete_hash_entry( efi_tx_table, &tx->txid );
xfree_all_sw_tx( tx );
}
}
/**
* 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;
}
/*_________________---------------------------__________________
_________________ mongoose callback __________________
-----------------___________________________------------------
*/
static int *mongoose_callback( struct mg_connection *conn )
{
const struct mg_request_info *request_info = mg_get_request_info(conn);
char *ret_strings = "";
/* Iterate all the url_mapping data */
hash_iterator iter;
hash_entry *e;
int reti;
init_hash_iterator( url_mapping_db.url_mapping, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
url_mapping *url_mapping_data = ( url_mapping * ) e->value;
/* Compare the string with regex */
reti = regexec( &url_mapping_data->regex, request_info->uri , 0, NULL, 0 );
if( !reti ){
/* Match the URI */
if( strcmp( request_info->request_method ,
url_mapping_data->method ) == 0 ) {
/* Match the REST API */
ret_strings = ( *url_mapping_data->restapi_requested_callback )( request_info, NULL );
}
else {
info( "REST API not found \n" );
}
}
}
/* Uncomment these and will see additional port number info from mongoose */
//int ret_length = strlen( ret_strings );
//char content[ ret_length + 1024 ];
//int content_length = snprintf(content, sizeof(content),
// "Hello from mongoose! Remote port: %d, content:%s\n",
// request_info->remote_port, ret_strings );
mg_printf(conn,
"HTTP/1.1 200 OK\r\n"
"Content-Type: text/plain\r\n"
"Content-Length: %d\r\n" // Always set Content-Length
"\r\n"
"%s",
strlen(ret_strings), ret_strings);
return 1;
}
buffer *
get_switches( void ) {
assert( dpid_table != NULL );
buffer *buf = alloc_buffer_with_length( sizeof( uint64_t ) );
hash_iterator iter;
hash_entry *entry;
init_hash_iterator( dpid_table, &iter );
while ( ( entry = iterate_hash_next( &iter ) ) != NULL ) {
uint64_t *dpid = append_back_buffer( buf, sizeof( uint64_t ) );
*dpid = htonll( *( uint64_t * )( entry->value ) );
}
return buf;
}
static void
test_reset_stats_succeeds_without_entries() {
assert_true( init_stat() );
reset_stats();
hash_iterator iter;
hash_entry *e = NULL;
init_hash_iterator( stats, &iter );
int n_entries = 0;
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
n_entries++;
}
assert_int_equal( n_entries, 0 );
assert_true( finalize_stat() );
}
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 );
}
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();
}
static void
test_reset_stats_succeeds_with_single_entry() {
assert_true( init_stat() );
const char *key = "key";
increment_stat( key );
reset_stats();
hash_iterator iter;
hash_entry *e = NULL;
init_hash_iterator( stats, &iter );
int n_entries = 0;
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
n_entries++;
}
assert_int_equal( n_entries, 0 );
assert_true( finalize_stat() );
}
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;
}
static void
delete_http_transaction_db() {
debug( "Deleting HTTP transaction database ( %p ).", transactions );
assert( transactions != NULL );
hash_entry *e = NULL;
hash_iterator iter;
init_hash_iterator( transactions, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
if ( e->value != NULL ) {
free_http_transaction( e->value );
e->value = NULL;
}
}
delete_hash( transactions );
debug( "HTTP transaction database is deleted ( %p ).", transactions );
transactions = NULL;
}
void
delete_fdb_entries( hash_table *fdb, uint64_t dpid, uint16_t port ) {
if ( fdb == NULL ) {
return;
}
debug( "Deleting fdb entries ( dpid = %#" PRIx64 ", port = %u ).", dpid, port );
fdb_entry *entry = NULL;
hash_iterator iter;
hash_entry *e;
init_hash_iterator( fdb, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
if ( e->value == NULL ) {
continue;
}
entry = e->value;
if ( entry->dpid == dpid && entry->port == port ) {
delete_hash_entry( fdb, entry->mac );
xfree( entry );
}
}
}
static void
test_multiple_inserts_and_deletes_then_iterate() {
table = create_hash( compare_string, hash_string );
char one[] = "one";
insert_hash_entry( table, one, ( void * ) 1 );
delete_hash_entry( table, one );
insert_hash_entry( table, one, ( void * ) 1 );
delete_hash_entry( table, one );
insert_hash_entry( table, one, ( void * ) 1 );
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 == 1 );
delete_hash( table );
}
static bool
delete_transaction_db() {
debug( "Deleting transaction database for overlay network manager ( %p ).", transactions );
assert( transactions != NULL );
hash_entry *e = NULL;
hash_iterator iter;
init_hash_iterator( transactions, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
if ( e->value != NULL ) {
xfree( e->value );
e->value = NULL;
}
}
delete_hash( transactions );
debug( "Transaction database is deleted ( %p ).", transactions );
transactions = NULL;
return true;
}
static void
age_transaction_entries( void *user_data ) {
UNUSED( user_data );
debug( "Aging transaction entries ( %p ).", transaction_db );
assert( transaction_db != NULL );
assert( transaction_db->xid != NULL );
struct timespec now;
bool ret = get_monotonic_time( &now );
if ( !ret ) {
return;
}
hash_entry *e;
hash_iterator iter;
init_hash_iterator( transaction_db->xid, &iter );
while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
transaction_entry *entry = e->value;
if( entry == NULL ) {
continue;
}
debug( "Checking an entry ( %p ).", entry );
dump_transaction_entry( debug, entry );
if ( TIMESPEC_LESS_THAN( &entry->expires_at, &now ) ) {
struct ofp_header *header = entry->message->data;
header->xid = htonl( entry->original_xid );
if ( entry->completed ) {
if ( !entry->error_received && entry->succeeded_callback != NULL ) {
debug( "Calling succeeded callback ( %p ).", entry->succeeded_callback );
entry->succeeded_callback( entry->datapath_id, entry->message, entry->succeeded_user_data );
}
else if ( entry->error_received && entry->failed_callback != NULL ) {
debug( "Calling failed callback ( %p ).", entry->failed_callback );
entry->failed_callback( entry->datapath_id, entry->message, entry->failed_user_data );
}
}
else {
if ( !entry->timeout ) {
debug( "Transaction timeout. Wait for final marin to elapse." );
// Wait for a moment after deleting all messages in send queue
delete_openflow_messages( entry->datapath_id );
entry->expires_at = now;
ADD_TIMESPEC( &entry->expires_at, &TRANSACTION_END_MARGIN, &entry->expires_at );
entry->timeout = true;
continue;
}
else {
warn( "Transaction timeout ( xid = %#x, barrier_xid = %#x, original_xid = %#x, expires_at = %d.%09d ).",
entry->xid, entry->barrier_xid, entry->original_xid,
( int ) entry->expires_at.tv_sec, ( int ) entry->expires_at.tv_nsec );
if ( entry->failed_callback != NULL ) {
entry->failed_callback( entry->datapath_id, entry->message, entry->failed_user_data );
}
}
}
delete_transaction_entry_by_xid( entry->xid );
free_transaction_entry( entry );
}
}
debug( "Aging completed ( %p ).", transaction_db );
}
static bool
hash_table_is_empty( hash_table *tbl ) {
hash_iterator it;
init_hash_iterator( tbl, &it );
return ( iterate_hash_next( &it ) == NULL );
}
