social_stream-presence 0.1.4 → 0.1.6

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+rsa_keys/*

data/app/controllers/xmpp_controller.rb

@@ -1,5 +1,7 @@
 class XmppController < ApplicationController
   
+  before_filter :authorization, :only => [:setConnection, :unsetConecction, :setPresence, :unsetPresence, :resetConnection, :synchronizePresence ]
+  
   #Mapping XMPP Standar Status to Social Stream Chat Status
   STATUS = {
   '' => 'available', 
@@ -10,14 +12,12 @@ class XmppController < ApplicationController
   }
    
    
-  #API METHODS
+  ############################## 
+  ########## REST API ##########
+  ##############################
   
-  def setConnection  
-    unless authorization
-      render :text => "Authorization error"
-      return
-    end
-    
+  def setConnection
+    params = @dparams
     user = User.find_by_slug(params[:name])
     
     if user && !user.connected
@@ -28,16 +28,12 @@ class XmppController < ApplicationController
        return
     end
     
-    render :text => "Error"
+    render :text => "Ok: The user was already connected"
   end
   
   
   def unsetConecction
-    unless authorization
-      render :text => "Authorization error"
-      return
-    end
-    
+    params = @dparams
     user = User.find_by_slug(params[:name])
     
     if user && user.connected
@@ -47,16 +43,12 @@ class XmppController < ApplicationController
        return
     end
     
-    render :text => "User not connected"
+    render :text => "Ok: The user was already disconnected"
   end
   
   
-  def setPresence  
-    unless authorization
-      render :text => "Authorization error"
-      return
-    end
-    
+  def setPresence 
+    params = @dparams
     user = User.find_by_slug(params[:name])
     status = params[:status]
     
@@ -65,20 +57,16 @@ class XmppController < ApplicationController
         user.connected = true
         user.save!
       end
-      render :text => 'Status changed'
+      render :text => "Ok: Status changed"
     else
-      render :text => 'Status not changed'
+      render :text => "Ok: Status not changed"
     end
     
   end
   
   
-  def unsetPresence  
-    unless authorization
-      render :text => "Authorization error"
-      return
-    end
-    
+  def unsetPresence
+    params = @dparams
     user = User.find_by_slug(params[:name])
     
     if user && user.connected
@@ -88,44 +76,36 @@ class XmppController < ApplicationController
        return
     end
     
-    render :text => "User not connected"
+    render :text => "Ok: The user was already disconnected"
   end
   
   
   def resetConnection
-    unless authorization
-      render :text => "Authorization error"
-      return
-    end
-    
     SocialStream::Presence::XmppServerOrder::resetPresence
-    
     render :text => "Ok" 
   end
   
   
-  def synchronizePresence  
-    unless authorization
-      render :text => "Authorization error"
+  def synchronizePresence
+    params = @dparams
+    
+    #Work without encrypted params
+    if params[:name] == nil or params[:name].empty? or params[:name]==""
+      render :text => "Ok: No users received"
       return
-    end 
-     
-    #Actual connected users
-    user_slugs = params[:name]  
+    end
     
+    #Actual connected users
+    user_slugs = params[:name].split(",")
     SocialStream::Presence::XmppServerOrder::synchronizePresenceForSlugs(user_slugs)
-    
-    render :text => "ok"
-  end
- 
- 
-  def authorization
-    return params[:password] == SocialStream::Presence.xmpp_server_password
+    render :text => "Ok"
   end
   
   
-  def chatWindow
-    
+  
+  #OPEN METHODS
+  
+  def chatWindow 
     if current_user and current_user.chat_enabled and (params[:userConnected]=="true")
       render :partial => 'chat/contacts'
     elsif current_user and current_user.chat_enabled
@@ -183,7 +163,7 @@ class XmppController < ApplicationController
   private
   
   def setStatus(user,status)
-    if user and status and user.status != status and validStatus(status)  
+    if user and status and validStatus(status) and user.status != STATUS[status]
       user.status = STATUS[status]
       user.save!
       return true
@@ -195,4 +175,13 @@ class XmppController < ApplicationController
     return STATUS.keys.include?(status)
   end
   
+  
+  #Authorization to use REST API
+  def authorization
+    unless SocialStream::Presence::XmppServerOrder::authorization(params)
+      render :text => "Authorization error"
+    end
+    @dparams = SocialStream::Presence::XmppServerOrder::decryptParams(params)
+  end
+  
 end

data/ejabberd/conf/ssconfig_example.cfg

@@ -24,7 +24,8 @@ cookie_name=_rails_server_cookie
 
 #Ejabberd Server Password
 ejabberd_password=password
-
+#True to enable REST API Security
+secure_rest_api=false
 
 #Emanagement configuration
 ejabberd_server_user=ejabberd

data/ejabberd/ejabberd_scripts/reset_connection_script

@@ -1,9 +1,14 @@
 #!/usr/bin/env ruby
-#Reset Connection Script
+#Rest Api Client Script
+#Version: 13-12-2011
 #@author Aldo
 
+
 require 'logger'
 require 'rest_client'
+require 'openssl'
+require 'digest/md5'
+
 
 path = "/var/log/ejabberd/scripts.log"
 file = File.open(path, File::WRONLY | File::APPEND | File::CREAT)
@@ -25,31 +30,268 @@ def getOption(option)
   return "Undefined"
 end
 
-$url = "http://" + getOption("web_domain=") + "/xmpp/resetConnection"
+#Constants
+$secure_rest_api = getOption("secure_rest_api=")
 $pass = getOption("ejabberd_password=")
+$scripts_path = getOption("scripts_path=")
+$script_title = "Reset Connection script"
+
+
+def log(title,text)
+	$logger.info title + ": " + text
+end
+
+def getMethodName
+  caller[0] =~ /`(.*?)'/
+  $1
+end
+
+
+#####################
+#####  Example  #####
+#####################
+#def myHook(param1,param2)
+#    log(getMethodName,"(My message: #{param1},#{param2})")
+#    url = "http://" + getOption("web_domain=") + "/xmpp/hookRoute"
+
+#    params = {}
+#    encrypted_params = {}
+#    #Add params to sent in clear
+#    params[:param1_in_server]=param1
+#    #Add params to sent cipher
+#    encrypted_params[:param2_in_server]=param2
+
+#    return [getMethodName,generic_api_call(url,params,encrypted_params)]
+#end
+
+def setConnection(username)
+    log($script_title,"#{getMethodName}(#{username})")
+    url = "http://" + getOption("web_domain=") + "/xmpp/setConnection"
+
+    params = {}
+    encrypted_params = {}
+    encrypted_params[:name]=username
+
+    return [getMethodName,generic_api_call(url,params,encrypted_params)]
+end
+
+
+def unsetConnection(username)
+    log($script_title,"#{getMethodName}(#{username})")
+    url = "http://" + getOption("web_domain=") + "/xmpp/unsetConnection"
+
+    params = {}
+    encrypted_params = {}
+    encrypted_params[:name]=username
 
+    return [getMethodName,generic_api_call(url,params,encrypted_params)]
+end
+
+
+def setPresence(username,status)
+    log($script_title,"#{getMethodName}(#{username},#{status})")
+    url = "http://" + getOption("web_domain=") + "/xmpp/setPresence"
+
+    params = {}
+    encrypted_params = {}
+    encrypted_params[:name]=username
+    encrypted_params[:status]=status
+
+    return [getMethodName,generic_api_call(url,params,encrypted_params)]
+end
+
+
+def unsetPresence(username)
+    log($script_title,"#{getMethodName}(#{username})")
+    url = "http://" + getOption("web_domain=") + "/xmpp/unsetPresence"
+
+    params = {}
+    encrypted_params = {}
+    encrypted_params[:name]=username
 
-def log(text)
-	$logger.info "Reset Connection Script: " + text
+    return [getMethodName,generic_api_call(url,params,encrypted_params)]
 end
 
 
 def resetConnection()
+    log($script_title,"Call #{getMethodName}()")
+    url = "http://" + getOption("web_domain=") + "/xmpp/resetConnection"
+
+    params = {}
+    encrypted_params = {}
+
+    return [getMethodName,generic_api_call(url,params,encrypted_params)]
+end
+
+
+def synchronize()
+    log($script_title,"Call #{getMethodName}()")
+    url = "http://" + getOption("web_domain=") + "/xmpp/synchronizePresence"
+
+
+    #Get connected users using Emanagement
+    users = []
+    command = $scripts_path + "/emanagement getConnectedUsers"
+    output = %x[#{command}]
+    sessions = output.split("\n")
+
+    sessions.each do |session|
+      users << session.split("@")[0]
+    end
+    #Finish
+
+
+    #In this cases users always will be sent in clear (not cipher)
+    #(Too much data to cipher)
+    #Anyway, we must to build the hash to pass the authentication
+    params = {}
+    encrypted_params = {}
+    params[:name]=users.join(",")
+
+    return [getMethodName,generic_api_call(url,params,encrypted_params)]
+end
+
+
+
+#Params must include the password and all the parameters to be sent in clear.
+#Anyway, If "secure_rest_api" is disable, encrypted_params will be send in clear.
+def generic_api_call(url,params,encrypted_params)
+
   begin
-    RestClient.post($url, :password => $pass)
-    return true
+    unless params
+ 	params = {}
+    end
+
+    unless encrypted_params
+ 	 encrypted_params = {}
+    end
+
+    params[:password]=$pass
+
+    response=sendHttpRequest(url,params,encrypted_params)
+    puts response.body
+
+    if response.body.include?("Ok")
+    	return true
+    else
+    	return false
+    end
+
   rescue => e
-    log("#{e.class.name}: #{e.message}")
+    log($script_title,"#{e.class.name}: #{e.message}")
+    puts("#{e.class.name}: #{e.message}")
     return false
   end
 end
 
-if (resetConnection())
-  puts "Reset Connection [OK]"
-  log( "Reset Connection [OK]" )
-else
-  puts "Reset Connection [FAIL]"
-  log( "Reset Connection [FAIL]" )
+
+#Send HTTP Request to Social Stream Presence API
+def sendHttpRequest(url,params,encrypted_params)
+
+    unless params[:password]
+	return "params[:password] required in sendHttpRequest";
+    end
+
+
+    if $secure_rest_api == "true"
+	xmpp_private_key_path = $scripts_path + "/rsa_keys/xmpp_rsa_key_private.pem";
+    	web_public_key_path = $scripts_path + "/rsa_keys/web_rsa_key_public.pem";
+    	xmpp_private_key = OpenSSL::PKey::RSA.new(File.read(xmpp_private_key_path))
+    	web_public_key = OpenSSL::PKey::RSA.new(File.read(web_public_key_path))
+
+	request_params = {};
+
+	#Copy non encypted params
+        params.each do |key,value|
+	  unless key.to_s == "password"
+		request_params[key] = value
+	  end 
+        end
+
+	#Include encrypted params
+	if encrypted_params and encrypted_params.empty? == false
+	  request_params[:encrypted_params] = web_public_key.public_encrypt(encrypted_params.to_s)
+	end
+	
+	#Generating stamp
+	#1 Get constant password
+	password = params[:password];
+	#2 Generating timestamp
+	timestamp = Time.now.utc.to_s
+	#3 Calculating Hash
+    	hash = calculateHash(request_params)
+
+	#Add cipher stamp to the request
+	request_params[:password] = xmpp_private_key.private_encrypt(password+"#####"+timestamp+"#####"+hash)
+	
+	#Replace previous params
+	params = request_params
+    else
+	#Non secure mode: send encrypted params in clear
+	if encrypted_params
+	  encrypted_params.each do |key,value|
+	      params[key] = value
+	  end
+	end
+    end
+    
+    response = RestClient.get url, :params => params
+    return response
 end
 
 
+def calculateHash(request_params)
+	unless request_params
+		request_params = {};
+	end
+
+	hash = "";
+        request_params.each do |key,value|
+              hash = hash + key.to_s + value.to_s
+        end
+        return Digest::MD5.hexdigest(hash)
+end
+
+
+
+
+def invokeApiCall(method,args)
+	length = args.length;
+	case length
+	when 0
+	  return send(method)
+	when 1
+	  return send(method,args[0])
+	when 2
+	  return send(method,args[0],args[1])
+	when 3
+	  return send(method,args[0],args[1],args[2])
+	when 4
+	  return send(method,args[0],args[1],args[2],args[3])
+	else
+	  return send(method,args)
+	end
+end
+
+
+#Main Program
+
+begin
+
+	args = []
+	method = "resetConnection";
+
+	if (response = invokeApiCall(method, args) and response[1])
+	  	puts $script_title  + ": #{response[0]} [OK]"
+	  	log( $script_title  , "#{response[0]} [OK]" )
+	else
+	  	puts $script_title  + ": #{response[0]} [FAIL]"
+	  	log( $script_title  , "#{response[0]} [FAIL]" )
+	end
+
+rescue => e
+	log($script_title,"#{e.class.name}: #{e.message}")
+   	puts("#{e.class.name}: #{e.message}")
+    	exit 1
+end
+