trema 0.2.6 → 0.2.7

data/ruby/trema/command/run.rb

@@ -35,7 +35,7 @@ module Trema
         $use_tremashark = true
       end
 
-      cleanup_current_session
+      need_cleanup = ( not running? )
 
       if $run_as_daemon
         Trema::DSL::Runner.new( load_config ).daemonize
@@ -45,7 +45,7 @@ module Trema
         rescue SystemExit
           # This is OK
         ensure
-          cleanup_current_session
+          cleanup_current_session if need_cleanup
         end
       end
     end

data/ruby/trema/controller.c

@@ -488,7 +488,7 @@ controller_send_packet_out( int argc, VALUE *argv, VALUE self ) {
     VALUE opt_data = rb_hash_aref( options, ID2SYM( rb_intern( "data" ) ) );
     if ( opt_data != Qnil ) {
       Check_Type( opt_data, T_STRING );
-      uint16_t length = ( u_int16_t ) RSTRING_LEN( opt_data );
+      uint16_t length = ( uint16_t ) RSTRING_LEN( opt_data );
       allocated_data = alloc_buffer_with_length( length );
       memcpy( append_back_buffer( allocated_data, length ), RSTRING_PTR( opt_data ), length );
       data = allocated_data;

data/ruby/trema/dsl/runner.rb

@@ -44,6 +44,9 @@ module Trema
 
 
       def maybe_run_switch_manager
+        # FIXME
+        return if FileTest.exists? File.join( Trema.pid, "switch_manager.pid" )
+
         switch_manager =
           if @context.switch_manager and @context.apps.values.size > 0
             last_app = @context.apps.values.last.name

data/ruby/trema/echo.c

@@ -61,9 +61,9 @@ echo_init( int argc, VALUE *argv, VALUE self ) {
       VALUE user_data = rb_hash_aref( options, ID2SYM( rb_intern( "user_data" ) ) );
       if ( user_data != Qnil ) {
         Check_Type( user_data, T_STRING );
-        uint16_t length = ( u_int16_t ) RSTRING_LEN( user_data );
+        uint16_t length = ( uint16_t ) RSTRING_LEN( user_data );
         append_back_buffer( echo, length );
-        set_length( echo, length );
+        set_length( echo, ( uint16_t ) ( sizeof( struct ofp_header ) + length ) );
         memcpy( ( char * ) echo->data + sizeof( struct ofp_header ), RSTRING_PTR( user_data ), length );
       }
     }

data/ruby/trema/error.c

@@ -115,7 +115,7 @@ error_init( int argc, VALUE *argv, VALUE self ) {
     VALUE data = rb_hash_aref( options, ID2SYM( rb_intern( "data" ) ) );
     if ( data != Qnil ) {
       Check_Type( data, T_STRING );
-      uint16_t length = ( u_int16_t ) RSTRING_LEN( data );
+      uint16_t length = ( uint16_t ) RSTRING_LEN( data );
       append_back_buffer( error, length );
       ( ( struct ofp_header * ) ( error->data ) )->length = htons( ( uint16_t ) ( offsetof( struct ofp_error_msg, data ) + length ) );
       memcpy( ( char * ) error->data + offsetof( struct ofp_error_msg, data ), RSTRING_PTR( data ), length );

data/ruby/trema/features-reply.c

@@ -91,12 +91,12 @@ features_reply_init( VALUE self, VALUE options ) {
       rb_raise( rb_eArgError, ":transaction_id is a mandatory option" );
     }
   }
-  features_reply->header.xid = htonl( NUM2UINT( tmp ) );
+  features_reply->header.xid = htonl( ( uint32_t ) NUM2UINT( tmp ) );
 
   features_reply->n_buffers = 0;
   tmp = rb_hash_aref( options, ID2SYM( rb_intern( "n_buffers" ) ) );
   if ( tmp != Qnil ) {
-    features_reply->n_buffers = htonl( NUM2UINT( tmp ) );
+    features_reply->n_buffers = htonl( ( uint32_t ) NUM2UINT( tmp ) );
   }
 
   features_reply->n_tables = 1;
@@ -108,13 +108,13 @@ features_reply_init( VALUE self, VALUE options ) {
   features_reply->capabilities = 0;
   tmp = rb_hash_aref( options, ID2SYM( rb_intern( "capabilities" ) ) );
   if ( tmp != Qnil ) {
-    features_reply->capabilities = htonl( NUM2UINT( tmp ) );
+    features_reply->capabilities = htonl( ( uint32_t ) NUM2UINT( tmp ) );
   }
 
   features_reply->actions = htonl( 1 << OFPAT_OUTPUT );
   tmp = rb_hash_aref( options, ID2SYM( rb_intern( "actions" ) ) );
   if ( tmp != Qnil ) {
-    features_reply->actions = htonl( NUM2UINT( tmp ) );
+    features_reply->actions = htonl( ( uint32_t ) NUM2UINT( tmp ) );
   }
 
   // TODO: ports

data/ruby/trema/packet-in.c

@@ -49,25 +49,62 @@ VALUE cPacketIn;
   }
 
 
+typedef struct rb_packet_in {
+  packet_in packet_in;
+  buffer *data;
+} rb_packet_in;
+
+
+static void
+packet_in_free( rb_packet_in *_packet_in ) {
+  free_buffer( _packet_in->data );
+  xfree( _packet_in );
+}
+
+
 static VALUE
 packet_in_alloc( VALUE klass ) {
-  packet_in *_packet_in = xmalloc( sizeof( packet_in ) );
-  return Data_Wrap_Struct( klass, 0, xfree, _packet_in );
+  rb_packet_in *_packet_in = xmalloc( sizeof( rb_packet_in ) );
+  memset( &_packet_in->packet_in, 0, sizeof( packet_in ) );
+  _packet_in->data = alloc_buffer_with_length( 1 );
+  parse_packet( _packet_in->data );
+  _packet_in->packet_in.data = _packet_in->data;
+  return Data_Wrap_Struct( klass, 0, packet_in_free, _packet_in );
+}
+
+
+static VALUE
+packet_in_init_copy( VALUE self, VALUE orig ) {
+  if ( self == orig ) {
+    return self;
+  }
+
+  rb_packet_in *self_pin, *orig_pin;
+  Data_Get_Struct( self, rb_packet_in, self_pin );
+  Data_Get_Struct( self, rb_packet_in, orig_pin );
+
+  memcpy( &self_pin->packet_in, &orig_pin->packet_in, sizeof( packet_in ) );
+  free_buffer( self_pin->data );
+  self_pin->data = duplicate_buffer( orig_pin->data );
+  parse_packet( self_pin->data );
+  self_pin->packet_in.data = self_pin->data;
+
+  return self;
 }
 
 
 static packet_in *
 get_packet_in( VALUE self ) {
-  packet_in *cpacket;
-  Data_Get_Struct( self, packet_in, cpacket );
-  return cpacket;
+  rb_packet_in *cpacket;
+  Data_Get_Struct( self, rb_packet_in, cpacket );
+  return &cpacket->packet_in;
 }
 
 
 static packet_info *
 get_packet_in_info( VALUE self ) {
-  packet_in *cpacket;
-  Data_Get_Struct( self, packet_in, cpacket );
+  rb_packet_in *cpacket;
+  Data_Get_Struct( self, rb_packet_in, cpacket );
   return ( packet_info * ) cpacket->data->user_data;
 }
 
@@ -1046,6 +1083,8 @@ Init_packet_in() {
   cPacketIn = rb_define_class_under( mTrema, "PacketIn", rb_cObject );
   rb_define_alloc_func( cPacketIn, packet_in_alloc );
 
+  rb_define_method( cPacketIn, "initialize_copy", packet_in_init_copy, 1 );
+
   rb_define_method( cPacketIn, "datapath_id", packet_in_datapath_id, 0 );
   rb_define_method( cPacketIn, "transaction_id", packet_in_transaction_id, 0 );
   rb_define_method( cPacketIn, "buffer_id", packet_in_buffer_id, 0 );
@@ -1142,9 +1181,13 @@ handle_packet_in( uint64_t datapath_id, packet_in message ) {
   }
 
   VALUE r_message = rb_funcall( cPacketIn, rb_intern( "new" ), 0 );
-  packet_in *tmp = NULL;
-  Data_Get_Struct( r_message, packet_in, tmp );
-  memcpy( tmp, &message, sizeof( packet_in ) );
+  rb_packet_in *tmp = NULL;
+  Data_Get_Struct( r_message, rb_packet_in, tmp );
+  memcpy( &tmp->packet_in, &message, sizeof( packet_in ) );
+  free_buffer( tmp->data );
+  tmp->data = duplicate_buffer( message.data );
+  parse_packet( tmp->data );
+  tmp->packet_in.data = tmp->data;
 
   rb_funcall( controller, rb_intern( "packet_in" ), 2, ULL2NUM( datapath_id ), r_message );
 }

data/ruby/trema/trema-ruby-utils.c

@@ -37,7 +37,7 @@ get_xid( VALUE self ) {
 
 void
 set_length( const buffer *openflow_message, uint16_t length ) {
-  ( ( struct ofp_header * ) ( openflow_message->data ) )->length = htons( ( uint16_t ) ( sizeof( struct ofp_header ) + length ) );
+  ( ( struct ofp_header * ) ( openflow_message->data ) )->length = htons( length );
 }
 
 

data/ruby/trema/util.rb

@@ -75,6 +75,11 @@ EOF
   end
 
 
+  def running?
+    FileTest.exists? Trema::DSL::Context::PATH
+  end
+
+
   def cleanup_current_session
     begin
       cleanup Trema::DSL::Context.load_current

data/ruby/trema/vendor.c

@@ -110,7 +110,7 @@ vendor_init( int argc, VALUE *argv, VALUE self ) {
           Check_Type( tmp, T_ARRAY );
           uint16_t length = ( uint16_t ) RARRAY_LEN( tmp );
           append_back_buffer( vendor, length );
-          set_length( vendor, length );
+          set_length( vendor, ( uint16_t ) ( sizeof( struct ofp_vendor_header ) + length ) );
           uint8_t *data = ( uint8_t * ) ( ( char * ) vendor->data + sizeof( struct ofp_vendor_header ) );
           int i;
           for ( i = 0; i < length; i++ ) {
@@ -165,7 +165,7 @@ vendor_data( VALUE self ) {
   if ( length > 0 ) {
     VALUE data_array = rb_ary_new2( length );
     uint8_t *data = ( uint8_t * ) ( ( char * ) vendor->data + sizeof( struct ofp_vendor_header ) );
-    int i;
+    long i;
     for ( i = 0; i < length; i++ ) {
       rb_ary_push( data_array, INT2FIX( data[ i ] ) );
     }
@@ -205,8 +205,13 @@ handle_vendor(
   rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( transaction_id ) );
   rb_hash_aset( attributes, ID2SYM( rb_intern( "vendor" ) ), UINT2NUM( vendor ) );
 
-  if ( data->length ) {
-    rb_hash_aset( attributes, ID2SYM( rb_intern( "data" ) ), rb_str_new( data->data, ( long ) data->length ) );
+  if ( data != NULL && data->length > 0 ) {
+    VALUE data_array = rb_ary_new2( ( long ) data->length );
+    long i;
+    for ( i = 0; i < data->length; i++ ) {
+      rb_ary_push( data_array, INT2FIX( ( ( uint8_t * ) data->data)[ i ] ) );
+    }
+    rb_hash_aset( attributes, ID2SYM( rb_intern( "data" ) ), data_array );
   }
   VALUE vendor_r = rb_funcall( cVendor, rb_intern( "new" ), 1, attributes );
   rb_funcall( controller, rb_intern( "vendor" ), 2, ULL2NUM( datapath_id ), vendor_r );

data/ruby/trema/version.rb

@@ -17,7 +17,7 @@
 
 
 module Trema
-  VERSION = "0.2.6"
+  VERSION = "0.2.7"
 end
 
 

data/src/lib/openflow_message.c

@@ -2752,7 +2752,7 @@ validate_port_stats_reply( const buffer *message ) {
   assert( message != NULL );
 
   ret = validate_header( message, OFPT_STATS_REPLY,
-                         offsetof( struct ofp_stats_reply, body ) + sizeof( struct ofp_port_stats ),
+                         offsetof( struct ofp_stats_reply, body ),
                          UINT16_MAX );
   if ( ret < 0 ) {
     return ret;

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: trema
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 2
-  - 6
-  version: 0.2.6
+  - 7
+  version: 0.2.7
 platform: ruby
 authors: 
 - Yasuhito Takamiya
@@ -15,7 +15,7 @@ autorequire:
 bindir: .
 cert_chain: []
 
-date: 2012-12-26 00:00:00 Z
+date: 2012-12-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false