#!/usr/bin/perl -w

# SYSTEMINFO script for xchat, by scoobs
# place this file into ~/.xchat/ dir so it can be automaticly loaded
# This program is free software, you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation.
# there is a bug with kernel 2.4.20 and greater with the disk size, if someone
# could fix this i would be very happy.
# 
#
#
#Commands /about /gfx /sound /mb /ker /cpu /ram /disk /net /temp /sys
#
#
#
#
#
#
#
#
#


IRC::register("SystemInfo", "1.3", "", "");
IRC::print "SYSTEMINFO loaded.... Commands /about /gfx /sound /mb /ker /cpu /ram /disk /net /temp /sys";
IRC::add_command_handler("about", "about");
IRC::add_command_handler("gfx", "gfx");
IRC::add_command_handler("sound", "sound");
IRC::add_command_handler("mb", "mb");
IRC::add_command_handler("ker", "ker");
IRC::add_command_handler("cpu", "cpu");
IRC::add_command_handler("ram", "ram");
IRC::add_command_handler("disk", "disk");
IRC::add_command_handler("net", "net");
IRC::add_command_handler("temp", "temp");
IRC::add_command_handler("sys", "sys");

$dev = eth0; #<-- Change that :)

sub about {

IRC::command("SYSTEMINFO - designed for XChat - by scoobs - version 1.3");
return 1;
}

sub gfx {

     $depths = `xdpyinfo | grep depths | awk '{print \$3 \$4 \$5 \$6 \$7 \$8 \$9}'`;
     chop ($bits);

     $xfree86 = `xdpyinfo | grep XFree86"."version | awk '{print \$3}'`;
     chop ($xfree86);

     $res = `xdpyinfo | grep dimensions | awk '{print \$2}'`;
     chop ($res);

     @vid = `cat /proc/pci`;
     foreach (@vid) {
     if (/VGA compatible controller: (.+).$/i) {$vidcard = $1;last;}

     @bits = `xwininfo -root`;
     foreach (@bits) {
     if (/^ +?Depth: (.+)/i) {$bits = $1;}
}
}
IRC::command("(Graphics):[$vidcard] (XFree86):[$xfree86] (Res):[$res] (Bits):[$bits]");
return 1;
}

sub ker {

    $ker =`uname -srm`;
    chop ($ker);



IRC::command("(Kernel):[$ker]");
return 1;
}

sub cpu {

    $model = `cat /proc/cpuinfo | grep 'model name' | head -1 | sed -e 's/^.*: //'`;
    chop ($model);

    $freq = `cat /proc/cpuinfo | grep 'cpu MHz' | head -1 | sed -e 's/^.*: //'`;
    chop ($freq);

    $cache = `cat /proc/cpuinfo | grep 'cache size' | head -1 | sed -e 's/^.*: //'`;
    chop ($cache);

    $bogomips = `cat /proc/cpuinfo | grep 'bogomips' | head -1 | sed -e 's/^.*: //'`;
    chop ($bogomips);



IRC::command("(CPU): $model: (Frequency): $freq"."MHz: (Cache): $cache: (Bogomips): $bogomips");
return 1;
}

sub sound {

     @snd = `cat /proc/pci`;
     foreach (@snd) {
     if (/Multimedia audio controller: (.+).$/i) {$sndcard = $1;first;}
     if (/Input device controller: (.+).$/i) {$inpdev = $1;last;}
}
IRC::command("(SoundCard):[$sndcard] (Input Device Controller):[$inpdev]");
return 1;
}


sub mb {

     @mb = `cat /proc/pci`;
     foreach (@mb) {
     if (/ISA bridge: (.+).$/i) {$isabrg = $1;last;}
}
IRC::command("$isabrg");
return 1;
}

sub disk {

    @ide = `cat /proc/pci`;
    foreach (@ide) {
    if (/IDE interface: (.+).$/i) {$ideinf = $1;last;}
}

IRC::command("(IDE Interfaces):[$ideinf]");
return 1;
}

