failirc 0.0.1

data/lib/failirc/server/client.rb

@@ -0,0 +1,100 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# failirc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/utils'
+require 'failirc/modes'
+require 'failirc/mask'
+
+require 'failirc/server/channels'
+
+module IRC
+
+class Server
+
+class Client
+    attr_reader   :server, :socket, :listen, :ip, :port, :channels, :modes, :mask, :nick, :user, :host, :connectedOn
+    attr_accessor :password, :realName
+
+    def initialize (server, socket, listen=nil)
+        @server = server
+        @socket = socket
+        @listen = listen
+
+        @registered = false
+
+        @channels = Channels.new(@server)
+        @modes    = Modes.new
+
+        if socket.is_a?(Mask)
+            @mask = socket
+        else
+            @mask     = Mask.new
+            self.host = socket.peeraddr[2]
+            @ip       = socket.peeraddr[3]
+            @port     = socket.addr[1]
+
+            if socket.is_a?(OpenSSL::SSL::SSLSocket)
+                @modes[:ssl] = true
+            end
+        end
+
+        @connectedOn = Time.now
+    end
+
+    def nick= (value)
+        @mask.nick = @nick = value
+    end
+
+    def user= (value)
+        @mask.user = @user = value
+    end
+
+    def host= (value)
+        @mask.host = @host = value
+    end
+
+    def send (symbol, *args)
+        begin
+            self.method(symbol).call(*args)
+        rescue Exception => e
+            self.debug e
+        end
+    end
+
+    def raw (text)
+        @server.dispatcher.dispatch :output, self, text
+        @server.dispatcher.connection.output.push @socket, text
+    end
+
+    def numeric (response, value=nil)
+        raw ":#{server.host} #{'%03d' % response[:code]} #{nick || 'faggot'} #{eval(response[:text])}"
+    end
+
+    def to_s
+        mask.to_s
+    end
+
+    def inspect
+        return "#<Client: #{mask} #{modes}#{(modes[:registered]) ? ' registered' : ''}>"
+    end
+end
+
+end
+
+end

data/lib/failirc/server/clients.rb

@@ -0,0 +1,54 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# failirc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/server/client'
+
+module IRC
+
+class Server
+
+class Clients < Hash
+    attr_reader :server
+
+    def initialize (server, *args)
+        @server = server
+
+        super(*args)
+    end
+
+    def send (*args)
+        each_value {|user|
+            user.send(*args)
+        }
+    end
+
+    def inspect
+        result = ""
+
+        each_value {|client|
+            result << " #{client.inspect}"
+        }
+
+        return result[1, result.length]
+    end
+end
+
+end
+
+end

data/lib/failirc/server/dispatcher.rb

