torchat 0.0.1.rc.1

data/README.md

@@ -0,0 +1,43 @@
+torchat - the Ruby implementation
+=================================
+You can find the official implementation [here](https://github.com/prof7bit/TorChat).
+
+This aims to be a Ruby implementation and daemon to deal with a TorChat session even from
+outside or with other languages without having to implement the whole thing.
+
+The main target is supporting TorChat in bitlbee.
+
+Setup the daemon
+----------------
+The daemon to work needs a tor configured with a hidden service, you can leave it automatic by
+passing `-t` as an option or you can configure it yourself.
+
+If you have an already created default TorChat session you just have to run `torchatd -t`, it
+will do all is needed, and you'll be able to connect to it on port `11110`. If you use bitlbee
+you just have to add the account, you can also pass a password with `-P password` which will have
+to be the password you added the account with.
+
+The daemon has a helper function to generate the needed tor configuration file based either
+on a YAML file or a TorChat configuration file.
+
+Example of tor configuration generation:
+
+```
+$ torchatd -g -c etc/torchat.yml
+SocksPort 11108
+
+HiddenServiceDir hidden_service
+HiddenServicePort 11009 127.0.0.1:11008
+
+DataDirectory tor_data
+
+AvoidDiskWrites 1
+LongLivedPorts 11009
+FetchDirInfoEarly 1
+CircuitBuildTimeout 30
+NumEntryGuards 6
+```
+
+Contacting the author
+---------------------
+If you want to contact me on torchat my id is `7acbk6jpofsanyfp`.

data/bin/torchatd

@@ -0,0 +1,537 @@
+#! /usr/bin/env ruby
+require 'optparse'
+require 'torchat'
+
+options = {}
+
+OptionParser.new do |o|
+	options[:host]                = '127.0.0.1'
+	options[:port]                = 11110
+	options[:file_transfer_ports] = []
+
+	o.on '-p', '--profile NAME', 'the profile name' do |name|
+		options[:profile] = name
+	end
+
+	o.on '-c', '--config PATH', 'the path to the config file' do |path|
+		options[:config] = path
+	end
+
+	o.on '-g', '--generate [PATH]', 'the path to save the generated torrc' do |path|
+		options[:generate] = path || '-'
+	end
+
+	o.on '-t', '--tor', 'enable automatic generation and run of Tor' do
+		options[:tor] = true
+	end
+
+	o.on '-l', '--listen HOST:PORT', 'the host and port to listen on' do |value|
+		host, port = value.split(':')
+
+		options[:host] = host      unless host.empty?
+		options[:port] = port.to_i unless port.empty?
+	end
+
+	o.on '-s', '--ssl KEY:CERT', 'the private key and cert files' do |path|
+		options[:ssl] = { key: path.split(':').first, cert: path.split(':').last }
+	end
+
+	o.on '-P', '--password PASSWORD' do |password|
+		options[:password] = password
+	end
+
+	o.on '-f', '--file-transfer-ports PORT...', Array, 'the list of ports to listen on for file transfers' do |ports|
+		options[:file_transfer_ports] = ports.map {|value|
+			value.include?('-') ? Range.new(*value.split('-').map(&:to_i)) : value.to_i
+		}.flatten.compact.uniq
+	end
+
+	o.on '-o', '--online' do
+		options[:online] = true
+	end
+
+	o.on '-d', '--debug [LEVEL=1]', 'enable debug mode' do |value|
+		ENV['DEBUG'] = value || ?1
+	end
+end.parse!
+
+class Torchatd
+	class Connection < EventMachine::Protocols::LineAndTextProtocol
+		attr_accessor :daemon, :host, :port, :ssl
+
+		def authorized?; @authorized;        end
+		def authorize!;  @authorized = true; end
+
+		def receive_line (line)
+			return if line.lstrip.empty?
+
+			@daemon.process self, line.lstrip
+		end
+
+		def send_response (text)
+			send_data "#{text.to_s.lstrip}\n"
+		end
+
+		def unbind
+			@daemon.connections.delete self
+		end
+	end
+
+	attr_reader   :password, :file_transfer_ports, :connections
+	attr_accessor :profile, :tor
+
+	def initialize (password = nil, file_transfer_ports = [])
+		@password            = password
+		@file_transfer_ports = file_transfer_ports.flatten.compact.uniq
+
+		@buddies     = []
+		@connections = []
+		@pings       = Hash.new { |h, k| h[k] = {} }
+
+		yield self if block_given?
+	end
+
+	def start (host, port, ssl = nil)
+		return if @started
+
+		@started = true
+
+		@signature = EM.start_server host, port, Connection do |conn|
+			@connections << conn
+
+			conn.daemon = self
+			conn.host   = host
+			conn.port   = port
+			conn.ssl    = ssl
+
+			unless @password
+				conn.authorize!
+			end
+		end
+	end
+
+	def stop
+		EM.stop_server @signature
+
+		profile.stop
+		tor.stop if tor
+	end
+
+	def process (connection, line)
+		command, rest = line.force_encoding('UTF-8').split(' ', 2)
+
+		case command.downcase.to_sym
+		when :starttls
+			if connection.ssl
+				connection.start_tls(private_key_file: connection.ssl[:key], cert_chain_file: connection.ssl[:cert])
+			else
+				connection.start_tls
+			end
+
+			return
+
+		when :pass
+			if !@password || @password == rest
+				connection.authorize!
+				connection.send_response "AUTHORIZED #{profile.session.id}"
+			end
+
+			return
+		end
+
+		unless connection.authorized?
+			connection.send_response "UNAUTHORIZED #{command}"
+			return
+		end
+
+		case command.downcase.to_sym
+		when :whoami
+			connection.send_response "WHOAMI #{profile.id}"
+
+		when :list
+			connection.send_response "LIST #{profile.buddies.keys.join(' ')}"
+
+		when :remove
+			profile.buddies.remove rest
+
+		when :add
+			attribute, rest = rest.split(' ')
+
+			if rest && attribute == 'tmp'
+				profile.buddies.add_temporary rest
+			else
+				profile.buddies.add attribute
+			end
+
+		when :typing
+			id, mode = rest.split(' ')
+
+			if buddy = profile.buddies[id]
+				buddy.send_typing(mode)
+			end
+
+		when :status
+			if rest && Torchat.normalize_id(rest, true)
+				if buddy = profile.buddies[rest]
+					connection.send_response "#{rest} STATUS #{buddy.status}"
+				end
+			else
+				profile.status = rest
+			end
+
+		when :client
+			if buddy = profile.buddies[rest]
+				if buddy.client.name
+					connection.send_response "#{rest} CLIENT_NAME #{buddy.client.name}"
+				end
+
+				if buddy.client.version
+					connection.send_response "#{rest} CLIENT_VERSION #{buddy.client.version}"
+				end
+			end
+
+		when :name
+			if rest && Torchat.normalize_id(rest, true)
+				if buddy = profile.buddies[rest]
+					connection.send_response "#{rest} NAME #{buddy.name}"
+				end
+			else
+				profile.name = rest
+			end
+
+		when :description
+			if rest && Torchat.normalize_id(rest, true)
+				if buddy = profile.buddies[rest]
+					connection.send_response "#{rest} DESCRIPTION #{buddy.description}"
+				end
+			else
+				profile.description = rest
+			end
+
+		when :message
+			profile.send_message_to *rest.split(' ', 2)
+
+		when :block
+			profile.buddies[rest].block!
+
+		when :allow
+			profile.buddies[rest].allow!
+
+		when :broadcast
+			profile.send_broadcast rest
+
+		when :groupchats
+			connection.send_response "GROUPCHATS #{profile.group_chats.keys.join(' ')}"
+
+		when :groupchat_participants
+			if group_chat = profile.group_chats[rest]
+				connection.send_response "GROUPCHAT_PARTICIPANTS #{group_chat.id} #{group_chat.participants.keys.join ' '}"
+			end
+
+		when :groupchat_invite
+			group_chat, buddy = rest.split ' '
+
+			if buddy
+				if (buddy = profile.buddies[buddy]) && (group_chat = profile.group_chats[group_chat])
+					group_chat.invite(buddy)
+				end
+			else
+				if buddy = profile.buddies[group_chat]
+					profile.group_chats.create.invite(buddy)
+				end
+			end
+
+		when :groupchat_leave
+			group_chat, reason = rest.split ' ', 2
+
+			if group_chat = profile.group_chats[group_chat]
+				group_chat.leave reason
+			end
+
+		when :groupchat_message
+			group_chat, message = rest.split ' ', 2
+
+			if group_chat = profile.group_chats[group_chat]
+				group_chat.send_message message
+			end
+
+		when :latency
+			id, rest = rest.split ' ', 2
+
+			if (buddy = profile.buddies[id]) && buddy.supports?(:latency)
+				@pings[id][buddy.latency.ping!.id] = [Time.now, rest]
+			end
+
+		else
+			connection.send_response "UNIMPLEMENTED #{command}"
+		end
+	rescue => e
+		Torchat.debug e
+	end
+
+	def received_packet (packet)
+		return unless @buddies.include? packet.from
+
+		if packet.type == :message
+			packet.to_s.lines.each {|line|
+				send_everyone "#{packet.from.id} MESSAGE #{line}"
+			}
+		elsif packet.type == :status
+			send_everyone "#{packet.from.id} STATUS #{packet}"
+		elsif packet.type == :client
+			send_everyone "#{packet.from.id} CLIENT_NAME #{packet}"
+		elsif packet.type == :version
+			send_everyone "#{packet.from.id} CLIENT_VERSION #{packet}"
+		elsif packet.type == :profile_name && !packet.nil?
+			send_everyone "#{packet.from.id} NAME #{packet}"
+		elsif packet.type == :profile_text && !packet.nil?
+			send_everyone "#{packet.from.id} DESCRIPTION #{packet}"
+		elsif packet.type == :remove_me
+			send_everyone "#{packet.from.id} REMOVE"
+		end
+	end
+
+	def file_transfer (what, file_transfer, *args)
+		if what == :start
+
+		elsif what == :stop
+
+		elsif what == :complete
+
+		end
+	end
+
+	def typing (buddy, mode)
+		send_everyone "#{buddy.id} TYPING #{mode}"
+	end
+
+	def broadcast (message)
+		send_everyone "BROADCAST #{message}"
+	end
+
+	def group_chat (what, group_chat, buddy = nil, *args)
+		if what == :create
+			send_everyone "GROUPCHAT_CREATE #{group_chat.id}"
+		elsif what == :invite
+			send_everyone "#{buddy.id} GROUPCHAT_INVITE #{group_chat.id}"
+		elsif what == :join
+			send_everyone "#{buddy.id} GROUPCHAT_JOIN #{group_chat.id}#{" #{args.first.id}" if args.first}"
+		elsif what == :joined
+			send_everyone "GROUPCHAT_JOINED #{group_chat.id}"
+			send_everyone "GROUPCHAT_PARTICIPANTS #{group_chat.id} #{group_chat.participants.keys.join ' '}"
+		elsif what == :leave
+			send_everyone "#{buddy.id} GROUPCHAT_LEAVE #{group_chat.id}#{" #{args.first}" if args.first}"
+		elsif what == :left
+			send_everyone "GROUPCHAT_LEFT #{group_chat.id} #{args.first}"
+		elsif what == :message
+			send_everyone "#{buddy.id} GROUPCHAT_MESSAGE #{group_chat.id} #{args.first}"
+		elsif what == :destroy
+			send_everyone "GROUPCHAT_DESTROY #{group_chat.id}"
+		end
+	end
+
+	def latency (buddy, amount, id)
+		send_everyone "#{buddy.id} LATENCY #{@pings[buddy.id].delete(id).last}"
+	end
+
+	def cleanup!
+		@pings.each {|id, pings|
+			pings.reject! {|time, payload|
+				(Time.now - time).to_i >= 80
+			}
+		}
+
+		@pings.reject!(&:empty?)
+	end
+
+	def connected?; @connected; end
+
+	def connected (buddy)
+		@buddies << buddy
+
+		send_everyone "#{buddy.id} CONNECTED"
+
+		send_everyone "#{buddy.id} NAME #{buddy.name}"               if buddy.name
+		send_everyone "#{buddy.id} DESCRIPTION #{buddy.description}" if buddy.description
+
+		if buddy.client.name
+			send_everyone "#{buddy.id} CLIENT_NAME #{buddy.client.name}"
+		end
+
+		if buddy.client.version
+			send_everyone "#{buddy.id} CLIENT_VERSION #{buddy.client.version}"
+		end
+	end
+
+	def disconnected (buddy)
+		return unless @buddies.include? buddy
+
+		send_everyone "#{buddy.id} DISCONNECTED"
+
+		@buddies.delete buddy
+	end
+
+	def removed (buddy)
+		return unless @buddies.include? buddy
+
+		send_everyone "#{buddy.id} REMOVE"
+	end
+
+	def send_everyone (text, even_unauthorized = false)
+		@connections.each {|connection|
+			next unless connection.authorized? || even_unauthorized
+
+			connection.send_response text
+		}
+	end
+end
+
+EM.run {
+	Torchatd.new(options[:password], options[:file_transfer_ports]) {|d|
+		d.profile = options[:config] ? Torchat.new(options[:config]) : Torchat.profile(options[:profile])
+
+		if options[:generate]
+			if options[:generate] == '-'
+				print d.profile.tor.rc
+			else
+				File.open(options[:generate], 'w') { |f| f.print d.profile.tor.rc }
+			end
+
+			exit
+		end
+
+		puts 'torchatd starting...'
+
+		if options[:tor]
+			d.profile.tor.file = 'torrc.txt'
+
+			d.profile.tor.start "#{d.profile.path || '~/.torchat'}/Tor", -> {
+				abort 'could not load the onion id' if 20.times {
+					break if File.exists? 'hidden_service/hostname'
+
+					sleep 1
+				}
+			}, -> {
+				abort 'tor exited with errors'
+			}
+		end
+
+		unless d.profile.config['id']
+			if d.profile.path
+				if File.readable?("#{d.profile.path}/Tor/hidden_service/hostname")
+					d.profile.config['id'] = File.read("#{d.profile.path}/Tor/hidden_service/hostname")[/^(.*?)\.onion/, 1]
+				end
+			end or abort 'could not deduce the onion id'
+		end
+
+		puts "torchatd started for #{d.profile.config['id']} on #{options[:host]}:#{options[:port]}"
+
+		%w[INT KILL].each {|sig|
+			trap sig do
+				puts 'torchatd stopping...'
+
+				d.stop
+
+				EM.stop_event_loop
+			end
+		}
+
+		d.profile.start {|s|
+			s.on :connect_to do |e|
+				Torchat.debug "connecting to #{e.address}:#{e.port}"
+			end
+
+			s.on :connect_failure do |e|
+				Torchat.debug "#{e.buddy.id} failed to connect"
+			end
+
+			s.on :connect do |e|
+				Torchat.debug "#{e.buddy.id} connected"
+			end
+
+			s.on :verify do |e|
+				Torchat.debug "#{e.buddy.id} has been verified"
+			end
+
+			s.on :ready do |e|
+				d.connected e.buddy
+			end
+
+			s.on :remove_buddy do |e|
+				d.removed e.buddy
+			end
+
+			s.on :disconnect do |e|
+				Torchat.debug "#{e.buddy.id} disconnected"
+
+				d.disconnected e.buddy
+			end
+
+			s.on_packet do |e|
+				d.received_packet e.packet unless e.packet.extension
+			end
+
+			s.on :file_transfer_start do |e|
+				d.file_transfer :start, e.file_transfer
+			end
+
+			s.on :file_transfer_stop do |e|
+				d.file_transfer :stop, e.file_transfer
+			end
+
+			s.on :file_transfer_complete do |e|
+				d.file_transfer :complete, e.file_transfer
+			end
+
+			s.on :typing do |e|
+				d.typing e.buddy, e.mode
+			end
+
+			s.on :broadcast do |e|
+				d.broadcast e.message
+			end
+
+			s.on :group_chat_create do |e|
+				d.group_chat :create, e.group_chat
+			end
+
+			s.on :group_chat_invite do |e|
+				d.group_chat :invite, e.group_chat, e.buddy
+			end
+
+			s.on :group_chat_join do |e|
+				if e.buddy
+					d.group_chat :join, e.group_chat, e.buddy, e.invited_by
+				else
+					d.group_chat :joined, e.group_chat, nil, e.invited_by
+				end
+			end
+
+			s.on :group_chat_message do |e|
+				d.group_chat :message, e.group_chat, e.buddy, e.message
+			end
+
+			s.on :group_chat_leave do |e|
+				if e.buddy
+					d.group_chat :leave, e.group_chat, e.buddy, e.reason
+				else
+					d.group_chat :left, e.group_chat, nil, e.reason
+				end
+			end
+
+			s.on :group_chat_destroy do |e|
+				d.group_chat :destroy, e.group_chat
+			end
+
+			s.on :latency do |e|
+				d.latency e.buddy, e.amount, e.id
+			end
+
+			s.online! if options[:online]
+		}
+
+		EM.add_periodic_timer 60 do
+			d.cleanup!
+		end
+	}.start(options[:host], options[:port], options[:ssl])
+}