Class: Net::Telnet

# File 'lib/net/telnet.rb', line 417

def binmode=(mode)
  if (true == mode or false == mode)
    @options["Binmode"] = mode
  else
    raise ArgumentError, "argument must be true or false"
  end
end

# File 'lib/net/telnet.rb', line 757

def close
  @sock.close
end

# File 'lib/net/telnet.rb', line 678

def cmd(options) # :yield: recvdata
  match    = @options["Prompt"]
  time_out = @options["Timeout"]
  fail_eof = @options["FailEOF"]

  if options.kind_of?(Hash)
    string   = options["String"]
    match    = options["Match"]   if options.has_key?("Match")
    time_out = options["Timeout"] if options.has_key?("Timeout")
    fail_eof = options["FailEOF"] if options.has_key?("FailEOF")
  else
    string = options
  end

  self.puts(string)
  if block_given?
    waitfor({"Prompt" => match, "Timeout" => time_out, "FailEOF" => fail_eof}){|c| yield c }
  else
    waitfor({"Prompt" => match, "Timeout" => time_out, "FailEOF" => fail_eof})
  end
end

# File 'lib/net/telnet.rb', line 722

def login(options, password = nil) # :yield: recvdata
  login_prompt = /[Ll]ogin[: ]*\z/n
  password_prompt = /[Pp]ass(?:word|phrase)[: ]*\z/n
  if options.kind_of?(Hash)
    username = options["Name"]
    password = options["Password"]
    login_prompt = options["LoginPrompt"] if options["LoginPrompt"]
    password_prompt = options["PasswordPrompt"] if options["PasswordPrompt"]
  else
    username = options
  end

  if block_given?
    line = waitfor(login_prompt){|c| yield c }
    if password
      line += cmd({"String" => username,
                   "Match" => password_prompt}){|c| yield c }
      line += cmd(password){|c| yield c }
    else
      line += cmd(username){|c| yield c }
    end
  else
    line = waitfor(login_prompt)
    if password
      line += cmd({"String" => username,
                   "Match" => password_prompt})
      line += cmd(password)
    else
      line += cmd(username)
    end
  end
  line
end

# File 'lib/net/telnet.rb', line 431

