I was wondering if anyone could take a gander at this program and tell
me if they see anything obviously wrong or if they could just give me
some pointers, or let me know if it looks good...  The threading thing
is quite new for me, so I wanted to make especially sure that I wasn't
dorking that up.

Thanks in advance

--
require 'net/telnet'
require 'getoptlong'

hosts = []
threads = []
progname = File.basename $0

# Defaults
timeout = 10
prompt = /[$%#>] \z/n
verbose = false
interactive = false
outfile = "/tmp/#{progname}.out"
sleepTime = 0

opts = GetoptLong.new(
        ["--verbose", "-v", GetoptLong::NO_ARGUMENT],
        ["--timeout", "-t", GetoptLong::OPTIONAL_ARGUMENT],
        ["--prompt", "-p", GetoptLong::OPTIONAL_ARGUMENT],
        ["--interactive", "-i", GetoptLong::NO_ARGUMENT],
        ["--outfile", "-o", GetoptLong::OPTIONAL_ARGUMENT],
        ["--sleep", "-s", GetoptLong::REQUIRED_ARGUMENT]
)

def printUsage
        puts <<-USAGE

Usage: #{progname} [-v] [-t] [-p] [-i] [-s N[hm]] host1..hostn
        -v|--verbose     doesn't print login mess
        -t|--timeout     sets the timeout in seconds (connection and
su's)
        -p|--prompt      sets the prompt to look for (ie. /[$%#>] \\z/n)
        -i|--interactive gives you a prompt at each system
        -o|--outfile     name of the file to send output to
        -s|--sleep       time to sleep before execution h/hour m/min

        USAGE
end

def getUser
        print "Username: "
        STDIN.gets.chomp!
end

def getPassword
        print "Password: "
        begin
                system("stty -echo")
                passwd = STDIN.gets.chomp!
        ensure
                system("stty echo")
        end
        puts
        passwd
end

def getCommand
        puts "Commands to run (CTRL-D to end):"
        STDIN.gets("\cD").chomp!
end

opts.each do |opt, arg|
        case opt
                when "--verbose"
                        verbose = true
                when "--timeout"
                        timeout = arg.inspect.to_i
                when "--prompt"
                        prompt = arg.inspect
                when "--interactive"
                        interactive = true
                when "--outfile"
                        outfile = arg.inspect
                when "--sleep"
                        sleepTime = arg.to_i.inspect.to_i
        end
end

if !ARGV[0]
        printUsage
        exit 1
end

user = getUser
passwd = getPassword
print "Enter root password (if needed) "
rpasswd = getPassword
command = getCommand
sleep sleepTime

ARGV.each do |host|
        begin
                hosts << Net::Telnet::new({"Host"       =>      host,
                                           "Timeout"    =>      timeout,
                                           "Prompt"     =>      prompt,
                                           "Output_log" =>
outfile})
        rescue TimeoutError
                puts "#{host} timed out"
        end
end

hosts.each do |con|
        threads << Thread.new(con) do |myCon|
                myCon.login(user, passwd) { |c| print c if verbose }
                if rpasswd != ""
                        myCon.cmd({"String" => "su - root",
                                   "Match" => /[pP]assword:/,
                                   "Timeout" => timeout}) { |c| print
c }
                        myCon.cmd({"String" => rpasswd,
                                   "Match" => prompt,
                                   "Timeout" => timeout}) { |c| print c}
                end

                command.split(/\n/).each do |cmd|
                        myCon.cmd({"String" => cmd,
                                   "Match" => prompt}) { |c| print c }
                end
                myCon.close
        end
end

threads.each { |aThread| aThread.join }


Sent via Deja.com
http://www.deja.com/