Lateralus

use strict;
use IO::Socket::INET;
use IO::Select;

{   package MultiplexServer;
 
    # Constructor
    sub new {
        my ( $class ) = @_;
        my $self = {
                    _connected => 0,
                    _addr => undef,
                    _port => undef,
                    _proto => undef,
                    _listen => undef,
                    _reuse => undef,
                    _listening => undef,
                    _readset => undef,
                    _writeset => undef
                   };
        bless $self, $class;
        return $self;
    }
    
    # Getters/Setters
    sub connected {
        my ( $self ) = @_;
        return $self->{_connected};
    }
    sub addr {
        my ( $self, $addr ) = @_;
        $self->{_addr} = $addr if defined($addr);
        return $self->{_addr};
    }
    sub port {
        my ( $self, $port ) = @_;
        $self->{_port} = $port if defined($port);
        return $self->{_port};
    }
    sub proto {
        my ( $self, $proto ) = @_;
        $self->{_proto} = $proto if defined($proto);
        return $self->{_proto};
    }
    sub listen {
        my ( $self, $listen ) = @_;
        $self->{_listen} = $listen if defined($listen);
        return $self->{_listen};
    }
    sub reuse {
        my ( $self, $reuse ) = @_;
        $self->{_reuse} = $reuse if defined($reuse);
        return $self->{_reuse};
    }
    
    sub start {
        my ( $self ) = @_;
        $self->{_listening} = IO::Socket::INET->new(
                                                    LocalAddr =>    $self->{_addr},
                                                    LocalPort =>    $self->{_port},
                                                    Proto     =>    $self->{_proto},
                                                    Listen    =>    $self->{_listen},
                                                    Reuse     =>    $self->{_reuse}
                                                    );
        die "Could not create socket: $!\n" unless $self->{_listening};
        
        $self->{_writeset} = IO::Select->new();
        $self->{_readset} = IO::Select->new($self->{_listening});
        
        1;
    }
    
    sub check {
        my ( $self ) = @_;
        while (1) {
            my ( $read_handles, $write_handles ) = IO::Select->select($self->{_readset}, $self->{_writeset}, undef, 0);
            
            foreach my $rh (@$read_handles) {
                if ($rh == $self->{_listening}) {
                    print 'New connection received!!';
                    
                    my $new_sock = $rh->accept();
                    $self->{_readset}->add($new_sock);
                    $self->{_writeset}->add($new_sock);
                } else {
                    my $buffer = <$rh>;
                    if ($buffer) {
                        print 'Data can be read!!';
                        print $buffer;
                    } else {
                        print 'Connection dropped.';
                        $self->{_readset}->remove($rh);
                        $self->{_writeset}->remove($rh);
                        close($rh);
                    }
                }
            }
        }
    }
    1;
}