def preprocess(string)
  # combine CR+NULL into CR
  string = string.gsub(/#{CR}#{NULL}/no, CR) if @options["Telnetmode"]

  # combine EOL into "\n"
  string = string.gsub(/#{EOL}/no, "\n") unless @options["Binmode"]

  # remove NULL
  string = string.gsub(/#{NULL}/no, '') unless @options["Binmode"]

  string.gsub(/#{IAC}(
               [#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]|
               [#{DO}#{DONT}#{WILL}#{WONT}]
                 [#{OPT_BINARY}-#{OPT_NEW_ENVIRON}#{OPT_EXOPL}]|
               #{SB}[^#{IAC}]*#{IAC}#{SE}
             )/xno) do
    if    IAC == $1  # handle escaped IAC characters
      IAC
    elsif AYT == $1  # respond to "IAC AYT" (are you there)
      self.write("nobody here but us pigeons" + EOL)
      ''
    elsif DO[0] == $1[0]  # respond to "IAC DO x"
      if OPT_BINARY[0] == $1[1]
        @telnet_option["BINARY"] = true
        self.write(IAC + WILL + OPT_BINARY)
      else
        self.write(IAC + WONT + $1[1..1])
      end
      ''
    elsif DONT[0] == $1[0]  # respond to "IAC DON'T x" with "IAC WON'T x"
      self.write(IAC + WONT + $1[1..1])
      ''
    elsif WILL[0] == $1[0]  # respond to "IAC WILL x"
      if    OPT_BINARY[0] == $1[1]
        self.write(IAC + DO + OPT_BINARY)
      elsif OPT_ECHO[0] == $1[1]
        self.write(IAC + DO + OPT_ECHO)
      elsif OPT_SGA[0]  == $1[1]
        @telnet_option["SGA"] = true
        self.write(IAC + DO + OPT_SGA)
      else
        self.write(IAC + DONT + $1[1..1])
      end
      ''
    elsif WONT[0] == $1[0]  # respond to "IAC WON'T x"
      if    OPT_ECHO[0] == $1[1]
        self.write(IAC + DONT + OPT_ECHO)
      elsif OPT_SGA[0]  == $1[1]
        @telnet_option["SGA"] = false
        self.write(IAC + DONT + OPT_SGA)
      else
        self.write(IAC + DONT + $1[1..1])
      end
      ''
    else
      ''
    end
  end
end

# File 'lib/net/telnet.rb', line 625

def print(string)
  string = string.gsub(/#{IAC}/no, IAC + IAC) if @options["Telnetmode"]

  if @options["Binmode"]
    self.write(string)
  else
    if @telnet_option["BINARY"] and @telnet_option["SGA"]
      # IAC WILL SGA IAC DO BIN send EOL --> CR
      self.write(string.gsub(/\n/n, CR))
    elsif @telnet_option["SGA"]
      # IAC WILL SGA send EOL --> CR+NULL
      self.write(string.gsub(/\n/n, CR + NULL))
    else
      # NONE send EOL --> CR+LF
      self.write(string.gsub(/\n/n, EOL))
    end
  end
end

# File 'lib/net/telnet.rb', line 647

def puts(string)
  self.print(string + "\n")
end

# File 'lib/net/telnet.rb', line 381

def telnetmode(mode = nil)
  case mode
  when nil
    @options["Telnetmode"]
  when true, false
    @options["Telnetmode"] = mode
  else
    raise ArgumentError, "argument must be true or false, or missing"
  end
end

# File 'lib/net/telnet.rb', line 395

def telnetmode=(mode)
  if (true == mode or false == mode)
    @options["Telnetmode"] = mode
  else
    raise ArgumentError, "argument must be true or false"
  end
end

# File 'lib/net/telnet.rb', line 528

def waitfor(options) # :yield: recvdata
  time_out = @options["Timeout"]
  waittime = @options["Waittime"]
  fail_eof = @options["FailEOF"]

  if options.kind_of?(Hash)
    prompt   = if options.has_key?("Match")
                 options["Match"]
               elsif options.has_key?("Prompt")
                 options["Prompt"]
               elsif options.has_key?("String")
                 Regexp.new( Regexp.quote(options["String"]) )
               end
    time_out = options["Timeout"]  if options.has_key?("Timeout")
    waittime = options["Waittime"] if options.has_key?("Waittime")
    fail_eof = options["FailEOF"]  if options.has_key?("FailEOF")
  else
    prompt = options
  end

  if time_out == false
    time_out = nil
  end

  line = ''
  buf = ''
  rest = ''
  until(prompt === line and not IO::select([@sock], nil, nil, waittime))
    unless IO::select([@sock], nil, nil, time_out)
      raise Net::ReadTimeout, "timed out while waiting for more data"
    end
    begin
      c = @sock.readpartial(1024 * 1024)
      @dumplog.log_dump('<', c) if @options.has_key?("Dump_log")
      if @options["Telnetmode"]
        c = rest + c
        if Integer(c.rindex(/#{IAC}#{SE}/no) || 0) <
           Integer(c.rindex(/#{IAC}#{SB}/no) || 0)
          buf = preprocess(c[0 ... c.rindex(/#{IAC}#{SB}/no)])
          rest = c[c.rindex(/#{IAC}#{SB}/no) .. -1]
        elsif pt = c.rindex(/#{IAC}[^#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]?\z/no) ||
                   c.rindex(/\r\z/no)
          buf = preprocess(c[0 ... pt])
          rest = c[pt .. -1]
        else
          buf = preprocess(c)
          rest = ''
        end
     else
       # Not Telnetmode.
       #
       # We cannot use preprocess() on this data, because that
       # method makes some Telnetmode-specific assumptions.
       buf = rest + c
       rest = ''
       unless @options["Binmode"]
         if pt = buf.rindex(/\r\z/no)
           buf = buf[0 ... pt]
           rest = buf[pt .. -1]
         end
         buf.gsub!(/#{EOL}/no, "\n")
       end
      end
      @log.print(buf) if @options.has_key?("Output_log")
      line += buf
      yield buf if block_given?
    rescue EOFError # End of file reached
      raise if fail_eof
      if line == ''
        line = nil
        yield nil if block_given?
      end
      break
    end
  end
  line
end

# File 'lib/net/telnet.rb', line 610

def write(string)
  length = string.length
  while 0 < length
    IO::select(nil, [@sock])
    @dumplog.log_dump('>', string[-length..-1]) if @options.has_key?("Dump_log")
    length -= @sock.syswrite(string[-length..-1])
  end
end