class Net::IMAP

# File net/imap.rb, line 303
def self.add_authenticator(auth_type, authenticator)
  @@authenticators[auth_type] = authenticator
end

# File net/imap.rb, line 273
def self.debug
  return @@debug
end

# File net/imap.rb, line 278
def self.debug=(val)
  return @@debug = val
end

# File net/imap.rb, line 1002
def self.decode_utf7(s)
  return s.gsub(/&([^-]+)?-/n) {
    if $1
      ($1.tr(",", "/") + "===").unpack1("m").encode(Encoding::UTF_8, Encoding::UTF_16BE)
    else
      "&"
    end
  }
end

# File net/imap.rb, line 308
def self.default_port
  return PORT
end

# File net/imap.rb, line 313
def self.default_tls_port
  return SSL_PORT
end

# File net/imap.rb, line 1013
def self.encode_utf7(s)
  return s.gsub(/(&)|[^\x20-\x7e]+/) {
    if $1
      "&-"
    else
      base64 = [$&.encode(Encoding::UTF_16BE)].pack("m0")
      "&" + base64.delete("=").tr("/", ",") + "-"
    end
  }.force_encoding("ASCII-8BIT")
end

# File net/imap.rb, line 1025
def self.format_date(time)
  return time.strftime('%d-%b-%Y')
end

# File net/imap.rb, line 1030
def self.format_datetime(time)
  return time.strftime('%d-%b-%Y %H:%M %z')
end

# File net/imap.rb, line 283
def self.max_flag_count
  return @@max_flag_count
end

# File net/imap.rb, line 288
def self.max_flag_count=(count)
  @@max_flag_count = count
end

# File net/imap.rb, line 1073
def initialize(host, port_or_options = {},
               usessl = false, certs = nil, verify = true)
  super()
  @host = host
  begin
    options = port_or_options.to_hash
  rescue NoMethodError
    # for backward compatibility
    options = {}
    options[:port] = port_or_options
    if usessl
      options[:ssl] = create_ssl_params(certs, verify)
    end
  end
  @port = options[:port] || (options[:ssl] ? SSL_PORT : PORT)
  @tag_prefix = "RUBY"
  @tagno = 0
  @open_timeout = options[:open_timeout] || 30
  @parser = ResponseParser.new
  @sock = tcp_socket(@host, @port)
  begin
    if options[:ssl]
      start_tls_session(options[:ssl])
      @usessl = true
    else
      @usessl = false
    end
    @responses = Hash.new([].freeze)
    @tagged_responses = {}
    @response_handlers = []
    @tagged_response_arrival = new_cond
    @continued_command_tag = nil
    @continuation_request_arrival = new_cond
    @continuation_request_exception = nil
    @idle_done_cond = nil
    @logout_command_tag = nil
    @debug_output_bol = true
    @exception = nil

    @greeting = get_response
    if @greeting.nil?
      raise Error, "connection closed"
    end
    if @greeting.name == "BYE"
      raise ByeResponseError, @greeting
    end

    @client_thread = Thread.current
    @receiver_thread = Thread.start {
      begin
        receive_responses
      rescue Exception
      end
    }
    @receiver_thread_terminating = false
  rescue Exception
    @sock.close
    raise
  end
end

# File net/imap.rb, line 908
def add_response_handler(handler = nil, &block)
  raise ArgumentError, "two Procs are passed" if handler && block
  @response_handlers.push(block || handler)
end

# File net/imap.rb, line 701
def append(mailbox, message, flags = nil, date_time = nil)
  args = []
  if flags
    args.push(flags)
  end
  args.push(date_time) if date_time
  args.push(Literal.new(message))
  send_command("APPEND", mailbox, *args)
end

# File net/imap.rb, line 419
def authenticate(auth_type, *args)
  auth_type = auth_type.upcase
  unless @@authenticators.has_key?(auth_type)
    raise ArgumentError,
      format('unknown auth type - "%s"', auth_type)
  end
  authenticator = @@authenticators[auth_type].new(*args)
  send_command("AUTHENTICATE", auth_type) do |resp|
    if resp.instance_of?(ContinuationRequest)
      data = authenticator.process(resp.data.text.unpack("m")[0])
      s = [data].pack("m0")
      send_string_data(s)
      put_string(CRLF)
    end
  end
end

# File net/imap.rb, line 361
def capability
  synchronize do
    send_command("CAPABILITY")
    return @responses.delete("CAPABILITY")[-1]
  end
