--- a/bindings/ruby/.gitignore	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-loudmouth.so
-

--- a/bindings/ruby/examples/send-message.rb	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,68 +0,0 @@
-# To change this template, choose Tools | Templates
-# and open the template in the editor.
-
-require 'loudmouth'
-require 'glib2'
-
-puts "Enter your JID: "
-jid = gets.chomp
-
-puts "Enter connect host: "
-host = gets.chomp
-
-puts "Enter your password: "
-password = gets.chomp
-
-if /(.+)@(.+)/ =~ jid
-  login = $1
-end
-
-puts "Logging in as '#{login}' to '#{host}'"
-
-main_loop = GLib::MainLoop.new
-
-conn = LM::Connection.new(host)
-conn.jid = jid
-conn.ssl = LM::SSL.new
-conn.ssl.use_starttls = true
-conn.ssl.require_starttls = true
-
-recipient = ""
-
-conn.open do |result|
-  puts "Connection open block"
-  if result
-    puts "Connection opened correctly"
-    conn.authenticate(login, password, "Test") do |auth_result|
-      unless auth_result
-        puts "Failed to authenticate"
-      end
-      authenticated_cb(conn)
-      main_loop.quit
-    end
-  else
-    puts "Failed to connect"
-    main_loop.quit
-  end
-end
-
-def authenticated_cb(conn)
-  puts "Authenticated!"
-  puts "Who do you want to message: "
-  recipient = gets.chomp
-  
-  puts "Enter message: "
-  body = gets.chomp
-  
-  m = LM::Message.new(recipient, LM::MessageType::MESSAGE)
-  m.node.add_child('body', body)
-  
-  conn.send(m)
-  conn.close
-  
-  puts "Message sent to #{recipient}"
-end
-
-main_loop.run
-
-puts "Quitting"

--- a/bindings/ruby/extconf.rb	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,15 +0,0 @@
-require 'pkg-config'
-
-PACKAGE_NAME = "loudmouth"
-PACKAGE_ID = "loudmouth"
-
-# SRCDIR = File.expand_path(File.dirname(__FILE__) + '/src')
-
-require 'mkmf'
-
-srcdir = File.join(File.expand_path(File.dirname(__FILE__)), 'src')
-
-PKGConfig.have_package("loudmouth-1.0", 1, 3, 4) or exit 1
-PKGConfig.have_package("glib-2.0", 2, 4, 0) or exit 1
-
-create_makefile("loudmouth", srcdir)

