Class: Net::SMTP

Inherits:
Protocol
  • Object
show all
Defined in:
lib/net/smtp.rb,
lib/net/smtp/auth_login.rb,
lib/net/smtp/auth_plain.rb,
lib/net/smtp/auth_xoauth2.rb,
lib/net/smtp/auth_cram_md5.rb,
lib/net/smtp/authenticator.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 [RFC5321]. This library also implements SMTP authentication, which is often necessary for message composers to submit messages to their outgoing SMTP server, see [RFC6409], and [SMTPUTF8], which is necessary to send messages to/from addresses containing characters outside the ASCII range.

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 the mail or rmail gems, or search for alternatives in RubyGems.org or The Ruby Toolbox.

FYI: the official specification on internet mail is: [RFC5322].

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 <[email protected]>
To: Destination Address <[email protected]>
Subject: test message
Date: Sat, 23 Jun 2001 16:26:43 +0900
Message-Id: <[email protected]>

This is a test message.
END_OF_MESSAGE

require 'net/smtp'
Net::SMTP.start('your.smtp.server', 25) do |smtp|
  smtp.send_message msgstr,
                    '[email protected]',
                    '[email protected]'
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 or 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 or 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') do |smtp|
  smtp.send_message msgstr, 'from@address', 'to@address'
end

SMTP Authentication

The Net::SMTP class supports the SMTP extension for SASL Authentication

RFC4954

and the following

SASL mechanisms: PLAIN, LOGIN _(deprecated)_, and CRAM-MD5 _(deprecated)_.

To use SMTP authentication, pass extra arguments to SMTP.start or SMTP#start.

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

Support for other SASL mechanisms-such as EXTERNAL, OAUTHBEARER, SCRAM-SHA-256, and XOAUTH2-will be added in a future release.

The LOGIN and CRAM-MD5 mechanisms are still available for backwards compatibility, but are deprecated and should be avoided.

Defined Under Namespace

Classes: Address, AuthCramMD5, AuthLogin, AuthPlain, AuthXoauth2, Authenticator, Response

Constant Summary collapse

VERSION = 
"0.5.0"
DEFAULT_AUTH_TYPE =

Authentication

:plain

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(address, port = nil, tls: false, starttls: :auto, tls_verify: true, tls_hostname: nil, ssl_context_params: nil) ⇒ SMTP

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.

If tls is true, enable TLS. The default is false. If starttls is :always, enable STARTTLS, if :auto, use STARTTLS when the server supports it, if false, disable STARTTLS.

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.

Additional SSLContext params can be added to the ssl_context_params hash argument and are passed to OpenSSL::SSL::SSLContext#set_params.

tls_verify: true is equivalent to ssl_context_params: { verify_mode: OpenSSL::SSL::VERIFY_PEER }.

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.



248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/net/smtp.rb', line 248

def initialize(address, port = nil, tls: false, starttls: :auto, tls_verify: true, tls_hostname: nil, ssl_context_params: 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 = tls
  @starttls = starttls
  @ssl_context_tls = nil
  @ssl_context_starttls = nil
  @tls_verify = tls_verify
  @tls_hostname = tls_hostname
  @ssl_context_params = ssl_context_params
end

Instance Attribute Details

#address ⇒ Object (readonly)

The address of the SMTP server to connect to.



414
415
416
 
# File 'lib/net/smtp.rb', line 414

def address
  @address
end

#capabilities ⇒ Object (readonly)

The server capabilities by EHLO response



307
308
309
 
# File 'lib/net/smtp.rb', line 307

def capabilities
  @capabilities
end

#esmtp ⇒ Object 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).



289
290
291
 
# File 'lib/net/smtp.rb', line 289

def esmtp
  @esmtp
end

#open_timeout ⇒ Object

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.



422
423
424
 
# File 'lib/net/smtp.rb', line 422

def open_timeout
  @open_timeout
end

#port ⇒ Object (readonly)

The port number of the SMTP server to connect to.



417
418
419
 
# File 'lib/net/smtp.rb', line 417

def port
  @port
end

#read_timeout ⇒ Object

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.



427
428
429
 
# File 'lib/net/smtp.rb', line 427

def read_timeout
  @read_timeout
end

#ssl_context_params ⇒ Object

Hash for additional SSLContext parameters.



275
276
277
 
# File 'lib/net/smtp.rb', line 275

def ssl_context_params
  @ssl_context_params
end

#tls_hostname ⇒ Object

The hostname for verifying hostname in the server certificatate.



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

def tls_hostname
  @tls_hostname
end

#tls_verify ⇒ Object

If true, verify th server’s certificate.



269
270
271
 
# File 'lib/net/smtp.rb', line 269

def tls_verify
  @tls_verify
end

Class Method Details

.default_port ⇒ Object

The default SMTP port number, 25.



198
199
200
 
# File 'lib/net/smtp.rb', line 198

def SMTP.default_port
  25
end

.default_ssl_context(ssl_context_params = nil) ⇒ Object 



216
217
218
219
220
 
# File 'lib/net/smtp.rb', line 216

def SMTP.default_ssl_context(ssl_context_params = nil)
  context = OpenSSL::SSL::SSLContext.new
  context.set_params(ssl_context_params || {})
  context
end

.default_submission_port ⇒ Object

The default mail submission port number, 587.



203
204
205
 
# File 'lib/net/smtp.rb', line 203

def SMTP.default_submission_port
  587
end

.default_tls_port ⇒ Object Also known as: default_ssl_port

The default SMTPS port number, 465.



208
209
210
 
# File 'lib/net/smtp.rb', line 208

def SMTP.default_tls_port
  465
end

.start(address, port = nil, *args, helo: nil, user: nil, secret: nil, password: nil, authtype: nil, tls: false, starttls: :auto, tls_verify: true, tls_hostname: nil, ssl_context_params: nil, &block) ⇒ Object

:call-seq:

start(address, port = nil, helo: 'localhost', user: nil, secret: nil, authtype: nil, tls: false, starttls: :auto, tls_verify: true, tls_hostname: nil, ssl_context_params: nil) { |smtp| ... }
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, tls_verify: flag, tls_hostname: hostname, ssl_context_params: nil)
  .start(helo: helo_domain, user: , secret: password, authtype: authtype)

