Class: Net::SMTP

Inherits:
Object
  • Object
show all
Defined in:
lib/net/smtp.rb

Overview

Net::SMTP

What is This Library?

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

What is This Library NOT?

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

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

Examples

Sending Messages

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

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

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

Then you can send messages.

msgstr = <<END_OF_MESSAGE
From: Your Name <[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/SMTP#start. This closes the SMTP session automatically:

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

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

HELO domain

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

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

SMTP Authentication

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

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

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

Constant Summary collapse

Revision = 
%q$Revision: 28208 $.split[1]
DEFAULT_AUTH_TYPE = 
:plain

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(address, port = 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.

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.



211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/net/smtp.rb', line 211

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_occured = false
  @debug_output = nil
  @tls = false
  @starttls = false
  @ssl_context = nil
end

Instance Attribute Details

#address ⇒ Object (readonly)

The address of the SMTP server to connect to.



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

def address
  @address
end

#open_timeout ⇒ Object

Seconds to wait while attempting to open a connection. If the connection cannot be opened within this time, a TimeoutError is raised.



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

def open_timeout
  @open_timeout
end

#port ⇒ Object (readonly)

The port number of the SMTP server to connect to.



369
370
371
 
# File 'lib/net/smtp.rb', line 369

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 TimeoutError is raised.



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

def read_timeout
  @read_timeout
end

Class Method Details

.default_port ⇒ Object

The default SMTP port number, 25.



178
179
180
 
# File 'lib/net/smtp.rb', line 178

def SMTP.default_port
  25
end

.default_ssl_context ⇒ Object 



196
197
198
 
# File 'lib/net/smtp.rb', line 196

def SMTP.default_ssl_context
  OpenSSL::SSL::SSLContext.new
end

.default_submission_port ⇒ Object

The default mail submission port number, 587.



183
184
185
 
# File 'lib/net/smtp.rb', line 183

def SMTP.default_submission_port
  587
end

.default_tls_port ⇒ Object Also known as: default_ssl_port

The default SMTPS port number, 465.



188
189
190
 
# File 'lib/net/smtp.rb', line 188

def SMTP.default_tls_port
  465
end

.start(address, port = nil, helo = 'localhost.localdomain', user = nil, secret = nil, authtype = nil, &block) ⇒ Object

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

This method is equivalent to:

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

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.localdomain???.

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

Errors

This method may raise:

  • Net::SMTPAuthenticationError

  • Net::SMTPServerBusy

  • Net::SMTPSyntaxError

  • Net::SMTPFatalError

  • Net::SMTPUnknownError

  • IOError

  • TimeoutError



460
461
462
463
464
 
# File 'lib/net/smtp.rb', line 460

def SMTP.start(address, port = nil, helo = 'localhost.localdomain',
               user = nil, secret = nil, authtype = nil,
               &block)   # :yield: smtp
  new(address, port).start(helo, user, secret, authtype, &block)
end

Instance Method Details

#auth_cram_md5(user, secret) ⇒ Object 



746
747
748
749
750
751
752
753
754
755
756
 
# File 'lib/net/smtp.rb', line 746

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



735
736
737
738
739
740
741
742
743
744
 
# File 'lib/net/smtp.rb', line 735

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_plain(user, secret) ⇒ Object 



726
727
728
729
730
731
732
733
 
# File 'lib/net/smtp.rb', line 726

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



720
721
722
723
724
 
# File 'lib/net/smtp.rb', line 720

def authenticate(user, secret, authtype = DEFAULT_AUTH_TYPE)
  check_auth_method authtype
  check_auth_args user, secret
  send auth_method(authtype), user, secret
end

#capable_auth_types ⇒ Object

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



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

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) 


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

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) 


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

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) 


264
265
266
 
# File 'lib/net/smtp.rb', line 264

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) 


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

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



880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
 
# File 'lib/net/smtp.rb', line 880

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')
    if msgstr
      @socket.write_message msgstr
    else
      @socket.write_message_by_block(&block)
    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



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

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.



360
361
362
363
 
# File 'lib/net/smtp.rb', line 360

def disable_starttls
  @starttls = false
  @ssl_context = 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.



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

def disable_tls
  @tls = false
  @ssl_context = nil
end

#ehlo(domain) ⇒ Object 



818
819
820
 
