trema 0.2.2.1 → 0.2.3

data/ruby/trema/echo-request.h

@@ -1,6 +1,4 @@
 /*
- * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
- *
  * Copyright (C) 2008-2012 NEC Corporation
  *
  * This program is free software; you can redistribute it and/or modify

data/ruby/trema/echo.c

@@ -0,0 +1,99 @@
+/*
+ * 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 "ruby.h"
+#include "trema-ruby-utils.h"
+
+
+VALUE
+echo_init( int argc, VALUE *argv, VALUE self ) {
+  buffer *echo = NULL;
+  Data_Get_Struct( self, buffer, echo );
+  VALUE options = Qnil;
+
+  if ( rb_scan_args( argc, argv, "01", &options ) == 0 ) {
+    set_xid( echo, get_transaction_id() );
+  }
+  else {
+    if ( options == Qnil ) {
+      set_xid( echo, get_transaction_id() );
+    }
+    else if ( rb_obj_is_kind_of( options, rb_cInteger ) == Qtrue ) {
+      validate_xid( options );
+      set_xid( echo, ( uint32_t ) NUM2UINT( options ) );
+    }
+    else {
+      Check_Type( options, T_HASH );
+      VALUE tmp = Qnil;
+      VALUE xid = Qnil;
+
+      tmp = rb_hash_aref( options, ID2SYM( rb_intern( "transaction_id" ) ) );
+      if ( tmp != Qnil ) {
+        xid = tmp;
+      }
+      tmp = rb_hash_aref( options, ID2SYM( rb_intern( "xid" ) ) );
+      if ( tmp != Qnil ) {
+        xid = tmp;
+      }
+      if ( xid != Qnil ) {
+        validate_xid( xid );
+        set_xid( echo, ( uint32_t ) NUM2UINT( xid ) );
+      }
+      else {
+        set_xid( echo, get_transaction_id() );
+      }
+
+      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 );
+        append_back_buffer( echo, length );
+        set_length( echo, length );
+        memcpy( ( char * ) echo->data + sizeof( struct ofp_header ), RSTRING_PTR( user_data ), length );
+      }
+    }
+  }
+
+  return self;
+}
+
+
+VALUE
+echo_transaction_id( VALUE self ) {
+  return get_xid( self );
+}
+
+
+VALUE
+echo_user_data( VALUE self ) {
+  buffer *echo;
+  Data_Get_Struct( self, buffer, echo );
+  if ( echo->length > sizeof( struct ofp_header ) ) {
+    return rb_str_new( ( char * ) echo->data + sizeof( struct ofp_header ),
+                       ( long ) ( echo->length - sizeof( struct ofp_header ) ) );
+  }
+  return Qnil;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/ruby/trema/{action-enqueue.h → echo.h}

@@ -1,6 +1,4 @@
 /*
- * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
- *
  * Copyright (C) 2008-2012 NEC Corporation
  *
  * This program is free software; you can redistribute it and/or modify
@@ -18,18 +16,19 @@
  */
 
 
-#ifndef ACTION_ENQUEUE_H
-#define ACTION_ENQUEUE_H
+#ifndef ECHO_H
+#define ECHO_H
 
 
 #include "ruby.h"
 
 
