I'd say your time is better spent learning how to install to your home directory than figuring out the minutae of sockets. Knowing how to locally install is much more transferable and long-term useful knowledge than socket programming because local installs can solve socket programs as well as lots of other problems.

To implement the entire Telnet protocol (or a subset of it), username and password is just the first issue you are facing. So the level of difficulty is higher than you thought. To install Net::Telnet is a much easier way out.

If you really want to go down the path to implement yourself (for whatever purpose, might be a good learning experience), you first need to get familiar with Telnet protocol, maybe read its specification first (RFC 854).

For your direct issue: yes, you cannot specify password and username when you create TCP socket, as TCP socket never defines those concept (actually not even Telnet). Username and password are tranfered by the Telnet protocol (which is build on top of TCP) as data.

That said, everybody's right you should just figure out how to install a module in your home directory.

First, create the connection to the socket:

use IO::Socket;
my $sock = IO::Socket::INET->new(
    PeerAddr => $host,
    PeerPort => 23,
    Proto => 'tcp',
    Timeout => 3,
    );

if ( ! $sock ) {
    print( STDERR "$host: could not connect: $!" );
    exit( 1 );
}
[download]

It's up to you whether you use blocking or non-blocking, or indeed if you want to wait for a prompt first or not. Here's an example of blocking with waiting for a prompt:

my ( $r, $resp );
while (sysread($sock, $r, 1024) >= 1) {
    $resp .= $r;
    $resp =~ /prompt>/ and last;
}
print $sock "$username\n";
[download]

Then I expect you'd continue using the socket from that point onwards.

Update: as an aside this is a technique that is used in a company I have been working at. There was so much information to be gathered that significant optimisation of the parsing routines had to be done to minimise CPU utilisation given the number of devices being polled using telnet. The above comments allude to Net::Telnet being required.. but the technique of just using IO::Socket has proved rather worthwhile for the purposes I've seen it used for.

Monarch Your code appears to be the solution that I am looking for. When I attach that snippet to my current program it hangs at the command prompt.

I then login to the linux box that telnet is running on and run a who and the user that I am connecting with is not listed...

If this is it then I will follow my Camel and do a local install of Net::Telnet.

Thanks for the input

EDIT: Castway, It is a limited functionality telnet server. The user that I am using does not require a password but all other users on the server do require a password

Have you tried littering the above code with tracing commands to see what is being received from the box you're connecting to? Sometimes you need to initiate a telnet connection with a "\n" just to kick it into life and send a prompt.

e.g.

my ( $r, $resp );

# kick the connection into life with a carriage return
print $sock "\n";

# read in from the connection
while (sysread($sock, $r, 1024) >= 1) {
    print( STDERR 
           "At " . scalar(localtime(time())) 
           . " received '$r'\n" );

    $resp .= $r;
    $resp =~ /prompt>/ and last;
}

# print username to socket
print( STDERR "Sending username..\n" );
print $sock "$username\n";

# debugging loop just to see what we're getting
while (sysread($sock, $r, 1024) >= 1) {
    print( STDERR 
           "At " . scalar(localtime(time())) 
           . " received '$r'\n" );

    $resp .= $r;
}
[download]

Note you can use the strace command as the root user on a linux box to attach tracing to your script. It will give you an idea of what text is coming and going from your socket. Very useful for debugging.

I do also in the same program use 2 different socket call to connect to different ports that also have a telnet like interface. Due to the fact that they don't use a username and password it was easy to implement this. Since that was so simple I was thinking that there was a simple way to go about this and it appears that the solution was in front of me all the time.

Thanks for the input and I will see how it goes.

I wouldnt advise using Net::Telnet if you want to do actual "Telnet" like stuff, since its options support is quite broken. (Its fine for simple "running commands on telnet servers" though).

C.