Class Net::SMTP
In: lib/net/smtp.rb
Parent: Object

Net::SMTP

What is This Library?

This library provides functionality to send internet mail via SMTP, the Simple Mail Transfer Protocol. For details of SMTP itself, see [RFC2821] (www.ietf.org/rfc/rfc2821.txt).

What is This Library NOT?

This library does NOT provide functions to compose internet mails. You must create them by yourself. If you want better mail support, try RubyMail or TMail. You can get both libraries from RAA. (www.ruby-lang.org/en/raa.html)

FYI: the official documentation on internet mail is: [RFC2822] (www.ietf.org/rfc/rfc2822.txt).

Examples

Sending Messages

You must open a connection to an SMTP server before sending messages. The first argument is the address of your SMTP server, and the second argument is the port number. Using SMTP.start with a block is the simplest way to do this. This way, the SMTP connection is closed automatically after the block is executed. 

    require 'net/smtp'
    Net::SMTP.start('your.smtp.server', 25) do |smtp|
      # Use the SMTP object smtp only in this block.
    end

Replace ‘your.smtp.server’ with your SMTP server. Normally your system manager or internet provider supplies a server for you.

Then you can send messages. 

    msgstr = <<END_OF_MESSAGE
    From: Your Name <your@mail.address>
    To: Destination Address <someone@example.com>
    Subject: test message
    Date: Sat, 23 Jun 2001 16:26:43 +0900
    Message-Id: <unique.message.id.string@example.com>

    This is a test message.
    END_OF_MESSAGE

    require 'net/smtp'
    Net::SMTP.start('your.smtp.server', 25) do |smtp|
      smtp.send_message msgstr,
                        'your@mail.address',
                        'his_addess@example.com'
    end

Closing the Session

You MUST close the SMTP session after sending messages, by calling the finish method: 

    # using SMTP#finish
    smtp = Net::SMTP.start('your.smtp.server', 25)
    smtp.send_message msgstr, 'from@address', 'to@address'
    smtp.finish

You can also use the block form of SMTP.start/SMTP#start. This closes the SMTP session automatically: 

    # using block form of SMTP.start
    Net::SMTP.start('your.smtp.server', 25) do |smtp|
      smtp.send_message msgstr, 'from@address', 'to@address'
    end

I strongly recommend this scheme. This form is simpler and more robust.

HELO domain

In almost all situations, you must provide a third argument to SMTP.start/SMTP#start. This is the domain name which you are on (the host to send mail from). It is called the "HELO domain". The SMTP server will judge whether it should send or reject the SMTP session by inspecting the HELO domain. 

    Net::SMTP.start('your.smtp.server', 25,
                    'mail.from.domain') { |smtp| ... }

SMTP Authentication

The Net::SMTP class supports three authentication schemes; PLAIN, LOGIN and CRAM MD5. (SMTP Authentication: [RFC2554]) To use SMTP authentication, pass extra arguments to SMTP.start/SMTP#start. 

    # PLAIN
    Net::SMTP.start('your.smtp.server', 25, 'mail.from.domain',
                    'Your Account', 'Your Password', :plain)
    # LOGIN
    Net::SMTP.start('your.smtp.server', 25, 'mail.from.domain',
                    'Your Account', 'Your Password', :login)

    # CRAM MD5
    Net::SMTP.start('your.smtp.server', 25, 'mail.from.domain',
                    'Your Account', 'Your Password', :cram_md5)

Methods

auth_cram_md5   auth_login   auth_plain   authenticate   base64_encode   check_auth_args   check_response   critical   default_port   do_finish   do_start   ehlo   esmtp   esmtp=   esmtp?   finish   get_response   getok   helo   inspect   mailfrom   new   open_message_stream   quit   rcptto   read_timeout=   ready   recv_response   send0   send_mail   send_message   sendmail   set_debug_output   start   start   started?  

Constants

Revision = %q$Revision: 1.69.2.3 $.split[1]

Attributes

