File Coverage

blib/lib/FUSE/Server.pm

Criterion	Covered	Total	%
statement	12	120	10.0
branch	0	28	0.0
condition	0	7	0.0
subroutine	4	16	25.0
pod	8	12	66.6
total	24	183	13.1

package FUSE::Server;

require 5;
use strict;

use vars qw($VERSION @ISA @EXPORT);

use IO::Socket;
use IO::Select;

require Exporter;

@ISA = qw(Exporter);
@EXPORT = qw();
$VERSION = '1.19';

my $nextid = 0;

sub new {
	my ($class,$params) = @_;
	my $self = {};
	bless $self,ref $class || $class;
	$self->{quiet} = ${$params}{Quiet};
	$self->{port} = ${$params}{Port} || 1024;
	$self->{maxc} = ${$params}{MaxClients} || SOMAXCONN;
	$self->{max_msglen} = 1024;
	$self->{server_sock} = 0;
	$self->{sel} = 0;
	$self->{users} = {};
	return $self;
}

sub bind {
	my ($self) = @_;

	$self->{server_sock} = IO::Socket::INET->new(Proto=>"tcp", LocalPort=>$self->{port}, Listen=>$self->{maxc}, Reuse=>1);
	$self->{sel} = IO::Select->new($self->{server_sock});

	return $self->{server_sock}->sockhost();
}

sub start {
	my ($self) = @_;

	while (my @ready = $self->{sel}->can_read) {

		foreach my $client (@ready) {

			if ($client == $self->{server_sock}) {

				my $add = $client->accept;
				$add->blocking(0);
				$self->{sel}->add($add);
				$self->newsession($add);
			}else{

				my ($in,$msg,$nread,$nsafe);

				do {
					$nread = sysread($client, $in, 1024);
					$msg .= $in;
					$nsafe = 0;
					if (defined($nread)){
						$nsafe = $nread;
					}
				} while ($nsafe == 1024);

				if (defined($nread)) {
					if ($nread == 0){
						$self->{sel}->remove($client);
						$self->endsession($client);
						close($client);
					}
				}

				if (defined($msg)){
					if ($msg){
						$self->incoming($client, $msg);
					}
				}
			}
		}
	}
}

sub stop{
	my ($self) = @_;

	close($self->{server_sock});
}

sub addCallback{
	my ($self,$msg,$coderef) = @_;
	$self->{callbacks}{$msg} = $coderef;
}

sub defaultCallback{
	my ($self,$coderef) = @_;
	$self->{def_callback} = $coderef;
}

sub send{
	my ($self,$uid,$msg,$params) = @_;

	for (keys %{$self->{users}}){
		if ($self->{users}{$_}{id} == $uid){
			my $sock = $self->{users}{$_}{sock};
			print $sock "# $msg\cM";
			print $sock "$params\cM";
			print $sock "##\cM\cJ";
			last;
		}
	}
}

sub sendAll{
	my ($self,$msg,$params) = @_;
	for (keys %{$self->{users}}){
		$self->send($self->{users}{$_}{id},$msg,$params);
	}
}


##########

sub newsession {
	my ($self,$sock) = @_;
	$nextid++;
	$self->{users}{$sock}{sock} = $sock;
	$self->{users}{$sock}{host} = $sock->peerhost;
	$self->{users}{$sock}{id} = $nextid;
	$self->{users}{$sock}{buffer} = '';

	unless ($self->{quiet}){
		print "new connection: ";
		print $self->{users}{$sock}{id};
		print " (";
		print $self->{users}{$sock}{host};
		print ")\n";
	}

	$self->packet($sock, 'client_start', '');
}

sub endsession {
	my ($self,$sock) = @_;

	unless ($self->{quiet}){
		print "connection closed: ";
		print $self->{users}{$sock}{id};
		print "\n";
	}

	$self->packet($sock, 'client_stop', '');

	delete $self->{users}{$sock};
}

sub incoming{
	my ($self,$sock,$data) = @_;

	my $id = $self->{users}{$sock}{id};
	$self->{users}{$sock}{buffer} .= $data;

	my $ok = 1;
	my $buffer = $self->{users}{$sock}{buffer};
	while ($ok){
		$ok = 0;
		if (length($buffer) > 4){
			my $size = substr($buffer,0,4);
			$size =~ s/[^0-9]//g;
			$size += 0;
			if (length($buffer) >= 4 + $size){
				my $packet = substr($buffer,4,$size);
				my $a = index($packet,' ');
				my $msg = substr($packet,0,$a);
				my $param = substr($packet,$a+1);
				$self->packet($sock,$msg,$param);
				$buffer = substr($buffer,4+$size);
				$ok=1;
			}
		}
	}
	$self->{users}{$sock}{buffer} = $buffer;
}

sub packet {
	my ($self,$sock,$msg,$params) = @_;

	my $uid = $self->{users}{$sock}{id};

	unless($self->{quiet}){
		print "packet sent to $uid: $msg\n";
	}

	if ($self->{callbacks}{$msg}){
		&{$self->{callbacks}{$msg}}($uid,$msg,$params);
	}else{
		if ($self->{def_callback}){
			&{$self->{def_callback}}($uid,$msg,$params);
		}
	}
}


1;
__END__