--- a/bindings/ruby/src/rblm-connection.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,364 +0,0 @@
-#include "rblm.h"
-#include "rblm-private.h"
-
-VALUE lm_cConnection;
-
-VALUE conn_set_server (VALUE self, VALUE server);
-
-/* -- START of GMainContext hack -- 
- * This is a hack to get the GMainContext from a ruby VALUE, this will break if
- * internals change in Ruby/GLib.
- */
-typedef struct {
-    gpointer boxed;
-    gboolean own;
-    gsize    type;
-} boxed_holder;
-
-static GMainContext *
-rb_lm_hack_get_main_context_from_rval (VALUE ctx_rval)
-{
-	boxed_holder *holder;
-
-	Data_Get_Struct (ctx_rval, boxed_holder, holder);
-
-	return holder->boxed;
-}
-/* -- END of GMainContext hack -- */
-
-LmConnection *
-rb_lm_connection_from_ruby_object (VALUE obj)
-{
-	LmConnection *conn;
-
-	if (!rb_lm__is_kind_of (obj, lm_cConnection)) {
-		rb_raise (rb_eTypeError, "not a LmConnection");
-	}
-
-	Data_Get_Struct (obj, LmConnection, conn);
-
-	return conn;
-}
-
-void
-conn_free (LmConnection *self)
-{
-	lm_connection_unref (self);
-}
-
-VALUE
-conn_allocate (VALUE klass)
-{
-	return Data_Wrap_Struct (klass, NULL, conn_free, NULL);
-}
-
-VALUE
-conn_initialize (int argc, VALUE *argv, VALUE self)
-{
-	LmConnection *conn;
-	char         *srv_str = NULL;
-	VALUE         server, context;
-
-	rb_scan_args (argc, argv, "02", &server, &context);
-
-	if (!NIL_P (context)) {
-		GMainContext *ctx;
-
-		ctx = rb_lm_hack_get_main_context_from_rval (context);
-
-		conn = lm_connection_new_with_context (NULL, ctx);
-	} else {
-		conn = lm_connection_new (NULL);
-	}
-
-	DATA_PTR (self) = conn;
-
-	if (!NIL_P (server)) {
-		conn_set_server (self, server);
-	}
-
-	return self;
-}
-
-static void
-open_callback (LmConnection *conn, gboolean success, gpointer user_data)
-{
-	rb_funcall((VALUE)user_data, rb_intern ("call"), 1,
-		   GBOOL2RVAL (success));
-}
-
-VALUE
-conn_open (int argc, VALUE *argv, VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-	VALUE         func;
-
-	rb_scan_args (argc, argv, "0&", &func);
-	if (NIL_P (func)) {
-		func = rb_block_proc ();
-	}
-
-	return GBOOL2RVAL (lm_connection_open (conn, open_callback, 
-					       (gpointer) func, NULL, NULL));
-}
-
-VALUE
-conn_close (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return GBOOL2RVAL (lm_connection_close (conn, NULL));
-}
-
-static void
-auth_callback (LmConnection *conn, gboolean success, gpointer user_data)
-{
-	rb_funcall((VALUE)user_data, rb_intern ("call"), 1,
-		   GBOOL2RVAL (success));
-}
-
-VALUE
-conn_auth (int argc, VALUE *argv, VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-	VALUE         name, password, resource, func; 
-
-	rb_scan_args (argc, argv, "21&", &name, &password, &resource, &func);
-	if (NIL_P (func)) {
-		func = rb_block_proc ();
-	}
-
-	return GBOOL2RVAL (lm_connection_authenticate (conn, 
-						       StringValuePtr (name),
-						       StringValuePtr (password), 
-						       StringValuePtr (resource),
-						       auth_callback,
-						       (gpointer) func, NULL,
-						       NULL));
-}
-
-VALUE
-conn_set_keep_alive_rate (VALUE self, VALUE rate)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	lm_connection_set_keep_alive_rate (conn, NUM2UINT (rate));
-
-	return Qnil;
-}
-
-/*
- * VALUE
-conn_get_keep_alive_rate (VALUE self)
-{
-	LmConnection *connection;
-} */
-
-VALUE
-conn_is_open (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return GBOOL2RVAL (lm_connection_is_open (conn));
-}
-
-VALUE
-conn_is_authenticated (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return GBOOL2RVAL (lm_connection_is_authenticated (conn));
-}
-
-VALUE
-conn_get_server (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return rb_str_new2 (lm_connection_get_server (conn));
-}
-
-VALUE
-conn_set_server (VALUE self, VALUE server)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	if (!rb_respond_to (server, rb_intern ("to_s"))) {
-		rb_raise (rb_eArgError, "server should respond to to_s");
-	} else {
-		VALUE str_val = rb_funcall (server, rb_intern ("to_s"), 0);
-		lm_connection_set_server (conn, StringValuePtr (str_val));
-	}
-
-	return Qnil;
-}
-
-VALUE
-conn_get_jid (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return rb_str_new2 (lm_connection_get_jid (conn));
-}
-
-VALUE
-conn_set_jid (VALUE self, VALUE jid)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	if (!rb_respond_to (jid, rb_intern ("to_s"))) {
-		rb_raise (rb_eArgError, "jid should respond to to_s");
-	} else {
-		VALUE str_val = rb_funcall (jid, rb_intern ("to_s"), 0);
-		lm_connection_set_jid (conn, StringValuePtr (str_val));
-	}
-
-	return Qnil;
-}
-
-VALUE
-conn_get_port (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return UINT2NUM (lm_connection_get_port (conn));
-}
-
-VALUE
-conn_set_port (VALUE self, VALUE port)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	lm_connection_set_port (conn, NUM2UINT (port));
-
-	return Qnil;
-}
-
-VALUE
-conn_get_ssl (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return LMSSL2RVAL (lm_connection_get_ssl (conn));
-}
-
-VALUE
-conn_set_ssl (VALUE self, VALUE ssl_rval)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-	LmSSL        *ssl  = rb_lm_ssl_from_ruby_object (ssl_rval);
-
-	lm_connection_set_ssl (conn, ssl);
-
-	return Qnil;
-}
-
-VALUE
-conn_get_proxy (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return LMPROXY2RVAL (lm_connection_get_proxy (conn));
-}
-
-VALUE
-conn_set_proxy (VALUE self, VALUE proxy_rval)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-	LmProxy      *proxy = rb_lm_proxy_from_ruby_object (proxy_rval);
-
-	lm_connection_set_proxy (conn, proxy);
-
-	return Qnil;
-}
-
-VALUE
-conn_send (VALUE self, VALUE msg)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-	LmMessage    *m = rb_lm_message_from_ruby_object (msg);
-
-	return GBOOL2RVAL (lm_connection_send (conn, m, NULL));
-}
-
-VALUE
-conn_get_state (VALUE self)
-{
-	LmConnection *conn = rb_lm_connection_from_ruby_object (self);
-
-	return INT2FIX (lm_connection_get_state (conn));
-}
-
-static LmHandlerResult
-msg_handler_cb (LmMessageHandler *handler,
-		LmConnection     *connection,
-		LmMessage        *message,
-		gpointer          user_data)
-{
-	rb_funcall ((VALUE)user_data, rb_intern ("call"), 1, 
-		    LMMESSAGE2RVAL (message));
-
-	return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
-}
-
-VALUE
-conn_add_msg_handler (int argc, VALUE *argv, VALUE self)
-{
-	LmConnection     *conn = rb_lm_connection_from_ruby_object (self);
-	VALUE             type, func;
-	LmMessageHandler *handler;
-
-	rb_scan_args (argc, argv, "1&", &type, &func);
-	if (NIL_P (func)) {
-		func = rb_block_proc ();
-	}
-
-	handler = lm_message_handler_new (msg_handler_cb, (gpointer) func, NULL);
-
-	lm_connection_register_message_handler (conn, handler,
-						rb_lm_message_type_from_ruby_object (type),
-						LM_HANDLER_PRIORITY_NORMAL);
-	lm_message_handler_unref (handler);
-
-	return Qnil;
-}
-
-void
-Init_lm_connection (VALUE lm_mLM)
-{
-	lm_cConnection = rb_define_class_under (lm_mLM, "Connection", 
-						rb_cObject);
-
-	rb_define_alloc_func (lm_cConnection, conn_allocate);
-
-	rb_define_method (lm_cConnection, "initialize", conn_initialize, -1);
-	rb_define_method (lm_cConnection, "open", conn_open, -1);
-	rb_define_method (lm_cConnection, "close", conn_close, 0);
-	rb_define_method (lm_cConnection, "authenticate", conn_auth, -1);
-	rb_define_method (lm_cConnection, "keep_alive_rate=", conn_set_keep_alive_rate, 1);
-	/* rb_define_method (lm_cConnection, "keep_alive_rate", conn_get_keep_alive_rate, 0); */
-	rb_define_method (lm_cConnection, "open?", conn_is_open, 0);
-	rb_define_method (lm_cConnection, "authenticated?", conn_is_authenticated, 0);
-	rb_define_method (lm_cConnection, "server", conn_get_server, 0);
-	rb_define_method (lm_cConnection, "server=", conn_set_server, 1);
-	rb_define_method (lm_cConnection, "jid", conn_get_jid, 0);
-	rb_define_method (lm_cConnection, "jid=", conn_set_jid, 1);
-	rb_define_method (lm_cConnection, "port", conn_get_port, 0);
-	rb_define_method (lm_cConnection, "port=", conn_set_port, 1);
-
-	rb_define_method (lm_cConnection, "ssl", conn_get_ssl, 0);
-	rb_define_method (lm_cConnection, "ssl=", conn_set_ssl, 1);
-	rb_define_method (lm_cConnection, "proxy", conn_get_proxy, 0);
-	rb_define_method (lm_cConnection, "proxy=", conn_set_proxy, 1);
-
-	/* Use one send message and check if there is a block passed? */
-	
-	rb_define_method (lm_cConnection, "send", conn_send, 1);
-	/*
-	rb_define_method (lm_cConnection, "send_with_reply", conn_send_with_reply, -1);
-	rb_define_method (lm_cConnection, "send_raw", conn_send_raw, 1);
-	*/
-
-	rb_define_method (lm_cConnection, "state", conn_get_state, 0);
-	rb_define_method (lm_cConnection, "add_message_handler", conn_add_msg_handler, -1);
-}

