Class | Net::SMTP |
In: |
lib/net/smtp.rb
|
Parent: | Object |
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).
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).
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
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.
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| ... }
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)
Revision | = | %q$Revision: 18353 $.split[1] | ||
DEFAULT_AUTH_TYPE | = | :plain | Authentication | |
IMASK | = | 0x36 | ||
OMASK | = | 0x5c | ||
CRAM_BUFSIZE | = | 64 |
default_tls_port | -> | default_ssl_port |
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. |
# 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.
# File lib/net/smtp.rb, line 183 183: def SMTP.default_submission_port 184: 587 185: end
The default SMTPS port number, 465.
# 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.
# 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)
Net::SMTP.start('your.smtp.server') do |smtp| smtp.send_message msgstr, 'from@example.com', ['dest@example.com'] end
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.
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.
This method may raise:
# 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
# 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
# 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
# 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
# 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
This method sends a message. If msgstr is given, sends it as a message. If block is given, yield a message writer stream. You must write message before the block is closed.
# Example 1 (by string) smtp.data(<<EndMessage) From: john@example.com To: betty@example.com Subject: I found a bug Check vm.c:58879. EndMessage # Example 2 (by block) smtp.data {|f| f.puts "From: john@example.com" f.puts "To: betty@example.com" f.puts "Subject: I found a bug" f.puts "" f.puts "Check vm.c:58879." }
# File lib/net/smtp.rb, line 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
# File lib/net/smtp.rb, line 402 402: def debug_output=(arg) 403: @debug_output = arg 404: end
Enables SMTP/TLS (STARTTLS) for this object. context is a OpenSSL::SSL::SSLContext object.
# 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.
# 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.
# 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
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).
# File lib/net/smtp.rb, line 244 244: def esmtp=(bool) 245: @esmtp = bool 246: end
Provide human-readable stringification of class state.
# File lib/net/smtp.rb, line 228 228: def inspect 229: "#<#{self.class} #{@address}:#{@port} started=#{@started}>" 230: end
# 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.
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.
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
This method may raise:
# 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
# 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
# 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
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.
Net::SMTP.start('smtp.example.com') do |smtp| smtp.send_message msgstr, 'from@example.com', ['dest@example.com', 'dest2@example.com'] end
This method may raise:
# 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
Opens a TCP connection and starts the SMTP session.
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.
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.
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.
If session has already been started, an IOError will be raised.
This method may raise:
# 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
Returns truth value if this object uses STARTTLS. If this object always uses STARTTLS, returns :always. If this object uses STARTTLS when the server support TLS, returns :auto.
# File lib/net/smtp.rb, line 326 326: def starttls? 327: @starttls 328: end
true if this object uses STARTTLS.
# 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.
# File lib/net/smtp.rb, line 336 336: def starttls_auto? 337: @starttls == :auto 338: end
# 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
# File lib/net/smtp.rb, line 768 768: def auth_method(type) 769: "auth_#{type.to_s.downcase}".intern 770: end
# 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
# File lib/net/smtp.rb, line 256 256: def capable?(key) 257: return nil unless @capabilities 258: @capabilities[key] ? true : false 259: end
# 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
# 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
# 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
# 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
# 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
# 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]
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/net/smtp.rb, line 903 903: def get_response(reqline) 904: @socket.writeline reqline 905: recv_response() 906: end
# 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
# File lib/net/smtp.rb, line 1006 1006: def logging(msg) 1007: @debug_output << msg + "\n" if @debug_output 1008: end
# 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
# 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
# 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