trema 0.3.16 → 0.3.17

data/features/support/hooks.rb

@@ -46,6 +46,7 @@ end
 After do
   run "trema killall"
   wait_until_all_pid_files_are_deleted
+  processes.clear
 end
 
 

data/ruby/rake/c/dependency.rb

@@ -0,0 +1,42 @@
+require "pstore"
+require "trema/path"
+
+
+module Rake
+  module C
+    module Dependency
+      @@store = {}
+
+
+      def self.read name, file
+        dump_of( name ).transaction( true ) do | store |
+          store[ file ]
+        end || []
+      end
+
+
+      def self.write name, file, dependency
+        dump_of( name ).transaction( false ) do | store |
+          store[ file ] = dependency
+        end
+      end
+
+
+      def self.dump_of name
+        @@store[ name ] ||= PStore.new( path( name ) )
+      end
+
+
+      def self.path name
+        File.join Trema.home, ".#{ name }.depends"
+      end
+    end
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/ruby/rake/c/library-task.rb

@@ -0,0 +1,142 @@
+require "popen4"
+require "rake/c/dependency"
+require "rake/clean"
+require "rake/tasklib"
+
+
+module Rake
+  module C
+    class LibraryTask < TaskLib
+      attr_accessor :cflags
+      attr_accessor :includes
+      attr_accessor :library_name
+      attr_accessor :name
+      attr_accessor :target_directory
+      attr_writer :sources
+
+
+      def initialize name, &block
+        init name
+        block.call self
+        define
+      end
+
+
+      def sources
+        FileList.new @sources
+      end
+
+
+      ##########################################################################
+      private
+      ##########################################################################
+
+
+      def init name
+        @name = name
+        @includes = []
+      end
+
+
+      def define
+        CLEAN.include objects
+        CLOBBER.include target_directory
+        CLOBBER.include Dependency.path( @library_name )
+
+        task name => [ target_directory, target_path ]
+        directory target_directory
+
+        sources.zip( objects ) do | source, object |
+          task object => source do | task |
+            compile task.name, task.prerequisites[ 0 ]
+          end
+        end
+
+        file target_path => objects do | task |
+          generate_library
+        end
+      end
+
+
+      def generate_library
+        raise NotImplementedError, "Override this!"
+      end
+
+
+      def target_file_name
+        raise NotImplementedError, "Override this!"
+      end
+
+
+      def target_path
+        File.join @target_directory, target_file_name
+      end
+
+
+      def objects
+        sources.collect do | each |
+          File.join @target_directory, File.basename( each ).ext( ".o" )
+        end
+      end
+
+
+      def compile o_file, c_file
+        return if uptodate?( o_file, [ c_file ] + Dependency.read( library_name, o_file ) )
+        autodepends = run_gcc_H( "gcc -H #{ gcc_cflags } -fPIC #{ gcc_I_options } -c #{ c_file } -o #{ o_file }" )
+        Dependency.write( library_name, o_file, autodepends )
+      end
+
+
+      def run_gcc_H command
+        autodepends = []
+
+        puts command
+        status = POpen4.popen4( command ) do | stdout, stderr, stdin, pid |
+          stdin.close
+          stderr.each do | line |
+            case line
+              when /^\./
+                autodepends << line.sub( /^\.+\s+/, "" ).strip
+              when /Multiple include guards/
+                # Filter out include guards warnings.
+                stderr.each do | line |
+                  if line =~ /:$/
+                    puts line
+                    break
+                  end
+                end
+              else
+                puts line
+            end
+          end
+        end
+        fail "gcc failed" if status.exitstatus != 0
+
+        autodepends
+      end
+
+
+      def gcc_cflags
+        @cflags.join " "
+      end
+
+
+      def gcc_I_options
+        @includes.collect do | each |
+          "-I#{ each }"
+        end.join( " " )
+      end
+    end
+  end
+end
+
+
+require "rake/c/shared-library-task"
+require "rake/c/static-library-task"
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/ruby/rake/c/shared-library-task.rb

@@ -0,0 +1,38 @@
+require "rake/c/library-task"
+
+
+module Rake
+  module C
+    class SharedLibraryTask < LibraryTask
+      attr_accessor :version
+
+
+      ##########################################################################
+      private
+      ##########################################################################
+
+
+      def generate_library
+        return if uptodate?( target_path, objects )
+        sh "gcc -shared -Wl,-soname=#{ soname } -o #{ target_path } #{ objects.to_s }"
+      end
+
+
+      def soname
+        File.basename( target_file_name ).sub( /\.\d+\.\d+\Z/, "" )
+      end
+
+
+      def target_file_name
+        @library_name + ".so." + @version
+      end
+    end
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/ruby/rake/c/static-library-task.rb