--- a/bindings/ruby/src/rblm-constants.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,266 +0,0 @@
-#include "rblm.h"
-
-VALUE lm_mMessageType;
-VALUE lm_mMessageSubType;
-VALUE lm_mDisconnectReason;
-VALUE lm_mConnectionState;
-VALUE lm_mProxyType;
-VALUE lm_mCertificateStatus;
-VALUE lm_mSSLStatus;
-VALUE lm_mSSLResponse;
-
-LmConnectionState
-rb_lm_connection_state_from_ruby_object (VALUE obj)
-{
-	LmConnectionState state;
-
-	state = FIX2INT (obj);
-	if (state < LM_CONNECTION_STATE_CLOSED ||
-	    state > LM_CONNECTION_STATE_AUTHENTICATED) {
-		rb_raise (rb_eArgError,
-			  "invalid LmConnectionState: %d (expected %d <= LmConnectionState <= %d)",
-			  state, LM_CONNECTION_STATE_CLOSED, 
-			  LM_CONNECTION_STATE_AUTHENTICATED);
-	}
-
-	return state;
-}
-
-LmDisconnectReason
-rb_lm_disconnect_reason_from_ruby_object (VALUE obj)
-{
-	LmDisconnectReason reason;
-
-	reason = FIX2INT (obj);
-	if (reason < LM_DISCONNECT_REASON_OK ||
-	    reason > LM_DISCONNECT_REASON_UNKNOWN) {
-		rb_raise (rb_eArgError,
-			  "invalid LmDisconnectReason: %d (expected %d <= LmDisconnectReason <= %d)",
-			  reason, 
-			  LM_DISCONNECT_REASON_OK, 
-			  LM_DISCONNECT_REASON_UNKNOWN);
-	}
-
-	return reason;
-}
-
-LmMessageType
-rb_lm_message_type_from_ruby_object (VALUE obj)
-{
-	LmMessageType type;
-
-	type = FIX2INT (obj);
-	if (type < LM_MESSAGE_TYPE_MESSAGE ||
-	    type > LM_MESSAGE_TYPE_IQ) {
-		rb_raise (rb_eArgError,
-			  "invalid LmMessageType: %d (expected %d <= LmMessageType <= %d)",
-			  type, LM_MESSAGE_TYPE_MESSAGE,
-			  LM_MESSAGE_TYPE_IQ);
-	}
-
-	return type;
-}
-
-LmMessageSubType
-rb_lm_message_sub_type_from_ruby_object (VALUE obj)
-{
-	LmMessageSubType type;
-
-	type = FIX2INT (obj);
-	if (type < LM_MESSAGE_SUB_TYPE_AVAILABLE ||
-	    type > LM_MESSAGE_SUB_TYPE_ERROR) {
-		rb_raise (rb_eArgError,
-			  "invalid LmMessageSubType: %d (expected %d <= LmMessageSubType <= %d)",
-			  type, LM_MESSAGE_SUB_TYPE_AVAILABLE,
-			  LM_MESSAGE_SUB_TYPE_ERROR);
-	}
-
-	return type;
-}
-
-LmProxyType
-rb_lm_proxy_type_from_ruby_object (VALUE obj)
-{
-	LmProxyType type;
-
-	type = FIX2INT (obj);
-	if (type < LM_PROXY_TYPE_NONE || type > LM_PROXY_TYPE_HTTP) {
-		rb_raise (rb_eArgError,
-			  "invalid LmProxyType: %d (expected %d <= LmProxyType <= %d)",
-			  type, LM_PROXY_TYPE_NONE, LM_PROXY_TYPE_HTTP);
-	}
-
-	return type;
-}
-
-LmCertificateStatus
-rb_lm_certificate_status_from_ruby_object (VALUE obj)
-{
-	LmCertificateStatus status;
-
-	status = FIX2INT (obj);
-	if (status < LM_CERT_INVALID || status > LM_CERT_REVOKED) {
-		rb_raise (rb_eArgError,
-			  "invalid LmCertificateStatus: %d (expected %d <= LmCertificateStatus <= %d)",
-			  status, LM_CERT_INVALID, LM_CERT_REVOKED);
-	}
-
-	return status;
-}
-
-LmSSLStatus 
-rb_lm_ssl_status_from_ruby_object (VALUE obj)
-{
-	LmSSLStatus status;
-
-	status = FIX2INT (obj);
-	if (status < LM_SSL_STATUS_NO_CERT_FOUND || 
-	    status > LM_SSL_STATUS_GENERIC_ERROR) {
-		rb_raise (rb_eArgError, 
-			  "invalid LmSSLStatus: %d (expected %d <= LmSSLStatus <= %d)",
-			  status, LM_SSL_STATUS_NO_CERT_FOUND, 
-			  LM_SSL_STATUS_GENERIC_ERROR);
-	}
-
-	return status;
-}
-
-LmSSLResponse
-rb_lm_ssl_response_from_ruby_object (VALUE obj)
-{
-	LmSSLResponse response;
-	
-	response = FIX2INT (obj);
-	if (response < LM_SSL_RESPONSE_CONTINUE || 
-	    response > LM_SSL_RESPONSE_STOP) {
-		rb_raise (rb_eArgError,
-			  "invalid LmSSLResponse: %d (expected %d <= LmSSLResponse <= %d)",
-			  response,
-			  LM_SSL_RESPONSE_CONTINUE, LM_SSL_RESPONSE_STOP);
-	}
-
-	return response;
-}
-
-void 
-Init_lm_constants (VALUE lm_mLM)
-{
-	/* LmMessageType */
-	lm_mMessageType = rb_define_module_under (lm_mLM, "MessageType");
-
-	rb_define_const (lm_mMessageType, "MESSAGE",
-			 INT2FIX (LM_MESSAGE_TYPE_MESSAGE));
-	rb_define_const (lm_mMessageType, "PRESENCE",
-			 INT2FIX (LM_MESSAGE_TYPE_PRESENCE));
-	rb_define_const (lm_mMessageType, "IQ",
-			 INT2FIX (LM_MESSAGE_TYPE_IQ));
-
-	/* LmMessageSubType */
-	lm_mMessageSubType = rb_define_module_under (lm_mLM, "MessageSubType");
-
-	rb_define_const (lm_mMessageSubType, "AVAILABLE",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_AVAILABLE));
-	rb_define_const (lm_mMessageSubType, "NORMAL",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_NORMAL));
-	rb_define_const (lm_mMessageSubType, "CHAT",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_CHAT));
-	rb_define_const (lm_mMessageSubType, "GROUPCHAT",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_GROUPCHAT));
-	rb_define_const (lm_mMessageSubType, "HEADLINE",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_HEADLINE));
-	rb_define_const (lm_mMessageSubType, "UNAVAILABLE",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_UNAVAILABLE));
-	rb_define_const (lm_mMessageSubType, "PROBE",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_PROBE));
-	rb_define_const (lm_mMessageSubType, "SUBSCRIBE",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_SUBSCRIBE));
-	rb_define_const (lm_mMessageSubType, "UNSUBSCRIBE",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE));
-	rb_define_const (lm_mMessageSubType, "SUBSCRIBED",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_SUBSCRIBED));
-	rb_define_const (lm_mMessageSubType, "UNSUBSCRIBED",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED));
-	rb_define_const (lm_mMessageSubType, "GET",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_GET));
-	rb_define_const (lm_mMessageSubType, "SET",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_SET));
-	rb_define_const (lm_mMessageSubType, "RESULT",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_RESULT));
-	rb_define_const (lm_mMessageSubType, "ERROR",
-			 INT2FIX (LM_MESSAGE_SUB_TYPE_ERROR));
-
-	/* LmDisconnectReason */
-	lm_mDisconnectReason = rb_define_module_under (lm_mLM, "DisconnectReason");
-
-	rb_define_const (lm_mDisconnectReason, "OK",
-			 INT2FIX (LM_DISCONNECT_REASON_OK));
-	rb_define_const (lm_mDisconnectReason, "PING_TIME_OUT",
-			 INT2FIX (LM_DISCONNECT_REASON_PING_TIME_OUT));
-	rb_define_const (lm_mDisconnectReason, "HUP",
-			 INT2FIX (LM_DISCONNECT_REASON_HUP));
-	rb_define_const (lm_mDisconnectReason, "ERROR",
-			 INT2FIX (LM_DISCONNECT_REASON_ERROR));
-	rb_define_const (lm_mDisconnectReason, "RESOURCE_CONFLICT",
-			 INT2FIX (LM_DISCONNECT_REASON_RESOURCE_CONFLICT));
-	rb_define_const (lm_mDisconnectReason, "INVALID_XML",
-			 INT2FIX (LM_DISCONNECT_REASON_INVALID_XML));
-	rb_define_const (lm_mDisconnectReason, "UNKNOWN",
-			 INT2FIX (LM_DISCONNECT_REASON_UNKNOWN));
-
-	/* LmConnectionState */
-	lm_mConnectionState = rb_define_module_under (lm_mLM, "ConnectionState");
-	rb_define_const (lm_mConnectionState, "CLOSED",
-			 INT2FIX (LM_CONNECTION_STATE_CLOSED));
-	rb_define_const (lm_mConnectionState, "OPENING",
-			 INT2FIX (LM_CONNECTION_STATE_OPENING));
-	rb_define_const (lm_mConnectionState, "OPEN",
-			 INT2FIX (LM_CONNECTION_STATE_OPEN));
-	rb_define_const (lm_mConnectionState, "AUTHENTICATING",
-			 INT2FIX (LM_CONNECTION_STATE_AUTHENTICATING));
-	rb_define_const (lm_mConnectionState, "AUTHENTICATED",
-			 INT2FIX (LM_CONNECTION_STATE_AUTHENTICATED));
-
-	/* LmProxyType */
-	lm_mProxyType = rb_define_module_under (lm_mLM, "ProxyType");
-
-	rb_define_const (lm_mProxyType, "NONE",
-			 INT2FIX (LM_PROXY_TYPE_NONE));
-	rb_define_const (lm_mProxyType, "HTTP",
-			 INT2FIX (LM_PROXY_TYPE_HTTP));
-
-	/* LmCertificateStatus */
-	lm_mCertificateStatus = rb_define_module_under (lm_mLM, 
-							"CertificateStatus");
-	rb_define_const (lm_mCertificateStatus, "INVALID",
-			 INT2FIX (LM_CERT_INVALID));
-	rb_define_const (lm_mCertificateStatus, "ISSUER_NOT_FOUND",
-			 INT2FIX (LM_CERT_ISSUER_NOT_FOUND));
-	rb_define_const (lm_mCertificateStatus, "REVOKED",
-			 INT2FIX (LM_CERT_REVOKED));
-
-	/* LmSSLStatus */
-	lm_mSSLStatus = rb_define_module_under (lm_mLM, "SSLStatus");
-
-	rb_define_const (lm_mSSLStatus, "NO_CERT_FOUND",
-			 INT2FIX (LM_SSL_STATUS_NO_CERT_FOUND));
-	rb_define_const (lm_mSSLStatus, "UNTRUSTED_CERT",
-			 INT2FIX (LM_SSL_STATUS_UNTRUSTED_CERT));
-	rb_define_const (lm_mSSLStatus, "CERT_EXPIRED",
-			 INT2FIX (LM_SSL_STATUS_CERT_EXPIRED));
-	rb_define_const (lm_mSSLStatus, "CERT_NOT_ACTIVATED",
-			 INT2FIX (LM_SSL_STATUS_CERT_NOT_ACTIVATED));
-	rb_define_const (lm_mSSLStatus, "CERT_HOSTNAME_MISMATCH",
-			 INT2FIX (LM_SSL_STATUS_CERT_HOSTNAME_MISMATCH));
-	rb_define_const (lm_mSSLStatus, "CERT_FINGERPRINT_MISMATCH",
-			 INT2FIX (LM_SSL_STATUS_CERT_FINGERPRINT_MISMATCH));
-	rb_define_const (lm_mSSLStatus, "GENERIC_ERROR",
-			 INT2FIX (LM_SSL_STATUS_GENERIC_ERROR));
-
-	/* LmSSLResponse */
-	lm_mSSLResponse = rb_define_module_under (lm_mLM, "SSLResponse");
-
-	rb_define_const (lm_mSSLResponse, "CONTINUE",
-			 INT2FIX (LM_SSL_RESPONSE_CONTINUE));
-	rb_define_const (lm_mSSLResponse, "STOP",
-			 INT2FIX (LM_SSL_RESPONSE_STOP));
-}