@@ -0,0 +1,219 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# failirc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'failirc/server/dispatcher/connectiondispatcher'
+require 'failirc/server/dispatcher/eventdispatcher'
+
+module IRC
+
+class Server
+
+class Dispatcher
+    attr_reader :server, :connection, :event
+
+    def initialize (server)
+        @server = server
+
+        @connection = ConnectionDispatcher.new(self)
+        @event      = EventDispatcher.new(self)
+
+        @intervals = {}
+        @timeouts  = {}
+    end
+
+    def start
+        @started = true
+
+        @listening = Fiber.new {
+            while true
+                if !@connection.connections.empty?
+                    timeout = 0
+                else
+                    timeout = 2
+                end
+
+                @connection.accept timeout
+
+                Fiber.yield
+            end
+        }
+
+        @reading = Fiber.new {
+            while true
+                @connection.read
+
+                Fiber.yield
+            end
+        }
+
+        @cleaning = Fiber.new {
+            while true
+                @connection.clean
+
+                Fiber.yield
+            end
+        }
+
+        @handling = Fiber.new {
+            while true
+                @connection.handle
+
+                Fiber.yield
+            end
+        }
+
+        @writing = Fiber.new {
+            while true
+                @connection.write
+
+                Fiber.yield
+            end
+        }
+
+        @defaults = [@listening, @cleaning, @reading, @handling, @writing]
+        
+        self.loop
+    end
+
+    def stop
+        if !@started
+            return
+        end
+
+        @started  = false
+        @stopping = true
+
+        @event.finalize
+        @connection.finalize
+
+        @stopping = false
+    end
+
+    def loop
+        while true
+            @defaults.each {|fiber|
+                begin
+                    fiber.resume
+                rescue FiberError
+                    self.debug 'Something went deeply wrong in the dispatcher, aborting.'
+                    Process::exit 23
+                rescue Exception => e
+                    self.debug e
+                end
+            }
+
+            @intervals.each {|fiber, meta|
+                begin
+                    if !@intervals[fiber]
+                        raise FiberError
+                    end
+
+                    if meta[:at] <= Time.now
+                        fiber.resume
+
+                        meta[:at] += meta[:offset]
+                    end
+                rescue FiberError
+                    clearInterval meta
+                rescue Exception => e
+                    self.debug e
+                end
+            }
+
+            @timeouts.each {|fiber, meta|
+                begin
+                    if !@timeouts[fiber]
+                        raise FiberError
+                    end
+
+                    if meta[:at] <= Time.now
+                        fiber.resume
+
+                        clearTimeout meta
+                    end
+                rescue FiberError
+                    clearTimeout meta
+                rescue Exception => e
+                    self.debug e
+                end
+            }
+        end
+    end
+
+    def setTimeout (fiber, time)
+        @timeouts[fiber] = {
+            :fiber => fiber,
+            :at    => Time.now + time,
+            :on    => Time.now,
+        }
+    end
+
+    def clearTimeout (timeout)
+        @timeouts.delete(timeout[:fiber])
+    end
+
+    def setInterval (fiber, time)
+        @intervals[fiber] = {
+            :fiber  => fiber,
+            :offset => time,
+            :at     => Time.now + time,
+            :on     => Time.now,
+        }
+    end
+
+    def clearInterval (interval)
+        @intervals.delete(interval[:fiber])
+    end
+
+    def connections
+        @connection.connections
+    end
+
+    def input
+        @connection.input
+    end
+
+    def output
+        @connection.output
+    end
+
+    def disconnecting
+        @connection.disconnecting
+    end
+
+    def alias (*args)
+        @event.alias(*args)
+    end
+
+    def register (*args)
+        @event.register(*args)
+    end
+
+    def dispatch (*args)
+        @event.dispatch(*args)
+    end
+
+    def execute (*args)
+        @event.execute(*args)
+    end
+end
+
+end
+
+end

data/lib/failirc/server/dispatcher/connectiondispatcher.rb

