rgadu 0.1.0

data/lib/gg/dccclient.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+require 'gg/dccserver'
+require 'socket'
+
+class DCCClient < DCCServer
+	def initialize(host, port, client_uin, server_uin, code=nil)
+		@client_uin, @server_uin, @code = client_uin, server_uin, code
+		@progress, @callback = {}, {}
+		@socket = TCPSocket.new(host, port)
+		if code
+			@socket.write(code)
+			@socket.read(8)
+		else
+			@socket.write([client_uin, server_uin].pack('LL'))
+			@socket.read(4)
+		end
+	end
+
+	def client_send(filename, &callback)
+		@callback[@server_uin] = callback if callback
+		@socket.write([0x02].pack('L'))
+		init_send(@server_uin, @socket, filename)
+	end
+
+	def client_recv(&action)
+		@prepare_recv = action
+		@socket.write([0x03].pack('L'))
+		init_recv(@socket, @server_uin)
+	end
+
+	def client_send7(filename, filesize, offset, &callback)
+		@callback[@code] = callback if callback
+		begin
+			send7(@code, @socket, filename, filesize, offset)
+		ensure
+			@progress.delete(@server_uin)
+		end
+	end
+
+	def client_recv7(filename, filesize, offset, &callback)
+		@callback[@code] = callback if callback
+		begin
+			recv7(@code, @socket, filename, filesize, offset)
+		ensure
+			@progress.delete(@server_uin)
+		end
+	end
+end

data/lib/gg/dccserver.rb

