#!/usr/bin/perl 

use Socket;
use Time::Local;
use Sys::Hostname;
use Time::HiRes qw(sleep);
use Unicode::String qw(latin1 utf8);
use LWP::Simple;
use IO::Handle;
use URI::URL;
use warnings;
use threads;
use Meteoalarm;



open(DATEI, "channels.txt");
$diachans = <DATEI>;
$diachans =~ s/##*/#/g;
@channels = split("  ",$diachans);

my $debug = 1;
my $master = 'majo';
my $master2 = 'Master';
my $master3 = 'thom';

my $schan="#sys-thx";
$uptimer=time();

my %conf;


$SIG{CHLD} = 'IGNORE';

my $hostname = Sys::Hostname::hostname();
my $nick = "ChannelWatcher";
my $pw = "27742774";

@joininfo=('ChannelWatcher - To Protect and Serve (c) 2017');
  

my ($remote, $local, $port, $iaddr, $paddr, $proto, $line, $myhost);
my $nl = "\015\012";


# You should specify a default server in $remote
$remote  = shift || '127.0.0.1';
$local   = "127.0.0.1";

$port    = shift || 6669;
my $uptimechan = shift || '#sys-thx';
my %chans;
$chans{lc $uptimechan} = 1;

if ($port =~ /\D/) { $port = getservbyname($port, 'tcp') }
die "No port" unless $port;
$iaddr   = inet_aton($remote)               || die "no host: $remote";
$paddr   = sockaddr_in($port, $iaddr);
$proto   = getprotobyname('tcp');

if (not $debug) {
    exit if fork();
}

close(STDIN) unless $debug;
close(STDOUT) unless $debug;


socket(IRC, PF_INET, SOCK_STREAM, $proto)  || die "socket: $!";
bind(IRC, sockaddr_in(0, inet_aton($local))) unless $local == undef;
connect(IRC, $paddr)    || die "connect: $!";
#IRC->autoflush(1);

{ my $ofh = select(IRC); $|=1; select($ofh); }

sub gracefully_die {
    my ($restarting) = @_;

        if ($restarting) {
            exec "perl sBot-restarter.pl";
        } else {
            exit;
        }
}

ircsend("NICK $nick");
ircsend("USER Cygnus ServerBot $hostname :ServerAdmin / ServerBot");

#handle the first ping.
#this one is really important to get right
#b/c it is used by the server to make sure you're
#not just spoofing (or using certain kinds of blind proxies)

while(my $line = <IRC>) {
       print " >> $line" if $debug;
        if($line =~ /^PING :(\S+)/ || $line =~ /^PING\s*(\S*)/ || $line =~ /^PING/ || $line=~ /^PING \:(.*)/) {
#       if($line =~ /^PING\s*(\S*)/i) {
                ircsend("PONG :$1");
        }
        # if server tells us we're logged in, break loop
        #els
if($line =~ /(376|422) $nick/) {
                last;
        }

}
ircsend("NickServ IDENTIFY");




#timer
do "timers.pl";



foreach(@channels){
my @channels=quotemeta($_);
$_=utf8($_)->latin1;
ircsend("JOIN $_");
privmsg($_, "@joininfo");
}


#start the pingtimer and
#set the handler for the
#alarm signal as the pingtimer

$SIG{ALRM} = \&pingtimer; # nee sigalrm
alarm 60;
irchandle();

#shouldn't ever get here, as irchandle becomes the main loop.
close(IRC);


sub ircsend {
        my $a = shift;
        $a=utf8($a)->latin1;
        print IRC $a, $nl;
        print " << ", $a, "\n" if $debug;
}

sub notice {
        my $user = shift;
        $x=utf8($x)->latin1;
        while(my $x=shift) {
        ircsend("NOTICE $user :$x");}
}

sub privmsg {
        my $user = shift;
        $x=utf8($x)->latin1;
        while(my $x=shift) {
        ircsend("PRIVMSG $user :$x");}
}

