Class Net::SMTP
In: lib/net/smtp.rb
Parent: Object

Net::SMTP

What is This Library?

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

What is This Library NOT?

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

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

Examples

Sending Messages

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

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

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

Then you can send messages.

    msgstr = <<END_OF_MESSAGE
    From: Your Name <your@mail.address>
    To: Destination Address <someone@example.com>
    Subject: test message
    Date: Sat, 23 Jun 2001 16:26:43 +0900
    Message-Id: <unique.message.id.string@example.com>

    This is a test message.
    END_OF_MESSAGE

    require 'net/smtp'
    Net::SMTP.start('your.smtp.server', 25) do |smtp|
      smtp.send_message msgstr,
                        'your@mail.address',
                        'his_addess@example.com'
    end

Closing the Session

You MUST close the SMTP session after sending messages, by calling the finish method:

    # using SMTP#finish
    smtp = Net::SMTP.start('your.smtp.server', 25)
    smtp.send_message msgstr, 'from@address', 'to@address'
    smtp.finish

You can also use the block form of SMTP.start/SMTP#start. This closes the SMTP session automatically:

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

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

HELO domain

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

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

SMTP Authentication

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

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

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

Methods

Classes and Modules

Class Net::SMTP::Response

Constants

Revision = %q$Revision: 18353 $.split[1]
DEFAULT_AUTH_TYPE = :plain   Authentication
IMASK = 0x36
OMASK = 0x5c
CRAM_BUFSIZE = 64

External Aliases

default_tls_port -> default_ssl_port

Attributes

address  [R]  The address of the SMTP server to connect to.
open_timeout  [RW]  Seconds to wait while attempting to open a connection. If the connection cannot be opened within this time, a TimeoutError is raised.
port  [R]  The port number of the SMTP server to connect to.
read_timeout  [R]  Seconds to wait while reading one block (by one read(2) call). If the read(2) call does not complete within this time, a TimeoutError is raised.

Public Class methods

The default SMTP port number, 25.

[Source]

     # File lib/net/smtp.rb, line 178
178:     def SMTP.default_port
179:       25
180:     end

[Source]

     # File lib/net/smtp.rb, line 196
196:     def SMTP.default_ssl_context
197:       OpenSSL::SSL::SSLContext.new
198:     end

The default mail submission port number, 587.

[Source]

     # File lib/net/smtp.rb, line 183
183:     def SMTP.default_submission_port
184:       587
185:     end

The default SMTPS port number, 465.

[Source]

     # File lib/net/smtp.rb, line 188
188:     def SMTP.default_tls_port
189:       465
190:     end

Creates a new Net::SMTP object.

address is the hostname or ip address of your SMTP server. port is the port to connect to; it defaults to port 25.

This method does not open the TCP connection. You can use SMTP.start instead of SMTP.new if you want to do everything at once. Otherwise, follow SMTP.new with SMTP#start.

[Source]

     # File lib/net/smtp.rb, line 211
211:     def initialize(address, port = nil)
212:       @address = address
213:       @port = (port || SMTP.default_port)
214:       @esmtp = true
215:       @capabilities = nil
216:       @socket = nil
217:       @started = false
218:       @open_timeout = 30
219:       @read_timeout = 60
220:       @error_occured = false
221:       @debug_output = nil
222:       @tls = false
223:       @starttls = false
224:       @ssl_context = nil
225:     end

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

This method is equivalent to:

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

Example

    Net::SMTP.start('your.smtp.server') do |smtp|
      smtp.send_message msgstr, 'from@example.com', ['dest@example.com']
    end

Block Usage

If called with a block, the newly-opened Net::SMTP object is yielded to the block, and automatically closed when the block finishes. If called without a block, the newly-opened Net::SMTP object is returned to the caller, and it is the caller‘s responsibility to close it when finished.

Parameters

address is the hostname or ip address of your smtp server.

port is the port to connect to; it defaults to port 25.

helo is the HELO domain provided by the client to the server (see overview comments); it defaults to ‘localhost.localdomain’.

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

Errors

This method may raise:

[Source]

     # File lib/net/smtp.rb, line 460
460:     def SMTP.start(address, port = nil, helo = 'localhost.localdomain',
461:                    user = nil, secret = nil, authtype = nil,
462:                    &block)   # :yield: smtp
463:       new(address, port).start(helo, user, secret, authtype, &block)
464:     end

Public Instance methods

[Source]

     # File lib/net/smtp.rb, line 748