sub net {

    if($dev =~ /^ppp/i) {
       $devtype=`cat /proc/pci | grep 'Communication controller:' | cut -d" " -f7-`;
    } else {
       $devtype=`cat /proc/pci | grep "IRQ \`/sbin/ifconfig $dev | grep Interrupt | cut -d":" -f2 | cut -d" " -f1\`" -B1 | grep Ethernet | cut -d":" -f2- | cut -d" " -f2-`;
    };
    chop($devtype);
    if ($devtype =~ /^$/) {
        $devtype="Unknown";
    };

    $packin = `cat /proc/net/dev | grep $dev | awk -F: '/:/ {print \$2}' | awk '{printf \$1}'`;
    if($packin < 1024**3) { $packin = sprintf("%.02f",$packin / 1024**2)."M"; } else { $packin = sprintf("%.02f", $packin / 1024**3)."G"; }

    $packout = `cat /proc/net/dev | grep $dev | awk -F: '/:/ {print \$2}' | awk '{print \$9}'`;
    if($packout < 1024**3) { $packout = sprintf("%.02f",$packout / 1024**2)."M"; } else { $packout = sprintf("%.02f", $packout / 1024**3)."G"; }


IRC::command("(Network):[Device:$devtype In:$packin Out:$packout]");
return 1;
}

sub temp {

    $sens1 = `sensors -f | grep SYS | awk '{print \$1, \$2, \$3}'`;
    chop ($sens1);

    $sens2 = `sensors -f | grep CPU Temp | awk '{print \$1, \$2, \$3}'`;
    chop ($sens2);

IRC::command("(Temperature):[System $sens1 CPU $sens2]");
return 1;
}

sub sys {

    $ker = `uname -srm`;
    chop ($ker);

    $vendor = `cat /proc/cpuinfo | grep 'vendor_id' | head -1 | sed -e 's/^.*: //'`;
    chop ($vendor);

    $model = `cat /proc/cpuinfo | grep 'model name' | head -1 | sed -e 's/^.*: //'`;
    chop ($model);

    $freq = `cat /proc/cpuinfo | grep 'cpu MHz' | head -1 | sed -e 's/^.*: //'`;
    chop ($freq);

    $cache = `cat /proc/cpuinfo | grep 'cache size' | head -1 | sed -e 's/^.*: //'`;
    chop ($cache);

    $bogomips = `cat /proc/cpuinfo | grep 'bogomips' | head -1  | sed -e 's/^.*: //'`;
    chop ($bogomips);

    $count = `cat /proc/cpuinfo | grep 'model name' | wc -l | sed 's/ *//'`;
    chop ($count);

    $f00f = `cat /proc/cpuinfo | grep 'f00f_bug' | head -1 | sed -e 's/^.*: //'`;
    chop ($f00f);

    $fdiv = `cat /proc/cpuinfo | grep 'fdiv_bug' | head -1 | sed -e 's/^.*: //'`;
    chop ($fdiv);

    $hlt = `cat /proc/cpuinfo | grep 'hlt_bug' | head -1 | sed -e 's/^.*: //'`;
    chop ($hlt);

    $coma = `cat /proc/cpuinfo | grep 'coma_bug' | head -1 | sed -e 's/^.*: //'`;
    chop ($coma);

    $flags = `cat /proc/cpuinfo | grep 'flags' | head -1 | sed -e 's/^.*: //'`;
    chop ($flags);

    $procs = `ps ax | wc -l | awk '{print \$1 - 5}'`;
    chop ($procs);

    $mem = `free -m`;
    foreach ($mem) {
    /mem.+?[ ]+([\d\.]+)[ ]+([\d\.]+)/i;
    $memtotal = $1;
    $memused = $2;

    $MEMTOTAL = `free | grep Mem | awk '{printf (\"%dMb\", \$2/1000 )}'`;
    chop ($MEMTOTAL);
    
   
    $MEMPERCENT = `free | grep Mem | awk '{print (( \$3 -(\$6 + \$7) )/\$2)*100}'`;
    chop ($MEMPERCENT);
    
    
    $MEMFREE = `free | grep Mem | awk '{printf (\"%.0fg\", ( \$3 -(\$6 + \$7) )/1000)}'`;
    chop ($MEMFREE);
    
    
    $FREEBAR = int($MEMPERCENT/10);
    $MEMBAR = "%C14[%C4";
    for ( $x = 0; $x < 10; $x++ )
    {
        if ( $x eq $FREEBAR )
                {
                $MEMBAR = "$MEMBAR%C3";
                }
        $MEMBAR = "$MEMBAR\|";
    }
    $MEMBAR = "$MEMBAR%C14]%C";

}

    $up = `uptime`;
    foreach ($up) {
    /.*?up *(.*),.*?users?.*?load average: ([\d\.]+).*/i;
    $up = $1;
    $load = $2;
}

IRC::command("(Kernel):[$ker] (Uptime):[$up] (Load):[$load] (CPUCount):[$count] (Model):[$model] (Clock):[$freq"."MHz] (Cache):[$cache] (Bogomips):[$bogomips] (Mem):[$MEMFREE/$MEMTOTAL $MEMBAR] (Total Space):[$disksize"."] (Processes):[$procs]");
return 1;
}

