# class 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 or search for alternatives in RubyGems.org or The Ruby Toolbox.

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_address@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
                    helo: '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
                    user: 'Your Account', secret: 'Your Password', authtype: :plain)
    # LOGIN
    Net::SMTP.start('your.smtp.server', 25
                    user: 'Your Account', secret: 'Your Password', authtype: :login)

    # CRAM MD5
    Net::SMTP.start('your.smtp.server', 25
                    user: 'Your Account', secret: 'Your Password', authtype: :cram_md5)

### Constants

CRAM_BUFSIZE
DEFAULT_AUTH_TYPE

  Authentication

IMASK
OMASK
Revision
VERSION

### Attributes

address[R]

The address of the `SMTP` server to connect to.

esmtp[RW]

`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).

esmtp?[RW]

`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).

open_timeout[RW]

Seconds to wait while attempting to open a connection. If the connection cannot be opened within this time, a `Net::OpenTimeout` is raised. The default value is 30 seconds.

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 `Net::ReadTimeout` is raised. The default value is 60 seconds.

### Public Class Methods

default_port() click to toggle source

The default `SMTP` port number, 25.

    # File lib/net/smtp.rb, line 176
    def SMTP.default_port
      25
    end

default_ssl_context(verify_peer=true) click to toggle source

    # File lib/net/smtp.rb, line 194
    def SMTP.default_ssl_context(verify_peer=true)
      context = OpenSSL::SSL::SSLContext.new
      context.verify_mode = verify_peer ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
      store = OpenSSL::X509::Store.new
      store.set_default_paths
      context.cert_store = store
      context
    end

default_ssl_port()
Alias for: default_tls_port
default_submission_port() click to toggle source

The default mail submission port number, 587.

    # File lib/net/smtp.rb, line 181
    def SMTP.default_submission_port
      587
    end

default_tls_port() click to toggle source

The default SMTPS port number, 465.

    # File lib/net/smtp.rb, line 186
    def SMTP.default_tls_port
      465
    end