end

# File net/imap.rb, line 715
def check
  send_command("CHECK")
end

# File net/imap.rb, line 722
def close
  send_command("CLOSE")
end

# File net/imap.rb, line 855
def copy(set, mailbox)
  copy_internal("COPY", set, mailbox)
end

# File net/imap.rb, line 482
def create(mailbox)
  send_command("CREATE", mailbox)
end

# File net/imap.rb, line 491
def delete(mailbox)
  send_command("DELETE", mailbox)
end

# File net/imap.rb, line 324
def disconnect
  return if disconnected?
  begin
    begin
      # try to call SSL::SSLSocket#io.
      @sock.io.shutdown
    rescue NoMethodError
      # @sock is not an SSL::SSLSocket.
      @sock.shutdown
    end
  rescue Errno::ENOTCONN
    # ignore `Errno::ENOTCONN: Socket is not connected' on some platforms.
  rescue Exception => e
    @receiver_thread.raise(e)
  end
  @receiver_thread.join
  synchronize do
    @sock.close
  end
  raise e if e
end

# File net/imap.rb, line 347
def disconnected?
  return @sock.closed?
end

# File net/imap.rb, line 471
def examine(mailbox)
  synchronize do
    @responses.clear
    send_command("EXAMINE", mailbox)
  end
end

# File net/imap.rb, line 728
def expunge
  synchronize do
    send_command("EXPUNGE")
    return @responses.delete("EXPUNGE")
  end
end

# File net/imap.rb, line 819
def fetch(set, attr, mod = nil)
  return fetch_internal("FETCH", set, attr, mod)
end

# File net/imap.rb, line 641
def getacl(mailbox)
  synchronize do
    send_command("GETACL", mailbox)
    return @responses.delete("ACL")[-1]
  end
end

# File net/imap.rb, line 605
def getquota(mailbox)
  synchronize do
    send_command("GETQUOTA", mailbox)
    return @responses.delete("QUOTA")
  end
end

# File net/imap.rb, line 591
def getquotaroot(mailbox)
  synchronize do
    send_command("GETQUOTAROOT", mailbox)
    result = []
    result.concat(@responses.delete("QUOTAROOT"))
    result.concat(@responses.delete("QUOTA"))
    return result
  end
end

# File net/imap.rb, line 955
def idle(timeout = nil, &response_handler)
  raise LocalJumpError, "no block given" unless response_handler

  response = nil

  synchronize do
    tag = Thread.current[:net_imap_tag] = generate_tag
    put_string("#{tag} IDLE#{CRLF}")

    begin
      add_response_handler(&response_handler)
      @idle_done_cond = new_cond
      @idle_done_cond.wait(timeout)
      @idle_done_cond = nil
      if @receiver_thread_terminating
        raise @exception || Net::IMAP::Error.new("connection closed")
      end
    ensure
      unless @receiver_thread_terminating
        remove_response_handler(response_handler)
        put_string("DONE#{CRLF}")
        response = get_tagged_response(tag, "IDLE")
      end
    end
  end

  return response
end

# File net/imap.rb, line 985
def idle_done
  synchronize do
    if @idle_done_cond.nil?
      raise Net::IMAP::Error, "not during IDLE"
    end
    @idle_done_cond.signal
  end
end

# File net/imap.rb, line 548
def list(refname, mailbox)
  synchronize do
    send_command("LIST", refname, mailbox)
    return @responses.delete("LIST")
  end
end

# File net/imap.rb, line 442
def login(user, password)
  send_command("LOGIN", user, password)
end

# File net/imap.rb, line 375
def logout
  send_command("LOGOUT")
end

# File net/imap.rb, line 653
def lsub(refname, mailbox)
  synchronize do
    send_command("LSUB", refname, mailbox)
    return @responses.delete("LSUB")
  end
end

# File net/imap.rb, line 869
def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end

# File net/imap.rb, line 369
def noop
  send_command("NOOP")
end

# File net/imap.rb, line 914
def remove_response_handler(handler)
  @response_handlers.delete(handler)
end

# File net/imap.rb, line 502
def rename(mailbox, newname)
  send_command("RENAME", mailbox, newname)
end

# File net/imap.rb, line 775
def search(keys, charset = nil)
  return search_internal("SEARCH", keys, charset)
end

# File net/imap.rb, line 458
def select(mailbox)
  synchronize do
    @responses.clear
    send_command("SELECT", mailbox)
  end
end