address  [R]  The address of the SMTP server to connect to.
open_timeout  [RW]  Seconds to wait while attempting to open a connection. If the connection cannot be opened within this time, a TimeoutError is raised.
port  [R]  The port number of the SMTP server to connect to.
read_timeout  [R]  Seconds to wait while reading one block (by one read(2) call). If the read(2) call does not complete within this time, a TimeoutError is raised.

Public Class methods

default_port()

The default SMTP port, port 25.

[Source]

     # File lib/net/smtp.rb, line 169
169:     def SMTP.default_port
170:       25
171:     end
new( address, port = nil )

Creates a new Net::SMTP object.

address is the hostname or ip address of your SMTP server. port is the port to connect to; it defaults to port 25.

This method does not open the TCP connection. You can use SMTP.start instead of SMTP.new if you want to do everything at once. Otherwise, follow SMTP.new with SMTP#start.

[Source]

     # File lib/net/smtp.rb, line 184
184:     def initialize( address, port = nil )
185:       @address = address
186:       @port = (port || SMTP.default_port)
187:       @esmtp = true
188:       @socket = nil
189:       @started = false
190:       @open_timeout = 30
191:       @read_timeout = 60
192:       @error_occured = false
193:       @debug_output = nil
194:     end
start( address, port = nil, helo = 'localhost.localdomain', user = nil, secret = nil, authtype = nil) {|smtp| ...}

Creates a new Net::SMTP object and connects to the server.

This method is equivalent to: 

  Net::SMTP.new(address, port).start(helo_domain, account, password, authtype)

Example

    Net::SMTP.start('your.smtp.server') do |smtp|
      smtp.send_message msgstr, 'from@example.com', ['dest@example.com']
    end

Block Usage

If called with a block, the newly-opened Net::SMTP object is yielded to the block, and automatically closed when the block finishes. If called without a block, the newly-opened Net::SMTP object is returned to the caller, and it is the caller‘s responsibility to close it when finished.

Parameters

address is the hostname or ip address of your smtp server.

port is the port to connect to; it defaults to port 25.

helo is the HELO domain provided by the client to the server (see overview comments); it defaults to ‘localhost.localdomain’.

The remaining arguments are used for SMTP authentication, if required or desired. user is the account name; secret is your password or other authentication token; and authtype is the authentication type, one of :plain, :login, or :cram_md5. See the discussion of SMTP Authentication in the overview notes.

Errors

This method may raise:

[Source]

     # File lib/net/smtp.rb, line 312
312:     def SMTP.start( address, port = nil,
313:                     helo = 'localhost.localdomain',
314:                     user = nil, secret = nil, authtype = nil,
315:                     &block) # :yield: smtp
316:       new(address, port).start(helo, user, secret, authtype, &block)
317:     end

Public Instance methods

esmtp()

Alias for esmtp?

esmtp=( bool )

Set whether to use ESMTP or not. This should be done before calling start. Note that if start is called in ESMTP mode, and the connection fails due to a ProtocolError, the SMTP object will automatically switch to plain SMTP mode and retry (but not vice versa).

[Source]

     # File lib/net/smtp.rb, line 213
213:     def esmtp=( bool )
214:       @esmtp = bool
215:     end
esmtp?()

true if the SMTP object uses ESMTP (which it does by default).

[Source]

     # File lib/net/smtp.rb, line 202
202:     def esmtp?
203:       @esmtp
204:     end
finish()

Finishes the SMTP session and closes TCP connection. Raises IOError if not started.

[Source]

     # File lib/net/smtp.rb, line 420
420:     def finish
421:       raise IOError, 'not yet started' unless started?
422:       do_finish
423:     end
inspect()

Provide human-readable stringification of class state.

[Source]

     # File lib/net/smtp.rb, line 197
197:     def inspect
198:       "#<#{self.class} #{@address}:#{@port} started=#{@started}>"
199:     end
open_message_stream( from_addr, *to_addrs ) {|stream| ...}

Opens a message writer stream and gives it to the block. The stream is valid only in the block, and has these methods:

