123456789_123456789_123456789_123456789_123456789_

Class: Net::SMTP

Relationships & Source Files
Namespace Children
Classes:
Response
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Protocol
Instance Chain:
self, Protocol
Inherits: Protocol
  • Object
Defined in: lib/net/smtp.rb

Overview

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

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

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(address, port = nil) ⇒ SMTP

Creates a new 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 .start instead of .new if you want to do everything at once. Otherwise, follow .new with #start.

[ GitHub ] 

  


# 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


  







Class Method Details



  

    .default_port  
  



  

    

The default SMTP port number, 25.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 176



def SMTP.default_port
  25
end


  








  

    .default_ssl_context(verify_peer = true)  
  

  [ GitHub ]


  

  


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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 191



alias default_ssl_port default_tls_port


  








  

    .default_submission_port  
  



  

    

The default mail submission port number, 587.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 181



def SMTP.default_submission_port
  587
end


  








  

    .default_tls_port  
    Also known as: .default_ssl_port
  



  

    

The default SMTPS port number, 465.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 186



def SMTP.default_tls_port
  465
end


  








  

    

      .start(address, port = nil, helo: 'localhost', user: nil, secret: nil, authtype: nil, tls_verify: true, tls_hostname: nil) {|smtp| ... } 
      .start(address, port = nil, helo = 'localhost', user = nil, secret = nil, authtype = nil) {|smtp| ... } 
    

  



  

    

Creates a new SMTP object and connects to the server.



This method is equivalent to:



