yong-purple_ruby 0.1.1 → 0.2.0

data/Rakefile

@@ -3,7 +3,7 @@ require 'hoe'
 
 EXT = "ext/ruburple_ext.#{Hoe::DLEXT}"
 
-Hoe.new('purple_ruby', '0.1.1') do |p|
+Hoe.new('purple_ruby', '0.2.0') do |p|
   p.author = 'yong'
   p.email = 'yong@intridea.com'
   p.url = 'http://www.intridea.com'

data/examples/purplegw_example.rb

@@ -36,22 +36,27 @@ class PurpleGWExample
       puts "recv: #{receiver}, #{sender}, #{text}"
     end
     
-    #TODO detect login failure
     PurpleRuby.watch_signed_on_event do |acc| 
       puts "signed on: #{acc.username}"
     end
     
+    PurpleRuby.watch_connection_error do |acc, type, description| 
+      raise "connection_error: #{acc.username} #{type} #{description}"
+    end
+    
+    #request can be: 'SSL Certificate Verification' etc
+    PurpleRuby.watch_request do |title, primary, secondary, who|
+      puts "request: #{title}, #{primary}, #{secondary}, #{who}"
+      true #'true': accept a request; 'false': ignore a request
+    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]
+      protocol, user, message = data.split(",").collect{|x| x.chomp.strip}
       puts "send: #{protocol}, #{user}, #{message}"
-      accounts[protocol].send_im(user, message)
+      puts accounts[protocol].send_im(user, message)
     end
         
     PurpleRuby.main_loop_run
@@ -61,7 +66,7 @@ class PurpleGWExample
     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.print "#{protocol},#{user},#{message}"
       t.close
     end
   end

data/ext/purple_ruby.c

@@ -22,6 +22,7 @@
 #include <errno.h>
 #include <signal.h>
 #include <stdarg.h>
+#include <unistd.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
@@ -102,19 +103,51 @@ static PurpleEventLoopUiOps glib_eventloops =
 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 GMainLoop *main_loop = NULL;
+static VALUE im_handler = Qnil;
+static VALUE signed_on_handler = Qnil;
+static VALUE connection_error_handler = Qnil;
+static VALUE notify_message_handler = Qnil;
+static VALUE request_handler = Qnil;
+static GHashTable* hash_table = NULL;
+static ID CALL;
+
+static void connection_error(PurpleConnection* connection, 
+                    PurpleConnectionError type,
+                    const gchar *description,
+                    gpointer unused)
+{
+  if (Qnil != connection_error_handler) {
+    VALUE *args = g_new(VALUE, 3);
+    args[0] = Data_Wrap_Struct(cAccount, NULL, NULL, purple_connection_get_account(connection));
+    args[1] = INT2FIX(type);
+    args[2] = rb_str_new2(description);
+    rb_funcall2((VALUE)connection_error_handler, CALL, 3, args);
+    g_free(args);
+  }
+}
 
 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);
+  if (im_handler != Qnil) {
+    PurpleAccount* account = purple_conversation_get_account(conv);
+    if (strcmp(purple_account_get_protocol_id(account), "prpl-msn") == 0 &&
+        strstr(message, "Message could not be sent") != NULL) {
+      /* I have seen error like 'msn: Connection error from Switchboard server'.
+       * In that case, libpurple will notify user with two regular im message.
+       * The first message is an error message, the second one is the original message that failed to send.
+       */
+      connection_error(purple_account_get_connection(account), PURPLE_CONNECTION_ERROR_NETWORK_ERROR, message, NULL);
+    } else {
+      VALUE *args = g_new(VALUE, 3);
+      args[0] = rb_str_new2(purple_account_get_username(account));
+      args[1] = rb_str_new2(who);
+      args[2] = rb_str_new2(message);
+      rb_funcall2(im_handler, CALL, 3, args);
+      g_free(args);
+    }
+  }
 }
 
 static PurpleConversationUiOps conv_uiops = 
@@ -140,20 +173,110 @@ static PurpleConversationUiOps conv_uiops =
 	NULL
 };
 
