trema 0.2.2.1 → 0.2.3

data/src/lib/chibach.h

@@ -0,0 +1,71 @@
+/*
+ * Chibach common functions.
+ *
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>, Yasunobu Chiba
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#ifndef CHIBACH_H
+#define CHIBACH_H
+
+
+#include "bool.h"
+#include "buffer.h"
+#include "byteorder.h"
+#include "checks.h"
+#include "doubly_linked_list.h"
+#include "ether.h"
+#include "event_handler.h"
+#include "hash_table.h"
+#include "linked_list.h"
+#include "log.h"
+#include "match.h"
+#include "match_table.h"
+#include "message_queue.h"
+#include "messenger.h"
+#include "openflow_service_interface.h"
+#include "openflow_switch_interface.h"
+#include "openflow_message.h"
+#include "packet_info.h"
+#include "stat.h"
+#include "timer.h"
+#include "utility.h"
+#include "wrapper.h"
+
+
+void init_chibach( int *argc, char ***argv );
+void start_chibach( void );
+void stop_chibach( void );
+void flush( void );
+const char *get_chibach_home( void );
+const char *get_chibach_tmp( void );
+const char *get_chibach_name( void );
+void set_chibach_name( const char *name );
+__attribute__( ( weak ) ) void usage( void );
+uint64_t get_datapath_id( void );
+
+
+#endif // CHIBACH_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/chibach_private.c

@@ -0,0 +1,170 @@
+/*
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>, Yasunobu Chiba
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "bool.h"
+#include "chibach_private.h"
+#include "log.h"
+#include "trema_wrapper.h"
+#include "wrapper.h"
+
+
+static const char CHIBACH_HOME[] = "CHIBACH_HOME";
+static const char CHIBACH_TMP[] = "CHIBACH_TMP";
+static char *chibach_home = NULL;
+static char *chibach_tmp = NULL;
+
+
+static bool
+expand( const char *path, char *absolute_path ) {
+  assert( path != NULL );
+  assert( absolute_path != NULL );
+
+  char buf[ 256 ];
+  char *result = realpath( path, absolute_path );
+  if ( result == NULL ) {
+    trema_fprintf( stderr, "Could not get the absolute path of %s: %s.\n", path, strerror_r( errno, buf, sizeof( buf ) ) );
+    return false;
+  }
+
+  return true;
+}
+
+
+/**
+ * Sets chibach home directory for your chibach session.
+ */
+void
+set_chibach_home( void ) {
+  if ( getenv( CHIBACH_HOME ) == NULL ) {
+    setenv( CHIBACH_HOME, "/", 1 );
+    chibach_home = xstrdup( "/" );
+  }
+  else {
+    char absolute_path[ PATH_MAX ];
+    if ( !expand( getenv( CHIBACH_HOME ), absolute_path ) ) {
+      trema_fprintf( stderr, "Falling back CHIBACH_HOME to \"/\".\n" );
+      strncpy( absolute_path, "/", 2 );
+    }
+    setenv( CHIBACH_HOME, absolute_path, 1 );
+    chibach_home = xstrdup( absolute_path );
+  }
+}
+
+
+/**
+ * Returns chibach home directory used in your chibach session.
+ */
+const char *
+get_chibach_home( void ) {
+  if ( chibach_home == NULL ) {
+    set_chibach_home();
+  }
+  return chibach_home;
+}
+
+
+/**
+ * Unsets chibach home directory used in your chibach session.
+ */
+void unset_chibach_home( void ) {
+  if ( chibach_home != NULL ) {
+    xfree( chibach_home );
+    chibach_home = NULL;
+  }
+}
+
+
+/**
+ * Sets temporary directory for your Chibach session.
+ */
+void
+set_chibach_tmp( void ) {
+  char path[ PATH_MAX ];
+
+  if ( getenv( CHIBACH_TMP ) == NULL ) {
+    const char *chibach_home = get_chibach_home();
+    if ( chibach_home[ strlen( chibach_home ) - 1 ] == '/' ) {
+      snprintf( path, PATH_MAX, "%stmp", chibach_home );
+    }
+    else {
+      snprintf( path, PATH_MAX, "%s/tmp", chibach_home );
+    }
+    path[ PATH_MAX - 1 ] = '\0';
+  }
+  else {
+    if ( !expand( getenv( CHIBACH_TMP ), path ) ) {
+      trema_fprintf( stderr, "Falling back CHIBACH_TMP to \"/tmp\".\n" );
+      strncpy( path, "/tmp", 5 );
+    }
+  }
+
+  chibach_tmp = xstrdup( path );
+  setenv( CHIBACH_TMP, chibach_tmp, 1 );
+}
+
+
+/**
+ * Returns temporary directory used in your Chibach session.
+ */
+const char *
+get_chibach_tmp( void ) {
+  if ( chibach_tmp == NULL ) {
+    set_chibach_tmp();
+  }
+  return chibach_tmp;
+}
+
+
+/**
+ * Unsets temporary directory used in your Chibach session.
+ */
+void unset_chibach_tmp( void ) {
+  if ( chibach_tmp != NULL ) {
+    xfree( chibach_tmp );
+    chibach_tmp = NULL;
+  }
+}
+
+
+const char *
+_get_chibach_home( void ) {
+  return chibach_home;
+}
+
+
+const char *
+_get_chibach_tmp( void ) {
+  return chibach_tmp;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/chibach_private.h

@@ -0,0 +1,52 @@
+/*
+ * Private functions that are only called from [chibach]/src/lib.
+ *
+ * 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 CHIBACH_PRIVATE_H
+#define CHIBACH_PRIVATE_H
+
+
+#include "bool.h"
+
+
+void set_chibach_home( void );
+const char *get_chibach_home( void );
+void unset_chibach_home( void );
+
+void set_chibach_tmp( void );
+const char *get_chibach_tmp( void );
+void unset_chibach_tmp( void );
+
+const char *get_chibach_name( void );
+
+const char *_get_chibach_home( void );
+const char *_get_chibach_tmp( void );
+
+
+#endif // CHIBACH_PRIVATE_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/ether.c

@@ -34,7 +34,8 @@ fill_ether_padding( buffer *buf ) {
     padding_length = ETH_MINIMUM_LENGTH - buf->length - ETH_FCS_LENGTH;
     debug( "Adding %u octets padding ( original frame length = %u ).", 
            buf->length, padding_length );
-    append_back_buffer( buf, padding_length );
+    void *padding = append_back_buffer( buf, padding_length );
+    memset( padding, 0, padding_length );
   }
   return ( uint16_t ) padding_length;
 }

data/src/lib/ether.h

@@ -24,7 +24,6 @@
 #define ETHER_H
 
 
-#include <endian.h>
 #include <stdint.h>
 #include "bool.h"
 #include "buffer.h"

data/src/lib/ipv4.h

@@ -24,27 +24,26 @@
 #define IPV4_H
 
 
-#include <netinet/ip.h>
 #include "buffer.h"
 
 
 typedef struct  {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-  unsigned int ihl:4;
-  unsigned int version:4;
+  uint8_t ihl:4;
+  uint8_t version:4;
 #elif __BYTE_ORDER == __BIG_ENDIAN
-  unsigned int version:4;
-  unsigned int ihl:4;
+  uint8_t version:4;
+  uint8_t ihl:4;
 #endif
-  u_int8_t tos;
-  u_int16_t tot_len;
-  u_int16_t id;
-  u_int16_t frag_off;
-  u_int8_t ttl;
-  u_int8_t protocol;
-  u_int16_t csum;
-  u_int32_t saddr;
-  u_int32_t daddr;
+  uint8_t tos;
+  uint16_t tot_len;
+  uint16_t id;
+  uint16_t frag_off;
+  uint8_t ttl;
+  uint8_t protocol;
+  uint16_t csum;
+  uint32_t saddr;
+  uint32_t daddr;
 } ipv4_header_t;
 
 

data/{ruby/trema/action-set-nw-src.h → src/lib/ipv6.h}

@@ -1,5 +1,5 @@
 /*
- * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
+ * IPv6 header definitions
  *
  * Copyright (C) 2008-2012 NEC Corporation
  *
@@ -18,20 +18,24 @@
  */
 
 
-#ifndef ACTION_SET_NW_SRC_H
-#define ACTION_SET_NW_SRC_H
+#ifndef IPV6_H
+#define IPV6_H
 
 
-#include "ruby.h"
+#define IPV6_ADDRLEN 16
 
 
-extern VALUE cActionSetNwSrc;
+typedef struct  {
+  uint32_t hdrctl;
+  uint16_t plen;
+  uint8_t nexthdr;
+  uint8_t hoplimit;
+  uint8_t saddr[ IPV6_ADDRLEN ];
+  uint8_t daddr[ IPV6_ADDRLEN ];
+} ipv6_header_t;
 
 
-void Init_action_set_nw_src( void );
-
-
-#endif // ACTION_SET_NW_SRC_H
+#endif // IPV6_H
 
 
 /*

data/src/lib/log.c

@@ -25,6 +25,7 @@
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
+#include <syslog.h>
 #include <time.h>
 #include "bool.h"
 #include "log.h"
@@ -34,32 +35,35 @@
 
 typedef struct {
   const char *name;
-  const logging_level value;
+  const int value;
 } priority;
 
 
+static bool initialized = false;
 static FILE *fd = NULL;
-static logging_level level = -1;
-static bool daemonized = false;
+static int level = -1;
+static char ident_string[ PATH_MAX ];
+static char log_directory[ PATH_MAX ];
+static logging_type output = LOGGING_TYPE_FILE;
 static pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 
 
 static priority priorities[][ 3 ] = {
   {
-    { .name = "critical", .value = LOG_CRITICAL },
-    { .name = "crit", .value = LOG_CRITICAL },
+    { .name = "critical", .value = LOG_CRIT },
+    { .name = "crit", .value = LOG_CRIT },
     { .name = NULL },
   },
 
   {
-    { .name = "error", .value = LOG_ERROR },
-    { .name = "err", .value = LOG_ERROR },
+    { .name = "error", .value = LOG_ERR },
+    { .name = "err", .value = LOG_ERR },
     { .name = NULL },
   },
 
   {
-    { .name = "warn", .value = LOG_WARN },
-    { .name = "warning", .value = LOG_WARN },
+    { .name = "warn", .value = LOG_WARNING },
+    { .name = "warning", .value = LOG_WARNING },
     { .name = NULL },
   },
 
@@ -83,8 +87,8 @@ static priority priorities[][ 3 ] = {
 
 
 static const char *
-priority_name_from( logging_level level ) {
-  const char *name = priorities[ level ][ 0 ].name;
+priority_name_from( int level ) {
+  const char *name = priorities[ level - LOG_CRIT ][ 0 ].name;
   assert( name != NULL );
   return name;
 }
@@ -93,7 +97,7 @@ priority_name_from( logging_level level ) {
 static const size_t max_message_length = 1024;
 
 static void
-log_file( logging_level priority, const char *format, va_list ap ) {
+log_file( int priority, const char *format, va_list ap ) {
   time_t tm = time( NULL );
   char now[ 26 ];
   asctime_r( localtime( &tm ), now );
@@ -122,13 +126,61 @@ log_stdout( const char *format, va_list ap ) {
 }
 
 
-static FILE*
-open_log( const char *ident, const char *log_directory, bool append ) {
+static void
+log_syslog( int priority, const char *format, va_list ap ) {
+  trema_vsyslog( priority, format, ap );
+}
+
+
+static void
+unset_ident_string() {
+  memset( ident_string, '\0', sizeof( ident_string ) );
+}
+
+
+static void
+set_ident_string( const char *ident ) {
   assert( ident != NULL );
-  assert( log_directory != NULL );
+
+  unset_ident_string();
+  strncpy( ident_string, ident, sizeof( ident_string ) - 1 );
+}
+
+
+static const char *
+get_ident_string() {
+  return ident_string;
+}
+
+
+static void
+unset_log_directory() {
+  memset( log_directory, '\0', sizeof( log_directory ) );
+}
+
+
+static void
+set_log_directory( const char *directory ) {
+  assert( directory != NULL );
+
+  unset_log_directory();
+  strncpy( log_directory, directory, sizeof( log_directory ) - 1 );
+}
+
+
+static const char *
+get_log_directory() {
+  return log_directory;
+}
+
+
+static FILE*
+open_log_file( bool append ) {
+  assert( strlen( get_log_directory() ) > 0 );
+  assert( strlen( get_ident_string() ) > 0 );
 
   char pathname[ PATH_MAX ];
-  sprintf( pathname, "%s/%s.log", log_directory, ident );
+  sprintf( pathname, "%s/%s.log", get_log_directory(), get_ident_string() );
   FILE *log = fopen( pathname, append ? "a" : "w" );
 
   if ( log == NULL ) {
@@ -142,27 +194,51 @@ open_log( const char *ident, const char *log_directory, bool append ) {
 }
 
 
+static void
+open_log_syslog() {
+  assert( strlen( get_ident_string() ) > 0 );
+
+  trema_openlog( get_ident_string(), LOG_NDELAY, LOG_USER );
+}
+
+
 /**
  * Initializes the Logger. This creates a log file to which messages
  * are written.
  *
  * @param ident name of the log file, used as an identifier.
  * @param log_directory the directory in which log file is created.
- * @param run_as_daemon determines if messages should be reported to terminal as well.
+ * @param type log output type.
  * @return true on success; false otherwise.
  */
 bool
-init_log( const char *ident, const char *log_directory, bool run_as_daemon ) {
+init_log( const char *ident, const char *directory, logging_type type ) {
+  assert( ident != NULL );
+  assert( directory != NULL );
+
   pthread_mutex_lock( &mutex );
 
-  level = LOG_INFO;
+  // set_logging_level() may be called before init_log().
+  // level = -1 indicates that logging level is not set yet.
+  if ( level < 0 || level > LOG_DEBUG ) {
+    level = LOG_INFO;
+  }
   char *level_string = getenv( "LOGGING_LEVEL" );
   if ( level_string != NULL ) {
     set_logging_level( level_string );
   }
 
-  daemonized = run_as_daemon;
-  fd = open_log( ident, log_directory, false );
+  set_ident_string( ident );
+  set_log_directory( directory );
+  output = type;
+  if ( output & LOGGING_TYPE_FILE ) {
+    fd = open_log_file( false );
+  }
+  if ( output & LOGGING_TYPE_SYSLOG ) {
+    open_log_syslog();
+  }
+
+  initialized = true;
 
   pthread_mutex_unlock( &mutex );
 
@@ -171,35 +247,51 @@ init_log( const char *ident, const char *log_directory, bool run_as_daemon ) {
 
 
 void
-restart_log( const char *ident, const char *log_directory ) {
+restart_log( const char *new_ident ) {
   pthread_mutex_lock( &mutex );
 
-  if ( fd != NULL ) {
-    fclose( fd );
+  if ( new_ident != NULL ) {
+    set_ident_string( new_ident );
+  }
+
+  if ( output & LOGGING_TYPE_FILE ) {
+    if ( fd != NULL ) {
+      fclose( fd );
+    }
+    fd = open_log_file( true );
+  }
+  if ( output & LOGGING_TYPE_SYSLOG ) {
+    trema_closelog();
+    open_log_syslog();
   }
-  fd = open_log( ident, log_directory, true );
 
   pthread_mutex_unlock( &mutex );
 }
 
 
 void
-rename_log( const char *old_ident, const char *new_ident, const char *directory ) {
-  assert( directory != NULL );
-  assert( old_ident != NULL );
+rename_log( const char *new_ident ) {
   assert( new_ident != NULL );
 
-  char old_path[ PATH_MAX ];
-  snprintf( old_path, PATH_MAX, "%s/%s.log", directory, old_ident );
-  old_path[ PATH_MAX - 1 ] = '\0';
-  char new_path[ PATH_MAX ];
-  snprintf( new_path, PATH_MAX, "%s/%s.log", directory, new_ident );
-  new_path[ PATH_MAX - 1 ] = '\0';
-
-  unlink( new_path );
-  int ret = rename( old_path, new_path );
-  if ( ret < 0 ) {
-    die( "Could not rename a log file from %s to %s.", old_path, new_path );
+  if ( output & LOGGING_TYPE_FILE ) {
+    char old_path[ PATH_MAX ];
+    snprintf( old_path, PATH_MAX, "%s/%s.log", get_log_directory(), get_ident_string() );
+    old_path[ PATH_MAX - 1 ] = '\0';
+    char new_path[ PATH_MAX ];
+    set_ident_string( new_ident );
+    snprintf( new_path, PATH_MAX, "%s/%s.log", get_log_directory(), get_ident_string() );
+    new_path[ PATH_MAX - 1 ] = '\0';
+
+    unlink( new_path );
+    int ret = rename( old_path, new_path );
+    if ( ret < 0 ) {
+      die( "Could not rename a log file from %s to %s.", old_path, new_path );
+    }
+  }
+  if ( output & LOGGING_TYPE_SYSLOG ) {
+    trema_closelog();
+    set_ident_string( new_ident );
+    open_log_syslog();
   }
 }
 
@@ -214,11 +306,22 @@ finalize_log() {
   pthread_mutex_lock( &mutex );
 
   level = -1;
-  if ( fd != NULL ) {
-    fclose( fd );
-    fd = NULL;
+
+  if ( output & LOGGING_TYPE_FILE ) {
+    if ( fd != NULL ) {
+      fclose( fd );
+      fd = NULL;
+    }
+  }
+  if ( output & LOGGING_TYPE_SYSLOG ) {
+    trema_closelog();
   }
 
+  unset_ident_string();
+  unset_log_directory();
+
+  initialized = false;
+
   pthread_mutex_unlock( &mutex );
 
   return true;
@@ -242,7 +345,7 @@ priority_value_from( const char *name ) {
   int level_value = -1;
   char *name_lower = lower( name );
 
-  for ( int i = 0; i <= LOG_DEBUG; i++ ) {
+  for ( int i = 0; i <= ( LOG_DEBUG - LOG_CRIT ); i++ ) {
     for ( priority *p = priorities[ i ]; p->name != NULL; p++ ) {
       if ( strncmp( p->name, name_lower, 20 ) == 0 ) {
         level_value = p->value;
@@ -257,12 +360,7 @@ priority_value_from( const char *name ) {
 
 static bool
 started() {
-  if ( fd == NULL ) {
-    return false;
-  }
-  else {
-    return true;
-  }
+  return initialized;
 }
 
 
@@ -288,19 +386,24 @@ set_logging_level( const char *name ) {
 }
 
 
-static logging_level
+static int
 _get_logging_level() {
   return level;
 }
-logging_level ( *get_logging_level )( void ) = _get_logging_level;
+int ( *get_logging_level )( void ) = _get_logging_level;
 
 
 static void
-do_log( logging_level priority, const char *format, va_list ap ) {
+do_log( int priority, const char *format, va_list ap ) {
   assert( started() );
 
-  log_file( priority, format, ap );
-  if ( !daemonized ) {
+  if ( output & LOGGING_TYPE_FILE ) {
+    log_file( priority, format, ap );
+  }
+  if ( output & LOGGING_TYPE_SYSLOG ) {
+    log_syslog( priority, format, ap );
+  }
+  if ( output & LOGGING_TYPE_STDOUT ) {
     log_stdout( format, ap );
   }
 }
@@ -311,7 +414,7 @@ do_log( logging_level priority, const char *format, va_list ap ) {
     if ( _format == NULL ) {                            \
       trema_abort();                                    \
     }                                                   \
-    if ( ( int ) get_logging_level() >= _priority ) {   \
+    if ( get_logging_level() >= _priority ) {           \
       pthread_mutex_lock( &mutex );                     \
       va_list _args;                                    \
       va_start( _args, _format );                       \
@@ -324,7 +427,7 @@ do_log( logging_level priority, const char *format, va_list ap ) {
 
 static void
 _critical( const char *format, ... ) {
-  DO_LOG( LOG_CRITICAL, format );
+  DO_LOG( LOG_CRIT, format );
 }
 /**
  * Logs an critical message.
@@ -336,7 +439,7 @@ void ( *critical )( const char *format, ... ) = _critical;
 
 static void
 _error( const char *format, ... ) {
-  DO_LOG( LOG_ERROR, format );
+  DO_LOG( LOG_ERR, format );
 }
 /**
  * Logs an error message.
@@ -348,7 +451,7 @@ void ( *error )( const char *format, ... ) = _error;
 
 static void
 _warn( const char *format, ... ) {
-  DO_LOG( LOG_WARN, format );
+  DO_LOG( LOG_WARNING, format );
 }
 /**
  * Logs a warning message.