sub writeHash {
        my $hash = $_[0];
        my $file = $_[1];

        open HASH, ">$file";

        my @keys = keys(%$hash); my @values = values(%$hash);

        for(my $i=0; $i<@keys; $i++) {
                if($values[$i][0]) {
                        chomp $keys[$i];
                        print HASH $keys[$i], " =[ ";
                        foreach my $atom (@{$values[$i]}) {
                                print HASH $atom, ", ";
                        }
                        print HASH "\n";
                } else {
                        chomp $keys[$i]; chomp $values[$i];
                        print HASH $keys[$i], " = ", $values[$i], "\n";
                }
        }

        close HASH;
}

sub readHash {
        my $file = $_[0];
        my %hash;

        open HASH, $file;
        while(my $line = <HASH>) {
                if($line =~ / =\[ /) {
                        my ($key, $value) = split(/ =\[ /, $line);
                        chomp $key; chomp $value;
                        $hash{$key} = [ split(/, /, $value) ];
                } else {
                        my ($key, $value) = split(/ = /, $line);
                        chomp $key; chomp $value;
                        $hash{$key} = $value;
                }
        }
        close HASH;

        return (%hash);
}


sub auth($) {
        my ($in) = @_;
        #$in =~ /^:(.+?)\s/;
        #my $ident = $1;
        my @ident = split(/\!|\@/, $in);

        foreach my $x (@auth) {
                my @x = split(/\!|\@/, $x);
                my $ok = 1;

                for(my $i=0; $i<@x; $i++) {
                        if($x[$i] eq "*") {
                                next;
                        }

                        elsif($x[$i] =~ /^\*(.*)/) {
                                $ok=0 unless $ident[$i] =~ /$1$/i;
                        }

                        elsif($x[$i] =~ /(.*)\*$/) {
                                $ok=0 unless $ident[$i] =~ /^$1/i;
                        }

                        else {
                                $ok=0 unless lc $ident[$i] eq lc $x[$i];
                        }
                        last unless $ok;
                }

                return 1 if $ok == 1;
        }

        return 0;
}

 $start=time; #########################################


sub irchandle() {
my $in = shift;
LINE:   while(my $in = <IRC>) {
                chomp $in; $in =~ s/\r//g;

                print " >> $in\n" if $debug;

  if ($in =~ /^PING \:(.*)/ || $in =~ /^PING :/) {
    ircsend("PONG :$1");
    } 



                if($in =~ /^:(.*?)!.* NICK :(\S+)/) {
                        if($nick eq $1) {
                                $nick = $2;
                        }
                        next;
                }

                $myhost = $1 if($in =~ /^:(\S+) 001 \Q$nick\E/);

                if($in =~ /:(.*?)!.*(PRIVMSG|NOTICE) $nick\s*:\001(\S+) (.*?)\001?$/i) {
                        my ($user, $op, $msg) = ($1, $3, $4);

                        notice($conf{"Debugger"}, $user, $msg) if $conf{"Debug"};

                        next LINE;
                }

#diverse scripte
do "subs.pl";




#Lastseen saving

                if($in =~ /:(.*?)!.* JOIN \s*:(.*)/i or $in =~ /:(.*?)!.* PART \s*(.*)/i or $in =~ /:(.*?)!.* QUIT \s*(.*)/i or $in =~ /:(.*?)!.* KICK \s*(.*)/i) {
                        my ($juser, $jchan, $jmsg) = ($1, $2, $3);

($host,$statein,$bchan)=split(/ /,$in);

lastseenup("$juser/$jchan/$statein/$host"); 
}






#(#\S+)\s* channel
#(.*) oder \s*(.*) user

if($in =~ /:(.*?)!.*MODE (#\S+)\s* -o (.*)/i) {
my ($user, $chan, $msg, $vict) = ($1, $2, $3, $4); #vict übergabe an script
do "reopscript.pl";
}



if($in =~ /:(.*?)!.* JOIN \s*:(.*)/i) {
do "userstate.pl";
}


#if($in =~ /311 $nick \s*(.*) (.*) (.*) :(.*)/i) {
#               my ($user, $msg, $vict, $reln) = ($1, $2, $3, $4); #vict übergabe an script
#privmsg($schan, "[WhoisScript] >> Host $msg $vict");
#       }

if($in =~ /319 $nick \s*(.*) (.*)/i) {
        my ($user, $chan, $msg, $vict) = ($1, $2, $3, $4); #vict übergabe an script
privmsg($lastchan, "[WhoisScript] >> Channels $user");
        }
#if($in =~ /312 $nick \s*(.*) (.*)/i) { save wegen zeichen
if($in =~ /307 $nick \s*(.*) :(.*)/i) {
        my ($user, $vict) = ($1, $2, $3, $4); #vict übergabe an script
$vict =~ s/is a registered nick/Yes/;
privmsg($lastchan, "[WhoisScript] >> Registered? $vict");
        }
if($in =~ /378 $nick \s*(.*) :(.*)/i) {
        my ($user, $vict) = ($1, $2, $3, $4); #vict übergabe an script
($host,$statein,$bchan,$hos,$rip)=split(/ /,$vict);
privmsg($lastchan, "[WhoisScript] >> Host $host $statein $bchan $hos");
privmsg($lastchan, "[WhoisScript] >> IP $rip");
        }

if($in =~ /353 $nick = (#\S+)\s* :(.*)/i) {
        my ($user, $vict) = ($1, $2, $3, $4); #vict übergabe an script
if ($lastchan eq ""){
privmsg($schan, "[InfoScript] >> Channel: $user");
privmsg($schan, "[InfoScript] >> Users: $vict");
}else{
privmsg($lastchan, "[InfoScript] >> Channel: $user");
privmsg($lastchan, "[InfoScript] >> Users: $vict");
}}



if($in =~ /:(.*?)!.* KICK (#\S+)\s*:(.*)/i) {
my ($user, $chan, $msg) = ($1, $2, $3);
privmsg($chan, "1.kick");
$kickcount=0;
push(@kicked,$jldat[2]);
foreach $_ (@kicked){
#if (lc($_) eq lc(@jldat[2])){
if (lc($_) eq lc($jldat[2])){
$kickcount++;
privmsg($chan, "2.kick");
}}
if ($kickcount == 3){
privmsg($chan, "Floodversuch erkannt! 3x gekickt nun Ban!");
ircsend("KICK $chan $_");
foreach $_ (@kicked){
#if (lc($_) ne lc(@jldat[2])){
if (lc($_) ne lc($jldat[2])){
push(@newkicked,$_);
}}
@kicked=@newkicked;
@newkicked=();
}}

###badworderkennung



######################################################DIA########################################################################################
##############################################################################################################################################

$tes = '#sys-thx';


if($in =~ /:(.*?)!.*PRIVMSG $nick :(.*)/i) {
$dia = 1;
my ($diauser, $diatext, $msg) = ($1, $2, $3);
if ($dia == 1){
                                privmsg($tes, "(DiaScript) >> ($diauser): $diatext ");
}
}



######################################################DIA ENDE########################################################################################
##############################################################################################################################################


if($in =~ /:(.*?)!.*PRIVMSG (#\S+)\s*:(.*)/i) {
my ($user, $chan, $msg) = ($1, $2, $3);
do "badwordscript.pl";
do "floodproscript.pl";
}



                if($in =~ /:(.*?)!.*PRIVMSG (#\S+)\s*:(.*)/i) {
                        my ($user, $chan, $msg) = ($1, $2, $3);
                        #print "$user, $chan, $msg";




#uscom
do 'uscom.pl';

#zugangskontrolle
do "zugangskontrolle.pl";

#datenbanken
do "datenbanken.pl";

#switches
do "switches.pl";

#newsletter
#do "newsle.pl";

#versuchsscript
#do "versuch.pl";

#normale channelcommands
do "chacom.pl";

#wetterscript
do "wetter.pl";

#load telegram modul
do "telegr.pl";






####Master-Admin-Befehle

if(lc($user) eq lc($master) || lc($user) eq lc($master2)){

if (lc(substr($msg,0,6)) eq "!close" || lc(substr($msg,0,9)) eq "!shutdown" || lc(substr($msg,0,5)) eq "!kill" || lc(substr($msg,0,5)) eq "!quit"){
privmsg($chan, "(ShutDown-System) (Beende alle verbindungen...)");
die "closed by $user";
}


if (lc(substr($msg,0,8)) eq "!restart" || lc(substr($msg,0,7)) eq "!reboot"){
privmsg($chan, "(Shutdown-System) (Bot startet neu!)");
sleep(1);
privmsg($chan, "(Shutdown-System) (Beende alle aktiven Module...)");
do "sBot-restarter.pl";
die "closed by master";
}




}#ende master








                        if(($msg =~ /^lusers/i) or ($msg =~ /^!lusers/i)) {
                                my $users = qx/users/; 
                                $users =~ s/\n//;
                                $users = join(' ', unique(split(/ /, $users)));
                                privmsg($chan, "Users logged onto $hostname: ".$users);
                                next;
                        }

                }


                
#               if($in =~ /:$myhost .*(PRIVMSG|NOTICE) $nick\s*:(.*)/i) {
                if($in =~ /:$remote .*(PRIVMSG|NOTICE) $nick\s*:(.*)/i) {
                        my $msg = $2;

                }
        }

        gracefully_die(1);
}


sub writeArray {
        my $array = $_[0];
        my $file = $_[1];

        open ARRAY, ">$file";

        foreach my $x (@$array) {
                print ARRAY $x . "\n";
        }

        close ARRAY;
}

sub readArray {
        my $file = $_[0];
        my @array;

        open ARRAY, $file;

        while(my $x = <ARRAY>) {
                chomp $x;
                push @array, $x;
        }

        close ARRAY;

        return (@array);
}

sub pingtimer { # nee sigalrm
        ircsend("PING :$remote");
        alarm 60;
}

#we don't actually call this from anywhere
#but the SCnet implementation seems to need
#it to handle when the socket is closed on us
#due to a kill.
sub sigpipe {
        graceful_die(1); #if $child;
}

sub unique(@) {
        my (@input_array) = @_;
        my %seen;
        foreach my $item (@input_array) {
                $seen{$item}++;
        }
        #return sort(keys(%seen));
        return map("$_($seen{$_})", sort(keys(%seen)));
}

undef $alv;
undef $propthread;

#!/usr/bin/perl -w

use LWP::Simple;
use threads;



my ($user, $chan, $msg) = ($1, $2, $3);
#my $master = 'majo';
#my $master2 = 'Master';
#my $master3 = 'thom';
#my $time = localtime(time());
#my $clock1 = '';

my $pchan = "#sys-thx";

#my ($wtag,$monat,$tag,$alive,$jeahr)=split(/ /,$time);




my $alv = threads->create(sub { &alive;});
my $propthread = threads->create(sub { &propaganda;});
my $aktthread = threads->create(sub { &akt;});



sub akt{

$alv=fork();
while ($alv==0){
sleep 1;
if ($end > 2 *60){
foreach(@werb){
my @werb=quotemeta($_);
($delopch,$wer)=split(":",$_);
}
if ($wer eq "status"){
curtime();
privmsg($delopch, "virtuelle hilfskraft meldet: es ist $curt am $curd!");
}
if ($wer eq "on"){
@tiscr = ('ich bin eure persönliche assistentin für den chat!', 'meine befehle kannst du unter !hilfe abrufen', 'party leute, party!!!!!');
privmsg($_, "$tiscr[rand @tiscr]");
}
if ($wer eq "off"){
$alti=localtime();
print "-= ChannelWatcher ControlSystem - All systems working fine! $alti =-\n";
}
$end=0;
}
$end++;
}
}


sub alive(){
ret:
sleep (10 *60);
privmsg($pchan, "Alive Massage");
sleep(1);
goto ret;
}


sub propaganda(){
red:
sleep (39 *60);
foreach(@channels){
my @channels=quotemeta($_);
privmsg($_, "ChannelWatcher v3 out now! The new generation Channel-Control-Bot. For more Informations, contact the Projekt Manager 'majo' on channel '#sys-thx'!");
}
sleep(1);
goto red;
}



#privmsg($pchan, "Info: WerbeTest1");
##$alti=localtime();
##print "-= Sending Alive... - $alti =-\n";
#goto ret;