@@ -0,0 +1,214 @@
+#!/usr/bin/ruby
+require 'socket'
+
+class DCCServer
+	def initialize(port, uin)
+		@uin = uin
+		@queue, @progress, @callback, @thread = {}, {}, {}, []
+		@server = TCPServer.new(port)
+		@server_loop = Thread.new do
+			while session = @server.accept
+				@thread << Thread.new(session) do |sess|
+					begin
+						server(sess)
+					rescue
+						warn "Error: #{$!}"
+					end
+				end
+			end
+		end
+	end
+
+	def server(session)
+		packet_raw = session.read(8) or return
+		client_uin, server_uin = packet_raw.unpack('LL')
+		if client_uin==@uin or server_uin==@uin
+			session.write([0x47414455].pack('L'))
+			packet_raw=session.read(4) or return
+			type=packet_raw.unpack('L')[0]
+			if type==0x03
+				if filename=@queue[client_uin]
+					init_send(client_uin, session, filename)
+				end
+			elsif type==0x02
+				init_recv(session, client_uin)
+			end
+		elsif @queue[packet_raw]
+			code=packet_raw
+			direction, filename, filesize, offset = @queue[code]
+			if direction == :out
+				session.write(code)
+				begin
+					send7(code, session, filename, filesize, offset)
+				ensure
+					@progress[code]=@callback[code]=nil
+				end
+			elsif direction == :in
+				session.write(packet_raw)
+				begin
+					recv7(code, session, filename, filesize, offset)
+				ensure
+					@progress[code]=@callback[code]=nil
+				end
+			end
+		end
+		session.close
+	end
+
+	def init_send(client_uin, session, filename)
+		return unless File.exist?(filename)
+		fileattr=creationlow=creationhigh=accesslow=accesshigh=writelow=writehigh=sizehigh=0
+		filesize=File.size(filename)
+		base=File.basename(filename)
+		alternate=base[0..12].upcase
+		session.write([0x01, 0x03, 0, 0, fileattr, creationlow, creationhigh, accesslow, accesshigh, writelow, writehigh, sizehigh, filesize, 0, 0, base, alternate].pack('LLLLLLLLLLLLLLLa262a14'))
+		packet_raw = session.read(12) or return
+		type, offset = packet_raw.unpack('LLL')
+		if type==0x06 and offset<filesize
+			begin
+				send(client_uin, session, filename, filesize, offset)
+			ensure
+				@progress[client_uin]=@callback[client_uin]=nil
+			end
+		end
+	end
+
+	def send(client_uin, session, filename, filesize, offset)
+		@progress[client_uin] = bytes = offset
+		file=File.open(filename, 'r')
+		file.seek(offset) if offset>0
+		while bytes<filesize and data=file.read(4096)
+			length = data.length
+			if bytes+length < filesize
+				type=0x03
+			else
+				type=0x02
+			end
+			packet_raw=[type, length, 0, data].pack('LLLa*')
+			session.write(packet_raw) or return
+			bytes += length
+			@progress[client_uin] = bytes
+			@callback[client_uin].call(bytes) if @callback[client_uin]
+		end
+	end
+
+	def init_recv(session, client_uin)
+		packet_raw=session.read(4) or return
+		type=packet_raw.unpack('L')[0]
+		if type==0x01
+			packet_raw = session.read(332) or return
+			packet_body = packet_raw.unpack('LLLLLLLLLLLLLLa262a14')
+			filename = packet_body[14].sub(/\x00+/, '')
+			filesize = packet_body[11]
+			if @prepare_recv and local_filename=@prepare_recv.call(client_uin, filename, filesize)
+				if local_filename.class == Array
+					local_filename, @callback[client_uin] = local_filename
+				end
+				if File.exist?(local_filename)
+					if File.size(local_filename)<filesize
+						offset=File.size(local_filename)
+					else
+						return
+					end
+				else
+					offset=0
+				end
+				session.write([0x06, offset, 0].pack('LLL')) or return
+				begin
+					recv(client_uin, session, local_filename, filesize, offset)
+				ensure
+					@progress[client_uin]=@callback[client_uin]=nil
+				end
+			end
+		end
+	end
+
+
+	def recv(client_uin, session, filename, filesize, offset)
+		if offset>0
+			mode='a'
+		else
+			mode='w'
+		end
+		file=File.open(filename, mode)
+		@progress[client_uin] = bytes = offset
+		while packet_raw=session.read(12)
+			type, length = packet_raw.unpack('LLL')
+			if bytes+length > filesize
+				break
+			end
+			if type==0x03 or type==0x02
+				packet=session.read(length) or return
+				file.write(packet)
+				bytes+=length
+				@progress[client_uin] = bytes
+				@callback[client_uin].call(bytes) if @callback[client_uin]
+				break if type==0x02
+			end
+		end
+		file.close
+	end
+
+	def send7(code, session, filename, filesize, offset)
+		return unless File.exist?(filename)
+		@progress[code]=bytes=offset
+		file=File.open(filename, 'r')
+		file.seek(offset) if offset>0
+		while bytes<filesize and data=file.read(4096)
+			session.write(data) or return
+			bytes += data.length
+			@progress[code] = bytes
+			@callback[code].call(bytes) if @callback[code]
+		end
+	end
+
+	def recv7(code, session, filename, filesize, offset)
+		if offset>0
+			mode='a'
+		else
+			mode='w'
+		end
+		file=File.open(filename, mode)
+		@progress[code]=bytes=offset
+		while bytes<filesize and data=session.read(4096)
+			file.write(data)
+			bytes += data.length
+			@progress[code] = bytes
+			@callback[code].call(bytes) if @callback[code]
+		end
+		file.close
+	end
+	
+	def add_send(uin, filename, &callback)
+		@queue[uin] = filename
+		@callback[uin] = callback if callback
+	end
+
+	def add_send_code(code, filename, filesize, offset, &callback)
+		@queue[code] = [:out, filename, filesize, offset]
+		@callback[code] = callback if callback
+	end
+
+	def add_recv_code(code, filename, filesize, offset, &callback)
+		@queue[code] = [:in, filename, filesize, offset]
+		@callback[code] = callback if callback
+	end
+
+	def on_recv(&action)
+		@prepare_recv = action
+	end
+
+	def progress(code)
+		@progress[code]
+	end
+
+	def wait
+		@server_loop.join
+	end
+
+	def close
+		@server_loop.exit
+		@thread.each {|t| t.exit }
+		@server.close
+	end
+end

data/lib/gg.rb