# File 'lib/net/smtp.rb', line 818

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

#enable_starttls(context = SMTP.default_ssl_context) ⇒ Object

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

Raises:

  • (ArgumentError) 


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

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

#enable_starttls_auto(context = SMTP.default_ssl_context) ⇒ Object

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

Raises:

  • (ArgumentError) 


351
352
353
354
355
356
 
# File 'lib/net/smtp.rb', line 351

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

#enable_tls(context = SMTP.default_ssl_context) ⇒ 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) 


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

def enable_tls(context = SMTP.default_ssl_context)
  raise 'openssl library not installed' unless defined?(OpenSSL)
  raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @starttls
  @tls = true
  @ssl_context = context
end

#esmtp=(bool) ⇒ Object

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



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

def esmtp=(bool)
  @esmtp = bool
end

#esmtp? ⇒ Boolean Also known as: esmtp

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

Returns:

  • (Boolean) 


233
234
235
 
# File 'lib/net/smtp.rb', line 233

def esmtp?
  @esmtp
end

#finish ⇒ Object

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

Raises:

  • (IOError) 


538
539
540
541
 
# File 'lib/net/smtp.rb', line 538

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

#helo(domain) ⇒ Object 



814
815
816
 
# File 'lib/net/smtp.rb', line 814

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

#inspect ⇒ Object

Provide human-readable stringification of class state.



228
229
230
 
# File 'lib/net/smtp.rb', line 228

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

#mailfrom(from_addr) ⇒ Object 



822
823
824
825
826
827
 
# File 'lib/net/smtp.rb', line 822

def mailfrom(from_addr)
  if $SAFE > 0
    raise SecurityError, 'tainted from_addr' if from_addr.tainted?
  end
  getok("MAIL FROM:<#{from_addr}>")
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 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('[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

  • IOError

  • TimeoutError

Raises:

  • (IOError) 


704
705
706
707
708
 
# File 'lib/net/smtp.rb', line 704

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



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

def quit
  getok('QUIT')
end

#rcptto(to_addr) ⇒ Object 



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

def rcptto(to_addr)
  if $SAFE > 0
    raise SecurityError, 'tainted to_addr' if to_addr.tainted?
  end
  getok("RCPT TO:<#{to_addr}>")
end

#rcptto_list(to_addrs) ⇒ Object

Raises:

  • (ArgumentError) 


829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
 
# File 'lib/net/smtp.rb', line 829

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

#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 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,
                    '[email protected]',
                    ['[email protected]', '[email protected]']
end

Errors

This method may raise:

  • Net::SMTPServerBusy

  • Net::SMTPSyntaxError

  • Net::SMTPFatalError

  • Net::SMTPUnknownError

  • IOError

  • TimeoutError

Raises:

  • (IOError) 


651
652
653
654
655
 
# File 'lib/net/smtp.rb', line 651

def send_message(msgstr, from_addr, *to_addrs)
  raise IOError, 'closed session' unless @socket
  mailfrom from_addr
  rcptto_list(to_addrs) {data msgstr}
end

#start(helo = 'localhost.localdomain', user = nil, secret = nil, authtype = nil) ⇒ Object

Opens a TCP connection and starts the SMTP session.

Parameters

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

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

Block Usage

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

Example

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

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

  • IOError

  • TimeoutError



521
522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'lib/net/smtp.rb', line 521

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

#started? ⇒ Boolean

true if the SMTP session has been started.

Returns:

  • (Boolean) 


467
468
469
 
# File 'lib/net/smtp.rb', line 467

def started?
  @started
end

#starttls ⇒ Object 



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

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) 


326
327
328
 
# File 'lib/net/smtp.rb', line 326

def starttls?
  @starttls
end

#starttls_always? ⇒ Boolean

true if this object uses STARTTLS.

Returns:

  • (Boolean) 


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

def starttls_always?
  @starttls == :always
end

#starttls_auto? ⇒ Boolean

true if this object uses STARTTLS when server advertises STARTTLS.

Returns:

  • (Boolean) 


336
337
338
 
# File 'lib/net/smtp.rb', line 336

def starttls_auto?
  @starttls == :auto
end

#tls? ⇒ Boolean Also known as: ssl?

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

Returns:

  • (Boolean) 


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

def tls?
  @tls
end