trema 0.1.3

data/src/switch_manager/README

@@ -0,0 +1,20 @@
+This directory includes OpenFlow switch management components:
+
+- Switch manager accepts connections from OpenFlow switches, then
+  delegates the accepted connections to a switch daemon.
+
+- Switch daemon starts a new secure channel with a OpenFlow switch.
+
+
+    connect
+  .-------------------------------------------.
+  v                                           |
++---------+           +--------+            +----------+
+| switch  |  1    *   | switch |  1      1  | openflow |
+| manager | --------> | daemon | <--------> |  switch  |
++---------+ fork and  +--------+  openflow  +----------+
+            exec          ^       messages
+                          |
+                          | packet in, etc.
+                          v
+                     trema apps

data/src/switch_manager/cookie_table.c

@@ -0,0 +1,292 @@
+/*
+ * 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 <inttypes.h>
+#include <openflow.h>
+#include <string.h>
+#include "cookie_table.h"
+#include "trema.h"
+
+
+static cookie_table_t cookie_table;
+static uint64_t cookie_dough = 0;
+static uint64_t INVALID_COOKIE = UINT64_MAX;
+static const time_t COOKIE_ENTRY_LIFETIME = 86400 * 30;
+static const unsigned int BUCKETS_SIZE = 131063;
+
+
+static uint64_t
+generate_cookie( void ) {
+  uint64_t initial_value = ( cookie_dough != ( INVALID_COOKIE - 1 ) ) ? ++cookie_dough : 1;
+
+  cookie_dough = initial_value;
+  while ( lookup_cookie_entry_by_cookie( &cookie_dough ) != NULL ) {
+    if ( cookie_dough != ( INVALID_COOKIE - 1 ) ) {
+      cookie_dough++;
+    }
+    else {
+      cookie_dough = 1;
+    }
+    if ( initial_value == cookie_dough ) {
+      error( "Failed to generate cookie value." );
+      cookie_dough = RESERVED_COOKIE;
+      break;
+    }
+  }
+
+  return cookie_dough;
+}
+
+
+static bool
+compare_cookie( const void *x, const void *y ) {
+  return ( *( ( const uint64_t * ) x ) == *( ( const uint64_t * ) y ) ? true : false );
+}
+
+
+static unsigned int
+hash_cookie_entry( const void *key ) {
+  return hash_core( key, ( int ) sizeof( uint64_t ) );
+}
+
+
+static bool
+compare_application( const void *x, const void *y ) {
+  const application_entry_t *ex = x;
+  const application_entry_t *ey = y;
+
+  if ( ex->cookie != ey->cookie ) {
+    return false;
+  }
+  if ( strcmp( ex->service_name, ey->service_name ) != 0 ) {
+    return false;
+  }
+  return true;
+}
+
+
+static unsigned int
+hash_application( const void *key ) {
+  return hash_core( key, ( int ) sizeof( uint64_t ) );
+}
+
+
+static cookie_entry_t *
+allocate_cookie_entry( uint64_t *original_cookie, char *service_name, uint16_t flags ) {
+  cookie_entry_t *new_entry;
+
+  new_entry = xmalloc( sizeof ( cookie_entry_t ) );
+  memset( new_entry, 0, sizeof( cookie_entry_t ) );
+
+  new_entry->cookie = generate_cookie();
+  new_entry->application.cookie = *original_cookie;
+
+  if ( strlen( service_name ) + 1 > MESSENGER_SERVICE_NAME_LENGTH ) {
+    warn( "Too long service name ( service_name = %s ).", service_name );
+  }
+  strncpy( new_entry->application.service_name, service_name, MESSENGER_SERVICE_NAME_LENGTH );
+  new_entry->application.service_name[ MESSENGER_SERVICE_NAME_LENGTH - 1 ] = '\0';
+
+  new_entry->application.flags = flags;
+  new_entry->reference_count = 1;
+  new_entry->expire_at = time( NULL ) + COOKIE_ENTRY_LIFETIME;
+
+  return new_entry;
+}
+
+
+static void
+free_cookie_entry( cookie_entry_t *free_entry ) {
+  xfree( free_entry );
+}
+
+
+static void
+free_cookie_table_walker( void *key, void *value, void *user_data ) {
+  cookie_entry_t *entry = value;
+
+  UNUSED( key );
+  UNUSED( user_data );
+
+  free_cookie_entry( entry );
+}
+
+
+void
+init_cookie_table( void ) {
+  cookie_table.global = create_hash_with_size( compare_cookie, hash_cookie_entry, BUCKETS_SIZE );
+  cookie_table.application = create_hash_with_size( compare_application, hash_application, BUCKETS_SIZE );
+}
+
+
+void
+finalize_cookie_table( void ) {
+  foreach_hash( cookie_table.global, free_cookie_table_walker, NULL );
+  delete_hash( cookie_table.global );
+  delete_hash( cookie_table.application );
+  cookie_table.global = NULL;
+  cookie_table.application = NULL;
+}
+
+
+uint64_t *
+insert_cookie_entry( uint64_t *original_cookie, char *service_name, uint16_t flags ) {
+  cookie_entry_t *new_entry, *conflict_entry;
+
+  debug( "Inserting cookie entry ( original_cookie = %#" PRIx64 ", service_name = %s, flags = %#x ).",
+         *original_cookie, service_name, flags );
+
+  new_entry = lookup_cookie_entry_by_application( original_cookie, service_name );
+  if ( new_entry != NULL ) {
+    new_entry->reference_count++;
+    new_entry->expire_at = time( NULL ) + COOKIE_ENTRY_LIFETIME;
+    new_entry->application.flags |= flags; // FIXME: save flags for each flow individually
+
+    return &new_entry->cookie;
+  }
+
+  new_entry = allocate_cookie_entry( original_cookie, service_name, flags );
+  conflict_entry = lookup_cookie_entry_by_cookie( &new_entry->cookie );
+  if ( conflict_entry != NULL ) {
+    warn( "Conflicted cookie ( cookie = %#" PRIx64 " ).", new_entry->cookie );
+    delete_cookie_entry( conflict_entry );
+  }
+  insert_hash_entry( cookie_table.global, &new_entry->cookie, new_entry );
+  insert_hash_entry( cookie_table.application, &new_entry->application, new_entry );
+
+  return &new_entry->cookie;
+}
+
+
+void
+delete_cookie_entry( cookie_entry_t *entry ) {
+  debug( "Deleting cookie entry ( cookie = %#" PRIx64 ", application = [ cookie = %#" PRIx64 ", service_name = %s, "
+         "flags = %#x ], reference_count = %d, expire_at = %u ).",
+         entry->cookie, entry->application.cookie, entry->application.service_name,
+         entry->application.flags, entry->reference_count, entry->expire_at );
+
+  if ( entry->reference_count > 1 ) {
+    debug( "Decrementing reference counter ( reference_count = %d ).", entry->reference_count );
+    entry->reference_count--;
+    return;
+  }
+
+  cookie_entry_t *delete_entry_global = delete_hash_entry( cookie_table.global, &entry->cookie );
+  if ( delete_entry_global == NULL ) {
+    error( "No cookie entry found ( cookie = %#" PRIx64 " ).", entry->cookie );
+  }
+  cookie_entry_t *delete_entry_application = delete_hash_entry( cookie_table.application, &entry->application );
+  if ( delete_entry_application == NULL ) {
+    error( "No cookie entry found ( cookie = %#" PRIx64 ", service_name = %s ).",
+           entry->application.cookie, entry->application.service_name );
+  }
+
+  free_cookie_entry( entry );
+}
+
+
+cookie_entry_t *
+lookup_cookie_entry_by_cookie( uint64_t *cookie ) {
+  return lookup_hash_entry( cookie_table.global, cookie );
+}
+
+
+cookie_entry_t *
+lookup_cookie_entry_by_application( uint64_t *cookie, char *service_name ) {
+  application_entry_t key;
+  cookie_entry_t *entry;
+
+  memset( &key, 0, sizeof( application_entry_t ) );
+  key.cookie = *cookie;
+  strncpy( key.service_name, service_name, MESSENGER_SERVICE_NAME_LENGTH );
+  key.service_name[ MESSENGER_SERVICE_NAME_LENGTH - 1 ] = '\0';
+
+  entry = lookup_hash_entry( cookie_table.application, &key );
+
+  return entry;
+}
+
+
+static void
+age_cookie_entry( cookie_entry_t *entry ) {
+  if ( entry->expire_at < time( NULL ) ) {
+    // TODO: check if the target flow is still alive or not
+    warn( "Aging out cookie entry ( cookie = %#" PRIx64 ", application = [ cookie = %#" PRIx64 ", service_name = %s, "
+          "flags = %#x ], reference_count = %d, expire_at = %u ).",
+          entry->cookie, entry->application.cookie, entry->application.service_name,
+          entry->application.flags, entry->reference_count, entry->expire_at );
+
+    delete_hash_entry( cookie_table.global, &entry->cookie );
+    delete_hash_entry( cookie_table.application, &entry->application );
+    free_cookie_entry( entry );
+  }
+}
+
+
+void
+age_cookie_table( void *user_data ) {
+  UNUSED( user_data );
+
+  hash_iterator iter;
+  hash_entry *e;
+
+  init_hash_iterator( cookie_table.global, &iter );
+  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
+    age_cookie_entry( e->value );
+  }
+}
+
+
+static void
+dump_cookie_entry( cookie_entry_t *entry ) {
+  info( "cookie = %#" PRIx64 ", application = [ cookie = %#" PRIx64 ", service_name = %s, "
+        "flags = %#x ], reference_count = %d, expire_at = %u",
+        entry->cookie, entry->application.cookie, entry->application.service_name,
+        entry->application.flags, entry->reference_count, entry->expire_at );
+}
+
+
+void
+dump_cookie_table( void ) {
+  hash_iterator iter;
+  hash_entry *e;
+
+  info( "#### COOKIE TABLE ####" );
+  info( "[global]" );
+  init_hash_iterator( cookie_table.global, &iter );
+  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
+    dump_cookie_entry( e->value );
+  }
+
+  info( "[application]" );
+  init_hash_iterator( cookie_table.application, &iter );
+  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
+    dump_cookie_entry( e->value );
+  }
+  info( "#### END ####" );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/cookie_table.h

@@ -0,0 +1,72 @@
+/*
+ * OpenFlow Switch Manager
+ *
+ * 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.
+ */
+
+
+#ifndef COOKIE_TABLE_H
+#define COOKIE_TABLE_H
+
+
+#include <limits.h>
+#include <time.h>
+#include "trema.h"
+
+
+#define RESERVED_COOKIE 0
+
+
+typedef struct application_entry {
+  uint64_t cookie;
+  char service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+  uint16_t flags;
+} application_entry_t;
+
+typedef struct cookie_entry {
+  uint64_t cookie;
+  application_entry_t application;
+  int reference_count;
+  time_t expire_at;
+} cookie_entry_t;
+
+typedef struct cookie_table {
+  hash_table *global;
+  hash_table *application;
+} cookie_table_t;
+
+
+void init_cookie_table( void );
+void finalize_cookie_table( void );
+uint64_t *insert_cookie_entry( uint64_t *original_cookie, char *service_name, uint16_t flags );
+void delete_cookie_entry( cookie_entry_t *entry );
+cookie_entry_t *lookup_cookie_entry_by_cookie( uint64_t *cookie );
+cookie_entry_t *lookup_cookie_entry_by_application( uint64_t *cookie, char *service_name );
+void age_cookie_table( void *user_data );
+void dump_cookie_table( void );
+
+
+#endif // COOKIE_TABLE_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/dpid_table.c

