Лично я пользуюсь перловским скриптом, так как сижу под никсами, + с командной строки запускается.
#!/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