trema 0.2.2.1 → 0.2.3

data/src/lib/openflow_switch_interface.c

@@ -0,0 +1,1380 @@
+/*
+ * Author: Yasunobu Chiba
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <assert.h>
+#include <inttypes.h>
+#include <arpa/inet.h>
+#include <syslog.h>
+#include "chibach_private.h"
+#include "hash_table.h"
+#include "log.h"
+#include "messenger.h"
+#include "openflow_message.h"
+#include "openflow_service_interface.h"
+#include "openflow_switch_interface.h"
+#include "secure_channel.h"
+#include "timer.h"
+#include "wrapper.h"
+
+
+typedef struct {
+  uint64_t datapath_id;
+  struct {
+    uint32_t ip;
+    uint16_t port;
+  } controller;
+} openflow_switch_config;
+
+typedef bool ( *message_send_handler )( buffer *message, void *user_data );
+
+typedef struct {
+  uint32_t transaction_id;
+  buffer *message;
+  message_send_handler send_callback;
+  void *user_data;
+  time_t created_at;
+} openflow_context;
+
+
+static bool openflow_switch_interface_initialized = false;
+static openflow_event_handlers event_handlers;
+static openflow_switch_config config;
+static const int CONTEXT_LIFETIME = 5;
+static hash_table *contexts = NULL;
+
+
+static bool
+compare_context( const void *x, const void *y ) {
+  const openflow_context *cx = x;
+  const openflow_context *cy = y;
+
+  return ( cx->transaction_id == cy->transaction_id ) ? true : false;
+}
+
+
+static unsigned int
+hash_context( const void *key ) {
+  return ( unsigned int ) *( ( const uint32_t * ) key );
+}
+
+
+static openflow_context *
+lookup_context( uint32_t transaction_id ) {
+  assert( contexts != NULL );
+
+  return lookup_hash_entry( contexts, &transaction_id );
+}
+
+
+static bool
+save_context( uint32_t transaction_id, buffer *message, message_send_handler callback, void *user_data ) {
+  assert( contexts != NULL );
+
+  openflow_context *context = lookup_context( transaction_id );
+  if ( context != NULL ) {
+    return false;
+  }
+
+  context = xmalloc( sizeof( openflow_context ) );
+  memset( context, 0, sizeof( openflow_context ) );
+  context->transaction_id = transaction_id;
+  context->message = duplicate_buffer( message );
+  context->send_callback = callback;
+  context->user_data = user_data;
+  context->created_at = time( NULL );
+
+  insert_hash_entry( contexts, &context->transaction_id, context );
+
+  return true;
+}
+
+
+static void
+delete_context( uint32_t transaction_id ) {
+  assert( contexts != NULL );
+
+  openflow_context *context = delete_hash_entry( contexts, &transaction_id );
+  if ( context == NULL ) {
+    return;
+  }
+
+  if ( context->message != NULL ) {
+    free_buffer( context->message );
+  }
+  if ( context->user_data != NULL ) {
+    xfree( context->user_data );
+  }
+
+  xfree( context );
+}
+
+
+static void
+age_contexts( void *user_data ) {
+  UNUSED( user_data );
+
+  time_t now = time( NULL );
+
+  hash_iterator iter;
+  init_hash_iterator( contexts, &iter );
+  hash_entry *e = NULL;
+  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
+    openflow_context *context = e->value;
+    if ( ( context != NULL ) && ( ( context->created_at + CONTEXT_LIFETIME ) <= now ) ) {
+      delete_context( context->transaction_id );
+    }
+  }
+}
+
+
+static void
+init_context() {
+  assert( contexts == NULL );
+
+  contexts = create_hash_with_size( compare_context, hash_context, 16 );
+}
+
+
+static void
+finalize_context() {
+  assert( contexts != NULL );
+
+  hash_iterator iter;
+  init_hash_iterator( contexts, &iter );
+  hash_entry *e = NULL;
+  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
+    openflow_context *context = e->value;
+    if ( context != NULL ) {
+      delete_context( context->transaction_id );
+    }
+  }
+  delete_hash( contexts );
+  contexts = NULL;
+}
+
+
+bool
+openflow_switch_interface_is_initialized() {
+  return openflow_switch_interface_initialized;
+}
+
+
+bool
+switch_set_openflow_event_handlers( const openflow_event_handlers handlers ) {
+  assert( openflow_switch_interface_initialized );
+
+  memcpy( &event_handlers, &handlers, sizeof( event_handlers ) );
+
+  return true;
+}
+
+
+bool
+set_controller_connected_handler( controller_connected_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a controller connected handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.controller_connected_callback = callback;
+  event_handlers.controller_connected_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_controller_disconnected_handler( controller_disconnected_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a controller disconnected handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.controller_disconnected_callback = callback;
+  event_handlers.controller_disconnected_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_hello_handler( hello_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a hello handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.hello_callback = callback;
+  event_handlers.hello_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+switch_set_error_handler( error_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting an error handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.error_callback = callback;
+  event_handlers.error_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_echo_request_handler( echo_request_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting an echo request handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.echo_request_callback = callback;
+  event_handlers.echo_request_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+switch_set_echo_reply_handler( echo_reply_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting an echo reply handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.echo_reply_callback = callback;
+  event_handlers.echo_reply_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+switch_set_vendor_handler( vendor_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a vendor handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.vendor_callback = callback;
+  event_handlers.vendor_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_features_request_handler( features_request_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a features request handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.features_request_callback = callback;
+  event_handlers.features_request_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_get_config_request_handler( get_config_request_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a get config request handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.get_config_request_callback = callback;
+  event_handlers.get_config_request_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_set_config_handler( set_config_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a set config handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.set_config_callback = callback;
+  event_handlers.set_config_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_packet_out_handler( packet_out_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a packet out handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.packet_out_callback = callback;
+  event_handlers.packet_out_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_flow_mod_handler( flow_mod_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a flow mod handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.flow_mod_callback = callback;
+  event_handlers.flow_mod_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_port_mod_handler( port_mod_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a port mod handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.port_mod_callback = callback;
+  event_handlers.port_mod_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_stats_request_handler( stats_request_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a stats request handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.stats_request_callback = callback;
+  event_handlers.stats_request_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_barrier_request_handler( barrier_request_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a barrier request handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.barrier_request_callback = callback;
+  event_handlers.barrier_request_user_data = user_data;
+
+  return true;
+}
+
+
+bool
+set_queue_get_config_request_handler( queue_get_config_request_handler callback, void *user_data ) {
+  assert( callback != NULL );
+  assert( openflow_switch_interface_initialized );
+
+  debug( "Setting a queue get config request handler ( callback = %p, user_data = %p ).", callback, user_data );
+
+  event_handlers.queue_get_config_request_callback = callback;
+  event_handlers.queue_get_config_request_user_data = user_data;
+
+  return true;
+}
+
+
+static bool
+empty( const buffer *data ) {
+  if ( ( data == NULL ) || ( ( data != NULL ) && ( data->length == 0 ) ) ) {
+    return true;
+  }
+
+  return false;
+}
+
+
+static void
+handle_hello( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_header *hello = data->data;
+
+  uint32_t transaction_id = ntohl( hello->xid );
+  uint8_t version = hello->version;
+
+  debug( "A hello message is received ( transaction_id = %#x, version = %#x ).", transaction_id, version );
+
+  if ( event_handlers.hello_callback == NULL ) {
+    debug( "Callback function for hello events is not set." );
+    return;
+  }
+
+  debug( "Calling hello handler ( callback = %p, user_data = %p ).",
+         event_handlers.hello_callback, event_handlers.hello_user_data );
+
+  event_handlers.hello_callback( transaction_id,
+                                 version,
+                                 event_handlers.hello_user_data );
+}
+
+
+static void
+handle_error( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_error_msg *error_msg = ( struct ofp_error_msg * ) data->data;
+
+  uint32_t transaction_id = ntohl( error_msg->header.xid );
+  uint16_t type = ntohs( error_msg->type );
+  uint16_t code = ntohs( error_msg->code );
+
+  buffer *body = duplicate_buffer( data );
+  remove_front_buffer( body, offsetof( struct ofp_error_msg, data ) );
+
+  debug( "An error message is received ( transaction_id = %#x, type = %u, code = %u, data length = %u ).",
+         transaction_id, type, code, body->length );
+
+  if ( event_handlers.error_callback == NULL ) {
+    debug( "Callback function for error events is not set." );
+    free_buffer( body );
+    return;
+  }
+
+  debug( "Calling error handler ( callback = %p, user_data = %p ).",
+         event_handlers.error_callback, event_handlers.error_user_data );
+
+  event_handlers.error_callback( transaction_id,
+                                 type,
+                                 code,
+                                 body,
+                                 event_handlers.error_user_data );
+
+  free_buffer( body );
+}
+
+
+static void
+handle_echo_request( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_header *header = data->data;
+  uint32_t transaction_id = htonl( header->xid );
+  uint16_t length = htons( header->length );
+
+  debug( "An echo request is received ( transaction_id = %#x, len = %u ).", transaction_id, length );
+
+  if ( event_handlers.echo_request_callback == NULL ) {
+    debug( "Callback function for echo request events is not set." );
+    return;
+  }
+
+  buffer *body = NULL;
+  if ( ( length - sizeof( struct ofp_header ) ) > 0 ) {
+    body = duplicate_buffer( data );
+    remove_front_buffer( body, sizeof( struct ofp_header ) );
+  }
+
+  debug( "Calling echo request handler ( callback = %p, body = %p, user_data = %p ).",
+         event_handlers.echo_request_callback,
+         body,
+         event_handlers.echo_request_user_data );
+
+  event_handlers.echo_request_callback( transaction_id, body, event_handlers.set_config_user_data );
+
+  if ( body != NULL ) {
+    free_buffer( body );
+  }
+}
+
+
+static void
+handle_echo_reply( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_header *header = data->data;
+  uint32_t transaction_id = htonl( header->xid );
+  uint16_t length = htons( header->length );
+
+  debug( "An echo reply is received ( transaction_id = %#x, len = %u ).", transaction_id, length );
+
+  if ( event_handlers.echo_reply_callback == NULL ) {
+    debug( "Callback function for echo reply events is not set." );
+    return;
+  }
+
+  buffer *body = NULL;
+  if ( ( length - sizeof( struct ofp_header ) ) > 0 ) {
+    body = duplicate_buffer( data );
+    remove_front_buffer( body, sizeof( struct ofp_header ) );
+  }
+
+  debug( "Calling echo reply handler ( callback = %p, body = %p, user_data = %p ).",
+         event_handlers.echo_reply_callback,
+         body,
+         event_handlers.echo_reply_user_data );
+
+  event_handlers.echo_reply_callback( transaction_id, body, event_handlers.set_config_user_data );
+
+  if ( body != NULL ) {
+    free_buffer( body );
+  }
+}
+
+
+static void
+handle_vendor( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_vendor_header *vendor_header = ( struct ofp_vendor_header * ) data->data;
+
+  uint32_t transaction_id = ntohl( vendor_header->header.xid );
+  uint32_t vendor = ntohl( vendor_header->vendor );
+
+  uint16_t body_length = ( uint16_t ) ( ntohs( vendor_header->header.length )
+                                        - sizeof( struct ofp_vendor_header ) );
+
+  debug( "A vendor message is received ( transaction_id = %#x, vendor = %#x, body length = %u ).",
+         transaction_id, vendor, body_length );
+
+  if ( event_handlers.vendor_callback == NULL ) {
+    debug( "Callback function for vendor events is not set." );
+    return;
+  }
+
+  buffer *body = NULL;
+  if ( body_length > 0 ) {
+    body = duplicate_buffer( data );
+    remove_front_buffer( body, sizeof( struct ofp_vendor_header ) );
+  }
+
+  debug( "Calling vendor handler ( callback = %p, user_data = %p ).",
+         event_handlers.vendor_callback, event_handlers.vendor_user_data );
+
+  event_handlers.vendor_callback( transaction_id,
+                                  vendor,
+                                  body,
+                                  event_handlers.vendor_user_data );
+
+  if ( body != NULL ) {
+    free_buffer( body );
+  }
+}
+
+
+static void
+handle_features_request( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_header *header = data->data;
+
+  uint32_t transaction_id = ntohl( header->xid );
+
+  debug( "A features request is received ( transaction_id = %#x ).", transaction_id );
+
+  if ( event_handlers.features_request_callback == NULL ) {
+    debug( "Callback function for features request events is not set." );
+    return;
+  }
+
+  debug( "Calling features request handler ( callback = %p, user_data = %p ).",
+         event_handlers.features_request_callback,
+         event_handlers.features_request_user_data );
+
+  event_handlers.features_request_callback( transaction_id,
+                                            event_handlers.features_request_user_data );
+}
+
+
+static void
+handle_get_config_request( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_header *header = data->data;
+
+  uint32_t transaction_id = ntohl( header->xid );
+
+  debug( "A get config request is received ( transaction_id = %#x ).", transaction_id );
+
+  if ( event_handlers.get_config_request_callback == NULL ) {
+    debug( "Callback function for get config request events is not set." );
+    return;
+  }
+
+  debug( "Calling get config request handler ( callback = %p, user_data = %p ).",
+         event_handlers.get_config_request_callback,
+         event_handlers.get_config_request_user_data );
+
+  event_handlers.get_config_request_callback( transaction_id,
+                                              event_handlers.get_config_request_user_data );
+}
+
+
+static void
+handle_set_config( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_switch_config *config = data->data;
+
+  uint32_t transaction_id = ntohl( config->header.xid );
+  uint16_t flags = ntohs( config->flags );
+  uint16_t miss_send_len = ntohs( config->miss_send_len );
+
+  debug( "A set config is received ( transaction_id = %#x, flags = %#x, miss_send_len = %u ).",
+         transaction_id, flags, miss_send_len );
+
+  if ( event_handlers.set_config_callback == NULL ) {
+    debug( "Callback function for set config events is not set." );
+    return;
+  }
+
+  debug( "Calling set config handler ( callback = %p, user_data = %p ).",
+         event_handlers.set_config_callback,
+         event_handlers.set_config_user_data );
+
+  event_handlers.set_config_callback( transaction_id, flags, miss_send_len,
+                                      event_handlers.set_config_user_data );
+}
+
+
+static void
+handle_packet_out( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_packet_out *packet_out = data->data;
+
+  uint32_t transaction_id = ntohl( packet_out->header.xid );
+  uint32_t buffer_id = ntohl( packet_out->buffer_id );
+  uint16_t in_port = ntohs( packet_out->in_port );
+  size_t actions_len = ntohs( packet_out->actions_len );
+  openflow_actions *actions = NULL;
+  if ( actions_len > 0 ) {
+    actions = create_actions();
+    void *actions_p = packet_out->actions;
+    while ( actions_len > 0 ) {
+      struct ofp_action_header *ah = actions_p;
+      ntoh_action( ah, ah );
+      actions_len -= ah->len;
+      actions_p = ( char * ) actions_p + ah->len;
+
+      void *action = xmalloc( ah->len );
+      memcpy( action, ah, ah->len );
+      append_to_tail( &actions->list, ( void * ) action );
+      actions->n_actions++;
+    }
+  }
+
+  buffer *frame = NULL;
+  actions_len = ntohs( packet_out->actions_len );
+  size_t frame_length = ntohs( packet_out->header.length ) - offsetof( struct ofp_packet_out, actions ) - actions_len;
+  if ( frame_length > 0 ) {
+    frame = alloc_buffer_with_length( frame_length );
+    void *p = append_back_buffer( frame, frame_length );
+    size_t offset = offsetof( struct ofp_packet_out, actions ) + actions_len;
+    memcpy( p, ( char * ) packet_out + offset, frame_length );
+  }
+
+  debug( "A packet-out is received ( transaction_id = %#x, buffer_id = %#x, in_port = %u, "
+         "actions_len = %u, frame_length = %u ).",
+         transaction_id, buffer_id, in_port, actions_len, frame_length );
+
+  if ( event_handlers.packet_out_callback == NULL ) {
+    debug( "Callback function for packet-out events is not set." );
+    return;
+  }
+
+  debug( "Calling packet-outhandler ( callback = %p, user_data = %p ).",
+         event_handlers.packet_out_callback,
+         event_handlers.packet_out_user_data );
+
+  event_handlers.packet_out_callback( transaction_id, buffer_id, in_port, actions, frame,
+                                      event_handlers.packet_out_user_data );
+
+  if ( actions != NULL ) {
+    delete_actions( actions );
+  }
+  if ( frame != NULL ) {
+    free_buffer( frame );
+  }
+}
+
+
+static void
+handle_flow_mod( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_flow_mod *flow_mod = data->data;
+
+  uint32_t transaction_id = ntohl( flow_mod->header.xid );
+  struct ofp_match match;
+  ntoh_match( &match, &flow_mod->match );
+  uint64_t cookie = ntohll( flow_mod->cookie );
+  uint16_t command = ntohs( flow_mod->command );
+  uint16_t idle_timeout = ntohs( flow_mod->idle_timeout );
+  uint16_t hard_timeout = ntohs( flow_mod->hard_timeout );
+  uint16_t priority = ntohs( flow_mod->priority );
+  uint32_t buffer_id = ntohl( flow_mod->buffer_id );
+  uint16_t out_port = ntohs( flow_mod->out_port );
+  uint16_t flags = ntohs( flow_mod->flags );
+
+  size_t actions_length = ntohs( flow_mod->header.length ) - offsetof( struct ofp_flow_mod, actions );
+  openflow_actions *actions = NULL;
+  if ( actions_length > 0 ) {
+    actions = create_actions();
+    void *actions_p = flow_mod->actions;
+    while ( actions_length > 0 ) {
+      struct ofp_action_header *ah = actions_p;
+      ntoh_action( ah, ah );
+      actions_length -= ah->len;
+      actions_p = ( char * ) actions_p + ah->len;
+
+      void *action = xmalloc( ah->len );
+      memcpy( action, ah, ah->len );
+      append_to_tail( &actions->list, ( void * ) action );
+      actions->n_actions++;
+    }
+  }
+
+  if ( get_logging_level() >= LOG_DEBUG ) {
+    char match_str[ 256 ];
+    match_to_string( &match, match_str, sizeof( match_str ) );
+    debug( "A flow modification is received ( transaction_id = %#x, match = [%s], cookie = %#" PRIx64 ", "
+           "command = %#x, idle_timeout = %u, hard_timeout = %u, priority = %u, buffer_id = %#x, "
+           "out_port = %u, flags = %#x ).",
+           transaction_id, match_str, cookie, command, idle_timeout, hard_timeout, priority, buffer_id,
+           out_port, flags );
+  }
+
+  if ( event_handlers.flow_mod_callback == NULL ) {
+    debug( "Callback function for flow modification events is not set." );
+    return;
+  }
+
+  debug( "Calling flow modification handler ( callback = %p, user_data = %p ).",
+         event_handlers.flow_mod_callback,
+         event_handlers.flow_mod_user_data );
+
+  event_handlers.flow_mod_callback( transaction_id, match, cookie, command, idle_timeout, hard_timeout,
+                                    priority, buffer_id, out_port, flags, actions,
+                                    event_handlers.flow_mod_user_data );
+
+  if ( actions != NULL ) {
+    delete_actions( actions );
+  }
+}
+
+
+static void
+handle_port_mod( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_port_mod *port_mod = data->data;
+
+  uint32_t transaction_id = ntohl( port_mod->header.xid );
+  uint16_t port_no = ntohs( port_mod->port_no );
+  uint8_t hw_addr[ OFP_ETH_ALEN ];
+  memcpy( hw_addr, port_mod->hw_addr, OFP_ETH_ALEN );
+  uint32_t config = ntohl( port_mod->config );
+  uint32_t mask = ntohl( port_mod->mask );
+  uint32_t advertise = ntohl( port_mod->advertise );
+
+  debug( "A port modification is received ( transaction_id = %#x, port_no = %u, "
+         "hw_addr = %02x:%02x:%02x:%02x:%02x:%02x, config = %#x, mask = %#x, advertise = %#x ).",
+         transaction_id, port_no,
+         hw_addr[ 0 ], hw_addr[ 1 ], hw_addr[ 2 ], hw_addr[ 3 ], hw_addr[ 4 ], hw_addr[ 5 ],
+         config, mask, advertise );
+
+  if ( event_handlers.port_mod_callback == NULL ) {
+    debug( "Callback function for port modification events is not set." );
+    return;
+  }
+
+  debug( "Calling port modification handler ( callback = %p, user_data = %p ).",
+         event_handlers.port_mod_callback,
+         event_handlers.port_mod_user_data );
+
+  event_handlers.port_mod_callback( transaction_id, port_no, hw_addr, config, mask, advertise,
+                                    event_handlers.barrier_request_user_data );
+
+}
+
+
+static void
+handle_stats_request( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_stats_request *stats_request = data->data;
+
+  uint32_t transaction_id = ntohl( stats_request->header.xid );
+  uint16_t type = ntohs( stats_request->type );
+  uint16_t flags = ntohs( stats_request->flags );
+
+  size_t body_length = ntohs( stats_request->header.length ) - offsetof( struct ofp_stats_request, body );
+  buffer *body = NULL;
+  if ( body_length > 0 ) {
+    body = alloc_buffer_with_length( body_length );
+    void *p = append_back_buffer( body, body_length );
+    memcpy( p, stats_request->body, body_length );
+
+    switch ( type ) {
+    case OFPST_FLOW:
+    {
+      struct ofp_flow_stats_request *flow = p;
+      ntoh_match( &flow->match, &flow->match );
+      flow->out_port = ntohs( flow->out_port );
+    }
+    break;
+
+    case OFPST_AGGREGATE:
+    {
+      struct ofp_aggregate_stats_request *aggregate = p;
+      ntoh_match( &aggregate->match, &aggregate->match );
+      aggregate->out_port = ntohs( aggregate->out_port );      
+    }
+    break;
+
+    case OFPST_PORT:
+    {
+      struct ofp_port_stats_request *port = p;
+      port->port_no = ntohs( port->port_no );
+    }
+    break;
+
+    case OFPST_VENDOR:
+    {
+      uint32_t *vendor_id = p;
+      *vendor_id = ntohl( *vendor_id );
+    }
+    break;
+
+    default:
+    break;
+    }
+  }
+
+  debug( "A stats request is received ( transaction_id = %#x, type = %#x, flags = %#x ).",
+         transaction_id, type, flags );
+
+  if ( event_handlers.stats_request_callback == NULL ) {
+    debug( "Callback function for stats request events is not set." );
+    return;
+  }
+
+  debug( "Calling stats request handler ( callback = %p, user_data = %p ).",
+         event_handlers.stats_request_callback,
+         event_handlers.stats_request_user_data );
+
+  event_handlers.stats_request_callback( transaction_id, type, flags, body,
+                                         event_handlers.stats_request_user_data );
+
+  if ( body_length > 0 && body != NULL ) {
+    free_buffer( body );
+  }
+}
+
+
+static void
+handle_barrier_request( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_header *header = data->data;
+
+  uint32_t transaction_id = ntohl( header->xid );
+
+  debug( "A barrier request is received ( transaction_id = %#x ).", transaction_id );
+
+  if ( event_handlers.barrier_request_callback == NULL ) {
+    debug( "Callback function for barrier request events is not set." );
+    return;
+  }
+
+  debug( "Calling barrier request handler ( callback = %p, user_data = %p ).",
+         event_handlers.barrier_request_callback,
+         event_handlers.barrier_request_user_data );
+
+  event_handlers.barrier_request_callback( transaction_id,
+                                           event_handlers.barrier_request_user_data );
+}
+
+
+static void
+handle_queue_get_config_request( buffer *data ) {
+  assert( empty( data ) == false );
+
+  struct ofp_queue_get_config_request *queue_get_config_request = data->data;
+
+  uint32_t transaction_id = ntohl( queue_get_config_request->header.xid );
+  uint16_t port = ntohs( queue_get_config_request->port );
+
+  debug( "A queue get config request is received ( transaction_id = %#x, port = %u ).",
+         transaction_id, port );
+
+  if ( event_handlers.queue_get_config_request_callback == NULL ) {
+    debug( "Callback function for queue get config request events is not set." );
+    return;
+  }
+
+  debug( "Calling queue get config request handler ( callback = %p, user_data = %p ).",
+         event_handlers.queue_get_config_request_callback,
+         event_handlers.queue_get_config_request_user_data );
+
+  event_handlers.queue_get_config_request_callback( transaction_id, port,
+                                                    event_handlers.queue_get_config_request_user_data );
+}
+
+
+static void
+handle_controller_connected() {
+  if ( event_handlers.controller_connected_callback == NULL ) {
+    debug( "Callback function for controller connected events is not set." );
+    return;
+  }
+
+  event_handlers.controller_connected_callback( event_handlers.controller_connected_user_data );
+}
+
+
+static void
+handle_controller_disconnected() {
+  if ( event_handlers.controller_disconnected_callback == NULL ) {
+    debug( "Callback function for controller disconnected events is not set." );
+    return;
+  }
+
+  event_handlers.controller_disconnected_callback( event_handlers.controller_disconnected_user_data );
+}
+
+
+static bool
+handle_openflow_message( buffer *message ) {
+  debug( "An OpenFlow message is received from remote." );
+
+  assert( message != NULL );
+  assert( message->length >= sizeof( struct ofp_header ) );
+
+  int ret = validate_openflow_message( message );
+  if ( ret < 0 ) {
+    error( "Failed to validate an OpenFlow message ( code = %d, length = %u ).", ret, message->length );
+    return false;
+  }
+
+  ret = true;
+  struct ofp_header *header = ( struct ofp_header * ) message->data;
+
+  switch ( header->type ) {
+  case OFPT_HELLO:
+    handle_hello( message );
+    break;
+  case OFPT_ERROR:
+    handle_error( message );
+    break;
+  case OFPT_ECHO_REQUEST:
+    handle_echo_request( message );
+    break;
+  case OFPT_ECHO_REPLY:
+    handle_echo_reply( message );
+    break;
+  case OFPT_VENDOR:
+    handle_vendor( message);
+    break;
+  case OFPT_FEATURES_REQUEST:
+    handle_features_request( message );
+    break;
+  case OFPT_GET_CONFIG_REQUEST:
+    handle_get_config_request( message );
+    break;
+  case OFPT_SET_CONFIG:
+    handle_set_config( message );
+    break;
+  case OFPT_PACKET_OUT:
+    handle_packet_out( message );
+    break;
+  case OFPT_FLOW_MOD:
+    handle_flow_mod( message );
+    break;
+  case OFPT_PORT_MOD:
+    handle_port_mod( message );
+    break;
+  case OFPT_STATS_REQUEST:
+    handle_stats_request( message );
+    break;
+  case OFPT_BARRIER_REQUEST:
+    handle_barrier_request( message );
+    break;
+  case OFPT_QUEUE_GET_CONFIG_REQUEST:
+    handle_queue_get_config_request( message );
+    break;
+  default:
+    error( "Unhandled OpenFlow message ( type = %u ).", header->type );
+    ret = false;
+    break;
+  }
+
+  return ret;
+}
+
+
+static bool
+send_openflow_message_to_secure_channel( buffer *message, void *user_data ) {
+  assert( user_data == NULL );
+
+  return send_message_to_secure_channel( message );
+}
+
+
+static bool
+send_openflow_message_to_local( buffer *message, void *user_data ) {
+  char *service_name = user_data;
+  size_t service_name_length = strlen( service_name ) + 1;
+  size_t service_header_length = sizeof( openflow_service_header_t ) + service_name_length;
+  openflow_service_header_t *service_header = append_front_buffer( message, service_header_length );
+  service_header->service_name_length = htons( ( uint16_t ) service_name_length );
+  memcpy( ( char * ) service_header + sizeof( openflow_service_header_t ), service_name, service_name_length );
+
+  return send_message( service_name, MESSENGER_OPENFLOW_MESSAGE, message->data, message->length );
+}
+
+
+bool
+switch_send_openflow_message( buffer *message ) {
+  assert( message != NULL );
+  assert( message->length >= sizeof( struct ofp_header ) );
+
+  struct ofp_header *header = message->data;
+  uint32_t transaction_id = ntohl( header->xid );
+  openflow_context *context = lookup_context( transaction_id );
+  if ( context != NULL ) {
+    assert( context->send_callback != NULL );
+    return context->send_callback( message, context->user_data );
+  }
+
+  return send_openflow_message_to_secure_channel( message, NULL );
+}
+
+
+bool
+handle_secure_channel_message( buffer *message ) {
+  debug( "An OpenFlow message is received from remove." );
+
+  assert( message != NULL );
+  assert( message->length >= sizeof( struct ofp_header ) );
+
+  struct ofp_header *header = message->data;
+
+  save_context( ntohl( header->xid ), message, send_openflow_message_to_secure_channel, NULL );
+
+  return handle_openflow_message( message );
+}
+
+
+static void
+handle_local_message( uint16_t tag, void *data, size_t length ) {
+  assert( data != NULL );
+  assert( length >= sizeof( openflow_service_header_t ) );
+
+  debug( "A message is received from remote ( tag = %u, data = %p, length = %u ).", tag, data, length );
+
+  switch ( tag ) {
+  case MESSENGER_OPENFLOW_MESSAGE:
+  {
+    openflow_service_header_t *header = data;
+    uint16_t service_name_length = ntohs( header->service_name_length );
+    size_t ofp_offset = sizeof( openflow_service_header_t ) + service_name_length;
+    size_t ofp_length = length - ofp_offset;
+    buffer *message = alloc_buffer_with_length( ofp_length );
+    char *p = append_back_buffer( message, ofp_length );
+    memcpy( p, ( char * ) data + ofp_offset, ofp_length );
+    char *service_name = strndup( ( char * ) data + sizeof( openflow_service_header_t ), service_name_length );
+
+    save_context( ntohl( ( ( struct ofp_header * ) p )->xid ), message, send_openflow_message_to_local,
+                  service_name );
+
+    handle_openflow_message( message );
+  }
+  break;
+  default:
+    break;
+  }
+}
+
+
+bool
+init_openflow_switch_interface( const uint64_t datapath_id, uint32_t controller_ip, uint16_t controller_port ) {
+  debug( "Initializing OpenFlow Switch Interface ( datapath_id = %#" PRIx64 ", controller_ip = %#x, controller_port = %u ).",
+         datapath_id, controller_ip, controller_port );
+
+  if ( openflow_switch_interface_is_initialized() ) {
+    error( "OpenFlow Switch Interface is already initialized." );
+    return false;
+  }
+
+  bool ret = init_secure_channel( controller_ip, controller_port,
+                                  handle_controller_connected, handle_controller_disconnected );
+  if ( ret == false ) {
+    error( "Failed to initialize a secure chanel." );
+    return false;
+  }
+
+
+  memset( &event_handlers, 0, sizeof( openflow_event_handlers ) );
+  memset( &config, 0, sizeof( openflow_switch_config ) );
+
+  config.datapath_id = datapath_id;
+  config.controller.ip = controller_ip;
+  config.controller.port = controller_port;
+
+  init_context();
+
+  add_periodic_event_callback( 5, age_contexts, NULL );
+  add_message_received_callback( get_chibach_name(), handle_local_message );
+
+  openflow_switch_interface_initialized = true;
+
+  return true;
+}
+
+
+bool
+finalize_openflow_switch_interface() {
+  if ( !openflow_switch_interface_is_initialized() ) {
+    error( "OpenFlow Switch Interface is not initialized." );
+    return false;
+  }
+
+  finalize_secure_channel();
+
+  delete_timer_event( age_contexts, NULL );
+  finalize_context();
+
+  openflow_switch_interface_initialized = false;
+
+  return true;
+}
+
+
+static const buffer *
+get_openflow_message( uint32_t transaction_id ) {
+  openflow_context *context = lookup_context( transaction_id );
+  if ( context == NULL ) {
+    return NULL;
+  }
+
+  return context->message;
+}
+
+
+bool
+send_error_message( uint32_t transaction_id, uint16_t type, uint16_t code ) {
+  buffer *data = NULL;
+  switch ( type ) {
+  case OFPET_HELLO_FAILED:
+  {
+    switch ( code ) {
+    case OFPHFC_INCOMPATIBLE:
+    {
+      const char *description = "Incompatible OpenFlow version.";
+      size_t length = strlen( description ) + 1;
+      data = alloc_buffer_with_length ( length );
+      void *p = append_back_buffer( data, length );
+      strncpy( p, description, length );
+    }
+    break;
+    case OFPHFC_EPERM:
+    {
+      const char *description = "Permissions error.";
+      size_t length = strlen( description ) + 1;
+      data = alloc_buffer_with_length ( length );
+      void *p = append_back_buffer( data, length );
+      strncpy( p, description, length );
+    }
+    break;
+    default:
+      error( "Undefined error code ( type = %#x, code = %#x ).", type, code );
+      return false;
+    }
+  }
+  break;
+
+  case OFPET_BAD_REQUEST:
+  {
+    switch ( code ) {
+    case OFPBRC_BAD_VERSION:
+    case OFPBRC_BAD_TYPE:
+    case OFPBRC_BAD_STAT:
+    case OFPBRC_BAD_VENDOR:
+    case OFPBRC_BAD_SUBTYPE:
+    case OFPBRC_EPERM:
+    case OFPBRC_BAD_LEN:
+    case OFPBRC_BUFFER_EMPTY:
+    case OFPBRC_BUFFER_UNKNOWN:
+    {
+      const buffer *original_message = get_openflow_message( transaction_id );
+      if ( original_message != NULL ) {
+        data = duplicate_buffer( original_message );
+        if ( data->length > 64 ) {
+          data->length = 64;
+        }
+      }
+    }
+    break;
+    default:
+      error( "Undefined error code ( type = %#x, code = %#x ).", type, code );
+      return false;
+    }
+  }
+  break;
+
+  case OFPET_BAD_ACTION:
+  {
+    switch ( code ) {
+    case OFPBAC_BAD_TYPE:
+    case OFPBAC_BAD_LEN:
+    case OFPBAC_BAD_VENDOR:
+    case OFPBAC_BAD_VENDOR_TYPE:
+    case OFPBAC_BAD_OUT_PORT:
+    case OFPBAC_BAD_ARGUMENT:
+    case OFPBAC_EPERM:
+    case OFPBAC_TOO_MANY:
+    case OFPBAC_BAD_QUEUE:   
+    {
+      const buffer *original_message = get_openflow_message( transaction_id );
+      if ( original_message != NULL ) {
+        data = duplicate_buffer( original_message );
+        if ( data->length > 64 ) {
+          data->length = 64;
+        }
+      }
+    }
+    break;
+    default:
+      error( "Undefined error code ( type = %#x, code = %#x ).", type, code );
+      return false;
+    }
+
+  }
+  break;
+
+  case OFPET_FLOW_MOD_FAILED:
+  {
+    switch ( code ) {
+    case OFPFMFC_ALL_TABLES_FULL:
+    case OFPFMFC_OVERLAP:
+    case OFPFMFC_EPERM:
+    case OFPFMFC_BAD_EMERG_TIMEOUT:
+    case OFPFMFC_BAD_COMMAND:
+    case OFPFMFC_UNSUPPORTED:
+    {
+      const buffer *original_message = get_openflow_message( transaction_id );
+      if ( original_message != NULL ) {
+        data = duplicate_buffer( original_message );
+        if ( data->length > 64 ) {
+          data->length = 64;
+        }
+      }
+    }
+    break;
+    default:
+      error( "Undefined error code ( type = %#x, code = %#x ).", type, code );
+      return false;
+    }
+  }
+  break;
+
+  case OFPET_PORT_MOD_FAILED:
+  {
+    switch ( code ) {
+    case OFPPMFC_BAD_PORT:
+    case OFPPMFC_BAD_HW_ADDR:
+    {
+      const buffer *original_message = get_openflow_message( transaction_id );
+      if ( original_message != NULL ) {
+        data = duplicate_buffer( original_message );
+        if ( data->length > 64 ) {
+          data->length = 64;
+        }
+      }
+    }
+    break;
+    default:
+      error( "Undefined error code ( type = %#x, code = %#x ).", type, code );
+      return false;
+    }
+  }
+  break;
+
+  case OFPET_QUEUE_OP_FAILED:
+  {
+    switch ( code ) {
+    case OFPQOFC_BAD_PORT:
+    case OFPQOFC_BAD_QUEUE:
+    case OFPQOFC_EPERM:
+    {
+      const buffer *original_message = get_openflow_message( transaction_id );
+      if ( original_message != NULL ) {
+        data = duplicate_buffer( original_message );
+        if ( data->length > 64 ) {
+          data->length = 64;
+        }
+      }
+    }
+    break;
+    default:
+      error( "Undefined error code ( type = %#x, code = %#x ).", type, code );
+      return false;
+    }
+  }
+  break;
+
+  default:
+    error( "Undefined error type ( type = %#x, code = %#x ).", type, code );
+    return false;
+  }
+
+  buffer *err = create_error( transaction_id, type, code, data );
+  bool ret = switch_send_openflow_message( err );
+  if ( !ret ) {
+    error( "Failed to send an error message ( transaction_id = %#x, type = %#x, code = %#x ).",
+           transaction_id, type, code );
+  }
+
+  free_buffer( err );
+  if ( data != NULL ) {
+    free_buffer( data );
+  }
+
+  return ret;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */