Class: Net::SMTP

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

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

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

alias default_ssl_port default_tls_port

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

def SMTP.default_submission_port
  587
end

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

def SMTP.default_tls_port
  465
end

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

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

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

attr_reader :capabilities

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

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

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

def capable_login_auth?
  auth_capable?('LOGIN')
end

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

def capable_plain_auth?
  auth_capable?('PLAIN')
end

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

def capable_starttls?
  capable?('STARTTLS')
end

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

def debug_output=(arg)
  @debug_output = arg
end

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

alias :esmtp? :esmtp

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

attr_accessor :open_timeout

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

attr_reader :port

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

attr_reader :read_timeout

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

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

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

alias ssl? tls?

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

attr_accessor :ssl_context_params

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

def started?
  @started
end

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

def starttls?
  @starttls
end

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

def starttls_always?
  @starttls == :always
end

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

def starttls_auto?
  @starttls == :auto
end

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

def tls?
  @tls
end

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

attr_accessor :tls_hostname

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

attr_accessor :tls_verify

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

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

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

def auth_login(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

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

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

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

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

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

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

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

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

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

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

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

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

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

def check_auth_args(user, secret, authtype = DEFAULT_AUTH_TYPE)
  unless user
    raise ArgumentError, 'SMTP-AUTH requested but missing user name'
  end
  unless secret
    raise ArgumentError, 'SMTP-AUTH requested but missing secret phrase'
  end
end

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

def check_auth_continue(res)
  unless res.continue?
    raise res.exception_class.new(res)
  end
end

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

def check_auth_method(type)
  unless respond_to?(auth_method(type), true)
    raise ArgumentError, "wrong authentication type #{type}"
  end
end

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

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

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

def check_continue(res)
  unless res.continue?
    raise SMTPUnknownError.new(res, message: "could not get 3xx (#{res.status}: #{res.string})")
  end
end

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

def check_response(res)
  unless res.success?
    raise res.exception_class.new(res)
  end
end

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

def cram_md5_response(secret, challenge)
  tmp = Digest::MD5.digest(cram_secret(secret, IMASK) + challenge)
  Digest::MD5.hexdigest(cram_secret(secret, OMASK) + tmp)
end

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

def cram_secret(secret, mask)
  secret = Digest::MD5.digest(secret) if secret.size > CRAM_BUFSIZE
  buf = secret.ljust(CRAM_BUFSIZE, "\0")
  0.upto(buf.size - 1) do |i|
    buf[i] = (buf[i].ord ^ mask).chr
  end
  buf
end

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

def critical
  return Response.parse('200 dummy reply code') if @error_occurred
  begin
    return yield()
  rescue Exception
    @error_occurred = true
    raise
  end
end

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

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

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

alias disable_ssl disable_tls

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

def disable_starttls
  @starttls = false
  @ssl_context_starttls = nil
end

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

def disable_tls
  @tls = false
  @ssl_context_tls = nil
end

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

def do_finish
  quit if @socket and not @socket.closed? and not @error_occurred
ensure
  @started = false
  @error_occurred = false
  @socket.close if @socket
  @socket = nil
end

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

def do_helo(helo_domain)
  res = @esmtp ? ehlo(helo_domain) : helo(helo_domain)
  @capabilities = res.capabilities
rescue SMTPError
  if @esmtp
    @esmtp = false
    @error_occurred = false
    retry
  end
  raise
end

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

def do_start(helo_domain, user, secret, authtype)
  raise IOError, 'SMTP session already started' if @started
  if user or secret
    check_auth_method(authtype || DEFAULT_AUTH_TYPE)
    check_auth_args user, secret
  end
  s = tcp_socket(@address, @port)
  logging "Connection opened: #{@address}:#{@port}"
  @socket = new_internet_message_io(tls? ? tlsconnect(s, @ssl_context_tls) : s)
  check_response critical { recv_response() }
  do_helo helo_domain
  if ! tls? and (starttls_always? or (capable_starttls? and starttls_auto?))
    unless capable_starttls?
      raise SMTPUnsupportedCommand.new(nil, message: "STARTTLS is not supported on this server")
    end
    starttls
    @socket = new_internet_message_io(tlsconnect(s, @ssl_context_starttls))
    # helo response may be different after STARTTLS
    do_helo helo_domain
  end
  authenticate user, secret, (authtype || DEFAULT_AUTH_TYPE) if user
  @started = true
ensure
  unless @started
    # authentication failed, cancel connection.
    s.close if s
    @socket = nil
  end
end

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

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

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

alias enable_ssl enable_tls

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

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

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

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

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

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

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

attr_accessor :esmtp

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

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

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

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

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

def getok(reqline)
  validate_line reqline
  res = critical {
    @socket.writeline reqline
    recv_response()
  }
  check_response res
  res
end

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

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

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

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

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

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

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

def mailfrom(from_addr)
  addr = Address.new(from_addr)
  getok((["MAIL FROM:<#{addr.address}>"] + addr.parameters).join(' '))
end

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

def new_internet_message_io(s)
  InternetMessageIO.new(s, read_timeout: @read_timeout,
                        debug_output: @debug_output)
end

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

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

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

def quit
  getok('QUIT')
end

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

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

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

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

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

alias ready open_message_stream   # obsolete

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

def recv_response
  buf = ''.dup
  while true
    line = @socket.readline
    buf << line << "\n"
    break unless line[3,1] == '-'   # "210-PIPELINING"
  end
  Response.parse(buf)
end

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

def rset
  getok('RSET')
end

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

alias send_mail send_message

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

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

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

alias sendmail send_message   # obsolete

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

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

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

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

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

def starttls
  getok('STARTTLS')
end

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

def tcp_socket(address, port)
  begin
    Socket.tcp address, port, nil, nil, connect_timeout: @open_timeout
  rescue Errno::ETIMEDOUT #raise Net:OpenTimeout instead for compatibility with previous versions
    raise Net::OpenTimeout, "Timeout to open TCP connection to "\
      "#{address}:#{port} (exceeds #{@open_timeout} seconds)"
  end
end

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

def tlsconnect(s, context)
  verified = false
  s = ssl_socket(s, context)
  logging "TLS connection started"
  s.sync_close = true
  s.hostname = @tls_hostname || @address
  ssl_socket_connect(s, @open_timeout)
  verified = true
  s
ensure
  s.close unless verified
end

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

def validate_line(line)
  # A bare CR or LF is not allowed in RFC5321.
  if /[\r\n]/ =~ line
    raise ArgumentError, "A line must not contain CR or LF"
  end
end