xmpp4r 0.3

data/data/doc/xmpp4r/examples/advanced/shellmgr/shellmgr_jabber.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby -w
+
+$:.unshift '../../lib'
+require 'shellmgr'
+require 'xmpp4r'
+include Jabber
+
+if ARGV.length != 3
+  puts "usage: ./shellmgr_jabber.rb jid_to_use password jid_to_authorize"
+  exit(1)
+end
+
+myjid = JID::new(ARGV[0])
+mypassword = ARGV[1]
+authjid = JID::new(ARGV[2])
+
+myjid = JID::new(myjid.node, myjid.domain, 'RSM')
+cl = Client::new(myjid)
+cl.connect
+cl.auth(mypassword)
+mainthread = Thread.current
+sh = Shell::new { |str| 
+  puts "-----RECEIVING-----\n#{str}"
+  cl.send(Message::new(authjid, str)) }
+cl.add_message_callback do |m|
+  if JID::new(m.from).strip.to_s != authjid.strip.to_s
+    puts "Received message from non-authorized user #{m.from}"
+  else
+    if m.body == "killshell"
+      cl.send(Message::new(authjid, "Exiting..."))
+      mainthread.wakeup
+    else
+      puts "-----EXECUTING-----\n#{m.body}"
+      sh.puts(m.body)
+    end
+  end
+end
+cl.send(Presence::new)
+puts "Connected ! Ask #{authjid.to_s} to send commands to #{myjid.to_s}"
+cl.send(Message::new(authjid, "I'm ready to receive commands from you."))
+Thread.stop
+cl.close
+sh.kill

data/data/doc/xmpp4r/examples/advanced/shellmgr/shellmgr_test.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby -w 
+
+require 'shellmgr'
+
+sh = Shell::new { |s| puts s }
+
+while true do
+  l = gets
+  sh.puts l
+end

data/data/doc/xmpp4r/examples/advanced/versionpoll.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby
+
+# This script will request the version information of a list of JID given
+# on stdin.
+
+$:.unshift '../lib'
+
+require 'optparse'
+require 'xmpp4r/client'
+require 'xmpp4r/version/iq/version'
+include Jabber
+#Jabber::debug = true
+
+# settings
+jid = JID::new('bot@localhost/Bot')
+password = 'bot'
+domains = []
+OptionParser::new do |opts|
+  opts.banner = 'Usage: versionpoll.rb -j jid -p password -d DOMAINS'
+  opts.separator ''
+  opts.on('-j', '--jid JID', 'sets the jid') { |j| jid = JID::new(j) }
+  opts.on('-p', '--password PASSWORD', 'sets the password') { |p| password = p }
+  opts.on('-d', '--domain DOMAIN', 'sets the domain') { |d| domains << d }
+  opts.on_tail('-h', '--help', 'Show this message') {
+    puts opts
+    exit
+  }
+  opts.parse!(ARGV)
+end
+
+cl = Client::new(jid)
+cl.connect
+cl.auth(password)
+sent = []
+queried = []
+activity = false
+cl.add_iq_callback do |i|
+  fjid = JID::new(i.from)
+  if i.type == :result and fjid.resource == "admin"
+    domain = fjid.domain
+    items = i.first_element('item')
+    raise "items nil" if items.nil?
+    items.each_element('user') do |e|
+      j = e.attribute('jid')
+      if not queried.include?(j)
+        activity = true
+        queried << j
+        cl.send(Iq::new_browseget.set_to(j))
+      end
+    end
+  end
+end
+
+cl.add_iq_callback do |i|
+  if i.type == :result
+    u = i.first_element('user')
+    if u
+      u.each_element('user') do |e|
+        if (a = e.attribute('type'))
+          if a.value == 'client'
+            activity = true
+            iq = Iq::new(:get)
+            iq.query = Version::IqQueryVersion::new
+            iq.set_to(JID::new(e.attribute('jid').to_s))
+            cl.send(iq)
+          end
+        end
+      end
+    end
+  end
+end
+cl.add_iq_callback do |iq|
+  if iq.type == :result and iq.query.class == Version::IqQueryVersion
+    activity = true
+    r = [ iq.from.to_s, iq.query.iname, iq.query.version, iq.query.os ]
+    puts r.inspect
+  end
+end
+cl.send(Presence::new)
+for d in domains do
+  cl.send(Iq::new_browseget.set_to("#{d}/admin"))
+end
+
+activity = true
+while activity
+  activity = false
+  # other threads might set activity to true
+  sleep 10
+end
+cl.close

