trema 0.1.3

data/src/lib/utility.h

@@ -0,0 +1,67 @@
+/*
+ * Utility functions.
+ *
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>
+ *
+ * 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.
+ */
+
+
+#ifndef UTILITY_H
+#define UTILITY_H
+
+
+#include <stdint.h>
+#include <stdio.h>
+#include "bool.h"
+#include "openflow.h"
+
+
+extern void ( *die )( const char *format, ... );
+
+unsigned int hash_core( const void *key, int size );
+
+bool compare_string( const void *x, const void *y );
+unsigned int hash_string( const void *key );
+
+bool compare_mac( const void *x, const void *y );
+unsigned int hash_mac( const void *mac );
+uint64_t mac_to_uint64( const uint8_t *mac );
+
+bool compare_uint32( const void *x, const void *y );
+unsigned int hash_uint32( const void *key );
+
+bool compare_datapath_id( const void *x, const void *y );
+unsigned int hash_datapath_id( const void *key );
+
+bool string_to_datapath_id( const char *str, uint64_t *datapath_id );
+
+bool match_to_string( const struct ofp_match *match, char *str, size_t size );
+bool phy_port_to_string( const struct ofp_phy_port *phy_port, char *str, size_t size );
+bool actions_to_string( const struct ofp_action_header *actions, uint16_t actions_length, char *str, size_t str_length );
+
+uint16_t get_checksum( uint16_t *pos, uint32_t size );
+
+
+#endif // UTILITY_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/wrapper.c