puts(str = ’’):outputs STR and CR LF.
print(str):outputs STR.
printf(fmt, *args):outputs sprintf(fmt,*args).
write(str):outputs STR and returns the length of written bytes.
<<(str):outputs STR and returns self.

If a single CR ("\r") or LF ("\n") is found in the message, it is converted to the CR LF pair. You cannot send a binary message with this method.

Parameters

from_addr is a String representing the source mail address.

to_addr is a String or Strings or Array of Strings, representing the destination mail address or addresses.

Example

    Net::SMTP.start('smtp.example.com', 25) do |smtp|
      smtp.open_message_stream('from@example.com', ['dest@example.com']) do |f|
        f.puts 'From: from@example.com'
        f.puts 'To: dest@example.com'
        f.puts 'Subject: test message'
        f.puts
        f.puts 'This is a test message.'
      end
    end

Errors

This method may raise:

[Source]

     # File lib/net/smtp.rb, line 524
524:     def open_message_stream( from_addr, *to_addrs, &block ) # :yield: stream
525:       send0(from_addr, to_addrs.flatten) {
526:         @socket.write_message_by_block(&block)
527:       }
528:     end
read_timeout=( sec )

Set the number of seconds to wait until timing-out a read(2) call.

[Source]

     # File lib/net/smtp.rb, line 237
237:     def read_timeout=( sec )
238:       @socket.read_timeout = sec if @socket
239:       @read_timeout = sec
240:     end
ready( from_addr, *to_addrs )

Alias for open_message_stream

send_mail( msgstr, from_addr, *to_addrs )

Alias for send_message

send_message( msgstr, from_addr, *to_addrs )

Sends msgstr as a message. Single CR ("\r") and LF ("\n") found in the msgstr, are converted into the CR LF pair. You cannot send a binary message with this method. msgstr should include both the message headers and body.

from_addr is a String representing the source mail address.

to_addr is a String or Strings or Array of Strings, representing the destination mail address or addresses.

Example

    Net::SMTP.start('smtp.example.com') do |smtp|
      smtp.send_message msgstr,
                        'from@example.com',
                        ['dest@example.com', 'dest2@example.com']
    end

Errors

This method may raise:

[Source]

     # File lib/net/smtp.rb, line 471
471:     def send_message( msgstr, from_addr, *to_addrs )
472:       send0(from_addr, to_addrs.flatten) {
473:         @socket.write_message msgstr
474:       }
475:     end
sendmail( msgstr, from_addr, *to_addrs )

Alias for send_message

set_debug_output( arg )

WARNING: This method causes serious security holes. Use this method for only debugging.

Set an output stream for debug logging. You must call this before start. 

  # example
  smtp = Net::SMTP.new(addr, port)
  smtp.set_debug_output $stderr
  smtp.start do |smtp|
    ....
  end

[Source]

     # File lib/net/smtp.rb, line 256
256:     def set_debug_output( arg )
257:       @debug_output = arg
258:     end
start( helo = 'localhost.localdomain', user = nil, secret = nil, authtype = nil ) {|smtp| ...}

Opens a TCP connection and starts the SMTP session.

Parameters

helo is the HELO domain that you‘ll dispatch mails from; see the discussion in the overview notes.

If both of user and secret are given, SMTP authentication will be attempted using the AUTH command. authtype specifies the type of authentication to attempt; it must be one of :login, :plain, and :cram_md5. See the notes on SMTP Authentication in the overview.

Block Usage

When this methods is called with a block, the newly-started SMTP object is yielded to the block, and automatically closed after the block call finishes. Otherwise, it is the caller‘s responsibility to close the session when finished.

Example

This is very similar to the class method SMTP.start. 

    require 'net/smtp'
    smtp = Net::SMTP.new('smtp.mail.server', 25)
    smtp.start(helo_domain, account, password, authtype) do |smtp|
      smtp.send_message msgstr, 'from@example.com', ['dest@example.com']
    end

The primary use of this method (as opposed to SMTP.start) is probably to set debugging (set_debug_output) or ESMTP (esmtp=), which must be done before the session is started.