See also: Net::SMTP.new, #start

Example

Net::SMTP.start('your.smtp.server') do |smtp|
  smtp.send_message msgstr, '[email protected]', ['[email protected]']
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’.

If tls is true, enable TLS. The default is false. If starttls is :always, enable STARTTLS, if :auto, use STARTTLS when the server supports it, if false, disable STARTTLS.

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.

Additional SSLContext params can be added to the ssl_context_params hash argument and are passed to OpenSSL::SSL::SSLContext#set_params.

tls_verify: true is equivalent to ssl_context_params: { verify_mode: OpenSSL::SSL::VERIFY_PEER }.

The remaining arguments are used for SMTP authentication, if required or desired.

authtype is the SASL authentication mechanism.

user is the authentication or authorization identity.

secret or password is your password or other authentication token.

These will be sent to #authenticate as positional arguments-the exact semantics are dependent on the authtype.

See the discussion of Net::SMTP@SMTP+Authentication in the overview notes.

Errors

This method may raise:

  • Net::SMTPAuthenticationError

  • Net::SMTPServerBusy

  • Net::SMTPSyntaxError

  • Net::SMTPFatalError

  • Net::SMTPUnknownError

  • Net::OpenTimeout

  • Net::ReadTimeout

  • IOError

Raises:

  • (ArgumentError) 


539
540
541
542
543
544
545
546
547
548
549
550
 
# File 'lib/net/smtp.rb', line 539

def SMTP.start(address, port = nil, *args, helo: nil,
               user: nil, secret: nil, password: nil, authtype: nil,
               tls: false, starttls: :auto,
               tls_verify: true, tls_hostname: nil, ssl_context_params: 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, tls: tls, starttls: starttls, tls_verify: tls_verify, tls_hostname: tls_hostname, ssl_context_params: ssl_context_params).start(helo: helo, user: user, secret: secret, authtype: authtype, &block)
end

Instance Method Details

#auth_capable?(type) ⇒ Boolean

Returns whether the server advertises support for the authentication type. You cannot get valid result before opening SMTP session.

Returns:

  • (Boolean) 


329
330
331
332
333
 
# File 'lib/net/smtp.rb', line 329

def auth_capable?(type)
  return nil unless @capabilities
  return false unless @capabilities['AUTH']
  @capabilities['AUTH'].include?(type)
end

#authenticate(user, secret, authtype = DEFAULT_AUTH_TYPE) ⇒ Object

Authenticates with the server, using the “AUTH” command.

authtype is the name of a SASL authentication mechanism.

All arguments-other than authtype-are forwarded to the authenticator. Different authenticators may interpret the user and secret arguments differently.



872
873
874
875
876
 
# File 'lib/net/smtp.rb', line 872

def authenticate(user, secret, authtype = DEFAULT_AUTH_TYPE)
  check_auth_args authtype, user, secret
  authenticator = Authenticator.auth_class(authtype).new(self)
  authenticator.auth(user, secret)
end

#capable?(key) ⇒ Boolean

true if the EHLO response contains key.

Returns:

  • (Boolean) 


301
302
303
304
 
# File 'lib/net/smtp.rb', line 301

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

#capable_auth_types ⇒ Object

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



337
338
339
340
341
 
# File 'lib/net/smtp.rb', line 337

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

#capable_cram_md5_auth? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

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