Net::SMTP.new(address, port).start(helo: helo_domain, user: , 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 SMTP object is yielded to the block, and automatically closed when the block finishes.  If called without a block, the newly-opened 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:



  





  
Raises:


    
  
  • 
    (ArgumentError)
  
    • 





  [ GitHub ]


  

  


# 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


  







Instance Attribute Details



  

    #address   (readonly)
  



  

    

The address of the SMTP server to connect to.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 364



attr_reader :address


  








  

    #capable_cram_md5_auth?  ⇒ Boolean  (readonly)
  



  

    

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


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 274



def capable_cram_md5_auth?
  auth_capable?('CRAM-MD5')
end


  








  

    #capable_login_auth?  ⇒ Boolean  (readonly)
  



  

    

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


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 268



def 
  auth_capable?('LOGIN')
end


  








  

    #capable_plain_auth?  ⇒ Boolean  (readonly)
  



  

    

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


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 262



def capable_plain_auth?
  auth_capable?('PLAIN')
end


  








  

    #capable_starttls?  ⇒ Boolean  (readonly)
  



  

    

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


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 250



def capable_starttls?
  capable?('STARTTLS')
end


  








  

    #debug_output=(arg)   (writeonly)
    Also known as: #set_debug_output
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 400



def debug_output=(arg)
  @debug_output = arg
end


  








  

    #esmtp?   (rw)
  



  

    

Alias for #esmtp.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 246



alias :esmtp? :esmtp


  








  

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 372



attr_accessor :open_timeout


  








  

    #port   (readonly)
  



  

    

The port number of the SMTP server to connect to.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 367



attr_reader :port


  








  

    #read_timeout   (rw)
  



  

    

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.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 377



attr_reader :read_timeout


  








  

    #read_timeout=(sec)   (rw)
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 381



def read_timeout=(sec)
  @socket.read_timeout = sec if @socket
  @read_timeout = sec
end


  








  

    #ssl?   (readonly)
  



  

    

Alias for #tls?.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 298



alias ssl? tls?


  








  

    #started?  ⇒ Boolean  (readonly)
  



  

    

true if the SMTP session has been started.


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 479



def started?
  @started
end


  








  

    #starttls?  ⇒ Boolean  (readonly)
  



  

    

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.


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 324



def starttls?
  @starttls
end


  








  

    #starttls_always?  ⇒ Boolean  (readonly)
  



  

    

true if this object uses STARTTLS.


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 329



def starttls_always?
  @starttls == :always
end


  








  

    #starttls_auto?  ⇒ Boolean  (readonly)
  



  

    

true if this object uses STARTTLS when server advertises STARTTLS.


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 334



def starttls_auto?
  @starttls == :auto
end


  








  

    #tls?  ⇒ Boolean  (readonly)
    Also known as: #ssl?
  



  

    

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


  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 294



def tls?
  @tls
end


  







Instance Method Details



  

    #auth_capable?(type)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# 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_cram_md5(user, secret)  
  

  [ GitHub ]


  

  


# 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)  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 780



def (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_method(type)   (private)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 811



def auth_method(type)
  "auth_#{type.to_s.downcase}".intern
end


  








  

    #auth_plain(user, secret)  
  

  [ GitHub ]


  

  


# 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)  
  

  [ GitHub ]


  

  


# 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


  








  

    #base64_encode(str)   (private)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 824



def base64_encode(str)
  # expects "str" may not become too long
  [str].pack('m0')
end


  








  

    #capable?(key)  ⇒ Boolean  (private)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 254



def capable?(key)
  return nil unless @capabilities
  @capabilities[key] ? true : false
end


  








  

    #capable_auth_types  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 287



def capable_auth_types
  return [] unless @capabilities
  return [] unless @capabilities['AUTH']
  @capabilities['AUTH']
end


  








  

    #check_auth_args(user, secret, authtype = DEFAULT_AUTH_TYPE)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 1013



def check_auth_response(res)
  unless res.success?
    raise SMTPAuthenticationError, res.message
  end
end


  








  

    #check_continue(res)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  



  

    

CRAM-MD5: [RFC2195]


  



  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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   (private)
  

  [ GitHub ]


  

  


# 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


  








  

    #data(msgstr = nil, &block)  
  



  

    

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."
}


  



  [ GitHub ]


  

  


# 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


  








  

    #disable_ssl  
  



  

    

Alias for #disable_tls.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 319



alias disable_ssl disable_tls


  








  

    #disable_starttls  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 358



def disable_starttls
  @starttls = false
  @ssl_context_starttls = nil
end


  








  

    #disable_tls  
    Also known as: #disable_ssl
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 314



def disable_tls
  @tls = false
  @ssl_context_tls = nil
end


  








  

    #do_finish   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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


  








  

    #ehlo(domain)  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 869



def ehlo(domain)
  getok("EHLO #{domain}")
end


  








  

    #enable_ssl(context = nil)  
  



  

    

Alias for #enable_tls.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 310



alias enable_ssl enable_tls


  








  

    #enable_starttls(context = nil)  
  



  

    

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


  





  
Raises:


    
  
  • 
    (ArgumentError)
  
    • 





  [ GitHub ]


  

  


# 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)  
  



  

    

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


  





  
Raises:


    
  
  • 
    (ArgumentError)
  
    • 





  [ GitHub ]


  

  


# 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)  
    Also known as: #enable_ssl
  



  

    

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.


  





  
Raises:


    
  
  • 
    (ArgumentError)
  
    • 





  [ GitHub ]


  

  


# 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


  








  

    #esmtp   (rw)
    Also known as: #esmtp?
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 243



attr_accessor :esmtp


  








  

    #finish  
  



  

    

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


  





  
Raises:


    
  
  • 
    (IOError)
  
    • 





  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 570



def finish
  raise IOError, 'not yet started' unless started?
  do_finish
end


  








  

    #get_response(reqline)   (private)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 975



def get_response(reqline)
  validate_line reqline
  @socket.writeline reqline
  recv_response()
end


  








  

    #getok(reqline)   (private)
  

  [ GitHub ]


  

  


# 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


  








  

    #helo(domain)  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 865



def helo(domain)
  getok("HELO #{domain}")
end


  








  

    #inspect  
  



  

    

Provide human-readable stringification of class state.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 232



def inspect
  "#<#{self.class} #{@address}:#{@port} started=#{@started}>"
end


  








  

    #logging(msg)  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 1104



def logging(msg)
  @debug_output << msg + "\n" if @debug_output
end


  








  

    #mailfrom(from_addr)  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 873



def mailfrom(from_addr)
  getok("MAIL FROM:<#{from_addr}>")
end


  








  

    #new_internet_message_io(s)   (private)
  

  [ GitHub ]


  

  


# 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


  








  

    #open_message_stream(from_addr, *to_addrs, &block)  
    Also known as: #ready
  



  

    

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:



  





  
Raises:


    
  
  • 
    (IOError)
  
    • 





  [ GitHub ]


  

  


# 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


  








  

    #quit  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 952



def quit
  getok('QUIT')
end


  








  

    #rcptto(to_addr)  
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 898



def rcptto(to_addr)
  getok("RCPT TO:<#{to_addr}>")
end


  








  

    #rcptto_list(to_addrs)  
  



  

    
  





  
Raises:


    
  
  • 
    (ArgumentError)
  
    • 





  [ GitHub ]


  

  


# 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


  








  

    #ready(from_addr, *to_addrs, &block)  
  



  

    

Alias for #open_message_stream.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 755



alias ready open_message_stream   # obsolete


  








  

    #recv_response   (private)
  

  [ GitHub ]


  

  


# 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


  








  

    #rset  
  



  

    

Aborts the current mail transaction


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 857



def rset
  getok('RSET')
end


  








  

    #send_mail(msgstr, from_addr, *to_addrs)  
  



  

    

Alias for #send_message.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 702



alias send_mail send_message


  








  

    #send_message(msgstr, from_addr, *to_addrs)  
    Also known as: #send_mail, #sendmail
  



  

    

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:



  





  
Raises:


    
  
  • 
    (IOError)
  
    • 





  [ GitHub ]


  

  


# 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


  








  

    #sendmail(msgstr, from_addr, *to_addrs)  
  



  

    

Alias for #send_message.


  



  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 703



alias sendmail send_message   # obsolete


  








  

    #ssl_socket(socket, context)   (private)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 614



def ssl_socket(socket, context)
  OpenSSL::SSL::SSLSocket.new socket, context
end


  








  

    

      #start(helo: 'localhost', user: nil, secret: nil, authtype: nil, tls_verify: true, tls_hostname: nil) {|smtp| ... } 
      #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 .start.



require 'net/smtp'
smtp = Net::SMTP.new('smtp.mail.server', 25)
smtp.start(helo: helo_domain, user: , 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 .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:



  





  
Raises:


    
  
  • 
    (ArgumentError)
  
    • 





  [ GitHub ]


  

  


# 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


  








  

    #starttls   (readonly)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 861



def starttls
  getok('STARTTLS')
end


  








  

    #tcp_socket(address, port)   (private)
  

  [ GitHub ]


  

  


# File 'lib/net/smtp.rb', line 577



def tcp_socket(address, port)
  TCPSocket.open address, port
end


  








  

    #tlsconnect(s, context)   (private)
  

  [ GitHub ]


  

  


# 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)   (private)
  

  [ GitHub ]


  

  


# 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