--- a/bindings/ruby/src/rblm-message-node.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,240 +0,0 @@
-#include <rblm.h>
-#include <rblm-private.h>
-
-VALUE lm_cMessageNode;
-
-LmMessageNode *
-rb_lm_message_node_from_ruby_object (VALUE obj)
-{
-	LmMessageNode *node;
-
-	if (!rb_lm__is_kind_of (obj, lm_cMessageNode)) {
-		rb_raise (rb_eTypeError, "not a LmMessageNode");
-	}
-
-	Data_Get_Struct (obj, LmMessageNode, node);
-
-	return node;
-}
-
-void
-msg_node_free (LmMessageNode *node)
-{
-	lm_message_node_unref (node);
-}
-
-VALUE
-rb_lm_message_node_to_ruby_object (LmMessageNode *node)
-{
-	if (node) {
-		lm_message_node_ref (node);
-		return Data_Wrap_Struct (lm_cMessageNode, NULL, 
-					 msg_node_free, node);
-	} else {
-		return Qnil;
-	}
-}
-
-VALUE
-msg_node_allocate (VALUE klass)
-{
-	return Data_Wrap_Struct (klass, NULL, msg_node_free, NULL);
-}
-
-VALUE
-msg_node_get_name (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return rb_str_new2 (node->name);
-}
-
-VALUE
-msg_node_get_value (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	if (lm_message_node_get_value (node)) {
-		return rb_str_new2 (lm_message_node_get_value (node));
-	} 
-
-	return Qnil;
-}
-
-VALUE
-msg_node_set_value (VALUE self, VALUE value)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);	
-	char          *value_str = NULL;
-	
-	if (!rb_respond_to (value, rb_intern ("to_s"))) {
-		rb_raise (rb_eArgError, "value should respond to to_s");
-	} else {
-		VALUE str_val = rb_funcall (value, rb_intern ("to_s"), 0);
-		value_str = StringValuePtr (str_val);
-	}
-
-	lm_message_node_set_value (node, value_str);
-}
-
-VALUE
-msg_node_add_child (int argc, VALUE *argv, VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-	LmMessageNode *child;
-	VALUE          name, value;
-	char          *value_str = NULL;
-	
-	rb_scan_args (argc, argv, "11", &name, &value);
-
-	if (!NIL_P (value)) {
-		if (!rb_respond_to (value, rb_intern ("to_s"))) {
-			rb_raise (rb_eArgError, "value should respond to to_s");
-		} else {
-			VALUE str_val = rb_funcall (value, rb_intern ("to_s"), 0);
-			value_str = StringValuePtr (str_val);
-		}
-	}
-
-	child = lm_message_node_add_child (node, StringValuePtr (name),
-					   value_str);
-
-	return LMMESSAGENODE2RVAL (child);
-}
-
-VALUE
-msg_node_get_attribute (VALUE self, VALUE attr)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	if (lm_message_node_get_attribute (node, StringValuePtr (attr))) {
-	    return rb_str_new2 (lm_message_node_get_attribute (node, 
-							       StringValuePtr (attr)));
-	}
-
-	return Qnil;
-}
-
-VALUE
-msg_node_set_attribute (VALUE self, VALUE attr, VALUE value)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-	char          *value_str = NULL;
-
-	if (!NIL_P (value)) {
-		value_str = StringValuePtr (value);
-	}
-	
-	lm_message_node_set_attribute (node, StringValuePtr (attr), value_str);
-	 
-	return Qnil;
-}
-
-VALUE 
-msg_node_get_child (VALUE self, VALUE name)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-	LmMessageNode *child;
-
-	child = lm_message_node_get_child (node, StringValuePtr (name));
-	
-	return LMMESSAGENODE2RVAL (child);
-}
-
-VALUE
-msg_node_find_child (VALUE self, VALUE name)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-	LmMessageNode *child;
-
-	child = lm_message_node_find_child (node, StringValuePtr (name));
-
-	return LMMESSAGENODE2RVAL (child);
-}
-
-VALUE
-msg_node_get_is_raw_mode (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return GBOOL2RVAL (lm_message_node_get_raw_mode (node));
-}
-
-VALUE
-msg_node_set_is_raw_mode (VALUE self, VALUE raw_mode)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	lm_message_node_set_raw_mode (node, RVAL2GBOOL (raw_mode));
-
-	return Qnil;
-}
-
-VALUE
-msg_node_to_string (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return rb_str_new2 (lm_message_node_to_string (node));
-}
-
-VALUE
-msg_node_get_next (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return LMMESSAGENODE2RVAL (node->next);
-}
-
-VALUE
-msg_node_get_prev (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return LMMESSAGENODE2RVAL (node->prev);
-}
-
-VALUE
-msg_node_get_parent (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return LMMESSAGENODE2RVAL (node->parent);
-}
-
-VALUE 
-msg_node_get_children (VALUE self)
-{
-	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);
-
-	return LMMESSAGENODE2RVAL (node->children);
-}
-
-extern void 
-Init_lm_message_node (VALUE lm_mLM)
-{
-	lm_cMessageNode = rb_define_class_under (lm_mLM, "MessageNode", 
-						 rb_cObject);
-
-	rb_define_alloc_func (lm_cMessageNode, msg_node_allocate);
-
-	rb_define_method (lm_cMessageNode, "name", msg_node_get_name, 0);
-	rb_define_method (lm_cMessageNode, "value", msg_node_get_value, 0);
-	rb_define_method (lm_cMessageNode, "value=", msg_node_set_value, 1);
-
-	rb_define_method (lm_cMessageNode, "add_child", msg_node_add_child, -1);
-	rb_define_method (lm_cMessageNode, "get_attribute", msg_node_get_attribute, 1);
-	rb_define_method (lm_cMessageNode, "set_attribute", msg_node_set_attribute, 2);
-	rb_define_method (lm_cMessageNode, "get_child", msg_node_get_child, 1);
-	rb_define_method (lm_cMessageNode, "find_child", msg_node_find_child, 1);
-
-	rb_define_method (lm_cMessageNode, "raw_mode", msg_node_get_is_raw_mode, 0);
-	rb_define_method (lm_cMessageNode, "raw_mode=", msg_node_set_is_raw_mode, 1);
-
-	rb_define_method (lm_cMessageNode, "to_s", msg_node_to_string, 0);
-
-	rb_define_method (lm_cMessageNode, "next", msg_node_get_next, 0);
-	rb_define_method (lm_cMessageNode, "prev", msg_node_get_prev, 0);
-	rb_define_method (lm_cMessageNode, "parent", msg_node_get_parent, 0);
-	rb_define_method (lm_cMessageNode, "children", msg_node_get_children, 0);
-}	