748:     def auth_cram_md5(user, secret)
749:       check_auth_args user, secret
750:       res = critical {
751:         res0 = get_response('AUTH CRAM-MD5')
752:         check_auth_continue res0
753:         crammed = cram_md5_response(secret, res0.cram_md5_challenge)
754:         get_response(base64_encode("#{user} #{crammed}"))
755:       }
756:       check_auth_response res
757:       res
758:     end

[Source]

     # File lib/net/smtp.rb, line 737
737:     def auth_login(user, secret)
738:       check_auth_args user, secret
739:       res = critical {
740:         check_auth_continue get_response('AUTH LOGIN')
741:         check_auth_continue get_response(base64_encode(user))
742:         get_response(base64_encode(secret))
743:       }
744:       check_auth_response res
745:       res
746:     end

[Source]

     # File lib/net/smtp.rb, line 728
728:     def auth_plain(user, secret)
729:       check_auth_args user, secret
730:       res = critical {
731:         get_response('AUTH PLAIN ' + base64_encode("\0#{user}\0#{secret}"))
732:       }
733:       check_auth_response res
734:       res
735:     end

[Source]

     # File lib/net/smtp.rb, line 722
722:     def authenticate(user, secret, authtype = DEFAULT_AUTH_TYPE)
723:       check_auth_method authtype
724:       check_auth_args user, secret
725:       send auth_method(authtype), user, secret
726:     end

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

[Source]

     # File lib/net/smtp.rb, line 289
289:     def capable_auth_types
290:       return [] unless @capabilities
291:       return [] unless @capabilities['AUTH']
292:       @capabilities['AUTH']
293:     end

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

[Source]

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

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

[Source]

     # File lib/net/smtp.rb, line 270
270:     def capable_login_auth?
271:       auth_capable?('LOGIN')
272:     end

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

[Source]

     # File lib/net/smtp.rb, line 264
264:     def capable_plain_auth?
265:       auth_capable?('PLAIN')
266:     end

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

[Source]

     # File lib/net/smtp.rb, line 252
252:     def capable_starttls?
253:       capable?('STARTTLS')
254:     end

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

[Source]

     # File lib/net/smtp.rb, line 868
868:     def data(msgstr = nil, &block)   #:yield: stream
869:       if msgstr and block
870:         raise ArgumentError, "message and block are exclusive"
871:       end
872:       unless msgstr or block
873:         raise ArgumentError, "message or block is required"
874:       end
875:       res = critical {
876:         check_continue get_response('DATA')
877:         if msgstr
878:           @socket.write_message msgstr
879:         else
880:           @socket.write_message_by_block(&block)
881:         end
882:         recv_response()
883:       }
884:       check_response res
885:       res
886:     end

WARNING: This method causes serious security holes. Use this method for only debugging.

Set an output stream for debug logging. You must call this before start.

  # example
  smtp = Net::SMTP.new(addr, port)
  smtp.set_debug_output $stderr
  smtp.start do |smtp|
    ....
  end

[Source]

     # File lib/net/smtp.rb, line 402
402:     def debug_output=(arg)
403:       @debug_output = arg
404:     end
disable_ssl()

Alias for disable_tls

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

[Source]

     # File lib/net/smtp.rb, line 360
360:     def disable_starttls
361:       @starttls = false
362:       @ssl_context = nil
363:     end

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

[Source]

     # File lib/net/smtp.rb, line 316
316:     def disable_tls
317:       @tls = false
318:       @ssl_context = nil
319:     end

[Source]

     # File lib/net/smtp.rb, line 820
820:     def ehlo(domain)
821:       getok("EHLO #{domain}")
822:     end
enable_ssl(context = SMTP.default_ssl_context)

Alias for enable_tls

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

[Source]

     # File lib/net/smtp.rb, line 342
342:     def enable_starttls(context = SMTP.default_ssl_context)
343:       raise 'openssl library not installed' unless defined?(OpenSSL)
344:       raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @tls
345:       @starttls = :always
346:       @ssl_context = context
347:     end

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

[Source]

     # File lib/net/smtp.rb, line 351
351:     def enable_starttls_auto(context = SMTP.default_ssl_context)
352:       raise 'openssl library not installed' unless defined?(OpenSSL)
353:       raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @tls
354:       @starttls = :auto
355:       @ssl_context = context
356:     end

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.

[Source]

     # File lib/net/smtp.rb, line 305