data/data/doc/xmpp4r/examples/advanced/xmpping.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+# This is PING for Jabber
+#
+# Please customize your ~/.xmppingrc
+
+
+require 'xmpp4r'
+require 'xmpp4r/version/iq/version'
+require 'xmpp4r/discovery/iq/discoinfo'
+require 'optparse'
+require 'yaml'
+require 'thread'
+
+
+##
+# Options
+##
+
+interval = 5
+jid = nil
+conf_filename = "#{ENV['HOME']}/.xmppingrc"
+accountname = 'default'
+
+OptionParser.new { |opts|
+  opts.banner = 'Usage: xmpping.rb [-d] [-a ACCOUNT] [-c FILENAME] [-i SECONDS] -t <JID>'
+  opts.separator 'Ping a destination JID with various <iq/> stanzas'
+  opts.on('-t', '--to JID', 'Destionation Jabber-ID') { |j| jid = Jabber::JID.new(j) }
+  opts.on('-a', '--account ACCOUNT', 'Account tag to use (default: default)') { |a| accountname = a }
+  opts.on('-c', '--config FILENAME', 'Configuration file (default: ~/.xmppingrc)') { |c| conf_filename = c }
+  opts.on('-i', '--interval SECONDS', 'Wait SECONDS between each stanza (default: 5)') { |sec| interval = sec.to_i }
+  opts.on('-d', '--debug', 'Enable XMPP4R debugging (print stanzas)') { Jabber::debug = true }
+  opts.on_tail('-h', '--help', 'Show help') {
+    puts opts
+    exit
+  }
+  opts.parse!(ARGV)
+
+  unless jid
+    puts opts
+    exit
+  end
+}
+
+
+##
+# Configuration
+##
+
+begin
+  conf_file = File.new(conf_filename)
+rescue Exception => e
+  puts "Unable to open config file: #{e.to_s}"
+  exit
+end
+
+conf = YAML::load(conf_file)
+unless conf
+  puts "#{conf_filename} is no valid YAML document"
+  exit
+end
+account = conf[accountname]
+unless account
+  puts "Account #{accountname} not found in #{conf_filename}"
+  exit
+end
+
+##
+# Connection
+##
+
+cl = Jabber::Client.new(Jabber::JID.new(account['jid']))
+cl.connect(account['host'], (account['port'] ? account['port'].to_i : 5222))
+cl.auth(account['password'])
+
+##
+# Reply printer
+##
+
+def print_reply(iq, roundtrip)
+  roundtrip_s = ((roundtrip * 100).round / 100.0).to_s + " sec"
+  output = "Received a #{iq.query.namespace} #{iq.type} from #{iq.from} (#{roundtrip_s}): "
+
+  if iq.query.kind_of?(Jabber::Version::IqQueryVersion)
+    output += "#{iq.query.iname}-#{iq.query.version} #{iq.query.os}"
+  elsif iq.query.namespace == 'jabber:iq:time'
+    output += "#{iq.query.first_element_text('display')} (#{iq.query.first_element_text('tz')})"
+  elsif iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoInfo)
+    identity = iq.query.identity
+    if identity
+      output += "#{identity.iname} (#{identity.category} #{identity.type})"
+    else
+      output += "<identity/> missing"
+    end
+  else
+    output += iq.query.to_s
+  end
+
+  puts output
+end
+
+##
+# Main loop
+##
+
+puts "XMPPING #{cl.jid} -> #{jid}"
+query_methods = ['jabber:iq:version', 'jabber:iq:time', 'http://jabber.org/protocol/disco#info']
+query_method = 0
+
+loop {
+  Thread.new {
+    iq = Jabber::Iq.new_query(:get, jid)
+    iq.query.add_namespace(query_methods[query_method])
+
+    time1 = Time.new
+
+    begin
+      cl.send_with_id(iq) { |reply|
+        print_reply(reply, Time.new - time1)
+        true
+      }
+    rescue Jabber::ErrorException => e
+      puts "Error for #{iq.query.namespace} to #{iq.to}: #{e.error.to_s.inspect}"
+    end
+  }
+
+  query_method += 1
+  if query_method >= query_methods.size
+    query_method = 0
+  end
+  
+  sleep(interval)
+}
+

data/data/doc/xmpp4r/examples/advanced/xmppingrc.sample

@@ -0,0 +1,9 @@
+default:
+  jid: user@host/xmpping
+  password: secret
+
+other_account:
+  jid: me@domain/ping
+  password: xxx
+  host: 127.0.0.1
+  port: 65222