--- a/bindings/ruby/src/rblm-message.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,117 +0,0 @@
-#include "rblm.h"
-#include "rblm-private.h"
-
-/* How to handle type, sub_type and root node*/
-
-VALUE lm_cMessage;
-
-LmMessage *
-rb_lm_message_from_ruby_object (VALUE obj)
-{
-	LmMessage *m;
-
-	if (!rb_lm__is_kind_of (obj, lm_cMessage)) {
-		rb_raise (rb_eTypeError, "not a LmMessage");
-	}
-
-	Data_Get_Struct (obj, LmMessage, m);
-
-	return m;
-}
-
-void
-msg_free (LmMessage *m)
-{
-	lm_message_unref (m);
-}
-
-VALUE
-rb_lm_message_to_ruby_object (LmMessage *m)
-{
-	if (m) {
-		lm_message_ref (m);
-		return Data_Wrap_Struct (lm_cMessage, NULL,
-					 msg_free, m);
-	} else {
-		return Qnil;
-	}
-}
-
-VALUE
-msg_allocate (VALUE klass)
-{
-	return Data_Wrap_Struct (klass, NULL, msg_free, NULL);
-}
-
-VALUE
-msg_initialize (int argc, VALUE *argv, VALUE self)
-{
-	LmMessage  *m;
-	VALUE       to, type, sub_type;
-	char       *to_str = NULL;
-
-	rb_scan_args (argc, argv, "21", &to, &type, &sub_type);
-
-	/* To can be nil */
-	if (!NIL_P (to)) {
-		if (!rb_respond_to (to, rb_intern ("to_s"))) {
-			rb_raise (rb_eArgError, "to should respond to to_s");
-		} else {
-			VALUE str_val = rb_funcall (to, rb_intern ("to_s"), 0);
-			to_str = StringValuePtr (str_val);
-		}
-	} 
-
-	if (NIL_P (sub_type)) {
-		/* Without sub_type */
-		m = lm_message_new (to_str, FIX2INT (type));
-	} else {
-		m = lm_message_new_with_sub_type (to_str,
-						  FIX2INT (type),
-						  FIX2INT (sub_type));
-	}
-
-	DATA_PTR (self) = m;
-
-	return self;
-}
-
-VALUE
-msg_get_type (VALUE self)
-{
-	LmMessage *m = rb_lm_message_from_ruby_object (self);
-
-	return INT2FIX (lm_message_get_type (m));
-}
-
-VALUE
-msg_get_sub_type (VALUE self)
-{
-	LmMessage *m = rb_lm_message_from_ruby_object (self);
-
-	return INT2FIX (lm_message_get_sub_type (m));
-}
-
-VALUE
-msg_get_root_node (VALUE self)
-{
-	LmMessage *m = rb_lm_message_from_ruby_object (self);
-
-	return LMMESSAGENODE2RVAL (m->node);
-}
-
-extern void 
-Init_lm_message (VALUE lm_mLM)
-{
-	lm_cMessage = rb_define_class_under (lm_mLM, "Message", rb_cObject);
-
-	rb_define_alloc_func (lm_cMessage, msg_allocate);
-	
-	rb_define_method (lm_cMessage, "initialize", msg_initialize, -1);
-	rb_define_method (lm_cMessage, "type", msg_get_type, 0);
-	rb_define_method (lm_cMessage, "sub_type", msg_get_sub_type, 0);
-	rb_define_method (lm_cMessage, "root_node", msg_get_root_node, 0);
-
-	rb_define_alias (lm_cMessage, "node", "root_node");
-}
-