305:     def enable_tls(context = SMTP.default_ssl_context)
306:       raise 'openssl library not installed' unless defined?(OpenSSL)
307:       raise ArgumentError, "SMTPS and STARTTLS is exclusive" if @starttls
308:       @tls = true
309:       @ssl_context = context
310:     end
esmtp()

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

[Source]

     # File lib/net/smtp.rb, line 244
244:     def esmtp=(bool)
245:       @esmtp = bool
246:     end

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

[Source]

     # File lib/net/smtp.rb, line 233
233:     def esmtp?
234:       @esmtp
235:     end

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

[Source]

     # File lib/net/smtp.rb, line 538
538:     def finish
539:       raise IOError, 'not yet started' unless started?
540:       do_finish
541:     end

[Source]

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

Provide human-readable stringification of class state.

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 824
824:     def mailfrom(from_addr)
825:       if $SAFE > 0
826:         raise SecurityError, 'tainted from_addr' if from_addr.tainted?
827:       end
828:       getok("MAIL FROM:<#{from_addr}>")
829:     end

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:

[Source]

     # File lib/net/smtp.rb, line 705
705:     def open_message_stream(from_addr, *to_addrs, &block)   # :yield: stream
706:       raise IOError, 'closed session' unless @socket
707:       mailfrom from_addr
708:       rcptto_list to_addrs
709:       data(&block)
710:     end

[Source]

     # File lib/net/smtp.rb, line 888
888:     def quit
889:       getok('QUIT')
890:     end

[Source]

     # File lib/net/smtp.rb, line 838
838:     def rcptto(to_addr)
839:       if $SAFE > 0
840:         raise SecurityError, 'tainted to_addr' if to_addr.tainted?
841:       end
842:       getok("RCPT TO:<#{to_addr}>")
843:     end

[Source]

     # File lib/net/smtp.rb, line 831
831:     def rcptto_list(to_addrs)
832:       raise ArgumentError, 'mail destination not given' if to_addrs.empty?
833:       to_addrs.flatten.each do |addr|
834:         rcptto addr
835:       end
836:     end

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

[Source]

     # File lib/net/smtp.rb, line 383
383:     def read_timeout=(sec)
384:       @socket.read_timeout = sec if @socket
385:       @read_timeout = sec
386:     end
ready(from_addr, *to_addrs)
send_mail(msgstr, from_addr, *to_addrs)

Alias for send_message

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:

[Source]

     # File lib/net/smtp.rb, line 651
651:     def send_message(msgstr, from_addr, *to_addrs)
652:       raise IOError, 'closed session' unless @socket
653:       mailfrom from_addr
654:       rcptto_list to_addrs
655:       data msgstr
656:     end
sendmail(msgstr, from_addr, *to_addrs)

Alias for send_message

set_debug_output(arg)

Alias for debug_output=

ssl?()

Alias for tls?

Opens a TCP connection and starts the SMTP session.

Parameters

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

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

Block Usage

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

Example

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

    require 'net/smtp'
    smtp = Net::SMTP.new('smtp.mail.server', 25)
    smtp.start(helo_domain, account, password, authtype) do |smtp|
      smtp.send_message msgstr, 'from@example.com', ['dest@example.com']
    end

The primary use of this method (as opposed to SMTP.start) is probably to set debugging (set_debug_output) or ESMTP (esmtp=), which must be done before the session is started.

Errors

If session has already been started, an IOError will be raised.

This method may raise:

[Source]

     # File lib/net/smtp.rb, line 521
521:     def start(helo = 'localhost.localdomain',
522:               user = nil, secret = nil, authtype = nil)   # :yield: smtp
523:       if block_given?
524:         begin
525:           do_start helo, user, secret, authtype
526:           return yield(self)
527:         ensure
528:           do_finish
529:         end
530:       else
531:         do_start helo, user, secret, authtype
532:         return self
533:       end
534:     end

true if the SMTP session has been started.

[Source]

     # File lib/net/smtp.rb, line 467
467:     def started?
468:       @started
469:     end

SMTP command dispatcher

[Source]

     # File lib/net/smtp.rb, line 812
812:     def starttls
813:       getok('STARTTLS')
814:     end

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.

[Source]

     # File lib/net/smtp.rb, line 326
326:     def starttls?
327:       @starttls
328:     end

true if this object uses STARTTLS.

[Source]

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

true if this object uses STARTTLS when server advertises STARTTLS.

[Source]

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

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

[Source]

     # File lib/net/smtp.rb, line 296
296:     def tls?
297:       @tls
298:     end

Private Instance methods