data/data/doc/xmpp4r/examples/basic/change_password.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+#
+# A tool to change the password of a Jabber account
+#
+
+
+$:.unshift('../../../../../lib')
+
+require 'xmpp4r'
+include Jabber
+
+def with_status(str, &block)
+  print "#{str}..."
+  $stdout.flush
+  begin
+    yield
+    puts " Ok"
+  rescue Exception => e
+    puts " Error: #{e.to_s}"
+    raise e
+  end
+end
+
+
+# settings
+if ARGV.length != 3
+  puts "Run with ./change_password.rb user@server/resource oldpassword newpassword"
+  exit 1
+end
+my_jid = JID::new(ARGV[0])
+my_jid.resource = 'change_password' if my_jid.resource.nil?
+old_password = ARGV[1]
+new_password = ARGV[2]
+
+cl = Client::new(my_jid)
+
+with_status('Connecting') { cl.connect }
+with_status('Authenticating') { cl.auth(old_password) }
+with_status('Changing password') { cl.password = new_password }
+
+cl.close

data/data/doc/xmpp4r/examples/basic/client.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/ruby
+
+# Basic console client that does nothing, but easy to modify to test things.
+# to test, start, then type :
+# connect login@server/resource password
+# auth
+
+require 'xmpp4r/client'
+include Jabber
+
+Jabber::debug = true
+
+class BasicClient
+  def initialize
+    puts "Welcome to this Basic Console Jabber Client!"
+    quit = false
+    # main loop
+    while not quit do
+      print "> "
+      $defout.flush
+      line = gets
+      quit = true if line.nil?
+      if not quit
+        command, args = line.split(' ', 2)
+        args.chomp!
+        # main case
+        case command
+        when 'exit'
+          quit = true
+        when 'connect'
+          do_connect(args)
+        when 'help'
+          do_help
+        when 'auth'
+          do_auth
+        else
+          puts "Command \"#{command}\" unknown"
+        end
+      end
+    end
+    puts "Goodbye!"
+  end
+
+  def do_help
+    puts <<-EOF
+# exit - exits
+# connect user@server/resource password - connects
+# auth - sends authentification
+    EOF
+  end
+
+  ##
+  # connect <jid> <password>
+  def do_connect(args)
+    @jid, @password = args.split(' ', 3)
+    @jid = JID::new(@jid)
+    @cl = Client::new(@jid)
+    @cl.connect
+  end
+
+  ##
+  # auth
+  def do_auth
+    @cl.auth(@password, false)
+  end
+end
+
+BasicClient::new

data/data/doc/xmpp4r/examples/basic/component.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+
+$:.unshift '../../../../../lib'
+
+require 'xmpp4r'
+include Jabber
+
+c = Component::new('tada', 'localhost', 60001)
+c.connect
+c.auth('jabber-rocks')
+Thread.stop

data/data/doc/xmpp4r/examples/basic/echo_nonthreaded.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/ruby
+
+# This bot will reply to every message it receives. To end the game, send 'exit'
+# NON-THREADED VERSION
+
+require 'xmpp4r'
+include Jabber
+
+# settings
+if ARGV.length != 2
+  puts "Run with ./echo_thread.rb user@server/resource password"
+  exit 1
+end
+myJID = JID::new(ARGV[0])
+myPassword = ARGV[1] 
+cl = Client::new(myJID, false)
+cl.connect
+cl.auth(myPassword)
+cl.send(Presence::new)
+puts "Connected ! send messages to #{myJID.strip.to_s}."
+exit = false
+cl.add_message_callback { |m|
+  cl.send(Message::new(m.from, "You sent: #{m.body}"))
+  if m.body == 'exit'
+    cl.send(Message::new(m.from, "Exiting ..."))
+    exit = true
+  end
+}
+while not exit
+  cl.process
+end
+cl.close

data/data/doc/xmpp4r/examples/basic/echo_threaded.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/ruby
+
+# This bot will reply to every message it receives. To end the game, send 'exit'
+# THREADED VERSION
+
+require 'xmpp4r/client'
+include Jabber
+
+# settings
+if ARGV.length != 2
+  puts "Run with ./echo_thread.rb user@server/resource password"
+  exit 1
+end
+myJID = JID::new(ARGV[0])
+myPassword = ARGV[1] 
+cl = Client::new(myJID)
+cl.connect
+cl.auth(myPassword)
+cl.send(Presence::new)
+puts "Connected ! send messages to #{myJID.strip.to_s}."
+mainthread = Thread.current
+cl.add_message_callback do |m|
+  if m.type != :error
+    cl.send(Message::new(m.from, "You sent: #{m.body}"))
+    if m.body == 'exit'
+      cl.send(Message::new(m.from, "Exiting ..."))
+      mainthread.wakeup
+    end
+  end
+end
+Thread.stop
+cl.close