# File net/imap.rb, line 630
def setacl(mailbox, user, rights)
  if rights.nil?
    send_command("SETACL", mailbox, user, "")
  else
    send_command("SETACL", mailbox, user, rights)
  end
end

# File net/imap.rb, line 617
def setquota(mailbox, quota)
  if quota.nil?
    data = '()'
  else
    data = '(STORAGE ' + quota.to_s + ')'
  end
  send_command("SETQUOTA", mailbox, RawData.new(data))
end

# File net/imap.rb, line 887
def sort(sort_keys, search_keys, charset)
  return sort_internal("SORT", sort_keys, search_keys, charset)
end

# File net/imap.rb, line 380
def starttls(options = {}, verify = true)
  send_command("STARTTLS") do |resp|
    if resp.kind_of?(TaggedResponse) && resp.name == "OK"
      begin
        # for backward compatibility
        certs = options.to_str
        options = create_ssl_params(certs, verify)
      rescue NoMethodError
      end
      start_tls_session(options)
    end
  end
end

# File net/imap.rb, line 676
def status(mailbox, attr)
  synchronize do
    send_command("STATUS", mailbox, attr)
    return @responses.delete("STATUS")[-1].attr
  end
end

# File net/imap.rb, line 842
def store(set, attr, flags)
  return store_internal("STORE", set, attr, flags)
end

# File net/imap.rb, line 512
def subscribe(mailbox)
  send_command("SUBSCRIBE", mailbox)
end

# File net/imap.rb, line 931
def thread(algorithm, search_keys, charset)
  return thread_internal("THREAD", algorithm, search_keys, charset)
end

# File net/imap.rb, line 860
def uid_copy(set, mailbox)
  copy_internal("UID COPY", set, mailbox)
end

# File net/imap.rb, line 824
def uid_fetch(set, attr, mod = nil)
  return fetch_internal("UID FETCH", set, attr, mod)
end

# File net/imap.rb, line 874
def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end

# File net/imap.rb, line 780
def uid_search(keys, charset = nil)
  return search_internal("UID SEARCH", keys, charset)
end

# File net/imap.rb, line 892
def uid_sort(sort_keys, search_keys, charset)
  return sort_internal("UID SORT", sort_keys, search_keys, charset)
end

# File net/imap.rb, line 847
def uid_store(set, attr, flags)
  return store_internal("UID STORE", set, attr, flags)
end

# File net/imap.rb, line 937
def uid_thread(algorithm, search_keys, charset)
  return thread_internal("UID THREAD", algorithm, search_keys, charset)
end

# File net/imap.rb, line 522
def unsubscribe(mailbox)
  send_command("UNSUBSCRIBE", mailbox)
end

# File net/imap.rb, line 580
def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    return @responses.delete("XLIST")
  end
end

# File net/imap.rb, line 1463
def copy_internal(cmd, set, mailbox)
  send_command(cmd, MessageSet.new(set), mailbox)
end

# File net/imap.rb, line 1502
def create_ssl_params(certs = nil, verify = true)
  params = {}
  if certs
    if File.file?(certs)
      params[:ca_file] = certs
    elsif File.directory?(certs)
      params[:ca_path] = certs
    end
  end
  if verify
    params[:verify_mode] = VERIFY_PEER
  else
    params[:verify_mode] = VERIFY_NONE
  end
  return params
end

# File net/imap.rb, line 1431
def fetch_internal(cmd, set, attr, mod = nil)
  case attr
  when String then
    attr = RawData.new(attr)
  when Array then
    attr = attr.map { |arg|
      arg.is_a?(String) ? RawData.new(arg) : arg
    }
  end

  synchronize do
    @responses.delete("FETCH")
    if mod
      send_command(cmd, MessageSet.new(set), attr, mod)
    else
      send_command(cmd, MessageSet.new(set), attr)
    end
    return @responses.delete("FETCH")
  end
end

# File net/imap.rb, line 1287
def generate_tag
  @tagno += 1
  return format("%s%04d", @tag_prefix, @tagno)
end

# File net/imap.rb, line 1232
def get_response
  buff = String.new
  while true
    s = @sock.gets(CRLF)
    break unless s
    buff.concat(s)
    if /\{(\d+)\}\r\n/n =~ s
      s = @sock.read($1.to_i)
      buff.concat(s)
    else
      break
    end
  end
  return nil if buff.length == 0
  if @@debug
    $stderr.print(buff.gsub(/^/n, "S: "))
  end
  return @parser.parse(buff)
end

# File net/imap.rb, line 1214
def get_tagged_response(tag, cmd)
  until @tagged_responses.key?(tag)
    raise @exception if @exception
    @tagged_response_arrival.wait
  end
  resp = @tagged_responses.delete(tag)
  case resp.name
  when /\A(?:OK)\z/ni
    return resp
  when /\A(?:NO)\z/ni
    raise NoResponseError, resp
  when /\A(?:BAD)\z/ni
    raise BadResponseError, resp
  else
    raise UnknownResponseError, resp
  end
end

# File net/imap.rb, line 1491
def normalize_searching_criteria(keys)
  keys.collect! do |i|
    case i
    when -1, Range, Array
      MessageSet.new(i)
    else
      i
    end
  end
end

# File net/imap.rb, line 1292
def put_string(str)
  @sock.print(str)
  if @@debug
    if @debug_output_bol
      $stderr.print("C: ")
    end
    $stderr.print(str.gsub(/\n(?!\z)/n, "\nC: "))
    if /\r\n\z/n.match(str)
      @debug_output_bol = true
    else
      @debug_output_bol = false
    end
  end
end

# File net/imap.rb, line 1143
def receive_responses
  connection_closed = false
  until connection_closed
    synchronize do
      @exception = nil
    end
    begin
      resp = get_response
    rescue Exception => e
      synchronize do
        @sock.close
        @exception = e
      end
      break
    end
    unless resp
      synchronize do
        @exception = EOFError.new("end of file reached")
      end
      break
    end
    begin
      synchronize do
        case resp
        when TaggedResponse
          @tagged_responses[resp.tag] = resp
          @tagged_response_arrival.broadcast
          case resp.tag
          when @logout_command_tag
            return
          when @continued_command_tag
            @continuation_request_exception =
              RESPONSE_ERRORS[resp.name].new(resp)
            @continuation_request_arrival.signal
          end
        when UntaggedResponse
          record_response(resp.name, resp.data)
          if resp.data.instance_of?(ResponseText) &&
              (code = resp.data.code)
            record_response(code.name, code.data)
          end
          if resp.name == "BYE" && @logout_command_tag.nil?
            @sock.close
            @exception = ByeResponseError.new(resp)
            connection_closed = true
          end
        when ContinuationRequest
          @continuation_request_arrival.signal
        end
        @response_handlers.each do |handler|
          handler.call(resp)
        end
      end
    rescue Exception => e
      @exception = e
      synchronize do
        @tagged_response_arrival.broadcast
        @continuation_request_arrival.broadcast
      end
    end
  end
  synchronize do
    @receiver_thread_terminating = true
    @tagged_response_arrival.broadcast
    @continuation_request_arrival.broadcast
    if @idle_done_cond
      @idle_done_cond.signal
    end
  end
end

# File net/imap.rb, line 1252
def record_response(name, data)
  unless @responses.has_key?(name)
    @responses[name] = []
  end
  @responses[name].push(data)
end

# File net/imap.rb, line 1415
def search_internal(cmd, keys, charset)
  if keys.instance_of?(String)
    keys = [RawData.new(keys)]
  else
    normalize_searching_criteria(keys)
  end
  synchronize do
    if charset
      send_command(cmd, "CHARSET", charset, *keys)
    else
      send_command(cmd, *keys)
    end
    return @responses.delete("SEARCH")[-1]
  end
end

# File net/imap.rb, line 1259
def send_command(cmd, *args, &block)
  synchronize do
    args.each do |i|
      validate_data(i)
    end
    tag = generate_tag
    put_string(tag + " " + cmd)
    args.each do |i|
      put_string(" ")
      send_data(i, tag)
    end
    put_string(CRLF)
    if cmd == "LOGOUT"
      @logout_command_tag = tag
    end
    if block
      add_response_handler(&block)
    end
    begin
      return get_tagged_response(tag, cmd)
    ensure
      if block
        remove_response_handler(block)
      end
    end
  end
end

# File net/imap.rb, line 1328
def send_data(data, tag = nil)
  case data
  when nil
    put_string("NIL")
  when String
    send_string_data(data, tag)
  when Integer
    send_number_data(data)
  when Array
    send_list_data(data, tag)
  when Time
    send_time_data(data)
  when Symbol
    send_symbol_data(data)
  else
    data.send_data(self, tag)
  end
end

