Информация о модулях из этой главы
|
Модуль |
Идентификатор на CPAN |
Версия |
|
| Mac: :Glue | CNANDOR | 0.58 | |
| Win32 . : OLE (входит в состав ActiveState Perl) | JDB | 1.11 | |
| Mail: : Mailer (можно найти в MailTools) | GBARR | 1.13 | |
| Text::Wrap (можно найти в Text-Tabs+Wrap,
также распространяется с Perl) |
MUIR | 98.112902 | |
| 10: '.Socket (можно найти в 10, кроме того, распространяется с Perl) | GBARR | 1.20 | |
| Mail : : Internet (можно найти в MailTools) | GBARR | 1.13 | |
| Mail: : Heade r (можно найти в MailTools) | GBARR | 1.13 | |
| Mail: : Folder: :Mbox (можно найти в Mail: : Folder) | KJOHNSON | 0.07 | |
| Socket (распространяется с Perl) | |||
| BerkeleyDB | PMQS | 0.10 | |
| Net: :Tclnet | JROGERS | 3.01 | |
| DB_File (распространяется с Perl) | PMQS | 1.72 |
Отправка почты
Начнем с рассмотрения механизмов отправки почты, а затем перейдем к более сложным вопросам. Традиционный (для Unix) Perl-код для
отправки почты бывает похож на пример, включенный в список часто задаваемых вопросов:
#
считаем, что ser.dmail установлен
open(SENDMAIL. "|/usr/lib/sendmail -oi -t -oaq") or
die "Невозможно запустить процесс для sendTiaii:
$!\n"; print SENDMAIL «"EOF"; From: от кого <me\$host> To:
кому <you\@othernost> Subject: Тема сообщения
Тело сообщения следует после пустой строки и может состоять из любого
количества строк.
EOF
close(SENDMAIL) or warn "Невозможно закрыть sendmail ";
Когда в Perl 5 изменились правила интерполяции массивов (по сравнению с Perl 4), очень много сценариев, отправляющих почту, перестали работать. Даже сейчас будьте осторожны и следите за таким кодом:
Saddress = "fred@example.com";
Чтобы все работало верно, его надо заменить на одну из следующих строк:
$address="fred\@example.com";
$address='fred@example.com1;
$address= join('@', 'fred', 'example.com');
Код, вызывающий sendmail, как было в нашем примере, во многих случаях будет работать отлично, но если в операционной системе не установлен агент передачи почты с именем «sendmail» (например, в NT или MacOS), он не будет работать никогда. В таких операционных системах выбор действий невелик.
Получение sendmail (или иного агента передачи почты)
Если вы работаете на Win32, то вам повезло, т. к. я знаю по крайней мере о трех версиях sendmail, перенесенных под Win32:
трех версиях sendmail, перенесенных под Win32:
Перенесенная версия sendmail от Cygwin (http://dome/weeg.ui-owa.edu/pub/domestic/sos/ports)
Коммерческая версия sendmail от Mercury Systems (http://www.de-mobuilder.com/sendmail.htm)
Коммерческая версия Sendmail for NT от Sendmail, Inc. (http:
www.sendmail.com)
Тем, кому нужно что-то менее тяжеловесное и кто хочет внести некоторые изменения в программу на Perl, чтобы поддержать различные аргументы командной строки, возможно, помогут достичь цели другие программы для Win32:
blat (http://www.interlog.com/~tcharron/blat.html)
netmall95 (http://www.geocitles.com/SlliconValley/Lakes/2382/net mail.html)
wmailto (http://www.impaqcomp.com/jgaa/wmailto.html)
Преимущества такого подхода состоят в том, что можно выбросить из сценария все сложности отправки почты. Хороший агент передачи почты (МТА) пытается повторно соединиться с почтовым сервером, если тот в данный момент недоступен, выбирает нужный целевой сервер (ищет записи Mail eXchanger в DNS и осуществляет переходы между ними), при необходимости переписывает заголовки, справляется с внезапными коллизиями и т. д. Если можно избежать необходимости заботиться обо всем этом в Perl, то это просто замечательно.
Использование IPC, специфичных для операционной системы
В MacOS или Windows NT можно управлять почтовым клиентом, используя IPC (Interprocess Communication, межпроцессные взаимодействия).
Я не знаю о существовании версий sendmail для MacOS, но в нем для управления почтовым клиентом можно применять AppleScript:
$to="someone\@example.com"; $from="me\@example.com"; $subject="Hi there"; $body="message body\n";
MacPerl: :DoAppleScnpt(«EOC); tell application "Eudora"
make message at end of mailbox "out"
-- 0 is the current message
set field \"from\" of message 0 to \"$frorn\"
set field \"to\" of message 0 to \"$to\"
set field \"subject\" of message 0 to \"$subject\"
set body of message 0 to \"$body\"
queue message 0
connect with sending without checking
quit
end tell EOC В этом примере запускается очень простая программа AppleScript, которая общается с почтовым клиентом Eudora. Сценарий создает новое сообщение, помещает его в очередь для отправки, а затем отдает инструкции почтовому клиенту об отправке сообщения из очереди перед выходом.
Еще один, более эффективный способ написать подобный сценарий состоит в том, чтобы использовать модуль Мае: : G1 ие, уже рассмотренный в главе 2 «Файловые системы».
use Mac::Glue ':glue ;
$e=new Mac::Glue 'Eudora';
$to="someone\@example.com"; $f rom="me\(<}>exainple. com";
$subject="Hi there"; $body="<riessage body";
$e->make(
new => 'message',
at => location(end => $e->obj(mailbox => 'Out')) );
$e->set($e->obj(field => from => message => 0), to =4 $froin):
$e->set($e->obj(field => to => message => 0), to => $to);
$e->set($e->ob](field => subject => message => 0), to => Ssubject);
$e->set($e->prop(body => message => 0), to => $body);
$e->queue($e->obj(message => 0)); $е->соппесц sending => 1, checking => 0);
$e->quit;
В NT можно обратиться к библиотеке Collaborative Data Objects Library (раньше она называлась Active Messaging), простой в использовании надстройке на архитектуре MAPI (интерфейс прикладного программирования систем передачи сообщений). Вызвать эту библиотеку для управления таким почтовым клиентом, как Outlook можно, применив модуль Win32: :OLE следующим образом:
$to="me\(Sexample.com"; $subject="Hi there";
$body="message body\n";
use Win32::OLE;
# инициализируем OLE и COINIT_OLEINITIALIZE,
необходимые при и использовании объектов MAPI.Session
Win32: :OLE->Initialize(Win32: :OLE: :COINIT__OLEINITIALI7E): die Win32: :OLE->LastEr'-or(), "\n"
if Win32: :OLE->LastErrc-( V
создаем объект сессии, который вызовет logoff при уничтожени
my Ssession = Win32::OLE->new('MAPI.Session','Logoff);
die Win32::OLE->LastError();"\n" if Win32::OLE->LastError();
№ регистрируемся в этой сессии, используя OL98 Internet Profile по
$session->Logon('Microsoft Outlook Internet Settings').
die Win32: :OLE->LastError(),"\n" if Win32::OLE->LastError();
создаем обьект message
my Smessage = $session->Outbox->Messages->Add:
die Win32:'OLE->LastError(),"\n" if Win32::OLE->LastError():
Я создаем обьект recipient
my Srecipient = $message->Recipients->Add;
die Win32::OLE->LastError(),"\n" if Win32::OLE->LastError();
заполняем данными объект recipient
$recipient->{Name} = $to;
$recipient->{Type} = 1; n 1 = "To:", 2 = "Cc:", 3 = "Вес:"
все адреса должны быть расшифрованы по справочнику
# (в этом случае, скорее всего, по вашей адресной книге)
Полные адреса расшифровываются сами в себя, так что эта
строка в большинстве случаев не изменит обьект recipient
$ recipient->Resolve();
die Win32: :OLE->LastError(). "\r> if Win32: :OLE->LastError();
tt заполняем строку Subject: и тело сообщения
$message->{Subject} = Ssubject; $message->{Text} = Sbody;
tt помещаем сообщение в очередь для отправки
1-й аргумент = сохранить копию сообщения
2-й аргумент = позволить пользователю изменить сообщение
tt перед отправкой в диалоговом окне
№ 3-й аргумент = родительское окно диалога, если 2-й аргумент True
$message->Send(0, О, О):
die Win32::OLE->LastError(),"\n" if Win32::OLE->LastError();
tt явно уничтожить объект Ssession, вызвав
$session->Logoff undef Ssession,
В отличие от предыдущего примера, программа всего лишь помещает письмо в очередь. Это уже дело почтового клиента (такого как Outlook) или транспортного агента (например Exchange) периодически инициировать отправку почты. Существует CDO/AM 1.1 - метод для объекта Session под названием DeiiverNow(), обращающийся к MAPI с заданием очистить все очереди входящих и исходящих сообщений. К сожалению, в некоторых ситуациях он недоступен или не работает, поэтому его нет и в предыдущем примере.
В упомянутом примере управление MAPI производится «вручную» при помощи вызовов OLE. Если вы хотите использовать MAPI, «не пачкая рук», можно применить модуль Win32: :МАР1, который берет на себя все функции (модуль находится на http://www.generation.net/ -aminer/Perl/ ).
Программы, полагающиеся на AppleScript/Apple Events или MAPI, так же непереносимы, как и вызов программы sendmall. Они берут на себя часть работы, но относительно неэффективны. К этим методам нужно прибегать в последнюю очередь.
Общение напрямую по почтовым протоколам
Последний выбор - написать программу, общающуюся с почтовым сервером на его родном языке. Большая часть этого языка документирована в RFC821. Вот как выглядит основной обмен данными по SMTP (Simple Mail Transfer Protocol, простой протокол передачи почты). Данные, которые мы посылаем, выделены жирным шрифтом:
%
telnet example.com 25 -соединяемся с SMTP-портом на
example.com
Trying 192.168.1.10 ... Connected to example.com. Escape character is '"]'.
220 mailhub.example.com ESMTP Sendmail 8.9.1a/8.9.1: Sun, 11 Apr 1999 15:32:16 -0400 (EOT)
HELD client.example.com -идентифицируеммашину,с которой мы.
пришли (можно использовать EHLO)
250 mailhub.example.com Hello dnb@client.example.com [192.168.1.11]. pienSt;' to meet you
MAIL FROM: «jnb@example.com> - определяем отправителя 250 <dnb@exarnple. com>... Sender ok
RCPT TO: <dnb@example.com> - определяем получателя
250 <dnb@example.com>... Recipient ok
DATA - начинаем отправлять данные, не забывая о некоторых ключевых заголовках
354 Enter mail, end with "." on a line by itself From:
David N. Blank-Edelman (David N. Blank-Edelman) To: dnbeexample.com Subject: SMTP - хороший протокол
Просто хочу напомнить себе о том, насколько я люблю SMTP. С миром, dNb
- завершаем сообщение
250 РАА266Р4 Message accepted for delivery QUIT - конец сессии
221 mailhuD.example.com closing connection Cor.rectici closed by foreign host.
Несложно записать в сценарий подобную беседу. Можно было бы использовать модуль Socket или что-нибудь вроде Net: : Telnet, как в главе 6 «Службы каталогов». Но существует несколько хороших модулей для отправки почты, которые упрощают эту задачу. Среди них модуль Женды Крыницки (Jenda Krynicky) Mail; :Se'-oer, Mai 1: :Sendmail Мили-вожа Ивковича (Milivoj Ivkovic) и Mail::Ma:Ier из пакета MailTools Грэхема Бара (Graham Barr). Все эти модули не зависят от операционной системы и будут работать практически везде, где доступен современный дистрибутив Perl. Мы рассмотрим Mail: :Mailer, поскольку он предлагает единый интерфейс к двум способам отправки почты, которые обсуждались до сих пор. Как и в случае с большинством модулей, написанных в объектно-ориентированном стиле, первый шаг заключается в создании экземпляра нового объекта:
use Mail::Mailer;
$f rom="me\@example. coin"; $to="you\@example.com";
$subject="Hi there"; $body="message body\n";
$type="srnto"; $server="mail.example,com";
my Smaller = Mail::Mailer->new($type, Server -> $server) or die
"Невозможно создать новый объект mailer:$'\n".
Переменная $ type позволяет выбрать один из следующих типов поведения:
smtp
Посылает почту, обращаясь к модулю Net: :SMTP (часть пакета lib-net),
доступному и для большинства не-Unix версий Perl. Если используется MailTools версии 1.13 или выше, можно задать имя SMTP-сервера, применяя приведенную выше символику =>. В противном случае, придется устанавливать имя сервера во время процедуры установки libnet.
Отправка почты при помощи почтового агента mail (или любого другого, который задан вторым необязательным аргументом). Это напоминает недавнее использование AppleScript и MAPI.
sendmail
Отправка почты с помощью программы sendmail, как и в первом случае из данного раздела.
Кроме того, можно установить переменную окружения PtRL_MAILERS, чтобы изменить путь, установленный по умолчанию для поиска программ (например,
sendmail) в системе.
Вызов метода ореп() для нашего объекта Mail:: Mailer заставляет последний выполнять роль дескриптора для исходящего сообщения. В этом вызове передаются заголовки сообщения ссылке на анонимный хэш:
$mailer->open({From => $from, То => $to.
Subject => Ssubject}) or die "Невозможно заполнить объект mailer
Тело сообщения выводится в этот псевдодескриптор, который потом закрывается для отправки сообщения:
print Smailer $body: $mailer->close;
Этого вполне достаточно, чтобы отправка почты из Perl не зависела от системы.
В зависимости от того, какой тип поведения $type был выбран при работе с модулем, могут оказаться скрытыми (а могут и не оказаться) более сложные вопросы, относящиеся к МТА, о которых уже говорилось. В предыдущем примере использовалось поведение smtp, а это означает, что программа должна быть достаточно умна, чтобы обрабатывать такие сбои как недоступность сервера. Приведенный пример не настолько «сообразителен». Обязательно позаботьтесь о таких моментах, когда будете писать программы.
Получение почты
Обсуждая в этом разделе получение почты, мы не будем говорить о ее сборе (fetching). Передача почты с одной машины на другую не представляет особого интереса. Модули Mail: :POP3Client Сина Дауда (Sean Dowd) и Mail: :Cclient Малколма Битти (Malcolm Beattie) легко могут передать почту по протоколам POP (Post Office Protocol) или ШАР (Internet Message Access Protocol). Гораздо интереснее посмотреть, что с этой почтой делать после ее получения, и именно на этом мы и остановимся.
Начать следует с основ, поэтому рассмотрим инструменты, позволяющие разбить как отдельные сообщения, так и почтовые ящики. Чтобы рассмотреть первое, вновь обратимся к пакету MailTools Грэма Бара (Graham Barr), на этот раз прибегнем к модулям Mail : :Interne: и Mail : :Header.
Разбиение отдельных сообщений
Модули Mail: :Internet и Mail: :Header предлагают удобный способ разбить заголовки почтового сообщения, соответствующего RFC822. RFC822 определяет формат почтового сообщения, включая имена допустимых заголовков и их форматов.
Модулю Mail: : Internet необходимо передать либо файловый дескриптор файла с сообщением, либо ссылку на массив, содержащий его строки:
use Hail::Internet: $messagefile = "mail";
open(MESSAGE,"Smessagefile") or die "Невозможно открыть $messagefile:$!\n";
Smessage = new Mail::Internet VMESSAGE;
close(MESSAGE);
Если мы хотим анализировать сообщение, поступающее в стандартный поток ввода (т. е. переданное через конвейер на стандартный ввод), можно поступить так:
use Mail::Internet;
Smessage = new Mail: :Internet VSTDIN;
Mail: : Internet возвращает экземпляр объекта сообщения. Чаще всего с этим экземпляром объекта будет применяться один из двух методов: body() и head(). Метод body() возвращает ссылку на анонимный массив, содержащий строки тела сообщения. head() более интересен и предлагает плавное продолжение модуля Mail: : Header.
При загрузке Mail::Internet неявно загружается Mail::Header. Если вызвать метод head() модуля Mail: :Internet, он вернет экземпляр объекта заголовка Mail: :Header. Это будет тот же экземпляр объекта, который можно получить, если использовать не Mail: :Internet, а напрямую Mail: :Header:
use Mail::Header; Smessagefile = "mail";
open(MESSAGE,"Smessagefile") or die "Невозможно открыть $messagefile:$!\n"
$header = new Mail:: Header VMESSAGE;
close(MESSAGE):
Объект $header содержит заголовки сообщения и предлагает несколько удобных способов для получения данных. Например, чтобы вывести
отсортированный список встречающихся имен заголовков (которые в модуле называются «тегами»), можно добавить такую строчку в конец предыдущего примера:
print join("\n",sort $header->tags);
В зависимости от сообщения можно увидеть что-то подобное нижеследующему:
Сс
Date
From
Message-Id
Organization
Received
Reply-To
Sender
Subject
To
Необходимо получить все заголовки Received: из сообщения. Вот как это можно сделать:
received = $header->get("Received");
Часто методы Mail: :Header используются вместе с объектом Mail: : Internet. Если применять Mail: : Internet для возвращения объекта, содержащего и тело и заголовки сообщения, можно сцепить вместе некоторые методы из этих модулей:
©received = $message->head->get("Received"):
Обратите внимание, что get()вызывается в списочном контексте. В скалярном контексте метод вернул бы только первое вхождение этого тега, в случае, если бы мы не задали вторым аргументом порядковый номер тега. Например, get("Received", 2) вернет вторую строку Receivec: из сообщения. Модуль Mail: : Header предоставляет и другие методы для удаления и добавления тегов в заголовки; подробную информацию можно найти в документации.
Разбиение почтового ящика
Перейти на следующий уровень, где мы разобьем на части почтовые ящики, довольно просто. Если почта хранится в формате «классического mbox» или qmail (еще один агент передачи почты, подобный sendma.il), можно использовать модуль Mail : : Folder Кевина Джонсона (Kevin Johnson). Многие из распространенных почтовых агентов (не в Unix), таких как Eudora, тоже хранят почту в классическом формате Unix mbox, так что этот модуль может быть полезным на многих платформах.
Что-то подобное мы уже видели:
use Mail': Folder: :Mbox: для классическое фермата Unix mbox
Sfolder = new Mail::Folder('mbox',"filename1 )
Конструктор new() принимает тип формата почтового ящика и имя файла для анализа. Он возвращает экземпляр объекта folder, через который можно запрашивать, добавлять, удалять и изменять сообщения. Чтобы получить шестое сообщение, нужно применить следующее:
Smessage = $folder->get_message(6);
Теперь Smessage содержит экземпляр объекта Mail: : Internet. С этим экземпляром объекта можно применять все только что обсужденные методы. Если вам нужен только заголовок сообщения, можно использовать:
$header = $folder->get_header(6);
Здесь нет никаких сюрпризов; возвращается ссылка на экземпляр объекта Mail: .'Header. Чтобы узнать о других доступных методах, загляните в документацию по Mail:: Folder.
Отслеживание спама
Теперь, когда мы знаем, как можно разбить на части сообщение, посмотрим, что делать с этим умением на практике. Первое, что можно рассмотреть, - это непрошеная коммерческая электронная почта, или спам. Большинству пользователей не нравится получать такие сообщения. Системные администраторы не любят спам за то, что он попусту забивает каталоги почтовых очередей и журналы регистрации. Кроме того, каждое непрошеное коммерческое письмо вызывает недовольство пользователей, так что в почтовом ящике системного администратора на каждое письмо «из спама» зачастую приходится более десятка возмущенных писем от пользователей.
Лучший способ сдерживать подобный напор- создать такую «атмосферу», в которой спам недопустим и, помимо этого, его очень сложно посылать. Жалобы интернет-провайдеру спамера (у большинства из которых определены строгие правила на этот счет) часто приводят к тому, что виновнику отказывают в услугах. Если это происходит вновь и вновь, то со временем спамеру все сложнее найти провайдера. А чем сложнее спамеру продолжать свое дело, тем меньше вероятность, что он в нем останется.
Жалобы провайдерам затруднены по следующим причинам:
Спамеры часто подделывают часть своих сообщений, пытаясь скрыть следы. Сам по себе этот факт является еще одной причиной не любить спамеров. В конце концов, это красноречиво говорит об их намерениях.
Спамеры часто посылают свою «макулатуру» через посторонние (и совершенно невинные, но неверно настроенные почтовые серверы). Этот процесс называется «ретрансляцией» (relaying), поскольку в большинстве случаев такая почта ни исходит от кого-либо с такого сервера, ни предназначена кому-либо там. Почтовый сервер выступает лишь в качестве передатчика. Системные администраторы серверов, допускающих ретрансляцию, часто оказываются в сложном положении. Их атакованные почтовые серверы начинают страдать от непредвиденных загрузок (вероятно, в ущерб полезным службам), имена их серверов попадают в черные списки и довольно большая часть почты «проникнута» ненавистью тех, кто подвергся «атаке» спамера.
С помощью Perl можно проанализировать сообщение и найти его источник. Начнем мы с малого и затем перейдем к более сложным вопросам, применяя то, что узнали в главе 5 «Службы имен TCP/IP» и главе 6. Если читателю хочется посмотреть на очень сложный Perl-сценарий для борьбы со спамом, советую взглянуть на
adcomplain Билла Макфад-дена (Bill McFadden), который можно найти на http://www.rdrop.com/ users /billmc/'adcomplain.html.
Вот копия настоящего спамерского сообщения, тело которого изменено, чтобы не доставить его автору удовольствия:
Received: from isiteinc.com (www.isiteinc.com [206.136.243.2])
by mailhost.exarnple.com (8.8.6/8.8.6) with ESMTP id NAA14955 f
or <webadmin@example.com>; Fri, 7 Аид 1998 13:55:41 -0400 (EOT)
From: responses@example.com
Received: from extreme (host-209-214-9-150.mia.bellsouth.net [209.214.9.150])
by isiteinc.com (8.8.3/8.8.3) with SMTP id KAA19050 for
webadmin@example.com; Fri, 7 Аид 1998 10:48:09 -0700 (EOT) Date:
Fri, 7 Аид 1998 10:48:09 -0700 (EOT)
Received: from login_0246.whynot.net mx.whynot.net[206.212.231.88])
by whynot.net (8.8.5/8.7.3) with SMTP id XAA06927 for <webadmin@example.com>;
Fri, 7 August 1998 13:48:11 -0700 (EOT) To: <webadmin@example.com>
Subject: ***ADVERTISE VACATION RENTALS - $25/year*»* - http://www.example.coT Reply-To:
sample@whynot.net X-PMFLAGS: 10322341.10 X-UIDL: 10293287J92832.222
Comments: Authenticated Sender is <user122@whynot.net>
Message-Id: <77126959_36550609>
Мы рады представить вам новый веб-сайт http://www.example.com от Extreme Technologies, Inc.
Наш новый сайт, посвященный путешествиям, содержит список некоторых интересных путешествий, которые только можно отыскать в WWto.вы легко найдете информацию об аренде и продаже жилья, об услугах и многом другом. Наш список сопровождается цветными фотографиями, анимированной графикой, точными описаниями и информацией о том, как напрямую связаться с арендатором/поставщиком.
Давайте критически оценим это сообщение. Во-первых, большинство его заголовков подозрительны. Как вы видели в предыдущем разделе этой главы, большинство заголовков (То:, From: и т. д.) передаются почтовой программе в разделе DATA передачи сообщения. Это единственный набор заголовков, которые трудно подделать и которые добавляются агентом передачи почты, когда сообщение проходит через почтовую систему.
В особенности нужно внимательно посмотреть на заголовки Received:.
Спамер может подделать строки Received:, но он не сумеет убрать те из них, которые были добавлены последующими почтовыми системами. Можно вставить фальшивые, но это потребует определенных и довольно серьезных знаний (например, как подделать TCP/IP-пакет или сфабриковать записи в DNS), которыми рядовые спамеры очень редко обладают.
Начнем с того, что выделим заголовки Received: из сообщения и представим их на экране в более читаемом виде. Мы выведем их в той последовательности, в которой передавалось сообщение, начиная с первого почтового сервера, получившего сообщение, и заканчивая местом назначения (нашим сайтом):
use Mail::Header;
Sheader = new Mail-Header \*STDIN;
$header->unfold('Received1); received = $header->get('Received');
for (reverse @received){
chomp;
parseline($_J;
if (Idefined $ehelo and Idefined $validname and I defined $validip){ print "$_\n";
}
else { write;
> }
format STDOUT =
(«««« ««««« 5«««««««« 5«<««««««
$ehelo,$validname,Svalidip sub parseline { my $line = $_;
и "нормальный" -- от НЕЮ (REAL [IP])
if (/from\s+(\w\S+)\s-\((\S+)\s*\[(\d+V\d+V \d+\.\d+)/){
($ehelo.$validname,$validip) = ($1.$2. $3); >
невозможно выполнить обратное разыменование -- от
НЕЮ ([IP]) elsif (/from\s+(\w\S+)\s+\(\[(\d+V\d+\.\d+V \d+)\]/)!
(Sehelo,Svalidname,$validip) = ($1,undef, $2); }
ft exim -- из [IP] (helo=[HELO IP]) elsif
(/ from\s+\[(\d+\.\d+\.\d+\.\d+)\]\s+\(helo=\[(\dA.\d+\Ad+\.\d+)\]/){
($validip,$ehelo,$validname) = ($1,$2, undef); >
ft Sun Internet Mail Server -- из [IP] by HELD
elsif (/from\s+\[(\d+V\d+V\d+V\d+)\]\s+by\s+(\S+)/){
($validip,$ehelo,$validname) = ($1,$2, undef); }
ft Microsoft SMTPSVC -- из HELD - (IP) elsif
(/from\s+(\S+)\s+-\s+(\d+V\d+V\d+V\d+)\s+/){
($ehelo,$validname,$validip) = ($1,$2, $3); } else { ft punt!
$ehelo = Svalidname = $validip = undef; }
return [Sehelo,$validname,Svalidip]; }
Первым делом из сообщения выбираются (при помощи unf old()) заголовки
Received:. Метод unf old () удаляет из заданных строк символы новой строки и символы продолжения. Это делается для упрощения анализа.
Все строки просматриваются в обратном порядке (по сравнению с тем, как они были найдены в сообщении). По существу, движение идет от центра сообщения к периферии, т. к. каждая система, через которую оно проходило, добавляла еще один уровень заголовков Received:. Большая часть работы выполняется подпрограммой &parseline. Используя несколько регулярных выражений, попробуем выделить следующее из заголовков Received::
Имя узла HELO/EHLO
Имя, представленное в обмен на HELO или EHLO при SMTP-«беседе».
«Действительный» IP-адрес
IP-адрес клиента, замеченный агентом передачи почты во время соединения. Он, скорее всего, будет «действительным», поскольку
использует информацию, не зависящую от того, что предоставил клиент во время SMTP-диалога. Это важно, поскольку клиент спамера, скорее всего, будет заядлым лжецом. Слово действительный берется в кавычки потому, что существуют способы сфабриковать и эту информацию.
«Действительное» имя
Имя клиента, найденное агентом передачи почты при обратном разыменовании IP-адреса через DNS. Эта информация, как и предыдущая, поступает не от клиента (хотя она тоже может быть фальшивой).
Формат правильной строки Received: определяется в RFC821 и RFC822. Однако, если просмотреть доставленную почту (как сделал я, создавая использованные регулярные выражения), можно заметить, что не все агенты передачи почты следуют данному правилу. В нашей программе будут применяться наиболее распространенные форматы, но существуют и другие способы, которые обязательно надо учитывать, если есть намерение в дальнейшем расширять код. Чтобы иметь представление о возможных форматах, посмотрите в сценарий adcomplain.
Вот как выглядит вывод программы, выполненной для сообщения, приведенного ранее:
login_0246.whynot.net mx.whynot.net 206.212.231.88
extreme host-209-214-9-150.mia 209.214.9.150
isiteinc.com www.isiteinc.com 206.136.243.2
В первом столбце перечислены имена, используемые машинами при идентификации; во втором - имена этих машин, указанные серверу при соединении; а в третьем - IP-адреса инициаторов данного соединения. Как уже отмечалось, в построенном списке последняя строка соответствует машине, передавшей сообщение на наш почтовый сервер.
Спамеры не могут удалить строки Received:, но они могут изменить их содержимое, задав фальшивое имя во время приветствия HELO или EHLO. Подтверждение этому можно увидеть во второй строке примера, поскольку имя узла из первого столбца не имеет ничего общего с именем из второго столбца, который более достоверен.
Но предположим, что они совпадают. Как же тогда узнать, что строка
Received: была подделана? Один из способов - сверять «действительный» IP-адрес из каждой строки Received: с «действительным» именем узла и сообщать об отклонениях. Приведенная ниже подпрограмма вернет значение (1), если разыменованное имя не совпадет с IP-адресом, в противном случае - (0). Вскоре этот код будет добавлен к основной программе:
my($ip,Sname) = @_;
return 0 unless ($ip and $name);
my $namelook = gethostbyaddr(inet_atoi($ip).AF_INET):
my SiplooK = gethostbyname(Sname):
Siplook = inet_ntoa($iplook) if Siplook;
ft может быть записан в различных регистрах
if ( Siplook eq Sip and Ic Snarnelook eq Ic Sname){
return 0; } else {
return 1; } }
Такая проверка не совсем надежна, потому что, как ни обидно, у вполне законных узлов может отсутствовать информация для обратного разыменования. Кроме того, серверам имен может быть предписано отвечать неверно, предоставляя фиктивную информацию (т. е. на gethostbyaddr() нельзя безоговорочно полагаться).
Много о чем можно догадаться из заголовков Received:, прежде чем отследить владельцев каждого хопа (hop). Например, кем разделяется мнение, что любой из хопов является известным источником спама?
Поиск в локальном черном списке
На некоторых сайтах ведутся локальные черные списки узлов, известных как распространители спама. Такая тактика была взята на вооружение, когда спам только начал появляться, и некоторые провайдеры отказывались принимать меры даже против самых закоренелых клиентов-спамеров. В ответ на это в основных агентах передачи почты появились механизмы, отвергающие соединения от узлов и доменов, входящих в список антисоциальных.
Можно использовать такой черный список, чтобы разобраться, проходило ли сообщение через узлы, известные своим спамерством. Ясно, что в черном списке нет сервера, передавшего нам почту (иначе с ним просто не было бы установлено соединение), но любой из остальных почтовых серверов, указанный в заголовках
Received:, вполне может там быть.
Не существует способа написать одну программу, проверяющую все возможные черные списки агентов передачи почты, поскольку разные агенты хранят эту информацию в различных форматах. Большая часть узлов в Интернете в настоящее время применяет в качестве агента передачи почты sendmail, так что в нашем примере будет применяться его формат черного списка. В новых версиях
sendmail черный спи-
сок хранится в базе данных при помощи библиотек Berkeley DB 2.X, доступных на http://www.sleepycat.com.
Поль Маркес (Paul Marquess) написал модуль BerkeleyDB, специально предназначенный для работы с библиотеками Berkeley 2.x/3.x. Это может сбить с толку, поскольку в документации по DB_File, еще одному известному модулю Маркеса, входящему в состав дистрибутива Perl, также рекомендуется применять библиотеки 2.х/З.х. DB_File использует библиотеки Berkeley DB 2.х/З.х в «режиме совместимости» (в частности, библиотека собирается с ключом --enable-compat185, так что доступен API версии 1.x API). Модуль BerkeleyDB позволяет программисту на Perl применять расширенные возможности из API версии 2.х/З.х.
Агент передачи sendmail использует формат BerkeleyDB 2.х/З.х, так что нужно включить модуль BerkeleyDB. Вот пример, который выводит содержимое локального черного списка:
Sblacklist = "/etc/mail/blacklist.db"; use BerkeleyDB;
Ясвяжем хэш %blist с черным списком, используя Berkeley DB
# для получения значений
tie %blist, 'BerkeleyDB::Hash', -Filename => Sblacklist or die
"Невозможно открыть файл $filenane: $! SBerkeleyDB::Error\n" ;
# обходим в цикле каждый ключ и значение из этого файла, и
выводя только записи REJECT while(($key,$value) = each %blist){
в списке также могут быть записи "OK", "RELAY" и др. next
if ($value ne "REJECT");
print "$key\n": }
Принимая за основу этот код, можно написать подпрограмму, проверяющую, находится ли данный узел или домен (содержащий этот узел) в черном списке. Если нужно узнать об узле mallserver.spam-mer.com, следует обойти в цикле все записи из черного списка (в котором могут находиться mailserver.spammer.com, spammer.com или даже просто spammer), чтобы проверить, содержатся ли в имени узла какие-либо записи из него.
Существует много способов написать на Perl программу, сравнивающую список значений с какими-либо данными. Но для того чтобы программа была эффективной и интересной, мы будем использовать две продвинутые технологии. Они созданы для уменьшения числа компиляций регулярных выражений, которые применяются в ходе выполнения программы. Каждый раз, когда программа использует «новое» регулярное выражение, Perl должен компилировать его заново. Например, в этом отрывке кода Perl вынужден обрабатывать новое значение на каждой итерации:
вообразите себе внешний цикл, в котором этот код вызывается
множество раз
foreach Smatch (qw( alewife davis porter harvard central кепааН park))
{
Sstation =" /Smatch/ and print "found our station stop'": }
Этот процесс требует больших вычислительных затрат, так что если бы можно было сократить количество вычислений, программа стала бы намного эффективней. Время, потраченное на компиляцию регулярных выражений, становится значительным в программах, где в цикле рассматривается список различных регулярных выражений.
Вот пример первой технологии, созданной для решения указанной проблемы:
use BerkeleyDB;
Sblacklist = "/etc/mail/blacklist.db";
&loadblist;
и принимаем имя узла в качестве аргумента командной строки и
сообщаем, если оно есть в черном списке
if (defined &checkblist($ARGV[0])){
print "*** $found найден в черном списке \п"; }
И
загружаем черный список в массив анонимных подпрограмм sub loadblist{
tie %blist, 'BerkeleyDB::Hash', -Filename => Sblacklist or die
"Невозможно открыть Sfilename:
$! $BerkeleyDB::ErrorXn" ;
while(my($key,$value) = each %blist){
# в черном списке могут быть "OK", "RELAY" и пр. next if ($value ne "REJECT");
push(@blisttests, eval 'sub {$_[0] =~ \Q$key/o and $key}'); } }
sub checkblist{
my($line) = shift:
foreach Ssubref (@blisttests){
return Sfound if (Sfound = &$subref($line)); }
return undef: }
В этом примере используются анонимные подпрограммы - технология, продемонстрированная в книге Джозефа Хола (Joseph Hall) «Effective Perl Programming» (Эффективное программирование на Perl) (Addison Wesley). Для каждой записи из черного списка создается анонимная подпрограмма. Каждая подпрограмма сверяет переданные ей данные с одним из элементов черного списка. Если они совпадают, такая запись возвращается. Ссылки на эти подпрограммы хранятся в списке. Вот строка, в которой создается подпрограмма и ссылка на нее добавляется к списку:
push(@blisttests, eval 'sub <$_[0] =" /\0$key/o and $key}');
Так что, если в черном списке есть запись spammer, ссылка на код, добавленная в массив, будет указывать на подпрограмму, по сути эквивалентную следующей:
sub {
$_[0] =" /\Qspammer/o and "spammer"; }
в начале регулярного выражения присутствует для того, чтобы точки (как в
.сот) или другие зарезервированные знаки пунктуации не считались бы метасимволами регулярных выражений.
Позже в программе будет обойден в цикле список ссылок на код и выполнена каждая маленькая подпрограмма для переданных данных. Если результатом каких-либо из этих вычислений окажется значение «истина», мы вернем код возврата подпрограммы:
return $found if (Sfound = &$subref($line));
Компиляция регулярного выражения, которая нас так беспокоит, происходит всего один раз - при создании ссылки на подпрограмму. Можно вызывать каждую подпрограмму столько раз, сколько надо, не теряя время на компиляцию регулярного выражения.
Существует и другой, чуть менее продвинутый подход, который можно применять, если у вас Perl версии 5.005 или выше. В Perl 5.005 была введена новая синтаксическая конструкция, названная «прекомпи-лируемым регулярным выражением», которая делает подобную задачу несколько проще. Переписать код, используя эту новую конструкцию, можно было бы примерно так:
sub loadblist{
tie %blist, 'BerkeleyDB::Hash', -Filename => $blacklist or die
"Невозможно открыть файл $Шегше:
$BerkeleyDB: :Error\n" ;
while(my($key,$vaiue) = eac^- %blist){
# в черном списке могут бьть запис/ "OK". "RELAY" и пр. next
(Svalue ne "PEJECT") push('SDlisttests, [qr/\Q$i<ey/. $кеу]): }
sub checkblisu
my($iine) = shift;
foreach my Stest (§blisttests){
my($re,$kr;v) = a{$test}
return $key i* ($line =" /$re/): }
return undef; }
На этот раз ссылка была перенесена на анонимный массив в@blist test. Первый элемент этого массива - скомпилированное регулярное выражение, созданное с применением нового синтаксиса qr/Y. Это позволяет сохранить регулярное выражение после его компиляции. Такая форма обработки значительно увеличивает скорость выполнения программы при дальнейшем поиске соответствия. Второй элемент анонимного массива - сама запись из черного списка, которая будет возвращена при найденном соответствии скомпилированному регулярному выражению.
Поиск в черном списке для всего Интернета
В последнем примере программы на вопрос «Спамер ли это?» мы отвечали, руководствуясь собственным мнением об узле или домене, не принимая во внимание опыт остальных пользователей Интернета. Существуют несколько спорные службы, предлагающие простой доступ к глобальным черным спискам спамеров или известных узлов, открыто допускающих ретрансляцию почты. Две хорошо известные службы такого типа - Realtime Blackhole List (RBL) от Mail Abuse Prevention System и Open Relay Behaviour-modification System (ORBS). Для получения доступа к этим спискам:
Измените на обратный порядок следования элементов проверяемого IP-адреса. Например, 192.168.1. 34 станет 34.1.168.192.
Добавьте специальное имя домена к полученному числу. Для проверки адреса в RBL необходимо использовать 34.1.168.192. rbl.
Выполните запрос к DNS-серверу для данного адреса.
Если вы получите положительный ответ (т. е. запись о ресурсах А), это означает, что данный IP-адрес находится в черном списке.
Несколько менее спорным является список Dial-up User List, также поддерживаемый силами специалистов из Mail Abuse Prevention System. Это список диапазонов IP-адресов, динамически присваиваемых модемным пулам. Теоретически, SMTP-соединения не должны исходить от какого-либо из этих узлов. Почта с таких узлов должна отправляться через почтовый сервер провайдера (которого нет в этом списке).
Вот один из способов проверить, находится ли IP-адрес в каком-либо из этих списков:
sub checkaddr{
my($ip,Sdomain) = @_;
return undef unless (defined Sip);
my $lookupip = join('.',reverse split(/\./,$ip));
if (gethostbyname($lookupip.$domain)){
return Sip; } else {
return undef; } }
Очень скоро эта подпрограмма будет добавлена в предпоследний пример этого раздела. А пока, располагая существенно большим объемом информации о каждом из заголовков Received:, попробуем вычислить человека или людей, ответственных за администрирование каждой машины из списка. Модуль Net: ;Whois, уже рассмотренный в главе 6, вероятно, первым будет использоваться для решения этой проблемы.
К сожалению, этот модуль специализируется только на получении информации о связи имен и доменов (name-to-domain information). Кроме того, он «предполагает», что информация будет представлена в виде, используемом InterNIC. Нам могут понадобиться сведения о связи IP-адресов и доменов (IP address-to-domain information) от WHOIS-серверов на http://whois.arin.net
(American Registry for Internet Numbers), http://whois.ripe.net (European IP Address Allocations) и http:// whois.apnic.net (Asia Pacific Address Allocations). Отсутствие соответствующего модуля - первое препятствие, которое необходимо преодолеть.
Но даже если бы мы знали, как соединиться со всеми этими реестрами и обработать их различные форматы вывода, было бы неясно, к какому из них нужно обращаться для поиска информации о данном IP-адресе. Нам необходимо определить, к какому серверу нужно обратиться, и это второе препятствие. К счастью, если обратиться к ARIN с запросом по адресу, не принадлежащему его базе данных, он направит нас на нужный реестр. Так что, если мы спросим ARIN об адресе из Японии, он отправит нас на APNIC.
Для преодоления первого препятствия можно использовать модуль общего назначения, подобный Net: :Telnet из главы 6. Другой путь - уже рассмотренный модуль 10: :Socket. Что выбрать- дело личных предпочтений, ну и, конечно, необходима возможность доступа к нему с вашей платформы.
Служба WHOIS работает на порту 43 TCP, хотя ее имя будет использоваться только в целях предосторожности. С WHOIS-сервером очень просто общаться. Необходимо соединиться, выполнить запрос (в нашем случае это IP-адрес) и получить ответ. Программа, запрашивающая произвольный WHOIS-сервер, очень проста:
sub getwhois{
my($ip) = shift; my(Sinfo);
$cn = new Net::Telnet(Host => Swhoishost, Port => 'wliois',
Errmode => "return", Timeout => 30)
or die "Невозможно установить -соединении с
Swhoishost connection:$!\n";
unless ($cn->print($ip."\n")){
$cn->close;
die "Невозможно послать
$ip на Swhoishost: ".$cn->errmsg."Vv }
while ($ret = $cn->get){
Sinfo ,=$ret; };
$cn->close;
return $info; 1
Для преодоления второго препятствия, состоящего в выборе нужного реестра, есть, по крайней мере, две возможности. Можно послать запрос к http://whois.arin.net и проанализировать ответ. Например, вот запись диалога с ARIN по поводу IP-адреса японской машины. Жирный шрифт используется для выделения текста, введенного человеком:
X telnet whois.arin.net 43
Trying 192.149.252.22 ..
Connected to whois. arm. not Escape character is '"] 210.161.92.226
Asia Pacific Network Information Center (NETBLK-APNIC-CIDR-BLK)
Level 1 - 33 Park Roan1 Milton, 4064 AU
Netname: APNIC-CIDR-BLK2
Netblock: 210.0.0.0 - 211.255.255.0
Coordinator;
Administrator, System (SA90-ARIN)
sysadn®APNIC,NET +61-7-3367-0490
Domain System inverse mapping provided by:
SVC01.APNIC.NET 202.12.28.131
NS.TELSTRA.NET 203.50.0.137
NS.KRNIC.NET 202.30.64.21
NS.RIPE.NET 193.0.0.193
-** please refer to whois.apnic.net for more information *«*
*«* before contacting APNIC
*-« use whois -h whois.apnic.net <object> *»*
Record last updated on 04-Mar-99.
Database last updated on 19-Apr-99 16:14:16 EOT.
Подобные результаты означают, что запрос нужно послать к http:// whois.apnic.net.
Другой способ - послать запрос к «умному» WHOIS-серверу, который сделает всю работу сам. Из них мне больше всего нравится сервер -http://whois.geektools.com. «Умник» проанализирует ваш запрос, отправит его на нужный WHOIS-сервер и вернет результаты. Тому, кто пользуется этой службой, не нужно беспокоиться о том, на каком именно сервере хранится информация.
Чтобы код программы сильно не разрастался, а мы не отвлекались от обсуждаемой темы, будем пользоваться вторым (более простым) способом.
Поместим все эти маленькие запросы в одну большую программу и запустим ее. Итак, если нужно выполнить все приведенные выше подпрограммы с нашим примером сообщения:
use Mail:'Header: use Socket; use BerkeleyDB;
use Net::Telnet;
$header = new Mail-Header \*STDIN;
Sheader ->unfold('Received'); @received = $header->get('Received'):
Srbldomain = ".rbl.maps.vix.com" Sorbsdomain = ".relays.orbs.org";
Sduldomain = ".dul.maps.vix.com": Sblacklist = "/etc/mail/blacklist.db":
Swhoishost = "whois.geektools.com";
&loadblist;
for (reverse @received){ chomp;
parseline($_);
if (!defined $ehelo and !defined Svalidname and !defined $validip){ print "$Дп";
>
else {
Sflags = (&checkaddr($validip:$rbldomain) ? "R" : ""):
# в RBI/' $flags .= (&checkaddr($validip,$orbsdomairi) ? "0" : "");
в ORBS9 Sflags ,= (&checkaddr($validip. Sduldomain) ? "D......);
$flags .= (&checkblist($_) 9 "B" : ""): # в нашем спи
$flags .= (&checkrev($validip,$validname) ? "L" "");
(I rev-.;o.;k: push(@iplist,Svalidip);
write; } }
for (@iplist){
print "\nWHOIS info for $_:\n"; print &getwhois($_); >
format STDOUT =
@««««««««<«« @<«««««<'<««««««<«««««
Sehelo.Svalidname.Svalidip.Sflags
то будут получены такие результаты (слегка сокращенные):
login_0246.whynot.net mx.whynot.net 206.212.231 88 ;
extreme host-209-214-9-150 :r.a 209.214.9.150 Or
isiteinc.cori www.isiteinc.com 206,136 243 2
WHOIS info for 206,212.231.88:
WHOIS info for 209.214.9.150;
BellSouth.net Inc. (NETBLK-BELLSNET-BLK4)
1100 Ashwood Parkway
Atlanta. GA 30338
Netname: BELLSNET-BLK4
Netblock: 209.214.0.0 - 209.215.255.255
Maintainer: BELL
Coordinator-...
WHOIS info for 206.136.243.2:
Brainsell Incorporated (NET-ISITEINC)
4105-R Laguna St.
Coral Gaoles, FL 33146
US
Netname: ISITEINC Netnumber: 206.136.243.0
Coordinator:...
Гораздо лучше! Теперь нам известно:
Спамер дал неверные ответы HELO/EHLO.
Первый узел, по всей вероятности, фальшивый (не удалась попытка разыменования, и по нему нет информации WHOIS).
Сообщение, скорее всего, попало в сеть через соединение по телефонным линиям.
Два из этих адресов уже находятся в нашем черном списке.
ORBS они тоже не нравятся.
Кроме того, нам известна контактная информация для связи с провайдером.
Perl помог разобраться с непрошеной коммерческой почтой.
Впрочем, спам это очень неприятная вещь. Лучше перейдем к более приятной теме, например, к взаимодействию пользователей средствами электронной почты.
Увеличение почты в службу поддержки
Даже если у вас нет официальной службы поддержки, наверняка существует несколько адресов, куда пользователи могут посылать свои вопросы и сообщения о трудностях. У электронной почты, как средства для связи по вопросам поддержки, есть несколько преимуществ:
Все можно хранить и отслеживать, в отличие от разговоров в коридорах.
Электронная почта асинхронна; системный администратор может читать почту и отвечать на нее в более спокойные вечерние часы.
По желанию, это может быть индивидуальная, групповая или широковещательная рассылка. Если 14 человек пишут об одном и том же (скажем, об одних и тех же сообщениях спамеров), есть возможность ответить им всем одновременно, когда проблема будет решена.
Почту легко переслать тому, кто разбирается в обсуждаемом деле или ответственен за конкретные службы.
Все это веские причины использовать электронную почту для связи по вопросам поддержки. Однако есть у электронной почты и недостатки:
Если проблема касается самой почтовой системы или у пользователя что-то не ладится с электронной почтой, то для связи нужно применять что-то другое.
Пользователи могут и будут писать в сообщениях все что угодно. Нет никакой гарантии, что в письме будет информация, которая пригодится для решения проблемы или помощи пользователю. Возможно, вы даже не поймете, зачем нужно было такое сообщение. Это приводит к головоломке, о которой стоит поговорить в данном разделе.
Мое любимое письмо в службу поддержки приведу точно в таком виде, в каком оно было получено, за исключением имени автора:
Date: Sat, 28 Sep 1996 12:27:35 -0400 (EOT) From:
Special User <user@example.com> To:
systems@example.com Subject: [Req. 89531] printer help
something is wrong and I
have know idea what (что-то случилось, и я не имею понятия, что именно)
Если бы пользователь не упомянул слово «принтер» в теме сообщения, не было бы никаких указаний на то, с чего начать, и нам, вероятно, пришлось бы думать, что и впрямь случилось нечто ужасное. Конечно, это самый крайний случай. Чаще вы будете получать примерно такую почту:
From: Another user <user2®examplecom>
Subject: [Req 814563] broken macine
To. systems§exarriple com
Date: Wed, 11 Mar 1998 10:59:42 -0500 (EST)
С малиной krakatoa. example, com
Пользователи посылают подобные письма, лишенные содержания, не со зла. Мне кажется, что корень всех бед в полном несоответствии представлений о компьютерной среде у пользователей и системных администраторов.
Для большинства пользователей видимая структура компьютерной среды ограничена клиентской машиной, на которой они работают, соседним принтером и их хранилищем данных (т. е. домашним каталогом). Для системного администратора структура совсем иная. Он видит ряд серверов, предоставляющих услуги клиентам, у каждого из которых может быть множество периферийных устройств. На каждой машине может быть установлено различное программное обеспечение и все они могут находиться в различном состоянии (системная загрузка, конфигурация и т. д.).
Для пользователя вопрос «С какой машиной проблемы?» кажется странным. Они говорят об одном компьютере, о том, на котором работают сейчас.
Неужели это не очевидно? Системному администратору столь же странной кажется просьба «помогите с принтером»; в конце концов, он следит за многими принтерами.
Также обстоит дело и со спецификой проблемы. Системные администраторы всего мира каждый день скрежещут зубами, получая почту, в которой сказано: «Мой компьютер не работает, не могли бы вы помочь мне?». Они знают, что «не работает» может относиться к множеству симптомов, у каждого из которых есть свои причины. Для пользователя, столкнувшегося с тремя зависаниями компьютера за неделю, слова «не работает» выглядят вполне конкретными.
Один из способов разобраться с таким расхождением - четко определить, какие данные посылать в сообщениях. На некоторых сайтах пользователь должен послать сообщение о проблеме, употребляя определенную форму или приложение. Беда такого подхода в том, что пользователи редко испытывают удовольствие от лишних движений мышью и нажатий клавиш, необходимых только для того, чтобы сообщить о проблеме или задать вопрос. Чем больше усилий нужно приложить, тем меньше вероятность, что кто-то воспользуется таким механизмом. Неважно, насколько хорошо продумана форма и какой у нее дизайн, если никто не захочет ею пользоваться. Вопросы в коридорах снова станут нормой. Снова вернулись назад?
Что ж, если применить Perl, может быть и нет. Perl наверняка поможет увеличить количество нормальной почты и поучаствовать в процессе поддержки. Один из первых шагов системного администратора выяснить местоположение: «Где случилась проблема? С каким принтером? С каким компьютером?». И так далее.
Вот костяк программы, которую я назвал suss, представляющая собой «скелет» для сбора информации. Программа изучает сообщение и пытается выяснить, с какой машиной оно связано. В результате часто
можно определить имя узла для писем из категории «С моим компьютером проблемы», не вступая ради этого в дальнейшую беседу с рассеянным пользователем. Имя узла - хорошая отправная точка в процессе поиска возникших проблем.
Программа suss применяет очень простой алгоритм для разгадывания имени узла (обычно, поиск в хэше для каждого слова из сообщения). Сначала изучается тема сообщения, затем его тело и, наконец, выполняется поиск по заголовкам
Received:. Вот упрощенная версия, считывающая файл /etc/hosts, чтобы определить имена узлов:
use Mail::Internet; $localdomain = ".example.com";
ft считываем файл /etc/hosts
open(HOSTS,"/etc/hosts") or die "He могу открыть файл узлов\п";
while(defined($_ = <HOSTS>)){
next if /"ft/; ft пропускаем комментарии
next if /"$/; ft пропускаем пустые строки
next if /monitor/i; ft пример вводящего в заблуждение узла
ft выделяем первое имя узла и переводим его в нижний регистр
Smachine = lc((split)[1]);
$machine =~ s/\Q$localdomain\E$//oi;
t удаляем имя домена
$macriines{$machine}++ unless $macnines{$machine}; }
ft анализируем сообщение
$message = new Mail: :Internet VSTDIN;
$message->head->unfold();
ft проверяем тему сообщения
my Ssubject = $message->head->get('Subject');
Ssubject =' s/[.,;?]//g;
for (split(/\s+/,Ssubject)) {
if (exists $machines{lc $_}) {
print "subject: $_\n";
$found++; } } exit if $found;
ft проверяем тело сообщения
chomp(my @body = @{$message->body()}):
my Sbody = join(" ",@body);
$body =" s/t"\w\s]/ /g: и удаляем знак
@body{split( ', lc $bcdy)i = ().
for (keys %body) {
if (exists $machines!ic $_}) {
print "body: $_\n";
$*ound+-i-; } }
exit if $found,
# последняя надежда: проверяем последнюю строку
Received: Sreceived -(reverse $message->head->get('Received'))[0];
Sreceived =" s/\0$localdomain\E//g; for (split(/\s+/,Sreceived)) {
if (exists $machines{lc $_}) { print "received: $_\n";
}
Несколько комментариев к программе:
Простота проверки становится проблемой, когда мы сталкиваемся с вполне приемлемыми именами узлов, подобных monitor. Если имена узлов, являющиеся обычными словами, могут появиться в сообщениях, вам придется либо специально их обработать, как было сделано с next if /monitor/i, либо придумать более сложную схему анализа, что предпочтительнее.
Мы используем срез хэша (§body{...}), чтобы ускорить поиск по телу сообщения. За один шаг из сообщения выделяются все уникальные слова. Чтобы разобраться с этой конструкцией, можно прочитать ее изнутри. Во-первых, split() возвращает из сообщения список всех «слов» (в нижнем регистре). Эти слова используются как ключи для хэша %body. Поскольку имена ключей в хэше повторяться не могут, он будет содержать только уникальные слова из тела сообщения. Именно подобные возможности делают программирование на Perl приятным.
Теперь применим эту программу. Вот два настоящих сообщения в службу поддержки:
Received: from strontium.example.com
(strontium.example.com [192.168.1.114])
by mailhub.example.com (8.8.4/8.7.3) with ESMTP id RAA27043
for <systems>; Thu, 27 Mar 1997 17:07:44 -0500 (EST)
From: User Person <user@example.com>
Received: (user@localhost)
by strontium.example.com (8.8.4/8.6.4) id RAA10500 for systems;
Thu, 27 Mar 1997 17:07:41 -0500 (EST)
Message-Id: <199703272207.RAA10500@strontium.example.com
Subject: [Req #11509] Monitor
To: systems@example.com
Date: Thu, 27 Mar 1997 17:07:40 -0500 (EST)
Hi,
My monitor is flickering a little bit and it is tiresome
when working with it to much.
Is it possible to fix it or changing the monitor?
Thanks. User,
Received: from example.com (user2@example.com [192.168.1.7])
by mailhost.example.com (8.8.4/8.7.3) with SMTP id SAA00732
for <systems@example.com>: Thu. 27 Mar 1997 18:34:54 -0500 (EST)
Date: Thu, 27 Mar 1997 18:34:54 -0500 (EST)
From: Another User <user2@example.com>
To: systems@example.com
Subject: [Req 811510] problems with two computers
Message-Id: <Pine.SUN.3.95.970327183117,23440A-100000ffiexamole.com>
In Jenolen (in room 292), there is a piece of a disk stuck in it.
In intrepid, there is a disk with no cover
(or whatever you call that silver thing) stuck in it.
We tried to turn off intrepid, but it wouldn't work.
Wo (the proctor on duty and I) tried to get the disk piece out, but it didn't. work.
The proctor in charge decided to put signs on them saying 'out of order'
AnotherUser После запуска программы для этих двух сообщений мы получили:
received: strontium и:
body: jenolen body: intrepid
Оба узла были найдены верно и для этого понадобился лишь небольшой отрывок простого кода. Шагнем дальше и предположим, что поступило такое письмо:
Received: from [192.168.1.118]
(buggypeak.example.com [192.168.1.118])
by mailhost.example.com (8.8.6/8.8.6)
with SMTP id JAA16638 for <systems>;
Tue, 4 Aug 1998 09:07:15 -0400 (EOT)
Message-Id: <v02130502b1ecb78576a9@[192.168.1.118]>
Date: Tue, 4 Aug 1998 09:07:16 -0400
To: systems@example.com
From: user@example.com (Nice User)
Subject: [Req «15746] printer
Could someone please persuade my printer to behave and print like
printer should9 Thanks much :)
-Nice User.
Пользователь, должно быть, не знает, что вы «пасете стадо» из 30 принтеров. Но можно применить Perl и чуть-чуть наблюдательности,
чтобы сделать умные догадки. Пользователи стараются печатать на принтерах, расположенных ближе всего к тому компьютеру, за которым в данный момент работают. Если бы можно было определить машину, с которой отправлена почта, вероятно, удалось бы вычислить и принтер. Существует много способов получить информацию о связи компьютер-принтер, например, из отдельного файла, из поля в базе данных узлов, о которой упоминалось в главе 5, или даже из службы каталогов LDAP. Вот простой пример, в котором используется простая база данных компьютеров и связанных с ними принтеров:
use Mail: .'Internet; use DB_File;
Slocaldomain = ".example.com";
# printdb - это файл Berkeley DB.
Ключи - имена узлов, значения - принтеры Sprintdb = "printdb";
п анализируем сообщение
Smessage = new Mail::Internet \*STDIN;
$message->head->unfold();
# проверяем тему сообщения
my Ssubject = $<nessage->head->get('Subject');
if (Ssubject =" /print(er|ing)?/i){
ff ищем машину-отправителя (ситаем, что используется формат заголовков Sendmail)
$received = (reverse $rr,essage->head->get( 'Received' ))[0];
($host) =
$received =" /"from \S+ \((?:\S+@)?(\S+)\Q$localdomain\E \[/; }
tie %printdb, "DB_File",Sprintdb or die "Невозможно подключиться к базе данных
Sprintdb:$!\n";
print "Проблема на машине Shost может быть связана с принтером " .
$pnntdb{$host} . "Дп";
untie %printdb;
Если в теме сообщения упоминаются слова «печать», «принтер» или «напечатать», мы выделяем имя узла из заголовка Received:. Для получения этой информации можно применить одно регулярное выражение, т. к. известен формат, используемый для заголовков Received: в нашей сети. Зная имя узла, нетрудно найти связанный с ним принтер в базе данных Berkeley DB. Конечный результат выглядит так:
Проблема на машине buggypea* может быть связана с niroshige. Потратив время на изучение структуры своего окружения, вы найдете разные способы получать больше пользы от почты, доставленной в службу поддержки. Приведенные в этом разделе примеры невелики и созданы для того, чтобы заставить вас задуматься о возможностях. Как еще могут помочь программы, читающие почту (возможно, это почта, отправленная другими программами)? Perl предоставляет много способов проанализировать почту, рассмотреть ее в широком контексте и затем использовать найденную информацию.
Распространенные ошибки при отправке почты
Что ж, можно приступить к использованию электронной почты для отправки извещений. Однако когда мы начнем писать программы для выполнения этой функции, то быстро обнаружим, что вопрос как посылать почту, отнюдь не так интересен, как вопросы когда и что посылать.
В данном разделе мы исследуем эти вопросы, действуя «от противного». Если рассмотреть, что и как не надо посылать, то сами вопросы можно изучить глубже. Так что поговорим об ошибках, допускаемых наиболее часто при написании программ системного администрирования, отправляющих почту.
Слишком частая отправка сообщений
Самая распространенная ошибка - это отправка слишком большого количества сообщений. Иметь сценарии, отправляющие почту, вообще говоря, отличная идея. Если с какой-либо службой случится что-то неприятное, то отправка обычного электронного сообщения или сообщения на пейджер - очень хороший способ привлечь внимание человека к случившейся проблеме. Но в большинстве случаев, раз в пять минут отправлять по сообщению о неприятностях - это очень плохое решение. Слишком усердные почтовые генераторы очень быстро попадают в почтовые фильтры тех, кто должен был их читать. В результате оказывается, что важная почта просто игнорируется.
Контроль над частотой отправки почты
Самый простой способ избежать лишней почты - добавить в программу меры предосторожности, чтобы устанавливать задержку между сообщениями. Если сценарий запущен постоянно, то очень просто запомнить время отправки последнего сообщения:
$last_sent = time;
Если программа запускается один раз в N минут или часов через сгоп в Unix или механизмы планирования задач NT, эту информацию можно переписать в файл, состоящий из одной строки, и считывать его при следующем запуске программы. В подобном случае обязательно обратите внимание на меры предосторожности, перечисленные в главе 1 «Введение».
В зависимости от ситуации можно поэкспериментировать с временем задержки. В этом примере показана экспоненциальная задержка (exponential backoff):
$max = 24*60*60; и максимальная задержка в секундах (1 день)
Sunit = 60;
увеличиваем задержку относительно этого значения (1минута)
# интервал времени, прошедший с момента отправки предыдущего
# сообщения и последняя степень 2, которая использовалась для
# расчета интервала задержки. Созданная нами подпрограмма
# возвращает ссылку на анонимный массив с этой информацией
sub time_closure {
my($stored_sent,$stored_power)=(0,-1); return sub {
(($stored_sent,$stored_power) = @_) if @_; [$stored_sent,$stored_power]; > };
$last_data=&time_closure; # создаем замыкание
ft возвращаем значение "истина" при первом вызове и затем после
# задержки
sub expbackoff {
my($last_sent,$last_power) = @{&$last_data};
# возвращаем true, если это первое наше обращение или если
# текущая задержка истекла с тех пор, как мы спрашивали
последний раз. Если мы возвращаем значение true, мы
запоминаем время последнего утвердительного ответа и
увеличиваем степень двойки, чтобы вычислить задержку.
if (!$last_sent or ($last_sent +
(($unit -.$last_power >= $max) 9
$max : $unit * 2**$last_power) <= time())){
&$last_data(time().++$last„power); return 1;
}
else {
return 0; } >
Подпрограмма expbackoffQ возвращает значение true (1), если нужно отправить сообщение, и false (0), если нет. При первом вызове она возвращает true, а затем быстро увеличивает время задержки до тех пор, пока значение t rue не станет появляться лишь раз в день.
Чтобы сделать программу более интересной, я применил необычную конструкцию под названием замыкание (closure) для хранения времени последней отправки сообщения и последней степени двойки, используемой для расчета задержки. Замыкание используется как способ скрытия важных переменных от остальной программы. В данной маленькой программе это было сделано из любопытства, но польза от такой технологии очень быстро становится очевидной в программах большего размера, где более вероятно, что другой код может случайно перезаписать значения этих переменных. Вот, вкратце, как работают замыкания.
Подпрограмма &time_closure() возвращает ссылку на анонимную подпрограмму, по существу, на небольшой отрывок кода без имени. Позже данная ссылка будет вызывать этот код, используя стандартный синтаксис символических ссылок: &$last_data. Код из анонимной подпрограммы возвращает ссылку на массив, поэтому и используется такая масса знаков пунктуации, чтобы получить доступ к возвращаемым данным:
my($last_sent,$last_power) = @{&$last_data};
Вот и вся тайна, которая скрывается за замыканиями: поскольку ссылка создается в том же блоке, что и переменные $stored_seri: и $sto-red_power (посредством my()), то они схватываются в уникальном контексте. Переменные $stored_sent и $stored_power можно прочитать и изменить только при выполнении кода из этой ссылки. Кроме того, они сохраняют свои значения между вызовами. Например:
создаем замыкание $last_data=&time._closure:
вызываем подпрограмму, устанавливающую значения переменных
&$last_data(1,1);
и пытаемся изменить их за пределами подпрел раммы
$stored__sent - $stored_power = 2:
выводим их текущие значения, используя подпрограмму
print "@{&$last_data}\n":
Результатом выполнения этого кода будет "1 1", хотя и создается впечатление, что в третьей строке были изменены значения переменных $stored_sent и $stored_power. Да, значения глобальных переменных с теми же именами были изменены, но невозможно затронуть копии, защищенные замыканиями.
Можно говорить о переменной из замыкания как о спутнике на орбите планеты. Спутник удерживается гравитацией планеты, так что куда движется планета, туда перемещается и спутник. Позицию спутника можно описать только относительно планеты: чтобы найти спутник, сначала нужно отыскать планету. Каждый раз, когда вы находите планету, там же будет и спутник, на том же месте, где был и прошлый раз. Можно считать, что переменные из замыкания находятся на орбите вокруг ссылки на анонимную подпрограмму, отдельно от вселенной остальной программы.
Но оставим астрофизику в покое и вернемся к рассуждениям об отправке почты. Иногда лучше, чтобы программа вела себя как двухлетний ребенок, жалующийся с течением времени все чаще. Вот еще одна программа, похожая на предыдущий пример. На этот раз со временем увеличивается количество дополнительно посылаемых сообщений. Начинаем мы с отправки сообщений один раз в день, а затем уменьшаем время задержки до тех пор, пока минимальная задержка не станет равной пяти минутам:
$тах = 60*60»24;
максимальная задержка в секундах (1 день)
$min = 60*5; tt минимальная задержка в секундах (5 минут)
$unit = 60; tt уменьшаем задержку относительно этого значения (1 минута)
$start_power = int log($max/$unit)/log(2): # ищем ближайшую степень двойки
sub time_closure {
my($last_sent,$last_power)=(0,$start_power+l); return sub {
(($last_sent, $last_p<wer) = @_) if ё>_; n keep exponent positive
$last_power = ($last_power > 0) 9
$last:_power : 0; [Siast^sent,$last_power]; } };
$last_data=&t ime_clusiire;
n создаем замыкание
возвращаем ггче
при первом вызове и затем после роста
it экспоненты sub exprampup {
my($last_sent,$last_power) = @{&$last_data}.
возвращаем true, если это первое обращение или если
текущая задержка истекла с момента последнего обиащен/я.
Если сообщение отправляется, то мш запоминаем время
последнего ответа и увеличиваем
$min : $unit * 2**$last_power) <= time())){
&$last_data(time(),++$last_power1): return 1;
}
else
{
return 0; } }
В обоих примерах вызывалась дополнительная подпрограмма (&$last_data), которая позволяла выяснить, когда было отправлено последнее сообщение и как вычислялась задержка. Позже, при необходимости изменить программу, такое деление позволит изменить способ хранения состояния. Например, если переписать программу так, чтобы она выполнялась периодически, а не постоянно, то замыкание совсем нетрудно заменить обычной подпрограммой, сохраняющей нужные данные в текстовом файле и потом считывающей их оттуда.
Контролируем количество сообщений
Другая разновидность синдрома «чрезмерной отправки почты» - это проблема «каждый в сети за себя». Если все машины из сети решат послать вам чуточку почты, вы вполне можете пропустить что-то действительно важное в этом потоке сообщений. Было бы лучше, если бы все сообщения отправлялись в центральный репозиторий. А затем в собранном виде почта поступала бы в одном сообщении.
Давайте рассмотрим несколько надуманный пример. Предположим, что каждая машина в сети записывает в разделяемый каталог файл, состоящий из одной строки. Имя каждого файла совпадает с именем машины и в каждом из них хранятся результаты научных вычислений, сделанных прошлой ночью. В файле будет одна строка следующего формата:
имя-узла
удача-или-неудача
количество-завершенных-вычислений
Программа, проверяющая эту информацию и отсылающая результаты, может выглядеть так:
use Mail::Mailer; use Text::Wrap;
tf список машин, отправляющих сообщения
$repolist = "/project/machinelist";
ft каталог, куда они записывают файлы
Srepodir = "/project/reportddir";
it
разделитель файловой системы, используется для переносимости.
Можно было бы использовать модуль File::Spec
$separator= "/";
# отправляем почту "с" этого адреса
$reportfromaddr = "project\@example. corn";
# отправляем почту на этот адрес Sreporttoaddr = "project\@example.com";
tf считываем список машин в хэш. Позже будем вынимать из этого
# хэша по мере доклада машин, оставив только те машины, которые
не принимали участие в действии
open(LIST,$repolist) or die "Невозможно открыть список
$repolist:$!\n"; while(<LIST>){
chomp;
$missing{$_}=1;
$machines++; }
# считываем все файлы из центрального каталога
и замечание: этот каталог должен автоматически очищаться другим
# сценарием
opendir(REPO,Srepodir) or die "Невозможно открыть каталог $repodir:$!\n";
while(defined($statfile=readdir(REPO))){
next unless -f Srepodir.$separator.$statfile;
# открываем каждый файл и считываем информацию о состоянии
open(STAT,$repodir.$separator.$statfile) or die "Невозможно открыть Sstatfile:$!\n";
chornp($report = <STAT>);
($hostname.$result,$details)=spiit(' ',$report,3);
warn " В файле Sstatfile утверждается, что он был сгенерирован машиной
Shostname1 \n" if($hostname ne Sstatfile);
имя узла больше не считается пропущенным
delete $missing{$nostname}; # заполняем значениями хэши
(Sresult eq "success")}
$success{$nostname}=$details;
$succeeded++: } else {
$fail{$hostname}=$details:
$failed++; }
close(STAT); } closedir(REPO);
# создаем информативный заголовок для сообщения if (Ssucceeded == $machines){
Ssubject = "[report] Success: $machines"; }
elsif ($failed == Smachines or scalar keys %missing >= Smachines) {
Ssubject = "[report] Fail: Smachines"; } else
{ ;
Ssubject = "[report] Partial: Ssucceeded ACK, Sfailed NACK".
((%missing) ? ", ".(scalar keys %missing)1." MIA" : ""); }
# создаем объект mailer и заполняем заголовки $type="sendmail";
my Smaller = Mail::Mailer->new($type) or die "Невозможно создать новый объект:$!\п";
$mailer->open({From=>$reportf romaddr,
To=>$reporttoaddr. Subject=>$subject})! or die "Невозможно заполнить объект mailer:$!\n";
» создаем тело сообщения !
print $mailer "Run report from $0 on " . scalar localtime(tine) . "\n":
if (keys %success){
print Smaller "\n==Succeeded==\n";
foreach $hostname (sort keys %success){
print Smaller "$hostname: $success{$hostname}\n":
} } 308
if (keys %fail){
print Smaller "\n==Failed==\n";
foreach Snostname (sort, keys %fail){
print Smaller "Shostname: $fail{$hostname}\n"
} }
if (keys %missing){
print Smaller "\n==Missing==\n";
print Smaller wrap("","".join(" ".sort keys %missing)),"\n"; }
# отправляем сообщение $mailer->close;
Сначала программа считывает список имен машин, участвующих в данном предприятии. Затем, чтобы проверить, встречались ли машины, не поместившие файл в общий каталог, используется хэш, созданный на основе этого списка. Мы открываем каждый файл из данного каталога и выделяем из него информацию о состоянии. Получив результаты, создаем сообщение и отправляем его.
Получается такой отчет:
Date: Wed, 14 Apr 1999 13:06:09 -0400 (EOT)
Message-Id: <199904141706.NAA08780@example.com> Subject: [report]
Partial: 3 ACK, 4 NACK, 1 MIA To: project(s>example. con From: project@example.com
Run report from reportscript on Wed Apr 14 13:06:08 1999
==Succeeded==
barney: computed 23123 oogatrons betty: computed 6745634
oogatrons fred: computed 56344 oogatrons
==Failed==
bambam: computed 0 oogatrons dino: computed 0
oogatrons pebbles: computed 0
oogatrons wilma: computed 0 oogatrons
==Missing== mrslate
Другой способ изучить подобные результаты состоит в том, чтобы создать демон журналов регистрации и посылать отчет от каждой машины через сокет. Сначала взгляните на код для сервера. Он совпадает с кодом из предыдущего примера. Рассмотрим новую программу и обсудим ее важные особенности:
use 10::Socket;
use Text::Wrap: ft используется для создания аккуратного вывода
список машин, посылающих отчеты Srepolist = "/project/machinelist":
номер порта для соединения с клиентами Sserverport = '9967' ;
Sloadmachines: # загружаем список ма^ин
# настраиваем нашу сторону сокета
Sreserver = 10::Socket::INET->new(LocalPort => Sserverport,
Proto => "tcp",
Type => SOCK_STREAM,
Listen => 5,
Reuse => 1) or die "Невозможно настроить сокет на нашей стороне: $!\п";
и начинаем слушать порт в ожидании соединений while(
($connectsock,Sconnectaddr) = $reserver->accept()){
# имя подсоединившегося клиента
Sconnectname = gethostbyaddr((sockaddr_in($connectadar))[1],AF_INЈT):
chomp($report=$connectsock->getline);
($hostname,$result,$details)=split(' ',$report,3);
в если нужно сбросить информацию, выводим готовое к
# отправке сообщение и заново инициализируем все
хэши/счетчики
if (Shostname eq "DUMPNOW'H
&printmail($connectsock);
close($connectsock):
undef %success;
undef %fail:
Ssucceeded = Sfailed = 0:
&loadmachines;
next: }
warn "$connectname говорит, что был сгенерирован $nostnarce' \r-."
if($hostname ne Sconnectnaiie): delete $n;issiP.g{Shostna"rie}:
($result eq "success")!
$success{Shostnare}=$deraiIs:
$succeeded++: / else 1
$fail{$hostrame}=$dera;ls:
$fai!ed++. }
close($connectsock); } close($reserver):
# загружаем список машин из заданного файла sub loadmachines
undef %missing;
undef Smachines;
open(LIST,$repolist) or die "Невозможно открыть список Srepolist:$!\n";
while(<LIST>){
chomp;
$missing{$_}=1;
$machines++; } }
выводим готовое к отправке сообщение. Первая строка - тема,
# последующие строки - тело сообщения sub printmail<
(Ssocket) = $_[0];
if (Ssucceded == $machines){
Ssubject = "[report] Success: Smachines"; }
elsif ($failed == Smachines or scalar keys %missing >= Smachines) {
Ssubject = "[report] Fail: Smachines"; } else {
Ssubject = "[report] Partial: Ssucceeded ACK, Sfailed NACK".
((%missing) ? ", ".(scalar keys %missing)1." MIA" : ""); }
print Ssocket "$subject\n":
print Ssocket "Run report from $0 on ".scalar localtime(time)."\n";
if (keys %success){
print Ssocket "\n==Succeeded==\n";
foreach Shostname (sort keys %success){ print
Ssocket "Shostname: $success{$hostname}\n":
}
}
if (keys %fail){ print Ssocket "\n==Failed==\n":
foreach Shostname (sort keys %fail)< print $socket "Shostname: $fail{$hostname}\n"; } }
if (keys %nissing){ print Ssocket " \n==Missing==\n":
print $socket wrapC"1."" join(" ".sort keys Vrissi^g) ).'"
}
Кроме переноса части кода в отдельные подпрограммы, главное изменение заключается в том, что добавлен код для работы с сетью. Модуль 10: : Socket позволяет без труда открывать и использовать сокеты, которые можно сравнить с телефоном. Сначала нужно установить свою сторону сокета (10: :Socket->new()), как бы включая свой телефон, а затем ждать «звонка» от клиента (10: :Socket»accept()). Программа приостановлена (или «заблокирована») до тех пор, пока не установлено соединение. Когда соединение установлено, запоминается имя подсоединившегося клиента. Затем из сокета считывается строка ввода.
Мы предполагаем, что строка ввода выглядит точно так же, как и строки из отдельных файлов в предыдущем примере. Единственное различие - это загадочное имя узла DUMPNOW. Если это имя встречается, подсоединившемуся клиенту выводится тема и тело готового к отправке сообщения, при этом сбрасываются все счетчики и хэш-таб-лицы. За отправку сообщения, полученного от сервера, ответственен клиент. Теперь посмотрим на пример клиента и узнаем, что он может сделать с этим сообщением:
use 10::Socket;
номер порта для соединения с клиентом
Sserverport = "9967";
и имя сервера
$servername = "reportserver";
ft преобразуем имя в IP-адрес
Sserveraddr = inet_ntoa(scalar gethostbyname($servername));
Sreporttoaddr = "project\@example.com";
Sreportf romaddr = "project\(g>example.com";
Sreserver = 10::Socket::INET->new(PeerAddr => Jserveraddr.
PeerPort => $serverport Proto => "tcp". Type => SCCK^STREAM) or ale
"Невозможно создать сокет -а нашей стороне:: $!\п":
if ($ARGV;;0] re "-ni"){
print Sreserver $ARGV[0]: v else {
use Mail::Mailer;
print Sreserver "DUMPNOW\T;
chomp($subject = <$reserver.>) $body = join("",<$reserver>);
$type="send!rmil";
my Smaller = Mail::Mailer->new($type) or die
"Невозможно создать новый обьект niailer-$' \n";
$mailer->open({
From => $reportfromaddr To => $reporttoaddr, Subject => Ssubject » or die
"Невозможно заполнить объект mailer:$!\n";
print Smaller $body; $mailer->close; }
close($reserver);
Эта программа проще. Сначала открывается сокет с сервером. В большинстве случаев ему передается информация о состоянии (полученная в командной строке как $ARGV[0]) и соединение закрывается. При желании создать клиент-серверную систему регистрации, подобную этой, вероятно, нам пришлось бы перенести данный клиентский код в подпрограмму и вызывать ее из другой, гораздо более крупной.
Если передать сценарию ключ -т, он отправит серверу «DUMPNOW» и прочитает полученную от него строку темы сообщения и тело сообщения. Затем этот вывод передается модулю Mail: : Mailer и отправляется в виде почтового сообщения при помощи той же программы, которую мы видели раньше.
Для ограничения размера примера и для того, чтобы не уходить в сторону от дискуссии, здесь представлен лишь костяк кода для клиента и сервера. В нем нет ни проверки ошибок или ввода, ни управления доступом, ни авторизации (в сети любой, получивший доступ к серверу, может взять с него данные), ни постоянного хранилища данных (а что, если машина не работает?), ни даже мало-мальских мер предосторожности. Мало того, в каждый момент времени можно обрабатывать только один запрос. Если клиент остановится в середине транзакции, мы «влипли». Более изощренные примеры можно найти в книгах «Advanced Perl Programming» (Углубленное программирование на Perl) Шрирама Шринивасана (Sriram Srinivasan) и «Perl Cookbook» («Perl: Библиотека программиста») Тома Кристиансена (Tom Christiansen) и Натана Торкингтона (Nathan Torkington), обе выпущены издательством O'Reilly. Модуль Net:: Daemon Джошена Вьедмана (Jochen Wi-edmann) также поможет создавать более сложные программы-демоны.
Однако пора вернуться к рассмотрению других ошибок, допускаемых в программах для системного администрирования, отправляющих почтовые сообщения.
Пропуск темы сообщения
Строка Subject:- это такая «вещица», которую не стоит пропускать. При автоматической отправке почты можно на лету создавать информативную строку
Subject: для каждого сообщения. Так что практически нет прощения тому, кто отправляет в почтовый ящик сообщения с заголовками:
Super-User File history database merge report
Super-User File history database merge report
Super-User File history database merge report
Super-User File history database merge report
Super-User File history database merge report
Super-User File history database merge report
Super-User File history database merge report
в то время как они могли бы выглядеть так:
Super-User Backup OK, 1 tape, 1.400 GB written.
Super-User Backup OK, 1 tape, 1.768 GB written.
Super-User Backup OK, 1 tape, 2.294 GB written.
Super-User Backup OK, 1 tape, 2.817 GB written.
Super-User Backup OK, 1 tape, 3.438 GB written.
Super-User Backup OK, 3 tapes, 75.40 GB written.
Строка Subject: должна содержать краткую и четкую информацию, описывающую происходящее. Из темы сообщения должно быть очевидно, докладывает ли программа об успехе, неудаче или о чем-то среднем. Незначительные добавочные усилия с лихвой окупаются экономией времени при чтении почты.
Недостаточная информация в теле сообщения
Эта ошибка попадает в ту же категорию, что и предыдущая. Если сценарий собирается сообщать о проблемах или ошибках в почтовых сообщениях, значит сгенерировать какую-то информацию, которая должна там присутствовать. Они сводятся к каноническим вопросам журналистики:
Кто?
Какой сценарий сообщает об ошибке? Добавьте содержимое переменной $0 (если не устанавливали ее явно), чтобы показать полный путь к текущему сценарию. Сообщите о версии сценария, если таковая у него имеется.
Где?
Сообщите что-то о том месте в сценарии, где возникает проблема. Функция caller () из Perl возвращает всю нужную для этого информацию:
замечание: то, что возвращает са!1ег(). может зависеть от
версии Perl, так что обязательно загляните в документацию по perlfunc
(Spackage, $filename, $line, $subroutine, Shasargs,
$wantarray, Sevaltext, $is_require) = caller($frames);
Где $f rames - это количество нужных фреймов на стеке (если вызывались подпрограммы из подпрограмм). Чаще всего вы будете устанавливать $f rames в 1. Вот пример списка, возвращаемого функцией caller() в середине кода для сервера из последнего полного примера:
('main','repserver1,32,'main:iprintmail1,1,undef)
Подобная запись указывает, что сценарий, запущенный из файла repserver в строке 32, находился в пакете main. В этот момент выполнялся код из подпрограммы main: .printmail (у нее есть аргументы, кроме того, она не вызывается в списочном контексте).
Если вы не хотите вручную применять caller(), можете воспользоваться отчетом о проблемах, предоставляемым модулем Carp.
Когда?
Опишите состояние программы в момент возникновения ошибки. К примеру, какой была последняя строка прочтенных данных?
Почему?
Если сумете, ответьте на незаданный читателем вопрос: «Зачем беспокоить меня этим почтовым сообщением?» Ответ может быть очень простым, например: «данные об учетных записях не были полностью обработаны», «DNS-сервер сейчас недоступен» или «в серверной пожар». Это даст читающему представление о предмете разговора (и, возможно, побудит к изучению).
Что?
Ну и наконец, надо сказать о том, что же пошло не так раньше всего. Вот небольшой пример на Perl, который охватывает все эти пункты:
use ext::Wrap;
sub problemreport {
9 $shortcontext - описание проблемы в одной строке
# Susercontext - подробное описание проблемы Получение почты 315
Snextstep - лучшее предположение о том, что делать, чтобы исправить
проблему
my($shortcontext,Susercontext,Snextstep) = @_: my
($filename, $line, Ssubroutine) = (caller(1) )[1,2,3]:
push(@return,"Проблема с Sfilename $shortcortext\n '):
push(@return,"** Сообщение о проблеме с Sfilename ***\n\n"):
push(@return,fill("","","- Проблема: Susercontext") "\r\n")
push(@return,"- Место: строка Sline файла Sfilename в
$subroutine\n\n"); push(@return,"- Произошла: ".scalar localtime(time)."\n\n");
push(@return,"- Дальнейшие действия: $nextstep\n"):
\@return; }
sub fireperson {
Sreport = &problemreport("компьютер горит ", «EOR, «EON);
При составлении отчета загорелась задняя часть компьютера.
Случилось это сразу же после обработки пенсионного плана для ORA. EOR
Пожалуйста, потушите пожар, а потом продолжайте работу. EON
print @{$report}; } &fireperson;
Обращение к &problemreport выведет, начиная с темы сообщения, отчет о проблеме, согласующийся с Mail: : Mailer, как и в предыдущих примерах.
Теперь, разобравшись с отправкой почты, перейдем к другой стороне медали.
Рекомендуемая дополнительная литература
«Advanced Perl Programming»,
Sriram Srinivasan (O'Reilly, 1997)- в книге есть хороший раздел о программировании серверов.
«Effective Perl Programming»,
Joseph Hall, Randal Schwartz (Addison Wesley, 1998) - полезная книга, в которой можно найти множество идиом Perl.
http://www.cauce.org/ -
сайт от Coalition Against Unsolicited Email (коалиция против непрошеной почты). Существует много сайтов, посвященных борьбе со спамом; этот сайт неплох для начала. Здесь можно найти ссылки на множество других ресурсов, включая те, на которых описан подробный аналиа почтовых заголовков.
http://www.eudora.com/developers/scripting.html -
содержит информацию по Eudora и ссылки на другие источники по AppleScript.
http://www.microsoft.com
и http://msdn.microsoft.com - содержат информацию по «MAPI», «active messaging» и «CDO». Названия этой технологии уже менялись дважды, так что я не решаюсь привести точную ссылку. На сайтах Microsoft содержится масса полезной информации (особенно в разделе про библиотеки MSDN) по этим темам, но она постоянно перемещается с места на место.
«Perl Cookbook»,
Tom Christiansen, Nathan Torkington (O'Reilly, 1998). В этой книге также рассматриваются вопросы программирования серверов.
«RFC821 .-Simple Mail Transfer Protocol»,
J. Postel, 1982.
«RFC822:Standard for the format of ARPA Internet text messages»,
D. Crocker, 1982.
«RFC954.-NICNAME/WHOIS»,
K. Harrenstien, M. Stahl, E. Feinler, 1985.