@@ -0,0 +1,477 @@
+# failirc, a fail IRC library.
+#
+# Copyleft meh. [http://meh.doesntexist.org | meh.ffff@gmail.com]
+#
+# This file is part of failirc.
+#
+# failirc is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# failirc is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with failirc. If not, see <http://www.gnu.org/licenses/>.
+
+require 'thread'
+require 'socket'
+require 'openssl/nonblock'
+
+require 'failirc/utils'
+require 'failirc/sslutils'
+
+module IRC
+
+class Server
+
+class Dispatcher
+
+class ConnectionDispatcher
+    class Connections
+        attr_reader :server
+    
+        def initialize (server)
+            @server = server
+    
+            @data = ThreadSafeHash.new
+    
+            @data[:listening] = {
+                :sockets => [],
+                :data    => {},
+            }
+    
+            @data[:sockets] = []
+            @data[:things]  = {}
+            @data[:clients] = CaseInsensitiveHash.new
+            @data[:links]   = CaseInsensitiveHash.new
+        end
+    
+        def listening
+            @data[:listening]
+        end
+    
+        def sockets
+            @data[:sockets]
+        end
+    
+        def things
+            @data[:things]
+        end
+    
+        def clients
+            @data[:clients]
+        end
+    
+        def links
+            @data[:links]
+        end
+    
+        def empty?
+            sockets.empty?
+        end
+    
+        def exists? (socket)
+            things[socket] ? true : false
+        end
+    
+        def delete (socket)
+            if !exists?(socket)
+                return
+            end
+
+            thing = @data[:things][socket]
+    
+            if thing.is_a?(Client)
+                @data[:clients].delete(thing.nick)
+                @data[:clients].delete(socket)
+            elsif thing.is_a?(Link)
+                @data[:links].delete(thing.host)
+                @data[:links].delete(socket)
+            end
+    
+            @data[:sockets].delete(socket)
+            @data[:things].delete(socket)
+        end
+    end
+
+    class Data
+        attr_reader :server, :dispatcher
+
+        def initialize (dispatcher)
+            @server     = dispatcher.server
+            @dispatcher = dispatcher
+
+            @data = ThreadSafeHash.new
+        end
+
+        def [] (socket)
+            if socket.is_a?(Client) || socket.is_a?(User)
+                socket = socket.socket
+            end
+
+            if !@data[socket].is_a?(Array)
+                @data[socket] = []
+            end
+
+            @data[socket]
+        end
+
+        def push (socket, string)
+            if string.is_a?(String)
+                string.lstrip!
+            end
+
+            if string == :EOC
+                if socket.is_a?(Client) || socket.is_a?(User)
+                    socket = socket.socket
+                end
+
+                dispatcher.disconnecting.push({ :thing => dispatcher.connections.things[socket], :output => self[socket] })
+            end
+
+            if (string && !string.empty?) || self[socket].last == :EOC
+                self[socket].push(string)
+            end
+        end
+
+        def pop (socket)
+            self[socket].shift
+        end
+
+        def clear (socket)
+            self[socket].clear
+        end
+
+        def delete (socket)
+            if socket.is_a?(Client) || socket.is_a?(User)
+                socket = socket.socket
+            end
+
+            @data.delete(socket)
+        end
+
+        def first (socket)
+            self[socket].first
+        end
+
+        def last (socket)
+            self[socket].last
+        end
+
+        def empty? (socket=nil)
+            if socket.is_a?(Client) || socket.is_a?(User)
+                socket = socket.socket
+            end
+
+            if socket
+                if @data.has_key?(socket)
+                   return @data[socket].empty?
+                else
+                    return true
+                end
+            else
+                return @data.empty?
+            end
+        end
+
+        def each (&block)
+            @data.each_key &block
+        end
+    end
+
+    attr_reader :server, :dispatcher, :connections, :input, :output, :disconnecting
+
+    def initialize (dispatcher)
+        @server     = dispatcher.server
+        @dispatcher = dispatcher
+
+        @connections   = Connections.new(server)
+        @input         = Data.new(dispatcher)
+        @output        = Data.new(dispatcher)
+        @disconnecting = []
+    end
+
+    def sockets
+        @connections.sockets
+    end
+
+    def clients
+        @connections.clients
+    end
+
+    def links
+        @connections.links
+    end
+
+    def listen (options, listen)
+        server  = TCPServer.new(options[:bind], options[:port])
+        context = nil
+
+        if options[:ssl] != 'disabled'
+            context = SSLUtils::context(options[:ssl_cert], options[:ssl_key])
+        end
+
+        @connections.listening[:sockets].push(server)
+        @connections.listening[:data][server] = { :listen => listen, :context => context }
+    end
+
+    def accept (timeout=0)
+        begin
+            listening, = IO::select @connections.listening[:sockets], nil, nil, timeout
+
+            if listening
+                listening.each {|server|
+                    begin
+                        socket, = server.accept_nonblock
+
+                        if socket
+                            newConnection socket, @connections.listening[:data][server][:listen], @connections.listening[:data][server][:context]
+                        end
+                    rescue Errno::EAGAIN
+                    rescue Exception => e
+                        self.debug e
+                    end
+                }
+            end
+        rescue IOError
+            @connections.listening[:sockets].each {|socket|
+                if socket.closed?
+                    @connections.listening[:sockets].delete(socket)
+                    @connections.listening[:data].delete(socket                 @connections.listening[:data].delete(socket))
+                end
+            }
+        rescue
+        end
+    end
+
+    # Executed with each incoming connection
+    def newConnection (socket, listen, context=nil)
+        # here, somehow we should check if the incoming peer is a linked server or a real client
+
+        host = socket.peeraddr[2]
+        ip   = socket.peeraddr[3]
+        port = socket.addr[1]
+
+        self.debug "#{host}[#{ip}/#{port}] connecting."
+
+        Thread.new {
+            begin
+                if listen.attributes['ssl'] != 'disabled'
+                    ssl = OpenSSL::SSL::SSLSocket.new socket, context
+
+                    ssl.accept
+                    socket = ssl
+                end
+
+                @connections.things[socket] = @connections.clients[socket] = Server::Client.new(server, socket, listen)
+                @connections.sockets.push(socket)
+
+                @input[socket]
+            rescue OpenSSL::SSL::SSLError
+                socket.write_nonblock "This is a SSL connection, faggot.\r\n" rescue nil
+                self.debug "#{host}[#{ip}/#{port}] tried to connect to a SSL connection and failed the handshake."
+                socket.close rescue nil
+            rescue Errno::ECONNRESET
+                socket.close rescue nil
+                self.debug "#{host}[#{ip}/#{port}] connection reset."
+            rescue Exception => e
+                socket.close rescue nil
+                self.debug(e)
+            end
+        }
+    end
+
+    def read (timeout=0.1)
+        begin
+            reading, = IO::select @connections.sockets, nil, nil, timeout
+        rescue IOError
+            @connections.sockets.each {|socket|
+                if socket.closed?
+                    server.kill socket
+                end
+            }
+        rescue Exception => e
+            self.debug e
+        end
+
+        if !reading
+            return
+        end
+
+        reading.each {|socket|
+            thing = thing socket
+
+            begin
+                input = socket.read_nonblock 2048
+
+                if !input || input.empty?
+                    raise Errno::EPIPE
+                end
+
+                input.split(/[\r\n]+/).each {|string|
+                    @input.push(socket, string)
+                }
+            rescue IOError
+                server.kill thing, 'Input/output error', true
+            rescue Errno::EBADF, Errno::EPIPE, OpenSSL::SSL::SSLError
+                server.kill thing, 'Client exited', true
+            rescue Errno::ECONNRESET
+                server.kill thing, 'Connection reset by peer', true
+            rescue Errno::ETIMEDOUT
+                server.kill thing, 'Ping timeout', true
+            rescue Errno::EHOSTUNREACH
+                server.kill thing, 'No route to host', true
+            rescue Errno::EAGAIN, IO::WaitReadable
+            rescue Exception => e
+                self.debug e
+            end
+        }
+    end
+
+    def clean
+        @disconnecting.each {|data|
+            thing  = data[:thing]
+            output = data[:output]
+
+            if output.first == :EOC
+                output.shift
+                handleDisconnection thing, output.shift
+                @disconnecting.delete(data)
+            end
+        }
+    end
+
+    def handle
+        @input.each {|socket|
+            if dispatcher.event.handling[socket] || @input.empty?(socket)
+                next
+            end
+
+            Thread.new {
+                begin
+                    if string = @input.pop(socket)
+                        dispatcher.dispatch(:input, thing(socket), string)
+                    end
+                rescue Exception => e
+                    self.debug e
+                end
+            }
+        }
+    end
+
+    def write (timeout=0)
+        begin
+            none, writing, erroring = IO::select nil, @connections.sockets, nil, timeout
+        rescue IOError
+            @connections.sockets.each {|socket|
+                if socket.closed?
+                    server.kill thing socket, 'Client exited'
+                end
+            }
+        rescue Exception => e
+            self.debug e
+        end
+
+        if !writing
+            return
+        end
+
+        writing.each {|socket|
+            if @output.empty?(socket)
+                next
+            end
+
+            thing = thing socket
+
+            begin
+                while !@output.empty?(socket)
+                    output = @output.first(socket)
+
+                    if output == :EOC
+                        @output.delete(socket)
+                    else
+                        output.force_encoding 'ASCII-8BIT'
+                        socket.write_nonblock "#{output}\r\n"
+
+                        @output.pop(socket)
+                    end
+                end
+            rescue IOError
+                server.kill thing, 'Input/output error', true
+            rescue Errno::EBADF, Errno::EPIPE, OpenSSL::SSL::SSLError
+                server.kill thing, 'Client exited', true
+            rescue Errno::ECONNRESET
+                server.kill thing, 'Connection reset by peer', true
+            rescue Errno::ETIMEDOUT
+                server.kill thing, 'Ping timeout', true
+            rescue Errno::EHOSTUNREACH
+                server.kill thing, 'No route to host', true
+            rescue Errno::EAGAIN, IO::WaitWritable
+            rescue Exception => e
+                self.debug e
+            end
+        }
+    end
+
+    def handleDisconnection (thing, message)
+        @dispatcher.execute(:kill, thing, message) rescue nil
+
+        if thing.is_a?(Client)
+            thing.modes[:quitting] = true
+
+            if thing.modes[:registered]
+                thing.channels.each_value {|channel|
+                    channel.users.delete(thing.nick)
+                }
+            end
+        elsif thing.is_a?(Link)
+            # wat
+        end
+    
+        @input.delete(thing.socket)
+        @output.delete(thing.socket)
+        connections.delete(thing.socket)
+
+        self.debug "#{thing.mask}[#{thing.ip}/#{thing.port}] disconnected."
+
+        thing.socket.close rescue nil
+    end
+
+    def finalize
+        begin
+            @connections.listening[:sockets].each {|server|
+                server.close
+            }
+
+            @clients.each {|key, client|
+                kill client, 'Good night sweet prince.'
+            }
+
+            @links.each {|key, link|
+                kill client, 'Good night sweet prince.'
+            }
+        rescue Exception => e
+            self.debug e
+        end
+    end
+
+    def thing (identifier)
+        if identifier.is_a?(Client) || identifier.is_a?(Link)
+            return identifier
+        elsif identifier.is_a?(User)
+            return identifier.client
+        else
+            return @connections.things[identifier]
+        end
+    end
+end
+
+end
+
+end
+
+end