#!/usr/bin/perl -w

# proxy_check.pl
use Getopt::Std;
use IO::Handle;
use threads;

use LWP;

my $MAX_THREADS = 10;
my $TIMEOUT = 10;
my $USAGE_MESSAGE = 
   "Usage: $0 -j <proxy_judge_list> [-c] [-f <proxy_list>] [-n <threads>] [-t <timeout>] [-d <detail output level>] [-v] --version --help\n";

# Отменяем буферизирование
STDOUT->autoflush(1);
STDERR->autoflush(1);


# ---------------------------------------------
# Обрабатываем аргументы
# ---------------------------------------------
our($opt_j,$opt_c,$opt_f,$opt_n,$opt_t,$opt_d,$opt_v);

getopts('j:cf:n:t:d:v');

die "$USAGE_MESSAGE" unless $opt_j;
$MAX_THREADS = $opt_n if $opt_n;
$TIMEOUT = $opt_t if $opt_t;

# ---------------------------------------------
# открываем файл со списком proxy-jugde, и подготавливаем массив proxy_judge
# ---------------------------------------------

open (PROXY_JUDGES, $opt_j);
my @proxy_judges; # инициализируем массив proxy_judge
my $j=0; # счетчик - количество пригодных proxy-judge
while (my $line =<PROXY_JUDGES>)
{
	chomp($line);
	# Пропуск комметариев и пустых строк
	next if $line =~ /^#/;
	next if $line =~ /^\s*$/;
	#$line =~ s!http://!!;
	#$line = "http://$line";
	# проверка по ключевым словам - недописано
	# обрезка конца строки - недописано
	$proxy_judges[$j++]=$line; 
}
close(PROXY_JUDGES);
# если массив proxy-jugde пуст - прерываем выполнение программы
die "No available proxy-judge in $opt_j" if ($j==0);
print STDERR "Loaded $j proxy-judge from \"$opt_j\" \n" if $opt_v;

# ---------------------------------------------
# Проверяем прокси-джаджи на доступность, в несколько потоков
# если не указана опция "не проверять"
# ---------------------------------------------
if (!$opt_c)
{
	%judge_result = ();
	sub check_judge;
	my %thread = ();
	print STDERR "Start checking of proxy-judge\n" if $opt_v;
	foreach my $judge (@proxy_judges)
	{
		if ($MAX_THREADS - threads->list(threads::running) > 0)
		{

  		       $thread{$judge} = threads->new(\&check_judge, $judge);
		}
     		else 
		{
			# Ждем завершения работы какого-нибудь thread
		       	sleep(1);
			redo; # повторить тело цикла без проверки 
		}
	} 

	# Помещаем в хэш judge_result результаты проверки 
	foreach my $judge (@proxy_judges)
	{
		$judge_result{$judge} = $thread{$judge}->join;
	}
	# заново формируем массив proxy_judge только с прошедшими проверку джаджами
	@proxy_judges=();
	foreach my $judge (keys %judge_result)
	{
		push @proxy_judges, $judge unless $judge_result{$judge} =~ m/FAILED/;
	}
	$j=scalar @proxy_judges;
	die "No good proxy-judge in $opt_j\n" if ($j==0);
	print STDERR "Check proxy-judges finished. Available $j proxy judges\n"  if $opt_v;
}



# ---------------------------------------------
# Загружаем все прокси в массив
# меняем стандартный поток ввода, если указана опция взять прокси-лист из файла.
# ---------------------------------------------
open STDIN, $opt_f if $opt_f;
@proxy = <>;
chomp @proxy;
die "No proxy for checking" if (scalar @proxy == 0);
print STDERR "Loaded ", scalar @proxy, " proxy for checking\n" if $opt_v; 


# ---------------------------------------------
# Берем очередную прокси из массива проксей
# если есть свободные нити, запускаем проверку (proxy-judge берется в цикле),
# иначе ждем 1 секунду освобождения нити
# Помещаем в хэш proxy_result результаты проверки 
# ---------------------------------------------
my $i=0;
my %proxy_result = (); # хеш результатов проверки прокси
my %thread = (); # хеш объектов типа threads
sub check_proxy;
foreach my $proxy (@proxy)
{

   if ($MAX_THREADS - threads->list(threads::running) > 0)
	{

  	       $thread{$proxy} = threads->new(\&check_proxy, $proxy, $proxy_judges[ $i++ % $j]);
	}
     else 
	{
		# Ждем завершения работы какого-нибудь thread
	       	sleep(1);
		redo; # повторить тело цикла без проверки 
	}

# Выводим в консоль сообщения о ходе проверки в случае запуска программы с опцией -v (verbose)
# Для каждой десятой итерации цикла
    if ( $i%10 == 0  && opt_v) 
	{
		my $count_joinable = threads->list(threads::joinable);
		my $count_running = threads->list(threads::running);
		print STDERR 
		"$i check started, $count_joinable finished, $count_running running \n";
	}
}

