Adding upstream version 1:2.3.21+dfsg1.upstream/1%2.3.21+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

10 files changed, 5459 insertions, 0 deletions

diff --git a/src/lib-imap-client/Makefile.am b/src/lib-imap-client/Makefile.am
new file mode 100644
index 0000000..8fe8a8d
--- /dev/null
+++ b/src/lib-imap-client/Makefile.am
@@ -0,0 +1,53 @@
+noinst_LTLIBRARIES = libimap_client.la
+
+AM_CPPFLAGS = \
+	-I$(top_srcdir)/src/lib \
+	-I$(top_srcdir)/src/lib-test \
+	-I$(top_srcdir)/src/lib-dns \
+	-I$(top_srcdir)/src/lib-sasl \
+	-I$(top_srcdir)/src/lib-ssl-iostream \
+	-I$(top_srcdir)/src/lib-mail \
+	-I$(top_srcdir)/src/lib-imap
+
+libimap_client_la_SOURCES = \
+	imapc-client.c \
+	imapc-connection.c \
+	imapc-msgmap.c
+
+headers = \
+	imapc-client.h \
+	imapc-client-private.h \
+	imapc-connection.h \
+	imapc-msgmap.h
+
+pkginc_libdir=$(pkgincludedir)
+pkginc_lib_HEADERS = $(headers)
+
+test_programs = \
+	test-imapc-client
+
+noinst_PROGRAMS = $(test_programs)
+
+test_deps = \
+	$(noinst_LTLIBRARIES) \
+	../lib-ssl-iostream/libssl_iostream.la \
+	../lib-sasl/libsasl.la \
+	../lib-imap/libimap.la \
+	../lib-mail/libmail.la \
+	../lib-charset/libcharset.la \
+	../lib-dns/libdns.la \
+	../lib-test/libtest.la \
+	../lib/liblib.la
+
+test_libs = \
+	$(test_deps) \
+	$(MODULE_LIBS)
+
+test_imapc_client_SOURCES = test-imapc-client.c
+test_imapc_client_LDADD = $(test_libs)
+test_imapc_client_DEPENDENCIES = $(test_deps)
+
+check-local:
+	for bin in $(test_programs); do \
+	  if ! $(RUN_TEST) ./$$bin; then exit 1; fi; \
+	done
diff --git a/src/lib-imap-client/Makefile.in b/src/lib-imap-client/Makefile.in
new file mode 100644
index 0000000..d3fe475
--- /dev/null
+++ b/src/lib-imap-client/Makefile.in
@@ -0,0 +1,880 @@
+# Makefile.in generated by automake 1.16.3 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2020 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
+am__make_running_with_option = \
+  case $${target_option-} in \
+      ?) ;; \
+      *) echo "am__make_running_with_option: internal error: invalid" \
+              "target option '$${target_option-}' specified" >&2; \
+         exit 1;; \
+  esac; \
+  has_opt=no; \
+  sane_makeflags=$$MAKEFLAGS; \
+  if $(am__is_gnu_make); then \
+    sane_makeflags=$$MFLAGS; \
+  else \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        bs=\\; \
+        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
+    esac; \
+  fi; \
+  skip_next=no; \
+  strip_trailopt () \
+  { \
+    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+  }; \
+  for flg in $$sane_makeflags; do \
+    test $$skip_next = yes && { skip_next=no; continue; }; \
+    case $$flg in \
+      *=*|--*) continue;; \
+        -*I) strip_trailopt 'I'; skip_next=yes;; \
+      -*I?*) strip_trailopt 'I';; \
+        -*O) strip_trailopt 'O'; skip_next=yes;; \
+      -*O?*) strip_trailopt 'O';; \
+        -*l) strip_trailopt 'l'; skip_next=yes;; \
+      -*l?*) strip_trailopt 'l';; \
+      -[dEDm]) skip_next=yes;; \
+      -[JT]) skip_next=yes;; \
+    esac; \
+    case $$flg in \
+      *$$target_option*) has_opt=yes; break;; \
+    esac; \
+  done; \
+  test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+noinst_PROGRAMS = $(am__EXEEXT_1)
+subdir = src/lib-imap-client
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_checktype2.m4 \
+	$(top_srcdir)/m4/ac_typeof.m4 $(top_srcdir)/m4/arc4random.m4 \
+	$(top_srcdir)/m4/blockdev.m4 $(top_srcdir)/m4/c99_vsnprintf.m4 \
+	$(top_srcdir)/m4/clock_gettime.m4 $(top_srcdir)/m4/crypt.m4 \
+	$(top_srcdir)/m4/crypt_xpg6.m4 $(top_srcdir)/m4/dbqlk.m4 \
+	$(top_srcdir)/m4/dirent_dtype.m4 $(top_srcdir)/m4/dovecot.m4 \
+	$(top_srcdir)/m4/fd_passing.m4 $(top_srcdir)/m4/fdatasync.m4 \
+	$(top_srcdir)/m4/flexible_array_member.m4 \
+	$(top_srcdir)/m4/glibc.m4 $(top_srcdir)/m4/gmtime_max.m4 \
+	$(top_srcdir)/m4/gmtime_tm_gmtoff.m4 \
+	$(top_srcdir)/m4/ioloop.m4 $(top_srcdir)/m4/iovec.m4 \
+	$(top_srcdir)/m4/ipv6.m4 $(top_srcdir)/m4/libcap.m4 \
+	$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/libwrap.m4 \
+	$(top_srcdir)/m4/linux_mremap.m4 $(top_srcdir)/m4/ltoptions.m4 \
+	$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+	$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/m4/mmap_write.m4 \
+	$(top_srcdir)/m4/mntctl.m4 $(top_srcdir)/m4/modules.m4 \
+	$(top_srcdir)/m4/notify.m4 $(top_srcdir)/m4/nsl.m4 \
+	$(top_srcdir)/m4/off_t_max.m4 $(top_srcdir)/m4/pkg.m4 \
+	$(top_srcdir)/m4/pr_set_dumpable.m4 \
+	$(top_srcdir)/m4/q_quotactl.m4 $(top_srcdir)/m4/quota.m4 \
+	$(top_srcdir)/m4/random.m4 $(top_srcdir)/m4/rlimit.m4 \
+	$(top_srcdir)/m4/sendfile.m4 $(top_srcdir)/m4/size_t_signed.m4 \
+	$(top_srcdir)/m4/sockpeercred.m4 $(top_srcdir)/m4/sql.m4 \
+	$(top_srcdir)/m4/ssl.m4 $(top_srcdir)/m4/st_tim.m4 \
+	$(top_srcdir)/m4/static_array.m4 $(top_srcdir)/m4/test_with.m4 \
+	$(top_srcdir)/m4/time_t.m4 $(top_srcdir)/m4/typeof.m4 \
+	$(top_srcdir)/m4/typeof_dev_t.m4 \
+	$(top_srcdir)/m4/uoff_t_max.m4 $(top_srcdir)/m4/vararg.m4 \
+	$(top_srcdir)/m4/want_apparmor.m4 \
+	$(top_srcdir)/m4/want_bsdauth.m4 \
+	$(top_srcdir)/m4/want_bzlib.m4 \
+	$(top_srcdir)/m4/want_cassandra.m4 \
+	$(top_srcdir)/m4/want_cdb.m4 \
+	$(top_srcdir)/m4/want_checkpassword.m4 \
+	$(top_srcdir)/m4/want_clucene.m4 $(top_srcdir)/m4/want_db.m4 \
+	$(top_srcdir)/m4/want_gssapi.m4 $(top_srcdir)/m4/want_icu.m4 \
+	$(top_srcdir)/m4/want_ldap.m4 $(top_srcdir)/m4/want_lua.m4 \
+	$(top_srcdir)/m4/want_lz4.m4 $(top_srcdir)/m4/want_lzma.m4 \
+	$(top_srcdir)/m4/want_mysql.m4 $(top_srcdir)/m4/want_pam.m4 \
+	$(top_srcdir)/m4/want_passwd.m4 $(top_srcdir)/m4/want_pgsql.m4 \
+	$(top_srcdir)/m4/want_prefetch.m4 \
+	$(top_srcdir)/m4/want_shadow.m4 \
+	$(top_srcdir)/m4/want_sodium.m4 $(top_srcdir)/m4/want_solr.m4 \
+	$(top_srcdir)/m4/want_sqlite.m4 \
+	$(top_srcdir)/m4/want_stemmer.m4 \
+	$(top_srcdir)/m4/want_systemd.m4 \
+	$(top_srcdir)/m4/want_textcat.m4 \
+	$(top_srcdir)/m4/want_unwind.m4 $(top_srcdir)/m4/want_zlib.m4 \
+	$(top_srcdir)/m4/want_zstd.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(pkginc_lib_HEADERS) \
+	$(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__EXEEXT_1 = test-imapc-client$(EXEEXT)
+PROGRAMS = $(noinst_PROGRAMS)
+LTLIBRARIES = $(noinst_LTLIBRARIES)
+libimap_client_la_LIBADD =
+am_libimap_client_la_OBJECTS = imapc-client.lo imapc-connection.lo \
+	imapc-msgmap.lo
+libimap_client_la_OBJECTS = $(am_libimap_client_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+am_test_imapc_client_OBJECTS = test-imapc-client.$(OBJEXT)
+test_imapc_client_OBJECTS = $(am_test_imapc_client_OBJECTS)
+am__DEPENDENCIES_1 =
+am__DEPENDENCIES_2 = $(test_deps) $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/imapc-client.Plo \
+	./$(DEPDIR)/imapc-connection.Plo ./$(DEPDIR)/imapc-msgmap.Plo \
+	./$(DEPDIR)/test-imapc-client.Po
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(libimap_client_la_SOURCES) $(test_imapc_client_SOURCES)
+DIST_SOURCES = $(libimap_client_la_SOURCES) \
+	$(test_imapc_client_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(pkginc_libdir)"
+HEADERS = $(pkginc_lib_HEADERS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+APPARMOR_LIBS = @APPARMOR_LIBS@
+AR = @AR@
+AUTH_CFLAGS = @AUTH_CFLAGS@
+AUTH_LIBS = @AUTH_LIBS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BINARY_CFLAGS = @BINARY_CFLAGS@
+BINARY_LDFLAGS = @BINARY_LDFLAGS@
+BISON = @BISON@
+CASSANDRA_CFLAGS = @CASSANDRA_CFLAGS@
+CASSANDRA_LIBS = @CASSANDRA_LIBS@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CDB_LIBS = @CDB_LIBS@
+CFLAGS = @CFLAGS@
+CLUCENE_CFLAGS = @CLUCENE_CFLAGS@
+CLUCENE_LIBS = @CLUCENE_LIBS@
+COMPRESS_LIBS = @COMPRESS_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CRYPT_LIBS = @CRYPT_LIBS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DICT_LIBS = @DICT_LIBS@
+DLLIB = @DLLIB@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+FLEX = @FLEX@
+FUZZER_CPPFLAGS = @FUZZER_CPPFLAGS@
+FUZZER_LDFLAGS = @FUZZER_LDFLAGS@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+KRB5CONFIG = @KRB5CONFIG@
+KRB5_CFLAGS = @KRB5_CFLAGS@
+KRB5_LIBS = @KRB5_LIBS@
+LD = @LD@
+LDAP_LIBS = @LDAP_LIBS@
+LDFLAGS = @LDFLAGS@
+LD_NO_WHOLE_ARCHIVE = @LD_NO_WHOLE_ARCHIVE@
+LD_WHOLE_ARCHIVE = @LD_WHOLE_ARCHIVE@
+LIBCAP = @LIBCAP@
+LIBDOVECOT = @LIBDOVECOT@
+LIBDOVECOT_COMPRESS = @LIBDOVECOT_COMPRESS@
+LIBDOVECOT_DEPS = @LIBDOVECOT_DEPS@
+LIBDOVECOT_DSYNC = @LIBDOVECOT_DSYNC@
+LIBDOVECOT_LA_LIBS = @LIBDOVECOT_LA_LIBS@
+LIBDOVECOT_LDA = @LIBDOVECOT_LDA@
+LIBDOVECOT_LDAP = @LIBDOVECOT_LDAP@
+LIBDOVECOT_LIBFTS = @LIBDOVECOT_LIBFTS@
+LIBDOVECOT_LIBFTS_DEPS = @LIBDOVECOT_LIBFTS_DEPS@
+LIBDOVECOT_LOGIN = @LIBDOVECOT_LOGIN@
+LIBDOVECOT_LUA = @LIBDOVECOT_LUA@
+LIBDOVECOT_LUA_DEPS = @LIBDOVECOT_LUA_DEPS@
+LIBDOVECOT_SQL = @LIBDOVECOT_SQL@
+LIBDOVECOT_STORAGE = @LIBDOVECOT_STORAGE@
+LIBDOVECOT_STORAGE_DEPS = @LIBDOVECOT_STORAGE_DEPS@
+LIBEXTTEXTCAT_CFLAGS = @LIBEXTTEXTCAT_CFLAGS@
+LIBEXTTEXTCAT_LIBS = @LIBEXTTEXTCAT_LIBS@
+LIBICONV = @LIBICONV@
+LIBICU_CFLAGS = @LIBICU_CFLAGS@
+LIBICU_LIBS = @LIBICU_LIBS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBSODIUM_CFLAGS = @LIBSODIUM_CFLAGS@
+LIBSODIUM_LIBS = @LIBSODIUM_LIBS@
+LIBTIRPC_CFLAGS = @LIBTIRPC_CFLAGS@
+LIBTIRPC_LIBS = @LIBTIRPC_LIBS@
+LIBTOOL = @LIBTOOL@
+LIBUNWIND_CFLAGS = @LIBUNWIND_CFLAGS@
+LIBUNWIND_LIBS = @LIBUNWIND_LIBS@
+LIBWRAP_LIBS = @LIBWRAP_LIBS@
+LINKED_STORAGE_LDADD = @LINKED_STORAGE_LDADD@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
+LUA_CFLAGS = @LUA_CFLAGS@
+LUA_LIBS = @LUA_LIBS@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+MODULE_LIBS = @MODULE_LIBS@
+MODULE_SUFFIX = @MODULE_SUFFIX@
+MYSQL_CFLAGS = @MYSQL_CFLAGS@
+MYSQL_CONFIG = @MYSQL_CONFIG@
+MYSQL_LIBS = @MYSQL_LIBS@
+NM = @NM@
+NMEDIT = @NMEDIT@
+NOPLUGIN_LDFLAGS = @NOPLUGIN_LDFLAGS@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PANDOC = @PANDOC@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PGSQL_CFLAGS = @PGSQL_CFLAGS@
+PGSQL_LIBS = @PGSQL_LIBS@
+PG_CONFIG = @PG_CONFIG@
+PIE_CFLAGS = @PIE_CFLAGS@
+PIE_LDFLAGS = @PIE_LDFLAGS@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+QUOTA_LIBS = @QUOTA_LIBS@
+RANLIB = @RANLIB@
+RELRO_LDFLAGS = @RELRO_LDFLAGS@
+RPCGEN = @RPCGEN@
+RUN_TEST = @RUN_TEST@
+SED = @SED@
+SETTING_FILES = @SETTING_FILES@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SQLITE_CFLAGS = @SQLITE_CFLAGS@
+SQLITE_LIBS = @SQLITE_LIBS@
+SQL_CFLAGS = @SQL_CFLAGS@
+SQL_LIBS = @SQL_LIBS@
+SSL_CFLAGS = @SSL_CFLAGS@
+SSL_LIBS = @SSL_LIBS@
+STRIP = @STRIP@
+SYSTEMD_CFLAGS = @SYSTEMD_CFLAGS@
+SYSTEMD_LIBS = @SYSTEMD_LIBS@
+VALGRIND = @VALGRIND@
+VERSION = @VERSION@
+ZSTD_CFLAGS = @ZSTD_CFLAGS@
+ZSTD_LIBS = @ZSTD_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+dict_drivers = @dict_drivers@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+moduledir = @moduledir@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+rundir = @rundir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sql_drivers = @sql_drivers@
+srcdir = @srcdir@
+ssldir = @ssldir@
+statedir = @statedir@
+sysconfdir = @sysconfdir@
+systemdservicetype = @systemdservicetype@
+systemdsystemunitdir = @systemdsystemunitdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+noinst_LTLIBRARIES = libimap_client.la
+AM_CPPFLAGS = \
+	-I$(top_srcdir)/src/lib \
+	-I$(top_srcdir)/src/lib-test \
+	-I$(top_srcdir)/src/lib-dns \
+	-I$(top_srcdir)/src/lib-sasl \
+	-I$(top_srcdir)/src/lib-ssl-iostream \
+	-I$(top_srcdir)/src/lib-mail \
+	-I$(top_srcdir)/src/lib-imap
+
+libimap_client_la_SOURCES = \
+	imapc-client.c \
+	imapc-connection.c \
+	imapc-msgmap.c
+
+headers = \
+	imapc-client.h \
+	imapc-client-private.h \
+	imapc-connection.h \
+	imapc-msgmap.h
+
+pkginc_libdir = $(pkgincludedir)
+pkginc_lib_HEADERS = $(headers)
+test_programs = \
+	test-imapc-client
+
+test_deps = \
+	$(noinst_LTLIBRARIES) \
+	../lib-ssl-iostream/libssl_iostream.la \
+	../lib-sasl/libsasl.la \
+	../lib-imap/libimap.la \
+	../lib-mail/libmail.la \
+	../lib-charset/libcharset.la \
+	../lib-dns/libdns.la \
+	../lib-test/libtest.la \
+	../lib/liblib.la
+
+test_libs = \
+	$(test_deps) \
+	$(MODULE_LIBS)
+
+test_imapc_client_SOURCES = test-imapc-client.c
+test_imapc_client_LDADD = $(test_libs)
+test_imapc_client_DEPENDENCIES = $(test_deps)
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/lib-imap-client/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign src/lib-imap-client/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+clean-noinstPROGRAMS:
+	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+
+clean-noinstLTLIBRARIES:
+	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+	@list='$(noinst_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+
+libimap_client.la: $(libimap_client_la_OBJECTS) $(libimap_client_la_DEPENDENCIES) $(EXTRA_libimap_client_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(LINK)  $(libimap_client_la_OBJECTS) $(libimap_client_la_LIBADD) $(LIBS)
+
+test-imapc-client$(EXEEXT): $(test_imapc_client_OBJECTS) $(test_imapc_client_DEPENDENCIES) $(EXTRA_test_imapc_client_DEPENDENCIES) 
+	@rm -f test-imapc-client$(EXEEXT)
+	$(AM_V_CCLD)$(LINK) $(test_imapc_client_OBJECTS) $(test_imapc_client_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/imapc-client.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/imapc-connection.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/imapc-msgmap.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test-imapc-client.Po@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-pkginc_libHEADERS: $(pkginc_lib_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(pkginc_lib_HEADERS)'; test -n "$(pkginc_libdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(pkginc_libdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(pkginc_libdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkginc_libdir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkginc_libdir)" || exit $$?; \
+	done
+
+uninstall-pkginc_libHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkginc_lib_HEADERS)'; test -n "$(pkginc_libdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(pkginc_libdir)'; $(am__uninstall_files_from_dir)
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) check-local
+check: check-am
+all-am: Makefile $(PROGRAMS) $(LTLIBRARIES) $(HEADERS)
+installdirs:
+	for dir in "$(DESTDIR)$(pkginc_libdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
+	clean-noinstPROGRAMS mostlyclean-am
+
+distclean: distclean-am
+		-rm -f ./$(DEPDIR)/imapc-client.Plo
+	-rm -f ./$(DEPDIR)/imapc-connection.Plo
+	-rm -f ./$(DEPDIR)/imapc-msgmap.Plo
+	-rm -f ./$(DEPDIR)/test-imapc-client.Po
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-pkginc_libHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+		-rm -f ./$(DEPDIR)/imapc-client.Plo
+	-rm -f ./$(DEPDIR)/imapc-connection.Plo
+	-rm -f ./$(DEPDIR)/imapc-msgmap.Plo
+	-rm -f ./$(DEPDIR)/test-imapc-client.Po
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-pkginc_libHEADERS
+
+.MAKE: check-am install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am \
+	check-local clean clean-generic clean-libtool \
+	clean-noinstLTLIBRARIES clean-noinstPROGRAMS cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-pkginc_libHEADERS install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \
+	uninstall-pkginc_libHEADERS
+
+.PRECIOUS: Makefile
+
+
+check-local:
+	for bin in $(test_programs); do \
+	  if ! $(RUN_TEST) ./$$bin; then exit 1; fi; \
+	done
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/lib-imap-client/imapc-client-private.h b/src/lib-imap-client/imapc-client-private.h
new file mode 100644
index 0000000..98c4e8e
--- /dev/null
+++ b/src/lib-imap-client/imapc-client-private.h
@@ -0,0 +1,63 @@
+#ifndef IMAPC_CLIENT_PRIVATE_H
+#define IMAPC_CLIENT_PRIVATE_H
+
+#include "imapc-client.h"
+
+#define IMAPC_CLIENT_IDLE_SEND_DELAY_MSECS 100
+
+struct imapc_client_connection {
+	struct imapc_connection *conn;
+	struct imapc_client *client;
+	struct imapc_client_mailbox *box;
+};
+
+struct imapc_client {
+	pool_t pool;
+	int refcount;
+
+	struct event *event;
+	struct imapc_client_settings set;
+	struct ssl_iostream_context *ssl_ctx;
+
+	imapc_untagged_callback_t *untagged_callback;
+	void *untagged_context;
+
+	imapc_state_change_callback_t *state_change_callback;
+	void *state_change_context;
+
+	imapc_command_callback_t *login_callback;
+	void *login_context;
+
+	ARRAY(struct imapc_client_connection *) conns;
+	bool logging_out;
+
+	struct ioloop *ioloop;
+	bool stop_on_state_finish;
+};
+
+struct imapc_client_mailbox {
+	struct imapc_client *client;
+	struct imapc_connection *conn;
+	struct imapc_msgmap *msgmap;
+	struct timeout *to_send_idle;
+
+	void (*reopen_callback)(void *context);
+	void *reopen_context;
+
+	void *untagged_box_context;
+
+	bool reconnect_ok;
+	bool reconnecting;
+	bool closing;
+};
+
+extern unsigned int imapc_client_cmd_tag_counter;
+
+void imapc_client_ref(struct imapc_client *client);
+void imapc_client_unref(struct imapc_client **client);
+
+void imapc_command_set_mailbox(struct imapc_command *cmd,
+			       struct imapc_client_mailbox *box);
+void imapc_client_try_stop(struct imapc_client *client);
+
+#endif
diff --git a/src/lib-imap-client/imapc-client.c b/src/lib-imap-client/imapc-client.c
new file mode 100644
index 0000000..5806a80
--- /dev/null
+++ b/src/lib-imap-client/imapc-client.c
@@ -0,0 +1,584 @@
+/* Copyright (c) 2011-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "array.h"
+#include "str.h"
+#include "ioloop.h"
+#include "safe-mkstemp.h"
+#include "iostream-ssl.h"
+#include "imapc-msgmap.h"
+#include "imapc-connection.h"
+#include "imapc-client-private.h"
+
+#include <unistd.h>
+
+const char *imapc_command_state_names[] = {
+	"OK", "NO", "BAD", "(auth failed)", "(disconnected)"
+
+};
+
+const struct imapc_capability_name imapc_capability_names[] = {
+	{ "SASL-IR", IMAPC_CAPABILITY_SASL_IR },
+	{ "LITERAL+", IMAPC_CAPABILITY_LITERALPLUS },
+	{ "QRESYNC", IMAPC_CAPABILITY_QRESYNC },
+	{ "IDLE", IMAPC_CAPABILITY_IDLE },
+	{ "UIDPLUS", IMAPC_CAPABILITY_UIDPLUS },
+	{ "AUTH=PLAIN", IMAPC_CAPABILITY_AUTH_PLAIN },
+	{ "STARTTLS", IMAPC_CAPABILITY_STARTTLS },
+	{ "X-GM-EXT-1", IMAPC_CAPABILITY_X_GM_EXT_1 },
+	{ "CONDSTORE", IMAPC_CAPABILITY_CONDSTORE },
+	{ "NAMESPACE", IMAPC_CAPABILITY_NAMESPACE },
+	{ "UNSELECT", IMAPC_CAPABILITY_UNSELECT },
+	{ "ESEARCH", IMAPC_CAPABILITY_ESEARCH },
+	{ "WITHIN", IMAPC_CAPABILITY_WITHIN },
+	{ "QUOTA", IMAPC_CAPABILITY_QUOTA },
+	{ "ID", IMAPC_CAPABILITY_ID },
+	{ "SAVEDATE", IMAPC_CAPABILITY_SAVEDATE },
+
+	{ "IMAP4REV1", IMAPC_CAPABILITY_IMAP4REV1 },
+	{ NULL, 0 }
+};
+
+unsigned int imapc_client_cmd_tag_counter = 0;
+
+static void
+default_untagged_callback(const struct imapc_untagged_reply *reply ATTR_UNUSED,
+			  void *context ATTR_UNUSED)
+{
+}
+
+struct imapc_client *
+imapc_client_init(const struct imapc_client_settings *set,
+		  struct event *event_parent)
+{
+	struct imapc_client *client;
+	const char *error;
+	pool_t pool;
+
+	i_assert(set->connect_retry_count == 0 ||
+		 set->connect_retry_interval_msecs > 0);
+
+	pool = pool_alloconly_create("imapc client", 1024);
+	client = p_new(pool, struct imapc_client, 1);
+	client->pool = pool;
+	client->refcount = 1;
+	client->event = event_create(event_parent);
+
+	client->set.debug = set->debug;
+	client->set.host = p_strdup(pool, set->host);
+	client->set.port = set->port;
+	client->set.master_user = p_strdup_empty(pool, set->master_user);
+	client->set.username = p_strdup(pool, set->username);
+	client->set.password = p_strdup(pool, set->password);
+	client->set.sasl_mechanisms = p_strdup(pool, set->sasl_mechanisms);
+	client->set.session_id_prefix = p_strdup(pool, set->session_id_prefix);
+	client->set.use_proxyauth = set->use_proxyauth;
+	client->set.dns_client_socket_path =
+		p_strdup(pool, set->dns_client_socket_path);
+	client->set.temp_path_prefix =
+		p_strdup(pool, set->temp_path_prefix);
+	client->set.rawlog_dir = p_strdup(pool, set->rawlog_dir);
+	client->set.max_idle_time = set->max_idle_time;
+	client->set.connect_timeout_msecs = set->connect_timeout_msecs != 0 ?
+		set->connect_timeout_msecs :
+		IMAPC_DEFAULT_CONNECT_TIMEOUT_MSECS;
+	client->set.connect_retry_count = set->connect_retry_count;
+	client->set.connect_retry_interval_msecs = set->connect_retry_interval_msecs;
+	client->set.cmd_timeout_msecs = set->cmd_timeout_msecs != 0 ?
+		set->cmd_timeout_msecs : IMAPC_DEFAULT_COMMAND_TIMEOUT_MSECS;
+	client->set.max_line_length = set->max_line_length != 0 ?
+		set->max_line_length : IMAPC_DEFAULT_MAX_LINE_LENGTH;
+	client->set.throttle_set = set->throttle_set;
+
+	if (client->set.throttle_set.init_msecs == 0)
+		client->set.throttle_set.init_msecs = IMAPC_THROTTLE_DEFAULT_INIT_MSECS;
+	if (client->set.throttle_set.max_msecs == 0)
+		client->set.throttle_set.max_msecs = IMAPC_THROTTLE_DEFAULT_MAX_MSECS;
+	if (client->set.throttle_set.shrink_min_msecs == 0)
+		client->set.throttle_set.shrink_min_msecs = IMAPC_THROTTLE_DEFAULT_SHRINK_MIN_MSECS;
+
+	if (set->ssl_mode != IMAPC_CLIENT_SSL_MODE_NONE) {
+		client->set.ssl_mode = set->ssl_mode;
+		ssl_iostream_settings_init_from(pool, &client->set.ssl_set, &set->ssl_set);
+		client->set.ssl_set.verbose_invalid_cert = !client->set.ssl_set.allow_invalid_cert;
+		if (ssl_iostream_client_context_cache_get(&client->set.ssl_set,
+							  &client->ssl_ctx,
+							  &error) < 0) {
+			i_error("imapc(%s:%u): Couldn't initialize SSL context: %s",
+				set->host, set->port, error);
+		}
+	}
+	client->untagged_callback = default_untagged_callback;
+
+	p_array_init(&client->conns, pool, 8);
+	return client;
+}
+
+void imapc_client_ref(struct imapc_client *client)
+{
+	i_assert(client->refcount > 0);
+
+	client->refcount++;
+}
+
+void imapc_client_unref(struct imapc_client **_client)
+{
+	struct imapc_client *client = *_client;
+
+	*_client = NULL;
+
+	i_assert(client->refcount > 0);
+	if (--client->refcount > 0)
+		return;
+
+	if (client->ssl_ctx != NULL)
+		ssl_iostream_context_unref(&client->ssl_ctx);
+	event_unref(&client->event);
+	pool_unref(&client->pool);
+}
+
+void imapc_client_disconnect(struct imapc_client *client)
+{
+	struct imapc_client_connection *const *conns, *conn;
+	unsigned int i, count;
+
+	conns = array_get(&client->conns, &count);
+	for (i = count; i > 0; i--) {
+		conn = conns[i-1];
+		array_delete(&client->conns, i-1, 1);
+
+		i_assert(imapc_connection_get_mailbox(conn->conn) == NULL);
+		imapc_connection_deinit(&conn->conn);
+		i_free(conn);
+	}
+}
+
+void imapc_client_deinit(struct imapc_client **_client)
+{
+	struct imapc_client *client = *_client;
+
+	imapc_client_disconnect(client);
+	imapc_client_unref(_client);
+}
+
+void imapc_client_register_untagged(struct imapc_client *client,
+				    imapc_untagged_callback_t *callback,
+				    void *context)
+{
+	client->untagged_callback = callback;
+	client->untagged_context = context;
+}
+
+static void imapc_client_run_pre(struct imapc_client *client)
+{
+	struct imapc_client_connection *conn;
+	struct ioloop *prev_ioloop = current_ioloop;
+
+	i_assert(client->ioloop == NULL);
+
+	client->ioloop = io_loop_create();
+	io_loop_set_running(client->ioloop);
+
+	array_foreach_elem(&client->conns, conn) {
+		imapc_connection_ioloop_changed(conn->conn);
+		if (imapc_connection_get_state(conn->conn) == IMAPC_CONNECTION_STATE_DISCONNECTED)
+			imapc_connection_connect(conn->conn);
+	}
+
+	if (io_loop_is_running(client->ioloop))
+		io_loop_run(client->ioloop);
+	io_loop_set_current(prev_ioloop);
+}
+
+static void imapc_client_run_post(struct imapc_client *client)
+{
+	struct imapc_client_connection *conn;
+	struct ioloop *ioloop = client->ioloop;
+
+	client->ioloop = NULL;
+	array_foreach_elem(&client->conns, conn)
+		imapc_connection_ioloop_changed(conn->conn);
+
+	io_loop_set_current(ioloop);
+	io_loop_destroy(&ioloop);
+}
+
+void imapc_client_run(struct imapc_client *client)
+{
+	imapc_client_run_pre(client);
+	imapc_client_run_post(client);
+}
+
+void imapc_client_stop(struct imapc_client *client)
+{
+	if (client->ioloop != NULL)
+		io_loop_stop(client->ioloop);
+}
+
+void imapc_client_try_stop(struct imapc_client *client)
+{
+	struct imapc_client_connection *conn;
+	array_foreach_elem(&client->conns, conn)
+		if (imapc_connection_get_state(conn->conn) != IMAPC_CONNECTION_STATE_DISCONNECTED)
+			return;
+	imapc_client_stop(client);
+}
+
+bool imapc_client_is_running(struct imapc_client *client)
+{
+	return client->ioloop != NULL;
+}
+
+static void imapc_client_login_callback(const struct imapc_command_reply *reply,
+					void *context)
+{
+	struct imapc_client_connection *conn = context;
+	struct imapc_client *client = conn->client;
+	struct imapc_client_mailbox *box = conn->box;
+
+	if (box != NULL && box->reconnecting) {
+		box->reconnecting = FALSE;
+
+		if (reply->state == IMAPC_COMMAND_STATE_OK) {
+			/* reopen the mailbox */
+			box->reopen_callback(box->reopen_context);
+		} else {
+			imapc_connection_abort_commands(box->conn, NULL, FALSE);
+		}
+	}
+
+	/* call the login callback only once */
+	if (client->login_callback != NULL) {
+		imapc_command_callback_t *callback = client->login_callback;
+		void *context = client->login_context;
+
+		client->login_callback = NULL;
+		client->login_context = NULL;
+		callback(reply, context);
+	}
+}
+
+static struct imapc_client_connection *
+imapc_client_add_connection(struct imapc_client *client)
+{
+	struct imapc_client_connection *conn;
+
+	conn = i_new(struct imapc_client_connection, 1);
+	conn->client = client;
+	conn->conn = imapc_connection_init(client, imapc_client_login_callback,
+					   conn);
+	array_push_back(&client->conns, &conn);
+	return conn;
+}
+
+static struct imapc_connection *
+imapc_client_find_connection(struct imapc_client *client)
+{
+	struct imapc_client_connection *const *connp;
+
+	/* FIXME: stupid algorithm */
+	if (array_count(&client->conns) == 0)
+		return imapc_client_add_connection(client)->conn;
+	connp = array_front(&client->conns);
+	return (*connp)->conn;
+}
+
+struct imapc_command *
+imapc_client_cmd(struct imapc_client *client,
+		 imapc_command_callback_t *callback, void *context)
+{
+	struct imapc_connection *conn;
+
+	conn = imapc_client_find_connection(client);
+	return imapc_connection_cmd(conn, callback, context);
+}
+
+static struct imapc_client_connection *
+imapc_client_get_unboxed_connection(struct imapc_client *client)
+{
+	struct imapc_client_connection *const *conns;
+	unsigned int i, count;
+
+	conns = array_get(&client->conns, &count);
+	for (i = 0; i < count; i++) {
+		if (conns[i]->box == NULL)
+			return conns[i];
+	}
+	return imapc_client_add_connection(client);
+}
+
+
+void imapc_client_login(struct imapc_client *client)
+{
+	struct imapc_client_connection *conn;
+
+	i_assert(client->login_callback != NULL);
+	i_assert(array_count(&client->conns) == 0);
+
+	conn = imapc_client_add_connection(client);
+	imapc_connection_connect(conn->conn);
+}
+
+struct imapc_logout_ctx {
+	struct imapc_client *client;
+	unsigned int logout_count;
+};
+
+static void
+imapc_client_logout_callback(const struct imapc_command_reply *reply ATTR_UNUSED,
+			     void *context)
+{
+	struct imapc_logout_ctx *ctx = context;
+
+	i_assert(ctx->logout_count > 0);
+
+	if (--ctx->logout_count == 0)
+		imapc_client_stop(ctx->client);
+}
+
+void imapc_client_logout(struct imapc_client *client)
+{
+	struct imapc_logout_ctx ctx = { .client = client };
+	struct imapc_client_connection *conn;
+	struct imapc_command *cmd;
+
+	client->logging_out = TRUE;
+
+	/* send LOGOUT to all connections */
+	array_foreach_elem(&client->conns, conn) {
+		if (imapc_connection_get_state(conn->conn) == IMAPC_CONNECTION_STATE_DISCONNECTED)
+			continue;
+		imapc_connection_set_no_reconnect(conn->conn);
+		ctx.logout_count++;
+		cmd = imapc_connection_cmd(conn->conn,
+			imapc_client_logout_callback, &ctx);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN |
+					IMAPC_COMMAND_FLAG_LOGOUT);
+		imapc_command_send(cmd, "LOGOUT");
+	}
+
+	/* wait for LOGOUT to finish */
+	while (ctx.logout_count > 0)
+		imapc_client_run(client);
+
+	/* we should have disconnected all clients already, but if there were
+	   any timeouts there may be some clients left. */
+	imapc_client_disconnect(client);
+}
+
+struct imapc_client_mailbox *
+imapc_client_mailbox_open(struct imapc_client *client,
+			  void *untagged_box_context)
+{
+	struct imapc_client_mailbox *box;
+	struct imapc_client_connection *conn;
+
+	box = i_new(struct imapc_client_mailbox, 1);
+	box->client = client;
+	box->untagged_box_context = untagged_box_context;
+	conn = imapc_client_get_unboxed_connection(client);
+	conn->box = box;
+	box->conn = conn->conn;
+	box->msgmap = imapc_msgmap_init();
+	/* if we get disconnected before the SELECT is finished, allow
+	   one reconnect retry. */
+	box->reconnect_ok = TRUE;
+	return box;
+}
+
+void imapc_client_mailbox_set_reopen_cb(struct imapc_client_mailbox *box,
+					void (*callback)(void *context),
+					void *context)
+{
+	box->reopen_callback = callback;
+	box->reopen_context = context;
+}
+
+bool imapc_client_mailbox_can_reconnect(struct imapc_client_mailbox *box)
+{
+	/* the reconnect_ok flag attempts to avoid infinite reconnection loops
+	   to a server that keeps disconnecting us (e.g. some of the commands
+	   we send keeps crashing it always) */
+	return box->reopen_callback != NULL && box->reconnect_ok;
+}
+
+void imapc_client_mailbox_reconnect(struct imapc_client_mailbox *box,
+				    const char *errmsg)
+{
+	imapc_connection_try_reconnect(box->conn, errmsg, 0, FALSE);
+}
+
+void imapc_client_mailbox_close(struct imapc_client_mailbox **_box)
+{
+	struct imapc_client_mailbox *box = *_box;
+	struct imapc_client_connection *conn;
+
+	box->closing = TRUE;
+
+	/* cancel any pending commands */
+	imapc_connection_unselect(box, FALSE);
+
+	if (box->reconnecting) {
+		/* need to abort the reconnection so it won't try to access
+		   the box */
+		imapc_connection_disconnect(box->conn);
+	}
+
+	/* set this only after unselect, which may cancel some commands that
+	   reference this box */
+	*_box = NULL;
+
+	array_foreach_elem(&box->client->conns, conn) {
+		if (conn->box == box) {
+			conn->box = NULL;
+			break;
+		}
+	}
+
+	imapc_msgmap_deinit(&box->msgmap);
+	timeout_remove(&box->to_send_idle);
+	i_free(box);
+}
+
+struct imapc_command *
+imapc_client_mailbox_cmd(struct imapc_client_mailbox *box,
+			 imapc_command_callback_t *callback, void *context)
+{
+	struct imapc_command *cmd;
+
+	i_assert(!box->closing);
+
+	cmd = imapc_connection_cmd(box->conn, callback, context);
+	imapc_command_set_mailbox(cmd, box);
+	return cmd;
+}
+
+struct imapc_msgmap *
+imapc_client_mailbox_get_msgmap(struct imapc_client_mailbox *box)
+{
+	return box->msgmap;
+}
+
+static void imapc_client_mailbox_idle_send(struct imapc_client_mailbox *box)
+{
+	timeout_remove(&box->to_send_idle);
+	if (imapc_client_mailbox_is_opened(box))
+		imapc_connection_idle(box->conn);
+}
+
+void imapc_client_mailbox_idle(struct imapc_client_mailbox *box)
+{
+	/* send the IDLE with a delay to avoid unnecessary IDLEs that are
+	   immediately aborted */
+	if (box->to_send_idle == NULL && imapc_client_mailbox_is_opened(box)) {
+		box->to_send_idle =
+			timeout_add_short(IMAPC_CLIENT_IDLE_SEND_DELAY_MSECS,
+					  imapc_client_mailbox_idle_send, box);
+	}
+	/* we're done with all work at this point. */
+	box->reconnect_ok = TRUE;
+}
+
+bool imapc_client_mailbox_is_opened(struct imapc_client_mailbox *box)
+{
+	struct imapc_client_mailbox *selected_box;
+
+	if (box->closing ||
+	    imapc_connection_get_state(box->conn) != IMAPC_CONNECTION_STATE_DONE)
+		return FALSE;
+
+	selected_box = imapc_connection_get_mailbox(box->conn);
+	if (selected_box != box) {
+		if (selected_box != NULL)
+			i_error("imapc: Selected mailbox changed unexpectedly");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+static bool
+imapc_client_get_any_capabilities(struct imapc_client *client,
+				  enum imapc_capability *capabilities_r)
+{
+	struct imapc_client_connection *conn;
+
+	array_foreach_elem(&client->conns, conn) {
+		if (imapc_connection_get_state(conn->conn) == IMAPC_CONNECTION_STATE_DONE) {
+			*capabilities_r = imapc_connection_get_capabilities(conn->conn);
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+int imapc_client_get_capabilities(struct imapc_client *client,
+				  enum imapc_capability *capabilities_r)
+{
+	/* try to find a connection that is already logged in */
+	if (imapc_client_get_any_capabilities(client, capabilities_r))
+		return 0;
+
+	/* if there are no connections yet, create one */
+	if (array_count(&client->conns) == 0)
+		(void)imapc_client_add_connection(client);
+
+	/* wait for any of the connections to login */
+	client->stop_on_state_finish = TRUE;
+	imapc_client_run(client);
+	client->stop_on_state_finish = FALSE;
+	if (imapc_client_get_any_capabilities(client, capabilities_r))
+		return 0;
+
+	/* failed */
+	return -1;
+}
+
+int imapc_client_create_temp_fd(struct imapc_client *client,
+				const char **path_r)
+{
+	string_t *path;
+	int fd;
+
+	if (client->set.temp_path_prefix == NULL) {
+		i_error("imapc: temp_path_prefix not set, "
+			"can't create temp file");
+		return -1;
+	}
+
+	path = t_str_new(128);
+	str_append(path, client->set.temp_path_prefix);
+	fd = safe_mkstemp(path, 0600, (uid_t)-1, (gid_t)-1);
+	if (fd == -1) {
+		i_error("safe_mkstemp(%s) failed: %m", str_c(path));
+		return -1;
+	}
+
+	/* we just want the fd, unlink it */
+	if (i_unlink(str_c(path)) < 0) {
+		/* shouldn't happen.. */
+		i_close_fd(&fd);
+		return -1;
+	}
+	*path_r = str_c(path);
+	return fd;
+}
+
+void imapc_client_register_state_change_callback(struct imapc_client *client,
+						 imapc_state_change_callback_t *cb,
+						 void *context)
+{
+	i_assert(client->state_change_callback == NULL);
+	i_assert(client->state_change_context == NULL);
+
+	client->state_change_callback = cb;
+	client->state_change_context = context;
+}
+
+void
+imapc_client_set_login_callback(struct imapc_client *client,
+				imapc_command_callback_t *callback, void *context)
+{
+	client->login_callback = callback;
+	client->login_context  = context;
+}
+
diff --git a/src/lib-imap-client/imapc-client.h b/src/lib-imap-client/imapc-client.h
new file mode 100644
index 0000000..5c81be6
--- /dev/null
+++ b/src/lib-imap-client/imapc-client.h
@@ -0,0 +1,250 @@
+#ifndef IMAPC_CLIENT_H
+#define IMAPC_CLIENT_H
+
+#include "net.h"
+#include "iostream-ssl.h"
+
+/* IMAP RFC defines this to be at least 30 minutes. */
+#define IMAPC_DEFAULT_MAX_IDLE_TIME (60*29)
+
+enum imapc_command_state {
+	IMAPC_COMMAND_STATE_OK = 0,
+	IMAPC_COMMAND_STATE_NO,
+	IMAPC_COMMAND_STATE_BAD,
+	/* Authentication to IMAP server failed (NO or BAD) */
+	IMAPC_COMMAND_STATE_AUTH_FAILED,
+	/* Client was unexpectedly disconnected. */
+	IMAPC_COMMAND_STATE_DISCONNECTED
+};
+extern const char *imapc_command_state_names[];
+
+enum imapc_capability {
+	IMAPC_CAPABILITY_SASL_IR	= 0x01,
+	IMAPC_CAPABILITY_LITERALPLUS	= 0x02,
+	IMAPC_CAPABILITY_QRESYNC	= 0x04,
+	IMAPC_CAPABILITY_IDLE		= 0x08,
+	IMAPC_CAPABILITY_UIDPLUS	= 0x10,
+	IMAPC_CAPABILITY_AUTH_PLAIN	= 0x20,
+	IMAPC_CAPABILITY_STARTTLS	= 0x40,
+	IMAPC_CAPABILITY_X_GM_EXT_1	= 0x80,
+	IMAPC_CAPABILITY_CONDSTORE	= 0x100,
+	IMAPC_CAPABILITY_NAMESPACE	= 0x200,
+	IMAPC_CAPABILITY_UNSELECT	= 0x400,
+	IMAPC_CAPABILITY_ESEARCH	= 0x800,
+	IMAPC_CAPABILITY_WITHIN		= 0x1000,
+	IMAPC_CAPABILITY_QUOTA		= 0x2000,
+	IMAPC_CAPABILITY_ID		= 0x4000,
+	IMAPC_CAPABILITY_SAVEDATE	= 0x8000,
+
+	IMAPC_CAPABILITY_IMAP4REV1	= 0x40000000
+};
+struct imapc_capability_name {
+	const char *name;
+	enum imapc_capability capability;
+};
+extern const struct imapc_capability_name imapc_capability_names[];
+
+enum imapc_command_flags {
+	/* The command changes the selected mailbox (SELECT, EXAMINE) */
+	IMAPC_COMMAND_FLAG_SELECT	= 0x01,
+	/* The command is sent to server before login (or is the login
+	   command itself). Non-prelogin commands will be queued until login
+	   is successful. */
+	IMAPC_COMMAND_FLAG_PRELOGIN	= 0x02,
+	/* Allow command to be automatically retried if disconnected before it
+	   finishes. */
+	IMAPC_COMMAND_FLAG_RETRIABLE	= 0x04,
+	/* This is the LOGOUT command. Use a small timeout for it. */
+	IMAPC_COMMAND_FLAG_LOGOUT	= 0x08,
+	/* Command is being resent after a reconnection. */
+	IMAPC_COMMAND_FLAG_RECONNECTED	= 0x10
+};
+
+enum imapc_client_ssl_mode {
+	IMAPC_CLIENT_SSL_MODE_NONE,
+	IMAPC_CLIENT_SSL_MODE_IMMEDIATE,
+	IMAPC_CLIENT_SSL_MODE_STARTTLS
+};
+
+#define IMAPC_DEFAULT_CONNECT_TIMEOUT_MSECS (1000*30)
+#define IMAPC_DEFAULT_COMMAND_TIMEOUT_MSECS (1000*60*5)
+#define IMAPC_DEFAULT_MAX_LINE_LENGTH (SIZE_MAX)
+
+struct imapc_throttling_settings {
+	unsigned int init_msecs;
+	unsigned int max_msecs;
+	unsigned int shrink_min_msecs;
+};
+
+struct imapc_client_settings {
+	const char *host;
+	in_port_t port;
+
+	const char *master_user;
+	const char *username;
+	const char *password;
+	/* Space-separated list of SASL mechanisms to try (in the specified
+	   order). The default is to use only LOGIN command or SASL PLAIN. */
+	const char *sasl_mechanisms;
+	bool use_proxyauth; /* Use Sun/Oracle PROXYAUTH command */
+	unsigned int max_idle_time;
+	/* If ID capability is advertised, send a unique "x-session-ext-id",
+	   which begins with this prefix. */
+	const char *session_id_prefix;
+
+	const char *dns_client_socket_path;
+	const char *temp_path_prefix;
+	struct ssl_iostream_settings ssl_set;
+
+	enum imapc_client_ssl_mode ssl_mode;
+
+	const char *rawlog_dir;
+	bool debug;
+
+	/* Timeout for logging in. 0 = default. */
+	unsigned int connect_timeout_msecs;
+	/* Number of retries, -1 = infinity */
+	unsigned int connect_retry_count;
+	/* Interval between retries, must be > 0 if retries > 0 */
+	unsigned int connect_retry_interval_msecs;
+
+	/* Timeout for IMAP commands. Reset every time more data is being
+	   sent or received. 0 = default. */
+	unsigned int cmd_timeout_msecs;
+
+	/* Maximum allowed line length (not including literals read as
+	   streams). 0 = unlimited. */
+	size_t max_line_length;
+
+	struct imapc_throttling_settings throttle_set;
+};
+
+struct imapc_command_reply {
+	enum imapc_command_state state;
+	/* "[RESP TEXT]" produces key=RESP, value=TEXT.
+	   "[RESP]" produces key=RESP, value=NULL
+	   otherwise both are NULL */
+	const char *resp_text_key, *resp_text_value;
+	/* The full tagged reply, including [RESP TEXT]. */
+	const char *text_full;
+	/* Tagged reply text without [RESP TEXT] */
+	const char *text_without_resp;
+};
+
+struct imapc_arg_file {
+	/* file descriptor containing the value */
+	int fd;
+
+	/* parent_arg.list[list_idx] points to the IMAP_ARG_LITERAL_SIZE
+	   argument */
+	const struct imap_arg *parent_arg;
+	unsigned int list_idx;
+};
+
+struct imapc_untagged_reply {
+	/* name of the untagged reply, e.g. EXISTS */
+	const char *name;
+	/* number at the beginning of the reply, or 0 if there wasn't any.
+	   Set for EXISTS, EXPUNGE, etc. */
+	uint32_t num;
+	/* the rest of the reply can be read from these args. */
+	const struct imap_arg *args;
+	/* arguments whose contents are stored into files. only
+	   "FETCH (BODY[" arguments can be here. */
+	const struct imapc_arg_file *file_args;
+	unsigned int file_args_count;
+
+	/* "* OK [RESP TEXT]" produces key=RESP, value=TEXT.
+	   "* OK [RESP]" produces key=RESP, value=NULL
+	   otherwise both are NULL */
+	const char *resp_text_key, *resp_text_value;
+
+	/* If this reply occurred while a mailbox was selected, this contains
+	   the mailbox's untagged_context. */
+	void *untagged_box_context;
+};
+
+enum imapc_state_change_event {
+	IMAPC_STATE_CHANGE_AUTH_OK,
+	IMAPC_STATE_CHANGE_AUTH_FAILED,
+};
+
+/* Called when tagged reply is received for command. */
+typedef void imapc_command_callback_t(const struct imapc_command_reply *reply,
+				      void *context);
+/* Called each time untagged input is received. */
+typedef void imapc_untagged_callback_t(const struct imapc_untagged_reply *reply,
+				       void *context);
+typedef void imapc_state_change_callback_t(void *context,
+					   enum imapc_state_change_event event,
+					   const char *error);
+
+struct imapc_client *
+imapc_client_init(const struct imapc_client_settings *set,
+		  struct event *event_parent);
+void imapc_client_disconnect(struct imapc_client *client);
+void imapc_client_deinit(struct imapc_client **client);
+
+/* Set login callback, must be set before calling other commands.
+   This is called only for the first login, not for any reconnects or if there
+   are multiple connections created. */
+void
+imapc_client_set_login_callback(struct imapc_client *client,
+				imapc_command_callback_t *callback, void *context);
+/* Explicitly login to server (also done automatically). */
+void imapc_client_login(struct imapc_client *client);
+/* Send a LOGOUT and wait for disconnection. */
+void imapc_client_logout(struct imapc_client *client);
+
+struct imapc_command *
+imapc_client_cmd(struct imapc_client *client,
+		 imapc_command_callback_t *callback, void *context);
+void imapc_command_set_flags(struct imapc_command *cmd,
+			     enum imapc_command_flags flags);
+bool imapc_command_connection_is_selected(struct imapc_command *cmd);
+void imapc_command_send(struct imapc_command *cmd, const char *cmd_str);
+void imapc_command_sendf(struct imapc_command *cmd, const char *cmd_fmt, ...)
+	ATTR_FORMAT(2, 3);
+void imapc_command_sendvf(struct imapc_command *cmd,
+			  const char *cmd_fmt, va_list args) ATTR_FORMAT(2, 0);
+const char *imapc_command_get_tag(struct imapc_command *cmd);
+void imapc_command_abort(struct imapc_command **cmd);
+
+void imapc_client_register_untagged(struct imapc_client *client,
+				    imapc_untagged_callback_t *callback,
+				    void *context);
+
+void imapc_client_run(struct imapc_client *client);
+void imapc_client_stop(struct imapc_client *client);
+bool imapc_client_is_running(struct imapc_client *client);
+
+struct imapc_client_mailbox *
+imapc_client_mailbox_open(struct imapc_client *client,
+			  void *untagged_box_context);
+void imapc_client_mailbox_set_reopen_cb(struct imapc_client_mailbox *box,
+					void (*callback)(void *context),
+					void *context);
+void imapc_client_mailbox_close(struct imapc_client_mailbox **box);
+bool imapc_client_mailbox_can_reconnect(struct imapc_client_mailbox *box);
+void imapc_client_mailbox_reconnect(struct imapc_client_mailbox *box,
+				    const char *errmsg);
+struct imapc_command *
+imapc_client_mailbox_cmd(struct imapc_client_mailbox *box,
+			 imapc_command_callback_t *callback, void *context);
+struct imapc_msgmap *
+imapc_client_mailbox_get_msgmap(struct imapc_client_mailbox *box);
+
+void imapc_client_mailbox_idle(struct imapc_client_mailbox *box);
+bool imapc_client_mailbox_is_opened(struct imapc_client_mailbox *box);
+
+int imapc_client_get_capabilities(struct imapc_client *client,
+				  enum imapc_capability *capabilities_r);
+
+int imapc_client_create_temp_fd(struct imapc_client *client,
+				const char **path_r);
+
+void imapc_client_register_state_change_callback(struct imapc_client *client,
+						 imapc_state_change_callback_t *cb,
+						 void *context);
+
+#endif
diff --git a/src/lib-imap-client/imapc-connection.c b/src/lib-imap-client/imapc-connection.c
new file mode 100644
index 0000000..f025403
--- /dev/null
+++ b/src/lib-imap-client/imapc-connection.c
@@ -0,0 +1,2557 @@
+/* Copyright (c) 2011-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "ioloop.h"
+#include "net.h"
+#include "istream.h"
+#include "ostream.h"
+#include "base64.h"
+#include "write-full.h"
+#include "str.h"
+#include "time-util.h"
+#include "dns-lookup.h"
+#include "dsasl-client.h"
+#include "iostream-rawlog.h"
+#include "iostream-ssl.h"
+#include "imap-quote.h"
+#include "imap-util.h"
+#include "imap-parser.h"
+#include "imapc-client-private.h"
+#include "imapc-connection.h"
+
+#include <unistd.h>
+#include <ctype.h>
+
+#define IMAPC_COMMAND_STATE_AUTHENTICATE_CONTINUE 10000
+#define IMAPC_MAX_INLINE_LITERAL_SIZE (1024*32)
+/* If LOGOUT reply takes longer than this, disconnect. */
+#define IMAPC_LOGOUT_TIMEOUT_MSECS 5000
+
+enum imapc_input_state {
+	IMAPC_INPUT_STATE_NONE = 0,
+	IMAPC_INPUT_STATE_PLUS,
+	IMAPC_INPUT_STATE_UNTAGGED,
+	IMAPC_INPUT_STATE_UNTAGGED_NUM,
+	IMAPC_INPUT_STATE_TAGGED
+};
+
+struct imapc_command_stream {
+	unsigned int pos;
+	uoff_t size;
+	struct istream *input;
+};
+
+struct imapc_command {
+	pool_t pool;
+	buffer_t *data;
+	unsigned int send_pos;
+	unsigned int tag;
+
+	enum imapc_command_flags flags;
+	struct imapc_connection *conn;
+	/* If non-NULL, points to the mailbox where this command should be
+	   executed */
+	struct imapc_client_mailbox *box;
+
+	ARRAY(struct imapc_command_stream) streams;
+
+	imapc_command_callback_t *callback;
+	void *context;
+
+	/* This is the AUTHENTICATE command */
+	bool authenticate:1;
+	/* This is the IDLE command */
+	bool idle:1;
+	/* Waiting for '+' literal reply before we can continue */
+	bool wait_for_literal:1;
+	/* Command is fully sent to server */
+	bool sent:1;
+};
+ARRAY_DEFINE_TYPE(imapc_command, struct imapc_command *);
+
+struct imapc_connection_literal {
+	char *temp_path;
+	int fd;
+	uoff_t bytes_left;
+
+	const struct imap_arg *parent_arg;
+	unsigned int list_idx;
+};
+
+struct imapc_connection {
+	struct imapc_client *client;
+	char *name;
+	int refcount;
+
+	int fd;
+	struct io *io;
+	struct istream *input, *raw_input;
+	struct ostream *output, *raw_output;
+	struct imap_parser *parser;
+	struct timeout *to;
+	struct timeout *to_output;
+	struct dns_lookup *dns_lookup;
+	struct dsasl_client *sasl_client;
+
+	struct ssl_iostream *ssl_iostream;
+
+	int (*input_callback)(struct imapc_connection *conn);
+	enum imapc_input_state input_state;
+	unsigned int cur_tag;
+	uint32_t cur_num;
+	struct timeval last_connect;
+	unsigned int reconnect_count;
+
+	/* If QRESYNC isn't used, this is set immediately after issuing
+	   SELECT/EXAMINE. We could differentiate better whether a mailbox is
+	   "being selected" vs "fully selected", but that code is already in
+	   the imapc-storage side so it would have to be moved or duplicated
+	   here. And since nothing actually cares about this distinction (yet),
+	   don't bother with it for now. This is set to NULL when the mailbox
+	   is closed from imapc-storage point of view, even if the server is
+	   still in selected state (see selected_on_server). */
+	struct imapc_client_mailbox *selected_box;
+	/* If QRESYNC is used, this is set when SELECT/EXAMINE is issued.
+	   If the server is already in selected state, the selected_box is most
+	   likely already NULL at this point, because imapc-storage has closed
+	   it. */
+	struct imapc_client_mailbox *qresync_selecting_box;
+	enum imapc_connection_state state;
+	char *disconnect_reason;
+
+	enum imapc_capability capabilities;
+	char **capabilities_list;
+
+	imapc_command_callback_t *login_callback;
+	void *login_context;
+
+	/* commands pending in queue to be sent */
+	ARRAY_TYPE(imapc_command) cmd_send_queue;
+	/* commands that have been sent, waiting for their tagged reply */
+	ARRAY_TYPE(imapc_command) cmd_wait_list;
+	/* commands that were already sent, but were aborted since (due to
+	   unselecting mailbox). */
+	ARRAY_TYPE(seq_range) aborted_cmd_tags;
+	unsigned int reconnect_command_count;
+
+	unsigned int ips_count, prev_connect_idx;
+	struct ip_addr *ips;
+
+	struct imapc_connection_literal literal;
+	ARRAY(struct imapc_arg_file) literal_files;
+
+	unsigned int throttle_msecs;
+	unsigned int throttle_shrink_msecs;
+	unsigned int last_successful_throttle_msecs;
+	bool throttle_pending;
+	struct timeval throttle_end_timeval;
+	struct timeout *to_throttle, *to_throttle_shrink;
+
+	bool reconnecting:1;
+	bool reconnect_waiting:1;
+	bool reconnect_ok:1;
+	bool idling:1;
+	bool idle_stopping:1;
+	bool idle_plus_waiting:1;
+	bool select_waiting_reply:1;
+	/* TRUE if IMAP server is in SELECTED state. select_box may be NULL
+	   though, if we already closed the mailbox from client point of
+	   view. */
+	bool selected_on_server:1;
+};
+
+static void imapc_connection_capability_cb(const struct imapc_command_reply *reply,
+					   void *context);
+static int imapc_connection_output(struct imapc_connection *conn);
+static int imapc_connection_ssl_init(struct imapc_connection *conn);
+static void imapc_command_free(struct imapc_command *cmd);
+static void imapc_command_send_more(struct imapc_connection *conn);
+static void
+imapc_login_callback(struct imapc_connection *conn,
+		     const struct imapc_command_reply *reply);
+
+static void
+imapc_auth_ok(struct imapc_connection *conn)
+{
+	if (conn->client->set.debug)
+		i_debug("imapc(%s): Authenticated successfully", conn->name);
+
+	if (conn->client->state_change_callback == NULL)
+		return;
+
+	conn->client->state_change_callback(conn->client->state_change_context,
+					    IMAPC_STATE_CHANGE_AUTH_OK, NULL);
+}
+
+static void
+imapc_auth_failed(struct imapc_connection *conn, const struct imapc_command_reply *_reply,
+		  const char *error)
+{
+	struct imapc_command_reply reply = *_reply;
+
+	reply.text_without_resp = reply.text_full =
+		t_strdup_printf("Authentication failed: %s", error);
+	if (reply.state != IMAPC_COMMAND_STATE_DISCONNECTED) {
+		reply.state = IMAPC_COMMAND_STATE_AUTH_FAILED;
+		i_error("imapc(%s): %s", conn->name, reply.text_full);
+	}
+	imapc_login_callback(conn, &reply);
+
+	if (conn->client->state_change_callback == NULL)
+		return;
+
+	conn->client->state_change_callback(conn->client->state_change_context,
+					    IMAPC_STATE_CHANGE_AUTH_FAILED,
+					    error);
+}
+
+struct imapc_connection *
+imapc_connection_init(struct imapc_client *client,
+		      imapc_command_callback_t *login_callback,
+		      void *login_context)
+{
+	struct imapc_connection *conn;
+
+	conn = i_new(struct imapc_connection, 1);
+	conn->refcount = 1;
+	conn->client = client;
+	conn->login_callback = login_callback;
+	conn->login_context = login_context;
+	conn->fd = -1;
+	conn->name = i_strdup_printf("%s:%u", client->set.host,
+				     client->set.port);
+	conn->literal.fd = -1;
+	conn->reconnect_ok = (client->set.connect_retry_count>0);
+	i_array_init(&conn->cmd_send_queue, 8);
+	i_array_init(&conn->cmd_wait_list, 32);
+	i_array_init(&conn->literal_files, 4);
+	i_array_init(&conn->aborted_cmd_tags, 8);
+
+	if (client->set.debug)
+		i_debug("imapc(%s): Created new connection", conn->name);
+
+	imapc_client_ref(client);
+	return conn;
+}
+
+static void imapc_connection_ref(struct imapc_connection *conn)
+{
+	i_assert(conn->refcount > 0);
+
+	conn->refcount++;
+}
+
+static void imapc_connection_unref(struct imapc_connection **_conn)
+{
+	struct imapc_connection *conn = *_conn;
+
+	i_assert(conn->refcount > 0);
+
+	*_conn = NULL;
+	if (--conn->refcount > 0)
+		return;
+
+	i_assert(conn->disconnect_reason == NULL);
+
+	if (conn->capabilities_list != NULL)
+		p_strsplit_free(default_pool, conn->capabilities_list);
+	array_free(&conn->cmd_send_queue);
+	array_free(&conn->cmd_wait_list);
+	array_free(&conn->literal_files);
+	array_free(&conn->aborted_cmd_tags);
+	imapc_client_unref(&conn->client);
+	i_free(conn->ips);
+	i_free(conn->name);
+	i_free(conn);
+}
+
+void imapc_connection_deinit(struct imapc_connection **_conn)
+{
+	imapc_connection_disconnect(*_conn);
+	imapc_connection_unref(_conn);
+}
+
+void imapc_connection_ioloop_changed(struct imapc_connection *conn)
+{
+	if (conn->io != NULL)
+		conn->io = io_loop_move_io(&conn->io);
+	if (conn->to != NULL)
+		conn->to = io_loop_move_timeout(&conn->to);
+	if (conn->to_throttle != NULL)
+		conn->to_throttle = io_loop_move_timeout(&conn->to_throttle);
+	if (conn->to_throttle_shrink != NULL)
+		conn->to_throttle_shrink = io_loop_move_timeout(&conn->to_throttle_shrink);
+	if (conn->output != NULL)
+		o_stream_switch_ioloop(conn->output);
+	if (conn->dns_lookup != NULL)
+		dns_lookup_switch_ioloop(conn->dns_lookup);
+
+	if (conn->client->ioloop == NULL && conn->to_output != NULL) {
+		/* we're only once moving the to_output to the main ioloop,
+		   since timeout moves currently also reset the timeout.
+		   (the rest of the times this is a no-op) */
+		conn->to_output = io_loop_move_timeout(&conn->to_output);
+	}
+}
+
+static const char *imapc_command_get_readable(struct imapc_command *cmd)
+{
+	string_t *str = t_str_new(256);
+	const unsigned char *data = cmd->data->data;
+	unsigned int i;
+
+	for (i = 0; i < cmd->data->used; i++) {
+		if (data[i] != '\r' && data[i] != '\n')
+			str_append_c(str, data[i]);
+	}
+	return str_c(str);
+}
+
+static void
+imapc_connection_abort_commands_array(ARRAY_TYPE(imapc_command) *cmd_array,
+				      ARRAY_TYPE(imapc_command) *dest_array,
+				      struct imapc_client_mailbox *only_box,
+				      bool keep_retriable)
+{
+	struct imapc_command *cmd;
+	unsigned int i;
+
+	for (i = 0; i < array_count(cmd_array); ) {
+		cmd = array_idx_elem(cmd_array, i);
+
+		if (cmd->box != only_box && only_box != NULL)
+			i++;
+		else if (keep_retriable &&
+			 (cmd->flags & IMAPC_COMMAND_FLAG_RETRIABLE) != 0) {
+			cmd->send_pos = 0;
+			cmd->wait_for_literal = 0;
+			cmd->flags |= IMAPC_COMMAND_FLAG_RECONNECTED;
+			i++;
+		} else {
+			array_delete(cmd_array, i, 1);
+			array_push_back(dest_array, &cmd);
+		}
+	}
+}
+
+void imapc_connection_abort_commands(struct imapc_connection *conn,
+				     struct imapc_client_mailbox *only_box,
+				     bool keep_retriable)
+{
+	struct imapc_command *cmd;
+	ARRAY_TYPE(imapc_command) tmp_array;
+	struct imapc_command_reply reply;
+
+	t_array_init(&tmp_array, 8);
+	imapc_connection_abort_commands_array(&conn->cmd_wait_list, &tmp_array,
+					      only_box, keep_retriable);
+	imapc_connection_abort_commands_array(&conn->cmd_send_queue, &tmp_array,
+					      only_box, keep_retriable);
+
+	if (array_count(&conn->cmd_wait_list) > 0 && only_box == NULL) {
+		/* need to move all the waiting commands to send queue */
+		array_append_array(&conn->cmd_wait_list,
+				   &conn->cmd_send_queue);
+		array_clear(&conn->cmd_send_queue);
+		array_append_array(&conn->cmd_send_queue,
+				   &conn->cmd_wait_list);
+		array_clear(&conn->cmd_wait_list);
+	}
+
+	/* abort the commands. we'll do it here later so that if the
+	   callback recurses us back here we don't crash */
+	i_zero(&reply);
+	reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
+	if (only_box != NULL) {
+		reply.text_without_resp = reply.text_full =
+			"Unselecting mailbox";
+	} else {
+		reply.text_without_resp = reply.text_full =
+			"Disconnected from server";
+	}
+	array_foreach_elem(&tmp_array, cmd) {
+		if (cmd->sent && conn->state == IMAPC_CONNECTION_STATE_DONE) {
+			/* We're not disconnected, so the reply will still
+			   come. Remember that it needs to be ignored. */
+			seq_range_array_add(&conn->aborted_cmd_tags, cmd->tag);
+		}
+		cmd->callback(&reply, cmd->context);
+		imapc_command_free(cmd);
+	}
+	if (array_count(&conn->cmd_wait_list) == 0)
+		timeout_remove(&conn->to);
+}
+
+static void
+imapc_login_callback(struct imapc_connection *conn,
+		     const struct imapc_command_reply *reply)
+{
+	if (conn->login_callback != NULL)
+		conn->login_callback(reply, conn->login_context);
+}
+
+static void imapc_connection_set_state(struct imapc_connection *conn,
+				       enum imapc_connection_state state)
+{
+	struct imapc_command_reply reply;
+
+	conn->state = state;
+
+	switch (state) {
+	case IMAPC_CONNECTION_STATE_DISCONNECTED:
+		i_zero(&reply);
+		reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
+		reply.text_full = "Disconnected from server";
+		if (conn->disconnect_reason != NULL) {
+			reply.text_full = t_strdup_printf("%s: %s",
+				reply.text_full, conn->disconnect_reason);
+			i_free_and_null(conn->disconnect_reason);
+		}
+		reply.text_without_resp = reply.text_full;
+		if (!conn->reconnecting) {
+			imapc_login_callback(conn, &reply);
+			i_free(conn->ips);
+			conn->ips_count = 0;
+		}
+		array_clear(&conn->aborted_cmd_tags);
+		conn->idling = FALSE;
+		conn->idle_plus_waiting = FALSE;
+		conn->idle_stopping = FALSE;
+
+		conn->select_waiting_reply = FALSE;
+		conn->qresync_selecting_box = NULL;
+		conn->selected_box = NULL;
+		conn->selected_on_server = FALSE;
+		/* fall through */
+	case IMAPC_CONNECTION_STATE_DONE:
+		/* if we came from imapc_client_get_capabilities(), stop so
+		   it can finish up and not just hang indefinitely. */
+		if (conn->client->stop_on_state_finish && !conn->reconnecting)
+			imapc_client_stop(conn->client);
+		break;
+	default:
+		break;
+	}
+}
+
+static void imapc_connection_lfiles_free(struct imapc_connection *conn)
+{
+	struct imapc_arg_file *lfile;
+
+	array_foreach_modifiable(&conn->literal_files, lfile) {
+		if (close(lfile->fd) < 0)
+			i_error("imapc: close(literal file) failed: %m");
+	}
+	array_clear(&conn->literal_files);
+}
+
+static void
+imapc_connection_literal_reset(struct imapc_connection_literal *literal)
+{
+	i_close_fd_path(&literal->fd, literal->temp_path);
+	i_free_and_null(literal->temp_path);
+
+	i_zero(literal);
+	literal->fd = -1;
+}
+
+void imapc_connection_disconnect_full(struct imapc_connection *conn,
+				      bool reconnecting)
+{
+	/* timeout may be set also in disconnected state */
+	timeout_remove(&conn->to);
+	conn->reconnecting = reconnecting;
+
+	if (conn->state == IMAPC_CONNECTION_STATE_DISCONNECTED) {
+		i_assert(array_count(&conn->cmd_wait_list) == 0);
+		if (conn->reconnect_command_count == 0)
+			imapc_connection_abort_commands(conn, NULL,
+						reconnecting);
+		return;
+	}
+
+	if (conn->client->set.debug)
+		i_debug("imapc(%s): Disconnected", conn->name);
+
+	if (conn->dns_lookup != NULL)
+		dns_lookup_abort(&conn->dns_lookup);
+	imapc_connection_lfiles_free(conn);
+	imapc_connection_literal_reset(&conn->literal);
+	timeout_remove(&conn->to_output);
+	timeout_remove(&conn->to_throttle);
+	timeout_remove(&conn->to_throttle_shrink);
+	if (conn->parser != NULL)
+		imap_parser_unref(&conn->parser);
+	io_remove(&conn->io);
+	ssl_iostream_destroy(&conn->ssl_iostream);
+	if (conn->fd != -1) {
+		i_stream_destroy(&conn->input);
+		o_stream_destroy(&conn->output);
+		net_disconnect(conn->fd);
+		conn->fd = -1;
+	}
+
+	/* get capabilities again after reconnection. this is especially
+	   important because post-login capabilities often do not contain AUTH=
+	   capabilities. */
+	conn->capabilities = 0;
+	if (conn->capabilities_list != NULL) {
+		p_strsplit_free(default_pool, conn->capabilities_list);
+		conn->capabilities_list = NULL;
+	}
+
+	imapc_connection_set_state(conn, IMAPC_CONNECTION_STATE_DISCONNECTED);
+	imapc_connection_abort_commands(conn, NULL, reconnecting);
+
+	if (!reconnecting) {
+		imapc_client_try_stop(conn->client);
+	}
+}
+
+void imapc_connection_set_no_reconnect(struct imapc_connection *conn)
+{
+	conn->reconnect_ok = FALSE;
+}
+
+void imapc_connection_disconnect(struct imapc_connection *conn)
+{
+	imapc_connection_disconnect_full(conn, FALSE);
+}
+
+static void imapc_connection_set_disconnected(struct imapc_connection *conn)
+{
+	imapc_connection_set_state(conn, IMAPC_CONNECTION_STATE_DISCONNECTED);
+	imapc_connection_abort_commands(conn, NULL, FALSE);
+}
+
+static bool imapc_connection_can_reconnect(struct imapc_connection *conn)
+{
+	if (conn->client->logging_out)
+		return FALSE;
+	if (conn->client->set.connect_retry_count == 0 ||
+	    (conn->client->set.connect_retry_count < UINT_MAX &&
+	     conn->reconnect_count >= conn->client->set.connect_retry_count))
+		return FALSE;
+
+	if (conn->selected_box != NULL)
+		return imapc_client_mailbox_can_reconnect(conn->selected_box);
+	else {
+		return conn->reconnect_command_count == 0 &&
+			conn->reconnect_ok;
+	}
+}
+
+static void imapc_connection_reconnect(struct imapc_connection *conn)
+{
+	conn->reconnect_ok = FALSE;
+	conn->reconnect_waiting = FALSE;
+
+	if (conn->selected_box != NULL) {
+		i_assert(!conn->selected_box->reconnecting);
+		conn->selected_box->reconnecting = TRUE;
+		/* if we fail again, avoid reconnecting immediately. if the
+		   server is broken we could just get into an infinitely
+		   failing reconnection loop. */
+		conn->selected_box->reconnect_ok = FALSE;
+	}
+	imapc_connection_disconnect_full(conn, TRUE);
+	imapc_connection_connect(conn);
+}
+
+void imapc_connection_try_reconnect(struct imapc_connection *conn,
+				    const char *errstr,
+				    unsigned int delay_msecs,
+				    bool connect_error)
+{
+	/* Try the next IP address only for connect() problems. */
+	if (conn->prev_connect_idx + 1 < conn->ips_count && connect_error) {
+		i_warning("imapc(%s): %s - trying the next IP", conn->name, errstr);
+		conn->reconnect_ok = TRUE;
+		imapc_connection_disconnect_full(conn, TRUE);
+		imapc_connection_connect(conn);
+		return;
+	}
+
+	if (!imapc_connection_can_reconnect(conn)) {
+		i_error("imapc(%s): %s - disconnecting", conn->name, errstr);
+		imapc_connection_disconnect(conn);
+	} else {
+		conn->reconnecting = TRUE;
+		i_warning("imapc(%s): %s - reconnecting (delay %u ms)", conn->name, errstr, delay_msecs);
+		if (delay_msecs == 0)
+			imapc_connection_reconnect(conn);
+		else {
+			imapc_connection_disconnect_full(conn, TRUE);
+			conn->to = timeout_add(delay_msecs, imapc_connection_reconnect, conn);
+			conn->reconnect_count++;
+			conn->reconnect_waiting = TRUE;
+		}
+	}
+}
+
+static void ATTR_FORMAT(2, 3)
+imapc_connection_input_error(struct imapc_connection *conn,
+			     const char *fmt, ...)
+{
+	va_list va;
+
+	va_start(va, fmt);
+	i_error("imapc(%s): Server sent invalid input: %s",
+		conn->name, t_strdup_vprintf(fmt, va));
+	imapc_connection_disconnect(conn);
+	va_end(va);
+}
+
+static bool last_arg_is_fetch_body(const struct imap_arg *args,
+				   const struct imap_arg **parent_arg_r,
+				   unsigned int *idx_r)
+{
+	const struct imap_arg *list;
+	const char *name;
+	unsigned int count;
+
+	if (args[0].type == IMAP_ARG_ATOM &&
+	    imap_arg_atom_equals(&args[1], "FETCH") &&
+	    imap_arg_get_list_full(&args[2], &list, &count) && count >= 2 &&
+	    list[count].type == IMAP_ARG_LITERAL_SIZE &&
+	    imap_arg_get_atom(&list[count-1], &name) &&
+	    strncasecmp(name, "BODY[", 5) == 0) {
+		*parent_arg_r = &args[2];
+		*idx_r = count;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+static int
+imapc_connection_read_literal_init(struct imapc_connection *conn, uoff_t size,
+				   const struct imap_arg *args)
+{
+	const char *path;
+	const struct imap_arg *parent_arg;
+	unsigned int idx;
+
+	i_assert(conn->literal.fd == -1);
+
+	if (size <= IMAPC_MAX_INLINE_LITERAL_SIZE ||
+	    !last_arg_is_fetch_body(args, &parent_arg, &idx)) {
+		/* read the literal directly into parser */
+		return 0;
+	}
+
+	conn->literal.fd = imapc_client_create_temp_fd(conn->client, &path);
+	if (conn->literal.fd == -1)
+		return -1;
+	conn->literal.temp_path = i_strdup(path);
+	conn->literal.bytes_left = size;
+	conn->literal.parent_arg = parent_arg;
+	conn->literal.list_idx = idx;
+	return 1;
+}
+
+static int imapc_connection_read_literal(struct imapc_connection *conn)
+{
+	struct imapc_arg_file *lfile;
+	const unsigned char *data;
+	size_t size;
+
+	if (conn->literal.bytes_left == 0)
+		return 1;
+
+	data = i_stream_get_data(conn->input, &size);
+	if (size > conn->literal.bytes_left)
+		size = conn->literal.bytes_left;
+	if (size > 0) {
+		if (write_full(conn->literal.fd, data, size) < 0) {
+			i_error("imapc(%s): write(%s) failed: %m",
+				conn->name, conn->literal.temp_path);
+			imapc_connection_disconnect(conn);
+			return -1;
+		}
+		i_stream_skip(conn->input, size);
+		conn->literal.bytes_left -= size;
+	}
+	if (conn->literal.bytes_left > 0)
+		return 0;
+
+	/* finished */
+	lfile = array_append_space(&conn->literal_files);
+	lfile->fd = conn->literal.fd;
+	lfile->parent_arg = conn->literal.parent_arg;
+	lfile->list_idx = conn->literal.list_idx;
+
+	conn->literal.fd = -1;
+	imapc_connection_literal_reset(&conn->literal);
+	return 1;
+}
+
+static int
+imapc_connection_read_line_more(struct imapc_connection *conn,
+				const struct imap_arg **imap_args_r)
+{
+	uoff_t literal_size;
+	int ret;
+
+	if ((ret = imapc_connection_read_literal(conn)) <= 0)
+		return ret;
+
+	ret = imap_parser_read_args(conn->parser, 0,
+				    IMAP_PARSE_FLAG_LITERAL_SIZE |
+				    IMAP_PARSE_FLAG_ATOM_ALLCHARS |
+				    IMAP_PARSE_FLAG_LITERAL8 |
+				    IMAP_PARSE_FLAG_SERVER_TEXT, imap_args_r);
+	if (ret == -2) {
+		/* need more data */
+		return 0;
+	}
+	if (ret < 0) {
+		enum imap_parser_error parser_error;
+		const char *err_msg = imap_parser_get_error(conn->parser, &parser_error);
+		if (parser_error != IMAP_PARSE_ERROR_BAD_SYNTAX)
+			imapc_connection_input_error(conn, "Error parsing input: %s", err_msg);
+		else
+			i_error("Error parsing input: %s", err_msg);
+		return -1;
+	}
+
+	if (imap_parser_get_literal_size(conn->parser, &literal_size)) {
+		if (imapc_connection_read_literal_init(conn, literal_size,
+						       *imap_args_r) <= 0) {
+			imap_parser_read_last_literal(conn->parser);
+			return 2;
+		}
+		return imapc_connection_read_line_more(conn, imap_args_r);
+	}
+	return 1;
+}
+
+static int
+imapc_connection_read_line(struct imapc_connection *conn,
+			   const struct imap_arg **imap_args_r)
+{
+	const unsigned char *data;
+	size_t size;
+	int ret;
+
+	while ((ret = imapc_connection_read_line_more(conn, imap_args_r)) == 2)
+		;
+
+	if (ret > 0) {
+		data = i_stream_get_data(conn->input, &size);
+		if (size >= 2 && data[0] == '\r' && data[1] == '\n')
+			i_stream_skip(conn->input, 2);
+		else if (size >= 1 && data[0] == '\n')
+			i_stream_skip(conn->input, 1);
+		else
+			i_panic("imapc: Missing LF from input line");
+	} else if (ret < 0) {
+		data = i_stream_get_data(conn->input, &size);
+		unsigned char *lf = memchr(data, '\n', size);
+		if (lf != NULL)
+			i_stream_skip(conn->input, (lf - data) + 1);
+	}
+	return ret;
+}
+
+static int
+imapc_connection_parse_capability(struct imapc_connection *conn,
+				  const char *value)
+{
+	const char *const *tmp;
+	unsigned int i;
+
+	if (conn->client->set.debug) {
+		i_debug("imapc(%s): Server capabilities: %s",
+			conn->name, value);
+	}
+
+	conn->capabilities = 0;
+	if (conn->capabilities_list != NULL)
+		p_strsplit_free(default_pool, conn->capabilities_list);
+	conn->capabilities_list = p_strsplit(default_pool, value, " ");
+
+	for (tmp = t_strsplit(value, " "); *tmp != NULL; tmp++) {
+		for (i = 0; imapc_capability_names[i].name != NULL; i++) {
+			const struct imapc_capability_name *cap =
+				&imapc_capability_names[i];
+
+			if (strcasecmp(*tmp, cap->name) == 0) {
+				conn->capabilities |= cap->capability;
+				break;
+			}
+		}
+	}
+
+	if ((conn->capabilities & IMAPC_CAPABILITY_IMAP4REV1) == 0) {
+		imapc_connection_input_error(conn,
+			"CAPABILITY list is missing IMAP4REV1");
+		return -1;
+	}
+	return 0;
+}
+
+static int
+imapc_connection_handle_resp_text_code(struct imapc_connection *conn,
+				       const char *key, const char *value)
+{
+	if (strcasecmp(key, "CAPABILITY") == 0) {
+		if (imapc_connection_parse_capability(conn, value) < 0)
+			return -1;
+	}
+	if (strcasecmp(key, "CLOSED") == 0) {
+		/* QRESYNC: SELECTing another mailbox */
+		if (conn->qresync_selecting_box != NULL) {
+			conn->selected_box = conn->qresync_selecting_box;
+			conn->qresync_selecting_box = NULL;
+		} else {
+			conn->selected_on_server = FALSE;
+		}
+	}
+	return 0;
+}
+
+static int
+imapc_connection_handle_resp_text(struct imapc_connection *conn,
+				  const char *text,
+				  const char **key_r, const char **value_r)
+{
+	const char *p, *value;
+
+	i_assert(text[0] == '[');
+
+	p = strchr(text, ']');
+	if (p == NULL) {
+		imapc_connection_input_error(conn, "Missing ']' in resp-text");
+		return -1;
+	}
+	text = t_strdup_until(text + 1, p);
+	value = strchr(text, ' ');
+	if (value != NULL) {
+		*key_r = t_strdup_until(text, value);
+		*value_r = value + 1;
+	} else {
+		*key_r = text;
+		*value_r = "";
+	}
+	return imapc_connection_handle_resp_text_code(conn, *key_r, *value_r);
+}
+
+static int
+imapc_connection_handle_imap_resp_text(struct imapc_connection *conn,
+				       const struct imap_arg *args,
+				       const char **key_r, const char **value_r)
+{
+	const char *text;
+
+	if (args->type != IMAP_ARG_ATOM)
+		return 0;
+
+	text = imap_args_to_str(args);
+	if (*text != '[') {
+		if (*text == '\0') {
+			imapc_connection_input_error(conn,
+				"Missing text in resp-text");
+			return -1;
+		}
+		return 0;
+	}
+	return imapc_connection_handle_resp_text(conn, text, key_r, value_r);
+}
+
+static bool need_literal(const char *str)
+{
+	unsigned int i;
+
+	for (i = 0; str[i] != '\0'; i++) {
+		unsigned char c = str[i];
+
+		if ((c & 0x80) != 0 || c == '\r' || c == '\n')
+			return TRUE;
+	}
+	return FALSE;
+}
+
+static void imapc_connection_input_reset(struct imapc_connection *conn)
+{
+	conn->input_state = IMAPC_INPUT_STATE_NONE;
+	conn->cur_tag = 0;
+	conn->cur_num = 0;
+	if (conn->parser != NULL)
+		imap_parser_reset(conn->parser);
+	imapc_connection_lfiles_free(conn);
+}
+
+static void
+imapc_connection_auth_finish(struct imapc_connection *conn,
+			     const struct imapc_command_reply *reply)
+{
+	if (reply->state != IMAPC_COMMAND_STATE_OK) {
+		imapc_auth_failed(conn, reply, reply->text_full);
+		imapc_connection_disconnect(conn);
+		return;
+	}
+
+	imapc_auth_ok(conn);
+
+	i_assert(array_count(&conn->cmd_wait_list) == 0);
+	timeout_remove(&conn->to);
+	imapc_connection_set_state(conn, IMAPC_CONNECTION_STATE_DONE);
+	imapc_login_callback(conn, reply);
+
+	imapc_command_send_more(conn);
+}
+
+static void imapc_connection_login_cb(const struct imapc_command_reply *reply,
+				      void *context)
+{
+	struct imapc_connection *conn = context;
+
+	imapc_connection_auth_finish(conn, reply);
+}
+
+static void
+imapc_connection_proxyauth_login_cb(const struct imapc_command_reply *reply,
+				    void *context)
+{
+	struct imapc_connection *conn = context;
+	const struct imapc_client_settings *set = &conn->client->set;
+	struct imapc_command *cmd;
+
+	if (reply->state == IMAPC_COMMAND_STATE_OK) {
+		cmd = imapc_connection_cmd(conn, imapc_connection_login_cb,
+					   conn);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+		imapc_command_sendf(cmd, "PROXYAUTH %s", set->username);
+		imapc_command_send_more(conn);
+	} else {
+		imapc_connection_auth_finish(conn, reply);
+	}
+}
+
+static void
+imapc_connection_authenticate_cb(const struct imapc_command_reply *reply,
+				 void *context)
+{
+	struct imapc_connection *conn = context;
+	const unsigned char *sasl_output;
+	size_t input_len, sasl_output_len;
+	buffer_t *buf;
+	const char *error;
+
+	if ((int)reply->state != IMAPC_COMMAND_STATE_AUTHENTICATE_CONTINUE) {
+		dsasl_client_free(&conn->sasl_client);
+		imapc_connection_auth_finish(conn, reply);
+		return;
+	}
+
+	input_len = strlen(reply->text_full);
+	buf = t_buffer_create(MAX_BASE64_DECODED_SIZE(input_len));
+	if (base64_decode(reply->text_full, input_len, NULL, buf) < 0) {
+		imapc_auth_failed(conn, reply,
+				  t_strdup_printf("Server sent non-base64 input for AUTHENTICATE: %s",
+						  reply->text_full));
+	} else if (dsasl_client_input(conn->sasl_client, buf->data, buf->used, &error) < 0) {
+		imapc_auth_failed(conn, reply, error);
+	} else if (dsasl_client_output(conn->sasl_client, &sasl_output,
+				       &sasl_output_len, &error) < 0) {
+		imapc_auth_failed(conn, reply, error);
+	} else {
+		string_t *imap_output =
+			t_str_new(MAX_BASE64_ENCODED_SIZE(sasl_output_len)+2);
+		base64_encode(sasl_output, sasl_output_len, imap_output);
+		str_append(imap_output, "\r\n");
+		o_stream_nsend(conn->output, str_data(imap_output),
+			       str_len(imap_output));
+		return;
+	}
+	imapc_connection_disconnect(conn);
+}
+
+static bool imapc_connection_have_auth(struct imapc_connection *conn,
+				       const char *mech_name)
+{
+	char *const *capa;
+
+	for (capa = conn->capabilities_list; *capa != NULL; capa++) {
+		if (strncasecmp(*capa, "AUTH=", 5) == 0 &&
+		    strcasecmp((*capa)+5, mech_name) == 0)
+			return TRUE;
+	}
+	return FALSE;
+}
+
+static int
+imapc_connection_get_sasl_mech(struct imapc_connection *conn,
+			       const struct dsasl_client_mech **mech_r,
+			       const char **error_r)
+{
+	const struct imapc_client_settings *set = &conn->client->set;
+	const char *const *mechanisms =
+		t_strsplit_spaces(set->sasl_mechanisms, ", ");
+
+	/* find one of the specified SASL mechanisms */
+	for (; *mechanisms != NULL; mechanisms++) {
+		if (imapc_connection_have_auth(conn, *mechanisms)) {
+			*mech_r = dsasl_client_mech_find(*mechanisms);
+			if (*mech_r != NULL)
+				return 0;
+
+			*error_r = t_strdup_printf(
+				"Support for SASL method '%s' is missing", *mechanisms);
+			return -1;
+		}
+	}
+	*error_r = t_strdup_printf("IMAP server doesn't support any of the requested SASL mechanisms: %s",
+				   set->sasl_mechanisms);
+	return -1;
+}
+
+static void imapc_connection_authenticate(struct imapc_connection *conn)
+{
+	const struct imapc_client_settings *set = &conn->client->set;
+	struct imapc_command *cmd;
+	struct dsasl_client_settings sasl_set;
+	const struct dsasl_client_mech *sasl_mech = NULL;
+	const char *error;
+
+	if (conn->client->set.debug) {
+		if (set->master_user == NULL) {
+			i_debug("imapc(%s): Authenticating as %s",
+				conn->name, set->username);
+		} else {
+			i_debug("imapc(%s): Authenticating as %s for user %s",
+				conn->name, set->master_user, set->username);
+		}
+	}
+
+	if (set->sasl_mechanisms != NULL && set->sasl_mechanisms[0] != '\0') {
+		if (imapc_connection_get_sasl_mech(conn, &sasl_mech, &error) < 0) {
+			struct imapc_command_reply reply;
+			i_zero(&reply);
+			reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
+			reply.text_full = "";
+			imapc_auth_failed(conn, &reply, error);
+			imapc_connection_disconnect(conn);
+			return;
+		}
+	}
+
+	if (set->use_proxyauth && set->master_user != NULL) {
+		/* We can use LOGIN command */
+		cmd = imapc_connection_cmd(conn, imapc_connection_proxyauth_login_cb,
+					   conn);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+		imapc_command_sendf(cmd, "LOGIN %s %s",
+				    set->master_user, set->password);
+		return;
+	}
+	if (sasl_mech == NULL &&
+	    ((set->master_user == NULL &&
+	      !need_literal(set->username) && !need_literal(set->password)) ||
+	     (conn->capabilities & IMAPC_CAPABILITY_AUTH_PLAIN) == 0)) {
+		/* We can use LOGIN command */
+		cmd = imapc_connection_cmd(conn, imapc_connection_login_cb,
+					   conn);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+		imapc_command_sendf(cmd, "LOGIN %s %s",
+				    set->username, set->password);
+		return;
+	}
+
+	i_zero(&sasl_set);
+	if (set->master_user == NULL)
+		sasl_set.authid = set->username;
+	else {
+		sasl_set.authid = set->master_user;
+		sasl_set.authzid = set->username;
+	}
+	sasl_set.password = set->password;
+
+	if (sasl_mech == NULL)
+		sasl_mech = &dsasl_client_mech_plain;
+	conn->sasl_client = dsasl_client_new(sasl_mech, &sasl_set);
+
+	cmd = imapc_connection_cmd(conn, imapc_connection_authenticate_cb, conn);
+	cmd->authenticate = TRUE;
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+
+	if ((conn->capabilities & IMAPC_CAPABILITY_SASL_IR) != 0) {
+		const unsigned char *sasl_output;
+		size_t sasl_output_len;
+		string_t *sasl_output_base64;
+		const char *error;
+
+		if (dsasl_client_output(conn->sasl_client, &sasl_output,
+					&sasl_output_len, &error) < 0) {
+			i_error("imapc(%s): Failed to create initial SASL reply: %s",
+				conn->name, error);
+			imapc_connection_disconnect(conn);
+			return;
+		}
+		sasl_output_base64 = t_str_new(MAX_BASE64_ENCODED_SIZE(sasl_output_len));
+		base64_encode(sasl_output, sasl_output_len, sasl_output_base64);
+
+		imapc_command_sendf(cmd, "AUTHENTICATE %1s %1s",
+				    dsasl_client_mech_get_name(sasl_mech),
+				    str_c(sasl_output_base64));
+	} else {
+		imapc_command_sendf(cmd, "AUTHENTICATE %1s",
+				    dsasl_client_mech_get_name(sasl_mech));
+	}
+}
+
+static void
+imapc_connection_starttls_cb(const struct imapc_command_reply *reply,
+			     void *context)
+{
+	struct imapc_connection *conn = context;
+	struct imapc_command *cmd;
+
+	if (reply->state != IMAPC_COMMAND_STATE_OK) {
+		imapc_connection_input_error(conn, "STARTTLS failed: %s",
+					     reply->text_full);
+		return;
+	}
+
+	if (imapc_connection_ssl_init(conn) < 0)
+		imapc_connection_disconnect(conn);
+	else {
+		/* get updated capabilities */
+		cmd = imapc_connection_cmd(conn, imapc_connection_capability_cb,
+					   conn);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+		imapc_command_send(cmd, "CAPABILITY");
+	}
+}
+
+static void
+imapc_connection_id_callback(const struct imapc_command_reply *reply ATTR_UNUSED,
+			     void *context ATTR_UNUSED)
+{
+}
+
+static void imapc_connection_send_id(struct imapc_connection *conn)
+{
+	static unsigned int global_id_counter = 0;
+	struct imapc_command *cmd;
+
+	if ((conn->capabilities & IMAPC_CAPABILITY_ID) == 0 ||
+	    conn->client->set.session_id_prefix == NULL)
+		return;
+
+	cmd = imapc_connection_cmd(conn, imapc_connection_id_callback, conn);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+	imapc_command_send(cmd, t_strdup_printf(
+		"ID (\"name\" \"Dovecot\" \"x-session-ext-id\" \"%s-%u\")",
+		conn->client->set.session_id_prefix, ++global_id_counter));
+}
+
+static void imapc_connection_starttls(struct imapc_connection *conn)
+{
+	struct imapc_command *cmd;
+
+	if (conn->client->set.ssl_mode == IMAPC_CLIENT_SSL_MODE_STARTTLS &&
+	    conn->ssl_iostream == NULL) {
+		if ((conn->capabilities & IMAPC_CAPABILITY_STARTTLS) == 0) {
+			i_error("imapc(%s): Requested STARTTLS, "
+				"but server doesn't support it",
+				conn->name);
+			imapc_connection_disconnect(conn);
+			return;
+		}
+		cmd = imapc_connection_cmd(conn, imapc_connection_starttls_cb,
+					   conn);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+		imapc_command_send(cmd, "STARTTLS");
+		return;
+	}
+	imapc_connection_send_id(conn);
+	imapc_connection_authenticate(conn);
+}
+
+static void
+imapc_connection_capability_cb(const struct imapc_command_reply *reply,
+			       void *context)
+{
+	struct imapc_connection *conn = context;
+
+	if (reply->state != IMAPC_COMMAND_STATE_OK) {
+		imapc_connection_input_error(conn,
+			"Failed to get capabilities: %s", reply->text_full);
+	} else if (conn->capabilities == 0) {
+		imapc_connection_input_error(conn,
+			"Capabilities not returned by server");
+	} else {
+		imapc_connection_starttls(conn);
+	}
+}
+
+static int imapc_connection_input_banner(struct imapc_connection *conn)
+{
+	const struct imap_arg *imap_args;
+	const char *key, *value;
+	struct imapc_command *cmd;
+	int ret;
+
+	if ((ret = imapc_connection_read_line(conn, &imap_args)) <= 0)
+		return ret;
+	/* we already verified that the banner beigns with OK */
+	i_assert(imap_arg_atom_equals(imap_args, "OK"));
+	imap_args++;
+
+	if (imapc_connection_handle_imap_resp_text(conn, imap_args,
+						   &key, &value) < 0)
+		return -1;
+	imapc_connection_set_state(conn, IMAPC_CONNECTION_STATE_AUTHENTICATING);
+
+	if (conn->capabilities == 0) {
+		/* capabilities weren't sent in the banner. ask for them. */
+		cmd = imapc_connection_cmd(conn, imapc_connection_capability_cb,
+					   conn);
+		imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_PRELOGIN);
+		imapc_command_send(cmd, "CAPABILITY");
+	} else {
+		imapc_connection_starttls(conn);
+	}
+	conn->input_callback = NULL;
+	imapc_connection_input_reset(conn);
+	return 1;
+}
+
+static int imapc_connection_input_untagged(struct imapc_connection *conn)
+{
+	const struct imap_arg *imap_args;
+	const unsigned char *data;
+	size_t size;
+	const char *name, *value;
+	struct imap_parser *parser;
+	struct imapc_untagged_reply reply;
+	int ret;
+
+	if (conn->state == IMAPC_CONNECTION_STATE_CONNECTING) {
+		/* input banner */
+		data = i_stream_get_data(conn->input, &size);
+		if (size < 3 && memchr(data, '\n', size) == NULL)
+			return 0;
+		if (i_memcasecmp(data, "OK ", 3) != 0) {
+			imapc_connection_input_error(conn,
+				"Banner doesn't begin with OK: %s",
+				t_strcut(t_strndup(data, size), '\n'));
+			return -1;
+		}
+		conn->input_callback = imapc_connection_input_banner;
+		return 1;
+	}
+
+	if ((ret = imapc_connection_read_line(conn, &imap_args)) == 0)
+		return 0;
+	else if (ret < 0) {
+		imapc_connection_input_reset(conn);
+		return 1;
+	}
+	if (!imap_arg_get_atom(&imap_args[0], &name)) {
+		imapc_connection_input_error(conn, "Invalid untagged reply");
+		return -1;
+	}
+	imap_args++;
+
+	if (conn->input_state == IMAPC_INPUT_STATE_UNTAGGED &&
+	    str_to_uint32(name, &conn->cur_num) == 0) {
+		/* <seq> <event> */
+		conn->input_state = IMAPC_INPUT_STATE_UNTAGGED_NUM;
+		if (!imap_arg_get_atom(&imap_args[0], &name)) {
+			imapc_connection_input_error(conn,
+						     "Invalid untagged reply");
+			return -1;
+		}
+		imap_args++;
+	}
+	i_zero(&reply);
+
+	if (strcasecmp(name, "OK") == 0) {
+		if (imapc_connection_handle_imap_resp_text(conn, imap_args,
+						&reply.resp_text_key,
+						&reply.resp_text_value) < 0)
+			return -1;
+	} else if (strcasecmp(name, "CAPABILITY") == 0) {
+		value = imap_args_to_str(imap_args);
+		if (imapc_connection_parse_capability(conn, value) < 0)
+			return -1;
+	} else if (strcasecmp(name, "BYE") == 0) {
+		i_free(conn->disconnect_reason);
+		conn->disconnect_reason = i_strdup(imap_args_to_str(imap_args));
+	}
+
+	reply.name = name;
+	reply.num = conn->cur_num;
+	reply.args = imap_args;
+	reply.file_args = array_get(&conn->literal_files,
+				    &reply.file_args_count);
+
+	if (conn->selected_box != NULL) {
+		reply.untagged_box_context =
+			conn->selected_box->untagged_box_context;
+	}
+
+	/* the callback may disconnect and destroy the parser */
+	parser = conn->parser;
+	imap_parser_ref(parser);
+	conn->client->untagged_callback(&reply, conn->client->untagged_context);
+	imap_parser_unref(&parser);
+	imapc_connection_input_reset(conn);
+	return 1;
+}
+
+static int imapc_connection_input_plus(struct imapc_connection *conn)
+{
+	struct imapc_command *const *cmds;
+	unsigned int cmds_count;
+	const char *line;
+
+	if ((line = i_stream_next_line(conn->input)) == NULL)
+		return 0;
+
+	cmds = array_get(&conn->cmd_send_queue, &cmds_count);
+	if (conn->idle_plus_waiting) {
+		/* "+ idling" reply for IDLE command */
+		conn->idle_plus_waiting = FALSE;
+		conn->idling = TRUE;
+		/* no timing out while IDLEing */
+		if (conn->to != NULL && !conn->idle_stopping)
+			timeout_remove(&conn->to);
+	} else if (cmds_count > 0 && cmds[0]->wait_for_literal) {
+		/* reply for literal */
+		cmds[0]->wait_for_literal = FALSE;
+		imapc_command_send_more(conn);
+	} else {
+		cmds = array_get(&conn->cmd_wait_list, &cmds_count);
+		if (cmds_count > 0 && cmds[0]->authenticate) {
+			/* continue AUTHENTICATE */
+			struct imapc_command_reply reply;
+
+			i_zero(&reply);
+			reply.state = (enum imapc_command_state)IMAPC_COMMAND_STATE_AUTHENTICATE_CONTINUE;
+			reply.text_full = line;
+			cmds[0]->callback(&reply, cmds[0]->context);
+		} else {
+			imapc_connection_input_error(conn, "Unexpected '+': %s", line);
+			return -1;
+		}
+	}
+
+	imapc_connection_input_reset(conn);
+	return 1;
+}
+
+static void
+imapc_connection_throttle_shrink_timeout(struct imapc_connection *conn)
+{
+	if (conn->throttle_msecs <= 1)
+		conn->throttle_msecs = 0;
+	else
+		conn->throttle_msecs = conn->throttle_msecs*3 / 4;
+
+	if (conn->throttle_shrink_msecs <= conn->client->set.throttle_set.shrink_min_msecs)
+		conn->throttle_shrink_msecs = 0;
+	else
+		conn->throttle_shrink_msecs = conn->throttle_shrink_msecs*3 / 4;
+
+	timeout_remove(&conn->to_throttle_shrink);
+	if (conn->throttle_shrink_msecs > 0) {
+		conn->to_throttle_shrink =
+			timeout_add(conn->throttle_shrink_msecs,
+				    imapc_connection_throttle_shrink_timeout, conn);
+	}
+}
+
+static void
+imapc_connection_throttle(struct imapc_connection *conn,
+			  const struct imapc_command_reply *reply)
+{
+	timeout_remove(&conn->to_throttle);
+
+	/* If GMail returns [THROTTLED], start slowing down commands.
+	   Unfortunately this isn't a nice resp-text-code, but just
+	   appended at the end of the line (although we kind of support
+	   it as resp-text-code also in here if it's uppercased). */
+	if (strstr(reply->text_full, "[THROTTLED]") != NULL) {
+		if (conn->throttle_msecs == 0)
+			conn->throttle_msecs = conn->client->set.throttle_set.init_msecs;
+		else if (conn->throttle_msecs < conn->last_successful_throttle_msecs)
+			conn->throttle_msecs = conn->last_successful_throttle_msecs;
+		else {
+			conn->throttle_msecs *= 2;
+			if (conn->throttle_msecs > conn->client->set.throttle_set.max_msecs)
+				conn->throttle_msecs = conn->client->set.throttle_set.max_msecs;
+		}
+		if (conn->throttle_shrink_msecs == 0)
+			conn->throttle_shrink_msecs = conn->client->set.throttle_set.shrink_min_msecs;
+		else
+			conn->throttle_shrink_msecs *= 2;
+		if (conn->to_throttle_shrink != NULL)
+			timeout_reset(conn->to_throttle_shrink);
+	} else {
+		if (conn->throttle_shrink_msecs > 0 &&
+		    conn->to_throttle_shrink == NULL) {
+			conn->to_throttle_shrink =
+				timeout_add(conn->throttle_shrink_msecs,
+					    imapc_connection_throttle_shrink_timeout, conn);
+		}
+		conn->last_successful_throttle_msecs = conn->throttle_msecs;
+	}
+
+	if (conn->throttle_msecs > 0) {
+		conn->throttle_end_timeval = ioloop_timeval;
+		timeval_add_msecs(&conn->throttle_end_timeval,
+				  conn->throttle_msecs);
+		conn->throttle_pending = TRUE;
+	}
+}
+
+static void
+imapc_command_reply_free(struct imapc_command *cmd,
+			 const struct imapc_command_reply *reply)
+{
+	cmd->callback(reply, cmd->context);
+	imapc_command_free(cmd);
+}
+
+static int imapc_connection_input_tagged(struct imapc_connection *conn)
+{
+	struct imapc_command *const *cmds, *cmd = NULL;
+	unsigned int i, count;
+	char *line, *linep;
+	const char *p;
+	struct imapc_command_reply reply;
+
+	line = i_stream_next_line(conn->input);
+	if (line == NULL)
+		return 0;
+	/* make sure reply texts stays valid if input stream gets freed */
+	line = t_strdup_noconst(line);
+
+	i_zero(&reply);
+
+	linep = strchr(line, ' ');
+	if (linep == NULL)
+		reply.text_full = "";
+	else {
+		*linep = '\0';
+		reply.text_full = linep + 1;
+	}
+
+	if (strcasecmp(line, "ok") == 0)
+		reply.state = IMAPC_COMMAND_STATE_OK;
+	else if (strcasecmp(line, "no") == 0)
+		reply.state = IMAPC_COMMAND_STATE_NO;
+	else if (strcasecmp(line, "bad") == 0)
+		reply.state = IMAPC_COMMAND_STATE_BAD;
+	else {
+		imapc_connection_input_error(conn,
+			"Invalid state in tagged reply: %u %s %s",
+			conn->cur_tag, line, reply.text_full);
+		return -1;
+	}
+
+	if (reply.text_full[0] == '[') {
+		/* get resp-text */
+		if (imapc_connection_handle_resp_text(conn, reply.text_full,
+					&reply.resp_text_key,
+					&reply.resp_text_value) < 0)
+			return -1;
+
+		p = i_strchr_to_next(reply.text_full, ']');
+		i_assert(p != NULL);
+		reply.text_without_resp = p;
+		if (reply.text_without_resp[0] == ' ')
+			reply.text_without_resp++;
+	} else {
+		reply.text_without_resp = reply.text_full;
+	}
+	/* if we've pipelined multiple commands, handle [THROTTLED] reply
+	   from only one of them */
+	if (!conn->throttle_pending)
+		imapc_connection_throttle(conn, &reply);
+
+	/* find the command. it's either the first command in send queue
+	   (literal failed) or somewhere in wait list. */
+	cmds = array_get(&conn->cmd_send_queue, &count);
+	if (count > 0 && cmds[0]->tag == conn->cur_tag) {
+		cmd = cmds[0];
+		array_pop_front(&conn->cmd_send_queue);
+	} else {
+		cmds = array_get(&conn->cmd_wait_list, &count);
+		for (i = 0; i < count; i++) {
+			if (cmds[i]->tag == conn->cur_tag) {
+				cmd = cmds[i];
+				array_delete(&conn->cmd_wait_list, i, 1);
+				break;
+			}
+		}
+	}
+	if (array_count(&conn->cmd_wait_list) == 0 &&
+	    array_count(&conn->cmd_send_queue) == 0 &&
+	    conn->state == IMAPC_CONNECTION_STATE_DONE && conn->to != NULL)
+		timeout_remove(&conn->to);
+
+	if (cmd == NULL) {
+		if (seq_range_exists(&conn->aborted_cmd_tags, conn->cur_tag)) {
+			/* sent command was already aborted - ignore it */
+			seq_range_array_remove(&conn->aborted_cmd_tags,
+					       conn->cur_tag);
+			imapc_connection_input_reset(conn);
+			return 1;
+		}
+		imapc_connection_input_error(conn,
+			"Unknown tag in a reply: %u %s %s",
+			conn->cur_tag, line, reply.text_full);
+		return -1;
+	}
+	if ((cmd->flags & IMAPC_COMMAND_FLAG_SELECT) != 0)
+		conn->select_waiting_reply = FALSE;
+
+	if (reply.state == IMAPC_COMMAND_STATE_BAD) {
+		i_error("imapc(%s): Command '%s' failed with BAD: %u %s",
+			conn->name, imapc_command_get_readable(cmd),
+			conn->cur_tag, reply.text_full);
+		imapc_connection_disconnect(conn);
+	}
+
+	if (reply.state == IMAPC_COMMAND_STATE_NO &&
+	    (cmd->flags & IMAPC_COMMAND_FLAG_SELECT) != 0 &&
+	    conn->selected_box != NULL) {
+		/* EXAMINE/SELECT failed: mailbox is no longer selected */
+		imapc_connection_unselect(conn->selected_box, TRUE);
+	}
+
+	if (conn->reconnect_command_count > 0 &&
+	    (cmd->flags & IMAPC_COMMAND_FLAG_RECONNECTED) != 0) {
+		i_assert(conn->reconnect_command_count > 0);
+		if (--conn->reconnect_command_count == 0) {
+			/* we've received replies for all the commands started
+			   before reconnection. if we get disconnected now, we
+			   can safely reconnect without worrying about infinite
+			   reconnect loops. */
+			if (conn->selected_box != NULL)
+				conn->selected_box->reconnect_ok = TRUE;
+		}
+	}
+	if (conn->reconnect_command_count == 0) {
+		/* we've successfully received replies to some commands. */
+		conn->reconnect_ok = TRUE;
+	}
+	imapc_connection_input_reset(conn);
+	imapc_command_reply_free(cmd, &reply);
+	imapc_command_send_more(conn);
+	return 1;
+}
+
+static int imapc_connection_input_one(struct imapc_connection *conn)
+{
+	const char *tag;
+	int ret = -1;
+
+	if (conn->input_callback != NULL)
+		return conn->input_callback(conn);
+
+	switch (conn->input_state) {
+	case IMAPC_INPUT_STATE_NONE:
+		tag = imap_parser_read_word(conn->parser);
+		if (tag == NULL)
+			return 0;
+
+		if (strcmp(tag, "*") == 0) {
+			conn->input_state = IMAPC_INPUT_STATE_UNTAGGED;
+			conn->cur_num = 0;
+			ret = imapc_connection_input_untagged(conn);
+		} else if (strcmp(tag, "+") == 0) {
+			conn->input_state = IMAPC_INPUT_STATE_PLUS;
+			ret = imapc_connection_input_plus(conn);
+		} else {
+			conn->input_state = IMAPC_INPUT_STATE_TAGGED;
+			if (str_to_uint(tag, &conn->cur_tag) < 0 ||
+			    conn->cur_tag == 0) {
+				imapc_connection_input_error(conn,
+					"Invalid command tag: %s", tag);
+				ret = -1;
+			} else {
+				ret = imapc_connection_input_tagged(conn);
+			}
+		}
+		break;
+	case IMAPC_INPUT_STATE_PLUS:
+		ret = imapc_connection_input_plus(conn);
+		break;
+	case IMAPC_INPUT_STATE_UNTAGGED:
+	case IMAPC_INPUT_STATE_UNTAGGED_NUM:
+		ret = imapc_connection_input_untagged(conn);
+		break;
+	case IMAPC_INPUT_STATE_TAGGED:
+		ret = imapc_connection_input_tagged(conn);
+		break;
+	}
+	return ret;
+}
+
+static void imapc_connection_input(struct imapc_connection *conn)
+{
+	const char *errstr;
+	string_t *str;
+	ssize_t ret = 0;
+
+	/* we need to read as much as we can with SSL streams to avoid
+	   hanging */
+	imapc_connection_ref(conn);
+	while (conn->input != NULL && (ret = i_stream_read(conn->input)) > 0)
+		imapc_connection_input_pending(conn);
+
+	if (ret < 0 && conn->client->logging_out &&
+	    conn->disconnect_reason != NULL) {
+		/* expected disconnection */
+		imapc_connection_disconnect(conn);
+	} else if (ret < 0) {
+		/* disconnected or buffer full */
+		str = t_str_new(128);
+		if (conn->disconnect_reason != NULL) {
+			str_printfa(str, "Server disconnected with message: %s",
+				    conn->disconnect_reason);
+		} else if (ret == -2) {
+			str_printfa(str, "Server sent too large input "
+				    "(buffer full at %zu)",
+				    i_stream_get_data_size(conn->input));
+		} else if (conn->ssl_iostream == NULL) {
+			errstr = conn->input->stream_errno == 0 ? "EOF" :
+				i_stream_get_error(conn->input);
+			str_printfa(str, "Server disconnected unexpectedly: %s",
+				    errstr);
+		} else {
+			errstr = ssl_iostream_get_last_error(conn->ssl_iostream);
+			if (errstr == NULL) {
+				errstr = conn->input->stream_errno == 0 ? "EOF" :
+					i_stream_get_error(conn->input);
+			}
+			str_printfa(str, "Server disconnected unexpectedly: %s",
+				    errstr);
+		}
+		imapc_connection_try_reconnect(conn, str_c(str), 0, FALSE);
+	}
+	imapc_connection_unref(&conn);
+}
+
+static int imapc_connection_ssl_handshaked(const char **error_r, void *context)
+{
+	struct imapc_connection *conn = context;
+	const char *error;
+
+	if (ssl_iostream_check_cert_validity(conn->ssl_iostream,
+					     conn->client->set.host, &error) == 0) {
+		if (conn->client->set.debug) {
+			i_debug("imapc(%s): SSL handshake successful",
+				conn->name);
+		}
+		return 0;
+	} else if (conn->client->set.ssl_set.allow_invalid_cert) {
+		if (conn->client->set.debug) {
+			i_debug("imapc(%s): SSL handshake successful, "
+				"ignoring invalid certificate: %s",
+				conn->name, error);
+		}
+		return 0;
+	} else {
+		*error_r = error;
+		return -1;
+	}
+}
+
+static int imapc_connection_ssl_init(struct imapc_connection *conn)
+{
+	const char *error;
+
+	if (conn->client->ssl_ctx == NULL) {
+		i_error("imapc(%s): No SSL context", conn->name);
+		return -1;
+	}
+
+	if (conn->client->set.debug)
+		i_debug("imapc(%s): Starting SSL handshake", conn->name);
+
+	if (conn->raw_input != conn->input) {
+		/* recreate rawlog after STARTTLS */
+		i_stream_ref(conn->raw_input);
+		o_stream_ref(conn->raw_output);
+		i_stream_destroy(&conn->input);
+		o_stream_destroy(&conn->output);
+		conn->input = conn->raw_input;
+		conn->output = conn->raw_output;
+	}
+
+	io_remove(&conn->io);
+	if (io_stream_create_ssl_client(conn->client->ssl_ctx,
+					conn->client->set.host,
+					&conn->client->set.ssl_set,
+					&conn->input, &conn->output,
+					&conn->ssl_iostream, &error) < 0) {
+		i_error("imapc(%s): Couldn't initialize SSL client: %s",
+			conn->name, error);
+		return -1;
+	}
+	conn->io = io_add_istream(conn->input, imapc_connection_input, conn);
+	ssl_iostream_set_handshake_callback(conn->ssl_iostream,
+					    imapc_connection_ssl_handshaked,
+					    conn);
+	if (ssl_iostream_handshake(conn->ssl_iostream) < 0) {
+		i_error("imapc(%s): SSL handshake failed: %s", conn->name,
+			ssl_iostream_get_last_error(conn->ssl_iostream));
+		return -1;
+	}
+
+	if (*conn->client->set.rawlog_dir != '\0') {
+		iostream_rawlog_create(conn->client->set.rawlog_dir,
+				       &conn->input, &conn->output);
+	}
+
+	imap_parser_set_streams(conn->parser, conn->input, NULL);
+	return 0;
+}
+
+static int imapc_connection_connected(struct imapc_connection *conn)
+{
+	const struct ip_addr *ip = &conn->ips[conn->prev_connect_idx];
+	struct ip_addr local_ip;
+	in_port_t local_port;
+	int err;
+
+	i_assert(conn->io == NULL);
+
+	err = net_geterror(conn->fd);
+	if (err != 0) {
+		imapc_connection_try_reconnect(conn, t_strdup_printf(
+			"connect(%s, %u) failed: %s",
+			net_ip2addr(ip), conn->client->set.port,
+			strerror(err)), conn->client->set.connect_retry_interval_msecs, TRUE);
+		return -1;
+	}
+	if (net_getsockname(conn->fd, &local_ip, &local_port) < 0)
+		local_port = 0;
+	i_info("imapc(%s): Connected to %s:%u (local %s:%u)", conn->name,
+	       net_ip2addr(ip), conn->client->set.port,
+	       net_ip2addr(&local_ip), local_port);
+	conn->io = io_add(conn->fd, IO_READ, imapc_connection_input, conn);
+	o_stream_set_flush_callback(conn->output, imapc_connection_output,
+				    conn);
+
+	if (conn->client->set.ssl_mode == IMAPC_CLIENT_SSL_MODE_IMMEDIATE) {
+		if (imapc_connection_ssl_init(conn) < 0)
+			imapc_connection_disconnect(conn);
+	}
+	return imapc_connection_output(conn);
+}
+
+static void imapc_connection_timeout(struct imapc_connection *conn)
+{
+	const struct ip_addr *ip = &conn->ips[conn->prev_connect_idx];
+	const char *errstr;
+	bool connect_error = FALSE;
+
+	switch (conn->state) {
+	case IMAPC_CONNECTION_STATE_CONNECTING:
+		errstr = t_strdup_printf("connect(%s, %u) timed out after %u seconds",
+			net_ip2addr(ip), conn->client->set.port,
+			conn->client->set.connect_timeout_msecs/1000);
+		connect_error = TRUE;
+		break;
+	case IMAPC_CONNECTION_STATE_AUTHENTICATING:
+		errstr = t_strdup_printf("Authentication timed out after %u seconds",
+			conn->client->set.connect_timeout_msecs/1000);
+		break;
+	default:
+		i_unreached();
+	}
+	imapc_connection_try_reconnect(conn, errstr, 0, connect_error);
+}
+
+static void
+imapc_noop_callback(const struct imapc_command_reply *reply ATTR_UNUSED,
+		    void *context ATTR_UNUSED)
+{
+}
+
+static void
+imapc_reidle_callback(const struct imapc_command_reply *reply ATTR_UNUSED,
+		      void *context)
+{
+	struct imapc_connection *conn = context;
+
+	imapc_connection_idle(conn);
+}
+
+static void imapc_connection_reset_idle(struct imapc_connection *conn)
+{
+	struct imapc_command *cmd;
+
+	if (conn->idling)
+		cmd = imapc_connection_cmd(conn, imapc_reidle_callback, conn);
+	else if (array_count(&conn->cmd_wait_list) == 0)
+		cmd = imapc_connection_cmd(conn, imapc_noop_callback, NULL);
+	else {
+		/* IMAP command reply is taking a long time */
+		return;
+	}
+	imapc_command_send(cmd, "NOOP");
+}
+
+static void imapc_connection_connect_next_ip(struct imapc_connection *conn)
+{
+	const struct ip_addr *ip = NULL;
+	unsigned int i;
+	int fd;
+
+	i_assert(conn->client->set.max_idle_time > 0);
+
+	for (i = 0; i<conn->ips_count;) {
+		conn->prev_connect_idx = (conn->prev_connect_idx+1) % conn->ips_count;
+		ip = &conn->ips[conn->prev_connect_idx];
+		fd = net_connect_ip(ip, conn->client->set.port, NULL);
+		if (fd != -1)
+			break;
+
+		/* failed to connect to one of the IPs immediately
+		   (e.g. IPv6 address without connectivity). try all IPs
+		   before failing completely. */
+		i_error("net_connect_ip(%s:%u) failed: %m",
+			net_ip2addr(ip), conn->client->set.port);
+		if (conn->prev_connect_idx+1 == conn->ips_count) {
+			imapc_connection_try_reconnect(conn, "No more IP address(es) to try",
+				conn->client->set.connect_retry_interval_msecs, TRUE);
+			return;
+		}
+	}
+
+	i_assert(ip != NULL);
+
+	conn->fd = fd;
+	conn->input = conn->raw_input =
+		i_stream_create_fd(fd, conn->client->set.max_line_length);
+	conn->output = conn->raw_output = o_stream_create_fd(fd, SIZE_MAX);
+	o_stream_set_no_error_handling(conn->output, TRUE);
+
+	if (*conn->client->set.rawlog_dir != '\0' &&
+	    conn->client->set.ssl_mode != IMAPC_CLIENT_SSL_MODE_IMMEDIATE) {
+		iostream_rawlog_create(conn->client->set.rawlog_dir,
+				       &conn->input, &conn->output);
+	}
+
+	o_stream_set_flush_pending(conn->output, TRUE);
+	o_stream_set_flush_callback(conn->output, imapc_connection_connected,
+				    conn);
+	conn->parser = imap_parser_create(conn->input, NULL,
+					  conn->client->set.max_line_length);
+	conn->to = timeout_add(conn->client->set.connect_timeout_msecs,
+			       imapc_connection_timeout, conn);
+	conn->to_output = timeout_add(conn->client->set.max_idle_time*1000,
+				      imapc_connection_reset_idle, conn);
+	if (conn->client->set.debug) {
+		i_debug("imapc(%s): Connecting to %s:%u", conn->name,
+			net_ip2addr(ip), conn->client->set.port);
+	}
+}
+
+static void
+imapc_connection_dns_callback(const struct dns_lookup_result *result,
+			      struct imapc_connection *conn)
+{
+	conn->dns_lookup = NULL;
+
+	if (result->ret != 0) {
+		i_error("imapc(%s): dns_lookup(%s) failed: %s",
+			conn->name, conn->client->set.host, result->error);
+		imapc_connection_set_disconnected(conn);
+		return;
+	}
+
+	i_assert(result->ips_count > 0);
+	conn->ips_count = result->ips_count;
+	conn->ips = i_new(struct ip_addr, conn->ips_count);
+	memcpy(conn->ips, result->ips, sizeof(*conn->ips) * conn->ips_count);
+	conn->prev_connect_idx = conn->ips_count - 1;
+
+	imapc_connection_connect_next_ip(conn);
+}
+
+void imapc_connection_connect(struct imapc_connection *conn)
+{
+	struct dns_lookup_settings dns_set;
+	struct ip_addr ip, *ips;
+	unsigned int ips_count;
+	int ret;
+
+	if (conn->fd != -1 || conn->dns_lookup != NULL)
+		return;
+	if (conn->reconnect_waiting) {
+		/* wait for the reconnection delay to finish before
+		   doing anything. */
+		return;
+	}
+
+	conn->reconnecting = FALSE;
+	/* if we get disconnected before we've finished all the pending
+	   commands, don't reconnect */
+	conn->reconnect_command_count = array_count(&conn->cmd_wait_list) +
+		array_count(&conn->cmd_send_queue);
+
+	imapc_connection_input_reset(conn);
+	conn->last_connect = ioloop_timeval;
+
+	if (conn->client->set.debug) {
+		i_debug("imapc(%s): Looking up IP address "
+			"(reconnect_ok=%s, last_connect=%ld)", conn->name,
+			(conn->reconnect_ok ? "true" : "false"),
+			(long)conn->last_connect.tv_sec);
+	}
+
+	i_zero(&dns_set);
+	dns_set.dns_client_socket_path =
+		conn->client->set.dns_client_socket_path;
+	dns_set.timeout_msecs = conn->client->set.connect_timeout_msecs;
+	dns_set.event_parent = conn->client->event;
+
+	imapc_connection_set_state(conn, IMAPC_CONNECTION_STATE_CONNECTING);
+	if (conn->ips_count > 0) {
+		/* do nothing */
+	} else if (net_addr2ip(conn->client->set.host, &ip) == 0) {
+		conn->ips_count = 1;
+		conn->ips = i_new(struct ip_addr, conn->ips_count);
+		conn->ips[0] = ip;
+	} else if (*dns_set.dns_client_socket_path == '\0') {
+		ret = net_gethostbyname(conn->client->set.host,
+					&ips, &ips_count);
+		if (ret != 0) {
+			i_error("imapc(%s): net_gethostbyname(%s) failed: %s",
+				conn->name, conn->client->set.host,
+				net_gethosterror(ret));
+			imapc_connection_set_disconnected(conn);
+			return;
+		}
+		conn->ips_count = ips_count;
+		conn->ips = i_new(struct ip_addr, ips_count);
+		memcpy(conn->ips, ips, ips_count * sizeof(*ips));
+	} else {
+		(void)dns_lookup(conn->client->set.host, &dns_set,
+				 imapc_connection_dns_callback, conn,
+				 &conn->dns_lookup);
+		return;
+	}
+	imapc_connection_connect_next_ip(conn);
+}
+
+void imapc_connection_input_pending(struct imapc_connection *conn)
+{
+	int ret = 1;
+
+	if (conn->input == NULL)
+		return;
+
+	if (conn->to != NULL && !conn->idle_stopping)
+		timeout_reset(conn->to);
+
+	o_stream_cork(conn->output);
+	while (ret > 0 && conn->input != NULL) {
+		T_BEGIN {
+			ret = imapc_connection_input_one(conn);
+		} T_END;
+	}
+
+	if (conn->output != NULL)
+		o_stream_uncork(conn->output);
+}
+
+static struct imapc_command *
+imapc_command_begin(imapc_command_callback_t *callback, void *context)
+{
+	struct imapc_command *cmd;
+	pool_t pool;
+
+	i_assert(callback != NULL);
+
+	pool = pool_alloconly_create("imapc command", 2048);
+	cmd = p_new(pool, struct imapc_command, 1);
+	cmd->pool = pool;
+	cmd->callback = callback;
+	cmd->context = context;
+
+	/* use a globally unique tag counter so looking at rawlogs is
+	   somewhat easier */
+	if (++imapc_client_cmd_tag_counter == 0)
+		imapc_client_cmd_tag_counter++;
+	cmd->tag = imapc_client_cmd_tag_counter;
+	return cmd;
+}
+
+static void imapc_command_free(struct imapc_command *cmd)
+{
+	struct imapc_command_stream *stream;
+
+	if (array_is_created(&cmd->streams)) {
+		array_foreach_modifiable(&cmd->streams, stream)
+			i_stream_unref(&stream->input);
+	}
+	pool_unref(&cmd->pool);
+}
+
+const char *imapc_command_get_tag(struct imapc_command *cmd)
+{
+	return t_strdup_printf("%u", cmd->tag);
+}
+
+void imapc_command_abort(struct imapc_command **_cmd)
+{
+	struct imapc_command *cmd = *_cmd;
+
+	*_cmd = NULL;
+	imapc_command_free(cmd);
+}
+
+static void imapc_command_timeout(struct imapc_connection *conn)
+{
+	struct imapc_command *const *cmds;
+	unsigned int count;
+
+	cmds = array_get(&conn->cmd_wait_list, &count);
+	i_assert(count > 0);
+
+	imapc_connection_try_reconnect(conn, t_strdup_printf(
+		"Command '%s' timed out", imapc_command_get_readable(cmds[0])), 0, FALSE);
+}
+
+static bool
+parse_sync_literal(const unsigned char *data, unsigned int pos,
+		   unsigned int *value_r)
+{
+	unsigned int value = 0, mul = 1;
+
+	/* data should contain "{size}\r\n" and pos points after \n */
+	if (pos <= 4 || data[pos-1] != '\n' || data[pos-2] != '\r' ||
+	    data[pos-3] != '}' || !i_isdigit(data[pos-4]))
+		return FALSE;
+	pos -= 4;
+
+	do {
+		value += (data[pos] - '0') * mul;
+		mul = mul*10;
+		pos--;
+	} while (pos > 0 && i_isdigit(data[pos]));
+
+	if (pos == 0 || data[pos] != '{')
+		return FALSE;
+
+	*value_r = value;
+	return TRUE;
+}
+
+static void imapc_command_send_finished(struct imapc_connection *conn,
+					struct imapc_command *cmd)
+{
+	struct imapc_command *const *cmdp;
+
+	i_assert(conn->to != NULL);
+
+	if (cmd->idle)
+		conn->idle_plus_waiting = TRUE;
+	cmd->sent = TRUE;
+
+	/* everything sent. move command to wait list. */
+	cmdp = array_front(&conn->cmd_send_queue);
+	i_assert(*cmdp == cmd);
+	array_pop_front(&conn->cmd_send_queue);
+	array_push_back(&conn->cmd_wait_list, &cmd);
+
+	/* send the next command in queue */
+	imapc_command_send_more(conn);
+}
+
+static struct imapc_command_stream *
+imapc_command_get_sending_stream(struct imapc_command *cmd)
+{
+	struct imapc_command_stream *stream;
+
+	if (!array_is_created(&cmd->streams) || array_count(&cmd->streams) == 0)
+		return NULL;
+
+	stream = array_front_modifiable(&cmd->streams);
+	if (stream->pos != cmd->send_pos)
+		return NULL;
+	return stream;
+}
+
+static int imapc_command_try_send_stream(struct imapc_connection *conn,
+					 struct imapc_command *cmd)
+{
+	struct imapc_command_stream *stream;
+	enum ostream_send_istream_result res;
+
+	stream = imapc_command_get_sending_stream(cmd);
+	if (stream == NULL)
+		return -2;
+
+	/* we're sending the stream now */
+	o_stream_set_max_buffer_size(conn->output, 0);
+	res = o_stream_send_istream(conn->output, stream->input);
+	o_stream_set_max_buffer_size(conn->output, SIZE_MAX);
+
+	switch (res) {
+	case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
+		break;
+	case OSTREAM_SEND_ISTREAM_RESULT_WAIT_INPUT:
+		i_unreached();
+	case OSTREAM_SEND_ISTREAM_RESULT_WAIT_OUTPUT:
+		i_assert(stream->input->v_offset < stream->size);
+		return 0;
+	case OSTREAM_SEND_ISTREAM_RESULT_ERROR_INPUT:
+		i_error("imapc: read(%s) failed: %s",
+			i_stream_get_name(stream->input),
+			i_stream_get_error(stream->input));
+		return -1;
+	case OSTREAM_SEND_ISTREAM_RESULT_ERROR_OUTPUT:
+		/* disconnected */
+		return -1;
+	}
+	i_assert(stream->input->v_offset == stream->size);
+
+	/* finished with the stream */
+	i_stream_unref(&stream->input);
+	array_pop_front(&cmd->streams);
+
+	i_assert(cmd->send_pos != cmd->data->used);
+	return 1;
+}
+
+static void imapc_connection_set_selecting(struct imapc_client_mailbox *box)
+{
+	struct imapc_connection *conn = box->conn;
+
+	i_assert(conn->qresync_selecting_box == NULL);
+
+	if (conn->selected_on_server &&
+	    (conn->capabilities & IMAPC_CAPABILITY_QRESYNC) != 0) {
+		/* server will send a [CLOSED] once selected mailbox is
+		   closed */
+		conn->qresync_selecting_box = box;
+	} else {
+		/* we'll have to assume that all the future untagged messages
+		   are for the mailbox we're selecting */
+		conn->selected_box = box;
+		conn->selected_on_server = TRUE;
+	}
+	conn->select_waiting_reply = TRUE;
+}
+
+static bool imapc_connection_is_throttled(struct imapc_connection *conn)
+{
+	timeout_remove(&conn->to_throttle);
+
+	if (conn->throttle_msecs == 0) {
+		/* we haven't received [THROTTLED] recently */
+		return FALSE;
+	}
+	if (array_count(&conn->cmd_wait_list) > 0) {
+		/* wait until we have received the existing commands' tagged
+		   replies to see if we're still throttled */
+		return TRUE;
+	}
+	if (timeval_cmp(&ioloop_timeval, &conn->throttle_end_timeval) >= 0) {
+		/* we reached the throttle timeout - send the next command */
+		conn->throttle_pending = FALSE;
+		return FALSE;
+	}
+
+	/* we're still being throttled - wait for it to end */
+	conn->to_throttle = timeout_add_absolute(&conn->throttle_end_timeval,
+						 imapc_command_send_more, conn);
+	return TRUE;
+}
+
+static void imapc_command_send_more(struct imapc_connection *conn)
+{
+	struct imapc_command *const *cmds, *cmd;
+	struct imapc_command_reply reply;
+	const unsigned char *p, *data;
+	unsigned int count, size;
+	size_t seek_pos, start_pos, end_pos;
+	int ret;
+
+	if (imapc_connection_is_throttled(conn))
+		return;
+
+	cmds = array_get(&conn->cmd_send_queue, &count);
+	if (count == 0)
+		return;
+	cmd = cmds[0];
+
+	if ((cmd->flags & IMAPC_COMMAND_FLAG_PRELOGIN) == 0 &&
+	    conn->state != IMAPC_CONNECTION_STATE_DONE) {
+		/* wait until we're fully connected */
+		return;
+	}
+	if ((cmd->flags & IMAPC_COMMAND_FLAG_LOGOUT) != 0 &&
+	    array_count(&conn->cmd_wait_list) > 0) {
+		/* wait until existing commands have finished */
+		return;
+	}
+	if (conn->select_waiting_reply) {
+		/* wait for SELECT to finish */
+		return;
+	}
+	if (cmd->wait_for_literal) {
+		/* wait until we received '+' */
+		return;
+	}
+
+	i_assert(cmd->send_pos < cmd->data->used);
+
+	if (cmd->box == NULL) {
+		/* non-mailbox command */
+	} else if (cmd->send_pos == 0 &&
+		   (cmd->flags & IMAPC_COMMAND_FLAG_SELECT) != 0) {
+		/* SELECT/EXAMINE command */
+		imapc_connection_set_selecting(cmd->box);
+	} else if (!imapc_client_mailbox_is_opened(cmd->box)) {
+		if (cmd->box->reconnecting) {
+			/* wait for SELECT/EXAMINE */
+			return;
+		}
+		/* shouldn't normally happen */
+		i_zero(&reply);
+		reply.text_without_resp = reply.text_full = "Mailbox not open";
+		reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
+
+		array_pop_front(&conn->cmd_send_queue);
+		imapc_command_reply_free(cmd, &reply);
+		imapc_command_send_more(conn);
+		return;
+	}
+
+	/* add timeout for commands if there's not one yet
+	   (pre-login has its own timeout) */
+	if ((cmd->flags & IMAPC_COMMAND_FLAG_LOGOUT) != 0) {
+		/* LOGOUT has a shorter timeout */
+		timeout_remove(&conn->to);
+		conn->to = timeout_add(IMAPC_LOGOUT_TIMEOUT_MSECS,
+				       imapc_command_timeout, conn);
+	} else if (conn->to == NULL) {
+		conn->to = timeout_add(conn->client->set.cmd_timeout_msecs,
+				       imapc_command_timeout, conn);
+	}
+
+	timeout_reset(conn->to_output);
+	if ((ret = imapc_command_try_send_stream(conn, cmd)) == 0)
+		return;
+	if (ret == -1) {
+		i_zero(&reply);
+		reply.text_without_resp = reply.text_full = "Mailbox not open";
+		reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
+
+		array_pop_front(&conn->cmd_send_queue);
+		imapc_command_reply_free(cmd, &reply);
+		imapc_command_send_more(conn);
+		return;
+	}
+
+	seek_pos = cmd->send_pos;
+	if (seek_pos != 0 && ret == -2) {
+		/* skip over the literal. we can also get here from
+		   AUTHENTICATE command, which doesn't use a literal */
+		if (parse_sync_literal(cmd->data->data, seek_pos, &size)) {
+			seek_pos += size;
+			i_assert(seek_pos <= cmd->data->used);
+		}
+	}
+
+	do {
+		start_pos = seek_pos;
+		p = memchr(CONST_PTR_OFFSET(cmd->data->data, seek_pos), '\n',
+			   cmd->data->used - seek_pos);
+		i_assert(p != NULL);
+
+		seek_pos = p - (const unsigned char *)cmd->data->data + 1;
+		/* keep going for LITERAL+ command */
+	} while (start_pos + 3 < seek_pos &&
+		 p[-1] == '\r' && p[-2] == '}' && p[-3] == '+');
+	end_pos = seek_pos;
+
+	data = CONST_PTR_OFFSET(cmd->data->data, cmd->send_pos);
+	size = end_pos - cmd->send_pos;
+	o_stream_nsend(conn->output, data, size);
+	cmd->send_pos = end_pos;
+
+	if (cmd->send_pos == cmd->data->used) {
+		i_assert(!array_is_created(&cmd->streams) ||
+			 array_count(&cmd->streams) == 0);
+		imapc_command_send_finished(conn, cmd);
+	} else {
+		cmd->wait_for_literal = TRUE;
+	}
+}
+
+static void imapc_connection_send_idle_done(struct imapc_connection *conn)
+{
+	if ((conn->idling || conn->idle_plus_waiting) && !conn->idle_stopping) {
+		conn->idle_stopping = TRUE;
+		o_stream_nsend_str(conn->output, "DONE\r\n");
+		if (conn->to == NULL) {
+			conn->to = timeout_add(conn->client->set.cmd_timeout_msecs,
+					       imapc_command_timeout, conn);
+		}
+	}
+}
+
+static void imapc_connection_cmd_send(struct imapc_command *cmd)
+{
+	struct imapc_connection *conn = cmd->conn;
+	struct imapc_command *const *cmds;
+	unsigned int i, count;
+
+	imapc_connection_send_idle_done(conn);
+
+	i_assert((cmd->flags & IMAPC_COMMAND_FLAG_RECONNECTED) == 0);
+
+	if ((cmd->flags & IMAPC_COMMAND_FLAG_PRELOGIN) != 0 &&
+	    conn->state == IMAPC_CONNECTION_STATE_AUTHENTICATING) {
+		/* pre-login commands get inserted before everything else */
+		array_push_front(&conn->cmd_send_queue, &cmd);
+		imapc_command_send_more(conn);
+		return;
+	}
+
+	/* add the command just before retried commands */
+	cmds = array_get(&conn->cmd_send_queue, &count);
+	for (i = count; i > 0; i--) {
+		if ((cmds[i-1]->flags & IMAPC_COMMAND_FLAG_RECONNECTED) == 0)
+			break;
+	}
+	array_insert(&conn->cmd_send_queue, i, &cmd, 1);
+	imapc_command_send_more(conn);
+}
+
+static int imapc_connection_output(struct imapc_connection *conn)
+{
+	struct imapc_command *const *cmds;
+	unsigned int count;
+	int ret;
+
+	if (conn->to != NULL)
+		timeout_reset(conn->to);
+
+	if ((ret = o_stream_flush(conn->output)) < 0)
+		return 1;
+
+	imapc_connection_ref(conn);
+	cmds = array_get(&conn->cmd_send_queue, &count);
+	if (count > 0) {
+		if (imapc_command_get_sending_stream(cmds[0]) != NULL &&
+		    !cmds[0]->wait_for_literal) {
+			/* we're sending a stream. send more. */
+			imapc_command_send_more(conn);
+		}
+	}
+	imapc_connection_unref(&conn);
+	return ret;
+}
+
+struct imapc_command *
+imapc_connection_cmd(struct imapc_connection *conn,
+		     imapc_command_callback_t *callback, void *context)
+{
+	struct imapc_command *cmd;
+
+	cmd = imapc_command_begin(callback, context);
+	cmd->conn = conn;
+	return cmd;
+}
+
+void imapc_command_set_flags(struct imapc_command *cmd,
+			     enum imapc_command_flags flags)
+{
+	cmd->flags = flags;
+}
+
+void imapc_command_set_mailbox(struct imapc_command *cmd,
+			       struct imapc_client_mailbox *box)
+{
+	cmd->box = box;
+}
+
+bool imapc_command_connection_is_selected(struct imapc_command *cmd)
+{
+	return cmd->conn->selected_box != NULL ||
+		cmd->conn->qresync_selecting_box != NULL;
+}
+
+void imapc_command_send(struct imapc_command *cmd, const char *cmd_str)
+{
+	size_t len = strlen(cmd_str);
+
+	cmd->data = str_new(cmd->pool, 6 + len + 2);
+	str_printfa(cmd->data, "%u %s\r\n", cmd->tag, cmd_str);
+	imapc_connection_cmd_send(cmd);
+}
+
+void imapc_command_sendf(struct imapc_command *cmd, const char *cmd_fmt, ...)
+{
+	va_list args;
+
+	va_start(args, cmd_fmt);
+	imapc_command_sendvf(cmd, cmd_fmt, args);
+	va_end(args);
+}
+
+void imapc_command_sendvf(struct imapc_command *cmd,
+			  const char *cmd_fmt, va_list args)
+{
+	unsigned int i;
+
+	cmd->data = str_new(cmd->pool, 128);
+	str_printfa(cmd->data, "%u ", cmd->tag);
+
+	for (i = 0; cmd_fmt[i] != '\0'; i++) {
+		if (cmd_fmt[i] != '%') {
+			str_append_c(cmd->data, cmd_fmt[i]);
+			continue;
+		}
+
+		switch (cmd_fmt[++i]) {
+		case '\0':
+			i_unreached();
+		case 'u': {
+			unsigned int arg = va_arg(args, unsigned int);
+
+			str_printfa(cmd->data, "%u", arg);
+			break;
+		}
+		case 'p': {
+			struct istream *input = va_arg(args, struct istream *);
+			struct imapc_command_stream *s;
+			uoff_t size;
+
+			if (!array_is_created(&cmd->streams))
+				p_array_init(&cmd->streams, cmd->pool, 2);
+			if (i_stream_get_size(input, TRUE, &size) < 0)
+				size = 0;
+			str_printfa(cmd->data, "{%"PRIuUOFF_T"}\r\n", size);
+			s = array_append_space(&cmd->streams);
+			s->pos = str_len(cmd->data);
+			s->size = size;
+			s->input = input;
+			i_stream_ref(input);
+			break;
+		}
+		case 's': {
+			const char *arg = va_arg(args, const char *);
+
+			if (!need_literal(arg))
+				imap_append_quoted(cmd->data, arg);
+			else if ((cmd->conn->capabilities &
+				  IMAPC_CAPABILITY_LITERALPLUS) != 0) {
+				str_printfa(cmd->data, "{%zu+}\r\n%s",
+					    strlen(arg), arg);
+			} else {
+				str_printfa(cmd->data, "{%zu}\r\n%s",
+					    strlen(arg), arg);
+			}
+			break;
+		}
+		case '1': {
+			/* %1s - no quoting */
+			const char *arg = va_arg(args, const char *);
+
+			i++;
+			i_assert(cmd_fmt[i] == 's');
+			str_append(cmd->data, arg);
+			break;
+		}
+		}
+	}
+	str_append(cmd->data, "\r\n");
+
+	imapc_connection_cmd_send(cmd);
+}
+
+enum imapc_connection_state
+imapc_connection_get_state(struct imapc_connection *conn)
+{
+	return conn->state;
+}
+
+enum imapc_capability
+imapc_connection_get_capabilities(struct imapc_connection *conn)
+{
+	return conn->capabilities;
+}
+
+void imapc_connection_unselect(struct imapc_client_mailbox *box,
+			       bool via_tagged_reply)
+{
+	struct imapc_connection *conn = box->conn;
+
+	if (conn->select_waiting_reply) {
+		/* Mailbox closing was requested before SELECT/EXAMINE
+		   replied. The connection state is now unknown and
+		   shouldn't be used anymore. */
+		imapc_connection_disconnect(conn);
+	} else if (conn->qresync_selecting_box == NULL &&
+		   conn->selected_box == NULL) {
+		/* There is no mailbox selected currently. */
+		i_assert(!via_tagged_reply);
+	} else {
+		/* Mailbox was closed in a known state. Either due to
+		   SELECT/EXAMINE failing (via_tagged_reply) or by
+		   imapc-storage after the mailbox was already fully
+		   selected. */
+		i_assert(conn->qresync_selecting_box == box ||
+			 conn->selected_box == box);
+		conn->qresync_selecting_box = NULL;
+		conn->selected_box = NULL;
+		if (via_tagged_reply)
+			conn->selected_on_server = FALSE;
+		else {
+			/* We didn't actually send UNSELECT command, so don't
+			   touch selected_on_server state. */
+		}
+	}
+
+	imapc_connection_send_idle_done(conn);
+	imapc_connection_abort_commands(conn, box, FALSE);
+}
+
+struct imapc_client_mailbox *
+imapc_connection_get_mailbox(struct imapc_connection *conn)
+{
+	if (conn->qresync_selecting_box != NULL)
+		return conn->qresync_selecting_box;
+	return conn->selected_box;
+}
+
+static void
+imapc_connection_idle_callback(const struct imapc_command_reply *reply ATTR_UNUSED,
+			       void *context)
+{
+	struct imapc_connection *conn = context;
+
+	conn->idling = FALSE;
+	conn->idle_plus_waiting = FALSE;
+	conn->idle_stopping = FALSE;
+}
+
+void imapc_connection_idle(struct imapc_connection *conn)
+{
+	struct imapc_command *cmd;
+
+	if (array_count(&conn->cmd_send_queue) != 0 ||
+	    array_count(&conn->cmd_wait_list) != 0 ||
+	    conn->idling || conn->idle_plus_waiting ||
+	    (conn->capabilities & IMAPC_CAPABILITY_IDLE) == 0)
+		return;
+
+	cmd = imapc_connection_cmd(conn, imapc_connection_idle_callback, conn);
+	cmd->idle = TRUE;
+	imapc_command_send(cmd, "IDLE");
+}
diff --git a/src/lib-imap-client/imapc-connection.h b/src/lib-imap-client/imapc-connection.h
new file mode 100644
index 0000000..20c249e
--- /dev/null
+++ b/src/lib-imap-client/imapc-connection.h
@@ -0,0 +1,64 @@
+#ifndef IMAPC_CONNECTION_H
+#define IMAPC_CONNECTION_H
+
+#include "imapc-client.h"
+
+/* [THROTTLED] handling behavior */
+#define IMAPC_THROTTLE_DEFAULT_INIT_MSECS 50
+#define IMAPC_THROTTLE_DEFAULT_MAX_MSECS (16*1000)
+#define IMAPC_THROTTLE_DEFAULT_SHRINK_MIN_MSECS 500
+
+struct imapc_client;
+struct imapc_connection;
+
+enum imapc_connection_state {
+	/* No connection */
+	IMAPC_CONNECTION_STATE_DISCONNECTED = 0,
+	/* Trying to connect */
+	IMAPC_CONNECTION_STATE_CONNECTING,
+	/* Connected, trying to authenticate */
+	IMAPC_CONNECTION_STATE_AUTHENTICATING,
+	/* Authenticated, ready to accept commands */
+	IMAPC_CONNECTION_STATE_DONE
+};
+
+struct imapc_connection *
+imapc_connection_init(struct imapc_client *client,
+		      imapc_command_callback_t *login_callback,
+		      void *login_context);
+void imapc_connection_deinit(struct imapc_connection **conn);
+
+void imapc_connection_connect(struct imapc_connection *conn);
+void imapc_connection_set_no_reconnect(struct imapc_connection *conn);
+void imapc_connection_disconnect(struct imapc_connection *conn);
+void imapc_connection_disconnect_full(struct imapc_connection *conn,
+				      bool reconnecting);
+void imapc_connection_try_reconnect(struct imapc_connection *conn,
+				    const char *errstr,
+				    unsigned int delay_msecs,
+				    bool connect_error);
+void imapc_connection_abort_commands(struct imapc_connection *conn,
+				     struct imapc_client_mailbox *only_box,
+				     bool keep_retriable) ATTR_NULL(2);
+void imapc_connection_ioloop_changed(struct imapc_connection *conn);
+void imapc_connection_input_pending(struct imapc_connection *conn);
+
+struct imapc_command *
+imapc_connection_cmd(struct imapc_connection *conn,
+		     imapc_command_callback_t *callback, void *context)
+	ATTR_NULL(3);
+
+void imapc_connection_unselect(struct imapc_client_mailbox *box,
+			       bool via_tagged_reply);
+
+enum imapc_connection_state
+imapc_connection_get_state(struct imapc_connection *conn);
+enum imapc_capability
+imapc_connection_get_capabilities(struct imapc_connection *conn);
+
+struct imapc_client_mailbox *
+imapc_connection_get_mailbox(struct imapc_connection *conn);
+
+void imapc_connection_idle(struct imapc_connection *conn);
+
+#endif
diff --git a/src/lib-imap-client/imapc-msgmap.c b/src/lib-imap-client/imapc-msgmap.c
new file mode 100644
index 0000000..6280a24
--- /dev/null
+++ b/src/lib-imap-client/imapc-msgmap.c
@@ -0,0 +1,89 @@
+/* Copyright (c) 2011-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "array.h"
+#include "imapc-msgmap.h"
+#include "sort.h"
+
+struct imapc_msgmap {
+	ARRAY_TYPE(uint32_t) uids;
+	uint32_t uid_next;
+};
+
+struct imapc_msgmap *imapc_msgmap_init(void)
+{
+	struct imapc_msgmap *msgmap;
+
+	msgmap = i_new(struct imapc_msgmap, 1);
+	i_array_init(&msgmap->uids, 128);
+	msgmap->uid_next = 1;
+	return msgmap;
+}
+
+void imapc_msgmap_deinit(struct imapc_msgmap **_msgmap)
+{
+	struct imapc_msgmap *msgmap = *_msgmap;
+
+	*_msgmap = NULL;
+
+	array_free(&msgmap->uids);
+	i_free(msgmap);
+}
+
+uint32_t imapc_msgmap_count(struct imapc_msgmap *msgmap)
+{
+	return array_count(&msgmap->uids);
+}
+
+uint32_t imapc_msgmap_uidnext(struct imapc_msgmap *msgmap)
+{
+	return msgmap->uid_next;
+}
+
+uint32_t imapc_msgmap_rseq_to_uid(struct imapc_msgmap *msgmap, uint32_t rseq)
+{
+	const uint32_t *uidp;
+
+	uidp = array_idx(&msgmap->uids, rseq-1);
+	return *uidp;
+}
+
+bool imapc_msgmap_uid_to_rseq(struct imapc_msgmap *msgmap,
+			      uint32_t uid, uint32_t *rseq_r)
+{
+	const uint32_t *p, *first;
+
+	p = array_bsearch(&msgmap->uids, &uid, uint32_cmp);
+	if (p == NULL) {
+		*rseq_r = 0;
+		return FALSE;
+	}
+
+	first = array_front(&msgmap->uids);
+	*rseq_r = (p - first) + 1;
+	return TRUE;
+}
+
+void imapc_msgmap_append(struct imapc_msgmap *msgmap,
+			 uint32_t rseq, uint32_t uid)
+{
+	i_assert(rseq == imapc_msgmap_count(msgmap) + 1);
+	i_assert(uid >= msgmap->uid_next);
+
+	msgmap->uid_next = uid + 1;
+	array_push_back(&msgmap->uids, &uid);
+}
+
+void imapc_msgmap_expunge(struct imapc_msgmap *msgmap, uint32_t rseq)
+{
+	i_assert(rseq > 0);
+	i_assert(rseq <= imapc_msgmap_count(msgmap));
+
+	array_delete(&msgmap->uids, rseq-1, 1);
+}
+
+void imapc_msgmap_reset(struct imapc_msgmap *msgmap)
+{
+	array_clear(&msgmap->uids);
+	msgmap->uid_next = 1;
+}
diff --git a/src/lib-imap-client/imapc-msgmap.h b/src/lib-imap-client/imapc-msgmap.h
new file mode 100644
index 0000000..934bf97
--- /dev/null
+++ b/src/lib-imap-client/imapc-msgmap.h
@@ -0,0 +1,18 @@
+#ifndef IMAPC_MSGMAP_H
+#define IMAPC_MSGMAP_H
+
+struct imapc_msgmap *imapc_msgmap_init(void);
+void imapc_msgmap_deinit(struct imapc_msgmap **msgmap);
+
+uint32_t imapc_msgmap_count(struct imapc_msgmap *msgmap);
+uint32_t imapc_msgmap_uidnext(struct imapc_msgmap *msgmap);
+uint32_t imapc_msgmap_rseq_to_uid(struct imapc_msgmap *msgmap, uint32_t rseq);
+bool imapc_msgmap_uid_to_rseq(struct imapc_msgmap *msgmap,
+			      uint32_t uid, uint32_t *rseq_r);
+
+void imapc_msgmap_append(struct imapc_msgmap *msgmap,
+			 uint32_t rseq, uint32_t uid);
+void imapc_msgmap_expunge(struct imapc_msgmap *msgmap, uint32_t rseq);
+void imapc_msgmap_reset(struct imapc_msgmap *msgmap);
+
+#endif
diff --git a/src/lib-imap-client/test-imapc-client.c b/src/lib-imap-client/test-imapc-client.c
new file mode 100644
index 0000000..c8953f0
--- /dev/null
+++ b/src/lib-imap-client/test-imapc-client.c
@@ -0,0 +1,901 @@
+/* Copyright (c) 2017-2018 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "array.h"
+#include "hostpid.h"
+#include "net.h"
+#include "istream.h"
+#include "ostream.h"
+#include "ioloop.h"
+#include "unlink-directory.h"
+#include "sleep.h"
+#include "test-common.h"
+#include "test-subprocess.h"
+#include "imapc-client-private.h"
+
+#include <stdio.h>
+#include <unistd.h>
+
+#define SERVER_KILL_TIMEOUT_SECS    20
+
+#define IMAPC_COMMAND_STATE_INVALID (enum imapc_command_state)-1
+
+typedef void test_server_init_t(void);
+typedef void test_client_init_t(void);
+
+struct test_server {
+	in_port_t port;
+	pid_t pid;
+
+	int fd_listen, fd;
+	struct istream *input;
+	struct ostream *output;
+};
+
+static struct ip_addr bind_ip;
+static struct test_server server;
+static struct imapc_client *imapc_client;
+static enum imapc_command_state imapc_login_last_reply;
+static ARRAY(enum imapc_command_state) imapc_cmd_last_replies;
+static bool debug = FALSE;
+
+static void main_deinit(void);
+
+/*
+ * Test client
+ */
+
+static struct imapc_client_settings test_imapc_default_settings = {
+	.host = "127.0.0.1",
+	.username = "testuser",
+	.password = "testpass",
+
+	.dns_client_socket_path = "",
+	.temp_path_prefix = ".test-tmp/",
+	.rawlog_dir = "",
+
+	.connect_timeout_msecs = 5000,
+	.connect_retry_count = 3,
+	.connect_retry_interval_msecs = 10,
+
+	.max_idle_time = 10000,
+};
+
+static enum imapc_command_state test_imapc_cmd_last_reply_pop(void)
+{
+	const enum imapc_command_state *replies;
+	enum imapc_command_state reply;
+	unsigned int count;
+
+	replies = array_get(&imapc_cmd_last_replies, &count);
+	if (count == 0)
+		return IMAPC_COMMAND_STATE_INVALID;
+	reply = replies[0];
+	array_pop_front(&imapc_cmd_last_replies);
+	return reply;
+}
+
+static bool test_imapc_cmd_last_reply_expect(enum imapc_command_state state)
+{
+	if (array_count(&imapc_cmd_last_replies) == 0)
+		imapc_client_run(imapc_client);
+	return test_imapc_cmd_last_reply_pop() == state;
+}
+
+static void imapc_login_callback(const struct imapc_command_reply *reply,
+				 void *context ATTR_UNUSED)
+{
+	if (debug) {
+		i_debug("Login reply: %s %s",
+			imapc_command_state_names[reply->state],
+			reply->text_full);
+	}
+	imapc_login_last_reply = reply->state;
+	imapc_client_stop(imapc_client);
+}
+
+static void imapc_command_callback(const struct imapc_command_reply *reply,
+				   void *context ATTR_UNUSED)
+{
+	if (debug) {
+		i_debug("Command reply: %s %s",
+			imapc_command_state_names[reply->state],
+			reply->text_full);
+	}
+	array_push_back(&imapc_cmd_last_replies, &reply->state);
+	imapc_client_stop(imapc_client);
+}
+
+static void imapc_reopen_callback(void *context)
+{
+	struct imapc_client_mailbox *box = context;
+	struct imapc_command *cmd;
+
+	cmd = imapc_client_mailbox_cmd(box, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_SELECT);
+	imapc_command_send(cmd, "SELECT");
+}
+
+/*
+ * Test server
+ */
+
+static bool
+test_imapc_server_expect_full(struct test_server *server,
+			      const char *expected_line)
+{
+	const char *line = i_stream_read_next_line(server->input);
+
+	if (debug)
+		i_debug("Received: %s", (line == NULL ? "<EOF>" : line));
+
+	if (line == NULL) {
+		printf("imapc client disconnected unexpectedly: %s\n",
+		       i_stream_get_error(server->input));
+		return FALSE;
+	} else if (strcmp(line, expected_line) != 0) {
+		printf("imapc client sent '%s' when expecting '%s'\n",
+		       line, expected_line);
+		return FALSE;
+	} else {
+		return TRUE;
+	}
+}
+
+static bool test_imapc_server_expect(const char *expected_line)
+{
+	return test_imapc_server_expect_full(&server, expected_line);
+}
+
+static void
+test_server_wait_connection(struct test_server *server, bool send_banner)
+{
+	if (debug)
+		i_debug("Waiting for connection");
+
+	server->fd = net_accept(server->fd_listen, NULL, NULL);
+	i_assert(server->fd >= 0);
+
+	if (debug)
+		i_debug("Client connected");
+
+	fd_set_nonblock(server->fd, FALSE);
+	server->input = i_stream_create_fd(server->fd, SIZE_MAX);
+	server->output = o_stream_create_fd(server->fd, SIZE_MAX);
+	o_stream_set_no_error_handling(server->output, TRUE);
+
+	if (send_banner) {
+		o_stream_nsend_str(server->output,
+			"* OK [CAPABILITY IMAP4rev1 UNSELECT QUOTA] ready\r\n");
+	}
+}
+
+static void test_server_disconnect(struct test_server *server)
+{
+	if (debug)
+		i_debug("Disconnecting client");
+
+	i_stream_unref(&server->input);
+	o_stream_unref(&server->output);
+	i_close_fd(&server->fd);
+}
+
+static void test_server_disconnect_and_wait(bool send_banner)
+{
+	test_server_disconnect(&server);
+	test_server_wait_connection(&server, send_banner);
+}
+
+/*
+ * Test processes
+ */
+
+static int test_open_server_fd(in_port_t *bind_port)
+{
+	int fd = net_listen(&bind_ip, bind_port, 128);
+	if (debug)
+		i_debug("server listening on %u", *bind_port);
+	if (fd == -1) {
+		i_fatal("listen(%s:%u) failed: %m",
+			net_ip2addr(&bind_ip), *bind_port);
+	}
+	fd_set_nonblock(fd, FALSE);
+	return fd;
+}
+
+static int test_run_server(test_server_init_t *server_test)
+{
+	struct ioloop *ioloop;
+
+	i_set_failure_prefix("SERVER: ");
+
+	if (debug)
+		i_debug("PID=%s", my_pid);
+
+	ioloop = io_loop_create();
+	if (server_test != NULL)
+		server_test();
+	test_server_disconnect(&server);
+	io_loop_destroy(&ioloop);
+
+	if (debug)
+		i_debug("Terminated");
+
+	i_close_fd(&server.fd_listen);
+	main_deinit();
+	return 0;
+}
+
+static void
+test_run_client(const struct imapc_client_settings *client_set,
+		test_client_init_t *client_test)
+{
+	struct ioloop *ioloop;
+
+	i_set_failure_prefix("CLIENT: ");
+
+	if (debug)
+		i_debug("PID=%s", my_pid);
+
+	i_sleep_msecs(100); /* wait a little for server setup */
+
+	ioloop = io_loop_create();
+	imapc_client = imapc_client_init(client_set, NULL);
+	client_test();
+	imapc_client_logout(imapc_client);
+	test_assert(array_count(&imapc_cmd_last_replies) == 0);
+	if (imapc_client != NULL)
+		imapc_client_deinit(&imapc_client);
+	io_loop_destroy(&ioloop);
+
+	if (debug)
+		i_debug("Terminated");
+}
+
+static void
+test_run_client_server(const struct imapc_client_settings *client_set,
+		       test_client_init_t *client_test,
+		       test_server_init_t *server_test)
+{
+	struct imapc_client_settings client_set_copy = *client_set;
+	const char *error;
+
+	imapc_client_cmd_tag_counter = 0;
+	imapc_login_last_reply = IMAPC_COMMAND_STATE_INVALID;
+	t_array_init(&imapc_cmd_last_replies, 4);
+
+	i_zero(&server);
+	server.pid = (pid_t)-1;
+	server.fd = -1;
+	server.fd_listen = test_open_server_fd(&server.port);
+	client_set_copy.port = server.port;
+
+	if (mkdir(client_set->temp_path_prefix, 0700) < 0 && errno != EEXIST)
+		i_fatal("mkdir(%s) failed: %m", client_set->temp_path_prefix);
+
+	if (server_test != NULL) {
+		/* Fork server */
+		test_subprocess_fork(test_run_server, server_test, TRUE);
+	}
+	i_close_fd(&server.fd_listen);
+
+	/* Run client */
+	test_run_client(&client_set_copy, client_test);
+
+	i_unset_failure_prefix();
+	test_subprocess_kill_all(SERVER_KILL_TIMEOUT_SECS);
+	if (unlink_directory(client_set->temp_path_prefix,
+			     UNLINK_DIRECTORY_FLAG_RMDIR, &error) < 0)
+		i_fatal("%s", error);
+}
+
+/*
+ * imapc connect failed
+ */
+
+static void test_imapc_connect_failed_client(void)
+{
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	/* connection refused & one reconnect */
+	test_expect_errors(2);
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_DISCONNECTED);
+}
+
+static void test_imapc_connect_failed(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc connect failed");
+	test_run_client_server(&set, test_imapc_connect_failed_client, NULL);
+	test_end();
+}
+
+/*
+ * imapc banner hang
+ */
+
+static void test_imapc_banner_hangs_client(void)
+{
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	test_expect_errors(2);
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_DISCONNECTED);
+}
+
+static void test_imapc_banner_hangs_server(void)
+{
+	struct test_server server2 = { .fd_listen = server.fd_listen };
+
+	test_server_wait_connection(&server, FALSE);
+	test_server_wait_connection(&server2, FALSE);
+	test_assert(i_stream_read_next_line(server2.input) == NULL);
+	test_server_disconnect(&server2);
+}
+
+static void test_imapc_banner_hangs(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+	set.connect_timeout_msecs = 500;
+
+	test_begin("imapc banner hangs");
+	test_run_client_server(&set, test_imapc_banner_hangs_client,
+			       test_imapc_banner_hangs_server);
+	test_end();
+}
+
+/*
+ * imapc login hangs
+ */
+
+static void test_imapc_login_hangs_client(void)
+{
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	/* run the first login */
+	test_expect_error_string("Authentication timed out");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	/* imapc_login_callback() has stopped us. run the second reconnect
+	   login. */
+	test_expect_error_string("Authentication timed out");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_DISCONNECTED);
+}
+
+static void test_imapc_login_hangs_server(void)
+{
+	struct test_server server2 = { .fd_listen = server.fd_listen };
+
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+
+	test_server_wait_connection(&server2, TRUE);
+	test_assert(test_imapc_server_expect_full(
+		&server2, "2 LOGIN \"testuser\" \"testpass\""));
+
+	test_assert(i_stream_read_next_line(server2.input) == NULL);
+	test_server_disconnect(&server2);
+}
+
+static void test_imapc_login_hangs(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+	set.connect_timeout_msecs = 500;
+
+	test_begin("imapc login hangs");
+	test_run_client_server(&set, test_imapc_login_hangs_client,
+			       test_imapc_login_hangs_server);
+	test_end();
+}
+
+/*
+ * imapc login fails
+ */
+
+static void test_imapc_login_fails_client(void)
+{
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	test_expect_error_string("Authentication failed: Test login failed");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_AUTH_FAILED);
+}
+
+static void test_imapc_login_fails_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "1 NO Test login failed\r\n");
+}
+
+static void test_imapc_login_fails(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc login fails");
+	test_run_client_server(&set, test_imapc_login_fails_client,
+			       test_imapc_login_fails_server);
+	test_end();
+}
+
+/*
+ * imapc reconnect
+ */
+
+static void test_imapc_reconnect_client(void)
+{
+	struct imapc_command *cmd;
+
+	/* login to server */
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	imapc_client_run(imapc_client);
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_OK);
+	imapc_login_last_reply = IMAPC_COMMAND_STATE_INVALID;
+
+	/* disconnect */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_send(cmd, "DISCONNECT");
+	test_expect_error_string("reconnecting");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(test_imapc_cmd_last_reply_pop() ==
+		    IMAPC_COMMAND_STATE_DISCONNECTED);
+
+	/* we should be reconnected now. try a command. */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_send(cmd, "NOOP");
+	imapc_client_run(imapc_client);
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_INVALID);
+	test_assert(test_imapc_cmd_last_reply_pop() == IMAPC_COMMAND_STATE_OK);
+}
+
+static void test_imapc_reconnect_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "1 OK \r\n");
+
+	test_assert(test_imapc_server_expect("2 DISCONNECT"));
+	test_server_disconnect_and_wait(TRUE);
+
+	test_assert(test_imapc_server_expect(
+		"4 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "4 OK \r\n");
+	test_assert(test_imapc_server_expect("3 NOOP"));
+	o_stream_nsend_str(server.output, "3 OK \r\n");
+
+	test_assert(test_imapc_server_expect("5 LOGOUT"));
+	o_stream_nsend_str(server.output, "5 OK \r\n");
+
+	test_assert(i_stream_read_next_line(server.input) == NULL);
+}
+
+static void test_imapc_reconnect(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc reconnect");
+	test_run_client_server(&set, test_imapc_reconnect_client,
+			       test_imapc_reconnect_server);
+	test_end();
+}
+
+/*
+ * imapc reconnect resend commands
+ */
+
+static void test_imapc_reconnect_resend_cmds_client(void)
+{
+	struct imapc_command *cmd;
+
+	/* login to server */
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	imapc_client_run(imapc_client);
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_OK);
+	imapc_login_last_reply = IMAPC_COMMAND_STATE_INVALID;
+
+	/* send two commands */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_RETRIABLE);
+	imapc_command_send(cmd, "RETRY1");
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_RETRIABLE);
+	imapc_command_send(cmd, "RETRY2");
+
+	/* disconnect & reconnect automatically */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_send(cmd, "DISCONNECT");
+	test_expect_error_string("reconnecting");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(test_imapc_cmd_last_reply_expect(
+		IMAPC_COMMAND_STATE_DISCONNECTED));
+
+	/* continue reconnection */
+	test_assert(test_imapc_cmd_last_reply_expect(IMAPC_COMMAND_STATE_OK));
+	test_assert(test_imapc_cmd_last_reply_expect(IMAPC_COMMAND_STATE_OK));
+}
+
+static void test_imapc_reconnect_resend_cmds_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "1 OK \r\n");
+
+	test_assert(test_imapc_server_expect("2 RETRY1"));
+	test_assert(test_imapc_server_expect("3 RETRY2"));
+	test_assert(test_imapc_server_expect("4 DISCONNECT"));
+	test_server_disconnect_and_wait(TRUE);
+
+	test_assert(test_imapc_server_expect(
+		"5 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "5 OK \r\n");
+	test_assert(test_imapc_server_expect("2 RETRY1"));
+	o_stream_nsend_str(server.output, "2 OK \r\n");
+	test_assert(test_imapc_server_expect("3 RETRY2"));
+	o_stream_nsend_str(server.output, "3 OK \r\n");
+
+	test_assert(test_imapc_server_expect("6 LOGOUT"));
+	o_stream_nsend_str(server.output, "6 OK \r\n");
+
+	test_assert(i_stream_read_next_line(server.input) == NULL);
+}
+
+static void test_imapc_reconnect_resend_commands(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc reconnect resend commands");
+	test_run_client_server(&set, test_imapc_reconnect_resend_cmds_client,
+			       test_imapc_reconnect_resend_cmds_server);
+	test_end();
+}
+
+/*
+ * imapc reconnect resend commands failed
+ */
+
+static void test_imapc_reconnect_resend_cmds_failed_client(void)
+{
+	struct imapc_command *cmd;
+
+	/* login to server */
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	imapc_client_run(imapc_client);
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_OK);
+	imapc_login_last_reply = IMAPC_COMMAND_STATE_INVALID;
+
+	/* send two commands */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_RETRIABLE);
+	imapc_command_send(cmd, "RETRY1");
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_RETRIABLE);
+	imapc_command_send(cmd, "RETRY2");
+
+	/* disconnect & try to reconnect automatically */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_send(cmd, "DISCONNECT");
+	test_expect_error_string("reconnecting");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(test_imapc_cmd_last_reply_expect(
+		IMAPC_COMMAND_STATE_DISCONNECTED));
+	test_expect_error_string("timed out");
+	test_assert(test_imapc_cmd_last_reply_expect(
+		IMAPC_COMMAND_STATE_DISCONNECTED));
+	test_expect_no_more_errors();
+	test_assert(test_imapc_cmd_last_reply_expect(
+		IMAPC_COMMAND_STATE_DISCONNECTED));
+}
+
+static void test_imapc_reconnect_resend_cmds_failed_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "1 OK \r\n");
+
+	test_assert(test_imapc_server_expect("2 RETRY1"));
+	test_assert(test_imapc_server_expect("3 RETRY2"));
+	test_assert(test_imapc_server_expect("4 DISCONNECT"));
+	test_server_disconnect(&server);
+
+	i_sleep_intr_secs(60);
+}
+
+static void test_imapc_reconnect_resend_commands_failed(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+	set.connect_timeout_msecs = 500;
+
+	test_begin("imapc reconnect resend commands failed");
+	test_run_client_server(&set,
+			       test_imapc_reconnect_resend_cmds_failed_client,
+			       test_imapc_reconnect_resend_cmds_failed_server);
+	test_end();
+}
+
+/*
+ * imapc reconnect mailbox
+ */
+
+static void test_imapc_reconnect_mailbox_client(void)
+{
+	struct imapc_command *cmd;
+	struct imapc_client_mailbox *box;
+
+	/* login to server */
+	imapc_client_set_login_callback(imapc_client,
+					imapc_login_callback, NULL);
+	imapc_client_login(imapc_client);
+	imapc_client_run(imapc_client);
+	test_assert(imapc_login_last_reply == IMAPC_COMMAND_STATE_OK);
+	imapc_login_last_reply = IMAPC_COMMAND_STATE_INVALID;
+
+	/* select a mailbox */
+	box = imapc_client_mailbox_open(imapc_client, NULL);
+	imapc_client_mailbox_set_reopen_cb(box, imapc_reopen_callback, box);
+
+	cmd = imapc_client_mailbox_cmd(box, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_SELECT);
+	imapc_command_send(cmd, "SELECT");
+	imapc_client_run(imapc_client);
+	test_assert(test_imapc_cmd_last_reply_expect(IMAPC_COMMAND_STATE_OK));
+
+	/* send a command */
+	cmd = imapc_client_mailbox_cmd(box, imapc_command_callback, NULL);
+	imapc_command_set_flags(cmd, IMAPC_COMMAND_FLAG_RETRIABLE);
+	imapc_command_send(cmd, "RETRY");
+
+	/* disconnect & reconnect automatically */
+	cmd = imapc_client_cmd(imapc_client, imapc_command_callback, NULL);
+	imapc_command_send(cmd, "DISCONNECT");
+	test_expect_error_string("reconnecting");
+	imapc_client_run(imapc_client);
+	test_expect_no_more_errors();
+	test_assert(test_imapc_cmd_last_reply_expect(
+		IMAPC_COMMAND_STATE_DISCONNECTED));
+
+	/* continue reconnection */
+	test_assert(test_imapc_cmd_last_reply_expect(IMAPC_COMMAND_STATE_OK));
+	test_assert(test_imapc_cmd_last_reply_expect(IMAPC_COMMAND_STATE_OK));
+
+	imapc_client_mailbox_close(&box);
+}
+
+static void test_imapc_reconnect_mailbox_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "1 OK \r\n");
+
+	test_assert(test_imapc_server_expect("2 SELECT"));
+	o_stream_nsend_str(server.output, "2 OK \r\n");
+
+	test_assert(test_imapc_server_expect("3 RETRY"));
+	test_assert(test_imapc_server_expect("4 DISCONNECT"));
+	test_server_disconnect_and_wait(TRUE);
+
+	test_assert(test_imapc_server_expect(
+		"5 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "5 OK \r\n");
+	test_assert(test_imapc_server_expect("6 SELECT"));
+	o_stream_nsend_str(server.output, "6 OK \r\n");
+	test_assert(test_imapc_server_expect("3 RETRY"));
+	o_stream_nsend_str(server.output, "3 OK \r\n");
+
+	test_assert(test_imapc_server_expect("7 LOGOUT"));
+	o_stream_nsend_str(server.output, "7 OK \r\n");
+
+	test_assert(i_stream_read_next_line(server.input) == NULL);
+}
+
+static void test_imapc_reconnect_mailbox(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc reconnect mailbox");
+	test_run_client_server(&set, test_imapc_reconnect_mailbox_client,
+			       test_imapc_reconnect_mailbox_server);
+	test_end();
+}
+
+/*
+ * imapc_client_get_capabilities()
+ */
+
+static void test_imapc_client_get_capabilities_client(void)
+{
+	enum imapc_capability capabilities;
+
+	test_assert(imapc_client_get_capabilities(imapc_client, &capabilities) == 0);
+	test_assert(capabilities == (IMAPC_CAPABILITY_IMAP4REV1 |
+				     IMAPC_CAPABILITY_UNSELECT |
+				     IMAPC_CAPABILITY_QUOTA));
+}
+
+static void test_imapc_client_get_capabilities_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_assert(test_imapc_server_expect(
+		"1 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "1 OK \r\n");
+
+	test_assert(test_imapc_server_expect("2 LOGOUT"));
+	o_stream_nsend_str(server.output, "2 OK \r\n");
+
+	test_assert(i_stream_read_next_line(server.input) == NULL);
+}
+
+static void test_imapc_client_get_capabilities(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc_client_get_capabilities()");
+	test_run_client_server(&set, test_imapc_client_get_capabilities_client,
+			       test_imapc_client_get_capabilities_server);
+	test_end();
+}
+
+/*
+ * imapc_client_get_capabilities() reconnected
+ */
+
+static void test_imapc_client_get_capabilities_reconnected_client(void)
+{
+	enum imapc_capability capabilities;
+
+	test_expect_error_string("Server disconnected unexpectedly");
+	test_assert(imapc_client_get_capabilities(imapc_client,
+						  &capabilities) == 0);
+	test_assert(capabilities == (IMAPC_CAPABILITY_IMAP4REV1 |
+				     IMAPC_CAPABILITY_UNSELECT |
+				     IMAPC_CAPABILITY_QUOTA));
+	test_expect_no_more_errors();
+}
+
+static void test_imapc_client_get_capabilities_reconnected_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_server_disconnect_and_wait(TRUE);
+
+	test_assert(test_imapc_server_expect(
+		"2 LOGIN \"testuser\" \"testpass\""));
+	o_stream_nsend_str(server.output, "2 OK \r\n");
+
+	test_assert(test_imapc_server_expect("3 LOGOUT"));
+	o_stream_nsend_str(server.output, "3 OK \r\n");
+
+	test_assert(i_stream_read_next_line(server.input) == NULL);
+}
+
+static void test_imapc_client_get_capabilities_reconnected(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc_client_get_capabilities() reconnected");
+
+	test_run_client_server(
+		&set, test_imapc_client_get_capabilities_reconnected_client,
+		test_imapc_client_get_capabilities_reconnected_server);
+	test_end();
+}
+
+/*
+ * imapc_client_get_capabilities() disconnected
+ */
+
+static void test_imapc_client_get_capabilities_disconnected_client(void)
+{
+	enum imapc_capability capabilities;
+
+	test_expect_errors(2);
+	test_assert(imapc_client_get_capabilities(imapc_client,
+						  &capabilities) < 0);
+	test_expect_no_more_errors();
+}
+
+static void test_imapc_client_get_capabilities_disconnected_server(void)
+{
+	test_server_wait_connection(&server, TRUE);
+	test_server_disconnect_and_wait(TRUE);
+}
+
+static void test_imapc_client_get_capabilities_disconnected(void)
+{
+	struct imapc_client_settings set = test_imapc_default_settings;
+
+	test_begin("imapc_client_get_capabilities() disconnected");
+
+	test_run_client_server(
+		&set, test_imapc_client_get_capabilities_disconnected_client,
+		test_imapc_client_get_capabilities_disconnected_server);
+	test_end();
+}
+
+/*
+ * Main
+ */
+
+static void main_init(void)
+{
+	/* nothing yet */
+}
+
+static void main_deinit(void)
+{
+	/* nothing yet; also called from sub-processes */
+}
+
+int main(int argc ATTR_UNUSED, char *argv[])
+{
+	int c;
+	int ret;
+
+	static void (*const test_functions[])(void) = {
+		test_imapc_connect_failed,
+		test_imapc_banner_hangs,
+		test_imapc_login_hangs,
+		test_imapc_login_fails,
+		test_imapc_reconnect,
+		test_imapc_reconnect_resend_commands,
+		test_imapc_reconnect_resend_commands_failed,
+		test_imapc_reconnect_mailbox,
+		test_imapc_client_get_capabilities,
+		test_imapc_client_get_capabilities_reconnected,
+		test_imapc_client_get_capabilities_disconnected,
+		NULL
+	};
+
+	lib_init();
+	main_init();
+
+	while ((c = getopt(argc, argv, "D")) > 0) {
+		switch (c) {
+		case 'D':
+			debug = TRUE;
+			break;
+		default:
+			i_fatal("Usage: %s [-D]", argv[0]);
+		}
+	}
+
+	test_subprocesses_init(debug);
+	test_imapc_default_settings.debug = debug;
+
+	/* listen on localhost */
+	i_zero(&bind_ip);
+	bind_ip.family = AF_INET;
+	bind_ip.u.ip4.s_addr = htonl(INADDR_LOOPBACK);
+
+	ret = test_run(test_functions);
+
+	test_subprocesses_deinit();
+	main_deinit();
+	lib_deinit();
+
+	return ret;
+}