Class | Net::SMTP
In: | 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

default_port esmtp esmtp= esmtp? finish inspect new open_message_stream read_timeout= ready 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 net/smtp.rb, line 169
        def SMTP.default_port
          25
        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 net/smtp.rb, line 184
        def initialize( address, port = nil )
          @address = address
          @port = (port || SMTP.default_port)
          @esmtp = true
          @socket = nil
          @started = false
          @open_timeout = 30
          @read_timeout = 60
          @error_occured = false
          @debug_output = nil
        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:

- Net::SMTPAuthenticationError
- Net::SMTPServerBusy
- Net::SMTPSyntaxError
- Net::SMTPFatalError
- Net::SMTPUnknownError
- IOError
- TimeoutError

[Source]

    # File net/smtp.rb, line 312
        def SMTP.start( address, port = nil,
                        helo = 'localhost.localdomain',
                        user = nil, secret = nil, authtype = nil,
                        &block) # :yield: smtp
          new(address, port).start(helo, user, secret, authtype, &block)
        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 net/smtp.rb, line 213
        def esmtp=( bool )
          @esmtp = bool
        end

esmtp?()

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

[Source]

    # File net/smtp.rb, line 202
        def esmtp?
          @esmtp
        end

finish()

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

[Source]

    # File net/smtp.rb, line 420
        def finish
          raise IOError, 'not yet started' unless started?
          do_finish
        end

inspect()

Provide human-readable stringification of class state.

[Source]

    # File net/smtp.rb, line 197
        def inspect
          "#<#{self.class} #{@address}:#{@port} started=#{@started}>"
        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:

- Net::SMTPServerBusy
- Net::SMTPSyntaxError
- Net::SMTPFatalError
- Net::SMTPUnknownError
- IOError
- TimeoutError

[Source]

    # File net/smtp.rb, line 524
        def open_message_stream( from_addr, *to_addrs, &block ) # :yield: stream
          send0(from_addr, to_addrs.flatten) {
            @socket.write_message_by_block(&block)
          }
        end

read_timeout=( sec )

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

[Source]

    # File net/smtp.rb, line 237
        def read_timeout=( sec )
          @socket.read_timeout = sec if @socket
          @read_timeout = sec
        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:

- Net::SMTPServerBusy
- Net::SMTPSyntaxError
- Net::SMTPFatalError
- Net::SMTPUnknownError
- IOError
- TimeoutError

[Source]

    # File net/smtp.rb, line 471
        def send_message( msgstr, from_addr, *to_addrs )
          send0(from_addr, to_addrs.flatten) {
            @socket.write_message msgstr
          }
        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 net/smtp.rb, line 256
        def set_debug_output( arg )
          @debug_output = arg
        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:

- Net::SMTPAuthenticationError
- Net::SMTPServerBusy
- Net::SMTPSyntaxError
- Net::SMTPFatalError
- Net::SMTPUnknownError
- IOError
- TimeoutError

[Source]

    # File net/smtp.rb, line 374
        def start( helo = 'localhost.localdomain',
                   user = nil, secret = nil, authtype = nil ) # :yield: smtp
          if block_given?
            begin
              do_start(helo, user, secret, authtype)
              return yield(self)
            ensure
              do_finish
            end
          else
            do_start(helo, user, secret, authtype)
            return self
          end
        end

started?()

`true` if the SMTP session has been started.

[Source]

    # File net/smtp.rb, line 320
        def started?
          @started
        end

[Validate]