--- a/bindings/ruby/src/rblm-private.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-#include "rblm-private.h"
-
-gboolean
-rb_lm__is_kind_of (VALUE object, VALUE klass)
-{
-	return RVAL2GBOOL (rb_obj_is_kind_of (object, klass));
-}
-

--- a/bindings/ruby/src/rblm-private.h	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-
-#ifndef __RBLM_PRIVATE_H__
-#define __RBLM_PRIVATE_H__
-
-#include <glib.h>
-#include <ruby.h>
-#include <loudmouth/loudmouth.h>
-
-#define GBOOL2RVAL(x) (x == TRUE ? Qtrue : Qfalse)
-#define RVAL2GBOOL(x) RTEST(x)
-
-#define LMMESSAGENODE2RVAL(x) (rb_lm_message_node_to_ruby_object(x))
-#define LMSSL2RVAL(x) (rb_lm_ssl_to_ruby_object(x))
-#define LMPROXY2RVAL(x) (rb_lm_proxy_to_ruby_object(x))
-#define LMMESSAGE2RVAL(x) (rb_lm_message_to_ruby_object(x))
-
-gboolean            rb_lm__is_kind_of (VALUE object, VALUE klass);
-
-VALUE               rb_lm_message_to_ruby_object      (LmMessage     *m);
-VALUE               rb_lm_message_node_to_ruby_object (LmMessageNode *node);
-VALUE               rb_lm_ssl_to_ruby_object          (LmSSL         *ssl);
-VALUE               rb_lm_proxy_to_ruby_object        (LmProxy       *proxy);
-
-LmConnection *      rb_lm_connection_from_ruby_object         (VALUE obj);
-LmMessage *         rb_lm_message_from_ruby_object            (VALUE obj);
-LmMessageNode *     rb_lm_message_node_from_ruby_object       (VALUE obj);
-LmSSL *             rb_lm_ssl_from_ruby_object                (VALUE obj);
-LmProxy *           rb_lm_proxy_from_ruby_object              (VALUE obj);
-
-LmConnectionState   rb_lm_connection_state_from_ruby_object   (VALUE obj);
-LmDisconnectReason  rb_lm_disconnect_reason_from_ruby_object  (VALUE obj);
-LmMessageType       rb_lm_message_type_from_ruby_object       (VALUE obj);
-LmMessageSubType    rb_lm_message_sub_type_from_ruby_object   (VALUE obj);
-LmProxyType         rb_lm_proxy_type_from_ruby_object         (VALUE obj);
-LmCertificateStatus rb_lm_certificate_status_from_ruby_object (VALUE obj);
-LmSSLStatus         rb_lm_ssl_status_from_ruby_object         (VALUE obj);
-LmSSLResponse       rb_lm_ssl_response_from_ruby_object       (VALUE obj);
-
-#endif /* __RBLM_PRIVATE_H__ */
-