Also aliased as: default_ssl_port
new(address, port = nil) click to toggle source

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`.

    # File lib/net/smtp.rb, line 214
    def initialize(address, port = nil)
      @address = address
      @port = (port || SMTP.default_port)
      @esmtp = true
      @capabilities = nil
      @socket = nil
      @started = false
      @open_timeout = 30
      @read_timeout = 60
      @error_occurred = false
      @debug_output = nil
      @tls = false
      @starttls = :auto
      @ssl_context_tls = nil
      @ssl_context_starttls = nil
    end

start(address, port = nil, helo: 'localhost', user: nil, secret: nil, authtype: nil, tls_verify: true, tls_hostname: nil) { |smtp| ... } click to toggle source
start(address, port = nil, helo = 'localhost', 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: helo_domain, user: account, secret: password, authtype: authtype, tls_verify: flag, tls_hostname: hostname)

### 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'.

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. If `tls_verify` is true, verify the server's certificate. The default is true. If the hostname in the server certificate is different from `address`, it can be specified with `tls_hostname`.

### Errors¶ ↑

This method may raise:

- `Net::SMTPAuthenticationError`

- `Net::SMTPServerBusy`

- `Net::SMTPSyntaxError`

- `Net::SMTPFatalError`

- `Net::SMTPUnknownError`

- `Net::OpenTimeout`

- `Net::ReadTimeout`

- `IOError`

    # File lib/net/smtp.rb, line 466
    def SMTP.start(address, port = nil, *args, helo: nil,
                   user: nil, secret: nil, password: nil, authtype: nil,
                   tls_verify: true, tls_hostname: nil,
                   &block)
      raise ArgumentError, "wrong number of arguments (given #{args.size + 2}, expected 1..6)" if args.size > 4
      helo ||= args[0] || 'localhost'
      user ||= args[1]
      secret ||= password || args[2]
      authtype ||= args[3]
      new(address, port).start(helo: helo, user: user, secret: secret, authtype: authtype, tls_verify: tls_verify, tls_hostname: tls_hostname, &block)
    end

### Public Instance Methods

auth_cram_md5(user, secret) click to toggle source

    # File lib/net/smtp.rb, line 791
    def auth_cram_md5(user, secret)
      check_auth_args user, secret
      res = critical {
        res0 = get_response('AUTH CRAM-MD5')
        check_auth_continue res0
        crammed = cram_md5_response(secret, res0.cram_md5_challenge)
        get_response(base64_encode("#{user} #{crammed}"))
      }
      check_auth_response res
      res
    end

auth_login(user, secret) click to toggle source

    # File lib/net/smtp.rb, line 780
    def auth_login(user, secret)
      check_auth_args user, secret
      res = critical {
        check_auth_continue get_response('AUTH LOGIN')
        check_auth_continue get_response(base64_encode(user))
        get_response(base64_encode(secret))
      }
      check_auth_response res
      res
    end

auth_plain(user, secret) click to toggle source

    # File lib/net/smtp.rb, line 771
    def auth_plain(user, secret)
      check_auth_args user, secret
      res = critical {
        get_response('AUTH PLAIN ' + base64_encode("\0#{user}\0#{secret}"))
      }
      check_auth_response res
      res
    end

authenticate(user, secret, authtype = DEFAULT_AUTH_TYPE) click to toggle source

    # File lib/net/smtp.rb, line 765
    def authenticate(user, secret, authtype = DEFAULT_AUTH_TYPE)
      check_auth_method authtype
      check_auth_args user, secret
      public_send auth_method(authtype), user, secret
    end

capable_auth_types() click to toggle source

Returns supported authentication methods on this server. You cannot get valid value before opening `SMTP` session.

    # File lib/net/smtp.rb, line 287
    def capable_auth_types
      return [] unless @capabilities
      return [] unless @capabilities['AUTH']
      @capabilities['AUTH']
    end

capable_cram_md5_auth?() click to toggle source

true if server advertises AUTH CRAM-MD5. You cannot get valid value before opening `SMTP` session.

    # File lib/net/smtp.rb, line 274
    def capable_cram_md5_auth?
      auth_capable?('CRAM-MD5')
    end

capable_login_auth?() click to toggle source

true if server advertises AUTH LOGIN. You cannot get valid value before opening `SMTP` session.

    # File lib/net/smtp.rb, line 268
    def capable_login_auth?
      auth_capable?('LOGIN')
    end

capable_plain_auth?() click to toggle source

true if server advertises AUTH PLAIN. You cannot get valid value before opening `SMTP` session.

    # File lib/net/smtp.rb, line 262
    def capable_plain_auth?
      auth_capable?('PLAIN')
    end

capable_starttls?() click to toggle source

true if server advertises STARTTLS. You cannot get valid value before opening `SMTP` session.

    # File lib/net/smtp.rb, line 250
    def capable_starttls?
      capable?('STARTTLS')
    end

data(msgstr = nil) { |stream| ... } click to toggle source

This method sends a message. If `msgstr` is given, sends it as a message. If block is given, yield a message writer stream. You must write message before the block is closed.

    # Example 1 (by string)
    smtp.data(<<EndMessage)
    From: john@example.com
    To: betty@example.com
    Subject: I found a bug

    Check vm.c:58879.
    EndMessage

    # Example 2 (by block)
    smtp.data {|f|
      f.puts "From: john@example.com"
      f.puts "To: betty@example.com"
      f.puts "Subject: I found a bug"
      f.puts ""
      f.puts "Check vm.c:58879."
    }

    # File lib/net/smtp.rb, line 925
    def data(msgstr = nil, &block)   #:yield: stream
      if msgstr and block
        raise ArgumentError, "message and block are exclusive"
      end
      unless msgstr or block
        raise ArgumentError, "message or block is required"
      end
      res = critical {
        check_continue get_response('DATA')
        socket_sync_bak = @socket.io.sync
        begin
          @socket.io.sync = false
          if msgstr
            @socket.write_message msgstr
          else
            @socket.write_message_by_block(&block)
          end
        ensure
          @socket.io.flush
          @socket.io.sync = socket_sync_bak
        end
        recv_response()
      }
      check_response res
      res
    end

debug_output=(arg) click to toggle source

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

    # File lib/net/smtp.rb, line 400
    def debug_output=(arg)
      @debug_output = arg
    end

Also aliased as: set_debug_output
disable_ssl()
Alias for: disable_tls
disable_starttls() click to toggle source

Disables SMTP/TLS (STARTTLS) for this object. Must be called before the connection is established to have any effect.

    # File lib/net/smtp.rb, line 358
    def disable_starttls
      @starttls = false
      @ssl_context_starttls = nil
    end

disable_tls() click to toggle source

Disables SMTP/TLS for this object. Must be called before the connection is established to have any effect.

    # File lib/net/smtp.rb, line 314
    def disable_tls
      @tls = false
      @ssl_context_tls = nil
    end

Also aliased as: disable_ssl
ehlo(domain) click to toggle source

    # File lib/net/smtp.rb, line 869
    def ehlo(domain)
      getok("EHLO #{domain}")
    end

enable_ssl(context = nil)
Alias for: enable_tls
enable_starttls(context = nil) click to toggle source

Enables SMTP/TLS (STARTTLS) for this object. `context` is a `OpenSSL::SSL::SSLContext` object.

    # File lib/net/smtp.rb, line 340
    def enable_starttls(context = nil)
      raise 'openssl library not installed' unless defined?(OpenSSL)
      raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @tls
      @starttls = :always
      @ssl_context_starttls = context
    end

enable_starttls_auto(context = nil) click to toggle source

Enables SMTP/TLS (STARTTLS) for this object if server accepts. `context` is a `OpenSSL::SSL::SSLContext` object.

    # File lib/net/smtp.rb, line 349
    def enable_starttls_auto(context = nil)
      raise 'openssl library not installed' unless defined?(OpenSSL)
      raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @tls
      @starttls = :auto
      @ssl_context_starttls = context
    end

enable_tls(context = nil) click to toggle source

Enables SMTP/TLS (SMTPS: `SMTP` over direct TLS connection) for this object. Must be called before the connection is established to have any effect. `context` is a `OpenSSL::SSL::SSLContext` object.

    # File lib/net/smtp.rb, line 303
    def enable_tls(context = nil)
      raise 'openssl library not installed' unless defined?(OpenSSL)
      raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @starttls == :always
      @tls = true
      @ssl_context_tls = context
    end

Also aliased as: enable_ssl
finish() click to toggle source

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

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

helo(domain) click to toggle source

    # File lib/net/smtp.rb, line 865
    def helo(domain)
      getok("HELO #{domain}")
    end

inspect() click to toggle source

Provide human-readable stringification of class state.

    # File lib/net/smtp.rb, line 232
    def inspect
      "#<#{self.class} #{@address}:#{@port} started=#{@started}>"
    end

mailfrom(from_addr) click to toggle source

    # File lib/net/smtp.rb, line 873
    def mailfrom(from_addr)
      getok("MAIL FROM:<#{from_addr}>")
    end

open_message_stream(from_addr, *to_addrs) { |stream| ... } click to toggle source

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`

