view release on metacpan or  search on metacpan

Daemon.pm  view on Meta::CPAN

package Audio::Daemon;

use IO::Socket::INET;
use IO::Select;
use vars qw($VERSION);
$VERSION='0.99Beta';

sub new {
  my ($proto, %arg)  = @_;
  my $class = ref($proto) || $proto;
  my $self = {};
  foreach my $k (qw/Allow Deny Server Port Log Pass/) {
    $self->{$k} = $arg{$k} if (defined $arg{$k});
  }
  # if you feel like changing the main seperator value:
  $self->{sep} = sprintf("%c", 255);
  # or changing the secondary seperator value:
  $self->{subsep} = sprintf("%c", 254);
  bless($self, $class);
  $self->parse_acl('Allow') if ($self->{Allow});
  $self->parse_acl('Deny') if ($self->{Deny});
  return $self;
}

sub debug { my $self = shift; return $self->log('debug', @_); }
sub info { my $self = shift; return $self->log('info', @_); }
sub error { my $self = shift; return $self->log('error', @_); }
sub crit { my $self = shift; return $self->log('crit', @_); }
sub warn { my $self = shift; return $self->log('warn', @_); }

sub log {
  my $self = shift;
  my @caller = caller(2);
  # print "caller line is ".$caller[2]."\n";
  # ($package, $filename, $line, $subroutine, $hasargs,
  #  $wantarray, $evaltext, $is_require, $hints, $bitmask)
  if (defined $self->{Log}) {
    &{$self->{Log}}(@_, @caller);
    return 1;
  } else {
    return 0;
  }
}

sub socket {
  my $self = shift;
  if (ref $self->{socket} eq 'IO::Socket::INET') {
    $self->debug('caller requested existing socket');
    return $self->{socket} 
  }
  my $package = (split '::', (ref $self))[-1];
  if ($package ne 'Client') {
    if (! defined $self->{Port}) {
      $self->crit("No Port defined for socket creation");
      return;
    }
    $self->{socket} = IO::Socket::INET->new(LocalPort => $self->{Port}, Proto=>'udp');
  } else {
    if (! defined $self->{Port} || ! defined $self->{Server}) {
      $self->crit("Need both the Port and Server defined for socket creation");
      return;
    }
    $self->{socket} = IO::Socket::INET->new(PeerPort => $self->{Port}, PeerAddr => $self->{Server}, Proto=>'udp');
  }
  if (! defined $self->{socket}) {
    $self->crit("Failed to initialize Socket: $!");
    return;
  }
  return $self->{socket};
}

# randomze takes in an array reference and returns an array of randomzied indixes
sub randomize {
  my $self = shift;
  my $start = shift;
  return unless (ref $start eq 'ARRAY');
  my @stack;
  my $count = 0;
  while (scalar @$start) {
    my $pick = int (rand() * (scalar @$start));
    push @stack, $start->[$pick];
    splice(@{$start}, $pick, 1);
  }
  $self->{random} = \@stack;
  my @revstack;
  foreach my $t (0..$#stack) {
    $revstack[$stack[$t]] = $t
  }
  $self->{revrandom} = \@revstack;
}

# Generic read routine, should return a hash ref of values read from client.
# will return undef if request comes from unallowed IP.