# Помещаем в хэш proxy_hash результаты проверки 
foreach my $proxy (@proxy)
{
	$proxy_result{$proxy} = $thread{$proxy}->join;
}



# ---------------------------------------------
# функция проверки прокси, вызваемая в каждой нити 
# аргументы - прокси ULR, judge URL
# возвращает строку с результатом проверки
# ---------------------------------------------

sub check_proxy()

{

# обрабатываем входные значения вызова подпрограммы:

$proxy_url=$_[0];

$judge_url=$_[1];

my $agent = LWP::UserAgent->new;
$agent->proxy(http => "http://$proxy_url");
$agent->timeout($TIMEOUT);


my $request = HTTP::Request->new(GET => $judge_url);

my $response = $agent->request($request);
if ($response->code == 200)
{

	my $wholehtml = $response->content;

	if ($wholehtml =~ m/(HTTP_VIA)/si)
	{
		if ($wholehtml =~ m/(HTTP_X_FORWARDED_FOR)/si)
		{
			return "HTTP_VIA, HTTP_X_FORWARDED_FOR";
		}
		else 
		{
			return "HTTP_VIA";
		}
	}
	else
	{
	 	return "ANONIMOUS";
	}
}
else
{	
	return "FAILED judge: $judge_url";
}



}


# ---------------------------------------------
# функция проверки валидности джаджа
# аргументы - judge URL
# возвращает строку с результатом проверки
# ---------------------------------------------
sub check_judge()

{
# обрабатываем входные значения вызова подпрограммы:

	my $judge_url=$_[0];

	my $agent = LWP::UserAgent->new;
	$agent->timeout($TIMEOUT);


	my $request = HTTP::Request->new(GET => $judge_url);

	my $response = $agent->request($request);
	if ($response->code == 200)
	{

		my $wholehtml = $response->content;

		if ($wholehtml =~ m/(REMOTE_ADDR)/si)
		{
			return "REMOTE_ADDR";

		}
		else
		{
		 	return "FAILED";
		}
	}
	else
	{
		return "FAILED";
	}


}



# ---------------------------------------------
# Вывод результатов (хранящихся в хэше proxy_result)
# В зависимости от уровня детализации
# По умолчанию выводиться список прошедших проверку прокси
# Уровень 1 - живые + доп. информация
# Уровeнь 2 - неформатируемый вывод  
# ---------------------------------------------

if ($opt_d && $opt_d eq 1)
{
	foreach my $proxy (keys %proxy_result)
	{ 
		print "$proxy : $proxy_result{$proxy}\n"
			 unless $proxy_result{$proxy} =~ m/FAILED/;

	}
}
elsif ($opt_d && $opt_d eq 2)
{
	foreach my $proxy (keys %proxy_result)
	{ 
		print "$proxy : $proxy_result{$proxy}\n";

	}
}
else
{
	foreach my $proxy (keys %proxy_result)
	{ 
		print "$proxy\n" unless $proxy_result{$proxy} =~ m/FAILED/;

	}
}


# ---------------------------------------------
# Справка и версия - для удобства использования
# ---------------------------------------------	

sub VERSION_MESSAGE()
{
	print "proxy_check.pl v0.1 -- Get proxylist from input or file and multithread check it againist proxyjudge from file \n";
}

sub HELP_MESSAGE()
{
	#&VERSION_MESSAGE();
	print "$USAGE_MESSAGE";
	print "\t -j file     mandatory file with proxy-judge list\n";
	print "\t -c          no check availability of proxy-judge from file\n";
	print "\t -f file     file with proxy (ip:port or url:port)\n";
	print "\t             by default get proxy from input\n";
        print "\t -n          number of threads ($MAX_THREADS by default)\n";
        print "\t -t          timeout in sec ($TIMEOUT by default)\n";
        print "\t -d          detalisation level in output \n";
        print "\t             (by default work as filter, output only good proxies):\n";
        print "\t -d 1        level 1: print only good proxy with info\n";
        print "\t -d 2        level 2: print all proxy with info, sort by good\n";
        print "\t -v          be verbose\n";
        print "\t --version   print version\n";
        print "\t --help      print this message and exit";
	die "\n";
}

perl proxy_check.pl -j <proxy_judge_list> [-c] [-f <proxy_list>] [-n <threads>] [-t <timeout>] [-d <detail output level>] [-v] --version --help