root/lang/ruby/partty/trunk/parttyd.rb @ 8625

require 'rubygems'
require 'eventmachine'
require 'emtelnet'


class ParttyServer
        def initialize
                @hosts = {}
        end
        def add_host(session, host)
                puts "Start session #{session.inspect}"
                @hosts[session] = host
        end
        def remove_host(session)
                puts "Close session #{session.inspect}"
                @hosts.delete(session)
        end
        def [](sessoin)
                @hosts[sessoin]
        end
end

Server = ParttyServer.new



module TelnetStateIO

        def initialize
                @telnet = Emtelnet.new
        end

        def receive_data data
                inbuf, outbuf = @telnet.recv(data)
                unless outbuf.empty?
                        send_data outbuf
                end
                unless inbuf.empty?
                        __send__ @state, inbuf
                end
        end

protected
        def send(data)
                send_data @telnet.send(data)
        end

        def set_state(state)
                @state = state
        end

        LINE_BREAK_CHRSETSET = /[^#{Regexp.escape('!#$%\'()*+-.:;=?@[\]_`{}~ ')}\w]/
        def recv_line(data, buf, max)
                unless (npos = data.index(LINE_BREAK_CHRSETSET)).nil?
                        data.slice!(npos..-1)
                        buf << data
                        buf.slice!(max..-1)
                        return true
                else
                        buf << data
                        if buf.length > max
                                buf.slice!(max..-1)
                                return true
                        end
                        return false
                end
        end

        def recv_fixed(data, buf, len)
                buf << data
                if buf.length > len
                        rest = buf.slice!(len..-1)
                        rest
                elsif buf.length == len
                        ""
                else
                        nil
                end
        end
end


module Host
        include TelnetStateIO

        def initialize
                super
                @guests = []
                @session = ""
                @write_pass = ""
                @read_pass = ""
                @header = ""
                @header_data = ""
                @host = nil
        end

        def post_init
                set_state :recv_init
        end

        def unbind
                if @host
                        Server.remove_host(@session)
                end
        end

        NEGOTIATION_MAGIC_STRING = "Partty!"
        NEGOTIATION_HEADER_LENGTH = 7 + 1 + 2*4
        module NEGOTIATION_REPLY
                SUCCESS = 0
                PROTOCOL_MISMATCH = 1
                SESSION_UNAVAILABLE = 2
                SERVER_ERROR = 3
                AUTHENTICATION_FAILED = 4
        end

        def recv_init(data)
                return unless rest_data = recv_fixed(data, @header, NEGOTIATION_HEADER_LENGTH)
                magic, protocol_version, @message_len, @session_len, @wpass_len, @rpass_len =
                        @header.unpack("a7cn4")
                if magic != NEGOTIATION_MAGIC_STRING
                        send_negotiation_reply(NEGOTIATION_REPLY::PROTOCOL_MISMATCH, "protocol mismatch")
                        return close_connection_after_writing
                end

                # FIXME check protocol_version

                set_state :recv_header
                recv_header(rest_data)
        end

        def recv_header(data)
                return unless recv_fixed(data, @header_data, @message_len + @session_len + @wpass_len + @rpass_len)
                @message, @session, @write_pass, @read_pass =
                        @header_data.unpack("a#{@message_len}a#{@session_len}a#{@wpass_len}a#{@rpass_len}")
                send_negotiation_reply(NEGOTIATION_REPLY::SUCCESS, "ok")
                @host = Server.add_host(@session, self)
                set_state :recv_term
        end

        def recv_term(data)
                @guests.each {|g|
                        g.send data
                }
        end

        def guest_data(guest, data)
                if guest.info.writable?
                        send data
                end
        end


        class GuestInfo
                def initialize(w)
                        @writable = w
                end
                attr_accessor :writable
                def writable?
                        @writable
                end
        end

        def add_guest(guest, password)
                if password == @write_pass
                        puts "#{@session.inspect}: accepted operatable guest #{guest.inspect}"
                        @guests << guest
                        GuestInfo.new(true)
                elsif password == @read_pass
                        puts "#{@session.inspect}: accepted view-only guest #{guest.inspect}"
                        @guests << guest
                        GuestInfo.new(false)
                else
                        nil
                end
        end

        def remove_guest(guest)
                puts "#{@session.inspect}: remove guest #{guest.inspect}"
                @guests.delete(guest)
        end

private
        def send_negotiation_reply(code, msg)
                send_data [code, msg.length].pack("n2") + msg
        end
end


module Guest
        include TelnetStateIO

        def initialize
                super
                @session = ""
                @password = ""
                @host = nil
                @info = nil

                # telnet option: force clinet line mode

                # use these options
                @telnet.my_option_handler[Emtelnet::OPT_BINARY] = Proc.new {}

                # supported partner options
                @telnet.partner_option_handler[Emtelnet::OPT_ECHO] = Proc.new {}
                @telnet.partner_option_handler[Emtelnet::OPT_LINEMODE] = Proc.new {}
                @telnet.partner_option_handler[Emtelnet::OPT_BINARY] = Proc.new {}
        end

        attr_reader :info


        def session_init
                # add these options
                @telnet.my_option_handler[Emtelnet::OPT_SGA] = Proc.new {}
                @telnet.my_option_handler[Emtelnet::OPT_NAWS] = Proc.new {}

                # add supported partner options
                @telnet.partner_option_handler[Emtelnet::OPT_BINARY] = Proc.new {}

                # prevent line mode
                @telnet.send_will(Emtelnet::OPT_SGA);
                @telnet.send_will(Emtelnet::OPT_ECHO);
                @telnet.send_dont(Emtelnet::OPT_ECHO);
                @telnet.send_dont(Emtelnet::OPT_LINEMODE);

                # enable multibyte characters
                @telnet.send_will(Emtelnet::OPT_BINARY);
                @telnet.send_do(Emtelnet::OPT_BINARY);

                # window size
                @telnet.send_will(Emtelnet::OPT_NAWS);
        end
        private :session_init


        # called when the connection is closed
        def unbind
                reset_host
        end

        def post_init
                send "Session name: "
                set_state :recv_session_name
        end

        def recv_session_name(data)
                if recv_line(data, @session, 64)
                        # prevent local-echo
                        @telnet.send_will(Emtelnet::OPT_ECHO)
                        @telnet.send_dont(Emtelnet::OPT_ECHO)

                        send "Password: "
                        @state = :recv_password
                end
        end

        def recv_password(data)
                if recv_line(data, @password, 64)
                        unless err = set_host
                                send "\r\nPartty! connected.\r\n"
                                @state = :recv_operation
                        else
                                send "\r\n#{err}.\r\n"
                                close_connection_after_writing
                        end
                end
        end

        def recv_operation(data)
                @host.guest_data(self, data)
        end

private

        def set_host
                host = Server[@session]
                return "No such session `#{@session}'" unless host
                if @info = host.add_guest(self, @password)
                        @host = host
                        session_init
                        nil
                else
                        return "Password not match"
                end
        end

        def reset_host
                if @host
                        @host.remove_guest(self)
                end
        end

end



require 'optparse'
op = OptionParser.new

op.version = "0.4.0"
op.banner = "Partty! Server #{op.version}\n#{op.banner}"

options = {
        :host_port => 10000,
        :guest_port => 20000,
        :flash_guest_port => nil,
        :listen_addr => "0.0.0.0",
}

op.on('-l <port>', "listen port for partty-host [#{options[:host_port]}]", Integer) {|arg|
        options[:host_port] = arg
}

op.on('-g <port>', "listen port for telnet guest [#{options[:guest_port]}]", Integer) {|arg|
        options[:guest_port] = arg
}

op.on('-f <port>', "listen port for flash telnet guest [don't listen]", Integer) {|arg|
        options[:flash_guest_port] = arg
}

op.on('-a <address>', "listen address [#{options[:listen_addr]}]", String) {|arg|
        options[:listen_addr] = arg
}

op.parse!(ARGV)
unless ARGV.empty?
        puts op.ver
        puts op.help
        exit
end

EventMachine::run do
        EventMachine.start_server options[:listen_addr], options[:host_port], Host
        EventMachine.start_server options[:listen_addr], options[:guest_port], Guest
end