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 ); }