|
1 # Net::SMTP.pm |
|
2 # |
|
3 # Copyright (c) 1995-1997 Graham Barr <gbarr@pobox.com>. All rights reserved. |
|
4 # This program is free software; you can redistribute it and/or |
|
5 # modify it under the same terms as Perl itself. |
|
6 |
|
7 package Net::SMTP; |
|
8 |
|
9 require 5.001; |
|
10 |
|
11 use strict; |
|
12 use vars qw($VERSION @ISA); |
|
13 use Socket 1.3; |
|
14 use Carp; |
|
15 use IO::Socket; |
|
16 use Net::Cmd; |
|
17 use Net::Config; |
|
18 |
|
19 $VERSION = "2.26"; # $Id: //depot/libnet/Net/SMTP.pm#31 $ |
|
20 |
|
21 @ISA = qw(Net::Cmd IO::Socket::INET); |
|
22 |
|
23 sub new |
|
24 { |
|
25 my $self = shift; |
|
26 my $type = ref($self) || $self; |
|
27 my $host = shift if @_ % 2; |
|
28 my %arg = @_; |
|
29 my $hosts = defined $host ? $host : $NetConfig{smtp_hosts}; |
|
30 my $obj; |
|
31 |
|
32 my $h; |
|
33 foreach $h (@{ref($hosts) ? $hosts : [ $hosts ]}) |
|
34 { |
|
35 $obj = $type->SUPER::new(PeerAddr => ($host = $h), |
|
36 PeerPort => $arg{Port} || 'smtp(25)', |
|
37 LocalAddr => $arg{LocalAddr}, |
|
38 LocalPort => $arg{LocalPort}, |
|
39 Proto => 'tcp', |
|
40 Timeout => defined $arg{Timeout} |
|
41 ? $arg{Timeout} |
|
42 : 120 |
|
43 ) and last; |
|
44 } |
|
45 |
|
46 return undef |
|
47 unless defined $obj; |
|
48 |
|
49 $obj->autoflush(1); |
|
50 |
|
51 $obj->debug(exists $arg{Debug} ? $arg{Debug} : undef); |
|
52 |
|
53 unless ($obj->response() == CMD_OK) |
|
54 { |
|
55 $obj->close(); |
|
56 return undef; |
|
57 } |
|
58 |
|
59 ${*$obj}{'net_smtp_exact_addr'} = $arg{ExactAddresses}; |
|
60 ${*$obj}{'net_smtp_host'} = $host; |
|
61 |
|
62 (${*$obj}{'net_smtp_banner'}) = $obj->message; |
|
63 (${*$obj}{'net_smtp_domain'}) = $obj->message =~ /\A\s*(\S+)/; |
|
64 |
|
65 unless($obj->hello($arg{Hello} || "")) |
|
66 { |
|
67 $obj->close(); |
|
68 return undef; |
|
69 } |
|
70 |
|
71 $obj; |
|
72 } |
|
73 |
|
74 ## |
|
75 ## User interface methods |
|
76 ## |
|
77 |
|
78 sub banner |
|
79 { |
|
80 my $me = shift; |
|
81 |
|
82 return ${*$me}{'net_smtp_banner'} || undef; |
|
83 } |
|
84 |
|
85 sub domain |
|
86 { |
|
87 my $me = shift; |
|
88 |
|
89 return ${*$me}{'net_smtp_domain'} || undef; |
|
90 } |
|
91 |
|
92 sub etrn { |
|
93 my $self = shift; |
|
94 defined($self->supports('ETRN',500,["Command unknown: 'ETRN'"])) && |
|
95 $self->_ETRN(@_); |
|
96 } |
|
97 |
|
98 sub auth { |
|
99 my ($self, $username, $password) = @_; |
|
100 |
|
101 require MIME::Base64; |
|
102 require Authen::SASL; |
|
103 |
|
104 my $mechanisms = $self->supports('AUTH',500,["Command unknown: 'AUTH'"]); |
|
105 return unless defined $mechanisms; |
|
106 |
|
107 my $sasl; |
|
108 |
|
109 if (ref($username) and UNIVERSAL::isa($username,'Authen::SASL')) { |
|
110 $sasl = $username; |
|
111 $sasl->mechanism($mechanisms); |
|
112 } |
|
113 else { |
|
114 die "auth(username, password)" if not length $username; |
|
115 $sasl = Authen::SASL->new(mechanism=> $mechanisms, |
|
116 callback => { user => $username, |
|
117 pass => $password, |
|
118 authname => $username, |
|
119 }); |
|
120 } |
|
121 |
|
122 # We should probably allow the user to pass the host, but I don't |
|
123 # currently know and SASL mechanisms that are used by smtp that need it |
|
124 my $client = $sasl->client_new('smtp',${*$self}{'net_smtp_host'},0); |
|
125 my $str = $client->client_start; |
|
126 # We dont support sasl mechanisms that encrypt the socket traffic. |
|
127 # todo that we would really need to change the ISA hierarchy |
|
128 # so we dont inherit from IO::Socket, but instead hold it in an attribute |
|
129 |
|
130 my @cmd = ("AUTH", $client->mechanism); |
|
131 my $code; |
|
132 |
|
133 push @cmd, MIME::Base64::encode_base64($str,'') |
|
134 if defined $str and length $str; |
|
135 |
|
136 while (($code = $self->command(@cmd)->response()) == CMD_MORE) { |
|
137 @cmd = (MIME::Base64::encode_base64( |
|
138 $client->client_step( |
|
139 MIME::Base64::decode_base64( |
|
140 ($self->message)[0] |
|
141 ) |
|
142 ), '' |
|
143 )); |
|
144 } |
|
145 |
|
146 $code == CMD_OK; |
|
147 } |
|
148 |
|
149 sub hello |
|
150 { |
|
151 my $me = shift; |
|
152 my $domain = shift || "localhost.localdomain"; |
|
153 my $ok = $me->_EHLO($domain); |
|
154 my @msg = $me->message; |
|
155 |
|
156 if($ok) |
|
157 { |
|
158 my $h = ${*$me}{'net_smtp_esmtp'} = {}; |
|
159 my $ln; |
|
160 foreach $ln (@msg) { |
|
161 $h->{uc $1} = $2 |
|
162 if $ln =~ /(\w+)\b[= \t]*([^\n]*)/; |
|
163 } |
|
164 } |
|
165 elsif($me->status == CMD_ERROR) |
|
166 { |
|
167 @msg = $me->message |
|
168 if $ok = $me->_HELO($domain); |
|
169 } |
|
170 |
|
171 return undef unless $ok; |
|
172 |
|
173 $msg[0] =~ /\A\s*(\S+)/; |
|
174 return ($1 || " "); |
|
175 } |
|
176 |
|
177 sub supports { |
|
178 my $self = shift; |
|
179 my $cmd = uc shift; |
|
180 return ${*$self}{'net_smtp_esmtp'}->{$cmd} |
|
181 if exists ${*$self}{'net_smtp_esmtp'}->{$cmd}; |
|
182 $self->set_status(@_) |
|
183 if @_; |
|
184 return; |
|
185 } |
|
186 |
|
187 sub _addr { |
|
188 my $self = shift; |
|
189 my $addr = shift; |
|
190 $addr = "" unless defined $addr; |
|
191 |
|
192 if (${*$self}{'net_smtp_exact_addr'}) { |
|
193 return $1 if $addr =~ /^\s*(<.*>)\s*$/s; |
|
194 } |
|
195 else { |
|
196 return $1 if $addr =~ /(<[^>]*>)/; |
|
197 $addr =~ s/^\s+|\s+$//sg; |
|
198 } |
|
199 |
|
200 "<$addr>"; |
|
201 } |
|
202 |
|
203 sub mail |
|
204 { |
|
205 my $me = shift; |
|
206 my $addr = _addr($me, shift); |
|
207 my $opts = ""; |
|
208 |
|
209 if(@_) |
|
210 { |
|
211 my %opt = @_; |
|
212 my($k,$v); |
|
213 |
|
214 if(exists ${*$me}{'net_smtp_esmtp'}) |
|
215 { |
|
216 my $esmtp = ${*$me}{'net_smtp_esmtp'}; |
|
217 |
|
218 if(defined($v = delete $opt{Size})) |
|
219 { |
|
220 if(exists $esmtp->{SIZE}) |
|
221 { |
|
222 $opts .= sprintf " SIZE=%d", $v + 0 |
|
223 } |
|
224 else |
|
225 { |
|
226 carp 'Net::SMTP::mail: SIZE option not supported by host'; |
|
227 } |
|
228 } |
|
229 |
|
230 if(defined($v = delete $opt{Return})) |
|
231 { |
|
232 if(exists $esmtp->{DSN}) |
|
233 { |
|
234 $opts .= " RET=" . ((uc($v) eq "FULL") ? "FULL" : "HDRS"); |
|
235 } |
|
236 else |
|
237 { |
|
238 carp 'Net::SMTP::mail: DSN option not supported by host'; |
|
239 } |
|
240 } |
|
241 |
|
242 if(defined($v = delete $opt{Bits})) |
|
243 { |
|
244 if($v eq "8") |
|
245 { |
|
246 if(exists $esmtp->{'8BITMIME'}) |
|
247 { |
|
248 $opts .= " BODY=8BITMIME"; |
|
249 } |
|
250 else |
|
251 { |
|
252 carp 'Net::SMTP::mail: 8BITMIME option not supported by host'; |
|
253 } |
|
254 } |
|
255 elsif($v eq "binary") |
|
256 { |
|
257 if(exists $esmtp->{'BINARYMIME'} && exists $esmtp->{'CHUNKING'}) |
|
258 { |
|
259 $opts .= " BODY=BINARYMIME"; |
|
260 ${*$me}{'net_smtp_chunking'} = 1; |
|
261 } |
|
262 else |
|
263 { |
|
264 carp 'Net::SMTP::mail: BINARYMIME option not supported by host'; |
|
265 } |
|
266 } |
|
267 elsif(exists $esmtp->{'8BITMIME'} or exists $esmtp->{'BINARYMIME'}) |
|
268 { |
|
269 $opts .= " BODY=7BIT"; |
|
270 } |
|
271 else |
|
272 { |
|
273 carp 'Net::SMTP::mail: 8BITMIME and BINARYMIME options not supported by host'; |
|
274 } |
|
275 } |
|
276 |
|
277 if(defined($v = delete $opt{Transaction})) |
|
278 { |
|
279 if(exists $esmtp->{CHECKPOINT}) |
|
280 { |
|
281 $opts .= " TRANSID=" . _addr($me, $v); |
|
282 } |
|
283 else |
|
284 { |
|
285 carp 'Net::SMTP::mail: CHECKPOINT option not supported by host'; |
|
286 } |
|
287 } |
|
288 |
|
289 if(defined($v = delete $opt{Envelope})) |
|
290 { |
|
291 if(exists $esmtp->{DSN}) |
|
292 { |
|
293 $v =~ s/([^\041-\176]|=|\+)/sprintf "+%02x", ord($1)/sge; |
|
294 $opts .= " ENVID=$v" |
|
295 } |
|
296 else |
|
297 { |
|
298 carp 'Net::SMTP::mail: DSN option not supported by host'; |
|
299 } |
|
300 } |
|
301 |
|
302 carp 'Net::SMTP::recipient: unknown option(s) ' |
|
303 . join(" ", keys %opt) |
|
304 . ' - ignored' |
|
305 if scalar keys %opt; |
|
306 } |
|
307 else |
|
308 { |
|
309 carp 'Net::SMTP::mail: ESMTP not supported by host - options discarded :-('; |
|
310 } |
|
311 } |
|
312 |
|
313 $me->_MAIL("FROM:".$addr.$opts); |
|
314 } |
|
315 |
|
316 sub send { my $me = shift; $me->_SEND("FROM:" . _addr($me, $_[0])) } |
|
317 sub send_or_mail { my $me = shift; $me->_SOML("FROM:" . _addr($me, $_[0])) } |
|
318 sub send_and_mail { my $me = shift; $me->_SAML("FROM:" . _addr($me, $_[0])) } |
|
319 |
|
320 sub reset |
|
321 { |
|
322 my $me = shift; |
|
323 |
|
324 $me->dataend() |
|
325 if(exists ${*$me}{'net_smtp_lastch'}); |
|
326 |
|
327 $me->_RSET(); |
|
328 } |
|
329 |
|
330 |
|
331 sub recipient |
|
332 { |
|
333 my $smtp = shift; |
|
334 my $opts = ""; |
|
335 my $skip_bad = 0; |
|
336 |
|
337 if(@_ && ref($_[-1])) |
|
338 { |
|
339 my %opt = %{pop(@_)}; |
|
340 my $v; |
|
341 |
|
342 $skip_bad = delete $opt{'SkipBad'}; |
|
343 |
|
344 if(exists ${*$smtp}{'net_smtp_esmtp'}) |
|
345 { |
|
346 my $esmtp = ${*$smtp}{'net_smtp_esmtp'}; |
|
347 |
|
348 if(defined($v = delete $opt{Notify})) |
|
349 { |
|
350 if(exists $esmtp->{DSN}) |
|
351 { |
|
352 $opts .= " NOTIFY=" . join(",",map { uc $_ } @$v) |
|
353 } |
|
354 else |
|
355 { |
|
356 carp 'Net::SMTP::recipient: DSN option not supported by host'; |
|
357 } |
|
358 } |
|
359 |
|
360 carp 'Net::SMTP::recipient: unknown option(s) ' |
|
361 . join(" ", keys %opt) |
|
362 . ' - ignored' |
|
363 if scalar keys %opt; |
|
364 } |
|
365 elsif(%opt) |
|
366 { |
|
367 carp 'Net::SMTP::recipient: ESMTP not supported by host - options discarded :-('; |
|
368 } |
|
369 } |
|
370 |
|
371 my @ok; |
|
372 my $addr; |
|
373 foreach $addr (@_) |
|
374 { |
|
375 if($smtp->_RCPT("TO:" . _addr($smtp, $addr) . $opts)) { |
|
376 push(@ok,$addr) if $skip_bad; |
|
377 } |
|
378 elsif(!$skip_bad) { |
|
379 return 0; |
|
380 } |
|
381 } |
|
382 |
|
383 return $skip_bad ? @ok : 1; |
|
384 } |
|
385 |
|
386 BEGIN { |
|
387 *to = \&recipient; |
|
388 *cc = \&recipient; |
|
389 *bcc = \&recipient; |
|
390 } |
|
391 |
|
392 sub data |
|
393 { |
|
394 my $me = shift; |
|
395 |
|
396 if(exists ${*$me}{'net_smtp_chunking'}) |
|
397 { |
|
398 carp 'Net::SMTP::data: CHUNKING extension in use, must call bdat instead'; |
|
399 } |
|
400 else |
|
401 { |
|
402 my $ok = $me->_DATA() && $me->datasend(@_); |
|
403 |
|
404 $ok && @_ ? $me->dataend |
|
405 : $ok; |
|
406 } |
|
407 } |
|
408 |
|
409 sub bdat |
|
410 { |
|
411 my $me = shift; |
|
412 |
|
413 if(exists ${*$me}{'net_smtp_chunking'}) |
|
414 { |
|
415 my $data = shift; |
|
416 |
|
417 $me->_BDAT(length $data) && $me->rawdatasend($data) && |
|
418 $me->response() == CMD_OK; |
|
419 } |
|
420 else |
|
421 { |
|
422 carp 'Net::SMTP::bdat: CHUNKING extension is not in use, call data instead'; |
|
423 } |
|
424 } |
|
425 |
|
426 sub bdatlast |
|
427 { |
|
428 my $me = shift; |
|
429 |
|
430 if(exists ${*$me}{'net_smtp_chunking'}) |
|
431 { |
|
432 my $data = shift; |
|
433 |
|
434 $me->_BDAT(length $data, "LAST") && $me->rawdatasend($data) && |
|
435 $me->response() == CMD_OK; |
|
436 } |
|
437 else |
|
438 { |
|
439 carp 'Net::SMTP::bdat: CHUNKING extension is not in use, call data instead'; |
|
440 } |
|
441 } |
|
442 |
|
443 sub datafh { |
|
444 my $me = shift; |
|
445 return unless $me->_DATA(); |
|
446 return $me->tied_fh; |
|
447 } |
|
448 |
|
449 sub expand |
|
450 { |
|
451 my $me = shift; |
|
452 |
|
453 $me->_EXPN(@_) ? ($me->message) |
|
454 : (); |
|
455 } |
|
456 |
|
457 |
|
458 sub verify { shift->_VRFY(@_) } |
|
459 |
|
460 sub help |
|
461 { |
|
462 my $me = shift; |
|
463 |
|
464 $me->_HELP(@_) ? scalar $me->message |
|
465 : undef; |
|
466 } |
|
467 |
|
468 sub quit |
|
469 { |
|
470 my $me = shift; |
|
471 |
|
472 $me->_QUIT; |
|
473 $me->close; |
|
474 } |
|
475 |
|
476 sub DESTROY |
|
477 { |
|
478 # ignore |
|
479 } |
|
480 |
|
481 ## |
|
482 ## RFC821 commands |
|
483 ## |
|
484 |
|
485 sub _EHLO { shift->command("EHLO", @_)->response() == CMD_OK } |
|
486 sub _HELO { shift->command("HELO", @_)->response() == CMD_OK } |
|
487 sub _MAIL { shift->command("MAIL", @_)->response() == CMD_OK } |
|
488 sub _RCPT { shift->command("RCPT", @_)->response() == CMD_OK } |
|
489 sub _SEND { shift->command("SEND", @_)->response() == CMD_OK } |
|
490 sub _SAML { shift->command("SAML", @_)->response() == CMD_OK } |
|
491 sub _SOML { shift->command("SOML", @_)->response() == CMD_OK } |
|
492 sub _VRFY { shift->command("VRFY", @_)->response() == CMD_OK } |
|
493 sub _EXPN { shift->command("EXPN", @_)->response() == CMD_OK } |
|
494 sub _HELP { shift->command("HELP", @_)->response() == CMD_OK } |
|
495 sub _RSET { shift->command("RSET")->response() == CMD_OK } |
|
496 sub _NOOP { shift->command("NOOP")->response() == CMD_OK } |
|
497 sub _QUIT { shift->command("QUIT")->response() == CMD_OK } |
|
498 sub _DATA { shift->command("DATA")->response() == CMD_MORE } |
|
499 sub _BDAT { shift->command("BDAT", @_) } |
|
500 sub _TURN { shift->unsupported(@_); } |
|
501 sub _ETRN { shift->command("ETRN", @_)->response() == CMD_OK } |
|
502 sub _AUTH { shift->command("AUTH", @_)->response() == CMD_OK } |
|
503 |
|
504 1; |
|
505 |
|
506 __END__ |
|
507 |
|
508 =head1 NAME |
|
509 |
|
510 Net::SMTP - Simple Mail Transfer Protocol Client |
|
511 |
|
512 =head1 SYNOPSIS |
|
513 |
|
514 use Net::SMTP; |
|
515 |
|
516 # Constructors |
|
517 $smtp = Net::SMTP->new('mailhost'); |
|
518 $smtp = Net::SMTP->new('mailhost', Timeout => 60); |
|
519 |
|
520 =head1 DESCRIPTION |
|
521 |
|
522 This module implements a client interface to the SMTP and ESMTP |
|
523 protocol, enabling a perl5 application to talk to SMTP servers. This |
|
524 documentation assumes that you are familiar with the concepts of the |
|
525 SMTP protocol described in RFC821. |
|
526 |
|
527 A new Net::SMTP object must be created with the I<new> method. Once |
|
528 this has been done, all SMTP commands are accessed through this object. |
|
529 |
|
530 The Net::SMTP class is a subclass of Net::Cmd and IO::Socket::INET. |
|
531 |
|
532 =head1 EXAMPLES |
|
533 |
|
534 This example prints the mail domain name of the SMTP server known as mailhost: |
|
535 |
|
536 #!/usr/local/bin/perl -w |
|
537 |
|
538 use Net::SMTP; |
|
539 |
|
540 $smtp = Net::SMTP->new('mailhost'); |
|
541 print $smtp->domain,"\n"; |
|
542 $smtp->quit; |
|
543 |
|
544 This example sends a small message to the postmaster at the SMTP server |
|
545 known as mailhost: |
|
546 |
|
547 #!/usr/local/bin/perl -w |
|
548 |
|
549 use Net::SMTP; |
|
550 |
|
551 $smtp = Net::SMTP->new('mailhost'); |
|
552 |
|
553 $smtp->mail($ENV{USER}); |
|
554 $smtp->to('postmaster'); |
|
555 |
|
556 $smtp->data(); |
|
557 $smtp->datasend("To: postmaster\n"); |
|
558 $smtp->datasend("\n"); |
|
559 $smtp->datasend("A simple test message\n"); |
|
560 $smtp->dataend(); |
|
561 |
|
562 $smtp->quit; |
|
563 |
|
564 =head1 CONSTRUCTOR |
|
565 |
|
566 =over 4 |
|
567 |
|
568 =item new Net::SMTP [ HOST, ] [ OPTIONS ] |
|
569 |
|
570 This is the constructor for a new Net::SMTP object. C<HOST> is the |
|
571 name of the remote host to which an SMTP connection is required. |
|
572 |
|
573 If C<HOST> is an array reference then each value will be attempted |
|
574 in turn until a connection is made. |
|
575 |
|
576 If C<HOST> is not given, then the C<SMTP_Host> specified in C<Net::Config> |
|
577 will be used. |
|
578 |
|
579 C<OPTIONS> are passed in a hash like fashion, using key and value pairs. |
|
580 Possible options are: |
|
581 |
|
582 B<Hello> - SMTP requires that you identify yourself. This option |
|
583 specifies a string to pass as your mail domain. If not |
|
584 given a guess will be taken. |
|
585 |
|
586 B<LocalAddr> and B<LocalPort> - These parameters are passed directly |
|
587 to IO::Socket to allow binding the socket to a local port. |
|
588 |
|
589 B<Timeout> - Maximum time, in seconds, to wait for a response from the |
|
590 SMTP server (default: 120) |
|
591 |
|
592 B<ExactAddresses> - If true the all ADDRESS arguments must be as |
|
593 defined by C<addr-spec> in RFC2822. If not given, or false, then |
|
594 Net::SMTP will attempt to extract the address from the value passed. |
|
595 |
|
596 B<Debug> - Enable debugging information |
|
597 |
|
598 |
|
599 Example: |
|
600 |
|
601 |
|
602 $smtp = Net::SMTP->new('mailhost', |
|
603 Hello => 'my.mail.domain' |
|
604 Timeout => 30, |
|
605 Debug => 1, |
|
606 ); |
|
607 |
|
608 =back |
|
609 |
|
610 =head1 METHODS |
|
611 |
|
612 Unless otherwise stated all methods return either a I<true> or I<false> |
|
613 value, with I<true> meaning that the operation was a success. When a method |
|
614 states that it returns a value, failure will be returned as I<undef> or an |
|
615 empty list. |
|
616 |
|
617 =over 4 |
|
618 |
|
619 =item banner () |
|
620 |
|
621 Returns the banner message which the server replied with when the |
|
622 initial connection was made. |
|
623 |
|
624 =item domain () |
|
625 |
|
626 Returns the domain that the remote SMTP server identified itself as during |
|
627 connection. |
|
628 |
|
629 =item hello ( DOMAIN ) |
|
630 |
|
631 Tell the remote server the mail domain which you are in using the EHLO |
|
632 command (or HELO if EHLO fails). Since this method is invoked |
|
633 automatically when the Net::SMTP object is constructed the user should |
|
634 normally not have to call it manually. |
|
635 |
|
636 =item etrn ( DOMAIN ) |
|
637 |
|
638 Request a queue run for the DOMAIN given. |
|
639 |
|
640 =item auth ( USERNAME, PASSWORD ) |
|
641 |
|
642 Attempt SASL authentication. |
|
643 |
|
644 =item mail ( ADDRESS [, OPTIONS] ) |
|
645 |
|
646 =item send ( ADDRESS ) |
|
647 |
|
648 =item send_or_mail ( ADDRESS ) |
|
649 |
|
650 =item send_and_mail ( ADDRESS ) |
|
651 |
|
652 Send the appropriate command to the server MAIL, SEND, SOML or SAML. C<ADDRESS> |
|
653 is the address of the sender. This initiates the sending of a message. The |
|
654 method C<recipient> should be called for each address that the message is to |
|
655 be sent to. |
|
656 |
|
657 The C<mail> method can some additional ESMTP OPTIONS which is passed |
|
658 in hash like fashion, using key and value pairs. Possible options are: |
|
659 |
|
660 Size => <bytes> |
|
661 Return => "FULL" | "HDRS" |
|
662 Bits => "7" | "8" | "binary" |
|
663 Transaction => <ADDRESS> |
|
664 Envelope => <ENVID> |
|
665 |
|
666 The C<Return> and C<Envelope> parameters are used for DSN (Delivery |
|
667 Status Notification). |
|
668 |
|
669 =item reset () |
|
670 |
|
671 Reset the status of the server. This may be called after a message has been |
|
672 initiated, but before any data has been sent, to cancel the sending of the |
|
673 message. |
|
674 |
|
675 =item recipient ( ADDRESS [, ADDRESS [ ...]] [, OPTIONS ] ) |
|
676 |
|
677 Notify the server that the current message should be sent to all of the |
|
678 addresses given. Each address is sent as a separate command to the server. |
|
679 Should the sending of any address result in a failure then the |
|
680 process is aborted and a I<false> value is returned. It is up to the |
|
681 user to call C<reset> if they so desire. |
|
682 |
|
683 The C<recipient> method can some additional OPTIONS which is passed |
|
684 in hash like fashion, using key and value pairs. Possible options are: |
|
685 |
|
686 Notify => |
|
687 SkipBad => ignore bad addresses |
|
688 |
|
689 If C<SkipBad> is true the C<recipient> will not return an error when a |
|
690 bad address is encountered and it will return an array of addresses |
|
691 that did succeed. |
|
692 |
|
693 $smtp->recipient($recipient1,$recipient2); # Good |
|
694 $smtp->recipient($recipient1,$recipient2, { SkipBad => 1 }); # Good |
|
695 $smtp->recipient("$recipient,$recipient2"); # BAD |
|
696 |
|
697 =item to ( ADDRESS [, ADDRESS [...]] ) |
|
698 |
|
699 =item cc ( ADDRESS [, ADDRESS [...]] ) |
|
700 |
|
701 =item bcc ( ADDRESS [, ADDRESS [...]] ) |
|
702 |
|
703 Synonyms for C<recipient>. |
|
704 |
|
705 =item data ( [ DATA ] ) |
|
706 |
|
707 Initiate the sending of the data from the current message. |
|
708 |
|
709 C<DATA> may be a reference to a list or a list. If specified the contents |
|
710 of C<DATA> and a termination string C<".\r\n"> is sent to the server. And the |
|
711 result will be true if the data was accepted. |
|
712 |
|
713 If C<DATA> is not specified then the result will indicate that the server |
|
714 wishes the data to be sent. The data must then be sent using the C<datasend> |
|
715 and C<dataend> methods described in L<Net::Cmd>. |
|
716 |
|
717 =item expand ( ADDRESS ) |
|
718 |
|
719 Request the server to expand the given address Returns an array |
|
720 which contains the text read from the server. |
|
721 |
|
722 =item verify ( ADDRESS ) |
|
723 |
|
724 Verify that C<ADDRESS> is a legitimate mailing address. |
|
725 |
|
726 =item help ( [ $subject ] ) |
|
727 |
|
728 Request help text from the server. Returns the text or undef upon failure |
|
729 |
|
730 =item quit () |
|
731 |
|
732 Send the QUIT command to the remote SMTP server and close the socket connection. |
|
733 |
|
734 =back |
|
735 |
|
736 =head1 ADDRESSES |
|
737 |
|
738 Net::SMTP attempts to DWIM with addresses that are passed. For |
|
739 example an application might extract The From: line from an email |
|
740 and pass that to mail(). While this may work, it is not reccomended. |
|
741 The application should really use a module like L<Mail::Address> |
|
742 to extract the mail address and pass that. |
|
743 |
|
744 If C<ExactAddresses> is passed to the contructor, then addresses |
|
745 should be a valid rfc2821-quoted address, although Net::SMTP will |
|
746 accept accept the address surrounded by angle brackets. |
|
747 |
|
748 funny user@domain WRONG |
|
749 "funny user"@domain RIGHT, recommended |
|
750 <"funny user"@domain> OK |
|
751 |
|
752 =head1 SEE ALSO |
|
753 |
|
754 L<Net::Cmd> |
|
755 |
|
756 =head1 AUTHOR |
|
757 |
|
758 Graham Barr <gbarr@pobox.com> |
|
759 |
|
760 =head1 COPYRIGHT |
|
761 |
|
762 Copyright (c) 1995-1997 Graham Barr. All rights reserved. |
|
763 This program is free software; you can redistribute it and/or modify |
|
764 it under the same terms as Perl itself. |
|
765 |
|
766 =for html <hr> |
|
767 |
|
768 I<$Id: //depot/libnet/Net/SMTP.pm#31 $> |
|
769 |
|
770 =cut |