@@ -0,0 +1,462 @@
+#!/usr/bin/ruby
+require 'gg/dccserver'
+require 'gg/dccclient'
+require 'socket'
+require 'digest/sha1'
+
+=begin rdoc
+Prosta implementacja protokolu Gadu-Gadu w czystym Ruby oparta na watkach i zdarzeniach. Pozwala bardzo szybko stworzyc dzialajacego klienta GG. Zawiera serwer DCC, obsluguje przesylanie plikow protokolem DCC w wersjach 6 i 7.
+=end
+class GG
+	STATUS = {0x02 => :avail, 0x04 => :avail,
+		0x03 => :busy, 0x05 => :busy,
+		0x14 => :invisible, 0x16 => :invisible,
+		0x01 => :notavail, 0x15 => :notavail}
+	TO_STATUS = {:avail => 0x02,
+		:busy => 0x03,
+		:invisible => 0x14,
+		:notavail => 0x01}
+	TO_STATUS_DESCRIPTION = {:avail => 0x04,
+		:busy => 0x05,
+		:invisible => 0x16,
+		:notavail => 0x15}
+	VERSION = {0x18 => '5.0', 0x19 => '5.0', 0x1b => '5.0', 0x1c => '5.7', 0x1e => '5.7',
+		0x20 => '6.0', 0x21 => '6.0', 0x22 => '6.0', 0x24 => '6.1',
+		0x25 => '7.0', 0x26 => '7.0', 0x27 => '7.0', 0x28 => '7.5', 0x29 => '7.6', 0x2a => '7.7'}
+	TO_GENDER = {:male => '2', :female => '1'}
+	PATTERN = {0x02 => 'LLa*',
+		0x0f => 'LCLSCCCa*',
+		0x0c => 'LCLSLSa*',
+		0x11 => 'LCLSCCCCa*',
+		0x0e => 'CLa*',
+		0x0a => 'LLLLa*',
+		0x23 => 'La8',
+		0x21 => 'La8LL',
+		0x20 => 'a8LLLa226a29LLa20',
+		0x1f => 'LLa8a21a43'}
+
+=begin rdoc
+Tworzy nowy obiekt GG i loguje sie na serwerze. Opcjonalnie uruchamia serwer DCC na porcie *dccport*.
+=end
+	def initialize(uin, password, dccport=0, server='217.17.45.146', port=8074)
+		@uin=uin
+		@dccport=dccport
+		@socket=TCPSocket.new(server, port)
+		type, length = read_header
+		if type!=0x01
+			raise "Packet not recognized"
+		end	
+		seed=read_body(length, 'L')[0]
+		hash=gg_login_hash(password, seed)
+		if dccport>0
+			@dcc = DCCServer.new(dccport, uin)
+			localip=@socket.addr[3].split('.').collect {|x| x.to_i }.pack('C4').unpack('L')[0]
+		else
+			localip=0
+		end
+		write(0x15, 'LLLLCLSLSCC', uin, hash, 0x02, 0x20, 0x00, localip, dccport, localip, dccport, 0x00, 0xbe)
+		type, length = read_header
+		read_body(length)
+		unless type==0x03 or type==0x14
+			raise "Authorization failed"
+		end
+		write(0x12, '')
+		@action, @status, @search_reply, @dcc_code, @dcc_action, @dcc_client_action = {}, {}, {}, [], {}, {}
+		@action_thread, @dcc_client, @dcc_client_thread = [], [], []
+		@action[0x0a] = lambda {|sender, seq, time, cl, message| msg_received(sender, seq, time, cl, message) }
+		@action[0x02] = lambda {|uin, status, description| status_changed(uin, status, description) }
+		@action[0x0f] = lambda {|uin, status, ip, port, version, x, y, description| status_changed(uin, status, description, ip, port, version) }
+		@action[0x0c] = lambda {|uin, status, ip, port, version, x, description| status_changed(uin, status, description, ip, port, version) }
+		@action[0x11] = lambda {|uin, status, ip, port, version, imgsize, x, descsize, description| status_changed(uin, status, description, ip, port, version) }
+		@action[0x0e] = lambda {|type, seq, response| @search_reply[seq] = response }
+		@action[0x23] = lambda {|type, code| @dcc_code << code }
+		@action[0x21] = lambda {|uin, code, offset, x| @dcc_action[code].call(offset) if @dcc_action[code] }
+		@action[0x1f] = lambda do |uin, x, code, ip_port, y|
+			if action = @dcc_client_action[code]
+				@dcc_client_action.delete(code)
+				action.call(*(ip_port.chomp(0.chr).split(' ')))
+			end
+		end
+		@read_loop = Thread.new do
+			loop do
+				sleep 0.1
+				read or break
+			end
+		end
+		@ping_loop = Thread.new do
+			loop do
+				sleep 180
+				ping
+			end
+		end
+	end
+
+=begin rdoc
+Wysyla wiadomosc *message* do *uin*.
+=end
+	def msg(uin, message)
+		write(0x0b, 'LLLa*C', uin, rand(2**32), 0x04, message, 0)
+	end
+
+=begin rdoc
+Zmienia status i opcjonalnie ustawia opis. Status powinien byc jednym z symboli: :avail, :busy, :invisible, :notavail
+=end
+	def status(status, description=nil)
+		if description
+			status_id = TO_STATUS_DESCRIPTION[status] or raise "Wrong status"
+			write(0x02, 'La*C', status_id, description, 0) if status_id
+		else
+			status_id = TO_STATUS[status] or raise "Wrong status"
+			write(0x02, 'L', status_id) if status_id
+		end
+	end
+
+=begin rdoc
+Dodaje numery GG do listy kontaktow. *uins* moze byc liczba lub tablica liczb.
+=end
+	def add(*uins)
+		uins.each do |uin|
+			@status[uin] = {:status => :notavail}
+			write(0x0d, 'LC', uin, 0x03)
+		end
+	end
+
+=begin rdoc
+Usuwa numery GG z listy kontaktow. *uins* moze byc liczba lub tablica liczb.
+=end
+	def remove(*uins)
+		uins.each do |uin|
+			@status[uin] = nil
+			write(0x0e, 'LC', uin, 0x03)
+		end
+	end
+
+=begin rdoc
+Wyszukiwanie w katalogu publicznym. *params* moze byc numerem GG lub tablica asocjacyjna z kluczami: :uin, :firstname, :lastname, :nickname, :birthyear, :city, :gender, :active. Kluczowi :gender moze odpowiadac wartosc :male lub :female. Zwraca tablice asocjacyjna z wynikami wyszukiwania, mozliwe sa klucze: :uin, :firstname, :nickname, :birthyear, :city, :status.
+=end
+	def find(params)
+		if params.class == Hash
+			request=[]
+			request.push('FmNumber', params[:uin].to_s) if params[:uin]
+			request.push('firstname', params[:firstname]) if params[:firstname]
+			request.push('lastname', params[:lastname]) if params[:lastname]
+			request.push('nickname', params[:nickname]) if params[:nickname]
+			request.push('birthyear', params[:birthyear].to_s) if params[:birthyear]
+			request.push('city', params[:city]) if params[:city]
+			request.push('gender', TO_GENDER[params[:gender]]) if params[:gender]
+			request.push('ActiveOnly', '1') if params[:active]
+		else
+			request=['FmNumber', params.to_s]
+		end
+		write(0x14, 'CLa*C', 0x03, seq=rand(2**32), request.join("\x00"), 0)
+		sleep 0.1 until reply = @search_reply[seq]
+		@search_reply.delete(seq)
+		search_reply_array = reply.chomp(0.chr).split("\x00\x00")
+		search_reply_hash=[]
+		search_reply_array.each do |x|
+			row={}
+			y=x.split("\x00")
+			y.each_index do |i|
+				if i%2==0
+					key=y[i]
+					value=y[i+1]
+					case key
+						when 'FmNumber': row[:uin] = value.to_i
+						when 'firstname': row[:firstname] = value
+						when 'nickname': row[:nickname] = value
+						when 'birthyear': row[:birthyear] = value.to_i
+						when 'city': row[:city] = value
+						when 'FmStatus': row[:status] = STATUS[value.to_i]
+						when 'nextstart': break
+					end
+				end
+			end
+			search_reply_hash << row if row.length>0
+		end
+		search_reply_hash
+	end
+
+=begin rdoc
+Wysyla plik *filename* do *uin*. Jesli dolaczono blok kodu, blok ten bedzie wywolywany podczas wysylania pliku. Blok przyjmuje jeden parametr - aktualna pozycje pliku w bajtach. Funkcja w zaleznosci od wersji protokolu DCC zwraca kod transferu lub numer GG odbiorcy.
+=end
+	def dcc_request(uin, filename, &callback)
+		raise "No DCC server" unless @dcc
+		if File.exist?(filename)
+			if @status[uin] and version=@status[uin][:version] and version.to_f >= 7.7
+				write(0x23, 'L', 0x04)
+				sleep 0.1 until code = @dcc_code.shift
+				filesize=File.size(filename)
+				hash=Digest::SHA1.digest(File.read(filename))
+				write(0x20, 'a8LLLa226a29LLa20', code, @uin, uin, 0x04, File.basename(filename), '', filesize, 0, hash)
+				@dcc_action[code] = lambda do |offset|
+					if callback
+						@dcc.add_send_code(code, filename, filesize, offset) {|pos| callback.call(pos) }
+					else
+						@dcc.add_send_code(code, filename, filesize, offset)
+					end
+					write(0x1f, 'LLa8a21a43', uin, 0x01, code, @socket.addr[3]+' '+@dccport.to_s, '')
+					if @socket.addr[3] =~ /^(10\.|172\.16\.|192\.168\.)/
+						@dcc_client_action[code] = lambda do |ip, port|
+							@dcc_client_thread << Thread.new(ip, port, @uin, uin, code, filename, filesize, offset, callback) do |ip, port, client_uin, server_uin, code, filename, filesize, offset, callback|
+								begin
+									client = DCCClient.new(ip, port, client_uin, server_uin, code)
+									@dcc_client << client
+									if callback
+										client.client_send7(filename, filesize, offset) {|pos| callback.call(pos) }
+									else
+										client.client_send7(filename, filesize, offset)
+									end
+								rescue
+									warn "Error: #{$!}"
+								end
+							end
+						end
+					end
+									
+				end
+				code
+			else
+				if @socket.addr[3] =~ /^(10\.|172\.16\.|192\.168\.)/ and ip = get_ip(uin) and port = get_port(uin) and port > 1
+					@dcc_client_thread << Thread.new(ip, port, @uin, uin, filename, callback) do |ip, port, client_uin, server_uin, filename, callback|
+						begin
+							client = DCCClient.new(ip, port, client_uin, server_uin)
+							@dcc_client << client
+							if callback
+								client.client_send(filename) {|pos| callback.call(pos) }
+							else
+								client.client_send(filename)
+							end
+						rescue
+							warn "Error: #{$!}"
+						end
+					end
+				else
+					if callback
+						@dcc.add_send(uin, filename) {|pos| callback.call(pos) }
+					else
+						@dcc.add_send(uin, filename)
+					end
+					write(0x0b, 'LLLa*C', uin, rand(2**32), 0x10, "\x02", 0)
+				end
+				uin
+			end
+		end
+	end
+
+=begin rdoc
+Ustawia blok kodu jako zdarzenie wywolywane, gdy otrzymamy wiadomosc. Blok przyjmuje 3 parametry: numer GG nadawcy, czas wysylania wiadomosci i wiadomosc. Czas wyslania jest obiektem Time.
+=end
+	def on_msg(&action)
+		@msg_action = action
+	end
+
+=begin rdoc
+Ustawia blok kodu jako zdarzenie wywolywane, gdy ktos z listy kontaktow zmieni status. Blok przyjmuje 6 parametrow: numer GG, status, opis, IP, port i wersje klienta. 2 pierwsze parametry wystepuja zawsze, pozostale nie sa obowiazkowe. Status moze byc jednym z symboli: :avail, :busy, :notavail. IP to lancuch znakow w postaci 4 liczb oddzielonych kropkami. Wersja klientu to liczba typu Float lub nil jesli wersji nie rozpoznano.
+=end
+	def on_status(&action)
+		@status_action = action
+	end
+
+=begin rdoc
+Ustawia blok kodu jako zdarzenie wywolywane, gdy ktos zechce wyslac do nas plik. Blok przyjmuje 3 parametry: numer GG, nazwe pliku i rozmiar. Blok powinien zwrocic lokalna sciezke, gdzie plik ma zostac pobrany, nil, jesli nalezy odrzucic pobieranie pliku, lub tablice skladajaca sie z lokalnej sciezki i bloku kodu, ktory bedzie wywolywany podczas pobierania pliku. Blok ten przyjmuje jeden parametr - aktualna pozycje w bajtach.
+=end
+	def on_dcc_recv(&action)
+		raise "No DCC server" unless @dcc
+		@dcc_recv_action = action
+		@dcc.on_recv {|uin, filename, filesize| action.call(uin, filename, filesize) }
+		@action[0x20] = lambda do |code, sender_uin, recv_uin, type, filename, x, filesize, y, hash|
+			if type==0x04
+				filename.sub!(/\x00.*/m, '')
+				if local_filename=action.call(sender_uin, filename, filesize)
+					if local_filename.class == Array
+						local_filename, callback = local_filename
+					end
+					if File.exist?(local_filename)
+						offset = File.size(local_filename)
+					else
+						offset = 0
+					end
+					if callback
+						@dcc.add_recv_code(code, local_filename, filesize, offset) {|pos| callback.call(pos) }
+					else
+						@dcc.add_recv_code(code, local_filename, filesize, offset)
+					end
+					write(0x21, 'La8LL', sender_uin, code, offset, 0)
+					write(0x1f, 'LLa8a21a43', sender_uin, 0x01, code, @socket.addr[3]+' '+@dccport.to_s, '')
+					@dcc_client_action[code] = lambda do |ip, port|
+						@dcc_client_thread << Thread.new(ip, port, @uin, sender_uin, code, local_filename, filesize, offset, callback) do |ip, port, client_uin, server_uin, code, filename, filesize, offset, callback|
+							begin
+								client = DCCClient.new(ip, port, client_uin, server_uin, code)
+								@dcc_client << client
+								if callback
+									client.client_recv7(filename, filesize, offset) {|pos| callback.call(pos) }
+								else
+									client.client_recv7(filename, filesize, offset)
+								end
+							rescue
+								warn "Error: #{$!}"
+							end
+						end
+					end
+				else
+					write(0x22, 'La8L', sender_uin, code, 0x02)
+				end
+			end
+		end
+	end
+
+=begin rdoc
+Zwraca status *uin* jesli jest on na liscie kontaktow. Status moze byc jednym z symboli: :avail, :busy, :notavail.
+=end
+	def get_status(uin)
+		@status[uin][:status]
+	end
+
+=begin rdoc
+Zwraca opis *uin* jesli jest on na liscie kontaktow.
+=end
+	def get_description(uin)
+		@status[uin][:description]
+	end
+
+=begin rdoc
+Zwraca adres IP *uin* jako lancuch znakow w postaci 4 liczb oddzielonych kropkami.
+=end
+	def get_ip(uin)
+		@status[uin][:ip]
+	end
+
+=begin rdoc
+Zwraca port, na ktorym *uin* ma serwer DCC.
+=end
+	def get_port(uin)
+		@status[uin][:port]
+	end
+
+=begin rdoc
+Zwraca wersje klienta *uin* jako liczbe Float lub nil jesli nie rozpoznano wersji.
+=end
+	def get_version(uin)
+		@status[uin][:version]
+	end
+
+=begin rdoc
+Sprawdza aktualna pozycje transferu DCC. *code* to numer GG lub kod transferu.
+=end
+	def dcc_progress(code)
+		@dcc && @dcc.progress(code) or @dcc_client.find {|c| c.progress(code) != nil }
+	end
+
+=begin rdoc
+Pozwala dzialac klientowi GG, blokujac watek do momentu, gdy skonczy dzialanie. Funkcja powinna zostac wywolana po ustawieniu zdarzen.
+=end
+	def wait
+		@read_loop.join
+	end
+
+=begin rdoc
+Rozlacza sie z serwerem GG, wylacza serwer DCC i zamyka wszystkie polaczenia DCC.
+=end
+	def close
+		@action_thread.each {|t| t.exit }
+		@ping_loop.exit
+		@read_loop.exit
+		@socket.close
+		@dcc.close
+		@dcc_client_thread.each {|t| t.exit }
+	end
+
+	def write(type, pattern, *params)
+		rawbody=params.pack(pattern)
+		rawpacket = [type, rawbody.length].pack('LL') + rawbody
+		@socket.write(rawpacket)
+	end
+
+	def read
+		type, length = read_header
+		return nil unless type
+		if PATTERN[type]
+			body = read_body(length, PATTERN[type])
+		else
+			body = read_body(length)
+		end
+		if @action[type]
+			@action_thread << Thread.new(body) {|bd| @action[type].call(*bd) }
+		end
+		1
+	end
+
+	def read_header
+		type=@socket.read(4).unpack('L')[0]
+		length=@socket.read(4).unpack('L')[0]
+		return type, length
+	end
+
+	def read_body(length, pattern=nil)
+		if length>0
+			packet=@socket.read(length)
+			if pattern
+				packet.unpack(pattern)
+			else
+				packet
+			end
+		end
+	end
+
+	def ping
+		write(0x08, '')
+	end
+
+	def gg_login_hash(password, seed)
+		x, y, z = 0, seed, 0
+		password.each_byte do |b|
+			x = (x & 0xffffff00) | b
+			y = y ^ x
+			y = (y + x) % 2**32
+			x = (x << 8) % 2**32
+			y = y ^ x
+			x = (x << 8) % 2**32
+			y = (y - x) % 2**32
+			x = (x << 8) % 2**32
+			y = y ^ x
+			z = y & 0x1f
+			y = ((y << z) % 2**32) | ((y >> (32 - z)) % 2**32)
+		end
+		y
+	end
+
+	def msg_received(sender, seq, time, cl, message)
+		if cl == 0x10 and message.chomp(0.chr) == 2.chr
+			if @dcc_recv_action and ip = get_ip(sender) and port = get_port(sender) and port > 1
+				@dcc_client_thread << Thread.new(ip, port, @uin, sender, @dcc_recv_action) do |ip, port, uin1, uin2, dcc_recv_action|
+					begin
+						client = DCCClient.new(ip, port, uin1, uin2)
+						@dcc_client << client
+						client.client_recv {|uin, filename, filesize| dcc_recv_action.call(uin, filename, filesize) }
+					rescue
+						warn "Error: #{$!}"
+					end
+				end
+			end
+		else
+			@msg_action.call(sender, Time.at(time), message.chomp(0.chr)) if @msg_action
+		end
+	end
+
+	def status_changed(uin, status, description, ip=nil, port=nil, version=nil)
+		uin = uin % 2**24
+		if description
+			description.chomp!(0.chr)
+			description=nil if description.empty?
+		end
+		status=STATUS[status]
+		version=VERSION[version] || version if version
+		ip = (ip>0 ? [ip].pack('L').unpack('C4').join('.') : nil) if ip
+		@status[uin] = {:status => status}
+		@status[uin][:description] = description if description
+		@status[uin][:ip] = ip if ip
+		@status[uin][:port] = port if port
+		@status[uin][:version] = version if version
+		@status_action.call(uin, status, description, ip, port, version) if @status_action
+	end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: rgadu
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-08-04 00:00:00 +02:00
+summary: A simple pure-Ruby implementation of the Gadu-Gadu protocol.
+require_paths: 
+- lib
+email: bl4@playker.info
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: gg
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- bl4
+files: 
+- lib/gg.rb
+- lib/gg/dccserver.rb
+- lib/gg/dccclient.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+