- `Net::ReadTimeout`

- `IOError`

    # File lib/net/smtp.rb, line 749
    def open_message_stream(from_addr, *to_addrs, &block)   # :yield: stream
      raise IOError, 'closed session' unless @socket
      mailfrom from_addr
      rcptto_list(to_addrs) {data(&block)}
    end

Also aliased as: ready
quit() click to toggle source

    # File lib/net/smtp.rb, line 952
    def quit
      getok('QUIT')
    end

rcptto(to_addr) click to toggle source

    # File lib/net/smtp.rb, line 898
    def rcptto(to_addr)
      getok("RCPT TO:<#{to_addr}>")
    end

rcptto_list(to_addrs) { || ... } click to toggle source

    # File lib/net/smtp.rb, line 877
    def rcptto_list(to_addrs)
      raise ArgumentError, 'mail destination not given' if to_addrs.empty?
      ok_users = []
      unknown_users = []
      to_addrs.flatten.each do |addr|
        begin
          rcptto addr
        rescue SMTPAuthenticationError
          unknown_users << addr.dump
        else
          ok_users << addr
        end
      end
      raise ArgumentError, 'mail destination not given' if ok_users.empty?
      ret = yield
      unless unknown_users.empty?
        raise SMTPAuthenticationError, "failed to deliver for #{unknown_users.join(', ')}"
      end
      ret
    end

