yong-purplegw_ruby 0.1.0

data/History.txt

@@ -0,0 +1,2 @@
+== 0.1.0
+ 

data/Manifest.txt

@@ -0,0 +1,7 @@
+ext/extconf.rb
+ext/purple_ruby.c
+examples/purplegw_example.rb
+Manifest.txt
+History.txt
+README.txt
+Rakefile

data/README.txt

@@ -0,0 +1,38 @@
+== OVERVIEW
+
+purple_ruby is a ruby gem to write servers that send and recive IM messages. It uses libpurple (http://developer.pidgin.im/wiki/WhatIsLibpurple) and therforce supports all protocols that Pidgin/Adium supports (MSN/Gtalk/Yahoo/AIM/ICQ etc).
+
+Please check examples/purplegw_example.rb for details. Bascially you just tell it what to do when an IM was received, and there is an embedded tcp 'proxy' which allows you send IM messages.
+
+Why not "ruburple"? I have used ruburple (http://rubyforge.org/projects/ruburple), but found it blocks a lot. libpurple needs to run its own event loop which interferes with ruby's green thread model. Ruburple's author has done lots of hard work to workaround the problem (http://rubyforge.org/pipermail/ruburple-development/2007-June/000005.html), but it does not work well.
+
+== INSTALLATION
+
+Linux (Ubuntu):
+---------------
+apt-get install libpurple0 libpurple-dev
+gem install yong-purple_ruby
+
+OSX:
+----
+sudo port -d selfupdate
+sudo port install gnutls
+		(wait forever....)
+sudo port install nss
+		(wait forever....)
+wget http://downloads.sourceforge.net/pidgin/pidgin-2.5.5.tar.bz2
+tar xvjf pidgin-2.5.5.tar.bz2
+cd pidgin-2.5.5
+./configure --disable-gtkui --disable-screensaver --disable-consoleui --disable-sm --disable-perl --disable-tk --disable-tcl --disable-gstreamer --disable-schemas-install --disable-gestures --disable-cap --disable-gevolution --disable-gtkspell --disable-startup-notification --disable-avahi --disable-nm --disable-dbus --disable-meanwhile
+make
+		(wait forever...)
+sudo make install
+
+edit your ~/.bash_profile and add this line
+export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig
+
+sudo gem install yong-purple_ruby
+
+
+
+

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'hoe'
+
+EXT = "ext/ruburple_ext.#{Hoe::DLEXT}"
+
+Hoe.new('purplegw_ruby', '0.1.0') do |p|
+  p.author = 'yong'
+  p.email = 'yong@intridea.com'
+  p.url = 'http://www.intridea.com'
+  p.summary = 'A ruby gem to write server that sends and recives IM messages'
+  p.description = 'A ruby gem to write server that sends and recives IM messages'
+  
+  p.spec_extras[:extensions] = "ext/extconf.rb"
+  p.clean_globs << EXT << "ext/*.o" << "ext/Makefile"
+end
+
+task :test => EXT
+
+file EXT => ["ext/extconf.rb", "ext/purple_ruby.c"] do
+  Dir.chdir "ext" do
+    ruby "extconf.rb"
+    sh "make"
+  end
+end

data/examples/purplegw_example.rb

@@ -0,0 +1,83 @@
+#
+#Example Usage:
+#
+#Start the daemon and receive IM:
+#$ruby examples/purplegw_example.rb prpl-msn user@hotmail.com password prpl-jabber user@gmail.com password
+#
+#Send im:
+#$ irb
+#irb(main):001:0> require 'lib/purplegw_ruby'
+#irb(main):007:0> PurpleGW.deliver 'prpl-jabber', 'friend@gmail.com', 'hello worlds!'
+#
+
+require 'hpricot'
+require 'socket'
+require File.expand_path(File.join(File.dirname(__FILE__), '../ext/purple_ruby'))
+
+class PurpleGWExample
+  SERVER_IP = "127.0.0.1"
+  SERVER_PORT = 9876
+
+  def start configs
+    PurpleRuby.init false #use 'true' if you want to see the debug messages
+    
+    puts "Available protocols:", PurpleRuby.list_protocols
+    
+    accounts = {}
+    configs.each {|config|
+      account = PurpleRuby.login(config[:protocol], config[:username], config[:password])
+      accounts[config[:protocol]] = account
+    }
+    
+    #handle incoming im messages
+    PurpleRuby.watch_incoming_im do |receiver, sender, message|
+      sender = sender[0...sender.index('/')] if sender.index('/') #discard anything after '/'
+      text = (Hpricot(message)).to_plain_text
+      puts "recv: #{receiver}, #{sender}, #{text}"
+    end
+    
+    #TODO detect login failure
+    PurpleRuby.watch_signed_on_event do |acc| 
+      puts "signed on: #{acc.username}"
+    end
+    
+    #listen a tcp port, parse incoming data and send it out.
+    #We assume the incoming data is in the following format:
+    #<protocol> <user> <message>
+    PurpleRuby.watch_incoming_ipc(SERVER_IP, SERVER_PORT) do |data|
+      first_space = data.index(' ')
+      second_space = data.index(' ', first_space + 1)
+      protocol = data[0...first_space]
+      user = data[(first_space+1)...second_space]
+      message = data[(second_space+1)...-1]
+      puts "send: #{protocol}, #{user}, #{message}"
+      accounts[protocol].send_im(user, message)
+    end
+    
+    trap("INT") {
+      #TODO ctrl-c can not be detected until a message is coming
+      puts 'Ctrl-C, quit...'
+      PurpleRuby.main_loop_stop
+    }
+    
+    PurpleRuby.main_loop_run
+  end
+  
+  def self.deliver(protocol, to_users, message)
+    to_users = [to_users] unless to_users.is_a?(Array)      
+    to_users.each do |user|
+      t = TCPSocket.new(SERVER_IP, SERVER_PORT)
+      t.print "#{protocol} #{user} #{message}\n"
+      t.close
+    end
+  end
+end
+
+if ARGV.length >= 3
+  configs = []
+  configs << {:protocol => ARGV[0], :username => ARGV[1], :password => ARGV[2]}
+  configs << {:protocol => ARGV[3], :username => ARGV[4], :password => ARGV[5]} if ARGV.length >= 6
+  #add more accounts here if you like
+  PurpleGWExample.new.start configs
+end
+

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+$CFLAGS = "#{ENV['CFLAGS']} -Wall -O3 -g"
+pkg_config 'purple'
+pkg_config 'glib-2.0'
+pkg_config 'gthread-2.0'
+create_makefile('purple_ruby')

data/ext/purple_ruby.c

@@ -0,0 +1,411 @@
+#include <libpurple/account.h>
+#include <libpurple/conversation.h>
+#include <libpurple/core.h>
+#include <libpurple/debug.h>
+#include <libpurple/cipher.h>
+#include <libpurple/eventloop.h>
+#include <libpurple/ft.h>
+#include <libpurple/log.h>
+#include <libpurple/notify.h>
+#include <libpurple/prefs.h>
+#include <libpurple/prpl.h>
+#include <libpurple/pounce.h>
+#include <libpurple/request.h>
+#include <libpurple/savedstatuses.h>
+#include <libpurple/sound.h>
+#include <libpurple/status.h>
+#include <libpurple/util.h>
+#include <libpurple/whiteboard.h>
+#include <libpurple/network.h>
+
+#include <ruby.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+
+#define PURPLE_GLIB_READ_COND  (G_IO_IN | G_IO_HUP | G_IO_ERR)
+#define PURPLE_GLIB_WRITE_COND (G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL)
+
+typedef struct _PurpleGLibIOClosure {
+	PurpleInputFunction function;
+	guint result;
+	gpointer data;
+} PurpleGLibIOClosure;
+
+static void purple_glib_io_destroy(gpointer data)
+{
+	g_free(data);
+}
+
+static gboolean purple_glib_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
+{
+	PurpleGLibIOClosure *closure = data;
+	PurpleInputCondition purple_cond = 0;
+
+	if (condition & PURPLE_GLIB_READ_COND)
+		purple_cond |= PURPLE_INPUT_READ;
+	if (condition & PURPLE_GLIB_WRITE_COND)
+		purple_cond |= PURPLE_INPUT_WRITE;
+
+	closure->function(closure->data, g_io_channel_unix_get_fd(source),
+			  purple_cond);
+
+	return TRUE;
+}
+
+static guint glib_input_add(gint fd, PurpleInputCondition condition, PurpleInputFunction function,
+							   gpointer data)
+{
+	PurpleGLibIOClosure *closure = g_new0(PurpleGLibIOClosure, 1);
+	GIOChannel *channel;
+	GIOCondition cond = 0;
+
+	closure->function = function;
+	closure->data = data;
+
+	if (condition & PURPLE_INPUT_READ)
+		cond |= PURPLE_GLIB_READ_COND;
+	if (condition & PURPLE_INPUT_WRITE)
+		cond |= PURPLE_GLIB_WRITE_COND;
+
+	channel = g_io_channel_unix_new(fd);
+	closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond,
+					      purple_glib_io_invoke, closure, purple_glib_io_destroy);
+
+	g_io_channel_unref(channel);
+	return closure->result;
+}
+
+static PurpleEventLoopUiOps glib_eventloops = 
+{
+	g_timeout_add,
+	g_source_remove,
+	glib_input_add,
+	g_source_remove,
+	NULL,
+#if GLIB_CHECK_VERSION(2,14,0)
+	g_timeout_add_seconds,
+#else
+	NULL,
+#endif
+
+	/* padding */
+	NULL,
+	NULL,
+	NULL
+};
+
+static VALUE cPurpleRuby;
+static VALUE cAccount;
+static char* UI_ID = "purplegw";
+static GMainLoop *main_loop;
+static VALUE im_hanlder;
+static VALUE signed_on_hanlder;
+static GHashTable* hash_table;
+
+static void write_conv(PurpleConversation *conv, const char *who, const char *alias,
+			const char *message, PurpleMessageFlags flags, time_t mtime)
+{	
+  VALUE *args = g_new(VALUE, 3);
+  args[0] = rb_str_new2(purple_account_get_username(purple_conversation_get_account(conv)));
+  args[1] = rb_str_new2(who);
+  args[2] = rb_str_new2(message);
+  rb_funcall2(im_hanlder, rb_intern("call"), 3, args);
+}
+
+static PurpleConversationUiOps conv_uiops = 
+{
+	NULL,                      /* create_conversation  */
+	NULL,                      /* destroy_conversation */
+	NULL,                      /* write_chat           */
+	NULL,                      /* write_im             */
+	write_conv,           /* write_conv           */
+	NULL,                      /* chat_add_users       */
+	NULL,                      /* chat_rename_user     */
+	NULL,                      /* chat_remove_users    */
+	NULL,                      /* chat_update_user     */
+	NULL,                      /* present              */
+	NULL,                      /* has_focus            */
+	NULL,                      /* custom_smiley_add    */
+	NULL,                      /* custom_smiley_write  */
+	NULL,                      /* custom_smiley_close  */
+	NULL,                      /* send_confirm         */
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static void ui_init(void)
+{
+	/**
+	 * This should initialize the UI components for all the modules. Here we
+	 * just initialize the UI for conversations.
+	 */
+	purple_conversations_set_ui_ops(&conv_uiops);
+}
+
+static PurpleCoreUiOps core_uiops = 
+{
+	NULL,
+	NULL,
+	ui_init,
+	NULL,
+
+	/* padding */
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static VALUE init(VALUE self, VALUE debug)
+{
+  hash_table = g_hash_table_new(NULL, NULL);
+
+  purple_debug_set_enabled((debug == Qnil || debug == Qfalse) ? FALSE : TRUE);
+  purple_core_set_ui_ops(&core_uiops);
+  purple_eventloop_set_ui_ops(&glib_eventloops);
+  
+  if (!purple_core_init(UI_ID)) {
+		rb_raise(rb_eRuntimeError, "libpurple initialization failed");
+	}
+
+  /* Create and load the buddylist. */
+  purple_set_blist(purple_blist_new());
+  purple_blist_load();
+
+  /* Load the preferences. */
+  purple_prefs_load();
+
+  /* Load the pounces. */
+  purple_pounces_load();
+
+  return Qnil;
+}
+
+static VALUE watch_incoming_im(VALUE self)
+{
+  im_hanlder = rb_block_proc();
+  return im_hanlder;
+}
+
+static void signed_on(PurpleConnection* connection)
+{
+  VALUE *args = g_new(VALUE, 1);
+  args[0] = Data_Wrap_Struct(cAccount, NULL, NULL, purple_connection_get_account(connection));
+  rb_funcall2((VALUE)signed_on_hanlder, rb_intern("call"), 1, args);
+}
+
+static VALUE watch_signed_on_event(VALUE self)
+{
+  signed_on_hanlder = rb_block_proc();
+  int handle;
+	purple_signal_connect(purple_connections_get_handle(), "signed-on", &handle,
+				PURPLE_CALLBACK(signed_on), NULL);
+  return signed_on_hanlder;
+}
+
+static void _read_socket_handler(gpointer data, int socket, PurpleInputCondition condition)
+{
+  char message[4096] = {0};
+  int i = recv(socket, message, sizeof(message) - 1, 0);
+  if (i > 0) {
+    //printf("recv %d %d\n", socket, i);
+    
+    VALUE str = (VALUE)g_hash_table_lookup(hash_table, (gpointer)socket);
+    if (NULL == str) rb_raise(rb_eRuntimeError, "can not find socket: %d", socket);
+    rb_str_append(str, rb_str_new2(message));
+  } else {
+    //printf("closed %d %d %s\n", socket, i, g_strerror(errno));
+    
+    VALUE str = (VALUE)g_hash_table_lookup(hash_table, (gpointer)socket);
+    if (NULL == str) return;
+    
+    close(socket);
+    purple_input_remove(socket);
+    g_hash_table_remove(hash_table, (gpointer)socket);
+    
+    VALUE *args = g_new(VALUE, 1);
+    args[0] = str;
+    rb_funcall2((VALUE)data, rb_intern("call"), 1, args);
+  }
+}
+
+static void _accept_socket_handler(gpointer data, int server_socket, PurpleInputCondition condition)
+{
+  /* Check that it is a read condition */
+	if (condition != PURPLE_INPUT_READ)
+		return;
+		
+	struct sockaddr_in their_addr; /* connector's address information */
+	socklen_t sin_size = sizeof(struct sockaddr);
+	int client_socket;
+  if ((client_socket = accept(server_socket, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
+		return;
+	}
+	
+	int flags = fcntl(client_socket, F_GETFL);
+	fcntl(client_socket, F_SETFL, flags | O_NONBLOCK);
+#ifndef _WIN32
+	fcntl(client_socket, F_SETFD, FD_CLOEXEC);
+#endif
+
+  //printf("new connection: %d\n", client_socket);
+	
+	g_hash_table_insert(hash_table, (gpointer)client_socket, (gpointer)rb_str_new2(""));
+	
+	purple_input_add(client_socket, PURPLE_INPUT_READ, _read_socket_handler, data);
+}
+
+static VALUE watch_incoming_ipc(VALUE self, VALUE serverip, VALUE port)
+{
+	struct sockaddr_in my_addr;
+  int soc;
+
+	/* Open a listening socket for incoming conversations */
+	if ((soc = socket(PF_INET, SOCK_STREAM, 0)) < 0)
+	{
+		rb_raise(rb_eRuntimeError, "Cannot open socket: %s\n", g_strerror(errno));
+		return Qnil;
+	}
+
+	memset(&my_addr, 0, sizeof(struct sockaddr_in));
+	my_addr.sin_family = AF_INET;
+	my_addr.sin_addr.s_addr = inet_addr(RSTRING(serverip)->ptr);
+	my_addr.sin_port = htons(FIX2INT(port));
+	if (bind(soc, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) != 0)
+	{
+		rb_raise(rb_eRuntimeError, "Unable to bind to port %d: %s\n", (int)FIX2INT(port), g_strerror(errno));
+		return Qnil;
+	}
+
+	/* Attempt to listen on the bound socket */
+	if (listen(soc, 10) != 0)
+	{
+		rb_raise(rb_eRuntimeError, "Cannot listen on socket: %s\n", g_strerror(errno));
+		return Qnil;
+	}
+
+  VALUE proc = rb_block_proc();
+  
+	/* Open a watcher in the socket we have just opened */
+	purple_input_add(soc, PURPLE_INPUT_READ, _accept_socket_handler, (gpointer)proc);
+	
+	return port;
+}
+
+static VALUE login(VALUE self, VALUE protocol, VALUE username, VALUE password)
+{
+  PurpleAccount* account = purple_account_new(RSTRING(username)->ptr, RSTRING(protocol)->ptr);
+  purple_account_set_password(account, RSTRING(password)->ptr);
+  purple_account_set_enabled(account, UI_ID, TRUE);
+  PurpleSavedStatus *status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
+	purple_savedstatus_activate(status);
+	
+	return Data_Wrap_Struct(cAccount, NULL, NULL, account);
+}
+
+static VALUE main_loop_run(VALUE self)
+{
+  main_loop = g_main_loop_new(NULL, FALSE);
+  g_main_loop_run(main_loop);
+  return Qnil;
+}
+
+static VALUE main_loop_stop(VALUE self)
+{
+  g_main_loop_quit(main_loop);
+  return Qnil;
+}
+
+static VALUE send_im(VALUE self, VALUE name, VALUE message)
+{
+  PurpleAccount *account;
+  Data_Get_Struct(self, PurpleAccount, account);
+  
+  if (purple_account_is_connected(account)) {
+    int i = serv_send_im(purple_account_get_connection(account), RSTRING(name)->ptr, RSTRING(message)->ptr, 0);
+    return INT2FIX(i);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE username(VALUE self)
+{
+  PurpleAccount *account;
+  Data_Get_Struct(self, PurpleAccount, account);
+  return rb_str_new2(purple_account_get_username(account));
+}
+
+static VALUE list_protocols(VALUE self)
+{
+  VALUE array = rb_ary_new();
+  
+  GList *iter = purple_plugins_get_protocols();
+  int i;
+	for (i = 0; iter; iter = iter->next) {
+		PurplePlugin *plugin = iter->data;
+		PurplePluginInfo *info = plugin->info;
+		if (info && info->name) {
+		  char s[256];
+			snprintf(s, sizeof(s) -1, "%s %s", info->id, info->name);
+			rb_ary_push(array, rb_str_new2(s));
+		}
+	}
+  
+  return array;
+}
+
+static VALUE add_buddy(VALUE self, VALUE buddy)
+{
+  PurpleAccount *account;
+  Data_Get_Struct(self, PurpleAccount, account);
+  
+  char* group = _("Buddies");
+  PurpleGroup* grp = purple_find_group(group);
+	if (!grp)
+	{
+		grp = purple_group_new(group);
+		purple_blist_add_group(grp, NULL);
+	}
+	
+	PurpleBuddy* pb = purple_buddy_new(account, RSTRING(buddy)->ptr, NULL);
+  purple_blist_add_buddy(pb, NULL, grp, NULL);
+  purple_account_add_buddy(account, pb);
+  return Qtrue;
+}
+
+static VALUE has_buddy(VALUE self, VALUE buddy)
+{
+  PurpleAccount *account;
+  Data_Get_Struct(self, PurpleAccount, account);
+  if (purple_find_buddy(account, RSTRING(buddy)->ptr) != NULL) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+void Init_purple_ruby() 
+{
+  cPurpleRuby = rb_define_class("PurpleRuby", rb_cObject);
+  rb_define_singleton_method(cPurpleRuby, "init", init, 1);
+  rb_define_singleton_method(cPurpleRuby, "list_protocols", list_protocols, 0);
+  rb_define_singleton_method(cPurpleRuby, "watch_signed_on_event", watch_signed_on_event, 0);
+  rb_define_singleton_method(cPurpleRuby, "watch_incoming_im", watch_incoming_im, 0);
+  rb_define_singleton_method(cPurpleRuby, "login", login, 3);
+  rb_define_singleton_method(cPurpleRuby, "watch_incoming_ipc", watch_incoming_ipc, 2);
+  rb_define_singleton_method(cPurpleRuby, "main_loop_run", main_loop_run, 0);
+  rb_define_singleton_method(cPurpleRuby, "main_loop_stop", main_loop_stop, 0);
+  
+  cAccount = rb_define_class_under(cPurpleRuby, "Account", rb_cObject);
+  rb_define_method(cAccount, "send_im", send_im, 2);
+  rb_define_method(cAccount, "username", username, 0);
+  rb_define_method(cAccount, "add_buddy", add_buddy, 1);
+  rb_define_method(cAccount, "has_buddy?", has_buddy, 1);
+}

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: yong-purplegw_ruby
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- yong
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-01 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: A ruby gem to write server that sends and recives IM messages
+email: yong@intridea.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- Manifest.txt
+- History.txt
+- README.txt
+files: 
+- ext/extconf.rb
+- ext/purple_ruby.c
+- examples/purplegw_example.rb
+- Manifest.txt
+- History.txt
+- README.txt
+- Rakefile
+has_rdoc: true
+homepage: http://www.intridea.com
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: purplegw_ruby
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A ruby gem to write server that sends and recives IM messages
+test_files: []
+