781 lines
14 KiB
Ruby
781 lines
14 KiB
Ruby
=begin
|
|
|
|
= net/protocol.rb
|
|
|
|
Copyright (c) 1999-2002 Yukihiro Matsumoto
|
|
|
|
written & maintained by Minero Aoki <aamine@loveruby.net>
|
|
|
|
This program is free software. You can re-distribute and/or
|
|
modify this program under the same terms as Ruby itself,
|
|
Ruby Distribute License or GNU General Public License.
|
|
|
|
NOTE: You can find Japanese version of this document in
|
|
the doc/net directory of the standard ruby interpreter package.
|
|
|
|
$Id$
|
|
|
|
=end
|
|
|
|
require 'socket'
|
|
require 'timeout'
|
|
|
|
|
|
module Net
|
|
|
|
class Protocol
|
|
|
|
Version = '1.2.3'
|
|
Revision = %q$Revision$.split(/\s+/)[1]
|
|
|
|
|
|
class << self
|
|
|
|
def port
|
|
default_port
|
|
end
|
|
|
|
private
|
|
|
|
def protocol_param( name, val )
|
|
module_eval <<-End, __FILE__, __LINE__ + 1
|
|
def self.#{name.id2name}
|
|
#{val}
|
|
end
|
|
End
|
|
end
|
|
|
|
end
|
|
|
|
|
|
#
|
|
# --- Configuration Staffs for Sub Classes ---
|
|
#
|
|
# class method default_port
|
|
# class method command_type
|
|
# class method socket_type
|
|
#
|
|
# private method do_start
|
|
# private method do_finish
|
|
#
|
|
# private method conn_address
|
|
# private method conn_port
|
|
#
|
|
|
|
|
|
def Protocol.start( address, port = nil, *args )
|
|
instance = new(address, port)
|
|
|
|
if block_given? then
|
|
instance.start(*args) { return yield(instance) }
|
|
else
|
|
instance.start(*args)
|
|
instance
|
|
end
|
|
end
|
|
|
|
def initialize( addr, port = nil )
|
|
@address = addr
|
|
@port = port || type.default_port
|
|
|
|
@command = nil
|
|
@socket = nil
|
|
|
|
@active = false
|
|
|
|
@open_timeout = 30
|
|
@read_timeout = 60
|
|
|
|
@dout = nil
|
|
end
|
|
|
|
attr_reader :address
|
|
attr_reader :port
|
|
|
|
attr_reader :command
|
|
attr_reader :socket
|
|
|
|
attr_accessor :open_timeout
|
|
attr_reader :read_timeout
|
|
|
|
def read_timeout=( sec )
|
|
@socket.read_timeout = sec if @socket
|
|
@read_timeout = sec
|
|
end
|
|
|
|
def active?
|
|
@active
|
|
end
|
|
|
|
def set_debug_output( arg ) # un-documented
|
|
@dout = arg
|
|
end
|
|
|
|
alias set_pipe set_debug_output
|
|
|
|
def inspect
|
|
"#<#{type} #{address}:#{port} open=#{active?}>"
|
|
end
|
|
|
|
#
|
|
# open
|
|
#
|
|
|
|
def start( *args )
|
|
@active and raise IOError, 'protocol has been opened already'
|
|
|
|
if block_given? then
|
|
begin
|
|
do_start( *args )
|
|
@active = true
|
|
return yield(self)
|
|
ensure
|
|
finish if @active
|
|
end
|
|
end
|
|
|
|
do_start( *args )
|
|
@active = true
|
|
nil
|
|
end
|
|
|
|
private
|
|
|
|
# abstract do_start()
|
|
|
|
def conn_socket
|
|
@socket = type.socket_type.open(
|
|
conn_address(), conn_port(),
|
|
@open_timeout, @read_timeout, @dout )
|
|
on_connect
|
|
end
|
|
|
|
alias conn_address address
|
|
alias conn_port port
|
|
|
|
def reconn_socket
|
|
@socket.reopen @open_timeout
|
|
on_connect
|
|
end
|
|
|
|
def conn_command
|
|
@command = type.command_type.new(@socket)
|
|
end
|
|
|
|
def on_connect
|
|
end
|
|
|
|
#
|
|
# close
|
|
#
|
|
|
|
public
|
|
|
|
def finish
|
|
active? or raise IOError, 'closing already closed protocol'
|
|
do_finish
|
|
@active = false
|
|
nil
|
|
end
|
|
|
|
private
|
|
|
|
# abstract do_finish()
|
|
|
|
def disconn_command
|
|
@command.quit if @command and not @command.critical?
|
|
@command = nil
|
|
end
|
|
|
|
def disconn_socket
|
|
if @socket and not @socket.closed? then
|
|
@socket.close
|
|
end
|
|
@socket = nil
|
|
end
|
|
|
|
end
|
|
|
|
Session = Protocol
|
|
|
|
|
|
class Response
|
|
|
|
def initialize( ctype, code, msg )
|
|
@code_type = ctype
|
|
@code = code
|
|
@message = msg
|
|
super()
|
|
end
|
|
|
|
attr_reader :code_type, :code, :message
|
|
alias msg message
|
|
|
|
def inspect
|
|
"#<#{type} #{code}>"
|
|
end
|
|
|
|
def error!
|
|
raise @code_type.error_type.new( code + ' ' + msg.dump, self )
|
|
end
|
|
|
|
end
|
|
|
|
|
|
class ProtocolError < StandardError; end
|
|
class ProtoSyntaxError < ProtocolError; end
|
|
class ProtoFatalError < ProtocolError; end
|
|
class ProtoUnknownError < ProtocolError; end
|
|
class ProtoServerError < ProtocolError; end
|
|
class ProtoAuthError < ProtocolError; end
|
|
class ProtoCommandError < ProtocolError; end
|
|
class ProtoRetriableError < ProtocolError; end
|
|
ProtocRetryError = ProtoRetriableError
|
|
|
|
class ProtocolError
|
|
|
|
def initialize( msg, resp )
|
|
super msg
|
|
@response = resp
|
|
end
|
|
|
|
attr_reader :response
|
|
alias data response
|
|
|
|
def inspect
|
|
"#<#{type}>"
|
|
end
|
|
|
|
end
|
|
|
|
|
|
class Code
|
|
|
|
def initialize( paren, err )
|
|
@parents = [self] + paren
|
|
@err = err
|
|
end
|
|
|
|
def parents
|
|
@parents.dup
|
|
end
|
|
|
|
def inspect
|
|
"#<#{type} #{sprintf '0x%x', __id__}>"
|
|
end
|
|
|
|
def error_type
|
|
@err
|
|
end
|
|
|
|
def ===( response )
|
|
response.code_type.parents.each {|c| return true if c == self }
|
|
false
|
|
end
|
|
|
|
def mkchild( err = nil )
|
|
type.new( @parents, err || @err )
|
|
end
|
|
|
|
end
|
|
|
|
ReplyCode = Code.new( [], ProtoUnknownError )
|
|
InformationCode = ReplyCode.mkchild( ProtoUnknownError )
|
|
SuccessCode = ReplyCode.mkchild( ProtoUnknownError )
|
|
ContinueCode = ReplyCode.mkchild( ProtoUnknownError )
|
|
ErrorCode = ReplyCode.mkchild( ProtocolError )
|
|
SyntaxErrorCode = ErrorCode.mkchild( ProtoSyntaxError )
|
|
FatalErrorCode = ErrorCode.mkchild( ProtoFatalError )
|
|
ServerErrorCode = ErrorCode.mkchild( ProtoServerError )
|
|
AuthErrorCode = ErrorCode.mkchild( ProtoAuthError )
|
|
RetriableCode = ReplyCode.mkchild( ProtoRetriableError )
|
|
UnknownCode = ReplyCode.mkchild( ProtoUnknownError )
|
|
|
|
|
|
class Command
|
|
|
|
def initialize( sock )
|
|
@socket = sock
|
|
@last_reply = nil
|
|
@atomic = false
|
|
end
|
|
|
|
attr_accessor :socket
|
|
attr_reader :last_reply
|
|
|
|
def inspect
|
|
"#<#{type}>"
|
|
end
|
|
|
|
# abstract quit()
|
|
|
|
private
|
|
|
|
def check_reply( *oks )
|
|
@last_reply = get_reply()
|
|
reply_must @last_reply, *oks
|
|
end
|
|
|
|
# abstract get_reply()
|
|
|
|
def reply_must( rep, *oks )
|
|
oks.each do |i|
|
|
return rep if i === rep
|
|
end
|
|
rep.error!
|
|
end
|
|
|
|
def getok( line, expect = SuccessCode )
|
|
@socket.writeline line
|
|
check_reply expect
|
|
end
|
|
|
|
#
|
|
# error handle
|
|
#
|
|
|
|
public
|
|
|
|
def critical?
|
|
@atomic
|
|
end
|
|
|
|
def error_ok
|
|
@atomic = false
|
|
end
|
|
|
|
private
|
|
|
|
def atomic
|
|
@atomic = true
|
|
ret = yield
|
|
@atomic = false
|
|
ret
|
|
end
|
|
|
|
end
|
|
|
|
|
|
class InternetMessageIO
|
|
|
|
class << self
|
|
alias open new
|
|
end
|
|
|
|
def initialize( addr, port, otime = nil, rtime = nil, dout = nil )
|
|
@address = addr
|
|
@port = port
|
|
@read_timeout = rtime
|
|
@debugout = dout
|
|
|
|
@socket = nil
|
|
@rbuf = nil
|
|
|
|
connect otime
|
|
D 'opened'
|
|
end
|
|
|
|
attr_reader :address
|
|
attr_reader :port
|
|
|
|
def ip_address
|
|
@socket or return ''
|
|
@socket.addr[3]
|
|
end
|
|
|
|
attr_accessor :read_timeout
|
|
|
|
attr_reader :socket
|
|
|
|
def connect( otime )
|
|
D "opening connection to #{@address}..."
|
|
timeout( otime ) {
|
|
@socket = TCPsocket.new( @address, @port )
|
|
}
|
|
@rbuf = ''
|
|
end
|
|
private :connect
|
|
|
|
def close
|
|
if @socket then
|
|
@socket.close
|
|
D 'closed'
|
|
else
|
|
D 'close call for already closed socket'
|
|
end
|
|
@socket = nil
|
|
@rbuf = ''
|
|
end
|
|
|
|
def reopen( otime = nil )
|
|
D 'reopening...'
|
|
close
|
|
connect otime
|
|
D 'reopened'
|
|
end
|
|
|
|
def closed?
|
|
not @socket
|
|
end
|
|
|
|
def inspect
|
|
"#<#{type} #{closed? ? 'closed' : 'opened'}>"
|
|
end
|
|
|
|
###
|
|
### READ
|
|
###
|
|
|
|
public
|
|
|
|
def read( len, dest = '', ignore = false )
|
|
D_off "reading #{len} bytes..."
|
|
|
|
rsize = 0
|
|
begin
|
|
while rsize + @rbuf.size < len do
|
|
rsize += rbuf_moveto(dest, @rbuf.size)
|
|
rbuf_fill
|
|
end
|
|
rbuf_moveto dest, len - rsize
|
|
rescue EOFError
|
|
raise unless ignore
|
|
end
|
|
|
|
D_on "read #{len} bytes"
|
|
dest
|
|
end
|
|
|
|
def read_all( dest = '' )
|
|
D_off 'reading all...'
|
|
|
|
rsize = 0
|
|
begin
|
|
while true do
|
|
rsize += rbuf_moveto(dest, @rbuf.size)
|
|
rbuf_fill
|
|
end
|
|
rescue EOFError
|
|
;
|
|
end
|
|
|
|
D_on "read #{rsize} bytes"
|
|
dest
|
|
end
|
|
|
|
def readuntil( target, ignore = false )
|
|
dest = ''
|
|
begin
|
|
while true do
|
|
idx = @rbuf.index(target)
|
|
break if idx
|
|
rbuf_fill
|
|
end
|
|
rbuf_moveto dest, idx + target.size
|
|
rescue EOFError
|
|
raise unless ignore
|
|
rbuf_moveto dest, @rbuf.size
|
|
end
|
|
dest
|
|
end
|
|
|
|
def readline
|
|
ret = readuntil("\n")
|
|
ret.chop!
|
|
ret
|
|
end
|
|
|
|
private
|
|
|
|
BLOCK_SIZE = 1024
|
|
|
|
def rbuf_fill
|
|
until IO.select [@socket], nil, nil, @read_timeout do
|
|
on_read_timeout
|
|
end
|
|
@rbuf << @socket.sysread(BLOCK_SIZE)
|
|
end
|
|
|
|
def on_read_timeout
|
|
raise TimeoutError, "socket read timeout (#{@read_timeout} sec)"
|
|
end
|
|
|
|
def rbuf_moveto( dest, len )
|
|
dest << (s = @rbuf.slice!(0, len))
|
|
@debugout << %Q[-> #{s.dump}\n] if @debugout
|
|
len
|
|
end
|
|
|
|
#
|
|
# message read
|
|
#
|
|
|
|
public
|
|
|
|
def read_message_to( dest )
|
|
D_off 'reading text...'
|
|
|
|
rsize = 0
|
|
while (str = readuntil("\r\n")) != ".\r\n" do
|
|
rsize += str.size
|
|
dest << str.sub(/\A\./, '')
|
|
end
|
|
|
|
D_on "read #{rsize} bytes"
|
|
dest
|
|
end
|
|
|
|
# private use only (cannot handle 'break')
|
|
def each_list_item
|
|
while (str = readuntil("\r\n")) != ".\r\n" do
|
|
yield str.chop
|
|
end
|
|
end
|
|
|
|
|
|
###
|
|
### WRITE
|
|
###
|
|
|
|
#
|
|
# basic write
|
|
#
|
|
|
|
public
|
|
|
|
def write( str )
|
|
writing {
|
|
do_write str
|
|
}
|
|
end
|
|
|
|
def writeline( str )
|
|
writing {
|
|
do_write str + "\r\n"
|
|
}
|
|
end
|
|
|
|
private
|
|
|
|
def writing
|
|
@writtensize = 0
|
|
@debugout << '<- ' if @debugout
|
|
yield
|
|
@socket.flush
|
|
@debugout << "\n" if @debugout
|
|
@writtensize
|
|
end
|
|
|
|
def do_write( str )
|
|
@debugout << str.dump if @debugout
|
|
@writtensize += (n = @socket.write(str))
|
|
n
|
|
end
|
|
|
|
#
|
|
# message write
|
|
#
|
|
|
|
public
|
|
|
|
def write_message( src )
|
|
D_off "writing text from #{src.type}"
|
|
|
|
wsize = using_each_crlf_line {
|
|
wpend_in src
|
|
}
|
|
|
|
D_on "wrote #{wsize} bytes text"
|
|
wsize
|
|
end
|
|
|
|
def through_message
|
|
D_off 'writing text from block'
|
|
|
|
wsize = using_each_crlf_line {
|
|
yield WriteAdapter.new(self, :wpend_in)
|
|
}
|
|
|
|
D_on "wrote #{wsize} bytes text"
|
|
wsize
|
|
end
|
|
|
|
private
|
|
|
|
def wpend_in( src )
|
|
line = nil
|
|
pre = @writtensize
|
|
each_crlf_line( src ) do |line|
|
|
do_write '.' if line[0] == ?.
|
|
do_write line
|
|
end
|
|
|
|
@writtensize - pre
|
|
end
|
|
|
|
def using_each_crlf_line
|
|
writing {
|
|
@wbuf = ''
|
|
|
|
yield
|
|
|
|
if not @wbuf.empty? then # unterminated last line
|
|
if @wbuf[-1] == ?\r then
|
|
@wbuf.chop!
|
|
end
|
|
@wbuf.concat "\r\n"
|
|
do_write @wbuf
|
|
elsif @writtensize == 0 then # empty src
|
|
do_write "\r\n"
|
|
end
|
|
do_write ".\r\n"
|
|
|
|
@wbuf = nil
|
|
}
|
|
end
|
|
|
|
def each_crlf_line( src )
|
|
str = m = beg = nil
|
|
|
|
adding( src ) do
|
|
beg = 0
|
|
buf = @wbuf
|
|
while buf.index( /\n|\r\n|\r/, beg ) do
|
|
m = Regexp.last_match
|
|
if m.begin(0) == buf.size - 1 and buf[-1] == ?\r then
|
|
# "...\r" : can follow "\n..."
|
|
break
|
|
end
|
|
str = buf[ beg ... m.begin(0) ]
|
|
str.concat "\r\n"
|
|
yield str
|
|
beg = m.end(0)
|
|
end
|
|
@wbuf = buf[ beg ... buf.size ]
|
|
end
|
|
end
|
|
|
|
def adding( src )
|
|
i = nil
|
|
|
|
case src
|
|
when String
|
|
0.step( src.size - 1, 2048 ) do |i|
|
|
@wbuf << src[i,2048]
|
|
yield
|
|
end
|
|
|
|
when File
|
|
while true do
|
|
i = src.read(2048)
|
|
break unless i
|
|
i[0,0] = @wbuf
|
|
@wbuf = i
|
|
yield
|
|
end
|
|
|
|
else
|
|
src.each do |i|
|
|
@wbuf << i
|
|
if @wbuf.size > 2048 then
|
|
yield
|
|
end
|
|
end
|
|
yield unless @wbuf.empty?
|
|
end
|
|
end
|
|
|
|
###
|
|
### DEBUG
|
|
###
|
|
|
|
private
|
|
|
|
def D_off( msg )
|
|
D msg
|
|
@savedo, @debugout = @debugout, nil
|
|
end
|
|
|
|
def D_on( msg )
|
|
@debugout = @savedo
|
|
D msg
|
|
end
|
|
|
|
def D( msg )
|
|
@debugout or return
|
|
@debugout << msg
|
|
@debugout << "\n"
|
|
end
|
|
|
|
end
|
|
|
|
|
|
class WriteAdapter
|
|
|
|
def initialize( sock, mid )
|
|
@socket = sock
|
|
@mid = mid
|
|
end
|
|
|
|
def inspect
|
|
"#<#{type} socket=#{@socket.inspect}>"
|
|
end
|
|
|
|
def write( str )
|
|
@socket.__send__ @mid, str
|
|
end
|
|
|
|
alias print write
|
|
|
|
def <<( str )
|
|
write str
|
|
self
|
|
end
|
|
|
|
def puts( str = '' )
|
|
write str.sub(/\n?/, "\n")
|
|
end
|
|
|
|
def printf( *args )
|
|
write sprintf(*args)
|
|
end
|
|
|
|
end
|
|
|
|
|
|
class ReadAdapter
|
|
|
|
def initialize( block )
|
|
@block = block
|
|
end
|
|
|
|
def inspect
|
|
"#<#{type}>"
|
|
end
|
|
|
|
def <<( str )
|
|
call_block str, &@block if @block
|
|
end
|
|
|
|
private
|
|
|
|
def call_block( str )
|
|
yield str
|
|
end
|
|
|
|
end
|
|
|
|
|
|
# for backward compatibility
|
|
module NetPrivate
|
|
Response = ::Net::Response
|
|
Command = ::Net::Command
|
|
Socket = ::Net::InternetMessageIO
|
|
BufferedSocket = ::Net::InternetMessageIO
|
|
WriteAdapter = ::Net::WriteAdapter
|
|
ReadAdapter = ::Net::ReadAdapter
|
|
end
|
|
BufferedSocket = ::Net::InternetMessageIO
|
|
|
|
end # module Net
|