sub ram {

    $MEMTOTAL = `free | grep Mem | awk '{printf (\"Mb\", \$2/1000 )}'`;
    chop ($MEMTOTAL);
    
   
    $MEMPERCENT = `free | grep Mem | awk '{print (( \$3 -(\$6 + \$7) )/\$2)*100}'`;
    chop ($MEMPERCENT);
    
    
    $MEMFREE = `free | grep Mem | awk '{printf (\"%.0fg\", ( \$3 -(\$6 + \$7) )/1000)}'`;
    chop ($MEMFREE);
    
    
    $FREEBAR = int($MEMPERCENT/10);
    $MEMBAR = "[";
    for ( $x = 0; $x < 10; $x++ )
    {
        if ( $x eq $FREEBAR )
                {
                $MEMBAR = "$MEMBAR%C3";
                }
        $MEMBAR = "$MEMBAR\|";
    }
    $MEMBAR = "$MEMBAR%C14]%C";

IRC::command("(Mem):[$MEMFREE/$MEMTOTAL $MEMBAR]");
return 1;
}

sub byte_converter {

    $line = shift(@_);
    $totalmegsize2 = $line;
    if ($totalmegsize2 > 1000000000000000000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000000000000000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"." Yottabytes";
}   elsif ($totalmegsize2 > 1000000000000000000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000000000000000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"." Zettabytes";
}   elsif ($totalmegsize2 > 1000000000000000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000000000000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"." Exabytes";
}   elsif ($totalmegsize2 > 1000000000000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000000000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"." Petabytes";
}   elsif ($totalmegsize2 > 1000000000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"."Terabytes";
}   elsif ($totalmegsize2 > 1000000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"."G";
}   elsif ($totalmegsize2 > 1000000) {
    $totalmegsize2 = $totalmegsize2 / 1000000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"."M";
}   elsif ($totalmegsize2 > 1000) {
    $totalmegsize2 = $totalmegsize2 / 1000;
    $totalmegsize2 =~ /(.*)\.(.*)/;
    $begin = $1;
    $end = (substr ($2, 0, 1));
    $totalmegsize2 = "$begin.$end"."k";
}   else {
    $totalmegsize2 = $totalmegsize2."b";
}
    return $totalmegsize2;
}

    @disks = `cat /proc/partitions`;
    $disksize = 0;

    foreach (@disks) {
    if (/^\D+\d+\D+0\D+(\d+)/i) {$disksize = $disksize + $1;}
}
    $disksize = $disksize * 1000;
    $disksize = byte_converter($disksize);

    @disks = `cat /proc/ide/ide*/hd*/m*`;
    $i = 0;
    $diskfound = "";
    foreach $er (@disks) {
    chomp $er;
    if ($i == 1) {$diskfound = "$diskfound:$er "};
    if ($i == 0) {$diskfound = "$diskfound$er"};
    $i++;if ($i > 1) {$i = 0;}
}
    chop $diskfound;