# File net/imap.rb, line 1387
def send_list_data(list, tag = nil)
  put_string("(")
  first = true
  list.each do |i|
    if first
      first = false
    else
      put_string(" ")
    end
    send_data(i, tag)
  end
  put_string(")")
end

# File net/imap.rb, line 1366
def send_literal(str, tag = nil)
  synchronize do
    put_string("{" + str.bytesize.to_s + "}" + CRLF)
    @continued_command_tag = tag
    @continuation_request_exception = nil
    begin
      @continuation_request_arrival.wait
      e = @continuation_request_exception || @exception
      raise e if e
      put_string(str)
    ensure
      @continued_command_tag = nil
      @continuation_request_exception = nil
    end
  end
end

# File net/imap.rb, line 1383
def send_number_data(num)
  put_string(num.to_s)
end

# File net/imap.rb, line 1362
def send_quoted_string(str)
  put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"')
end

# File net/imap.rb, line 1347
def send_string_data(str, tag = nil)
  case str
  when ""
    put_string('""')
  when /[\x80-\xff\r\n]/n
    # literal
    send_literal(str, tag)
  when /[(){ \x00-\x1f\x7f%*"\\]/n
    # quoted string
    send_quoted_string(str)
  else
    put_string(str)
  end
end

# File net/imap.rb, line 1411
def send_symbol_data(symbol)
  put_string("\\" + symbol.to_s)
end

# File net/imap.rb, line 1403
def send_time_data(time)
  t = time.dup.gmtime
  s = format('"%2d-%3s-%4d %02d:%02d:%02d +0000"',
             t.day, DATE_MONTH[t.month - 1], t.year,
             t.hour, t.min, t.sec)
  put_string(s)
end

# File net/imap.rb, line 1467
def sort_internal(cmd, sort_keys, search_keys, charset)
  if search_keys.instance_of?(String)
    search_keys = [RawData.new(search_keys)]
  else
    normalize_searching_criteria(search_keys)
  end
  normalize_searching_criteria(search_keys)
  synchronize do
    send_command(cmd, sort_keys, charset, *search_keys)
    return @responses.delete("SORT")[-1]
  end
end

# File net/imap.rb, line 1519
def start_tls_session(params = {})
  unless defined?(OpenSSL::SSL)
    raise "SSL extension not installed"
  end
  if @sock.kind_of?(OpenSSL::SSL::SSLSocket)
    raise RuntimeError, "already using SSL"
  end
  begin
    params = params.to_hash
  rescue NoMethodError
    params = {}
  end
  context = SSLContext.new
  context.set_params(params)
  if defined?(VerifyCallbackProc)
    context.verify_callback = VerifyCallbackProc
  end
  @sock = SSLSocket.new(@sock, context)
  @sock.sync_close = true
  @sock.hostname = @host if @sock.respond_to? :hostname=
  ssl_socket_connect(@sock, @open_timeout)
  if context.verify_mode != VERIFY_NONE
    @sock.post_connection_check(@host)
  end
end

# File net/imap.rb, line 1452
def store_internal(cmd, set, attr, flags)
  if attr.instance_of?(String)
    attr = RawData.new(attr)
  end
  synchronize do
    @responses.delete("FETCH")
    send_command(cmd, MessageSet.new(set), attr, flags)
    return @responses.delete("FETCH")
  end
end

# File net/imap.rb, line 1134
def tcp_socket(host, port)
  s = Socket.tcp(host, port, :connect_timeout => @open_timeout)
  s.setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, true)
  s
rescue Errno::ETIMEDOUT
  raise Net::OpenTimeout, "Timeout to open TCP connection to " +
    "#{host}:#{port} (exceeds #{@open_timeout} seconds)"
end

# File net/imap.rb, line 1480
def thread_internal(cmd, algorithm, search_keys, charset)
  if search_keys.instance_of?(String)
    search_keys = [RawData.new(search_keys)]
  else
    normalize_searching_criteria(search_keys)
  end
  normalize_searching_criteria(search_keys)
  send_command(cmd, algorithm, charset, *search_keys)
  return @responses.delete("THREAD")[-1]
end

# File net/imap.rb, line 1307
def validate_data(data)
  case data
  when nil
  when String
  when Integer
    NumValidator.ensure_number(data)
  when Array
    if data[0] == 'CHANGEDSINCE'
      NumValidator.ensure_mod_sequence_value(data[1])
    else
      data.each do |i|
        validate_data(i)
      end
    end
  when Time
  when Symbol
  else
    data.validate
  end
end