#capable_login_auth? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def 
  auth_capable?('LOGIN')
end

#capable_plain_auth? ⇒ Boolean

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

Returns:

  • (Boolean) 


311
312
313
 
# File 'lib/net/smtp.rb', line 311

def capable_plain_auth?
  auth_capable?('PLAIN')
end

#capable_starttls? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def capable_starttls?
  capable?('STARTTLS')
end

#data(msgstr = nil, &block) ⇒ Object

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: [email protected]
To: [email protected]
Subject: I found a bug

Check vm.c:58879.
EndMessage

# Example 2 (by block)
smtp.data {|f|
  f.puts "From: [email protected]"
  f.puts "To: [email protected]"
  f.puts "Subject: I found a bug"
  f.puts ""
  f.puts "Check vm.c:58879."
}



958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
 
# File 'lib/net/smtp.rb', line 958

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) ⇒ Object 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



450
451
452
 
# File 'lib/net/smtp.rb', line 450

def debug_output=(arg)
  @debug_output = arg
end

#disable_starttls ⇒ Object

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



408
409
410
411
 
# File 'lib/net/smtp.rb', line 408

def disable_starttls
  @starttls = false
  @ssl_context_starttls = nil
end

#disable_tls ⇒ Object Also known as: disable_ssl

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



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

def disable_tls
  @tls = false
  @ssl_context_tls = nil
end

#ehlo(domain) ⇒ Object 



907
908
909
 
# File 'lib/net/smtp.rb', line 907

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

#enable_starttls(context = nil) ⇒ Object

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

Raises:

  • (ArgumentError) 


390
391
392
393
394
395
 
# File 'lib/net/smtp.rb', line 390

def enable_starttls(context = nil)
  raise 'openssl library not installed' unless defined?(OpenSSL::VERSION)
  raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @tls
  @starttls = :always
  @ssl_context_starttls = context
end

#enable_starttls_auto(context = nil) ⇒ Object

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

Raises:

  • (ArgumentError) 


399
400
401
402
403
404
 
# File 'lib/net/smtp.rb', line 399

def enable_starttls_auto(context = nil)
  raise 'openssl library not installed' unless defined?(OpenSSL::VERSION)
  raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @tls
  @starttls = :auto
  @ssl_context_starttls = context
end

#enable_tls(context = nil) ⇒ Object 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) 


353
354
355
356
357
358
 
# File 'lib/net/smtp.rb', line 353

def enable_tls(context = nil)
  raise 'openssl library not installed' unless defined?(OpenSSL::VERSION)
  raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @starttls == :always
  @tls = true
  @ssl_context_tls = context
end

#finish ⇒ Object

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

Raises:

  • (IOError) 


655
656
657
658
 
# File 'lib/net/smtp.rb', line 655

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

#get_response(reqline) ⇒ Object 



989
990
991
992
993
 
# File 'lib/net/smtp.rb', line 989

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

#helo(domain) ⇒ Object 



903
904
905
 
# File 'lib/net/smtp.rb', line 903

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

#inspect ⇒ Object

Provide human-readable stringification of class state.



278
279
280
 
# File 'lib/net/smtp.rb', line 278

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

#mailfrom(from_addr) ⇒ Object

from_addr is String or Net::SMTP::Address



912
913
914
915
916
917
918
919
 
# File 'lib/net/smtp.rb', line 912

def mailfrom(from_addr)
  addr = if requires_smtputf8(from_addr) && capable?("SMTPUTF8")
           Address.new(from_addr, "SMTPUTF8")
         else
           Address.new(from_addr)
         end
  getok((["MAIL FROM:<#{addr.address}>"] + addr.parameters).join(' '))
end

#open_message_stream(from_addr, *to_addrs, &block) ⇒ Object 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 or Net::SMTP::Address representing the source mail address.

to_addr is a String or Net::SMTP::Address or Array of them, representing the destination mail address or addresses.

Example

Net::SMTP.start('smtp.example.com', 25) do |smtp|
  smtp.open_message_stream('[email protected]', ['[email protected]']) do |f|
    f.puts 'From: [email protected]'
    f.puts 'To: [email protected]'
    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

Raises:

  • (IOError) 


849
850
851
852
853
854
855
 
# File 'lib/net/smtp.rb', line 849

def open_message_stream(from_addr, *to_addrs, &block)   # :yield: stream
  to_addrs.flatten!
  raise IOError, 'closed session' unless @socket
  from_addr = Address.new(from_addr, 'SMTPUTF8') if any_require_smtputf8(to_addrs) && capable?('SMTPUTF8')
  mailfrom from_addr
  rcptto_list(to_addrs) {data(&block)}
end

#quit ⇒ Object 



985
986
987
 
# File 'lib/net/smtp.rb', line 985

def quit
  getok('QUIT')
end

#rcptto(to_addr) ⇒ Object