Errors

If session has already been started, an IOError will be raised.

This method may raise:

[Source]

     # File lib/net/smtp.rb, line 374
374:     def start( helo = 'localhost.localdomain',
375:                user = nil, secret = nil, authtype = nil ) # :yield: smtp
376:       if block_given?
377:         begin
378:           do_start(helo, user, secret, authtype)
379:           return yield(self)
380:         ensure
381:           do_finish
382:         end
383:       else
384:         do_start(helo, user, secret, authtype)
385:         return self
386:       end
387:     end
started?()

true if the SMTP session has been started.

[Source]

     # File lib/net/smtp.rb, line 320
320:     def started?
321:       @started
322:     end

Private Instance methods

auth_cram_md5( user, secret )

[Source]

     # File lib/net/smtp.rb, line 589
589:     def auth_cram_md5( user, secret )
590:       # CRAM-MD5: [RFC2195]
591:       res = nil
592:       critical {
593:         res = check_response(get_response('AUTH CRAM-MD5'), true)
594:         challenge = res.split(/ /)[1].unpack('m')[0]
595:         secret = Digest::MD5.digest(secret) if secret.size > 64
596: 
597:         isecret = secret + "\0" * (64 - secret.size)
598:         osecret = isecret.dup
599:         0.upto(63) do |i|
600:           isecret[i] ^= 0x36
601:           osecret[i] ^= 0x5c
602:         end
603:         tmp = Digest::MD5.digest(isecret + challenge)
604:         tmp = Digest::MD5.hexdigest(osecret + tmp)
605: 
606:         res = get_response(base64_encode(user + ' ' + tmp))
607:       }
608:       raise SMTPAuthenticationError, res unless /\A2../ === res
609:     end
auth_login( user, secret )

[Source]

     # File lib/net/smtp.rb, line 580
580:     def auth_login( user, secret )
581:       res = critical {
582:         check_response(get_response('AUTH LOGIN'), true)
583:         check_response(get_response(base64_encode(user)), true)
584:         get_response(base64_encode(secret))
585:       }
586:       raise SMTPAuthenticationError, res unless /\A2../ === res
587:     end
auth_plain( user, secret )

[Source]

     # File lib/net/smtp.rb, line 574
574:     def auth_plain( user, secret )
575:       res = critical { get_response('AUTH PLAIN %s',
576:                                     base64_encode("\0#{user}\0#{secret}")) }
577:       raise SMTPAuthenticationError, res unless /\A2../ === res
578:     end
authenticate( user, secret, authtype )

[Source]

     # File lib/net/smtp.rb, line 570
570:     def authenticate( user, secret, authtype )
571:       __send__("auth_#{authtype || 'cram_md5'}", user, secret)
572:     end
base64_encode( str )

[Source]

     # File lib/net/smtp.rb, line 611
611:     def base64_encode( str )
612:       # expects "str" may not become too long
613:       [str].pack('m').gsub(/\s+/, '')
614:     end
check_auth_args( user, secret, authtype )

auth

[Source]

     # File lib/net/smtp.rb, line 562
562:     def check_auth_args( user, secret, authtype )
563:       raise ArgumentError, 'both user and secret are required'\
564:                       unless user and secret
565:       auth_method = "auth_#{authtype || 'cram_md5'}"
566:       raise ArgumentError, "wrong auth type #{authtype}"\
567:                       unless respond_to?(auth_method, true)
568:     end
check_response( res, allow_continue = false )

[Source]

     # File lib/net/smtp.rb, line 671
671:     def check_response( res, allow_continue = false )
672:       return res if /\A2/ === res
673:       return res if allow_continue and /\A3/ === res
674:       err = case res
675:             when /\A4/  then SMTPServerBusy
676:             when /\A50/ then SMTPSyntaxError
677:             when /\A55/ then SMTPFatalError
678:             else SMTPUnknownError
679:             end
680:       raise err, res
681:     end
critical( ) {|| ...}

[Source]

     # File lib/net/smtp.rb, line 683
