xmpp4r 0.3

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

@@ -0,0 +1,89 @@
+#!/usr/bin/ruby
+
+# This script can be used to migrate from one jabber account to another
+
+$:.unshift '../lib'
+
+require 'optparse'
+require 'xmpp4r'
+include Jabber
+
+jidfrom = JID::new('lucas@linux.ensimag.fr/JabberMigrate')
+pwfrom = 'z'
+jidto = JID::new('lucas@nussbaum.fr/JabberMigrate')
+pwto = 'z'
+
+BOTHOLD = "Hi, you are subscribed to my presence. I just changed my JID. The new one is #{jidto.strip}. You might want to update your roster. Thank you, and sorry for the inconvenience !"
+BOTHNEW = "Hi, you are subscribed to the presence of my previous JID : #{jidfrom.strip}. I just changed my JID, and this is the new one. You might want to update your roster. Thank you, and sorry for the inconvenience !"
+
+clfrom = Client::new(jidfrom, false)
+clfrom.connect
+clfrom.auth(pwfrom)
+clto = Client::new(jidto, false)
+clto.connect
+clto.auth(pwto)
+#clfrom.send(Presence::new)
+#clto.send(Presence::new)
+clfrom.send(Iq::new_rosterget)
+exit = false
+clfrom.add_iq_callback { |i|
+  if i.type == :result and i.queryns == 'jabber:iq:roster'
+    i.query.each_element do |e|
+      e.text = ''
+      jid = e.attribute('jid')
+      name = e.attribute('name')
+      subscription = e.attribute('subscription')
+      ask = e.attribute('ask')
+      jid &&= jid.value
+      next if jid =~ /@(icq|msn|aim|yahoo).blop.info/
+#      next if jid !~ /lucas@im.apinc.org/
+      puts "Processing #{e.to_s}"
+#      Jabber::debug = true
+      name &&= name.value
+      subscription &&= subscription.value
+      ask &&= ask.value
+      puts subscription
+      case subscription
+      when 'from'
+        # il veut me voir, je veux pas le voir.
+        # envoi unsubscribed
+        clfrom.send(Presence::new.set_to(jid).set_type(:unsubscribed))
+        # envoi message d'info OLD & NEW
+        clfrom.send(Message::new(jid, BOTHOLD).set_type(:chat))
+        clto.send(Message::new(jid, BOTHNEW).set_type(:chat))
+      when 'to'
+        # je veux le voir, il veut pas me voir
+        # envoi unsubscribe
+        clfrom.send(Presence::new.set_to(jid).set_type(:unsubscribe))
+        # envoi subscribe avec message
+        pres = Presence::new.set_to(jid).set_type(:subscribe)
+        pres.add(Element::new('status').add_text("Hi, I was previously subscribed to your presence with my JID #{jidfrom.strip}. Can I re-subscribe to your presence ? Thank you."))
+        clto.send(pres)
+      when 'both'
+        # envoi unsubscribed
+        clfrom.send(Presence::new.set_to(jid).set_type(:unsubscribed))
+        # envoi unsubscribe
+        clfrom.send(Presence::new.set_to(jid).set_type(:unsubscribe))
+        # update roster
+        iq = Iq::new_rosterset
+        e.delete_attribute('ask')
+        e.delete_attribute('subscription')
+        iq.query.add_element(e)
+        clto.send(iq)
+        # envoi message d'info OLD & NEW
+        clfrom.send(Message::new(jid, BOTHOLD).set_type(:chat))
+        pres = Presence::new.set_to(jid).set_type(:subscribe)
+        pres.add(Element::new('status').add_text("Hi, I was previously subscribed to your presence with my JID #{jidfrom.strip}. Can I re-subscribe to your presence ? Thank you."))
+        clto.send(pres)
+        clto.send(Message::new(jid, BOTHNEW).set_type(:chat))
+      end
+    end
+  end
+}
+while not exit
+  clfrom.process
+  clto.process
+end
+clfrom.close
+clto.close
+

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

@@ -0,0 +1,266 @@
+#!/usr/bin/ruby
+
+$:.unshift '../../../../../lib'
+
+require 'xmpp4r'
+require 'xmpp4r/iq/query/discoinfo'
+require 'xmpp4r/iq/query/discoitems'
+require 'xmpp4r/x/muc'
+
+
+#Jabber::debug = true
+
+class Room
+  class RoomException < Exception
+    attr_reader :error
+    def initialize(error, msg)
+      @error = Jabber::Error.new(error, msg)
+    end
+  end
+  
+  def initialize(stream, name)
+    @users = {}   # nick => jid
+    @stream = stream
+    @name = name
+  end
+
+  def num_users
+    @users.size
+  end
+
+  def each_user(&block)
+    @users.each { |n,j| yield(n, j) }
+  end
+
+  def handle_message(msg)
+    origin = msg.from
+    msg.from = nil
+    @users.each { |nick,jid|
+      if jid == origin
+        msg.from = Jabber::JID::new(@name.node, @name.domain, nick)
+      end
+    }
+    unless msg.from.nil?
+      broadcast(msg)
+    end
+
+    true
+  end
+
+  def handle_presence(pres)
+    reason = nil
+    
+    # Check if nick already registered
+    @users.each { |nick,jid|
+      if pres.from != jid && pres.to.resource == nick
+        puts "#{pres.from} tried to use already active #{pres.to}"
+        raise RoomException.new('conflict', "Nick already used")
+      end
+    }
+    # New user?
+    unless @users.has_key?(pres.to.resource)
+      # Check nick length
+      if pres.to.resource.size < 1
+        puts "#{pres.from} tried to use empty nick"
+        raise RoomException.new('not-acceptable', "Nick must contain characters")
+      end
+
+      # Push user-list
+      userinfo = Jabber::Presence.import(pres)
+      userinfo.to = pres.from
+      userinfo.add(Jabber::XMucUser.new).add(Jabber::XMucUserItem.new(:none, :participant))
+      print "Sending all users for #{pres.to} to #{pres.from}:"
+      @users.each { |nick,jid|
+        userinfo.from = Jabber::JID::new(@name.node, @name.domain, nick)
+        print " #{nick} (#{jid})"
+        @stream.send(userinfo)
+      }
+      puts " Ok"
+      
+      # Add the new user
+      puts "Adding #{pres.from} as #{pres.to}"
+      @users[pres.to.resource] = pres.from
+
+      send_message("#{pres.to.resource} joins #{@name.node}")
+      reason = "#{pres.to.resource} joins #{@name.node}"
+    end
+
+    # Remove dead rats
+    if pres.type == :error || pres.type == :unavailable
+      was_nick = nil
+      @users.delete_if { |nick,jid|
+        was_nick = nick
+        jid == pres.from
+      }
+      unless was_nick.nil?
+        send_message("#{was_nick} has left #{@name.node}")
+        reason = "#{was_nick} has left #{@name.node}"
+      end
+    end
+    
+    # Advertise users presence to all
+    puts "Advertising user to all"
+    x = Jabber::XMucUserItem.new(:none, :participant, pres.from)
+    x.reason = reason
+    pres.add(Jabber::XMucUser.new).add(x)
+    pres.from = pres.to
+    broadcast(pres)
+  end
+
+  def send_message(body)
+    msg = Jabber::Message::new
+    msg.from = Jabber::JID::new(@name.node, @name.domain, "")
+    msg.type = :groupchat
+    msg.body = body
+    broadcast(msg)
+  end
+  
+  def broadcast(stanza)
+    x = stanza.class::import(stanza)
+    @users.each { |nick,jid|
+      x.to = jid
+      @stream.send(x)
+    }
+  end
+end
+
+class MUC
+  def initialize(jid, secret, addr, port=5347)
+    @rooms = {}
+    
+    @component = Jabber::Component::new(jid, addr, port)
+    @component.connect
+    @component.auth(secret)
+
+    @component.add_iq_callback { |iq|
+      handle_iq(iq)
+    }
+    @component.add_presence_callback { |pres|
+      handle_presence(pres)
+    }
+    @component.add_message_callback { |msg|
+      handle_message(msg)
+    }
+  end
+
+  def handle_iq(iq)
+    puts "#{iq.from} #{iq.queryns} to #{iq.to}"
+    if iq.query.kind_of?(Jabber::IqQueryDiscoInfo)
+      handle_disco_info(iq)
+      true
+    elsif iq.query.kind_of?(Jabber::IqQueryDiscoItems)
+      handle_disco_items(iq)
+      true
+    else
+      false
+    end
+  end
+
+  def handle_presence(pres)
+    room = nil
+    @rooms.each { |name,r|
+      room = r if name == pres.to.strip
+    }
+
+    if room.nil? && pres.type.nil? && (pres.to.node.to_s != '')
+      room = Room.new(@component, pres.to.strip)
+      @rooms[pres.to.strip] = room
+    elsif room.nil? && pres.type != :error
+      pres.to, pres.from = pres.from, pres.to
+      pres.type = :error
+      pres.add(Jabber::Error.new('item-not-found'))
+      @component.send(pres)
+      return(true)
+    end
+
+    begin
+      room.handle_presence(pres)
+    rescue Room::RoomException => e
+      pres.to, pres.from = pres.from, pres.to
+      pres.type = :error
+      pres.add(e.error)
+      @component.send(pres)
+      return(true)
+    end
+    return(false)
+  end
+
+  def handle_message(msg)
+    puts "Message from #{msg.from} to #{msg.to} (#{msg.type}): #{msg.body.inspect}"
+    return if msg.type == :error
+
+    room = @rooms[msg.to]
+    unless room.nil?
+      room.handle_message(msg)
+    else
+      msg.to, msg.from = msg.from, msg.to
+      msg.type = :error
+      msg.add(Jabber::Error.new('item-not-found', 'The chatroom you are trying to reach is currently not available.'))
+      @component.send(msg)
+    end
+  end
+  
+  def handle_disco_info(iq)
+    if (iq.type == :get)
+      iq.type = :result
+      iq.query = Jabber::IqQueryDiscoInfo.new
+      if iq.to.node == nil
+        iq.query.add(Jabber::DiscoIdentity.new('conference', 'Minimal Multi-User Chat', 'text'))
+      else
+        room = @rooms[iq.to]
+        if room.nil?
+          iq.type = :error
+          iq.add_element(Jabber::Error.new('item-not-found'))
+        else
+          iq.query.add(Jabber::DiscoIdentity.new('conference', "#{iq.to.node} (#{room.num_users})", 'text'))
+        end
+      end
+      [Jabber::IqQueryDiscoInfo.new.namespace,
+       Jabber::IqQueryDiscoItems.new.namespace,
+       Jabber::XMuc.new.namespace,
+       Jabber::XMucUser.new.namespace].each { |ns|
+          iq.query.add(Jabber::DiscoFeature.new(ns))
+      }
+    else
+      iq.type = :error
+      iq.add_element(Jabber::Error.new('bad-request'))
+    end
+    iq.to, iq.from = iq.from, iq.to
+    @component.send(iq)
+  end
+
+  def handle_disco_items(iq)
+    if (iq.type == :get)
+      iq.type = :result
+      if iq.to.node == nil
+        @rooms.each { |name,room|
+          iq.query.add(Jabber::DiscoItem::new(Jabber::JID::new(name, @component.jid.domain), name))
+        }
+      elsif iq.to.resource == nil
+        room = @rooms[iq.to.strip]
+        unless room.nil?
+          room.each_user { |nick,jid|
+            iq.query.add(Jabber::DiscoItem::new(jid, nick))
+          }
+        else
+          iq.type = :error
+          iq.add_element(Jabber::Error.new('item-not-found'))
+        end
+      end
+    else
+      iq.type = :error
+      iq.add_element(Jabber::Error.new('bad-request'))
+    end
+    iq.to, iq.from = iq.from, iq.to
+    @component.send(iq)
+  end
+end
+
+if ARGV.size != 3
+  puts "Syntax: ./minimuc.rb <JID> <Password> <Host>"
+  puts "Example: ./minimuc.rb conference.xmpp4r.mil minimuc localhost"
+  exit
+end
+
+muc = MUC::new(Jabber::JID::new(ARGV[0]), ARGV[1], ARGV[2])
+Thread.stop

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

@@ -0,0 +1,83 @@
+require 'xmpp4r'
+require 'xmpp4r/helpers/filetransfer'
+
+
+if ARGV.size != 3
+  puts "Usage: #{$0} <jid> <password> <incoming-directory>"
+  exit
+end
+
+
+#Jabber::debug = true
+
+cl = Jabber::Client.new(Jabber::JID.new(ARGV[0]))
+puts "Connecting Jabber client..."
+cl.connect
+puts "Authenticating..."
+cl.auth ARGV[1]
+
+ft = Jabber::Helpers::FileTransfer.new(cl)
+ft.add_incoming_callback { |iq,file|
+  puts "Incoming file transfer from #{iq.from}: #{file.fname} (#{file.size / 1024} KB)"
+
+  filename = "#{ARGV[2]}/#{file.fname.split(/\//).last}"
+  offset = nil
+  if File::exist?(filename)
+    puts "#{filename} already exists"
+    if File::size(filename) < file.size and file.range
+      offset = File::size(filename)
+      puts "Peer supports <range/>, will retrieve #{file.fname} starting at #{offset}"
+    else
+      puts "#{file.fname} is already fully retrieved, declining file-transfer"
+      ft.decline(iq)
+      next
+    end
+  end
+
+  Thread.new {
+    begin
+      puts "Accepting #{file.fname}"
+      stream = ft.accept(iq, offset)
+      if stream.kind_of?(Jabber::Helpers::SOCKS5Bytestreams)
+        stream.connect_timeout = 5
+        stream.add_streamhost_callback { |streamhost,state,e|
+          case state
+            when :connecting
+              puts "Connecting to #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+            when :success
+              puts "Successfully using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+            when :failure
+              puts "Error using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port}): #{e}"
+          end
+        }
+      end
+
+      puts "Waiting for stream configuration"
+      if stream.accept
+        puts "Stream established"
+        outfile = File.new(filename, (offset ? 'a' : 'w'))
+        while buf = stream.read
+          outfile.write(buf)
+          print '.'
+          $stdout.flush
+        end
+        puts '!'
+        outfile.close
+        stream.close
+      else
+        puts "Stream failed"
+      end
+    rescue Exception => e
+      puts "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+    end
+  }
+}
+
+cl.send(Jabber::Presence.new(:chat, 'Send me files!'))
+
+puts "Waiting."
+
+Thread.stop
+
+cl.close
+

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

@@ -0,0 +1,130 @@
+#!/usr/bin/ruby
+#
+# XMPP4R - XMPP Library for Ruby
+# Copyright (C) 2005 Stephan Maka <stephan@spaceboyz.net>
+# Released under Ruby's license (see the LICENSE file) or GPL, at your option
+#
+#
+# Roster-Discovery example
+#
+# If you don't understand this code read JEP-0030 (Service Discovery) first:
+# http://www.jabber.org/jeps/jep-0030.html
+#
+# This examples exposes your roster to Service Discovery and can be browsed
+# by anyone. Please use with care if you want to keep your roster private!
+#
+# The Psi client has a very pretty Service Discovery dialog. But be sure
+# to turn off "Auto-browse into objects" for big rosters.
+#
+
+$:.unshift '../../../../../lib'
+
+require 'thread'
+
+require 'xmpp4r'
+require 'xmpp4r/helpers/roster'
+require 'xmpp4r/iq/query/discoinfo'
+require 'xmpp4r/iq/query/discoitems'
+
+# Command line argument checking
+
+if ARGV.size != 2
+  puts("Usage: ./rosterdiscovery.rb <jid> <password>")
+  exit
+end
+
+# Building up the connection
+
+#Jabber::debug = true
+
+jid = Jabber::JID.new(ARGV[0])
+
+cl = Jabber::Client.new(jid)
+cl.connect
+cl.auth(ARGV[1])
+
+
+# The roster instance
+roster = Jabber::Helpers::Roster.new(cl)
+
+
+cl.add_iq_callback { |iq|
+  if iq.query.kind_of?(Jabber::IqQueryDiscoInfo) || iq.query.kind_of?(Jabber::IqQueryDiscoItems)
+
+    # Prepare the <iq/> stanza for result
+    iq.from, iq.to = iq.to, iq.from
+    iq.type = :result
+
+
+    if iq.query.kind_of?(Jabber::IqQueryDiscoInfo)
+      # iq.to and iq.from are already switched here:
+      puts("#{iq.to} requests info of #{iq.from} node #{iq.query.node.inspect}")
+
+      if iq.query.node.nil?
+        iq.query.add(Jabber::DiscoIdentity.new('directory', 'Roster discovery', 'user'))
+      else
+        # Count contacts in group
+        in_group = 0
+        roster.items.each { |jid,item|
+          if item.groups.include?(iq.query.node)
+            in_group += 1
+          end
+        }
+
+        iq.query.add(Jabber::DiscoIdentity.new('directory', "#{iq.query.node} (#{in_group})", 'group'))
+      end
+
+      iq.query.add(Jabber::DiscoFeature.new(Jabber::IqQueryDiscoInfo.new.namespace))
+      iq.query.add(Jabber::DiscoFeature.new(Jabber::IqQueryDiscoItems.new.namespace))
+
+    elsif iq.query.kind_of?(Jabber::IqQueryDiscoItems)
+      # iq.to and iq.from are already switched here:
+      puts("#{iq.to} requests items of #{iq.from} node #{iq.query.node.inspect}")
+
+      if iq.query.node.nil?
+        # Make items from group names
+        groups = []
+        
+        roster.items.each { |jid,item|
+          groups += item.groups
+        }
+        
+        groups.uniq.each { |group|
+          iq.query.add(Jabber::DiscoItem.new(cl.jid, group, group))
+        }
+
+        # Collect all ungrouped roster items
+        roster.items.each { |jid,item|
+          if item.groups == []
+            iq.query.add(Jabber::DiscoItem.new(item.jid, item.iname.to_s == '' ? item.jid : item.iname))
+          end
+        }
+      else
+        # Add a discovery item for each roster item in that group
+        roster.items.each { |jid,item|
+          if item.groups.include?(iq.query.node)
+            iq.query.add(Jabber::DiscoItem.new(item.jid, item.iname.to_s == '' ? item.jid : item.iname))
+          end
+        }
+      end
+
+    end
+
+    cl.send(iq)
+
+    true
+  end
+}
+
+# Initial presence
+cl.send(Jabber::Presence.new.set_status("Discover my roster at #{jid}"))
+
+# Main loop:
+
+loop do
+  cl.process
+  Thread.stop
+end
+
+cl.close
+

data/data/doc/xmpp4r/examples/advanced/sendfile.conf

@@ -0,0 +1,10 @@
+---
+jabber:
+  jid: user@server/resource
+  password: password
+local:
+  port: 65010
+  addresses: [172.22.16.3]
+proxies:
+  - proxy.jabber.org
+  - transfer.jabber.freenet.de

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

@@ -0,0 +1,72 @@
+require 'xmpp4r'
+require 'xmpp4r/bytestreams'
+require 'yaml'
+
+Jabber::debug = true
+
+if ARGV.size != 3
+  puts "Usage: #{$0} <jid> <description> <file>"
+  exit
+end
+
+conf = YAML::load File.new('sendfile.conf')
+
+cl = Jabber::Client.new(Jabber::JID.new(conf['jabber']['jid']))
+puts "Connecting Jabber client..."
+cl.connect
+puts "Authenticating..."
+cl.auth conf['jabber']['password']
+
+puts "Starting local Bytestreams server"
+bss = Jabber::Bytestreams::SOCKS5BytestreamsServer.new(conf['local']['port'])
+conf['local']['addresses'].each { |address|
+  bss.add_address(address)
+}
+ft = Jabber::FileTransfer::Helper.new(cl)
+#ft.allow_bytestreams = false
+source = Jabber::FileTransfer::FileSource.new(ARGV[2])
+puts "Offering #{source.filename} to #{ARGV[0]}"
+stream = ft.offer(Jabber::JID.new(ARGV[0]), source, ARGV[1])
+
+if stream
+  puts "Starting stream initialization (#{stream.class})"
+
+  if stream.kind_of? Jabber::Bytestreams::SOCKS5BytestreamsInitiator
+    stream.add_streamhost(bss)
+    (conf['proxies'] || []).each { |proxy|
+      puts "Querying proxy #{proxy}"
+      stream.add_streamhost proxy
+    }
+    puts "Offering streamhosts " + stream.streamhosts.collect { |sh| sh.jid }.join(' ')
+
+    stream.add_streamhost_callback { |streamhost,state,e|
+      case state
+        when :connecting
+          puts "Connecting to #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+        when :success
+          puts "Successfully using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port})"
+        when :failure
+          puts "Error using #{streamhost.jid} (#{streamhost.host}:#{streamhost.port}): #{e}"
+      end
+    }
+  end
+
+  stream.open
+  if stream.kind_of? Jabber::Bytestreams::SOCKS5BytestreamsInitiator
+    puts "Using streamhost #{stream.streamhost_used.jid} (#{stream.streamhost_used.host}:#{stream.streamhost_used.port})"
+  end
+
+  while buf = source.read
+    print "."
+    $stdout.flush
+    stream.write buf
+    stream.flush
+  end
+  puts "!"
+  stream.close
+
+else
+  puts "Peer declined"
+end
+
+cl.close

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

@@ -0,0 +1,51 @@
+require 'thread'
+
+class Shell
+
+  PROMPT = "_-=READY=-_"
+
+  def initialize(shell = "/bin/bash", delay = 1, &block)
+    @cb = block
+    @shell = shell
+    @delay = delay
+    @parent_to_child_read, @parent_to_child_write = IO.pipe
+    @child_to_parent_read, @child_to_parent_write = IO.pipe
+    @child_pid = fork do
+      @parent_to_child_write.close
+      @child_to_parent_read.close
+      $stdin.reopen(@parent_to_child_read)
+      $stdout.reopen(@child_to_parent_write)
+      $stderr.reopen(@child_to_parent_write)
+      exec("/bin/bash")
+    end
+    buffer = ""
+    semaphore = Mutex::new
+    Thread::new do
+      while true
+        c = @child_to_parent_read.read(1)
+        semaphore.synchronize { buffer += c }
+      end
+    end
+    Thread::new do
+      ch = ""
+      while true do
+        sleep @delay
+        semaphore.synchronize {
+          if buffer == ch and ch != ""
+            @cb.call buffer
+            buffer = ""
+          end
+          ch = buffer
+        }
+      end
+    end
+  end
+
+  def puts(str)
+    @parent_to_child_write.puts(str)
+  end
+
+  def kill
+    @child_pid.kill
+  end
+end