read_timeout=(sec) click to toggle source

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

    # File lib/net/smtp.rb, line 381
    def read_timeout=(sec)
      @socket.read_timeout = sec if @socket
      @read_timeout = sec
    end

ready(from_addr, *to_addrs)
Alias for: open_message_stream
rset() click to toggle source

Aborts the current mail transaction

    # File lib/net/smtp.rb, line 857
    def rset
      getok('RSET')
    end

send_mail(msgstr, from_addr, *to_addrs)
Alias for: send_message
send_message(msgstr, from_addr, *to_addrs) click to toggle source

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`

- `Net::ReadTimeout`

- `IOError`

    # File lib/net/smtp.rb, line 696
    def send_message(msgstr, from_addr, *to_addrs)
      raise IOError, 'closed session' unless @socket
      mailfrom from_addr
      rcptto_list(to_addrs) {data msgstr}
    end

Also aliased as: send_mail, sendmail
sendmail(msgstr, from_addr, *to_addrs)
Alias for: send_message
set_debug_output(arg)
Alias for: debug_output=
ssl?()
Alias for: tls?
start(helo: 'localhost', user: nil, secret: nil, authtype: nil, tls_verify: true, tls_hostname: nil) { |smtp| ... } click to toggle source
start(helo = 'localhost', 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. If `tls_verify` is true, verify the server's certificate. The default is true. If the hostname in the server certificate is different from `address`, it can be specified with `tls_hostname`.

### 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: helo_domain, user: account, secret: password, authtype: 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`

- `Net::OpenTimeout`

- `Net::ReadTimeout`

- `IOError`

    # File lib/net/smtp.rb, line 541
    def start(*args, helo: nil,
              user: nil, secret: nil, password: nil, authtype: nil, tls_verify: true, tls_hostname: nil)
      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..4)" if args.size > 4
      helo ||= args[0] || 'localhost'
      user ||= args[1]
      secret ||= password || args[2]
      authtype ||= args[3]
      if @tls && @ssl_context_tls.nil?
        @ssl_context_tls = SMTP.default_ssl_context(tls_verify)
      end
      if @starttls && @ssl_context_starttls.nil?
        @ssl_context_starttls = SMTP.default_ssl_context(tls_verify)
      end
      @tls_hostname = tls_hostname
      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?() click to toggle source

`true` if the `SMTP` session has been started.

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

starttls() click to toggle source

    # File lib/net/smtp.rb, line 861
    def starttls
      getok('STARTTLS')
    end

starttls?() click to toggle source

Returns truth value if this object uses STARTTLS. If this object always uses STARTTLS, returns :always. If this object uses STARTTLS when the server support TLS, returns :auto.

    # File lib/net/smtp.rb, line 324
    def starttls?
      @starttls
    end

starttls_always?() click to toggle source

true if this object uses STARTTLS.

    # File lib/net/smtp.rb, line 329
    def starttls_always?
      @starttls == :always
    end

starttls_auto?() click to toggle source

true if this object uses STARTTLS when server advertises STARTTLS.

    # File lib/net/smtp.rb, line 334
    def starttls_auto?
      @starttls == :auto
    end

tls?() click to toggle source

