bitjoe - Contrib - SOURCE CODE

#!/usr/bin/perl	-I/root/.mutella/MutellaProxy

use MutellaProxy::Mutella;
MutellaProxy::Mutella->GetAndInstallUltraPeerHostList();

#!/usr/bin/perl	-I/root/.mutella/MutellaProxy

use MutellaProxy::Mutella;

MutellaProxy::Mutella->GetAndInstallUltraPeerHostList();

#!/usr/bin/perl	-I/root/.mutella/MutellaProxy

#########################################
##### Author:		Sebastian Enger / B.Sc
##### CopyRight:	BitJoe GmbH
##### LastModified	27.07.2006
##### Function:		Parsing von Daten
##### Todo:			
########################################

use MutellaProxy::Parser;
use MutellaProxy::IO;

my $MutellaSocket = MutellaProxy::IO->CreateMutellaSocket();
MutellaProxy::Parser->CheckSharingRatio($MutellaSocket);

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

use MutellaProxy::CryptoLibrary;

my $ct = MutellaProxy::CryptoLibrary->Encrypt( "a9e83ef0f3161057a5d3fe40a09e9cbf", "TESTT" );
my $plain = MutellaProxy::CryptoLibrary->Decrypt( "a9e83ef0f3161057a5d3fe40a09e9cbf", $ct );

print "PLAIN: '$plain' \n";

#!/usr/bin/perl	-I/root/.mutella/MutellaProxy

use MutellaProxy::Time;

my $DATE = MutellaProxy::Time->GetValid8DayDateForLicence();

print "$DATE\n";

#!/usr/bin/perl	-I/root/.mutella/MutellaProxy

use MutellaProxy::ResultCleaner;

MutellaProxy::ResultCleaner->DeleteOldEntries();

#!/usr/bin/perl

my $finalString;

open(RH,"<$ARGV[0]");
open(WH,">out.txt");
while( <RH>){
	my $line = $_;
	chomp($line);
	$finalString .= '"' . $line . '",'
};
print WH $finalString;
close WH;
close RH;

my %ConfigHash =(
	"1"	=> my $CfG1 = { 
			"HOST"	=> "HOSTIP",
			"USER"	=> "USERNAME",
			"PASS"	=> "PASSWORD"
			},
	"2"	=> my $CfG2 = { 
			"HOST"	=> "HOSTIP",
			"USER"	=> "USERNAME",
			"PASS"	=> "PASSWORD"
			}, 
	);


while ( my ($key, $value) = each(%ConfigHash) ) {
#		my $RemoteUserName	= %ConfigHash->{  }
#		my $RemotePassword
#		my $RemoteHostname
#		my $RemoteStorePath
		print $value->{'USER'} . "\n" ;
};

@array = (1..8100000);

my $start = time();

for ($i=0;$i<=$#array; $i++) {

	my $a = rand(1);
	
	if ( $a == $array[$i] ) {
	} else {
	};

};

my $end = time();

print "Start-FOR: ";
print scalar( localtime($start) );

print " \nEnd: ";
print scalar( localtime($end) );


exit;


foreach (0..8100000) {

	my $a = rand(1);
	my $b = rand(1);

	if ( $a == $b ) {
	} else {
	};

};

my $end = time();

print "\nStart-FOREACH: ";
print scalar( localtime($start) );

print " \n End: ";
print scalar( localtime($end) );

use LWP::Simple;

my $doc = get("http://www.heise.de");

my @content = split(' ', $doc );
my $lineContent;