@@ -0,0 +1,32 @@
+require "rake/c/library-task"
+
+
+module Rake
+  module C
+    class StaticLibraryTask < LibraryTask
+      ##########################################################################
+      private
+      ##########################################################################
+
+
+      def generate_library
+        if not uptodate?( target_path, objects )
+          sh "ar -cq #{ target_path } #{ objects.join ' ' }"
+          sh "ranlib #{ target_path }"
+        end
+      end
+
+
+      def target_file_name
+        @library_name + ".a"
+      end
+    end
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/ruby/trema/path.rb

@@ -60,6 +60,7 @@ module Trema
   dir :objects, "oflops"
   dir :objects, "openflow"
   dir :objects, "openvswitch"
+  dir :objects, "phost"
   dir :tmp, "log"
   dir :tmp, "pid"
   dir :tmp, "sock"

data/ruby/trema/switch-event.c

@@ -0,0 +1,647 @@
+/*
+ * Copyright (C) 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 <assert.h>
+#include "ruby.h"
+#include "switch-event.h"
+
+#include "trema.h"
+
+extern VALUE mTrema;
+VALUE mSwitchEvent;
+
+static ID idVendor;
+static ID idPacketIn;
+static ID idPortStatus;
+static ID idStateNotify;
+
+
+typedef struct callback_info {
+  VALUE self;
+  VALUE block;
+} callback_info;
+
+
+static bool
+event_type_symbol_to_enum( VALUE rType, enum efi_event_type *cType ) {
+  assert( cType != NULL );
+  const ID idType = rb_to_id( rType );
+  if ( false ) {
+  }
+  else if ( idType == idVendor ) {
+    *cType = EVENT_FORWARD_TYPE_VENDOR;
+  }
+  else if ( idType == idPacketIn ) {
+    *cType = EVENT_FORWARD_TYPE_PACKET_IN;
+  }
+  else if ( idType == idPortStatus ) {
+    *cType = EVENT_FORWARD_TYPE_PORT_STATUS;
+  }
+  else if ( idType == idStateNotify ) {
+    *cType = EVENT_FORWARD_TYPE_STATE_NOTIFY;
+  }
+  else {
+    return false;
+  }
+  return true;
+}
+
+
+static void
+handle_event_forward_entry_to_all_callback( enum efi_result result,
+                                            void *user_data ) {
+  debug( "%s", __func__ );
+  callback_info *cb = user_data;
+  if ( cb->block != Qnil ) {
+    if ( result == EFI_OPERATION_SUCCEEDED ) {
+      rb_funcall( cb->block, rb_intern( "call" ), 1, Qtrue );
+    }
+    else {
+      rb_funcall( cb->block, rb_intern( "call" ), 1, Qfalse );
+    }
+  }
+  xfree( cb );
+
+}
+
+/*
+ * @!group Operation for all existing switches and switch manager
+ *
+ * @overload add_forward_entry_to_all_switches type, service_name, {|result| ... }
+ * Add forwarding entry to all existing switches and switch manager.
+ *
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [String] service_name Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful on all switches and switch manager
+ */
+static VALUE
+add_forward_entry_to_all_switches( VALUE self, VALUE type, VALUE service_name ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const char *c_service_name = StringValuePtr( service_name );
+  if ( strlen( c_service_name ) == 0 ) {
+    warn( "service_name cannot be empty" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = add_event_forward_entry_to_all_switches(
+                                    c_type, c_service_name,
+                                    handle_event_forward_entry_to_all_callback,
+                                    cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for all existing switches and switch manager
+ *
+ * @overload delete_forward_entry_from_all_switches type, service_name, {|result| ... }
+ * Delete forwarding entry to all existing switches and switch manager.
+ *
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [String] service_name Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful on all switches and switch manager
+ */
+static VALUE
+delete_forward_entry_from_all_switches( VALUE self, VALUE type,
+                                        VALUE service_name ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const char *c_service_name = StringValuePtr( service_name );
+  if ( strlen( c_service_name ) == 0 ) {
+    warn( "service_name cannot be empty" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = delete_event_forward_entry_to_all_switches(
+                                    c_type, c_service_name,
+                                    handle_event_forward_entry_to_all_callback,
+                                    cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+static void
+handle_event_forward_entry_operation_callback(
+    event_forward_operation_result result, void *user_data ) {
+  debug( "%s", __func__ );
+  callback_info *cb = user_data;
+
+  if ( cb->block != Qnil ) {
+    if ( result.result == EFI_OPERATION_SUCCEEDED ) {
+      VALUE aryDpid = rb_ary_new2( ( long ) result.n_services );
+      for ( uint32_t i = 0 ; i < result.n_services ; ++i ) {
+        VALUE service_name = rb_str_new2( result.services[i] );
+        rb_ary_push( aryDpid, service_name );
+      }
+      rb_funcall( cb->block, rb_intern( "call" ), 2, Qtrue, aryDpid );
+    }
+    else {
+      VALUE aryDpid = rb_ary_new();
+      rb_funcall( cb->block, rb_intern( "call" ), 2, Qfalse, aryDpid );
+    }
+  }
+  xfree( cb );
+}
+
+
+/*
+ * @!group Operation for existing switch
+ *
+ * @overload add_forward_entry_to_switch datapath_id, type, service_name, {|result, services| ... }
+ * Add forwarding entry of a switch specified.
+ *
+ * @param [Integer] dpid Switch datapath_id
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [String] service_name Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful.
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+add_forward_entry_to_switch( VALUE self, VALUE dpid, VALUE type,
+                             VALUE service_name ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const uint64_t c_dpid = NUM2ULL( dpid );
+  const char *c_service_name = StringValuePtr( service_name );
+  if ( strlen( c_service_name ) == 0 ) {
+    warn( "service_name cannot be empty" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = add_switch_event_forward_entry(
+                                c_dpid, c_type, c_service_name,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for existing switch
+ *
+ * @overload delete_forward_entry_from_switch datapath_id, type, service_name, {|result, services| ... }
+ * Delete forwarding entry of a switch specified.
+ *
+ * @param [Integer] dpid Switch datapath_id
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [String] service_name Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful.
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+delete_forward_entry_from_switch( VALUE self, VALUE dpid, VALUE type,
+                                  VALUE service_name ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const uint64_t c_dpid = NUM2ULL( dpid );
+  const char *c_service_name = StringValuePtr( service_name );
+  if ( strlen( c_service_name ) == 0 ) {
+    warn( "service_name cannot be empty" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = delete_switch_event_forward_entry(
+                                c_dpid, c_type, c_service_name,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for existing switch
+ *
+ * @overload set_forward_entries_to_switch datapath_id, type, service_name, {|result, services| ... }
+ * Set forwarding entries of a switch specified.
+ *
+ * @param [Integer] dpid Switch datapath_id
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [Array<String>] service_names Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful.
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+set_forward_entries_to_switch( VALUE self, VALUE dpid, VALUE type,
+                               VALUE service_names ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const uint64_t c_dpid = NUM2ULL( dpid );
+  list_element *service_list = NULL;
+  create_list( &service_list );
+  for ( long i = 0 ; i < RARRAY( service_names )->len ; ++i ) {
+    VALUE ruby_service_name = rb_ary_entry( service_names, i );
+    char *c_service_name = StringValuePtr( ruby_service_name );
+    if ( strlen( c_service_name ) == 0 ) {
+      warn( "Ignoring empty service_name" );
+      continue;
+    }
+    append_to_tail( &service_list, c_service_name );
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = set_switch_event_forward_entries(
+                                c_dpid, c_type, service_list,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+
+  delete_list( service_list );
+
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for existing switch
+ *
+ * @overload dump_forward_entries_from_switch datapath_id, type, {|result, services| ... }
+ * Dump forwarding entry of a switch specified.
+ *
+ * @param [Integer] dpid Switch datapath_id
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful on all switches and switch manager
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+dump_forward_entries_from_switch( VALUE self, VALUE dpid, VALUE type ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const uint64_t c_dpid = NUM2ULL( dpid );
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = dump_switch_event_forward_entries(
+                                c_dpid, c_type,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for switch manager
+ *
+ * @overload add_forward_entry_to_switch_manager type, service_name, {|result, services| ... }
+ * Add forwarding entry to a switch manager.
+ *
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [String] service_name Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful.
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+add_forward_entry_to_switch_manager( VALUE self, VALUE type,
+                                     VALUE service_name ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const char *c_service_name = StringValuePtr( service_name );
+  if ( strlen( c_service_name ) == 0 ) {
+    warn( "service_name cannot be empty" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = add_switch_manager_event_forward_entry(
+                                c_type, c_service_name,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for switch manager
+ *
+ * @overload delete_forward_entry_from_switch_manager type, service_name, {|result, services| ... }
+ * Delete forwarding entry of a switch manager.
+ *
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [String] service_name Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful.
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+delete_forward_entry_from_switch_manager( VALUE self, VALUE type,
+                                          VALUE service_name ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  const char *c_service_name = StringValuePtr( service_name );
+  if ( strlen( c_service_name ) == 0 ) {
+    warn( "service_name cannot be empty" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = delete_switch_manager_event_forward_entry(
+                                c_type, c_service_name,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for switch manager
+ *
+ * @overload set_forward_entries_to_switch_manager type, service_names, {|result, services| ... }
+ * Set forwarding entries of a switch manager.
+ *
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @param [Array<String>] service_names Name of controller to forward event.
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful.
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+set_forward_entries_to_switch_manager( VALUE self, VALUE type,
+                                       VALUE service_names ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  list_element *service_list = NULL;
+  create_list( &service_list );
+  for ( long i = 0 ; i < RARRAY( service_names )->len ; ++i ) {
+    VALUE ruby_service_name = rb_ary_entry( service_names, i );
+    char *c_service_name = StringValuePtr( ruby_service_name );
+    if ( strlen( c_service_name ) == 0 ) {
+      warn( "Ignoring empty service_name" );
+      continue;
+    }
+    append_to_tail( &service_list, c_service_name );
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = set_switch_manager_event_forward_entries(
+                                c_type, service_list,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+
+  delete_list( service_list );
+
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * @!group Operation for switch manager
+ *
+ * @overload dump_forward_entries_from_switch type, {|result, services| ... }
+ * Dump forwarding entry of a switch manager.
+ *
+ * @param [Symbol] type Switch event type. it must be one of :vendor, :packet_in, :port_status, :state_notify
+ * @return [Boolean] true if request was sent successfully.
+ *
+ * @yield Callback to notify the result of operation.
+ * @yieldparam result [Boolean] true if result successful on all switches and switch manager
+ * @yieldparam services [Array<String>] Service Name list on forwarding entry after operation.
+ */
+static VALUE
+dump_forward_entries_from_switch_manager( VALUE self, VALUE type ) {
+  debug( "%s", __func__ );
+  enum efi_event_type c_type;
+  if ( !event_type_symbol_to_enum( type, &c_type ) ) {
+    warn( "Invalid event type was specified" );
+    return Qfalse;
+  }
+
+  callback_info *cb = xcalloc( 1, sizeof( callback_info ) );
+  cb->self = self;
+  cb->block = Qnil;
+  if ( rb_block_given_p() == Qtrue ) {
+    cb->block = rb_block_proc();
+  }
+  bool succ = dump_switch_manager_event_forward_entries(
+                                c_type,
+                                handle_event_forward_entry_operation_callback,
+                                cb );
+  if ( succ ) {
+    return Qtrue;
+  }
+  else {
+    xfree( cb );
+    return Qfalse;
+  }
+}
+
+
+/*
+ * Document-module: Trema::SwitchEvent
+ */
+void
+Init_switch_event( void ) {
+  mSwitchEvent = rb_define_module_under( mTrema, "SwitchEvent" );
+
+  idVendor = rb_intern( "vendor" );
+  idPacketIn = rb_intern( "packet_in" );
+  idPortStatus = rb_intern( "port_status" );
+  idStateNotify = rb_intern( "state_notify" );
+
+  rb_define_method( mSwitchEvent, "add_forward_entry_to_all_switches",
+                    add_forward_entry_to_all_switches, 2 );
+  rb_define_method( mSwitchEvent, "delete_forward_entry_from_all_switches",
+                    delete_forward_entry_from_all_switches, 2 );
+
+  rb_define_method( mSwitchEvent, "add_forward_entry_to_switch",
+                    add_forward_entry_to_switch, 3 );
+  rb_define_method( mSwitchEvent, "delete_forward_entry_from_switch",
+                    delete_forward_entry_from_switch, 3 );
+  rb_define_method( mSwitchEvent, "set_forward_entries_to_switch",
+                    set_forward_entries_to_switch, 3 );
+  rb_define_method( mSwitchEvent, "dump_forward_entries_from_switch",
+                    dump_forward_entries_from_switch, 2 );
+
+  rb_define_method( mSwitchEvent, "add_forward_entry_to_switch_manager",
+                    add_forward_entry_to_switch_manager, 2 );
+  rb_define_method( mSwitchEvent, "delete_forward_entry_from_switch_manager",
+                    delete_forward_entry_from_switch_manager, 2 );
+  rb_define_method( mSwitchEvent, "set_forward_entries_to_switch_manager",
+                    set_forward_entries_to_switch_manager, 2 );
+  rb_define_method( mSwitchEvent, "dump_forward_entries_from_switch_manager",
+                    dump_forward_entries_from_switch_manager, 1 );
+}