File _service:obs_scm:kmailtransport-VERSIONgit.2021... of Package kmailtransport

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:kmailtransport-VERSIONgit.20210805T082020~47b7f31.obscpio of Package kmailtransport (Revision ffa6278ddfa3a368c47e3aa59138c490)

Currently displaying revision ffa6278ddfa3a368c47e3aa59138c490 , Show latest

07070100000000000081A4000000000000000000000001610B832400000038000000000000000000000000000000000000004900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/.git-blame-ignore-revs# clang-format
9b29aa9832111db3bd0f29adebcd423bff8a8bda
07070100000001000081A4000000000000000000000001610B83240000011D000000000000000000000000000000000000003D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/.gitignore# Ignore the following files
*~
*.[oa]
*.diff
*.kate-swp
*.kdev4
.kdev_include_paths
*.kdevelop.pcs
*.moc
*.moc.cpp
*.orig
*.user
.*.swp
.swp.*
Doxyfile
Makefile
/build*/
.cmake/
CMakeLists.txt.user*
*.unc-backup*
compile_commands.json
.clang-format
.clangd
.idea
/cmake-build*
.cache
07070100000002000081A4000000000000000000000001610B8324000008A9000000000000000000000000000000000000004100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/.gitlab-ci.yml# SPDX-FileCopyrightText: 2020-2021 Laurent Montel <montel@kde.org>
# SPDX-FileCopyrightText: 2021 Laurent Montel <montel@kde.org>
# SPDX-License-Identifier: CC0-1.0

include:
  - https://invent.kde.org/sysadmin/ci-tooling/raw/master/invent/ci-before.yml
  - https://invent.kde.org/sysadmin/ci-tooling/raw/master/invent/ci-applications-linux.yml

build_clazy_clang_tidy:
  stage: build
  image: kdeorg/ci-suse-qt515
  extends: .linux
  #only:
  #  - merge_requests
  before_script:
    - zypper install -y clazy
    - git clone --depth=1 https://invent.kde.org/sysadmin/ci-tooling.git $CI_TOOLING
    - git clone --depth=1 https://invent.kde.org/sysadmin/repo-metadata.git $CI_TOOLING/repo-metadata
    - git clone --depth=1 https://invent.kde.org/sysadmin/kde-build-metadata.git $CI_TOOLING/kde-build-metadata
    - git clone --depth=1 https://invent.kde.org/sdk/kde-dev-scripts.git $CI_TOOLING/kde-dev-scripts

script:
    - export CXX=clazy
    - export CC=clang
    - export CXXFLAGS="-Wno-deprecated-declarations"
    - export CLAZY_HEADER_FILTER='^(?!ui_)\w+.h\$'
    - export CLAZY_CHECKS="level0,level1,detaching-member,ifndef-define-typo,isempty-vs-count,qrequiredresult-candidates,reserve-candidates,signal-with-return-value,unneeded-cast,function-args-by-ref,function-args-by-value,returning-void-expression,no-ctor-missing-parent-argument,isempty-vs-count,qhash-with-char-pointer-key,raw-environment-function,qproperty-type-mismatch,old-style-connect,qstring-allocations,container-inside-loop,heap-allocated-small-trivial-type,inefficient-qlist,qstring-varargs"
    - python3 -u $CI_TOOLING/helpers/prepare-dependencies.py --product $PRODUCT --project $PROJECT --branchGroup $BRANCH_GROUP --environment production --platform $PLATFORM --installTo $INSTALL_PREFIX
    - python3 -u $CI_TOOLING/helpers/configure-build.py --product $PRODUCT --project $PROJECT --branchGroup $BRANCH_GROUP --platform $PLATFORM --installTo $INSTALL_PREFIX
    - python3 -u $CI_TOOLING/helpers/compile-build.py --product $PRODUCT --project $PROJECT --branchGroup $BRANCH_GROUP --platform $PLATFORM --usingInstall $INSTALL_PREFIX
    - cd build && run-clang-tidy
  variables:
    PLATFORM: SUSEQt5.15
    BRANCH_GROUP: kf5-qt5
07070100000003000081A4000000000000000000000001610B83240000000D000000000000000000000000000000000000003900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/.krazySKIP /tests/
07070100000004000081A4000000000000000000000001610B832400000B52000000000000000000000000000000000000004100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/CMakeLists.txtcmake_minimum_required(VERSION 3.16 FATAL_ERROR)
set(PIM_VERSION "5.18.40")
project(MailTransport VERSION ${PIM_VERSION})

# ECM setup
set(KF5_MIN_VERSION "5.84.0")

find_package(ECM ${KF5_MIN_VERSION} CONFIG REQUIRED)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)

include(GenerateExportHeader)
include(ECMGenerateHeaders)
include(ECMGeneratePriFile)

include(ECMSetupVersion)
include(FeatureSummary)
include(KDEGitCommitHooks)
include(ECMQtDeclareLoggingCategory)

add_definitions(-DTRANSLATION_DOMAIN=\"libmailtransport5\")

set(KMAILTRANSPORT_LIB_VERSION ${PIM_VERSION})

set(KMIME_LIB_VERSION "5.18.40")
set(AKONADI_LIB_VERSION "5.18.40")
set(AKONADIMIME_LIB_VERSION "5.18.40")
set(KSMTP_LIB_VERSION "5.18.40")
set(KGAPI_LIB_VERSION "5.18.40")

set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5MailTransport")

########### Find packages ###########
find_package(KF5KCMUtils ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5ConfigWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)
#remove in the future
find_package(KF5Wallet ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5I18n ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5KIO ${KF5_MIN_VERSION} CONFIG REQUIRED)
find_package(KF5Mime ${KMIME_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5Akonadi ${AKONADI_LIB_VERSION} CONFIG REQUIRED)
find_package(KF5AkonadiMime ${AKONADIMIME_LIB_VERSION} CONFIG REQUIRED)
find_package(KPimSMTP ${KSMTP_LIB_VERSION} CONFIG REQUIRED)
find_package(KPimGAPI ${KGAPI_LIB_VERSION} CONFIG REQUIRED)

#it will replace kwallet support
find_package(Qt5Keychain CONFIG)
set_package_properties(Qt5Keychain PROPERTIES
                                   DESCRIPTION "Provides support for secure credentials storage"
                                   URL "https://github.com/frankosterfeld/qtkeychain"
                                   TYPE REQUIRED)

option(KDEPIM_RUN_AKONADI_TEST "Enable autotest based on Akonadi." ON)
add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f00)
add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055500)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
if(BUILD_TESTING)
    find_package(Qt5Test CONFIG REQUIRED)
   add_definitions(-DBUILD_TESTING)
endif(BUILD_TESTING)

option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)

set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
if (USE_UNITY_CMAKE_SUPPORT)
    set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
endif()

########### Targets ###########
add_subdirectory(src)

ecm_qt_install_logging_categories(
        EXPORT MAILTRANSPORT
        FILE kmailtransport.categories
        DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
        )
kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)
ki18n_install(po)
feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

07070100000005000081A4000000000000000000000001610B832400001255000000000000000000000000000000000000004400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/CMakePresets.json{
    "version": 3,
    "configurePresets": [
        {
            "name": "dev",
            "displayName": "Build as debug",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            },
            "installDir": "$env{KF5}"
        },
        {
            "name": "asan",
            "displayName": "Build with Asan support.",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build-asan",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug",
                "ECM_ENABLE_SANITIZERS" : "'address;undefined'",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            },
            "installDir": "$env{KF5}"
        },
        {
            "name": "dev-clang",
            "displayName": "dev-clang",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build-clang",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            },
            "environment": {
                "CXX": "clang++",
                "CCACHE_DISABLE": "ON"
            },
            "installDir": "$env{KF5}"
        },
        {
            "name": "unity",
            "displayName": "Build with CMake unity support.",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build-unity",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug",
                "USE_UNITY_CMAKE_SUPPORT": "ON",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            },
            "installDir": "$env{KF5}"
        },
        {
            "name": "release",
            "displayName": "Build as release mode.",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build-release",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Release"
            },
            "installDir": "$env{KF5}"
        },
        {
            "name": "profile",
            "displayName": "profile",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build-profile",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "RelWithDebInfo",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            },
            "installDir": "$env{KF5}"
        },
        {
            "name": "clazy",
            "displayName": "clazy",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build-clazy",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug"
            },
            "environment": {
                "CXX": "clazy",
                "CCACHE_DISABLE": "ON"
            },
            "installDir": "$env{KF5}"
        }

],
    "buildPresets": [
        {
            "name": "dev",
            "configurePreset": "dev"
        },
        {
            "name": "release",
            "configurePreset": "release"
        },
        {
            "name": "dev-clang",
            "configurePreset": "dev-clang"
        },
        {
            "name": "asan",
            "configurePreset": "asan"
        },
        {
            "name": "unity",
            "configurePreset": "unity"
        },
        {
            "name": "clazy",
            "configurePreset": "clazy",
            "environment": {
                "CLAZY_CHECKS" : "level0,level1,detaching-member,ifndef-define-typo,isempty-vs-count,qrequiredresult-candidates,reserve-candidates,signal-with-return-value,unneeded-cast,function-args-by-ref,function-args-by-value,returning-void-expression,no-ctor-missing-parent-argument,isempty-vs-count,qhash-with-char-pointer-key,raw-environment-function,qproperty-type-mismatch,old-style-connect,qstring-allocations,container-inside-loop,heap-allocated-small-trivial-type,inefficient-qlist,qstring-varargs,level2,detaching-member,heap-allocated-small-trivial-type,isempty-vs-count,qstring-varargs,qvariant-template-instantiation,raw-environment-function,reserve-candidates,signal-with-return-value,thread-with-slots,no-ctor-missing-parent-argument,no-missing-typeinfo",
                "CCACHE_DISABLE" : "ON"
            }
        }
    ],
    "testPresets": [
    { 
      "name": "dev",
      "configurePreset": "dev",
      "output": {"outputOnFailure": true},
      "execution": {"noTestsAction": "error", "stopOnFailure": false}
    },
    { 
      "name": "asan",
      "configurePreset": "asan",
      "output": {"outputOnFailure": true},
      "execution": {"noTestsAction": "error", "stopOnFailure": true}
    }
    ]
}
07070100000006000081A4000000000000000000000001610B832400000067000000000000000000000000000000000000004C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/CMakePresets.json.license# SPDX-FileCopyrightText: 2021 Laurent Montel <montel@kde.org>
# SPDX-License-Identifier: BSD-3-Clause
07070100000007000081A4000000000000000000000001610B832400000443000000000000000000000000000000000000003900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/DESIGNGlossary:
New apps == apps using MessageQueueJob.
Old apps == apps using the MailTransport jobs directly.
Traditional transports == SMTP and Sendmail, which are handled by MailTransport.
Resource-based transports == Akonadi-based transports, which are handled by the MDA.
MDA == Mail Dispatcher Agent.

Current situation:
* New apps, traditional transports:
  App's composer -> MailTransport (MessageQueueJob) -> MDA -> MailTransport (SmtpJob or SendmailJob).
* New apps, resource-based transports:
  App's composer -> MailTransport (MessageQueueJob) -> MDA -> specific resource.
* Old apps, traditional transports:
  App's composer -> MailTransport (SmtpJob or SendmailJob).
* Old apps, resource-based transports:
  App's composer -> MailTransport (ResourceSendJob) -> MailTransport (MessageQueueJob) -> MDA -> specific resource.

Ideal situation (KDE5):
* Move SmtpJob and SendmailJob to the MDA, and let MailTransport handle only config stuff and putting things in the outbox.
* All apps:
  App's composer -> MailTransport (MessageQueueJob) -> MDA (SMTP, Sendmail, or specific resource)

07070100000008000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000003B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/LICENSES07070100000009000081A4000000000000000000000001610B832400001B04000000000000000000000000000000000000004700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/LICENSES/CC0-1.0.txtCreative Commons Legal Code

CC0 1.0 Universal CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES
NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE
AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION
ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE USE
OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER, AND DISCLAIMS
LIABILITY FOR DAMAGES RESULTING FROM THE USE OF THIS DOCUMENT OR THE INFORMATION
OR WORKS PROVIDED HEREUNDER.

Statement of Purpose

The laws of most jurisdictions throughout the world automatically confer exclusive
Copyright and Related Rights (defined below) upon the creator and subsequent
owner(s) (each and all, an "owner") of an original work of authorship and/or
a database (each, a "Work").

Certain owners wish to permanently relinquish those rights to a Work for the
purpose of contributing to a commons of creative, cultural and scientific
works ("Commons") that the public can reliably and without fear of later claims
of infringement build upon, modify, incorporate in other works, reuse and
redistribute as freely as possible in any form whatsoever and for any purposes,
including without limitation commercial purposes. These owners may contribute
to the Commons to promote the ideal of a free culture and the further production
of creative, cultural and scientific works, or to gain reputation or greater
distribution for their Work in part through the use and efforts of others.

For these and/or other purposes and motivations, and without any expectation
of additional consideration or compensation, the person associating CC0 with
a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
and publicly distribute the Work under its terms, with knowledge of his or
her Copyright and Related Rights in the Work and the meaning and intended
legal effect of CC0 on those rights.

1. Copyright and Related Rights. A Work made available under CC0 may be protected
by copyright and related or neighboring rights ("Copyright and Related Rights").
Copyright and Related Rights include, but are not limited to, the following:

i. the right to reproduce, adapt, distribute, perform, display, communicate,
and translate a Work;

ii. moral rights retained by the original author(s) and/or performer(s);

iii. publicity and privacy rights pertaining to a person's image or likeness
depicted in a Work;

iv. rights protecting against unfair competition in regards to a Work, subject
to the limitations in paragraph 4(a), below;

v. rights protecting the extraction, dissemination, use and reuse of data
in a Work;

vi. database rights (such as those arising under Directive 96/9/EC of the
European Parliament and of the Council of 11 March 1996 on the legal protection
of databases, and under any national implementation thereof, including any
amended or successor version of such directive); and

vii. other similar, equivalent or corresponding rights throughout the world
based on applicable law or treaty, and any national implementations thereof.

2. Waiver. To the greatest extent permitted by, but not in contravention of,
applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
and Related Rights and associated claims and causes of action, whether now
known or unknown (including existing as well as future claims and causes of
action), in the Work (i) in all territories worldwide, (ii) for the maximum
duration provided by applicable law or treaty (including future time extensions),
(iii) in any current or future medium and for any number of copies, and (iv)
for any purpose whatsoever, including without limitation commercial, advertising
or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the
benefit of each member of the public at large and to the detriment of Affirmer's
heirs and successors, fully intending that such Waiver shall not be subject
to revocation, rescission, cancellation, termination, or any other legal or
equitable action to disrupt the quiet enjoyment of the Work by the public
as contemplated by Affirmer's express Statement of Purpose.

3. Public License Fallback. Should any part of the Waiver for any reason be
judged legally invalid or ineffective under applicable law, then the Waiver
shall be preserved to the maximum extent permitted taking into account Affirmer's
express Statement of Purpose. In addition, to the extent the Waiver is so
judged Affirmer hereby grants to each affected person a royalty-free, non
transferable, non sublicensable, non exclusive, irrevocable and unconditional
license to exercise Affirmer's Copyright and Related Rights in the Work (i)
in all territories worldwide, (ii) for the maximum duration provided by applicable
law or treaty (including future time extensions), (iii) in any current or
future medium and for any number of copies, and (iv) for any purpose whatsoever,
including without limitation commercial, advertising or promotional purposes
(the "License"). The License shall be deemed effective as of the date CC0
was applied by Affirmer to the Work. Should any part of the License for any
reason be judged legally invalid or ineffective under applicable law, such
partial invalidity or ineffectiveness shall not invalidate the remainder of
the License, and in such case Affirmer hereby affirms that he or she will
not (i) exercise any of his or her remaining Copyright and Related Rights
in the Work or (ii) assert any associated claims and causes of action with
respect to the Work, in either case contrary to Affirmer's express Statement
of Purpose.

4. Limitations and Disclaimers.

a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered,
licensed or otherwise affected by this document.

b. Affirmer offers the Work as-is and makes no representations or warranties
of any kind concerning the Work, express, implied, statutory or otherwise,
including without limitation warranties of title, merchantability, fitness
for a particular purpose, non infringement, or the absence of latent or other
defects, accuracy, or the present or absence of errors, whether or not discoverable,
all to the greatest extent permissible under applicable law.

c. Affirmer disclaims responsibility for clearing rights of other persons
that may apply to the Work or any use thereof, including without limitation
any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims
responsibility for obtaining any necessary consents, permissions or other
rights required for any use of the Work.

d. Affirmer understands and acknowledges that Creative Commons is not a party
to this document and has no duty or obligation with respect to this CC0 or
use of the Work.
0707010000000A000081A4000000000000000000000001610B8324000060C6000000000000000000000000000000000000005100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/LICENSES/LGPL-2.0-or-later.txtGNU LIBRARY GENERAL PUBLIC LICENSE

51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.

[This is the first released version of the library GPL. It is numbered 2 because
it goes with version 2 of the ordinary GPL.]

Preamble

The licenses for most software are designed to take away your freedom to share
and change it. By contrast, the GNU General Public Licenses are intended to
guarantee your freedom to share and change free software--to make sure the
software is free for all its users.

This license, the Library General Public License, applies to some specially
designated Free Software Foundation software, and to any other libraries whose
authors decide to use it. You can use it for your libraries, too.

When we speak of free software, we are referring to freedom, not price. Our
General Public Licenses are designed to make sure that you have the freedom
to distribute copies of free software (and charge for this service if you
wish), that you receive source code or can get it if you want it, that you
can change the software or use pieces of it in new free programs; and that
you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to
deny you these rights or to ask you to surrender the rights. These restrictions
translate to certain responsibilities for you if you distribute copies of
the library, or if you modify it.

For example, if you distribute copies of the library, whether gratis or for
a fee, you must give the recipients all the rights that we gave you. You must
make sure that they, too, receive or can get the source code. If you link
a program with the library, you must provide complete object files to the
recipients so that they can relink them with the library, after making changes
to the library and recompiling it. And you must show them these terms so they
know their rights.

Our method of protecting your rights has two steps: (1) copyright the library,
and (2) offer you this license which gives you legal permission to copy, distribute
and/or modify the library.

Also, for each distributor's protection, we want to make certain that everyone
understands that there is no warranty for this free library. If the library
is modified by someone else and passed on, we want its recipients to know
that what they have is not the original version, so that any problems introduced
by others will not reflect on the original authors' reputations.

Finally, any free program is threatened constantly by software patents. We
wish to avoid the danger that companies distributing free software will individually
obtain patent licenses, thus in effect transforming the program into proprietary
software. To prevent this, we have made it clear that any patent must be licensed
for everyone's free use or not licensed at all.

Most GNU software, including some libraries, is covered by the ordinary GNU
General Public License, which was designed for utility programs. This license,
the GNU Library General Public License, applies to certain designated libraries.
This license is quite different from the ordinary one; be sure to read it
in full, and don't assume that anything in it is the same as in the ordinary
license.

The reason we have a separate public license for some libraries is that they
blur the distinction we usually make between modifying or adding to a program
and simply using it. Linking a program with a library, without changing the
library, is in some sense simply using the library, and is analogous to running
a utility program or application program. However, in a textual and legal
sense, the linked executable is a combined work, a derivative of the original
library, and the ordinary General Public License treats it as such.

Because of this blurred distinction, using the ordinary General Public License
for libraries did not effectively promote software sharing, because most developers
did not use the libraries. We concluded that weaker conditions might promote
sharing better.

However, unrestricted linking of non-free programs would deprive the users
of those programs of all benefit from the free status of the libraries themselves.
This Library General Public License is intended to permit developers of non-free
programs to use free libraries, while preserving your freedom as a user of
such programs to change the free libraries that are incorporated in them.
(We have not seen how to achieve this as regards changes in header files,
but we have achieved it as regards changes in the actual functions of the
Library.) The hope is that this will lead to faster development of free libraries.

The precise terms and conditions for copying, distribution and modification
follow. Pay close attention to the difference between a "work based on the
library" and a "work that uses the library". The former contains code derived
from the library, while the latter only works together with the library.

Note that it is possible for a library to be covered by the ordinary General
Public License rather than by this special one.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library which contains a
notice placed by the copyright holder or other authorized party saying it
may be distributed under the terms of this Library General Public License
(also called "this License"). Each licensee is addressed as "you".

A "library" means a collection of software functions and/or data prepared
so as to be conveniently linked with application programs (which use some
of those functions and data) to form executables.

The "Library", below, refers to any such software library or work which has
been distributed under these terms. A "work based on the Library" means either
the Library or any derivative work under copyright law: that is to say, a
work containing the Library or a portion of it, either verbatim or with modifications
and/or translated straightforwardly into another language. (Hereinafter, translation
is included without limitation in the term "modification".)

"Source code" for a work means the preferred form of the work for making modifications
to it. For a library, complete source code means all the source code for all
modules it contains, plus any associated interface definition files, plus
the scripts used to control compilation and installation of the library.

Activities other than copying, distribution and modification are not covered
by this License; they are outside its scope. The act of running a program
using the Library is not restricted, and output from such a program is covered
only if its contents constitute a work based on the Library (independent of
the use of the Library in a tool for writing it). Whether that is true depends
on what the Library does and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's complete source
code as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and disclaimer
of warranty; keep intact all the notices that refer to this License and to
the absence of any warranty; and distribute a copy of this License along with
the Library.

You may charge a fee for the physical act of transferring a copy, and you
may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Library or any portion of it,
thus forming a work based on the Library, and copy and distribute such modifications
or work under the terms of Section 1 above, provided that you also meet all
of these conditions:

a) The modified work must itself be a software library.

b) You must cause the files modified to carry prominent notices stating that
you changed the files and the date of any change.

c) You must cause the whole of the work to be licensed at no charge to all
third parties under the terms of this License.

d) If a facility in the modified Library refers to a function or a table of
data to be supplied by an application program that uses the facility, other
than as an argument passed when the facility is invoked, then you must make
a good faith effort to ensure that, in the event an application does not supply
such function or table, the facility still operates, and performs whatever
part of its purpose remains meaningful.

(For example, a function in a library to compute square roots has a purpose
that is entirely well-defined independent of the application. Therefore, Subsection
2d requires that any application-supplied function or table used by this function
must be optional: if the application does not supply it, the square root function
must still compute square roots.)

These requirements apply to the modified work as a whole. If identifiable
sections of that work are not derived from the Library, and can be reasonably
considered independent and separate works in themselves, then this License,
and its terms, do not apply to those sections when you distribute them as
separate works. But when you distribute the same sections as part of a whole
which is a work based on the Library, the distribution of the whole must be
on the terms of this License, whose permissions for other licensees extend
to the entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest your
rights to work written entirely by you; rather, the intent is to exercise
the right to control the distribution of derivative or collective works based
on the Library.

In addition, mere aggregation of another work not based on the Library with
the Library (or with a work based on the Library) on a volume of a storage
or distribution medium does not bring the other work under the scope of this
License.

3. You may opt to apply the terms of the ordinary GNU General Public License
instead of this License to a given copy of the Library. To do this, you must
alter all the notices that refer to this License, so that they refer to the
ordinary GNU General Public License, version 2, instead of to this License.
(If a newer version than version 2 of the ordinary GNU General Public License
has appeared, then you can specify that version instead if you wish.) Do not
make any other change in these notices.

Once this change is made in a given copy, it is irreversible for that copy,
so the ordinary GNU General Public License applies to all subsequent copies
and derivative works made from that copy.

This option is useful when you wish to copy part of the code of the Library
into a program that is not a library.

4. You may copy and distribute the Library (or a portion or derivative of
it, under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you accompany it with the complete corresponding
machine-readable source code, which must be distributed under the terms of
Sections 1 and 2 above on a medium customarily used for software interchange.

If distribution of object code is made by offering access to copy from a designated
place, then offering equivalent access to copy the source code from the same
place satisfies the requirement to distribute the source code, even though
third parties are not compelled to copy the source along with the object code.

5. A program that contains no derivative of any portion of the Library, but
is designed to work with the Library by being compiled or linked with it,
is called a "work that uses the Library". Such a work, in isolation, is not
a derivative work of the Library, and therefore falls outside the scope of
this License.

However, linking a "work that uses the Library" with the Library creates an
executable that is a derivative of the Library (because it contains portions
of the Library), rather than a "work that uses the library". The executable
is therefore covered by this License. Section 6 states terms for distribution
of such executables.

When a "work that uses the Library" uses material from a header file that
is part of the Library, the object code for the work may be a derivative work
of the Library even though the source code is not. Whether this is true is
especially significant if the work can be linked without the Library, or if
the work is itself a library. The threshold for this to be true is not precisely
defined by law.

If such an object file uses only numerical parameters, data structure layouts
and accessors, and small macros and small inline functions (ten lines or less
in length), then the use of the object file is unrestricted, regardless of
whether it is legally a derivative work. (Executables containing this object
code plus portions of the Library will still fall under Section 6.)

Otherwise, if the work is a derivative of the Library, you may distribute
the object code for the work under the terms of Section 6. Any executables
containing that work also fall under Section 6, whether or not they are linked
directly with the Library itself.

6. As an exception to the Sections above, you may also compile or link a "work
that uses the Library" with the Library to produce a work containing portions
of the Library, and distribute that work under terms of your choice, provided
that the terms permit modification of the work for the customer's own use
and reverse engineering for debugging such modifications.

You must give prominent notice with each copy of the work that the Library
is used in it and that the Library and its use are covered by this License.
You must supply a copy of this License. If the work during execution displays
copyright notices, you must include the copyright notice for the Library among
them, as well as a reference directing the user to the copy of this License.
Also, you must do one of these things:

a) Accompany the work with the complete corresponding machine-readable source
code for the Library including whatever changes were used in the work (which
must be distributed under Sections 1 and 2 above); and, if the work is an
executable linked with the Library, with the complete machine-readable "work
that uses the Library", as object code and/or source code, so that the user
can modify the Library and then relink to produce a modified executable containing
the modified Library. (It is understood that the user who changes the contents
of definitions files in the Library will not necessarily be able to recompile
the application to use the modified definitions.)

b) Accompany the work with a written offer, valid for at least three years,
to give the same user the materials specified in Subsection 6a, above, for
a charge no more than the cost of performing this distribution.

c) If distribution of the work is made by offering access to copy from a designated
place, offer equivalent access to copy the above specified materials from
the same place.

d) Verify that the user has already received a copy of these materials or
that you have already sent this user a copy.

For an executable, the required form of the "work that uses the Library" must
include any data and utility programs needed for reproducing the executable
from it. However, as a special exception, the source code distributed need
not include anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the operating
system on which the executable runs, unless that component itself accompanies
the executable.

It may happen that this requirement contradicts the license restrictions of
other proprietary libraries that do not normally accompany the operating system.
Such a contradiction means you cannot use both them and the Library together
in an executable that you distribute.

7. You may place library facilities that are a work based on the Library side-by-side
in a single library together with other library facilities not covered by
this License, and distribute such a combined library, provided that the separate
distribution of the work based on the Library and of the other library facilities
is otherwise permitted, and provided that you do these two things:

a) Accompany the combined library with a copy of the same work based on the
Library, uncombined with any other library facilities. This must be distributed
under the terms of the Sections above.

b) Give prominent notice with the combined library of the fact that part of
it is a work based on the Library, and explaining where to find the accompanying
uncombined form of the same work.

8. You may not copy, modify, sublicense, link with, or distribute the Library
except as expressly provided under this License. Any attempt otherwise to
copy, modify, sublicense, link with, or distribute the Library is void, and
will automatically terminate your rights under this License. However, parties
who have received copies, or rights, from you under this License will not
have their licenses terminated so long as such parties remain in full compliance.

9. You are not required to accept this License, since you have not signed
it. However, nothing else grants you permission to modify or distribute the
Library or its derivative works. These actions are prohibited by law if you
do not accept this License. Therefore, by modifying or distributing the Library
(or any work based on the Library), you indicate your acceptance of this License
to do so, and all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

10. Each time you redistribute the Library (or any work based on the Library),
the recipient automatically receives a license from the original licensor
to copy, distribute, link with or modify the Library subject to these terms
and conditions. You may not impose any further restrictions on the recipients'
exercise of the rights granted herein. You are not responsible for enforcing
compliance by third parties to this License.

11. If, as a consequence of a court judgment or allegation of patent infringement
or for any other reason (not limited to patent issues), conditions are imposed
on you (whether by court order, agreement or otherwise) that contradict the
conditions of this License, they do not excuse you from the conditions of
this License. If you cannot distribute so as to satisfy simultaneously your
obligations under this License and any other pertinent obligations, then as
a consequence you may not distribute the Library at all. For example, if a
patent license would not permit royalty-free redistribution of the Library
by all those who receive copies directly or indirectly through you, then the
only way you could satisfy both it and this License would be to refrain entirely
from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any patents
or other property right claims or to contest validity of any such claims;
this section has the sole purpose of protecting the integrity of the free
software distribution system which is implemented by public license practices.
Many people have made generous contributions to the wide range of software
distributed through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing to
distribute software through any other system and a licensee cannot impose
that choice.

This section is intended to make thoroughly clear what is believed to be a
consequence of the rest of this License.

12. If the distribution and/or use of the Library is restricted in certain
countries either by patents or by copyrighted interfaces, the original copyright
holder who places the Library under this License may add an explicit geographical
distribution limitation excluding those countries, so that distribution is
permitted only in or among countries not thus excluded. In such case, this
License incorporates the limitation as if written in the body of this License.

13. The Free Software Foundation may publish revised and/or new versions of
the Library General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to address
new problems or concerns.

Each version is given a distinguishing version number. If the Library specifies
a version number of this License which applies to it and "any later version",
you have the option of following the terms and conditions either of that version
or of any later version published by the Free Software Foundation. If the
Library does not specify a license version number, you may choose any version
ever published by the Free Software Foundation.

14. If you wish to incorporate parts of the Library into other free programs
whose distribution conditions are incompatible with these, write to the author
to ask for permission. For software which is copyrighted by the Free Software
Foundation, write to the Free Software Foundation; we sometimes make exceptions
for this. Our decision will be guided by the two goals of preserving the free
status of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

NO WARRANTY

15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Libraries

If you develop a new library, and you want it to be of the greatest possible
use to the public, we recommend making it free software that everyone can
redistribute and change. You can do so by permitting redistribution under
these terms (or, alternatively, under the terms of the ordinary General Public
License).

To apply these terms, attach the following notices to the library. It is safest
to attach them to the start of each source file to most effectively convey
the exclusion of warranty; and each file should have at least the "copyright"
line and a pointer to where the full notice is found.

one line to give the library's name and an idea of what it does.

This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Library General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option)
any later version.

This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more
details.

You should have received a copy of the GNU Library General Public License
along with this library; if not, write to the Free Software Foundation, Inc.,
51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your school,
if any, to sign a "copyright disclaimer" for the library, if necessary. Here
is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in

the library `Frob' (a library for tweaking knobs) written

by James Random Hacker.

signature of Ty Coon, 1 April 1990

Ty Coon, President of Vice

That's all there is to it!
0707010000000B000081A4000000000000000000000001610B832400006532000000000000000000000000000000000000005100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/LICENSES/LGPL-2.1-or-later.txtGNU LESSER GENERAL PUBLIC LICENSE

Version 2.1, February 1999

51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.

[This is the first released version of the Lesser GPL. It also counts as the
successor of the GNU Library Public License, version 2, hence the version
number 2.1.]

Preamble

This license, the Lesser General Public License, applies to some specially
designated software packages--typically libraries--of the Free Software Foundation
and other authors who decide to use it. You can use it too, but we suggest
you first think carefully about whether this license or the ordinary General
Public License is the better strategy to use in any particular case, based
on the explanations below.

When we speak of free software, we are referring to freedom of use, not price.
Our General Public Licenses are designed to make sure that you have the freedom
to distribute copies of free software (and charge for this service if you
wish); that you receive source code or can get it if you want it; that you
can change the software and use pieces of it in new free programs; and that
you are informed that you can do these things.

To protect your rights, we need to make restrictions that forbid distributors
to deny you these rights or to ask you to surrender these rights. These restrictions
translate to certain responsibilities for you if you distribute copies of
the library or if you modify it.

For example, if you distribute copies of the library, whether gratis or for
a fee, you must give the recipients all the rights that we gave you. You must
make sure that they, too, receive or can get the source code. If you link
other code with the library, you must provide complete object files to the
recipients, so that they can relink them with the library after making changes
to the library and recompiling it. And you must show them these terms so they
know their rights.

We protect your rights with a two-step method: (1) we copyright the library,
and (2) we offer you this license, which gives you legal permission to copy,
distribute and/or modify the library.

To protect each distributor, we want to make it very clear that there is no
warranty for the free library. Also, if the library is modified by someone
else and passed on, the recipients should know that what they have is not
the original version, so that the original author's reputation will not be
affected by problems that might be introduced by others.

Finally, software patents pose a constant threat to the existence of any free
program. We wish to make sure that a company cannot effectively restrict the
users of a free program by obtaining a restrictive license from a patent holder.
Therefore, we insist that any patent license obtained for a version of the
library must be consistent with the full freedom of use specified in this
license.

Most GNU software, including some libraries, is covered by the ordinary GNU
General Public License. This license, the GNU Lesser General Public License,
applies to certain designated libraries, and is quite different from the ordinary
General Public License. We use this license for certain libraries in order
to permit linking those libraries into non-free programs.

When a program is linked with a library, whether statically or using a shared
library, the combination of the two is legally speaking a combined work, a
derivative of the original library. The ordinary General Public License therefore
permits such linking only if the entire combination fits its criteria of freedom.
The Lesser General Public License permits more lax criteria for linking other
code with the library.

We call this license the "Lesser" General Public License because it does Less
to protect the user's freedom than the ordinary General Public License. It
also provides other free software developers Less of an advantage over competing
non-free programs. These disadvantages are the reason we use the ordinary
General Public License for many libraries. However, the Lesser license provides
advantages in certain special circumstances.

For example, on rare occasions, there may be a special need to encourage the
widest possible use of a certain library, so that it becomes a de-facto standard.
To achieve this, non-free programs must be allowed to use the library. A more
frequent case is that a free library does the same job as widely used non-free
libraries. In this case, there is little to gain by limiting the free library
to free software only, so we use the Lesser General Public License.

In other cases, permission to use a particular library in non-free programs
enables a greater number of people to use a large body of free software. For
example, permission to use the GNU C Library in non-free programs enables
many more people to use the whole GNU operating system, as well as its variant,
the GNU/Linux operating system.

Although the Lesser General Public License is Less protective of the users'
freedom, it does ensure that the user of a program that is linked with the
Library has the freedom and the wherewithal to run that program using a modified
version of the Library.

The precise terms and conditions for copying, distribution and modification
follow. Pay close attention to the difference between a "work based on the
library" and a "work that uses the library". The former contains code derived
from the library, whereas the latter must be combined with the library in
order to run.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library or other program
which contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Lesser General
Public License (also called "this License"). Each licensee is addressed as
"you".

A "library" means a collection of software functions and/or data prepared
so as to be conveniently linked with application programs (which use some
of those functions and data) to form executables.

You may charge a fee for the physical act of transferring a copy, and you
may at your option offer warranty protection in exchange for a fee.

a) The modified work must itself be a software library.

b) You must cause the files modified to carry prominent notices stating that
you changed the files and the date of any change.

c) You must cause the whole of the work to be licensed at no charge to all
third parties under the terms of this License.

Once this change is made in a given copy, it is irreversible for that copy,
so the ordinary GNU General Public License applies to all subsequent copies
and derivative works made from that copy.

This option is useful when you wish to copy part of the code of the Library
into a program that is not a library.

6. As an exception to the Sections above, you may also combine or link a "work
that uses the Library" with the Library to produce a work containing portions
of the Library, and distribute that work under terms of your choice, provided
that the terms permit modification of the work for the customer's own use
and reverse engineering for debugging such modifications.

b) Use a suitable shared library mechanism for linking with the Library. A
suitable mechanism is one that (1) uses at run time a copy of the library
already present on the user's computer system, rather than copying library
functions into the executable, and (2) will operate properly with a modified
version of the library, if the user installs one, as long as the modified
version is interface-compatible with the version that the work was made with.

c) Accompany the work with a written offer, valid for at least three years,
to give the same user the materials specified in Subsection 6a, above, for
a charge no more than the cost of performing this distribution.

d) If distribution of the work is made by offering access to copy from a designated
place, offer equivalent access to copy the above specified materials from
the same place.

e) Verify that the user has already received a copy of these materials or
that you have already sent this user a copy.

For an executable, the required form of the "work that uses the Library" must
include any data and utility programs needed for reproducing the executable
from it. However, as a special exception, the materials to be distributed
need not include anything that is normally distributed (in either source or
binary form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component itself
accompanies the executable.

a) Accompany the combined library with a copy of the same work based on the
Library, uncombined with any other library facilities. This must be distributed
under the terms of the Sections above.

b) Give prominent notice with the combined library of the fact that part of
it is a work based on the Library, and explaining where to find the accompanying
uncombined form of the same work.

This section is intended to make thoroughly clear what is believed to be a
consequence of the rest of this License.

13. The Free Software Foundation may publish revised and/or new versions of
the Lesser General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to address
new problems or concerns.

NO WARRANTY

How to Apply These Terms to Your New Libraries

This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation; either version 2.1 of the License, or (at your option)
any later version.

You should have received a copy of the GNU Lesser General Public License along
with this library; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your school,
if any, to sign a "copyright disclaimer" for the library, if necessary. Here
is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in

the library `Frob' (a library for tweaking knobs) written

by James Random Hacker.

< signature of Ty Coon > , 1 April 1990

Ty Coon, President of Vice

That's all there is to it!
0707010000000C000081A4000000000000000000000001610B83240000027A000000000000000000000000000000000000003F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/Mainpage.dox/**
  @mainpage Mail Transport Service

@section Overview
  The mailtransport module provides the following functionality:
  - Shared mail transport settings
  - GUI elements to configure mail transport settings
  - Job classes for mail sending

The mailtransport module consists of the following components:
  - a shared library containing the above listed functionality
  - a KCModule which can be embedded into your application to provide mail transport configuration
  - a KDED module which provides a D-Bus interface to mail transport settings and mail sending (not yet implemented)
*/

// DOXYGEN_REFERENCES = kdecore kdeui
0707010000000D000081A4000000000000000000000001610B832400000367000000000000000000000000000000000000003700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/TODOMail Transport TODO
~~~~~~~~~~~~~~~~~~~

Migration
---------
- password migration within kwallet (for kmail and knode), requires KWallet to
  be fixed first

TransportManager
----------------
- load passwords if another instance opens the wallet
- load passwords if application opens wallet
- add D-Bus interface for sending mails
- test to see if there is always a default transport, by adding / deleting accounts
- it would be nice to make showNewTransportDialog,
  promptCreateTransportIfNoneExists, and configureTransport visible on D-Bus,
  but how to handle QWidget *parent?

Transport
---------
- password is not reloaded from wallet on remote change

TransportJob
------------
- use QByteArray for addresses instead of QString

SMTPJob
-------
- get rid of kmail specific stuff in start()

Precommand
----------
- test conversion from kprocess to qprocess (TA)

0707010000000E000081A4000000000000000000000001610B8324000001B6000000000000000000000000000000000000004000000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/metainfo.yamlname: kmailtransport
description: Manage mail transport
maintainer: mlaurent
public_lib: true
group: kdepim
type: solution
platforms:
    - name: All
irc: akonadi

libraries:
 - qmake: KMailTransport
   cmake: "KF5::MailTransport"
 - qmake: KMailTransportAkonadi
   cmake: "KF5::MailTransportAkonadi"
cmakename: KF5MailTransport
# FIXME kapidox does not support more than one cmake module per repo yet
#cmakename: KF5MailTransportAkonadi
0707010000000F000081A4000000000000000000000001610B83240000003E000000000000000000000000000000000000004800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/metainfo.yaml.licenseSPDX-FileCopyrightText: none
SPDX-License-Identifier: CC0-1.0
07070100000010000081A4000000000000000000000001610B8324000001BA000000000000000000000000000000000000004200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/sanitizers.supp# SPDX-FileCopyrightText: 2021 Laurent Montel <montel@kde.org>
# SPDX-License-Identifier: CC0-1.0
# Suppression file for ASAN/LSAN

leak:libspeechd
leak:getdelim
leak:g_malloc
leak:libfontconfig
leak:libdbus
leak:QEasingCurve::
leak:QtSharedPointer::ExternalRefCountData::getAndRef
leak:QArrayData::allocate
leak:QObject::QObject
leak:QObjectPrivate::addConnection
leak:QObjectPrivate::connectImpl
leak:QPropertyAnimation::QPropertyAnimation
07070100000011000041ED000000000000000000000005610B832400000000000000000000000000000000000000000000003600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src07070100000012000081A4000000000000000000000001610B832400000061000000000000000000000000000000000000004500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/CMakeLists.txt
add_subdirectory(kmailtransport)
add_subdirectory(kmailtransportakonadi)
add_subdirectory(kcm)

07070100000013000081A4000000000000000000000001610B8324000000BF000000000000000000000000000000000000004200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/Messages.sh#! /bin/sh
$EXTRACTRC `find . -name \*.ui -o -iname \*.kcfg` >> rc.cpp || exit 11
$XGETTEXT `find . -name '*.cpp' | grep -v '/tests/' | grep -v '/autotests/'` -o $podir/libmailtransport5.pot
07070100000014000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000003A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kcm07070100000015000081A4000000000000000000000001610B8324000001A4000000000000000000000000000000000000004900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kcm/CMakeLists.txt
add_library(kcm_mailtransport MODULE)
target_sources(kcm_mailtransport PRIVATE configmodule.cpp)
target_link_libraries(kcm_mailtransport
                        KF5::KCMUtils
                        KF5::ConfigWidgets
                        KF5::MailTransport
)

install(TARGETS kcm_mailtransport DESTINATION ${KDE_INSTALL_PLUGINDIR})
install(FILES kcm_mailtransport.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR})

07070100000016000081A4000000000000000000000001610B83240000029A000000000000000000000000000000000000004B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kcm/configmodule.cpp/*
    SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "configmodule.h"
#include "widgets/transportmanagementwidget.h"

#include <KPluginFactory>

#include <QVBoxLayout>

using namespace MailTransport;

K_PLUGIN_FACTORY(MailTransportConfigFactory, registerPlugin<ConfigModule>();)

ConfigModule::ConfigModule(QWidget *parent, const QVariantList &args)
    : KCModule(parent, args)
{
    setButtons(NoAdditionalButton);
    auto l = new QVBoxLayout(this);
    l->setContentsMargins({});
    auto tmw = new TransportManagementWidget(this);
    l->addWidget(tmw);
}

#include "configmodule.moc"
07070100000017000081A4000000000000000000000001610B83240000019F000000000000000000000000000000000000004900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kcm/configmodule.h/*
    SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <KCModule>

namespace MailTransport
{
/**
  KCModule for transport management.
*/
class ConfigModule : public KCModule
{
    Q_OBJECT
public:
    explicit ConfigModule(QWidget *parent = nullptr, const QVariantList &args = QVariantList());
};
} // namespace MailTransport

07070100000018000081A4000000000000000000000001610B8324000007D9000000000000000000000000000000000000005400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kcm/kcm_mailtransport.desktop[Desktop Entry]
Icon=network-workgroup
Type=Service
X-KDE-ServiceTypes=KCModule

X-KDE-Library=kcm_mailtransport
X-KDE-FactoryName=kcm_mailtransport

Name=Mail Transport
Name[ar]=نقل البريد
Name[be]=Паштовы транспарт
Name[bs]=Transport pošte
Name[ca]=Transport de correu
Name[ca@valencia]=Transport de correu
Name[cs]=Přenos pošty
Name[da]=Mail-transport
Name[de]=Versandart
Name[el]=Κύριος μεταφορέας
Name[en_GB]=Mail Transport
Name[es]=Transporte de correo
Name[et]=Kirja saatmise viis
Name[fi]=Postinvälitys
Name[fr]=Transport de courrier électronique
Name[ga]=Iompar Ríomhphoist
Name[gl]=Transporte de correo
Name[he]=מעביר דואר
Name[hne]=मेल ट्रांसपोर्ट
Name[hu]=Levéltovábbítás
Name[ia]=Transporto de Posta
Name[it]=Trasporto della posta
Name[ja]=メール送信手段
Name[kk]=Пошта тасымалдауы
Name[km]=ការដឹកជញ្ជូនសំបុត្រ
Name[ko]=메일 전송
Name[lt]=Pašto programa
Name[lv]=Pasta transports
Name[mr]=मेल वाहतुक
Name[nb]=E-post-transport
Name[nds]=Nettpost-Överdreegmetood
Name[nl]=E-mailtransport
Name[nn]=E-posttransport
Name[pa]=ਮੇਲ ਟਰਾਂਸਪੋਰਟ
Name[pl]=Serwery pocztowe
Name[pt]=Transporte de Correio
Name[pt_BR]=Transporte de e-mail
Name[ro]=Transport poștal
Name[ru]=Метод отправки
Name[se]=E-boastta fievrridanvuohki
Name[sk]=Mail Transport
Name[sl]=Prenos pošte
Name[sq]=Mail Transport
Name[sr]=Транспорт поште
Name[sr@ijekavian]=Транспорт поште
Name[sr@ijekavianlatin]=Transport pošte
Name[sr@latin]=Transport pošte
Name[sv]=E-postöverföring
Name[th]=เครื่องมือส่งจดหมาย
Name[tr]=E-posta Aktarımı
Name[ug]=خەت(ئېلخەت) ئالاقىسى
Name[uk]=Транспортування пошти
Name[wa]=Berwetaedje d' emile
Name[x-test]=xxMail Transportxx
Name[zh_CN]=邮件传输
Name[zh_TW]=Mail 傳送
07070100000019000041ED000000000000000000000006610B832400000000000000000000000000000000000000000000004500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport0707010000001A000081A4000000000000000000000001610B832400001383000000000000000000000000000000000000005400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/CMakeLists.txtadd_library(KF5MailTransport)
add_library(KF5::MailTransport ALIAS KF5MailTransport)
ecm_setup_version(PROJECT VARIABLE_PREFIX MAILTRANSPORT
    VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/mailtransport_version.h"
    PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportConfigVersion.cmake"
    SOVERSION 5
    )

target_sources(KF5MailTransport PRIVATE
    transport.cpp
    transportmanager.cpp
    transporttype.cpp
    transportjob.cpp
    precommandjob.cpp
    socket.cpp
    servertest.cpp
    )

target_sources(KF5MailTransport PRIVATE
    widgets/transportconfigwidget.cpp
    widgets/transportcombobox.cpp
    widgets/transportlistview.cpp
    widgets/transportmanagementwidget.cpp
    widgets/addtransportdialogng.cpp
    )

target_sources(KF5MailTransport PRIVATE
    plugins/transportabstractplugin.cpp
    plugins/transportpluginmanager.cpp
    )

ecm_qt_declare_logging_category(KF5MailTransport HEADER mailtransport_debug.h IDENTIFIER MAILTRANSPORT_LOG CATEGORY_NAME org.kde.pim.mailtransport
        DESCRIPTION "kmailtransport (kmailtransport)"
        OLD_CATEGORY_NAMES log_mailtransport
        EXPORT MAILTRANSPORT
    )

ki18n_wrap_ui(KF5MailTransport
    ui/addtransportdialog.ui
    ui/transportmanagementwidget.ui
    )

kconfig_add_kcfg_files(KF5MailTransport transportbase.kcfgc)

if (COMPILE_WITH_UNITY_CMAKE_SUPPORT)
    set_target_properties(KF5MailTransport PROPERTIES UNITY_BUILD ON)
endif()

generate_export_header(KF5MailTransport BASE_NAME mailtransport)

target_include_directories(KF5MailTransport INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/MailTransport;${KDE_INSTALL_INCLUDEDIR_KF5}/mailtransport>")
target_include_directories(KF5MailTransport PUBLIC "$<BUILD_INTERFACE:${MailTransport_SOURCE_DIR}/src;${MailTransport_BINARY_DIR}/src>")

target_link_libraries(KF5MailTransport
    PUBLIC
    KF5::Wallet
    PRIVATE
    KF5::I18n
    KF5::ConfigGui
    KF5::WidgetsAddons
    KF5::CoreAddons
    KF5::Wallet
    KF5::ConfigWidgets
    Qt::DBus
    Qt::Network
    qt5keychain
    )

set_target_properties(KF5MailTransport PROPERTIES
    VERSION ${MAILTRANSPORT_VERSION}
    SOVERSION ${MAILTRANSPORT_SOVERSION}
    EXPORT_NAME MailTransport
    )

install(TARGETS KF5MailTransport EXPORT KF5MailTransportTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})

install(FILES mailtransport.kcfg DESTINATION ${KDE_INSTALL_KCFGDIR})

ecm_generate_headers(MailTransport_CamelCase_HEADERS
    HEADER_NAMES
    PrecommandJob
    ServerTest
    Transport
    TransportJob
    TransportManager
    TransportType
    PREFIX MailTransport
    REQUIRED_HEADERS MailTransport_HEADERS
    )

ecm_generate_headers(MailTransport_widgets_CamelCase_HEADERS
    HEADER_NAMES
    TransportComboBox
    TransportManagementWidget
    TransportConfigWidget
    PREFIX MailTransport
    REQUIRED_HEADERS MailTransport_widgets_HEADERS
    RELATIVE widgets
    )

ecm_generate_headers(MailTransport_plugins_CamelCase_HEADERS
    HEADER_NAMES
    TransportAbstractPlugin
    PREFIX MailTransport
    REQUIRED_HEADERS MailTransport_plugins_HEADERS
    RELATIVE plugins
    )

install(FILES
    ${MailTransport_SOURCE_DIR}/src/kmailtransport/widgets/transportconfigwidget_p.h
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/mailtransport/private COMPONENT Devel )

install(FILES
    ${MailTransport_CamelCase_HEADERS}
    ${MailTransport_widgets_CamelCase_HEADERS}
    ${MailTransport_plugins_CamelCase_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/MailTransport/ COMPONENT Devel )

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/mailtransport_export.h
    ${MailTransport_HEADERS}
    ${MailTransport_widgets_HEADERS}
    ${MailTransport_plugins_HEADERS}
    ${CMAKE_CURRENT_BINARY_DIR}/transportbase.h

DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/mailtransport COMPONENT Devel
    )

ecm_generate_pri_file(BASE_NAME KMailTransport LIB_NAME KF5MailTransport DEPS "KWallet" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/MailTransport/)
install(FILES ${PRI_FILENAME} DESTINATION ${ECM_MKSPECS_INSTALL_DIR})

set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5MailTransport")

configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/KF5MailTransportConfig.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportConfig.cmake"
    INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
    )

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportConfigVersion.cmake"
    DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
    COMPONENT Devel
    )

install(EXPORT KF5MailTransportTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KF5MailTransportTargets.cmake NAMESPACE KF5::)

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/mailtransport_version.h
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel
    )

if(BUILD_TESTING)
    add_subdirectory(tests)
    add_subdirectory(plugins/tests)
endif()

add_subdirectory(plugins/smtp)
0707010000001B000081A4000000000000000000000001610B8324000000EB000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/KF5MailTransportConfig.cmake.in@PACKAGE_INIT@

set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_MODULE_PATH})
include(CMakeFindDependencyMacro)
find_dependency(KF5Wallet "@KF5_MIN_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KF5MailTransportTargets.cmake")
0707010000001C000081A4000000000000000000000001610B8324000001C5000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/kmailtransport_private_export.h/*  This file is part of the KDE project
    SPDX-FileCopyrightText: 2007 David Faure <faure@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "mailtransport_export.h"

/* Classes which are exported only for unit tests */
#ifdef BUILD_TESTING
#ifndef KMAILTRANSPORT_TESTS_EXPORT
#define KMAILTRANSPORT_TESTS_EXPORT MAILTRANSPORT_EXPORT
#endif
#else /* not compiling tests */
#define KMAILTRANSPORT_TESTS_EXPORT
#endif

0707010000001D000081A4000000000000000000000001610B8324000013B2000000000000000000000000000000000000005800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/mailtransport.kcfg<?xml version="1.0" encoding="UTF-8"?>
<kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
      http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
  <kcfgfile name="mailtransports">
    <parameter name="transportId" />
  </kcfgfile>

<group name="Transport $(transportId)">
    <entry name="id" type="Int">
      <label>Unique identifier</label>
      <default>0</default>
    </entry>
    <entry name="name" type="String">
      <label>User-visible transport name</label>
      <whatsthis>The name that will be used when referring to this server.</whatsthis>
      <default code="true">i18n("Unnamed")</default>
    </entry>
    <entry name="identifier" type="String">
      <default>SMTP</default>
    </entry>
    <entry name="host" type="String">
      <label>Host name of the server</label>
      <whatsthis>The domain name or numerical address of the SMTP server.</whatsthis>
    </entry>
    <entry name="port" type="UInt">
      <label>Port number of the server</label>
      <whatsthis>The port number that the SMTP server is listening on. The default port is 25.</whatsthis>
      <default>25</default>
    </entry>
    <entry name="userName" type="String" key="user">
      <label>User name needed for login</label>
      <whatsthis>The user name to send to the server for authorization.</whatsthis>
    </entry>
    <entry name="precommand" type="String">
      <label>Command to execute before sending a mail</label>
      <whatsthis>A command to run locally, prior to sending email. This can be used to set up SSH tunnels, for example. Leave it empty if no command should be run.</whatsthis>
    </entry>
    <entry name="options" type="String">
     <label>Options added to mailtransport method</label>
    </entry>	    
    <entry name="requiresAuthentication" type="Bool" key="auth">
      <label>Server requires authentication</label>
      <whatsthis>Check this option if your SMTP server requires authentication before accepting mail. This is known as 'Authenticated SMTP' or simply ASMTP.</whatsthis>
      <default>false</default>
    </entry>
    <entry name="storePassword" type="Bool" key="storepass">
      <label>Store password</label>
      <whatsthis>Check this option to have your password stored.
If KWallet is available the password will be stored there, which is considered safe.
However, if KWallet is not available, the password will be stored in the configuration file. The password is stored in an obfuscated format, but should not be considered secure from decryption efforts if access to the configuration file is obtained.</whatsthis>
      <default>false</default>
    </entry>
    <entry name="encryption" type="Enum">
      <label>Encryption method used for communication</label>
      <choices>
        <choice name="None">
          <label>No encryption</label>
        </choice>
        <choice name="SSL">
          <label>SSL encryption</label>
        </choice>
        <choice name="TLS">
          <label>TLS encryption</label>
        </choice>
      </choices>
    </entry>
    <entry name="authenticationType" type="Enum" key="authtype">
      <label>Authentication method</label>
      <choices>
        
        <choice name="LOGIN"/>
        <choice name="PLAIN"/>
        <choice name="CRAM_MD5"/>
        <choice name="DIGEST_MD5"/>
        <choice name="GSSAPI"/>
        <choice name="NTLM"/>
        <choice name="APOP" />
        <choice name="CLEAR" />
        <choice name="ANONYMOUS" />
        <choice name="XOAUTH2" />
      </choices>
      <default>PLAIN</default>
    </entry>
    <entry name="specifyHostname" type="Bool">
      <label></label>
      <whatsthis>Check this option to use a custom hostname when identifying to the mail server. This is useful when your system's hostname may not be set correctly or to mask your system's true hostname.</whatsthis>
      <default>false</default>
    </entry>
    <entry name="localHostname" type="String">
      <label></label>
      <whatsthis>Enter the hostname that should be used when identifying to the server.</whatsthis>
    </entry>
    <entry name="specifySenderOverwriteAddress" type="Bool">
      <label></label>
      <whatsthis>Check this option to use a custom sender address when identifying to the mail server. If not checked, the address from the identity is used.</whatsthis>
      <default>false</default>
    </entry>
    <entry name="senderOverwriteAddress" type="String">
      <label></label>
      <whatsthis>Enter the address that should be used to overwrite the default sender address.</whatsthis>
    </entry>
    <entry name="useProxy" type="Bool">
      <label>Connect using the system proxy settings</label>
      <whatsthis>If checked, the system proxy settings will be used to connect to the mail server.</whatsthis>
      <default>false</default>
    </entry>
  </group>

</kcfg>
0707010000001E000081A4000000000000000000000001610B8324000004F4000000000000000000000000000000000000005A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/mailtransport_defs.h/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

/**
  @file mailtransport_defs.h
  Internal file containing constant definitions etc.
*/

#define WALLET_FOLDER QStringLiteral("mailtransports")
#define KMAIL_WALLET_FOLDER QStringLiteral("kmail")

#define DBUS_SERVICE_NAME QStringLiteral("org.kde.pim.TransportManager")
#define DBUS_INTERFACE_NAME QStringLiteral("org.kde.pim.TransportManager")
#define DBUS_OBJECT_PATH QStringLiteral("/TransportManager")
#define DBUS_CHANGE_SIGNAL QStringLiteral("changesCommitted")

#define SMTP_PROTOCOL QStringLiteral("smtp")
#define SMTPS_PROTOCOL QStringLiteral("smtps")

#define SMTP_PORT 587
#define SMTP_OLD_PORT 25
#define SMTPS_PORT 465

// Because ServerTest is also capable of testing IMAP,
// some additional defines:

#define IMAP_PROTOCOL QStringLiteral("imap")
#define IMAPS_PROTOCOL QStringLiteral("imaps")

#define POP_PROTOCOL QStringLiteral("pop")
#define POPS_PROTOCOL QStringLiteral("pops")

#define NNTP_PROTOCOL QStringLiteral("nntp")
#define NNTPS_PROTOCOL QStringLiteral("nntps")

#define IMAP_PORT 143
#define IMAPS_PORT 993

#define POP_PORT 110
#define POPS_PORT 995

#define NNTP_PORT 119
#define NNTPS_PORT 563

0707010000001F000041ED000000000000000000000004610B832400000000000000000000000000000000000000000000004D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins07070100000020000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000005200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp07070100000021000081A4000000000000000000000001610B83240000035C000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/CMakeLists.txtif (BUILD_TESTING)
    add_subdirectory(autotests)
endif()
kcoreaddons_add_plugin(mailtransport_smtpplugin JSON smtpmailtransport.json INSTALL_NAMESPACE mailtransport)

target_sources(mailtransport_smtpplugin PRIVATE
    smtpmailtransportplugin.cpp
    smtpconfigdialog.cpp
    smtpjob.cpp
    smtpconfigwidget.cpp
    )
ki18n_wrap_ui(mailtransport_smtpplugin
    smtpsettings.ui
    )
ecm_qt_declare_logging_category(mailtransport_smtpplugin HEADER mailtransportplugin_smtp_debug.h IDENTIFIER MAILTRANSPORT_SMTP_LOG CATEGORY_NAME org.kde.pim.mailtransport.smtpplugin
        DESCRIPTION "kmailtransport (smtp plugin)"
        OLD_CATEGORY_NAMES log_smtp
        EXPORT MAILTRANSPORT
    )

target_link_libraries(mailtransport_smtpplugin
    KF5::MailTransport
    KF5::I18n
    KF5::ConfigWidgets
    KF5::KIOWidgets
    KPim::SMTP
    KPim::GAPICore
    )
07070100000022000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000005C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/autotests07070100000023000081A4000000000000000000000001610B832400000212000000000000000000000000000000000000006B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/autotests/CMakeLists.txtinclude(ECMAddTests)

include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)

ecm_add_test(smtpjobtest.cpp
             ../smtpjob.cpp
             ${CMAKE_CURRENT_BINARY_DIR}/../mailtransportplugin_smtp_debug.cpp
             fakeserver.cpp
    LINK_LIBRARIES Qt::Network
                   Qt::Test
                   KF5::MailTransport
                   KF5::I18n
                   KF5::ConfigWidgets
                   KF5::KIOWidgets
                   KPim::SMTP
                   KPim::GAPICore
    TEST_NAME smtpjobtest
)
07070100000024000081A4000000000000000000000001610B832400001550000000000000000000000000000000000000006B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/autotests/fakeserver.cpp/*
  SPDX-FileCopyrightText: 2010 BetterInbox <contact@betterinbox.com>
  SPDX-FileContributor: Christophe Laveault <christophe@betterinbox.com>
  SPDX-FileContributor: Gregory Schlomoff <gregory.schlomoff@gmail.com>

SPDX-License-Identifier: LGPL-2.1-or-later
*/

#include "fakeserver.h"

#include <QDebug>
#include <QFile>
#include <QTcpServer>
#include <QTest>

FakeServer::FakeServer(QObject *parent)
    : QThread(parent)
    , m_tcpServer(nullptr)
{
    moveToThread(this);
}

QByteArray FakeServer::greeting()
{
    return "S: 220 localhost ESMTP xx777xx";
}

QList<QByteArray> FakeServer::greetingAndEhlo(bool multiline)
{
    return QList<QByteArray>() << greeting() << "C: EHLO 127.0.0.1" << QByteArray("S: 250") + (multiline ? '-' : ' ') + "Localhost ready to roll";
}

QList<QByteArray> FakeServer::bye()
{
    return {"C: QUIT", "S: 221 So long, and thanks for all the fish", "X: "};
}

FakeServer::~FakeServer()
{
    quit();
    wait();
}

void FakeServer::startAndWait()
{
    start();
    // this will block until the event queue starts
    QMetaObject::invokeMethod(this, &FakeServer::started, Qt::BlockingQueuedConnection);
}

void FakeServer::dataAvailable()
{
    QMutexLocker locker(&m_mutex);

auto socket = qobject_cast<QTcpSocket *>(sender());
    Q_ASSERT(socket != nullptr);

int scenarioNumber = m_clientSockets.indexOf(socket);

QVERIFY(!m_scenarios[scenarioNumber].isEmpty());

readClientPart(scenarioNumber);
    writeServerPart(scenarioNumber);
}

void FakeServer::newConnection()
{
    QMutexLocker locker(&m_mutex);

m_clientSockets << m_tcpServer->nextPendingConnection();
    connect(m_clientSockets.last(), &QIODevice::readyRead, this, &FakeServer::dataAvailable);
    // m_clientParsers << new KIMAP::ImapStreamParser( m_clientSockets.last(), true );

QVERIFY(m_clientSockets.size() <= m_scenarios.size());

writeServerPart(m_clientSockets.size() - 1);
}

void FakeServer::run()
{
    m_tcpServer = new QTcpServer();
    if (!m_tcpServer->listen(QHostAddress(QHostAddress::LocalHost), 5989)) {
        qFatal("Unable to start the server");
        return;
    }

connect(m_tcpServer, &QTcpServer::newConnection, this, &FakeServer::newConnection);

exec();

qDeleteAll(m_clientSockets);

delete m_tcpServer;
}

void FakeServer::started()
{
    // do nothing: this is a dummy slot used by startAndWait()
}

void FakeServer::setScenario(const QList<QByteArray> &scenario)
{
    QMutexLocker locker(&m_mutex);

m_scenarios.clear();
    m_scenarios << scenario;
}

void FakeServer::addScenario(const QList<QByteArray> &scenario)
{
    QMutexLocker locker(&m_mutex);

m_scenarios << scenario;
}

void FakeServer::addScenarioFromFile(const QString &fileName)
{
    QFile file(fileName);
    file.open(QFile::ReadOnly);

QList<QByteArray> scenario;

// When loading from files we never have the authentication phase
    // force jumping directly to authenticated state.
    // scenario << preauth();

while (!file.atEnd()) {
        scenario << file.readLine().trimmed();
    }

file.close();

addScenario(scenario);
}

bool FakeServer::isScenarioDone(int scenarioNumber) const
{
    QMutexLocker locker(&m_mutex);

if (scenarioNumber < m_scenarios.size()) {
        return m_scenarios[scenarioNumber].isEmpty();
    } else {
        return true; // Non existent hence empty, right?
    }
}

bool FakeServer::isAllScenarioDone() const
{
    QMutexLocker locker(&m_mutex);

for (const auto &scenario : std::as_const(m_scenarios)) {
        if (!scenario.isEmpty()) {
            qDebug() << scenario;
            return false;
        }
    }

return true;
}

void FakeServer::writeServerPart(int scenarioNumber)
{
    QList<QByteArray> scenario = m_scenarios[scenarioNumber];
    QTcpSocket *clientSocket = m_clientSockets[scenarioNumber];

while (!scenario.isEmpty() && (scenario.first().startsWith("S: ") || scenario.first().startsWith("W: "))) {
        QByteArray rule = scenario.takeFirst();

if (rule.startsWith("S: ")) {
            QByteArray payload = rule.mid(3);
            clientSocket->write(payload + "\r\n");
        } else {
            int timeout = rule.mid(3).toInt();
            QTest::qWait(timeout);
        }
    }

if (!scenario.isEmpty() && scenario.first().startsWith('X')) {
        scenario.takeFirst();
        clientSocket->close();
    }

if (!scenario.isEmpty()) {
        QVERIFY(scenario.first().startsWith("C: "));
    }

m_scenarios[scenarioNumber] = scenario;
}

void FakeServer::readClientPart(int scenarioNumber)
{
    QList<QByteArray> scenario = m_scenarios[scenarioNumber];
    QTcpSocket *clientSocket = m_clientSockets[scenarioNumber];

while (!scenario.isEmpty() && scenario.first().startsWith("C: ")) {
        QByteArray line = clientSocket->readLine();
        QByteArray received = "C: " + line.trimmed();
        QByteArray expected = scenario.takeFirst();

if (expected == "C: SKIP" && !scenario.isEmpty()) {
            expected = scenario.takeFirst();
            while (received != expected) {
                received = "C: " + clientSocket->readLine().trimmed();
            }
        }

QCOMPARE(QString::fromUtf8(received), QString::fromUtf8(expected));
        QCOMPARE(received, expected);
    }

if (!scenario.isEmpty()) {
        QVERIFY(scenario.first().startsWith("S: "));
    }

m_scenarios[scenarioNumber] = scenario;
}
07070100000025000081A4000000000000000000000001610B832400000531000000000000000000000000000000000000006900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/autotests/fakeserver.h/*
  SPDX-FileCopyrightText: 2010 BetterInbox <contact@betterinbox.com>
  SPDX-FileContributor: Christophe Laveault <christophe@betterinbox.com>
  SPDX-FileContributor: Gregory Schlomoff <gregory.schlomoff@gmail.com>

SPDX-License-Identifier: LGPL-2.1-or-later
*/

#pragma once

#include <QMutex>
#include <QTcpSocket>
#include <QThread>

Q_DECLARE_METATYPE(QList<QByteArray>)
class QTcpServer;
class FakeServer : public QThread
{
    Q_OBJECT

public:
    explicit FakeServer(QObject *parent = nullptr);
    ~FakeServer() override;

void startAndWait();
    void run() override;

static QByteArray greeting();
    static QList<QByteArray> greetingAndEhlo(bool multiline = true);
    static QList<QByteArray> bye();

void setScenario(const QList<QByteArray> &scenario);
    void addScenario(const QList<QByteArray> &scenario);
    void addScenarioFromFile(const QString &fileName);
    bool isScenarioDone(int scenarioNumber) const;
    bool isAllScenarioDone() const;

private Q_SLOTS:
    void newConnection();
    void dataAvailable();
    void started();

private:
    void writeServerPart(int scenarioNumber);
    void readClientPart(int scenarioNumber);

QList<QList<QByteArray>> m_scenarios;
    QTcpServer *m_tcpServer = nullptr;
    mutable QMutex m_mutex;
    QList<QTcpSocket *> m_clientSockets;
};

07070100000026000081A4000000000000000000000001610B832400000EE6000000000000000000000000000000000000006C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/autotests/smtpjobtest.cpp/*
    SPDX-FileCopyrightText: 2017 Daniel Vrátil <dvratil@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "../smtpjob.h"
#include "fakeserver.h"

#include "transportbase.h"
#include "transportmanager.h"

#include <QObject>
#include <QStandardPaths>
#include <QTest>

Q_DECLARE_METATYPE(MailTransport::TransportBase::EnumAuthenticationType::type)

class SmtpJobTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void initTestCase()
    {
        QStandardPaths::setTestModeEnabled(true);
    }

void smtpJobTest_data()
    {
        QTest::addColumn<QList<QByteArray>>("scenario");
        QTest::addColumn<MailTransport::TransportBase::EnumAuthenticationType::type>("authType");
        QTest::addColumn<QString>("from");
        QTest::addColumn<QStringList>("to");
        QTest::addColumn<QStringList>("cc");
        QTest::addColumn<QByteArray>("data");
        QTest::addColumn<bool>("success");

QList<QByteArray> scenario;
        scenario << FakeServer::greetingAndEhlo() << "S: 250 AUTH PLAIN LOGIN"
                 << "C: AUTH LOGIN"
                 << "S: 334 VXNlcm5hbWU6"
                 << "C: bG9naW4=" // "login".toBase64()
                 << "S: 334 UGFzc3dvcmQ6"
                 << "C: cGFzc3dvcmQ=" // "password".toBase64()
                 << "S: 235 Authenticated."
                 << "C: MAIL FROM:<foo@bar.com>"
                 << "S: 250 ok"
                 << "C: RCPT TO:<bar@foo.com>"
                 << "S: 250 ok"
                 << "C: RCPT TO:<bar@bar.foo>"
                 << "S: 250 ok"
                 << "C: DATA"
                 << "S: 354 Ok go ahead"
                 << "C: Hi Bob"
                 << "C: "
                 << "C: ."
                 << "S: 250 Ok transfer done" << FakeServer::bye();
        QTest::newRow("simple") << scenario << MailTransport::TransportBase::EnumAuthenticationType::LOGIN << QStringLiteral("Foo Bar <foo@bar.com>")
                                << QStringList{} << QStringList{QStringLiteral("bar@foo.com"), QStringLiteral("<bar@bar.foo>")} << QByteArray("Hi Bob") << true;
    }

void smtpJobTest()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(MailTransport::TransportBase::EnumAuthenticationType::type, authType);
        QFETCH(QString, from);
        QFETCH(QStringList, to);
        QFETCH(QStringList, cc);
        QFETCH(QByteArray, data);
        QFETCH(bool, success);

FakeServer server;
        server.setScenario(scenario);
        server.startAndWait();

auto transport = MailTransport::TransportManager::self()->createTransport();
        transport->setSpecifyHostname(true);
        transport->setHost(QStringLiteral("127.0.0.1"));
        transport->setLocalHostname(QStringLiteral("127.0.0.1"));
        transport->setPort(5989);
        transport->setRequiresAuthentication(true);
        transport->setAuthenticationType(authType);
        transport->setStorePassword(false);
        transport->setUserName(QStringLiteral("login"));
        transport->setPassword(QStringLiteral("password"));

{
            MailTransport::SmtpJob smtpJob(transport);
            smtpJob.setSender(from);
            smtpJob.setTo(to);
            smtpJob.setCc(cc);
            smtpJob.setData(data);

QVERIFY(smtpJob.exec());
            if (success) {
                QCOMPARE(smtpJob.error(), 0);
            } else {
                QVERIFY(smtpJob.error() > 0);
            }

// Make sure the smtpJob goes out-of-scope here and thus the
            // internal session pool is destroyed
        }
        // KSMTP time to stop the session
        QTest::qWait(10);

QVERIFY(server.isAllScenarioDone());
        server.quit();
    }
};

QTEST_MAIN(SmtpJobTest)

#include "smtpjobtest.moc"
07070100000027000081A4000000000000000000000001610B8324000001BD000000000000000000000000000000000000006300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/sessionuiproxy.h/*
  SPDX-FileCopyrightText: 2017 Daniel Vrátil <dvratil@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <KSMTP/SessionUiProxy>
#include <kio/sslui.h>

class SmtpSessionUiProxy : public KSmtp::SessionUiProxy
{
public:
    Q_REQUIRED_RESULT bool ignoreSslError(const KSslErrorUiData &errorData) override
    {
        return KIO::SslUi::askIgnoreSslErrors(errorData, KIO::SslUi::RecallAndStoreRules);
    }
};

07070100000028000081A4000000000000000000000001610B832400000635000000000000000000000000000000000000006700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpconfigdialog.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "smtpconfigdialog.h"

#include "smtpconfigwidget.h"
#include "transport.h"
#include "transportmanager.h"
#include "transporttype.h"

#include <QDialogButtonBox>
#include <QPushButton>
#include <QVBoxLayout>

using namespace MailTransport;

SmtpConfigDialog::SmtpConfigDialog(Transport *transport, QWidget *parent)
    : QDialog(parent)
{
    Q_ASSERT(transport);
    mTransport = transport;
    auto mainLayout = new QVBoxLayout(this);
    mConfigWidget = new SMTPConfigWidget(transport, this);
    mConfigWidget->setObjectName(QStringLiteral("smtpconfigwidget"));
    mainLayout->addWidget(mConfigWidget);
    auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
    buttonBox->setObjectName(QStringLiteral("buttons"));
    mOkButton = buttonBox->button(QDialogButtonBox::Ok);
    mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
    mainLayout->addWidget(buttonBox);

connect(mOkButton, &QAbstractButton::clicked, this, &SmtpConfigDialog::okClicked);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &SmtpConfigDialog::accept);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &SmtpConfigDialog::reject);
}

SmtpConfigDialog::~SmtpConfigDialog()
{
}

void SmtpConfigDialog::okClicked()
{
    mConfigWidget->apply();
    mTransport->save();
}

void SmtpConfigDialog::slotTextChanged(const QString &text)
{
    mOkButton->setEnabled(!text.isEmpty());
}

#include "moc_smtpconfigdialog.cpp"
07070100000029000081A4000000000000000000000001610B83240000027E000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpconfigdialog.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QDialog>

namespace MailTransport
{
class Transport;
class SMTPConfigWidget;
class SmtpConfigDialog : public QDialog
{
    Q_OBJECT
public:
    explicit SmtpConfigDialog(Transport *transport, QWidget *parent = nullptr);
    ~SmtpConfigDialog() override;

private:
    void okClicked();
    void slotTextChanged(const QString &text);

Transport *mTransport = nullptr;
    SMTPConfigWidget *mConfigWidget = nullptr;
    QPushButton *mOkButton = nullptr;
};
} // namespace MailTransport

0707010000002A000081A4000000000000000000000001610B832400003096000000000000000000000000000000000000006700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpconfigwidget.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

Based on MailTransport code by:
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>
    SPDX-FileCopyrightText: 2007 KovoKs <kovoks@kovoks.nl>

Based on KMail code by:
    SPDX-FileCopyrightText: 2001-2002 Michael Haeckel <haeckel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "smtpconfigwidget.h"
#include "ui_smtpsettings.h"

#include "mailtransport_defs.h"
#include "mailtransportplugin_smtp_debug.h"
#include "servertest.h"
#include "transport.h"
#include "transportmanager.h"
#include "widgets/transportconfigwidget_p.h"

#include <QAbstractButton>
#include <QButtonGroup>

#include "mailtransport_debug.h"
#include <KAuthorized>
#include <KMessageBox>
#include <KProtocolInfo>

using namespace MailTransport;

class MailTransport::SMTPConfigWidgetPrivate : public TransportConfigWidgetPrivate
{
public:
    ::Ui::SMTPSettings ui;

ServerTest *serverTest = nullptr;
    QButtonGroup *encryptionGroup = nullptr;

// detected authentication capabilities
    QVector<int> noEncCapa, sslCapa, tlsCapa;

bool serverTestFailed;

static void addAuthenticationItem(QComboBox *combo, int authenticationType)
    {
        combo->addItem(Transport::authenticationTypeString(authenticationType), QVariant(authenticationType));
    }

void resetAuthCapabilities()
    {
        noEncCapa.clear();
        noEncCapa << Transport::EnumAuthenticationType::LOGIN << Transport::EnumAuthenticationType::PLAIN << Transport::EnumAuthenticationType::CRAM_MD5
                  << Transport::EnumAuthenticationType::DIGEST_MD5 << Transport::EnumAuthenticationType::NTLM << Transport::EnumAuthenticationType::GSSAPI
                  << Transport::EnumAuthenticationType::XOAUTH2;
        sslCapa = tlsCapa = noEncCapa;
        updateAuthCapbilities();
    }

void enablePasswordLine()
    {
        ui.password->setEnabled(ui.kcfg_storePassword->isChecked());
    }

void updateAuthCapbilities()
    {
        if (serverTestFailed) {
            return;
        }

QVector<int> capa = noEncCapa;
        if (ui.encryptionSsl->isChecked()) {
            capa = sslCapa;
        } else if (ui.encryptionTls->isChecked()) {
            capa = tlsCapa;
        }

ui.authCombo->clear();
        for (int authType : std::as_const(capa)) {
            addAuthenticationItem(ui.authCombo, authType);
        }

if (transport->isValid()) {
            const int idx = ui.authCombo->findData(transport->authenticationType());

if (idx != -1) {
                ui.authCombo->setCurrentIndex(idx);
            }
        }

if (capa.isEmpty()) {
            ui.noAuthPossible->setVisible(true);
            ui.kcfg_requiresAuthentication->setChecked(false);
            ui.kcfg_requiresAuthentication->setEnabled(false);
            ui.kcfg_requiresAuthentication->setVisible(false);
            ui.authCombo->setEnabled(false);
            ui.authLabel->setEnabled(false);
        } else {
            ui.noAuthPossible->setVisible(false);
            ui.kcfg_requiresAuthentication->setEnabled(true);
            ui.kcfg_requiresAuthentication->setVisible(true);
            ui.authCombo->setEnabled(true);
            ui.authLabel->setEnabled(true);
            enablePasswordLine();
        }
    }
};

SMTPConfigWidget::SMTPConfigWidget(Transport *transport, QWidget *parent)
    : TransportConfigWidget(*new SMTPConfigWidgetPrivate, transport, parent)
{
    init();
}

static void checkHighestEnabledButton(QButtonGroup *group)
{
    Q_ASSERT(group);

for (int i = group->buttons().count() - 1; i >= 0; --i) {
        QAbstractButton *b = group->buttons().at(i);
        if (b && b->isEnabled()) {
            b->animateClick();
            return;
        }
    }
}

void SMTPConfigWidget::init()
{
    Q_D(SMTPConfigWidget);
    d->serverTest = nullptr;

connect(TransportManager::self(), &TransportManager::passwordsChanged, this, &SMTPConfigWidget::passwordsLoaded);

d->serverTestFailed = false;

d->ui.setupUi(this);
    d->ui.password->setRevealPasswordAvailable(KAuthorized::authorize(QStringLiteral("lineedit_reveal_password")));
    d->manager->addWidget(this); // otherwise it doesn't find out about these widgets
    d->manager->updateWidgets();

d->ui.password->setWhatsThis(i18n("The password to send to the server for authorization."));

d->ui.kcfg_userName->setClearButtonEnabled(true);
    d->encryptionGroup = new QButtonGroup(this);
    d->encryptionGroup->addButton(d->ui.encryptionNone, Transport::EnumEncryption::None);
    d->encryptionGroup->addButton(d->ui.encryptionSsl, Transport::EnumEncryption::SSL);
    d->encryptionGroup->addButton(d->ui.encryptionTls, Transport::EnumEncryption::TLS);

d->ui.encryptionNone->setChecked(d->transport->encryption() == Transport::EnumEncryption::None);
    d->ui.encryptionSsl->setChecked(d->transport->encryption() == Transport::EnumEncryption::SSL);
    d->ui.encryptionTls->setChecked(d->transport->encryption() == Transport::EnumEncryption::TLS);

d->resetAuthCapabilities();

if (!KProtocolInfo::capabilities(SMTP_PROTOCOL).contains(QLatin1String("SASL"))) {
        d->ui.authCombo->removeItem(d->ui.authCombo->findData(Transport::EnumAuthenticationType::NTLM));
        d->ui.authCombo->removeItem(d->ui.authCombo->findData(Transport::EnumAuthenticationType::GSSAPI));
    }

connect(d->ui.checkCapabilities, &QPushButton::clicked, this, &SMTPConfigWidget::checkSmtpCapabilities);
    connect(d->ui.kcfg_host, &QLineEdit::textChanged, this, &SMTPConfigWidget::hostNameChanged);

connect(d->encryptionGroup, qOverload<QAbstractButton *>(&QButtonGroup::buttonClicked), this, &SMTPConfigWidget::encryptionAbstractButtonChanged);
    connect(d->ui.kcfg_requiresAuthentication, &QCheckBox::toggled, this, &SMTPConfigWidget::ensureValidAuthSelection);
    connect(d->ui.kcfg_storePassword, &QCheckBox::toggled, this, &SMTPConfigWidget::enablePasswordLine);
    if (!d->transport->isValid()) {
        checkHighestEnabledButton(d->encryptionGroup);
    }

// load the password
    d->transport->updatePasswordState();
    if (d->transport->isComplete()) {
        d->ui.password->setPassword(d->transport->password());
    } else {
        if (d->transport->requiresAuthentication()) {
            TransportManager::self()->loadPasswordsAsync();
        }
    }

hostNameChanged(d->transport->host());
}

void SMTPConfigWidget::enablePasswordLine()
{
    Q_D(SMTPConfigWidget);
    d->enablePasswordLine();
}

void SMTPConfigWidget::checkSmtpCapabilities()
{
    Q_D(SMTPConfigWidget);

d->serverTest = new ServerTest(this);
    d->serverTest->setProtocol(SMTP_PROTOCOL);
    d->serverTest->setServer(d->ui.kcfg_host->text().trimmed());
    if (d->ui.kcfg_specifyHostname->isChecked()) {
        d->serverTest->setFakeHostname(d->ui.kcfg_localHostname->text());
    }
    QAbstractButton *encryptionChecked = d->encryptionGroup->checkedButton();
    if (encryptionChecked == d->ui.encryptionNone) {
        d->serverTest->setPort(Transport::EnumEncryption::None, d->ui.kcfg_port->value());
    } else if (encryptionChecked == d->ui.encryptionSsl) {
        d->serverTest->setPort(Transport::EnumEncryption::SSL, d->ui.kcfg_port->value());
    }
    d->serverTest->setProgressBar(d->ui.checkCapabilitiesProgress);
    d->ui.checkCapabilitiesStack->setCurrentIndex(1);
    qApp->setOverrideCursor(Qt::BusyCursor);

connect(d->serverTest, &ServerTest::finished, this, &SMTPConfigWidget::slotFinished);
    connect(d->serverTest, &ServerTest::finished, qApp, []() {
        qApp->restoreOverrideCursor();
    });
    d->ui.checkCapabilities->setEnabled(false);
    d->serverTest->start();
    d->serverTestFailed = false;
}

void SMTPConfigWidget::apply()
{
    Q_D(SMTPConfigWidget);
    Q_ASSERT(d->manager);
    d->manager->updateSettings();
    if (!d->ui.kcfg_storePassword->isChecked() && d->ui.kcfg_requiresAuthentication->isChecked()) {
        // Delete stored password
        TransportManager::self()->removePasswordFromWallet(d->transport->id());
    }
    d->transport->setPassword(d->ui.password->password());

KConfigGroup group(d->transport->config(), d->transport->currentGroup());
    const int index = d->ui.authCombo->currentIndex();
    if (index >= 0) {
        group.writeEntry("authtype", d->ui.authCombo->itemData(index).toInt());
    }

if (d->ui.encryptionNone->isChecked()) {
        d->transport->setEncryption(Transport::EnumEncryption::None);
    } else if (d->ui.encryptionSsl->isChecked()) {
        d->transport->setEncryption(Transport::EnumEncryption::SSL);
    } else if (d->ui.encryptionTls->isChecked()) {
        d->transport->setEncryption(Transport::EnumEncryption::TLS);
    }

TransportConfigWidget::apply();
}

void SMTPConfigWidget::passwordsLoaded()
{
    Q_D(SMTPConfigWidget);

// Load the password from the original to our cloned copy
    d->transport->updatePasswordState();

if (d->ui.password->password().isEmpty()) {
        d->ui.password->setPassword(d->transport->password());
    }
}

// TODO rename
void SMTPConfigWidget::slotFinished(const QVector<int> &results)
{
    Q_D(SMTPConfigWidget);

d->ui.checkCapabilitiesStack->setCurrentIndex(0);

d->ui.checkCapabilities->setEnabled(true);
    d->serverTest->deleteLater();

// If the servertest did not find any usable authentication modes, assume the
    // connection failed and don't disable any of the radioboxes.
    if (results.isEmpty()) {
        KMessageBox::error(this, i18n("Failed to check capabilities. Please verify port and authentication mode."), i18n("Check Capabilities Failed"));
        d->serverTestFailed = true;
        d->serverTest->deleteLater();
        return;
    }

// encryption method
    d->ui.encryptionNone->setEnabled(results.contains(Transport::EnumEncryption::None));
    d->ui.encryptionSsl->setEnabled(results.contains(Transport::EnumEncryption::SSL));
    d->ui.encryptionTls->setEnabled(results.contains(Transport::EnumEncryption::TLS));
    checkHighestEnabledButton(d->encryptionGroup);

d->noEncCapa = d->serverTest->normalProtocols();
    if (d->ui.encryptionTls->isEnabled()) {
        d->tlsCapa = d->serverTest->tlsProtocols();
    } else {
        d->tlsCapa.clear();
    }
    d->sslCapa = d->serverTest->secureProtocols();
    d->updateAuthCapbilities();
    // Show correct port from capabilities.
    if (d->ui.encryptionSsl->isEnabled()) {
        const int portValue = d->serverTest->port(Transport::EnumEncryption::SSL);
        d->ui.kcfg_port->setValue(portValue == -1 ? SMTPS_PORT : portValue);
    } else if (d->ui.encryptionNone->isEnabled()) {
        const int portValue = d->serverTest->port(Transport::EnumEncryption::None);
        d->ui.kcfg_port->setValue(portValue == -1 ? SMTP_PORT : portValue);
    }
    d->serverTest->deleteLater();
}

void SMTPConfigWidget::hostNameChanged(const QString &text)
{
    // TODO: really? is this done at every change? wtf

Q_D(SMTPConfigWidget);

// sanitize hostname...
    const int pos = d->ui.kcfg_host->cursorPosition();
    d->ui.kcfg_host->blockSignals(true);
    d->ui.kcfg_host->setText(text.trimmed());
    d->ui.kcfg_host->blockSignals(false);
    d->ui.kcfg_host->setCursorPosition(pos);

d->resetAuthCapabilities();
    if (d->encryptionGroup) {
        for (int i = 0; i < d->encryptionGroup->buttons().count(); ++i) {
            d->encryptionGroup->buttons().at(i)->setEnabled(true);
        }
    }
}

void SMTPConfigWidget::ensureValidAuthSelection()
{
    Q_D(SMTPConfigWidget);

// adjust available authentication methods
    d->updateAuthCapbilities();
    d->enablePasswordLine();
}

void SMTPConfigWidget::encryptionAbstractButtonChanged(QAbstractButton *button)
{
    Q_D(SMTPConfigWidget);
    if (button) {
        encryptionChanged(d->encryptionGroup->id(button));
    }
}

void SMTPConfigWidget::encryptionChanged(int enc)
{
    Q_D(SMTPConfigWidget);
    qCDebug(MAILTRANSPORT_SMTP_LOG) << enc;

// adjust port
    if (enc == Transport::EnumEncryption::SSL) {
        if (d->ui.kcfg_port->value() == SMTP_PORT) {
            d->ui.kcfg_port->setValue(SMTPS_PORT);
        }
    } else {
        if (d->ui.kcfg_port->value() == SMTPS_PORT) {
            d->ui.kcfg_port->setValue(SMTP_PORT);
        }
    }

ensureValidAuthSelection();
}
0707010000002B000081A4000000000000000000000001610B8324000004DE000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpconfigwidget.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

Based on MailTransport code by:
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
    SPDX-FileCopyrightText: 2001-2002 Michael Haeckel <haeckel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "widgets/transportconfigwidget.h"
class QAbstractButton;
namespace MailTransport
{
class Transport;

/**
  @internal
*/
class SMTPConfigWidgetPrivate;

/**
  @internal
  Configuration widget for a SMTP transport.
*/
class SMTPConfigWidget : public TransportConfigWidget
{
    Q_OBJECT

public:
    explicit SMTPConfigWidget(Transport *transport, QWidget *parent = nullptr);

public Q_SLOTS:
    /** reimpl */
    void apply() override;

private Q_SLOTS:
    void checkSmtpCapabilities();
    void passwordsLoaded();
    void slotFinished(const QVector<int> &results);
    void hostNameChanged(const QString &text);
    void encryptionChanged(int enc);
    void ensureValidAuthSelection();

private:
    void encryptionAbstractButtonChanged(QAbstractButton *button);
    Q_DECLARE_PRIVATE(SMTPConfigWidget)

void init();
    void enablePasswordLine();
};
} // namespace MailTransport

0707010000002C000081A4000000000000000000000001610B83240000345C000000000000000000000000000000000000005E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpjob.cpp/*
  SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
  SPDX-FileCopyrightText: 1996-1998 Stefan Taferner <taferner@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "smtpjob.h"
#include "mailtransport_defs.h"
#include "mailtransportplugin_smtp_debug.h"
#include "precommandjob.h"
#include "sessionuiproxy.h"
#include "transport.h"
#include <KAuthorized>
#include <QHash>
#include <QPointer>
#include <kwidgetsaddons_version.h>

#include "mailtransport_debug.h"
#include <KLocalizedString>
#include <KPasswordDialog>

#include <KSMTP/LoginJob>
#include <KSMTP/SendJob>

#include <KGAPI/Account>
#include <KGAPI/AccountManager>
#include <KGAPI/AuthJob>

#define GOOGLE_API_KEY QStringLiteral("554041944266.apps.googleusercontent.com")
#define GOOGLE_API_SECRET QStringLiteral("mdT1DjzohxN3npUUzkENT0gO")

using namespace MailTransport;

class SessionPool
{
public:
    int ref = 0;
    QHash<int, KSmtp::Session *> sessions;

void removeSession(KSmtp::Session *session)
    {
        qCDebug(MAILTRANSPORT_SMTP_LOG) << "Removing session" << session << "from the pool";
        int key = sessions.key(session);
        if (key > 0) {
            QObject::connect(session, &KSmtp::Session::stateChanged, [session](KSmtp::Session::State state) {
                if (state == KSmtp::Session::Disconnected) {
                    session->deleteLater();
                }
            });
            session->quit();
            sessions.remove(key);
        }
    }
};

Q_GLOBAL_STATIC(SessionPool, s_sessionPool)

/**
 * Private class that helps to provide binary compatibility between releases.
 * @internal
 */
class SmtpJobPrivate
{
public:
    SmtpJobPrivate(SmtpJob *parent)
        : q(parent)
    {
    }

void doLogin();

SmtpJob *const q;
    KSmtp::Session *session = nullptr;
    KSmtp::SessionUiProxy::Ptr uiProxy;
    enum State { Idle, Precommand, Smtp } currentState;
    bool finished;
};

SmtpJob::SmtpJob(Transport *transport, QObject *parent)
    : TransportJob(transport, parent)
    , d(new SmtpJobPrivate(this))
{
    d->currentState = SmtpJobPrivate::Idle;
    d->session = nullptr;
    d->finished = false;
    d->uiProxy = KSmtp::SessionUiProxy::Ptr(new SmtpSessionUiProxy);
    if (!s_sessionPool.isDestroyed()) {
        s_sessionPool->ref++;
    }
}

SmtpJob::~SmtpJob()
{
    if (!s_sessionPool.isDestroyed()) {
        s_sessionPool->ref--;
        if (s_sessionPool->ref == 0) {
            qCDebug(MAILTRANSPORT_SMTP_LOG) << "clearing SMTP session pool" << s_sessionPool->sessions.count();
            while (!s_sessionPool->sessions.isEmpty()) {
                s_sessionPool->removeSession(*(s_sessionPool->sessions.begin()));
            }
        }
    }
    delete d;
}

void SmtpJob::doStart()
{
    if (s_sessionPool.isDestroyed()) {
        return;
    }

if ((!s_sessionPool->sessions.isEmpty() && s_sessionPool->sessions.contains(transport()->id())) || transport()->precommand().isEmpty()) {
        d->currentState = SmtpJobPrivate::Smtp;
        startSmtpJob();
    } else {
        d->currentState = SmtpJobPrivate::Precommand;
        auto job = new PrecommandJob(transport()->precommand(), this);
        addSubjob(job);
        job->start();
    }
}

void SmtpJob::startSmtpJob()
{
    if (s_sessionPool.isDestroyed()) {
        return;
    }

d->session = s_sessionPool->sessions.value(transport()->id());
    if (!d->session) {
        d->session = new KSmtp::Session(transport()->host(), transport()->port());
        d->session->setUseNetworkProxy(transport()->useProxy());
        d->session->setUiProxy(d->uiProxy);
        if (transport()->specifyHostname()) {
            d->session->setCustomHostname(transport()->localHostname());
        }
        s_sessionPool->sessions.insert(transport()->id(), d->session);
    }

connect(d->session, &KSmtp::Session::stateChanged, this, &SmtpJob::sessionStateChanged, Qt::UniqueConnection);
    connect(d->session, &KSmtp::Session::connectionError, this, [this](const QString &err) {
        setError(KJob::UserDefinedError);
        setErrorText(err);
        s_sessionPool->removeSession(d->session);
        emitResult();
    });

if (d->session->state() == KSmtp::Session::Disconnected) {
        d->session->open();
    } else {
        if (d->session->state() != KSmtp::Session::Authenticated) {
            startPasswordRetrieval();
        }

startSendJob();
    }
}

void SmtpJob::sessionStateChanged(KSmtp::Session::State state)
{
    if (state == KSmtp::Session::Ready) {
        startPasswordRetrieval();
    } else if (state == KSmtp::Session::Authenticated) {
        startSendJob();
    }
}

void SmtpJob::startPasswordRetrieval(bool forceRefresh)
{
    if (!transport()->requiresAuthentication() && !forceRefresh) {
        startSendJob();
        return;
    }

if (transport()->authenticationType() == TransportBase::EnumAuthenticationType::XOAUTH2) {
        auto promise = KGAPI2::AccountManager::instance()->findAccount(GOOGLE_API_KEY, transport()->userName(), {KGAPI2::Account::mailScopeUrl()});
        connect(promise, &KGAPI2::AccountPromise::finished, this, [forceRefresh, this](KGAPI2::AccountPromise *promise) {
            if (promise->account()) {
                if (forceRefresh) {
                    promise = KGAPI2::AccountManager::instance()->refreshTokens(GOOGLE_API_KEY, GOOGLE_API_SECRET, transport()->userName());
                } else {
                    onTokenRequestFinished(promise);
                    return;
                }
            } else {
                promise = KGAPI2::AccountManager::instance()->getAccount(GOOGLE_API_KEY,
                                                                         GOOGLE_API_SECRET,
                                                                         transport()->userName(),
                                                                         {KGAPI2::Account::mailScopeUrl()});
            }
            connect(promise, &KGAPI2::AccountPromise::finished, this, &SmtpJob::onTokenRequestFinished);
        });
    } else {
        startLoginJob();
    }
}

void SmtpJob::onTokenRequestFinished(KGAPI2::AccountPromise *promise)
{
    if (promise->hasError()) {
        qCWarning(MAILTRANSPORT_SMTP_LOG) << "Error obtaining XOAUTH2 token:" << promise->errorText();
        setError(KJob::UserDefinedError);
        setErrorText(promise->errorText());
        emitResult();
        return;
    }

const auto account = promise->account();
    const QString tokens = QStringLiteral("%1\001%2").arg(account->accessToken(), account->refreshToken());
    transport()->setPassword(tokens);
    startLoginJob();
}

void SmtpJob::startLoginJob()
{
    if (!transport()->requiresAuthentication()) {
        startSendJob();
        return;
    }

auto user = transport()->userName();
    auto passwd = transport()->password();
    if ((user.isEmpty() || passwd.isEmpty()) && transport()->authenticationType() != Transport::EnumAuthenticationType::GSSAPI) {
        QPointer<KPasswordDialog> dlg = new KPasswordDialog(nullptr, KPasswordDialog::ShowUsernameLine | KPasswordDialog::ShowKeepPassword);
        dlg->setAttribute(Qt::WA_DeleteOnClose, true);
        dlg->setPrompt(
            i18n("You need to supply a username and a password "
                 "to use this SMTP server."));
        dlg->setKeepPassword(transport()->storePassword());
        dlg->addCommentLine(QString(), transport()->name());
        dlg->setUsername(user);
        dlg->setPassword(passwd);
#if KWIDGETSADDONS_VERSION >= QT_VERSION_CHECK(5, 84, 0)
        dlg->setRevealPasswordAvailable(KAuthorized::authorize(QStringLiteral("lineedit_reveal_password")));
#endif

connect(this, &KJob::result, dlg, &QDialog::reject);

connect(dlg, &QDialog::finished, this, [this, dlg](const int result) {
            if (result == QDialog::Rejected) {
                setError(KilledJobError);
                emitResult();
                return;
            }

transport()->setUserName(dlg->username());
            transport()->setPassword(dlg->password());
            transport()->setStorePassword(dlg->keepPassword());
            transport()->save();

d->doLogin();
        });
        dlg->open();

return;
    }

d->doLogin();
}

void SmtpJobPrivate::doLogin()
{
    QString passwd = q->transport()->password();
    if (q->transport()->authenticationType() == Transport::EnumAuthenticationType::XOAUTH2) {
        passwd = passwd.left(passwd.indexOf(QLatin1Char('\001')));
    }

auto login = new KSmtp::LoginJob(session);
    login->setUserName(q->transport()->userName());
    login->setPassword(passwd);
    switch (q->transport()->authenticationType()) {
    case TransportBase::EnumAuthenticationType::PLAIN:
        login->setPreferedAuthMode(KSmtp::LoginJob::Plain);
        break;
    case TransportBase::EnumAuthenticationType::LOGIN:
        login->setPreferedAuthMode(KSmtp::LoginJob::Login);
        break;
    case TransportBase::EnumAuthenticationType::CRAM_MD5:
        login->setPreferedAuthMode(KSmtp::LoginJob::CramMD5);
        break;
    case TransportBase::EnumAuthenticationType::XOAUTH2:
        login->setPreferedAuthMode(KSmtp::LoginJob::XOAuth2);
        break;
    case TransportBase::EnumAuthenticationType::DIGEST_MD5:
        login->setPreferedAuthMode(KSmtp::LoginJob::DigestMD5);
        break;
    case TransportBase::EnumAuthenticationType::NTLM:
        login->setPreferedAuthMode(KSmtp::LoginJob::NTLM);
        break;
    case TransportBase::EnumAuthenticationType::GSSAPI:
        login->setPreferedAuthMode(KSmtp::LoginJob::GSSAPI);
        break;
    default:
        qCWarning(MAILTRANSPORT_SMTP_LOG) << "Unknown authentication mode" << q->transport()->authenticationTypeString();
        break;
    }

switch (q->transport()->encryption()) {
    case Transport::EnumEncryption::None:
        login->setEncryptionMode(KSmtp::LoginJob::Unencrypted);
        break;
    case Transport::EnumEncryption::TLS:
        login->setEncryptionMode(KSmtp::LoginJob::STARTTLS);
        break;
    case Transport::EnumEncryption::SSL:
        login->setEncryptionMode(KSmtp::LoginJob::SSLorTLS);
        break;
    default:
        qCWarning(MAILTRANSPORT_SMTP_LOG) << "Unknown encryption mode" << q->transport()->encryption();
        break;
    }

q->connect(login, &KJob::result, q, &SmtpJob::slotResult);
    q->addSubjob(login);
    login->start();
    qCDebug(MAILTRANSPORT_SMTP_LOG) << "Login started";
}

void SmtpJob::startSendJob()
{
    auto send = new KSmtp::SendJob(d->session);
    send->setFrom(sender());
    send->setTo(to());
    send->setCc(cc());
    send->setBcc(bcc());
    send->setData(data());

addSubjob(send);
    send->start();

qCDebug(MAILTRANSPORT_SMTP_LOG) << "Send started";
}

bool SmtpJob::doKill()
{
    if (s_sessionPool.isDestroyed()) {
        return false;
    }

if (!hasSubjobs()) {
        return true;
    }
    if (d->currentState == SmtpJobPrivate::Precommand) {
        return subjobs().first()->kill();
    } else if (d->currentState == SmtpJobPrivate::Smtp) {
        clearSubjobs();
        s_sessionPool->removeSession(d->session);
        return true;
    }
    return false;
}

void SmtpJob::slotResult(KJob *job)
{
    if (s_sessionPool.isDestroyed()) {
        return;
    }

if (qobject_cast<KSmtp::LoginJob *>(job)) {
        if (job->error() == KSmtp::LoginJob::TokenExpired) {
            startPasswordRetrieval(/*force refresh */ true);
            return;
        }
    }

// The job has finished, so we don't care about any further errors. Set
    // d->finished to true, so slaveError() knows about this and doesn't call
    // emitResult() anymore.
    // Sometimes, the SMTP slave emits more than one error
    //
    // The first error causes slotResult() to be called, but not slaveError(), since
    // the scheduler doesn't emit errors for connected slaves.
    //
    // The second error then causes slaveError() to be called (as the slave is no
    // longer connected), which does emitResult() a second time, which is invalid
    // (and triggers an assert in KMail).
    d->finished = true;

// Normally, calling TransportJob::slotResult() would set the proper error code
    // for error() via KComposite::slotResult(). However, we can't call that here,
    // since that also emits the result signal.
    // In KMail, when there are multiple mails in the outbox, KMail tries to send
    // the next mail when it gets the result signal, which then would reuse the
    // old broken slave from the slave pool if there was an error.
    // To prevent that, we call TransportJob::slotResult() only after removing the
    // slave from the pool and calculate the error code ourselves.
    int errorCode = error();
    if (!errorCode) {
        errorCode = job->error();
    }

if (errorCode && d->currentState == SmtpJobPrivate::Smtp) {
        s_sessionPool->removeSession(d->session);
        TransportJob::slotResult(job);
        return;
    }

TransportJob::slotResult(job);
    if (!error() && d->currentState == SmtpJobPrivate::Precommand) {
        d->currentState = SmtpJobPrivate::Smtp;
        startSmtpJob();
        return;
    }
    if (!error() && !hasSubjobs()) {
        emitResult();
    }
}

#include "moc_smtpjob.cpp"
0707010000002D000081A4000000000000000000000001610B8324000006A3000000000000000000000000000000000000005C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpjob.h/*
    SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
    SPDX-FileCopyrightText: 1996-1998 Stefan Taferner <taferner@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <KSMTP/Session>
#include <transportjob.h>

namespace KIO
{
class Job;
class Slave;
}

namespace KGAPI2
{
class AccountPromise;
}

class SmtpJobPrivate;

namespace MailTransport
{
/**
  Mail transport job for SMTP.
  Internally, all jobs for a specific transport are queued to use the same
  KIO::Slave. This avoids multiple simultaneous connections to the server,
  which is not always allowed. Also, re-using an already existing connection
  avoids the login overhead and can improve performance.

Precommands are automatically executed, once per opening a connection to the
  server (not necessarily once per message).
*/
class SmtpJob : public TransportJob
{
    Q_OBJECT
public:
    /**
      Creates a SmtpJob.
      @param transport The transport settings.
      @param parent The parent object.
    */
    explicit SmtpJob(Transport *transport, QObject *parent = nullptr);

/**
      Deletes this job.
    */
    ~SmtpJob() override;

protected:
    void doStart() override;
    bool doKill() override;

protected Q_SLOTS:
    void slotResult(KJob *job) override;
    void sessionStateChanged(KSmtp::Session::State state);

private:
    void startPasswordRetrieval(bool forceRefresh = false);
    void onTokenRequestFinished(KGAPI2::AccountPromise *result);
    void startSmtpJob();
    void startLoginJob();
    void startSendJob();

private:
    friend class ::SmtpJobPrivate;
    SmtpJobPrivate *const d;
};
} // namespace MailTransport

0707010000002E000081A4000000000000000000000001610B832400000746000000000000000000000000000000000000006900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpmailtransport.json{
    "KPlugin": {
        "Id": "smtpmailtransport",
        "Name": "SMTP Mail Transport",
        "Name[ar]": "نقولات بريد SMTP",
        "Name[ca@valencia]": "Transport de correu SMTP",
        "Name[ca]": "Transport de correu SMTP",
        "Name[cs]": "Přenos pošty SMTP",
        "Name[da]": "SMTP mailtransport",
        "Name[de]": "SMTP-E-Mailtransport",
        "Name[el]": "SMTP ηλεκτρονικό ταχυδρομείο",
        "Name[en_GB]": "SMTP Mail Transport",
        "Name[es]": "Transporte de correo SMTP",
        "Name[et]": "SMTP kirja saatmise viis",
        "Name[fi]": "SMTP-postinvälitys",
        "Name[fr]": "Transport de courrier électronique SMTP",
        "Name[gl]": "Transporte de correo SMTP",
        "Name[ia]": "Transporto de Posta SMTP",
        "Name[it]": "Trasporto della posta SMTP",
        "Name[ko]": "SMTP 메일 전송",
        "Name[nl]": "E-mailtransport SMTP",
        "Name[nn]": "SMTP-e-postoverførring",
        "Name[pl]": "Serwery pocztowe SMTP",
        "Name[pt]": "Transporte de E-mail SMTP",
        "Name[pt_BR]": "Transporte de e-mail SMTP",
        "Name[ru]": "Метод отправки SMTP",
        "Name[sk]": "Prenos pošty SMTP",
        "Name[sl]": "Prenos pošte SMTP",
        "Name[sr@ijekavian]": "Транспорт поште СМТП‑ом",
        "Name[sr@ijekavianlatin]": "Transport pošte SMTP‑om",
        "Name[sr@latin]": "Transport pošte SMTP‑om",
        "Name[sr]": "Транспорт поште СМТП‑ом",
        "Name[sv]": "SMTP e-postöverföring",
        "Name[tr]": "SMTP Posta Aktarımı",
        "Name[uk]": "Надсилання пошти SMTP",
        "Name[x-test]": "xxSMTP Mail Transportxx",
        "Name[zh_CN]": "SMTP 邮件传输",
        "Name[zh_TW]": "SMTP 郵件傳輸",
        "Version": "1.0"
    }
}
0707010000002F000081A4000000000000000000000001610B8324000006B8000000000000000000000000000000000000006E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpmailtransportplugin.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "smtpmailtransportplugin.h"
#include "smtpconfigdialog.h"
#include "smtpjob.h"
#include <KLocalizedString>
#include <KPluginFactory>

K_PLUGIN_CLASS_WITH_JSON(SMTPMailTransportPlugin, "smtpmailtransport.json")

SMTPMailTransportPlugin::SMTPMailTransportPlugin(QObject *parent, const QList<QVariant> &)
    : MailTransport::TransportAbstractPlugin(parent)
{
}

SMTPMailTransportPlugin::~SMTPMailTransportPlugin()
{
}

QVector<MailTransport::TransportAbstractPluginInfo> SMTPMailTransportPlugin::names() const
{
    MailTransport::TransportAbstractPluginInfo info;

info.name = i18nc("@option SMTP transport", "SMTP");
    info.description = i18n("An SMTP server on the Internet");
    info.identifier = QStringLiteral("SMTP");
    info.isAkonadi = false;
    return QVector<MailTransport::TransportAbstractPluginInfo>() << info;
}

bool SMTPMailTransportPlugin::configureTransport(const QString &identifier, MailTransport::Transport *transport, QWidget *parent)
{
    Q_UNUSED(identifier)
    QPointer<MailTransport::SmtpConfigDialog> transportConfigDialog = new MailTransport::SmtpConfigDialog(transport, parent);
    transportConfigDialog->setWindowTitle(i18nc("@title:window", "Configure account"));
    bool okClicked = (transportConfigDialog->exec() == QDialog::Accepted);
    delete transportConfigDialog;
    return okClicked;
}

MailTransport::TransportJob *SMTPMailTransportPlugin::createTransportJob(MailTransport::Transport *t, const QString &identifier)
{
    Q_UNUSED(identifier)
    return new MailTransport::SmtpJob(t, this);
}

#include "smtpmailtransportplugin.moc"
07070100000030000081A4000000000000000000000001610B832400000336000000000000000000000000000000000000006C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpmailtransportplugin.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <MailTransport/TransportAbstractPlugin>
#include <QVariant>

class SMTPMailTransportPlugin : public MailTransport::TransportAbstractPlugin
{
    Q_OBJECT
public:
    explicit SMTPMailTransportPlugin(QObject *parent = nullptr, const QList<QVariant> & = {});
    ~SMTPMailTransportPlugin() override;

Q_REQUIRED_RESULT QVector<MailTransport::TransportAbstractPluginInfo> names() const override;
    Q_REQUIRED_RESULT bool configureTransport(const QString &identifier, MailTransport::Transport *transport, QWidget *parent) override;
    Q_REQUIRED_RESULT MailTransport::TransportJob *createTransportJob(MailTransport::Transport *t, const QString &identifier) override;
};

07070100000031000081A4000000000000000000000001610B8324000045B1000000000000000000000000000000000000006200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/smtp/smtpsettings.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <author>Volker Krause &lt;vkrause@kde.org&gt;, KovoKs &lt;tomalbers@kde.nl&gt;</author>
 <class>SMTPSettings</class>
 <widget class="QWidget" name="SMTPSettings">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>411</width>
    <height>474</height>
   </rect>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item>
    <widget class="QTabWidget" name="tabWidget">
     <property name="currentIndex">
      <number>0</number>
     </property>
     <widget class="QWidget" name="smptTab">
      <attribute name="title">
       <string comment="general smtp settings">General</string>
      </attribute>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QGroupBox" name="groupBox">
         <property name="title">
          <string>Account Information</string>
         </property>
         <layout class="QGridLayout" name="gridLayout">
          <item row="0" column="0">
           <widget class="QLabel" name="hostLabel">
            <property name="text">
             <string>Outgoing &amp;mail server:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>kcfg_host</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="KLineEdit" name="kcfg_host">
            <property name="trapEnterKeyEvent" stdset="0">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="usernameLabel">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="text">
             <string>&amp;Login:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>kcfg_userName</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KLineEdit" name="kcfg_userName">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="trapEnterKeyEvent" stdset="0">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="passwordLabel">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="text">
             <string>P&amp;assword:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>password</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="KPasswordLineEdit" name="password">
            <property name="enabled">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="QCheckBox" name="kcfg_storePassword">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="text">
             <string>&amp;Store SMTP password</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QCheckBox" name="kcfg_requiresAuthentication">
            <property name="text">
             <string>Server &amp;requires authentication</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
     <widget class="QWidget" name="advancedTab">
      <attribute name="title">
       <string comment="advanced smtp settings">Advanced</string>
      </attribute>
      <layout class="QVBoxLayout" name="verticalLayout_7">
       <item>
        <widget class="QGroupBox" name="encryptionGroup">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="title">
          <string>Connection Settings</string>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout_5">
          <item>
           <widget class="QStackedWidget" name="checkCapabilitiesStack">
            <property name="currentIndex">
             <number>0</number>
            </property>
            <widget class="QWidget" name="page">
             <layout class="QVBoxLayout" name="verticalLayout_3">
              <item>
               <widget class="QPushButton" name="checkCapabilities">
                <property name="text">
                 <string>Auto Detect</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
            <widget class="QWidget" name="page_2">
             <layout class="QVBoxLayout" name="verticalLayout_4">
              <item>
               <widget class="QProgressBar" name="checkCapabilitiesProgress">
                <property name="value">
                 <number>0</number>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="noAuthPossible">
            <property name="visible">
             <bool>false</bool>
            </property>
            <property name="frameShape">
             <enum>QFrame::Box</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Plain</enum>
            </property>
            <property name="lineWidth">
             <number>0</number>
            </property>
            <property name="text">
             <string>This server does not support authentication</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignCenter</set>
            </property>
           </widget>
          </item>
          <item>
           <layout class="QFormLayout" name="formLayout_2">
            <property name="fieldGrowthPolicy">
             <enum>QFormLayout::ExpandingFieldsGrow</enum>
            </property>
            <item row="0" column="0">
             <widget class="QLabel" name="label">
              <property name="text">
               <string>Encryption:</string>
              </property>
             </widget>
            </item>
            <item row="0" column="1">
             <layout class="QHBoxLayout" name="encryptHLayout">
              <item>
               <widget class="QRadioButton" name="encryptionNone">
                <property name="text">
                 <string>&amp;None</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QRadioButton" name="encryptionSsl">
                <property name="text">
                 <string>&amp;SSL/TLS</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QRadioButton" name="encryptionTls">
                <property name="text">
                 <string>START&amp;TLS</string>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item row="1" column="0">
             <widget class="QLabel" name="portLabel">
              <property name="text">
               <string>&amp;Port:</string>
              </property>
              <property name="alignment">
               <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
              </property>
              <property name="buddy">
               <cstring>kcfg_port</cstring>
              </property>
             </widget>
            </item>
            <item row="1" column="1">
             <widget class="QSpinBox" name="kcfg_port">
              <property name="minimum">
               <number>1</number>
              </property>
              <property name="maximum">
               <number>65535</number>
              </property>
              <property name="value">
               <number>25</number>
              </property>
             </widget>
            </item>
            <item row="2" column="0">
             <widget class="QLabel" name="authLabel">
              <property name="text">
               <string>Authentication:</string>
              </property>
             </widget>
            </item>
            <item row="2" column="1">
             <widget class="QComboBox" name="authCombo"/>
            </item>
            <item row="3" column="0" colspan="2">
             <widget class="QCheckBox" name="kcfg_useProxy">
              <property name="text">
               <string>Connect using the system proxy settings</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>SMTP Settings</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <item row="0" column="0" colspan="2">
           <widget class="QCheckBox" name="kcfg_specifyHostname">
            <property name="text">
             <string>Sen&amp;d custom hostname to server</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="hostnameLabel">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="text">
             <string>Hostna&amp;me:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>kcfg_localHostname</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KLineEdit" name="kcfg_localHostname">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="trapEnterKeyEvent" stdset="0">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="2" column="0" colspan="2">
           <widget class="QCheckBox" name="kcfg_specifySenderOverwriteAddress">
            <property name="text">
             <string>Use custom sender address</string>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_2">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="text">
             <string>Sender Address:</string>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="KLineEdit" name="kcfg_senderOverwriteAddress">
            <property name="enabled">
             <bool>false</bool>
            </property>
            <property name="trapEnterKeyEvent" stdset="0">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="precommandLabel">
            <property name="text">
             <string>Precommand:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="KLineEdit" name="kcfg_precommand">
            <property name="trapEnterKeyEvent" stdset="0">
             <bool>true</bool>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer_2">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>0</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KLineEdit</class>
   <extends>QLineEdit</extends>
   <header>klineedit.h</header>
  </customwidget>
   <customwidget>
    <class>KPasswordLineEdit</class>
    <extends>QWidget</extends>
    <header>kpasswordlineedit.h</header>
   </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>tabWidget</tabstop>
  <tabstop>kcfg_host</tabstop>
  <tabstop>kcfg_requiresAuthentication</tabstop>
  <tabstop>kcfg_userName</tabstop>
  <tabstop>password</tabstop>
  <tabstop>kcfg_storePassword</tabstop>
  <tabstop>checkCapabilities</tabstop>
  <tabstop>encryptionNone</tabstop>
  <tabstop>encryptionSsl</tabstop>
  <tabstop>encryptionTls</tabstop>
  <tabstop>authCombo</tabstop>
  <tabstop>kcfg_specifyHostname</tabstop>
  <tabstop>kcfg_localHostname</tabstop>
  <tabstop>kcfg_specifySenderOverwriteAddress</tabstop>
  <tabstop>kcfg_senderOverwriteAddress</tabstop>
  <tabstop>kcfg_precommand</tabstop>
 </tabstops>
 <resources/>
 <connections>
  <connection>
   <sender>kcfg_specifyHostname</sender>
   <signal>toggled(bool)</signal>
   <receiver>hostnameLabel</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>101</x>
     <y>249</y>
    </hint>
    <hint type="destinationlabel">
     <x>83</x>
     <y>277</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_specifyHostname</sender>
   <signal>toggled(bool)</signal>
   <receiver>kcfg_localHostname</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>196</x>
     <y>249</y>
    </hint>
    <hint type="destinationlabel">
     <x>199</x>
     <y>277</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_requiresAuthentication</sender>
   <signal>toggled(bool)</signal>
   <receiver>kcfg_userName</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>372</x>
     <y>110</y>
    </hint>
    <hint type="destinationlabel">
     <x>372</x>
     <y>137</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_requiresAuthentication</sender>
   <signal>toggled(bool)</signal>
   <receiver>usernameLabel</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>372</x>
     <y>110</y>
    </hint>
    <hint type="destinationlabel">
     <x>141</x>
     <y>137</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_requiresAuthentication</sender>
   <signal>toggled(bool)</signal>
   <receiver>passwordLabel</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>372</x>
     <y>110</y>
    </hint>
    <hint type="destinationlabel">
     <x>128</x>
     <y>164</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_requiresAuthentication</sender>
   <signal>toggled(bool)</signal>
   <receiver>password</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>372</x>
     <y>110</y>
    </hint>
    <hint type="destinationlabel">
     <x>372</x>
     <y>164</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_requiresAuthentication</sender>
   <signal>toggled(bool)</signal>
   <receiver>kcfg_storePassword</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>372</x>
     <y>110</y>
    </hint>
    <hint type="destinationlabel">
     <x>372</x>
     <y>189</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_specifySenderOverwriteAddress</sender>
   <signal>toggled(bool)</signal>
   <receiver>label_2</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>59</x>
     <y>299</y>
    </hint>
    <hint type="destinationlabel">
     <x>78</x>
     <y>312</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>kcfg_specifySenderOverwriteAddress</sender>
   <signal>toggled(bool)</signal>
   <receiver>kcfg_senderOverwriteAddress</receiver>
   <slot>setEnabled(bool)</slot>
   <hints>
    <hint type="sourcelabel">
     <x>152</x>
     <y>297</y>
    </hint>
    <hint type="destinationlabel">
     <x>169</x>
     <y>318</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>
07070100000032000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000005300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/tests07070100000033000081A4000000000000000000000001610B8324000000B9000000000000000000000000000000000000006200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/tests/CMakeLists.txtinclude(ECMMarkAsTest)
add_executable(transportmanagertest transportmanagertest.cpp)
ecm_mark_as_test(transportmanagertest)
target_link_libraries(transportmanagertest KF5MailTransport)
07070100000034000081A4000000000000000000000001610B832400000424000000000000000000000000000000000000006C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/tests/transportmanagertest.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportmanagertest.h"
#include "kmailtransport/plugins/transportpluginmanager.h"
#include <MailTransport/TransportAbstractPlugin>
#include <QCoreApplication>
#include <QDebug>

TransportManagerTest::TransportManagerTest(QObject *parent)
    : QObject(parent)
{
}

int main(int argc, char **argv)
{
    QCoreApplication app(argc, argv);

const QVector<MailTransport::TransportAbstractPlugin *> lst = MailTransport::TransportPluginManager::self()->pluginsList();
    if (lst.isEmpty()) {
        qDebug() << "Any plugin found. Please verify your installation";
        return 0;
    }
    for (MailTransport::TransportAbstractPlugin *plugin : lst) {
        const QVector<MailTransport::TransportAbstractPluginInfo> lstPluginInfo = plugin->names();
        for (const MailTransport::TransportAbstractPluginInfo &info : lstPluginInfo) {
            qDebug() << "Plugin name " << info.name;
        }
    }
    return 0;
}
07070100000035000081A4000000000000000000000001610B832400000124000000000000000000000000000000000000006A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/tests/transportmanagertest.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>

class TransportManagerTest : public QObject
{
    Q_OBJECT
public:
    explicit TransportManagerTest(QObject *parent = nullptr);
};

07070100000036000081A4000000000000000000000001610B832400000268000000000000000000000000000000000000006900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/transportabstractplugin.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportabstractplugin.h"
#include "mailtransport_debug.h"
using namespace MailTransport;

TransportAbstractPlugin::TransportAbstractPlugin(QObject *parent)
    : QObject(parent)
{
}

TransportAbstractPlugin::~TransportAbstractPlugin()
{
}

void TransportAbstractPlugin::cleanUp(MailTransport::Transport *t)
{
    Q_UNUSED(t)
}

void TransportAbstractPlugin::initializeTransport(MailTransport::Transport *t, const QString &identifier)
{
    Q_UNUSED(identifier)
    Q_UNUSED(t)
}
07070100000037000081A4000000000000000000000001610B83240000059B000000000000000000000000000000000000006700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/transportabstractplugin.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "mailtransport_export.h"
#include <QObject>
#include <QVector>
namespace MailTransport
{
class TransportJob;
class Transport;
/**
 * @brief The TransportAbstractPluginInfo struct
 * @author Laurent Montel <montel@kde.org>
 */
struct MAILTRANSPORT_EXPORT TransportAbstractPluginInfo {
    QString name;
    QString identifier;
    QString description;
    bool isAkonadi = false;
};

/**
 * @brief The TransportAbstractPlugin class
 * @author Laurent Montel <montel@kde.org>
 */
class MAILTRANSPORT_EXPORT TransportAbstractPlugin : public QObject
{
    Q_OBJECT
public:
    explicit TransportAbstractPlugin(QObject *parent = nullptr);
    ~TransportAbstractPlugin() override;

Q_REQUIRED_RESULT virtual TransportJob *createTransportJob(MailTransport::Transport *t, const QString &identifier) = 0;
    Q_REQUIRED_RESULT virtual QVector<TransportAbstractPluginInfo> names() const = 0;
    Q_REQUIRED_RESULT virtual bool configureTransport(const QString &identifier, Transport *transport, QWidget *parent) = 0;
    virtual void cleanUp(MailTransport::Transport *t);
    virtual void initializeTransport(MailTransport::Transport *t, const QString &identifier);

Q_SIGNALS:
    void updatePluginList();
};
}
Q_DECLARE_TYPEINFO(MailTransport::TransportAbstractPluginInfo, Q_MOVABLE_TYPE);

07070100000038000081A4000000000000000000000001610B832400000FF8000000000000000000000000000000000000006800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/transportpluginmanager.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportpluginmanager.h"
#include "mailtransport_debug.h"
#include <KPluginFactory>
#include <KPluginLoader>
#include <kpluginmetadata.h>

#include <MailTransport/TransportAbstractPlugin>

#include <QFileInfo>

using namespace MailTransport;

class MailTransportPluginInfo
{
public:
    QString metaDataFileNameBaseName;
    QString metaDataFileName;
    MailTransport::TransportAbstractPlugin *plugin = nullptr;
};

namespace
{
QString pluginVersion()
{
    return QStringLiteral("1.0");
}
}

class MailTransport::TransportPluginManagerPrivate
{
public:
    TransportPluginManagerPrivate(TransportPluginManager *qq)
        : q(qq)
    {
        initializePlugins();
    }

void loadPlugin(MailTransportPluginInfo *item);
    QVector<MailTransport::TransportAbstractPlugin *> pluginsList() const;
    QVector<MailTransportPluginInfo> mPluginList;
    bool initializePlugins();

private:
    TransportPluginManager *q;
};

bool TransportPluginManagerPrivate::initializePlugins()
{
    if (!mPluginList.isEmpty()) {
        return true;
    }
    const QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(QStringLiteral("mailtransport"));

QVectorIterator<KPluginMetaData> i(plugins);
    i.toBack();
    while (i.hasPrevious()) {
        MailTransportPluginInfo info;
        const KPluginMetaData data = i.previous();

info.metaDataFileNameBaseName = QFileInfo(data.fileName()).baseName();
        info.metaDataFileName = data.fileName();
        if (pluginVersion() == data.version()) {
            info.plugin = nullptr;
            mPluginList.push_back(info);
        } else {
            qCWarning(MAILTRANSPORT_LOG) << "Plugin " << data.name() << " doesn't have correction plugin version. It will not be loaded.";
        }
    }
    const QVector<MailTransportPluginInfo>::iterator end(mPluginList.end());
    for (QVector<MailTransportPluginInfo>::iterator it = mPluginList.begin(); it != end; ++it) {
        loadPlugin(&(*it));
    }
    return true;
}

void TransportPluginManagerPrivate::loadPlugin(MailTransportPluginInfo *item)
{
    KPluginLoader pluginLoader(item->metaDataFileName);
    if (pluginLoader.factory()) {
        item->plugin = pluginLoader.factory()->create<MailTransport::TransportAbstractPlugin>(q, QVariantList() << item->metaDataFileNameBaseName);
        if (item->plugin) {
            QObject::connect(item->plugin, &TransportAbstractPlugin::updatePluginList, q, &TransportPluginManager::updatePluginList);
        }
    }
}

QVector<MailTransport::TransportAbstractPlugin *> TransportPluginManagerPrivate::pluginsList() const
{
    QVector<MailTransport::TransportAbstractPlugin *> lst;
    const QVector<MailTransportPluginInfo>::ConstIterator end(mPluginList.constEnd());
    for (QVector<MailTransportPluginInfo>::ConstIterator it = mPluginList.constBegin(); it != end; ++it) {
        if (auto plugin = (*it).plugin) {
            lst << plugin;
        }
    }
    return lst;
}

TransportPluginManager::TransportPluginManager(QObject *parent)
    : QObject(parent)
    , d(new TransportPluginManagerPrivate(this))
{
}

TransportPluginManager::~TransportPluginManager()
{
    delete d;
}

TransportPluginManager *TransportPluginManager::self()
{
    static TransportPluginManager s_self;
    return &s_self;
}

QVector<MailTransport::TransportAbstractPlugin *> TransportPluginManager::pluginsList() const
{
    return d->pluginsList();
}

MailTransport::TransportAbstractPlugin *TransportPluginManager::plugin(const QString &identifier)
{
    const QVector<MailTransport::TransportAbstractPlugin *> lstPlugins = pluginsList();
    for (MailTransport::TransportAbstractPlugin *p : lstPlugins) {
        const QVector<TransportAbstractPluginInfo> lstPluginInfo = p->names();
        for (const MailTransport::TransportAbstractPluginInfo &info : lstPluginInfo) {
            if (info.identifier == identifier) {
                return p;
            }
        }
    }
    return {};
}
07070100000039000081A4000000000000000000000001610B832400000340000000000000000000000000000000000000006600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/plugins/transportpluginmanager.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "kmailtransport_private_export.h"
#include <QObject>
namespace MailTransport
{
class TransportAbstractPlugin;
class TransportPluginManagerPrivate;
class KMAILTRANSPORT_TESTS_EXPORT TransportPluginManager : public QObject
{
    Q_OBJECT
public:
    explicit TransportPluginManager(QObject *parent = nullptr);
    ~TransportPluginManager() override;

static TransportPluginManager *self();

Q_REQUIRED_RESULT MailTransport::TransportAbstractPlugin *plugin(const QString &identifier);
    Q_REQUIRED_RESULT QVector<MailTransport::TransportAbstractPlugin *> pluginsList() const;

Q_SIGNALS:
    void updatePluginList();

private:
    TransportPluginManagerPrivate *const d;
};
}

0707010000003A000081A4000000000000000000000001610B832400000AB4000000000000000000000000000000000000005700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/precommandjob.cpp/*
    SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
    SPDX-FileCopyrightText: 1996-1998 Stefan Taferner <taferner@kde.org>
    SPDX-FileCopyrightText: 2000-2002 Michael Haeckel <haeckel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "precommandjob.h"

#include <KLocalizedString>

#include <QProcess>

using namespace MailTransport;

/**
 * Private class that helps to provide binary compatibility between releases.
 * @internal
 */
class PreCommandJobPrivate
{
public:
    PreCommandJobPrivate(PrecommandJob *parent);
    QProcess *process = nullptr;
    QString precommand;
    PrecommandJob *const q;

// Slots
    void slotFinished(int, QProcess::ExitStatus);
    void slotStarted();
    void slotError(QProcess::ProcessError error);
};

PreCommandJobPrivate::PreCommandJobPrivate(PrecommandJob *parent)
    : q(parent)
{
}

PrecommandJob::PrecommandJob(const QString &precommand, QObject *parent)
    : KJob(parent)
    , d(new PreCommandJobPrivate(this))
{
    d->precommand = precommand;
    d->process = new QProcess(this);
    connect(d->process, &QProcess::started, this, [this]() {
        d->slotStarted();
    });
    connect(d->process, &QProcess::errorOccurred, this, [this](QProcess::ProcessError error) {
        d->slotError(error);
    });
    connect(d->process, qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this, [this](int val, QProcess::ExitStatus status) {
        d->slotFinished(val, status);
    });
}

PrecommandJob::~PrecommandJob()
{
    delete d;
}

void PrecommandJob::start()
{
    d->process->start(d->precommand, QStringList());
}

void PreCommandJobPrivate::slotStarted()
{
    Q_EMIT q->infoMessage(q, i18n("Executing precommand"), i18n("Executing precommand '%1'.", precommand));
}

void PreCommandJobPrivate::slotError(QProcess::ProcessError error)
{
    q->setError(KJob::UserDefinedError);
    if (error == QProcess::FailedToStart) {
        q->setErrorText(i18n("Unable to start precommand '%1'.", precommand));
    } else {
        q->setErrorText(i18n("Error while executing precommand '%1'.", precommand));
    }
    q->emitResult();
}

bool PrecommandJob::doKill()
{
    delete d->process;
    d->process = nullptr;
    return true;
}

void PreCommandJobPrivate::slotFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
    if (exitStatus == QProcess::CrashExit) {
        q->setError(KJob::UserDefinedError);
        q->setErrorText(i18n("The precommand crashed."));
    } else if (exitCode != 0) {
        q->setError(KJob::UserDefinedError);
        q->setErrorText(i18n("The precommand exited with code %1.", process->exitStatus()));
    }
    q->emitResult();
}

#include "moc_precommandjob.cpp"
0707010000003B000081A4000000000000000000000001610B83240000051A000000000000000000000000000000000000005500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/precommandjob.h/*
    SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
    SPDX-FileCopyrightText: 1996-1998 Stefan Taferner <taferner@kde.org>
    SPDX-FileCopyrightText: 2000-2002 Michael Haeckel <haeckel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "mailtransport_export.h"

#include <KJob>

class PreCommandJobPrivate;

namespace MailTransport
{
/**
  Job to execute a command.
  This is used often for sending or receiving mails, for example to set up
  a tunnel of VPN connection.
  Basically this is just a KJob wrapper around a QProcess.

@since 4.4
 */
class MAILTRANSPORT_EXPORT PrecommandJob : public KJob
{
    Q_OBJECT

public:
    /**
      Creates a new precommand job.
      @param precommand The command to run.
      @param parent The parent object.
    */
    explicit PrecommandJob(const QString &precommand, QObject *parent = nullptr);

/**
      Destroys this job.
    */
    ~PrecommandJob() override;

/**
      Executes the precommand.
      Reimplemented from KJob.
    */
    void start() override;

protected:
    /**
      Reimplemented from KJob.
    */
    bool doKill() override;

private:
    friend class ::PreCommandJobPrivate;
    PreCommandJobPrivate *const d;
};
} // namespace MailTransport

0707010000003C000081A4000000000000000000000001610B832400005BC1000000000000000000000000000000000000005400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/servertest.cpp/*
  SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>
  SPDX-FileCopyrightText: 2007 KovoKs <info@kovoks.nl>
  SPDX-FileCopyrightText: 2008 Thomas McGuire <thomas.mcguire@gmx.net>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

// Own
#include "servertest.h"
#include "socket.h"

#include <mailtransport_defs.h>
#include <transportbase.h>

// Qt
#include <QHash>
#include <QHostInfo>
#include <QProgressBar>
#include <QRegularExpression>
#include <QSet>
#include <QTimer>

// KDE
#include "mailtransport_debug.h"

using namespace MailTransport;

namespace MailTransport
{
class ServerTestPrivate
{
public:
    ServerTestPrivate(ServerTest *test);

ServerTest *const q;
    QString server;
    QString fakeHostname;
    QString testProtocol;

MailTransport::Socket *normalSocket = nullptr;
    MailTransport::Socket *secureSocket = nullptr;

QSet<int> connectionResults;
    QHash<int, QVector<int>> authenticationResults;
    QSet<ServerTest::Capability> capabilityResults;
    QHash<int, uint> customPorts;
    QTimer *normalSocketTimer = nullptr;
    QTimer *secureSocketTimer = nullptr;
    QTimer *progressTimer = nullptr;

QProgressBar *testProgress = nullptr;

bool secureSocketFinished = false;
    bool normalSocketFinished = false;
    bool tlsFinished = false;
    bool popSupportsTLS;
    int normalStage;
    int secureStage;
    int encryptionMode;

bool normalPossible = true;
    bool securePossible = true;

void finalResult();
    void handleSMTPIMAPResponse(int type, const QString &text);
    void sendInitialCapabilityQuery(MailTransport::Socket *socket);
    bool handlePopConversation(MailTransport::Socket *socket, int type, int stage, const QString &response, bool *shouldStartTLS);
    bool handleNntpConversation(MailTransport::Socket *socket, int type, int *stage, const QString &response, bool *shouldStartTLS);
    QVector<int> parseAuthenticationList(const QStringList &authentications);

inline bool isGmail(const QString &server) const
    {
        return server.endsWith(QLatin1String("gmail.com")) || server.endsWith(QLatin1String("googlemail.com"));
    }

// slots
    void slotNormalPossible();
    void slotNormalNotPossible();
    void slotSslPossible();
    void slotSslNotPossible();
    void slotTlsDone();
    void slotReadNormal(const QString &text);
    void slotReadSecure(const QString &text);
    void slotUpdateProgress();
};
}

ServerTestPrivate::ServerTestPrivate(ServerTest *test)
    : q(test)
{
}

void ServerTestPrivate::finalResult()
{
    if (!secureSocketFinished || !normalSocketFinished || !tlsFinished) {
        return;
    }

qCDebug(MAILTRANSPORT_LOG) << "Modes:" << connectionResults;
    qCDebug(MAILTRANSPORT_LOG) << "Capabilities:" << capabilityResults;
    qCDebug(MAILTRANSPORT_LOG) << "Normal:" << q->normalProtocols();
    qCDebug(MAILTRANSPORT_LOG) << "SSL:" << q->secureProtocols();
    qCDebug(MAILTRANSPORT_LOG) << "TLS:" << q->tlsProtocols();

if (testProgress) {
        testProgress->hide();
    }
    progressTimer->stop();
    secureSocketFinished = false;
    normalSocketFinished = false;
    tlsFinished = false;

QVector<int> resultsAsVector;
    resultsAsVector.reserve(connectionResults.size());
    for (int res : std::as_const(connectionResults)) {
        resultsAsVector.append(res);
    }

Q_EMIT q->finished(resultsAsVector);
}

QVector<int> ServerTestPrivate::parseAuthenticationList(const QStringList &authentications)
{
    QVector<int> result;
    for (QStringList::ConstIterator it = authentications.begin(); it != authentications.end(); ++it) {
        QString current = (*it).toUpper();
        if (current == QLatin1String("LOGIN")) {
            result << Transport::EnumAuthenticationType::LOGIN;
        } else if (current == QLatin1String("PLAIN")) {
            result << Transport::EnumAuthenticationType::PLAIN;
        } else if (current == QLatin1String("CRAM-MD5")) {
            result << Transport::EnumAuthenticationType::CRAM_MD5;
        } else if (current == QLatin1String("DIGEST-MD5")) {
            result << Transport::EnumAuthenticationType::DIGEST_MD5;
        } else if (current == QLatin1String("NTLM")) {
            result << Transport::EnumAuthenticationType::NTLM;
        } else if (current == QLatin1String("GSSAPI")) {
            result << Transport::EnumAuthenticationType::GSSAPI;
        } else if (current == QLatin1String("ANONYMOUS")) {
            result << Transport::EnumAuthenticationType::ANONYMOUS;
        } else if (current == QLatin1String("XOAUTH2")) {
            if (isGmail(server)) {
                result << Transport::EnumAuthenticationType::XOAUTH2;
            }
        }
        // APOP is handled by handlePopConversation()
    }
    qCDebug(MAILTRANSPORT_LOG) << authentications << result;

// LOGIN doesn't offer anything over PLAIN, requires more server
    // roundtrips and is not an official SASL mechanism, but a MS-ism,
    // so only enable it if PLAIN isn't available:
    if (result.contains(Transport::EnumAuthenticationType::PLAIN)) {
        result.removeAll(Transport::EnumAuthenticationType::LOGIN);
    }

return result;
}

void ServerTestPrivate::handleSMTPIMAPResponse(int type, const QString &text)
{
    if (!text.contains(QLatin1String("AUTH"), Qt::CaseInsensitive)) {
        qCDebug(MAILTRANSPORT_LOG) << "No authentication possible";
        return;
    }

QStringList protocols;
    if (isGmail(server)) {
        protocols << QStringLiteral("XOAUTH2");
    }

protocols << QStringLiteral("LOGIN") << QStringLiteral("PLAIN") << QStringLiteral("CRAM-MD5") << QStringLiteral("DIGEST-MD5") << QStringLiteral("NTLM")
              << QStringLiteral("GSSAPI") << QStringLiteral("ANONYMOUS");

QStringList results;
    for (int i = 0; i < protocols.count(); ++i) {
        if (text.contains(protocols.at(i), Qt::CaseInsensitive)) {
            results.append(protocols.at(i));
        }
    }

authenticationResults[type] = parseAuthenticationList(results);

// if we couldn't parse any authentication modes, default to clear-text
    if (authenticationResults[type].isEmpty()) {
        authenticationResults[type] << Transport::EnumAuthenticationType::CLEAR;
    }

qCDebug(MAILTRANSPORT_LOG) << "For type" << type << ", we have:" << authenticationResults[type];
}

void ServerTestPrivate::slotNormalPossible()
{
    normalSocketTimer->stop();
    connectionResults << Transport::EnumEncryption::None;
}

void ServerTestPrivate::sendInitialCapabilityQuery(MailTransport::Socket *socket)
{
    if (testProtocol == IMAP_PROTOCOL) {
        socket->write(QStringLiteral("1 CAPABILITY"));
    } else if (testProtocol == SMTP_PROTOCOL) {
        // Detect the hostname which we send with the EHLO command.
        // If there is a fake one set, use that, otherwise use the
        // local host name (and make sure it contains a domain, so the
        // server thinks it is valid).
        QString hostname;
        if (!fakeHostname.isNull()) {
            hostname = fakeHostname;
        } else {
            hostname = QHostInfo::localHostName();
            if (hostname.isEmpty()) {
                hostname = QStringLiteral("localhost.invalid");
            } else if (!hostname.contains(QChar::fromLatin1('.'))) {
                hostname += QLatin1String(".localnet");
            }
        }
        qCDebug(MAILTRANSPORT_LOG) << "Hostname for EHLO is" << hostname;

socket->write(QLatin1String("EHLO ") + hostname);
    }
}

void ServerTestPrivate::slotTlsDone()
{
    // The server will not send a response after starting TLS. Therefore, we have to manually
    // call slotReadNormal(), because this is not triggered by a data received signal this time.
    slotReadNormal(QString());
}

bool ServerTestPrivate::handlePopConversation(MailTransport::Socket *socket, int type, int stage, const QString &response, bool *shouldStartTLS)
{
    Q_ASSERT(shouldStartTLS != nullptr);

// Initial Greeting
    if (stage == 0) {
        // Regexp taken from POP3 ioslave
        const QString responseWithoutCRLF = response.chopped(2);
        const QRegularExpression re(QStringLiteral("<[A-Za-z0-9\\.\\-_]+@[A-Za-z0-9\\.\\-_]+>$"), QRegularExpression::CaseInsensitiveOption);
        if (responseWithoutCRLF.indexOf(re) != -1) {
            authenticationResults[type] << Transport::EnumAuthenticationType::APOP;
        }

// Each server is supposed to support clear text login
        authenticationResults[type] << Transport::EnumAuthenticationType::CLEAR;

// If we are in TLS stage, the server does not send the initial greeting.
        // Assume that the APOP availability is the same as with an unsecured connection.
        if (type == Transport::EnumEncryption::TLS
            && authenticationResults[Transport::EnumEncryption::None].contains(Transport::EnumAuthenticationType::APOP)) {
            authenticationResults[Transport::EnumEncryption::TLS] << Transport::EnumAuthenticationType::APOP;
        }

socket->write(QStringLiteral("CAPA"));
        return true;
    }
    // CAPA result
    else if (stage == 1) {
        //     Example:
        //     CAPA
        //     +OK
        //     TOP
        //     USER
        //     SASL LOGIN CRAM-MD5
        //     UIDL
        //     RESP-CODES
        //     .
        if (response.contains(QLatin1String("TOP"))) {
            capabilityResults += ServerTest::Top;
        }
        if (response.contains(QLatin1String("PIPELINING"))) {
            capabilityResults += ServerTest::Pipelining;
        }
        if (response.contains(QLatin1String("UIDL"))) {
            capabilityResults += ServerTest::UIDL;
        }
        if (response.contains(QLatin1String("STLS"))) {
            connectionResults << Transport::EnumEncryption::TLS;
            popSupportsTLS = true;
        }
        socket->write(QStringLiteral("AUTH"));
        return true;
    }
    // AUTH response
    else if (stage == 2) {
        //     Example:
        //     C: AUTH
        //     S: +OK List of supported authentication methods follows
        //     S: LOGIN
        //     S: CRAM-MD5
        //     S:.
        QString formattedReply = response;

// Get rid of trailing ".CRLF"
        formattedReply.chop(3);

// Get rid of the first +OK line
        formattedReply = formattedReply.right(formattedReply.size() - formattedReply.indexOf(QLatin1Char('\n')) - 1);
        formattedReply = formattedReply.replace(QLatin1Char(' '), QLatin1Char('-')).replace(QLatin1String("\r\n"), QLatin1String(" "));

authenticationResults[type] += parseAuthenticationList(formattedReply.split(QLatin1Char(' ')));
    }

*shouldStartTLS = popSupportsTLS;
    return false;
}

bool ServerTestPrivate::handleNntpConversation(MailTransport::Socket *socket, int type, int *stage, const QString &response, bool *shouldStartTLS)
{
    Q_ASSERT(shouldStartTLS != nullptr);
    Q_ASSERT(stage != nullptr);

// Initial Greeting
    if (*stage == 0) {
        if (response.startsWith(QLatin1String("382 "))) {
            return true;
        }
        if (!response.isEmpty() && !response.startsWith(QLatin1String("200 "))) {
            return false;
        }

socket->write(QStringLiteral("CAPABILITIES"));
        return true;
    }
    // CAPABILITIES result
    else if (*stage == 1) {
        // Check whether we got "500 command 'CAPABILITIES' not recognized"
        if (response.startsWith(QLatin1String("500 "))) {
            return false;
        }

//     Example:
        //     101 Capability list:
        //     VERSION 2
        //     IMPLEMENTATION INN 2.5.4
        //     AUTHINFO USER SASL
        //     HDR
        //     LIST ACTIVE [etc]
        //     OVER
        //     POST
        //     READER
        //     SASL DIGEST-MD5 CRAM-MD5 NTLM PLAIN LOGIN
        //     STARTTLS
        //     .
        const QVector<QStringRef> lines = response.splitRef(QStringLiteral("\r\n"), Qt::SkipEmptyParts);
        for (const QStringRef &line : lines) {
            if (line.compare(QLatin1String("STARTTLS"), Qt::CaseInsensitive) == 0) {
                *shouldStartTLS = true;
            } else if (line.startsWith(QLatin1String("AUTHINFO "), Qt::CaseInsensitive)) {
                const QVector<QStringRef> authinfos = line.split(QLatin1Char(' '), Qt::SkipEmptyParts);
                const QString s(QStringLiteral("USER"));
                const QStringRef ref(&s);
                if (authinfos.contains(ref)) {
                    authenticationResults[type].append(Transport::EnumAuthenticationType::CLEAR); // XXX
                }
            } else if (line.startsWith(QLatin1String("SASL "), Qt::CaseInsensitive)) {
                const QStringList auths = line.mid(5).toString().split(QLatin1Char(' '), Qt::SkipEmptyParts);
                authenticationResults[type] += parseAuthenticationList(auths);
            } else if (line == QLatin1Char('.')) {
                return false;
            }
        }
        // We have not hit the end of the capabilities list yet,
        // so avoid the stage counter to rise without reason.
        --(*stage);
        return true;
    }

return false;
}

// slotReadNormal() handles normal (no) encryption and TLS encryption.
// At first, the communication is not encrypted, but if the server supports
// the STARTTLS/STLS keyword, the same authentication query is done again
// with TLS.
void ServerTestPrivate::slotReadNormal(const QString &text)
{
    Q_ASSERT(encryptionMode != Transport::EnumEncryption::SSL);
    static const int tlsHandshakeStage = 42;

qCDebug(MAILTRANSPORT_LOG) << "Stage" << normalStage + 1 << ", Mode" << encryptionMode;

// If we are in stage 42, we just do the handshake for TLS encryption and
    // then reset the stage to -1, so that all authentication modes and
    // capabilities are queried again for TLS encryption (some servers have
    // different authentication  methods in normal and in TLS mode).
    if (normalStage == tlsHandshakeStage) {
        Q_ASSERT(encryptionMode == Transport::EnumEncryption::TLS);
        normalStage = -1;
        normalSocket->startTLS();
        return;
    }

bool shouldStartTLS = false;
    normalStage++;

// Handle the whole POP and NNTP conversations separately, as
    // they are very different from IMAP and SMTP
    if (testProtocol == POP_PROTOCOL) {
        if (handlePopConversation(normalSocket, encryptionMode, normalStage, text, &shouldStartTLS)) {
            return;
        }
    } else if (testProtocol == NNTP_PROTOCOL) {
        if (handleNntpConversation(normalSocket, encryptionMode, &normalStage, text, &shouldStartTLS)) {
            return;
        }
    } else {
        // Handle the SMTP/IMAP conversation here. We just send the EHLO command in
        // sendInitialCapabilityQuery.
        if (normalStage == 0) {
            sendInitialCapabilityQuery(normalSocket);
            return;
        }

if (text.contains(QLatin1String("STARTTLS"), Qt::CaseInsensitive)) {
            connectionResults << Transport::EnumEncryption::TLS;
            shouldStartTLS = true;
        }
        handleSMTPIMAPResponse(encryptionMode, text);
    }

// If we reach here, the normal authentication/capabilities query is completed.
    // Now do the same for TLS.
    normalSocketFinished = true;

// If the server announced that STARTTLS/STLS is available, we'll add TLS to the
    // connection result, do the command and set the stage to 42 to start the handshake.
    if (shouldStartTLS && encryptionMode == Transport::EnumEncryption::None) {
        qCDebug(MAILTRANSPORT_LOG) << "Trying TLS...";
        connectionResults << Transport::EnumEncryption::TLS;
        if (testProtocol == POP_PROTOCOL) {
            normalSocket->write(QStringLiteral("STLS"));
        } else if (testProtocol == IMAP_PROTOCOL) {
            normalSocket->write(QStringLiteral("2 STARTTLS"));
        } else {
            normalSocket->write(QStringLiteral("STARTTLS"));
        }
        encryptionMode = Transport::EnumEncryption::TLS;
        normalStage = tlsHandshakeStage;
        return;
    }

// If we reach here, either the TLS authentication/capabilities query is finished
    // or the server does not support the STARTTLS/STLS command.
    tlsFinished = true;
    finalResult();
}

void ServerTestPrivate::slotReadSecure(const QString &text)
{
    secureStage++;
    if (testProtocol == POP_PROTOCOL) {
        bool dummy;
        if (handlePopConversation(secureSocket, Transport::EnumEncryption::SSL, secureStage, text, &dummy)) {
            return;
        }
    } else if (testProtocol == NNTP_PROTOCOL) {
        bool dummy;
        if (handleNntpConversation(secureSocket, Transport::EnumEncryption::SSL, &secureStage, text, &dummy)) {
            return;
        }
    } else {
        if (secureStage == 0) {
            sendInitialCapabilityQuery(secureSocket);
            return;
        }
        handleSMTPIMAPResponse(Transport::EnumEncryption::SSL, text);
    }
    secureSocketFinished = true;
    finalResult();
}

void ServerTestPrivate::slotNormalNotPossible()
{
    if (testProtocol == SMTP_PROTOCOL && normalSocket->port() == SMTP_PORT) {
        // For SMTP, fallback to port 25
        normalSocket->setPort(SMTP_OLD_PORT);
        normalSocket->reconnect();
        normalSocketTimer->start(10000);
        return;
    }

normalSocketTimer->stop();
    normalPossible = false;
    normalSocketFinished = true;
    tlsFinished = true;
    finalResult();
}

void ServerTestPrivate::slotSslPossible()
{
    secureSocketTimer->stop();
    connectionResults << Transport::EnumEncryption::SSL;
}

void ServerTestPrivate::slotSslNotPossible()
{
    secureSocketTimer->stop();
    securePossible = false;
    secureSocketFinished = true;
    finalResult();
}

void ServerTestPrivate::slotUpdateProgress()
{
    if (testProgress) {
        testProgress->setValue(testProgress->value() + 1);
    }
}

//---------------------- end private class -----------------------//

ServerTest::ServerTest(QObject *parent)
    : QObject(parent)
    , d(new ServerTestPrivate(this))
{
    d->normalSocketTimer = new QTimer(this);
    d->normalSocketTimer->setSingleShot(true);
    connect(d->normalSocketTimer, SIGNAL(timeout()), SLOT(slotNormalNotPossible()));

d->secureSocketTimer = new QTimer(this);
    d->secureSocketTimer->setSingleShot(true);
    connect(d->secureSocketTimer, SIGNAL(timeout()), SLOT(slotSslNotPossible()));

d->progressTimer = new QTimer(this);
    connect(d->progressTimer, SIGNAL(timeout()), SLOT(slotUpdateProgress()));
}

ServerTest::~ServerTest()
{
    delete d;
}

void ServerTest::start()
{
    qCDebug(MAILTRANSPORT_LOG) << d;

d->connectionResults.clear();
    d->authenticationResults.clear();
    d->capabilityResults.clear();
    d->popSupportsTLS = false;
    d->normalStage = -1;
    d->secureStage = -1;
    d->encryptionMode = Transport::EnumEncryption::None;
    d->normalPossible = true;
    d->securePossible = true;

if (d->testProgress) {
        d->testProgress->setMaximum(20);
        d->testProgress->setValue(0);
        d->testProgress->setTextVisible(true);
        d->testProgress->show();
        d->progressTimer->start(1000);
    }

d->normalSocket = new MailTransport::Socket(this);
    d->secureSocket = new MailTransport::Socket(this);
    d->normalSocket->setObjectName(QStringLiteral("normal"));
    d->normalSocket->setServer(d->server);
    d->normalSocket->setProtocol(d->testProtocol);
    if (d->testProtocol == IMAP_PROTOCOL) {
        d->normalSocket->setPort(IMAP_PORT);
        d->secureSocket->setPort(IMAPS_PORT);
    } else if (d->testProtocol == SMTP_PROTOCOL) {
        d->normalSocket->setPort(SMTP_PORT);
        d->secureSocket->setPort(SMTPS_PORT);
    } else if (d->testProtocol == POP_PROTOCOL) {
        d->normalSocket->setPort(POP_PORT);
        d->secureSocket->setPort(POPS_PORT);
    } else if (d->testProtocol == NNTP_PROTOCOL) {
        d->normalSocket->setPort(NNTP_PORT);
        d->secureSocket->setPort(NNTPS_PORT);
    }

if (d->customPorts.contains(Transport::EnumEncryption::None)) {
        d->normalSocket->setPort(d->customPorts.value(Transport::EnumEncryption::None));
    }
    if (d->customPorts.contains(Transport::EnumEncryption::SSL)) {
        d->secureSocket->setPort(d->customPorts.value(Transport::EnumEncryption::SSL));
    }

connect(d->normalSocket, SIGNAL(connected()), SLOT(slotNormalPossible()));
    connect(d->normalSocket, SIGNAL(failed()), SLOT(slotNormalNotPossible()));
    connect(d->normalSocket, SIGNAL(data(QString)), SLOT(slotReadNormal(QString)));
    connect(d->normalSocket, SIGNAL(tlsDone()), SLOT(slotTlsDone()));
    d->normalSocket->reconnect();
    d->normalSocketTimer->start(10000);

if (d->secureSocket->port() > 0) {
        d->secureSocket->setObjectName(QStringLiteral("secure"));
        d->secureSocket->setServer(d->server);
        d->secureSocket->setProtocol(d->testProtocol + QLatin1Char('s'));
        d->secureSocket->setSecure(true);
        connect(d->secureSocket, SIGNAL(connected()), SLOT(slotSslPossible()));
        connect(d->secureSocket, SIGNAL(failed()), SLOT(slotSslNotPossible()));
        connect(d->secureSocket, SIGNAL(data(QString)), SLOT(slotReadSecure(QString)));
        d->secureSocket->reconnect();
        d->secureSocketTimer->start(10000);
    } else {
        d->slotSslNotPossible();
    }
}

void ServerTest::setFakeHostname(const QString &fakeHostname)
{
    d->fakeHostname = fakeHostname;
}

QString ServerTest::fakeHostname() const
{
    return d->fakeHostname;
}

void ServerTest::setServer(const QString &server)
{
    d->server = server;
}

void ServerTest::setPort(Transport::EnumEncryption::type encryptionMode, uint port)
{
    Q_ASSERT(encryptionMode == Transport::EnumEncryption::None || encryptionMode == Transport::EnumEncryption::SSL);
    d->customPorts.insert(encryptionMode, port);
}

void ServerTest::setProgressBar(QProgressBar *pb)
{
    d->testProgress = pb;
}

void ServerTest::setProtocol(const QString &protocol)
{
    d->testProtocol = protocol;
    d->customPorts.clear();
}

QString ServerTest::protocol() const
{
    return d->testProtocol;
}

QString ServerTest::server() const
{
    return d->server;
}

int ServerTest::port(TransportBase::EnumEncryption::type encryptionMode) const
{
    Q_ASSERT(encryptionMode == Transport::EnumEncryption::None || encryptionMode == Transport::EnumEncryption::SSL);
    if (d->customPorts.contains(encryptionMode)) {
        return d->customPorts.value(static_cast<int>(encryptionMode));
    } else {
        return -1;
    }
}

QProgressBar *ServerTest::progressBar() const
{
    return d->testProgress;
}

QVector<int> ServerTest::normalProtocols() const
{
    return d->authenticationResults[TransportBase::EnumEncryption::None];
}

bool ServerTest::isNormalPossible() const
{
    return d->normalPossible;
}

QVector<int> ServerTest::tlsProtocols() const
{
    return d->authenticationResults[TransportBase::EnumEncryption::TLS];
}

QVector<int> ServerTest::secureProtocols() const
{
    return d->authenticationResults[Transport::EnumEncryption::SSL];
}

bool ServerTest::isSecurePossible() const
{
    return d->securePossible;
}

QList<ServerTest::Capability> ServerTest::capabilities() const
{
    return d->capabilityResults.values();
}

#include "moc_servertest.cpp"
0707010000003D000081A4000000000000000000000001610B832400001869000000000000000000000000000000000000005200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/servertest.h/*
  SPDX-FileCopyrightText: 2007 KovoKs <info@kovoks.nl>
  SPDX-FileCopyrightText: 2008 Thomas McGuire <thomas.mcguire@gmx.net>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>
#include <transport.h>

#include <QList>
#include <QObject>

class QProgressBar;

namespace MailTransport
{
class ServerTestPrivate;

/**
 * @class ServerTest
 * This class can be used to test certain server to see if they support stuff.
 * @author Tom Albers <tomalbers@kde.nl>
 */
class MAILTRANSPORT_EXPORT ServerTest : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString server READ server WRITE setServer)
    Q_PROPERTY(QString protocol READ protocol WRITE setProtocol)
    Q_PROPERTY(QProgressBar *progressBar READ progressBar WRITE setProgressBar)

public:
    /**
     * This enumeration has the special capabilities a server might
     * support. This covers only capabilities not related to authentication.
     * @since 4.1
     */
    enum Capability {
        Pipelining, ///< POP3 only. The server supports pipeplining of commands
        Top, ///< POP3 only. The server supports fetching only the headers
        UIDL ///< POP3 only. The server has support for unique identifiers
    };

/**
     * Creates a new server test.
     *
     * @param parent The parent widget.
     */
    explicit ServerTest(QObject *parent = nullptr);

/**
     * Destroys the server test.
     */
    ~ServerTest() override;

/**
     * Sets the server to test.
     */
    void setServer(const QString &server);

/**
     * Returns the server to test.
     */
    Q_REQUIRED_RESULT QString server() const;

/**
     * Set a custom port to use.
     *
     * Each encryption mode (no encryption or SSL) has a different port.
     * TLS uses the same port as no encryption, because TLS is invoked during
     * a normal session.
     *
     * If this function is never called, the default port is used, which is:
     * (normal first, then SSL)
     * SMTP: 587 (falls back to 25), 465
     * POP: 110, 995
     * IMAP: 143, 993
     * NNTP: 119, 563
     *
     * @param encryptionMode the port will only be used in this encryption mode.
     *                       Valid values for this are only 'None' and 'SSL'.
     * @param port the port to use
     *
     * @since 4.1
     */
    void setPort(Transport::EnumEncryption::type encryptionMode, uint port);

/**
     * @param encryptionMode the port of this encryption mode is returned.
     *                       Can only be 'None' and 'SSL'
     *
     * @return the port set by @ref setPort or -1 if @ref setPort() was never
     *         called for this encryption mode.
     *
     * @since 4.1
     */
    Q_REQUIRED_RESULT int port(Transport::EnumEncryption::type encryptionMode) const;

/**
     * Sets a fake hostname for the test. This is currently only used when
     * testing a SMTP server; there, the command for testing the capabilities
     * (called EHLO) needs to have the hostname of the client included.
     * The user can however choose to send a fake hostname instead of the
     * local hostname to work around various problems. This fake hostname needs
     * to be set here.
     *
     * @param fakeHostname the fake hostname to send
     */
    void setFakeHostname(const QString &fakeHostname);

/**
     * @return the fake hostname, as set before with @ref setFakeHostname
     */
    Q_REQUIRED_RESULT QString fakeHostname() const;

/**
     * Makes @p pb the progressbar to use. This class will call show()
     * and hide() and will count down. It does not take ownership of
     * the progressbar.
     */
    void setProgressBar(QProgressBar *pb);

/**
     * Returns the used progress bar.
     */
    QProgressBar *progressBar() const;

/**
     * Sets @p protocol the protocol to test, currently supported are
     * "smtp", "pop", "imap", and "nntp".
     */
    void setProtocol(const QString &protocol);

/**
     * Returns the protocol.
     */
    Q_REQUIRED_RESULT QString protocol() const;

/**
     * Starts the test. Will emit finished() when done.
     */
    void start();

/**
     * Get the protocols for the normal connections.. Call this only
     * after the finished() signals has been sent.
     * @return an enum of the type Transport::EnumAuthenticationType
     */
    Q_REQUIRED_RESULT QVector<int> normalProtocols() const;

/**
     * tells you if the normal server is available
     * @since 4.5
     */
    Q_REQUIRED_RESULT bool isNormalPossible() const;

/**
     * Get the protocols for the TLS connections. Call this only
     * after the finished() signals has been sent.
     * @return an enum of the type Transport::EnumAuthenticationType
     * @since 4.1
     */
    Q_REQUIRED_RESULT QVector<int> tlsProtocols() const;

/**
     * Get the protocols for the SSL connections. Call this only
     * after the finished() signals has been sent.
     * @return an enum of the type Transport::EnumAuthenticationType
     */
    Q_REQUIRED_RESULT QVector<int> secureProtocols() const;

/**
     * tells you if the ssl server is available
     * @since 4.5
     */
    Q_REQUIRED_RESULT bool isSecurePossible() const;

/**
     * Get the special capabilities of the server.
     * Call this only after the finished() signals has been sent.
     *
     * @return the list of special capabilities of the server.
     * @since 4.1
     */
    Q_REQUIRED_RESULT QList<Capability> capabilities() const;

Q_SIGNALS:
    /**
     * This will be emitted when the test is done. It will contain
     * the values from the enum EnumEncryption which are possible.
     */
    void finished(const QVector<int> &);

private:
    Q_DECLARE_PRIVATE(ServerTest)
    ServerTestPrivate *const d;

Q_PRIVATE_SLOT(d, void slotNormalPossible())
    Q_PRIVATE_SLOT(d, void slotTlsDone())
    Q_PRIVATE_SLOT(d, void slotSslPossible())
    Q_PRIVATE_SLOT(d, void slotReadNormal(const QString &text))
    Q_PRIVATE_SLOT(d, void slotReadSecure(const QString &text))
    Q_PRIVATE_SLOT(d, void slotNormalNotPossible())
    Q_PRIVATE_SLOT(d, void slotSslNotPossible())
    Q_PRIVATE_SLOT(d, void slotUpdateProgress())
};
} // namespace MailTransport

0707010000003E000081A4000000000000000000000001610B83240000124B000000000000000000000000000000000000005000000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/socket.cpp/*
  SPDX-FileCopyrightText: 2006-2007 KovoKs <info@kovoks.nl>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

// Uncomment the next line for full comm debug
// #define comm_debug

// Own
#include "socket.h"

// Qt
#include <QByteArray>
#include <QNetworkProxy>
// KDE
#include "mailtransport_debug.h"

using namespace MailTransport;

namespace MailTransport
{
class SocketPrivate
{
public:
    SocketPrivate(Socket *s);
    Socket *const q;
    QSslSocket *socket = nullptr;
    QString server;
    QString protocol;
    int port = 0;
    bool secure = false;

// slots
    void slotConnected();
    void slotStateChanged(QAbstractSocket::SocketState state);
    void slotModeChanged(QSslSocket::SslMode state);
    void slotSocketRead();
    void slotSslErrors(const QList<QSslError> &errors);

private:
    QString m_msg;
};
}

SocketPrivate::SocketPrivate(Socket *s)
    : q(s)
{
}

void SocketPrivate::slotConnected()
{
    qCDebug(MAILTRANSPORT_LOG);

if (!secure) {
        qCDebug(MAILTRANSPORT_LOG) << "normal connect";
        Q_EMIT q->connected();
    } else {
        qCDebug(MAILTRANSPORT_LOG) << "encrypted connect";
        socket->startClientEncryption();
    }
}

void SocketPrivate::slotStateChanged(QAbstractSocket::SocketState state)
{
#ifdef comm_debug
    qCDebug(MAILTRANSPORT_LOG) << "State is now:" << (int)state;
#endif
    if (state == QAbstractSocket::UnconnectedState) {
        Q_EMIT q->failed();
    }
}

void SocketPrivate::slotModeChanged(QSslSocket::SslMode state)
{
#ifdef comm_debug
    qCDebug(MAILTRANSPORT_LOG) << "Mode is now:" << state;
#endif
    if (state == QSslSocket::SslClientMode) {
        Q_EMIT q->tlsDone();
    }
}

void SocketPrivate::slotSocketRead()
{
    qCDebug(MAILTRANSPORT_LOG);

if (!socket) {
        return;
    }

m_msg += QLatin1String(socket->readAll());

if (!m_msg.endsWith(QLatin1Char('\n'))) {
        return;
    }

#ifdef comm_debug
    qCDebug(MAILTRANSPORT_LOG) << socket->isEncrypted() << m_msg.trimmed();
#endif

Q_EMIT q->data(m_msg);
    m_msg.clear();
}

void SocketPrivate::slotSslErrors(const QList<QSslError> &)
{
    qCDebug(MAILTRANSPORT_LOG);
    /* We can safely ignore the errors, we are only interested in the
    capabilities. We're not sending auth info. */
    socket->ignoreSslErrors();
    Q_EMIT q->connected();
}

// ------------------ end private ---------------------------//

Socket::Socket(QObject *parent)
    : QObject(parent)
    , d(new SocketPrivate(this))
{
    qCDebug(MAILTRANSPORT_LOG);
}

Socket::~Socket()
{
    qCDebug(MAILTRANSPORT_LOG);
    delete d;
}

void Socket::reconnect()
{
    qCDebug(MAILTRANSPORT_LOG) << "Connecting to:" << d->server << ":" << d->port;

#ifdef comm_debug
    // qCDebug(MAILTRANSPORT_LOG) << d->protocol;
#endif

if (d->socket) {
        return;
    }

d->socket = new QSslSocket(this);
    d->socket->setProxy(QNetworkProxy::DefaultProxy);
    d->socket->connectToHost(d->server, d->port);

d->socket->setProtocol(QSsl::AnyProtocol);

connect(d->socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), SLOT(slotStateChanged(QAbstractSocket::SocketState)));
    connect(d->socket, SIGNAL(modeChanged(QSslSocket::SslMode)), SLOT(slotModeChanged(QSslSocket::SslMode)));
    connect(d->socket, SIGNAL(connected()), SLOT(slotConnected()));
    connect(d->socket, SIGNAL(readyRead()), SLOT(slotSocketRead()));
    connect(d->socket, &QSslSocket::encrypted, this, &Socket::connected);
    connect(d->socket, SIGNAL(sslErrors(QList<QSslError>)), SLOT(slotSslErrors(QList<QSslError>)));
}

void Socket::write(const QString &text)
{
    // qCDebug(MAILTRANSPORT_LOG);
    // Eat things in the queue when there is no connection. We need
    // to get a connection first don't we...
    if (!d->socket || !available()) {
        return;
    }

QByteArray cs = (text + QLatin1String("\r\n")).toLatin1();

#ifdef comm_debug
    qCDebug(MAILTRANSPORT_LOG) << "C   :" << cs;
#endif

d->socket->write(cs.data(), cs.size());
}

bool Socket::available()
{
    // qCDebug(MAILTRANSPORT_LOG);
    bool ok = d->socket && d->socket->state() == QAbstractSocket::ConnectedState;
    return ok;
}

void Socket::startTLS()
{
    qCDebug(MAILTRANSPORT_LOG) << objectName();
    d->socket->setProtocol(QSsl::TlsV1_0OrLater);
    d->socket->startClientEncryption();
}

void Socket::setProtocol(const QString &proto)
{
    d->protocol = proto;
}

void Socket::setServer(const QString &server)
{
    d->server = server;
}

void Socket::setPort(int port)
{
    d->port = port;
}

int Socket::port() const
{
    return d->port;
}

void Socket::setSecure(bool what)
{
    d->secure = what;
}

#include "moc_socket.cpp"
0707010000003F000081A4000000000000000000000001610B83240000097F000000000000000000000000000000000000004E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/socket.h/*
  SPDX-FileCopyrightText: 2006-2007 KovoKs <info@kovoks.nl>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>

#include <QSslSocket>

namespace MailTransport
{
class SocketPrivate;

/**
 * @class Socket
 * Responsible for communicating with the server, it's designed to work
 * with the ServerTest class.
 * @author Tom Albers <tomalbers@kde.nl>
 */
class Socket : public QObject
{
    Q_OBJECT

public:
    /**
     * Constructor, it will not auto connect. Call reconnect() to connect to
     * the parameters given.
     * @param parent the parent
     */
    explicit Socket(QObject *parent);

/**
     * Destructor
     */
    ~Socket() override;

/**
     * Existing connection will be closed and a new connection will be
     * made
     */
    virtual void reconnect();

/**
     * Write @p text to the socket
     */
    virtual void write(const QString &text);

/**
     * @return true when the connection is live and kicking
     */
    virtual bool available();

/**
     * set the protocol to use
     */
    void setProtocol(const QString &proto);

/**
     * set the server to use
     */
    void setServer(const QString &server);

/**
     * set the port to use. If not specified, it will use the default
     * belonging to the protocol.
     */
    void setPort(int port);

/**
     * returns the used port.
     */
    int port() const;

/**
     * this will be a secure connection
     */
    void setSecure(bool what);

/**
     * If you want to start TLS encryption, call this. For example after the starttls command.
     */
    void startTLS();

private:
    Q_DECLARE_PRIVATE(Socket)
    SocketPrivate *const d;

Q_PRIVATE_SLOT(d, void slotConnected())
    Q_PRIVATE_SLOT(d, void slotStateChanged(QAbstractSocket::SocketState state))
    Q_PRIVATE_SLOT(d, void slotModeChanged(QSslSocket::SslMode state))
    Q_PRIVATE_SLOT(d, void slotSocketRead())
    Q_PRIVATE_SLOT(d, void slotSslErrors(const QList<QSslError> &errors))

Q_SIGNALS:
    /**
     * emits the incoming data
     */
    void data(const QString &);

/**
     * emitted when there is a connection (ready to send something).
     */
    void connected();

/**
     * emitted when not connected.
     */
    void failed();

/**
     * emitted when startShake() is completed.
     */
    void tlsDone();
};
} // namespace MailTransport

07070100000040000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000004B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests07070100000041000081A4000000000000000000000001610B83240000029B000000000000000000000000000000000000005A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests/CMakeLists.txt
include(ECMMarkAsTest)

find_package(KF5TextWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)

add_executable(transportmgr transportmgr.cpp)
ecm_mark_as_test(transportmgr)
target_link_libraries(transportmgr KF5MailTransport Qt::Widgets KF5::I18n KF5::ConfigGui KF5::TextWidgets KF5::CoreAddons)

add_executable(servertest servertest.cpp)
ecm_mark_as_test(servertest)
target_link_libraries(servertest KF5MailTransport KF5::I18n KF5::ConfigGui Qt::Widgets)

add_executable(addtransportdialogng_gui addtransportdialogng_gui.cpp)
ecm_mark_as_test(addtransportdialogng_gui)
target_link_libraries(addtransportdialogng_gui KF5MailTransport KF5::I18n KF5::ConfigGui Qt::Widgets)
07070100000042000081A4000000000000000000000001610B8324000003EC000000000000000000000000000000000000006800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests/addtransportdialogng_gui.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "addtransportdialogng_gui.h"
#include "../src/kmailtransport/widgets/addtransportdialogng.h"

#include <QApplication>
#include <QHBoxLayout>
#include <QPushButton>
#include <QStandardPaths>

AddTransportDialogNG_gui::AddTransportDialogNG_gui(QWidget *parent)
    : QWidget(parent)
{
    auto layout = new QHBoxLayout(this);
    auto button = new QPushButton(QStringLiteral("Add transport"));
    layout->addWidget(button);
    connect(button, &QPushButton::clicked, this, [this] {
        auto dlg = new MailTransport::AddTransportDialogNG(this);
        dlg->exec();
        delete dlg;
    });
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("addtransportnewng"));
    QStandardPaths::setTestModeEnabled(true);
    auto t = new AddTransportDialogNG_gui();
    t->show();
    app.exec();
    delete t;
}
07070100000043000081A4000000000000000000000001610B83240000012C000000000000000000000000000000000000006600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests/addtransportdialogng_gui.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QWidget>

class AddTransportDialogNG_gui : public QWidget
{
    Q_OBJECT
public:
    explicit AddTransportDialogNG_gui(QWidget *parent = nullptr);
};

07070100000044000081A4000000000000000000000001610B8324000002EF000000000000000000000000000000000000005A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests/servertest.cpp/*
    SPDX-FileCopyrightText: 2015 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "servertest.h"

#include <QApplication>
#include <QDebug>

using namespace MailTransport;

int main(int argc, char **argv)
{
    if (argc <= 2) {
        qFatal("Usage: servertest <protocol> <hostname>");
    }

QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("kmailtransport-servertest"));

ServerTest test;
    test.setProtocol(app.arguments().at(1));
    test.setServer(app.arguments().at(2));
    test.start();
    QObject::connect(&test, &ServerTest::finished, [](const QVector<int> &encs) {
        qDebug() << encs;
        QCoreApplication::quit();
    });
    return app.exec();
}
07070100000045000081A4000000000000000000000001610B832400001181000000000000000000000000000000000000005C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests/transportmgr.cpp/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportmgr.h"

#include <QVBoxLayout>
#include <transport.h>
#include <transportjob.h>
#include <transportmanager.h>
#include <widgets/transportmanagementwidget.h>

#include <KTextEdit>
#include <QApplication>
#include <QDebug>
#include <QLineEdit>

#include <QPushButton>

using namespace MailTransport;

TransportMgr::TransportMgr()
    : mCurrentJob(nullptr)
{
    auto vbox = new QVBoxLayout(this);
    vbox->setContentsMargins(0, 0, 0, 0);

vbox->addWidget(new TransportManagementWidget(this));
    mComboBox = new TransportComboBox(this);
    mComboBox->setEditable(true);
    vbox->addWidget(mComboBox);
    auto b = new QPushButton(QStringLiteral("&Edit"), this);
    vbox->addWidget(b);
    connect(b, &QPushButton::clicked, this, &TransportMgr::editBtnClicked);
    b = new QPushButton(QStringLiteral("&Remove all transports"), this);
    vbox->addWidget(b);
    connect(b, &QPushButton::clicked, this, &TransportMgr::removeAllBtnClicked);
    mSenderEdit = new QLineEdit(this);
    mSenderEdit->setPlaceholderText(QStringLiteral("Sender"));
    vbox->addWidget(mSenderEdit);
    mToEdit = new QLineEdit(this);
    mToEdit->setPlaceholderText(QStringLiteral("To"));
    vbox->addWidget(mToEdit);
    mCcEdit = new QLineEdit(this);
    mCcEdit->setPlaceholderText(QStringLiteral("Cc"));
    vbox->addWidget(mCcEdit);
    mBccEdit = new QLineEdit(this);
    mBccEdit->setPlaceholderText(QStringLiteral("Bcc"));
    vbox->addWidget(mBccEdit);
    mMailEdit = new KTextEdit(this);
    mMailEdit->setAcceptRichText(false);
    mMailEdit->setLineWrapMode(QTextEdit::NoWrap);
    vbox->addWidget(mMailEdit);
    b = new QPushButton(QStringLiteral("&Send"), this);
    connect(b, &QPushButton::clicked, this, &TransportMgr::sendBtnClicked);
    vbox->addWidget(b);
    b = new QPushButton(QStringLiteral("&Cancel"), this);
    connect(b, &QPushButton::clicked, this, &TransportMgr::cancelBtnClicked);
    vbox->addWidget(b);
}

void TransportMgr::removeAllBtnClicked()
{
    MailTransport::TransportManager *manager = MailTransport::TransportManager::self();
    const QList<Transport *> transports = manager->transports();
    for (int i = 0; i < transports.count(); i++) {
        MailTransport::Transport *transport = transports.at(i);
        qDebug() << transport->host();
        manager->removeTransport(transport->id());
    }
}

void TransportMgr::editBtnClicked()
{
    const int index = mComboBox->currentTransportId();
    if (index < 0) {
        return;
    }
    const auto transport = TransportManager::self()->transportById(index);
    TransportManager::self()->configureTransport(transport->identifier(), transport, this);
}

void TransportMgr::sendBtnClicked()
{
    TransportJob *job = TransportManager::self()->createTransportJob(mComboBox->currentTransportId());
    if (!job) {
        qDebug() << "Invalid transport!";
        return;
    }
    job->setSender(mSenderEdit->text());
    job->setTo(mToEdit->text().isEmpty() ? QStringList() : mToEdit->text().split(QLatin1Char(',')));
    job->setCc(mCcEdit->text().isEmpty() ? QStringList() : mCcEdit->text().split(QLatin1Char(',')));
    job->setBcc(mBccEdit->text().isEmpty() ? QStringList() : mBccEdit->text().split(QLatin1Char(',')));
    job->setData(mMailEdit->document()->toPlainText().toLatin1());
    connect(job, &KJob::result, this, &TransportMgr::jobResult);
    connect(job, SIGNAL(percent(KJob *, ulong)), SLOT(jobPercent(KJob *, ulong)));
    connect(job, &KJob::infoMessage, this, &TransportMgr::jobInfoMessage);
    mCurrentJob = job;
    TransportManager::self()->schedule(job);
}

void TransportMgr::cancelBtnClicked()
{
    if (mCurrentJob) {
        qDebug() << "kill success:" << mCurrentJob->kill();
    }
    mCurrentJob = nullptr;
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("transportmgr"));

auto t = new TransportMgr();
    t->show();
    app.exec();
    delete t;
}

void TransportMgr::jobResult(KJob *job)
{
    qDebug() << job->error() << job->errorText();
    mCurrentJob = nullptr;
}

void TransportMgr::jobPercent(KJob *job, unsigned long percent)
{
    Q_UNUSED(job)
    qDebug() << percent << "%";
}

void TransportMgr::jobInfoMessage(KJob *job, const QString &info, const QString &info2)
{
    Q_UNUSED(job)
    qDebug() << info;
    qDebug() << info2;
}
07070100000046000081A4000000000000000000000001610B8324000003B5000000000000000000000000000000000000005A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/tests/transportmgr.h/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#define USES_DEPRECATED_MAILTRANSPORT_API

#include <QWidget>
#include <widgets/transportcombobox.h>

class KJob;
class QLineEdit;
class KTextEdit;

class TransportMgr : public QWidget
{
    Q_OBJECT

public:
    TransportMgr();

private Q_SLOTS:
    void removeAllBtnClicked();
    void editBtnClicked();
    void sendBtnClicked();
    void cancelBtnClicked();
    void jobResult(KJob *job);
    void jobPercent(KJob *job, unsigned long percent);
    void jobInfoMessage(KJob *job, const QString &info, const QString &info2);

private:
    MailTransport::TransportComboBox *mComboBox = nullptr;
    QLineEdit *mSenderEdit = nullptr;
    QLineEdit *mToEdit = nullptr;
    QLineEdit *mCcEdit = nullptr;
    QLineEdit *mBccEdit = nullptr;
    KTextEdit *mMailEdit = nullptr;
    KJob *mCurrentJob = nullptr;
};

07070100000047000081A4000000000000000000000001610B832400002360000000000000000000000000000000000000005300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transport.cpp/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transport.h"
#include "mailtransport_defs.h"
#include "transport_p.h"
#include "transportmanager.h"
#include "transporttype_p.h"

#include "mailtransport_debug.h"
#include <KConfigGroup>
#include <KLocalizedString>
#include <KMessageBox>
#include <KStringHandler>
#include <KWallet/KWallet>
#include <qt5keychain/keychain.h>
using namespace QKeychain;
using namespace MailTransport;
using namespace KWallet;

Transport::Transport(const QString &cfgGroup)
    : TransportBase(cfgGroup)
    , d(new TransportPrivate)
{
    qCDebug(MAILTRANSPORT_LOG) << cfgGroup;
    d->passwordLoaded = false;
    d->passwordDirty = false;
    d->storePasswordInFile = false;
    d->needsWalletMigration = false;
    load();
    loadPassword();
}

Transport::~Transport()
{
    delete d;
}

bool Transport::isValid() const
{
    return (id() > 0) && !host().isEmpty() && port() <= 65536;
}

void Transport::loadPassword()
{
    if (!d->passwordLoaded && requiresAuthentication() && storePassword() && d->password.isEmpty()) {
        readPassword();
    }
}

QString Transport::password()
{
    return d->password;
}

void Transport::setPassword(const QString &passwd)
{
    d->passwordLoaded = true;
    if (d->password == passwd) {
        return;
    }
    d->passwordDirty = true;
    d->password = passwd;
}

void Transport::forceUniqueName()
{
    QStringList existingNames;
    const auto lstTransports = TransportManager::self()->transports();
    for (Transport *t : lstTransports) {
        if (t->id() != id()) {
            existingNames << t->name();
        }
    }
    int suffix = 1;
    QString origName = name();
    while (existingNames.contains(name())) {
        setName(
            i18nc("%1: name; %2: number appended to it to make "
                  "it unique among a list of names",
                  "%1 #%2",
                  origName,
                  suffix));
        ++suffix;
    }
}

void Transport::updatePasswordState()
{
    Transport *original = TransportManager::self()->transportById(id(), false);
    if (original == this) {
        qCWarning(MAILTRANSPORT_LOG) << "Tried to update password state of non-cloned transport.";
        return;
    }
    if (original) {
        d->password = original->d->password;
        d->passwordLoaded = original->d->passwordLoaded;
        d->passwordDirty = original->d->passwordDirty;
    } else {
        qCWarning(MAILTRANSPORT_LOG) << "Transport with this ID not managed by transport manager.";
    }
}

bool Transport::isComplete() const
{
    return !requiresAuthentication() || !storePassword() || d->passwordLoaded;
}

QString Transport::authenticationTypeString() const
{
    return Transport::authenticationTypeString(authenticationType());
}

QString Transport::authenticationTypeString(int type)
{
    switch (type) {
    case EnumAuthenticationType::LOGIN:
        return QStringLiteral("LOGIN");
    case EnumAuthenticationType::PLAIN:
        return QStringLiteral("PLAIN");
    case EnumAuthenticationType::CRAM_MD5:
        return QStringLiteral("CRAM-MD5");
    case EnumAuthenticationType::DIGEST_MD5:
        return QStringLiteral("DIGEST-MD5");
    case EnumAuthenticationType::NTLM:
        return QStringLiteral("NTLM");
    case EnumAuthenticationType::GSSAPI:
        return QStringLiteral("GSSAPI");
    case EnumAuthenticationType::CLEAR:
        return i18nc("Authentication method", "Clear text");
    case EnumAuthenticationType::APOP:
        return QStringLiteral("APOP");
    case EnumAuthenticationType::ANONYMOUS:
        return i18nc("Authentication method", "Anonymous");
    case EnumAuthenticationType::XOAUTH2:
        return QStringLiteral("XOAUTH2");
    }
    Q_ASSERT(false);
    return QString();
}

void Transport::usrRead()
{
    TransportBase::usrRead();

setHost(host().trimmed());

if (d->oldName.isEmpty()) {
        d->oldName = name();
    }

// Set TransportType.
    {
        d->transportType = TransportType();
        d->transportType.d->mIdentifier = identifier();
        // qCDebug(MAILTRANSPORT_LOG) << "type" << identifier();
        // Now we have the type and possibly agentType.  Get the name, description
        // etc. from TransportManager.
        const TransportType::List &types = TransportManager::self()->types();
        int index = types.indexOf(d->transportType);
        if (index != -1) {
            d->transportType = types[index];
        } else {
            qCWarning(MAILTRANSPORT_LOG) << "Type unknown to manager.";
            d->transportType.d->mName = i18nc("An unknown transport type", "Unknown");
        }
    }

// we have everything we need
    if (!storePassword()) {
        return;
    }

if (d->passwordLoaded) {
        return;
    }

// try to find a password in the config file otherwise
    KConfigGroup group(config(), currentGroup());
    if (group.hasKey("password")) {
        d->password = KStringHandler::obscure(group.readEntry("password"));
    }

if (!d->password.isEmpty()) {
        d->passwordLoaded = true;
        if (Wallet::isEnabled()) {
            d->needsWalletMigration = true;
        } else {
            d->storePasswordInFile = true;
        }
    }
}

bool Transport::usrSave()
{
    if (requiresAuthentication() && storePassword() && d->passwordDirty) {
        const QString storePassword = d->password;
        Wallet *wallet = TransportManager::self()->wallet();
        if (!wallet || wallet->writePassword(QString::number(id()), d->password) != 0) {
            // wallet saving failed, ask if we should store in the config file instead
            if (d->storePasswordInFile
                || KMessageBox::warningYesNo(nullptr,
                                             i18n("KWallet is not available. It is strongly recommended to use "
                                                  "KWallet for managing your passwords.\n"
                                                  "However, the password can be stored in the configuration "
                                                  "file instead. The password is stored in an obfuscated format, "
                                                  "but should not be considered secure from decryption efforts "
                                                  "if access to the configuration file is obtained.\n"
                                                  "Do you want to store the password for server '%1' in the "
                                                  "configuration file?",
                                                  name()),
                                             i18n("KWallet Not Available"),
                                             KGuiItem(i18n("Store Password")),
                                             KGuiItem(i18n("Do Not Store Password")))
                    == KMessageBox::Yes) {
                // write to config file
                KConfigGroup group(config(), currentGroup());
                group.writeEntry("password", KStringHandler::obscure(storePassword));
                d->storePasswordInFile = true;
            }
        }
        d->passwordDirty = false;
    }

if (!TransportBase::usrSave()) {
        return false;
    }
    TransportManager::self()->emitChangesCommitted();
    if (name() != d->oldName) {
        Q_EMIT TransportManager::self()->transportRenamed(id(), d->oldName, name());
        d->oldName = name();
    }

return true;
}

void Transport::readPassword()
{
    // no need to load a password if the account doesn't require auth
    if (!requiresAuthentication()) {
        return;
    }
    d->passwordLoaded = true;

auto readJob = new ReadPasswordJob(WALLET_FOLDER, this);
    connect(readJob, &Job::finished, this, &Transport::readTransportPasswordFinished);
    readJob->setKey(QString::number(id()));
    readJob->start();
}

void Transport::readTransportPasswordFinished(QKeychain::Job *baseJob)
{
    auto job = qobject_cast<ReadPasswordJob *>(baseJob);
    Q_ASSERT(job);
    if (job->error()) {
        d->password.clear();
        d->passwordLoaded = false;
        qWarning() << "We have an error during reading password " << job->errorString();
    } else {
        setPassword(job->textData());
    }
}

bool Transport::needsWalletMigration() const
{
    return d->needsWalletMigration;
}

void Transport::migrateToWallet()
{
    qCDebug(MAILTRANSPORT_LOG) << "migrating" << id() << "to wallet";
    d->needsWalletMigration = false;
    KConfigGroup group(config(), currentGroup());
    group.deleteEntry("password");
    d->passwordDirty = true;
    d->storePasswordInFile = false;
    save();
}

Transport *Transport::clone() const
{
    const QString id = currentGroup().mid(10);
    return new Transport(id);
}

TransportType Transport::transportType() const
{
    if (!d->transportType.isValid()) {
        qCWarning(MAILTRANSPORT_LOG) << "Invalid transport type.";
    }
    return d->transportType;
}
07070100000048000081A4000000000000000000000001610B832400000EA6000000000000000000000000000000000000005100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transport.h/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>
#include <transportbase.h>
#include <transporttype.h>

class TransportPrivate;
namespace QKeychain
{
class Job;
}
namespace MailTransport
{
class TransportType;

/**
  Represents the settings of a specific mail transport.

To create a new empty Transport object, use TransportManager::createTransport().

Initialize an empty Transport object by calling the set...() methods defined in
  kcfg-generated TransportBase, and in this class.
*/
class MAILTRANSPORT_EXPORT Transport : public TransportBase
{
    Q_OBJECT
    friend class TransportManager;
    friend class TransportManagerPrivate;

public:
    /**
      Destructor
    */
    ~Transport() override;

using List = QList<Transport *>;

/**
      Returns true if this transport is valid, ie. has all necessary data set.
    */
    Q_REQUIRED_RESULT bool isValid() const;

/**
      Returns the password of this transport.
    */
    Q_REQUIRED_RESULT QString password();

/**
      Sets the password of this transport.
      @param passwd The new password.
    */
    void setPassword(const QString &passwd);

/**
      Makes sure the transport has a unique name.  Adds #1, #2, #3 etc. if
      necessary.
      @since 4.4
    */
    void forceUniqueName();

/**
      This function synchronizes the password of this transport with the
      password of the transport with the same ID that is managed by the
      transport manager. This is only useful for cloned transports, since
      their passwords don't automatically get updated when calling
      TransportManager::loadPasswordsAsync() or TransportManager::loadPasswords().

@sa clone()
      @since 4.2
    */
    void updatePasswordState();

/**
      Returns true if all settings have been loaded.
      This is the way to find out if the password has already been loaded
      from the wallet.
    */
    Q_REQUIRED_RESULT bool isComplete() const;

/**
      Returns a string representation of the authentication type.
    */
    Q_REQUIRED_RESULT QString authenticationTypeString() const;

/**
      Returns a string representation of the authentication type.
      Convenience function when there isn't a Transport object
      instantiated.

@since 4.5
    */
    static Q_REQUIRED_RESULT QString authenticationTypeString(int type);

/**
      Returns a deep copy of this Transport object which will no longer be
      automatically updated. Use this if you need to store a Transport object
      over a longer time. However it is recommended to store transport identifiers
      instead if possible.

@sa updatePasswordState()
    */
    Transport *clone() const;

/**
      Returns the type of this transport.
      @see TransportType.
      @since 4.4
    */
    Q_REQUIRED_RESULT TransportType transportType() const;

protected:
    /**
      Creates a Transport object. Should only be used by TransportManager.
      @param cfgGroup The KConfig group to read its data from.
    */
    Transport(const QString &cfgGroup);

void usrRead() override;
    bool usrSave() override;

/**
      Returns true if the password was not stored in the wallet.
    */
    Q_REQUIRED_RESULT bool needsWalletMigration() const;

/**
      Try to migrate the password from the config file to the wallet.
    */
    void migrateToWallet();

private Q_SLOTS:

// Used by our friend, TransportManager
    void readPassword();

private:
    void readTransportPasswordFinished(QKeychain::Job *baseJob);
    void loadPassword();
    TransportPrivate *const d;
};
} // namespace MailTransport

07070100000049000081A4000000000000000000000001610B8324000001F8000000000000000000000000000000000000005300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transport_p.h/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "transporttype.h"

/**
 * Private class that helps to provide binary compatibility between releases.
 * @internal
 */
class TransportPrivate
{
public:
    MailTransport::TransportType transportType;
    QString password;
    QString oldName;
    bool passwordLoaded;
    bool passwordDirty;
    bool storePasswordInFile;
    bool needsWalletMigration;
};

0707010000004A000081A4000000000000000000000001610B83240000010A000000000000000000000000000000000000005900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transportbase.kcfgcFile=mailtransport.kcfg
ClassName=TransportBase
NameSpace=MailTransport
Mutators=true
ItemAccessors=true
SetUserTexts=true
Visibility=MAILTRANSPORT_EXPORT
IncludeFiles=mailtransport_export.h,KLocalizedString
TranslationDomain=libmailtransport5
TranslationSystem=kde
0707010000004B000081A4000000000000000000000001610B8324000007D8000000000000000000000000000000000000005600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transportjob.cpp/*
    SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportjob.h"
#include "transport.h"

#include <QBuffer>

#include <KLocalizedString>

using namespace MailTransport;

class Q_DECL_HIDDEN MailTransport::TransportJob::Private
{
public:
    QString sender;
    QStringList to;
    QStringList cc;
    QStringList bcc;
    QByteArray data;
    Transport *transport = nullptr;
    QBuffer *buffer = nullptr;
};

TransportJob::TransportJob(Transport *transport, QObject *parent)
    : KCompositeJob(parent)
    , d(new Private)
{
    d->transport = transport;
    d->buffer = nullptr;
}

TransportJob::~TransportJob()
{
    delete d->transport;
    delete d;
}

void TransportJob::setSender(const QString &sender)
{
    d->sender = sender;
}

void TransportJob::setTo(const QStringList &to)
{
    d->to = to;
}

void TransportJob::setCc(const QStringList &cc)
{
    d->cc = cc;
}

void TransportJob::setBcc(const QStringList &bcc)
{
    d->bcc = bcc;
}

void TransportJob::setData(const QByteArray &data)
{
    d->data = data;
}

Transport *TransportJob::transport() const
{
    return d->transport;
}

QString TransportJob::sender() const
{
    return d->sender;
}

QStringList TransportJob::to() const
{
    return d->to;
}

QStringList TransportJob::cc() const
{
    return d->cc;
}

QStringList TransportJob::bcc() const
{
    return d->bcc;
}

QByteArray TransportJob::data() const
{
    return d->data;
}

QBuffer *TransportJob::buffer()
{
    if (!d->buffer) {
        d->buffer = new QBuffer(this);
        d->buffer->setData(d->data);
        d->buffer->open(QIODevice::ReadOnly);
        Q_ASSERT(d->buffer->isOpen());
    }
    return d->buffer;
}

void TransportJob::start()
{
    if (!transport()->isValid()) {
        setError(UserDefinedError);
        setErrorText(i18n("The outgoing account \"%1\" is not correctly configured.", transport()->name()));
        emitResult();
        return;
    }
    doStart();
}
0707010000004C000081A4000000000000000000000001610B832400000C1E000000000000000000000000000000000000005400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transportjob.h/*
  SPDX-FileCopyrightText: 2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>

#include <QStringList>

#include <KCompositeJob>

class QBuffer;

namespace MailTransport
{
class Transport;

/**
  Abstract base class for all mail transport jobs.
  This is a job that is supposed to send exactly one mail.

@deprecated Use MessageQueueJob for sending e-mail.
*/
class MAILTRANSPORT_DEPRECATED_EXPORT TransportJob : public KCompositeJob
{
    Q_OBJECT
    friend class TransportManager;

public:
    /**
      Deletes this transport job.
    */
    ~TransportJob() override;

/**
      Sets the sender of the mail.
      @p sender must be the plain email address, not including display name.
    */
    void setSender(const QString &sender);

/**
      Sets the "To" receiver(s) of the mail.
      @p to must be the plain email address(es), not including display name.
    */
    void setTo(const QStringList &to);

/**
      Sets the "Cc" receiver(s) of the mail.
      @p cc must be the plain email address(es), not including display name.
    */
    void setCc(const QStringList &cc);

/**
      Sets the "Bcc" receiver(s) of the mail.
      @p bcc must be the plain email address(es), not including display name.
    */
    void setBcc(const QStringList &bcc);

/**
      Sets the content of the mail.
    */
    void setData(const QByteArray &data);

/**
      Starts this job. It is recommended to not call this method directly but use
      TransportManager::schedule() to execute the job instead.

@see TransportManager::schedule()
    */
    void start() override;

/**
      Returns the Transport object containing the mail transport settings.
    */
    Transport *transport() const;

protected:
    /**
      Creates a new mail transport job.
      @param transport The transport configuration. This must be a deep copy of
      a Transport object, the job takes the ownership of this object.
      @param parent The parent object.
      @see TransportManager::createTransportJob()
    */
    explicit TransportJob(Transport *transport, QObject *parent = nullptr);

/**
      Returns the sender of the mail.
    */
    Q_REQUIRED_RESULT QString sender() const;

/**
      Returns the "To" receiver(s) of the mail.
    */
    Q_REQUIRED_RESULT QStringList to() const;

/**
      Returns the "Cc" receiver(s) of the mail.
    */
    Q_REQUIRED_RESULT QStringList cc() const;

/**
      Returns the "Bcc" receiver(s) of the mail.
    */
    Q_REQUIRED_RESULT QStringList bcc() const;

/**
      Returns the data of the mail.
    */
    Q_REQUIRED_RESULT QByteArray data() const;

/**
      Returns a QBuffer opened on the message data. This is useful for
      processing the data in smaller chunks.
    */
    QBuffer *buffer();

/**
      Do the actual work, implement in your subclass.
    */
    virtual void doStart() = 0;

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
} // namespace MailTransport

0707010000004D000081A4000000000000000000000001610B832400004D68000000000000000000000000000000000000005A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transportmanager.cpp/*
  SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportmanager.h"
#include "mailtransport_defs.h"
#include "plugins/transportabstractplugin.h"
#include "plugins/transportpluginmanager.h"
#include "transport.h"
#include "transport_p.h"
#include "transportjob.h"
#include "transporttype.h"
#include "transporttype_p.h"
#include "widgets/addtransportdialogng.h"
#include <MailTransport/TransportAbstractPlugin>

#include <QApplication>
#include <QDBusConnection>
#include <QDBusConnectionInterface>
#include <QDBusServiceWatcher>
#include <QPointer>
#include <QRandomGenerator>
#include <QRegularExpression>
#include <QStringList>

#include "mailtransport_debug.h"
#include <KConfig>
#include <KConfigGroup>
#include <KEMailSettings>
#include <KLocalizedString>
#include <KMessageBox>
#include <kcoreaddons_version.h>
#if KCOREADDONS_VERSION < QT_VERSION_CHECK(6, 0, 0)
#include <Kdelibs4ConfigMigrator>
#endif
#include <qt5keychain/keychain.h>
using namespace QKeychain;
#include <KWallet>

using namespace MailTransport;
using namespace KWallet;

namespace MailTransport
{
/**
 * Private class that helps to provide binary compatibility between releases.
 * @internal
 */
class TransportManagerPrivate
{
public:
    TransportManagerPrivate(TransportManager *parent)
        : q(parent)
    {
    }

~TransportManagerPrivate()
    {
        delete config;
        qDeleteAll(transports);
    }

KConfig *config = nullptr;
    QList<Transport *> transports;
    TransportType::List types;
    bool myOwnChange = false;
    bool appliedChange = false;
    KWallet::Wallet *wallet = nullptr;
    bool walletOpenFailed = false;
    bool walletAsyncOpen = false;
    int defaultTransportId = -1;
    bool isMainInstance = false;
    QList<TransportJob *> walletQueue;
    TransportManager *const q;

void readConfig();
    void writeConfig();
    void fillTypes();
    int createId() const;
    void prepareWallet();
    void validateDefault();
    void migrateToWallet();
    void updatePluginList();

// Slots
    void slotTransportsChanged();
    void slotWalletOpened(bool success);
    void dbusServiceUnregistered();
    void jobResult(KJob *job);
};
}

class StaticTransportManager : public TransportManager
{
public:
    StaticTransportManager()
        : TransportManager()
    {
    }
};

StaticTransportManager *sSelf = nullptr;

static void destroyStaticTransportManager()
{
    delete sSelf;
}

TransportManager::TransportManager()
    : QObject()
    , d(new TransportManagerPrivate(this))
{
#if KCOREADDONS_VERSION < QT_VERSION_CHECK(6, 0, 0)
    Kdelibs4ConfigMigrator migrate(QStringLiteral("transportmanager"));
    migrate.setConfigFiles(QStringList() << QStringLiteral("mailtransports"));
    migrate.migrate();
#endif
    qAddPostRoutine(destroyStaticTransportManager);
    d->config = new KConfig(QStringLiteral("mailtransports"));

QDBusConnection::sessionBus().registerObject(DBUS_OBJECT_PATH, this, QDBusConnection::ExportScriptableSlots | QDBusConnection::ExportScriptableSignals);

auto watcher = new QDBusServiceWatcher(DBUS_SERVICE_NAME, QDBusConnection::sessionBus(), QDBusServiceWatcher::WatchForUnregistration, this);
    connect(watcher, &QDBusServiceWatcher::serviceUnregistered, this, [this]() {
        d->dbusServiceUnregistered();
    });

QDBusConnection::sessionBus().connect(QString(), QString(), DBUS_INTERFACE_NAME, DBUS_CHANGE_SIGNAL, this, SLOT(slotTransportsChanged()));

d->isMainInstance = QDBusConnection::sessionBus().registerService(DBUS_SERVICE_NAME);

d->fillTypes();
}

TransportManager::~TransportManager()
{
    qRemovePostRoutine(destroyStaticTransportManager);
    delete d;
}

TransportManager *TransportManager::self()
{
    if (!sSelf) {
        sSelf = new StaticTransportManager;
        sSelf->d->readConfig();
    }
    return sSelf;
}

Transport *TransportManager::transportById(int id, bool def) const
{
    for (Transport *t : std::as_const(d->transports)) {
        if (t->id() == id) {
            return t;
        }
    }

if (def || (id == 0 && d->defaultTransportId != id)) {
        return transportById(d->defaultTransportId, false);
    }
    return nullptr;
}

Transport *TransportManager::transportByName(const QString &name, bool def) const
{
    for (Transport *t : std::as_const(d->transports)) {
        if (t->name() == name) {
            return t;
        }
    }
    if (def) {
        return transportById(0, false);
    }
    return nullptr;
}

QList<Transport *> TransportManager::transports() const
{
    return d->transports;
}

TransportType::List TransportManager::types() const
{
    return d->types;
}

Transport *TransportManager::createTransport() const
{
    int id = d->createId();
    auto t = new Transport(QString::number(id));
    t->setId(id);
    return t;
}

void TransportManager::addTransport(Transport *transport)
{
    if (d->transports.contains(transport)) {
        qCDebug(MAILTRANSPORT_LOG) << "Already have this transport.";
        return;
    }

qCDebug(MAILTRANSPORT_LOG) << "Added transport" << transport;
    d->transports.append(transport);
    d->validateDefault();
    emitChangesCommitted();
}

void TransportManager::schedule(TransportJob *job)
{
    connect(job, &TransportJob::result, this, [this](KJob *job) {
        d->jobResult(job);
    });

// check if the job is waiting for the wallet
    if (!job->transport()->isComplete()) {
        qCDebug(MAILTRANSPORT_LOG) << "job waits for wallet:" << job;
        d->walletQueue << job;
        loadPasswordsAsync();
        return;
    }

job->start();
}

void TransportManager::createDefaultTransport()
{
    KEMailSettings kes;
    Transport *t = createTransport();
    t->setName(i18n("Default Transport"));
    t->setHost(kes.getSetting(KEMailSettings::OutServer));
    if (t->isValid()) {
        t->save();
        addTransport(t);
    } else {
        qCWarning(MAILTRANSPORT_LOG) << "KEMailSettings does not contain a valid transport.";
    }
}

bool TransportManager::showTransportCreationDialog(QWidget *parent, ShowCondition showCondition)
{
    if (showCondition == IfNoTransportExists) {
        if (!isEmpty()) {
            return true;
        }

const int response = KMessageBox::messageBox(parent,
                                                     KMessageBox::WarningContinueCancel,
                                                     i18n("You must create an outgoing account before sending."),
                                                     i18n("Create Account Now?"),
                                                     KGuiItem(i18n("Create Account Now")));
        if (response != KMessageBox::Continue) {
            return false;
        }
    }

QPointer<AddTransportDialogNG> dialog = new AddTransportDialogNG(parent);
    const bool accepted = (dialog->exec() == QDialog::Accepted);
    delete dialog;
    return accepted;
}

void TransportManager::initializeTransport(const QString &identifier, Transport *transport)
{
    TransportAbstractPlugin *plugin = TransportPluginManager::self()->plugin(identifier);
    if (plugin) {
        plugin->initializeTransport(transport, identifier);
    }
}

bool TransportManager::configureTransport(const QString &identifier, Transport *transport, QWidget *parent)
{
    TransportAbstractPlugin *plugin = TransportPluginManager::self()->plugin(identifier);
    if (plugin) {
        return plugin->configureTransport(identifier, transport, parent);
    }
    return false;
}

TransportJob *TransportManager::createTransportJob(int transportId)
{
    Transport *t = transportById(transportId, false);
    if (!t) {
        return nullptr;
    }
    t = t->clone(); // Jobs delete their transports.
    t->updatePasswordState();
    TransportAbstractPlugin *plugin = TransportPluginManager::self()->plugin(t->identifier());
    if (plugin) {
        return plugin->createTransportJob(t, t->identifier());
    }
    Q_ASSERT(false);
    return nullptr;
}

TransportJob *TransportManager::createTransportJob(const QString &transport)
{
    bool ok = false;
    Transport *t = nullptr;

int transportId = transport.toInt(&ok);
    if (ok) {
        t = transportById(transportId);
    }

if (!t) {
        t = transportByName(transport, false);
    }

if (t) {
        return createTransportJob(t->id());
    }

return nullptr;
}

bool TransportManager::isEmpty() const
{
    return d->transports.isEmpty();
}

QVector<int> TransportManager::transportIds() const
{
    QVector<int> rv;
    rv.reserve(d->transports.count());
    for (Transport *t : std::as_const(d->transports)) {
        rv << t->id();
    }
    return rv;
}

QStringList TransportManager::transportNames() const
{
    QStringList rv;
    rv.reserve(d->transports.count());
    for (Transport *t : std::as_const(d->transports)) {
        rv << t->name();
    }
    return rv;
}

QString TransportManager::defaultTransportName() const
{
    Transport *t = transportById(d->defaultTransportId, false);
    if (t) {
        return t->name();
    }
    return QString();
}

int TransportManager::defaultTransportId() const
{
    return d->defaultTransportId;
}

void TransportManager::setDefaultTransport(int id)
{
    if (id == d->defaultTransportId || !transportById(id, false)) {
        return;
    }
    d->defaultTransportId = id;
    d->writeConfig();
}

void TransportManager::removePasswordFromWallet(int id)
{
    auto deleteJob = new DeletePasswordJob(WALLET_FOLDER);
    deleteJob->setKey(QString::number(id));
    deleteJob->start();
}

void TransportManager::removeTransport(int id)
{
    Transport *t = transportById(id, false);
    if (!t) {
        return;
    }
    auto plugin = MailTransport::TransportPluginManager::self()->plugin(t->identifier());
    if (plugin) {
        plugin->cleanUp(t);
    }
    Q_EMIT transportRemoved(t->id(), t->name());

d->transports.removeAll(t);
    d->validateDefault();
    const QString group = t->currentGroup();
    if (t->storePassword()) {
        auto deleteJob = new DeletePasswordJob(WALLET_FOLDER);
        deleteJob->setKey(QString::number(t->id()));
        deleteJob->start();
    }
    delete t;
    d->config->deleteGroup(group);
    d->writeConfig();
}

void TransportManagerPrivate::readConfig()
{
    QList<Transport *> oldTransports = transports;
    transports.clear();

static QRegularExpression re(QStringLiteral("^Transport (.+)$"));
    const QStringList groups = config->groupList().filter(re);
    for (const QString &s : groups) {
        const QRegularExpressionMatch match = re.match(s);
        if (!match.hasMatch()) {
            continue;
        }
        Transport *t = nullptr;
        // see if we happen to have that one already
        const QString capturedString = match.captured(1);
        const QString checkString = QLatin1String("Transport ") + capturedString;
        for (Transport *old : oldTransports) {
            if (old->currentGroup() == checkString) {
                qCDebug(MAILTRANSPORT_LOG) << "reloading existing transport:" << s;
                t = old;
                t->load();
                oldTransports.removeAll(old);
                break;
            }
        }

if (!t) {
            t = new Transport(capturedString);
        }
        if (t->id() <= 0) {
            t->setId(createId());
            t->save();
        }
        transports.append(t);
    }

qDeleteAll(oldTransports);
    oldTransports.clear();
    // read default transport
    KConfigGroup group(config, "General");
    defaultTransportId = group.readEntry("default-transport", 0);
    if (defaultTransportId == 0) {
        // migrated default transport contains the name instead
        QString name = group.readEntry("default-transport", QString());
        if (!name.isEmpty()) {
            Transport *t = q->transportByName(name, false);
            if (t) {
                defaultTransportId = t->id();
                writeConfig();
            }
        }
    }
    validateDefault();
    migrateToWallet();
    q->loadPasswordsAsync();
}

void TransportManagerPrivate::writeConfig()
{
    KConfigGroup group(config, "General");
    group.writeEntry("default-transport", defaultTransportId);
    config->sync();
    q->emitChangesCommitted();
}

void TransportManagerPrivate::fillTypes()
{
    Q_ASSERT(types.isEmpty());

updatePluginList();
    QObject::connect(MailTransport::TransportPluginManager::self(), &TransportPluginManager::updatePluginList, q, &TransportManager::updatePluginList);
}

void TransportManagerPrivate::updatePluginList()
{
    types.clear();
    const QVector<MailTransport::TransportAbstractPlugin *> lstPlugins = MailTransport::TransportPluginManager::self()->pluginsList();
    for (MailTransport::TransportAbstractPlugin *plugin : lstPlugins) {
        if (plugin->names().isEmpty()) {
            qCDebug(MAILTRANSPORT_LOG) << "Plugin " << plugin << " doesn't provide plugin";
        }
        const QVector<TransportAbstractPluginInfo> lstInfos = plugin->names();
        for (const MailTransport::TransportAbstractPluginInfo &info : lstInfos) {
            TransportType type;
            type.d->mName = info.name;
            type.d->mDescription = info.description;
            type.d->mIdentifier = info.identifier;
            type.d->mIsAkonadiResource = info.isAkonadi;
            types << type;
        }
    }
}

void TransportManager::updatePluginList()
{
    d->updatePluginList();
}

void TransportManager::emitChangesCommitted()
{
    d->myOwnChange = true; // prevent us from reading our changes again
    d->appliedChange = false; // but we have to read them at least once
    Q_EMIT transportsChanged();
    Q_EMIT changesCommitted();
}

void TransportManagerPrivate::slotTransportsChanged()
{
    if (myOwnChange && appliedChange) {
        myOwnChange = false;
        appliedChange = false;
        return;
    }

qCDebug(MAILTRANSPORT_LOG);
    config->reparseConfiguration();
    // FIXME: this deletes existing transport objects!
    readConfig();
    appliedChange = true; // to prevent recursion
    Q_EMIT q->transportsChanged();
}

int TransportManagerPrivate::createId() const
{
    QVector<int> usedIds;
    usedIds.reserve(1 + transports.count());
    for (Transport *t : std::as_const(transports)) {
        usedIds << t->id();
    }
    usedIds << 0; // 0 is default for unknown
    int newId;
    do {
        newId = QRandomGenerator::global()->generate();
    } while (usedIds.contains(newId));
    return newId;
}

KWallet::Wallet *TransportManager::wallet()
{
    if (d->wallet && d->wallet->isOpen()) {
        return d->wallet;
    }

if (!Wallet::isEnabled() || d->walletOpenFailed) {
        return nullptr;
    }

WId window = 0;
    if (qApp->activeWindow()) {
        window = qApp->activeWindow()->winId();
    } else if (!QApplication::topLevelWidgets().isEmpty()) {
        window = qApp->topLevelWidgets().first()->winId();
    }

delete d->wallet;
    d->wallet = Wallet::openWallet(Wallet::NetworkWallet(), window);

if (!d->wallet) {
        d->walletOpenFailed = true;
        return nullptr;
    }

d->prepareWallet();
    return d->wallet;
}

void TransportManagerPrivate::prepareWallet()
{
    if (!wallet) {
        return;
    }
    if (!wallet->hasFolder(WALLET_FOLDER)) {
        wallet->createFolder(WALLET_FOLDER);
    }
    wallet->setFolder(WALLET_FOLDER);
}

void TransportManager::loadPasswords()
{
    for (Transport *t : std::as_const(d->transports)) {
        t->readPassword();
    }

// flush the wallet queue
    const QList<TransportJob *> copy = d->walletQueue;
    d->walletQueue.clear();
    for (TransportJob *job : copy) {
        job->start();
    }

Q_EMIT passwordsChanged();
}

void TransportManager::loadPasswordsAsync()
{
    qCDebug(MAILTRANSPORT_LOG);

// check if there is anything to do at all
    bool found = false;
    for (Transport *t : std::as_const(d->transports)) {
        if (!t->isComplete()) {
            found = true;
            break;
        }
    }
    if (!found) {
        return;
    }

// async wallet opening
    if (!d->wallet && !d->walletOpenFailed) {
        WId window = 0;
        if (qApp->activeWindow()) {
            window = qApp->activeWindow()->winId();
        } else if (!QApplication::topLevelWidgets().isEmpty()) {
            window = qApp->topLevelWidgets().first()->winId();
        }

d->wallet = Wallet::openWallet(Wallet::NetworkWallet(), window, Wallet::Asynchronous);
        // Already async. It will be easy to port to qt5keychain
        if (d->wallet) {
            connect(d->wallet, &KWallet::Wallet::walletOpened, this, [this](bool status) {
                d->slotWalletOpened(status);
            });
            d->walletAsyncOpen = true;
        } else {
            d->walletOpenFailed = true;
            loadPasswords();
        }
        return;
    }
    if (d->wallet && !d->walletAsyncOpen) {
        loadPasswords();
    }
}

void TransportManagerPrivate::slotWalletOpened(bool success)
{
    qCDebug(MAILTRANSPORT_LOG);
    walletAsyncOpen = false;
    if (!success) {
        walletOpenFailed = true;
        delete wallet;
        wallet = nullptr;
    } else {
        prepareWallet();
    }
    q->loadPasswords();
}

void TransportManagerPrivate::validateDefault()
{
    if (!q->transportById(defaultTransportId, false)) {
        if (q->isEmpty()) {
            defaultTransportId = -1;
        } else {
            defaultTransportId = transports.constFirst()->id();
            writeConfig();
        }
    }
}

void TransportManagerPrivate::migrateToWallet()
{
    // check if we tried this already
    static bool firstRun = true;
    if (!firstRun) {
        return;
    }
    firstRun = false;

// check if we are the main instance
    if (!isMainInstance) {
        return;
    }

// check if migration is needed
    QStringList names;
    for (Transport *t : std::as_const(transports)) {
        if (t->needsWalletMigration()) {
            names << t->name();
        }
    }
    if (names.isEmpty()) {
        return;
    }

// ask user if he wants to migrate
    int result = KMessageBox::questionYesNoList(nullptr,
                                                i18n("The following mail transports store their passwords in an "
                                                     "unencrypted configuration file.\nFor security reasons, "
                                                     "please consider migrating these passwords to KWallet, the "
                                                     "KDE Wallet management tool,\nwhich stores sensitive data "
                                                     "for you in a strongly encrypted file.\n"
                                                     "Do you want to migrate your passwords to KWallet?"),
                                                names,
                                                i18n("Question"),
                                                KGuiItem(i18n("Migrate")),
                                                KGuiItem(i18n("Keep")),
                                                QStringLiteral("WalletMigrate"));
    if (result != KMessageBox::Yes) {
        return;
    }

// perform migration
    for (Transport *t : std::as_const(transports)) {
        if (t->needsWalletMigration()) {
            t->migrateToWallet();
        }
    }
}

void TransportManagerPrivate::dbusServiceUnregistered()
{
    QDBusConnection::sessionBus().registerService(DBUS_SERVICE_NAME);
}

void TransportManagerPrivate::jobResult(KJob *job)
{
    walletQueue.removeAll(static_cast<TransportJob *>(job));
}

#include "moc_transportmanager.cpp"
0707010000004E000081A4000000000000000000000001610B8324000022D4000000000000000000000000000000000000005800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transportmanager.h/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>
#include <transporttype.h>

#include <QList>
#include <QObject>

namespace KWallet
{
class Wallet;
}

namespace MailTransport
{
class Transport;
class TransportJob;
class TransportManagerPrivate;

/**
  @short Central transport management interface.

This class manages the creation, configuration, and removal of mail
  transports, as well as the loading and storing of mail transport settings.

It also handles the creation of transport jobs, although that behaviour is
  deprecated and you are encouraged to use MessageQueueJob.

@see MessageQueueJob.
*/
class MAILTRANSPORT_EXPORT TransportManager : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("D-Bus Interface", "org.kde.pim.TransportManager")

friend class Transport;
    friend class TransportManagerPrivate;

public:
    /**
      Destructor.
    */
    ~TransportManager() override;

/**
      Returns the TransportManager instance.
    */
    static TransportManager *self();

/**
      Tries to load passwords asynchronously from KWallet if needed.
      The passwordsChanged() signal is emitted once the passwords have been loaded.
      Nothing happens if the passwords were already available.
    */
    void loadPasswordsAsync();

/**
      Returns the Transport object with the given id.
      @param id The identifier of the Transport.
      @param def if set to true, the default transport will be returned if the
      specified Transport object could not be found, 0 otherwise.
      @returns A Transport object for immediate use. It might become invalid as
      soon as the event loop is entered again due to remote changes. If you need
      to store a Transport object, store the transport identifier instead.
    */
    Transport *transportById(int id, bool def = true) const;

/**
      Returns the transport object with the given name.
      @param name The transport name.
      @param def if set to true, the default transport will be returned if the
      specified Transport object could not be found, 0 otherwise.
      @returns A Transport object for immediate use, see transportById() for
      limitations.
    */
    Transport *transportByName(const QString &name, bool def = true) const;

/**
      Returns a list of all available transports.
      Note: The Transport objects become invalid as soon as a change occur, so
      they are only suitable for immediate use.
    */
    Q_REQUIRED_RESULT QList<Transport *> transports() const;

/**
      Returns a list of all available transport types.
    */
    Q_REQUIRED_RESULT TransportType::List types() const;

/**
      Creates a new, empty Transport object. The object is owned by the caller.
      If you want to add the Transport permanently (eg. after configuring it)
      call addTransport().
    */
    Transport *createTransport() const;

/**
      Adds the given transport. The object ownership is transferred to
      TransportMananger, ie. you must not delete @p transport.
      @param transport The Transport object to add.
    */
    void addTransport(Transport *transport);

/**
      Creates a mail transport job for the given transport identifier.
      Returns 0 if the specified transport is invalid.
      @param transportId The transport identifier.

@deprecated use MessageQueueJob to queue messages
                  and rely on the Dispatcher Agent to send them.
    */
    MAILTRANSPORT_DEPRECATED TransportJob *createTransportJob(int transportId);

/**
      Creates a mail transport job for the given transport identifier,
      or transport name.
      Returns 0 if the specified transport is invalid.
      @param transport A string defining a mail transport.

@deprecated use MessageQueueJob to queue messages
                  and rely on the Dispatcher Agent to send them.
    */
    MAILTRANSPORT_DEPRECATED TransportJob *createTransportJob(const QString &transport);

/**
      Executes the given transport job. This is the preferred way to start
      transport jobs. It takes care of asynchronously loading passwords from
      KWallet if necessary.
      @param job The completely configured transport job to execute.

@deprecated use MessageQueueJob to queue messages
                  and rely on the Dispatcher Agent to send them.
    */
    MAILTRANSPORT_DEPRECATED void schedule(TransportJob *job);

/**
      Tries to create a transport based on KEMailSettings.
      If the data in KEMailSettings is incomplete, no transport is created.
    */
    void createDefaultTransport();

/// Describes when to show the transport creation dialog
    enum ShowCondition {
        Always, ///< Show the transport creation dialog unconditionally
        IfNoTransportExists ///< Only show the transport creation dialog if no transport currently
        ///  exists. Ask the user if he wants to add a transport in
        ///  the other case.
    };

/**
      Shows a dialog for creating and configuring a new transport.
      @param parent Parent widget of the dialog.
      @param showCondition the condition under which the dialog is shown at all
      @return True if a new transport has been created and configured.
      @since 4.4
    */
    bool showTransportCreationDialog(QWidget *parent, ShowCondition showCondition = Always);

/**
      Open a configuration dialog for an existing transport.
      @param identifier The identifier.
      @param transport The transport to configure.  It can be a new transport,
                       or one already managed by TransportManager.
      @param parent The parent widget for the dialog.
      @return True if the user clicked Ok, false if the user cancelled.
      @since 4.4
    */
    bool configureTransport(const QString &identifier, Transport *transport, QWidget *parent);

void initializeTransport(const QString &identifier, Transport *transport);

public:
    /**
      Returns true if there are no mail transports at all.
    */
    Q_SCRIPTABLE bool isEmpty() const;

/**
      Returns a list of transport identifiers.
    */
    Q_SCRIPTABLE QVector<int> transportIds() const;

/**
      Returns a list of transport names.
    */
    Q_SCRIPTABLE QStringList transportNames() const;

/**
      Returns the default transport name.
    */
    Q_SCRIPTABLE QString defaultTransportName() const;

/**
      Returns the default transport identifier.
      Invalid if there are no transports at all.
    */
    Q_SCRIPTABLE int defaultTransportId() const;

/**
      Sets the default transport. The change will be in effect immediately.
      @param id The identifier of the new default transport.
    */
    Q_SCRIPTABLE void setDefaultTransport(int id);

/**
      Deletes the specified transport.
      @param id The identifier of the mail transport to remove.
    */
    Q_SCRIPTABLE void removeTransport(int id);

void removePasswordFromWallet(int id);
Q_SIGNALS:
    /**
      Emitted when transport settings have changed (by this or any other
      TransportManager instance).
    */
    Q_SCRIPTABLE void transportsChanged();

/**
      Internal signal to synchronize all TransportManager instances.
      This signal is emitted by the instance writing the changes.
      You probably want to use transportsChanged() instead.
    */
    Q_SCRIPTABLE void changesCommitted();

/**
      Emitted when passwords have been loaded from the wallet.
      If you made a deep copy of a transport, you should call updatePasswordState()
      for the cloned transport to ensure its password is updated as well.
    */
    void passwordsChanged();

/**
      Emitted when a transport is deleted.
      @param id The identifier of the deleted transport.
      @param name The name of the deleted transport.
    */
    void transportRemoved(int id, const QString &name);

/**
      Emitted when a transport has been renamed.
      @param id The identifier of the renamed transport.
      @param oldName The old name.
      @param newName The new name.
    */
    void transportRenamed(int id, const QString &oldName, const QString &newName);

protected:
    /**
      Returns a pointer to an open wallet if available, 0 otherwise.
      The wallet is opened synchronously if necessary.
    */
    KWallet::Wallet *wallet();

/**
      Loads all passwords synchronously.
    */
    void loadPasswords();

/**
      Singleton class, the only instance resides in the static object sSelf.
    */
    TransportManager();

private:
    // These are used by our friend, Transport
    void emitChangesCommitted();
    void updatePluginList();

private:
    TransportManagerPrivate *const d;

Q_PRIVATE_SLOT(d, void slotTransportsChanged())
};
} // namespace MailTransport

0707010000004F000081A4000000000000000000000001610B832400000405000000000000000000000000000000000000005700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transporttype.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transporttype.h"
#include "transporttype_p.h"

using namespace MailTransport;

TransportType::TransportType()
    : d(new Private)
{
}

TransportType::TransportType(const TransportType &other)
    : d(other.d)
{
}

TransportType::~TransportType()
{
}

TransportType &TransportType::operator=(const TransportType &other)
{
    if (this != &other) {
        d = other.d;
    }
    return *this;
}

bool TransportType::operator==(const TransportType &other) const
{
    return d->mIdentifier == other.d->mIdentifier;
}

bool TransportType::isValid() const
{
    return !d->mIdentifier.isEmpty();
}

QString TransportType::name() const
{
    return d->mName;
}

QString TransportType::description() const
{
    return d->mDescription;
}

QString TransportType::identifier() const
{
    return d->mIdentifier;
}

bool TransportType::isAkonadiResource() const
{
    return d->mIsAkonadiResource;
}
07070100000050000081A4000000000000000000000001610B832400000852000000000000000000000000000000000000005500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transporttype.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "mailtransport_export.h"
#include "transport.h"

#include <QString>

namespace MailTransport
{
class AddTransportDialog;
class TransportManager;

/**
  @short A representation of a transport type.

Represents an available transport type.  SMTP is available

All available transport types can be retrieved via TransportManager::types().

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORT_EXPORT TransportType
{
    friend class AddTransportDialog;
    friend class Transport;
    friend class TransportManager;
    friend class TransportManagerPrivate;

public:
    /**
      Describes a list of transport types.
    */
    using List = QVector<TransportType>;

/**
      Constructs a new TransportType.
    */
    TransportType();

/**
      Creates a copy of the @p other TransportType.
    */
    TransportType(const TransportType &other);

/**
      Destroys the TransportType.
    */
    ~TransportType();

/**
     * Replaces the transport type by the @p other.
     */
    TransportType &operator=(const TransportType &other);

/**
     * Compares the transport type with the @p other.
     */
    Q_REQUIRED_RESULT bool operator==(const TransportType &other) const;

/**
      Returns whether the transport type is valid.
    */
    Q_REQUIRED_RESULT bool isValid() const;

/**
      Returns the i18n'ed name of the transport type.
    */
    Q_REQUIRED_RESULT QString name() const;

/**
      Returns a description of the transport type.
    */
    Q_REQUIRED_RESULT QString description() const;

/**
     * Returns a plugin identifier
     */
    Q_REQUIRED_RESULT QString identifier() const;

Q_REQUIRED_RESULT bool isAkonadiResource() const;

private:
    //@cond PRIVATE
    class Private;
    QSharedDataPointer<Private> d;
    //@endcond
};
} // namespace MailTransport

Q_DECLARE_METATYPE(MailTransport::TransportType)
Q_DECLARE_TYPEINFO(MailTransport::TransportType, Q_MOVABLE_TYPE);

07070100000051000081A4000000000000000000000001610B8324000002BC000000000000000000000000000000000000005700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/transporttype_p.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QSharedData>
#include <QString>

namespace MailTransport
{
/**
  @internal
*/
class TransportType::Private : public QSharedData
{
public:
    Private()
    {
    }

Private(const Private &other)
        : QSharedData(other)
    {
        mName = other.mName;
        mDescription = other.mDescription;
        mIdentifier = other.mIdentifier;
        mIsAkonadiResource = other.mIsAkonadiResource;
    }

QString mName;
    QString mDescription;
    QString mIdentifier;
    bool mIsAkonadiResource = false;
};
} // namespace MailTransport

07070100000052000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000004800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/ui07070100000053000081A4000000000000000000000001610B8324000009BF000000000000000000000000000000000000005E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/ui/addtransportdialog.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>AddTransportDialog</class>
 <widget class="QWidget" name="AddTransportDialog">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>482</width>
    <height>353</height>
   </rect>
  </property>
  <property name="minimumSize">
   <size>
    <width>0</width>
    <height>0</height>
   </size>
  </property>
  <property name="windowTitle">
   <string>Step One: Select Transport Type</string>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item row="0" column="0">
    <widget class="QLabel" name="label">
     <property name="text">
      <string comment="The name of a mail transport">Name:</string>
     </property>
    </widget>
   </item>
   <item row="0" column="1">
    <widget class="QLineEdit" name="name"/>
   </item>
   <item row="1" column="1">
    <widget class="QCheckBox" name="setDefault">
     <property name="text">
      <string>Make this the default outgoing account</string>
     </property>
    </widget>
   </item>
   <item row="2" column="0" colspan="2">
    <widget class="QLabel" name="descLabel">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="text">
      <string>Select an account type from the list below:</string>
     </property>
     <property name="alignment">
      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
     </property>
     <property name="wordWrap">
      <bool>true</bool>
     </property>
    </widget>
   </item>
   <item row="3" column="0" colspan="2">
    <widget class="QTreeWidget" name="typeListView">
     <property name="alternatingRowColors">
      <bool>true</bool>
     </property>
     <property name="rootIsDecorated">
      <bool>false</bool>
     </property>
     <column>
      <property name="text">
       <string>Type</string>
      </property>
     </column>
     <column>
      <property name="text">
       <string>Description</string>
      </property>
     </column>
    </widget>
   </item>
  </layout>
 </widget>
 <resources/>
 <connections/>
</ui>
07070100000054000081A4000000000000000000000001610B8324000009DC000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/ui/transportmanagementwidget.ui<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MailTransport::TransportManagementWidget</class>
 <widget class="QWidget" name="MailTransport::TransportManagementWidget">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <item row="3" column="1">
    <widget class="QPushButton" name="removeButton">
     <property name="text">
      <string>Remo&amp;ve</string>
     </property>
    </widget>
   </item>
   <item row="5" column="1">
    <widget class="QPushButton" name="defaultButton">
     <property name="text">
      <string>&amp;Set as Default</string>
     </property>
    </widget>
   </item>
   <item row="0" column="0" rowspan="7">
    <widget class="TransportListView" name="transportList">
     <property name="itemsExpandable">
      <bool>false</bool>
     </property>
    </widget>
   </item>
   <item row="6" column="1">
    <spacer>
     <property name="orientation">
      <enum>Qt::Vertical</enum>
     </property>
     <property name="sizeHint" stdset="0">
      <size>
       <width>20</width>
       <height>141</height>
      </size>
     </property>
    </spacer>
   </item>
   <item row="0" column="1">
    <widget class="QPushButton" name="addButton">
     <property name="text">
      <string>A&amp;dd...</string>
     </property>
    </widget>
   </item>
   <item row="2" column="1">
    <widget class="QPushButton" name="renameButton">
     <property name="text">
      <string>&amp;Rename</string>
     </property>
    </widget>
   </item>
   <item row="1" column="1">
    <widget class="QPushButton" name="editButton">
     <property name="text">
      <string>&amp;Modify...</string>
     </property>
    </widget>
   </item>
   <item row="4" column="1">
    <widget class="KSeparator" name="kseparator"/>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>KSeparator</class>
   <extends>QFrame</extends>
   <header>kseparator.h</header>
  </customwidget>
  <customwidget>
   <class>TransportListView</class>
   <extends>QTreeWidget</extends>
   <header location="global">widgets/transportlistview.h</header>
  </customwidget>
 </customwidgets>
 <tabstops>
  <tabstop>transportList</tabstop>
  <tabstop>addButton</tabstop>
  <tabstop>editButton</tabstop>
  <tabstop>renameButton</tabstop>
  <tabstop>removeButton</tabstop>
  <tabstop>defaultButton</tabstop>
 </tabstops>
 <resources/>
 <connections/>
</ui>
07070100000055000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000004D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets07070100000056000081A4000000000000000000000001610B832400001522000000000000000000000000000000000000006600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/addtransportdialogng.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "addtransportdialogng.h"
#include "transport.h"
#include "transportconfigwidget.h"
#include "transportmanager.h"
#include "transporttype.h"
#include "ui_addtransportdialog.h"

#include "mailtransport_debug.h"
#include <QDialogButtonBox>

#include <QPushButton>

using namespace MailTransport;

/**
  @internal
*/
class Q_DECL_HIDDEN AddTransportDialogNG::Private
{
public:
    Private(AddTransportDialogNG *qq)
        : q(qq)
    {
    }

QString selectedType() const;

/**
      Enables the OK button if a type is selected.
    */
    void updateOkButton(); // slot
    void doubleClicked(); // slot
    void writeConfig();
    void readConfig();

AddTransportDialogNG *const q;
    QPushButton *okButton = nullptr;
    ::Ui::AddTransportDialog ui;
};

void AddTransportDialogNG::Private::writeConfig()
{
    KConfigGroup group(KSharedConfig::openStateConfig(), "AddTransportDialog");
    group.writeEntry("Size", q->size());
}

void AddTransportDialogNG::Private::readConfig()
{
    KConfigGroup group(KSharedConfig::openStateConfig(), "AddTransportDialog");
    const QSize sizeDialog = group.readEntry("Size", QSize(300, TransportManager::self()->types().size() > 1 ? 300 : 160));
    if (sizeDialog.isValid()) {
        q->resize(sizeDialog);
    }
}

QString AddTransportDialogNG::Private::selectedType() const
{
    const QList<QTreeWidgetItem *> sel = ui.typeListView->selectedItems();
    if (!sel.empty()) {
        return sel.first()->data(0, Qt::UserRole).toString();
    }
    return {};
}

void AddTransportDialogNG::Private::doubleClicked()
{
    if (!selectedType().isEmpty() && !ui.name->text().trimmed().isEmpty()) {
        q->accept();
    }
}

void AddTransportDialogNG::Private::updateOkButton()
{
    // Make sure a type is selected before allowing the user to continue.
    okButton->setEnabled(!selectedType().isEmpty() && !ui.name->text().trimmed().isEmpty());
}

AddTransportDialogNG::AddTransportDialogNG(QWidget *parent)
    : QDialog(parent)
    , d(new Private(this))
{
    // Setup UI.
    {
        auto mainLayout = new QVBoxLayout(this);
        auto widget = new QWidget(this);
        d->ui.setupUi(widget);
        mainLayout->addWidget(widget);
        setWindowTitle(i18nc("@title:window", "Create Outgoing Account"));
        auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
        d->okButton = buttonBox->button(QDialogButtonBox::Ok);
        d->okButton->setText(i18nc("create and configure a mail transport", "Create and Configure"));
        d->okButton->setEnabled(false);
        d->okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
        mainLayout->addWidget(buttonBox);
        connect(buttonBox, &QDialogButtonBox::accepted, this, &AddTransportDialogNG::accept);
        connect(buttonBox, &QDialogButtonBox::rejected, this, &AddTransportDialogNG::reject);
    }

// Populate type list.
    const auto transportTypes = TransportManager::self()->types();
    for (const TransportType &type : transportTypes) {
        auto treeItem = new QTreeWidgetItem(d->ui.typeListView);
        treeItem->setText(0, type.name());
        treeItem->setText(1, type.description());
        treeItem->setToolTip(1, type.description());
        treeItem->setData(0, Qt::UserRole, type.identifier()); // the transport type
        if (type.identifier() == QLatin1String("SMTP")) {
            treeItem->setSelected(true); // select SMTP by default
        }
    }
    d->ui.typeListView->resizeColumnToContents(0);

// if we only have one type, don't bother the user with this
    if (d->ui.typeListView->invisibleRootItem()->childCount() == 1) {
        d->ui.descLabel->hide();
        d->ui.typeListView->hide();
    }

updateGeometry();
    d->ui.typeListView->setFocus();

// Connect user input.
    connect(d->ui.typeListView, &QTreeWidget::itemClicked, this, [this]() {
        d->updateOkButton();
    });
    connect(d->ui.typeListView, &QTreeWidget::itemSelectionChanged, this, [this]() {
        d->updateOkButton();
    });
    connect(d->ui.typeListView, &QTreeWidget::itemDoubleClicked, this, [this]() {
        d->doubleClicked();
    });
    connect(d->ui.name, &QLineEdit::textChanged, this, [this]() {
        d->updateOkButton();
    });
    d->readConfig();
}

AddTransportDialogNG::~AddTransportDialogNG()
{
    d->writeConfig();
    delete d;
}

void AddTransportDialogNG::accept()
{
    if (d->selectedType().isEmpty()) {
        return;
    }

// Create a new transport and configure it.
    Transport *transport = TransportManager::self()->createTransport();
    transport->setName(d->ui.name->text().trimmed());
    const QString identifier = d->selectedType();
    transport->setIdentifier(identifier);
    transport->forceUniqueName();
    TransportManager::self()->initializeTransport(identifier, transport);
    if (TransportManager::self()->configureTransport(identifier, transport, this)) {
        // The user clicked OK and the transport settings were saved.
        TransportManager::self()->addTransport(transport);
        if (d->ui.setDefault->isChecked()) {
            TransportManager::self()->setDefaultTransport(transport->id());
        }
        QDialog::accept();
    }
}

#include "moc_addtransportdialogng.cpp"
07070100000057000081A4000000000000000000000001610B8324000003E3000000000000000000000000000000000000006400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/addtransportdialogng.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "kmailtransport_private_export.h"
#include <QDialog>

namespace MailTransport
{
/**
  @internal

A dialog for creating a new transport.  It asks the user for the transport
  type and name, and then proceeds to configure the new transport.

To create a new transport from applications, use
  TransportManager::showNewTransportDialog().

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class KMAILTRANSPORT_TESTS_EXPORT AddTransportDialogNG : public QDialog
{
    Q_OBJECT

public:
    /**
      Creates a new AddTransportDialogNG.
    */
    explicit AddTransportDialogNG(QWidget *parent = nullptr);

/**
      Destroys the AddTransportDialogNG.
    */
    ~AddTransportDialogNG() override;

/* reimpl */
    void accept() override;

private:
    class Private;
    Private *const d;
};
} // namespace MailTransport

07070100000058000081A4000000000000000000000001610B832400000873000000000000000000000000000000000000006300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportcombobox.cpp/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportcombobox.h"
#include "transport.h"
#include "transportmanager.h"

using namespace MailTransport;

/**
 * Private class that helps to provide binary compatibility between releases.
 * @internal
 */
class TransportComboBoxPrivate
{
public:
    QVector<int> transports;
};

TransportComboBox::TransportComboBox(QWidget *parent)
    : QComboBox(parent)
    , d(new TransportComboBoxPrivate)
{
    updateComboboxList();
    connect(TransportManager::self(), &TransportManager::transportsChanged, this, &TransportComboBox::updateComboboxList);
    connect(TransportManager::self(), &TransportManager::transportRemoved, this, &TransportComboBox::transportRemoved);
}

TransportComboBox::~TransportComboBox()
{
    delete d;
}

int TransportComboBox::currentTransportId() const
{
    if (currentIndex() >= 0 && currentIndex() < d->transports.count()) {
        return d->transports.at(currentIndex());
    }
    return -1;
}

bool TransportComboBox::setCurrentTransport(int transportId)
{
    const int i = d->transports.indexOf(transportId);
    if (i >= 0 && i < count()) {
        setCurrentIndex(i);
        return true;
    }
    return false;
}

QString TransportComboBox::transportType() const
{
    return TransportManager::self()->transportById(currentTransportId())->identifier();
}

void TransportComboBox::updateComboboxList()
{
    const int oldTransport = currentTransportId();
    clear();

int defaultId = 0;
    if (!TransportManager::self()->isEmpty()) {
        const QStringList listNames = TransportManager::self()->transportNames();
        const QVector<int> listIds = TransportManager::self()->transportIds();
        addItems(listNames);
        setTransportList(listIds);
        defaultId = TransportManager::self()->defaultTransportId();
    }

if (oldTransport != -1) {
        setCurrentTransport(oldTransport);
    } else {
        setCurrentTransport(defaultId);
    }
}

void TransportComboBox::setTransportList(const QVector<int> &transportList)
{
    d->transports = transportList;
}
07070100000059000081A4000000000000000000000001610B8324000005C0000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportcombobox.h/*
  SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>
#include <transportbase.h>

#include <QComboBox>

class TransportComboBoxPrivate;

namespace MailTransport
{
/**
  A combo-box for selecting a mail transport.
  It is updated automatically when transports are added, changed, or removed.
*/
class MAILTRANSPORT_EXPORT TransportComboBox : public QComboBox
{
    Q_OBJECT
public:
    /**
      Creates a new mail transport selection combo box.
      @param parent The paren widget.
    */
    explicit TransportComboBox(QWidget *parent = nullptr);

~TransportComboBox() override;

/**
      Returns identifier of the currently selected mail transport.
    */
    Q_REQUIRED_RESULT int currentTransportId() const;

/**
      Selects the given transport.
      @param transportId The transport identifier.
      @return return true if we success to find transportId
    */
    bool setCurrentTransport(int transportId);

/**
      Returns the type of the selected transport.
    */
    Q_REQUIRED_RESULT QString transportType() const;

Q_SIGNALS:
    void transportRemoved(int id, const QString &name);

protected:
    void setTransportList(const QVector<int> &transportList);

public Q_SLOTS:
    /**
     * @since 4.11
     */
    void updateComboboxList();

private:
    TransportComboBoxPrivate *const d;
};
} // namespace MailTransport

0707010000005A000081A4000000000000000000000001610B8324000006A5000000000000000000000000000000000000006700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportconfigwidget.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

Based on MailTransport code by:
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>
    SPDX-FileCopyrightText: 2007 KovoKs <kovoks@kovoks.nl>

Based on KMail code by:
    SPDX-FileCopyrightText: 2001-2002 Michael Haeckel <haeckel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportconfigwidget.h"
#include "transport.h"
#include "transportconfigwidget_p.h"
#include "transportmanager.h"

#include "mailtransport_debug.h"
#include <KConfigDialogManager>

using namespace MailTransport;

TransportConfigWidget::TransportConfigWidget(Transport *transport, QWidget *parent)
    : QWidget(parent)
    , d_ptr(new TransportConfigWidgetPrivate)
{
    init(transport);
}

TransportConfigWidget::TransportConfigWidget(TransportConfigWidgetPrivate &dd, Transport *transport, QWidget *parent)
    : QWidget(parent)
    , d_ptr(&dd)
{
    init(transport);
}

TransportConfigWidget::~TransportConfigWidget()
{
    delete d_ptr;
}

void TransportConfigWidget::init(Transport *transport)
{
    Q_D(TransportConfigWidget);
    qCDebug(MAILTRANSPORT_LOG) << "this" << this << "d" << d;
    Q_ASSERT(transport);
    d->transport = transport;

d->manager = new KConfigDialogManager(this, transport);
}

KConfigDialogManager *TransportConfigWidget::configManager() const
{
    Q_D(const TransportConfigWidget);
    Q_ASSERT(d->manager);
    return d->manager;
}

void TransportConfigWidget::apply()
{
    Q_D(TransportConfigWidget);
    d->manager->updateSettings();
    d->transport->forceUniqueName();
    d->transport->save();
    qCDebug(MAILTRANSPORT_LOG) << "Config written.";
}
0707010000005B000081A4000000000000000000000001610B832400000989000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportconfigwidget.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

Based on MailTransport code by:
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
    SPDX-FileCopyrightText: 2001-2002 Michael Haeckel <haeckel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QWidget>
#include <mailtransport_export.h>

class KConfigDialogManager;

namespace MailTransport
{
class Transport;
class TransportConfigWidgetPrivate;

/**
  @internal

Abstract configuration widget for a mail transport.  It makes sure that
  the configured transport has a unique name, and takes care of writing its
  settings to the config file.  If it is a new transport, the caller must
  still call TransportManager::addTransport() to register the transport.

Concrete configuration is done in subclasses SMTPConfigWidget.

To configure a transport from applications, use
  TransportManager::configureTransport().  You still need to call
  TransportManager::addTransport() if this is a new transport, not registered
  with TransportManager.

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORT_EXPORT TransportConfigWidget : public QWidget
{
    Q_OBJECT

public:
    /**
      Creates a new mail transport configuration widget for the given
      Transport object.
      @param transport The Transport object to configure.
      @param parent The parent widget.
    */
    explicit TransportConfigWidget(Transport *transport, QWidget *parent = nullptr);

/**
      Destroys the widget.
    */
    ~TransportConfigWidget() override;

/**
      @internal
      Get the KConfigDialogManager for this widget.
    */
    KConfigDialogManager *configManager() const;

public Q_SLOTS:
    /**
      Saves the transport's settings.

The base implementation writes the settings to the config file and makes
      sure the transport has a unique name.  Reimplement in derived classes to
      save your custom settings, and call the base implementation.
    */
    // TODO: do we also want to check for invalid settings?
    virtual void apply();

protected:
    TransportConfigWidgetPrivate *const d_ptr;
    TransportConfigWidget(TransportConfigWidgetPrivate &dd, Transport *transport, QWidget *parent);

private:
    Q_DECLARE_PRIVATE(TransportConfigWidget)

void init(Transport *transport);
};
} // namespace MailTransport

0707010000005C000081A4000000000000000000000001610B8324000001CB000000000000000000000000000000000000006700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportconfigwidget_p.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "transport.h"

#include <KConfigDialogManager>

namespace MailTransport
{
/**
  @internal
*/
class TransportConfigWidgetPrivate
{
public:
    Transport *transport = nullptr;
    KConfigDialogManager *manager = nullptr;

virtual ~TransportConfigWidgetPrivate()
    {
    }
};
} // namespace MailTransport

0707010000005D000081A4000000000000000000000001610B832400000E53000000000000000000000000000000000000006300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportlistview.cpp/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

Based on KMail code by:
  SPDX-FileCopyrightText: 2002 Marc Mutz <mutz@kde.org>
  SPDX-FileCopyrightText: 2007 Mathias Soeken <msoeken@tzi.de>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportlistview.h"
#include "transport.h"
#include "transportmanager.h"
#include "transporttype.h"

#include <QHeaderView>
#include <QLineEdit>

#include "mailtransport_debug.h"
#include <KLocalizedString>

using namespace MailTransport;

TransportListView::TransportListView(QWidget *parent)
    : QTreeWidget(parent)
{
    setHeaderLabels(QStringList() << i18nc("@title:column email transport name", "Name") << i18nc("@title:column email transport type", "Type"));
    setRootIsDecorated(false);
    header()->setSectionsMovable(false);
    header()->setSectionResizeMode(QHeaderView::ResizeToContents);
    setAllColumnsShowFocus(true);
    setAlternatingRowColors(true);
    setSortingEnabled(true);
    sortByColumn(0, Qt::AscendingOrder);
    setSelectionMode(SingleSelection);

fillTransportList();
    connect(TransportManager::self(), &TransportManager::transportsChanged, this, &TransportListView::fillTransportList);
}

void TransportListView::editItem(QTreeWidgetItem *item, int column)
{
    // TODO: is there a nicer way to make only the 'name' column editable?
    if (column == 0 && item) {
        Qt::ItemFlags oldFlags = item->flags();
        item->setFlags(oldFlags | Qt::ItemIsEditable);
        QTreeWidget::editItem(item, 0);
        item->setFlags(oldFlags);
        const int id = item->data(0, Qt::UserRole).toInt();
        Transport *t = TransportManager::self()->transportById(id);
        if (!t) {
            qCWarning(MAILTRANSPORT_LOG) << "Transport" << id << "not known by manager.";
            return;
        }
        if (TransportManager::self()->defaultTransportId() == t->id()) {
            item->setText(0, t->name());
        }
    }
}

void TransportListView::commitData(QWidget *editor)
{
    if (selectedItems().isEmpty()) {
        // transport was deleted by someone else???
        qCDebug(MAILTRANSPORT_LOG) << "No selected item.";
        return;
    }
    QTreeWidgetItem *item = selectedItems().first();
    auto edit = dynamic_cast<QLineEdit *>(editor); // krazy:exclude=qclasses
    Q_ASSERT(edit); // original code had if

const int id = item->data(0, Qt::UserRole).toInt();
    Transport *t = TransportManager::self()->transportById(id);
    if (!t) {
        qCWarning(MAILTRANSPORT_LOG) << "Transport" << id << "not known by manager.";
        return;
    }
    qCDebug(MAILTRANSPORT_LOG) << "Renaming transport" << id << "to" << edit->text();
    t->setName(edit->text());
    t->forceUniqueName();
    t->save();
}

void TransportListView::fillTransportList()
{
    // try to preserve the selection
    int selected = -1;
    if (currentItem()) {
        selected = currentItem()->data(0, Qt::UserRole).toInt();
    }

clear();
    const auto lstTransports = TransportManager::self()->transports();
    for (Transport *t : lstTransports) {
        auto item = new QTreeWidgetItem(this);
        item->setData(0, Qt::UserRole, t->id());
        QString name = t->name();
        if (TransportManager::self()->defaultTransportId() == t->id()) {
            name += i18nc("@label the default mail transport", " (Default)");
            QFont font(item->font(0));
            font.setBold(true);
            item->setFont(0, font);
        }
        item->setText(0, name);
        item->setText(1, t->transportType().name());
        if (t->id() == selected) {
            setCurrentItem(item);
        }
    }
}
0707010000005E000081A4000000000000000000000001610B832400000260000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportlistview.h/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QTreeWidget>

namespace MailTransport
{
/**
  @internal
  A QTreeWidget for transports.
*/
class TransportListView : public QTreeWidget
{
    Q_OBJECT

public:
    explicit TransportListView(QWidget *parent = nullptr);

// overloaded from QTreeWidget
    void editItem(QTreeWidgetItem *item, int column = 0);

protected Q_SLOTS:
    void commitData(QWidget *editor) override;

private Q_SLOTS:
    void fillTransportList();
};
} // namespace MailTransport

0707010000005F000081A4000000000000000000000001610B8324000015C5000000000000000000000000000000000000006B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportmanagementwidget.cpp/*
  SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
  SPDX-FileCopyrightText: 2001-2003 Marc Mutz <mutz@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportmanagementwidget.h"
#include "transport.h"
#include "transportmanager.h"
#include "ui_transportmanagementwidget.h"

#include <KMessageBox>
#include <QMenu>

using namespace MailTransport;

class Q_DECL_HIDDEN TransportManagementWidget::Private
{
public:
    Private(TransportManagementWidget *parent);

Ui::TransportManagementWidget ui;
    TransportManagementWidget *const q;

// Slots
    void defaultClicked();
    void removeClicked();
    void renameClicked();
    void editClicked();
    void addClicked();
    void updateButtonState();
    void slotCustomContextMenuRequested(const QPoint &);
};

TransportManagementWidget::Private::Private(TransportManagementWidget *parent)
    : q(parent)
{
}

TransportManagementWidget::TransportManagementWidget(QWidget *parent)
    : QWidget(parent)
    , d(new Private(this))
{
    d->ui.setupUi(this);
    d->updateButtonState();

d->ui.transportList->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(d->ui.transportList, &QTreeWidget::currentItemChanged, this, [this]() {
        d->updateButtonState();
    });
    connect(d->ui.transportList, &QTreeWidget::itemDoubleClicked, this, [this]() {
        d->editClicked();
    });
    connect(d->ui.addButton, &QPushButton::clicked, this, [this]() {
        d->addClicked();
    });
    connect(d->ui.editButton, &QPushButton::clicked, this, [this]() {
        d->editClicked();
    });
    connect(d->ui.renameButton, &QPushButton::clicked, this, [this]() {
        d->renameClicked();
    });
    connect(d->ui.removeButton, &QPushButton::clicked, this, [this]() {
        d->removeClicked();
    });
    connect(d->ui.defaultButton, &QPushButton::clicked, this, [this]() {
        d->defaultClicked();
    });
    connect(d->ui.transportList, &QTreeWidget::customContextMenuRequested, this, [this](QPoint p) {
        d->slotCustomContextMenuRequested(p);
    });
}

TransportManagementWidget::~TransportManagementWidget()
{
    delete d;
}

void TransportManagementWidget::Private::updateButtonState()
{
    // TODO figure out current item vs. selected item (in almost every function)
    if (!ui.transportList->currentItem()) {
        ui.editButton->setEnabled(false);
        ui.renameButton->setEnabled(false);
        ui.removeButton->setEnabled(false);
        ui.defaultButton->setEnabled(false);
    } else {
        ui.editButton->setEnabled(true);
        ui.renameButton->setEnabled(true);
        ui.removeButton->setEnabled(true);
        if (ui.transportList->currentItem()->data(0, Qt::UserRole) == TransportManager::self()->defaultTransportId()) {
            ui.defaultButton->setEnabled(false);
        } else {
            ui.defaultButton->setEnabled(true);
        }
    }
}

void TransportManagementWidget::Private::addClicked()
{
    TransportManager::self()->showTransportCreationDialog(q);
}

void TransportManagementWidget::Private::editClicked()
{
    if (!ui.transportList->currentItem()) {
        return;
    }

const int currentId = ui.transportList->currentItem()->data(0, Qt::UserRole).toInt();
    Transport *transport = TransportManager::self()->transportById(currentId);
    TransportManager::self()->configureTransport(transport->identifier(), transport, q);
}

void TransportManagementWidget::Private::renameClicked()
{
    if (!ui.transportList->currentItem()) {
        return;
    }

ui.transportList->editItem(ui.transportList->currentItem(), 0);
}

void TransportManagementWidget::Private::removeClicked()
{
    if (!ui.transportList->currentItem()) {
        return;
    }
    const int rc = KMessageBox::questionYesNo(q,
                                              i18n("Do you want to remove outgoing account '%1'?", ui.transportList->currentItem()->text(0)),
                                              i18n("Remove outgoing account?"));
    if (rc == KMessageBox::No) {
        return;
    }

TransportManager::self()->removeTransport(ui.transportList->currentItem()->data(0, Qt::UserRole).toInt());
}

void TransportManagementWidget::Private::defaultClicked()
{
    if (!ui.transportList->currentItem()) {
        return;
    }

TransportManager::self()->setDefaultTransport(ui.transportList->currentItem()->data(0, Qt::UserRole).toInt());
}

void TransportManagementWidget::Private::slotCustomContextMenuRequested(const QPoint &pos)
{
    QMenu menu(q);
    menu.addAction(QIcon::fromTheme(QStringLiteral("list-add")), i18n("Add..."), q, [this]() {
        addClicked();
    });
    QTreeWidgetItem *item = ui.transportList->itemAt(pos);
    if (item) {
        menu.addAction(QIcon::fromTheme(QStringLiteral("document-edit")), i18n("Modify..."), q, [this]() {
            editClicked();
        });
        menu.addAction(QIcon::fromTheme(QStringLiteral("edit-rename")), i18n("Rename"), q, [this]() {
            renameClicked();
        });
        menu.addAction(QIcon::fromTheme(QStringLiteral("list-remove")), i18n("Remove"), q, [this]() {
            removeClicked();
        });
        if (item->data(0, Qt::UserRole) != TransportManager::self()->defaultTransportId()) {
            menu.addSeparator();
            menu.addAction(i18n("Set as Default"), q, [this]() {
                defaultClicked();
            });
        }
    }
    menu.exec(ui.transportList->viewport()->mapToGlobal(pos));
}

#include "moc_transportmanagementwidget.cpp"
07070100000060000081A4000000000000000000000001610B83240000030D000000000000000000000000000000000000006900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransport/widgets/transportmanagementwidget.h/*
  SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>

Based on KMail code by:
  SPDX-FileCopyrightText: 2001-2003 Marc Mutz <mutz@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransport_export.h>

#include <QWidget>

namespace MailTransport
{
/**
  A widget to manage mail transports.
*/
class MAILTRANSPORT_EXPORT TransportManagementWidget : public QWidget
{
    Q_OBJECT

public:
    /**
      Creates a new TransportManagementWidget.
      @param parent The parent widget.
    */
    explicit TransportManagementWidget(QWidget *parent = nullptr);

/**
      Destroys the widget.
    */
    ~TransportManagementWidget() override;

private:
    class Private;
    Private *const d;
};
} // namespace MailTransport

07070100000061000041ED000000000000000000000005610B832400000000000000000000000000000000000000000000004C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi07070100000062000081A4000000000000000000000001610B832400000FDB000000000000000000000000000000000000005B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/CMakeLists.txtadd_library(KF5MailTransportAkonadi)
add_library(KF5::MailTransportAkonadi ALIAS KF5MailTransportAkonadi)

ecm_setup_version(PROJECT VARIABLE_PREFIX MAILTRANSPORT
    VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/mailtransportakonadi_version.h"
    PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportAkonadiConfigVersion.cmake"
    SOVERSION 5
    )

target_sources(KF5MailTransportAkonadi PRIVATE
    dispatcherinterface.cpp
    attributeregistrar.cpp
    dispatchmodeattribute.cpp
    errorattribute.cpp
    transportattribute.cpp
    sentactionattribute.cpp
    sentbehaviourattribute.cpp
    messagequeuejob.cpp
    outboxactions.cpp
    filteractionjob.cpp
    )

ecm_qt_declare_logging_category(KF5MailTransportAkonadi HEADER mailtransportakonadi_debug.h IDENTIFIER MAILTRANSPORTAKONADI_LOG CATEGORY_NAME org.kde.pim.mailtransportakonadi
        DESCRIPTION "kmailtransportakonadi (kmailtransportakonadi)"
        EXPORT MAILTRANSPORT
    )

if (COMPILE_WITH_UNITY_CMAKE_SUPPORT)
    set_target_properties(KF5MailTransportAkonadi PROPERTIES UNITY_BUILD ON)
endif()
generate_export_header(KF5MailTransportAkonadi BASE_NAME mailtransportakonadi)

target_include_directories(KF5MailTransportAkonadi INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/MailTransportAkonadi;${KDE_INSTALL_INCLUDEDIR_KF5}/mailtransportakonadi>")
target_include_directories(KF5MailTransportAkonadi PUBLIC "$<BUILD_INTERFACE:${MailTransport_SOURCE_DIR}/src;${MailTransport_BINARY_DIR}/src>")

target_link_libraries(KF5MailTransportAkonadi
    PUBLIC
    KF5::AkonadiCore
    KF5::Mime
    KF5::AkonadiMime
    KF5::MailTransport
    PRIVATE
    KF5::I18n
    KF5::CoreAddons
    KF5::ConfigGui
    )

set_target_properties(KF5MailTransportAkonadi PROPERTIES
    VERSION ${MAILTRANSPORT_VERSION}
    SOVERSION ${MAILTRANSPORT_SOVERSION}
    EXPORT_NAME MailTransportAkonadi
    )

install(TARGETS KF5MailTransportAkonadi EXPORT KF5MailTransportAkonadiTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})

ecm_generate_headers(MailTransport_kmailtransportakonadi_CamelCase_HEADERS
    HEADER_NAMES
    DispatcherInterface
    MessageQueueJob
    TransportAttribute
    SentBehaviourAttribute
    DispatchModeAttribute
    ErrorAttribute
    SentActionAttribute
    PREFIX MailTransportAkonadi
    REQUIRED_HEADERS MailTransport_kmailtransportakonadi_HEADERS
    )

install(FILES
    ${MailTransport_kmailtransportakonadi_CamelCase_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/MailTransportAkonadi COMPONENT Devel )

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/mailtransportakonadi_export.h
    ${MailTransport_kmailtransportakonadi_HEADERS}

DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/mailtransportakonadi COMPONENT Devel
    )

ecm_generate_pri_file(BASE_NAME KMailTransportAkonadi LIB_NAME KF5MailTransportAkonadi DEPS "KMailTransport AkonadiCore KMime AkonadiMime" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/MailTransportAkonadi/)
install(FILES ${PRI_FILENAME} DESTINATION ${ECM_MKSPECS_INSTALL_DIR})

set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5MailTransportAkonadi")

install(EXPORT KF5MailTransportAkonadiTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KF5MailTransportAkonadiTargets.cmake NAMESPACE KF5::)

configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/KF5MailTransportAkonadiConfig.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportAkonadiConfig.cmake"
    INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
    )

install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportAkonadiConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/KF5MailTransportAkonadiConfigVersion.cmake"
    DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
    COMPONENT Devel
    )

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/mailtransportakonadi_version.h
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel
    )

if(BUILD_TESTING)
    add_subdirectory(tests)
    if (KDEPIM_RUN_AKONADI_TEST)
	    add_subdirectory(autotests)
    endif()
endif()

add_subdirectory(plugins)
07070100000063000081A4000000000000000000000001610B83240000011B000000000000000000000000000000000000007300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/KF5MailTransportAkonadiConfig.cmake.in@PACKAGE_INIT@

include(CMakeFindDependencyMacro)
find_dependency(KF5AkonadiMime "@AKONADIMIME_LIB_VERSION@")
find_dependency(KF5Mime "@KMIME_LIB_VERSION@")
find_dependency(KF5MailTransport "@PIM_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KF5MailTransportAkonadiTargets.cmake")
07070100000064000081A4000000000000000000000001610B832400000385000000000000000000000000000000000000006300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/attributeregistrar.cpp/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "dispatchmodeattribute.h"
#include "errorattribute.h"
#include "sentactionattribute.h"
#include "sentbehaviourattribute.h"
#include "transportattribute.h"

#include <attributefactory.h>

namespace
{
// Anonymous namespace; function is invisible outside this file.
bool dummy()
{
    using namespace Akonadi;
    using namespace MailTransport;
    AttributeFactory::registerAttribute<DispatchModeAttribute>();
    AttributeFactory::registerAttribute<ErrorAttribute>();
    AttributeFactory::registerAttribute<SentActionAttribute>();
    AttributeFactory::registerAttribute<SentBehaviourAttribute>();
    AttributeFactory::registerAttribute<TransportAttribute>();
    return true;
}

// Called when this library is loaded.
const bool registered = dummy();
} // namespace
07070100000065000041ED000000000000000000000004610B832400000000000000000000000000000000000000000000005600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests07070100000066000081A4000000000000000000000001610B8324000001D5000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/CMakeLists.txtfind_package(KF5DBusAddons CONFIG REQUIRED)

# Akonadi testrunner-based tests:
add_akonadi_isolated_test(
    SOURCE attributetest.cpp
    LINK_LIBRARIES KF5::MailTransportAkonadi
)
add_akonadi_isolated_test(
    SOURCE messagequeuejobtest.cpp
    LINK_LIBRARIES KF5::MailTransportAkonadi KF5::I18n KF5::ConfigGui
)
# TODO: port & re-enable
#add_akonadi_isolated_test(
#    SOURCE filteractiontest.cpp
#    LINK_LIBRARIES KF5::AkonadiCore KF5::MailTransportAkonadi
#)

07070100000067000081A4000000000000000000000001610B83240000006C000000000000000000000000000000000000005B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/TODOMessageQueueJob:
- see source

Attributes:
- add test for common mistakes such as forgetting to setDueDate

07070100000068000081A4000000000000000000000001610B832400001EEA000000000000000000000000000000000000006800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/attributetest.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "attributetest.h"

#include <addressattribute.h>
#include <attributefactory.h>
#include <qtest_akonadi.h>

#include <kmailtransportakonadi/dispatchmodeattribute.h>
#include <kmailtransportakonadi/errorattribute.h>
#include <kmailtransportakonadi/sentactionattribute.h>
#include <kmailtransportakonadi/sentbehaviourattribute.h>
#include <kmailtransportakonadi/transportattribute.h>

using namespace Akonadi;
using namespace MailTransport;

void AttributeTest::initTestCase()
{
}

void AttributeTest::testRegistrar()
{
    // The attributes should have been registered without any effort on our part.
    {
        Attribute *a = AttributeFactory::createAttribute("AddressAttribute");
        QVERIFY(dynamic_cast<AddressAttribute *>(a));
        delete a;
    }

{
        Attribute *a = AttributeFactory::createAttribute("DispatchModeAttribute");
        QVERIFY(dynamic_cast<DispatchModeAttribute *>(a));
        delete a;
    }

{
        Attribute *a = AttributeFactory::createAttribute("ErrorAttribute");
        QVERIFY(dynamic_cast<ErrorAttribute *>(a));
        delete a;
    }

{
        Attribute *a = AttributeFactory::createAttribute("SentActionAttribute");
        QVERIFY(dynamic_cast<SentActionAttribute *>(a));
        delete a;
    }

{
        Attribute *a = AttributeFactory::createAttribute("SentBehaviourAttribute");
        QVERIFY(dynamic_cast<SentBehaviourAttribute *>(a));
        delete a;
    }

{
        Attribute *a = AttributeFactory::createAttribute("TransportAttribute");
        QVERIFY(dynamic_cast<TransportAttribute *>(a));
        delete a;
    }
}

void AttributeTest::testSerialization()
{
    {
        QString from(QStringLiteral("from@me.org"));
        QStringList to(QStringLiteral("to1@me.org"));
        to << QStringLiteral("to2@me.org");
        QStringList cc(QStringLiteral("cc1@me.org"));
        cc << QStringLiteral("cc2@me.org");
        QStringList bcc(QStringLiteral("bcc1@me.org"));
        bcc << QStringLiteral("bcc2@me.org");
        auto a = new AddressAttribute(from, to, cc, bcc);
        QByteArray data = a->serialized();
        delete a;
        a = new AddressAttribute;
        a->deserialize(data);
        QCOMPARE(from, a->from());
        QCOMPARE(to, a->to());
        QCOMPARE(cc, a->cc());
        QCOMPARE(bcc, a->bcc());
        delete a;
    }

{
        DispatchModeAttribute::DispatchMode mode = DispatchModeAttribute::Automatic;
        QDateTime date = QDateTime::currentDateTime();
        // The serializer does not keep track of milliseconds, so forget them.
        qDebug() << "ms" << date.toString(QStringLiteral("z"));
        int ms = date.toString(QStringLiteral("z")).toInt();
        date = date.addMSecs(-ms);
        auto a = new DispatchModeAttribute(mode);
        a->setSendAfter(date);
        QByteArray data = a->serialized();
        delete a;
        a = new DispatchModeAttribute;
        a->deserialize(data);
        QCOMPARE(mode, a->dispatchMode());
        QCOMPARE(date, a->sendAfter());
        delete a;
    }

{
        QString msg(QStringLiteral("The #!@$ing thing failed!"));
        auto a = new ErrorAttribute(msg);
        QByteArray data = a->serialized();
        delete a;
        a = new ErrorAttribute;
        a->deserialize(data);
        QCOMPARE(msg, a->message());
        delete a;
    }

{
        auto a = new SentActionAttribute();
        const qlonglong id = 123456789012345ll;

a->addAction(SentActionAttribute::Action::MarkAsReplied, QVariant(id));
        a->addAction(SentActionAttribute::Action::MarkAsForwarded, QVariant(id));

QByteArray data = a->serialized();
        delete a;
        a = new SentActionAttribute;
        a->deserialize(data);

const SentActionAttribute::Action::List actions = a->actions();
        QCOMPARE(actions.count(), 2);

QCOMPARE(SentActionAttribute::Action::MarkAsReplied, actions[0].type());
        QCOMPARE(id, actions[0].value().toLongLong());

QCOMPARE(SentActionAttribute::Action::MarkAsForwarded, actions[1].type());
        QCOMPARE(id, actions[1].value().toLongLong());
        delete a;
    }

{
        SentBehaviourAttribute::SentBehaviour beh = SentBehaviourAttribute::MoveToCollection;
        Collection::Id id = 123456789012345ll;
        auto a = new SentBehaviourAttribute(beh, Collection(id));
        bool sendSilently = true;
        a->setSendSilently(sendSilently);
        QByteArray data = a->serialized();
        delete a;
        a = new SentBehaviourAttribute;
        a->deserialize(data);
        QCOMPARE(beh, a->sentBehaviour());
        QCOMPARE(id, a->moveToCollection().id());
        QCOMPARE(sendSilently, a->sendSilently());
        delete a;
    }

// MoveToCollection + silently
    {
        SentBehaviourAttribute::SentBehaviour beh = SentBehaviourAttribute::MoveToCollection;
        Collection::Id id = 123456789012345ll;
        auto a = new SentBehaviourAttribute(beh, Collection(id));
        bool sendSilently = true;
        a->setSendSilently(sendSilently);
        QByteArray data = a->serialized();
        delete a;
        a = new SentBehaviourAttribute;
        a->deserialize(data);
        QCOMPARE(beh, a->sentBehaviour());
        QCOMPARE(id, a->moveToCollection().id());
        QCOMPARE(sendSilently, a->sendSilently());
        SentBehaviourAttribute *copy = a->clone();
        QCOMPARE(copy->sentBehaviour(), beh);
        QCOMPARE(copy->moveToCollection().id(), id);
        QCOMPARE(copy->sendSilently(), sendSilently);
        delete a;
        delete copy;
    }

// Delete + silently
    {
        SentBehaviourAttribute::SentBehaviour beh = SentBehaviourAttribute::Delete;
        Collection::Id id = 123456789012345ll;
        auto a = new SentBehaviourAttribute(beh, Collection(id));
        bool sendSilently = true;
        a->setSendSilently(sendSilently);
        QByteArray data = a->serialized();
        delete a;
        a = new SentBehaviourAttribute;
        a->deserialize(data);
        QCOMPARE(beh, a->sentBehaviour());
        // When delete we move to -1
        QCOMPARE(a->moveToCollection().id(), -1);
        QCOMPARE(sendSilently, a->sendSilently());
        SentBehaviourAttribute *copy = a->clone();
        QCOMPARE(copy->sentBehaviour(), beh);
        // When delete we move to -1
        QCOMPARE(copy->moveToCollection().id(), -1);
        QCOMPARE(copy->sendSilently(), sendSilently);
        delete a;
        delete copy;
    }

// MoveToDefaultSentCollection + silently
    {
        SentBehaviourAttribute::SentBehaviour beh = SentBehaviourAttribute::MoveToDefaultSentCollection;
        Collection::Id id = 123456789012345ll;
        auto a = new SentBehaviourAttribute(beh, Collection(id));
        bool sendSilently = true;
        a->setSendSilently(sendSilently);
        QByteArray data = a->serialized();
        delete a;
        a = new SentBehaviourAttribute;
        a->deserialize(data);
        QCOMPARE(beh, a->sentBehaviour());
        // When movetodefaultsendCollection we move to -1
        QCOMPARE(a->moveToCollection().id(), -1);
        QCOMPARE(sendSilently, a->sendSilently());
        SentBehaviourAttribute *copy = a->clone();
        QCOMPARE(copy->sentBehaviour(), beh);
        // When movetodefaultsendCollection we move to -1
        QCOMPARE(copy->moveToCollection().id(), -1);
        QCOMPARE(copy->sendSilently(), sendSilently);
        delete a;
        delete copy;
    }

{
        int id = 3219;
        auto a = new TransportAttribute(id);
        QByteArray data = a->serialized();
        delete a;
        a = new TransportAttribute;
        a->deserialize(data);
        QCOMPARE(id, a->transportId());
        delete a;
    }
}

QTEST_AKONADIMAIN(AttributeTest)
07070100000069000081A4000000000000000000000001610B83240000016F000000000000000000000000000000000000006600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/attributetest.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>

/**
  This is a test of the various attributes.
*/
class AttributeTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void initTestCase();
    void testRegistrar();
    void testSerialization();
};

0707010000006A000081A4000000000000000000000001610B83240000176D000000000000000000000000000000000000006B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/filteractiontest.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "filteractiontest.h"
#include <collectionpathresolver_p.h>
#include <testattribute.h>

#include <attributefactory.h>
#include <collectioncreatejob.h>
#include <filteractionjob_p.h>
#include <itemcreatejob.h>
#include <itemfetchjob.h>
#include <itemfetchscope.h>
#include <itemmodifyjob.h>
#include <qtest_akonadi.h>

using namespace Akonadi;

QTEST_AKONADIMAIN(FilterActionTest, NoGUI)

static const QByteArray acceptable = "acceptable";
static const QByteArray unacceptable = "unacceptable";
static const QByteArray modified = "modified";
static Collection res1;

class MyFunctor : public FilterAction
{
    virtual Akonadi::ItemFetchScope fetchScope() const
    {
        ItemFetchScope scope;
        scope.fetchAttribute<TestAttribute>();
        return scope;
    }

virtual bool itemAccepted(const Akonadi::Item &item) const
    {
        if (!item.hasAttribute<TestAttribute>()) {
            return false;
        }
        return item.attribute<TestAttribute>()->data == acceptable;
    }

virtual Akonadi::Job *itemAction(const Akonadi::Item &item, FilterActionJob *parent) const
    {
        Item cp(item);
        TestAttribute *newa = new TestAttribute;
        newa->data = modified;
        cp.addAttribute(newa);
        return new ItemModifyJob(cp, parent);
    }
};

void FilterActionTest::initTestCase()
{
    AttributeFactory::registerAttribute<TestAttribute>();

CollectionPathResolver *resolver = new CollectionPathResolver("res1", this);
    QVERIFY(resolver->exec());
    res1 = Collection(resolver->collection());
}

void FilterActionTest::testMassModifyItem()
{
    Collection col = createCollection("testMassModifyItem");

// Test acceptable item.
    Item item = createItem(col, true);
    FilterActionJob *mjob = new FilterActionJob(item, new MyFunctor, this);
    AKVERIFYEXEC(mjob);
    ItemFetchJob *fjob = new ItemFetchJob(item, this);
    fjob->fetchScope().fetchAllAttributes();
    AKVERIFYEXEC(fjob);
    QCOMPARE(fjob->items().count(), 1);
    item = fjob->items().first();
    QVERIFY(item.hasAttribute<TestAttribute>());
    TestAttribute *attr = item.attribute<TestAttribute>();
    QCOMPARE(attr->data, modified);

// Test unacceptable item.
    item = createItem(col, false);
    mjob = new FilterActionJob(item, new MyFunctor, this);
    AKVERIFYEXEC(mjob);
    fjob = new ItemFetchJob(item, this);
    fjob->fetchScope().fetchAllAttributes();
    AKVERIFYEXEC(fjob);
    QCOMPARE(fjob->items().count(), 1);
    item = fjob->items().first();
    QVERIFY(item.hasAttribute<TestAttribute>());
    attr = item.attribute<TestAttribute>();
    QCOMPARE(attr->data, unacceptable);
}

void FilterActionTest::testMassModifyItems()
{
    Collection col = createCollection("testMassModifyItems");

// Test a bunch of acceptable and unacceptable items.
    Item::List acc, unacc;
    for (int i = 0; i < 5; i++) {
        acc.append(createItem(col, true));
        unacc.append(createItem(col, false));
    }
    Item::List all = acc + unacc;
    QCOMPARE(all.count(), 10);
    FilterActionJob *mjob = new FilterActionJob(all, new MyFunctor, this);
    AKVERIFYEXEC(mjob);
    ItemFetchJob *fjob = new ItemFetchJob(col, this);
    fjob->fetchScope().fetchAllAttributes();
    AKVERIFYEXEC(fjob);
    QCOMPARE(fjob->items().count(), 10);
    foreach (const Item &item, fjob->items()) {
        QVERIFY(item.hasAttribute<TestAttribute>());
        const QByteArray data = item.attribute<TestAttribute>()->data;
        if (data == unacceptable) {
            QVERIFY(unacc.contains(item));
            unacc.removeAll(item);
        } else if (data == modified) {
            QVERIFY(acc.contains(item));
            acc.removeAll(item);
        } else {
            QVERIFY2(false, QByteArray(QByteArray("Got bad data \"") + data + QByteArray("\"")));
        }
    }
    QCOMPARE(acc.count(), 0);
    QCOMPARE(unacc.count(), 0);
}

void FilterActionTest::testMassModifyCollection()
{
    Collection col = createCollection("testMassModifyCollection");

// Test a bunch of acceptable and unacceptable items.
    Item::List acc, unacc;
    for (int i = 0; i < 5; i++) {
        acc.append(createItem(col, true));
        unacc.append(createItem(col, false));
    }
    FilterActionJob *mjob = new FilterActionJob(col, new MyFunctor, this);
    qDebug() << "Executing FilterActionJob.";
    AKVERIFYEXEC(mjob);
    ItemFetchJob *fjob = new ItemFetchJob(col, this);
    fjob->fetchScope().fetchAllAttributes();
    AKVERIFYEXEC(fjob);
    QCOMPARE(fjob->items().count(), 10);
    foreach (const Item &item, fjob->items()) {
        QVERIFY(item.hasAttribute<TestAttribute>());
        const QByteArray data = item.attribute<TestAttribute>()->data;
        if (data == unacceptable) {
            QVERIFY(unacc.contains(item));
            unacc.removeAll(item);
        } else if (data == modified) {
            QVERIFY(acc.contains(item));
            acc.removeAll(item);
        } else {
            QVERIFY2(false, QByteArray(QByteArray("Got bad data \"") + data + QByteArray("\"")));
        }
    }
    QCOMPARE(acc.count(), 0);
    QCOMPARE(unacc.count(), 0);
}

Collection FilterActionTest::createCollection(const QString &name)
{
    Collection col;
    col.setParentCollection(res1);
    col.setName(name);
    CollectionCreateJob *ccjob = new CollectionCreateJob(col, this);
    Q_ASSERT(ccjob->exec());
    return ccjob->collection();
}

Item FilterActionTest::createItem(const Collection &col, bool accept)
{
    Q_ASSERT(col.isValid());

Item item;
    item.setMimeType("text/directory");
    TestAttribute *attr = new TestAttribute;
    if (accept) {
        attr->data = acceptable;
    } else {
        attr->data = unacceptable;
    }
    item.addAttribute(attr);
    ItemCreateJob *cjob = new ItemCreateJob(item, col, this);
    Q_ASSERT(cjob->exec());
    return cjob->item();
}
0707010000006B000081A4000000000000000000000001610B83240000023D000000000000000000000000000000000000006900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/filteractiontest.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>
#include <QString>

#include <collection.h>
#include <item.h>

class FilterActionTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void initTestCase();
    void testMassModifyItem();
    void testMassModifyItems();
    void testMassModifyCollection();

private:
    Akonadi::Collection createCollection(const QString &name);
    Akonadi::Item createItem(const Akonadi::Collection &col, bool accept);
};

0707010000006C000081A4000000000000000000000001610B8324000017A3000000000000000000000000000000000000006E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/messagequeuejobtest.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "messagequeuejobtest.h"

#include <QStringList>

#include <addressattribute.h>
#include <agentinstance.h>
#include <agentmanager.h>
#include <collection.h>
#include <collectionstatistics.h>
#include <collectionstatisticsjob.h>
#include <control.h>
#include <itemdeletejob.h>
#include <itemfetchjob.h>
#include <itemfetchscope.h>
#include <messageflags.h>
#include <qtest_akonadi.h>
#include <specialmailcollections.h>
#include <specialmailcollectionsrequestjob.h>

#include <kmime/kmime_message.h>

#include <QSignalSpy>
#include <kmailtransportakonadi/dispatchmodeattribute.h>
#include <kmailtransportakonadi/errorattribute.h>
#include <kmailtransportakonadi/messagequeuejob.h>
#include <kmailtransportakonadi/sentbehaviourattribute.h>
#include <kmailtransportakonadi/transportattribute.h>
#include <transport.h>
#include <transportmanager.h>

#define SPAM_ADDRESS (QStringList() << QStringLiteral("idanoka@gmail.com"))

using namespace Akonadi;
using namespace KMime;
using namespace MailTransport;

void MessageQueueJobTest::initTestCase()
{
    Control::start();
    // HACK: Otherwise the MDA is not switched offline soon enough apparently...
    QTest::qWait(1000);

// Switch MDA offline to avoid spam.
    AgentInstance mda = AgentManager::self()->instance(QStringLiteral("akonadi_maildispatcher_agent"));
    QVERIFY(mda.isValid());
    mda.setIsOnline(false);

// check that outbox is empty
    auto rjob = new SpecialMailCollectionsRequestJob(this);
    rjob->requestDefaultCollection(SpecialMailCollections::Outbox);
    QSignalSpy spy(rjob, &KJob::result);
    QVERIFY(spy.wait(10000));
    verifyOutboxContents(0);
}

void MessageQueueJobTest::testValidMessages()
{
    // check transport
    int tid = TransportManager::self()->defaultTransportId();
    QVERIFY2(tid >= 0, "I need a default transport, but there is none.");

// send a valid message using the default transport
    auto qjob = new MessageQueueJob;
    qjob->transportAttribute().setTransportId(tid);
    Message::Ptr msg = Message::Ptr(new Message);
    msg->setContent("\nThis is message #1 from the MessageQueueJobTest unit test.\n");
    qjob->setMessage(msg);
    qjob->addressAttribute().setTo(SPAM_ADDRESS);
    verifyOutboxContents(0);
    AKVERIFYEXEC(qjob);

// fetch the message and verify it
    QTest::qWait(1000);
    verifyOutboxContents(1);
    auto fjob = new ItemFetchJob(SpecialMailCollections::self()->defaultCollection(SpecialMailCollections::Outbox));
    fjob->fetchScope().fetchFullPayload();
    fjob->fetchScope().fetchAllAttributes();
    AKVERIFYEXEC(fjob);
    QCOMPARE(fjob->items().count(), 1);
    Item item = fjob->items().constFirst();
    QVERIFY(!item.remoteId().isEmpty()); // stored by the resource
    QVERIFY(item.hasPayload<Message::Ptr>());
    auto addrA = item.attribute<AddressAttribute>();
    QVERIFY(addrA);
    QVERIFY(addrA->from().isEmpty());
    QCOMPARE(addrA->to().count(), 1);
    QCOMPARE(addrA->to(), SPAM_ADDRESS);
    QCOMPARE(addrA->cc().count(), 0);
    QCOMPARE(addrA->bcc().count(), 0);
    auto dA = item.attribute<DispatchModeAttribute>();
    QVERIFY(dA);
    QCOMPARE(dA->dispatchMode(), DispatchModeAttribute::Automatic); // default mode
    auto sA = item.attribute<SentBehaviourAttribute>();
    QVERIFY(sA);
    // default sent collection
    QCOMPARE(sA->sentBehaviour(), SentBehaviourAttribute::MoveToDefaultSentCollection);
    auto tA = item.attribute<TransportAttribute>();
    QVERIFY(tA);
    QCOMPARE(tA->transportId(), tid);
    auto eA = item.attribute<ErrorAttribute>();
    QVERIFY(!eA); // no error
    QCOMPARE(item.flags().count(), 1);
    QVERIFY(item.flags().contains(Akonadi::MessageFlags::Queued));

// delete message, for further tests
    auto djob = new ItemDeleteJob(item);
    AKVERIFYEXEC(djob);
    verifyOutboxContents(0);

// TODO test with no To: but only BCC:

// TODO test due-date sending

// TODO test sending with custom sent-mail collections
}

void MessageQueueJobTest::testInvalidMessages()
{
    Message::Ptr msg;

// without message
    auto job = new MessageQueueJob;
    job->transportAttribute().setTransportId(TransportManager::self()->defaultTransportId());
    job->addressAttribute().setTo(SPAM_ADDRESS);
    QVERIFY(!job->exec());

// without recipients
    job = new MessageQueueJob;
    msg = Message::Ptr(new Message);
    msg->setContent(
        "\nThis is a message sent from the MessageQueueJobTest unittest."
        " This shouldn't have been sent.\n");
    job->setMessage(msg);
    job->transportAttribute().setTransportId(TransportManager::self()->defaultTransportId());
    QVERIFY(!job->exec());

// without transport
    job = new MessageQueueJob;
    msg = Message::Ptr(new Message);
    msg->setContent(
        "\nThis is a message sent from the MessageQueueJobTest unittest."
        " This shouldn't have been sent.\n");
    job->setMessage(msg);
    job->addressAttribute().setTo(SPAM_ADDRESS);
    QVERIFY(!job->exec());

// with MoveToCollection and no sent-mail folder
    job = new MessageQueueJob;
    msg = Message::Ptr(new Message);
    msg->setContent(
        "\nThis is a message sent from the MessageQueueJobTest unittest."
        " This shouldn't have been sent.\n");
    job->setMessage(msg);
    job->addressAttribute().setTo(SPAM_ADDRESS);
    job->sentBehaviourAttribute().setSentBehaviour(SentBehaviourAttribute::MoveToCollection);
    QVERIFY(!job->exec());
}

void MessageQueueJobTest::verifyOutboxContents(qlonglong count)
{
    QVERIFY(SpecialMailCollections::self()->hasDefaultCollection(SpecialMailCollections::Outbox));
    Collection outbox = SpecialMailCollections::self()->defaultCollection(SpecialMailCollections::Outbox);
    QVERIFY(outbox.isValid());
    auto job = new CollectionStatisticsJob(outbox);
    AKVERIFYEXEC(job);
    QCOMPARE(job->statistics().count(), count);
}

QTEST_AKONADIMAIN(MessageQueueJobTest)
0707010000006D000081A4000000000000000000000001610B832400000225000000000000000000000000000000000000006C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/messagequeuejobtest.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>

/**
  This tests the ability to queue messages (MessageQueueJob class).
  Note that the actual sending of messages is the MDA's job, and is not tested
  here.
 */
class MessageQueueJobTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void initTestCase();
    void testValidMessages();
    void testInvalidMessages();

private:
    void verifyOutboxContents(qlonglong count);
};

0707010000006E000081A4000000000000000000000001610B8324000002A0000000000000000000000000000000000000006600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/testattribute.h/*
    SPDX-FileCopyrightText: 2008 Volker Krause <vkrause@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <attribute.h>

/* Attribute used for testing by various unit tests. */
class TestAttribute : public Akonadi::Attribute
{
public:
    TestAttribute()
    {
    }

QByteArray type() const
    {
        return "EXTRA";
    }

QByteArray serialized() const
    {
        return data;
    }

void deserialize(const QByteArray &ba)
    {
        data = ba;
    }

TestAttribute *clone() const
    {
        TestAttribute *a = new TestAttribute;
        a->data = data;
        return a;
    }

QByteArray data;
};

0707010000006F000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000006200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv07070100000070000081A4000000000000000000000001610B832400000013000000000000000000000000000000000000006D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv/config.xml<config>
</config>
07070100000071000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000006C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv/xdgconfig07070100000072000081A4000000000000000000000001610B832400000041000000000000000000000000000000000000007F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv/xdgconfig/akonadi-firstrunrc[ProcessedDefaults]
defaultaddressbook=done
defaultcalendar=done
07070100000073000081A4000000000000000000000001610B832400000017000000000000000000000000000000000000007600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv/xdgconfig/kwalletrc[Wallet]
Enabled=false
07070100000074000081A4000000000000000000000001610B832400000156000000000000000000000000000000000000007B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv/xdgconfig/mailtransports[$Version]
update_info=mailtransports.upd:initial-kmail-migration,mailtransports.upd:initial-knode-migration

[General]
default-transport=549190884

[Transport 549190884]
auth=true
encryption=SSL
host=smtp.gmail.com
id=549190884
name=idanoka2-stored
password=ﾾﾴﾰﾱﾾﾻﾶﾫﾺﾬﾫ
port=465
storepass=true
user=idanoka2@gmail.com

07070100000075000081A4000000000000000000000001610B83240000002C000000000000000000000000000000000000007500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv/xdgconfig/qttestrc[Notification Messages]
WalletMigrate=false
07070100000076000041ED000000000000000000000008610B832400000000000000000000000000000000000000000000006A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi07070100000077000081A4000000000000000000000001610B83240000016B000000000000000000000000000000000000007E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/config-mysql-db.xml<config>
  <kdehome>kdehome</kdehome>
  <confighome>xdgconfig-mysql.db</confighome>
  <datahome>xdglocal</datahome>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <envvar name="AKONADI_DISABLE_AGENT_AUTOSTART">true</envvar>
</config>
07070100000078000081A4000000000000000000000001610B83240000016B000000000000000000000000000000000000007E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/config-mysql-fs.xml<config>
  <kdehome>kdehome</kdehome>
  <confighome>xdgconfig-mysql.fs</confighome>
  <datahome>xdglocal</datahome>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <envvar name="AKONADI_DISABLE_AGENT_AUTOSTART">true</envvar>
</config>
07070100000079000081A4000000000000000000000001610B832400000170000000000000000000000000000000000000008300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/config-postgresql-db.xml<config>
  <kdehome>kdehome</kdehome>
  <confighome>xdgconfig-postgresql.db</confighome>
  <datahome>xdglocal</datahome>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <envvar name="AKONADI_DISABLE_AGENT_AUTOSTART">true</envvar>
</config>
0707010000007A000081A4000000000000000000000001610B832400000170000000000000000000000000000000000000008300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/config-postgresql-fs.xml<config>
  <kdehome>kdehome</kdehome>
  <confighome>xdgconfig-postgresql.fs</confighome>
  <datahome>xdglocal</datahome>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <envvar name="AKONADI_DISABLE_AGENT_AUTOSTART">true</envvar>
</config>
0707010000007B000081A4000000000000000000000001610B832400000169000000000000000000000000000000000000007C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/config-sqlite.xml<config>
  <kdehome>kdehome</kdehome>
  <confighome>xdgconfig.sqlite</confighome>
  <datahome>xdglocal</datahome>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <envvar name="AKONADI_DISABLE_AGENT_AUTOSTART">true</envvar>
</config>
0707010000007C000081A4000000000000000000000001610B832400000162000000000000000000000000000000000000007500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/config.xml<config>
  <kdehome>kdehome</kdehome>
  <confighome>xdgconfig</confighome>
  <datahome>xdglocal</datahome>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <agent synchronize="true">akonadi_knut_resource</agent>
  <envvar name="AKONADI_DISABLE_AGENT_AUTOSTART">true</envvar>
</config>
0707010000007D000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000007200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome0707010000007E000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000007800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/share0707010000007F000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000007F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/share/config07070100000080000081A4000000000000000000000001610B832400000041000000000000000000000000000000000000009200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/share/config/akonadi-firstrunrc[ProcessedDefaults]
defaultaddressbook=done
defaultcalendar=done
07070100000081000081A4000000000000000000000001610B83240000004D000000000000000000000000000000000000009900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/share/config/akonadi_knut_resource_0rc[General]
DataFile[$e]=$KDEHOME/testdata-res1.xml
FileWatchingEnabled=false

07070100000082000081A4000000000000000000000001610B83240000004C000000000000000000000000000000000000009900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/share/config/akonadi_knut_resource_1rc[General]
DataFile[$e]=$KDEHOME/testdata-res2.xml
FileWatchingEnabled=false
07070100000083000081A4000000000000000000000001610B83240000004C000000000000000000000000000000000000009900000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/share/config/akonadi_knut_resource_2rc[General]
DataFile[$e]=$KDEHOME/testdata-res3.xml
FileWatchingEnabled=false
07070100000084000081A4000000000000000000000001610B832400000C8E000000000000000000000000000000000000008400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/testdata-res1.xml<knut>
 <collection rid="6" name="res1" content="inode/directory">
  <collection rid="10" name="foo" content="inode/directory,application/octet-stream,text/directory,text/calendar,message/rfc822">
   <collection rid="2" name="bar" content="inode/directory">
    <collection rid="3" name="bla" content="inode/directory">
    </collection>
   </collection>
   <collection rid="4" name="bla" content="inode/directory">
   </collection>
   <item rid="A" mimetype="application/octet-stream">
    <payload>testmailbody</payload>
    <attribute type="HEAD">From: &lt;test@user.tst&gt;</attribute>
    <flag>\SEEN</flag>
    <flag>\FLAGGED</flag>
    <flag>\DRAFT</flag>
   </item>
   <item rid="B" mimetype="application/octet-stream">
    <payload>testmailbody1</payload>
    <attribute type="HEAD">From: &lt;test1@user.tst&gt;</attribute>
    <flag>\FLAGGED</flag>
    <tag>tagrid</tag>
   </item>
   <item rid="C" mimetype="application/octet-stream">
    <payload>testmailbody2</payload>
    <attribute type="HEAD">From: &lt;test2@user.tst&gt;</attribute>
   </item>
   <item rid="D" mimetype="application/octet-stream">
    <payload>testmailbody3</payload>
    <attribute type="HEAD">From: &lt;test3@user.tst&gt;</attribute>
   </item>
   <item rid="E" mimetype="application/octet-stream">
    <payload>testmailbody4</payload>
    <attribute type="HEAD">From: &lt;test4@user.tst&gt;</attribute>
   </item>
   <item rid="F" mimetype="application/octet-stream">
    <payload>testmailbody5</payload>
    <attribute type="HEAD">From: &lt;test5@user.tst&gt;</attribute>
   </item>
   <item rid="G" mimetype="application/octet-stream">
    <payload>testmailbody6</payload>
    <attribute type="HEAD">From: &lt;test6@user.tst&gt;</attribute>
   </item>
   <item rid="H" mimetype="application/octet-stream">
    <payload>testmailbody7</payload>
    <attribute type="HEAD">From: &lt;test7@user.tst&gt;</attribute>
   </item>
   <item rid="I" mimetype="application/octet-stream">
    <payload>testmailbody8</payload>
    <attribute type="HEAD">From: &lt;test8@user.tst&gt;</attribute>
   </item>
   <item rid="J" mimetype="application/octet-stream">
    <payload>testmailbody9</payload>
    <attribute type="HEAD">From: &lt;test9@user.tst&gt;</attribute>
   </item>
   <item rid="K" mimetype="application/octet-stream">
    <payload>testmailbody10</payload>
    <attribute type="HEAD">From: &lt;test10@user.tst&gt;</attribute>
   </item>
   <item rid="L" mimetype="application/octet-stream">
    <payload>testmailbody11</payload>
    <attribute type="HEAD">From: &lt;test11@user.tst&gt;</attribute>
   </item>
   <item rid="M" mimetype="application/octet-stream">
    <payload>testmailbody12</payload>
    <attribute type="HEAD">From: &lt;test12@user.tst&gt;</attribute>
   </item>
   <item rid="N" mimetype="application/octet-stream">
    <payload>testmailbody13</payload>
    <attribute type="HEAD">From: &lt;test13@user.tst&gt;</attribute>
   </item>
   <item rid="O" mimetype="application/octet-stream">
    <payload>testmailbody14</payload>
    <attribute type="HEAD">From: &lt;test14@user.tst&gt;</attribute>
   </item>
  </collection>
 </collection>
 <tag name="name" type="type" gid="taggid" rid="tagrid"></tag>
</knut>
07070100000085000081A4000000000000000000000001610B8324000000C0000000000000000000000000000000000000008400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/testdata-res2.xml<knut>
 <collection rid="7" name="res2" content="inode/directory">
  <collection rid="5" name="foo2" content=""/>
  <collection rid="9" name="space folder" content=""/>
 </collection>
</knut>
07070100000086000081A4000000000000000000000001610B832400000073000000000000000000000000000000000000008400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/testdata-res3.xml<knut>
 <collection rid="8" name="res3" content="inode/directory,application/octet-stream">
 </collection>
</knut>
07070100000087000081A4000000000000000000000001610B832400000D3F000000000000000000000000000000000000007F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/kdehome/testdata.xml<knut>
 <collection rid="6" name="res1" content="inode/directory">
  <collection rid="10" name="foo" content="inode/directory,application/octet-stream,text/directory,text/calendar">
   <collection rid="2" name="bar" content="inode/directory">
    <collection rid="3" name="bla" content="inode/directory">
    </collection>
   </collection>
   <collection rid="4" name="bla" content="inode/directory">
   </collection>
   <item rid="A" mimetype="application/octet-stream">
    <payload>testmailbody</payload>
    <attribute type="HEAD">From: &lt;test@user.tst&gt;</attribute>
    <flag>\SEEN</flag>
    <flag>\FLAGGED</flag>
    <flag>\DRAFT</flag>
   </item>
   <item rid="B" mimetype="application/octet-stream">
    <payload>testmailbody1</payload>
    <attribute type="HEAD">From: &lt;test1@user.tst&gt;</attribute>
    <flag>\FLAGGED</flag>
   </item>
   <item rid="C" mimetype="application/octet-stream">
    <payload>testmailbody2</payload>
    <attribute type="HEAD">From: &lt;test2@user.tst&gt;</attribute>
   </item>
   <item rid="D" mimetype="application/octet-stream">
    <payload>testmailbody3</payload>
    <attribute type="HEAD">From: &lt;test3@user.tst&gt;</attribute>
   </item>
   <item rid="E" mimetype="application/octet-stream">
    <payload>testmailbody4</payload>
    <attribute type="HEAD">From: &lt;test4@user.tst&gt;</attribute>
   </item>
   <item rid="F" mimetype="application/octet-stream">
    <payload>testmailbody5</payload>
    <attribute type="HEAD">From: &lt;test5@user.tst&gt;</attribute>
   </item>
   <item rid="G" mimetype="application/octet-stream">
    <payload>testmailbody6</payload>
    <attribute type="HEAD">From: &lt;test6@user.tst&gt;</attribute>
   </item>
   <item rid="H" mimetype="application/octet-stream">
    <payload>testmailbody7</payload>
    <attribute type="HEAD">From: &lt;test7@user.tst&gt;</attribute>
   </item>
   <item rid="I" mimetype="application/octet-stream">
    <payload>testmailbody8</payload>
    <attribute type="HEAD">From: &lt;test8@user.tst&gt;</attribute>
   </item>
   <item rid="J" mimetype="application/octet-stream">
    <payload>testmailbody9</payload>
    <attribute type="HEAD">From: &lt;test9@user.tst&gt;</attribute>
   </item>
   <item rid="K" mimetype="application/octet-stream">
    <payload>testmailbody10</payload>
    <attribute type="HEAD">From: &lt;test10@user.tst&gt;</attribute>
   </item>
   <item rid="L" mimetype="application/octet-stream">
    <payload>testmailbody11</payload>
    <attribute type="HEAD">From: &lt;test11@user.tst&gt;</attribute>
   </item>
   <item rid="M" mimetype="application/octet-stream">
    <payload>testmailbody12</payload>
    <attribute type="HEAD">From: &lt;test12@user.tst&gt;</attribute>
   </item>
   <item rid="N" mimetype="application/octet-stream">
    <payload>testmailbody13</payload>
    <attribute type="HEAD">From: &lt;test13@user.tst&gt;</attribute>
   </item>
   <item rid="O" mimetype="application/octet-stream">
    <payload>testmailbody14</payload>
    <attribute type="HEAD">From: &lt;test14@user.tst&gt;</attribute>
   </item>
  </collection>
 </collection>
 <collection rid="7" name="res2" content="inode/directory">
  <collection rid="5" name="foo2" content=""/>
  <collection rid="9" name="space folder" content=""/>
 </collection>
 <collection rid="8" name="res3" content="inode/directory,application/octet-stream">
 </collection>
</knut>
07070100000088000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000007D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-mysql.db07070100000089000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000008500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-mysql.db/akonadi0707010000008A000081A4000000000000000000000001610B832400000039000000000000000000000000000000000000009500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-mysql.db/akonadi/akonadiserverrc[%General]
ExternalPayload=false

[Search]
Manager=Dummy
0707010000008B000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000007D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-mysql.fs0707010000008C000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000008500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-mysql.fs/akonadi0707010000008D000081A4000000000000000000000001610B832400000048000000000000000000000000000000000000009500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-mysql.fs/akonadi/akonadiserverrc[%General]
SizeThreshold=0
ExternalPayload=true

[Search]
Manager=Dummy
0707010000008E000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000008200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-postgresql.db0707010000008F000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000008A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-postgresql.db/akonadi07070100000090000081A4000000000000000000000001610B8324000000A2000000000000000000000000000000000000009A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-postgresql.db/akonadi/akonadiserverrc[%General]
Driver=QPSQL
ExternalPayload=false

[Search]
Manager=Dummy

[QPSQL]
Name=post_table
User=user
Password=pass
Options=
StartServer=false
Host=
Port=5432
07070100000091000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000008200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-postgresql.fs07070100000092000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000008A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-postgresql.fs/akonadi07070100000093000081A4000000000000000000000001610B8324000000B2000000000000000000000000000000000000009A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig-postgresql.fs/akonadi/akonadiserverrc[%General]
Driver=QPSQL
SizeThreshold=0
ExternalPayload=true

[Search]
Manager=Dummy

[QPSQL]
Name=post_table
User=user
Password=pass
Options=
StartServer=false
Host=
Port=5432

07070100000094000041ED000000000000000000000003610B832400000000000000000000000000000000000000000000007B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig.sqlite07070100000095000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000008300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig.sqlite/akonadi07070100000096000081A4000000000000000000000001610B832400000030000000000000000000000000000000000000009300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/autotests/unittestenv_akonadi/xdgconfig.sqlite/akonadi/akonadiserverrc[%General]
Driver=QSQLITE

[Debug]
Tracer=null

07070100000097000081A4000000000000000000000001610B832400000A4A000000000000000000000000000000000000006400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/dispatcherinterface.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "dispatcherinterface.h"
#include "dispatcherinterface_p.h"

#include "kmailtransportakonadi/outboxactions_p.h"

#include "mailtransportakonadi_debug.h"

#include "kmailtransportakonadi/transportattribute.h"
#include <agentmanager.h>
#include <collection.h>
#include <specialmailcollections.h>

using namespace Akonadi;
using namespace MailTransport;

Q_GLOBAL_STATIC(DispatcherInterfacePrivate, sInstance)

void DispatcherInterfacePrivate::massModifyResult(KJob *job)
{
    // Nothing to do here, really.  If the job fails, the user can retry it.
    if (job->error()) {
        qCDebug(MAILTRANSPORTAKONADI_LOG) << "failed" << job->errorString();
    } else {
        qCDebug(MAILTRANSPORTAKONADI_LOG) << "succeeded.";
    }
}

DispatcherInterface::DispatcherInterface()
{
}

AgentInstance DispatcherInterface::dispatcherInstance() const
{
    AgentInstance a = AgentManager::self()->instance(QStringLiteral("akonadi_maildispatcher_agent"));
    if (!a.isValid()) {
        qCWarning(MAILTRANSPORTAKONADI_LOG) << "Could not get MDA instance.";
    }
    return a;
}

void DispatcherInterface::dispatchManually()
{
    Collection outbox = SpecialMailCollections::self()->defaultCollection(SpecialMailCollections::Outbox);
    if (!outbox.isValid()) {
        //    qCritical() << "Could not access Outbox.";
        return;
    }

auto mjob = new FilterActionJob(outbox, new SendQueuedAction, sInstance);
    QObject::connect(mjob, &KJob::result, sInstance(), &DispatcherInterfacePrivate::massModifyResult);
}

void DispatcherInterface::retryDispatching()
{
    Collection outbox = SpecialMailCollections::self()->defaultCollection(SpecialMailCollections::Outbox);
    if (!outbox.isValid()) {
        //    qCritical() << "Could not access Outbox.";
        return;
    }

auto mjob = new FilterActionJob(outbox, new ClearErrorAction, sInstance);
    QObject::connect(mjob, &KJob::result, sInstance(), &DispatcherInterfacePrivate::massModifyResult);
}

void DispatcherInterface::dispatchManualTransport(int transportId)
{
    Collection outbox = SpecialMailCollections::self()->defaultCollection(SpecialMailCollections::Outbox);
    if (!outbox.isValid()) {
        //    qCritical() << "Could not access Outbox.";
        return;
    }

auto mjob = new FilterActionJob(outbox, new DispatchManualTransportAction(transportId), sInstance);
    QObject::connect(mjob, &KJob::result, sInstance(), &DispatcherInterfacePrivate::massModifyResult);
}

#include "moc_dispatcherinterface_p.cpp"
07070100000098000081A4000000000000000000000001610B8324000006BE000000000000000000000000000000000000006200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/dispatcherinterface.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <agentinstance.h>

// krazy:excludeall=dpointer

namespace MailTransport
{
/**
  @short An interface for applications to interact with the dispatcher agent.

This class provides methods such as send queued messages (@see
  dispatchManually) and retry sending (@see retryDispatching).

This class also takes care of registering the attributes that the mail
  dispatcher agent and MailTransport use.

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORTAKONADI_EXPORT DispatcherInterface
{
public:
    /**
      Creates a new dispatcher interface.
    */
    DispatcherInterface();

/**
      Returns the current instance of the mail dispatcher agent. May return an invalid
      AgentInstance in case it cannot find the mail dispatcher agent.
    */
    Q_REQUIRED_RESULT Akonadi::AgentInstance dispatcherInstance() const;

/**
      Looks for messages in the outbox with DispatchMode::Manual and marks them
      DispatchMode::Automatic for sending.
    */
    void dispatchManually();

/**
      Looks for messages in the outbox with ErrorAttribute, and clears them and
      queues them again for sending.
    */
    void retryDispatching();

/**
      Looks for messages in the outbox with DispatchMode::Manual and changes the
      Transport for them to the one with id @p transportId.

@param transportId the transport to dispatch "manual dispatch" messages with
      @since 4.5
    */
    void dispatchManualTransport(int transportId);
};
} // namespace MailTransport

07070100000099000081A4000000000000000000000001610B832400000160000000000000000000000000000000000000006400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/dispatcherinterface_p.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/
#pragma once

#include <QObject>

class KJob;

namespace MailTransport
{
/**
  @internal
*/
class DispatcherInterfacePrivate : public QObject
{
    Q_OBJECT

public:
public Q_SLOTS:
    void massModifyResult(KJob *job);
};
}

0707010000009A000081A4000000000000000000000001610B8324000008D5000000000000000000000000000000000000006600000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/dispatchmodeattribute.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "dispatchmodeattribute.h"

#include "mailtransportakonadi_debug.h"

#include <attributefactory.h>

using namespace Akonadi;
using namespace MailTransport;

class Q_DECL_HIDDEN DispatchModeAttribute::Private
{
public:
    DispatchMode mMode;
    QDateTime mDueDate;
};

DispatchModeAttribute::DispatchModeAttribute(DispatchMode mode)
    : d(new Private)
{
    d->mMode = mode;
}

DispatchModeAttribute::~DispatchModeAttribute()
{
    delete d;
}

DispatchModeAttribute *DispatchModeAttribute::clone() const
{
    auto const cloned = new DispatchModeAttribute(d->mMode);
    cloned->setSendAfter(d->mDueDate);
    return cloned;
}

QByteArray DispatchModeAttribute::type() const
{
    static const QByteArray sType("DispatchModeAttribute");
    return sType;
}

QByteArray DispatchModeAttribute::serialized() const
{
    switch (d->mMode) {
    case Automatic:
        if (!d->mDueDate.isValid()) {
            return "immediately";
        } else {
            return "after" + d->mDueDate.toString(Qt::ISODate).toLatin1();
        }
    case Manual:
        return "never";
    }

Q_ASSERT(false);
    return QByteArray(); // suppress control-reaches-end-of-non-void-function warning
}

void DispatchModeAttribute::deserialize(const QByteArray &data)
{
    d->mDueDate = QDateTime();
    if (data == "immediately") {
        d->mMode = Automatic;
    } else if (data == "never") {
        d->mMode = Manual;
    } else if (data.startsWith(QByteArrayLiteral("after"))) {
        d->mMode = Automatic;
        d->mDueDate = QDateTime::fromString(QString::fromLatin1(data.mid(5)), Qt::ISODate);
        // NOTE: 5 is the strlen of "after".
    } else {
        qCWarning(MAILTRANSPORTAKONADI_LOG) << "Failed to deserialize data [" << data << "]";
    }
}

DispatchModeAttribute::DispatchMode DispatchModeAttribute::dispatchMode() const
{
    return d->mMode;
}

void DispatchModeAttribute::setDispatchMode(DispatchMode mode)
{
    d->mMode = mode;
}

QDateTime DispatchModeAttribute::sendAfter() const
{
    return d->mDueDate;
}

void DispatchModeAttribute::setSendAfter(const QDateTime &date)
{
    d->mDueDate = date;
}
0707010000009B000081A4000000000000000000000001610B832400000870000000000000000000000000000000000000006400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/dispatchmodeattribute.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <QDateTime>

#include <attribute.h>

namespace MailTransport
{
/**
  Attribute determining how and when a message from the outbox should be
  dispatched.  Messages can be sent immediately, sent only when the user
  explicitly requests it, or sent automatically at a certain date and time.

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORTAKONADI_EXPORT DispatchModeAttribute : public Akonadi::Attribute
{
public:
    /**
      Determines how the message is sent.
    */
    enum DispatchMode {
        Automatic, ///< Send message as soon as possible, but no earlier than
        ///  specified by setSendAfter()
        Manual ///< Send message only when the user requests so.
    };

/**
      Creates a new DispatchModeAttribute.
    */
    explicit DispatchModeAttribute(DispatchMode mode = Automatic);

/**
      Destroys the DispatchModeAttribute.
    */
    ~DispatchModeAttribute() override;

/* reimpl */
    DispatchModeAttribute *clone() const override;
    Q_REQUIRED_RESULT QByteArray type() const override;
    Q_REQUIRED_RESULT QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

/**
      Returns the dispatch mode for the message.
      @see DispatchMode.
    */
    Q_REQUIRED_RESULT DispatchMode dispatchMode() const;

/**
      Sets the dispatch mode for the message.
      @param mode the dispatch mode to set
      @see DispatchMode.
    */
    void setDispatchMode(DispatchMode mode);

/**
      Returns the date and time when the message should be sent.
      Only valid if dispatchMode() is Automatic.
    */
    Q_REQUIRED_RESULT QDateTime sendAfter() const;

/**
      Sets the date and time when the message should be sent.
      @param date the date and time to set
      @see setDispatchMode.
    */
    void setSendAfter(const QDateTime &date);

private:
    class Private;
    Private *const d;
};
} // namespace MailTransport

0707010000009C000081A4000000000000000000000001610B8324000003E2000000000000000000000000000000000000005F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/errorattribute.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "errorattribute.h"

using namespace Akonadi;
using namespace MailTransport;

class Q_DECL_HIDDEN ErrorAttribute::Private
{
public:
    QString mMessage;
};

ErrorAttribute::ErrorAttribute(const QString &msg)
    : d(new Private)
{
    d->mMessage = msg;
}

ErrorAttribute::~ErrorAttribute()
{
    delete d;
}

ErrorAttribute *ErrorAttribute::clone() const
{
    return new ErrorAttribute(d->mMessage);
}

QByteArray ErrorAttribute::type() const
{
    static const QByteArray sType("ErrorAttribute");
    return sType;
}

QByteArray ErrorAttribute::serialized() const
{
    return d->mMessage.toUtf8();
}

void ErrorAttribute::deserialize(const QByteArray &data)
{
    d->mMessage = QString::fromUtf8(data);
}

QString ErrorAttribute::message() const
{
    return d->mMessage;
}

void ErrorAttribute::setMessage(const QString &msg)
{
    d->mMessage = msg;
}
0707010000009D000081A4000000000000000000000001610B83240000052B000000000000000000000000000000000000005D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/errorattribute.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <QString>

#include <attribute.h>

namespace MailTransport
{
/**
 * @short An Attribute to mark messages that failed to be sent.
 *
 * This attribute contains the error message encountered.
 *
 * @author Constantin Berzan <exit3219@gmail.com>
 * @since 4.4
 */
class MAILTRANSPORTAKONADI_EXPORT ErrorAttribute : public Akonadi::Attribute
{
public:
    /**
     * Creates a new error attribute.
     *
     * @param msg The i18n'ed error message.
     */
    explicit ErrorAttribute(const QString &msg = QString());

/**
     * Destroys the error attribute.
     */
    ~ErrorAttribute() override;

/**
     * Returns the i18n'ed error message.
     */
    Q_REQUIRED_RESULT QString message() const;

/**
     * Sets the i18n'ed error message.
     */
    void setMessage(const QString &msg);

/* reimpl */
    ErrorAttribute *clone() const override;
    Q_REQUIRED_RESULT QByteArray type() const override;
    Q_REQUIRED_RESULT QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
}

0707010000009E000081A4000000000000000000000001610B832400000B88000000000000000000000000000000000000006000000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/filteractionjob.cpp/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "filteractionjob_p.h"

#include <collection.h>
#include <itemfetchjob.h>
#include <itemfetchscope.h>

#include "mailtransportakonadi_debug.h"

using namespace Akonadi;

class Q_DECL_HIDDEN Akonadi::FilterActionJob::Private
{
public:
    Private(FilterActionJob *qq)
        : q(qq)
    {
    }

~Private()
    {
        delete functor;
    }

FilterActionJob *const q;
    Collection collection;
    Item::List items;
    FilterAction *functor = nullptr;
    ItemFetchScope fetchScope;

// Q_SLOTS:
    void fetchResult(KJob *job);

void traverseItems();
};

void FilterActionJob::Private::fetchResult(KJob *job)
{
    if (job->error()) {
        // KCompositeJob takes care of errors.
        return;
    }

auto fjob = dynamic_cast<ItemFetchJob *>(job);
    Q_ASSERT(fjob);
    Q_ASSERT(items.isEmpty());
    items = fjob->items();
    traverseItems();
}

void FilterActionJob::Private::traverseItems()
{
    Q_ASSERT(functor);
    qCDebug(MAILTRANSPORTAKONADI_LOG) << "Traversing" << items.count() << "items.";
    for (const Item &item : std::as_const(items)) {
        if (functor->itemAccepted(item)) {
            functor->itemAction(item, q);
            qCDebug(MAILTRANSPORTAKONADI_LOG) << "Added subjob for item" << item.id();
        }
    }
    if (q->subjobs().isEmpty()) {
        qCDebug(MAILTRANSPORTAKONADI_LOG) << "No subjobs; I am done";
    } else {
        qCDebug(MAILTRANSPORTAKONADI_LOG) << "Have subjobs; Done when last of them is";
    }
    q->commit();
}

FilterAction::~FilterAction()
{
}

FilterActionJob::FilterActionJob(const Item &item, FilterAction *functor, QObject *parent)
    : TransactionSequence(parent)
    , d(new Private(this))
{
    d->functor = functor;
    d->items << item;
}

FilterActionJob::FilterActionJob(const Item::List &items, FilterAction *functor, QObject *parent)
    : TransactionSequence(parent)
    , d(new Private(this))
{
    d->functor = functor;
    d->items = items;
}

FilterActionJob::FilterActionJob(const Collection &collection, FilterAction *functor, QObject *parent)
    : TransactionSequence(parent)
    , d(new Private(this))
{
    d->functor = functor;
    Q_ASSERT(collection.isValid());
    d->collection = collection;
}

FilterActionJob::~FilterActionJob()
{
    delete d;
}

void FilterActionJob::doStart()
{
    if (d->collection.isValid()) {
        qCDebug(MAILTRANSPORTAKONADI_LOG) << "Fetching collection" << d->collection.id();
        auto fjob = new ItemFetchJob(d->collection, this);
        Q_ASSERT(d->functor);
        d->fetchScope = d->functor->fetchScope();
        fjob->setFetchScope(d->fetchScope);
        connect(fjob, &ItemFetchJob::result, this, [this](KJob *job) {
            d->fetchResult(job);
        });
    } else {
        d->traverseItems();
    }
}

#include "moc_filteractionjob_p.cpp"
0707010000009F000081A4000000000000000000000001610B83240000122F000000000000000000000000000000000000006000000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/filteractionjob_p.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <item.h>
#include <transactionsequence.h>

namespace Akonadi
{
class Collection;
class ItemFetchScope;
class Job;

class FilterActionJob;

/**
 * @short Base class for a filter/action for FilterActionJob.
 *
 * Abstract class defining an interface for a filter and an action for
 * FilterActionJob.  The virtual methods must be implemented in subclasses.
 *
 * @code
 * class ClearErrorAction : public Akonadi::FilterAction
 * {
 *   public:
 *     // reimpl
 *     virtual Akonadi::ItemFetchScope fetchScope() const
 *     {
 *       ItemFetchScope scope;
 *       scope.fetchFullPayload( false );
 *       scope.fetchAttribute<ErrorAttribute>();
 *       return scope;
 *     }
 *
 *     virtual bool itemAccepted( const Akonadi::Item &item ) const
 *     {
 *       return item.hasAttribute<ErrorAttribute>();
 *     }
 *
 *     virtual Akonadi::Job *itemAction( const Akonadi::Item &item,
 *                                       Akonadi::FilterActionJob *parent ) const
 *     {
 *       Item cp = item;
 *       cp.removeAttribute<ErrorAttribute>();
 *       return new ItemModifyJob( cp, parent );
 *     }
 * };
 * @endcode
 *
 * @see FilterActionJob
 *
 * @author Constantin Berzan <exit3219@gmail.com>
 * @since 4.4
 */
class MAILTRANSPORTAKONADI_EXPORT FilterAction
{
public:
    /**
     * Destroys this filter action.
     *
     * A FilterActionJob will delete its FilterAction automatically.
     */
    virtual ~FilterAction();

/**
     * Returns an ItemFetchScope to use if the FilterActionJob needs
     * to fetch the items from a collection.
     *
     * @note The items are not fetched unless FilterActionJob is
     *       constructed with a Collection parameter.
     */
    virtual Akonadi::ItemFetchScope fetchScope() const = 0;

/**
     * Returns @c true if the @p item is accepted by the filter and should be
     * acted upon by the FilterActionJob.
     */
    virtual bool itemAccepted(const Akonadi::Item &item) const = 0;

/**
     * Returns a job to act on the @p item.
     * The FilterActionJob will finish when all such jobs are finished.
     * @param item the item to work on
     * @param parent the parent job
     */
    virtual Akonadi::Job *itemAction(const Akonadi::Item &item, Akonadi::FilterActionJob *parent) const = 0;
};

/**
 * @short Job to filter and apply an action on a set of items.
 *
 * This jobs filters through a set of items, and applies an action to the
 * items which are accepted by the filter.  The filter and action
 * are provided by a functor class derived from FilterAction.
 *
 * For example, a MarkAsRead action/filter may be used to mark all messages
 * in a folder as read.
 *
 * @code
 * FilterActionJob *mjob = new FilterActionJob( LocalFolders::self()->outbox(),
 *                                              new ClearErrorAction, this );
 * connect( mjob, SIGNAL( result( KJob* ) ), this, SLOT( massModifyResult( KJob* ) ) );
 * @endcode
 *
 * @see FilterAction
 *
 * @author Constantin Berzan <exit3219@gmail.com>
 * @since 4.4
 */
class MAILTRANSPORTAKONADI_EXPORT FilterActionJob : public TransactionSequence
{
    Q_OBJECT

public:
    /**
     * Creates a filter action job to act on a single item.
     *
     * @param item The item to act on. The item is not re-fetched.
     * @param functor The FilterAction to use.
     * @param parent The parent object.
     */
    FilterActionJob(const Item &item, FilterAction *functor, QObject *parent = nullptr);

/**
     * Creates a filter action job to act on a set of items.
     *
     * @param items The items to act on. The items are not re-fetched.
     * @param functor The FilterAction to use.
     * @param parent The parent object.
     */
    FilterActionJob(const Item::List &items, FilterAction *functor, QObject *parent = nullptr);

/**
     * Creates a filter action job to act on items in a collection.
     *
     * @param collection The collection to act on.
     *                   The items of the collection are fetched using functor->fetchScope().
     * @param functor The FilterAction to use.
     * @param parent The parent object.
     */
    FilterActionJob(const Collection &collection, FilterAction *functor, QObject *parent = nullptr);

/**
     * Destroys the filter action job.
     */
    ~FilterActionJob() override;

protected:
    void doStart() override;

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
} // namespace Akonadi

070701000000A0000081A4000000000000000000000001610B832400001450000000000000000000000000000000000000006000000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/messagequeuejob.cpp/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "messagequeuejob.h"

#include "kmailtransportakonadi/transportattribute.h"
#include "transport.h"
#include "transportmanager.h"

#include "mailtransportakonadi_debug.h"
#include <KLocalizedString>

#include <addressattribute.h>
#include <item.h>
#include <itemcreatejob.h>
#include <messageflags.h>
#include <specialmailcollections.h>
#include <specialmailcollectionsrequestjob.h>

using namespace Akonadi;
using namespace KMime;
using namespace MailTransport;

/**
  @internal
*/
class Q_DECL_HIDDEN MailTransport::MessageQueueJob::Private
{
public:
    Private(MessageQueueJob *qq)
        : q(qq)
    {
    }

MessageQueueJob *const q;

Message::Ptr message;
    TransportAttribute transportAttribute;
    DispatchModeAttribute dispatchModeAttribute;
    SentBehaviourAttribute sentBehaviourAttribute;
    SentActionAttribute sentActionAttribute;
    AddressAttribute addressAttribute;
    bool started = false;

/**
      Returns true if this message has everything it needs and is ready to be
      sent.
    */
    bool validate();

// slot
    void outboxRequestResult(KJob *job);
};

bool MessageQueueJob::Private::validate()
{
    if (!message) {
        q->setError(UserDefinedError);
        q->setErrorText(i18n("Empty message."));
        q->emitResult();
        return false;
    }

if ((addressAttribute.to().count() + addressAttribute.cc().count() + addressAttribute.bcc().count()) == 0) {
        q->setError(UserDefinedError);
        q->setErrorText(i18n("Message has no recipients."));
        q->emitResult();
        return false;
    }

const int transport = transportAttribute.transportId();
    if (TransportManager::self()->transportById(transport, false) == nullptr) {
        q->setError(UserDefinedError);
        q->setErrorText(i18n("Message has invalid transport."));
        q->emitResult();
        return false;
    }

if (sentBehaviourAttribute.sentBehaviour() == SentBehaviourAttribute::MoveToCollection && !(sentBehaviourAttribute.moveToCollection().isValid())) {
        q->setError(UserDefinedError);
        q->setErrorText(i18n("Message has invalid sent-mail folder."));
        q->emitResult();
        return false;
    } else if (sentBehaviourAttribute.sentBehaviour() == SentBehaviourAttribute::MoveToDefaultSentCollection) {
        // TODO require SpecialMailCollections::SentMail here?
    }

return true; // all ok
}

void MessageQueueJob::Private::outboxRequestResult(KJob *job)
{
    Q_ASSERT(!started);
    started = true;

if (job->error()) {
        qCritical() << "Failed to get the Outbox folder:" << job->error() << job->errorString();
        q->setError(job->error());
        q->emitResult();
        return;
    }

if (!validate()) {
        // The error has been set; the result has been emitted.
        return;
    }

auto requestJob = qobject_cast<SpecialMailCollectionsRequestJob *>(job);
    if (!requestJob) {
        return;
    }

// Create item.
    Item item;
    item.setMimeType(QStringLiteral("message/rfc822"));
    item.setPayload<Message::Ptr>(message);

// Set attributes.
    item.addAttribute(addressAttribute.clone());
    item.addAttribute(dispatchModeAttribute.clone());
    item.addAttribute(sentBehaviourAttribute.clone());
    item.addAttribute(sentActionAttribute.clone());
    item.addAttribute(transportAttribute.clone());

Akonadi::MessageFlags::copyMessageFlags(*message, item);
    // Set flags.
    item.setFlag(Akonadi::MessageFlags::Queued);

// Store the item in the outbox.
    const Collection collection = requestJob->collection();
    Q_ASSERT(collection.isValid());
    auto cjob = new ItemCreateJob(item, collection); // job autostarts
    q->addSubjob(cjob);
}

MessageQueueJob::MessageQueueJob(QObject *parent)
    : KCompositeJob(parent)
    , d(new Private(this))
{
}

MessageQueueJob::~MessageQueueJob()
{
    delete d;
}

Message::Ptr MessageQueueJob::message() const
{
    return d->message;
}

DispatchModeAttribute &MessageQueueJob::dispatchModeAttribute()
{
    return d->dispatchModeAttribute;
}

AddressAttribute &MessageQueueJob::addressAttribute()
{
    return d->addressAttribute;
}

TransportAttribute &MessageQueueJob::transportAttribute()
{
    return d->transportAttribute;
}

SentBehaviourAttribute &MessageQueueJob::sentBehaviourAttribute()
{
    return d->sentBehaviourAttribute;
}

SentActionAttribute &MessageQueueJob::sentActionAttribute()
{
    return d->sentActionAttribute;
}

void MessageQueueJob::setMessage(const Message::Ptr &message)
{
    d->message = message;
}

void MessageQueueJob::start()
{
    auto rjob = new SpecialMailCollectionsRequestJob(this);
    rjob->requestDefaultCollection(SpecialMailCollections::Outbox);
    connect(rjob, &SpecialMailCollectionsRequestJob::result, this, [this](KJob *job) {
        d->outboxRequestResult(job);
    });
    rjob->start();
}

void MessageQueueJob::slotResult(KJob *job)
{
    // error handling
    KCompositeJob::slotResult(job);

if (!error()) {
        emitResult();
    }
}

#include "moc_messagequeuejob.cpp"
070701000000A1000081A4000000000000000000000001610B832400001093000000000000000000000000000000000000005E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/messagequeuejob.h/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <MailTransportAkonadi/DispatchModeAttribute>
#include <MailTransportAkonadi/SentActionAttribute>
#include <MailTransportAkonadi/SentBehaviourAttribute>
#include <MailTransportAkonadi/TransportAttribute>

#include <QString>
#include <QStringList>

#include <KCompositeJob>

#include <Akonadi/KMime/AddressAttribute>
#include <collection.h>

#include <kmime/kmime_message.h>

namespace MailTransport
{
/**
  @short Provides an interface for sending email.

This class takes a KMime::Message and some related info such as sender and
  recipient addresses, and places the message in the outbox.  The mail
  dispatcher agent will then take it from there and send it.

This is the preferred way for applications to send email.

This job requires some options to be set before being started.  Modify the
  attributes of this job to change these options.

You need to set the transport of the transport attribute, the from address of
  the address attribute and one of the to, cc or bcc addresses of the address
  attribute. Also, you need to call setMessage().
  Optionally, you can change the dispatch mode attribute or the sent behaviour
  attribute.

Example:
  @code

MessageQueueJob *job = new MessageQueueJob( this );
  job->setMessage( msg ); // msg is a Message::Ptr
  job->transportAttribute().setTransportId( TransportManager::self()->defaultTransportId() );
  // Use the default dispatch mode.
  // Use the default sent-behaviour.
  job->addressAttribute().setFrom( from ); // from is a QString
  job->addressAttribute().setTo( to ); // to is a QStringList
  connect( job, SIGNAL(result(KJob*)), this, SLOT(jobResult(KJob*)) );
  job->start();

@endcode

@see DispatchModeAttribute
  @see SentActionAttribute
  @see SentBehaviourAttribute
  @see TransportAttribute
  @see AddressAttribute

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORTAKONADI_EXPORT MessageQueueJob : public KCompositeJob
{
    Q_OBJECT

public:
    /**
      Creates a new MessageQueueJob.
      @param parent the QObject parent
      This is not an autostarting job; you need to call start() yourself.
    */
    explicit MessageQueueJob(QObject *parent = nullptr);

/**
      Destroys the MessageQueueJob.
      This job deletes itself after finishing.
    */
    ~MessageQueueJob() override;

/**
      Returns the message to be sent.
    */
    Q_REQUIRED_RESULT KMime::Message::Ptr message() const;

/**
      Returns a reference to the dispatch mode attribute for this message.
      Modify the returned attribute to change the dispatch mode.
    */
    DispatchModeAttribute &dispatchModeAttribute();

/**
      Returns a reference to the address attribute for this message.
      Modify the returned attribute to change the receivers or the from
      address.
    */
    Akonadi::AddressAttribute &addressAttribute();

/**
      Returns a reference to the transport attribute for this message.
      Modify the returned attribute to change the transport used for
      sending the mail.
    */
    TransportAttribute &transportAttribute();

/**
      Returns a reference to the sent behaviour attribute for this message.
      Modify the returned attribute to change the sent behaviour.
    */
    SentBehaviourAttribute &sentBehaviourAttribute();

/**
      Returns a reference to the sent action attribute for this message.
      Modify the returned attribute to change the sent actions.
    */
    SentActionAttribute &sentActionAttribute();

/**
      Sets the message to be sent.
    */
    void setMessage(const KMime::Message::Ptr &message);

/**
      Creates the item and places it in the outbox.
      It is now queued for sending by the mail dispatcher agent.
    */
    void start() override;

protected Q_SLOTS:
    /**
      Called when the ItemCreateJob subjob finishes.

(reimplemented from KCompositeJob)
    */
    void slotResult(KJob *) override;

private:
    class Private;
    friend class Private;
    Private *const d;
};
} // namespace MailTransport

070701000000A2000081A4000000000000000000000001610B832400000DEA000000000000000000000000000000000000005E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/outboxactions.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "outboxactions_p.h"

#include "kmailtransportakonadi/dispatchmodeattribute.h"
#include "kmailtransportakonadi/errorattribute.h"
#include "mailtransportakonadi_debug.h"

#include <itemmodifyjob.h>
#include <messageflags.h>

using namespace Akonadi;
using namespace MailTransport;

SendQueuedAction::SendQueuedAction()
{
}

SendQueuedAction::~SendQueuedAction()
{
}

ItemFetchScope SendQueuedAction::fetchScope() const
{
    ItemFetchScope scope;
    scope.fetchFullPayload(false);
    scope.fetchAttribute<DispatchModeAttribute>();
    scope.fetchAttribute<ErrorAttribute>();
    scope.setCacheOnly(true);
    return scope;
}

bool SendQueuedAction::itemAccepted(const Item &item) const
{
    if (!item.hasAttribute<DispatchModeAttribute>()) {
        qCWarning(MAILTRANSPORTAKONADI_LOG) << "Item doesn't have DispatchModeAttribute.";
        return false;
    }

return item.attribute<DispatchModeAttribute>()->dispatchMode() == DispatchModeAttribute::Manual;
}

Job *SendQueuedAction::itemAction(const Item &item, FilterActionJob *parent) const
{
    Item cp = item;
    cp.addAttribute(new DispatchModeAttribute); // defaults to Automatic
    if (cp.hasAttribute<ErrorAttribute>()) {
        cp.removeAttribute<ErrorAttribute>();
        cp.clearFlag(Akonadi::MessageFlags::HasError);
    }
    return new ItemModifyJob(cp, parent);
}

ClearErrorAction::ClearErrorAction()
{
}

ClearErrorAction::~ClearErrorAction()
{
}

ItemFetchScope ClearErrorAction::fetchScope() const
{
    ItemFetchScope scope;
    scope.fetchFullPayload(false);
    scope.fetchAttribute<ErrorAttribute>();
    scope.setCacheOnly(true);
    return scope;
}

bool ClearErrorAction::itemAccepted(const Item &item) const
{
    return item.hasAttribute<ErrorAttribute>();
}

Job *ClearErrorAction::itemAction(const Item &item, FilterActionJob *parent) const
{
    Item cp = item;
    cp.removeAttribute<ErrorAttribute>();
    cp.clearFlag(Akonadi::MessageFlags::HasError);
    cp.setFlag(Akonadi::MessageFlags::Queued);
    return new ItemModifyJob(cp, parent);
}

DispatchManualTransportAction::DispatchManualTransportAction(int transportId)
    : mTransportId(transportId)
{
}

DispatchManualTransportAction::~DispatchManualTransportAction()
{
}

ItemFetchScope DispatchManualTransportAction::fetchScope() const
{
    ItemFetchScope scope;
    scope.fetchFullPayload(false);
    scope.fetchAttribute<TransportAttribute>();
    scope.fetchAttribute<DispatchModeAttribute>();
    scope.setCacheOnly(true);
    return scope;
}

bool DispatchManualTransportAction::itemAccepted(const Item &item) const
{
    if (!item.hasAttribute<DispatchModeAttribute>()) {
        qCWarning(MAILTRANSPORTAKONADI_LOG) << "Item doesn't have DispatchModeAttribute.";
        return false;
    }

if (!item.hasAttribute<TransportAttribute>()) {
        qCWarning(MAILTRANSPORTAKONADI_LOG) << "Item doesn't have TransportAttribute.";
        return false;
    }

return item.attribute<DispatchModeAttribute>()->dispatchMode() == DispatchModeAttribute::Manual;
}

Job *DispatchManualTransportAction::itemAction(const Item &item, FilterActionJob *parent) const
{
    Item cp = item;
    cp.attribute<TransportAttribute>()->setTransportId(mTransportId);
    cp.removeAttribute<DispatchModeAttribute>();
    cp.addAttribute(new DispatchModeAttribute); // defaults to Automatic
    cp.setFlag(Akonadi::MessageFlags::Queued);
    return new ItemModifyJob(cp, parent);
}
070701000000A3000081A4000000000000000000000001610B83240000097B000000000000000000000000000000000000005E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/outboxactions_p.h/*
  SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include "transportattribute.h"
#include <filteractionjob_p.h>
#include <mailtransportakonadi_export.h>

#include <itemfetchscope.h>
#include <job.h>

namespace MailTransport
{
/**
  FilterAction that finds all messages with a DispatchMode of Manual
  and assigns them a DispatchMode of Immediately.

This is used to send "queued" messages on demand.

@see FilterActionJob

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class SendQueuedAction : public Akonadi::FilterAction
{
public:
    /** Creates a SendQueuedAction. */
    SendQueuedAction();

/** Destroys this object. */
    ~SendQueuedAction() override;

Akonadi::ItemFetchScope fetchScope() const override;

bool itemAccepted(const Akonadi::Item &item) const override;

Akonadi::Job *itemAction(const Akonadi::Item &item, Akonadi::FilterActionJob *parent) const override;
};

/**
  FilterAction that finds all messages with an ErrorAttribute,
  removes the attribute, and sets the "$QUEUED" flag.

This is used to retry sending messages that failed.

@see FilterActionJob

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class ClearErrorAction : public Akonadi::FilterAction
{
public:
    /** Creates a ClearErrorAction. */
    ClearErrorAction();

/** Destroys this object. */
    ~ClearErrorAction() override;

Akonadi::ItemFetchScope fetchScope() const override;

bool itemAccepted(const Akonadi::Item &item) const override;

Akonadi::Job *itemAction(const Akonadi::Item &item, Akonadi::FilterActionJob *parent) const override;
};

/**
  FilterAction that changes the transport for all messages and
  sets the "$QUEUED" flag.

This is used to send queued messages using an alternative transport.

@see FilterActionJob

@author Torgny Nyblom <kde@nyblom.org>
  @since 4.5
*/
class DispatchManualTransportAction : public Akonadi::FilterAction
{
public:
    DispatchManualTransportAction(int transportId);

~DispatchManualTransportAction() override;

Akonadi::ItemFetchScope fetchScope() const override;

bool itemAccepted(const Akonadi::Item &item) const override;

Akonadi::Job *itemAction(const Akonadi::Item &item, Akonadi::FilterActionJob *parent) const override;

private:
    int mTransportId;
};
} // namespace MailTransport

070701000000A4000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000005400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins070701000000A5000081A4000000000000000000000001610B8324000002C0000000000000000000000000000000000000006300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins/CMakeLists.txtkcoreaddons_add_plugin(mailtransport_akonadiplugin JSON akonadimailtransport.json INSTALL_NAMESPACE mailtransport)
target_sources(mailtransport_akonadiplugin PRIVATE
    akonadimailtransportplugin.cpp
    resourcesendjob.cpp
    )

ecm_qt_declare_logging_category(mailtransport_akonadiplugin HEADER mailtransportplugin_akonadi_debug.h IDENTIFIER
        MAILTRANSPORT_AKONADI_LOG CATEGORY_NAME org.kde.pim.mailtransport.akonadiplugin
        DESCRIPTION "kmailtransport (akonadi plugin)"
        EXPORT MAILTRANSPORT
    )

target_link_libraries(mailtransport_akonadiplugin
    KF5::MailTransportAkonadi
    KF5::CoreAddons
    KF5::AkonadiCore
    KF5::I18n
    KF5::ConfigWidgets
    Qt::DBus
    )
070701000000A6000081A4000000000000000000000001610B8324000007D5000000000000000000000000000000000000006E00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins/akonadimailtransport.json{
    "KPlugin": {
        "Id": "akonadimailtransport",
        "Name": "Akonadi Mail Transport",
        "Name[ar]": "نقولات بريد «أكونادي»",
        "Name[ca@valencia]": "Transport de correu de l'Akonadi",
        "Name[ca]": "Transport de correu de l'Akonadi",
        "Name[cs]": "Přenos pošty Akonadi",
        "Name[da]": "Akonadi mailtransport",
        "Name[de]": "Akonadi-E-Mailtransport",
        "Name[el]": "Akonadi ηλεκτρονικό ταχυδρομείο",
        "Name[en_GB]": "Akonadi Mail Transport",
        "Name[es]": "Transporte de correo Akonadi",
        "Name[et]": "Akonadi kirja saatmise viis",
        "Name[fi]": "Akonadin postinvälitys",
        "Name[fr]": "Transport de courrier électronique Akonadi",
        "Name[gl]": "Transporte de correo de Akonadi",
        "Name[ia]": "Transporto de Posta d Akonadi",
        "Name[it]": "Trasporto della posta di Akonadi",
        "Name[ko]": "Akonadi 메일 전송",
        "Name[nl]": "Akonadi e-mailtransport",
        "Name[nn]": "Akonadi-e-postoverføring",
        "Name[pl]": "Serwery pocztowe Akonadi",
        "Name[pt]": "Transporte de E-mail do Akonadi",
        "Name[pt_BR]": "Transporte de e-mail do Akonadi",
        "Name[ru]": "Метод отправки Akonadi",
        "Name[sk]": "Prenos pošty Akonadi",
        "Name[sl]": "Prenos pošte Akonadi",
        "Name[sr@ijekavian]": "Транспорт поште Аконадијем",
        "Name[sr@ijekavianlatin]": "Transport pošte Akonadijem",
        "Name[sr@latin]": "Transport pošte Akonadijem",
        "Name[sr]": "Транспорт поште Аконадијем",
        "Name[sv]": "Akonadi e-postöverföring",
        "Name[tr]": "Akonadi Posta Aktarımı",
        "Name[uk]": "Надсилання пошти Akonadi",
        "Name[x-test]": "xxAkonadi Mail Transportxx",
        "Name[zh_CN]": "Akonadi 邮件传输",
        "Name[zh_TW]": "Akonadi 郵件傳輸",
        "Version": "1.0"
    }
}
070701000000A7000081A4000000000000000000000001610B832400000D7C000000000000000000000000000000000000007300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins/akonadimailtransportplugin.cpp/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "akonadimailtransportplugin.h"
#include "mailtransportplugin_akonadi_debug.h"
#include "resourcesendjob_p.h"
#include <AkonadiCore/AgentInstanceCreateJob>
#include <AkonadiCore/AgentManager>
#include <KPluginFactory>
#include <MailTransport/Transport>

using namespace Akonadi;

K_PLUGIN_CLASS_WITH_JSON(AkonadiMailTransportPlugin, "akonadimailtransport.json")

AkonadiMailTransportPlugin::AkonadiMailTransportPlugin(QObject *parent, const QList<QVariant> &)
    : MailTransport::TransportAbstractPlugin(parent)
{
    // Watch for appearing and disappearing types.
    connect(AgentManager::self(), &AgentManager::typeAdded, this, &AkonadiMailTransportPlugin::slotUpdatePluginList);
    connect(AgentManager::self(), &AgentManager::typeRemoved, this, &AkonadiMailTransportPlugin::slotUpdatePluginList);
}

AkonadiMailTransportPlugin::~AkonadiMailTransportPlugin()
{
}

void AkonadiMailTransportPlugin::slotUpdatePluginList(const Akonadi::AgentType &type)
{
    if (type.capabilities().contains(QLatin1String("MailTransport"))) {
        Q_EMIT updatePluginList();
    }
}

void AkonadiMailTransportPlugin::cleanUp(MailTransport::Transport *t)
{
    const AgentInstance instance = AgentManager::self()->instance(t->host());
    if (!instance.isValid()) {
        qCWarning(MAILTRANSPORT_AKONADI_LOG) << "Could not find resource instance for name:" << t->host();
    }
    AgentManager::self()->removeInstance(instance);
}

QVector<MailTransport::TransportAbstractPluginInfo> AkonadiMailTransportPlugin::names() const
{
    QVector<MailTransport::TransportAbstractPluginInfo> lst;

for (const AgentType &atype : AgentManager::self()->types()) {
        // TODO probably the string "MailTransport" should be #defined somewhere
        // and used like that in the resources (?)
        if (atype.capabilities().contains(QLatin1String("MailTransport"))) {
            MailTransport::TransportAbstractPluginInfo info;
            info.name = atype.name();
            info.description = atype.description();
            info.identifier = atype.identifier();
            info.isAkonadi = true;
            lst << info;
        }
    }
    return lst;
}

bool AkonadiMailTransportPlugin::configureTransport(const QString &identifier, MailTransport::Transport *transport, QWidget *parent)
{
    Q_UNUSED(identifier)
    AgentInstance instance = AgentManager::self()->instance(transport->host());
    if (!instance.isValid()) {
        qCWarning(MAILTRANSPORT_AKONADI_LOG) << "Invalid resource instance" << transport->host();
        return false;
    }
    instance.configure(parent); // Async...
    transport->save();
    return true; // No way to know here if the user cancelled or not.
}

MailTransport::TransportJob *AkonadiMailTransportPlugin::createTransportJob(MailTransport::Transport *t, const QString &identifier)
{
    Q_UNUSED(identifier)
    return new MailTransport::ResourceSendJob(t, this);
}

void AkonadiMailTransportPlugin::initializeTransport(MailTransport::Transport *t, const QString &identifier)
{
    auto cjob = new AgentInstanceCreateJob(identifier);
    if (!cjob->exec()) {
        qCWarning(MAILTRANSPORT_AKONADI_LOG) << "Failed to create agent instance of type" << identifier;
        return;
    }
    t->setHost(cjob->instance().identifier());
}

#include "akonadimailtransportplugin.moc"
070701000000A8000081A4000000000000000000000001610B832400000435000000000000000000000000000000000000007100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins/akonadimailtransportplugin.h/*
    SPDX-FileCopyrightText: 2017-2021 Laurent Montel <montel@kde.org>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <MailTransport/TransportAbstractPlugin>
#include <QVariant>
namespace Akonadi
{
class AgentType;
}

class AkonadiMailTransportPlugin : public MailTransport::TransportAbstractPlugin
{
    Q_OBJECT
public:
    explicit AkonadiMailTransportPlugin(QObject *parent = nullptr, const QList<QVariant> & = {});
    ~AkonadiMailTransportPlugin() override;

void cleanUp(MailTransport::Transport *t) override;
    MailTransport::TransportJob *createTransportJob(MailTransport::Transport *t, const QString &identifier) override;
    void initializeTransport(MailTransport::Transport *t, const QString &identifier) override;

private:
    void slotUpdatePluginList(const Akonadi::AgentType &type);
};

070701000000A9000081A4000000000000000000000001610B83240000056D000000000000000000000000000000000000006800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins/resourcesendjob.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "../messagequeuejob.h"
#include "resourcesendjob_p.h"
#include "transport.h"

#include <kmime/kmime_message.h>

#include <Akonadi/KMime/AddressAttribute>
#include <AkonadiCore/Collection>

using namespace Akonadi;
using namespace KMime;
using namespace MailTransport;

ResourceSendJob::ResourceSendJob(Transport *transport, QObject *parent)
    : TransportJob(transport, parent)
{
}

ResourceSendJob::~ResourceSendJob()
{
}

void ResourceSendJob::doStart()
{
    Message::Ptr msg = Message::Ptr(new Message);
    msg->setContent(data());
    auto job = new MessageQueueJob;
    job->setMessage(msg);
    job->transportAttribute().setTransportId(transport()->id());
    // Default dispatch mode (send now).
    // Move to default sent-mail collection.
    job->addressAttribute().setFrom(sender());
    job->addressAttribute().setTo(to());
    job->addressAttribute().setCc(cc());
    job->addressAttribute().setBcc(bcc());
    addSubjob(job);
    // Once the item is in the outbox, there is nothing more we can do.
    connect(job, &KJob::result, this, &ResourceSendJob::slotEmitResult);
    job->start();
}

void ResourceSendJob::slotEmitResult()
{
    // KCompositeJob took care of the error.
    emitResult();
}

#include "moc_resourcesendjob_p.cpp"
070701000000AA000081A4000000000000000000000001610B832400000442000000000000000000000000000000000000006800000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/plugins/resourcesendjob_p.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <transportjob.h>

#include <item.h>

namespace MailTransport
{
/**
  Mail transport job for an Akonadi resource-based transport.

This is a wrapper job that makes old applications work with resource-based
  transports.  It calls the appropriate methods in MessageQueueJob, and emits
  result() as soon as the item is placed in the outbox, since there is no way
  of monitoring the progress from here.

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class ResourceSendJob : public TransportJob
{
    Q_OBJECT
public:
    /**
      Creates an ResourceSendJob.
      @param transport The transport object to use.
      @param parent The parent object.
    */
    explicit ResourceSendJob(Transport *transport, QObject *parent = nullptr);

/**
      Destroys this job.
    */
    ~ResourceSendJob() override;

protected:
    void doStart() override;

private:
    void slotEmitResult();
};
} // namespace MailTransport

070701000000AB000081A4000000000000000000000001610B832400000CCE000000000000000000000000000000000000006400000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/sentactionattribute.cpp/*
  SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>
  SPDX-FileContributor: Tobias Koenig <tokoe@kdab.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "sentactionattribute.h"

#include <QDataStream>
#include <QSharedData>

using namespace Akonadi;
using namespace MailTransport;

class SentActionAttribute::Action::Private : public QSharedData
{
public:
    Private()
    {
    }

Private(const Private &other)
        : QSharedData(other)
    {
        mType = other.mType;
        mValue = other.mValue;
    }

Type mType = Invalid;
    QVariant mValue;
};

SentActionAttribute::Action::Action()
    : d(new Private)
{
}

SentActionAttribute::Action::Action(Type type, const QVariant &value)
    : d(new Private)
{
    d->mType = type;
    d->mValue = value;
}

SentActionAttribute::Action::Action(const Action &other)
    : d(other.d)
{
}

SentActionAttribute::Action::~Action()
{
}

SentActionAttribute::Action::Type SentActionAttribute::Action::type() const
{
    return d->mType;
}

QVariant SentActionAttribute::Action::value() const
{
    return d->mValue;
}

SentActionAttribute::Action &SentActionAttribute::Action::operator=(const Action &other)
{
    if (this != &other) {
        d = other.d;
    }

return *this;
}

bool SentActionAttribute::Action::operator==(const Action &other) const
{
    return (d->mType == other.d->mType) && (d->mValue == other.d->mValue);
}

class Q_DECL_HIDDEN SentActionAttribute::Private
{
public:
    Action::List mActions;
};

SentActionAttribute::SentActionAttribute()
    : d(new Private)
{
}

SentActionAttribute::~SentActionAttribute()
{
    delete d;
}

void SentActionAttribute::addAction(Action::Type type, const QVariant &value)
{
    d->mActions.append(Action(type, value));
}

SentActionAttribute::Action::List SentActionAttribute::actions() const
{
    return d->mActions;
}

SentActionAttribute *SentActionAttribute::clone() const
{
    auto attribute = new SentActionAttribute;
    attribute->d->mActions = d->mActions;

return attribute;
}

QByteArray SentActionAttribute::type() const
{
    static const QByteArray sType("SentActionAttribute");
    return sType;
}

QByteArray SentActionAttribute::serialized() const
{
    QVariantList list;
    list.reserve(d->mActions.count());
    for (const Action &action : std::as_const(d->mActions)) {
        QVariantMap map;
        map.insert(QString::number(action.type()), action.value());

list << QVariant(map);
    }

QByteArray data;
    QDataStream stream(&data, QIODevice::WriteOnly);
    stream.setVersion(QDataStream::Qt_4_6);
    stream << list;

return data;
}

void SentActionAttribute::deserialize(const QByteArray &data)
{
    d->mActions.clear();

QDataStream stream(data);
    stream.setVersion(QDataStream::Qt_4_6);

QVariantList list;
    stream >> list;

for (const QVariant &variant : std::as_const(list)) {
        const QVariantMap map = variant.toMap();
        QMap<QString, QVariant>::const_iterator it = map.cbegin();
        const QMap<QString, QVariant>::const_iterator itEnd = map.cend();
        for (; it != itEnd; ++it) {
            d->mActions << Action(static_cast<Action::Type>(it.key().toInt()), it.value());
        }
    }
}
070701000000AC000081A4000000000000000000000001610B832400000C6A000000000000000000000000000000000000006200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/sentactionattribute.h/*
  SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.net>
  SPDX-FileContributor: Tobias Koenig <tokoe@kdab.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <QSharedDataPointer>
#include <QVariant>
#include <QVector>
#include <attribute.h>

namespace MailTransport
{
/**
 * @short An Attribute that stores the action to execute after sending.
 *
 * This attribute stores the action that will be executed by the mail dispatcher
 * after a mail has successfully be sent.
 *
 * @author Tobias Koenig <tokoe@kdab.com>
 * @since 4.6
 */
class MAILTRANSPORTAKONADI_EXPORT SentActionAttribute : public Akonadi::Attribute
{
public:
    /**
     * @short A sent action.
     */
    class MAILTRANSPORTAKONADI_EXPORT Action
    {
    public:
        /**
         * Describes the action type.
         */
        enum Type {
            Invalid, ///< An invalid action.
            MarkAsReplied, ///< The message will be marked as replied.
            MarkAsForwarded ///< The message will be marked as forwarded.
        };

/**
         * Describes a list of sent actions.
         */
        using List = QVector<Action>;

/**
         * Creates a new invalid action.
         */
        Action();

/**
         * Creates a new action.
         *
         * @param type The type of action that shall be executed.
         * @param value The action specific argument.
         */
        Action(Type type, const QVariant &value);

/**
         * Creates an action from an @p other action.
         */
        Action(const Action &other);

/**
         * Destroys the action.
         */
        ~Action();

/**
         * Returns the type of the action.
         */
        Type type() const;

/**
         * Returns the argument value of the action.
         */
        QVariant value() const;

/**
         * @internal
         */
        Action &operator=(const Action &other);

/**
         * @internal
         */
        bool operator==(const Action &other) const;

private:
        //@cond PRIVATE
        class Private;
        QSharedDataPointer<Private> d;
        //@endcond
    };

/**
     * Creates a new sent action attribute.
     */
    explicit SentActionAttribute();

/**
     * Destroys the sent action attribute.
     */
    ~SentActionAttribute() override;

/**
     * Adds a new action to the attribute.
     *
     * @param type The type of the action that shall be executed.
     * @param value The action specific argument.
     */
    void addAction(Action::Type type, const QVariant &value);

/**
     * Returns the list of actions.
     */
    Action::List actions() const;

/* reimpl */
    SentActionAttribute *clone() const override;
    QByteArray type() const override;
    QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond
};
}
Q_DECLARE_TYPEINFO(MailTransport::SentActionAttribute::Action, Q_MOVABLE_TYPE);

070701000000AD000081A4000000000000000000000001610B832400000BE7000000000000000000000000000000000000006700000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/sentbehaviourattribute.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "sentbehaviourattribute.h"

using namespace Akonadi;
using namespace MailTransport;

class Q_DECL_HIDDEN SentBehaviourAttribute::Private
{
public:
    Private()
    {
    }

SentBehaviourAttribute::SentBehaviour mBehaviour = SentBehaviourAttribute::MoveToDefaultSentCollection;
    Akonadi::Collection mMoveToCollection;
    bool mSilent = false;
};

SentBehaviourAttribute::SentBehaviourAttribute(SentBehaviour beh, const Collection &moveToCollection, bool sendSilently)
    : d(new Private)
{
    d->mBehaviour = beh;
    d->mMoveToCollection = moveToCollection;
    d->mSilent = sendSilently;
}

SentBehaviourAttribute::~SentBehaviourAttribute()
{
    delete d;
}

SentBehaviourAttribute *SentBehaviourAttribute::clone() const
{
    return new SentBehaviourAttribute(d->mBehaviour, d->mMoveToCollection, d->mSilent);
}

QByteArray SentBehaviourAttribute::type() const
{
    static const QByteArray sType("SentBehaviourAttribute");
    return sType;
}

QByteArray SentBehaviourAttribute::serialized() const
{
    QByteArray out;

switch (d->mBehaviour) {
    case Delete:
        out = QByteArrayLiteral("delete");
        break;
    case MoveToCollection:
        out = QByteArrayLiteral("moveTo") + QByteArray::number(d->mMoveToCollection.id());
        break;
    case MoveToDefaultSentCollection:
        out = QByteArrayLiteral("moveToDefault");
        break;
    default:
        Q_ASSERT(false);
        return QByteArray();
    }

if (d->mSilent) {
        out += QByteArrayLiteral(",silent");
    }

return out;
}

void SentBehaviourAttribute::deserialize(const QByteArray &data)
{
    const QByteArrayList in = data.split(',');
    Q_ASSERT(!in.isEmpty());

const QByteArray attr0 = in[0];
    d->mMoveToCollection = Akonadi::Collection(-1);
    if (attr0 == "delete") {
        d->mBehaviour = Delete;
    } else if (attr0 == "moveToDefault") {
        d->mBehaviour = MoveToDefaultSentCollection;
    } else if (attr0.startsWith(QByteArrayLiteral("moveTo"))) {
        d->mBehaviour = MoveToCollection;
        d->mMoveToCollection = Akonadi::Collection(attr0.mid(6).toLongLong());
        // NOTE: 6 is the strlen of "moveTo".
    } else {
        Q_ASSERT(false);
    }

if (in.size() == 2 && in[1] == "silent") {
        d->mSilent = true;
    }
}

SentBehaviourAttribute::SentBehaviour SentBehaviourAttribute::sentBehaviour() const
{
    return d->mBehaviour;
}

void SentBehaviourAttribute::setSentBehaviour(SentBehaviour beh)
{
    d->mBehaviour = beh;
}

Collection SentBehaviourAttribute::moveToCollection() const
{
    return d->mMoveToCollection;
}

void SentBehaviourAttribute::setMoveToCollection(const Collection &moveToCollection)
{
    d->mMoveToCollection = moveToCollection;
}

bool SentBehaviourAttribute::sendSilently() const
{
    return d->mSilent;
}

void SentBehaviourAttribute::setSendSilently(bool sendSilently)
{
    d->mSilent = sendSilently;
}
070701000000AE000081A4000000000000000000000001610B832400000B2C000000000000000000000000000000000000006500000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/sentbehaviourattribute.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <attribute.h>
#include <collection.h>

namespace MailTransport
{
/**
  Attribute determining what will happen to a message after it is sent.  The
  message can be deleted from the Outbox, moved to the default sent-mail
  collection, or moved to a custom collection.

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORTAKONADI_EXPORT SentBehaviourAttribute : public Akonadi::Attribute
{
public:
    /**
      What to do with the item in the outbox after it has been sent successfully.
    */
    enum SentBehaviour {
        Delete, ///< Delete the item from the outbox.
        MoveToCollection, ///< Move the item to a custom collection.
        MoveToDefaultSentCollection ///< Move the item to the default sent-mail collection.
    };

/**
      Creates a new SentBehaviourAttribute.
    */
    explicit SentBehaviourAttribute(SentBehaviour beh = MoveToDefaultSentCollection,
                                    const Akonadi::Collection &moveToCollection = Akonadi::Collection(-1),
                                    bool sendSilently = false);

/**
      Destroys the SentBehaviourAttribute.
    */
    ~SentBehaviourAttribute() override;

/* reimpl */
    SentBehaviourAttribute *clone() const override;
    QByteArray type() const override;
    QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

/**
      Returns the sent-behaviour of the message.
      @see SentBehaviour.
    */
    SentBehaviour sentBehaviour() const;

/**
      Sets the sent-behaviour of the message.
      @param beh the sent-behaviour to set
      @see SentBehaviour.
    */
    void setSentBehaviour(SentBehaviour beh);

/**
      Returns the collection to which the item should be moved after it is sent.
      Only valid if sentBehaviour() is MoveToCollection.
    */
    Akonadi::Collection moveToCollection() const;

/**
      Sets the collection to which the item should be moved after it is sent.
      Make sure you set the SentBehaviour to MoveToCollection first.
      @param moveToCollection target collection for "move to" operation
      @see setSentBehaviour.
    */
    void setMoveToCollection(const Akonadi::Collection &moveToCollection);

/**
     * Returns whether a notification should be shown after the email is sent.
     * @since 5.4
     */
    bool sendSilently() const;

/**
     * Set whether a notification should be shown after the email is sent.
     *
     * Default is false.
     *
     * @since 5.4
     */
    void setSendSilently(bool sendSilently);

private:
    class Private;
    Private *const d;
};
} // namespace MailTransport

070701000000AF000041ED000000000000000000000002610B832400000000000000000000000000000000000000000000005200000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests070701000000B0000081A4000000000000000000000001610B83240000036A000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/CMakeLists.txt
include(ECMMarkAsTest)

find_package(KF5TextWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)

set(queuer_srcs queuer.cpp)
add_executable(queuer ${queuer_srcs})
ecm_mark_as_test(queuer)
target_link_libraries(queuer KF5MailTransportAkonadi Qt::Widgets KF5::I18n KF5::ConfigGui KF5::TextWidgets)

set( sendqueued_srcs sendqueued.cpp )
add_executable( sendqueued ${sendqueued_srcs} )
ecm_mark_as_test(sendqueued)
target_link_libraries( sendqueued KF5MailTransportAkonadi  KF5::AkonadiMime Qt::Widgets)

set( clearerror_srcs clearerror.cpp )
add_executable( clearerror ${clearerror_srcs} )
ecm_mark_as_test(clearerror)
target_link_libraries( clearerror KF5MailTransportAkonadi  KF5::AkonadiMime Qt::Widgets)

set( abort_srcs abort.cpp )
add_executable( abort ${abort_srcs} )
ecm_mark_as_test(abort)
target_link_libraries( abort KF5MailTransportAkonadi KF5::AkonadiCore Qt::Widgets)

070701000000B1000081A4000000000000000000000001610B8324000003D1000000000000000000000000000000000000005C00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/abort.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "abort.h"

#include <QTimer>

#include <QApplication>
#include <QDebug>

#include <control.h>

#include <kmailtransportakonadi/dispatcherinterface.h>

using namespace Akonadi;
using namespace MailTransport;

Runner::Runner()
{
    Control::start();

QTimer::singleShot(0, this, &Runner::sendAbort);
}

void Runner::sendAbort()
{
    const AgentInstance mda = DispatcherInterface().dispatcherInstance();
    if (!mda.isValid()) {
        qDebug() << "Invalid instance; waiting.";
        QTimer::singleShot(1000, this, &Runner::sendAbort);
        return;
    }

mda.abortCurrentTask();
    qDebug() << "Told the MDA to abort.";
    QApplication::exit(0);
}

int main(int argc, char **argv)
{
    QApplication::setApplicationName(QStringLiteral("Abort"));
    QApplication app(argc, argv);

new Runner();
    return app.exec();
}
070701000000B2000081A4000000000000000000000001610B832400000168000000000000000000000000000000000000005A00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/abort.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>

/**
  This class uses the DispatcherInterface to send an abort() signal th the MDA.
*/
class Runner : public QObject
{
    Q_OBJECT

public:
    Runner();

private Q_SLOTS:
    void sendAbort();
};

070701000000B3000081A4000000000000000000000001610B8324000003D4000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/clearerror.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "clearerror.h"

#include <QApplication>

#include <collection.h>
#include <control.h>
#include <filteractionjob_p.h>
#include <kmailtransportakonadi/dispatcherinterface.h>
#include <specialmailcollections.h>
#include <specialmailcollectionsrequestjob.h>

using namespace Akonadi;
using namespace MailTransport;

Runner::Runner()
{
    Control::start();

auto rjob = new SpecialMailCollectionsRequestJob(this);
    rjob->requestDefaultCollection(SpecialMailCollections::Outbox);
    connect(rjob, &SpecialMailCollectionsRequestJob::result, this, &Runner::checkFolders);
    rjob->start();
}

void Runner::checkFolders()
{
    DispatcherInterface().retryDispatching();
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("clearerror"));

new Runner();
    return app.exec();
}
070701000000B4000081A4000000000000000000000001610B832400000185000000000000000000000000000000000000005F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/clearerror.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>

/**
  This class uses the ClearErrorAction to mark all failed messages in the
  outbox for immediate sending.
*/
class Runner : public QObject
{
    Q_OBJECT

public:
    Runner();

private Q_SLOTS:
    void checkFolders();
};

070701000000B5000081A4000000000000000000000001610B8324000015A5000000000000000000000000000000000000005D00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/queuer.cpp/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "queuer.h"

#include <QDateTime>
#include <QPointer>
#include <QPushButton>

#include <KTextEdit>
#include <QApplication>
#include <QDateTimeEdit>
#include <QLineEdit>
#include <QVBoxLayout>
#include <control.h>

#include <QDebug>
#include <QDialog>
#include <QDialogButtonBox>

#include <kmailtransportakonadi/dispatchmodeattribute.h>
#include <kmailtransportakonadi/messagequeuejob.h>
#include <transport.h>
#include <transportmanager.h>

using namespace KMime;
using namespace MailTransport;

MessageQueuer::MessageQueuer()
{
    if (!Akonadi::Control::start()) {
        qFatal("Could not start Akonadi server.");
    }
    auto vbox = new QVBoxLayout(this);
    vbox->setContentsMargins(0, 0, 0, 0);

mComboBox = new TransportComboBox(this);
    mComboBox->setEditable(true);
    vbox->addWidget(mComboBox);
    mSenderEdit = new QLineEdit(this);
    mSenderEdit->setPlaceholderText(QStringLiteral("Sender"));
    vbox->addWidget(mSenderEdit);
    mToEdit = new QLineEdit(this);
    mToEdit->setText(QStringLiteral("idanoka@gmail.com"));
    vbox->addWidget(mToEdit);
    mToEdit->setPlaceholderText(QStringLiteral("To"));
    mCcEdit = new QLineEdit(this);
    vbox->addWidget(mCcEdit);
    mCcEdit->setPlaceholderText(QStringLiteral("Cc"));
    mBccEdit = new QLineEdit(this);
    mBccEdit->setPlaceholderText(QStringLiteral("Bcc"));
    vbox->addWidget(mBccEdit);
    mMailEdit = new KTextEdit(this);
    mMailEdit->setText(QStringLiteral("test from queuer!"));
    mMailEdit->setAcceptRichText(false);
    mMailEdit->setLineWrapMode(QTextEdit::NoWrap);
    vbox->addWidget(mMailEdit);
    auto b = new QPushButton(QStringLiteral("&Send Now"), this);
    vbox->addWidget(b);
    connect(b, &QPushButton::clicked, this, &MessageQueuer::sendNowClicked);
    b = new QPushButton(QStringLiteral("Send &Queued"), this);
    vbox->addWidget(b);
    connect(b, &QPushButton::clicked, this, &MessageQueuer::sendQueuedClicked);
    b = new QPushButton(QStringLiteral("Send on &Date..."), this);
    vbox->addWidget(b);
    connect(b, &QPushButton::clicked, this, &MessageQueuer::sendOnDateClicked);
}

void MessageQueuer::sendNowClicked()
{
    MessageQueueJob *qjob = createQueueJob();
    qDebug() << "DispatchMode default (Automatic).";
    qjob->start();
}

void MessageQueuer::sendQueuedClicked()
{
    MessageQueueJob *qjob = createQueueJob();
    qDebug() << "DispatchMode Manual.";
    qjob->dispatchModeAttribute().setDispatchMode(DispatchModeAttribute::Manual);
    qjob->start();
}

void MessageQueuer::sendOnDateClicked()
{
    QPointer<QDialog> dialog = new QDialog(this);
    auto layout = new QVBoxLayout(dialog);
    auto dt = new QDateTimeEdit(dialog);
    dt->setDateTime(QDateTime::currentDateTime());
    dt->setDisplayFormat(QStringLiteral("hh:mm:ss"));
    layout->addWidget(dt);
    auto box = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, dialog);
    connect(box, &QDialogButtonBox::accepted, dialog.data(), &QDialog::accept);
    connect(box, &QDialogButtonBox::rejected, dialog.data(), &QDialog::reject);
    layout->addWidget(box);
    if (!dialog->exec() || !dialog) {
        return;
    }
    qDebug() << "DispatchMode AfterDueDate" << dt->dateTime();
    MessageQueueJob *qjob = createQueueJob();
    qjob->dispatchModeAttribute().setDispatchMode(DispatchModeAttribute::Automatic);
    qjob->dispatchModeAttribute().setSendAfter(dt->dateTime());
    qjob->start();
    delete dialog;
}

MessageQueueJob *MessageQueuer::createQueueJob()
{
    Message::Ptr msg = Message::Ptr(new Message);
    // No headers; need a '\n' to separate headers from body.
    // TODO: use real headers
    msg->setContent(QByteArray("\n") + mMailEdit->document()->toPlainText().toLatin1());
    qDebug() << "msg:" << msg->encodedContent(true);

auto job = new MessageQueueJob();
    job->setMessage(msg);
    job->transportAttribute().setTransportId(mComboBox->currentTransportId());
    // default dispatch mode
    // default sent-mail collection
    job->addressAttribute().setFrom(mSenderEdit->text());
    job->addressAttribute().setTo(mToEdit->text().isEmpty() ? QStringList() : mToEdit->text().split(QLatin1Char(',')));
    job->addressAttribute().setCc(mCcEdit->text().isEmpty() ? QStringList() : mCcEdit->text().split(QLatin1Char(',')));
    job->addressAttribute().setBcc(mBccEdit->text().isEmpty() ? QStringList() : mBccEdit->text().split(QLatin1Char(',')));

connect(job, &MessageQueueJob::result, this, &MessageQueuer::jobResult);
    connect(job, SIGNAL(percent(KJob *, ulong)), SLOT(jobPercent(KJob *, ulong)));
    connect(job, &KJob::infoMessage, this, &MessageQueuer::jobInfoMessage);

return job;
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("messagequeuer"));

auto t = new MessageQueuer();
    t->show();
    app.exec();
    delete t;
}

void MessageQueuer::jobResult(KJob *job)
{
    if (job->error()) {
        qDebug() << "job error:" << job->errorText();
    } else {
        qDebug() << "job success.";
    }
}

void MessageQueuer::jobPercent(KJob *job, unsigned long percent)
{
    Q_UNUSED(job)
    qDebug() << percent << "%";
}

void MessageQueuer::jobInfoMessage(KJob *job, const QString &info, const QString &info2)
{
    Q_UNUSED(job)
    qDebug() << info;
    qDebug() << info2;
}
070701000000B6000081A4000000000000000000000001610B832400000433000000000000000000000000000000000000005B00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/queuer.h/*
    SPDX-FileCopyrightText: 2006-2007 Volker Krause <vkrause@kde.org>
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QWidget>
#include <widgets/transportcombobox.h>

class KJob;
class QLineEdit;
class KTextEdit;

namespace MailTransport
{
class MessageQueueJob;
}

/**
  Mostly stolen from transportmgr.{h,cpp}
*/
class MessageQueuer : public QWidget
{
    Q_OBJECT

public:
    MessageQueuer();

private Q_SLOTS:
    void sendNowClicked();
    void sendQueuedClicked();
    void sendOnDateClicked();
    void jobResult(KJob *job);
    void jobPercent(KJob *job, unsigned long percent);
    void jobInfoMessage(KJob *job, const QString &info, const QString &info2);

MailTransport::MessageQueueJob *createQueueJob();
};

070701000000B7000081A4000000000000000000000001610B8324000003D4000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/sendqueued.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "sendqueued.h"

#include <QApplication>

using namespace Akonadi;
using namespace MailTransport;

Runner::Runner()
{
    Control::start();

void Runner::checkFolders()
{
    DispatcherInterface().dispatchManually();
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    app.setApplicationName(QStringLiteral("sendqueued"));

new Runner();
    return app.exec();
}
070701000000B8000081A4000000000000000000000001610B832400000185000000000000000000000000000000000000005F00000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/tests/sendqueued.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <QObject>

/**
  This class uses the SendQueuedAction to mark all queued messages in the
  outbox for immediate sending.
*/
class Runner : public QObject
{
    Q_OBJECT

public:
    Runner();

private Q_SLOTS:
    void checkFolders();
};

070701000000B9000081A4000000000000000000000001610B83240000047E000000000000000000000000000000000000006300000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/transportattribute.cpp/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "transportattribute.h"

#include "transportmanager.h"

using namespace Akonadi;
using namespace MailTransport;

class Q_DECL_HIDDEN TransportAttribute::Private
{
public:
    int mId = -1;
};

TransportAttribute::TransportAttribute(int id)
    : d(new Private)
{
    d->mId = id;
}

TransportAttribute::~TransportAttribute()
{
    delete d;
}

TransportAttribute *TransportAttribute::clone() const
{
    return new TransportAttribute(d->mId);
}

QByteArray TransportAttribute::type() const
{
    static const QByteArray sType("TransportAttribute");
    return sType;
}

QByteArray TransportAttribute::serialized() const
{
    return QByteArray::number(d->mId);
}

void TransportAttribute::deserialize(const QByteArray &data)
{
    d->mId = data.toInt();
}

int TransportAttribute::transportId() const
{
    return d->mId;
}

Transport *TransportAttribute::transport() const
{
    return TransportManager::self()->transportById(d->mId, false);
}

void TransportAttribute::setTransportId(int id)
{
    d->mId = id;
}
070701000000BA000081A4000000000000000000000001610B8324000005AA000000000000000000000000000000000000006100000000kmailtransport-VERSIONgit.20210805T082020~47b7f31/src/kmailtransportakonadi/transportattribute.h/*
    SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>

SPDX-License-Identifier: LGPL-2.0-or-later
*/

#pragma once

#include <mailtransportakonadi_export.h>

#include <attribute.h>

namespace MailTransport
{
class Transport;

/**
  Attribute determining which transport to use for sending a message.

@see mailtransport
  @see TransportManager.

@author Constantin Berzan <exit3219@gmail.com>
  @since 4.4
*/
class MAILTRANSPORTAKONADI_EXPORT TransportAttribute : public Akonadi::Attribute
{
public:
    /**
      Creates a new TransportAttribute.
    */
    explicit TransportAttribute(int id = -1);

/**
      Destroys this TransportAttribute.
    */
    ~TransportAttribute() override;

/* reimpl */
    TransportAttribute *clone() const override;
    QByteArray type() const override;
    QByteArray serialized() const override;
    void deserialize(const QByteArray &data) override;

/**
      Returns the transport id to use for sending this message.
      @see TransportManager.
    */
    Q_REQUIRED_RESULT int transportId() const;

/**
      Returns the transport object corresponding to the transport id contained
      in this attribute.
      @see Transport.
    */
    Transport *transport() const;
    /**
      Sets the transport id to use for sending this message.
    */
    void setTransportId(int id);

private:
    class Private;
    Private *const d;
};
} // namespace MailTransport

07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!862 blocks

Places

File _service:obs_scm:kmailtransport-VERSIONgit.20210805T082020~47b7f31.obscpio of Package kmailtransport (Revision ffa6278ddfa3a368c47e3aa59138c490)

Places