@@ -0,0 +1,100 @@
+/*
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>
+ *
+ * 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 <linux/limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include "trema_wrapper.h"
+#include "utility.h"
+#include "wrapper.h"
+
+
+static void *
+_trema_malloc( size_t size, const char *error_message ) {
+  void *ret = trema_malloc( size );
+  if ( !ret ) {
+    die( error_message );
+  }
+  return ret;
+}
+
+
+void *
+xmalloc( size_t size ) {
+  void *ret = _trema_malloc( size, "Out of memory, xmalloc failed" );
+  memset( ret, 0xA5, size );
+  return ret;
+}
+
+
+void *
+xcalloc( size_t nmemb, size_t size ) {
+  void *ret = trema_calloc( nmemb, size );
+  if ( !ret ) {
+    die( "Out of memory, xcalloc failed" );
+  }
+  return ret;
+}
+
+
+void
+xfree( void *ptr ) {
+  trema_free( ptr );
+}
+
+
+static char *
+_xstrdup( const char *s, const char *error_message ) {
+  size_t len = strlen( s ) + 1;
+  char *ret = _trema_malloc( len, error_message );
+  memcpy( ret, s, len );
+  return ret;
+}
+
+
+char *
+xstrdup( const char *s ) {
+  return _xstrdup( s, "Out of memory, xstrdup failed" );
+}
+
+
+char *
+xasprintf( const char *format, ... ) {
+  const char error[] = "Out of memory, xasprintf failed";
+  va_list args;
+  va_start( args, format );
+  char *str;
+  if ( trema_vasprintf( &str, format, args ) < 0 ) {
+    die( error );
+  }
+  char *result = _xstrdup( str, error );
+  free( str );
+  va_end( args );
+  return result;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/wrapper.h

@@ -0,0 +1,76 @@
+/*
+ * Wrappers that simplifies the handling of memory allocation errors.
+ *
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>
+ *
+ * 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.
+ */
+
+
+#ifndef WRAPPER_H
+#define WRAPPER_H
+
+
+#include <stddef.h>
+#include <string.h>
+#include "utility.h"
+
+
+// If this is being built for a unit test.
+#ifdef UNIT_TESTING
+
+// Redirect assert to mock_assert() so assertions can be caught by cmockery.
+#ifdef assert
+#undef assert
+#endif // assert
+#define assert( expression )                                                \
+  mock_assert( ( int ) ( expression ), #expression, __FILE__, __LINE__ );
+extern void mock_assert( const int result, const char *const expression, const char *const file, const int line );
+
+#endif // UNIT_TESTING
+
+
+// Undef Ruby's xmalloc()
+#ifdef xmalloc
+#undef xmalloc
+#endif
+void *xmalloc( size_t size );
+
+// Undef Ruby's xcalloc()
+#ifdef xcalloc
+#undef xcalloc
+#endif
+void *xcalloc( size_t nmemb, size_t size );
+
+// Undef Ruby's xfree()
+#ifdef xfree
+#undef xfree
+#endif
+void xfree( void *ptr );
+
+char *xstrdup( const char *s );
+char *xasprintf( const char *format, ... );
+
+
+#endif // WRAPPER_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/packetin_filter/README

@@ -0,0 +1,17 @@
+This directory includes packet-in filter component.
+
+              packet out
+         .---------------------------------------.
+         v                                       |
++----------+           +-----------+           +-------+
+|  switch  |  *    1   | packet in |  1    *   | trema |
+|  daemon  | --------> |  filter   | --------> | apps  |
++----------+ packet in +-----------+ packet in +-------+
+  ^ 1
+  |
+  |
+  v 1
++----------+
+| openflow |
+|  switch  |
++----------+

data/src/packetin_filter/packetin_filter.c

@@ -0,0 +1,575 @@
+/*
+ * OpenFlow Packet_in message filter
+ *
+ * Author: Kazushi SUGYO
+ *
+ * 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 <arpa/inet.h>
+#include <assert.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include "trema.h"
+
+
+#ifdef UNIT_TESTING
+
+#define static
+#define main packetin_filter_main
+
+#ifdef printf
+#undef printf
+#endif
+#define printf( fmt, args... )  mock_printf2( fmt, ##args )
+int mock_printf2(const char *format, ...);
+
+#ifdef error
+#undef error
+#endif
+#define error( fmt, args... ) mock_error( fmt, ##args )
+void mock_error( const char *format, ... );
+
+#ifdef set_match_from_packet
+#undef set_match_from_packet
+#endif
+#define set_match_from_packet mock_set_match_from_packet
+void mock_set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
+                                 const uint32_t wildcards, const buffer *packet );
+
+#ifdef create_packet_in
+#undef create_packet_in
+#endif
+#define create_packet_in mock_create_packet_in
+buffer *mock_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 );
+
+#ifdef insert_match_entry
+#undef insert_match_entry
+#endif
+#define insert_match_entry mock_insert_match_entry
+void mock_insert_match_entry( struct ofp_match *ofp_match, uint16_t priority,
+                              const char *service_name );
+
+#ifdef lookup_match_entry
+#undef lookup_match_entry
+#endif
+#define lookup_match_entry mock_lookup_match_entry
+match_entry *mock_lookup_match_entry( struct ofp_match *match );
+
+#ifdef send_message
+#undef send_message
+#endif
+#define send_message mock_send_message
+bool mock_send_message( const char *service_name, const uint16_t tag, const void *data,
+                        size_t len );
+
+#ifdef init_trema
+#undef init_trema
+#endif
+#define init_trema mock_init_trema
+void mock_init_trema( int *argc, char ***argv );
+
+#ifdef set_packet_in_handler
+#undef set_packet_in_handler
+#endif
+#define set_packet_in_handler mock_set_packet_in_handler
+bool mock_set_packet_in_handler( packet_in_handler callback, void *user_data );
+
+#ifdef start_trema
+#undef start_trema
+#endif
+#define start_trema mock_start_trema
+void mock_start_trema( void );
+
+#ifdef get_executable_name
+#undef get_executable_name
+#endif
+#define get_executable_name mock_get_executable_name
+const char *mock_get_executable_name( void );
+
+#endif // UNIT_TESTING
+
+
+void
+usage() {
+  printf(
+	 "OpenFlow Packet in Filter.\n"
+	 "Usage: %s [OPTION]... [PACKETIN-FILTER-RULE]...\n"
+	 "\n"
+	 "  -n, --name=SERVICE_NAME     service name\n"
+	 "  -d, --daemonize             run in the background\n"
+	 "  -l, --logging_level=LEVEL   set logging level\n"
+	 "  -h, --help                  display this help and exit\n"
+	 "\n"
+	 "PACKETIN-FILTER-RULE:\n"
+	 "  match-type::destination-service-name\n"
+	 "\n"
+	 "match-type:\n"
+	 "  lldp                        LLDP ethernet frame type and priority is 0x8000\n"
+	 "  packet_in                   any packet and priority is zero\n"
+	 "\n"
+	 "destination-service-name      destination service name\n"
+	 , get_executable_name()
+	 );
+}
+
+
+static buffer *
+parse_etherip( const buffer *data ) {
+  packet_info *packet_info = data->user_data;
+  if ( packet_info->etherip_version != ETHERIP_VERSION ) {
+    error( "invalid etherip version 0x%04x.", packet_info->etherip_version );
+    return NULL;
+  }
+  if ( packet_info->etherip_offset == 0 ) {
+    debug( "too short etherip message" );
+    return NULL;
+  }
+
+  buffer *copy = duplicate_buffer( data );
+  if ( copy == NULL ) {
+    error( "duplicate_buffer failed." );
+    return NULL;
+  }
+  copy->user_data = NULL;
+  remove_front_buffer( copy, packet_info->etherip_offset );
+
+  if ( !parse_packet( copy ) ) {
+    error( "parse_packet failed." );
+    free_buffer( copy );
+    return NULL;
+  }
+
+  debug( "Receive EtherIP packet." );
+
+  return copy;
+}
+
+
+static void
+handle_packet_in( uint64_t datapath_id, uint32_t transaction_id,
+                  uint32_t buffer_id, uint16_t total_len,
+                  uint16_t in_port, uint8_t reason, const buffer *data,
+                  void *user_data ) {
+  UNUSED( user_data );
+
+  char match_str[ 1024 ];
+  struct ofp_match ofp_match;   // host order
+
+  buffer *copy = NULL;
+  packet_info *packet_info = data->user_data;
+  debug( "Receive packet. ethertype=0x%04x, ipproto=0x%x", packet_info->eth_type, packet_info->ipv4_protocol );
+  if ( packet_type_ipv4_etherip( data ) ) {
+    copy = parse_etherip( data );
+  }
+  set_match_from_packet( &ofp_match, in_port, 0, copy != NULL ? copy : data );
+  if ( copy != NULL ) {
+    free_buffer( copy );
+    copy = NULL;
+  }
+  match_to_string( &ofp_match, match_str, sizeof( match_str ) );
+
+  list_element *services = lookup_match_entry( ofp_match );
+  if ( services == NULL ) {
+    debug( "match entry not found" );
+    return;
+  }
+
+  buffer *buf = create_packet_in( transaction_id, buffer_id, total_len, in_port,
+                                  reason, data );
+
+  openflow_service_header_t *message;
+  message = append_front_buffer( buf, sizeof( openflow_service_header_t ) );
+  message->datapath_id = htonll( datapath_id );
+  message->service_name_length = htons( 0 );
+  list_element *element;
+  for ( element = services; element != NULL; element = element->next ) {
+    const char *service_name = element->data;
+    if ( !send_message( service_name, MESSENGER_OPENFLOW_MESSAGE,
+                        buf->data, buf->length ) ) {
+      error( "Failed to send a message to %s ( match = %s ).", service_name, match_str );
+      free_buffer( buf );
+      return;
+    }
+  
+    debug( "Sending a message to %s ( match = %s ).", service_name, match_str );
+  }
+
+  free_buffer( buf );
+}
+
+
+static void
+init_packetin_match_table( void ) {
+  init_match_table();
+}
+
+
+static void
+free_user_data_entry( struct ofp_match match, uint16_t priority, void *services, void *user_data ) {
+  UNUSED( match );
+  UNUSED( priority );
+  UNUSED( user_data );
+
+  list_element *element;
+  for ( element = services; element != NULL; element = element->next ) {
+    xfree( element->data );
+    element->data = NULL;
+  }
+  delete_list( services );
+}
+
+
+static void
+finalize_packetin_match_table( void ) {
+  foreach_match_table( free_user_data_entry, NULL );
+  finalize_match_table();
+}
+
+
+static bool
+add_packetin_match_entry( struct ofp_match match, uint16_t priority, const char *service_name ) {
+  bool ( *insert_or_update_match_entry ) ( struct ofp_match, uint16_t, void * ) = update_match_entry;
+  list_element *services = lookup_match_strict_entry( match, priority );
+  if ( services == NULL ) {
+    insert_or_update_match_entry = insert_match_entry;
+    create_list( &services );
+  }
+  else {
+    list_element *element;
+    for ( element = services; element != NULL; element = element->next ) {
+      if ( strcmp( element->data, service_name ) == 0 ) {
+        char match_string[ 256 ];
+        match_to_string( &match, match_string, sizeof( match_string ) );
+        warn( "match entry already exists ( match = [%s], service_name = [%s] )", match_string, service_name );
+        return false;
+      }
+    }
+  }
+  append_to_tail( &services, xstrdup( service_name ) );
+  insert_or_update_match_entry( match, priority, services );
+
+  return true;
+}
+
+
+static int
+delete_packetin_match_entry( struct ofp_match match, uint16_t priority, const char *service_name ) {
+  list_element *head = delete_match_strict_entry( match, priority );
+  if ( head == NULL ) {
+    return 0;
+  }
+
+  int n_deleted = 0;
+  int n_remaining_services = 0;
+  list_element *services = head;
+  while ( services != NULL ) {
+    char *service = services->data;
+    services = services->next;
+    if ( strcmp( service, service_name ) == 0 ) {
+      delete_element( &head, service );
+      xfree( service );
+      n_deleted++;
+    }
+    else {
+      n_remaining_services++;
+    }
+  }
+
+  if ( n_remaining_services == 0 ) {
+    if ( head != NULL ) {
+      delete_list( head );
+    }
+  }
+  else {
+    insert_match_entry( match, priority, head );
+  }
+
+  return n_deleted;
+}
+
+
+static void
+register_dl_type_filter( uint16_t dl_type, uint16_t priority, const char *service_name ) {
+  struct ofp_match match;
+  memset( &match, 0, sizeof( struct ofp_match ) );
+  match.wildcards = OFPFW_ALL & ~OFPFW_DL_TYPE;
+  match.dl_type = dl_type;
+
+  add_packetin_match_entry( match, priority, service_name );
+}
+
+
+static void
+register_any_filter( uint16_t priority, const char *service_name ) {
+  struct ofp_match match;
+  memset( &match, 0, sizeof( struct ofp_match ) );
+  match.wildcards = OFPFW_ALL;
+
+  add_packetin_match_entry( match, priority, service_name );
+}
+
+
+static const char *
+match_type( const char *type, char *name ) {
+  size_t len = strlen( type );
+  if ( strncmp( name, type, len ) != 0 ) {
+    return NULL;
+  }
+
+  return name + len;
+}
+
+
+// built-in packetin-filter-rule
+static const char LLDP_PACKET_IN[] = "lldp::";
+static const char ANY_PACKET_IN[] = "packet_in::";
+
+static bool
+set_match_type( int argc, char *argv[] ) {
+  int i;
+  const char *service_name;
+  for ( i = 1; i < argc; i++ ) {
+    if ( ( service_name = match_type( LLDP_PACKET_IN, argv[ i ] ) ) != NULL ) {
+      register_dl_type_filter( ETH_ETHTYPE_LLDP, OFP_DEFAULT_PRIORITY, service_name );
+    }
+    else if ( ( service_name = match_type( ANY_PACKET_IN, argv[ i ] ) ) != NULL ) {
+      register_any_filter( 0, service_name );
+    }
+    else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+static void
+handle_add_filter_request( const messenger_context_handle *handle, add_packetin_filter_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL ) ;
+
+  request->entry.service_name[ MESSENGER_SERVICE_NAME_LENGTH - 1 ] = '\0';
+  if ( strlen( request->entry.service_name ) == 0 ) {
+    error( "Service name must be specified." );
+    return;
+  }
+  struct ofp_match match;
+  ntoh_match( &match, &request->entry.match );
+  bool ret = add_packetin_match_entry( match, ntohs( request->entry.priority ), request->entry.service_name );
+
+  add_packetin_filter_reply reply;
+  memset( &reply, 0, sizeof( add_packetin_filter_reply ) );
+  reply.status = ( uint8_t ) ( ret ? PACKETIN_FILTER_OPERATION_SUCCEEDED : PACKETIN_FILTER_OPERATION_FAILED );
+  ret = send_reply_message( handle, MESSENGER_ADD_PACKETIN_FILTER_REPLY,
+                            &reply, sizeof( add_packetin_filter_reply ) );
+  if ( ret == false ) {
+    error( "Failed to send an add filter reply." );
+  }
+}
+
+
+static void
+delete_filter_walker( struct ofp_match match, uint16_t priority, void *data, void *user_data ) {
+  UNUSED( data );
+  buffer *reply_buffer = user_data; 
+  assert( reply_buffer != NULL );
+
+  delete_packetin_filter_reply *reply = reply_buffer->data;
+  list_element *head = delete_match_strict_entry( match, priority );
+  for ( list_element *services = head; services != NULL; services = services->next ) {
+    xfree( services->data );
+    reply->n_deleted++;
+  }
+  if ( head != NULL ) {
+    delete_list( head );
+  }
+}
+
+
+static void
+handle_delete_filter_request( const messenger_context_handle *handle, delete_packetin_filter_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL ) ;
+
+  buffer *buf = alloc_buffer_with_length( sizeof( delete_packetin_filter_reply ) );
+  delete_packetin_filter_reply *reply = append_back_buffer( buf, sizeof( delete_packetin_filter_reply ) );
+  reply->status = PACKETIN_FILTER_OPERATION_SUCCEEDED;
+  reply->n_deleted = 0;
+
+  struct ofp_match match;
+  ntoh_match( &match, &request->criteria.match );
+  uint16_t priority = ntohs( request->criteria.priority );
+  if ( request->flags & PACKETIN_FILTER_FLAG_MATCH_STRICT ) {
+    int n_deleted = delete_packetin_match_entry( match, priority, request->criteria.service_name );
+    reply->n_deleted += ( uint32_t ) n_deleted;
+  }
+  else {
+    map_match_table( match, delete_filter_walker, buf );
+  }
+  reply->n_deleted = htonl( reply->n_deleted );
+
+  bool ret = send_reply_message( handle, MESSENGER_DELETE_PACKETIN_FILTER_REPLY, buf->data, buf->length );
+  free_buffer( buf );
+  if ( ret == false ) {
+    error( "Failed to send a dump filter reply." );
+  }
+}
+
+
+static void
+dump_filter_walker( struct ofp_match match, uint16_t priority, void *data, void *user_data ) {
+  buffer *reply_buffer = user_data;
+  assert( reply_buffer != NULL );
+
+  dump_packetin_filter_reply *reply = reply_buffer->data;
+  list_element *services = data;
+  while ( services != NULL ) {
+    reply->n_entries++;
+    packetin_filter_entry *entry = append_back_buffer( reply_buffer, sizeof( packetin_filter_entry ) );
+    hton_match( &entry->match, &match );
+    entry->priority = htons( priority );
+    strncpy( entry->service_name, services->data, sizeof( entry->service_name ) );
+    entry->service_name[ sizeof( entry->service_name ) - 1 ] = '\0';
+    services = services->next;
+  }
+}
+
+
+static void
+handle_dump_filter_request( const messenger_context_handle *handle, dump_packetin_filter_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL ) ;
+
+  buffer *buf = alloc_buffer_with_length( 2048 );
+  dump_packetin_filter_reply *reply = append_back_buffer( buf, offsetof( dump_packetin_filter_reply, entries ) );
+  reply->status = PACKETIN_FILTER_OPERATION_SUCCEEDED;
+  reply->n_entries = 0;
+
+  struct ofp_match match;
+  ntoh_match( &match, &request->criteria.match );
+  uint16_t priority = ntohs( request->criteria.priority );
+  if ( request->flags & PACKETIN_FILTER_FLAG_MATCH_STRICT ) {
+    list_element *services = lookup_match_strict_entry( match, priority );
+    while ( services != NULL ) {
+      if ( strcmp( services->data, request->criteria.service_name ) == 0 ) {
+        packetin_filter_entry *entry = append_back_buffer( buf, sizeof( packetin_filter_entry ) );
+        reply->n_entries++;
+        entry->match = request->criteria.match;
+        entry->priority = request->criteria.priority;
+        strncpy( entry->service_name, services->data, sizeof( entry->service_name ) );
+        entry->service_name[ sizeof( entry->service_name ) - 1 ] = '\0';
+      }
+      services = services->next;
+    }
+  }
+  else {
+    map_match_table( match, dump_filter_walker, buf );
+  }
+  reply->n_entries = htonl( reply->n_entries );
+
+  bool ret = send_reply_message( handle, MESSENGER_DUMP_PACKETIN_FILTER_REPLY, buf->data, buf->length );
+  free_buffer( buf );
+  if ( ret == false ) {
+    error( "Failed to send a dump packetin filter reply." );
+  }
+}
+
+
+static void
+handle_request( const messenger_context_handle *handle, uint16_t tag, void *data, size_t length ) {
+  assert( handle != NULL );
+
+  debug( "Handling a request ( handle = %p, tag = %#x, data = %p, length = %u ).",
+         handle, tag, data, length );
+
+  switch ( tag ) {
+    case MESSENGER_ADD_PACKETIN_FILTER_REQUEST:
+    {
+      if ( length != sizeof( add_packetin_filter_request ) ) {
+        error( "Invalid add packetin filter request ( length = %u ).", length );
+        return;
+      }
+
+      handle_add_filter_request( handle, data );
+    }
+    break;
+    case MESSENGER_DELETE_PACKETIN_FILTER_REQUEST:
+    {
+      if ( length != sizeof( delete_packetin_filter_request ) ) {
+        error( "Invalid delete packetin filter request ( length = %u ).", length );
+        return;
+      }
+
+      handle_delete_filter_request( handle, data );
+    }
+    break;
+    case MESSENGER_DUMP_PACKETIN_FILTER_REQUEST:
+    {
+      if ( length != sizeof( dump_packetin_filter_request ) ) {
+        error( "Invalid dump packetin filter request ( length = %u ).", length );
+        return;
+      }
+
+      handle_dump_filter_request( handle, data );
+    }
+    break;
+    default:
+    {
+      warn( "Undefined request tag ( tag = %#x ).", tag );
+    }
+    break;
+  }
+}
+
+
+int
+main( int argc, char *argv[] ) {
+  init_trema( &argc, &argv );
+
+  init_packetin_match_table();
+
+  // built-in packetin-filter-rule
+  if ( !set_match_type( argc, argv ) ) {
+    usage();
+    finalize_packetin_match_table();
+    exit( EXIT_FAILURE );
+  }
+
+  set_packet_in_handler( handle_packet_in, NULL );
+  add_message_requested_callback( PACKETIN_FILTER_MANAGEMENT_SERVICE, handle_request );
+
+  start_trema();
+
+  finalize_packetin_match_table();
+
+  return 0;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */