ruggby 0.3.0

data/lib/ruggby/packet/incoming/login_status.rb

@@ -0,0 +1,28 @@
+module RuGGby
+
+  module Packet
+
+    module Incoming
+
+      # Message telling as whether or not the loginj process was successfull
+      # It is a bit different from others because it gets one parameter on which
+      # we assume that the login was successful or unsuccessful
+      class LoginStatus
+
+        TYPE = 0x00035
+
+        def initialize(valid)
+          @valid = valid
+        end
+
+        def successful?
+          @valid
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/incoming/message.rb

@@ -0,0 +1,35 @@
+module RuGGby
+
+  module Packet
+
+    module Incoming
+
+      # Packet containing and incoming message
+      # Message packet contains not formatted data (not parsed, etc) so
+      class Message < RuGGby::Packet::Incoming::Base
+
+        TYPE    = 0x002e
+        PATTERN = 'LLLLa*'
+
+        attr_reader :uin, :message, :data, :created_at
+
+        def initialize(data)
+          super
+          @uin        = @data[0]
+          @created_at = @data[2]
+          @message    = @data[4]
+        end
+
+        private
+
+        def pattern
+          PATTERN
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/incoming/welcome.rb

@@ -0,0 +1,33 @@
+module RuGGby
+
+  module Packet
+
+    module Incoming
+
+      # Welcome packet - sent by GG when we connect to their socket
+      # Contains a seed used to mix with password before authorization
+      class Welcome < RuGGby::Packet::Incoming::Base
+
+        TYPE    = 0x0001
+        PATTERN = 'I'
+
+        attr_reader :seed
+
+        def initialize(data)
+          super
+          @seed = @data[0]
+        end
+
+        private
+
+        def pattern
+          PATTERN
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/outgoing/base.rb

@@ -0,0 +1,67 @@
+module RuGGby
+
+  module Packet
+
+    module Outgoing
+
+      # Base class for all the outgoing messages
+      # Contains all the methods needed to prepare the data to be send via
+      # TCPSocket
+      class Base
+
+        class << self
+
+          attr_reader :send_only_header
+
+          @send_only_header = false
+
+          # Tell us that, the package will be send without body
+          def only_header
+            @send_only_header = true
+          end
+
+        end
+
+        class NotImplemented < Exception; end
+
+        def initialize(params = {})
+          params.each do |key, value|
+            self.send(:"#{key}=", value)
+          end
+        end
+
+        # Pack data set according to given pattern
+        def pack
+          if self.class.send_only_header
+            rawbody=[].pack('')
+          else
+            rawbody = body.pack(pattern)
+          end
+
+          [type, rawbody.length].pack('LL') + rawbody
+        end
+
+        private
+
+        # Body array
+        def body
+          raise NotImplemented
+        end
+
+        # Packet type
+        def type
+          raise NotImplemented
+        end
+
+        # Pack pattern
+        def pattern
+          raise NotImplemented
+        end
+
+      end
+
+    end
+    
+  end
+
+end

data/lib/ruggby/packet/outgoing/change_status.rb

@@ -0,0 +1,57 @@
+module RuGGby
+
+  module Packet
+
+    module Outgoing
+
+      # Packet send when we want to change status
+      # Params:
+      # => new_status
+      # => description
+      class ChangeStatus < RuGGby::Packet::Outgoing::Base
+
+        TYPE       = 0x0038
+        PATTERN    = 'LLL'
+
+        attr_accessor :status, :description
+
+        def initialize(status, description)
+          @description = description || ''
+
+          if @description.length > 0
+            @status = RuGGby::Converter.status_description(status)
+          else
+            @status = RuGGby::Converter.status(status)
+          end
+        end
+
+        private
+
+        def body
+          [
+           @status,             # L
+           0,                   # L
+           @description.length, # L
+           @description         # a
+          ]
+        end
+
+        def type
+          TYPE
+        end
+
+        def pattern
+          if @description.length > 0
+            PATTERN+"a#{@description.length}"
+          else
+            PATTERN
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/outgoing/login.rb

@@ -0,0 +1,75 @@
+module RuGGby
+
+  module Packet
+
+    module Outgoing
+
+      # Packet send when we want to login into our GG account
+      # There is a lot of data that needs to be send here, but basically
+      # We need to provide:
+      # => :uin  - gg number
+      # => :hash - hashed password
+      # We can also provide a gg status:
+      # => :status
+      class Login < RuGGby::Packet::Outgoing::Base
+
+        TYPE       = 0x0031
+        PATTERN    = 'La2Ca64LLLLSLSCCLa35L'
+        GG_VERSION = 'Gadu-Gadu Client build 10.0.0.10450'
+
+        attr_accessor :uin, :hash, :status, :description
+
+        def initialize(params = {})
+          super
+          @description = params[:description] || ''
+
+          if @description.length > 0
+            @status = RuGGby::Converter.status_description(@status)
+          else
+            @status = RuGGby::Converter.status(@status)
+          end
+        end
+
+        private
+
+        def body
+          [
+           @uin.to_i,           # L
+           'pl',                # a2
+           0x02,                # C
+           @hash,               # a64
+           @status,             # L
+           0,                   # L
+           0x00000007,          # L
+           0,                   # L
+           0,                   # S
+           0,                   # L
+           0,                   # S
+           64,                  # C
+           0x64,                # C
+           GG_VERSION.length,   # L
+           GG_VERSION,          #a35
+           @description.length, #L,
+           @description         # Nothing?
+          ]
+        end
+
+        def type
+          TYPE
+        end
+
+        def pattern
+          if @description.length > 0
+            PATTERN+"a#{@description.length}"
+          else
+            PATTERN
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/outgoing/mark.rb

@@ -0,0 +1,28 @@
+module RuGGby
+
+  module Packet
+
+    module Outgoing
+
+      # Mark instance needs to be send to GG if we don't have (and don't want)
+      # any user list - if we don't send this after valid loggin process
+      # the GG will not communicate with us
+      class Mark < RuGGby::Packet::Outgoing::Base
+
+        TYPE = 0x12
+
+        only_header
+
+        private
+
+        def type
+          TYPE
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/outgoing/message.rb

@@ -0,0 +1,47 @@
+module RuGGby
+
+  module Packet
+
+    module Outgoing
+
+      # Out going message class
+      # When we want to send a message to a GG user, we need to provide
+      # a GG number an a message
+      class Message < RuGGby::Packet::Outgoing::Base
+
+        TYPE    = 0x0b
+        PATTERN = 'LLLa*C'
+
+        attr_accessor :message, :uin
+
+        # uin => GG nr
+        # msg => message we want to send
+        def initialize(uin, msg)
+          # Type uin (gg number) to integer, just to be sure
+          @uin = uin.to_i
+          # Convert incoming message into ISO-8859-2 just to be sure that
+          # polish letters will be sent properly
+          @message = StringEncoder.to_output(msg)
+        end
+
+        private
+
+        def body
+          [@uin, rand(2**32), 0x08, @message, 0]
+        end
+
+        def pattern
+          PATTERN
+        end
+
+        def type
+          TYPE
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/packet/outgoing/ping.rb

@@ -0,0 +1,27 @@
+module RuGGby
+
+  module Packet
+
+    module Outgoing
+
+      # Ping packet is used to upkeep the TCP connection with GG
+      # Needs to be send every 3-5 minutes to tell GG that we are alive
+      class Ping < RuGGby::Packet::Outgoing::Base
+
+        TYPE = 0x08
+
+        only_header
+
+        private
+
+        def type
+          TYPE
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/password.rb

@@ -0,0 +1,19 @@
+require 'digest/sha1'
+
+
+module RuGGby
+
+  # Password encryption method
+  class Password
+
+    # SHA1
+    HASH_TYPE = 0x02
+
+    # Hash password with seed to a format accepted by GG server
+    def self.hash(password, seed)
+      Digest::SHA1.digest(password+[seed].pack('L'))
+    end
+
+  end
+
+end

data/lib/ruggby/socket.rb

@@ -0,0 +1,67 @@
+require 'socket'
+require 'open-uri'
+
+module RuGGby
+
+  # TCP socket proxy
+  class Socket
+    # GG version that we send to the URL
+    VERSION = '10.0.0.7669'
+    # URL with 'real' server address
+    URL     = 'http://appmsg.gadu-gadu.pl'
+
+    class NotOperating < Exception; end
+
+    attr_reader :host, :port
+
+    # We need to provide a GG number because different GG numbers might get
+    # different 'real' servers
+    def initialize(gg_nr)
+      conn_params = self.class.connection_params(gg_nr)
+      @host = conn_params[:host]
+      @port = conn_params[:port]
+      ensure_operating
+
+      socket
+    end
+
+    # Before writing to socket, pack the incoming data
+    # We use pack because we assume that only objects from
+    # ruGGby::Packet::Outgoing might be send and all of them implemenent this
+    # method
+    def write(data)
+      socket.write(data.pack)
+    end
+
+    private
+
+    # Send all the unknown methods invokations into TCPSocket
+    def method_missing(name, *args, &block)
+      socket.public_send(name, *args, &block)
+    end
+
+    # Create a TCPSocket
+    def socket
+      @socket ||= ::TCPSocket.new(@host , @port)
+    end
+
+    # Get connection params
+    def self.connection_params(gg_nr)
+      gg_info = open(build_url(gg_nr)).readlines[0].split(/\s/)[2].split(':')
+      {:host => gg_info[0], :port => gg_info[1]}
+    end
+
+    # Buduje caly adres ktory bedziemy odpytywac o IP i port serwera do laczenia
+    # sie z GG
+    def self.build_url(gg_nr)
+      @build_url ||= "#{URL}/appsvc/appmsg_ver8.asp?fmnumber=#{gg_nr}&version=#{VERSION}&lastmsg=0"
+    end
+
+    #  Raise exception if we will get a not operating 'real' server
+    def ensure_operating
+      raise NotOperating if @host == 'notoperating'
+    end
+
+  end
+
+end