File _service:obs_scm:kimap-VERSIONgit.20200529T1727... of Package kimap

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:kimap-VERSIONgit.20200529T172740~a5402d2.obscpio of Package kimap (Revision 211bc10074386a65651730ca284f5020)

Currently displaying revision 211bc10074386a65651730ca284f5020 , Show latest

07070100000000000081A40000000200000002000000015ED129EC000004BE000000000000000000000000000000000000003800000000kimap-VERSIONgit.20200529T172740~a5402d2/.gitlab-ci.ymlinclude:
  - 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: debian:testing
  only:
    - merge_requests
  before_script:
    - echo 'deb-src http://deb.debian.org/debian unstable main' >> /etc/apt/sources.list
    - apt-get update
    - apt-get install --yes --no-install-recommends ninja-build clazy clang clang-tidy python python3-yaml libkf5crash-dev libkf5purpose-dev libegl-dev jq

script:
    - srcdir=`pwd` && mkdir -p /tmp/pim_build && cd /tmp/pim_build && CC=clang CXX=clazy CXXFLAGS="-Werror -Wno-deprecated-declarations" cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -G Ninja $srcdir && cat compile_commands.json | jq  '[.[] | select(.file | contains("'"$srcdir"'"))]' > compile_commands.aux.json && cat compile_commands.aux.json | jq  '[.[] | select(.file | contains("/synctex/")| not)]' > compile_commands.json && cp "$srcdir/.clang-tidy" .
    - CLAZY_CHECKS="level0,level1,level2,no-ctor-missing-parent-argument,isempty-vs-count,qhash-with-char-pointer-key,raw-environment-function,qproperty-type-mismatch" ninja
    - run-clang-tidy
07070100000001000081A40000000200000002000000015ED129EC0000000D000000000000000000000000000000000000003000000000kimap-VERSIONgit.20200529T172740~a5402d2/.krazySKIP /tests/
07070100000002000081A40000000200000002000000015ED129EC00000A44000000000000000000000000000000000000003800000000kimap-VERSIONgit.20200529T172740~a5402d2/CMakeLists.txtcmake_minimum_required(VERSION 3.5)
set(PIM_VERSION "5.14.40")

project(KIMAP VERSION ${PIM_VERSION})

set(CMAKE_CXX_STANDARD 14)

# ECM setup
set(KF5_MIN_VERSION "5.70.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(ECMQtDeclareLoggingCategory)

set(QT_REQUIRED_VERSION "5.13.0")

set(KIMAP_LIB_VERSION ${PIM_VERSION})
set(KMIME_LIBS_VERSION "5.14.40")
ecm_setup_version(PROJECT VARIABLE_PREFIX KIMAP
                        VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kimap_version.h"
                        PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5IMAPConfigVersion.cmake"
                        SOVERSION 5
)

########### Find packages ###########
find_package(Sasl2)
set_package_properties(Sasl2 PROPERTIES TYPE REQUIRED)

find_package(KF5CoreAddons ${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_LIBS_VERSION} CONFIG REQUIRED)

########### CMake Config Files ###########
set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5IMAP")
add_definitions(-DTRANSLATION_DOMAIN=\"libkimap5\")

if (EXISTS "${CMAKE_SOURCE_DIR}/.git")
   add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050e00)
   add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054700)
endif()
add_definitions(-DQT_NO_SIGNALS_SLOTS_KEYWORDS)
add_definitions(-DQT_NO_EMIT)

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

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

if(BUILD_TESTING)
    find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Test)
    add_subdirectory(autotests)
    add_subdirectory(tests)
endif()

########### Install Files ###########
install(FILES
  "${CMAKE_CURRENT_BINARY_DIR}/KF5IMAPConfig.cmake"
  "${CMAKE_CURRENT_BINARY_DIR}/KF5IMAPConfigVersion.cmake"
  DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
  COMPONENT Devel
)

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

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

feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
07070100000003000081A40000000200000002000000015ED129EC00004761000000000000000000000000000000000000003100000000kimap-VERSIONgit.20200529T172740~a5402d2/COPYINGNOTE! The GPL below is copyrighted by the Free Software Foundation, but
the instance of code that it refers to (the kde programs) are copyrighted
by the authors who actually wrote it.

---------------------------------------------------------------------------
			
		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.
               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.

Preamble

The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, 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 software, or if you modify it.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, 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 redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and
modification follow.

GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

1. You may copy and distribute verbatim copies of the Program's
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 give any other recipients of the Program a copy of this License
along with the Program.

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 Program or any portion
of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
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 Program, 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 Program.

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

3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

a) 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; or,

b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, 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 executable.  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.

If distribution of executable or 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 counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program 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.

5. 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 Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program 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.

7. 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 Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program 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 Program.

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.

8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program 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.

9. The Free Software Foundation may publish revised and/or new versions
of the 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 Program
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 Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, 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

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

12. 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 PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), 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 Programs

If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program.  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 program's name and a brief idea of what it does.>
    Copyright (C) 19yy  <name of author>

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

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
    along with this program; 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.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19yy name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

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

Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

<signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.
07070100000004000081A40000000200000002000000015ED129EC0000679F000000000000000000000000000000000000003500000000kimap-VERSIONgit.20200529T172740~a5402d2/COPYING.LIB
                  GNU LESSER GENERAL PUBLIC LICENSE
                       Version 2.1, February 1999

Copyright (C) 1991, 1999 Free Software Foundation, Inc.
	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 Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

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 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.

GNU LESSER GENERAL PUBLIC LICENSE
   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.

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.

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 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.

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

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 with
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 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.

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 a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

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.

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
    Lesser General Public License for more details.

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 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!

07070100000005000081A40000000200000002000000015ED129EC00000116000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/KF5IMAPConfig.cmake.in@PACKAGE_INIT@

set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_MODULE_PATH})
include(CMakeFindDependencyMacro)
find_dependency(KF5CoreAddons "@KF5_MIN_VERSION@")
find_dependency(KF5Mime "@KMIME_LIBS_VERSION@")

include("${CMAKE_CURRENT_LIST_DIR}/KF5IMAPTargets.cmake")
07070100000006000081A40000000200000002000000015ED129EC0000024D000000000000000000000000000000000000003300000000kimap-VERSIONgit.20200529T172740~a5402d2/README.md# KIMAP #

This library provides a job-based API for interacting with an IMAP4rev1 server.
It manages connections, encryption and parameter quoting and encoding, but
otherwise provides quite a low-level interface to the protocol.  This library
does not implement an IMAP client; it merely makes it easier to do so.

Users should be familiar with [RFC 3501](https://tools.ietf.org/html/rfc3501 "IMAP 4rev1")
as well as [other related RFCs](https://www.iana.org/assignments/imap4-capabilities)
although the library hides some of the nastier details like the encoding and quoting of
strings.
07070100000007000041ED0000000200000002000000035ED129EC00000000000000000000000000000000000000000000003300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests07070100000008000081A40000000200000002000000015ED129EC00000453000000000000000000000000000000000000004200000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/CMakeLists.txtkde_enable_exceptions()

include(ECMMarkAsTest)

find_package(Qt5Test CONFIG REQUIRED)

add_subdirectory(kimaptest)

macro(KIMAP_UNIT_TESTS)
  foreach(_testname ${ARGN})
    add_executable(${_testname} ${_testname}.cpp)
    add_test(NAME ${_testname} COMMAND ${_testname})
    ecm_mark_as_test(${_testname})
    target_link_libraries(${_testname} KF5IMAP Qt5::Test kimaptest Qt5::Network)
    set_target_properties(${_testname} PROPERTIES COMPILE_FLAGS -DTEST_DATA="\\"${CMAKE_CURRENT_SOURCE_DIR}\\"")
    set_tests_properties(${_testname} PROPERTIES RUN_SERIAL TRUE)
  endforeach()
endmacro()

########### automated tests ###############

KIMAP_UNIT_TESTS(
  fakeservertest
  testrfccodecs
  testsession
  loginjobtest
  logoutjobtest
  capabilitiesjobtest
  selectjobtest
  createjobtest
  deletejobtest
  expungejobtest
  fetchjobtest
  renamejobtest
  subscribejobtest
  unsubscribejobtest
  listjobtest
  storejobtest
  imapsettest
  idjobtest
  idlejobtest
  quotarootjobtest
  searchjobtest
  getmetadatajobtest
  streamparsertest
  setmetadatajobtest
  appendjobtest
  statusjobtest
  movejobtest
)
07070100000009000081A40000000200000002000000015ED129EC00001006000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/appendjobtest.cpp/*
   Copyright (C) 2013 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/appendjob.h"

#include <QTest>
#include <QDateTime>

class AppendJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testAppend_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QList<QByteArray> >("flags");
        QTest::addColumn<QDateTime>("internaldate");
        QTest::addColumn<QByteArray>("content");
        QTest::addColumn<qint64>("uid");

QList<QByteArray> flags;
        flags << QByteArray("\\Seen");
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 APPEND \"INBOX\" (\\Seen) {7}\r\ncontent"
                     << "S: A000001 OK APPEND completed. [ APPENDUID 492 2671 ]";
            QTest::newRow("good") << "INBOX" << scenario << flags << QDateTime() << QByteArray("content") << qint64(2671);
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 APPEND \"INBOX\" (\\Seen) \"26-Feb-2014 12:38:00 +0000\" {7}\r\ncontent"
                     << "S: A000001 OK APPEND completed. [ APPENDUID 493 2672 ]";
            QTest::newRow("good, with internalDate set") << "INBOX" << scenario << flags << QDateTime::fromString(QStringLiteral("2014-02-26T12:38:00Z"), Qt::ISODate) << QByteArray("content") << qint64(2672);
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 APPEND \"INBOX\" (\\Seen) {7}\r\ncontent"
                     << "S: BYE"
                     << "X" ;
            QTest::newRow("bad") << "INBOX" << scenario << flags << QDateTime() << QByteArray("content") << qint64(0);
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 APPEND \"INBOX\" (\\Seen) {7}\r\ncontent"
                     << "S: "
                     << "X" ;
            QTest::newRow("Don't crash on empty response") << "INBOX" << scenario << flags << QDateTime() << QByteArray("content") << qint64(0);
        }
    }

void testAppend()
    {
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QList<QByteArray>, flags);
        QFETCH(QDateTime, internaldate);
        QFETCH(QByteArray, content);
        QFETCH(qint64, uid);

FakeServer fakeServer;
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();
        KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::AppendJob *job = new KIMAP::AppendJob(&session);
        job->setContent(content);
        job->setFlags(flags);
        job->setInternalDate(internaldate);
        job->setMailBox(mailbox);
        const bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on connection abort", Continue);
        QEXPECT_FAIL("Don't crash on empty response" , "Expected failure on connection abort", Continue);
        QVERIFY(result);
        QCOMPARE(job->uid(), uid);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(AppendJobTest)

#include "appendjobtest.moc"
0707010000000A000081A40000000200000002000000015ED129EC00000C81000000000000000000000000000000000000004B00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/capabilitiesjobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/capabilitiesjob.h"

#include <QTest>

class CapabilitiesJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testCapabilities_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QStringList>("capabilities");
        QList<QByteArray> scenario;
        scenario << "S: * PREAUTH"
                 << "C: A000001 CAPABILITY"
                 << "S: * CAPABILITY IMAP4rev1 STARTTLS AUTH=GSSAPI"
                 << "S: A000001 OK CAPABILITY completed";

QStringList capabilities;
        capabilities << QStringLiteral("IMAP4REV1") << QStringLiteral("STARTTLS") <<  QStringLiteral("AUTH=GSSAPI");
        QTest::newRow("good") << scenario << capabilities;

scenario.clear();
        capabilities.clear();
        scenario << "S: * PREAUTH"
                 << "C: A000001 CAPABILITY"
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << scenario << capabilities;

scenario.clear();
        capabilities.clear();
        scenario << "S: * PREAUTH"
                 << "C: A000001 CAPABILITY"
                 << "S: * CAPABILITY IMAP4rev1 STARTTLS AUTH=PLAIN"
                 << "S: * some response"
                 << "S: A000001 OK CAPABILITY completed";

capabilities << QStringLiteral("IMAP4REV1") << QStringLiteral("STARTTLS") <<  QStringLiteral("AUTH=PLAIN");
        QTest::newRow("extra-untagged") << scenario << capabilities;
    }

void testCapabilities()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QStringList, capabilities);

FakeServer fakeServer;
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();
        KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::CapabilitiesJob *job = new KIMAP::CapabilitiesJob(&session);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QVERIFY(result);
        if (result) {
            QCOMPARE(job->capabilities(), capabilities);
        }
        fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(CapabilitiesJobTest)

#include "capabilitiesjobtest.moc"
0707010000000B000081A40000000200000002000000015ED129EC00000ACC000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/createjobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/createjob.h"

#include <QTest>

class CreateJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testCreate_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 CREATE \"INBOX\""
                 << "S: A000001 OK CREATE completed";
        QTest::newRow("good") << "INBOX" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 CREATE \"INBOX-FAIL-BAD\""
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << "INBOX-FAIL-BAD" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 CREATE \"INBOX-FAIL-NO\""
                 << "S: A000001 NO create failure";
        QTest::newRow("no") << "INBOX-FAIL-NO" << scenario;
    }

void testCreate()
    {
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, scenario);

FakeServer fakeServer;
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();
        KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::CreateJob *job = new KIMAP::CreateJob(&session);
        job->setMailBox(mailbox);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO response", Continue);
        QVERIFY(result);
        if (result) {
            QCOMPARE(job->mailBox(), mailbox);
        }

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(CreateJobTest)

#include "createjobtest.moc"
0707010000000C000081A40000000200000002000000015ED129EC00000BB1000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/deletejobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/deletejob.h"

#include <QTest>

class DeleteJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testDelete_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 DELETE \"foo\""
                 << "S: A000001 OK DELETE completed";
        QTest::newRow("good") << "foo" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 DELETE \"foo-BAD\""
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << "foo-BAD" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 DELETE \"foo\""
                 << "S: A000001 Name \"foo\" has inferior hierarchical names";
        QTest::newRow("no") << "foo" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 DELETE \"foo/bar\""
                 << "S: A000001 OK DELETE completed";
        QTest::newRow("hierarchical") << "foo/bar" << scenario;
    }

void testDelete()
    {
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::DeleteJob *job = new KIMAP::DeleteJob(&session);
        job->setMailBox(mailbox);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO response", Continue);
        QVERIFY(result);
        if (result) {
            QCOMPARE(job->mailBox(), mailbox);
        }

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(DeleteJobTest)

#include "deletejobtest.moc"
0707010000000D000081A40000000200000002000000015ED129EC00000AB6000000000000000000000000000000000000004600000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/expungejobtest.cpp/*
   Copyright (C) 2016 Daniel Vrátil <dvratil@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/expungejob.h"

#include <QTest>

class ExpungeJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testDelete_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 EXPUNGE"
                 << "S: * 1 EXPUNGE"
                 << "S: * 2 EXPUNGE"
                 << "S: * 3 EXPUNGE"
                 << "S: A000001 OK EXPUNGE completed";
        QTest::newRow("good") << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 EXPUNGE"
                 << "S: * 1" // missing EXPUNGE word
                 << "S: A000001 OK EXPUNGE completed";
        QTest::newRow("non-standard response") << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 EXPUNGE"
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 EXPUNGE"
                 << "S: A000001 NO access denied";
        QTest::newRow("no") << scenario;
    }

void testDelete()
    {
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::ExpungeJob *job = new KIMAP::ExpungeJob(&session);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO response", Continue);
        QVERIFY(result);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(ExpungeJobTest)

#include "expungejobtest.moc"
0707010000000E000081A40000000200000002000000015ED129EC0000010D000000000000000000000000000000000000004A00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/fakeserverscenario.logC: A000001 LIST "" *
S: * LIST ( \HasChildren ) / INBOX
S: * LIST ( \HasNoChildren ) / INBOX/&AOQ- &APY- &APw- @ &IKw-
S: * LIST ( \HasChildren ) / INBOX/lost+found
S: * LIST ( \HasNoChildren ) / "INBOX/lost+found/Calendar Public-20080128"
S: A000001 OK LIST completed
0707010000000F000081A40000000200000002000000015ED129EC000008DB000000000000000000000000000000000000004600000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/fakeservertest.cpp/*
   Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
   Author: Kevin Ottens <kevin@kdab.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/listjob.h"

#include <QTest>

class FakeServerTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testLoadScenario()
    {
        KIMAP::MailBoxDescriptor descriptor;
        QList<KIMAP::MailBoxDescriptor> listresult;

descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QString::fromUtf8("INBOX/ä ö ü @ €");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/lost+found");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/lost+found/Calendar Public-20080128");
        listresult << descriptor;

FakeServer fakeServer;
        fakeServer.addScenarioFromFile(QStringLiteral(TEST_DATA) + QStringLiteral("/fakeserverscenario.log"));
        fakeServer.startAndWait();

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::ListJob *job = new KIMAP::ListJob(&session);
        job->setIncludeUnsubscribed(true);
        QVERIFY(job->exec());

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(FakeServerTest)

#include "fakeservertest.moc"
07070100000010000081A40000000200000002000000015ED129EC00004885000000000000000000000000000000000000004400000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/fetchjobtest.cpp/*
   Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
   Author: Kevin Ottens <kevin@kdab.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/fetchjob.h"

#include <QTest>

Q_DECLARE_METATYPE(KIMAP::FetchJob::FetchScope)

class FetchJobTest: public QObject
{
    Q_OBJECT

private:
    QStringList m_signals;

QMap<qint64, qint64> m_uids;
    QMap<qint64, qint64> m_sizes;
    QMap<qint64, KIMAP::MessageFlags> m_flags;
    QMap<qint64, KIMAP::MessagePtr> m_messages;
    QMap<qint64, KIMAP::MessageParts> m_parts;
    QMap<qint64, KIMAP::MessageAttribute> m_attrs;
    QMap<qint64, KIMAP::Message> m_msgs;

public Q_SLOTS:
    void onHeadersReceived(const QString &/*mailBox*/,
                           const QMap<qint64, qint64> &uids,
                           const QMap<qint64, qint64> &sizes,
                           const QMap<qint64, KIMAP::MessageAttribute> &attrs,
                           const QMap<qint64, KIMAP::MessageFlags> &flags,
                           const QMap<qint64, KIMAP::MessagePtr> &messages)
    {
        m_signals << QStringLiteral("headersReceived");
        m_uids.unite(uids);
        m_sizes.unite(sizes);
        m_flags.unite(flags);
        m_messages.unite(messages);
        m_attrs.unite(attrs);
    }

void onMessagesReceived(const QString &/*mailbox*/,
                            const QMap<qint64, qint64> &uids,
                            const QMap<qint64, KIMAP::MessageAttribute> &attrs,
                            const QMap<qint64, KIMAP::MessagePtr> &messages)
    {
        m_signals << QStringLiteral("messagesReceived");
        m_uids.unite(uids);
        m_messages.unite(messages);
        m_attrs.unite(attrs);
    }

void onPartsReceived(const QString &/*mailbox*/,
                         const QMap<qint64, qint64> &/*uids*/,
                         const QMap<qint64, KIMAP::MessageAttribute> &attrs,
                         const QMap<qint64, KIMAP::MessageParts> &parts)
    {
        m_signals << QStringLiteral("partsReceived");
        m_attrs.unite(attrs);
        m_parts.unite(parts);
    }

void onMessagesAvailable(const QMap<qint64, KIMAP::Message> &messages)
    {
        m_signals << QStringLiteral("messagesAvailable");
        m_msgs.unite(messages);
    }

private Q_SLOTS:

void testFetch_data()
    {
        qRegisterMetaType<KIMAP::FetchJob::FetchScope>();

QTest::addColumn<bool>("uidBased");
        QTest::addColumn< KIMAP::ImapSet >("set");
        QTest::addColumn<int>("expectedMessageCount");
        QTest::addColumn< QList<QByteArray> >("scenario");
        QTest::addColumn<KIMAP::FetchJob::FetchScope>("scope");

KIMAP::FetchJob::FetchScope scope;
        scope.mode = KIMAP::FetchJob::FetchScope::Flags;
        scope.changedSince = 123456789;

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 1:4 (FLAGS UID) (CHANGEDSINCE 123456789)"
                 << "S: * 1 FETCH ( FLAGS () UID 1 )"
                 << "S: * 2 FETCH ( FLAGS () UID 2 )"
                 << "S: * 3 FETCH ( FLAGS () UID 3 )"
                 << "S: * 4 FETCH ( FLAGS () UID 4 )"
                 << "S: A000001 OK fetch done";

QTest::newRow("messages have empty flags (with changedsince)") << false << KIMAP::ImapSet(1, 4) << 4
                << scenario << scope;

scenario.clear();
        scope.changedSince = 0;
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 1:4 (FLAGS UID)"
                 << "S: * 1 FETCH ( FLAGS () UID 1 )"
                 << "S: * 2 FETCH ( FLAGS () UID 2 )"
                 << "S: * 3 FETCH ( FLAGS () UID 3 )"
                 << "S: * 4 FETCH ( FLAGS () UID 4 )"
                 << "S: A000001 OK fetch done";

QTest::newRow("messages have empty flags") << false << KIMAP::ImapSet(1, 4) << 4
                << scenario << scope;

scenario.clear();
        // kill the connection part-way through a list, with carriage returns at end
        // BUG 253619
        // this should fail, but it shouldn't crash
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 11 (RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] FLAGS UID)"
                 << "S: * 11 FETCH (RFC822.SIZE 770 INTERNALDATE \"11-Oct-2010 03:33:50 +0100\" BODY[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] {246}"
                 << "S: From: John Smith <jonathanr.smith@foobarbaz.com>\r\nTo: \"amagicemailaddress@foobarbazbarfoo.com\"\r\n\t<amagicemailaddress@foobarbazbarfoo.com>\r\nDate: Mon, 11 Oct 2010 03:34:48 +0100\r\nSubject: unsubscribe\r\nMessage-ID: <ASDFFDSASDFFDS@foobarbaz.com>\r\n\r\n"
                 << "X";
        scope.mode = KIMAP::FetchJob::FetchScope::Headers;
        QTest::newRow("connection drop") << false << KIMAP::ImapSet(11, 11) << 1 << scenario << scope;

scenario.clear();
        // Important bit here if "([127.0.0.1])" which used to crash the stream parser
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 11 (RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] FLAGS UID)"
                 << "S: * 11 FETCH (RFC822.SIZE 770 INTERNALDATE \"11-Oct-2010 03:33:50 +0100\" BODY[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] {246}"
                 << "S: ([127.0.0.1])\r\nDate: Mon, 11 Oct 2010 03:34:48 +0100\r\nSubject: unsubscribe\r\nMessage-ID: <ASDFFDSASDFFDS@foobarbaz.com>\r\n\r\n"
                 << "X";
        scope.mode = KIMAP::FetchJob::FetchScope::Headers;
        QTest::newRow("buffer overwrite") << false << KIMAP::ImapSet(11, 11) << 1 << scenario << scope;

scenario.clear();
        // We're assuming a buffer overwrite here which made us miss the opening parenthesis
        // for the properties list
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 11 (RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] FLAGS UID)"
                 << "S: * 11 FETCH {10}doh!\r\n\r\n\r\n)\r\n"
                 << "X";
        scope.mode = KIMAP::FetchJob::FetchScope::Headers;
        QTest::newRow("buffer overwrite 2") << false << KIMAP::ImapSet(11, 11) << 1 << scenario << scope;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 11 (RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER] FLAGS UID) (CHANGEDSINCE 123456789)"
                 << "S: * 11 FETCH (UID 123 RFC822.SIZE 770 INTERNALDATE \"11-Oct-2010 03:33:50 +0100\" BODY[HEADER] {245}"
                 << "S: From: John Smith <jonathanr.smith@foobarbaz.com>\r\nTo: \"amagicemailaddress@foobarbazbarfoo.com\"\r\n\t<amagicemailaddress@foobarbazbarfoo.com>\r\nDate: Mon, 11 Oct 2010 03:34:48 +0100\r\nSubject: unsubscribe\r\nMessage-ID: <ASDFFDSASDFFDS@foobarbaz.com>\r\n\r\n  FLAGS ())"
                 << "S: A000001 OK fetch done";
        scope.mode = KIMAP::FetchJob::FetchScope::FullHeaders;
        scope.changedSince = 123456789;
        QTest::newRow("fetch full headers") << false << KIMAP::ImapSet(11, 11) << 1
                                            << scenario << scope;
    }

void testFetch()
    {
        QFETCH(bool, uidBased);
        QFETCH(KIMAP::ImapSet, set);
        QFETCH(int, expectedMessageCount);
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(KIMAP::FetchJob::FetchScope, scope);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::FetchJob *job = new KIMAP::FetchJob(&session);
        job->setUidBased(uidBased);
        job->setSequenceSet(set);
        job->setScope(scope);

bool result = job->exec();
        QEXPECT_FAIL("connection drop", "Expected failure on connection drop", Continue);
        QEXPECT_FAIL("buffer overwrite", "Expected failure on confused list", Continue);
        QEXPECT_FAIL("buffer overwrite 2", "Expected beginning of message missing", Continue);
        QVERIFY(result);
        if (result) {
            QVERIFY(m_signals.count() > 0);
            QCOMPARE(m_uids.count(), expectedMessageCount);
            QCOMPARE(m_msgs.count(), expectedMessageCount);
        }

QVERIFY(fakeServer.isAllScenarioDone());
        fakeServer.quit();

m_signals.clear();
        m_uids.clear();
        m_sizes.clear();
        m_flags.clear();
        m_messages.clear();
        m_parts.clear();
        m_attrs.clear();
        m_msgs.clear();
    }

void testFetchStructure()
    {
        QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 1:2 (BODYSTRUCTURE UID)"
                 << "S: * 1 FETCH (UID 10 BODYSTRUCTURE (\"TEXT\" \"PLAIN\" (\"CHARSET\" \"ISO-8859-1\") NIL NIL \"7BIT\" 5 1 NIL NIL NIL))"
                 << "S: * 2 FETCH (UID 20 BODYSTRUCTURE ((((\"TEXT\" \"PLAIN\" (\"CHARSET\" \"ISO-8859-1\") NIL NIL \"7BIT\" 72 4 NIL NIL NIL)(\"TEXT\" \"HTML\" (\"CHARSET\" \"ISO-8859-1\") NIL NIL \"QUOTED-PRINTABLE\" 281 5 NIL NIL NIL) \"ALTERNATIVE\" (\"BOUNDARY\" \"0001\") NIL NIL)(\"IMAGE\" \"GIF\" (\"NAME\" \"B56.gif\") \"<B56@goomoji.gmail>\" NIL \"BASE64\" 528 NIL NIL NIL) \"RELATED\" (\"BOUNDARY\" \"0002\") NIL NIL)(\"IMAGE\" \"JPEG\" (\"NAME\" \"photo.jpg\") NIL NIL \"BASE64\" 53338 NIL (\"ATTACHMENT\" (\"FILENAME\" \"photo.jpg\")) NIL) \"MIXED\" (\"BOUNDARY\" \"0003\") NIL NIL))"
                 << "S: A000001 OK fetch done";

KIMAP::FetchJob::FetchScope scope;
        scope.mode = KIMAP::FetchJob::FetchScope::Structure;

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::FetchJob *job = new KIMAP::FetchJob(&session);
        job->setUidBased(false);
        job->setSequenceSet(KIMAP::ImapSet(1, 2));
        job->setScope(scope);

connect(job, SIGNAL(messagesReceived(QString,
                                             QMap<qint64, qint64>,
                                             QMap<qint64, KIMAP::MessageAttribute>,
                                             QMap<qint64, KIMAP::MessagePtr>)),
                this, SLOT(onMessagesReceived(QString,
                                              QMap<qint64, qint64>,
                                              QMap<qint64, KIMAP::MessageAttribute>,
                                              QMap<qint64, KIMAP::MessagePtr>)));
        connect(job, &KIMAP::FetchJob::messagesAvailable,
                this, &FetchJobTest::onMessagesAvailable);

bool result = job->exec();
        QVERIFY(result);
        QVERIFY(m_signals.count() > 0);
        QCOMPARE(m_uids.count(), 2);
        QCOMPARE(m_messages[1]->attachments().count(), 0);
        QCOMPARE(m_messages[2]->attachments().count(), 1);
        QCOMPARE(m_messages[2]->contents().size(), 2);
        QCOMPARE(m_messages[2]->contents()[0]->contents().size(), 2);
        QCOMPARE(m_messages[2]->attachments().at(0)->contentDisposition()->filename(), QStringLiteral("photo.jpg"));
        QCOMPARE(m_msgs.count(), 2);
        QCOMPARE(m_msgs[1].message->attachments().count(), 0);
        QCOMPARE(m_msgs[2].message->attachments().count(), 1);
        QCOMPARE(m_msgs[2].message->contents().size(), 2);
        QCOMPARE(m_msgs[2].message->contents()[0]->contents().size(), 2);
        QCOMPARE(m_msgs[2].message->attachments().at(0)->contentDisposition()->filename(),
                 QStringLiteral("photo.jpg"));

fakeServer.quit();

void testFetchParts()
    {
        QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 FETCH 2 (BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] BODY.PEEK[1.1.1.MIME] BODY.PEEK[1.1.1] FLAGS UID)"
                 << "S: * 2 FETCH (UID 20 FLAGS (\\Seen) BODY[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] {154}\r\nFrom: Joe Smith <smith@example.com>\r\nDate: Wed, 2 Mar 2011 11:33:24 +0700\r\nMessage-ID: <1234@example.com>\r\nSubject: hello\r\nTo: Jane <jane@example.com>\r\n\r\n BODY[1.1.1] {28}\r\nHi Jane, nice to meet you!\r\n BODY[1.1.1.MIME] {48}\r\nContent-Type: text/plain; charset=ISO-8859-1\r\n\r\n)\r\n"
                 << "S: A000001 OK fetch done";

KIMAP::FetchJob::FetchScope scope;
        scope.mode = KIMAP::FetchJob::FetchScope::HeaderAndContent;
        scope.parts.clear();
        scope.parts.append("1.1.1");

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::FetchJob *job = new KIMAP::FetchJob(&session);
        job->setUidBased(false);
        job->setSequenceSet(KIMAP::ImapSet(2, 2));
        job->setScope(scope);

connect(job, SIGNAL(headersReceived(QString,
                                            QMap<qint64, qint64>,
                                            QMap<qint64, qint64>,
                                            QMap<qint64, KIMAP::MessageAttribute>,
                                            QMap<qint64, KIMAP::MessageFlags>,
                                            QMap<qint64, KIMAP::MessagePtr>)),
                this, SLOT(onHeadersReceived(QString,
                                             QMap<qint64, qint64>,
                                             QMap<qint64, qint64>,
                                             QMap<qint64, KIMAP::MessageAttribute>,
                                             QMap<qint64, KIMAP::MessageFlags>,
                                             QMap<qint64, KIMAP::MessagePtr>)));
        connect(job, SIGNAL(partsReceived(QString,
                                          QMap<qint64, qint64>,
                                          QMap<qint64, KIMAP::MessageAttribute>,
                                          QMap<qint64, KIMAP::MessageParts>)),
                this, SLOT(onPartsReceived(QString,
                                           QMap<qint64, qint64>,
                                           QMap<qint64, KIMAP::MessageAttribute>,
                                           QMap<qint64, KIMAP::MessageParts>)));
        connect(job, &KIMAP::FetchJob::messagesAvailable,
                this, &FetchJobTest::onMessagesAvailable);
        bool result = job->exec();

QVERIFY(result);
        QVERIFY(m_signals.count() > 0);
        QCOMPARE(m_uids.count(), 1);
        QCOMPARE(m_parts.count(), 1);
        QCOMPARE(m_attrs.count(), 0);
        QCOMPARE(m_msgs.count(), 1);

// Check that we received the message header
        QCOMPARE(m_messages[2]->messageID()->identifier(), QByteArray("1234@example.com"));
        QCOMPARE(m_msgs[2].message->messageID()->identifier(), QByteArray("1234@example.com"));

// Check that we received the flags
        QMap<qint64, KIMAP::MessageFlags> expectedFlags;
        expectedFlags.insert(2, KIMAP::MessageFlags() << "\\Seen");
        QCOMPARE(m_flags, expectedFlags);
        QCOMPARE(m_msgs[2].flags, expectedFlags[2]);

// Check that we didn't received the full message body, since we only requested a specific part
        QCOMPARE(m_messages[2]->decodedText().length(), 0);
        QCOMPARE(m_messages[2]->attachments().count(), 0);
        QCOMPARE(m_msgs[2].message->decodedText().length(), 0);
        QCOMPARE(m_msgs[2].message->attachments().count(), 0);

// Check that we received the part we requested
        QByteArray partId = m_parts[2].keys().first();
        QString text = m_parts[2].value(partId)->decodedText(true, true);
        QCOMPARE(partId, QByteArray("1.1.1"));
        QCOMPARE(text, QStringLiteral("Hi Jane, nice to meet you!")) ;

QCOMPARE(m_msgs[2].parts.keys().first(), QByteArray("1.1.1"));
        QCOMPARE(m_msgs[2].parts.value(partId)->decodedText(true, true),
                 QStringLiteral("Hi Jane, nice to meet you!"));

fakeServer.quit();

};

QTEST_GUILESS_MAIN(FetchJobTest)

#include "fetchjobtest.moc"
07070100000011000081A40000000200000002000000015ED129EC00004252000000000000000000000000000000000000004A00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/getmetadatajobtest.cpp/*
   Copyright (C) 2013 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/getmetadatajob.h"

#include <QTest>
#include <QDebug>

typedef QMap<QByteArray, QByteArray> MAP;
Q_DECLARE_METATYPE(MAP)

class GetMetadataJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void metadata_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QMap<QByteArray, QByteArray> >("expectedAnnotations");

{
            //FIXME requesting /shared and getting /private back doesn't make sense => fix scenario
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 GETMETADATA (DEPTH infinity) \"Folder1\" (/shared)"
                     << "S: * METADATA \"Folder1\" (/shared/comment \"Shared comment\")"
                     << "S: * METADATA \"Folder1\" (/private/comment \"My own comment\")"
                     << "S: A000001 OK GETMETADATA complete";
            QMap<QByteArray, QByteArray> expected;
            expected.insert("/shared/comment", "Shared comment");
            expected.insert("/private/comment", "My own comment");
            QTest::newRow("normal") << scenario << "Folder1" << expected;
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 GETMETADATA (DEPTH infinity) \"Folder1\" (/shared)"
                     << "S: * METADATA \"Folder1\" (/shared/comment \"Shared comment\" /private/comment \"My own comment\")"
                     << "S: A000001 OK GETMETADATA complete";
            QMap<QByteArray, QByteArray> expected;
            expected.insert("/shared/comment", "Shared comment");
            expected.insert("/private/comment", "My own comment");
            QTest::newRow("combined response") << scenario << "Folder1" << expected;
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 GETMETADATA (DEPTH infinity) \"Folder1\" (/shared)"
                     << "S: * METADATA \"Folder1\" (/shared/comment \"NIL\" /private/comment \"NIL\")"
                     << "S: A000001 OK GETMETADATA complete";
            QMap<QByteArray, QByteArray> expected;
            expected.insert("/shared/comment", "");
            expected.insert("/private/comment", "");
            QTest::newRow("NIL response") << scenario << "Folder1" << expected;
        }
    }

void metadata()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QString, mailbox);
        QFETCH(MAP, expectedAnnotations);

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

KIMAP::Session session(QLatin1String("127.0.0.1"), 5989);

KIMAP::GetMetaDataJob *getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(mailbox);
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::AllLevels);
        getMetadataJob->addRequestedEntry("/shared");

QVERIFY(getMetadataJob->exec());

QCOMPARE(getMetadataJob->allMetaData(mailbox).size(), expectedAnnotations.size());
        const QMap <QByteArray, QByteArray> &allMetaData = getMetadataJob->allMetaData();
        QCOMPARE(allMetaData.size(), expectedAnnotations.size());
        foreach (const QByteArray &entry, expectedAnnotations.keys()) {
            QCOMPARE(getMetadataJob->metaData(mailbox, entry), expectedAnnotations.value(entry));
            QCOMPARE(getMetadataJob->metaData(entry), expectedAnnotations.value(entry));
            QCOMPARE(allMetaData.value(entry), expectedAnnotations.value(entry));
        }

fakeServer.quit();
    }

void testMetadataParameter()
    {
        FakeServer fakeServer;
        QList<QByteArray> scenario;

scenario << FakeServer::preauth()
                 << "C: A000001 GETMETADATA \"Folder1\" (/shared)"
                 << "S: A000001 OK GETMETADATA complete"
                 << "C: A000002 GETMETADATA (DEPTH 1) \"Folder1\" (/shared)"
                 << "S: A000002 OK GETMETADATA complete"
                 << "C: A000003 GETMETADATA (MAXSIZE 1234) \"Folder1\" (/shared)"
                 << "S: A000003 OK GETMETADATA complete"
                 << "C: A000004 GETMETADATA (DEPTH 1 MAXSIZE 1234) \"Folder1\" (/shared)"
                 << "S: A000004 OK GETMETADATA complete"
                 << "C: A000005 GETMETADATA (DEPTH 1 MAXSIZE 1234) \"Folder1\" (/shared /shared2)"
                 << "S: A000005 OK GETMETADATA complete"
                 << "C: A000006 GETMETADATA (DEPTH 1 MAXSIZE 1234) \"Folder1\""
                 << "S: A000006 OK GETMETADATA complete"
                 << "C: A000007 GETMETADATA (DEPTH 1) \"Folder1\""
                 << "S: A000007 OK GETMETADATA complete"
                 << "C: A000008 GETMETADATA (MAXSIZE 1234) \"Folder1\""
                 << "S: A000008 OK GETMETADATA complete"
                 << "C: A000009 GETMETADATA \"Folder1\""
                 << "S: A000009 OK GETMETADATA complete"
                 << "C: A000010 GETMETADATA \"\""
                 << "S: A000010 OK GETMETADATA complete";
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

//C: A000001 GETMETADATA "Folder1" (/shared)
        KIMAP::GetMetaDataJob *getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared");
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::NoDepth);
        QVERIFY(getMetadataJob->exec());

QCOMPARE(getMetadataJob->allMetaData(QLatin1String("Folder1")).size(), 0);

//C: A000002 GETMETADATA "Folder1" (DEPTH 1) (/shared)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared");
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::OneLevel);
        QVERIFY(getMetadataJob->exec());

//C: A000003 GETMETADATA "Folder1" (MAXSIZE 1234) (/shared)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared");
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::NoDepth);
        getMetadataJob->setMaximumSize(1234);
        QVERIFY(getMetadataJob->exec());

//C: A000004 GETMETADATA "Folder1" (DEPTH 1) (MAXSIZE 1234) (/shared)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared");
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::OneLevel);
        getMetadataJob->setMaximumSize(1234);
        QVERIFY(getMetadataJob->exec());

//C: A000005 GETMETADATA "Folder1" (DEPTH 1) (MAXSIZE 1234) (/shared /shared2)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared");
        getMetadataJob->addRequestedEntry("/shared2");
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::OneLevel);
        getMetadataJob->setMaximumSize(1234);
        QVERIFY(getMetadataJob->exec());

//C: A000006 GETMETADATA "Folder1" (DEPTH 1) (MAXSIZE 1234)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::OneLevel);
        getMetadataJob->setMaximumSize(1234);
        QVERIFY(getMetadataJob->exec());

//C: A000007 GETMETADATA "Folder1" (DEPTH 1)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::OneLevel);
        QVERIFY(getMetadataJob->exec());

//C: A000008 GETMETADATA "Folder1" (MAXSIZE 1234)
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::NoDepth);
        getMetadataJob->setMaximumSize(1234);
        QVERIFY(getMetadataJob->exec());

//C: A000009 GETMETADATA "Folder1"
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::NoDepth);
        QVERIFY(getMetadataJob->exec());

//C: A000010 GETMETADATA ""
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        getMetadataJob->setMailBox(QLatin1String(""));
        getMetadataJob->setDepth(KIMAP::GetMetaDataJob::NoDepth);
        QVERIFY(getMetadataJob->exec());

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

void annotatemore_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QMap<QByteArray, QByteArray> >("expectedAnnotations");
        QTest::addColumn<QByteArray>("entry");

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 GETANNOTATION \"Folder1\" \"*\" \"value.shared\""
                     << "S: * ANNOTATION Folder1 /comment (value.shared \"Shared comment\")"
                     << "S: * ANNOTATION Folder1 /comment (value.priv \"My own comment\")"
                     << "S: A000001 OK annotations retrieved";

QMap<QByteArray, QByteArray> expected;
            expected.insert("/shared/comment", "Shared comment");
            expected.insert("/private/comment", "My own comment");
            QTest::newRow("get all") << scenario << "Folder1" << expected << QByteArray("/shared*");
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 GETANNOTATION \"Folder1\" \"/comment\" \"value.shared\""
                     << "S: * ANNOTATION Folder1 /comment (value.shared \"Shared comment\")"
                     << "S: * ANNOTATION Folder1 /comment (value.priv \"My own comment\")"
                     << "S: A000001 OK annotations retrieved";

void annotatemore()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QString, mailbox);
        QFETCH(MAP, expectedAnnotations);
        QFETCH(QByteArray, entry);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::GetMetaDataJob *getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Annotatemore);
        getMetadataJob->setMailBox(mailbox);
        getMetadataJob->addRequestedEntry(entry);

QVERIFY(getMetadataJob->exec());

//   qDebug() << getMetadataJob->allMetaData(mailbox);
        qDebug() << getMetadataJob->allMetaData();
        const QMap <QByteArray, QByteArray> &allMetaData = getMetadataJob->allMetaData();
        QCOMPARE(allMetaData.size(), expectedAnnotations.size());
        foreach (const QByteArray &e, expectedAnnotations.keys()) {
            QCOMPARE(getMetadataJob->metaData(e), expectedAnnotations.value(e));
            QCOMPARE(allMetaData.value(e), expectedAnnotations.value(e));
        }

fakeServer.quit();
    }

void testAnnotateEntires()
    {
        FakeServer fakeServer;
        QList<QByteArray> scenario;

scenario << FakeServer::preauth()
                 << "C: A000001 GETANNOTATION \"Folder1\""
                 << "S: A000001 OK annotations retrieved"
                 << "C: A000002 GETANNOTATION \"Folder1\" (\"/comment\" \"/motd\") (\"value.priv\" \"value.shared\")"
                 << "S: A000002 OK annotations retrieved";
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

//C: A000001 GETANNOTATION "Folder1"
        KIMAP::GetMetaDataJob *getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Annotatemore);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        QVERIFY(getMetadataJob->exec());

QCOMPARE(getMetadataJob->allMetaData(QLatin1String("Folder1")).size(), 0);

//C: A000002 GETANNOTATION "Folder1" ("/comment" "/motd") ("value.shared" "value.priv")
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Annotatemore);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared/comment");
        getMetadataJob->addRequestedEntry("/private/motd");
        QVERIFY(getMetadataJob->exec());

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

void testAnnotateMutiple()
    {
        //Do not double same parts of the request
        FakeServer fakeServer;
        QList<QByteArray> scenario;

scenario << FakeServer::preauth()
            << "C: A000001 GETANNOTATION \"Folder1\" (\"/comment\" \"/motd\") \"value.shared\""
            << "S: A000001 OK annotations retrieved"
            << "C: A000002 GETANNOTATION \"Folder1\" \"/comment\" (\"value.priv\" \"value.shared\")"
            << "S: A000002 OK annotations retrieved";
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

//C: A000001 GETANNOTATION "Folder1" ("/comment" "/motd") "value.shared"
        KIMAP::GetMetaDataJob *getMetadataJob = new KIMAP::GetMetaDataJob( &session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Annotatemore);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared/comment");
        getMetadataJob->addRequestedEntry("/shared/motd");
        QVERIFY(getMetadataJob->exec());

//C: A000002 GETANNOTATION "Folder1" ("/comment") ("value.shared" "value.priv")
        getMetadataJob = new KIMAP::GetMetaDataJob(&session);
        getMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Annotatemore);
        getMetadataJob->setMailBox(QStringLiteral("Folder1"));
        getMetadataJob->addRequestedEntry("/shared/comment");
        getMetadataJob->addRequestedEntry("/private/comment");
        QVERIFY(getMetadataJob->exec());

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

};

QTEST_GUILESS_MAIN(GetMetadataJobTest)

#include "getmetadatajobtest.moc"
07070100000012000081A40000000200000002000000015ED129EC000007D6000000000000000000000000000000000000004100000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/idjobtest.cpp/*
   Copyright (c) 2015 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

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

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/idjob.h"

#include <QTest>

typedef QMap<QByteArray, QByteArray> ArrayMap;
Q_DECLARE_METATYPE(ArrayMap)

class IdJobTest: public QObject {
  Q_OBJECT

private Q_SLOTS:

void testId_data() {
    QTest::addColumn<QList<QByteArray> >("scenario");
    QTest::addColumn<ArrayMap>("values");
    QList<QByteArray> scenario;
    scenario << "S: * PREAUTH"
             << "C: A000001 ID (\"name\" \"clientid\")"
             << "S: * ID NIL"
             << "S: A000001 OK ID completed";
  
    ArrayMap values;
    values.insert("name", "clientid");
    QTest::newRow("good") << scenario << values;
}

void testId()
{
    QFETCH(QList<QByteArray>, scenario);
    QFETCH(ArrayMap, values);

FakeServer fakeServer;
    fakeServer.setScenario(scenario);
    fakeServer.startAndWait();
    KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::IdJob *job = new KIMAP::IdJob(&session);
    foreach (const QByteArray &key, values.keys()) {
        job->setField(key, values.value(key));
    }
    bool result = job->exec();
    QVERIFY(result);
    fakeServer.quit();
}

};

QTEST_GUILESS_MAIN(IdJobTest)

#include "idjobtest.moc"
07070100000013000081A40000000200000002000000015ED129EC00002778000000000000000000000000000000000000004300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/idlejobtest.cpp/*
   Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
   Author: Kevin Ottens <kevin@kdab.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/selectjob.h"
#include "kimap/idlejob.h"

#include <QTest>
#include <QSignalSpy>

Q_DECLARE_METATYPE(QList<int>)
Q_DECLARE_METATYPE(QList<qint64>)
Q_DECLARE_METATYPE(KIMAP::IdleJob *)

class IdleJobTest: public QObject
{
    Q_OBJECT

public:
    explicit IdleJobTest(QObject *parent = nullptr)
        : QObject(parent)
    {
        qRegisterMetaType<KIMAP::IdleJob *>();
    }

private Q_SLOTS:
    void shouldReactToIdle_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QString>("expectedMailBox");
        QTest::addColumn< QList<int> >("expectedMessageCounts");
        QTest::addColumn< QList<int> >("expectedRecentCounts");
        QTest::addColumn< QList<qint64> >("expectedFlagsNotifications");

QList<QByteArray> scenario;
        QString expectedMailBox;
        QList<int> expectedMessageCounts;
        QList<int> expectedRecentCounts;
        QList<qint64> expectedFlagsNotifications;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX/Foo\""
                 << "S: A000001 OK SELECT done"
                 << "C: A000002 IDLE"
                 << "S: + OK"
                 << "S: * 0 RECENT"
                 << "S: * 1 EXISTS"
                 << "S: * 1 RECENT"
                 << "S: * 2 EXISTS"
                 << "S: A000002 OK done idling";

expectedMailBox = QStringLiteral("INBOX/Foo");

expectedMessageCounts.clear();
        expectedRecentCounts.clear();

expectedMessageCounts << 1 << 2;
        expectedRecentCounts << 0 << 1;

QTest::newRow("normal") << scenario << expectedMailBox << expectedMessageCounts << expectedRecentCounts << expectedFlagsNotifications;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX/Foo\""
                 << "S: A000001 OK SELECT done"
                 << "C: A000002 IDLE"
                 << "S: + OK"
                 << "S: * 0 RECENT"
                 << "S: * 1 RECENT"
                 << "S: A000002 OK done idling";

expectedMailBox = QStringLiteral("INBOX/Foo");

expectedMessageCounts.clear();
        expectedRecentCounts.clear();

expectedMessageCounts << -1 << -1;
        expectedRecentCounts << 0 << 1;

QTest::newRow("only RECENT") << scenario << expectedMailBox << expectedMessageCounts << expectedRecentCounts << expectedFlagsNotifications;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX/Foo\""
                 << "S: A000001 OK SELECT done"
                 << "C: A000002 IDLE"
                 << "S: + OK"
                 << "S: * 1 EXISTS"
                 << "S: * 2 EXISTS"
                 << "S: A000002 OK done idling";

expectedMailBox = QStringLiteral("INBOX/Foo");

expectedMessageCounts.clear();
        expectedRecentCounts.clear();

expectedMessageCounts << 1 << 2;
        expectedRecentCounts << -1 << -1;

QTest::newRow("only EXISTS") << scenario << expectedMailBox << expectedMessageCounts << expectedRecentCounts << expectedFlagsNotifications;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX/Foo\""
                 << "S: A000001 OK SELECT done"
                 << "C: A000002 IDLE"
                 << "S: + OK"
                 << "S: * 2 EXISTS"
                 << "W: 150"
                 << "S: * 1 RECENT"
                 << "S: A000002 OK done idling";

expectedMailBox = QStringLiteral("INBOX/Foo");

expectedMessageCounts.clear();
        expectedRecentCounts.clear();

expectedMessageCounts << 2;
        expectedRecentCounts << 1;

QTest::newRow("under 200ms, same notification") << scenario << expectedMailBox << expectedMessageCounts << expectedRecentCounts << expectedFlagsNotifications;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX/Foo\""
                 << "S: A000001 OK SELECT done"
                 << "C: A000002 IDLE"
                 << "S: + OK"
                 << "S: * 2 EXISTS"
                 << "W: 250"
                 << "S: * 1 RECENT"
                 << "S: A000002 OK done idling";

expectedMailBox = QStringLiteral("INBOX/Foo");

expectedMessageCounts.clear();
        expectedRecentCounts.clear();

expectedMessageCounts << 2 << -1;
        expectedRecentCounts << -1 << 1;

QTest::newRow("above 200ms, two notifications") << scenario << expectedMailBox << expectedMessageCounts << expectedRecentCounts << expectedFlagsNotifications;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX/Foo\""
                 << "S: A000001 OK SELECT done"
                 << "C: A000002 IDLE"
                 << "S: + OK"
                 << "S: * 1 FETCH (FLAGS ())"
                 << "W: 200"
                 << "S: * 2 FETCH (FLAGS (\\Seen))"
                 << "S: A000002 OK done idling";

expectedMailBox = QStringLiteral("INBOX/Foo");

expectedMessageCounts.clear();
        expectedRecentCounts.clear();
        expectedFlagsNotifications << 1 << 2;

QTest::newRow("2 flags change notifications") << scenario << expectedMailBox << expectedMessageCounts << expectedRecentCounts << expectedFlagsNotifications;
    }

void shouldReactToIdle()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QString, expectedMailBox);
        QFETCH(QList<int>, expectedMessageCounts);
        QFETCH(QList<int>, expectedRecentCounts);
        QFETCH(QList<qint64>, expectedFlagsNotifications);

QVERIFY(expectedMessageCounts.size() == expectedRecentCounts.size());

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SelectJob *select = new KIMAP::SelectJob(&session);
        select->setMailBox(expectedMailBox);
        QVERIFY(select->exec());

KIMAP::IdleJob *idle = new KIMAP::IdleJob(&session);

QSignalSpy statsSpy(idle, &KIMAP::IdleJob::mailBoxStats);
        QSignalSpy flagsSpy(idle, &KIMAP::IdleJob::mailBoxMessageFlagsChanged);

bool result = idle->exec();

if (result) {
            QCOMPARE(statsSpy.count(), expectedMessageCounts.size());
            QCOMPARE(flagsSpy.count(), expectedFlagsNotifications.size());

for (int i = 0 ; i < statsSpy.count(); i++) {
                const KIMAP::IdleJob *job = statsSpy.at(i).at(0).value<KIMAP::IdleJob *>();
                const QString mailBox = statsSpy.at(i).at(1).toString();
                const int messageCount = statsSpy.at(i).at(2).toInt();
                const int recentCount = statsSpy.at(i).at(3).toInt();

QCOMPARE(job, idle);
                QCOMPARE(mailBox, expectedMailBox);
                QCOMPARE(messageCount, expectedMessageCounts.at(i));
                QCOMPARE(recentCount, expectedRecentCounts.at(i));
            }

for (int i = 0; i < flagsSpy.count(); i++) {
                const KIMAP::IdleJob *job = flagsSpy.at(i).at(0).value<KIMAP::IdleJob *>();
                const qint64 uid = flagsSpy.at(i).at(1).toLongLong();

QCOMPARE(job, idle);
                QCOMPARE(uid, expectedFlagsNotifications.at(i));
            }
        }

fakeServer.quit();
    }

void shouldResetTimeout_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SELECT \"INBOX\""
                     << "S: A000001 OK SELECT done"
                     << "C: A000002 IDLE"
                     << "S: + OK"
                     << "S: A000002 OK done idling";

QTest::newRow("good") << scenario;
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SELECT \"INBOX\""
                     << "S: A000001 OK SELECT done"
                     << "C: A000002 IDLE"
                     << "S: + OK"
                     << "X";

QTest::newRow("bad") << scenario;
        }
    }

void shouldResetTimeout()
    {
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);
        const int originalTimeout = session.timeout();

KIMAP::SelectJob *select = new KIMAP::SelectJob(&session);
        select->setMailBox(QStringLiteral("INBOX"));
        QVERIFY(select->exec());

KIMAP::IdleJob *idle = new KIMAP::IdleJob(&session);
        idle->exec();

QCOMPARE(session.timeout(), originalTimeout);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(IdleJobTest)

#include "idlejobtest.moc"
07070100000014000081A40000000200000002000000015ED129EC0000178E000000000000000000000000000000000000004300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/imapsettest.cpp/*
   Copyright (C) 2009 Kevin Ottens <ervin@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimap/imapset.h"

#include <QTest>
#include <QDebug>

using namespace KIMAP;

QByteArray operator""_ba(const char *str, std::size_t len)
{
    return QByteArray{str, static_cast<int>(len)};
}

class ImapSetTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void shouldConvertToAndFromByteArray_data()
    {
        ImapSet set;

QTest::addColumn<ImapSet>("imapSet");
        QTest::addColumn<QByteArray>("byteArray");

QTest::newRow("empty set") << ImapSet() << QByteArray();
        QTest::newRow("unique value") << ImapSet(7) << QByteArray("7");
        QTest::newRow("single interval") << ImapSet(7, 10) << QByteArray("7:10");
        QTest::newRow("single interval with no upper bound") << ImapSet(1, 0) << QByteArray("1:*");

set = ImapSet(7, 10);
        set.add(ImapInterval(12, 14));
        QTest::newRow("two intervals") << set << QByteArray("7:10,12:14");

set = ImapSet(7, 10);
        set.add(ImapInterval(12));
        QTest::newRow("two intervals with an infinite one") << set << QByteArray("7:10,12:*");

set = ImapSet(7, 10);
        set.add(5);
        QTest::newRow("one interval and a value") << set << QByteArray("7:10,5");

set = ImapSet(7, 10);
        set.add(QVector<ImapSet::Id>() << 5 << 3);
        QTest::newRow("one interval and two values") << set << QByteArray("7:10,3,5");
    }

void shouldConvertToAndFromByteArray()
    {
        QFETCH(ImapSet, imapSet);
        QFETCH(QByteArray, byteArray);

QCOMPARE(QString::fromUtf8(imapSet.toImapSequenceSet()),
                 QString::fromUtf8(byteArray));
        //qDebug() << "Expects" << imapSet << "got" << ImapSet::fromImapSequenceSet( byteArray );
        QCOMPARE(ImapSet::fromImapSequenceSet(byteArray), imapSet);
    }

void testOptimize_data()
    {
        QTest::addColumn<ImapSet>("imapSet");
        QTest::addColumn<QByteArray>("originalString");
        QTest::addColumn<QByteArray>("expectedString");

{
            ImapSet imapSet;
            for (int i = 1; i <= 10; ++i) {
                imapSet.add(i);
            }
            QTest::newRow("Neighbouring numbers") << imapSet << "1,2,3,4,5,6,7,8,9,10"_ba << "1:10"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(ImapInterval{1, 3});
            imapSet.add(ImapInterval{5, 7});
            QTest::newRow("Neighbouring intervals with a gap") << imapSet << "1:3,5:7"_ba << "1:3,5:7"_ba;
        }
        {
            ImapSet imapSet;
            for (int i : { 5, 8, 3, 1, 9, 2, 7, 4, 6 }) {
                imapSet.add(i);
            }
            QTest::newRow("Random order") << imapSet << "5,8,3,1,9,2,7,4,6"_ba << "1:9"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(ImapInterval{1, 3});
            imapSet.add(ImapInterval{2, 4});
            QTest::newRow("Overlapping") << imapSet << "1:3,2:4"_ba << "1:4"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(ImapInterval{2, 4});
            imapSet.add(ImapInterval{1, 3});
            imapSet.add(4);
            imapSet.add(ImapInterval{7, 8});
            imapSet.add(ImapInterval{8, 9});
            QTest::newRow("Multiple overlapping with a gap") << imapSet << "2:4,1:3,4,7:8,8:9"_ba << "1:4,7:9"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(5);
            imapSet.add(8);
            imapSet.add(10);
            imapSet.add(ImapInterval{0, 20});
            QTest::newRow("Overlapping multiple intervals") << imapSet << "5,8,10,0:20"_ba << "0:20"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(1);
            imapSet.add(ImapInterval{3, 5});
            imapSet.add(ImapInterval{4, 0});
            QTest::newRow("Open end overlap") << imapSet << "1,3:5,4:*"_ba << "1,3:*"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(ImapInterval{1, 4});
            imapSet.add(3);
            QTest::newRow("Value within interval") << imapSet << "1:4,3"_ba << "1:4"_ba;
        }
        {
            ImapSet imapSet;
            imapSet.add(ImapInterval{1, 0});
            imapSet.add(ImapInterval{3, 0});
            imapSet.add(5);
            QTest::newRow("Multiple open end intervals") << imapSet << "1:*,3:*,5"_ba << "1:*"_ba;
        }
        {
            ImapSet imapSet;
            for (ImapSet::Id id : {1, 2, 3, 5, 6, 8, 9, 10, 15, 16, 19, 20, 21, 23}) {
                imapSet.add(id);
            }
            QTest::newRow("Merge single values") << imapSet << "1,2,3,5,6,8,9,10,15,16,19,20,21,23"_ba
                                                 << "1:3,5:6,8:10,15:16,19:21,23"_ba;
        }
    }

void testOptimize()
    {
        QFETCH(ImapSet, imapSet);
        QFETCH(QByteArray, originalString);
        QFETCH(QByteArray, expectedString);

QCOMPARE(imapSet.intervals().size(), originalString.count(",") + 1);
        QCOMPARE(imapSet.toImapSequenceSet(), originalString);

imapSet.optimize();

QCOMPARE(imapSet.intervals().size(), expectedString.count(",") + 1);
        QCOMPARE(imapSet.toImapSequenceSet(), expectedString);
    }
};

QTEST_GUILESS_MAIN(ImapSetTest)

#include "imapsettest.moc"
07070100000015000041ED0000000200000002000000025ED129EC00000000000000000000000000000000000000000000003D00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest07070100000016000081A40000000200000002000000015ED129EC00000242000000000000000000000000000000000000004C00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/CMakeLists.txtkde_enable_exceptions()

set(kimaptest_SRCS
   fakeserver.cpp
   mockjob.cpp
   sslserver.cpp
)

add_library(kimaptest STATIC ${kimaptest_SRCS})
generate_export_header(kimaptest)
add_library(KF5::kimaptest ALIAS kimaptest)
target_link_libraries(kimaptest KF5IMAP Qt5::Test Qt5::Network Qt5::Core KF5::CoreAddons KF5::KIOCore KF5::I18n)

install(TARGETS kimaptest EXPORT KF5IMAPTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})

########### install files ###############

install(FILES
  fakeserver.h
  mockjob.h
  DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/kimaptest COMPONENT Devel)
07070100000017000081A40000000200000002000000015ED129EC00001A89000000000000000000000000000000000000004C00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/fakeserver.cpp/*
   Copyright (C) 2008 Omat Holding B.V. <info@omat.nl>

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

This program 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
   General Public License for more details.

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

// Own
#include "fakeserver.h"
#include "sslserver.h"

// Qt
#include <QDebug>
#include <QTcpServer>

#include <QFile>
#include <QTest>

#include "imapstreamparser.h"

QByteArray FakeServer::preauth()
{
    return "S: * PREAUTH localhost Test Library server ready";
}

QByteArray FakeServer::greeting()
{
    return "S: * OK localhost Test Library server ready";
}

FakeServer::FakeServer(QObject *parent) : QThread(parent), m_encrypted(false), m_starttls(false)
{
    moveToThread(this);
}

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

QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    QVERIFY(socket);

int scenarioNumber = m_clientSockets.indexOf(socket);

if (m_scenarios[scenarioNumber].isEmpty()) {
        KIMAP::ImapStreamParser *clientParser = m_clientParsers[scenarioNumber];
        QByteArray received = "C: " + clientParser->readUntilCommandEnd().trimmed();
        qWarning() << "Scenario" << scenarioNumber << "finished, but we got command" << received;
        QVERIFY(false);
    }

readClientPart(scenarioNumber);
    writeServerPart(scenarioNumber);
    if (m_starttls) {
        m_starttls = false;
        qDebug() << "start tls";
        static_cast<QSslSocket *>(socket)->startServerEncryption();
    }
}

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

m_clientSockets << m_tcpServer->nextPendingConnection();
    connect(m_clientSockets.last(), SIGNAL(readyRead()), this, SLOT(dataAvailable()));
    m_clientParsers << new KIMAP::ImapStreamParser(m_clientSockets.last(), true);

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

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

void FakeServer::setEncrypted(QSsl::SslProtocol protocol)
{
    m_encrypted = true;
    m_sslProtocol = protocol;
}

void FakeServer::setWaitForStartTls(bool wait)
{
    m_waitForStartTls = wait;
}

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

connect(m_tcpServer, SIGNAL(newConnection()), this, SLOT(newConnection()));

exec();

qDeleteAll(m_clientParsers);
    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);

foreach (const QList<QByteArray> &scenario, m_scenarios) {
        if (!scenario.isEmpty()) {
            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::compareReceived(const QByteArray &received, const QByteArray &expected) const
{
    QCOMPARE(QString::fromUtf8(received), QString::fromUtf8(expected));
    QCOMPARE(received, expected);
}

void FakeServer::readClientPart(int scenarioNumber)
{
    QList<QByteArray> scenario = m_scenarios[scenarioNumber];
    KIMAP::ImapStreamParser *clientParser = m_clientParsers[scenarioNumber];

while (!scenario.isEmpty() &&
            scenario.first().startsWith("C: ")) {
        QByteArray received = "C: " + clientParser->readUntilCommandEnd().trimmed();
        QByteArray expected = scenario.takeFirst();
        if (expected.contains("C: SKIP")) {
            continue;
        }
        compareReceived(received, expected);
        if (received.contains("STARTTLS")) {
            m_starttls = true;
        }
    }

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

m_scenarios[scenarioNumber] = scenario;
}
07070100000018000081A40000000200000002000000015ED129EC00001E0C000000000000000000000000000000000000004A00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/fakeserver.h/*
   Copyright (C) 2008 Omat Holding B.V. <info@omat.nl>

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

This program 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
   General Public License for more details.

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

#ifndef FAKESERVER_H
#define FAKESERVER_H

#include <QTcpSocket>
#include <QTcpServer>
#include <QThread>
#include <QMutex>
#include <QSsl>

namespace KIMAP
{
class ImapStreamParser;
}

Q_DECLARE_METATYPE(QList<QByteArray>)

/**
 * Pretends to be an IMAP server for the purposes of unit tests.
 *
 * FakeServer does not really understand the IMAP protocol.  Instead,
 * you give it a script, or scenario, that lists how an IMAP session
 * exchange should go.  When it receives the client parts of the
 * scenario, it will respond with the following server parts.
 *
 * The server can be furnished with several scenarios.  The first
 * scenario will be played out to the first client that connects, the
 * second scenario to the second client connection and so on.
 *
 * The fake server runs as a separate thread in the same process it
 * is started from, and listens for connections on port 5989 on the
 * local machine.
 *
 * Scenarios are in the form of protocol messages, with a tag at the
 * start to indicate whether it is message that will be sent by the
 * client ("C:") or a response that should be sent by the server
 * ("S:").  For example:
 * @code
 * C: A000001 LIST "" *
 * S: * LIST ( \HasChildren ) / INBOX
 * S: * LIST ( \HasNoChildren ) / INBOX/&AOQ- &APY- &APw- @ &IKw-
 * S: * LIST ( \HasChildren ) / INBOX/lost+found
 * S: * LIST ( \HasNoChildren ) / "INBOX/lost+found/Calendar Public-20080128"
 * S: A000001 OK LIST completed
 * @endcode
 *
 * A line starting with X indicates that the connection should be
 * closed by the server.  This should be the last line in the
 * scenario.  For example, the following simulates the server closing
 * the connection after receiving too many bad commands:
 * @code
 * C: A000001 madhatter
 * S: A000001 BAD Command madhatter
 * X
 * @endcode
 *
 * FakeServer::preauth() and FakeServer::greeting() provide standard
 * PREAUTH and OK responses, respectively, that can be used (unmodified)
 * as the first line of a scenario.
 *
 * A typical usage is something like
 * @code
 * QList<QByteArray> scenario;
 * scenario << FakeServer::preauth()
 *          << "C: A000001 CAPABILITY"
 *          << "S: * CAPABILITY IMAP4rev1 STARTTLS AUTH=GSSAPI"
 *          << "S: A000001 OK CAPABILITY completed";
 *
 * FakeServer fakeServer;
 * fakeServer.setScenario( scenario );
 * fakeServer.startAndWait();
 *
 * KIMAP::Session session( QStringLiteral("127.0.0.1"), 5989 );
 * KIMAP::CapabilitiesJob *job = new KIMAP::CapabilitiesJob(&session);
 * QVERIFY( job->exec() );
 * // check the returned capabilities
 *
 * fakeServer.quit();
 * @endcode
 */
class FakeServer : public QThread
{
    Q_OBJECT

public:
    /**
     * Get the default PREAUTH response
     *
     * This is the initial PREAUTH message that the server
     * sends at the start of a session to indicate that the
     * user is already authenticated by some other mechanism.
     *
     * Can be used as the first line in a scenario where
     * you want to skip the LOGIN stage of the protocol.
     */
    static QByteArray preauth();
    /**
     * Get the default greeting
     *
     * This is the initial OK message that the server sends at the
     * start of a session to indicate that a LOGIN is required.
     *
     * Can be used as the first line in a scenario where
     * you want to use the LOGIN command.
     */
    static QByteArray greeting();

explicit FakeServer(QObject *parent = nullptr);
    ~FakeServer();

/**
     * Sets the encryption mode used by the server socket.
     */
    void setEncrypted(QSsl::SslProtocol protocol);

/**
     * Won't start encryption until client sends STARTTLS
     */
    void setWaitForStartTls(bool wait);

/**
     * Starts the server and waits for it to be ready
     *
     * You should use this instead of start() to avoid race conditions.
     */
    void startAndWait();

/**
     * Starts the fake IMAP server
     *
     * You should not call this directly.  Use start() instead.
     *
     * @reimp
     */
    void run() override;

/**
     * Removes any previously-added scenarios, and adds a new one
     *
     * After this, there will only be one scenario, and so the fake
     * server will only be able to service a single request.  More
     * scenarios can be added with addScenario, though.
     *
     * @see addScenario()\n
     * addScenarioFromFile()
     */
    void setScenario(const QList<QByteArray> &scenario);

/**
     * Adds a new scenario
     *
     * Note that scenarios will be used in the order that clients
     * connect.  If this is the 5th scenario that has been added
     * (bearing in mind that setScenario() resets the scenario
     * count), it will be used to service the 5th client that
     * connects.
     *
     * @see addScenarioFromFile()
     *
     * @param scenario  the scenario as a list of messages
     */
    void addScenario(const QList<QByteArray> &scenario);
    /**
     * Adds a new scenario from a local file
     *
     * Note that scenarios will be used in the order that clients
     * connect.  If this is the 5th scenario that has been added
     * (bearing in mind that setScenario() resets the scenario
     * count), it will be used to service the 5th client that
     * connects.
     *
     * @see addScenario()
     *
     * @param fileName  the name of the file that contains the
     *                  scenario; it will be split at line
     *                  boundaries, and excess whitespace will
     *                  be trimmed from the start and end of lines
     */
    void addScenarioFromFile(const QString &fileName);

/**
     * Checks whether a particular scenario has completed
     *
     * @param scenarioNumber  the number of the scenario to check,
     *                        in order of addition/client connection
     */
    bool isScenarioDone(int scenarioNumber) const;
    /**
     * Whether all the scenarios that were added to the fake
     * server have been completed.
     */
    bool isAllScenarioDone() const;

protected:
    /**
     * Whether the received content is the same as the expected.
     * Use QCOMPARE, if creating subclasses.
     */
    virtual void compareReceived(const QByteArray &received, const QByteArray &expected) 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;
    mutable QMutex m_mutex;
    QList<QTcpSocket *> m_clientSockets;
    QList<KIMAP::ImapStreamParser *> m_clientParsers;
    bool m_encrypted;
    bool m_starttls;
    bool m_waitForStartTls = false;
    QSsl::SslProtocol m_sslProtocol;
};

#endif
07070100000019000081A40000000200000002000000015ED129EC000008F2000000000000000000000000000000000000004900000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/mockjob.cpp/*
    This file is part of the KDE project
    Copyright (C) 2008 Kevin Ottens <ervin@kde.org>

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.

You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */

#include "mockjob.h"

#include "job_p.h"
#include "session.h"
#include "session_p.h"
#include <KLocalizedString>
#include <QTimer>

class MockJobPrivate : public KIMAP::JobPrivate
{
public:
    MockJobPrivate(KIMAP::Session *session, const QString &name)
        : KIMAP::JobPrivate(session, name),
          timeout(10)
    { }

~MockJobPrivate() { }

QByteArray command;
    int timeout;
};

MockJob::MockJob(KIMAP::Session *session)
    : KIMAP::Job(*new MockJobPrivate(session, i18n("Mock")))
{
}

void MockJob::doStart()
{
    Q_D(MockJob);
    if (isNull()) {
        QTimer::singleShot(d->timeout, this, SLOT(done()));
    } else {
        d->sessionInternal()->setSocketTimeout(d->timeout);
        d->tags << d->sessionInternal()->sendCommand(d->command);
    }
}

void MockJob::done()
{
    emitResult();
}

void MockJob::setCommand(const QByteArray &command)
{
    Q_D(MockJob);
    d->command = command;
}

QByteArray MockJob::command() const
{
    Q_D(const MockJob);
    return d->command;
}

void MockJob::setTimeout(int timeout)
{
    Q_D(MockJob);
    d->timeout = timeout;
}

int MockJob::timeout() const
{
    Q_D(const MockJob);
    return d->timeout;
}

bool MockJob::isNull() const
{
    Q_D(const MockJob);
    return d->command.isEmpty();
}
0707010000001A000081A40000000200000002000000015ED129EC00000846000000000000000000000000000000000000004700000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/mockjob.h/*
    This file is part of the KDE project
    Copyright (C) 2008 Kevin Ottens <ervin@kde.org>

#ifndef MOCKJOB_H
#define MOCKJOB_H

#include <kimap/job.h>

class MockJobPrivate;

/**
 * Provides an easy way to send an arbitrary IMAP client command.
 */
class MockJob : public KIMAP::Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(MockJob)

public:
    MockJob(KIMAP::Session *session);

/**
     * Sets the command to execute.
     *
     * This should not include the command tag.
     */
    void setCommand(const QByteArray &command);
    /**
     * The command that will be sent.
     */
    QByteArray command() const;
    /**
     * Sets the timeout before the job completes.
     */
    void setTimeout(int timeout);
    /**
     * The timeout used by the job.
     */
    int timeout() const;
    /**
     * Whether the command is empty.
     *
     * Equivalent to command().isEmpty().
     *
     * @return @c true if no command is set, @c false otherwise
     */
    bool isNull() const;

/**
     * Starts the job.
     *
     * Do not call this directly.  Use start() instead.
     *
     * @reimp
     */
    void doStart() override;

private Q_SLOTS:
    void done();
};

#endif
0707010000001B000081A40000000200000002000000015ED129EC00001243000000000000000000000000000000000000004B00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/sslserver.cpp/*
   Copyright (C) 2013 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "sslserver.h"

#include <QSslKey>
#include <QSslConfiguration>
#include <QDebug>

static QByteArray staticCert()
{
    //a dummy certificate
    return QByteArray(
               "-----BEGIN CERTIFICATE-----\n\
MIIB+zCCAWQCCQDBBi7xZ2944DANBgkqhkiG9w0BAQUFADBCMQswCQYDVQQGEwJY\n\
WDEVMBMGA1UEBwwMRGVmYXVsdCBDaXR5MRwwGgYDVQQKDBNEZWZhdWx0IENvbXBh\n\
bnkgTHRkMB4XDTEzMTIwNTA5MDcxNVoXDTQxMDQyMjA5MDcxNVowQjELMAkGA1UE\n\
BhMCWFgxFTATBgNVBAcMDERlZmF1bHQgQ2l0eTEcMBoGA1UECgwTRGVmYXVsdCBD\n\
b21wYW55IEx0ZDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAyuZdeqTgzX2E\n\
Q+tOj8/QzT8jHOUvwleqv56hAOEbZ5pLhYPesaSqV0lADiYHKjCRVIrhJQXePf7y\n\
MrJ3zE6hbHEMoIj+ku6ttNQkfJif30wmbXxLXO+RqraYgJW730kcbi2Jyq7ciEC1\n\
SVeiIaaiV2yUFBc/ARDFBc7733Y053UCAwEAATANBgkqhkiG9w0BAQUFAAOBgQAE\n\
BmB+mGtQzdmOAPbRYegA2ybuUARnW467qMOQpj5dV2LN+bizCbqrsz2twFKWS7oK\n\
EiC1bd6EGHnF6inFksUwODqeb+rjQ85pFBWskG51LWvX2/hoS+0x2V37vUYMxnDH\n\
rOEQiDe3oerErB0x9FMWk7VivEqO5HGEdxy7fGl3vg==\n\
-----END CERTIFICATE-----");
}

static QByteArray staticKey()
{
    //a dummy key without password
    return QByteArray(
               "-----BEGIN RSA PRIVATE KEY-----\n\
MIICXgIBAAKBgQDK5l16pODNfYRD606Pz9DNPyMc5S/CV6q/nqEA4RtnmkuFg96x\n\
pKpXSUAOJgcqMJFUiuElBd49/vIysnfMTqFscQygiP6S7q201CR8mJ/fTCZtfEtc\n\
75GqtpiAlbvfSRxuLYnKrtyIQLVJV6IhpqJXbJQUFz8BEMUFzvvfdjTndQIDAQAB\n\
AoGBAIdNfXLGtl5x4BzGspn2NEBaZRjkwKdxfJzRtH34nyTEYK5FVODTdQBGCaAl\n\
vctlndRp1F+y/RQMighCuN6WZM/SdkzxkGGJVzDDuMw0Cwc48aqtMA3A3x/3bQkK\n\
kk2A5sLBc1TuC4DYSP5zkoXDbvBsHHN+tGAaC348Df6of1J1AkEA7ye3W9JUN4uK\n\
2cPrnh7EKwQ2pFypeE/UNQ+LXR9h8XK90mxwiShU9sRFlNIA+pPcZ2aBxoY9m3rJ\n\
4GHitl4ajwJBANkw6xM9IdgjMD8OQonpZTHSrKki/MaSSe9eBJ+WiCkTKL+Y9aTm\n\
28sU7I+j3V38kYf5zyWXkyWmmNaQ4VaU77sCQQDMx7BM0qPEUBtb7lQxt9x3jQsQ\n\
4DtIxupJaP8HhRjDu2Fo7evKthtSlauTC+NErRl7/J1BFa9pE9IK7SZIy/lnAkB6\n\
ssga9k5IbJi1BrlQcCpbG0mvw7RJ+hsKv3KdNc12Zvx+QUuE/WbuM8Pw4gINNsKA\n\
rv/3nMnkW1m83dxvrXRBAkEAmy3nO9HXdcKtSseseLJ6h9RB/R0XE1EvG8CKvveS\n\
IiVUnppVeiLFa7ItwHOovgqvWVbePd5xl6+yBGxUXznjWA==\n\
-----END RSA PRIVATE KEY-----");
}

SslServer::SslServer(QSsl::SslProtocol protocol, bool waitForStartTls)
    : QTcpServer(),
      mProtocol(protocol),
      mWaitForStartTls(waitForStartTls)
{

}

void SslServer::incomingConnection(qintptr handle)
{
    QSslSocket *socket = new QSslSocket();
    socket->setSocketDescriptor(handle);

socket->setProtocol(mProtocol);

QSslKey ssl_key(staticKey(), QSsl::Rsa);
    QSslCertificate ssl_cert(staticCert());
    Q_ASSERT(QDateTime::currentDateTime() >= ssl_cert.effectiveDate());
    Q_ASSERT(QDateTime::currentDateTime() <= ssl_cert.expiryDate());
    Q_ASSERT(!ssl_cert.isBlacklisted());

socket->setPrivateKey(ssl_key);
    socket->setLocalCertificate(ssl_cert);
#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
    socket->addCaCertificates(QList<QSslCertificate>() << ssl_cert);
#else
    socket->sslConfiguration().addCaCertificates(QList<QSslCertificate>() << ssl_cert);
#endif
    socket->setPeerVerifyMode(QSslSocket::VerifyNone);
    socket->ignoreSslErrors();
    connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error(QAbstractSocket::SocketError)));
    if (!mWaitForStartTls) {
        socket->startServerEncryption();
    }

addPendingConnection(socket);
}

void SslServer::sslErrors(const QList<QSslError> &errors)
{
    for (const QSslError &error : errors) {
        qWarning() << "Received ssl error: " << error.errorString();
    }
    QSslSocket *socket = qobject_cast<QSslSocket *>(QObject::sender());
    if (socket) {
        socket->disconnectFromHost();
    }
}

void SslServer::error(QAbstractSocket::SocketError error)
{
    QSslSocket *socket = qobject_cast<QSslSocket *>(QObject::sender());
    if (socket) {
        qWarning() << socket->errorString();
    }
    qWarning() << error;
}
0707010000001C000081A40000000200000002000000015ED129EC000004F8000000000000000000000000000000000000004900000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/kimaptest/sslserver.h/*
   Copyright (C) 2013 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

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

#ifndef SSLSERVER_H
#define SSLSERVER_H

#include <QTcpServer>
#include <QSslSocket>

class SslServer: public QTcpServer
{
    Q_OBJECT
public:
    SslServer(QSsl::SslProtocol, bool waitForStartTls);
    void incomingConnection(qintptr handle) override;

private Q_SLOTS:
    void sslErrors(const QList<QSslError> &errors);
    void error(QAbstractSocket::SocketError);

private:
    QSsl::SslProtocol mProtocol;
    QSslSocket mSocket;
    bool mWaitForStartTls = false;
};

#endif
0707010000001D000081A40000000200000002000000015ED129EC00002501000000000000000000000000000000000000004300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/listjobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/listjob.h"

#include <QTest>
#include <QSignalSpy>
#include <QDebug>

Q_DECLARE_METATYPE(QList<KIMAP::MailBoxDescriptor>)
Q_DECLARE_METATYPE(QList< QList<QByteArray> >)

class ListJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testList_data()
    {
        QTest::addColumn<bool>("unsubscribed");
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QList<KIMAP::MailBoxDescriptor> >("listresult");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 LIST \"\" *"
                 << "S: * LIST ( \\HasChildren ) / INBOX"
                 << "S: * LIST ( \\HasNoChildren ) / INBOX/&AOQ- &APY- &APw- @ &IKw-"
                 << "S: * LIST ( \\HasChildren ) / INBOX/lost+found"
                 << "S: * LIST ( \\HasNoChildren ) / \"INBOX/lost+found/Calendar Public-20080128\""
                 << "S: A000001 OK LIST completed";
        KIMAP::MailBoxDescriptor descriptor;
        QList<KIMAP::MailBoxDescriptor> listresult;

QTest::newRow("normal") << true << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LIST \"\" *"
                 << "S: * LIST ( \\HasChildren ) / Inbox"
                 << "S: * LIST ( \\HasNoChildren ) / Inbox/&AOQ- &APY- &APw- @ &IKw-"
                 << "S: * LIST ( \\HasChildren ) / Inbox/lost+found"
                 << "S: * LIST ( \\HasNoChildren ) / \"Inbox/lost+found/Calendar Public-20080128\""
                 << "S: A000001 OK LIST completed";
        listresult.clear();

QTest::newRow("lowercase Inbox") << true << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LSUB \"\" *"
                 << "S: * LSUB ( \\HasChildren ) / INBOX"
                 << "S: * LSUB ( ) / INBOX/Calendar/3196"
                 << "S: * LSUB ( \\HasChildren ) / INBOX/Calendar/ff"
                 << "S: * LSUB ( ) / INBOX/Calendar/ff/hgh"
                 << "S: * LSUB ( ) / user/test2/Calendar"
                 << "S: A000001 OK LSUB completed";
        listresult.clear();

descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/Calendar/3196");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/Calendar/ff");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/Calendar/ff/hgh");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("user/test2/Calendar");
        listresult << descriptor;

QTest::newRow("subscribed") << false << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LSUB \"\" *"
                 << "S: * LSUB ( \\HasChildren ) / Inbox"
                 << "S: * LSUB ( ) / Inbox/Calendar/3196"
                 << "S: * LSUB ( \\HasChildren ) / Inbox/Calendar/ff"
                 << "S: * LSUB ( ) / Inbox/Calendar/ff/hgh"
                 << "S: * LSUB ( ) / user/test2/Calendar"
                 << "S: A000001 OK LSUB completed";
        listresult.clear();

descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/Calendar/3196");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/Calendar/ff");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/Calendar/ff/hgh");
        listresult << descriptor;
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("user/test2/Calendar");
        listresult << descriptor;

QTest::newRow("subscribed, lowercase Inbox") << false << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LIST \"\" *"
                 << "S: * LIST ( \\HasNoChildren ) / INBOX/lost+found/Calendar Public-20080128"
                 << "S: A000001 OK LIST completed";
        listresult.clear();
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX/lost+found/Calendar Public-20080128");
        listresult << descriptor;

QTest::newRow("unquoted-space") << true << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LIST \"\" *"
                 << "S: * LIST ( \\NoInferiors ) ( ) INBOX"
                 << "S: A000001 OK LIST completed";
        listresult.clear();
        descriptor.separator = QLatin1Char('/');
        descriptor.name = QStringLiteral("INBOX");
        listresult << descriptor;

QTest::newRow("separator is empty list") << true << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LIST \"\" *"
                 << "S: A000001 BAD command unknown or arguments invalid";
        listresult.clear();
        QTest::newRow("bad") << true << scenario << listresult;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 LIST \"\" *"
                 << "S: A000001 NO list failure";
        QTest::newRow("no") << true << scenario << listresult;
    }

void testList()
    {
        QFETCH(bool, unsubscribed);
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QList<KIMAP::MailBoxDescriptor>, listresult);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::ListJob *job = new KIMAP::ListJob(&session);
        job->setIncludeUnsubscribed(unsubscribed);

QSignalSpy spy(job,
                       SIGNAL(mailBoxesReceived(const QList<KIMAP::MailBoxDescriptor> &,
                                                const QList< QList<QByteArray> > &)));

bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO response", Continue);
        QVERIFY(result);
        if (result) {
            QVERIFY(spy.count() > 0);
            QList<KIMAP::MailBoxDescriptor> mailBoxes;

for (int i = 0; i < spy.count(); ++i) {
                mailBoxes += spy.at(i).at(0).value< QList<KIMAP::MailBoxDescriptor> >();
            }

//qDebug() << mailBoxes.first().name;
            //qDebug() << listresult.first().name;
            QCOMPARE(mailBoxes, listresult);
        }
//     QCOMPARE(job->mailBox(), mailbox);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(ListJobTest)

#include "listjobtest.moc"
0707010000001E000081A40000000200000002000000015ED129EC000029D8000000000000000000000000000000000000004400000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/loginjobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/loginjob.h"

#include <QTest>

class TestUiProxy: public KIMAP::SessionUiProxy
{
    bool ignoreSslError(const KSslErrorUiData &) override
    {
        return true;
    }
};

class LoginJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void shouldHandleLogin_data()
    {
        QTest::addColumn<QString>("user");
        QTest::addColumn<QString>("password");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user\" \"password\""
                 << "S: A000001 OK User logged in";

QTest::newRow("success") << QStringLiteral("user") << QStringLiteral("password") << scenario;

scenario.clear();
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user_bad\" \"password\""
                 << "S: A000001 NO Login failed: authentication failure";

QTest::newRow("wrong login") << "user_bad" << QStringLiteral("password") << scenario;

scenario.clear();
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user\" \"aa\\\"bb\\\\cc[dd ee\""
                 << "S: A000001 OK User logged in";

QTest::newRow("special chars") << QStringLiteral("user") << "aa\"bb\\cc[dd ee" << scenario;

scenario.clear();
        scenario << FakeServer::preauth();

QTest::newRow("already authenticated") << QStringLiteral("user") << QStringLiteral("password") << scenario;
    }

void shouldHandleLogin()
    {
        QFETCH(QString, user);
        QFETCH(QString, password);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session *session = new KIMAP::Session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::LoginJob *login = new KIMAP::LoginJob(session);
        login->setUserName(user);
        login->setPassword(password);
        bool result = login->exec();

QEXPECT_FAIL("wrong login", "Login with bad user name", Continue);
        QEXPECT_FAIL("already authenticated", "Trying to log on an already authenticated session", Continue);
        QVERIFY(result);

fakeServer.quit();
        delete session;
    }

void shouldHandleProxyLogin_data()
    {
        QTest::addColumn<QString>("user");
        QTest::addColumn<QString>("proxy");
        QTest::addColumn<QString>("password");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::greeting()
                 << "C: A000001 AUTHENTICATE PLAIN"
                 << "S: A000001 OK (success)"
                 << "C: A000001 LOGIN \"proxy\" \"user\" \"password\""
                 << "S: A000001 OK User logged in";

QTest::newRow("success") << QStringLiteral("user") << "proxy" << QStringLiteral("password") << scenario;
    }

void shouldHandleProxyLogin()
    {
        QFETCH(QString, user);
        QFETCH(QString, proxy);
        QFETCH(QString, password);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session *session = new KIMAP::Session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::LoginJob *login = new KIMAP::LoginJob(session);
        login->setAuthenticationMode(KIMAP::LoginJob::Plain);
        login->setUserName(user);
        login->setAuthorizationName(proxy);
        login->setPassword(password);
        bool result = login->exec();

QVERIFY(result);

fakeServer.quit();
        delete session;
    }

void shouldSaveServerGreeting_data()
    {
        QTest::addColumn<QString>("greeting");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user\" \"password\""
                 << "S: A000001 OK Welcome John Smith";

QTest::newRow("greeting") << "Welcome John Smith" << scenario;

scenario.clear();
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user\" \"password\""
                 << "S: A000001 OK Welcome John Smith (last login: Feb 21, 2010)";

QTest::newRow("greeting with parenthesis") << "Welcome John Smith (last login: Feb 21, 2010)" << scenario;

scenario.clear();
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user\" \"password\""
                 << "S: A000001 OK";

QTest::newRow("no greeting") << "" << scenario;

scenario.clear();
        scenario << FakeServer::greeting()
                 << "C: A000001 LOGIN \"user\" \"password\""
                 << "S: A000001 NO Login failed: authentication failure";

QTest::newRow("login failed") << "" << scenario;
    }

void shouldSaveServerGreeting()
    {
        QFETCH(QString, greeting);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session *session = new KIMAP::Session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::LoginJob *login = new KIMAP::LoginJob(session);
        login->setUserName(QStringLiteral("user"));
        login->setPassword(QStringLiteral("password"));
        login->exec();

QCOMPARE(login->serverGreeting(), greeting);

fakeServer.quit();
        delete session;
    }

void shouldUseSsl_data()
    {
        QTest::addColumn< QList<QByteArray> >("scenario");
        QTest::addColumn< int >("serverEncryption");

{
            QList<QByteArray> scenario;
            scenario << FakeServer::greeting()
                     << "C: A000001 CAPABILITY"
                     << "S: A000001 OK"
                     << "C: A000002 LOGIN \"user\" \"password\""
                     << "S: A000002 OK";

// SSLv2 support was removed from openssl 1.1
            //QTest::newRow("sslv2") << scenario << static_cast<int>(QSsl::SslV2);

// FIXME: SSLv3-only server is failing, likely openssl configuration problem
            //QTest::newRow("sslv3") << scenario << static_cast<int>(QSsl::SslV3);

//AnySslVersion doesn't mean the server can force a specific version (e.g. openssl always starts with a tls12 hello)
            QTest::newRow("any protocol with anyssl version") << scenario << static_cast<int>(QSsl::AnyProtocol);

QTest::newRow("tlsv10") << scenario << static_cast<int>(QSsl::TlsV1_0);
            QTest::newRow("tlsv11") << scenario << static_cast<int>(QSsl::TlsV1_1);
            QTest::newRow("tlsv12") << scenario << static_cast<int>(QSsl::TlsV1_2);

}
    }

void shouldUseSsl()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(int, serverEncryption);

FakeServer fakeServer;
        fakeServer.setEncrypted(static_cast<QSsl::SslProtocol>(serverEncryption));
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();

KIMAP::Session *session = new KIMAP::Session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SessionUiProxy::Ptr uiProxy(new TestUiProxy);
        session->setUiProxy(uiProxy);

KIMAP::LoginJob *login = new KIMAP::LoginJob(session);
        login->setUserName(QStringLiteral("user"));
        login->setPassword(QStringLiteral("password"));
        login->setEncryptionMode(KIMAP::LoginJob::SSLorTLS);
        QVERIFY(login->exec());

fakeServer.quit();
        delete session;
    }

void shouldUseStartTls_data()
    {
        QTest::addColumn<QList<QByteArray>>("scenario");
        QTest::addColumn<bool>("success");

{
            QList<QByteArray> scenario;
            scenario << FakeServer::greeting()
                     << "C: A000001 CAPABILITY"
                     << "S: * CAPABILITY IMAP4rev1 STARTTLS"
                     << "S: A000001 OK CAPABILITY completed"
                     << "C: A000002 STARTTLS"
                     << "S: A000002 OK"
                     << "C: A000003 CAPABILITY"
                     << "S: * CAPABILITY IMAP4rev1"
                     << "S: A000003 OK CAPABILITY completed"
                     << "C: A000004 LOGIN \"user\" \"password\""
                     << "S: A000004 OK";
            QTest::newRow("STARTTLS supported") << scenario << true;
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::greeting()
                     << "C: A000001 CAPABILITY"
                     << "S: * CAPABILITY IMAP4rev1"
                     << "S: A000001 OK CAPABILITY completed";

QTest::newRow("STARTTLS not supported") << scenario << false;
        }
    }

void shouldUseStartTls()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(bool, success);

FakeServer fakeServer;
        fakeServer.setEncrypted(QSsl::AnyProtocol);
        fakeServer.setWaitForStartTls(true);
        fakeServer.setScenario(scenario);
        fakeServer.startAndWait();

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SessionUiProxy::Ptr uiProxy(new TestUiProxy);
        session.setUiProxy(uiProxy);

KIMAP::LoginJob login(&session);
        login.setUserName(QStringLiteral("user"));
        login.setPassword(QStringLiteral("password"));
        login.setEncryptionMode(KIMAP::LoginJob::STARTTLS);
        QCOMPARE(login.exec(), success);

fakeServer.quit();
    }
};

QTEST_GUILESS_MAIN(LoginJobTest)

#include "loginjobtest.moc"
0707010000001F000081A40000000200000002000000015ED129EC000009B1000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/logoutjobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/logoutjob.h"
#include "kimap/loginjob.h"

#include <QTest>

class LogoutJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testLogout()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::preauth()
                               << "C: A000001 LOGOUT"
                               << "S: A000001 OK LOGOUT completed"
                              );
        fakeServer.startAndWait();

KIMAP::Session *session = new KIMAP::Session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::LogoutJob *logout = new KIMAP::LogoutJob(session);
        QVERIFY(logout->exec());

fakeServer.quit();
        delete session;
    }

void testLogoutUntagged()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::preauth()
                               << "C: A000001 LOGOUT"
                               << "S: * some untagged response"
                               << "S: A000001 OK LOGOUT completed"
                              );
        fakeServer.startAndWait();

KIMAP::Session *session = new KIMAP::Session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::LogoutJob *logout = new KIMAP::LogoutJob(session);
        QVERIFY(logout->exec());

fakeServer.quit();
        delete session;
    }

};

QTEST_GUILESS_MAIN(LogoutJobTest)

#include "logoutjobtest.moc"
07070100000020000081A40000000200000002000000015ED129EC00000AF4000000000000000000000000000000000000004300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/movejobtest.cpp/*
   Copyright (C) 2016 Daniel Vrátil <dvratil@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/imapset.h"
#include "../src/movejob.h"

#include <QTest>

class MoveJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testMove_data()
    {
        QTest::addColumn<bool>("uidBased");
        QTest::addColumn<qint64>("id");
        QTest::addColumn<qint64>("resultUid");
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 MOVE 3 \"foo\""
                 << "S: * OK [COPYUID 12345 3 7]"
                 << "S: A000001 OK MOVE completed";

QTest::newRow("not uid based") << false << qint64(3) << qint64(7)
                                       << QStringLiteral("foo") << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 UID MOVE 1024 \"bar\""
                 << "S: * OK [COPYUID 12346 4 2048]"
                 << "S: A000001 OK MOVE completed";

QTest::newRow("uid based") << true << qint64(1024) << qint64(2048)
                                   << QStringLiteral("bar") << scenario;
    }

void testMove()
    {
        QFETCH(bool, uidBased);
        QFETCH(qint64, id);
        QFETCH(qint64, resultUid);
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

auto job = new KIMAP::MoveJob(&session);
        job->setMailBox(mailbox);
        job->setUidBased(uidBased);
        job->setSequenceSet(KIMAP::ImapSet(id));
        bool result = job->exec();
        QVERIFY(result);
        QCOMPARE(job->resultingUids(), KIMAP::ImapSet(resultUid));

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(MoveJobTest)

#include "movejobtest.moc"

07070100000021000081A40000000200000002000000015ED129EC00001B46000000000000000000000000000000000000004800000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/quotarootjobtest.cpp/*
   Copyright (C) 2011 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/getquotarootjob.h"

#include <QTest>

Q_DECLARE_METATYPE(QList<qint64>)

class QuotaRootJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testGetQuotaRoot_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QList<QByteArray> >("roots");
        QTest::addColumn<QList<QByteArray> >("resources");
        QTest::addColumn<QList<qint64> >("usages");
        QTest::addColumn<QList<qint64> >("limits");
        QTest::addColumn<QList<QByteArray> >("scenario");

QList<QByteArray> roots;
        QList<QByteArray> resources;
        QList<qint64> usages;
        QList<qint64> limits;
        QList<QByteArray> scenario;
        roots << "";
        resources << "STORAGE";
        limits << 512;
        usages << 10;
        scenario << FakeServer::preauth()
                 << "C: A000001 GETQUOTAROOT \"INBOX\""
                 << "S: * QUOTAROOT INBOX \"\" "
                 << "S: * QUOTA \"\" (STORAGE 10 512)"
                 << "S: A000001 OK GETQUOTA completed";
        QTest::newRow("one root, one resource") << "INBOX" << roots << resources << usages << limits << scenario;

roots.clear();
        resources.clear();
        usages.clear();
        limits.clear();
        scenario.clear();
        roots << "";
        resources << "STORAGE" << "MESSAGE";
        usages << 10 << 8221;
        limits << 512 << 20000;
        scenario << FakeServer::preauth()
                 << "C: A000001 GETQUOTAROOT \"INBOX\""
                 << "S: * QUOTAROOT INBOX \"\" "
                 << "S: * QUOTA \"\" (STORAGE 10 512)"
                 << "S: * QUOTA \"\" ( MESSAGE 8221 20000 ) "
                 << "S: A000001 OK GETQUOTA completed";
        QTest::newRow("one root, multiple resource") << "INBOX" << roots << resources << usages << limits << scenario;

roots.clear();
        resources.clear();
        usages.clear();
        limits.clear();
        scenario.clear();
        roots << "root1" << "root2";
        resources << "STORAGE" << "MESSAGE";
        usages << 10 << 8221 << 30 << 100;
        limits << 512 << 20000 << 5124 << 120000;
        scenario << FakeServer::preauth()
                 << "C: A000001 GETQUOTAROOT \"INBOX\""
                 << "S: * QUOTAROOT INBOX \"root1\" root2 "
                 << "S: * QUOTA \"root1\" (STORAGE 10 512)"
                 << "S: * QUOTA \"root1\" ( MESSAGE 8221 20000 ) "
                 << "S: * QUOTA \"root2\" ( MESSAGE 100 120000 ) "
                 << "S: * QUOTA \"root2\" (STORAGE 30 5124)"
                 << "S: A000001 OK GETQUOTA completed";
        QTest::newRow("multiple roots, multiple resource") << "INBOX" << roots << resources << usages << limits << scenario;

roots.clear();
        resources.clear();
        usages.clear();
        limits.clear();
        scenario.clear();
        roots << "";
        resources << "STORAGE" << "MESSAGE";
        usages << 10 << 8221;
        limits << 512 << 20000;
        scenario << FakeServer::preauth()
                 << "C: A000001 GETQUOTAROOT \"INBOX\""
                 << "S: * QUOTAROOT INBOX"
                 << "S: * QUOTA (STORAGE 10 512)"
                 << "S: * QUOTA ( MESSAGE 8221 20000 ) "
                 << "S: A000001 OK GETQUOTA completed";
        QTest::newRow("no rootname, multiple resource") << "INBOX" << roots << resources << usages << limits << scenario;

roots.clear();
        resources.clear();
        usages.clear();
        limits.clear();
        scenario.clear();
        roots << "";
        resources << "STORAGE";
        limits << 512;
        usages << 10;
        scenario << FakeServer::preauth()
                 << "C: A000001 GETQUOTAROOT \"INBOX\""
                 << "S: * QUOTAROOT INBOX \"\" "
                 << "S: * QUOTA (STORAGE 10 512)"
                 << "S: A000001 OK GETQUOTA completed";
        QTest::newRow("no rootname in QUOTA, one resource") << "INBOX" << roots << resources << usages << limits << scenario;

roots.clear();
        resources.clear();
        usages.clear();
        limits.clear();
        scenario.clear();
        roots << "";
        resources << "STORAGE";
        limits << 512;
        usages << 10;
        scenario << FakeServer::preauth()
                 << "C: A000001 GETQUOTAROOT \"INBOX\""
                 << "S: * QUOTAROOT INBOX \"root1\" "
                 << "S: * QUOTA \"root2\" (STORAGE 10 512)"
                 << "S: A000001 OK GETQUOTA completed";
        QTest::newRow("rootname missmatch") << "INBOX" << roots << resources << usages << limits << scenario;
    }

void testGetQuotaRoot()
    {
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, roots);
        QFETCH(QList<QByteArray>, resources);
        QFETCH(QList<qint64>, usages);
        QFETCH(QList<qint64>, limits);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::GetQuotaRootJob *job = new KIMAP::GetQuotaRootJob(&session);
        job->setMailBox(mailbox);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO response", Continue);
        QVERIFY(result);
        QEXPECT_FAIL("rootname missmatch" , "Expected failure on rootname missmatch in QUOTAROOT and QUOTA response", Abort);
        QCOMPARE(job->roots(), roots);
        for (int rootIdx = 0; rootIdx < roots.size(); rootIdx++) {
            const QByteArray &root = roots[rootIdx];
            for (int i = 0; i < resources.size(); i++) {
                int idx = i + rootIdx * roots.size();
                QByteArray resource = resources[i];
                QCOMPARE(job->limit(root, resource), limits[idx]);
                QCOMPARE(job->usage(root, resource), usages[idx]);
            }
        }

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(QuotaRootJobTest)

#include "quotarootjobtest.moc"
07070100000022000081A40000000200000002000000015ED129EC00000BC2000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/renamejobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/renamejob.h"

#include <QTest>

class RenameJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testRename_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QString>("newname");
        QTest::addColumn<QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 RENAME \"INBOX\" \"oldmail\""
                 << "S: A000001 OK RENAME completed";
        QTest::newRow("good") << "INBOX" << "oldmail" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 RENAME \"INBOX-FAIL-BAD\" \"oldmail-bad\""
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << "INBOX-FAIL-BAD"  << "oldmail-bad" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 RENAME \"INBOX-FAIL-NO\" \"oldmail-no\""
                 << "S: A000001 NO rename failure";
        QTest::newRow("no") << "INBOX-FAIL-NO" << "oldmail-no" << scenario;
    }

void testRename()
    {
        QFETCH(QString, mailbox);
        QFETCH(QString, newname);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::RenameJob *job = new KIMAP::RenameJob(&session);
        job->setSourceMailBox(mailbox);
        job->setDestinationMailBox(newname);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD response", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO response", Continue);
        QVERIFY(result);
        QCOMPARE(job->sourceMailBox(), mailbox);
        QCOMPARE(job->destinationMailBox(), newname);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(RenameJobTest)

#include "renamejobtest.moc"
07070100000023000081A40000000200000002000000015ED129EC000021C8000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/searchjobtest.cpp/*
 * Copyright (C) 2013  Daniel Vrátil <dvratil@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/loginjob.h"
#include "kimap/session.h"
#include "kimap/searchjob.h"

#include <QTest>

typedef QPair< KIMAP::SearchJob::SearchCriteria, QByteArray > SearchCriteriaValuePair;

Q_DECLARE_METATYPE(QList<SearchCriteriaValuePair>)
Q_DECLARE_METATYPE(KIMAP::SearchJob::SearchLogic)
Q_DECLARE_METATYPE(KIMAP::Term)

#define searchPair(a,b) qMakePair<KIMAP::SearchJob::SearchCriteria, QByteArray>( a, b )

class SearchJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testSearch_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<bool>("uidbased");
        QTest::addColumn<int>("expectedResultsCount");
        QTest::addColumn<KIMAP::SearchJob::SearchLogic>("searchLogic");
        QTest::addColumn<QList<SearchCriteriaValuePair> >("searchCriteria");

QList<QByteArray> scenario;
        QList<SearchCriteriaValuePair> criteria;
        scenario << FakeServer::preauth()
                 << "C: A000001 UID SEARCH HEADER Message-Id <12345678@mail.box>"
                 << "S: * SEARCH 10 12"
                 << "S: A000001 OK search done";

criteria << searchPair(KIMAP::SearchJob::Header, "Message-Id <12345678@mail.box>");
        QTest::newRow("uidbased header search") << scenario << true << 2 << KIMAP::SearchJob::And << criteria;

scenario.clear();
        criteria.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SEARCH OR (NEW) (HEADER Message-Id <12345678@mail.box>)"
                 << "S: * SEARCH"
                 << "S: A000001 OK search done";

criteria << searchPair(KIMAP::SearchJob::New, QByteArray())
                 << searchPair(KIMAP::SearchJob::Header, "Message-Id <12345678@mail.box>");
        QTest::newRow("OR search with no results") << scenario << false << 0 << KIMAP::SearchJob::Or << criteria;

scenario.clear();
        criteria.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SEARCH TO {25}\r\n<testuser@kde.testserver>"
                 << "S: * SEARCH 1"
                 << "S: A000001 OK search done";
        criteria << searchPair(KIMAP::SearchJob::To, "<testuser@kde.testserver>");
        QTest::newRow("literal data search") << scenario << false << 1 << KIMAP::SearchJob::And << criteria;

scenario.clear();
        criteria.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 UID SEARCH NOT (NEW)"
                 << "S: * SEARCH 1 2 3 4 5 6"
                 << "S: A000001 OK search done";
        criteria << searchPair(KIMAP::SearchJob::New, QByteArray());
        QTest::newRow("uidbased NOT NEW search") << scenario << true << 6 << KIMAP::SearchJob::Not << criteria;
    }

void testSearch()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(bool, uidbased);
        QFETCH(int, expectedResultsCount);
        QFETCH(KIMAP::SearchJob::SearchLogic, searchLogic);
        QFETCH(QList<SearchCriteriaValuePair>, searchCriteria);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SearchJob *job = new KIMAP::SearchJob(&session);
        job->setUidBased(uidbased);
        job->setSearchLogic(searchLogic);
        for (const SearchCriteriaValuePair &pair : qAsConst(searchCriteria)) {
            if (pair.second.isEmpty()) {
                job->addSearchCriteria(pair.first);
            } else {
                job->addSearchCriteria(pair.first, pair.second);
            }
        }

bool result = job->exec();
        QVERIFY(result);
        if (result) {
            QVector<qint64> foundItems = job->results();
            QCOMPARE(foundItems.size(), expectedResultsCount);
        }

fakeServer.quit();
    }

void testSearchTerm_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<bool>("uidbased");
        QTest::addColumn<int>("expectedResultsCount");
        QTest::addColumn<KIMAP::Term>("searchTerm");

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 UID SEARCH HEADER Message-Id \"<12345678@mail.box>\""
                     << "S: * SEARCH 10 12"
                     << "S: A000001 OK search done";

QTest::newRow("uidbased header search") << scenario << true << 2 << KIMAP::Term(QStringLiteral("Message-Id"), QStringLiteral("<12345678@mail.box>"));
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SEARCH OR NEW HEADER Message-Id \"<12345678@mail.box>\""
                     << "S: * SEARCH"
                     << "S: A000001 OK search done";

QTest::newRow("OR search with no results") << scenario << false << 0 << KIMAP::Term(KIMAP::Term::Or, QVector<KIMAP::Term>() << KIMAP::Term(KIMAP::Term::New) << KIMAP::Term(QStringLiteral("Message-Id"), QStringLiteral("<12345678@mail.box>")));
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SEARCH TO \"<testuser@kde.testserver>\""
                     << "S: * SEARCH 1"
                     << "S: A000001 OK search done";
            QTest::newRow("literal data search") << scenario << false << 1 << KIMAP::Term(KIMAP::Term::To, QStringLiteral("<testuser@kde.testserver>"));
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 UID SEARCH NOT NEW"
                     << "S: * SEARCH 1 2 3 4 5 6"
                     << "S: A000001 OK search done";
            QTest::newRow("uidbased NOT NEW search") << scenario << true << 6 << KIMAP::Term(KIMAP::Term::New).setNegated(true);
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 UID SEARCH OR HEADER Message-Id \"<1234567@mail.box>\" (OR HEADER Message-Id \"<7654321@mail.box>\" (OR HEADER Message-Id \"<abcdefg@mail.box>\" HEADER Message-Id \"<gfedcba@mail.box>\"))"
                     << "S: * SEARCH 1 2 3 4"
                     << "S: A000001 OK search done";
            KIMAP::Term term{KIMAP::Term::Or, {KIMAP::Term{QStringLiteral("Message-Id"), QStringLiteral("<1234567@mail.box>")},
                                               KIMAP::Term{QStringLiteral("Message-Id"), QStringLiteral("<7654321@mail.box>")},
                                               KIMAP::Term{QStringLiteral("Message-Id"), QStringLiteral("<abcdefg@mail.box>")},
                                               KIMAP::Term{QStringLiteral("Message-Id"), QStringLiteral("<gfedcba@mail.box>")}}};
            QTest::newRow("OR with multiple subterms") << scenario << true << 4 << term;
        }
    }

void testSearchTerm()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(bool, uidbased);
        QFETCH(int, expectedResultsCount);
        QFETCH(KIMAP::Term, searchTerm);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SearchJob *job = new KIMAP::SearchJob(&session);
        job->setUidBased(uidbased);
        job->setTerm(searchTerm);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(SearchJobTest)

#include "searchjobtest.moc"
07070100000024000081A40000000200000002000000015ED129EC00001F19000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/selectjobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/loginjob.h"
#include "kimap/session.h"
#include "kimap/selectjob.h"

#include <QTest>

class SelectJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testSingleSelect_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QList<QByteArray> >("flags");
        QTest::addColumn<QList<QByteArray> >("permanentflags");
        QTest::addColumn<int>("messagecount");
        QTest::addColumn<int>("recentcount");
        QTest::addColumn<int>("firstUnseenIndex");
        QTest::addColumn<qint64>("uidValidity");
        QTest::addColumn<qint64>("nextUid");
        QTest::addColumn<quint64>("highestmodseq");
        QTest::addColumn<bool>("condstoreEnabled");
        QTest::addColumn<bool>("readonly");

QList<QByteArray> scenario;
        QList<QByteArray> flags;
        QList<QByteArray> permanentflags;
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX\" (CONDSTORE)"
                 << "S: * 172 EXISTS"
                 << "S: * 1 RECENT"
                 << "S: * OK [UNSEEN 12] Message 12 is first unseen"
                 << "S: * OK [UIDVALIDITY 3857529045] UIDs valid"
                 << "S: * OK [UIDNEXT 4392] Predicted next UID"
                 << "S: * OK [HIGHESTMODSEQ 123456789]"
                 << "S: * FLAGS (\\Answered \\Flagged \\Deleted \\Seen \\Draft)"
                 << "S: * OK [PERMANENTFLAGS (\\Deleted \\Seen \\*)] Limited"
                 << "S: A000001 OK [READ-WRITE] SELECT completed";

flags << "\\Answered" << "\\Flagged" << "\\Deleted" << "\\Seen" << "\\Draft";
        permanentflags << "\\Deleted" << "\\Seen" << "\\*";
        QTest::newRow("good") << scenario << flags << permanentflags << 172 << 1 << 12 << (qint64)3857529045 << (qint64)4392 << (quint64)123456789 << true << false;

scenario.clear();
        flags.clear();
        permanentflags.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX\""
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << scenario << flags << permanentflags << 0 << 0 << 0 << (qint64)0 << (qint64)0 << (quint64)0 << false << false;

scenario.clear();
        flags.clear();
        permanentflags.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SELECT \"INBOX\""
                 << "S: A000001 NO select failure";
        QTest::newRow("no") << scenario << flags << permanentflags << 0 << 0 << 0 << (qint64)0 << (qint64)0 << (quint64)0 << false << false;
    }

void testSingleSelect()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QList<QByteArray>, flags);
        QFETCH(QList<QByteArray>, permanentflags);
        QFETCH(int, messagecount);
        QFETCH(int, recentcount);
        QFETCH(int, firstUnseenIndex);
        QFETCH(qint64, uidValidity);
        QFETCH(qint64, nextUid);
        QFETCH(quint64, highestmodseq);
        QFETCH(bool, condstoreEnabled);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SelectJob *job = new KIMAP::SelectJob(&session);
        job->setCondstoreEnabled(condstoreEnabled);
        job->setMailBox(QStringLiteral("INBOX"));
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD scenario", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO scenario", Continue);
        QVERIFY(result);
        if (result) {
            QCOMPARE(job->flags(), flags);
            QCOMPARE(job->permanentFlags(), permanentflags);
            QCOMPARE(job->messageCount(), messagecount);
            QCOMPARE(job->recentCount(), recentcount);
            QCOMPARE(job->firstUnseenIndex(), firstUnseenIndex);
            QCOMPARE(job->uidValidity(), uidValidity);
            QCOMPARE(job->nextUid(), nextUid);
            QCOMPARE(job->highestModSequence(), highestmodseq);
        }

fakeServer.quit();
    }

void testSeveralSelect()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::preauth()
                               << "C: A000001 SELECT \"INBOX\""
                               << "S: A000001 OK [READ-WRITE] SELECT completed"
                               << "C: A000002 SELECT \"INBOX/Foo\""
                               << "S: A000002 OK [READ-WRITE] SELECT completed"
                              );
        fakeServer.startAndWait();

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SelectJob *job = new KIMAP::SelectJob(&session);
        job->setMailBox(QStringLiteral("INBOX"));
        QVERIFY(job->exec());

job = new KIMAP::SelectJob(&session);
        job->setMailBox(QStringLiteral("INBOX/Foo"));
        QVERIFY(job->exec());
    }

void testReadOnlySelect_data()
    {
        QTest::addColumn<QList<QByteArray>>("scenario");
        QTest::addColumn<bool>("examine");
        QTest::addColumn<bool>("isReadOnly");

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SELECT \"INBOX\""
                     << "S: A000001 OK [READ-WRITE] SELECT ok";
            QTest::newRow("SELECT rw") << scenario << false << false;
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SELECT \"INBOX\""
                     << "S: A000001 OK SELECT ok";
            QTest::newRow("SELECT rw (without code)") << scenario << false << false;
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SELECT \"INBOX\""
                     << "S: A000001 OK [READ-ONLY] SELECT ok";
            QTest::newRow("SELECT ro") << scenario << false << true;
        }

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 EXAMINE \"INBOX\""
                     << "S: A000001 OK [READ-ONLY] EXAMINE ok";
            QTest::newRow("EXAMINE ro") << scenario << true << true;
        }
    }

void testReadOnlySelect()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(bool, examine);
        QFETCH(bool, isReadOnly);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SelectJob select(&session);
        select.setOpenReadOnly(examine);
        select.setMailBox(QStringLiteral("INBOX"));
        QVERIFY(select.exec());

QCOMPARE(select.isOpenReadOnly(), isReadOnly);
    }
};

QTEST_GUILESS_MAIN(SelectJobTest)

#include "selectjobtest.moc"
07070100000025000081A40000000200000002000000015ED129EC000019F6000000000000000000000000000000000000004A00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/setmetadatajobtest.cpp/*
   Copyright (C) 2013 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/setmetadatajob.h"

#include <QTest>

typedef QMap<QByteArray, QByteArray> MAP;
Q_DECLARE_METATYPE(MAP)

class SetMetadataJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SETMETADATA \"Folder1\" (\"/public/comment\" \"comment2\" \"/shared/comment\" \"Shared comment\")"
                     << "S: A000001 OK SETMETADATA complete";
            QMap<QByteArray, QByteArray> annotations;
            annotations.insert("/public/comment", "comment2");
            annotations.insert("/shared/comment", "Shared comment");
            QTest::newRow("normal") << scenario << "Folder1" << annotations;
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                    << "C: A000001 SETMETADATA \"Folder1\" (\"/public/comment\" {8}\r\ncomment2 \"/shared/comment\" {14}\r\nShared\ncomment)"
                    << "S: A000001 OK SETMETADATA complete";
            QMap<QByteArray, QByteArray> annotations;
            annotations.insert("/shared/comment", "Shared\ncomment");
            annotations.insert("/public/comment", "comment2");
            QTest::newRow( "newline" ) << scenario << "Folder1" << annotations;
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                    << "C: A000001 SETMETADATA \"Folder1\" (\"/shared/comment\" NIL)"
                    << "S: A000001 OK SETMETADATA complete";
            QMap<QByteArray, QByteArray> annotations;
            annotations.insert("/shared/comment","");
            QTest::newRow( "newline" ) << scenario << "Folder1" << annotations;
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                    << "C: A000001 SETMETADATA \"Folder1\" (\"/public/comment\" {12}\r\ncomment\ntest \"/shared/comment\" {3}\r\nNIL)"
                    << "S: A000001 OK SETMETADATA complete";
            QMap<QByteArray, QByteArray> annotations;
            annotations.insert("/shared/comment","");
            annotations.insert("/public/comment", "comment\ntest");
            QTest::newRow( "newline2" ) << scenario << "Folder1" << annotations;
        }
        {
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                    << "C: A000001 SETMETADATA \"Folder1\" (\"/public/comment\" {3}\r\nNIL \"/shared/comment\" {12}\r\ncomment\ntest)"
                    << "S: A000001 OK SETMETADATA complete";
            QMap<QByteArray, QByteArray> annotations;
            annotations.insert("/shared/comment", "comment\ntest");
            annotations.insert("/public/comment","");
            QTest::newRow( "newline2" ) << scenario << "Folder1" << annotations;
        }
    }

void metadata()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QString, mailbox);
        QFETCH(MAP, annotations);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SetMetaDataJob *setMetadataJob = new KIMAP::SetMetaDataJob(&session);
        setMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Metadata);
        setMetadataJob->setMailBox(mailbox);
        foreach (const QByteArray &entry, annotations.keys()) {
            setMetadataJob->addMetaData(entry, annotations[entry]);
        }

QVERIFY(setMetadataJob->exec());

fakeServer.quit();
    }

void annotatemore_data()
    {
        QTest::addColumn<QList<QByteArray> >("scenario");
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn<QMap<QByteArray, QByteArray> >("annotations");
        QTest::addColumn<bool>("legacyMode");

{
            QList<QByteArray> scenario;
            scenario << FakeServer::preauth()
                     << "C: A000001 SETANNOTATION \"Folder1\" \"/comment\" (\"value.shared\" \"Shared comment\")"
                     << "S: A000001 OK annotations changed";

QMap<QByteArray, QByteArray> annotations;
            annotations.insert("/comment", "Shared comment");
            QTest::newRow("normal") << scenario << "Folder1" << annotations << false;
            QTest::newRow("legacy") << scenario << "Folder1" << annotations << true;
        }
    }

void annotatemore()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QString, mailbox);
        QFETCH(MAP, annotations);
        QFETCH(bool, legacyMode);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SetMetaDataJob *setMetadataJob = new KIMAP::SetMetaDataJob(&session);
        setMetadataJob->setServerCapability(KIMAP::MetaDataJobBase::Annotatemore);
        setMetadataJob->setMailBox(mailbox);
        foreach (const QByteArray &entry, annotations.keys()) {
            if (legacyMode) {
                setMetadataJob->setEntry(entry);
                setMetadataJob->addMetaData("value.shared", annotations[entry]);
            } else {
                setMetadataJob->addMetaData(QByteArray("/shared") + entry, annotations[entry]);
            }
        }

QVERIFY(setMetadataJob->exec());

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(SetMetadataJobTest)

#include "setmetadatajobtest.moc"
07070100000026000081A40000000200000002000000015ED129EC00001271000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/statusjobtest.cpp/*
    Copyright (c) 2016 Daniel Vrátil <dvratil@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/loginjob.h"
#include "kimap/session.h"
#include "kimap/statusjob.h"

typedef QList<QPair<QByteArray, qint64>> StatusMap;
Q_DECLARE_METATYPE(StatusMap)

class StatusJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testStatus_data()
    {
        QTest::addColumn<QList<QByteArray>>("scenario");
        QTest::addColumn<QList<QByteArray>>("dataItems");
        QTest::addColumn<StatusMap>("results");

QList<QByteArray> scenario;
        QList<QByteArray> dataItems;
        StatusMap results;
        scenario << FakeServer::preauth()
                 << "C: A000001 STATUS \"INBOX\" (MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)"
                 << "S: * STATUS \"INBOX\" (MESSAGES 294 RECENT 1 UIDNEXT 295 UIDVALIDITY 458587604 UNSEEN 181)"
                 << "S: A000001 OK STATUS Completed";
        dataItems = { "MESSAGES", "RECENT", "UIDNEXT", "UIDVALIDITY", "UNSEEN" };
        results = { { "MESSAGES", 294 }, { "RECENT", 1 }, { "UIDNEXT", 295 },
                    { "UIDVALIDITY", 458587604 }, { "UNSEEN", 181 } };
        QTest::newRow("good") << scenario << dataItems << results;

scenario.clear();
        results.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 STATUS \"INBOX\" (MESSAGES UIDNEXT HIGHESTMODSEQ)"
                 << "S: * STATUS \"INBOX\" (MESSAGES 294 UIDNEXT 295)"
                 << "S: A000001 OK STATUS Completed";
        dataItems = { "MESSAGES", "UIDNEXT", "HIGHESTMODSEQ" };
        results = { { "MESSAGES", 294 }, { "UIDNEXT", 295 } };
        QTest::newRow("incomplete") << scenario << dataItems << results;

scenario.clear();
        results.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 STATUS \"INBOX\" (HIGHESTMODSEQ)"
                 << "S: * STATUS \"INBOX\" ()"
                 << "S: A000001 OK STATUS Completed";
        dataItems = { "HIGHESTMODSEQ" };
        QTest::newRow("empty response") << scenario << dataItems << results;

scenario.clear();
        results.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 STATUS \"INBOX\" (MESSAGES HIGHESTMODSEQ)"
                 << "S: A000001 NO status failure";
        dataItems = { "MESSAGES", "HIGHESTMODSEQ" };
        results.clear();
        QTest::newRow("no") << scenario << dataItems << results;

scenario.clear();
        results.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 STATUS \"INBOX\" (UIDNEXT)"
                 << "S: A000001 NO bad command";
        dataItems = { "UIDNEXT" };
        QTest::newRow("bad") << scenario << dataItems << results;
    }

void testStatus()
    {
        QFETCH(QList<QByteArray>, scenario);
        QFETCH(QList<QByteArray>, dataItems);
        QFETCH(StatusMap, results);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);
        KIMAP::StatusJob *job = new KIMAP::StatusJob(&session);
        job->setMailBox(QStringLiteral("INBOX"));
        job->setDataItems(dataItems);
        bool result = job->exec();

QEXPECT_FAIL("bad" , "Expected failure on BAD scenario", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO scenario", Continue);
        QVERIFY(result);

if (result) {
            const StatusMap status = job->status();
            QCOMPARE(status.count(), results.count());
            for (int i = 0; i < results.count(); ++i) {
                QCOMPARE(results[i].first, status[i].first);
                QCOMPARE(results[i].second, status[i].second);
            }
        }

fakeServer.quit();
    }
};

QTEST_GUILESS_MAIN(StatusJobTest)

#include "statusjobtest.moc"

07070100000027000081A40000000200000002000000015ED129EC00000CC6000000000000000000000000000000000000004400000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/storejobtest.cpp/*
   Copyright (C) 2009 Kevin Ottens <ervin@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/storejob.h"

#include <QTest>

class StoreJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testStore_data()
    {
        QTest::addColumn<bool>("uidBased");
        QTest::addColumn<qint64>("id");
        QTest::addColumn<qint64>("uid");
        QTest::addColumn< QList<QByteArray> >("flags");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 STORE 3 FLAGS (\\Seen \\Foo)"
                 << "S: * 3 FETCH (FLAGS (\\Seen \\Foo) UID 1096)"
                 << "S: A000001 OK STORE completed";

QTest::newRow("not uid based") << false << qint64(3) << qint64(1096)
                                       << (QList<QByteArray>() << "\\Seen" << "\\Foo")
                                       << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 UID STORE 1096 FLAGS (\\Seen \\Foo)"
                 << "S: * 3 FETCH (FLAGS (\\Seen \\Foo) UID 1096)"
                 << "S: A000001 OK STORE completed";

QTest::newRow("uid based") << true << qint64(3) << qint64(1096)
                                   << (QList<QByteArray>() << "\\Seen" << "\\Foo")
                                   << scenario;
    }

void testStore()
    {
        QFETCH(bool, uidBased);
        QFETCH(qint64, id);
        QFETCH(qint64, uid);
        QFETCH(QList<QByteArray>, flags);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::StoreJob *job = new KIMAP::StoreJob(&session);
        job->setUidBased(uidBased);
        job->setSequenceSet(KIMAP::ImapSet(uidBased ? uid : id));
        job->setFlags(flags);
        job->setMode(KIMAP::StoreJob::SetFlags);
        bool result = job->exec();
        QVERIFY(result);
        if (uidBased) {
            QVERIFY(job->resultingFlags().contains(uid));
        } else {
            QVERIFY(job->resultingFlags().contains(id));
        }

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(StoreJobTest)

#include "storejobtest.moc"
07070100000028000081A40000000200000002000000015ED129EC000016B1000000000000000000000000000000000000004800000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/streamparsertest.cpp/*
   Copyright (C) 2013 Christian Mollekopf <mollekopf@kolabsys.com>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "imapstreamparser.h"
#include <response_p.h>
#include <QBuffer>
#include <QTest>

using namespace KIMAP;

class StreamParserTest: public QObject
{
    Q_OBJECT

QByteArray part1;
    QByteArray part2;
    QByteArray part3;
    QByteArray part4;
    QByteArray completeResponse;
    QList<QByteArray> expectedList;

private Q_SLOTS:

void init()
    {

part1 = "* 230 FETCH (FLAGS (\\Recent \\Seen) UID 230 INTERNALDATE \" 1-Nov-2013 13:31:17 +0100\" RFC822.SIZE 37 BODY[] {37}\r";
        part2 = "\nDate: Fri, 01 Nov 2013 12:31:13 +0000\n";
        part3 = "body\n";
        part4 = ")\n\r";
        completeResponse = part1 + part2 + part3 + part4;
        expectedList.clear();
        expectedList << "FLAGS";
        expectedList << "(\\Recent \\Seen)";
        expectedList << "UID";
        expectedList << "230";
        expectedList << "INTERNALDATE";
        expectedList << " 1-Nov-2013 13:31:17 +0100";
        expectedList << "RFC822.SIZE";
        expectedList << "37";
        expectedList << "BODY[]";
        expectedList << "Date: Fri, 01 Nov 2013 12:31:13 +0000";
        expectedList << "body";
    }

/**
    * Test parsing of the example command if the complete command is in the buffer
    */
    void testParse()
    {
        QByteArray buffer;
        QBuffer socket(&buffer);
        socket.open(QBuffer::WriteOnly);
        QVERIFY(socket.write(completeResponse) != -1);

QBuffer readSocket(&buffer);
        readSocket.open(QBuffer::ReadOnly);
        ImapStreamParser parser(&readSocket);

QVERIFY(parser.availableDataSize() != 0);

Response message;
        QList<Response::Part> *payload = &message.content;
        QVERIFY(!parser.atCommandEnd());
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //*
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //230
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //FETCH
        QVERIFY(parser.hasList());
        *payload << Response::Part(parser.readParenthesizedList());
        QVERIFY(parser.atCommandEnd());

QCOMPARE(message.content.last().toList(), expectedList);
    }

void testLeadingNewline()
    {
        /**
        * Test a the special case when the CRLF after the string octet count, is separated and not initially loaded into the buffer.
        */
        QByteArray buffer;
        QBuffer socket(&buffer);
        socket.open(QBuffer::WriteOnly);

QVERIFY(socket.write(part1) != -1);

QBuffer readSocket(&buffer);
        readSocket.open(QBuffer::ReadOnly);
        ImapStreamParser parser(&readSocket);

QVERIFY(parser.availableDataSize() != 0);

Response message;
        QList<Response::Part> *payload = &message.content;
        QVERIFY(!parser.atCommandEnd());
        //We wait with writing part2 until the first part is already loaded into the buffer
        QVERIFY(socket.write(part2) != -1);
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //*
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //230
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //FETCH

QVERIFY(socket.write(part3) != -1);
        QVERIFY(socket.write(part4) != -1);

QVERIFY(parser.hasList());
        *payload << Response::Part(parser.readParenthesizedList());
        QVERIFY(parser.atCommandEnd());
    }

void testNewLineInString()
    {
        QByteArray command2;
        command2 = "* 33 FETCH (FLAGS (\\Recent \\Seen) UID 33 INTERNALDATE \" 1-Nov-2013 18:43:34 +0100\" RFC822.SIZE 1203 BODY[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] {54}\r\n";
        command2 += "Date: Fri, 01 Nov 2013 17:43:29 +0000\n";
        command2 += "Subject: uid32\n";
        command2 += "\n";
        command2 += ")\n\r";

QByteArray buffer;
        QBuffer socket(&buffer);
        socket.open(QBuffer::WriteOnly);
        QVERIFY(socket.write(command2) != -1);

QBuffer readSocket(&buffer);
        readSocket.open(QBuffer::ReadOnly);
        ImapStreamParser parser(&readSocket);

QVERIFY(parser.availableDataSize() != 0);

Response message;
        QList<Response::Part> *payload = &message.content;
        QVERIFY(!parser.atCommandEnd());
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //*
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //33
        QVERIFY(parser.hasString());
        *payload << Response::Part(parser.readString());   //FETCH
        QVERIFY(parser.hasList());
        *payload << Response::Part(parser.readParenthesizedList());
        QVERIFY(parser.atCommandEnd());
    }

};

QTEST_GUILESS_MAIN(StreamParserTest)

#include "streamparsertest.moc"
07070100000029000081A40000000200000002000000015ED129EC00000AD9000000000000000000000000000000000000004800000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/subscribejobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/subscribejob.h"

#include <QTest>

class SubscribeJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testSubscribe_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 SUBSCRIBE \"INBOX/foo\""
                 << "S: A000001 OK CREATE completed";
        QTest::newRow("good") << "INBOX/foo"  << scenario ;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SUBSCRIBE \"INBOX-FAIL-BAD\""
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << "INBOX-FAIL-BAD" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 SUBSCRIBE \"INBOX-FAIL-NO\""
                 << "S: A000001 NO subscribe failure";
        QTest::newRow("no") << "INBOX-FAIL-NO" << scenario ;
    }

void testSubscribe()
    {
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::SubscribeJob *job = new KIMAP::SubscribeJob(&session);
        job->setMailBox(mailbox);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD scenario", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO scenario", Continue);
        QVERIFY(result);
        QCOMPARE(job->mailBox(), mailbox);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(SubscribeJobTest)

#include "subscribejobtest.moc"
0707010000002A000081A40000000200000002000000015ED129EC00000D91000000000000000000000000000000000000004500000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/testrfccodecs.cpp/*
   This file is part of the kimap library.
   Copyright (C) 2007 Tom Albers <tomalbers@kde.nl>
   Copyright (c) 2007 Allen Winter <winter@kde.org>

This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

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; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/
#include <QTest>

#include "testrfccodecs.h"

QTEST_GUILESS_MAIN(RFCCodecsTest)

#include "rfccodecs.h"
using namespace KIMAP;

void RFCCodecsTest::testIMAPEncoding()
{
    QString encoded, decoded;
    QByteArray bEncoded, bDecoded;

encoded = encodeImapFolderName(QString::fromUtf8("Test.Frode Rønning"));
    QCOMPARE(encoded, QString::fromUtf8("Test.Frode R&APg-nning"));
    bEncoded = encodeImapFolderName(QString::fromUtf8("Test.Frode Rønning").toUtf8());
    QCOMPARE(bEncoded, QString::fromUtf8("Test.Frode R&APg-nning").toUtf8());

decoded = decodeImapFolderName(QString::fromLatin1("Test.Frode R&APg-nning"));
    QCOMPARE(decoded, QString::fromUtf8("Test.Frode Rønning"));
    bDecoded = decodeImapFolderName(QString::fromUtf8("Test.Frode Rønning").toUtf8());
    QCOMPARE(bDecoded, QString::fromUtf8("Test.Frode Rønning").toUtf8());

encoded = encodeImapFolderName(QString::fromUtf8("Test.tom & jerry"));
    QCOMPARE(encoded, QString::fromUtf8("Test.tom &- jerry"));
    bEncoded = encodeImapFolderName(QString::fromUtf8("Test.tom & jerry").toUtf8());
    QCOMPARE(bEncoded, QString::fromUtf8("Test.tom &- jerry").toUtf8());

decoded = decodeImapFolderName(QString::fromUtf8("Test.tom &- jerry"));
    QCOMPARE(decoded, QString::fromUtf8("Test.tom & jerry"));
    bDecoded = decodeImapFolderName(QString::fromUtf8("Test.tom &- jerry").toUtf8());
    QCOMPARE(bDecoded, QString::fromUtf8("Test.tom & jerry").toUtf8());

// Try to feed already encoded
    encoded = encodeImapFolderName(QString::fromUtf8("Test.Cl&AOE-udio"));
    QCOMPARE(encoded, QString::fromUtf8("Test.Cl&-AOE-udio"));
    bEncoded = encodeImapFolderName(QString::fromUtf8("Test.Cl&AOE-udio").toUtf8());
    QCOMPARE(bEncoded, QString::fromUtf8("Test.Cl&-AOE-udio").toUtf8());

decoded = decodeImapFolderName(QString::fromUtf8("Test.Cl&-AOE-udio"));
    QCOMPARE(decoded, QString::fromUtf8("Test.Cl&AOE-udio"));
    bDecoded = decodeImapFolderName(QString::fromUtf8("Test.Cl&-AOE-udio").toUtf8());
    QCOMPARE(bDecoded, QString::fromUtf8("Test.Cl&AOE-udio").toUtf8());

// With UTF8 characters
    bEncoded = "INBOX/&AOQ- &APY- &APw- @ &IKw-";
    QCOMPARE(decodeImapFolderName(bEncoded), QByteArray("INBOX/ä ö ü @ €"));
}

void RFCCodecsTest::testQuotes()
{
    QString test(QStringLiteral("tom\"allen"));
    QCOMPARE(quoteIMAP(test), QString::fromLatin1("tom\\\"allen"));
    test = QStringLiteral("tom\'allen");
    QCOMPARE(quoteIMAP(test), QString::fromLatin1("tom\'allen"));
    test =  QStringLiteral("tom\\allen");
    QCOMPARE(quoteIMAP(test), QString::fromLatin1("tom\\\\allen"));
}
0707010000002B000081A40000000200000002000000015ED129EC0000043F000000000000000000000000000000000000004300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/testrfccodecs.h/*
    This file is part of the kimap library.

#ifndef TESTRFCCODECS_H
#define TESTRFCCODECS_H

#include <QObject>

class RFCCodecsTest : public QObject
{
    Q_OBJECT
private Q_SLOTS:
    void testIMAPEncoding();
    void testQuotes();
};

#endif
0707010000002C000081A40000000200000002000000015ED129EC000032AB000000000000000000000000000000000000004300000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/testsession.cpp/*
    This file is part of the KDE project
    Copyright (C) 2008 Kevin Ottens <ervin@kde.org>

#include <QEventLoop>
#include <QObject>
#include <QTest>
#include <QSignalSpy>

#include "session.h"
#include "job.h"
#include "kimaptest/fakeserver.h"
#include "kimaptest/mockjob.h"

Q_DECLARE_METATYPE(KIMAP::Session::State)
Q_DECLARE_METATYPE(KJob *)

class SessionTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:

void initTestCase()
    {
        qRegisterMetaType<KIMAP::Session::State>();
    }

void shouldStartDisconnected()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::greeting()
                              );
        fakeServer.startAndWait();
        KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);
        QSignalSpy spy(&s, SIGNAL(stateChanged(KIMAP::Session::State,KIMAP::Session::State)));
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);
        QTest::qWait(600);
        QCOMPARE((int)s.state(), (int)KIMAP::Session::NotAuthenticated);
        QCOMPARE(spy.count(), 1);   // NotAuthenticated
        QList<QVariant> arguments = spy.takeFirst();
        QCOMPARE((int)qvariant_cast<KIMAP::Session::State>(arguments.at(0)), (int)KIMAP::Session::NotAuthenticated);
        QCOMPARE((int)qvariant_cast<KIMAP::Session::State>(arguments.at(1)), (int)KIMAP::Session::Disconnected);
    }

void shouldFailForInvalidHosts()
    {
        KIMAP::Session s(QStringLiteral("0.0.0.0"), 1234);
        s.setTimeout(1);   // 1 second timout

QSignalSpy spyFail(&s, SIGNAL(connectionFailed()));
        QSignalSpy spyLost(&s, SIGNAL(connectionLost()));
        QSignalSpy spyState(&s, SIGNAL(stateChanged(KIMAP::Session::State,KIMAP::Session::State)));

QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);

QTest::qWait(500);
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);
        QCOMPARE(spyFail.count(), 1);
        QCOMPARE(spyLost.count(), 0);
        QCOMPARE(spyState.count(), 0);

// Wait 800ms more. So now it's 1.3 seconds, check that the socket timeout has correctly been
        // disabled, and that it hadn't fired unexpectedly.
        QTest::qWait(800);
        QCOMPARE(spyFail.count(), 1);
    }

/**
      Checks that the timeout works when the connection succeeds, but the server doesn't sends anything
      back to the client. This could happen for example if we connected to a non-IMAP server.
    */
    void shouldTimeoutOnNoGreeting()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>());
        fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);
        s.setTimeout(2);
        QSignalSpy spyFail(&s, SIGNAL(connectionFailed()));
        QSignalSpy spyLost(&s, SIGNAL(connectionLost()));
        QSignalSpy spyState(&s, SIGNAL(stateChanged(KIMAP::Session::State,KIMAP::Session::State)));
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);

// Wait 1.8 second. Since the timeout is set to 2 seconds, the socket should be still
        // disconnected at this point, yet the connectionFailed() signal shouldn't have been emitted.
        QTest::qWait(1800);
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);
        QCOMPARE(spyFail.count(), 0);
        QCOMPARE(spyLost.count(), 0);
        QCOMPARE(spyState.count(), 0);

// Wait 0.5 second more. Now we are at 2.3 seconds, the socket should have timed out, and the
        // connectionFailed() signal should have been emitted.
        QTest::qWait(500);
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);
        QCOMPARE(spyFail.count(), 0);
        QCOMPARE(spyLost.count(), 1);
        QCOMPARE(spyState.count(), 0);
    }

void shouldSupportPreauth()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::preauth()
                              );
        fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);
        QSignalSpy spy(&s, SIGNAL(stateChanged(KIMAP::Session::State,KIMAP::Session::State)));
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Disconnected);
        QTest::qWait(500);
        QCOMPARE((int)s.state(), (int)KIMAP::Session::Authenticated);
        QCOMPARE(spy.count(), 1);   // Authenticated
        QList<QVariant> arguments = spy.takeFirst();
        QCOMPARE((int)qvariant_cast<KIMAP::Session::State>(arguments.at(0)), (int)KIMAP::Session::Authenticated);
        QCOMPARE((int)qvariant_cast<KIMAP::Session::State>(arguments.at(1)), (int)KIMAP::Session::Disconnected);
    }

void shouldRespectStartOrder()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::greeting()
                              );
        fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);
        MockJob *j1 = new MockJob(&s);
        connect(j1, SIGNAL(result(KJob*)), this, SLOT(jobDone(KJob*)));
        MockJob *j2 = new MockJob(&s);
        connect(j2, SIGNAL(result(KJob*)), this, SLOT(jobDone(KJob*)));
        MockJob *j3 = new MockJob(&s);
        connect(j3, SIGNAL(result(KJob*)), this, SLOT(jobDone(KJob*)));
        MockJob *j4 = new MockJob(&s);
        connect(j4, SIGNAL(result(KJob*)), this, SLOT(jobDone(KJob*)));

j4->start();
        j2->start();
        j3->start();
        j1->start();

m_expectedCalls = 4;
        m_eventLoop.exec();

QCOMPARE(m_jobs.size(), 4);
        QCOMPARE(m_jobs[0], j4);
        QCOMPARE(m_jobs[1], j2);
        QCOMPARE(m_jobs[2], j3);
        QCOMPARE(m_jobs[3], j1);
    }

void shouldManageQueueSize()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::greeting()
                              );
        fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);

QSignalSpy queueSpy(&s, SIGNAL(jobQueueSizeChanged(int)));

QCOMPARE(s.jobQueueSize(), 0);

MockJob *j1 = new MockJob(&s);
        MockJob *j2 = new MockJob(&s);
        MockJob *j3 = new MockJob(&s);
        MockJob *j4 = new MockJob(&s);
        connect(j4, SIGNAL(result(KJob*)), &m_eventLoop, SLOT(quit()));

QCOMPARE(s.jobQueueSize(), 0);

j1->start();
        QCOMPARE(s.jobQueueSize(), 1);
        QCOMPARE(queueSpy.size(), 1);
        QCOMPARE(queueSpy.at(0).at(0).toInt(), 1);

j2->start();
        QCOMPARE(s.jobQueueSize(), 2);
        QCOMPARE(queueSpy.size(), 2);
        QCOMPARE(queueSpy.at(1).at(0).toInt(), 2);

j3->start();
        QCOMPARE(s.jobQueueSize(), 3);
        QCOMPARE(queueSpy.size(), 3);
        QCOMPARE(queueSpy.at(2).at(0).toInt(), 3);

j4->start();
        QCOMPARE(s.jobQueueSize(), 4);
        QCOMPARE(queueSpy.size(), 4);
        QCOMPARE(queueSpy.at(3).at(0).toInt(), 4);

queueSpy.clear();
        m_eventLoop.exec();

QCOMPARE(s.jobQueueSize(), 0);

QCOMPARE(queueSpy.at(0).at(0).toInt(), 3);
        QCOMPARE(queueSpy.at(1).at(0).toInt(), 2);
        QCOMPARE(queueSpy.at(2).at(0).toInt(), 1);
        QCOMPARE(queueSpy.at(3).at(0).toInt(), 0);
    }

void shouldTimeoutOnNoReply()
    {
        FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>()
                               << FakeServer::preauth()
                               << "C: A000001 DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               << "S: * DUMMY"
                               // We never get a OK or anything, so the job can't normally complete
                              );
        fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);

MockJob *mock = new MockJob(&s);
        mock->setCommand("DUMMY");

mock->exec();
        // We expect to get an error here due to some timeout
        QVERIFY(mock->error() != 0);
        QCOMPARE(spyFail.count(), 0);
        QCOMPARE(spyLost.count(), 1);
        QCOMPARE(spyState.count(), 2);   // Authenticated, Disconnected
    }

void shouldFailFirstJobOnConnectionFailed()
    {
        qRegisterMetaType<KJob *>();

FakeServer fakeServer;
        fakeServer.setScenario(QList<QByteArray>());
        fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);
        s.setTimeout(1);

MockJob *j1 = new MockJob(&s);
        QSignalSpy spyResult1(j1, SIGNAL(result(KJob*)));
        QSignalSpy spyDestroyed1(j1, SIGNAL(destroyed()));

MockJob *j2 = new MockJob(&s);
        QSignalSpy spyResult2(j2, SIGNAL(result(KJob*)));
        QSignalSpy spyDestroyed2(j2, SIGNAL(destroyed()));

MockJob *j3 = new MockJob(&s);
        QSignalSpy spyResult3(j3, SIGNAL(result(KJob*)));
        QSignalSpy spyDestroyed3(j3, SIGNAL(destroyed()));

j1->start();
        j2->start();
        j3->start();

QCOMPARE(s.jobQueueSize(), 3);

QTest::qWait(1100);

// Check that only the first job has emitted it's result
        QCOMPARE(spyResult1.count(), 1);
        QCOMPARE(spyResult2.count(), 0);
        QCOMPARE(spyResult3.count(), 0);

// Check that all jobs have been deleted
        QCOMPARE(spyDestroyed1.count(), 1);
        QCOMPARE(spyDestroyed2.count(), 1);
        QCOMPARE(spyDestroyed3.count(), 1);

QCOMPARE(s.jobQueueSize(), 0);
    }

void shouldCloseOnInconsistency()
    {
        for (int count = 0; count < 10; count++) {
            FakeServer fakeServer;
            fakeServer.setScenario(QList<QByteArray>()
                                   << FakeServer::preauth()
                                   << "C: A000001 DUMMY"
                                   << "S: * DUMMY %"
                                   << "S: DUMMY)"
                                  );
            fakeServer.startAndWait();

KIMAP::Session s(QStringLiteral("127.0.0.1"), 5989);

QSignalSpy spyFail(&s, SIGNAL(connectionFailed()));
            QSignalSpy spyLost(&s, SIGNAL(connectionLost()));
            QSignalSpy spyState(&s, SIGNAL(stateChanged(KIMAP::Session::State,KIMAP::Session::State)));

MockJob *mock = new MockJob(&s);
            mock->setTimeout(5000);
            mock->setCommand("DUMMY");

mock->setAutoDelete(false);
            mock->start();
            QTest::qWait(250);   // Should be plenty

// We expect to get an error here due to the inconsistency
            QVERIFY(mock->error() != 0);
            QCOMPARE(spyFail.count(), 0);
            QCOMPARE(spyLost.count(), 1);
            QCOMPARE(spyState.count(), 2);   // Authenticated, Disconnected

delete mock;
        }
    }

public Q_SLOTS:
    void jobDone(KJob *job)
    {
        m_jobs << job;

if (m_expectedCalls == m_jobs.size()) {
            m_eventLoop.quit();
        }
    }

private:
    QEventLoop m_eventLoop;
    int m_expectedCalls;
    QList<KJob *> m_jobs;
};

QTEST_GUILESS_MAIN(SessionTest)

#include "testsession.moc"
0707010000002D000081A40000000200000002000000015ED129EC00000B0A000000000000000000000000000000000000004A00000000kimap-VERSIONgit.20200529T172740~a5402d2/autotests/unsubscribejobtest.cpp/*
   Copyright (C) 2009 Andras Mantia <amantia@kde.org>

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

This program 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
   General Public License for more details.

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

#include <QTest>

#include "kimaptest/fakeserver.h"
#include "kimap/session.h"
#include "kimap/unsubscribejob.h"

#include <QTest>

class UnsubscribeJobTest: public QObject
{
    Q_OBJECT

private Q_SLOTS:

void testUnsubscribe_data()
    {
        QTest::addColumn<QString>("mailbox");
        QTest::addColumn< QList<QByteArray> >("scenario");

QList<QByteArray> scenario;
        scenario << FakeServer::preauth()
                 << "C: A000001 UNSUBSCRIBE \"#news.comp.mail.mime\""
                 << "S: A000001 OK UNSUBSCRIBE completed";
        QTest::newRow("good") << "#news.comp.mail.mime"  << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 UNSUBSCRIBE \"INBOX-FAIL-BAD\""
                 << "S: A000001 BAD command unknown or arguments invalid";
        QTest::newRow("bad") << "INBOX-FAIL-BAD" << scenario;

scenario.clear();
        scenario << FakeServer::preauth()
                 << "C: A000001 UNSUBSCRIBE \"INBOX-FAIL-NO\""
                 << "S: A000001 NO unsubscribe failure";
        QTest::newRow("no") << "INBOX-FAIL-NO" << scenario;
    }

void testUnsubscribe()
    {
        QFETCH(QString, mailbox);
        QFETCH(QList<QByteArray>, scenario);

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

KIMAP::Session session(QStringLiteral("127.0.0.1"), 5989);

KIMAP::UnsubscribeJob *job = new KIMAP::UnsubscribeJob(&session);
        job->setMailBox(mailbox);
        bool result = job->exec();
        QEXPECT_FAIL("bad" , "Expected failure on BAD scenario", Continue);
        QEXPECT_FAIL("no" , "Expected failure on NO scenario", Continue);
        QVERIFY(result);
        QCOMPARE(job->mailBox(), mailbox);

fakeServer.quit();
    }

};

QTEST_GUILESS_MAIN(UnsubscribeJobTest)

#include "unsubscribejobtest.moc"
0707010000002E000081A40000000200000002000000015ED129EC0000014D000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/metainfo.yamlfancyname: KIMAP
maintainer: dvratil 
description: A job-based API for interacting with IMAP servers
tier: 3
type: functional
platforms:
    - name: All
portingAid: false
deprecated: false
release: false
libraries:
 - qmake: KImap
   cmake: "KF5::Imap"
cmakename: KF5Imap

public_lib: true
group: kdepim
platforms:
    - name: Linux
0707010000002F000041ED0000000200000002000000025ED129EC00000000000000000000000000000000000000000000002D00000000kimap-VERSIONgit.20200529T172740~a5402d2/src07070100000030000081A40000000200000002000000015ED129EC00000C39000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/CMakeLists.txt
# Turn exceptions on
kde_enable_exceptions()

set(kimap_SRCS
   acl.cpp
   acljobbase.cpp
   appendjob.cpp
   capabilitiesjob.cpp
   closejob.cpp
   copyjob.cpp
   createjob.cpp
   deleteacljob.cpp
   deletejob.cpp
   expungejob.cpp
   fetchjob.cpp
   getacljob.cpp
   getmetadatajob.cpp
   getquotajob.cpp
   getquotarootjob.cpp
   idjob.cpp
   idlejob.cpp
   imapset.cpp
   imapstreamparser.cpp
   job.cpp
   listjob.cpp
   listrightsjob.cpp
   loginjob.cpp
   logoutjob.cpp
   metadatajobbase.cpp
   movejob.cpp
   myrightsjob.cpp
   namespacejob.cpp
   quotajobbase.cpp
   renamejob.cpp
   rfccodecs.cpp
   searchjob.cpp
   selectjob.cpp
   session.cpp
   sessionlogger.cpp
   sessionthread.cpp
   sessionuiproxy.cpp
   setacljob.cpp
   setmetadatajob.cpp
   setquotajob.cpp
   statusjob.cpp
   storejob.cpp
   subscribejob.cpp
   unsubscribejob.cpp
)

ecm_qt_declare_logging_category(kimap_SRCS HEADER kimap_debug.h IDENTIFIER KIMAP_LOG CATEGORY_NAME org.kde.pim.kimap
        OLD_CATEGORY_NAMES log_kimap
        DESCRIPTION "kimap (pim lib)" EXPORT KIMAP)

add_library(KF5IMAP ${kimap_SRCS})

generate_export_header(KF5IMAP BASE_NAME kimap)

add_library(KF5::IMAP ALIAS KF5IMAP)

target_include_directories(KF5IMAP INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/KIMAP>")
target_include_directories(KF5IMAP PUBLIC "$<BUILD_INTERFACE:${KIMAP_SOURCE_DIR}/src;${KIMAP_BINARY_DIR}/src>")

if (WIN32)
    set(extra_LIBS ws2_32)
endif()

target_link_libraries(KF5IMAP
PUBLIC
  KF5::Mime
  KF5::CoreAddons
  Qt5::Network
PRIVATE
  KF5::KIOCore
  KF5::Codecs
  KF5::I18n
  Sasl2::Sasl2
  ${extra_LIBS}
)

set_target_properties(KF5IMAP PROPERTIES
    VERSION ${KIMAP_VERSION_STRING}
    SOVERSION ${KIMAP_SOVERSION}
    EXPORT_NAME IMAP
)

ecm_generate_headers(KIMAP_CamelCase_HEADERS
  HEADER_NAMES
  Acl
  AclJobBase
  AppendJob
  CapabilitiesJob
  CloseJob
  CopyJob
  CreateJob
  DeleteAclJob
  DeleteJob
  ExpungeJob
  FetchJob
  GetAclJob
  GetMetaDataJob
  GetQuotaJob
  GetQuotaRootJob
  IdJob
  IdleJob
  ImapSet
  Job
  ListJob
  ListRightsJob
  LoginJob
  LogoutJob
  MetaDataJobBase
  MoveJob
  MyRightsJob
  NamespaceJob
  QuotaJobBase
  RenameJob
  RFCCodecs
  SearchJob
  SelectJob
  Session
  SessionUiProxy
  SetAclJob
  SetMetaDataJob
  SetQuotaJob
  StatusJob
  StoreJob
  SubscribeJob
  UnsubscribeJob
  PREFIX KIMAP

REQUIRED_HEADERS KIMAP_HEADERS
)

install(TARGETS KF5IMAP EXPORT KF5IMAPTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/kimap_export.h
    ${KIMAP_HEADERS}
    ${KIMAP_CamelCase_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/KIMAP/kimap
    COMPONENT Devel
)

install(FILES
    ${KIMAP_CamelCase_HEADERS}
    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/KIMAP/KIMAP
    COMPONENT Devel
)

ecm_qt_install_logging_categories(EXPORT KIMAP FILE kimap.categories DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR})
ecm_generate_pri_file(BASE_NAME KIMAP LIB_NAME KF5IMAP DEPS "Mime" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/KIMAP)
install(FILES ${PRI_FILENAME} DESTINATION ${ECM_MKSPECS_INSTALL_DIR})
07070100000031000081ED0000000200000002000000015ED129EC00000053000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/Messages.sh#! /bin/sh
$XGETTEXT `find . -name "*.cpp" -o -name "*.h"` -o $podir/libkimap5.pot
07070100000032000081A40000000200000002000000015ED129EC00000CBF000000000000000000000000000000000000003500000000kimap-VERSIONgit.20200529T172740~a5402d2/src/acl.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "acl.h"

#include <QByteArray>
#include <QMap>

namespace KIMAP
{
namespace Acl
{

class RightsMap
{
public:
    RightsMap()
    {
        map['l'] = Lookup;
        map['r'] = Read;
        map['s'] = KeepSeen;
        map['w'] = Write;
        map['i'] = Insert;
        map['p'] = Post;
        map['c'] = Create; //TODO: obsolete, keep it?
        map['d'] = Delete; //TODO: obsolete, keep it?
        map['k'] = CreateMailbox;
        map['x'] = DeleteMailbox;
        map['t'] = DeleteMessage;
        map['e'] = Expunge;
        map['a'] = Admin;
        map['n'] = WriteShared;
        map['0'] = Custom0;
        map['1'] = Custom1;
        map['2'] = Custom2;
        map['3'] = Custom3;
        map['4'] = Custom4;
        map['5'] = Custom5;
        map['6'] = Custom6;
        map['7'] = Custom7;
        map['8'] = Custom8;
        map['9'] = Custom9;
    }

QMap<char, Right> map;
};

Q_GLOBAL_STATIC(RightsMap, globalRights)

}
}

KIMAP::Acl::Rights KIMAP::Acl::rightsFromString(const QByteArray &string)
{
    Rights result;

if (string.isEmpty()) {
        return result;
    }

int pos = 0;
    if (string[0] == '+' || string[0] == '-') {   // Skip modifier if any
        pos++;
    }

for (int i = pos; i < string.size(); i++) {
        if (globalRights->map.contains(string[i])) {
            result |= globalRights->map[string[i]];
        }
    }

return result;
}

QByteArray KIMAP::Acl::rightsToString(Rights rights)
{
    QByteArray result;

for (int right = Lookup; right <= Custom9; right <<= 1) {
        if (rights & right) {
            result += globalRights->map.key(static_cast<Right>(right));
        }
    }

return result;
}

KIMAP::Acl::Rights KIMAP::Acl::normalizedRights(KIMAP::Acl::Rights rights)
{
    Rights normalized = rights;
    if (normalized & Create) {
        normalized |= (CreateMailbox | DeleteMailbox);
        normalized &= ~Create;
    }
    if (normalized & Delete) {
        normalized |= (DeleteMessage | Expunge);
        normalized &= ~Delete;
    }
    return normalized;
}

KIMAP::Acl::Rights KIMAP::Acl::denormalizedRights(KIMAP::Acl::Rights rights)
{
    Rights denormalized = normalizedRights(rights);
    if (denormalized & (CreateMailbox | DeleteMailbox)) {
        denormalized |= Create;
    }
    if (denormalized & (DeleteMessage | Expunge)) {
        denormalized |= Delete;
    }
    return denormalized;
}
07070100000033000081A40000000200000002000000015ED129EC0000126C000000000000000000000000000000000000003300000000kimap-VERSIONgit.20200529T172740~a5402d2/src/acl.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_ACL_H
#define KIMAP_ACL_H

#include "kimap_export.h"

#include <qglobal.h>

namespace KIMAP
{

/**
 * Operations for dealing with mailbox permissions.
 */
namespace Acl
{

/**
 * Possible rights that can be held on a mailbox
 */
enum Right {
    None          = 0x000000,
    /** Mailbox is visible to LIST/LSUB commands, SUBSCRIBE mailbox */
    Lookup        = 0x000001,
    /** SELECT the mailbox, perform STATUS */
    Read          = 0x000002,
    /** Set or clear the \Seen flag on messages in the mailbox, and keep it across sessions */
    KeepSeen      = 0x000004,
    /** Set or clear flags other than \Seen and \Deleted on messages in the mailbox */
    Write         = 0x000008,
    /** Perform APPEND and COPY with the mailbox as the target */
    Insert        = 0x000010,
    /** Send mail to the submission address for the mailbox
     *
     * Note: this is not enforced by IMAP4, but is purely advisory.
     */
    Post          = 0x000020,
    /** Obsolete as of RFC 4314, replaced by CreateMailbox and DeleteMailbox */
    Create        = 0x000040,
    /** Create new child mailboxes, or move a mailbox with this mailbox as the new parent
     *
     * Note that what constitutes a "child" mailbox is implementation-defined, but
     * . or / are usually used as separaters.
     */
    CreateMailbox = 0x000080,
    /** Delete or move the mailbox */
    DeleteMailbox = 0x000100,
    /** Set or clear the \Deleted flag on messages in the mailbox */
    DeleteMessage = 0x000200,
    /** Obsolete as of RFC 4314, replaced by DeleteMessage and Expunge*/
    Delete        = 0x000400,
    /** View and modify the access control list for the mailbox */
    Admin         = 0x000800,
    /** Expunge the messages in this mailbox
     *
     * Note that if this right is not held on a mailbox, closing the mailbox
     * (see CloseJob) will succeed, but will not expunge the messages.
     */
    Expunge       = 0x001000,
    /** Write shared annotations
     *
     * See <a href="https://tools.ietf.org/html/rfc5257" title="IMAP ANNOTATE extension">RFC
     * 5257</a>.  Only supported by servers that implement the ANNOTATE extension.
     */
    WriteShared   = 0x002000,
    Custom0       = 0x004000, /**< Server-specific right 0 */
    Custom1       = 0x008000, /**< Server-specific right 1 */
    Custom2       = 0x010000, /**< Server-specific right 2 */
    Custom3       = 0x020000, /**< Server-specific right 3 */
    Custom4       = 0x040000, /**< Server-specific right 4 */
    Custom5       = 0x080000, /**< Server-specific right 5 */
    Custom6       = 0x100000, /**< Server-specific right 6 */
    Custom7       = 0x200000, /**< Server-specific right 7 */
    Custom8       = 0x400000, /**< Server-specific right 8 */
    Custom9       = 0x800000  /**< Server-specific right 9 */
};

Q_DECLARE_FLAGS(Rights, Right)

/**
 * Returns a rights mask that has no obsolete members anymore, i.e. obsolete flags are removed and
 * replaced by their successors.
 * @param rights set of #Rights flags to normalize
 * @since 4.6
 */
KIMAP_EXPORT Rights normalizedRights(Rights rights);

/**
 * Returns a rights mask that contains both obsolete and new flags if one of them is set.
 * @param rights set of #Rights flags to augment
 * @since 4.6
 */
KIMAP_EXPORT Rights denormalizedRights(Rights rights);

/**
 * Convert a set of rights into text format
 *
 * No modifier flag ('+' or '-') will be included.
 */
KIMAP_EXPORT QByteArray rightsToString(Rights rights);
/**
 * Convert the text form of a set of rights into a Rights bitflag
 *
 * Modifier flags ('+' and '-') are ignored, as are any unknown
 * characters.  This method will not complain if you give it
 * something that is not a list of rights.
 */
KIMAP_EXPORT Rights rightsFromString(const QByteArray &string);

}
}

Q_DECLARE_OPERATORS_FOR_FLAGS(KIMAP::Acl::Rights)

#endif
07070100000034000081A40000000200000002000000015ED129EC000008A4000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/acljobbase.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "acljobbase.h"
#include "acljobbase_p.h"
#include "response_p.h"
#include "session_p.h"

#include <KLocalizedString>

using namespace KIMAP;

void AclJobBasePrivate::setIdentifier(const QByteArray &identifier)
{
    id = identifier;
}

QByteArray AclJobBasePrivate::identifier() const
{
    return id;
}

bool AclJobBasePrivate::hasRightEnabled(Acl::Right right) const
{
    return rightList & right;
}

void AclJobBasePrivate::setRights(const QByteArray &rights)
{
    switch (rights[0]) {
    case '+':
        modifier = AclJobBase::Add;
        break;
    case '-':
        modifier = AclJobBase::Remove;
        break;
    default:
        modifier = AclJobBase::Change;
        break;
    }

rightList = Acl::rightsFromString(rights);
}

void AclJobBasePrivate::setRights(AclJobBase::AclModifier _modifier, Acl::Rights rights)
{
    modifier = _modifier;
    // XXX: [alexmerry, 2010-07-24]: this is REALLY unintuitive behaviour
    rightList |= rights;
}

AclJobBase::AclJobBase(Session *session)
    : Job(*new AclJobBasePrivate(session, i18n("AclJobBase")))
{
}

AclJobBase::AclJobBase(JobPrivate &dd)
    : Job(dd)
{

}

AclJobBase::~AclJobBase()
{
}

void AclJobBase::setMailBox(const QString &mailBox)
{
    Q_D(AclJobBase);
    d->mailBox = mailBox;
}

QString AclJobBase::mailBox() const
{
    Q_D(const AclJobBase);
    return d->mailBox;
}
07070100000035000081A40000000200000002000000015ED129EC000007F8000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/acljobbase.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_ACLJOBBASE_H
#define KIMAP_ACLJOBBASE_H

#include "kimap_export.h"

#include "acl.h"
#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class AclJobBasePrivate;

/**
 * Base class for jobs that operate on mailbox ACLs
 *
 * Provides support for the IMAP ACL extension, as defined by
 * <a href="https://tools.ietf.org/html/rfc4314" title="IMAP ACL extension">RFC 4314</a>.
 *
 * This class cannot be used directly, you must subclass it and reimplement
 * at least the doStart() method.
*/
class KIMAP_EXPORT AclJobBase : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(AclJobBase)

friend class SessionPrivate;

public:
    AclJobBase(Session *session);
    ~AclJobBase() override;

/**
     * Used when subclassing to specify how the ACL will be modified.
     */
    enum AclModifier {
        Add = 0,
        Remove,
        Change
    };

/**
     * Set the mailbox to act on
     *
     * @param mailBox  the name of an existing mailbox
     */
    void setMailBox(const QString &mailBox);
    /**
     * The mailbox that will be acted upon.
     */
    QString mailBox() const;

protected:
    explicit AclJobBase(JobPrivate &dd);

};

}

#endif
07070100000036000081A40000000200000002000000015ED129EC00000666000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/acljobbase_p.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_ACLJOBBASE_P_H
#define KIMAP_ACLJOBBASE_P_H

#include "acljobbase.h"
#include "job_p.h"
#include "session.h"

namespace KIMAP
{
class AclJobBasePrivate : public JobPrivate
{
public:
    AclJobBasePrivate(Session *session, const QString &name) : JobPrivate(session, name), rightList(Acl::None), modifier(AclJobBase::Change)
    {
    }
    ~AclJobBasePrivate() { }

void setIdentifier(const QByteArray &identifier);
    Q_REQUIRED_RESULT QByteArray identifier() const;

Q_REQUIRED_RESULT bool hasRightEnabled(Acl::Right right) const;

void setRights(const QByteArray &rights);
    void setRights(AclJobBase::AclModifier modifier, Acl::Rights rights);

QString mailBox;
    QByteArray id;
    Acl::Rights rightList;
    AclJobBase::AclModifier modifier;
};
}

#endif
07070100000037000081A40000000200000002000000015ED129EC00000EDA000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/appendjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "appendjob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class AppendJobPrivate : public JobPrivate
{
public:
    AppendJobPrivate(Session *session, const QString &name) : JobPrivate(session, name), uid(0) { }
    ~AppendJobPrivate() { }

QString mailBox;
    QList<QByteArray> flags;
    QDateTime internalDate;
    QByteArray content;
    qint64 uid;
};
}

using namespace KIMAP;

AppendJob::AppendJob(Session *session)
    : Job(*new AppendJobPrivate(session, i18n("Append")))
{
}

AppendJob::~AppendJob()
{
}

void AppendJob::setMailBox(const QString &mailBox)
{
    Q_D(AppendJob);
    d->mailBox = mailBox;
}

QString AppendJob::mailBox() const
{
    Q_D(const AppendJob);
    return d->mailBox;
}

void AppendJob::setFlags(const QList<QByteArray> &flags)
{
    Q_D(AppendJob);
    d->flags = flags;
}

QList<QByteArray> AppendJob::flags() const
{
    Q_D(const AppendJob);
    return d->flags;
}

void AppendJob::setInternalDate(const QDateTime &internalDate)
{
    Q_D(AppendJob);
    d->internalDate = internalDate;
}

QDateTime AppendJob::internalDate() const
{
    Q_D(const AppendJob);
    return d->internalDate;
}

void AppendJob::setContent(const QByteArray &content)
{
    Q_D(AppendJob);
    d->content = content;
}

QByteArray AppendJob::content() const
{
    Q_D(const AppendJob);
    return d->content;
}

qint64 AppendJob::uid() const
{
    Q_D(const AppendJob);
    return d->uid;
}

void AppendJob::doStart()
{
    Q_D(AppendJob);

QByteArray parameters = '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"';

if (!d->flags.isEmpty()) {
        parameters += " (";
        for (const QByteArray &flag : qAsConst(d->flags)) {
            parameters += flag + ' ';
        }
        parameters.chop(1);
        parameters += ')';
    }

if (!d->internalDate.isNull()) {
        const QDateTime utcDateTime = d->internalDate.toUTC();
        parameters += " \"" + QLocale::c().toString(utcDateTime, QStringLiteral("dd-MMM-yyyy hh:mm:ss")).toLatin1() + " +0000" + '\"';
    }

parameters += " {" + QByteArray::number(d->content.size()) + '}';

d->tags << d->sessionInternal()->sendCommand("APPEND", parameters);
}

void AppendJob::handleResponse(const Response &response)
{
    Q_D(AppendJob);
    const QList<Response::Part>::ConstIterator end(response.responseCode.end());
    for (QList<Response::Part>::ConstIterator it = response.responseCode.begin();
            it != end; ++it) {
        if (it->toString() == "APPENDUID") {
            it = it + 2;
            if (it != end) {
                d->uid = it->toString().toLongLong();
            }
            break;
        }
    }

if (handleErrorReplies(response) == NotHandled) {
        if (!response.content.isEmpty() && response.content[0].toString() == "+") {
            d->sessionInternal()->sendData(d->content);
        }
    }
}
07070100000038000081A40000000200000002000000015ED129EC00000E8E000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/appendjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_APPENDJOB_H
#define KIMAP_APPENDJOB_H

#include "kimap_export.h"

#include "job.h"
#include <QDateTime>

namespace KIMAP
{

class Session;
struct Response;
class AppendJobPrivate;

/**
 * Appends a message to a mailbox.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * If the server supports ACLs, the user will need the
 * Acl::Insert right on the mailbox.
 */
class KIMAP_EXPORT AppendJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(AppendJob)

friend class SessionPrivate;

public:
    explicit AppendJob(Session *session);
    ~AppendJob() override;

/**
     * Set the mailbox to append the message to.
     *
     * If the mailbox does not exist, it will not automatically
     * be created and the command will fail.
     *
     * @param mailBox  the (unquoted) name of the mailbox
     */
    void setMailBox(const QString &mailBox);
    /**
     * The mailbox that the message will be appended to.
     */
    Q_REQUIRED_RESULT QString mailBox() const;

/**
     * Set the flags that should be applied to the appended message.
     *
     * @param flags  a list of flags
     */
    void setFlags(const QList<QByteArray> &flags);
    /**
     * The flags that will be set on the appended message.
     */
    Q_REQUIRED_RESULT QList<QByteArray> flags() const;

/**
     * Set the internal date that should be applied to the appended message.
     *
     * This is the date/time the IMAP server should set internally for the appended message.
     * See https://tools.ietf.org/html/rfc3501#section-6.3.11
     *
     * If this is not set, the server will use the current date/time.
     *
     * @param internalDate  the internal date
     *
     * @since 4.13
     */
    void setInternalDate(const QDateTime &internalDate);

/**
     * The internal date that will be set on the appended message.
     *
     * @since 4.13
     */
    Q_REQUIRED_RESULT QDateTime internalDate() const;

/**
     * The content of the message.
     *
     * This should be in RFC-2822 format, although some required header
     * lines may be omitted in certain cases, for example when appending
     * to a Drafts folder.
     *
     * @param content  usually an RFC-2822 message
     */
    void setContent(const QByteArray &content);
    /**
     * The content that the message will have.
     */
    Q_REQUIRED_RESULT QByteArray content() const;

/**
     * The UID of the new message.
     *
     * This will be zero if it is unknown.
     *
     * The UID will not be known until the job has been successfully
     * executed, and it will only be known at all if the server
     * supports the UIDPLUS extension (RFC 4315).
     */
    Q_REQUIRED_RESULT qint64 uid() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
07070100000039000081A40000000200000002000000015ED129EC00000886000000000000000000000000000000000000004100000000kimap-VERSIONgit.20200529T172740~a5402d2/src/capabilitiesjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "capabilitiesjob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class CapabilitiesJobPrivate : public JobPrivate
{
public:
    CapabilitiesJobPrivate(Session *session,  const QString &name) : JobPrivate(session, name) { }
    ~CapabilitiesJobPrivate() { }

QStringList capabilities;
};
}

using namespace KIMAP;

CapabilitiesJob::CapabilitiesJob(Session *session)
    : Job(*new CapabilitiesJobPrivate(session, i18n("Capabilities")))
{
}

CapabilitiesJob::~CapabilitiesJob()
{
}

QStringList CapabilitiesJob::capabilities() const
{
    Q_D(const CapabilitiesJob);
    return d->capabilities;
}

void CapabilitiesJob::doStart()
{
    Q_D(CapabilitiesJob);
    d->tags << d->sessionInternal()->sendCommand("CAPABILITY");
}

void CapabilitiesJob::handleResponse(const Response &response)
{
    Q_D(CapabilitiesJob);
    if (handleErrorReplies(response) == NotHandled) {
        const int responseSize(response.content.size());
        if (responseSize >= 2 &&
                response.content[1].toString() == "CAPABILITY") {
            for (int i = 2; i < responseSize; ++i) {
                d->capabilities << QLatin1String(response.content[i].toString().toUpper());
            }
            Q_EMIT capabilitiesReceived(d->capabilities);
        }
    }
}
0707010000003A000081A40000000200000002000000015ED129EC000008AE000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/capabilitiesjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_CAPABILITIESJOB_H
#define KIMAP_CAPABILITIESJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class CapabilitiesJobPrivate;

/**
 * Checks server capabilities.
 *
 * This job can be run in any open session.
 *
 * This simply asks the server what capabilities it supports
 * (using the CAPABILITY command) and returns the list
 * provided by the server.  The list may, therefore, be
 * inaccurate: the server may claim to support something
 * it does not implement properly, or it may omit a feature
 * that it does, in reality, support.
 */
class KIMAP_EXPORT CapabilitiesJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(CapabilitiesJob)

friend class SessionPrivate;

public:
    CapabilitiesJob(Session *session);
    ~CapabilitiesJob() override;

/**
     * The capabilities the server claims to support.
     *
     * This will return an empty list until the job has completed.
     */
    Q_REQUIRED_RESULT QStringList capabilities() const;

Q_SIGNALS:
    /**
     * Notifies listeners that the capabilities have been fetched.
     *
     * @param capabilities  The capabilities the server claims to support.
     */
    void capabilitiesReceived(const QStringList &capabilities);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
0707010000003B000081A40000000200000002000000015ED129EC00000584000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/closejob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "closejob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class CloseJobPrivate : public JobPrivate
{
public:
    CloseJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~CloseJobPrivate() { }
};
}

using namespace KIMAP;

CloseJob::CloseJob(Session *session)
    : Job(*new CloseJobPrivate(session, i18n("Close")))
{
}

CloseJob::~CloseJob()
{
}

void CloseJob::doStart()
{
    Q_D(CloseJob);
    d->tags << d->sessionInternal()->sendCommand("CLOSE");
}
0707010000003C000081A40000000200000002000000015ED129EC000007B7000000000000000000000000000000000000003800000000kimap-VERSIONgit.20200529T172740~a5402d2/src/closejob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_CLOSEJOB_H
#define KIMAP_CLOSEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class CloseJobPrivate;

/**
 * Closes the current mailbox.
 *
 * This job can only be run when the session is in the selected state.
 *
 * Permanently removes all messages that have the \\Deleted
 * flag set from the currently selected mailbox, and returns
 * to the authenticated state from the selected state.
 *
 * The server will not provide any notifications of which
 * messages were expunged, so this is quicker than doing
 * an expunge and then implicitly closing the mailbox
 * (by selecting or examining another mailbox or logging
 * out).
 *
 * No messages are removed if the mailbox is open in a read-only
 * state, or if the server supports ACLs and the user does not
 * have the Acl::Expunge right on the mailbox.
 */
class KIMAP_EXPORT CloseJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(CloseJob)

friend class SessionPrivate;

public:
    explicit CloseJob(Session *session);
    ~CloseJob() override;

protected:
    void doStart() override;
};

}

#endif
0707010000003D000081A40000000200000002000000015ED129EC000006F2000000000000000000000000000000000000003600000000kimap-VERSIONgit.20200529T172740~a5402d2/src/common.h/*  This file is part of the KDE project
    Copyright (C) 2008 Jarosław Staniek <staniek@kde.org>

#ifndef _KIOSLAVE_COMMON_H
#define _KIOSLAVE_COMMON_H

#include <stdio.h>
#include <QFile>
#include <QDir>
#include <QCoreApplication>

extern "C" {
#include <sasl/sasl.h>
}

inline bool initSASL()
{
#ifdef Q_OS_WIN  //krazy:exclude=cpp
    for (const auto &path : QCoreApplication::libraryPaths()) {
        QDir dir(path);
        if (dir.exists(QStringLiteral("sasl2"))) {
            auto libInstallPath = QFile::encodeName(dir.absoluteFilePath(QStringLiteral("sasl2")));
            if (sasl_set_path(SASL_PATH_TYPE_PLUGIN, libInstallPath.data()) != SASL_OK) {
                fprintf(stderr, "SASL path initialization failed!\n");
                return false;
            }
            break;
        }
    }
#endif

if (sasl_client_init(nullptr) != SASL_OK) {
        fprintf(stderr, "SASL library initialization failed!\n");
        return false;
    }
    return true;
}

#endif
0707010000003E000081A40000000200000002000000015ED129EC00000BCB000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/copyjob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "copyjob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

//TODO: when custom error codes are introduced, handle the NO [TRYCREATE] response

namespace KIMAP
{
class CopyJobPrivate : public JobPrivate
{
public:
    CopyJobPrivate(Session *session, const QString &name) : JobPrivate(session, name), uidBased(false) { }
    ~CopyJobPrivate() { }

QString mailBox;
    ImapSet set;
    bool uidBased;
    ImapSet resultingUids;
};
}

using namespace KIMAP;

CopyJob::CopyJob(Session *session)
    : Job(*new CopyJobPrivate(session, i18n("Copy")))
{
    Q_D(CopyJob);
    d->uidBased = false;
}

CopyJob::~CopyJob()
{
}

void CopyJob::setMailBox(const QString &mailBox)
{
    Q_D(CopyJob);
    d->mailBox = mailBox;
}

QString CopyJob::mailBox() const
{
    Q_D(const CopyJob);
    return d->mailBox;
}

void CopyJob::setSequenceSet(const ImapSet &set)
{
    Q_D(CopyJob);
    d->set = set;
}

ImapSet CopyJob::sequenceSet() const
{
    Q_D(const CopyJob);
    return d->set;
}

void CopyJob::setUidBased(bool uidBased)
{
    Q_D(CopyJob);
    d->uidBased = uidBased;
}

bool CopyJob::isUidBased() const
{
    Q_D(const CopyJob);
    return d->uidBased;
}

ImapSet CopyJob::resultingUids() const
{
    Q_D(const CopyJob);
    return d->resultingUids;
}

void CopyJob::doStart()
{
    Q_D(CopyJob);

d->set.optimize();
    QByteArray parameters = d->set.toImapSequenceSet() + ' ';
    parameters += '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"';

QByteArray command = "COPY";
    if (d->uidBased) {
        command = "UID " + command;
    }

d->tags << d->sessionInternal()->sendCommand(command, parameters);
}

void CopyJob::handleResponse(const Response &response)
{
    Q_D(CopyJob);
    for (auto it = response.responseCode.cbegin(), end = response.responseCode.cend();
         it != end; ++it) {
        if (it->toString() == "COPYUID") {
            it = it + 3;
            if (it < end) {
                d->resultingUids = ImapSet::fromImapSequenceSet(it->toString());
            }
            break;
        }
    }

handleErrorReplies(response);
}
0707010000003F000081A40000000200000002000000015ED129EC00000F40000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/copyjob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_COPYJOB_H
#define KIMAP_COPYJOB_H

#include "kimap_export.h"

#include "job.h"
#include "imapset.h"

namespace KIMAP
{

class Session;
struct Message;
class CopyJobPrivate;

/**
 * Copies one or more messages to another mailbox.
 *
 * This job can only be run when the session is in the selected state.
 *
 * If the server supports ACLs, the user will need the
 * Acl::Insert right on the target mailbox.
 * In order to preserve message flags, the user may also need
 * some combination of Acl::DeleteMessage,
 * Acl::KeepSeen and Acl::Write on the
 * target mailbox.
 */
class KIMAP_EXPORT CopyJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(CopyJob)

friend class SessionPrivate;

public:
    explicit CopyJob(Session *session);
    ~CopyJob() override;

/**
     * Sets the destination mailbox.
     *
     * If the mailbox does not exist, the server should not create
     * it automatically and the job should fail.  Note, however,
     * that a conforming server may create the mailbox automatically.
     *
     * @param mailBox  the (unquoted) name of the mailbox where the
     *                 messages should be copied to
     */
    void setMailBox(const QString &mailBox);
    /**
     * The destination mailbox
     */
    Q_REQUIRED_RESULT QString mailBox() const;

/**
     * Sets the messages to be copied
     *
     * If sequence numbers are given, isUidBased() should be false.  If UIDs
     * are given, isUidBased() should be true.
     *
     * RFC 3501 is unclear as to what should happen if invalid sequence numbers
     * are passed.  If non-existent UIDs are passed, they will be ignored.
     *
     * @param set  the sequence numbers or UIDs of the messages to be copied
     */
    void setSequenceSet(const ImapSet &set);
    /**
     * The messages that will be copied.
     *
     * isUidBased() can be used to check whether the ImapSet contains
     * sequence numbers or UIDs.
     *
     * @return  the sequence numbers or UIDs of the messages to be copied
     */
    Q_REQUIRED_RESULT ImapSet sequenceSet() const;

/**
     * Set how the sequence set should be interpreted.
     *
     * @param uidBased  if @c true the argument to setSequenceSet will be
     *                  interpreted as UIDs, if @c false it will be interpreted
     *                  as sequence numbers
     */
    void setUidBased(bool uidBased);
    /**
     * How to interpret the sequence set.
     *
     * @return  if @c true the result of sequenceSet() should be
     *          interpreted as UIDs, if @c false it should be interpreted
     *          as sequence numbers
     */
    Q_REQUIRED_RESULT bool isUidBased() const;

/**
     * The UIDs of the new copies of the messages
     *
     * This will be an empty set if no messages have been copied yet
     * or if the server does not support the UIDPLUS extension.
     */
    Q_REQUIRED_RESULT ImapSet resultingUids() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
07070100000040000081A40000000200000002000000015ED129EC000006BD000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/createjob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "createjob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "rfccodecs.h"
#include "session_p.h"

namespace KIMAP
{
class CreateJobPrivate : public JobPrivate
{
public:
    CreateJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~CreateJobPrivate() { }

QString mailBox;
};
}

using namespace KIMAP;

CreateJob::CreateJob(Session *session)
    : Job(*new CreateJobPrivate(session, i18n("Create")))
{
}

CreateJob::~CreateJob()
{
}

void CreateJob::doStart()
{
    Q_D(CreateJob);
    d->tags << d->sessionInternal()->sendCommand("CREATE", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void CreateJob::setMailBox(const QString &mailBox)
{
    Q_D(CreateJob);
    d->mailBox = mailBox;
}

QString CreateJob::mailBox() const
{
    Q_D(const CreateJob);
    return d->mailBox;
}
07070100000041000081A40000000200000002000000015ED129EC000007F6000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/createjob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_CREATEJOB_H
#define KIMAP_CREATEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class CreateJobPrivate;

/**
 * Creates a new mailbox
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * This job will fail if the mailbox already exists.
 *
 * If the server supports ACLs, the user must have the
 * Acl::CreateMailbox permission on the parent
 * mailbox.  Note that what is meant by "parent mailbox"
 * depends on the server: . and / are typical hierachy
 * delimiters.
 */
class KIMAP_EXPORT CreateJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(CreateJob)

friend class SessionPrivate;

public:
    explicit CreateJob(Session *session);
    ~CreateJob() override;

/**
     * Set the name of the new mailbox
     *
     * @param mailBox  an (unquoted) identifier that does not correspond
     *                 to an existing mailbox name
     */
    void setMailBox(const QString &mailBox);
    /**
     * The name of the mailbox that will be created
     */
    Q_REQUIRED_RESULT QString mailBox() const;

protected:
    void doStart() override;
};

}

#endif
07070100000042000081A40000000200000002000000015ED129EC00000721000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/deleteacljob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "deleteacljob.h"

#include <KLocalizedString>

#include "acljobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class DeleteAclJobPrivate : public AclJobBasePrivate
{
public:
    DeleteAclJobPrivate(Session *session, const QString &name) : AclJobBasePrivate(session, name) {}
    ~DeleteAclJobPrivate() { }
};
}

using namespace KIMAP;

DeleteAclJob::DeleteAclJob(Session *session)
    : AclJobBase(session)
{
    Q_D(DeleteAclJob);
    d->m_name = i18n("DeleteAclJob");
}

DeleteAclJob::~DeleteAclJob()
{
}

void DeleteAclJob::doStart()
{
    Q_D(DeleteAclJob);

d->tags << d->sessionInternal()->sendCommand("DELETEACL", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + "\" \"" + d->id);
}

void DeleteAclJob::setIdentifier(const QByteArray &identifier)
{
    Q_D(DeleteAclJob);
    d->setIdentifier(identifier);
}

QByteArray DeleteAclJob::identifier()
{
    Q_D(DeleteAclJob);
    return d->identifier();
}
07070100000043000081A40000000200000002000000015ED129EC00000795000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/deleteacljob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_DELETEACLJOB_H
#define KIMAP_DELETEACLJOB_H

#include "kimap_export.h"

#include "acljobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class DeleteAclJobPrivate;

/**
 * Removes an identifier from the ACL of a mailbox.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * The user must have the Acl::Admin permission
 * on the mailbox for this job to succeed (see
 * MyRightsJob).
 *
 * This job requires that the server supports the ACL
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc4314">RFC 4314</a>.
 */
class KIMAP_EXPORT DeleteAclJob : public AclJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(DeleteAclJob)

friend class SessionPrivate;

public:
    explicit DeleteAclJob(Session *session);
    ~DeleteAclJob() override;

/**
     * Sets the identifier to remove
     */
    void setIdentifier(const QByteArray &identifier);
    /**
     * The identifier that will be removed
     */
    Q_REQUIRED_RESULT QByteArray identifier();

protected:
    void doStart() override;

};

}

#endif
07070100000044000081A40000000200000002000000015ED129EC000006BD000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/deletejob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "deletejob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class DeleteJobPrivate : public JobPrivate
{
public:
    DeleteJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~DeleteJobPrivate() { }

QString mailBox;
};
}

using namespace KIMAP;

DeleteJob::DeleteJob(Session *session)
    : Job(*new DeleteJobPrivate(session, i18n("Delete")))
{
}

DeleteJob::~DeleteJob()
{
}

void DeleteJob::doStart()
{
    Q_D(DeleteJob);
    d->tags << d->sessionInternal()->sendCommand("DELETE", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void DeleteJob::setMailBox(const QString &mailBox)
{
    Q_D(DeleteJob);
    d->mailBox = mailBox;
}

QString DeleteJob::mailBox() const
{
    Q_D(const DeleteJob);
    return d->mailBox;
}
07070100000045000081A40000000200000002000000015ED129EC0000072F000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/deletejob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_DELETEJOB_H
#define KIMAP_DELETEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
class DeleteJobPrivate;

/**
 * Delete a mailbox
 *
 * Note that some servers will refuse to delete a
 * mailbox unless it is empty (ie: all mails have
 * had their \Deleted flag set, and then the
 * mailbox has been expunged).
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * If the server supports ACLs, you will need the
 * Acl::DeleteMailbox right on the mailbox.
 */
class KIMAP_EXPORT DeleteJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(DeleteJob)

friend class SessionPrivate;

public:
    explicit DeleteJob(Session *session);
    ~DeleteJob() override;

/**
     * Set the mailbox to delete.
     */
    void setMailBox(const QString &mailBox);
    /**
     * The mailbox that will be deleted.
     */
    QString mailBox() const;

protected:
    void doStart() override;
};

}

#endif
07070100000046000081A40000000200000002000000015ED129EC00000894000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/expungejob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "expungejob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class ExpungeJobPrivate : public JobPrivate
{
public:
    ExpungeJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~ExpungeJobPrivate() { }
#if 0
    QList< int > items;
#endif
};
}

using namespace KIMAP;

ExpungeJob::ExpungeJob(Session *session)
    : Job(*new ExpungeJobPrivate(session, i18n("Expunge")))
{
}

ExpungeJob::~ExpungeJob()
{
}

void ExpungeJob::doStart()
{
    Q_D(ExpungeJob);
    d->tags << d->sessionInternal()->sendCommand("EXPUNGE");
}

void ExpungeJob::handleResponse(const Response &response)
{
//  Q_D(ExpungeJob);

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 3) {
            QByteArray code = response.content[2].toString();
            if (code == "EXPUNGE") {
#if 0
                QByteArray s = response.content[1].toString();
                bool ok = true;
                int id = s.toInt(&ok);
                if (ok) {
                    d->items.append(id);
                }
                //TODO error handling
#endif
                return;
            }
        }
        qCDebug(KIMAP_LOG) << "Unhandled response: " << response.toString().constData();

}
}
07070100000047000081A40000000200000002000000015ED129EC00000694000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/expungejob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_EXPUNGEJOB_H
#define KIMAP_EXPUNGEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class ExpungeJobPrivate;

/**
 * Expunges the deleted messages in the selected mailbox.
 *
 * This permanently removes any messages that have the
 * \Deleted flag set in the selected mailbox.
 *
 * This job can only be run when the session is in the
 * selected state.
 *
 * If the server supports ACLs, the user will need the
 * Acl::Expunge right on the mailbox.
 */
class KIMAP_EXPORT ExpungeJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ExpungeJob)

friend class SessionPrivate;

public:
    explicit ExpungeJob(Session *session);
    ~ExpungeJob() override;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
07070100000048000081A40000000200000002000000015ED129EC00004C82000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/fetchjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "fetchjob.h"

#include <QTimer>
#include "kimap_debug.h"
#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class FetchJobPrivate : public JobPrivate
{
public:
    FetchJobPrivate(FetchJob *job, Session *session, const QString &name)
        : JobPrivate(session, name)
        , q(job)
        , uidBased(false)
        , gmailEnabled(false)
    { }

~FetchJobPrivate()
    { }

void parseBodyStructure(const QByteArray &structure, int &pos, KMime::Content *content);
    void parsePart(const QByteArray &structure, int &pos, KMime::Content *content);
    QByteArray parseString(const QByteArray &structure, int &pos);
    QByteArray parseSentence(const QByteArray &structure, int &pos);
    void skipLeadingSpaces(const QByteArray &structure, int &pos);

void emitPendings()
    {
        if (pendingMsgs.isEmpty()) {
            return;
        }

Q_EMIT q->messagesAvailable(pendingMsgs);

if (!pendingParts.isEmpty()) {
            Q_EMIT q->partsReceived(selectedMailBox,
                                  pendingUids, pendingParts);
            Q_EMIT q->partsReceived(selectedMailBox,
                                  pendingUids, pendingAttributes,
                                  pendingParts);
        }
        if (!pendingSizes.isEmpty() || !pendingFlags.isEmpty() || !pendingMessages.isEmpty()) {
            Q_EMIT q->headersReceived(selectedMailBox,
                                    pendingUids, pendingSizes,
                                    pendingFlags, pendingMessages);
            Q_EMIT q->headersReceived(selectedMailBox,
                                    pendingUids, pendingSizes,
                                    pendingAttributes, pendingFlags,
                                    pendingMessages);
        }
        if (!pendingMessages.isEmpty()) {
            Q_EMIT q->messagesReceived(selectedMailBox,
                                     pendingUids, pendingMessages);
            Q_EMIT q->messagesReceived(selectedMailBox,
                                     pendingUids, pendingAttributes,
                                     pendingMessages);
        }

pendingUids.clear();
        pendingMessages.clear();
        pendingParts.clear();
        pendingSizes.clear();
        pendingFlags.clear();
        pendingAttributes.clear();
        pendingMsgs.clear();
    }

FetchJob *const q;

ImapSet set;
    bool uidBased;
    FetchJob::FetchScope scope;
    QString selectedMailBox;
    bool gmailEnabled;

QTimer emitPendingsTimer;
    QMap<qint64, MessagePtr> pendingMessages;
    QMap<qint64, MessageParts> pendingParts;
    QMap<qint64, MessageFlags> pendingFlags;
    QMap<qint64, MessageAttribute> pendingAttributes;
    QMap<qint64, qint64> pendingSizes;
    QMap<qint64, qint64> pendingUids;
    QMap<qint64, Message> pendingMsgs;
};
}

using namespace KIMAP;

FetchJob::FetchScope::FetchScope():
    mode(FetchScope::Content),
    changedSince(0)
{

}

FetchJob::FetchJob(Session *session)
    : Job(*new FetchJobPrivate(this, session, i18n("Fetch")))
{
    Q_D(FetchJob);
    connect(&d->emitPendingsTimer, SIGNAL(timeout()),
            this, SLOT(emitPendings()));
}

FetchJob::~FetchJob()
{
}

void FetchJob::setSequenceSet(const ImapSet &set)
{
    Q_D(FetchJob);
    Q_ASSERT(!set.isEmpty());
    d->set = set;
}

ImapSet FetchJob::sequenceSet() const
{
    Q_D(const FetchJob);
    return d->set;
}

void FetchJob::setUidBased(bool uidBased)
{
    Q_D(FetchJob);
    d->uidBased = uidBased;
}

bool FetchJob::isUidBased() const
{
    Q_D(const FetchJob);
    return d->uidBased;
}

void FetchJob::setScope(const FetchScope &scope)
{
    Q_D(FetchJob);
    d->scope = scope;
}

FetchJob::FetchScope FetchJob::scope() const
{
    Q_D(const FetchJob);
    return d->scope;
}

bool FetchJob::setGmailExtensionsEnabled() const
{
    Q_D(const FetchJob);
    return d->gmailEnabled;
}

void FetchJob::setGmailExtensionsEnabled(bool enabled)
{
    Q_D(FetchJob);
    d->gmailEnabled = enabled;
}

QString FetchJob::mailBox() const
{
    Q_D(const FetchJob);
    return d->selectedMailBox;
}

void FetchJob::doStart()
{
    Q_D(FetchJob);

d->set.optimize();
    QByteArray parameters = d->set.toImapSequenceSet() + ' ';
    Q_ASSERT(!parameters.trimmed().isEmpty());

switch (d->scope.mode) {
    case FetchScope::Headers:
        if (d->scope.parts.isEmpty()) {
            parameters += "(RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)] FLAGS UID";
        } else {
            parameters += '(';
            for (const QByteArray &part : qAsConst(d->scope.parts)) {
                parameters += "BODY.PEEK[" + part + ".MIME] ";
            }
            parameters += "UID";
        }
        break;
    case FetchScope::Flags:
        parameters += "(FLAGS UID";
        break;
    case FetchScope::Structure:
        parameters += "(BODYSTRUCTURE UID";
        break;
    case FetchScope::Content:
        if (d->scope.parts.isEmpty()) {
            parameters += "(BODY.PEEK[] UID";
        } else {
            parameters += '(';
            for (const QByteArray &part : qAsConst(d->scope.parts)) {
                parameters += "BODY.PEEK[" + part + "] ";
            }
            parameters += "UID";
        }
        break;
    case FetchScope::Full:
        parameters += "(RFC822.SIZE INTERNALDATE BODY.PEEK[] FLAGS UID";
        break;
    case FetchScope::HeaderAndContent:
        if (d->scope.parts.isEmpty()) {
            parameters += "(BODY.PEEK[] FLAGS UID";
        } else {
            parameters += "(BODY.PEEK[HEADER.FIELDS (TO FROM MESSAGE-ID REFERENCES IN-REPLY-TO SUBJECT DATE)]";
            for (const QByteArray &part : qAsConst(d->scope.parts)) {
                parameters += " BODY.PEEK[" + part + ".MIME] BODY.PEEK[" + part + "]"; //krazy:exclude=doublequote_chars
            }
            parameters += " FLAGS UID";
        }
        break;
    case FetchScope::FullHeaders:
        parameters += "(RFC822.SIZE INTERNALDATE BODY.PEEK[HEADER] FLAGS UID";
        break;
    }

if (d->gmailEnabled) {
        parameters += " X-GM-LABELS X-GM-MSGID X-GM-THRID";
    }
    parameters += ")";

if (d->scope.changedSince > 0) {
        parameters += " (CHANGEDSINCE " + QByteArray::number(d->scope.changedSince) + ")";
    }

QByteArray command = "FETCH";
    if (d->uidBased) {
        command = "UID " + command;
    }

d->emitPendingsTimer.start(100);
    d->selectedMailBox = d->m_session->selectedMailBox();
    d->tags << d->sessionInternal()->sendCommand(command, parameters);
}

void FetchJob::handleResponse(const Response &response)
{
    Q_D(FetchJob);

// We can predict it'll be handled by handleErrorReplies() so stop
    // the timer now so that result() will really be the last emitted signal.
    if (!response.content.isEmpty() &&
            d->tags.size() == 1 &&
            d->tags.contains(response.content.first().toString())) {
        d->emitPendingsTimer.stop();
        d->emitPendings();
    }

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() == 4 &&
                response.content[2].toString() == "FETCH" &&
                response.content[3].type() == Response::Part::List) {

qint64 id = response.content[1].toString().toLongLong();
            QList<QByteArray> content = response.content[3].toList();

Message msg;
            MessagePtr message(new KMime::Message);
            bool shouldParseMessage = false;
            MessageParts parts;

for (QList<QByteArray>::ConstIterator it = content.constBegin();
                    it != content.constEnd(); ++it) {
                QByteArray str = *it;
                ++it;

if (it == content.constEnd()) {   // Uh oh, message was truncated?
                    qCWarning(KIMAP_LOG) << "FETCH reply got truncated, skipping.";
                    break;
                }

if (str == "UID") {
                    d->pendingUids[id] = msg.uid = it->toLongLong();
                } else if (str == "RFC822.SIZE") {
                    d->pendingSizes[id] = msg.size = it->toLongLong();
                } else if (str == "INTERNALDATE") {
                    message->date()->setDateTime(QDateTime::fromString(QLatin1String(*it), Qt::RFC2822Date));
                } else if (str == "FLAGS") {
                    if ((*it).startsWith('(') && (*it).endsWith(')')) {
                        QByteArray str = *it;
                        str.chop(1);
                        str.remove(0, 1);
                        const auto flags = str.split(' ');
                        d->pendingFlags[id] = flags;
                        msg.flags = flags;
                    } else {
                        d->pendingFlags[id] << *it;
                        msg.flags << *it;
                    }
                } else if (str == "X-GM-LABELS") {
                    d->pendingAttributes.insert(id, { "X-GM-LABELS", *it });
                    msg.attributes.insert("X-GM-LABELS", *it);
                } else if (str == "X-GM-THRID") {
                    d->pendingAttributes.insert(id, { "X-GM-THRID", *it });
                    msg.attributes.insert("X-GM-THRID", *it);
                } else if (str == "X-GM-MSGID") {
                    d->pendingAttributes.insert(id, { "X-GM-MSGID", *it });
                    msg.attributes.insert("X-GM-MSGID", *it);
                } else if (str == "BODYSTRUCTURE") {
                    int pos = 0;
                    d->parseBodyStructure(*it, pos, message.data());
                    message->assemble();
                    d->pendingMessages[id] = message;
                    msg.message = message;
                } else if (str.startsWith("BODY[")) {     //krazy:exclude=strings
                    if (!str.endsWith(']')) {     // BODY[ ... ] might have been split, skip until we find the ]
                        while (!(*it).endsWith(']')) {
                            ++it;
                        }
                        ++it;
                    }

int index;
                    if ((index = str.indexOf("HEADER")) > 0 || (index = str.indexOf("MIME")) > 0) {           // headers
                        if (str[index - 1] == '.') {
                            QByteArray partId = str.mid(5, index - 6);
                            if (!parts.contains(partId)) {
                                parts[partId] = ContentPtr(new KMime::Content);
                            }
                            parts[partId]->setHead(*it);
                            parts[partId]->parse();
                            d->pendingParts[id] = parts;
                            msg.parts = parts;
                        } else {
                            message->setHead(*it);
                            shouldParseMessage = true;
                        }
                    } else { // full payload
                        if (str == "BODY[]") {
                            message->setContent(KMime::CRLFtoLF(*it));
                            shouldParseMessage = true;

d->pendingMessages[id] = message;
                            msg.message = message;
                        } else {
                            QByteArray partId = str.mid(5, str.size() - 6);
                            if (!parts.contains(partId)) {
                                parts[partId] = ContentPtr(new KMime::Content);
                            }
                            parts[partId]->setBody(*it);
                            parts[partId]->parse();

d->pendingParts[id] = parts;
                            msg.parts = parts;
                        }
                    }
                }
            }

if (shouldParseMessage) {
                message->parse();
            }

// For the headers mode the message is built in several
            // steps, hence why we wait it to be done until putting it
            // in the pending queue.
            if (d->scope.mode == FetchScope::Headers ||
                    d->scope.mode == FetchScope::HeaderAndContent ||
                    d->scope.mode == FetchScope::FullHeaders) {
                d->pendingMessages[id] = message;
                msg.message = message;
            }

d->pendingMsgs[id] = msg;
        }
    }
}

void FetchJobPrivate::parseBodyStructure(const QByteArray &structure, int &pos, KMime::Content *content)
{
    skipLeadingSpaces(structure, pos);

if (structure[pos] != '(') {
        return;
    }

pos++;

if (structure[pos] != '(') {   // simple part
        pos--;
        parsePart(structure, pos, content);
    } else { // multi part
        content->contentType()->setMimeType("MULTIPART/MIXED");
        while (pos < structure.size() && structure[pos] == '(') {
            KMime::Content *child = new KMime::Content;
            content->addContent(child);
            parseBodyStructure(structure, pos, child);
            child->assemble();
        }

QByteArray subType = parseString(structure, pos);
        content->contentType()->setMimeType("MULTIPART/" + subType);

QByteArray parameters = parseSentence(structure, pos);   // FIXME: Read the charset
        if (parameters.contains("BOUNDARY")) {
            content->contentType()->setBoundary(parameters.remove(0, parameters.indexOf("BOUNDARY") + 11).split('\"')[0]);
        }

parseSentence(structure, pos);   // Ditch the body language
    }

// Consume what's left
    while (pos < structure.size() && structure[pos] != ')') {
        skipLeadingSpaces(structure, pos);
        parseSentence(structure, pos);
        skipLeadingSpaces(structure, pos);
    }

pos++;
}

void FetchJobPrivate::parsePart(const QByteArray &structure, int &pos, KMime::Content *content)
{
    if (structure[pos] != '(') {
        return;
    }

pos++;

QByteArray mainType = parseString(structure, pos);
    QByteArray subType = parseString(structure, pos);

content->contentType()->setMimeType(mainType + '/' + subType);

parseSentence(structure, pos);   // Ditch the parameters... FIXME: Read it to get charset and name
    parseString(structure, pos);   // ... and the id

content->contentDescription()->from7BitString(parseString(structure, pos));

parseString(structure, pos);   // Ditch the encoding too
    parseString(structure, pos);   // ... and the size
    parseString(structure, pos);   // ... and the line count

QByteArray disposition = parseSentence(structure, pos);
    if (disposition.contains("INLINE")) {
        content->contentDisposition()->setDisposition(KMime::Headers::CDinline);
    } else if (disposition.contains("ATTACHMENT")) {
        content->contentDisposition()->setDisposition(KMime::Headers::CDattachment);
    }
    if ((content->contentDisposition()->disposition() == KMime::Headers::CDattachment ||
            content->contentDisposition()->disposition() == KMime::Headers::CDinline) &&
            disposition.contains("FILENAME")) {
        QByteArray filename = disposition.remove(0, disposition.indexOf("FILENAME") + 11).split('\"')[0];
        content->contentDisposition()->setFilename(QLatin1String(filename));
    }

QByteArray FetchJobPrivate::parseSentence(const QByteArray &structure, int &pos)
{
    QByteArray result;
    int stack = 0;

skipLeadingSpaces(structure, pos);

if (structure[pos] != '(') {
        return parseString(structure, pos);
    }

int start = pos;

do {
        switch (structure[pos]) {
        case '(':
            pos++;
            stack++;
            break;
        case ')':
            pos++;
            stack--;
            break;
        case '[':
            pos++;
            stack++;
            break;
        case ']':
            pos++;
            stack--;
            break;
        default:
            skipLeadingSpaces(structure, pos);
            parseString(structure, pos);
            skipLeadingSpaces(structure, pos);
            break;
        }
    } while (pos < structure.size() && stack != 0);

result = structure.mid(start, pos - start);

return result;
}

QByteArray FetchJobPrivate::parseString(const QByteArray &structure, int &pos)
{
    QByteArray result;

skipLeadingSpaces(structure, pos);

int start = pos;
    bool foundSlash = false;

// quoted string
    if (structure[pos] == '"') {
        pos++;
        Q_FOREVER {
        if (structure[pos] == '\\')
            {
                pos += 2;
                foundSlash = true;
                continue;
            }
            if (structure[pos] == '"')
            {
                result = structure.mid(start + 1, pos - start - 1);
                pos++;
                break;
            }
            pos++;
        }
    } else { // unquoted string
        Q_FOREVER {
        if (structure[pos] == ' ' ||
            structure[pos] == '(' ||
            structure[pos] == ')' ||
            structure[pos] == '[' ||
            structure[pos] == ']' ||
            structure[pos] == '\n' ||
            structure[pos] == '\r' ||
            structure[pos] == '"')
            {
                break;
            }
            if (structure[pos] == '\\')
            {
                foundSlash = true;
            }
            pos++;
        }

result = structure.mid(start, pos - start);

// transform unquoted NIL
        if (result == "NIL") {
            result.clear();
        }
    }

// simplify slashes
    if (foundSlash) {
        while (result.contains("\\\"")) {
            result.replace("\\\"", "\"");
        }
        while (result.contains("\\\\")) {
            result.replace("\\\\", "\\");
        }
    }

return result;
}

void FetchJobPrivate::skipLeadingSpaces(const QByteArray &structure, int &pos)
{
    while (pos < structure.size() && structure[pos] == ' ') {
        pos++;
    }
}

#include "moc_fetchjob.cpp"
07070100000049000081A40000000200000002000000015ED129EC000040C0000000000000000000000000000000000000003800000000kimap-VERSIONgit.20200529T172740~a5402d2/src/fetchjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_FETCHJOB_H
#define KIMAP_FETCHJOB_H

#include "kimap_export.h"

#include "imapset.h"
#include "job.h"

#include <kmime/kmime_content.h>
#include <kmime/kmime_message.h>

namespace KIMAP
{

class Session;
struct Response;
class FetchJobPrivate;

typedef QSharedPointer<KMime::Content> ContentPtr;
typedef QMap<QByteArray, ContentPtr> MessageParts;

typedef QSharedPointer<KMime::Message> MessagePtr;
typedef QList<QByteArray> MessageFlags;

typedef QPair<QByteArray, QVariant> MessageAttribute;

struct Message
{
    qint64 uid;
    qint64 size;
    MessageFlags flags;
    QMap<QByteArray, QVariant> attributes;
    MessageParts parts;
    MessagePtr message;
};

/**
 * Fetch message data from the server
 *
 * All data is returned using the signals, so you need to connect to
 * the relevant signal (or all of them) before starting the job.
 *
 * This job will always use BODY.PEEK rather than BODY to fetch message
 * content, so it will not set the \Seen flag.
 *
 * This job can only be run when the session is in the selected state.
 */
class KIMAP_EXPORT FetchJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(FetchJob)

friend class SessionPrivate;

public:
    /**
     * Used to indicate what message data should be fetched.
     *
     * This doesn't provide the same fine-grained control over
     * what is fetched that the IMAP FETCH command normally
     * does, but the common cases are catered for.
     */
    class KIMAP_EXPORT FetchScope
    {
    public:
        FetchScope();

/**
         * Used to indicate what part of the message should be fetched.
         */
        enum Mode {
            /**
             * Fetch RFC-2822 or MIME message headers.
             *
             * To fetch MIME headers for a MIME part, populate the @p parts field.
             *
             * If the RFC-2822 headers are requested (so @p parts is empty), the
             * returned information is:
             * - To, From, Message-id, References In-Reply-To, Subject and Date headers
             * - The message size (in octets)
             * - The internal date of the message
             * - The message flags
             * - The message UID
             */
            Headers,
            /**
             * Fetch the message flags (the UID is also fetched)
             */
            Flags,
            /**
             * Fetch the MIME message body structure (the UID is also fetched)
             */
            Structure,
            /**
             * Fetch the message content (the UID is also fetched)
             *
             * To fetch only certain MIME parts (see Structure), populate the
             * @p parts field.
             */
            Content,
            /**
             * Fetch the complete message.
             */
            Full,
            /**
             * Fetch the message MIME headers and the content of parts specified in the @p parts
             * field.
             *
             * If @p parts is empty, this mode will return the full message, just like
             * FetchScope::Content
             *
             * Use case:
             * -# Start a FetchJob with the FetchScope::Structure mode to retrieve the structure
             *    of the message.
             * -# Parse the structure to identify the parts that are interesting (ie: probably
             *    everything but attachments).
             * -# Start another FetchJob with FetchScope::HeaderAndContent to fetch those parts.
             * -# At the request of the user, you can repeat the step above to fetch the attachments.
             *
             * @since 4.7
             */
            HeaderAndContent,

/**
             * Fetch message size (in octets), internal date of the message, flags, UID
             * and all RFC822 headers.
             *
             * The @p parts field is ignored when using this scope
             *
             * @since 4.12
             */
            FullHeaders
        };

/**
         * Specify which message parts to operate on.
         *
         * This refers to multipart-MIME message parts or MIME-IMB encapsulated
         * message parts.
         *
         * Note that this is ignored unless @p mode is Headers or Content.
         *
         * If @p mode is Headers, this sets the parts to get the MIME headers
         * for.  If this list is empty, the headers for the whole message
         * (the RFC-2822 headers) are fetched.
         *
         * If @p mode is Content, this sets the parts to fetch.  Parts are
         * fetched wholesale.  If this list is empty, the whole message body
         * is fetched (all MIME parts together).
         */
        QList<QByteArray> parts;
        /**
         * Specify what message data should be fetched.
         */
        Mode mode;

/**
         * Specify to fetch only items with mod-sequence higher then @p changedSince.
         *
         * The server must have CONDSTORE capability (RFC4551).
         *
         * Default value is 0 (ignored).
         *
         * @since 4.12
         */
        quint64 changedSince;
    };

explicit FetchJob(Session *session);
    ~FetchJob() override;

/**
     * Set which messages to fetch data for.
     *
     * If sequence numbers are given, isUidBased() should be false.  If UIDs
     * are given, isUidBased() should be true.
     *
     * @param set  the sequence numbers or UIDs of the messages to fetch data for
     */
    void setSequenceSet(const ImapSet &set);
    /**
     * The messages that will be fetched.
     */
    ImapSet sequenceSet() const;

/**
     * Sets what data should be fetched.
     *
     * The default scope is FetchScope::Content (all content parts).
     *
     * @param scope  a FetchScope object describing what data
     *               should be fetched
     */
    void setScope(const FetchScope &scope);
    /**
     * Specifies what data will be fetched.
     */
    FetchScope scope() const;

// TODO: KF5: Move this to FetchScope
    /**
     * Enables retrieving of Gmail-specific extensions
     *
     * The FETCH response will contain X-GM-MSGID, X-GM-THRID and X-GM-LABELS
     *
     * Do NOT enable this, unless talking to Gmail servers, otherwise the
     * request may fail.
     *
     * @param enabled Whether the Gmail support should be enabled
     * @since 4.14
     */
    void setGmailExtensionsEnabled(bool enabled);

/**
     * Returns whether Gmail support is enabled
     *
     * @since 4.14
     * @see setGmailExtensionsEnabled()
     */
    bool setGmailExtensionsEnabled() const;

/**
     * Returns the name of the mailbox the fetch job is executed on.
     *
     * Can only be accessed after the job is actually started, before that
     * returns an empty string.
     *
     * @since 5.6
     */
    QString mailBox() const;

Q_SIGNALS:
    /**
     * Provides header and message results.
     *
     * This signal will be emitted if the requested scope mode
     * was FetchScope::Full, FetchScope::Flags or
     * FetchScope::Headers with no parts specified
     *
     * This signal may be emitted any number of times before
     * the result() signal is emitted.  The result() signal will
     * only be emitted once all results have been reported via
     * one of the signals.
     *
     * Note that, depending on the scope, some of the parameters
     * of this signal may be empty maps.
     *
     * @param mailBox  the name of the mailbox the fetch job was
     *                 executed on
     * @param uids     a map from message sequence numbers to message UIDs;
     *                 this will always be populated
     * @param sizes    a map from message sequence numbers to message sizes
     *                 (sizes are in octets and refer to the transfer encoding of
     *                 the message); populated if the scope is FetchScope::Full or
     *                 FetchScope::Headers
     * @param flags    a map from message sequence numbers to message flags;
     *                 populated if the scope is FetchScope::Flags, FetchScope::Full
     *                 of FetchScope::Headers
     * @param messages a map from message sequence numbers to message contents (including
     *                 headers); populated if the scope is FetchScope::Full,
     *                 FetchScope::Headers or FetchScope::Structure
     *
     * @deprecated Use messagesAvailable() instead.
     */
    KIMAP_DEPRECATED
    void headersReceived(const QString &mailBox,
                         const QMap<qint64, qint64> &uids,
                         const QMap<qint64, qint64> &sizes,
                         const QMap<qint64, KIMAP::MessageFlags> &flags,
                         const QMap<qint64, KIMAP::MessagePtr> &messages);

/**
     * An overloaded version of headersReceived(), which includes additional attribute
     * specified in the FETCH response, but that don't belong to actual content of the
     * message.
     *
     * @param mailBox  the name of the mailbox the fetch job was
     *                 executed on
     * @param uids     a map from message sequence numbers to message UIDs;
     *                 this will always be populated
     * @param attrs    a map from message sequence numbers to a pair of attribute
     *                 name and value
     * @param sizes    a map from message sequence numbers to message sizes
     *                 (sizes are in octets and refer to the transfer encoding of
     *                 the message); populated if the scope is FetchScope::Full or
     *                 FetchScope::Headers
     * @param flags    a map from message sequence numbers to message flags;
     *                 populated if the scope is FetchScope::Flags, FetchScope::Full
     *                 of FetchScope::Headers
     * @param messages a map from message sequence numbers to message contents (including
     *                 headers); populated if the scope is FetchScope::Full,
     *                 FetchScope::Headers or FetchScope::Structure
     *
     * @overload
     * @since 4.14
     * @deprecated Use messagesAvailable() instead.
     */
    KIMAP_DEPRECATED
    void headersReceived(const QString &mailBox,
                         const QMap<qint64, qint64> &uids,
                         const QMap<qint64, qint64> &sizes,
                         const QMap<qint64, KIMAP::MessageAttribute > &attrs,
                         const QMap<qint64, KIMAP::MessageFlags> &flags,
                         const QMap<qint64, KIMAP::MessagePtr> &messages);

/**
     * Provides header and message results.
     *
     * This signal will be emitted if the requested scope mode
     * was FetchScope::Content or FetchScope::Headers with no
     * parts specified or FetchScope::Structure.
     *
     * This signal may be emitted any number of times before
     * the result() signal is emitted.  The result() signal will
     * only be emitted once all results have been reported via
     * one of the signals.
     *
     *
     * @param mailBox  the name of the mailbox the fetch job was
     *                 executed on
     * @param uids     a map from message sequence numbers to message UIDs
     * @param messages a map from message sequence numbers to message contents
     *
     * @deprecated Use messagesAvailable() instead.
     */
    KIMAP_DEPRECATED
    void messagesReceived(const QString &mailBox,
                          const QMap<qint64, qint64> &uids,
                          const QMap<qint64, KIMAP::MessagePtr> &messages);

/**
     * An overloaded version of messagesReceived(), which includes additional attribute
     * specified in the FETCH response, but that don't belong to actual content of the
     * message.
     *
     * @param mailBox  the name of the mailbox the fetch job was
     *                 executed on
     * @param uids     a map from message sequence numbers to message UIDs
     * @param attrs    a map from message sequence numbers to pair of attribute
     *                 name and it's value
     * @param messages a map from message sequence numbers to message contents
     *
     * @overload
     * @since 4.14
     *
     * @deprecated Use messagesAvailable() instead.
     */
    KIMAP_DEPRECATED
    void messagesReceived(const QString &mailBox,
                          const QMap<qint64, qint64> &uids,
                          const QMap<qint64, KIMAP::MessageAttribute > &attrs,
                          const QMap<qint64, KIMAP::MessagePtr> &messages);
    /**
     * Provides header and message results.
     *
     * This signal will be emitted if the requested scope mode
     * was FetchScope::Content or FetchScope::Headers with
     * specified parts.
     *
     * This signal may be emitted any number of times before
     * the result() signal is emitted.  The result() signal will
     * only be emitted once all results have been reported via
     * one of the signals.
     *
     * @param mailBox  the name of the mailbox the fetch job was
     *                 executed on
     * @param uids     a map from message sequence numbers to message UIDs
     * @param parts    a map from message sequence numbers to message part collections
     *
     * @deprecated Use messagesAvailable() instead.
     */
    KIMAP_DEPRECATED
    void partsReceived(const QString &mailBox,
                       const QMap<qint64, qint64> &uids,
                       const QMap<qint64, KIMAP::MessageParts> &parts);

/**
      * An overloaded version of partsReceived(), which includes additional attribute
      * specified in the FETCH response, but that don't belong to actual content of the
      * message.
      *
      * @param mailBox  the name of the mailbox the fetch job was
      *                 executed on
      * @param uids     a map from message sequence numbers to message UIDs
      * @param attrs    a map from message sequence numbers to pair of attribute
      * @param parts    a map from message sequence numbers to message part collections
      *
      * @overload
      * @since 4.14
      *
      * @deprecated Use messagesAvailable() instead.
      */
    KIMAP_DEPRECATED
    void partsReceived(const QString &mailBox,
                       const QMap<qint64, qint64> &uids,
                       const QMap<qint64, KIMAP::MessageAttribute > &attrs,
                       const QMap<qint64, KIMAP::MessageParts> &parts);

/**
     * Provides received messages.
     *
     * This signal is emitted when some data are received. The signal can be
     * emitted multiple times as the messages are being received.
     *
     * @param messages A map from message sequence number to message. Not all
     *                 fields may be populated, depending on the fetch scope.
     *
     * @since 5.6
     */
    void messagesAvailable(const QMap<qint64, KIMAP::Message> &messages);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

private:
    Q_PRIVATE_SLOT(d_func(), void emitPendings())
};

}

#endif
0707010000004A000081A40000000200000002000000015ED129EC00000B9E000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getacljob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "getacljob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include "acljobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class GetAclJobPrivate : public AclJobBasePrivate
{
public:
    GetAclJobPrivate(Session *session, const QString &name) : AclJobBasePrivate(session, name) {}
    ~GetAclJobPrivate() { }

QMap<QByteArray, Acl::Rights> userRights;
};
}

using namespace KIMAP;

GetAclJob::GetAclJob(Session *session)
    : AclJobBase(*new GetAclJobPrivate(session, i18n("GetAcl")))
{
}

GetAclJob::~GetAclJob()
{
}

void GetAclJob::doStart()
{
    Q_D(GetAclJob);

d->tags << d->sessionInternal()->sendCommand("GETACL", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void GetAclJob::handleResponse(const Response &response)
{
    Q_D(GetAclJob);
//   qCDebug(KIMAP_LOG) << response.toString();

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 4 &&
                response.content[1].toString() == "ACL") {
            int i = 3;
            while (i < response.content.size() - 1) {
                QByteArray id = response.content[i].toString();
                QByteArray rights = response.content[i + 1].toString();
                d->userRights[id] = Acl::rightsFromString(rights);
                i += 2;
            }
        }
    }
}

QList<QByteArray> GetAclJob::identifiers() const
{
    Q_D(const GetAclJob);
    return d->userRights.keys();
}

bool GetAclJob::hasRightEnabled(const QByteArray &identifier, Acl::Right right) const
{
    Q_D(const GetAclJob);
    if (d->userRights.contains(identifier)) {
        Acl::Rights rights = d->userRights[identifier];
        return rights & right;
    }

return false;
}

Acl::Rights GetAclJob::rights(const QByteArray &identifier) const
{
    Q_D(const GetAclJob);
    Acl::Rights result;
    if (d->userRights.contains(identifier)) {
        result = d->userRights[identifier];
    }
    return result;
}

QMap<QByteArray, Acl::Rights> GetAclJob::allRights() const
{
    Q_D(const GetAclJob);
    return d->userRights;
}
0707010000004B000081A40000000200000002000000015ED129EC00001127000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getacljob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_GETACLJOB_H
#define KIMAP_GETACLJOB_H

#include "kimap_export.h"

#include "acljobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class GetAclJobPrivate;

/**
 * Gets the ACL for a mailbox
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * The user must have the Acl::Admin permission
 * on the mailbox for this job to succeed (see
 * MyRightsJob).
 *
 * This job requires that the server supports the ACL
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc4314">RFC 4314</a>.
 *
 * The meaning of identifiers depends on the server implementation,
 * with the following restrictions:
 *
 * - "anyone" means any authenticated user, including anonymous
 * - an identifier starting with a minus sign ('-') indicates
 *   "negative rights": rights that should be taken away from
 *   matching users
 *
 * Other than the above restrictions, ACL identifiers are usually
 * IMAP usernames, but could potentially be group names as well.
 *
 * Note that negative rights override positive rights: if
 * "fred" and "-fred" are both assigned the 'w' right, the
 * user "fred" will not have the 'w' right.
 */
class KIMAP_EXPORT GetAclJob : public AclJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(GetAclJob)

friend class SessionPrivate;

public:
    explicit GetAclJob(Session *session);
    ~GetAclJob() override;

/**
     * The identifiers present in the ACL.
     *
     * This method will return an empty list if the job has
     * not yet been run.
     *
     * See the GetAclJob documentation for an explanation of
     * identifiers; in particular, identifiers starting with
     * '-' specify negative rights.
     */
    QList<QByteArray> identifiers() const;
    /**
     * Check whether an identifier has a given right set
     *
     * The result of this method is undefined if the job has
     * not yet completed.
     *
     * See the GetAclJob documentation for an explanation of
     * identifiers; in particular, identifiers starting with
     * '-' specify negative rights.
     *
     * Note that this will not tell you whether the net result
     * of all the ACL entries means that a given user has
     * a certain right.
     *
     * @param identifier  the identifier to check the rights for
     * @param right       the right to check for
     */
    bool hasRightEnabled(const QByteArray &identifier, Acl::Right right) const;
    /**
     * Get the rights associated with an identifier.
     *
     * The result of this method is undefined if the job has
     * not yet completed.
     *
     * See the GetAclJob documentation for an explanation of
     * identifiers; in particular, identifiers starting with
     * '-' specify negative rights.
     *
     * Note that this will not tell you the rights that a
     * given user will have once all the ACL entries have
     * been taken into account.
     *
     * @param identifier  the identifier to check the rights for
     */
    Acl::Rights rights(const QByteArray &identifier) const;

/**
     * Gets the full access control list.
     *
     * The result of this method is undefined if the job has
     * not yet completed.
     *
     * See the GetAclJob documentation for an explanation of
     * identifiers; in particular, identifiers starting with
     * '-' specify negative rights.
     */
    QMap<QByteArray, Acl::Rights> allRights() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
0707010000004C000081A40000000200000002000000015ED129EC00002247000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getmetadatajob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "getmetadatajob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include "metadatajobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class GetMetaDataJobPrivate : public MetaDataJobBasePrivate
{
public:
    GetMetaDataJobPrivate(Session *session, const QString &name) : MetaDataJobBasePrivate(session, name), maxSize(-1), depth("0") { }
    ~GetMetaDataJobPrivate() { }

qint64 maxSize;
    QByteArray depth;
    QSet<QByteArray> entries;
    QSet<QByteArray> attributes;
    QMap<QString, QMap<QByteArray, QMap<QByteArray, QByteArray> > > metadata;
    //    ^ mailbox        ^ entry          ^attribute  ^ value
};
}

using namespace KIMAP;

GetMetaDataJob::GetMetaDataJob(Session *session)
    : MetaDataJobBase(*new GetMetaDataJobPrivate(session, i18n("GetMetaData")))
{
}

GetMetaDataJob::~GetMetaDataJob()
{
}

static QList<QByteArray> sort(const QSet<QByteArray> &set)
{
    QList<QByteArray> sortedEntries = set.values();
    std::sort(sortedEntries.begin(), sortedEntries.end());
    return sortedEntries;
}

void GetMetaDataJob::doStart()
{
    Q_D(GetMetaDataJob);
    QByteArray parameters;
    parameters = '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + "\" ";

QByteArray command = "GETMETADATA";
    if (d->serverCapability == Annotatemore) {
        d->m_name = i18n("GetAnnotation");
        command = "GETANNOTATION";
        if (d->entries.size() > 1) {
            parameters += '(';
        }
        Q_FOREACH (const QByteArray &entry, sort(d->entries)) {
            parameters += '\"' + entry + "\" ";
        }
        if (d->entries.size() > 1) {
            parameters[parameters.length() - 1 ] = ')';
            parameters += ' ';
        }

if (d->attributes.size() > 1) {
            parameters += '(';
        }
        Q_FOREACH (const QByteArray &attribute, sort(d->attributes)) {
            parameters += '\"' + attribute + "\" ";
        }
        if (d->attributes.size() > 1) {
            parameters[parameters.length() - 1 ] = ')';
        } else {
            parameters.chop(1);
        }

} else {

QByteArray options;
        if (d->depth != "0") {
            options = "DEPTH " + d->depth;
        }
        if (d->maxSize != -1) {
            if (!options.isEmpty()) {
                options += ' ';
            }
            options += "MAXSIZE " + QByteArray::number(d->maxSize);
        }

if (!options.isEmpty()) {
            parameters = "(" + options + ") " + parameters;
        }

if (d->entries.size() >= 1) {
            parameters += '(';
            Q_FOREACH (const QByteArray &entry, sort(d->entries)) {
                parameters += entry + " ";
            }
            parameters[parameters.length() - 1 ] = ')';
        } else {
            parameters.chop(1);
        }
    }

d->tags << d->sessionInternal()->sendCommand(command, parameters);
//  qCDebug(KIMAP_LOG) << "SENT: " << command << " " << parameters;
}

void GetMetaDataJob::handleResponse(const Response &response)
{
    Q_D(GetMetaDataJob);
//  qCDebug(KIMAP_LOG) << "GOT: " << response.toString();

//TODO: handle NO error messages having [METADATA MAXSIZE NNN], [METADATA TOOMANY], [METADATA NOPRIVATE] (see rfc5464)
    // or [ANNOTATEMORE TOOBIG], [ANNOTATEMORE TOOMANY] respectively
    if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 4) {
            if (d->serverCapability == Annotatemore && response.content[1].toString() == "ANNOTATION") {
                QString mailBox = QString::fromUtf8(KIMAP::decodeImapFolderName(response.content[2].toString()));

int i = 3;
                while (i < response.content.size() - 1) {
                    QByteArray entry = response.content[i].toString();
                    QList<QByteArray> attributes = response.content[i + 1].toList();
                    int j = 0;
                    while (j < attributes.size() - 1) {
                        d->metadata[mailBox][entry][attributes[j]] = attributes[j + 1];
                        j += 2;
                    }
                    i += 2;
                }
            } else if (d->serverCapability == Metadata && response.content[1].toString() == "METADATA") {
                QString mailBox = QString::fromUtf8(KIMAP::decodeImapFolderName(response.content[2].toString()));

const QList<QByteArray> &entries = response.content[3].toList();
                int i = 0;
                while (i < entries.size() - 1) {
                    const QByteArray &value = entries[i + 1];
                    QByteArray &targetValue = d->metadata[mailBox][entries[i]][""];
                    if (value != "NIL") {   //This just indicates no value
                        targetValue = value;
                    }
                    i += 2;
                }
            }
        }
    }
}

void GetMetaDataJob::addEntry(const QByteArray &entry, const QByteArray &attribute)
{
    Q_D(GetMetaDataJob);
    if (d->serverCapability == Annotatemore && attribute.isNull()) {
        qCWarning(KIMAP_LOG) << "In ANNOTATEMORE mode an attribute must be specified with addEntry!";
    }
    d->entries.insert(entry);
    d->attributes.insert(attribute);
}

void GetMetaDataJob::addRequestedEntry(const QByteArray &entry)
{
    Q_D(GetMetaDataJob);
    d->entries.insert(d->removePrefix(entry));
    d->attributes.insert(d->getAttribute(entry));
}

void GetMetaDataJob::setMaximumSize(qint64 size)
{
    Q_D(GetMetaDataJob);
    d->maxSize = size;
}

void GetMetaDataJob::setDepth(Depth depth)
{
    Q_D(GetMetaDataJob);

switch (depth) {
    case OneLevel:
        d->depth = "1"; //krazy:exclude=doublequote_chars
        break;
    case AllLevels:
        d->depth = "infinity";
        break;
    default:
        d->depth = "0"; //krazy:exclude=doublequote_chars
    }
}

QByteArray GetMetaDataJob::metaData(const QString &mailBox, const QByteArray &entry, const QByteArray &attribute) const
{
    Q_D(const GetMetaDataJob);
    QByteArray attr = attribute;

if (d->serverCapability == Metadata) {
        attr = "";
    }

QByteArray result;
    if (d->metadata.contains(mailBox)) {
        if (d->metadata[mailBox].contains(entry)) {
            result = d->metadata[mailBox][entry].value(attr);
        }
    }
    return result;
}

QByteArray GetMetaDataJob::metaData(const QByteArray &entry) const
{
    qCDebug(KIMAP_LOG) << entry;
    Q_D(const GetMetaDataJob);
    return d->metadata.value(d->mailBox).value(d->removePrefix(entry)).value(d->getAttribute(entry));
}

QMap<QByteArray, QMap<QByteArray, QByteArray> > GetMetaDataJob::allMetaData(const QString &mailBox) const
{
    Q_D(const GetMetaDataJob);
    return d->metadata[mailBox];
}

QMap<QByteArray, QByteArray> GetMetaDataJob::allMetaData() const
{
    Q_D(const GetMetaDataJob);
    return allMetaDataForMailbox(d->mailBox);
}

QMap<QByteArray, QByteArray> GetMetaDataJob::allMetaDataForMailbox(const QString &mailbox) const
{
    Q_D(const GetMetaDataJob);
    const QMap<QByteArray, QMap<QByteArray, QByteArray> > &entries = d->metadata[mailbox];
    QMap<QByteArray, QByteArray> map;
    foreach (const QByteArray &entry, entries.keys()) {
        const QMap<QByteArray, QByteArray> &values = entries[entry];
        foreach (const QByteArray &attribute, values.keys()) {
            map.insert(d->addPrefix(entry, attribute), values[attribute]);
        }
    }
    return map;
}

QHash<QString, QMap<QByteArray, QByteArray> > GetMetaDataJob::allMetaDataForMailboxes() const
{
    Q_D(const GetMetaDataJob);
    QHash<QString, QMap<QByteArray, QByteArray> > mailboxHash;

QMapIterator<QString, QMap<QByteArray, QMap<QByteArray, QByteArray> > > i(d->metadata);
    while (i.hasNext()) {
        i.next();
        mailboxHash.insert(i.key(), allMetaDataForMailbox(i.key()));
    }
    return mailboxHash;
}

0707010000004D000081A40000000200000002000000015ED129EC00002624000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getmetadatajob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_GETMETADATAJOB_H
#define KIMAP_GETMETADATAJOB_H

#include "kimap_export.h"

#include "metadatajobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class GetMetaDataJobPrivate;

/**
 * Fetches mailbox metadata.
 *
 * Provides support for the IMAP METADATA extension; both the
 * final RFC version
 * (<a href="https://tools.ietf.org/html/rfc5464">RFC 5464</a>)
 * and the older, incompatible draft version (known as ANNOTATEMORE)
 * (<a
 * href="https://tools.ietf.org/html/draft-daboo-imap-annotatemore-07"
 * >draft-daboo-imap-annotatemore-07</a>).  See setServerCompatibility().
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * If the server supports ACLs, the user will need the
 * Acl::Lookup right on the mailbox, as well as one of
 * - Acl::Read
 * - Acl::KeepSeen
 * - Acl::Write
 * - Acl::Insert
 * - Acl::Post
 * Otherwise, the user must be able to list the mailbox
 * and either read or write the message content.
 *
 * Note also that on servers that implement the Annotatemore
 * version of the extension, only Acl::Lookup rights are
 * required (ie: the user must be able to list the mailbox).
 */
class KIMAP_EXPORT GetMetaDataJob : public MetaDataJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(GetMetaDataJob)

friend class SessionPrivate;

public:
    explicit GetMetaDataJob(Session *session);
    ~GetMetaDataJob() override;

/**
     * Used to specify the depth of the metadata hierarchy to walk.
     */
    enum Depth {
        NoDepth = 0, /**< Only the requested entries */
        OneLevel,    /**< The requested entries and all their direct children */
        AllLevels    /**< The requested entries and all their descendants */
    };

Q_DECLARE_FLAGS(Depths, Depth)

/**
     * Add an entry to the query list.
     *
     * See SetMetaDataJob for a description of metadata entry names.
     *
     * When operating in Annotatemore mode, you should provide an attribute
     * name.  Typically this will be "value", "value.priv" or "value.shared",
     * although you might want to fetch the "content-type" or
     * "content-language" attributes as well.
     *
     * @param entry      the metadata entry name
     * @param attribute  the attribute name, in Annotatemore mode
     *
     * @deprecated use addRequestedEntry(QByteArray) instead
     */
    KIMAP_DEPRECATED void addEntry(const QByteArray &entry, const QByteArray &attribute = QByteArray());

/**
     * Add an entry to the query list.
     *
     * See SetMetaDataJob for a description of metadata entry names.
     *
     * Note that this expects METADATA style entries (with a /shared or /private prefix typically).
     * In ANNOTATEMORE mode, this prefix is automatically replaced with an appropriate attribute.
     *
     * @param entry the metadata entry name
     */
    void addRequestedEntry(const QByteArray &entry);

/**
     * Limits the size of returned metadata entries.
     *
     * In order to save time or bandwidth, it is possible to prevent the
     * server from returning metadata entries that are larger than a
     * certain size.  These entries will simply not appear in the
     * list returned by allMetaData(), and will not be accessible using
     * metaData().
     *
     * Note that this is only used when the server capability mode is
     * Metadata.
     *
     * The default is no limit (-1).  A value of less than -1 will cause
     * the job to fail.
     *
     * @param size  the entry size limit, in octets, or -1 for no limit
     */
    void setMaximumSize(qint64 size);

/**
     * Sets whether to retrieve children or descendants of the requested entries.
     *
     * Metadata entry names are hierarchical, much like UNIX path names.
     * It therefore makes sense to ask for an entry and all its children
     * (OneLevel) or an entry and all its descendants (AllLevels).
     *
     * For example, /shared/foo/bar/baz is a child of /shared/foo/bar and a
     * descendent of /shared/foo.  So if you request the entry "/shared/foo"
     * with depth NoDepth, you will only get the "/shared/foo" entry.  If
     * you set the depth to OneLevel, you will also get "/shared/foo/bar".
     * If you set the depth to AllLevels, you will also get
     * "/shared/foo/bar/baz", and every other metadata entry that starts
     * with "/shared/foo/".
     *
     * Note that this is only used when the server capability mode is
     * Metadata.
     *
     * @param depth  the depth of the metadata tree to return
     */
    void setDepth(Depth depth);

/**
     * Get a single metadata entry.
     *
     * The metadata must have been requested using addEntry(), and
     * the job must have completed successfully, or this method
     * will not return anything.
     *
     * Note that if setMaximumSize() was used to limit the size of
     * returned metadata, this method may return an empty QByteArray
     * even if the metadata entry was requested and exists on the
     * server.  This will happen when the metadata entry is larger
     * than the size limit given to setMaximumSize().
     *
     * @param mailBox    the mailbox the metadata is attached to, or
     *                   an empty string for server metadata
     * @param entry      the entry to get
     * @param attribute  (only in Annotatemore mode) the attribute to get
     * @return  the metadata entry value
     *
     * @deprecated use metaData(QByteArray entry) instead
     */
    // XXX: what's with the mailBox argument in a class that has setMailBox()?
    //      KJobs are not intended to be run more than once
    KIMAP_DEPRECATED QByteArray metaData(const QString &mailBox, const QByteArray &entry,
                                         const QByteArray &attribute = QByteArray()) const;

/**
     * Get a single metadata entry.
     *
     * The metadata must have been requested using addEntry(), and
     * the job must have completed successfully, or this method
     * will not return anything.
     *
     * Note that if setMaximumSize() was used to limit the size of
     * returned metadata, this method may return an empty QByteArray
     * even if the metadata entry was requested and exists on the
     * server.  This will happen when the metadata entry is larger
     * than the size limit given to setMaximumSize().
     *
     * Note that this expects METADATA style entries (with a /shared or /private prefix typically).
     * In ANNOTATEMORE mode, this prefix is automatically replaced with an appropriate attribute.
     *
     * @param entry the entry to get
     * @return  the metadata entry value
     */
    QByteArray metaData(const QByteArray &entry) const;

/**
     * Get all the metadata for a given mailbox.
     *
     * The returned map is from metadata entry names to attributes or values.
     *
     * If operating in Metadata mode, the metadata value is stored against the
     * empty QByteArray:
     * @code
     * map = job.allMetaData( "INBOX" );
     * QByteArray value = map[ "/shared/comment" ].value( QByteArray() );
     * @endcode
     *
     * The equivalent in Annotatemore mode would be:
     * @code
     * map = job.allMetaData( "INBOX" );
     * QByteArray value = map[ "/comment" ].value( "value.shared" );
     * @endcode
     *
     * @param mailBox  a mailbox name or an empty string for server metadata
     * @return  a map from metadata entry names to attributes or values
     */
    // XXX: what's with the mailBox argument in a class that has setMailBox()?
    //      KJobs are not intended to be run more than once
    QMap<QByteArray, QMap<QByteArray, QByteArray> > allMetaData(const QString &mailBox) const;

/**
     * Get all the metadata for the mailbox set with setMailBox().
     * 
     * Note that the returned map uses METADATA style entries (with a /shared or /private prefix typically),
     * also in ANNOTATEMORE mode.
     *
     * @return a map from metadata entry names to values
     */
    QMap<QByteArray, QByteArray> allMetaData() const;

/**
     * Get all the metadata for the mailbox.
     *
     * Note that the returned map uses METADATA style entries (with a /shared or /private prefix typically),
     * also in ANNOTATEMORE mode.
     *
     * @return a map from metadata entry names to values
     */
     QMap<QByteArray, QByteArray> allMetaDataForMailbox(const QString &mailbox) const;

/**
     * Get all the metadata for for all mailboxes.
     *
     * Note that the returned map uses METADATA style entries (with a /shared or /private prefix typically),
     * also in ANNOTATEMORE mode.
     *
     * @return a map in the form (mailbox, (entry, value))
     */
     QHash<QString, QMap<QByteArray, QByteArray> > allMetaDataForMailboxes() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
0707010000004E000081A40000000200000002000000015ED129EC0000083D000000000000000000000000000000000000003D00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getquotajob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "getquotajob.h"

#include <KLocalizedString>

#include "quotajobbase_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class GetQuotaJobPrivate : public QuotaJobBasePrivate
{
public:
    GetQuotaJobPrivate(Session *session, const QString &name) : QuotaJobBasePrivate(session, name) { }
    ~GetQuotaJobPrivate() { }

QByteArray root;
};
}

using namespace KIMAP;

GetQuotaJob::GetQuotaJob(Session *session)
    : QuotaJobBase(*new GetQuotaJobPrivate(session, i18n("GetQuota")))
{
}

GetQuotaJob::~GetQuotaJob()
{
}

void GetQuotaJob::doStart()
{
    Q_D(GetQuotaJob);
    //XXX: [alexmerry, 2010-07-24]: should d->root be quoted properly?
    d->tags << d->sessionInternal()->sendCommand("GETQUOTA", '\"' + d->root + '\"');
}

void GetQuotaJob::handleResponse(const Response &response)
{
    Q_D(GetQuotaJob);
    if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 4 &&
                response.content[1].toString() == "QUOTA") {
            d->quota = d->readQuota(response.content[3]);
        }
    }
}

void GetQuotaJob::setRoot(const QByteArray &root)
{
    Q_D(GetQuotaJob);
    d->root = root;
}

QByteArray GetQuotaJob::root() const
{
    Q_D(const GetQuotaJob);
    return d->root;
}
0707010000004F000081A40000000200000002000000015ED129EC000009A6000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getquotajob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_GETQUOTAJOB_H
#define KIMAP_GETQUOTAJOB_H

#include "quotajobbase.h"

namespace KIMAP
{

class Session;
struct Message;
class GetQuotaJobPrivate;

/**
 * Gets resource limits for a quota root.
 *
 * Quotas are defined with respect to "resources" and "quota roots".
 * A resource is a numerical property that can be limited, such
 * as the octet size of all the messages in a mailbox, or the
 * number of messages in a mailbox.  Each mailbox has one or more
 * quota roots, which are where the resource limits are defined.
 * A quota root may or may not be a mailbox name, and an empty
 * string is a valid quota root.  All mailboxes with the same quota
 * root share the resource limits of the quota root.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * This job requires that the server supports the QUOTA
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc2087">RFC 2087</a>.
 */
class KIMAP_EXPORT GetQuotaJob : public QuotaJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(GetQuotaJob)

friend class SessionPrivate;

public:
    explicit GetQuotaJob(Session *session);
    ~GetQuotaJob() override;

/**
     * Set the quota root to get the resource limits for.
     * @param root the quota root to set
     * @see GetQuotaRootJob
     */
    void setRoot(const QByteArray &root);
    /**
     * The quota root that resource limit information will be fetched for.
     */
    Q_REQUIRED_RESULT QByteArray root() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
07070100000050000081A40000000200000002000000015ED129EC000014FA000000000000000000000000000000000000004100000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getquotarootjob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "getquotarootjob.h"

#include <KLocalizedString>

#include "quotajobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class GetQuotaRootJobPrivate : public QuotaJobBasePrivate
{
public:
    GetQuotaRootJobPrivate(Session *session, const QString &name) : QuotaJobBasePrivate(session, name) { }
    ~GetQuotaRootJobPrivate() { }

QString mailBox;
    QList<QByteArray> rootList;
    QMap< QByteArray, QMap<QByteArray, QPair<qint64, qint64> > > quotas;
};
}

using namespace KIMAP;

GetQuotaRootJob::GetQuotaRootJob(Session *session)
    : QuotaJobBase(*new GetQuotaRootJobPrivate(session, i18n("GetQuotaRoot")))
{
}

GetQuotaRootJob::~GetQuotaRootJob()
{
}

void GetQuotaRootJob::doStart()
{
    Q_D(GetQuotaRootJob);
    d->tags << d->sessionInternal()->sendCommand("GETQUOTAROOT", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void GetQuotaRootJob::handleResponse(const Response &response)
{
    Q_D(GetQuotaRootJob);
    if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 3) {
            if (response.content[1].toString() == "QUOTAROOT") {
                d->rootList.clear();
                //some impls don't give the root a name which for us seems as if
                //there were no message part
                if (response.content.size() == 3) {
                    d->rootList.append("");
                } else {
                    int i = 3;
                    while (i < response.content.size()) {
                        d->rootList.append(response.content[i].toString());
                        i++;
                    }
                }
            } else if (response.content[1].toString() == "QUOTA") {
                QByteArray rootName;
                int  quotaContentIndex = 3;
                //some impls don't give the root a name in the response
                if (response.content.size() == 3) {
                    quotaContentIndex = 2;
                } else {
                    rootName = response.content[2].toString();
                }

const QMap<QByteArray, QPair<qint64, qint64> > &quota = d->readQuota(response.content[quotaContentIndex]);
                if (d->quotas.contains(rootName)) {
                    d->quotas[ rootName ].unite(quota);
                } else {
                    d->quotas[ rootName ] = quota;
                }
            }
        }
    }
}

void GetQuotaRootJob::setMailBox(const QString &mailBox)
{
    Q_D(GetQuotaRootJob);
    d->mailBox = mailBox;
}

QString GetQuotaRootJob::mailBox() const
{
    Q_D(const GetQuotaRootJob);
    return d->mailBox;
}

QList<QByteArray> GetQuotaRootJob::roots() const
{
    Q_D(const GetQuotaRootJob);
    return d->rootList;
}

qint64 GetQuotaRootJob::usage(const QByteArray &root, const QByteArray &resource) const
{
    Q_D(const GetQuotaRootJob);
    QByteArray r = resource.toUpper();

if (d->quotas.contains(root) && d->quotas[root].contains(r)) {
        return d->quotas[root][r].first;
    }
    return -1;
}

qint64 GetQuotaRootJob::limit(const QByteArray &root, const QByteArray &resource) const
{
    Q_D(const GetQuotaRootJob);

QByteArray r = resource.toUpper();

if (d->quotas.contains(root) && d->quotas[root].contains(r)) {
        return d->quotas[root][r].second;
    }
    return -1;
}

QMap<QByteArray, qint64> GetQuotaRootJob::allUsages(const QByteArray &root) const
{
    Q_D(const GetQuotaRootJob);

QMap<QByteArray, qint64> result;

QMap<QByteArray, qint64> GetQuotaRootJob::allLimits(const QByteArray &root) const
{
    Q_D(const GetQuotaRootJob);

QMap<QByteArray, qint64> result;

if (d->quotas.contains(root)) {
        const QMap< QByteArray, QPair<qint64, qint64> > quota = d->quotas[root];
        QMap<QByteArray, QPair<qint64, qint64> >::const_iterator it = quota.cbegin();
        const QMap<QByteArray, QPair<qint64, qint64> >::const_iterator itEnd = quota.cend();
        for (; it != itEnd; ++it) {
            result[it.key()] = it.value().second;
        }
    }
    return result;
}
07070100000051000081A40000000200000002000000015ED129EC00001088000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/getquotarootjob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_GETQUOTAROOTJOB_H
#define KIMAP_GETQUOTAROOTJOB_H

#include "quotajobbase.h"

namespace KIMAP
{

class Session;
struct Message;
class GetQuotaRootJobPrivate;

/**
 * Gets the quota root and resource limits for a mailbox.
 *
 * Quotas are defined with respect to "resources" and "quota roots".
 * A resource is a numerical property that can be limited, such
 * as the octet size of all the messages in a mailbox, or the
 * number of messages in a mailbox.  Each mailbox has one or more
 * quota roots, which are where the resource limits are defined.
 * A quota root may or may not be a mailbox name, and an empty
 * string is a valid quota root.  All mailboxes with the same quota
 * root share the resource limits of the quota root.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * This job requires that the server supports the QUOTA
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc2087">RFC 2087</a>.
 */
class KIMAP_EXPORT GetQuotaRootJob : public QuotaJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(GetQuotaRootJob)

friend class SessionPrivate;

public:
    explicit GetQuotaRootJob(Session *session);
    ~GetQuotaRootJob() override;

/**
     * Set the mailbox to get the quota roots for.
     *
     * @param mailBox  the name of an existing mailbox
     */
    void setMailBox(const QString &mailBox);
    /**
     * The mailbox that the quota roots will be fetched for.
     */
    Q_REQUIRED_RESULT QString mailBox() const;

/**
     * The quota roots for the mailbox.
     */
    Q_REQUIRED_RESULT QList<QByteArray> roots() const;
    /**
     * Get the current usage for a resource.
     *
     * Note that if there is no limit for a resource, the
     * server will not provide information about resource
     * usage.
     *
     * @param root      the quota root to get the resource usage for
     * @param resource  the resource to get the usage for
     * @return  the resource usage in appropriate units, or -1
     *          if the usage is unknown or there is no
     *          limit on the resource
     */
    Q_REQUIRED_RESULT qint64 usage(const QByteArray &root, const QByteArray &resource) const;
    /**
     * Get the current limit for a resource.
     *
     * @param root      the quota root to get the resource limit for
     * @param resource  the resource to get the limit for
     * @return  the resource limit in appropriate units, or -1
     *          if the limit is unknown or there is no
     *          limit on the resource
     */
    Q_REQUIRED_RESULT qint64 limit(const QByteArray &root, const QByteArray &resource) const;

/**
     * Get a map containing all resource usage figures for a quota root.
     *
     * @param root  the quota root to get resource usage figures for
     * @return  a map from resource names to usage figures
     */
    Q_REQUIRED_RESULT QMap<QByteArray, qint64> allUsages(const QByteArray &root) const;
    /**
     * Get a map containing all resource limits for a quota root.
     *
     * @param root  the quota root to get resource limits for
     * @return  a map from resource names to limits
     */
    Q_REQUIRED_RESULT QMap<QByteArray, qint64> allLimits(const QByteArray &root) const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
07070100000052000081A40000000200000002000000015ED129EC000007E3000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/idjob.cpp/*
    Copyright (c) 2015 Christian Mollekopf <mollekopf@kolabsys.com>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "idjob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
    class IdJobPrivate : public JobPrivate
    {
    public:
        IdJobPrivate(Session *session,  const QString& name) : JobPrivate(session, name) { }
        ~IdJobPrivate() { }
  
        QMap<QByteArray, QByteArray> fields;
    };
}

using namespace KIMAP;

IdJob::IdJob(Session *session)
    : Job(*new IdJobPrivate(session, i18n("Id")))
{
}

IdJob::~IdJob()
{
}

void IdJob::setField(const QByteArray &name, const QByteArray &value)
{
    Q_D(IdJob);
    d->fields.insert(name, value);
}

void IdJob::doStart()
{
    Q_D(IdJob);
    QByteArray command = "ID";
    command += " (";

QMapIterator<QByteArray, QByteArray> i(d->fields);
    while (i.hasNext()) {
        i.next();
        command += "\"" + i.key() + "\" \"" + i.value() + "\" ";
    }
    command.chop(1);
    command += ")";
    d->tags << d->sessionInternal()->sendCommand(command);
}

void IdJob::handleResponse(const Response &response)
{
    //Q_D(IdJob);
    if (handleErrorReplies(response) == NotHandled) {
        // Ignore the response
    }
}
07070100000053000081A40000000200000002000000015ED129EC000005B0000000000000000000000000000000000000003500000000kimap-VERSIONgit.20200529T172740~a5402d2/src/idjob.h/*
    Copyright (c) 2015 Christian Mollekopf <mollekopf@kolabsys.com>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_IDJOB_H
#define KIMAP_IDJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP {

class Session;
struct Message;
class IdJobPrivate;

/**
 * Reports client id.
 *
 * This job can be run in any open session.
 */
class KIMAP_EXPORT IdJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(IdJob)

friend class SessionPrivate;

public:
    IdJob( Session *session);
    ~IdJob() override;

void setField(const QByteArray &name, const QByteArray &field);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
07070100000054000081A40000000200000002000000015ED129EC00001256000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/idlejob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "idlejob.h"

#include <QTimer>
#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class IdleJobPrivate : public JobPrivate
{
public:
    IdleJobPrivate(IdleJob *job, Session *session, const QString &name)
        : JobPrivate(session, name), q(job),
          messageCount(-1), recentCount(-1),
          lastMessageCount(-1), lastRecentCount(-1),
          originalSocketTimeout(-1) { }
    ~IdleJobPrivate() { }

void emitStats()
    {
        emitStatsTimer.stop();

Q_EMIT q->mailBoxStats(q, m_session->selectedMailBox(),
                             messageCount, recentCount);

lastMessageCount = messageCount;
        lastRecentCount = recentCount;

messageCount = -1;
        recentCount = -1;
    }

void resetTimeout()
    {
        sessionInternal()->setSocketTimeout(originalSocketTimeout);
    }

IdleJob *const q;

QTimer emitStatsTimer;

int messageCount;
    int recentCount;

int lastMessageCount;
    int lastRecentCount;

int originalSocketTimeout;
};
}

using namespace KIMAP;

IdleJob::IdleJob(Session *session)
    : Job(*new IdleJobPrivate(this, session, i18nc("name of the idle job", "Idle")))
{
    Q_D(IdleJob);
    connect(&d->emitStatsTimer, SIGNAL(timeout()),
            this, SLOT(emitStats()));

connect(this, SIGNAL(result(KJob*)),
            this, SLOT(resetTimeout()));
}

IdleJob::~IdleJob()
{
}

void KIMAP::IdleJob::stop()
{
    Q_D(IdleJob);
    d->sessionInternal()->setSocketTimeout(d->originalSocketTimeout);
    d->sessionInternal()->sendData("DONE");
}

void IdleJob::doStart()
{
    Q_D(IdleJob);
    d->originalSocketTimeout = d->sessionInternal()->socketTimeout();
    d->sessionInternal()->setSocketTimeout(-1);
    d->tags << d->sessionInternal()->sendCommand("IDLE");
}

void IdleJob::handleResponse(const Response &response)
{
    Q_D(IdleJob);

// We can predict it'll be handled by handleErrorReplies() so Q_EMIT
    // pending signals now (if needed) so that result() will really be
    // the last emitted signal.
    if (!response.content.isEmpty() &&
            d->tags.size() == 1 &&
            d->tags.contains(response.content.first().toString()) &&
            (d->messageCount >= 0 || d->recentCount >= 0)) {
        d->emitStats();
    }

if (handleErrorReplies(response) == NotHandled) {
        if (!response.content.isEmpty() && response.content[0].toString() == "+") {
            // Got the continuation all is fine
            return;

} else if (response.content.size() > 2) {
            const QByteArray ba = response.content[2].toString();
            if (ba == "EXISTS") {
                if (d->messageCount >= 0) {
                    d->emitStats();
                }

d->messageCount = response.content[1].toString().toInt();
            } else if (ba == "RECENT") {
                if (d->recentCount >= 0) {
                    d->emitStats();
                }

d->recentCount = response.content[1].toString().toInt();
            } else if (ba == "FETCH") {
                const qint64 uid = response.content[1].toString().toLongLong();
                Q_EMIT mailBoxMessageFlagsChanged(this, uid);
            }
        }

if (d->messageCount >= 0 && d->recentCount >= 0) {
            d->emitStats();
        } else if (d->messageCount >= 0 || d->recentCount >= 0) {
            d->emitStatsTimer.start(200);
        }
    }
}

QString KIMAP::IdleJob::lastMailBox() const
{
    Q_D(const IdleJob);
    return d->m_session->selectedMailBox();
}

int KIMAP::IdleJob::lastMessageCount() const
{
    Q_D(const IdleJob);
    return d->lastMessageCount;
}

int KIMAP::IdleJob::lastRecentCount() const
{
    Q_D(const IdleJob);
    return d->lastRecentCount;
}

#include "moc_idlejob.cpp"
07070100000055000081A40000000200000002000000015ED129EC000010D9000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/idlejob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_IDLEJOB_H
#define KIMAP_IDLEJOB_H

#include "kimap_export.h"

#include "imapset.h"
#include "job.h"

#include <kmime/kmime_content.h>
#include <kmime/kmime_message.h>

namespace KIMAP
{

class Session;
struct Response;
class IdleJobPrivate;

/**
 * Idles the connection to the IMAP server.
 *
 * This job can be run while the client has no other use
 * for the connection, and the server will send updates
 * about the selected mailbox.
 *
 * Note that although the server may send a variety of
 * responses while the job is running (including EXPUNGE,
 * for example), only RECENT and EXISTS responses are
 * actually reported by this job.
 *
 * The job also processes updates in pairs - if the server
 * sends an EXISTS update but not a RECENT one (because
 * another client is changing the mailbox contents), this
 * job will not report the update.
 *
 * It only makes sense to run this job when the session is
 * in the selected state.
 *
 * This job requires that the server supports the IDLE
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc2177">RFC 2177</a>.
 */
class KIMAP_EXPORT IdleJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(IdleJob)

public:
    explicit IdleJob(Session *session);
    ~IdleJob() override;

/**
     * The last mailbox status that was reported.
     *
     * This is just the session's selected mailbox.
     */
    Q_REQUIRED_RESULT QString lastMailBox() const;
    /**
     * The last message count that was reported.
     *
     * The server will send updates about the number of
     * messages in the mailbox when that number changes.
     * This is the last number it reported.
     *
     * @return  the last message count the server reported,
     *          or -1 if it has not reported a message count
     *          since the job started.
     */
    Q_REQUIRED_RESULT int lastMessageCount() const;
    /**
     * The last recent message count that was reported.
     *
     * The server will send updates about the number of
     * messages in the mailbox that are tagged with \Recent
     * when that number changes. This is the last number it
     * reported.
     *
     * @return  the last recent message count the server reported,
     *          or -1 if it has not reported a recent message count
     *          since the job started.
     */
    Q_REQUIRED_RESULT int lastRecentCount() const;

public Q_SLOTS:
    /**
     * Stops the idle job.
     */
    void stop();

Q_SIGNALS:
    /**
     * Signals that the server has notified that the total and
     * recent message counts have changed.
     *
     * @param job           this object
     * @param mailBox       the selected mailbox
     * @param messageCount  the new total message count reported by the server
     * @param recentCount   the new "recent message" count reported by the server
     */
    void mailBoxStats(KIMAP::IdleJob *job, const QString &mailBox, int messageCount, int recentCount);

/**
     * Signals that the server has notified that the some messages flags
     * have changed
     *
     * @param job this object
     * @param uid UID of message that has changed
     * @since 4.12
     */
    void mailBoxMessageFlagsChanged(KIMAP::IdleJob *job, qint64 uid);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

private:
    Q_PRIVATE_SLOT(d_func(), void emitStats())
    Q_PRIVATE_SLOT(d_func(), void resetTimeout())
};

}

#endif
07070100000056000081A40000000200000002000000015ED129EC00001EAD000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/imapset.cpp/*
    Copyright (c) 2007 Volker Krause <vkrause@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "imapset.h"

#include <QSharedData>

using namespace KIMAP;

class ImapInterval::Private : public QSharedData
{
public:
    Private() :
        QSharedData(),
        begin(0),
        end(0)
    {}

Private(const Private &other) :
        QSharedData(other)
    {
        begin = other.begin;
        end = other.end;
    }

Id begin;
    Id end;
};

class ImapSet::Private : public QSharedData
{
public:
    Private() : QSharedData() {}
    Private(const Private &other) :
        QSharedData(other)
    {
        intervals = other.intervals;
    }

ImapInterval::List intervals;
};

ImapInterval::ImapInterval() :
    d(new Private)
{
}

ImapInterval::ImapInterval(const ImapInterval &other) :
    d(other.d)
{
}

ImapInterval::ImapInterval(Id begin, Id end) :
    d(new Private)
{
    d->begin = begin;
    d->end = end;
}

ImapInterval::~ ImapInterval()
{
}

ImapInterval &ImapInterval::operator =(const ImapInterval &other)
{
    if (this != &other) {
        d = other.d;
    }
    return *this;
}

bool ImapInterval::operator ==(const ImapInterval &other) const
{
    return (d->begin == other.d->begin && d->end == other.d->end);
}

ImapInterval::Id ImapInterval::size() const
{
    if (!d->begin && !d->end) {
        return 0;
    }
    if (d->begin && !d->end) {
        return Q_INT64_C(0x7FFFFFFFFFFFFFFF) - d->begin + 1;
    }
    return d->end - d->begin + 1;
}

bool ImapInterval::hasDefinedBegin() const
{
    return d->begin != 0;
}

ImapInterval::Id ImapInterval::begin() const
{
    return d->begin;
}

bool ImapInterval::hasDefinedEnd() const
{
    return d->end != 0;
}

ImapInterval::Id ImapInterval::end() const
{
    if (hasDefinedEnd()) {
        return d->end;
    }
    return std::numeric_limits<qint64>::max();
}

void ImapInterval::setBegin(Id value)
{
    Q_ASSERT(value >= 0);
    Q_ASSERT(value <= d->end || !hasDefinedEnd());
    d->begin = value;
}

void ImapInterval::setEnd(Id value)
{
    Q_ASSERT(value >= 0);
    Q_ASSERT(value >= d->begin || !hasDefinedBegin());
    d->end = value;
}

QByteArray ImapInterval::toImapSequence() const
{
    if (size() == 0) {
        return QByteArray();
    }
    if (size() == 1) {
        return QByteArray::number(d->begin);
    }
    QByteArray rv = QByteArray::number(d->begin) + ':';
    if (hasDefinedEnd()) {
        rv += QByteArray::number(d->end);
    } else {
        rv += '*';
    }
    return rv;
}

ImapInterval ImapInterval::fromImapSequence(const QByteArray &sequence)
{
    QList<QByteArray> values = sequence.split(':');
    if (values.isEmpty() || values.size() > 2) {
        return ImapInterval();
    }

bool ok = false;
    Id begin = values[0].toLongLong(&ok);

if (!ok) {
        return ImapInterval();
    }

Id end;

if (values.size() == 1) {
        end = begin;
    } else if (values[1] == QByteArray("*")) {
        end = 0;
    } else {
        ok = false;
        end = values[1].toLongLong(&ok);
        if (!ok) {
            return ImapInterval();
        }
    }

return ImapInterval(begin, end);
}

ImapSet::ImapSet() :
    d(new Private)
{
}

ImapSet::ImapSet(Id begin, Id end) :
    d(new Private)
{
    add(ImapInterval(begin, end));
}

ImapSet::ImapSet(Id value) :
    d(new Private)
{
    add(QVector<Id>() << value);
}

ImapSet::ImapSet(const ImapSet &other) :
    d(other.d)
{
}

ImapSet::~ImapSet()
{
}

ImapSet &ImapSet::operator =(const ImapSet &other)
{
    if (this != &other) {
        d = other.d;
    }
    return *this;
}

bool ImapSet::operator ==(const ImapSet &other) const
{
    if (d->intervals.size() != other.d->intervals.size()) {
        return false;
    }

for (const ImapInterval &interval : qAsConst(d->intervals)) {
        if (!other.d->intervals.contains(interval)) {
            return false;
        }
    }

return true;
}

void ImapSet::add(Id value)
{
    add(QVector<Id>() << value);
}

void ImapSet::add(const QVector<Id> &values)
{
    QVector<Id> vals = values;
    std::sort(vals.begin(), vals.end());
    for (int i = 0; i < vals.count(); ++i) {
        const Id begin = vals[i];
        Q_ASSERT(begin >= 0);
        if (i == vals.count() - 1) {
            d->intervals << ImapInterval(begin, begin);
            break;
        }
        do {
            ++i;
            Q_ASSERT(vals[i] >= 0);
            if (vals[i] != (vals[i - 1] + 1)) {
                --i;
                break;
            }
        } while (i < vals.count() - 1);
        d->intervals << ImapInterval(begin, vals[i]);
    }
}

void ImapSet::add(const ImapInterval &interval)
{
    d->intervals << interval;
}

QByteArray ImapSet::toImapSequenceSet() const
{
    QList<QByteArray> rv;
    rv.reserve(d->intervals.count());
    for (const ImapInterval &interval : qAsConst(d->intervals)) {
        rv << interval.toImapSequence();
    }

QByteArray result;

if (!rv.isEmpty()) {
        result = rv.first();
        QList<QByteArray>::ConstIterator it = rv.constBegin();
        const QList<QByteArray>::ConstIterator end = rv.constEnd();
        ++it;
        for (; it != end; ++it) {
            result += ',' + (*it);
        }
    }

return result;
}

ImapSet ImapSet::fromImapSequenceSet(const QByteArray &sequence)
{
    ImapSet result;

const QList<QByteArray> intervals = sequence.split(',');

for (const QByteArray &interval : qAsConst(intervals)) {
        if (!interval.isEmpty()) {
            result.add(ImapInterval::fromImapSequence(interval));
        }
    }

return result;
}

ImapInterval::List ImapSet::intervals() const
{
    return d->intervals;
}

bool ImapSet::isEmpty() const
{
    return d->intervals.isEmpty();
}

void ImapSet::optimize()
{
    // There's nothing to optimize if we have fewer than 2 intervals
    if (d->intervals.size() < 2) {
        return;
    }

// Sort the intervals in ascending order by their beginning value
    std::sort(d->intervals.begin(), d->intervals.end(),
              [](const ImapInterval &lhs, const ImapInterval &rhs) {
                   return lhs.begin() < rhs.begin();
              });

auto it = d->intervals.begin();
    while (it != d->intervals.end() && it != std::prev(d->intervals.end())) {
        auto next = std::next(it);
        // +1 so that we also merge neighbouring intervals, e.g. 1:2,3:4 -> 1:4
        if (it->hasDefinedEnd() && it->end() + 1 >= next->begin()) {
            next->setBegin(it->begin());
            if (next->hasDefinedEnd() && it->end() > next->end()) {
                next->setEnd(it->end());
            }
            it = d->intervals.erase(it);
        } else if (!it->hasDefinedEnd()) {
            // We can eat up all the remaining intervals
            it = d->intervals.erase(next, d->intervals.end());
        } else {
            ++it;
        }
    }
}

QDebug &operator<<(QDebug &d, const ImapInterval &interval)
{
    d << interval.toImapSequence();
    return d;
}

QDebug &operator<<(QDebug &d, const ImapSet &set)
{
    d << set.toImapSequenceSet();
    return d;
}
07070100000057000081A40000000200000002000000015ED129EC0000177B000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/imapset.h/*
    Copyright (c) 2007 Volker Krause <vkrause@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_IMAPSET_H
#define KIMAP_IMAPSET_H

#include "kimap_export.h"

#include <QByteArray>
#include <QDebug>
#include <QList>
#include <QMetaType>
#include <QSharedDataPointer>

namespace KIMAP
{

/**
  Represents a single interval in an ImapSet.
  This class is implicitly shared.
*/
class KIMAP_EXPORT ImapInterval
{
public:
    /**
     * Describes the ids stored in the interval.
     */
    typedef qint64 Id;

/**
      A list of ImapInterval objects.
    */
    typedef QList<ImapInterval> List;

/**
      Constructs an interval that covers all positive numbers.
    */
    ImapInterval();

/**
      Copy constructor.
    */
    ImapInterval(const ImapInterval &other);

/**
      Create a new interval.
      @param begin The begin of the interval.
      @param end Keep default (0) to just set the interval begin
    */
    explicit ImapInterval(Id begin, Id end = 0);

/**
      Destructor.
    */
    ~ImapInterval();

/**
      Assignment operator.
    */
    ImapInterval &operator=(const ImapInterval &other);

/**
      Comparison operator.
    */
    bool operator==(const ImapInterval &other) const;

/**
      Returns the size of this interval.
      Size is only defined for finite intervals.
    */
    Id size() const;

/**
      Returns true if this interval has a defined begin.
    */
    bool hasDefinedBegin() const;

/**
      Returns the begin of this interval. The value is the smallest value part of the interval.
      Only valid if begin is defined.
    */
    Id begin() const;

/**
      Returns true if this intercal has been defined.
    */
    bool hasDefinedEnd() const;

/**
      Returns the end of this interval. This value is the largest value part of the interval.
      Only valid if hasDefinedEnd() returned true.
    */
    Id end() const;

/**
      Sets the begin of the interval.
    */
    void setBegin(Id value);

/**
      Sets the end of this interval.
    */
    void setEnd(Id value);

/**
      Converts this set into an IMAP compatible sequence.
    */
    QByteArray toImapSequence() const;

/**
      Return the interval corresponding to the given IMAP-compatible QByteArray representation
    */
    static ImapInterval fromImapSequence(const QByteArray &sequence);

private:
    class Private;
    QSharedDataPointer<Private> d;
};

/**
  Represents a set of natural numbers (1->∞) in a as compact as possible form.
  Used to address Akonadi items via the IMAP protocol or in the database.
  This class is implicitly shared.
*/
class KIMAP_EXPORT ImapSet
{
public:
    /**
     * Describes the ids stored in the set.
     */
    typedef qint64 Id;

/**
      Constructs an empty set.
    */
    ImapSet();

/**
      Constructs a set containing a single interval.
    */
    ImapSet(Id begin, Id end);

/**
      Constructs a set containing a single value.
    */
    explicit ImapSet(Id value);

/**
      Copy constructor.
    */
    ImapSet(const ImapSet &other);

/**
      Destructor.
    */
    ~ImapSet();

/**
      Assignment operator.
    */
    ImapSet &operator=(const ImapSet &other);

/**
      Comparison operator.
    */
    bool operator==(const ImapSet &other) const;

/**
      Adds a single positive integer numbers to the set.
      The list is sorted and split into as large as possible intervals.
      No interval merging is performed.
      @param value A positive integer number
    */
    void add(Id value);

/**
      Adds the given list of positive integer numbers to the set.
      The list is sorted and split into as large as possible intervals.
      No interval merging is performed.
      @param values List of positive integer numbers in arbitrary order
    */
    void add(const QVector<Id> &values);

/**
      Adds the given ImapInterval to this set.
      No interval merging is performed.
      @param interval the interval to add
    */
    void add(const ImapInterval &interval);

/**
      Returns a IMAP-compatible QByteArray representation of this set.
    */
    QByteArray toImapSequenceSet() const;

/**
      Return the set corresponding to the given IMAP-compatible QByteArray representation
    */
    static ImapSet fromImapSequenceSet(const QByteArray &sequence);

/**
      Returns the intervals this set consists of.
    */
    ImapInterval::List intervals() const;

/**
      Returns true if this set doesn't contains any values.
    */
    bool isEmpty() const;

/**
     * Optimizes the ImapSet by sorting and merging overlapping intervals.
     *
     * Normally you shouldn't need to call this method. KIMAP will make sure
     * to opimize the ImapSet before serializing it to string and sending it
     * to the IMAP server.
     */
    void optimize();

private:
    class Private;
    QSharedDataPointer<Private> d;
};

}

KIMAP_EXPORT QDebug &operator<<(QDebug &d, const KIMAP::ImapInterval &interval);
KIMAP_EXPORT QDebug &operator<<(QDebug &d, const KIMAP::ImapSet &set);

Q_DECLARE_METATYPE(KIMAP::ImapInterval)
Q_DECLARE_METATYPE(KIMAP::ImapInterval::List)
Q_DECLARE_METATYPE(KIMAP::ImapSet)

#endif
07070100000058000081A40000000200000002000000015ED129EC00003E36000000000000000000000000000000000000004200000000kimap-VERSIONgit.20200529T172740~a5402d2/src/imapstreamparser.cpp/*
    Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "imapstreamparser.h"

#include <ctype.h>
#include <QIODevice>

using namespace KIMAP;

ImapStreamParser::ImapStreamParser(QIODevice *socket, bool serverModeEnabled)
    : m_position(0)
    , m_literalSize(0)
{
    m_socket = socket;
    m_isServerModeEnabled = serverModeEnabled;
}

QString ImapStreamParser::readUtf8String()
{
    QByteArray tmp;
    tmp = readString();
    QString result = QString::fromUtf8(tmp);
    return result;
}

QByteArray ImapStreamParser::readString()
{
    QByteArray result;
    if (!waitForMoreData(m_data.isEmpty())) {
        throw ImapParserException("Unable to read more data");
    }
    stripLeadingSpaces();
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }

// literal string
    // TODO: error handling
    if (hasLiteral()) {
        while (!atLiteralEnd()) {
            result += readLiteralPart();
        }
        return result;
    }

// quoted string
    return parseQuotedString();
}

bool ImapStreamParser::hasString()
{
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    int savedPos = m_position;
    stripLeadingSpaces();
    int pos = m_position;
    m_position = savedPos;
    const char dataChar = m_data.at(pos);
    if (dataChar == '{') {
        return true; //literal string
    } else if (dataChar == '"') {
        return true; //quoted string
    } else if (dataChar != ' ' &&
            dataChar != '(' &&
            dataChar != ')' &&
            dataChar != '[' &&
            dataChar != ']' &&
            dataChar != '\n' &&
            dataChar != '\r') {
        return true;  //unquoted string
    }

return false; //something else, not a string
}

bool ImapStreamParser::hasLiteral()
{
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    int savedPos = m_position;
    stripLeadingSpaces();
    if (m_data.at(m_position) == '{') {
        int end = -1;
        do {
            end = m_data.indexOf('}', m_position);
            if (!waitForMoreData(end == -1)) {
                throw ImapParserException("Unable to read more data");
            }
        } while (end == -1);
        Q_ASSERT(end > m_position);
        m_literalSize = m_data.mid(m_position + 1, end - m_position - 1).toInt();
        // strip CRLF
        m_position = end + 1;
        // ensure that the CRLF is available
        if (!waitForMoreData(m_position + 1 >= m_data.length())) {
            throw ImapParserException("Unable to read more data");
        }
        if (m_position < m_data.length() && m_data.at(m_position) == '\r') {
            ++m_position;
        }
        if (m_position < m_data.length() && m_data.at(m_position) == '\n') {
            ++m_position;
        }

//FIXME: Makes sense only on the server side?
        if (m_isServerModeEnabled && m_literalSize > 0) {
            sendContinuationResponse(m_literalSize);
        }
        return true;
    } else {
        m_position = savedPos;
        return false;
    }
}

bool ImapStreamParser::atLiteralEnd() const
{
    return (m_literalSize == 0);
}

QByteArray ImapStreamParser::readLiteralPart()
{
    static const qint64 maxLiteralPartSize = 4096;
    int size = qMin(maxLiteralPartSize, m_literalSize);

if (!waitForMoreData(m_data.length() < m_position + size)) {
        throw ImapParserException("Unable to read more data");
    }

if (m_data.length() < m_position + size) {   // Still not enough data
        // Take what's already there
        size = m_data.length() - m_position;
    }

QByteArray result = m_data.mid(m_position, size);
    m_position += size;
    m_literalSize -= size;
    Q_ASSERT(m_literalSize >= 0);
    trimBuffer();

return result;
}

bool ImapStreamParser::hasList()
{
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    int savedPos = m_position;
    stripLeadingSpaces();
    int pos = m_position;
    m_position = savedPos;
    if (m_data.at(pos) == '(') {
        return true;
    }
    return false;
}

bool ImapStreamParser::atListEnd()
{
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    int savedPos = m_position;
    stripLeadingSpaces();
    int pos = m_position;
    m_position = savedPos;
    if (m_data.at(pos) == ')') {
        m_position = pos + 1;
        return true;
    }
    return false;
}

QList<QByteArray> ImapStreamParser::readParenthesizedList()
{
    QList<QByteArray> result;
    if (!waitForMoreData(m_data.length() <= m_position)) {
        throw ImapParserException("Unable to read more data");
    }

stripLeadingSpaces();
    if (m_data.at(m_position) != '(') {
        return result; //no list found
    }

bool concatToLast = false;
    int count = 0;
    int sublistbegin = m_position;
    int i = m_position + 1;
    Q_FOREVER {
    if (!waitForMoreData(m_data.length() <= i))
        {
            m_position = i;
            throw ImapParserException("Unable to read more data");
        }
        if (m_data.at(i) == '(')
        {
            ++count;
            if (count == 1) {
                sublistbegin = i;
            }
            ++i;
            continue;
        }
        if (m_data.at(i) == ')')
        {
            if (count <= 0) {
                m_position = i + 1;
                return result;
            }
            if (count == 1) {
                result.append(m_data.mid(sublistbegin, i - sublistbegin + 1));
            }
            --count;
            ++i;
            continue;
        }
        if (m_data.at(i) == ' ')
        {
            ++i;
            continue;
        }
        if (m_data.at(i) == '"')
        {
            if (count > 0) {
                m_position = i;
                parseQuotedString();
                i = m_position;
                continue;
            }
        }
        if (m_data.at(i) == '[')
        {
            concatToLast = true;
            if (result.isEmpty()) {
                result.append(QByteArray());
            }
            result.last() += '[';
            ++i;
            continue;
        }
        if (m_data.at(i) == ']')
        {
            concatToLast = false;
            result.last() += ']';
            ++i;
            continue;
        }
        if (count == 0)
        {
            m_position = i;
            QByteArray ba;
            if (hasLiteral()) {
                while (!atLiteralEnd()) {
                    ba += readLiteralPart();
                }
            } else {
                ba = readString();
            }

// We might sometime get some unwanted CRLF, but we're still not at the end
            // of the list, would make further string reads fail so eat the CRLFs.
            while ((m_position < m_data.size()) &&
                    (m_data.at(m_position) == '\r' || m_data.at(m_position) == '\n')) {
                m_position++;
            }

i = m_position - 1;
            if (concatToLast) {
                result.last() += ba;
            } else {
                result.append(ba);
            }
        }
        ++i;
    }

throw ImapParserException("Something went very very wrong!");
}

bool ImapStreamParser::hasResponseCode()
{
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    int savedPos = m_position;
    stripLeadingSpaces();
    int pos = m_position;
    m_position = savedPos;
    if (m_data.at(pos) == '[') {
        m_position = pos + 1;
        return true;
    }
    return false;
}

bool ImapStreamParser::atResponseCodeEnd()
{
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    int savedPos = m_position;
    stripLeadingSpaces();
    int pos = m_position;
    m_position = savedPos;
    if (m_data.at(pos) == ']') {
        m_position = pos + 1;
        return true;
    }
    return false;
}

QByteArray ImapStreamParser::parseQuotedString()
{
    QByteArray result;
    if (!waitForMoreData(m_data.length() == 0)) {
        throw ImapParserException("Unable to read more data");
    }
    stripLeadingSpaces();
    int end = m_position;
    result.clear();
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }

bool foundSlash = false;
    // quoted string
    if (m_data.at(m_position) == '"') {
        ++m_position;
        int i = m_position;
        Q_FOREVER {
        if (!waitForMoreData(m_data.length() <= i))
            {
                m_position = i;
                throw ImapParserException("Unable to read more data");
            }
            if (m_data.at(i) == '\\')
            {
                i += 2;
                foundSlash = true;
                continue;
            }
            if (m_data.at(i) == '"')
            {
                result = m_data.mid(m_position, i - m_position);
                end = i + 1; // skip the '"'
                break;
            }
            ++i;
        }
    }

// unquoted string
    else {
        bool reachedInputEnd = true;
        int i = m_position;
        Q_FOREVER {
        if (!waitForMoreData(m_data.length() <= i))
            {
                m_position = i;
                throw ImapParserException("Unable to read more data");
            }
            if (m_data.at(i) == ' ' ||
            m_data.at(i) == '(' ||
            m_data.at(i) == ')' ||
            m_data.at(i) == '[' ||
            m_data.at(i) == ']' ||
            m_data.at(i) == '\n' ||
            m_data.at(i) == '\r' ||
            m_data.at(i) == '"')
            {
                end = i;
                reachedInputEnd = false;
                break;
            }
            if (m_data.at(i) == '\\')
            {
                foundSlash = true;
            }
            i++;
        }
        if (reachedInputEnd) {   //FIXME: how can it get here?
            end = m_data.length();
        }

result = m_data.mid(m_position, end - m_position);
    }

// strip quotes
    if (foundSlash) {
        while (result.contains("\\\"")) {
            result.replace("\\\"", "\"");
        }
        while (result.contains("\\\\")) {
            result.replace("\\\\", "\\");
        }
    }
    m_position = end;
    return result;
}

qint64 ImapStreamParser::readNumber(bool *ok)
{
    qint64  result;
    if (ok) {
        *ok = false;
    }
    if (!waitForMoreData(m_data.length() == 0)) {
        throw ImapParserException("Unable to read more data");
    }
    stripLeadingSpaces();
    if (!waitForMoreData(m_position >= m_data.length())) {
        throw ImapParserException("Unable to read more data");
    }
    if (m_position >= m_data.length()) {
        throw ImapParserException("Unable to read more data");
    }
    int i = m_position;
    Q_FOREVER {
    if (!waitForMoreData(m_data.length() <= i))
        {
            m_position = i;
            throw ImapParserException("Unable to read more data");
        }
        if (!isdigit(m_data.at(i)))
        {
            break;
        }
        ++i;
    }
    const QByteArray tmp = m_data.mid(m_position, i - m_position);
    result = tmp.toLongLong(ok);
    m_position = i;
    return result;
}

void ImapStreamParser::stripLeadingSpaces()
{
    for (int i = m_position; i < m_data.length(); ++i) {
        if (m_data.at(i) != ' ') {
            m_position = i;
            return;
        }
    }
    m_position = m_data.length();
}

bool ImapStreamParser::waitForMoreData(bool wait)
{
    if (wait) {
        if (m_socket->bytesAvailable() > 0 ||
                m_socket->waitForReadyRead(30000)) {
            m_data.append(m_socket->readAll());
        } else {
            return false;
        }
    }
    return true;
}

void ImapStreamParser::setData(const QByteArray &data)
{
    m_data = data;
}

QByteArray ImapStreamParser::readRemainingData()
{
    return m_data.mid(m_position);
}

int ImapStreamParser::availableDataSize() const
{
    return m_socket->bytesAvailable() + m_data.size() - m_position;
}

bool ImapStreamParser::atCommandEnd()
{
    int savedPos = m_position;
    do {
        if (!waitForMoreData(m_position >= m_data.length())) {
            throw ImapParserException("Unable to read more data");
        }
        stripLeadingSpaces();
    } while (m_position >= m_data.size());

if (m_data.at(m_position) == '\n' || m_data.at(m_position) == '\r') {
        if (m_data.at(m_position) == '\r') {
            ++m_position;
        }
        if (m_position < m_data.length() && m_data.at(m_position) == '\n') {
            ++m_position;
        }

// We'd better empty m_data from time to time before it grows out of control
        trimBuffer();

return true; //command end
    }
    m_position = savedPos;
    return false; //something else
}

QByteArray ImapStreamParser::readUntilCommandEnd()
{
    QByteArray result;
    int i = m_position;
    int paranthesisBalance = 0;
    Q_FOREVER {
    if (!waitForMoreData(m_data.length() <= i))
        {
            m_position = i;
            throw ImapParserException("Unable to read more data");
        }
        if (m_data.at(i) == '{')
        {
            m_position = i - 1;
            hasLiteral(); //init literal size
            result.append( m_data.mid( i, m_position + 1 ) );
            while (!atLiteralEnd()) {
                result.append(readLiteralPart());
            }
            i = m_position;
        }
        if (m_data.at(i) == '(')
        {
            paranthesisBalance++;
        }
        if (m_data.at(i) == ')')
        {
            paranthesisBalance--;
        }
        if ((i == m_data.length() && paranthesisBalance == 0) ||
                m_data.at(i) == '\n'  || m_data.at(i) == '\r')
        {
            break; //command end
        }
        result.append(m_data.at(i));
        ++i;
    }
    m_position = i;
    atCommandEnd();
    return result;
}

void ImapStreamParser::sendContinuationResponse(qint64 size)
{
    QByteArray block = "+ Ready for literal data (expecting " +
                       QByteArray::number(size) + " bytes)\r\n";
    m_socket->write(block);
    m_socket->waitForBytesWritten(30000);
}

void ImapStreamParser::trimBuffer()
{
    if (m_position < 4096) {   // right() is expensive, so don't do it for every line
        return;
    }
    m_data = m_data.right(m_data.size() - m_position);
    m_position = 0;
}
07070100000059000081A40000000200000002000000015ED129EC000018E9000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/src/imapstreamparser.h/*
    Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_IMAPSTREAMPARSER_P_H
#define KIMAP_IMAPSTREAMPARSER_P_H

#include "kimap_export.h"

#include <exception>

#include <QByteArray>
#include <QList>
#include <QString>

class QIODevice;

namespace KIMAP
{

class ImapParserException : public std::exception
{
public:
    explicit ImapParserException(const char *what) throw() : mWhat(what) {}
    explicit ImapParserException(const QByteArray &what) throw() : mWhat(what) {}
    explicit ImapParserException(const QString &what) throw() : mWhat(what.toUtf8()) {}
    ImapParserException(const ImapParserException &other) throw() : std::exception(other), mWhat(other.what()) {}
    virtual ~ImapParserException() throw() {}
    const char *what() const throw() override
    {
        return mWhat.constData();
    }
    virtual const char *type() const throw()
    {
        return "ImapParserException";
    }
private:
    QByteArray mWhat;
};

/**
  Parser for IMAP messages that operates on a local socket stream.
*/
class KIMAP_EXPORT ImapStreamParser
{
public:
    /**
     * Construct the parser.
     * @param socket the local socket to work with.
     * @param serverModeEnabled true if the parser has to assume we're writing a server (e.g. sends
     * continuation message automatically)
     */
    explicit ImapStreamParser(QIODevice *socket, bool serverModeEnabled = false);

/**
     * Get a string from the message. If the upcoming data is not a quoted string, unquoted string or a literal,
     * the behavior is undefined. Use @ref hasString to be sure a string comes. This call might block.
     * @return the next string from the message as an utf8 string
     */
    QString readUtf8String();

/**
     * Same as above, but without decoding it to utf8.
     * @return the next string from the message
     */
    QByteArray readString();

/**
     * Get he next parenthesized list. If the upcoming data is not a parenthesized list,
     * the behavior is undefined. Use @ref hasList to be sure a string comes. This call might block.
     * @return the next parenthesized list.
     */
    QList<QByteArray> readParenthesizedList();

/**
     * Get the next data as a number. This call might block.
     * @param ok true if the data found was a number
     * @return the number
     */
    qint64 readNumber(bool *ok = nullptr);

/**
     * Check if the next data is a string or not. This call might block.
     * @return true if a string follows
     */
    bool hasString();

/**
     * Check if the next data is a literal data or not. If a literal is found, the
     * internal position pointer is set to the beginning of the literal data.
     * This call might block.
     * @return true if a literal follows
     */
    bool hasLiteral();

/**
     * Read the next literal sequence. This might or might not be the full data. Example code to read a literal would be:
     * @code
     * ImapStreamParser parser;
     *  ...
     * if (parser.hasLiteral())
     * {
     *   while (!parser.atLiteralEnd())
     *   {
     *      QByteArray data = parser.readLiteralPart();
     *      // do something with the data
     *   }
     * }
     * @endcode
     *
     * This call might block.
     *
     * @return part of a literal data
     */
    QByteArray readLiteralPart();

/**
     * Check if the literal data end was reached. See @ref hasLiteral and @ref readLiteralPart .
     * @return true if the literal was completely read.
     */
    bool atLiteralEnd() const;

/**
     * Check if the next data is a parenthesized list. This call might block.
     * @return true if a parenthesized list comes.
    */
    bool hasList();

/**
    * Check if the next data is a parenthesized list end. This call might block.
    * @return true if a parenthesized list end.
     */
    bool atListEnd();

/**
     * Check if the next data is a response code. This call might block.
     * @return true if a response code comes.
     */
    bool hasResponseCode();

/**
    * Check if the next data is a response code end. This call might block.
    * @return true if a response code end.
     */
    bool atResponseCodeEnd();

/**
     * Check if the command end was reached
     * @return true if the end of command is reached
     */
    bool atCommandEnd();

/**
     * Return everything that remained from the command.
     * @return the remaining command data
     */
    QByteArray readUntilCommandEnd();

/**
     * Return all the data that was read from the socket, but not processed yet.
     * @return the remaining unprocessed data
     */
    QByteArray readRemainingData();

int availableDataSize() const;

void setData(const QByteArray &data);

private:
    void stripLeadingSpaces();
    QByteArray parseQuotedString();

/**
     * If the condition is true, wait for more data to be available from the socket.
     * If no data comes after a timeout (30000ms), it aborts and returns false.
     * @param wait the condition
     * @return true if more data is available
     */
    bool waitForMoreData(bool wait);

/**
     * Inform the client to send more literal data.
     */
    void sendContinuationResponse(qint64 size);

/**
     * Remove already read data from the internal buffer if necessary.
     */
    void trimBuffer();

QIODevice *m_socket = nullptr;
    bool m_isServerModeEnabled = false;
    QByteArray m_data;
    int m_position = -1;
    qint64 m_literalSize = -1;
};

}

#endif
0707010000005A000081A40000000200000002000000015ED129EC0000098C000000000000000000000000000000000000003500000000kimap-VERSIONgit.20200529T172740~a5402d2/src/job.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "job.h"
#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

#include <KLocalizedString>
#include "kimap_debug.h"

using namespace KIMAP;

Job::Job(Session *session)
    : KJob(session), d_ptr(new JobPrivate(session, i18n("Job")))
{
}

Job::Job(JobPrivate &dd)
    : KJob(dd.m_session), d_ptr(&dd)
{
}

Job::~Job()
{
    delete d_ptr;
}

Session *Job::session() const
{
    Q_D(const Job);
    return d->m_session;
}

void Job::start()
{
    Q_D(Job);
    d->sessionInternal()->addJob(this);
}

void Job::handleResponse(const Response &response)
{
    handleErrorReplies(response);
}

void Job::connectionLost()
{
    setError(KJob::UserDefinedError);
    setErrorText(i18n("Connection to server lost."));
    emitResult();
}

Job::HandlerResponse Job::handleErrorReplies(const Response &response)
{
    Q_D(Job);
//   qCDebug(KIMAP_LOG) << response.toString();

if (!response.content.isEmpty() &&
            d->tags.contains(response.content.first().toString())) {
        if (response.content.size() < 2) {
            setErrorText(i18n("%1 failed, malformed reply from the server.", d->m_name));
        } else if (response.content[1].toString() != "OK") {
            setError(UserDefinedError);
            setErrorText(i18n("%1 failed, server replied: %2", d->m_name, QLatin1String(response.toString().constData())));
        }
        d->tags.removeAll(response.content.first().toString());
        if (d->tags.isEmpty()) {   // Only emit result when the last command returned
            emitResult();
        }
        return Handled;
    }

return NotHandled;
}
0707010000005B000081A40000000200000002000000015ED129EC00000657000000000000000000000000000000000000003300000000kimap-VERSIONgit.20200529T172740~a5402d2/src/job.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_JOB_H
#define KIMAP_JOB_H

#include "kimap_export.h"

#include <KJob>

namespace KIMAP
{

class Session;
class SessionPrivate;
class JobPrivate;
struct Response;

class KIMAP_EXPORT Job : public KJob
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Job)

friend class SessionPrivate;

public:
    ~Job() override;

Session *session() const;

void start() override;

private:
    virtual void doStart() = 0;
    virtual void handleResponse(const Response &response);
    virtual void connectionLost();

protected:
    enum HandlerResponse {
        Handled = 0,
        NotHandled
    };

HandlerResponse handleErrorReplies(const Response &response);

explicit Job(Session *session);
    explicit Job(JobPrivate &dd);

JobPrivate *const d_ptr;
};

}

#endif
0707010000005C000081A40000000200000002000000015ED129EC00000650000000000000000000000000000000000000003500000000kimap-VERSIONgit.20200529T172740~a5402d2/src/job_p.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_JOB_P_H
#define KIMAP_JOB_P_H

#include "session.h"
#include <QAbstractSocket>

namespace KIMAP
{

class SessionPrivate;

class JobPrivate
{
public:
    JobPrivate(Session *session, const QString &name) : m_session(session)
    {
        m_name = name;
    }
    virtual ~JobPrivate() { }

inline SessionPrivate *sessionInternal()
    {
        return m_session->d;
    }

inline const SessionPrivate *sessionInternal() const
    {
        return m_session->d;
    }

void setSocketError(QAbstractSocket::SocketError error)
    {
        m_socketError = error;
    }

QList<QByteArray> tags;
    Session *m_session = nullptr;
    QString m_name;
    QAbstractSocket::SocketError m_socketError = QAbstractSocket::UnknownSocketError;
};

}

#endif
0707010000005D000081A40000000200000002000000015ED129EC00001973000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/listjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "listjob.h"

#include <QTimer>
#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "rfccodecs.h"
#include "session_p.h"

namespace KIMAP
{
class ListJobPrivate : public JobPrivate
{
public:
    ListJobPrivate(ListJob *job, Session *session, const QString &name) : JobPrivate(session, name), q(job), option(ListJob::NoOption) { }
    ~ListJobPrivate() { }

void emitPendings()
    {
        if (pendingDescriptors.isEmpty()) {
            return;
        }

Q_EMIT q->mailBoxesReceived(pendingDescriptors, pendingFlags);

pendingDescriptors.clear();
        pendingFlags.clear();
    }

ListJob *const q;

ListJob::Option option;
    QList<MailBoxDescriptor> namespaces;
    QByteArray command;

QTimer emitPendingsTimer;
    QList<MailBoxDescriptor> pendingDescriptors;
    QList< QList<QByteArray> > pendingFlags;
};
}

using namespace KIMAP;

ListJob::ListJob(Session *session)
    : Job(*new ListJobPrivate(this, session, i18n("List")))
{
    Q_D(ListJob);
    connect(&d->emitPendingsTimer, SIGNAL(timeout()),
            this, SLOT(emitPendings()));
}

ListJob::~ListJob()
{
}

void ListJob::setIncludeUnsubscribed(bool include)
{
    Q_D(ListJob);
    if (include) {
        d->option = ListJob::IncludeUnsubscribed;
    } else {
        d->option = ListJob::NoOption;
    }
}

bool ListJob::isIncludeUnsubscribed() const
{
    Q_D(const ListJob);
    return (d->option == ListJob::IncludeUnsubscribed);
}

void ListJob::setOption(Option option)
{
    Q_D(ListJob);
    d->option = option;
}

ListJob::Option ListJob::option() const
{
    Q_D(const ListJob);
    return d->option;
}

void ListJob::setQueriedNamespaces(const QList<MailBoxDescriptor> &namespaces)
{
    Q_D(ListJob);
    d->namespaces = namespaces;
}

QList<MailBoxDescriptor> ListJob::queriedNamespaces() const
{
    Q_D(const ListJob);
    return d->namespaces;
}

QList<MailBoxDescriptor> ListJob::mailBoxes() const
{
    return QList<MailBoxDescriptor>();
}

QMap< MailBoxDescriptor, QList<QByteArray> > ListJob::flags() const
{
    return QMap< MailBoxDescriptor, QList<QByteArray> >();
}

void ListJob::doStart()
{
    Q_D(ListJob);

switch (d->option) {
    case IncludeUnsubscribed:
        d->command = "LIST";
        break;
    case IncludeFolderRoleFlags:
        d->command = "XLIST";
        break;
    case NoOption:
        d->command = "LSUB";
    }

d->emitPendingsTimer.start(100);

if (d->namespaces.isEmpty()) {
        d->tags << d->sessionInternal()->sendCommand(d->command, "\"\" *");
    } else {
        for (const MailBoxDescriptor &descriptor : qAsConst(d->namespaces)) {
            QString parameters = QStringLiteral("\"\" \"%1\"");

if (descriptor.name.endsWith(descriptor.separator)) {
                QString name = encodeImapFolderName(descriptor.name);
                name.chop(1);
                d->tags << d->sessionInternal()->sendCommand(d->command,
                        parameters.arg(name).toUtf8());
            }

d->tags << d->sessionInternal()->sendCommand(d->command,
                    parameters.arg(descriptor.name + QLatin1Char('*')).toUtf8());
        }
    }
}

void ListJob::handleResponse(const Response &response)
{
    Q_D(ListJob);

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 5 && response.content[1].toString() == d->command) {
            QList<QByteArray> flags = response.content[2].toList();
            for (QList<QByteArray>::iterator it = flags.begin(), itEnd = flags.end(); it != itEnd; ++it) {
                *it = it->toLower();
            }
            QByteArray separator = response.content[3].toString();
            if (separator.isEmpty()) {
                // Defaults to / for servers reporting an empty list
                // it's supposedly not a problem as servers doing that
                // only do it for mailboxes with no child.
                separator = "/"; //krazy:exclude=doublequote_chars since a QByteArray
            }
            Q_ASSERT(separator.size() == 1);
            QByteArray fullName;
            for (int i = 4; i < response.content.size(); i++) {
                fullName += response.content[i].toString() + ' ';
            }
            fullName.chop(1);

fullName = decodeImapFolderName(fullName);

MailBoxDescriptor mailBoxDescriptor;
            mailBoxDescriptor.separator = QLatin1Char(separator[0]);
            mailBoxDescriptor.name = QString::fromUtf8(fullName);
            convertInboxName(mailBoxDescriptor);

d->pendingDescriptors << mailBoxDescriptor;
            d->pendingFlags << flags;
        }
    }
}

void ListJob::convertInboxName(KIMAP::MailBoxDescriptor &descriptor)
{
    //Inbox must be case sensitive, according to the RFC, so make it always uppercase
    QStringList pathParts = descriptor.name.split(descriptor.separator);
    if (!pathParts.isEmpty() &&
            pathParts[0].compare(QLatin1String("INBOX"), Qt::CaseInsensitive) == 0) {
        pathParts.removeAt(0);
        descriptor.name = QStringLiteral("INBOX");
        if (!pathParts.isEmpty()) {
            descriptor.name += descriptor.separator + pathParts.join(descriptor.separator);
        }
    }
}
#include "moc_listjob.cpp"
0707010000005E000081A40000000200000002000000015ED129EC00000CB1000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/listjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_LISTJOB_H
#define KIMAP_LISTJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class ListJobPrivate;

struct KIMAP_EXPORT MailBoxDescriptor {
    QString name;
    QChar separator;

inline bool operator==(const MailBoxDescriptor &other) const
    {
        return other.name == name && other.separator == separator;
    }

inline bool operator<(const MailBoxDescriptor &other) const
    {
        return other.name < name || (other.name == name && other.separator < separator);
    }
};

class KIMAP_EXPORT ListJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ListJob)

friend class SessionPrivate;

public:
    enum Option {
        NoOption = 0x0,         /**< List only subscribed mailboxes. (Uses the LSUB IMAP command.) */
        IncludeUnsubscribed,    /**< List subscribed and unsubscribed mailboxes. (Uses the LIST IMAP command.) */
        IncludeFolderRoleFlags  /**< List subscribed and unsubscribed mailboxes with flags to identify standard mailboxes whose name may be localized.
                                   The server must support the XLIST extension. */
    };

explicit ListJob(Session *session);
    ~ListJob() override;

KIMAP_DEPRECATED void setIncludeUnsubscribed(bool include);
    KIMAP_DEPRECATED bool isIncludeUnsubscribed() const;

void setOption(Option option);
    Q_REQUIRED_RESULT Option option() const;

void setQueriedNamespaces(const QList<MailBoxDescriptor> &namespaces);
    Q_REQUIRED_RESULT QList<MailBoxDescriptor> queriedNamespaces() const;

KIMAP_DEPRECATED QList<MailBoxDescriptor> mailBoxes() const;
    KIMAP_DEPRECATED QMap< MailBoxDescriptor, QList<QByteArray> > flags() const;

Q_SIGNALS:
    void mailBoxesReceived(const QList<KIMAP::MailBoxDescriptor> &descriptors,
                           const QList< QList<QByteArray> > &flags);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

private:
    Q_PRIVATE_SLOT(d_func(), void emitPendings())

/**
    * @brief Converts a mailbox descriptor's name to uppercase if it is the Inbox or an Inbox subfolder.
    *  This is according to the RFC3501, 5.1. Mailbox Naming section.
    *
    * @param descriptor the descriptor to convert, conversion happens in place
    **/
    void convertInboxName(KIMAP::MailBoxDescriptor &descriptor);
};

}

#endif
0707010000005F000081A40000000200000002000000015ED129EC00000AC6000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/listrightsjob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "listrightsjob.h"

#include <KLocalizedString>

#include "acljobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class ListRightsJobPrivate : public AclJobBasePrivate
{
public:
    ListRightsJobPrivate(Session *session, const QString &name) : AclJobBasePrivate(session, name), defaultRights(Acl::None) {}
    ~ListRightsJobPrivate() { }

QList<Acl::Rights> possibleRights;
    Acl::Rights defaultRights;

};
}

using namespace KIMAP;

ListRightsJob::ListRightsJob(Session *session)
    : AclJobBase(*new ListRightsJobPrivate(session, i18n("ListRights")))
{

}

ListRightsJob::~ListRightsJob()
{
}

void ListRightsJob::doStart()
{
    Q_D(ListRightsJob);

d->tags << d->sessionInternal()->sendCommand("LISTRIGHTS", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + "\" \"" + d->id + "\"");
}

void ListRightsJob::handleResponse(const Response &response)
{
    Q_D(ListRightsJob);

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 4 &&
                response.content[1].toString() == "LISTRIGHTS") {
            QByteArray s = response.content[4].toString();
            d->defaultRights = Acl::rightsFromString(s);
            int i = 5;
            while (i < response.content.size()) {
                s = response.content[i].toString();
                d->possibleRights.append(Acl::rightsFromString(s));
                i++;
            }
        }
    }
}

void ListRightsJob::setIdentifier(const QByteArray &identifier)
{
    Q_D(ListRightsJob);
    d->setIdentifier(identifier);
}

QByteArray ListRightsJob::identifier()
{
    Q_D(ListRightsJob);
    return d->identifier();
}

Acl::Rights ListRightsJob::defaultRights()
{
    Q_D(ListRightsJob);
    return d->defaultRights;
}

QList<Acl::Rights> ListRightsJob::possibleRights()
{
    Q_D(ListRightsJob);
    return d->possibleRights;
}
07070100000060000081A40000000200000002000000015ED129EC00000EAB000000000000000000000000000000000000003D00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/listrightsjob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_LISTRIGHTSJOB_H
#define KIMAP_LISTRIGHTSJOB_H

#include "kimap_export.h"

#include "acljobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class ListRightsJobPrivate;

/**
 * Lists the possible and automatic rights for
 * an identifier on a mailbox
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * The user must have the Acl::Admin permission
 * on the mailbox for this job to succeed (see
 * MyRightsJob).
 *
 * This job requires that the server supports the ACL
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc4314">RFC 4314</a>.
 */
class KIMAP_EXPORT ListRightsJob : public AclJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ListRightsJob)

friend class SessionPrivate;

public:
    explicit ListRightsJob(Session *session);
    ~ListRightsJob() override;

/**
     * Sets the identifier that should be looked up
     *
     * The meaning of identifiers depends on the server implementation,
     * with the following restrictions:
     *
     * - "anyone" means any authenticated user, including anonymous
     * - an identifier starting with a minus sign ('-') indicates
     *   "negative rights": rights that should be taken away from
     *   matching users
     *
     * Other than the above restrictions, ACL identifiers are usually
     * IMAP usernames, but could potentially be group names as well.
     *
     * Note that negative rights override positive rights: if
     * "fred" and "-fred" are both assigned the 'w' right, the
     * user "fred" will not have the 'w' right.
     *
     * @param identifier  the identifier to list the rights for
     */
    void setIdentifier(const QByteArray &identifier);
    /**
     * The identifier that will be looked up
     */
    Q_REQUIRED_RESULT QByteArray identifier();

/**
     * The rights that will always be assigned to the identifier,
     * regardless of the access control list.
     *
     * For example, under the UNIX permission model, the owner
     * of a mailbox will always have the Acl::Admin right.
     */
    Q_REQUIRED_RESULT Acl::Rights defaultRights();

/**
     * The rights it is possible to assign to the identifier.
     *
     * The rights are grouped by those that are tied together.
     * For each set of rights in the returned list, either all
     * or none of those rights may be set, but not only some of
     * them.
     *
     * For example, under the UNIX permission model, the following
     * rights are all controlled by the "write" flag, and hence
     * must either all be set or all be not set:
     * - Acl::KeepSeen
     * - Acl::Write
     * - Acl::Insert
     * - Acl::DeleteMessage
     * - Acl::Expunge
     */
    Q_REQUIRED_RESULT QList<Acl::Rights> possibleRights();

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
07070100000061000081A40000000200000002000000015ED129EC00004E22000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/loginjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "loginjob.h"

#include <KLocalizedString>
#include <QSslSocket>

#include "kimap_debug.h"

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"
#include "capabilitiesjob.h"

#include "common.h"

extern "C" {
#include <sasl/sasl.h>
}

static const sasl_callback_t callbacks[] = {
    { SASL_CB_ECHOPROMPT, nullptr, nullptr },
    { SASL_CB_NOECHOPROMPT, nullptr, nullptr },
    { SASL_CB_GETREALM, nullptr, nullptr },
    { SASL_CB_USER, nullptr, nullptr },
    { SASL_CB_AUTHNAME, nullptr, nullptr },
    { SASL_CB_PASS, nullptr, nullptr },
    { SASL_CB_CANON_USER, nullptr, nullptr },
    { SASL_CB_LIST_END, nullptr, nullptr }
};

namespace KIMAP
{
class LoginJobPrivate : public JobPrivate
{
public:
    enum AuthState {
        PreStartTlsCapability = 0,
        StartTls,
        Capability,
        Login,
        Authenticate
    };

LoginJobPrivate(LoginJob *job, Session *session, const QString &name) : JobPrivate(session, name), q(job), encryptionMode(LoginJob::Unencrypted), authState(Login), plainLoginDisabled(false)
    {
        conn = nullptr;
        client_interact = nullptr;
    }
    ~LoginJobPrivate() { }
    bool sasl_interact();

bool startAuthentication();
    bool answerChallenge(const QByteArray &data);
    void sslResponse(bool response);
    void saveServerGreeting(const Response &response);

LoginJob *q;

QString userName;
    QString authorizationName;
    QString password;
    QString serverGreeting;

LoginJob::EncryptionMode encryptionMode;
    QString authMode;
    AuthState authState;
    QStringList capabilities;
    bool plainLoginDisabled;

sasl_conn_t *conn;
    sasl_interact_t *client_interact;
};
}

using namespace KIMAP;

bool LoginJobPrivate::sasl_interact()
{
    qCDebug(KIMAP_LOG) << "sasl_interact";
    sasl_interact_t *interact = client_interact;

//some mechanisms do not require username && pass, so it doesn't need a popup
    //window for getting this info
    for (; interact->id != SASL_CB_LIST_END; interact++) {
        if (interact->id == SASL_CB_AUTHNAME ||
                interact->id == SASL_CB_PASS) {
            //TODO: dialog for use name??
            break;
        }
    }

interact = client_interact;
    while (interact->id != SASL_CB_LIST_END) {
        qCDebug(KIMAP_LOG) << "SASL_INTERACT id:" << interact->id;
        switch (interact->id) {
        case SASL_CB_AUTHNAME:
            if (!authorizationName.isEmpty()) {
                qCDebug(KIMAP_LOG) << "SASL_CB_[AUTHNAME]: '" << authorizationName << "'";
                interact->result = strdup(authorizationName.toUtf8().constData());
                interact->len = strlen((const char *) interact->result);
                break;
            }
            Q_FALLTHROUGH();
        case SASL_CB_USER:
            qCDebug(KIMAP_LOG) << "SASL_CB_[USER|AUTHNAME]: '" << userName << "'";
            interact->result = strdup(userName.toUtf8().constData());
            interact->len = strlen((const char *) interact->result);
            break;
        case SASL_CB_PASS:
            qCDebug(KIMAP_LOG) << "SASL_CB_PASS: [hidden]";
            interact->result = strdup(password.toUtf8().constData());
            interact->len = strlen((const char *) interact->result);
            break;
        default:
            interact->result = nullptr;
            interact->len = 0;
            break;
        }
        interact++;
    }
    return true;
}

LoginJob::LoginJob(Session *session)
    : Job(*new LoginJobPrivate(this, session, i18n("Login")))
{
    Q_D(LoginJob);
    connect(d->sessionInternal(), SIGNAL(encryptionNegotiationResult(bool)), this, SLOT(sslResponse(bool)));
    qCDebug(KIMAP_LOG) << this;
}

LoginJob::~LoginJob()
{
    qCDebug(KIMAP_LOG) << this;
}

QString LoginJob::userName() const
{
    Q_D(const LoginJob);
    return d->userName;
}

void LoginJob::setUserName(const QString &userName)
{
    Q_D(LoginJob);
    d->userName = userName;
}

QString LoginJob::authorizationName() const
{
    Q_D(const LoginJob);
    return d->authorizationName;
}

void LoginJob::setAuthorizationName(const QString &authorizationName)
{
    Q_D(LoginJob);
    d->authorizationName = authorizationName;
}

QString LoginJob::password() const
{
    Q_D(const LoginJob);
    return d->password;
}

void LoginJob::setPassword(const QString &password)
{
    Q_D(LoginJob);
    d->password = password;
}

void LoginJob::doStart()
{
    Q_D(LoginJob);

qCDebug(KIMAP_LOG) << this;
    // Don't authenticate on a session in the authenticated state
    if (session()->state() == Session::Authenticated || session()->state() == Session::Selected) {
        setError(UserDefinedError);
        setErrorText(i18n("IMAP session in the wrong state for authentication"));
        emitResult();
        return;
    }

// Trigger encryption negotiation only if needed
    EncryptionMode encryptionMode = d->encryptionMode;

const auto negotiatedEncryption = d->sessionInternal()->negotiatedEncryption();
    if (negotiatedEncryption != QSsl::UnknownProtocol) {
        // If the socket is already encrypted, pretend we did not want any
        // encryption
        encryptionMode = Unencrypted;
    }

if (encryptionMode == SSLorTLS) {
        d->sessionInternal()->startSsl(QSsl::SecureProtocols);
    } else if (encryptionMode == STARTTLS) {
        // Check if STARTTLS is supported
        d->authState = LoginJobPrivate::PreStartTlsCapability;
        d->tags << d->sessionInternal()->sendCommand("CAPABILITY");
    } else {
        if (d->authMode.isEmpty()) {
            d->authState = LoginJobPrivate::Login;
            qCDebug(KIMAP_LOG) << "sending LOGIN";
            d->tags << d->sessionInternal()->sendCommand("LOGIN",
                    '"' + quoteIMAP(d->userName).toUtf8() + '"' +
                    ' ' +
                    '"' + quoteIMAP(d->password).toUtf8() + '"');
        } else {
            if (!d->startAuthentication()) {
                emitResult();
            }
        }
    }
}

void LoginJob::handleResponse(const Response &response)
{
    Q_D(LoginJob);

if (response.content.isEmpty()) {
        return;
    }

//set the actual command name for standard responses
    QString commandName = i18n("Login");
    if (d->authState == LoginJobPrivate::Capability) {
        commandName = i18n("Capability");
    } else if (d->authState == LoginJobPrivate::StartTls) {
        commandName = i18n("StartTls");
    }

enum ResponseCode {
        OK,
        ERR,
        UNTAGGED,
        CONTINUATION,
        MALFORMED
    };

QByteArray tag = response.content.first().toString();
    ResponseCode code = OK;

qCDebug(KIMAP_LOG) << commandName << tag;

if (tag == "+") {
        code = CONTINUATION;
    } else if (tag == "*") {
        if (response.content.size() < 2) {
            code = MALFORMED; // Received empty untagged response
        } else {
            code = UNTAGGED;
        }
    } else if (d->tags.contains(tag)) {
        if (response.content.size() < 2) {
            code = MALFORMED;
        } else if (response.content[1].toString() == "OK") {
            code = OK;
        } else {
            code = ERR;
        }
    }

switch (code) {
    case MALFORMED:
        // We'll handle it later
        break;

case ERR:
        //server replied with NO or BAD for SASL authentication
        if (d->authState == LoginJobPrivate::Authenticate) {
            sasl_dispose(&d->conn);
        }

setError(UserDefinedError);
        setErrorText(i18n("%1 failed, server replied: %2", commandName, QLatin1String(response.toString().constData())));
        emitResult();
        return;

case UNTAGGED:
        // The only untagged response interesting for us here is CAPABILITY
        if (response.content[1].toString() == "CAPABILITY") {
            d->capabilities.clear();
            QList<Response::Part>::const_iterator p = response.content.begin() + 2;
            while (p != response.content.end()) {
                QString capability = QLatin1String(p->toString());
                d->capabilities << capability;
                if (capability == QLatin1String("LOGINDISABLED")) {
                    d->plainLoginDisabled = true;
                }
                ++p;
            }
            qCDebug(KIMAP_LOG) << "Capabilities updated: " << d->capabilities;
        }
        break;

case CONTINUATION:
        if (d->authState != LoginJobPrivate::Authenticate) {
            // Received unexpected continuation response for something
            // other than AUTHENTICATE command
            code = MALFORMED;
            break;
        }

if (d->authMode == QLatin1String("PLAIN")) {
            if (response.content.size() > 1 && response.content.at(1).toString() == "OK") {
                return;
            }
            QByteArray challengeResponse;
            if (!d->authorizationName.isEmpty()) {
                challengeResponse += d->authorizationName.toUtf8();
            }
            challengeResponse += '\0';
            challengeResponse += d->userName.toUtf8();
            challengeResponse += '\0';
            challengeResponse += d->password.toUtf8();
            challengeResponse = challengeResponse.toBase64();
            d->sessionInternal()->sendData(challengeResponse);
        } else if (response.content.size() >= 2) {
            if (!d->answerChallenge(QByteArray::fromBase64(response.content[1].toString()))) {
                emitResult(); //error, we're done
            }
        } else {
            // Received empty continuation for authMode other than PLAIN
            code = MALFORMED;
        }
        break;

case OK:

switch (d->authState) {
        case LoginJobPrivate::PreStartTlsCapability:
            if (d->capabilities.contains(QLatin1String("STARTTLS"))) {
                d->authState = LoginJobPrivate::StartTls;
                d->tags << d->sessionInternal()->sendCommand("STARTTLS");
            } else {
                qCWarning(KIMAP_LOG) << "STARTTLS not supported by server!";
                setError(UserDefinedError);
                setErrorText(i18n("STARTTLS is not supported by the server, try using SSL/TLS instead."));
                emitResult();
            }
            break;

case LoginJobPrivate::StartTls:
            d->sessionInternal()->startSsl(QSsl::SecureProtocols);
            break;

case LoginJobPrivate::Capability:
            //cleartext login, if enabled
            if (d->authMode.isEmpty()) {
                if (d->plainLoginDisabled) {
                    setError(UserDefinedError);
                    setErrorText(i18n("Login failed, plain login is disabled by the server."));
                    emitResult();
                } else {
                    d->authState = LoginJobPrivate::Login;
                    d->tags << d->sessionInternal()->sendCommand("LOGIN",
                            '"' + quoteIMAP(d->userName).toUtf8() + '"' +
                            ' ' +
                            '"' + quoteIMAP(d->password).toUtf8() + '"');
                }
            } else {
                bool authModeSupported = false;
                //find the selected SASL authentication method
                for (const QString &capability : qAsConst(d->capabilities)) {
                    if (capability.startsWith(QLatin1String("AUTH="))) {
                        if (capability.midRef(5) == d->authMode) {
                            authModeSupported = true;
                            break;
                        }
                    }
                }
                if (!authModeSupported) {
                    setError(UserDefinedError);
                    setErrorText(i18n("Login failed, authentication mode %1 is not supported by the server.", d->authMode));
                    emitResult();
                } else if (!d->startAuthentication()) {
                    emitResult(); //problem, we're done
                }
            }
            break;

case LoginJobPrivate::Authenticate:
            sasl_dispose(&d->conn);   //SASL authentication done
        // Fall through
            Q_FALLTHROUGH();
        case LoginJobPrivate::Login:
            d->saveServerGreeting(response);
            emitResult(); //got an OK, command done
            break;

}

if (code == MALFORMED) {
        setErrorText(i18n("%1 failed, malformed reply from the server.", commandName));
        emitResult();
    }
}

bool LoginJobPrivate::startAuthentication()
{
    //SASL authentication
    if (!initSASL()) {
        q->setError(LoginJob::UserDefinedError);
        q->setErrorText(i18n("Login failed, client cannot initialize the SASL library."));
        return false;
    }

authState = LoginJobPrivate::Authenticate;
    const char *out = nullptr;
    uint outlen = 0;
    const char *mechusing = nullptr;

int result = sasl_client_new("imap", m_session->hostName().toLatin1().constData(), nullptr, nullptr, callbacks, 0, &conn);
    if (result != SASL_OK) {
        const QString saslError = QString::fromUtf8(sasl_errdetail(conn));
        qCWarning(KIMAP_LOG) << "sasl_client_new failed with:" << result << saslError;
        q->setError(LoginJob::UserDefinedError);
        q->setErrorText(saslError);
        return false;
    }

do {
        qCDebug(KIMAP_LOG) << "Trying authmod" << authMode.toLatin1();
        result = sasl_client_start(conn, authMode.toLatin1().constData(), &client_interact, capabilities.contains(QLatin1String("SASL-IR")) ? &out : nullptr, &outlen, &mechusing);

if (result == SASL_INTERACT) {
            if (!sasl_interact()) {
                sasl_dispose(&conn);
                q->setError(LoginJob::UserDefinedError);   //TODO: check up the actual error
                return false;
            }
        }
    } while (result == SASL_INTERACT);

if (result != SASL_CONTINUE && result != SASL_OK) {
        const QString saslError = QString::fromUtf8(sasl_errdetail(conn));
        qCWarning(KIMAP_LOG) << "sasl_client_start failed with:" << result << saslError;
        q->setError(LoginJob::UserDefinedError);
        q->setErrorText(saslError);
        sasl_dispose(&conn);
        return false;
    }

QByteArray tmp = QByteArray::fromRawData(out, outlen);
    QByteArray challenge = tmp.toBase64();

if (challenge.isEmpty()) {
        tags << sessionInternal()->sendCommand("AUTHENTICATE", authMode.toLatin1());
    } else {
        tags << sessionInternal()->sendCommand("AUTHENTICATE", authMode.toLatin1() + ' ' + challenge);
    }

return true;
}

bool LoginJobPrivate::answerChallenge(const QByteArray &data)
{
    QByteArray challenge = data;
    int result = -1;
    const char *out = nullptr;
    uint outlen = 0;
    do {
        result = sasl_client_step(conn, challenge.isEmpty() ? nullptr : challenge.data(),
                                  challenge.size(),
                                  &client_interact,
                                  &out, &outlen);

if (result == SASL_INTERACT) {
            if (!sasl_interact()) {
                q->setError(LoginJob::UserDefinedError);   //TODO: check up the actual error
                sasl_dispose(&conn);
                return false;
            }
        }
    } while (result == SASL_INTERACT);

if (result != SASL_CONTINUE && result != SASL_OK) {
        const QString saslError = QString::fromUtf8(sasl_errdetail(conn));
        qCWarning(KIMAP_LOG) << "sasl_client_step failed with:" << result << saslError;
        q->setError(LoginJob::UserDefinedError);   //TODO: check up the actual error
        q->setErrorText(saslError);
        sasl_dispose(&conn);
        return false;
    }

QByteArray tmp = QByteArray::fromRawData(out, outlen);
    challenge = tmp.toBase64();

sessionInternal()->sendData(challenge);

return true;
}

void LoginJobPrivate::sslResponse(bool response)
{
    if (response) {
        authState = LoginJobPrivate::Capability;
        tags << sessionInternal()->sendCommand("CAPABILITY");
    } else {
        q->setError(LoginJob::UserDefinedError);
        q->setErrorText(i18n("Login failed, TLS negotiation failed."));
        encryptionMode = LoginJob::Unencrypted;
        q->emitResult();
    }
}

void LoginJob::setEncryptionMode(EncryptionMode mode)
{
    Q_D(LoginJob);
    d->encryptionMode = mode;
}

LoginJob::EncryptionMode LoginJob::encryptionMode()
{
    Q_D(LoginJob);
    return d->encryptionMode;
}

void LoginJob::setAuthenticationMode(AuthenticationMode mode)
{
    Q_D(LoginJob);
    switch (mode) {
    case ClearText: d->authMode = QLatin1String("");
        break;
    case Login: d->authMode = QStringLiteral("LOGIN");
        break;
    case Plain: d->authMode = QStringLiteral("PLAIN");
        break;
    case CramMD5: d->authMode = QStringLiteral("CRAM-MD5");
        break;
    case DigestMD5: d->authMode = QStringLiteral("DIGEST-MD5");
        break;
    case GSSAPI: d->authMode = QStringLiteral("GSSAPI");
        break;
    case Anonymous: d->authMode = QStringLiteral("ANONYMOUS");
        break;
    case XOAuth2: d->authMode = QStringLiteral("XOAUTH2");
        break;
    default:
        d->authMode = QString();
    }
}

void LoginJob::connectionLost()
{
    Q_D(LoginJob);

//don't emit the result if the connection was lost before getting the tls result, as it can mean
    //the TLS handshake failed and the socket was reconnected in normal mode
    if (d->authState != LoginJobPrivate::StartTls) {
        qCWarning(KIMAP_LOG) << "Connection to server lost " << d->m_socketError;
        if (d->m_socketError == QAbstractSocket::SslHandshakeFailedError) {
            setError(KJob::UserDefinedError);
            setErrorText(i18n("SSL handshake failed."));
            emitResult();
        } else {
            setError(ERR_COULD_NOT_CONNECT);
            setErrorText(i18n("Connection to server lost."));
            emitResult();
        }
    }

}

void LoginJobPrivate::saveServerGreeting(const Response &response)
{
    // Concatenate the parts of the server response into a string, while dropping the first two parts
    // (the response tag and the "OK" code), and being careful not to add useless extra whitespace.

for (int i = 2; i < response.content.size(); i++) {
        if (response.content.at(i).type() == Response::Part::List) {
            serverGreeting += QLatin1Char('(');
            const QList<QByteArray> itemLst = response.content.at(i).toList();
            for (const QByteArray &item : itemLst) {
                serverGreeting += QLatin1String(item) + QLatin1Char(' ');
            }
            serverGreeting.chop(1);
            serverGreeting += QStringLiteral(") ");
        } else {
            serverGreeting += QLatin1String(response.content.at(i).toString()) + QLatin1Char(' ');
        }
    }
    serverGreeting.chop(1);
}

QString LoginJob::serverGreeting() const
{
    Q_D(const LoginJob);
    return d->serverGreeting;
}

#include "moc_loginjob.cpp"
07070100000062000081A40000000200000002000000015ED129EC0000100B000000000000000000000000000000000000003800000000kimap-VERSIONgit.20200529T172740~a5402d2/src/loginjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_LOGINJOB_H
#define KIMAP_LOGINJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class LoginJobPrivate;

class KIMAP_EXPORT LoginJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(LoginJob)

friend class SessionPrivate;

public:
    enum EncryptionMode {
        Unencrypted = 0,
        SSLorTLS, /*!< Use SSL/TLS encryption, KIMAP will automatically negoatiate
                       the best supported encryption protocol. */
        STARTTLS  /*!< Use STARTTLS to upgrade an initially plaintext connection to
                       encrypted connection. KIMAP will automatically negoatiate
                       the best supported encryption protocol. */
    };

enum AuthenticationMode {
        ClearText = 0,
        Login,
        Plain,
        CramMD5,
        DigestMD5,
        NTLM,
        GSSAPI,
        Anonymous,
        XOAuth2
    };

enum ErrorCode {
        ERR_COULD_NOT_CONNECT = KJob::UserDefinedError + 23 // same as in kio
    };

explicit LoginJob(Session *session);
    ~LoginJob() override;

Q_REQUIRED_RESULT QString userName() const;
    void setUserName(const QString &userName);

/**
     * Get the authorization identity.
     * @since 4.10
     */
    Q_REQUIRED_RESULT QString authorizationName() const;

/**
     * Set the authorization identity.
     *
     * If set, proxy-authentication according to RFC4616 will be used.
     *
     * Note that this feature only works with the "PLAIN" AuthenticationMode.
     *
     * The @param authorizationName will be used together with the password() to get authenticated as userName() by the authorization of the provided credentials.
     * This allows to login as a user using the admin credentials and the users name.
     * @since 4.10
     */
    void setAuthorizationName(const QString &authorizationName);

Q_REQUIRED_RESULT QString password() const;
    void setPassword(const QString &password);

/**
     * Returns the server greeting, in case of a successful login.
     * If the login wasn't successful, this method returns an empty string. Use errorString() to
     * get the error message in this case.
     *
     * Note that the content of this response is not defined by the IMAP protocol and is
     * implementation-dependent.
     * @since 4.7
     */
    Q_REQUIRED_RESULT QString serverGreeting() const;

/**
     * Set the encryption mode for the connection. In case an encryption mode is set, the caller
     * MUST check the encryptionMode() result after executing the job, to see if the connection is
     * encrypted or not (e.g handshaking failed).
     * @param mode the encryption mode, see EncryptionModes
     */
    void setEncryptionMode(EncryptionMode mode);

/**
      Get the encryption mode.
      @return the currently active encryption mode
    */
    Q_REQUIRED_RESULT EncryptionMode encryptionMode();

void setAuthenticationMode(AuthenticationMode mode);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
    void connectionLost() override;

private:
    Q_PRIVATE_SLOT(d_func(), void sslResponse(bool))
};

}

#endif
07070100000063000081A40000000200000002000000015ED129EC000005C6000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/logoutjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "logoutjob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class LogoutJobPrivate : public JobPrivate
{
public:
    LogoutJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~LogoutJobPrivate() { }
};
}

using namespace KIMAP;

LogoutJob::LogoutJob(Session *session)
    : Job(*new LogoutJobPrivate(session, i18n("Logout")))
{
}

LogoutJob::~LogoutJob()
{
}

void LogoutJob::doStart()
{
    Q_D(LogoutJob);
    d->tags << d->sessionInternal()->sendCommand("LOGOUT");
}

void LogoutJob::connectionLost()
{
    emitResult();
}
07070100000064000081A40000000200000002000000015ED129EC0000050A000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/logoutjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_LOGOUTJOB_H
#define KIMAP_LOGOUTJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
class LogoutJobPrivate;

class KIMAP_EXPORT LogoutJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(LogoutJob)

friend class SessionPrivate;

public:
    explicit LogoutJob(Session *session);
    ~LogoutJob() override;

protected:
    void doStart() override;
    void connectionLost() override;
};

}

#endif
07070100000065000081A40000000200000002000000015ED129EC00000B64000000000000000000000000000000000000004100000000kimap-VERSIONgit.20200529T172740~a5402d2/src/metadatajobbase.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "metadatajobbase.h"
#include "metadatajobbase_p.h"
#include "response_p.h"
#include "session_p.h"

#include <KLocalizedString>

using namespace KIMAP;

QByteArray MetaDataJobBasePrivate::addPrefix(const QByteArray &entry, const QByteArray &attribute) const
{
    if (serverCapability == MetaDataJobBase::Annotatemore) {
        if (attribute == "value.shared") {
            return QByteArray("/shared").append(entry);
        } else if (attribute == "value.priv") {
            return QByteArray("/private").append(entry);
        }
    }
    return entry;
}

QByteArray MetaDataJobBasePrivate::removePrefix(const QByteArray &entry) const
{
    if (serverCapability == MetaDataJobBase::Annotatemore) {
        if (entry.startsWith("/shared")) {
            return entry.mid(QByteArray("/shared").size());
        } else if (entry.startsWith("/private")) {
            return entry.mid(QByteArray("/private").size());
        }
    }
    return entry;
}

QByteArray MetaDataJobBasePrivate::getAttribute(const QByteArray &entry) const
{
    if (serverCapability == MetaDataJobBase::Annotatemore) {
        if (entry.startsWith("/shared")) {
            return QByteArray("value.shared");
        } else if (entry.startsWith("/private")) {
            return QByteArray("value.priv");
        }
    }
    return QByteArray();
}

MetaDataJobBase::MetaDataJobBase(Session *session)
    : Job(*new MetaDataJobBasePrivate(session, i18n("MetaDataJobBase")))
{
}

MetaDataJobBase::MetaDataJobBase(JobPrivate &dd)
    : Job(dd)
{
}

MetaDataJobBase::~MetaDataJobBase()
{
}

void MetaDataJobBase::setMailBox(const QString &mailBox)
{
    Q_D(MetaDataJobBase);
    d->mailBox = mailBox;
}

QString MetaDataJobBase::mailBox() const
{
    Q_D(const MetaDataJobBase);
    return d->mailBox;
}

void MetaDataJobBase::setServerCapability(ServerCapability capability)
{
    Q_D(MetaDataJobBase);
    d->serverCapability = capability;
}

MetaDataJobBase::ServerCapability MetaDataJobBase::serverCapability() const
{
    Q_D(const MetaDataJobBase);
    return d->serverCapability;
}
07070100000066000081A40000000200000002000000015ED129EC00000F6B000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/metadatajobbase.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_METADATAJOBBASE_H
#define KIMAP_METADATAJOBBASE_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class MetaDataJobBasePrivate;

/**
 * Base class for jobs that operate on mailbox metadata
 *
 * Provides support for the IMAP METADATA extension; both the
 * final RFC version
 * (<a href="https://tools.ietf.org/html/rfc5464">RFC 5464</a>)
 * and the older, incompatible draft version (known as ANNOTATEMORE)
 * (<a
 * href="https://tools.ietf.org/html/draft-daboo-imap-annotatemore-07"
 * >draft-daboo-imap-annotatemore-07</a>).
 *
 * This class cannot be used directly, you must subclass it and reimplement
 * at least the doStart() method.
*/
class KIMAP_EXPORT MetaDataJobBase : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(MetaDataJobBase)

friend class SessionPrivate;

public:
    explicit MetaDataJobBase(Session *session);
    ~MetaDataJobBase() override;

/**
     * Represents the capability level of the server.
     */
    enum ServerCapability {
        /**
         * Used to indicate that the server supports the RFC 5464 version
         * of the extension.
         *
         * This corresponds to the METADATA server capability.
         */
        Metadata = 0,
        /**
         * Used to indicate that the server supports the
         * draft-daboo-imap-annotatemore-07 version of the extension.
         *
         * This corresponds to the ANNOTATEMORE server capability.
         */
        Annotatemore
    };

/**
     * Set the mailbox to act on
     *
     * This may be an empty string, in which case metadata for the
     * server (rather than a specific mailbox) will be retrieved.
     *
     * @param mailBox  the name of an existing mailbox, or an empty string
     */
    void setMailBox(const QString &mailBox);
    /**
     * The mailbox that will be acted upon.
     *
     * If this is an empty string, server metadata will be retrieved.
     *
     * @return  a mailbox name, or an empty string
     */
    Q_REQUIRED_RESULT QString mailBox() const;

/**
     * Set what version of the metadata extension to be compatible with.
     *
     * This will determine the commands that will be sent to the server.
     *
     * The draft for the metadata extension changed in an incompatible
     * way between versions 7 and 8, and some servers support version 7.
     * It should be possible to check which version the server supports
     * using CapabilityJob: servers implementing
     * draft-daboo-imap-annotatemore-07 should advertise the
     * ANNOTATEMORE capability, whereas servers implementing the final
     * RFC 5464 should advertise the METADATA capability.
     *
     * The default mode is Metadata.
     *
     * @param capability  the version of the extension implemented by the server
     */
    void setServerCapability(ServerCapability capability);
    /**
     * The version of the metadata extension that will be used.
     */
    Q_REQUIRED_RESULT ServerCapability serverCapability() const;

protected:
    MetaDataJobBase(JobPrivate &dd);

};

}

#endif
07070100000067000081A40000000200000002000000015ED129EC00000616000000000000000000000000000000000000004100000000kimap-VERSIONgit.20200529T172740~a5402d2/src/metadatajobbase_p.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_METADATAJOBBASE_P_H
#define KIMAP_METADATAJOBBASE_P_H

#include "metadatajobbase.h"
#include "job_p.h"
#include "response_p.h"
#include "session.h"

namespace KIMAP
{
class MetaDataJobBasePrivate : public JobPrivate
{
public:
    MetaDataJobBasePrivate(Session *session, const QString &name) : JobPrivate(session, name), serverCapability(MetaDataJobBase::Metadata)
    {}

~MetaDataJobBasePrivate() { }

QByteArray addPrefix(const QByteArray &entry, const QByteArray &attribute) const;
    QByteArray removePrefix(const QByteArray &) const;

QByteArray getAttribute(const QByteArray &entry) const;

MetaDataJobBase::ServerCapability serverCapability;
    QString mailBox;
};
}

#endif
07070100000068000081A40000000200000002000000015ED129EC00000BE6000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/movejob.cpp/*
    Copyright (c) 2016 Daniel Vrátil <dvratil@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "movejob.h"

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

#include <KLocalizedString>

//TODO: when custom error codes are introduced, handle the NO [TRYCREATE] response

namespace KIMAP
{
class MoveJobPrivate : public JobPrivate
{
public:
    MoveJobPrivate(Session *session, const QString &name) 
        : JobPrivate(session, name)
        , uidBased(false)
    {}

~MoveJobPrivate()
    {}

QString mailBox;
    ImapSet set;
    ImapSet resultingUids;
    bool uidBased;
};
}

using namespace KIMAP;

MoveJob::MoveJob(Session *session)
    : Job(*new MoveJobPrivate(session, i18n("Move")))
{
    Q_D(MoveJob);
    d->uidBased = false;
}

MoveJob::~MoveJob()
{
}

void MoveJob::setMailBox(const QString &mailBox)
{
    Q_D(MoveJob);
    d->mailBox = mailBox;
}

QString MoveJob::mailBox() const
{
    Q_D(const MoveJob);
    return d->mailBox;
}

void MoveJob::setSequenceSet(const ImapSet &set)
{
    Q_D(MoveJob);
    d->set = set;
}

ImapSet MoveJob::sequenceSet() const
{
    Q_D(const MoveJob);
    return d->set;
}

void MoveJob::setUidBased(bool uidBased)
{
    Q_D(MoveJob);
    d->uidBased = uidBased;
}

bool MoveJob::isUidBased() const
{
    Q_D(const MoveJob);
    return d->uidBased;
}

ImapSet MoveJob::resultingUids() const
{
    Q_D(const MoveJob);
    return d->resultingUids;
}

void MoveJob::doStart()
{
    Q_D(MoveJob);

d->set.optimize();
    QByteArray parameters = d->set.toImapSequenceSet() + ' ';
    parameters += '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"';

QByteArray command = "MOVE";
    if (d->uidBased) {
        command = "UID " + command;
    }

d->tags << d->sessionInternal()->sendCommand(command, parameters);
}

void MoveJob::handleResponse(const Response &response)
{
    Q_D(MoveJob);

for (auto it = response.responseCode.cbegin(), end = response.responseCode.cend();
         it != end; ++it) {
        if (it->toString() == "COPYUID") {
            it = it + 3;
            if (it < end) {
                d->resultingUids = ImapSet::fromImapSequenceSet(it->toString());
            }
            break;
        }
    }

handleErrorReplies(response);
}
07070100000069000081A40000000200000002000000015ED129EC00000EBB000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/movejob.h/*
    Copyright (c) 2016 Daniel Vrátil <dvratil@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_MOVEJOB_H_
#define KIMAP_MOVEJOB_H_

#include "kimap_export.h"

#include "job.h"
#include "imapset.h"

namespace KIMAP {

class MoveJobPrivate;

/**
 * Moves messages from current mailbox to another
 *
 * Note that move functionality is not specified in the base IMAP
 * protocol and is defined as an extension in RFC6851. That means
 * that the MoveJob can only be used when the server lists "MOVE"
 * in response to CAPABILITY command.
 *
 * Unlike the traditional emulation of moving messages, i.e. COPY + STORE + EXPUNGE,
 * MOVE guarantees the transaction to be atomic on the server.
 *
 * @since 5.4
 */
class KIMAP_EXPORT MoveJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(MoveJob)

friend class SessionPrivate;

public:
    explicit MoveJob(Session *session);
    ~MoveJob() override;

/**
     * Set the destination mailbox
     *
     * If the mailbox does not exist, the server should not create
     * it automatically and the job should fail.  Note, however,
     * that a conforming server may create the mailbox automatically.
     *
     * @param mailBox  the (unquoted) name of the mailbox where the
     *                 messages should be moved to
     */
    void setMailBox(const QString &mailbox);
    /**
     * The destination mailbox
     */
    Q_REQUIRED_RESULT QString mailBox() const;

/**
     * Sets the messages to be moved,
     *
     * If sequence numbers are given, isUidBased() should be false.  If UIDs
     * are given, isUidBased() should be true.
     *
     * @param set  the sequence numbers or UIDs of the messages to be moved
     */
    void setSequenceSet(const ImapSet &set);
    /**
     * The messages that will be moved.
     *
     * isUidBased() can be used to check whether the ImapSet contains
     * sequence numbers or UIDs.
     *
     * @return  the sequence numbers or UIDs of the messages to be moved
     */
    Q_REQUIRED_RESULT ImapSet sequenceSet() const;

/**
     * The UIDs of the moved messages in the destination mailbox.
     *
     * This will be an empty set if no messages have been moved yet
     * or if the server does not support the UIDPLUS extension.
     */
    Q_REQUIRED_RESULT ImapSet resultingUids() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}
#endif
0707010000006A000081A40000000200000002000000015ED129EC0000086C000000000000000000000000000000000000003D00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/myrightsjob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "myrightsjob.h"

#include <KLocalizedString>

#include "acljobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class MyRightsJobPrivate : public AclJobBasePrivate
{
public:
    MyRightsJobPrivate(Session *session, const QString &name) : AclJobBasePrivate(session, name), myRights(Acl::None) {}
    ~MyRightsJobPrivate() { }

Acl::Rights myRights;
};
}

using namespace KIMAP;

MyRightsJob::MyRightsJob(Session *session)
    : AclJobBase(*new MyRightsJobPrivate(session, i18n("MyRights")))
{
}

MyRightsJob::~MyRightsJob()
{
}

void MyRightsJob::doStart()
{
    Q_D(MyRightsJob);

d->tags << d->sessionInternal()->sendCommand("MYRIGHTS", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void MyRightsJob::handleResponse(const Response &response)
{
    Q_D(MyRightsJob);

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() == 4 &&
                response.content[1].toString() == "MYRIGHTS") {
            d->myRights = Acl::rightsFromString(response.content[3].toString());
        }
    }
}

bool MyRightsJob::hasRightEnabled(Acl::Right right)
{
    Q_D(MyRightsJob);
    return d->myRights & right;
}

Acl::Rights MyRightsJob::rights()
{
    Q_D(MyRightsJob);
    return d->myRights;
}
0707010000006B000081A40000000200000002000000015ED129EC000009D1000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/myrightsjob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_MYRIGHTSJOB_H
#define KIMAP_MYRIGHTSJOB_H

#include "kimap_export.h"

#include "acljobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class MyRightsJobPrivate;

/**
 * Determine the rights the currently-logged-in user
 * has on the current mailbox.
 *
 * This should take into account the full access control
 * list.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * The current user must have one of the following rights
 * on the mailbox for this job to succeed:
 * - Acl::Lookup
 * - Acl::Read
 * - Acl::Insert
 * - Acl::CreateMailbox
 * - Acl::DeleteMailbox
 * - Acl::Admin
 *
 * This job requires that the server supports the ACL
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc4314">RFC 4314</a>.
 */
class KIMAP_EXPORT MyRightsJob : public AclJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(MyRightsJob)

friend class SessionPrivate;

public:
    explicit MyRightsJob(Session *session);
    ~MyRightsJob() override;

/**
     * Check whether the current user has the a particular right
     * on the mailbox.
     *
     * The result of this method is undefined if the job has
     * not yet completed.
     *
     * @param right       the right to check for
     */
    Q_REQUIRED_RESULT bool hasRightEnabled(Acl::Right right);
    /**
     * Get the rights for the current user on the mailbox.
     *
     * The result of this method is undefined if the job has
     * not yet completed.
     */
    Q_REQUIRED_RESULT Acl::Rights rights();

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
0707010000006C000081A40000000200000002000000015ED129EC0000106A000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/namespacejob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "namespacejob.h"

#include "kimap_debug.h"
#include <KLocalizedString>

#include "job_p.h"
#include "listjob.h"
#include "response_p.h"
#include "rfccodecs.h"
#include "session_p.h"
#include "imapstreamparser.h"

namespace KIMAP
{
class NamespaceJobPrivate : public JobPrivate
{
public:
    NamespaceJobPrivate(Session *session,  const QString &name) : JobPrivate(session, name) { }
    ~NamespaceJobPrivate() { }

QList<MailBoxDescriptor> processNamespaceList(const QList<QByteArray> &namespaceList)
    {
        QList<MailBoxDescriptor> result;

for (const QByteArray &namespaceItem : namespaceList) {
            ImapStreamParser parser(nullptr);
            parser.setData(namespaceItem);

try {
                QList<QByteArray> parts = parser.readParenthesizedList();
                if (parts.size() < 2) {
                    continue;
                }
                MailBoxDescriptor descriptor;
                descriptor.name = QString::fromUtf8(decodeImapFolderName(parts[0]));
                descriptor.separator = QLatin1Char(parts[1][0]);

result << descriptor;
            } catch (const KIMAP::ImapParserException &e) {
                qCWarning(KIMAP_LOG) << "The stream parser raised an exception during namespace list parsing:" << e.what();
                qCWarning(KIMAP_LOG) << "namespacelist:" << namespaceList;
            }

}

return result;
    }

QList<MailBoxDescriptor> personalNamespaces;
    QList<MailBoxDescriptor> userNamespaces;
    QList<MailBoxDescriptor> sharedNamespaces;
};
}

using namespace KIMAP;

NamespaceJob::NamespaceJob(Session *session)
    : Job(*new NamespaceJobPrivate(session, i18n("Namespace")))
{
}

NamespaceJob::~NamespaceJob()
{
}

QList<MailBoxDescriptor> NamespaceJob::personalNamespaces() const
{
    Q_D(const NamespaceJob);
    return d->personalNamespaces;
}

QList<MailBoxDescriptor> NamespaceJob::userNamespaces() const
{
    Q_D(const NamespaceJob);
    return d->userNamespaces;
}

QList<MailBoxDescriptor> NamespaceJob::sharedNamespaces() const
{
    Q_D(const NamespaceJob);
    return d->sharedNamespaces;
}

bool NamespaceJob::containsEmptyNamespace() const
{
    Q_D(const NamespaceJob);
    const QList<MailBoxDescriptor> completeList = d->personalNamespaces
                                            + d->userNamespaces
                                            + d->sharedNamespaces;

for (const MailBoxDescriptor &descriptor : completeList) {
        if (descriptor.name.isEmpty()) {
            return true;
        }
    }

return false;
}

void NamespaceJob::doStart()
{
    Q_D(NamespaceJob);
    d->tags << d->sessionInternal()->sendCommand("NAMESPACE");
}

void NamespaceJob::handleResponse(const Response &response)
{
    Q_D(NamespaceJob);
    if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 5 &&
                response.content[1].toString() == "NAMESPACE") {
            // Personal namespaces
            d->personalNamespaces = d->processNamespaceList(response.content[2].toList());

// User namespaces
            d->userNamespaces = d->processNamespaceList(response.content[3].toList());

// Shared namespaces
            d->sharedNamespaces = d->processNamespaceList(response.content[4].toList());
        }
    }
}
0707010000006D000081A40000000200000002000000015ED129EC0000065F000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/namespacejob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_NAMESPACEJOB_H
#define KIMAP_NAMESPACEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
struct MailBoxDescriptor;
class NamespaceJobPrivate;

class KIMAP_EXPORT NamespaceJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(NamespaceJob)

friend class SessionPrivate;

public:
    NamespaceJob(Session *session);
    ~NamespaceJob() override;

Q_REQUIRED_RESULT QList<MailBoxDescriptor> personalNamespaces() const;
    Q_REQUIRED_RESULT QList<MailBoxDescriptor> userNamespaces() const;
    Q_REQUIRED_RESULT QList<MailBoxDescriptor> sharedNamespaces() const;

bool containsEmptyNamespace() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
0707010000006E000081A40000000200000002000000015ED129EC0000085B000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/quotajobbase.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "quotajobbase.h"
#include "quotajobbase_p.h"
#include "response_p.h"
#include "session_p.h"

#include <KLocalizedString>

using namespace KIMAP;

QMap<QByteArray, QPair<qint64, qint64> > QuotaJobBasePrivate::readQuota(const Response::Part &content)
{
    QMap<QByteArray, QPair<qint64, qint64> > quotaMap;
    QList<QByteArray> quotas = content.toList();

int i = 0;
    while (i < quotas.size() - 2) {
        QByteArray resource = quotas[i].toUpper();
        qint64 usage = quotas[i + 1].toInt();
        qint64 limit = quotas[i + 2].toInt();
        quotaMap[resource] = qMakePair(usage, limit);
        i += 3;
    }

return quotaMap;
}

QuotaJobBase::QuotaJobBase(Session *session)
    : Job(*new QuotaJobBasePrivate(session, i18n("QuotaJobBase")))
{
}

QuotaJobBase::QuotaJobBase(JobPrivate &dd)
    : Job(dd)
{
}

QuotaJobBase::~QuotaJobBase()
{
}

qint64 QuotaJobBase::usage(const QByteArray &resource)
{
    Q_D(QuotaJobBase);

QByteArray r = resource.toUpper();

if (d->quota.contains(r)) {
        return d->quota[r].first;
    }
    return -1;
}

qint64 QuotaJobBase::limit(const QByteArray &resource)
{
    Q_D(QuotaJobBase);

QByteArray r = resource.toUpper();

if (d->quota.contains(r)) {
        return d->quota[r].second;
    }
    return -1;
}
0707010000006F000081A40000000200000002000000015ED129EC00000C19000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/quotajobbase.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_QUOTAJOBBASE_H
#define KIMAP_QUOTAJOBBASE_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class QuotaJobBasePrivate;

/**
 * Base class for jobs that operate on mailbox quotas
 *
 * Provides support for the IMAP QUOTA extension, as defined by
 * <a href="https://tools.ietf.org/html/rfc2087" title="IMAP QUOTA extension">RFC 2087</a>.
 *
 * This class cannot be used directly, you must subclass it and reimplement
 * at least the doStart() method.
*/
class KIMAP_EXPORT QuotaJobBase : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(QuotaJobBase)

friend class SessionPrivate;

public:
    explicit QuotaJobBase(Session *session);
    ~QuotaJobBase() override;

/**
     * Get the current usage for a resource.
     *
     * All quota jobs will normally cause the server to return
     * details of resource usage for all resources that were
     * queried or modified by the job.
     *
     * Note that RFC 2087 is slightly ambiguous about whether
     * SETQUOTA will cause this information to be sent by the
     * server.
     *
     * Note that if there is no limit for a resource, the
     * server will not provide information about resource
     * usage.
     *
     * @param resource  the resource to get the usage for
     * @return  the resource usage in appropriate units, or -1
     *          if the usage is unknown or there is no
     *          limit on the resource
     */
    Q_REQUIRED_RESULT qint64 usage(const QByteArray &resource);
    /**
     * Get the current limit for a resource.
     *
     * All quota jobs will normally cause the server to return
     * details of resource limits for all resources that were
     * queried or modified by the job.
     *
     * Note that RFC 2087 is slightly ambiguous about whether
     * SETQUOTA will cause this information to be sent by the
     * server.
     *
     * @param resource  the resource to get the limit for
     * @return  the resource limit in appropriate units, or -1
     *          if the limit is unknown or there is no limit
     *          on the resource
     */
    Q_REQUIRED_RESULT qint64 limit(const QByteArray &resource);

protected:
    QuotaJobBase(JobPrivate &dd);

};

}

#endif
07070100000070000081A40000000200000002000000015ED129EC00000548000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/quotajobbase_p.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_QUOTAJOBBASE_P_H
#define KIMAP_QUOTAJOBBASE_P_H

#include "job_p.h"
#include "response_p.h"
#include "session.h"

#include <QMap>

namespace KIMAP
{
class QuotaJobBasePrivate : public JobPrivate
{
public:
    QuotaJobBasePrivate(Session *session, const QString &name) : JobPrivate(session, name)
    {}

~QuotaJobBasePrivate() { }
    static QMap<QByteArray, QPair<qint64, qint64> > readQuota(const Response::Part &content);

QMap<QByteArray, QPair<qint64, qint64> > quota;
};
}

#endif
07070100000071000081A40000000200000002000000015ED129EC00000840000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/renamejob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "renamejob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class RenameJobPrivate : public JobPrivate
{
public:
    RenameJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~RenameJobPrivate() { }

QString sourceMailBox;
    QString destinationMailBox;
};
}

using namespace KIMAP;

RenameJob::RenameJob(Session *session)
    : Job(*new RenameJobPrivate(session, i18n("Rename")))
{
}

RenameJob::~RenameJob()
{
}

void RenameJob::doStart()
{
    Q_D(RenameJob);
    d->tags << d->sessionInternal()->sendCommand("RENAME", '\"' + KIMAP::encodeImapFolderName(d->sourceMailBox.toUtf8()) +
            "\" \"" + KIMAP::encodeImapFolderName(d->destinationMailBox.toUtf8()) + '\"');
}

void RenameJob::setSourceMailBox(const QString &mailBox)
{
    Q_D(RenameJob);
    d->sourceMailBox = mailBox;
}

QString RenameJob::sourceMailBox() const
{
    Q_D(const RenameJob);
    return d->sourceMailBox;
}

void RenameJob::setDestinationMailBox(const QString &mailBox)
{
    Q_D(RenameJob);
    d->destinationMailBox = mailBox;
}

QString RenameJob::destinationMailBox() const
{
    Q_D(const RenameJob);
    return d->destinationMailBox;
}
07070100000072000081A40000000200000002000000015ED129EC000006B4000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/renamejob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_RENAMEJOB_H
#define KIMAP_RENAMEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
class RenameJobPrivate;

class KIMAP_EXPORT RenameJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(RenameJob)

friend class SessionPrivate;

public:
    explicit RenameJob(Session *session);
    ~RenameJob() override;

/**
     * Set the name of the mailbox that will be renamed.
     * @param mailBox the original name of the mailbox
     */
    void setSourceMailBox(const QString &mailBox);
    Q_REQUIRED_RESULT QString sourceMailBox() const;

/**
     * The new name of the mailbox, see setMailBox.
     * @param mailBox the new mailbox name
     */
    void setDestinationMailBox(const QString &mailBox);
    Q_REQUIRED_RESULT QString destinationMailBox() const;

protected:
    void doStart() override;
};

}

#endif
07070100000073000081A40000000200000002000000015ED129EC00000BC8000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/response_p.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_RESPONSE_P_H
#define KIMAP_RESPONSE_P_H

#include <QByteArray>
#include <QList>
#include <QMetaType>

namespace KIMAP
{

struct Response {
    class Part
    {
    public:
        enum Type { String = 0, List };

explicit Part(const QByteArray &string)
            : m_type(String), m_string(string) { }
        explicit Part(const QList<QByteArray> &list)
            : m_type(List), m_list(list) { }

inline Type type() const
        {
            return m_type;
        }
        inline QByteArray toString() const
        {
            return m_string;
        }
        inline QList<QByteArray> toList() const
        {
            return m_list;
        }

private:
        Type m_type;
        QByteArray m_string;
        QList<QByteArray> m_list;
    };

inline QByteArray toString() const
    {
        QByteArray result;

for (const Part &part : qAsConst(content)) {
            if (part.type() == Part::List) {
                result += '(';
                const QList<QByteArray> lstBa = part.toList();
                for (const QByteArray &item : lstBa ) {
                    result += ' ';
                    result += item;
                }
                result += " ) ";
            } else {
                result += part.toString() + ' ';
            }
        }

if (!responseCode.isEmpty()) {
            result += "[ ";
            for (const Part &part : qAsConst(responseCode)) {
                if (part.type() == Part::List) {
                    result += '(';
                    const QList<QByteArray> lstBa = part.toList();
                    for (const QByteArray &item : lstBa) {
                        result += ' ';
                        result += item;
                    }
                    result += " ) ";
                } else {
                    result += part.toString() + ' ';
                }
            }
            result += " ]";
        }

return result;
    }

QList<Part> content;
    QList<Part> responseCode;
};

}

Q_DECLARE_METATYPE(KIMAP::Response)
static const int _kimap_messageTypeId = qRegisterMetaType<KIMAP::Response>();

#endif
07070100000074000081A40000000200000002000000015ED129EC00004EFF000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/rfccodecs.cpp/**********************************************************************
 *
 *   rfccodecs.cpp - handler for various rfc/mime encodings
 *   Copyright (C) 2000 s.carstens@gmx.de
 *
 *   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; see the file COPYING.LIB.  If not, write to
 *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *   Boston, MA 02110-1301, USA.
 *
 *********************************************************************/
/**
 * @file
 * This file is part of the IMAP support library and defines the
 * RfcCodecs class.
 *
 * @brief
 * Defines the RfcCodecs class.
 *
 * @author Sven Carstens
 */

#include "rfccodecs.h"

#include <ctype.h>
#include <sys/types.h>

#include <stdio.h>
#include <stdlib.h>

#include <QTextCodec>
#include <QByteArray>
#include <QLatin1Char>
#include <KCodecs>

using namespace KIMAP;

// This part taken from rfc 2192 IMAP URL Scheme. C. Newman. September 1997.
// adapted to QT-Toolkit by Sven Carstens <s.carstens@gmx.de> 2000

//@cond PRIVATE
static const unsigned char base64chars[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
#define UNDEFINED 64
#define MAXLINE  76
static const char especials[17] = "()<>@,;:\"/[]?.= ";

/* UTF16 definitions */
#define UTF16MASK       0x03FFUL
#define UTF16SHIFT      10
#define UTF16BASE       0x10000UL
#define UTF16HIGHSTART  0xD800UL
#define UTF16HIGHEND    0xDBFFUL
#define UTF16LOSTART    0xDC00UL
#define UTF16LOEND      0xDFFFUL
//@endcond

//-----------------------------------------------------------------------------
QByteArray KIMAP::decodeImapFolderName(const QByteArray &inSrc)
{
    unsigned char c, i, bitcount;
    unsigned long ucs4, utf16, bitbuf;
    unsigned char base64[256], utf8[6];
    unsigned int srcPtr = 0;
    QByteArray dst;
    QByteArray src = inSrc;
    uint srcLen = inSrc.length();

/* initialize modified base64 decoding table */
    memset(base64, UNDEFINED, sizeof(base64));
    for (i = 0; i < sizeof(base64chars); ++i) {
        base64[(int)base64chars[i]] = i;
    }

/* loop until end of string */
    while (srcPtr < srcLen) {
        c = src[srcPtr++];
        /* deal with literal characters and &- */
        if (c != '&' || src[srcPtr] == '-') {
            /* encode literally */
            dst += c;
            /* skip over the '-' if this is an &- sequence */
            if (c == '&') {
                srcPtr++;
            }
        } else {
            /* convert modified UTF-7 -> UTF-16 -> UCS-4 -> UTF-8 -> HEX */
            bitbuf = 0;
            bitcount = 0;
            ucs4 = 0;
            while ((c = base64[(unsigned char)src[srcPtr]]) != UNDEFINED) {
                ++srcPtr;
                bitbuf = (bitbuf << 6) | c;
                bitcount += 6;
                /* enough bits for a UTF-16 character? */
                if (bitcount >= 16) {
                    bitcount -= 16;
                    utf16 = (bitcount ? bitbuf >> bitcount : bitbuf) & 0xffff;
                    /* convert UTF16 to UCS4 */
                    if (utf16 >= UTF16HIGHSTART && utf16 <= UTF16HIGHEND) {
                        ucs4 = (utf16 - UTF16HIGHSTART) << UTF16SHIFT;
                        continue;
                    } else if (utf16 >= UTF16LOSTART && utf16 <= UTF16LOEND) {
                        ucs4 += utf16 - UTF16LOSTART + UTF16BASE;
                    } else {
                        ucs4 = utf16;
                    }
                    /* convert UTF-16 range of UCS4 to UTF-8 */
                    if (ucs4 <= 0x7fUL) {
                        utf8[0] = ucs4;
                        i = 1;
                    } else if (ucs4 <= 0x7ffUL) {
                        utf8[0] = 0xc0 | (ucs4 >> 6);
                        utf8[1] = 0x80 | (ucs4 & 0x3f);
                        i = 2;
                    } else if (ucs4 <= 0xffffUL) {
                        utf8[0] = 0xe0 | (ucs4 >> 12);
                        utf8[1] = 0x80 | ((ucs4 >> 6) & 0x3f);
                        utf8[2] = 0x80 | (ucs4 & 0x3f);
                        i = 3;
                    } else {
                        utf8[0] = 0xf0 | (ucs4 >> 18);
                        utf8[1] = 0x80 | ((ucs4 >> 12) & 0x3f);
                        utf8[2] = 0x80 | ((ucs4 >> 6) & 0x3f);
                        utf8[3] = 0x80 | (ucs4 & 0x3f);
                        i = 4;
                    }
                    /* copy it */
                    for (c = 0; c < i; ++c) {
                        dst += utf8[c];
                    }
                }
            }
            /* skip over trailing '-' in modified UTF-7 encoding */
            if (src[srcPtr] == '-') {
                ++srcPtr;
            }
        }
    }
    return dst;
}

QString KIMAP::decodeImapFolderName(const QString &inSrc)
{
    return QString::fromUtf8(decodeImapFolderName(inSrc.toUtf8()).constData());
}

//-----------------------------------------------------------------------------

QByteArray KIMAP::quoteIMAP(const QByteArray &src)
{
    int len = src.length();
    QByteArray result;
    result.reserve(2 * len);
    for (int i = 0; i < len; i++) {
        if (src[i] == '"' || src[i] == '\\') {
            result += '\\';
        }
        result += src[i];
    }
    result.squeeze();
    return result;
}

QString KIMAP::quoteIMAP(const QString &src)
{
    uint len = src.length();
    QString result;
    result.reserve(2 * len);
    for (unsigned int i = 0; i < len; i++) {
        if (src[i] == QLatin1Char('"') || src[i] == QLatin1Char('\\')) {
            result += QLatin1Char('\\');
        }
        result += src[i];
    }
    //result.squeeze(); - unnecessary and slow
    return result;
}

//-----------------------------------------------------------------------------
QString KIMAP::encodeImapFolderName(const QString &inSrc)
{
    return QString::fromUtf8(encodeImapFolderName(inSrc.toUtf8()).constData());
}

QByteArray KIMAP::encodeImapFolderName(const QByteArray &inSrc)
{
    unsigned int utf8pos, utf8total, c, utf7mode, bitstogo, utf16flag;
    unsigned int ucs4, bitbuf;
    QByteArray src = inSrc;
    QByteArray dst;

int srcPtr = 0;
    utf7mode = 0;
    utf8total = 0;
    bitstogo = 0;
    utf8pos = 0;
    bitbuf = 0;
    ucs4 = 0;
    while (srcPtr < src.length()) {
        c = (unsigned char)src[srcPtr++];
        /* normal character? */
        if (c >= ' ' && c <= '~') {
            /* switch out of UTF-7 mode */
            if (utf7mode) {
                if (bitstogo) {
                    dst += base64chars[(bitbuf << (6 - bitstogo)) & 0x3F];
                    bitstogo = 0;
                }
                dst += '-';
                utf7mode = 0;
            }
            dst += c;
            /* encode '&' as '&-' */
            if (c == '&') {
                dst += '-';
            }
            continue;
        }
        /* switch to UTF-7 mode */
        if (!utf7mode) {
            dst += '&';
            utf7mode = 1;
        }
        /* Encode US-ASCII characters as themselves */
        if (c < 0x80) {
            ucs4 = c;
            utf8total = 1;
        } else if (utf8total) {
            /* save UTF8 bits into UCS4 */
            ucs4 = (ucs4 << 6) | (c & 0x3FUL);
            if (++utf8pos < utf8total) {
                continue;
            }
        } else {
            utf8pos = 1;
            if (c < 0xE0) {
                utf8total = 2;
                ucs4 = c & 0x1F;
            } else if (c < 0xF0) {
                utf8total = 3;
                ucs4 = c & 0x0F;
            } else {
                /* NOTE: can't convert UTF8 sequences longer than 4 */
                utf8total = 4;
                ucs4 = c & 0x03;
            }
            continue;
        }
        /* loop to split ucs4 into two utf16 chars if necessary */
        utf8total = 0;
        do {
            if (ucs4 >= UTF16BASE) {
                ucs4 -= UTF16BASE;
                bitbuf =
                    (bitbuf << 16) | ((ucs4 >> UTF16SHIFT) + UTF16HIGHSTART);
                ucs4 = (ucs4 & UTF16MASK) + UTF16LOSTART;
                utf16flag = 1;
            } else {
                bitbuf = (bitbuf << 16) | ucs4;
                utf16flag = 0;
            }
            bitstogo += 16;
            /* spew out base64 */
            while (bitstogo >= 6) {
                bitstogo -= 6;
                dst +=
                    base64chars[(bitstogo ? (bitbuf >> bitstogo) : bitbuf) & 0x3F];
            }
        } while (utf16flag);
    }
    /* if in UTF-7 mode, finish in ASCII */
    if (utf7mode) {
        if (bitstogo) {
            dst += base64chars[(bitbuf << (6 - bitstogo)) & 0x3F];
        }
        dst += '-';
    }
    return quoteIMAP(dst);
}

//-----------------------------------------------------------------------------
QTextCodec *KIMAP::codecForName(const QString &str)
{
    if (str.isEmpty()) {
        return nullptr;
    }
    return QTextCodec::codecForName(str.toLower().
                                    replace(QStringLiteral("windows"), QStringLiteral("cp")).toLatin1());
}

//-----------------------------------------------------------------------------
const QString KIMAP::decodeRFC2047String(const QString &str)
{
    QString throw_away;

return decodeRFC2047String(str, throw_away);
}

//-----------------------------------------------------------------------------
const QString KIMAP::decodeRFC2047String(const QString &str,
        QString &charset)
{
    QString throw_away;

return decodeRFC2047String(str, charset, throw_away);
}

//-----------------------------------------------------------------------------
const QString KIMAP::decodeRFC2047String(const QString &str,
        QString &charset,
        QString &language)
{
    //do we have a rfc string
    if (!str.contains(QLatin1String("=?"))) {
        return str;
    }

// FIXME get rid of the conversion?
    QByteArray aStr = str.toLatin1();   // QString.length() means Unicode chars
    QByteArray result;
    char *pos, *beg, *end, *mid = nullptr;
    QByteArray cstr;
    char encoding = 0, ch;
    bool valid;
    const int maxLen = 200;
    int i;

//  result.truncate(aStr.length());
    for (pos = aStr.data(); *pos; pos++) {
        if (pos[0] != '=' || pos[1] != '?') {
            result += *pos;
            continue;
        }
        beg = pos + 2;
        end = beg;
        valid = true;
        // parse charset name
        for (i = 2, pos += 2;
                i < maxLen &&
                (*pos != '?' && (ispunct(*pos) || isalnum(*pos)));
                i++) {
            pos++;
        }
        if (*pos != '?' || i < 4 || i >= maxLen) {
            valid = false;
        } else {
            charset = QLatin1String(QByteArray(beg, i - 1));    // -2 + 1 for the zero
            int pt = charset.lastIndexOf(QLatin1Char('*'));
            if (pt != -1) {
                // save language for later usage
                language = charset.right(charset.length() - pt - 1);

// tie off language as defined in rfc2047
                charset.truncate(pt);
            }
            // get encoding and check delimiting question marks
            encoding = toupper(pos[1]);
            if (pos[2] != '?' ||
                    (encoding != 'Q' && encoding != 'B' &&
                     encoding != 'q' && encoding != 'b')) {
                valid = false;
            }
            pos += 3;
            i += 3;
//  qCDebug(KIMAP_LOG) << "Charset:" << charset << "- Language:" << language << "-'" << pos << "'";
        }
        if (valid) {
            mid = pos;
            // search for end of encoded part
            while (i < maxLen && *pos && !(*pos == '?' && *(pos + 1) == '=')) {
                i++;
                pos++;
            }
            end = pos + 2;//end now points to the first char after the encoded string
            if (i >= maxLen || !*pos) {
                valid = false;
            }
        }
        if (valid) {
            ch = *pos;
            *pos = '\0';
            cstr = QByteArray(mid).left(static_cast<int>(mid - pos - 1));
            if (encoding == 'Q') {
                // decode quoted printable text
                for (i = cstr.length() - 1; i >= 0; --i) {
                    if (cstr[i] == '_') {
                        cstr[i] = ' ';
                    }
                }
//    qCDebug(KIMAP_LOG) << "before QP '"
//    << cstr << "'";
                cstr = KCodecs::quotedPrintableDecode(cstr);
//    qCDebug(KIMAP_LOG) << "after QP '"
//    << cstr << "'";
            } else {
                // decode base64 text
                cstr = QByteArray::fromBase64(cstr);
            }
            *pos = ch;
            int len = cstr.length();
            for (i = 0; i < len; ++i) {
                result += cstr[i];
            }

pos = end - 1;
        } else {
//    qCDebug(KIMAP_LOG) << "invalid";
            //result += "=?";
            //pos = beg -1; // because pos gets increased shortly afterwards
            pos = beg - 2;
            result += *pos++;
            result += *pos;
        }
    }
    if (!charset.isEmpty()) {
        QTextCodec *aCodec = codecForName(QLatin1String(charset.toLatin1()));
        if (aCodec) {
//    qCDebug(KIMAP_LOG) << "Codec is" << aCodec->name();
            return aCodec->toUnicode(result);
        }
    }
    return QLatin1String(result);
}

//-----------------------------------------------------------------------------
const QString KIMAP::encodeRFC2047String(const QString &str)
{
    return QLatin1String(encodeRFC2047String(str.toLatin1()));
}

//-----------------------------------------------------------------------------
const QByteArray KIMAP::encodeRFC2047String(const QByteArray &str)
{
    if (str.isEmpty()) {
        return str;
    }

const signed char *latin =
        reinterpret_cast<const signed char *>
        (str.data()), *l, *start, *stop;
    char hexcode;
    int numQuotes, i;
    int rptr = 0;
    // My stats show this number results in 12 resize() out of 73,000
    int resultLen = 3 * str.length() / 2;
    QByteArray result(resultLen, '\0');

while (*latin) {
        l = latin;
        start = latin;
        while (*l) {
            if (*l == 32) {
                start = l + 1;
            }
            if (*l < 0) {
                break;
            }
            l++;
        }
        if (*l) {
            numQuotes = 1;
            while (*l) {
                /* The encoded word must be limited to 75 character */
                for (i = 0; i < 16; ++i) {
                    if (*l == especials[i]) {
                        numQuotes++;
                    }
                }
                if (*l < 0) {
                    numQuotes++;
                }
                /* Stop after 58 = 75 - 17 characters or at "<user@host..." */
                if (l - start + 2 * numQuotes >= 58 || *l == 60) {
                    break;
                }
                l++;
            }
            if (*l) {
                stop = l - 1;
                while (stop >= start && *stop != 32) {
                    stop--;
                }
                if (stop <= start) {
                    stop = l;
                }
            } else {
                stop = l;
            }
            if (resultLen - rptr - 1 <= start -  latin + 1 + 16) {
                // =?iso-88...
                resultLen += (start - latin + 1) * 2 + 20;   // more space
                result.resize(resultLen);
            }
            while (latin < start) {
                result[rptr++] = *latin;
                latin++;
            }
            result.replace(rptr, 15, "=?iso-8859-1?q?");
            rptr += 15;
            if (resultLen - rptr - 1 <= 3 * (stop - latin + 1)) {
                resultLen += (stop - latin + 1) * 4 + 20;   // more space
                result.resize(resultLen);
            }
            while (latin < stop) {
                // can add up to 3 chars/iteration
                numQuotes = 0;
                for (i = 0; i < 16; ++i) {
                    if (*latin == especials[i]) {
                        numQuotes = 1;
                    }
                }
                if (*latin < 0) {
                    numQuotes = 1;
                }
                if (numQuotes) {
                    result[rptr++] = '=';
                    hexcode = ((*latin & 0xF0) >> 4) + 48;
                    if (hexcode >= 58) {
                        hexcode += 7;
                    }
                    result[rptr++] = hexcode;
                    hexcode = (*latin & 0x0F) + 48;
                    if (hexcode >= 58) {
                        hexcode += 7;
                    }
                    result[rptr++] = hexcode;
                } else {
                    result[rptr++] = *latin;
                }
                latin++;
            }
            result[rptr++] = '?';
            result[rptr++] = '=';
        } else {
            while (*latin) {
                if (rptr == resultLen - 1) {
                    resultLen += 30;
                    result.resize(resultLen);
                }
                result[rptr++] = *latin;
                latin++;
            }
        }
    }
    result[rptr] = 0;
    return result;
}

//-----------------------------------------------------------------------------
const QString KIMAP::encodeRFC2231String(const QString &str)
{
    if (str.isEmpty()) {
        return str;
    }

signed char *latin = (signed char *)calloc(1, str.length() + 1);
    char *latin_us = (char *)latin;
    strcpy(latin_us, str.toLatin1().constData());
    signed char *l = latin;
    char hexcode;
    int i;
    while (*l) {
        if (*l < 0) {
            break;
        }
        l++;
    }
    if (!*l) {
        free(latin);
        return str;
    }
    QByteArray result;
    l = latin;
    while (*l) {
        bool quote = *l < 0;
        for (i = 0; i < 16; ++i) {
            if (*l == especials[i]) {
                quote = true;
            }
        }
        if (quote) {
            result += '%';
            hexcode = ((*l & 0xF0) >> 4) + 48;
            if (hexcode >= 58) {
                hexcode += 7;
            }
            result += hexcode;
            hexcode = (*l & 0x0F) + 48;
            if (hexcode >= 58) {
                hexcode += 7;
            }
            result += hexcode;
        } else {
            result += *l;
        }
        l++;
    }
    free(latin);
    return QLatin1String(result);
}

//-----------------------------------------------------------------------------
const QString KIMAP::decodeRFC2231String(const QString &str)
{
    int p = str.indexOf(QLatin1Char('\''));

//see if it is an rfc string
    if (p < 0) {
        return str;
    }

int l = str.lastIndexOf(QLatin1Char('\''));

//second is language
    if (p >= l) {
        return str;
    }

//first is charset or empty
    //QString charset = str.left ( p );
    QString st = str.mid(l + 1);
    //QString language = str.mid ( p + 1, l - p - 1 );

//qCDebug(KIMAP_LOG) << "Charset:" << charset << "Language:" << language;

char ch, ch2;
    p = 0;
    while (p < st.length()) {
        if (st.at(p) == 37) {
            ch = st.at(p + 1).toLatin1() - 48;
            if (ch > 16) {
                ch -= 7;
            }
            ch2 = st.at(p + 2).toLatin1() - 48;
            if (ch2 > 16) {
                ch2 -= 7;
            }
            st.replace(p, 1, ch * 16 + ch2);
            st.remove(p + 1, 2);
        }
        p++;
    }
    return st;
}
07070100000075000081A40000000200000002000000015ED129EC000010D7000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/rfccodecs.h/**********************************************************************
 *
 *   rfccodecs  - handler for various rfc/mime encodings
 *   Copyright (C) 2000 s.carstens@gmx.de
 *
 *   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; see the file COPYING.LIB.  If not, write to
 *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *   Boston, MA 02110-1301, USA.
 *
 *********************************************************************/
/**
 * @file
 * This file is part of the IMAP support library and defines the
 * RfcCodecs class.
 *
 * @brief
 * Provides handlers for various RFC/MIME encodings.
 *
 * @author Sven Carstens
 */

#ifndef KIMAP_RFCCODECS_H
#define KIMAP_RFCCODECS_H

#include <QString>

#include "kimap_export.h"

class QTextCodec;

namespace KIMAP
{

/**
  Converts an Unicode IMAP mailbox to a QByteArray which can be used in
  IMAP communication.
  @param src is the QByteArray containing the IMAP mailbox.
  @since 4.3
*/
Q_REQUIRED_RESULT KIMAP_EXPORT QByteArray encodeImapFolderName(const QByteArray &src);

/**
  Converts an UTF-7 encoded IMAP mailbox to a QByteArray
  @param inSrc is the QByteArray containing the Unicode path.
  @since 4.3
*/
Q_REQUIRED_RESULT KIMAP_EXPORT QByteArray decodeImapFolderName(const QByteArray &inSrc);
/**
  Converts an Unicode IMAP mailbox to a QString which can be used in
  IMAP communication.
  @param src is the QString containing the IMAP mailbox.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT QString encodeImapFolderName(const QString &src);

/**
  Converts an UTF-7 encoded IMAP mailbox to a Unicode QString.
  @param inSrc is the QString containing the Unicode path.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT QString decodeImapFolderName(const QString &inSrc);

/**
  Replaces " with \" and \ with \\ " and \ characters.
  @param src is the QString to quote.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT QString quoteIMAP(const QString &src);

/**
  Replaces " with \" and \ with \\ " and \ characters.
  @param src is the QString to quote.
  @since 4.3
*/
Q_REQUIRED_RESULT KIMAP_EXPORT QByteArray quoteIMAP(const QByteArray &src);

/**
  Fetches a Codec by @p name.
  @param name is the QString version of the Codec name.
  @return Text Codec object
*/
KIMAP_EXPORT QTextCodec *codecForName(const QString &name);

/**
  Decodes a RFC2047 string @p str.
  @param str is the QString to decode.
  @param charset is the character set to use when decoding.
  @param language is the language found in the charset.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QString decodeRFC2047String(const QString &str,
        QString &charset,
        QString &language);
/**
  Decodes a RFC2047 string @p str.
  @param str is the QString to decode.
  @param charset is the character set to use when decoding.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QString decodeRFC2047String(const QString &str,
        QString &charset);

/**
  Decodes a RFC2047 string @p str.
  @param str is the QString to decode.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QString decodeRFC2047String(const QString &str);

/**
  Encodes a RFC2047 string @p str.
  @param str is the QString to encode.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QString encodeRFC2047String(const QString &str);

/**
  Encodes a RFC2047 string @p str.
  @param str is the QString to encode.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QByteArray encodeRFC2047String(const QByteArray &str);

/**
  Encodes a RFC2231 string @p str.
  @param str is the QString to encode.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QString encodeRFC2231String(const QString &str);

/**
  Decodes a RFC2231 string @p str.
  @param str is the QString to decode.
*/
Q_REQUIRED_RESULT KIMAP_EXPORT const QString decodeRFC2231String(const QString &str);
}

#endif
07070100000076000081A40000000200000002000000015ED129EC00003B9E000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/searchjob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "searchjob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include <QDate>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "imapset.h"

namespace KIMAP
{

class Term::Private : public QSharedData
{
public:
    Private(): QSharedData(), isFuzzy(false), isNegated(false), isNull(false) {}
    Private(const Private &other)
        : QSharedData(other)
        , command(other.command)
        , isFuzzy(other.isFuzzy)
        , isNegated(other.isNegated)
        , isNull(other.isNull)
    {}

Private &operator=(const Private &other)
    {
        command = other.command;
        isFuzzy = other.isFuzzy;
        isNegated = other.isNegated;
        isNull = other.isNull;
        return *this;
    }

QByteArray command;
    bool isFuzzy;
    bool isNegated;
    bool isNull;
};

Term::Term()
    :  d(new Term::Private)
{
    d->isNull = true;
}

Term::Term(Term::Relation relation, const QVector<Term> &subterms)
    :  d(new Term::Private)
{
    if (subterms.size() >= 2) {
        if (relation == KIMAP::Term::Or) {
            for (int i = 0; i < subterms.size() - 1; ++i) {
                d->command += "(OR " + subterms[i].serialize() + " ";
            }
            d->command += subterms.back().serialize();
            for (int i = 0; i < subterms.size() - 1; ++i) {
                d->command += ")";
            }
        } else {
            d->command += "(";
            for (const Term &t : subterms) {
                d->command += t.serialize() + ' ';
            }
            if (!subterms.isEmpty()) {
                d->command.chop(1);
            }
            d->command += ")";
        }
    } else if (subterms.size() == 1) {
        d->command += subterms.first().serialize();
    } else {
        d->isNull = true;
    }
}

Term::Term(Term::SearchKey key, const QString &value)
    :  d(new Term::Private)
{
    switch (key) {
    case All:
        d->command += "ALL";
        break;
    case Bcc:
        d->command += "BCC";
        break;
    case Cc:
        d->command += "CC";
        break;
    case Body:
        d->command += "BODY";
        break;
    case From:
        d->command += "FROM";
        break;
    case Keyword:
        d->command += "KEYWORD";
        break;
    case Subject:
        d->command += "SUBJECT";
        break;
    case Text:
        d->command += "TEXT";
        break;
    case To:
        d->command += "TO";
        break;
    }
    if (key != All) {
        d->command += " \"" + QByteArray(value.toUtf8().constData()) + "\"";
    }
}

Term::Term(const QString &header, const QString &value)
    :  d(new Term::Private)
{
    d->command += "HEADER";
    d->command += ' ' + QByteArray(header.toUtf8().constData());
    d->command += " \"" + QByteArray(value.toUtf8().constData()) + "\"";
}

Term::Term(Term::BooleanSearchKey key)
    :  d(new Term::Private)
{
    switch (key) {
    case Answered:
        d->command = "ANSWERED";
        break;
    case Deleted:
        d->command = "DELETED";
        break;
    case Draft:
        d->command = "DRAFT";
        break;
    case Flagged:
        d->command = "FLAGGED";
        break;
    case New:
        d->command = "NEW";
        break;
    case Old:
        d->command = "OLD";
        break;
    case Recent:
        d->command = "RECENT";
        break;
    case Seen:
        d->command = "SEEN";
        break;
    }
}

static QByteArray monthName(int month)
{
    static const char* names[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
    return (month >= 1 && month <= 12) ? QByteArray(names[month - 1]) : QByteArray();
}

Term::Term(Term::DateSearchKey key, const QDate &date)
    :  d(new Term::Private)
{
    switch (key) {
    case Before:
        d->command = "BEFORE";
        break;
    case On:
        d->command = "ON";
        break;
    case SentBefore:
        d->command = "SENTBEFORE";
        break;
    case SentOn:
        d->command = "SENTON";
        break;
    case SentSince:
        d->command = "SENTSINCE";
        break;
    case Since:
        d->command = "SINCE";
        break;
    }
    d->command += " \"";
    d->command += QByteArray::number(date.day()) + '-';
    d->command += monthName(date.month()) + '-';
    d->command += QByteArray::number(date.year());
    d->command += '\"';
}

Term::Term(Term::NumberSearchKey key, int value)
    :  d(new Term::Private)
{
    switch (key) {
    case Larger:
        d->command = "LARGER";
        break;
    case Smaller:
        d->command = "SMALLER";
        break;
    }
    d->command += " " + QByteArray::number(value);
}

Term::Term(Term::SequenceSearchKey key, const ImapSet &set)
    :  d(new Term::Private)
{
    switch (key) {
    case Uid:
        d->command = "UID";
        break;
    case SequenceNumber:
        break;
    }
    auto optimizedSet = set;
    optimizedSet.optimize();
    d->command += " " + optimizedSet.toImapSequenceSet();
}

Term::Term(const Term &other)
    :  d(new Term::Private)
{
    *d = *other.d;
}

Term::~Term()
{
}

Term &Term::operator=(const Term &other)
{
    *d = *other.d;
    return *this;
}

bool Term::operator==(const Term &other) const
{
    return d->command == other.d->command &&
           d->isNegated == other.d->isNegated &&
           d->isFuzzy == other.d->isFuzzy;
}

QByteArray Term::serialize() const
{
    QByteArray command;
    if (d->isFuzzy) {
        command = "FUZZY ";
    }
    if (d->isNegated) {
        command = "NOT ";
    }
    return command + d->command;
}

Term &Term::setFuzzy(bool fuzzy)
{
    d->isFuzzy = fuzzy;
    return *this;
}

Term &Term::setNegated(bool negated)
{
    d->isNegated = negated;
    return *this;
}

bool Term::isNull() const
{
    return d->isNull;
}

//TODO: when custom error codes are introduced, handle the NO [TRYCREATE] response

class SearchJobPrivate : public JobPrivate
{
public:
    SearchJobPrivate(Session *session, const QString &name) : JobPrivate(session, name), logic(SearchJob::And)
    {
        criteriaMap[SearchJob::All]  = "ALL";
        criteriaMap[SearchJob::Answered] = "ANSWERED";
        criteriaMap[SearchJob::BCC] = "BCC";
        criteriaMap[SearchJob::Before] = "BEFORE";
        criteriaMap[SearchJob::Body] = "BODY";
        criteriaMap[SearchJob::CC] = "CC";
        criteriaMap[SearchJob::Deleted] = "DELETED";
        criteriaMap[SearchJob::Draft] = "DRAFT";
        criteriaMap[SearchJob::Flagged] = "FLAGGED";
        criteriaMap[SearchJob::From] = "FROM";
        criteriaMap[SearchJob::Header] = "HEADER";
        criteriaMap[SearchJob::Keyword] = "KEYWORD";
        criteriaMap[SearchJob::Larger] = "LARGER";
        criteriaMap[SearchJob::New] = "NEW";
        criteriaMap[SearchJob::Old] = "OLD";
        criteriaMap[SearchJob::On] = "ON";
        criteriaMap[SearchJob::Recent] = "RECENT";
        criteriaMap[SearchJob::Seen] = "SEEN";
        criteriaMap[SearchJob::SentBefore] = "SENTBEFORE";
        criteriaMap[SearchJob::SentOn] = "SENTON";
        criteriaMap[SearchJob::SentSince] = "SENTSINCE";
        criteriaMap[SearchJob::Since] = "SINCE";
        criteriaMap[SearchJob::Smaller] = "SMALLER";
        criteriaMap[SearchJob::Subject] = "SUBJECT";
        criteriaMap[SearchJob::Text] = "TEXT";
        criteriaMap[SearchJob::To] = "TO";
        criteriaMap[SearchJob::Uid] = "UID";
        criteriaMap[SearchJob::Unanswered] = "UNANSWERED";
        criteriaMap[SearchJob::Undeleted] = "UNDELETED";
        criteriaMap[SearchJob::Undraft] = "UNDRAFT";
        criteriaMap[SearchJob::Unflagged] = "UNFLAGGED";
        criteriaMap[SearchJob::Unkeyword] = "UNKEYWORD";
        criteriaMap[SearchJob::Unseen] = "UNSEEN";

//don't use QDate::shortMonthName(), it returns a localized month name
        months[1] = "Jan";
        months[2] = "Feb";
        months[3] = "Mar";
        months[4] = "Apr";
        months[5] = "May";
        months[6] = "Jun";
        months[7] = "Jul";
        months[8] = "Aug";
        months[9] = "Sep";
        months[10] = "Oct";
        months[11] = "Nov";
        months[12] = "Dec";

nextContent = 0;
        uidBased = false;
    }
    ~SearchJobPrivate() { }

QByteArray charset;
    QList<QByteArray> criterias;
    QMap<SearchJob::SearchCriteria, QByteArray > criteriaMap;
    QMap<int, QByteArray> months;
    SearchJob::SearchLogic logic;
    QList<QByteArray> contents;
    QVector<qint64> results;
    uint nextContent;
    bool uidBased;
    Term term;
};
}

using namespace KIMAP;

SearchJob::SearchJob(Session *session)
    : Job(*new SearchJobPrivate(session, i18nc("Name of the search job", "Search")))
{
}

SearchJob::~SearchJob()
{
}

void SearchJob::setTerm(const Term &term)
{
    Q_D(SearchJob);
    d->term = term;
}

void SearchJob::doStart()
{
    Q_D(SearchJob);

QByteArray searchKey;

if (!d->charset.isEmpty()) {
        searchKey = "CHARSET " + d->charset;
    }

if (!d->term.isNull()) {
        const QByteArray term = d->term.serialize();
        if (term.startsWith('(')) {
            searchKey += term.mid(1, term.size() - 2);
        } else {
            searchKey += term;
        }
    } else {

if (d->logic == SearchJob::Not) {
            searchKey += "NOT ";
        } else if (d->logic == SearchJob::Or && d->criterias.size() > 1) {
            searchKey += "OR ";
        }

if (d->logic == SearchJob::And) {
            const int numberCriterias(d->criterias.size());
            for (int i = 0; i < numberCriterias; i++) {
                const QByteArray key = d->criterias.at(i);
                if (i > 0) {
                    searchKey += ' ';
                }
                searchKey += key;
            }
        } else {
            const int numberCriterias(d->criterias.size());
            for (int i = 0; i < numberCriterias; i++) {
                const QByteArray key = d->criterias.at(i);
                if (i > 0) {
                    searchKey += ' ';
                }
                searchKey += '(' + key + ')';
            }
        }
    }

QByteArray command = "SEARCH";
    if (d->uidBased) {
        command = "UID " + command;
    }

d->tags << d->sessionInternal()->sendCommand(command, searchKey);
}

void SearchJob::handleResponse(const Response &response)
{
    Q_D(SearchJob);

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 1 && response.content[0].toString() == "+") {
            if (d->term.isNull()) {
                d->sessionInternal()->sendData(d->contents[d->nextContent]);
            } else {
                qCWarning(KIMAP_LOG) << "The term API only supports inline strings.";
            }
            d->nextContent++;
        } else if (response.content.size() >= 2 && response.content[1].toString() == "SEARCH") {
            for (int i = 2; i < response.content.size(); i++) {
                d->results.append(response.content[i].toString().toInt());
            }
        }
    }
}

void SearchJob::setCharset(const QByteArray &charset)
{
    Q_D(SearchJob);
    d->charset = charset;
}

QByteArray SearchJob::charset() const
{
    Q_D(const SearchJob);
    return d->charset;
}

void SearchJob::setSearchLogic(SearchLogic logic)
{
    Q_D(SearchJob);
    d->logic = logic;
}

void SearchJob::addSearchCriteria(SearchCriteria criteria)
{
    Q_D(SearchJob);

switch (criteria) {
    case All:
    case Answered:
    case Deleted:
    case Draft:
    case Flagged:
    case New:
    case Old:
    case Recent:
    case Seen:
    case Unanswered:
    case Undeleted:
    case Undraft:
    case Unflagged:
    case Unseen:
        d->criterias.append(d->criteriaMap[criteria]);
        break;
    default:
        //TODO Discuss if we keep error checking here, or accept anything, even if it is wrong
        qCDebug(KIMAP_LOG) << "Criteria " << d->criteriaMap[criteria] << " needs an argument, but none was specified.";
        break;
    }
}

void SearchJob::addSearchCriteria(SearchCriteria criteria, int argument)
{
    Q_D(SearchJob);
    switch (criteria) {
    case Larger:
    case Smaller:
        d->criterias.append(d->criteriaMap[criteria] + ' ' + QByteArray::number(argument));
        break;
    default:
        //TODO Discuss if we keep error checking here, or accept anything, even if it is wrong
        qCDebug(KIMAP_LOG) << "Criteria " << d->criteriaMap[criteria] << " doesn't accept an integer as an argument.";
        break;
    }
}

void SearchJob::addSearchCriteria(SearchCriteria criteria, const QByteArray &argument)
{
    Q_D(SearchJob);
    switch (criteria) {
    case BCC:
    case Body:
    case CC:
    case From:
    case Subject:
    case Text:
    case To:
        d->contents.append(argument);
        d->criterias.append(d->criteriaMap[criteria] + " {" + QByteArray::number(argument.size()) + '}');
        break;
    case Keyword:
    case Unkeyword:
    case Header:
    case Uid:
        d->criterias.append(d->criteriaMap[criteria] + ' ' + argument);
        break;
    default:
        //TODO Discuss if we keep error checking here, or accept anything, even if it is wrong
        qCDebug(KIMAP_LOG) << "Criteria " << d->criteriaMap[criteria] << " doesn't accept any argument.";
        break;
    }
}

void SearchJob::addSearchCriteria(SearchCriteria criteria, const QDate &argument)
{
    Q_D(SearchJob);
    switch (criteria) {
    case Before:
    case On:
    case SentBefore:
    case SentSince:
    case Since: {
        QByteArray date = QByteArray::number(argument.day()) + '-';
        date += d->months[argument.month()] + '-';
        date += QByteArray::number(argument.year());
        d->criterias.append(d->criteriaMap[criteria] + " \"" + date + '\"');
        break;
    }
    default:
        //TODO Discuss if we keep error checking here, or accept anything, even if it is wrong
        qCDebug(KIMAP_LOG) << "Criteria " << d->criteriaMap[criteria] << " doesn't accept a date as argument.";
        break;
    }
}

void SearchJob::addSearchCriteria(const QByteArray &searchCriteria)
{
    Q_D(SearchJob);
    d->criterias.append(searchCriteria);
}

void SearchJob::setUidBased(bool uidBased)
{
    Q_D(SearchJob);
    d->uidBased = uidBased;
}

bool SearchJob::isUidBased() const
{
    Q_D(const SearchJob);
    return d->uidBased;
}

QVector<qint64> SearchJob::results() const
{
    Q_D(const SearchJob);
    return d->results;
}
07070100000077000081A40000000200000002000000015ED129EC000017C5000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/searchjob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>
    Copyright (c) 2014 Christian Mollekopf <mollekopf@kolabsys.com>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SEARCHJOB_H
#define KIMAP_SEARCHJOB_H

#include "kimap_export.h"

#include "job.h"

#include <QSharedDataPointer>

class QDate;

namespace KIMAP
{

class ImapSet;

class Session;
struct Response;
class SearchJobPrivate;

/**
 * A query term.
 * Refer to the IMAP RFC for the meaning of the individual terms.
 * @since 4.13
 */
class KIMAP_EXPORT Term
{
public:
    enum Relation {
        And,
        Or
    };

enum SearchKey {
        All,
        Bcc,
        Body,
        Cc,
        From,
        Subject,
        Text,
        To,
        Keyword
    };

enum BooleanSearchKey {
        New,
        Old,
        Recent,
        Seen,
        Draft,
        Deleted,
        Flagged,
        Answered
    };

enum DateSearchKey {
        Before,
        On,
        Since,
        SentBefore,
        SentOn,
        SentSince
    };
    enum NumberSearchKey {
        Larger,
        Smaller
    };
    enum SequenceSearchKey {
        Uid,
        SequenceNumber
    };

Term();
    ~Term();
    Term(Relation relation, const QVector<Term> &subterms);
    Term(SearchKey key, const QString &value);
    Term(BooleanSearchKey key);
    Term(DateSearchKey key, const QDate &date);
    Term(NumberSearchKey key, int value);
    Term(SequenceSearchKey key, const KIMAP::ImapSet &);
    Term(const QString &header, const QString &value);

Term(const Term &other);

Term &operator=(const Term &other);
    bool operator==(const Term &other) const;

Q_REQUIRED_RESULT bool isNull() const;

Term &setFuzzy(bool fuzzy);
    Term &setNegated(bool negated);

Q_REQUIRED_RESULT QByteArray serialize() const;

private:
    class Private;
    QSharedDataPointer<Private> d;
};

class KIMAP_EXPORT SearchJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(SearchJob)

friend class SessionPrivate;

public:
    enum SearchLogic {
        And = 0,
        Or,
        Not
    };

enum SearchCriteria {
        All = 0,
        Answered,
        BCC,
        Before,
        Body,
        CC,
        Deleted,
        Draft,
        Flagged,
        From,
        Header,
        Keyword,
        Larger,
        New,
        Old,
        On,
        Recent,
        Seen,
        SentBefore,
        SentOn,
        SentSince,
        Since,
        Smaller,
        Subject,
        Text,
        To,
        Uid,
        Unanswered,
        Undeleted,
        Undraft,
        Unflagged,
        Unkeyword,
        Unseen
    };

explicit SearchJob(Session *session);
    ~SearchJob() override;

void setUidBased(bool uidBased);
    bool isUidBased() const;

void setCharset(const QByteArray &charSet);
    QByteArray charset() const;

/**
     * Get the search result, as a list of sequence numbers or UIDs, based on the isUidBased status
     * @return the found items
     * @since 4.6
     */
    QVector<qint64> results() const;

/**
     * Add a search criteria that doesn't have an argument. Passing a criteria that
     * should have an argument will be ignored.
     * @param criteria a criteria from SearchCriterias
     * @deprecated since 4.13
     */
    KIMAP_DEPRECATED void addSearchCriteria(SearchCriteria criteria);

/**
     * Add a search criteria that has one or more space separate string arguments.
     * Passing a criteria that accepts a different type or argument or no
     * argument will be ignored.
     * @param criteria a criteria from SearchCriterias
     * @param argument the arguments
     * @deprecated since 4.13
     */
    KIMAP_DEPRECATED void addSearchCriteria(SearchCriteria criteria, const QByteArray &argument);

/**
     * Add a search criteria that has an integer argument.
     * Passing a criteria that accepts a different type or argument or no
     * argument will be ignored.
     * @param criteria a criteria from SearchCriterias
     * @param argument a number argument
     * @deprecated since 4.13
     */
    KIMAP_DEPRECATED void addSearchCriteria(SearchCriteria criteria, int argument);

/**
     * Add a search criteria that has a date as argument.
     * Passing a criteria that accepts a different type or argument or no
     * argument will be ignored.
     * @param criteria a criteria from SearchCriterias
     * @param argument a date
     * @deprecated since 4.13
     */
    KIMAP_DEPRECATED void addSearchCriteria(SearchCriteria criteria, const QDate &argument);

/**
     * Add a custom criteria. No checks are done, the data is sent as it is
     * to the server.
     * @param searchCriteria free form search criteria.
     * @deprecated since 4.13
     */
    KIMAP_DEPRECATED void addSearchCriteria(const QByteArray &searchCriteria);

/**
     * Set the logic combining the search criterias.
     * @param logic AND (the default), OR, NOT. See SearchLogics.
     * @deprecated since 4.13
     */
    KIMAP_DEPRECATED void setSearchLogic(SearchLogic logic);

/**
     * Sets the search term.
     * @param term The search term.
     * @since 4.13
     */
    void setTerm(const Term &);

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
07070100000078000081A40000000200000002000000015ED129EC00001853000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/selectjob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "selectjob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class SelectJobPrivate : public JobPrivate
{
public:
    SelectJobPrivate(Session *session, const QString &name)
        : JobPrivate(session, name), readOnly(false), messageCount(-1), recentCount(-1),
          firstUnseenIndex(-1), uidValidity(-1), nextUid(-1), highestmodseq(0),
          condstoreEnabled(false) { }
    ~SelectJobPrivate() { }

QString mailBox;
    bool readOnly;

QList<QByteArray> flags;
    QList<QByteArray> permanentFlags;
    int messageCount;
    int recentCount;
    int firstUnseenIndex;
    qint64 uidValidity;
    qint64 nextUid;
    quint64 highestmodseq;
    bool condstoreEnabled;
};
}

using namespace KIMAP;

SelectJob::SelectJob(Session *session)
    : Job(*new SelectJobPrivate(session, i18nc("name of the select job", "Select")))
{
}

SelectJob::~SelectJob()
{
}

void SelectJob::setMailBox(const QString &mailBox)
{
    Q_D(SelectJob);
    d->mailBox = mailBox;
}

QString SelectJob::mailBox() const
{
    Q_D(const SelectJob);
    return d->mailBox;
}

void SelectJob::setOpenReadOnly(bool readOnly)
{
    Q_D(SelectJob);
    d->readOnly = readOnly;
}

bool SelectJob::isOpenReadOnly() const
{
    Q_D(const SelectJob);
    return d->readOnly;
}

QList<QByteArray> SelectJob::flags() const
{
    Q_D(const SelectJob);
    return d->flags;
}

QList<QByteArray> SelectJob::permanentFlags() const
{
    Q_D(const SelectJob);
    return d->permanentFlags;
}

int SelectJob::messageCount() const
{
    Q_D(const SelectJob);
    return d->messageCount;
}

int SelectJob::recentCount() const
{
    Q_D(const SelectJob);
    return d->recentCount;
}

int SelectJob::firstUnseenIndex() const
{
    Q_D(const SelectJob);
    return d->firstUnseenIndex;
}

qint64 SelectJob::uidValidity() const
{
    Q_D(const SelectJob);
    return d->uidValidity;
}

qint64 SelectJob::nextUid() const
{
    Q_D(const SelectJob);
    return d->nextUid;
}

quint64 SelectJob::highestModSequence() const
{
    Q_D(const SelectJob);
    return d->highestmodseq;
}

void SelectJob::setCondstoreEnabled(bool enable)
{
    Q_D(SelectJob);
    d->condstoreEnabled = enable;
}

bool SelectJob::condstoreEnabled() const
{
    Q_D(const SelectJob);
    return d->condstoreEnabled;
}

void SelectJob::doStart()
{
    Q_D(SelectJob);

QByteArray command = "SELECT";
    if (d->readOnly) {
        command = "EXAMINE";
    }

QByteArray params = '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"';

if (d->condstoreEnabled) {
        params += " (CONDSTORE)";
    }

d->tags << d->sessionInternal()->sendCommand(command, params);
}

void SelectJob::handleResponse(const Response &response)
{
    Q_D(SelectJob);

// Check for [READ-ONLY] response in final tagged OK
    // This must be checked before handleErrorReplies(), because that calls emitResult()
    // right away
    if (!response.content.isEmpty() && d->tags.contains(response.content.first().toString())) {
        if (response.responseCode.size() >= 1 && response.responseCode[0].toString() == "READ-ONLY") {
            d->readOnly = true;
        }
    }

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 2) {
            QByteArray code = response.content[1].toString();

if (code == "OK") {
                if (response.responseCode.size() < 2) {
                    return;
                }

code = response.responseCode[0].toString();
                if (code == "PERMANENTFLAGS") {
                    d->permanentFlags = response.responseCode[1].toList();
                } else if (code == "HIGHESTMODSEQ") {
                    bool isInt;
                    quint64 value = response.responseCode[1].toString().toULongLong(&isInt);
                    if (!isInt) {
                        return;
                    }
                    d->highestmodseq = value;
                } else {
                    bool isInt;
                    qint64 value = response.responseCode[1].toString().toLongLong(&isInt);
                    if (!isInt) {
                        return;
                    }
                    if (code == "UIDVALIDITY") {
                        d->uidValidity = value;
                    } else if (code == "UNSEEN") {
                        d->firstUnseenIndex = value;
                    } else if (code == "UIDNEXT") {
                        d->nextUid = value;
                    }
                }
            } else if (code == "FLAGS") {
                d->flags = response.content[2].toList();
            } else {
                bool isInt;
                int value = response.content[1].toString().toInt(&isInt);
                if (!isInt || response.content.size() < 3) {
                    return;
                }

code = response.content[2].toString();
                if (code == "EXISTS") {
                    d->messageCount = value;
                } else if (code == "RECENT") {
                    d->recentCount = value;
                }
            }
        } else {
            qCDebug(KIMAP_LOG) << response.toString();
        }
    } else {
        Q_ASSERT(error() || d->m_session->selectedMailBox() == d->mailBox);
    }
}
07070100000079000081A40000000200000002000000015ED129EC00000B67000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/selectjob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SELECTJOB_H
#define KIMAP_SELECTJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
struct Response;
class SelectJobPrivate;

class KIMAP_EXPORT SelectJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(SelectJob)

friend class SessionPrivate;

public:
    explicit SelectJob(Session *session);
    ~SelectJob() override;

void setMailBox(const QString &mailBox);
    Q_REQUIRED_RESULT QString mailBox() const;

void setOpenReadOnly(bool readOnly);
    /**
     * @return Returns whether the mailbox is opened in read-only mode. Note
     * that this can return true even if setOpenReadOnly() was set to false,
     * as the mailbox may be read-only on the server.
     */
    Q_REQUIRED_RESULT bool isOpenReadOnly() const;

Q_REQUIRED_RESULT QList<QByteArray> flags() const;
    Q_REQUIRED_RESULT QList<QByteArray> permanentFlags() const;

Q_REQUIRED_RESULT int messageCount() const;
    Q_REQUIRED_RESULT int recentCount() const;
    Q_REQUIRED_RESULT int firstUnseenIndex() const;

Q_REQUIRED_RESULT qint64 uidValidity() const;
    Q_REQUIRED_RESULT qint64 nextUid() const;

/**
     * @return Highest mod-sequence value of all messages in the mailbox or 0
     * if the server does not have CONDSTORE capability (RFC4551) or does not
     * support persistent storage of mod-sequences.
     *
     * @since 4.12
     */
    Q_REQUIRED_RESULT quint64 highestModSequence() const;

/**
     * Whether to append CONDSTORE parameter to the SELECT command.
     *
     * This option is false by default and can be enabled only when server
     * has CONDSTORE capability (RFC4551), otherwise the SELECT command will
     * fail.
     *
     * @since 4.12
     */
    void setCondstoreEnabled(bool enable);

/**
     * Returns whether the CONDSTORE parameter will be appended to SELECT command
     *
     * @since 4.12
     */
    Q_REQUIRED_RESULT bool condstoreEnabled() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
0707010000007A000081A40000000200000002000000015ED129EC000034B1000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/session.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "session.h"
#include "session_p.h"
#include "sessionuiproxy.h"

#include <QTimer>
#include <QPointer>

#include "kimap_debug.h"

#include "job.h"
#include "job_p.h"
#include "loginjob.h"
#include "response_p.h"
#include "sessionlogger_p.h"
#include "sessionthread_p.h"
#include "rfccodecs.h"

Q_DECLARE_METATYPE(QSsl::SslProtocol)
Q_DECLARE_METATYPE(QSslSocket::SslMode)
static const int _kimap_sslVersionId = qRegisterMetaType<QSsl::SslProtocol>();

using namespace KIMAP;

Session::Session(const QString &hostName, quint16 port, QObject *parent)
    : QObject(parent), d(new SessionPrivate(this))
{
    if (!qEnvironmentVariableIsEmpty("KIMAP_LOGFILE")) {
        d->logger = new SessionLogger;
    }

d->isSocketConnected = false;
    d->state = Disconnected;
    d->jobRunning = false;

d->thread = new SessionThread(hostName, port);
    connect(d->thread, &SessionThread::encryptionNegotiationResult, d, &SessionPrivate::onEncryptionNegotiationResult);
    connect(d->thread, &SessionThread::sslError, d, &SessionPrivate::handleSslError);
    connect(d->thread, &SessionThread::socketDisconnected, d, &SessionPrivate::socketDisconnected);
    connect(d->thread, &SessionThread::responseReceived, d, &SessionPrivate::responseReceived);
    connect(d->thread, &SessionThread::socketConnected, d, &SessionPrivate::socketConnected);
    connect(d->thread, &SessionThread::socketActivity, d, &SessionPrivate::socketActivity);
    connect(d->thread, &SessionThread::socketError, d, &SessionPrivate::socketError);

d->socketTimer.setSingleShot(true);
    connect(&d->socketTimer, &QTimer::timeout,
            d, &SessionPrivate::onSocketTimeout);

d->startSocketTimer();
}

Session::~Session()
{
    //Make sure all jobs know we're done
    d->socketDisconnected();
    delete d->thread;
    d->thread = nullptr;
}

void Session::setUiProxy(const SessionUiProxy::Ptr &proxy)
{
    d->uiProxy = proxy;
}

void Session::setUiProxy(SessionUiProxy *proxy)
{
    setUiProxy(SessionUiProxy::Ptr(proxy));
}

QString Session::hostName() const
{
    return d->thread->hostName();
}

quint16 Session::port() const
{
    return d->thread->port();
}

void Session::setUseNetworkProxy(bool useProxy)
{
    d->thread->setUseNetworkProxy(useProxy);
}

Session::State Session::state() const
{
    return d->state;
}

QString Session::userName() const
{
    return d->userName;
}

QByteArray Session::serverGreeting() const
{
    return d->greeting;
}

int Session::jobQueueSize() const
{
    return d->queue.size() + (d->jobRunning ? 1 : 0);
}

void KIMAP::Session::close()
{
    d->thread->closeSocket();
}

void SessionPrivate::handleSslError(const KSslErrorUiData &errorData)
{
    //ignoreSslError is async, so the thread might already be gone when it returns
    QPointer<SessionThread> _t = thread;
    const bool ignoreSslError = uiProxy && uiProxy->ignoreSslError(errorData);
    if (_t) {
        _t->sslErrorHandlerResponse(ignoreSslError);
    }
}

SessionPrivate::SessionPrivate(Session *session)
    : QObject(session),
      q(session),
      isSocketConnected(false),
      state(Session::Disconnected),
      logger(nullptr),
      thread(nullptr),
      jobRunning(false),
      currentJob(nullptr),
      tagCount(0),
      sslVersion(QSsl::UnknownProtocol),
      socketTimerInterval(30000)   // By default timeouts on 30s
{
}

SessionPrivate::~SessionPrivate()
{
    delete logger;
}

void SessionPrivate::addJob(Job *job)
{
    queue.append(job);
    Q_EMIT q->jobQueueSizeChanged(q->jobQueueSize());

QObject::connect(job, &KJob::result, this, &SessionPrivate::jobDone);
    QObject::connect(job, &QObject::destroyed, this, &SessionPrivate::jobDestroyed);

if (state != Session::Disconnected) {
        startNext();
    }
}

void SessionPrivate::startNext()
{
    QMetaObject::invokeMethod(this, &SessionPrivate::doStartNext);
}

void SessionPrivate::doStartNext()
{
    if (queue.isEmpty() || jobRunning || !isSocketConnected) {
        return;
    }

restartSocketTimer();
    jobRunning = true;

currentJob = queue.dequeue();
    currentJob->doStart();
}

void SessionPrivate::jobDone(KJob *job)
{
    Q_UNUSED(job);
    Q_ASSERT(job == currentJob);

stopSocketTimer();

jobRunning = false;
    currentJob = nullptr;
    Q_EMIT q->jobQueueSizeChanged(q->jobQueueSize());
    startNext();
}

void SessionPrivate::jobDestroyed(QObject *job)
{
    queue.removeAll(static_cast<KIMAP::Job *>(job));
    if (currentJob == job) {
        currentJob = nullptr;
    }
}

void SessionPrivate::responseReceived(const Response &response)
{
    if (logger && isConnected()) {
        logger->dataReceived(response.toString());
    }

QByteArray tag;
    QByteArray code;

if (response.content.size() >= 1) {
        tag = response.content[0].toString();
    }

if (response.content.size() >= 2) {
        code = response.content[1].toString();
    }

// BYE may arrive as part of a LOGOUT sequence or before the server closes the connection after an error.
    // In any case we should wait until the server closes the connection, so we don't have to do anything.
    if (code == "BYE") {
        Response simplified = response;
        if (simplified.content.size() >= 2) {
            simplified.content.removeFirst(); // Strip the tag
            simplified.content.removeFirst(); // Strip the code
        }
        qCDebug(KIMAP_LOG) << "Received BYE: " << simplified.toString();
        return;
    }

switch (state) {
    case Session::Disconnected:
        if (socketTimer.isActive()) {
            stopSocketTimer();
        }
        if (code == "OK") {
            setState(Session::NotAuthenticated);

Response simplified = response;
            simplified.content.removeFirst(); // Strip the tag
            simplified.content.removeFirst(); // Strip the code
            greeting = simplified.toString().trimmed(); // Save the server greeting
            startNext();
        } else if (code == "PREAUTH") {
            setState(Session::Authenticated);

startNext();
        } else {
            thread->closeSocket();
        }
        return;
    case Session::NotAuthenticated:
        if (code == "OK" && tag == authTag) {
            setState(Session::Authenticated);
        }
        break;
    case Session::Authenticated:
        if (code == "OK" && tag == selectTag) {
            setState(Session::Selected);
            currentMailBox = upcomingMailBox;
        }
        break;
    case Session::Selected:
        if ((code == "OK" && tag == closeTag) ||
                (code != "OK" && tag == selectTag)) {
            setState(Session::Authenticated);
            currentMailBox = QByteArray();
        } else if (code == "OK" && tag == selectTag) {
            currentMailBox = upcomingMailBox;
        }
        break;
    }

if (tag == authTag) {
        authTag.clear();
    }
    if (tag == selectTag) {
        selectTag.clear();
    }
    if (tag == closeTag) {
        closeTag.clear();
    }

// If a job is running forward it the response
    if (currentJob != nullptr) {
        restartSocketTimer();
        currentJob->handleResponse(response);
    } else {
        qCWarning(KIMAP_LOG) << "A message was received from the server with no job to handle it:"
                             << response.toString()
                             << '(' + response.toString().toHex() + ')';
    }
}

void SessionPrivate::setState(Session::State s)
{
    if (s != state) {
        Session::State oldState = state;
        state = s;
        Q_EMIT q->stateChanged(state, oldState);
    }
}

QByteArray SessionPrivate::sendCommand(const QByteArray &command, const QByteArray &args)
{
    QByteArray tag = 'A' + QByteArray::number(++tagCount).rightJustified(6, '0');

QByteArray payload = tag + ' ' + command;
    if (!args.isEmpty()) {
        payload += ' ' + args;
    }

sendData(payload);

if (command == "LOGIN" || command == "AUTHENTICATE") {
        authTag = tag;
    } else if (command == "SELECT" || command == "EXAMINE") {
        selectTag = tag;
        upcomingMailBox = args;
        upcomingMailBox.remove(0, 1);
        upcomingMailBox = upcomingMailBox.left(upcomingMailBox.indexOf('\"'));
        upcomingMailBox = KIMAP::decodeImapFolderName(upcomingMailBox);
    } else if (command == "CLOSE") {
        closeTag = tag;
    }
    return tag;
}

void SessionPrivate::sendData(const QByteArray &data)
{
    restartSocketTimer();

if (logger && isConnected()) {
        logger->dataSent(data);
    }

thread->sendData(data + "\r\n");
}

void SessionPrivate::socketConnected()
{
    stopSocketTimer();
    isSocketConnected = true;

bool willUseSsl = false;
    if (!queue.isEmpty()) {
        KIMAP::LoginJob *login = qobject_cast<KIMAP::LoginJob *>(queue.first());
        if (login) {
            willUseSsl = (login->encryptionMode() == KIMAP::LoginJob::SSLorTLS);

userName = login->userName();
        }
    }

if (state == Session::Disconnected && willUseSsl) {
        startNext();
    } else {
        startSocketTimer();
    }
}

bool SessionPrivate::isConnected() const
{
    return state == Session::Authenticated || state == Session::Selected;
}

void SessionPrivate::socketDisconnected()
{
    if (socketTimer.isActive()) {
        stopSocketTimer();
    }

if (logger && isConnected()) {
        logger->disconnectionOccured();
    }

if (isSocketConnected) {
        setState(Session::Disconnected);
        Q_EMIT q->connectionLost();
    } else {
        Q_EMIT q->connectionFailed();
    }

isSocketConnected = false;

clearJobQueue();
}

void SessionPrivate::socketActivity()
{
    restartSocketTimer();
}

void SessionPrivate::socketError(QAbstractSocket::SocketError error)
{
    if (socketTimer.isActive()) {
        stopSocketTimer();
    }

if (currentJob) {
        currentJob->d_ptr->setSocketError(error);
    } else if (!queue.isEmpty()) {
        currentJob = queue.takeFirst();
        currentJob->d_ptr->setSocketError(error);
    }

if (isSocketConnected) {
        thread->closeSocket();
    } else {
        Q_EMIT q->connectionFailed();
        clearJobQueue();
    }
}

void SessionPrivate::clearJobQueue()
{
    if (currentJob) {
        currentJob->connectionLost();
    } else if (!queue.isEmpty()) {
        currentJob = queue.takeFirst();
        currentJob->connectionLost();
    }

QQueue<Job *> queueCopy = queue; // copy because jobDestroyed calls removeAll
    qDeleteAll(queueCopy);
    queue.clear();
    Q_EMIT q->jobQueueSizeChanged(0);
}

void SessionPrivate::startSsl(QSsl::SslProtocol protocol)
{
    thread->startSsl(protocol);
}

QString Session::selectedMailBox() const
{
    return QString::fromUtf8(d->currentMailBox);
}

void SessionPrivate::onEncryptionNegotiationResult(bool isEncrypted, QSsl::SslProtocol protocol)
{
    if (isEncrypted) {
        sslVersion = protocol;
    } else {
        sslVersion = QSsl::UnknownProtocol;
    }
    Q_EMIT encryptionNegotiationResult(isEncrypted);
}

QSsl::SslProtocol SessionPrivate::negotiatedEncryption() const
{
    return sslVersion;
}

void SessionPrivate::setSocketTimeout(int ms)
{
    bool timerActive = socketTimer.isActive();

if (timerActive) {
        stopSocketTimer();
    }

socketTimerInterval = ms;

if (timerActive) {
        startSocketTimer();
    }
}

int SessionPrivate::socketTimeout() const
{
    return socketTimerInterval;
}

void SessionPrivate::startSocketTimer()
{
    if (socketTimerInterval < 0) {
        return;
    }
    Q_ASSERT(!socketTimer.isActive());

socketTimer.start(socketTimerInterval);
}

void SessionPrivate::stopSocketTimer()
{
    if (socketTimerInterval < 0) {
        return;
    }

socketTimer.stop();
}

void SessionPrivate::restartSocketTimer()
{
    if (socketTimer.isActive()) {
        stopSocketTimer();
    }
    startSocketTimer();
}

void SessionPrivate::onSocketTimeout()
{
    qCDebug(KIMAP_LOG) << "Socket timeout!";
    thread->closeSocket();
}

void Session::setTimeout(int timeout)
{
    d->setSocketTimeout(timeout * 1000);
}

int Session::timeout() const
{
    return d->socketTimeout() / 1000;
}

#include "moc_session.cpp"
#include "moc_session_p.cpp"
0707010000007B000081A40000000200000002000000015ED129EC00001185000000000000000000000000000000000000003700000000kimap-VERSIONgit.20200529T172740~a5402d2/src/session.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SESSION_H
#define KIMAP_SESSION_H

#include "kimap_export.h"

#include <QObject>

#include "sessionuiproxy.h"

namespace KIMAP
{

class SessionPrivate;
class JobPrivate;
struct Response;

class KIMAP_EXPORT Session : public QObject
{
    Q_OBJECT

friend class JobPrivate;

public:
    enum State { Disconnected = 0, NotAuthenticated, Authenticated, Selected };
    Q_ENUM(State)
    Session(const QString &hostName, quint16 port, QObject *parent = nullptr);
    ~Session();

Q_REQUIRED_RESULT QString hostName() const;
    Q_REQUIRED_RESULT quint16 port() const;
    Q_REQUIRED_RESULT State state() const;

/**
     * Returns the name that has been set with LoginJob::setUserName()
     * The user name is useful to uniquely identify an IMAP resource, in combination with the host name
     * @note If the Session was pre-authenticated, userName() will return an empty string
     * @since 4.7
     */
    Q_REQUIRED_RESULT QString userName() const;

Q_REQUIRED_RESULT QByteArray serverGreeting() const;

/**
     * Sets an ui proxy that displays the error messages and waits for user feedback.
     * @param proxy the ui proxy object
     */
    void setUiProxy(const SessionUiProxy::Ptr &proxy);

/**
     * Sets an ui proxy that displays the error messages and waits for user feedback.
     * @param proxy the ui proxy object
     * @deprecated Use the shared pointer version instead
     */
    KIMAP_DEPRECATED void setUiProxy(SessionUiProxy *proxy);

/**
     * Set the session timeout. The default is 30 seconds.
     * @param timeout The socket timeout in seconds, negative values disable the timeout.
     * @since 4.6
     */
    void setTimeout(int timeout);

/**
     * Returns the session timeout.
     * @since 4.12
     */
    Q_REQUIRED_RESULT int timeout() const;

/**
     * Returns the currently selected mailbox.
     * @since 4.5
     */
    Q_REQUIRED_RESULT QString selectedMailBox() const;

/**
    * Sets whether the IMAP network connection should use the system proxy settings.
    *
    * @param useProxy @c true if the proxy is to be used
    * The default is to not use the proxy.
    * @since 5.11.41
    *
    * @note If the session is currently connected to the IMAP server, calling this
    * function will disconnect and reconnect to it with the changed proxy setting.
    */
    void setUseNetworkProxy(bool useProxy);

Q_REQUIRED_RESULT int jobQueueSize() const;

void close();

Q_SIGNALS:
    void jobQueueSizeChanged(int queueSize);

/**
      Emitted when we lose a previously established connection

Likely reasons: server closed the connection, loss of internet connectivity, etc...
    */
    void connectionLost();

/**
      Emitted when the Session couldn't connect to the host.

Likely reasons: invalid host address, no internet connectivity, firewall blocking rules,
      etc...

Pending jobs in the queue will be deleted, and the first job in the queue will be failed. (ie:
      it will have its result signal emitted with a non-zero error code.)

@since 4.7
    */
    void connectionFailed();

/**
      Emitted when the session's state changes.

Not very useful after all... :-)

If you want to receive the stateChanged arguments in your slot, you must register the State
      enum with @c Q_DECLARE_METATYPE(KIMAP::Session::State) and @c qRegisterMetaType<KIMAP::Session::State>();

@since 4.7
    */
    void stateChanged(KIMAP::Session::State newState, KIMAP::Session::State oldState);

private:
    friend class SessionPrivate;
    SessionPrivate *const d;
};

}

#endif
0707010000007C000081A40000000200000002000000015ED129EC00000BBA000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/session_p.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SESSION_P_H
#define KIMAP_SESSION_P_H

#include "session.h"
#include "sessionuiproxy.h"

#include <QObject>
#include <QQueue>
#include <QString>
#include <QTimer>
#include <QSslSocket>

class KJob;

namespace KIMAP
{

class Job;
struct Response;
class SessionLogger;
class SessionThread;

class KIMAP_EXPORT SessionPrivate : public QObject
{
    Q_OBJECT

friend class Session;

public:
    explicit SessionPrivate(Session *session);
    ~SessionPrivate() override;

void addJob(Job *job);
    QByteArray sendCommand(const QByteArray &command, const QByteArray &args = QByteArray());
    void startSsl(QSsl::SslProtocol protocol);
    void sendData(const QByteArray &data);

QSsl::SslProtocol negotiatedEncryption() const;

void setSocketTimeout(int ms);
    int socketTimeout() const;

Q_SIGNALS:
    void encryptionNegotiationResult(bool);

private Q_SLOTS:
    void onEncryptionNegotiationResult(bool isEncrypted, QSsl::SslProtocol sslVersion);
    void onSocketTimeout();

void doStartNext();
    void jobDone(KJob *);
    void jobDestroyed(QObject *);
    void responseReceived(const KIMAP::Response &);

void socketConnected();
    void socketDisconnected();
    void socketError(QAbstractSocket::SocketError error);
    void socketActivity();

void handleSslError(const KSslErrorUiData &errorData);

private:
    void startNext();
    void clearJobQueue();
    void setState(Session::State state);

void startSocketTimer();
    void stopSocketTimer();
    void restartSocketTimer();
    bool isConnected() const;

Session *const q;

bool isSocketConnected = false;
    Session::State state;

SessionLogger *logger = nullptr;
    SessionThread *thread = nullptr;
    SessionUiProxy::Ptr uiProxy;

bool jobRunning = false;
    Job *currentJob = nullptr;
    QQueue<Job *> queue;

QByteArray authTag;
    QByteArray selectTag;
    QByteArray closeTag;

QString userName;
    QByteArray greeting;
    QByteArray currentMailBox;
    QByteArray upcomingMailBox;
    quint16 tagCount;

QSsl::SslProtocol sslVersion;

int socketTimerInterval = 0;
    QTimer socketTimer;
};

}

#endif
0707010000007D000081A40000000200000002000000015ED129EC0000078C000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/sessionlogger.cpp/*
    Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
    Author: Kevin Ottens <kevin@kdab.com>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "sessionlogger_p.h"

#include "kimap_debug.h"
#include <QCoreApplication>

using namespace KIMAP;

SessionLogger::SessionLogger()
    : m_id(0)
{
    static qint64 nextId = 0;
    m_id = ++nextId;

m_file.setFileName(QLatin1String(qgetenv("KIMAP_LOGFILE"))
                       + QLatin1Char('.')
                       + QString::number(QCoreApplication::applicationPid())
                       + QLatin1Char('.')
                       + QString::number(m_id));
    if (!m_file.open(QFile::WriteOnly)) {
        qCWarning(KIMAP_LOG) << "Could not open log file for writing:" << m_file.fileName();
    }
}

SessionLogger::~SessionLogger()
{
    m_file.close();
}

void SessionLogger::dataSent(const QByteArray &data)
{
    m_file.write("C: " + data.trimmed() + '\n');
    m_file.flush();
}

void SessionLogger::dataReceived(const QByteArray &data)
{
    m_file.write("S: " + data.trimmed() + '\n');
    m_file.flush();
}

void SessionLogger::disconnectionOccured()
{
    m_file.write("X\n");
}
0707010000007E000081A40000000200000002000000015ED129EC0000053E000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/sessionlogger_p.h/*
    Copyright (c) 2010 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
    Author: Kevin Ottens <kevin@kdab.com>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SESSIONLOGGER_P_H
#define KIMAP_SESSIONLOGGER_P_H

#include <QFile>

namespace KIMAP
{

class SessionLoggerPrivate;

class SessionLogger
{
public:
    SessionLogger();
    ~SessionLogger();

void dataSent(const QByteArray &data);
    void dataReceived(const QByteArray &data);
    void disconnectionOccured();

private:
    Q_DISABLE_COPY(SessionLogger)
    qint64 m_id;
    QFile m_file;
};

}

#endif
0707010000007F000081A40000000200000002000000015ED129EC00002D5B000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/sessionthread.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "sessionthread_p.h"

#include <KSslErrorUiData>

#include <QDebug>
#include <QThread>
#include <QNetworkProxy>
#include <QSslCipher>
#include "kimap_debug.h"

#include "imapstreamparser.h"
#include "response_p.h"

using namespace KIMAP;

Q_DECLARE_METATYPE(KSslErrorUiData)

namespace {
static const int _kimap_abstractSocketError = qRegisterMetaType<QAbstractSocket::SocketError>();
static const int _kimap_sslErrorUiData = qRegisterMetaType<KSslErrorUiData>();
}

SessionThread::SessionThread(const QString &hostName, quint16 port)
    : QObject(), m_hostName(hostName), m_port(port),
      m_encryptedMode(false),
      m_useProxy(false)
{
    // Just like the Qt docs now recommend, for event-driven threads:
    // don't derive from QThread, create one directly and move the object to it.
    QThread *thread = new QThread();
    moveToThread(thread);
    thread->start();
    QMetaObject::invokeMethod(this, &SessionThread::threadInit);
}

SessionThread::~SessionThread()
{
    QMetaObject::invokeMethod(this, &SessionThread::threadQuit);
    if (!thread()->wait(10 * 1000)) {
        qCWarning(KIMAP_LOG) << "Session thread refuses to die, killing harder...";
        thread()->terminate();
        // Make sure to wait until it's done, otherwise it can crash when the pthread callback is called
        thread()->wait();
    }
    delete thread();
}

// Called in primary thread, passes setting to secondary thread
void SessionThread::setUseNetworkProxy(bool useProxy)
{
    QMetaObject::invokeMethod(this, [this, useProxy]() { setUseProxyInternal(useProxy); }, Qt::QueuedConnection);
}

// Called in primary thread
void SessionThread::sendData(const QByteArray &payload)
{
    QMutexLocker locker(&m_mutex);

m_dataQueue.enqueue(payload);
    QMetaObject::invokeMethod(this, &SessionThread::writeDataQueue);
}

// Called in secondary thread
void SessionThread::writeDataQueue()
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_socket) {
        return;
    }
    QMutexLocker locker(&m_mutex);

while (!m_dataQueue.isEmpty()) {
        m_socket->write(m_dataQueue.dequeue());
    }
}

// Called in secondary thread
void SessionThread::readMessage()
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_stream || m_stream->availableDataSize() == 0) {
        return;
    }

Response message;
    QList<Response::Part> *payload = &message.content;

try {
        while (!m_stream->atCommandEnd()) {
            if (m_stream->hasString()) {
                QByteArray string = m_stream->readString();
                if (string == "NIL") {
                    *payload << Response::Part(QList<QByteArray>());
                } else {
                    *payload << Response::Part(string);
                }
            } else if (m_stream->hasList()) {
                *payload << Response::Part(m_stream->readParenthesizedList());
            } else if (m_stream->hasResponseCode()) {
                payload = &message.responseCode;
            } else if (m_stream->atResponseCodeEnd()) {
                payload = &message.content;
            } else if (m_stream->hasLiteral()) {
                QByteArray literal;
                while (!m_stream->atLiteralEnd()) {
                    literal += m_stream->readLiteralPart();
                }
                *payload << Response::Part(literal);
            } else {
                // Oops! Something really bad happened, we won't be able to recover
                // so close the socket immediately
                qWarning("Inconsistent state, probably due to some packet loss");
                doCloseSocket();
                return;
            }
        }

Q_EMIT responseReceived(message);

} catch (const KIMAP::ImapParserException &e) {
        qCWarning(KIMAP_LOG) << "The stream parser raised an exception:" << e.what();
    }

if (m_stream->availableDataSize() > 1) {
        QMetaObject::invokeMethod(this, &SessionThread::readMessage, Qt::QueuedConnection);
    }

}

// Called in main thread
void SessionThread::closeSocket()
{
    QMetaObject::invokeMethod(this, &SessionThread::doCloseSocket, Qt::QueuedConnection);
}

// Called in secondary thread
void SessionThread::doCloseSocket()
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_socket) {
        return;
    }
    m_encryptedMode = false;
    qCDebug(KIMAP_LOG) << "close";
    m_socket->close();
}

// Called in secondary thread
void SessionThread::reconnect()
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (m_socket == nullptr) { // threadQuit already called
        return;
    }
    if (m_socket->state() != QSslSocket::ConnectedState &&
            m_socket->state() != QSslSocket::ConnectingState) {

QNetworkProxy proxy;
        if (!m_useProxy) {
            qCDebug(KIMAP_LOG) << "Connecting to IMAP server with no proxy";
            proxy.setType(QNetworkProxy::NoProxy);
        } else {
            qCDebug(KIMAP_LOG) << "Connecting to IMAP server using default system proxy";
            proxy.setType(QNetworkProxy::DefaultProxy);
        }
        m_socket->setProxy(proxy);

if (m_encryptedMode) {
            qCDebug(KIMAP_LOG) << "connectToHostEncrypted" << m_hostName << m_port;
            m_socket->connectToHostEncrypted(m_hostName, m_port);
        } else {
            qCDebug(KIMAP_LOG) << "connectToHost" << m_hostName << m_port;
            m_socket->connectToHost(m_hostName, m_port);
        }
    }
}

// Called in secondary thread
void SessionThread::threadInit()
{
    Q_ASSERT(QThread::currentThread() == thread());
    m_socket = std::make_unique<QSslSocket>();
    m_stream = std::make_unique<ImapStreamParser>(m_socket.get());
    connect(m_socket.get(), &QIODevice::readyRead,
            this, &SessionThread::readMessage, Qt::QueuedConnection);

// Delay the call to slotSocketDisconnected so that it finishes disconnecting before we call reconnect()
    connect(m_socket.get(), &QSslSocket::disconnected,
            this, &SessionThread::slotSocketDisconnected, Qt::QueuedConnection);
    connect(m_socket.get(), &QSslSocket::connected,
            this, &SessionThread::socketConnected);
#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
    connect(m_socket.get(), QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error),
#else
    connect(m_socket.get(), QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::errorOccurred),
#endif
            this, &SessionThread::slotSocketError);

connect(m_socket.get(), &QIODevice::bytesWritten,
            this, &SessionThread::socketActivity);
    connect(m_socket.get(), &QSslSocket::encryptedBytesWritten,
            this, &SessionThread::socketActivity);
    connect(m_socket.get(), &QIODevice::readyRead,
            this, &SessionThread::socketActivity);
    QMetaObject::invokeMethod(this, &SessionThread::reconnect, Qt::QueuedConnection);
}

// Called in secondary thread
void SessionThread::threadQuit()
{
    Q_ASSERT(QThread::currentThread() == thread());
    m_stream.reset();
    m_socket.reset();
    thread()->quit();
}

// Called in secondary thread
void SessionThread::setUseProxyInternal(bool useProxy)
{
    m_useProxy = useProxy;
    if (m_socket != nullptr) {
        if (m_socket->state() != QSslSocket::UnconnectedState) {
            m_socket->disconnectFromHost();
            QMetaObject::invokeMethod(this, &SessionThread::reconnect, Qt::QueuedConnection);
        }
    }
}

// Called in primary thread
void SessionThread::startSsl(QSsl::SslProtocol protocol)
{
    QMetaObject::invokeMethod(this, [this, protocol]() { doStartSsl(protocol); });
}

// Called in secondary thread (via invokeMethod)
void SessionThread::doStartSsl(QSsl::SslProtocol protocol)
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_socket) {
        return;
    }

m_socket->setProtocol(protocol);
    m_socket->ignoreSslErrors(); // Don't worry, errors are handled manually below
    connect(m_socket.get(), &QSslSocket::encrypted, this, &SessionThread::sslConnected);
    m_socket->startClientEncryption();
}

// Called in secondary thread
void SessionThread::slotSocketDisconnected()
{
    Q_ASSERT(QThread::currentThread() == thread());
    Q_EMIT socketDisconnected();
}

// Called in secondary thread
void SessionThread::slotSocketError(QAbstractSocket::SocketError error)
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_socket) {
        return;
    }
    Q_EMIT socketError(error);
}

// Called in secondary thread
void SessionThread::sslConnected()
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_socket) {
        return;
    }
    QSslCipher cipher = m_socket->sessionCipher();
#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
    if (!m_socket->sslErrors().isEmpty()
#else
    if (!m_socket->sslHandshakeErrors().isEmpty()
#endif
            || !m_socket->isEncrypted()
        || cipher.isNull() || cipher.usedBits() == 0) {
        qCDebug(KIMAP_LOG) << "Initial SSL handshake failed. cipher.isNull() is" << cipher.isNull()
                           << ", cipher.usedBits() is" << cipher.usedBits()
                           << ", the socket says:" <<  m_socket->errorString()
                           << "and the list of SSL errors contains"
                      #if (QT_VERSION < QT_VERSION_CHECK(5, 15, 0))
                           << m_socket->sslErrors().count()
                      #else
                           << m_socket->sslHandshakeErrors().count()
                      #endif
                           << "items.";
        KSslErrorUiData errorData(m_socket.get());
        Q_EMIT sslError(errorData);
    } else {
        qCDebug(KIMAP_LOG) << "TLS negotiation done, the negotiated protocol is" << cipher.protocolString();
        m_encryptedMode = true;
        Q_EMIT encryptionNegotiationResult(true, m_socket->sessionProtocol());
    }
}

void SessionThread::sslErrorHandlerResponse(bool response)
{
    QMetaObject::invokeMethod(this, [this, response]() { doSslErrorHandlerResponse(response); });
}

// Called in secondary thread (via invokeMethod)
void SessionThread::doSslErrorHandlerResponse(bool response)
{
    Q_ASSERT(QThread::currentThread() == thread());
    if (!m_socket) {
        return;
    }
    if (response) {
        m_encryptedMode = true;
        Q_EMIT encryptionNegotiationResult(true, m_socket->sessionProtocol());
    } else {
        m_encryptedMode = false;
        //reconnect in unencrypted mode, so new commands can be issued
        m_socket->disconnectFromHost();
        m_socket->waitForDisconnected();
        m_socket->connectToHost(m_hostName, m_port);
        Q_EMIT encryptionNegotiationResult(false, QSsl::UnknownProtocol);
    }
}

#include "moc_sessionthread_p.cpp"
07070100000080000081A40000000200000002000000015ED129EC00000A38000000000000000000000000000000000000003F00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/sessionthread_p.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SESSIONTHREAD_P_H
#define KIMAP_SESSIONTHREAD_P_H

#include <QMutex>
#include <QQueue>

#include <QSslSocket>

#include <memory>

class KSslErrorUiData;

namespace KIMAP
{

class ImapStreamParser;
struct Response;

class SessionThread : public QObject
{
    Q_OBJECT

public:
    explicit SessionThread(const QString &hostName, quint16 port);
    ~SessionThread();

inline QString hostName()
    {
        return m_hostName;
    }
    inline quint16 port()
    {
        return m_port;
    }

void setUseNetworkProxy(bool useProxy);

void sendData(const QByteArray &payload);

public Q_SLOTS:
    void closeSocket();
    void startSsl(QSsl::SslProtocol protocol);
    void sslErrorHandlerResponse(bool result);

Q_SIGNALS:
    void socketConnected();
    void socketDisconnected();
    void socketActivity();
    void socketError(QAbstractSocket::SocketError);
    void responseReceived(const KIMAP::Response &response);
    void encryptionNegotiationResult(bool, QSsl::SslProtocol);
    void sslError(const KSslErrorUiData &);

private Q_SLOTS:
    void reconnect();
    void threadInit();
    void threadQuit();
    void readMessage();
    void writeDataQueue();
    void sslConnected();
    void doCloseSocket();
    void slotSocketError(QAbstractSocket::SocketError);
    void slotSocketDisconnected();
    void doStartSsl(QSsl::SslProtocol);
    void doSslErrorHandlerResponse(bool result);
    void setUseProxyInternal(bool useProxy);

private:
    QString m_hostName;
    quint16 m_port;

std::unique_ptr<QSslSocket> m_socket;
    std::unique_ptr<ImapStreamParser> m_stream;

QQueue<QByteArray> m_dataQueue;

// Protects m_dataQueue
    QMutex m_mutex;

bool m_encryptedMode = false;
    bool m_useProxy = false;
};

}

#endif
07070100000081000081A40000000200000002000000015ED129EC00000394000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/src/sessionuiproxy.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "sessionuiproxy.h"

KIMAP::SessionUiProxy::~SessionUiProxy() {}
07070100000082000081A40000000200000002000000015ED129EC00000807000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/sessionuiproxy.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SESSIONUIPROXY_H
#define KIMAP_SESSIONUIPROXY_H

#include "kimap_export.h"

#include "job.h"

#include <QSharedPointer>

class KSslErrorUiData;

namespace KIMAP
{

/** @short Interface to display communication errors and wait for user feedback. */
class KIMAP_EXPORT SessionUiProxy
{
public:
    typedef QSharedPointer<SessionUiProxy> Ptr;

virtual ~SessionUiProxy();
    /**
     * Show an SSL error and ask the user whether it should be ignored or not.
     * The recommended KDE UI is the following:
     * @code
     * #include <kio/ksslui.h>
     * class UiProxy: public SessionUiProxy {
     *   public:
     *     bool ignoreSslError(const KSslErrorUiData& errorData) {
     *       if (KIO::SslUi::askIgnoreSslErrors(errorData)) {
     *         return true;
     *       } else {
     *        return false;
     *       }
     *     }
     * };
     * [...]
     * Session session(server, port);
     * UiProxy *proxy = new UiProxy();
     * session.setUiProxy(proxy);
     * @endcode
     * @param errorData contains details about the error.
     * @return true if the error can be ignored
     */
    virtual bool ignoreSslError(const KSslErrorUiData &errorData) = 0;
};

}

#endif
07070100000083000081A40000000200000002000000015ED129EC00000825000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/setacljob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "setacljob.h"

#include <KLocalizedString>

#include "acljobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class SetAclJobPrivate : public AclJobBasePrivate
{
public:
    SetAclJobPrivate(Session *session, const QString &name) : AclJobBasePrivate(session, name) {}
    ~SetAclJobPrivate() { }
};
}

using namespace KIMAP;

SetAclJob::SetAclJob(Session *session)
    : AclJobBase(*new SetAclJobPrivate(session, i18n("SetAcl")))
{
}

SetAclJob::~SetAclJob()
{
}

void SetAclJob::doStart()
{
    Q_D(SetAclJob);
    QByteArray r = Acl::rightsToString(d->rightList);
    if (d->modifier == Add) {
        r.prepend('+');
    } else if (d->modifier == Remove) {
        r.prepend('-');
    }
    d->tags << d->sessionInternal()->sendCommand("SETACL", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + "\" \"" + d->id + "\" \"" + r + '\"');
}

void SetAclJob::setRights(AclModifier modifier, Acl::Rights rights)
{
    Q_D(SetAclJob);
    d->setRights(modifier, rights);
}

void SetAclJob::setIdentifier(const QByteArray &identifier)
{
    Q_D(SetAclJob);
    d->setIdentifier(identifier);
}

QByteArray SetAclJob::identifier()
{
    Q_D(SetAclJob);
    return d->identifier();
}
07070100000084000081A40000000200000002000000015ED129EC00000EA9000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/setacljob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SETACLJOB_H
#define KIMAP_SETACLJOB_H

#include "kimap_export.h"

#include "acljobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class SetAclJobPrivate;

/**
 * Sets the rights that correspond to an identifier on a mailbox
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * This job requires that the server supports the ACL
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc4314">RFC 4314</a>.
 */
class KIMAP_EXPORT SetAclJob : public AclJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(SetAclJob)

friend class SessionPrivate;

public:
    explicit SetAclJob(Session *session);
    ~SetAclJob() override;

/**
     * Sets the rights that will be changed for the identifier
     *
     * Note that multiple calls to this method will have a
     * non-intuitive effect: the @p modifier value of the most
     * recent call will be used, but the OR'd-together values
     * of all calls to setRights() will be used.
     *
     * If the server does not recognise any of the rights,
     * the job will fail and the ACL for the mailbox will
     * remain unchanged.
     *
     * Note that some rights may be tied together, and must be set
     * or removed as a group.  See ListRightsJob::possibleRights()
     * for more details.  The server will only set a tied group
     * of rights if you have requested that all the rights in that
     * group should be set.
     *
     * @param modifier  determines whether the rights will be
     *                  added to the identifier, removed from
     *                  the identifier or will replace any
     *                  existing rights assigned to the
     *                  identifier
     * @param rights    the rights to be added, removed or set
     */
    void setRights(AclModifier modifier, Acl::Rights rights);

/**
     * Sets the identifier the rights will be modified for
     *
     * The meaning of identifiers depends on the server implementation,
     * with the following restrictions:
     *
     * - "anyone" means any authenticated user, including anonymous
     * - an identifier starting with a minus sign ('-') indicates
     *   "negative rights": rights that should be taken away from
     *   matching users
     *
     * Other than the above restrictions, ACL identifiers are usually
     * IMAP usernames, but could potentially be group names as well.
     *
     * Note that negative rights override positive rights: if
     * "fred" and "-fred" are both assigned the 'w' right, the
     * user "fred" will not have the 'w' right.
     * @param identifier the identifier to set
     */
    void setIdentifier(const QByteArray &identifier);
    /**
     * The identifier that rights will be associated with
     */
    Q_REQUIRED_RESULT QByteArray identifier();

protected:
    void doStart() override;

};

}

#endif
07070100000085000081A40000000200000002000000015ED129EC00001A18000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/src/setmetadatajob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "setmetadatajob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include "metadatajobbase_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class SetMetaDataJobPrivate : public MetaDataJobBasePrivate
{
public:
    SetMetaDataJobPrivate(Session *session, const QString &name) : MetaDataJobBasePrivate(session, name), metaDataErrors({}), maxAcceptedSize(-1) { }
    ~SetMetaDataJobPrivate() { }

QMap<QByteArray, QByteArray> entries;
    QMap<QByteArray, QByteArray>::ConstIterator entriesIt;
    QByteArray entryName;
    SetMetaDataJob::MetaDataErrors metaDataErrors;
    qint64 maxAcceptedSize;
};
}

using namespace KIMAP;

SetMetaDataJob::SetMetaDataJob(Session *session)
    : MetaDataJobBase(*new SetMetaDataJobPrivate(session, i18n("SetMetaData")))
{
}

SetMetaDataJob::~SetMetaDataJob()
{
}

void SetMetaDataJob::doStart()
{
    Q_D(SetMetaDataJob);
    QByteArray parameters = '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + "\" ";
    d->entriesIt = d->entries.constBegin();

QByteArray command = "SETMETADATA";
    bool bSimpleData = true;

if (d->serverCapability == Annotatemore) {
        command = "SETANNOTATION";
        parameters += '\"' + d->entryName + "\" ";
    } else {
        for (; d->entriesIt != d->entries.constEnd(); ++d->entriesIt) {
            if (d->entriesIt.value().contains('\r') || d->entriesIt.value().contains('\n')) {
                bSimpleData = false;
                break;
            }
        }
        d->entriesIt = d->entries.constBegin();
    }

parameters += '(';
    if (bSimpleData == true) {
        for ( ; d->entriesIt != d->entries.constEnd(); ++d->entriesIt ) {
            parameters += '\"' + d->entriesIt.key() + "\" ";
            if (d->entriesIt.value().isEmpty()) {
                parameters += "NIL";
            } else {
                parameters +=  "\"" + d->entriesIt.value() + "\"";
            }
            parameters += " ";

}
        parameters[parameters.length() - 1] = ')';
    } else {
        if (!d->entries.isEmpty()) {
            parameters += '\"' + d->entriesIt.key() + "\"";
            int size = d->entriesIt.value().size();
            parameters += " {" + QByteArray::number( size==0 ? 3 : size ) + '}';
        }
    }

if (d->entries.isEmpty()) {
        parameters += ')';
    }

d->tags << d->sessionInternal()->sendCommand(command, parameters);
//   qCDebug(KIMAP_LOG) << "SENT: " << command << " " << parameters;
}

void SetMetaDataJob::handleResponse(const Response &response)
{
    Q_D(SetMetaDataJob);

//TODO: Test if a server can really return more then one untagged NO response. If not, no need to OR the error codes
    if (!response.content.isEmpty() &&
        d->tags.contains(response.content.first().toString())) {
        if (response.content[1].toString() == "NO") {
            setError(UserDefinedError);
            setErrorText(i18n("%1 failed, server replied: %2", d->m_name, QLatin1String(response.toString().constData())));
            const QByteArray responseBa = response.content[2].toString();
            if (responseBa == "[ANNOTATEMORE TOOMANY]" ||
                    responseBa == "[METADATA TOOMANY]") {
                d->metaDataErrors |= TooMany;
            } else if (responseBa == "[ANNOTATEMORE TOOBIG]" ||
                       responseBa.startsWith("[METADATA MAXSIZE")) {    //krazy:exclude=strings
                d->metaDataErrors |= TooBig;
                d->maxAcceptedSize = -1;
                if (responseBa.startsWith("[METADATA MAXSIZE")) {     //krazy:exclude=strings
                    QByteArray max = responseBa;
                    max.replace("[METADATA MAXSIZE", "");   //krazy:exclude=doublequote_chars
                    max.replace("]", "");                   //krazy:exclude=doublequote_chars
                    d->maxAcceptedSize = max.toLongLong();
                }
            } else if (responseBa == "[METADATA NOPRIVATE]") {
                d->metaDataErrors |= NoPrivate;
            }
        } else if (response.content.size() < 2) {
            setErrorText(i18n("%1 failed, malformed reply from the server.", d->m_name));
        } else if (response.content[1].toString() != "OK") {
            setError(UserDefinedError);
            setErrorText(i18n("%1 failed, server replied: %2", d->m_name, QLatin1String(response.toString().constData())));
        }
        emitResult();
    } else if (d->serverCapability == Metadata && response.content[0].toString() == "+") {
        QByteArray content = "";
        if (d->entriesIt.value().isEmpty()) {
            content += "NIL";
        } else {
            content +=  d->entriesIt.value();
        }
        ++d->entriesIt;
        if (d->entriesIt == d->entries.constEnd()) {
            content += ')';
        } else {
            content += " \"" + d->entriesIt.key() + '\"';
            int size = d->entriesIt.value().size();
            content += " {" + QByteArray::number( size==0 ? 3 : size ) + '}';
        }
//      qCDebug(KIMAP_LOG) << "SENT: " << content;
        d->sessionInternal()->sendData(content);
    }
}

void SetMetaDataJob::addMetaData(const QByteArray &name, const QByteArray &value)
{
    Q_D(SetMetaDataJob);
    if (d->serverCapability == Annotatemore && (name.startsWith("/shared") || name.startsWith("/private"))) {
        const QByteArray &attribute = d->getAttribute(name);
        d->entries[attribute] = value;
        d->entryName = d->removePrefix(name);
    } else {
        d->entries[name] = value;
    }
}

void SetMetaDataJob::setEntry(const QByteArray &entry)
{
    Q_D(SetMetaDataJob);
    d->entryName = entry;
}

SetMetaDataJob::MetaDataErrors SetMetaDataJob::metaDataErrors() const
{
    Q_D(const SetMetaDataJob);
    return d->metaDataErrors;
}
07070100000086000081A40000000200000002000000015ED129EC00001EE1000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/setmetadatajob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SETMETADATAJOB_H
#define KIMAP_SETMETADATAJOB_H

#include "kimap_export.h"

#include "metadatajobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class SetMetaDataJobPrivate;

/**
 * Sets mailbox metadata.
 *
 * Provides support for the IMAP METADATA extension; both the
 * final RFC version
 * (<a href="https://tools.ietf.org/html/rfc5464">RFC 5464</a>)
 * and the older, incompatible draft version (known as ANNOTATEMORE)
 * (<a
 * href="https://tools.ietf.org/html/draft-daboo-imap-annotatemore-07"
 * >draft-daboo-imap-annotatemore-07</a>).  See setServerCompatibility().
 *
 * Note that in Annotatemore mode, this job can only operate on
 * one metadata entry at once.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * If the server supports ACLs, the user will need the
 * Acl::Lookup right on the mailbox, as well as one of
 * - Acl::Read
 * - Acl::KeepSeen
 * - Acl::Write
 * - Acl::Insert
 * - Acl::Post
 * Otherwise, the user must be able to list the mailbox
 * and either read or write the message content.
 *
 * Note that even if the user has these permissions, the
 * server may refuse to allow the user to write metadata
 * based on some other criteria.
 *
 * Note also that on servers that implement the Annotatemore
 * version of the extension, only Acl::Lookup rights are
 * required (ie: the user must be able to list the mailbox).
 */
class KIMAP_EXPORT SetMetaDataJob : public MetaDataJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(SetMetaDataJob)

friend class SessionPrivate;

public:
    explicit SetMetaDataJob(Session *session);
    ~SetMetaDataJob() override;

/**
     * Adds a metadata entry or attribute to the list of modifications to make
     *
     * When in Metadata mode, this method adds a metadata
     * entry to the list of metadata additions and updates that
     * will be performed when the job is run.
     *
     * @p name must be a valid ASCII string and may not contain two
     * consecutive forward slashes ('/'), must not end with '/' and
     * must not contain '*', '%', non-ASCII characters or characters
     * in the ASCII range 0x00 to 0x19 (in practice, all control
     * characters should be avoided).  The name is case-insensitive.
     *
     * The first part of the entry name should be "/private" or
     * "/shared", indicating the scope of the entry.  Note that
     * private metadata may not be supported by all servers.
     *
     * Server metadata entry names include:
     * - /shared/comment
     * - /shared/admin - a URI for contacting the server administrator
     *                   (eg: a mailto: or tel: URI)
     * - /shared/vendor/<vendor-token>/something
     * - /private/vendor/<vendor-token>/something
     *
     * Mailbox metadata entry names include:
     * - /shared/comment
     * - /private/comment
     * - /shared/vendor/<vendor-token>/something
     * - /private/vendor/<vendor-token>/something
     *
     * @p value can be any data, although if it is a multi-line string
     * value, CRLF line-endings must be used.
     *
     * In Annotatemore mode it is possible to prefix the entry name with a /shared or /private prefix, that is automatically translated
     * to an appropriate value.shared|priv attribute.
     *
     * Annotatemore legacy mode:
     * When in Annotatemore mode, this method adds an attribute
     * entry to the list of additions and updates that will be
     * performed on the metadata entry when the job is run.
     *
     * @p name must be a valid UTF-8 string, and may not contain the
     * '%' or '*' characters, or NUL.  Use of non-visible UTF-8 characters
     * is strongly discouraged.
     *
     * Possible attribute name prefixes are:
     * - value - the data value of the attribute
     * - content-type - a MIME content type and subtype
     * - content-language - a RFC 3282 language code
     * - vendor.<vendor-token> - a vendor-specific attribute
     *
     * Attribute names an attribute name prefix followed by ".priv" for
     * private attributes or ".shared" for shared attributes.  Note that
     * the attributes "size.priv" and "size.shared" are read-only
     * attributes set by the server, and so cannot be used with
     * SetMetaDataJob.
     *
     * @param name   the metadata entry name (Metadata or Annotatemore mode) in ASCII or
     *               attribute name (Annotatemore mode, if used without /shared or /private prefix) in UTF-8
     * @param value  the value of the entry or attribute
     */
    // KDE5: drop ANNOTATEMORE support
    void addMetaData(const QByteArray &name, const QByteArray &value);

/**
     * Sets the metadata entry name to operate on (in Annotatemore mode)
     *
     * In Annotatemore mode, this specifies the metadata entry name to
     * operate on.  For server metadata, this is one of:
     * - /comment
     * - /motd
     * - /admin
     * - /vendor/<vendor-token>/something
     *
     * For mailbox metadata, this is one of:
     * - /comment
     * - /sort
     * - /thread
     * - /check
     * - /checkperiod
     * - /vendor/<vendor-token>/something
     *
     * Entry names must be valid UTF-8 strings that do not contain the
     * '%' or '*' characters, or NUL.  Use of non-visible UTF-8
     * characters is strongly discouraged.
     *
     * In Metadata mode, this has no effect.  Metadata entry names
     * should instead be specified as the first argument to addMetaData().
     *
     * @see setServerCapability()
     *
     * @param entry  the metadata entry name in UTF-8
     *
     * @deprecated Use a /shared or /private prefix with addMetaData instead.
     */
    // KDE5: remove
    KIMAP_DEPRECATED void setEntry(const QByteArray &entry);

/**
     * Possible error codes that may be returned by the server.
     */
    enum MetaDataError {
        NoError = 0,  /**< Used to indicate that no errors have been received */
        TooMany = 1,  /**< Cannot add a new metadata item, because the limit has already been reached */
        TooBig = 2,   /**< A metadata value was too big (see maxAcceptedSize()) */
        NoPrivate = 4 /**< The server does not support private metadata entries */
    };

// Q_DECLARE_WHATEVER_THAT_WAS missing
    Q_DECLARE_FLAGS(MetaDataErrors, MetaDataError)

/**
     * The metadata errors received from the server.
     *
     * @return  a set of error codes
     */
    Q_REQUIRED_RESULT MetaDataErrors metaDataErrors() const;
    /**
     * The maximum accepted metadata size.
     *
     * If the server replied that one of the metadata values was too
     * large (see metaDataErrors), this should indicate what the
     * maximum size accepted by the server is.
     *
     * @return  the maximum value size in octets, or -1 if the limit is unknown
     */
    Q_REQUIRED_RESULT qint64 maxAcceptedSize();

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

Q_DECLARE_OPERATORS_FOR_FLAGS(KIMAP::SetMetaDataJob::MetaDataErrors)

#endif
07070100000087000081A40000000200000002000000015ED129EC00000AA5000000000000000000000000000000000000003D00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/setquotajob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "setquotajob.h"

#include <KLocalizedString>
#include "kimap_debug.h"

#include "quotajobbase_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class SetQuotaJobPrivate : public QuotaJobBasePrivate
{
public:
    SetQuotaJobPrivate(Session *session, const QString &name) : QuotaJobBasePrivate(session, name) { }
    ~SetQuotaJobPrivate() { }

QMap<QByteArray, qint64> setList;
    QByteArray root;
};
}

using namespace KIMAP;

SetQuotaJob::SetQuotaJob(Session *session)
    : QuotaJobBase(*new SetQuotaJobPrivate(session, i18n("SetQuota")))
{
}

SetQuotaJob::~SetQuotaJob()
{
}

void SetQuotaJob::doStart()
{
    Q_D(SetQuotaJob);
    QByteArray s;
    s += '(';
    for (QMap<QByteArray, qint64>::ConstIterator it = d->setList.constBegin(), end = d->setList.constEnd(); it != end; ++it) {
        s += it.key() + ' ' + QByteArray::number(it.value()) + ' ';
    }
    if (d->setList.isEmpty()) {
        s += ')';
    } else {
        s[s.length() - 1] = ')';
    }

qCDebug(KIMAP_LOG) << "SETQUOTA " << '\"' + d->root + "\" " + s;
    //XXX: [alexmerry, 2010-07-24]: should d->root be quoted properly?
    d->tags << d->sessionInternal()->sendCommand("SETQUOTA", '\"' + d->root + "\" " + s);
}

void SetQuotaJob::handleResponse(const Response &response)
{
    Q_D(SetQuotaJob);
    if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 4 &&
                response.content[1].toString() == "QUOTA") {
            d->quota = d->readQuota(response.content[3]);
        }
    }
}

void SetQuotaJob::setQuota(const QByteArray &resource, qint64 limit)
{
    Q_D(SetQuotaJob);

d->setList[resource.toUpper()] = limit;
}

void SetQuotaJob::setRoot(const QByteArray &root)
{
    Q_D(SetQuotaJob);

d->root = root;
}

QByteArray SetQuotaJob::root() const
{
    Q_D(const SetQuotaJob);

return d->root;
}
07070100000088000081A40000000200000002000000015ED129EC00000D5F000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/setquotajob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SETQUOTAJOB_H
#define KIMAP_SETQUOTAJOB_H

#include "quotajobbase.h"

namespace KIMAP
{

class Session;
struct Response;
class SetQuotaJobPrivate;

/**
 * Sets resource limits on a quota root.
 *
 * Quotas are defined with respect to "resources" and "quota roots".
 * A resource is a numerical property that can be limited, such
 * as the octet size of all the messages in a mailbox, or the
 * number of messages in a mailbox.  Each mailbox has one or more
 * quota roots, which are where the resource limits are defined.
 * A quota root may or may not be a mailbox name, and an empty
 * string is a valid quota root.  All mailboxes with the same quota
 * root share the resource limits of the quota root.
 *
 * This job can only be run when the session is in the
 * authenticated (or selected) state.
 *
 * This job requires that the server supports the QUOTA
 * capability, defined in
 * <a href="https://tools.ietf.org/html/rfc2087">RFC 2087</a>.
 */
class KIMAP_EXPORT SetQuotaJob : public QuotaJobBase
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(SetQuotaJob)

friend class SessionPrivate;

public:
    explicit SetQuotaJob(Session *session);
    ~SetQuotaJob() override;

/**
     * Set a limit for a quota resource.
     *
     * For example, you might set the limit for "STORAGE" to
     * 512 to limit the sum of the messages' RFC822.SIZE to
     * 512*1024 octets (ie: 512 kb), or the limit for "MESSAGE"
     * to 100 to limit the number of messages to 100.
     *
     * Note that although RFC 2087 allows a resource name to
     * be any string, this API actually limits resource names
     * to upper-case atoms.  In practice, resource names will
     * almost certainly be composed entirely of upper-case latin
     * letters (A-Z).
     *
     * @param resource  the resource name
     * @param limit     the maximum value the resource may take
     */
    void setQuota(const QByteArray &resource, qint64 limit);

/**
     * Set the quota root the resource limits should be set for.
     *
     * Note: if the quota root does not already exist, the server
     * may create it and change the quota roots for any number of
     * existing mailboxes in an implementation-defined manner.
     *
     * @param root the quota root to set, in bytes
     * @see GetQuotaRootJob
     */
    void setRoot(const QByteArray &root);
    /**
     * The quota root that will be modified.
     */
    Q_REQUIRED_RESULT QByteArray root() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;

};

}

#endif
07070100000089000081A40000000200000002000000015ED129EC00000BCE000000000000000000000000000000000000003B00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/statusjob.cpp/*
    Copyright (c) 2016 Daniel Vrátil <dvratil@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "statusjob.h"
#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"
#include "kimap_debug.h"

#include <KLocalizedString>

namespace KIMAP
{

class StatusJobPrivate : public JobPrivate
{
public:
    explicit StatusJobPrivate(Session *session, const QString &name)
        : JobPrivate(session, name)
    {
    }

~StatusJobPrivate()
    {
    }

QString mailBox;
    QList<QByteArray> dataItems;
    QList<QPair<QByteArray, qint64>> status;
};

}

using namespace KIMAP;

StatusJob::StatusJob(Session *session)
    : Job(*new StatusJobPrivate(session, i18nc("name of the status job", "Status")))
{
}

StatusJob::~StatusJob()
{
}

void StatusJob::setMailBox(const QString &mailBox)
{
    Q_D(StatusJob);
    d->mailBox = mailBox;
}

QString StatusJob::mailBox() const
{
    Q_D(const StatusJob);
    return d->mailBox;
}

void StatusJob::setDataItems(const QList<QByteArray> &dataItems)
{
    Q_D(StatusJob);
    d->dataItems = dataItems;
}

QList<QByteArray> StatusJob::dataItems() const
{
    Q_D(const StatusJob);
    return d->dataItems;
}

QList<QPair<QByteArray, qint64>> StatusJob::status() const
{
    Q_D(const StatusJob);
    return d->status;
}

void StatusJob::doStart()
{
    Q_D(StatusJob);

const QByteArray params = '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + "\" ("
                            + d->dataItems.join(' ') + ')';

d->tags << d->sessionInternal()->sendCommand("STATUS", params);
}

void StatusJob::handleResponse(const Response &response)
{
    Q_D(StatusJob);

if (handleErrorReplies(response) == NotHandled) {
        if (response.content.size() >= 3) {
            const QByteArray code = response.content[1].toString();
            if (code == "STATUS") {

const QList<QByteArray> resp = response.content[3].toList();
                for (int i = 0; i < resp.size(); i += 2) {
                    d->status << (qMakePair(resp[i], resp[i + 1].toLongLong()));
                }

} else if (code == "OK") {
                return;
            } else {
                qCDebug(KIMAP_LOG) << response.toString();
            }
        }
    }
}
0707010000008A000081A40000000200000002000000015ED129EC00000669000000000000000000000000000000000000003900000000kimap-VERSIONgit.20200529T172740~a5402d2/src/statusjob.h/*
    Copyright (c) 2016 Daniel Vrátil <dvratil@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_STATUSJOB_H
#define KIMAP_STATUSJOB_H

#include "kimap_export.h"

#include "job.h"
#include <QList>

namespace KIMAP
{
class Session;
class StatusJobPrivate;

class KIMAP_EXPORT StatusJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(StatusJob)

friend class StatusJobPrivate;

public:
    explicit StatusJob(Session *session);
    ~StatusJob() override;

void setMailBox(const QString &mailBox);
    Q_REQUIRED_RESULT QString mailBox() const;

void setDataItems(const QList<QByteArray> &dataItems);
    Q_REQUIRED_RESULT QList<QByteArray> dataItems() const;

Q_REQUIRED_RESULT QList<QPair<QByteArray, qint64>> status() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif // KIMAP_STATUSJOB_H
0707010000008B000081A40000000200000002000000015ED129EC0000169E000000000000000000000000000000000000003A00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/storejob.cpp/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "storejob.h"

#include "kimap_debug.h"
#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"

namespace KIMAP
{
class StoreJobPrivate : public JobPrivate
{
public:
    StoreJobPrivate(Session *session, const QString &name) : JobPrivate(session, name), uidBased(false) { }
    ~StoreJobPrivate() { }

QByteArray addFlags(const QByteArray &param, const MessageFlags &flags)
    {
        QByteArray parameters;
        switch (mode) {
        case StoreJob::SetFlags:
            parameters += param;
            break;
        case StoreJob::AppendFlags:
            parameters += "+" + param;
            break;
        case StoreJob::RemoveFlags:
            parameters += "-" + param;
            break;
        }

parameters += " (";
        for (const QByteArray &flag : flags) {
            parameters += flag + ' ';
        }
        if (!flags.isEmpty()) {
            parameters.chop(1);
        }
        parameters += ')';

return parameters;
    }

ImapSet set;
    bool uidBased;
    StoreJob::StoreMode mode;
    MessageFlags flags;
    MessageFlags gmLabels;

QMap<int, MessageFlags> resultingFlags;
};
}

using namespace KIMAP;

StoreJob::StoreJob(Session *session)
    : Job(*new StoreJobPrivate(session, i18n("Store")))
{
    Q_D(StoreJob);
    d->uidBased = false;
    d->mode = SetFlags;
}

StoreJob::~StoreJob()
{
}

void StoreJob::setSequenceSet(const ImapSet &set)
{
    Q_D(StoreJob);
    d->set = set;
}

ImapSet StoreJob::sequenceSet() const
{
    Q_D(const StoreJob);
    return d->set;
}

void StoreJob::setUidBased(bool uidBased)
{
    Q_D(StoreJob);
    d->uidBased = uidBased;
}

bool StoreJob::isUidBased() const
{
    Q_D(const StoreJob);
    return d->uidBased;
}

void StoreJob::setFlags(const MessageFlags &flags)
{
    Q_D(StoreJob);
    d->flags = flags;
}

MessageFlags StoreJob::flags() const
{
    Q_D(const StoreJob);
    return d->flags;
}

void StoreJob::setGMLabels(const MessageFlags &gmLabels)
{
    Q_D(StoreJob);
    d->gmLabels = gmLabels;
}

MessageFlags StoreJob::gmLabels() const
{
    Q_D(const StoreJob);
    return d->gmLabels;
}

void StoreJob::setMode(StoreMode mode)
{
    Q_D(StoreJob);
    d->mode = mode;
}

StoreJob::StoreMode StoreJob::mode() const
{
    Q_D(const StoreJob);
    return d->mode;
}

QMap<int, MessageFlags> StoreJob::resultingFlags() const
{
    Q_D(const StoreJob);
    return d->resultingFlags;
}

void StoreJob::doStart()
{
    Q_D(StoreJob);

if (d->set.isEmpty()) {
        qCWarning(KIMAP_LOG) << "Empty uid set passed to store job";
        setError(KJob::UserDefinedError);
        setErrorText(QStringLiteral("Empty uid set passed to store job"));
        emitResult();
        return;
    }

d->set.optimize();
    QByteArray parameters = d->set.toImapSequenceSet() + ' ';

if (!d->flags.isEmpty()) {
        parameters += d->addFlags("FLAGS", d->flags);
    }
    if (!d->gmLabels.isEmpty()) {
        if (!d->flags.isEmpty()) {
            parameters += ' ';
        }
        parameters += d->addFlags("X-GM-LABELS", d->gmLabels);
    }

qCDebug(KIMAP_LOG) << parameters;

QByteArray command = "STORE";
    if (d->uidBased) {
        command = "UID " + command;
    }

d->tags << d->sessionInternal()->sendCommand(command, parameters);
}

void StoreJob::handleResponse(const Response &response)
{
    Q_D(StoreJob);

int id = response.content[1].toString().toInt();
            qint64 uid = 0;
            bool uidFound = false;
            QList<QByteArray> resultingFlags;

QList<QByteArray> content = response.content[3].toList();

for (QList<QByteArray>::ConstIterator it = content.constBegin();
                    it != content.constEnd(); ++it) {
                QByteArray str = *it;
                ++it;

if (str == "FLAGS") {
                    if ((*it).startsWith('(') && (*it).endsWith(')')) {
                        QByteArray str = *it;
                        str.chop(1);
                        str.remove(0, 1);
                        resultingFlags = str.split(' ');
                    } else {
                        resultingFlags << *it;
                    }
                } else if (str == "UID") {
                    uid = it->toLongLong(&uidFound);
                }
            }

if (!d->uidBased) {
                d->resultingFlags[id] = resultingFlags;
            } else if (uidFound) {
                d->resultingFlags[uid] = resultingFlags;
            } else {
                qCWarning(KIMAP_LOG) << "We asked for UID but the server didn't give it back, resultingFlags not stored.";
            }
        }
    }
}
0707010000008C000081A40000000200000002000000015ED129EC000007DB000000000000000000000000000000000000003800000000kimap-VERSIONgit.20200529T172740~a5402d2/src/storejob.h/*
    Copyright (c) 2009 Kevin Ottens <ervin@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_STOREJOB_H
#define KIMAP_STOREJOB_H

#include "kimap_export.h"

#include "job.h"
#include "imapset.h"

namespace KIMAP
{

class Session;
struct Response;
class StoreJobPrivate;

typedef QList<QByteArray> MessageFlags;

class KIMAP_EXPORT StoreJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(StoreJob)

friend class SessionPrivate;

public:
    enum StoreMode {
        SetFlags,
        AppendFlags,
        RemoveFlags
    };

explicit StoreJob(Session *session);
    ~StoreJob() override;

void setSequenceSet(const ImapSet &set);
    Q_REQUIRED_RESULT ImapSet sequenceSet() const;

void setUidBased(bool uidBased);
    Q_REQUIRED_RESULT bool isUidBased() const;

void setFlags(const MessageFlags &flags);
    Q_REQUIRED_RESULT MessageFlags flags() const;

void setGMLabels(const MessageFlags &gmLabels);
    Q_REQUIRED_RESULT MessageFlags gmLabels() const;

void setMode(StoreMode mode);
    Q_REQUIRED_RESULT StoreMode mode() const;

Q_REQUIRED_RESULT QMap<int, MessageFlags> resultingFlags() const;

protected:
    void doStart() override;
    void handleResponse(const Response &response) override;
};

}

#endif
0707010000008D000081A40000000200000002000000015ED129EC000006F0000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/subscribejob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "subscribejob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class SubscribeJobPrivate : public JobPrivate
{
public:
    SubscribeJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~SubscribeJobPrivate() { }

QString mailBox;
};
}

using namespace KIMAP;

SubscribeJob::SubscribeJob(Session *session)
    : Job(*new SubscribeJobPrivate(session, i18n("Subscribe")))
{
}

SubscribeJob::~SubscribeJob()
{
}

void SubscribeJob::doStart()
{
    Q_D(SubscribeJob);
    d->tags << d->sessionInternal()->sendCommand("SUBSCRIBE", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void SubscribeJob::setMailBox(const QString &mailBox)
{
    Q_D(SubscribeJob);
    d->mailBox = mailBox;
}

QString SubscribeJob::mailBox() const
{
    Q_D(const SubscribeJob);
    return d->mailBox;
}
0707010000008E000081A40000000200000002000000015ED129EC0000055B000000000000000000000000000000000000003C00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/subscribejob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_SUBSCRIBEJOB_H
#define KIMAP_SUBSCRIBEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
class SubscribeJobPrivate;

class KIMAP_EXPORT SubscribeJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(SubscribeJob)

friend class SessionPrivate;

public:
    explicit SubscribeJob(Session *session);
    ~SubscribeJob() override;

void setMailBox(const QString &mailBox);
    Q_REQUIRED_RESULT QString mailBox() const;

protected:
    void doStart() override;
};

}

#endif
0707010000008F000081A40000000200000002000000015ED129EC00000712000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/src/unsubscribejob.cpp/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#include "unsubscribejob.h"

#include <KLocalizedString>

#include "job_p.h"
#include "response_p.h"
#include "session_p.h"
#include "rfccodecs.h"

namespace KIMAP
{
class UnsubscribeJobPrivate : public JobPrivate
{
public:
    UnsubscribeJobPrivate(Session *session, const QString &name) : JobPrivate(session, name) { }
    ~UnsubscribeJobPrivate() { }

QString mailBox;
};
}

using namespace KIMAP;

UnsubscribeJob::UnsubscribeJob(Session *session)
    : Job(*new UnsubscribeJobPrivate(session, i18n("Unsubscribe")))
{
}

UnsubscribeJob::~UnsubscribeJob()
{
}

void UnsubscribeJob::doStart()
{
    Q_D(UnsubscribeJob);
    d->tags << d->sessionInternal()->sendCommand("UNSUBSCRIBE", '\"' + KIMAP::encodeImapFolderName(d->mailBox.toUtf8()) + '\"');
}

void UnsubscribeJob::setMailBox(const QString &mailBox)
{
    Q_D(UnsubscribeJob);
    d->mailBox = mailBox;
}

QString UnsubscribeJob::mailBox() const
{
    Q_D(const UnsubscribeJob);
    return d->mailBox;
}
07070100000090000081A40000000200000002000000015ED129EC00000569000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/src/unsubscribejob.h/*
    Copyright (c) 2009 Andras Mantia <amantia@kde.org>

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; see the file COPYING.LIB.  If not, write to the
    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
*/

#ifndef KIMAP_UNSUBSCRIBEJOB_H
#define KIMAP_UNSUBSCRIBEJOB_H

#include "kimap_export.h"

#include "job.h"

namespace KIMAP
{

class Session;
class UnsubscribeJobPrivate;

class KIMAP_EXPORT UnsubscribeJob : public Job
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(UnsubscribeJob)

friend class SessionPrivate;

public:
    explicit UnsubscribeJob(Session *session);
    ~UnsubscribeJob() override;

void setMailBox(const QString &mailBox);
    Q_REQUIRED_RESULT QString mailBox() const;

protected:
    void doStart() override;
};

}

#endif
07070100000091000041ED0000000200000002000000025ED129EC00000000000000000000000000000000000000000000002F00000000kimap-VERSIONgit.20200529T172740~a5402d2/tests07070100000092000081A40000000200000002000000015ED129EC00000155000000000000000000000000000000000000003E00000000kimap-VERSIONgit.20200529T172740~a5402d2/tests/CMakeLists.txtkde_enable_exceptions()

find_package(Qt5Test CONFIG REQUIRED) #for qsignalspy.h

add_executable(testimapidle testimapidle.cpp)
target_link_libraries(testimapidle KF5IMAP Qt5::Test KF5::KIOCore Qt5::Network)

add_executable(testimapserver testimapserver.cpp)
target_link_libraries(testimapserver KF5IMAP Qt5::Test KF5::KIOCore Qt5::Network)
07070100000093000081A40000000200000002000000015ED129EC000011E5000000000000000000000000000000000000004000000000kimap-VERSIONgit.20200529T172740~a5402d2/tests/testimapidle.cpp/**
  * This file is part of the KDE project
  * Copyright (C) 2009 Kevin Ottens <ervin@kde.org>
  *
  * 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; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */

#include <QDebug>
#include <QCoreApplication>
#include <QSignalSpy>

#include "session.h"
#include "capabilitiesjob.h"
#include "idlejob.h"
#include "loginjob.h"
#include "logoutjob.h"
#include "selectjob.h"
#include "closejob.h"
#include "sessionuiproxy.h"

using namespace KIMAP;

class UiProxy: public SessionUiProxy
{
public:
    bool ignoreSslError(const KSslErrorUiData &errorData) override
    {
        Q_UNUSED(errorData);
        return true;
    }
};

int main(int argc, char **argv)
{
    QCoreApplication::setApplicationName(QStringLiteral("TestImapIdle"));

if (argc < 4) {
        qCritical() << "Not enough parameters, expecting: <server> <user> <password>";
    }

QString server = QString::fromLocal8Bit(argv[1]);
    int port = 143;
    if (server.count(QLatin1Char(':')) == 1) {
        const QStringList lstSplit = server.split(QLatin1Char(':'));
        port = lstSplit.last().toInt();
        server = lstSplit.first();
    }
    QString user = QString::fromLocal8Bit(argv[2]);
    QString password = QString::fromLocal8Bit(argv[3]);

qDebug() << "Listening:" << server << port << user << password;
    qDebug();

QCoreApplication app(argc, argv);
    Session session(server, port);
    UiProxy *proxy = new UiProxy();
    session.setUiProxy(UiProxy::Ptr(proxy));

qDebug() << "Logging in...";
    LoginJob *login = new LoginJob(&session);
    login->setUserName(user);
    login->setPassword(password);
    login->exec();
    Q_ASSERT_X(login->error() == 0, "LoginJob", login->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Authenticated);
    qDebug();

qDebug() << "Asking for capabilities:";
    CapabilitiesJob *capabilities = new CapabilitiesJob(&session);
    capabilities->exec();
    Q_ASSERT_X(capabilities->error() == 0, "CapabilitiesJob", capabilities->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Authenticated);
    qDebug() << capabilities->capabilities();
    qDebug();

Q_ASSERT(capabilities->capabilities().contains(QLatin1String("IDLE")));

qDebug() << "Selecting INBOX:";
    SelectJob *select = new SelectJob(&session);
    select->setMailBox(QStringLiteral("INBOX"));
    select->exec();
    Q_ASSERT_X(select->error() == 0, "SelectJob", select->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Selected);
    qDebug() << "Flags:" << select->flags();
    qDebug() << "Permanent flags:" << select->permanentFlags();
    qDebug() << "Total Number of Messages:" << select->messageCount();
    qDebug() << "Number of recent Messages:" << select->recentCount();
    qDebug() << "First Unseen Message Index:" << select->firstUnseenIndex();
    qDebug() << "UID validity:" << select->uidValidity();
    qDebug() << "Next UID:" << select->nextUid();
    qDebug();

qDebug() << "Start idling...";
    IdleJob *idle = new IdleJob(&session);
    QObject::connect(idle, SIGNAL(mailBoxStats(KIMAP::IdleJob*,QString,int,int)),
                     idle, SLOT(stop()));
    idle->exec();
    qDebug() << "Idling done for" << idle->lastMailBox()
             << "message count:" << idle->lastMessageCount()
             << "recent count:" << idle->lastRecentCount();

qDebug() << "Closing INBOX:";
    CloseJob *close = new CloseJob(&session);
    close->exec();
    Q_ASSERT(session.state() == Session::Authenticated);
    qDebug();

qDebug() << "Logging out...";
    LogoutJob *logout = new LogoutJob(&session);
    logout->exec();
    Q_ASSERT_X(logout->error() == 0, "LogoutJob", logout->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Disconnected);

return 0;
}
07070100000094000081A40000000200000002000000015ED129EC000063A7000000000000000000000000000000000000004200000000kimap-VERSIONgit.20200529T172740~a5402d2/tests/testimapserver.cpp/**
  * This file is part of the KDE project
  * Copyright (C) 2009 Kevin Ottens <ervin@kde.org>
  * Copyright (C) 2009 Andras Mantia <amantia@kde.org>
  *
  * 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; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */

#include <QDebug>
#include <QTcpSocket>
#include <QCoreApplication>
#include <QSignalSpy>

#include "acl.h"
#include "session.h"
#include "appendjob.h"
#include "capabilitiesjob.h"
#include "fetchjob.h"
#include "listjob.h"
#include "loginjob.h"
#include "logoutjob.h"
#include "selectjob.h"
#include "closejob.h"
#include "expungejob.h"
#include "createjob.h"
#include "deletejob.h"
#include "namespacejob.h"
#include "subscribejob.h"
#include "unsubscribejob.h"
#include "renamejob.h"
#include "storejob.h"
#include "sessionuiproxy.h"
#include "setacljob.h"
#include "getacljob.h"
#include "deleteacljob.h"
#include "myrightsjob.h"
#include "listrightsjob.h"
#include "setmetadatajob.h"
#include "getmetadatajob.h"

using namespace KIMAP;

using PartsReceivedSignal = void(FetchJob::*)(const QString &, const QMap<qint64,qint64> &,
                                              const QMap<qint64, MessageParts> &);

using HeadersReceivedSignal = void(FetchJob::*)(const QString &,
                                                const QMap<qint64, qint64> &,
                                                const QMap<qint64, qint64> &,
                                                const QMap<qint64, MessageFlags> &,
                                                const QMap<qint64, MessagePtr> &);

class UiProxy: public SessionUiProxy
{
public:
    bool ignoreSslError(const KSslErrorUiData &errorData) override
    {
        Q_UNUSED(errorData);
        return true;
    }
};

void dumpContentHelper(KMime::Content *part, const QString &partId = QString())
{
    if (partId.isEmpty()) {
        qDebug() << "** Message root **";
    } else {
        qDebug() << "** Part" << partId << "**";
    }

qDebug() << part->head();

KMime::Content::List children = part->contents();
    for (int i = 0; i < children.size(); i++) {
        QString newId = partId;
        if (!newId.isEmpty()) {
            newId += QLatin1String(".");
        }
        newId += QString::number(i + 1);
        dumpContentHelper(children[i], newId);
    }
}

void listFolders(Session *session, bool includeUnsubscribed = false, const QString &nameFilter = QLatin1String(""))
{
    ListJob *list = new ListJob(session);
    list->setIncludeUnsubscribed(includeUnsubscribed);
    list->exec();
    Q_ASSERT_X(list->error() == 0, "ListJob", list->errorString().toLocal8Bit().constData());
    int count = list->mailBoxes().size();
    for (int i = 0; i < count; ++i) {
        MailBoxDescriptor descriptor = list->mailBoxes()[i];
        if (descriptor.name.endsWith(nameFilter)) {
            qDebug() << descriptor.separator << descriptor.name;
        }
    }

}

void testMetaData(Session *session)
{
    qDebug() << "TESTING: METADATA commands";
    CreateJob *create = new CreateJob(session);
    create->setMailBox(QStringLiteral("INBOX/TestFolder"));
    create->exec();

SetMetaDataJob *setmetadata = new SetMetaDataJob(session);
    setmetadata->setMailBox(QStringLiteral("INBOX/TestFolder"));
    setmetadata->setServerCapability(SetMetaDataJob::Annotatemore);
    setmetadata->setEntry("/comment");
    setmetadata->addMetaData("value.priv", "My new comment");
    setmetadata->exec();

setmetadata = new SetMetaDataJob(session);
    setmetadata->setMailBox(QStringLiteral("INBOX/TestFolder"));
    setmetadata->setServerCapability(SetMetaDataJob::Annotatemore);
    setmetadata->setEntry("/check");
    setmetadata->addMetaData("value.priv", "true");
    setmetadata->exec();

GetMetaDataJob *getmetadata = new GetMetaDataJob(session);
    getmetadata->setMailBox(QStringLiteral("INBOX/TestFolder"));
    getmetadata->setServerCapability(SetMetaDataJob::Annotatemore);
    getmetadata->addEntry("/*", "value.priv");
    getmetadata->exec();
    Q_ASSERT_X(getmetadata->metaData(QLatin1String("INBOX/TestFolder"), "/check", "value.priv") == "true", "",  "/check metadata should be true");
    Q_ASSERT_X(getmetadata->metaData(QLatin1String("INBOX/TestFolder"), "/comment", "value.priv") == "My new comment", "",  "/check metadata should be My new comment");

//cleanup
    DeleteJob *deletejob = new DeleteJob(session);
    deletejob->setMailBox(QLatin1String("INBOX/TestFolder"));
    deletejob->exec();
}

void testAcl(Session *session, const QString &user)
{
    qDebug() << "TESTING: ACL commands";
    CreateJob *create = new CreateJob(session);
    create->setMailBox(QStringLiteral("INBOX/TestFolder"));
    create->exec();

ListRightsJob *listRights = new ListRightsJob(session);
    listRights->setMailBox(QStringLiteral("INBOX/TestFolder"));
    listRights->setIdentifier(user.toLatin1());
    listRights->exec();
    qDebug() << "Default rights on INBOX/TestFolder: " << Acl::rightsToString(listRights->defaultRights());
    const QList<Acl::Rights> possible = listRights->possibleRights();
    QStringList strList;
    for (Acl::Rights r : qAsConst(possible)) {
        strList << QString::fromLatin1(Acl::rightsToString(r));
    }
    qDebug() << "Possible rights on INBOX/TestFolder: " << strList;

MyRightsJob *myRights = new MyRightsJob(session);
    myRights->setMailBox(QStringLiteral("INBOX/TestFolder"));
    myRights->exec();

Acl::Rights mine = myRights->rights();
    qDebug() << "My rights on INBOX/TestFolder: " << Acl::rightsToString(mine);
    qDebug() << "Reading INBOX/TestFolder is possible: " << myRights->hasRightEnabled(Acl::Read);
    Q_ASSERT_X(myRights->hasRightEnabled(Acl::Read), "Reading INBOX is NOT possible", "");

GetAclJob *getAcl = new GetAclJob(session);
    getAcl->setMailBox(QStringLiteral("INBOX/TestFolder"));
    getAcl->exec();
    qDebug() << "Anyone rights on INBOX/TestFolder: " << getAcl->rights("anyone");
    Acl::Rights users = getAcl->rights(user.toLatin1());
    qDebug() << user << " rights on INBOX/TestFolder: " << Acl::rightsToString(users);
    Q_ASSERT_X(mine == users, "GETACL returns different rights for the same user", "");

qDebug() << "Removing Delete right ";
    mine = Acl::Delete;
    SetAclJob *setAcl = new SetAclJob(session);
    setAcl->setMailBox(QStringLiteral("INBOX/TestFolder"));
    setAcl->setIdentifier(user.toLatin1());
    setAcl->setRights(AclJobBase::Remove, mine);
    setAcl->exec();

getAcl = new GetAclJob(session);
    getAcl->setMailBox(QStringLiteral("INBOX/TestFolder"));
    getAcl->exec();
    users = getAcl->rights(user.toLatin1());
    qDebug() << user << " rights on INBOX/TestFolder: " << Acl::rightsToString(users);

qDebug() << "Adding back Delete right ";
    mine = Acl::Delete;
    setAcl = new SetAclJob(session);
    setAcl->setMailBox(QStringLiteral("INBOX/TestFolder"));
    setAcl->setIdentifier(user.toLatin1());
    setAcl->setRights(AclJobBase::Add, mine);
    setAcl->exec();

//cleanup
    DeleteJob *deletejob = new DeleteJob(session);
    deletejob->setMailBox(QStringLiteral("INBOX/TestFolder"));
    deletejob->exec();
}

void testAppendAndStore(Session *session)
{
    qDebug() << "TESTING: APPEND and STORE";
    //setup
    CreateJob *create = new CreateJob(session);
    create->setMailBox(QStringLiteral("INBOX/TestFolder"));
    create->exec();

QByteArray testMailContent =
        "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)\r\n"
        "From: Fred Foobar <foobar@Blurdybloop.COM>\r\n"
        "Subject: afternoon meeting\r\n"
        "To: mooch@owatagu.siam.edu\r\n"
        "Message-Id: <B27397-0100000@Blurdybloop.COM>\r\n"
        "MIME-Version: 1.0\r\n"
        "Content-Type: TEXT/PLAIN; CHARSET=US-ASCII\r\n"
        "\r\n"
        "Hello Joe, do you think we can meet at 3:30 tomorrow?\r\n";

qDebug() << "Append a message in INBOX/TestFolder...";
    AppendJob *append = new AppendJob(session);
    append->setMailBox(QStringLiteral("INBOX/TestFolder"));
    append->setContent(testMailContent);
    append->exec();
    Q_ASSERT_X(append->error() == 0, "AppendJob", append->errorString().toLocal8Bit().constData());

qDebug() << "Read the message back and compare...";
    SelectJob *select = new SelectJob(session);
    select->setMailBox(QStringLiteral("INBOX/TestFolder"));
    select->exec();

FetchJob *fetch = new FetchJob(session);
    FetchJob::FetchScope scope;
    fetch->setSequenceSet(ImapSet(1));
    scope.parts.clear();
    scope.mode = FetchJob::FetchScope::Content;
    fetch->setScope(scope);
    MessagePtr message;
    QObject::connect(fetch, static_cast<HeadersReceivedSignal>(&FetchJob::headersReceived),
                     fetch, [&](const QString &, const QMap<qint64, qint64> &,
                                const QMap<qint64, qint64> &, const QMap<qint64, MessageFlags> &,
                                const QMap<qint64, MessagePtr> &msgs) {
                        message = msgs[1];
                    });
    fetch->exec();
    Q_ASSERT_X(fetch->error() == 0, "FetchJob", fetch->errorString().toLocal8Bit().constData());
    testMailContent.replace("\r\n", "\n");
    Q_ASSERT_X(testMailContent == message->head() + "\n" + message->body(),
               "Message differs from reference", QByteArray(message->head() + "\n" + message->body()).constData());

fetch = new FetchJob(session);
    fetch->setSequenceSet(ImapSet(1));
    scope.parts.clear();
    scope.mode = FetchJob::FetchScope::Flags;
    fetch->setScope(scope);
    MessageFlags expectedFlags;
    QObject::connect(fetch, static_cast<HeadersReceivedSignal>(&FetchJob::headersReceived),
                     fetch, [&](const QString &, const QMap<qint64, qint64> &,
                                const QMap<qint64, qint64> &, const QMap<qint64, MessageFlags> &flags,
                                const QMap<qint64, MessagePtr> &) {
                        expectedFlags = flags[1];
                    });
    fetch->exec();
    qDebug() << "Read the message flags:" << expectedFlags;

qDebug() << "Add the \\Deleted flag...";
    expectedFlags << "\\Deleted";
    std::sort(expectedFlags.begin(), expectedFlags.end());
    StoreJob *store = new StoreJob(session);
    store->setSequenceSet(ImapSet(1));
    store->setMode(StoreJob::AppendFlags);
    store->setFlags(QList<QByteArray>() << "\\Deleted");
    store->exec();
    Q_ASSERT_X(store->error() == 0, "StoreJob", store->errorString().toLocal8Bit().constData());

QList<QByteArray> resultingFlags = store->resultingFlags()[1];
    std::sort(resultingFlags.begin(), resultingFlags.end());
    if (expectedFlags != resultingFlags) {
        qDebug() << resultingFlags;
    }
    Q_ASSERT(expectedFlags == resultingFlags);

select = new SelectJob(session);
    select->setMailBox(QStringLiteral("INBOX"));
    select->exec();

//cleanup
    DeleteJob *deletejob = new DeleteJob(session);
    deletejob->setMailBox(QStringLiteral("INBOX/TestFolder"));
    deletejob->exec();
    deletejob = new DeleteJob(session);
    deletejob->setMailBox(QStringLiteral("INBOX/RenamedTestFolder"));
    deletejob->exec();
}

void testRename(Session *session)
{
    qDebug() << "TESTING: RENAME";
    //setup
    CreateJob *create = new CreateJob(session);
    create->setMailBox(QStringLiteral("INBOX/TestFolder"));
    create->exec();

qDebug() << "Listing mailboxes with name TestFolder:";
    listFolders(session, true, QStringLiteral("TestFolder"));

//actual tests
    qDebug() << "Renaming to RenamedTestFolder";
    RenameJob *rename = new RenameJob(session);
    rename->setSourceMailBox(QStringLiteral("INBOX/TestFolder"));
    rename->setDestinationMailBox(QStringLiteral("INBOX/RenamedTestFolder"));
    rename->exec();

qDebug() << "Listing mailboxes with name TestFolder:";
    listFolders(session, true, QStringLiteral("TestFolder"));
    qDebug() << "Listing mailboxes with name RenamedTestFolder:";
    listFolders(session, true, QStringLiteral("RenamedTestFolder"));

void testSubscribe(Session *session)
{
    qDebug() << "TESTING: SUBSCRIBE/UNSUBSCRIBE";
    //setup
    CreateJob *create = new CreateJob(session);
    create->setMailBox(QStringLiteral("INBOX/TestFolder"));
    create->exec();

qDebug() << "Listing  subscribed mailboxes with name TestFolder:";
    listFolders(session, false, QStringLiteral("TestFolder"));

//actual tests
    qDebug() << "Subscribing to INBOX/TestFolder";
    SubscribeJob *subscribe = new SubscribeJob(session);
    subscribe->setMailBox(QStringLiteral("INBOX/TestFolder"));
    subscribe->exec();

qDebug() << "Listing  subscribed mailboxes with name TestFolder:";
    listFolders(session, false, QStringLiteral("TestFolder"));

qDebug() << "Unsubscribing from INBOX/TestFolder";
    UnsubscribeJob *unsubscribe = new UnsubscribeJob(session);
    unsubscribe->setMailBox(QStringLiteral("INBOX/TestFolder"));
    unsubscribe->exec();

qDebug() << "Listing  subscribed mailboxes with name TestFolder:";
    listFolders(session, false, QStringLiteral("TestFolder"));

//cleanup
    DeleteJob *deletejob = new DeleteJob(session);
    deletejob->setMailBox(QStringLiteral("INBOX/TestFolder"));
    deletejob->exec();
}

void testDelete(Session *session)
{
    qDebug() << "TESTING: DELETE";
    qDebug() << "Creating INBOX/TestFolder:";
    CreateJob *create = new CreateJob(session);
    create->setMailBox(QStringLiteral("INBOX/TestFolder"));
    create->exec();

qDebug() << "Listing  with name TestFolder  before DELETE:";
    listFolders(session, true, QStringLiteral("TestFolder"));

qDebug() << "Deleting INBOX/TestFolder";
    DeleteJob *deletejob = new DeleteJob(session);
    deletejob->setMailBox(QStringLiteral("INBOX/TestFolder"));
    deletejob->exec();

qDebug() << "Listing with name TestFolder after DELETE:";
    listFolders(session, true, QStringLiteral("TestFolder"));
}

int main(int argc, char **argv)
{
    QCoreApplication::setApplicationName(QStringLiteral("TestImapServer"));

if (argc < 4) {
        qCritical() << "Not enough parameters, expecting: <server> <user> <password>";
    }

qDebug() << "Querying:" << server << port << user << password;
    qDebug();

QCoreApplication app(argc, argv);
    Session session(server, port);
    UiProxy::Ptr proxy(new UiProxy());
    session.setUiProxy(proxy);

qDebug() << "Logging in...";
    LoginJob *login = new LoginJob(&session);
    //login->setEncryptionMode( LoginJob::TlsV1 );
    //login->setAuthenticationMode( LoginJob::Plain );
    login->setUserName(user);
    login->setPassword(password);
    login->exec();
    qDebug();

/*if (login->encryptionMode() == LoginJob::Unencrypted)
    {
      qDebug() << "Encrypted login not possible, try to log in without encryption";
      login = new LoginJob( &session );
      login->setUserName( user );
      login->setPassword( password );
      login->exec();
      Q_ASSERT_X( login->error() == 0, "LoginJob", login->errorString().toLocal8Bit().constData() );
      Q_ASSERT( session.state() == Session::Authenticated );
      qDebug();

}*/

qDebug() << "Server greeting:" << session.serverGreeting();

qDebug() << "Asking for namespaces:";
    NamespaceJob *namespaces = new NamespaceJob(&session);
    namespaces->exec();
    Q_ASSERT_X(namespaces->error() == 0, "CapabilitiesJob", namespaces->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Authenticated);

qDebug() << "Contains empty namespace:" << namespaces->containsEmptyNamespace();

qDebug() << "Personal:";
    foreach (MailBoxDescriptor ns, namespaces->personalNamespaces()) {
        qDebug() << ns.separator << ns.name;
    }

qDebug() << "User:    ";
    foreach (MailBoxDescriptor ns, namespaces->userNamespaces()) {
        qDebug() << ns.separator << ns.name;
    }

qDebug() << "Shared:  ";
    foreach (MailBoxDescriptor ns, namespaces->sharedNamespaces()) {
        qDebug() << ns.separator << ns.name;
    }
    qDebug();

qDebug() << "Listing mailboxes:";
    listFolders(&session);
    Q_ASSERT(session.state() == Session::Authenticated);

qDebug() << "Fetching first 3 messages headers:";
    FetchJob *fetch = new FetchJob(&session);
    FetchJob::FetchScope scope;
    fetch->setSequenceSet(ImapSet(1, 3));
    scope.parts.clear();
    scope.mode = FetchJob::FetchScope::Headers;
    fetch->setScope(scope);
    QMap<qint64, qint64> sizes;
    QMap<qint64, MessagePtr> messages;

QObject::connect(fetch, static_cast<HeadersReceivedSignal>(&FetchJob::headersReceived),
                     fetch, [&](const QString &, const QMap<qint64,qint64> &,
                                const QMap<qint64, qint64> &sizes_,
                                const QMap<qint64, MessageFlags> &,
                                const QMap<qint64, MessagePtr> &msgs_) {
                         sizes = sizes_;
                         messages = msgs_;
                     });
    fetch->exec();
    Q_ASSERT_X(fetch->error() == 0, "FetchJob", fetch->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Selected);
    foreach (qint64 id, messages.keys()) {
        qDebug() << "* Message" << id << "(" << sizes[id] << "bytes )";
        qDebug() << "  From      :" << messages[id]->from()->asUnicodeString();
        qDebug() << "  To        :" << messages[id]->to()->asUnicodeString();
        qDebug() << "  Date      :" << messages[id]->date()->asUnicodeString();
        qDebug() << "  Subject   :" << messages[id]->subject()->asUnicodeString();
        qDebug() << "  Message-ID:" << messages[id]->messageID()->asUnicodeString();
    }
    qDebug();

qDebug() << "Fetching first 3 messages flags:";
    fetch = new FetchJob(&session);
    fetch->setSequenceSet(ImapSet(1, 3));
    scope.parts.clear();
    scope.mode = FetchJob::FetchScope::Flags;
    fetch->setScope(scope);
    QMap<qint64, MessageFlags> flags;
    QObject::connect(fetch, static_cast<HeadersReceivedSignal>(&FetchJob::headersReceived),
                     fetch, [&](const QString &, const QMap<qint64,qint64> &,
                                const QMap<qint64, qint64> &,
                                const QMap<qint64, MessageFlags> &flags_,
                                const QMap<qint64, MessagePtr> &) {
                         flags = flags_;
                     });
    fetch->exec();
    Q_ASSERT_X(fetch->error() == 0, "FetchJob", fetch->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Selected);
    foreach (qint64 id, flags.keys()) {
        qDebug() << "* Message" << id << "flags:" << flags[id];
    }
    qDebug();

qDebug() << "Fetching first message structure:";
    fetch = new FetchJob(&session);
    fetch->setSequenceSet(ImapSet(1));
    scope.parts.clear();
    scope.mode = FetchJob::FetchScope::Structure;
    fetch->setScope(scope);
    QObject::connect(fetch, static_cast<HeadersReceivedSignal>(&FetchJob::headersReceived),
                     fetch, [&](const QString &, const QMap<qint64,qint64> &,
                                const QMap<qint64, qint64> &,
                                const QMap<qint64, MessageFlags> &,
                                const QMap<qint64, MessagePtr> &msgs_) {
                         messages = msgs_;
                     });
    fetch->exec();
    Q_ASSERT_X(fetch->error() == 0, "FetchJob", fetch->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Selected);
    MessagePtr message = messages[1];
    dumpContentHelper(message.data());
    qDebug();

qDebug() << "Fetching first message second part headers:";
    fetch = new FetchJob(&session);
    fetch->setSequenceSet(ImapSet(1));
    scope.parts.clear();
    scope.parts << "2";
    scope.mode = FetchJob::FetchScope::Headers;
    fetch->setScope(scope);
    QMap<qint64, MessageParts> allParts;
    QObject::connect(fetch, static_cast<PartsReceivedSignal>(&FetchJob::partsReceived),
                     fetch, [&](const QString &, const QMap<qint64, qint64> &,
                                const QMap<qint64, MessageParts> &parts_) {
                         allParts = parts_;
                     });
    fetch->exec();
    Q_ASSERT_X(fetch->error() == 0, "FetchJob", fetch->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Selected);
    foreach (qint64 id, allParts.keys()) {
        qDebug() << "* Message" << id << "parts headers";
        MessageParts parts = allParts[id];
        foreach (const QByteArray &partId, parts.keys()) {
            qDebug() << "  ** Part" << partId;
            qDebug() << "     Name       :" << parts[partId]->contentType()->name();
            qDebug() << "     Mimetype   :" << parts[partId]->contentType()->mimeType();
            qDebug() << "     Description:" << parts[partId]->contentDescription()->asUnicodeString().simplified();
        }
    }
    qDebug();

qDebug() << "Fetching first message second part content:";
    fetch = new FetchJob(&session);
    fetch->setSequenceSet(ImapSet(1));
    scope.parts.clear();
    scope.parts << "2";
    scope.mode = FetchJob::FetchScope::Content;
    fetch->setScope(scope);
    QObject::connect(fetch, static_cast<PartsReceivedSignal>(&FetchJob::partsReceived),
                     fetch, [&](const QString &, const QMap<qint64, qint64> &,
                                const QMap<qint64, MessageParts> &parts_) {
                         allParts = parts_;
                     });
    fetch->exec();
    Q_ASSERT_X(fetch->error() == 0, "FetchJob", fetch->errorString().toLocal8Bit().constData());
    Q_ASSERT(session.state() == Session::Selected);
    foreach (int id, allParts.keys()) {
        MessageParts parts = allParts[id];
        foreach (const QByteArray &partId, parts.keys()) {
            qDebug() << "* Message" << id << "part" << partId << "content:";
            qDebug() << parts[partId]->body();
        }
    }
    qDebug();

testDelete(&session);

testSubscribe(&session);

testRename(&session);

testAppendAndStore(&session);

testAcl(&session, user);

testMetaData(&session);

qDebug() << "Expunge INBOX:";
    ExpungeJob *expunge = new ExpungeJob(&session);
    expunge->exec();

qDebug() << "Closing INBOX:";
    CloseJob *close = new CloseJob(&session);
    close->exec();
    Q_ASSERT(session.state() == Session::Authenticated);
    qDebug();

return 0;
}
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!1390 blocks

Places

File _service:obs_scm:kimap-VERSIONgit.20200529T172740~a5402d2.obscpio of Package kimap (Revision 211bc10074386a65651730ca284f5020)

Places