-static void ui_init(void)
+static void report_disconnect_reason(PurpleConnection *gc, PurpleConnectionError reason, const char *text)
+{
+  connection_error(gc, reason, text, NULL);
+}
+
+static PurpleConnectionUiOps connection_ops = 
+{
+	NULL, /* connect_progress */
+	NULL, /* connected */
+	NULL, /* disconnected */
+	NULL, /* notice */
+	NULL,
+	NULL, /* network_connected */
+	NULL, /* network_disconnected */
+	report_disconnect_reason,
+	NULL,
+	NULL,
+	NULL
+};
+
+static void* notify_message(PurpleNotifyMsgType type, 
+	const char *title,
+	const char *primary, 
+	const char *secondary)
+{
+  if (notify_message_handler != Qnil) {
+    VALUE *args = g_new(VALUE, 4);
+    args[0] = INT2FIX(type);
+    args[1] = rb_str_new2(NULL == title ? "" : title);
+    args[2] = rb_str_new2(NULL == primary ? "" : primary);
+    args[3] = rb_str_new2(NULL == secondary ? "" : secondary);
+    rb_funcall2(notify_message_handler, CALL, 4, args);
+    g_free(args);
+  }
+  
+  return NULL;
+}
+
+static void* request_action(const char *title, const char *primary, const char *secondary,
+                            int default_action,
+                            PurpleAccount *account, 
+                            const char *who, 
+                            PurpleConversation *conv,
+                            void *user_data, 
+                            size_t action_count, 
+                            va_list actions)
 {
-	/**
-	 * 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);
+  if (request_handler != Qnil) {
+	  VALUE *args = g_new(VALUE, 4);
+    args[0] = rb_str_new2(NULL == title ? "" : title);
+    args[1] = rb_str_new2(NULL == primary ? "" : primary);
+    args[2] = rb_str_new2(NULL == secondary ? "" : secondary);
+    args[3] = rb_str_new2(NULL == who ? "" : who);
+    VALUE v = rb_funcall2(request_handler, CALL, 4, args);
+	  
+	  if (v != Qnil && v != Qfalse) {
+	    const char *text = va_arg(actions, const char *);
+	    GCallback ok_cb = va_arg(actions, GCallback);
+      ((PurpleRequestActionCb)ok_cb)(user_data, default_action);
+    }
+    
+    g_free(args);
+  }
+  
+  return NULL;
 }
 
+static PurpleRequestUiOps request_ops =
+{
+	NULL,           /*request_input*/
+	NULL,           /*request_choice*/
+	request_action, /*request_action*/
+	NULL,           /*request_fields*/
+	NULL,           /*request_file*/
+	NULL,           /*close_request*/
+	NULL,           /*request_folder*/
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static PurpleNotifyUiOps notify_ops =
+{
+  notify_message, /*notify_message*/
+  NULL,           /*notify_email*/ 
+  NULL,           /*notify_emails*/
+  NULL,           /*notify_formatted*/
+  NULL,           /*notify_searchresults*/
+  NULL,           /*notify_searchresults_new_rows*/
+  NULL,           /*notify_userinfo*/
+  NULL,           /*notify_uri*/
+  NULL,           /*close_notify*/
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+};
+
 static PurpleCoreUiOps core_uiops = 
 {
 	NULL,
 	NULL,
-	ui_init,
+	NULL,
 	NULL,
 
 	/* padding */
@@ -163,8 +286,10 @@ static PurpleCoreUiOps core_uiops =
 	NULL
 };
 
-static void
-sighandler(int sig)
+//I have tried to detect Ctrl-C using ruby's trap method,
+//but it does not work as expected: it can not detect Ctrl-C
+//until a network event occurs
+static void sighandler(int sig)
 {
   switch (sig) {
   case SIGINT:
@@ -173,7 +298,6 @@ sighandler(int sig)
 	}
 }
 
-
 static VALUE init(VALUE self, VALUE debug)
 {
   signal(SIGPIPE, SIG_IGN);
@@ -204,24 +328,51 @@ static VALUE init(VALUE self, VALUE debug)
 
 static VALUE watch_incoming_im(VALUE self)
 {
-  im_hanlder = rb_block_proc();
-  return im_hanlder;
+  purple_conversations_set_ui_ops(&conv_uiops);
+  im_handler = rb_block_proc();
+  return im_handler;
+}
+
+static VALUE watch_notify_message(VALUE self)
+{
+  purple_notify_set_ui_ops(&notify_ops);
+  notify_message_handler = rb_block_proc();
+  return notify_message_handler;
+}
+
+static VALUE watch_request(VALUE self)
+{
+  purple_request_set_ui_ops(&request_ops);
+  request_handler = rb_block_proc();
+  return request_handler;
 }
 
 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);
+  rb_funcall2((VALUE)signed_on_handler, CALL, 1, args);
+  g_free(args);
 }
 
 static VALUE watch_signed_on_event(VALUE self)
 {
-  signed_on_hanlder = rb_block_proc();
+  signed_on_handler = rb_block_proc();
   int handle;
 	purple_signal_connect(purple_connections_get_handle(), "signed-on", &handle,
 				PURPLE_CALLBACK(signed_on), NULL);
-  return signed_on_hanlder;
+  return signed_on_handler;
+}
+
+static VALUE watch_connection_error(VALUE self)
+{
+  purple_connections_set_ui_ops(&connection_ops);
+  
+  connection_error_handler = rb_block_proc();
+  int handle;
+	purple_signal_connect(purple_connections_get_handle(), "connection-error", &handle,
+				PURPLE_CALLBACK(connection_error), NULL);
+  return connection_error_handler;
 }
 
 static void _read_socket_handler(gpointer data, int socket, PurpleInputCondition condition)