-extern VALUE cActionEnqueue;
-void Init_action_enqueue( void );
+VALUE echo_init( int argc, VALUE *argv, VALUE self );
+VALUE echo_transaction_id( VALUE self );
+VALUE echo_user_data( VALUE self );
 
 
-#endif // ACTION_ENQUEUE_H
+#endif // ECHO_H
 
 
 /*

data/ruby/trema/enqueue.rb

@@ -0,0 +1,87 @@
+#
+# 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.
+#
+
+
+require "trema/action"
+require "trema/monkey-patch/integer"
+
+
+module Trema
+  #
+  # An action to enqueue the packet on the specified queue attached to
+  # a port.
+  #
+  class Enqueue < Action
+    attr_reader :port_number
+    attr_reader :queue_id
+
+
+    #
+    # Creates an action to enqueue the packet on the specified queue
+    # attached to a port. When a queue is configured the user can
+    # associate a flow with this action to forward a packet through
+    # the specific queue in that port.
+    #
+    # @example
+    #   Enqueue.new( :port_number => 1, :queue_id => 2 )
+    #
+    # @param [Hash] options
+    #   the options hash to create this action class instance with.
+    #
+    # @option options [Number] :port_number
+    #   the port the queue is attached to.
+    #
+    # @option options [Number] :queue_id
+    #   the configured queue. Currently only minimum rate queues provided.
+    #
+    # @raise [TypeError] if options is not a Hash.
+    # @raise [ArgumentError] if both port_number and queue_id arguments not supplied.
+    # @raise [ArgumentError] if port_number is not an unsigned 16-bit integer.
+    # @raise [ArgumentError] if queue id is not an unsigned 32-bit integer.
+    #
+    def initialize options
+      if options.is_a?( Hash )
+        @port_number = options[ :port_number ]
+        @queue_id = options[ :queue_id ]
+        if @port_number.nil?
+          raise ArgumentError, "Port number is a mandatory option"
+        end
+        if not @port_number.unsigned_16bit?
+          raise ArgumentError, "Port number must be an unsigned 16-bit integer"
+        end
+        if @queue_id.nil?
+          raise ArgumentError, "Queue ID is a mandatory option"
+        end
+        if not @queue_id.unsigned_32bit?
+          raise ArgumentError, "Queue ID must be an unsigned 32-bit integer"
+        end
+      else
+        raise "Invalid option"
+      end
+    end
+  end
+
+
+  ActionEnqueue = Enqueue
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/ruby/trema/error.c

@@ -1,6 +1,4 @@
 /*
- * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
- *
  * Copyright (C) 2008-2012 NEC Corporation
  *
  * This program is free software; you can redistribute it and/or modify
@@ -18,111 +16,116 @@
  */
 
 
-#include "trema.h"
 #include "ruby.h"
+#include "trema-ruby-utils.h"
+#include "trema.h"
 
 
 extern VALUE mTrema;
 VALUE cError;
 
 
+static VALUE
+error_alloc( VALUE klass ) {
+  buffer *error = create_error( 0, 0, 0, NULL );
+  return Data_Wrap_Struct( klass, NULL, free_buffer, error );
+}
+
+
 /*
- * @overload initialize(options={})
+ * @overload initialize(options)
  *   @example
  *     Error.new(
- *       :type => Error::OFPET_BAD_REQUEST,
- *       :code => Error::OFPBRC_BAD_TYPE,
+ *       :type => OFPET_BAD_REQUEST,
+ *       :code => OFPBRC_BAD_TYPE,
  *     )
  *     Error.new(
- *       :type => Errr::OFPET_BAD_REQUEST,
- *       :code => Error::OFPBRC_BAD_TYPE,
+ *       :type => OFPET_BAD_REQUEST,
+ *       :code => OFPBRC_BAD_TYPE,
  *       :transcation_id => 123
  *     )
  *     Error.new(
- *       :type => Errr::OFPET_BAD_REQUEST,
- *       :code => Error::OFPBRC_BAD_TYPE,
+ *       :type => OFPET_BAD_REQUEST,
+ *       :code => OFPBRC_BAD_TYPE,
  *       :transcation_id => 123
- *       :user_data => "Error!!"
+ *       :data => "Error!!"
  *     )
- *
- *   @param [Hash] options 
+ *   @param [Hash] options
  *     the options to create a message with.
- *
  *   @option options [Number] :type
  *     a command or action that failed.
- *
  *   @option options [Number] :code
  *     the reason of the failed type error.
- *
+ *   @option options [String] :data
+ *     a more user friendly explanation of the error. Defaults to nil
+ *     if not specified.
+ *   @option options [Number] :xid
  *   @option options [Number] :transaction_id
- *     a positive number, not recently attached to any previous pending commands to
- *     guarantee message integrity auto-generated if not specified.
- *
- *   @option options [String] :user_data
- *     a more user friendly explanation of the error. Defaults to nil if not
- *     specified.
- *
- *   @raise [ArgumentError] if transaction_id is not an unsigned 32bit integer.
+ *     An unsigned 32bit integer number associated with this message.
+ *     If not specified, an auto-generated value is set.
+ *   @raise [ArgumentError] if transaction ID is not an unsigned 32bit integer.
  *   @raise [ArgumentError] if type and code are not supplied.
  *   @raise [ArgumentError] if user data is not a string.
  *   @raise [TypeError] if options is not a hash.
- *
  *   @return [Error]
- *     an object that encapsulates the +OFPT_ERROR+ OpenFlow message.
  */
 static VALUE
