From 0441d265f2bb9da249c7abf333f0f771fadb4ab5 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 19:36:47 +0200 Subject: Adding upstream version 1:2.3.21+dfsg1. Signed-off-by: Daniel Baumann --- src/lib-imap-client/Makefile.am | 53 + src/lib-imap-client/Makefile.in | 880 ++++++++++ src/lib-imap-client/imapc-client-private.h | 63 + src/lib-imap-client/imapc-client.c | 584 +++++++ src/lib-imap-client/imapc-client.h | 250 +++ src/lib-imap-client/imapc-connection.c | 2557 ++++++++++++++++++++++++++++ src/lib-imap-client/imapc-connection.h | 64 + src/lib-imap-client/imapc-msgmap.c | 89 + src/lib-imap-client/imapc-msgmap.h | 18 + src/lib-imap-client/test-imapc-client.c | 901 ++++++++++ 10 files changed, 5459 insertions(+) create mode 100644 src/lib-imap-client/Makefile.am create mode 100644 src/lib-imap-client/Makefile.in create mode 100644 src/lib-imap-client/imapc-client-private.h create mode 100644 src/lib-imap-client/imapc-client.c create mode 100644 src/lib-imap-client/imapc-client.h create mode 100644 src/lib-imap-client/imapc-connection.c create mode 100644 src/lib-imap-client/imapc-connection.h create mode 100644 src/lib-imap-client/imapc-msgmap.c create mode 100644 src/lib-imap-client/imapc-msgmap.h create mode 100644 src/lib-imap-client/test-imapc-client.c (limited to 'src/lib-imap-client') 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 + +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 +#include + +#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) { + /* */ + 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; iips_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 +#include + +#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 ? "" : 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; +} -- cgit v1.2.3