@@ -0,0 +1,110 @@
+/*
+ * 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 <assert.h>
+#include <string.h>
+#include <inttypes.h>
+#include "trema.h"
+#include "dpid_table.h"
+
+
+static hash_table *dpid_table = NULL;
+
+
+void
+init_dpid_table( void ) {
+  assert( dpid_table == NULL );
+  dpid_table = create_hash( compare_datapath_id, hash_datapath_id );
+}
+
+
+static void
+free_dpid_table_walker( void *key, void *value, void *user_data ) {
+  UNUSED( key );
+  UNUSED( user_data );
+  xfree( value );
+}
+
+
+void
+finalize_dpid_table( void ) {
+  assert( dpid_table != NULL );
+
+  foreach_hash( dpid_table, free_dpid_table_walker, NULL );
+  delete_hash( dpid_table );
+  dpid_table = NULL;
+}
+
+
+void
+insert_dpid_entry( uint64_t *dpid ) {
+  assert( dpid_table != NULL );
+  assert( dpid != NULL );
+
+  if ( lookup_hash_entry( dpid_table, dpid ) != NULL ) {
+    warn( "datapath %#" PRIx64 " is already registered.", *dpid );
+    return;
+  }
+
+  uint64_t *new_entry = xmalloc( sizeof ( uint64_t ) );
+  *new_entry = *dpid;
+  insert_hash_entry( dpid_table, new_entry, new_entry );
+}
+
+
+void
+delete_dpid_entry( uint64_t *dpid ) {
+  assert( dpid_table != NULL );
+  assert( dpid != NULL );
+
+  uint64_t *deleted_entry = delete_hash_entry( dpid_table, dpid );
+  if ( deleted_entry == NULL ) {
+    warn( "datapath %#" PRIx64 " is not found.", *dpid );
+    return;
+  }
+
+  xfree( deleted_entry );
+}
+
+
+buffer *
+get_switches( void ) {
+  assert( dpid_table != NULL );
+
+  buffer *buf = alloc_buffer_with_length( sizeof( uint64_t ) );
+
+  hash_iterator iter;
+  hash_entry *entry;
+  init_hash_iterator( dpid_table, &iter );
+  while ( ( entry = iterate_hash_next( &iter ) ) != NULL ) {
+    uint64_t *dpid = append_back_buffer( buf, sizeof( uint64_t ) );
+    *dpid = htonll( *( uint64_t * )( entry->value ) );
+  }
+
+  return buf;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */