Class: Net::IMAP

# File 'lib/net/imap.rb', line 276

def self.debug=(val)
  return @@debug = val
end

# File 'lib/net/imap.rb', line 281

def self.max_flag_count
  return @@max_flag_count
end

# File 'lib/net/imap.rb', line 286

def self.max_flag_count=(count)
  @@max_flag_count = count
end

# File 'lib/net/imap.rb', line 1000

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 'lib/net/imap.rb', line 316

alias default_imap_port default_port

# File 'lib/net/imap.rb', line 317

alias default_imaps_port default_tls_port

# File 'lib/net/imap.rb', line 306

def self.default_port
  return PORT
end

# File 'lib/net/imap.rb', line 318

alias default_ssl_port default_tls_port

# File 'lib/net/imap.rb', line 311

def self.default_tls_port
  return SSL_PORT
end

# File 'lib/net/imap.rb', line 1011

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 'lib/net/imap.rb', line 1023

def self.format_date(time)
  return time.strftime('%d-%b-%Y')
end

# File 'lib/net/imap.rb', line 1028

def self.format_datetime(time)
  return time.strftime('%d-%b-%Y %H:%M %z')
end

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

def disconnected?
  return @sock.closed?
end

# File 'lib/net/imap.rb', line 211

attr_reader :greeting

# File 'lib/net/imap.rb', line 228

attr_reader :open_timeout

# File 'lib/net/imap.rb', line 223

attr_reader :response_handlers

# File 'lib/net/imap.rb', line 220

attr_reader :responses

# File 'lib/net/imap.rb', line 699

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 'lib/net/imap.rb', line 417

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 'lib/net/imap.rb', line 359

def capability
  synchronize do
    send_command("CAPABILITY")
    return @responses.delete("CAPABILITY")[-1]
  end
end

# File 'lib/net/imap.rb', line 713

def check
  send_command("CHECK")
end

# File 'lib/net/imap.rb', line 720

def close
  send_command("CLOSE")
end

# File 'lib/net/imap.rb', line 853

def copy(set, mailbox)
  copy_internal("COPY", set, mailbox)
end

# File 'lib/net/imap.rb', line 1461

def copy_internal(cmd, set, mailbox)
  send_command(cmd, MessageSet.new(set), mailbox)
end

# File 'lib/net/imap.rb', line 480

def create(mailbox)
  send_command("CREATE", mailbox)
end

# File 'lib/net/imap.rb', line 1500

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 'lib/net/imap.rb', line 489

def delete(mailbox)
  send_command("DELETE", mailbox)
end

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

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 'lib/net/imap.rb', line 469

def examine(mailbox)
  synchronize do
    @responses.clear
    send_command("EXAMINE", mailbox)
  end
end

# File 'lib/net/imap.rb', line 726

def expunge
  synchronize do
    send_command("EXPUNGE")
    return @responses.delete("EXPUNGE")
  end
end

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

def fetch(set, attr, mod = nil)
  return fetch_internal("FETCH", set, attr, mod)
end

# File 'lib/net/imap.rb', line 1429

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 'lib/net/imap.rb', line 1285

def generate_tag
  @tagno += 1
  return format("%s%04d", @tag_prefix, @tagno)
end

# File 'lib/net/imap.rb', line 1230

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 'lib/net/imap.rb', line 1212

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 'lib/net/imap.rb', line 639

def getacl(mailbox)
  synchronize do
    send_command("GETACL", mailbox)
    return @responses.delete("ACL")[-1]
  end
end

# File 'lib/net/imap.rb', line 603

def getquota(mailbox)
  synchronize do
    send_command("GETQUOTA", mailbox)
    return @responses.delete("QUOTA")
  end
end

# File 'lib/net/imap.rb', line 589

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 'lib/net/imap.rb', line 953

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 'lib/net/imap.rb', line 983

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 'lib/net/imap.rb', line 546

def list(refname, mailbox)
  synchronize do
    send_command("LIST", refname, mailbox)
    return @responses.delete("LIST")
  end
end

# File 'lib/net/imap.rb', line 440

def login(user, password)
  send_command("LOGIN", user, password)
end

# File 'lib/net/imap.rb', line 373

def logout
  send_command("LOGOUT")
end

# File 'lib/net/imap.rb', line 651

def lsub(refname, mailbox)
  synchronize do
    send_command("LSUB", refname, mailbox)
    return @responses.delete("LSUB")
  end
end

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

def move(set, mailbox)
  copy_internal("MOVE", set, mailbox)
end

# File 'lib/net/imap.rb', line 367

def noop
  send_command("NOOP")
end

# File 'lib/net/imap.rb', line 1489

def normalize_searching_criteria(keys)
  keys.collect! do |i|
    case i
    when -1, Range, Array
      MessageSet.new(i)
    else
      i
    end
  end
end

# File 'lib/net/imap.rb', line 1290

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 'lib/net/imap.rb', line 1141

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 'lib/net/imap.rb', line 1250

def record_response(name, data)
  unless @responses.has_key?(name)
    @responses[name] = []
  end
  @responses[name].push(data)
end

# File 'lib/net/imap.rb', line 912

def remove_response_handler(handler)
  @response_handlers.delete(handler)
end

# File 'lib/net/imap.rb', line 500

def rename(mailbox, newname)
  send_command("RENAME", mailbox, newname)
end

# File 'lib/net/imap.rb', line 773

def search(keys, charset = nil)
  return search_internal("SEARCH", keys, charset)
end

# File 'lib/net/imap.rb', line 1413

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 'lib/net/imap.rb', line 456

def select(mailbox)
  synchronize do
    @responses.clear
    send_command("SELECT", mailbox)
  end
end

# File 'lib/net/imap.rb', line 1257

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 'lib/net/imap.rb', line 1326

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 'lib/net/imap.rb', line 1385

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 'lib/net/imap.rb', line 1364

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 'lib/net/imap.rb', line 1381

def send_number_data(num)
  put_string(num.to_s)
end

# File 'lib/net/imap.rb', line 1360

def send_quoted_string(str)
  put_string('"' + str.gsub(/["\\]/n, "\\\\\\&") + '"')
end

# File 'lib/net/imap.rb', line 1345

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 'lib/net/imap.rb', line 1409

def send_symbol_data(symbol)
  put_string("\\" + symbol.to_s)
end

# File 'lib/net/imap.rb', line 1401

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 'lib/net/imap.rb', line 628

def setacl(mailbox, user, rights)
  if rights.nil?
    send_command("SETACL", mailbox, user, "")
  else
    send_command("SETACL", mailbox, user, rights)
  end
end

# File 'lib/net/imap.rb', line 615

def setquota(mailbox, quota)
  if quota.nil?
    data = '()'
  else
    data = '(STORAGE ' + quota.to_s + ')'
  end
  send_command("SETQUOTA", mailbox, RawData.new(data))
end

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

def sort(sort_keys, search_keys, charset)
  return sort_internal("SORT", sort_keys, search_keys, charset)
end

# File 'lib/net/imap.rb', line 1465

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 'lib/net/imap.rb', line 1517

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 'lib/net/imap.rb', line 378

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 'lib/net/imap.rb', line 674

def status(mailbox, attr)
  synchronize do
    send_command("STATUS", mailbox, attr)
    return @responses.delete("STATUS")[-1].attr
  end
end

# File 'lib/net/imap.rb', line 840

def store(set, attr, flags)
  return store_internal("STORE", set, attr, flags)
end

# File 'lib/net/imap.rb', line 1450

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 'lib/net/imap.rb', line 510

def subscribe(mailbox)
  send_command("SUBSCRIBE", mailbox)
end

# File 'lib/net/imap.rb', line 1132

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 'lib/net/imap.rb', line 929

def thread(algorithm, search_keys, charset)
  return thread_internal("THREAD", algorithm, search_keys, charset)
end

# File 'lib/net/imap.rb', line 1478

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 'lib/net/imap.rb', line 858

def uid_copy(set, mailbox)
  copy_internal("UID COPY", set, mailbox)
end

# File 'lib/net/imap.rb', line 822

def uid_fetch(set, attr, mod = nil)
  return fetch_internal("UID FETCH", set, attr, mod)
end

# File 'lib/net/imap.rb', line 872

def uid_move(set, mailbox)
  copy_internal("UID MOVE", set, mailbox)
end

# File 'lib/net/imap.rb', line 778

def uid_search(keys, charset = nil)
  return search_internal("UID SEARCH", keys, charset)
end

# File 'lib/net/imap.rb', line 890

def uid_sort(sort_keys, search_keys, charset)
  return sort_internal("UID SORT", sort_keys, search_keys, charset)
end

# File 'lib/net/imap.rb', line 845

def uid_store(set, attr, flags)
  return store_internal("UID STORE", set, attr, flags)
end

# File 'lib/net/imap.rb', line 935

def uid_thread(algorithm, search_keys, charset)
  return thread_internal("UID THREAD", algorithm, search_keys, charset)
end

# File 'lib/net/imap.rb', line 520

def unsubscribe(mailbox)
  send_command("UNSUBSCRIBE", mailbox)
end

# File 'lib/net/imap.rb', line 1305

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

# File 'lib/net/imap.rb', line 578

def xlist(refname, mailbox)
  synchronize do
    send_command("XLIST", refname, mailbox)
    return @responses.delete("XLIST")
  end
end