class DRb::DRbMessage

normal use.
The user does not have to directly deal with this object in
protocol layer with having to deal with these details.
and client. This relieves the implementor of a new drb
of drb requests and responses sent over the wire between server
This takes care of the low-level marshalling and unmarshalling
Handler for sending and receiving drb messages.

def dump(obj, error=false) # :nodoc:

:nodoc: 
def dump(obj, error=false)  # :nodoc:
  case obj
  when DRbUndumped
    obj = make_proxy(obj, error)
  when Object
    # nothing
  else
    obj = make_proxy(obj, error)
  end
  begin
    str = Marshal::dump(obj)
  rescue
    str = Marshal::dump(make_proxy(obj, error))
  end
  [str.size].pack('N') + str
end

def initialize(config) # :nodoc:

:nodoc: 
def initialize(config) # :nodoc:
  @load_limit = config[:load_limit]
  @argc_limit = config[:argc_limit]
end

def load(soc) # :nodoc:

:nodoc: 
def load(soc)  # :nodoc:
  begin
    sz = soc.read(4)        # sizeof (N)
  rescue
    raise(DRbConnError, $!.message, $!.backtrace)
  end
  raise(DRbConnError, 'connection closed') if sz.nil?
  raise(DRbConnError, 'premature header') if sz.size < 4
  sz = sz.unpack('N')[0]
  raise(DRbConnError, "too large packet #{sz}") if @load_limit < sz
  begin
    str = soc.read(sz)
  rescue
    raise(DRbConnError, $!.message, $!.backtrace)
  end
  raise(DRbConnError, 'connection closed') if str.nil?
  raise(DRbConnError, 'premature marshal format(can\'t read)') if str.size < sz
  DRb.mutex.synchronize do
    begin
      Marshal::load(str)
    rescue NameError, ArgumentError
      DRbUnknown.new($!, str)
    end
  end
end

def make_proxy(obj, error=false) # :nodoc:

:nodoc: 
def make_proxy(obj, error=false) # :nodoc:
  if error
    DRbRemoteError.new(obj)
  else
    DRbObject.new(obj)
  end
end

def recv_reply(stream) # :nodoc:

:nodoc: 
def recv_reply(stream)  # :nodoc:
  succ = load(stream)
  result = load(stream)
  [succ, result]
end

def recv_request(stream) # :nodoc:

:nodoc: 
def recv_request(stream) # :nodoc:
  ref = load(stream)
  ro = DRb.to_obj(ref)
  msg = load(stream)
  argc = load(stream)
  raise(DRbConnError, "too many arguments") if @argc_limit < argc
  argv = Array.new(argc, nil)
  argc.times do |n|
    argv[n] = load(stream)
  end
  block = load(stream)
  return ro, msg, argv, block
end

def send_reply(stream, succ, result) # :nodoc:

:nodoc: 
def send_reply(stream, succ, result)  # :nodoc:
  stream.write(dump(succ) + dump(result, !succ))
rescue
  raise(DRbConnError, $!.message, $!.backtrace)
end

def send_request(stream, ref, msg_id, arg, b) # :nodoc:

:nodoc: 
def send_request(stream, ref, msg_id, arg, b) # :nodoc:
  ary = []
  ary.push(dump(ref.__drbref))
  ary.push(dump(msg_id.id2name))
  ary.push(dump(arg.length))
  arg.each do |e|
    ary.push(dump(e))
  end
  ary.push(dump(b))
  stream.write(ary.join(''))
rescue
  raise(DRbConnError, $!.message, $!.backtrace)
end