[Source]

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

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 781
781:     def base64_encode(str)
782:       # expects "str" may not become too long
783:       [str].pack('m').gsub(/\s+/, '')
784:     end

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 772
772:     def check_auth_args(user, secret)
773:       unless user
774:         raise ArgumentError, 'SMTP-AUTH requested but missing user name'
775:       end
776:       unless secret
777:         raise ArgumentError, 'SMTP-AUTH requested but missing secret phrase'
778:       end
779:     end

[Source]

     # File lib/net/smtp.rb, line 946
946:     def check_auth_continue(res)
947:       unless res.continue?
948:         raise res.exception_class, res.message
949:       end
950:     end

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 940
940:     def check_auth_response(res)
941:       unless res.success?
942:         raise SMTPAuthenticationError, res.message
943:       end
944:     end

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 928
928:     def check_response(res)
929:       unless res.success?
930:         raise res.exception_class, res.message
931:       end
932:     end

CRAM-MD5: [RFC2195]

[Source]

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

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 918
918:     def critical(&block)
919:       return '200 dummy reply code' if @error_occured
920:       begin
921:         return yield()
922:       rescue Exception
923:         @error_occured = true
924:         raise
925:       end
926:     end

[Source]

     # File lib/net/smtp.rb, line 606
606:     def do_finish
607:       quit if @socket and not @socket.closed? and not @error_occured
608:     ensure
609:       @started = false
610:       @error_occured = false
611:       @socket.close if @socket and not @socket.closed?
612:       @socket = nil
613:     end

[Source]

     # File lib/net/smtp.rb, line 594
594:     def do_helo(helo_domain)
595:       res = @esmtp ? ehlo(helo_domain) : helo(helo_domain)
596:       @capabilities = res.capabilities
597:     rescue SMTPError
598:       if @esmtp
599:         @esmtp = false
600:         @error_occured = false
601:         retry
602:       end
603:       raise
604:     end

[Source]

     # File lib/net/smtp.rb, line 545
545:     def do_start(helo_domain, user, secret, authtype)
546:       raise IOError, 'SMTP session already started' if @started
547:       if user or secret
548:         check_auth_method(authtype || DEFAULT_AUTH_TYPE)
549:         check_auth_args user, secret
550:       end
551:       s = timeout(@open_timeout) { TCPSocket.open(@address, @port) }   
552:       logging "Connection opened: #{@address}:#{@port}"
553:       @socket = new_internet_message_io(tls? ? tlsconnect(s) : s)
554:       check_response critical { recv_response() }
555:       do_helo helo_domain
556:       if starttls_always? or (capable_starttls? and starttls_auto?)
557:         unless capable_starttls?
558:           raise SMTPUnsupportedCommand,
559:               "STARTTLS is not supported on this server"
560:         end
561:         starttls
562:         @socket = new_internet_message_io(tlsconnect(s))
563:         # helo response may be different after STARTTLS
564:         do_helo helo_domain
565:       end
566:       authenticate user, secret, (authtype || DEFAULT_AUTH_TYPE) if user
567:       @started = true
568:     ensure
569:       unless @started
570:         # authentication failed, cancel connection.
571:         s.close if s and not s.closed?
572:         @socket = nil
573:       end
574:     end

[Source]

     # File lib/net/smtp.rb, line 903
903:     def get_response(reqline)
904:       @socket.writeline reqline
905:       recv_response()
906:     end

[Source]

     # File lib/net/smtp.rb, line 894
894:     def getok(reqline)
895:       res = critical {
896:         @socket.writeline reqline
897:         recv_response()
898:       }
899:       check_response res
900:       res
901:     end

[Source]

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

[Source]

     # File lib/net/smtp.rb, line 587
587:     def new_internet_message_io(s)
588:       io = InternetMessageIO.new(s)
589:       io.read_timeout = @read_timeout
590:       io.debug_output = @debug_output
591:       io
592:     end

[Source]

     # File lib/net/smtp.rb, line 908
908:     def recv_response
909:       buf = ''
910:       while true
911:         line = @socket.readline
912:         buf << line << "\n"
913:         break unless line[3,1] == '-'   # "210-PIPELINING"
914:       end
915:       Response.parse(buf)
916:     end

[Source]

     # File lib/net/smtp.rb, line 576
576:     def tlsconnect(s)
577:       s = OpenSSL::SSL::SSLSocket.new(s, @ssl_context)
578:       logging "TLS connection started"
579:       s.sync_close = true
580:       s.connect
581:       if @ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
582:         s.post_connection_check(@address)
583:       end
584:       s
585:     end

[Validate]