Форум АНТИЧАТ - Подскажите чекер проксей

Лично я пользуюсь перловским скриптом, так как сижу под никсами, + с командной строки запускается.

Код:

#!/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";

}

Есть встроенный хелп (команда help).
Юзаем так:

Код:

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