--- a/bindings/ruby/src/rblm-proxy.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,210 +0,0 @@
-#include "rblm.h"
-
-VALUE lm_cProxy;
-
-LmProxy *
-rb_lm_proxy_from_ruby_object (VALUE obj)
-{
-	LmProxy *proxy;
-
-	if (!rb_lm__is_kind_of (obj, lm_cProxy)) {
-		rb_raise (rb_eTypeError, "not a LmProxy");
-	}
-
-	Data_Get_Struct (obj, LmProxy, proxy);
-
-	return proxy;
-}
-
-void
-proxy_free (LmProxy *proxy)
-{
-	lm_proxy_unref (proxy);
-}
-
-VALUE
-rb_lm_proxy_to_ruby_object (LmProxy *proxy)
-{
-	if (proxy) {
-		lm_proxy_ref (proxy);
-		return Data_Wrap_Struct (lm_cProxy, NULL, 
-					 proxy_free, proxy);
-	} else {
-		return Qnil;
-	}
-}
-VALUE
-proxy_allocate (VALUE klass)
-{
-	return Data_Wrap_Struct (klass, NULL, proxy_free, NULL);
-}
-
-VALUE
-proxy_initialize (int argc, VALUE *argv, VALUE self)
-{
-	LmProxy *proxy;
-	VALUE    type, server, port;
-	char    *server_str = NULL;
-
-	rb_scan_args (argc, argv, "12", &type, &server, &port);
-
-	proxy = lm_proxy_new (FIX2INT (type));
-
-	if (!NIL_P (server)) {
-		if (!rb_respond_to (server, rb_intern ("to_s"))) {
-			rb_raise (rb_eArgError, "server should respond to to_s");
-		} else {
-			VALUE str_val = rb_funcall (server, rb_intern ("to_s"), 0);
-			lm_proxy_set_server (proxy, StringValuePtr (str_val));
-		}
-	}
-
-	if (!NIL_P (port)) {
-		lm_proxy_set_port (proxy, NUM2UINT (port));
-	}
-
-	DATA_PTR (self) = proxy;
-
-	return self;
-}
-
-VALUE
-proxy_get_type (VALUE self)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	return INT2FIX (lm_proxy_get_type (proxy));
-}
-
-VALUE
-proxy_set_type (VALUE self, VALUE type)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	lm_proxy_set_type (proxy, FIX2INT (type));
-
-	return Qnil;
-}
-
-VALUE
-proxy_get_server (VALUE self)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	if (lm_proxy_get_server (proxy)) {
-		return rb_str_new2 (lm_proxy_get_server (proxy));
-	}
-
-	return Qnil;
-}
-
-VALUE
-proxy_set_server (VALUE self, VALUE server)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-	VALUE    str_val;
-
-	if (!rb_respond_to (server, rb_intern ("to_s"))) {
-		rb_raise (rb_eArgError, "server should respond to to_s");
-	} 
-
-	str_val = rb_funcall (server, rb_intern ("to_s"), 0);
-	lm_proxy_set_server (proxy, StringValuePtr (str_val));
-
-	return Qnil;
-}
-
-VALUE 
-proxy_get_port (VALUE self)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	return UINT2NUM (lm_proxy_get_port (proxy));
-}
-
-VALUE
-proxy_set_port (VALUE self, VALUE port)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	lm_proxy_set_port (proxy, NUM2UINT (port));
-
-	return Qnil;
-}
-
-VALUE
-proxy_get_username (VALUE self)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	if (lm_proxy_get_username (proxy)) {
-		return rb_str_new2 (lm_proxy_get_username (proxy));
-	}
-
-	return Qnil;
-}
-
-VALUE
-proxy_set_username (VALUE self, VALUE username)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-	VALUE    str_val;
-
-	if (!rb_respond_to (username, rb_intern ("to_s"))) {
-		rb_raise (rb_eArgError, "username should respond to to_s");
-	} 
-
-	str_val = rb_funcall (username, rb_intern ("to_s"), 0);
-	lm_proxy_set_username (proxy, StringValuePtr (str_val));
-
-	return Qnil;
-}
-
-VALUE
-proxy_get_password (VALUE self)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-
-	if (lm_proxy_get_password (proxy)) {
-		return rb_str_new2 (lm_proxy_get_password (proxy));
-	}
-
-	return Qnil;
-}
-
-VALUE
-proxy_set_password (VALUE self, VALUE password)
-{
-	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);
-	VALUE    str_val;
-
-	if (!rb_respond_to (password, rb_intern ("to_s"))) {
-		rb_raise (rb_eArgError, "password should respond to to_s");
-	} 
-
-	str_val = rb_funcall (password, rb_intern ("to_s"), 0);
-	lm_proxy_set_password (proxy, StringValuePtr (str_val));
-
-	return Qnil;
-}
-
-extern void
-Init_lm_proxy (VALUE lm_mLM)
-{
-	lm_cProxy = rb_define_class_under (lm_mLM, "Proxy", rb_cObject);
-
-	rb_define_alloc_func (lm_cProxy, proxy_allocate);
-
-	rb_define_method (lm_cProxy, "initialize", proxy_initialize, -1);
-	rb_define_method (lm_cProxy, "type", proxy_get_type, 0);
-	rb_define_method (lm_cProxy, "type=", proxy_set_type, 1);
-	rb_define_method (lm_cProxy, "server", proxy_get_server, 0);
-	rb_define_method (lm_cProxy, "server=", proxy_set_server, 1);
-	rb_define_method (lm_cProxy, "port", proxy_get_port, 0);
-	rb_define_method (lm_cProxy, "port=", proxy_set_port, 1);
-	rb_define_method (lm_cProxy, "username", proxy_get_username, 0);
-	rb_define_method (lm_cProxy, "username=", proxy_set_username, 1);
-	rb_define_method (lm_cProxy, "password", proxy_get_password, 0);
-	rb_define_method (lm_cProxy, "password=", proxy_set_password, 1);
-}
-

