Class: Net::IMAP

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

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

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

def self.max_flag_count
  return @@max_flag_count
end

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

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

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

def self.decode_utf7(s)
  return s.gsub(/&([^-]+)?-/n) {
    if $1
      ($1.tr(",", "/") + "===").unpack("m")[0].encode(Encoding::UTF_8, Encoding::UTF_16BE)
    else
      "&"
    end
  }
end

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

alias default_imap_port default_port

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

alias default_imaps_port default_tls_port

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

def self.default_port
  return PORT
end

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

alias default_ssl_port default_tls_port

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

def self.default_tls_port
  return SSL_PORT
end

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

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

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

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

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

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

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

def disconnected?
  return @sock.closed?
end

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

attr_reader :greeting

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

attr_reader :response_handlers

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

attr_reader :responses

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

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 412

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("m").gsub(/\n/, "")
      send_string_data(s)
      put_string(CRLF)
    end
  end
end

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

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

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

def check
  send_command("CHECK")
end

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

def close
  send_command("CLOSE")
end

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

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

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

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

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

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

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

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 484

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

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

def disconnect
  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
    unless @sock.closed?
      @sock.close
    end
  end
  raise e if e
end

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

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

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

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

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

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

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

def fetch_internal(cmd, set, attr)
  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")
    send_command(cmd, MessageSet.new(set), attr)
    return @responses.delete("FETCH")
  end
end

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

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

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

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 1188

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(?:NO)\z/ni
    raise NoResponseError, resp
  when /\A(?:BAD)\z/ni
    raise BadResponseError, resp
  else
    return resp
  end
end

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

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

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

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

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

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 947

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 Net::IMAP::Error, "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 977

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 541

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

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

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

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

def logout
  send_command("LOGOUT")
end

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

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

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

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

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

def noop
  send_command("NOOP")
end

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

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 1264

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 1122

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
          if resp.tag == @logout_command_tag
            return
          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 1224

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

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

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

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

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

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

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

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

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 451

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

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

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)
    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 1296

def send_data(data)
  case data
  when nil
    put_string("NIL")
  when String
    send_string_data(data)
  when Integer
    send_number_data(data)
  when Array
    send_list_data(data)
  when Time
    send_time_data(data)
  when Symbol
    send_symbol_data(data)
  else
    data.send_data(self)
  end
end

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

def send_list_data(list)
  put_string("(")
  first = true
  list.each do |i|
    if first
      first = false
    else
      put_string(" ")
    end
    send_data(i)
  end
  put_string(")")
end

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

def send_literal(str)
  put_string("{" + str.bytesize.to_s + "}" + CRLF)
  @continuation_request_arrival.wait
  raise @exception if @exception
  put_string(str)
end

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

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

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

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

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

def send_string_data(str)
  case str
  when ""
    put_string('""')
  when /[\x80-\xff\r\n]/n
    # literal
    send_literal(str)
  when /[(){ \x00-\x1f\x7f%*"\\]/n
    # quoted string
    send_quoted_string(str)
  else
    put_string(str)
  end
end

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

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

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

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 623

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 610

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 880

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

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

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 1473

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.connect
  if context.verify_mode != VERIFY_NONE
    @sock.post_connection_check(@host)
  end
end

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

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 669

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 835

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

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

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 505

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

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

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

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

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 853

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

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

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

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

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

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

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

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

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 840

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

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

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

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

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

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

def validate_data(data)
  case data
  when nil
  when String
  when Integer
    NumValidator.ensure_number(data)
  when Array
    data.each do |i|
      validate_data(i)
    end
  when Time
  when Symbol
  else
    data.validate
  end
end

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

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