683:     def critical( &block )
684:       return '200 dummy reply code' if @error_occured
685:       begin
686:         return yield()
687:       rescue Exception
688:         @error_occured = true
689:         raise
690:       end
691:     end
do_finish()

[Source]

     # File lib/net/smtp.rb, line 425
425:     def do_finish
426:       quit if @socket and not @socket.closed? and not @error_occured
427:     ensure
428:       @started = false
429:       @error_occured = false
430:       @socket.close if @socket and not @socket.closed?
431:       @socket = nil
432:     end
do_start( helodomain, user, secret, authtype )

[Source]

     # File lib/net/smtp.rb, line 389
389:     def do_start( helodomain, user, secret, authtype )
390:       raise IOError, 'SMTP session already started' if @started
391:       check_auth_args user, secret, authtype if user or secret
392: 
393:       @socket = InternetMessageIO.old_open(@address, @port,
394:                                        @open_timeout, @read_timeout,
395:                                        @debug_output)
396:       check_response(critical { recv_response() })
397:       begin
398:         if @esmtp
399:           ehlo helodomain
400:         else
401:           helo helodomain
402:         end
403:       rescue ProtocolError
404:         if @esmtp
405:           @esmtp = false
406:           @error_occured = false
407:           retry
408:         end
409:         raise
410:       end
411:       authenticate user, secret, authtype if user
412:       @started = true
413:     ensure
414:       @socket.close if not @started and @socket and not @socket.closed?
415:     end
ehlo( domain )

[Source]

     # File lib/net/smtp.rb, line 626
626:     def ehlo( domain )
627:       getok('EHLO %s', domain)
628:     end
get_response( fmt, *args )

[Source]

     # File lib/net/smtp.rb, line 656
656:     def get_response( fmt, *args )
657:       @socket.writeline sprintf(fmt, *args)
658:       recv_response()
659:     end
getok( fmt, *args )

row level library

[Source]

     # File lib/net/smtp.rb, line 648
648:     def getok( fmt, *args )
649:       res = critical {
650:         @socket.writeline sprintf(fmt, *args)
651:         recv_response()
652:       }
653:       return check_response(res)
654:     end
helo( domain )

SMTP command dispatcher

[Source]

     # File lib/net/smtp.rb, line 622
622:     def helo( domain )
623:       getok('HELO %s', domain)
624:     end
mailfrom( fromaddr )

[Source]

     # File lib/net/smtp.rb, line 630
630:     def mailfrom( fromaddr )
631:       getok('MAIL FROM:<%s>', fromaddr)
632:     end
quit()

[Source]

     # File lib/net/smtp.rb, line 638
638:     def quit
639:       getok('QUIT')
640:     end
rcptto( to )

[Source]

     # File lib/net/smtp.rb, line 634
634:     def rcptto( to )
635:       getok('RCPT TO:<%s>', to)
636:     end
recv_response()

[Source]

     # File lib/net/smtp.rb, line 661
661:     def recv_response
662:       res = ''
663:       while true
664:         line = @socket.readline
665:         res << line << "\n"
666:         break unless line[3] == ?-   # "210-PIPELINING"
667:       end
668:       res
669:     end
send0( from_addr, to_addrs ) {|| ...}

[Source]

     # File lib/net/smtp.rb, line 534
534:     def send0( from_addr, to_addrs )
535:       raise IOError, 'closed session' unless @socket
536:       raise ArgumentError, 'mail destination not given' if to_addrs.empty?
537:       if $SAFE > 0
538:         raise SecurityError, 'tainted from_addr' if from_addr.tainted?
539:         to_addrs.each do |to| 
540:           raise SecurityError, 'tainted to_addr' if to.tainted?
541:         end
542:       end
543: 
544:       mailfrom from_addr
545:       to_addrs.each do |to|
546:         rcptto to
547:       end
548:       res = critical {
549:         check_response(get_response('DATA'), true)
550:         yield
551:         recv_response()
552:       }
553:       check_response(res)
554:     end

[Validate]