@@ -229,24 +380,26 @@ static void _read_socket_handler(gpointer data, int socket, PurpleInputCondition
   char message[4096] = {0};
   int i = recv(socket, message, sizeof(message) - 1, 0);
   if (i > 0) {
-    //printf("recv %d %d\n", socket, i);
+    purple_debug_info("purple_ruby", "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));
+    purple_debug_info("purple_ruby", "close connection %d: %d %d\n", socket, i, errno);
+    
+    close(socket);
+    purple_input_remove(socket);
     
     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);
+    rb_funcall2((VALUE)data, CALL, 1, args);
+    g_free(args);
   }
 }
 
@@ -260,6 +413,7 @@ static void _accept_socket_handler(gpointer data, int server_socket, PurpleInput
 	socklen_t sin_size = sizeof(struct sockaddr);
 	int client_socket;
   if ((client_socket = accept(server_socket, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
+    purple_debug_warning("purple_ruby", "failed to accept %d: %d\n", client_socket, errno);
 		return;
 	}
 	
@@ -269,7 +423,7 @@ static void _accept_socket_handler(gpointer data, int server_socket, PurpleInput
 	fcntl(client_socket, F_SETFD, FD_CLOEXEC);
 #endif
 
-  //printf("new connection: %d\n", client_socket);
+  purple_debug_info("purple_ruby", "new connection: %d\n", client_socket);
 	
 	g_hash_table_insert(hash_table, (gpointer)client_socket, (gpointer)rb_str_new2(""));
 	
@@ -316,6 +470,9 @@ static VALUE watch_incoming_ipc(VALUE self, VALUE serverip, VALUE port)
 static VALUE login(VALUE self, VALUE protocol, VALUE username, VALUE password)
 {
   PurpleAccount* account = purple_account_new(RSTRING(username)->ptr, RSTRING(protocol)->ptr);
+  if (NULL == account || NULL == account->presence) {
+    rb_raise(rb_eRuntimeError, "No able to create account: %s", 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);
@@ -381,6 +538,8 @@ static VALUE add_buddy(VALUE self, VALUE buddy)
   PurpleAccount *account;
   Data_Get_Struct(self, PurpleAccount, account);
   
+	PurpleBuddy* pb = purple_buddy_new(account, RSTRING(buddy)->ptr, NULL);
+  
   char* group = _("Buddies");
   PurpleGroup* grp = purple_find_group(group);
 	if (!grp)
@@ -388,13 +547,35 @@ static VALUE add_buddy(VALUE self, VALUE buddy)
 		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 remove_buddy(VALUE self, VALUE buddy)
+{
+  PurpleAccount *account;
+  Data_Get_Struct(self, PurpleAccount, account);
+  
+	PurpleBuddy* pb = purple_find_buddy(account, RSTRING(buddy)->ptr);
+	if (NULL == pb) {
+	  rb_raise(rb_eRuntimeError, "Failed to remove buddy for %s : %s does not exist", purple_account_get_username(account), RSTRING(buddy)->ptr);
+	}
+	
+	char* group = _("Buddies");
+  PurpleGroup* grp = purple_find_group(group);
+	if (!grp)
+	{
+		grp = purple_group_new(group);
+		purple_blist_add_group(grp, NULL);
+	}
+	
+	purple_blist_remove_buddy(pb);
+	purple_account_remove_buddy(account, pb, grp);
+  return Qtrue;
+}
+
 static VALUE has_buddy(VALUE self, VALUE buddy)
 {
   PurpleAccount *account;
@@ -408,19 +589,29 @@ static VALUE has_buddy(VALUE self, VALUE buddy)
 
 void Init_purple_ruby() 
 {
+  CALL = rb_intern("call");
+
   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_connection_error", watch_connection_error, 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_notify_message", watch_notify_message, 0);
+  rb_define_singleton_method(cPurpleRuby, "watch_request", watch_request, 0);
   rb_define_singleton_method(cPurpleRuby, "watch_incoming_ipc", watch_incoming_ipc, 2);
+  rb_define_singleton_method(cPurpleRuby, "login", login, 3);
   rb_define_singleton_method(cPurpleRuby, "main_loop_run", main_loop_run, 0);
   rb_define_singleton_method(cPurpleRuby, "main_loop_stop", main_loop_stop, 0);
   
+  rb_define_const(cPurpleRuby, "NOTIFY_MSG_ERROR", INT2NUM(PURPLE_NOTIFY_MSG_ERROR));
+  rb_define_const(cPurpleRuby, "NOTIFY_MSG_WARNING", INT2NUM(PURPLE_NOTIFY_MSG_WARNING));
+  rb_define_const(cPurpleRuby, "NOTIFY_MSG_INFO", INT2NUM(PURPLE_NOTIFY_MSG_INFO));
+  
   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, "remove_buddy", remove_buddy, 1);
   rb_define_method(cAccount, "has_buddy?", has_buddy, 1);
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: yong-purple_ruby
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - yong