trema 0.4.7 → 0.4.8

data/src/lib/openflow_message.h

@@ -1,291 +0,0 @@
-/*
- * An OpenFlow message library.
- *
- * Copyright (C) 2008-2013 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.
- */
-
-
-#ifndef OPENFLOW_MESSAGE_H
-#define OPENFLOW_MESSAGE_H
-
-
-#include <openflow.h>
-#include "bool.h"
-#include "buffer.h"
-#include "byteorder.h"
-#include "linked_list.h"
-#include "packet_info.h"
-
-
-// A structure for storing OpenFlow actions
-typedef struct openflow_actions {
-  int n_actions;
-  list_element *list;
-} openflow_actions;
-
-
-// Initialization
-bool init_openflow_message( void );
-
-// Functions for creating OpenFlow messages
-buffer *create_hello( const uint32_t transaction_id );
-buffer *create_error( const uint32_t transaction_id, const uint16_t type,
-                      const uint16_t code, const buffer *data );
-buffer *create_echo_request( const uint32_t transaction_id, const buffer *body );
-buffer *create_echo_reply( const uint32_t transaction_id, const buffer *body );
-buffer *create_vendor( const uint32_t transaction_id, const uint32_t vendor,
-                       const buffer *body );
-buffer *create_features_request( const uint32_t transaction_id );
-buffer *create_features_reply( const uint32_t transaction_id, const uint64_t datapath_id,
-                               const uint32_t n_buffers, const uint8_t n_tables,
-                               const uint32_t capabilities, const uint32_t actions,
-                               const list_element *ports );
-buffer *create_get_config_request( const uint32_t transaction_id );
-buffer *create_get_config_reply( const uint32_t transaction_id, const uint16_t flags,
-                                 const uint16_t miss_send_len );
-buffer *create_set_config( const uint32_t transaction_id, const uint16_t flags,
-                           const uint16_t miss_send_len );
-buffer *create_packet_in( const uint32_t transaction_id, const uint32_t buffer_id,
-                          const uint16_t total_len, uint16_t in_port,
-                          const uint8_t reason, const buffer *data );
-buffer *create_flow_removed( const uint32_t transaction_id, const struct ofp_match match,
-                            const uint64_t cookie, const uint16_t priority,
-                            const uint8_t reason, const uint32_t duration_sec,
-                            const uint32_t duration_nsec, const uint16_t idle_timeout,
-                            const uint64_t packet_count, const uint64_t byte_count );
-buffer *create_port_status( const uint32_t transaction_id, const uint8_t reason,
-                            const struct ofp_phy_port desc );
-buffer *create_packet_out( const uint32_t transaction_id, const uint32_t buffer_id,
-                           const uint16_t in_port, const openflow_actions *actions,
-                           const buffer *data );
-buffer *create_flow_mod(
-  const uint32_t transaction_id,
-  const struct ofp_match match,
-  const uint64_t cookie,
-  const uint16_t command,
-  const uint16_t idle_timeout,
-  const uint16_t hard_timeout,
-  const uint16_t priority,
-  const uint32_t buffer_id,
-  const uint16_t out_port,
-  const uint16_t flags,
-  const openflow_actions *actions
-);
-buffer *create_port_mod( const uint32_t transaction_id, const uint16_t port_no,
-                         const uint8_t hw_addr[ OFP_ETH_ALEN ], const uint32_t config,
-                         const uint32_t mask, const uint32_t advertise );
-buffer *create_desc_stats_request( const uint32_t transaction_id, const uint16_t flags );
-buffer *create_flow_stats_request( const uint32_t transaction_id, const uint16_t flags,
-                                   const struct ofp_match match, const uint8_t table_id,
-                                   const uint16_t out_port );
-buffer *create_aggregate_stats_request( const uint32_t transaction_id,
-                                        const uint16_t flags, const struct ofp_match match,
-                                        const uint8_t table_id, const uint16_t out_port );
-buffer *create_table_stats_request( const uint32_t transaction_id, const uint16_t flags );
-buffer *create_port_stats_request( const uint32_t transaction_id, const uint16_t flags,
-                                   const uint16_t port_no );
-buffer *create_queue_stats_request( const uint32_t transaction_id, const uint16_t flags,
-                                    const uint16_t port_no, const uint32_t queue_id );
-buffer *create_vendor_stats_request( const uint32_t transaction_id, const uint16_t flags,
-                                     const uint32_t vendor, const buffer *body );
-buffer *create_desc_stats_reply( const uint32_t transaction_id, const uint16_t flags,
-                                 const char mfr_desc[ DESC_STR_LEN ],
-                                 const char hw_desc[ DESC_STR_LEN ],
-                                 const char sw_desc[ DESC_STR_LEN ],
-                                 const char serial_num[ SERIAL_NUM_LEN ],
-                                 const char dp_desc[ DESC_STR_LEN ] );
-buffer *create_flow_stats_reply( const uint32_t transaction_id, const uint16_t flags,
-                                 const list_element *flows_stats_head );
-buffer *create_aggregate_stats_reply( const uint32_t transaction_id,
-                                      const uint16_t flags,
-                                      const uint64_t packet_count, const uint64_t byte_count,
-                                      const uint32_t flow_count );
-buffer *create_table_stats_reply( const uint32_t transaction_id, const uint16_t flags,
-                                  const list_element *table_stats_head );
-buffer *create_port_stats_reply( const uint32_t transaction_id, const uint16_t flags,
-                                 const list_element *port_stats_head );
-buffer *create_queue_stats_reply( const uint32_t transaction_id, const uint16_t flags,
-                                  const list_element *queue_stats_head );
-buffer *create_vendor_stats_reply( const uint32_t transaction_id, const uint16_t flags,
-                                   const uint32_t vendor, const buffer *body );
-buffer *create_barrier_request( const uint32_t transaction_id );
-buffer *create_barrier_reply( const uint32_t transaction_id );
-buffer *create_queue_get_config_request( const uint32_t transaction_id, const uint16_t port );
-buffer *create_queue_get_config_reply( const uint32_t transaction_id, const uint16_t port,
-                                       const list_element *queues );
-uint32_t get_transaction_id( void );
-uint64_t get_cookie( void );
-openflow_actions *create_actions( void );
-bool delete_actions( openflow_actions *actions );
-bool append_action_output( openflow_actions *actions, const uint16_t port, const uint16_t max_len );
-bool append_action_set_vlan_vid( openflow_actions *actions, const uint16_t vlan_vid );
-bool append_action_set_vlan_pcp( openflow_actions *actions, const uint8_t vlan_pcp );
-bool append_action_strip_vlan( openflow_actions *actions );
-bool append_action_set_dl_src( openflow_actions *actions, const uint8_t hw_addr[ OFP_ETH_ALEN ] );
-bool append_action_set_dl_dst( openflow_actions *actions, const uint8_t hw_addr[ OFP_ETH_ALEN ] );
-bool append_action_set_nw_src( openflow_actions *actions, const uint32_t nw_addr );
-bool append_action_set_nw_dst( openflow_actions *actions, const uint32_t nw_addr );
-bool append_action_set_nw_tos( openflow_actions *actions, const uint8_t nw_tos );
-bool append_action_set_tp_src( openflow_actions *actions, const uint16_t tp_port );
-bool append_action_set_tp_dst( openflow_actions *actions, const uint16_t tp_port );
-bool append_action_enqueue( openflow_actions *actions, const uint16_t port,
-                            const uint32_t queue_id );
-bool append_action_vendor( openflow_actions *actions, const uint32_t vendor,
-                           const buffer *data );
-
-
-// Return code definitions indicating the result of OpenFlow message validation.
-enum {
-  SUCCESS = 0,
-  ERROR_UNSUPPORTED_VERSION = -63,
-  ERROR_INVALID_LENGTH,
-  ERROR_TOO_SHORT_MESSAGE,
-  ERROR_TOO_LONG_MESSAGE,
-  ERROR_INVALID_TYPE,
-  ERROR_UNDEFINED_TYPE,
-  ERROR_UNSUPPORTED_TYPE,
-  ERROR_NO_TABLE_AVAILABLE,
-  ERROR_INVALID_PORT_NO,
-  ERROR_INVALID_PORT_CONFIG,
-  ERROR_INVALID_PORT_STATE,
-  ERROR_INVALID_PORT_FEATURES,
-  ERROR_INVALID_SWITCH_CONFIG,
-  ERROR_INVALID_PACKET_IN_REASON,
-  ERROR_INVALID_FLOW_REMOVED_REASON,
-  ERROR_INVALID_WILDCARDS,
-  ERROR_INVALID_VLAN_VID,
-  ERROR_INVALID_VLAN_PCP,
-  ERROR_INVALID_NW_TOS,
-  ERROR_INVALID_PORT_STATUS_REASON,
-  ERROR_TOO_SHORT_QUEUE_DESCRIPTION,
-  ERROR_TOO_SHORT_QUEUE_PROPERTY,
-  ERROR_TOO_LONG_QUEUE_PROPERTY,
-  ERROR_UNDEFINED_QUEUE_PROPERTY,
-  ERROR_TOO_SHORT_ACTION,
-  ERROR_UNDEFINED_ACTION_TYPE,
-  ERROR_INVALID_ACTION_TYPE,
-  ERROR_TOO_SHORT_ACTION_OUTPUT,
-  ERROR_TOO_LONG_ACTION_OUTPUT,
-  ERROR_TOO_SHORT_ACTION_VLAN_VID,
-  ERROR_TOO_LONG_ACTION_VLAN_VID,
-  ERROR_TOO_SHORT_ACTION_VLAN_PCP,
-  ERROR_TOO_LONG_ACTION_VLAN_PCP,
-  ERROR_TOO_SHORT_ACTION_STRIP_VLAN,
-  ERROR_TOO_LONG_ACTION_STRIP_VLAN,
-  ERROR_TOO_SHORT_ACTION_DL_SRC,
-  ERROR_TOO_LONG_ACTION_DL_SRC,
-  ERROR_TOO_SHORT_ACTION_DL_DST,
-  ERROR_TOO_LONG_ACTION_DL_DST,
-  ERROR_TOO_SHORT_ACTION_NW_SRC,
-  ERROR_TOO_LONG_ACTION_NW_SRC,
-  ERROR_TOO_SHORT_ACTION_NW_DST,
-  ERROR_TOO_LONG_ACTION_NW_DST,
-  ERROR_TOO_SHORT_ACTION_NW_TOS,
-  ERROR_TOO_LONG_ACTION_NW_TOS,
-  ERROR_TOO_SHORT_ACTION_TP_SRC,
-  ERROR_TOO_LONG_ACTION_TP_SRC,
-  ERROR_TOO_SHORT_ACTION_TP_DST,
-  ERROR_TOO_LONG_ACTION_TP_DST,
-  ERROR_TOO_SHORT_ACTION_ENQUEUE,
-  ERROR_TOO_LONG_ACTION_ENQUEUE,
-  ERROR_TOO_SHORT_ACTION_VENDOR,
-  ERROR_INVALID_LENGTH_ACTION_VENDOR,
-  ERROR_UNSUPPORTED_STATS_TYPE,
-  ERROR_INVALID_STATS_REPLY_FLAGS,
-  ERROR_INVALID_FLOW_PRIORITY,
-  ERROR_INVALID_FLOW_MOD_FLAGS,
-  ERROR_INVALID_PORT_MASK,
-  ERROR_INVALID_STATS_TYPE,
-  ERROR_INVALID_STATS_REQUEST_FLAGS,
-  ERROR_UNDEFINED_FLOW_MOD_COMMAND,
-  ERROR_INVALID_ERROR_TYPE,
-  ERROR_INVALID_ERROR_CODE,
-  ERROR_UNEXPECTED_ERROR = -255
-};
-
-
-// Functions for validating OpenFlow messages
-int validate_hello( const buffer *message );
-int validate_error( const buffer *message );
-int validate_echo_request( const buffer *message );
-int validate_echo_reply( const buffer *message );
-int validate_vendor( const buffer *message );
-int validate_features_request( const buffer *message );
-int validate_features_reply( const buffer *message );
-int validate_get_config_request( const buffer *message );
-int validate_get_config_reply( const buffer *message );
-int validate_set_config( const buffer *message );
-int validate_packet_in( const buffer *message );
-int validate_flow_removed( const buffer *message );
-int validate_port_status( const buffer *message );
-int validate_packet_out( const buffer *message );
-int validate_flow_mod( const buffer *message );
-int validate_port_mod( const buffer *message );
-int validate_desc_stats_request( const buffer *message );
-int validate_flow_stats_request( const buffer *message );
-int validate_aggregate_stats_request( const buffer *message );
-int validate_table_stats_request( const buffer *message );
-int validate_port_stats_request( const buffer *message );
-int validate_queue_stats_request( const buffer *message );
-int validate_vendor_stats_request( const buffer *message );
-int validate_stats_request( const buffer *message );
-int validate_desc_stats_reply( const buffer *message );
-int validate_flow_stats_reply( const buffer *message );
-int validate_aggregate_stats_reply( const buffer *message );
-int validate_table_stats_reply( const buffer *message );
-int validate_port_stats_reply( const buffer *message );
-int validate_queue_stats_reply( const buffer *message );
-int validate_vendor_stats_reply( const buffer *message );
-int validate_stats_reply( const buffer *message );
-int validate_barrier_request( const buffer *message );
-int validate_barrier_reply( const buffer *message );
-int validate_queue_get_config_request( const buffer *message );
-int validate_queue_get_config_reply( const buffer *message );
-int validate_actions( struct ofp_action_header *actions_head, const uint16_t length );
-int validate_action_output( const struct ofp_action_output *action );
-int validate_action_set_vlan_vid( const struct ofp_action_vlan_vid *action );
-int validate_action_set_vlan_pcp( const struct ofp_action_vlan_pcp *action );
-int validate_action_strip_vlan( const struct ofp_action_header *action );
-int validate_action_set_dl_src( const struct ofp_action_dl_addr *action );
-int validate_action_set_dl_dst( const struct ofp_action_dl_addr *action );
-int validate_action_set_nw_src( const struct ofp_action_nw_addr *action );
-int validate_action_set_nw_dst( const struct ofp_action_nw_addr *action );
-int validate_action_set_nw_tos( const struct ofp_action_nw_tos *action );
-int validate_action_set_tp_src( const struct ofp_action_tp_port *action );
-int validate_action_set_tp_dst( const struct ofp_action_tp_port *action );
-int validate_action_enqueue( const struct ofp_action_enqueue *action );
-int validate_action_vendor( const struct ofp_action_vendor_header *action );
-int validate_openflow_message( const buffer *message );
-bool valid_openflow_message( const buffer *message );
-bool valid_message_version( const uint8_t type, const uint8_t version );
-
-// Utility functions
-bool get_error_type_and_code( const uint8_t type, const int error_no,
-                              uint16_t *error_type, uint16_t *error_code );
-void set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
-                            const uint32_t wildcards, const buffer *packet );
-void normalize_match( struct ofp_match *match );
-
-
-#endif // OPENFLOW_MESSAGE_H
-
-
-/*
- * Local variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */

data/src/lib/openflow_service_interface.h

@@ -1,58 +0,0 @@
-/*
- * OpenFlow service interface.
- *
- * Copyright (C) 2008-2013 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.
- */
-
-
-#ifndef OPENFLOW_SERVICE_INTERFACE_H
-#define OPENFLOW_SERVICE_INTERFACE_H
-
-
-/**
- * Message type definitions for sending/receiving OpenFlow messages or
- * related events via messenger.
- */
-#define MESSENGER_OPENFLOW_MESSAGE 1
-#define MESSENGER_OPENFLOW_CONNECTED 2
-#define MESSENGER_OPENFLOW_READY 3
-#define MESSENGER_OPENFLOW_DISCONNECTED 4
-#define MESSENGER_OPENFLOW_DISCONNECT_REQUEST 5
-#define MESSENGER_OPENFLOW_FAILD_TO_CONNECT 6
-
-
-/**
- * Header for sending/receiving OpenFlow messages or events via messenger.
- * A null-terminated service name can be provided after service_name_len
- * and an OpenFlow message must be included in the rest of part in case of
- * MESSENGER_OPENFLOW_MESSAGE. service_name_length can be zero if service
- * name notification is not necessary.
- */
-typedef struct openflow_service_header {
-  uint64_t datapath_id;
-  uint16_t service_name_length;
-} __attribute__( ( packed ) ) openflow_service_header_t;
-
-
-#endif // OPENFLOW_SERVICE_INTERFACE_H
-
-
-/*
- * Local variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */

data/src/lib/openflow_switch_interface.c

@@ -1,1378 +0,0 @@
-/*
- * Copyright (C) 2008-2013 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 <arpa/inet.h>
-#include <assert.h>
-#include <inttypes.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, 128 );
-}
-
-
-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 = %#x, code = %#x, data length = %zu ).",
-         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.echo_request_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.echo_reply_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 = %zu, frame_length = %zu ).",
-         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.port_mod_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 = %zu ).", 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 = %#x ).", 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 remote." );
-
-  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 = %#x, data = %p, length = %zu ).", 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:
- */