foreach my $line ( @content ) {
	next if ( $line !~ /\w/ );
	next if ( $line =~ /\"/ );
	$lineContent .= '"' . $line . '",';
};

print $lineContent;

#!/usr/bin/perl -w


use MIME::Lite; #  perl -MCPAN -e 'install "MIME::Lite"'
#
# Variablendefinition
my $to		 = 'thecerial@gmail.com';
my $from     = 'root@zoozle.net';
my $name     = 'Basti';
my $vorname  = 'BigBoss';
my $subject  = 'TestNachricht';
my $body     = 'Dies ist eine Testmail.und zwar die 2. version';


 ### Create a new single-part message, to send a GIF file:
    $msg = MIME::Lite->new(
                 From     => $from,
                 To       => $to,
                # Cc       => 'torsten.morgenroth@gmail.com',
                 Subject  => $subject,
                 Type     => 'text/plain',
				 Data     => $body,
                # Encoding =>'base64',
                # Path     =>'hellonurse.gif'
                 );
 $msg->send;
 system("/usr/sbin/postfix flush");

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

##########################################################
# tod: client has requested: eventuell rauslassen, wenn ResultCleaner.pm funzt
##########################################################

use strict;

# fr den server
use IO::Socket;
use IO::File;
use IO::Select;
use Net::hostent;

# fr die parameter
use Getopt::Std;

# debug
use Data::Dumper;

# mutella
use MutellaProxy::IO;
use MutellaProxy::Parser;
use MutellaProxy::Daemon;
use MutellaProxy::Mutella;
use MutellaProxy::Logging;
use MutellaProxy::Mutella;
use MutellaProxy::SortRank;
use MutellaProxy::ResultCache;
use MutellaProxy::ResultCleaner;
use MutellaProxy::LicenceManagement;
			
# md5
# later: use MutellaProxy::MD5->new()
# use Digest::MD5 qw(md5 md5_hex md5_base64);
use Digest::MD5 qw( md5_hex );
use constant CRLF => "\r\n";

##########################################################

my $IO				= MutellaProxy::IO->new();
my $PARSER			= MutellaProxy::Parser->new();
my $LOGGING			= MutellaProxy::Logging->new();
my $MUTELLA			= MutellaProxy::Mutella->new();
my $SORTRANK		= MutellaProxy::SortRank->new();
my $CACHE			= MutellaProxy::ResultCache->new();
my $CLEANER			= MutellaProxy::ResultCleaner->new();
my $LICENCE			= MutellaProxy::LicenceManagement->new();

##############

... [truncated, 396 more lines] ...

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

system("clear");

use strict;

# fr den server
use IO::Socket;
use IO::File;
use IO::Select;
use Net::hostent;

# debug
use Data::Dumper;

# mutella
use MutellaProxy::IO;
use MutellaProxy::Parser;
use MutellaProxy::Daemon;
use MutellaProxy::Mutella;
use MutellaProxy::Logging;
use MutellaProxy::Mutella;
use MutellaProxy::SortRank;
use MutellaProxy::CheckSum;
use MutellaProxy::ResultCache;
use MutellaProxy::ResultCleaner;
use MutellaProxy::LicenceManagement;

use constant CRLF => "\r\n";

##########################################################

my $IO				= MutellaProxy::IO->new();
my $PARSER			= MutellaProxy::Parser->new();
my $LOGGING			= MutellaProxy::Logging->new();
my $MUTELLA			= MutellaProxy::Mutella->new();
my $SORTRANK		= MutellaProxy::SortRank->new();
my $CHECKSUM		= MutellaProxy::CheckSum->new();
my $CACHE			= MutellaProxy::ResultCache->new();
my $CLEANER			= MutellaProxy::ResultCleaner->new();
my $LICENCE			= MutellaProxy::LicenceManagement->new();

##############
my $MutellaSocket	= MutellaProxy::IO->CreateMutellaSocket();
my $ProxySocket		= MutellaProxy::IO->CreateProxySocket();
my $FILE			= '/root/.mutella/IDS';
my $NUMBEROFRESULTS	= 10;
##############

my $listHashRef = {};

... [truncated, 382 more lines] ...

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

#########################################
##### Author:		Sebastian Enger / B.Sc
##### CopyRight:	BitJoe GmbH
##### LastModified	12.07.2006
##### Function:		Hauptdatei fr MutellaProxy
##### Todo:			for statt foreach: ist schneller
########################################

system("clear");

# todo: connection counter - nach 5 mal keine ergebnisse bemhe den result cache
# connection request daten abholen: 20s, 10s, 10s, 7s, 5s, public result cache

my $VERSION = '0.18.1';

use strict;

# fr den server
use IO::Socket;
# use IO::File;
use IO::Select;
use Net::hostent;

# debug
use Data::Dumper;

# mutella
use MutellaProxy::IO;
use MutellaProxy::Debug;
use MutellaProxy::Status;
use MutellaProxy::Parser;
use MutellaProxy::Daemon;
use MutellaProxy::Mutella;
use MutellaProxy::Logging;
use MutellaProxy::Mutella;
use MutellaProxy::IPFilter;
use MutellaProxy::SortRank;
use MutellaProxy::CheckSum;
use MutellaProxy::IOTransfer;
use MutellaProxy::ResultCache;
use MutellaProxy::ResultCleaner;
use MutellaProxy::LicenceManagement;

use constant CRLF => "\r\n";

# gib aus debug
# print $DEBUG->Debugging( $RefObj, $VarToDump, $ManualEditedText ,'SCREEN');


... [truncated, 472 more lines] ...

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

#########################################
##### Author:		Sebastian Enger / B.Sc
##### CopyRight:	BitJoe GmbH
##### LastModified	13.07.2006
##### Function:		Hauptdatei fr MutellaProxy
##### Todo:			for statt foreach: ist schneller
##### MileStones:	IPBlocker.pm->IPBlocker() funktioniert
#####				Status.pm->readStatus() funktioniert
#####				SortRank.pm->SortRank() funktioniert
########################################



system("clear");

# todo: connection counter - nach 5 mal keine ergebnisse bemhe den result cache
# connection request daten abholen: 20s, 10s, 10s, 7s, 5s, public result cache
# IOTransfer.pm funzt noch nicht

my $VERSION = '0.18.1';

use strict;

# fr den server
use IO::Socket;
# use IO::File;
use IO::Select;
use Net::hostent;

# mutella
use MutellaProxy::IO;
use MutellaProxy::Debug;
use MutellaProxy::Status;
use MutellaProxy::Parser;
use MutellaProxy::Daemon;
use MutellaProxy::Mutella;
use MutellaProxy::Logging;
use MutellaProxy::Mutella;
use MutellaProxy::IPFilter;
use MutellaProxy::SortRank;
use MutellaProxy::CheckSum;
use MutellaProxy::ResultCache;
use MutellaProxy::CryptoLibrary;
use MutellaProxy::ResultCleaner;
use MutellaProxy::LicenceManagement;

use constant CRLF => "\r\n";


... [truncated, 470 more lines] ...

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

#########################################
##### Author:		Sebastian Enger / B.Sc
##### CopyRight:	BitJoe GmbH
##### LastModified	13.07.2006
##### Function:		Hauptdatei fr MutellaProxy
##### Todo:			for statt foreach: ist schneller
##### MileStones:	IPBlocker.pm->IPBlocker() funktioniert
#####				Status.pm->readStatus() funktioniert
#####				SortRank.pm->SortRank() funktioniert
########################################

# perl -MCPAN -e 'install "WWW::Mechanizer"' 

system("clear");

# todo: connection counter - nach 5 mal keine ergebnisse bemhe den result cache
# connection request daten abholen: 20s, 10s, 10s, 7s, 5s, public result cache

my $VERSION = '0.20.1';

use strict;

# fr den server
use IO::Socket;
# use IO::File;
use IO::Select;
use Net::hostent;

# mutella
use MutellaProxy::IO;
use MutellaProxy::Time;
use MutellaProxy::Debug;
use MutellaProxy::Status;
use MutellaProxy::Parser;
use MutellaProxy::Daemon;
use MutellaProxy::Mutella;
use MutellaProxy::Logging;
use MutellaProxy::Mutella;
use MutellaProxy::IPFilter;
use MutellaProxy::SortRank;
use MutellaProxy::CheckSum;
use MutellaProxy::ResultCache;
use MutellaProxy::CryptoLibrary;
use MutellaProxy::ResultCleaner;
use MutellaProxy::LicenceManagement;

use constant CRLF => "\r\n";
use constant PIDFILE => "/root/.mutella/PID.file";

... [truncated, 485 more lines] ...

#!/usr/bin/perl -I/root/.mutella/MutellaProxy

#########################################
##### Author:		Sebastian Enger / B.Sc
##### CopyRight:	BitJoe GmbH
##### LastModified	13.07.2006
##### Function:		Hauptdatei fr MutellaProxy
##### Todo:			for statt foreach: ist schneller
##### MileStones:	IPBlocker.pm->IPBlocker() funktioniert
#####				Status.pm->readStatus() funktioniert
#####				SortRank.pm->SortRank() funktioniert
########################################



system("clear");

# todo: connection counter - nach 5 mal keine ergebnisse bemhe den result cache
# connection request daten abholen: 20s, 10s, 10s, 7s, 5s, public result cache

my $VERSION = '0.18.1';

use strict;

# fr den server
use IO::Socket;
# use IO::File;
use IO::Select;
use Net::hostent;

# mutella
use MutellaProxy::IO;
use MutellaProxy::Debug;
use MutellaProxy::Status;
use MutellaProxy::Parser;
use MutellaProxy::Daemon;
use MutellaProxy::Mutella;
use MutellaProxy::Logging;
use MutellaProxy::Mutella;
use MutellaProxy::IPFilter;
use MutellaProxy::SortRank;
use MutellaProxy::CheckSum;
use MutellaProxy::ResultCache;
use MutellaProxy::CryptoLibrary;
use MutellaProxy::ResultCleaner;
use MutellaProxy::LicenceManagement;

use constant CRLF => "\r\n";

# gib aus debug

... [truncated, 477 more lines] ...

#!/usr/bin/perl

use Net::SCP::Expect;


my $scpe = Net::SCP::Expect->new(host=>'85.214.59.105', user=>'root', password=>'PQdfqZHr');
$scpe->auto_yes(1);
$scpe->scp('/root/.mutella/MutellaProxy_V0.1.9.pl','root@85.214.59.105:/root/');

use LWP::Simple;

_GetExtractStore();

sub _GetExtractStore(){
		
		my $url		= shift || "http://gwc2.nonexiste.net:8080/";
		
		my $doc		= get($url);
		my @content = split(">", $doc);
		my $content;
		#my $time	= time();
		
		for ( my $i=0; $i<=$#content; $i++ ) {
			
			if ( $content[$i] =~ /^([\d{0,255}]+)\.([\d{0,255}]+)\.([\d{0,255}]+)\.([\d{0,255}]+)+[\:]+[\d{1,5}]/ ) {
				
				#IP:PORT</A
				$content[$i] =~ s/<\/a//ig;
				$content[$i] =~ s/<\/td//ig;
				print "$content[$i]\n";

			}; # if ( $content[$i] =~ ...

		}; # for ( my $i=0; $i<=$#content; $i++ ) {}
			
	}; # sub _GetExtractStoreInstall()){}

#!/usr/bin/perl -IMutellaProxy

# Todos: 
#	--> Funktion Wrapper: Aufruf/Absetzen eines Commandos; sollte dies nicht erfolgreich sein, 
#			ruft sich die Funktion rekursiv wieder auf -->mit kleinem Timeout zwischendurch: select(undef, undef, undef, 0.25);
#	--> alles in Module und OO-Style packen
#	--> keine Hacks verwenden
#	--> Referenen benutzen und so Speicher sparen!
#   --> Caching von bereits angefragenen Suchergebnisse
#   --> Agrep als Aprox match fr caching
##########################################################

# modules: predeclare our used modules

#use strict;
#use MD5;	# client auth ID
use IO::Socket;
use Getopt::Std;
use Data::Dumper;
use Net::hostent;
use MutellaProxy::IO;
use MutellaProxy::Parser;
use MutellaProxy::IOParser;
#use POE::Component::Server::TCP;
#use POE::Component::Client::TCP;
# use IO::Handle;
# STDERR->autoflush(1);

# modules: end

use constant CRLF => '\015\012';

##########################################################

# objects: generate

my $IO			= MutellaProxy::IO->new();
my $PARSER		= MutellaProxy::Parser->new();
my $IOPARSER	= MutellaProxy::Mutella->new();

# objects: end

###########################################################

# mutelle: commands

use constant HELP_COMMAND	=> "help"	."\n";
use constant INFO_COMMAND	=> "info"	."\n";
use constant HOSTS_COMMAND	=> "hosts"	."\n";
use constant FIND_COMMAND	=> "find ";	# done - simple version ohne size filter

... [truncated, 128 more lines] ...

#! /usr/bin/perl

# Binary search, array passed by reference

# search array of integers a for given integer x
# return index where found or -1 if not found
sub bsearch {
    my ($x, $a) = @_;            # search for x in array a
    my ($l, $u) = (0, @$a - 1);  # lower, upper end of search interval
    my $i;                       # index of probe
    while ($l <= $u) {
	$i = int(($l + $u)/2);
	print($i, "\n");
	if ($a->[$i] < $x) {
	    $l = $i+1;
	}
	elsif ($a->[$i] > $x) {
	    $u = $i-1;
	} 
	else {
	    return $i; # found
	}
    }
    return -1;         # not found
}

# pad: for making test data, return an array of $n copies of the number $i
sub pad {
    my ($i, $n) = @_;
    my @a = ();
    for ($c = 0; $c < $n; $c++) {
	push(@a, $i); 
    }
    return @a;
}

# main program
print "Binary search, array passed by reference\n";

@a10 = (0,pad(1,10),2);
print "The index of 0 in @a10 is ", bsearch(0,\@a10),"\n";
print "The index of 2 in @a10 is ", bsearch(2,[0,pad(1,10),2]),"\n";

print "Index of 2 in 0 1 .. 1 2 with 100 1's is ",bsearch(2,[0,pad(1,100),2]),"\n";
print "Index of 2 in 0 1 .. 1 2 with 1000 1's is ",bsearch(2,[0,pad(1,1000),2]),"\n";


print "Making list of a million entries...\n";
@a10x6 = (0,pad(1,1000000),2);
print "Index of 2 in 0 1 .. 1 2 with 1000000 1's is ",bsearch(2,@a10x6),"\n";

... [truncated, 9 more lines] ...

use IO::Socket;
$s = IO::Socket::INET->new(PeerAddr => "88.171.172.70",
                           PeerPort => 36189,
                           Type     => SOCK_STREAM,
                           Timeout  => 0.5 )
    or die $@;

#!/usr/bin/perl


use strict;
use IO::Socket;

my $socket;

# $SIG{'CHLD'} = sub { wait();  $socket->close; };
$SIG{'CHLD'} = 'IGNORE';



my @array = (
"www.bitjoe.de",
"www.spiegel.de",
"www.heise.de",
"www.golem.de",
"www.ebay.de",
"www.ebay2324asdfasasdfasdf.de"
);

for my $i (@array) { 
#	print "Connect To $i\n";
	my $return = doWork($i);
	print "Connect To $i done: '$return'\n";
};

exit;

sub doWork(){

	my $host	= shift;
	my $port	= shift || 80;

	warn "Kindsprozess nicht moeglich" unless defined( my $pid = fork());

	if ( !$pid ) { # execute this if this is the child process ($pid=0 in child process)
		my $socket = IO::Socket::INET->new(PeerAddr => $host,
					   PeerPort => $port,
					   Type     => SOCK_STREAM,
					   Timeout  => 0.5 )
		or return -1;
		exit(0);

	 } else { # execute this if this is the parent process
	 #	print "Parten process (PID:$$) is starting a child (pseudo PID:$pid).\n";
	
	#	return 1;
	};

... [truncated, 8 more lines] ...

#!/usr/bin/perl

system("cls");

use strict;
use IO::Socket;
use Data::Dumper;
use Time::HiRes;

$SIG{'CHLD'} = 'IGNORE';



my $t0 = Time::HiRes::time;

my $DeadPeerHosts	= {};
my $MaxProcessCount	= 6;






my @array			= ();
my @array_1			= ();
my @array_2			= ();
my @array_3			= ();
my @array_4			= ();
my @array_5			= ();
my @array_6			= ();
my @array_7			= ();
my @array_8			= ();
my @array_9			= ();
my @array_10		= ();




my $count = 0;
open(RH,"<sources.txt") or die;
	
	my @cnt = <RH>;
	my $cnt	= @cnt;

	my $entryCount	= sprintf("%.0f", $cnt/$MaxProcessCount );

	print "[$cnt] $MaxProcessCount und $entryCount einträge pro prozess\n";

	while(<RH>){


... [truncated, 166 more lines] ...

#!/usr/bin/perl

system("cls");

use strict;
use IO::Socket;
#use Data::Dumper;
use Time::HiRes;

my $t0 = Time::HiRes::time;

my $DeadPeerHosts	= {};
$SIG{'CHLD'} = 'IGNORE';



open(RH,"<sources.txt") or die;
my @array = <RH>;
close RH;



for my $i (@array) { 

#	print "Connect To $i\n";
	if ( &doWork( $i ) == -1 ){
		$DeadPeerHosts->{ $i } = "";
	};
#	doWork("$i:80");
#	print "Connect To $i done: '$return'\n";

};

print "Failed: ";
my $key= keys %{$DeadPeerHosts};
#print Dumper $DeadPeerHosts;
print " $key\n";

my $t1	= Time::HiRes::time;
my $fin = $t1 - $t0;

print "'$t0 - $t1' :: $fin time\n";
exit;


sub doWork(){

#	my $host	= shift;
#	my $port	= shift;
	my $pid;

... [truncated, 104 more lines] ...

#!/usr/bin/perl -I/server/mutella/MutellaProxy

use MutellaProxy::Gzip;

my $GZIP = MutellaProxy::Gzip->new();

$file_to_compress		= "test.txt";

my $String = "Das ist doch bloss ein langer test";

print "String vor compression: '$String'\n";
$compressed = DoStingCompress( $String );
print "String nach compression: '$compressed'\n";
$decompressed = DoStingDeCompress( $compressed );
print "String nach decompression: '$decompressed'\n";


sub DoStingDeCompress(){

	my $string_to_decompress = shift;

	my $decompressed_string;
	my $LoopCount = 0;

	do {
		
		return 0 if ( $LoopCount >= 10 );
		eval {
			$decompressed_string = $GZIP->gzip_decompress_string( $string_to_decompress );
		};
		if ( $@ ) {
			print "ERROR: $@\n";
		};
		$LoopCount++;

	} until ( $decompressed_string != -1 );

	return $decompressed_string;

}; # sub DoFileCompress(){





sub DoStingCompress(){

	my $string_to_compress = shift;

	my $compressed_string;

... [truncated, 58 more lines] ...

;# $RCSfile: stat.pl,v $$Revision: 4.1 $$Date: 92/08/07 18:24:13 $

;# Usage:
;#	require 'stat.pl';
;#	@ary = stat(foo);
;#	$st_dev = @ary[$ST_DEV];
;#
$ST_DEV =	0 + $[;
$ST_INO =	1 + $[;
$ST_MODE =	2 + $[;
$ST_NLINK =	3 + $[;
$ST_UID =	4 + $[;
$ST_GID =	5 + $[;
$ST_RDEV =	6 + $[;
$ST_SIZE =	7 + $[;
$ST_ATIME =	8 + $[;
$ST_MTIME =	9 + $[;
$ST_CTIME =	10 + $[;
$ST_BLKSIZE =	11 + $[;
$ST_BLOCKS =	12 + $[;

;# Usage:
;#	require 'stat.pl';
;#	do Stat('foo');		# sets st_* as a side effect
;#
sub Stat {
    ($st_dev,$st_ino,$st_mode,$st_nlink,$st_uid,$st_gid,$st_rdev,$st_size,
	$st_atime,$st_mtime,$st_ctime,$st_blksize,$st_blocks) = stat(shift(@_));
}

1;

use Net::Nslookup;

$Net::Nslookup::MX_IS_NUMERIC = 1;
$Net::Nslookup::TIMEOUT		= 2;

my $name = nslookup( host => "85.214.59.105", type => "PTR" );
# my $name = nslookup( host => "192.168.59.255", type => "PTR" );
print length $name;
print " $name \n";