true if this object uses SMTP/TLS (SMTPS).

    # File lib/net/smtp.rb, line 294
    def tls?
      @tls
    end

Also aliased as: ssl?

### Private Instance Methods

auth_capable?(type) click to toggle source

    # File lib/net/smtp.rb, line 278
    def auth_capable?(type)
      return nil unless @capabilities
      return false unless @capabilities['AUTH']
      @capabilities['AUTH'].include?(type)
    end

auth_method(type) click to toggle source

    # File lib/net/smtp.rb, line 811
    def auth_method(type)
      "auth_#{type.to_s.downcase}".intern
    end

base64_encode(str) click to toggle source

    # File lib/net/smtp.rb, line 824
    def base64_encode(str)
      # expects "str" may not become too long
      [str].pack('m0')
    end

capable?(key) click to toggle source

    # File lib/net/smtp.rb, line 254
    def capable?(key)
      return nil unless @capabilities
      @capabilities[key] ? true : false
    end

check_auth_args(user, secret, authtype = DEFAULT_AUTH_TYPE) click to toggle source

    # File lib/net/smtp.rb, line 815
    def check_auth_args(user, secret, authtype = DEFAULT_AUTH_TYPE)
      unless user
        raise ArgumentError, 'SMTP-AUTH requested but missing user name'
      end
      unless secret
        raise ArgumentError, 'SMTP-AUTH requested but missing secret phrase'
      end
    end

check_auth_continue(res) click to toggle source

    # File lib/net/smtp.rb, line 1019
    def check_auth_continue(res)
      unless res.continue?
        raise res.exception_class, res.message
      end
    end

check_auth_method(type) click to toggle source

    # File lib/net/smtp.rb, line 805
    def check_auth_method(type)
      unless respond_to?(auth_method(type), true)
        raise ArgumentError, "wrong authentication type #{type}"
      end
    end

check_auth_response(res) click to toggle source

    # File lib/net/smtp.rb, line 1013
    def check_auth_response(res)
      unless res.success?
        raise SMTPAuthenticationError, res.message
      end
    end

check_continue(res) click to toggle source

    # File lib/net/smtp.rb, line 1007
    def check_continue(res)
      unless res.continue?
        raise SMTPUnknownError, "could not get 3xx (#{res.status}: #{res.string})"
      end
    end

check_response(res) click to toggle source

    # File lib/net/smtp.rb, line 1001
    def check_response(res)
      unless res.success?
        raise res.exception_class, res.message
      end
    end

cram_md5_response(secret, challenge) click to toggle source

CRAM-MD5: [RFC2195]

    # File lib/net/smtp.rb, line 833
    def cram_md5_response(secret, challenge)
      tmp = Digest::MD5.digest(cram_secret(secret, IMASK) + challenge)
      Digest::MD5.hexdigest(cram_secret(secret, OMASK) + tmp)
    end

cram_secret(secret, mask) click to toggle source

    # File lib/net/smtp.rb, line 840
    def cram_secret(secret, mask)
      secret = Digest::MD5.digest(secret) if secret.size > CRAM_BUFSIZE
      buf = secret.ljust(CRAM_BUFSIZE, "\0")
      0.upto(buf.size - 1) do |i|
        buf[i] = (buf[i].ord ^ mask).chr
      end
      buf
    end

critical() { || ... } click to toggle source

    # File lib/net/smtp.rb, line 991
    def critical
      return Response.parse('200 dummy reply code') if @error_occurred
      begin
        return yield()
      rescue Exception
        @error_occurred = true
        raise
      end
    end

do_finish() click to toggle source

    # File lib/net/smtp.rb, line 651
    def do_finish
      quit if @socket and not @socket.closed? and not @error_occurred
    ensure
      @started = false
      @error_occurred = false
      @socket.close if @socket
      @socket = nil
    end