data/data/doc/xmpp4r/examples/basic/jabbersend.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+
+# This script will send a jabber message to the specified JID. The subject can be
+# specified using the '-s' option, and the message will be taken from stdin.
+
+$:.unshift '../../../../../lib'
+
+require 'optparse'
+require 'xmpp4r'
+include Jabber
+
+# settings
+myJID = JID::new('bot@localhost/Bot')
+myPassword = 'bot'
+
+to = nil
+subject = ''
+OptionParser::new do |opts|
+  opts.banner = 'Usage: jabbersend.rb -s \'subject\' -t dest@domain'
+  opts.separator ''
+  opts.on('-s', '--subject SUBJECT', 'sets the message\'s subject') { |s| subject = s }
+  opts.on('-t', '--to DESTJID', 'sets the receiver') { |t| to = JID::new(t) }
+  opts.on_tail('-h', '--help', 'Show this message') {
+    puts opts
+    exit
+  }
+  opts.parse!(ARGV)
+end
+
+if to.nil?
+  puts "No receiver specified. See jabbersend -h"
+end
+
+cl = Client::new(myJID, false)
+cl.connect
+cl.auth(myPassword)
+body = STDIN.readlines.join
+m = Message::new(to, body).set_type(:normal).set_id('1').set_subject(subject)
+puts m.to_s
+cl.send(m)
+cl.close

data/data/doc/xmpp4r/examples/basic/mass_sender.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/ruby
+
+# This script will send a jabber message to a list of JID given on stdin.
+
+$:.unshift '../../../../../lib'
+
+require 'optparse'
+require 'xmpp4r'
+include Jabber
+#Jabber::debug = true
+
+# - message in file
+# - subject in command line
+# - JID list on stdin
+
+# settings
+jid = JID::new('bot@localhost/Bot')
+password = 'bot'
+filename = 'message.txt'
+
+subject = "Message de test"
+
+OptionParser::new do |opts|
+  opts.banner = 'Usage: mass_sender.rb -j jid -p password'
+  opts.separator ''
+  opts.on('-j', '--jid JID', 'sets the jid') { |j| jid = JID::new(j) }
+  opts.on('-p', '--password PASSWORD', 'sets the password') { |p| password = p }
+  opts.on('-f', '--filename MESSAGE', 'sets the filename containing the message') { |f| filename = f }
+  opts.on('-s', '--subject SUBJECT', 'sets the subject') { |s| subject = s }
+  opts.on_tail('-h', '--help', 'Show this message') {
+    puts opts
+    exit
+  }
+  opts.parse!(ARGV)
+end
+
+body = IO::read(filename).chomp
+
+cl = Client::new(jid, false)
+cl.connect
+cl.auth(password)
+exit = false
+sent = []
+cl.add_message_callback do |m|
+  if m.type != :error
+    if !sent.include?(m.from)
+      cl.send(Message::new(m.from, "Je suis un robot. Si tu souhaites contacter un administrateur du serveur, envoie un message à lucas@nussbaum.fr ou rejoins la salle jabberfr@chat.jabberfr.org."))
+      sent << m.from
+    end
+    if m.body == 'exitnowplease'
+      cl.send(Message::new(m.from, "Exiting ..."))
+      exit = true
+    end
+    cl.send(Message::new('lucas@nussbaum.fr', "From #{m.from}: #{m.body.to_s}"))
+  end
+end
+cl.send(Presence::new)
+m = Message::new(nil, body)
+STDIN.each_line { |l|
+  l.chomp!
+  m.set_to(JID::new(l).to_s)
+  cl.send(m)
+}
+while not exit do
+	cl.process(1)
+end
+cl.close

data/data/doc/xmpp4r/examples/basic/mucinfo.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'xmpp4r'
+require 'xmpp4r/muc/helper/mucbrowser'
+
+if ARGV.size != 3
+  puts "Usage: #{$0} <jid> <password> <muc-jid>"
+  exit
+end
+
+jid, password, muc_jid = Jabber::JID.new(ARGV.shift), ARGV.shift, Jabber::JID.new(ARGV.shift)
+
+cl = Jabber::Client.new(jid)
+cl.connect
+cl.auth(password)
+
+browser = Jabber::MUC::MUCBrowser.new(cl)
+
+print "Querying #{muc_jid} for identity..."; $stdout.flush
+name = browser.muc_name(muc_jid)
+
+if name.nil?
+  puts " Sorry, but the queried MUC component doesn't seem to support MUC or Groupchat."
+else
+  puts " #{name}"
+  
+  print "Querying #{muc_jid} for its rooms..."; $stdout.flush
+  rooms = browser.muc_rooms(muc_jid)
+  puts " #{rooms.size} rooms found"
+
+  max_room_length = 0
+  rooms.each_key { |jid| max_room_length = jid.to_s.size if jid.to_s.size > max_room_length }
+
+  rooms.each { |jid,name|
+    puts "#{jid.to_s.ljust(max_room_length)} #{name}"
+  }
+end
+
+cl.close