-error_new( int argc, VALUE *argv, VALUE klass ) {
-  buffer *data = NULL;
-  uint32_t xid;
-  uint16_t type;
-  uint16_t code;
+error_init( int argc, VALUE *argv, VALUE self ) {
+  buffer *error = NULL;
+  Data_Get_Struct( self, buffer, error );
   VALUE options;
 
   if ( rb_scan_args( argc, argv, "01", &options ) == 1 ) {
     Check_Type( options, T_HASH );
-    VALUE type_r;
-    if ( ( type_r = rb_hash_aref( options, ID2SYM( rb_intern( "type" ) ) ) ) != Qnil ) {
-      type = ( uint16_t ) NUM2UINT( type_r );
+    VALUE tmp = Qnil;
+
+    tmp = rb_hash_aref( options, ID2SYM( rb_intern( "type" ) ) );
+    if ( tmp != Qnil ) {
+      ( ( struct ofp_error_msg * ) error->data )->type = htons( ( uint16_t ) NUM2UINT( tmp ) );
     }
     else {
       rb_raise( rb_eArgError, "Type is a mandatory option" );
     }
-    VALUE code_r;
-    if ( ( code_r = rb_hash_aref( options, ID2SYM( rb_intern( "code" ) ) ) ) != Qnil ) {
-      code = ( uint16_t ) NUM2UINT( code_r );
+
+    tmp = rb_hash_aref( options, ID2SYM( rb_intern( "code" ) ) );
+    if ( tmp != Qnil ) {
+      ( ( struct ofp_error_msg * ) error->data )->code = htons( ( uint16_t ) NUM2UINT( tmp ) );
     }
     else {
       rb_raise( rb_eArgError, "Code is a mandatory option" );
     }
-    VALUE xid_r;
-    if ( ( xid_r = rb_hash_aref( options, ID2SYM( rb_intern( "transaction_id" ) ) ) ) != Qnil ) {
-      if ( rb_funcall( xid_r, rb_intern( "unsigned_32bit?" ), 0 ) == Qfalse ) {
-        rb_raise( rb_eArgError, "Transaction ID must be an unsigned 32-bit integer" );
-      }
-      xid = ( uint32_t ) NUM2UINT( xid_r );
+
+    VALUE xid = Qnil;
+    tmp = rb_hash_aref( options, ID2SYM( rb_intern( "transaction_id" ) ) );
+    if ( tmp != Qnil ) {
+      xid = tmp;
+    }
+    tmp = rb_hash_aref( options, ID2SYM( rb_intern( "xid" ) ) );
+    if ( tmp != Qnil ) {
+      xid = tmp;
+    }
+    if ( xid != Qnil ) {
+      validate_xid( xid );
+      set_xid( error, ( uint32_t ) NUM2UINT( xid ) );
     }
     else {
-      xid = get_transaction_id();
+      set_xid( error, get_transaction_id() );
     }
-    VALUE user_data;
-    if ( ( user_data = rb_hash_aref( options, ID2SYM( rb_intern( "user_data" ) ) ) ) != Qnil ) {
-      if ( rb_obj_is_kind_of( user_data, rb_cString ) == Qfalse ) {
-        rb_raise( rb_eArgError, "User data must be a string" );
-      }
-      uint16_t length = ( u_int16_t ) RSTRING_LEN( user_data );
-      data = alloc_buffer_with_length( length );
-      void *p = append_back_buffer( data, length );
-      memcpy( p, RSTRING_PTR( user_data ), length );
+
+    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 );
+      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 );
     }
   }
   else {
     rb_raise( rb_eArgError, "Type and code are mandatory options" );
   }
-  buffer *error = create_error( xid, type, code, data );
-  if ( data != NULL ) {
-    free_buffer( data );
-  }
-  return Data_Wrap_Struct( klass, NULL, free_buffer, error );
+
+  return self;
 }
 
 
@@ -154,7 +157,7 @@ error_transaction_id( VALUE self ) {
  * @return [nil] user data payload is not set.
  */
 static VALUE
-error_user_data( VALUE self ) {
+error_data( VALUE self ) {
   struct ofp_error_msg *error = get_error( self );
   long length = ( long ) ( ntohs( error->header.length ) - sizeof( struct ofp_error_msg ) );
   if ( length > 0 ) {
@@ -192,54 +195,56 @@ error_code( VALUE self ) {
 
 void
 Init_error() {
+  rb_define_const( mTrema, "OFPET_HELLO_FAILED", INT2NUM( OFPET_HELLO_FAILED ) );
+  rb_define_const( mTrema, "OFPHFC_INCOMPATIBLE", INT2NUM( OFPHFC_INCOMPATIBLE ) );
+  rb_define_const( mTrema, "OFPHFC_EPERM", INT2NUM( OFPHFC_EPERM ) );
+
+  rb_define_const( mTrema, "OFPET_BAD_REQUEST", INT2NUM( OFPET_BAD_REQUEST ) );
+  rb_define_const( mTrema, "OFPBRC_BAD_VERSION", INT2NUM( OFPBRC_BAD_VERSION ) );
+  rb_define_const( mTrema, "OFPBRC_BAD_TYPE", INT2NUM( OFPBRC_BAD_TYPE ) );
+  rb_define_const( mTrema, "OFPBRC_BAD_STAT", INT2NUM( OFPBRC_BAD_STAT ) );
+  rb_define_const( mTrema, "OFPBRC_BAD_VENDOR", INT2NUM( OFPBRC_BAD_VENDOR ) );
+  rb_define_const( mTrema, "OFPBRC_BAD_SUBTYPE", INT2NUM( OFPBRC_BAD_SUBTYPE ) );
+  rb_define_const( mTrema, "OFPBRC_EPERM", INT2NUM( OFPBRC_EPERM ) );
+  rb_define_const( mTrema, "OFPBRC_BAD_LEN", INT2NUM( OFPBRC_BAD_LEN ) );
+  rb_define_const( mTrema, "OFPBRC_BUFFER_EMPTY", INT2NUM( OFPBRC_BUFFER_EMPTY ) );
+  rb_define_const( mTrema, "OFPBRC_BUFFER_UNKNOWN", INT2NUM( OFPBRC_BUFFER_UNKNOWN ) );
+
+  rb_define_const( mTrema, "OFPET_BAD_ACTION", INT2NUM( OFPET_BAD_ACTION ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_TYPE", INT2NUM( OFPBAC_BAD_TYPE ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_LEN", INT2NUM( OFPBAC_BAD_LEN ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_VENDOR", INT2NUM( OFPBAC_BAD_VENDOR ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_VENDOR_TYPE", INT2NUM( OFPBAC_BAD_VENDOR_TYPE ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_OUT_PORT", INT2NUM( OFPBAC_BAD_OUT_PORT ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_ARGUMENT", INT2NUM( OFPBAC_BAD_ARGUMENT ) );
+  rb_define_const( mTrema, "OFPBAC_EPERM", INT2NUM( OFPBAC_EPERM ) );
+  rb_define_const( mTrema, "OFPBAC_TOO_MANY", INT2NUM( OFPBAC_TOO_MANY ) );
+  rb_define_const( mTrema, "OFPBAC_BAD_QUEUE", INT2NUM( OFPBAC_BAD_QUEUE ) );
+
+  rb_define_const( mTrema, "OFPET_FLOW_MOD_FAILED", INT2NUM( OFPET_FLOW_MOD_FAILED ) );
+  rb_define_const( mTrema, "OFPFMFC_ALL_TABLES_FULL", INT2NUM( OFPFMFC_ALL_TABLES_FULL ) );
+  rb_define_const( mTrema, "OFPFMFC_OVERLAP", INT2NUM( OFPFMFC_OVERLAP ) );
+  rb_define_const( mTrema, "OFPFMFC_EPERM", INT2NUM( OFPFMFC_EPERM ) );
+  rb_define_const( mTrema, "OFPFMFC_BAD_EMERG_TIMEOUT", INT2NUM( OFPFMFC_BAD_EMERG_TIMEOUT ) );
+  rb_define_const( mTrema, "OFPFMFC_BAD_COMMAND", INT2NUM( OFPFMFC_BAD_COMMAND ) );
+  rb_define_const( mTrema, "OFPFMFC_UNSUPPORTED", INT2NUM( OFPFMFC_UNSUPPORTED ) );
+
+  rb_define_const( mTrema, "OFPET_PORT_MOD_FAILED", INT2NUM( OFPET_PORT_MOD_FAILED ) );
+  rb_define_const( mTrema, "OFPPMFC_BAD_PORT", INT2NUM( OFPPMFC_BAD_PORT ) );
+  rb_define_const( mTrema, "OFPPMFC_BAD_HW_ADDR", INT2NUM( OFPPMFC_BAD_HW_ADDR ) );
+
+  rb_define_const( mTrema, "OFPET_QUEUE_OP_FAILED", INT2NUM( OFPET_QUEUE_OP_FAILED ) );
+  rb_define_const( mTrema, "OFPQOFC_BAD_PORT", INT2NUM(OFPQOFC_BAD_PORT));
+  rb_define_const( mTrema, "OFPQOFC_BAD_QUEUE", INT2NUM(OFPQOFC_BAD_QUEUE));
+  rb_define_const( mTrema, "OFPQOFC_EPERM", INT2NUM(OFPQOFC_EPERM));
+
   cError = rb_define_class_under( mTrema, "Error", rb_cObject );
-  rb_define_singleton_method( cError, "new", error_new, -1 );
-  rb_define_const( cError, "OFPET_HELLO_FAILED", INT2NUM( OFPET_HELLO_FAILED ) );
-  rb_define_const( cError, "OFPET_BAD_REQUEST", INT2NUM( OFPET_BAD_REQUEST ) );
-  rb_define_const( cError, "OFPET_BAD_ACTION", INT2NUM( OFPET_BAD_ACTION ) );
-  rb_define_const( cError, "OFPET_FLOW_MOD_FAILED", INT2NUM( OFPET_FLOW_MOD_FAILED ) );
-  rb_define_const( cError, "OFPET_PORT_MOD_FAILED", INT2NUM( OFPET_PORT_MOD_FAILED ) );
-  rb_define_const( cError, "OFPET_QUEUE_OP_FAILED", INT2NUM( OFPET_QUEUE_OP_FAILED ) );
-
-  rb_define_const( cError, "OFPHFC_INCOMPATIBLE", INT2NUM( OFPHFC_INCOMPATIBLE ) );
-  rb_define_const( cError, "OFPHFC_EPERM", INT2NUM( OFPHFC_EPERM ) );
-
-  rb_define_const( cError, "OFPBRC_BAD_VERSION", INT2NUM( OFPBRC_BAD_VERSION ) );
-  rb_define_const( cError, "OFPBRC_BAD_TYPE", INT2NUM( OFPBRC_BAD_TYPE ) );
-  rb_define_const( cError, "OFPBRC_BAD_STAT", INT2NUM( OFPBRC_BAD_STAT ) );
-  rb_define_const( cError, "OFPBRC_BAD_VENDOR", INT2NUM( OFPBRC_BAD_VENDOR ) );
-  rb_define_const( cError, "OFPBRC_BAD_SUBTYPE", INT2NUM( OFPBRC_BAD_SUBTYPE ) );
-  rb_define_const( cError, "OFPBRC_EPERM", INT2NUM( OFPBRC_EPERM ) );
-  rb_define_const( cError, "OFPBRC_BAD_LEN", INT2NUM( OFPBRC_BAD_LEN ) );
-  rb_define_const( cError, "OFPBRC_BUFFER_EMPTY", INT2NUM( OFPBRC_BUFFER_EMPTY ) );
-  rb_define_const( cError, "OFPBRC_BUFFER_UNKNOWN", INT2NUM( OFPBRC_BUFFER_UNKNOWN ) );
-
-  rb_define_const( cError, "OFPBAC_BAD_TYPE", INT2NUM( OFPBAC_BAD_TYPE ) );
-  rb_define_const( cError, "OFPBAC_BAD_LEN", INT2NUM( OFPBAC_BAD_LEN ) );
-  rb_define_const( cError, "OFPBAC_BAD_VENDOR", INT2NUM( OFPBAC_BAD_VENDOR ) );
-  rb_define_const( cError, "OFPBAC_BAD_VENDOR_TYPE", INT2NUM( OFPBAC_BAD_VENDOR_TYPE ) );
-  rb_define_const( cError, "OFPBAC_BAD_OUT_PORT", INT2NUM( OFPBAC_BAD_OUT_PORT ) );
-  rb_define_const( cError, "OFPBAC_BAD_ARGUMENT", INT2NUM( OFPBAC_BAD_ARGUMENT ) );
-  rb_define_const( cError, "OFPBAC_EPERM", INT2NUM( OFPBAC_EPERM ) );
-  rb_define_const( cError, "OFPBAC_TOO_MANY", INT2NUM( OFPBAC_TOO_MANY ) );
-  rb_define_const( cError, "OFPBAC_BAD_QUEUE", INT2NUM( OFPBAC_BAD_QUEUE ) );
-
-  rb_define_const( cError, "OFPFMFC_ALL_TABLES_FULL", INT2NUM( OFPFMFC_ALL_TABLES_FULL ) );
-  rb_define_const( cError, "OFPFMFC_OVERLAP", INT2NUM( OFPFMFC_OVERLAP ) );
-  rb_define_const( cError, "OFPFMFC_EPERM", INT2NUM( OFPFMFC_EPERM ) );
-  rb_define_const( cError, "OFPFMFC_BAD_EMERG_TIMEOUT", INT2NUM( OFPFMFC_BAD_EMERG_TIMEOUT ) );
-  rb_define_const( cError, "OFPFMFC_BAD_COMMAND", INT2NUM( OFPFMFC_BAD_COMMAND ) );
-  rb_define_const( cError, "OFPFMFC_UNSUPPORTED", INT2NUM( OFPFMFC_UNSUPPORTED ) );
-
-  rb_define_const( cError, "OFPPMFC_BAD_PORT", INT2NUM( OFPPMFC_BAD_PORT ) );
-  rb_define_const( cError, "OFPPMFC_BAD_HW_ADDR", INT2NUM( OFPPMFC_BAD_HW_ADDR ) );
-
-  rb_define_const( cError, "OFPQOFC_BAD_PORT", INT2NUM(OFPQOFC_BAD_PORT));
-  rb_define_const( cError, "OFPQOFC_BAD_QUEUE", INT2NUM(OFPQOFC_BAD_QUEUE));
-  rb_define_const( cError, "OFPQOFC_EPERM", INT2NUM(OFPQOFC_EPERM));
 
+  rb_define_alloc_func( cError, error_alloc );
+  rb_define_method( cError, "initialize", error_init, -1 );
   rb_define_method( cError, "transaction_id", error_transaction_id, 0 );
-  rb_define_method( cError, "user_data", error_user_data, 0 );
+  rb_alias( cError, rb_intern( "xid" ), rb_intern( "transaction_id" ) );
+  rb_define_method( cError, "data", error_data, 0 );
   rb_define_method( cError, "error_type", error_type, 0 );
   rb_define_method( cError, "code", error_code, 0 );
 }