Lateralus

#!/usr/bin/perl -w

use strict;
use MultiplexServer;

my $server = MultiplexServer->new();
$server->addr('127.0.0.1');
$server->port(9090);
$server->proto('tcp');
$server->listen(16);
$server->reuse(1);
$server->start();
$server->check();



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);
            
            foreach my $rh (@read_handles) {
                if ($rh == $self->{_listening}) {
                    print 'New connection received!!';
                }
            }
        }
    }
    1;
}