int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
add_periodic_event_callback( 30, timeout, NULL );
add_periodic_event_callback( 2, ( void ( * )( void * ) ) send_list_switches_request, NULL );
set_list_switches_reply_handler( handle_list_switches_reply );
start_trema();
}
static void
http_transaction_completed( int status, int code, const http_content *content, void *user_data ) {
debug( "A HTTP transaction completed ( status = %d, code = %d, content = %p, user_data = %p ).",
status, code, content, user_data );
assert( user_data != NULL );
transaction_entry *entry = user_data;
entry->n_ongoing_http_requests--;
if ( status == HTTP_TRANSACTION_FAILED ) {
if ( !( ( entry->operation == OPERATION_ATTACH ) && ( code == 440 ) ) && // 440: Specified TEP has already been added.
!( ( entry->operation == OPERATION_DETACH ) && ( code == 404 ) ) ) { // 404: Already deleted.
error( "HTTP transaction failed ( vni = %#x, datapath_id = %#" PRIx64 ", operation = %#x, port_wait_count = %d, "
"n_ongoing_http_requests = %u, n_failed_http_requests = %u, status = %d, code = %d ).",
entry->vni, entry->datapath_id, entry->operation, entry->port_wait_count,
entry->n_ongoing_http_requests, entry->n_failed_http_requests, status, code );
entry->n_failed_http_requests++;
}
}
if ( entry->n_ongoing_http_requests > 0 ) {
return;
}
assert( entry->n_ongoing_http_requests == 0 );
if ( entry->n_failed_http_requests == 0 ) {
if ( entry->callback != NULL ) {
if ( entry->operation == OPERATION_ATTACH ) {
add_periodic_event_callback( 1, wait_for_port_to_be_added, entry );
return;
}
else if ( entry->operation == OPERATION_DETACH ) {
add_periodic_event_callback( 1, wait_for_port_to_be_deleted, entry );
return;
}
}
}
else {
if ( entry->callback != NULL ) {
debug( "Calling a callback function ( calback = %p, user_data = %p ).", entry->callback, entry->user_data );
entry->callback( OVERLAY_NETWORK_OPERATION_FAILED, entry->user_data );
}
}
delete_transaction( entry->datapath_id, entry->vni );
}
static void
confirm_self_dpid_is_registered( const list_element *switches, void *user_data ) {
struct switch_info *sw_info = user_data;
switch_unset_timeout( registration_timeout, sw_info );
debug( "Received switch manager's switch list." );
bool found = false;
for ( const list_element *e = switches; e != NULL; e = e->next ) {
if ( sw_info->datapath_id == *( uint64_t * ) e->data ) {
// self dpid registered
debug( "Self dpid found" );
found = true;
break;
}
}
if ( found ) {
sw_info->state = SWITCH_STATE_COMPLETED;
finalize_openflow_application_interface();
// notify state and datapath_id to controllers
service_send_state( sw_info, &sw_info->datapath_id, MESSENGER_OPENFLOW_READY );
debug( "send ready state" );
add_periodic_event_callback( ECHO_REQUEST_INTERVAL, echo_request_interval, sw_info );
}
else {
debug( "Self dpid not found. Retrying..." );
switch_set_timeout( REGISTRATION_RETRY, registration_retry, sw_info );
}
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
add_periodic_event_callback( 1, send_request, NULL );
add_message_replied_callback( get_trema_name(), recv_reply );
start_trema();
}
static void
management_recv( uint16_t tag, void *data, size_t data_len ) {
UNUSED( data );
UNUSED( data_len );
switch ( tag ) {
case DUMP_XID_TABLE:
dump_xid_table();
break;
case DUMP_COOKIE_TABLE:
dump_cookie_table();
break;
case TOGGLE_COOKIE_AGING:
if ( age_cookie_table_enabled ) {
delete_periodic_event_callback( age_cookie_table );
age_cookie_table_enabled = false;
}
else {
add_periodic_event_callback( COOKIE_TABLE_AGING_INTERVAL, age_cookie_table, NULL );
age_cookie_table_enabled = true;
}
break;
default:
error( "Undefined management message tag ( tag = %#x )", tag );
}
}
int
main( int argc, char *argv[] ) {
// Initialize the Trema world
init_trema( &argc, &argv );
// =============================== Monitoring Manager ===============================
/* Setup a timer to send request for querying port loading */
add_periodic_event_callback( 10, send_my_port_loading_request, NULL );
/* Setup a handler for the reply of query port loading */
add_callback_port_loading_requested( handle_port_loading_reply, NULL );
/* Subscribe the port and flow notification */
add_callback_port_loading_notified( alert_port_loading, NULL );
add_callback_flow_loading_notified( alert_flow_loading, NULL );
init_monitoring();
send_monitoring_subscribe_request();
// =============================== Monitoring Manager ===============================
// Main loop
start_trema();
// Finalize monitoring
finalize_monitoring();
return 0;
}
static void
add_filter( void ) {
struct ofp_match match;
memset( &match, 0, sizeof( struct ofp_match ) );
match.wildcards = OFPFW_DL_SRC | OFPFW_DL_DST;
match.in_port = 1;
match.dl_type = 0x0800;
match.dl_vlan = 0xffff;
match.dl_vlan_pcp = 0;
match.nw_src = 0x0a000001;
match.nw_dst = 0x0a000002;
match.nw_tos = 0;
match.nw_proto = 0x0a;
match.tp_src = 1024;
match.tp_dst = 2048;
static handler_data data;
data.match = match;
snprintf( data.service_name, sizeof( data.service_name ), "dumper" );
data.service_name[ sizeof( data.service_name ) - 1 ] = '\0';
bool ret = add_packetin_filter( data.match, UINT16_MAX, data.service_name, add_filter_completed, &data );
if ( ret == false ) {
error( "Failed to add a packetin filter ( ret = %d ).", ret );
}
else {
add_periodic_event_callback( 5, timeout, &data );
}
}
static void
dump_filter_strict( void ) {
oxm_matches *match = create_oxm_matches();
append_oxm_match_in_port( match, 1 );
append_oxm_match_eth_type( match, 0x0800 );
append_oxm_match_vlan_vid( match, 0, 0 );
append_oxm_match_ipv4_src( match, 0x0a000001, 0 );
append_oxm_match_ipv4_dst( match, 0x0a000002, 0 );
append_oxm_match_ip_dscp( match, 0 );
append_oxm_match_ip_ecn( match, 0 );
append_oxm_match_ip_proto( match, 0x6 );
append_oxm_match_tcp_src( match, 1024 );
append_oxm_match_tcp_dst( match, 2048 );
static handler_data data;
data.match = match;
snprintf( data.service_name, sizeof( data.service_name ), "dumper" );
data.service_name[ sizeof( data.service_name ) - 1 ] = '\0';
data.strict = true;
bool ret = dump_packetin_filter( data.match, OFP_HIGH_PRIORITY, data.service_name, data.strict,
dump_filters, &data );
if ( ret == false ) {
error( "Failed to dump packetin filters ( ret = %d ).", ret );
}
else {
add_periodic_event_callback( 5, timeout, &data );
}
}
static void
test_clock_gettime_fail_einval() {
init_timer();
char user_data[] = "It's time!!!";
will_return_count( mock_clock_gettime, -1, -1 );
assert_false( add_periodic_event_callback( 1, mock_timer_event_callback, user_data ) );
finalize_timer();
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
hash_table *forwarding_db = create_hash( compare_forwarding_entry, hash_forwarding_entry );
add_periodic_event_callback( AGING_INTERVAL, update_forwarding_db, forwarding_db );
set_packet_in_handler( handle_packet_in, forwarding_db );
start_trema();
return 0;
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
init_packetin_filter_interface();
add_periodic_event_callback( 5, timeout, NULL );
add_filter();
start_trema();
finalize_packetin_filter_interface();
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
hash_table *switch_db = create_hash( compare_datapath_id, hash_datapath_id );
add_periodic_event_callback( AGING_INTERVAL, update_all_switches, switch_db );
set_switch_ready_handler( handle_switch_ready, switch_db );
set_switch_disconnected_handler( handle_switch_disconnected, switch_db );
set_packet_in_handler( handle_packet_in, switch_db );
start_trema();
return 0;
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
parse_argument( argc, argv );
init_event_forward_interface();
send_efi_request();
add_periodic_event_callback( 30, timeout, NULL );
start_trema();
finalize_event_forward_interface();
return 0;
}
static void
dump_filter( void ) {
oxm_matches *match = create_oxm_matches();
static handler_data data;
data.match = match;
snprintf( data.service_name, sizeof( data.service_name ), "dumper" );
data.service_name[ sizeof( data.service_name ) - 1 ] = '\0';
data.strict = false;
bool ret = dump_packetin_filter( data.match, UINT16_MAX, data.service_name, data.strict,
dump_filters, &data );
if ( ret == false ) {
error( "Failed to dump packetin filters ( ret = %d ).", ret );
}
else {
add_periodic_event_callback( 5, timeout, &data );
}
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
traffic db;
db.counter = create_counter();
db.fdb = create_fdb();
add_periodic_event_callback( 10, show_counter, &db );
set_packet_in_handler( handle_packet_in, &db );
set_flow_removed_handler( handle_flow_removed, &db );
start_trema();
delete_fdb( db.fdb );
delete_counter( db.counter );
return 0;
}
static void
test_periodic_event_callback() {
init_timer();
char user_data[] = "It's time!!!";
will_return_count( mock_clock_gettime, 0, -1 );
assert_true( add_periodic_event_callback( 1, mock_timer_event_callback, user_data ) );
timer_callback_info *callback = find_timer_callback( mock_timer_event_callback );
assert_true( callback != NULL );
assert_true( callback->function == mock_timer_event_callback );
assert_string_equal( callback->user_data, "It's time!!!" );
assert_int_equal( callback->interval.tv_sec, 1 );
assert_int_equal( callback->interval.tv_nsec, 0 );
delete_timer_event( mock_timer_event_callback, user_data );
assert_true( find_timer_callback( mock_timer_event_callback ) == NULL );
finalize_timer();
}
bool
init_redirector() {
if ( !init_tun( TUN_INTERFACE ) ) {
error( "Cannot create a tun interface." );
return false;
}
if ( host_db != NULL ) {
error( "Host database is already created." );
return false;
}
host_db = create_hash( compare_ip_address, hash_ip_address );
set_fd_handler( fd, read_tun_fd, NULL, NULL, NULL );
set_readable( fd, true );
add_periodic_event_callback( HOST_DB_AGING_INTERVAL, age_host_db, NULL );
return true;
}
static void
delete_filter( void ) {
struct ofp_match match;
memset( &match, 0, sizeof( struct ofp_match ) );
match.wildcards = OFPFW_ALL;
static handler_data data;
data.match = match;
snprintf( data.service_name, sizeof( data.service_name ), "dumper" );
data.service_name[ sizeof( data.service_name ) - 1 ] = '\0';
data.strict = false;
bool ret = delete_packetin_filter( data.match, UINT16_MAX, data.service_name, data.strict,
delete_filter_completed, &data );
if ( ret == false ) {
error( "Failed to delete a packetin filter ( ret = %d ).", ret );
}
else {
add_periodic_event_callback( 5, timeout, &data );
}
}
int
main( int argc, char *argv[] ) {
// Initialize the Trema world
init_trema( &argc, &argv );
// Parse arguments
parse_arguments( argc, argv );
// Set a handler to handle application specific management reply
add_message_replied_callback( get_trema_name(), handle_reply );
// Send an application specific management request
send_application_request();
// Set timeout
add_periodic_event_callback( 5, timeout, NULL );
// Main loop
start_trema();
return EXIT_SUCCESS;
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
show_desc show_desc;
show_desc.db = create_hash( compare_datapath_id, hash_datapath_id );
show_desc.count = 0;
set_list_switches_reply_handler( handle_list_switches_reply );
#ifdef TREMA_EDGE
set_multipart_reply_handler( handle_stats_reply, &show_desc );
#else
set_stats_reply_handler( handle_stats_reply, &show_desc );
set_features_reply_handler( handle_features_reply, &show_desc );
#endif
add_periodic_event_callback( 10, timed_out, NULL );
send_list_switches_request( &show_desc );
start_trema();
return 0;
}
int
switch_event_recv_featuresreply( struct switch_info *sw_info, uint64_t *dpid ) {
int ret;
char new_service_name[ SWITCH_MANAGER_PREFIX_STR_LEN + SWITCH_MANAGER_DPID_STR_LEN + 1 ];
const uint16_t new_service_name_len = SWITCH_MANAGER_PREFIX_STR_LEN + SWITCH_MANAGER_DPID_STR_LEN + 1;
switch ( sw_info->state ) {
case SWITCH_STATE_WAIT_FEATURES_REPLY:
sw_info->datapath_id = *dpid;
sw_info->state = SWITCH_STATE_COMPLETED;
// cancel to features_reply_wait-timeout timer
switch_unset_timeout( switch_event_timeout_features_reply, NULL );
// TODO: set keepalive-timeout
snprintf( new_service_name, new_service_name_len, "%s%#" PRIx64, SWITCH_MANAGER_PREFIX, sw_info->datapath_id );
// checking duplicate service
pid_t pid = get_trema_process_from_name( new_service_name );
if ( pid > 0 ) {
// duplicated
if ( !terminate_trema_process( pid ) ) {
return -1;
}
}
// rename service_name of messenger
rename_message_received_callback( get_trema_name(), new_service_name );
debug( "Rename service name from %s to %s.", get_trema_name(), new_service_name );
if ( messenger_dump_enabled() ) {
stop_messenger_dump();
start_messenger_dump( new_service_name, DEFAULT_DUMP_SERVICE_NAME );
}
set_trema_name( new_service_name );
// notify state and datapath_id
service_send_state( sw_info, &sw_info->datapath_id, MESSENGER_OPENFLOW_READY );
debug( "send ready state" );
ret = ofpmsg_send_setconfig( sw_info );
if ( ret < 0 ) {
return ret;
}
if ( switch_info.flow_cleanup ) {
ret = ofpmsg_send_delete_all_flows( sw_info );
if ( ret < 0 ) {
return ret;
}
}
add_periodic_event_callback( ECHO_REQUEST_INTERVAL, echo_request_interval, sw_info );
break;
case SWITCH_STATE_COMPLETED:
// NOP
break;
default:
notice( "Invalid event 'features reply' from a switch." );
return -1;
break;
}
return 0;
}
void
init_age_fdb( hash_table *fdb ) {
assert( fdb != NULL );
add_periodic_event_callback( FDB_AGING_INTERVAL, age_fdb, fdb );
}
static void
management_recv( const messenger_context_handle *handle, uint32_t command, void *data, size_t data_len, void *user_data ) {
UNUSED( user_data );
switch ( command ) {
case DUMP_XID_TABLE:
{
dump_xid_table();
}
break;
case DUMP_COOKIE_TABLE:
{
if ( !switch_info.cookie_translation ) {
break;
}
dump_cookie_table();
}
break;
case TOGGLE_COOKIE_AGING:
{
if ( !switch_info.cookie_translation ) {
break;
}
if ( age_cookie_table_enabled ) {
delete_timer_event( age_cookie_table, NULL );
age_cookie_table_enabled = false;
}
else {
add_periodic_event_callback( COOKIE_TABLE_AGING_INTERVAL, age_cookie_table, NULL );
age_cookie_table_enabled = true;
}
}
break;
case EVENT_FORWARD_ENTRY_ADD:
case EVENT_FORWARD_ENTRY_DELETE:
case EVENT_FORWARD_ENTRY_DUMP:
case EVENT_FORWARD_ENTRY_SET:
{
event_forward_operation_request *req = data;
req->n_services = ntohl( req->n_services );
management_event_forward_entry_operation( handle, command, req, data_len );
return;
}
break;
default:
{
error( "Undefined management command ( %#x )", command );
management_application_reply *reply = create_management_application_reply( MANAGEMENT_REQUEST_FAILED, command, NULL, 0 );
send_management_application_reply( handle, reply );
xfree( reply );
return;
}
}
management_application_reply *reply = create_management_application_reply( MANAGEMENT_REQUEST_SUCCEEDED, command, NULL, 0 );
send_management_application_reply( handle, reply );
xfree( reply );
}