--- a/bindings/ruby/src/rblm-ssl.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,171 +0,0 @@
-#include "rblm.h"
-#include "rblm-private.h"
-
-VALUE lm_cSSL;
-
-LmSSL *
-rb_lm_ssl_from_ruby_object (VALUE obj)
-{
-	LmSSL *ssl;
-
-	if (!rb_lm__is_kind_of (obj, lm_cSSL)) {
-		rb_raise (rb_eTypeError, "not a LmSSL");
-	}
-
-	Data_Get_Struct (obj, LmSSL, ssl);
-
-	return ssl;
-}
-
-void
-ssl_free (LmSSL *ssl)
-{
-	lm_ssl_unref (ssl);
-}
-
-VALUE
-rb_lm_ssl_to_ruby_object (LmSSL *ssl)
-{
-	if (ssl) {
-		lm_ssl_ref (ssl);
-		return Data_Wrap_Struct (lm_cSSL, NULL, 
-					 ssl_free, ssl);
-	} else {
-		return Qnil;
-	}
-}
-
-VALUE
-ssl_allocate (VALUE klass)
-{
-	return Data_Wrap_Struct (klass, NULL, ssl_free, NULL);
-}
-
-static VALUE
-ssl_is_supported (VALUE self)
-{
-	return GBOOL2RVAL (lm_ssl_is_supported ());
-}
-
-static LmSSLResponse
-ssl_func_callback (LmSSL       *ssl,
-		   LmSSLStatus  status,
-		   gpointer     user_data)
-{
-	VALUE response;
-
-	if (!user_data) {
-		return LM_SSL_RESPONSE_CONTINUE;
-	}
-
-	response = rb_funcall ((VALUE)user_data, rb_intern ("call"), 1,
-			       INT2FIX (status));
-
-	return rb_lm_ssl_response_from_ruby_object (response);
-}
-
-static VALUE
-ssl_initialize (int argc, VALUE *argv, VALUE self)
-{
-	LmSSL    *ssl;
-	VALUE     fingerprint;
-	VALUE     func;
-	char     *fingerprint_str = NULL;
-	gpointer  func_ptr = NULL;
-
-	rb_scan_args (argc, argv, "01&", &fingerprint, &func);
-
-	if (!NIL_P (func)) {
-		func_ptr = (gpointer) func;
-	}
-
-	if (!NIL_P (fingerprint)) {
-		VALUE str_val;
-
-		if (!rb_respond_to (fingerprint, rb_intern ("to_s"))) {
-			rb_raise (rb_eArgError, 
-				  "fingerprint should respond to to_s");
-		}
-
-		str_val = rb_funcall (fingerprint, rb_intern ("to_s"), 0);
-		fingerprint_str = StringValuePtr (str_val);
-	}
-
-	ssl = lm_ssl_new (fingerprint_str, ssl_func_callback,
-			  func_ptr, NULL);
-
-	DATA_PTR (self) = ssl;
-
-	return self;
-}
-
-static VALUE
-ssl_get_fingerprint (VALUE self)
-{
-	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);
-
-	if (lm_ssl_get_fingerprint (ssl)) {
-		return rb_str_new2 (lm_ssl_get_fingerprint (ssl));
-	}
-
-	return Qnil;
-}
-
-static VALUE
-ssl_get_use_starttls (VALUE self)
-{
-	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);
-
-	return GBOOL2RVAL (lm_ssl_get_use_starttls (ssl));
-}
-
-static VALUE
-ssl_set_use_starttls (VALUE self, VALUE use)
-{
-	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);
-
-	lm_ssl_use_starttls (ssl,
-			     RVAL2GBOOL (use),
-			     lm_ssl_get_require_starttls (ssl));
-
-	return Qnil;
-}
-
-static VALUE
-ssl_get_require_starttls (VALUE self)
-{
-	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);
-
-	return GBOOL2RVAL (lm_ssl_get_require_starttls (ssl));
-}
-
-static VALUE
-ssl_set_require_starttls (VALUE self, VALUE require)
-{
-	LmSSL *ssl = rb_lm_ssl_from_ruby_object (self);
-
-	lm_ssl_use_starttls (ssl,
-			     lm_ssl_get_use_starttls (ssl),
-			     RVAL2GBOOL (require));
-
-	return Qnil;
-}
-
-extern void
-Init_lm_ssl (VALUE lm_mLM)
-{
-	lm_cSSL = rb_define_class_under (lm_mLM, "SSL", rb_cObject);
-
-	rb_define_alloc_func (lm_cSSL, ssl_allocate);
-
-	rb_define_singleton_method (lm_cSSL, "supported?", 
-				    ssl_is_supported, 0);
-
-	rb_define_method (lm_cSSL, "initialize", ssl_initialize, -1);
-	rb_define_method (lm_cSSL, "fingerprint", ssl_get_fingerprint, 0);
-	rb_define_method (lm_cSSL, "use_starttls", ssl_get_use_starttls, 0);
-	rb_define_method (lm_cSSL, "use_starttls=", ssl_set_use_starttls, 1);
-	rb_define_method (lm_cSSL, "require_starttls", ssl_get_require_starttls, 0);
-	rb_define_method (lm_cSSL, "require_starttls=", ssl_set_require_starttls, 1);
-}
-

--- a/bindings/ruby/src/rblm.c	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-#include "rblm.h"
-
-void
-Init_loudmouth (void)
-{
-	VALUE lm_mLM;
-	
-	lm_mLM = rb_define_module ("LM");
-
-	Init_lm_connection (lm_mLM);
-	Init_lm_message (lm_mLM);
-	Init_lm_message_node (lm_mLM);
-	Init_lm_constants (lm_mLM);
-	Init_lm_ssl (lm_mLM);
-	Init_lm_proxy (lm_mLM);
-}
-

--- a/bindings/ruby/src/rblm.h	Fri Apr 11 18:15:58 2008 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-#ifndef __RLM_H__
-#define __RLM_H__
-
-#include <ruby.h>
-#include <loudmouth/loudmouth.h> 
-#include <glib.h>
-
-extern void Init_loudmouth          (void);
-extern void Init_lm_connection      (VALUE lm_mLM);
-extern void Init_lm_message         (VALUE lm_mLM);
-extern void Init_lm_message_node    (VALUE lm_mLM);
-extern void Init_lm_constants       (VALUE lm_mLM);
-extern void Init_lm_ssl             (VALUE lm_mLM);
-extern void Init_lm_proxy           (VALUE lm_mLM);
-
-#endif /* __RLM_H__ */
-