if(defined($child_pid)){

You probably meant if($child_pid){, as testing defined $child_pid is true for both parent and child (pid==0), so they'll both execute the same code — which is most likely not what you want...

That was the first initial thing I tried, at the Server.pl program, it would allow writing at that terminal session but whatever typed in is not conveyed through into the client session, the same thing is true vice versa...

That was the first initial thing I tried, at the Server.pl program

Did you have it in Client.pl, too?  With if (defined($child_pid)), the client would never execute its read loop either, i.e.

while(my $line = <$socket>){
        print "SERVER says: $line\n";
        }
[download]

With the mentioned change in both Server.pl and Client.pl, your code works fine for me... — except that you may not want to add another empty line every time the server sends a line to the client  (the superfluous "\n" in print $client "$line\n"; ).

I'd recommend to use POE or AnyEvent for your program. These packages will take care about low level details, so you should only write handlers for read/write events.

Update: here's the example that uses AnyEvent. Start without arguments for server, or specify hostname as argument for client.

use strict;
use warnings;

use AnyEvent;
use AnyEvent::Socket;
use AnyEvent::Handle;

my $port = 7777;
my $cv = AnyEvent->condvar;

if ( $ARGV[0] ) {

    # client
    tcp_connect $ARGV[0], 7777, sub {
        my ($fh) = @_
            or die "connect failed: $!";
        create_handle($fh, 1);
    };
}
else {

    # server
    tcp_server undef, 7777, sub {
        my ( $fh, $host, $port ) = @_;
        warn "Accepted connection from $host\n";
        create_handle($fh, 0);
    };
}

sub create_handle {
    my ($socket, $exit_on_close) = @_;
    my ( $shandle, $thandle );
    my $destroy = sub { 
        $shandle->destroy; 
        $thandle->destroy;
        $cv->send if $exit_on_close;
    };
    $shandle = AnyEvent::Handle->new(
        fh       => $socket,
        on_error => $destroy,
        on_close => $destroy,
    );
    $thandle = AnyEvent::Handle->new(
        fh       => \*STDIN,
        on_error => $destroy,
        on_close => $destroy,
    );
    $shandle->on_read( sub { 
        print $shandle->rbuf;
        $shandle->rbuf = '';
      }
    );
    $thandle->on_read( sub {
        $shandle->push_write( $thandle->rbuf );
        $thandle->rbuf = '';
      }
    );
}

$cv->recv;
[download]

Update: fixed some issues

#!/usr/bin/perl -w
use strict;
use IO::Socket;

my ( $host, $port, $kidpid, $handle, $line );

( $host, $port ) = ('localhost',1200);

my $name = shift || '';
if($name eq ''){print "What's your name?\n"}
chomp ($name = <>);


# create a tcp connection to the specified host and port
$handle = IO::Socket::INET->new(
    Proto    => "tcp",
    PeerAddr => $host,
    PeerPort => $port
  )
  or die "can't connect to port $port on $host: $!";
$handle->autoflush(1);    # so output gets there right away
print STDERR "[Connected to $host:$port]\n";

# split the program into two processes, identical twins
die "can't fork: $!" unless defined( $kidpid = fork() );

# the if{} block runs only in the parent process
if ($kidpid) {

    # copy the socket to standard output
    while ( defined( $line = <$handle> ) ) {
                      print STDOUT $line;
                      }
    kill( "TERM", $kidpid );    # send SIGTERM to child
}

# the else{} block runs only in the child process
else {

    # copy standard input to the socket
    while ( defined( $line = <STDIN> ) ) {
        print $handle "$name->$line";
    }
}
[download]

The system I run this on is WinXP

Don't expect fork() and exec() on Windows to behave like they do on Unix-like systems. Windows has neither a fork() nor an exec() system call.

Perl has a rather thin emulation layer that fakes fork() and exec() well enough (using separate interpreter threads inside the same process) for some common cases. But the emulation is far from being perfect.

Cygwin has a different approach, it emulates fork() using mutexes and shared memory across different processes, which is quite slow. And even cygwin can't emulate exec().

Alexander