do_helo(helo_domain) click to toggle source

    # File lib/net/smtp.rb, line 639
    def do_helo(helo_domain)
      res = @esmtp ? ehlo(helo_domain) : helo(helo_domain)
      @capabilities = res.capabilities
    rescue SMTPError
      if @esmtp
        @esmtp = false
        @error_occurred = false
        retry
      end
      raise
    end

do_start(helo_domain, user, secret, authtype) click to toggle source

    # File lib/net/smtp.rb, line 581
    def do_start(helo_domain, user, secret, authtype)
      raise IOError, 'SMTP session already started' if @started
      if user or secret
        check_auth_method(authtype || DEFAULT_AUTH_TYPE)
        check_auth_args user, secret
      end
      s = Timeout.timeout(@open_timeout, Net::OpenTimeout) do
        tcp_socket(@address, @port)
      end
      logging "Connection opened: #{@address}:#{@port}"
      @socket = new_internet_message_io(tls? ? tlsconnect(s, @ssl_context_tls) : s)
      check_response critical { recv_response() }
      do_helo helo_domain
      if ! tls? and (starttls_always? or (capable_starttls? and starttls_auto?))
        unless capable_starttls?
          raise SMTPUnsupportedCommand,
              "STARTTLS is not supported on this server"
        end
        starttls
        @socket = new_internet_message_io(tlsconnect(s, @ssl_context_starttls))
        # helo response may be different after STARTTLS
        do_helo helo_domain
      end
      authenticate user, secret, (authtype || DEFAULT_AUTH_TYPE) if user
      @started = true
    ensure
      unless @started
        # authentication failed, cancel connection.
        s.close if s
        @socket = nil
      end
    end

get_response(reqline) click to toggle source

    # File lib/net/smtp.rb, line 975
    def get_response(reqline)
      validate_line reqline
      @socket.writeline reqline
      recv_response()
    end

getok(reqline) click to toggle source

    # File lib/net/smtp.rb, line 965
    def getok(reqline)
      validate_line reqline
      res = critical {
        @socket.writeline reqline
        recv_response()
      }
      check_response res
      res
    end

logging(msg) click to toggle source

    # File lib/net/smtp.rb, line 1104
    def logging(msg)
      @debug_output << msg + "\n" if @debug_output
    end

new_internet_message_io(s) click to toggle source

    # File lib/net/smtp.rb, line 634
    def new_internet_message_io(s)
      InternetMessageIO.new(s, read_timeout: @read_timeout,
                            debug_output: @debug_output)
    end

recv_response() click to toggle source

    # File lib/net/smtp.rb, line 981
    def recv_response
      buf = ''.dup
      while true
        line = @socket.readline
        buf << line << "\n"
        break unless line[3,1] == '-'   # "210-PIPELINING"
      end
      Response.parse(buf)
    end

ssl_socket(socket, context) click to toggle source

    # File lib/net/smtp.rb, line 614
    def ssl_socket(socket, context)
      OpenSSL::SSL::SSLSocket.new socket, context
    end

tcp_socket(address, port) click to toggle source

    # File lib/net/smtp.rb, line 577
    def tcp_socket(address, port)
      TCPSocket.open address, port
    end

tlsconnect(s, context) click to toggle source

    # File lib/net/smtp.rb, line 618
    def tlsconnect(s, context)
      verified = false
      s = ssl_socket(s, context)
      logging "TLS connection started"
      s.sync_close = true
      s.hostname = @tls_hostname || @address if s.respond_to? :hostname=
      ssl_socket_connect(s, @open_timeout)
      if context.verify_mode && context.verify_mode != OpenSSL::SSL::VERIFY_NONE
        s.post_connection_check(@tls_hostname || @address)
      end
      verified = true
      s
    ensure
      s.close unless verified
    end

validate_line(line) click to toggle source

    # File lib/net/smtp.rb, line 958
    def validate_line(line)
      # A bare CR or LF is not allowed in RFC5321.
      if /[\r\n]/ =~ line
        raise ArgumentError, "A line must not contain CR or LF"
      end
    end