to_addr is String or Net::SMTP::Address



930
931
932
933
 
# File 'lib/net/smtp.rb', line 930

def rcptto(to_addr)
  addr = Address.new(to_addr)
  getok((["RCPT TO:<#{addr.address}>"] + addr.parameters).join(' '))
end

#rcptto_list(to_addrs) ⇒ Object

Raises:

  • (ArgumentError) 


921
922
923
924
925
926
927
 
# File 'lib/net/smtp.rb', line 921

def rcptto_list(to_addrs)
  raise ArgumentError, 'mail destination not given' if to_addrs.empty?
  to_addrs.flatten.each do |addr|
    rcptto addr
  end
  yield
end

#rset ⇒ Object

Aborts the current mail transaction



895
896
897
 
# File 'lib/net/smtp.rb', line 895

def rset
  getok('RSET')
end

#send_message(msgstr, from_addr, *to_addrs) ⇒ Object 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 or Net::SMTP::Address representing the source mail address.

to_addr is a String or Net::SMTP::Address or Array of them, representing the destination mail address or addresses.

Example

Net::SMTP.start('smtp.example.com') do |smtp|
  smtp.send_message msgstr,
                    '[email protected]',
                    ['[email protected]', '[email protected]']
end

Net::SMTP.start('smtp.example.com') do |smtp|
  smtp.send_message msgstr,
                    Net::SMTP::Address.new('[email protected]', size: 12345),
                    Net::SMTP::Address.new('[email protected]', notify: :success)
end

Errors

This method may raise:

  • Net::SMTPServerBusy

  • Net::SMTPSyntaxError

  • Net::SMTPFatalError

  • Net::SMTPUnknownError

  • Net::ReadTimeout

  • IOError

Raises:

  • (IOError) 


794
795
796
797
798
799
800
 
# File 'lib/net/smtp.rb', line 794

def send_message(msgstr, from_addr, *to_addrs)
  to_addrs.flatten!
  raise IOError, 'closed session' unless @socket
  from_addr = Address.new(from_addr, 'SMTPUTF8') if any_require_smtputf8(to_addrs) && capable?('SMTPUTF8')
  mailfrom from_addr
  rcptto_list(to_addrs) {data msgstr}
end

#start(*args, helo: nil, user: nil, secret: nil, password: nil, authtype: nil) ⇒ Object

:call-seq:

start(helo: 'localhost', user: nil, secret: nil, authtype: 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.

The remaining arguments are used for SMTP authentication, if required or desired.

authtype is the SASL authentication mechanism.

user is the authentication or authorization identity.

secret or password is your password or other authentication token.

These will be sent to #authenticate as positional arguments-the exact semantics are dependent on the authtype.

See the discussion of Net::SMTP@SMTP+Authentication in the overview notes.

See also: Net::SMTP.start

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: , secret: password, authtype: authtype) do |smtp|
  smtp.send_message msgstr, '[email protected]', ['[email protected]']
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

Raises:

  • (ArgumentError) 


622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
 
# File 'lib/net/smtp.rb', line 622

def start(*args, helo: nil, user: nil, secret: nil, password: nil, authtype: 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 defined?(OpenSSL::VERSION)
    ssl_context_params = @ssl_context_params || {}
    unless ssl_context_params.has_key?(:verify_mode)
      ssl_context_params[:verify_mode] = @tls_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
    end
    if @tls && @ssl_context_tls.nil?
      @ssl_context_tls = SMTP.default_ssl_context(ssl_context_params)
    end
    if @starttls && @ssl_context_starttls.nil?
      @ssl_context_starttls = SMTP.default_ssl_context(ssl_context_params)
    end
  end
  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? ⇒ Boolean

true if the SMTP session has been started.

Returns:

  • (Boolean) 


553
554
555
 
# File 'lib/net/smtp.rb', line 553

def started?
  @started
end

#starttls ⇒ Object 



899
900
901
 
# File 'lib/net/smtp.rb', line 899

def starttls
  getok('STARTTLS')
end

#starttls? ⇒ Boolean

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.

Returns:

  • (Boolean) 


374
375
376
 
# File 'lib/net/smtp.rb', line 374

def starttls?
  @starttls
end

#starttls_always? ⇒ Boolean

true if this object uses STARTTLS.

Returns:

  • (Boolean) 


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

def starttls_always?
  @starttls == :always
end

#starttls_auto? ⇒ Boolean

true if this object uses STARTTLS when server advertises STARTTLS.

Returns:

  • (Boolean) 


384
385
386
 
# File 'lib/net/smtp.rb', line 384

def starttls_auto?
  @starttls == :auto
end

#tls? ⇒ Boolean Also known as: ssl?

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

Returns:

  • (Boolean) 


344
345
346
 
# File 'lib/net/smtp.rb', line 344

def tls?
  @tls
end